linux/fs/xfs/xfs_dir2_block.c
<<
>>
Prefs
   1/*
   2 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
   3 * Copyright (c) 2013 Red Hat, Inc.
   4 * All Rights Reserved.
   5 *
   6 * This program is free software; you can redistribute it and/or
   7 * modify it under the terms of the GNU General Public License as
   8 * published by the Free Software Foundation.
   9 *
  10 * This program is distributed in the hope that it would be useful,
  11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 * GNU General Public License for more details.
  14 *
  15 * You should have received a copy of the GNU General Public License
  16 * along with this program; if not, write the Free Software Foundation,
  17 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18 */
  19#include "xfs.h"
  20#include "xfs_fs.h"
  21#include "xfs_types.h"
  22#include "xfs_log.h"
  23#include "xfs_trans.h"
  24#include "xfs_sb.h"
  25#include "xfs_ag.h"
  26#include "xfs_mount.h"
  27#include "xfs_da_btree.h"
  28#include "xfs_bmap_btree.h"
  29#include "xfs_dinode.h"
  30#include "xfs_inode.h"
  31#include "xfs_inode_item.h"
  32#include "xfs_bmap.h"
  33#include "xfs_buf_item.h"
  34#include "xfs_dir2.h"
  35#include "xfs_dir2_format.h"
  36#include "xfs_dir2_priv.h"
  37#include "xfs_error.h"
  38#include "xfs_trace.h"
  39#include "xfs_cksum.h"
  40
  41/*
  42 * Local function prototypes.
  43 */
  44static void xfs_dir2_block_log_leaf(xfs_trans_t *tp, struct xfs_buf *bp,
  45                                    int first, int last);
  46static void xfs_dir2_block_log_tail(xfs_trans_t *tp, struct xfs_buf *bp);
  47static int xfs_dir2_block_lookup_int(xfs_da_args_t *args, struct xfs_buf **bpp,
  48                                     int *entno);
  49static int xfs_dir2_block_sort(const void *a, const void *b);
  50
  51static xfs_dahash_t xfs_dir_hash_dot, xfs_dir_hash_dotdot;
  52
  53/*
  54 * One-time startup routine called from xfs_init().
  55 */
  56void
  57xfs_dir_startup(void)
  58{
  59        xfs_dir_hash_dot = xfs_da_hashname((unsigned char *)".", 1);
  60        xfs_dir_hash_dotdot = xfs_da_hashname((unsigned char *)"..", 2);
  61}
  62
  63static bool
  64xfs_dir3_block_verify(
  65        struct xfs_buf          *bp)
  66{
  67        struct xfs_mount        *mp = bp->b_target->bt_mount;
  68        struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
  69
  70        if (xfs_sb_version_hascrc(&mp->m_sb)) {
  71                if (hdr3->magic != cpu_to_be32(XFS_DIR3_BLOCK_MAGIC))
  72                        return false;
  73                if (!uuid_equal(&hdr3->uuid, &mp->m_sb.sb_uuid))
  74                        return false;
  75                if (be64_to_cpu(hdr3->blkno) != bp->b_bn)
  76                        return false;
  77        } else {
  78                if (hdr3->magic != cpu_to_be32(XFS_DIR2_BLOCK_MAGIC))
  79                        return false;
  80        }
  81        if (__xfs_dir3_data_check(NULL, bp))
  82                return false;
  83        return true;
  84}
  85
  86static void
  87xfs_dir3_block_read_verify(
  88        struct xfs_buf  *bp)
  89{
  90        struct xfs_mount        *mp = bp->b_target->bt_mount;
  91
  92        if ((xfs_sb_version_hascrc(&mp->m_sb) &&
  93             !xfs_verify_cksum(bp->b_addr, BBTOB(bp->b_length),
  94                                          XFS_DIR3_DATA_CRC_OFF)) ||
  95            !xfs_dir3_block_verify(bp)) {
  96                XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
  97                xfs_buf_ioerror(bp, EFSCORRUPTED);
  98        }
  99}
 100
 101static void
 102xfs_dir3_block_write_verify(
 103        struct xfs_buf  *bp)
 104{
 105        struct xfs_mount        *mp = bp->b_target->bt_mount;
 106        struct xfs_buf_log_item *bip = bp->b_fspriv;
 107        struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
 108
 109        if (!xfs_dir3_block_verify(bp)) {
 110                XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
 111                xfs_buf_ioerror(bp, EFSCORRUPTED);
 112                return;
 113        }
 114
 115        if (!xfs_sb_version_hascrc(&mp->m_sb))
 116                return;
 117
 118        if (bip)
 119                hdr3->lsn = cpu_to_be64(bip->bli_item.li_lsn);
 120
 121        xfs_update_cksum(bp->b_addr, BBTOB(bp->b_length), XFS_DIR3_DATA_CRC_OFF);
 122}
 123
 124const struct xfs_buf_ops xfs_dir3_block_buf_ops = {
 125        .verify_read = xfs_dir3_block_read_verify,
 126        .verify_write = xfs_dir3_block_write_verify,
 127};
 128
 129static int
 130xfs_dir3_block_read(
 131        struct xfs_trans        *tp,
 132        struct xfs_inode        *dp,
 133        struct xfs_buf          **bpp)
 134{
 135        struct xfs_mount        *mp = dp->i_mount;
 136        int                     err;
 137
 138        err = xfs_da_read_buf(tp, dp, mp->m_dirdatablk, -1, bpp,
 139                                XFS_DATA_FORK, &xfs_dir3_block_buf_ops);
 140        if (!err && tp)
 141                xfs_trans_buf_set_type(tp, *bpp, XFS_BLFT_DIR_BLOCK_BUF);
 142        return err;
 143}
 144
 145static void
 146xfs_dir3_block_init(
 147        struct xfs_mount        *mp,
 148        struct xfs_trans        *tp,
 149        struct xfs_buf          *bp,
 150        struct xfs_inode        *dp)
 151{
 152        struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
 153
 154        bp->b_ops = &xfs_dir3_block_buf_ops;
 155        xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DIR_BLOCK_BUF);
 156
 157        if (xfs_sb_version_hascrc(&mp->m_sb)) {
 158                memset(hdr3, 0, sizeof(*hdr3));
 159                hdr3->magic = cpu_to_be32(XFS_DIR3_BLOCK_MAGIC);
 160                hdr3->blkno = cpu_to_be64(bp->b_bn);
 161                hdr3->owner = cpu_to_be64(dp->i_ino);
 162                uuid_copy(&hdr3->uuid, &mp->m_sb.sb_uuid);
 163                return;
 164
 165        }
 166        hdr3->magic = cpu_to_be32(XFS_DIR2_BLOCK_MAGIC);
 167}
 168
 169static void
 170xfs_dir2_block_need_space(
 171        struct xfs_dir2_data_hdr        *hdr,
 172        struct xfs_dir2_block_tail      *btp,
 173        struct xfs_dir2_leaf_entry      *blp,
 174        __be16                          **tagpp,
 175        struct xfs_dir2_data_unused     **dupp,
 176        struct xfs_dir2_data_unused     **enddupp,
 177        int                             *compact,
 178        int                             len)
 179{
 180        struct xfs_dir2_data_free       *bf;
 181        __be16                          *tagp = NULL;
 182        struct xfs_dir2_data_unused     *dup = NULL;
 183        struct xfs_dir2_data_unused     *enddup = NULL;
 184
 185        *compact = 0;
 186        bf = xfs_dir3_data_bestfree_p(hdr);
 187
 188        /*
 189         * If there are stale entries we'll use one for the leaf.
 190         */
 191        if (btp->stale) {
 192                if (be16_to_cpu(bf[0].length) >= len) {
 193                        /*
 194                         * The biggest entry enough to avoid compaction.
 195                         */
 196                        dup = (xfs_dir2_data_unused_t *)
 197                              ((char *)hdr + be16_to_cpu(bf[0].offset));
 198                        goto out;
 199                }
 200
 201                /*
 202                 * Will need to compact to make this work.
 203                 * Tag just before the first leaf entry.
 204                 */
 205                *compact = 1;
 206                tagp = (__be16 *)blp - 1;
 207
 208                /* Data object just before the first leaf entry.  */
 209                dup = (xfs_dir2_data_unused_t *)((char *)hdr + be16_to_cpu(*tagp));
 210
 211                /*
 212                 * If it's not free then the data will go where the
 213                 * leaf data starts now, if it works at all.
 214                 */
 215                if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
 216                        if (be16_to_cpu(dup->length) + (be32_to_cpu(btp->stale) - 1) *
 217                            (uint)sizeof(*blp) < len)
 218                                dup = NULL;
 219                } else if ((be32_to_cpu(btp->stale) - 1) * (uint)sizeof(*blp) < len)
 220                        dup = NULL;
 221                else
 222                        dup = (xfs_dir2_data_unused_t *)blp;
 223                goto out;
 224        }
 225
 226        /*
 227         * no stale entries, so just use free space.
 228         * Tag just before the first leaf entry.
 229         */
 230        tagp = (__be16 *)blp - 1;
 231
 232        /* Data object just before the first leaf entry.  */
 233        enddup = (xfs_dir2_data_unused_t *)((char *)hdr + be16_to_cpu(*tagp));
 234
 235        /*
 236         * If it's not free then can't do this add without cleaning up:
 237         * the space before the first leaf entry needs to be free so it
 238         * can be expanded to hold the pointer to the new entry.
 239         */
 240        if (be16_to_cpu(enddup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
 241                /*
 242                 * Check out the biggest freespace and see if it's the same one.
 243                 */
 244                dup = (xfs_dir2_data_unused_t *)
 245                      ((char *)hdr + be16_to_cpu(bf[0].offset));
 246                if (dup != enddup) {
 247                        /*
 248                         * Not the same free entry, just check its length.
 249                         */
 250                        if (be16_to_cpu(dup->length) < len)
 251                                dup = NULL;
 252                        goto out;
 253                }
 254
 255                /*
 256                 * It is the biggest freespace, can it hold the leaf too?
 257                 */
 258                if (be16_to_cpu(dup->length) < len + (uint)sizeof(*blp)) {
 259                        /*
 260                         * Yes, use the second-largest entry instead if it works.
 261                         */
 262                        if (be16_to_cpu(bf[1].length) >= len)
 263                                dup = (xfs_dir2_data_unused_t *)
 264                                      ((char *)hdr + be16_to_cpu(bf[1].offset));
 265                        else
 266                                dup = NULL;
 267                }
 268        }
 269out:
 270        *tagpp = tagp;
 271        *dupp = dup;
 272        *enddupp = enddup;
 273}
 274
 275/*
 276 * compact the leaf entries.
 277 * Leave the highest-numbered stale entry stale.
 278 * XXX should be the one closest to mid but mid is not yet computed.
 279 */
 280static void
 281xfs_dir2_block_compact(
 282        struct xfs_trans                *tp,
 283        struct xfs_buf                  *bp,
 284        struct xfs_dir2_data_hdr        *hdr,
 285        struct xfs_dir2_block_tail      *btp,
 286        struct xfs_dir2_leaf_entry      *blp,
 287        int                             *needlog,
 288        int                             *lfloghigh,
 289        int                             *lfloglow)
 290{
 291        int                     fromidx;        /* source leaf index */
 292        int                     toidx;          /* target leaf index */
 293        int                     needscan = 0;
 294        int                     highstale;      /* high stale index */
 295
 296        fromidx = toidx = be32_to_cpu(btp->count) - 1;
 297        highstale = *lfloghigh = -1;
 298        for (; fromidx >= 0; fromidx--) {
 299                if (blp[fromidx].address == cpu_to_be32(XFS_DIR2_NULL_DATAPTR)) {
 300                        if (highstale == -1)
 301                                highstale = toidx;
 302                        else {
 303                                if (*lfloghigh == -1)
 304                                        *lfloghigh = toidx;
 305                                continue;
 306                        }
 307                }
 308                if (fromidx < toidx)
 309                        blp[toidx] = blp[fromidx];
 310                toidx--;
 311        }
 312        *lfloglow = toidx + 1 - (be32_to_cpu(btp->stale) - 1);
 313        *lfloghigh -= be32_to_cpu(btp->stale) - 1;
 314        be32_add_cpu(&btp->count, -(be32_to_cpu(btp->stale) - 1));
 315        xfs_dir2_data_make_free(tp, bp,
 316                (xfs_dir2_data_aoff_t)((char *)blp - (char *)hdr),
 317                (xfs_dir2_data_aoff_t)((be32_to_cpu(btp->stale) - 1) * sizeof(*blp)),
 318                needlog, &needscan);
 319        blp += be32_to_cpu(btp->stale) - 1;
 320        btp->stale = cpu_to_be32(1);
 321        /*
 322         * If we now need to rebuild the bestfree map, do so.
 323         * This needs to happen before the next call to use_free.
 324         */
 325        if (needscan)
 326                xfs_dir2_data_freescan(tp->t_mountp, hdr, needlog);
 327}
 328
 329/*
 330 * Add an entry to a block directory.
 331 */
 332int                                             /* error */
 333xfs_dir2_block_addname(
 334        xfs_da_args_t           *args)          /* directory op arguments */
 335{
 336        xfs_dir2_data_hdr_t     *hdr;           /* block header */
 337        xfs_dir2_leaf_entry_t   *blp;           /* block leaf entries */
 338        struct xfs_buf          *bp;            /* buffer for block */
 339        xfs_dir2_block_tail_t   *btp;           /* block tail */
 340        int                     compact;        /* need to compact leaf ents */
 341        xfs_dir2_data_entry_t   *dep;           /* block data entry */
 342        xfs_inode_t             *dp;            /* directory inode */
 343        xfs_dir2_data_unused_t  *dup;           /* block unused entry */
 344        int                     error;          /* error return value */
 345        xfs_dir2_data_unused_t  *enddup=NULL;   /* unused at end of data */
 346        xfs_dahash_t            hash;           /* hash value of found entry */
 347        int                     high;           /* high index for binary srch */
 348        int                     highstale;      /* high stale index */
 349        int                     lfloghigh=0;    /* last final leaf to log */
 350        int                     lfloglow=0;     /* first final leaf to log */
 351        int                     len;            /* length of the new entry */
 352        int                     low;            /* low index for binary srch */
 353        int                     lowstale;       /* low stale index */
 354        int                     mid=0;          /* midpoint for binary srch */
 355        xfs_mount_t             *mp;            /* filesystem mount point */
 356        int                     needlog;        /* need to log header */
 357        int                     needscan;       /* need to rescan freespace */
 358        __be16                  *tagp;          /* pointer to tag value */
 359        xfs_trans_t             *tp;            /* transaction structure */
 360
 361        trace_xfs_dir2_block_addname(args);
 362
 363        dp = args->dp;
 364        tp = args->trans;
 365        mp = dp->i_mount;
 366
 367        /* Read the (one and only) directory block into bp. */
 368        error = xfs_dir3_block_read(tp, dp, &bp);
 369        if (error)
 370                return error;
 371
 372        len = xfs_dir2_data_entsize(args->namelen);
 373
 374        /*
 375         * Set up pointers to parts of the block.
 376         */
 377        hdr = bp->b_addr;
 378        btp = xfs_dir2_block_tail_p(mp, hdr);
 379        blp = xfs_dir2_block_leaf_p(btp);
 380
 381        /*
 382         * Find out if we can reuse stale entries or whether we need extra
 383         * space for entry and new leaf.
 384         */
 385        xfs_dir2_block_need_space(hdr, btp, blp, &tagp, &dup,
 386                                  &enddup, &compact, len);
 387
 388        /*
 389         * Done everything we need for a space check now.
 390         */
 391        if (args->op_flags & XFS_DA_OP_JUSTCHECK) {
 392                xfs_trans_brelse(tp, bp);
 393                if (!dup)
 394                        return XFS_ERROR(ENOSPC);
 395                return 0;
 396        }
 397
 398        /*
 399         * If we don't have space for the new entry & leaf ...
 400         */
 401        if (!dup) {
 402                /* Don't have a space reservation: return no-space.  */
 403                if (args->total == 0)
 404                        return XFS_ERROR(ENOSPC);
 405                /*
 406                 * Convert to the next larger format.
 407                 * Then add the new entry in that format.
 408                 */
 409                error = xfs_dir2_block_to_leaf(args, bp);
 410                if (error)
 411                        return error;
 412                return xfs_dir2_leaf_addname(args);
 413        }
 414
 415        needlog = needscan = 0;
 416
 417        /*
 418         * If need to compact the leaf entries, do it now.
 419         */
 420        if (compact) {
 421                xfs_dir2_block_compact(tp, bp, hdr, btp, blp, &needlog,
 422                                      &lfloghigh, &lfloglow);
 423                /* recalculate blp post-compaction */
 424                blp = xfs_dir2_block_leaf_p(btp);
 425        } else if (btp->stale) {
 426                /*
 427                 * Set leaf logging boundaries to impossible state.
 428                 * For the no-stale case they're set explicitly.
 429                 */
 430                lfloglow = be32_to_cpu(btp->count);
 431                lfloghigh = -1;
 432        }
 433
 434        /*
 435         * Find the slot that's first lower than our hash value, -1 if none.
 436         */
 437        for (low = 0, high = be32_to_cpu(btp->count) - 1; low <= high; ) {
 438                mid = (low + high) >> 1;
 439                if ((hash = be32_to_cpu(blp[mid].hashval)) == args->hashval)
 440                        break;
 441                if (hash < args->hashval)
 442                        low = mid + 1;
 443                else
 444                        high = mid - 1;
 445        }
 446        while (mid >= 0 && be32_to_cpu(blp[mid].hashval) >= args->hashval) {
 447                mid--;
 448        }
 449        /*
 450         * No stale entries, will use enddup space to hold new leaf.
 451         */
 452        if (!btp->stale) {
 453                /*
 454                 * Mark the space needed for the new leaf entry, now in use.
 455                 */
 456                xfs_dir2_data_use_free(tp, bp, enddup,
 457                        (xfs_dir2_data_aoff_t)
 458                        ((char *)enddup - (char *)hdr + be16_to_cpu(enddup->length) -
 459                         sizeof(*blp)),
 460                        (xfs_dir2_data_aoff_t)sizeof(*blp),
 461                        &needlog, &needscan);
 462                /*
 463                 * Update the tail (entry count).
 464                 */
 465                be32_add_cpu(&btp->count, 1);
 466                /*
 467                 * If we now need to rebuild the bestfree map, do so.
 468                 * This needs to happen before the next call to use_free.
 469                 */
 470                if (needscan) {
 471                        xfs_dir2_data_freescan(mp, hdr, &needlog);
 472                        needscan = 0;
 473                }
 474                /*
 475                 * Adjust pointer to the first leaf entry, we're about to move
 476                 * the table up one to open up space for the new leaf entry.
 477                 * Then adjust our index to match.
 478                 */
 479                blp--;
 480                mid++;
 481                if (mid)
 482                        memmove(blp, &blp[1], mid * sizeof(*blp));
 483                lfloglow = 0;
 484                lfloghigh = mid;
 485        }
 486        /*
 487         * Use a stale leaf for our new entry.
 488         */
 489        else {
 490                for (lowstale = mid;
 491                     lowstale >= 0 &&
 492                        blp[lowstale].address !=
 493                        cpu_to_be32(XFS_DIR2_NULL_DATAPTR);
 494                     lowstale--)
 495                        continue;
 496                for (highstale = mid + 1;
 497                     highstale < be32_to_cpu(btp->count) &&
 498                        blp[highstale].address !=
 499                        cpu_to_be32(XFS_DIR2_NULL_DATAPTR) &&
 500                        (lowstale < 0 || mid - lowstale > highstale - mid);
 501                     highstale++)
 502                        continue;
 503                /*
 504                 * Move entries toward the low-numbered stale entry.
 505                 */
 506                if (lowstale >= 0 &&
 507                    (highstale == be32_to_cpu(btp->count) ||
 508                     mid - lowstale <= highstale - mid)) {
 509                        if (mid - lowstale)
 510                                memmove(&blp[lowstale], &blp[lowstale + 1],
 511                                        (mid - lowstale) * sizeof(*blp));
 512                        lfloglow = MIN(lowstale, lfloglow);
 513                        lfloghigh = MAX(mid, lfloghigh);
 514                }
 515                /*
 516                 * Move entries toward the high-numbered stale entry.
 517                 */
 518                else {
 519                        ASSERT(highstale < be32_to_cpu(btp->count));
 520                        mid++;
 521                        if (highstale - mid)
 522                                memmove(&blp[mid + 1], &blp[mid],
 523                                        (highstale - mid) * sizeof(*blp));
 524                        lfloglow = MIN(mid, lfloglow);
 525                        lfloghigh = MAX(highstale, lfloghigh);
 526                }
 527                be32_add_cpu(&btp->stale, -1);
 528        }
 529        /*
 530         * Point to the new data entry.
 531         */
 532        dep = (xfs_dir2_data_entry_t *)dup;
 533        /*
 534         * Fill in the leaf entry.
 535         */
 536        blp[mid].hashval = cpu_to_be32(args->hashval);
 537        blp[mid].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(mp,
 538                                (char *)dep - (char *)hdr));
 539        xfs_dir2_block_log_leaf(tp, bp, lfloglow, lfloghigh);
 540        /*
 541         * Mark space for the data entry used.
 542         */
 543        xfs_dir2_data_use_free(tp, bp, dup,
 544                (xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr),
 545                (xfs_dir2_data_aoff_t)len, &needlog, &needscan);
 546        /*
 547         * Create the new data entry.
 548         */
 549        dep->inumber = cpu_to_be64(args->inumber);
 550        dep->namelen = args->namelen;
 551        memcpy(dep->name, args->name, args->namelen);
 552        tagp = xfs_dir2_data_entry_tag_p(dep);
 553        *tagp = cpu_to_be16((char *)dep - (char *)hdr);
 554        /*
 555         * Clean up the bestfree array and log the header, tail, and entry.
 556         */
 557        if (needscan)
 558                xfs_dir2_data_freescan(mp, hdr, &needlog);
 559        if (needlog)
 560                xfs_dir2_data_log_header(tp, bp);
 561        xfs_dir2_block_log_tail(tp, bp);
 562        xfs_dir2_data_log_entry(tp, bp, dep);
 563        xfs_dir3_data_check(dp, bp);
 564        return 0;
 565}
 566
 567/*
 568 * Readdir for block directories.
 569 */
 570int                                             /* error */
 571xfs_dir2_block_getdents(
 572        xfs_inode_t             *dp,            /* incore inode */
 573        struct dir_context      *ctx)
 574{
 575        xfs_dir2_data_hdr_t     *hdr;           /* block header */
 576        struct xfs_buf          *bp;            /* buffer for block */
 577        xfs_dir2_block_tail_t   *btp;           /* block tail */
 578        xfs_dir2_data_entry_t   *dep;           /* block data entry */
 579        xfs_dir2_data_unused_t  *dup;           /* block unused entry */
 580        char                    *endptr;        /* end of the data entries */
 581        int                     error;          /* error return value */
 582        xfs_mount_t             *mp;            /* filesystem mount point */
 583        char                    *ptr;           /* current data entry */
 584        int                     wantoff;        /* starting block offset */
 585        xfs_off_t               cook;
 586
 587        mp = dp->i_mount;
 588        /*
 589         * If the block number in the offset is out of range, we're done.
 590         */
 591        if (xfs_dir2_dataptr_to_db(mp, ctx->pos) > mp->m_dirdatablk)
 592                return 0;
 593
 594        error = xfs_dir3_block_read(NULL, dp, &bp);
 595        if (error)
 596                return error;
 597
 598        /*
 599         * Extract the byte offset we start at from the seek pointer.
 600         * We'll skip entries before this.
 601         */
 602        wantoff = xfs_dir2_dataptr_to_off(mp, ctx->pos);
 603        hdr = bp->b_addr;
 604        xfs_dir3_data_check(dp, bp);
 605        /*
 606         * Set up values for the loop.
 607         */
 608        btp = xfs_dir2_block_tail_p(mp, hdr);
 609        ptr = (char *)xfs_dir3_data_entry_p(hdr);
 610        endptr = (char *)xfs_dir2_block_leaf_p(btp);
 611
 612        /*
 613         * Loop over the data portion of the block.
 614         * Each object is a real entry (dep) or an unused one (dup).
 615         */
 616        while (ptr < endptr) {
 617                dup = (xfs_dir2_data_unused_t *)ptr;
 618                /*
 619                 * Unused, skip it.
 620                 */
 621                if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
 622                        ptr += be16_to_cpu(dup->length);
 623                        continue;
 624                }
 625
 626                dep = (xfs_dir2_data_entry_t *)ptr;
 627
 628                /*
 629                 * Bump pointer for the next iteration.
 630                 */
 631                ptr += xfs_dir2_data_entsize(dep->namelen);
 632                /*
 633                 * The entry is before the desired starting point, skip it.
 634                 */
 635                if ((char *)dep - (char *)hdr < wantoff)
 636                        continue;
 637
 638                cook = xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk,
 639                                            (char *)dep - (char *)hdr);
 640
 641                ctx->pos = cook & 0x7fffffff;
 642                /*
 643                 * If it didn't fit, set the final offset to here & return.
 644                 */
 645                if (!dir_emit(ctx, (char *)dep->name, dep->namelen,
 646                            be64_to_cpu(dep->inumber), DT_UNKNOWN)) {
 647                        xfs_trans_brelse(NULL, bp);
 648                        return 0;
 649                }
 650        }
 651
 652        /*
 653         * Reached the end of the block.
 654         * Set the offset to a non-existent block 1 and return.
 655         */
 656        ctx->pos = xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk + 1, 0) &
 657                        0x7fffffff;
 658        xfs_trans_brelse(NULL, bp);
 659        return 0;
 660}
 661
 662/*
 663 * Log leaf entries from the block.
 664 */
 665static void
 666xfs_dir2_block_log_leaf(
 667        xfs_trans_t             *tp,            /* transaction structure */
 668        struct xfs_buf          *bp,            /* block buffer */
 669        int                     first,          /* index of first logged leaf */
 670        int                     last)           /* index of last logged leaf */
 671{
 672        xfs_dir2_data_hdr_t     *hdr = bp->b_addr;
 673        xfs_dir2_leaf_entry_t   *blp;
 674        xfs_dir2_block_tail_t   *btp;
 675
 676        btp = xfs_dir2_block_tail_p(tp->t_mountp, hdr);
 677        blp = xfs_dir2_block_leaf_p(btp);
 678        xfs_trans_log_buf(tp, bp, (uint)((char *)&blp[first] - (char *)hdr),
 679                (uint)((char *)&blp[last + 1] - (char *)hdr - 1));
 680}
 681
 682/*
 683 * Log the block tail.
 684 */
 685static void
 686xfs_dir2_block_log_tail(
 687        xfs_trans_t             *tp,            /* transaction structure */
 688        struct xfs_buf          *bp)            /* block buffer */
 689{
 690        xfs_dir2_data_hdr_t     *hdr = bp->b_addr;
 691        xfs_dir2_block_tail_t   *btp;
 692
 693        btp = xfs_dir2_block_tail_p(tp->t_mountp, hdr);
 694        xfs_trans_log_buf(tp, bp, (uint)((char *)btp - (char *)hdr),
 695                (uint)((char *)(btp + 1) - (char *)hdr - 1));
 696}
 697
 698/*
 699 * Look up an entry in the block.  This is the external routine,
 700 * xfs_dir2_block_lookup_int does the real work.
 701 */
 702int                                             /* error */
 703xfs_dir2_block_lookup(
 704        xfs_da_args_t           *args)          /* dir lookup arguments */
 705{
 706        xfs_dir2_data_hdr_t     *hdr;           /* block header */
 707        xfs_dir2_leaf_entry_t   *blp;           /* block leaf entries */
 708        struct xfs_buf          *bp;            /* block buffer */
 709        xfs_dir2_block_tail_t   *btp;           /* block tail */
 710        xfs_dir2_data_entry_t   *dep;           /* block data entry */
 711        xfs_inode_t             *dp;            /* incore inode */
 712        int                     ent;            /* entry index */
 713        int                     error;          /* error return value */
 714        xfs_mount_t             *mp;            /* filesystem mount point */
 715
 716        trace_xfs_dir2_block_lookup(args);
 717
 718        /*
 719         * Get the buffer, look up the entry.
 720         * If not found (ENOENT) then return, have no buffer.
 721         */
 722        if ((error = xfs_dir2_block_lookup_int(args, &bp, &ent)))
 723                return error;
 724        dp = args->dp;
 725        mp = dp->i_mount;
 726        hdr = bp->b_addr;
 727        xfs_dir3_data_check(dp, bp);
 728        btp = xfs_dir2_block_tail_p(mp, hdr);
 729        blp = xfs_dir2_block_leaf_p(btp);
 730        /*
 731         * Get the offset from the leaf entry, to point to the data.
 732         */
 733        dep = (xfs_dir2_data_entry_t *)((char *)hdr +
 734                xfs_dir2_dataptr_to_off(mp, be32_to_cpu(blp[ent].address)));
 735        /*
 736         * Fill in inode number, CI name if appropriate, release the block.
 737         */
 738        args->inumber = be64_to_cpu(dep->inumber);
 739        error = xfs_dir_cilookup_result(args, dep->name, dep->namelen);
 740        xfs_trans_brelse(args->trans, bp);
 741        return XFS_ERROR(error);
 742}
 743
 744/*
 745 * Internal block lookup routine.
 746 */
 747static int                                      /* error */
 748xfs_dir2_block_lookup_int(
 749        xfs_da_args_t           *args,          /* dir lookup arguments */
 750        struct xfs_buf          **bpp,          /* returned block buffer */
 751        int                     *entno)         /* returned entry number */
 752{
 753        xfs_dir2_dataptr_t      addr;           /* data entry address */
 754        xfs_dir2_data_hdr_t     *hdr;           /* block header */
 755        xfs_dir2_leaf_entry_t   *blp;           /* block leaf entries */
 756        struct xfs_buf          *bp;            /* block buffer */
 757        xfs_dir2_block_tail_t   *btp;           /* block tail */
 758        xfs_dir2_data_entry_t   *dep;           /* block data entry */
 759        xfs_inode_t             *dp;            /* incore inode */
 760        int                     error;          /* error return value */
 761        xfs_dahash_t            hash;           /* found hash value */
 762        int                     high;           /* binary search high index */
 763        int                     low;            /* binary search low index */
 764        int                     mid;            /* binary search current idx */
 765        xfs_mount_t             *mp;            /* filesystem mount point */
 766        xfs_trans_t             *tp;            /* transaction pointer */
 767        enum xfs_dacmp          cmp;            /* comparison result */
 768
 769        dp = args->dp;
 770        tp = args->trans;
 771        mp = dp->i_mount;
 772
 773        error = xfs_dir3_block_read(tp, dp, &bp);
 774        if (error)
 775                return error;
 776
 777        hdr = bp->b_addr;
 778        xfs_dir3_data_check(dp, bp);
 779        btp = xfs_dir2_block_tail_p(mp, hdr);
 780        blp = xfs_dir2_block_leaf_p(btp);
 781        /*
 782         * Loop doing a binary search for our hash value.
 783         * Find our entry, ENOENT if it's not there.
 784         */
 785        for (low = 0, high = be32_to_cpu(btp->count) - 1; ; ) {
 786                ASSERT(low <= high);
 787                mid = (low + high) >> 1;
 788                if ((hash = be32_to_cpu(blp[mid].hashval)) == args->hashval)
 789                        break;
 790                if (hash < args->hashval)
 791                        low = mid + 1;
 792                else
 793                        high = mid - 1;
 794                if (low > high) {
 795                        ASSERT(args->op_flags & XFS_DA_OP_OKNOENT);
 796                        xfs_trans_brelse(tp, bp);
 797                        return XFS_ERROR(ENOENT);
 798                }
 799        }
 800        /*
 801         * Back up to the first one with the right hash value.
 802         */
 803        while (mid > 0 && be32_to_cpu(blp[mid - 1].hashval) == args->hashval) {
 804                mid--;
 805        }
 806        /*
 807         * Now loop forward through all the entries with the
 808         * right hash value looking for our name.
 809         */
 810        do {
 811                if ((addr = be32_to_cpu(blp[mid].address)) == XFS_DIR2_NULL_DATAPTR)
 812                        continue;
 813                /*
 814                 * Get pointer to the entry from the leaf.
 815                 */
 816                dep = (xfs_dir2_data_entry_t *)
 817                        ((char *)hdr + xfs_dir2_dataptr_to_off(mp, addr));
 818                /*
 819                 * Compare name and if it's an exact match, return the index
 820                 * and buffer. If it's the first case-insensitive match, store
 821                 * the index and buffer and continue looking for an exact match.
 822                 */
 823                cmp = mp->m_dirnameops->compname(args, dep->name, dep->namelen);
 824                if (cmp != XFS_CMP_DIFFERENT && cmp != args->cmpresult) {
 825                        args->cmpresult = cmp;
 826                        *bpp = bp;
 827                        *entno = mid;
 828                        if (cmp == XFS_CMP_EXACT)
 829                                return 0;
 830                }
 831        } while (++mid < be32_to_cpu(btp->count) &&
 832                        be32_to_cpu(blp[mid].hashval) == hash);
 833
 834        ASSERT(args->op_flags & XFS_DA_OP_OKNOENT);
 835        /*
 836         * Here, we can only be doing a lookup (not a rename or replace).
 837         * If a case-insensitive match was found earlier, return success.
 838         */
 839        if (args->cmpresult == XFS_CMP_CASE)
 840                return 0;
 841        /*
 842         * No match, release the buffer and return ENOENT.
 843         */
 844        xfs_trans_brelse(tp, bp);
 845        return XFS_ERROR(ENOENT);
 846}
 847
 848/*
 849 * Remove an entry from a block format directory.
 850 * If that makes the block small enough to fit in shortform, transform it.
 851 */
 852int                                             /* error */
 853xfs_dir2_block_removename(
 854        xfs_da_args_t           *args)          /* directory operation args */
 855{
 856        xfs_dir2_data_hdr_t     *hdr;           /* block header */
 857        xfs_dir2_leaf_entry_t   *blp;           /* block leaf pointer */
 858        struct xfs_buf          *bp;            /* block buffer */
 859        xfs_dir2_block_tail_t   *btp;           /* block tail */
 860        xfs_dir2_data_entry_t   *dep;           /* block data entry */
 861        xfs_inode_t             *dp;            /* incore inode */
 862        int                     ent;            /* block leaf entry index */
 863        int                     error;          /* error return value */
 864        xfs_mount_t             *mp;            /* filesystem mount point */
 865        int                     needlog;        /* need to log block header */
 866        int                     needscan;       /* need to fixup bestfree */
 867        xfs_dir2_sf_hdr_t       sfh;            /* shortform header */
 868        int                     size;           /* shortform size */
 869        xfs_trans_t             *tp;            /* transaction pointer */
 870
 871        trace_xfs_dir2_block_removename(args);
 872
 873        /*
 874         * Look up the entry in the block.  Gets the buffer and entry index.
 875         * It will always be there, the vnodeops level does a lookup first.
 876         */
 877        if ((error = xfs_dir2_block_lookup_int(args, &bp, &ent))) {
 878                return error;
 879        }
 880        dp = args->dp;
 881        tp = args->trans;
 882        mp = dp->i_mount;
 883        hdr = bp->b_addr;
 884        btp = xfs_dir2_block_tail_p(mp, hdr);
 885        blp = xfs_dir2_block_leaf_p(btp);
 886        /*
 887         * Point to the data entry using the leaf entry.
 888         */
 889        dep = (xfs_dir2_data_entry_t *)
 890              ((char *)hdr + xfs_dir2_dataptr_to_off(mp, be32_to_cpu(blp[ent].address)));
 891        /*
 892         * Mark the data entry's space free.
 893         */
 894        needlog = needscan = 0;
 895        xfs_dir2_data_make_free(tp, bp,
 896                (xfs_dir2_data_aoff_t)((char *)dep - (char *)hdr),
 897                xfs_dir2_data_entsize(dep->namelen), &needlog, &needscan);
 898        /*
 899         * Fix up the block tail.
 900         */
 901        be32_add_cpu(&btp->stale, 1);
 902        xfs_dir2_block_log_tail(tp, bp);
 903        /*
 904         * Remove the leaf entry by marking it stale.
 905         */
 906        blp[ent].address = cpu_to_be32(XFS_DIR2_NULL_DATAPTR);
 907        xfs_dir2_block_log_leaf(tp, bp, ent, ent);
 908        /*
 909         * Fix up bestfree, log the header if necessary.
 910         */
 911        if (needscan)
 912                xfs_dir2_data_freescan(mp, hdr, &needlog);
 913        if (needlog)
 914                xfs_dir2_data_log_header(tp, bp);
 915        xfs_dir3_data_check(dp, bp);
 916        /*
 917         * See if the size as a shortform is good enough.
 918         */
 919        size = xfs_dir2_block_sfsize(dp, hdr, &sfh);
 920        if (size > XFS_IFORK_DSIZE(dp))
 921                return 0;
 922
 923        /*
 924         * If it works, do the conversion.
 925         */
 926        return xfs_dir2_block_to_sf(args, bp, size, &sfh);
 927}
 928
 929/*
 930 * Replace an entry in a V2 block directory.
 931 * Change the inode number to the new value.
 932 */
 933int                                             /* error */
 934xfs_dir2_block_replace(
 935        xfs_da_args_t           *args)          /* directory operation args */
 936{
 937        xfs_dir2_data_hdr_t     *hdr;           /* block header */
 938        xfs_dir2_leaf_entry_t   *blp;           /* block leaf entries */
 939        struct xfs_buf          *bp;            /* block buffer */
 940        xfs_dir2_block_tail_t   *btp;           /* block tail */
 941        xfs_dir2_data_entry_t   *dep;           /* block data entry */
 942        xfs_inode_t             *dp;            /* incore inode */
 943        int                     ent;            /* leaf entry index */
 944        int                     error;          /* error return value */
 945        xfs_mount_t             *mp;            /* filesystem mount point */
 946
 947        trace_xfs_dir2_block_replace(args);
 948
 949        /*
 950         * Lookup the entry in the directory.  Get buffer and entry index.
 951         * This will always succeed since the caller has already done a lookup.
 952         */
 953        if ((error = xfs_dir2_block_lookup_int(args, &bp, &ent))) {
 954                return error;
 955        }
 956        dp = args->dp;
 957        mp = dp->i_mount;
 958        hdr = bp->b_addr;
 959        btp = xfs_dir2_block_tail_p(mp, hdr);
 960        blp = xfs_dir2_block_leaf_p(btp);
 961        /*
 962         * Point to the data entry we need to change.
 963         */
 964        dep = (xfs_dir2_data_entry_t *)
 965              ((char *)hdr + xfs_dir2_dataptr_to_off(mp, be32_to_cpu(blp[ent].address)));
 966        ASSERT(be64_to_cpu(dep->inumber) != args->inumber);
 967        /*
 968         * Change the inode number to the new value.
 969         */
 970        dep->inumber = cpu_to_be64(args->inumber);
 971        xfs_dir2_data_log_entry(args->trans, bp, dep);
 972        xfs_dir3_data_check(dp, bp);
 973        return 0;
 974}
 975
 976/*
 977 * Qsort comparison routine for the block leaf entries.
 978 */
 979static int                                      /* sort order */
 980xfs_dir2_block_sort(
 981        const void                      *a,     /* first leaf entry */
 982        const void                      *b)     /* second leaf entry */
 983{
 984        const xfs_dir2_leaf_entry_t     *la;    /* first leaf entry */
 985        const xfs_dir2_leaf_entry_t     *lb;    /* second leaf entry */
 986
 987        la = a;
 988        lb = b;
 989        return be32_to_cpu(la->hashval) < be32_to_cpu(lb->hashval) ? -1 :
 990                (be32_to_cpu(la->hashval) > be32_to_cpu(lb->hashval) ? 1 : 0);
 991}
 992
 993/*
 994 * Convert a V2 leaf directory to a V2 block directory if possible.
 995 */
 996int                                             /* error */
 997xfs_dir2_leaf_to_block(
 998        xfs_da_args_t           *args,          /* operation arguments */
 999        struct xfs_buf          *lbp,           /* leaf buffer */
1000        struct xfs_buf          *dbp)           /* data buffer */
1001{
1002        __be16                  *bestsp;        /* leaf bests table */
1003        xfs_dir2_data_hdr_t     *hdr;           /* block header */
1004        xfs_dir2_block_tail_t   *btp;           /* block tail */
1005        xfs_inode_t             *dp;            /* incore directory inode */
1006        xfs_dir2_data_unused_t  *dup;           /* unused data entry */
1007        int                     error;          /* error return value */
1008        int                     from;           /* leaf from index */
1009        xfs_dir2_leaf_t         *leaf;          /* leaf structure */
1010        xfs_dir2_leaf_entry_t   *lep;           /* leaf entry */
1011        xfs_dir2_leaf_tail_t    *ltp;           /* leaf tail structure */
1012        xfs_mount_t             *mp;            /* file system mount point */
1013        int                     needlog;        /* need to log data header */
1014        int                     needscan;       /* need to scan for bestfree */
1015        xfs_dir2_sf_hdr_t       sfh;            /* shortform header */
1016        int                     size;           /* bytes used */
1017        __be16                  *tagp;          /* end of entry (tag) */
1018        int                     to;             /* block/leaf to index */
1019        xfs_trans_t             *tp;            /* transaction pointer */
1020        struct xfs_dir2_leaf_entry *ents;
1021        struct xfs_dir3_icleaf_hdr leafhdr;
1022
1023        trace_xfs_dir2_leaf_to_block(args);
1024
1025        dp = args->dp;
1026        tp = args->trans;
1027        mp = dp->i_mount;
1028        leaf = lbp->b_addr;
1029        xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
1030        ents = xfs_dir3_leaf_ents_p(leaf);
1031        ltp = xfs_dir2_leaf_tail_p(mp, leaf);
1032
1033        ASSERT(leafhdr.magic == XFS_DIR2_LEAF1_MAGIC ||
1034               leafhdr.magic == XFS_DIR3_LEAF1_MAGIC);
1035        /*
1036         * If there are data blocks other than the first one, take this
1037         * opportunity to remove trailing empty data blocks that may have
1038         * been left behind during no-space-reservation operations.
1039         * These will show up in the leaf bests table.
1040         */
1041        while (dp->i_d.di_size > mp->m_dirblksize) {
1042                int hdrsz;
1043
1044                hdrsz = xfs_dir3_data_hdr_size(xfs_sb_version_hascrc(&mp->m_sb));
1045                bestsp = xfs_dir2_leaf_bests_p(ltp);
1046                if (be16_to_cpu(bestsp[be32_to_cpu(ltp->bestcount) - 1]) ==
1047                                            mp->m_dirblksize - hdrsz) {
1048                        if ((error =
1049                            xfs_dir2_leaf_trim_data(args, lbp,
1050                                    (xfs_dir2_db_t)(be32_to_cpu(ltp->bestcount) - 1))))
1051                                return error;
1052                } else
1053                        return 0;
1054        }
1055        /*
1056         * Read the data block if we don't already have it, give up if it fails.
1057         */
1058        if (!dbp) {
1059                error = xfs_dir3_data_read(tp, dp, mp->m_dirdatablk, -1, &dbp);
1060                if (error)
1061                        return error;
1062        }
1063        hdr = dbp->b_addr;
1064        ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
1065               hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC));
1066
1067        /*
1068         * Size of the "leaf" area in the block.
1069         */
1070        size = (uint)sizeof(xfs_dir2_block_tail_t) +
1071               (uint)sizeof(*lep) * (leafhdr.count - leafhdr.stale);
1072        /*
1073         * Look at the last data entry.
1074         */
1075        tagp = (__be16 *)((char *)hdr + mp->m_dirblksize) - 1;
1076        dup = (xfs_dir2_data_unused_t *)((char *)hdr + be16_to_cpu(*tagp));
1077        /*
1078         * If it's not free or is too short we can't do it.
1079         */
1080        if (be16_to_cpu(dup->freetag) != XFS_DIR2_DATA_FREE_TAG ||
1081            be16_to_cpu(dup->length) < size)
1082                return 0;
1083
1084        /*
1085         * Start converting it to block form.
1086         */
1087        xfs_dir3_block_init(mp, tp, dbp, dp);
1088
1089        needlog = 1;
1090        needscan = 0;
1091        /*
1092         * Use up the space at the end of the block (blp/btp).
1093         */
1094        xfs_dir2_data_use_free(tp, dbp, dup, mp->m_dirblksize - size, size,
1095                &needlog, &needscan);
1096        /*
1097         * Initialize the block tail.
1098         */
1099        btp = xfs_dir2_block_tail_p(mp, hdr);
1100        btp->count = cpu_to_be32(leafhdr.count - leafhdr.stale);
1101        btp->stale = 0;
1102        xfs_dir2_block_log_tail(tp, dbp);
1103        /*
1104         * Initialize the block leaf area.  We compact out stale entries.
1105         */
1106        lep = xfs_dir2_block_leaf_p(btp);
1107        for (from = to = 0; from < leafhdr.count; from++) {
1108                if (ents[from].address == cpu_to_be32(XFS_DIR2_NULL_DATAPTR))
1109                        continue;
1110                lep[to++] = ents[from];
1111        }
1112        ASSERT(to == be32_to_cpu(btp->count));
1113        xfs_dir2_block_log_leaf(tp, dbp, 0, be32_to_cpu(btp->count) - 1);
1114        /*
1115         * Scan the bestfree if we need it and log the data block header.
1116         */
1117        if (needscan)
1118                xfs_dir2_data_freescan(mp, hdr, &needlog);
1119        if (needlog)
1120                xfs_dir2_data_log_header(tp, dbp);
1121        /*
1122         * Pitch the old leaf block.
1123         */
1124        error = xfs_da_shrink_inode(args, mp->m_dirleafblk, lbp);
1125        if (error)
1126                return error;
1127
1128        /*
1129         * Now see if the resulting block can be shrunken to shortform.
1130         */
1131        size = xfs_dir2_block_sfsize(dp, hdr, &sfh);
1132        if (size > XFS_IFORK_DSIZE(dp))
1133                return 0;
1134
1135        return xfs_dir2_block_to_sf(args, dbp, size, &sfh);
1136}
1137
1138/*
1139 * Convert the shortform directory to block form.
1140 */
1141int                                             /* error */
1142xfs_dir2_sf_to_block(
1143        xfs_da_args_t           *args)          /* operation arguments */
1144{
1145        xfs_dir2_db_t           blkno;          /* dir-relative block # (0) */
1146        xfs_dir2_data_hdr_t     *hdr;           /* block header */
1147        xfs_dir2_leaf_entry_t   *blp;           /* block leaf entries */
1148        struct xfs_buf          *bp;            /* block buffer */
1149        xfs_dir2_block_tail_t   *btp;           /* block tail pointer */
1150        xfs_dir2_data_entry_t   *dep;           /* data entry pointer */
1151        xfs_inode_t             *dp;            /* incore directory inode */
1152        int                     dummy;          /* trash */
1153        xfs_dir2_data_unused_t  *dup;           /* unused entry pointer */
1154        int                     endoffset;      /* end of data objects */
1155        int                     error;          /* error return value */
1156        int                     i;              /* index */
1157        xfs_mount_t             *mp;            /* filesystem mount point */
1158        int                     needlog;        /* need to log block header */
1159        int                     needscan;       /* need to scan block freespc */
1160        int                     newoffset;      /* offset from current entry */
1161        int                     offset;         /* target block offset */
1162        xfs_dir2_sf_entry_t     *sfep;          /* sf entry pointer */
1163        xfs_dir2_sf_hdr_t       *oldsfp;        /* old shortform header  */
1164        xfs_dir2_sf_hdr_t       *sfp;           /* shortform header  */
1165        __be16                  *tagp;          /* end of data entry */
1166        xfs_trans_t             *tp;            /* transaction pointer */
1167        struct xfs_name         name;
1168        struct xfs_ifork        *ifp;
1169
1170        trace_xfs_dir2_sf_to_block(args);
1171
1172        dp = args->dp;
1173        tp = args->trans;
1174        mp = dp->i_mount;
1175        ifp = XFS_IFORK_PTR(dp, XFS_DATA_FORK);
1176        ASSERT(ifp->if_flags & XFS_IFINLINE);
1177        /*
1178         * Bomb out if the shortform directory is way too short.
1179         */
1180        if (dp->i_d.di_size < offsetof(xfs_dir2_sf_hdr_t, parent)) {
1181                ASSERT(XFS_FORCED_SHUTDOWN(mp));
1182                return XFS_ERROR(EIO);
1183        }
1184
1185        oldsfp = (xfs_dir2_sf_hdr_t *)ifp->if_u1.if_data;
1186
1187        ASSERT(ifp->if_bytes == dp->i_d.di_size);
1188        ASSERT(ifp->if_u1.if_data != NULL);
1189        ASSERT(dp->i_d.di_size >= xfs_dir2_sf_hdr_size(oldsfp->i8count));
1190        ASSERT(dp->i_d.di_nextents == 0);
1191
1192        /*
1193         * Copy the directory into a temporary buffer.
1194         * Then pitch the incore inode data so we can make extents.
1195         */
1196        sfp = kmem_alloc(ifp->if_bytes, KM_SLEEP);
1197        memcpy(sfp, oldsfp, ifp->if_bytes);
1198
1199        xfs_idata_realloc(dp, -ifp->if_bytes, XFS_DATA_FORK);
1200        xfs_bmap_local_to_extents_empty(dp, XFS_DATA_FORK);
1201        dp->i_d.di_size = 0;
1202
1203        /*
1204         * Add block 0 to the inode.
1205         */
1206        error = xfs_dir2_grow_inode(args, XFS_DIR2_DATA_SPACE, &blkno);
1207        if (error) {
1208                kmem_free(sfp);
1209                return error;
1210        }
1211        /*
1212         * Initialize the data block, then convert it to block format.
1213         */
1214        error = xfs_dir3_data_init(args, blkno, &bp);
1215        if (error) {
1216                kmem_free(sfp);
1217                return error;
1218        }
1219        xfs_dir3_block_init(mp, tp, bp, dp);
1220        hdr = bp->b_addr;
1221
1222        /*
1223         * Compute size of block "tail" area.
1224         */
1225        i = (uint)sizeof(*btp) +
1226            (sfp->count + 2) * (uint)sizeof(xfs_dir2_leaf_entry_t);
1227        /*
1228         * The whole thing is initialized to free by the init routine.
1229         * Say we're using the leaf and tail area.
1230         */
1231        dup = xfs_dir3_data_unused_p(hdr);
1232        needlog = needscan = 0;
1233        xfs_dir2_data_use_free(tp, bp, dup, mp->m_dirblksize - i, i, &needlog,
1234                &needscan);
1235        ASSERT(needscan == 0);
1236        /*
1237         * Fill in the tail.
1238         */
1239        btp = xfs_dir2_block_tail_p(mp, hdr);
1240        btp->count = cpu_to_be32(sfp->count + 2);       /* ., .. */
1241        btp->stale = 0;
1242        blp = xfs_dir2_block_leaf_p(btp);
1243        endoffset = (uint)((char *)blp - (char *)hdr);
1244        /*
1245         * Remove the freespace, we'll manage it.
1246         */
1247        xfs_dir2_data_use_free(tp, bp, dup,
1248                (xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr),
1249                be16_to_cpu(dup->length), &needlog, &needscan);
1250        /*
1251         * Create entry for .
1252         */
1253        dep = xfs_dir3_data_dot_entry_p(hdr);
1254        dep->inumber = cpu_to_be64(dp->i_ino);
1255        dep->namelen = 1;
1256        dep->name[0] = '.';
1257        tagp = xfs_dir2_data_entry_tag_p(dep);
1258        *tagp = cpu_to_be16((char *)dep - (char *)hdr);
1259        xfs_dir2_data_log_entry(tp, bp, dep);
1260        blp[0].hashval = cpu_to_be32(xfs_dir_hash_dot);
1261        blp[0].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(mp,
1262                                (char *)dep - (char *)hdr));
1263        /*
1264         * Create entry for ..
1265         */
1266        dep = xfs_dir3_data_dotdot_entry_p(hdr);
1267        dep->inumber = cpu_to_be64(xfs_dir2_sf_get_parent_ino(sfp));
1268        dep->namelen = 2;
1269        dep->name[0] = dep->name[1] = '.';
1270        tagp = xfs_dir2_data_entry_tag_p(dep);
1271        *tagp = cpu_to_be16((char *)dep - (char *)hdr);
1272        xfs_dir2_data_log_entry(tp, bp, dep);
1273        blp[1].hashval = cpu_to_be32(xfs_dir_hash_dotdot);
1274        blp[1].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(mp,
1275                                (char *)dep - (char *)hdr));
1276        offset = xfs_dir3_data_first_offset(hdr);
1277        /*
1278         * Loop over existing entries, stuff them in.
1279         */
1280        i = 0;
1281        if (!sfp->count)
1282                sfep = NULL;
1283        else
1284                sfep = xfs_dir2_sf_firstentry(sfp);
1285        /*
1286         * Need to preserve the existing offset values in the sf directory.
1287         * Insert holes (unused entries) where necessary.
1288         */
1289        while (offset < endoffset) {
1290                /*
1291                 * sfep is null when we reach the end of the list.
1292                 */
1293                if (sfep == NULL)
1294                        newoffset = endoffset;
1295                else
1296                        newoffset = xfs_dir2_sf_get_offset(sfep);
1297                /*
1298                 * There should be a hole here, make one.
1299                 */
1300                if (offset < newoffset) {
1301                        dup = (xfs_dir2_data_unused_t *)((char *)hdr + offset);
1302                        dup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
1303                        dup->length = cpu_to_be16(newoffset - offset);
1304                        *xfs_dir2_data_unused_tag_p(dup) = cpu_to_be16(
1305                                ((char *)dup - (char *)hdr));
1306                        xfs_dir2_data_log_unused(tp, bp, dup);
1307                        xfs_dir2_data_freeinsert(hdr, dup, &dummy);
1308                        offset += be16_to_cpu(dup->length);
1309                        continue;
1310                }
1311                /*
1312                 * Copy a real entry.
1313                 */
1314                dep = (xfs_dir2_data_entry_t *)((char *)hdr + newoffset);
1315                dep->inumber = cpu_to_be64(xfs_dir2_sfe_get_ino(sfp, sfep));
1316                dep->namelen = sfep->namelen;
1317                memcpy(dep->name, sfep->name, dep->namelen);
1318                tagp = xfs_dir2_data_entry_tag_p(dep);
1319                *tagp = cpu_to_be16((char *)dep - (char *)hdr);
1320                xfs_dir2_data_log_entry(tp, bp, dep);
1321                name.name = sfep->name;
1322                name.len = sfep->namelen;
1323                blp[2 + i].hashval = cpu_to_be32(mp->m_dirnameops->
1324                                                        hashname(&name));
1325                blp[2 + i].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(mp,
1326                                                 (char *)dep - (char *)hdr));
1327                offset = (int)((char *)(tagp + 1) - (char *)hdr);
1328                if (++i == sfp->count)
1329                        sfep = NULL;
1330                else
1331                        sfep = xfs_dir2_sf_nextentry(sfp, sfep);
1332        }
1333        /* Done with the temporary buffer */
1334        kmem_free(sfp);
1335        /*
1336         * Sort the leaf entries by hash value.
1337         */
1338        xfs_sort(blp, be32_to_cpu(btp->count), sizeof(*blp), xfs_dir2_block_sort);
1339        /*
1340         * Log the leaf entry area and tail.
1341         * Already logged the header in data_init, ignore needlog.
1342         */
1343        ASSERT(needscan == 0);
1344        xfs_dir2_block_log_leaf(tp, bp, 0, be32_to_cpu(btp->count) - 1);
1345        xfs_dir2_block_log_tail(tp, bp);
1346        xfs_dir3_data_check(dp, bp);
1347        return 0;
1348}
1349
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.