1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include "xfs.h"
20#include "xfs_fs.h"
21#include "xfs_types.h"
22#include "xfs_log.h"
23#include "xfs_trans.h"
24#include "xfs_sb.h"
25#include "xfs_ag.h"
26#include "xfs_mount.h"
27#include "xfs_da_btree.h"
28#include "xfs_bmap_btree.h"
29#include "xfs_dinode.h"
30#include "xfs_inode.h"
31#include "xfs_bmap.h"
32#include "xfs_dir2_format.h"
33#include "xfs_dir2_priv.h"
34#include "xfs_error.h"
35#include "xfs_trace.h"
36#include "xfs_buf_item.h"
37#include "xfs_cksum.h"
38
39
40
41
42static int xfs_dir2_leafn_add(struct xfs_buf *bp, xfs_da_args_t *args,
43 int index);
44static void xfs_dir2_leafn_rebalance(xfs_da_state_t *state,
45 xfs_da_state_blk_t *blk1,
46 xfs_da_state_blk_t *blk2);
47static int xfs_dir2_leafn_remove(xfs_da_args_t *args, struct xfs_buf *bp,
48 int index, xfs_da_state_blk_t *dblk,
49 int *rval);
50static int xfs_dir2_node_addname_int(xfs_da_args_t *args,
51 xfs_da_state_blk_t *fblk);
52
53
54
55
56#ifdef DEBUG
57#define xfs_dir3_leaf_check(mp, bp) \
58do { \
59 if (!xfs_dir3_leafn_check((mp), (bp))) \
60 ASSERT(0); \
61} while (0);
62
63static bool
64xfs_dir3_leafn_check(
65 struct xfs_mount *mp,
66 struct xfs_buf *bp)
67{
68 struct xfs_dir2_leaf *leaf = bp->b_addr;
69 struct xfs_dir3_icleaf_hdr leafhdr;
70
71 xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
72
73 if (leafhdr.magic == XFS_DIR3_LEAFN_MAGIC) {
74 struct xfs_dir3_leaf_hdr *leaf3 = bp->b_addr;
75 if (be64_to_cpu(leaf3->info.blkno) != bp->b_bn)
76 return false;
77 } else if (leafhdr.magic != XFS_DIR2_LEAFN_MAGIC)
78 return false;
79
80 return xfs_dir3_leaf_check_int(mp, &leafhdr, leaf);
81}
82#else
83#define xfs_dir3_leaf_check(mp, bp)
84#endif
85
86static bool
87xfs_dir3_free_verify(
88 struct xfs_buf *bp)
89{
90 struct xfs_mount *mp = bp->b_target->bt_mount;
91 struct xfs_dir2_free_hdr *hdr = bp->b_addr;
92
93 if (xfs_sb_version_hascrc(&mp->m_sb)) {
94 struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
95
96 if (hdr3->magic != cpu_to_be32(XFS_DIR3_FREE_MAGIC))
97 return false;
98 if (!uuid_equal(&hdr3->uuid, &mp->m_sb.sb_uuid))
99 return false;
100 if (be64_to_cpu(hdr3->blkno) != bp->b_bn)
101 return false;
102 } else {
103 if (hdr->magic != cpu_to_be32(XFS_DIR2_FREE_MAGIC))
104 return false;
105 }
106
107
108
109 return true;
110}
111
112static void
113xfs_dir3_free_read_verify(
114 struct xfs_buf *bp)
115{
116 struct xfs_mount *mp = bp->b_target->bt_mount;
117
118 if ((xfs_sb_version_hascrc(&mp->m_sb) &&
119 !xfs_verify_cksum(bp->b_addr, BBTOB(bp->b_length),
120 XFS_DIR3_FREE_CRC_OFF)) ||
121 !xfs_dir3_free_verify(bp)) {
122 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
123 xfs_buf_ioerror(bp, EFSCORRUPTED);
124 }
125}
126
127static void
128xfs_dir3_free_write_verify(
129 struct xfs_buf *bp)
130{
131 struct xfs_mount *mp = bp->b_target->bt_mount;
132 struct xfs_buf_log_item *bip = bp->b_fspriv;
133 struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
134
135 if (!xfs_dir3_free_verify(bp)) {
136 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
137 xfs_buf_ioerror(bp, EFSCORRUPTED);
138 return;
139 }
140
141 if (!xfs_sb_version_hascrc(&mp->m_sb))
142 return;
143
144 if (bip)
145 hdr3->lsn = cpu_to_be64(bip->bli_item.li_lsn);
146
147 xfs_update_cksum(bp->b_addr, BBTOB(bp->b_length), XFS_DIR3_FREE_CRC_OFF);
148}
149
150const struct xfs_buf_ops xfs_dir3_free_buf_ops = {
151 .verify_read = xfs_dir3_free_read_verify,
152 .verify_write = xfs_dir3_free_write_verify,
153};
154
155
156static int
157__xfs_dir3_free_read(
158 struct xfs_trans *tp,
159 struct xfs_inode *dp,
160 xfs_dablk_t fbno,
161 xfs_daddr_t mappedbno,
162 struct xfs_buf **bpp)
163{
164 int err;
165
166 err = xfs_da_read_buf(tp, dp, fbno, mappedbno, bpp,
167 XFS_DATA_FORK, &xfs_dir3_free_buf_ops);
168
169
170 if (!err && tp && *bpp)
171 xfs_trans_buf_set_type(tp, *bpp, XFS_BLFT_DIR_FREE_BUF);
172 return err;
173}
174
175int
176xfs_dir2_free_read(
177 struct xfs_trans *tp,
178 struct xfs_inode *dp,
179 xfs_dablk_t fbno,
180 struct xfs_buf **bpp)
181{
182 return __xfs_dir3_free_read(tp, dp, fbno, -1, bpp);
183}
184
185static int
186xfs_dir2_free_try_read(
187 struct xfs_trans *tp,
188 struct xfs_inode *dp,
189 xfs_dablk_t fbno,
190 struct xfs_buf **bpp)
191{
192 return __xfs_dir3_free_read(tp, dp, fbno, -2, bpp);
193}
194
195
196void
197xfs_dir3_free_hdr_from_disk(
198 struct xfs_dir3_icfree_hdr *to,
199 struct xfs_dir2_free *from)
200{
201 if (from->hdr.magic == cpu_to_be32(XFS_DIR2_FREE_MAGIC)) {
202 to->magic = be32_to_cpu(from->hdr.magic);
203 to->firstdb = be32_to_cpu(from->hdr.firstdb);
204 to->nvalid = be32_to_cpu(from->hdr.nvalid);
205 to->nused = be32_to_cpu(from->hdr.nused);
206 } else {
207 struct xfs_dir3_free_hdr *hdr3 = (struct xfs_dir3_free_hdr *)from;
208
209 to->magic = be32_to_cpu(hdr3->hdr.magic);
210 to->firstdb = be32_to_cpu(hdr3->firstdb);
211 to->nvalid = be32_to_cpu(hdr3->nvalid);
212 to->nused = be32_to_cpu(hdr3->nused);
213 }
214
215 ASSERT(to->magic == XFS_DIR2_FREE_MAGIC ||
216 to->magic == XFS_DIR3_FREE_MAGIC);
217}
218
219static void
220xfs_dir3_free_hdr_to_disk(
221 struct xfs_dir2_free *to,
222 struct xfs_dir3_icfree_hdr *from)
223{
224 ASSERT(from->magic == XFS_DIR2_FREE_MAGIC ||
225 from->magic == XFS_DIR3_FREE_MAGIC);
226
227 if (from->magic == XFS_DIR2_FREE_MAGIC) {
228 to->hdr.magic = cpu_to_be32(from->magic);
229 to->hdr.firstdb = cpu_to_be32(from->firstdb);
230 to->hdr.nvalid = cpu_to_be32(from->nvalid);
231 to->hdr.nused = cpu_to_be32(from->nused);
232 } else {
233 struct xfs_dir3_free_hdr *hdr3 = (struct xfs_dir3_free_hdr *)to;
234
235 hdr3->hdr.magic = cpu_to_be32(from->magic);
236 hdr3->firstdb = cpu_to_be32(from->firstdb);
237 hdr3->nvalid = cpu_to_be32(from->nvalid);
238 hdr3->nused = cpu_to_be32(from->nused);
239 }
240}
241
242static int
243xfs_dir3_free_get_buf(
244 struct xfs_trans *tp,
245 struct xfs_inode *dp,
246 xfs_dir2_db_t fbno,
247 struct xfs_buf **bpp)
248{
249 struct xfs_mount *mp = dp->i_mount;
250 struct xfs_buf *bp;
251 int error;
252 struct xfs_dir3_icfree_hdr hdr;
253
254 error = xfs_da_get_buf(tp, dp, xfs_dir2_db_to_da(mp, fbno),
255 -1, &bp, XFS_DATA_FORK);
256 if (error)
257 return error;
258
259 xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DIR_FREE_BUF);
260 bp->b_ops = &xfs_dir3_free_buf_ops;
261
262
263
264
265
266 memset(bp->b_addr, 0, sizeof(struct xfs_dir3_free_hdr));
267 memset(&hdr, 0, sizeof(hdr));
268
269 if (xfs_sb_version_hascrc(&mp->m_sb)) {
270 struct xfs_dir3_free_hdr *hdr3 = bp->b_addr;
271
272 hdr.magic = XFS_DIR3_FREE_MAGIC;
273
274 hdr3->hdr.blkno = cpu_to_be64(bp->b_bn);
275 hdr3->hdr.owner = cpu_to_be64(dp->i_ino);
276 uuid_copy(&hdr3->hdr.uuid, &mp->m_sb.sb_uuid);
277 } else
278 hdr.magic = XFS_DIR2_FREE_MAGIC;
279 xfs_dir3_free_hdr_to_disk(bp->b_addr, &hdr);
280 *bpp = bp;
281 return 0;
282}
283
284
285
286
287STATIC void
288xfs_dir2_free_log_bests(
289 struct xfs_trans *tp,
290 struct xfs_buf *bp,
291 int first,
292 int last)
293{
294 xfs_dir2_free_t *free;
295 __be16 *bests;
296
297 free = bp->b_addr;
298 bests = xfs_dir3_free_bests_p(tp->t_mountp, free);
299 ASSERT(free->hdr.magic == cpu_to_be32(XFS_DIR2_FREE_MAGIC) ||
300 free->hdr.magic == cpu_to_be32(XFS_DIR3_FREE_MAGIC));
301 xfs_trans_log_buf(tp, bp,
302 (uint)((char *)&bests[first] - (char *)free),
303 (uint)((char *)&bests[last] - (char *)free +
304 sizeof(bests[0]) - 1));
305}
306
307
308
309
310static void
311xfs_dir2_free_log_header(
312 struct xfs_trans *tp,
313 struct xfs_buf *bp)
314{
315 xfs_dir2_free_t *free;
316
317 free = bp->b_addr;
318 ASSERT(free->hdr.magic == cpu_to_be32(XFS_DIR2_FREE_MAGIC) ||
319 free->hdr.magic == cpu_to_be32(XFS_DIR3_FREE_MAGIC));
320 xfs_trans_log_buf(tp, bp, 0, xfs_dir3_free_hdr_size(tp->t_mountp) - 1);
321}
322
323
324
325
326
327
328int
329xfs_dir2_leaf_to_node(
330 xfs_da_args_t *args,
331 struct xfs_buf *lbp)
332{
333 xfs_inode_t *dp;
334 int error;
335 struct xfs_buf *fbp;
336 xfs_dir2_db_t fdb;
337 xfs_dir2_free_t *free;
338 __be16 *from;
339 int i;
340 xfs_dir2_leaf_t *leaf;
341 xfs_dir2_leaf_tail_t *ltp;
342 xfs_mount_t *mp;
343 int n;
344 xfs_dir2_data_off_t off;
345 __be16 *to;
346 xfs_trans_t *tp;
347 struct xfs_dir3_icfree_hdr freehdr;
348
349 trace_xfs_dir2_leaf_to_node(args);
350
351 dp = args->dp;
352 mp = dp->i_mount;
353 tp = args->trans;
354
355
356
357 if ((error = xfs_dir2_grow_inode(args, XFS_DIR2_FREE_SPACE, &fdb))) {
358 return error;
359 }
360 ASSERT(fdb == XFS_DIR2_FREE_FIRSTDB(mp));
361
362
363
364 error = xfs_dir3_free_get_buf(tp, dp, fdb, &fbp);
365 if (error)
366 return error;
367
368 free = fbp->b_addr;
369 xfs_dir3_free_hdr_from_disk(&freehdr, free);
370 leaf = lbp->b_addr;
371 ltp = xfs_dir2_leaf_tail_p(mp, leaf);
372 ASSERT(be32_to_cpu(ltp->bestcount) <=
373 (uint)dp->i_d.di_size / mp->m_dirblksize);
374
375
376
377
378
379 from = xfs_dir2_leaf_bests_p(ltp);
380 to = xfs_dir3_free_bests_p(mp, free);
381 for (i = n = 0; i < be32_to_cpu(ltp->bestcount); i++, from++, to++) {
382 if ((off = be16_to_cpu(*from)) != NULLDATAOFF)
383 n++;
384 *to = cpu_to_be16(off);
385 }
386
387
388
389
390 freehdr.nused = n;
391 freehdr.nvalid = be32_to_cpu(ltp->bestcount);
392
393 xfs_dir3_free_hdr_to_disk(fbp->b_addr, &freehdr);
394 xfs_dir2_free_log_bests(tp, fbp, 0, freehdr.nvalid - 1);
395 xfs_dir2_free_log_header(tp, fbp);
396
397
398
399
400
401
402
403 if (leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAF1_MAGIC))
404 leaf->hdr.info.magic = cpu_to_be16(XFS_DIR2_LEAFN_MAGIC);
405 else
406 leaf->hdr.info.magic = cpu_to_be16(XFS_DIR3_LEAFN_MAGIC);
407 lbp->b_ops = &xfs_dir3_leafn_buf_ops;
408 xfs_trans_buf_set_type(tp, lbp, XFS_BLFT_DIR_LEAFN_BUF);
409 xfs_dir3_leaf_log_header(tp, lbp);
410 xfs_dir3_leaf_check(mp, lbp);
411 return 0;
412}
413
414
415
416
417
418static int
419xfs_dir2_leafn_add(
420 struct xfs_buf *bp,
421 xfs_da_args_t *args,
422 int index)
423{
424 int compact;
425 xfs_inode_t *dp;
426 int highstale;
427 xfs_dir2_leaf_t *leaf;
428 xfs_dir2_leaf_entry_t *lep;
429 int lfloghigh;
430 int lfloglow;
431 int lowstale;
432 xfs_mount_t *mp;
433 xfs_trans_t *tp;
434 struct xfs_dir3_icleaf_hdr leafhdr;
435 struct xfs_dir2_leaf_entry *ents;
436
437 trace_xfs_dir2_leafn_add(args, index);
438
439 dp = args->dp;
440 mp = dp->i_mount;
441 tp = args->trans;
442 leaf = bp->b_addr;
443 xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
444 ents = xfs_dir3_leaf_ents_p(leaf);
445
446
447
448
449
450 if (index < 0)
451 return XFS_ERROR(EFSCORRUPTED);
452
453
454
455
456
457
458
459
460 if (leafhdr.count == xfs_dir3_max_leaf_ents(mp, leaf)) {
461 if (!leafhdr.stale)
462 return XFS_ERROR(ENOSPC);
463 compact = leafhdr.stale > 1;
464 } else
465 compact = 0;
466 ASSERT(index == 0 || be32_to_cpu(ents[index - 1].hashval) <= args->hashval);
467 ASSERT(index == leafhdr.count ||
468 be32_to_cpu(ents[index].hashval) >= args->hashval);
469
470 if (args->op_flags & XFS_DA_OP_JUSTCHECK)
471 return 0;
472
473
474
475
476
477 if (compact)
478 xfs_dir3_leaf_compact_x1(&leafhdr, ents, &index, &lowstale,
479 &highstale, &lfloglow, &lfloghigh);
480 else if (leafhdr.stale) {
481
482
483
484 lfloglow = leafhdr.count;
485 lfloghigh = -1;
486 }
487
488
489
490
491 lep = xfs_dir3_leaf_find_entry(&leafhdr, ents, index, compact, lowstale,
492 highstale, &lfloglow, &lfloghigh);
493
494 lep->hashval = cpu_to_be32(args->hashval);
495 lep->address = cpu_to_be32(xfs_dir2_db_off_to_dataptr(mp,
496 args->blkno, args->index));
497
498 xfs_dir3_leaf_hdr_to_disk(leaf, &leafhdr);
499 xfs_dir3_leaf_log_header(tp, bp);
500 xfs_dir3_leaf_log_ents(tp, bp, lfloglow, lfloghigh);
501 xfs_dir3_leaf_check(mp, bp);
502 return 0;
503}
504
505#ifdef DEBUG
506static void
507xfs_dir2_free_hdr_check(
508 struct xfs_mount *mp,
509 struct xfs_buf *bp,
510 xfs_dir2_db_t db)
511{
512 struct xfs_dir3_icfree_hdr hdr;
513
514 xfs_dir3_free_hdr_from_disk(&hdr, bp->b_addr);
515
516 ASSERT((hdr.firstdb % xfs_dir3_free_max_bests(mp)) == 0);
517 ASSERT(hdr.firstdb <= db);
518 ASSERT(db < hdr.firstdb + hdr.nvalid);
519}
520#else
521#define xfs_dir2_free_hdr_check(mp, dp, db)
522#endif
523
524
525
526
527
528xfs_dahash_t
529xfs_dir2_leafn_lasthash(
530 struct xfs_buf *bp,
531 int *count)
532{
533 struct xfs_dir2_leaf *leaf = bp->b_addr;
534 struct xfs_dir2_leaf_entry *ents;
535 struct xfs_dir3_icleaf_hdr leafhdr;
536
537 xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
538
539 ASSERT(leafhdr.magic == XFS_DIR2_LEAFN_MAGIC ||
540 leafhdr.magic == XFS_DIR3_LEAFN_MAGIC);
541
542 if (count)
543 *count = leafhdr.count;
544 if (!leafhdr.count)
545 return 0;
546
547 ents = xfs_dir3_leaf_ents_p(leaf);
548 return be32_to_cpu(ents[leafhdr.count - 1].hashval);
549}
550
551
552
553
554
555STATIC int
556xfs_dir2_leafn_lookup_for_addname(
557 struct xfs_buf *bp,
558 xfs_da_args_t *args,
559 int *indexp,
560 xfs_da_state_t *state)
561{
562 struct xfs_buf *curbp = NULL;
563 xfs_dir2_db_t curdb = -1;
564 xfs_dir2_db_t curfdb = -1;
565 xfs_inode_t *dp;
566 int error;
567 int fi;
568 xfs_dir2_free_t *free = NULL;
569 int index;
570 xfs_dir2_leaf_t *leaf;
571 int length;
572 xfs_dir2_leaf_entry_t *lep;
573 xfs_mount_t *mp;
574 xfs_dir2_db_t newdb;
575 xfs_dir2_db_t newfdb;
576 xfs_trans_t *tp;
577 struct xfs_dir2_leaf_entry *ents;
578 struct xfs_dir3_icleaf_hdr leafhdr;
579
580 dp = args->dp;
581 tp = args->trans;
582 mp = dp->i_mount;
583 leaf = bp->b_addr;
584 xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
585 ents = xfs_dir3_leaf_ents_p(leaf);
586
587 xfs_dir3_leaf_check(mp, bp);
588 ASSERT(leafhdr.count > 0);
589
590
591
592
593 index = xfs_dir2_leaf_search_hash(args, bp);
594
595
596
597 if (state->extravalid) {
598
599 curbp = state->extrablk.bp;
600 curfdb = state->extrablk.blkno;
601 free = curbp->b_addr;
602 ASSERT(free->hdr.magic == cpu_to_be32(XFS_DIR2_FREE_MAGIC) ||
603 free->hdr.magic == cpu_to_be32(XFS_DIR3_FREE_MAGIC));
604 }
605 length = xfs_dir2_data_entsize(args->namelen);
606
607
608
609 for (lep = &ents[index];
610 index < leafhdr.count && be32_to_cpu(lep->hashval) == args->hashval;
611 lep++, index++) {
612
613
614
615 if (be32_to_cpu(lep->address) == XFS_DIR2_NULL_DATAPTR)
616 continue;
617
618
619
620 newdb = xfs_dir2_dataptr_to_db(mp, be32_to_cpu(lep->address));
621
622
623
624
625
626
627
628
629 if (newdb != curdb) {
630 __be16 *bests;
631
632 curdb = newdb;
633
634
635
636
637 newfdb = xfs_dir2_db_to_fdb(mp, newdb);
638
639
640
641 if (newfdb != curfdb) {
642
643
644
645 if (curbp)
646 xfs_trans_brelse(tp, curbp);
647
648 error = xfs_dir2_free_read(tp, dp,
649 xfs_dir2_db_to_da(mp, newfdb),
650 &curbp);
651 if (error)
652 return error;
653 free = curbp->b_addr;
654
655 xfs_dir2_free_hdr_check(mp, curbp, curdb);
656 }
657
658
659
660 fi = xfs_dir2_db_to_fdindex(mp, curdb);
661
662
663
664 bests = xfs_dir3_free_bests_p(mp, free);
665 if (unlikely(bests[fi] == cpu_to_be16(NULLDATAOFF))) {
666 XFS_ERROR_REPORT("xfs_dir2_leafn_lookup_int",
667 XFS_ERRLEVEL_LOW, mp);
668 if (curfdb != newfdb)
669 xfs_trans_brelse(tp, curbp);
670 return XFS_ERROR(EFSCORRUPTED);
671 }
672 curfdb = newfdb;
673 if (be16_to_cpu(bests[fi]) >= length)
674 goto out;
675 }
676 }
677
678 fi = -1;
679out:
680 ASSERT(args->op_flags & XFS_DA_OP_OKNOENT);
681 if (curbp) {
682
683 state->extravalid = 1;
684 state->extrablk.bp = curbp;
685 state->extrablk.index = fi;
686 state->extrablk.blkno = curfdb;
687
688
689
690
691
692
693 state->extrablk.magic = XFS_DIR2_FREE_MAGIC;
694 } else {
695 state->extravalid = 0;
696 }
697
698
699
700 *indexp = index;
701 return XFS_ERROR(ENOENT);
702}
703
704
705
706
707
708STATIC int
709xfs_dir2_leafn_lookup_for_entry(
710 struct xfs_buf *bp,
711 xfs_da_args_t *args,
712 int *indexp,
713 xfs_da_state_t *state)
714{
715 struct xfs_buf *curbp = NULL;
716 xfs_dir2_db_t curdb = -1;
717 xfs_dir2_data_entry_t *dep;
718 xfs_inode_t *dp;
719 int error;
720 int index;
721 xfs_dir2_leaf_t *leaf;
722 xfs_dir2_leaf_entry_t *lep;
723 xfs_mount_t *mp;
724 xfs_dir2_db_t newdb;
725 xfs_trans_t *tp;
726 enum xfs_dacmp cmp;
727 struct xfs_dir2_leaf_entry *ents;
728 struct xfs_dir3_icleaf_hdr leafhdr;
729
730 dp = args->dp;
731 tp = args->trans;
732 mp = dp->i_mount;
733 leaf = bp->b_addr;
734 xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
735 ents = xfs_dir3_leaf_ents_p(leaf);
736
737 xfs_dir3_leaf_check(mp, bp);
738 ASSERT(leafhdr.count > 0);
739
740
741
742
743 index = xfs_dir2_leaf_search_hash(args, bp);
744
745
746
747 if (state->extravalid) {
748 curbp = state->extrablk.bp;
749 curdb = state->extrablk.blkno;
750 }
751
752
753
754 for (lep = &ents[index];
755 index < leafhdr.count && be32_to_cpu(lep->hashval) == args->hashval;
756 lep++, index++) {
757
758
759
760 if (be32_to_cpu(lep->address) == XFS_DIR2_NULL_DATAPTR)
761 continue;
762
763
764
765 newdb = xfs_dir2_dataptr_to_db(mp, be32_to_cpu(lep->address));
766
767
768
769
770
771
772 if (newdb != curdb) {
773
774
775
776
777 if (curbp && (args->cmpresult == XFS_CMP_DIFFERENT ||
778 curdb != state->extrablk.blkno))
779 xfs_trans_brelse(tp, curbp);
780
781
782
783
784 if (args->cmpresult != XFS_CMP_DIFFERENT &&
785 newdb == state->extrablk.blkno) {
786 ASSERT(state->extravalid);
787 curbp = state->extrablk.bp;
788 } else {
789 error = xfs_dir3_data_read(tp, dp,
790 xfs_dir2_db_to_da(mp, newdb),
791 -1, &curbp);
792 if (error)
793 return error;
794 }
795 xfs_dir3_data_check(dp, curbp);
796 curdb = newdb;
797 }
798
799
800
801 dep = (xfs_dir2_data_entry_t *)((char *)curbp->b_addr +
802 xfs_dir2_dataptr_to_off(mp, be32_to_cpu(lep->address)));
803
804
805
806
807
808 cmp = mp->m_dirnameops->compname(args, dep->name, dep->namelen);
809 if (cmp != XFS_CMP_DIFFERENT && cmp != args->cmpresult) {
810
811 if (args->cmpresult != XFS_CMP_DIFFERENT &&
812 curdb != state->extrablk.blkno)
813 xfs_trans_brelse(tp, state->extrablk.bp);
814 args->cmpresult = cmp;
815 args->inumber = be64_to_cpu(dep->inumber);
816 *indexp = index;
817 state->extravalid = 1;
818 state->extrablk.bp = curbp;
819 state->extrablk.blkno = curdb;
820 state->extrablk.index = (int)((char *)dep -
821 (char *)curbp->b_addr);
822 state->extrablk.magic = XFS_DIR2_DATA_MAGIC;
823 curbp->b_ops = &xfs_dir3_data_buf_ops;
824 xfs_trans_buf_set_type(tp, curbp, XFS_BLFT_DIR_DATA_BUF);
825 if (cmp == XFS_CMP_EXACT)
826 return XFS_ERROR(EEXIST);
827 }
828 }
829 ASSERT(index == leafhdr.count || (args->op_flags & XFS_DA_OP_OKNOENT));
830 if (curbp) {
831 if (args->cmpresult == XFS_CMP_DIFFERENT) {
832
833 state->extravalid = 1;
834 state->extrablk.bp = curbp;
835 state->extrablk.index = -1;
836 state->extrablk.blkno = curdb;
837 state->extrablk.magic = XFS_DIR2_DATA_MAGIC;
838 curbp->b_ops = &xfs_dir3_data_buf_ops;
839 xfs_trans_buf_set_type(tp, curbp, XFS_BLFT_DIR_DATA_BUF);
840 } else {
841
842 if (state->extrablk.bp != curbp)
843 xfs_trans_brelse(tp, curbp);
844 }
845 } else {
846 state->extravalid = 0;
847 }
848 *indexp = index;
849 return XFS_ERROR(ENOENT);
850}
851
852
853
854
855
856
857int
858xfs_dir2_leafn_lookup_int(
859 struct xfs_buf *bp,
860 xfs_da_args_t *args,
861 int *indexp,
862 xfs_da_state_t *state)
863{
864 if (args->op_flags & XFS_DA_OP_ADDNAME)
865 return xfs_dir2_leafn_lookup_for_addname(bp, args, indexp,
866 state);
867 return xfs_dir2_leafn_lookup_for_entry(bp, args, indexp, state);
868}
869
870
871
872
873
874static void
875xfs_dir3_leafn_moveents(
876 xfs_da_args_t *args,
877 struct xfs_buf *bp_s,
878 struct xfs_dir3_icleaf_hdr *shdr,
879 struct xfs_dir2_leaf_entry *sents,
880 int start_s,
881 struct xfs_buf *bp_d,
882 struct xfs_dir3_icleaf_hdr *dhdr,
883 struct xfs_dir2_leaf_entry *dents,
884 int start_d,
885 int count)
886{
887 struct xfs_trans *tp = args->trans;
888 int stale;
889
890 trace_xfs_dir2_leafn_moveents(args, start_s, start_d, count);
891
892
893
894
895 if (count == 0)
896 return;
897
898
899
900
901
902
903 if (start_d < dhdr->count) {
904 memmove(&dents[start_d + count], &dents[start_d],
905 (dhdr->count - start_d) * sizeof(xfs_dir2_leaf_entry_t));
906 xfs_dir3_leaf_log_ents(tp, bp_d, start_d + count,
907 count + dhdr->count - 1);
908 }
909
910
911
912
913 if (shdr->stale) {
914 int i;
915
916 for (i = start_s, stale = 0; i < start_s + count; i++) {
917 if (sents[i].address ==
918 cpu_to_be32(XFS_DIR2_NULL_DATAPTR))
919 stale++;
920 }
921 } else
922 stale = 0;
923
924
925
926 memcpy(&dents[start_d], &sents[start_s],
927 count * sizeof(xfs_dir2_leaf_entry_t));
928 xfs_dir3_leaf_log_ents(tp, bp_d, start_d, start_d + count - 1);
929
930
931
932
933
934 if (start_s + count < shdr->count) {
935 memmove(&sents[start_s], &sents[start_s + count],
936 count * sizeof(xfs_dir2_leaf_entry_t));
937 xfs_dir3_leaf_log_ents(tp, bp_s, start_s, start_s + count - 1);
938 }
939
940
941
942
943 shdr->count -= count;
944 shdr->stale -= stale;
945 dhdr->count += count;
946 dhdr->stale += stale;
947}
948
949
950
951
952
953int
954xfs_dir2_leafn_order(
955 struct xfs_buf *leaf1_bp,
956 struct xfs_buf *leaf2_bp)
957{
958 struct xfs_dir2_leaf *leaf1 = leaf1_bp->b_addr;
959 struct xfs_dir2_leaf *leaf2 = leaf2_bp->b_addr;
960 struct xfs_dir2_leaf_entry *ents1;
961 struct xfs_dir2_leaf_entry *ents2;
962 struct xfs_dir3_icleaf_hdr hdr1;
963 struct xfs_dir3_icleaf_hdr hdr2;
964
965 xfs_dir3_leaf_hdr_from_disk(&hdr1, leaf1);
966 xfs_dir3_leaf_hdr_from_disk(&hdr2, leaf2);
967 ents1 = xfs_dir3_leaf_ents_p(leaf1);
968 ents2 = xfs_dir3_leaf_ents_p(leaf2);
969
970 if (hdr1.count > 0 && hdr2.count > 0 &&
971 (be32_to_cpu(ents2[0].hashval) < be32_to_cpu(ents1[0].hashval) ||
972 be32_to_cpu(ents2[hdr2.count - 1].hashval) <
973 be32_to_cpu(ents1[hdr1.count - 1].hashval)))
974 return 1;
975 return 0;
976}
977
978
979
980
981
982
983
984
985static void
986xfs_dir2_leafn_rebalance(
987 xfs_da_state_t *state,
988 xfs_da_state_blk_t *blk1,
989 xfs_da_state_blk_t *blk2)
990{
991 xfs_da_args_t *args;
992 int count;
993 int isleft;
994 xfs_dir2_leaf_t *leaf1;
995 xfs_dir2_leaf_t *leaf2;
996 int mid;
997#if defined(DEBUG) || defined(XFS_WARN)
998 int oldstale;
999#endif
1000 int oldsum;
1001 int swap;
1002 struct xfs_dir2_leaf_entry *ents1;
1003 struct xfs_dir2_leaf_entry *ents2;
1004 struct xfs_dir3_icleaf_hdr hdr1;
1005 struct xfs_dir3_icleaf_hdr hdr2;
1006
1007 args = state->args;
1008
1009
1010
1011 if ((swap = xfs_dir2_leafn_order(blk1->bp, blk2->bp))) {
1012 xfs_da_state_blk_t *tmp;
1013
1014 tmp = blk1;
1015 blk1 = blk2;
1016 blk2 = tmp;
1017 }
1018 leaf1 = blk1->bp->b_addr;
1019 leaf2 = blk2->bp->b_addr;
1020 xfs_dir3_leaf_hdr_from_disk(&hdr1, leaf1);
1021 xfs_dir3_leaf_hdr_from_disk(&hdr2, leaf2);
1022 ents1 = xfs_dir3_leaf_ents_p(leaf1);
1023 ents2 = xfs_dir3_leaf_ents_p(leaf2);
1024
1025 oldsum = hdr1.count + hdr2.count;
1026#if defined(DEBUG) || defined(XFS_WARN)
1027 oldstale = hdr1.stale + hdr2.stale;
1028#endif
1029 mid = oldsum >> 1;
1030
1031
1032
1033
1034
1035 if (oldsum & 1) {
1036 xfs_dahash_t midhash;
1037
1038 if (mid >= hdr1.count)
1039 midhash = be32_to_cpu(ents2[mid - hdr1.count].hashval);
1040 else
1041 midhash = be32_to_cpu(ents1[mid].hashval);
1042 isleft = args->hashval <= midhash;
1043 }
1044
1045
1046
1047
1048
1049 else
1050 isleft = 1;
1051
1052
1053
1054
1055 count = hdr1.count - mid + (isleft == 0);
1056 if (count > 0)
1057 xfs_dir3_leafn_moveents(args, blk1->bp, &hdr1, ents1,
1058 hdr1.count - count, blk2->bp,
1059 &hdr2, ents2, 0, count);
1060 else if (count < 0)
1061 xfs_dir3_leafn_moveents(args, blk2->bp, &hdr2, ents2, 0,
1062 blk1->bp, &hdr1, ents1,
1063 hdr1.count, count);
1064
1065 ASSERT(hdr1.count + hdr2.count == oldsum);
1066 ASSERT(hdr1.stale + hdr2.stale == oldstale);
1067
1068
1069 xfs_dir3_leaf_hdr_to_disk(leaf1, &hdr1);
1070 xfs_dir3_leaf_hdr_to_disk(leaf2, &hdr2);
1071 xfs_dir3_leaf_log_header(args->trans, blk1->bp);
1072 xfs_dir3_leaf_log_header(args->trans, blk2->bp);
1073
1074 xfs_dir3_leaf_check(args->dp->i_mount, blk1->bp);
1075 xfs_dir3_leaf_check(args->dp->i_mount, blk2->bp);
1076
1077
1078
1079
1080 if (hdr1.count < hdr2.count)
1081 state->inleaf = swap;
1082 else if (hdr1.count > hdr2.count)
1083 state->inleaf = !swap;
1084 else
1085 state->inleaf = swap ^ (blk1->index <= hdr1.count);
1086
1087
1088
1089 if (!state->inleaf)
1090 blk2->index = blk1->index - hdr1.count;
1091
1092
1093
1094
1095
1096 if(blk2->index < 0) {
1097 state->inleaf = 1;
1098 blk2->index = 0;
1099 xfs_alert(args->dp->i_mount,
1100 "%s: picked the wrong leaf? reverting original leaf: blk1->index %d\n",
1101 __func__, blk1->index);
1102 }
1103}
1104
1105static int
1106xfs_dir3_data_block_free(
1107 xfs_da_args_t *args,
1108 struct xfs_dir2_data_hdr *hdr,
1109 struct xfs_dir2_free *free,
1110 xfs_dir2_db_t fdb,
1111 int findex,
1112 struct xfs_buf *fbp,
1113 int longest)
1114{
1115 struct xfs_trans *tp = args->trans;
1116 int logfree = 0;
1117 __be16 *bests;
1118 struct xfs_dir3_icfree_hdr freehdr;
1119
1120 xfs_dir3_free_hdr_from_disk(&freehdr, free);
1121
1122 bests = xfs_dir3_free_bests_p(tp->t_mountp, free);
1123 if (hdr) {
1124
1125
1126
1127
1128 bests[findex] = cpu_to_be16(longest);
1129 xfs_dir2_free_log_bests(tp, fbp, findex, findex);
1130 return 0;
1131 }
1132
1133
1134 freehdr.nused--;
1135
1136
1137
1138
1139
1140
1141 if (findex == freehdr.nvalid - 1) {
1142 int i;
1143
1144 for (i = findex - 1; i >= 0; i--) {
1145 if (bests[i] != cpu_to_be16(NULLDATAOFF))
1146 break;
1147 }
1148 freehdr.nvalid = i + 1;
1149 logfree = 0;
1150 } else {
1151
1152 bests[findex] = cpu_to_be16(NULLDATAOFF);
1153 logfree = 1;
1154 }
1155
1156 xfs_dir3_free_hdr_to_disk(free, &freehdr);
1157 xfs_dir2_free_log_header(tp, fbp);
1158
1159
1160
1161
1162
1163 if (!freehdr.nused) {
1164 int error;
1165
1166 error = xfs_dir2_shrink_inode(args, fdb, fbp);
1167 if (error == 0) {
1168 fbp = NULL;
1169 logfree = 0;
1170 } else if (error != ENOSPC || args->total != 0)
1171 return error;
1172
1173
1174
1175
1176
1177 }
1178
1179
1180 if (logfree)
1181 xfs_dir2_free_log_bests(tp, fbp, findex, findex);
1182 return 0;
1183}
1184
1185
1186
1187
1188
1189
1190static int
1191xfs_dir2_leafn_remove(
1192 xfs_da_args_t *args,
1193 struct xfs_buf *bp,
1194 int index,
1195 xfs_da_state_blk_t *dblk,
1196 int *rval)
1197{
1198 xfs_dir2_data_hdr_t *hdr;
1199 xfs_dir2_db_t db;
1200 struct xfs_buf *dbp;
1201 xfs_dir2_data_entry_t *dep;
1202 xfs_inode_t *dp;
1203 xfs_dir2_leaf_t *leaf;
1204 xfs_dir2_leaf_entry_t *lep;
1205 int longest;
1206 int off;
1207 xfs_mount_t *mp;
1208 int needlog;
1209 int needscan;
1210 xfs_trans_t *tp;
1211 struct xfs_dir2_data_free *bf;
1212 struct xfs_dir3_icleaf_hdr leafhdr;
1213 struct xfs_dir2_leaf_entry *ents;
1214
1215 trace_xfs_dir2_leafn_remove(args, index);
1216
1217 dp = args->dp;
1218 tp = args->trans;
1219 mp = dp->i_mount;
1220 leaf = bp->b_addr;
1221 xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
1222 ents = xfs_dir3_leaf_ents_p(leaf);
1223
1224
1225
1226
1227 lep = &ents[index];
1228
1229
1230
1231
1232 db = xfs_dir2_dataptr_to_db(mp, be32_to_cpu(lep->address));
1233 ASSERT(dblk->blkno == db);
1234 off = xfs_dir2_dataptr_to_off(mp, be32_to_cpu(lep->address));
1235 ASSERT(dblk->index == off);
1236
1237
1238
1239
1240
1241 leafhdr.stale++;
1242 xfs_dir3_leaf_hdr_to_disk(leaf, &leafhdr);
1243 xfs_dir3_leaf_log_header(tp, bp);
1244
1245 lep->address = cpu_to_be32(XFS_DIR2_NULL_DATAPTR);
1246 xfs_dir3_leaf_log_ents(tp, bp, index, index);
1247
1248
1249
1250
1251
1252 dbp = dblk->bp;
1253 hdr = dbp->b_addr;
1254 dep = (xfs_dir2_data_entry_t *)((char *)hdr + off);
1255 bf = xfs_dir3_data_bestfree_p(hdr);
1256 longest = be16_to_cpu(bf[0].length);
1257 needlog = needscan = 0;
1258 xfs_dir2_data_make_free(tp, dbp, off,
1259 xfs_dir2_data_entsize(dep->namelen), &needlog, &needscan);
1260
1261
1262
1263
1264 if (needscan)
1265 xfs_dir2_data_freescan(mp, hdr, &needlog);
1266 if (needlog)
1267 xfs_dir2_data_log_header(tp, dbp);
1268 xfs_dir3_data_check(dp, dbp);
1269
1270
1271
1272
1273 if (longest < be16_to_cpu(bf[0].length)) {
1274 int error;
1275 struct xfs_buf *fbp;
1276 xfs_dir2_db_t fdb;
1277 int findex;
1278 xfs_dir2_free_t *free;
1279
1280
1281
1282
1283
1284 fdb = xfs_dir2_db_to_fdb(mp, db);
1285 error = xfs_dir2_free_read(tp, dp, xfs_dir2_db_to_da(mp, fdb),
1286 &fbp);
1287 if (error)
1288 return error;
1289 free = fbp->b_addr;
1290#ifdef DEBUG
1291 {
1292 struct xfs_dir3_icfree_hdr freehdr;
1293 xfs_dir3_free_hdr_from_disk(&freehdr, free);
1294 ASSERT(freehdr.firstdb == xfs_dir3_free_max_bests(mp) *
1295 (fdb - XFS_DIR2_FREE_FIRSTDB(mp)));
1296 }
1297#endif
1298
1299
1300
1301 findex = xfs_dir2_db_to_fdindex(mp, db);
1302 longest = be16_to_cpu(bf[0].length);
1303
1304
1305
1306
1307 if (longest == mp->m_dirblksize -
1308 xfs_dir3_data_entry_offset(hdr)) {
1309
1310
1311
1312 error = xfs_dir2_shrink_inode(args, db, dbp);
1313 if (error == 0) {
1314 dblk->bp = NULL;
1315 hdr = NULL;
1316 }
1317
1318
1319
1320
1321
1322 else if (!(error == ENOSPC && args->total == 0))
1323 return error;
1324 }
1325
1326
1327
1328
1329 error = xfs_dir3_data_block_free(args, hdr, free,
1330 fdb, findex, fbp, longest);
1331 if (error)
1332 return error;
1333 }
1334
1335 xfs_dir3_leaf_check(mp, bp);
1336
1337
1338
1339
1340 *rval = (xfs_dir3_leaf_hdr_size(leaf) +
1341 (uint)sizeof(ents[0]) * (leafhdr.count - leafhdr.stale)) <
1342 mp->m_dir_magicpct;
1343 return 0;
1344}
1345
1346
1347
1348
1349int
1350xfs_dir2_leafn_split(
1351 xfs_da_state_t *state,
1352 xfs_da_state_blk_t *oldblk,
1353 xfs_da_state_blk_t *newblk)
1354{
1355 xfs_da_args_t *args;
1356 xfs_dablk_t blkno;
1357 int error;
1358 xfs_mount_t *mp;
1359
1360
1361
1362
1363 args = state->args;
1364 mp = args->dp->i_mount;
1365 ASSERT(args != NULL);
1366 ASSERT(oldblk->magic == XFS_DIR2_LEAFN_MAGIC);
1367 error = xfs_da_grow_inode(args, &blkno);
1368 if (error) {
1369 return error;
1370 }
1371
1372
1373
1374 error = xfs_dir3_leaf_get_buf(args, xfs_dir2_da_to_db(mp, blkno),
1375 &newblk->bp, XFS_DIR2_LEAFN_MAGIC);
1376 if (error)
1377 return error;
1378
1379 newblk->blkno = blkno;
1380 newblk->magic = XFS_DIR2_LEAFN_MAGIC;
1381
1382
1383
1384
1385 xfs_dir2_leafn_rebalance(state, oldblk, newblk);
1386 error = xfs_da3_blk_link(state, oldblk, newblk);
1387 if (error) {
1388 return error;
1389 }
1390
1391
1392
1393 if (state->inleaf)
1394 error = xfs_dir2_leafn_add(oldblk->bp, args, oldblk->index);
1395 else
1396 error = xfs_dir2_leafn_add(newblk->bp, args, newblk->index);
1397
1398
1399
1400 oldblk->hashval = xfs_dir2_leafn_lasthash(oldblk->bp, NULL);
1401 newblk->hashval = xfs_dir2_leafn_lasthash(newblk->bp, NULL);
1402 xfs_dir3_leaf_check(mp, oldblk->bp);
1403 xfs_dir3_leaf_check(mp, newblk->bp);
1404 return error;
1405}
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416int
1417xfs_dir2_leafn_toosmall(
1418 xfs_da_state_t *state,
1419 int *action)
1420{
1421 xfs_da_state_blk_t *blk;
1422 xfs_dablk_t blkno;
1423 struct xfs_buf *bp;
1424 int bytes;
1425 int count;
1426 int error;
1427 int forward;
1428 int i;
1429 xfs_dir2_leaf_t *leaf;
1430 int rval;
1431 struct xfs_dir3_icleaf_hdr leafhdr;
1432 struct xfs_dir2_leaf_entry *ents;
1433
1434
1435
1436
1437
1438
1439 blk = &state->path.blk[state->path.active - 1];
1440 leaf = blk->bp->b_addr;
1441 xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
1442 ents = xfs_dir3_leaf_ents_p(leaf);
1443 xfs_dir3_leaf_check(state->args->dp->i_mount, blk->bp);
1444
1445 count = leafhdr.count - leafhdr.stale;
1446 bytes = xfs_dir3_leaf_hdr_size(leaf) + count * sizeof(ents[0]);
1447 if (bytes > (state->blocksize >> 1)) {
1448
1449
1450
1451 *action = 0;
1452 return 0;
1453 }
1454
1455
1456
1457
1458
1459
1460 if (count == 0) {
1461
1462
1463
1464
1465 forward = (leafhdr.forw != 0);
1466 memcpy(&state->altpath, &state->path, sizeof(state->path));
1467 error = xfs_da3_path_shift(state, &state->altpath, forward, 0,
1468 &rval);
1469 if (error)
1470 return error;
1471 *action = rval ? 2 : 0;
1472 return 0;
1473 }
1474
1475
1476
1477
1478
1479
1480
1481 forward = leafhdr.forw < leafhdr.back;
1482 for (i = 0, bp = NULL; i < 2; forward = !forward, i++) {
1483 struct xfs_dir3_icleaf_hdr hdr2;
1484
1485 blkno = forward ? leafhdr.forw : leafhdr.back;
1486 if (blkno == 0)
1487 continue;
1488
1489
1490
1491 error = xfs_dir3_leafn_read(state->args->trans, state->args->dp,
1492 blkno, -1, &bp);
1493 if (error)
1494 return error;
1495
1496
1497
1498
1499 count = leafhdr.count - leafhdr.stale;
1500 bytes = state->blocksize - (state->blocksize >> 2);
1501
1502 leaf = bp->b_addr;
1503 xfs_dir3_leaf_hdr_from_disk(&hdr2, leaf);
1504 ents = xfs_dir3_leaf_ents_p(leaf);
1505 count += hdr2.count - hdr2.stale;
1506 bytes -= count * sizeof(ents[0]);
1507
1508
1509
1510
1511 if (bytes >= 0)
1512 break;
1513 xfs_trans_brelse(state->args->trans, bp);
1514 }
1515
1516
1517
1518 if (i >= 2) {
1519 *action = 0;
1520 return 0;
1521 }
1522
1523
1524
1525
1526
1527 memcpy(&state->altpath, &state->path, sizeof(state->path));
1528 if (blkno < blk->blkno)
1529 error = xfs_da3_path_shift(state, &state->altpath, forward, 0,
1530 &rval);
1531 else
1532 error = xfs_da3_path_shift(state, &state->path, forward, 0,
1533 &rval);
1534 if (error) {
1535 return error;
1536 }
1537 *action = rval ? 0 : 1;
1538 return 0;
1539}
1540
1541
1542
1543
1544
1545void
1546xfs_dir2_leafn_unbalance(
1547 xfs_da_state_t *state,
1548 xfs_da_state_blk_t *drop_blk,
1549 xfs_da_state_blk_t *save_blk)
1550{
1551 xfs_da_args_t *args;
1552 xfs_dir2_leaf_t *drop_leaf;
1553 xfs_dir2_leaf_t *save_leaf;
1554 struct xfs_dir3_icleaf_hdr savehdr;
1555 struct xfs_dir3_icleaf_hdr drophdr;
1556 struct xfs_dir2_leaf_entry *sents;
1557 struct xfs_dir2_leaf_entry *dents;
1558
1559 args = state->args;
1560 ASSERT(drop_blk->magic == XFS_DIR2_LEAFN_MAGIC);
1561 ASSERT(save_blk->magic == XFS_DIR2_LEAFN_MAGIC);
1562 drop_leaf = drop_blk->bp->b_addr;
1563 save_leaf = save_blk->bp->b_addr;
1564
1565 xfs_dir3_leaf_hdr_from_disk(&savehdr, save_leaf);
1566 xfs_dir3_leaf_hdr_from_disk(&drophdr, drop_leaf);
1567 sents = xfs_dir3_leaf_ents_p(save_leaf);
1568 dents = xfs_dir3_leaf_ents_p(drop_leaf);
1569
1570
1571
1572
1573
1574 if (drophdr.stale)
1575 xfs_dir3_leaf_compact(args, &drophdr, drop_blk->bp);
1576 if (savehdr.stale)
1577 xfs_dir3_leaf_compact(args, &savehdr, save_blk->bp);
1578
1579
1580
1581
1582 drop_blk->hashval = be32_to_cpu(dents[drophdr.count - 1].hashval);
1583 if (xfs_dir2_leafn_order(save_blk->bp, drop_blk->bp))
1584 xfs_dir3_leafn_moveents(args, drop_blk->bp, &drophdr, dents, 0,
1585 save_blk->bp, &savehdr, sents, 0,
1586 drophdr.count);
1587 else
1588 xfs_dir3_leafn_moveents(args, drop_blk->bp, &drophdr, dents, 0,
1589 save_blk->bp, &savehdr, sents,
1590 savehdr.count, drophdr.count);
1591 save_blk->hashval = be32_to_cpu(sents[savehdr.count - 1].hashval);
1592
1593
1594 xfs_dir3_leaf_hdr_to_disk(save_leaf, &savehdr);
1595 xfs_dir3_leaf_hdr_to_disk(drop_leaf, &drophdr);
1596 xfs_dir3_leaf_log_header(args->trans, save_blk->bp);
1597 xfs_dir3_leaf_log_header(args->trans, drop_blk->bp);
1598
1599 xfs_dir3_leaf_check(args->dp->i_mount, save_blk->bp);
1600 xfs_dir3_leaf_check(args->dp->i_mount, drop_blk->bp);
1601}
1602
1603
1604
1605
1606int
1607xfs_dir2_node_addname(
1608 xfs_da_args_t *args)
1609{
1610 xfs_da_state_blk_t *blk;
1611 int error;
1612 int rval;
1613 xfs_da_state_t *state;
1614
1615 trace_xfs_dir2_node_addname(args);
1616
1617
1618
1619
1620 state = xfs_da_state_alloc();
1621 state->args = args;
1622 state->mp = args->dp->i_mount;
1623 state->blocksize = state->mp->m_dirblksize;
1624 state->node_ents = state->mp->m_dir_node_ents;
1625
1626
1627
1628
1629 error = xfs_da3_node_lookup_int(state, &rval);
1630 if (error)
1631 rval = error;
1632 if (rval != ENOENT) {
1633 goto done;
1634 }
1635
1636
1637
1638
1639 rval = xfs_dir2_node_addname_int(args,
1640 state->extravalid ? &state->extrablk : NULL);
1641 if (rval) {
1642 goto done;
1643 }
1644 blk = &state->path.blk[state->path.active - 1];
1645 ASSERT(blk->magic == XFS_DIR2_LEAFN_MAGIC);
1646
1647
1648
1649 rval = xfs_dir2_leafn_add(blk->bp, args, blk->index);
1650 if (rval == 0) {
1651
1652
1653
1654 if (!(args->op_flags & XFS_DA_OP_JUSTCHECK))
1655 xfs_da3_fixhashpath(state, &state->path);
1656 } else {
1657
1658
1659
1660 if (args->total == 0) {
1661 ASSERT(rval == ENOSPC);
1662 goto done;
1663 }
1664
1665
1666
1667 rval = xfs_da3_split(state);
1668 }
1669done:
1670 xfs_da_state_free(state);
1671 return rval;
1672}
1673
1674
1675
1676
1677
1678
1679static int
1680xfs_dir2_node_addname_int(
1681 xfs_da_args_t *args,
1682 xfs_da_state_blk_t *fblk)
1683{
1684 xfs_dir2_data_hdr_t *hdr;
1685 xfs_dir2_db_t dbno;
1686 struct xfs_buf *dbp;
1687 xfs_dir2_data_entry_t *dep;
1688 xfs_inode_t *dp;
1689 xfs_dir2_data_unused_t *dup;
1690 int error;
1691 xfs_dir2_db_t fbno;
1692 struct xfs_buf *fbp;
1693 int findex;
1694 xfs_dir2_free_t *free=NULL;
1695 xfs_dir2_db_t ifbno;
1696 xfs_dir2_db_t lastfbno=0;
1697 int length;
1698 int logfree;
1699 xfs_mount_t *mp;
1700 int needlog;
1701 int needscan;
1702 __be16 *tagp;
1703 xfs_trans_t *tp;
1704 __be16 *bests;
1705 struct xfs_dir3_icfree_hdr freehdr;
1706 struct xfs_dir2_data_free *bf;
1707
1708 dp = args->dp;
1709 mp = dp->i_mount;
1710 tp = args->trans;
1711 length = xfs_dir2_data_entsize(args->namelen);
1712
1713
1714
1715
1716
1717 if (fblk) {
1718 fbp = fblk->bp;
1719
1720
1721
1722 ifbno = fblk->blkno;
1723 free = fbp->b_addr;
1724 findex = fblk->index;
1725 bests = xfs_dir3_free_bests_p(mp, free);
1726 xfs_dir3_free_hdr_from_disk(&freehdr, free);
1727
1728
1729
1730
1731
1732
1733 if (findex >= 0) {
1734 ASSERT(findex < freehdr.nvalid);
1735 ASSERT(be16_to_cpu(bests[findex]) != NULLDATAOFF);
1736 ASSERT(be16_to_cpu(bests[findex]) >= length);
1737 dbno = freehdr.firstdb + findex;
1738 } else {
1739
1740
1741
1742
1743 dbno = -1;
1744 findex = 0;
1745 }
1746 } else {
1747
1748
1749
1750 ifbno = dbno = -1;
1751 fbp = NULL;
1752 findex = 0;
1753 }
1754
1755
1756
1757
1758
1759
1760 if (dbno == -1) {
1761 xfs_fileoff_t fo;
1762
1763 if ((error = xfs_bmap_last_offset(tp, dp, &fo, XFS_DATA_FORK)))
1764 return error;
1765 lastfbno = xfs_dir2_da_to_db(mp, (xfs_dablk_t)fo);
1766 fbno = ifbno;
1767 }
1768
1769
1770
1771
1772
1773 while (dbno == -1) {
1774
1775
1776
1777 if (fbp == NULL) {
1778
1779
1780
1781
1782 if (++fbno == 0)
1783 fbno = XFS_DIR2_FREE_FIRSTDB(mp);
1784
1785
1786
1787 if (fbno == ifbno)
1788 fbno++;
1789
1790
1791
1792 if (fbno >= lastfbno)
1793 break;
1794
1795
1796
1797
1798
1799
1800 error = xfs_dir2_free_try_read(tp, dp,
1801 xfs_dir2_db_to_da(mp, fbno),
1802 &fbp);
1803 if (error)
1804 return error;
1805 if (!fbp)
1806 continue;
1807 free = fbp->b_addr;
1808 findex = 0;
1809 }
1810
1811
1812
1813
1814
1815
1816
1817
1818 bests = xfs_dir3_free_bests_p(mp, free);
1819 xfs_dir3_free_hdr_from_disk(&freehdr, free);
1820 if (be16_to_cpu(bests[findex]) != NULLDATAOFF &&
1821 be16_to_cpu(bests[findex]) >= length)
1822 dbno = freehdr.firstdb + findex;
1823 else {
1824
1825
1826
1827 if (++findex == freehdr.nvalid) {
1828
1829
1830
1831 xfs_trans_brelse(tp, fbp);
1832 fbp = NULL;
1833 if (fblk && fblk->bp)
1834 fblk->bp = NULL;
1835 }
1836 }
1837 }
1838
1839
1840
1841
1842 if (unlikely(dbno == -1)) {
1843
1844
1845
1846 if ((args->op_flags & XFS_DA_OP_JUSTCHECK) || args->total == 0)
1847 return XFS_ERROR(ENOSPC);
1848
1849
1850
1851
1852 if (unlikely((error = xfs_dir2_grow_inode(args,
1853 XFS_DIR2_DATA_SPACE,
1854 &dbno)) ||
1855 (error = xfs_dir3_data_init(args, dbno, &dbp))))
1856 return error;
1857
1858
1859
1860
1861 if (fbp)
1862 xfs_trans_brelse(tp, fbp);
1863 if (fblk && fblk->bp)
1864 fblk->bp = NULL;
1865
1866
1867
1868
1869
1870 fbno = xfs_dir2_db_to_fdb(mp, dbno);
1871 error = xfs_dir2_free_try_read(tp, dp,
1872 xfs_dir2_db_to_da(mp, fbno),
1873 &fbp);
1874 if (error)
1875 return error;
1876
1877
1878
1879
1880
1881 if (!fbp) {
1882 error = xfs_dir2_grow_inode(args, XFS_DIR2_FREE_SPACE,
1883 &fbno);
1884 if (error)
1885 return error;
1886
1887 if (unlikely(xfs_dir2_db_to_fdb(mp, dbno) != fbno)) {
1888 xfs_alert(mp,
1889 "%s: dir ino %llu needed freesp block %lld for\n"
1890 " data block %lld, got %lld ifbno %llu lastfbno %d",
1891 __func__, (unsigned long long)dp->i_ino,
1892 (long long)xfs_dir2_db_to_fdb(mp, dbno),
1893 (long long)dbno, (long long)fbno,
1894 (unsigned long long)ifbno, lastfbno);
1895 if (fblk) {
1896 xfs_alert(mp,
1897 " fblk 0x%p blkno %llu index %d magic 0x%x",
1898 fblk,
1899 (unsigned long long)fblk->blkno,
1900 fblk->index,
1901 fblk->magic);
1902 } else {
1903 xfs_alert(mp, " ... fblk is NULL");
1904 }
1905 XFS_ERROR_REPORT("xfs_dir2_node_addname_int",
1906 XFS_ERRLEVEL_LOW, mp);
1907 return XFS_ERROR(EFSCORRUPTED);
1908 }
1909
1910
1911
1912
1913 error = xfs_dir3_free_get_buf(tp, dp, fbno, &fbp);
1914 if (error)
1915 return error;
1916 free = fbp->b_addr;
1917 bests = xfs_dir3_free_bests_p(mp, free);
1918 xfs_dir3_free_hdr_from_disk(&freehdr, free);
1919
1920
1921
1922
1923 freehdr.firstdb = (fbno - XFS_DIR2_FREE_FIRSTDB(mp)) *
1924 xfs_dir3_free_max_bests(mp);
1925 } else {
1926 free = fbp->b_addr;
1927 bests = xfs_dir3_free_bests_p(mp, free);
1928 xfs_dir3_free_hdr_from_disk(&freehdr, free);
1929 }
1930
1931
1932
1933
1934 findex = xfs_dir2_db_to_fdindex(mp, dbno);
1935
1936
1937
1938
1939 if (findex >= freehdr.nvalid) {
1940 ASSERT(findex < xfs_dir3_free_max_bests(mp));
1941 freehdr.nvalid = findex + 1;
1942
1943
1944
1945 bests[findex] = cpu_to_be16(NULLDATAOFF);
1946 }
1947
1948
1949
1950
1951 if (bests[findex] == cpu_to_be16(NULLDATAOFF)) {
1952 freehdr.nused++;
1953 xfs_dir3_free_hdr_to_disk(fbp->b_addr, &freehdr);
1954 xfs_dir2_free_log_header(tp, fbp);
1955 }
1956
1957
1958
1959
1960
1961 hdr = dbp->b_addr;
1962 bf = xfs_dir3_data_bestfree_p(hdr);
1963 bests[findex] = bf[0].length;
1964 logfree = 1;
1965 }
1966
1967
1968
1969 else {
1970
1971
1972
1973 if (args->op_flags & XFS_DA_OP_JUSTCHECK)
1974 return 0;
1975
1976
1977
1978
1979 error = xfs_dir3_data_read(tp, dp, xfs_dir2_db_to_da(mp, dbno),
1980 -1, &dbp);
1981 if (error)
1982 return error;
1983 hdr = dbp->b_addr;
1984 bf = xfs_dir3_data_bestfree_p(hdr);
1985 logfree = 0;
1986 }
1987 ASSERT(be16_to_cpu(bf[0].length) >= length);
1988
1989
1990
1991 dup = (xfs_dir2_data_unused_t *)
1992 ((char *)hdr + be16_to_cpu(bf[0].offset));
1993 needscan = needlog = 0;
1994
1995
1996
1997 xfs_dir2_data_use_free(tp, dbp, dup,
1998 (xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr), length,
1999 &needlog, &needscan);
2000
2001
2002
2003 dep = (xfs_dir2_data_entry_t *)dup;
2004 dep->inumber = cpu_to_be64(args->inumber);
2005 dep->namelen = args->namelen;
2006 memcpy(dep->name, args->name, dep->namelen);
2007 tagp = xfs_dir2_data_entry_tag_p(dep);
2008 *tagp = cpu_to_be16((char *)dep - (char *)hdr);
2009 xfs_dir2_data_log_entry(tp, dbp, dep);
2010
2011
2012
2013 if (needscan)
2014 xfs_dir2_data_freescan(mp, hdr, &needlog);
2015
2016
2017
2018 if (needlog)
2019 xfs_dir2_data_log_header(tp, dbp);
2020
2021
2022
2023 bests = xfs_dir3_free_bests_p(mp, free);
2024 if (be16_to_cpu(bests[findex]) != be16_to_cpu(bf[0].length)) {
2025 bests[findex] = bf[0].length;
2026 logfree = 1;
2027 }
2028
2029
2030
2031 if (logfree)
2032 xfs_dir2_free_log_bests(tp, fbp, findex, findex);
2033
2034
2035
2036 args->blkno = (xfs_dablk_t)dbno;
2037 args->index = be16_to_cpu(*tagp);
2038 return 0;
2039}
2040
2041
2042
2043
2044
2045
2046int
2047xfs_dir2_node_lookup(
2048 xfs_da_args_t *args)
2049{
2050 int error;
2051 int i;
2052 int rval;
2053 xfs_da_state_t *state;
2054
2055 trace_xfs_dir2_node_lookup(args);
2056
2057
2058
2059
2060 state = xfs_da_state_alloc();
2061 state->args = args;
2062 state->mp = args->dp->i_mount;
2063 state->blocksize = state->mp->m_dirblksize;
2064 state->node_ents = state->mp->m_dir_node_ents;
2065
2066
2067
2068 error = xfs_da3_node_lookup_int(state, &rval);
2069 if (error)
2070 rval = error;
2071 else if (rval == ENOENT && args->cmpresult == XFS_CMP_CASE) {
2072
2073 xfs_dir2_data_entry_t *dep;
2074
2075 dep = (xfs_dir2_data_entry_t *)
2076 ((char *)state->extrablk.bp->b_addr +
2077 state->extrablk.index);
2078 rval = xfs_dir_cilookup_result(args, dep->name, dep->namelen);
2079 }
2080
2081
2082
2083 for (i = 0; i < state->path.active; i++) {
2084 xfs_trans_brelse(args->trans, state->path.blk[i].bp);
2085 state->path.blk[i].bp = NULL;
2086 }
2087
2088
2089
2090 if (state->extravalid && state->extrablk.bp) {
2091 xfs_trans_brelse(args->trans, state->extrablk.bp);
2092 state->extrablk.bp = NULL;
2093 }
2094 xfs_da_state_free(state);
2095 return rval;
2096}
2097
2098
2099
2100
2101int
2102xfs_dir2_node_removename(
2103 xfs_da_args_t *args)
2104{
2105 xfs_da_state_blk_t *blk;
2106 int error;
2107 int rval;
2108 xfs_da_state_t *state;
2109
2110 trace_xfs_dir2_node_removename(args);
2111
2112
2113
2114
2115 state = xfs_da_state_alloc();
2116 state->args = args;
2117 state->mp = args->dp->i_mount;
2118 state->blocksize = state->mp->m_dirblksize;
2119 state->node_ents = state->mp->m_dir_node_ents;
2120
2121
2122
2123 error = xfs_da3_node_lookup_int(state, &rval);
2124 if (error)
2125 rval = error;
2126
2127
2128
2129 if (rval != EEXIST) {
2130 xfs_da_state_free(state);
2131 return rval;
2132 }
2133 blk = &state->path.blk[state->path.active - 1];
2134 ASSERT(blk->magic == XFS_DIR2_LEAFN_MAGIC);
2135 ASSERT(state->extravalid);
2136
2137
2138
2139
2140 error = xfs_dir2_leafn_remove(args, blk->bp, blk->index,
2141 &state->extrablk, &rval);
2142 if (error)
2143 return error;
2144
2145
2146
2147 xfs_da3_fixhashpath(state, &state->path);
2148
2149
2150
2151 if (rval && state->path.active > 1)
2152 error = xfs_da3_join(state);
2153
2154
2155
2156 if (!error)
2157 error = xfs_dir2_node_to_leaf(state);
2158 xfs_da_state_free(state);
2159 return error;
2160}
2161
2162
2163
2164
2165int
2166xfs_dir2_node_replace(
2167 xfs_da_args_t *args)
2168{
2169 xfs_da_state_blk_t *blk;
2170 xfs_dir2_data_hdr_t *hdr;
2171 xfs_dir2_data_entry_t *dep;
2172 int error;
2173 int i;
2174 xfs_ino_t inum;
2175 xfs_dir2_leaf_t *leaf;
2176 xfs_dir2_leaf_entry_t *lep;
2177 int rval;
2178 xfs_da_state_t *state;
2179
2180 trace_xfs_dir2_node_replace(args);
2181
2182
2183
2184
2185 state = xfs_da_state_alloc();
2186 state->args = args;
2187 state->mp = args->dp->i_mount;
2188 state->blocksize = state->mp->m_dirblksize;
2189 state->node_ents = state->mp->m_dir_node_ents;
2190 inum = args->inumber;
2191
2192
2193
2194 error = xfs_da3_node_lookup_int(state, &rval);
2195 if (error) {
2196 rval = error;
2197 }
2198
2199
2200
2201
2202 if (rval == EEXIST) {
2203 struct xfs_dir2_leaf_entry *ents;
2204
2205
2206
2207 blk = &state->path.blk[state->path.active - 1];
2208 ASSERT(blk->magic == XFS_DIR2_LEAFN_MAGIC);
2209 leaf = blk->bp->b_addr;
2210 ents = xfs_dir3_leaf_ents_p(leaf);
2211 lep = &ents[blk->index];
2212 ASSERT(state->extravalid);
2213
2214
2215
2216 hdr = state->extrablk.bp->b_addr;
2217 ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
2218 hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC));
2219 dep = (xfs_dir2_data_entry_t *)
2220 ((char *)hdr +
2221 xfs_dir2_dataptr_to_off(state->mp, be32_to_cpu(lep->address)));
2222 ASSERT(inum != be64_to_cpu(dep->inumber));
2223
2224
2225
2226 dep->inumber = cpu_to_be64(inum);
2227 xfs_dir2_data_log_entry(args->trans, state->extrablk.bp, dep);
2228 rval = 0;
2229 }
2230
2231
2232
2233 else if (state->extravalid) {
2234 xfs_trans_brelse(args->trans, state->extrablk.bp);
2235 state->extrablk.bp = NULL;
2236 }
2237
2238
2239
2240 for (i = 0; i < state->path.active; i++) {
2241 xfs_trans_brelse(args->trans, state->path.blk[i].bp);
2242 state->path.blk[i].bp = NULL;
2243 }
2244 xfs_da_state_free(state);
2245 return rval;
2246}
2247
2248
2249
2250
2251
2252int
2253xfs_dir2_node_trim_free(
2254 xfs_da_args_t *args,
2255 xfs_fileoff_t fo,
2256 int *rvalp)
2257{
2258 struct xfs_buf *bp;
2259 xfs_inode_t *dp;
2260 int error;
2261 xfs_dir2_free_t *free;
2262 xfs_mount_t *mp;
2263 xfs_trans_t *tp;
2264 struct xfs_dir3_icfree_hdr freehdr;
2265
2266 dp = args->dp;
2267 mp = dp->i_mount;
2268 tp = args->trans;
2269
2270
2271
2272 error = xfs_dir2_free_try_read(tp, dp, fo, &bp);
2273 if (error)
2274 return error;
2275
2276
2277
2278
2279 if (!bp)
2280 return 0;
2281 free = bp->b_addr;
2282 xfs_dir3_free_hdr_from_disk(&freehdr, free);
2283
2284
2285
2286
2287 if (freehdr.nused > 0) {
2288 xfs_trans_brelse(tp, bp);
2289 *rvalp = 0;
2290 return 0;
2291 }
2292
2293
2294
2295 if ((error =
2296 xfs_dir2_shrink_inode(args, xfs_dir2_da_to_db(mp, (xfs_dablk_t)fo),
2297 bp))) {
2298
2299
2300
2301
2302
2303 ASSERT(error != ENOSPC);
2304 xfs_trans_brelse(tp, bp);
2305 return error;
2306 }
2307
2308
2309
2310 *rvalp = 1;
2311 return 0;
2312}
2313