fs/xfs/libxfs/xfs_dir2

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
__xfs_dir3_data_check
xfs_dir3_data_check
xfs_dir3_data_verify
xfs_dir3_data_reada_verify
xfs_dir3_data_read_verify
xfs_dir3_data_write_verify
xfs_dir3_data_read
xfs_dir3_data_readahead
xfs_dir2_data_freefind_verify
xfs_dir2_data_freefind
xfs_dir2_data_freeinsert
xfs_dir2_data_freeremove
xfs_dir2_data_freescan_int
xfs_dir2_data_freescan
xfs_dir3_data_init
xfs_dir2_data_log_entry
xfs_dir2_data_log_header
xfs_dir2_data_log_unused
xfs_dir2_data_make_free
xfs_dir2_data_check_free
xfs_dir2_data_check_new_free
xfs_dir2_data_use_free
xfs_dir3_data_endp
   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
   4  * Copyright (c) 2013 Red Hat, Inc.
   5  * All Rights Reserved.
   6  */
   7 #include "xfs.h"
   8 #include "xfs_fs.h"
   9 #include "xfs_shared.h"
  10 #include "xfs_format.h"
  11 #include "xfs_log_format.h"
  12 #include "xfs_trans_resv.h"
  13 #include "xfs_mount.h"
  14 #include "xfs_inode.h"
  15 #include "xfs_dir2.h"
  16 #include "xfs_error.h"
  17 #include "xfs_trans.h"
  18 #include "xfs_buf_item.h"
  19 #include "xfs_log.h"
  20 
  21 static xfs_failaddr_t xfs_dir2_data_freefind_verify(
  22                 struct xfs_dir2_data_hdr *hdr, struct xfs_dir2_data_free *bf,
  23                 struct xfs_dir2_data_unused *dup,
  24                 struct xfs_dir2_data_free **bf_ent);
  25 
  26 /*
  27  * Check the consistency of the data block.
  28  * The input can also be a block-format directory.
  29  * Return NULL if the buffer is good, otherwise the address of the error.
  30  */
  31 xfs_failaddr_t
  32 __xfs_dir3_data_check(
  33         struct xfs_inode        *dp,            /* incore inode pointer */
  34         struct xfs_buf          *bp)            /* data block's buffer */
  35 {
  36         xfs_dir2_dataptr_t      addr;           /* addr for leaf lookup */
  37         xfs_dir2_data_free_t    *bf;            /* bestfree table */
  38         xfs_dir2_block_tail_t   *btp=NULL;      /* block tail */
  39         int                     count;          /* count of entries found */
  40         xfs_dir2_data_hdr_t     *hdr;           /* data block header */
  41         xfs_dir2_data_entry_t   *dep;           /* data entry */
  42         xfs_dir2_data_free_t    *dfp;           /* bestfree entry */
  43         xfs_dir2_data_unused_t  *dup;           /* unused entry */
  44         char                    *endp;          /* end of useful data */
  45         int                     freeseen;       /* mask of bestfrees seen */
  46         xfs_dahash_t            hash;           /* hash of current name */
  47         int                     i;              /* leaf index */
  48         int                     lastfree;       /* last entry was unused */
  49         xfs_dir2_leaf_entry_t   *lep=NULL;      /* block leaf entries */
  50         struct xfs_mount        *mp = bp->b_mount;
  51         char                    *p;             /* current data position */
  52         int                     stale;          /* count of stale leaves */
  53         struct xfs_name         name;
  54         const struct xfs_dir_ops *ops;
  55         struct xfs_da_geometry  *geo;
  56 
  57         geo = mp->m_dir_geo;
  58 
  59         /*
  60          * We can be passed a null dp here from a verifier, so we need to go the
  61          * hard way to get them.
  62          */
  63         ops = xfs_dir_get_ops(mp, dp);
  64 
  65         /*
  66          * If this isn't a directory, or we don't get handed the dir ops,
  67          * something is seriously wrong.  Bail out.
  68          */
  69         if ((dp && !S_ISDIR(VFS_I(dp)->i_mode)) ||
  70             ops != xfs_dir_get_ops(mp, NULL))
  71                 return __this_address;
  72 
  73         hdr = bp->b_addr;
  74         p = (char *)ops->data_entry_p(hdr);
  75 
  76         switch (hdr->magic) {
  77         case cpu_to_be32(XFS_DIR3_BLOCK_MAGIC):
  78         case cpu_to_be32(XFS_DIR2_BLOCK_MAGIC):
  79                 btp = xfs_dir2_block_tail_p(geo, hdr);
  80                 lep = xfs_dir2_block_leaf_p(btp);
  81 
  82                 /*
  83                  * The number of leaf entries is limited by the size of the
  84                  * block and the amount of space used by the data entries.
  85                  * We don't know how much space is used by the data entries yet,
  86                  * so just ensure that the count falls somewhere inside the
  87                  * block right now.
  88                  */
  89                 if (be32_to_cpu(btp->count) >=
  90                     ((char *)btp - p) / sizeof(struct xfs_dir2_leaf_entry))
  91                         return __this_address;
  92                 break;
  93         case cpu_to_be32(XFS_DIR3_DATA_MAGIC):
  94         case cpu_to_be32(XFS_DIR2_DATA_MAGIC):
  95                 break;
  96         default:
  97                 return __this_address;
  98         }
  99         endp = xfs_dir3_data_endp(geo, hdr);
 100         if (!endp)
 101                 return __this_address;
 102 
 103         /*
 104          * Account for zero bestfree entries.
 105          */
 106         bf = ops->data_bestfree_p(hdr);
 107         count = lastfree = freeseen = 0;
 108         if (!bf[0].length) {
 109                 if (bf[0].offset)
 110                         return __this_address;
 111                 freeseen |= 1 << 0;
 112         }
 113         if (!bf[1].length) {
 114                 if (bf[1].offset)
 115                         return __this_address;
 116                 freeseen |= 1 << 1;
 117         }
 118         if (!bf[2].length) {
 119                 if (bf[2].offset)
 120                         return __this_address;
 121                 freeseen |= 1 << 2;
 122         }
 123 
 124         if (be16_to_cpu(bf[0].length) < be16_to_cpu(bf[1].length))
 125                 return __this_address;
 126         if (be16_to_cpu(bf[1].length) < be16_to_cpu(bf[2].length))
 127                 return __this_address;
 128         /*
 129          * Loop over the data/unused entries.
 130          */
 131         while (p < endp) {
 132                 dup = (xfs_dir2_data_unused_t *)p;
 133                 /*
 134                  * If it's unused, look for the space in the bestfree table.
 135                  * If we find it, account for that, else make sure it
 136                  * doesn't need to be there.
 137                  */
 138                 if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
 139                         xfs_failaddr_t  fa;
 140 
 141                         if (lastfree != 0)
 142                                 return __this_address;
 143                         if (endp < p + be16_to_cpu(dup->length))
 144                                 return __this_address;
 145                         if (be16_to_cpu(*xfs_dir2_data_unused_tag_p(dup)) !=
 146                             (char *)dup - (char *)hdr)
 147                                 return __this_address;
 148                         fa = xfs_dir2_data_freefind_verify(hdr, bf, dup, &dfp);
 149                         if (fa)
 150                                 return fa;
 151                         if (dfp) {
 152                                 i = (int)(dfp - bf);
 153                                 if ((freeseen & (1 << i)) != 0)
 154                                         return __this_address;
 155                                 freeseen |= 1 << i;
 156                         } else {
 157                                 if (be16_to_cpu(dup->length) >
 158                                     be16_to_cpu(bf[2].length))
 159                                         return __this_address;
 160                         }
 161                         p += be16_to_cpu(dup->length);
 162                         lastfree = 1;
 163                         continue;
 164                 }
 165                 /*
 166                  * It's a real entry.  Validate the fields.
 167                  * If this is a block directory then make sure it's
 168                  * in the leaf section of the block.
 169                  * The linear search is crude but this is DEBUG code.
 170                  */
 171                 dep = (xfs_dir2_data_entry_t *)p;
 172                 if (dep->namelen == 0)
 173                         return __this_address;
 174                 if (xfs_dir_ino_validate(mp, be64_to_cpu(dep->inumber)))
 175                         return __this_address;
 176                 if (endp < p + ops->data_entsize(dep->namelen))
 177                         return __this_address;
 178                 if (be16_to_cpu(*ops->data_entry_tag_p(dep)) !=
 179                     (char *)dep - (char *)hdr)
 180                         return __this_address;
 181                 if (ops->data_get_ftype(dep) >= XFS_DIR3_FT_MAX)
 182                         return __this_address;
 183                 count++;
 184                 lastfree = 0;
 185                 if (hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
 186                     hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC)) {
 187                         addr = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
 188                                                 (xfs_dir2_data_aoff_t)
 189                                                 ((char *)dep - (char *)hdr));
 190                         name.name = dep->name;
 191                         name.len = dep->namelen;
 192                         hash = mp->m_dirnameops->hashname(&name);
 193                         for (i = 0; i < be32_to_cpu(btp->count); i++) {
 194                                 if (be32_to_cpu(lep[i].address) == addr &&
 195                                     be32_to_cpu(lep[i].hashval) == hash)
 196                                         break;
 197                         }
 198                         if (i >= be32_to_cpu(btp->count))
 199                                 return __this_address;
 200                 }
 201                 p += ops->data_entsize(dep->namelen);
 202         }
 203         /*
 204          * Need to have seen all the entries and all the bestfree slots.
 205          */
 206         if (freeseen != 7)
 207                 return __this_address;
 208         if (hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
 209             hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC)) {
 210                 for (i = stale = 0; i < be32_to_cpu(btp->count); i++) {
 211                         if (lep[i].address ==
 212                             cpu_to_be32(XFS_DIR2_NULL_DATAPTR))
 213                                 stale++;
 214                         if (i > 0 && be32_to_cpu(lep[i].hashval) <
 215                                      be32_to_cpu(lep[i - 1].hashval))
 216                                 return __this_address;
 217                 }
 218                 if (count != be32_to_cpu(btp->count) - be32_to_cpu(btp->stale))
 219                         return __this_address;
 220                 if (stale != be32_to_cpu(btp->stale))
 221                         return __this_address;
 222         }
 223         return NULL;
 224 }
 225 
 226 #ifdef DEBUG
 227 void
 228 xfs_dir3_data_check(
 229         struct xfs_inode        *dp,
 230         struct xfs_buf          *bp)
 231 {
 232         xfs_failaddr_t          fa;
 233 
 234         fa = __xfs_dir3_data_check(dp, bp);
 235         if (!fa)
 236                 return;
 237         xfs_corruption_error(__func__, XFS_ERRLEVEL_LOW, dp->i_mount,
 238                         bp->b_addr, BBTOB(bp->b_length), __FILE__, __LINE__,
 239                         fa);
 240         ASSERT(0);
 241 }
 242 #endif
 243 
 244 static xfs_failaddr_t
 245 xfs_dir3_data_verify(
 246         struct xfs_buf          *bp)
 247 {
 248         struct xfs_mount        *mp = bp->b_mount;
 249         struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
 250 
 251         if (!xfs_verify_magic(bp, hdr3->magic))
 252                 return __this_address;
 253 
 254         if (xfs_sb_version_hascrc(&mp->m_sb)) {
 255                 if (!uuid_equal(&hdr3->uuid, &mp->m_sb.sb_meta_uuid))
 256                         return __this_address;
 257                 if (be64_to_cpu(hdr3->blkno) != bp->b_bn)
 258                         return __this_address;
 259                 if (!xfs_log_check_lsn(mp, be64_to_cpu(hdr3->lsn)))
 260                         return __this_address;
 261         }
 262         return __xfs_dir3_data_check(NULL, bp);
 263 }
 264 
 265 /*
 266  * Readahead of the first block of the directory when it is opened is completely
 267  * oblivious to the format of the directory. Hence we can either get a block
 268  * format buffer or a data format buffer on readahead.
 269  */
 270 static void
 271 xfs_dir3_data_reada_verify(
 272         struct xfs_buf          *bp)
 273 {
 274         struct xfs_dir2_data_hdr *hdr = bp->b_addr;
 275 
 276         switch (hdr->magic) {
 277         case cpu_to_be32(XFS_DIR2_BLOCK_MAGIC):
 278         case cpu_to_be32(XFS_DIR3_BLOCK_MAGIC):
 279                 bp->b_ops = &xfs_dir3_block_buf_ops;
 280                 bp->b_ops->verify_read(bp);
 281                 return;
 282         case cpu_to_be32(XFS_DIR2_DATA_MAGIC):
 283         case cpu_to_be32(XFS_DIR3_DATA_MAGIC):
 284                 bp->b_ops = &xfs_dir3_data_buf_ops;
 285                 bp->b_ops->verify_read(bp);
 286                 return;
 287         default:
 288                 xfs_verifier_error(bp, -EFSCORRUPTED, __this_address);
 289                 break;
 290         }
 291 }
 292 
 293 static void
 294 xfs_dir3_data_read_verify(
 295         struct xfs_buf  *bp)
 296 {
 297         struct xfs_mount        *mp = bp->b_mount;
 298         xfs_failaddr_t          fa;
 299 
 300         if (xfs_sb_version_hascrc(&mp->m_sb) &&
 301             !xfs_buf_verify_cksum(bp, XFS_DIR3_DATA_CRC_OFF))
 302                 xfs_verifier_error(bp, -EFSBADCRC, __this_address);
 303         else {
 304                 fa = xfs_dir3_data_verify(bp);
 305                 if (fa)
 306                         xfs_verifier_error(bp, -EFSCORRUPTED, fa);
 307         }
 308 }
 309 
 310 static void
 311 xfs_dir3_data_write_verify(
 312         struct xfs_buf  *bp)
 313 {
 314         struct xfs_mount        *mp = bp->b_mount;
 315         struct xfs_buf_log_item *bip = bp->b_log_item;
 316         struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
 317         xfs_failaddr_t          fa;
 318 
 319         fa = xfs_dir3_data_verify(bp);
 320         if (fa) {
 321                 xfs_verifier_error(bp, -EFSCORRUPTED, fa);
 322                 return;
 323         }
 324 
 325         if (!xfs_sb_version_hascrc(&mp->m_sb))
 326                 return;
 327 
 328         if (bip)
 329                 hdr3->lsn = cpu_to_be64(bip->bli_item.li_lsn);
 330 
 331         xfs_buf_update_cksum(bp, XFS_DIR3_DATA_CRC_OFF);
 332 }
 333 
 334 const struct xfs_buf_ops xfs_dir3_data_buf_ops = {
 335         .name = "xfs_dir3_data",
 336         .magic = { cpu_to_be32(XFS_DIR2_DATA_MAGIC),
 337                    cpu_to_be32(XFS_DIR3_DATA_MAGIC) },
 338         .verify_read = xfs_dir3_data_read_verify,
 339         .verify_write = xfs_dir3_data_write_verify,
 340         .verify_struct = xfs_dir3_data_verify,
 341 };
 342 
 343 static const struct xfs_buf_ops xfs_dir3_data_reada_buf_ops = {
 344         .name = "xfs_dir3_data_reada",
 345         .magic = { cpu_to_be32(XFS_DIR2_DATA_MAGIC),
 346                    cpu_to_be32(XFS_DIR3_DATA_MAGIC) },
 347         .verify_read = xfs_dir3_data_reada_verify,
 348         .verify_write = xfs_dir3_data_write_verify,
 349 };
 350 
 351 
 352 int
 353 xfs_dir3_data_read(
 354         struct xfs_trans        *tp,
 355         struct xfs_inode        *dp,
 356         xfs_dablk_t             bno,
 357         xfs_daddr_t             mapped_bno,
 358         struct xfs_buf          **bpp)
 359 {
 360         int                     err;
 361 
 362         err = xfs_da_read_buf(tp, dp, bno, mapped_bno, bpp,
 363                                 XFS_DATA_FORK, &xfs_dir3_data_buf_ops);
 364         if (!err && tp && *bpp)
 365                 xfs_trans_buf_set_type(tp, *bpp, XFS_BLFT_DIR_DATA_BUF);
 366         return err;
 367 }
 368 
 369 int
 370 xfs_dir3_data_readahead(
 371         struct xfs_inode        *dp,
 372         xfs_dablk_t             bno,
 373         xfs_daddr_t             mapped_bno)
 374 {
 375         return xfs_da_reada_buf(dp, bno, mapped_bno,
 376                                 XFS_DATA_FORK, &xfs_dir3_data_reada_buf_ops);
 377 }
 378 
 379 /*
 380  * Find the bestfree entry that exactly coincides with unused directory space
 381  * or a verifier error because the bestfree data are bad.
 382  */
 383 static xfs_failaddr_t
 384 xfs_dir2_data_freefind_verify(
 385         struct xfs_dir2_data_hdr        *hdr,
 386         struct xfs_dir2_data_free       *bf,
 387         struct xfs_dir2_data_unused     *dup,
 388         struct xfs_dir2_data_free       **bf_ent)
 389 {
 390         struct xfs_dir2_data_free       *dfp;
 391         xfs_dir2_data_aoff_t            off;
 392         bool                            matched = false;
 393         bool                            seenzero = false;
 394 
 395         *bf_ent = NULL;
 396         off = (xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr);
 397 
 398         /*
 399          * Validate some consistency in the bestfree table.
 400          * Check order, non-overlapping entries, and if we find the
 401          * one we're looking for it has to be exact.
 402          */
 403         for (dfp = &bf[0]; dfp < &bf[XFS_DIR2_DATA_FD_COUNT]; dfp++) {
 404                 if (!dfp->offset) {
 405                         if (dfp->length)
 406                                 return __this_address;
 407                         seenzero = true;
 408                         continue;
 409                 }
 410                 if (seenzero)
 411                         return __this_address;
 412                 if (be16_to_cpu(dfp->offset) == off) {
 413                         matched = true;
 414                         if (dfp->length != dup->length)
 415                                 return __this_address;
 416                 } else if (be16_to_cpu(dfp->offset) > off) {
 417                         if (off + be16_to_cpu(dup->length) >
 418                                         be16_to_cpu(dfp->offset))
 419                                 return __this_address;
 420                 } else {
 421                         if (be16_to_cpu(dfp->offset) +
 422                                         be16_to_cpu(dfp->length) > off)
 423                                 return __this_address;
 424                 }
 425                 if (!matched &&
 426                     be16_to_cpu(dfp->length) < be16_to_cpu(dup->length))
 427                         return __this_address;
 428                 if (dfp > &bf[0] &&
 429                     be16_to_cpu(dfp[-1].length) < be16_to_cpu(dfp[0].length))
 430                         return __this_address;
 431         }
 432 
 433         /* Looks ok so far; now try to match up with a bestfree entry. */
 434         *bf_ent = xfs_dir2_data_freefind(hdr, bf, dup);
 435         return NULL;
 436 }
 437 
 438 /*
 439  * Given a data block and an unused entry from that block,
 440  * return the bestfree entry if any that corresponds to it.
 441  */
 442 xfs_dir2_data_free_t *
 443 xfs_dir2_data_freefind(
 444         struct xfs_dir2_data_hdr *hdr,          /* data block header */
 445         struct xfs_dir2_data_free *bf,          /* bestfree table pointer */
 446         struct xfs_dir2_data_unused *dup)       /* unused space */
 447 {
 448         xfs_dir2_data_free_t    *dfp;           /* bestfree entry */
 449         xfs_dir2_data_aoff_t    off;            /* offset value needed */
 450 
 451         off = (xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr);
 452 
 453         /*
 454          * If this is smaller than the smallest bestfree entry,
 455          * it can't be there since they're sorted.
 456          */
 457         if (be16_to_cpu(dup->length) <
 458             be16_to_cpu(bf[XFS_DIR2_DATA_FD_COUNT - 1].length))
 459                 return NULL;
 460         /*
 461          * Look at the three bestfree entries for our guy.
 462          */
 463         for (dfp = &bf[0]; dfp < &bf[XFS_DIR2_DATA_FD_COUNT]; dfp++) {
 464                 if (!dfp->offset)
 465                         return NULL;
 466                 if (be16_to_cpu(dfp->offset) == off)
 467                         return dfp;
 468         }
 469         /*
 470          * Didn't find it.  This only happens if there are duplicate lengths.
 471          */
 472         return NULL;
 473 }
 474 
 475 /*
 476  * Insert an unused-space entry into the bestfree table.
 477  */
 478 xfs_dir2_data_free_t *                          /* entry inserted */
 479 xfs_dir2_data_freeinsert(
 480         struct xfs_dir2_data_hdr *hdr,          /* data block pointer */
 481         struct xfs_dir2_data_free *dfp,         /* bestfree table pointer */
 482         struct xfs_dir2_data_unused *dup,       /* unused space */
 483         int                     *loghead)       /* log the data header (out) */
 484 {
 485         xfs_dir2_data_free_t    new;            /* new bestfree entry */
 486 
 487         ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
 488                hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
 489                hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
 490                hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
 491 
 492         new.length = dup->length;
 493         new.offset = cpu_to_be16((char *)dup - (char *)hdr);
 494 
 495         /*
 496          * Insert at position 0, 1, or 2; or not at all.
 497          */
 498         if (be16_to_cpu(new.length) > be16_to_cpu(dfp[0].length)) {
 499                 dfp[2] = dfp[1];
 500                 dfp[1] = dfp[0];
 501                 dfp[0] = new;
 502                 *loghead = 1;
 503                 return &dfp[0];
 504         }
 505         if (be16_to_cpu(new.length) > be16_to_cpu(dfp[1].length)) {
 506                 dfp[2] = dfp[1];
 507                 dfp[1] = new;
 508                 *loghead = 1;
 509                 return &dfp[1];
 510         }
 511         if (be16_to_cpu(new.length) > be16_to_cpu(dfp[2].length)) {
 512                 dfp[2] = new;
 513                 *loghead = 1;
 514                 return &dfp[2];
 515         }
 516         return NULL;
 517 }
 518 
 519 /*
 520  * Remove a bestfree entry from the table.
 521  */
 522 STATIC void
 523 xfs_dir2_data_freeremove(
 524         struct xfs_dir2_data_hdr *hdr,          /* data block header */
 525         struct xfs_dir2_data_free *bf,          /* bestfree table pointer */
 526         struct xfs_dir2_data_free *dfp,         /* bestfree entry pointer */
 527         int                     *loghead)       /* out: log data header */
 528 {
 529 
 530         ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
 531                hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
 532                hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
 533                hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
 534 
 535         /*
 536          * It's the first entry, slide the next 2 up.
 537          */
 538         if (dfp == &bf[0]) {
 539                 bf[0] = bf[1];
 540                 bf[1] = bf[2];
 541         }
 542         /*
 543          * It's the second entry, slide the 3rd entry up.
 544          */
 545         else if (dfp == &bf[1])
 546                 bf[1] = bf[2];
 547         /*
 548          * Must be the last entry.
 549          */
 550         else
 551                 ASSERT(dfp == &bf[2]);
 552         /*
 553          * Clear the 3rd entry, must be zero now.
 554          */
 555         bf[2].length = 0;
 556         bf[2].offset = 0;
 557         *loghead = 1;
 558 }
 559 
 560 /*
 561  * Given a data block, reconstruct its bestfree map.
 562  */
 563 void
 564 xfs_dir2_data_freescan_int(
 565         struct xfs_da_geometry  *geo,
 566         const struct xfs_dir_ops *ops,
 567         struct xfs_dir2_data_hdr *hdr,
 568         int                     *loghead)
 569 {
 570         xfs_dir2_data_entry_t   *dep;           /* active data entry */
 571         xfs_dir2_data_unused_t  *dup;           /* unused data entry */
 572         struct xfs_dir2_data_free *bf;
 573         char                    *endp;          /* end of block's data */
 574         char                    *p;             /* current entry pointer */
 575 
 576         ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
 577                hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
 578                hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
 579                hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
 580 
 581         /*
 582          * Start by clearing the table.
 583          */
 584         bf = ops->data_bestfree_p(hdr);
 585         memset(bf, 0, sizeof(*bf) * XFS_DIR2_DATA_FD_COUNT);
 586         *loghead = 1;
 587         /*
 588          * Set up pointers.
 589          */
 590         p = (char *)ops->data_entry_p(hdr);
 591         endp = xfs_dir3_data_endp(geo, hdr);
 592         /*
 593          * Loop over the block's entries.
 594          */
 595         while (p < endp) {
 596                 dup = (xfs_dir2_data_unused_t *)p;
 597                 /*
 598                  * If it's a free entry, insert it.
 599                  */
 600                 if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
 601                         ASSERT((char *)dup - (char *)hdr ==
 602                                be16_to_cpu(*xfs_dir2_data_unused_tag_p(dup)));
 603                         xfs_dir2_data_freeinsert(hdr, bf, dup, loghead);
 604                         p += be16_to_cpu(dup->length);
 605                 }
 606                 /*
 607                  * For active entries, check their tags and skip them.
 608                  */
 609                 else {
 610                         dep = (xfs_dir2_data_entry_t *)p;
 611                         ASSERT((char *)dep - (char *)hdr ==
 612                                be16_to_cpu(*ops->data_entry_tag_p(dep)));
 613                         p += ops->data_entsize(dep->namelen);
 614                 }
 615         }
 616 }
 617 
 618 void
 619 xfs_dir2_data_freescan(
 620         struct xfs_inode        *dp,
 621         struct xfs_dir2_data_hdr *hdr,
 622         int                     *loghead)
 623 {
 624         return xfs_dir2_data_freescan_int(dp->i_mount->m_dir_geo, dp->d_ops,
 625                         hdr, loghead);
 626 }
 627 
 628 /*
 629  * Initialize a data block at the given block number in the directory.
 630  * Give back the buffer for the created block.
 631  */
 632 int                                             /* error */
 633 xfs_dir3_data_init(
 634         xfs_da_args_t           *args,          /* directory operation args */
 635         xfs_dir2_db_t           blkno,          /* logical dir block number */
 636         struct xfs_buf          **bpp)          /* output block buffer */
 637 {
 638         struct xfs_buf          *bp;            /* block buffer */
 639         xfs_dir2_data_hdr_t     *hdr;           /* data block header */
 640         xfs_inode_t             *dp;            /* incore directory inode */
 641         xfs_dir2_data_unused_t  *dup;           /* unused entry pointer */
 642         struct xfs_dir2_data_free *bf;
 643         int                     error;          /* error return value */
 644         int                     i;              /* bestfree index */
 645         xfs_mount_t             *mp;            /* filesystem mount point */
 646         xfs_trans_t             *tp;            /* transaction pointer */
 647         int                     t;              /* temp */
 648 
 649         dp = args->dp;
 650         mp = dp->i_mount;
 651         tp = args->trans;
 652         /*
 653          * Get the buffer set up for the block.
 654          */
 655         error = xfs_da_get_buf(tp, dp, xfs_dir2_db_to_da(args->geo, blkno),
 656                                -1, &bp, XFS_DATA_FORK);
 657         if (error)
 658                 return error;
 659         bp->b_ops = &xfs_dir3_data_buf_ops;
 660         xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DIR_DATA_BUF);
 661 
 662         /*
 663          * Initialize the header.
 664          */
 665         hdr = bp->b_addr;
 666         if (xfs_sb_version_hascrc(&mp->m_sb)) {
 667                 struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
 668 
 669                 memset(hdr3, 0, sizeof(*hdr3));
 670                 hdr3->magic = cpu_to_be32(XFS_DIR3_DATA_MAGIC);
 671                 hdr3->blkno = cpu_to_be64(bp->b_bn);
 672                 hdr3->owner = cpu_to_be64(dp->i_ino);
 673                 uuid_copy(&hdr3->uuid, &mp->m_sb.sb_meta_uuid);
 674 
 675         } else
 676                 hdr->magic = cpu_to_be32(XFS_DIR2_DATA_MAGIC);
 677 
 678         bf = dp->d_ops->data_bestfree_p(hdr);
 679         bf[0].offset = cpu_to_be16(dp->d_ops->data_entry_offset);
 680         for (i = 1; i < XFS_DIR2_DATA_FD_COUNT; i++) {
 681                 bf[i].length = 0;
 682                 bf[i].offset = 0;
 683         }
 684 
 685         /*
 686          * Set up an unused entry for the block's body.
 687          */
 688         dup = dp->d_ops->data_unused_p(hdr);
 689         dup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
 690 
 691         t = args->geo->blksize - (uint)dp->d_ops->data_entry_offset;
 692         bf[0].length = cpu_to_be16(t);
 693         dup->length = cpu_to_be16(t);
 694         *xfs_dir2_data_unused_tag_p(dup) = cpu_to_be16((char *)dup - (char *)hdr);
 695         /*
 696          * Log it and return it.
 697          */
 698         xfs_dir2_data_log_header(args, bp);
 699         xfs_dir2_data_log_unused(args, bp, dup);
 700         *bpp = bp;
 701         return 0;
 702 }
 703 
 704 /*
 705  * Log an active data entry from the block.
 706  */
 707 void
 708 xfs_dir2_data_log_entry(
 709         struct xfs_da_args      *args,
 710         struct xfs_buf          *bp,
 711         xfs_dir2_data_entry_t   *dep)           /* data entry pointer */
 712 {
 713         struct xfs_dir2_data_hdr *hdr = bp->b_addr;
 714 
 715         ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
 716                hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
 717                hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
 718                hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
 719 
 720         xfs_trans_log_buf(args->trans, bp, (uint)((char *)dep - (char *)hdr),
 721                 (uint)((char *)(args->dp->d_ops->data_entry_tag_p(dep) + 1) -
 722                        (char *)hdr - 1));
 723 }
 724 
 725 /*
 726  * Log a data block header.
 727  */
 728 void
 729 xfs_dir2_data_log_header(
 730         struct xfs_da_args      *args,
 731         struct xfs_buf          *bp)
 732 {
 733 #ifdef DEBUG
 734         struct xfs_dir2_data_hdr *hdr = bp->b_addr;
 735 
 736         ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
 737                hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
 738                hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
 739                hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
 740 #endif
 741 
 742         xfs_trans_log_buf(args->trans, bp, 0,
 743                           args->dp->d_ops->data_entry_offset - 1);
 744 }
 745 
 746 /*
 747  * Log a data unused entry.
 748  */
 749 void
 750 xfs_dir2_data_log_unused(
 751         struct xfs_da_args      *args,
 752         struct xfs_buf          *bp,
 753         xfs_dir2_data_unused_t  *dup)           /* data unused pointer */
 754 {
 755         xfs_dir2_data_hdr_t     *hdr = bp->b_addr;
 756 
 757         ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
 758                hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
 759                hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
 760                hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
 761 
 762         /*
 763          * Log the first part of the unused entry.
 764          */
 765         xfs_trans_log_buf(args->trans, bp, (uint)((char *)dup - (char *)hdr),
 766                 (uint)((char *)&dup->length + sizeof(dup->length) -
 767                        1 - (char *)hdr));
 768         /*
 769          * Log the end (tag) of the unused entry.
 770          */
 771         xfs_trans_log_buf(args->trans, bp,
 772                 (uint)((char *)xfs_dir2_data_unused_tag_p(dup) - (char *)hdr),
 773                 (uint)((char *)xfs_dir2_data_unused_tag_p(dup) - (char *)hdr +
 774                        sizeof(xfs_dir2_data_off_t) - 1));
 775 }
 776 
 777 /*
 778  * Make a byte range in the data block unused.
 779  * Its current contents are unimportant.
 780  */
 781 void
 782 xfs_dir2_data_make_free(
 783         struct xfs_da_args      *args,
 784         struct xfs_buf          *bp,
 785         xfs_dir2_data_aoff_t    offset,         /* starting byte offset */
 786         xfs_dir2_data_aoff_t    len,            /* length in bytes */
 787         int                     *needlogp,      /* out: log header */
 788         int                     *needscanp)     /* out: regen bestfree */
 789 {
 790         xfs_dir2_data_hdr_t     *hdr;           /* data block pointer */
 791         xfs_dir2_data_free_t    *dfp;           /* bestfree pointer */
 792         char                    *endptr;        /* end of data area */
 793         int                     needscan;       /* need to regen bestfree */
 794         xfs_dir2_data_unused_t  *newdup;        /* new unused entry */
 795         xfs_dir2_data_unused_t  *postdup;       /* unused entry after us */
 796         xfs_dir2_data_unused_t  *prevdup;       /* unused entry before us */
 797         struct xfs_dir2_data_free *bf;
 798 
 799         hdr = bp->b_addr;
 800 
 801         /*
 802          * Figure out where the end of the data area is.
 803          */
 804         endptr = xfs_dir3_data_endp(args->geo, hdr);
 805         ASSERT(endptr != NULL);
 806 
 807         /*
 808          * If this isn't the start of the block, then back up to
 809          * the previous entry and see if it's free.
 810          */
 811         if (offset > args->dp->d_ops->data_entry_offset) {
 812                 __be16                  *tagp;  /* tag just before us */
 813 
 814                 tagp = (__be16 *)((char *)hdr + offset) - 1;
 815                 prevdup = (xfs_dir2_data_unused_t *)((char *)hdr + be16_to_cpu(*tagp));
 816                 if (be16_to_cpu(prevdup->freetag) != XFS_DIR2_DATA_FREE_TAG)
 817                         prevdup = NULL;
 818         } else
 819                 prevdup = NULL;
 820         /*
 821          * If this isn't the end of the block, see if the entry after
 822          * us is free.
 823          */
 824         if ((char *)hdr + offset + len < endptr) {
 825                 postdup =
 826                         (xfs_dir2_data_unused_t *)((char *)hdr + offset + len);
 827                 if (be16_to_cpu(postdup->freetag) != XFS_DIR2_DATA_FREE_TAG)
 828                         postdup = NULL;
 829         } else
 830                 postdup = NULL;
 831         ASSERT(*needscanp == 0);
 832         needscan = 0;
 833         /*
 834          * Previous and following entries are both free,
 835          * merge everything into a single free entry.
 836          */
 837         bf = args->dp->d_ops->data_bestfree_p(hdr);
 838         if (prevdup && postdup) {
 839                 xfs_dir2_data_free_t    *dfp2;  /* another bestfree pointer */
 840 
 841                 /*
 842                  * See if prevdup and/or postdup are in bestfree table.
 843                  */
 844                 dfp = xfs_dir2_data_freefind(hdr, bf, prevdup);
 845                 dfp2 = xfs_dir2_data_freefind(hdr, bf, postdup);
 846                 /*
 847                  * We need a rescan unless there are exactly 2 free entries
 848                  * namely our two.  Then we know what's happening, otherwise
 849                  * since the third bestfree is there, there might be more
 850                  * entries.
 851                  */
 852                 needscan = (bf[2].length != 0);
 853                 /*
 854                  * Fix up the new big freespace.
 855                  */
 856                 be16_add_cpu(&prevdup->length, len + be16_to_cpu(postdup->length));
 857                 *xfs_dir2_data_unused_tag_p(prevdup) =
 858                         cpu_to_be16((char *)prevdup - (char *)hdr);
 859                 xfs_dir2_data_log_unused(args, bp, prevdup);
 860                 if (!needscan) {
 861                         /*
 862                          * Has to be the case that entries 0 and 1 are
 863                          * dfp and dfp2 (don't know which is which), and
 864                          * entry 2 is empty.
 865                          * Remove entry 1 first then entry 0.
 866                          */
 867                         ASSERT(dfp && dfp2);
 868                         if (dfp == &bf[1]) {
 869                                 dfp = &bf[0];
 870                                 ASSERT(dfp2 == dfp);
 871                                 dfp2 = &bf[1];
 872                         }
 873                         xfs_dir2_data_freeremove(hdr, bf, dfp2, needlogp);
 874                         xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
 875                         /*
 876                          * Now insert the new entry.
 877                          */
 878                         dfp = xfs_dir2_data_freeinsert(hdr, bf, prevdup,
 879                                                        needlogp);
 880                         ASSERT(dfp == &bf[0]);
 881                         ASSERT(dfp->length == prevdup->length);
 882                         ASSERT(!dfp[1].length);
 883                         ASSERT(!dfp[2].length);
 884                 }
 885         }
 886         /*
 887          * The entry before us is free, merge with it.
 888          */
 889         else if (prevdup) {
 890                 dfp = xfs_dir2_data_freefind(hdr, bf, prevdup);
 891                 be16_add_cpu(&prevdup->length, len);
 892                 *xfs_dir2_data_unused_tag_p(prevdup) =
 893                         cpu_to_be16((char *)prevdup - (char *)hdr);
 894                 xfs_dir2_data_log_unused(args, bp, prevdup);
 895                 /*
 896                  * If the previous entry was in the table, the new entry
 897                  * is longer, so it will be in the table too.  Remove
 898                  * the old one and add the new one.
 899                  */
 900                 if (dfp) {
 901                         xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
 902                         xfs_dir2_data_freeinsert(hdr, bf, prevdup, needlogp);
 903                 }
 904                 /*
 905                  * Otherwise we need a scan if the new entry is big enough.
 906                  */
 907                 else {
 908                         needscan = be16_to_cpu(prevdup->length) >
 909                                    be16_to_cpu(bf[2].length);
 910                 }
 911         }
 912         /*
 913          * The following entry is free, merge with it.
 914          */
 915         else if (postdup) {
 916                 dfp = xfs_dir2_data_freefind(hdr, bf, postdup);
 917                 newdup = (xfs_dir2_data_unused_t *)((char *)hdr + offset);
 918                 newdup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
 919                 newdup->length = cpu_to_be16(len + be16_to_cpu(postdup->length));
 920                 *xfs_dir2_data_unused_tag_p(newdup) =
 921                         cpu_to_be16((char *)newdup - (char *)hdr);
 922                 xfs_dir2_data_log_unused(args, bp, newdup);
 923                 /*
 924                  * If the following entry was in the table, the new entry
 925                  * is longer, so it will be in the table too.  Remove
 926                  * the old one and add the new one.
 927                  */
 928                 if (dfp) {
 929                         xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
 930                         xfs_dir2_data_freeinsert(hdr, bf, newdup, needlogp);
 931                 }
 932                 /*
 933                  * Otherwise we need a scan if the new entry is big enough.
 934                  */
 935                 else {
 936                         needscan = be16_to_cpu(newdup->length) >
 937                                    be16_to_cpu(bf[2].length);
 938                 }
 939         }
 940         /*
 941          * Neither neighbor is free.  Make a new entry.
 942          */
 943         else {
 944                 newdup = (xfs_dir2_data_unused_t *)((char *)hdr + offset);
 945                 newdup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
 946                 newdup->length = cpu_to_be16(len);
 947                 *xfs_dir2_data_unused_tag_p(newdup) =
 948                         cpu_to_be16((char *)newdup - (char *)hdr);
 949                 xfs_dir2_data_log_unused(args, bp, newdup);
 950                 xfs_dir2_data_freeinsert(hdr, bf, newdup, needlogp);
 951         }
 952         *needscanp = needscan;
 953 }
 954 
 955 /* Check our free data for obvious signs of corruption. */
 956 static inline xfs_failaddr_t
 957 xfs_dir2_data_check_free(
 958         struct xfs_dir2_data_hdr        *hdr,
 959         struct xfs_dir2_data_unused     *dup,
 960         xfs_dir2_data_aoff_t            offset,
 961         xfs_dir2_data_aoff_t            len)
 962 {
 963         if (hdr->magic != cpu_to_be32(XFS_DIR2_DATA_MAGIC) &&
 964             hdr->magic != cpu_to_be32(XFS_DIR3_DATA_MAGIC) &&
 965             hdr->magic != cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) &&
 966             hdr->magic != cpu_to_be32(XFS_DIR3_BLOCK_MAGIC))
 967                 return __this_address;
 968         if (be16_to_cpu(dup->freetag) != XFS_DIR2_DATA_FREE_TAG)
 969                 return __this_address;
 970         if (offset < (char *)dup - (char *)hdr)
 971                 return __this_address;
 972         if (offset + len > (char *)dup + be16_to_cpu(dup->length) - (char *)hdr)
 973                 return __this_address;
 974         if ((char *)dup - (char *)hdr !=
 975                         be16_to_cpu(*xfs_dir2_data_unused_tag_p(dup)))
 976                 return __this_address;
 977         return NULL;
 978 }
 979 
 980 /* Sanity-check a new bestfree entry. */
 981 static inline xfs_failaddr_t
 982 xfs_dir2_data_check_new_free(
 983         struct xfs_dir2_data_hdr        *hdr,
 984         struct xfs_dir2_data_free       *dfp,
 985         struct xfs_dir2_data_unused     *newdup)
 986 {
 987         if (dfp == NULL)
 988                 return __this_address;
 989         if (dfp->length != newdup->length)
 990                 return __this_address;
 991         if (be16_to_cpu(dfp->offset) != (char *)newdup - (char *)hdr)
 992                 return __this_address;
 993         return NULL;
 994 }
 995 
 996 /*
 997  * Take a byte range out of an existing unused space and make it un-free.
 998  */
 999 int
