1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
4 * Copyright (c) 2013 Red Hat, Inc.
7 #include "libxfs_priv.h"
9 #include "xfs_shared.h"
10 #include "xfs_format.h"
11 #include "xfs_log_format.h"
12 #include "xfs_trans_resv.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"
21 #include "xfs_attr_sf.h"
23 #include "xfs_attr_remote.h"
24 #include "xfs_attr_leaf.h"
25 #include "xfs_trace.h"
28 #include "xfs_errortag.h"
34 * Routines to implement leaf blocks of attributes as Btrees of hashed names.
37 /*========================================================================
38 * Function prototypes for the kernel.
39 *========================================================================*/
42 * Routines used for growing the Btree.
44 STATIC
int xfs_attr3_leaf_create(struct xfs_da_args
*args
,
45 xfs_dablk_t which_block
, struct xfs_buf
**bpp
);
46 STATIC
int xfs_attr3_leaf_add_work(struct xfs_buf
*leaf_buffer
,
47 struct xfs_attr3_icleaf_hdr
*ichdr
,
48 struct xfs_da_args
*args
, int freemap_index
);
49 STATIC
void xfs_attr3_leaf_compact(struct xfs_da_args
*args
,
50 struct xfs_attr3_icleaf_hdr
*ichdr
,
51 struct xfs_buf
*leaf_buffer
);
52 STATIC
void xfs_attr3_leaf_rebalance(xfs_da_state_t
*state
,
53 xfs_da_state_blk_t
*blk1
,
54 xfs_da_state_blk_t
*blk2
);
55 STATIC
int xfs_attr3_leaf_figure_balance(xfs_da_state_t
*state
,
56 xfs_da_state_blk_t
*leaf_blk_1
,
57 struct xfs_attr3_icleaf_hdr
*ichdr1
,
58 xfs_da_state_blk_t
*leaf_blk_2
,
59 struct xfs_attr3_icleaf_hdr
*ichdr2
,
60 int *number_entries_in_blk1
,
61 int *number_usedbytes_in_blk1
);
66 STATIC
void xfs_attr3_leaf_moveents(struct xfs_da_args
*args
,
67 struct xfs_attr_leafblock
*src_leaf
,
68 struct xfs_attr3_icleaf_hdr
*src_ichdr
, int src_start
,
69 struct xfs_attr_leafblock
*dst_leaf
,
70 struct xfs_attr3_icleaf_hdr
*dst_ichdr
, int dst_start
,
72 STATIC
int xfs_attr_leaf_entsize(xfs_attr_leafblock_t
*leaf
, int index
);
75 * attr3 block 'firstused' conversion helpers.
77 * firstused refers to the offset of the first used byte of the nameval region
78 * of an attr leaf block. The region starts at the tail of the block and expands
79 * backwards towards the middle. As such, firstused is initialized to the block
80 * size for an empty leaf block and is reduced from there.
82 * The attr3 block size is pegged to the fsb size and the maximum fsb is 64k.
83 * The in-core firstused field is 32-bit and thus supports the maximum fsb size.
84 * The on-disk field is only 16-bit, however, and overflows at 64k. Since this
85 * only occurs at exactly 64k, we use zero as a magic on-disk value to represent
86 * the attr block size. The following helpers manage the conversion between the
87 * in-core and on-disk formats.
91 xfs_attr3_leaf_firstused_from_disk(
92 struct xfs_da_geometry
*geo
,
93 struct xfs_attr3_icleaf_hdr
*to
,
94 struct xfs_attr_leafblock
*from
)
96 struct xfs_attr3_leaf_hdr
*hdr3
;
98 if (from
->hdr
.info
.magic
== cpu_to_be16(XFS_ATTR3_LEAF_MAGIC
)) {
99 hdr3
= (struct xfs_attr3_leaf_hdr
*) from
;
100 to
->firstused
= be16_to_cpu(hdr3
->firstused
);
102 to
->firstused
= be16_to_cpu(from
->hdr
.firstused
);
106 * Convert from the magic fsb size value to actual blocksize. This
107 * should only occur for empty blocks when the block size overflows
110 if (to
->firstused
== XFS_ATTR3_LEAF_NULLOFF
) {
111 ASSERT(!to
->count
&& !to
->usedbytes
);
112 ASSERT(geo
->blksize
> USHRT_MAX
);
113 to
->firstused
= geo
->blksize
;
118 xfs_attr3_leaf_firstused_to_disk(
119 struct xfs_da_geometry
*geo
,
120 struct xfs_attr_leafblock
*to
,
121 struct xfs_attr3_icleaf_hdr
*from
)
123 struct xfs_attr3_leaf_hdr
*hdr3
;
126 /* magic value should only be seen on disk */
127 ASSERT(from
->firstused
!= XFS_ATTR3_LEAF_NULLOFF
);
130 * Scale down the 32-bit in-core firstused value to the 16-bit on-disk
131 * value. This only overflows at the max supported value of 64k. Use the
132 * magic on-disk value to represent block size in this case.
134 firstused
= from
->firstused
;
135 if (firstused
> USHRT_MAX
) {
136 ASSERT(from
->firstused
== geo
->blksize
);
137 firstused
= XFS_ATTR3_LEAF_NULLOFF
;
140 if (from
->magic
== XFS_ATTR3_LEAF_MAGIC
) {
141 hdr3
= (struct xfs_attr3_leaf_hdr
*) to
;
142 hdr3
->firstused
= cpu_to_be16(firstused
);
144 to
->hdr
.firstused
= cpu_to_be16(firstused
);
149 xfs_attr3_leaf_hdr_from_disk(
150 struct xfs_da_geometry
*geo
,
151 struct xfs_attr3_icleaf_hdr
*to
,
152 struct xfs_attr_leafblock
*from
)
156 ASSERT(from
->hdr
.info
.magic
== cpu_to_be16(XFS_ATTR_LEAF_MAGIC
) ||
157 from
->hdr
.info
.magic
== cpu_to_be16(XFS_ATTR3_LEAF_MAGIC
));
159 if (from
->hdr
.info
.magic
== cpu_to_be16(XFS_ATTR3_LEAF_MAGIC
)) {
160 struct xfs_attr3_leaf_hdr
*hdr3
= (struct xfs_attr3_leaf_hdr
*)from
;
162 to
->forw
= be32_to_cpu(hdr3
->info
.hdr
.forw
);
163 to
->back
= be32_to_cpu(hdr3
->info
.hdr
.back
);
164 to
->magic
= be16_to_cpu(hdr3
->info
.hdr
.magic
);
165 to
->count
= be16_to_cpu(hdr3
->count
);
166 to
->usedbytes
= be16_to_cpu(hdr3
->usedbytes
);
167 xfs_attr3_leaf_firstused_from_disk(geo
, to
, from
);
168 to
->holes
= hdr3
->holes
;
170 for (i
= 0; i
< XFS_ATTR_LEAF_MAPSIZE
; i
++) {
171 to
->freemap
[i
].base
= be16_to_cpu(hdr3
->freemap
[i
].base
);
172 to
->freemap
[i
].size
= be16_to_cpu(hdr3
->freemap
[i
].size
);
176 to
->forw
= be32_to_cpu(from
->hdr
.info
.forw
);
177 to
->back
= be32_to_cpu(from
->hdr
.info
.back
);
178 to
->magic
= be16_to_cpu(from
->hdr
.info
.magic
);
179 to
->count
= be16_to_cpu(from
->hdr
.count
);
180 to
->usedbytes
= be16_to_cpu(from
->hdr
.usedbytes
);
181 xfs_attr3_leaf_firstused_from_disk(geo
, to
, from
);
182 to
->holes
= from
->hdr
.holes
;
184 for (i
= 0; i
< XFS_ATTR_LEAF_MAPSIZE
; i
++) {
185 to
->freemap
[i
].base
= be16_to_cpu(from
->hdr
.freemap
[i
].base
);
186 to
->freemap
[i
].size
= be16_to_cpu(from
->hdr
.freemap
[i
].size
);
191 xfs_attr3_leaf_hdr_to_disk(
192 struct xfs_da_geometry
*geo
,
193 struct xfs_attr_leafblock
*to
,
194 struct xfs_attr3_icleaf_hdr
*from
)
198 ASSERT(from
->magic
== XFS_ATTR_LEAF_MAGIC
||
199 from
->magic
== XFS_ATTR3_LEAF_MAGIC
);
201 if (from
->magic
== XFS_ATTR3_LEAF_MAGIC
) {
202 struct xfs_attr3_leaf_hdr
*hdr3
= (struct xfs_attr3_leaf_hdr
*)to
;
204 hdr3
->info
.hdr
.forw
= cpu_to_be32(from
->forw
);
205 hdr3
->info
.hdr
.back
= cpu_to_be32(from
->back
);
206 hdr3
->info
.hdr
.magic
= cpu_to_be16(from
->magic
);
207 hdr3
->count
= cpu_to_be16(from
->count
);
208 hdr3
->usedbytes
= cpu_to_be16(from
->usedbytes
);
209 xfs_attr3_leaf_firstused_to_disk(geo
, to
, from
);
210 hdr3
->holes
= from
->holes
;
213 for (i
= 0; i
< XFS_ATTR_LEAF_MAPSIZE
; i
++) {
214 hdr3
->freemap
[i
].base
= cpu_to_be16(from
->freemap
[i
].base
);
215 hdr3
->freemap
[i
].size
= cpu_to_be16(from
->freemap
[i
].size
);
219 to
->hdr
.info
.forw
= cpu_to_be32(from
->forw
);
220 to
->hdr
.info
.back
= cpu_to_be32(from
->back
);
221 to
->hdr
.info
.magic
= cpu_to_be16(from
->magic
);
222 to
->hdr
.count
= cpu_to_be16(from
->count
);
223 to
->hdr
.usedbytes
= cpu_to_be16(from
->usedbytes
);
224 xfs_attr3_leaf_firstused_to_disk(geo
, to
, from
);
225 to
->hdr
.holes
= from
->holes
;
228 for (i
= 0; i
< XFS_ATTR_LEAF_MAPSIZE
; i
++) {
229 to
->hdr
.freemap
[i
].base
= cpu_to_be16(from
->freemap
[i
].base
);
230 to
->hdr
.freemap
[i
].size
= cpu_to_be16(from
->freemap
[i
].size
);
234 static xfs_failaddr_t
235 xfs_attr3_leaf_verify_entry(
236 struct xfs_mount
*mp
,
238 struct xfs_attr_leafblock
*leaf
,
239 struct xfs_attr3_icleaf_hdr
*leafhdr
,
240 struct xfs_attr_leaf_entry
*ent
,
244 struct xfs_attr_leaf_name_local
*lentry
;
245 struct xfs_attr_leaf_name_remote
*rentry
;
247 unsigned int nameidx
;
248 unsigned int namesize
;
251 /* hash order check */
252 hashval
= be32_to_cpu(ent
->hashval
);
253 if (hashval
< *last_hashval
)
254 return __this_address
;
255 *last_hashval
= hashval
;
257 nameidx
= be16_to_cpu(ent
->nameidx
);
258 if (nameidx
< leafhdr
->firstused
|| nameidx
>= mp
->m_attr_geo
->blksize
)
259 return __this_address
;
262 * Check the name information. The namelen fields are u8 so we can't
263 * possibly exceed the maximum name length of 255 bytes.
265 if (ent
->flags
& XFS_ATTR_LOCAL
) {
266 lentry
= xfs_attr3_leaf_name_local(leaf
, idx
);
267 namesize
= xfs_attr_leaf_entsize_local(lentry
->namelen
,
268 be16_to_cpu(lentry
->valuelen
));
269 name_end
= (char *)lentry
+ namesize
;
270 if (lentry
->namelen
== 0)
271 return __this_address
;
273 rentry
= xfs_attr3_leaf_name_remote(leaf
, idx
);
274 namesize
= xfs_attr_leaf_entsize_remote(rentry
->namelen
);
275 name_end
= (char *)rentry
+ namesize
;
276 if (rentry
->namelen
== 0)
277 return __this_address
;
278 if (!(ent
->flags
& XFS_ATTR_INCOMPLETE
) &&
279 rentry
->valueblk
== 0)
280 return __this_address
;
283 if (name_end
> buf_end
)
284 return __this_address
;
290 * Validate an attribute leaf block.
292 * Empty leaf blocks can occur under the following circumstances:
294 * 1. setxattr adds a new extended attribute to a file;
295 * 2. The file has zero existing attributes;
296 * 3. The attribute is too large to fit in the attribute fork;
297 * 4. The attribute is small enough to fit in a leaf block;
298 * 5. A log flush occurs after committing the transaction that creates
299 * the (empty) leaf block; and
300 * 6. The filesystem goes down after the log flush but before the new
301 * attribute can be committed to the leaf block.
303 * Hence we need to ensure that we don't fail the validation purely
304 * because the leaf is empty.
306 static xfs_failaddr_t
307 xfs_attr3_leaf_verify(
310 struct xfs_attr3_icleaf_hdr ichdr
;
311 struct xfs_mount
*mp
= bp
->b_mount
;
312 struct xfs_attr_leafblock
*leaf
= bp
->b_addr
;
313 struct xfs_attr_leaf_entry
*entries
;
314 struct xfs_attr_leaf_entry
*ent
;
316 uint32_t end
; /* must be 32bit - see below */
317 __u32 last_hashval
= 0;
321 xfs_attr3_leaf_hdr_from_disk(mp
->m_attr_geo
, &ichdr
, leaf
);
323 fa
= xfs_da3_blkinfo_verify(bp
, bp
->b_addr
);
328 * firstused is the block offset of the first name info structure.
329 * Make sure it doesn't go off the block or crash into the header.
331 if (ichdr
.firstused
> mp
->m_attr_geo
->blksize
)
332 return __this_address
;
333 if (ichdr
.firstused
< xfs_attr3_leaf_hdr_size(leaf
))
334 return __this_address
;
336 /* Make sure the entries array doesn't crash into the name info. */
337 entries
= xfs_attr3_leaf_entryp(bp
->b_addr
);
338 if ((char *)&entries
[ichdr
.count
] >
339 (char *)bp
->b_addr
+ ichdr
.firstused
)
340 return __this_address
;
343 * NOTE: This verifier historically failed empty leaf buffers because
344 * we expect the fork to be in another format. Empty attr fork format
345 * conversions are possible during xattr set, however, and format
346 * conversion is not atomic with the xattr set that triggers it. We
347 * cannot assume leaf blocks are non-empty until that is addressed.
349 buf_end
= (char *)bp
->b_addr
+ mp
->m_attr_geo
->blksize
;
350 for (i
= 0, ent
= entries
; i
< ichdr
.count
; ent
++, i
++) {
351 fa
= xfs_attr3_leaf_verify_entry(mp
, buf_end
, leaf
, &ichdr
,
352 ent
, i
, &last_hashval
);
358 * Quickly check the freemap information. Attribute data has to be
359 * aligned to 4-byte boundaries, and likewise for the free space.
361 * Note that for 64k block size filesystems, the freemap entries cannot
362 * overflow as they are only be16 fields. However, when checking end
363 * pointer of the freemap, we have to be careful to detect overflows and
364 * so use uint32_t for those checks.
366 for (i
= 0; i
< XFS_ATTR_LEAF_MAPSIZE
; i
++) {
367 if (ichdr
.freemap
[i
].base
> mp
->m_attr_geo
->blksize
)
368 return __this_address
;
369 if (ichdr
.freemap
[i
].base
& 0x3)
370 return __this_address
;
371 if (ichdr
.freemap
[i
].size
> mp
->m_attr_geo
->blksize
)
372 return __this_address
;
373 if (ichdr
.freemap
[i
].size
& 0x3)
374 return __this_address
;
376 /* be care of 16 bit overflows here */
377 end
= (uint32_t)ichdr
.freemap
[i
].base
+ ichdr
.freemap
[i
].size
;
378 if (end
< ichdr
.freemap
[i
].base
)
379 return __this_address
;
380 if (end
> mp
->m_attr_geo
->blksize
)
381 return __this_address
;
388 xfs_attr3_leaf_write_verify(
391 struct xfs_mount
*mp
= bp
->b_mount
;
392 struct xfs_buf_log_item
*bip
= bp
->b_log_item
;
393 struct xfs_attr3_leaf_hdr
*hdr3
= bp
->b_addr
;
396 fa
= xfs_attr3_leaf_verify(bp
);
398 xfs_verifier_error(bp
, -EFSCORRUPTED
, fa
);
402 if (!xfs_has_crc(mp
))
406 hdr3
->info
.lsn
= cpu_to_be64(bip
->bli_item
.li_lsn
);
408 xfs_buf_update_cksum(bp
, XFS_ATTR3_LEAF_CRC_OFF
);
412 * leaf/node format detection on trees is sketchy, so a node read can be done on
413 * leaf level blocks when detection identifies the tree as a node format tree
414 * incorrectly. In this case, we need to swap the verifier to match the correct
415 * format of the block being read.
418 xfs_attr3_leaf_read_verify(
421 struct xfs_mount
*mp
= bp
->b_mount
;
424 if (xfs_has_crc(mp
) &&
425 !xfs_buf_verify_cksum(bp
, XFS_ATTR3_LEAF_CRC_OFF
))
426 xfs_verifier_error(bp
, -EFSBADCRC
, __this_address
);
428 fa
= xfs_attr3_leaf_verify(bp
);
430 xfs_verifier_error(bp
, -EFSCORRUPTED
, fa
);
434 const struct xfs_buf_ops xfs_attr3_leaf_buf_ops
= {
435 .name
= "xfs_attr3_leaf",
436 .magic16
= { cpu_to_be16(XFS_ATTR_LEAF_MAGIC
),
437 cpu_to_be16(XFS_ATTR3_LEAF_MAGIC
) },
438 .verify_read
= xfs_attr3_leaf_read_verify
,
439 .verify_write
= xfs_attr3_leaf_write_verify
,
440 .verify_struct
= xfs_attr3_leaf_verify
,
445 struct xfs_trans
*tp
,
446 struct xfs_inode
*dp
,
448 struct xfs_buf
**bpp
)
452 err
= xfs_da_read_buf(tp
, dp
, bno
, 0, bpp
, XFS_ATTR_FORK
,
453 &xfs_attr3_leaf_buf_ops
);
454 if (!err
&& tp
&& *bpp
)
455 xfs_trans_buf_set_type(tp
, *bpp
, XFS_BLFT_ATTR_LEAF_BUF
);
459 /*========================================================================
460 * Namespace helper routines
461 *========================================================================*/
464 * If we are in log recovery, then we want the lookup to ignore the INCOMPLETE
465 * flag on disk - if there's an incomplete attr then recovery needs to tear it
466 * down. If there's no incomplete attr, then recovery needs to tear that attr
467 * down to replace it with the attr that has been logged. In this case, the
468 * INCOMPLETE flag will not be set in attr->attr_filter, but rather
469 * XFS_DA_OP_RECOVERY will be set in args->op_flags.
473 struct xfs_da_args
*args
,
479 if (args
->namelen
!= namelen
)
481 if (memcmp(args
->name
, name
, namelen
) != 0)
484 /* Recovery ignores the INCOMPLETE flag. */
485 if ((args
->op_flags
& XFS_DA_OP_RECOVERY
) &&
486 args
->attr_filter
== (flags
& XFS_ATTR_NSP_ONDISK_MASK
))
489 /* All remaining matches need to be filtered by INCOMPLETE state. */
490 if (args
->attr_filter
!=
491 (flags
& (XFS_ATTR_NSP_ONDISK_MASK
| XFS_ATTR_INCOMPLETE
)))
498 struct xfs_da_args
*args
,
499 unsigned char *value
,
503 * No copy if all we have to do is get the length
505 if (!args
->valuelen
) {
506 args
->valuelen
= valuelen
;
511 * No copy if the length of the existing buffer is too small
513 if (args
->valuelen
< valuelen
) {
514 args
->valuelen
= valuelen
;
519 args
->value
= kvmalloc(valuelen
, GFP_KERNEL
| __GFP_NOLOCKDEP
);
523 args
->valuelen
= valuelen
;
525 /* remote block xattr requires IO for copy-in */
527 return xfs_attr_rmtval_get(args
);
530 * This is to prevent a GCC warning because the remote xattr case
531 * doesn't have a value to pass in. In that case, we never reach here,
532 * but GCC can't work that out and so throws a "passing NULL to
537 memcpy(args
->value
, value
, valuelen
);
541 /*========================================================================
542 * External routines when attribute fork size < XFS_LITINO(mp).
543 *========================================================================*/
546 * Query whether the total requested number of attr fork bytes of extended
547 * attribute space will be able to fit inline.
549 * Returns zero if not, else the i_forkoff fork offset to be used in the
550 * literal area for attribute data once the new bytes have been added.
552 * i_forkoff must be 8 byte aligned, hence is stored as a >>3 value;
553 * special case for dev/uuid inodes, they have fixed size data forks.
556 xfs_attr_shortform_bytesfit(
557 struct xfs_inode
*dp
,
560 struct xfs_mount
*mp
= dp
->i_mount
;
567 * Check if the new size could fit at all first:
569 if (bytes
> XFS_LITINO(mp
))
573 offset
= (XFS_LITINO(mp
) - bytes
) >> 3;
575 if (dp
->i_df
.if_format
== XFS_DINODE_FMT_DEV
) {
576 minforkoff
= roundup(sizeof(xfs_dev_t
), 8) >> 3;
577 return (offset
>= minforkoff
) ? minforkoff
: 0;
581 * If the requested numbers of bytes is smaller or equal to the
582 * current attribute fork size we can always proceed.
584 * Note that if_bytes in the data fork might actually be larger than
585 * the current data fork size is due to delalloc extents. In that
586 * case either the extent count will go down when they are converted
587 * to real extents, or the delalloc conversion will take care of the
588 * literal area rebalancing.
590 if (bytes
<= xfs_inode_attr_fork_size(dp
))
591 return dp
->i_forkoff
;
594 * For attr2 we can try to move the forkoff if there is space in the
595 * literal area, but for the old format we are done if there is no
596 * space in the fixed attribute fork.
598 if (!xfs_has_attr2(mp
))
601 dsize
= dp
->i_df
.if_bytes
;
603 switch (dp
->i_df
.if_format
) {
604 case XFS_DINODE_FMT_EXTENTS
:
606 * If there is no attr fork and the data fork is extents,
607 * determine if creating the default attr fork will result
608 * in the extents form migrating to btree. If so, the
609 * minimum offset only needs to be the space required for
612 if (!dp
->i_forkoff
&& dp
->i_df
.if_bytes
>
613 xfs_default_attroffset(dp
))
614 dsize
= XFS_BMDR_SPACE_CALC(MINDBTPTRS
);
616 case XFS_DINODE_FMT_BTREE
:
618 * If we have a data btree then keep forkoff if we have one,
619 * otherwise we are adding a new attr, so then we set
620 * minforkoff to where the btree root can finish so we have
621 * plenty of room for attrs
624 if (offset
< dp
->i_forkoff
)
626 return dp
->i_forkoff
;
628 dsize
= XFS_BMAP_BROOT_SPACE(mp
, dp
->i_df
.if_broot
);
633 * A data fork btree root must have space for at least
634 * MINDBTPTRS key/ptr pairs if the data fork is small or empty.
636 minforkoff
= max_t(int64_t, dsize
, XFS_BMDR_SPACE_CALC(MINDBTPTRS
));
637 minforkoff
= roundup(minforkoff
, 8) >> 3;
639 /* attr fork btree root can have at least this many key/ptr pairs */
640 maxforkoff
= XFS_LITINO(mp
) - XFS_BMDR_SPACE_CALC(MINABTPTRS
);
641 maxforkoff
= maxforkoff
>> 3; /* rounded down */
643 if (offset
>= maxforkoff
)
645 if (offset
>= minforkoff
)
651 * Switch on the ATTR2 superblock bit (implies also FEATURES2) unless:
652 * - noattr2 mount option is set,
653 * - on-disk version bit says it is already set, or
654 * - the attr2 mount option is not set to enable automatic upgrade from attr1.
657 xfs_sbversion_add_attr2(
658 struct xfs_mount
*mp
,
659 struct xfs_trans
*tp
)
661 if (xfs_has_noattr2(mp
))
663 if (mp
->m_sb
.sb_features2
& XFS_SB_VERSION2_ATTR2BIT
)
665 if (!xfs_has_attr2(mp
))
668 spin_lock(&mp
->m_sb_lock
);
670 spin_unlock(&mp
->m_sb_lock
);
675 * Create the initial contents of a shortform attribute list.
678 xfs_attr_shortform_create(
679 struct xfs_da_args
*args
)
681 struct xfs_inode
*dp
= args
->dp
;
682 struct xfs_ifork
*ifp
= &dp
->i_af
;
683 struct xfs_attr_sf_hdr
*hdr
;
685 trace_xfs_attr_sf_create(args
);
687 ASSERT(ifp
->if_bytes
== 0);
688 if (ifp
->if_format
== XFS_DINODE_FMT_EXTENTS
)
689 ifp
->if_format
= XFS_DINODE_FMT_LOCAL
;
690 xfs_idata_realloc(dp
, sizeof(*hdr
), XFS_ATTR_FORK
);
691 hdr
= (struct xfs_attr_sf_hdr
*)ifp
->if_u1
.if_data
;
692 memset(hdr
, 0, sizeof(*hdr
));
693 hdr
->totsize
= cpu_to_be16(sizeof(*hdr
));
694 xfs_trans_log_inode(args
->trans
, dp
, XFS_ILOG_CORE
| XFS_ILOG_ADATA
);
698 * Return -EEXIST if attr is found, or -ENOATTR if not
699 * args: args containing attribute name and namelen
700 * sfep: If not null, pointer will be set to the last attr entry found on
701 -EEXIST. On -ENOATTR pointer is left at the last entry in the list
702 * basep: If not null, pointer is set to the byte offset of the entry in the
703 * list on -EEXIST. On -ENOATTR, pointer is left at the byte offset of
704 * the last entry in the list
707 xfs_attr_sf_findname(
708 struct xfs_da_args
*args
,
709 struct xfs_attr_sf_entry
**sfep
,
712 struct xfs_attr_shortform
*sf
;
713 struct xfs_attr_sf_entry
*sfe
;
714 unsigned int base
= sizeof(struct xfs_attr_sf_hdr
);
719 sf
= (struct xfs_attr_shortform
*)args
->dp
->i_af
.if_u1
.if_data
;
722 for (i
= 0; i
< end
; sfe
= xfs_attr_sf_nextentry(sfe
),
724 size
= xfs_attr_sf_entsize(sfe
);
725 if (!xfs_attr_match(args
, sfe
->namelen
, sfe
->nameval
,
743 * Add a name/value pair to the shortform attribute list.
744 * Overflow from the inode has already been checked for.
747 xfs_attr_shortform_add(
748 struct xfs_da_args
*args
,
751 struct xfs_attr_shortform
*sf
;
752 struct xfs_attr_sf_entry
*sfe
;
754 struct xfs_mount
*mp
;
755 struct xfs_inode
*dp
;
756 struct xfs_ifork
*ifp
;
758 trace_xfs_attr_sf_add(args
);
762 dp
->i_forkoff
= forkoff
;
765 ASSERT(ifp
->if_format
== XFS_DINODE_FMT_LOCAL
);
766 sf
= (struct xfs_attr_shortform
*)ifp
->if_u1
.if_data
;
767 if (xfs_attr_sf_findname(args
, &sfe
, NULL
) == -EEXIST
)
770 offset
= (char *)sfe
- (char *)sf
;
771 size
= xfs_attr_sf_entsize_byname(args
->namelen
, args
->valuelen
);
772 xfs_idata_realloc(dp
, size
, XFS_ATTR_FORK
);
773 sf
= (struct xfs_attr_shortform
*)ifp
->if_u1
.if_data
;
774 sfe
= (struct xfs_attr_sf_entry
*)((char *)sf
+ offset
);
776 sfe
->namelen
= args
->namelen
;
777 sfe
->valuelen
= args
->valuelen
;
778 sfe
->flags
= args
->attr_filter
;
779 memcpy(sfe
->nameval
, args
->name
, args
->namelen
);
780 memcpy(&sfe
->nameval
[args
->namelen
], args
->value
, args
->valuelen
);
782 be16_add_cpu(&sf
->hdr
.totsize
, size
);
783 xfs_trans_log_inode(args
->trans
, dp
, XFS_ILOG_CORE
| XFS_ILOG_ADATA
);
785 xfs_sbversion_add_attr2(mp
, args
->trans
);
789 * After the last attribute is removed revert to original inode format,
790 * making all literal area available to the data fork once more.
793 xfs_attr_fork_remove(
794 struct xfs_inode
*ip
,
795 struct xfs_trans
*tp
)
797 ASSERT(ip
->i_af
.if_nextents
== 0);
799 xfs_ifork_zap_attr(ip
);
801 xfs_trans_log_inode(tp
, ip
, XFS_ILOG_CORE
);
805 * Remove an attribute from the shortform attribute list structure.
808 xfs_attr_sf_removename(
809 struct xfs_da_args
*args
)
811 struct xfs_attr_shortform
*sf
;
812 struct xfs_attr_sf_entry
*sfe
;
813 int size
= 0, end
, totsize
;
815 struct xfs_mount
*mp
;
816 struct xfs_inode
*dp
;
819 trace_xfs_attr_sf_remove(args
);
823 sf
= (struct xfs_attr_shortform
*)dp
->i_af
.if_u1
.if_data
;
825 error
= xfs_attr_sf_findname(args
, &sfe
, &base
);
828 * If we are recovering an operation, finding nothing to
829 * remove is not an error - it just means there was nothing
832 if (error
== -ENOATTR
&& (args
->op_flags
& XFS_DA_OP_RECOVERY
))
834 if (error
!= -EEXIST
)
836 size
= xfs_attr_sf_entsize(sfe
);
839 * Fix up the attribute fork data, covering the hole
842 totsize
= be16_to_cpu(sf
->hdr
.totsize
);
844 memmove(&((char *)sf
)[base
], &((char *)sf
)[end
], totsize
- end
);
846 be16_add_cpu(&sf
->hdr
.totsize
, -size
);
849 * Fix up the start offset of the attribute fork
852 if (totsize
== sizeof(xfs_attr_sf_hdr_t
) && xfs_has_attr2(mp
) &&
853 (dp
->i_df
.if_format
!= XFS_DINODE_FMT_BTREE
) &&
854 !(args
->op_flags
& (XFS_DA_OP_ADDNAME
| XFS_DA_OP_REPLACE
))) {
855 xfs_attr_fork_remove(dp
, args
->trans
);
857 xfs_idata_realloc(dp
, -size
, XFS_ATTR_FORK
);
858 dp
->i_forkoff
= xfs_attr_shortform_bytesfit(dp
, totsize
);
859 ASSERT(dp
->i_forkoff
);
860 ASSERT(totsize
> sizeof(xfs_attr_sf_hdr_t
) ||
861 (args
->op_flags
& XFS_DA_OP_ADDNAME
) ||
862 !xfs_has_attr2(mp
) ||
863 dp
->i_df
.if_format
== XFS_DINODE_FMT_BTREE
);
864 xfs_trans_log_inode(args
->trans
, dp
,
865 XFS_ILOG_CORE
| XFS_ILOG_ADATA
);
868 xfs_sbversion_add_attr2(mp
, args
->trans
);
874 * Look up a name in a shortform attribute list structure.
878 xfs_attr_shortform_lookup(xfs_da_args_t
*args
)
880 struct xfs_attr_shortform
*sf
;
881 struct xfs_attr_sf_entry
*sfe
;
883 struct xfs_ifork
*ifp
;
885 trace_xfs_attr_sf_lookup(args
);
887 ifp
= &args
->dp
->i_af
;
888 ASSERT(ifp
->if_format
== XFS_DINODE_FMT_LOCAL
);
889 sf
= (struct xfs_attr_shortform
*)ifp
->if_u1
.if_data
;
891 for (i
= 0; i
< sf
->hdr
.count
;
892 sfe
= xfs_attr_sf_nextentry(sfe
), i
++) {
893 if (xfs_attr_match(args
, sfe
->namelen
, sfe
->nameval
,
901 * Retrieve the attribute value and length.
903 * If args->valuelen is zero, only the length needs to be returned. Unlike a
904 * lookup, we only return an error if the attribute does not exist or we can't
905 * retrieve the value.
908 xfs_attr_shortform_getvalue(
909 struct xfs_da_args
*args
)
911 struct xfs_attr_shortform
*sf
;
912 struct xfs_attr_sf_entry
*sfe
;
915 ASSERT(args
->dp
->i_af
.if_format
== XFS_DINODE_FMT_LOCAL
);
916 sf
= (struct xfs_attr_shortform
*)args
->dp
->i_af
.if_u1
.if_data
;
918 for (i
= 0; i
< sf
->hdr
.count
;
919 sfe
= xfs_attr_sf_nextentry(sfe
), i
++) {
920 if (xfs_attr_match(args
, sfe
->namelen
, sfe
->nameval
,
922 return xfs_attr_copy_value(args
,
923 &sfe
->nameval
[args
->namelen
], sfe
->valuelen
);
928 /* Convert from using the shortform to the leaf format. */
930 xfs_attr_shortform_to_leaf(
931 struct xfs_da_args
*args
)
933 struct xfs_inode
*dp
;
934 struct xfs_attr_shortform
*sf
;
935 struct xfs_attr_sf_entry
*sfe
;
936 struct xfs_da_args nargs
;
941 struct xfs_ifork
*ifp
;
943 trace_xfs_attr_sf_to_leaf(args
);
947 sf
= (struct xfs_attr_shortform
*)ifp
->if_u1
.if_data
;
948 size
= be16_to_cpu(sf
->hdr
.totsize
);
949 tmpbuffer
= kmem_alloc(size
, 0);
950 ASSERT(tmpbuffer
!= NULL
);
951 memcpy(tmpbuffer
, ifp
->if_u1
.if_data
, size
);
952 sf
= (struct xfs_attr_shortform
*)tmpbuffer
;
954 xfs_idata_realloc(dp
, -size
, XFS_ATTR_FORK
);
955 xfs_bmap_local_to_extents_empty(args
->trans
, dp
, XFS_ATTR_FORK
);
958 error
= xfs_da_grow_inode(args
, &blkno
);
963 error
= xfs_attr3_leaf_create(args
, blkno
, &bp
);
967 memset((char *)&nargs
, 0, sizeof(nargs
));
969 nargs
.geo
= args
->geo
;
970 nargs
.total
= args
->total
;
971 nargs
.whichfork
= XFS_ATTR_FORK
;
972 nargs
.trans
= args
->trans
;
973 nargs
.op_flags
= XFS_DA_OP_OKNOENT
;
976 for (i
= 0; i
< sf
->hdr
.count
; i
++) {
977 nargs
.name
= sfe
->nameval
;
978 nargs
.namelen
= sfe
->namelen
;
979 nargs
.value
= &sfe
->nameval
[nargs
.namelen
];
980 nargs
.valuelen
= sfe
->valuelen
;
981 nargs
.hashval
= xfs_da_hashname(sfe
->nameval
,
983 nargs
.attr_filter
= sfe
->flags
& XFS_ATTR_NSP_ONDISK_MASK
;
984 error
= xfs_attr3_leaf_lookup_int(bp
, &nargs
); /* set a->index */
985 ASSERT(error
== -ENOATTR
);
986 error
= xfs_attr3_leaf_add(bp
, &nargs
);
987 ASSERT(error
!= -ENOSPC
);
990 sfe
= xfs_attr_sf_nextentry(sfe
);
994 kmem_free(tmpbuffer
);
999 * Check a leaf attribute block to see if all the entries would fit into
1000 * a shortform attribute list.
1003 xfs_attr_shortform_allfit(
1005 struct xfs_inode
*dp
)
1007 struct xfs_attr_leafblock
*leaf
;
1008 struct xfs_attr_leaf_entry
*entry
;
1009 xfs_attr_leaf_name_local_t
*name_loc
;
1010 struct xfs_attr3_icleaf_hdr leafhdr
;
1013 struct xfs_mount
*mp
= bp
->b_mount
;
1016 xfs_attr3_leaf_hdr_from_disk(mp
->m_attr_geo
, &leafhdr
, leaf
);
1017 entry
= xfs_attr3_leaf_entryp(leaf
);
1019 bytes
= sizeof(struct xfs_attr_sf_hdr
);
1020 for (i
= 0; i
< leafhdr
.count
; entry
++, i
++) {
1021 if (entry
->flags
& XFS_ATTR_INCOMPLETE
)
1022 continue; /* don't copy partial entries */
1023 if (!(entry
->flags
& XFS_ATTR_LOCAL
))
1025 name_loc
= xfs_attr3_leaf_name_local(leaf
, i
);
1026 if (name_loc
->namelen
>= XFS_ATTR_SF_ENTSIZE_MAX
)
1028 if (be16_to_cpu(name_loc
->valuelen
) >= XFS_ATTR_SF_ENTSIZE_MAX
)
1030 bytes
+= xfs_attr_sf_entsize_byname(name_loc
->namelen
,
1031 be16_to_cpu(name_loc
->valuelen
));
1033 if (xfs_has_attr2(dp
->i_mount
) &&
1034 (dp
->i_df
.if_format
!= XFS_DINODE_FMT_BTREE
) &&
1035 (bytes
== sizeof(struct xfs_attr_sf_hdr
)))
1037 return xfs_attr_shortform_bytesfit(dp
, bytes
);
1040 /* Verify the consistency of an inline attribute fork. */
1042 xfs_attr_shortform_verify(
1043 struct xfs_inode
*ip
)
1045 struct xfs_attr_shortform
*sfp
;
1046 struct xfs_attr_sf_entry
*sfep
;
1047 struct xfs_attr_sf_entry
*next_sfep
;
1049 struct xfs_ifork
*ifp
;
1053 ASSERT(ip
->i_af
.if_format
== XFS_DINODE_FMT_LOCAL
);
1054 ifp
= xfs_ifork_ptr(ip
, XFS_ATTR_FORK
);
1055 sfp
= (struct xfs_attr_shortform
*)ifp
->if_u1
.if_data
;
1056 size
= ifp
->if_bytes
;
1059 * Give up if the attribute is way too short.
1061 if (size
< sizeof(struct xfs_attr_sf_hdr
))
1062 return __this_address
;
1064 endp
= (char *)sfp
+ size
;
1066 /* Check all reported entries */
1067 sfep
= &sfp
->list
[0];
1068 for (i
= 0; i
< sfp
->hdr
.count
; i
++) {
1070 * struct xfs_attr_sf_entry has a variable length.
1071 * Check the fixed-offset parts of the structure are
1072 * within the data buffer.
1073 * xfs_attr_sf_entry is defined with a 1-byte variable
1074 * array at the end, so we must subtract that off.
1076 if (((char *)sfep
+ sizeof(*sfep
)) >= endp
)
1077 return __this_address
;
1079 /* Don't allow names with known bad length. */
1080 if (sfep
->namelen
== 0)
1081 return __this_address
;
1084 * Check that the variable-length part of the structure is
1085 * within the data buffer. The next entry starts after the
1086 * name component, so nextentry is an acceptable test.
1088 next_sfep
= xfs_attr_sf_nextentry(sfep
);
1089 if ((char *)next_sfep
> endp
)
1090 return __this_address
;
1093 * Check for unknown flags. Short form doesn't support
1094 * the incomplete or local bits, so we can use the namespace
1097 if (sfep
->flags
& ~XFS_ATTR_NSP_ONDISK_MASK
)
1098 return __this_address
;
1101 * Check for invalid namespace combinations. We only allow
1102 * one namespace flag per xattr, so we can just count the
1103 * bits (i.e. hweight) here.
1105 if (hweight8(sfep
->flags
& XFS_ATTR_NSP_ONDISK_MASK
) > 1)
1106 return __this_address
;
1110 if ((void *)sfep
!= (void *)endp
)
1111 return __this_address
;
1117 * Convert a leaf attribute list to shortform attribute list
1120 xfs_attr3_leaf_to_shortform(
1122 struct xfs_da_args
*args
,
1125 struct xfs_attr_leafblock
*leaf
;
1126 struct xfs_attr3_icleaf_hdr ichdr
;
1127 struct xfs_attr_leaf_entry
*entry
;
1128 struct xfs_attr_leaf_name_local
*name_loc
;
1129 struct xfs_da_args nargs
;
1130 struct xfs_inode
*dp
= args
->dp
;
1135 trace_xfs_attr_leaf_to_sf(args
);
1137 tmpbuffer
= kmem_alloc(args
->geo
->blksize
, 0);
1141 memcpy(tmpbuffer
, bp
->b_addr
, args
->geo
->blksize
);
1143 leaf
= (xfs_attr_leafblock_t
*)tmpbuffer
;
1144 xfs_attr3_leaf_hdr_from_disk(args
->geo
, &ichdr
, leaf
);
1145 entry
= xfs_attr3_leaf_entryp(leaf
);
1147 /* XXX (dgc): buffer is about to be marked stale - why zero it? */
1148 memset(bp
->b_addr
, 0, args
->geo
->blksize
);
1151 * Clean out the prior contents of the attribute list.
1153 error
= xfs_da_shrink_inode(args
, 0, bp
);
1157 if (forkoff
== -1) {
1159 * Don't remove the attr fork if this operation is the first
1160 * part of a attr replace operations. We're going to add a new
1161 * attr immediately, so we need to keep the attr fork around in
1164 if (!(args
->op_flags
& XFS_DA_OP_REPLACE
)) {
1165 ASSERT(xfs_has_attr2(dp
->i_mount
));
1166 ASSERT(dp
->i_df
.if_format
!= XFS_DINODE_FMT_BTREE
);
1167 xfs_attr_fork_remove(dp
, args
->trans
);
1172 xfs_attr_shortform_create(args
);
1175 * Copy the attributes
1177 memset((char *)&nargs
, 0, sizeof(nargs
));
1178 nargs
.geo
= args
->geo
;
1180 nargs
.total
= args
->total
;
1181 nargs
.whichfork
= XFS_ATTR_FORK
;
1182 nargs
.trans
= args
->trans
;
1183 nargs
.op_flags
= XFS_DA_OP_OKNOENT
;
1185 for (i
= 0; i
< ichdr
.count
; entry
++, i
++) {
1186 if (entry
->flags
& XFS_ATTR_INCOMPLETE
)
1187 continue; /* don't copy partial entries */
1188 if (!entry
->nameidx
)
1190 ASSERT(entry
->flags
& XFS_ATTR_LOCAL
);
1191 name_loc
= xfs_attr3_leaf_name_local(leaf
, i
);
1192 nargs
.name
= name_loc
->nameval
;
1193 nargs
.namelen
= name_loc
->namelen
;
1194 nargs
.value
= &name_loc
->nameval
[nargs
.namelen
];
1195 nargs
.valuelen
= be16_to_cpu(name_loc
->valuelen
);
1196 nargs
.hashval
= be32_to_cpu(entry
->hashval
);
1197 nargs
.attr_filter
= entry
->flags
& XFS_ATTR_NSP_ONDISK_MASK
;
1198 xfs_attr_shortform_add(&nargs
, forkoff
);
1203 kmem_free(tmpbuffer
);
1208 * Convert from using a single leaf to a root node and a leaf.
1211 xfs_attr3_leaf_to_node(
1212 struct xfs_da_args
*args
)
1214 struct xfs_attr_leafblock
*leaf
;
1215 struct xfs_attr3_icleaf_hdr icleafhdr
;
1216 struct xfs_attr_leaf_entry
*entries
;
1217 struct xfs_da3_icnode_hdr icnodehdr
;
1218 struct xfs_da_intnode
*node
;
1219 struct xfs_inode
*dp
= args
->dp
;
1220 struct xfs_mount
*mp
= dp
->i_mount
;
1221 struct xfs_buf
*bp1
= NULL
;
1222 struct xfs_buf
*bp2
= NULL
;
1226 trace_xfs_attr_leaf_to_node(args
);
1228 if (XFS_TEST_ERROR(false, mp
, XFS_ERRTAG_ATTR_LEAF_TO_NODE
)) {
1233 error
= xfs_da_grow_inode(args
, &blkno
);
1236 error
= xfs_attr3_leaf_read(args
->trans
, dp
, 0, &bp1
);
1240 error
= xfs_da_get_buf(args
->trans
, dp
, blkno
, &bp2
, XFS_ATTR_FORK
);
1244 /* copy leaf to new buffer, update identifiers */
1245 xfs_trans_buf_set_type(args
->trans
, bp2
, XFS_BLFT_ATTR_LEAF_BUF
);
1246 bp2
->b_ops
= bp1
->b_ops
;
1247 memcpy(bp2
->b_addr
, bp1
->b_addr
, args
->geo
->blksize
);
1248 if (xfs_has_crc(mp
)) {
1249 struct xfs_da3_blkinfo
*hdr3
= bp2
->b_addr
;
1250 hdr3
->blkno
= cpu_to_be64(xfs_buf_daddr(bp2
));
1252 xfs_trans_log_buf(args
->trans
, bp2
, 0, args
->geo
->blksize
- 1);
1255 * Set up the new root node.
1257 error
= xfs_da3_node_create(args
, 0, 1, &bp1
, XFS_ATTR_FORK
);
1261 xfs_da3_node_hdr_from_disk(mp
, &icnodehdr
, node
);
1264 xfs_attr3_leaf_hdr_from_disk(args
->geo
, &icleafhdr
, leaf
);
1265 entries
= xfs_attr3_leaf_entryp(leaf
);
1267 /* both on-disk, don't endian-flip twice */
1268 icnodehdr
.btree
[0].hashval
= entries
[icleafhdr
.count
- 1].hashval
;
1269 icnodehdr
.btree
[0].before
= cpu_to_be32(blkno
);
1270 icnodehdr
.count
= 1;
1271 xfs_da3_node_hdr_to_disk(dp
->i_mount
, node
, &icnodehdr
);
1272 xfs_trans_log_buf(args
->trans
, bp1
, 0, args
->geo
->blksize
- 1);
1278 /*========================================================================
1279 * Routines used for growing the Btree.
1280 *========================================================================*/
1283 * Create the initial contents of a leaf attribute list
1284 * or a leaf in a node attribute list.
1287 xfs_attr3_leaf_create(
1288 struct xfs_da_args
*args
,
1290 struct xfs_buf
**bpp
)
1292 struct xfs_attr_leafblock
*leaf
;
1293 struct xfs_attr3_icleaf_hdr ichdr
;
1294 struct xfs_inode
*dp
= args
->dp
;
1295 struct xfs_mount
*mp
= dp
->i_mount
;
1299 trace_xfs_attr_leaf_create(args
);
1301 error
= xfs_da_get_buf(args
->trans
, args
->dp
, blkno
, &bp
,
1305 bp
->b_ops
= &xfs_attr3_leaf_buf_ops
;
1306 xfs_trans_buf_set_type(args
->trans
, bp
, XFS_BLFT_ATTR_LEAF_BUF
);
1308 memset(leaf
, 0, args
->geo
->blksize
);
1310 memset(&ichdr
, 0, sizeof(ichdr
));
1311 ichdr
.firstused
= args
->geo
->blksize
;
1313 if (xfs_has_crc(mp
)) {
1314 struct xfs_da3_blkinfo
*hdr3
= bp
->b_addr
;
1316 ichdr
.magic
= XFS_ATTR3_LEAF_MAGIC
;
1318 hdr3
->blkno
= cpu_to_be64(xfs_buf_daddr(bp
));
1319 hdr3
->owner
= cpu_to_be64(dp
->i_ino
);
1320 uuid_copy(&hdr3
->uuid
, &mp
->m_sb
.sb_meta_uuid
);
1322 ichdr
.freemap
[0].base
= sizeof(struct xfs_attr3_leaf_hdr
);
1324 ichdr
.magic
= XFS_ATTR_LEAF_MAGIC
;
1325 ichdr
.freemap
[0].base
= sizeof(struct xfs_attr_leaf_hdr
);
1327 ichdr
.freemap
[0].size
= ichdr
.firstused
- ichdr
.freemap
[0].base
;
1329 xfs_attr3_leaf_hdr_to_disk(args
->geo
, leaf
, &ichdr
);
1330 xfs_trans_log_buf(args
->trans
, bp
, 0, args
->geo
->blksize
- 1);
1337 * Split the leaf node, rebalance, then add the new entry.
1340 xfs_attr3_leaf_split(
1341 struct xfs_da_state
*state
,
1342 struct xfs_da_state_blk
*oldblk
,
1343 struct xfs_da_state_blk
*newblk
)
1348 trace_xfs_attr_leaf_split(state
->args
);
1351 * Allocate space for a new leaf node.
1353 ASSERT(oldblk
->magic
== XFS_ATTR_LEAF_MAGIC
);
1354 error
= xfs_da_grow_inode(state
->args
, &blkno
);
1357 error
= xfs_attr3_leaf_create(state
->args
, blkno
, &newblk
->bp
);
1360 newblk
->blkno
= blkno
;
1361 newblk
->magic
= XFS_ATTR_LEAF_MAGIC
;
1364 * Rebalance the entries across the two leaves.
1365 * NOTE: rebalance() currently depends on the 2nd block being empty.
1367 xfs_attr3_leaf_rebalance(state
, oldblk
, newblk
);
1368 error
= xfs_da3_blk_link(state
, oldblk
, newblk
);
1373 * Save info on "old" attribute for "atomic rename" ops, leaf_add()
1374 * modifies the index/blkno/rmtblk/rmtblkcnt fields to show the
1375 * "new" attrs info. Will need the "old" info to remove it later.
1377 * Insert the "new" entry in the correct block.
1379 if (state
->inleaf
) {
1380 trace_xfs_attr_leaf_add_old(state
->args
);
1381 error
= xfs_attr3_leaf_add(oldblk
->bp
, state
->args
);
1383 trace_xfs_attr_leaf_add_new(state
->args
);
1384 error
= xfs_attr3_leaf_add(newblk
->bp
, state
->args
);
1388 * Update last hashval in each block since we added the name.
1390 oldblk
->hashval
= xfs_attr_leaf_lasthash(oldblk
->bp
, NULL
);
1391 newblk
->hashval
= xfs_attr_leaf_lasthash(newblk
->bp
, NULL
);
1396 * Add a name to the leaf attribute list structure.
1401 struct xfs_da_args
*args
)
1403 struct xfs_attr_leafblock
*leaf
;
1404 struct xfs_attr3_icleaf_hdr ichdr
;
1411 trace_xfs_attr_leaf_add(args
);
1414 xfs_attr3_leaf_hdr_from_disk(args
->geo
, &ichdr
, leaf
);
1415 ASSERT(args
->index
>= 0 && args
->index
<= ichdr
.count
);
1416 entsize
= xfs_attr_leaf_newentsize(args
, NULL
);
1419 * Search through freemap for first-fit on new name length.
1420 * (may need to figure in size of entry struct too)
1422 tablesize
= (ichdr
.count
+ 1) * sizeof(xfs_attr_leaf_entry_t
)
1423 + xfs_attr3_leaf_hdr_size(leaf
);
1424 for (sum
= 0, i
= XFS_ATTR_LEAF_MAPSIZE
- 1; i
>= 0; i
--) {
1425 if (tablesize
> ichdr
.firstused
) {
1426 sum
+= ichdr
.freemap
[i
].size
;
1429 if (!ichdr
.freemap
[i
].size
)
1430 continue; /* no space in this map */
1432 if (ichdr
.freemap
[i
].base
< ichdr
.firstused
)
1433 tmp
+= sizeof(xfs_attr_leaf_entry_t
);
1434 if (ichdr
.freemap
[i
].size
>= tmp
) {
1435 tmp
= xfs_attr3_leaf_add_work(bp
, &ichdr
, args
, i
);
1438 sum
+= ichdr
.freemap
[i
].size
;
1442 * If there are no holes in the address space of the block,
1443 * and we don't have enough freespace, then compaction will do us
1444 * no good and we should just give up.
1446 if (!ichdr
.holes
&& sum
< entsize
)
1450 * Compact the entries to coalesce free space.
1451 * This may change the hdr->count via dropping INCOMPLETE entries.
1453 xfs_attr3_leaf_compact(args
, &ichdr
, bp
);
1456 * After compaction, the block is guaranteed to have only one
1457 * free region, in freemap[0]. If it is not big enough, give up.
1459 if (ichdr
.freemap
[0].size
< (entsize
+ sizeof(xfs_attr_leaf_entry_t
))) {
1464 tmp
= xfs_attr3_leaf_add_work(bp
, &ichdr
, args
, 0);
1467 xfs_attr3_leaf_hdr_to_disk(args
->geo
, leaf
, &ichdr
);
1468 xfs_trans_log_buf(args
->trans
, bp
,
1469 XFS_DA_LOGRANGE(leaf
, &leaf
->hdr
,
1470 xfs_attr3_leaf_hdr_size(leaf
)));
1475 * Add a name to a leaf attribute list structure.
1478 xfs_attr3_leaf_add_work(
1480 struct xfs_attr3_icleaf_hdr
*ichdr
,
1481 struct xfs_da_args
*args
,
1484 struct xfs_attr_leafblock
*leaf
;
1485 struct xfs_attr_leaf_entry
*entry
;
1486 struct xfs_attr_leaf_name_local
*name_loc
;
1487 struct xfs_attr_leaf_name_remote
*name_rmt
;
1488 struct xfs_mount
*mp
;
1492 trace_xfs_attr_leaf_add_work(args
);
1495 ASSERT(mapindex
>= 0 && mapindex
< XFS_ATTR_LEAF_MAPSIZE
);
1496 ASSERT(args
->index
>= 0 && args
->index
<= ichdr
->count
);
1499 * Force open some space in the entry array and fill it in.
1501 entry
= &xfs_attr3_leaf_entryp(leaf
)[args
->index
];
1502 if (args
->index
< ichdr
->count
) {
1503 tmp
= ichdr
->count
- args
->index
;
1504 tmp
*= sizeof(xfs_attr_leaf_entry_t
);
1505 memmove(entry
+ 1, entry
, tmp
);
1506 xfs_trans_log_buf(args
->trans
, bp
,
1507 XFS_DA_LOGRANGE(leaf
, entry
, tmp
+ sizeof(*entry
)));
1512 * Allocate space for the new string (at the end of the run).
1514 mp
= args
->trans
->t_mountp
;
1515 ASSERT(ichdr
->freemap
[mapindex
].base
< args
->geo
->blksize
);
1516 ASSERT((ichdr
->freemap
[mapindex
].base
& 0x3) == 0);
1517 ASSERT(ichdr
->freemap
[mapindex
].size
>=
1518 xfs_attr_leaf_newentsize(args
, NULL
));
1519 ASSERT(ichdr
->freemap
[mapindex
].size
< args
->geo
->blksize
);
1520 ASSERT((ichdr
->freemap
[mapindex
].size
& 0x3) == 0);
1522 ichdr
->freemap
[mapindex
].size
-= xfs_attr_leaf_newentsize(args
, &tmp
);
1524 entry
->nameidx
= cpu_to_be16(ichdr
->freemap
[mapindex
].base
+
1525 ichdr
->freemap
[mapindex
].size
);
1526 entry
->hashval
= cpu_to_be32(args
->hashval
);
1527 entry
->flags
= args
->attr_filter
;
1529 entry
->flags
|= XFS_ATTR_LOCAL
;
1530 if (args
->op_flags
& XFS_DA_OP_REPLACE
) {
1531 if (!(args
->op_flags
& XFS_DA_OP_LOGGED
))
1532 entry
->flags
|= XFS_ATTR_INCOMPLETE
;
1533 if ((args
->blkno2
== args
->blkno
) &&
1534 (args
->index2
<= args
->index
)) {
1538 xfs_trans_log_buf(args
->trans
, bp
,
1539 XFS_DA_LOGRANGE(leaf
, entry
, sizeof(*entry
)));
1540 ASSERT((args
->index
== 0) ||
1541 (be32_to_cpu(entry
->hashval
) >= be32_to_cpu((entry
-1)->hashval
)));
1542 ASSERT((args
->index
== ichdr
->count
- 1) ||
1543 (be32_to_cpu(entry
->hashval
) <= be32_to_cpu((entry
+1)->hashval
)));
1546 * For "remote" attribute values, simply note that we need to
1547 * allocate space for the "remote" value. We can't actually
1548 * allocate the extents in this transaction, and we can't decide
1549 * which blocks they should be as we might allocate more blocks
1550 * as part of this transaction (a split operation for example).
1552 if (entry
->flags
& XFS_ATTR_LOCAL
) {
1553 name_loc
= xfs_attr3_leaf_name_local(leaf
, args
->index
);
1554 name_loc
->namelen
= args
->namelen
;
1555 name_loc
->valuelen
= cpu_to_be16(args
->valuelen
);
1556 memcpy((char *)name_loc
->nameval
, args
->name
, args
->namelen
);
1557 memcpy((char *)&name_loc
->nameval
[args
->namelen
], args
->value
,
1558 be16_to_cpu(name_loc
->valuelen
));
1560 name_rmt
= xfs_attr3_leaf_name_remote(leaf
, args
->index
);
1561 name_rmt
->namelen
= args
->namelen
;
1562 memcpy((char *)name_rmt
->name
, args
->name
, args
->namelen
);
1563 entry
->flags
|= XFS_ATTR_INCOMPLETE
;
1565 name_rmt
->valuelen
= 0;
1566 name_rmt
->valueblk
= 0;
1568 args
->rmtblkcnt
= xfs_attr3_rmt_blocks(mp
, args
->valuelen
);
1569 args
->rmtvaluelen
= args
->valuelen
;
1571 xfs_trans_log_buf(args
->trans
, bp
,
1572 XFS_DA_LOGRANGE(leaf
, xfs_attr3_leaf_name(leaf
, args
->index
),
1573 xfs_attr_leaf_entsize(leaf
, args
->index
)));
1576 * Update the control info for this leaf node
1578 if (be16_to_cpu(entry
->nameidx
) < ichdr
->firstused
)
1579 ichdr
->firstused
= be16_to_cpu(entry
->nameidx
);
1581 ASSERT(ichdr
->firstused
>= ichdr
->count
* sizeof(xfs_attr_leaf_entry_t
)
1582 + xfs_attr3_leaf_hdr_size(leaf
));
1583 tmp
= (ichdr
->count
- 1) * sizeof(xfs_attr_leaf_entry_t
)
1584 + xfs_attr3_leaf_hdr_size(leaf
);
1586 for (i
= 0; i
< XFS_ATTR_LEAF_MAPSIZE
; i
++) {
1587 if (ichdr
->freemap
[i
].base
== tmp
) {
1588 ichdr
->freemap
[i
].base
+= sizeof(xfs_attr_leaf_entry_t
);
1589 ichdr
->freemap
[i
].size
-=
1590 min_t(uint16_t, ichdr
->freemap
[i
].size
,
1591 sizeof(xfs_attr_leaf_entry_t
));
1594 ichdr
->usedbytes
+= xfs_attr_leaf_entsize(leaf
, args
->index
);
1599 * Garbage collect a leaf attribute list block by copying it to a new buffer.
1602 xfs_attr3_leaf_compact(
1603 struct xfs_da_args
*args
,
1604 struct xfs_attr3_icleaf_hdr
*ichdr_dst
,
1607 struct xfs_attr_leafblock
*leaf_src
;
1608 struct xfs_attr_leafblock
*leaf_dst
;
1609 struct xfs_attr3_icleaf_hdr ichdr_src
;
1610 struct xfs_trans
*trans
= args
->trans
;
1613 trace_xfs_attr_leaf_compact(args
);
1615 tmpbuffer
= kmem_alloc(args
->geo
->blksize
, 0);
1616 memcpy(tmpbuffer
, bp
->b_addr
, args
->geo
->blksize
);
1617 memset(bp
->b_addr
, 0, args
->geo
->blksize
);
1618 leaf_src
= (xfs_attr_leafblock_t
*)tmpbuffer
;
1619 leaf_dst
= bp
->b_addr
;
1622 * Copy the on-disk header back into the destination buffer to ensure
1623 * all the information in the header that is not part of the incore
1624 * header structure is preserved.
1626 memcpy(bp
->b_addr
, tmpbuffer
, xfs_attr3_leaf_hdr_size(leaf_src
));
1628 /* Initialise the incore headers */
1629 ichdr_src
= *ichdr_dst
; /* struct copy */
1630 ichdr_dst
->firstused
= args
->geo
->blksize
;
1631 ichdr_dst
->usedbytes
= 0;
1632 ichdr_dst
->count
= 0;
1633 ichdr_dst
->holes
= 0;
1634 ichdr_dst
->freemap
[0].base
= xfs_attr3_leaf_hdr_size(leaf_src
);
1635 ichdr_dst
->freemap
[0].size
= ichdr_dst
->firstused
-
1636 ichdr_dst
->freemap
[0].base
;
1638 /* write the header back to initialise the underlying buffer */
1639 xfs_attr3_leaf_hdr_to_disk(args
->geo
, leaf_dst
, ichdr_dst
);
1642 * Copy all entry's in the same (sorted) order,
1643 * but allocate name/value pairs packed and in sequence.
1645 xfs_attr3_leaf_moveents(args
, leaf_src
, &ichdr_src
, 0,
1646 leaf_dst
, ichdr_dst
, 0, ichdr_src
.count
);
1648 * this logs the entire buffer, but the caller must write the header
1649 * back to the buffer when it is finished modifying it.
1651 xfs_trans_log_buf(trans
, bp
, 0, args
->geo
->blksize
- 1);
1653 kmem_free(tmpbuffer
);
1657 * Compare two leaf blocks "order".
1658 * Return 0 unless leaf2 should go before leaf1.
1661 xfs_attr3_leaf_order(
1662 struct xfs_buf
*leaf1_bp
,
1663 struct xfs_attr3_icleaf_hdr
*leaf1hdr
,
1664 struct xfs_buf
*leaf2_bp
,
1665 struct xfs_attr3_icleaf_hdr
*leaf2hdr
)
1667 struct xfs_attr_leaf_entry
*entries1
;
1668 struct xfs_attr_leaf_entry
*entries2
;
1670 entries1
= xfs_attr3_leaf_entryp(leaf1_bp
->b_addr
);
1671 entries2
= xfs_attr3_leaf_entryp(leaf2_bp
->b_addr
);
1672 if (leaf1hdr
->count
> 0 && leaf2hdr
->count
> 0 &&
1673 ((be32_to_cpu(entries2
[0].hashval
) <
1674 be32_to_cpu(entries1
[0].hashval
)) ||
1675 (be32_to_cpu(entries2
[leaf2hdr
->count
- 1].hashval
) <
1676 be32_to_cpu(entries1
[leaf1hdr
->count
- 1].hashval
)))) {
1683 xfs_attr_leaf_order(
1684 struct xfs_buf
*leaf1_bp
,
1685 struct xfs_buf
*leaf2_bp
)
1687 struct xfs_attr3_icleaf_hdr ichdr1
;
1688 struct xfs_attr3_icleaf_hdr ichdr2
;
1689 struct xfs_mount
*mp
= leaf1_bp
->b_mount
;
1691 xfs_attr3_leaf_hdr_from_disk(mp
->m_attr_geo
, &ichdr1
, leaf1_bp
->b_addr
);
1692 xfs_attr3_leaf_hdr_from_disk(mp
->m_attr_geo
, &ichdr2
, leaf2_bp
->b_addr
);
1693 return xfs_attr3_leaf_order(leaf1_bp
, &ichdr1
, leaf2_bp
, &ichdr2
);
1697 * Redistribute the attribute list entries between two leaf nodes,
1698 * taking into account the size of the new entry.
1700 * NOTE: if new block is empty, then it will get the upper half of the
1701 * old block. At present, all (one) callers pass in an empty second block.
1703 * This code adjusts the args->index/blkno and args->index2/blkno2 fields
1704 * to match what it is doing in splitting the attribute leaf block. Those
1705 * values are used in "atomic rename" operations on attributes. Note that
1706 * the "new" and "old" values can end up in different blocks.
1709 xfs_attr3_leaf_rebalance(
1710 struct xfs_da_state
*state
,
1711 struct xfs_da_state_blk
*blk1
,
1712 struct xfs_da_state_blk
*blk2
)
1714 struct xfs_da_args
*args
;
1715 struct xfs_attr_leafblock
*leaf1
;
1716 struct xfs_attr_leafblock
*leaf2
;
1717 struct xfs_attr3_icleaf_hdr ichdr1
;
1718 struct xfs_attr3_icleaf_hdr ichdr2
;
1719 struct xfs_attr_leaf_entry
*entries1
;
1720 struct xfs_attr_leaf_entry
*entries2
;
1728 * Set up environment.
1730 ASSERT(blk1
->magic
== XFS_ATTR_LEAF_MAGIC
);
1731 ASSERT(blk2
->magic
== XFS_ATTR_LEAF_MAGIC
);
1732 leaf1
= blk1
->bp
->b_addr
;
1733 leaf2
= blk2
->bp
->b_addr
;
1734 xfs_attr3_leaf_hdr_from_disk(state
->args
->geo
, &ichdr1
, leaf1
);
1735 xfs_attr3_leaf_hdr_from_disk(state
->args
->geo
, &ichdr2
, leaf2
);
1736 ASSERT(ichdr2
.count
== 0);
1739 trace_xfs_attr_leaf_rebalance(args
);
1742 * Check ordering of blocks, reverse if it makes things simpler.
1744 * NOTE: Given that all (current) callers pass in an empty
1745 * second block, this code should never set "swap".
1748 if (xfs_attr3_leaf_order(blk1
->bp
, &ichdr1
, blk2
->bp
, &ichdr2
)) {
1751 /* swap structures rather than reconverting them */
1752 swap(ichdr1
, ichdr2
);
1754 leaf1
= blk1
->bp
->b_addr
;
1755 leaf2
= blk2
->bp
->b_addr
;
1760 * Examine entries until we reduce the absolute difference in
1761 * byte usage between the two blocks to a minimum. Then get
1762 * the direction to copy and the number of elements to move.
1764 * "inleaf" is true if the new entry should be inserted into blk1.
1765 * If "swap" is also true, then reverse the sense of "inleaf".
1767 state
->inleaf
= xfs_attr3_leaf_figure_balance(state
, blk1
, &ichdr1
,
1771 state
->inleaf
= !state
->inleaf
;
1774 * Move any entries required from leaf to leaf:
1776 if (count
< ichdr1
.count
) {
1778 * Figure the total bytes to be added to the destination leaf.
1780 /* number entries being moved */
1781 count
= ichdr1
.count
- count
;
1782 space
= ichdr1
.usedbytes
- totallen
;
1783 space
+= count
* sizeof(xfs_attr_leaf_entry_t
);
1786 * leaf2 is the destination, compact it if it looks tight.
1788 max
= ichdr2
.firstused
- xfs_attr3_leaf_hdr_size(leaf1
);
1789 max
-= ichdr2
.count
* sizeof(xfs_attr_leaf_entry_t
);
1791 xfs_attr3_leaf_compact(args
, &ichdr2
, blk2
->bp
);
1794 * Move high entries from leaf1 to low end of leaf2.
1796 xfs_attr3_leaf_moveents(args
, leaf1
, &ichdr1
,
1797 ichdr1
.count
- count
, leaf2
, &ichdr2
, 0, count
);
1799 } else if (count
> ichdr1
.count
) {
1801 * I assert that since all callers pass in an empty
1802 * second buffer, this code should never execute.
1807 * Figure the total bytes to be added to the destination leaf.
1809 /* number entries being moved */
1810 count
-= ichdr1
.count
;
1811 space
= totallen
- ichdr1
.usedbytes
;
1812 space
+= count
* sizeof(xfs_attr_leaf_entry_t
);
1815 * leaf1 is the destination, compact it if it looks tight.
1817 max
= ichdr1
.firstused
- xfs_attr3_leaf_hdr_size(leaf1
);
1818 max
-= ichdr1
.count
* sizeof(xfs_attr_leaf_entry_t
);
1820 xfs_attr3_leaf_compact(args
, &ichdr1
, blk1
->bp
);
1823 * Move low entries from leaf2 to high end of leaf1.
1825 xfs_attr3_leaf_moveents(args
, leaf2
, &ichdr2
, 0, leaf1
, &ichdr1
,
1826 ichdr1
.count
, count
);
1829 xfs_attr3_leaf_hdr_to_disk(state
->args
->geo
, leaf1
, &ichdr1
);
1830 xfs_attr3_leaf_hdr_to_disk(state
->args
->geo
, leaf2
, &ichdr2
);
1831 xfs_trans_log_buf(args
->trans
, blk1
->bp
, 0, args
->geo
->blksize
- 1);
1832 xfs_trans_log_buf(args
->trans
, blk2
->bp
, 0, args
->geo
->blksize
- 1);
1835 * Copy out last hashval in each block for B-tree code.
1837 entries1
= xfs_attr3_leaf_entryp(leaf1
);
1838 entries2
= xfs_attr3_leaf_entryp(leaf2
);
1839 blk1
->hashval
= be32_to_cpu(entries1
[ichdr1
.count
- 1].hashval
);
1840 blk2
->hashval
= be32_to_cpu(entries2
[ichdr2
.count
- 1].hashval
);
1843 * Adjust the expected index for insertion.
1844 * NOTE: this code depends on the (current) situation that the
1845 * second block was originally empty.
1847 * If the insertion point moved to the 2nd block, we must adjust
1848 * the index. We must also track the entry just following the
1849 * new entry for use in an "atomic rename" operation, that entry
1850 * is always the "old" entry and the "new" entry is what we are
1851 * inserting. The index/blkno fields refer to the "old" entry,
1852 * while the index2/blkno2 fields refer to the "new" entry.
1854 if (blk1
->index
> ichdr1
.count
) {
1855 ASSERT(state
->inleaf
== 0);
1856 blk2
->index
= blk1
->index
- ichdr1
.count
;
1857 args
->index
= args
->index2
= blk2
->index
;
1858 args
->blkno
= args
->blkno2
= blk2
->blkno
;
1859 } else if (blk1
->index
== ichdr1
.count
) {
1860 if (state
->inleaf
) {
1861 args
->index
= blk1
->index
;
1862 args
->blkno
= blk1
->blkno
;
1864 args
->blkno2
= blk2
->blkno
;
1867 * On a double leaf split, the original attr location
1868 * is already stored in blkno2/index2, so don't
1869 * overwrite it overwise we corrupt the tree.
1871 blk2
->index
= blk1
->index
- ichdr1
.count
;
1872 args
->index
= blk2
->index
;
1873 args
->blkno
= blk2
->blkno
;
1874 if (!state
->extravalid
) {
1876 * set the new attr location to match the old
1877 * one and let the higher level split code
1878 * decide where in the leaf to place it.
1880 args
->index2
= blk2
->index
;
1881 args
->blkno2
= blk2
->blkno
;
1885 ASSERT(state
->inleaf
== 1);
1886 args
->index
= args
->index2
= blk1
->index
;
1887 args
->blkno
= args
->blkno2
= blk1
->blkno
;
1892 * Examine entries until we reduce the absolute difference in
1893 * byte usage between the two blocks to a minimum.
1894 * GROT: Is this really necessary? With other than a 512 byte blocksize,
1895 * GROT: there will always be enough room in either block for a new entry.
1896 * GROT: Do a double-split for this case?
1899 xfs_attr3_leaf_figure_balance(
1900 struct xfs_da_state
*state
,
1901 struct xfs_da_state_blk
*blk1
,
1902 struct xfs_attr3_icleaf_hdr
*ichdr1
,
1903 struct xfs_da_state_blk
*blk2
,
1904 struct xfs_attr3_icleaf_hdr
*ichdr2
,
1908 struct xfs_attr_leafblock
*leaf1
= blk1
->bp
->b_addr
;
1909 struct xfs_attr_leafblock
*leaf2
= blk2
->bp
->b_addr
;
1910 struct xfs_attr_leaf_entry
*entry
;
1921 * Examine entries until we reduce the absolute difference in
1922 * byte usage between the two blocks to a minimum.
1924 max
= ichdr1
->count
+ ichdr2
->count
;
1925 half
= (max
+ 1) * sizeof(*entry
);
1926 half
+= ichdr1
->usedbytes
+ ichdr2
->usedbytes
+
1927 xfs_attr_leaf_newentsize(state
->args
, NULL
);
1929 lastdelta
= state
->args
->geo
->blksize
;
1930 entry
= xfs_attr3_leaf_entryp(leaf1
);
1931 for (count
= index
= 0; count
< max
; entry
++, index
++, count
++) {
1933 #define XFS_ATTR_ABS(A) (((A) < 0) ? -(A) : (A))
1935 * The new entry is in the first block, account for it.
1937 if (count
== blk1
->index
) {
1938 tmp
= totallen
+ sizeof(*entry
) +
1939 xfs_attr_leaf_newentsize(state
->args
, NULL
);
1940 if (XFS_ATTR_ABS(half
- tmp
) > lastdelta
)
1942 lastdelta
= XFS_ATTR_ABS(half
- tmp
);
1948 * Wrap around into the second block if necessary.
1950 if (count
== ichdr1
->count
) {
1952 entry
= xfs_attr3_leaf_entryp(leaf1
);
1957 * Figure out if next leaf entry would be too much.
1959 tmp
= totallen
+ sizeof(*entry
) + xfs_attr_leaf_entsize(leaf1
,
1961 if (XFS_ATTR_ABS(half
- tmp
) > lastdelta
)
1963 lastdelta
= XFS_ATTR_ABS(half
- tmp
);
1969 * Calculate the number of usedbytes that will end up in lower block.
1970 * If new entry not in lower block, fix up the count.
1972 totallen
-= count
* sizeof(*entry
);
1974 totallen
-= sizeof(*entry
) +
1975 xfs_attr_leaf_newentsize(state
->args
, NULL
);
1979 *usedbytesarg
= totallen
;
1983 /*========================================================================
1984 * Routines used for shrinking the Btree.
1985 *========================================================================*/
1988 * Check a leaf block and its neighbors to see if the block should be
1989 * collapsed into one or the other neighbor. Always keep the block
1990 * with the smaller block number.
1991 * If the current block is over 50% full, don't try to join it, return 0.
1992 * If the block is empty, fill in the state structure and return 2.
1993 * If it can be collapsed, fill in the state structure and return 1.
1994 * If nothing can be done, return 0.
1996 * GROT: allow for INCOMPLETE entries in calculation.
1999 xfs_attr3_leaf_toosmall(
2000 struct xfs_da_state
*state
,
2003 struct xfs_attr_leafblock
*leaf
;
2004 struct xfs_da_state_blk
*blk
;
2005 struct xfs_attr3_icleaf_hdr ichdr
;
2014 trace_xfs_attr_leaf_toosmall(state
->args
);
2017 * Check for the degenerate case of the block being over 50% full.
2018 * If so, it's not worth even looking to see if we might be able
2019 * to coalesce with a sibling.
2021 blk
= &state
->path
.blk
[ state
->path
.active
-1 ];
2022 leaf
= blk
->bp
->b_addr
;
2023 xfs_attr3_leaf_hdr_from_disk(state
->args
->geo
, &ichdr
, leaf
);
2024 bytes
= xfs_attr3_leaf_hdr_size(leaf
) +
2025 ichdr
.count
* sizeof(xfs_attr_leaf_entry_t
) +
2027 if (bytes
> (state
->args
->geo
->blksize
>> 1)) {
2028 *action
= 0; /* blk over 50%, don't try to join */
2033 * Check for the degenerate case of the block being empty.
2034 * If the block is empty, we'll simply delete it, no need to
2035 * coalesce it with a sibling block. We choose (arbitrarily)
2036 * to merge with the forward block unless it is NULL.
2038 if (ichdr
.count
== 0) {
2040 * Make altpath point to the block we want to keep and
2041 * path point to the block we want to drop (this one).
2043 forward
= (ichdr
.forw
!= 0);
2044 memcpy(&state
->altpath
, &state
->path
, sizeof(state
->path
));
2045 error
= xfs_da3_path_shift(state
, &state
->altpath
, forward
,
2058 * Examine each sibling block to see if we can coalesce with
2059 * at least 25% free space to spare. We need to figure out
2060 * whether to merge with the forward or the backward block.
2061 * We prefer coalescing with the lower numbered sibling so as
2062 * to shrink an attribute list over time.
2064 /* start with smaller blk num */
2065 forward
= ichdr
.forw
< ichdr
.back
;
2066 for (i
= 0; i
< 2; forward
= !forward
, i
++) {
2067 struct xfs_attr3_icleaf_hdr ichdr2
;
2074 error
= xfs_attr3_leaf_read(state
->args
->trans
, state
->args
->dp
,
2079 xfs_attr3_leaf_hdr_from_disk(state
->args
->geo
, &ichdr2
, bp
->b_addr
);
2081 bytes
= state
->args
->geo
->blksize
-
2082 (state
->args
->geo
->blksize
>> 2) -
2083 ichdr
.usedbytes
- ichdr2
.usedbytes
-
2084 ((ichdr
.count
+ ichdr2
.count
) *
2085 sizeof(xfs_attr_leaf_entry_t
)) -
2086 xfs_attr3_leaf_hdr_size(leaf
);
2088 xfs_trans_brelse(state
->args
->trans
, bp
);
2090 break; /* fits with at least 25% to spare */
2098 * Make altpath point to the block we want to keep (the lower
2099 * numbered block) and path point to the block we want to drop.
2101 memcpy(&state
->altpath
, &state
->path
, sizeof(state
->path
));
2102 if (blkno
< blk
->blkno
) {
2103 error
= xfs_da3_path_shift(state
, &state
->altpath
, forward
,
2106 error
= xfs_da3_path_shift(state
, &state
->path
, forward
,
2120 * Remove a name from the leaf attribute list structure.
2122 * Return 1 if leaf is less than 37% full, 0 if >= 37% full.
2123 * If two leaves are 37% full, when combined they will leave 25% free.
2126 xfs_attr3_leaf_remove(
2128 struct xfs_da_args
*args
)
2130 struct xfs_attr_leafblock
*leaf
;
2131 struct xfs_attr3_icleaf_hdr ichdr
;
2132 struct xfs_attr_leaf_entry
*entry
;
2141 trace_xfs_attr_leaf_remove(args
);
2144 xfs_attr3_leaf_hdr_from_disk(args
->geo
, &ichdr
, leaf
);
2146 ASSERT(ichdr
.count
> 0 && ichdr
.count
< args
->geo
->blksize
/ 8);
2147 ASSERT(args
->index
>= 0 && args
->index
< ichdr
.count
);
2148 ASSERT(ichdr
.firstused
>= ichdr
.count
* sizeof(*entry
) +
2149 xfs_attr3_leaf_hdr_size(leaf
));
2151 entry
= &xfs_attr3_leaf_entryp(leaf
)[args
->index
];
2153 ASSERT(be16_to_cpu(entry
->nameidx
) >= ichdr
.firstused
);
2154 ASSERT(be16_to_cpu(entry
->nameidx
) < args
->geo
->blksize
);
2157 * Scan through free region table:
2158 * check for adjacency of free'd entry with an existing one,
2159 * find smallest free region in case we need to replace it,
2160 * adjust any map that borders the entry table,
2162 tablesize
= ichdr
.count
* sizeof(xfs_attr_leaf_entry_t
)
2163 + xfs_attr3_leaf_hdr_size(leaf
);
2164 tmp
= ichdr
.freemap
[0].size
;
2165 before
= after
= -1;
2166 smallest
= XFS_ATTR_LEAF_MAPSIZE
- 1;
2167 entsize
= xfs_attr_leaf_entsize(leaf
, args
->index
);
2168 for (i
= 0; i
< XFS_ATTR_LEAF_MAPSIZE
; i
++) {
2169 ASSERT(ichdr
.freemap
[i
].base
< args
->geo
->blksize
);
2170 ASSERT(ichdr
.freemap
[i
].size
< args
->geo
->blksize
);
2171 if (ichdr
.freemap
[i
].base
== tablesize
) {
2172 ichdr
.freemap
[i
].base
-= sizeof(xfs_attr_leaf_entry_t
);
2173 ichdr
.freemap
[i
].size
+= sizeof(xfs_attr_leaf_entry_t
);
2176 if (ichdr
.freemap
[i
].base
+ ichdr
.freemap
[i
].size
==
2177 be16_to_cpu(entry
->nameidx
)) {
2179 } else if (ichdr
.freemap
[i
].base
==
2180 (be16_to_cpu(entry
->nameidx
) + entsize
)) {
2182 } else if (ichdr
.freemap
[i
].size
< tmp
) {
2183 tmp
= ichdr
.freemap
[i
].size
;
2189 * Coalesce adjacent freemap regions,
2190 * or replace the smallest region.
2192 if ((before
>= 0) || (after
>= 0)) {
2193 if ((before
>= 0) && (after
>= 0)) {
2194 ichdr
.freemap
[before
].size
+= entsize
;
2195 ichdr
.freemap
[before
].size
+= ichdr
.freemap
[after
].size
;
2196 ichdr
.freemap
[after
].base
= 0;
2197 ichdr
.freemap
[after
].size
= 0;
2198 } else if (before
>= 0) {
2199 ichdr
.freemap
[before
].size
+= entsize
;
2201 ichdr
.freemap
[after
].base
= be16_to_cpu(entry
->nameidx
);
2202 ichdr
.freemap
[after
].size
+= entsize
;
2206 * Replace smallest region (if it is smaller than free'd entry)
2208 if (ichdr
.freemap
[smallest
].size
< entsize
) {
2209 ichdr
.freemap
[smallest
].base
= be16_to_cpu(entry
->nameidx
);
2210 ichdr
.freemap
[smallest
].size
= entsize
;
2215 * Did we remove the first entry?
2217 if (be16_to_cpu(entry
->nameidx
) == ichdr
.firstused
)
2223 * Compress the remaining entries and zero out the removed stuff.
2225 memset(xfs_attr3_leaf_name(leaf
, args
->index
), 0, entsize
);
2226 ichdr
.usedbytes
-= entsize
;
2227 xfs_trans_log_buf(args
->trans
, bp
,
2228 XFS_DA_LOGRANGE(leaf
, xfs_attr3_leaf_name(leaf
, args
->index
),
2231 tmp
= (ichdr
.count
- args
->index
) * sizeof(xfs_attr_leaf_entry_t
);
2232 memmove(entry
, entry
+ 1, tmp
);
2234 xfs_trans_log_buf(args
->trans
, bp
,
2235 XFS_DA_LOGRANGE(leaf
, entry
, tmp
+ sizeof(xfs_attr_leaf_entry_t
)));
2237 entry
= &xfs_attr3_leaf_entryp(leaf
)[ichdr
.count
];
2238 memset(entry
, 0, sizeof(xfs_attr_leaf_entry_t
));
2241 * If we removed the first entry, re-find the first used byte
2242 * in the name area. Note that if the entry was the "firstused",
2243 * then we don't have a "hole" in our block resulting from
2244 * removing the name.
2247 tmp
= args
->geo
->blksize
;
2248 entry
= xfs_attr3_leaf_entryp(leaf
);
2249 for (i
= ichdr
.count
- 1; i
>= 0; entry
++, i
--) {
2250 ASSERT(be16_to_cpu(entry
->nameidx
) >= ichdr
.firstused
);
2251 ASSERT(be16_to_cpu(entry
->nameidx
) < args
->geo
->blksize
);
2253 if (be16_to_cpu(entry
->nameidx
) < tmp
)
2254 tmp
= be16_to_cpu(entry
->nameidx
);
2256 ichdr
.firstused
= tmp
;
2257 ASSERT(ichdr
.firstused
!= 0);
2259 ichdr
.holes
= 1; /* mark as needing compaction */
2261 xfs_attr3_leaf_hdr_to_disk(args
->geo
, leaf
, &ichdr
);
2262 xfs_trans_log_buf(args
->trans
, bp
,
2263 XFS_DA_LOGRANGE(leaf
, &leaf
->hdr
,
2264 xfs_attr3_leaf_hdr_size(leaf
)));
2267 * Check if leaf is less than 50% full, caller may want to
2268 * "join" the leaf with a sibling if so.
2270 tmp
= ichdr
.usedbytes
+ xfs_attr3_leaf_hdr_size(leaf
) +
2271 ichdr
.count
* sizeof(xfs_attr_leaf_entry_t
);
2273 return tmp
< args
->geo
->magicpct
; /* leaf is < 37% full */
2277 * Move all the attribute list entries from drop_leaf into save_leaf.
2280 xfs_attr3_leaf_unbalance(
2281 struct xfs_da_state
*state
,
2282 struct xfs_da_state_blk
*drop_blk
,
2283 struct xfs_da_state_blk
*save_blk
)
2285 struct xfs_attr_leafblock
*drop_leaf
= drop_blk
->bp
->b_addr
;
2286 struct xfs_attr_leafblock
*save_leaf
= save_blk
->bp
->b_addr
;
2287 struct xfs_attr3_icleaf_hdr drophdr
;
2288 struct xfs_attr3_icleaf_hdr savehdr
;
2289 struct xfs_attr_leaf_entry
*entry
;
2291 trace_xfs_attr_leaf_unbalance(state
->args
);
2293 xfs_attr3_leaf_hdr_from_disk(state
->args
->geo
, &drophdr
, drop_leaf
);
2294 xfs_attr3_leaf_hdr_from_disk(state
->args
->geo
, &savehdr
, save_leaf
);
2295 entry
= xfs_attr3_leaf_entryp(drop_leaf
);
2298 * Save last hashval from dying block for later Btree fixup.
2300 drop_blk
->hashval
= be32_to_cpu(entry
[drophdr
.count
- 1].hashval
);
2303 * Check if we need a temp buffer, or can we do it in place.
2304 * Note that we don't check "leaf" for holes because we will
2305 * always be dropping it, toosmall() decided that for us already.
2307 if (savehdr
.holes
== 0) {
2309 * dest leaf has no holes, so we add there. May need
2310 * to make some room in the entry array.
2312 if (xfs_attr3_leaf_order(save_blk
->bp
, &savehdr
,
2313 drop_blk
->bp
, &drophdr
)) {
2314 xfs_attr3_leaf_moveents(state
->args
,
2315 drop_leaf
, &drophdr
, 0,
2316 save_leaf
, &savehdr
, 0,
2319 xfs_attr3_leaf_moveents(state
->args
,
2320 drop_leaf
, &drophdr
, 0,
2321 save_leaf
, &savehdr
,
2322 savehdr
.count
, drophdr
.count
);
2326 * Destination has holes, so we make a temporary copy
2327 * of the leaf and add them both to that.
2329 struct xfs_attr_leafblock
*tmp_leaf
;
2330 struct xfs_attr3_icleaf_hdr tmphdr
;
2332 tmp_leaf
= kmem_zalloc(state
->args
->geo
->blksize
, 0);
2335 * Copy the header into the temp leaf so that all the stuff
2336 * not in the incore header is present and gets copied back in
2337 * once we've moved all the entries.
2339 memcpy(tmp_leaf
, save_leaf
, xfs_attr3_leaf_hdr_size(save_leaf
));
2341 memset(&tmphdr
, 0, sizeof(tmphdr
));
2342 tmphdr
.magic
= savehdr
.magic
;
2343 tmphdr
.forw
= savehdr
.forw
;
2344 tmphdr
.back
= savehdr
.back
;
2345 tmphdr
.firstused
= state
->args
->geo
->blksize
;
2347 /* write the header to the temp buffer to initialise it */
2348 xfs_attr3_leaf_hdr_to_disk(state
->args
->geo
, tmp_leaf
, &tmphdr
);
2350 if (xfs_attr3_leaf_order(save_blk
->bp
, &savehdr
,
2351 drop_blk
->bp
, &drophdr
)) {
2352 xfs_attr3_leaf_moveents(state
->args
,
2353 drop_leaf
, &drophdr
, 0,
2354 tmp_leaf
, &tmphdr
, 0,
2356 xfs_attr3_leaf_moveents(state
->args
,
2357 save_leaf
, &savehdr
, 0,
2358 tmp_leaf
, &tmphdr
, tmphdr
.count
,
2361 xfs_attr3_leaf_moveents(state
->args
,
2362 save_leaf
, &savehdr
, 0,
2363 tmp_leaf
, &tmphdr
, 0,
2365 xfs_attr3_leaf_moveents(state
->args
,
2366 drop_leaf
, &drophdr
, 0,
2367 tmp_leaf
, &tmphdr
, tmphdr
.count
,
2370 memcpy(save_leaf
, tmp_leaf
, state
->args
->geo
->blksize
);
2371 savehdr
= tmphdr
; /* struct copy */
2372 kmem_free(tmp_leaf
);
2375 xfs_attr3_leaf_hdr_to_disk(state
->args
->geo
, save_leaf
, &savehdr
);
2376 xfs_trans_log_buf(state
->args
->trans
, save_blk
->bp
, 0,
2377 state
->args
->geo
->blksize
- 1);
2380 * Copy out last hashval in each block for B-tree code.
2382 entry
= xfs_attr3_leaf_entryp(save_leaf
);
2383 save_blk
->hashval
= be32_to_cpu(entry
[savehdr
.count
- 1].hashval
);
2386 /*========================================================================
2387 * Routines used for finding things in the Btree.
2388 *========================================================================*/
2391 * Look up a name in a leaf attribute list structure.
2392 * This is the internal routine, it uses the caller's buffer.
2394 * Note that duplicate keys are allowed, but only check within the
2395 * current leaf node. The Btree code must check in adjacent leaf nodes.
2397 * Return in args->index the index into the entry[] array of either
2398 * the found entry, or where the entry should have been (insert before
2401 * Don't change the args->value unless we find the attribute.
2404 xfs_attr3_leaf_lookup_int(
2406 struct xfs_da_args
*args
)
2408 struct xfs_attr_leafblock
*leaf
;
2409 struct xfs_attr3_icleaf_hdr ichdr
;
2410 struct xfs_attr_leaf_entry
*entry
;
2411 struct xfs_attr_leaf_entry
*entries
;
2412 struct xfs_attr_leaf_name_local
*name_loc
;
2413 struct xfs_attr_leaf_name_remote
*name_rmt
;
2414 xfs_dahash_t hashval
;
2418 trace_xfs_attr_leaf_lookup(args
);
2421 xfs_attr3_leaf_hdr_from_disk(args
->geo
, &ichdr
, leaf
);
2422 entries
= xfs_attr3_leaf_entryp(leaf
);
2423 if (ichdr
.count
>= args
->geo
->blksize
/ 8) {
2424 xfs_buf_mark_corrupt(bp
);
2425 return -EFSCORRUPTED
;
2429 * Binary search. (note: small blocks will skip this loop)
2431 hashval
= args
->hashval
;
2432 probe
= span
= ichdr
.count
/ 2;
2433 for (entry
= &entries
[probe
]; span
> 4; entry
= &entries
[probe
]) {
2435 if (be32_to_cpu(entry
->hashval
) < hashval
)
2437 else if (be32_to_cpu(entry
->hashval
) > hashval
)
2442 if (!(probe
>= 0 && (!ichdr
.count
|| probe
< ichdr
.count
))) {
2443 xfs_buf_mark_corrupt(bp
);
2444 return -EFSCORRUPTED
;
2446 if (!(span
<= 4 || be32_to_cpu(entry
->hashval
) == hashval
)) {
2447 xfs_buf_mark_corrupt(bp
);
2448 return -EFSCORRUPTED
;
2452 * Since we may have duplicate hashval's, find the first matching
2453 * hashval in the leaf.
2455 while (probe
> 0 && be32_to_cpu(entry
->hashval
) >= hashval
) {
2459 while (probe
< ichdr
.count
&&
2460 be32_to_cpu(entry
->hashval
) < hashval
) {
2464 if (probe
== ichdr
.count
|| be32_to_cpu(entry
->hashval
) != hashval
) {
2465 args
->index
= probe
;
2470 * Duplicate keys may be present, so search all of them for a match.
2472 for (; probe
< ichdr
.count
&& (be32_to_cpu(entry
->hashval
) == hashval
);
2475 * GROT: Add code to remove incomplete entries.
2477 if (entry
->flags
& XFS_ATTR_LOCAL
) {
2478 name_loc
= xfs_attr3_leaf_name_local(leaf
, probe
);
2479 if (!xfs_attr_match(args
, name_loc
->namelen
,
2480 name_loc
->nameval
, entry
->flags
))
2482 args
->index
= probe
;
2485 name_rmt
= xfs_attr3_leaf_name_remote(leaf
, probe
);
2486 if (!xfs_attr_match(args
, name_rmt
->namelen
,
2487 name_rmt
->name
, entry
->flags
))
2489 args
->index
= probe
;
2490 args
->rmtvaluelen
= be32_to_cpu(name_rmt
->valuelen
);
2491 args
->rmtblkno
= be32_to_cpu(name_rmt
->valueblk
);
2492 args
->rmtblkcnt
= xfs_attr3_rmt_blocks(
2498 args
->index
= probe
;
2503 * Get the value associated with an attribute name from a leaf attribute
2506 * If args->valuelen is zero, only the length needs to be returned. Unlike a
2507 * lookup, we only return an error if the attribute does not exist or we can't
2508 * retrieve the value.
2511 xfs_attr3_leaf_getvalue(
2513 struct xfs_da_args
*args
)
2515 struct xfs_attr_leafblock
*leaf
;
2516 struct xfs_attr3_icleaf_hdr ichdr
;
2517 struct xfs_attr_leaf_entry
*entry
;
2518 struct xfs_attr_leaf_name_local
*name_loc
;
2519 struct xfs_attr_leaf_name_remote
*name_rmt
;
2522 xfs_attr3_leaf_hdr_from_disk(args
->geo
, &ichdr
, leaf
);
2523 ASSERT(ichdr
.count
< args
->geo
->blksize
/ 8);
2524 ASSERT(args
->index
< ichdr
.count
);
2526 entry
= &xfs_attr3_leaf_entryp(leaf
)[args
->index
];
2527 if (entry
->flags
& XFS_ATTR_LOCAL
) {
2528 name_loc
= xfs_attr3_leaf_name_local(leaf
, args
->index
);
2529 ASSERT(name_loc
->namelen
== args
->namelen
);
2530 ASSERT(memcmp(args
->name
, name_loc
->nameval
, args
->namelen
) == 0);
2531 return xfs_attr_copy_value(args
,
2532 &name_loc
->nameval
[args
->namelen
],
2533 be16_to_cpu(name_loc
->valuelen
));
2536 name_rmt
= xfs_attr3_leaf_name_remote(leaf
, args
->index
);
2537 ASSERT(name_rmt
->namelen
== args
->namelen
);
2538 ASSERT(memcmp(args
->name
, name_rmt
->name
, args
->namelen
) == 0);
2539 args
->rmtvaluelen
= be32_to_cpu(name_rmt
->valuelen
);
2540 args
->rmtblkno
= be32_to_cpu(name_rmt
->valueblk
);
2541 args
->rmtblkcnt
= xfs_attr3_rmt_blocks(args
->dp
->i_mount
,
2543 return xfs_attr_copy_value(args
, NULL
, args
->rmtvaluelen
);
2546 /*========================================================================
2548 *========================================================================*/
2551 * Move the indicated entries from one leaf to another.
2552 * NOTE: this routine modifies both source and destination leaves.
2556 xfs_attr3_leaf_moveents(
2557 struct xfs_da_args
*args
,
2558 struct xfs_attr_leafblock
*leaf_s
,
2559 struct xfs_attr3_icleaf_hdr
*ichdr_s
,
2561 struct xfs_attr_leafblock
*leaf_d
,
2562 struct xfs_attr3_icleaf_hdr
*ichdr_d
,
2566 struct xfs_attr_leaf_entry
*entry_s
;
2567 struct xfs_attr_leaf_entry
*entry_d
;
2573 * Check for nothing to do.
2579 * Set up environment.
2581 ASSERT(ichdr_s
->magic
== XFS_ATTR_LEAF_MAGIC
||
2582 ichdr_s
->magic
== XFS_ATTR3_LEAF_MAGIC
);
2583 ASSERT(ichdr_s
->magic
== ichdr_d
->magic
);
2584 ASSERT(ichdr_s
->count
> 0 && ichdr_s
->count
< args
->geo
->blksize
/ 8);
2585 ASSERT(ichdr_s
->firstused
>= (ichdr_s
->count
* sizeof(*entry_s
))
2586 + xfs_attr3_leaf_hdr_size(leaf_s
));
2587 ASSERT(ichdr_d
->count
< args
->geo
->blksize
/ 8);
2588 ASSERT(ichdr_d
->firstused
>= (ichdr_d
->count
* sizeof(*entry_d
))
2589 + xfs_attr3_leaf_hdr_size(leaf_d
));
2591 ASSERT(start_s
< ichdr_s
->count
);
2592 ASSERT(start_d
<= ichdr_d
->count
);
2593 ASSERT(count
<= ichdr_s
->count
);
2597 * Move the entries in the destination leaf up to make a hole?
2599 if (start_d
< ichdr_d
->count
) {
2600 tmp
= ichdr_d
->count
- start_d
;
2601 tmp
*= sizeof(xfs_attr_leaf_entry_t
);
2602 entry_s
= &xfs_attr3_leaf_entryp(leaf_d
)[start_d
];
2603 entry_d
= &xfs_attr3_leaf_entryp(leaf_d
)[start_d
+ count
];
2604 memmove(entry_d
, entry_s
, tmp
);
2608 * Copy all entry's in the same (sorted) order,
2609 * but allocate attribute info packed and in sequence.
2611 entry_s
= &xfs_attr3_leaf_entryp(leaf_s
)[start_s
];
2612 entry_d
= &xfs_attr3_leaf_entryp(leaf_d
)[start_d
];
2614 for (i
= 0; i
< count
; entry_s
++, entry_d
++, desti
++, i
++) {
2615 ASSERT(be16_to_cpu(entry_s
->nameidx
) >= ichdr_s
->firstused
);
2616 tmp
= xfs_attr_leaf_entsize(leaf_s
, start_s
+ i
);
2619 * Code to drop INCOMPLETE entries. Difficult to use as we
2620 * may also need to change the insertion index. Code turned
2621 * off for 6.2, should be revisited later.
2623 if (entry_s
->flags
& XFS_ATTR_INCOMPLETE
) { /* skip partials? */
2624 memset(xfs_attr3_leaf_name(leaf_s
, start_s
+ i
), 0, tmp
);
2625 ichdr_s
->usedbytes
-= tmp
;
2626 ichdr_s
->count
-= 1;
2627 entry_d
--; /* to compensate for ++ in loop hdr */
2629 if ((start_s
+ i
) < offset
)
2630 result
++; /* insertion index adjustment */
2633 ichdr_d
->firstused
-= tmp
;
2634 /* both on-disk, don't endian flip twice */
2635 entry_d
->hashval
= entry_s
->hashval
;
2636 entry_d
->nameidx
= cpu_to_be16(ichdr_d
->firstused
);
2637 entry_d
->flags
= entry_s
->flags
;
2638 ASSERT(be16_to_cpu(entry_d
->nameidx
) + tmp
2639 <= args
->geo
->blksize
);
2640 memmove(xfs_attr3_leaf_name(leaf_d
, desti
),
2641 xfs_attr3_leaf_name(leaf_s
, start_s
+ i
), tmp
);
2642 ASSERT(be16_to_cpu(entry_s
->nameidx
) + tmp
2643 <= args
->geo
->blksize
);
2644 memset(xfs_attr3_leaf_name(leaf_s
, start_s
+ i
), 0, tmp
);
2645 ichdr_s
->usedbytes
-= tmp
;
2646 ichdr_d
->usedbytes
+= tmp
;
2647 ichdr_s
->count
-= 1;
2648 ichdr_d
->count
+= 1;
2649 tmp
= ichdr_d
->count
* sizeof(xfs_attr_leaf_entry_t
)
2650 + xfs_attr3_leaf_hdr_size(leaf_d
);
2651 ASSERT(ichdr_d
->firstused
>= tmp
);
2658 * Zero out the entries we just copied.
2660 if (start_s
== ichdr_s
->count
) {
2661 tmp
= count
* sizeof(xfs_attr_leaf_entry_t
);
2662 entry_s
= &xfs_attr3_leaf_entryp(leaf_s
)[start_s
];
2663 ASSERT(((char *)entry_s
+ tmp
) <=
2664 ((char *)leaf_s
+ args
->geo
->blksize
));
2665 memset(entry_s
, 0, tmp
);
2668 * Move the remaining entries down to fill the hole,
2669 * then zero the entries at the top.
2671 tmp
= (ichdr_s
->count
- count
) * sizeof(xfs_attr_leaf_entry_t
);
2672 entry_s
= &xfs_attr3_leaf_entryp(leaf_s
)[start_s
+ count
];
2673 entry_d
= &xfs_attr3_leaf_entryp(leaf_s
)[start_s
];
2674 memmove(entry_d
, entry_s
, tmp
);
2676 tmp
= count
* sizeof(xfs_attr_leaf_entry_t
);
2677 entry_s
= &xfs_attr3_leaf_entryp(leaf_s
)[ichdr_s
->count
];
2678 ASSERT(((char *)entry_s
+ tmp
) <=
2679 ((char *)leaf_s
+ args
->geo
->blksize
));
2680 memset(entry_s
, 0, tmp
);
2684 * Fill in the freemap information
2686 ichdr_d
->freemap
[0].base
= xfs_attr3_leaf_hdr_size(leaf_d
);
2687 ichdr_d
->freemap
[0].base
+= ichdr_d
->count
* sizeof(xfs_attr_leaf_entry_t
);
2688 ichdr_d
->freemap
[0].size
= ichdr_d
->firstused
- ichdr_d
->freemap
[0].base
;
2689 ichdr_d
->freemap
[1].base
= 0;
2690 ichdr_d
->freemap
[2].base
= 0;
2691 ichdr_d
->freemap
[1].size
= 0;
2692 ichdr_d
->freemap
[2].size
= 0;
2693 ichdr_s
->holes
= 1; /* leaf may not be compact */
2697 * Pick up the last hashvalue from a leaf block.
2700 xfs_attr_leaf_lasthash(
2704 struct xfs_attr3_icleaf_hdr ichdr
;
2705 struct xfs_attr_leaf_entry
*entries
;
2706 struct xfs_mount
*mp
= bp
->b_mount
;
2708 xfs_attr3_leaf_hdr_from_disk(mp
->m_attr_geo
, &ichdr
, bp
->b_addr
);
2709 entries
= xfs_attr3_leaf_entryp(bp
->b_addr
);
2711 *count
= ichdr
.count
;
2714 return be32_to_cpu(entries
[ichdr
.count
- 1].hashval
);
2718 * Calculate the number of bytes used to store the indicated attribute
2719 * (whether local or remote only calculate bytes in this block).
2722 xfs_attr_leaf_entsize(xfs_attr_leafblock_t
*leaf
, int index
)
2724 struct xfs_attr_leaf_entry
*entries
;
2725 xfs_attr_leaf_name_local_t
*name_loc
;
2726 xfs_attr_leaf_name_remote_t
*name_rmt
;
2729 entries
= xfs_attr3_leaf_entryp(leaf
);
2730 if (entries
[index
].flags
& XFS_ATTR_LOCAL
) {
2731 name_loc
= xfs_attr3_leaf_name_local(leaf
, index
);
2732 size
= xfs_attr_leaf_entsize_local(name_loc
->namelen
,
2733 be16_to_cpu(name_loc
->valuelen
));
2735 name_rmt
= xfs_attr3_leaf_name_remote(leaf
, index
);
2736 size
= xfs_attr_leaf_entsize_remote(name_rmt
->namelen
);
2742 * Calculate the number of bytes that would be required to store the new
2743 * attribute (whether local or remote only calculate bytes in this block).
2744 * This routine decides as a side effect whether the attribute will be
2745 * a "local" or a "remote" attribute.
2748 xfs_attr_leaf_newentsize(
2749 struct xfs_da_args
*args
,
2754 size
= xfs_attr_leaf_entsize_local(args
->namelen
, args
->valuelen
);
2755 if (size
< xfs_attr_leaf_entsize_local_max(args
->geo
->blksize
)) {
2762 return xfs_attr_leaf_entsize_remote(args
->namelen
);
2766 /*========================================================================
2767 * Manage the INCOMPLETE flag in a leaf entry
2768 *========================================================================*/
2771 * Clear the INCOMPLETE flag on an entry in a leaf block.
2774 xfs_attr3_leaf_clearflag(
2775 struct xfs_da_args
*args
)
2777 struct xfs_attr_leafblock
*leaf
;
2778 struct xfs_attr_leaf_entry
*entry
;
2779 struct xfs_attr_leaf_name_remote
*name_rmt
;
2783 struct xfs_attr3_icleaf_hdr ichdr
;
2784 xfs_attr_leaf_name_local_t
*name_loc
;
2789 trace_xfs_attr_leaf_clearflag(args
);
2791 * Set up the operation.
2793 error
= xfs_attr3_leaf_read(args
->trans
, args
->dp
, args
->blkno
, &bp
);
2798 entry
= &xfs_attr3_leaf_entryp(leaf
)[args
->index
];
2799 ASSERT(entry
->flags
& XFS_ATTR_INCOMPLETE
);
2802 xfs_attr3_leaf_hdr_from_disk(args
->geo
, &ichdr
, leaf
);
2803 ASSERT(args
->index
< ichdr
.count
);
2804 ASSERT(args
->index
>= 0);
2806 if (entry
->flags
& XFS_ATTR_LOCAL
) {
2807 name_loc
= xfs_attr3_leaf_name_local(leaf
, args
->index
);
2808 namelen
= name_loc
->namelen
;
2809 name
= (char *)name_loc
->nameval
;
2811 name_rmt
= xfs_attr3_leaf_name_remote(leaf
, args
->index
);
2812 namelen
= name_rmt
->namelen
;
2813 name
= (char *)name_rmt
->name
;
2815 ASSERT(be32_to_cpu(entry
->hashval
) == args
->hashval
);
2816 ASSERT(namelen
== args
->namelen
);
2817 ASSERT(memcmp(name
, args
->name
, namelen
) == 0);
2820 entry
->flags
&= ~XFS_ATTR_INCOMPLETE
;
2821 xfs_trans_log_buf(args
->trans
, bp
,
2822 XFS_DA_LOGRANGE(leaf
, entry
, sizeof(*entry
)));
2824 if (args
->rmtblkno
) {
2825 ASSERT((entry
->flags
& XFS_ATTR_LOCAL
) == 0);
2826 name_rmt
= xfs_attr3_leaf_name_remote(leaf
, args
->index
);
2827 name_rmt
->valueblk
= cpu_to_be32(args
->rmtblkno
);
2828 name_rmt
->valuelen
= cpu_to_be32(args
->rmtvaluelen
);
2829 xfs_trans_log_buf(args
->trans
, bp
,
2830 XFS_DA_LOGRANGE(leaf
, name_rmt
, sizeof(*name_rmt
)));
2837 * Set the INCOMPLETE flag on an entry in a leaf block.
2840 xfs_attr3_leaf_setflag(
2841 struct xfs_da_args
*args
)
2843 struct xfs_attr_leafblock
*leaf
;
2844 struct xfs_attr_leaf_entry
*entry
;
2845 struct xfs_attr_leaf_name_remote
*name_rmt
;
2849 struct xfs_attr3_icleaf_hdr ichdr
;
2852 trace_xfs_attr_leaf_setflag(args
);
2855 * Set up the operation.
2857 error
= xfs_attr3_leaf_read(args
->trans
, args
->dp
, args
->blkno
, &bp
);
2863 xfs_attr3_leaf_hdr_from_disk(args
->geo
, &ichdr
, leaf
);
2864 ASSERT(args
->index
< ichdr
.count
);
2865 ASSERT(args
->index
>= 0);
2867 entry
= &xfs_attr3_leaf_entryp(leaf
)[args
->index
];
2869 ASSERT((entry
->flags
& XFS_ATTR_INCOMPLETE
) == 0);
2870 entry
->flags
|= XFS_ATTR_INCOMPLETE
;
2871 xfs_trans_log_buf(args
->trans
, bp
,
2872 XFS_DA_LOGRANGE(leaf
, entry
, sizeof(*entry
)));
2873 if ((entry
->flags
& XFS_ATTR_LOCAL
) == 0) {
2874 name_rmt
= xfs_attr3_leaf_name_remote(leaf
, args
->index
);
2875 name_rmt
->valueblk
= 0;
2876 name_rmt
->valuelen
= 0;
2877 xfs_trans_log_buf(args
->trans
, bp
,
2878 XFS_DA_LOGRANGE(leaf
, name_rmt
, sizeof(*name_rmt
)));
2885 * In a single transaction, clear the INCOMPLETE flag on the leaf entry
2886 * given by args->blkno/index and set the INCOMPLETE flag on the leaf
2887 * entry given by args->blkno2/index2.
2889 * Note that they could be in different blocks, or in the same block.
2892 xfs_attr3_leaf_flipflags(
2893 struct xfs_da_args
*args
)
2895 struct xfs_attr_leafblock
*leaf1
;
2896 struct xfs_attr_leafblock
*leaf2
;
2897 struct xfs_attr_leaf_entry
*entry1
;
2898 struct xfs_attr_leaf_entry
*entry2
;
2899 struct xfs_attr_leaf_name_remote
*name_rmt
;
2900 struct xfs_buf
*bp1
;
2901 struct xfs_buf
*bp2
;
2904 struct xfs_attr3_icleaf_hdr ichdr1
;
2905 struct xfs_attr3_icleaf_hdr ichdr2
;
2906 xfs_attr_leaf_name_local_t
*name_loc
;
2907 int namelen1
, namelen2
;
2908 char *name1
, *name2
;
2911 trace_xfs_attr_leaf_flipflags(args
);
2914 * Read the block containing the "old" attr
2916 error
= xfs_attr3_leaf_read(args
->trans
, args
->dp
, args
->blkno
, &bp1
);
2921 * Read the block containing the "new" attr, if it is different
2923 if (args
->blkno2
!= args
->blkno
) {
2924 error
= xfs_attr3_leaf_read(args
->trans
, args
->dp
, args
->blkno2
,
2932 leaf1
= bp1
->b_addr
;
2933 entry1
= &xfs_attr3_leaf_entryp(leaf1
)[args
->index
];
2935 leaf2
= bp2
->b_addr
;
2936 entry2
= &xfs_attr3_leaf_entryp(leaf2
)[args
->index2
];
2939 xfs_attr3_leaf_hdr_from_disk(args
->geo
, &ichdr1
, leaf1
);
2940 ASSERT(args
->index
< ichdr1
.count
);
2941 ASSERT(args
->index
>= 0);
2943 xfs_attr3_leaf_hdr_from_disk(args
->geo
, &ichdr2
, leaf2
);
2944 ASSERT(args
->index2
< ichdr2
.count
);
2945 ASSERT(args
->index2
>= 0);
2947 if (entry1
->flags
& XFS_ATTR_LOCAL
) {
2948 name_loc
= xfs_attr3_leaf_name_local(leaf1
, args
->index
);
2949 namelen1
= name_loc
->namelen
;
2950 name1
= (char *)name_loc
->nameval
;
2952 name_rmt
= xfs_attr3_leaf_name_remote(leaf1
, args
->index
);
2953 namelen1
= name_rmt
->namelen
;
2954 name1
= (char *)name_rmt
->name
;
2956 if (entry2
->flags
& XFS_ATTR_LOCAL
) {
2957 name_loc
= xfs_attr3_leaf_name_local(leaf2
, args
->index2
);
2958 namelen2
= name_loc
->namelen
;
2959 name2
= (char *)name_loc
->nameval
;
2961 name_rmt
= xfs_attr3_leaf_name_remote(leaf2
, args
->index2
);
2962 namelen2
= name_rmt
->namelen
;
2963 name2
= (char *)name_rmt
->name
;
2965 ASSERT(be32_to_cpu(entry1
->hashval
) == be32_to_cpu(entry2
->hashval
));
2966 ASSERT(namelen1
== namelen2
);
2967 ASSERT(memcmp(name1
, name2
, namelen1
) == 0);
2970 ASSERT(entry1
->flags
& XFS_ATTR_INCOMPLETE
);
2971 ASSERT((entry2
->flags
& XFS_ATTR_INCOMPLETE
) == 0);
2973 entry1
->flags
&= ~XFS_ATTR_INCOMPLETE
;
2974 xfs_trans_log_buf(args
->trans
, bp1
,
2975 XFS_DA_LOGRANGE(leaf1
, entry1
, sizeof(*entry1
)));
2976 if (args
->rmtblkno
) {
2977 ASSERT((entry1
->flags
& XFS_ATTR_LOCAL
) == 0);
2978 name_rmt
= xfs_attr3_leaf_name_remote(leaf1
, args
->index
);
2979 name_rmt
->valueblk
= cpu_to_be32(args
->rmtblkno
);
2980 name_rmt
->valuelen
= cpu_to_be32(args
->rmtvaluelen
);
2981 xfs_trans_log_buf(args
->trans
, bp1
,
2982 XFS_DA_LOGRANGE(leaf1
, name_rmt
, sizeof(*name_rmt
)));
2985 entry2
->flags
|= XFS_ATTR_INCOMPLETE
;
2986 xfs_trans_log_buf(args
->trans
, bp2
,
2987 XFS_DA_LOGRANGE(leaf2
, entry2
, sizeof(*entry2
)));
2988 if ((entry2
->flags
& XFS_ATTR_LOCAL
) == 0) {
2989 name_rmt
= xfs_attr3_leaf_name_remote(leaf2
, args
->index2
);
2990 name_rmt
->valueblk
= 0;
2991 name_rmt
->valuelen
= 0;
2992 xfs_trans_log_buf(args
->trans
, bp2
,
2993 XFS_DA_LOGRANGE(leaf2
, name_rmt
, sizeof(*name_rmt
)));