Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0
2 : /*
3 : * Copyright (c) 2000-2005 Silicon Graphics, Inc.
4 : * Copyright (c) 2013 Red Hat, Inc.
5 : * All Rights Reserved.
6 : */
7 : #include "xfs.h"
8 : #include "xfs_fs.h"
9 : #include "xfs_shared.h"
10 : #include "xfs_format.h"
11 : #include "xfs_log_format.h"
12 : #include "xfs_trans_resv.h"
13 : #include "xfs_mount.h"
14 : #include "xfs_inode.h"
15 : #include "xfs_bmap.h"
16 : #include "xfs_dir2.h"
17 : #include "xfs_dir2_priv.h"
18 : #include "xfs_error.h"
19 : #include "xfs_trace.h"
20 : #include "xfs_trans.h"
21 : #include "xfs_buf_item.h"
22 : #include "xfs_log.h"
23 :
24 : /*
25 : * Function declarations.
26 : */
27 : static int xfs_dir2_leafn_add(struct xfs_buf *bp, xfs_da_args_t *args,
28 : int index);
29 : static void xfs_dir2_leafn_rebalance(xfs_da_state_t *state,
30 : xfs_da_state_blk_t *blk1,
31 : xfs_da_state_blk_t *blk2);
32 : static int xfs_dir2_leafn_remove(xfs_da_args_t *args, struct xfs_buf *bp,
33 : int index, xfs_da_state_blk_t *dblk,
34 : int *rval);
35 :
36 : /*
37 : * Convert data space db to the corresponding free db.
38 : */
39 : static xfs_dir2_db_t
40 13027329 : xfs_dir2_db_to_fdb(struct xfs_da_geometry *geo, xfs_dir2_db_t db)
41 : {
42 13027329 : return xfs_dir2_byte_to_db(geo, XFS_DIR2_FREE_OFFSET) +
43 13027329 : (db / geo->free_max_bests);
44 : }
45 :
46 : /*
47 : * Convert data space db to the corresponding index in a free db.
48 : */
49 : static int
50 13027250 : xfs_dir2_db_to_fdindex(struct xfs_da_geometry *geo, xfs_dir2_db_t db)
51 : {
52 13027250 : return db % geo->free_max_bests;
53 : }
54 :
55 : /*
56 : * Check internal consistency of a leafn block.
57 : */
58 : #ifdef DEBUG
59 : static xfs_failaddr_t
60 235766708 : xfs_dir3_leafn_check(
61 : struct xfs_inode *dp,
62 : struct xfs_buf *bp)
63 : {
64 235766708 : struct xfs_dir2_leaf *leaf = bp->b_addr;
65 235766708 : struct xfs_dir3_icleaf_hdr leafhdr;
66 :
67 235766708 : xfs_dir2_leaf_hdr_from_disk(dp->i_mount, &leafhdr, leaf);
68 :
69 235747722 : if (leafhdr.magic == XFS_DIR3_LEAFN_MAGIC) {
70 235747722 : struct xfs_dir3_leaf_hdr *leaf3 = bp->b_addr;
71 235747722 : if (be64_to_cpu(leaf3->info.blkno) != xfs_buf_daddr(bp))
72 0 : return __this_address;
73 0 : } else if (leafhdr.magic != XFS_DIR2_LEAFN_MAGIC)
74 0 : return __this_address;
75 :
76 235747722 : return xfs_dir3_leaf_check_int(dp->i_mount, &leafhdr, leaf, false);
77 : }
78 :
79 : static inline void
80 235752764 : xfs_dir3_leaf_check(
81 : struct xfs_inode *dp,
82 : struct xfs_buf *bp)
83 : {
84 235752764 : xfs_failaddr_t fa;
85 :
86 235752764 : fa = xfs_dir3_leafn_check(dp, bp);
87 235760551 : if (!fa)
88 : return;
89 0 : xfs_corruption_error(__func__, XFS_ERRLEVEL_LOW, dp->i_mount,
90 0 : bp->b_addr, BBTOB(bp->b_length), __FILE__, __LINE__,
91 : fa);
92 0 : ASSERT(0);
93 : }
94 : #else
95 : #define xfs_dir3_leaf_check(dp, bp)
96 : #endif
97 :
98 : static xfs_failaddr_t
99 213041 : xfs_dir3_free_verify(
100 : struct xfs_buf *bp)
101 : {
102 213041 : struct xfs_mount *mp = bp->b_mount;
103 213041 : struct xfs_dir2_free_hdr *hdr = bp->b_addr;
104 :
105 213041 : if (!xfs_verify_magic(bp, hdr->magic))
106 0 : return __this_address;
107 :
108 213041 : if (xfs_has_crc(mp)) {
109 213041 : struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
110 :
111 213041 : if (!uuid_equal(&hdr3->uuid, &mp->m_sb.sb_meta_uuid))
112 0 : return __this_address;
113 213041 : if (be64_to_cpu(hdr3->blkno) != xfs_buf_daddr(bp))
114 0 : return __this_address;
115 213041 : if (!xfs_log_check_lsn(mp, be64_to_cpu(hdr3->lsn)))
116 0 : return __this_address;
117 : }
118 :
119 : /* XXX: should bounds check the xfs_dir3_icfree_hdr here */
120 :
121 : return NULL;
122 : }
123 :
124 : static void
125 40058 : xfs_dir3_free_read_verify(
126 : struct xfs_buf *bp)
127 : {
128 40058 : struct xfs_mount *mp = bp->b_mount;
129 40058 : xfs_failaddr_t fa;
130 :
131 80116 : if (xfs_has_crc(mp) &&
132 : !xfs_buf_verify_cksum(bp, XFS_DIR3_FREE_CRC_OFF))
133 2 : xfs_verifier_error(bp, -EFSBADCRC, __this_address);
134 : else {
135 40056 : fa = xfs_dir3_free_verify(bp);
136 40056 : if (fa)
137 0 : xfs_verifier_error(bp, -EFSCORRUPTED, fa);
138 : }
139 40058 : }
140 :
141 : static void
142 132533 : xfs_dir3_free_write_verify(
143 : struct xfs_buf *bp)
144 : {
145 132533 : struct xfs_mount *mp = bp->b_mount;
146 132533 : struct xfs_buf_log_item *bip = bp->b_log_item;
147 132533 : struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
148 132533 : xfs_failaddr_t fa;
149 :
150 132533 : fa = xfs_dir3_free_verify(bp);
151 132533 : if (fa) {
152 0 : xfs_verifier_error(bp, -EFSCORRUPTED, fa);
153 0 : return;
154 : }
155 :
156 132533 : if (!xfs_has_crc(mp))
157 : return;
158 :
159 132533 : if (bip)
160 132533 : hdr3->lsn = cpu_to_be64(bip->bli_item.li_lsn);
161 :
162 132533 : xfs_buf_update_cksum(bp, XFS_DIR3_FREE_CRC_OFF);
163 : }
164 :
165 : const struct xfs_buf_ops xfs_dir3_free_buf_ops = {
166 : .name = "xfs_dir3_free",
167 : .magic = { cpu_to_be32(XFS_DIR2_FREE_MAGIC),
168 : cpu_to_be32(XFS_DIR3_FREE_MAGIC) },
169 : .verify_read = xfs_dir3_free_read_verify,
170 : .verify_write = xfs_dir3_free_write_verify,
171 : .verify_struct = xfs_dir3_free_verify,
172 : };
173 :
174 : /* Everything ok in the free block header? */
175 : static xfs_failaddr_t
176 40089474 : xfs_dir3_free_header_check(
177 : struct xfs_inode *dp,
178 : xfs_dablk_t fbno,
179 : struct xfs_buf *bp)
180 : {
181 40089474 : struct xfs_mount *mp = dp->i_mount;
182 40089474 : int maxbests = mp->m_dir_geo->free_max_bests;
183 40089474 : unsigned int firstdb;
184 :
185 40089474 : firstdb = (xfs_dir2_da_to_db(mp->m_dir_geo, fbno) -
186 40092702 : xfs_dir2_byte_to_db(mp->m_dir_geo, XFS_DIR2_FREE_OFFSET)) *
187 : maxbests;
188 40091757 : if (xfs_has_crc(mp)) {
189 40091757 : struct xfs_dir3_free_hdr *hdr3 = bp->b_addr;
190 :
191 80183514 : if (be32_to_cpu(hdr3->firstdb) != firstdb)
192 612 : return __this_address;
193 80182324 : if (be32_to_cpu(hdr3->nvalid) > maxbests)
194 0 : return __this_address;
195 80182324 : if (be32_to_cpu(hdr3->nvalid) < be32_to_cpu(hdr3->nused))
196 0 : return __this_address;
197 40091162 : if (be64_to_cpu(hdr3->hdr.owner) != dp->i_ino)
198 2 : return __this_address;
199 : } else {
200 0 : struct xfs_dir2_free_hdr *hdr = bp->b_addr;
201 :
202 0 : if (be32_to_cpu(hdr->firstdb) != firstdb)
203 0 : return __this_address;
204 0 : if (be32_to_cpu(hdr->nvalid) > maxbests)
205 0 : return __this_address;
206 0 : if (be32_to_cpu(hdr->nvalid) < be32_to_cpu(hdr->nused))
207 0 : return __this_address;
208 : }
209 : return NULL;
210 : }
211 :
212 : static int
213 40087415 : __xfs_dir3_free_read(
214 : struct xfs_trans *tp,
215 : struct xfs_inode *dp,
216 : xfs_dablk_t fbno,
217 : unsigned int flags,
218 : struct xfs_buf **bpp)
219 : {
220 40087415 : xfs_failaddr_t fa;
221 40087415 : int err;
222 :
223 40087415 : err = xfs_da_read_buf(tp, dp, fbno, flags, bpp, XFS_DATA_FORK,
224 : &xfs_dir3_free_buf_ops);
225 40092835 : if (err || !*bpp)
226 : return err;
227 :
228 : /* Check things that we can't do in the verifier. */
229 40092633 : fa = xfs_dir3_free_header_check(dp, fbno, *bpp);
230 40092089 : if (fa) {
231 0 : __xfs_buf_mark_corrupt(*bpp, fa);
232 0 : xfs_trans_brelse(tp, *bpp);
233 0 : *bpp = NULL;
234 0 : return -EFSCORRUPTED;
235 : }
236 :
237 : /* try read returns without an error or *bpp if it lands in a hole */
238 40092089 : if (tp)
239 40092089 : xfs_trans_buf_set_type(tp, *bpp, XFS_BLFT_DIR_FREE_BUF);
240 :
241 : return 0;
242 : }
243 :
244 : void
245 53341419 : xfs_dir2_free_hdr_from_disk(
246 : struct xfs_mount *mp,
247 : struct xfs_dir3_icfree_hdr *to,
248 : struct xfs_dir2_free *from)
249 : {
250 53341419 : if (xfs_has_crc(mp)) {
251 53341419 : struct xfs_dir3_free *from3 = (struct xfs_dir3_free *)from;
252 :
253 53341419 : to->magic = be32_to_cpu(from3->hdr.hdr.magic);
254 53341419 : to->firstdb = be32_to_cpu(from3->hdr.firstdb);
255 53341419 : to->nvalid = be32_to_cpu(from3->hdr.nvalid);
256 53341419 : to->nused = be32_to_cpu(from3->hdr.nused);
257 53341419 : to->bests = from3->bests;
258 :
259 53341419 : ASSERT(to->magic == XFS_DIR3_FREE_MAGIC);
260 : } else {
261 0 : to->magic = be32_to_cpu(from->hdr.magic);
262 0 : to->firstdb = be32_to_cpu(from->hdr.firstdb);
263 0 : to->nvalid = be32_to_cpu(from->hdr.nvalid);
264 0 : to->nused = be32_to_cpu(from->hdr.nused);
265 0 : to->bests = from->bests;
266 :
267 0 : ASSERT(to->magic == XFS_DIR2_FREE_MAGIC);
268 : }
269 53341419 : }
270 :
271 : static void
272 48487 : xfs_dir2_free_hdr_to_disk(
273 : struct xfs_mount *mp,
274 : struct xfs_dir2_free *to,
275 : struct xfs_dir3_icfree_hdr *from)
276 : {
277 48487 : if (xfs_has_crc(mp)) {
278 48487 : struct xfs_dir3_free *to3 = (struct xfs_dir3_free *)to;
279 :
280 48487 : ASSERT(from->magic == XFS_DIR3_FREE_MAGIC);
281 :
282 48487 : to3->hdr.hdr.magic = cpu_to_be32(from->magic);
283 48487 : to3->hdr.firstdb = cpu_to_be32(from->firstdb);
284 48487 : to3->hdr.nvalid = cpu_to_be32(from->nvalid);
285 96974 : to3->hdr.nused = cpu_to_be32(from->nused);
286 : } else {
287 0 : ASSERT(from->magic == XFS_DIR2_FREE_MAGIC);
288 :
289 0 : to->hdr.magic = cpu_to_be32(from->magic);
290 0 : to->hdr.firstdb = cpu_to_be32(from->firstdb);
291 0 : to->hdr.nvalid = cpu_to_be32(from->nvalid);
292 0 : to->hdr.nused = cpu_to_be32(from->nused);
293 : }
294 48487 : }
295 :
296 : int
297 41853 : xfs_dir2_free_read(
298 : struct xfs_trans *tp,
299 : struct xfs_inode *dp,
300 : xfs_dablk_t fbno,
301 : struct xfs_buf **bpp)
302 : {
303 11640219 : return __xfs_dir3_free_read(tp, dp, fbno, 0, bpp);
304 : }
305 :
306 : static int
307 : xfs_dir2_free_try_read(
308 : struct xfs_trans *tp,
309 : struct xfs_inode *dp,
310 : xfs_dablk_t fbno,
311 : struct xfs_buf **bpp)
312 : {
313 28450255 : return __xfs_dir3_free_read(tp, dp, fbno, XFS_DABUF_MAP_HOLE_OK, bpp);
314 : }
315 :
316 : static int
317 1726 : xfs_dir3_free_get_buf(
318 : xfs_da_args_t *args,
319 : xfs_dir2_db_t fbno,
320 : struct xfs_buf **bpp)
321 : {
322 1726 : struct xfs_trans *tp = args->trans;
323 1726 : struct xfs_inode *dp = args->dp;
324 1726 : struct xfs_mount *mp = dp->i_mount;
325 1726 : struct xfs_buf *bp;
326 1726 : int error;
327 1726 : struct xfs_dir3_icfree_hdr hdr;
328 :
329 1726 : error = xfs_da_get_buf(tp, dp, xfs_dir2_db_to_da(args->geo, fbno),
330 : &bp, XFS_DATA_FORK);
331 1726 : if (error)
332 : return error;
333 :
334 1726 : xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DIR_FREE_BUF);
335 1726 : bp->b_ops = &xfs_dir3_free_buf_ops;
336 :
337 : /*
338 : * Initialize the new block to be empty, and remember
339 : * its first slot as our empty slot.
340 : */
341 1726 : memset(bp->b_addr, 0, sizeof(struct xfs_dir3_free_hdr));
342 1726 : memset(&hdr, 0, sizeof(hdr));
343 :
344 1726 : if (xfs_has_crc(mp)) {
345 1726 : struct xfs_dir3_free_hdr *hdr3 = bp->b_addr;
346 :
347 1726 : hdr.magic = XFS_DIR3_FREE_MAGIC;
348 :
349 1726 : hdr3->hdr.blkno = cpu_to_be64(xfs_buf_daddr(bp));
350 1726 : hdr3->hdr.owner = cpu_to_be64(dp->i_ino);
351 1726 : uuid_copy(&hdr3->hdr.uuid, &mp->m_sb.sb_meta_uuid);
352 : } else
353 0 : hdr.magic = XFS_DIR2_FREE_MAGIC;
354 1726 : xfs_dir2_free_hdr_to_disk(mp, bp->b_addr, &hdr);
355 1726 : *bpp = bp;
356 1726 : return 0;
357 : }
358 :
359 : /*
360 : * Log entries from a freespace block.
361 : */
362 : STATIC void
363 25341125 : xfs_dir2_free_log_bests(
364 : struct xfs_da_args *args,
365 : struct xfs_dir3_icfree_hdr *hdr,
366 : struct xfs_buf *bp,
367 : int first, /* first entry to log */
368 : int last) /* last entry to log */
369 : {
370 25341125 : struct xfs_dir2_free *free = bp->b_addr;
371 :
372 25341125 : ASSERT(free->hdr.magic == cpu_to_be32(XFS_DIR2_FREE_MAGIC) ||
373 : free->hdr.magic == cpu_to_be32(XFS_DIR3_FREE_MAGIC));
374 25341125 : xfs_trans_log_buf(args->trans, bp,
375 25341125 : (char *)&hdr->bests[first] - (char *)free,
376 25341125 : (char *)&hdr->bests[last] - (char *)free +
377 : sizeof(hdr->bests[0]) - 1);
378 25340531 : }
379 :
380 : /*
381 : * Log header from a freespace block.
382 : */
383 : static void
384 46761 : xfs_dir2_free_log_header(
385 : struct xfs_da_args *args,
386 : struct xfs_buf *bp)
387 : {
388 : #ifdef DEBUG
389 46761 : xfs_dir2_free_t *free; /* freespace structure */
390 :
391 46761 : free = bp->b_addr;
392 46761 : ASSERT(free->hdr.magic == cpu_to_be32(XFS_DIR2_FREE_MAGIC) ||
393 : free->hdr.magic == cpu_to_be32(XFS_DIR3_FREE_MAGIC));
394 : #endif
395 46761 : xfs_trans_log_buf(args->trans, bp, 0,
396 46761 : args->geo->free_hdr_size - 1);
397 46761 : }
398 :
399 : /*
400 : * Convert a leaf-format directory to a node-format directory.
401 : * We need to change the magic number of the leaf block, and copy
402 : * the freespace table out of the leaf block into its own block.
403 : */
404 : int /* error */
405 1725 : xfs_dir2_leaf_to_node(
406 : xfs_da_args_t *args, /* operation arguments */
407 : struct xfs_buf *lbp) /* leaf buffer */
408 : {
409 1725 : xfs_inode_t *dp; /* incore directory inode */
410 1725 : int error; /* error return value */
411 1725 : struct xfs_buf *fbp; /* freespace buffer */
412 1725 : xfs_dir2_db_t fdb; /* freespace block number */
413 1725 : __be16 *from; /* pointer to freespace entry */
414 1725 : int i; /* leaf freespace index */
415 1725 : xfs_dir2_leaf_t *leaf; /* leaf structure */
416 1725 : xfs_dir2_leaf_tail_t *ltp; /* leaf tail structure */
417 1725 : int n; /* count of live freespc ents */
418 1725 : xfs_dir2_data_off_t off; /* freespace entry value */
419 1725 : xfs_trans_t *tp; /* transaction pointer */
420 1725 : struct xfs_dir3_icfree_hdr freehdr;
421 :
422 1725 : trace_xfs_dir2_leaf_to_node(args);
423 :
424 1725 : dp = args->dp;
425 1725 : tp = args->trans;
426 : /*
427 : * Add a freespace block to the directory.
428 : */
429 1725 : if ((error = xfs_dir2_grow_inode(args, XFS_DIR2_FREE_SPACE, &fdb))) {
430 : return error;
431 : }
432 1723 : ASSERT(fdb == xfs_dir2_byte_to_db(args->geo, XFS_DIR2_FREE_OFFSET));
433 : /*
434 : * Get the buffer for the new freespace block.
435 : */
436 1723 : error = xfs_dir3_free_get_buf(args, fdb, &fbp);
437 1723 : if (error)
438 : return error;
439 :
440 1723 : xfs_dir2_free_hdr_from_disk(dp->i_mount, &freehdr, fbp->b_addr);
441 1723 : leaf = lbp->b_addr;
442 1723 : ltp = xfs_dir2_leaf_tail_p(args->geo, leaf);
443 1723 : if (be32_to_cpu(ltp->bestcount) >
444 3446 : (uint)dp->i_disk_size / args->geo->blksize) {
445 0 : xfs_buf_mark_corrupt(lbp);
446 0 : return -EFSCORRUPTED;
447 : }
448 :
449 : /*
450 : * Copy freespace entries from the leaf block to the new block.
451 : * Count active entries.
452 : */
453 1723 : from = xfs_dir2_leaf_bests_p(ltp);
454 14062 : for (i = n = 0; i < be32_to_cpu(ltp->bestcount); i++, from++) {
455 5308 : off = be16_to_cpu(*from);
456 5308 : if (off != NULLDATAOFF)
457 5305 : n++;
458 10616 : freehdr.bests[i] = cpu_to_be16(off);
459 : }
460 :
461 : /*
462 : * Now initialize the freespace block header.
463 : */
464 1723 : freehdr.nused = n;
465 1723 : freehdr.nvalid = be32_to_cpu(ltp->bestcount);
466 :
467 1723 : xfs_dir2_free_hdr_to_disk(dp->i_mount, fbp->b_addr, &freehdr);
468 1723 : xfs_dir2_free_log_bests(args, &freehdr, fbp, 0, freehdr.nvalid - 1);
469 1723 : xfs_dir2_free_log_header(args, fbp);
470 :
471 : /*
472 : * Converting the leaf to a leafnode is just a matter of changing the
473 : * magic number and the ops. Do the change directly to the buffer as
474 : * it's less work (and less code) than decoding the header to host
475 : * format and back again.
476 : */
477 1723 : if (leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAF1_MAGIC))
478 0 : leaf->hdr.info.magic = cpu_to_be16(XFS_DIR2_LEAFN_MAGIC);
479 : else
480 1723 : leaf->hdr.info.magic = cpu_to_be16(XFS_DIR3_LEAFN_MAGIC);
481 1723 : lbp->b_ops = &xfs_dir3_leafn_buf_ops;
482 1723 : xfs_trans_buf_set_type(tp, lbp, XFS_BLFT_DIR_LEAFN_BUF);
483 1723 : xfs_dir3_leaf_log_header(args, lbp);
484 1723 : xfs_dir3_leaf_check(dp, lbp);
485 1723 : return 0;
486 : }
487 :
488 : /*
489 : * Add a leaf entry to a leaf block in a node-form directory.
490 : * The other work necessary is done from the caller.
491 : */
492 : static int /* error */
493 28240995 : xfs_dir2_leafn_add(
494 : struct xfs_buf *bp, /* leaf buffer */
495 : struct xfs_da_args *args, /* operation arguments */
496 : int index) /* insertion pt for new entry */
497 : {
498 28240995 : struct xfs_dir3_icleaf_hdr leafhdr;
499 28240995 : struct xfs_inode *dp = args->dp;
500 28240995 : struct xfs_dir2_leaf *leaf = bp->b_addr;
501 28240995 : struct xfs_dir2_leaf_entry *lep;
502 28240995 : struct xfs_dir2_leaf_entry *ents;
503 28240995 : int compact; /* compacting stale leaves */
504 28240995 : int highstale = 0; /* next stale entry */
505 28240995 : int lfloghigh; /* high leaf entry logging */
506 28240995 : int lfloglow; /* low leaf entry logging */
507 28240995 : int lowstale = 0; /* previous stale entry */
508 :
509 28240995 : trace_xfs_dir2_leafn_add(args, index);
510 :
511 28243342 : xfs_dir2_leaf_hdr_from_disk(dp->i_mount, &leafhdr, leaf);
512 28243489 : ents = leafhdr.ents;
513 :
514 : /*
515 : * Quick check just to make sure we are not going to index
516 : * into other peoples memory
517 : */
518 28243489 : if (index < 0) {
519 0 : xfs_buf_mark_corrupt(bp);
520 0 : return -EFSCORRUPTED;
521 : }
522 :
523 : /*
524 : * If there are already the maximum number of leaf entries in
525 : * the block, if there are no stale entries it won't fit.
526 : * Caller will do a split. If there are stale entries we'll do
527 : * a compact.
528 : */
529 :
530 28243489 : if (leafhdr.count == args->geo->leaf_max_ents) {
531 32242 : if (!leafhdr.stale)
532 : return -ENOSPC;
533 7843 : compact = leafhdr.stale > 1;
534 : } else
535 : compact = 0;
536 56423292 : ASSERT(index == 0 || be32_to_cpu(ents[index - 1].hashval) <= args->hashval);
537 54468385 : ASSERT(index == leafhdr.count ||
538 : be32_to_cpu(ents[index].hashval) >= args->hashval);
539 :
540 28219090 : if (args->op_flags & XFS_DA_OP_JUSTCHECK)
541 : return 0;
542 :
543 : /*
544 : * Compact out all but one stale leaf entry. Leaves behind
545 : * the entry closest to index.
546 : */
547 28219090 : if (compact)
548 3155 : xfs_dir3_leaf_compact_x1(&leafhdr, ents, &index, &lowstale,
549 : &highstale, &lfloglow, &lfloghigh);
550 28215935 : else if (leafhdr.stale) {
551 : /*
552 : * Set impossible logging indices for this case.
553 : */
554 20786905 : lfloglow = leafhdr.count;
555 20786905 : lfloghigh = -1;
556 : }
557 :
558 : /*
559 : * Insert the new entry, log everything.
560 : */
561 28219090 : lep = xfs_dir3_leaf_find_entry(&leafhdr, ents, index, compact, lowstale,
562 : highstale, &lfloglow, &lfloghigh);
563 :
564 28216794 : lep->hashval = cpu_to_be32(args->hashval);
565 28216794 : lep->address = cpu_to_be32(xfs_dir2_db_off_to_dataptr(args->geo,
566 : args->blkno, args->index));
567 :
568 28218557 : xfs_dir2_leaf_hdr_to_disk(dp->i_mount, leaf, &leafhdr);
569 28218609 : xfs_dir3_leaf_log_header(args, bp);
570 28218403 : xfs_dir3_leaf_log_ents(args, &leafhdr, bp, lfloglow, lfloghigh);
571 28219009 : xfs_dir3_leaf_check(dp, bp);
572 28219009 : return 0;
573 : }
574 :
575 : #ifdef DEBUG
576 : static void
577 254511 : xfs_dir2_free_hdr_check(
578 : struct xfs_inode *dp,
579 : struct xfs_buf *bp,
580 : xfs_dir2_db_t db)
581 : {
582 254511 : struct xfs_dir3_icfree_hdr hdr;
583 :
584 254511 : xfs_dir2_free_hdr_from_disk(dp->i_mount, &hdr, bp->b_addr);
585 :
586 254511 : ASSERT((hdr.firstdb % dp->i_mount->m_dir_geo->free_max_bests) == 0);
587 254511 : ASSERT(hdr.firstdb <= db);
588 254511 : ASSERT(db < hdr.firstdb + hdr.nvalid);
589 254511 : }
590 : #else
591 : #define xfs_dir2_free_hdr_check(dp, bp, db)
592 : #endif /* DEBUG */
593 :
594 : /*
595 : * Return the last hash value in the leaf.
596 : * Stale entries are ok.
597 : */
598 : xfs_dahash_t /* hash value */
599 235266041 : xfs_dir2_leaf_lasthash(
600 : struct xfs_inode *dp,
601 : struct xfs_buf *bp, /* leaf buffer */
602 : int *count) /* count of entries in leaf */
603 : {
604 235266041 : struct xfs_dir3_icleaf_hdr leafhdr;
605 :
606 235266041 : xfs_dir2_leaf_hdr_from_disk(dp->i_mount, &leafhdr, bp->b_addr);
607 :
608 235267533 : ASSERT(leafhdr.magic == XFS_DIR2_LEAFN_MAGIC ||
609 : leafhdr.magic == XFS_DIR3_LEAFN_MAGIC ||
610 : leafhdr.magic == XFS_DIR2_LEAF1_MAGIC ||
611 : leafhdr.magic == XFS_DIR3_LEAF1_MAGIC);
612 :
613 235267533 : if (count)
614 55368664 : *count = leafhdr.count;
615 235267533 : if (!leafhdr.count)
616 : return 0;
617 235267533 : return be32_to_cpu(leafhdr.ents[leafhdr.count - 1].hashval);
618 : }
619 :
620 : /*
621 : * Look up a leaf entry for space to add a name in a node-format leaf block.
622 : * The extrablk in state is a freespace block.
623 : */
624 : STATIC int
625 28374075 : xfs_dir2_leafn_lookup_for_addname(
626 : struct xfs_buf *bp, /* leaf buffer */
627 : xfs_da_args_t *args, /* operation arguments */
628 : int *indexp, /* out: leaf entry index */
629 : xfs_da_state_t *state) /* state to fill in */
630 : {
631 28374075 : struct xfs_buf *curbp = NULL; /* current data/free buffer */
632 28374075 : xfs_dir2_db_t curdb = -1; /* current data block number */
633 28374075 : xfs_dir2_db_t curfdb = -1; /* current free block number */
634 28374075 : xfs_inode_t *dp; /* incore directory inode */
635 28374075 : int error; /* error return value */
636 28374075 : int fi; /* free entry index */
637 28374075 : xfs_dir2_free_t *free = NULL; /* free block structure */
638 28374075 : int index; /* leaf entry index */
639 28374075 : xfs_dir2_leaf_t *leaf; /* leaf structure */
640 28374075 : int length; /* length of new data entry */
641 28374075 : xfs_dir2_leaf_entry_t *lep; /* leaf entry */
642 28374075 : xfs_mount_t *mp; /* filesystem mount point */
643 28374075 : xfs_dir2_db_t newdb; /* new data block number */
644 28374075 : xfs_dir2_db_t newfdb; /* new free block number */
645 28374075 : xfs_trans_t *tp; /* transaction pointer */
646 28374075 : struct xfs_dir3_icleaf_hdr leafhdr;
647 :
648 28374075 : dp = args->dp;
649 28374075 : tp = args->trans;
650 28374075 : mp = dp->i_mount;
651 28374075 : leaf = bp->b_addr;
652 28374075 : xfs_dir2_leaf_hdr_from_disk(mp, &leafhdr, leaf);
653 :
654 28376031 : xfs_dir3_leaf_check(dp, bp);
655 28375192 : ASSERT(leafhdr.count > 0);
656 :
657 : /*
658 : * Look up the hash value in the leaf entries.
659 : */
660 28375192 : index = xfs_dir2_leaf_search_hash(args, bp);
661 : /*
662 : * Do we have a buffer coming in?
663 : */
664 28375488 : if (state->extravalid) {
665 : /* If so, it's a free block buffer, get the block number. */
666 156154 : curbp = state->extrablk.bp;
667 156154 : curfdb = state->extrablk.blkno;
668 156154 : free = curbp->b_addr;
669 156154 : ASSERT(free->hdr.magic == cpu_to_be32(XFS_DIR2_FREE_MAGIC) ||
670 : free->hdr.magic == cpu_to_be32(XFS_DIR3_FREE_MAGIC));
671 : }
672 28375488 : length = xfs_dir2_data_entsize(mp, args->namelen);
673 : /*
674 : * Loop over leaf entries with the right hash value.
675 : */
676 28375488 : for (lep = &leafhdr.ents[index];
677 104096208 : index < leafhdr.count && be32_to_cpu(lep->hashval) == args->hashval;
678 24673368 : lep++, index++) {
679 : /*
680 : * Skip stale leaf entries.
681 : */
682 24854229 : if (be32_to_cpu(lep->address) == XFS_DIR2_NULL_DATAPTR)
683 251211 : continue;
684 : /*
685 : * Pull the data block number from the entry.
686 : */
687 24603018 : newdb = xfs_dir2_dataptr_to_db(args->geo,
688 0 : be32_to_cpu(lep->address));
689 : /*
690 : * For addname, we're looking for a place to put the new entry.
691 : * We want to use a data block with an entry of equal
692 : * hash value to ours if there is one with room.
693 : *
694 : * If this block isn't the data block we already have
695 : * in hand, take a look at it.
696 : */
697 24603104 : if (newdb != curdb) {
698 1653349 : struct xfs_dir3_icfree_hdr freehdr;
699 :
700 1653349 : curdb = newdb;
701 : /*
702 : * Convert the data block to the free block
703 : * holding its freespace information.
704 : */
705 1653349 : newfdb = xfs_dir2_db_to_fdb(args->geo, newdb);
706 : /*
707 : * If it's not the one we have in hand, read it in.
708 : */
709 1653349 : if (newfdb != curfdb) {
710 : /*
711 : * If we had one before, drop it.
712 : */
713 254511 : if (curbp)
714 0 : xfs_trans_brelse(tp, curbp);
715 :
716 254511 : error = xfs_dir2_free_read(tp, dp,
717 : xfs_dir2_db_to_da(args->geo,
718 : newfdb),
719 : &curbp);
720 254511 : if (error)
721 0 : return error;
722 254511 : free = curbp->b_addr;
723 :
724 254511 : xfs_dir2_free_hdr_check(dp, curbp, curdb);
725 : }
726 : /*
727 : * Get the index for our entry.
728 : */
729 1653349 : fi = xfs_dir2_db_to_fdindex(args->geo, curdb);
730 : /*
731 : * If it has room, return it.
732 : */
733 1653349 : xfs_dir2_free_hdr_from_disk(mp, &freehdr, free);
734 1653349 : if (XFS_IS_CORRUPT(mp,
735 : freehdr.bests[fi] ==
736 : cpu_to_be16(NULLDATAOFF))) {
737 0 : if (curfdb != newfdb)
738 0 : xfs_trans_brelse(tp, curbp);
739 0 : return -EFSCORRUPTED;
740 : }
741 1653349 : curfdb = newfdb;
742 1653349 : if (be16_to_cpu(freehdr.bests[fi]) >= length)
743 180939 : goto out;
744 : }
745 : }
746 : /* Didn't find any space */
747 : fi = -1;
748 28375566 : out:
749 28375566 : ASSERT(args->op_flags & XFS_DA_OP_OKNOENT);
750 28375566 : if (curbp) {
751 : /* Giving back a free block. */
752 410665 : state->extravalid = 1;
753 410665 : state->extrablk.bp = curbp;
754 410665 : state->extrablk.index = fi;
755 410665 : state->extrablk.blkno = curfdb;
756 :
757 : /*
758 : * Important: this magic number is not in the buffer - it's for
759 : * buffer type information and therefore only the free/data type
760 : * matters here, not whether CRCs are enabled or not.
761 : */
762 410665 : state->extrablk.magic = XFS_DIR2_FREE_MAGIC;
763 : } else {
764 27964901 : state->extravalid = 0;
765 : }
766 : /*
767 : * Return the index, that will be the insertion point.
768 : */
769 28375566 : *indexp = index;
770 28375566 : return -ENOENT;
771 : }
772 :
773 : /*
774 : * Look up a leaf entry in a node-format leaf block.
775 : * The extrablk in state a data block.
776 : */
777 : STATIC int
778 150668223 : xfs_dir2_leafn_lookup_for_entry(
779 : struct xfs_buf *bp, /* leaf buffer */
780 : xfs_da_args_t *args, /* operation arguments */
781 : int *indexp, /* out: leaf entry index */
782 : xfs_da_state_t *state) /* state to fill in */
783 : {
784 150668223 : struct xfs_buf *curbp = NULL; /* current data/free buffer */
785 150668223 : xfs_dir2_db_t curdb = -1; /* current data block number */
786 150668223 : xfs_dir2_data_entry_t *dep; /* data block entry */
787 150668223 : xfs_inode_t *dp; /* incore directory inode */
788 150668223 : int error; /* error return value */
789 150668223 : int index; /* leaf entry index */
790 150668223 : xfs_dir2_leaf_t *leaf; /* leaf structure */
791 150668223 : xfs_dir2_leaf_entry_t *lep; /* leaf entry */
792 150668223 : xfs_mount_t *mp; /* filesystem mount point */
793 150668223 : xfs_dir2_db_t newdb; /* new data block number */
794 150668223 : xfs_trans_t *tp; /* transaction pointer */
795 150668223 : enum xfs_dacmp cmp; /* comparison result */
796 150668223 : struct xfs_dir3_icleaf_hdr leafhdr;
797 :
798 150668223 : dp = args->dp;
799 150668223 : tp = args->trans;
800 150668223 : mp = dp->i_mount;
801 150668223 : leaf = bp->b_addr;
802 150668223 : xfs_dir2_leaf_hdr_from_disk(mp, &leafhdr, leaf);
803 :
804 150666431 : xfs_dir3_leaf_check(dp, bp);
805 150673618 : if (leafhdr.count <= 0) {
806 0 : xfs_buf_mark_corrupt(bp);
807 0 : return -EFSCORRUPTED;
808 : }
809 :
810 : /*
811 : * Look up the hash value in the leaf entries.
812 : */
813 150673618 : index = xfs_dir2_leaf_search_hash(args, bp);
814 : /*
815 : * Do we have a buffer coming in?
816 : */
817 150672894 : if (state->extravalid) {
818 808609 : curbp = state->extrablk.bp;
819 808609 : curdb = state->extrablk.blkno;
820 : }
821 : /*
822 : * Loop over leaf entries with the right hash value.
823 : */
824 150672894 : for (lep = &leafhdr.ents[index];
825 1129213196 : index < leafhdr.count && be32_to_cpu(lep->hashval) == args->hashval;
826 414749949 : lep++, index++) {
827 : /*
828 : * Skip stale leaf entries.
829 : */
830 556902424 : if (be32_to_cpu(lep->address) == XFS_DIR2_NULL_DATAPTR)
831 77129015 : continue;
832 : /*
833 : * Pull the data block number from the entry.
834 : */
835 479773409 : newdb = xfs_dir2_dataptr_to_db(args->geo,
836 0 : be32_to_cpu(lep->address));
837 : /*
838 : * Not adding a new entry, so we really want to find
839 : * the name given to us.
840 : *
841 : * If it's a different data block, go get it.
842 : */
843 479778038 : if (newdb != curdb) {
844 : /*
845 : * If we had a block before that we aren't saving
846 : * for a CI name, drop it
847 : */
848 149659775 : if (curbp && (args->cmpresult == XFS_CMP_DIFFERENT ||
849 709770 : curdb != state->extrablk.blkno))
850 6991259 : xfs_trans_brelse(tp, curbp);
851 : /*
852 : * If needing the block that is saved with a CI match,
853 : * use it otherwise read in the new data block.
854 : */
855 149658850 : if (args->cmpresult != XFS_CMP_DIFFERENT &&
856 709770 : newdb == state->extrablk.blkno) {
857 1199 : ASSERT(state->extravalid);
858 1199 : curbp = state->extrablk.bp;
859 : } else {
860 149657651 : error = xfs_dir3_data_read(tp, dp,
861 : xfs_dir2_db_to_da(args->geo,
862 : newdb),
863 : 0, &curbp);
864 149649058 : if (error)
865 2215 : return error;
866 : }
867 149648042 : xfs_dir3_data_check(dp, curbp);
868 149648042 : curdb = newdb;
869 : }
870 : /*
871 : * Point to the data entry.
872 : */
873 959538002 : dep = (xfs_dir2_data_entry_t *)((char *)curbp->b_addr +
874 959538002 : xfs_dir2_dataptr_to_off(args->geo,
875 479769001 : be32_to_cpu(lep->address)));
876 : /*
877 : * Compare the entry and if it's an exact match, return
878 : * EEXIST immediately. If it's the first case-insensitive
879 : * match, store the block & inode number and continue looking.
880 : */
881 479769001 : cmp = xfs_dir2_compname(args, dep->name, dep->namelen);
882 479765009 : if (cmp != XFS_CMP_DIFFERENT && cmp != args->cmpresult) {
883 : /* If there is a CI match block, drop it */
884 142205103 : if (args->cmpresult != XFS_CMP_DIFFERENT &&
885 0 : curdb != state->extrablk.blkno)
886 0 : xfs_trans_brelse(tp, state->extrablk.bp);
887 142205103 : args->cmpresult = cmp;
888 142205103 : args->inumber = be64_to_cpu(dep->inumber);
889 142205103 : args->filetype = xfs_dir2_data_get_ftype(mp, dep);
890 142207832 : *indexp = index;
891 142207832 : state->extravalid = 1;
892 142207832 : state->extrablk.bp = curbp;
893 142207832 : state->extrablk.blkno = curdb;
894 142207832 : state->extrablk.index = (int)((char *)dep -
895 142207832 : (char *)curbp->b_addr);
896 142207832 : state->extrablk.magic = XFS_DIR2_DATA_MAGIC;
897 142207832 : curbp->b_ops = &xfs_dir3_data_buf_ops;
898 142207832 : xfs_trans_buf_set_type(tp, curbp, XFS_BLFT_DIR_DATA_BUF);
899 142209165 : if (cmp == XFS_CMP_EXACT)
900 : return -EEXIST;
901 : }
902 : }
903 8517073 : ASSERT(index == leafhdr.count || (args->op_flags & XFS_DA_OP_OKNOENT));
904 8517073 : if (curbp) {
905 1158972 : if (args->cmpresult == XFS_CMP_DIFFERENT) {
906 : /* Giving back last used data block. */
907 980933 : state->extravalid = 1;
908 980933 : state->extrablk.bp = curbp;
909 980933 : state->extrablk.index = -1;
910 980933 : state->extrablk.blkno = curdb;
911 980933 : state->extrablk.magic = XFS_DIR2_DATA_MAGIC;
912 980933 : curbp->b_ops = &xfs_dir3_data_buf_ops;
913 980933 : xfs_trans_buf_set_type(tp, curbp, XFS_BLFT_DIR_DATA_BUF);
914 : } else {
915 : /* If the curbp is not the CI match block, drop it */
916 178039 : if (state->extrablk.bp != curbp)
917 161004 : xfs_trans_brelse(tp, curbp);
918 : }
919 : } else {
920 7358101 : state->extravalid = 0;
921 : }
922 8517073 : *indexp = index;
923 8517073 : return -ENOENT;
924 : }
925 :
926 : /*
927 : * Look up a leaf entry in a node-format leaf block.
928 : * If this is an addname then the extrablk in state is a freespace block,
929 : * otherwise it's a data block.
930 : */
931 : int
932 179049863 : xfs_dir2_leafn_lookup_int(
933 : struct xfs_buf *bp, /* leaf buffer */
934 : xfs_da_args_t *args, /* operation arguments */
935 : int *indexp, /* out: leaf entry index */
936 : xfs_da_state_t *state) /* state to fill in */
937 : {
938 179049863 : if (args->op_flags & XFS_DA_OP_ADDNAME)
939 28375998 : return xfs_dir2_leafn_lookup_for_addname(bp, args, indexp,
940 : state);
941 150673865 : return xfs_dir2_leafn_lookup_for_entry(bp, args, indexp, state);
942 : }
943 :
944 : /*
945 : * Move count leaf entries from source to destination leaf.
946 : * Log entries and headers. Stale entries are preserved.
947 : */
948 : static void
949 43517 : xfs_dir3_leafn_moveents(
950 : xfs_da_args_t *args, /* operation arguments */
951 : struct xfs_buf *bp_s, /* source */
952 : struct xfs_dir3_icleaf_hdr *shdr,
953 : struct xfs_dir2_leaf_entry *sents,
954 : int start_s,/* source leaf index */
955 : struct xfs_buf *bp_d, /* destination */
956 : struct xfs_dir3_icleaf_hdr *dhdr,
957 : struct xfs_dir2_leaf_entry *dents,
958 : int start_d,/* destination leaf index */
959 : int count) /* count of leaves to copy */
960 : {
961 43517 : int stale; /* count stale leaves copied */
962 :
963 43517 : trace_xfs_dir2_leafn_moveents(args, start_s, start_d, count);
964 :
965 : /*
966 : * Silently return if nothing to do.
967 : */
968 43517 : if (count == 0)
969 : return;
970 :
971 : /*
972 : * If the destination index is not the end of the current
973 : * destination leaf entries, open up a hole in the destination
974 : * to hold the new entries.
975 : */
976 43517 : if (start_d < dhdr->count) {
977 6050 : memmove(&dents[start_d + count], &dents[start_d],
978 : (dhdr->count - start_d) * sizeof(xfs_dir2_leaf_entry_t));
979 3025 : xfs_dir3_leaf_log_ents(args, dhdr, bp_d, start_d + count,
980 3025 : count + dhdr->count - 1);
981 : }
982 : /*
983 : * If the source has stale leaves, count the ones in the copy range
984 : * so we can update the header correctly.
985 : */
986 43517 : if (shdr->stale) {
987 : int i; /* temp leaf index */
988 :
989 0 : for (i = start_s, stale = 0; i < start_s + count; i++) {
990 0 : if (sents[i].address ==
991 : cpu_to_be32(XFS_DIR2_NULL_DATAPTR))
992 0 : stale++;
993 : }
994 : } else
995 : stale = 0;
996 : /*
997 : * Copy the leaf entries from source to destination.
998 : */
999 87034 : memcpy(&dents[start_d], &sents[start_s],
1000 : count * sizeof(xfs_dir2_leaf_entry_t));
1001 43517 : xfs_dir3_leaf_log_ents(args, dhdr, bp_d, start_d, start_d + count - 1);
1002 :
1003 : /*
1004 : * If there are source entries after the ones we copied,
1005 : * delete the ones we copied by sliding the next ones down.
1006 : */
1007 43517 : if (start_s + count < shdr->count) {
1008 0 : memmove(&sents[start_s], &sents[start_s + count],
1009 : count * sizeof(xfs_dir2_leaf_entry_t));
1010 0 : xfs_dir3_leaf_log_ents(args, shdr, bp_s, start_s,
1011 : start_s + count - 1);
1012 : }
1013 :
1014 : /*
1015 : * Update the headers and log them.
1016 : */
1017 43517 : shdr->count -= count;
1018 43517 : shdr->stale -= stale;
1019 43517 : dhdr->count += count;
1020 43517 : dhdr->stale += stale;
1021 : }
1022 :
1023 : /*
1024 : * Determine the sort order of two leaf blocks.
1025 : * Returns 1 if both are valid and leaf2 should be before leaf1, else 0.
1026 : */
1027 : int /* sort order */
1028 67916 : xfs_dir2_leafn_order(
1029 : struct xfs_inode *dp,
1030 : struct xfs_buf *leaf1_bp, /* leaf1 buffer */
1031 : struct xfs_buf *leaf2_bp) /* leaf2 buffer */
1032 : {
1033 67916 : struct xfs_dir2_leaf *leaf1 = leaf1_bp->b_addr;
1034 67916 : struct xfs_dir2_leaf *leaf2 = leaf2_bp->b_addr;
1035 67916 : struct xfs_dir2_leaf_entry *ents1;
1036 67916 : struct xfs_dir2_leaf_entry *ents2;
1037 67916 : struct xfs_dir3_icleaf_hdr hdr1;
1038 67916 : struct xfs_dir3_icleaf_hdr hdr2;
1039 :
1040 67916 : xfs_dir2_leaf_hdr_from_disk(dp->i_mount, &hdr1, leaf1);
1041 67916 : xfs_dir2_leaf_hdr_from_disk(dp->i_mount, &hdr2, leaf2);
1042 67916 : ents1 = hdr1.ents;
1043 67916 : ents2 = hdr2.ents;
1044 :
1045 111432 : if (hdr1.count > 0 && hdr2.count > 0 &&
1046 127523 : (be32_to_cpu(ents2[0].hashval) < be32_to_cpu(ents1[0].hashval) ||
1047 40491 : be32_to_cpu(ents2[hdr2.count - 1].hashval) <
1048 40491 : be32_to_cpu(ents1[hdr1.count - 1].hashval)))
1049 3025 : return 1;
1050 : return 0;
1051 : }
1052 :
1053 : /*
1054 : * Rebalance leaf entries between two leaf blocks.
1055 : * This is actually only called when the second block is new,
1056 : * though the code deals with the general case.
1057 : * A new entry will be inserted in one of the blocks, and that
1058 : * entry is taken into account when balancing.
1059 : */
1060 : static void
1061 24399 : xfs_dir2_leafn_rebalance(
1062 : xfs_da_state_t *state, /* btree cursor */
1063 : xfs_da_state_blk_t *blk1, /* first btree block */
1064 : xfs_da_state_blk_t *blk2) /* second btree block */
1065 : {
1066 24399 : xfs_da_args_t *args; /* operation arguments */
1067 24399 : int count; /* count (& direction) leaves */
1068 24399 : int isleft; /* new goes in left leaf */
1069 24399 : xfs_dir2_leaf_t *leaf1; /* first leaf structure */
1070 24399 : xfs_dir2_leaf_t *leaf2; /* second leaf structure */
1071 24399 : int mid; /* midpoint leaf index */
1072 : #if defined(DEBUG) || defined(XFS_WARN)
1073 24399 : int oldstale; /* old count of stale leaves */
1074 : #endif
1075 24399 : int oldsum; /* old total leaf count */
1076 24399 : int swap_blocks; /* swapped leaf blocks */
1077 24399 : struct xfs_dir2_leaf_entry *ents1;
1078 24399 : struct xfs_dir2_leaf_entry *ents2;
1079 24399 : struct xfs_dir3_icleaf_hdr hdr1;
1080 24399 : struct xfs_dir3_icleaf_hdr hdr2;
1081 24399 : struct xfs_inode *dp = state->args->dp;
1082 :
1083 24399 : args = state->args;
1084 : /*
1085 : * If the block order is wrong, swap the arguments.
1086 : */
1087 24399 : swap_blocks = xfs_dir2_leafn_order(dp, blk1->bp, blk2->bp);
1088 24399 : if (swap_blocks)
1089 0 : swap(blk1, blk2);
1090 :
1091 24399 : leaf1 = blk1->bp->b_addr;
1092 24399 : leaf2 = blk2->bp->b_addr;
1093 24399 : xfs_dir2_leaf_hdr_from_disk(dp->i_mount, &hdr1, leaf1);
1094 24399 : xfs_dir2_leaf_hdr_from_disk(dp->i_mount, &hdr2, leaf2);
1095 24399 : ents1 = hdr1.ents;
1096 24399 : ents2 = hdr2.ents;
1097 :
1098 24399 : oldsum = hdr1.count + hdr2.count;
1099 : #if defined(DEBUG) || defined(XFS_WARN)
1100 24399 : oldstale = hdr1.stale + hdr2.stale;
1101 : #endif
1102 24399 : mid = oldsum >> 1;
1103 :
1104 : /*
1105 : * If the old leaf count was odd then the new one will be even,
1106 : * so we need to divide the new count evenly.
1107 : */
1108 24399 : if (oldsum & 1) {
1109 0 : xfs_dahash_t midhash; /* middle entry hash value */
1110 :
1111 0 : if (mid >= hdr1.count)
1112 0 : midhash = be32_to_cpu(ents2[mid - hdr1.count].hashval);
1113 : else
1114 0 : midhash = be32_to_cpu(ents1[mid].hashval);
1115 0 : isleft = args->hashval <= midhash;
1116 : }
1117 : /*
1118 : * If the old count is even then the new count is odd, so there's
1119 : * no preferred side for the new entry.
1120 : * Pick the left one.
1121 : */
1122 : else
1123 : isleft = 1;
1124 : /*
1125 : * Calculate moved entry count. Positive means left-to-right,
1126 : * negative means right-to-left. Then move the entries.
1127 : */
1128 24399 : count = hdr1.count - mid + (isleft == 0);
1129 24399 : if (count > 0)
1130 24399 : xfs_dir3_leafn_moveents(args, blk1->bp, &hdr1, ents1,
1131 : hdr1.count - count, blk2->bp,
1132 : &hdr2, ents2, 0, count);
1133 0 : else if (count < 0)
1134 0 : xfs_dir3_leafn_moveents(args, blk2->bp, &hdr2, ents2, 0,
1135 : blk1->bp, &hdr1, ents1,
1136 : hdr1.count, count);
1137 :
1138 24399 : ASSERT(hdr1.count + hdr2.count == oldsum);
1139 24399 : ASSERT(hdr1.stale + hdr2.stale == oldstale);
1140 :
1141 : /* log the changes made when moving the entries */
1142 24399 : xfs_dir2_leaf_hdr_to_disk(dp->i_mount, leaf1, &hdr1);
1143 24399 : xfs_dir2_leaf_hdr_to_disk(dp->i_mount, leaf2, &hdr2);
1144 24399 : xfs_dir3_leaf_log_header(args, blk1->bp);
1145 24399 : xfs_dir3_leaf_log_header(args, blk2->bp);
1146 :
1147 24399 : xfs_dir3_leaf_check(dp, blk1->bp);
1148 24399 : xfs_dir3_leaf_check(dp, blk2->bp);
1149 :
1150 : /*
1151 : * Mark whether we're inserting into the old or new leaf.
1152 : */
1153 24399 : if (hdr1.count < hdr2.count)
1154 0 : state->inleaf = swap_blocks;
1155 24399 : else if (hdr1.count > hdr2.count)
1156 0 : state->inleaf = !swap_blocks;
1157 : else
1158 24399 : state->inleaf = swap_blocks ^ (blk1->index <= hdr1.count);
1159 : /*
1160 : * Adjust the expected index for insertion.
1161 : */
1162 24399 : if (!state->inleaf)
1163 18829 : blk2->index = blk1->index - hdr1.count;
1164 :
1165 : /*
1166 : * Finally sanity check just to make sure we are not returning a
1167 : * negative index
1168 : */
1169 24399 : if (blk2->index < 0) {
1170 0 : state->inleaf = 1;
1171 0 : blk2->index = 0;
1172 0 : xfs_alert(dp->i_mount,
1173 : "%s: picked the wrong leaf? reverting original leaf: blk1->index %d",
1174 : __func__, blk1->index);
1175 : }
1176 24399 : }
1177 :
1178 : static int
1179 11343939 : xfs_dir3_data_block_free(
1180 : xfs_da_args_t *args,
1181 : struct xfs_dir2_data_hdr *hdr,
1182 : struct xfs_dir2_free *free,
1183 : xfs_dir2_db_t fdb,
1184 : int findex,
1185 : struct xfs_buf *fbp,
1186 : int longest)
1187 : {
1188 11343939 : int logfree = 0;
1189 11343939 : struct xfs_dir3_icfree_hdr freehdr;
1190 11343939 : struct xfs_inode *dp = args->dp;
1191 :
1192 11343939 : xfs_dir2_free_hdr_from_disk(dp->i_mount, &freehdr, free);
1193 11343980 : if (hdr) {
1194 : /*
1195 : * Data block is not empty, just set the free entry to the new
1196 : * value.
1197 : */
1198 11329084 : freehdr.bests[findex] = cpu_to_be16(longest);
1199 11329084 : xfs_dir2_free_log_bests(args, &freehdr, fbp, findex, findex);
1200 11329084 : return 0;
1201 : }
1202 :
1203 : /* One less used entry in the free table. */
1204 14896 : freehdr.nused--;
1205 :
1206 : /*
1207 : * If this was the last entry in the table, we can trim the table size
1208 : * back. There might be other entries at the end referring to
1209 : * non-existent data blocks, get those too.
1210 : */
1211 14896 : if (findex == freehdr.nvalid - 1) {
1212 491 : int i; /* free entry index */
1213 :
1214 8703 : for (i = findex - 1; i >= 0; i--) {
1215 8701 : if (freehdr.bests[i] != cpu_to_be16(NULLDATAOFF))
1216 : break;
1217 : }
1218 491 : freehdr.nvalid = i + 1;
1219 491 : logfree = 0;
1220 : } else {
1221 : /* Not the last entry, just punch it out. */
1222 14405 : freehdr.bests[findex] = cpu_to_be16(NULLDATAOFF);
1223 14405 : logfree = 1;
1224 : }
1225 :
1226 14896 : xfs_dir2_free_hdr_to_disk(dp->i_mount, free, &freehdr);
1227 14896 : xfs_dir2_free_log_header(args, fbp);
1228 :
1229 : /*
1230 : * If there are no useful entries left in the block, get rid of the
1231 : * block if we can.
1232 : */
1233 14896 : if (!freehdr.nused) {
1234 2 : int error;
1235 :
1236 2 : error = xfs_dir2_shrink_inode(args, fdb, fbp);
1237 2 : if (error == 0) {
1238 : fbp = NULL;
1239 : logfree = 0;
1240 0 : } else if (error != -ENOSPC || args->total != 0)
1241 : return error;
1242 : /*
1243 : * It's possible to get ENOSPC if there is no
1244 : * space reservation. In this case some one
1245 : * else will eventually get rid of this block.
1246 : */
1247 : }
1248 :
1249 : /* Log the free entry that changed, unless we got rid of it. */
1250 14894 : if (logfree)
1251 14405 : xfs_dir2_free_log_bests(args, &freehdr, fbp, findex, findex);
1252 : return 0;
1253 : }
1254 :
1255 : /*
1256 : * Remove an entry from a node directory.
1257 : * This removes the leaf entry and the data entry,
1258 : * and updates the free block if necessary.
1259 : */
1260 : static int /* error */
1261 26758565 : xfs_dir2_leafn_remove(
1262 : xfs_da_args_t *args, /* operation arguments */
1263 : struct xfs_buf *bp, /* leaf buffer */
1264 : int index, /* leaf entry index */
1265 : xfs_da_state_blk_t *dblk, /* data block */
1266 : int *rval) /* resulting block needs join */
1267 : {
1268 26758565 : struct xfs_da_geometry *geo = args->geo;
1269 26758565 : xfs_dir2_data_hdr_t *hdr; /* data block header */
1270 26758565 : xfs_dir2_db_t db; /* data block number */
1271 26758565 : struct xfs_buf *dbp; /* data block buffer */
1272 26758565 : xfs_dir2_data_entry_t *dep; /* data block entry */
1273 26758565 : xfs_inode_t *dp; /* incore directory inode */
1274 26758565 : xfs_dir2_leaf_t *leaf; /* leaf structure */
1275 26758565 : xfs_dir2_leaf_entry_t *lep; /* leaf entry */
1276 26758565 : int longest; /* longest data free entry */
1277 26758565 : int off; /* data block entry offset */
1278 26758565 : int needlog; /* need to log data header */
1279 26758565 : int needscan; /* need to rescan data frees */
1280 26758565 : xfs_trans_t *tp; /* transaction pointer */
1281 26758565 : struct xfs_dir2_data_free *bf; /* bestfree table */
1282 26758565 : struct xfs_dir3_icleaf_hdr leafhdr;
1283 :
1284 26758565 : trace_xfs_dir2_leafn_remove(args, index);
1285 :
1286 26758743 : dp = args->dp;
1287 26758743 : tp = args->trans;
1288 26758743 : leaf = bp->b_addr;
1289 26758743 : xfs_dir2_leaf_hdr_from_disk(dp->i_mount, &leafhdr, leaf);
1290 :
1291 : /*
1292 : * Point to the entry we're removing.
1293 : */
1294 26758703 : lep = &leafhdr.ents[index];
1295 :
1296 : /*
1297 : * Extract the data block and offset from the entry.
1298 : */
1299 26758703 : db = xfs_dir2_dataptr_to_db(geo, be32_to_cpu(lep->address));
1300 26758477 : ASSERT(dblk->blkno == db);
1301 26758477 : off = xfs_dir2_dataptr_to_off(geo, be32_to_cpu(lep->address));
1302 26758477 : ASSERT(dblk->index == off);
1303 :
1304 : /*
1305 : * Kill the leaf entry by marking it stale.
1306 : * Log the leaf block changes.
1307 : */
1308 26758477 : leafhdr.stale++;
1309 26758477 : xfs_dir2_leaf_hdr_to_disk(dp->i_mount, leaf, &leafhdr);
1310 26758774 : xfs_dir3_leaf_log_header(args, bp);
1311 :
1312 26758719 : lep->address = cpu_to_be32(XFS_DIR2_NULL_DATAPTR);
1313 26758719 : xfs_dir3_leaf_log_ents(args, &leafhdr, bp, index, index);
1314 :
1315 : /*
1316 : * Make the data entry free. Keep track of the longest freespace
1317 : * in the data block in case it changes.
1318 : */
1319 26758903 : dbp = dblk->bp;
1320 26758903 : hdr = dbp->b_addr;
1321 26758903 : dep = (xfs_dir2_data_entry_t *)((char *)hdr + off);
1322 26758903 : bf = xfs_dir2_data_bestfree_p(dp->i_mount, hdr);
1323 26758877 : longest = be16_to_cpu(bf[0].length);
1324 26758877 : needlog = needscan = 0;
1325 26758877 : xfs_dir2_data_make_free(args, dbp, off,
1326 26758877 : xfs_dir2_data_entsize(dp->i_mount, dep->namelen), &needlog,
1327 : &needscan);
1328 : /*
1329 : * Rescan the data block freespaces for bestfree.
1330 : * Log the data block header if needed.
1331 : */
1332 26758529 : if (needscan)
1333 2594361 : xfs_dir2_data_freescan(dp->i_mount, hdr, &needlog);
1334 26758533 : if (needlog)
1335 16967494 : xfs_dir2_data_log_header(args, dbp);
1336 26758320 : xfs_dir3_data_check(dp, dbp);
1337 : /*
1338 : * If the longest data block freespace changes, need to update
1339 : * the corresponding freeblock entry.
1340 : */
1341 26758879 : if (longest < be16_to_cpu(bf[0].length)) {
1342 11343517 : int error; /* error return value */
1343 11343517 : struct xfs_buf *fbp; /* freeblock buffer */
1344 11343517 : xfs_dir2_db_t fdb; /* freeblock block number */
1345 11343517 : int findex; /* index in freeblock entries */
1346 11343517 : xfs_dir2_free_t *free; /* freeblock structure */
1347 :
1348 : /*
1349 : * Convert the data block number to a free block,
1350 : * read in the free block.
1351 : */
1352 11343517 : fdb = xfs_dir2_db_to_fdb(geo, db);
1353 11343853 : error = xfs_dir2_free_read(tp, dp, xfs_dir2_db_to_da(geo, fdb),
1354 : &fbp);
1355 11343957 : if (error)
1356 2 : return error;
1357 11343955 : free = fbp->b_addr;
1358 : #ifdef DEBUG
1359 : {
1360 11343955 : struct xfs_dir3_icfree_hdr freehdr;
1361 :
1362 11343955 : xfs_dir2_free_hdr_from_disk(dp->i_mount, &freehdr, free);
1363 11343930 : ASSERT(freehdr.firstdb == geo->free_max_bests *
1364 : (fdb - xfs_dir2_byte_to_db(geo, XFS_DIR2_FREE_OFFSET)));
1365 : }
1366 : #endif
1367 : /*
1368 : * Calculate which entry we need to fix.
1369 : */
1370 11343981 : findex = xfs_dir2_db_to_fdindex(geo, db);
1371 11343891 : longest = be16_to_cpu(bf[0].length);
1372 : /*
1373 : * If the data block is now empty we can get rid of it
1374 : * (usually).
1375 : */
1376 11343891 : if (longest == geo->blksize - geo->data_entry_offset) {
1377 : /*
1378 : * Try to punch out the data block.
1379 : */
1380 14896 : error = xfs_dir2_shrink_inode(args, db, dbp);
1381 14896 : if (error == 0) {
1382 14896 : dblk->bp = NULL;
1383 14896 : hdr = NULL;
1384 : }
1385 : /*
1386 : * We can get ENOSPC if there's no space reservation.
1387 : * In this case just drop the buffer and some one else
1388 : * will eventually get rid of the empty block.
1389 : */
1390 0 : else if (!(error == -ENOSPC && args->total == 0))
1391 : return error;
1392 : }
1393 : /*
1394 : * If we got rid of the data block, we can eliminate that entry
1395 : * in the free block.
1396 : */
1397 11343891 : error = xfs_dir3_data_block_free(args, hdr, free,
1398 : fdb, findex, fbp, longest);
1399 11343953 : if (error)
1400 : return error;
1401 : }
1402 :
1403 26759315 : xfs_dir3_leaf_check(dp, bp);
1404 : /*
1405 : * Return indication of whether this leaf block is empty enough
1406 : * to justify trying to join it with a neighbor.
1407 : */
1408 26757883 : *rval = (geo->leaf_hdr_size +
1409 26757883 : (uint)sizeof(leafhdr.ents) * (leafhdr.count - leafhdr.stale)) <
1410 26757883 : geo->magicpct;
1411 26757883 : return 0;
1412 : }
1413 :
1414 : /*
1415 : * Split the leaf entries in the old block into old and new blocks.
1416 : */
1417 : int /* error */
1418 24399 : xfs_dir2_leafn_split(
1419 : xfs_da_state_t *state, /* btree cursor */
1420 : xfs_da_state_blk_t *oldblk, /* original block */
1421 : xfs_da_state_blk_t *newblk) /* newly created block */
1422 : {
1423 24399 : xfs_da_args_t *args; /* operation arguments */
1424 24399 : xfs_dablk_t blkno; /* new leaf block number */
1425 24399 : int error; /* error return value */
1426 24399 : struct xfs_inode *dp;
1427 :
1428 : /*
1429 : * Allocate space for a new leaf node.
1430 : */
1431 24399 : args = state->args;
1432 24399 : dp = args->dp;
1433 24399 : ASSERT(oldblk->magic == XFS_DIR2_LEAFN_MAGIC);
1434 24399 : error = xfs_da_grow_inode(args, &blkno);
1435 24399 : if (error) {
1436 : return error;
1437 : }
1438 : /*
1439 : * Initialize the new leaf block.
1440 : */
1441 24399 : error = xfs_dir3_leaf_get_buf(args, xfs_dir2_da_to_db(args->geo, blkno),
1442 : &newblk->bp, XFS_DIR2_LEAFN_MAGIC);
1443 24399 : if (error)
1444 : return error;
1445 :
1446 24399 : newblk->blkno = blkno;
1447 24399 : newblk->magic = XFS_DIR2_LEAFN_MAGIC;
1448 : /*
1449 : * Rebalance the entries across the two leaves, link the new
1450 : * block into the leaves.
1451 : */
1452 24399 : xfs_dir2_leafn_rebalance(state, oldblk, newblk);
1453 24399 : error = xfs_da3_blk_link(state, oldblk, newblk);
1454 24399 : if (error) {
1455 : return error;
1456 : }
1457 : /*
1458 : * Insert the new entry in the correct block.
1459 : */
1460 24399 : if (state->inleaf)
1461 5570 : error = xfs_dir2_leafn_add(oldblk->bp, args, oldblk->index);
1462 : else
1463 18829 : error = xfs_dir2_leafn_add(newblk->bp, args, newblk->index);
1464 : /*
1465 : * Update last hashval in each block since we added the name.
1466 : */
1467 24399 : oldblk->hashval = xfs_dir2_leaf_lasthash(dp, oldblk->bp, NULL);
1468 24399 : newblk->hashval = xfs_dir2_leaf_lasthash(dp, newblk->bp, NULL);
1469 24399 : xfs_dir3_leaf_check(dp, oldblk->bp);
1470 24399 : xfs_dir3_leaf_check(dp, newblk->bp);
1471 24399 : return error;
1472 : }
1473 :
1474 : /*
1475 : * Check a leaf block and its neighbors to see if the block should be
1476 : * collapsed into one or the other neighbor. Always keep the block
1477 : * with the smaller block number.
1478 : * If the current block is over 50% full, don't try to join it, return 0.
1479 : * If the block is empty, fill in the state structure and return 2.
1480 : * If it can be collapsed, fill in the state structure and return 1.
1481 : * If nothing can be done, return 0.
1482 : */
1483 : int /* error */
1484 1654145 : xfs_dir2_leafn_toosmall(
1485 : xfs_da_state_t *state, /* btree cursor */
1486 : int *action) /* resulting action to take */
1487 : {
1488 1654145 : xfs_da_state_blk_t *blk; /* leaf block */
1489 1654145 : xfs_dablk_t blkno; /* leaf block number */
1490 1654145 : struct xfs_buf *bp; /* leaf buffer */
1491 1654145 : int bytes; /* bytes in use */
1492 1654145 : int count; /* leaf live entry count */
1493 1654145 : int error; /* error return value */
1494 1654145 : int forward; /* sibling block direction */
1495 1654145 : int i; /* sibling counter */
1496 1654145 : xfs_dir2_leaf_t *leaf; /* leaf structure */
1497 1654145 : int rval; /* result from path_shift */
1498 1654145 : struct xfs_dir3_icleaf_hdr leafhdr;
1499 1654145 : struct xfs_dir2_leaf_entry *ents;
1500 1654145 : struct xfs_inode *dp = state->args->dp;
1501 :
1502 : /*
1503 : * Check for the degenerate case of the block being over 50% full.
1504 : * If so, it's not worth even looking to see if we might be able
1505 : * to coalesce with a sibling.
1506 : */
1507 1654145 : blk = &state->path.blk[state->path.active - 1];
1508 1654145 : leaf = blk->bp->b_addr;
1509 1654145 : xfs_dir2_leaf_hdr_from_disk(dp->i_mount, &leafhdr, leaf);
1510 1654146 : ents = leafhdr.ents;
1511 1654146 : xfs_dir3_leaf_check(dp, blk->bp);
1512 :
1513 1654147 : count = leafhdr.count - leafhdr.stale;
1514 1654147 : bytes = state->args->geo->leaf_hdr_size + count * sizeof(ents[0]);
1515 1654147 : if (bytes > (state->args->geo->blksize >> 1)) {
1516 : /*
1517 : * Blk over 50%, don't try to join.
1518 : */
1519 0 : *action = 0;
1520 0 : return 0;
1521 : }
1522 : /*
1523 : * Check for the degenerate case of the block being empty.
1524 : * If the block is empty, we'll simply delete it, no need to
1525 : * coalesce it with a sibling block. We choose (arbitrarily)
1526 : * to merge with the forward block unless it is NULL.
1527 : */
1528 1654147 : if (count == 0) {
1529 : /*
1530 : * Make altpath point to the block we want to keep and
1531 : * path point to the block we want to drop (this one).
1532 : */
1533 1 : forward = (leafhdr.forw != 0);
1534 2 : memcpy(&state->altpath, &state->path, sizeof(state->path));
1535 1 : error = xfs_da3_path_shift(state, &state->altpath, forward, 0,
1536 : &rval);
1537 1 : if (error)
1538 : return error;
1539 1 : *action = rval ? 2 : 0;
1540 1 : return 0;
1541 : }
1542 : /*
1543 : * Examine each sibling block to see if we can coalesce with
1544 : * at least 25% free space to spare. We need to figure out
1545 : * whether to merge with the forward or the backward block.
1546 : * We prefer coalescing with the lower numbered sibling so as
1547 : * to shrink a directory over time.
1548 : */
1549 1654146 : forward = leafhdr.forw < leafhdr.back;
1550 4938100 : for (i = 0, bp = NULL; i < 2; forward = !forward, i++) {
1551 3303069 : struct xfs_dir3_icleaf_hdr hdr2;
1552 :
1553 3303069 : blkno = forward ? leafhdr.forw : leafhdr.back;
1554 3303069 : if (blkno == 0)
1555 1437017 : continue;
1556 : /*
1557 : * Read the sibling leaf block.
1558 : */
1559 1866052 : error = xfs_dir3_leafn_read(state->args->trans, dp, blkno, &bp);
1560 1866055 : if (error)
1561 0 : return error;
1562 :
1563 : /*
1564 : * Count bytes in the two blocks combined.
1565 : */
1566 1866055 : count = leafhdr.count - leafhdr.stale;
1567 1866055 : bytes = state->args->geo->blksize -
1568 1866055 : (state->args->geo->blksize >> 2);
1569 :
1570 1866055 : leaf = bp->b_addr;
1571 1866055 : xfs_dir2_leaf_hdr_from_disk(dp->i_mount, &hdr2, leaf);
1572 1866055 : ents = hdr2.ents;
1573 1866055 : count += hdr2.count - hdr2.stale;
1574 1866055 : bytes -= count * sizeof(ents[0]);
1575 :
1576 : /*
1577 : * Fits with at least 25% to spare.
1578 : */
1579 1866055 : if (bytes >= 0)
1580 : break;
1581 1846937 : xfs_trans_brelse(state->args->trans, bp);
1582 : }
1583 : /*
1584 : * Didn't like either block, give up.
1585 : */
1586 1654149 : if (i >= 2) {
1587 1635031 : *action = 0;
1588 1635031 : return 0;
1589 : }
1590 :
1591 : /*
1592 : * Make altpath point to the block we want to keep (the lower
1593 : * numbered block) and path point to the block we want to drop.
1594 : */
1595 38236 : memcpy(&state->altpath, &state->path, sizeof(state->path));
1596 19118 : if (blkno < blk->blkno)
1597 6107 : error = xfs_da3_path_shift(state, &state->altpath, forward, 0,
1598 : &rval);
1599 : else
1600 13011 : error = xfs_da3_path_shift(state, &state->path, forward, 0,
1601 : &rval);
1602 19118 : if (error) {
1603 : return error;
1604 : }
1605 19118 : *action = rval ? 0 : 1;
1606 19118 : return 0;
1607 : }
1608 :
1609 : /*
1610 : * Move all the leaf entries from drop_blk to save_blk.
1611 : * This is done as part of a join operation.
1612 : */
1613 : void
1614 19118 : xfs_dir2_leafn_unbalance(
1615 : xfs_da_state_t *state, /* cursor */
1616 : xfs_da_state_blk_t *drop_blk, /* dead block */
1617 : xfs_da_state_blk_t *save_blk) /* surviving block */
1618 : {
1619 19118 : xfs_da_args_t *args; /* operation arguments */
1620 19118 : xfs_dir2_leaf_t *drop_leaf; /* dead leaf structure */
1621 19118 : xfs_dir2_leaf_t *save_leaf; /* surviving leaf structure */
1622 19118 : struct xfs_dir3_icleaf_hdr savehdr;
1623 19118 : struct xfs_dir3_icleaf_hdr drophdr;
1624 19118 : struct xfs_dir2_leaf_entry *sents;
1625 19118 : struct xfs_dir2_leaf_entry *dents;
1626 19118 : struct xfs_inode *dp = state->args->dp;
1627 :
1628 19118 : args = state->args;
1629 19118 : ASSERT(drop_blk->magic == XFS_DIR2_LEAFN_MAGIC);
1630 19118 : ASSERT(save_blk->magic == XFS_DIR2_LEAFN_MAGIC);
1631 19118 : drop_leaf = drop_blk->bp->b_addr;
1632 19118 : save_leaf = save_blk->bp->b_addr;
1633 :
1634 19118 : xfs_dir2_leaf_hdr_from_disk(dp->i_mount, &savehdr, save_leaf);
1635 19118 : xfs_dir2_leaf_hdr_from_disk(dp->i_mount, &drophdr, drop_leaf);
1636 19118 : sents = savehdr.ents;
1637 19118 : dents = drophdr.ents;
1638 :
1639 : /*
1640 : * If there are any stale leaf entries, take this opportunity
1641 : * to purge them.
1642 : */
1643 19118 : if (drophdr.stale)
1644 16836 : xfs_dir3_leaf_compact(args, &drophdr, drop_blk->bp);
1645 19118 : if (savehdr.stale)
1646 19044 : xfs_dir3_leaf_compact(args, &savehdr, save_blk->bp);
1647 :
1648 : /*
1649 : * Move the entries from drop to the appropriate end of save.
1650 : */
1651 19118 : drop_blk->hashval = be32_to_cpu(dents[drophdr.count - 1].hashval);
1652 19118 : if (xfs_dir2_leafn_order(dp, save_blk->bp, drop_blk->bp))
1653 3025 : xfs_dir3_leafn_moveents(args, drop_blk->bp, &drophdr, dents, 0,
1654 : save_blk->bp, &savehdr, sents, 0,
1655 3025 : drophdr.count);
1656 : else
1657 16093 : xfs_dir3_leafn_moveents(args, drop_blk->bp, &drophdr, dents, 0,
1658 : save_blk->bp, &savehdr, sents,
1659 16093 : savehdr.count, drophdr.count);
1660 19118 : save_blk->hashval = be32_to_cpu(sents[savehdr.count - 1].hashval);
1661 :
1662 : /* log the changes made when moving the entries */
1663 19118 : xfs_dir2_leaf_hdr_to_disk(dp->i_mount, save_leaf, &savehdr);
1664 19118 : xfs_dir2_leaf_hdr_to_disk(dp->i_mount, drop_leaf, &drophdr);
1665 19118 : xfs_dir3_leaf_log_header(args, save_blk->bp);
1666 19118 : xfs_dir3_leaf_log_header(args, drop_blk->bp);
1667 :
1668 19118 : xfs_dir3_leaf_check(dp, save_blk->bp);
1669 19118 : xfs_dir3_leaf_check(dp, drop_blk->bp);
1670 19118 : }
1671 :
1672 : /*
1673 : * Add a new data block to the directory at the free space index that the caller
1674 : * has specified.
1675 : */
1676 : static int
1677 30142 : xfs_dir2_node_add_datablk(
1678 : struct xfs_da_args *args,
1679 : struct xfs_da_state_blk *fblk,
1680 : xfs_dir2_db_t *dbno,
1681 : struct xfs_buf **dbpp,
1682 : struct xfs_buf **fbpp,
1683 : struct xfs_dir3_icfree_hdr *hdr,
1684 : int *findex)
1685 : {
1686 30142 : struct xfs_inode *dp = args->dp;
1687 30142 : struct xfs_trans *tp = args->trans;
1688 30142 : struct xfs_mount *mp = dp->i_mount;
1689 30142 : struct xfs_dir2_data_free *bf;
1690 30142 : xfs_dir2_db_t fbno;
1691 30142 : struct xfs_buf *fbp;
1692 30142 : struct xfs_buf *dbp;
1693 30142 : int error;
1694 :
1695 : /* Not allowed to allocate, return failure. */
1696 30142 : if (args->total == 0)
1697 : return -ENOSPC;
1698 :
1699 : /* Allocate and initialize the new data block. */
1700 30142 : error = xfs_dir2_grow_inode(args, XFS_DIR2_DATA_SPACE, dbno);
1701 30142 : if (error)
1702 : return error;
1703 30142 : error = xfs_dir3_data_init(args, *dbno, &dbp);
1704 30142 : if (error)
1705 : return error;
1706 :
1707 : /*
1708 : * Get the freespace block corresponding to the data block
1709 : * that was just allocated.
1710 : */
1711 30142 : fbno = xfs_dir2_db_to_fdb(args->geo, *dbno);
1712 30142 : error = xfs_dir2_free_try_read(tp, dp,
1713 : xfs_dir2_db_to_da(args->geo, fbno), &fbp);
1714 30142 : if (error)
1715 : return error;
1716 :
1717 : /*
1718 : * If there wasn't a freespace block, the read will
1719 : * return a NULL fbp. Allocate and initialize a new one.
1720 : */
1721 30142 : if (!fbp) {
1722 3 : error = xfs_dir2_grow_inode(args, XFS_DIR2_FREE_SPACE, &fbno);
1723 3 : if (error)
1724 : return error;
1725 :
1726 3 : if (XFS_IS_CORRUPT(mp,
1727 : xfs_dir2_db_to_fdb(args->geo, *dbno) !=
1728 : fbno)) {
1729 0 : xfs_alert(mp,
1730 : "%s: dir ino %llu needed freesp block %lld for data block %lld, got %lld",
1731 : __func__, (unsigned long long)dp->i_ino,
1732 : (long long)xfs_dir2_db_to_fdb(args->geo, *dbno),
1733 : (long long)*dbno, (long long)fbno);
1734 0 : if (fblk) {
1735 0 : xfs_alert(mp,
1736 : " fblk "PTR_FMT" blkno %llu index %d magic 0x%x",
1737 : fblk, (unsigned long long)fblk->blkno,
1738 : fblk->index, fblk->magic);
1739 : } else {
1740 0 : xfs_alert(mp, " ... fblk is NULL");
1741 : }
1742 0 : return -EFSCORRUPTED;
1743 : }
1744 :
1745 : /* Get a buffer for the new block. */
1746 3 : error = xfs_dir3_free_get_buf(args, fbno, &fbp);
1747 3 : if (error)
1748 : return error;
1749 3 : xfs_dir2_free_hdr_from_disk(mp, hdr, fbp->b_addr);
1750 :
1751 : /* Remember the first slot as our empty slot. */
1752 3 : hdr->firstdb = (fbno - xfs_dir2_byte_to_db(args->geo,
1753 3 : XFS_DIR2_FREE_OFFSET)) *
1754 3 : args->geo->free_max_bests;
1755 : } else {
1756 30139 : xfs_dir2_free_hdr_from_disk(mp, hdr, fbp->b_addr);
1757 : }
1758 :
1759 : /* Set the freespace block index from the data block number. */
1760 30142 : *findex = xfs_dir2_db_to_fdindex(args->geo, *dbno);
1761 :
1762 : /* Extend the freespace table if the new data block is off the end. */
1763 30142 : if (*findex >= hdr->nvalid) {
1764 29769 : ASSERT(*findex < args->geo->free_max_bests);
1765 29769 : hdr->nvalid = *findex + 1;
1766 29769 : hdr->bests[*findex] = cpu_to_be16(NULLDATAOFF);
1767 : }
1768 :
1769 : /*
1770 : * If this entry was for an empty data block (this should always be
1771 : * true) then update the header.
1772 : */
1773 30142 : if (hdr->bests[*findex] == cpu_to_be16(NULLDATAOFF)) {
1774 30142 : hdr->nused++;
1775 30142 : xfs_dir2_free_hdr_to_disk(mp, fbp->b_addr, hdr);
1776 30142 : xfs_dir2_free_log_header(args, fbp);
1777 : }
1778 :
1779 : /* Update the freespace value for the new block in the table. */
1780 30142 : bf = xfs_dir2_data_bestfree_p(mp, dbp->b_addr);
1781 30142 : hdr->bests[*findex] = bf[0].length;
1782 :
1783 30142 : *dbpp = dbp;
1784 30142 : *fbpp = fbp;
1785 30142 : return 0;
1786 : }
1787 :
1788 : static int
1789 28218083 : xfs_dir2_node_find_freeblk(
1790 : struct xfs_da_args *args,
1791 : struct xfs_da_state_blk *fblk,
1792 : xfs_dir2_db_t *dbnop,
1793 : struct xfs_buf **fbpp,
1794 : struct xfs_dir3_icfree_hdr *hdr,
1795 : int *findexp,
1796 : int length)
1797 : {
1798 28218083 : struct xfs_inode *dp = args->dp;
1799 28218083 : struct xfs_trans *tp = args->trans;
1800 28218083 : struct xfs_buf *fbp = NULL;
1801 28218083 : xfs_dir2_db_t firstfbno;
1802 28218083 : xfs_dir2_db_t lastfbno;
1803 28218083 : xfs_dir2_db_t ifbno = -1;
1804 28218083 : xfs_dir2_db_t dbno = -1;
1805 28218083 : xfs_dir2_db_t fbno;
1806 28218083 : xfs_fileoff_t fo;
1807 28218083 : int findex = 0;
1808 28218083 : int error;
1809 :
1810 : /*
1811 : * If we came in with a freespace block that means that lookup
1812 : * found an entry with our hash value. This is the freespace
1813 : * block for that data entry.
1814 : */
1815 28218083 : if (fblk) {
1816 254511 : fbp = fblk->bp;
1817 254511 : findex = fblk->index;
1818 254511 : xfs_dir2_free_hdr_from_disk(dp->i_mount, hdr, fbp->b_addr);
1819 254511 : if (findex >= 0) {
1820 : /* caller already found the freespace for us. */
1821 56944 : ASSERT(findex < hdr->nvalid);
1822 56944 : ASSERT(be16_to_cpu(hdr->bests[findex]) != NULLDATAOFF);
1823 56944 : ASSERT(be16_to_cpu(hdr->bests[findex]) >= length);
1824 56944 : dbno = hdr->firstdb + findex;
1825 56944 : goto found_block;
1826 : }
1827 :
1828 : /*
1829 : * The data block looked at didn't have enough room.
1830 : * We'll start at the beginning of the freespace entries.
1831 : */
1832 197567 : ifbno = fblk->blkno;
1833 197567 : xfs_trans_brelse(tp, fbp);
1834 197567 : fbp = NULL;
1835 197567 : fblk->bp = NULL;
1836 : }
1837 :
1838 : /*
1839 : * If we don't have a data block yet, we're going to scan the freespace
1840 : * data for a data block with enough free space in it.
1841 : */
1842 28161139 : error = xfs_bmap_last_offset(dp, &fo, XFS_DATA_FORK);
1843 28161003 : if (error)
1844 : return error;
1845 28162659 : lastfbno = xfs_dir2_da_to_db(args->geo, (xfs_dablk_t)fo);
1846 28163131 : firstfbno = xfs_dir2_byte_to_db(args->geo, XFS_DIR2_FREE_OFFSET);
1847 :
1848 28576377 : for (fbno = lastfbno - 1; fbno >= firstfbno; fbno--) {
1849 : /* If it's ifbno we already looked at it. */
1850 28546235 : if (fbno == ifbno)
1851 126492 : continue;
1852 :
1853 : /*
1854 : * Read the block. There can be holes in the freespace blocks,
1855 : * so this might not succeed. This should be really rare, so
1856 : * there's no reason to avoid it.
1857 : */
1858 28419743 : error = xfs_dir2_free_try_read(tp, dp,
1859 : xfs_dir2_db_to_da(args->geo, fbno),
1860 : &fbp);
1861 28419558 : if (error)
1862 197 : return error;
1863 28419361 : if (!fbp)
1864 0 : continue;
1865 :
1866 28419361 : xfs_dir2_free_hdr_from_disk(dp->i_mount, hdr, fbp->b_addr);
1867 :
1868 : /* Scan the free entry array for a large enough free space. */
1869 476899798 : for (findex = hdr->nvalid - 1; findex >= 0; findex--) {
1870 950934632 : if (be16_to_cpu(hdr->bests[findex]) != NULLDATAOFF &&
1871 474322124 : be16_to_cpu(hdr->bests[findex]) >= length) {
1872 28132540 : dbno = hdr->firstdb + findex;
1873 28132540 : goto found_block;
1874 : }
1875 : }
1876 :
1877 : /* Didn't find free space, go on to next free block */
1878 287290 : xfs_trans_brelse(tp, fbp);
1879 : }
1880 :
1881 30142 : found_block:
1882 28219626 : *dbnop = dbno;
1883 28219626 : *fbpp = fbp;
1884 28219626 : *findexp = findex;
1885 28219626 : return 0;
1886 : }
1887 :
1888 : /*
1889 : * Add the data entry for a node-format directory name addition.
1890 : * The leaf entry is added in xfs_dir2_leafn_add.
1891 : * We may enter with a freespace block that the lookup found.
1892 : */
1893 : static int
1894 28218657 : xfs_dir2_node_addname_int(
1895 : struct xfs_da_args *args, /* operation arguments */
1896 : struct xfs_da_state_blk *fblk) /* optional freespace block */
1897 : {
1898 28218657 : struct xfs_dir2_data_unused *dup; /* data unused entry pointer */
1899 28218657 : struct xfs_dir2_data_entry *dep; /* data entry pointer */
1900 28218657 : struct xfs_dir2_data_hdr *hdr; /* data block header */
1901 28218657 : struct xfs_dir2_data_free *bf;
1902 28218657 : struct xfs_trans *tp = args->trans;
1903 28218657 : struct xfs_inode *dp = args->dp;
1904 28218657 : struct xfs_dir3_icfree_hdr freehdr;
1905 28218657 : struct xfs_buf *dbp; /* data block buffer */
1906 28218657 : struct xfs_buf *fbp; /* freespace buffer */
1907 28218657 : xfs_dir2_data_aoff_t aoff;
1908 28218657 : xfs_dir2_db_t dbno; /* data block number */
1909 28218657 : int error; /* error return value */
1910 28218657 : int findex; /* freespace entry index */
1911 28218657 : int length; /* length of the new entry */
1912 28218657 : int logfree = 0; /* need to log free entry */
1913 28218657 : int needlog = 0; /* need to log data header */
1914 28218657 : int needscan = 0; /* need to rescan data frees */
1915 28218657 : __be16 *tagp; /* data entry tag pointer */
1916 :
1917 28218657 : length = xfs_dir2_data_entsize(dp->i_mount, args->namelen);
1918 28218657 : error = xfs_dir2_node_find_freeblk(args, fblk, &dbno, &fbp, &freehdr,
1919 : &findex, length);
1920 28219400 : if (error)
1921 : return error;
1922 :
1923 : /*
1924 : * Now we know if we must allocate blocks, so if we are checking whether
1925 : * we can insert without allocation then we can return now.
1926 : */
1927 28219203 : if (args->op_flags & XFS_DA_OP_JUSTCHECK) {
1928 0 : if (dbno == -1)
1929 : return -ENOSPC;
1930 0 : return 0;
1931 : }
1932 :
1933 : /*
1934 : * If we don't have a data block, we need to allocate one and make
1935 : * the freespace entries refer to it.
1936 : */
1937 28219203 : if (dbno == -1) {
1938 : /* we're going to have to log the free block index later */
1939 30142 : logfree = 1;
1940 30142 : error = xfs_dir2_node_add_datablk(args, fblk, &dbno, &dbp, &fbp,
1941 : &freehdr, &findex);
1942 : } else {
1943 : /* Read the data block in. */
1944 28189061 : error = xfs_dir3_data_read(tp, dp,
1945 : xfs_dir2_db_to_da(args->geo, dbno),
1946 : 0, &dbp);
1947 : }
1948 28219813 : if (error)
1949 : return error;
1950 :
1951 : /* setup for data block up now */
1952 28219682 : hdr = dbp->b_addr;
1953 28219682 : bf = xfs_dir2_data_bestfree_p(dp->i_mount, hdr);
1954 28219622 : ASSERT(be16_to_cpu(bf[0].length) >= length);
1955 :
1956 : /* Point to the existing unused space. */
1957 56439244 : dup = (xfs_dir2_data_unused_t *)
1958 28219622 : ((char *)hdr + be16_to_cpu(bf[0].offset));
1959 :
1960 : /* Mark the first part of the unused space, inuse for us. */
1961 28219622 : aoff = (xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr);
1962 28219622 : error = xfs_dir2_data_use_free(args, dbp, dup, aoff, length,
1963 : &needlog, &needscan);
1964 28217535 : if (error) {
1965 0 : xfs_trans_brelse(tp, dbp);
1966 0 : return error;
1967 : }
1968 :
1969 : /* Fill in the new entry and log it. */
1970 28217535 : dep = (xfs_dir2_data_entry_t *)dup;
1971 28217535 : dep->inumber = cpu_to_be64(args->inumber);
1972 28217535 : dep->namelen = args->namelen;
1973 56435070 : memcpy(dep->name, args->name, dep->namelen);
1974 28217535 : xfs_dir2_data_put_ftype(dp->i_mount, dep, args->filetype);
1975 28217794 : tagp = xfs_dir2_data_entry_tag_p(dp->i_mount, dep);
1976 28218772 : *tagp = cpu_to_be16((char *)dep - (char *)hdr);
1977 28218772 : xfs_dir2_data_log_entry(args, dbp, dep);
1978 :
1979 : /* Rescan the freespace and log the data block if needed. */
1980 28219115 : if (needscan)
1981 13305660 : xfs_dir2_data_freescan(dp->i_mount, hdr, &needlog);
1982 28219341 : if (needlog)
1983 28218193 : xfs_dir2_data_log_header(args, dbp);
1984 :
1985 : /* If the freespace block entry is now wrong, update it. */
1986 28219104 : if (freehdr.bests[findex] != bf[0].length) {
1987 13996313 : freehdr.bests[findex] = bf[0].length;
1988 13996313 : logfree = 1;
1989 : }
1990 :
1991 : /* Log the freespace entry if needed. */
1992 28219104 : if (logfree)
1993 13996313 : xfs_dir2_free_log_bests(args, &freehdr, fbp, findex, findex);
1994 :
1995 : /* Return the data block and offset in args. */
1996 28218704 : args->blkno = (xfs_dablk_t)dbno;
1997 28218704 : args->index = be16_to_cpu(*tagp);
1998 28218704 : return 0;
1999 : }
2000 :
2001 : /*
2002 : * Top-level node form directory addname routine.
2003 : */
2004 : int /* error */
2005 28216162 : xfs_dir2_node_addname(
2006 : xfs_da_args_t *args) /* operation arguments */
2007 : {
2008 28216162 : xfs_da_state_blk_t *blk; /* leaf block for insert */
2009 28216162 : int error; /* error return value */
2010 28216162 : int rval; /* sub-return value */
2011 28216162 : xfs_da_state_t *state; /* btree cursor */
2012 :
2013 28216162 : trace_xfs_dir2_node_addname(args);
2014 :
2015 : /*
2016 : * Allocate and initialize the state (btree cursor).
2017 : */
2018 28219558 : state = xfs_da_state_alloc(args);
2019 : /*
2020 : * Look up the name. We're not supposed to find it, but
2021 : * this gives us the insertion point.
2022 : */
2023 28217818 : error = xfs_da3_node_lookup_int(state, &rval);
2024 28217177 : if (error)
2025 4 : rval = error;
2026 28217177 : if (rval != -ENOENT) {
2027 4 : goto done;
2028 : }
2029 : /*
2030 : * Add the data entry to a data block.
2031 : * Extravalid is set to a freeblock found by lookup.
2032 : */
2033 28217173 : rval = xfs_dir2_node_addname_int(args,
2034 28217173 : state->extravalid ? &state->extrablk : NULL);
2035 28219112 : if (rval) {
2036 328 : goto done;
2037 : }
2038 28218784 : blk = &state->path.blk[state->path.active - 1];
2039 28218764 : ASSERT(blk->magic == XFS_DIR2_LEAFN_MAGIC);
2040 : /*
2041 : * Add the new leaf entry.
2042 : */
2043 28218764 : rval = xfs_dir2_leafn_add(blk->bp, args, blk->index);
2044 28217274 : if (rval == 0) {
2045 : /*
2046 : * It worked, fix the hash values up the btree.
2047 : */
2048 28192875 : if (!(args->op_flags & XFS_DA_OP_JUSTCHECK))
2049 28195053 : xfs_da3_fixhashpath(state, &state->path);
2050 : } else {
2051 : /*
2052 : * It didn't work, we need to split the leaf block.
2053 : */
2054 24399 : if (args->total == 0) {
2055 0 : ASSERT(rval == -ENOSPC);
2056 0 : goto done;
2057 : }
2058 : /*
2059 : * Split the leaf block and insert the new entry.
2060 : */
2061 24399 : rval = xfs_da3_split(state);
2062 : }
2063 28217046 : done:
2064 28217046 : xfs_da_state_free(state);
2065 28219676 : return rval;
2066 : }
2067 :
2068 : /*
2069 : * Lookup an entry in a node-format directory.
2070 : * All the real work happens in xfs_da3_node_lookup_int.
2071 : * The only real output is the inode number of the entry.
2072 : */
2073 : int /* error */
2074 122643571 : xfs_dir2_node_lookup(
2075 : xfs_da_args_t *args) /* operation arguments */
2076 : {
2077 122643571 : int error; /* error return value */
2078 122643571 : int i; /* btree level */
2079 122643571 : int rval; /* operation return value */
2080 122643571 : xfs_da_state_t *state; /* btree cursor */
2081 :
2082 122643571 : trace_xfs_dir2_node_lookup(args);
2083 :
2084 : /*
2085 : * Allocate and initialize the btree cursor.
2086 : */
2087 122643845 : state = xfs_da_state_alloc(args);
2088 :
2089 : /*
2090 : * Fill in the path to the entry in the cursor.
2091 : */
2092 122644011 : error = xfs_da3_node_lookup_int(state, &rval);
2093 122641898 : if (error)
2094 7359 : rval = error;
2095 122634539 : else if (rval == -ENOENT && args->cmpresult == XFS_CMP_CASE) {
2096 : /* If a CI match, dup the actual name and return -EEXIST */
2097 58413 : xfs_dir2_data_entry_t *dep;
2098 :
2099 58413 : dep = (xfs_dir2_data_entry_t *)
2100 58413 : ((char *)state->extrablk.bp->b_addr +
2101 58413 : state->extrablk.index);
2102 58413 : rval = xfs_dir_cilookup_result(args, dep->name, dep->namelen);
2103 : }
2104 : /*
2105 : * Release the btree blocks and leaf block.
2106 : */
2107 369193772 : for (i = 0; i < state->path.active; i++) {
2108 246549020 : xfs_trans_brelse(args->trans, state->path.blk[i].bp);
2109 246566441 : state->path.blk[i].bp = NULL;
2110 : }
2111 : /*
2112 : * Release the data block if we have it.
2113 : */
2114 122644752 : if (state->extravalid && state->extrablk.bp) {
2115 115294304 : xfs_trans_brelse(args->trans, state->extrablk.bp);
2116 115294315 : state->extrablk.bp = NULL;
2117 : }
2118 122644763 : xfs_da_state_free(state);
2119 122641075 : return rval;
2120 : }
2121 :
2122 : /*
2123 : * Remove an entry from a node-format directory.
2124 : */
2125 : int /* error */
2126 26758210 : xfs_dir2_node_removename(
2127 : struct xfs_da_args *args) /* operation arguments */
2128 : {
2129 26758210 : struct xfs_da_state_blk *blk; /* leaf block */
2130 26758210 : int error; /* error return value */
2131 26758210 : int rval; /* operation return value */
2132 26758210 : struct xfs_da_state *state; /* btree cursor */
2133 :
2134 26758210 : trace_xfs_dir2_node_removename(args);
2135 :
2136 : /*
2137 : * Allocate and initialize the btree cursor.
2138 : */
2139 26758997 : state = xfs_da_state_alloc(args);
2140 :
2141 : /* Look up the entry we're deleting, set up the cursor. */
2142 26758325 : error = xfs_da3_node_lookup_int(state, &rval);
2143 26757890 : if (error)
2144 2 : goto out_free;
2145 :
2146 : /* Didn't find it, upper layer screwed up. */
2147 26757888 : if (rval != -EEXIST) {
2148 0 : error = rval;
2149 0 : goto out_free;
2150 : }
2151 :
2152 26757888 : blk = &state->path.blk[state->path.active - 1];
2153 26758823 : ASSERT(blk->magic == XFS_DIR2_LEAFN_MAGIC);
2154 26758823 : ASSERT(state->extravalid);
2155 : /*
2156 : * Remove the leaf and data entries.
2157 : * Extrablk refers to the data block.
2158 : */
2159 26758823 : error = xfs_dir2_leafn_remove(args, blk->bp, blk->index,
2160 : &state->extrablk, &rval);
2161 26757715 : if (error)
2162 2 : goto out_free;
2163 : /*
2164 : * Fix the hash values up the btree.
2165 : */
2166 26757713 : xfs_da3_fixhashpath(state, &state->path);
2167 : /*
2168 : * If we need to join leaf blocks, do it.
2169 : */
2170 26758346 : if (rval && state->path.active > 1)
2171 1654145 : error = xfs_da3_join(state);
2172 : /*
2173 : * If no errors so far, try conversion to leaf format.
2174 : */
2175 26758351 : if (!error)
2176 26758351 : error = xfs_dir2_node_to_leaf(state);
2177 0 : out_free:
2178 26758228 : xfs_da_state_free(state);
2179 26758306 : return error;
2180 : }
2181 :
2182 : /*
2183 : * Replace an entry's inode number in a node-format directory.
2184 : */
2185 : int /* error */
2186 452870 : xfs_dir2_node_replace(
2187 : xfs_da_args_t *args) /* operation arguments */
2188 : {
2189 452870 : xfs_da_state_blk_t *blk; /* leaf block */
2190 452870 : xfs_dir2_data_hdr_t *hdr; /* data block header */
2191 452870 : xfs_dir2_data_entry_t *dep; /* data entry changed */
2192 452870 : int error; /* error return value */
2193 452870 : int i; /* btree level */
2194 452870 : xfs_ino_t inum; /* new inode number */
2195 452870 : int ftype; /* new file type */
2196 452870 : int rval; /* internal return value */
2197 452870 : xfs_da_state_t *state; /* btree cursor */
2198 :
2199 452870 : trace_xfs_dir2_node_replace(args);
2200 :
2201 : /*
2202 : * Allocate and initialize the btree cursor.
2203 : */
2204 452873 : state = xfs_da_state_alloc(args);
2205 :
2206 : /*
2207 : * We have to save new inode number and ftype since
2208 : * xfs_da3_node_lookup_int() is going to overwrite them
2209 : */
2210 452873 : inum = args->inumber;
2211 452873 : ftype = args->filetype;
2212 :
2213 : /*
2214 : * Lookup the entry to change in the btree.
2215 : */
2216 452873 : error = xfs_da3_node_lookup_int(state, &rval);
2217 452873 : if (error) {
2218 114 : rval = error;
2219 : }
2220 : /*
2221 : * It should be found, since the vnodeops layer has looked it up
2222 : * and locked it. But paranoia is good.
2223 : */
2224 452873 : if (rval == -EEXIST) {
2225 452759 : struct xfs_dir3_icleaf_hdr leafhdr;
2226 :
2227 : /*
2228 : * Find the leaf entry.
2229 : */
2230 452759 : blk = &state->path.blk[state->path.active - 1];
2231 452759 : ASSERT(blk->magic == XFS_DIR2_LEAFN_MAGIC);
2232 452759 : ASSERT(state->extravalid);
2233 :
2234 452759 : xfs_dir2_leaf_hdr_from_disk(state->mp, &leafhdr,
2235 452759 : blk->bp->b_addr);
2236 : /*
2237 : * Point to the data entry.
2238 : */
2239 452758 : hdr = state->extrablk.bp->b_addr;
2240 452758 : ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
2241 : hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC));
2242 905516 : dep = (xfs_dir2_data_entry_t *)
2243 : ((char *)hdr +
2244 905516 : xfs_dir2_dataptr_to_off(args->geo,
2245 452758 : be32_to_cpu(leafhdr.ents[blk->index].address)));
2246 452758 : ASSERT(inum != be64_to_cpu(dep->inumber));
2247 : /*
2248 : * Fill in the new inode number and log the entry.
2249 : */
2250 452758 : dep->inumber = cpu_to_be64(inum);
2251 452758 : xfs_dir2_data_put_ftype(state->mp, dep, ftype);
2252 452759 : xfs_dir2_data_log_entry(args, state->extrablk.bp, dep);
2253 452758 : rval = 0;
2254 : }
2255 : /*
2256 : * Didn't find it, and we're holding a data block. Drop it.
2257 : */
2258 114 : else if (state->extravalid) {
2259 0 : xfs_trans_brelse(args->trans, state->extrablk.bp);
2260 0 : state->extrablk.bp = NULL;
2261 : }
2262 : /*
2263 : * Release all the buffers in the cursor.
2264 : */
2265 1358362 : for (i = 0; i < state->path.active; i++) {
2266 905489 : xfs_trans_brelse(args->trans, state->path.blk[i].bp);
2267 905493 : state->path.blk[i].bp = NULL;
2268 : }
2269 452873 : xfs_da_state_free(state);
2270 452873 : return rval;
2271 : }
2272 :
2273 : /*
2274 : * Trim off a trailing empty freespace block.
2275 : * Return (in rvalp) 1 if we did it, 0 if not.
2276 : */
2277 : int /* error */
2278 2150 : xfs_dir2_node_trim_free(
2279 : xfs_da_args_t *args, /* operation arguments */
2280 : xfs_fileoff_t fo, /* free block number */
2281 : int *rvalp) /* out: did something */
2282 : {
2283 2150 : struct xfs_buf *bp; /* freespace buffer */
2284 2150 : xfs_inode_t *dp; /* incore directory inode */
2285 2150 : int error; /* error return code */
2286 2150 : xfs_dir2_free_t *free; /* freespace structure */
2287 2150 : xfs_trans_t *tp; /* transaction pointer */
2288 2150 : struct xfs_dir3_icfree_hdr freehdr;
2289 :
2290 2150 : dp = args->dp;
2291 2150 : tp = args->trans;
2292 :
2293 2150 : *rvalp = 0;
2294 :
2295 : /*
2296 : * Read the freespace block.
2297 : */
2298 2150 : error = xfs_dir2_free_try_read(tp, dp, fo, &bp);
2299 2150 : if (error)
2300 : return error;
2301 : /*
2302 : * There can be holes in freespace. If fo is a hole, there's
2303 : * nothing to do.
2304 : */
2305 2150 : if (!bp)
2306 : return 0;
2307 2150 : free = bp->b_addr;
2308 2150 : xfs_dir2_free_hdr_from_disk(dp->i_mount, &freehdr, free);
2309 :
2310 : /*
2311 : * If there are used entries, there's nothing to do.
2312 : */
2313 2150 : if (freehdr.nused > 0) {
2314 2150 : xfs_trans_brelse(tp, bp);
2315 2150 : return 0;
2316 : }
2317 : /*
2318 : * Blow the block away.
2319 : */
2320 0 : error = xfs_dir2_shrink_inode(args,
2321 : xfs_dir2_da_to_db(args->geo, (xfs_dablk_t)fo), bp);
2322 0 : if (error) {
2323 : /*
2324 : * Can't fail with ENOSPC since that only happens with no
2325 : * space reservation, when breaking up an extent into two
2326 : * pieces. This is the last block of an extent.
2327 : */
2328 0 : ASSERT(error != -ENOSPC);
2329 0 : xfs_trans_brelse(tp, bp);
2330 0 : return error;
2331 : }
2332 : /*
2333 : * Return that we succeeded.
2334 : */
2335 0 : *rvalp = 1;
2336 0 : return 0;
2337 : }
|
