fs/xfs/libxfs/xfs_inode_buf.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2000-2006 Silicon Graphics, Inc.
   4  * All Rights Reserved.
   5  */
   6 #include "xfs.h"
   7 #include "xfs_fs.h"
   8 #include "xfs_shared.h"
   9 #include "xfs_format.h"
  10 #include "xfs_log_format.h"
  11 #include "xfs_trans_resv.h"
  12 #include "xfs_mount.h"
  13 #include "xfs_ag.h"
  14 #include "xfs_inode.h"
  15 #include "xfs_errortag.h"
  16 #include "xfs_error.h"
  17 #include "xfs_icache.h"
  18 #include "xfs_trans.h"
  19 #include "xfs_ialloc.h"
  20 #include "xfs_dir2.h"
  21
  22 #include <linux/iversion.h>
  23
  24 /*
  25  * If we are doing readahead on an inode buffer, we might be in log recovery
  26  * reading an inode allocation buffer that hasn't yet been replayed, and hence
  27  * has not had the inode cores stamped into it. Hence for readahead, the buffer
  28  * may be potentially invalid.
  29  *
  30  * If the readahead buffer is invalid, we need to mark it with an error and
  31  * clear the DONE status of the buffer so that a followup read will re-read it
  32  * from disk. We don't report the error otherwise to avoid warnings during log
  33  * recovery and we don't get unnecessary panics on debug kernels. We use EIO here
  34  * because all we want to do is say readahead failed; there is no-one to report
  35  * the error to, so this will distinguish it from a non-ra verifier failure.
  36  * Changes to this readahead error behaviour also need to be reflected in
  37  * xfs_dquot_buf_readahead_verify().
  38  */
  39 static void
  40 xfs_inode_buf_verify(
  41         struct xfs_buf  *bp,
  42         bool            readahead)
  43 {
  44         struct xfs_mount *mp = bp->b_mount;
  45         int             i;
  46         int             ni;
  47
  48         /*
  49          * Validate the magic number and version of every inode in the buffer
  50          */
  51         ni = XFS_BB_TO_FSB(mp, bp->b_length) * mp->m_sb.sb_inopblock;
  52         for (i = 0; i < ni; i++) {
  53                 struct xfs_dinode       *dip;
  54                 xfs_agino_t             unlinked_ino;
  55                 int                     di_ok;
  56
  57                 dip = xfs_buf_offset(bp, (i << mp->m_sb.sb_inodelog));
  58                 unlinked_ino = be32_to_cpu(dip->di_next_unlinked);
  59                 di_ok = xfs_verify_magic16(bp, dip->di_magic) &&
  60                         xfs_dinode_good_version(mp, dip->di_version) &&
  61                         xfs_verify_agino_or_null(bp->b_pag, unlinked_ino);
  62                 if (unlikely(XFS_TEST_ERROR(!di_ok, mp,
  63                                                 XFS_ERRTAG_ITOBP_INOTOBP))) {
  64                         if (readahead) {
  65                                 bp->b_flags &= ~XBF_DONE;
  66                                 xfs_buf_ioerror(bp, -EIO);
  67                                 return;
  68                         }
  69
  70 #ifdef DEBUG
  71                         xfs_alert(mp,
  72                                 "bad inode magic/vsn daddr %lld #%d (magic=%x)",
  73                                 (unsigned long long)xfs_buf_daddr(bp), i,
  74                                 be16_to_cpu(dip->di_magic));
  75 #endif
  76                         xfs_buf_verifier_error(bp, -EFSCORRUPTED,
  77                                         __func__, dip, sizeof(*dip),
  78                                         NULL);
  79                         return;
  80                 }
  81         }
  82 }
  83
  84
  85 static void
  86 xfs_inode_buf_read_verify(
  87         struct xfs_buf  *bp)
  88 {
  89         xfs_inode_buf_verify(bp, false);
  90 }
  91
  92 static void
  93 xfs_inode_buf_readahead_verify(
  94         struct xfs_buf  *bp)
  95 {
  96         xfs_inode_buf_verify(bp, true);
  97 }
  98
  99 static void
 100 xfs_inode_buf_write_verify(
 101         struct xfs_buf  *bp)
 102 {
 103         xfs_inode_buf_verify(bp, false);
 104 }
 105
 106 const struct xfs_buf_ops xfs_inode_buf_ops = {
 107         .name = "xfs_inode",
 108         .magic16 = { cpu_to_be16(XFS_DINODE_MAGIC),
 109                      cpu_to_be16(XFS_DINODE_MAGIC) },
 110         .verify_read = xfs_inode_buf_read_verify,
 111         .verify_write = xfs_inode_buf_write_verify,
 112 };
 113
 114 const struct xfs_buf_ops xfs_inode_buf_ra_ops = {
 115         .name = "xfs_inode_ra",
 116         .magic16 = { cpu_to_be16(XFS_DINODE_MAGIC),
 117                      cpu_to_be16(XFS_DINODE_MAGIC) },
 118         .verify_read = xfs_inode_buf_readahead_verify,
 119         .verify_write = xfs_inode_buf_write_verify,
 120 };
 121
 122
 123 /*
 124  * This routine is called to map an inode to the buffer containing the on-disk
 125  * version of the inode.  It returns a pointer to the buffer containing the
 126  * on-disk inode in the bpp parameter.
 127  */
 128 int
 129 xfs_imap_to_bp(
 130         struct xfs_mount        *mp,
 131         struct xfs_trans        *tp,
 132         struct xfs_imap         *imap,
 133         struct xfs_buf          **bpp)
 134 {
 135         return xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, imap->im_blkno,
 136                                    imap->im_len, XBF_UNMAPPED, bpp,
 137                                    &xfs_inode_buf_ops);
 138 }
 139
 140 static inline struct timespec64 xfs_inode_decode_bigtime(uint64_t ts)
 141 {
 142         struct timespec64       tv;
 143         uint32_t                n;
 144
 145         tv.tv_sec = xfs_bigtime_to_unix(div_u64_rem(ts, NSEC_PER_SEC, &n));
 146         tv.tv_nsec = n;
 147
 148         return tv;
 149 }
 150
 151 /* Convert an ondisk timestamp to an incore timestamp. */
 152 struct timespec64
 153 xfs_inode_from_disk_ts(
 154         struct xfs_dinode               *dip,
 155         const xfs_timestamp_t           ts)
 156 {
 157         struct timespec64               tv;
 158         struct xfs_legacy_timestamp     *lts;
 159
 160         if (xfs_dinode_has_bigtime(dip))
 161                 return xfs_inode_decode_bigtime(be64_to_cpu(ts));
 162
 163         lts = (struct xfs_legacy_timestamp *)&ts;
 164         tv.tv_sec = (int)be32_to_cpu(lts->t_sec);
 165         tv.tv_nsec = (int)be32_to_cpu(lts->t_nsec);
 166
 167         return tv;
 168 }
 169
 170 int
 171 xfs_inode_from_disk(
 172         struct xfs_inode        *ip,
 173         struct xfs_dinode       *from)
 174 {
 175         struct inode            *inode = VFS_I(ip);
 176         int                     error;
 177         xfs_failaddr_t          fa;
 178
 179         ASSERT(ip->i_cowfp == NULL);
 180
 181         fa = xfs_dinode_verify(ip->i_mount, ip->i_ino, from);
 182         if (fa) {
 183                 xfs_inode_verifier_error(ip, -EFSCORRUPTED, "dinode", from,
 184                                 sizeof(*from), fa);
 185                 return -EFSCORRUPTED;
 186         }
 187
 188         /*
 189          * First get the permanent information that is needed to allocate an
 190          * inode. If the inode is unused, mode is zero and we shouldn't mess
 191          * with the uninitialized part of it.
 192          */
 193         if (!xfs_has_v3inodes(ip->i_mount))
 194                 ip->i_flushiter = be16_to_cpu(from->di_flushiter);
 195         inode->i_generation = be32_to_cpu(from->di_gen);
 196         inode->i_mode = be16_to_cpu(from->di_mode);
 197         if (!inode->i_mode)
 198                 return 0;
 199
 200         /*
 201          * Convert v1 inodes immediately to v2 inode format as this is the
 202          * minimum inode version format we support in the rest of the code.
 203          * They will also be unconditionally written back to disk as v2 inodes.
 204          */
 205         if (unlikely(from->di_version == 1)) {
 206                 set_nlink(inode, be16_to_cpu(from->di_onlink));
 207                 ip->i_projid = 0;
 208         } else {
 209                 set_nlink(inode, be32_to_cpu(from->di_nlink));
 210                 ip->i_projid = (prid_t)be16_to_cpu(from->di_projid_hi) << 16 |
 211                                         be16_to_cpu(from->di_projid_lo);
 212         }
 213
 214         i_uid_write(inode, be32_to_cpu(from->di_uid));
 215         i_gid_write(inode, be32_to_cpu(from->di_gid));
 216
 217         /*
 218          * Time is signed, so need to convert to signed 32 bit before
 219          * storing in inode timestamp which may be 64 bit. Otherwise
 220          * a time before epoch is converted to a time long after epoch
 221          * on 64 bit systems.
 222          */
 223         inode->i_atime = xfs_inode_from_disk_ts(from, from->di_atime);
 224         inode->i_mtime = xfs_inode_from_disk_ts(from, from->di_mtime);
 225         inode_set_ctime_to_ts(inode,
 226                               xfs_inode_from_disk_ts(from, from->di_ctime));
 227
 228         ip->i_disk_size = be64_to_cpu(from->di_size);
 229         ip->i_nblocks = be64_to_cpu(from->di_nblocks);
 230         ip->i_extsize = be32_to_cpu(from->di_extsize);
 231         ip->i_forkoff = from->di_forkoff;
 232         ip->i_diflags = be16_to_cpu(from->di_flags);
 233         ip->i_next_unlinked = be32_to_cpu(from->di_next_unlinked);
 234
 235         if (from->di_dmevmask || from->di_dmstate)
 236                 xfs_iflags_set(ip, XFS_IPRESERVE_DM_FIELDS);
 237
 238         if (xfs_has_v3inodes(ip->i_mount)) {
 239                 inode_set_iversion_queried(inode,
 240                                            be64_to_cpu(from->di_changecount));
 241                 ip->i_crtime = xfs_inode_from_disk_ts(from, from->di_crtime);
 242                 ip->i_diflags2 = be64_to_cpu(from->di_flags2);
 243                 ip->i_cowextsize = be32_to_cpu(from->di_cowextsize);
 244         }
 245
 246         error = xfs_iformat_data_fork(ip, from);
 247         if (error)
 248                 return error;
 249         if (from->di_forkoff) {
 250                 error = xfs_iformat_attr_fork(ip, from);
 251                 if (error)
 252                         goto out_destroy_data_fork;
 253         }
 254         if (xfs_is_reflink_inode(ip))
 255                 xfs_ifork_init_cow(ip);
 256         return 0;
 257
 258 out_destroy_data_fork:
 259         xfs_idestroy_fork(&ip->i_df);
 260         return error;
 261 }
 262
 263 /* Convert an incore timestamp to an ondisk timestamp. */
 264 static inline xfs_timestamp_t
 265 xfs_inode_to_disk_ts(
 266         struct xfs_inode                *ip,
 267         const struct timespec64         tv)
 268 {
 269         struct xfs_legacy_timestamp     *lts;
 270         xfs_timestamp_t                 ts;
 271
 272         if (xfs_inode_has_bigtime(ip))
 273                 return cpu_to_be64(xfs_inode_encode_bigtime(tv));
 274
 275         lts = (struct xfs_legacy_timestamp *)&ts;
 276         lts->t_sec = cpu_to_be32(tv.tv_sec);
 277         lts->t_nsec = cpu_to_be32(tv.tv_nsec);
 278
 279         return ts;
 280 }
 281
 282 static inline void
 283 xfs_inode_to_disk_iext_counters(
 284         struct xfs_inode        *ip,
 285         struct xfs_dinode       *to)
 286 {
 287         if (xfs_inode_has_large_extent_counts(ip)) {
 288                 to->di_big_nextents = cpu_to_be64(xfs_ifork_nextents(&ip->i_df));
 289                 to->di_big_anextents = cpu_to_be32(xfs_ifork_nextents(&ip->i_af));
 290                 /*
 291                  * We might be upgrading the inode to use larger extent counters
 292                  * than was previously used. Hence zero the unused field.
 293                  */
 294                 to->di_nrext64_pad = cpu_to_be16(0);
 295         } else {
 296                 to->di_nextents = cpu_to_be32(xfs_ifork_nextents(&ip->i_df));
 297                 to->di_anextents = cpu_to_be16(xfs_ifork_nextents(&ip->i_af));
 298         }
 299 }
 300
 301 void
 302 xfs_inode_to_disk(
 303         struct xfs_inode        *ip,
 304         struct xfs_dinode       *to,
 305         xfs_lsn_t               lsn)
 306 {
 307         struct inode            *inode = VFS_I(ip);
 308
 309         to->di_magic = cpu_to_be16(XFS_DINODE_MAGIC);
 310         to->di_onlink = 0;
 311
 312         to->di_format = xfs_ifork_format(&ip->i_df);
 313         to->di_uid = cpu_to_be32(i_uid_read(inode));
 314         to->di_gid = cpu_to_be32(i_gid_read(inode));
 315         to->di_projid_lo = cpu_to_be16(ip->i_projid & 0xffff);
 316         to->di_projid_hi = cpu_to_be16(ip->i_projid >> 16);
 317
 318         to->di_atime = xfs_inode_to_disk_ts(ip, inode->i_atime);
 319         to->di_mtime = xfs_inode_to_disk_ts(ip, inode->i_mtime);
 320         to->di_ctime = xfs_inode_to_disk_ts(ip, inode_get_ctime(inode));
 321         to->di_nlink = cpu_to_be32(inode->i_nlink);
 322         to->di_gen = cpu_to_be32(inode->i_generation);
 323         to->di_mode = cpu_to_be16(inode->i_mode);
 324
 325         to->di_size = cpu_to_be64(ip->i_disk_size);
 326         to->di_nblocks = cpu_to_be64(ip->i_nblocks);
 327         to->di_extsize = cpu_to_be32(ip->i_extsize);
 328         to->di_forkoff = ip->i_forkoff;
 329         to->di_aformat = xfs_ifork_format(&ip->i_af);
 330         to->di_flags = cpu_to_be16(ip->i_diflags);
 331
 332         if (xfs_has_v3inodes(ip->i_mount)) {
 333                 to->di_version = 3;
 334                 to->di_changecount = cpu_to_be64(inode_peek_iversion(inode));
 335                 to->di_crtime = xfs_inode_to_disk_ts(ip, ip->i_crtime);
 336                 to->di_flags2 = cpu_to_be64(ip->i_diflags2);
 337                 to->di_cowextsize = cpu_to_be32(ip->i_cowextsize);
 338                 to->di_ino = cpu_to_be64(ip->i_ino);
 339                 to->di_lsn = cpu_to_be64(lsn);
 340                 memset(to->di_pad2, 0, sizeof(to->di_pad2));
 341                 uuid_copy(&to->di_uuid, &ip->i_mount->m_sb.sb_meta_uuid);
 342                 to->di_v3_pad = 0;
 343         } else {
 344                 to->di_version = 2;
 345                 to->di_flushiter = cpu_to_be16(ip->i_flushiter);
 346                 memset(to->di_v2_pad, 0, sizeof(to->di_v2_pad));
 347         }
 348
 349         xfs_inode_to_disk_iext_counters(ip, to);
 350 }
 351
 352 static xfs_failaddr_t
 353 xfs_dinode_verify_fork(
 354         struct xfs_dinode       *dip,
 355         struct xfs_mount        *mp,
 356         int                     whichfork)
 357 {
 358         xfs_extnum_t            di_nextents;
 359         xfs_extnum_t            max_extents;
 360         mode_t                  mode = be16_to_cpu(dip->di_mode);
 361         uint32_t                fork_size = XFS_DFORK_SIZE(dip, mp, whichfork);
 362         uint32_t                fork_format = XFS_DFORK_FORMAT(dip, whichfork);
 363
 364         di_nextents = xfs_dfork_nextents(dip, whichfork);
 365
 366         /*
 367          * For fork types that can contain local data, check that the fork
 368          * format matches the size of local data contained within the fork.
 369          *
 370          * For all types, check that when the size says the should be in extent
 371          * or btree format, the inode isn't claiming it is in local format.
 372          */
 373         if (whichfork == XFS_DATA_FORK) {
 374                 if (S_ISDIR(mode) || S_ISLNK(mode)) {
 375                         if (be64_to_cpu(dip->di_size) <= fork_size &&
 376                             fork_format != XFS_DINODE_FMT_LOCAL)
 377                                 return __this_address;
 378                 }
 379
 380                 if (be64_to_cpu(dip->di_size) > fork_size &&
 381                     fork_format == XFS_DINODE_FMT_LOCAL)
 382                         return __this_address;
 383         }
 384
 385         switch (fork_format) {
 386         case XFS_DINODE_FMT_LOCAL:
 387                 /*
 388                  * No local regular files yet.
 389                  */
 390                 if (S_ISREG(mode) && whichfork == XFS_DATA_FORK)
 391                         return __this_address;
 392                 if (di_nextents)
 393                         return __this_address;
 394                 break;
 395         case XFS_DINODE_FMT_EXTENTS:
 396                 if (di_nextents > XFS_DFORK_MAXEXT(dip, mp, whichfork))
 397                         return __this_address;
 398                 break;
 399         case XFS_DINODE_FMT_BTREE:
 400                 max_extents = xfs_iext_max_nextents(
 401                                         xfs_dinode_has_large_extent_counts(dip),
 402                                         whichfork);
 403                 if (di_nextents > max_extents)
 404                         return __this_address;
 405                 break;
 406         default:
 407                 return __this_address;
 408         }
 409         return NULL;
 410 }
 411
 412 static xfs_failaddr_t
 413 xfs_dinode_verify_forkoff(
 414         struct xfs_dinode       *dip,
 415         struct xfs_mount        *mp)
 416 {
 417         if (!dip->di_forkoff)
 418                 return NULL;
 419
 420         switch (dip->di_format)  {
 421         case XFS_DINODE_FMT_DEV:
 422                 if (dip->di_forkoff != (roundup(sizeof(xfs_dev_t), 8) >> 3))
 423                         return __this_address;
 424                 break;
 425         case XFS_DINODE_FMT_LOCAL:      /* fall through ... */
 426         case XFS_DINODE_FMT_EXTENTS:    /* fall through ... */
 427         case XFS_DINODE_FMT_BTREE:
 428                 if (dip->di_forkoff >= (XFS_LITINO(mp) >> 3))
 429                         return __this_address;
 430                 break;
 431         default:
 432                 return __this_address;
 433         }
 434         return NULL;
 435 }
 436
 437 static xfs_failaddr_t
 438 xfs_dinode_verify_nrext64(
 439         struct xfs_mount        *mp,
 440         struct xfs_dinode       *dip)
 441 {
 442         if (xfs_dinode_has_large_extent_counts(dip)) {
 443                 if (!xfs_has_large_extent_counts(mp))
 444                         return __this_address;
 445                 if (dip->di_nrext64_pad != 0)
 446                         return __this_address;
 447         } else if (dip->di_version >= 3) {
 448                 if (dip->di_v3_pad != 0)
 449                         return __this_address;
 450         }
 451
 452         return NULL;
 453 }
 454
 455 xfs_failaddr_t
 456 xfs_dinode_verify(
 457         struct xfs_mount        *mp,
 458         xfs_ino_t               ino,
 459         struct xfs_dinode       *dip)
 460 {
 461         xfs_failaddr_t          fa;
 462         uint16_t                mode;
 463         uint16_t                flags;
 464         uint64_t                flags2;
 465         uint64_t                di_size;
 466         xfs_extnum_t            nextents;
 467         xfs_extnum_t            naextents;
 468         xfs_filblks_t           nblocks;
 469
 470         if (dip->di_magic != cpu_to_be16(XFS_DINODE_MAGIC))
 471                 return __this_address;
 472
 473         /* Verify v3 integrity information first */
 474         if (dip->di_version >= 3) {
 475                 if (!xfs_has_v3inodes(mp))
 476                         return __this_address;
 477                 if (!xfs_verify_cksum((char *)dip, mp->m_sb.sb_inodesize,
 478                                       XFS_DINODE_CRC_OFF))
 479                         return __this_address;
 480                 if (be64_to_cpu(dip->di_ino) != ino)
 481                         return __this_address;
 482                 if (!uuid_equal(&dip->di_uuid, &mp->m_sb.sb_meta_uuid))
 483                         return __this_address;
 484         }
 485
 486         /* don't allow invalid i_size */
 487         di_size = be64_to_cpu(dip->di_size);
 488         if (di_size & (1ULL << 63))
 489                 return __this_address;
 490
 491         mode = be16_to_cpu(dip->di_mode);
 492         if (mode && xfs_mode_to_ftype(mode) == XFS_DIR3_FT_UNKNOWN)
 493                 return __this_address;
 494
 495         /* No zero-length symlinks/dirs. */
 496         if ((S_ISLNK(mode) || S_ISDIR(mode)) && di_size == 0)
 497                 return __this_address;
 498
 499         fa = xfs_dinode_verify_nrext64(mp, dip);
 500         if (fa)
 501                 return fa;
 502
 503         nextents = xfs_dfork_data_extents(dip);
 504         naextents = xfs_dfork_attr_extents(dip);
 505         nblocks = be64_to_cpu(dip->di_nblocks);
 506
 507         /* Fork checks carried over from xfs_iformat_fork */
 508         if (mode && nextents + naextents > nblocks)
 509                 return __this_address;
 510
 511         if (nextents + naextents == 0 && nblocks != 0)
 512                 return __this_address;
 513
 514         if (S_ISDIR(mode) && nextents > mp->m_dir_geo->max_extents)
 515                 return __this_address;
 516
 517         if (mode && XFS_DFORK_BOFF(dip) > mp->m_sb.sb_inodesize)
 518                 return __this_address;
 519
 520         flags = be16_to_cpu(dip->di_flags);
 521
 522         if (mode && (flags & XFS_DIFLAG_REALTIME) && !mp->m_rtdev_targp)
 523                 return __this_address;
 524
 525         /* check for illegal values of forkoff */
 526         fa = xfs_dinode_verify_forkoff(dip, mp);
 527         if (fa)
 528                 return fa;
 529
 530         /* Do we have appropriate data fork formats for the mode? */
 531         switch (mode & S_IFMT) {
 532         case S_IFIFO:
 533         case S_IFCHR:
 534         case S_IFBLK:
 535         case S_IFSOCK:
 536                 if (dip->di_format != XFS_DINODE_FMT_DEV)
 537                         return __this_address;
 538                 break;
 539         case S_IFREG:
 540         case S_IFLNK:
 541         case S_IFDIR:
 542                 fa = xfs_dinode_verify_fork(dip, mp, XFS_DATA_FORK);
 543                 if (fa)
 544                         return fa;
 545                 break;
 546         case 0:
 547                 /* Uninitialized inode ok. */
 548                 break;
 549         default:
 550                 return __this_address;
 551         }
 552
 553         if (dip->di_forkoff) {
 554                 fa = xfs_dinode_verify_fork(dip, mp, XFS_ATTR_FORK);
 555                 if (fa)
 556                         return fa;
 557         } else {
 558                 /*
 559                  * If there is no fork offset, this may be a freshly-made inode
 560                  * in a new disk cluster, in which case di_aformat is zeroed.
 561                  * Otherwise, such an inode must be in EXTENTS format; this goes
 562                  * for freed inodes as well.
 563                  */
 564                 switch (dip->di_aformat) {
 565                 case 0:
 566                 case XFS_DINODE_FMT_EXTENTS:
 567                         break;
 568                 default:
 569                         return __this_address;
 570                 }
 571                 if (naextents)
 572                         return __this_address;
 573         }
 574
 575         /* extent size hint validation */
 576         fa = xfs_inode_validate_extsize(mp, be32_to_cpu(dip->di_extsize),
 577                         mode, flags);
 578         if (fa)
 579                 return fa;
 580
 581         /* only version 3 or greater inodes are extensively verified here */
 582         if (dip->di_version < 3)
 583                 return NULL;
 584
 585         flags2 = be64_to_cpu(dip->di_flags2);
 586
 587         /* don't allow reflink/cowextsize if we don't have reflink */
 588         if ((flags2 & (XFS_DIFLAG2_REFLINK | XFS_DIFLAG2_COWEXTSIZE)) &&
 589              !xfs_has_reflink(mp))
 590                 return __this_address;
 591
 592         /* only regular files get reflink */
 593         if ((flags2 & XFS_DIFLAG2_REFLINK) && (mode & S_IFMT) != S_IFREG)
 594                 return __this_address;
 595
 596         /* don't let reflink and realtime mix */
 597         if ((flags2 & XFS_DIFLAG2_REFLINK) && (flags & XFS_DIFLAG_REALTIME))
 598                 return __this_address;
 599
 600         /* COW extent size hint validation */
 601         fa = xfs_inode_validate_cowextsize(mp, be32_to_cpu(dip->di_cowextsize),
 602                         mode, flags, flags2);
 603         if (fa)
 604                 return fa;
 605
 606         /* bigtime iflag can only happen on bigtime filesystems */
 607         if (xfs_dinode_has_bigtime(dip) &&
 608             !xfs_has_bigtime(mp))
 609                 return __this_address;
 610
 611         return NULL;
 612 }
 613
 614 void
 615 xfs_dinode_calc_crc(
 616         struct xfs_mount        *mp,
 617         struct xfs_dinode       *dip)
 618 {
 619         uint32_t                crc;
 620
 621         if (dip->di_version < 3)
 622                 return;
 623
 624         ASSERT(xfs_has_crc(mp));
 625         crc = xfs_start_cksum_update((char *)dip, mp->m_sb.sb_inodesize,
 626                               XFS_DINODE_CRC_OFF);
 627         dip->di_crc = xfs_end_cksum(crc);
 628 }
 629
 630 /*
 631  * Validate di_extsize hint.
 632  *
 633  * 1. Extent size hint is only valid for directories and regular files.
 634  * 2. FS_XFLAG_EXTSIZE is only valid for regular files.
 635  * 3. FS_XFLAG_EXTSZINHERIT is only valid for directories.
 636  * 4. Hint cannot be larger than MAXTEXTLEN.
 637  * 5. Can be changed on directories at any time.
 638  * 6. Hint value of 0 turns off hints, clears inode flags.
 639  * 7. Extent size must be a multiple of the appropriate block size.
 640  *    For realtime files, this is the rt extent size.
 641  * 8. For non-realtime files, the extent size hint must be limited
 642  *    to half the AG size to avoid alignment extending the extent beyond the
 643  *    limits of the AG.
 644  */
 645 xfs_failaddr_t
 646 xfs_inode_validate_extsize(
 647         struct xfs_mount                *mp,
 648         uint32_t                        extsize,
 649         uint16_t                        mode,
 650         uint16_t                        flags)
 651 {
 652         bool                            rt_flag;
 653         bool                            hint_flag;
 654         bool                            inherit_flag;
 655         uint32_t                        extsize_bytes;
 656         uint32_t                        blocksize_bytes;
 657
 658         rt_flag = (flags & XFS_DIFLAG_REALTIME);
 659         hint_flag = (flags & XFS_DIFLAG_EXTSIZE);
 660         inherit_flag = (flags & XFS_DIFLAG_EXTSZINHERIT);
 661         extsize_bytes = XFS_FSB_TO_B(mp, extsize);
 662
 663         /*
 664          * This comment describes a historic gap in this verifier function.
 665          *
 666          * For a directory with both RTINHERIT and EXTSZINHERIT flags set, this
 667          * function has never checked that the extent size hint is an integer
 668          * multiple of the realtime extent size.  Since we allow users to set
 669          * this combination  on non-rt filesystems /and/ to change the rt
 670          * extent size when adding a rt device to a filesystem, the net effect
 671          * is that users can configure a filesystem anticipating one rt
 672          * geometry and change their minds later.  Directories do not use the
 673          * extent size hint, so this is harmless for them.
 674          *
 675          * If a directory with a misaligned extent size hint is allowed to
 676          * propagate that hint into a new regular realtime file, the result
 677          * is that the inode cluster buffer verifier will trigger a corruption
 678          * shutdown the next time it is run, because the verifier has always
 679          * enforced the alignment rule for regular files.
 680          *
 681          * Because we allow administrators to set a new rt extent size when
 682          * adding a rt section, we cannot add a check to this verifier because
 683          * that will result a new source of directory corruption errors when
 684          * reading an existing filesystem.  Instead, we rely on callers to
 685          * decide when alignment checks are appropriate, and fix things up as
 686          * needed.
 687          */
 688
 689         if (rt_flag)
 690                 blocksize_bytes = XFS_FSB_TO_B(mp, mp->m_sb.sb_rextsize);
 691         else
 692                 blocksize_bytes = mp->m_sb.sb_blocksize;
 693
 694         if ((hint_flag || inherit_flag) && !(S_ISDIR(mode) || S_ISREG(mode)))
 695                 return __this_address;
 696
 697         if (hint_flag && !S_ISREG(mode))
 698                 return __this_address;
 699
 700         if (inherit_flag && !S_ISDIR(mode))
 701                 return __this_address;
 702
 703         if ((hint_flag || inherit_flag) && extsize == 0)
 704                 return __this_address;
 705
 706         /* free inodes get flags set to zero but extsize remains */
 707         if (mode && !(hint_flag || inherit_flag) && extsize != 0)
 708                 return __this_address;
 709
 710         if (extsize_bytes % blocksize_bytes)
 711                 return __this_address;
 712
 713         if (extsize > XFS_MAX_BMBT_EXTLEN)
 714                 return __this_address;
 715
 716         if (!rt_flag && extsize > mp->m_sb.sb_agblocks / 2)
 717                 return __this_address;
 718
 719         return NULL;
 720 }
 721
 722 /*
 723  * Validate di_cowextsize hint.
 724  *
 725  * 1. CoW extent size hint can only be set if reflink is enabled on the fs.
 726  *    The inode does not have to have any shared blocks, but it must be a v3.
 727  * 2. FS_XFLAG_COWEXTSIZE is only valid for directories and regular files;
 728  *    for a directory, the hint is propagated to new files.
 729  * 3. Can be changed on files & directories at any time.
 730  * 4. Hint value of 0 turns off hints, clears inode flags.
 731  * 5. Extent size must be a multiple of the appropriate block size.
 732  * 6. The extent size hint must be limited to half the AG size to avoid
 733  *    alignment extending the extent beyond the limits of the AG.
 734  */
 735 xfs_failaddr_t
 736 xfs_inode_validate_cowextsize(
 737         struct xfs_mount                *mp,
 738         uint32_t                        cowextsize,
 739         uint16_t                        mode,
 740         uint16_t                        flags,
 741         uint64_t                        flags2)
 742 {
 743         bool                            rt_flag;
 744         bool                            hint_flag;
 745         uint32_t                        cowextsize_bytes;
 746
 747         rt_flag = (flags & XFS_DIFLAG_REALTIME);
 748         hint_flag = (flags2 & XFS_DIFLAG2_COWEXTSIZE);
 749         cowextsize_bytes = XFS_FSB_TO_B(mp, cowextsize);
 750
 751         if (hint_flag && !xfs_has_reflink(mp))
 752                 return __this_address;
 753
 754         if (hint_flag && !(S_ISDIR(mode) || S_ISREG(mode)))
 755                 return __this_address;
 756
 757         if (hint_flag && cowextsize == 0)
 758                 return __this_address;
 759
 760         /* free inodes get flags set to zero but cowextsize remains */
 761         if (mode && !hint_flag && cowextsize != 0)
 762                 return __this_address;
 763
 764         if (hint_flag && rt_flag)
 765                 return __this_address;
 766
 767         if (cowextsize_bytes % mp->m_sb.sb_blocksize)
 768                 return __this_address;
 769
 770         if (cowextsize > XFS_MAX_BMBT_EXTLEN)
 771                 return __this_address;
 772
 773         if (cowextsize > mp->m_sb.sb_agblocks / 2)
 774                 return __this_address;
 775
 776         return NULL;
 777 }