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