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