~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/xfs/xfs_da_btree.c

Version: ~ [ linux-5.9 ] ~ [ linux-5.8.14 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.70 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.150 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.200 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.238 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.238 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Copyright (c) 2000-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_bit.h"
 23 #include "xfs_log.h"
 24 #include "xfs_trans.h"
 25 #include "xfs_sb.h"
 26 #include "xfs_ag.h"
 27 #include "xfs_mount.h"
 28 #include "xfs_da_btree.h"
 29 #include "xfs_bmap_btree.h"
 30 #include "xfs_dir2.h"
 31 #include "xfs_dir2_format.h"
 32 #include "xfs_dir2_priv.h"
 33 #include "xfs_dinode.h"
 34 #include "xfs_inode.h"
 35 #include "xfs_inode_item.h"
 36 #include "xfs_alloc.h"
 37 #include "xfs_bmap.h"
 38 #include "xfs_attr.h"
 39 #include "xfs_attr_leaf.h"
 40 #include "xfs_error.h"
 41 #include "xfs_trace.h"
 42 #include "xfs_cksum.h"
 43 #include "xfs_buf_item.h"
 44 
 45 /*
 46  * xfs_da_btree.c
 47  *
 48  * Routines to implement directories as Btrees of hashed names.
 49  */
 50 
 51 /*========================================================================
 52  * Function prototypes for the kernel.
 53  *========================================================================*/
 54 
 55 /*
 56  * Routines used for growing the Btree.
 57  */
 58 STATIC int xfs_da3_root_split(xfs_da_state_t *state,
 59                                             xfs_da_state_blk_t *existing_root,
 60                                             xfs_da_state_blk_t *new_child);
 61 STATIC int xfs_da3_node_split(xfs_da_state_t *state,
 62                                             xfs_da_state_blk_t *existing_blk,
 63                                             xfs_da_state_blk_t *split_blk,
 64                                             xfs_da_state_blk_t *blk_to_add,
 65                                             int treelevel,
 66                                             int *result);
 67 STATIC void xfs_da3_node_rebalance(xfs_da_state_t *state,
 68                                          xfs_da_state_blk_t *node_blk_1,
 69                                          xfs_da_state_blk_t *node_blk_2);
 70 STATIC void xfs_da3_node_add(xfs_da_state_t *state,
 71                                    xfs_da_state_blk_t *old_node_blk,
 72                                    xfs_da_state_blk_t *new_node_blk);
 73 
 74 /*
 75  * Routines used for shrinking the Btree.
 76  */
 77 STATIC int xfs_da3_root_join(xfs_da_state_t *state,
 78                                            xfs_da_state_blk_t *root_blk);
 79 STATIC int xfs_da3_node_toosmall(xfs_da_state_t *state, int *retval);
 80 STATIC void xfs_da3_node_remove(xfs_da_state_t *state,
 81                                               xfs_da_state_blk_t *drop_blk);
 82 STATIC void xfs_da3_node_unbalance(xfs_da_state_t *state,
 83                                          xfs_da_state_blk_t *src_node_blk,
 84                                          xfs_da_state_blk_t *dst_node_blk);
 85 
 86 /*
 87  * Utility routines.
 88  */
 89 STATIC int      xfs_da3_blk_unlink(xfs_da_state_t *state,
 90                                   xfs_da_state_blk_t *drop_blk,
 91                                   xfs_da_state_blk_t *save_blk);
 92 
 93 
 94 kmem_zone_t *xfs_da_state_zone; /* anchor for state struct zone */
 95 
 96 /*
 97  * Allocate a dir-state structure.
 98  * We don't put them on the stack since they're large.
 99  */
100 xfs_da_state_t *
101 xfs_da_state_alloc(void)
102 {
103         return kmem_zone_zalloc(xfs_da_state_zone, KM_NOFS);
104 }
105 
106 /*
107  * Kill the altpath contents of a da-state structure.
108  */
109 STATIC void
110 xfs_da_state_kill_altpath(xfs_da_state_t *state)
111 {
112         int     i;
113 
114         for (i = 0; i < state->altpath.active; i++)
115                 state->altpath.blk[i].bp = NULL;
116         state->altpath.active = 0;
117 }
118 
119 /*
120  * Free a da-state structure.
121  */
122 void
123 xfs_da_state_free(xfs_da_state_t *state)
124 {
125         xfs_da_state_kill_altpath(state);
126 #ifdef DEBUG
127         memset((char *)state, 0, sizeof(*state));
128 #endif /* DEBUG */
129         kmem_zone_free(xfs_da_state_zone, state);
130 }
131 
132 void
133 xfs_da3_node_hdr_from_disk(
134         struct xfs_da3_icnode_hdr       *to,
135         struct xfs_da_intnode           *from)
136 {
137         ASSERT(from->hdr.info.magic == cpu_to_be16(XFS_DA_NODE_MAGIC) ||
138                from->hdr.info.magic == cpu_to_be16(XFS_DA3_NODE_MAGIC));
139 
140         if (from->hdr.info.magic == cpu_to_be16(XFS_DA3_NODE_MAGIC)) {
141                 struct xfs_da3_node_hdr *hdr3 = (struct xfs_da3_node_hdr *)from;
142 
143                 to->forw = be32_to_cpu(hdr3->info.hdr.forw);
144                 to->back = be32_to_cpu(hdr3->info.hdr.back);
145                 to->magic = be16_to_cpu(hdr3->info.hdr.magic);
146                 to->count = be16_to_cpu(hdr3->__count);
147                 to->level = be16_to_cpu(hdr3->__level);
148                 return;
149         }
150         to->forw = be32_to_cpu(from->hdr.info.forw);
151         to->back = be32_to_cpu(from->hdr.info.back);
152         to->magic = be16_to_cpu(from->hdr.info.magic);
153         to->count = be16_to_cpu(from->hdr.__count);
154         to->level = be16_to_cpu(from->hdr.__level);
155 }
156 
157 void
158 xfs_da3_node_hdr_to_disk(
159         struct xfs_da_intnode           *to,
160         struct xfs_da3_icnode_hdr       *from)
161 {
162         ASSERT(from->magic == XFS_DA_NODE_MAGIC ||
163                from->magic == XFS_DA3_NODE_MAGIC);
164 
165         if (from->magic == XFS_DA3_NODE_MAGIC) {
166                 struct xfs_da3_node_hdr *hdr3 = (struct xfs_da3_node_hdr *)to;
167 
168                 hdr3->info.hdr.forw = cpu_to_be32(from->forw);
169                 hdr3->info.hdr.back = cpu_to_be32(from->back);
170                 hdr3->info.hdr.magic = cpu_to_be16(from->magic);
171                 hdr3->__count = cpu_to_be16(from->count);
172                 hdr3->__level = cpu_to_be16(from->level);
173                 return;
174         }
175         to->hdr.info.forw = cpu_to_be32(from->forw);
176         to->hdr.info.back = cpu_to_be32(from->back);
177         to->hdr.info.magic = cpu_to_be16(from->magic);
178         to->hdr.__count = cpu_to_be16(from->count);
179         to->hdr.__level = cpu_to_be16(from->level);
180 }
181 
182 static bool
183 xfs_da3_node_verify(
184         struct xfs_buf          *bp)
185 {
186         struct xfs_mount        *mp = bp->b_target->bt_mount;
187         struct xfs_da_intnode   *hdr = bp->b_addr;
188         struct xfs_da3_icnode_hdr ichdr;
189 
190         xfs_da3_node_hdr_from_disk(&ichdr, hdr);
191 
192         if (xfs_sb_version_hascrc(&mp->m_sb)) {
193                 struct xfs_da3_node_hdr *hdr3 = bp->b_addr;
194 
195                 if (ichdr.magic != XFS_DA3_NODE_MAGIC)
196                         return false;
197 
198                 if (!uuid_equal(&hdr3->info.uuid, &mp->m_sb.sb_uuid))
199                         return false;
200                 if (be64_to_cpu(hdr3->info.blkno) != bp->b_bn)
201                         return false;
202         } else {
203                 if (ichdr.magic != XFS_DA_NODE_MAGIC)
204                         return false;
205         }
206         if (ichdr.level == 0)
207                 return false;
208         if (ichdr.level > XFS_DA_NODE_MAXDEPTH)
209                 return false;
210         if (ichdr.count == 0)
211                 return false;
212 
213         /*
214          * we don't know if the node is for and attribute or directory tree,
215          * so only fail if the count is outside both bounds
216          */
217         if (ichdr.count > mp->m_dir_node_ents &&
218             ichdr.count > mp->m_attr_node_ents)
219                 return false;
220 
221         /* XXX: hash order check? */
222 
223         return true;
224 }
225 
226 static void
227 xfs_da3_node_write_verify(
228         struct xfs_buf  *bp)
229 {
230         struct xfs_mount        *mp = bp->b_target->bt_mount;
231         struct xfs_buf_log_item *bip = bp->b_fspriv;
232         struct xfs_da3_node_hdr *hdr3 = bp->b_addr;
233 
234         if (!xfs_da3_node_verify(bp)) {
235                 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
236                 xfs_buf_ioerror(bp, EFSCORRUPTED);
237                 return;
238         }
239 
240         if (!xfs_sb_version_hascrc(&mp->m_sb))
241                 return;
242 
243         if (bip)
244                 hdr3->info.lsn = cpu_to_be64(bip->bli_item.li_lsn);
245 
246         xfs_update_cksum(bp->b_addr, BBTOB(bp->b_length), XFS_DA3_NODE_CRC_OFF);
247 }
248 
249 /*
250  * leaf/node format detection on trees is sketchy, so a node read can be done on
251  * leaf level blocks when detection identifies the tree as a node format tree
252  * incorrectly. In this case, we need to swap the verifier to match the correct
253  * format of the block being read.
254  */
255 static void
256 xfs_da3_node_read_verify(
257         struct xfs_buf          *bp)
258 {
259         struct xfs_mount        *mp = bp->b_target->bt_mount;
260         struct xfs_da_blkinfo   *info = bp->b_addr;
261 
262         switch (be16_to_cpu(info->magic)) {
263                 case XFS_DA3_NODE_MAGIC:
264                         if (!xfs_verify_cksum(bp->b_addr, BBTOB(bp->b_length),
265                                               XFS_DA3_NODE_CRC_OFF))
266                                 break;
267                         /* fall through */
268                 case XFS_DA_NODE_MAGIC:
269                         if (!xfs_da3_node_verify(bp))
270                                 break;
271                         return;
272                 case XFS_ATTR_LEAF_MAGIC:
273                 case XFS_ATTR3_LEAF_MAGIC:
274                         bp->b_ops = &xfs_attr3_leaf_buf_ops;
275                         bp->b_ops->verify_read(bp);
276                         return;
277                 case XFS_DIR2_LEAFN_MAGIC:
278                 case XFS_DIR3_LEAFN_MAGIC:
279                         bp->b_ops = &xfs_dir3_leafn_buf_ops;
280                         bp->b_ops->verify_read(bp);
281                         return;
282                 default:
283                         break;
284         }
285 
286         /* corrupt block */
287         XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
288         xfs_buf_ioerror(bp, EFSCORRUPTED);
289 }
290 
291 const struct xfs_buf_ops xfs_da3_node_buf_ops = {
292         .verify_read = xfs_da3_node_read_verify,
293         .verify_write = xfs_da3_node_write_verify,
294 };
295 
296 int
297 xfs_da3_node_read(
298         struct xfs_trans        *tp,
299         struct xfs_inode        *dp,
300         xfs_dablk_t             bno,
301         xfs_daddr_t             mappedbno,
302         struct xfs_buf          **bpp,
303         int                     which_fork)
304 {
305         int                     err;
306 
307         err = xfs_da_read_buf(tp, dp, bno, mappedbno, bpp,
308                                         which_fork, &xfs_da3_node_buf_ops);
309         if (!err && tp) {
310                 struct xfs_da_blkinfo   *info = (*bpp)->b_addr;
311                 int                     type;
312 
313                 switch (be16_to_cpu(info->magic)) {
314                 case XFS_DA_NODE_MAGIC:
315                 case XFS_DA3_NODE_MAGIC:
316                         type = XFS_BLFT_DA_NODE_BUF;
317                         break;
318                 case XFS_ATTR_LEAF_MAGIC:
319                 case XFS_ATTR3_LEAF_MAGIC:
320                         type = XFS_BLFT_ATTR_LEAF_BUF;
321                         break;
322                 case XFS_DIR2_LEAFN_MAGIC:
323                 case XFS_DIR3_LEAFN_MAGIC:
324                         type = XFS_BLFT_DIR_LEAFN_BUF;
325                         break;
326                 default:
327                         type = 0;
328                         ASSERT(0);
329                         break;
330                 }
331                 xfs_trans_buf_set_type(tp, *bpp, type);
332         }
333         return err;
334 }
335 
336 /*========================================================================
337  * Routines used for growing the Btree.
338  *========================================================================*/
339 
340 /*
341  * Create the initial contents of an intermediate node.
342  */
343 int
344 xfs_da3_node_create(
345         struct xfs_da_args      *args,
346         xfs_dablk_t             blkno,
347         int                     level,
348         struct xfs_buf          **bpp,
349         int                     whichfork)
350 {
351         struct xfs_da_intnode   *node;
352         struct xfs_trans        *tp = args->trans;
353         struct xfs_mount        *mp = tp->t_mountp;
354         struct xfs_da3_icnode_hdr ichdr = {0};
355         struct xfs_buf          *bp;
356         int                     error;
357 
358         trace_xfs_da_node_create(args);
359         ASSERT(level <= XFS_DA_NODE_MAXDEPTH);
360 
361         error = xfs_da_get_buf(tp, args->dp, blkno, -1, &bp, whichfork);
362         if (error)
363                 return(error);
364         bp->b_ops = &xfs_da3_node_buf_ops;
365         xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DA_NODE_BUF);
366         node = bp->b_addr;
367 
368         if (xfs_sb_version_hascrc(&mp->m_sb)) {
369                 struct xfs_da3_node_hdr *hdr3 = bp->b_addr;
370 
371                 ichdr.magic = XFS_DA3_NODE_MAGIC;
372                 hdr3->info.blkno = cpu_to_be64(bp->b_bn);
373                 hdr3->info.owner = cpu_to_be64(args->dp->i_ino);
374                 uuid_copy(&hdr3->info.uuid, &mp->m_sb.sb_uuid);
375         } else {
376                 ichdr.magic = XFS_DA_NODE_MAGIC;
377         }
378         ichdr.level = level;
379 
380         xfs_da3_node_hdr_to_disk(node, &ichdr);
381         xfs_trans_log_buf(tp, bp,
382                 XFS_DA_LOGRANGE(node, &node->hdr, xfs_da3_node_hdr_size(node)));
383 
384         *bpp = bp;
385         return(0);
386 }
387 
388 /*
389  * Split a leaf node, rebalance, then possibly split
390  * intermediate nodes, rebalance, etc.
391  */
392 int                                                     /* error */
393 xfs_da3_split(
394         struct xfs_da_state     *state)
395 {
396         struct xfs_da_state_blk *oldblk;
397         struct xfs_da_state_blk *newblk;
398         struct xfs_da_state_blk *addblk;
399         struct xfs_da_intnode   *node;
400         struct xfs_buf          *bp;
401         int                     max;
402         int                     action;
403         int                     error;
404         int                     i;
405 
406         trace_xfs_da_split(state->args);
407 
408         /*
409          * Walk back up the tree splitting/inserting/adjusting as necessary.
410          * If we need to insert and there isn't room, split the node, then
411          * decide which fragment to insert the new block from below into.
412          * Note that we may split the root this way, but we need more fixup.
413          */
414         max = state->path.active - 1;
415         ASSERT((max >= 0) && (max < XFS_DA_NODE_MAXDEPTH));
416         ASSERT(state->path.blk[max].magic == XFS_ATTR_LEAF_MAGIC ||
417                state->path.blk[max].magic == XFS_DIR2_LEAFN_MAGIC);
418 
419         addblk = &state->path.blk[max];         /* initial dummy value */
420         for (i = max; (i >= 0) && addblk; state->path.active--, i--) {
421                 oldblk = &state->path.blk[i];
422                 newblk = &state->altpath.blk[i];
423 
424                 /*
425                  * If a leaf node then
426                  *     Allocate a new leaf node, then rebalance across them.
427                  * else if an intermediate node then
428                  *     We split on the last layer, must we split the node?
429                  */
430                 switch (oldblk->magic) {
431                 case XFS_ATTR_LEAF_MAGIC:
432                         error = xfs_attr3_leaf_split(state, oldblk, newblk);
433                         if ((error != 0) && (error != ENOSPC)) {
434                                 return(error);  /* GROT: attr is inconsistent */
435                         }
436                         if (!error) {
437                                 addblk = newblk;
438                                 break;
439                         }
440                         /*
441                          * Entry wouldn't fit, split the leaf again.
442                          */
443                         state->extravalid = 1;
444                         if (state->inleaf) {
445                                 state->extraafter = 0;  /* before newblk */
446                                 trace_xfs_attr_leaf_split_before(state->args);
447                                 error = xfs_attr3_leaf_split(state, oldblk,
448                                                             &state->extrablk);
449                         } else {
450                                 state->extraafter = 1;  /* after newblk */
451                                 trace_xfs_attr_leaf_split_after(state->args);
452                                 error = xfs_attr3_leaf_split(state, newblk,
453                                                             &state->extrablk);
454                         }
455                         if (error)
456                                 return(error);  /* GROT: attr inconsistent */
457                         addblk = newblk;
458                         break;
459                 case XFS_DIR2_LEAFN_MAGIC:
460                         error = xfs_dir2_leafn_split(state, oldblk, newblk);
461                         if (error)
462                                 return error;
463                         addblk = newblk;
464                         break;
465                 case XFS_DA_NODE_MAGIC:
466                         error = xfs_da3_node_split(state, oldblk, newblk, addblk,
467                                                          max - i, &action);
468                         addblk->bp = NULL;
469                         if (error)
470                                 return(error);  /* GROT: dir is inconsistent */
471                         /*
472                          * Record the newly split block for the next time thru?
473                          */
474                         if (action)
475                                 addblk = newblk;
476                         else
477                                 addblk = NULL;
478                         break;
479                 }
480 
481                 /*
482                  * Update the btree to show the new hashval for this child.
483                  */
484                 xfs_da3_fixhashpath(state, &state->path);
485         }
486         if (!addblk)
487                 return(0);
488 
489         /*
490          * Split the root node.
491          */
492         ASSERT(state->path.active == 0);
493         oldblk = &state->path.blk[0];
494         error = xfs_da3_root_split(state, oldblk, addblk);
495         if (error) {
496                 addblk->bp = NULL;
497                 return(error);  /* GROT: dir is inconsistent */
498         }
499 
500         /*
501          * Update pointers to the node which used to be block 0 and
502          * just got bumped because of the addition of a new root node.
503          * There might be three blocks involved if a double split occurred,
504          * and the original block 0 could be at any position in the list.
505          *
506          * Note: the magic numbers and sibling pointers are in the same
507          * physical place for both v2 and v3 headers (by design). Hence it
508          * doesn't matter which version of the xfs_da_intnode structure we use
509          * here as the result will be the same using either structure.
510          */
511         node = oldblk->bp->b_addr;
512         if (node->hdr.info.forw) {
513                 if (be32_to_cpu(node->hdr.info.forw) == addblk->blkno) {
514                         bp = addblk->bp;
515                 } else {
516                         ASSERT(state->extravalid);
517                         bp = state->extrablk.bp;
518                 }
519                 node = bp->b_addr;
520                 node->hdr.info.back = cpu_to_be32(oldblk->blkno);
521                 xfs_trans_log_buf(state->args->trans, bp,
522                     XFS_DA_LOGRANGE(node, &node->hdr.info,
523                     sizeof(node->hdr.info)));
524         }
525         node = oldblk->bp->b_addr;
526         if (node->hdr.info.back) {
527                 if (be32_to_cpu(node->hdr.info.back) == addblk->blkno) {
528                         bp = addblk->bp;
529                 } else {
530                         ASSERT(state->extravalid);
531                         bp = state->extrablk.bp;
532                 }
533                 node = bp->b_addr;
534                 node->hdr.info.forw = cpu_to_be32(oldblk->blkno);
535                 xfs_trans_log_buf(state->args->trans, bp,
536                     XFS_DA_LOGRANGE(node, &node->hdr.info,
537                     sizeof(node->hdr.info)));
538         }
539         addblk->bp = NULL;
540         return(0);
541 }
542 
543 /*
544  * Split the root.  We have to create a new root and point to the two
545  * parts (the split old root) that we just created.  Copy block zero to
546  * the EOF, extending the inode in process.
547  */
548 STATIC int                                              /* error */
549 xfs_da3_root_split(
550         struct xfs_da_state     *state,
551         struct xfs_da_state_blk *blk1,
552         struct xfs_da_state_blk *blk2)
553 {
554         struct xfs_da_intnode   *node;
555         struct xfs_da_intnode   *oldroot;
556         struct xfs_da_node_entry *btree;
557         struct xfs_da3_icnode_hdr nodehdr;
558         struct xfs_da_args      *args;
559         struct xfs_buf          *bp;
560         struct xfs_inode        *dp;
561         struct xfs_trans        *tp;
562         struct xfs_mount        *mp;
563         struct xfs_dir2_leaf    *leaf;
564         xfs_dablk_t             blkno;
565         int                     level;
566         int                     error;
567         int                     size;
568 
569         trace_xfs_da_root_split(state->args);
570 
571         /*
572          * Copy the existing (incorrect) block from the root node position
573          * to a free space somewhere.
574          */
575         args = state->args;
576         error = xfs_da_grow_inode(args, &blkno);
577         if (error)
578                 return error;
579 
580         dp = args->dp;
581         tp = args->trans;
582         mp = state->mp;
583         error = xfs_da_get_buf(tp, dp, blkno, -1, &bp, args->whichfork);
584         if (error)
585                 return error;
586         node = bp->b_addr;
587         oldroot = blk1->bp->b_addr;
588         if (oldroot->hdr.info.magic == cpu_to_be16(XFS_DA_NODE_MAGIC) ||
589             oldroot->hdr.info.magic == cpu_to_be16(XFS_DA3_NODE_MAGIC)) {
590                 struct xfs_da3_icnode_hdr nodehdr;
591 
592                 xfs_da3_node_hdr_from_disk(&nodehdr, oldroot);
593                 btree = xfs_da3_node_tree_p(oldroot);
594                 size = (int)((char *)&btree[nodehdr.count] - (char *)oldroot);
595                 level = nodehdr.level;
596 
597                 /*
598                  * we are about to copy oldroot to bp, so set up the type
599                  * of bp while we know exactly what it will be.
600                  */
601                 xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DA_NODE_BUF);
602         } else {
603                 struct xfs_dir3_icleaf_hdr leafhdr;
604                 struct xfs_dir2_leaf_entry *ents;
605 
606                 leaf = (xfs_dir2_leaf_t *)oldroot;
607                 xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
608                 ents = xfs_dir3_leaf_ents_p(leaf);
609 
610                 ASSERT(leafhdr.magic == XFS_DIR2_LEAFN_MAGIC ||
611                        leafhdr.magic == XFS_DIR3_LEAFN_MAGIC);
612                 size = (int)((char *)&ents[leafhdr.count] - (char *)leaf);
613                 level = 0;
614 
615                 /*
616                  * we are about to copy oldroot to bp, so set up the type
617                  * of bp while we know exactly what it will be.
618                  */
619                 xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DIR_LEAFN_BUF);
620         }
621 
622         /*
623          * we can copy most of the information in the node from one block to
624          * another, but for CRC enabled headers we have to make sure that the
625          * block specific identifiers are kept intact. We update the buffer
626          * directly for this.
627          */
628         memcpy(node, oldroot, size);
629         if (oldroot->hdr.info.magic == cpu_to_be16(XFS_DA3_NODE_MAGIC) ||
630             oldroot->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC)) {
631                 struct xfs_da3_intnode *node3 = (struct xfs_da3_intnode *)node;
632 
633                 node3->hdr.info.blkno = cpu_to_be64(bp->b_bn);
634         }
635         xfs_trans_log_buf(tp, bp, 0, size - 1);
636 
637         bp->b_ops = blk1->bp->b_ops;
638         blk1->bp = bp;
639         blk1->blkno = blkno;
640 
641         /*
642          * Set up the new root node.
643          */
644         error = xfs_da3_node_create(args,
645                 (args->whichfork == XFS_DATA_FORK) ? mp->m_dirleafblk : 0,
646                 level + 1, &bp, args->whichfork);
647         if (error)
648                 return error;
649 
650         node = bp->b_addr;
651         xfs_da3_node_hdr_from_disk(&nodehdr, node);
652         btree = xfs_da3_node_tree_p(node);
653         btree[0].hashval = cpu_to_be32(blk1->hashval);
654         btree[0].before = cpu_to_be32(blk1->blkno);
655         btree[1].hashval = cpu_to_be32(blk2->hashval);
656         btree[1].before = cpu_to_be32(blk2->blkno);
657         nodehdr.count = 2;
658         xfs_da3_node_hdr_to_disk(node, &nodehdr);
659 
660 #ifdef DEBUG
661         if (oldroot->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) ||
662             oldroot->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC)) {
663                 ASSERT(blk1->blkno >= mp->m_dirleafblk &&
664                        blk1->blkno < mp->m_dirfreeblk);
665                 ASSERT(blk2->blkno >= mp->m_dirleafblk &&
666                        blk2->blkno < mp->m_dirfreeblk);
667         }
668 #endif
669 
670         /* Header is already logged by xfs_da_node_create */
671         xfs_trans_log_buf(tp, bp,
672                 XFS_DA_LOGRANGE(node, btree, sizeof(xfs_da_node_entry_t) * 2));
673 
674         return 0;
675 }
676 
677 /*
678  * Split the node, rebalance, then add the new entry.
679  */
680 STATIC int                                              /* error */
681 xfs_da3_node_split(
682         struct xfs_da_state     *state,
683         struct xfs_da_state_blk *oldblk,
684         struct xfs_da_state_blk *newblk,
685         struct xfs_da_state_blk *addblk,
686         int                     treelevel,
687         int                     *result)
688 {
689         struct xfs_da_intnode   *node;
690         struct xfs_da3_icnode_hdr nodehdr;
691         xfs_dablk_t             blkno;
692         int                     newcount;
693         int                     error;
694         int                     useextra;
695 
696         trace_xfs_da_node_split(state->args);
697 
698         node = oldblk->bp->b_addr;
699         xfs_da3_node_hdr_from_disk(&nodehdr, node);
700 
701         /*
702          * With V2 dirs the extra block is data or freespace.
703          */
704         useextra = state->extravalid && state->args->whichfork == XFS_ATTR_FORK;
705         newcount = 1 + useextra;
706         /*
707          * Do we have to split the node?
708          */
709         if (nodehdr.count + newcount > state->node_ents) {
710                 /*
711                  * Allocate a new node, add to the doubly linked chain of
712                  * nodes, then move some of our excess entries into it.
713                  */
714                 error = xfs_da_grow_inode(state->args, &blkno);
715                 if (error)
716                         return(error);  /* GROT: dir is inconsistent */
717 
718                 error = xfs_da3_node_create(state->args, blkno, treelevel,
719                                            &newblk->bp, state->args->whichfork);
720                 if (error)
721                         return(error);  /* GROT: dir is inconsistent */
722                 newblk->blkno = blkno;
723                 newblk->magic = XFS_DA_NODE_MAGIC;
724                 xfs_da3_node_rebalance(state, oldblk, newblk);
725                 error = xfs_da3_blk_link(state, oldblk, newblk);
726                 if (error)
727                         return(error);
728                 *result = 1;
729         } else {
730                 *result = 0;
731         }
732 
733         /*
734          * Insert the new entry(s) into the correct block
735          * (updating last hashval in the process).
736          *
737          * xfs_da3_node_add() inserts BEFORE the given index,
738          * and as a result of using node_lookup_int() we always
739          * point to a valid entry (not after one), but a split
740          * operation always results in a new block whose hashvals
741          * FOLLOW the current block.
742          *
743          * If we had double-split op below us, then add the extra block too.
744          */
745         node = oldblk->bp->b_addr;
746         xfs_da3_node_hdr_from_disk(&nodehdr, node);
747         if (oldblk->index <= nodehdr.count) {
748                 oldblk->index++;
749                 xfs_da3_node_add(state, oldblk, addblk);
750                 if (useextra) {
751                         if (state->extraafter)
752                                 oldblk->index++;
753                         xfs_da3_node_add(state, oldblk, &state->extrablk);
754                         state->extravalid = 0;
755                 }
756         } else {
757                 newblk->index++;
758                 xfs_da3_node_add(state, newblk, addblk);
759                 if (useextra) {
760                         if (state->extraafter)
761                                 newblk->index++;
762                         xfs_da3_node_add(state, newblk, &state->extrablk);
763                         state->extravalid = 0;
764                 }
765         }
766 
767         return(0);
768 }
769 
770 /*
771  * Balance the btree elements between two intermediate nodes,
772  * usually one full and one empty.
773  *
774  * NOTE: if blk2 is empty, then it will get the upper half of blk1.
775  */
776 STATIC void
777 xfs_da3_node_rebalance(
778         struct xfs_da_state     *state,
779         struct xfs_da_state_blk *blk1,
780         struct xfs_da_state_blk *blk2)
781 {
782         struct xfs_da_intnode   *node1;
783         struct xfs_da_intnode   *node2;
784         struct xfs_da_intnode   *tmpnode;
785         struct xfs_da_node_entry *btree1;
786         struct xfs_da_node_entry *btree2;
787         struct xfs_da_node_entry *btree_s;
788         struct xfs_da_node_entry *btree_d;
789         struct xfs_da3_icnode_hdr nodehdr1;
790         struct xfs_da3_icnode_hdr nodehdr2;
791         struct xfs_trans        *tp;
792         int                     count;
793         int                     tmp;
794         int                     swap = 0;
795 
796         trace_xfs_da_node_rebalance(state->args);
797 
798         node1 = blk1->bp->b_addr;
799         node2 = blk2->bp->b_addr;
800         xfs_da3_node_hdr_from_disk(&nodehdr1, node1);
801         xfs_da3_node_hdr_from_disk(&nodehdr2, node2);
802         btree1 = xfs_da3_node_tree_p(node1);
803         btree2 = xfs_da3_node_tree_p(node2);
804 
805         /*
806          * Figure out how many entries need to move, and in which direction.
807          * Swap the nodes around if that makes it simpler.
808          */
809         if (nodehdr1.count > 0 && nodehdr2.count > 0 &&
810             ((be32_to_cpu(btree2[0].hashval) < be32_to_cpu(btree1[0].hashval)) ||
811              (be32_to_cpu(btree2[nodehdr2.count - 1].hashval) <
812                         be32_to_cpu(btree1[nodehdr1.count - 1].hashval)))) {
813                 tmpnode = node1;
814                 node1 = node2;
815                 node2 = tmpnode;
816                 xfs_da3_node_hdr_from_disk(&nodehdr1, node1);
817                 xfs_da3_node_hdr_from_disk(&nodehdr2, node2);
818                 btree1 = xfs_da3_node_tree_p(node1);
819                 btree2 = xfs_da3_node_tree_p(node2);
820                 swap = 1;
821         }
822 
823         count = (nodehdr1.count - nodehdr2.count) / 2;
824         if (count == 0)
825                 return;
826         tp = state->args->trans;
827         /*
828          * Two cases: high-to-low and low-to-high.
829          */
830         if (count > 0) {
831                 /*
832                  * Move elements in node2 up to make a hole.
833                  */
834                 tmp = nodehdr2.count;
835                 if (tmp > 0) {
836                         tmp *= (uint)sizeof(xfs_da_node_entry_t);
837                         btree_s = &btree2[0];
838                         btree_d = &btree2[count];
839                         memmove(btree_d, btree_s, tmp);
840                 }
841 
842                 /*
843                  * Move the req'd B-tree elements from high in node1 to
844                  * low in node2.
845                  */
846                 nodehdr2.count += count;
847                 tmp = count * (uint)sizeof(xfs_da_node_entry_t);
848                 btree_s = &btree1[nodehdr1.count - count];
849                 btree_d = &btree2[0];
850                 memcpy(btree_d, btree_s, tmp);
851                 nodehdr1.count -= count;
852         } else {
853                 /*
854                  * Move the req'd B-tree elements from low in node2 to
855                  * high in node1.
856                  */
857                 count = -count;
858                 tmp = count * (uint)sizeof(xfs_da_node_entry_t);
859                 btree_s = &btree2[0];
860                 btree_d = &btree1[nodehdr1.count];
861                 memcpy(btree_d, btree_s, tmp);
862                 nodehdr1.count += count;
863 
864                 xfs_trans_log_buf(tp, blk1->bp,
865                         XFS_DA_LOGRANGE(node1, btree_d, tmp));
866 
867                 /*
868                  * Move elements in node2 down to fill the hole.
869                  */
870                 tmp  = nodehdr2.count - count;
871                 tmp *= (uint)sizeof(xfs_da_node_entry_t);
872                 btree_s = &btree2[count];
873                 btree_d = &btree2[0];
874                 memmove(btree_d, btree_s, tmp);
875                 nodehdr2.count -= count;
876         }
877 
878         /*
879          * Log header of node 1 and all current bits of node 2.
880          */
881         xfs_da3_node_hdr_to_disk(node1, &nodehdr1);
882         xfs_trans_log_buf(tp, blk1->bp,
883                 XFS_DA_LOGRANGE(node1, &node1->hdr,
884                                 xfs_da3_node_hdr_size(node1)));
885 
886         xfs_da3_node_hdr_to_disk(node2, &nodehdr2);
887         xfs_trans_log_buf(tp, blk2->bp,
888                 XFS_DA_LOGRANGE(node2, &node2->hdr,
889                                 xfs_da3_node_hdr_size(node2) +
890                                 (sizeof(btree2[0]) * nodehdr2.count)));
891 
892         /*
893          * Record the last hashval from each block for upward propagation.
894          * (note: don't use the swapped node pointers)
895          */
896         if (swap) {
897                 node1 = blk1->bp->b_addr;
898                 node2 = blk2->bp->b_addr;
899                 xfs_da3_node_hdr_from_disk(&nodehdr1, node1);
900                 xfs_da3_node_hdr_from_disk(&nodehdr2, node2);
901                 btree1 = xfs_da3_node_tree_p(node1);
902                 btree2 = xfs_da3_node_tree_p(node2);
903         }
904         blk1->hashval = be32_to_cpu(btree1[nodehdr1.count - 1].hashval);
905         blk2->hashval = be32_to_cpu(btree2[nodehdr2.count - 1].hashval);
906 
907         /*
908          * Adjust the expected index for insertion.
909          */
910         if (blk1->index >= nodehdr1.count) {
911                 blk2->index = blk1->index - nodehdr1.count;
912                 blk1->index = nodehdr1.count + 1;       /* make it invalid */
913         }
914 }
915 
916 /*
917  * Add a new entry to an intermediate node.
918  */
919 STATIC void
920 xfs_da3_node_add(
921         struct xfs_da_state     *state,
922         struct xfs_da_state_blk *oldblk,
923         struct xfs_da_state_blk *newblk)
924 {
925         struct xfs_da_intnode   *node;
926         struct xfs_da3_icnode_hdr nodehdr;
927         struct xfs_da_node_entry *btree;
928         int                     tmp;
929 
930         trace_xfs_da_node_add(state->args);
931 
932         node = oldblk->bp->b_addr;
933         xfs_da3_node_hdr_from_disk(&nodehdr, node);
934         btree = xfs_da3_node_tree_p(node);
935 
936         ASSERT(oldblk->index >= 0 && oldblk->index <= nodehdr.count);
937         ASSERT(newblk->blkno != 0);
938         if (state->args->whichfork == XFS_DATA_FORK)
939                 ASSERT(newblk->blkno >= state->mp->m_dirleafblk &&
940                        newblk->blkno < state->mp->m_dirfreeblk);
941 
942         /*
943          * We may need to make some room before we insert the new node.
944          */
945         tmp = 0;
946         if (oldblk->index < nodehdr.count) {
947                 tmp = (nodehdr.count - oldblk->index) * (uint)sizeof(*btree);
948                 memmove(&btree[oldblk->index + 1], &btree[oldblk->index], tmp);
949         }
950         btree[oldblk->index].hashval = cpu_to_be32(newblk->hashval);
951         btree[oldblk->index].before = cpu_to_be32(newblk->blkno);
952         xfs_trans_log_buf(state->args->trans, oldblk->bp,
953                 XFS_DA_LOGRANGE(node, &btree[oldblk->index],
954                                 tmp + sizeof(*btree)));
955 
956         nodehdr.count += 1;
957         xfs_da3_node_hdr_to_disk(node, &nodehdr);
958         xfs_trans_log_buf(state->args->trans, oldblk->bp,
959                 XFS_DA_LOGRANGE(node, &node->hdr, xfs_da3_node_hdr_size(node)));
960 
961         /*
962          * Copy the last hash value from the oldblk to propagate upwards.
963          */
964         oldblk->hashval = be32_to_cpu(btree[nodehdr.count - 1].hashval);
965 }
966 
967 /*========================================================================
968  * Routines used for shrinking the Btree.
969  *========================================================================*/
970 
971 /*
972  * Deallocate an empty leaf node, remove it from its parent,
973  * possibly deallocating that block, etc...
974  */
975 int
976 xfs_da3_join(
977         struct xfs_da_state     *state)
978 {
979         struct xfs_da_state_blk *drop_blk;
980         struct xfs_da_state_blk *save_blk;
981         int                     action = 0;
982         int                     error;
983 
984         trace_xfs_da_join(state->args);
985 
986         drop_blk = &state->path.blk[ state->path.active-1 ];
987         save_blk = &state->altpath.blk[ state->path.active-1 ];
988         ASSERT(state->path.blk[0].magic == XFS_DA_NODE_MAGIC);
989         ASSERT(drop_blk->magic == XFS_ATTR_LEAF_MAGIC ||
990                drop_blk->magic == XFS_DIR2_LEAFN_MAGIC);
991 
992         /*
993          * Walk back up the tree joining/deallocating as necessary.
994          * When we stop dropping blocks, break out.
995          */
996         for (  ; state->path.active >= 2; drop_blk--, save_blk--,
997                  state->path.active--) {
998                 /*
999                  * See if we can combine the block with a neighbor.
1000                  *   (action == 0) => no options, just leave
1001                  *   (action == 1) => coalesce, then unlink
1002                  *   (action == 2) => block empty, unlink it
1003                  */
1004                 switch (drop_blk->magic) {
1005                 case XFS_ATTR_LEAF_MAGIC:
1006                         error = xfs_attr3_leaf_toosmall(state, &action);
1007                         if (error)
1008                                 return(error);
1009                         if (action == 0)
1010                                 return(0);
1011                         xfs_attr3_leaf_unbalance(state, drop_blk, save_blk);
1012                         break;
1013                 case XFS_DIR2_LEAFN_MAGIC:
1014                         error = xfs_dir2_leafn_toosmall(state, &action);
1015                         if (error)
1016                                 return error;
1017                         if (action == 0)
1018                                 return 0;
1019                         xfs_dir2_leafn_unbalance(state, drop_blk, save_blk);
1020                         break;
1021                 case XFS_DA_NODE_MAGIC:
1022                         /*
1023                          * Remove the offending node, fixup hashvals,
1024                          * check for a toosmall neighbor.
1025                          */
1026                         xfs_da3_node_remove(state, drop_blk);
1027                         xfs_da3_fixhashpath(state, &state->path);
1028                         error = xfs_da3_node_toosmall(state, &action);
1029                         if (error)
1030                                 return(error);
1031                         if (action == 0)
1032                                 return 0;
1033                         xfs_da3_node_unbalance(state, drop_blk, save_blk);
1034                         break;
1035                 }
1036                 xfs_da3_fixhashpath(state, &state->altpath);
1037                 error = xfs_da3_blk_unlink(state, drop_blk, save_blk);
1038                 xfs_da_state_kill_altpath(state);
1039                 if (error)
1040                         return(error);
1041                 error = xfs_da_shrink_inode(state->args, drop_blk->blkno,
1042                                                          drop_blk->bp);
1043                 drop_blk->bp = NULL;
1044                 if (error)
1045                         return(error);
1046         }
1047         /*
1048          * We joined all the way to the top.  If it turns out that
1049          * we only have one entry in the root, make the child block
1050          * the new root.
1051          */
1052         xfs_da3_node_remove(state, drop_blk);
1053         xfs_da3_fixhashpath(state, &state->path);
1054         error = xfs_da3_root_join(state, &state->path.blk[0]);
1055         return(error);
1056 }
1057 
1058 #ifdef  DEBUG
1059 static void
1060 xfs_da_blkinfo_onlychild_validate(struct xfs_da_blkinfo *blkinfo, __u16 level)
1061 {
1062         __be16  magic = blkinfo->magic;
1063 
1064         if (level == 1) {
1065                 ASSERT(magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) ||
1066                        magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC) ||
1067                        magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC) ||
1068                        magic == cpu_to_be16(XFS_ATTR3_LEAF_MAGIC));
1069         } else {
1070                 ASSERT(magic == cpu_to_be16(XFS_DA_NODE_MAGIC) ||
1071                        magic == cpu_to_be16(XFS_DA3_NODE_MAGIC));
1072         }
1073         ASSERT(!blkinfo->forw);
1074         ASSERT(!blkinfo->back);
1075 }
1076 #else   /* !DEBUG */
1077 #define xfs_da_blkinfo_onlychild_validate(blkinfo, level)
1078 #endif  /* !DEBUG */
1079 
1080 /*
1081  * We have only one entry in the root.  Copy the only remaining child of
1082  * the old root to block 0 as the new root node.
1083  */
1084 STATIC int
1085 xfs_da3_root_join(
1086         struct xfs_da_state     *state,
1087         struct xfs_da_state_blk *root_blk)
1088 {
1089         struct xfs_da_intnode   *oldroot;
1090         struct xfs_da_args      *args;
1091         xfs_dablk_t             child;
1092         struct xfs_buf          *bp;
1093         struct xfs_da3_icnode_hdr oldroothdr;
1094         struct xfs_da_node_entry *btree;
1095         int                     error;
1096 
1097         trace_xfs_da_root_join(state->args);
1098 
1099         ASSERT(root_blk->magic == XFS_DA_NODE_MAGIC);
1100 
1101         args = state->args;
1102         oldroot = root_blk->bp->b_addr;
1103         xfs_da3_node_hdr_from_disk(&oldroothdr, oldroot);
1104         ASSERT(oldroothdr.forw == 0);
1105         ASSERT(oldroothdr.back == 0);
1106 
1107         /*
1108          * If the root has more than one child, then don't do anything.
1109          */
1110         if (oldroothdr.count > 1)
1111                 return 0;
1112 
1113         /*
1114          * Read in the (only) child block, then copy those bytes into
1115          * the root block's buffer and free the original child block.
1116          */
1117         btree = xfs_da3_node_tree_p(oldroot);
1118         child = be32_to_cpu(btree[0].before);
1119         ASSERT(child != 0);
1120         error = xfs_da3_node_read(args->trans, args->dp, child, -1, &bp,
1121                                              args->whichfork);
1122         if (error)
1123                 return error;
1124         xfs_da_blkinfo_onlychild_validate(bp->b_addr, oldroothdr.level);
1125 
1126         /*
1127          * This could be copying a leaf back into the root block in the case of
1128          * there only being a single leaf block left in the tree. Hence we have
1129          * to update the b_ops pointer as well to match the buffer type change
1130          * that could occur. For dir3 blocks we also need to update the block
1131          * number in the buffer header.
1132          */
1133         memcpy(root_blk->bp->b_addr, bp->b_addr, state->blocksize);
1134         root_blk->bp->b_ops = bp->b_ops;
1135         xfs_trans_buf_copy_type(root_blk->bp, bp);
1136         if (oldroothdr.magic == XFS_DA3_NODE_MAGIC) {
1137                 struct xfs_da3_blkinfo *da3 = root_blk->bp->b_addr;
1138                 da3->blkno = cpu_to_be64(root_blk->bp->b_bn);
1139         }
1140         xfs_trans_log_buf(args->trans, root_blk->bp, 0, state->blocksize - 1);
1141         error = xfs_da_shrink_inode(args, child, bp);
1142         return(error);
1143 }
1144 
1145 /*
1146  * Check a node block and its neighbors to see if the block should be
1147  * collapsed into one or the other neighbor.  Always keep the block
1148  * with the smaller block number.
1149  * If the current block is over 50% full, don't try to join it, return 0.
1150  * If the block is empty, fill in the state structure and return 2.
1151  * If it can be collapsed, fill in the state structure and return 1.
1152  * If nothing can be done, return 0.
1153  */
1154 STATIC int
1155 xfs_da3_node_toosmall(
1156         struct xfs_da_state     *state,
1157         int                     *action)
1158 {
1159         struct xfs_da_intnode   *node;
1160         struct xfs_da_state_blk *blk;
1161         struct xfs_da_blkinfo   *info;
1162         xfs_dablk_t             blkno;
1163         struct xfs_buf          *bp;
1164         struct xfs_da3_icnode_hdr nodehdr;
1165         int                     count;
1166         int                     forward;
1167         int                     error;
1168         int                     retval;
1169         int                     i;
1170 
1171         trace_xfs_da_node_toosmall(state->args);
1172 
1173         /*
1174          * Check for the degenerate case of the block being over 50% full.
1175          * If so, it's not worth even looking to see if we might be able
1176          * to coalesce with a sibling.
1177          */
1178         blk = &state->path.blk[ state->path.active-1 ];
1179         info = blk->bp->b_addr;
1180         node = (xfs_da_intnode_t *)info;
1181         xfs_da3_node_hdr_from_disk(&nodehdr, node);
1182         if (nodehdr.count > (state->node_ents >> 1)) {
1183                 *action = 0;    /* blk over 50%, don't try to join */
1184                 return(0);      /* blk over 50%, don't try to join */
1185         }
1186 
1187         /*
1188          * Check for the degenerate case of the block being empty.
1189          * If the block is empty, we'll simply delete it, no need to
1190          * coalesce it with a sibling block.  We choose (arbitrarily)
1191          * to merge with the forward block unless it is NULL.
1192          */
1193         if (nodehdr.count == 0) {
1194                 /*
1195                  * Make altpath point to the block we want to keep and
1196                  * path point to the block we want to drop (this one).
1197                  */
1198                 forward = (info->forw != 0);
1199                 memcpy(&state->altpath, &state->path, sizeof(state->path));
1200                 error = xfs_da3_path_shift(state, &state->altpath, forward,
1201                                                  0, &retval);
1202                 if (error)
1203                         return(error);
1204                 if (retval) {
1205                         *action = 0;
1206                 } else {
1207                         *action = 2;
1208                 }
1209                 return(0);
1210         }
1211 
1212         /*
1213          * Examine each sibling block to see if we can coalesce with
1214          * at least 25% free space to spare.  We need to figure out
1215          * whether to merge with the forward or the backward block.
1216          * We prefer coalescing with the lower numbered sibling so as
1217          * to shrink a directory over time.
1218          */
1219         count  = state->node_ents;
1220         count -= state->node_ents >> 2;
1221         count -= nodehdr.count;
1222 
1223         /* start with smaller blk num */
1224         forward = nodehdr.forw < nodehdr.back;
1225         for (i = 0; i < 2; forward = !forward, i++) {
1226                 struct xfs_da3_icnode_hdr thdr;
1227                 if (forward)
1228                         blkno = nodehdr.forw;
1229                 else
1230                         blkno = nodehdr.back;
1231                 if (blkno == 0)
1232                         continue;
1233                 error = xfs_da3_node_read(state->args->trans, state->args->dp,
1234                                         blkno, -1, &bp, state->args->whichfork);
1235                 if (error)
1236                         return(error);
1237 
1238                 node = bp->b_addr;
1239                 xfs_da3_node_hdr_from_disk(&thdr, node);
1240                 xfs_trans_brelse(state->args->trans, bp);
1241 
1242                 if (count - thdr.count >= 0)
1243                         break;  /* fits with at least 25% to spare */
1244         }
1245         if (i >= 2) {
1246                 *action = 0;
1247                 return 0;
1248         }
1249 
1250         /*
1251          * Make altpath point to the block we want to keep (the lower
1252          * numbered block) and path point to the block we want to drop.
1253          */
1254         memcpy(&state->altpath, &state->path, sizeof(state->path));
1255         if (blkno < blk->blkno) {
1256                 error = xfs_da3_path_shift(state, &state->altpath, forward,
1257                                                  0, &retval);
1258         } else {
1259                 error = xfs_da3_path_shift(state, &state->path, forward,
1260                                                  0, &retval);
1261         }
1262         if (error)
1263                 return error;
1264         if (retval) {
1265                 *action = 0;
1266                 return 0;
1267         }
1268         *action = 1;
1269         return 0;
1270 }
1271 
1272 /*
1273  * Pick up the last hashvalue from an intermediate node.
1274  */
1275 STATIC uint
1276 xfs_da3_node_lasthash(
1277         struct xfs_buf          *bp,
1278         int                     *count)
1279 {
1280         struct xfs_da_intnode    *node;
1281         struct xfs_da_node_entry *btree;
1282         struct xfs_da3_icnode_hdr nodehdr;
1283 
1284         node = bp->b_addr;
1285         xfs_da3_node_hdr_from_disk(&nodehdr, node);
1286         if (count)
1287                 *count = nodehdr.count;
1288         if (!nodehdr.count)
1289                 return 0;
1290         btree = xfs_da3_node_tree_p(node);
1291         return be32_to_cpu(btree[nodehdr.count - 1].hashval);
1292 }
1293 
1294 /*
1295  * Walk back up the tree adjusting hash values as necessary,
1296  * when we stop making changes, return.
1297  */
1298 void
1299 xfs_da3_fixhashpath(
1300         struct xfs_da_state     *state,
1301         struct xfs_da_state_path *path)
1302 {
1303         struct xfs_da_state_blk *blk;
1304         struct xfs_da_intnode   *node;
1305         struct xfs_da_node_entry *btree;
1306         xfs_dahash_t            lasthash=0;
1307         int                     level;
1308         int                     count;
1309 
1310         trace_xfs_da_fixhashpath(state->args);
1311 
1312         level = path->active-1;
1313         blk = &path->blk[ level ];
1314         switch (blk->magic) {
1315         case XFS_ATTR_LEAF_MAGIC:
1316                 lasthash = xfs_attr_leaf_lasthash(blk->bp, &count);
1317                 if (count == 0)
1318                         return;
1319                 break;
1320         case XFS_DIR2_LEAFN_MAGIC:
1321                 lasthash = xfs_dir2_leafn_lasthash(blk->bp, &count);
1322                 if (count == 0)
1323                         return;
1324                 break;
1325         case XFS_DA_NODE_MAGIC:
1326                 lasthash = xfs_da3_node_lasthash(blk->bp, &count);
1327                 if (count == 0)
1328                         return;
1329                 break;
1330         }
1331         for (blk--, level--; level >= 0; blk--, level--) {
1332                 struct xfs_da3_icnode_hdr nodehdr;
1333 
1334                 node = blk->bp->b_addr;
1335                 xfs_da3_node_hdr_from_disk(&nodehdr, node);
1336                 btree = xfs_da3_node_tree_p(node);
1337                 if (be32_to_cpu(btree[blk->index].hashval) == lasthash)
1338                         break;
1339                 blk->hashval = lasthash;
1340                 btree[blk->index].hashval = cpu_to_be32(lasthash);
1341                 xfs_trans_log_buf(state->args->trans, blk->bp,
1342                                   XFS_DA_LOGRANGE(node, &btree[blk->index],
1343                                                   sizeof(*btree)));
1344 
1345                 lasthash = be32_to_cpu(btree[nodehdr.count - 1].hashval);
1346         }
1347 }
1348 
1349 /*
1350  * Remove an entry from an intermediate node.
1351  */
1352 STATIC void
1353 xfs_da3_node_remove(
1354         struct xfs_da_state     *state,
1355         struct xfs_da_state_blk *drop_blk)
1356 {
1357         struct xfs_da_intnode   *node;
1358         struct xfs_da3_icnode_hdr nodehdr;
1359         struct xfs_da_node_entry *btree;
1360         int                     index;
1361         int                     tmp;
1362 
1363         trace_xfs_da_node_remove(state->args);
1364 
1365         node = drop_blk->bp->b_addr;
1366         xfs_da3_node_hdr_from_disk(&nodehdr, node);
1367         ASSERT(drop_blk->index < nodehdr.count);
1368         ASSERT(drop_blk->index >= 0);
1369 
1370         /*
1371          * Copy over the offending entry, or just zero it out.
1372          */
1373         index = drop_blk->index;
1374         btree = xfs_da3_node_tree_p(node);
1375         if (index < nodehdr.count - 1) {
1376                 tmp  = nodehdr.count - index - 1;
1377                 tmp *= (uint)sizeof(xfs_da_node_entry_t);
1378                 memmove(&btree[index], &btree[index + 1], tmp);
1379                 xfs_trans_log_buf(state->args->trans, drop_blk->bp,
1380                     XFS_DA_LOGRANGE(node, &btree[index], tmp));
1381                 index = nodehdr.count - 1;
1382         }
1383         memset(&btree[index], 0, sizeof(xfs_da_node_entry_t));
1384         xfs_trans_log_buf(state->args->trans, drop_blk->bp,
1385             XFS_DA_LOGRANGE(node, &btree[index], sizeof(btree[index])));
1386         nodehdr.count -= 1;
1387         xfs_da3_node_hdr_to_disk(node, &nodehdr);
1388         xfs_trans_log_buf(state->args->trans, drop_blk->bp,
1389             XFS_DA_LOGRANGE(node, &node->hdr, xfs_da3_node_hdr_size(node)));
1390 
1391         /*
1392          * Copy the last hash value from the block to propagate upwards.
1393          */
1394         drop_blk->hashval = be32_to_cpu(btree[index - 1].hashval);
1395 }
1396 
1397 /*
1398  * Unbalance the elements between two intermediate nodes,
1399  * move all Btree elements from one node into another.
1400  */
1401 STATIC void
1402 xfs_da3_node_unbalance(
1403         struct xfs_da_state     *state,
1404         struct xfs_da_state_blk *drop_blk,
1405         struct xfs_da_state_blk *save_blk)
1406 {
1407         struct xfs_da_intnode   *drop_node;
1408         struct xfs_da_intnode   *save_node;
1409         struct xfs_da_node_entry *drop_btree;
1410         struct xfs_da_node_entry *save_btree;
1411         struct xfs_da3_icnode_hdr drop_hdr;
1412         struct xfs_da3_icnode_hdr save_hdr;
1413         struct xfs_trans        *tp;
1414         int                     sindex;
1415         int                     tmp;
1416 
1417         trace_xfs_da_node_unbalance(state->args);
1418 
1419         drop_node = drop_blk->bp->b_addr;
1420         save_node = save_blk->bp->b_addr;
1421         xfs_da3_node_hdr_from_disk(&drop_hdr, drop_node);
1422         xfs_da3_node_hdr_from_disk(&save_hdr, save_node);
1423         drop_btree = xfs_da3_node_tree_p(drop_node);
1424         save_btree = xfs_da3_node_tree_p(save_node);
1425         tp = state->args->trans;
1426 
1427         /*
1428          * If the dying block has lower hashvals, then move all the
1429          * elements in the remaining block up to make a hole.
1430          */
1431         if ((be32_to_cpu(drop_btree[0].hashval) <
1432                         be32_to_cpu(save_btree[0].hashval)) ||
1433             (be32_to_cpu(drop_btree[drop_hdr.count - 1].hashval) <
1434                         be32_to_cpu(save_btree[save_hdr.count - 1].hashval))) {
1435                 /* XXX: check this - is memmove dst correct? */
1436                 tmp = save_hdr.count * sizeof(xfs_da_node_entry_t);
1437                 memmove(&save_btree[drop_hdr.count], &save_btree[0], tmp);
1438 
1439                 sindex = 0;
1440                 xfs_trans_log_buf(tp, save_blk->bp,
1441                         XFS_DA_LOGRANGE(save_node, &save_btree[0],
1442                                 (save_hdr.count + drop_hdr.count) *
1443                                                 sizeof(xfs_da_node_entry_t)));
1444         } else {
1445                 sindex = save_hdr.count;
1446                 xfs_trans_log_buf(tp, save_blk->bp,
1447                         XFS_DA_LOGRANGE(save_node, &save_btree[sindex],
1448                                 drop_hdr.count * sizeof(xfs_da_node_entry_t)));
1449         }
1450 
1451         /*
1452          * Move all the B-tree elements from drop_blk to save_blk.
1453          */
1454         tmp = drop_hdr.count * (uint)sizeof(xfs_da_node_entry_t);
1455         memcpy(&save_btree[sindex], &drop_btree[0], tmp);
1456         save_hdr.count += drop_hdr.count;
1457 
1458         xfs_da3_node_hdr_to_disk(save_node, &save_hdr);
1459         xfs_trans_log_buf(tp, save_blk->bp,
1460                 XFS_DA_LOGRANGE(save_node, &save_node->hdr,
1461                                 xfs_da3_node_hdr_size(save_node)));
1462 
1463         /*
1464          * Save the last hashval in the remaining block for upward propagation.
1465          */
1466         save_blk->hashval = be32_to_cpu(save_btree[save_hdr.count - 1].hashval);
1467 }
1468 
1469 /*========================================================================
1470  * Routines used for finding things in the Btree.
1471  *========================================================================*/
1472 
1473 /*
1474  * Walk down the Btree looking for a particular filename, filling
1475  * in the state structure as we go.
1476  *
1477  * We will set the state structure to point to each of the elements
1478  * in each of the nodes where either the hashval is or should be.
1479  *
1480  * We support duplicate hashval's so for each entry in the current
1481  * node that could contain the desired hashval, descend.  This is a
1482  * pruned depth-first tree search.
1483  */
1484 int                                                     /* error */
1485 xfs_da3_node_lookup_int(
1486         struct xfs_da_state     *state,
1487         int                     *result)
1488 {
1489         struct xfs_da_state_blk *blk;
1490         struct xfs_da_blkinfo   *curr;
1491         struct xfs_da_intnode   *node;
1492         struct xfs_da_node_entry *btree;
1493         struct xfs_da3_icnode_hdr nodehdr;
1494         struct xfs_da_args      *args;
1495         xfs_dablk_t             blkno;
1496         xfs_dahash_t            hashval;
1497         xfs_dahash_t            btreehashval;
1498         int                     probe;
1499         int                     span;
1500         int                     max;
1501         int                     error;
1502         int                     retval;
1503 
1504         args = state->args;
1505 
1506         /*
1507          * Descend thru the B-tree searching each level for the right
1508          * node to use, until the right hashval is found.
1509          */
1510         blkno = (args->whichfork == XFS_DATA_FORK)? state->mp->m_dirleafblk : 0;
1511         for (blk = &state->path.blk[0], state->path.active = 1;
1512                          state->path.active <= XFS_DA_NODE_MAXDEPTH;
1513                          blk++, state->path.active++) {
1514                 /*
1515                  * Read the next node down in the tree.
1516                  */
1517                 blk->blkno = blkno;
1518                 error = xfs_da3_node_read(args->trans, args->dp, blkno,
1519                                         -1, &blk->bp, args->whichfork);
1520                 if (error) {
1521                         blk->blkno = 0;
1522                         state->path.active--;
1523                         return(error);
1524                 }
1525                 curr = blk->bp->b_addr;
1526                 blk->magic = be16_to_cpu(curr->magic);
1527 
1528                 if (blk->magic == XFS_ATTR_LEAF_MAGIC ||
1529                     blk->magic == XFS_ATTR3_LEAF_MAGIC) {
1530                         blk->magic = XFS_ATTR_LEAF_MAGIC;
1531                         blk->hashval = xfs_attr_leaf_lasthash(blk->bp, NULL);
1532                         break;
1533                 }
1534 
1535                 if (blk->magic == XFS_DIR2_LEAFN_MAGIC ||
1536                     blk->magic == XFS_DIR3_LEAFN_MAGIC) {
1537                         blk->magic = XFS_DIR2_LEAFN_MAGIC;
1538                         blk->hashval = xfs_dir2_leafn_lasthash(blk->bp, NULL);
1539                         break;
1540                 }
1541 
1542                 blk->magic = XFS_DA_NODE_MAGIC;
1543 
1544 
1545                 /*
1546                  * Search an intermediate node for a match.
1547                  */
1548                 node = blk->bp->b_addr;
1549                 xfs_da3_node_hdr_from_disk(&nodehdr, node);
1550                 btree = xfs_da3_node_tree_p(node);
1551 
1552                 max = nodehdr.count;
1553                 blk->hashval = be32_to_cpu(btree[max - 1].hashval);
1554 
1555                 /*
1556                  * Binary search.  (note: small blocks will skip loop)
1557                  */
1558                 probe = span = max / 2;
1559                 hashval = args->hashval;
1560                 while (span > 4) {
1561                         span /= 2;
1562                         btreehashval = be32_to_cpu(btree[probe].hashval);
1563                         if (btreehashval < hashval)
1564                                 probe += span;
1565                         else if (btreehashval > hashval)
1566                                 probe -= span;
1567                         else
1568                                 break;
1569                 }
1570                 ASSERT((probe >= 0) && (probe < max));
1571                 ASSERT((span <= 4) ||
1572                         (be32_to_cpu(btree[probe].hashval) == hashval));
1573 
1574                 /*
1575                  * Since we may have duplicate hashval's, find the first
1576                  * matching hashval in the node.
1577                  */
1578                 while (probe > 0 &&
1579                        be32_to_cpu(btree[probe].hashval) >= hashval) {
1580                         probe--;
1581                 }
1582                 while (probe < max &&
1583                        be32_to_cpu(btree[probe].hashval) < hashval) {
1584                         probe++;
1585                 }
1586 
1587                 /*
1588                  * Pick the right block to descend on.
1589                  */
1590                 if (probe == max) {
1591                         blk->index = max - 1;
1592                         blkno = be32_to_cpu(btree[max - 1].before);
1593                 } else {
1594                         blk->index = probe;
1595                         blkno = be32_to_cpu(btree[probe].before);
1596                 }
1597         }
1598 
1599         /*
1600          * A leaf block that ends in the hashval that we are interested in
1601          * (final hashval == search hashval) means that the next block may
1602          * contain more entries with the same hashval, shift upward to the
1603          * next leaf and keep searching.
1604          */
1605         for (;;) {
1606                 if (blk->magic == XFS_DIR2_LEAFN_MAGIC) {
1607                         retval = xfs_dir2_leafn_lookup_int(blk->bp, args,
1608                                                         &blk->index, state);
1609                 } else if (blk->magic == XFS_ATTR_LEAF_MAGIC) {
1610                         retval = xfs_attr3_leaf_lookup_int(blk->bp, args);
1611                         blk->index = args->index;
1612                         args->blkno = blk->blkno;
1613                 } else {
1614                         ASSERT(0);
1615                         return XFS_ERROR(EFSCORRUPTED);
1616                 }
1617                 if (((retval == ENOENT) || (retval == ENOATTR)) &&
1618                     (blk->hashval == args->hashval)) {
1619                         error = xfs_da3_path_shift(state, &state->path, 1, 1,
1620                                                          &retval);
1621                         if (error)
1622                                 return(error);
1623                         if (retval == 0) {
1624                                 continue;
1625                         } else if (blk->magic == XFS_ATTR_LEAF_MAGIC) {
1626                                 /* path_shift() gives ENOENT */
1627                                 retval = XFS_ERROR(ENOATTR);
1628                         }
1629                 }
1630                 break;
1631         }
1632         *result = retval;
1633         return(0);
1634 }
1635 
1636 /*========================================================================
1637  * Utility routines.
1638  *========================================================================*/
1639 
1640 /*
1641  * Compare two intermediate nodes for "order".
1642  */
1643 STATIC int
1644 xfs_da3_node_order(
1645         struct xfs_buf  *node1_bp,
1646         struct xfs_buf  *node2_bp)
1647 {
1648         struct xfs_da_intnode   *node1;
1649         struct xfs_da_intnode   *node2;
1650         struct xfs_da_node_entry *btree1;
1651         struct xfs_da_node_entry *btree2;
1652         struct xfs_da3_icnode_hdr node1hdr;
1653         struct xfs_da3_icnode_hdr node2hdr;
1654 
1655         node1 = node1_bp->b_addr;
1656         node2 = node2_bp->b_addr;
1657         xfs_da3_node_hdr_from_disk(&node1hdr, node1);
1658         xfs_da3_node_hdr_from_disk(&node2hdr, node2);
1659         btree1 = xfs_da3_node_tree_p(node1);
1660         btree2 = xfs_da3_node_tree_p(node2);
1661 
1662         if (node1hdr.count > 0 && node2hdr.count > 0 &&
1663             ((be32_to_cpu(btree2[0].hashval) < be32_to_cpu(btree1[0].hashval)) ||
1664              (be32_to_cpu(btree2[node2hdr.count - 1].hashval) <
1665               be32_to_cpu(btree1[node1hdr.count - 1].hashval)))) {
1666                 return 1;
1667         }
1668         return 0;
1669 }
1670 
1671 /*
1672  * Link a new block into a doubly linked list of blocks (of whatever type).
1673  */
1674 int                                                     /* error */
1675 xfs_da3_blk_link(
1676         struct xfs_da_state     *state,
1677         struct xfs_da_state_blk *old_blk,
1678         struct xfs_da_state_blk *new_blk)
1679 {
1680         struct xfs_da_blkinfo   *old_info;
1681         struct xfs_da_blkinfo   *new_info;
1682         struct xfs_da_blkinfo   *tmp_info;
1683         struct xfs_da_args      *args;
1684         struct xfs_buf          *bp;
1685         int                     before = 0;
1686         int                     error;
1687 
1688         /*
1689          * Set up environment.
1690          */
1691         args = state->args;
1692         ASSERT(args != NULL);
1693         old_info = old_blk->bp->b_addr;
1694         new_info = new_blk->bp->b_addr;
1695         ASSERT(old_blk->magic == XFS_DA_NODE_MAGIC ||
1696                old_blk->magic == XFS_DIR2_LEAFN_MAGIC ||
1697                old_blk->magic == XFS_ATTR_LEAF_MAGIC);
1698 
1699         switch (old_blk->magic) {
1700         case XFS_ATTR_LEAF_MAGIC:
1701                 before = xfs_attr_leaf_order(old_blk->bp, new_blk->bp);
1702                 break;
1703         case XFS_DIR2_LEAFN_MAGIC:
1704                 before = xfs_dir2_leafn_order(old_blk->bp, new_blk->bp);
1705                 break;
1706         case XFS_DA_NODE_MAGIC:
1707                 before = xfs_da3_node_order(old_blk->bp, new_blk->bp);
1708                 break;
1709         }
1710 
1711         /*
1712          * Link blocks in appropriate order.
1713          */
1714         if (before) {
1715                 /*
1716                  * Link new block in before existing block.
1717                  */
1718                 trace_xfs_da_link_before(args);
1719                 new_info->forw = cpu_to_be32(old_blk->blkno);
1720                 new_info->back = old_info->back;
1721                 if (old_info->back) {
1722                         error = xfs_da3_node_read(args->trans, args->dp,
1723                                                 be32_to_cpu(old_info->back),
1724                                                 -1, &bp, args->whichfork);
1725                         if (error)
1726                                 return(error);
1727                         ASSERT(bp != NULL);
1728                         tmp_info = bp->b_addr;
1729                         ASSERT(tmp_info->magic == old_info->magic);
1730                         ASSERT(be32_to_cpu(tmp_info->forw) == old_blk->blkno);
1731                         tmp_info->forw = cpu_to_be32(new_blk->blkno);
1732                         xfs_trans_log_buf(args->trans, bp, 0, sizeof(*tmp_info)-1);
1733                 }
1734                 old_info->back = cpu_to_be32(new_blk->blkno);
1735         } else {
1736                 /*
1737                  * Link new block in after existing block.
1738                  */
1739                 trace_xfs_da_link_after(args);
1740                 new_info->forw = old_info->forw;
1741                 new_info->back = cpu_to_be32(old_blk->blkno);
1742                 if (old_info->forw) {
1743                         error = xfs_da3_node_read(args->trans, args->dp,
1744                                                 be32_to_cpu(old_info->forw),
1745                                                 -1, &bp, args->whichfork);
1746                         if (error)
1747                                 return(error);
1748                         ASSERT(bp != NULL);
1749                         tmp_info = bp->b_addr;
1750                         ASSERT(tmp_info->magic == old_info->magic);
1751                         ASSERT(be32_to_cpu(tmp_info->back) == old_blk->blkno);
1752                         tmp_info->back = cpu_to_be32(new_blk->blkno);
1753                         xfs_trans_log_buf(args->trans, bp, 0, sizeof(*tmp_info)-1);
1754                 }
1755                 old_info->forw = cpu_to_be32(new_blk->blkno);
1756         }
1757 
1758         xfs_trans_log_buf(args->trans, old_blk->bp, 0, sizeof(*tmp_info) - 1);
1759         xfs_trans_log_buf(args->trans, new_blk->bp, 0, sizeof(*tmp_info) - 1);
1760         return(0);
1761 }
1762 
1763 /*
1764  * Unlink a block from a doubly linked list of blocks.
1765  */
1766 STATIC int                                              /* error */
1767 xfs_da3_blk_unlink(
1768         struct xfs_da_state     *state,
1769         struct xfs_da_state_blk *drop_blk,
1770         struct xfs_da_state_blk *save_blk)
1771 {
1772         struct xfs_da_blkinfo   *drop_info;
1773         struct xfs_da_blkinfo   *save_info;
1774         struct xfs_da_blkinfo   *tmp_info;
1775         struct xfs_da_args      *args;
1776         struct xfs_buf          *bp;
1777         int                     error;
1778 
1779         /*
1780          * Set up environment.
1781          */
1782         args = state->args;
1783         ASSERT(args != NULL);
1784         save_info = save_blk->bp->b_addr;
1785         drop_info = drop_blk->bp->b_addr;
1786         ASSERT(save_blk->magic == XFS_DA_NODE_MAGIC ||
1787                save_blk->magic == XFS_DIR2_LEAFN_MAGIC ||
1788                save_blk->magic == XFS_ATTR_LEAF_MAGIC);
1789         ASSERT(save_blk->magic == drop_blk->magic);
1790         ASSERT((be32_to_cpu(save_info->forw) == drop_blk->blkno) ||
1791                (be32_to_cpu(save_info->back) == drop_blk->blkno));
1792         ASSERT((be32_to_cpu(drop_info->forw) == save_blk->blkno) ||
1793                (be32_to_cpu(drop_info->back) == save_blk->blkno));
1794 
1795         /*
1796          * Unlink the leaf block from the doubly linked chain of leaves.
1797          */
1798         if (be32_to_cpu(save_info->back) == drop_blk->blkno) {
1799                 trace_xfs_da_unlink_back(args);
1800                 save_info->back = drop_info->back;
1801                 if (drop_info->back) {
1802                         error = xfs_da3_node_read(args->trans, args->dp,
1803                                                 be32_to_cpu(drop_info->back),
1804                                                 -1, &bp, args->whichfork);
1805                         if (error)
1806                                 return(error);
1807                         ASSERT(bp != NULL);
1808                         tmp_info = bp->b_addr;
1809                         ASSERT(tmp_info->magic == save_info->magic);
1810                         ASSERT(be32_to_cpu(tmp_info->forw) == drop_blk->blkno);
1811                         tmp_info->forw = cpu_to_be32(save_blk->blkno);
1812                         xfs_trans_log_buf(args->trans, bp, 0,
1813                                                     sizeof(*tmp_info) - 1);
1814                 }
1815         } else {
1816                 trace_xfs_da_unlink_forward(args);
1817                 save_info->forw = drop_info->forw;
1818                 if (drop_info->forw) {
1819                         error = xfs_da3_node_read(args->trans, args->dp,
1820                                                 be32_to_cpu(drop_info->forw),
1821                                                 -1, &bp, args->whichfork);
1822                         if (error)
1823                                 return(error);
1824                         ASSERT(bp != NULL);
1825                         tmp_info = bp->b_addr;
1826                         ASSERT(tmp_info->magic == save_info->magic);
1827                         ASSERT(be32_to_cpu(tmp_info->back) == drop_blk->blkno);
1828                         tmp_info->back = cpu_to_be32(save_blk->blkno);
1829                         xfs_trans_log_buf(args->trans, bp, 0,
1830                                                     sizeof(*tmp_info) - 1);
1831                 }
1832         }
1833 
1834         xfs_trans_log_buf(args->trans, save_blk->bp, 0, sizeof(*save_info) - 1);
1835         return(0);
1836 }
1837 
1838 /*
1839  * Move a path "forward" or "!forward" one block at the current level.
1840  *
1841  * This routine will adjust a "path" to point to the next block
1842  * "forward" (higher hashvalues) or "!forward" (lower hashvals) in the
1843  * Btree, including updating pointers to the intermediate nodes between
1844  * the new bottom and the root.
1845  */
1846 int                                                     /* error */
1847 xfs_da3_path_shift(
1848         struct xfs_da_state     *state,
1849         struct xfs_da_state_path *path,
1850         int                     forward,
1851         int                     release,
1852         int                     *result)
1853 {
1854         struct xfs_da_state_blk *blk;
1855         struct xfs_da_blkinfo   *info;
1856         struct xfs_da_intnode   *node;
1857         struct xfs_da_args      *args;
1858         struct xfs_da_node_entry *btree;
1859         struct xfs_da3_icnode_hdr nodehdr;
1860         xfs_dablk_t             blkno = 0;
1861         int                     level;
1862         int                     error;
1863 
1864         trace_xfs_da_path_shift(state->args);
1865 
1866         /*
1867          * Roll up the Btree looking for the first block where our
1868          * current index is not at the edge of the block.  Note that
1869          * we skip the bottom layer because we want the sibling block.
1870          */
1871         args = state->args;
1872         ASSERT(args != NULL);
1873         ASSERT(path != NULL);
1874         ASSERT((path->active > 0) && (path->active < XFS_DA_NODE_MAXDEPTH));
1875         level = (path->active-1) - 1;   /* skip bottom layer in path */
1876         for (blk = &path->blk[level]; level >= 0; blk--, level--) {
1877                 node = blk->bp->b_addr;
1878                 xfs_da3_node_hdr_from_disk(&nodehdr, node);
1879                 btree = xfs_da3_node_tree_p(node);
1880 
1881                 if (forward && (blk->index < nodehdr.count - 1)) {
1882                         blk->index++;
1883                         blkno = be32_to_cpu(btree[blk->index].before);
1884                         break;
1885                 } else if (!forward && (blk->index > 0)) {
1886                         blk->index--;
1887                         blkno = be32_to_cpu(btree[blk->index].before);
1888                         break;
1889                 }
1890         }
1891         if (level < 0) {
1892                 *result = XFS_ERROR(ENOENT);    /* we're out of our tree */
1893                 ASSERT(args->op_flags & XFS_DA_OP_OKNOENT);
1894                 return(0);
1895         }
1896 
1897         /*
1898          * Roll down the edge of the subtree until we reach the
1899          * same depth we were at originally.
1900          */
1901         for (blk++, level++; level < path->active; blk++, level++) {
1902                 /*
1903                  * Release the old block.
1904                  * (if it's dirty, trans won't actually let go)
1905                  */
1906                 if (release)
1907                         xfs_trans_brelse(args->trans, blk->bp);
1908 
1909                 /*
1910                  * Read the next child block.
1911                  */
1912                 blk->blkno = blkno;
1913                 error = xfs_da3_node_read(args->trans, args->dp, blkno, -1,
1914                                         &blk->bp, args->whichfork);
1915                 if (error)
1916                         return(error);
1917                 info = blk->bp->b_addr;
1918                 ASSERT(info->magic == cpu_to_be16(XFS_DA_NODE_MAGIC) ||
1919                        info->magic == cpu_to_be16(XFS_DA3_NODE_MAGIC) ||
1920                        info->magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) ||
1921                        info->magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC) ||
1922                        info->magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC) ||
1923                        info->magic == cpu_to_be16(XFS_ATTR3_LEAF_MAGIC));
1924 
1925 
1926                 /*
1927                  * Note: we flatten the magic number to a single type so we
1928                  * don't have to compare against crc/non-crc types elsewhere.
1929                  */
1930                 switch (be16_to_cpu(info->magic)) {
1931                 case XFS_DA_NODE_MAGIC:
1932                 case XFS_DA3_NODE_MAGIC:
1933                         blk->magic = XFS_DA_NODE_MAGIC;
1934                         node = (xfs_da_intnode_t *)info;
1935                         xfs_da3_node_hdr_from_disk(&nodehdr, node);
1936                         btree = xfs_da3_node_tree_p(node);
1937                         blk->hashval = be32_to_cpu(btree[nodehdr.count - 1].hashval);
1938                         if (forward)
1939                                 blk->index = 0;
1940                         else
1941                                 blk->index = nodehdr.count - 1;
1942                         blkno = be32_to_cpu(btree[blk->index].before);
1943                         break;
1944                 case XFS_ATTR_LEAF_MAGIC:
1945                 case XFS_ATTR3_LEAF_MAGIC:
1946                         blk->magic = XFS_ATTR_LEAF_MAGIC;
1947                         ASSERT(level == path->active-1);
1948                         blk->index = 0;
1949                         blk->hashval = xfs_attr_leaf_lasthash(blk->bp,
1950                                                               NULL);
1951                         break;
1952                 case XFS_DIR2_LEAFN_MAGIC:
1953                 case XFS_DIR3_LEAFN_MAGIC:
1954                         blk->magic = XFS_DIR2_LEAFN_MAGIC;
1955                         ASSERT(level == path->active-1);
1956                         blk->index = 0;
1957                         blk->hashval = xfs_dir2_leafn_lasthash(blk->bp,
1958                                                                NULL);
1959                         break;
1960                 default:
1961                         ASSERT(0);
1962                         break;
1963                 }
1964         }
1965         *result = 0;
1966         return 0;
1967 }
1968 
1969 
1970 /*========================================================================
1971  * Utility routines.
1972  *========================================================================*/
1973 
1974 /*
1975  * Implement a simple hash on a character string.
1976  * Rotate the hash value by 7 bits, then XOR each character in.
1977  * This is implemented with some source-level loop unrolling.
1978  */
1979 xfs_dahash_t
1980 xfs_da_hashname(const __uint8_t *name, int namelen)
1981 {
1982         xfs_dahash_t hash;
1983 
1984         /*
1985          * Do four characters at a time as long as we can.
1986          */
1987         for (hash = 0; namelen >= 4; namelen -= 4, name += 4)
1988                 hash = (name[0] << 21) ^ (name[1] << 14) ^ (name[2] << 7) ^
1989                        (name[3] << 0) ^ rol32(hash, 7 * 4);
1990 
1991         /*
1992          * Now do the rest of the characters.
1993          */
1994         switch (namelen) {
1995         case 3:
1996                 return (name[0] << 14) ^ (name[1] << 7) ^ (name[2] << 0) ^
1997                        rol32(hash, 7 * 3);
1998         case 2:
1999                 return (name[0] << 7) ^ (name[1] << 0) ^ rol32(hash, 7 * 2);
2000         case 1:
2001                 return (name[0] << 0) ^ rol32(hash, 7 * 1);
2002         default: /* case 0: */
2003                 return hash;
2004         }
2005 }
2006 
2007 enum xfs_dacmp
2008 xfs_da_compname(
2009         struct xfs_da_args *args,
2010         const unsigned char *name,
2011         int             len)
2012 {
2013         return (args->namelen == len && memcmp(args->name, name, len) == 0) ?
2014                                         XFS_CMP_EXACT : XFS_CMP_DIFFERENT;
2015 }
2016 
2017 static xfs_dahash_t
2018 xfs_default_hashname(
2019         struct xfs_name *name)
2020 {
2021         return xfs_da_hashname(name->name, name->len);
2022 }
2023 
2024 const struct xfs_nameops xfs_default_nameops = {
2025         .hashname       = xfs_default_hashname,
2026         .compname       = xfs_da_compname
2027 };
2028 
2029 int
2030 xfs_da_grow_inode_int(
2031         struct xfs_da_args      *args,
2032         xfs_fileoff_t           *bno,
2033         int                     count)
2034 {
2035         struct xfs_trans        *tp = args->trans;
2036         struct xfs_inode        *dp = args->dp;
2037         int                     w = args->whichfork;
2038         xfs_drfsbno_t           nblks = dp->i_d.di_nblocks;
2039         struct xfs_bmbt_irec    map, *mapp;
2040         int                     nmap, error, got, i, mapi;
2041 
2042         /*
2043          * Find a spot in the file space to put the new block.
2044          */
2045         error = xfs_bmap_first_unused(tp, dp, count, bno, w);
2046         if (error)
2047                 return error;
2048 
2049         /*
2050          * Try mapping it in one filesystem block.
2051          */
2052         nmap = 1;
2053         ASSERT(args->firstblock != NULL);
2054         error = xfs_bmapi_write(tp, dp, *bno, count,
2055                         xfs_bmapi_aflag(w)|XFS_BMAPI_METADATA|XFS_BMAPI_CONTIG,
2056                         args->firstblock, args->total, &map, &nmap,
2057                         args->flist);
2058         if (error)
2059                 return error;
2060 
2061         ASSERT(nmap <= 1);
2062         if (nmap == 1) {
2063                 mapp = &map;
2064                 mapi = 1;
2065         } else if (nmap == 0 && count > 1) {
2066                 xfs_fileoff_t           b;
2067                 int                     c;
2068 
2069                 /*
2070                  * If we didn't get it and the block might work if fragmented,
2071                  * try without the CONTIG flag.  Loop until we get it all.
2072                  */
2073                 mapp = kmem_alloc(sizeof(*mapp) * count, KM_SLEEP);
2074                 for (b = *bno, mapi = 0; b < *bno + count; ) {
2075                         nmap = MIN(XFS_BMAP_MAX_NMAP, count);
2076                         c = (int)(*bno + count - b);
2077                         error = xfs_bmapi_write(tp, dp, b, c,
2078                                         xfs_bmapi_aflag(w)|XFS_BMAPI_METADATA,
2079                                         args->firstblock, args->total,
2080                                         &mapp[mapi], &nmap, args->flist);
2081                         if (error)
2082                                 goto out_free_map;
2083                         if (nmap < 1)
2084                                 break;
2085                         mapi += nmap;
2086                         b = mapp[mapi - 1].br_startoff +
2087                             mapp[mapi - 1].br_blockcount;
2088                 }
2089         } else {
2090                 mapi = 0;
2091                 mapp = NULL;
2092         }
2093 
2094         /*
2095          * Count the blocks we got, make sure it matches the total.
2096          */
2097         for (i = 0, got = 0; i < mapi; i++)
2098                 got += mapp[i].br_blockcount;
2099         if (got != count || mapp[0].br_startoff != *bno ||
2100             mapp[mapi - 1].br_startoff + mapp[mapi - 1].br_blockcount !=
2101             *bno + count) {
2102                 error = XFS_ERROR(ENOSPC);
2103                 goto out_free_map;
2104         }
2105 
2106         /* account for newly allocated blocks in reserved blocks total */
2107         args->total -= dp->i_d.di_nblocks - nblks;
2108 
2109 out_free_map:
2110         if (mapp != &map)
2111                 kmem_free(mapp);
2112         return error;
2113 }
2114 
2115 /*
2116  * Add a block to the btree ahead of the file.
2117  * Return the new block number to the caller.
2118  */
2119 int
2120 xfs_da_grow_inode(
2121         struct xfs_da_args      *args,
2122         xfs_dablk_t             *new_blkno)
2123 {
2124         xfs_fileoff_t           bno;
2125         int                     count;
2126         int                     error;
2127 
2128         trace_xfs_da_grow_inode(args);
2129 
2130         if (args->whichfork == XFS_DATA_FORK) {
2131                 bno = args->dp->i_mount->m_dirleafblk;
2132                 count = args->dp->i_mount->m_dirblkfsbs;
2133         } else {
2134                 bno = 0;
2135                 count = 1;
2136         }
2137 
2138         error = xfs_da_grow_inode_int(args, &bno, count);
2139         if (!error)
2140                 *new_blkno = (xfs_dablk_t)bno;
2141         return error;
2142 }
2143 
2144 /*
2145  * Ick.  We need to always be able to remove a btree block, even
2146  * if there's no space reservation because the filesystem is full.
2147  * This is called if xfs_bunmapi on a btree block fails due to ENOSPC.
2148  * It swaps the target block with the last block in the file.  The
2149  * last block in the file can always be removed since it can't cause
2150  * a bmap btree split to do that.
2151  */
2152 STATIC int
2153 xfs_da3_swap_lastblock(
2154         struct xfs_da_args      *args,
2155         xfs_dablk_t             *dead_blknop,
2156         struct xfs_buf          **dead_bufp)
2157 {
2158         struct xfs_da_blkinfo   *dead_info;
2159         struct xfs_da_blkinfo   *sib_info;
2160         struct xfs_da_intnode   *par_node;
2161         struct xfs_da_intnode   *dead_node;
2162         struct xfs_dir2_leaf    *dead_leaf2;
2163         struct xfs_da_node_entry *btree;
2164         struct xfs_da3_icnode_hdr par_hdr;
2165         struct xfs_inode        *ip;
2166         struct xfs_trans        *tp;
2167         struct xfs_mount        *mp;
2168         struct xfs_buf          *dead_buf;
2169         struct xfs_buf          *last_buf;
2170         struct xfs_buf          *sib_buf;
2171         struct xfs_buf          *par_buf;
2172         xfs_dahash_t            dead_hash;
2173         xfs_fileoff_t           lastoff;
2174         xfs_dablk_t             dead_blkno;
2175         xfs_dablk_t             last_blkno;
2176         xfs_dablk_t             sib_blkno;
2177         xfs_dablk_t             par_blkno;
2178         int                     error;
2179         int                     w;
2180         int                     entno;
2181         int                     level;
2182         int                     dead_level;
2183 
2184         trace_xfs_da_swap_lastblock(args);
2185 
2186         dead_buf = *dead_bufp;
2187         dead_blkno = *dead_blknop;
2188         tp = args->trans;
2189         ip = args->dp;
2190         w = args->whichfork;
2191         ASSERT(w == XFS_DATA_FORK);
2192         mp = ip->i_mount;
2193         lastoff = mp->m_dirfreeblk;
2194         error = xfs_bmap_last_before(tp, ip, &lastoff, w);
2195         if (error)
2196                 return error;
2197         if (unlikely(lastoff == 0)) {
2198                 XFS_ERROR_REPORT("xfs_da_swap_lastblock(1)", XFS_ERRLEVEL_LOW,
2199                                  mp);
2200                 return XFS_ERROR(EFSCORRUPTED);
2201         }
2202         /*
2203          * Read the last block in the btree space.
2204          */
2205         last_blkno = (xfs_dablk_t)lastoff - mp->m_dirblkfsbs;
2206         error = xfs_da3_node_read(tp, ip, last_blkno, -1, &last_buf, w);
2207         if (error)
2208                 return error;
2209         /*
2210          * Copy the last block into the dead buffer and log it.
2211          */
2212         memcpy(dead_buf->b_addr, last_buf->b_addr, mp->m_dirblksize);
2213         xfs_trans_log_buf(tp, dead_buf, 0, mp->m_dirblksize - 1);
2214         dead_info = dead_buf->b_addr;
2215         /*
2216          * Get values from the moved block.
2217          */
2218         if (dead_info->magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) ||
2219             dead_info->magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC)) {
2220                 struct xfs_dir3_icleaf_hdr leafhdr;
2221                 struct xfs_dir2_leaf_entry *ents;
2222 
2223                 dead_leaf2 = (xfs_dir2_leaf_t *)dead_info;
2224                 xfs_dir3_leaf_hdr_from_disk(&leafhdr, dead_leaf2);
2225                 ents = xfs_dir3_leaf_ents_p(dead_leaf2);
2226                 dead_level = 0;
2227                 dead_hash = be32_to_cpu(ents[leafhdr.count - 1].hashval);
2228         } else {
2229                 struct xfs_da3_icnode_hdr deadhdr;
2230 
2231                 dead_node = (xfs_da_intnode_t *)dead_info;
2232                 xfs_da3_node_hdr_from_disk(&deadhdr, dead_node);
2233                 btree = xfs_da3_node_tree_p(dead_node);
2234                 dead_level = deadhdr.level;
2235                 dead_hash = be32_to_cpu(btree[deadhdr.count - 1].hashval);
2236         }
2237         sib_buf = par_buf = NULL;
2238         /*
2239          * If the moved block has a left sibling, fix up the pointers.
2240          */
2241         if ((sib_blkno = be32_to_cpu(dead_info->back))) {
2242                 error = xfs_da3_node_read(tp, ip, sib_blkno, -1, &sib_buf, w);
2243                 if (error)
2244                         goto done;
2245                 sib_info = sib_buf->b_addr;
2246                 if (unlikely(
2247                     be32_to_cpu(sib_info->forw) != last_blkno ||
2248                     sib_info->magic != dead_info->magic)) {
2249                         XFS_ERROR_REPORT("xfs_da_swap_lastblock(2)",
2250                                          XFS_ERRLEVEL_LOW, mp);
2251                         error = XFS_ERROR(EFSCORRUPTED);
2252                         goto done;
2253                 }
2254                 sib_info->forw = cpu_to_be32(dead_blkno);
2255                 xfs_trans_log_buf(tp, sib_buf,
2256                         XFS_DA_LOGRANGE(sib_info, &sib_info->forw,
2257                                         sizeof(sib_info->forw)));
2258                 sib_buf = NULL;
2259         }
2260         /*
2261          * If the moved block has a right sibling, fix up the pointers.
2262          */
2263         if ((sib_blkno = be32_to_cpu(dead_info->forw))) {
2264                 error = xfs_da3_node_read(tp, ip, sib_blkno, -1, &sib_buf, w);
2265                 if (error)
2266                         goto done;
2267                 sib_info = sib_buf->b_addr;
2268                 if (unlikely(
2269                        be32_to_cpu(sib_info->back) != last_blkno ||
2270                        sib_info->magic != dead_info->magic)) {
2271                         XFS_ERROR_REPORT("xfs_da_swap_lastblock(3)",
2272                                          XFS_ERRLEVEL_LOW, mp);
2273                         error = XFS_ERROR(EFSCORRUPTED);
2274                         goto done;
2275                 }
2276                 sib_info->back = cpu_to_be32(dead_blkno);
2277                 xfs_trans_log_buf(tp, sib_buf,
2278                         XFS_DA_LOGRANGE(sib_info, &sib_info->back,
2279                                         sizeof(sib_info->back)));
2280                 sib_buf = NULL;
2281         }
2282         par_blkno = mp->m_dirleafblk;
2283         level = -1;
2284         /*
2285          * Walk down the tree looking for the parent of the moved block.
2286          */
2287         for (;;) {
2288                 error = xfs_da3_node_read(tp, ip, par_blkno, -1, &par_buf, w);
2289                 if (error)
2290                         goto done;
2291                 par_node = par_buf->b_addr;
2292                 xfs_da3_node_hdr_from_disk(&par_hdr, par_node);
2293                 if (level >= 0 && level != par_hdr.level + 1) {
2294                         XFS_ERROR_REPORT("xfs_da_swap_lastblock(4)",
2295                                          XFS_ERRLEVEL_LOW, mp);
2296                         error = XFS_ERROR(EFSCORRUPTED);
2297                         goto done;
2298                 }
2299                 level = par_hdr.level;
2300                 btree = xfs_da3_node_tree_p(par_node);
2301                 for (entno = 0;
2302                      entno < par_hdr.count &&
2303                      be32_to_cpu(btree[entno].hashval) < dead_hash;
2304                      entno++)
2305                         continue;
2306                 if (entno == par_hdr.count) {
2307                         XFS_ERROR_REPORT("xfs_da_swap_lastblock(5)",
2308                                          XFS_ERRLEVEL_LOW, mp);
2309                         error = XFS_ERROR(EFSCORRUPTED);
2310                         goto done;
2311                 }
2312                 par_blkno = be32_to_cpu(btree[entno].before);
2313                 if (level == dead_level + 1)
2314                         break;
2315                 xfs_trans_brelse(tp, par_buf);
2316                 par_buf = NULL;
2317         }
2318         /*
2319          * We're in the right parent block.
2320          * Look for the right entry.
2321          */
2322         for (;;) {
2323                 for (;
2324                      entno < par_hdr.count &&
2325                      be32_to_cpu(btree[entno].before) != last_blkno;
2326                      entno++)
2327                         continue;
2328                 if (entno < par_hdr.count)
2329                         break;
2330                 par_blkno = par_hdr.forw;
2331                 xfs_trans_brelse(tp, par_buf);
2332                 par_buf = NULL;
2333                 if (unlikely(par_blkno == 0)) {
2334                         XFS_ERROR_REPORT("xfs_da_swap_lastblock(6)",
2335                                          XFS_ERRLEVEL_LOW, mp);
2336                         error = XFS_ERROR(EFSCORRUPTED);
2337                         goto done;
2338                 }
2339                 error = xfs_da3_node_read(tp, ip, par_blkno, -1, &par_buf, w);
2340                 if (error)
2341                         goto done;
2342                 par_node = par_buf->b_addr;
2343                 xfs_da3_node_hdr_from_disk(&par_hdr, par_node);
2344                 if (par_hdr.level != level) {
2345                         XFS_ERROR_REPORT("xfs_da_swap_lastblock(7)",
2346                                          XFS_ERRLEVEL_LOW, mp);
2347                         error = XFS_ERROR(EFSCORRUPTED);
2348                         goto done;
2349                 }
2350                 btree = xfs_da3_node_tree_p(par_node);
2351                 entno = 0;
2352         }
2353         /*
2354          * Update the parent entry pointing to the moved block.
2355          */
2356         btree[entno].before = cpu_to_be32(dead_blkno);
2357         xfs_trans_log_buf(tp, par_buf,
2358                 XFS_DA_LOGRANGE(par_node, &btree[entno].before,
2359                                 sizeof(btree[entno].before)));
2360         *dead_blknop = last_blkno;
2361         *dead_bufp = last_buf;
2362         return 0;
2363 done:
2364         if (par_buf)
2365                 xfs_trans_brelse(tp, par_buf);
2366         if (sib_buf)
2367                 xfs_trans_brelse(tp, sib_buf);
2368         xfs_trans_brelse(tp, last_buf);
2369         return error;
2370 }
2371 
2372 /*
2373  * Remove a btree block from a directory or attribute.
2374  */
2375 int
2376 xfs_da_shrink_inode(
2377         xfs_da_args_t   *args,
2378         xfs_dablk_t     dead_blkno,
2379         struct xfs_buf  *dead_buf)
2380 {
2381         xfs_inode_t *dp;
2382         int done, error, w, count;
2383         xfs_trans_t *tp;
2384         xfs_mount_t *mp;
2385 
2386         trace_xfs_da_shrink_inode(args);
2387 
2388         dp = args->dp;
2389         w = args->whichfork;
2390         tp = args->trans;
2391         mp = dp->i_mount;
2392         if (w == XFS_DATA_FORK)
2393                 count = mp->m_dirblkfsbs;
2394         else
2395                 count = 1;
2396         for (;;) {
2397                 /*
2398                  * Remove extents.  If we get ENOSPC for a dir we have to move
2399                  * the last block to the place we want to kill.
2400                  */
2401                 error = xfs_bunmapi(tp, dp, dead_blkno, count,
2402                                     xfs_bmapi_aflag(w)|XFS_BMAPI_METADATA,
2403                                     0, args->firstblock, args->flist, &done);
2404                 if (error == ENOSPC) {
2405                         if (w != XFS_DATA_FORK)
2406                                 break;
2407                         error = xfs_da3_swap_lastblock(args, &dead_blkno,
2408                                                       &dead_buf);
2409                         if (error)
2410                                 break;
2411                 } else {
2412                         break;
2413                 }
2414         }
2415         xfs_trans_binval(tp, dead_buf);
2416         return error;
2417 }
2418 
2419 /*
2420  * See if the mapping(s) for this btree block are valid, i.e.
2421  * don't contain holes, are logically contiguous, and cover the whole range.
2422  */
2423 STATIC int
2424 xfs_da_map_covers_blocks(
2425         int             nmap,
2426         xfs_bmbt_irec_t *mapp,
2427         xfs_dablk_t     bno,
2428         int             count)
2429 {
2430         int             i;
2431         xfs_fileoff_t   off;
2432 
2433         for (i = 0, off = bno; i < nmap; i++) {
2434                 if (mapp[i].br_startblock == HOLESTARTBLOCK ||
2435                     mapp[i].br_startblock == DELAYSTARTBLOCK) {
2436                         return 0;
2437                 }
2438                 if (off != mapp[i].br_startoff) {
2439                         return 0;
2440                 }
2441                 off += mapp[i].br_blockcount;
2442         }
2443         return off == bno + count;
2444 }
2445 
2446 /*
2447  * Convert a struct xfs_bmbt_irec to a struct xfs_buf_map.
2448  *
2449  * For the single map case, it is assumed that the caller has provided a pointer
2450  * to a valid xfs_buf_map.  For the multiple map case, this function will
2451  * allocate the xfs_buf_map to hold all the maps and replace the caller's single
2452  * map pointer with the allocated map.
2453  */
2454 static int
2455 xfs_buf_map_from_irec(
2456         struct xfs_mount        *mp,
2457         struct xfs_buf_map      **mapp,
2458         unsigned int            *nmaps,
2459         struct xfs_bmbt_irec    *irecs,
2460         unsigned int            nirecs)
2461 {
2462         struct xfs_buf_map      *map;
2463         int                     i;
2464 
2465         ASSERT(*nmaps == 1);
2466         ASSERT(nirecs >= 1);
2467 
2468         if (nirecs > 1) {
2469                 map = kmem_zalloc(nirecs * sizeof(struct xfs_buf_map),
2470                                   KM_SLEEP | KM_NOFS);
2471                 if (!map)
2472                         return ENOMEM;
2473                 *mapp = map;
2474         }
2475 
2476         *nmaps = nirecs;
2477         map = *mapp;
2478         for (i = 0; i < *nmaps; i++) {
2479                 ASSERT(irecs[i].br_startblock != DELAYSTARTBLOCK &&
2480                        irecs[i].br_startblock != HOLESTARTBLOCK);
2481                 map[i].bm_bn = XFS_FSB_TO_DADDR(mp, irecs[i].br_startblock);
2482                 map[i].bm_len = XFS_FSB_TO_BB(mp, irecs[i].br_blockcount);
2483         }
2484         return 0;
2485 }
2486 
2487 /*
2488  * Map the block we are given ready for reading. There are three possible return
2489  * values:
2490  *      -1 - will be returned if we land in a hole and mappedbno == -2 so the
2491  *           caller knows not to execute a subsequent read.
2492  *       0 - if we mapped the block successfully
2493  *      >0 - positive error number if there was an error.
2494  */
2495 static int
2496 xfs_dabuf_map(
2497         struct xfs_trans        *trans,
2498         struct xfs_inode        *dp,
2499         xfs_dablk_t             bno,
2500         xfs_daddr_t             mappedbno,
2501         int                     whichfork,
2502         struct xfs_buf_map      **map,
2503         int                     *nmaps)
2504 {
2505         struct xfs_mount        *mp = dp->i_mount;
2506         int                     nfsb;
2507         int                     error = 0;
2508         struct xfs_bmbt_irec    irec;
2509         struct xfs_bmbt_irec    *irecs = &irec;
2510         int                     nirecs;
2511 
2512         ASSERT(map && *map);
2513         ASSERT(*nmaps == 1);
2514 
2515         nfsb = (whichfork == XFS_DATA_FORK) ? mp->m_dirblkfsbs : 1;
2516 
2517         /*
2518          * Caller doesn't have a mapping.  -2 means don't complain
2519          * if we land in a hole.
2520          */
2521         if (mappedbno == -1 || mappedbno == -2) {
2522                 /*
2523                  * Optimize the one-block case.
2524                  */
2525                 if (nfsb != 1)
2526                         irecs = kmem_zalloc(sizeof(irec) * nfsb,
2527                                             KM_SLEEP | KM_NOFS);
2528 
2529                 nirecs = nfsb;
2530                 error = xfs_bmapi_read(dp, (xfs_fileoff_t)bno, nfsb, irecs,
2531                                        &nirecs, xfs_bmapi_aflag(whichfork));
2532                 if (error)
2533                         goto out;
2534         } else {
2535                 irecs->br_startblock = XFS_DADDR_TO_FSB(mp, mappedbno);
2536                 irecs->br_startoff = (xfs_fileoff_t)bno;
2537                 irecs->br_blockcount = nfsb;
2538                 irecs->br_state = 0;
2539                 nirecs = 1;
2540         }
2541 
2542         if (!xfs_da_map_covers_blocks(nirecs, irecs, bno, nfsb)) {
2543                 error = mappedbno == -2 ? -1 : XFS_ERROR(EFSCORRUPTED);
2544                 if (unlikely(error == EFSCORRUPTED)) {
2545                         if (xfs_error_level >= XFS_ERRLEVEL_LOW) {
2546                                 int i;
2547                                 xfs_alert(mp, "%s: bno %lld dir: inode %lld",
2548                                         __func__, (long long)bno,
2549                                         (long long)dp->i_ino);
2550                                 for (i = 0; i < *nmaps; i++) {
2551                                         xfs_alert(mp,
2552 "[%02d] br_startoff %lld br_startblock %lld br_blockcount %lld br_state %d",
2553                                                 i,
2554                                                 (long long)irecs[i].br_startoff,
2555                                                 (long long)irecs[i].br_startblock,
2556                                                 (long long)irecs[i].br_blockcount,
2557                                                 irecs[i].br_state);
2558                                 }
2559                         }
2560                         XFS_ERROR_REPORT("xfs_da_do_buf(1)",
2561                                          XFS_ERRLEVEL_LOW, mp);
2562                 }
2563                 goto out;
2564         }
2565         error = xfs_buf_map_from_irec(mp, map, nmaps, irecs, nirecs);
2566 out:
2567         if (irecs != &irec)
2568                 kmem_free(irecs);
2569         return error;
2570 }
2571 
2572 /*
2573  * Get a buffer for the dir/attr block.
2574  */
2575 int
2576 xfs_da_get_buf(
2577         struct xfs_trans        *trans,
2578         struct xfs_inode        *dp,
2579         xfs_dablk_t             bno,
2580         xfs_daddr_t             mappedbno,
2581         struct xfs_buf          **bpp,
2582         int                     whichfork)
2583 {
2584         struct xfs_buf          *bp;
2585         struct xfs_buf_map      map;
2586         struct xfs_buf_map      *mapp;
2587         int                     nmap;
2588         int                     error;
2589 
2590         *bpp = NULL;
2591         mapp = &map;
2592         nmap = 1;
2593         error = xfs_dabuf_map(trans, dp, bno, mappedbno, whichfork,
2594                                 &mapp, &nmap);
2595         if (error) {
2596                 /* mapping a hole is not an error, but we don't continue */
2597                 if (error == -1)
2598                         error = 0;
2599                 goto out_free;
2600         }
2601 
2602         bp = xfs_trans_get_buf_map(trans, dp->i_mount->m_ddev_targp,
2603                                     mapp, nmap, 0);
2604         error = bp ? bp->b_error : XFS_ERROR(EIO);
2605         if (error) {
2606                 xfs_trans_brelse(trans, bp);
2607                 goto out_free;
2608         }
2609 
2610         *bpp = bp;
2611 
2612 out_free:
2613         if (mapp != &map)
2614                 kmem_free(mapp);
2615 
2616         return error;
2617 }
2618 
2619 /*
2620  * Get a buffer for the dir/attr block, fill in the contents.
2621  */
2622 int
2623 xfs_da_read_buf(
2624         struct xfs_trans        *trans,
2625         struct xfs_inode        *dp,
2626         xfs_dablk_t             bno,
2627         xfs_daddr_t             mappedbno,
2628         struct xfs_buf          **bpp,
2629         int                     whichfork,
2630         const struct xfs_buf_ops *ops)
2631 {
2632         struct xfs_buf          *bp;
2633         struct xfs_buf_map      map;
2634         struct xfs_buf_map      *mapp;
2635         int                     nmap;
2636         int                     error;
2637 
2638         *bpp = NULL;
2639         mapp = &map;
2640         nmap = 1;
2641         error = xfs_dabuf_map(trans, dp, bno, mappedbno, whichfork,
2642                                 &mapp, &nmap);
2643         if (error) {
2644                 /* mapping a hole is not an error, but we don't continue */
2645                 if (error == -1)
2646                         error = 0;
2647                 goto out_free;
2648         }
2649 
2650         error = xfs_trans_read_buf_map(dp->i_mount, trans,
2651                                         dp->i_mount->m_ddev_targp,
2652                                         mapp, nmap, 0, &bp, ops);
2653         if (error)
2654                 goto out_free;
2655 
2656         if (whichfork == XFS_ATTR_FORK)
2657                 xfs_buf_set_ref(bp, XFS_ATTR_BTREE_REF);
2658         else
2659                 xfs_buf_set_ref(bp, XFS_DIR_BTREE_REF);
2660 
2661         /*
2662          * This verification code will be moved to a CRC verification callback
2663          * function so just leave it here unchanged until then.
2664          */
2665         {
2666                 xfs_dir2_data_hdr_t     *hdr = bp->b_addr;
2667                 xfs_dir2_free_t         *free = bp->b_addr;
2668                 xfs_da_blkinfo_t        *info = bp->b_addr;
2669                 uint                    magic, magic1;
2670                 struct xfs_mount        *mp = dp->i_mount;
2671 
2672                 magic = be16_to_cpu(info->magic);
2673                 magic1 = be32_to_cpu(hdr->magic);
2674                 if (unlikely(
2675                     XFS_TEST_ERROR((magic != XFS_DA_NODE_MAGIC) &&
2676                                    (magic != XFS_DA3_NODE_MAGIC) &&
2677                                    (magic != XFS_ATTR_LEAF_MAGIC) &&
2678                                    (magic != XFS_ATTR3_LEAF_MAGIC) &&
2679                                    (magic != XFS_DIR2_LEAF1_MAGIC) &&
2680                                    (magic != XFS_DIR3_LEAF1_MAGIC) &&
2681                                    (magic != XFS_DIR2_LEAFN_MAGIC) &&
2682                                    (magic != XFS_DIR3_LEAFN_MAGIC) &&
2683                                    (magic1 != XFS_DIR2_BLOCK_MAGIC) &&
2684                                    (magic1 != XFS_DIR3_BLOCK_MAGIC) &&
2685                                    (magic1 != XFS_DIR2_DATA_MAGIC) &&
2686                                    (magic1 != XFS_DIR3_DATA_MAGIC) &&
2687                                    (free->hdr.magic !=
2688                                         cpu_to_be32(XFS_DIR2_FREE_MAGIC)) &&
2689                                    (free->hdr.magic !=
2690                                         cpu_to_be32(XFS_DIR3_FREE_MAGIC)),
2691                                 mp, XFS_ERRTAG_DA_READ_BUF,
2692                                 XFS_RANDOM_DA_READ_BUF))) {
2693                         trace_xfs_da_btree_corrupt(bp, _RET_IP_);
2694                         XFS_CORRUPTION_ERROR("xfs_da_do_buf(2)",
2695                                              XFS_ERRLEVEL_LOW, mp, info);
2696                         error = XFS_ERROR(EFSCORRUPTED);
2697                         xfs_trans_brelse(trans, bp);
2698                         goto out_free;
2699                 }
2700         }
2701         *bpp = bp;
2702 out_free:
2703         if (mapp != &map)
2704                 kmem_free(mapp);
2705 
2706         return error;
2707 }
2708 
2709 /*
2710  * Readahead the dir/attr block.
2711  */
2712 xfs_daddr_t
2713 xfs_da_reada_buf(
2714         struct xfs_trans        *trans,
2715         struct xfs_inode        *dp,
2716         xfs_dablk_t             bno,
2717         xfs_daddr_t             mappedbno,
2718         int                     whichfork,
2719         const struct xfs_buf_ops *ops)
2720 {
2721         struct xfs_buf_map      map;
2722         struct xfs_buf_map      *mapp;
2723         int                     nmap;
2724         int                     error;
2725 
2726         mapp = &map;
2727         nmap = 1;
2728         error = xfs_dabuf_map(trans, dp, bno, mappedbno, whichfork,
2729                                 &mapp, &nmap);
2730         if (error) {
2731                 /* mapping a hole is not an error, but we don't continue */
2732                 if (error == -1)
2733                         error = 0;
2734                 goto out_free;
2735         }
2736 
2737         mappedbno = mapp[0].bm_bn;
2738         xfs_buf_readahead_map(dp->i_mount->m_ddev_targp, mapp, nmap, ops);
2739 
2740 out_free:
2741         if (mapp != &map)
2742                 kmem_free(mapp);
2743 
2744         if (error)
2745                 return -1;
2746         return mappedbno;
2747 }
2748 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp