blob: d25eafd4d28de31d326078dbfdc21140c69b5acb [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Nathan Scott7b718762005-11-02 14:58:39 +11002 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
3 * All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
Nathan Scott7b718762005-11-02 14:58:39 +11005 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * published by the Free Software Foundation.
8 *
Nathan Scott7b718762005-11-02 14:58:39 +11009 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
Nathan Scott7b718762005-11-02 14:58:39 +110014 * 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include "xfs.h"
Nathan Scotta844f452005-11-02 14:38:42 +110019#include "xfs_fs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include "xfs_types.h"
Nathan Scotta844f452005-11-02 14:38:42 +110021#include "xfs_bit.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include "xfs_log.h"
Nathan Scotta844f452005-11-02 14:38:42 +110023#include "xfs_inum.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include "xfs_trans.h"
25#include "xfs_sb.h"
26#include "xfs_ag.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include "xfs_mount.h"
Nathan Scotta844f452005-11-02 14:38:42 +110028#include "xfs_da_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include "xfs_bmap_btree.h"
Nathan Scotta844f452005-11-02 14:38:42 +110030#include "xfs_alloc_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include "xfs_ialloc_btree.h"
32#include "xfs_alloc.h"
33#include "xfs_btree.h"
Nathan Scotta844f452005-11-02 14:38:42 +110034#include "xfs_attr_sf.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include "xfs_dinode.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include "xfs_inode.h"
Nathan Scotta844f452005-11-02 14:38:42 +110037#include "xfs_inode_item.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include "xfs_bmap.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include "xfs_attr.h"
40#include "xfs_attr_leaf.h"
41#include "xfs_error.h"
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000042#include "xfs_trace.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070043
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 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +100057STATIC int xfs_attr_leaf_create(xfs_da_args_t *args, xfs_dablk_t which_block,
58 xfs_dabuf_t **bpp);
Linus Torvalds1da177e2005-04-16 15:20:36 -070059STATIC 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
71/*
Christoph Hellwigba0f32d2005-06-21 15:36:52 +100072 * 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
81/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070082 * 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);
Christoph Hellwigba0f32d2005-06-21 15:36:52 +100089STATIC int xfs_attr_leaf_entsize(xfs_attr_leafblock_t *leaf, int index);
Tim Shimmin726801b2006-09-28 11:01:37 +100090
91/*========================================================================
92 * Namespace helper routines
93 *========================================================================*/
94
Tim Shimmin726801b2006-09-28 11:01:37 +100095/*
96 * If namespace bits don't match return 0.
97 * If all match then return 1.
98 */
Christoph Hellwigb8f82a42009-11-14 16:17:22 +000099STATIC int
Tim Shimmin726801b2006-09-28 11:01:37 +1000100xfs_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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105
106/*========================================================================
Nathan Scottd8cc8902005-11-02 10:34:53 +1100107 * External routines when attribute fork size < XFS_LITINO(mp).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 *========================================================================*/
109
110/*
Nathan Scottd8cc8902005-11-02 10:34:53 +1100111 * Query whether the requested number of additional bytes of extended
112 * attribute space will be able to fit inline.
Christoph Hellwig4c393a62011-11-19 17:44:30 +0000113 *
Nathan Scottd8cc8902005-11-02 10:34:53 +1100114 * 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.
119 */
120int
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 */
Christoph Hellwig4c393a62011-11-19 17:44:30 +0000126 int dsize;
Nathan Scottd8cc8902005-11-02 10:34:53 +1100127 xfs_mount_t *mp = dp->i_mount;
128
Nathan Scottd8cc8902005-11-02 10:34:53 +1100129 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
Christoph Hellwig4c393a62011-11-19 17:44:30 +0000140 /*
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))
Nathan Scottda087ba2005-11-02 15:00:20 +1100159 return 0;
Nathan Scottda087ba2005-11-02 15:00:20 +1100160
Barry Naujoke5889e92007-02-10 18:35:58 +1100161 dsize = dp->i_df.if_bytes;
Christoph Hellwig4c393a62011-11-19 17:44:30 +0000162
Barry Naujoke5889e92007-02-10 18:35:58 +1100163 switch (dp->i_d.di_format) {
164 case XFS_DINODE_FMT_EXTENTS:
Christoph Hellwig4c393a62011-11-19 17:44:30 +0000165 /*
Barry Naujoke5889e92007-02-10 18:35:58 +1100166 * If there is no attr fork and the data fork is extents,
Christoph Hellwig4c393a62011-11-19 17:44:30 +0000167 * 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
Barry Naujoke5889e92007-02-10 18:35:58 +1100170 * the btree root.
Christoph Hellwig4c393a62011-11-19 17:44:30 +0000171 */
Christoph Hellwig1a5902c2009-03-29 19:26:46 +0200172 if (!dp->i_d.di_forkoff && dp->i_df.if_bytes >
173 xfs_default_attroffset(dp))
Barry Naujoke5889e92007-02-10 18:35:58 +1100174 dsize = XFS_BMDR_SPACE_CALC(MINDBTPTRS);
175 break;
Barry Naujoke5889e92007-02-10 18:35:58 +1100176 case XFS_DINODE_FMT_BTREE:
177 /*
Christoph Hellwig4c393a62011-11-19 17:44:30 +0000178 * 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
Barry Naujoke5889e92007-02-10 18:35:58 +1100181 * plenty of room for attrs
182 */
183 if (dp->i_d.di_forkoff) {
Christoph Hellwig4c393a62011-11-19 17:44:30 +0000184 if (offset < dp->i_d.di_forkoff)
Barry Naujoke5889e92007-02-10 18:35:58 +1100185 return 0;
Christoph Hellwig4c393a62011-11-19 17:44:30 +0000186 return dp->i_d.di_forkoff;
187 }
188 dsize = XFS_BMAP_BROOT_SPACE(dp->i_df.if_broot);
Barry Naujoke5889e92007-02-10 18:35:58 +1100189 break;
190 }
Christoph Hellwig4c393a62011-11-19 17:44:30 +0000191
192 /*
193 * A data fork btree root must have space for at least
Barry Naujoke5889e92007-02-10 18:35:58 +1100194 * MINDBTPTRS key/ptr pairs if the data fork is small or empty.
195 */
196 minforkoff = MAX(dsize, XFS_BMDR_SPACE_CALC(MINDBTPTRS));
Nathan Scottd8cc8902005-11-02 10:34:53 +1100197 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
Nathan Scottd8cc8902005-11-02 10:34:53 +1100203 if (offset >= maxforkoff)
204 return maxforkoff;
Christoph Hellwig4c393a62011-11-19 17:44:30 +0000205 if (offset >= minforkoff)
206 return offset;
Nathan Scottd8cc8902005-11-02 10:34:53 +1100207 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{
Nathan Scott13059ff2006-01-11 15:32:01 +1100216 if ((mp->m_flags & XFS_MOUNT_ATTR2) &&
Eric Sandeen62118702008-03-06 13:44:28 +1100217 !(xfs_sb_version_hasattr2(&mp->m_sb))) {
Eric Sandeen3685c2a2007-10-11 17:42:32 +1000218 spin_lock(&mp->m_sb_lock);
Eric Sandeen62118702008-03-06 13:44:28 +1100219 if (!xfs_sb_version_hasattr2(&mp->m_sb)) {
220 xfs_sb_version_addattr2(&mp->m_sb);
Eric Sandeen3685c2a2007-10-11 17:42:32 +1000221 spin_unlock(&mp->m_sb_lock);
Nathan Scottd8cc8902005-11-02 10:34:53 +1100222 xfs_mod_sb(tp, XFS_SB_VERSIONNUM | XFS_SB_FEATURES2);
223 } else
Eric Sandeen3685c2a2007-10-11 17:42:32 +1000224 spin_unlock(&mp->m_sb_lock);
Nathan Scottd8cc8902005-11-02 10:34:53 +1100225 }
226}
227
228/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 * Create the initial contents of a shortform attribute list.
230 */
Nathan Scottd8cc8902005-11-02 10:34:53 +1100231void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232xfs_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
238 dp = args->dp;
239 ASSERT(dp != NULL);
240 ifp = dp->i_afp;
241 ASSERT(ifp != NULL);
242 ASSERT(ifp->if_bytes == 0);
243 if (dp->i_d.di_aformat == XFS_DINODE_FMT_EXTENTS) {
244 ifp->if_flags &= ~XFS_IFEXTENTS; /* just in case */
245 dp->i_d.di_aformat = XFS_DINODE_FMT_LOCAL;
246 ifp->if_flags |= XFS_IFINLINE;
247 } else {
248 ASSERT(ifp->if_flags & XFS_IFINLINE);
249 }
250 xfs_idata_realloc(dp, sizeof(*hdr), XFS_ATTR_FORK);
251 hdr = (xfs_attr_sf_hdr_t *)ifp->if_u1.if_data;
252 hdr->count = 0;
Nathan Scott3b244aa2006-03-17 17:29:25 +1100253 hdr->totsize = cpu_to_be16(sizeof(*hdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_ADATA);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255}
256
257/*
258 * Add a name/value pair to the shortform attribute list.
259 * Overflow from the inode has already been checked for.
260 */
Nathan Scottd8cc8902005-11-02 10:34:53 +1100261void
262xfs_attr_shortform_add(xfs_da_args_t *args, int forkoff)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263{
264 xfs_attr_shortform_t *sf;
265 xfs_attr_sf_entry_t *sfe;
266 int i, offset, size;
Nathan Scottd8cc8902005-11-02 10:34:53 +1100267 xfs_mount_t *mp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 xfs_inode_t *dp;
269 xfs_ifork_t *ifp;
270
271 dp = args->dp;
Nathan Scottd8cc8902005-11-02 10:34:53 +1100272 mp = dp->i_mount;
273 dp->i_d.di_forkoff = forkoff;
Nathan Scottd8cc8902005-11-02 10:34:53 +1100274
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 ifp = dp->i_afp;
276 ASSERT(ifp->if_flags & XFS_IFINLINE);
277 sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;
278 sfe = &sf->list[0];
Nathan Scott3b244aa2006-03-17 17:29:25 +1100279 for (i = 0; i < sf->hdr.count; sfe = XFS_ATTR_SF_NEXTENTRY(sfe), i++) {
Nathan Scottd8cc8902005-11-02 10:34:53 +1100280#ifdef DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 if (sfe->namelen != args->namelen)
282 continue;
283 if (memcmp(args->name, sfe->nameval, args->namelen) != 0)
284 continue;
Tim Shimmin726801b2006-09-28 11:01:37 +1000285 if (!xfs_attr_namesp_match(args->flags, sfe->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 continue;
Nathan Scottd8cc8902005-11-02 10:34:53 +1100287 ASSERT(0);
288#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 }
290
291 offset = (char *)sfe - (char *)sf;
292 size = XFS_ATTR_SF_ENTSIZE_BYNAME(args->namelen, args->valuelen);
293 xfs_idata_realloc(dp, size, XFS_ATTR_FORK);
294 sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;
295 sfe = (xfs_attr_sf_entry_t *)((char *)sf + offset);
296
297 sfe->namelen = args->namelen;
Nathan Scott3b244aa2006-03-17 17:29:25 +1100298 sfe->valuelen = args->valuelen;
Tim Shimmin726801b2006-09-28 11:01:37 +1000299 sfe->flags = XFS_ATTR_NSP_ARGS_TO_ONDISK(args->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 memcpy(sfe->nameval, args->name, args->namelen);
301 memcpy(&sfe->nameval[args->namelen], args->value, args->valuelen);
Nathan Scott3b244aa2006-03-17 17:29:25 +1100302 sf->hdr.count++;
Marcin Slusarz413d57c2008-02-13 15:03:29 -0800303 be16_add_cpu(&sf->hdr.totsize, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_ADATA);
305
Nathan Scottd8cc8902005-11-02 10:34:53 +1100306 xfs_sbversion_add_attr2(mp, args->trans);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307}
308
309/*
Christoph Hellwige1486de2009-02-04 09:36:00 +0100310 * After the last attribute is removed revert to original inode format,
311 * making all literal area available to the data fork once more.
312 */
313STATIC void
314xfs_attr_fork_reset(
315 struct xfs_inode *ip,
316 struct xfs_trans *tp)
317{
318 xfs_idestroy_fork(ip, XFS_ATTR_FORK);
319 ip->i_d.di_forkoff = 0;
320 ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
321
322 ASSERT(ip->i_d.di_anextents == 0);
323 ASSERT(ip->i_afp == NULL);
324
Christoph Hellwige1486de2009-02-04 09:36:00 +0100325 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
326}
327
328/*
Nathan Scottd8cc8902005-11-02 10:34:53 +1100329 * Remove an attribute from the shortform attribute list structure.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 */
331int
332xfs_attr_shortform_remove(xfs_da_args_t *args)
333{
334 xfs_attr_shortform_t *sf;
335 xfs_attr_sf_entry_t *sfe;
336 int base, size=0, end, totsize, i;
Nathan Scottd8cc8902005-11-02 10:34:53 +1100337 xfs_mount_t *mp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 xfs_inode_t *dp;
339
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 dp = args->dp;
Nathan Scottd8cc8902005-11-02 10:34:53 +1100341 mp = dp->i_mount;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 base = sizeof(xfs_attr_sf_hdr_t);
343 sf = (xfs_attr_shortform_t *)dp->i_afp->if_u1.if_data;
344 sfe = &sf->list[0];
Nathan Scott3b244aa2006-03-17 17:29:25 +1100345 end = sf->hdr.count;
Nathan Scottd8cc8902005-11-02 10:34:53 +1100346 for (i = 0; i < end; sfe = XFS_ATTR_SF_NEXTENTRY(sfe),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 base += size, i++) {
348 size = XFS_ATTR_SF_ENTSIZE(sfe);
349 if (sfe->namelen != args->namelen)
350 continue;
351 if (memcmp(sfe->nameval, args->name, args->namelen) != 0)
352 continue;
Tim Shimmin726801b2006-09-28 11:01:37 +1000353 if (!xfs_attr_namesp_match(args->flags, sfe->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 continue;
355 break;
356 }
Nathan Scottd8cc8902005-11-02 10:34:53 +1100357 if (i == end)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 return(XFS_ERROR(ENOATTR));
359
Nathan Scottd8cc8902005-11-02 10:34:53 +1100360 /*
361 * Fix up the attribute fork data, covering the hole
362 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 end = base + size;
Nathan Scott3b244aa2006-03-17 17:29:25 +1100364 totsize = be16_to_cpu(sf->hdr.totsize);
Nathan Scottd8cc8902005-11-02 10:34:53 +1100365 if (end != totsize)
366 memmove(&((char *)sf)[base], &((char *)sf)[end], totsize - end);
Nathan Scott3b244aa2006-03-17 17:29:25 +1100367 sf->hdr.count--;
Marcin Slusarz413d57c2008-02-13 15:03:29 -0800368 be16_add_cpu(&sf->hdr.totsize, -size);
Nathan Scottd8cc8902005-11-02 10:34:53 +1100369
370 /*
371 * Fix up the start offset of the attribute fork
372 */
373 totsize -= size;
Barry Naujok6a178102008-05-21 16:42:05 +1000374 if (totsize == sizeof(xfs_attr_sf_hdr_t) &&
Christoph Hellwige1486de2009-02-04 09:36:00 +0100375 (mp->m_flags & XFS_MOUNT_ATTR2) &&
376 (dp->i_d.di_format != XFS_DINODE_FMT_BTREE) &&
377 !(args->op_flags & XFS_DA_OP_ADDNAME)) {
378 xfs_attr_fork_reset(dp, args->trans);
Nathan Scottd8cc8902005-11-02 10:34:53 +1100379 } else {
380 xfs_idata_realloc(dp, -size, XFS_ATTR_FORK);
381 dp->i_d.di_forkoff = xfs_attr_shortform_bytesfit(dp, totsize);
382 ASSERT(dp->i_d.di_forkoff);
Barry Naujok6a178102008-05-21 16:42:05 +1000383 ASSERT(totsize > sizeof(xfs_attr_sf_hdr_t) ||
384 (args->op_flags & XFS_DA_OP_ADDNAME) ||
385 !(mp->m_flags & XFS_MOUNT_ATTR2) ||
386 dp->i_d.di_format == XFS_DINODE_FMT_BTREE);
Nathan Scottd8cc8902005-11-02 10:34:53 +1100387 xfs_trans_log_inode(args->trans, dp,
388 XFS_ILOG_CORE | XFS_ILOG_ADATA);
389 }
390
391 xfs_sbversion_add_attr2(mp, args->trans);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392
393 return(0);
394}
395
396/*
397 * Look up a name in a shortform attribute list structure.
398 */
399/*ARGSUSED*/
400int
401xfs_attr_shortform_lookup(xfs_da_args_t *args)
402{
403 xfs_attr_shortform_t *sf;
404 xfs_attr_sf_entry_t *sfe;
405 int i;
406 xfs_ifork_t *ifp;
407
408 ifp = args->dp->i_afp;
409 ASSERT(ifp->if_flags & XFS_IFINLINE);
410 sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;
411 sfe = &sf->list[0];
Nathan Scott3b244aa2006-03-17 17:29:25 +1100412 for (i = 0; i < sf->hdr.count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 sfe = XFS_ATTR_SF_NEXTENTRY(sfe), i++) {
414 if (sfe->namelen != args->namelen)
415 continue;
416 if (memcmp(args->name, sfe->nameval, args->namelen) != 0)
417 continue;
Tim Shimmin726801b2006-09-28 11:01:37 +1000418 if (!xfs_attr_namesp_match(args->flags, sfe->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 continue;
420 return(XFS_ERROR(EEXIST));
421 }
422 return(XFS_ERROR(ENOATTR));
423}
424
425/*
426 * Look up a name in a shortform attribute list structure.
427 */
428/*ARGSUSED*/
429int
430xfs_attr_shortform_getvalue(xfs_da_args_t *args)
431{
432 xfs_attr_shortform_t *sf;
433 xfs_attr_sf_entry_t *sfe;
434 int i;
435
436 ASSERT(args->dp->i_d.di_aformat == XFS_IFINLINE);
437 sf = (xfs_attr_shortform_t *)args->dp->i_afp->if_u1.if_data;
438 sfe = &sf->list[0];
Nathan Scott3b244aa2006-03-17 17:29:25 +1100439 for (i = 0; i < sf->hdr.count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 sfe = XFS_ATTR_SF_NEXTENTRY(sfe), i++) {
441 if (sfe->namelen != args->namelen)
442 continue;
443 if (memcmp(args->name, sfe->nameval, args->namelen) != 0)
444 continue;
Tim Shimmin726801b2006-09-28 11:01:37 +1000445 if (!xfs_attr_namesp_match(args->flags, sfe->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 continue;
447 if (args->flags & ATTR_KERNOVAL) {
Nathan Scott3b244aa2006-03-17 17:29:25 +1100448 args->valuelen = sfe->valuelen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 return(XFS_ERROR(EEXIST));
450 }
Nathan Scott3b244aa2006-03-17 17:29:25 +1100451 if (args->valuelen < sfe->valuelen) {
452 args->valuelen = sfe->valuelen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 return(XFS_ERROR(ERANGE));
454 }
Nathan Scott3b244aa2006-03-17 17:29:25 +1100455 args->valuelen = sfe->valuelen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 memcpy(args->value, &sfe->nameval[args->namelen],
457 args->valuelen);
458 return(XFS_ERROR(EEXIST));
459 }
460 return(XFS_ERROR(ENOATTR));
461}
462
463/*
464 * Convert from using the shortform to the leaf.
465 */
466int
467xfs_attr_shortform_to_leaf(xfs_da_args_t *args)
468{
469 xfs_inode_t *dp;
470 xfs_attr_shortform_t *sf;
471 xfs_attr_sf_entry_t *sfe;
472 xfs_da_args_t nargs;
473 char *tmpbuffer;
474 int error, i, size;
475 xfs_dablk_t blkno;
476 xfs_dabuf_t *bp;
477 xfs_ifork_t *ifp;
478
479 dp = args->dp;
480 ifp = dp->i_afp;
481 sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;
Nathan Scott3b244aa2006-03-17 17:29:25 +1100482 size = be16_to_cpu(sf->hdr.totsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 tmpbuffer = kmem_alloc(size, KM_SLEEP);
484 ASSERT(tmpbuffer != NULL);
485 memcpy(tmpbuffer, ifp->if_u1.if_data, size);
486 sf = (xfs_attr_shortform_t *)tmpbuffer;
487
488 xfs_idata_realloc(dp, -size, XFS_ATTR_FORK);
489 bp = NULL;
490 error = xfs_da_grow_inode(args, &blkno);
491 if (error) {
492 /*
493 * If we hit an IO error middle of the transaction inside
494 * grow_inode(), we may have inconsistent data. Bail out.
495 */
496 if (error == EIO)
497 goto out;
498 xfs_idata_realloc(dp, size, XFS_ATTR_FORK); /* try to put */
499 memcpy(ifp->if_u1.if_data, tmpbuffer, size); /* it back */
500 goto out;
501 }
502
503 ASSERT(blkno == 0);
504 error = xfs_attr_leaf_create(args, blkno, &bp);
505 if (error) {
506 error = xfs_da_shrink_inode(args, 0, bp);
507 bp = NULL;
508 if (error)
509 goto out;
510 xfs_idata_realloc(dp, size, XFS_ATTR_FORK); /* try to put */
511 memcpy(ifp->if_u1.if_data, tmpbuffer, size); /* it back */
512 goto out;
513 }
514
515 memset((char *)&nargs, 0, sizeof(nargs));
516 nargs.dp = dp;
517 nargs.firstblock = args->firstblock;
518 nargs.flist = args->flist;
519 nargs.total = args->total;
520 nargs.whichfork = XFS_ATTR_FORK;
521 nargs.trans = args->trans;
Barry Naujok6a178102008-05-21 16:42:05 +1000522 nargs.op_flags = XFS_DA_OP_OKNOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523
524 sfe = &sf->list[0];
Nathan Scott3b244aa2006-03-17 17:29:25 +1100525 for (i = 0; i < sf->hdr.count; i++) {
Dave Chinnera9273ca2010-01-20 10:47:48 +1100526 nargs.name = sfe->nameval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 nargs.namelen = sfe->namelen;
Dave Chinnera9273ca2010-01-20 10:47:48 +1100528 nargs.value = &sfe->nameval[nargs.namelen];
Nathan Scott3b244aa2006-03-17 17:29:25 +1100529 nargs.valuelen = sfe->valuelen;
Dave Chinnera9273ca2010-01-20 10:47:48 +1100530 nargs.hashval = xfs_da_hashname(sfe->nameval,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 sfe->namelen);
Tim Shimmin726801b2006-09-28 11:01:37 +1000532 nargs.flags = XFS_ATTR_NSP_ONDISK_TO_ARGS(sfe->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 error = xfs_attr_leaf_lookup_int(bp, &nargs); /* set a->index */
534 ASSERT(error == ENOATTR);
535 error = xfs_attr_leaf_add(bp, &nargs);
536 ASSERT(error != ENOSPC);
537 if (error)
538 goto out;
539 sfe = XFS_ATTR_SF_NEXTENTRY(sfe);
540 }
541 error = 0;
542
543out:
544 if(bp)
545 xfs_da_buf_done(bp);
Denys Vlasenkof0e2d932008-05-19 16:31:57 +1000546 kmem_free(tmpbuffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 return(error);
548}
549
550STATIC int
551xfs_attr_shortform_compare(const void *a, const void *b)
552{
553 xfs_attr_sf_sort_t *sa, *sb;
554
555 sa = (xfs_attr_sf_sort_t *)a;
556 sb = (xfs_attr_sf_sort_t *)b;
Nathan Scott984a0812006-03-17 17:29:31 +1100557 if (sa->hash < sb->hash) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 return(-1);
Nathan Scott984a0812006-03-17 17:29:31 +1100559 } else if (sa->hash > sb->hash) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 return(1);
561 } else {
562 return(sa->entno - sb->entno);
563 }
564}
565
Tim Shimmin726801b2006-09-28 11:01:37 +1000566
567#define XFS_ISRESET_CURSOR(cursor) \
568 (!((cursor)->initted) && !((cursor)->hashval) && \
569 !((cursor)->blkno) && !((cursor)->offset))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570/*
571 * Copy out entries of shortform attribute lists for attr_list().
Nathan Scottc41564b2006-03-29 08:55:14 +1000572 * Shortform attribute lists are not stored in hashval sorted order.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 * If the output buffer is not large enough to hold them all, then we
574 * we have to calculate each entries' hashvalue and sort them before
575 * we can begin returning them to the user.
576 */
577/*ARGSUSED*/
578int
579xfs_attr_shortform_list(xfs_attr_list_context_t *context)
580{
581 attrlist_cursor_kern_t *cursor;
582 xfs_attr_sf_sort_t *sbuf, *sbp;
583 xfs_attr_shortform_t *sf;
584 xfs_attr_sf_entry_t *sfe;
585 xfs_inode_t *dp;
586 int sbsize, nsbuf, count, i;
Tim Shimmin726801b2006-09-28 11:01:37 +1000587 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588
589 ASSERT(context != NULL);
590 dp = context->dp;
591 ASSERT(dp != NULL);
592 ASSERT(dp->i_afp != NULL);
593 sf = (xfs_attr_shortform_t *)dp->i_afp->if_u1.if_data;
594 ASSERT(sf != NULL);
595 if (!sf->hdr.count)
596 return(0);
597 cursor = context->cursor;
598 ASSERT(cursor != NULL);
599
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000600 trace_xfs_attr_list_sf(context);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601
602 /*
Tim Shimmin726801b2006-09-28 11:01:37 +1000603 * If the buffer is large enough and the cursor is at the start,
604 * do not bother with sorting since we will return everything in
605 * one buffer and another call using the cursor won't need to be
606 * made.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 * Note the generous fudge factor of 16 overhead bytes per entry.
Tim Shimmin726801b2006-09-28 11:01:37 +1000608 * If bufsize is zero then put_listent must be a search function
609 * and can just scan through what we have.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 */
Tim Shimmin726801b2006-09-28 11:01:37 +1000611 if (context->bufsize == 0 ||
612 (XFS_ISRESET_CURSOR(cursor) &&
613 (dp->i_afp->if_bytes + sf->hdr.count * 16) < context->bufsize)) {
Nathan Scott3b244aa2006-03-17 17:29:25 +1100614 for (i = 0, sfe = &sf->list[0]; i < sf->hdr.count; i++) {
Tim Shimmin726801b2006-09-28 11:01:37 +1000615 error = context->put_listent(context,
Christoph Hellwigad9b4632008-06-23 13:23:48 +1000616 sfe->flags,
Dave Chinnera9273ca2010-01-20 10:47:48 +1100617 sfe->nameval,
Tim Shimmin726801b2006-09-28 11:01:37 +1000618 (int)sfe->namelen,
619 (int)sfe->valuelen,
Dave Chinnera9273ca2010-01-20 10:47:48 +1100620 &sfe->nameval[sfe->namelen]);
Tim Shimmin726801b2006-09-28 11:01:37 +1000621
622 /*
623 * Either search callback finished early or
624 * didn't fit it all in the buffer after all.
625 */
626 if (context->seen_enough)
627 break;
628
629 if (error)
630 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 sfe = XFS_ATTR_SF_NEXTENTRY(sfe);
632 }
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000633 trace_xfs_attr_list_sf_all(context);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 return(0);
635 }
636
Tim Shimmin726801b2006-09-28 11:01:37 +1000637 /* do no more for a search callback */
638 if (context->bufsize == 0)
639 return 0;
640
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 /*
642 * It didn't all fit, so we have to sort everything on hashval.
643 */
Nathan Scott3b244aa2006-03-17 17:29:25 +1100644 sbsize = sf->hdr.count * sizeof(*sbuf);
Dave Chinner622d8142010-12-23 11:57:37 +1100645 sbp = sbuf = kmem_alloc(sbsize, KM_SLEEP | KM_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646
647 /*
648 * Scan the attribute list for the rest of the entries, storing
649 * the relevant info from only those that match into a buffer.
650 */
651 nsbuf = 0;
Nathan Scott3b244aa2006-03-17 17:29:25 +1100652 for (i = 0, sfe = &sf->list[0]; i < sf->hdr.count; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 if (unlikely(
654 ((char *)sfe < (char *)sf) ||
655 ((char *)sfe >= ((char *)sf + dp->i_afp->if_bytes)))) {
656 XFS_CORRUPTION_ERROR("xfs_attr_shortform_list",
657 XFS_ERRLEVEL_LOW,
658 context->dp->i_mount, sfe);
Denys Vlasenkof0e2d932008-05-19 16:31:57 +1000659 kmem_free(sbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 return XFS_ERROR(EFSCORRUPTED);
661 }
Christoph Hellwigad9b4632008-06-23 13:23:48 +1000662
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 sbp->entno = i;
Dave Chinnera9273ca2010-01-20 10:47:48 +1100664 sbp->hash = xfs_da_hashname(sfe->nameval, sfe->namelen);
665 sbp->name = sfe->nameval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 sbp->namelen = sfe->namelen;
667 /* These are bytes, and both on-disk, don't endian-flip */
668 sbp->valuelen = sfe->valuelen;
669 sbp->flags = sfe->flags;
670 sfe = XFS_ATTR_SF_NEXTENTRY(sfe);
671 sbp++;
672 nsbuf++;
673 }
674
675 /*
676 * Sort the entries on hash then entno.
677 */
Nathan Scott380b5dc2005-11-02 11:43:18 +1100678 xfs_sort(sbuf, nsbuf, sizeof(*sbuf), xfs_attr_shortform_compare);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679
680 /*
681 * Re-find our place IN THE SORTED LIST.
682 */
683 count = 0;
684 cursor->initted = 1;
685 cursor->blkno = 0;
686 for (sbp = sbuf, i = 0; i < nsbuf; i++, sbp++) {
Nathan Scott984a0812006-03-17 17:29:31 +1100687 if (sbp->hash == cursor->hashval) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 if (cursor->offset == count) {
689 break;
690 }
691 count++;
Nathan Scott984a0812006-03-17 17:29:31 +1100692 } else if (sbp->hash > cursor->hashval) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 break;
694 }
695 }
696 if (i == nsbuf) {
Denys Vlasenkof0e2d932008-05-19 16:31:57 +1000697 kmem_free(sbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 return(0);
699 }
700
701 /*
702 * Loop putting entries into the user buffer.
703 */
704 for ( ; i < nsbuf; i++, sbp++) {
Nathan Scott984a0812006-03-17 17:29:31 +1100705 if (cursor->hashval != sbp->hash) {
706 cursor->hashval = sbp->hash;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 cursor->offset = 0;
708 }
Tim Shimmin726801b2006-09-28 11:01:37 +1000709 error = context->put_listent(context,
Christoph Hellwigad9b4632008-06-23 13:23:48 +1000710 sbp->flags,
Tim Shimmin726801b2006-09-28 11:01:37 +1000711 sbp->name,
712 sbp->namelen,
713 sbp->valuelen,
714 &sbp->name[sbp->namelen]);
715 if (error)
716 return error;
717 if (context->seen_enough)
718 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 cursor->offset++;
720 }
721
Denys Vlasenkof0e2d932008-05-19 16:31:57 +1000722 kmem_free(sbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 return(0);
724}
725
726/*
727 * Check a leaf attribute block to see if all the entries would fit into
728 * a shortform attribute list.
729 */
730int
731xfs_attr_shortform_allfit(xfs_dabuf_t *bp, xfs_inode_t *dp)
732{
733 xfs_attr_leafblock_t *leaf;
734 xfs_attr_leaf_entry_t *entry;
735 xfs_attr_leaf_name_local_t *name_loc;
736 int bytes, i;
737
738 leaf = bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +0200739 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740
741 entry = &leaf->entries[0];
742 bytes = sizeof(struct xfs_attr_sf_hdr);
Nathan Scott918ae422006-03-17 17:28:54 +1100743 for (i = 0; i < be16_to_cpu(leaf->hdr.count); entry++, i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 if (entry->flags & XFS_ATTR_INCOMPLETE)
745 continue; /* don't copy partial entries */
746 if (!(entry->flags & XFS_ATTR_LOCAL))
747 return(0);
Eric Sandeenc9fb86a2009-01-01 16:40:11 -0600748 name_loc = xfs_attr_leaf_name_local(leaf, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 if (name_loc->namelen >= XFS_ATTR_SF_ENTSIZE_MAX)
750 return(0);
Nathan Scott053b5752006-03-17 17:29:09 +1100751 if (be16_to_cpu(name_loc->valuelen) >= XFS_ATTR_SF_ENTSIZE_MAX)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 return(0);
753 bytes += sizeof(struct xfs_attr_sf_entry)-1
754 + name_loc->namelen
Nathan Scott053b5752006-03-17 17:29:09 +1100755 + be16_to_cpu(name_loc->valuelen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 }
Nathan Scott13059ff2006-01-11 15:32:01 +1100757 if ((dp->i_mount->m_flags & XFS_MOUNT_ATTR2) &&
Barry Naujoke5889e92007-02-10 18:35:58 +1100758 (dp->i_d.di_format != XFS_DINODE_FMT_BTREE) &&
Nathan Scotte0144ca2005-11-25 16:42:22 +1100759 (bytes == sizeof(struct xfs_attr_sf_hdr)))
Nathan Scottd8cc8902005-11-02 10:34:53 +1100760 return(-1);
761 return(xfs_attr_shortform_bytesfit(dp, bytes));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762}
763
764/*
765 * Convert a leaf attribute list to shortform attribute list
766 */
767int
Nathan Scottd8cc8902005-11-02 10:34:53 +1100768xfs_attr_leaf_to_shortform(xfs_dabuf_t *bp, xfs_da_args_t *args, int forkoff)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769{
770 xfs_attr_leafblock_t *leaf;
771 xfs_attr_leaf_entry_t *entry;
772 xfs_attr_leaf_name_local_t *name_loc;
773 xfs_da_args_t nargs;
774 xfs_inode_t *dp;
775 char *tmpbuffer;
776 int error, i;
777
778 dp = args->dp;
779 tmpbuffer = kmem_alloc(XFS_LBSIZE(dp->i_mount), KM_SLEEP);
780 ASSERT(tmpbuffer != NULL);
781
782 ASSERT(bp != NULL);
783 memcpy(tmpbuffer, bp->data, XFS_LBSIZE(dp->i_mount));
784 leaf = (xfs_attr_leafblock_t *)tmpbuffer;
Christoph Hellwig69ef9212011-07-08 14:36:05 +0200785 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 memset(bp->data, 0, XFS_LBSIZE(dp->i_mount));
787
788 /*
789 * Clean out the prior contents of the attribute list.
790 */
791 error = xfs_da_shrink_inode(args, 0, bp);
792 if (error)
793 goto out;
Nathan Scottd8cc8902005-11-02 10:34:53 +1100794
795 if (forkoff == -1) {
Nathan Scott13059ff2006-01-11 15:32:01 +1100796 ASSERT(dp->i_mount->m_flags & XFS_MOUNT_ATTR2);
Barry Naujoke5889e92007-02-10 18:35:58 +1100797 ASSERT(dp->i_d.di_format != XFS_DINODE_FMT_BTREE);
Christoph Hellwige1486de2009-02-04 09:36:00 +0100798 xfs_attr_fork_reset(dp, args->trans);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 goto out;
Nathan Scottd8cc8902005-11-02 10:34:53 +1100800 }
801
802 xfs_attr_shortform_create(args);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803
804 /*
805 * Copy the attributes
806 */
807 memset((char *)&nargs, 0, sizeof(nargs));
808 nargs.dp = dp;
809 nargs.firstblock = args->firstblock;
810 nargs.flist = args->flist;
811 nargs.total = args->total;
812 nargs.whichfork = XFS_ATTR_FORK;
813 nargs.trans = args->trans;
Barry Naujok6a178102008-05-21 16:42:05 +1000814 nargs.op_flags = XFS_DA_OP_OKNOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 entry = &leaf->entries[0];
Nathan Scott918ae422006-03-17 17:28:54 +1100816 for (i = 0; i < be16_to_cpu(leaf->hdr.count); entry++, i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 if (entry->flags & XFS_ATTR_INCOMPLETE)
818 continue; /* don't copy partial entries */
819 if (!entry->nameidx)
820 continue;
821 ASSERT(entry->flags & XFS_ATTR_LOCAL);
Eric Sandeenc9fb86a2009-01-01 16:40:11 -0600822 name_loc = xfs_attr_leaf_name_local(leaf, i);
Dave Chinnera9273ca2010-01-20 10:47:48 +1100823 nargs.name = name_loc->nameval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 nargs.namelen = name_loc->namelen;
Dave Chinnera9273ca2010-01-20 10:47:48 +1100825 nargs.value = &name_loc->nameval[nargs.namelen];
Nathan Scott053b5752006-03-17 17:29:09 +1100826 nargs.valuelen = be16_to_cpu(name_loc->valuelen);
Nathan Scott6b19f2d2006-03-17 17:29:02 +1100827 nargs.hashval = be32_to_cpu(entry->hashval);
Tim Shimmin726801b2006-09-28 11:01:37 +1000828 nargs.flags = XFS_ATTR_NSP_ONDISK_TO_ARGS(entry->flags);
Nathan Scottd8cc8902005-11-02 10:34:53 +1100829 xfs_attr_shortform_add(&nargs, forkoff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 }
831 error = 0;
832
833out:
Denys Vlasenkof0e2d932008-05-19 16:31:57 +1000834 kmem_free(tmpbuffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 return(error);
836}
837
838/*
839 * Convert from using a single leaf to a root node and a leaf.
840 */
841int
842xfs_attr_leaf_to_node(xfs_da_args_t *args)
843{
844 xfs_attr_leafblock_t *leaf;
845 xfs_da_intnode_t *node;
846 xfs_inode_t *dp;
847 xfs_dabuf_t *bp1, *bp2;
848 xfs_dablk_t blkno;
849 int error;
850
851 dp = args->dp;
852 bp1 = bp2 = NULL;
853 error = xfs_da_grow_inode(args, &blkno);
854 if (error)
855 goto out;
856 error = xfs_da_read_buf(args->trans, args->dp, 0, -1, &bp1,
857 XFS_ATTR_FORK);
858 if (error)
859 goto out;
860 ASSERT(bp1 != NULL);
861 bp2 = NULL;
862 error = xfs_da_get_buf(args->trans, args->dp, blkno, -1, &bp2,
863 XFS_ATTR_FORK);
864 if (error)
865 goto out;
866 ASSERT(bp2 != NULL);
867 memcpy(bp2->data, bp1->data, XFS_LBSIZE(dp->i_mount));
868 xfs_da_buf_done(bp1);
869 bp1 = NULL;
870 xfs_da_log_buf(args->trans, bp2, 0, XFS_LBSIZE(dp->i_mount) - 1);
871
872 /*
873 * Set up the new root node.
874 */
875 error = xfs_da_node_create(args, 0, 1, &bp1, XFS_ATTR_FORK);
876 if (error)
877 goto out;
878 node = bp1->data;
879 leaf = bp2->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +0200880 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 /* both on-disk, don't endian-flip twice */
882 node->btree[0].hashval =
Nathan Scott918ae422006-03-17 17:28:54 +1100883 leaf->entries[be16_to_cpu(leaf->hdr.count)-1 ].hashval;
Nathan Scott403432d2006-03-17 17:29:46 +1100884 node->btree[0].before = cpu_to_be32(blkno);
Nathan Scottfac80cc2006-03-17 17:29:56 +1100885 node->hdr.count = cpu_to_be16(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 xfs_da_log_buf(args->trans, bp1, 0, XFS_LBSIZE(dp->i_mount) - 1);
887 error = 0;
888out:
889 if (bp1)
890 xfs_da_buf_done(bp1);
891 if (bp2)
892 xfs_da_buf_done(bp2);
893 return(error);
894}
895
896
897/*========================================================================
898 * Routines used for growing the Btree.
899 *========================================================================*/
900
901/*
902 * Create the initial contents of a leaf attribute list
903 * or a leaf in a node attribute list.
904 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +1000905STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906xfs_attr_leaf_create(xfs_da_args_t *args, xfs_dablk_t blkno, xfs_dabuf_t **bpp)
907{
908 xfs_attr_leafblock_t *leaf;
909 xfs_attr_leaf_hdr_t *hdr;
910 xfs_inode_t *dp;
911 xfs_dabuf_t *bp;
912 int error;
913
914 dp = args->dp;
915 ASSERT(dp != NULL);
916 error = xfs_da_get_buf(args->trans, args->dp, blkno, -1, &bp,
917 XFS_ATTR_FORK);
918 if (error)
919 return(error);
920 ASSERT(bp != NULL);
921 leaf = bp->data;
922 memset((char *)leaf, 0, XFS_LBSIZE(dp->i_mount));
923 hdr = &leaf->hdr;
Nathan Scott89da0542006-03-17 17:28:40 +1100924 hdr->info.magic = cpu_to_be16(XFS_ATTR_LEAF_MAGIC);
Nathan Scott918ae422006-03-17 17:28:54 +1100925 hdr->firstused = cpu_to_be16(XFS_LBSIZE(dp->i_mount));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 if (!hdr->firstused) {
Nathan Scott918ae422006-03-17 17:28:54 +1100927 hdr->firstused = cpu_to_be16(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 XFS_LBSIZE(dp->i_mount) - XFS_ATTR_LEAF_NAME_ALIGN);
929 }
930
Nathan Scott918ae422006-03-17 17:28:54 +1100931 hdr->freemap[0].base = cpu_to_be16(sizeof(xfs_attr_leaf_hdr_t));
932 hdr->freemap[0].size = cpu_to_be16(be16_to_cpu(hdr->firstused) -
933 sizeof(xfs_attr_leaf_hdr_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934
935 xfs_da_log_buf(args->trans, bp, 0, XFS_LBSIZE(dp->i_mount) - 1);
936
937 *bpp = bp;
938 return(0);
939}
940
941/*
942 * Split the leaf node, rebalance, then add the new entry.
943 */
944int
945xfs_attr_leaf_split(xfs_da_state_t *state, xfs_da_state_blk_t *oldblk,
946 xfs_da_state_blk_t *newblk)
947{
948 xfs_dablk_t blkno;
949 int error;
950
951 /*
952 * Allocate space for a new leaf node.
953 */
954 ASSERT(oldblk->magic == XFS_ATTR_LEAF_MAGIC);
955 error = xfs_da_grow_inode(state->args, &blkno);
956 if (error)
957 return(error);
958 error = xfs_attr_leaf_create(state->args, blkno, &newblk->bp);
959 if (error)
960 return(error);
961 newblk->blkno = blkno;
962 newblk->magic = XFS_ATTR_LEAF_MAGIC;
963
964 /*
965 * Rebalance the entries across the two leaves.
966 * NOTE: rebalance() currently depends on the 2nd block being empty.
967 */
968 xfs_attr_leaf_rebalance(state, oldblk, newblk);
969 error = xfs_da_blk_link(state, oldblk, newblk);
970 if (error)
971 return(error);
972
973 /*
974 * Save info on "old" attribute for "atomic rename" ops, leaf_add()
975 * modifies the index/blkno/rmtblk/rmtblkcnt fields to show the
976 * "new" attrs info. Will need the "old" info to remove it later.
977 *
978 * Insert the "new" entry in the correct block.
979 */
980 if (state->inleaf)
981 error = xfs_attr_leaf_add(oldblk->bp, state->args);
982 else
983 error = xfs_attr_leaf_add(newblk->bp, state->args);
984
985 /*
986 * Update last hashval in each block since we added the name.
987 */
988 oldblk->hashval = xfs_attr_leaf_lasthash(oldblk->bp, NULL);
989 newblk->hashval = xfs_attr_leaf_lasthash(newblk->bp, NULL);
990 return(error);
991}
992
993/*
994 * Add a name to the leaf attribute list structure.
995 */
996int
997xfs_attr_leaf_add(xfs_dabuf_t *bp, xfs_da_args_t *args)
998{
999 xfs_attr_leafblock_t *leaf;
1000 xfs_attr_leaf_hdr_t *hdr;
1001 xfs_attr_leaf_map_t *map;
1002 int tablesize, entsize, sum, tmp, i;
1003
1004 leaf = bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02001005 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 ASSERT((args->index >= 0)
Nathan Scott918ae422006-03-17 17:28:54 +11001007 && (args->index <= be16_to_cpu(leaf->hdr.count)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 hdr = &leaf->hdr;
Nathan Scottaa82daa2005-11-02 10:33:33 +11001009 entsize = xfs_attr_leaf_newentsize(args->namelen, args->valuelen,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 args->trans->t_mountp->m_sb.sb_blocksize, NULL);
1011
1012 /*
1013 * Search through freemap for first-fit on new name length.
1014 * (may need to figure in size of entry struct too)
1015 */
Nathan Scott918ae422006-03-17 17:28:54 +11001016 tablesize = (be16_to_cpu(hdr->count) + 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 * sizeof(xfs_attr_leaf_entry_t)
1018 + sizeof(xfs_attr_leaf_hdr_t);
1019 map = &hdr->freemap[XFS_ATTR_LEAF_MAPSIZE-1];
1020 for (sum = 0, i = XFS_ATTR_LEAF_MAPSIZE-1; i >= 0; map--, i--) {
Nathan Scott918ae422006-03-17 17:28:54 +11001021 if (tablesize > be16_to_cpu(hdr->firstused)) {
1022 sum += be16_to_cpu(map->size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 continue;
1024 }
1025 if (!map->size)
1026 continue; /* no space in this map */
1027 tmp = entsize;
Nathan Scott918ae422006-03-17 17:28:54 +11001028 if (be16_to_cpu(map->base) < be16_to_cpu(hdr->firstused))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 tmp += sizeof(xfs_attr_leaf_entry_t);
Nathan Scott918ae422006-03-17 17:28:54 +11001030 if (be16_to_cpu(map->size) >= tmp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 tmp = xfs_attr_leaf_add_work(bp, args, i);
1032 return(tmp);
1033 }
Nathan Scott918ae422006-03-17 17:28:54 +11001034 sum += be16_to_cpu(map->size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 }
1036
1037 /*
1038 * If there are no holes in the address space of the block,
1039 * and we don't have enough freespace, then compaction will do us
1040 * no good and we should just give up.
1041 */
1042 if (!hdr->holes && (sum < entsize))
1043 return(XFS_ERROR(ENOSPC));
1044
1045 /*
1046 * Compact the entries to coalesce free space.
1047 * This may change the hdr->count via dropping INCOMPLETE entries.
1048 */
1049 xfs_attr_leaf_compact(args->trans, bp);
1050
1051 /*
1052 * After compaction, the block is guaranteed to have only one
1053 * free region, in freemap[0]. If it is not big enough, give up.
1054 */
Nathan Scott918ae422006-03-17 17:28:54 +11001055 if (be16_to_cpu(hdr->freemap[0].size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 < (entsize + sizeof(xfs_attr_leaf_entry_t)))
1057 return(XFS_ERROR(ENOSPC));
1058
1059 return(xfs_attr_leaf_add_work(bp, args, 0));
1060}
1061
1062/*
1063 * Add a name to a leaf attribute list structure.
1064 */
1065STATIC int
1066xfs_attr_leaf_add_work(xfs_dabuf_t *bp, xfs_da_args_t *args, int mapindex)
1067{
1068 xfs_attr_leafblock_t *leaf;
1069 xfs_attr_leaf_hdr_t *hdr;
1070 xfs_attr_leaf_entry_t *entry;
1071 xfs_attr_leaf_name_local_t *name_loc;
1072 xfs_attr_leaf_name_remote_t *name_rmt;
1073 xfs_attr_leaf_map_t *map;
1074 xfs_mount_t *mp;
1075 int tmp, i;
1076
1077 leaf = bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02001078 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 hdr = &leaf->hdr;
1080 ASSERT((mapindex >= 0) && (mapindex < XFS_ATTR_LEAF_MAPSIZE));
Nathan Scott918ae422006-03-17 17:28:54 +11001081 ASSERT((args->index >= 0) && (args->index <= be16_to_cpu(hdr->count)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082
1083 /*
1084 * Force open some space in the entry array and fill it in.
1085 */
1086 entry = &leaf->entries[args->index];
Nathan Scott918ae422006-03-17 17:28:54 +11001087 if (args->index < be16_to_cpu(hdr->count)) {
1088 tmp = be16_to_cpu(hdr->count) - args->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 tmp *= sizeof(xfs_attr_leaf_entry_t);
1090 memmove((char *)(entry+1), (char *)entry, tmp);
1091 xfs_da_log_buf(args->trans, bp,
1092 XFS_DA_LOGRANGE(leaf, entry, tmp + sizeof(*entry)));
1093 }
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001094 be16_add_cpu(&hdr->count, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095
1096 /*
1097 * Allocate space for the new string (at the end of the run).
1098 */
1099 map = &hdr->freemap[mapindex];
1100 mp = args->trans->t_mountp;
Nathan Scott918ae422006-03-17 17:28:54 +11001101 ASSERT(be16_to_cpu(map->base) < XFS_LBSIZE(mp));
1102 ASSERT((be16_to_cpu(map->base) & 0x3) == 0);
1103 ASSERT(be16_to_cpu(map->size) >=
Nathan Scottaa82daa2005-11-02 10:33:33 +11001104 xfs_attr_leaf_newentsize(args->namelen, args->valuelen,
1105 mp->m_sb.sb_blocksize, NULL));
Nathan Scott918ae422006-03-17 17:28:54 +11001106 ASSERT(be16_to_cpu(map->size) < XFS_LBSIZE(mp));
1107 ASSERT((be16_to_cpu(map->size) & 0x3) == 0);
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001108 be16_add_cpu(&map->size,
Nathan Scottaa82daa2005-11-02 10:33:33 +11001109 -xfs_attr_leaf_newentsize(args->namelen, args->valuelen,
1110 mp->m_sb.sb_blocksize, &tmp));
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001111 entry->nameidx = cpu_to_be16(be16_to_cpu(map->base) +
1112 be16_to_cpu(map->size));
1113 entry->hashval = cpu_to_be32(args->hashval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114 entry->flags = tmp ? XFS_ATTR_LOCAL : 0;
Tim Shimmin726801b2006-09-28 11:01:37 +10001115 entry->flags |= XFS_ATTR_NSP_ARGS_TO_ONDISK(args->flags);
Barry Naujok6a178102008-05-21 16:42:05 +10001116 if (args->op_flags & XFS_DA_OP_RENAME) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 entry->flags |= XFS_ATTR_INCOMPLETE;
1118 if ((args->blkno2 == args->blkno) &&
1119 (args->index2 <= args->index)) {
1120 args->index2++;
1121 }
1122 }
1123 xfs_da_log_buf(args->trans, bp,
1124 XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001125 ASSERT((args->index == 0) ||
1126 (be32_to_cpu(entry->hashval) >= be32_to_cpu((entry-1)->hashval)));
Nathan Scott918ae422006-03-17 17:28:54 +11001127 ASSERT((args->index == be16_to_cpu(hdr->count)-1) ||
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001128 (be32_to_cpu(entry->hashval) <= be32_to_cpu((entry+1)->hashval)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129
1130 /*
1131 * Copy the attribute name and value into the new space.
1132 *
1133 * For "remote" attribute values, simply note that we need to
1134 * allocate space for the "remote" value. We can't actually
1135 * allocate the extents in this transaction, and we can't decide
1136 * which blocks they should be as we might allocate more blocks
1137 * as part of this transaction (a split operation for example).
1138 */
1139 if (entry->flags & XFS_ATTR_LOCAL) {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06001140 name_loc = xfs_attr_leaf_name_local(leaf, args->index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 name_loc->namelen = args->namelen;
Nathan Scott053b5752006-03-17 17:29:09 +11001142 name_loc->valuelen = cpu_to_be16(args->valuelen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 memcpy((char *)name_loc->nameval, args->name, args->namelen);
1144 memcpy((char *)&name_loc->nameval[args->namelen], args->value,
Nathan Scott053b5752006-03-17 17:29:09 +11001145 be16_to_cpu(name_loc->valuelen));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 } else {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06001147 name_rmt = xfs_attr_leaf_name_remote(leaf, args->index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 name_rmt->namelen = args->namelen;
1149 memcpy((char *)name_rmt->name, args->name, args->namelen);
1150 entry->flags |= XFS_ATTR_INCOMPLETE;
1151 /* just in case */
1152 name_rmt->valuelen = 0;
1153 name_rmt->valueblk = 0;
1154 args->rmtblkno = 1;
1155 args->rmtblkcnt = XFS_B_TO_FSB(mp, args->valuelen);
1156 }
1157 xfs_da_log_buf(args->trans, bp,
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06001158 XFS_DA_LOGRANGE(leaf, xfs_attr_leaf_name(leaf, args->index),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 xfs_attr_leaf_entsize(leaf, args->index)));
1160
1161 /*
1162 * Update the control info for this leaf node
1163 */
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001164 if (be16_to_cpu(entry->nameidx) < be16_to_cpu(hdr->firstused)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165 /* both on-disk, don't endian-flip twice */
1166 hdr->firstused = entry->nameidx;
1167 }
Nathan Scott918ae422006-03-17 17:28:54 +11001168 ASSERT(be16_to_cpu(hdr->firstused) >=
1169 ((be16_to_cpu(hdr->count) * sizeof(*entry)) + sizeof(*hdr)));
1170 tmp = (be16_to_cpu(hdr->count)-1) * sizeof(xfs_attr_leaf_entry_t)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 + sizeof(xfs_attr_leaf_hdr_t);
1172 map = &hdr->freemap[0];
1173 for (i = 0; i < XFS_ATTR_LEAF_MAPSIZE; map++, i++) {
Nathan Scott918ae422006-03-17 17:28:54 +11001174 if (be16_to_cpu(map->base) == tmp) {
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001175 be16_add_cpu(&map->base, sizeof(xfs_attr_leaf_entry_t));
1176 be16_add_cpu(&map->size,
Nathan Scott918ae422006-03-17 17:28:54 +11001177 -((int)sizeof(xfs_attr_leaf_entry_t)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178 }
1179 }
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001180 be16_add_cpu(&hdr->usedbytes, xfs_attr_leaf_entsize(leaf, args->index));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 xfs_da_log_buf(args->trans, bp,
1182 XFS_DA_LOGRANGE(leaf, hdr, sizeof(*hdr)));
1183 return(0);
1184}
1185
1186/*
1187 * Garbage collect a leaf attribute list block by copying it to a new buffer.
1188 */
1189STATIC void
1190xfs_attr_leaf_compact(xfs_trans_t *trans, xfs_dabuf_t *bp)
1191{
1192 xfs_attr_leafblock_t *leaf_s, *leaf_d;
1193 xfs_attr_leaf_hdr_t *hdr_s, *hdr_d;
1194 xfs_mount_t *mp;
1195 char *tmpbuffer;
1196
1197 mp = trans->t_mountp;
1198 tmpbuffer = kmem_alloc(XFS_LBSIZE(mp), KM_SLEEP);
1199 ASSERT(tmpbuffer != NULL);
1200 memcpy(tmpbuffer, bp->data, XFS_LBSIZE(mp));
1201 memset(bp->data, 0, XFS_LBSIZE(mp));
1202
1203 /*
1204 * Copy basic information
1205 */
1206 leaf_s = (xfs_attr_leafblock_t *)tmpbuffer;
1207 leaf_d = bp->data;
1208 hdr_s = &leaf_s->hdr;
1209 hdr_d = &leaf_d->hdr;
1210 hdr_d->info = hdr_s->info; /* struct copy */
Nathan Scott918ae422006-03-17 17:28:54 +11001211 hdr_d->firstused = cpu_to_be16(XFS_LBSIZE(mp));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212 /* handle truncation gracefully */
1213 if (!hdr_d->firstused) {
Nathan Scott918ae422006-03-17 17:28:54 +11001214 hdr_d->firstused = cpu_to_be16(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 XFS_LBSIZE(mp) - XFS_ATTR_LEAF_NAME_ALIGN);
1216 }
1217 hdr_d->usedbytes = 0;
1218 hdr_d->count = 0;
1219 hdr_d->holes = 0;
Nathan Scott918ae422006-03-17 17:28:54 +11001220 hdr_d->freemap[0].base = cpu_to_be16(sizeof(xfs_attr_leaf_hdr_t));
1221 hdr_d->freemap[0].size = cpu_to_be16(be16_to_cpu(hdr_d->firstused) -
1222 sizeof(xfs_attr_leaf_hdr_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223
1224 /*
1225 * Copy all entry's in the same (sorted) order,
1226 * but allocate name/value pairs packed and in sequence.
1227 */
1228 xfs_attr_leaf_moveents(leaf_s, 0, leaf_d, 0,
Nathan Scott918ae422006-03-17 17:28:54 +11001229 be16_to_cpu(hdr_s->count), mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230 xfs_da_log_buf(trans, bp, 0, XFS_LBSIZE(mp) - 1);
1231
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10001232 kmem_free(tmpbuffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233}
1234
1235/*
1236 * Redistribute the attribute list entries between two leaf nodes,
1237 * taking into account the size of the new entry.
1238 *
1239 * NOTE: if new block is empty, then it will get the upper half of the
1240 * old block. At present, all (one) callers pass in an empty second block.
1241 *
1242 * This code adjusts the args->index/blkno and args->index2/blkno2 fields
1243 * to match what it is doing in splitting the attribute leaf block. Those
1244 * values are used in "atomic rename" operations on attributes. Note that
1245 * the "new" and "old" values can end up in different blocks.
1246 */
1247STATIC void
1248xfs_attr_leaf_rebalance(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
1249 xfs_da_state_blk_t *blk2)
1250{
1251 xfs_da_args_t *args;
1252 xfs_da_state_blk_t *tmp_blk;
1253 xfs_attr_leafblock_t *leaf1, *leaf2;
1254 xfs_attr_leaf_hdr_t *hdr1, *hdr2;
1255 int count, totallen, max, space, swap;
1256
1257 /*
1258 * Set up environment.
1259 */
1260 ASSERT(blk1->magic == XFS_ATTR_LEAF_MAGIC);
1261 ASSERT(blk2->magic == XFS_ATTR_LEAF_MAGIC);
1262 leaf1 = blk1->bp->data;
1263 leaf2 = blk2->bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02001264 ASSERT(leaf1->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1265 ASSERT(leaf2->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 args = state->args;
1267
1268 /*
1269 * Check ordering of blocks, reverse if it makes things simpler.
1270 *
1271 * NOTE: Given that all (current) callers pass in an empty
1272 * second block, this code should never set "swap".
1273 */
1274 swap = 0;
1275 if (xfs_attr_leaf_order(blk1->bp, blk2->bp)) {
1276 tmp_blk = blk1;
1277 blk1 = blk2;
1278 blk2 = tmp_blk;
1279 leaf1 = blk1->bp->data;
1280 leaf2 = blk2->bp->data;
1281 swap = 1;
1282 }
1283 hdr1 = &leaf1->hdr;
1284 hdr2 = &leaf2->hdr;
1285
1286 /*
1287 * Examine entries until we reduce the absolute difference in
1288 * byte usage between the two blocks to a minimum. Then get
1289 * the direction to copy and the number of elements to move.
1290 *
1291 * "inleaf" is true if the new entry should be inserted into blk1.
1292 * If "swap" is also true, then reverse the sense of "inleaf".
1293 */
1294 state->inleaf = xfs_attr_leaf_figure_balance(state, blk1, blk2,
1295 &count, &totallen);
1296 if (swap)
1297 state->inleaf = !state->inleaf;
1298
1299 /*
1300 * Move any entries required from leaf to leaf:
1301 */
Nathan Scott918ae422006-03-17 17:28:54 +11001302 if (count < be16_to_cpu(hdr1->count)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 /*
1304 * Figure the total bytes to be added to the destination leaf.
1305 */
1306 /* number entries being moved */
Nathan Scott918ae422006-03-17 17:28:54 +11001307 count = be16_to_cpu(hdr1->count) - count;
1308 space = be16_to_cpu(hdr1->usedbytes) - totallen;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309 space += count * sizeof(xfs_attr_leaf_entry_t);
1310
1311 /*
1312 * leaf2 is the destination, compact it if it looks tight.
1313 */
Nathan Scott918ae422006-03-17 17:28:54 +11001314 max = be16_to_cpu(hdr2->firstused)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 - sizeof(xfs_attr_leaf_hdr_t);
Nathan Scott918ae422006-03-17 17:28:54 +11001316 max -= be16_to_cpu(hdr2->count) * sizeof(xfs_attr_leaf_entry_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 if (space > max) {
1318 xfs_attr_leaf_compact(args->trans, blk2->bp);
1319 }
1320
1321 /*
1322 * Move high entries from leaf1 to low end of leaf2.
1323 */
Nathan Scott918ae422006-03-17 17:28:54 +11001324 xfs_attr_leaf_moveents(leaf1, be16_to_cpu(hdr1->count) - count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325 leaf2, 0, count, state->mp);
1326
1327 xfs_da_log_buf(args->trans, blk1->bp, 0, state->blocksize-1);
1328 xfs_da_log_buf(args->trans, blk2->bp, 0, state->blocksize-1);
Nathan Scott918ae422006-03-17 17:28:54 +11001329 } else if (count > be16_to_cpu(hdr1->count)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330 /*
1331 * I assert that since all callers pass in an empty
1332 * second buffer, this code should never execute.
1333 */
1334
1335 /*
1336 * Figure the total bytes to be added to the destination leaf.
1337 */
1338 /* number entries being moved */
Nathan Scott918ae422006-03-17 17:28:54 +11001339 count -= be16_to_cpu(hdr1->count);
1340 space = totallen - be16_to_cpu(hdr1->usedbytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 space += count * sizeof(xfs_attr_leaf_entry_t);
1342
1343 /*
1344 * leaf1 is the destination, compact it if it looks tight.
1345 */
Nathan Scott918ae422006-03-17 17:28:54 +11001346 max = be16_to_cpu(hdr1->firstused)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 - sizeof(xfs_attr_leaf_hdr_t);
Nathan Scott918ae422006-03-17 17:28:54 +11001348 max -= be16_to_cpu(hdr1->count) * sizeof(xfs_attr_leaf_entry_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349 if (space > max) {
1350 xfs_attr_leaf_compact(args->trans, blk1->bp);
1351 }
1352
1353 /*
1354 * Move low entries from leaf2 to high end of leaf1.
1355 */
1356 xfs_attr_leaf_moveents(leaf2, 0, leaf1,
Nathan Scott918ae422006-03-17 17:28:54 +11001357 be16_to_cpu(hdr1->count), count, state->mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358
1359 xfs_da_log_buf(args->trans, blk1->bp, 0, state->blocksize-1);
1360 xfs_da_log_buf(args->trans, blk2->bp, 0, state->blocksize-1);
1361 }
1362
1363 /*
1364 * Copy out last hashval in each block for B-tree code.
1365 */
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001366 blk1->hashval = be32_to_cpu(
1367 leaf1->entries[be16_to_cpu(leaf1->hdr.count)-1].hashval);
1368 blk2->hashval = be32_to_cpu(
1369 leaf2->entries[be16_to_cpu(leaf2->hdr.count)-1].hashval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370
1371 /*
1372 * Adjust the expected index for insertion.
1373 * NOTE: this code depends on the (current) situation that the
1374 * second block was originally empty.
1375 *
1376 * If the insertion point moved to the 2nd block, we must adjust
1377 * the index. We must also track the entry just following the
1378 * new entry for use in an "atomic rename" operation, that entry
1379 * is always the "old" entry and the "new" entry is what we are
1380 * inserting. The index/blkno fields refer to the "old" entry,
1381 * while the index2/blkno2 fields refer to the "new" entry.
1382 */
Nathan Scott918ae422006-03-17 17:28:54 +11001383 if (blk1->index > be16_to_cpu(leaf1->hdr.count)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 ASSERT(state->inleaf == 0);
Nathan Scott918ae422006-03-17 17:28:54 +11001385 blk2->index = blk1->index - be16_to_cpu(leaf1->hdr.count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 args->index = args->index2 = blk2->index;
1387 args->blkno = args->blkno2 = blk2->blkno;
Nathan Scott918ae422006-03-17 17:28:54 +11001388 } else if (blk1->index == be16_to_cpu(leaf1->hdr.count)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389 if (state->inleaf) {
1390 args->index = blk1->index;
1391 args->blkno = blk1->blkno;
1392 args->index2 = 0;
1393 args->blkno2 = blk2->blkno;
1394 } else {
1395 blk2->index = blk1->index
Nathan Scott918ae422006-03-17 17:28:54 +11001396 - be16_to_cpu(leaf1->hdr.count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397 args->index = args->index2 = blk2->index;
1398 args->blkno = args->blkno2 = blk2->blkno;
1399 }
1400 } else {
1401 ASSERT(state->inleaf == 1);
1402 args->index = args->index2 = blk1->index;
1403 args->blkno = args->blkno2 = blk1->blkno;
1404 }
1405}
1406
1407/*
1408 * Examine entries until we reduce the absolute difference in
1409 * byte usage between the two blocks to a minimum.
1410 * GROT: Is this really necessary? With other than a 512 byte blocksize,
1411 * GROT: there will always be enough room in either block for a new entry.
1412 * GROT: Do a double-split for this case?
1413 */
1414STATIC int
1415xfs_attr_leaf_figure_balance(xfs_da_state_t *state,
1416 xfs_da_state_blk_t *blk1,
1417 xfs_da_state_blk_t *blk2,
1418 int *countarg, int *usedbytesarg)
1419{
1420 xfs_attr_leafblock_t *leaf1, *leaf2;
1421 xfs_attr_leaf_hdr_t *hdr1, *hdr2;
1422 xfs_attr_leaf_entry_t *entry;
1423 int count, max, index, totallen, half;
1424 int lastdelta, foundit, tmp;
1425
1426 /*
1427 * Set up environment.
1428 */
1429 leaf1 = blk1->bp->data;
1430 leaf2 = blk2->bp->data;
1431 hdr1 = &leaf1->hdr;
1432 hdr2 = &leaf2->hdr;
1433 foundit = 0;
1434 totallen = 0;
1435
1436 /*
1437 * Examine entries until we reduce the absolute difference in
1438 * byte usage between the two blocks to a minimum.
1439 */
Nathan Scott918ae422006-03-17 17:28:54 +11001440 max = be16_to_cpu(hdr1->count) + be16_to_cpu(hdr2->count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441 half = (max+1) * sizeof(*entry);
Nathan Scott918ae422006-03-17 17:28:54 +11001442 half += be16_to_cpu(hdr1->usedbytes) +
1443 be16_to_cpu(hdr2->usedbytes) +
1444 xfs_attr_leaf_newentsize(
1445 state->args->namelen,
1446 state->args->valuelen,
1447 state->blocksize, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 half /= 2;
1449 lastdelta = state->blocksize;
1450 entry = &leaf1->entries[0];
1451 for (count = index = 0; count < max; entry++, index++, count++) {
1452
1453#define XFS_ATTR_ABS(A) (((A) < 0) ? -(A) : (A))
1454 /*
1455 * The new entry is in the first block, account for it.
1456 */
1457 if (count == blk1->index) {
1458 tmp = totallen + sizeof(*entry) +
Nathan Scottaa82daa2005-11-02 10:33:33 +11001459 xfs_attr_leaf_newentsize(
1460 state->args->namelen,
1461 state->args->valuelen,
1462 state->blocksize, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 if (XFS_ATTR_ABS(half - tmp) > lastdelta)
1464 break;
1465 lastdelta = XFS_ATTR_ABS(half - tmp);
1466 totallen = tmp;
1467 foundit = 1;
1468 }
1469
1470 /*
1471 * Wrap around into the second block if necessary.
1472 */
Nathan Scott918ae422006-03-17 17:28:54 +11001473 if (count == be16_to_cpu(hdr1->count)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 leaf1 = leaf2;
1475 entry = &leaf1->entries[0];
1476 index = 0;
1477 }
1478
1479 /*
1480 * Figure out if next leaf entry would be too much.
1481 */
1482 tmp = totallen + sizeof(*entry) + xfs_attr_leaf_entsize(leaf1,
1483 index);
1484 if (XFS_ATTR_ABS(half - tmp) > lastdelta)
1485 break;
1486 lastdelta = XFS_ATTR_ABS(half - tmp);
1487 totallen = tmp;
1488#undef XFS_ATTR_ABS
1489 }
1490
1491 /*
1492 * Calculate the number of usedbytes that will end up in lower block.
1493 * If new entry not in lower block, fix up the count.
1494 */
1495 totallen -= count * sizeof(*entry);
1496 if (foundit) {
1497 totallen -= sizeof(*entry) +
Nathan Scottaa82daa2005-11-02 10:33:33 +11001498 xfs_attr_leaf_newentsize(
1499 state->args->namelen,
1500 state->args->valuelen,
1501 state->blocksize, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502 }
1503
1504 *countarg = count;
1505 *usedbytesarg = totallen;
1506 return(foundit);
1507}
1508
1509/*========================================================================
1510 * Routines used for shrinking the Btree.
1511 *========================================================================*/
1512
1513/*
1514 * Check a leaf block and its neighbors to see if the block should be
1515 * collapsed into one or the other neighbor. Always keep the block
1516 * with the smaller block number.
1517 * If the current block is over 50% full, don't try to join it, return 0.
1518 * If the block is empty, fill in the state structure and return 2.
1519 * If it can be collapsed, fill in the state structure and return 1.
1520 * If nothing can be done, return 0.
1521 *
1522 * GROT: allow for INCOMPLETE entries in calculation.
1523 */
1524int
1525xfs_attr_leaf_toosmall(xfs_da_state_t *state, int *action)
1526{
1527 xfs_attr_leafblock_t *leaf;
1528 xfs_da_state_blk_t *blk;
1529 xfs_da_blkinfo_t *info;
1530 int count, bytes, forward, error, retval, i;
1531 xfs_dablk_t blkno;
1532 xfs_dabuf_t *bp;
1533
1534 /*
1535 * Check for the degenerate case of the block being over 50% full.
1536 * If so, it's not worth even looking to see if we might be able
1537 * to coalesce with a sibling.
1538 */
1539 blk = &state->path.blk[ state->path.active-1 ];
1540 info = blk->bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02001541 ASSERT(info->magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542 leaf = (xfs_attr_leafblock_t *)info;
Nathan Scott918ae422006-03-17 17:28:54 +11001543 count = be16_to_cpu(leaf->hdr.count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544 bytes = sizeof(xfs_attr_leaf_hdr_t) +
1545 count * sizeof(xfs_attr_leaf_entry_t) +
Nathan Scott918ae422006-03-17 17:28:54 +11001546 be16_to_cpu(leaf->hdr.usedbytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547 if (bytes > (state->blocksize >> 1)) {
1548 *action = 0; /* blk over 50%, don't try to join */
1549 return(0);
1550 }
1551
1552 /*
1553 * Check for the degenerate case of the block being empty.
1554 * If the block is empty, we'll simply delete it, no need to
Nathan Scottc41564b2006-03-29 08:55:14 +10001555 * coalesce it with a sibling block. We choose (arbitrarily)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556 * to merge with the forward block unless it is NULL.
1557 */
1558 if (count == 0) {
1559 /*
1560 * Make altpath point to the block we want to keep and
1561 * path point to the block we want to drop (this one).
1562 */
Nathan Scott89da0542006-03-17 17:28:40 +11001563 forward = (info->forw != 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564 memcpy(&state->altpath, &state->path, sizeof(state->path));
1565 error = xfs_da_path_shift(state, &state->altpath, forward,
1566 0, &retval);
1567 if (error)
1568 return(error);
1569 if (retval) {
1570 *action = 0;
1571 } else {
1572 *action = 2;
1573 }
1574 return(0);
1575 }
1576
1577 /*
1578 * Examine each sibling block to see if we can coalesce with
1579 * at least 25% free space to spare. We need to figure out
1580 * whether to merge with the forward or the backward block.
1581 * We prefer coalescing with the lower numbered sibling so as
1582 * to shrink an attribute list over time.
1583 */
1584 /* start with smaller blk num */
Nathan Scott89da0542006-03-17 17:28:40 +11001585 forward = (be32_to_cpu(info->forw) < be32_to_cpu(info->back));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586 for (i = 0; i < 2; forward = !forward, i++) {
1587 if (forward)
Nathan Scott89da0542006-03-17 17:28:40 +11001588 blkno = be32_to_cpu(info->forw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589 else
Nathan Scott89da0542006-03-17 17:28:40 +11001590 blkno = be32_to_cpu(info->back);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 if (blkno == 0)
1592 continue;
1593 error = xfs_da_read_buf(state->args->trans, state->args->dp,
1594 blkno, -1, &bp, XFS_ATTR_FORK);
1595 if (error)
1596 return(error);
1597 ASSERT(bp != NULL);
1598
1599 leaf = (xfs_attr_leafblock_t *)info;
Nathan Scott918ae422006-03-17 17:28:54 +11001600 count = be16_to_cpu(leaf->hdr.count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601 bytes = state->blocksize - (state->blocksize>>2);
Nathan Scott918ae422006-03-17 17:28:54 +11001602 bytes -= be16_to_cpu(leaf->hdr.usedbytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603 leaf = bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02001604 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Nathan Scott918ae422006-03-17 17:28:54 +11001605 count += be16_to_cpu(leaf->hdr.count);
1606 bytes -= be16_to_cpu(leaf->hdr.usedbytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607 bytes -= count * sizeof(xfs_attr_leaf_entry_t);
1608 bytes -= sizeof(xfs_attr_leaf_hdr_t);
1609 xfs_da_brelse(state->args->trans, bp);
1610 if (bytes >= 0)
1611 break; /* fits with at least 25% to spare */
1612 }
1613 if (i >= 2) {
1614 *action = 0;
1615 return(0);
1616 }
1617
1618 /*
1619 * Make altpath point to the block we want to keep (the lower
1620 * numbered block) and path point to the block we want to drop.
1621 */
1622 memcpy(&state->altpath, &state->path, sizeof(state->path));
1623 if (blkno < blk->blkno) {
1624 error = xfs_da_path_shift(state, &state->altpath, forward,
1625 0, &retval);
1626 } else {
1627 error = xfs_da_path_shift(state, &state->path, forward,
1628 0, &retval);
1629 }
1630 if (error)
1631 return(error);
1632 if (retval) {
1633 *action = 0;
1634 } else {
1635 *action = 1;
1636 }
1637 return(0);
1638}
1639
1640/*
1641 * Remove a name from the leaf attribute list structure.
1642 *
1643 * Return 1 if leaf is less than 37% full, 0 if >= 37% full.
1644 * If two leaves are 37% full, when combined they will leave 25% free.
1645 */
1646int
1647xfs_attr_leaf_remove(xfs_dabuf_t *bp, xfs_da_args_t *args)
1648{
1649 xfs_attr_leafblock_t *leaf;
1650 xfs_attr_leaf_hdr_t *hdr;
1651 xfs_attr_leaf_map_t *map;
1652 xfs_attr_leaf_entry_t *entry;
1653 int before, after, smallest, entsize;
1654 int tablesize, tmp, i;
1655 xfs_mount_t *mp;
1656
1657 leaf = bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02001658 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659 hdr = &leaf->hdr;
1660 mp = args->trans->t_mountp;
Nathan Scott918ae422006-03-17 17:28:54 +11001661 ASSERT((be16_to_cpu(hdr->count) > 0)
1662 && (be16_to_cpu(hdr->count) < (XFS_LBSIZE(mp)/8)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663 ASSERT((args->index >= 0)
Nathan Scott918ae422006-03-17 17:28:54 +11001664 && (args->index < be16_to_cpu(hdr->count)));
1665 ASSERT(be16_to_cpu(hdr->firstused) >=
1666 ((be16_to_cpu(hdr->count) * sizeof(*entry)) + sizeof(*hdr)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667 entry = &leaf->entries[args->index];
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001668 ASSERT(be16_to_cpu(entry->nameidx) >= be16_to_cpu(hdr->firstused));
1669 ASSERT(be16_to_cpu(entry->nameidx) < XFS_LBSIZE(mp));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670
1671 /*
1672 * Scan through free region table:
1673 * check for adjacency of free'd entry with an existing one,
1674 * find smallest free region in case we need to replace it,
1675 * adjust any map that borders the entry table,
1676 */
Nathan Scott918ae422006-03-17 17:28:54 +11001677 tablesize = be16_to_cpu(hdr->count) * sizeof(xfs_attr_leaf_entry_t)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678 + sizeof(xfs_attr_leaf_hdr_t);
1679 map = &hdr->freemap[0];
Nathan Scott918ae422006-03-17 17:28:54 +11001680 tmp = be16_to_cpu(map->size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 before = after = -1;
1682 smallest = XFS_ATTR_LEAF_MAPSIZE - 1;
1683 entsize = xfs_attr_leaf_entsize(leaf, args->index);
1684 for (i = 0; i < XFS_ATTR_LEAF_MAPSIZE; map++, i++) {
Nathan Scott918ae422006-03-17 17:28:54 +11001685 ASSERT(be16_to_cpu(map->base) < XFS_LBSIZE(mp));
1686 ASSERT(be16_to_cpu(map->size) < XFS_LBSIZE(mp));
1687 if (be16_to_cpu(map->base) == tablesize) {
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001688 be16_add_cpu(&map->base,
Nathan Scott918ae422006-03-17 17:28:54 +11001689 -((int)sizeof(xfs_attr_leaf_entry_t)));
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001690 be16_add_cpu(&map->size, sizeof(xfs_attr_leaf_entry_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691 }
1692
Nathan Scott918ae422006-03-17 17:28:54 +11001693 if ((be16_to_cpu(map->base) + be16_to_cpu(map->size))
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001694 == be16_to_cpu(entry->nameidx)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 before = i;
Nathan Scott918ae422006-03-17 17:28:54 +11001696 } else if (be16_to_cpu(map->base)
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001697 == (be16_to_cpu(entry->nameidx) + entsize)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698 after = i;
Nathan Scott918ae422006-03-17 17:28:54 +11001699 } else if (be16_to_cpu(map->size) < tmp) {
1700 tmp = be16_to_cpu(map->size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701 smallest = i;
1702 }
1703 }
1704
1705 /*
1706 * Coalesce adjacent freemap regions,
1707 * or replace the smallest region.
1708 */
1709 if ((before >= 0) || (after >= 0)) {
1710 if ((before >= 0) && (after >= 0)) {
1711 map = &hdr->freemap[before];
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001712 be16_add_cpu(&map->size, entsize);
1713 be16_add_cpu(&map->size,
Nathan Scott918ae422006-03-17 17:28:54 +11001714 be16_to_cpu(hdr->freemap[after].size));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715 hdr->freemap[after].base = 0;
1716 hdr->freemap[after].size = 0;
1717 } else if (before >= 0) {
1718 map = &hdr->freemap[before];
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001719 be16_add_cpu(&map->size, entsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720 } else {
1721 map = &hdr->freemap[after];
1722 /* both on-disk, don't endian flip twice */
1723 map->base = entry->nameidx;
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001724 be16_add_cpu(&map->size, entsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725 }
1726 } else {
1727 /*
1728 * Replace smallest region (if it is smaller than free'd entry)
1729 */
1730 map = &hdr->freemap[smallest];
Nathan Scott918ae422006-03-17 17:28:54 +11001731 if (be16_to_cpu(map->size) < entsize) {
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001732 map->base = cpu_to_be16(be16_to_cpu(entry->nameidx));
Nathan Scott918ae422006-03-17 17:28:54 +11001733 map->size = cpu_to_be16(entsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734 }
1735 }
1736
1737 /*
1738 * Did we remove the first entry?
1739 */
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001740 if (be16_to_cpu(entry->nameidx) == be16_to_cpu(hdr->firstused))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741 smallest = 1;
1742 else
1743 smallest = 0;
1744
1745 /*
1746 * Compress the remaining entries and zero out the removed stuff.
1747 */
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06001748 memset(xfs_attr_leaf_name(leaf, args->index), 0, entsize);
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001749 be16_add_cpu(&hdr->usedbytes, -entsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750 xfs_da_log_buf(args->trans, bp,
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06001751 XFS_DA_LOGRANGE(leaf, xfs_attr_leaf_name(leaf, args->index),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752 entsize));
1753
Nathan Scott918ae422006-03-17 17:28:54 +11001754 tmp = (be16_to_cpu(hdr->count) - args->index)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001755 * sizeof(xfs_attr_leaf_entry_t);
1756 memmove((char *)entry, (char *)(entry+1), tmp);
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001757 be16_add_cpu(&hdr->count, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758 xfs_da_log_buf(args->trans, bp,
1759 XFS_DA_LOGRANGE(leaf, entry, tmp + sizeof(*entry)));
Nathan Scott918ae422006-03-17 17:28:54 +11001760 entry = &leaf->entries[be16_to_cpu(hdr->count)];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761 memset((char *)entry, 0, sizeof(xfs_attr_leaf_entry_t));
1762
1763 /*
1764 * If we removed the first entry, re-find the first used byte
1765 * in the name area. Note that if the entry was the "firstused",
1766 * then we don't have a "hole" in our block resulting from
1767 * removing the name.
1768 */
1769 if (smallest) {
1770 tmp = XFS_LBSIZE(mp);
1771 entry = &leaf->entries[0];
Nathan Scott918ae422006-03-17 17:28:54 +11001772 for (i = be16_to_cpu(hdr->count)-1; i >= 0; entry++, i--) {
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001773 ASSERT(be16_to_cpu(entry->nameidx) >=
1774 be16_to_cpu(hdr->firstused));
1775 ASSERT(be16_to_cpu(entry->nameidx) < XFS_LBSIZE(mp));
1776
1777 if (be16_to_cpu(entry->nameidx) < tmp)
1778 tmp = be16_to_cpu(entry->nameidx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779 }
Nathan Scott918ae422006-03-17 17:28:54 +11001780 hdr->firstused = cpu_to_be16(tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781 if (!hdr->firstused) {
Nathan Scott918ae422006-03-17 17:28:54 +11001782 hdr->firstused = cpu_to_be16(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783 tmp - XFS_ATTR_LEAF_NAME_ALIGN);
1784 }
1785 } else {
1786 hdr->holes = 1; /* mark as needing compaction */
1787 }
1788 xfs_da_log_buf(args->trans, bp,
1789 XFS_DA_LOGRANGE(leaf, hdr, sizeof(*hdr)));
1790
1791 /*
1792 * Check if leaf is less than 50% full, caller may want to
1793 * "join" the leaf with a sibling if so.
1794 */
1795 tmp = sizeof(xfs_attr_leaf_hdr_t);
Nathan Scott918ae422006-03-17 17:28:54 +11001796 tmp += be16_to_cpu(leaf->hdr.count) * sizeof(xfs_attr_leaf_entry_t);
1797 tmp += be16_to_cpu(leaf->hdr.usedbytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798 return(tmp < mp->m_attr_magicpct); /* leaf is < 37% full */
1799}
1800
1801/*
1802 * Move all the attribute list entries from drop_leaf into save_leaf.
1803 */
1804void
1805xfs_attr_leaf_unbalance(xfs_da_state_t *state, xfs_da_state_blk_t *drop_blk,
1806 xfs_da_state_blk_t *save_blk)
1807{
1808 xfs_attr_leafblock_t *drop_leaf, *save_leaf, *tmp_leaf;
1809 xfs_attr_leaf_hdr_t *drop_hdr, *save_hdr, *tmp_hdr;
1810 xfs_mount_t *mp;
1811 char *tmpbuffer;
1812
1813 /*
1814 * Set up environment.
1815 */
1816 mp = state->mp;
1817 ASSERT(drop_blk->magic == XFS_ATTR_LEAF_MAGIC);
1818 ASSERT(save_blk->magic == XFS_ATTR_LEAF_MAGIC);
1819 drop_leaf = drop_blk->bp->data;
1820 save_leaf = save_blk->bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02001821 ASSERT(drop_leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1822 ASSERT(save_leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823 drop_hdr = &drop_leaf->hdr;
1824 save_hdr = &save_leaf->hdr;
1825
1826 /*
1827 * Save last hashval from dying block for later Btree fixup.
1828 */
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001829 drop_blk->hashval = be32_to_cpu(
1830 drop_leaf->entries[be16_to_cpu(drop_leaf->hdr.count)-1].hashval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001831
1832 /*
1833 * Check if we need a temp buffer, or can we do it in place.
1834 * Note that we don't check "leaf" for holes because we will
1835 * always be dropping it, toosmall() decided that for us already.
1836 */
1837 if (save_hdr->holes == 0) {
1838 /*
1839 * dest leaf has no holes, so we add there. May need
1840 * to make some room in the entry array.
1841 */
1842 if (xfs_attr_leaf_order(save_blk->bp, drop_blk->bp)) {
1843 xfs_attr_leaf_moveents(drop_leaf, 0, save_leaf, 0,
Nathan Scott918ae422006-03-17 17:28:54 +11001844 be16_to_cpu(drop_hdr->count), mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001845 } else {
1846 xfs_attr_leaf_moveents(drop_leaf, 0, save_leaf,
Nathan Scott918ae422006-03-17 17:28:54 +11001847 be16_to_cpu(save_hdr->count),
1848 be16_to_cpu(drop_hdr->count), mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849 }
1850 } else {
1851 /*
1852 * Destination has holes, so we make a temporary copy
1853 * of the leaf and add them both to that.
1854 */
1855 tmpbuffer = kmem_alloc(state->blocksize, KM_SLEEP);
1856 ASSERT(tmpbuffer != NULL);
1857 memset(tmpbuffer, 0, state->blocksize);
1858 tmp_leaf = (xfs_attr_leafblock_t *)tmpbuffer;
1859 tmp_hdr = &tmp_leaf->hdr;
1860 tmp_hdr->info = save_hdr->info; /* struct copy */
1861 tmp_hdr->count = 0;
Nathan Scott918ae422006-03-17 17:28:54 +11001862 tmp_hdr->firstused = cpu_to_be16(state->blocksize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001863 if (!tmp_hdr->firstused) {
Nathan Scott918ae422006-03-17 17:28:54 +11001864 tmp_hdr->firstused = cpu_to_be16(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865 state->blocksize - XFS_ATTR_LEAF_NAME_ALIGN);
1866 }
1867 tmp_hdr->usedbytes = 0;
1868 if (xfs_attr_leaf_order(save_blk->bp, drop_blk->bp)) {
1869 xfs_attr_leaf_moveents(drop_leaf, 0, tmp_leaf, 0,
Nathan Scott918ae422006-03-17 17:28:54 +11001870 be16_to_cpu(drop_hdr->count), mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871 xfs_attr_leaf_moveents(save_leaf, 0, tmp_leaf,
Nathan Scott918ae422006-03-17 17:28:54 +11001872 be16_to_cpu(tmp_leaf->hdr.count),
1873 be16_to_cpu(save_hdr->count), mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874 } else {
1875 xfs_attr_leaf_moveents(save_leaf, 0, tmp_leaf, 0,
Nathan Scott918ae422006-03-17 17:28:54 +11001876 be16_to_cpu(save_hdr->count), mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877 xfs_attr_leaf_moveents(drop_leaf, 0, tmp_leaf,
Nathan Scott918ae422006-03-17 17:28:54 +11001878 be16_to_cpu(tmp_leaf->hdr.count),
1879 be16_to_cpu(drop_hdr->count), mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880 }
1881 memcpy((char *)save_leaf, (char *)tmp_leaf, state->blocksize);
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10001882 kmem_free(tmpbuffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883 }
1884
1885 xfs_da_log_buf(state->args->trans, save_blk->bp, 0,
1886 state->blocksize - 1);
1887
1888 /*
1889 * Copy out last hashval in each block for B-tree code.
1890 */
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001891 save_blk->hashval = be32_to_cpu(
1892 save_leaf->entries[be16_to_cpu(save_leaf->hdr.count)-1].hashval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893}
1894
1895/*========================================================================
1896 * Routines used for finding things in the Btree.
1897 *========================================================================*/
1898
1899/*
1900 * Look up a name in a leaf attribute list structure.
1901 * This is the internal routine, it uses the caller's buffer.
1902 *
1903 * Note that duplicate keys are allowed, but only check within the
1904 * current leaf node. The Btree code must check in adjacent leaf nodes.
1905 *
1906 * Return in args->index the index into the entry[] array of either
1907 * the found entry, or where the entry should have been (insert before
1908 * that entry).
1909 *
1910 * Don't change the args->value unless we find the attribute.
1911 */
1912int
1913xfs_attr_leaf_lookup_int(xfs_dabuf_t *bp, xfs_da_args_t *args)
1914{
1915 xfs_attr_leafblock_t *leaf;
1916 xfs_attr_leaf_entry_t *entry;
1917 xfs_attr_leaf_name_local_t *name_loc;
1918 xfs_attr_leaf_name_remote_t *name_rmt;
1919 int probe, span;
1920 xfs_dahash_t hashval;
1921
1922 leaf = bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02001923 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Nathan Scott918ae422006-03-17 17:28:54 +11001924 ASSERT(be16_to_cpu(leaf->hdr.count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925 < (XFS_LBSIZE(args->dp->i_mount)/8));
1926
1927 /*
1928 * Binary search. (note: small blocks will skip this loop)
1929 */
1930 hashval = args->hashval;
Nathan Scott918ae422006-03-17 17:28:54 +11001931 probe = span = be16_to_cpu(leaf->hdr.count) / 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001932 for (entry = &leaf->entries[probe]; span > 4;
1933 entry = &leaf->entries[probe]) {
1934 span /= 2;
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001935 if (be32_to_cpu(entry->hashval) < hashval)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001936 probe += span;
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001937 else if (be32_to_cpu(entry->hashval) > hashval)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938 probe -= span;
1939 else
1940 break;
1941 }
Tim Shimmin726801b2006-09-28 11:01:37 +10001942 ASSERT((probe >= 0) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943 (!leaf->hdr.count
Nathan Scott918ae422006-03-17 17:28:54 +11001944 || (probe < be16_to_cpu(leaf->hdr.count))));
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001945 ASSERT((span <= 4) || (be32_to_cpu(entry->hashval) == hashval));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946
1947 /*
1948 * Since we may have duplicate hashval's, find the first matching
1949 * hashval in the leaf.
1950 */
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001951 while ((probe > 0) && (be32_to_cpu(entry->hashval) >= hashval)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001952 entry--;
1953 probe--;
1954 }
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001955 while ((probe < be16_to_cpu(leaf->hdr.count)) &&
1956 (be32_to_cpu(entry->hashval) < hashval)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957 entry++;
1958 probe++;
1959 }
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001960 if ((probe == be16_to_cpu(leaf->hdr.count)) ||
1961 (be32_to_cpu(entry->hashval) != hashval)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001962 args->index = probe;
1963 return(XFS_ERROR(ENOATTR));
1964 }
1965
1966 /*
1967 * Duplicate keys may be present, so search all of them for a match.
1968 */
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001969 for ( ; (probe < be16_to_cpu(leaf->hdr.count)) &&
1970 (be32_to_cpu(entry->hashval) == hashval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001971 entry++, probe++) {
1972/*
1973 * GROT: Add code to remove incomplete entries.
1974 */
1975 /*
1976 * If we are looking for INCOMPLETE entries, show only those.
1977 * If we are looking for complete entries, show only those.
1978 */
1979 if ((args->flags & XFS_ATTR_INCOMPLETE) !=
1980 (entry->flags & XFS_ATTR_INCOMPLETE)) {
1981 continue;
1982 }
1983 if (entry->flags & XFS_ATTR_LOCAL) {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06001984 name_loc = xfs_attr_leaf_name_local(leaf, probe);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001985 if (name_loc->namelen != args->namelen)
1986 continue;
Tim Shimmin726801b2006-09-28 11:01:37 +10001987 if (memcmp(args->name, (char *)name_loc->nameval, args->namelen) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988 continue;
Tim Shimmin726801b2006-09-28 11:01:37 +10001989 if (!xfs_attr_namesp_match(args->flags, entry->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001990 continue;
1991 args->index = probe;
1992 return(XFS_ERROR(EEXIST));
1993 } else {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06001994 name_rmt = xfs_attr_leaf_name_remote(leaf, probe);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995 if (name_rmt->namelen != args->namelen)
1996 continue;
1997 if (memcmp(args->name, (char *)name_rmt->name,
1998 args->namelen) != 0)
1999 continue;
Tim Shimmin726801b2006-09-28 11:01:37 +10002000 if (!xfs_attr_namesp_match(args->flags, entry->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002001 continue;
2002 args->index = probe;
Nathan Scottc0f054e2006-03-17 17:29:18 +11002003 args->rmtblkno = be32_to_cpu(name_rmt->valueblk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004 args->rmtblkcnt = XFS_B_TO_FSB(args->dp->i_mount,
Nathan Scottc0f054e2006-03-17 17:29:18 +11002005 be32_to_cpu(name_rmt->valuelen));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006 return(XFS_ERROR(EEXIST));
2007 }
2008 }
2009 args->index = probe;
2010 return(XFS_ERROR(ENOATTR));
2011}
2012
2013/*
2014 * Get the value associated with an attribute name from a leaf attribute
2015 * list structure.
2016 */
2017int
2018xfs_attr_leaf_getvalue(xfs_dabuf_t *bp, xfs_da_args_t *args)
2019{
2020 int valuelen;
2021 xfs_attr_leafblock_t *leaf;
2022 xfs_attr_leaf_entry_t *entry;
2023 xfs_attr_leaf_name_local_t *name_loc;
2024 xfs_attr_leaf_name_remote_t *name_rmt;
2025
2026 leaf = bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002027 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Nathan Scott918ae422006-03-17 17:28:54 +11002028 ASSERT(be16_to_cpu(leaf->hdr.count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002029 < (XFS_LBSIZE(args->dp->i_mount)/8));
Nathan Scott918ae422006-03-17 17:28:54 +11002030 ASSERT(args->index < be16_to_cpu(leaf->hdr.count));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002031
2032 entry = &leaf->entries[args->index];
2033 if (entry->flags & XFS_ATTR_LOCAL) {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002034 name_loc = xfs_attr_leaf_name_local(leaf, args->index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035 ASSERT(name_loc->namelen == args->namelen);
2036 ASSERT(memcmp(args->name, name_loc->nameval, args->namelen) == 0);
Nathan Scott053b5752006-03-17 17:29:09 +11002037 valuelen = be16_to_cpu(name_loc->valuelen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038 if (args->flags & ATTR_KERNOVAL) {
2039 args->valuelen = valuelen;
2040 return(0);
2041 }
2042 if (args->valuelen < valuelen) {
2043 args->valuelen = valuelen;
2044 return(XFS_ERROR(ERANGE));
2045 }
2046 args->valuelen = valuelen;
2047 memcpy(args->value, &name_loc->nameval[args->namelen], valuelen);
2048 } else {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002049 name_rmt = xfs_attr_leaf_name_remote(leaf, args->index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002050 ASSERT(name_rmt->namelen == args->namelen);
2051 ASSERT(memcmp(args->name, name_rmt->name, args->namelen) == 0);
Nathan Scottc0f054e2006-03-17 17:29:18 +11002052 valuelen = be32_to_cpu(name_rmt->valuelen);
2053 args->rmtblkno = be32_to_cpu(name_rmt->valueblk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002054 args->rmtblkcnt = XFS_B_TO_FSB(args->dp->i_mount, valuelen);
2055 if (args->flags & ATTR_KERNOVAL) {
2056 args->valuelen = valuelen;
2057 return(0);
2058 }
2059 if (args->valuelen < valuelen) {
2060 args->valuelen = valuelen;
2061 return(XFS_ERROR(ERANGE));
2062 }
2063 args->valuelen = valuelen;
2064 }
2065 return(0);
2066}
2067
2068/*========================================================================
2069 * Utility routines.
2070 *========================================================================*/
2071
2072/*
2073 * Move the indicated entries from one leaf to another.
2074 * NOTE: this routine modifies both source and destination leaves.
2075 */
2076/*ARGSUSED*/
2077STATIC void
2078xfs_attr_leaf_moveents(xfs_attr_leafblock_t *leaf_s, int start_s,
2079 xfs_attr_leafblock_t *leaf_d, int start_d,
2080 int count, xfs_mount_t *mp)
2081{
2082 xfs_attr_leaf_hdr_t *hdr_s, *hdr_d;
2083 xfs_attr_leaf_entry_t *entry_s, *entry_d;
2084 int desti, tmp, i;
2085
2086 /*
2087 * Check for nothing to do.
2088 */
2089 if (count == 0)
2090 return;
2091
2092 /*
2093 * Set up environment.
2094 */
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002095 ASSERT(leaf_s->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
2096 ASSERT(leaf_d->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097 hdr_s = &leaf_s->hdr;
2098 hdr_d = &leaf_d->hdr;
Nathan Scott918ae422006-03-17 17:28:54 +11002099 ASSERT((be16_to_cpu(hdr_s->count) > 0) &&
2100 (be16_to_cpu(hdr_s->count) < (XFS_LBSIZE(mp)/8)));
2101 ASSERT(be16_to_cpu(hdr_s->firstused) >=
2102 ((be16_to_cpu(hdr_s->count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103 * sizeof(*entry_s))+sizeof(*hdr_s)));
Nathan Scott918ae422006-03-17 17:28:54 +11002104 ASSERT(be16_to_cpu(hdr_d->count) < (XFS_LBSIZE(mp)/8));
2105 ASSERT(be16_to_cpu(hdr_d->firstused) >=
2106 ((be16_to_cpu(hdr_d->count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107 * sizeof(*entry_d))+sizeof(*hdr_d)));
2108
Nathan Scott918ae422006-03-17 17:28:54 +11002109 ASSERT(start_s < be16_to_cpu(hdr_s->count));
2110 ASSERT(start_d <= be16_to_cpu(hdr_d->count));
2111 ASSERT(count <= be16_to_cpu(hdr_s->count));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002112
2113 /*
2114 * Move the entries in the destination leaf up to make a hole?
2115 */
Nathan Scott918ae422006-03-17 17:28:54 +11002116 if (start_d < be16_to_cpu(hdr_d->count)) {
2117 tmp = be16_to_cpu(hdr_d->count) - start_d;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002118 tmp *= sizeof(xfs_attr_leaf_entry_t);
2119 entry_s = &leaf_d->entries[start_d];
2120 entry_d = &leaf_d->entries[start_d + count];
2121 memmove((char *)entry_d, (char *)entry_s, tmp);
2122 }
2123
2124 /*
2125 * Copy all entry's in the same (sorted) order,
2126 * but allocate attribute info packed and in sequence.
2127 */
2128 entry_s = &leaf_s->entries[start_s];
2129 entry_d = &leaf_d->entries[start_d];
2130 desti = start_d;
2131 for (i = 0; i < count; entry_s++, entry_d++, desti++, i++) {
Nathan Scott6b19f2d2006-03-17 17:29:02 +11002132 ASSERT(be16_to_cpu(entry_s->nameidx)
Nathan Scott918ae422006-03-17 17:28:54 +11002133 >= be16_to_cpu(hdr_s->firstused));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134 tmp = xfs_attr_leaf_entsize(leaf_s, start_s + i);
2135#ifdef GROT
2136 /*
2137 * Code to drop INCOMPLETE entries. Difficult to use as we
2138 * may also need to change the insertion index. Code turned
2139 * off for 6.2, should be revisited later.
2140 */
2141 if (entry_s->flags & XFS_ATTR_INCOMPLETE) { /* skip partials? */
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002142 memset(xfs_attr_leaf_name(leaf_s, start_s + i), 0, tmp);
Marcin Slusarz413d57c2008-02-13 15:03:29 -08002143 be16_add_cpu(&hdr_s->usedbytes, -tmp);
2144 be16_add_cpu(&hdr_s->count, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002145 entry_d--; /* to compensate for ++ in loop hdr */
2146 desti--;
2147 if ((start_s + i) < offset)
2148 result++; /* insertion index adjustment */
2149 } else {
2150#endif /* GROT */
Marcin Slusarz413d57c2008-02-13 15:03:29 -08002151 be16_add_cpu(&hdr_d->firstused, -tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002152 /* both on-disk, don't endian flip twice */
2153 entry_d->hashval = entry_s->hashval;
2154 /* both on-disk, don't endian flip twice */
2155 entry_d->nameidx = hdr_d->firstused;
2156 entry_d->flags = entry_s->flags;
Nathan Scott6b19f2d2006-03-17 17:29:02 +11002157 ASSERT(be16_to_cpu(entry_d->nameidx) + tmp
Linus Torvalds1da177e2005-04-16 15:20:36 -07002158 <= XFS_LBSIZE(mp));
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002159 memmove(xfs_attr_leaf_name(leaf_d, desti),
2160 xfs_attr_leaf_name(leaf_s, start_s + i), tmp);
Nathan Scott6b19f2d2006-03-17 17:29:02 +11002161 ASSERT(be16_to_cpu(entry_s->nameidx) + tmp
Linus Torvalds1da177e2005-04-16 15:20:36 -07002162 <= XFS_LBSIZE(mp));
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002163 memset(xfs_attr_leaf_name(leaf_s, start_s + i), 0, tmp);
Marcin Slusarz413d57c2008-02-13 15:03:29 -08002164 be16_add_cpu(&hdr_s->usedbytes, -tmp);
2165 be16_add_cpu(&hdr_d->usedbytes, tmp);
2166 be16_add_cpu(&hdr_s->count, -1);
2167 be16_add_cpu(&hdr_d->count, 1);
Nathan Scott918ae422006-03-17 17:28:54 +11002168 tmp = be16_to_cpu(hdr_d->count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002169 * sizeof(xfs_attr_leaf_entry_t)
2170 + sizeof(xfs_attr_leaf_hdr_t);
Nathan Scott918ae422006-03-17 17:28:54 +11002171 ASSERT(be16_to_cpu(hdr_d->firstused) >= tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002172#ifdef GROT
2173 }
2174#endif /* GROT */
2175 }
2176
2177 /*
2178 * Zero out the entries we just copied.
2179 */
Nathan Scott918ae422006-03-17 17:28:54 +11002180 if (start_s == be16_to_cpu(hdr_s->count)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002181 tmp = count * sizeof(xfs_attr_leaf_entry_t);
2182 entry_s = &leaf_s->entries[start_s];
2183 ASSERT(((char *)entry_s + tmp) <=
2184 ((char *)leaf_s + XFS_LBSIZE(mp)));
2185 memset((char *)entry_s, 0, tmp);
2186 } else {
2187 /*
2188 * Move the remaining entries down to fill the hole,
2189 * then zero the entries at the top.
2190 */
Nathan Scott918ae422006-03-17 17:28:54 +11002191 tmp = be16_to_cpu(hdr_s->count) - count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002192 tmp *= sizeof(xfs_attr_leaf_entry_t);
2193 entry_s = &leaf_s->entries[start_s + count];
2194 entry_d = &leaf_s->entries[start_s];
2195 memmove((char *)entry_d, (char *)entry_s, tmp);
2196
2197 tmp = count * sizeof(xfs_attr_leaf_entry_t);
Nathan Scott918ae422006-03-17 17:28:54 +11002198 entry_s = &leaf_s->entries[be16_to_cpu(hdr_s->count)];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002199 ASSERT(((char *)entry_s + tmp) <=
2200 ((char *)leaf_s + XFS_LBSIZE(mp)));
2201 memset((char *)entry_s, 0, tmp);
2202 }
2203
2204 /*
2205 * Fill in the freemap information
2206 */
Nathan Scott918ae422006-03-17 17:28:54 +11002207 hdr_d->freemap[0].base = cpu_to_be16(sizeof(xfs_attr_leaf_hdr_t));
Marcin Slusarz413d57c2008-02-13 15:03:29 -08002208 be16_add_cpu(&hdr_d->freemap[0].base, be16_to_cpu(hdr_d->count) *
Nathan Scott918ae422006-03-17 17:28:54 +11002209 sizeof(xfs_attr_leaf_entry_t));
2210 hdr_d->freemap[0].size = cpu_to_be16(be16_to_cpu(hdr_d->firstused)
2211 - be16_to_cpu(hdr_d->freemap[0].base));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002212 hdr_d->freemap[1].base = 0;
2213 hdr_d->freemap[2].base = 0;
2214 hdr_d->freemap[1].size = 0;
2215 hdr_d->freemap[2].size = 0;
2216 hdr_s->holes = 1; /* leaf may not be compact */
2217}
2218
2219/*
2220 * Compare two leaf blocks "order".
2221 * Return 0 unless leaf2 should go before leaf1.
2222 */
2223int
2224xfs_attr_leaf_order(xfs_dabuf_t *leaf1_bp, xfs_dabuf_t *leaf2_bp)
2225{
2226 xfs_attr_leafblock_t *leaf1, *leaf2;
2227
2228 leaf1 = leaf1_bp->data;
2229 leaf2 = leaf2_bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002230 ASSERT((leaf1->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC)) &&
2231 (leaf2->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC)));
Nathan Scott918ae422006-03-17 17:28:54 +11002232 if ((be16_to_cpu(leaf1->hdr.count) > 0) &&
2233 (be16_to_cpu(leaf2->hdr.count) > 0) &&
Nathan Scott6b19f2d2006-03-17 17:29:02 +11002234 ((be32_to_cpu(leaf2->entries[0].hashval) <
2235 be32_to_cpu(leaf1->entries[0].hashval)) ||
2236 (be32_to_cpu(leaf2->entries[
2237 be16_to_cpu(leaf2->hdr.count)-1].hashval) <
2238 be32_to_cpu(leaf1->entries[
2239 be16_to_cpu(leaf1->hdr.count)-1].hashval)))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002240 return(1);
2241 }
2242 return(0);
2243}
2244
2245/*
2246 * Pick up the last hashvalue from a leaf block.
2247 */
2248xfs_dahash_t
2249xfs_attr_leaf_lasthash(xfs_dabuf_t *bp, int *count)
2250{
2251 xfs_attr_leafblock_t *leaf;
2252
2253 leaf = bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002254 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002255 if (count)
Nathan Scott918ae422006-03-17 17:28:54 +11002256 *count = be16_to_cpu(leaf->hdr.count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002257 if (!leaf->hdr.count)
2258 return(0);
Nathan Scott6b19f2d2006-03-17 17:29:02 +11002259 return be32_to_cpu(leaf->entries[be16_to_cpu(leaf->hdr.count)-1].hashval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260}
2261
2262/*
2263 * Calculate the number of bytes used to store the indicated attribute
2264 * (whether local or remote only calculate bytes in this block).
2265 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002266STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002267xfs_attr_leaf_entsize(xfs_attr_leafblock_t *leaf, int index)
2268{
2269 xfs_attr_leaf_name_local_t *name_loc;
2270 xfs_attr_leaf_name_remote_t *name_rmt;
2271 int size;
2272
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002273 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002274 if (leaf->entries[index].flags & XFS_ATTR_LOCAL) {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002275 name_loc = xfs_attr_leaf_name_local(leaf, index);
2276 size = xfs_attr_leaf_entsize_local(name_loc->namelen,
Nathan Scott053b5752006-03-17 17:29:09 +11002277 be16_to_cpu(name_loc->valuelen));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002278 } else {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002279 name_rmt = xfs_attr_leaf_name_remote(leaf, index);
2280 size = xfs_attr_leaf_entsize_remote(name_rmt->namelen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002281 }
2282 return(size);
2283}
2284
2285/*
2286 * Calculate the number of bytes that would be required to store the new
2287 * attribute (whether local or remote only calculate bytes in this block).
2288 * This routine decides as a side effect whether the attribute will be
2289 * a "local" or a "remote" attribute.
2290 */
2291int
Nathan Scottaa82daa2005-11-02 10:33:33 +11002292xfs_attr_leaf_newentsize(int namelen, int valuelen, int blocksize, int *local)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002293{
2294 int size;
2295
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002296 size = xfs_attr_leaf_entsize_local(namelen, valuelen);
2297 if (size < xfs_attr_leaf_entsize_local_max(blocksize)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002298 if (local) {
2299 *local = 1;
2300 }
2301 } else {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002302 size = xfs_attr_leaf_entsize_remote(namelen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002303 if (local) {
2304 *local = 0;
2305 }
2306 }
2307 return(size);
2308}
2309
2310/*
2311 * Copy out attribute list entries for attr_list(), for leaf attribute lists.
2312 */
2313int
2314xfs_attr_leaf_list_int(xfs_dabuf_t *bp, xfs_attr_list_context_t *context)
2315{
2316 attrlist_cursor_kern_t *cursor;
2317 xfs_attr_leafblock_t *leaf;
2318 xfs_attr_leaf_entry_t *entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002319 int retval, i;
2320
2321 ASSERT(bp != NULL);
2322 leaf = bp->data;
2323 cursor = context->cursor;
2324 cursor->initted = 1;
2325
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00002326 trace_xfs_attr_list_leaf(context);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002327
2328 /*
2329 * Re-find our place in the leaf block if this is a new syscall.
2330 */
2331 if (context->resynch) {
2332 entry = &leaf->entries[0];
Nathan Scott918ae422006-03-17 17:28:54 +11002333 for (i = 0; i < be16_to_cpu(leaf->hdr.count); entry++, i++) {
Nathan Scott6b19f2d2006-03-17 17:29:02 +11002334 if (be32_to_cpu(entry->hashval) == cursor->hashval) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002335 if (cursor->offset == context->dupcnt) {
2336 context->dupcnt = 0;
2337 break;
2338 }
2339 context->dupcnt++;
Nathan Scott6b19f2d2006-03-17 17:29:02 +11002340 } else if (be32_to_cpu(entry->hashval) >
2341 cursor->hashval) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002342 context->dupcnt = 0;
2343 break;
2344 }
2345 }
Nathan Scott918ae422006-03-17 17:28:54 +11002346 if (i == be16_to_cpu(leaf->hdr.count)) {
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00002347 trace_xfs_attr_list_notfound(context);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002348 return(0);
2349 }
2350 } else {
2351 entry = &leaf->entries[0];
2352 i = 0;
2353 }
2354 context->resynch = 0;
2355
2356 /*
2357 * We have found our place, start copying out the new attributes.
2358 */
2359 retval = 0;
Tim Shimmin726801b2006-09-28 11:01:37 +10002360 for ( ; (i < be16_to_cpu(leaf->hdr.count)); entry++, i++) {
Nathan Scott6b19f2d2006-03-17 17:29:02 +11002361 if (be32_to_cpu(entry->hashval) != cursor->hashval) {
2362 cursor->hashval = be32_to_cpu(entry->hashval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002363 cursor->offset = 0;
2364 }
2365
2366 if (entry->flags & XFS_ATTR_INCOMPLETE)
2367 continue; /* skip incomplete entries */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002368
2369 if (entry->flags & XFS_ATTR_LOCAL) {
Tim Shimmin726801b2006-09-28 11:01:37 +10002370 xfs_attr_leaf_name_local_t *name_loc =
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002371 xfs_attr_leaf_name_local(leaf, i);
Tim Shimmin726801b2006-09-28 11:01:37 +10002372
2373 retval = context->put_listent(context,
Christoph Hellwigad9b4632008-06-23 13:23:48 +10002374 entry->flags,
Dave Chinnera9273ca2010-01-20 10:47:48 +11002375 name_loc->nameval,
Tim Shimmin726801b2006-09-28 11:01:37 +10002376 (int)name_loc->namelen,
2377 be16_to_cpu(name_loc->valuelen),
Dave Chinnera9273ca2010-01-20 10:47:48 +11002378 &name_loc->nameval[name_loc->namelen]);
Tim Shimmin726801b2006-09-28 11:01:37 +10002379 if (retval)
2380 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002381 } else {
Tim Shimmin726801b2006-09-28 11:01:37 +10002382 xfs_attr_leaf_name_remote_t *name_rmt =
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002383 xfs_attr_leaf_name_remote(leaf, i);
Tim Shimmin726801b2006-09-28 11:01:37 +10002384
2385 int valuelen = be32_to_cpu(name_rmt->valuelen);
2386
2387 if (context->put_value) {
2388 xfs_da_args_t args;
2389
2390 memset((char *)&args, 0, sizeof(args));
2391 args.dp = context->dp;
2392 args.whichfork = XFS_ATTR_FORK;
2393 args.valuelen = valuelen;
Dave Chinner622d8142010-12-23 11:57:37 +11002394 args.value = kmem_alloc(valuelen, KM_SLEEP | KM_NOFS);
Tim Shimmin726801b2006-09-28 11:01:37 +10002395 args.rmtblkno = be32_to_cpu(name_rmt->valueblk);
2396 args.rmtblkcnt = XFS_B_TO_FSB(args.dp->i_mount, valuelen);
2397 retval = xfs_attr_rmtval_get(&args);
2398 if (retval)
2399 return retval;
2400 retval = context->put_listent(context,
Christoph Hellwigad9b4632008-06-23 13:23:48 +10002401 entry->flags,
Dave Chinnera9273ca2010-01-20 10:47:48 +11002402 name_rmt->name,
Tim Shimmin726801b2006-09-28 11:01:37 +10002403 (int)name_rmt->namelen,
2404 valuelen,
Dave Chinnera9273ca2010-01-20 10:47:48 +11002405 args.value);
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10002406 kmem_free(args.value);
Christoph Hellwigad9b4632008-06-23 13:23:48 +10002407 } else {
Tim Shimmin726801b2006-09-28 11:01:37 +10002408 retval = context->put_listent(context,
Christoph Hellwigad9b4632008-06-23 13:23:48 +10002409 entry->flags,
Dave Chinnera9273ca2010-01-20 10:47:48 +11002410 name_rmt->name,
Tim Shimmin726801b2006-09-28 11:01:37 +10002411 (int)name_rmt->namelen,
2412 valuelen,
2413 NULL);
2414 }
2415 if (retval)
2416 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002417 }
Tim Shimmin726801b2006-09-28 11:01:37 +10002418 if (context->seen_enough)
2419 break;
2420 cursor->offset++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002421 }
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00002422 trace_xfs_attr_list_leaf_end(context);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002423 return(retval);
2424}
2425
Linus Torvalds1da177e2005-04-16 15:20:36 -07002426
2427/*========================================================================
2428 * Manage the INCOMPLETE flag in a leaf entry
2429 *========================================================================*/
2430
2431/*
2432 * Clear the INCOMPLETE flag on an entry in a leaf block.
2433 */
2434int
2435xfs_attr_leaf_clearflag(xfs_da_args_t *args)
2436{
2437 xfs_attr_leafblock_t *leaf;
2438 xfs_attr_leaf_entry_t *entry;
2439 xfs_attr_leaf_name_remote_t *name_rmt;
2440 xfs_dabuf_t *bp;
2441 int error;
2442#ifdef DEBUG
2443 xfs_attr_leaf_name_local_t *name_loc;
2444 int namelen;
2445 char *name;
2446#endif /* DEBUG */
2447
2448 /*
2449 * Set up the operation.
2450 */
2451 error = xfs_da_read_buf(args->trans, args->dp, args->blkno, -1, &bp,
2452 XFS_ATTR_FORK);
2453 if (error) {
2454 return(error);
2455 }
2456 ASSERT(bp != NULL);
2457
2458 leaf = bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002459 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Nathan Scott918ae422006-03-17 17:28:54 +11002460 ASSERT(args->index < be16_to_cpu(leaf->hdr.count));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002461 ASSERT(args->index >= 0);
2462 entry = &leaf->entries[ args->index ];
2463 ASSERT(entry->flags & XFS_ATTR_INCOMPLETE);
2464
2465#ifdef DEBUG
2466 if (entry->flags & XFS_ATTR_LOCAL) {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002467 name_loc = xfs_attr_leaf_name_local(leaf, args->index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002468 namelen = name_loc->namelen;
2469 name = (char *)name_loc->nameval;
2470 } else {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002471 name_rmt = xfs_attr_leaf_name_remote(leaf, args->index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002472 namelen = name_rmt->namelen;
2473 name = (char *)name_rmt->name;
2474 }
Nathan Scott6b19f2d2006-03-17 17:29:02 +11002475 ASSERT(be32_to_cpu(entry->hashval) == args->hashval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002476 ASSERT(namelen == args->namelen);
2477 ASSERT(memcmp(name, args->name, namelen) == 0);
2478#endif /* DEBUG */
2479
2480 entry->flags &= ~XFS_ATTR_INCOMPLETE;
2481 xfs_da_log_buf(args->trans, bp,
2482 XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));
2483
2484 if (args->rmtblkno) {
2485 ASSERT((entry->flags & XFS_ATTR_LOCAL) == 0);
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002486 name_rmt = xfs_attr_leaf_name_remote(leaf, args->index);
Nathan Scottc0f054e2006-03-17 17:29:18 +11002487 name_rmt->valueblk = cpu_to_be32(args->rmtblkno);
2488 name_rmt->valuelen = cpu_to_be32(args->valuelen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002489 xfs_da_log_buf(args->trans, bp,
2490 XFS_DA_LOGRANGE(leaf, name_rmt, sizeof(*name_rmt)));
2491 }
2492 xfs_da_buf_done(bp);
2493
2494 /*
2495 * Commit the flag value change and start the next trans in series.
2496 */
Niv Sardi322ff6b2008-08-13 16:05:49 +10002497 return xfs_trans_roll(&args->trans, args->dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002498}
2499
2500/*
2501 * Set the INCOMPLETE flag on an entry in a leaf block.
2502 */
2503int
2504xfs_attr_leaf_setflag(xfs_da_args_t *args)
2505{
2506 xfs_attr_leafblock_t *leaf;
2507 xfs_attr_leaf_entry_t *entry;
2508 xfs_attr_leaf_name_remote_t *name_rmt;
2509 xfs_dabuf_t *bp;
2510 int error;
2511
2512 /*
2513 * Set up the operation.
2514 */
2515 error = xfs_da_read_buf(args->trans, args->dp, args->blkno, -1, &bp,
2516 XFS_ATTR_FORK);
2517 if (error) {
2518 return(error);
2519 }
2520 ASSERT(bp != NULL);
2521
2522 leaf = bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002523 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Nathan Scott918ae422006-03-17 17:28:54 +11002524 ASSERT(args->index < be16_to_cpu(leaf->hdr.count));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002525 ASSERT(args->index >= 0);
2526 entry = &leaf->entries[ args->index ];
2527
2528 ASSERT((entry->flags & XFS_ATTR_INCOMPLETE) == 0);
2529 entry->flags |= XFS_ATTR_INCOMPLETE;
2530 xfs_da_log_buf(args->trans, bp,
2531 XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));
2532 if ((entry->flags & XFS_ATTR_LOCAL) == 0) {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002533 name_rmt = xfs_attr_leaf_name_remote(leaf, args->index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002534 name_rmt->valueblk = 0;
2535 name_rmt->valuelen = 0;
2536 xfs_da_log_buf(args->trans, bp,
2537 XFS_DA_LOGRANGE(leaf, name_rmt, sizeof(*name_rmt)));
2538 }
2539 xfs_da_buf_done(bp);
2540
2541 /*
2542 * Commit the flag value change and start the next trans in series.
2543 */
Niv Sardi322ff6b2008-08-13 16:05:49 +10002544 return xfs_trans_roll(&args->trans, args->dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002545}
2546
2547/*
2548 * In a single transaction, clear the INCOMPLETE flag on the leaf entry
2549 * given by args->blkno/index and set the INCOMPLETE flag on the leaf
2550 * entry given by args->blkno2/index2.
2551 *
2552 * Note that they could be in different blocks, or in the same block.
2553 */
2554int
2555xfs_attr_leaf_flipflags(xfs_da_args_t *args)
2556{
2557 xfs_attr_leafblock_t *leaf1, *leaf2;
2558 xfs_attr_leaf_entry_t *entry1, *entry2;
2559 xfs_attr_leaf_name_remote_t *name_rmt;
2560 xfs_dabuf_t *bp1, *bp2;
2561 int error;
2562#ifdef DEBUG
2563 xfs_attr_leaf_name_local_t *name_loc;
2564 int namelen1, namelen2;
2565 char *name1, *name2;
2566#endif /* DEBUG */
2567
2568 /*
2569 * Read the block containing the "old" attr
2570 */
2571 error = xfs_da_read_buf(args->trans, args->dp, args->blkno, -1, &bp1,
2572 XFS_ATTR_FORK);
2573 if (error) {
2574 return(error);
2575 }
2576 ASSERT(bp1 != NULL);
2577
2578 /*
2579 * Read the block containing the "new" attr, if it is different
2580 */
2581 if (args->blkno2 != args->blkno) {
2582 error = xfs_da_read_buf(args->trans, args->dp, args->blkno2,
2583 -1, &bp2, XFS_ATTR_FORK);
2584 if (error) {
2585 return(error);
2586 }
2587 ASSERT(bp2 != NULL);
2588 } else {
2589 bp2 = bp1;
2590 }
2591
2592 leaf1 = bp1->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002593 ASSERT(leaf1->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Nathan Scott918ae422006-03-17 17:28:54 +11002594 ASSERT(args->index < be16_to_cpu(leaf1->hdr.count));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002595 ASSERT(args->index >= 0);
2596 entry1 = &leaf1->entries[ args->index ];
2597
2598 leaf2 = bp2->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002599 ASSERT(leaf2->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Nathan Scott918ae422006-03-17 17:28:54 +11002600 ASSERT(args->index2 < be16_to_cpu(leaf2->hdr.count));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002601 ASSERT(args->index2 >= 0);
2602 entry2 = &leaf2->entries[ args->index2 ];
2603
2604#ifdef DEBUG
2605 if (entry1->flags & XFS_ATTR_LOCAL) {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002606 name_loc = xfs_attr_leaf_name_local(leaf1, args->index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002607 namelen1 = name_loc->namelen;
2608 name1 = (char *)name_loc->nameval;
2609 } else {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002610 name_rmt = xfs_attr_leaf_name_remote(leaf1, args->index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002611 namelen1 = name_rmt->namelen;
2612 name1 = (char *)name_rmt->name;
2613 }
2614 if (entry2->flags & XFS_ATTR_LOCAL) {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002615 name_loc = xfs_attr_leaf_name_local(leaf2, args->index2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002616 namelen2 = name_loc->namelen;
2617 name2 = (char *)name_loc->nameval;
2618 } else {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002619 name_rmt = xfs_attr_leaf_name_remote(leaf2, args->index2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002620 namelen2 = name_rmt->namelen;
2621 name2 = (char *)name_rmt->name;
2622 }
Nathan Scott6b19f2d2006-03-17 17:29:02 +11002623 ASSERT(be32_to_cpu(entry1->hashval) == be32_to_cpu(entry2->hashval));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002624 ASSERT(namelen1 == namelen2);
2625 ASSERT(memcmp(name1, name2, namelen1) == 0);
2626#endif /* DEBUG */
2627
2628 ASSERT(entry1->flags & XFS_ATTR_INCOMPLETE);
2629 ASSERT((entry2->flags & XFS_ATTR_INCOMPLETE) == 0);
2630
2631 entry1->flags &= ~XFS_ATTR_INCOMPLETE;
2632 xfs_da_log_buf(args->trans, bp1,
2633 XFS_DA_LOGRANGE(leaf1, entry1, sizeof(*entry1)));
2634 if (args->rmtblkno) {
2635 ASSERT((entry1->flags & XFS_ATTR_LOCAL) == 0);
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002636 name_rmt = xfs_attr_leaf_name_remote(leaf1, args->index);
Nathan Scottc0f054e2006-03-17 17:29:18 +11002637 name_rmt->valueblk = cpu_to_be32(args->rmtblkno);
2638 name_rmt->valuelen = cpu_to_be32(args->valuelen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002639 xfs_da_log_buf(args->trans, bp1,
2640 XFS_DA_LOGRANGE(leaf1, name_rmt, sizeof(*name_rmt)));
2641 }
2642
2643 entry2->flags |= XFS_ATTR_INCOMPLETE;
2644 xfs_da_log_buf(args->trans, bp2,
2645 XFS_DA_LOGRANGE(leaf2, entry2, sizeof(*entry2)));
2646 if ((entry2->flags & XFS_ATTR_LOCAL) == 0) {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002647 name_rmt = xfs_attr_leaf_name_remote(leaf2, args->index2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002648 name_rmt->valueblk = 0;
2649 name_rmt->valuelen = 0;
2650 xfs_da_log_buf(args->trans, bp2,
2651 XFS_DA_LOGRANGE(leaf2, name_rmt, sizeof(*name_rmt)));
2652 }
2653 xfs_da_buf_done(bp1);
2654 if (bp1 != bp2)
2655 xfs_da_buf_done(bp2);
2656
2657 /*
2658 * Commit the flag value change and start the next trans in series.
2659 */
Niv Sardi322ff6b2008-08-13 16:05:49 +10002660 error = xfs_trans_roll(&args->trans, args->dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002661
2662 return(error);
2663}
2664
2665/*========================================================================
2666 * Indiscriminately delete the entire attribute fork
2667 *========================================================================*/
2668
2669/*
2670 * Recurse (gasp!) through the attribute nodes until we find leaves.
2671 * We're doing a depth-first traversal in order to invalidate everything.
2672 */
2673int
2674xfs_attr_root_inactive(xfs_trans_t **trans, xfs_inode_t *dp)
2675{
2676 xfs_da_blkinfo_t *info;
2677 xfs_daddr_t blkno;
2678 xfs_dabuf_t *bp;
2679 int error;
2680
2681 /*
2682 * Read block 0 to see what we have to work with.
2683 * We only get here if we have extents, since we remove
2684 * the extents in reverse order the extent containing
2685 * block 0 must still be there.
2686 */
2687 error = xfs_da_read_buf(*trans, dp, 0, -1, &bp, XFS_ATTR_FORK);
2688 if (error)
2689 return(error);
2690 blkno = xfs_da_blkno(bp);
2691
2692 /*
2693 * Invalidate the tree, even if the "tree" is only a single leaf block.
2694 * This is a depth-first traversal!
2695 */
2696 info = bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002697 if (info->magic == cpu_to_be16(XFS_DA_NODE_MAGIC)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002698 error = xfs_attr_node_inactive(trans, dp, bp, 1);
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002699 } else if (info->magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002700 error = xfs_attr_leaf_inactive(trans, dp, bp);
2701 } else {
2702 error = XFS_ERROR(EIO);
2703 xfs_da_brelse(*trans, bp);
2704 }
2705 if (error)
2706 return(error);
2707
2708 /*
2709 * Invalidate the incore copy of the root block.
2710 */
2711 error = xfs_da_get_buf(*trans, dp, 0, blkno, &bp, XFS_ATTR_FORK);
2712 if (error)
2713 return(error);
2714 xfs_da_binval(*trans, bp); /* remove from cache */
2715 /*
2716 * Commit the invalidate and start the next transaction.
2717 */
Niv Sardi322ff6b2008-08-13 16:05:49 +10002718 error = xfs_trans_roll(trans, dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002719
2720 return (error);
2721}
2722
2723/*
2724 * Recurse (gasp!) through the attribute nodes until we find leaves.
2725 * We're doing a depth-first traversal in order to invalidate everything.
2726 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002727STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002728xfs_attr_node_inactive(xfs_trans_t **trans, xfs_inode_t *dp, xfs_dabuf_t *bp,
2729 int level)
2730{
2731 xfs_da_blkinfo_t *info;
2732 xfs_da_intnode_t *node;
2733 xfs_dablk_t child_fsb;
2734 xfs_daddr_t parent_blkno, child_blkno;
2735 int error, count, i;
2736 xfs_dabuf_t *child_bp;
2737
2738 /*
2739 * Since this code is recursive (gasp!) we must protect ourselves.
2740 */
2741 if (level > XFS_DA_NODE_MAXDEPTH) {
2742 xfs_da_brelse(*trans, bp); /* no locks for later trans */
2743 return(XFS_ERROR(EIO));
2744 }
2745
2746 node = bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002747 ASSERT(node->hdr.info.magic == cpu_to_be16(XFS_DA_NODE_MAGIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002748 parent_blkno = xfs_da_blkno(bp); /* save for re-read later */
Nathan Scottfac80cc2006-03-17 17:29:56 +11002749 count = be16_to_cpu(node->hdr.count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002750 if (!count) {
2751 xfs_da_brelse(*trans, bp);
2752 return(0);
2753 }
Nathan Scott403432d2006-03-17 17:29:46 +11002754 child_fsb = be32_to_cpu(node->btree[0].before);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002755 xfs_da_brelse(*trans, bp); /* no locks for later trans */
2756
2757 /*
2758 * If this is the node level just above the leaves, simply loop
2759 * over the leaves removing all of them. If this is higher up
2760 * in the tree, recurse downward.
2761 */
2762 for (i = 0; i < count; i++) {
2763 /*
2764 * Read the subsidiary block to see what we have to work with.
2765 * Don't do this in a transaction. This is a depth-first
2766 * traversal of the tree so we may deal with many blocks
2767 * before we come back to this one.
2768 */
2769 error = xfs_da_read_buf(*trans, dp, child_fsb, -2, &child_bp,
2770 XFS_ATTR_FORK);
2771 if (error)
2772 return(error);
2773 if (child_bp) {
2774 /* save for re-read later */
2775 child_blkno = xfs_da_blkno(child_bp);
2776
2777 /*
2778 * Invalidate the subtree, however we have to.
2779 */
2780 info = child_bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002781 if (info->magic == cpu_to_be16(XFS_DA_NODE_MAGIC)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002782 error = xfs_attr_node_inactive(trans, dp,
2783 child_bp, level+1);
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002784 } else if (info->magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002785 error = xfs_attr_leaf_inactive(trans, dp,
2786 child_bp);
2787 } else {
2788 error = XFS_ERROR(EIO);
2789 xfs_da_brelse(*trans, child_bp);
2790 }
2791 if (error)
2792 return(error);
2793
2794 /*
2795 * Remove the subsidiary block from the cache
2796 * and from the log.
2797 */
2798 error = xfs_da_get_buf(*trans, dp, 0, child_blkno,
2799 &child_bp, XFS_ATTR_FORK);
2800 if (error)
2801 return(error);
2802 xfs_da_binval(*trans, child_bp);
2803 }
2804
2805 /*
2806 * If we're not done, re-read the parent to get the next
2807 * child block number.
2808 */
2809 if ((i+1) < count) {
2810 error = xfs_da_read_buf(*trans, dp, 0, parent_blkno,
2811 &bp, XFS_ATTR_FORK);
2812 if (error)
2813 return(error);
Nathan Scott403432d2006-03-17 17:29:46 +11002814 child_fsb = be32_to_cpu(node->btree[i+1].before);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002815 xfs_da_brelse(*trans, bp);
2816 }
2817 /*
2818 * Atomically commit the whole invalidate stuff.
2819 */
Niv Sardi322ff6b2008-08-13 16:05:49 +10002820 error = xfs_trans_roll(trans, dp);
2821 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002822 return (error);
2823 }
2824
2825 return(0);
2826}
2827
2828/*
2829 * Invalidate all of the "remote" value regions pointed to by a particular
2830 * leaf block.
2831 * Note that we must release the lock on the buffer so that we are not
2832 * caught holding something that the logging code wants to flush to disk.
2833 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002834STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002835xfs_attr_leaf_inactive(xfs_trans_t **trans, xfs_inode_t *dp, xfs_dabuf_t *bp)
2836{
2837 xfs_attr_leafblock_t *leaf;
2838 xfs_attr_leaf_entry_t *entry;
2839 xfs_attr_leaf_name_remote_t *name_rmt;
2840 xfs_attr_inactive_list_t *list, *lp;
2841 int error, count, size, tmp, i;
2842
2843 leaf = bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002844 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002845
2846 /*
2847 * Count the number of "remote" value extents.
2848 */
2849 count = 0;
2850 entry = &leaf->entries[0];
Nathan Scott918ae422006-03-17 17:28:54 +11002851 for (i = 0; i < be16_to_cpu(leaf->hdr.count); entry++, i++) {
Nathan Scott6b19f2d2006-03-17 17:29:02 +11002852 if (be16_to_cpu(entry->nameidx) &&
2853 ((entry->flags & XFS_ATTR_LOCAL) == 0)) {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002854 name_rmt = xfs_attr_leaf_name_remote(leaf, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002855 if (name_rmt->valueblk)
2856 count++;
2857 }
2858 }
2859
2860 /*
2861 * If there are no "remote" values, we're done.
2862 */
2863 if (count == 0) {
2864 xfs_da_brelse(*trans, bp);
2865 return(0);
2866 }
2867
2868 /*
2869 * Allocate storage for a list of all the "remote" value extents.
2870 */
2871 size = count * sizeof(xfs_attr_inactive_list_t);
2872 list = (xfs_attr_inactive_list_t *)kmem_alloc(size, KM_SLEEP);
2873
2874 /*
2875 * Identify each of the "remote" value extents.
2876 */
2877 lp = list;
2878 entry = &leaf->entries[0];
Nathan Scott918ae422006-03-17 17:28:54 +11002879 for (i = 0; i < be16_to_cpu(leaf->hdr.count); entry++, i++) {
Nathan Scott6b19f2d2006-03-17 17:29:02 +11002880 if (be16_to_cpu(entry->nameidx) &&
2881 ((entry->flags & XFS_ATTR_LOCAL) == 0)) {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002882 name_rmt = xfs_attr_leaf_name_remote(leaf, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002883 if (name_rmt->valueblk) {
Nathan Scottd7929ff2006-03-17 17:29:36 +11002884 lp->valueblk = be32_to_cpu(name_rmt->valueblk);
2885 lp->valuelen = XFS_B_TO_FSB(dp->i_mount,
2886 be32_to_cpu(name_rmt->valuelen));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002887 lp++;
2888 }
2889 }
2890 }
2891 xfs_da_brelse(*trans, bp); /* unlock for trans. in freextent() */
2892
2893 /*
2894 * Invalidate each of the "remote" value extents.
2895 */
2896 error = 0;
2897 for (lp = list, i = 0; i < count; i++, lp++) {
2898 tmp = xfs_attr_leaf_freextent(trans, dp,
Nathan Scottd7929ff2006-03-17 17:29:36 +11002899 lp->valueblk, lp->valuelen);
2900
Linus Torvalds1da177e2005-04-16 15:20:36 -07002901 if (error == 0)
2902 error = tmp; /* save only the 1st errno */
2903 }
2904
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10002905 kmem_free((xfs_caddr_t)list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002906 return(error);
2907}
2908
2909/*
2910 * Look at all the extents for this logical region,
2911 * invalidate any buffers that are incore/in transactions.
2912 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002913STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002914xfs_attr_leaf_freextent(xfs_trans_t **trans, xfs_inode_t *dp,
2915 xfs_dablk_t blkno, int blkcnt)
2916{
2917 xfs_bmbt_irec_t map;
2918 xfs_dablk_t tblkno;
2919 int tblkcnt, dblkcnt, nmap, error;
2920 xfs_daddr_t dblkno;
2921 xfs_buf_t *bp;
2922
2923 /*
2924 * Roll through the "value", invalidating the attribute value's
2925 * blocks.
2926 */
2927 tblkno = blkno;
2928 tblkcnt = blkcnt;
2929 while (tblkcnt > 0) {
2930 /*
2931 * Try to remember where we decided to put the value.
2932 */
2933 nmap = 1;
Dave Chinner5c8ed202011-09-18 20:40:45 +00002934 error = xfs_bmapi_read(dp, (xfs_fileoff_t)tblkno, tblkcnt,
2935 &map, &nmap, XFS_BMAPI_ATTRFORK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002936 if (error) {
2937 return(error);
2938 }
2939 ASSERT(nmap == 1);
2940 ASSERT(map.br_startblock != DELAYSTARTBLOCK);
2941
2942 /*
2943 * If it's a hole, these are already unmapped
2944 * so there's nothing to invalidate.
2945 */
2946 if (map.br_startblock != HOLESTARTBLOCK) {
2947
2948 dblkno = XFS_FSB_TO_DADDR(dp->i_mount,
2949 map.br_startblock);
2950 dblkcnt = XFS_FSB_TO_BB(dp->i_mount,
2951 map.br_blockcount);
2952 bp = xfs_trans_get_buf(*trans,
2953 dp->i_mount->m_ddev_targp,
Christoph Hellwig0cadda12010-01-19 09:56:44 +00002954 dblkno, dblkcnt, XBF_LOCK);
Chandra Seetharaman2a30f36d2011-09-20 13:56:55 +00002955 if (!bp)
2956 return ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002957 xfs_trans_binval(*trans, bp);
2958 /*
2959 * Roll to next transaction.
2960 */
Niv Sardi322ff6b2008-08-13 16:05:49 +10002961 error = xfs_trans_roll(trans, dp);
2962 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002963 return (error);
2964 }
2965
2966 tblkno += map.br_blockcount;
2967 tblkcnt -= map.br_blockcount;
2968 }
2969
2970 return(0);
2971}