1000 xfs_dir2_data_use_free(
1001         struct xfs_da_args      *args,
1002         struct xfs_buf          *bp,
1003         xfs_dir2_data_unused_t  *dup,           /* unused entry */
1004         xfs_dir2_data_aoff_t    offset,         /* starting offset to use */
1005         xfs_dir2_data_aoff_t    len,            /* length to use */
1006         int                     *needlogp,      /* out: need to log header */
1007         int                     *needscanp)     /* out: need regen bestfree */
1008 {
1009         xfs_dir2_data_hdr_t     *hdr;           /* data block header */
1010         xfs_dir2_data_free_t    *dfp;           /* bestfree pointer */
1011         xfs_dir2_data_unused_t  *newdup;        /* new unused entry */
1012         xfs_dir2_data_unused_t  *newdup2;       /* another new unused entry */
1013         struct xfs_dir2_data_free *bf;
1014         xfs_failaddr_t          fa;
1015         int                     matchback;      /* matches end of freespace */
1016         int                     matchfront;     /* matches start of freespace */
1017         int                     needscan;       /* need to regen bestfree */
1018         int                     oldlen;         /* old unused entry's length */
1019 
1020         hdr = bp->b_addr;
1021         fa = xfs_dir2_data_check_free(hdr, dup, offset, len);
1022         if (fa)
1023                 goto corrupt;
1024         /*
1025          * Look up the entry in the bestfree table.
1026          */
1027         oldlen = be16_to_cpu(dup->length);
1028         bf = args->dp->d_ops->data_bestfree_p(hdr);
1029         dfp = xfs_dir2_data_freefind(hdr, bf, dup);
1030         ASSERT(dfp || oldlen <= be16_to_cpu(bf[2].length));
1031         /*
1032          * Check for alignment with front and back of the entry.
1033          */
1034         matchfront = (char *)dup - (char *)hdr == offset;
1035         matchback = (char *)dup + oldlen - (char *)hdr == offset + len;
1036         ASSERT(*needscanp == 0);
1037         needscan = 0;
1038         /*
1039          * If we matched it exactly we just need to get rid of it from
1040          * the bestfree table.
1041          */
1042         if (matchfront && matchback) {
1043                 if (dfp) {
1044                         needscan = (bf[2].offset != 0);
1045                         if (!needscan)
1046                                 xfs_dir2_data_freeremove(hdr, bf, dfp,
1047                                                          needlogp);
1048                 }
1049         }
1050         /*
1051          * We match the first part of the entry.
1052          * Make a new entry with the remaining freespace.
1053          */
1054         else if (matchfront) {
1055                 newdup = (xfs_dir2_data_unused_t *)((char *)hdr + offset + len);
1056                 newdup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
1057                 newdup->length = cpu_to_be16(oldlen - len);
1058                 *xfs_dir2_data_unused_tag_p(newdup) =
1059                         cpu_to_be16((char *)newdup - (char *)hdr);
1060                 xfs_dir2_data_log_unused(args, bp, newdup);
1061                 /*
1062                  * If it was in the table, remove it and add the new one.
1063                  */
1064                 if (dfp) {
1065                         xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
1066                         dfp = xfs_dir2_data_freeinsert(hdr, bf, newdup,
1067                                                        needlogp);
1068                         fa = xfs_dir2_data_check_new_free(hdr, dfp, newdup);
1069                         if (fa)
1070                                 goto corrupt;
1071                         /*
1072                          * If we got inserted at the last slot,
1073                          * that means we don't know if there was a better
1074                          * choice for the last slot, or not.  Rescan.
1075                          */
1076                         needscan = dfp == &bf[2];
1077                 }
1078         }
1079         /*
1080          * We match the last part of the entry.
1081          * Trim the allocated space off the tail of the entry.
1082          */
1083         else if (matchback) {
1084                 newdup = dup;
1085                 newdup->length = cpu_to_be16(((char *)hdr + offset) - (char *)newdup);
1086                 *xfs_dir2_data_unused_tag_p(newdup) =
1087                         cpu_to_be16((char *)newdup - (char *)hdr);
1088                 xfs_dir2_data_log_unused(args, bp, newdup);
1089                 /*
1090                  * If it was in the table, remove it and add the new one.
1091                  */
1092                 if (dfp) {
1093                         xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
1094                         dfp = xfs_dir2_data_freeinsert(hdr, bf, newdup,
1095                                                        needlogp);
1096                         fa = xfs_dir2_data_check_new_free(hdr, dfp, newdup);
1097                         if (fa)
1098                                 goto corrupt;
1099                         /*
1100                          * If we got inserted at the last slot,
1101                          * that means we don't know if there was a better
1102                          * choice for the last slot, or not.  Rescan.
1103                          */
1104                         needscan = dfp == &bf[2];
1105                 }
1106         }
1107         /*
1108          * Poking out the middle of an entry.
1109          * Make two new entries.
1110          */
1111         else {
1112                 newdup = dup;
1113                 newdup->length = cpu_to_be16(((char *)hdr + offset) - (char *)newdup);
1114                 *xfs_dir2_data_unused_tag_p(newdup) =
1115                         cpu_to_be16((char *)newdup - (char *)hdr);
1116                 xfs_dir2_data_log_unused(args, bp, newdup);
1117                 newdup2 = (xfs_dir2_data_unused_t *)((char *)hdr + offset + len);
1118                 newdup2->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
1119                 newdup2->length = cpu_to_be16(oldlen - len - be16_to_cpu(newdup->length));
1120                 *xfs_dir2_data_unused_tag_p(newdup2) =
1121                         cpu_to_be16((char *)newdup2 - (char *)hdr);
1122                 xfs_dir2_data_log_unused(args, bp, newdup2);
1123                 /*
1124                  * If the old entry was in the table, we need to scan
1125                  * if the 3rd entry was valid, since these entries
1126                  * are smaller than the old one.
1127                  * If we don't need to scan that means there were 1 or 2
1128                  * entries in the table, and removing the old and adding
1129                  * the 2 new will work.
1130                  */
1131                 if (dfp) {
1132                         needscan = (bf[2].length != 0);
1133                         if (!needscan) {
1134                                 xfs_dir2_data_freeremove(hdr, bf, dfp,
1135                                                          needlogp);
1136                                 xfs_dir2_data_freeinsert(hdr, bf, newdup,
1137                                                          needlogp);
1138                                 xfs_dir2_data_freeinsert(hdr, bf, newdup2,
1139                                                          needlogp);
1140                         }
1141                 }
1142         }
1143         *needscanp = needscan;
1144         return 0;
1145 corrupt:
1146         xfs_corruption_error(__func__, XFS_ERRLEVEL_LOW, args->dp->i_mount,
1147                         hdr, sizeof(*hdr), __FILE__, __LINE__, fa);
1148         return -EFSCORRUPTED;
1149 }
1150 
1151 /* Find the end of the entry data in a data/block format dir block. */
1152 void *
1153 xfs_dir3_data_endp(
1154         struct xfs_da_geometry          *geo,
1155         struct xfs_dir2_data_hdr        *hdr)
1156 {
1157         switch (hdr->magic) {
1158         case cpu_to_be32(XFS_DIR3_BLOCK_MAGIC):
1159         case cpu_to_be32(XFS_DIR2_BLOCK_MAGIC):
1160                 return xfs_dir2_block_leaf_p(xfs_dir2_block_tail_p(geo, hdr));
1161         case cpu_to_be32(XFS_DIR3_DATA_MAGIC):
1162         case cpu_to_be32(XFS_DIR2_DATA_MAGIC):
1163                 return (char *)hdr + geo->blksize;
1164         default:
1165                 return NULL;
1166         }
1167 }
/* [<][>][^][v][top][bottom][index][help] */
root/fs/xfs/libxfs/xfs_dir2_data.c

DEFINITIONS
