projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
xfs: add lots of attribute trace points
[deliverable/linux.git] / fs / xfs / xfs_attr_leaf.c
CommitLineData
1da177e4 1/*
7b718769
NS		 2 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
3 * All Rights Reserved.
1da177e4 4 *
7b718769
NS		 5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
1da177e4
LT		 7 * published by the Free Software Foundation.
8 *
7b718769
NS		 9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
1da177e4 13 *
7b718769
NS		 14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
1da177e4 17 */
1da177e4 18#include "xfs.h"
a844f451 19#include "xfs_fs.h"
1da177e4 20#include "xfs_types.h"
a844f451 21#include "xfs_bit.h"
1da177e4 22#include "xfs_log.h"
a844f451 23#include "xfs_inum.h"
1da177e4
LT		 24#include "xfs_trans.h"
25#include "xfs_sb.h"
26#include "xfs_ag.h"
1da177e4 27#include "xfs_mount.h"
a844f451 28#include "xfs_da_btree.h"
1da177e4 29#include "xfs_bmap_btree.h"
a844f451 30#include "xfs_alloc_btree.h"
1da177e4
LT		 31#include "xfs_ialloc_btree.h"
32#include "xfs_alloc.h"
33#include "xfs_btree.h"
a844f451 34#include "xfs_attr_sf.h"
1da177e4 35#include "xfs_dinode.h"
1da177e4 36#include "xfs_inode.h"
a844f451 37#include "xfs_inode_item.h"
1da177e4 38#include "xfs_bmap.h"
1da177e4
LT		 39#include "xfs_attr.h"
40#include "xfs_attr_leaf.h"
41#include "xfs_error.h"
0b1b213f 42#include "xfs_trace.h"
1da177e4
LT		 43
44/*
45 * xfs_attr_leaf.c
46 *
47 * Routines to implement leaf blocks of attributes as Btrees of hashed names.
48 */
49
50/*========================================================================
51 * Function prototypes for the kernel.
52 *========================================================================*/
53
54/*
55 * Routines used for growing the Btree.
56 */
ba0f32d4
CH		 57STATIC int xfs_attr_leaf_create(xfs_da_args_t *args, xfs_dablk_t which_block,
58 xfs_dabuf_t **bpp);
1da177e4
LT		 59STATIC int xfs_attr_leaf_add_work(xfs_dabuf_t *leaf_buffer, xfs_da_args_t *args,
60 int freemap_index);
61STATIC void xfs_attr_leaf_compact(xfs_trans_t *trans, xfs_dabuf_t *leaf_buffer);
62STATIC void xfs_attr_leaf_rebalance(xfs_da_state_t *state,
63 xfs_da_state_blk_t *blk1,
64 xfs_da_state_blk_t *blk2);
65STATIC int xfs_attr_leaf_figure_balance(xfs_da_state_t *state,
66 xfs_da_state_blk_t *leaf_blk_1,
67 xfs_da_state_blk_t *leaf_blk_2,
68 int *number_entries_in_blk1,
69 int *number_usedbytes_in_blk1);
70
ba0f32d4
CH		 71/*
72 * Routines used for shrinking the Btree.
73 */
74STATIC int xfs_attr_node_inactive(xfs_trans_t **trans, xfs_inode_t *dp,
75 xfs_dabuf_t *bp, int level);
76STATIC int xfs_attr_leaf_inactive(xfs_trans_t **trans, xfs_inode_t *dp,
77 xfs_dabuf_t *bp);
78STATIC int xfs_attr_leaf_freextent(xfs_trans_t **trans, xfs_inode_t *dp,
79 xfs_dablk_t blkno, int blkcnt);
80
1da177e4
LT		 81/*
82 * Utility routines.
83 */
84STATIC void xfs_attr_leaf_moveents(xfs_attr_leafblock_t *src_leaf,
85 int src_start,
86 xfs_attr_leafblock_t *dst_leaf,
87 int dst_start, int move_count,
88 xfs_mount_t *mp);
ba0f32d4 89STATIC int xfs_attr_leaf_entsize(xfs_attr_leafblock_t *leaf, int index);
726801ba
TS		 90
91/*========================================================================
92 * Namespace helper routines
93 *========================================================================*/
94
726801ba
TS		 95/*
96 * If namespace bits don't match return 0.
97 * If all match then return 1.
98 */
b8f82a4a 99STATIC int
726801ba
TS		 100xfs_attr_namesp_match(int arg_flags, int ondisk_flags)
101{
102 return XFS_ATTR_NSP_ONDISK(ondisk_flags) == XFS_ATTR_NSP_ARGS_TO_ONDISK(arg_flags);
103}
104
1da177e4
LT		 105
106/*========================================================================
d8cc890d 107 * External routines when attribute fork size < XFS_LITINO(mp).
1da177e4
LT		 108 *========================================================================*/
109
110/*
d8cc890d
NS		 111 * Query whether the requested number of additional bytes of extended
112 * attribute space will be able to fit inline.
4c393a60 113 *
d8cc890d
NS		 114 * Returns zero if not, else the di_forkoff fork offset to be used in the
115 * literal area for attribute data once the new bytes have been added.
116 *
117 * di_forkoff must be 8 byte aligned, hence is stored as a >>3 value;
118 * special case for dev/uuid inodes, they have fixed size data forks.
1da177e4
LT		 119 */
120int
d8cc890d
NS		 121xfs_attr_shortform_bytesfit(xfs_inode_t *dp, int bytes)
122{
123 int offset;
124 int minforkoff; /* lower limit on valid forkoff locations */
125 int maxforkoff; /* upper limit on valid forkoff locations */
4c393a60 126 int dsize;
d8cc890d
NS		 127 xfs_mount_t *mp = dp->i_mount;
128
d8cc890d
NS		 129 offset = (XFS_LITINO(mp) - bytes) >> 3; /* rounded down */
130
131 switch (dp->i_d.di_format) {
132 case XFS_DINODE_FMT_DEV:
133 minforkoff = roundup(sizeof(xfs_dev_t), 8) >> 3;
134 return (offset >= minforkoff) ? minforkoff : 0;
135 case XFS_DINODE_FMT_UUID:
136 minforkoff = roundup(sizeof(uuid_t), 8) >> 3;
137 return (offset >= minforkoff) ? minforkoff : 0;
138 }
139
4c393a60
CH		 140 /*
141 * If the requested numbers of bytes is smaller or equal to the
142 * current attribute fork size we can always proceed.
143 *
144 * Note that if_bytes in the data fork might actually be larger than
145 * the current data fork size is due to delalloc extents. In that
146 * case either the extent count will go down when they are converted
147 * to real extents, or the delalloc conversion will take care of the
148 * literal area rebalancing.
149 */
150 if (bytes <= XFS_IFORK_ASIZE(dp))
151 return dp->i_d.di_forkoff;
152
153 /*
154 * For attr2 we can try to move the forkoff if there is space in the
155 * literal area, but for the old format we are done if there is no
156 * space in the fixed attribute fork.
157 */
158 if (!(mp->m_flags & XFS_MOUNT_ATTR2))
da087bad 159 return 0;
da087bad 160
e5889e90 161 dsize = dp->i_df.if_bytes;
4c393a60 162
e5889e90
BN		 163 switch (dp->i_d.di_format) {
164 case XFS_DINODE_FMT_EXTENTS:
4c393a60 165 /*
e5889e90 166 * If there is no attr fork and the data fork is extents,
4c393a60
CH		 167 * determine if creating the default attr fork will result
168 * in the extents form migrating to btree. If so, the
169 * minimum offset only needs to be the space required for
e5889e90 170 * the btree root.
4c393a60 171 */
1a5902c5
CH		 172 if (!dp->i_d.di_forkoff && dp->i_df.if_bytes >
173 xfs_default_attroffset(dp))
e5889e90
BN		 174 dsize = XFS_BMDR_SPACE_CALC(MINDBTPTRS);
175 break;
e5889e90
BN		 176 case XFS_DINODE_FMT_BTREE:
177 /*
4c393a60
CH		 178 * If we have a data btree then keep forkoff if we have one,
179 * otherwise we are adding a new attr, so then we set
180 * minforkoff to where the btree root can finish so we have
e5889e90
BN		 181 * plenty of room for attrs
182 */
183 if (dp->i_d.di_forkoff) {
4c393a60 184 if (offset < dp->i_d.di_forkoff)
e5889e90 185 return 0;
4c393a60
CH		 186 return dp->i_d.di_forkoff;
187 }
188 dsize = XFS_BMAP_BROOT_SPACE(dp->i_df.if_broot);
e5889e90
BN		 189 break;
190 }
4c393a60
CH		 191
192 /*
193 * A data fork btree root must have space for at least
e5889e90
BN		 194 * MINDBTPTRS key/ptr pairs if the data fork is small or empty.
195 */
196 minforkoff = MAX(dsize, XFS_BMDR_SPACE_CALC(MINDBTPTRS));
d8cc890d
NS		 197 minforkoff = roundup(minforkoff, 8) >> 3;
198
199 /* attr fork btree root can have at least this many key/ptr pairs */
200 maxforkoff = XFS_LITINO(mp) - XFS_BMDR_SPACE_CALC(MINABTPTRS);
201 maxforkoff = maxforkoff >> 3; /* rounded down */
202
d8cc890d
NS		 203 if (offset >= maxforkoff)
204 return maxforkoff;
4c393a60
CH		 205 if (offset >= minforkoff)
206 return offset;
d8cc890d
NS		 207 return 0;
208}
209
210/*
211 * Switch on the ATTR2 superblock bit (implies also FEATURES2)
212 */
213STATIC void
214xfs_sbversion_add_attr2(xfs_mount_t *mp, xfs_trans_t *tp)
215{
13059ff0 216 if ((mp->m_flags & XFS_MOUNT_ATTR2) &&
62118709 217 !(xfs_sb_version_hasattr2(&mp->m_sb))) {
3685c2a1 218 spin_lock(&mp->m_sb_lock);
62118709
ES		 219 if (!xfs_sb_version_hasattr2(&mp->m_sb)) {
220 xfs_sb_version_addattr2(&mp->m_sb);
3685c2a1 221 spin_unlock(&mp->m_sb_lock);
d8cc890d
NS		 222 xfs_mod_sb(tp, XFS_SB_VERSIONNUM | XFS_SB_FEATURES2);
223 } else
3685c2a1 224 spin_unlock(&mp->m_sb_lock);
d8cc890d
NS		 225 }
226}
227
228/*
229 * Create the initial contents of a shortform attribute list.
230 */
231void
1da177e4
LT		 232xfs_attr_shortform_create(xfs_da_args_t *args)
233{
234 xfs_attr_sf_hdr_t *hdr;
235 xfs_inode_t *dp;
236 xfs_ifork_t *ifp;
237
5a5881cd
DC		 238 trace_xfs_attr_sf_create(args);
239
1da177e4
LT		 240 dp = args->dp;
241 ASSERT(dp != NULL);
242 ifp = dp->i_afp;
243 ASSERT(ifp != NULL);
244 ASSERT(ifp->if_bytes == 0);
245 if (dp->i_d.di_aformat == XFS_DINODE_FMT_EXTENTS) {
246 ifp->if_flags &= ~XFS_IFEXTENTS; /* just in case */
247 dp->i_d.di_aformat = XFS_DINODE_FMT_LOCAL;
248 ifp->if_flags |= XFS_IFINLINE;
249 } else {
250 ASSERT(ifp->if_flags & XFS_IFINLINE);
251 }
252 xfs_idata_realloc(dp, sizeof(*hdr), XFS_ATTR_FORK);
253 hdr = (xfs_attr_sf_hdr_t *)ifp->if_u1.if_data;
254 hdr->count = 0;
3b244aa8 255 hdr->totsize = cpu_to_be16(sizeof(*hdr));
1da177e4 256 xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_ADATA);
1da177e4
LT		 257}
258
259/*
260 * Add a name/value pair to the shortform attribute list.
261 * Overflow from the inode has already been checked for.
262 */
d8cc890d
NS		 263void
264xfs_attr_shortform_add(xfs_da_args_t *args, int forkoff)
1da177e4
LT		 265{
266 xfs_attr_shortform_t *sf;
267 xfs_attr_sf_entry_t *sfe;
268 int i, offset, size;
d8cc890d 269 xfs_mount_t *mp;
1da177e4
LT		 270 xfs_inode_t *dp;
271 xfs_ifork_t *ifp;
272
5a5881cd
DC		 273 trace_xfs_attr_sf_add(args);
274
1da177e4 275 dp = args->dp;
d8cc890d
NS		 276 mp = dp->i_mount;
277 dp->i_d.di_forkoff = forkoff;
d8cc890d 278
1da177e4
LT		 279 ifp = dp->i_afp;
280 ASSERT(ifp->if_flags & XFS_IFINLINE);
281 sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;
282 sfe = &sf->list[0];
3b244aa8 283 for (i = 0; i < sf->hdr.count; sfe = XFS_ATTR_SF_NEXTENTRY(sfe), i++) {
d8cc890d 284#ifdef DEBUG
1da177e4
LT		 285 if (sfe->namelen != args->namelen)
286 continue;
287 if (memcmp(args->name, sfe->nameval, args->namelen) != 0)
288 continue;
726801ba 289 if (!xfs_attr_namesp_match(args->flags, sfe->flags))
1da177e4 290 continue;
d8cc890d
NS		 291 ASSERT(0);
292#endif
1da177e4
LT		 293 }
294
295 offset = (char *)sfe - (char *)sf;
296 size = XFS_ATTR_SF_ENTSIZE_BYNAME(args->namelen, args->valuelen);
297 xfs_idata_realloc(dp, size, XFS_ATTR_FORK);
298 sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;
299 sfe = (xfs_attr_sf_entry_t *)((char *)sf + offset);
300
301 sfe->namelen = args->namelen;
3b244aa8 302 sfe->valuelen = args->valuelen;
726801ba 303 sfe->flags = XFS_ATTR_NSP_ARGS_TO_ONDISK(args->flags);
1da177e4
LT		 304 memcpy(sfe->nameval, args->name, args->namelen);
305 memcpy(&sfe->nameval[args->namelen], args->value, args->valuelen);
3b244aa8 306 sf->hdr.count++;
413d57c9 307 be16_add_cpu(&sf->hdr.totsize, size);
1da177e4
LT		 308 xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_ADATA);
309
d8cc890d 310 xfs_sbversion_add_attr2(mp, args->trans);
1da177e4
LT		 311}
312
e1486dea
CH		 313/*
314 * After the last attribute is removed revert to original inode format,
315 * making all literal area available to the data fork once more.
316 */
317STATIC void
318xfs_attr_fork_reset(
319 struct xfs_inode *ip,
320 struct xfs_trans *tp)
321{
322 xfs_idestroy_fork(ip, XFS_ATTR_FORK);
323 ip->i_d.di_forkoff = 0;
324 ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
325
326 ASSERT(ip->i_d.di_anextents == 0);
327 ASSERT(ip->i_afp == NULL);
328
e1486dea
CH		 329 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
330}
331
1da177e4 332/*
d8cc890d 333 * Remove an attribute from the shortform attribute list structure.
1da177e4
LT		 334 */
335int
336xfs_attr_shortform_remove(xfs_da_args_t *args)
337{
338 xfs_attr_shortform_t *sf;
339 xfs_attr_sf_entry_t *sfe;
340 int base, size=0, end, totsize, i;
d8cc890d 341 xfs_mount_t *mp;
1da177e4
LT		 342 xfs_inode_t *dp;
343
5a5881cd
DC		 344 trace_xfs_attr_sf_remove(args);
345
1da177e4 346 dp = args->dp;
d8cc890d 347 mp = dp->i_mount;
1da177e4
LT		 348 base = sizeof(xfs_attr_sf_hdr_t);
349 sf = (xfs_attr_shortform_t *)dp->i_afp->if_u1.if_data;
350 sfe = &sf->list[0];
3b244aa8 351 end = sf->hdr.count;
d8cc890d 352 for (i = 0; i < end; sfe = XFS_ATTR_SF_NEXTENTRY(sfe),
1da177e4
LT		 353 base += size, i++) {
354 size = XFS_ATTR_SF_ENTSIZE(sfe);
355 if (sfe->namelen != args->namelen)
356 continue;
357 if (memcmp(sfe->nameval, args->name, args->namelen) != 0)
358 continue;
726801ba 359 if (!xfs_attr_namesp_match(args->flags, sfe->flags))
1da177e4
LT		 360 continue;
361 break;
362 }
d8cc890d 363 if (i == end)
1da177e4
LT		 364 return(XFS_ERROR(ENOATTR));
365
d8cc890d
NS		 366 /*
367 * Fix up the attribute fork data, covering the hole
368 */
1da177e4 369 end = base + size;
3b244aa8 370 totsize = be16_to_cpu(sf->hdr.totsize);
d8cc890d
NS		 371 if (end != totsize)
372 memmove(&((char *)sf)[base], &((char *)sf)[end], totsize - end);
3b244aa8 373 sf->hdr.count--;
413d57c9 374 be16_add_cpu(&sf->hdr.totsize, -size);
d8cc890d
NS		 375
376 /*
377 * Fix up the start offset of the attribute fork
378 */
379 totsize -= size;
6a178100 380 if (totsize == sizeof(xfs_attr_sf_hdr_t) &&
e1486dea
CH		 381 (mp->m_flags & XFS_MOUNT_ATTR2) &&
382 (dp->i_d.di_format != XFS_DINODE_FMT_BTREE) &&
383 !(args->op_flags & XFS_DA_OP_ADDNAME)) {
384 xfs_attr_fork_reset(dp, args->trans);
d8cc890d
NS		 385 } else {
386 xfs_idata_realloc(dp, -size, XFS_ATTR_FORK);
387 dp->i_d.di_forkoff = xfs_attr_shortform_bytesfit(dp, totsize);
388 ASSERT(dp->i_d.di_forkoff);
6a178100
BN		 389 ASSERT(totsize > sizeof(xfs_attr_sf_hdr_t) ||
390 (args->op_flags & XFS_DA_OP_ADDNAME) ||
391 !(mp->m_flags & XFS_MOUNT_ATTR2) ||
392 dp->i_d.di_format == XFS_DINODE_FMT_BTREE);
d8cc890d
NS		 393 xfs_trans_log_inode(args->trans, dp,
394 XFS_ILOG_CORE | XFS_ILOG_ADATA);
395 }
396
397 xfs_sbversion_add_attr2(mp, args->trans);
1da177e4
LT		 398
399 return(0);
400}
401
402/*
403 * Look up a name in a shortform attribute list structure.
404 */
405/*ARGSUSED*/
406int
407xfs_attr_shortform_lookup(xfs_da_args_t *args)
408{
409 xfs_attr_shortform_t *sf;
410 xfs_attr_sf_entry_t *sfe;
411 int i;
412 xfs_ifork_t *ifp;
413
5a5881cd
DC		 414 trace_xfs_attr_sf_lookup(args);
415
1da177e4
LT		 416 ifp = args->dp->i_afp;
417 ASSERT(ifp->if_flags & XFS_IFINLINE);
418 sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;
419 sfe = &sf->list[0];
3b244aa8 420 for (i = 0; i < sf->hdr.count;
1da177e4
LT		 421 sfe = XFS_ATTR_SF_NEXTENTRY(sfe), i++) {
422 if (sfe->namelen != args->namelen)
423 continue;
424 if (memcmp(args->name, sfe->nameval, args->namelen) != 0)
425 continue;
726801ba 426 if (!xfs_attr_namesp_match(args->flags, sfe->flags))
1da177e4
LT		 427 continue;
428 return(XFS_ERROR(EEXIST));
429 }
430 return(XFS_ERROR(ENOATTR));
431}
432
433/*
434 * Look up a name in a shortform attribute list structure.
435 */
436/*ARGSUSED*/
437int
438xfs_attr_shortform_getvalue(xfs_da_args_t *args)
439{
440 xfs_attr_shortform_t *sf;
441 xfs_attr_sf_entry_t *sfe;
442 int i;
443
444 ASSERT(args->dp->i_d.di_aformat == XFS_IFINLINE);
445 sf = (xfs_attr_shortform_t *)args->dp->i_afp->if_u1.if_data;
446 sfe = &sf->list[0];
3b244aa8 447 for (i = 0; i < sf->hdr.count;
1da177e4
LT		 448 sfe = XFS_ATTR_SF_NEXTENTRY(sfe), i++) {
449 if (sfe->namelen != args->namelen)
450 continue;
451 if (memcmp(args->name, sfe->nameval, args->namelen) != 0)
452 continue;
726801ba 453 if (!xfs_attr_namesp_match(args->flags, sfe->flags))
1da177e4
LT		 454 continue;
455 if (args->flags & ATTR_KERNOVAL) {
3b244aa8 456 args->valuelen = sfe->valuelen;
1da177e4
LT		 457 return(XFS_ERROR(EEXIST));
458 }
3b244aa8
NS		 459 if (args->valuelen < sfe->valuelen) {
460 args->valuelen = sfe->valuelen;
1da177e4
LT		 461 return(XFS_ERROR(ERANGE));
462 }
3b244aa8 463 args->valuelen = sfe->valuelen;
1da177e4
LT		 464 memcpy(args->value, &sfe->nameval[args->namelen],
465 args->valuelen);
466 return(XFS_ERROR(EEXIST));
467 }
468 return(XFS_ERROR(ENOATTR));
469}
470
471/*
472 * Convert from using the shortform to the leaf.
473 */
474int
475xfs_attr_shortform_to_leaf(xfs_da_args_t *args)
476{
477 xfs_inode_t *dp;
478 xfs_attr_shortform_t *sf;
479 xfs_attr_sf_entry_t *sfe;
480 xfs_da_args_t nargs;
481 char *tmpbuffer;
482 int error, i, size;
483 xfs_dablk_t blkno;
484 xfs_dabuf_t *bp;
485 xfs_ifork_t *ifp;
486
5a5881cd
DC		 487 trace_xfs_attr_sf_to_leaf(args);
488
1da177e4
LT		 489 dp = args->dp;
490 ifp = dp->i_afp;
491 sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;
3b244aa8 492 size = be16_to_cpu(sf->hdr.totsize);
1da177e4
LT		 493 tmpbuffer = kmem_alloc(size, KM_SLEEP);
494 ASSERT(tmpbuffer != NULL);
495 memcpy(tmpbuffer, ifp->if_u1.if_data, size);
496 sf = (xfs_attr_shortform_t *)tmpbuffer;
497
498 xfs_idata_realloc(dp, -size, XFS_ATTR_FORK);
499 bp = NULL;
500 error = xfs_da_grow_inode(args, &blkno);
501 if (error) {
502 /*
503 * If we hit an IO error middle of the transaction inside
504 * grow_inode(), we may have inconsistent data. Bail out.
505 */
506 if (error == EIO)
507 goto out;
508 xfs_idata_realloc(dp, size, XFS_ATTR_FORK); /* try to put */
509 memcpy(ifp->if_u1.if_data, tmpbuffer, size); /* it back */
510 goto out;
511 }
512
513 ASSERT(blkno == 0);
514 error = xfs_attr_leaf_create(args, blkno, &bp);
515 if (error) {
516 error = xfs_da_shrink_inode(args, 0, bp);
517 bp = NULL;
518 if (error)
519 goto out;
520 xfs_idata_realloc(dp, size, XFS_ATTR_FORK); /* try to put */
521 memcpy(ifp->if_u1.if_data, tmpbuffer, size); /* it back */
522 goto out;
523 }
524
525 memset((char *)&nargs, 0, sizeof(nargs));
526 nargs.dp = dp;
527 nargs.firstblock = args->firstblock;
528 nargs.flist = args->flist;
529 nargs.total = args->total;
530 nargs.whichfork = XFS_ATTR_FORK;
531 nargs.trans = args->trans;
6a178100 532 nargs.op_flags = XFS_DA_OP_OKNOENT;
1da177e4
LT		 533
534 sfe = &sf->list[0];
3b244aa8 535 for (i = 0; i < sf->hdr.count; i++) {
a9273ca5 536 nargs.name = sfe->nameval;
1da177e4 537 nargs.namelen = sfe->namelen;
a9273ca5 538 nargs.value = &sfe->nameval[nargs.namelen];
3b244aa8 539 nargs.valuelen = sfe->valuelen;
a9273ca5 540 nargs.hashval = xfs_da_hashname(sfe->nameval,
1da177e4 541 sfe->namelen);
726801ba 542 nargs.flags = XFS_ATTR_NSP_ONDISK_TO_ARGS(sfe->flags);
1da177e4
LT		 543 error = xfs_attr_leaf_lookup_int(bp, &nargs); /* set a->index */
544 ASSERT(error == ENOATTR);
545 error = xfs_attr_leaf_add(bp, &nargs);
546 ASSERT(error != ENOSPC);
547 if (error)
548 goto out;
549 sfe = XFS_ATTR_SF_NEXTENTRY(sfe);
550 }
551 error = 0;
552
553out:
554 if(bp)
555 xfs_da_buf_done(bp);
f0e2d93c 556 kmem_free(tmpbuffer);
1da177e4
LT		 557 return(error);
558}
559
560STATIC int
561xfs_attr_shortform_compare(const void *a, const void *b)
562{
563 xfs_attr_sf_sort_t *sa, *sb;
564
565 sa = (xfs_attr_sf_sort_t *)a;
566 sb = (xfs_attr_sf_sort_t *)b;
984a081a 567 if (sa->hash < sb->hash) {
1da177e4 568 return(-1);
984a081a 569 } else if (sa->hash > sb->hash) {
1da177e4
LT		 570 return(1);
571 } else {
572 return(sa->entno - sb->entno);
573 }
574}
575
726801ba
TS		 576
577#define XFS_ISRESET_CURSOR(cursor) \
578 (!((cursor)->initted) && !((cursor)->hashval) && \
579 !((cursor)->blkno) && !((cursor)->offset))
1da177e4
LT		 580/*
581 * Copy out entries of shortform attribute lists for attr_list().
c41564b5 582 * Shortform attribute lists are not stored in hashval sorted order.
1da177e4
LT		 583 * If the output buffer is not large enough to hold them all, then we
584 * we have to calculate each entries' hashvalue and sort them before
585 * we can begin returning them to the user.
586 */
587/*ARGSUSED*/
588int
589xfs_attr_shortform_list(xfs_attr_list_context_t *context)
590{
591 attrlist_cursor_kern_t *cursor;
592 xfs_attr_sf_sort_t *sbuf, *sbp;
593 xfs_attr_shortform_t *sf;
594 xfs_attr_sf_entry_t *sfe;
595 xfs_inode_t *dp;
596 int sbsize, nsbuf, count, i;
726801ba 597 int error;
1da177e4
LT		 598
599 ASSERT(context != NULL);
600 dp = context->dp;
601 ASSERT(dp != NULL);
602 ASSERT(dp->i_afp != NULL);
603 sf = (xfs_attr_shortform_t *)dp->i_afp->if_u1.if_data;
604 ASSERT(sf != NULL);
605 if (!sf->hdr.count)
606 return(0);
607 cursor = context->cursor;
608 ASSERT(cursor != NULL);
609
0b1b213f 610 trace_xfs_attr_list_sf(context);
1da177e4
LT		 611
612 /*
726801ba
TS		 613 * If the buffer is large enough and the cursor is at the start,
614 * do not bother with sorting since we will return everything in
615 * one buffer and another call using the cursor won't need to be
616 * made.
1da177e4 617 * Note the generous fudge factor of 16 overhead bytes per entry.
726801ba
TS		 618 * If bufsize is zero then put_listent must be a search function
619 * and can just scan through what we have.
1da177e4 620 */
726801ba
TS		 621 if (context->bufsize == 0 ||
622 (XFS_ISRESET_CURSOR(cursor) &&
623 (dp->i_afp->if_bytes + sf->hdr.count * 16) < context->bufsize)) {
3b244aa8 624 for (i = 0, sfe = &sf->list[0]; i < sf->hdr.count; i++) {
726801ba 625 error = context->put_listent(context,
ad9b463a 626 sfe->flags,
a9273ca5 627 sfe->nameval,
726801ba
TS		 628 (int)sfe->namelen,
629 (int)sfe->valuelen,
a9273ca5 630 &sfe->nameval[sfe->namelen]);
726801ba
TS		 631
632 /*
633 * Either search callback finished early or
634 * didn't fit it all in the buffer after all.
635 */
636 if (context->seen_enough)
637 break;
638
639 if (error)
640 return error;
1da177e4
LT		 641 sfe = XFS_ATTR_SF_NEXTENTRY(sfe);
642 }
0b1b213f 643 trace_xfs_attr_list_sf_all(context);
1da177e4
LT		 644 return(0);
645 }
646
726801ba
TS		 647 /* do no more for a search callback */
648 if (context->bufsize == 0)
649 return 0;
650
1da177e4
LT		 651 /*
652 * It didn't all fit, so we have to sort everything on hashval.
653 */
3b244aa8 654 sbsize = sf->hdr.count * sizeof(*sbuf);
622d8149 655 sbp = sbuf = kmem_alloc(sbsize, KM_SLEEP | KM_NOFS);
1da177e4
LT		 656
657 /*
658 * Scan the attribute list for the rest of the entries, storing
659 * the relevant info from only those that match into a buffer.
660 */
661 nsbuf = 0;
3b244aa8 662 for (i = 0, sfe = &sf->list[0]; i < sf->hdr.count; i++) {
1da177e4
LT		 663 if (unlikely(
664 ((char *)sfe < (char *)sf) ||
665 ((char *)sfe >= ((char *)sf + dp->i_afp->if_bytes)))) {
666 XFS_CORRUPTION_ERROR("xfs_attr_shortform_list",
667 XFS_ERRLEVEL_LOW,
668 context->dp->i_mount, sfe);
f0e2d93c 669 kmem_free(sbuf);
1da177e4
LT		 670 return XFS_ERROR(EFSCORRUPTED);
671 }
ad9b463a 672
1da177e4 673 sbp->entno = i;
a9273ca5
DC		 674 sbp->hash = xfs_da_hashname(sfe->nameval, sfe->namelen);
675 sbp->name = sfe->nameval;
1da177e4
LT		 676 sbp->namelen = sfe->namelen;
677 /* These are bytes, and both on-disk, don't endian-flip */
678 sbp->valuelen = sfe->valuelen;
679 sbp->flags = sfe->flags;
680 sfe = XFS_ATTR_SF_NEXTENTRY(sfe);
681 sbp++;
682 nsbuf++;
683 }
684
685 /*
686 * Sort the entries on hash then entno.
687 */
380b5dc0 688 xfs_sort(sbuf, nsbuf, sizeof(*sbuf), xfs_attr_shortform_compare);
1da177e4
LT		 689
690 /*
691 * Re-find our place IN THE SORTED LIST.
692 */
693 count = 0;
694 cursor->initted = 1;
695 cursor->blkno = 0;
696 for (sbp = sbuf, i = 0; i < nsbuf; i++, sbp++) {
984a081a 697 if (sbp->hash == cursor->hashval) {
1da177e4
LT		 698 if (cursor->offset == count) {
699 break;
700 }
701 count++;
984a081a 702 } else if (sbp->hash > cursor->hashval) {
1da177e4
LT		 703 break;
704 }
705 }
706 if (i == nsbuf) {
f0e2d93c 707 kmem_free(sbuf);
1da177e4
LT		 708 return(0);
709 }
710
711 /*
712 * Loop putting entries into the user buffer.
713 */
714 for ( ; i < nsbuf; i++, sbp++) {
984a081a
NS		 715 if (cursor->hashval != sbp->hash) {
716 cursor->hashval = sbp->hash;
1da177e4
LT		 717 cursor->offset = 0;
718 }
726801ba 719 error = context->put_listent(context,
ad9b463a 720 sbp->flags,
726801ba
TS		 721 sbp->name,
722 sbp->namelen,
723 sbp->valuelen,
724 &sbp->name[sbp->namelen]);
725 if (error)
726 return error;
727 if (context->seen_enough)
728 break;
1da177e4
LT		 729 cursor->offset++;
730 }
731
f0e2d93c 732 kmem_free(sbuf);
1da177e4
LT		 733 return(0);
734}
735
736/*
737 * Check a leaf attribute block to see if all the entries would fit into
738 * a shortform attribute list.
739 */
740int
741xfs_attr_shortform_allfit(xfs_dabuf_t *bp, xfs_inode_t *dp)
742{
743 xfs_attr_leafblock_t *leaf;
744 xfs_attr_leaf_entry_t *entry;
745 xfs_attr_leaf_name_local_t *name_loc;
746 int bytes, i;
747
748 leaf = bp->data;
69ef921b 749 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1da177e4
LT		 750
751 entry = &leaf->entries[0];
752 bytes = sizeof(struct xfs_attr_sf_hdr);
918ae424 753 for (i = 0; i < be16_to_cpu(leaf->hdr.count); entry++, i++) {
1da177e4
LT		 754 if (entry->flags & XFS_ATTR_INCOMPLETE)
755 continue; /* don't copy partial entries */
756 if (!(entry->flags & XFS_ATTR_LOCAL))
757 return(0);
c9fb86a9 758 name_loc = xfs_attr_leaf_name_local(leaf, i);
1da177e4
LT		 759 if (name_loc->namelen >= XFS_ATTR_SF_ENTSIZE_MAX)
760 return(0);
053b5758 761 if (be16_to_cpu(name_loc->valuelen) >= XFS_ATTR_SF_ENTSIZE_MAX)
1da177e4
LT		 762 return(0);
763 bytes += sizeof(struct xfs_attr_sf_entry)-1
764 + name_loc->namelen
053b5758 765 + be16_to_cpu(name_loc->valuelen);
1da177e4 766 }
13059ff0 767 if ((dp->i_mount->m_flags & XFS_MOUNT_ATTR2) &&
e5889e90 768 (dp->i_d.di_format != XFS_DINODE_FMT_BTREE) &&
e0144ca5 769 (bytes == sizeof(struct xfs_attr_sf_hdr)))
d8cc890d
NS		 770 return(-1);
771 return(xfs_attr_shortform_bytesfit(dp, bytes));
1da177e4
LT		 772}
773
774/*
775 * Convert a leaf attribute list to shortform attribute list
776 */
777int
d8cc890d 778xfs_attr_leaf_to_shortform(xfs_dabuf_t *bp, xfs_da_args_t *args, int forkoff)
1da177e4
LT		 779{
780 xfs_attr_leafblock_t *leaf;
781 xfs_attr_leaf_entry_t *entry;
782 xfs_attr_leaf_name_local_t *name_loc;
783 xfs_da_args_t nargs;
784 xfs_inode_t *dp;
785 char *tmpbuffer;
786 int error, i;
787
5a5881cd
DC		 788 trace_xfs_attr_leaf_to_sf(args);
789
1da177e4
LT		 790 dp = args->dp;
791 tmpbuffer = kmem_alloc(XFS_LBSIZE(dp->i_mount), KM_SLEEP);
792 ASSERT(tmpbuffer != NULL);
793
794 ASSERT(bp != NULL);
795 memcpy(tmpbuffer, bp->data, XFS_LBSIZE(dp->i_mount));
796 leaf = (xfs_attr_leafblock_t *)tmpbuffer;
69ef921b 797 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1da177e4
LT		 798 memset(bp->data, 0, XFS_LBSIZE(dp->i_mount));
799
800 /*
801 * Clean out the prior contents of the attribute list.
802 */
803 error = xfs_da_shrink_inode(args, 0, bp);
804 if (error)
805 goto out;
d8cc890d
NS		 806
807 if (forkoff == -1) {
13059ff0 808 ASSERT(dp->i_mount->m_flags & XFS_MOUNT_ATTR2);
e5889e90 809 ASSERT(dp->i_d.di_format != XFS_DINODE_FMT_BTREE);
e1486dea 810 xfs_attr_fork_reset(dp, args->trans);
1da177e4 811 goto out;
d8cc890d
NS		 812 }
813
814 xfs_attr_shortform_create(args);
1da177e4
LT		 815
816 /*
817 * Copy the attributes
818 */
819 memset((char *)&nargs, 0, sizeof(nargs));
820 nargs.dp = dp;
821 nargs.firstblock = args->firstblock;
822 nargs.flist = args->flist;
823 nargs.total = args->total;
824 nargs.whichfork = XFS_ATTR_FORK;
825 nargs.trans = args->trans;
6a178100 826 nargs.op_flags = XFS_DA_OP_OKNOENT;
1da177e4 827 entry = &leaf->entries[0];
918ae424 828 for (i = 0; i < be16_to_cpu(leaf->hdr.count); entry++, i++) {
1da177e4
LT		 829 if (entry->flags & XFS_ATTR_INCOMPLETE)
830 continue; /* don't copy partial entries */
831 if (!entry->nameidx)
832 continue;
833 ASSERT(entry->flags & XFS_ATTR_LOCAL);
c9fb86a9 834 name_loc = xfs_attr_leaf_name_local(leaf, i);
a9273ca5 835 nargs.name = name_loc->nameval;
1da177e4 836 nargs.namelen = name_loc->namelen;
a9273ca5 837 nargs.value = &name_loc->nameval[nargs.namelen];
053b5758 838 nargs.valuelen = be16_to_cpu(name_loc->valuelen);
6b19f2d8 839 nargs.hashval = be32_to_cpu(entry->hashval);
726801ba 840 nargs.flags = XFS_ATTR_NSP_ONDISK_TO_ARGS(entry->flags);
d8cc890d 841 xfs_attr_shortform_add(&nargs, forkoff);
1da177e4
LT		 842 }
843 error = 0;
844
845out:
f0e2d93c 846 kmem_free(tmpbuffer);
1da177e4
LT		 847 return(error);
848}
849
850/*
851 * Convert from using a single leaf to a root node and a leaf.
852 */
853int
854xfs_attr_leaf_to_node(xfs_da_args_t *args)
855{
856 xfs_attr_leafblock_t *leaf;
857 xfs_da_intnode_t *node;
858 xfs_inode_t *dp;
859 xfs_dabuf_t *bp1, *bp2;
860 xfs_dablk_t blkno;
861 int error;
862
5a5881cd
DC		 863 trace_xfs_attr_leaf_to_node(args);
864
1da177e4
LT		 865 dp = args->dp;
866 bp1 = bp2 = NULL;
867 error = xfs_da_grow_inode(args, &blkno);
868 if (error)
869 goto out;
870 error = xfs_da_read_buf(args->trans, args->dp, 0, -1, &bp1,
871 XFS_ATTR_FORK);
872 if (error)
873 goto out;
874 ASSERT(bp1 != NULL);
875 bp2 = NULL;
876 error = xfs_da_get_buf(args->trans, args->dp, blkno, -1, &bp2,
877 XFS_ATTR_FORK);
878 if (error)
879 goto out;
880 ASSERT(bp2 != NULL);
881 memcpy(bp2->data, bp1->data, XFS_LBSIZE(dp->i_mount));
882 xfs_da_buf_done(bp1);
883 bp1 = NULL;
884 xfs_da_log_buf(args->trans, bp2, 0, XFS_LBSIZE(dp->i_mount) - 1);
885
886 /*
887 * Set up the new root node.
888 */
889 error = xfs_da_node_create(args, 0, 1, &bp1, XFS_ATTR_FORK);
890 if (error)
891 goto out;
892 node = bp1->data;
893 leaf = bp2->data;
69ef921b 894 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1da177e4
LT		 895 /* both on-disk, don't endian-flip twice */
896 node->btree[0].hashval =
918ae424 897 leaf->entries[be16_to_cpu(leaf->hdr.count)-1 ].hashval;
403432dc 898 node->btree[0].before = cpu_to_be32(blkno);
fac80cce 899 node->hdr.count = cpu_to_be16(1);
1da177e4
LT		 900 xfs_da_log_buf(args->trans, bp1, 0, XFS_LBSIZE(dp->i_mount) - 1);
901 error = 0;
902out:
903 if (bp1)
904 xfs_da_buf_done(bp1);
905 if (bp2)
906 xfs_da_buf_done(bp2);
907 return(error);
908}
909
910
911/*========================================================================
912 * Routines used for growing the Btree.
913 *========================================================================*/
914
915/*
916 * Create the initial contents of a leaf attribute list
917 * or a leaf in a node attribute list.
918 */
ba0f32d4 919STATIC int
1da177e4
LT		 920xfs_attr_leaf_create(xfs_da_args_t *args, xfs_dablk_t blkno, xfs_dabuf_t **bpp)
921{
922 xfs_attr_leafblock_t *leaf;
923 xfs_attr_leaf_hdr_t *hdr;
924 xfs_inode_t *dp;
925 xfs_dabuf_t *bp;
926 int error;
927
5a5881cd
DC		 928 trace_xfs_attr_leaf_create(args);
929
1da177e4
LT		 930 dp = args->dp;
931 ASSERT(dp != NULL);
932 error = xfs_da_get_buf(args->trans, args->dp, blkno, -1, &bp,
933 XFS_ATTR_FORK);
934 if (error)
935 return(error);
936 ASSERT(bp != NULL);
937 leaf = bp->data;
938 memset((char *)leaf, 0, XFS_LBSIZE(dp->i_mount));
939 hdr = &leaf->hdr;
89da0544 940 hdr->info.magic = cpu_to_be16(XFS_ATTR_LEAF_MAGIC);
918ae424 941 hdr->firstused = cpu_to_be16(XFS_LBSIZE(dp->i_mount));
1da177e4 942 if (!hdr->firstused) {
918ae424 943 hdr->firstused = cpu_to_be16(
1da177e4
LT		 944 XFS_LBSIZE(dp->i_mount) - XFS_ATTR_LEAF_NAME_ALIGN);
945 }
946
918ae424
NS		 947 hdr->freemap[0].base = cpu_to_be16(sizeof(xfs_attr_leaf_hdr_t));
948 hdr->freemap[0].size = cpu_to_be16(be16_to_cpu(hdr->firstused) -
949 sizeof(xfs_attr_leaf_hdr_t));
1da177e4
LT		 950
951 xfs_da_log_buf(args->trans, bp, 0, XFS_LBSIZE(dp->i_mount) - 1);
952
953 *bpp = bp;
954 return(0);
955}
956
957/*
958 * Split the leaf node, rebalance, then add the new entry.
959 */
960int
961xfs_attr_leaf_split(xfs_da_state_t *state, xfs_da_state_blk_t *oldblk,
962 xfs_da_state_blk_t *newblk)
963{
964 xfs_dablk_t blkno;
965 int error;
966
5a5881cd
DC		 967 trace_xfs_attr_leaf_split(state->args);
968
1da177e4
LT		 969 /*
970 * Allocate space for a new leaf node.
971 */
972 ASSERT(oldblk->magic == XFS_ATTR_LEAF_MAGIC);
973 error = xfs_da_grow_inode(state->args, &blkno);
974 if (error)
975 return(error);
976 error = xfs_attr_leaf_create(state->args, blkno, &newblk->bp);
977 if (error)
978 return(error);
979 newblk->blkno = blkno;
980 newblk->magic = XFS_ATTR_LEAF_MAGIC;
981
982 /*
983 * Rebalance the entries across the two leaves.
984 * NOTE: rebalance() currently depends on the 2nd block being empty.
985 */
986 xfs_attr_leaf_rebalance(state, oldblk, newblk);
987 error = xfs_da_blk_link(state, oldblk, newblk);
988 if (error)
989 return(error);
990
991 /*
992 * Save info on "old" attribute for "atomic rename" ops, leaf_add()
993 * modifies the index/blkno/rmtblk/rmtblkcnt fields to show the
994 * "new" attrs info. Will need the "old" info to remove it later.
995 *
996 * Insert the "new" entry in the correct block.
997 */
5a5881cd
DC		 998 if (state->inleaf) {
999 trace_xfs_attr_leaf_add_old(state->args);
1da177e4 1000 error = xfs_attr_leaf_add(oldblk->bp, state->args);
5a5881cd
DC		 1001 } else {
1002 trace_xfs_attr_leaf_add_new(state->args);
1da177e4 1003 error = xfs_attr_leaf_add(newblk->bp, state->args);
5a5881cd 1004 }
1da177e4
LT		 1005
1006 /*
1007 * Update last hashval in each block since we added the name.
1008 */
1009 oldblk->hashval = xfs_attr_leaf_lasthash(oldblk->bp, NULL);
1010 newblk->hashval = xfs_attr_leaf_lasthash(newblk->bp, NULL);
1011 return(error);
1012}
1013
1014/*
1015 * Add a name to the leaf attribute list structure.
1016 */
1017int
1018xfs_attr_leaf_add(xfs_dabuf_t *bp, xfs_da_args_t *args)
1019{
1020 xfs_attr_leafblock_t *leaf;
1021 xfs_attr_leaf_hdr_t *hdr;
1022 xfs_attr_leaf_map_t *map;
1023 int tablesize, entsize, sum, tmp, i;
1024
5a5881cd
DC		 1025 trace_xfs_attr_leaf_add(args);
1026
1da177e4 1027 leaf = bp->data;
69ef921b 1028 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1da177e4 1029 ASSERT((args->index >= 0)
918ae424 1030 && (args->index <= be16_to_cpu(leaf->hdr.count)));
1da177e4 1031 hdr = &leaf->hdr;
aa82daa0 1032 entsize = xfs_attr_leaf_newentsize(args->namelen, args->valuelen,
1da177e4
LT		 1033 args->trans->t_mountp->m_sb.sb_blocksize, NULL);
1034
1035 /*
1036 * Search through freemap for first-fit on new name length.
1037 * (may need to figure in size of entry struct too)
1038 */
918ae424 1039 tablesize = (be16_to_cpu(hdr->count) + 1)
1da177e4
LT		 1040 * sizeof(xfs_attr_leaf_entry_t)
1041 + sizeof(xfs_attr_leaf_hdr_t);
1042 map = &hdr->freemap[XFS_ATTR_LEAF_MAPSIZE-1];
1043 for (sum = 0, i = XFS_ATTR_LEAF_MAPSIZE-1; i >= 0; map--, i--) {
918ae424
NS		 1044 if (tablesize > be16_to_cpu(hdr->firstused)) {
1045 sum += be16_to_cpu(map->size);
1da177e4
LT		 1046 continue;
1047 }
1048 if (!map->size)
1049 continue; /* no space in this map */
1050 tmp = entsize;
918ae424 1051 if (be16_to_cpu(map->base) < be16_to_cpu(hdr->firstused))
1da177e4 1052 tmp += sizeof(xfs_attr_leaf_entry_t);
918ae424 1053 if (be16_to_cpu(map->size) >= tmp) {
1da177e4
LT		 1054 tmp = xfs_attr_leaf_add_work(bp, args, i);
1055 return(tmp);
1056 }
918ae424 1057 sum += be16_to_cpu(map->size);
1da177e4
LT		 1058 }
1059
1060 /*
1061 * If there are no holes in the address space of the block,
1062 * and we don't have enough freespace, then compaction will do us
1063 * no good and we should just give up.
1064 */
1065 if (!hdr->holes && (sum < entsize))
1066 return(XFS_ERROR(ENOSPC));
1067
1068 /*
1069 * Compact the entries to coalesce free space.
1070 * This may change the hdr->count via dropping INCOMPLETE entries.
1071 */
1072 xfs_attr_leaf_compact(args->trans, bp);
1073
1074 /*
1075 * After compaction, the block is guaranteed to have only one
1076 * free region, in freemap[0]. If it is not big enough, give up.
1077 */
918ae424 1078 if (be16_to_cpu(hdr->freemap[0].size)
1da177e4
LT		 1079 < (entsize + sizeof(xfs_attr_leaf_entry_t)))
1080 return(XFS_ERROR(ENOSPC));
1081
1082 return(xfs_attr_leaf_add_work(bp, args, 0));
1083}
1084
1085/*
1086 * Add a name to a leaf attribute list structure.
1087 */
1088STATIC int
1089xfs_attr_leaf_add_work(xfs_dabuf_t *bp, xfs_da_args_t *args, int mapindex)
1090{
1091 xfs_attr_leafblock_t *leaf;
1092 xfs_attr_leaf_hdr_t *hdr;
1093 xfs_attr_leaf_entry_t *entry;
1094 xfs_attr_leaf_name_local_t *name_loc;
1095 xfs_attr_leaf_name_remote_t *name_rmt;
1096 xfs_attr_leaf_map_t *map;
1097 xfs_mount_t *mp;
1098 int tmp, i;
1099
1100 leaf = bp->data;
69ef921b 1101 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1da177e4
LT		 1102 hdr = &leaf->hdr;
1103 ASSERT((mapindex >= 0) && (mapindex < XFS_ATTR_LEAF_MAPSIZE));
918ae424 1104 ASSERT((args->index >= 0) && (args->index <= be16_to_cpu(hdr->count)));
1da177e4
LT		 1105
1106 /*
1107 * Force open some space in the entry array and fill it in.
1108 */
1109 entry = &leaf->entries[args->index];
918ae424
NS		 1110 if (args->index < be16_to_cpu(hdr->count)) {
1111 tmp = be16_to_cpu(hdr->count) - args->index;
1da177e4
LT		 1112 tmp *= sizeof(xfs_attr_leaf_entry_t);
1113 memmove((char *)(entry+1), (char *)entry, tmp);
1114 xfs_da_log_buf(args->trans, bp,
1115 XFS_DA_LOGRANGE(leaf, entry, tmp + sizeof(*entry)));
1116 }
413d57c9 1117 be16_add_cpu(&hdr->count, 1);
1da177e4
LT		 1118
1119 /*
1120 * Allocate space for the new string (at the end of the run).
1121 */
1122 map = &hdr->freemap[mapindex];
1123 mp = args->trans->t_mountp;
918ae424
NS		 1124 ASSERT(be16_to_cpu(map->base) < XFS_LBSIZE(mp));
1125 ASSERT((be16_to_cpu(map->base) & 0x3) == 0);
1126 ASSERT(be16_to_cpu(map->size) >=
aa82daa0
NS		 1127 xfs_attr_leaf_newentsize(args->namelen, args->valuelen,
1128 mp->m_sb.sb_blocksize, NULL));
918ae424
NS		 1129 ASSERT(be16_to_cpu(map->size) < XFS_LBSIZE(mp));
1130 ASSERT((be16_to_cpu(map->size) & 0x3) == 0);
413d57c9 1131 be16_add_cpu(&map->size,
aa82daa0
NS		 1132 -xfs_attr_leaf_newentsize(args->namelen, args->valuelen,
1133 mp->m_sb.sb_blocksize, &tmp));
6b19f2d8
NS		 1134 entry->nameidx = cpu_to_be16(be16_to_cpu(map->base) +
1135 be16_to_cpu(map->size));
1136 entry->hashval = cpu_to_be32(args->hashval);
1da177e4 1137 entry->flags = tmp ? XFS_ATTR_LOCAL : 0;
726801ba 1138 entry->flags |= XFS_ATTR_NSP_ARGS_TO_ONDISK(args->flags);
6a178100 1139 if (args->op_flags & XFS_DA_OP_RENAME) {
1da177e4
LT		 1140 entry->flags |= XFS_ATTR_INCOMPLETE;
1141 if ((args->blkno2 == args->blkno) &&
1142 (args->index2 <= args->index)) {
1143 args->index2++;
1144 }
1145 }
1146 xfs_da_log_buf(args->trans, bp,
1147 XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));
6b19f2d8
NS		 1148 ASSERT((args->index == 0) ||
1149 (be32_to_cpu(entry->hashval) >= be32_to_cpu((entry-1)->hashval)));
918ae424 1150 ASSERT((args->index == be16_to_cpu(hdr->count)-1) ||
6b19f2d8 1151 (be32_to_cpu(entry->hashval) <= be32_to_cpu((entry+1)->hashval)));
1da177e4
LT		 1152
1153 /*
1da177e4
LT		 1154 * For "remote" attribute values, simply note that we need to
1155 * allocate space for the "remote" value. We can't actually
1156 * allocate the extents in this transaction, and we can't decide
1157 * which blocks they should be as we might allocate more blocks
1158 * as part of this transaction (a split operation for example).
1159 */
1160 if (entry->flags & XFS_ATTR_LOCAL) {
c9fb86a9 1161 name_loc = xfs_attr_leaf_name_local(leaf, args->index);
1da177e4 1162 name_loc->namelen = args->namelen;
053b5758 1163 name_loc->valuelen = cpu_to_be16(args->valuelen);
1da177e4
LT		 1164 memcpy((char *)name_loc->nameval, args->name, args->namelen);
1165 memcpy((char *)&name_loc->nameval[args->namelen], args->value,
053b5758 1166 be16_to_cpu(name_loc->valuelen));
1da177e4 1167 } else {
c9fb86a9 1168 name_rmt = xfs_attr_leaf_name_remote(leaf, args->index);
1da177e4
LT		 1169 name_rmt->namelen = args->namelen;
1170 memcpy((char *)name_rmt->name, args->name, args->namelen);
1171 entry->flags |= XFS_ATTR_INCOMPLETE;
1172 /* just in case */
1173 name_rmt->valuelen = 0;
1174 name_rmt->valueblk = 0;
1175 args->rmtblkno = 1;
1176 args->rmtblkcnt = XFS_B_TO_FSB(mp, args->valuelen);
1177 }
1178 xfs_da_log_buf(args->trans, bp,
c9fb86a9 1179 XFS_DA_LOGRANGE(leaf, xfs_attr_leaf_name(leaf, args->index),
1da177e4
LT		 1180 xfs_attr_leaf_entsize(leaf, args->index)));
1181
1182 /*
1183 * Update the control info for this leaf node
1184 */
6b19f2d8 1185 if (be16_to_cpu(entry->nameidx) < be16_to_cpu(hdr->firstused)) {
1da177e4
LT		 1186 /* both on-disk, don't endian-flip twice */
1187 hdr->firstused = entry->nameidx;
1188 }
918ae424
NS		 1189 ASSERT(be16_to_cpu(hdr->firstused) >=
1190 ((be16_to_cpu(hdr->count) * sizeof(*entry)) + sizeof(*hdr)));
1191 tmp = (be16_to_cpu(hdr->count)-1) * sizeof(xfs_attr_leaf_entry_t)
1da177e4
LT		 1192 + sizeof(xfs_attr_leaf_hdr_t);
1193 map = &hdr->freemap[0];
1194 for (i = 0; i < XFS_ATTR_LEAF_MAPSIZE; map++, i++) {
918ae424 1195 if (be16_to_cpu(map->base) == tmp) {
413d57c9
MS		 1196 be16_add_cpu(&map->base, sizeof(xfs_attr_leaf_entry_t));
1197 be16_add_cpu(&map->size,
918ae424 1198 -((int)sizeof(xfs_attr_leaf_entry_t)));
1da177e4
LT		 1199 }
1200 }
413d57c9 1201 be16_add_cpu(&hdr->usedbytes, xfs_attr_leaf_entsize(leaf, args->index));
1da177e4
LT		 1202 xfs_da_log_buf(args->trans, bp,
1203 XFS_DA_LOGRANGE(leaf, hdr, sizeof(*hdr)));
1204 return(0);
1205}
1206
1207/*
1208 * Garbage collect a leaf attribute list block by copying it to a new buffer.
1209 */
1210STATIC void
1211xfs_attr_leaf_compact(xfs_trans_t *trans, xfs_dabuf_t *bp)
1212{
1213 xfs_attr_leafblock_t *leaf_s, *leaf_d;
1214 xfs_attr_leaf_hdr_t *hdr_s, *hdr_d;
1215 xfs_mount_t *mp;
1216 char *tmpbuffer;
1217
1218 mp = trans->t_mountp;
1219 tmpbuffer = kmem_alloc(XFS_LBSIZE(mp), KM_SLEEP);
1220 ASSERT(tmpbuffer != NULL);
1221 memcpy(tmpbuffer, bp->data, XFS_LBSIZE(mp));
1222 memset(bp->data, 0, XFS_LBSIZE(mp));
1223
1224 /*
1225 * Copy basic information
1226 */
1227 leaf_s = (xfs_attr_leafblock_t *)tmpbuffer;
1228 leaf_d = bp->data;
1229 hdr_s = &leaf_s->hdr;
1230 hdr_d = &leaf_d->hdr;
1231 hdr_d->info = hdr_s->info; /* struct copy */
918ae424 1232 hdr_d->firstused = cpu_to_be16(XFS_LBSIZE(mp));
1da177e4
LT		 1233 /* handle truncation gracefully */
1234 if (!hdr_d->firstused) {
918ae424 1235 hdr_d->firstused = cpu_to_be16(
1da177e4
LT		 1236 XFS_LBSIZE(mp) - XFS_ATTR_LEAF_NAME_ALIGN);
1237 }
1238 hdr_d->usedbytes = 0;
1239 hdr_d->count = 0;
1240 hdr_d->holes = 0;
918ae424
NS		 1241 hdr_d->freemap[0].base = cpu_to_be16(sizeof(xfs_attr_leaf_hdr_t));
1242 hdr_d->freemap[0].size = cpu_to_be16(be16_to_cpu(hdr_d->firstused) -
1243 sizeof(xfs_attr_leaf_hdr_t));
1da177e4
LT		 1244
1245 /*
1246 * Copy all entry's in the same (sorted) order,
1247 * but allocate name/value pairs packed and in sequence.
1248 */
1249 xfs_attr_leaf_moveents(leaf_s, 0, leaf_d, 0,
918ae424 1250 be16_to_cpu(hdr_s->count), mp);
1da177e4
LT		 1251 xfs_da_log_buf(trans, bp, 0, XFS_LBSIZE(mp) - 1);
1252
f0e2d93c 1253 kmem_free(tmpbuffer);
1da177e4
LT		 1254}
1255
1256/*
1257 * Redistribute the attribute list entries between two leaf nodes,
1258 * taking into account the size of the new entry.
1259 *
1260 * NOTE: if new block is empty, then it will get the upper half of the
1261 * old block. At present, all (one) callers pass in an empty second block.
1262 *
1263 * This code adjusts the args->index/blkno and args->index2/blkno2 fields
1264 * to match what it is doing in splitting the attribute leaf block. Those
1265 * values are used in "atomic rename" operations on attributes. Note that
1266 * the "new" and "old" values can end up in different blocks.
1267 */
1268STATIC void
1269xfs_attr_leaf_rebalance(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
1270 xfs_da_state_blk_t *blk2)
1271{
1272 xfs_da_args_t *args;
1273 xfs_da_state_blk_t *tmp_blk;
1274 xfs_attr_leafblock_t *leaf1, *leaf2;
1275 xfs_attr_leaf_hdr_t *hdr1, *hdr2;
1276 int count, totallen, max, space, swap;
1277
1278 /*
1279 * Set up environment.
1280 */
1281 ASSERT(blk1->magic == XFS_ATTR_LEAF_MAGIC);
1282 ASSERT(blk2->magic == XFS_ATTR_LEAF_MAGIC);
1283 leaf1 = blk1->bp->data;
1284 leaf2 = blk2->bp->data;
69ef921b
CH		 1285 ASSERT(leaf1->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1286 ASSERT(leaf2->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1da177e4
LT		 1287 args = state->args;
1288
5a5881cd
DC		 1289 trace_xfs_attr_leaf_rebalance(args);
1290
1da177e4
LT		 1291 /*
1292 * Check ordering of blocks, reverse if it makes things simpler.
1293 *
1294 * NOTE: Given that all (current) callers pass in an empty
1295 * second block, this code should never set "swap".
1296 */
1297 swap = 0;
1298 if (xfs_attr_leaf_order(blk1->bp, blk2->bp)) {
1299 tmp_blk = blk1;
1300 blk1 = blk2;
1301 blk2 = tmp_blk;
1302 leaf1 = blk1->bp->data;
1303 leaf2 = blk2->bp->data;
1304 swap = 1;
1305 }
1306 hdr1 = &leaf1->hdr;
1307 hdr2 = &leaf2->hdr;
1308
1309 /*
1310 * Examine entries until we reduce the absolute difference in
1311 * byte usage between the two blocks to a minimum. Then get
1312 * the direction to copy and the number of elements to move.
1313 *
1314 * "inleaf" is true if the new entry should be inserted into blk1.
1315 * If "swap" is also true, then reverse the sense of "inleaf".
1316 */
1317 state->inleaf = xfs_attr_leaf_figure_balance(state, blk1, blk2,
1318 &count, &totallen);
1319 if (swap)
1320 state->inleaf = !state->inleaf;
1321
1322 /*
1323 * Move any entries required from leaf to leaf:
1324 */
918ae424 1325 if (count < be16_to_cpu(hdr1->count)) {
1da177e4
LT		 1326 /*
1327 * Figure the total bytes to be added to the destination leaf.
1328 */
1329 /* number entries being moved */
918ae424
NS		 1330 count = be16_to_cpu(hdr1->count) - count;
1331 space = be16_to_cpu(hdr1->usedbytes) - totallen;
1da177e4
LT		 1332 space += count * sizeof(xfs_attr_leaf_entry_t);
1333
1334 /*
1335 * leaf2 is the destination, compact it if it looks tight.
1336 */
918ae424 1337 max = be16_to_cpu(hdr2->firstused)
1da177e4 1338 - sizeof(xfs_attr_leaf_hdr_t);
918ae424 1339 max -= be16_to_cpu(hdr2->count) * sizeof(xfs_attr_leaf_entry_t);
1da177e4
LT		 1340 if (space > max) {
1341 xfs_attr_leaf_compact(args->trans, blk2->bp);
1342 }
1343
1344 /*
1345 * Move high entries from leaf1 to low end of leaf2.
1346 */
918ae424 1347 xfs_attr_leaf_moveents(leaf1, be16_to_cpu(hdr1->count) - count,
1da177e4
LT		 1348 leaf2, 0, count, state->mp);
1349
1350 xfs_da_log_buf(args->trans, blk1->bp, 0, state->blocksize-1);
1351 xfs_da_log_buf(args->trans, blk2->bp, 0, state->blocksize-1);
918ae424 1352 } else if (count > be16_to_cpu(hdr1->count)) {
1da177e4
LT		 1353 /*
1354 * I assert that since all callers pass in an empty
1355 * second buffer, this code should never execute.
1356 */
1357
1358 /*
1359 * Figure the total bytes to be added to the destination leaf.
1360 */
1361 /* number entries being moved */
918ae424
NS		 1362 count -= be16_to_cpu(hdr1->count);
1363 space = totallen - be16_to_cpu(hdr1->usedbytes);
1da177e4
LT		 1364 space += count * sizeof(xfs_attr_leaf_entry_t);
1365
1366 /*
1367 * leaf1 is the destination, compact it if it looks tight.
1368 */
918ae424 1369 max = be16_to_cpu(hdr1->firstused)
1da177e4 1370 - sizeof(xfs_attr_leaf_hdr_t);
918ae424 1371 max -= be16_to_cpu(hdr1->count) * sizeof(xfs_attr_leaf_entry_t);
1da177e4
LT		 1372 if (space > max) {
1373 xfs_attr_leaf_compact(args->trans, blk1->bp);
1374 }
1375
1376 /*
1377 * Move low entries from leaf2 to high end of leaf1.
1378 */
1379 xfs_attr_leaf_moveents(leaf2, 0, leaf1,
918ae424 1380 be16_to_cpu(hdr1->count), count, state->mp);
1da177e4
LT		 1381
1382 xfs_da_log_buf(args->trans, blk1->bp, 0, state->blocksize-1);
1383 xfs_da_log_buf(args->trans, blk2->bp, 0, state->blocksize-1);
1384 }
1385
1386 /*
1387 * Copy out last hashval in each block for B-tree code.
1388 */
6b19f2d8
NS		 1389 blk1->hashval = be32_to_cpu(
1390 leaf1->entries[be16_to_cpu(leaf1->hdr.count)-1].hashval);
1391 blk2->hashval = be32_to_cpu(
1392 leaf2->entries[be16_to_cpu(leaf2->hdr.count)-1].hashval);
1da177e4
LT		 1393
1394 /*
1395 * Adjust the expected index for insertion.
1396 * NOTE: this code depends on the (current) situation that the
1397 * second block was originally empty.
1398 *
1399 * If the insertion point moved to the 2nd block, we must adjust
1400 * the index. We must also track the entry just following the
1401 * new entry for use in an "atomic rename" operation, that entry
1402 * is always the "old" entry and the "new" entry is what we are
1403 * inserting. The index/blkno fields refer to the "old" entry,
1404 * while the index2/blkno2 fields refer to the "new" entry.
1405 */
918ae424 1406 if (blk1->index > be16_to_cpu(leaf1->hdr.count)) {
1da177e4 1407 ASSERT(state->inleaf == 0);
918ae424 1408 blk2->index = blk1->index - be16_to_cpu(leaf1->hdr.count);
1da177e4
LT		 1409 args->index = args->index2 = blk2->index;
1410 args->blkno = args->blkno2 = blk2->blkno;
918ae424 1411 } else if (blk1->index == be16_to_cpu(leaf1->hdr.count)) {
1da177e4
LT		 1412 if (state->inleaf) {
1413 args->index = blk1->index;
1414 args->blkno = blk1->blkno;
1415 args->index2 = 0;
1416 args->blkno2 = blk2->blkno;
1417 } else {
1418 blk2->index = blk1->index
918ae424 1419 - be16_to_cpu(leaf1->hdr.count);
1da177e4
LT		 1420 args->index = args->index2 = blk2->index;
1421 args->blkno = args->blkno2 = blk2->blkno;
1422 }
1423 } else {
1424 ASSERT(state->inleaf == 1);
1425 args->index = args->index2 = blk1->index;
1426 args->blkno = args->blkno2 = blk1->blkno;
1427 }
1428}
1429
1430/*
1431 * Examine entries until we reduce the absolute difference in
1432 * byte usage between the two blocks to a minimum.
1433 * GROT: Is this really necessary? With other than a 512 byte blocksize,
1434 * GROT: there will always be enough room in either block for a new entry.
1435 * GROT: Do a double-split for this case?
1436 */
1437STATIC int
1438xfs_attr_leaf_figure_balance(xfs_da_state_t *state,
1439 xfs_da_state_blk_t *blk1,
1440 xfs_da_state_blk_t *blk2,
1441 int *countarg, int *usedbytesarg)
1442{
1443 xfs_attr_leafblock_t *leaf1, *leaf2;
1444 xfs_attr_leaf_hdr_t *hdr1, *hdr2;
1445 xfs_attr_leaf_entry_t *entry;
1446 int count, max, index, totallen, half;
1447 int lastdelta, foundit, tmp;
1448
1449 /*
1450 * Set up environment.
1451 */
1452 leaf1 = blk1->bp->data;
1453 leaf2 = blk2->bp->data;
1454 hdr1 = &leaf1->hdr;
1455 hdr2 = &leaf2->hdr;
1456 foundit = 0;
1457 totallen = 0;
1458
1459 /*
1460 * Examine entries until we reduce the absolute difference in
1461 * byte usage between the two blocks to a minimum.
1462 */
918ae424 1463 max = be16_to_cpu(hdr1->count) + be16_to_cpu(hdr2->count);
1da177e4 1464 half = (max+1) * sizeof(*entry);
918ae424
NS		 1465 half += be16_to_cpu(hdr1->usedbytes) +
1466 be16_to_cpu(hdr2->usedbytes) +
1467 xfs_attr_leaf_newentsize(
1468 state->args->namelen,
1469 state->args->valuelen,
1470 state->blocksize, NULL);
1da177e4
LT		 1471 half /= 2;
1472 lastdelta = state->blocksize;
1473 entry = &leaf1->entries[0];
1474 for (count = index = 0; count < max; entry++, index++, count++) {
1475
1476#define XFS_ATTR_ABS(A) (((A) < 0) ? -(A) : (A))
1477 /*
1478 * The new entry is in the first block, account for it.
1479 */
1480 if (count == blk1->index) {
1481 tmp = totallen + sizeof(*entry) +
aa82daa0
NS		 1482 xfs_attr_leaf_newentsize(
1483 state->args->namelen,
1484 state->args->valuelen,
1485 state->blocksize, NULL);
1da177e4
LT		 1486 if (XFS_ATTR_ABS(half - tmp) > lastdelta)
1487 break;
1488 lastdelta = XFS_ATTR_ABS(half - tmp);
1489 totallen = tmp;
1490 foundit = 1;
1491 }
1492
1493 /*
1494 * Wrap around into the second block if necessary.
1495 */
918ae424 1496 if (count == be16_to_cpu(hdr1->count)) {
1da177e4
LT		 1497 leaf1 = leaf2;
1498 entry = &leaf1->entries[0];
1499 index = 0;
1500 }
1501
1502 /*
1503 * Figure out if next leaf entry would be too much.
1504 */
1505 tmp = totallen + sizeof(*entry) + xfs_attr_leaf_entsize(leaf1,
1506 index);
1507 if (XFS_ATTR_ABS(half - tmp) > lastdelta)
1508 break;
1509 lastdelta = XFS_ATTR_ABS(half - tmp);
1510 totallen = tmp;
1511#undef XFS_ATTR_ABS
1512 }
1513
1514 /*
1515 * Calculate the number of usedbytes that will end up in lower block.
1516 * If new entry not in lower block, fix up the count.
1517 */
1518 totallen -= count * sizeof(*entry);
1519 if (foundit) {
1520 totallen -= sizeof(*entry) +
aa82daa0
NS		 1521 xfs_attr_leaf_newentsize(
1522 state->args->namelen,
1523 state->args->valuelen,
1524 state->blocksize, NULL);
1da177e4
LT		 1525 }
1526
1527 *countarg = count;
1528 *usedbytesarg = totallen;
1529 return(foundit);
1530}
1531
1532/*========================================================================
1533 * Routines used for shrinking the Btree.
1534 *========================================================================*/
1535
1536/*
1537 * Check a leaf block and its neighbors to see if the block should be
1538 * collapsed into one or the other neighbor. Always keep the block
1539 * with the smaller block number.
1540 * If the current block is over 50% full, don't try to join it, return 0.
1541 * If the block is empty, fill in the state structure and return 2.
1542 * If it can be collapsed, fill in the state structure and return 1.
1543 * If nothing can be done, return 0.
1544 *
1545 * GROT: allow for INCOMPLETE entries in calculation.
1546 */
1547int
1548xfs_attr_leaf_toosmall(xfs_da_state_t *state, int *action)
1549{
1550 xfs_attr_leafblock_t *leaf;
1551 xfs_da_state_blk_t *blk;
1552 xfs_da_blkinfo_t *info;
1553 int count, bytes, forward, error, retval, i;
1554 xfs_dablk_t blkno;
1555 xfs_dabuf_t *bp;
1556
1557 /*
1558 * Check for the degenerate case of the block being over 50% full.
1559 * If so, it's not worth even looking to see if we might be able
1560 * to coalesce with a sibling.
1561 */
1562 blk = &state->path.blk[ state->path.active-1 ];
1563 info = blk->bp->data;
69ef921b 1564 ASSERT(info->magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1da177e4 1565 leaf = (xfs_attr_leafblock_t *)info;
918ae424 1566 count = be16_to_cpu(leaf->hdr.count);
1da177e4
LT		 1567 bytes = sizeof(xfs_attr_leaf_hdr_t) +
1568 count * sizeof(xfs_attr_leaf_entry_t) +
918ae424 1569 be16_to_cpu(leaf->hdr.usedbytes);
1da177e4
LT		 1570 if (bytes > (state->blocksize >> 1)) {
1571 *action = 0; /* blk over 50%, don't try to join */
1572 return(0);
1573 }
1574
1575 /*
1576 * Check for the degenerate case of the block being empty.
1577 * If the block is empty, we'll simply delete it, no need to
c41564b5 1578 * coalesce it with a sibling block. We choose (arbitrarily)
1da177e4
LT		 1579 * to merge with the forward block unless it is NULL.
1580 */
1581 if (count == 0) {
1582 /*
1583 * Make altpath point to the block we want to keep and
1584 * path point to the block we want to drop (this one).
1585 */
89da0544 1586 forward = (info->forw != 0);
1da177e4
LT		 1587 memcpy(&state->altpath, &state->path, sizeof(state->path));
1588 error = xfs_da_path_shift(state, &state->altpath, forward,
1589 0, &retval);
1590 if (error)
1591 return(error);
1592 if (retval) {
1593 *action = 0;
1594 } else {
1595 *action = 2;
1596 }
1597 return(0);
1598 }
1599
1600 /*
1601 * Examine each sibling block to see if we can coalesce with
1602 * at least 25% free space to spare. We need to figure out
1603 * whether to merge with the forward or the backward block.
1604 * We prefer coalescing with the lower numbered sibling so as
1605 * to shrink an attribute list over time.
1606 */
1607 /* start with smaller blk num */
89da0544 1608 forward = (be32_to_cpu(info->forw) < be32_to_cpu(info->back));
1da177e4
LT		 1609 for (i = 0; i < 2; forward = !forward, i++) {
1610 if (forward)
89da0544 1611 blkno = be32_to_cpu(info->forw);
1da177e4 1612 else
89da0544 1613 blkno = be32_to_cpu(info->back);
1da177e4
LT		 1614 if (blkno == 0)
1615 continue;
1616 error = xfs_da_read_buf(state->args->trans, state->args->dp,
1617 blkno, -1, &bp, XFS_ATTR_FORK);
1618 if (error)
1619 return(error);
1620 ASSERT(bp != NULL);
1621
1622 leaf = (xfs_attr_leafblock_t *)info;
918ae424 1623 count = be16_to_cpu(leaf->hdr.count);
1da177e4 1624 bytes = state->blocksize - (state->blocksize>>2);
918ae424 1625 bytes -= be16_to_cpu(leaf->hdr.usedbytes);
1da177e4 1626 leaf = bp->data;
69ef921b 1627 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
918ae424
NS		 1628 count += be16_to_cpu(leaf->hdr.count);
1629 bytes -= be16_to_cpu(leaf->hdr.usedbytes);
1da177e4
LT		 1630 bytes -= count * sizeof(xfs_attr_leaf_entry_t);
1631 bytes -= sizeof(xfs_attr_leaf_hdr_t);
1632 xfs_da_brelse(state->args->trans, bp);
1633 if (bytes >= 0)
1634 break; /* fits with at least 25% to spare */
1635 }
1636 if (i >= 2) {
1637 *action = 0;
1638 return(0);
1639 }
1640
1641 /*
1642 * Make altpath point to the block we want to keep (the lower
1643 * numbered block) and path point to the block we want to drop.
1644 */
1645 memcpy(&state->altpath, &state->path, sizeof(state->path));
1646 if (blkno < blk->blkno) {
1647 error = xfs_da_path_shift(state, &state->altpath, forward,
1648 0, &retval);
1649 } else {
1650 error = xfs_da_path_shift(state, &state->path, forward,
1651 0, &retval);
1652 }
1653 if (error)
1654 return(error);
1655 if (retval) {
1656 *action = 0;
1657 } else {
1658 *action = 1;
1659 }
1660 return(0);
1661}
1662
1663/*
1664 * Remove a name from the leaf attribute list structure.
1665 *
1666 * Return 1 if leaf is less than 37% full, 0 if >= 37% full.
1667 * If two leaves are 37% full, when combined they will leave 25% free.
1668 */
1669int
1670xfs_attr_leaf_remove(xfs_dabuf_t *bp, xfs_da_args_t *args)
1671{
1672 xfs_attr_leafblock_t *leaf;
1673 xfs_attr_leaf_hdr_t *hdr;
1674 xfs_attr_leaf_map_t *map;
1675 xfs_attr_leaf_entry_t *entry;
1676 int before, after, smallest, entsize;
1677 int tablesize, tmp, i;
1678 xfs_mount_t *mp;
1679
1680 leaf = bp->data;
69ef921b 1681 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1da177e4
LT		 1682 hdr = &leaf->hdr;
1683 mp = args->trans->t_mountp;
918ae424
NS		 1684 ASSERT((be16_to_cpu(hdr->count) > 0)
1685 && (be16_to_cpu(hdr->count) < (XFS_LBSIZE(mp)/8)));
1da177e4 1686 ASSERT((args->index >= 0)
918ae424
NS		 1687 && (args->index < be16_to_cpu(hdr->count)));
1688 ASSERT(be16_to_cpu(hdr->firstused) >=
1689 ((be16_to_cpu(hdr->count) * sizeof(*entry)) + sizeof(*hdr)));
1da177e4 1690 entry = &leaf->entries[args->index];
6b19f2d8
NS		 1691 ASSERT(be16_to_cpu(entry->nameidx) >= be16_to_cpu(hdr->firstused));
1692 ASSERT(be16_to_cpu(entry->nameidx) < XFS_LBSIZE(mp));
1da177e4
LT		 1693
1694 /*
1695 * Scan through free region table:
1696 * check for adjacency of free'd entry with an existing one,
1697 * find smallest free region in case we need to replace it,
1698 * adjust any map that borders the entry table,
1699 */
918ae424 1700 tablesize = be16_to_cpu(hdr->count) * sizeof(xfs_attr_leaf_entry_t)
1da177e4
LT		 1701 + sizeof(xfs_attr_leaf_hdr_t);
1702 map = &hdr->freemap[0];
918ae424 1703 tmp = be16_to_cpu(map->size);
1da177e4
LT		 1704 before = after = -1;
1705 smallest = XFS_ATTR_LEAF_MAPSIZE - 1;
1706 entsize = xfs_attr_leaf_entsize(leaf, args->index);
1707 for (i = 0; i < XFS_ATTR_LEAF_MAPSIZE; map++, i++) {
918ae424
NS		 1708 ASSERT(be16_to_cpu(map->base) < XFS_LBSIZE(mp));
1709 ASSERT(be16_to_cpu(map->size) < XFS_LBSIZE(mp));
1710 if (be16_to_cpu(map->base) == tablesize) {
413d57c9 1711 be16_add_cpu(&map->base,
918ae424 1712 -((int)sizeof(xfs_attr_leaf_entry_t)));
413d57c9 1713 be16_add_cpu(&map->size, sizeof(xfs_attr_leaf_entry_t));
1da177e4
LT		 1714 }
1715
918ae424 1716 if ((be16_to_cpu(map->base) + be16_to_cpu(map->size))
6b19f2d8 1717 == be16_to_cpu(entry->nameidx)) {
1da177e4 1718 before = i;
918ae424 1719 } else if (be16_to_cpu(map->base)
6b19f2d8 1720 == (be16_to_cpu(entry->nameidx) + entsize)) {
1da177e4 1721 after = i;
918ae424
NS		 1722 } else if (be16_to_cpu(map->size) < tmp) {
1723 tmp = be16_to_cpu(map->size);
1da177e4
LT		 1724 smallest = i;
1725 }
1726 }
1727
1728 /*
1729 * Coalesce adjacent freemap regions,
1730 * or replace the smallest region.
1731 */
1732 if ((before >= 0) || (after >= 0)) {
1733 if ((before >= 0) && (after >= 0)) {
1734 map = &hdr->freemap[before];
413d57c9
MS		 1735 be16_add_cpu(&map->size, entsize);
1736 be16_add_cpu(&map->size,
918ae424 1737 be16_to_cpu(hdr->freemap[after].size));
1da177e4
LT		 1738 hdr->freemap[after].base = 0;
1739 hdr->freemap[after].size = 0;
1740 } else if (before >= 0) {
1741 map = &hdr->freemap[before];
413d57c9 1742 be16_add_cpu(&map->size, entsize);
1da177e4
LT		 1743 } else {
1744 map = &hdr->freemap[after];
1745 /* both on-disk, don't endian flip twice */
1746 map->base = entry->nameidx;
413d57c9 1747 be16_add_cpu(&map->size, entsize);
1da177e4
LT		 1748 }
1749 } else {
1750 /*
1751 * Replace smallest region (if it is smaller than free'd entry)
1752 */
1753 map = &hdr->freemap[smallest];
918ae424 1754 if (be16_to_cpu(map->size) < entsize) {
6b19f2d8 1755 map->base = cpu_to_be16(be16_to_cpu(entry->nameidx));
918ae424 1756 map->size = cpu_to_be16(entsize);
1da177e4
LT		 1757 }
1758 }
1759
1760 /*
1761 * Did we remove the first entry?
1762 */
6b19f2d8 1763 if (be16_to_cpu(entry->nameidx) == be16_to_cpu(hdr->firstused))
1da177e4
LT		 1764 smallest = 1;
1765 else
1766 smallest = 0;
1767
1768 /*
1769 * Compress the remaining entries and zero out the removed stuff.
1770 */
c9fb86a9 1771 memset(xfs_attr_leaf_name(leaf, args->index), 0, entsize);
413d57c9 1772 be16_add_cpu(&hdr->usedbytes, -entsize);
1da177e4 1773 xfs_da_log_buf(args->trans, bp,
c9fb86a9 1774 XFS_DA_LOGRANGE(leaf, xfs_attr_leaf_name(leaf, args->index),
1da177e4
LT		 1775 entsize));
1776
918ae424 1777 tmp = (be16_to_cpu(hdr->count) - args->index)
1da177e4
LT		 1778 * sizeof(xfs_attr_leaf_entry_t);
1779 memmove((char *)entry, (char *)(entry+1), tmp);
413d57c9 1780 be16_add_cpu(&hdr->count, -1);
1da177e4
LT		 1781 xfs_da_log_buf(args->trans, bp,
1782 XFS_DA_LOGRANGE(leaf, entry, tmp + sizeof(*entry)));
918ae424 1783 entry = &leaf->entries[be16_to_cpu(hdr->count)];
1da177e4
LT		 1784 memset((char *)entry, 0, sizeof(xfs_attr_leaf_entry_t));
1785
1786 /*
1787 * If we removed the first entry, re-find the first used byte
1788 * in the name area. Note that if the entry was the "firstused",
1789 * then we don't have a "hole" in our block resulting from
1790 * removing the name.
1791 */
1792 if (smallest) {
1793 tmp = XFS_LBSIZE(mp);
1794 entry = &leaf->entries[0];
918ae424 1795 for (i = be16_to_cpu(hdr->count)-1; i >= 0; entry++, i--) {
6b19f2d8
NS		 1796 ASSERT(be16_to_cpu(entry->nameidx) >=
1797 be16_to_cpu(hdr->firstused));
1798 ASSERT(be16_to_cpu(entry->nameidx) < XFS_LBSIZE(mp));
1799
1800 if (be16_to_cpu(entry->nameidx) < tmp)
1801 tmp = be16_to_cpu(entry->nameidx);
1da177e4 1802 }
918ae424 1803 hdr->firstused = cpu_to_be16(tmp);
1da177e4 1804 if (!hdr->firstused) {
918ae424 1805 hdr->firstused = cpu_to_be16(
1da177e4
LT		 1806 tmp - XFS_ATTR_LEAF_NAME_ALIGN);
1807 }
1808 } else {
1809 hdr->holes = 1; /* mark as needing compaction */
1810 }
1811 xfs_da_log_buf(args->trans, bp,
1812 XFS_DA_LOGRANGE(leaf, hdr, sizeof(*hdr)));
1813
1814 /*
1815 * Check if leaf is less than 50% full, caller may want to
1816 * "join" the leaf with a sibling if so.
1817 */
1818 tmp = sizeof(xfs_attr_leaf_hdr_t);
918ae424
NS		 1819 tmp += be16_to_cpu(leaf->hdr.count) * sizeof(xfs_attr_leaf_entry_t);
1820 tmp += be16_to_cpu(leaf->hdr.usedbytes);
1da177e4
LT		 1821 return(tmp < mp->m_attr_magicpct); /* leaf is < 37% full */
1822}
1823
1824/*
1825 * Move all the attribute list entries from drop_leaf into save_leaf.
1826 */
1827void
1828xfs_attr_leaf_unbalance(xfs_da_state_t *state, xfs_da_state_blk_t *drop_blk,
1829 xfs_da_state_blk_t *save_blk)
1830{
1831 xfs_attr_leafblock_t *drop_leaf, *save_leaf, *tmp_leaf;
1832 xfs_attr_leaf_hdr_t *drop_hdr, *save_hdr, *tmp_hdr;
1833 xfs_mount_t *mp;
1834 char *tmpbuffer;
1835
5a5881cd
DC		 1836 trace_xfs_attr_leaf_unbalance(state->args);
1837
1da177e4
LT		 1838 /*
1839 * Set up environment.
1840 */
1841 mp = state->mp;
1842 ASSERT(drop_blk->magic == XFS_ATTR_LEAF_MAGIC);
1843 ASSERT(save_blk->magic == XFS_ATTR_LEAF_MAGIC);
1844 drop_leaf = drop_blk->bp->data;
1845 save_leaf = save_blk->bp->data;
69ef921b
CH		 1846 ASSERT(drop_leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1847 ASSERT(save_leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1da177e4
LT		 1848 drop_hdr = &drop_leaf->hdr;
1849 save_hdr = &save_leaf->hdr;
1850
1851 /*
1852 * Save last hashval from dying block for later Btree fixup.
1853 */
6b19f2d8
NS		 1854 drop_blk->hashval = be32_to_cpu(
1855 drop_leaf->entries[be16_to_cpu(drop_leaf->hdr.count)-1].hashval);
1da177e4
LT		 1856
1857 /*
1858 * Check if we need a temp buffer, or can we do it in place.
1859 * Note that we don't check "leaf" for holes because we will
1860 * always be dropping it, toosmall() decided that for us already.
1861 */
1862 if (save_hdr->holes == 0) {
1863 /*
1864 * dest leaf has no holes, so we add there. May need
1865 * to make some room in the entry array.
1866 */
1867 if (xfs_attr_leaf_order(save_blk->bp, drop_blk->bp)) {
1868 xfs_attr_leaf_moveents(drop_leaf, 0, save_leaf, 0,
918ae424 1869 be16_to_cpu(drop_hdr->count), mp);
1da177e4
LT		 1870 } else {
1871 xfs_attr_leaf_moveents(drop_leaf, 0, save_leaf,
918ae424
NS		 1872 be16_to_cpu(save_hdr->count),
1873 be16_to_cpu(drop_hdr->count), mp);
1da177e4
LT		 1874 }
1875 } else {
1876 /*
1877 * Destination has holes, so we make a temporary copy
1878 * of the leaf and add them both to that.
1879 */
1880 tmpbuffer = kmem_alloc(state->blocksize, KM_SLEEP);
1881 ASSERT(tmpbuffer != NULL);
1882 memset(tmpbuffer, 0, state->blocksize);
1883 tmp_leaf = (xfs_attr_leafblock_t *)tmpbuffer;
1884 tmp_hdr = &tmp_leaf->hdr;
1885 tmp_hdr->info = save_hdr->info; /* struct copy */
1886 tmp_hdr->count = 0;
918ae424 1887 tmp_hdr->firstused = cpu_to_be16(state->blocksize);
1da177e4 1888 if (!tmp_hdr->firstused) {
918ae424 1889 tmp_hdr->firstused = cpu_to_be16(
1da177e4
LT		 1890 state->blocksize - XFS_ATTR_LEAF_NAME_ALIGN);
1891 }
1892 tmp_hdr->usedbytes = 0;
1893 if (xfs_attr_leaf_order(save_blk->bp, drop_blk->bp)) {
1894 xfs_attr_leaf_moveents(drop_leaf, 0, tmp_leaf, 0,
918ae424 1895 be16_to_cpu(drop_hdr->count), mp);
1da177e4 1896 xfs_attr_leaf_moveents(save_leaf, 0, tmp_leaf,
918ae424
NS		 1897 be16_to_cpu(tmp_leaf->hdr.count),
1898 be16_to_cpu(save_hdr->count), mp);
1da177e4
LT		 1899 } else {
1900 xfs_attr_leaf_moveents(save_leaf, 0, tmp_leaf, 0,
918ae424 1901 be16_to_cpu(save_hdr->count), mp);
1da177e4 1902 xfs_attr_leaf_moveents(drop_leaf, 0, tmp_leaf,
918ae424
NS		 1903 be16_to_cpu(tmp_leaf->hdr.count),
1904 be16_to_cpu(drop_hdr->count), mp);
1da177e4
LT		 1905 }
1906 memcpy((char *)save_leaf, (char *)tmp_leaf, state->blocksize);
f0e2d93c 1907 kmem_free(tmpbuffer);
1da177e4
LT		 1908 }
1909
1910 xfs_da_log_buf(state->args->trans, save_blk->bp, 0,
1911 state->blocksize - 1);
1912
1913 /*
1914 * Copy out last hashval in each block for B-tree code.
1915 */
6b19f2d8
NS		 1916 save_blk->hashval = be32_to_cpu(
1917 save_leaf->entries[be16_to_cpu(save_leaf->hdr.count)-1].hashval);
1da177e4
LT		 1918}
1919
1920/*========================================================================
1921 * Routines used for finding things in the Btree.
1922 *========================================================================*/
1923
1924/*
1925 * Look up a name in a leaf attribute list structure.
1926 * This is the internal routine, it uses the caller's buffer.
1927 *
1928 * Note that duplicate keys are allowed, but only check within the
1929 * current leaf node. The Btree code must check in adjacent leaf nodes.
1930 *
1931 * Return in args->index the index into the entry[] array of either
1932 * the found entry, or where the entry should have been (insert before
1933 * that entry).
1934 *
1935 * Don't change the args->value unless we find the attribute.
1936 */
1937int
1938xfs_attr_leaf_lookup_int(xfs_dabuf_t *bp, xfs_da_args_t *args)
1939{
1940 xfs_attr_leafblock_t *leaf;
1941 xfs_attr_leaf_entry_t *entry;
1942 xfs_attr_leaf_name_local_t *name_loc;
1943 xfs_attr_leaf_name_remote_t *name_rmt;
1944 int probe, span;
1945 xfs_dahash_t hashval;
1946
5a5881cd
DC		 1947 trace_xfs_attr_leaf_lookup(args);
1948
1da177e4 1949 leaf = bp->data;
69ef921b 1950 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
918ae424 1951 ASSERT(be16_to_cpu(leaf->hdr.count)
1da177e4
LT		 1952 < (XFS_LBSIZE(args->dp->i_mount)/8));
1953
1954 /*
1955 * Binary search. (note: small blocks will skip this loop)
1956 */
1957 hashval = args->hashval;
918ae424 1958 probe = span = be16_to_cpu(leaf->hdr.count) / 2;
1da177e4
LT		 1959 for (entry = &leaf->entries[probe]; span > 4;
1960 entry = &leaf->entries[probe]) {
1961 span /= 2;
6b19f2d8 1962 if (be32_to_cpu(entry->hashval) < hashval)
1da177e4 1963 probe += span;
6b19f2d8 1964 else if (be32_to_cpu(entry->hashval) > hashval)
1da177e4
LT		 1965 probe -= span;
1966 else
1967 break;
1968 }
726801ba 1969 ASSERT((probe >= 0) &&
1da177e4 1970 (!leaf->hdr.count
918ae424 1971 || (probe < be16_to_cpu(leaf->hdr.count))));
6b19f2d8 1972 ASSERT((span <= 4) || (be32_to_cpu(entry->hashval) == hashval));
1da177e4
LT		 1973
1974 /*
1975 * Since we may have duplicate hashval's, find the first matching
1976 * hashval in the leaf.
1977 */
6b19f2d8 1978 while ((probe > 0) && (be32_to_cpu(entry->hashval) >= hashval)) {
1da177e4
LT		 1979 entry--;
1980 probe--;
1981 }
6b19f2d8
NS		 1982 while ((probe < be16_to_cpu(leaf->hdr.count)) &&
1983 (be32_to_cpu(entry->hashval) < hashval)) {
1da177e4
LT		 1984 entry++;
1985 probe++;
1986 }
6b19f2d8
NS		 1987 if ((probe == be16_to_cpu(leaf->hdr.count)) ||
1988 (be32_to_cpu(entry->hashval) != hashval)) {
1da177e4
LT		 1989 args->index = probe;
1990 return(XFS_ERROR(ENOATTR));
1991 }
1992
1993 /*
1994 * Duplicate keys may be present, so search all of them for a match.
1995 */
6b19f2d8
NS		 1996 for ( ; (probe < be16_to_cpu(leaf->hdr.count)) &&
1997 (be32_to_cpu(entry->hashval) == hashval);
1da177e4
LT		 1998 entry++, probe++) {
1999/*
2000 * GROT: Add code to remove incomplete entries.
2001 */
2002 /*
2003 * If we are looking for INCOMPLETE entries, show only those.
2004 * If we are looking for complete entries, show only those.
2005 */
2006 if ((args->flags & XFS_ATTR_INCOMPLETE) !=
2007 (entry->flags & XFS_ATTR_INCOMPLETE)) {
2008 continue;
2009 }
2010 if (entry->flags & XFS_ATTR_LOCAL) {
c9fb86a9 2011 name_loc = xfs_attr_leaf_name_local(leaf, probe);
1da177e4
LT		 2012 if (name_loc->namelen != args->namelen)
2013 continue;
726801ba 2014 if (memcmp(args->name, (char *)name_loc->nameval, args->namelen) != 0)
1da177e4 2015 continue;
726801ba 2016 if (!xfs_attr_namesp_match(args->flags, entry->flags))
1da177e4
LT		 2017 continue;
2018 args->index = probe;
2019 return(XFS_ERROR(EEXIST));
2020 } else {
c9fb86a9 2021 name_rmt = xfs_attr_leaf_name_remote(leaf, probe);
1da177e4
LT		 2022 if (name_rmt->namelen != args->namelen)
2023 continue;
2024 if (memcmp(args->name, (char *)name_rmt->name,
2025 args->namelen) != 0)
2026 continue;
726801ba 2027 if (!xfs_attr_namesp_match(args->flags, entry->flags))
1da177e4
LT		 2028 continue;
2029 args->index = probe;
c0f054e7 2030 args->rmtblkno = be32_to_cpu(name_rmt->valueblk);
1da177e4 2031 args->rmtblkcnt = XFS_B_TO_FSB(args->dp->i_mount,
c0f054e7 2032 be32_to_cpu(name_rmt->valuelen));
1da177e4
LT		 2033 return(XFS_ERROR(EEXIST));
2034 }
2035 }
2036 args->index = probe;
2037 return(XFS_ERROR(ENOATTR));
2038}
2039
2040/*
2041 * Get the value associated with an attribute name from a leaf attribute
2042 * list structure.
2043 */
2044int
2045xfs_attr_leaf_getvalue(xfs_dabuf_t *bp, xfs_da_args_t *args)
2046{
2047 int valuelen;
2048 xfs_attr_leafblock_t *leaf;
2049 xfs_attr_leaf_entry_t *entry;
2050 xfs_attr_leaf_name_local_t *name_loc;
2051 xfs_attr_leaf_name_remote_t *name_rmt;
2052
2053 leaf = bp->data;
69ef921b 2054 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
918ae424 2055 ASSERT(be16_to_cpu(leaf->hdr.count)
1da177e4 2056 < (XFS_LBSIZE(args->dp->i_mount)/8));
918ae424 2057 ASSERT(args->index < be16_to_cpu(leaf->hdr.count));
1da177e4
LT		 2058
2059 entry = &leaf->entries[args->index];
2060 if (entry->flags & XFS_ATTR_LOCAL) {
c9fb86a9 2061 name_loc = xfs_attr_leaf_name_local(leaf, args->index);
1da177e4
LT		 2062 ASSERT(name_loc->namelen == args->namelen);
2063 ASSERT(memcmp(args->name, name_loc->nameval, args->namelen) == 0);
053b5758 2064 valuelen = be16_to_cpu(name_loc->valuelen);
1da177e4
LT		 2065 if (args->flags & ATTR_KERNOVAL) {
2066 args->valuelen = valuelen;
2067 return(0);
2068 }
2069 if (args->valuelen < valuelen) {
2070 args->valuelen = valuelen;
2071 return(XFS_ERROR(ERANGE));
2072 }
2073 args->valuelen = valuelen;
2074 memcpy(args->value, &name_loc->nameval[args->namelen], valuelen);
2075 } else {
c9fb86a9 2076 name_rmt = xfs_attr_leaf_name_remote(leaf, args->index);
1da177e4
LT		 2077 ASSERT(name_rmt->namelen == args->namelen);
2078 ASSERT(memcmp(args->name, name_rmt->name, args->namelen) == 0);
c0f054e7
NS		 2079 valuelen = be32_to_cpu(name_rmt->valuelen);
2080 args->rmtblkno = be32_to_cpu(name_rmt->valueblk);
1da177e4
LT		 2081 args->rmtblkcnt = XFS_B_TO_FSB(args->dp->i_mount, valuelen);
2082 if (args->flags & ATTR_KERNOVAL) {
2083 args->valuelen = valuelen;
2084 return(0);
2085 }
2086 if (args->valuelen < valuelen) {
2087 args->valuelen = valuelen;
2088 return(XFS_ERROR(ERANGE));
2089 }
2090 args->valuelen = valuelen;
2091 }
2092 return(0);
2093}
2094
2095/*========================================================================
2096 * Utility routines.
2097 *========================================================================*/
2098
2099/*
2100 * Move the indicated entries from one leaf to another.
2101 * NOTE: this routine modifies both source and destination leaves.
2102 */
2103/*ARGSUSED*/
2104STATIC void
2105xfs_attr_leaf_moveents(xfs_attr_leafblock_t *leaf_s, int start_s,
2106 xfs_attr_leafblock_t *leaf_d, int start_d,
2107 int count, xfs_mount_t *mp)
2108{
2109 xfs_attr_leaf_hdr_t *hdr_s, *hdr_d;
2110 xfs_attr_leaf_entry_t *entry_s, *entry_d;
2111 int desti, tmp, i;
2112
2113 /*
2114 * Check for nothing to do.
2115 */
2116 if (count == 0)
2117 return;
2118
2119 /*
2120 * Set up environment.
2121 */
69ef921b
CH		 2122 ASSERT(leaf_s->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
2123 ASSERT(leaf_d->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1da177e4
LT		 2124 hdr_s = &leaf_s->hdr;
2125 hdr_d = &leaf_d->hdr;
918ae424
NS		 2126 ASSERT((be16_to_cpu(hdr_s->count) > 0) &&
2127 (be16_to_cpu(hdr_s->count) < (XFS_LBSIZE(mp)/8)));
2128 ASSERT(be16_to_cpu(hdr_s->firstused) >=
2129 ((be16_to_cpu(hdr_s->count)
1da177e4 2130 * sizeof(*entry_s))+sizeof(*hdr_s)));
918ae424
NS		 2131 ASSERT(be16_to_cpu(hdr_d->count) < (XFS_LBSIZE(mp)/8));
2132 ASSERT(be16_to_cpu(hdr_d->firstused) >=
2133 ((be16_to_cpu(hdr_d->count)
1da177e4
LT		 2134 * sizeof(*entry_d))+sizeof(*hdr_d)));
2135
918ae424
NS		 2136 ASSERT(start_s < be16_to_cpu(hdr_s->count));
2137 ASSERT(start_d <= be16_to_cpu(hdr_d->count));
2138 ASSERT(count <= be16_to_cpu(hdr_s->count));
1da177e4
LT		 2139
2140 /*
2141 * Move the entries in the destination leaf up to make a hole?
2142 */
918ae424
NS		 2143 if (start_d < be16_to_cpu(hdr_d->count)) {
2144 tmp = be16_to_cpu(hdr_d->count) - start_d;
1da177e4
LT		 2145 tmp *= sizeof(xfs_attr_leaf_entry_t);
2146 entry_s = &leaf_d->entries[start_d];
2147 entry_d = &leaf_d->entries[start_d + count];
2148 memmove((char *)entry_d, (char *)entry_s, tmp);
2149 }
2150
2151 /*
2152 * Copy all entry's in the same (sorted) order,
2153 * but allocate attribute info packed and in sequence.
2154 */
2155 entry_s = &leaf_s->entries[start_s];
2156 entry_d = &leaf_d->entries[start_d];
2157 desti = start_d;
2158 for (i = 0; i < count; entry_s++, entry_d++, desti++, i++) {
6b19f2d8 2159 ASSERT(be16_to_cpu(entry_s->nameidx)
918ae424 2160 >= be16_to_cpu(hdr_s->firstused));
1da177e4
LT		 2161 tmp = xfs_attr_leaf_entsize(leaf_s, start_s + i);
2162#ifdef GROT
2163 /*
2164 * Code to drop INCOMPLETE entries. Difficult to use as we
2165 * may also need to change the insertion index. Code turned
2166 * off for 6.2, should be revisited later.
2167 */
2168 if (entry_s->flags & XFS_ATTR_INCOMPLETE) { /* skip partials? */
c9fb86a9 2169 memset(xfs_attr_leaf_name(leaf_s, start_s + i), 0, tmp);
413d57c9
MS		 2170 be16_add_cpu(&hdr_s->usedbytes, -tmp);
2171 be16_add_cpu(&hdr_s->count, -1);
1da177e4
LT		 2172 entry_d--; /* to compensate for ++ in loop hdr */
2173 desti--;
2174 if ((start_s + i) < offset)
2175 result++; /* insertion index adjustment */
2176 } else {
2177#endif /* GROT */
413d57c9 2178 be16_add_cpu(&hdr_d->firstused, -tmp);
1da177e4
LT		 2179 /* both on-disk, don't endian flip twice */
2180 entry_d->hashval = entry_s->hashval;
2181 /* both on-disk, don't endian flip twice */
2182 entry_d->nameidx = hdr_d->firstused;
2183 entry_d->flags = entry_s->flags;
6b19f2d8 2184 ASSERT(be16_to_cpu(entry_d->nameidx) + tmp
1da177e4 2185 <= XFS_LBSIZE(mp));
c9fb86a9
ES		 2186 memmove(xfs_attr_leaf_name(leaf_d, desti),
2187 xfs_attr_leaf_name(leaf_s, start_s + i), tmp);
6b19f2d8 2188 ASSERT(be16_to_cpu(entry_s->nameidx) + tmp
1da177e4 2189 <= XFS_LBSIZE(mp));
c9fb86a9 2190 memset(xfs_attr_leaf_name(leaf_s, start_s + i), 0, tmp);
413d57c9
MS		 2191 be16_add_cpu(&hdr_s->usedbytes, -tmp);
2192 be16_add_cpu(&hdr_d->usedbytes, tmp);
2193 be16_add_cpu(&hdr_s->count, -1);
2194 be16_add_cpu(&hdr_d->count, 1);
918ae424 2195 tmp = be16_to_cpu(hdr_d->count)
1da177e4
LT		 2196 * sizeof(xfs_attr_leaf_entry_t)
2197 + sizeof(xfs_attr_leaf_hdr_t);
918ae424 2198 ASSERT(be16_to_cpu(hdr_d->firstused) >= tmp);
1da177e4
LT		 2199#ifdef GROT
2200 }
2201#endif /* GROT */
2202 }
2203
2204 /*
2205 * Zero out the entries we just copied.
2206 */
918ae424 2207 if (start_s == be16_to_cpu(hdr_s->count)) {
1da177e4
LT		 2208 tmp = count * sizeof(xfs_attr_leaf_entry_t);
2209 entry_s = &leaf_s->entries[start_s];
2210 ASSERT(((char *)entry_s + tmp) <=
2211 ((char *)leaf_s + XFS_LBSIZE(mp)));
2212 memset((char *)entry_s, 0, tmp);
2213 } else {
2214 /*
2215 * Move the remaining entries down to fill the hole,
2216 * then zero the entries at the top.
2217 */
918ae424 2218 tmp = be16_to_cpu(hdr_s->count) - count;
1da177e4
LT		 2219 tmp *= sizeof(xfs_attr_leaf_entry_t);
2220 entry_s = &leaf_s->entries[start_s + count];
2221 entry_d = &leaf_s->entries[start_s];
2222 memmove((char *)entry_d, (char *)entry_s, tmp);
2223
2224 tmp = count * sizeof(xfs_attr_leaf_entry_t);
918ae424 2225 entry_s = &leaf_s->entries[be16_to_cpu(hdr_s->count)];
1da177e4
LT		 2226 ASSERT(((char *)entry_s + tmp) <=
2227 ((char *)leaf_s + XFS_LBSIZE(mp)));
2228 memset((char *)entry_s, 0, tmp);
2229 }
2230
2231 /*
2232 * Fill in the freemap information
2233 */
918ae424 2234 hdr_d->freemap[0].base = cpu_to_be16(sizeof(xfs_attr_leaf_hdr_t));
413d57c9 2235 be16_add_cpu(&hdr_d->freemap[0].base, be16_to_cpu(hdr_d->count) *
918ae424
NS		 2236 sizeof(xfs_attr_leaf_entry_t));
2237 hdr_d->freemap[0].size = cpu_to_be16(be16_to_cpu(hdr_d->firstused)
2238 - be16_to_cpu(hdr_d->freemap[0].base));
1da177e4
LT		 2239 hdr_d->freemap[1].base = 0;
2240 hdr_d->freemap[2].base = 0;
2241 hdr_d->freemap[1].size = 0;
2242 hdr_d->freemap[2].size = 0;
2243 hdr_s->holes = 1; /* leaf may not be compact */
2244}
2245
2246/*
2247 * Compare two leaf blocks "order".
2248 * Return 0 unless leaf2 should go before leaf1.
2249 */
2250int
2251xfs_attr_leaf_order(xfs_dabuf_t *leaf1_bp, xfs_dabuf_t *leaf2_bp)
2252{
2253 xfs_attr_leafblock_t *leaf1, *leaf2;
2254
2255 leaf1 = leaf1_bp->data;
2256 leaf2 = leaf2_bp->data;
69ef921b
CH		 2257 ASSERT((leaf1->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC)) &&
2258 (leaf2->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC)));
918ae424
NS		 2259 if ((be16_to_cpu(leaf1->hdr.count) > 0) &&
2260 (be16_to_cpu(leaf2->hdr.count) > 0) &&
6b19f2d8
NS		 2261 ((be32_to_cpu(leaf2->entries[0].hashval) <
2262 be32_to_cpu(leaf1->entries[0].hashval)) ||
2263 (be32_to_cpu(leaf2->entries[
2264 be16_to_cpu(leaf2->hdr.count)-1].hashval) <
2265 be32_to_cpu(leaf1->entries[
2266 be16_to_cpu(leaf1->hdr.count)-1].hashval)))) {
1da177e4
LT		 2267 return(1);
2268 }
2269 return(0);
2270}
2271
2272/*
2273 * Pick up the last hashvalue from a leaf block.
2274 */
2275xfs_dahash_t
2276xfs_attr_leaf_lasthash(xfs_dabuf_t *bp, int *count)
2277{
2278 xfs_attr_leafblock_t *leaf;
2279
2280 leaf = bp->data;
69ef921b 2281 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1da177e4 2282 if (count)
918ae424 2283 *count = be16_to_cpu(leaf->hdr.count);
1da177e4
LT		 2284 if (!leaf->hdr.count)
2285 return(0);
6b19f2d8 2286 return be32_to_cpu(leaf->entries[be16_to_cpu(leaf->hdr.count)-1].hashval);
1da177e4
LT		 2287}
2288
2289/*
2290 * Calculate the number of bytes used to store the indicated attribute
2291 * (whether local or remote only calculate bytes in this block).
2292 */
ba0f32d4 2293STATIC int
1da177e4
LT		 2294xfs_attr_leaf_entsize(xfs_attr_leafblock_t *leaf, int index)
2295{
2296 xfs_attr_leaf_name_local_t *name_loc;
2297 xfs_attr_leaf_name_remote_t *name_rmt;
2298 int size;
2299
69ef921b 2300 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1da177e4 2301 if (leaf->entries[index].flags & XFS_ATTR_LOCAL) {
c9fb86a9
ES		 2302 name_loc = xfs_attr_leaf_name_local(leaf, index);
2303 size = xfs_attr_leaf_entsize_local(name_loc->namelen,
053b5758 2304 be16_to_cpu(name_loc->valuelen));
1da177e4 2305 } else {
c9fb86a9
ES		 2306 name_rmt = xfs_attr_leaf_name_remote(leaf, index);
2307 size = xfs_attr_leaf_entsize_remote(name_rmt->namelen);
1da177e4
LT		 2308 }
2309 return(size);
2310}
2311
2312/*
2313 * Calculate the number of bytes that would be required to store the new
2314 * attribute (whether local or remote only calculate bytes in this block).
2315 * This routine decides as a side effect whether the attribute will be
2316 * a "local" or a "remote" attribute.
2317 */
2318int
aa82daa0 2319xfs_attr_leaf_newentsize(int namelen, int valuelen, int blocksize, int *local)
1da177e4
LT		 2320{
2321 int size;
2322
c9fb86a9
ES		 2323 size = xfs_attr_leaf_entsize_local(namelen, valuelen);
2324 if (size < xfs_attr_leaf_entsize_local_max(blocksize)) {
1da177e4
LT		 2325 if (local) {
2326 *local = 1;
2327 }
2328 } else {
c9fb86a9 2329 size = xfs_attr_leaf_entsize_remote(namelen);
1da177e4
LT		 2330 if (local) {
2331 *local = 0;
2332 }
2333 }
2334 return(size);
2335}
2336
2337/*
2338 * Copy out attribute list entries for attr_list(), for leaf attribute lists.
2339 */
2340int
2341xfs_attr_leaf_list_int(xfs_dabuf_t *bp, xfs_attr_list_context_t *context)
2342{
2343 attrlist_cursor_kern_t *cursor;
2344 xfs_attr_leafblock_t *leaf;
2345 xfs_attr_leaf_entry_t *entry;
1da177e4
LT		 2346 int retval, i;
2347
2348 ASSERT(bp != NULL);
2349 leaf = bp->data;
2350 cursor = context->cursor;
2351 cursor->initted = 1;
2352
0b1b213f 2353 trace_xfs_attr_list_leaf(context);
1da177e4
LT		 2354
2355 /*
2356 * Re-find our place in the leaf block if this is a new syscall.
2357 */
2358 if (context->resynch) {
2359 entry = &leaf->entries[0];
918ae424 2360 for (i = 0; i < be16_to_cpu(leaf->hdr.count); entry++, i++) {
6b19f2d8 2361 if (be32_to_cpu(entry->hashval) == cursor->hashval) {
1da177e4
LT		 2362 if (cursor->offset == context->dupcnt) {
2363 context->dupcnt = 0;
2364 break;
2365 }
2366 context->dupcnt++;
6b19f2d8
NS		 2367 } else if (be32_to_cpu(entry->hashval) >
2368 cursor->hashval) {
1da177e4
LT		 2369 context->dupcnt = 0;
2370 break;
2371 }
2372 }
918ae424 2373 if (i == be16_to_cpu(leaf->hdr.count)) {
0b1b213f 2374 trace_xfs_attr_list_notfound(context);
1da177e4
LT		 2375 return(0);
2376 }
2377 } else {
2378 entry = &leaf->entries[0];
2379 i = 0;
2380 }
2381 context->resynch = 0;
2382
2383 /*
2384 * We have found our place, start copying out the new attributes.
2385 */
2386 retval = 0;
726801ba 2387 for ( ; (i < be16_to_cpu(leaf->hdr.count)); entry++, i++) {
6b19f2d8
NS		 2388 if (be32_to_cpu(entry->hashval) != cursor->hashval) {
2389 cursor->hashval = be32_to_cpu(entry->hashval);
1da177e4
LT		 2390 cursor->offset = 0;
2391 }
2392
2393 if (entry->flags & XFS_ATTR_INCOMPLETE)
2394 continue; /* skip incomplete entries */
1da177e4
LT		 2395
2396 if (entry->flags & XFS_ATTR_LOCAL) {
726801ba 2397 xfs_attr_leaf_name_local_t *name_loc =
c9fb86a9 2398 xfs_attr_leaf_name_local(leaf, i);
726801ba
TS		 2399
2400 retval = context->put_listent(context,
ad9b463a 2401 entry->flags,
a9273ca5 2402 name_loc->nameval,
726801ba
TS		 2403 (int)name_loc->namelen,
2404 be16_to_cpu(name_loc->valuelen),
a9273ca5 2405 &name_loc->nameval[name_loc->namelen]);
726801ba
TS		 2406 if (retval)
2407 return retval;
1da177e4 2408 } else {
726801ba 2409 xfs_attr_leaf_name_remote_t *name_rmt =
c9fb86a9 2410 xfs_attr_leaf_name_remote(leaf, i);
726801ba
TS		 2411
2412 int valuelen = be32_to_cpu(name_rmt->valuelen);
2413
2414 if (context->put_value) {
2415 xfs_da_args_t args;
2416
2417 memset((char *)&args, 0, sizeof(args));
2418 args.dp = context->dp;
2419 args.whichfork = XFS_ATTR_FORK;
2420 args.valuelen = valuelen;
622d8149 2421 args.value = kmem_alloc(valuelen, KM_SLEEP | KM_NOFS);
726801ba
TS		 2422 args.rmtblkno = be32_to_cpu(name_rmt->valueblk);
2423 args.rmtblkcnt = XFS_B_TO_FSB(args.dp->i_mount, valuelen);
2424 retval = xfs_attr_rmtval_get(&args);
2425 if (retval)
2426 return retval;
2427 retval = context->put_listent(context,
ad9b463a 2428 entry->flags,
a9273ca5 2429 name_rmt->name,
726801ba
TS		 2430 (int)name_rmt->namelen,
2431 valuelen,
a9273ca5 2432 args.value);
f0e2d93c 2433 kmem_free(args.value);
ad9b463a 2434 } else {
726801ba 2435 retval = context->put_listent(context,
ad9b463a 2436 entry->flags,
a9273ca5 2437 name_rmt->name,
726801ba
TS		 2438 (int)name_rmt->namelen,
2439 valuelen,
2440 NULL);
2441 }
2442 if (retval)
2443 return retval;
1da177e4 2444 }
726801ba
TS		 2445 if (context->seen_enough)
2446 break;
2447 cursor->offset++;
1da177e4 2448 }
0b1b213f 2449 trace_xfs_attr_list_leaf_end(context);
1da177e4
LT		 2450 return(retval);
2451}
2452
1da177e4
LT		 2453
2454/*========================================================================
2455 * Manage the INCOMPLETE flag in a leaf entry
2456 *========================================================================*/
2457
2458/*
2459 * Clear the INCOMPLETE flag on an entry in a leaf block.
2460 */
2461int
2462xfs_attr_leaf_clearflag(xfs_da_args_t *args)
2463{
2464 xfs_attr_leafblock_t *leaf;
2465 xfs_attr_leaf_entry_t *entry;
2466 xfs_attr_leaf_name_remote_t *name_rmt;
2467 xfs_dabuf_t *bp;
2468 int error;
2469#ifdef DEBUG
2470 xfs_attr_leaf_name_local_t *name_loc;
2471 int namelen;
2472 char *name;
2473#endif /* DEBUG */
2474
5a5881cd 2475 trace_xfs_attr_leaf_clearflag(args);
1da177e4
LT		 2476 /*
2477 * Set up the operation.
2478 */
2479 error = xfs_da_read_buf(args->trans, args->dp, args->blkno, -1, &bp,
2480 XFS_ATTR_FORK);
2481 if (error) {
2482 return(error);
2483 }
2484 ASSERT(bp != NULL);
2485
2486 leaf = bp->data;
69ef921b 2487 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
918ae424 2488 ASSERT(args->index < be16_to_cpu(leaf->hdr.count));
1da177e4
LT		 2489 ASSERT(args->index >= 0);
2490 entry = &leaf->entries[ args->index ];
2491 ASSERT(entry->flags & XFS_ATTR_INCOMPLETE);
2492
2493#ifdef DEBUG
2494 if (entry->flags & XFS_ATTR_LOCAL) {
c9fb86a9 2495 name_loc = xfs_attr_leaf_name_local(leaf, args->index);
1da177e4
LT		 2496 namelen = name_loc->namelen;
2497 name = (char *)name_loc->nameval;
2498 } else {
c9fb86a9 2499 name_rmt = xfs_attr_leaf_name_remote(leaf, args->index);
1da177e4
LT		 2500 namelen = name_rmt->namelen;
2501 name = (char *)name_rmt->name;
2502 }
6b19f2d8 2503 ASSERT(be32_to_cpu(entry->hashval) == args->hashval);
1da177e4
LT		 2504 ASSERT(namelen == args->namelen);
2505 ASSERT(memcmp(name, args->name, namelen) == 0);
2506#endif /* DEBUG */
2507
2508 entry->flags &= ~XFS_ATTR_INCOMPLETE;
2509 xfs_da_log_buf(args->trans, bp,
2510 XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));
2511
2512 if (args->rmtblkno) {
2513 ASSERT((entry->flags & XFS_ATTR_LOCAL) == 0);
c9fb86a9 2514 name_rmt = xfs_attr_leaf_name_remote(leaf, args->index);
c0f054e7
NS		 2515 name_rmt->valueblk = cpu_to_be32(args->rmtblkno);
2516 name_rmt->valuelen = cpu_to_be32(args->valuelen);
1da177e4
LT		 2517 xfs_da_log_buf(args->trans, bp,
2518 XFS_DA_LOGRANGE(leaf, name_rmt, sizeof(*name_rmt)));
2519 }
2520 xfs_da_buf_done(bp);
2521
2522 /*
2523 * Commit the flag value change and start the next trans in series.
2524 */
322ff6b8 2525 return xfs_trans_roll(&args->trans, args->dp);
1da177e4
LT		 2526}
2527
2528/*
2529 * Set the INCOMPLETE flag on an entry in a leaf block.
2530 */
2531int
2532xfs_attr_leaf_setflag(xfs_da_args_t *args)
2533{
2534 xfs_attr_leafblock_t *leaf;
2535 xfs_attr_leaf_entry_t *entry;
2536 xfs_attr_leaf_name_remote_t *name_rmt;
2537 xfs_dabuf_t *bp;
2538 int error;
2539
5a5881cd
DC		 2540 trace_xfs_attr_leaf_setflag(args);
2541
1da177e4
LT		 2542 /*
2543 * Set up the operation.
2544 */
2545 error = xfs_da_read_buf(args->trans, args->dp, args->blkno, -1, &bp,
2546 XFS_ATTR_FORK);
2547 if (error) {
2548 return(error);
2549 }
2550 ASSERT(bp != NULL);
2551
2552 leaf = bp->data;
69ef921b 2553 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
918ae424 2554 ASSERT(args->index < be16_to_cpu(leaf->hdr.count));
1da177e4
LT		 2555 ASSERT(args->index >= 0);
2556 entry = &leaf->entries[ args->index ];
2557
2558 ASSERT((entry->flags & XFS_ATTR_INCOMPLETE) == 0);
2559 entry->flags |= XFS_ATTR_INCOMPLETE;
2560 xfs_da_log_buf(args->trans, bp,
2561 XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));
2562 if ((entry->flags & XFS_ATTR_LOCAL) == 0) {
c9fb86a9 2563 name_rmt = xfs_attr_leaf_name_remote(leaf, args->index);
1da177e4
LT		 2564 name_rmt->valueblk = 0;
2565 name_rmt->valuelen = 0;
2566 xfs_da_log_buf(args->trans, bp,
2567 XFS_DA_LOGRANGE(leaf, name_rmt, sizeof(*name_rmt)));
2568 }
2569 xfs_da_buf_done(bp);
2570
2571 /*
2572 * Commit the flag value change and start the next trans in series.
2573 */
322ff6b8 2574 return xfs_trans_roll(&args->trans, args->dp);
1da177e4
LT		 2575}
2576
2577/*
2578 * In a single transaction, clear the INCOMPLETE flag on the leaf entry
2579 * given by args->blkno/index and set the INCOMPLETE flag on the leaf
2580 * entry given by args->blkno2/index2.
2581 *
2582 * Note that they could be in different blocks, or in the same block.
2583 */
2584int
2585xfs_attr_leaf_flipflags(xfs_da_args_t *args)
2586{
2587 xfs_attr_leafblock_t *leaf1, *leaf2;
2588 xfs_attr_leaf_entry_t *entry1, *entry2;
2589 xfs_attr_leaf_name_remote_t *name_rmt;
2590 xfs_dabuf_t *bp1, *bp2;
2591 int error;
2592#ifdef DEBUG
2593 xfs_attr_leaf_name_local_t *name_loc;
2594 int namelen1, namelen2;
2595 char *name1, *name2;
2596#endif /* DEBUG */
2597
5a5881cd
DC		 2598 trace_xfs_attr_leaf_flipflags(args);
2599
1da177e4
LT		 2600 /*
2601 * Read the block containing the "old" attr
2602 */
2603 error = xfs_da_read_buf(args->trans, args->dp, args->blkno, -1, &bp1,
2604 XFS_ATTR_FORK);
2605 if (error) {
2606 return(error);
2607 }
2608 ASSERT(bp1 != NULL);
2609
2610 /*
2611 * Read the block containing the "new" attr, if it is different
2612 */
2613 if (args->blkno2 != args->blkno) {
2614 error = xfs_da_read_buf(args->trans, args->dp, args->blkno2,
2615 -1, &bp2, XFS_ATTR_FORK);
2616 if (error) {
2617 return(error);
2618 }
2619 ASSERT(bp2 != NULL);
2620 } else {
2621 bp2 = bp1;
2622 }
2623
2624 leaf1 = bp1->data;
69ef921b 2625 ASSERT(leaf1->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
918ae424 2626 ASSERT(args->index < be16_to_cpu(leaf1->hdr.count));
1da177e4
LT		 2627 ASSERT(args->index >= 0);
2628 entry1 = &leaf1->entries[ args->index ];
2629
2630 leaf2 = bp2->data;
69ef921b 2631 ASSERT(leaf2->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
918ae424 2632 ASSERT(args->index2 < be16_to_cpu(leaf2->hdr.count));
1da177e4
LT		 2633 ASSERT(args->index2 >= 0);
2634 entry2 = &leaf2->entries[ args->index2 ];
2635
2636#ifdef DEBUG
2637 if (entry1->flags & XFS_ATTR_LOCAL) {
c9fb86a9 2638 name_loc = xfs_attr_leaf_name_local(leaf1, args->index);
1da177e4
LT		 2639 namelen1 = name_loc->namelen;
2640 name1 = (char *)name_loc->nameval;
2641 } else {
c9fb86a9 2642 name_rmt = xfs_attr_leaf_name_remote(leaf1, args->index);
1da177e4
LT		 2643 namelen1 = name_rmt->namelen;
2644 name1 = (char *)name_rmt->name;
2645 }
2646 if (entry2->flags & XFS_ATTR_LOCAL) {
c9fb86a9 2647 name_loc = xfs_attr_leaf_name_local(leaf2, args->index2);
1da177e4
LT		 2648 namelen2 = name_loc->namelen;
2649 name2 = (char *)name_loc->nameval;
2650 } else {
c9fb86a9 2651 name_rmt = xfs_attr_leaf_name_remote(leaf2, args->index2);
1da177e4
LT		 2652 namelen2 = name_rmt->namelen;
2653 name2 = (char *)name_rmt->name;
2654 }
6b19f2d8 2655 ASSERT(be32_to_cpu(entry1->hashval) == be32_to_cpu(entry2->hashval));
1da177e4
LT		 2656 ASSERT(namelen1 == namelen2);
2657 ASSERT(memcmp(name1, name2, namelen1) == 0);
2658#endif /* DEBUG */
2659
2660 ASSERT(entry1->flags & XFS_ATTR_INCOMPLETE);
2661 ASSERT((entry2->flags & XFS_ATTR_INCOMPLETE) == 0);
2662
2663 entry1->flags &= ~XFS_ATTR_INCOMPLETE;
2664 xfs_da_log_buf(args->trans, bp1,
2665 XFS_DA_LOGRANGE(leaf1, entry1, sizeof(*entry1)));
2666 if (args->rmtblkno) {
2667 ASSERT((entry1->flags & XFS_ATTR_LOCAL) == 0);
c9fb86a9 2668 name_rmt = xfs_attr_leaf_name_remote(leaf1, args->index);
c0f054e7
NS		 2669 name_rmt->valueblk = cpu_to_be32(args->rmtblkno);
2670 name_rmt->valuelen = cpu_to_be32(args->valuelen);
1da177e4
LT		 2671 xfs_da_log_buf(args->trans, bp1,
2672 XFS_DA_LOGRANGE(leaf1, name_rmt, sizeof(*name_rmt)));
2673 }
2674
2675 entry2->flags |= XFS_ATTR_INCOMPLETE;
2676 xfs_da_log_buf(args->trans, bp2,
2677 XFS_DA_LOGRANGE(leaf2, entry2, sizeof(*entry2)));
2678 if ((entry2->flags & XFS_ATTR_LOCAL) == 0) {
c9fb86a9 2679 name_rmt = xfs_attr_leaf_name_remote(leaf2, args->index2);
1da177e4
LT		 2680 name_rmt->valueblk = 0;
2681 name_rmt->valuelen = 0;
2682 xfs_da_log_buf(args->trans, bp2,
2683 XFS_DA_LOGRANGE(leaf2, name_rmt, sizeof(*name_rmt)));
2684 }
2685 xfs_da_buf_done(bp1);
2686 if (bp1 != bp2)
2687 xfs_da_buf_done(bp2);
2688
2689 /*
2690 * Commit the flag value change and start the next trans in series.
2691 */
322ff6b8 2692 error = xfs_trans_roll(&args->trans, args->dp);
1da177e4
LT		 2693
2694 return(error);
2695}
2696
2697/*========================================================================
2698 * Indiscriminately delete the entire attribute fork
2699 *========================================================================*/
2700
2701/*
2702 * Recurse (gasp!) through the attribute nodes until we find leaves.
2703 * We're doing a depth-first traversal in order to invalidate everything.
2704 */
2705int
2706xfs_attr_root_inactive(xfs_trans_t **trans, xfs_inode_t *dp)
2707{
2708 xfs_da_blkinfo_t *info;
2709 xfs_daddr_t blkno;
2710 xfs_dabuf_t *bp;
2711 int error;
2712
2713 /*
2714 * Read block 0 to see what we have to work with.
2715 * We only get here if we have extents, since we remove
2716 * the extents in reverse order the extent containing
2717 * block 0 must still be there.
2718 */
2719 error = xfs_da_read_buf(*trans, dp, 0, -1, &bp, XFS_ATTR_FORK);
2720 if (error)
2721 return(error);
2722 blkno = xfs_da_blkno(bp);
2723
2724 /*
2725 * Invalidate the tree, even if the "tree" is only a single leaf block.
2726 * This is a depth-first traversal!
2727 */
2728 info = bp->data;
69ef921b 2729 if (info->magic == cpu_to_be16(XFS_DA_NODE_MAGIC)) {
1da177e4 2730 error = xfs_attr_node_inactive(trans, dp, bp, 1);
69ef921b 2731 } else if (info->magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC)) {
1da177e4
LT		 2732 error = xfs_attr_leaf_inactive(trans, dp, bp);
2733 } else {
2734 error = XFS_ERROR(EIO);
2735 xfs_da_brelse(*trans, bp);
2736 }
2737 if (error)
2738 return(error);
2739
2740 /*
2741 * Invalidate the incore copy of the root block.
2742 */
2743 error = xfs_da_get_buf(*trans, dp, 0, blkno, &bp, XFS_ATTR_FORK);
2744 if (error)
2745 return(error);
2746 xfs_da_binval(*trans, bp); /* remove from cache */
2747 /*
2748 * Commit the invalidate and start the next transaction.
2749 */
322ff6b8 2750 error = xfs_trans_roll(trans, dp);
1da177e4
LT		 2751
2752 return (error);
2753}
2754
2755/*
2756 * Recurse (gasp!) through the attribute nodes until we find leaves.
2757 * We're doing a depth-first traversal in order to invalidate everything.
2758 */
ba0f32d4 2759STATIC int
1da177e4
LT		 2760xfs_attr_node_inactive(xfs_trans_t **trans, xfs_inode_t *dp, xfs_dabuf_t *bp,
2761 int level)
2762{
2763 xfs_da_blkinfo_t *info;
2764 xfs_da_intnode_t *node;
2765 xfs_dablk_t child_fsb;
2766 xfs_daddr_t parent_blkno, child_blkno;
2767 int error, count, i;
2768 xfs_dabuf_t *child_bp;
2769
2770 /*
2771 * Since this code is recursive (gasp!) we must protect ourselves.
2772 */
2773 if (level > XFS_DA_NODE_MAXDEPTH) {
2774 xfs_da_brelse(*trans, bp); /* no locks for later trans */
2775 return(XFS_ERROR(EIO));
2776 }
2777
2778 node = bp->data;
69ef921b 2779 ASSERT(node->hdr.info.magic == cpu_to_be16(XFS_DA_NODE_MAGIC));
1da177e4 2780 parent_blkno = xfs_da_blkno(bp); /* save for re-read later */
fac80cce 2781 count = be16_to_cpu(node->hdr.count);
1da177e4
LT		 2782 if (!count) {
2783 xfs_da_brelse(*trans, bp);
2784 return(0);
2785 }
403432dc 2786 child_fsb = be32_to_cpu(node->btree[0].before);
1da177e4
LT		 2787 xfs_da_brelse(*trans, bp); /* no locks for later trans */
2788
2789 /*
2790 * If this is the node level just above the leaves, simply loop
2791 * over the leaves removing all of them. If this is higher up
2792 * in the tree, recurse downward.
2793 */
2794 for (i = 0; i < count; i++) {
2795 /*
2796 * Read the subsidiary block to see what we have to work with.
2797 * Don't do this in a transaction. This is a depth-first
2798 * traversal of the tree so we may deal with many blocks
2799 * before we come back to this one.
2800 */
2801 error = xfs_da_read_buf(*trans, dp, child_fsb, -2, &child_bp,
2802 XFS_ATTR_FORK);
2803 if (error)
2804 return(error);
2805 if (child_bp) {
2806 /* save for re-read later */
2807 child_blkno = xfs_da_blkno(child_bp);
2808
2809 /*
2810 * Invalidate the subtree, however we have to.
2811 */
2812 info = child_bp->data;
69ef921b 2813 if (info->magic == cpu_to_be16(XFS_DA_NODE_MAGIC)) {
1da177e4
LT		 2814 error = xfs_attr_node_inactive(trans, dp,
2815 child_bp, level+1);
69ef921b 2816 } else if (info->magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC)) {
1da177e4
LT		 2817 error = xfs_attr_leaf_inactive(trans, dp,
2818 child_bp);
2819 } else {
2820 error = XFS_ERROR(EIO);
2821 xfs_da_brelse(*trans, child_bp);
2822 }
2823 if (error)
2824 return(error);
2825
2826 /*
2827 * Remove the subsidiary block from the cache
2828 * and from the log.
2829 */
2830 error = xfs_da_get_buf(*trans, dp, 0, child_blkno,
2831 &child_bp, XFS_ATTR_FORK);
2832 if (error)
2833 return(error);
2834 xfs_da_binval(*trans, child_bp);
2835 }
2836
2837 /*
2838 * If we're not done, re-read the parent to get the next
2839 * child block number.
2840 */
2841 if ((i+1) < count) {
2842 error = xfs_da_read_buf(*trans, dp, 0, parent_blkno,
2843 &bp, XFS_ATTR_FORK);
2844 if (error)
2845 return(error);
403432dc 2846 child_fsb = be32_to_cpu(node->btree[i+1].before);
1da177e4
LT		 2847 xfs_da_brelse(*trans, bp);
2848 }
2849 /*
2850 * Atomically commit the whole invalidate stuff.
2851 */
322ff6b8
NS		 2852 error = xfs_trans_roll(trans, dp);
2853 if (error)
1da177e4
LT		 2854 return (error);
2855 }
2856
2857 return(0);
2858}
2859
2860/*
2861 * Invalidate all of the "remote" value regions pointed to by a particular
2862 * leaf block.
2863 * Note that we must release the lock on the buffer so that we are not
2864 * caught holding something that the logging code wants to flush to disk.
2865 */
ba0f32d4 2866STATIC int
1da177e4
LT		 2867xfs_attr_leaf_inactive(xfs_trans_t **trans, xfs_inode_t *dp, xfs_dabuf_t *bp)
2868{
2869 xfs_attr_leafblock_t *leaf;
2870 xfs_attr_leaf_entry_t *entry;
2871 xfs_attr_leaf_name_remote_t *name_rmt;
2872 xfs_attr_inactive_list_t *list, *lp;
2873 int error, count, size, tmp, i;
2874
2875 leaf = bp->data;
69ef921b 2876 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1da177e4
LT		 2877
2878 /*
2879 * Count the number of "remote" value extents.
2880 */
2881 count = 0;
2882 entry = &leaf->entries[0];
918ae424 2883 for (i = 0; i < be16_to_cpu(leaf->hdr.count); entry++, i++) {
6b19f2d8
NS		 2884 if (be16_to_cpu(entry->nameidx) &&
2885 ((entry->flags & XFS_ATTR_LOCAL) == 0)) {
c9fb86a9 2886 name_rmt = xfs_attr_leaf_name_remote(leaf, i);
1da177e4
LT		 2887 if (name_rmt->valueblk)
2888 count++;
2889 }
2890 }
2891
2892 /*
2893 * If there are no "remote" values, we're done.
2894 */
2895 if (count == 0) {
2896 xfs_da_brelse(*trans, bp);
2897 return(0);
2898 }
2899
2900 /*
2901 * Allocate storage for a list of all the "remote" value extents.
2902 */
2903 size = count * sizeof(xfs_attr_inactive_list_t);
2904 list = (xfs_attr_inactive_list_t *)kmem_alloc(size, KM_SLEEP);
2905
2906 /*
2907 * Identify each of the "remote" value extents.
2908 */
2909 lp = list;
2910 entry = &leaf->entries[0];
918ae424 2911 for (i = 0; i < be16_to_cpu(leaf->hdr.count); entry++, i++) {
6b19f2d8
NS		 2912 if (be16_to_cpu(entry->nameidx) &&
2913 ((entry->flags & XFS_ATTR_LOCAL) == 0)) {
c9fb86a9 2914 name_rmt = xfs_attr_leaf_name_remote(leaf, i);
1da177e4 2915 if (name_rmt->valueblk) {
d7929ff6
NS		 2916 lp->valueblk = be32_to_cpu(name_rmt->valueblk);
2917 lp->valuelen = XFS_B_TO_FSB(dp->i_mount,
2918 be32_to_cpu(name_rmt->valuelen));
1da177e4
LT		 2919 lp++;
2920 }
2921 }
2922 }
2923 xfs_da_brelse(*trans, bp); /* unlock for trans. in freextent() */
2924
2925 /*
2926 * Invalidate each of the "remote" value extents.
2927 */
2928 error = 0;
2929 for (lp = list, i = 0; i < count; i++, lp++) {
2930 tmp = xfs_attr_leaf_freextent(trans, dp,
d7929ff6
NS		 2931 lp->valueblk, lp->valuelen);
2932
1da177e4
LT		 2933 if (error == 0)
2934 error = tmp; /* save only the 1st errno */
2935 }
2936
f0e2d93c 2937 kmem_free((xfs_caddr_t)list);
1da177e4
LT		 2938 return(error);
2939}
2940
2941/*
2942 * Look at all the extents for this logical region,
2943 * invalidate any buffers that are incore/in transactions.
2944 */
ba0f32d4 2945STATIC int
1da177e4
LT		 2946xfs_attr_leaf_freextent(xfs_trans_t **trans, xfs_inode_t *dp,
2947 xfs_dablk_t blkno, int blkcnt)
2948{
2949 xfs_bmbt_irec_t map;
2950 xfs_dablk_t tblkno;
2951 int tblkcnt, dblkcnt, nmap, error;
2952 xfs_daddr_t dblkno;
2953 xfs_buf_t *bp;
2954
2955 /*
2956 * Roll through the "value", invalidating the attribute value's
2957 * blocks.
2958 */
2959 tblkno = blkno;
2960 tblkcnt = blkcnt;
2961 while (tblkcnt > 0) {
2962 /*
2963 * Try to remember where we decided to put the value.
2964 */
2965 nmap = 1;
5c8ed202
DC		 2966 error = xfs_bmapi_read(dp, (xfs_fileoff_t)tblkno, tblkcnt,
2967 &map, &nmap, XFS_BMAPI_ATTRFORK);
1da177e4
LT		 2968 if (error) {
2969 return(error);
2970 }
2971 ASSERT(nmap == 1);
2972 ASSERT(map.br_startblock != DELAYSTARTBLOCK);
2973
2974 /*
2975 * If it's a hole, these are already unmapped
2976 * so there's nothing to invalidate.
2977 */
2978 if (map.br_startblock != HOLESTARTBLOCK) {
2979
2980 dblkno = XFS_FSB_TO_DADDR(dp->i_mount,
2981 map.br_startblock);
2982 dblkcnt = XFS_FSB_TO_BB(dp->i_mount,
2983 map.br_blockcount);
2984 bp = xfs_trans_get_buf(*trans,
2985 dp->i_mount->m_ddev_targp,
0cadda1c 2986 dblkno, dblkcnt, XBF_LOCK);
2a30f36d
CS		 2987 if (!bp)
2988 return ENOMEM;
1da177e4
LT		 2989 xfs_trans_binval(*trans, bp);
2990 /*
2991 * Roll to next transaction.
2992 */
322ff6b8
NS		 2993 error = xfs_trans_roll(trans, dp);
2994 if (error)
1da177e4
LT		 2995 return (error);
2996 }
2997
2998 tblkno += map.br_blockcount;
2999 tblkcnt -= map.br_blockcount;
3000 }
3001
3002 return(0);
3003}
Linux kernel - Deliverables
This page took 0.735479 seconds and 5 git commands to generate.