blob: 76d93dc953e15fea0a213955e1c8cd7223974d7b [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
Dave Chinner5a5881c2012-03-22 05:15:13 +0000238 trace_xfs_attr_sf_create(args);
239
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 dp = args->dp;
241 ASSERT(dp != NULL);
242 ifp = dp->i_afp;
243 ASSERT(ifp != NULL);
244 ASSERT(ifp->if_bytes == 0);
245 if (dp->i_d.di_aformat == XFS_DINODE_FMT_EXTENTS) {
246 ifp->if_flags &= ~XFS_IFEXTENTS; /* just in case */
247 dp->i_d.di_aformat = XFS_DINODE_FMT_LOCAL;
248 ifp->if_flags |= XFS_IFINLINE;
249 } else {
250 ASSERT(ifp->if_flags & XFS_IFINLINE);
251 }
252 xfs_idata_realloc(dp, sizeof(*hdr), XFS_ATTR_FORK);
253 hdr = (xfs_attr_sf_hdr_t *)ifp->if_u1.if_data;
254 hdr->count = 0;
Nathan Scott3b244aa2006-03-17 17:29:25 +1100255 hdr->totsize = cpu_to_be16(sizeof(*hdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_ADATA);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257}
258
259/*
260 * Add a name/value pair to the shortform attribute list.
261 * Overflow from the inode has already been checked for.
262 */
Nathan Scottd8cc8902005-11-02 10:34:53 +1100263void
264xfs_attr_shortform_add(xfs_da_args_t *args, int forkoff)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265{
266 xfs_attr_shortform_t *sf;
267 xfs_attr_sf_entry_t *sfe;
268 int i, offset, size;
Nathan Scottd8cc8902005-11-02 10:34:53 +1100269 xfs_mount_t *mp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 xfs_inode_t *dp;
271 xfs_ifork_t *ifp;
272
Dave Chinner5a5881c2012-03-22 05:15:13 +0000273 trace_xfs_attr_sf_add(args);
274
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 dp = args->dp;
Nathan Scottd8cc8902005-11-02 10:34:53 +1100276 mp = dp->i_mount;
277 dp->i_d.di_forkoff = forkoff;
Nathan Scottd8cc8902005-11-02 10:34:53 +1100278
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 ifp = dp->i_afp;
280 ASSERT(ifp->if_flags & XFS_IFINLINE);
281 sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;
282 sfe = &sf->list[0];
Nathan Scott3b244aa2006-03-17 17:29:25 +1100283 for (i = 0; i < sf->hdr.count; sfe = XFS_ATTR_SF_NEXTENTRY(sfe), i++) {
Nathan Scottd8cc8902005-11-02 10:34:53 +1100284#ifdef DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 if (sfe->namelen != args->namelen)
286 continue;
287 if (memcmp(args->name, sfe->nameval, args->namelen) != 0)
288 continue;
Tim Shimmin726801b2006-09-28 11:01:37 +1000289 if (!xfs_attr_namesp_match(args->flags, sfe->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 continue;
Nathan Scottd8cc8902005-11-02 10:34:53 +1100291 ASSERT(0);
292#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 }
294
295 offset = (char *)sfe - (char *)sf;
296 size = XFS_ATTR_SF_ENTSIZE_BYNAME(args->namelen, args->valuelen);
297 xfs_idata_realloc(dp, size, XFS_ATTR_FORK);
298 sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;
299 sfe = (xfs_attr_sf_entry_t *)((char *)sf + offset);
300
301 sfe->namelen = args->namelen;
Nathan Scott3b244aa2006-03-17 17:29:25 +1100302 sfe->valuelen = args->valuelen;
Tim Shimmin726801b2006-09-28 11:01:37 +1000303 sfe->flags = XFS_ATTR_NSP_ARGS_TO_ONDISK(args->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 memcpy(sfe->nameval, args->name, args->namelen);
305 memcpy(&sfe->nameval[args->namelen], args->value, args->valuelen);
Nathan Scott3b244aa2006-03-17 17:29:25 +1100306 sf->hdr.count++;
Marcin Slusarz413d57c2008-02-13 15:03:29 -0800307 be16_add_cpu(&sf->hdr.totsize, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_ADATA);
309
Nathan Scottd8cc8902005-11-02 10:34:53 +1100310 xfs_sbversion_add_attr2(mp, args->trans);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311}
312
313/*
Christoph Hellwige1486de2009-02-04 09:36:00 +0100314 * After the last attribute is removed revert to original inode format,
315 * making all literal area available to the data fork once more.
316 */
317STATIC void
318xfs_attr_fork_reset(
319 struct xfs_inode *ip,
320 struct xfs_trans *tp)
321{
322 xfs_idestroy_fork(ip, XFS_ATTR_FORK);
323 ip->i_d.di_forkoff = 0;
324 ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
325
326 ASSERT(ip->i_d.di_anextents == 0);
327 ASSERT(ip->i_afp == NULL);
328
Christoph Hellwige1486de2009-02-04 09:36:00 +0100329 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
330}
331
332/*
Nathan Scottd8cc8902005-11-02 10:34:53 +1100333 * Remove an attribute from the shortform attribute list structure.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 */
335int
336xfs_attr_shortform_remove(xfs_da_args_t *args)
337{
338 xfs_attr_shortform_t *sf;
339 xfs_attr_sf_entry_t *sfe;
340 int base, size=0, end, totsize, i;
Nathan Scottd8cc8902005-11-02 10:34:53 +1100341 xfs_mount_t *mp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 xfs_inode_t *dp;
343
Dave Chinner5a5881c2012-03-22 05:15:13 +0000344 trace_xfs_attr_sf_remove(args);
345
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 dp = args->dp;
Nathan Scottd8cc8902005-11-02 10:34:53 +1100347 mp = dp->i_mount;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 base = sizeof(xfs_attr_sf_hdr_t);
349 sf = (xfs_attr_shortform_t *)dp->i_afp->if_u1.if_data;
350 sfe = &sf->list[0];
Nathan Scott3b244aa2006-03-17 17:29:25 +1100351 end = sf->hdr.count;
Nathan Scottd8cc8902005-11-02 10:34:53 +1100352 for (i = 0; i < end; sfe = XFS_ATTR_SF_NEXTENTRY(sfe),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 base += size, i++) {
354 size = XFS_ATTR_SF_ENTSIZE(sfe);
355 if (sfe->namelen != args->namelen)
356 continue;
357 if (memcmp(sfe->nameval, args->name, args->namelen) != 0)
358 continue;
Tim Shimmin726801b2006-09-28 11:01:37 +1000359 if (!xfs_attr_namesp_match(args->flags, sfe->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 continue;
361 break;
362 }
Nathan Scottd8cc8902005-11-02 10:34:53 +1100363 if (i == end)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 return(XFS_ERROR(ENOATTR));
365
Nathan Scottd8cc8902005-11-02 10:34:53 +1100366 /*
367 * Fix up the attribute fork data, covering the hole
368 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 end = base + size;
Nathan Scott3b244aa2006-03-17 17:29:25 +1100370 totsize = be16_to_cpu(sf->hdr.totsize);
Nathan Scottd8cc8902005-11-02 10:34:53 +1100371 if (end != totsize)
372 memmove(&((char *)sf)[base], &((char *)sf)[end], totsize - end);
Nathan Scott3b244aa2006-03-17 17:29:25 +1100373 sf->hdr.count--;
Marcin Slusarz413d57c2008-02-13 15:03:29 -0800374 be16_add_cpu(&sf->hdr.totsize, -size);
Nathan Scottd8cc8902005-11-02 10:34:53 +1100375
376 /*
377 * Fix up the start offset of the attribute fork
378 */
379 totsize -= size;
Barry Naujok6a178102008-05-21 16:42:05 +1000380 if (totsize == sizeof(xfs_attr_sf_hdr_t) &&
Christoph Hellwige1486de2009-02-04 09:36:00 +0100381 (mp->m_flags & XFS_MOUNT_ATTR2) &&
382 (dp->i_d.di_format != XFS_DINODE_FMT_BTREE) &&
383 !(args->op_flags & XFS_DA_OP_ADDNAME)) {
384 xfs_attr_fork_reset(dp, args->trans);
Nathan Scottd8cc8902005-11-02 10:34:53 +1100385 } else {
386 xfs_idata_realloc(dp, -size, XFS_ATTR_FORK);
387 dp->i_d.di_forkoff = xfs_attr_shortform_bytesfit(dp, totsize);
388 ASSERT(dp->i_d.di_forkoff);
Barry Naujok6a178102008-05-21 16:42:05 +1000389 ASSERT(totsize > sizeof(xfs_attr_sf_hdr_t) ||
390 (args->op_flags & XFS_DA_OP_ADDNAME) ||
391 !(mp->m_flags & XFS_MOUNT_ATTR2) ||
392 dp->i_d.di_format == XFS_DINODE_FMT_BTREE);
Nathan Scottd8cc8902005-11-02 10:34:53 +1100393 xfs_trans_log_inode(args->trans, dp,
394 XFS_ILOG_CORE | XFS_ILOG_ADATA);
395 }
396
397 xfs_sbversion_add_attr2(mp, args->trans);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398
399 return(0);
400}
401
402/*
403 * Look up a name in a shortform attribute list structure.
404 */
405/*ARGSUSED*/
406int
407xfs_attr_shortform_lookup(xfs_da_args_t *args)
408{
409 xfs_attr_shortform_t *sf;
410 xfs_attr_sf_entry_t *sfe;
411 int i;
412 xfs_ifork_t *ifp;
413
Dave Chinner5a5881c2012-03-22 05:15:13 +0000414 trace_xfs_attr_sf_lookup(args);
415
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 ifp = args->dp->i_afp;
417 ASSERT(ifp->if_flags & XFS_IFINLINE);
418 sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;
419 sfe = &sf->list[0];
Nathan Scott3b244aa2006-03-17 17:29:25 +1100420 for (i = 0; i < sf->hdr.count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 sfe = XFS_ATTR_SF_NEXTENTRY(sfe), i++) {
422 if (sfe->namelen != args->namelen)
423 continue;
424 if (memcmp(args->name, sfe->nameval, args->namelen) != 0)
425 continue;
Tim Shimmin726801b2006-09-28 11:01:37 +1000426 if (!xfs_attr_namesp_match(args->flags, sfe->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 continue;
428 return(XFS_ERROR(EEXIST));
429 }
430 return(XFS_ERROR(ENOATTR));
431}
432
433/*
434 * Look up a name in a shortform attribute list structure.
435 */
436/*ARGSUSED*/
437int
438xfs_attr_shortform_getvalue(xfs_da_args_t *args)
439{
440 xfs_attr_shortform_t *sf;
441 xfs_attr_sf_entry_t *sfe;
442 int i;
443
444 ASSERT(args->dp->i_d.di_aformat == XFS_IFINLINE);
445 sf = (xfs_attr_shortform_t *)args->dp->i_afp->if_u1.if_data;
446 sfe = &sf->list[0];
Nathan Scott3b244aa2006-03-17 17:29:25 +1100447 for (i = 0; i < sf->hdr.count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 sfe = XFS_ATTR_SF_NEXTENTRY(sfe), i++) {
449 if (sfe->namelen != args->namelen)
450 continue;
451 if (memcmp(args->name, sfe->nameval, args->namelen) != 0)
452 continue;
Tim Shimmin726801b2006-09-28 11:01:37 +1000453 if (!xfs_attr_namesp_match(args->flags, sfe->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 continue;
455 if (args->flags & ATTR_KERNOVAL) {
Nathan Scott3b244aa2006-03-17 17:29:25 +1100456 args->valuelen = sfe->valuelen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 return(XFS_ERROR(EEXIST));
458 }
Nathan Scott3b244aa2006-03-17 17:29:25 +1100459 if (args->valuelen < sfe->valuelen) {
460 args->valuelen = sfe->valuelen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 return(XFS_ERROR(ERANGE));
462 }
Nathan Scott3b244aa2006-03-17 17:29:25 +1100463 args->valuelen = sfe->valuelen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 memcpy(args->value, &sfe->nameval[args->namelen],
465 args->valuelen);
466 return(XFS_ERROR(EEXIST));
467 }
468 return(XFS_ERROR(ENOATTR));
469}
470
471/*
472 * Convert from using the shortform to the leaf.
473 */
474int
475xfs_attr_shortform_to_leaf(xfs_da_args_t *args)
476{
477 xfs_inode_t *dp;
478 xfs_attr_shortform_t *sf;
479 xfs_attr_sf_entry_t *sfe;
480 xfs_da_args_t nargs;
481 char *tmpbuffer;
482 int error, i, size;
483 xfs_dablk_t blkno;
484 xfs_dabuf_t *bp;
485 xfs_ifork_t *ifp;
486
Dave Chinner5a5881c2012-03-22 05:15:13 +0000487 trace_xfs_attr_sf_to_leaf(args);
488
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 dp = args->dp;
490 ifp = dp->i_afp;
491 sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;
Nathan Scott3b244aa2006-03-17 17:29:25 +1100492 size = be16_to_cpu(sf->hdr.totsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 tmpbuffer = kmem_alloc(size, KM_SLEEP);
494 ASSERT(tmpbuffer != NULL);
495 memcpy(tmpbuffer, ifp->if_u1.if_data, size);
496 sf = (xfs_attr_shortform_t *)tmpbuffer;
497
498 xfs_idata_realloc(dp, -size, XFS_ATTR_FORK);
499 bp = NULL;
500 error = xfs_da_grow_inode(args, &blkno);
501 if (error) {
502 /*
503 * If we hit an IO error middle of the transaction inside
504 * grow_inode(), we may have inconsistent data. Bail out.
505 */
506 if (error == EIO)
507 goto out;
508 xfs_idata_realloc(dp, size, XFS_ATTR_FORK); /* try to put */
509 memcpy(ifp->if_u1.if_data, tmpbuffer, size); /* it back */
510 goto out;
511 }
512
513 ASSERT(blkno == 0);
514 error = xfs_attr_leaf_create(args, blkno, &bp);
515 if (error) {
516 error = xfs_da_shrink_inode(args, 0, bp);
517 bp = NULL;
518 if (error)
519 goto out;
520 xfs_idata_realloc(dp, size, XFS_ATTR_FORK); /* try to put */
521 memcpy(ifp->if_u1.if_data, tmpbuffer, size); /* it back */
522 goto out;
523 }
524
525 memset((char *)&nargs, 0, sizeof(nargs));
526 nargs.dp = dp;
527 nargs.firstblock = args->firstblock;
528 nargs.flist = args->flist;
529 nargs.total = args->total;
530 nargs.whichfork = XFS_ATTR_FORK;
531 nargs.trans = args->trans;
Barry Naujok6a178102008-05-21 16:42:05 +1000532 nargs.op_flags = XFS_DA_OP_OKNOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533
534 sfe = &sf->list[0];
Nathan Scott3b244aa2006-03-17 17:29:25 +1100535 for (i = 0; i < sf->hdr.count; i++) {
Dave Chinnera9273ca2010-01-20 10:47:48 +1100536 nargs.name = sfe->nameval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 nargs.namelen = sfe->namelen;
Dave Chinnera9273ca2010-01-20 10:47:48 +1100538 nargs.value = &sfe->nameval[nargs.namelen];
Nathan Scott3b244aa2006-03-17 17:29:25 +1100539 nargs.valuelen = sfe->valuelen;
Dave Chinnera9273ca2010-01-20 10:47:48 +1100540 nargs.hashval = xfs_da_hashname(sfe->nameval,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 sfe->namelen);
Tim Shimmin726801b2006-09-28 11:01:37 +1000542 nargs.flags = XFS_ATTR_NSP_ONDISK_TO_ARGS(sfe->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 error = xfs_attr_leaf_lookup_int(bp, &nargs); /* set a->index */
544 ASSERT(error == ENOATTR);
545 error = xfs_attr_leaf_add(bp, &nargs);
546 ASSERT(error != ENOSPC);
547 if (error)
548 goto out;
549 sfe = XFS_ATTR_SF_NEXTENTRY(sfe);
550 }
551 error = 0;
552
553out:
554 if(bp)
555 xfs_da_buf_done(bp);
Denys Vlasenkof0e2d932008-05-19 16:31:57 +1000556 kmem_free(tmpbuffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 return(error);
558}
559
560STATIC int
561xfs_attr_shortform_compare(const void *a, const void *b)
562{
563 xfs_attr_sf_sort_t *sa, *sb;
564
565 sa = (xfs_attr_sf_sort_t *)a;
566 sb = (xfs_attr_sf_sort_t *)b;
Nathan Scott984a0812006-03-17 17:29:31 +1100567 if (sa->hash < sb->hash) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 return(-1);
Nathan Scott984a0812006-03-17 17:29:31 +1100569 } else if (sa->hash > sb->hash) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 return(1);
571 } else {
572 return(sa->entno - sb->entno);
573 }
574}
575
Tim Shimmin726801b2006-09-28 11:01:37 +1000576
577#define XFS_ISRESET_CURSOR(cursor) \
578 (!((cursor)->initted) && !((cursor)->hashval) && \
579 !((cursor)->blkno) && !((cursor)->offset))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580/*
581 * Copy out entries of shortform attribute lists for attr_list().
Nathan Scottc41564b2006-03-29 08:55:14 +1000582 * Shortform attribute lists are not stored in hashval sorted order.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 * If the output buffer is not large enough to hold them all, then we
584 * we have to calculate each entries' hashvalue and sort them before
585 * we can begin returning them to the user.
586 */
587/*ARGSUSED*/
588int
589xfs_attr_shortform_list(xfs_attr_list_context_t *context)
590{
591 attrlist_cursor_kern_t *cursor;
592 xfs_attr_sf_sort_t *sbuf, *sbp;
593 xfs_attr_shortform_t *sf;
594 xfs_attr_sf_entry_t *sfe;
595 xfs_inode_t *dp;
596 int sbsize, nsbuf, count, i;
Tim Shimmin726801b2006-09-28 11:01:37 +1000597 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598
599 ASSERT(context != NULL);
600 dp = context->dp;
601 ASSERT(dp != NULL);
602 ASSERT(dp->i_afp != NULL);
603 sf = (xfs_attr_shortform_t *)dp->i_afp->if_u1.if_data;
604 ASSERT(sf != NULL);
605 if (!sf->hdr.count)
606 return(0);
607 cursor = context->cursor;
608 ASSERT(cursor != NULL);
609
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000610 trace_xfs_attr_list_sf(context);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611
612 /*
Tim Shimmin726801b2006-09-28 11:01:37 +1000613 * If the buffer is large enough and the cursor is at the start,
614 * do not bother with sorting since we will return everything in
615 * one buffer and another call using the cursor won't need to be
616 * made.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 * Note the generous fudge factor of 16 overhead bytes per entry.
Tim Shimmin726801b2006-09-28 11:01:37 +1000618 * If bufsize is zero then put_listent must be a search function
619 * and can just scan through what we have.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 */
Tim Shimmin726801b2006-09-28 11:01:37 +1000621 if (context->bufsize == 0 ||
622 (XFS_ISRESET_CURSOR(cursor) &&
623 (dp->i_afp->if_bytes + sf->hdr.count * 16) < context->bufsize)) {
Nathan Scott3b244aa2006-03-17 17:29:25 +1100624 for (i = 0, sfe = &sf->list[0]; i < sf->hdr.count; i++) {
Tim Shimmin726801b2006-09-28 11:01:37 +1000625 error = context->put_listent(context,
Christoph Hellwigad9b4632008-06-23 13:23:48 +1000626 sfe->flags,
Dave Chinnera9273ca2010-01-20 10:47:48 +1100627 sfe->nameval,
Tim Shimmin726801b2006-09-28 11:01:37 +1000628 (int)sfe->namelen,
629 (int)sfe->valuelen,
Dave Chinnera9273ca2010-01-20 10:47:48 +1100630 &sfe->nameval[sfe->namelen]);
Tim Shimmin726801b2006-09-28 11:01:37 +1000631
632 /*
633 * Either search callback finished early or
634 * didn't fit it all in the buffer after all.
635 */
636 if (context->seen_enough)
637 break;
638
639 if (error)
640 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 sfe = XFS_ATTR_SF_NEXTENTRY(sfe);
642 }
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000643 trace_xfs_attr_list_sf_all(context);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 return(0);
645 }
646
Tim Shimmin726801b2006-09-28 11:01:37 +1000647 /* do no more for a search callback */
648 if (context->bufsize == 0)
649 return 0;
650
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 /*
652 * It didn't all fit, so we have to sort everything on hashval.
653 */
Nathan Scott3b244aa2006-03-17 17:29:25 +1100654 sbsize = sf->hdr.count * sizeof(*sbuf);
Dave Chinner622d8142010-12-23 11:57:37 +1100655 sbp = sbuf = kmem_alloc(sbsize, KM_SLEEP | KM_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656
657 /*
658 * Scan the attribute list for the rest of the entries, storing
659 * the relevant info from only those that match into a buffer.
660 */
661 nsbuf = 0;
Nathan Scott3b244aa2006-03-17 17:29:25 +1100662 for (i = 0, sfe = &sf->list[0]; i < sf->hdr.count; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 if (unlikely(
664 ((char *)sfe < (char *)sf) ||
665 ((char *)sfe >= ((char *)sf + dp->i_afp->if_bytes)))) {
666 XFS_CORRUPTION_ERROR("xfs_attr_shortform_list",
667 XFS_ERRLEVEL_LOW,
668 context->dp->i_mount, sfe);
Denys Vlasenkof0e2d932008-05-19 16:31:57 +1000669 kmem_free(sbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 return XFS_ERROR(EFSCORRUPTED);
671 }
Christoph Hellwigad9b4632008-06-23 13:23:48 +1000672
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 sbp->entno = i;
Dave Chinnera9273ca2010-01-20 10:47:48 +1100674 sbp->hash = xfs_da_hashname(sfe->nameval, sfe->namelen);
675 sbp->name = sfe->nameval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 sbp->namelen = sfe->namelen;
677 /* These are bytes, and both on-disk, don't endian-flip */
678 sbp->valuelen = sfe->valuelen;
679 sbp->flags = sfe->flags;
680 sfe = XFS_ATTR_SF_NEXTENTRY(sfe);
681 sbp++;
682 nsbuf++;
683 }
684
685 /*
686 * Sort the entries on hash then entno.
687 */
Nathan Scott380b5dc2005-11-02 11:43:18 +1100688 xfs_sort(sbuf, nsbuf, sizeof(*sbuf), xfs_attr_shortform_compare);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689
690 /*
691 * Re-find our place IN THE SORTED LIST.
692 */
693 count = 0;
694 cursor->initted = 1;
695 cursor->blkno = 0;
696 for (sbp = sbuf, i = 0; i < nsbuf; i++, sbp++) {
Nathan Scott984a0812006-03-17 17:29:31 +1100697 if (sbp->hash == cursor->hashval) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 if (cursor->offset == count) {
699 break;
700 }
701 count++;
Nathan Scott984a0812006-03-17 17:29:31 +1100702 } else if (sbp->hash > cursor->hashval) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 break;
704 }
705 }
706 if (i == nsbuf) {
Denys Vlasenkof0e2d932008-05-19 16:31:57 +1000707 kmem_free(sbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 return(0);
709 }
710
711 /*
712 * Loop putting entries into the user buffer.
713 */
714 for ( ; i < nsbuf; i++, sbp++) {
Nathan Scott984a0812006-03-17 17:29:31 +1100715 if (cursor->hashval != sbp->hash) {
716 cursor->hashval = sbp->hash;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 cursor->offset = 0;
718 }
Tim Shimmin726801b2006-09-28 11:01:37 +1000719 error = context->put_listent(context,
Christoph Hellwigad9b4632008-06-23 13:23:48 +1000720 sbp->flags,
Tim Shimmin726801b2006-09-28 11:01:37 +1000721 sbp->name,
722 sbp->namelen,
723 sbp->valuelen,
724 &sbp->name[sbp->namelen]);
725 if (error)
726 return error;
727 if (context->seen_enough)
728 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 cursor->offset++;
730 }
731
Denys Vlasenkof0e2d932008-05-19 16:31:57 +1000732 kmem_free(sbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 return(0);
734}
735
736/*
737 * Check a leaf attribute block to see if all the entries would fit into
738 * a shortform attribute list.
739 */
740int
741xfs_attr_shortform_allfit(xfs_dabuf_t *bp, xfs_inode_t *dp)
742{
743 xfs_attr_leafblock_t *leaf;
744 xfs_attr_leaf_entry_t *entry;
745 xfs_attr_leaf_name_local_t *name_loc;
746 int bytes, i;
747
748 leaf = bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +0200749 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750
751 entry = &leaf->entries[0];
752 bytes = sizeof(struct xfs_attr_sf_hdr);
Nathan Scott918ae422006-03-17 17:28:54 +1100753 for (i = 0; i < be16_to_cpu(leaf->hdr.count); entry++, i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 if (entry->flags & XFS_ATTR_INCOMPLETE)
755 continue; /* don't copy partial entries */
756 if (!(entry->flags & XFS_ATTR_LOCAL))
757 return(0);
Eric Sandeenc9fb86a2009-01-01 16:40:11 -0600758 name_loc = xfs_attr_leaf_name_local(leaf, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 if (name_loc->namelen >= XFS_ATTR_SF_ENTSIZE_MAX)
760 return(0);
Nathan Scott053b5752006-03-17 17:29:09 +1100761 if (be16_to_cpu(name_loc->valuelen) >= XFS_ATTR_SF_ENTSIZE_MAX)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 return(0);
763 bytes += sizeof(struct xfs_attr_sf_entry)-1
764 + name_loc->namelen
Nathan Scott053b5752006-03-17 17:29:09 +1100765 + be16_to_cpu(name_loc->valuelen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 }
Nathan Scott13059ff2006-01-11 15:32:01 +1100767 if ((dp->i_mount->m_flags & XFS_MOUNT_ATTR2) &&
Barry Naujoke5889e92007-02-10 18:35:58 +1100768 (dp->i_d.di_format != XFS_DINODE_FMT_BTREE) &&
Nathan Scotte0144ca2005-11-25 16:42:22 +1100769 (bytes == sizeof(struct xfs_attr_sf_hdr)))
Nathan Scottd8cc8902005-11-02 10:34:53 +1100770 return(-1);
771 return(xfs_attr_shortform_bytesfit(dp, bytes));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772}
773
774/*
775 * Convert a leaf attribute list to shortform attribute list
776 */
777int
Nathan Scottd8cc8902005-11-02 10:34:53 +1100778xfs_attr_leaf_to_shortform(xfs_dabuf_t *bp, xfs_da_args_t *args, int forkoff)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779{
780 xfs_attr_leafblock_t *leaf;
781 xfs_attr_leaf_entry_t *entry;
782 xfs_attr_leaf_name_local_t *name_loc;
783 xfs_da_args_t nargs;
784 xfs_inode_t *dp;
785 char *tmpbuffer;
786 int error, i;
787
Dave Chinner5a5881c2012-03-22 05:15:13 +0000788 trace_xfs_attr_leaf_to_sf(args);
789
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 dp = args->dp;
791 tmpbuffer = kmem_alloc(XFS_LBSIZE(dp->i_mount), KM_SLEEP);
792 ASSERT(tmpbuffer != NULL);
793
794 ASSERT(bp != NULL);
795 memcpy(tmpbuffer, bp->data, XFS_LBSIZE(dp->i_mount));
796 leaf = (xfs_attr_leafblock_t *)tmpbuffer;
Christoph Hellwig69ef9212011-07-08 14:36:05 +0200797 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 memset(bp->data, 0, XFS_LBSIZE(dp->i_mount));
799
800 /*
801 * Clean out the prior contents of the attribute list.
802 */
803 error = xfs_da_shrink_inode(args, 0, bp);
804 if (error)
805 goto out;
Nathan Scottd8cc8902005-11-02 10:34:53 +1100806
807 if (forkoff == -1) {
Nathan Scott13059ff2006-01-11 15:32:01 +1100808 ASSERT(dp->i_mount->m_flags & XFS_MOUNT_ATTR2);
Barry Naujoke5889e92007-02-10 18:35:58 +1100809 ASSERT(dp->i_d.di_format != XFS_DINODE_FMT_BTREE);
Christoph Hellwige1486de2009-02-04 09:36:00 +0100810 xfs_attr_fork_reset(dp, args->trans);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 goto out;
Nathan Scottd8cc8902005-11-02 10:34:53 +1100812 }
813
814 xfs_attr_shortform_create(args);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815
816 /*
817 * Copy the attributes
818 */
819 memset((char *)&nargs, 0, sizeof(nargs));
820 nargs.dp = dp;
821 nargs.firstblock = args->firstblock;
822 nargs.flist = args->flist;
823 nargs.total = args->total;
824 nargs.whichfork = XFS_ATTR_FORK;
825 nargs.trans = args->trans;
Barry Naujok6a178102008-05-21 16:42:05 +1000826 nargs.op_flags = XFS_DA_OP_OKNOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 entry = &leaf->entries[0];
Nathan Scott918ae422006-03-17 17:28:54 +1100828 for (i = 0; i < be16_to_cpu(leaf->hdr.count); entry++, i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 if (entry->flags & XFS_ATTR_INCOMPLETE)
830 continue; /* don't copy partial entries */
831 if (!entry->nameidx)
832 continue;
833 ASSERT(entry->flags & XFS_ATTR_LOCAL);
Eric Sandeenc9fb86a2009-01-01 16:40:11 -0600834 name_loc = xfs_attr_leaf_name_local(leaf, i);
Dave Chinnera9273ca2010-01-20 10:47:48 +1100835 nargs.name = name_loc->nameval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836 nargs.namelen = name_loc->namelen;
Dave Chinnera9273ca2010-01-20 10:47:48 +1100837 nargs.value = &name_loc->nameval[nargs.namelen];
Nathan Scott053b5752006-03-17 17:29:09 +1100838 nargs.valuelen = be16_to_cpu(name_loc->valuelen);
Nathan Scott6b19f2d2006-03-17 17:29:02 +1100839 nargs.hashval = be32_to_cpu(entry->hashval);
Tim Shimmin726801b2006-09-28 11:01:37 +1000840 nargs.flags = XFS_ATTR_NSP_ONDISK_TO_ARGS(entry->flags);
Nathan Scottd8cc8902005-11-02 10:34:53 +1100841 xfs_attr_shortform_add(&nargs, forkoff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 }
843 error = 0;
844
845out:
Denys Vlasenkof0e2d932008-05-19 16:31:57 +1000846 kmem_free(tmpbuffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 return(error);
848}
849
850/*
851 * Convert from using a single leaf to a root node and a leaf.
852 */
853int
854xfs_attr_leaf_to_node(xfs_da_args_t *args)
855{
856 xfs_attr_leafblock_t *leaf;
857 xfs_da_intnode_t *node;
858 xfs_inode_t *dp;
859 xfs_dabuf_t *bp1, *bp2;
860 xfs_dablk_t blkno;
861 int error;
862
Dave Chinner5a5881c2012-03-22 05:15:13 +0000863 trace_xfs_attr_leaf_to_node(args);
864
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 dp = args->dp;
866 bp1 = bp2 = NULL;
867 error = xfs_da_grow_inode(args, &blkno);
868 if (error)
869 goto out;
870 error = xfs_da_read_buf(args->trans, args->dp, 0, -1, &bp1,
871 XFS_ATTR_FORK);
872 if (error)
873 goto out;
874 ASSERT(bp1 != NULL);
875 bp2 = NULL;
876 error = xfs_da_get_buf(args->trans, args->dp, blkno, -1, &bp2,
877 XFS_ATTR_FORK);
878 if (error)
879 goto out;
880 ASSERT(bp2 != NULL);
881 memcpy(bp2->data, bp1->data, XFS_LBSIZE(dp->i_mount));
882 xfs_da_buf_done(bp1);
883 bp1 = NULL;
884 xfs_da_log_buf(args->trans, bp2, 0, XFS_LBSIZE(dp->i_mount) - 1);
885
886 /*
887 * Set up the new root node.
888 */
889 error = xfs_da_node_create(args, 0, 1, &bp1, XFS_ATTR_FORK);
890 if (error)
891 goto out;
892 node = bp1->data;
893 leaf = bp2->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +0200894 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 /* both on-disk, don't endian-flip twice */
896 node->btree[0].hashval =
Nathan Scott918ae422006-03-17 17:28:54 +1100897 leaf->entries[be16_to_cpu(leaf->hdr.count)-1 ].hashval;
Nathan Scott403432d2006-03-17 17:29:46 +1100898 node->btree[0].before = cpu_to_be32(blkno);
Nathan Scottfac80cc2006-03-17 17:29:56 +1100899 node->hdr.count = cpu_to_be16(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 xfs_da_log_buf(args->trans, bp1, 0, XFS_LBSIZE(dp->i_mount) - 1);
901 error = 0;
902out:
903 if (bp1)
904 xfs_da_buf_done(bp1);
905 if (bp2)
906 xfs_da_buf_done(bp2);
907 return(error);
908}
909
910
911/*========================================================================
912 * Routines used for growing the Btree.
913 *========================================================================*/
914
915/*
916 * Create the initial contents of a leaf attribute list
917 * or a leaf in a node attribute list.
918 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +1000919STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920xfs_attr_leaf_create(xfs_da_args_t *args, xfs_dablk_t blkno, xfs_dabuf_t **bpp)
921{
922 xfs_attr_leafblock_t *leaf;
923 xfs_attr_leaf_hdr_t *hdr;
924 xfs_inode_t *dp;
925 xfs_dabuf_t *bp;
926 int error;
927
Dave Chinner5a5881c2012-03-22 05:15:13 +0000928 trace_xfs_attr_leaf_create(args);
929
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 dp = args->dp;
931 ASSERT(dp != NULL);
932 error = xfs_da_get_buf(args->trans, args->dp, blkno, -1, &bp,
933 XFS_ATTR_FORK);
934 if (error)
935 return(error);
936 ASSERT(bp != NULL);
937 leaf = bp->data;
938 memset((char *)leaf, 0, XFS_LBSIZE(dp->i_mount));
939 hdr = &leaf->hdr;
Nathan Scott89da0542006-03-17 17:28:40 +1100940 hdr->info.magic = cpu_to_be16(XFS_ATTR_LEAF_MAGIC);
Nathan Scott918ae422006-03-17 17:28:54 +1100941 hdr->firstused = cpu_to_be16(XFS_LBSIZE(dp->i_mount));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 if (!hdr->firstused) {
Nathan Scott918ae422006-03-17 17:28:54 +1100943 hdr->firstused = cpu_to_be16(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 XFS_LBSIZE(dp->i_mount) - XFS_ATTR_LEAF_NAME_ALIGN);
945 }
946
Nathan Scott918ae422006-03-17 17:28:54 +1100947 hdr->freemap[0].base = cpu_to_be16(sizeof(xfs_attr_leaf_hdr_t));
948 hdr->freemap[0].size = cpu_to_be16(be16_to_cpu(hdr->firstused) -
949 sizeof(xfs_attr_leaf_hdr_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950
951 xfs_da_log_buf(args->trans, bp, 0, XFS_LBSIZE(dp->i_mount) - 1);
952
953 *bpp = bp;
954 return(0);
955}
956
957/*
958 * Split the leaf node, rebalance, then add the new entry.
959 */
960int
961xfs_attr_leaf_split(xfs_da_state_t *state, xfs_da_state_blk_t *oldblk,
962 xfs_da_state_blk_t *newblk)
963{
964 xfs_dablk_t blkno;
965 int error;
966
Dave Chinner5a5881c2012-03-22 05:15:13 +0000967 trace_xfs_attr_leaf_split(state->args);
968
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969 /*
970 * Allocate space for a new leaf node.
971 */
972 ASSERT(oldblk->magic == XFS_ATTR_LEAF_MAGIC);
973 error = xfs_da_grow_inode(state->args, &blkno);
974 if (error)
975 return(error);
976 error = xfs_attr_leaf_create(state->args, blkno, &newblk->bp);
977 if (error)
978 return(error);
979 newblk->blkno = blkno;
980 newblk->magic = XFS_ATTR_LEAF_MAGIC;
981
982 /*
983 * Rebalance the entries across the two leaves.
984 * NOTE: rebalance() currently depends on the 2nd block being empty.
985 */
986 xfs_attr_leaf_rebalance(state, oldblk, newblk);
987 error = xfs_da_blk_link(state, oldblk, newblk);
988 if (error)
989 return(error);
990
991 /*
992 * Save info on "old" attribute for "atomic rename" ops, leaf_add()
993 * modifies the index/blkno/rmtblk/rmtblkcnt fields to show the
994 * "new" attrs info. Will need the "old" info to remove it later.
995 *
996 * Insert the "new" entry in the correct block.
997 */
Dave Chinner5a5881c2012-03-22 05:15:13 +0000998 if (state->inleaf) {
999 trace_xfs_attr_leaf_add_old(state->args);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 error = xfs_attr_leaf_add(oldblk->bp, state->args);
Dave Chinner5a5881c2012-03-22 05:15:13 +00001001 } else {
1002 trace_xfs_attr_leaf_add_new(state->args);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 error = xfs_attr_leaf_add(newblk->bp, state->args);
Dave Chinner5a5881c2012-03-22 05:15:13 +00001004 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005
1006 /*
1007 * Update last hashval in each block since we added the name.
1008 */
1009 oldblk->hashval = xfs_attr_leaf_lasthash(oldblk->bp, NULL);
1010 newblk->hashval = xfs_attr_leaf_lasthash(newblk->bp, NULL);
1011 return(error);
1012}
1013
1014/*
1015 * Add a name to the leaf attribute list structure.
1016 */
1017int
1018xfs_attr_leaf_add(xfs_dabuf_t *bp, xfs_da_args_t *args)
1019{
1020 xfs_attr_leafblock_t *leaf;
1021 xfs_attr_leaf_hdr_t *hdr;
1022 xfs_attr_leaf_map_t *map;
1023 int tablesize, entsize, sum, tmp, i;
1024
Dave Chinner5a5881c2012-03-22 05:15:13 +00001025 trace_xfs_attr_leaf_add(args);
1026
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 leaf = bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02001028 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 ASSERT((args->index >= 0)
Nathan Scott918ae422006-03-17 17:28:54 +11001030 && (args->index <= be16_to_cpu(leaf->hdr.count)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 hdr = &leaf->hdr;
Nathan Scottaa82daa2005-11-02 10:33:33 +11001032 entsize = xfs_attr_leaf_newentsize(args->namelen, args->valuelen,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 args->trans->t_mountp->m_sb.sb_blocksize, NULL);
1034
1035 /*
1036 * Search through freemap for first-fit on new name length.
1037 * (may need to figure in size of entry struct too)
1038 */
Nathan Scott918ae422006-03-17 17:28:54 +11001039 tablesize = (be16_to_cpu(hdr->count) + 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 * sizeof(xfs_attr_leaf_entry_t)
1041 + sizeof(xfs_attr_leaf_hdr_t);
1042 map = &hdr->freemap[XFS_ATTR_LEAF_MAPSIZE-1];
1043 for (sum = 0, i = XFS_ATTR_LEAF_MAPSIZE-1; i >= 0; map--, i--) {
Nathan Scott918ae422006-03-17 17:28:54 +11001044 if (tablesize > be16_to_cpu(hdr->firstused)) {
1045 sum += be16_to_cpu(map->size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 continue;
1047 }
1048 if (!map->size)
1049 continue; /* no space in this map */
1050 tmp = entsize;
Nathan Scott918ae422006-03-17 17:28:54 +11001051 if (be16_to_cpu(map->base) < be16_to_cpu(hdr->firstused))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 tmp += sizeof(xfs_attr_leaf_entry_t);
Nathan Scott918ae422006-03-17 17:28:54 +11001053 if (be16_to_cpu(map->size) >= tmp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054 tmp = xfs_attr_leaf_add_work(bp, args, i);
1055 return(tmp);
1056 }
Nathan Scott918ae422006-03-17 17:28:54 +11001057 sum += be16_to_cpu(map->size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058 }
1059
1060 /*
1061 * If there are no holes in the address space of the block,
1062 * and we don't have enough freespace, then compaction will do us
1063 * no good and we should just give up.
1064 */
1065 if (!hdr->holes && (sum < entsize))
1066 return(XFS_ERROR(ENOSPC));
1067
1068 /*
1069 * Compact the entries to coalesce free space.
1070 * This may change the hdr->count via dropping INCOMPLETE entries.
1071 */
1072 xfs_attr_leaf_compact(args->trans, bp);
1073
1074 /*
1075 * After compaction, the block is guaranteed to have only one
1076 * free region, in freemap[0]. If it is not big enough, give up.
1077 */
Nathan Scott918ae422006-03-17 17:28:54 +11001078 if (be16_to_cpu(hdr->freemap[0].size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 < (entsize + sizeof(xfs_attr_leaf_entry_t)))
1080 return(XFS_ERROR(ENOSPC));
1081
1082 return(xfs_attr_leaf_add_work(bp, args, 0));
1083}
1084
1085/*
1086 * Add a name to a leaf attribute list structure.
1087 */
1088STATIC int
1089xfs_attr_leaf_add_work(xfs_dabuf_t *bp, xfs_da_args_t *args, int mapindex)
1090{
1091 xfs_attr_leafblock_t *leaf;
1092 xfs_attr_leaf_hdr_t *hdr;
1093 xfs_attr_leaf_entry_t *entry;
1094 xfs_attr_leaf_name_local_t *name_loc;
1095 xfs_attr_leaf_name_remote_t *name_rmt;
1096 xfs_attr_leaf_map_t *map;
1097 xfs_mount_t *mp;
1098 int tmp, i;
1099
1100 leaf = bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02001101 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 hdr = &leaf->hdr;
1103 ASSERT((mapindex >= 0) && (mapindex < XFS_ATTR_LEAF_MAPSIZE));
Nathan Scott918ae422006-03-17 17:28:54 +11001104 ASSERT((args->index >= 0) && (args->index <= be16_to_cpu(hdr->count)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105
1106 /*
1107 * Force open some space in the entry array and fill it in.
1108 */
1109 entry = &leaf->entries[args->index];
Nathan Scott918ae422006-03-17 17:28:54 +11001110 if (args->index < be16_to_cpu(hdr->count)) {
1111 tmp = be16_to_cpu(hdr->count) - args->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112 tmp *= sizeof(xfs_attr_leaf_entry_t);
1113 memmove((char *)(entry+1), (char *)entry, tmp);
1114 xfs_da_log_buf(args->trans, bp,
1115 XFS_DA_LOGRANGE(leaf, entry, tmp + sizeof(*entry)));
1116 }
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001117 be16_add_cpu(&hdr->count, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118
1119 /*
1120 * Allocate space for the new string (at the end of the run).
1121 */
1122 map = &hdr->freemap[mapindex];
1123 mp = args->trans->t_mountp;
Nathan Scott918ae422006-03-17 17:28:54 +11001124 ASSERT(be16_to_cpu(map->base) < XFS_LBSIZE(mp));
1125 ASSERT((be16_to_cpu(map->base) & 0x3) == 0);
1126 ASSERT(be16_to_cpu(map->size) >=
Nathan Scottaa82daa2005-11-02 10:33:33 +11001127 xfs_attr_leaf_newentsize(args->namelen, args->valuelen,
1128 mp->m_sb.sb_blocksize, NULL));
Nathan Scott918ae422006-03-17 17:28:54 +11001129 ASSERT(be16_to_cpu(map->size) < XFS_LBSIZE(mp));
1130 ASSERT((be16_to_cpu(map->size) & 0x3) == 0);
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001131 be16_add_cpu(&map->size,
Nathan Scottaa82daa2005-11-02 10:33:33 +11001132 -xfs_attr_leaf_newentsize(args->namelen, args->valuelen,
1133 mp->m_sb.sb_blocksize, &tmp));
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001134 entry->nameidx = cpu_to_be16(be16_to_cpu(map->base) +
1135 be16_to_cpu(map->size));
1136 entry->hashval = cpu_to_be32(args->hashval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 entry->flags = tmp ? XFS_ATTR_LOCAL : 0;
Tim Shimmin726801b2006-09-28 11:01:37 +10001138 entry->flags |= XFS_ATTR_NSP_ARGS_TO_ONDISK(args->flags);
Barry Naujok6a178102008-05-21 16:42:05 +10001139 if (args->op_flags & XFS_DA_OP_RENAME) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 entry->flags |= XFS_ATTR_INCOMPLETE;
1141 if ((args->blkno2 == args->blkno) &&
1142 (args->index2 <= args->index)) {
1143 args->index2++;
1144 }
1145 }
1146 xfs_da_log_buf(args->trans, bp,
1147 XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001148 ASSERT((args->index == 0) ||
1149 (be32_to_cpu(entry->hashval) >= be32_to_cpu((entry-1)->hashval)));
Nathan Scott918ae422006-03-17 17:28:54 +11001150 ASSERT((args->index == be16_to_cpu(hdr->count)-1) ||
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001151 (be32_to_cpu(entry->hashval) <= be32_to_cpu((entry+1)->hashval)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152
1153 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 * For "remote" attribute values, simply note that we need to
1155 * allocate space for the "remote" value. We can't actually
1156 * allocate the extents in this transaction, and we can't decide
1157 * which blocks they should be as we might allocate more blocks
1158 * as part of this transaction (a split operation for example).
1159 */
1160 if (entry->flags & XFS_ATTR_LOCAL) {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06001161 name_loc = xfs_attr_leaf_name_local(leaf, args->index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 name_loc->namelen = args->namelen;
Nathan Scott053b5752006-03-17 17:29:09 +11001163 name_loc->valuelen = cpu_to_be16(args->valuelen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164 memcpy((char *)name_loc->nameval, args->name, args->namelen);
1165 memcpy((char *)&name_loc->nameval[args->namelen], args->value,
Nathan Scott053b5752006-03-17 17:29:09 +11001166 be16_to_cpu(name_loc->valuelen));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167 } else {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06001168 name_rmt = xfs_attr_leaf_name_remote(leaf, args->index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169 name_rmt->namelen = args->namelen;
1170 memcpy((char *)name_rmt->name, args->name, args->namelen);
1171 entry->flags |= XFS_ATTR_INCOMPLETE;
1172 /* just in case */
1173 name_rmt->valuelen = 0;
1174 name_rmt->valueblk = 0;
1175 args->rmtblkno = 1;
1176 args->rmtblkcnt = XFS_B_TO_FSB(mp, args->valuelen);
1177 }
1178 xfs_da_log_buf(args->trans, bp,
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06001179 XFS_DA_LOGRANGE(leaf, xfs_attr_leaf_name(leaf, args->index),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180 xfs_attr_leaf_entsize(leaf, args->index)));
1181
1182 /*
1183 * Update the control info for this leaf node
1184 */
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001185 if (be16_to_cpu(entry->nameidx) < be16_to_cpu(hdr->firstused)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 /* both on-disk, don't endian-flip twice */
1187 hdr->firstused = entry->nameidx;
1188 }
Nathan Scott918ae422006-03-17 17:28:54 +11001189 ASSERT(be16_to_cpu(hdr->firstused) >=
1190 ((be16_to_cpu(hdr->count) * sizeof(*entry)) + sizeof(*hdr)));
1191 tmp = (be16_to_cpu(hdr->count)-1) * sizeof(xfs_attr_leaf_entry_t)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192 + sizeof(xfs_attr_leaf_hdr_t);
1193 map = &hdr->freemap[0];
1194 for (i = 0; i < XFS_ATTR_LEAF_MAPSIZE; map++, i++) {
Nathan Scott918ae422006-03-17 17:28:54 +11001195 if (be16_to_cpu(map->base) == tmp) {
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001196 be16_add_cpu(&map->base, sizeof(xfs_attr_leaf_entry_t));
1197 be16_add_cpu(&map->size,
Nathan Scott918ae422006-03-17 17:28:54 +11001198 -((int)sizeof(xfs_attr_leaf_entry_t)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 }
1200 }
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001201 be16_add_cpu(&hdr->usedbytes, xfs_attr_leaf_entsize(leaf, args->index));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 xfs_da_log_buf(args->trans, bp,
1203 XFS_DA_LOGRANGE(leaf, hdr, sizeof(*hdr)));
1204 return(0);
1205}
1206
1207/*
1208 * Garbage collect a leaf attribute list block by copying it to a new buffer.
1209 */
1210STATIC void
1211xfs_attr_leaf_compact(xfs_trans_t *trans, xfs_dabuf_t *bp)
1212{
1213 xfs_attr_leafblock_t *leaf_s, *leaf_d;
1214 xfs_attr_leaf_hdr_t *hdr_s, *hdr_d;
1215 xfs_mount_t *mp;
1216 char *tmpbuffer;
1217
1218 mp = trans->t_mountp;
1219 tmpbuffer = kmem_alloc(XFS_LBSIZE(mp), KM_SLEEP);
1220 ASSERT(tmpbuffer != NULL);
1221 memcpy(tmpbuffer, bp->data, XFS_LBSIZE(mp));
1222 memset(bp->data, 0, XFS_LBSIZE(mp));
1223
1224 /*
1225 * Copy basic information
1226 */
1227 leaf_s = (xfs_attr_leafblock_t *)tmpbuffer;
1228 leaf_d = bp->data;
1229 hdr_s = &leaf_s->hdr;
1230 hdr_d = &leaf_d->hdr;
1231 hdr_d->info = hdr_s->info; /* struct copy */
Nathan Scott918ae422006-03-17 17:28:54 +11001232 hdr_d->firstused = cpu_to_be16(XFS_LBSIZE(mp));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 /* handle truncation gracefully */
1234 if (!hdr_d->firstused) {
Nathan Scott918ae422006-03-17 17:28:54 +11001235 hdr_d->firstused = cpu_to_be16(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236 XFS_LBSIZE(mp) - XFS_ATTR_LEAF_NAME_ALIGN);
1237 }
1238 hdr_d->usedbytes = 0;
1239 hdr_d->count = 0;
1240 hdr_d->holes = 0;
Nathan Scott918ae422006-03-17 17:28:54 +11001241 hdr_d->freemap[0].base = cpu_to_be16(sizeof(xfs_attr_leaf_hdr_t));
1242 hdr_d->freemap[0].size = cpu_to_be16(be16_to_cpu(hdr_d->firstused) -
1243 sizeof(xfs_attr_leaf_hdr_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244
1245 /*
1246 * Copy all entry's in the same (sorted) order,
1247 * but allocate name/value pairs packed and in sequence.
1248 */
1249 xfs_attr_leaf_moveents(leaf_s, 0, leaf_d, 0,
Nathan Scott918ae422006-03-17 17:28:54 +11001250 be16_to_cpu(hdr_s->count), mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251 xfs_da_log_buf(trans, bp, 0, XFS_LBSIZE(mp) - 1);
1252
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10001253 kmem_free(tmpbuffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254}
1255
1256/*
1257 * Redistribute the attribute list entries between two leaf nodes,
1258 * taking into account the size of the new entry.
1259 *
1260 * NOTE: if new block is empty, then it will get the upper half of the
1261 * old block. At present, all (one) callers pass in an empty second block.
1262 *
1263 * This code adjusts the args->index/blkno and args->index2/blkno2 fields
1264 * to match what it is doing in splitting the attribute leaf block. Those
1265 * values are used in "atomic rename" operations on attributes. Note that
1266 * the "new" and "old" values can end up in different blocks.
1267 */
1268STATIC void
1269xfs_attr_leaf_rebalance(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
1270 xfs_da_state_blk_t *blk2)
1271{
1272 xfs_da_args_t *args;
1273 xfs_da_state_blk_t *tmp_blk;
1274 xfs_attr_leafblock_t *leaf1, *leaf2;
1275 xfs_attr_leaf_hdr_t *hdr1, *hdr2;
1276 int count, totallen, max, space, swap;
1277
1278 /*
1279 * Set up environment.
1280 */
1281 ASSERT(blk1->magic == XFS_ATTR_LEAF_MAGIC);
1282 ASSERT(blk2->magic == XFS_ATTR_LEAF_MAGIC);
1283 leaf1 = blk1->bp->data;
1284 leaf2 = blk2->bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02001285 ASSERT(leaf1->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1286 ASSERT(leaf2->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287 args = state->args;
1288
Dave Chinner5a5881c2012-03-22 05:15:13 +00001289 trace_xfs_attr_leaf_rebalance(args);
1290
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291 /*
1292 * Check ordering of blocks, reverse if it makes things simpler.
1293 *
1294 * NOTE: Given that all (current) callers pass in an empty
1295 * second block, this code should never set "swap".
1296 */
1297 swap = 0;
1298 if (xfs_attr_leaf_order(blk1->bp, blk2->bp)) {
1299 tmp_blk = blk1;
1300 blk1 = blk2;
1301 blk2 = tmp_blk;
1302 leaf1 = blk1->bp->data;
1303 leaf2 = blk2->bp->data;
1304 swap = 1;
1305 }
1306 hdr1 = &leaf1->hdr;
1307 hdr2 = &leaf2->hdr;
1308
1309 /*
1310 * Examine entries until we reduce the absolute difference in
1311 * byte usage between the two blocks to a minimum. Then get
1312 * the direction to copy and the number of elements to move.
1313 *
1314 * "inleaf" is true if the new entry should be inserted into blk1.
1315 * If "swap" is also true, then reverse the sense of "inleaf".
1316 */
1317 state->inleaf = xfs_attr_leaf_figure_balance(state, blk1, blk2,
1318 &count, &totallen);
1319 if (swap)
1320 state->inleaf = !state->inleaf;
1321
1322 /*
1323 * Move any entries required from leaf to leaf:
1324 */
Nathan Scott918ae422006-03-17 17:28:54 +11001325 if (count < be16_to_cpu(hdr1->count)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 /*
1327 * Figure the total bytes to be added to the destination leaf.
1328 */
1329 /* number entries being moved */
Nathan Scott918ae422006-03-17 17:28:54 +11001330 count = be16_to_cpu(hdr1->count) - count;
1331 space = be16_to_cpu(hdr1->usedbytes) - totallen;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332 space += count * sizeof(xfs_attr_leaf_entry_t);
1333
1334 /*
1335 * leaf2 is the destination, compact it if it looks tight.
1336 */
Nathan Scott918ae422006-03-17 17:28:54 +11001337 max = be16_to_cpu(hdr2->firstused)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 - sizeof(xfs_attr_leaf_hdr_t);
Nathan Scott918ae422006-03-17 17:28:54 +11001339 max -= be16_to_cpu(hdr2->count) * sizeof(xfs_attr_leaf_entry_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340 if (space > max) {
1341 xfs_attr_leaf_compact(args->trans, blk2->bp);
1342 }
1343
1344 /*
1345 * Move high entries from leaf1 to low end of leaf2.
1346 */
Nathan Scott918ae422006-03-17 17:28:54 +11001347 xfs_attr_leaf_moveents(leaf1, be16_to_cpu(hdr1->count) - count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348 leaf2, 0, count, state->mp);
1349
1350 xfs_da_log_buf(args->trans, blk1->bp, 0, state->blocksize-1);
1351 xfs_da_log_buf(args->trans, blk2->bp, 0, state->blocksize-1);
Nathan Scott918ae422006-03-17 17:28:54 +11001352 } else if (count > be16_to_cpu(hdr1->count)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353 /*
1354 * I assert that since all callers pass in an empty
1355 * second buffer, this code should never execute.
1356 */
1357
1358 /*
1359 * Figure the total bytes to be added to the destination leaf.
1360 */
1361 /* number entries being moved */
Nathan Scott918ae422006-03-17 17:28:54 +11001362 count -= be16_to_cpu(hdr1->count);
1363 space = totallen - be16_to_cpu(hdr1->usedbytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364 space += count * sizeof(xfs_attr_leaf_entry_t);
1365
1366 /*
1367 * leaf1 is the destination, compact it if it looks tight.
1368 */
Nathan Scott918ae422006-03-17 17:28:54 +11001369 max = be16_to_cpu(hdr1->firstused)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 - sizeof(xfs_attr_leaf_hdr_t);
Nathan Scott918ae422006-03-17 17:28:54 +11001371 max -= be16_to_cpu(hdr1->count) * sizeof(xfs_attr_leaf_entry_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 if (space > max) {
1373 xfs_attr_leaf_compact(args->trans, blk1->bp);
1374 }
1375
1376 /*
1377 * Move low entries from leaf2 to high end of leaf1.
1378 */
1379 xfs_attr_leaf_moveents(leaf2, 0, leaf1,
Nathan Scott918ae422006-03-17 17:28:54 +11001380 be16_to_cpu(hdr1->count), count, state->mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381
1382 xfs_da_log_buf(args->trans, blk1->bp, 0, state->blocksize-1);
1383 xfs_da_log_buf(args->trans, blk2->bp, 0, state->blocksize-1);
1384 }
1385
1386 /*
1387 * Copy out last hashval in each block for B-tree code.
1388 */
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001389 blk1->hashval = be32_to_cpu(
1390 leaf1->entries[be16_to_cpu(leaf1->hdr.count)-1].hashval);
1391 blk2->hashval = be32_to_cpu(
1392 leaf2->entries[be16_to_cpu(leaf2->hdr.count)-1].hashval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393
1394 /*
1395 * Adjust the expected index for insertion.
1396 * NOTE: this code depends on the (current) situation that the
1397 * second block was originally empty.
1398 *
1399 * If the insertion point moved to the 2nd block, we must adjust
1400 * the index. We must also track the entry just following the
1401 * new entry for use in an "atomic rename" operation, that entry
1402 * is always the "old" entry and the "new" entry is what we are
1403 * inserting. The index/blkno fields refer to the "old" entry,
1404 * while the index2/blkno2 fields refer to the "new" entry.
1405 */
Nathan Scott918ae422006-03-17 17:28:54 +11001406 if (blk1->index > be16_to_cpu(leaf1->hdr.count)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 ASSERT(state->inleaf == 0);
Nathan Scott918ae422006-03-17 17:28:54 +11001408 blk2->index = blk1->index - be16_to_cpu(leaf1->hdr.count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409 args->index = args->index2 = blk2->index;
1410 args->blkno = args->blkno2 = blk2->blkno;
Nathan Scott918ae422006-03-17 17:28:54 +11001411 } else if (blk1->index == be16_to_cpu(leaf1->hdr.count)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412 if (state->inleaf) {
1413 args->index = blk1->index;
1414 args->blkno = blk1->blkno;
1415 args->index2 = 0;
1416 args->blkno2 = blk2->blkno;
1417 } else {
1418 blk2->index = blk1->index
Nathan Scott918ae422006-03-17 17:28:54 +11001419 - be16_to_cpu(leaf1->hdr.count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 args->index = args->index2 = blk2->index;
1421 args->blkno = args->blkno2 = blk2->blkno;
1422 }
1423 } else {
1424 ASSERT(state->inleaf == 1);
1425 args->index = args->index2 = blk1->index;
1426 args->blkno = args->blkno2 = blk1->blkno;
1427 }
1428}
1429
1430/*
1431 * Examine entries until we reduce the absolute difference in
1432 * byte usage between the two blocks to a minimum.
1433 * GROT: Is this really necessary? With other than a 512 byte blocksize,
1434 * GROT: there will always be enough room in either block for a new entry.
1435 * GROT: Do a double-split for this case?
1436 */
1437STATIC int
1438xfs_attr_leaf_figure_balance(xfs_da_state_t *state,
1439 xfs_da_state_blk_t *blk1,
1440 xfs_da_state_blk_t *blk2,
1441 int *countarg, int *usedbytesarg)
1442{
1443 xfs_attr_leafblock_t *leaf1, *leaf2;
1444 xfs_attr_leaf_hdr_t *hdr1, *hdr2;
1445 xfs_attr_leaf_entry_t *entry;
1446 int count, max, index, totallen, half;
1447 int lastdelta, foundit, tmp;
1448
1449 /*
1450 * Set up environment.
1451 */
1452 leaf1 = blk1->bp->data;
1453 leaf2 = blk2->bp->data;
1454 hdr1 = &leaf1->hdr;
1455 hdr2 = &leaf2->hdr;
1456 foundit = 0;
1457 totallen = 0;
1458
1459 /*
1460 * Examine entries until we reduce the absolute difference in
1461 * byte usage between the two blocks to a minimum.
1462 */
Nathan Scott918ae422006-03-17 17:28:54 +11001463 max = be16_to_cpu(hdr1->count) + be16_to_cpu(hdr2->count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464 half = (max+1) * sizeof(*entry);
Nathan Scott918ae422006-03-17 17:28:54 +11001465 half += be16_to_cpu(hdr1->usedbytes) +
1466 be16_to_cpu(hdr2->usedbytes) +
1467 xfs_attr_leaf_newentsize(
1468 state->args->namelen,
1469 state->args->valuelen,
1470 state->blocksize, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471 half /= 2;
1472 lastdelta = state->blocksize;
1473 entry = &leaf1->entries[0];
1474 for (count = index = 0; count < max; entry++, index++, count++) {
1475
1476#define XFS_ATTR_ABS(A) (((A) < 0) ? -(A) : (A))
1477 /*
1478 * The new entry is in the first block, account for it.
1479 */
1480 if (count == blk1->index) {
1481 tmp = totallen + sizeof(*entry) +
Nathan Scottaa82daa2005-11-02 10:33:33 +11001482 xfs_attr_leaf_newentsize(
1483 state->args->namelen,
1484 state->args->valuelen,
1485 state->blocksize, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 if (XFS_ATTR_ABS(half - tmp) > lastdelta)
1487 break;
1488 lastdelta = XFS_ATTR_ABS(half - tmp);
1489 totallen = tmp;
1490 foundit = 1;
1491 }
1492
1493 /*
1494 * Wrap around into the second block if necessary.
1495 */
Nathan Scott918ae422006-03-17 17:28:54 +11001496 if (count == be16_to_cpu(hdr1->count)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 leaf1 = leaf2;
1498 entry = &leaf1->entries[0];
1499 index = 0;
1500 }
1501
1502 /*
1503 * Figure out if next leaf entry would be too much.
1504 */
1505 tmp = totallen + sizeof(*entry) + xfs_attr_leaf_entsize(leaf1,
1506 index);
1507 if (XFS_ATTR_ABS(half - tmp) > lastdelta)
1508 break;
1509 lastdelta = XFS_ATTR_ABS(half - tmp);
1510 totallen = tmp;
1511#undef XFS_ATTR_ABS
1512 }
1513
1514 /*
1515 * Calculate the number of usedbytes that will end up in lower block.
1516 * If new entry not in lower block, fix up the count.
1517 */
1518 totallen -= count * sizeof(*entry);
1519 if (foundit) {
1520 totallen -= sizeof(*entry) +
Nathan Scottaa82daa2005-11-02 10:33:33 +11001521 xfs_attr_leaf_newentsize(
1522 state->args->namelen,
1523 state->args->valuelen,
1524 state->blocksize, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525 }
1526
1527 *countarg = count;
1528 *usedbytesarg = totallen;
1529 return(foundit);
1530}
1531
1532/*========================================================================
1533 * Routines used for shrinking the Btree.
1534 *========================================================================*/
1535
1536/*
1537 * Check a leaf block and its neighbors to see if the block should be
1538 * collapsed into one or the other neighbor. Always keep the block
1539 * with the smaller block number.
1540 * If the current block is over 50% full, don't try to join it, return 0.
1541 * If the block is empty, fill in the state structure and return 2.
1542 * If it can be collapsed, fill in the state structure and return 1.
1543 * If nothing can be done, return 0.
1544 *
1545 * GROT: allow for INCOMPLETE entries in calculation.
1546 */
1547int
1548xfs_attr_leaf_toosmall(xfs_da_state_t *state, int *action)
1549{
1550 xfs_attr_leafblock_t *leaf;
1551 xfs_da_state_blk_t *blk;
1552 xfs_da_blkinfo_t *info;
1553 int count, bytes, forward, error, retval, i;
1554 xfs_dablk_t blkno;
1555 xfs_dabuf_t *bp;
1556
1557 /*
1558 * Check for the degenerate case of the block being over 50% full.
1559 * If so, it's not worth even looking to see if we might be able
1560 * to coalesce with a sibling.
1561 */
1562 blk = &state->path.blk[ state->path.active-1 ];
1563 info = blk->bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02001564 ASSERT(info->magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565 leaf = (xfs_attr_leafblock_t *)info;
Nathan Scott918ae422006-03-17 17:28:54 +11001566 count = be16_to_cpu(leaf->hdr.count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567 bytes = sizeof(xfs_attr_leaf_hdr_t) +
1568 count * sizeof(xfs_attr_leaf_entry_t) +
Nathan Scott918ae422006-03-17 17:28:54 +11001569 be16_to_cpu(leaf->hdr.usedbytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570 if (bytes > (state->blocksize >> 1)) {
1571 *action = 0; /* blk over 50%, don't try to join */
1572 return(0);
1573 }
1574
1575 /*
1576 * Check for the degenerate case of the block being empty.
1577 * If the block is empty, we'll simply delete it, no need to
Nathan Scottc41564b2006-03-29 08:55:14 +10001578 * coalesce it with a sibling block. We choose (arbitrarily)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579 * to merge with the forward block unless it is NULL.
1580 */
1581 if (count == 0) {
1582 /*
1583 * Make altpath point to the block we want to keep and
1584 * path point to the block we want to drop (this one).
1585 */
Nathan Scott89da0542006-03-17 17:28:40 +11001586 forward = (info->forw != 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 memcpy(&state->altpath, &state->path, sizeof(state->path));
1588 error = xfs_da_path_shift(state, &state->altpath, forward,
1589 0, &retval);
1590 if (error)
1591 return(error);
1592 if (retval) {
1593 *action = 0;
1594 } else {
1595 *action = 2;
1596 }
1597 return(0);
1598 }
1599
1600 /*
1601 * Examine each sibling block to see if we can coalesce with
1602 * at least 25% free space to spare. We need to figure out
1603 * whether to merge with the forward or the backward block.
1604 * We prefer coalescing with the lower numbered sibling so as
1605 * to shrink an attribute list over time.
1606 */
1607 /* start with smaller blk num */
Nathan Scott89da0542006-03-17 17:28:40 +11001608 forward = (be32_to_cpu(info->forw) < be32_to_cpu(info->back));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609 for (i = 0; i < 2; forward = !forward, i++) {
1610 if (forward)
Nathan Scott89da0542006-03-17 17:28:40 +11001611 blkno = be32_to_cpu(info->forw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612 else
Nathan Scott89da0542006-03-17 17:28:40 +11001613 blkno = be32_to_cpu(info->back);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614 if (blkno == 0)
1615 continue;
1616 error = xfs_da_read_buf(state->args->trans, state->args->dp,
1617 blkno, -1, &bp, XFS_ATTR_FORK);
1618 if (error)
1619 return(error);
1620 ASSERT(bp != NULL);
1621
1622 leaf = (xfs_attr_leafblock_t *)info;
Nathan Scott918ae422006-03-17 17:28:54 +11001623 count = be16_to_cpu(leaf->hdr.count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624 bytes = state->blocksize - (state->blocksize>>2);
Nathan Scott918ae422006-03-17 17:28:54 +11001625 bytes -= be16_to_cpu(leaf->hdr.usedbytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626 leaf = bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02001627 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Nathan Scott918ae422006-03-17 17:28:54 +11001628 count += be16_to_cpu(leaf->hdr.count);
1629 bytes -= be16_to_cpu(leaf->hdr.usedbytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630 bytes -= count * sizeof(xfs_attr_leaf_entry_t);
1631 bytes -= sizeof(xfs_attr_leaf_hdr_t);
1632 xfs_da_brelse(state->args->trans, bp);
1633 if (bytes >= 0)
1634 break; /* fits with at least 25% to spare */
1635 }
1636 if (i >= 2) {
1637 *action = 0;
1638 return(0);
1639 }
1640
1641 /*
1642 * Make altpath point to the block we want to keep (the lower
1643 * numbered block) and path point to the block we want to drop.
1644 */
1645 memcpy(&state->altpath, &state->path, sizeof(state->path));
1646 if (blkno < blk->blkno) {
1647 error = xfs_da_path_shift(state, &state->altpath, forward,
1648 0, &retval);
1649 } else {
1650 error = xfs_da_path_shift(state, &state->path, forward,
1651 0, &retval);
1652 }
1653 if (error)
1654 return(error);
1655 if (retval) {
1656 *action = 0;
1657 } else {
1658 *action = 1;
1659 }
1660 return(0);
1661}
1662
1663/*
1664 * Remove a name from the leaf attribute list structure.
1665 *
1666 * Return 1 if leaf is less than 37% full, 0 if >= 37% full.
1667 * If two leaves are 37% full, when combined they will leave 25% free.
1668 */
1669int
1670xfs_attr_leaf_remove(xfs_dabuf_t *bp, xfs_da_args_t *args)
1671{
1672 xfs_attr_leafblock_t *leaf;
1673 xfs_attr_leaf_hdr_t *hdr;
1674 xfs_attr_leaf_map_t *map;
1675 xfs_attr_leaf_entry_t *entry;
1676 int before, after, smallest, entsize;
1677 int tablesize, tmp, i;
1678 xfs_mount_t *mp;
1679
1680 leaf = bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02001681 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682 hdr = &leaf->hdr;
1683 mp = args->trans->t_mountp;
Nathan Scott918ae422006-03-17 17:28:54 +11001684 ASSERT((be16_to_cpu(hdr->count) > 0)
1685 && (be16_to_cpu(hdr->count) < (XFS_LBSIZE(mp)/8)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686 ASSERT((args->index >= 0)
Nathan Scott918ae422006-03-17 17:28:54 +11001687 && (args->index < be16_to_cpu(hdr->count)));
1688 ASSERT(be16_to_cpu(hdr->firstused) >=
1689 ((be16_to_cpu(hdr->count) * sizeof(*entry)) + sizeof(*hdr)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001690 entry = &leaf->entries[args->index];
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001691 ASSERT(be16_to_cpu(entry->nameidx) >= be16_to_cpu(hdr->firstused));
1692 ASSERT(be16_to_cpu(entry->nameidx) < XFS_LBSIZE(mp));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693
1694 /*
1695 * Scan through free region table:
1696 * check for adjacency of free'd entry with an existing one,
1697 * find smallest free region in case we need to replace it,
1698 * adjust any map that borders the entry table,
1699 */
Nathan Scott918ae422006-03-17 17:28:54 +11001700 tablesize = be16_to_cpu(hdr->count) * sizeof(xfs_attr_leaf_entry_t)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701 + sizeof(xfs_attr_leaf_hdr_t);
1702 map = &hdr->freemap[0];
Nathan Scott918ae422006-03-17 17:28:54 +11001703 tmp = be16_to_cpu(map->size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 before = after = -1;
1705 smallest = XFS_ATTR_LEAF_MAPSIZE - 1;
1706 entsize = xfs_attr_leaf_entsize(leaf, args->index);
1707 for (i = 0; i < XFS_ATTR_LEAF_MAPSIZE; map++, i++) {
Nathan Scott918ae422006-03-17 17:28:54 +11001708 ASSERT(be16_to_cpu(map->base) < XFS_LBSIZE(mp));
1709 ASSERT(be16_to_cpu(map->size) < XFS_LBSIZE(mp));
1710 if (be16_to_cpu(map->base) == tablesize) {
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001711 be16_add_cpu(&map->base,
Nathan Scott918ae422006-03-17 17:28:54 +11001712 -((int)sizeof(xfs_attr_leaf_entry_t)));
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001713 be16_add_cpu(&map->size, sizeof(xfs_attr_leaf_entry_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714 }
1715
Nathan Scott918ae422006-03-17 17:28:54 +11001716 if ((be16_to_cpu(map->base) + be16_to_cpu(map->size))
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001717 == be16_to_cpu(entry->nameidx)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718 before = i;
Nathan Scott918ae422006-03-17 17:28:54 +11001719 } else if (be16_to_cpu(map->base)
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001720 == (be16_to_cpu(entry->nameidx) + entsize)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721 after = i;
Nathan Scott918ae422006-03-17 17:28:54 +11001722 } else if (be16_to_cpu(map->size) < tmp) {
1723 tmp = be16_to_cpu(map->size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724 smallest = i;
1725 }
1726 }
1727
1728 /*
1729 * Coalesce adjacent freemap regions,
1730 * or replace the smallest region.
1731 */
1732 if ((before >= 0) || (after >= 0)) {
1733 if ((before >= 0) && (after >= 0)) {
1734 map = &hdr->freemap[before];
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001735 be16_add_cpu(&map->size, entsize);
1736 be16_add_cpu(&map->size,
Nathan Scott918ae422006-03-17 17:28:54 +11001737 be16_to_cpu(hdr->freemap[after].size));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738 hdr->freemap[after].base = 0;
1739 hdr->freemap[after].size = 0;
1740 } else if (before >= 0) {
1741 map = &hdr->freemap[before];
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001742 be16_add_cpu(&map->size, entsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743 } else {
1744 map = &hdr->freemap[after];
1745 /* both on-disk, don't endian flip twice */
1746 map->base = entry->nameidx;
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001747 be16_add_cpu(&map->size, entsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748 }
1749 } else {
1750 /*
1751 * Replace smallest region (if it is smaller than free'd entry)
1752 */
1753 map = &hdr->freemap[smallest];
Nathan Scott918ae422006-03-17 17:28:54 +11001754 if (be16_to_cpu(map->size) < entsize) {
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001755 map->base = cpu_to_be16(be16_to_cpu(entry->nameidx));
Nathan Scott918ae422006-03-17 17:28:54 +11001756 map->size = cpu_to_be16(entsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 }
1758 }
1759
1760 /*
1761 * Did we remove the first entry?
1762 */
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001763 if (be16_to_cpu(entry->nameidx) == be16_to_cpu(hdr->firstused))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764 smallest = 1;
1765 else
1766 smallest = 0;
1767
1768 /*
1769 * Compress the remaining entries and zero out the removed stuff.
1770 */
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06001771 memset(xfs_attr_leaf_name(leaf, args->index), 0, entsize);
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001772 be16_add_cpu(&hdr->usedbytes, -entsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773 xfs_da_log_buf(args->trans, bp,
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06001774 XFS_DA_LOGRANGE(leaf, xfs_attr_leaf_name(leaf, args->index),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775 entsize));
1776
Nathan Scott918ae422006-03-17 17:28:54 +11001777 tmp = (be16_to_cpu(hdr->count) - args->index)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 * sizeof(xfs_attr_leaf_entry_t);
1779 memmove((char *)entry, (char *)(entry+1), tmp);
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001780 be16_add_cpu(&hdr->count, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781 xfs_da_log_buf(args->trans, bp,
1782 XFS_DA_LOGRANGE(leaf, entry, tmp + sizeof(*entry)));
Nathan Scott918ae422006-03-17 17:28:54 +11001783 entry = &leaf->entries[be16_to_cpu(hdr->count)];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784 memset((char *)entry, 0, sizeof(xfs_attr_leaf_entry_t));
1785
1786 /*
1787 * If we removed the first entry, re-find the first used byte
1788 * in the name area. Note that if the entry was the "firstused",
1789 * then we don't have a "hole" in our block resulting from
1790 * removing the name.
1791 */
1792 if (smallest) {
1793 tmp = XFS_LBSIZE(mp);
1794 entry = &leaf->entries[0];
Nathan Scott918ae422006-03-17 17:28:54 +11001795 for (i = be16_to_cpu(hdr->count)-1; i >= 0; entry++, i--) {
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001796 ASSERT(be16_to_cpu(entry->nameidx) >=
1797 be16_to_cpu(hdr->firstused));
1798 ASSERT(be16_to_cpu(entry->nameidx) < XFS_LBSIZE(mp));
1799
1800 if (be16_to_cpu(entry->nameidx) < tmp)
1801 tmp = be16_to_cpu(entry->nameidx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802 }
Nathan Scott918ae422006-03-17 17:28:54 +11001803 hdr->firstused = cpu_to_be16(tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804 if (!hdr->firstused) {
Nathan Scott918ae422006-03-17 17:28:54 +11001805 hdr->firstused = cpu_to_be16(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001806 tmp - XFS_ATTR_LEAF_NAME_ALIGN);
1807 }
1808 } else {
1809 hdr->holes = 1; /* mark as needing compaction */
1810 }
1811 xfs_da_log_buf(args->trans, bp,
1812 XFS_DA_LOGRANGE(leaf, hdr, sizeof(*hdr)));
1813
1814 /*
1815 * Check if leaf is less than 50% full, caller may want to
1816 * "join" the leaf with a sibling if so.
1817 */
1818 tmp = sizeof(xfs_attr_leaf_hdr_t);
Nathan Scott918ae422006-03-17 17:28:54 +11001819 tmp += be16_to_cpu(leaf->hdr.count) * sizeof(xfs_attr_leaf_entry_t);
1820 tmp += be16_to_cpu(leaf->hdr.usedbytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 return(tmp < mp->m_attr_magicpct); /* leaf is < 37% full */
1822}
1823
1824/*
1825 * Move all the attribute list entries from drop_leaf into save_leaf.
1826 */
1827void
1828xfs_attr_leaf_unbalance(xfs_da_state_t *state, xfs_da_state_blk_t *drop_blk,
1829 xfs_da_state_blk_t *save_blk)
1830{
1831 xfs_attr_leafblock_t *drop_leaf, *save_leaf, *tmp_leaf;
1832 xfs_attr_leaf_hdr_t *drop_hdr, *save_hdr, *tmp_hdr;
1833 xfs_mount_t *mp;
1834 char *tmpbuffer;
1835
Dave Chinner5a5881c2012-03-22 05:15:13 +00001836 trace_xfs_attr_leaf_unbalance(state->args);
1837
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838 /*
1839 * Set up environment.
1840 */
1841 mp = state->mp;
1842 ASSERT(drop_blk->magic == XFS_ATTR_LEAF_MAGIC);
1843 ASSERT(save_blk->magic == XFS_ATTR_LEAF_MAGIC);
1844 drop_leaf = drop_blk->bp->data;
1845 save_leaf = save_blk->bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02001846 ASSERT(drop_leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1847 ASSERT(save_leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001848 drop_hdr = &drop_leaf->hdr;
1849 save_hdr = &save_leaf->hdr;
1850
1851 /*
1852 * Save last hashval from dying block for later Btree fixup.
1853 */
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001854 drop_blk->hashval = be32_to_cpu(
1855 drop_leaf->entries[be16_to_cpu(drop_leaf->hdr.count)-1].hashval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856
1857 /*
1858 * Check if we need a temp buffer, or can we do it in place.
1859 * Note that we don't check "leaf" for holes because we will
1860 * always be dropping it, toosmall() decided that for us already.
1861 */
1862 if (save_hdr->holes == 0) {
1863 /*
1864 * dest leaf has no holes, so we add there. May need
1865 * to make some room in the entry array.
1866 */
1867 if (xfs_attr_leaf_order(save_blk->bp, drop_blk->bp)) {
1868 xfs_attr_leaf_moveents(drop_leaf, 0, save_leaf, 0,
Nathan Scott918ae422006-03-17 17:28:54 +11001869 be16_to_cpu(drop_hdr->count), mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 } else {
1871 xfs_attr_leaf_moveents(drop_leaf, 0, save_leaf,
Nathan Scott918ae422006-03-17 17:28:54 +11001872 be16_to_cpu(save_hdr->count),
1873 be16_to_cpu(drop_hdr->count), mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874 }
1875 } else {
1876 /*
1877 * Destination has holes, so we make a temporary copy
1878 * of the leaf and add them both to that.
1879 */
1880 tmpbuffer = kmem_alloc(state->blocksize, KM_SLEEP);
1881 ASSERT(tmpbuffer != NULL);
1882 memset(tmpbuffer, 0, state->blocksize);
1883 tmp_leaf = (xfs_attr_leafblock_t *)tmpbuffer;
1884 tmp_hdr = &tmp_leaf->hdr;
1885 tmp_hdr->info = save_hdr->info; /* struct copy */
1886 tmp_hdr->count = 0;
Nathan Scott918ae422006-03-17 17:28:54 +11001887 tmp_hdr->firstused = cpu_to_be16(state->blocksize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888 if (!tmp_hdr->firstused) {
Nathan Scott918ae422006-03-17 17:28:54 +11001889 tmp_hdr->firstused = cpu_to_be16(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890 state->blocksize - XFS_ATTR_LEAF_NAME_ALIGN);
1891 }
1892 tmp_hdr->usedbytes = 0;
1893 if (xfs_attr_leaf_order(save_blk->bp, drop_blk->bp)) {
1894 xfs_attr_leaf_moveents(drop_leaf, 0, tmp_leaf, 0,
Nathan Scott918ae422006-03-17 17:28:54 +11001895 be16_to_cpu(drop_hdr->count), mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896 xfs_attr_leaf_moveents(save_leaf, 0, tmp_leaf,
Nathan Scott918ae422006-03-17 17:28:54 +11001897 be16_to_cpu(tmp_leaf->hdr.count),
1898 be16_to_cpu(save_hdr->count), mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899 } else {
1900 xfs_attr_leaf_moveents(save_leaf, 0, tmp_leaf, 0,
Nathan Scott918ae422006-03-17 17:28:54 +11001901 be16_to_cpu(save_hdr->count), mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902 xfs_attr_leaf_moveents(drop_leaf, 0, tmp_leaf,
Nathan Scott918ae422006-03-17 17:28:54 +11001903 be16_to_cpu(tmp_leaf->hdr.count),
1904 be16_to_cpu(drop_hdr->count), mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905 }
1906 memcpy((char *)save_leaf, (char *)tmp_leaf, state->blocksize);
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10001907 kmem_free(tmpbuffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908 }
1909
1910 xfs_da_log_buf(state->args->trans, save_blk->bp, 0,
1911 state->blocksize - 1);
1912
1913 /*
1914 * Copy out last hashval in each block for B-tree code.
1915 */
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001916 save_blk->hashval = be32_to_cpu(
1917 save_leaf->entries[be16_to_cpu(save_leaf->hdr.count)-1].hashval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918}
1919
1920/*========================================================================
1921 * Routines used for finding things in the Btree.
1922 *========================================================================*/
1923
1924/*
1925 * Look up a name in a leaf attribute list structure.
1926 * This is the internal routine, it uses the caller's buffer.
1927 *
1928 * Note that duplicate keys are allowed, but only check within the
1929 * current leaf node. The Btree code must check in adjacent leaf nodes.
1930 *
1931 * Return in args->index the index into the entry[] array of either
1932 * the found entry, or where the entry should have been (insert before
1933 * that entry).
1934 *
1935 * Don't change the args->value unless we find the attribute.
1936 */
1937int
1938xfs_attr_leaf_lookup_int(xfs_dabuf_t *bp, xfs_da_args_t *args)
1939{
1940 xfs_attr_leafblock_t *leaf;
1941 xfs_attr_leaf_entry_t *entry;
1942 xfs_attr_leaf_name_local_t *name_loc;
1943 xfs_attr_leaf_name_remote_t *name_rmt;
1944 int probe, span;
1945 xfs_dahash_t hashval;
1946
Dave Chinner5a5881c2012-03-22 05:15:13 +00001947 trace_xfs_attr_leaf_lookup(args);
1948
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949 leaf = bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02001950 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Nathan Scott918ae422006-03-17 17:28:54 +11001951 ASSERT(be16_to_cpu(leaf->hdr.count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001952 < (XFS_LBSIZE(args->dp->i_mount)/8));
1953
1954 /*
1955 * Binary search. (note: small blocks will skip this loop)
1956 */
1957 hashval = args->hashval;
Nathan Scott918ae422006-03-17 17:28:54 +11001958 probe = span = be16_to_cpu(leaf->hdr.count) / 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959 for (entry = &leaf->entries[probe]; span > 4;
1960 entry = &leaf->entries[probe]) {
1961 span /= 2;
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001962 if (be32_to_cpu(entry->hashval) < hashval)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963 probe += span;
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001964 else if (be32_to_cpu(entry->hashval) > hashval)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965 probe -= span;
1966 else
1967 break;
1968 }
Tim Shimmin726801b2006-09-28 11:01:37 +10001969 ASSERT((probe >= 0) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970 (!leaf->hdr.count
Nathan Scott918ae422006-03-17 17:28:54 +11001971 || (probe < be16_to_cpu(leaf->hdr.count))));
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001972 ASSERT((span <= 4) || (be32_to_cpu(entry->hashval) == hashval));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973
1974 /*
1975 * Since we may have duplicate hashval's, find the first matching
1976 * hashval in the leaf.
1977 */
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001978 while ((probe > 0) && (be32_to_cpu(entry->hashval) >= hashval)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979 entry--;
1980 probe--;
1981 }
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001982 while ((probe < be16_to_cpu(leaf->hdr.count)) &&
1983 (be32_to_cpu(entry->hashval) < hashval)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984 entry++;
1985 probe++;
1986 }
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001987 if ((probe == be16_to_cpu(leaf->hdr.count)) ||
1988 (be32_to_cpu(entry->hashval) != hashval)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989 args->index = probe;
1990 return(XFS_ERROR(ENOATTR));
1991 }
1992
1993 /*
1994 * Duplicate keys may be present, so search all of them for a match.
1995 */
Nathan Scott6b19f2d2006-03-17 17:29:02 +11001996 for ( ; (probe < be16_to_cpu(leaf->hdr.count)) &&
1997 (be32_to_cpu(entry->hashval) == hashval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998 entry++, probe++) {
1999/*
2000 * GROT: Add code to remove incomplete entries.
2001 */
2002 /*
2003 * If we are looking for INCOMPLETE entries, show only those.
2004 * If we are looking for complete entries, show only those.
2005 */
2006 if ((args->flags & XFS_ATTR_INCOMPLETE) !=
2007 (entry->flags & XFS_ATTR_INCOMPLETE)) {
2008 continue;
2009 }
2010 if (entry->flags & XFS_ATTR_LOCAL) {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002011 name_loc = xfs_attr_leaf_name_local(leaf, probe);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002012 if (name_loc->namelen != args->namelen)
2013 continue;
Tim Shimmin726801b2006-09-28 11:01:37 +10002014 if (memcmp(args->name, (char *)name_loc->nameval, args->namelen) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002015 continue;
Tim Shimmin726801b2006-09-28 11:01:37 +10002016 if (!xfs_attr_namesp_match(args->flags, entry->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017 continue;
2018 args->index = probe;
2019 return(XFS_ERROR(EEXIST));
2020 } else {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002021 name_rmt = xfs_attr_leaf_name_remote(leaf, probe);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002022 if (name_rmt->namelen != args->namelen)
2023 continue;
2024 if (memcmp(args->name, (char *)name_rmt->name,
2025 args->namelen) != 0)
2026 continue;
Tim Shimmin726801b2006-09-28 11:01:37 +10002027 if (!xfs_attr_namesp_match(args->flags, entry->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002028 continue;
2029 args->index = probe;
Nathan Scottc0f054e2006-03-17 17:29:18 +11002030 args->rmtblkno = be32_to_cpu(name_rmt->valueblk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002031 args->rmtblkcnt = XFS_B_TO_FSB(args->dp->i_mount,
Nathan Scottc0f054e2006-03-17 17:29:18 +11002032 be32_to_cpu(name_rmt->valuelen));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002033 return(XFS_ERROR(EEXIST));
2034 }
2035 }
2036 args->index = probe;
2037 return(XFS_ERROR(ENOATTR));
2038}
2039
2040/*
2041 * Get the value associated with an attribute name from a leaf attribute
2042 * list structure.
2043 */
2044int
2045xfs_attr_leaf_getvalue(xfs_dabuf_t *bp, xfs_da_args_t *args)
2046{
2047 int valuelen;
2048 xfs_attr_leafblock_t *leaf;
2049 xfs_attr_leaf_entry_t *entry;
2050 xfs_attr_leaf_name_local_t *name_loc;
2051 xfs_attr_leaf_name_remote_t *name_rmt;
2052
2053 leaf = bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002054 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Nathan Scott918ae422006-03-17 17:28:54 +11002055 ASSERT(be16_to_cpu(leaf->hdr.count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002056 < (XFS_LBSIZE(args->dp->i_mount)/8));
Nathan Scott918ae422006-03-17 17:28:54 +11002057 ASSERT(args->index < be16_to_cpu(leaf->hdr.count));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058
2059 entry = &leaf->entries[args->index];
2060 if (entry->flags & XFS_ATTR_LOCAL) {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002061 name_loc = xfs_attr_leaf_name_local(leaf, args->index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002062 ASSERT(name_loc->namelen == args->namelen);
2063 ASSERT(memcmp(args->name, name_loc->nameval, args->namelen) == 0);
Nathan Scott053b5752006-03-17 17:29:09 +11002064 valuelen = be16_to_cpu(name_loc->valuelen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002065 if (args->flags & ATTR_KERNOVAL) {
2066 args->valuelen = valuelen;
2067 return(0);
2068 }
2069 if (args->valuelen < valuelen) {
2070 args->valuelen = valuelen;
2071 return(XFS_ERROR(ERANGE));
2072 }
2073 args->valuelen = valuelen;
2074 memcpy(args->value, &name_loc->nameval[args->namelen], valuelen);
2075 } else {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002076 name_rmt = xfs_attr_leaf_name_remote(leaf, args->index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077 ASSERT(name_rmt->namelen == args->namelen);
2078 ASSERT(memcmp(args->name, name_rmt->name, args->namelen) == 0);
Nathan Scottc0f054e2006-03-17 17:29:18 +11002079 valuelen = be32_to_cpu(name_rmt->valuelen);
2080 args->rmtblkno = be32_to_cpu(name_rmt->valueblk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081 args->rmtblkcnt = XFS_B_TO_FSB(args->dp->i_mount, valuelen);
2082 if (args->flags & ATTR_KERNOVAL) {
2083 args->valuelen = valuelen;
2084 return(0);
2085 }
2086 if (args->valuelen < valuelen) {
2087 args->valuelen = valuelen;
2088 return(XFS_ERROR(ERANGE));
2089 }
2090 args->valuelen = valuelen;
2091 }
2092 return(0);
2093}
2094
2095/*========================================================================
2096 * Utility routines.
2097 *========================================================================*/
2098
2099/*
2100 * Move the indicated entries from one leaf to another.
2101 * NOTE: this routine modifies both source and destination leaves.
2102 */
2103/*ARGSUSED*/
2104STATIC void
2105xfs_attr_leaf_moveents(xfs_attr_leafblock_t *leaf_s, int start_s,
2106 xfs_attr_leafblock_t *leaf_d, int start_d,
2107 int count, xfs_mount_t *mp)
2108{
2109 xfs_attr_leaf_hdr_t *hdr_s, *hdr_d;
2110 xfs_attr_leaf_entry_t *entry_s, *entry_d;
2111 int desti, tmp, i;
2112
2113 /*
2114 * Check for nothing to do.
2115 */
2116 if (count == 0)
2117 return;
2118
2119 /*
2120 * Set up environment.
2121 */
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002122 ASSERT(leaf_s->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
2123 ASSERT(leaf_d->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002124 hdr_s = &leaf_s->hdr;
2125 hdr_d = &leaf_d->hdr;
Nathan Scott918ae422006-03-17 17:28:54 +11002126 ASSERT((be16_to_cpu(hdr_s->count) > 0) &&
2127 (be16_to_cpu(hdr_s->count) < (XFS_LBSIZE(mp)/8)));
2128 ASSERT(be16_to_cpu(hdr_s->firstused) >=
2129 ((be16_to_cpu(hdr_s->count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002130 * sizeof(*entry_s))+sizeof(*hdr_s)));
Nathan Scott918ae422006-03-17 17:28:54 +11002131 ASSERT(be16_to_cpu(hdr_d->count) < (XFS_LBSIZE(mp)/8));
2132 ASSERT(be16_to_cpu(hdr_d->firstused) >=
2133 ((be16_to_cpu(hdr_d->count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134 * sizeof(*entry_d))+sizeof(*hdr_d)));
2135
Nathan Scott918ae422006-03-17 17:28:54 +11002136 ASSERT(start_s < be16_to_cpu(hdr_s->count));
2137 ASSERT(start_d <= be16_to_cpu(hdr_d->count));
2138 ASSERT(count <= be16_to_cpu(hdr_s->count));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139
2140 /*
2141 * Move the entries in the destination leaf up to make a hole?
2142 */
Nathan Scott918ae422006-03-17 17:28:54 +11002143 if (start_d < be16_to_cpu(hdr_d->count)) {
2144 tmp = be16_to_cpu(hdr_d->count) - start_d;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002145 tmp *= sizeof(xfs_attr_leaf_entry_t);
2146 entry_s = &leaf_d->entries[start_d];
2147 entry_d = &leaf_d->entries[start_d + count];
2148 memmove((char *)entry_d, (char *)entry_s, tmp);
2149 }
2150
2151 /*
2152 * Copy all entry's in the same (sorted) order,
2153 * but allocate attribute info packed and in sequence.
2154 */
2155 entry_s = &leaf_s->entries[start_s];
2156 entry_d = &leaf_d->entries[start_d];
2157 desti = start_d;
2158 for (i = 0; i < count; entry_s++, entry_d++, desti++, i++) {
Nathan Scott6b19f2d2006-03-17 17:29:02 +11002159 ASSERT(be16_to_cpu(entry_s->nameidx)
Nathan Scott918ae422006-03-17 17:28:54 +11002160 >= be16_to_cpu(hdr_s->firstused));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002161 tmp = xfs_attr_leaf_entsize(leaf_s, start_s + i);
2162#ifdef GROT
2163 /*
2164 * Code to drop INCOMPLETE entries. Difficult to use as we
2165 * may also need to change the insertion index. Code turned
2166 * off for 6.2, should be revisited later.
2167 */
2168 if (entry_s->flags & XFS_ATTR_INCOMPLETE) { /* skip partials? */
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002169 memset(xfs_attr_leaf_name(leaf_s, start_s + i), 0, tmp);
Marcin Slusarz413d57c2008-02-13 15:03:29 -08002170 be16_add_cpu(&hdr_s->usedbytes, -tmp);
2171 be16_add_cpu(&hdr_s->count, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002172 entry_d--; /* to compensate for ++ in loop hdr */
2173 desti--;
2174 if ((start_s + i) < offset)
2175 result++; /* insertion index adjustment */
2176 } else {
2177#endif /* GROT */
Marcin Slusarz413d57c2008-02-13 15:03:29 -08002178 be16_add_cpu(&hdr_d->firstused, -tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179 /* both on-disk, don't endian flip twice */
2180 entry_d->hashval = entry_s->hashval;
2181 /* both on-disk, don't endian flip twice */
2182 entry_d->nameidx = hdr_d->firstused;
2183 entry_d->flags = entry_s->flags;
Nathan Scott6b19f2d2006-03-17 17:29:02 +11002184 ASSERT(be16_to_cpu(entry_d->nameidx) + tmp
Linus Torvalds1da177e2005-04-16 15:20:36 -07002185 <= XFS_LBSIZE(mp));
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002186 memmove(xfs_attr_leaf_name(leaf_d, desti),
2187 xfs_attr_leaf_name(leaf_s, start_s + i), tmp);
Nathan Scott6b19f2d2006-03-17 17:29:02 +11002188 ASSERT(be16_to_cpu(entry_s->nameidx) + tmp
Linus Torvalds1da177e2005-04-16 15:20:36 -07002189 <= XFS_LBSIZE(mp));
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002190 memset(xfs_attr_leaf_name(leaf_s, start_s + i), 0, tmp);
Marcin Slusarz413d57c2008-02-13 15:03:29 -08002191 be16_add_cpu(&hdr_s->usedbytes, -tmp);
2192 be16_add_cpu(&hdr_d->usedbytes, tmp);
2193 be16_add_cpu(&hdr_s->count, -1);
2194 be16_add_cpu(&hdr_d->count, 1);
Nathan Scott918ae422006-03-17 17:28:54 +11002195 tmp = be16_to_cpu(hdr_d->count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002196 * sizeof(xfs_attr_leaf_entry_t)
2197 + sizeof(xfs_attr_leaf_hdr_t);
Nathan Scott918ae422006-03-17 17:28:54 +11002198 ASSERT(be16_to_cpu(hdr_d->firstused) >= tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002199#ifdef GROT
2200 }
2201#endif /* GROT */
2202 }
2203
2204 /*
2205 * Zero out the entries we just copied.
2206 */
Nathan Scott918ae422006-03-17 17:28:54 +11002207 if (start_s == be16_to_cpu(hdr_s->count)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002208 tmp = count * sizeof(xfs_attr_leaf_entry_t);
2209 entry_s = &leaf_s->entries[start_s];
2210 ASSERT(((char *)entry_s + tmp) <=
2211 ((char *)leaf_s + XFS_LBSIZE(mp)));
2212 memset((char *)entry_s, 0, tmp);
2213 } else {
2214 /*
2215 * Move the remaining entries down to fill the hole,
2216 * then zero the entries at the top.
2217 */
Nathan Scott918ae422006-03-17 17:28:54 +11002218 tmp = be16_to_cpu(hdr_s->count) - count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002219 tmp *= sizeof(xfs_attr_leaf_entry_t);
2220 entry_s = &leaf_s->entries[start_s + count];
2221 entry_d = &leaf_s->entries[start_s];
2222 memmove((char *)entry_d, (char *)entry_s, tmp);
2223
2224 tmp = count * sizeof(xfs_attr_leaf_entry_t);
Nathan Scott918ae422006-03-17 17:28:54 +11002225 entry_s = &leaf_s->entries[be16_to_cpu(hdr_s->count)];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002226 ASSERT(((char *)entry_s + tmp) <=
2227 ((char *)leaf_s + XFS_LBSIZE(mp)));
2228 memset((char *)entry_s, 0, tmp);
2229 }
2230
2231 /*
2232 * Fill in the freemap information
2233 */
Nathan Scott918ae422006-03-17 17:28:54 +11002234 hdr_d->freemap[0].base = cpu_to_be16(sizeof(xfs_attr_leaf_hdr_t));
Marcin Slusarz413d57c2008-02-13 15:03:29 -08002235 be16_add_cpu(&hdr_d->freemap[0].base, be16_to_cpu(hdr_d->count) *
Nathan Scott918ae422006-03-17 17:28:54 +11002236 sizeof(xfs_attr_leaf_entry_t));
2237 hdr_d->freemap[0].size = cpu_to_be16(be16_to_cpu(hdr_d->firstused)
2238 - be16_to_cpu(hdr_d->freemap[0].base));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002239 hdr_d->freemap[1].base = 0;
2240 hdr_d->freemap[2].base = 0;
2241 hdr_d->freemap[1].size = 0;
2242 hdr_d->freemap[2].size = 0;
2243 hdr_s->holes = 1; /* leaf may not be compact */
2244}
2245
2246/*
2247 * Compare two leaf blocks "order".
2248 * Return 0 unless leaf2 should go before leaf1.
2249 */
2250int
2251xfs_attr_leaf_order(xfs_dabuf_t *leaf1_bp, xfs_dabuf_t *leaf2_bp)
2252{
2253 xfs_attr_leafblock_t *leaf1, *leaf2;
2254
2255 leaf1 = leaf1_bp->data;
2256 leaf2 = leaf2_bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002257 ASSERT((leaf1->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC)) &&
2258 (leaf2->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC)));
Nathan Scott918ae422006-03-17 17:28:54 +11002259 if ((be16_to_cpu(leaf1->hdr.count) > 0) &&
2260 (be16_to_cpu(leaf2->hdr.count) > 0) &&
Nathan Scott6b19f2d2006-03-17 17:29:02 +11002261 ((be32_to_cpu(leaf2->entries[0].hashval) <
2262 be32_to_cpu(leaf1->entries[0].hashval)) ||
2263 (be32_to_cpu(leaf2->entries[
2264 be16_to_cpu(leaf2->hdr.count)-1].hashval) <
2265 be32_to_cpu(leaf1->entries[
2266 be16_to_cpu(leaf1->hdr.count)-1].hashval)))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002267 return(1);
2268 }
2269 return(0);
2270}
2271
2272/*
2273 * Pick up the last hashvalue from a leaf block.
2274 */
2275xfs_dahash_t
2276xfs_attr_leaf_lasthash(xfs_dabuf_t *bp, int *count)
2277{
2278 xfs_attr_leafblock_t *leaf;
2279
2280 leaf = bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002281 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002282 if (count)
Nathan Scott918ae422006-03-17 17:28:54 +11002283 *count = be16_to_cpu(leaf->hdr.count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002284 if (!leaf->hdr.count)
2285 return(0);
Nathan Scott6b19f2d2006-03-17 17:29:02 +11002286 return be32_to_cpu(leaf->entries[be16_to_cpu(leaf->hdr.count)-1].hashval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002287}
2288
2289/*
2290 * Calculate the number of bytes used to store the indicated attribute
2291 * (whether local or remote only calculate bytes in this block).
2292 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002293STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294xfs_attr_leaf_entsize(xfs_attr_leafblock_t *leaf, int index)
2295{
2296 xfs_attr_leaf_name_local_t *name_loc;
2297 xfs_attr_leaf_name_remote_t *name_rmt;
2298 int size;
2299
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002300 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002301 if (leaf->entries[index].flags & XFS_ATTR_LOCAL) {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002302 name_loc = xfs_attr_leaf_name_local(leaf, index);
2303 size = xfs_attr_leaf_entsize_local(name_loc->namelen,
Nathan Scott053b5752006-03-17 17:29:09 +11002304 be16_to_cpu(name_loc->valuelen));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002305 } else {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002306 name_rmt = xfs_attr_leaf_name_remote(leaf, index);
2307 size = xfs_attr_leaf_entsize_remote(name_rmt->namelen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002308 }
2309 return(size);
2310}
2311
2312/*
2313 * Calculate the number of bytes that would be required to store the new
2314 * attribute (whether local or remote only calculate bytes in this block).
2315 * This routine decides as a side effect whether the attribute will be
2316 * a "local" or a "remote" attribute.
2317 */
2318int
Nathan Scottaa82daa2005-11-02 10:33:33 +11002319xfs_attr_leaf_newentsize(int namelen, int valuelen, int blocksize, int *local)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002320{
2321 int size;
2322
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002323 size = xfs_attr_leaf_entsize_local(namelen, valuelen);
2324 if (size < xfs_attr_leaf_entsize_local_max(blocksize)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002325 if (local) {
2326 *local = 1;
2327 }
2328 } else {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002329 size = xfs_attr_leaf_entsize_remote(namelen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330 if (local) {
2331 *local = 0;
2332 }
2333 }
2334 return(size);
2335}
2336
2337/*
2338 * Copy out attribute list entries for attr_list(), for leaf attribute lists.
2339 */
2340int
2341xfs_attr_leaf_list_int(xfs_dabuf_t *bp, xfs_attr_list_context_t *context)
2342{
2343 attrlist_cursor_kern_t *cursor;
2344 xfs_attr_leafblock_t *leaf;
2345 xfs_attr_leaf_entry_t *entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002346 int retval, i;
2347
2348 ASSERT(bp != NULL);
2349 leaf = bp->data;
2350 cursor = context->cursor;
2351 cursor->initted = 1;
2352
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00002353 trace_xfs_attr_list_leaf(context);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002354
2355 /*
2356 * Re-find our place in the leaf block if this is a new syscall.
2357 */
2358 if (context->resynch) {
2359 entry = &leaf->entries[0];
Nathan Scott918ae422006-03-17 17:28:54 +11002360 for (i = 0; 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) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002362 if (cursor->offset == context->dupcnt) {
2363 context->dupcnt = 0;
2364 break;
2365 }
2366 context->dupcnt++;
Nathan Scott6b19f2d2006-03-17 17:29:02 +11002367 } else if (be32_to_cpu(entry->hashval) >
2368 cursor->hashval) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002369 context->dupcnt = 0;
2370 break;
2371 }
2372 }
Nathan Scott918ae422006-03-17 17:28:54 +11002373 if (i == be16_to_cpu(leaf->hdr.count)) {
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00002374 trace_xfs_attr_list_notfound(context);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002375 return(0);
2376 }
2377 } else {
2378 entry = &leaf->entries[0];
2379 i = 0;
2380 }
2381 context->resynch = 0;
2382
2383 /*
2384 * We have found our place, start copying out the new attributes.
2385 */
2386 retval = 0;
Tim Shimmin726801b2006-09-28 11:01:37 +10002387 for ( ; (i < be16_to_cpu(leaf->hdr.count)); entry++, i++) {
Nathan Scott6b19f2d2006-03-17 17:29:02 +11002388 if (be32_to_cpu(entry->hashval) != cursor->hashval) {
2389 cursor->hashval = be32_to_cpu(entry->hashval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002390 cursor->offset = 0;
2391 }
2392
2393 if (entry->flags & XFS_ATTR_INCOMPLETE)
2394 continue; /* skip incomplete entries */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002395
2396 if (entry->flags & XFS_ATTR_LOCAL) {
Tim Shimmin726801b2006-09-28 11:01:37 +10002397 xfs_attr_leaf_name_local_t *name_loc =
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002398 xfs_attr_leaf_name_local(leaf, i);
Tim Shimmin726801b2006-09-28 11:01:37 +10002399
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_loc->nameval,
Tim Shimmin726801b2006-09-28 11:01:37 +10002403 (int)name_loc->namelen,
2404 be16_to_cpu(name_loc->valuelen),
Dave Chinnera9273ca2010-01-20 10:47:48 +11002405 &name_loc->nameval[name_loc->namelen]);
Tim Shimmin726801b2006-09-28 11:01:37 +10002406 if (retval)
2407 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002408 } else {
Tim Shimmin726801b2006-09-28 11:01:37 +10002409 xfs_attr_leaf_name_remote_t *name_rmt =
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002410 xfs_attr_leaf_name_remote(leaf, i);
Tim Shimmin726801b2006-09-28 11:01:37 +10002411
2412 int valuelen = be32_to_cpu(name_rmt->valuelen);
2413
2414 if (context->put_value) {
2415 xfs_da_args_t args;
2416
2417 memset((char *)&args, 0, sizeof(args));
2418 args.dp = context->dp;
2419 args.whichfork = XFS_ATTR_FORK;
2420 args.valuelen = valuelen;
Dave Chinner622d8142010-12-23 11:57:37 +11002421 args.value = kmem_alloc(valuelen, KM_SLEEP | KM_NOFS);
Tim Shimmin726801b2006-09-28 11:01:37 +10002422 args.rmtblkno = be32_to_cpu(name_rmt->valueblk);
2423 args.rmtblkcnt = XFS_B_TO_FSB(args.dp->i_mount, valuelen);
2424 retval = xfs_attr_rmtval_get(&args);
2425 if (retval)
2426 return retval;
2427 retval = context->put_listent(context,
Christoph Hellwigad9b4632008-06-23 13:23:48 +10002428 entry->flags,
Dave Chinnera9273ca2010-01-20 10:47:48 +11002429 name_rmt->name,
Tim Shimmin726801b2006-09-28 11:01:37 +10002430 (int)name_rmt->namelen,
2431 valuelen,
Dave Chinnera9273ca2010-01-20 10:47:48 +11002432 args.value);
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10002433 kmem_free(args.value);
Christoph Hellwigad9b4632008-06-23 13:23:48 +10002434 } else {
Tim Shimmin726801b2006-09-28 11:01:37 +10002435 retval = context->put_listent(context,
Christoph Hellwigad9b4632008-06-23 13:23:48 +10002436 entry->flags,
Dave Chinnera9273ca2010-01-20 10:47:48 +11002437 name_rmt->name,
Tim Shimmin726801b2006-09-28 11:01:37 +10002438 (int)name_rmt->namelen,
2439 valuelen,
2440 NULL);
2441 }
2442 if (retval)
2443 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002444 }
Tim Shimmin726801b2006-09-28 11:01:37 +10002445 if (context->seen_enough)
2446 break;
2447 cursor->offset++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002448 }
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00002449 trace_xfs_attr_list_leaf_end(context);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002450 return(retval);
2451}
2452
Linus Torvalds1da177e2005-04-16 15:20:36 -07002453
2454/*========================================================================
2455 * Manage the INCOMPLETE flag in a leaf entry
2456 *========================================================================*/
2457
2458/*
2459 * Clear the INCOMPLETE flag on an entry in a leaf block.
2460 */
2461int
2462xfs_attr_leaf_clearflag(xfs_da_args_t *args)
2463{
2464 xfs_attr_leafblock_t *leaf;
2465 xfs_attr_leaf_entry_t *entry;
2466 xfs_attr_leaf_name_remote_t *name_rmt;
2467 xfs_dabuf_t *bp;
2468 int error;
2469#ifdef DEBUG
2470 xfs_attr_leaf_name_local_t *name_loc;
2471 int namelen;
2472 char *name;
2473#endif /* DEBUG */
2474
Dave Chinner5a5881c2012-03-22 05:15:13 +00002475 trace_xfs_attr_leaf_clearflag(args);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002476 /*
2477 * Set up the operation.
2478 */
2479 error = xfs_da_read_buf(args->trans, args->dp, args->blkno, -1, &bp,
2480 XFS_ATTR_FORK);
2481 if (error) {
2482 return(error);
2483 }
2484 ASSERT(bp != NULL);
2485
2486 leaf = bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002487 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Nathan Scott918ae422006-03-17 17:28:54 +11002488 ASSERT(args->index < be16_to_cpu(leaf->hdr.count));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002489 ASSERT(args->index >= 0);
2490 entry = &leaf->entries[ args->index ];
2491 ASSERT(entry->flags & XFS_ATTR_INCOMPLETE);
2492
2493#ifdef DEBUG
2494 if (entry->flags & XFS_ATTR_LOCAL) {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002495 name_loc = xfs_attr_leaf_name_local(leaf, args->index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002496 namelen = name_loc->namelen;
2497 name = (char *)name_loc->nameval;
2498 } else {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002499 name_rmt = xfs_attr_leaf_name_remote(leaf, args->index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002500 namelen = name_rmt->namelen;
2501 name = (char *)name_rmt->name;
2502 }
Nathan Scott6b19f2d2006-03-17 17:29:02 +11002503 ASSERT(be32_to_cpu(entry->hashval) == args->hashval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002504 ASSERT(namelen == args->namelen);
2505 ASSERT(memcmp(name, args->name, namelen) == 0);
2506#endif /* DEBUG */
2507
2508 entry->flags &= ~XFS_ATTR_INCOMPLETE;
2509 xfs_da_log_buf(args->trans, bp,
2510 XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));
2511
2512 if (args->rmtblkno) {
2513 ASSERT((entry->flags & XFS_ATTR_LOCAL) == 0);
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002514 name_rmt = xfs_attr_leaf_name_remote(leaf, args->index);
Nathan Scottc0f054e2006-03-17 17:29:18 +11002515 name_rmt->valueblk = cpu_to_be32(args->rmtblkno);
2516 name_rmt->valuelen = cpu_to_be32(args->valuelen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002517 xfs_da_log_buf(args->trans, bp,
2518 XFS_DA_LOGRANGE(leaf, name_rmt, sizeof(*name_rmt)));
2519 }
2520 xfs_da_buf_done(bp);
2521
2522 /*
2523 * Commit the flag value change and start the next trans in series.
2524 */
Niv Sardi322ff6b2008-08-13 16:05:49 +10002525 return xfs_trans_roll(&args->trans, args->dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002526}
2527
2528/*
2529 * Set the INCOMPLETE flag on an entry in a leaf block.
2530 */
2531int
2532xfs_attr_leaf_setflag(xfs_da_args_t *args)
2533{
2534 xfs_attr_leafblock_t *leaf;
2535 xfs_attr_leaf_entry_t *entry;
2536 xfs_attr_leaf_name_remote_t *name_rmt;
2537 xfs_dabuf_t *bp;
2538 int error;
2539
Dave Chinner5a5881c2012-03-22 05:15:13 +00002540 trace_xfs_attr_leaf_setflag(args);
2541
Linus Torvalds1da177e2005-04-16 15:20:36 -07002542 /*
2543 * Set up the operation.
2544 */
2545 error = xfs_da_read_buf(args->trans, args->dp, args->blkno, -1, &bp,
2546 XFS_ATTR_FORK);
2547 if (error) {
2548 return(error);
2549 }
2550 ASSERT(bp != NULL);
2551
2552 leaf = bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002553 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Nathan Scott918ae422006-03-17 17:28:54 +11002554 ASSERT(args->index < be16_to_cpu(leaf->hdr.count));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002555 ASSERT(args->index >= 0);
2556 entry = &leaf->entries[ args->index ];
2557
2558 ASSERT((entry->flags & XFS_ATTR_INCOMPLETE) == 0);
2559 entry->flags |= XFS_ATTR_INCOMPLETE;
2560 xfs_da_log_buf(args->trans, bp,
2561 XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));
2562 if ((entry->flags & XFS_ATTR_LOCAL) == 0) {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002563 name_rmt = xfs_attr_leaf_name_remote(leaf, args->index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002564 name_rmt->valueblk = 0;
2565 name_rmt->valuelen = 0;
2566 xfs_da_log_buf(args->trans, bp,
2567 XFS_DA_LOGRANGE(leaf, name_rmt, sizeof(*name_rmt)));
2568 }
2569 xfs_da_buf_done(bp);
2570
2571 /*
2572 * Commit the flag value change and start the next trans in series.
2573 */
Niv Sardi322ff6b2008-08-13 16:05:49 +10002574 return xfs_trans_roll(&args->trans, args->dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002575}
2576
2577/*
2578 * In a single transaction, clear the INCOMPLETE flag on the leaf entry
2579 * given by args->blkno/index and set the INCOMPLETE flag on the leaf
2580 * entry given by args->blkno2/index2.
2581 *
2582 * Note that they could be in different blocks, or in the same block.
2583 */
2584int
2585xfs_attr_leaf_flipflags(xfs_da_args_t *args)
2586{
2587 xfs_attr_leafblock_t *leaf1, *leaf2;
2588 xfs_attr_leaf_entry_t *entry1, *entry2;
2589 xfs_attr_leaf_name_remote_t *name_rmt;
2590 xfs_dabuf_t *bp1, *bp2;
2591 int error;
2592#ifdef DEBUG
2593 xfs_attr_leaf_name_local_t *name_loc;
2594 int namelen1, namelen2;
2595 char *name1, *name2;
2596#endif /* DEBUG */
2597
Dave Chinner5a5881c2012-03-22 05:15:13 +00002598 trace_xfs_attr_leaf_flipflags(args);
2599
Linus Torvalds1da177e2005-04-16 15:20:36 -07002600 /*
2601 * Read the block containing the "old" attr
2602 */
2603 error = xfs_da_read_buf(args->trans, args->dp, args->blkno, -1, &bp1,
2604 XFS_ATTR_FORK);
2605 if (error) {
2606 return(error);
2607 }
2608 ASSERT(bp1 != NULL);
2609
2610 /*
2611 * Read the block containing the "new" attr, if it is different
2612 */
2613 if (args->blkno2 != args->blkno) {
2614 error = xfs_da_read_buf(args->trans, args->dp, args->blkno2,
2615 -1, &bp2, XFS_ATTR_FORK);
2616 if (error) {
2617 return(error);
2618 }
2619 ASSERT(bp2 != NULL);
2620 } else {
2621 bp2 = bp1;
2622 }
2623
2624 leaf1 = bp1->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002625 ASSERT(leaf1->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Nathan Scott918ae422006-03-17 17:28:54 +11002626 ASSERT(args->index < be16_to_cpu(leaf1->hdr.count));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002627 ASSERT(args->index >= 0);
2628 entry1 = &leaf1->entries[ args->index ];
2629
2630 leaf2 = bp2->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002631 ASSERT(leaf2->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Nathan Scott918ae422006-03-17 17:28:54 +11002632 ASSERT(args->index2 < be16_to_cpu(leaf2->hdr.count));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002633 ASSERT(args->index2 >= 0);
2634 entry2 = &leaf2->entries[ args->index2 ];
2635
2636#ifdef DEBUG
2637 if (entry1->flags & XFS_ATTR_LOCAL) {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002638 name_loc = xfs_attr_leaf_name_local(leaf1, args->index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002639 namelen1 = name_loc->namelen;
2640 name1 = (char *)name_loc->nameval;
2641 } else {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002642 name_rmt = xfs_attr_leaf_name_remote(leaf1, args->index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002643 namelen1 = name_rmt->namelen;
2644 name1 = (char *)name_rmt->name;
2645 }
2646 if (entry2->flags & XFS_ATTR_LOCAL) {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002647 name_loc = xfs_attr_leaf_name_local(leaf2, args->index2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002648 namelen2 = name_loc->namelen;
2649 name2 = (char *)name_loc->nameval;
2650 } else {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002651 name_rmt = xfs_attr_leaf_name_remote(leaf2, args->index2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002652 namelen2 = name_rmt->namelen;
2653 name2 = (char *)name_rmt->name;
2654 }
Nathan Scott6b19f2d2006-03-17 17:29:02 +11002655 ASSERT(be32_to_cpu(entry1->hashval) == be32_to_cpu(entry2->hashval));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002656 ASSERT(namelen1 == namelen2);
2657 ASSERT(memcmp(name1, name2, namelen1) == 0);
2658#endif /* DEBUG */
2659
2660 ASSERT(entry1->flags & XFS_ATTR_INCOMPLETE);
2661 ASSERT((entry2->flags & XFS_ATTR_INCOMPLETE) == 0);
2662
2663 entry1->flags &= ~XFS_ATTR_INCOMPLETE;
2664 xfs_da_log_buf(args->trans, bp1,
2665 XFS_DA_LOGRANGE(leaf1, entry1, sizeof(*entry1)));
2666 if (args->rmtblkno) {
2667 ASSERT((entry1->flags & XFS_ATTR_LOCAL) == 0);
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002668 name_rmt = xfs_attr_leaf_name_remote(leaf1, args->index);
Nathan Scottc0f054e2006-03-17 17:29:18 +11002669 name_rmt->valueblk = cpu_to_be32(args->rmtblkno);
2670 name_rmt->valuelen = cpu_to_be32(args->valuelen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002671 xfs_da_log_buf(args->trans, bp1,
2672 XFS_DA_LOGRANGE(leaf1, name_rmt, sizeof(*name_rmt)));
2673 }
2674
2675 entry2->flags |= XFS_ATTR_INCOMPLETE;
2676 xfs_da_log_buf(args->trans, bp2,
2677 XFS_DA_LOGRANGE(leaf2, entry2, sizeof(*entry2)));
2678 if ((entry2->flags & XFS_ATTR_LOCAL) == 0) {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002679 name_rmt = xfs_attr_leaf_name_remote(leaf2, args->index2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002680 name_rmt->valueblk = 0;
2681 name_rmt->valuelen = 0;
2682 xfs_da_log_buf(args->trans, bp2,
2683 XFS_DA_LOGRANGE(leaf2, name_rmt, sizeof(*name_rmt)));
2684 }
2685 xfs_da_buf_done(bp1);
2686 if (bp1 != bp2)
2687 xfs_da_buf_done(bp2);
2688
2689 /*
2690 * Commit the flag value change and start the next trans in series.
2691 */
Niv Sardi322ff6b2008-08-13 16:05:49 +10002692 error = xfs_trans_roll(&args->trans, args->dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002693
2694 return(error);
2695}
2696
2697/*========================================================================
2698 * Indiscriminately delete the entire attribute fork
2699 *========================================================================*/
2700
2701/*
2702 * Recurse (gasp!) through the attribute nodes until we find leaves.
2703 * We're doing a depth-first traversal in order to invalidate everything.
2704 */
2705int
2706xfs_attr_root_inactive(xfs_trans_t **trans, xfs_inode_t *dp)
2707{
2708 xfs_da_blkinfo_t *info;
2709 xfs_daddr_t blkno;
2710 xfs_dabuf_t *bp;
2711 int error;
2712
2713 /*
2714 * Read block 0 to see what we have to work with.
2715 * We only get here if we have extents, since we remove
2716 * the extents in reverse order the extent containing
2717 * block 0 must still be there.
2718 */
2719 error = xfs_da_read_buf(*trans, dp, 0, -1, &bp, XFS_ATTR_FORK);
2720 if (error)
2721 return(error);
2722 blkno = xfs_da_blkno(bp);
2723
2724 /*
2725 * Invalidate the tree, even if the "tree" is only a single leaf block.
2726 * This is a depth-first traversal!
2727 */
2728 info = bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002729 if (info->magic == cpu_to_be16(XFS_DA_NODE_MAGIC)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002730 error = xfs_attr_node_inactive(trans, dp, bp, 1);
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002731 } else if (info->magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002732 error = xfs_attr_leaf_inactive(trans, dp, bp);
2733 } else {
2734 error = XFS_ERROR(EIO);
2735 xfs_da_brelse(*trans, bp);
2736 }
2737 if (error)
2738 return(error);
2739
2740 /*
2741 * Invalidate the incore copy of the root block.
2742 */
2743 error = xfs_da_get_buf(*trans, dp, 0, blkno, &bp, XFS_ATTR_FORK);
2744 if (error)
2745 return(error);
2746 xfs_da_binval(*trans, bp); /* remove from cache */
2747 /*
2748 * Commit the invalidate and start the next transaction.
2749 */
Niv Sardi322ff6b2008-08-13 16:05:49 +10002750 error = xfs_trans_roll(trans, dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002751
2752 return (error);
2753}
2754
2755/*
2756 * Recurse (gasp!) through the attribute nodes until we find leaves.
2757 * We're doing a depth-first traversal in order to invalidate everything.
2758 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002759STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002760xfs_attr_node_inactive(xfs_trans_t **trans, xfs_inode_t *dp, xfs_dabuf_t *bp,
2761 int level)
2762{
2763 xfs_da_blkinfo_t *info;
2764 xfs_da_intnode_t *node;
2765 xfs_dablk_t child_fsb;
2766 xfs_daddr_t parent_blkno, child_blkno;
2767 int error, count, i;
2768 xfs_dabuf_t *child_bp;
2769
2770 /*
2771 * Since this code is recursive (gasp!) we must protect ourselves.
2772 */
2773 if (level > XFS_DA_NODE_MAXDEPTH) {
2774 xfs_da_brelse(*trans, bp); /* no locks for later trans */
2775 return(XFS_ERROR(EIO));
2776 }
2777
2778 node = bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002779 ASSERT(node->hdr.info.magic == cpu_to_be16(XFS_DA_NODE_MAGIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002780 parent_blkno = xfs_da_blkno(bp); /* save for re-read later */
Nathan Scottfac80cc2006-03-17 17:29:56 +11002781 count = be16_to_cpu(node->hdr.count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002782 if (!count) {
2783 xfs_da_brelse(*trans, bp);
2784 return(0);
2785 }
Nathan Scott403432d2006-03-17 17:29:46 +11002786 child_fsb = be32_to_cpu(node->btree[0].before);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002787 xfs_da_brelse(*trans, bp); /* no locks for later trans */
2788
2789 /*
2790 * If this is the node level just above the leaves, simply loop
2791 * over the leaves removing all of them. If this is higher up
2792 * in the tree, recurse downward.
2793 */
2794 for (i = 0; i < count; i++) {
2795 /*
2796 * Read the subsidiary block to see what we have to work with.
2797 * Don't do this in a transaction. This is a depth-first
2798 * traversal of the tree so we may deal with many blocks
2799 * before we come back to this one.
2800 */
2801 error = xfs_da_read_buf(*trans, dp, child_fsb, -2, &child_bp,
2802 XFS_ATTR_FORK);
2803 if (error)
2804 return(error);
2805 if (child_bp) {
2806 /* save for re-read later */
2807 child_blkno = xfs_da_blkno(child_bp);
2808
2809 /*
2810 * Invalidate the subtree, however we have to.
2811 */
2812 info = child_bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002813 if (info->magic == cpu_to_be16(XFS_DA_NODE_MAGIC)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002814 error = xfs_attr_node_inactive(trans, dp,
2815 child_bp, level+1);
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002816 } else if (info->magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002817 error = xfs_attr_leaf_inactive(trans, dp,
2818 child_bp);
2819 } else {
2820 error = XFS_ERROR(EIO);
2821 xfs_da_brelse(*trans, child_bp);
2822 }
2823 if (error)
2824 return(error);
2825
2826 /*
2827 * Remove the subsidiary block from the cache
2828 * and from the log.
2829 */
2830 error = xfs_da_get_buf(*trans, dp, 0, child_blkno,
2831 &child_bp, XFS_ATTR_FORK);
2832 if (error)
2833 return(error);
2834 xfs_da_binval(*trans, child_bp);
2835 }
2836
2837 /*
2838 * If we're not done, re-read the parent to get the next
2839 * child block number.
2840 */
2841 if ((i+1) < count) {
2842 error = xfs_da_read_buf(*trans, dp, 0, parent_blkno,
2843 &bp, XFS_ATTR_FORK);
2844 if (error)
2845 return(error);
Nathan Scott403432d2006-03-17 17:29:46 +11002846 child_fsb = be32_to_cpu(node->btree[i+1].before);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002847 xfs_da_brelse(*trans, bp);
2848 }
2849 /*
2850 * Atomically commit the whole invalidate stuff.
2851 */
Niv Sardi322ff6b2008-08-13 16:05:49 +10002852 error = xfs_trans_roll(trans, dp);
2853 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002854 return (error);
2855 }
2856
2857 return(0);
2858}
2859
2860/*
2861 * Invalidate all of the "remote" value regions pointed to by a particular
2862 * leaf block.
2863 * Note that we must release the lock on the buffer so that we are not
2864 * caught holding something that the logging code wants to flush to disk.
2865 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002866STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002867xfs_attr_leaf_inactive(xfs_trans_t **trans, xfs_inode_t *dp, xfs_dabuf_t *bp)
2868{
2869 xfs_attr_leafblock_t *leaf;
2870 xfs_attr_leaf_entry_t *entry;
2871 xfs_attr_leaf_name_remote_t *name_rmt;
2872 xfs_attr_inactive_list_t *list, *lp;
2873 int error, count, size, tmp, i;
2874
2875 leaf = bp->data;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002876 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002877
2878 /*
2879 * Count the number of "remote" value extents.
2880 */
2881 count = 0;
2882 entry = &leaf->entries[0];
Nathan Scott918ae422006-03-17 17:28:54 +11002883 for (i = 0; i < be16_to_cpu(leaf->hdr.count); entry++, i++) {
Nathan Scott6b19f2d2006-03-17 17:29:02 +11002884 if (be16_to_cpu(entry->nameidx) &&
2885 ((entry->flags & XFS_ATTR_LOCAL) == 0)) {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002886 name_rmt = xfs_attr_leaf_name_remote(leaf, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002887 if (name_rmt->valueblk)
2888 count++;
2889 }
2890 }
2891
2892 /*
2893 * If there are no "remote" values, we're done.
2894 */
2895 if (count == 0) {
2896 xfs_da_brelse(*trans, bp);
2897 return(0);
2898 }
2899
2900 /*
2901 * Allocate storage for a list of all the "remote" value extents.
2902 */
2903 size = count * sizeof(xfs_attr_inactive_list_t);
2904 list = (xfs_attr_inactive_list_t *)kmem_alloc(size, KM_SLEEP);
2905
2906 /*
2907 * Identify each of the "remote" value extents.
2908 */
2909 lp = list;
2910 entry = &leaf->entries[0];
Nathan Scott918ae422006-03-17 17:28:54 +11002911 for (i = 0; i < be16_to_cpu(leaf->hdr.count); entry++, i++) {
Nathan Scott6b19f2d2006-03-17 17:29:02 +11002912 if (be16_to_cpu(entry->nameidx) &&
2913 ((entry->flags & XFS_ATTR_LOCAL) == 0)) {
Eric Sandeenc9fb86a2009-01-01 16:40:11 -06002914 name_rmt = xfs_attr_leaf_name_remote(leaf, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002915 if (name_rmt->valueblk) {
Nathan Scottd7929ff2006-03-17 17:29:36 +11002916 lp->valueblk = be32_to_cpu(name_rmt->valueblk);
2917 lp->valuelen = XFS_B_TO_FSB(dp->i_mount,
2918 be32_to_cpu(name_rmt->valuelen));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002919 lp++;
2920 }
2921 }
2922 }
2923 xfs_da_brelse(*trans, bp); /* unlock for trans. in freextent() */
2924
2925 /*
2926 * Invalidate each of the "remote" value extents.
2927 */
2928 error = 0;
2929 for (lp = list, i = 0; i < count; i++, lp++) {
2930 tmp = xfs_attr_leaf_freextent(trans, dp,
Nathan Scottd7929ff2006-03-17 17:29:36 +11002931 lp->valueblk, lp->valuelen);
2932
Linus Torvalds1da177e2005-04-16 15:20:36 -07002933 if (error == 0)
2934 error = tmp; /* save only the 1st errno */
2935 }
2936
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10002937 kmem_free((xfs_caddr_t)list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002938 return(error);
2939}
2940
2941/*
2942 * Look at all the extents for this logical region,
2943 * invalidate any buffers that are incore/in transactions.
2944 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002945STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002946xfs_attr_leaf_freextent(xfs_trans_t **trans, xfs_inode_t *dp,
2947 xfs_dablk_t blkno, int blkcnt)
2948{
2949 xfs_bmbt_irec_t map;
2950 xfs_dablk_t tblkno;
2951 int tblkcnt, dblkcnt, nmap, error;
2952 xfs_daddr_t dblkno;
2953 xfs_buf_t *bp;
2954
2955 /*
2956 * Roll through the "value", invalidating the attribute value's
2957 * blocks.
2958 */
2959 tblkno = blkno;
2960 tblkcnt = blkcnt;
2961 while (tblkcnt > 0) {
2962 /*
2963 * Try to remember where we decided to put the value.
2964 */
2965 nmap = 1;
Dave Chinner5c8ed202011-09-18 20:40:45 +00002966 error = xfs_bmapi_read(dp, (xfs_fileoff_t)tblkno, tblkcnt,
2967 &map, &nmap, XFS_BMAPI_ATTRFORK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002968 if (error) {
2969 return(error);
2970 }
2971 ASSERT(nmap == 1);
2972 ASSERT(map.br_startblock != DELAYSTARTBLOCK);
2973
2974 /*
2975 * If it's a hole, these are already unmapped
2976 * so there's nothing to invalidate.
2977 */
2978 if (map.br_startblock != HOLESTARTBLOCK) {
2979
2980 dblkno = XFS_FSB_TO_DADDR(dp->i_mount,
2981 map.br_startblock);
2982 dblkcnt = XFS_FSB_TO_BB(dp->i_mount,
2983 map.br_blockcount);
2984 bp = xfs_trans_get_buf(*trans,
2985 dp->i_mount->m_ddev_targp,
Christoph Hellwig0cadda12010-01-19 09:56:44 +00002986 dblkno, dblkcnt, XBF_LOCK);
Chandra Seetharaman2a30f36d2011-09-20 13:56:55 +00002987 if (!bp)
2988 return ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002989 xfs_trans_binval(*trans, bp);
2990 /*
2991 * Roll to next transaction.
2992 */
Niv Sardi322ff6b2008-08-13 16:05:49 +10002993 error = xfs_trans_roll(trans, dp);
2994 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002995 return (error);
2996 }
2997
2998 tblkno += map.br_blockcount;
2999 tblkcnt -= map.br_blockcount;
3000 }
3001
3002 return(0);
3003}