1
2
3
4
5
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_sb.h"
14#include "xfs_mount.h"
15#include "xfs_da_format.h"
16#include "xfs_da_btree.h"
17#include "xfs_inode.h"
18#include "xfs_trans.h"
19#include "xfs_bmap_btree.h"
20#include "xfs_bmap.h"
21#include "xfs_attr_sf.h"
22#include "xfs_attr_remote.h"
23#include "xfs_attr.h"
24#include "xfs_attr_leaf.h"
25#include "xfs_error.h"
26#include "xfs_trace.h"
27#include "xfs_buf_item.h"
28#include "xfs_dir2.h"
29#include "xfs_log.h"
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45STATIC int xfs_attr3_leaf_create(struct xfs_da_args *args,
46 xfs_dablk_t which_block, struct xfs_buf **bpp);
47STATIC int xfs_attr3_leaf_add_work(struct xfs_buf *leaf_buffer,
48 struct xfs_attr3_icleaf_hdr *ichdr,
49 struct xfs_da_args *args, int freemap_index);
50STATIC void xfs_attr3_leaf_compact(struct xfs_da_args *args,
51 struct xfs_attr3_icleaf_hdr *ichdr,
52 struct xfs_buf *leaf_buffer);
53STATIC void xfs_attr3_leaf_rebalance(xfs_da_state_t *state,
54 xfs_da_state_blk_t *blk1,
55 xfs_da_state_blk_t *blk2);
56STATIC int xfs_attr3_leaf_figure_balance(xfs_da_state_t *state,
57 xfs_da_state_blk_t *leaf_blk_1,
58 struct xfs_attr3_icleaf_hdr *ichdr1,
59 xfs_da_state_blk_t *leaf_blk_2,
60 struct xfs_attr3_icleaf_hdr *ichdr2,
61 int *number_entries_in_blk1,
62 int *number_usedbytes_in_blk1);
63
64
65
66
67STATIC void xfs_attr3_leaf_moveents(struct xfs_da_args *args,
68 struct xfs_attr_leafblock *src_leaf,
69 struct xfs_attr3_icleaf_hdr *src_ichdr, int src_start,
70 struct xfs_attr_leafblock *dst_leaf,
71 struct xfs_attr3_icleaf_hdr *dst_ichdr, int dst_start,
72 int move_count);
73STATIC int xfs_attr_leaf_entsize(xfs_attr_leafblock_t *leaf, int index);
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91static void
92xfs_attr3_leaf_firstused_from_disk(
93 struct xfs_da_geometry *geo,
94 struct xfs_attr3_icleaf_hdr *to,
95 struct xfs_attr_leafblock *from)
96{
97 struct xfs_attr3_leaf_hdr *hdr3;
98
99 if (from->hdr.info.magic == cpu_to_be16(XFS_ATTR3_LEAF_MAGIC)) {
100 hdr3 = (struct xfs_attr3_leaf_hdr *) from;
101 to->firstused = be16_to_cpu(hdr3->firstused);
102 } else {
103 to->firstused = be16_to_cpu(from->hdr.firstused);
104 }
105
106
107
108
109
110
111 if (to->firstused == XFS_ATTR3_LEAF_NULLOFF) {
112 ASSERT(!to->count && !to->usedbytes);
113 ASSERT(geo->blksize > USHRT_MAX);
114 to->firstused = geo->blksize;
115 }
116}
117
118static void
119xfs_attr3_leaf_firstused_to_disk(
120 struct xfs_da_geometry *geo,
121 struct xfs_attr_leafblock *to,
122 struct xfs_attr3_icleaf_hdr *from)
123{
124 struct xfs_attr3_leaf_hdr *hdr3;
125 uint32_t firstused;
126
127
128 ASSERT(from->firstused != XFS_ATTR3_LEAF_NULLOFF);
129
130
131
132
133
134
135 firstused = from->firstused;
136 if (firstused > USHRT_MAX) {
137 ASSERT(from->firstused == geo->blksize);
138 firstused = XFS_ATTR3_LEAF_NULLOFF;
139 }
140
141 if (from->magic == XFS_ATTR3_LEAF_MAGIC) {
142 hdr3 = (struct xfs_attr3_leaf_hdr *) to;
143 hdr3->firstused = cpu_to_be16(firstused);
144 } else {
145 to->hdr.firstused = cpu_to_be16(firstused);
146 }
147}
148
149void
150xfs_attr3_leaf_hdr_from_disk(
151 struct xfs_da_geometry *geo,
152 struct xfs_attr3_icleaf_hdr *to,
153 struct xfs_attr_leafblock *from)
154{
155 int i;
156
157 ASSERT(from->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC) ||
158 from->hdr.info.magic == cpu_to_be16(XFS_ATTR3_LEAF_MAGIC));
159
160 if (from->hdr.info.magic == cpu_to_be16(XFS_ATTR3_LEAF_MAGIC)) {
161 struct xfs_attr3_leaf_hdr *hdr3 = (struct xfs_attr3_leaf_hdr *)from;
162
163 to->forw = be32_to_cpu(hdr3->info.hdr.forw);
164 to->back = be32_to_cpu(hdr3->info.hdr.back);
165 to->magic = be16_to_cpu(hdr3->info.hdr.magic);
166 to->count = be16_to_cpu(hdr3->count);
167 to->usedbytes = be16_to_cpu(hdr3->usedbytes);
168 xfs_attr3_leaf_firstused_from_disk(geo, to, from);
169 to->holes = hdr3->holes;
170
171 for (i = 0; i < XFS_ATTR_LEAF_MAPSIZE; i++) {
172 to->freemap[i].base = be16_to_cpu(hdr3->freemap[i].base);
173 to->freemap[i].size = be16_to_cpu(hdr3->freemap[i].size);
174 }
175 return;
176 }
177 to->forw = be32_to_cpu(from->hdr.info.forw);
178 to->back = be32_to_cpu(from->hdr.info.back);
179 to->magic = be16_to_cpu(from->hdr.info.magic);
180 to->count = be16_to_cpu(from->hdr.count);
181 to->usedbytes = be16_to_cpu(from->hdr.usedbytes);
182 xfs_attr3_leaf_firstused_from_disk(geo, to, from);
183 to->holes = from->hdr.holes;
184
185 for (i = 0; i < XFS_ATTR_LEAF_MAPSIZE; i++) {
186 to->freemap[i].base = be16_to_cpu(from->hdr.freemap[i].base);
187 to->freemap[i].size = be16_to_cpu(from->hdr.freemap[i].size);
188 }
189}
190
191void
192xfs_attr3_leaf_hdr_to_disk(
193 struct xfs_da_geometry *geo,
194 struct xfs_attr_leafblock *to,
195 struct xfs_attr3_icleaf_hdr *from)
196{
197 int i;
198
199 ASSERT(from->magic == XFS_ATTR_LEAF_MAGIC ||
200 from->magic == XFS_ATTR3_LEAF_MAGIC);
201
202 if (from->magic == XFS_ATTR3_LEAF_MAGIC) {
203 struct xfs_attr3_leaf_hdr *hdr3 = (struct xfs_attr3_leaf_hdr *)to;
204
205 hdr3->info.hdr.forw = cpu_to_be32(from->forw);
206 hdr3->info.hdr.back = cpu_to_be32(from->back);
207 hdr3->info.hdr.magic = cpu_to_be16(from->magic);
208 hdr3->count = cpu_to_be16(from->count);
209 hdr3->usedbytes = cpu_to_be16(from->usedbytes);
210 xfs_attr3_leaf_firstused_to_disk(geo, to, from);
211 hdr3->holes = from->holes;
212 hdr3->pad1 = 0;
213
214 for (i = 0; i < XFS_ATTR_LEAF_MAPSIZE; i++) {
215 hdr3->freemap[i].base = cpu_to_be16(from->freemap[i].base);
216 hdr3->freemap[i].size = cpu_to_be16(from->freemap[i].size);
217 }
218 return;
219 }
220 to->hdr.info.forw = cpu_to_be32(from->forw);
221 to->hdr.info.back = cpu_to_be32(from->back);
222 to->hdr.info.magic = cpu_to_be16(from->magic);
223 to->hdr.count = cpu_to_be16(from->count);
224 to->hdr.usedbytes = cpu_to_be16(from->usedbytes);
225 xfs_attr3_leaf_firstused_to_disk(geo, to, from);
226 to->hdr.holes = from->holes;
227 to->hdr.pad1 = 0;
228
229 for (i = 0; i < XFS_ATTR_LEAF_MAPSIZE; i++) {
230 to->hdr.freemap[i].base = cpu_to_be16(from->freemap[i].base);
231 to->hdr.freemap[i].size = cpu_to_be16(from->freemap[i].size);
232 }
233}
234
235static xfs_failaddr_t
236xfs_attr3_leaf_verify_entry(
237 struct xfs_mount *mp,
238 char *buf_end,
239 struct xfs_attr_leafblock *leaf,
240 struct xfs_attr3_icleaf_hdr *leafhdr,
241 struct xfs_attr_leaf_entry *ent,
242 int idx,
243 __u32 *last_hashval)
244{
245 struct xfs_attr_leaf_name_local *lentry;
246 struct xfs_attr_leaf_name_remote *rentry;
247 char *name_end;
248 unsigned int nameidx;
249 unsigned int namesize;
250 __u32 hashval;
251
252
253 hashval = be32_to_cpu(ent->hashval);
254 if (hashval < *last_hashval)
255 return __this_address;
256 *last_hashval = hashval;
257
258 nameidx = be16_to_cpu(ent->nameidx);
259 if (nameidx < leafhdr->firstused || nameidx >= mp->m_attr_geo->blksize)
260 return __this_address;
261
262
263
264
265
266 if (ent->flags & XFS_ATTR_LOCAL) {
267 lentry = xfs_attr3_leaf_name_local(leaf, idx);
268 namesize = xfs_attr_leaf_entsize_local(lentry->namelen,
269 be16_to_cpu(lentry->valuelen));
270 name_end = (char *)lentry + namesize;
271 if (lentry->namelen == 0)
272 return __this_address;
273 } else {
274 rentry = xfs_attr3_leaf_name_remote(leaf, idx);
275 namesize = xfs_attr_leaf_entsize_remote(rentry->namelen);
276 name_end = (char *)rentry + namesize;
277 if (rentry->namelen == 0)
278 return __this_address;
279 if (!(ent->flags & XFS_ATTR_INCOMPLETE) &&
280 rentry->valueblk == 0)
281 return __this_address;
282 }
283
284 if (name_end > buf_end)
285 return __this_address;
286
287 return NULL;
288}
289
290static xfs_failaddr_t
291xfs_attr3_leaf_verify(
292 struct xfs_buf *bp)
293{
294 struct xfs_attr3_icleaf_hdr ichdr;
295 struct xfs_mount *mp = bp->b_mount;
296 struct xfs_attr_leafblock *leaf = bp->b_addr;
297 struct xfs_attr_leaf_entry *entries;
298 struct xfs_attr_leaf_entry *ent;
299 char *buf_end;
300 uint32_t end;
301 __u32 last_hashval = 0;
302 int i;
303 xfs_failaddr_t fa;
304
305 xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &ichdr, leaf);
306
307 fa = xfs_da3_blkinfo_verify(bp, bp->b_addr);
308 if (fa)
309 return fa;
310
311
312
313
314
315 if (ichdr.firstused > mp->m_attr_geo->blksize)
316 return __this_address;
317 if (ichdr.firstused < xfs_attr3_leaf_hdr_size(leaf))
318 return __this_address;
319
320
321 entries = xfs_attr3_leaf_entryp(bp->b_addr);
322 if ((char *)&entries[ichdr.count] >
323 (char *)bp->b_addr + ichdr.firstused)
324 return __this_address;
325
326
327
328
329
330
331
332
333 buf_end = (char *)bp->b_addr + mp->m_attr_geo->blksize;
334 for (i = 0, ent = entries; i < ichdr.count; ent++, i++) {
335 fa = xfs_attr3_leaf_verify_entry(mp, buf_end, leaf, &ichdr,
336 ent, i, &last_hashval);
337 if (fa)
338 return fa;
339 }
340
341
342
343
344
345
346
347
348
349
350 for (i = 0; i < XFS_ATTR_LEAF_MAPSIZE; i++) {
351 if (ichdr.freemap[i].base > mp->m_attr_geo->blksize)
352 return __this_address;
353 if (ichdr.freemap[i].base & 0x3)
354 return __this_address;
355 if (ichdr.freemap[i].size > mp->m_attr_geo->blksize)
356 return __this_address;
357 if (ichdr.freemap[i].size & 0x3)
358 return __this_address;
359
360
361 end = (uint32_t)ichdr.freemap[i].base + ichdr.freemap[i].size;
362 if (end < ichdr.freemap[i].base)
363 return __this_address;
364 if (end > mp->m_attr_geo->blksize)
365 return __this_address;
366 }
367
368 return NULL;
369}
370
371static void
372xfs_attr3_leaf_write_verify(
373 struct xfs_buf *bp)
374{
375 struct xfs_mount *mp = bp->b_mount;
376 struct xfs_buf_log_item *bip = bp->b_log_item;
377 struct xfs_attr3_leaf_hdr *hdr3 = bp->b_addr;
378 xfs_failaddr_t fa;
379
380 fa = xfs_attr3_leaf_verify(bp);
381 if (fa) {
382 xfs_verifier_error(bp, -EFSCORRUPTED, fa);
383 return;
384 }
385
386 if (!xfs_sb_version_hascrc(&mp->m_sb))
387 return;
388
389 if (bip)
390 hdr3->info.lsn = cpu_to_be64(bip->bli_item.li_lsn);
391
392 xfs_buf_update_cksum(bp, XFS_ATTR3_LEAF_CRC_OFF);
393}
394
395
396
397
398
399
400
401static void
402xfs_attr3_leaf_read_verify(
403 struct xfs_buf *bp)
404{
405 struct xfs_mount *mp = bp->b_mount;
406 xfs_failaddr_t fa;
407
408 if (xfs_sb_version_hascrc(&mp->m_sb) &&
409 !xfs_buf_verify_cksum(bp, XFS_ATTR3_LEAF_CRC_OFF))
410 xfs_verifier_error(bp, -EFSBADCRC, __this_address);
411 else {
412 fa = xfs_attr3_leaf_verify(bp);
413 if (fa)
414 xfs_verifier_error(bp, -EFSCORRUPTED, fa);
415 }
416}
417
418const struct xfs_buf_ops xfs_attr3_leaf_buf_ops = {
419 .name = "xfs_attr3_leaf",
420 .magic16 = { cpu_to_be16(XFS_ATTR_LEAF_MAGIC),
421 cpu_to_be16(XFS_ATTR3_LEAF_MAGIC) },
422 .verify_read = xfs_attr3_leaf_read_verify,
423 .verify_write = xfs_attr3_leaf_write_verify,
424 .verify_struct = xfs_attr3_leaf_verify,
425};
426
427int
428xfs_attr3_leaf_read(
429 struct xfs_trans *tp,
430 struct xfs_inode *dp,
431 xfs_dablk_t bno,
432 struct xfs_buf **bpp)
433{
434 int err;
435
436 err = xfs_da_read_buf(tp, dp, bno, 0, bpp, XFS_ATTR_FORK,
437 &xfs_attr3_leaf_buf_ops);
438 if (!err && tp && *bpp)
439 xfs_trans_buf_set_type(tp, *bpp, XFS_BLFT_ATTR_LEAF_BUF);
440 return err;
441}
442
443
444
445
446
447static bool
448xfs_attr_match(
449 struct xfs_da_args *args,
450 uint8_t namelen,
451 unsigned char *name,
452 int flags)
453{
454 if (args->namelen != namelen)
455 return false;
456 if (memcmp(args->name, name, namelen) != 0)
457 return false;
458
459
460
461
462 if (args->attr_filter !=
463 (flags & (XFS_ATTR_NSP_ONDISK_MASK | XFS_ATTR_INCOMPLETE)))
464 return false;
465 return true;
466}
467
468static int
469xfs_attr_copy_value(
470 struct xfs_da_args *args,
471 unsigned char *value,
472 int valuelen)
473{
474
475
476
477 if (!args->valuelen) {
478 args->valuelen = valuelen;
479 return 0;
480 }
481
482
483
484
485 if (args->valuelen < valuelen) {
486 args->valuelen = valuelen;
487 return -ERANGE;
488 }
489
490 if (!args->value) {
491 args->value = kmem_alloc_large(valuelen, KM_NOLOCKDEP);
492 if (!args->value)
493 return -ENOMEM;
494 }
495 args->valuelen = valuelen;
496
497
498 if (args->rmtblkno)
499 return xfs_attr_rmtval_get(args);
500
501
502
503
504
505
506
507 if (!value)
508 return -EINVAL;
509 memcpy(args->value, value, valuelen);
510 return 0;
511}
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527int
528xfs_attr_shortform_bytesfit(
529 struct xfs_inode *dp,
530 int bytes)
531{
532 struct xfs_mount *mp = dp->i_mount;
533 int64_t dsize;
534 int minforkoff;
535 int maxforkoff;
536 int offset;
537
538
539
540
541 if (bytes > XFS_LITINO(mp))
542 return 0;
543
544
545 offset = (XFS_LITINO(mp) - bytes) >> 3;
546
547 if (dp->i_df.if_format == XFS_DINODE_FMT_DEV) {
548 minforkoff = roundup(sizeof(xfs_dev_t), 8) >> 3;
549 return (offset >= minforkoff) ? minforkoff : 0;
550 }
551
552
553
554
555
556
557
558
559
560
561
562 if (bytes <= XFS_IFORK_ASIZE(dp))
563 return dp->i_d.di_forkoff;
564
565
566
567
568
569
570 if (!(mp->m_flags & XFS_MOUNT_ATTR2))
571 return 0;
572
573 dsize = dp->i_df.if_bytes;
574
575 switch (dp->i_df.if_format) {
576 case XFS_DINODE_FMT_EXTENTS:
577
578
579
580
581
582
583
584 if (!dp->i_d.di_forkoff && dp->i_df.if_bytes >
585 xfs_default_attroffset(dp))
586 dsize = XFS_BMDR_SPACE_CALC(MINDBTPTRS);
587 break;
588 case XFS_DINODE_FMT_BTREE:
589
590
591
592
593
594
595 if (dp->i_d.di_forkoff) {
596 if (offset < dp->i_d.di_forkoff)
597 return 0;
598 return dp->i_d.di_forkoff;
599 }
600 dsize = XFS_BMAP_BROOT_SPACE(mp, dp->i_df.if_broot);
601 break;
602 }
603
604
605
606
607
608 minforkoff = max_t(int64_t, dsize, XFS_BMDR_SPACE_CALC(MINDBTPTRS));
609 minforkoff = roundup(minforkoff, 8) >> 3;
610
611
612 maxforkoff = XFS_LITINO(mp) - XFS_BMDR_SPACE_CALC(MINABTPTRS);
613 maxforkoff = maxforkoff >> 3;
614
615 if (offset >= maxforkoff)
616 return maxforkoff;
617 if (offset >= minforkoff)
618 return offset;
619 return 0;
620}
621
622
623
624
625STATIC void
626xfs_sbversion_add_attr2(xfs_mount_t *mp, xfs_trans_t *tp)
627{
628 if ((mp->m_flags & XFS_MOUNT_ATTR2) &&
629 !(xfs_sb_version_hasattr2(&mp->m_sb))) {
630 spin_lock(&mp->m_sb_lock);
631 if (!xfs_sb_version_hasattr2(&mp->m_sb)) {
632 xfs_sb_version_addattr2(&mp->m_sb);
633 spin_unlock(&mp->m_sb_lock);
634 xfs_log_sb(tp);
635 } else
636 spin_unlock(&mp->m_sb_lock);
637 }
638}
639
640
641
642
643void
644xfs_attr_shortform_create(
645 struct xfs_da_args *args)
646{
647 struct xfs_inode *dp = args->dp;
648 struct xfs_ifork *ifp = dp->i_afp;
649 struct xfs_attr_sf_hdr *hdr;
650
651 trace_xfs_attr_sf_create(args);
652
653 ASSERT(ifp->if_bytes == 0);
654 if (ifp->if_format == XFS_DINODE_FMT_EXTENTS) {
655 ifp->if_flags &= ~XFS_IFEXTENTS;
656 ifp->if_format = XFS_DINODE_FMT_LOCAL;
657 ifp->if_flags |= XFS_IFINLINE;
658 } else {
659 ASSERT(ifp->if_flags & XFS_IFINLINE);
660 }
661 xfs_idata_realloc(dp, sizeof(*hdr), XFS_ATTR_FORK);
662 hdr = (struct xfs_attr_sf_hdr *)ifp->if_u1.if_data;
663 memset(hdr, 0, sizeof(*hdr));
664 hdr->totsize = cpu_to_be16(sizeof(*hdr));
665 xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_ADATA);
666}
667
668
669
670
671
672
673
674
675
676
677int
678xfs_attr_sf_findname(
679 struct xfs_da_args *args,
680 struct xfs_attr_sf_entry **sfep,
681 unsigned int *basep)
682{
683 struct xfs_attr_shortform *sf;
684 struct xfs_attr_sf_entry *sfe;
685 unsigned int base = sizeof(struct xfs_attr_sf_hdr);
686 int size = 0;
687 int end;
688 int i;
689
690 sf = (struct xfs_attr_shortform *)args->dp->i_afp->if_u1.if_data;
691 sfe = &sf->list[0];
692 end = sf->hdr.count;
693 for (i = 0; i < end; sfe = xfs_attr_sf_nextentry(sfe),
694 base += size, i++) {
695 size = xfs_attr_sf_entsize(sfe);
696 if (!xfs_attr_match(args, sfe->namelen, sfe->nameval,
697 sfe->flags))
698 continue;
699 break;
700 }
701
702 if (sfep != NULL)
703 *sfep = sfe;
704
705 if (basep != NULL)
706 *basep = base;
707
708 if (i == end)
709 return -ENOATTR;
710 return -EEXIST;
711}
712
713
714
715
716
717void
718xfs_attr_shortform_add(
719 struct xfs_da_args *args,
720 int forkoff)
721{
722 struct xfs_attr_shortform *sf;
723 struct xfs_attr_sf_entry *sfe;
724 int offset, size;
725 struct xfs_mount *mp;
726 struct xfs_inode *dp;
727 struct xfs_ifork *ifp;
728
729 trace_xfs_attr_sf_add(args);
730
731 dp = args->dp;
732 mp = dp->i_mount;
733 dp->i_d.di_forkoff = forkoff;
734
735 ifp = dp->i_afp;
736 ASSERT(ifp->if_flags & XFS_IFINLINE);
737 sf = (struct xfs_attr_shortform *)ifp->if_u1.if_data;
738 if (xfs_attr_sf_findname(args, &sfe, NULL) == -EEXIST)
739 ASSERT(0);
740
741 offset = (char *)sfe - (char *)sf;
742 size = xfs_attr_sf_entsize_byname(args->namelen, args->valuelen);
743 xfs_idata_realloc(dp, size, XFS_ATTR_FORK);
744 sf = (struct xfs_attr_shortform *)ifp->if_u1.if_data;
745 sfe = (struct xfs_attr_sf_entry *)((char *)sf + offset);
746
747 sfe->namelen = args->namelen;
748 sfe->valuelen = args->valuelen;
749 sfe->flags = args->attr_filter;
750 memcpy(sfe->nameval, args->name, args->namelen);
751 memcpy(&sfe->nameval[args->namelen], args->value, args->valuelen);
752 sf->hdr.count++;
753 be16_add_cpu(&sf->hdr.totsize, size);
754 xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_ADATA);
755
756 xfs_sbversion_add_attr2(mp, args->trans);
757}
758
759
760
761
762
763void
764xfs_attr_fork_remove(
765 struct xfs_inode *ip,
766 struct xfs_trans *tp)
767{
768 ASSERT(ip->i_afp->if_nextents == 0);
769
770 xfs_idestroy_fork(ip->i_afp);
771 kmem_cache_free(xfs_ifork_zone, ip->i_afp);
772 ip->i_afp = NULL;
773 ip->i_d.di_forkoff = 0;
774 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
775}
776
777
778
779
780int
781xfs_attr_shortform_remove(
782 struct xfs_da_args *args)
783{
784 struct xfs_attr_shortform *sf;
785 struct xfs_attr_sf_entry *sfe;
786 int size = 0, end, totsize;
787 unsigned int base;
788 struct xfs_mount *mp;
789 struct xfs_inode *dp;
790 int error;
791
792 trace_xfs_attr_sf_remove(args);
793
794 dp = args->dp;
795 mp = dp->i_mount;
796 sf = (struct xfs_attr_shortform *)dp->i_afp->if_u1.if_data;
797
798 error = xfs_attr_sf_findname(args, &sfe, &base);
799 if (error != -EEXIST)
800 return error;
801 size = xfs_attr_sf_entsize(sfe);
802
803
804
805
806 end = base + size;
807 totsize = be16_to_cpu(sf->hdr.totsize);
808 if (end != totsize)
809 memmove(&((char *)sf)[base], &((char *)sf)[end], totsize - end);
810 sf->hdr.count--;
811 be16_add_cpu(&sf->hdr.totsize, -size);
812
813
814
815
816 totsize -= size;
817 if (totsize == sizeof(xfs_attr_sf_hdr_t) &&
818 (mp->m_flags & XFS_MOUNT_ATTR2) &&
819 (dp->i_df.if_format != XFS_DINODE_FMT_BTREE) &&
820 !(args->op_flags & XFS_DA_OP_ADDNAME)) {
821 xfs_attr_fork_remove(dp, args->trans);
822 } else {
823 xfs_idata_realloc(dp, -size, XFS_ATTR_FORK);
824 dp->i_d.di_forkoff = xfs_attr_shortform_bytesfit(dp, totsize);
825 ASSERT(dp->i_d.di_forkoff);
826 ASSERT(totsize > sizeof(xfs_attr_sf_hdr_t) ||
827 (args->op_flags & XFS_DA_OP_ADDNAME) ||
828 !(mp->m_flags & XFS_MOUNT_ATTR2) ||
829 dp->i_df.if_format == XFS_DINODE_FMT_BTREE);
830 xfs_trans_log_inode(args->trans, dp,
831 XFS_ILOG_CORE | XFS_ILOG_ADATA);
832 }
833
834 xfs_sbversion_add_attr2(mp, args->trans);
835
836 return 0;
837}
838
839
840
841
842
843int
844xfs_attr_shortform_lookup(xfs_da_args_t *args)
845{
846 struct xfs_attr_shortform *sf;
847 struct xfs_attr_sf_entry *sfe;
848 int i;
849 struct xfs_ifork *ifp;
850
851 trace_xfs_attr_sf_lookup(args);
852
853 ifp = args->dp->i_afp;
854 ASSERT(ifp->if_flags & XFS_IFINLINE);
855 sf = (struct xfs_attr_shortform *)ifp->if_u1.if_data;
856 sfe = &sf->list[0];
857 for (i = 0; i < sf->hdr.count;
858 sfe = xfs_attr_sf_nextentry(sfe), i++) {
859 if (xfs_attr_match(args, sfe->namelen, sfe->nameval,
860 sfe->flags))
861 return -EEXIST;
862 }
863 return -ENOATTR;
864}
865
866
867
868
869
870
871
872
873int
874xfs_attr_shortform_getvalue(
875 struct xfs_da_args *args)
876{
877 struct xfs_attr_shortform *sf;
878 struct xfs_attr_sf_entry *sfe;
879 int i;
880
881 ASSERT(args->dp->i_afp->if_flags == XFS_IFINLINE);
882 sf = (struct xfs_attr_shortform *)args->dp->i_afp->if_u1.if_data;
883 sfe = &sf->list[0];
884 for (i = 0; i < sf->hdr.count;
885 sfe = xfs_attr_sf_nextentry(sfe), i++) {
886 if (xfs_attr_match(args, sfe->namelen, sfe->nameval,
887 sfe->flags))
888 return xfs_attr_copy_value(args,
889 &sfe->nameval[args->namelen], sfe->valuelen);
890 }
891 return -ENOATTR;
892}
893
894
895
896
897
898int
899xfs_attr_shortform_to_leaf(
900 struct xfs_da_args *args,
901 struct xfs_buf **leaf_bp)
902{
903 struct xfs_inode *dp;
904 struct xfs_attr_shortform *sf;
905 struct xfs_attr_sf_entry *sfe;
906 struct xfs_da_args nargs;
907 char *tmpbuffer;
908 int error, i, size;
909 xfs_dablk_t blkno;
910 struct xfs_buf *bp;
911 struct xfs_ifork *ifp;
912
913 trace_xfs_attr_sf_to_leaf(args);
914
915 dp = args->dp;
916 ifp = dp->i_afp;
917 sf = (struct xfs_attr_shortform *)ifp->if_u1.if_data;
918 size = be16_to_cpu(sf->hdr.totsize);
919 tmpbuffer = kmem_alloc(size, 0);
920 ASSERT(tmpbuffer != NULL);
921 memcpy(tmpbuffer, ifp->if_u1.if_data, size);
922 sf = (struct xfs_attr_shortform *)tmpbuffer;
923
924 xfs_idata_realloc(dp, -size, XFS_ATTR_FORK);
925 xfs_bmap_local_to_extents_empty(args->trans, dp, XFS_ATTR_FORK);
926
927 bp = NULL;
928 error = xfs_da_grow_inode(args, &blkno);
929 if (error)
930 goto out;
931
932 ASSERT(blkno == 0);
933 error = xfs_attr3_leaf_create(args, blkno, &bp);
934 if (error)
935 goto out;
936
937 memset((char *)&nargs, 0, sizeof(nargs));
938 nargs.dp = dp;
939 nargs.geo = args->geo;
940 nargs.total = args->total;
941 nargs.whichfork = XFS_ATTR_FORK;
942 nargs.trans = args->trans;
943 nargs.op_flags = XFS_DA_OP_OKNOENT;
944
945 sfe = &sf->list[0];
946 for (i = 0; i < sf->hdr.count; i++) {
947 nargs.name = sfe->nameval;
948 nargs.namelen = sfe->namelen;
949 nargs.value = &sfe->nameval[nargs.namelen];
950 nargs.valuelen = sfe->valuelen;
951 nargs.hashval = xfs_da_hashname(sfe->nameval,
952 sfe->namelen);
953 nargs.attr_filter = sfe->flags & XFS_ATTR_NSP_ONDISK_MASK;
954 error = xfs_attr3_leaf_lookup_int(bp, &nargs);
955 ASSERT(error == -ENOATTR);
956 error = xfs_attr3_leaf_add(bp, &nargs);
957 ASSERT(error != -ENOSPC);
958 if (error)
959 goto out;
960 sfe = xfs_attr_sf_nextentry(sfe);
961 }
962 error = 0;
963 *leaf_bp = bp;
964out:
965 kmem_free(tmpbuffer);
966 return error;
967}
968
969
970
971
972
973int
974xfs_attr_shortform_allfit(
975 struct xfs_buf *bp,
976 struct xfs_inode *dp)
977{
978 struct xfs_attr_leafblock *leaf;
979 struct xfs_attr_leaf_entry *entry;
980 xfs_attr_leaf_name_local_t *name_loc;
981 struct xfs_attr3_icleaf_hdr leafhdr;
982 int bytes;
983 int i;
984 struct xfs_mount *mp = bp->b_mount;
985
986 leaf = bp->b_addr;
987 xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &leafhdr, leaf);
988 entry = xfs_attr3_leaf_entryp(leaf);
989
990 bytes = sizeof(struct xfs_attr_sf_hdr);
991 for (i = 0; i < leafhdr.count; entry++, i++) {
992 if (entry->flags & XFS_ATTR_INCOMPLETE)
993 continue;
994 if (!(entry->flags & XFS_ATTR_LOCAL))
995 return 0;
996 name_loc = xfs_attr3_leaf_name_local(leaf, i);
997 if (name_loc->namelen >= XFS_ATTR_SF_ENTSIZE_MAX)
998 return 0;
999 if (be16_to_cpu(name_loc->valuelen) >= XFS_ATTR_SF_ENTSIZE_MAX)
1000 return 0;
1001 bytes += xfs_attr_sf_entsize_byname(name_loc->namelen,
1002 be16_to_cpu(name_loc->valuelen));
1003 }
1004 if ((dp->i_mount->m_flags & XFS_MOUNT_ATTR2) &&
1005 (dp->i_df.if_format != XFS_DINODE_FMT_BTREE) &&
1006 (bytes == sizeof(struct xfs_attr_sf_hdr)))
1007 return -1;
1008 return xfs_attr_shortform_bytesfit(dp, bytes);
1009}
1010
1011
1012xfs_failaddr_t
1013xfs_attr_shortform_verify(
1014 struct xfs_inode *ip)
1015{
1016 struct xfs_attr_shortform *sfp;
1017 struct xfs_attr_sf_entry *sfep;
1018 struct xfs_attr_sf_entry *next_sfep;
1019 char *endp;
1020 struct xfs_ifork *ifp;
1021 int i;
1022 int64_t size;
1023
1024 ASSERT(ip->i_afp->if_format == XFS_DINODE_FMT_LOCAL);
1025 ifp = XFS_IFORK_PTR(ip, XFS_ATTR_FORK);
1026 sfp = (struct xfs_attr_shortform *)ifp->if_u1.if_data;
1027 size = ifp->if_bytes;
1028
1029
1030
1031
1032 if (size < sizeof(struct xfs_attr_sf_hdr))
1033 return __this_address;
1034
1035 endp = (char *)sfp + size;
1036
1037
1038 sfep = &sfp->list[0];
1039 for (i = 0; i < sfp->hdr.count; i++) {
1040
1041
1042
1043
1044
1045
1046
1047 if (((char *)sfep + sizeof(*sfep)) >= endp)
1048 return __this_address;
1049
1050
1051 if (sfep->namelen == 0)
1052 return __this_address;
1053
1054
1055
1056
1057
1058
1059 next_sfep = xfs_attr_sf_nextentry(sfep);
1060 if ((char *)next_sfep > endp)
1061 return __this_address;
1062
1063
1064
1065
1066
1067
1068 if (sfep->flags & ~XFS_ATTR_NSP_ONDISK_MASK)
1069 return __this_address;
1070
1071
1072
1073
1074
1075
1076 if (hweight8(sfep->flags & XFS_ATTR_NSP_ONDISK_MASK) > 1)
1077 return __this_address;
1078
1079 sfep = next_sfep;
1080 }
1081 if ((void *)sfep != (void *)endp)
1082 return __this_address;
1083
1084 return NULL;
1085}
1086
1087
1088
1089
1090int
1091xfs_attr3_leaf_to_shortform(
1092 struct xfs_buf *bp,
1093 struct xfs_da_args *args,
1094 int forkoff)
1095{
1096 struct xfs_attr_leafblock *leaf;
1097 struct xfs_attr3_icleaf_hdr ichdr;
1098 struct xfs_attr_leaf_entry *entry;
1099 struct xfs_attr_leaf_name_local *name_loc;
1100 struct xfs_da_args nargs;
1101 struct xfs_inode *dp = args->dp;
1102 char *tmpbuffer;
1103 int error;
1104 int i;
1105
1106 trace_xfs_attr_leaf_to_sf(args);
1107
1108 tmpbuffer = kmem_alloc(args->geo->blksize, 0);
1109 if (!tmpbuffer)
1110 return -ENOMEM;
1111
1112 memcpy(tmpbuffer, bp->b_addr, args->geo->blksize);
1113
1114 leaf = (xfs_attr_leafblock_t *)tmpbuffer;
1115 xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);
1116 entry = xfs_attr3_leaf_entryp(leaf);
1117
1118
1119 memset(bp->b_addr, 0, args->geo->blksize);
1120
1121
1122
1123
1124 error = xfs_da_shrink_inode(args, 0, bp);
1125 if (error)
1126 goto out;
1127
1128 if (forkoff == -1) {
1129 ASSERT(dp->i_mount->m_flags & XFS_MOUNT_ATTR2);
1130 ASSERT(dp->i_df.if_format != XFS_DINODE_FMT_BTREE);
1131 xfs_attr_fork_remove(dp, args->trans);
1132 goto out;
1133 }
1134
1135 xfs_attr_shortform_create(args);
1136
1137
1138
1139
1140 memset((char *)&nargs, 0, sizeof(nargs));
1141 nargs.geo = args->geo;
1142 nargs.dp = dp;
1143 nargs.total = args->total;
1144 nargs.whichfork = XFS_ATTR_FORK;
1145 nargs.trans = args->trans;
1146 nargs.op_flags = XFS_DA_OP_OKNOENT;
1147
1148 for (i = 0; i < ichdr.count; entry++, i++) {
1149 if (entry->flags & XFS_ATTR_INCOMPLETE)
1150 continue;
1151 if (!entry->nameidx)
1152 continue;
1153 ASSERT(entry->flags & XFS_ATTR_LOCAL);
1154 name_loc = xfs_attr3_leaf_name_local(leaf, i);
1155 nargs.name = name_loc->nameval;
1156 nargs.namelen = name_loc->namelen;
1157 nargs.value = &name_loc->nameval[nargs.namelen];
1158 nargs.valuelen = be16_to_cpu(name_loc->valuelen);
1159 nargs.hashval = be32_to_cpu(entry->hashval);
1160 nargs.attr_filter = entry->flags & XFS_ATTR_NSP_ONDISK_MASK;
1161 xfs_attr_shortform_add(&nargs, forkoff);
1162 }
1163 error = 0;
1164
1165out:
1166 kmem_free(tmpbuffer);
1167 return error;
1168}
1169
1170
1171
1172
1173int
1174xfs_attr3_leaf_to_node(
1175 struct xfs_da_args *args)
1176{
1177 struct xfs_attr_leafblock *leaf;
1178 struct xfs_attr3_icleaf_hdr icleafhdr;
1179 struct xfs_attr_leaf_entry *entries;
1180 struct xfs_da3_icnode_hdr icnodehdr;
1181 struct xfs_da_intnode *node;
1182 struct xfs_inode *dp = args->dp;
1183 struct xfs_mount *mp = dp->i_mount;
1184 struct xfs_buf *bp1 = NULL;
1185 struct xfs_buf *bp2 = NULL;
1186 xfs_dablk_t blkno;
1187 int error;
1188
1189 trace_xfs_attr_leaf_to_node(args);
1190
1191 error = xfs_da_grow_inode(args, &blkno);
1192 if (error)
1193 goto out;
1194 error = xfs_attr3_leaf_read(args->trans, dp, 0, &bp1);
1195 if (error)
1196 goto out;
1197
1198 error = xfs_da_get_buf(args->trans, dp, blkno, &bp2, XFS_ATTR_FORK);
1199 if (error)
1200 goto out;
1201
1202
1203 xfs_trans_buf_set_type(args->trans, bp2, XFS_BLFT_ATTR_LEAF_BUF);
1204 bp2->b_ops = bp1->b_ops;
1205 memcpy(bp2->b_addr, bp1->b_addr, args->geo->blksize);
1206 if (xfs_sb_version_hascrc(&mp->m_sb)) {
1207 struct xfs_da3_blkinfo *hdr3 = bp2->b_addr;
1208 hdr3->blkno = cpu_to_be64(bp2->b_bn);
1209 }
1210 xfs_trans_log_buf(args->trans, bp2, 0, args->geo->blksize - 1);
1211
1212
1213
1214
1215 error = xfs_da3_node_create(args, 0, 1, &bp1, XFS_ATTR_FORK);
1216 if (error)
1217 goto out;
1218 node = bp1->b_addr;
1219 xfs_da3_node_hdr_from_disk(mp, &icnodehdr, node);
1220
1221 leaf = bp2->b_addr;
1222 xfs_attr3_leaf_hdr_from_disk(args->geo, &icleafhdr, leaf);
1223 entries = xfs_attr3_leaf_entryp(leaf);
1224
1225
1226 icnodehdr.btree[0].hashval = entries[icleafhdr.count - 1].hashval;
1227 icnodehdr.btree[0].before = cpu_to_be32(blkno);
1228 icnodehdr.count = 1;
1229 xfs_da3_node_hdr_to_disk(dp->i_mount, node, &icnodehdr);
1230 xfs_trans_log_buf(args->trans, bp1, 0, args->geo->blksize - 1);
1231 error = 0;
1232out:
1233 return error;
1234}
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244STATIC int
1245xfs_attr3_leaf_create(
1246 struct xfs_da_args *args,
1247 xfs_dablk_t blkno,
1248 struct xfs_buf **bpp)
1249{
1250 struct xfs_attr_leafblock *leaf;
1251 struct xfs_attr3_icleaf_hdr ichdr;
1252 struct xfs_inode *dp = args->dp;
1253 struct xfs_mount *mp = dp->i_mount;
1254 struct xfs_buf *bp;
1255 int error;
1256
1257 trace_xfs_attr_leaf_create(args);
1258
1259 error = xfs_da_get_buf(args->trans, args->dp, blkno, &bp,
1260 XFS_ATTR_FORK);
1261 if (error)
1262 return error;
1263 bp->b_ops = &xfs_attr3_leaf_buf_ops;
1264 xfs_trans_buf_set_type(args->trans, bp, XFS_BLFT_ATTR_LEAF_BUF);
1265 leaf = bp->b_addr;
1266 memset(leaf, 0, args->geo->blksize);
1267
1268 memset(&ichdr, 0, sizeof(ichdr));
1269 ichdr.firstused = args->geo->blksize;
1270
1271 if (xfs_sb_version_hascrc(&mp->m_sb)) {
1272 struct xfs_da3_blkinfo *hdr3 = bp->b_addr;
1273
1274 ichdr.magic = XFS_ATTR3_LEAF_MAGIC;
1275
1276 hdr3->blkno = cpu_to_be64(bp->b_bn);
1277 hdr3->owner = cpu_to_be64(dp->i_ino);
1278 uuid_copy(&hdr3->uuid, &mp->m_sb.sb_meta_uuid);
1279
1280 ichdr.freemap[0].base = sizeof(struct xfs_attr3_leaf_hdr);
1281 } else {
1282 ichdr.magic = XFS_ATTR_LEAF_MAGIC;
1283 ichdr.freemap[0].base = sizeof(struct xfs_attr_leaf_hdr);
1284 }
1285 ichdr.freemap[0].size = ichdr.firstused - ichdr.freemap[0].base;
1286
1287 xfs_attr3_leaf_hdr_to_disk(args->geo, leaf, &ichdr);
1288 xfs_trans_log_buf(args->trans, bp, 0, args->geo->blksize - 1);
1289
1290 *bpp = bp;
1291 return 0;
1292}
1293
1294
1295
1296
1297int
1298xfs_attr3_leaf_split(
1299 struct xfs_da_state *state,
1300 struct xfs_da_state_blk *oldblk,
1301 struct xfs_da_state_blk *newblk)
1302{
1303 xfs_dablk_t blkno;
1304 int error;
1305
1306 trace_xfs_attr_leaf_split(state->args);
1307
1308
1309
1310
1311 ASSERT(oldblk->magic == XFS_ATTR_LEAF_MAGIC);
1312 error = xfs_da_grow_inode(state->args, &blkno);
1313 if (error)
1314 return error;
1315 error = xfs_attr3_leaf_create(state->args, blkno, &newblk->bp);
1316 if (error)
1317 return error;
1318 newblk->blkno = blkno;
1319 newblk->magic = XFS_ATTR_LEAF_MAGIC;
1320
1321
1322
1323
1324
1325 xfs_attr3_leaf_rebalance(state, oldblk, newblk);
1326 error = xfs_da3_blk_link(state, oldblk, newblk);
1327 if (error)
1328 return error;
1329
1330
1331
1332
1333
1334
1335
1336
1337 if (state->inleaf) {
1338 trace_xfs_attr_leaf_add_old(state->args);
1339 error = xfs_attr3_leaf_add(oldblk->bp, state->args);
1340 } else {
1341 trace_xfs_attr_leaf_add_new(state->args);
1342 error = xfs_attr3_leaf_add(newblk->bp, state->args);
1343 }
1344
1345
1346
1347
1348 oldblk->hashval = xfs_attr_leaf_lasthash(oldblk->bp, NULL);
1349 newblk->hashval = xfs_attr_leaf_lasthash(newblk->bp, NULL);
1350 return error;
1351}
1352
1353
1354
1355
1356int
1357xfs_attr3_leaf_add(
1358 struct xfs_buf *bp,
1359 struct xfs_da_args *args)
1360{
1361 struct xfs_attr_leafblock *leaf;
1362 struct xfs_attr3_icleaf_hdr ichdr;
1363 int tablesize;
1364 int entsize;
1365 int sum;
1366 int tmp;
1367 int i;
1368
1369 trace_xfs_attr_leaf_add(args);
1370
1371 leaf = bp->b_addr;
1372 xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);
1373 ASSERT(args->index >= 0 && args->index <= ichdr.count);
1374 entsize = xfs_attr_leaf_newentsize(args, NULL);
1375
1376
1377
1378
1379
1380 tablesize = (ichdr.count + 1) * sizeof(xfs_attr_leaf_entry_t)
1381 + xfs_attr3_leaf_hdr_size(leaf);
1382 for (sum = 0, i = XFS_ATTR_LEAF_MAPSIZE - 1; i >= 0; i--) {
1383 if (tablesize > ichdr.firstused) {
1384 sum += ichdr.freemap[i].size;
1385 continue;
1386 }
1387 if (!ichdr.freemap[i].size)
1388 continue;
1389 tmp = entsize;
1390 if (ichdr.freemap[i].base < ichdr.firstused)
1391 tmp += sizeof(xfs_attr_leaf_entry_t);
1392 if (ichdr.freemap[i].size >= tmp) {
1393 tmp = xfs_attr3_leaf_add_work(bp, &ichdr, args, i);
1394 goto out_log_hdr;
1395 }
1396 sum += ichdr.freemap[i].size;
1397 }
1398
1399
1400
1401
1402
1403
1404 if (!ichdr.holes && sum < entsize)
1405 return -ENOSPC;
1406
1407
1408
1409
1410
1411 xfs_attr3_leaf_compact(args, &ichdr, bp);
1412
1413
1414
1415
1416
1417 if (ichdr.freemap[0].size < (entsize + sizeof(xfs_attr_leaf_entry_t))) {
1418 tmp = -ENOSPC;
1419 goto out_log_hdr;
1420 }
1421
1422 tmp = xfs_attr3_leaf_add_work(bp, &ichdr, args, 0);
1423
1424out_log_hdr:
1425 xfs_attr3_leaf_hdr_to_disk(args->geo, leaf, &ichdr);
1426 xfs_trans_log_buf(args->trans, bp,
1427 XFS_DA_LOGRANGE(leaf, &leaf->hdr,
1428 xfs_attr3_leaf_hdr_size(leaf)));
1429 return tmp;
1430}
1431
1432
1433
1434
1435STATIC int
1436xfs_attr3_leaf_add_work(
1437 struct xfs_buf *bp,
1438 struct xfs_attr3_icleaf_hdr *ichdr,
1439 struct xfs_da_args *args,
1440 int mapindex)
1441{
1442 struct xfs_attr_leafblock *leaf;
1443 struct xfs_attr_leaf_entry *entry;
1444 struct xfs_attr_leaf_name_local *name_loc;
1445 struct xfs_attr_leaf_name_remote *name_rmt;
1446 struct xfs_mount *mp;
1447 int tmp;
1448 int i;
1449
1450 trace_xfs_attr_leaf_add_work(args);
1451
1452 leaf = bp->b_addr;
1453 ASSERT(mapindex >= 0 && mapindex < XFS_ATTR_LEAF_MAPSIZE);
1454 ASSERT(args->index >= 0 && args->index <= ichdr->count);
1455
1456
1457
1458
1459 entry = &xfs_attr3_leaf_entryp(leaf)[args->index];
1460 if (args->index < ichdr->count) {
1461 tmp = ichdr->count - args->index;
1462 tmp *= sizeof(xfs_attr_leaf_entry_t);
1463 memmove(entry + 1, entry, tmp);
1464 xfs_trans_log_buf(args->trans, bp,
1465 XFS_DA_LOGRANGE(leaf, entry, tmp + sizeof(*entry)));
1466 }
1467 ichdr->count++;
1468
1469
1470
1471
1472 mp = args->trans->t_mountp;
1473 ASSERT(ichdr->freemap[mapindex].base < args->geo->blksize);
1474 ASSERT((ichdr->freemap[mapindex].base & 0x3) == 0);
1475 ASSERT(ichdr->freemap[mapindex].size >=
1476 xfs_attr_leaf_newentsize(args, NULL));
1477 ASSERT(ichdr->freemap[mapindex].size < args->geo->blksize);
1478 ASSERT((ichdr->freemap[mapindex].size & 0x3) == 0);
1479
1480 ichdr->freemap[mapindex].size -= xfs_attr_leaf_newentsize(args, &tmp);
1481
1482 entry->nameidx = cpu_to_be16(ichdr->freemap[mapindex].base +
1483 ichdr->freemap[mapindex].size);
1484 entry->hashval = cpu_to_be32(args->hashval);
1485 entry->flags = args->attr_filter;
1486 if (tmp)
1487 entry->flags |= XFS_ATTR_LOCAL;
1488 if (args->op_flags & XFS_DA_OP_RENAME) {
1489 entry->flags |= XFS_ATTR_INCOMPLETE;
1490 if ((args->blkno2 == args->blkno) &&
1491 (args->index2 <= args->index)) {
1492 args->index2++;
1493 }
1494 }
1495 xfs_trans_log_buf(args->trans, bp,
1496 XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));
1497 ASSERT((args->index == 0) ||
1498 (be32_to_cpu(entry->hashval) >= be32_to_cpu((entry-1)->hashval)));
1499 ASSERT((args->index == ichdr->count - 1) ||
1500 (be32_to_cpu(entry->hashval) <= be32_to_cpu((entry+1)->hashval)));
1501
1502
1503
1504
1505
1506
1507
1508
1509 if (entry->flags & XFS_ATTR_LOCAL) {
1510 name_loc = xfs_attr3_leaf_name_local(leaf, args->index);
1511 name_loc->namelen = args->namelen;
1512 name_loc->valuelen = cpu_to_be16(args->valuelen);
1513 memcpy((char *)name_loc->nameval, args->name, args->namelen);
1514 memcpy((char *)&name_loc->nameval[args->namelen], args->value,
1515 be16_to_cpu(name_loc->valuelen));
1516 } else {
1517 name_rmt = xfs_attr3_leaf_name_remote(leaf, args->index);
1518 name_rmt->namelen = args->namelen;
1519 memcpy((char *)name_rmt->name, args->name, args->namelen);
1520 entry->flags |= XFS_ATTR_INCOMPLETE;
1521
1522 name_rmt->valuelen = 0;
1523 name_rmt->valueblk = 0;
1524 args->rmtblkno = 1;
1525 args->rmtblkcnt = xfs_attr3_rmt_blocks(mp, args->valuelen);
1526 args->rmtvaluelen = args->valuelen;
1527 }
1528 xfs_trans_log_buf(args->trans, bp,
1529 XFS_DA_LOGRANGE(leaf, xfs_attr3_leaf_name(leaf, args->index),
1530 xfs_attr_leaf_entsize(leaf, args->index)));
1531
1532
1533
1534
1535 if (be16_to_cpu(entry->nameidx) < ichdr->firstused)
1536 ichdr->firstused = be16_to_cpu(entry->nameidx);
1537
1538 ASSERT(ichdr->firstused >= ichdr->count * sizeof(xfs_attr_leaf_entry_t)
1539 + xfs_attr3_leaf_hdr_size(leaf));
1540 tmp = (ichdr->count - 1) * sizeof(xfs_attr_leaf_entry_t)
1541 + xfs_attr3_leaf_hdr_size(leaf);
1542
1543 for (i = 0; i < XFS_ATTR_LEAF_MAPSIZE; i++) {
1544 if (ichdr->freemap[i].base == tmp) {
1545 ichdr->freemap[i].base += sizeof(xfs_attr_leaf_entry_t);
1546 ichdr->freemap[i].size -=
1547 min_t(uint16_t, ichdr->freemap[i].size,
1548 sizeof(xfs_attr_leaf_entry_t));
1549 }
1550 }
1551 ichdr->usedbytes += xfs_attr_leaf_entsize(leaf, args->index);
1552 return 0;
1553}
1554
1555
1556
1557
1558STATIC void
1559xfs_attr3_leaf_compact(
1560 struct xfs_da_args *args,
1561 struct xfs_attr3_icleaf_hdr *ichdr_dst,
1562 struct xfs_buf *bp)
1563{
1564 struct xfs_attr_leafblock *leaf_src;
1565 struct xfs_attr_leafblock *leaf_dst;
1566 struct xfs_attr3_icleaf_hdr ichdr_src;
1567 struct xfs_trans *trans = args->trans;
1568 char *tmpbuffer;
1569
1570 trace_xfs_attr_leaf_compact(args);
1571
1572 tmpbuffer = kmem_alloc(args->geo->blksize, 0);
1573 memcpy(tmpbuffer, bp->b_addr, args->geo->blksize);
1574 memset(bp->b_addr, 0, args->geo->blksize);
1575 leaf_src = (xfs_attr_leafblock_t *)tmpbuffer;
1576 leaf_dst = bp->b_addr;
1577
1578
1579
1580
1581
1582
1583 memcpy(bp->b_addr, tmpbuffer, xfs_attr3_leaf_hdr_size(leaf_src));
1584
1585
1586 ichdr_src = *ichdr_dst;
1587 ichdr_dst->firstused = args->geo->blksize;
1588 ichdr_dst->usedbytes = 0;
1589 ichdr_dst->count = 0;
1590 ichdr_dst->holes = 0;
1591 ichdr_dst->freemap[0].base = xfs_attr3_leaf_hdr_size(leaf_src);
1592 ichdr_dst->freemap[0].size = ichdr_dst->firstused -
1593 ichdr_dst->freemap[0].base;
1594
1595
1596 xfs_attr3_leaf_hdr_to_disk(args->geo, leaf_dst, ichdr_dst);
1597
1598
1599
1600
1601
1602 xfs_attr3_leaf_moveents(args, leaf_src, &ichdr_src, 0,
1603 leaf_dst, ichdr_dst, 0, ichdr_src.count);
1604
1605
1606
1607
1608 xfs_trans_log_buf(trans, bp, 0, args->geo->blksize - 1);
1609
1610 kmem_free(tmpbuffer);
1611}
1612
1613
1614
1615
1616
1617static int
1618xfs_attr3_leaf_order(
1619 struct xfs_buf *leaf1_bp,
1620 struct xfs_attr3_icleaf_hdr *leaf1hdr,
1621 struct xfs_buf *leaf2_bp,
1622 struct xfs_attr3_icleaf_hdr *leaf2hdr)
1623{
1624 struct xfs_attr_leaf_entry *entries1;
1625 struct xfs_attr_leaf_entry *entries2;
1626
1627 entries1 = xfs_attr3_leaf_entryp(leaf1_bp->b_addr);
1628 entries2 = xfs_attr3_leaf_entryp(leaf2_bp->b_addr);
1629 if (leaf1hdr->count > 0 && leaf2hdr->count > 0 &&
1630 ((be32_to_cpu(entries2[0].hashval) <
1631 be32_to_cpu(entries1[0].hashval)) ||
1632 (be32_to_cpu(entries2[leaf2hdr->count - 1].hashval) <
1633 be32_to_cpu(entries1[leaf1hdr->count - 1].hashval)))) {
1634 return 1;
1635 }
1636 return 0;
1637}
1638
1639int
1640xfs_attr_leaf_order(
1641 struct xfs_buf *leaf1_bp,
1642 struct xfs_buf *leaf2_bp)
1643{
1644 struct xfs_attr3_icleaf_hdr ichdr1;
1645 struct xfs_attr3_icleaf_hdr ichdr2;
1646 struct xfs_mount *mp = leaf1_bp->b_mount;
1647
1648 xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &ichdr1, leaf1_bp->b_addr);
1649 xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &ichdr2, leaf2_bp->b_addr);
1650 return xfs_attr3_leaf_order(leaf1_bp, &ichdr1, leaf2_bp, &ichdr2);
1651}
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665STATIC void
1666xfs_attr3_leaf_rebalance(
1667 struct xfs_da_state *state,
1668 struct xfs_da_state_blk *blk1,
1669 struct xfs_da_state_blk *blk2)
1670{
1671 struct xfs_da_args *args;
1672 struct xfs_attr_leafblock *leaf1;
1673 struct xfs_attr_leafblock *leaf2;
1674 struct xfs_attr3_icleaf_hdr ichdr1;
1675 struct xfs_attr3_icleaf_hdr ichdr2;
1676 struct xfs_attr_leaf_entry *entries1;
1677 struct xfs_attr_leaf_entry *entries2;
1678 int count;
1679 int totallen;
1680 int max;
1681 int space;
1682 int swap;
1683
1684
1685
1686
1687 ASSERT(blk1->magic == XFS_ATTR_LEAF_MAGIC);
1688 ASSERT(blk2->magic == XFS_ATTR_LEAF_MAGIC);
1689 leaf1 = blk1->bp->b_addr;
1690 leaf2 = blk2->bp->b_addr;
1691 xfs_attr3_leaf_hdr_from_disk(state->args->geo, &ichdr1, leaf1);
1692 xfs_attr3_leaf_hdr_from_disk(state->args->geo, &ichdr2, leaf2);
1693 ASSERT(ichdr2.count == 0);
1694 args = state->args;
1695
1696 trace_xfs_attr_leaf_rebalance(args);
1697
1698
1699
1700
1701
1702
1703
1704 swap = 0;
1705 if (xfs_attr3_leaf_order(blk1->bp, &ichdr1, blk2->bp, &ichdr2)) {
1706 swap(blk1, blk2);
1707
1708
1709 swap(ichdr1, ichdr2);
1710
1711 leaf1 = blk1->bp->b_addr;
1712 leaf2 = blk2->bp->b_addr;
1713 swap = 1;
1714 }
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724 state->inleaf = xfs_attr3_leaf_figure_balance(state, blk1, &ichdr1,
1725 blk2, &ichdr2,
1726 &count, &totallen);
1727 if (swap)
1728 state->inleaf = !state->inleaf;
1729
1730
1731
1732
1733 if (count < ichdr1.count) {
1734
1735
1736
1737
1738 count = ichdr1.count - count;
1739 space = ichdr1.usedbytes - totallen;
1740 space += count * sizeof(xfs_attr_leaf_entry_t);
1741
1742
1743
1744
1745 max = ichdr2.firstused - xfs_attr3_leaf_hdr_size(leaf1);
1746 max -= ichdr2.count * sizeof(xfs_attr_leaf_entry_t);
1747 if (space > max)
1748 xfs_attr3_leaf_compact(args, &ichdr2, blk2->bp);
1749
1750
1751
1752
1753 xfs_attr3_leaf_moveents(args, leaf1, &ichdr1,
1754 ichdr1.count - count, leaf2, &ichdr2, 0, count);
1755
1756 } else if (count > ichdr1.count) {
1757
1758
1759
1760
1761 ASSERT(0);
1762
1763
1764
1765
1766
1767 count -= ichdr1.count;
1768 space = totallen - ichdr1.usedbytes;
1769 space += count * sizeof(xfs_attr_leaf_entry_t);
1770
1771
1772
1773
1774 max = ichdr1.firstused - xfs_attr3_leaf_hdr_size(leaf1);
1775 max -= ichdr1.count * sizeof(xfs_attr_leaf_entry_t);
1776 if (space > max)
1777 xfs_attr3_leaf_compact(args, &ichdr1, blk1->bp);
1778
1779
1780
1781
1782 xfs_attr3_leaf_moveents(args, leaf2, &ichdr2, 0, leaf1, &ichdr1,
1783 ichdr1.count, count);
1784 }
1785
1786 xfs_attr3_leaf_hdr_to_disk(state->args->geo, leaf1, &ichdr1);
1787 xfs_attr3_leaf_hdr_to_disk(state->args->geo, leaf2, &ichdr2);
1788 xfs_trans_log_buf(args->trans, blk1->bp, 0, args->geo->blksize - 1);
1789 xfs_trans_log_buf(args->trans, blk2->bp, 0, args->geo->blksize - 1);
1790
1791
1792
1793
1794 entries1 = xfs_attr3_leaf_entryp(leaf1);
1795 entries2 = xfs_attr3_leaf_entryp(leaf2);
1796 blk1->hashval = be32_to_cpu(entries1[ichdr1.count - 1].hashval);
1797 blk2->hashval = be32_to_cpu(entries2[ichdr2.count - 1].hashval);
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811 if (blk1->index > ichdr1.count) {
1812 ASSERT(state->inleaf == 0);
1813 blk2->index = blk1->index - ichdr1.count;
1814 args->index = args->index2 = blk2->index;
1815 args->blkno = args->blkno2 = blk2->blkno;
1816 } else if (blk1->index == ichdr1.count) {
1817 if (state->inleaf) {
1818 args->index = blk1->index;
1819 args->blkno = blk1->blkno;
1820 args->index2 = 0;
1821 args->blkno2 = blk2->blkno;
1822 } else {
1823
1824
1825
1826
1827
1828 blk2->index = blk1->index - ichdr1.count;
1829 args->index = blk2->index;
1830 args->blkno = blk2->blkno;
1831 if (!state->extravalid) {
1832
1833
1834
1835
1836
1837 args->index2 = blk2->index;
1838 args->blkno2 = blk2->blkno;
1839 }
1840 }
1841 } else {
1842 ASSERT(state->inleaf == 1);
1843 args->index = args->index2 = blk1->index;
1844 args->blkno = args->blkno2 = blk1->blkno;
1845 }
1846}
1847
1848
1849
1850
1851
1852
1853
1854
1855STATIC int
1856xfs_attr3_leaf_figure_balance(
1857 struct xfs_da_state *state,
1858 struct xfs_da_state_blk *blk1,
1859 struct xfs_attr3_icleaf_hdr *ichdr1,
1860 struct xfs_da_state_blk *blk2,
1861 struct xfs_attr3_icleaf_hdr *ichdr2,
1862 int *countarg,
1863 int *usedbytesarg)
1864{
1865 struct xfs_attr_leafblock *leaf1 = blk1->bp->b_addr;
1866 struct xfs_attr_leafblock *leaf2 = blk2->bp->b_addr;
1867 struct xfs_attr_leaf_entry *entry;
1868 int count;
1869 int max;
1870 int index;
1871 int totallen = 0;
1872 int half;
1873 int lastdelta;
1874 int foundit = 0;
1875 int tmp;
1876
1877
1878
1879
1880
1881 max = ichdr1->count + ichdr2->count;
1882 half = (max + 1) * sizeof(*entry);
1883 half += ichdr1->usedbytes + ichdr2->usedbytes +
1884 xfs_attr_leaf_newentsize(state->args, NULL);
1885 half /= 2;
1886 lastdelta = state->args->geo->blksize;
1887 entry = xfs_attr3_leaf_entryp(leaf1);
1888 for (count = index = 0; count < max; entry++, index++, count++) {
1889
1890#define XFS_ATTR_ABS(A) (((A) < 0) ? -(A) : (A))
1891
1892
1893
1894 if (count == blk1->index) {
1895 tmp = totallen + sizeof(*entry) +
1896 xfs_attr_leaf_newentsize(state->args, NULL);
1897 if (XFS_ATTR_ABS(half - tmp) > lastdelta)
1898 break;
1899 lastdelta = XFS_ATTR_ABS(half - tmp);
1900 totallen = tmp;
1901 foundit = 1;
1902 }
1903
1904
1905
1906
1907 if (count == ichdr1->count) {
1908 leaf1 = leaf2;
1909 entry = xfs_attr3_leaf_entryp(leaf1);
1910 index = 0;
1911 }
1912
1913
1914
1915
1916 tmp = totallen + sizeof(*entry) + xfs_attr_leaf_entsize(leaf1,
1917 index);
1918 if (XFS_ATTR_ABS(half - tmp) > lastdelta)
1919 break;
1920 lastdelta = XFS_ATTR_ABS(half - tmp);
1921 totallen = tmp;
1922#undef XFS_ATTR_ABS
1923 }
1924
1925
1926
1927
1928
1929 totallen -= count * sizeof(*entry);
1930 if (foundit) {
1931 totallen -= sizeof(*entry) +
1932 xfs_attr_leaf_newentsize(state->args, NULL);
1933 }
1934
1935 *countarg = count;
1936 *usedbytesarg = totallen;
1937 return foundit;
1938}
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955int
1956xfs_attr3_leaf_toosmall(
1957 struct xfs_da_state *state,
1958 int *action)
1959{
1960 struct xfs_attr_leafblock *leaf;
1961 struct xfs_da_state_blk *blk;
1962 struct xfs_attr3_icleaf_hdr ichdr;
1963 struct xfs_buf *bp;
1964 xfs_dablk_t blkno;
1965 int bytes;
1966 int forward;
1967 int error;
1968 int retval;
1969 int i;
1970
1971 trace_xfs_attr_leaf_toosmall(state->args);
1972
1973
1974
1975
1976
1977
1978 blk = &state->path.blk[ state->path.active-1 ];
1979 leaf = blk->bp->b_addr;
1980 xfs_attr3_leaf_hdr_from_disk(state->args->geo, &ichdr, leaf);
1981 bytes = xfs_attr3_leaf_hdr_size(leaf) +
1982 ichdr.count * sizeof(xfs_attr_leaf_entry_t) +
1983 ichdr.usedbytes;
1984 if (bytes > (state->args->geo->blksize >> 1)) {
1985 *action = 0;
1986 return 0;
1987 }
1988
1989
1990
1991
1992
1993
1994
1995 if (ichdr.count == 0) {
1996
1997
1998
1999
2000 forward = (ichdr.forw != 0);
2001 memcpy(&state->altpath, &state->path, sizeof(state->path));
2002 error = xfs_da3_path_shift(state, &state->altpath, forward,
2003 0, &retval);
2004 if (error)
2005 return error;
2006 if (retval) {
2007 *action = 0;
2008 } else {
2009 *action = 2;
2010 }
2011 return 0;
2012 }
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022 forward = ichdr.forw < ichdr.back;
2023 for (i = 0; i < 2; forward = !forward, i++) {
2024 struct xfs_attr3_icleaf_hdr ichdr2;
2025 if (forward)
2026 blkno = ichdr.forw;
2027 else
2028 blkno = ichdr.back;
2029 if (blkno == 0)
2030 continue;
2031 error = xfs_attr3_leaf_read(state->args->trans, state->args->dp,
2032 blkno, &bp);
2033 if (error)
2034 return error;
2035
2036 xfs_attr3_leaf_hdr_from_disk(state->args->geo, &ichdr2, bp->b_addr);
2037
2038 bytes = state->args->geo->blksize -
2039 (state->args->geo->blksize >> 2) -
2040 ichdr.usedbytes - ichdr2.usedbytes -
2041 ((ichdr.count + ichdr2.count) *
2042 sizeof(xfs_attr_leaf_entry_t)) -
2043 xfs_attr3_leaf_hdr_size(leaf);
2044
2045 xfs_trans_brelse(state->args->trans, bp);
2046 if (bytes >= 0)
2047 break;
2048 }
2049 if (i >= 2) {
2050 *action = 0;
2051 return 0;
2052 }
2053
2054
2055
2056
2057
2058 memcpy(&state->altpath, &state->path, sizeof(state->path));
2059 if (blkno < blk->blkno) {
2060 error = xfs_da3_path_shift(state, &state->altpath, forward,
2061 0, &retval);
2062 } else {
2063 error = xfs_da3_path_shift(state, &state->path, forward,
2064 0, &retval);
2065 }
2066 if (error)
2067 return error;
2068 if (retval) {
2069 *action = 0;
2070 } else {
2071 *action = 1;
2072 }
2073 return 0;
2074}
2075
2076
2077
2078
2079
2080
2081
2082int
2083xfs_attr3_leaf_remove(
2084 struct xfs_buf *bp,
2085 struct xfs_da_args *args)
2086{
2087 struct xfs_attr_leafblock *leaf;
2088 struct xfs_attr3_icleaf_hdr ichdr;
2089 struct xfs_attr_leaf_entry *entry;
2090 int before;
2091 int after;
2092 int smallest;
2093 int entsize;
2094 int tablesize;
2095 int tmp;
2096 int i;
2097
2098 trace_xfs_attr_leaf_remove(args);
2099
2100 leaf = bp->b_addr;
2101 xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);
2102
2103 ASSERT(ichdr.count > 0 && ichdr.count < args->geo->blksize / 8);
2104 ASSERT(args->index >= 0 && args->index < ichdr.count);
2105 ASSERT(ichdr.firstused >= ichdr.count * sizeof(*entry) +
2106 xfs_attr3_leaf_hdr_size(leaf));
2107
2108 entry = &xfs_attr3_leaf_entryp(leaf)[args->index];
2109
2110 ASSERT(be16_to_cpu(entry->nameidx) >= ichdr.firstused);
2111 ASSERT(be16_to_cpu(entry->nameidx) < args->geo->blksize);
2112
2113
2114
2115
2116
2117
2118
2119 tablesize = ichdr.count * sizeof(xfs_attr_leaf_entry_t)
2120 + xfs_attr3_leaf_hdr_size(leaf);
2121 tmp = ichdr.freemap[0].size;
2122 before = after = -1;
2123 smallest = XFS_ATTR_LEAF_MAPSIZE - 1;
2124 entsize = xfs_attr_leaf_entsize(leaf, args->index);
2125 for (i = 0; i < XFS_ATTR_LEAF_MAPSIZE; i++) {
2126 ASSERT(ichdr.freemap[i].base < args->geo->blksize);
2127 ASSERT(ichdr.freemap[i].size < args->geo->blksize);
2128 if (ichdr.freemap[i].base == tablesize) {
2129 ichdr.freemap[i].base -= sizeof(xfs_attr_leaf_entry_t);
2130 ichdr.freemap[i].size += sizeof(xfs_attr_leaf_entry_t);
2131 }
2132
2133 if (ichdr.freemap[i].base + ichdr.freemap[i].size ==
2134 be16_to_cpu(entry->nameidx)) {
2135 before = i;
2136 } else if (ichdr.freemap[i].base ==
2137 (be16_to_cpu(entry->nameidx) + entsize)) {
2138 after = i;
2139 } else if (ichdr.freemap[i].size < tmp) {
2140 tmp = ichdr.freemap[i].size;
2141 smallest = i;
2142 }
2143 }
2144
2145
2146
2147
2148
2149 if ((before >= 0) || (after >= 0)) {
2150 if ((before >= 0) && (after >= 0)) {
2151 ichdr.freemap[before].size += entsize;
2152 ichdr.freemap[before].size += ichdr.freemap[after].size;
2153 ichdr.freemap[after].base = 0;
2154 ichdr.freemap[after].size = 0;
2155 } else if (before >= 0) {
2156 ichdr.freemap[before].size += entsize;
2157 } else {
2158 ichdr.freemap[after].base = be16_to_cpu(entry->nameidx);
2159 ichdr.freemap[after].size += entsize;
2160 }
2161 } else {
2162
2163
2164
2165 if (ichdr.freemap[smallest].size < entsize) {
2166 ichdr.freemap[smallest].base = be16_to_cpu(entry->nameidx);
2167 ichdr.freemap[smallest].size = entsize;
2168 }
2169 }
2170
2171
2172
2173
2174 if (be16_to_cpu(entry->nameidx) == ichdr.firstused)
2175 smallest = 1;
2176 else
2177 smallest = 0;
2178
2179
2180
2181
2182 memset(xfs_attr3_leaf_name(leaf, args->index), 0, entsize);
2183 ichdr.usedbytes -= entsize;
2184 xfs_trans_log_buf(args->trans, bp,
2185 XFS_DA_LOGRANGE(leaf, xfs_attr3_leaf_name(leaf, args->index),
2186 entsize));
2187
2188 tmp = (ichdr.count - args->index) * sizeof(xfs_attr_leaf_entry_t);
2189 memmove(entry, entry + 1, tmp);
2190 ichdr.count--;
2191 xfs_trans_log_buf(args->trans, bp,
2192 XFS_DA_LOGRANGE(leaf, entry, tmp + sizeof(xfs_attr_leaf_entry_t)));
2193
2194 entry = &xfs_attr3_leaf_entryp(leaf)[ichdr.count];
2195 memset(entry, 0, sizeof(xfs_attr_leaf_entry_t));
2196
2197
2198
2199
2200
2201
2202
2203 if (smallest) {
2204 tmp = args->geo->blksize;
2205 entry = xfs_attr3_leaf_entryp(leaf);
2206 for (i = ichdr.count - 1; i >= 0; entry++, i--) {
2207 ASSERT(be16_to_cpu(entry->nameidx) >= ichdr.firstused);
2208 ASSERT(be16_to_cpu(entry->nameidx) < args->geo->blksize);
2209
2210 if (be16_to_cpu(entry->nameidx) < tmp)
2211 tmp = be16_to_cpu(entry->nameidx);
2212 }
2213 ichdr.firstused = tmp;
2214 ASSERT(ichdr.firstused != 0);
2215 } else {
2216 ichdr.holes = 1;
2217 }
2218 xfs_attr3_leaf_hdr_to_disk(args->geo, leaf, &ichdr);
2219 xfs_trans_log_buf(args->trans, bp,
2220 XFS_DA_LOGRANGE(leaf, &leaf->hdr,
2221 xfs_attr3_leaf_hdr_size(leaf)));
2222
2223
2224
2225
2226
2227 tmp = ichdr.usedbytes + xfs_attr3_leaf_hdr_size(leaf) +
2228 ichdr.count * sizeof(xfs_attr_leaf_entry_t);
2229
2230 return tmp < args->geo->magicpct;
2231}
2232
2233
2234
2235
2236void
2237xfs_attr3_leaf_unbalance(
2238 struct xfs_da_state *state,
2239 struct xfs_da_state_blk *drop_blk,
2240 struct xfs_da_state_blk *save_blk)
2241{
2242 struct xfs_attr_leafblock *drop_leaf = drop_blk->bp->b_addr;
2243 struct xfs_attr_leafblock *save_leaf = save_blk->bp->b_addr;
2244 struct xfs_attr3_icleaf_hdr drophdr;
2245 struct xfs_attr3_icleaf_hdr savehdr;
2246 struct xfs_attr_leaf_entry *entry;
2247
2248 trace_xfs_attr_leaf_unbalance(state->args);
2249
2250 drop_leaf = drop_blk->bp->b_addr;
2251 save_leaf = save_blk->bp->b_addr;
2252 xfs_attr3_leaf_hdr_from_disk(state->args->geo, &drophdr, drop_leaf);
2253 xfs_attr3_leaf_hdr_from_disk(state->args->geo, &savehdr, save_leaf);
2254 entry = xfs_attr3_leaf_entryp(drop_leaf);
2255
2256
2257
2258
2259 drop_blk->hashval = be32_to_cpu(entry[drophdr.count - 1].hashval);
2260
2261
2262
2263
2264
2265
2266 if (savehdr.holes == 0) {
2267
2268
2269
2270
2271 if (xfs_attr3_leaf_order(save_blk->bp, &savehdr,
2272 drop_blk->bp, &drophdr)) {
2273 xfs_attr3_leaf_moveents(state->args,
2274 drop_leaf, &drophdr, 0,
2275 save_leaf, &savehdr, 0,
2276 drophdr.count);
2277 } else {
2278 xfs_attr3_leaf_moveents(state->args,
2279 drop_leaf, &drophdr, 0,
2280 save_leaf, &savehdr,
2281 savehdr.count, drophdr.count);
2282 }
2283 } else {
2284
2285
2286
2287
2288 struct xfs_attr_leafblock *tmp_leaf;
2289 struct xfs_attr3_icleaf_hdr tmphdr;
2290
2291 tmp_leaf = kmem_zalloc(state->args->geo->blksize, 0);
2292
2293
2294
2295
2296
2297
2298 memcpy(tmp_leaf, save_leaf, xfs_attr3_leaf_hdr_size(save_leaf));
2299
2300 memset(&tmphdr, 0, sizeof(tmphdr));
2301 tmphdr.magic = savehdr.magic;
2302 tmphdr.forw = savehdr.forw;
2303 tmphdr.back = savehdr.back;
2304 tmphdr.firstused = state->args->geo->blksize;
2305
2306
2307 xfs_attr3_leaf_hdr_to_disk(state->args->geo, tmp_leaf, &tmphdr);
2308
2309 if (xfs_attr3_leaf_order(save_blk->bp, &savehdr,
2310 drop_blk->bp, &drophdr)) {
2311 xfs_attr3_leaf_moveents(state->args,
2312 drop_leaf, &drophdr, 0,
2313 tmp_leaf, &tmphdr, 0,
2314 drophdr.count);
2315 xfs_attr3_leaf_moveents(state->args,
2316 save_leaf, &savehdr, 0,
2317 tmp_leaf, &tmphdr, tmphdr.count,
2318 savehdr.count);
2319 } else {
2320 xfs_attr3_leaf_moveents(state->args,
2321 save_leaf, &savehdr, 0,
2322 tmp_leaf, &tmphdr, 0,
2323 savehdr.count);
2324 xfs_attr3_leaf_moveents(state->args,
2325 drop_leaf, &drophdr, 0,
2326 tmp_leaf, &tmphdr, tmphdr.count,
2327 drophdr.count);
2328 }
2329 memcpy(save_leaf, tmp_leaf, state->args->geo->blksize);
2330 savehdr = tmphdr;
2331 kmem_free(tmp_leaf);
2332 }
2333
2334 xfs_attr3_leaf_hdr_to_disk(state->args->geo, save_leaf, &savehdr);
2335 xfs_trans_log_buf(state->args->trans, save_blk->bp, 0,
2336 state->args->geo->blksize - 1);
2337
2338
2339
2340
2341 entry = xfs_attr3_leaf_entryp(save_leaf);
2342 save_blk->hashval = be32_to_cpu(entry[savehdr.count - 1].hashval);
2343}
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362int
2363xfs_attr3_leaf_lookup_int(
2364 struct xfs_buf *bp,
2365 struct xfs_da_args *args)
2366{
2367 struct xfs_attr_leafblock *leaf;
2368 struct xfs_attr3_icleaf_hdr ichdr;
2369 struct xfs_attr_leaf_entry *entry;
2370 struct xfs_attr_leaf_entry *entries;
2371 struct xfs_attr_leaf_name_local *name_loc;
2372 struct xfs_attr_leaf_name_remote *name_rmt;
2373 xfs_dahash_t hashval;
2374 int probe;
2375 int span;
2376
2377 trace_xfs_attr_leaf_lookup(args);
2378
2379 leaf = bp->b_addr;
2380 xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);
2381 entries = xfs_attr3_leaf_entryp(leaf);
2382 if (ichdr.count >= args->geo->blksize / 8) {
2383 xfs_buf_mark_corrupt(bp);
2384 return -EFSCORRUPTED;
2385 }
2386
2387
2388
2389
2390 hashval = args->hashval;
2391 probe = span = ichdr.count / 2;
2392 for (entry = &entries[probe]; span > 4; entry = &entries[probe]) {
2393 span /= 2;
2394 if (be32_to_cpu(entry->hashval) < hashval)
2395 probe += span;
2396 else if (be32_to_cpu(entry->hashval) > hashval)
2397 probe -= span;
2398 else
2399 break;
2400 }
2401 if (!(probe >= 0 && (!ichdr.count || probe < ichdr.count))) {
2402 xfs_buf_mark_corrupt(bp);
2403 return -EFSCORRUPTED;
2404 }
2405 if (!(span <= 4 || be32_to_cpu(entry->hashval) == hashval)) {
2406 xfs_buf_mark_corrupt(bp);
2407 return -EFSCORRUPTED;
2408 }
2409
2410
2411
2412
2413
2414 while (probe > 0 && be32_to_cpu(entry->hashval) >= hashval) {
2415 entry--;
2416 probe--;
2417 }
2418 while (probe < ichdr.count &&
2419 be32_to_cpu(entry->hashval) < hashval) {
2420 entry++;
2421 probe++;
2422 }
2423 if (probe == ichdr.count || be32_to_cpu(entry->hashval) != hashval) {
2424 args->index = probe;
2425 return -ENOATTR;
2426 }
2427
2428
2429
2430
2431 for (; probe < ichdr.count && (be32_to_cpu(entry->hashval) == hashval);
2432 entry++, probe++) {
2433
2434
2435
2436 if (entry->flags & XFS_ATTR_LOCAL) {
2437 name_loc = xfs_attr3_leaf_name_local(leaf, probe);
2438 if (!xfs_attr_match(args, name_loc->namelen,
2439 name_loc->nameval, entry->flags))
2440 continue;
2441 args->index = probe;
2442 return -EEXIST;
2443 } else {
2444 name_rmt = xfs_attr3_leaf_name_remote(leaf, probe);
2445 if (!xfs_attr_match(args, name_rmt->namelen,
2446 name_rmt->name, entry->flags))
2447 continue;
2448 args->index = probe;
2449 args->rmtvaluelen = be32_to_cpu(name_rmt->valuelen);
2450 args->rmtblkno = be32_to_cpu(name_rmt->valueblk);
2451 args->rmtblkcnt = xfs_attr3_rmt_blocks(
2452 args->dp->i_mount,
2453 args->rmtvaluelen);
2454 return -EEXIST;
2455 }
2456 }
2457 args->index = probe;
2458 return -ENOATTR;
2459}
2460
2461
2462
2463
2464
2465
2466
2467
2468
2469int
2470xfs_attr3_leaf_getvalue(
2471 struct xfs_buf *bp,
2472 struct xfs_da_args *args)
2473{
2474 struct xfs_attr_leafblock *leaf;
2475 struct xfs_attr3_icleaf_hdr ichdr;
2476 struct xfs_attr_leaf_entry *entry;
2477 struct xfs_attr_leaf_name_local *name_loc;
2478 struct xfs_attr_leaf_name_remote *name_rmt;
2479
2480 leaf = bp->b_addr;
2481 xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);
2482 ASSERT(ichdr.count < args->geo->blksize / 8);
2483 ASSERT(args->index < ichdr.count);
2484
2485 entry = &xfs_attr3_leaf_entryp(leaf)[args->index];
2486 if (entry->flags & XFS_ATTR_LOCAL) {
2487 name_loc = xfs_attr3_leaf_name_local(leaf, args->index);
2488 ASSERT(name_loc->namelen == args->namelen);
2489 ASSERT(memcmp(args->name, name_loc->nameval, args->namelen) == 0);
2490 return xfs_attr_copy_value(args,
2491 &name_loc->nameval[args->namelen],
2492 be16_to_cpu(name_loc->valuelen));
2493 }
2494
2495 name_rmt = xfs_attr3_leaf_name_remote(leaf, args->index);
2496 ASSERT(name_rmt->namelen == args->namelen);
2497 ASSERT(memcmp(args->name, name_rmt->name, args->namelen) == 0);
2498 args->rmtvaluelen = be32_to_cpu(name_rmt->valuelen);
2499 args->rmtblkno = be32_to_cpu(name_rmt->valueblk);
2500 args->rmtblkcnt = xfs_attr3_rmt_blocks(args->dp->i_mount,
2501 args->rmtvaluelen);
2502 return xfs_attr_copy_value(args, NULL, args->rmtvaluelen);
2503}
2504
2505
2506
2507
2508
2509
2510
2511
2512
2513
2514STATIC void
2515xfs_attr3_leaf_moveents(
2516 struct xfs_da_args *args,
2517 struct xfs_attr_leafblock *leaf_s,
2518 struct xfs_attr3_icleaf_hdr *ichdr_s,
2519 int start_s,
2520 struct xfs_attr_leafblock *leaf_d,
2521 struct xfs_attr3_icleaf_hdr *ichdr_d,
2522 int start_d,
2523 int count)
2524{
2525 struct xfs_attr_leaf_entry *entry_s;
2526 struct xfs_attr_leaf_entry *entry_d;
2527 int desti;
2528 int tmp;
2529 int i;
2530
2531
2532
2533
2534 if (count == 0)
2535 return;
2536
2537
2538
2539
2540 ASSERT(ichdr_s->magic == XFS_ATTR_LEAF_MAGIC ||
2541 ichdr_s->magic == XFS_ATTR3_LEAF_MAGIC);
2542 ASSERT(ichdr_s->magic == ichdr_d->magic);
2543 ASSERT(ichdr_s->count > 0 && ichdr_s->count < args->geo->blksize / 8);
2544 ASSERT(ichdr_s->firstused >= (ichdr_s->count * sizeof(*entry_s))
2545 + xfs_attr3_leaf_hdr_size(leaf_s));
2546 ASSERT(ichdr_d->count < args->geo->blksize / 8);
2547 ASSERT(ichdr_d->firstused >= (ichdr_d->count * sizeof(*entry_d))
2548 + xfs_attr3_leaf_hdr_size(leaf_d));
2549
2550 ASSERT(start_s < ichdr_s->count);
2551 ASSERT(start_d <= ichdr_d->count);
2552 ASSERT(count <= ichdr_s->count);
2553
2554
2555
2556
2557
2558 if (start_d < ichdr_d->count) {
2559 tmp = ichdr_d->count - start_d;
2560 tmp *= sizeof(xfs_attr_leaf_entry_t);
2561 entry_s = &xfs_attr3_leaf_entryp(leaf_d)[start_d];
2562 entry_d = &xfs_attr3_leaf_entryp(leaf_d)[start_d + count];
2563 memmove(entry_d, entry_s, tmp);
2564 }
2565
2566
2567
2568
2569
2570 entry_s = &xfs_attr3_leaf_entryp(leaf_s)[start_s];
2571 entry_d = &xfs_attr3_leaf_entryp(leaf_d)[start_d];
2572 desti = start_d;
2573 for (i = 0; i < count; entry_s++, entry_d++, desti++, i++) {
2574 ASSERT(be16_to_cpu(entry_s->nameidx) >= ichdr_s->firstused);
2575 tmp = xfs_attr_leaf_entsize(leaf_s, start_s + i);
2576#ifdef GROT
2577
2578
2579
2580
2581
2582 if (entry_s->flags & XFS_ATTR_INCOMPLETE) {
2583 memset(xfs_attr3_leaf_name(leaf_s, start_s + i), 0, tmp);
2584 ichdr_s->usedbytes -= tmp;
2585 ichdr_s->count -= 1;
2586 entry_d--;
2587 desti--;
2588 if ((start_s + i) < offset)
2589 result++;
2590 } else {
2591#endif
2592 ichdr_d->firstused -= tmp;
2593
2594 entry_d->hashval = entry_s->hashval;
2595 entry_d->nameidx = cpu_to_be16(ichdr_d->firstused);
2596 entry_d->flags = entry_s->flags;
2597 ASSERT(be16_to_cpu(entry_d->nameidx) + tmp
2598 <= args->geo->blksize);
2599 memmove(xfs_attr3_leaf_name(leaf_d, desti),
2600 xfs_attr3_leaf_name(leaf_s, start_s + i), tmp);
2601 ASSERT(be16_to_cpu(entry_s->nameidx) + tmp
2602 <= args->geo->blksize);
2603 memset(xfs_attr3_leaf_name(leaf_s, start_s + i), 0, tmp);
2604 ichdr_s->usedbytes -= tmp;
2605 ichdr_d->usedbytes += tmp;
2606 ichdr_s->count -= 1;
2607 ichdr_d->count += 1;
2608 tmp = ichdr_d->count * sizeof(xfs_attr_leaf_entry_t)
2609 + xfs_attr3_leaf_hdr_size(leaf_d);
2610 ASSERT(ichdr_d->firstused >= tmp);
2611#ifdef GROT
2612 }
2613#endif
2614 }
2615
2616
2617
2618
2619 if (start_s == ichdr_s->count) {
2620 tmp = count * sizeof(xfs_attr_leaf_entry_t);
2621 entry_s = &xfs_attr3_leaf_entryp(leaf_s)[start_s];
2622 ASSERT(((char *)entry_s + tmp) <=
2623 ((char *)leaf_s + args->geo->blksize));
2624 memset(entry_s, 0, tmp);
2625 } else {
2626
2627
2628
2629
2630 tmp = (ichdr_s->count - count) * sizeof(xfs_attr_leaf_entry_t);
2631 entry_s = &xfs_attr3_leaf_entryp(leaf_s)[start_s + count];
2632 entry_d = &xfs_attr3_leaf_entryp(leaf_s)[start_s];
2633 memmove(entry_d, entry_s, tmp);
2634
2635 tmp = count * sizeof(xfs_attr_leaf_entry_t);
2636 entry_s = &xfs_attr3_leaf_entryp(leaf_s)[ichdr_s->count];
2637 ASSERT(((char *)entry_s + tmp) <=
2638 ((char *)leaf_s + args->geo->blksize));
2639 memset(entry_s, 0, tmp);
2640 }
2641
2642
2643
2644
2645 ichdr_d->freemap[0].base = xfs_attr3_leaf_hdr_size(leaf_d);
2646 ichdr_d->freemap[0].base += ichdr_d->count * sizeof(xfs_attr_leaf_entry_t);
2647 ichdr_d->freemap[0].size = ichdr_d->firstused - ichdr_d->freemap[0].base;
2648 ichdr_d->freemap[1].base = 0;
2649 ichdr_d->freemap[2].base = 0;
2650 ichdr_d->freemap[1].size = 0;
2651 ichdr_d->freemap[2].size = 0;
2652 ichdr_s->holes = 1;
2653}
2654
2655
2656
2657
2658xfs_dahash_t
2659xfs_attr_leaf_lasthash(
2660 struct xfs_buf *bp,
2661 int *count)
2662{
2663 struct xfs_attr3_icleaf_hdr ichdr;
2664 struct xfs_attr_leaf_entry *entries;
2665 struct xfs_mount *mp = bp->b_mount;
2666
2667 xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &ichdr, bp->b_addr);
2668 entries = xfs_attr3_leaf_entryp(bp->b_addr);
2669 if (count)
2670 *count = ichdr.count;
2671 if (!ichdr.count)
2672 return 0;
2673 return be32_to_cpu(entries[ichdr.count - 1].hashval);
2674}
2675
2676
2677
2678
2679
2680STATIC int
2681xfs_attr_leaf_entsize(xfs_attr_leafblock_t *leaf, int index)
2682{
2683 struct xfs_attr_leaf_entry *entries;
2684 xfs_attr_leaf_name_local_t *name_loc;
2685 xfs_attr_leaf_name_remote_t *name_rmt;
2686 int size;
2687
2688 entries = xfs_attr3_leaf_entryp(leaf);
2689 if (entries[index].flags & XFS_ATTR_LOCAL) {
2690 name_loc = xfs_attr3_leaf_name_local(leaf, index);
2691 size = xfs_attr_leaf_entsize_local(name_loc->namelen,
2692 be16_to_cpu(name_loc->valuelen));
2693 } else {
2694 name_rmt = xfs_attr3_leaf_name_remote(leaf, index);
2695 size = xfs_attr_leaf_entsize_remote(name_rmt->namelen);
2696 }
2697 return size;
2698}
2699
2700
2701
2702
2703
2704
2705
2706int
2707xfs_attr_leaf_newentsize(
2708 struct xfs_da_args *args,
2709 int *local)
2710{
2711 int size;
2712
2713 size = xfs_attr_leaf_entsize_local(args->namelen, args->valuelen);
2714 if (size < xfs_attr_leaf_entsize_local_max(args->geo->blksize)) {
2715 if (local)
2716 *local = 1;
2717 return size;
2718 }
2719 if (local)
2720 *local = 0;
2721 return xfs_attr_leaf_entsize_remote(args->namelen);
2722}
2723
2724
2725
2726
2727
2728
2729
2730
2731
2732int
2733xfs_attr3_leaf_clearflag(
2734 struct xfs_da_args *args)
2735{
2736 struct xfs_attr_leafblock *leaf;
2737 struct xfs_attr_leaf_entry *entry;
2738 struct xfs_attr_leaf_name_remote *name_rmt;
2739 struct xfs_buf *bp;
2740 int error;
2741#ifdef DEBUG
2742 struct xfs_attr3_icleaf_hdr ichdr;
2743 xfs_attr_leaf_name_local_t *name_loc;
2744 int namelen;
2745 char *name;
2746#endif
2747
2748 trace_xfs_attr_leaf_clearflag(args);
2749
2750
2751
2752 error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, &bp);
2753 if (error)
2754 return error;
2755
2756 leaf = bp->b_addr;
2757 entry = &xfs_attr3_leaf_entryp(leaf)[args->index];
2758 ASSERT(entry->flags & XFS_ATTR_INCOMPLETE);
2759
2760#ifdef DEBUG
2761 xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);
2762 ASSERT(args->index < ichdr.count);
2763 ASSERT(args->index >= 0);
2764
2765 if (entry->flags & XFS_ATTR_LOCAL) {
2766 name_loc = xfs_attr3_leaf_name_local(leaf, args->index);
2767 namelen = name_loc->namelen;
2768 name = (char *)name_loc->nameval;
2769 } else {
2770 name_rmt = xfs_attr3_leaf_name_remote(leaf, args->index);
2771 namelen = name_rmt->namelen;
2772 name = (char *)name_rmt->name;
2773 }
2774 ASSERT(be32_to_cpu(entry->hashval) == args->hashval);
2775 ASSERT(namelen == args->namelen);
2776 ASSERT(memcmp(name, args->name, namelen) == 0);
2777#endif
2778
2779 entry->flags &= ~XFS_ATTR_INCOMPLETE;
2780 xfs_trans_log_buf(args->trans, bp,
2781 XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));
2782
2783 if (args->rmtblkno) {
2784 ASSERT((entry->flags & XFS_ATTR_LOCAL) == 0);
2785 name_rmt = xfs_attr3_leaf_name_remote(leaf, args->index);
2786 name_rmt->valueblk = cpu_to_be32(args->rmtblkno);
2787 name_rmt->valuelen = cpu_to_be32(args->rmtvaluelen);
2788 xfs_trans_log_buf(args->trans, bp,
2789 XFS_DA_LOGRANGE(leaf, name_rmt, sizeof(*name_rmt)));
2790 }
2791
2792 return 0;
2793}
2794
2795
2796
2797
2798int
2799xfs_attr3_leaf_setflag(
2800 struct xfs_da_args *args)
2801{
2802 struct xfs_attr_leafblock *leaf;
2803 struct xfs_attr_leaf_entry *entry;
2804 struct xfs_attr_leaf_name_remote *name_rmt;
2805 struct xfs_buf *bp;
2806 int error;
2807#ifdef DEBUG
2808 struct xfs_attr3_icleaf_hdr ichdr;
2809#endif
2810
2811 trace_xfs_attr_leaf_setflag(args);
2812
2813
2814
2815
2816 error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, &bp);
2817 if (error)
2818 return error;
2819
2820 leaf = bp->b_addr;
2821#ifdef DEBUG
2822 xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);
2823 ASSERT(args->index < ichdr.count);
2824 ASSERT(args->index >= 0);
2825#endif
2826 entry = &xfs_attr3_leaf_entryp(leaf)[args->index];
2827
2828 ASSERT((entry->flags & XFS_ATTR_INCOMPLETE) == 0);
2829 entry->flags |= XFS_ATTR_INCOMPLETE;
2830 xfs_trans_log_buf(args->trans, bp,
2831 XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));
2832 if ((entry->flags & XFS_ATTR_LOCAL) == 0) {
2833 name_rmt = xfs_attr3_leaf_name_remote(leaf, args->index);
2834 name_rmt->valueblk = 0;
2835 name_rmt->valuelen = 0;
2836 xfs_trans_log_buf(args->trans, bp,
2837 XFS_DA_LOGRANGE(leaf, name_rmt, sizeof(*name_rmt)));
2838 }
2839
2840 return 0;
2841}
2842
2843
2844
2845
2846
2847
2848
2849
2850int
2851xfs_attr3_leaf_flipflags(
2852 struct xfs_da_args *args)
2853{
2854 struct xfs_attr_leafblock *leaf1;
2855 struct xfs_attr_leafblock *leaf2;
2856 struct xfs_attr_leaf_entry *entry1;
2857 struct xfs_attr_leaf_entry *entry2;
2858 struct xfs_attr_leaf_name_remote *name_rmt;
2859 struct xfs_buf *bp1;
2860 struct xfs_buf *bp2;
2861 int error;
2862#ifdef DEBUG
2863 struct xfs_attr3_icleaf_hdr ichdr1;
2864 struct xfs_attr3_icleaf_hdr ichdr2;
2865 xfs_attr_leaf_name_local_t *name_loc;
2866 int namelen1, namelen2;
2867 char *name1, *name2;
2868#endif
2869
2870 trace_xfs_attr_leaf_flipflags(args);
2871
2872
2873
2874
2875 error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, &bp1);
2876 if (error)
2877 return error;
2878
2879
2880
2881
2882 if (args->blkno2 != args->blkno) {
2883 error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno2,
2884 &bp2);
2885 if (error)
2886 return error;
2887 } else {
2888 bp2 = bp1;
2889 }
2890
2891 leaf1 = bp1->b_addr;
2892 entry1 = &xfs_attr3_leaf_entryp(leaf1)[args->index];
2893
2894 leaf2 = bp2->b_addr;
2895 entry2 = &xfs_attr3_leaf_entryp(leaf2)[args->index2];
2896
2897#ifdef DEBUG
2898 xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr1, leaf1);
2899 ASSERT(args->index < ichdr1.count);
2900 ASSERT(args->index >= 0);
2901
2902 xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr2, leaf2);
2903 ASSERT(args->index2 < ichdr2.count);
2904 ASSERT(args->index2 >= 0);
2905
2906 if (entry1->flags & XFS_ATTR_LOCAL) {
2907 name_loc = xfs_attr3_leaf_name_local(leaf1, args->index);
2908 namelen1 = name_loc->namelen;
2909 name1 = (char *)name_loc->nameval;
2910 } else {
2911 name_rmt = xfs_attr3_leaf_name_remote(leaf1, args->index);
2912 namelen1 = name_rmt->namelen;
2913 name1 = (char *)name_rmt->name;
2914 }
2915 if (entry2->flags & XFS_ATTR_LOCAL) {
2916 name_loc = xfs_attr3_leaf_name_local(leaf2, args->index2);
2917 namelen2 = name_loc->namelen;
2918 name2 = (char *)name_loc->nameval;
2919 } else {
2920 name_rmt = xfs_attr3_leaf_name_remote(leaf2, args->index2);
2921 namelen2 = name_rmt->namelen;
2922 name2 = (char *)name_rmt->name;
2923 }
2924 ASSERT(be32_to_cpu(entry1->hashval) == be32_to_cpu(entry2->hashval));
2925 ASSERT(namelen1 == namelen2);
2926 ASSERT(memcmp(name1, name2, namelen1) == 0);
2927#endif
2928
2929 ASSERT(entry1->flags & XFS_ATTR_INCOMPLETE);
2930 ASSERT((entry2->flags & XFS_ATTR_INCOMPLETE) == 0);
2931
2932 entry1->flags &= ~XFS_ATTR_INCOMPLETE;
2933 xfs_trans_log_buf(args->trans, bp1,
2934 XFS_DA_LOGRANGE(leaf1, entry1, sizeof(*entry1)));
2935 if (args->rmtblkno) {
2936 ASSERT((entry1->flags & XFS_ATTR_LOCAL) == 0);
2937 name_rmt = xfs_attr3_leaf_name_remote(leaf1, args->index);
2938 name_rmt->valueblk = cpu_to_be32(args->rmtblkno);
2939 name_rmt->valuelen = cpu_to_be32(args->rmtvaluelen);
2940 xfs_trans_log_buf(args->trans, bp1,
2941 XFS_DA_LOGRANGE(leaf1, name_rmt, sizeof(*name_rmt)));
2942 }
2943
2944 entry2->flags |= XFS_ATTR_INCOMPLETE;
2945 xfs_trans_log_buf(args->trans, bp2,
2946 XFS_DA_LOGRANGE(leaf2, entry2, sizeof(*entry2)));
2947 if ((entry2->flags & XFS_ATTR_LOCAL) == 0) {
2948 name_rmt = xfs_attr3_leaf_name_remote(leaf2, args->index2);
2949 name_rmt->valueblk = 0;
2950 name_rmt->valuelen = 0;
2951 xfs_trans_log_buf(args->trans, bp2,
2952 XFS_DA_LOGRANGE(leaf2, name_rmt, sizeof(*name_rmt)));
2953 }
2954
2955 return 0;
2956}
2957