]> git.ipfire.org Git - thirdparty/xfsprogs-dev.git/blob - libxfs/xfs_attr.c
projects / thirdparty / xfsprogs-dev.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
libxfs: disambiguate xfs.h
[thirdparty/xfsprogs-dev.git] / libxfs / xfs_attr.c
1 /*
2 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
3 * All Rights Reserved.
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18 #include "libxfs_priv.h"
19 #include "xfs_fs.h"
20 #include "xfs_shared.h"
21 #include "xfs_format.h"
22 #include "xfs_log_format.h"
23 #include "xfs_trans_resv.h"
24 #include "xfs_bit.h"
25 #include "xfs_mount.h"
26 #include "xfs_da_format.h"
27 #include "xfs_da_btree.h"
28 #include "xfs_attr_sf.h"
29 #include "xfs_inode.h"
30 #include "xfs_alloc.h"
31 #include "xfs_trans.h"
32 #include "xfs_bmap.h"
33 #include "xfs_bmap_btree.h"
34 #include "xfs_attr_leaf.h"
35 #include "xfs_attr_remote.h"
36 #include "xfs_trans_space.h"
37 #include "xfs_trace.h"
38
39 /*
40 * xfs_attr.c
41 *
42 * Provide the external interfaces to manage attribute lists.
43 */
44
45 /*========================================================================
46 * Function prototypes for the kernel.
47 *========================================================================*/
48
49 /*
50 * Internal routines when attribute list fits inside the inode.
51 */
52 STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);
53
54 /*
55 * Internal routines when attribute list is one block.
56 */
57 STATIC int xfs_attr_leaf_get(xfs_da_args_t *args);
58 STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args);
59 STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args);
60
61 /*
62 * Internal routines when attribute list is more than one block.
63 */
64 STATIC int xfs_attr_node_get(xfs_da_args_t *args);
65 STATIC int xfs_attr_node_addname(xfs_da_args_t *args);
66 STATIC int xfs_attr_node_removename(xfs_da_args_t *args);
67 STATIC int xfs_attr_fillstate(xfs_da_state_t *state);
68 STATIC int xfs_attr_refillstate(xfs_da_state_t *state);
69
70
71 STATIC int
72 xfs_attr_args_init(
73 struct xfs_da_args *args,
74 struct xfs_inode *dp,
75 const unsigned char *name,
76 int flags)
77 {
78
79 if (!name)
80 return -EINVAL;
81
82 memset(args, 0, sizeof(*args));
83 args->geo = dp->i_mount->m_attr_geo;
84 args->whichfork = XFS_ATTR_FORK;
85 args->dp = dp;
86 args->flags = flags;
87 args->name = name;
88 args->namelen = strlen((const char *)name);
89 if (args->namelen >= MAXNAMELEN)
90 return -EFAULT; /* match IRIX behaviour */
91
92 args->hashval = xfs_da_hashname(args->name, args->namelen);
93 return 0;
94 }
95
96 int
97 xfs_inode_hasattr(
98 struct xfs_inode *ip)
99 {
100 if (!XFS_IFORK_Q(ip) ||
101 (ip->i_d.di_aformat == XFS_DINODE_FMT_EXTENTS &&
102 ip->i_d.di_anextents == 0))
103 return 0;
104 return 1;
105 }
106
107 /*========================================================================
108 * Overall external interface routines.
109 *========================================================================*/
110
111 int
112 xfs_attr_get(
113 struct xfs_inode *ip,
114 const unsigned char *name,
115 unsigned char *value,
116 int *valuelenp,
117 int flags)
118 {
119 struct xfs_da_args args;
120 uint lock_mode;
121 int error;
122
123 XFS_STATS_INC(xs_attr_get);
124
125 if (XFS_FORCED_SHUTDOWN(ip->i_mount))
126 return -EIO;
127
128 if (!xfs_inode_hasattr(ip))
129 return -ENOATTR;
130
131 error = xfs_attr_args_init(&args, ip, name, flags);
132 if (error)
133 return error;
134
135 args.value = value;
136 args.valuelen = *valuelenp;
137
138 lock_mode = xfs_ilock_attr_map_shared(ip);
139 if (!xfs_inode_hasattr(ip))
140 error = -ENOATTR;
141 else if (ip->i_d.di_aformat == XFS_DINODE_FMT_LOCAL)
142 error = xfs_attr_shortform_getvalue(&args);
143 else if (xfs_bmap_one_block(ip, XFS_ATTR_FORK))
144 error = xfs_attr_leaf_get(&args);
145 else
146 error = xfs_attr_node_get(&args);
147 xfs_iunlock(ip, lock_mode);
148
149 *valuelenp = args.valuelen;
150 return error == -EEXIST ? 0 : error;
151 }
152
153 /*
154 * Calculate how many blocks we need for the new attribute,
155 */
156 STATIC int
157 xfs_attr_calc_size(
158 struct xfs_da_args *args,
159 int *local)
160 {
161 struct xfs_mount *mp = args->dp->i_mount;
162 int size;
163 int nblks;
164
165 /*
166 * Determine space new attribute will use, and if it would be
167 * "local" or "remote" (note: local != inline).
168 */
169 size = xfs_attr_leaf_newentsize(args, local);
170 nblks = XFS_DAENTER_SPACE_RES(mp, XFS_ATTR_FORK);
171 if (*local) {
172 if (size > (args->geo->blksize / 2)) {
173 /* Double split possible */
174 nblks *= 2;
175 }
176 } else {
177 /*
178 * Out of line attribute, cannot double split, but
179 * make room for the attribute value itself.
180 */
181 uint dblocks = xfs_attr3_rmt_blocks(mp, args->valuelen);
182 nblks += dblocks;
183 nblks += XFS_NEXTENTADD_SPACE_RES(mp, dblocks, XFS_ATTR_FORK);
184 }
185
186 return nblks;
187 }
188
189 int
190 xfs_attr_set(
191 struct xfs_inode *dp,
192 const unsigned char *name,
193 unsigned char *value,
194 int valuelen,
195 int flags)
196 {
197 struct xfs_mount *mp = dp->i_mount;
198 struct xfs_da_args args;
199 struct xfs_bmap_free flist;
200 struct xfs_trans_res tres;
201 xfs_fsblock_t firstblock;
202 int rsvd = (flags & ATTR_ROOT) != 0;
203 int error, err2, committed, local;
204
205 XFS_STATS_INC(xs_attr_set);
206
207 if (XFS_FORCED_SHUTDOWN(dp->i_mount))
208 return -EIO;
209
210 error = xfs_attr_args_init(&args, dp, name, flags);
211 if (error)
212 return error;
213
214 args.value = value;
215 args.valuelen = valuelen;
216 args.firstblock = &firstblock;
217 args.flist = &flist;
218 args.op_flags = XFS_DA_OP_ADDNAME | XFS_DA_OP_OKNOENT;
219 args.total = xfs_attr_calc_size(&args, &local);
220
221 error = xfs_qm_dqattach(dp, 0);
222 if (error)
223 return error;
224
225 /*
226 * If the inode doesn't have an attribute fork, add one.
227 * (inode must not be locked when we call this routine)
228 */
229 if (XFS_IFORK_Q(dp) == 0) {
230 int sf_size = sizeof(xfs_attr_sf_hdr_t) +
231 XFS_ATTR_SF_ENTSIZE_BYNAME(args.namelen, valuelen);
232
233 error = xfs_bmap_add_attrfork(dp, sf_size, rsvd);
234 if (error)
235 return error;
236 }
237
238 /*
239 * Start our first transaction of the day.
240 *
241 * All future transactions during this code must be "chained" off
242 * this one via the trans_dup() call. All transactions will contain
243 * the inode, and the inode will always be marked with trans_ihold().
244 * Since the inode will be locked in all transactions, we must log
245 * the inode in every transaction to let it float upward through
246 * the log.
247 */
248 args.trans = xfs_trans_alloc(mp, XFS_TRANS_ATTR_SET);
249
250 /*
251 * Root fork attributes can use reserved data blocks for this
252 * operation if necessary
253 */
254
255 if (rsvd)
256 args.trans->t_flags |= XFS_TRANS_RESERVE;
257
258 tres.tr_logres = M_RES(mp)->tr_attrsetm.tr_logres +
259 M_RES(mp)->tr_attrsetrt.tr_logres * args.total;
260 tres.tr_logcount = XFS_ATTRSET_LOG_COUNT;
261 tres.tr_logflags = XFS_TRANS_PERM_LOG_RES;
262 error = xfs_trans_reserve(args.trans, &tres, args.total, 0);
263 if (error) {
264 xfs_trans_cancel(args.trans, 0);
265 return error;
266 }
267 xfs_ilock(dp, XFS_ILOCK_EXCL);
268
269 error = xfs_trans_reserve_quota_nblks(args.trans, dp, args.total, 0,
270 rsvd ? XFS_QMOPT_RES_REGBLKS | XFS_QMOPT_FORCE_RES :
271 XFS_QMOPT_RES_REGBLKS);
272 if (error) {
273 xfs_iunlock(dp, XFS_ILOCK_EXCL);
274 xfs_trans_cancel(args.trans, XFS_TRANS_RELEASE_LOG_RES);
275 return error;
276 }
277
278 xfs_trans_ijoin(args.trans, dp, 0);
279
280 /*
281 * If the attribute list is non-existent or a shortform list,
282 * upgrade it to a single-leaf-block attribute list.
283 */
284 if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL ||
285 (dp->i_d.di_aformat == XFS_DINODE_FMT_EXTENTS &&
286 dp->i_d.di_anextents == 0)) {
287
288 /*
289 * Build initial attribute list (if required).
290 */
291 if (dp->i_d.di_aformat == XFS_DINODE_FMT_EXTENTS)
292 xfs_attr_shortform_create(&args);
293
294 /*
295 * Try to add the attr to the attribute list in
296 * the inode.
297 */
298 error = xfs_attr_shortform_addname(&args);
299 if (error != -ENOSPC) {
300 /*
301 * Commit the shortform mods, and we're done.
302 * NOTE: this is also the error path (EEXIST, etc).
303 */
304 ASSERT(args.trans != NULL);
305
306 /*
307 * If this is a synchronous mount, make sure that
308 * the transaction goes to disk before returning
309 * to the user.
310 */
311 if (mp->m_flags & XFS_MOUNT_WSYNC)
312 xfs_trans_set_sync(args.trans);
313
314 if (!error && (flags & ATTR_KERNOTIME) == 0) {
315 xfs_trans_ichgtime(args.trans, dp,
316 XFS_ICHGTIME_CHG);
317 }
318 err2 = xfs_trans_commit(args.trans,
319 XFS_TRANS_RELEASE_LOG_RES);
320 xfs_iunlock(dp, XFS_ILOCK_EXCL);
321
322 return error ? error : err2;
323 }
324
325 /*
326 * It won't fit in the shortform, transform to a leaf block.
327 * GROT: another possible req'mt for a double-split btree op.
328 */
329 xfs_bmap_init(args.flist, args.firstblock);
330 error = xfs_attr_shortform_to_leaf(&args);
331 if (!error) {
332 error = xfs_bmap_finish(&args.trans, args.flist,
333 &committed);
334 }
335 if (error) {
336 ASSERT(committed);
337 args.trans = NULL;
338 xfs_bmap_cancel(&flist);
339 goto out;
340 }
341
342 /*
343 * bmap_finish() may have committed the last trans and started
344 * a new one. We need the inode to be in all transactions.
345 */
346 if (committed)
347 xfs_trans_ijoin(args.trans, dp, 0);
348
349 /*
350 * Commit the leaf transformation. We'll need another (linked)
351 * transaction to add the new attribute to the leaf.
352 */
353
354 error = xfs_trans_roll(&args.trans, dp);
355 if (error)
356 goto out;
357
358 }
359
360 if (xfs_bmap_one_block(dp, XFS_ATTR_FORK))
361 error = xfs_attr_leaf_addname(&args);
362 else
363 error = xfs_attr_node_addname(&args);
364 if (error)
365 goto out;
366
367 /*
368 * If this is a synchronous mount, make sure that the
369 * transaction goes to disk before returning to the user.
370 */
371 if (mp->m_flags & XFS_MOUNT_WSYNC)
372 xfs_trans_set_sync(args.trans);
373
374 if ((flags & ATTR_KERNOTIME) == 0)
375 xfs_trans_ichgtime(args.trans, dp, XFS_ICHGTIME_CHG);
376
377 /*
378 * Commit the last in the sequence of transactions.
379 */
380 xfs_trans_log_inode(args.trans, dp, XFS_ILOG_CORE);
381 error = xfs_trans_commit(args.trans, XFS_TRANS_RELEASE_LOG_RES);
382 xfs_iunlock(dp, XFS_ILOCK_EXCL);
383
384 return error;
385
386 out:
387 if (args.trans) {
388 xfs_trans_cancel(args.trans,
389 XFS_TRANS_RELEASE_LOG_RES|XFS_TRANS_ABORT);
390 }
391 xfs_iunlock(dp, XFS_ILOCK_EXCL);
392 return error;
393 }
394
395 /*
396 * Generic handler routine to remove a name from an attribute list.
397 * Transitions attribute list from Btree to shortform as necessary.
398 */
399 int
400 xfs_attr_remove(
401 struct xfs_inode *dp,
402 const unsigned char *name,
403 int flags)
404 {
405 struct xfs_mount *mp = dp->i_mount;
406 struct xfs_da_args args;
407 struct xfs_bmap_free flist;
408 xfs_fsblock_t firstblock;
409 int error;
410
411 XFS_STATS_INC(xs_attr_remove);
412
413 if (XFS_FORCED_SHUTDOWN(dp->i_mount))
414 return -EIO;
415
416 if (!xfs_inode_hasattr(dp))
417 return -ENOATTR;
418
419 error = xfs_attr_args_init(&args, dp, name, flags);
420 if (error)
421 return error;
422
423 args.firstblock = &firstblock;
424 args.flist = &flist;
425
426 /*
427 * we have no control over the attribute names that userspace passes us
428 * to remove, so we have to allow the name lookup prior to attribute
429 * removal to fail.
430 */
431 args.op_flags = XFS_DA_OP_OKNOENT;
432
433 error = xfs_qm_dqattach(dp, 0);
434 if (error)
435 return error;
436
437 /*
438 * Start our first transaction of the day.
439 *
440 * All future transactions during this code must be "chained" off
441 * this one via the trans_dup() call. All transactions will contain
442 * the inode, and the inode will always be marked with trans_ihold().
443 * Since the inode will be locked in all transactions, we must log
444 * the inode in every transaction to let it float upward through
445 * the log.
446 */
447 args.trans = xfs_trans_alloc(mp, XFS_TRANS_ATTR_RM);
448
449 /*
450 * Root fork attributes can use reserved data blocks for this
451 * operation if necessary
452 */
453
454 if (flags & ATTR_ROOT)
455 args.trans->t_flags |= XFS_TRANS_RESERVE;
456
457 error = xfs_trans_reserve(args.trans, &M_RES(mp)->tr_attrrm,
458 XFS_ATTRRM_SPACE_RES(mp), 0);
459 if (error) {
460 xfs_trans_cancel(args.trans, 0);
461 return error;
462 }
463
464 xfs_ilock(dp, XFS_ILOCK_EXCL);
465 /*
466 * No need to make quota reservations here. We expect to release some
467 * blocks not allocate in the common case.
468 */
469 xfs_trans_ijoin(args.trans, dp, 0);
470
471 if (!xfs_inode_hasattr(dp)) {
472 error = -ENOATTR;
473 } else if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
474 ASSERT(dp->i_afp->if_flags & XFS_IFINLINE);
475 error = xfs_attr_shortform_remove(&args);
476 } else if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
477 error = xfs_attr_leaf_removename(&args);
478 } else {
479 error = xfs_attr_node_removename(&args);
480 }
481
482 if (error)
483 goto out;
484
485 /*
486 * If this is a synchronous mount, make sure that the
487 * transaction goes to disk before returning to the user.
488 */
489 if (mp->m_flags & XFS_MOUNT_WSYNC)
490 xfs_trans_set_sync(args.trans);
491
492 if ((flags & ATTR_KERNOTIME) == 0)
493 xfs_trans_ichgtime(args.trans, dp, XFS_ICHGTIME_CHG);
494
495 /*
496 * Commit the last in the sequence of transactions.
497 */
498 xfs_trans_log_inode(args.trans, dp, XFS_ILOG_CORE);
499 error = xfs_trans_commit(args.trans, XFS_TRANS_RELEASE_LOG_RES);
500 xfs_iunlock(dp, XFS_ILOCK_EXCL);
501
502 return error;
503
504 out:
505 if (args.trans) {
506 xfs_trans_cancel(args.trans,
507 XFS_TRANS_RELEASE_LOG_RES|XFS_TRANS_ABORT);
508 }
509 xfs_iunlock(dp, XFS_ILOCK_EXCL);
510 return error;
511 }
512
513 /*========================================================================
514 * External routines when attribute list is inside the inode
515 *========================================================================*/
516
517 /*
518 * Add a name to the shortform attribute list structure
519 * This is the external routine.
520 */
521 STATIC int
522 xfs_attr_shortform_addname(xfs_da_args_t *args)
523 {
524 int newsize, forkoff, retval;
525
526 trace_xfs_attr_sf_addname(args);
527
528 retval = xfs_attr_shortform_lookup(args);
529 if ((args->flags & ATTR_REPLACE) && (retval == -ENOATTR)) {
530 return retval;
531 } else if (retval == -EEXIST) {
532 if (args->flags & ATTR_CREATE)
533 return retval;
534 retval = xfs_attr_shortform_remove(args);
535 ASSERT(retval == 0);
536 }
537
538 if (args->namelen >= XFS_ATTR_SF_ENTSIZE_MAX ||
539 args->valuelen >= XFS_ATTR_SF_ENTSIZE_MAX)
540 return -ENOSPC;
541
542 newsize = XFS_ATTR_SF_TOTSIZE(args->dp);
543 newsize += XFS_ATTR_SF_ENTSIZE_BYNAME(args->namelen, args->valuelen);
544
545 forkoff = xfs_attr_shortform_bytesfit(args->dp, newsize);
546 if (!forkoff)
547 return -ENOSPC;
548
549 xfs_attr_shortform_add(args, forkoff);
550 return 0;
551 }
552
553
554 /*========================================================================
555 * External routines when attribute list is one block
556 *========================================================================*/
557
558 /*
559 * Add a name to the leaf attribute list structure
560 *
561 * This leaf block cannot have a "remote" value, we only call this routine
562 * if bmap_one_block() says there is only one block (ie: no remote blks).
563 */
564 STATIC int
565 xfs_attr_leaf_addname(xfs_da_args_t *args)
566 {
567 xfs_inode_t *dp;
568 struct xfs_buf *bp;
569 int retval, error, committed, forkoff;
570
571 trace_xfs_attr_leaf_addname(args);
572
573 /*
574 * Read the (only) block in the attribute list in.
575 */
576 dp = args->dp;
577 args->blkno = 0;
578 error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, -1, &bp);
579 if (error)
580 return error;
581
582 /*
583 * Look up the given attribute in the leaf block. Figure out if
584 * the given flags produce an error or call for an atomic rename.
585 */
586 retval = xfs_attr3_leaf_lookup_int(bp, args);
587 if ((args->flags & ATTR_REPLACE) && (retval == -ENOATTR)) {
588 xfs_trans_brelse(args->trans, bp);
589 return retval;
590 } else if (retval == -EEXIST) {
591 if (args->flags & ATTR_CREATE) { /* pure create op */
592 xfs_trans_brelse(args->trans, bp);
593 return retval;
594 }
595
596 trace_xfs_attr_leaf_replace(args);
597
598 /* save the attribute state for later removal*/
599 args->op_flags |= XFS_DA_OP_RENAME; /* an atomic rename */
600 args->blkno2 = args->blkno; /* set 2nd entry info*/
601 args->index2 = args->index;
602 args->rmtblkno2 = args->rmtblkno;
603 args->rmtblkcnt2 = args->rmtblkcnt;
604 args->rmtvaluelen2 = args->rmtvaluelen;
605
606 /*
607 * clear the remote attr state now that it is saved so that the
608 * values reflect the state of the attribute we are about to
609 * add, not the attribute we just found and will remove later.
610 */
611 args->rmtblkno = 0;
612 args->rmtblkcnt = 0;
613 args->rmtvaluelen = 0;
614 }
615
616 /*
617 * Add the attribute to the leaf block, transitioning to a Btree
618 * if required.
619 */
620 retval = xfs_attr3_leaf_add(bp, args);
621 if (retval == -ENOSPC) {
622 /*
623 * Promote the attribute list to the Btree format, then
624 * Commit that transaction so that the node_addname() call
625 * can manage its own transactions.
626 */
627 xfs_bmap_init(args->flist, args->firstblock);
628 error = xfs_attr3_leaf_to_node(args);
629 if (!error) {
630 error = xfs_bmap_finish(&args->trans, args->flist,
631 &committed);
632 }
633 if (error) {
634 ASSERT(committed);
635 args->trans = NULL;
636 xfs_bmap_cancel(args->flist);
637 return error;
638 }
639
640 /*
641 * bmap_finish() may have committed the last trans and started
642 * a new one. We need the inode to be in all transactions.
643 */
644 if (committed)
645 xfs_trans_ijoin(args->trans, dp, 0);
646
647 /*
648 * Commit the current trans (including the inode) and start
649 * a new one.
650 */
651 error = xfs_trans_roll(&args->trans, dp);
652 if (error)
653 return error;
654
655 /*
656 * Fob the whole rest of the problem off on the Btree code.
657 */
658 error = xfs_attr_node_addname(args);
659 return error;
660 }
661
662 /*
663 * Commit the transaction that added the attr name so that
664 * later routines can manage their own transactions.
665 */
666 error = xfs_trans_roll(&args->trans, dp);
667 if (error)
668 return error;
669
670 /*
671 * If there was an out-of-line value, allocate the blocks we
672 * identified for its storage and copy the value. This is done
673 * after we create the attribute so that we don't overflow the
674 * maximum size of a transaction and/or hit a deadlock.
675 */
676 if (args->rmtblkno > 0) {
677 error = xfs_attr_rmtval_set(args);
678 if (error)
679 return error;
680 }
681
682 /*
683 * If this is an atomic rename operation, we must "flip" the
684 * incomplete flags on the "new" and "old" attribute/value pairs
685 * so that one disappears and one appears atomically. Then we
686 * must remove the "old" attribute/value pair.
687 */
688 if (args->op_flags & XFS_DA_OP_RENAME) {
689 /*
690 * In a separate transaction, set the incomplete flag on the
691 * "old" attr and clear the incomplete flag on the "new" attr.
692 */
693 error = xfs_attr3_leaf_flipflags(args);
694 if (error)
695 return error;
696
697 /*
698 * Dismantle the "old" attribute/value pair by removing
699 * a "remote" value (if it exists).
700 */
701 args->index = args->index2;
702 args->blkno = args->blkno2;
703 args->rmtblkno = args->rmtblkno2;
704 args->rmtblkcnt = args->rmtblkcnt2;
705 args->rmtvaluelen = args->rmtvaluelen2;
706 if (args->rmtblkno) {
707 error = xfs_attr_rmtval_remove(args);
708 if (error)
709 return error;
710 }
711
712 /*
713 * Read in the block containing the "old" attr, then
714 * remove the "old" attr from that block (neat, huh!)
715 */
716 error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno,
717 -1, &bp);
718 if (error)
719 return error;
720
721 xfs_attr3_leaf_remove(bp, args);
722
723 /*
724 * If the result is small enough, shrink it all into the inode.
725 */
726 if ((forkoff = xfs_attr_shortform_allfit(bp, dp))) {
727 xfs_bmap_init(args->flist, args->firstblock);
728 error = xfs_attr3_leaf_to_shortform(bp, args, forkoff);
729 /* bp is gone due to xfs_da_shrink_inode */
730 if (!error) {
731 error = xfs_bmap_finish(&args->trans,
732 args->flist,
733 &committed);
734 }
735 if (error) {
736 ASSERT(committed);
737 args->trans = NULL;
738 xfs_bmap_cancel(args->flist);
739 return error;
740 }
741
742 /*
743 * bmap_finish() may have committed the last trans
744 * and started a new one. We need the inode to be
745 * in all transactions.
746 */
747 if (committed)
748 xfs_trans_ijoin(args->trans, dp, 0);
749 }
750
751 /*
752 * Commit the remove and start the next trans in series.
753 */
754 error = xfs_trans_roll(&args->trans, dp);
755
756 } else if (args->rmtblkno > 0) {
757 /*
758 * Added a "remote" value, just clear the incomplete flag.
759 */
760 error = xfs_attr3_leaf_clearflag(args);
761 }
762 return error;
763 }
764
765 /*
766 * Remove a name from the leaf attribute list structure
767 *
768 * This leaf block cannot have a "remote" value, we only call this routine
769 * if bmap_one_block() says there is only one block (ie: no remote blks).
770 */
771 STATIC int
772 xfs_attr_leaf_removename(xfs_da_args_t *args)
773 {
774 xfs_inode_t *dp;
775 struct xfs_buf *bp;
776 int error, committed, forkoff;
777
778 trace_xfs_attr_leaf_removename(args);
779
780 /*
781 * Remove the attribute.
782 */
783 dp = args->dp;
784 args->blkno = 0;
785 error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, -1, &bp);
786 if (error)
787 return error;
788
789 error = xfs_attr3_leaf_lookup_int(bp, args);
790 if (error == -ENOATTR) {
791 xfs_trans_brelse(args->trans, bp);
792 return error;
793 }
794
795 xfs_attr3_leaf_remove(bp, args);
796
797 /*
798 * If the result is small enough, shrink it all into the inode.
799 */
800 if ((forkoff = xfs_attr_shortform_allfit(bp, dp))) {
801 xfs_bmap_init(args->flist, args->firstblock);
802 error = xfs_attr3_leaf_to_shortform(bp, args, forkoff);
803 /* bp is gone due to xfs_da_shrink_inode */
804 if (!error) {
805 error = xfs_bmap_finish(&args->trans, args->flist,
806 &committed);
807 }
808 if (error) {
809 ASSERT(committed);
810 args->trans = NULL;
811 xfs_bmap_cancel(args->flist);
812 return error;
813 }
814
815 /*
816 * bmap_finish() may have committed the last trans and started
817 * a new one. We need the inode to be in all transactions.
818 */
819 if (committed)
820 xfs_trans_ijoin(args->trans, dp, 0);
821 }
822 return 0;
823 }
824
825 /*
826 * Look up a name in a leaf attribute list structure.
827 *
828 * This leaf block cannot have a "remote" value, we only call this routine
829 * if bmap_one_block() says there is only one block (ie: no remote blks).
830 */
831 STATIC int
832 xfs_attr_leaf_get(xfs_da_args_t *args)
833 {
834 struct xfs_buf *bp;
835 int error;
836
837 trace_xfs_attr_leaf_get(args);
838
839 args->blkno = 0;
840 error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, -1, &bp);
841 if (error)
842 return error;
843
844 error = xfs_attr3_leaf_lookup_int(bp, args);
845 if (error != -EEXIST) {
846 xfs_trans_brelse(args->trans, bp);
847 return error;
848 }
849 error = xfs_attr3_leaf_getvalue(bp, args);
850 xfs_trans_brelse(args->trans, bp);
851 if (!error && (args->rmtblkno > 0) && !(args->flags & ATTR_KERNOVAL)) {
852 error = xfs_attr_rmtval_get(args);
853 }
854 return error;
855 }
856
857 /*========================================================================
858 * External routines when attribute list size > geo->blksize
859 *========================================================================*/
860
861 /*
862 * Add a name to a Btree-format attribute list.
863 *
864 * This will involve walking down the Btree, and may involve splitting
865 * leaf nodes and even splitting intermediate nodes up to and including
866 * the root node (a special case of an intermediate node).
867 *
868 * "Remote" attribute values confuse the issue and atomic rename operations
869 * add a whole extra layer of confusion on top of that.
870 */
871 STATIC int
872 xfs_attr_node_addname(xfs_da_args_t *args)
873 {
874 xfs_da_state_t *state;
875 xfs_da_state_blk_t *blk;
876 xfs_inode_t *dp;
877 xfs_mount_t *mp;
878 int committed, retval, error;
879
880 trace_xfs_attr_node_addname(args);
881
882 /*
883 * Fill in bucket of arguments/results/context to carry around.
884 */
885 dp = args->dp;
886 mp = dp->i_mount;
887 restart:
888 state = xfs_da_state_alloc();
889 state->args = args;
890 state->mp = mp;
891
892 /*
893 * Search to see if name already exists, and get back a pointer
894 * to where it should go.
895 */
896 error = xfs_da3_node_lookup_int(state, &retval);
897 if (error)
898 goto out;
899 blk = &state->path.blk[ state->path.active-1 ];
900 ASSERT(blk->magic == XFS_ATTR_LEAF_MAGIC);
901 if ((args->flags & ATTR_REPLACE) && (retval == -ENOATTR)) {
902 goto out;
903 } else if (retval == -EEXIST) {
904 if (args->flags & ATTR_CREATE)
905 goto out;
906
907 trace_xfs_attr_node_replace(args);
908
909 /* save the attribute state for later removal*/
910 args->op_flags |= XFS_DA_OP_RENAME; /* atomic rename op */
911 args->blkno2 = args->blkno; /* set 2nd entry info*/
912 args->index2 = args->index;
913 args->rmtblkno2 = args->rmtblkno;
914 args->rmtblkcnt2 = args->rmtblkcnt;
915 args->rmtvaluelen2 = args->rmtvaluelen;
916
917 /*
918 * clear the remote attr state now that it is saved so that the
919 * values reflect the state of the attribute we are about to
920 * add, not the attribute we just found and will remove later.
921 */
922 args->rmtblkno = 0;
923 args->rmtblkcnt = 0;
924 args->rmtvaluelen = 0;
925 }
926
927 retval = xfs_attr3_leaf_add(blk->bp, state->args);
928 if (retval == -ENOSPC) {
929 if (state->path.active == 1) {
930 /*
931 * Its really a single leaf node, but it had
932 * out-of-line values so it looked like it *might*
933 * have been a b-tree.
934 */
935 xfs_da_state_free(state);
936 state = NULL;
937 xfs_bmap_init(args->flist, args->firstblock);
938 error = xfs_attr3_leaf_to_node(args);
939 if (!error) {
940 error = xfs_bmap_finish(&args->trans,
941 args->flist,
942 &committed);
943 }
944 if (error) {
945 ASSERT(committed);
946 args->trans = NULL;
947 xfs_bmap_cancel(args->flist);
948 goto out;
949 }
950
951 /*
952 * bmap_finish() may have committed the last trans
953 * and started a new one. We need the inode to be
954 * in all transactions.
955 */
956 if (committed)
957 xfs_trans_ijoin(args->trans, dp, 0);
958
959 /*
960 * Commit the node conversion and start the next
961 * trans in the chain.
962 */
963 error = xfs_trans_roll(&args->trans, dp);
964 if (error)
965 goto out;
966
967 goto restart;
968 }
969
970 /*
971 * Split as many Btree elements as required.
972 * This code tracks the new and old attr's location
973 * in the index/blkno/rmtblkno/rmtblkcnt fields and
974 * in the index2/blkno2/rmtblkno2/rmtblkcnt2 fields.
975 */
976 xfs_bmap_init(args->flist, args->firstblock);
977 error = xfs_da3_split(state);
978 if (!error) {
979 error = xfs_bmap_finish(&args->trans, args->flist,
980 &committed);
981 }
982 if (error) {
983 ASSERT(committed);
984 args->trans = NULL;
985 xfs_bmap_cancel(args->flist);
986 goto out;
987 }
988
989 /*
990 * bmap_finish() may have committed the last trans and started
991 * a new one. We need the inode to be in all transactions.
992 */
993 if (committed)
994 xfs_trans_ijoin(args->trans, dp, 0);
995 } else {
996 /*
997 * Addition succeeded, update Btree hashvals.
998 */
999 xfs_da3_fixhashpath(state, &state->path);
1000 }
1001
1002 /*
1003 * Kill the state structure, we're done with it and need to
1004 * allow the buffers to come back later.
1005 */
1006 xfs_da_state_free(state);
1007 state = NULL;
1008
1009 /*
1010 * Commit the leaf addition or btree split and start the next
1011 * trans in the chain.
1012 */
1013 error = xfs_trans_roll(&args->trans, dp);
1014 if (error)
1015 goto out;
1016
1017 /*
1018 * If there was an out-of-line value, allocate the blocks we
1019 * identified for its storage and copy the value. This is done
1020 * after we create the attribute so that we don't overflow the
1021 * maximum size of a transaction and/or hit a deadlock.
1022 */
1023 if (args->rmtblkno > 0) {
1024 error = xfs_attr_rmtval_set(args);
1025 if (error)
1026 return error;
1027 }
1028
1029 /*
1030 * If this is an atomic rename operation, we must "flip" the
1031 * incomplete flags on the "new" and "old" attribute/value pairs
1032 * so that one disappears and one appears atomically. Then we
1033 * must remove the "old" attribute/value pair.
1034 */
1035 if (args->op_flags & XFS_DA_OP_RENAME) {
1036 /*
1037 * In a separate transaction, set the incomplete flag on the
1038 * "old" attr and clear the incomplete flag on the "new" attr.
1039 */
1040 error = xfs_attr3_leaf_flipflags(args);
1041 if (error)
1042 goto out;
1043
1044 /*
1045 * Dismantle the "old" attribute/value pair by removing
1046 * a "remote" value (if it exists).
1047 */
1048 args->index = args->index2;
1049 args->blkno = args->blkno2;
1050 args->rmtblkno = args->rmtblkno2;
1051 args->rmtblkcnt = args->rmtblkcnt2;
1052 args->rmtvaluelen = args->rmtvaluelen2;
1053 if (args->rmtblkno) {
1054 error = xfs_attr_rmtval_remove(args);
1055 if (error)
1056 return error;
1057 }
1058
1059 /*
1060 * Re-find the "old" attribute entry after any split ops.
1061 * The INCOMPLETE flag means that we will find the "old"
1062 * attr, not the "new" one.
1063 */
1064 args->flags |= XFS_ATTR_INCOMPLETE;
1065 state = xfs_da_state_alloc();
1066 state->args = args;
1067 state->mp = mp;
1068 state->inleaf = 0;
1069 error = xfs_da3_node_lookup_int(state, &retval);
1070 if (error)
1071 goto out;
1072
1073 /*
1074 * Remove the name and update the hashvals in the tree.
1075 */
1076 blk = &state->path.blk[ state->path.active-1 ];
1077 ASSERT(blk->magic == XFS_ATTR_LEAF_MAGIC);
1078 error = xfs_attr3_leaf_remove(blk->bp, args);
1079 xfs_da3_fixhashpath(state, &state->path);
1080
1081 /*
1082 * Check to see if the tree needs to be collapsed.
1083 */
1084 if (retval && (state->path.active > 1)) {
1085 xfs_bmap_init(args->flist, args->firstblock);
1086 error = xfs_da3_join(state);
1087 if (!error) {
1088 error = xfs_bmap_finish(&args->trans,
1089 args->flist,
1090 &committed);
1091 }
1092 if (error) {
1093 ASSERT(committed);
1094 args->trans = NULL;
1095 xfs_bmap_cancel(args->flist);
1096 goto out;
1097 }
1098
1099 /*
1100 * bmap_finish() may have committed the last trans
1101 * and started a new one. We need the inode to be
1102 * in all transactions.
1103 */
1104 if (committed)
1105 xfs_trans_ijoin(args->trans, dp, 0);
1106 }
1107
1108 /*
1109 * Commit and start the next trans in the chain.
1110 */
1111 error = xfs_trans_roll(&args->trans, dp);
1112 if (error)
1113 goto out;
1114
1115 } else if (args->rmtblkno > 0) {
1116 /*
1117 * Added a "remote" value, just clear the incomplete flag.
1118 */
1119 error = xfs_attr3_leaf_clearflag(args);
1120 if (error)
1121 goto out;
1122 }
1123 retval = error = 0;
1124
1125 out:
1126 if (state)
1127 xfs_da_state_free(state);
1128 if (error)
1129 return error;
1130 return retval;
1131 }
1132
1133 /*
1134 * Remove a name from a B-tree attribute list.
1135 *
1136 * This will involve walking down the Btree, and may involve joining
1137 * leaf nodes and even joining intermediate nodes up to and including
1138 * the root node (a special case of an intermediate node).
1139 */
1140 STATIC int
1141 xfs_attr_node_removename(xfs_da_args_t *args)
1142 {
1143 xfs_da_state_t *state;
1144 xfs_da_state_blk_t *blk;
1145 xfs_inode_t *dp;
1146 struct xfs_buf *bp;
1147 int retval, error, committed, forkoff;
1148
1149 trace_xfs_attr_node_removename(args);
1150
1151 /*
1152 * Tie a string around our finger to remind us where we are.
1153 */
1154 dp = args->dp;
1155 state = xfs_da_state_alloc();
1156 state->args = args;
1157 state->mp = dp->i_mount;
1158
1159 /*
1160 * Search to see if name exists, and get back a pointer to it.
1161 */
1162 error = xfs_da3_node_lookup_int(state, &retval);
1163 if (error || (retval != -EEXIST)) {
1164 if (error == 0)
1165 error = retval;
1166 goto out;
1167 }
1168
1169 /*
1170 * If there is an out-of-line value, de-allocate the blocks.
1171 * This is done before we remove the attribute so that we don't
1172 * overflow the maximum size of a transaction and/or hit a deadlock.
1173 */
1174 blk = &state->path.blk[ state->path.active-1 ];
1175 ASSERT(blk->bp != NULL);
1176 ASSERT(blk->magic == XFS_ATTR_LEAF_MAGIC);
1177 if (args->rmtblkno > 0) {
1178 /*
1179 * Fill in disk block numbers in the state structure
1180 * so that we can get the buffers back after we commit
1181 * several transactions in the following calls.
1182 */
1183 error = xfs_attr_fillstate(state);
1184 if (error)
1185 goto out;
1186
1187 /*
1188 * Mark the attribute as INCOMPLETE, then bunmapi() the
1189 * remote value.
1190 */
1191 error = xfs_attr3_leaf_setflag(args);
1192 if (error)
1193 goto out;
1194 error = xfs_attr_rmtval_remove(args);
1195 if (error)
1196 goto out;
1197
1198 /*
1199 * Refill the state structure with buffers, the prior calls
1200 * released our buffers.
1201 */
1202 error = xfs_attr_refillstate(state);
1203 if (error)
1204 goto out;
1205 }
1206
1207 /*
1208 * Remove the name and update the hashvals in the tree.
1209 */
1210 blk = &state->path.blk[ state->path.active-1 ];
1211 ASSERT(blk->magic == XFS_ATTR_LEAF_MAGIC);
1212 retval = xfs_attr3_leaf_remove(blk->bp, args);
1213 xfs_da3_fixhashpath(state, &state->path);
1214
1215 /*
1216 * Check to see if the tree needs to be collapsed.
1217 */
1218 if (retval && (state->path.active > 1)) {
1219 xfs_bmap_init(args->flist, args->firstblock);
1220 error = xfs_da3_join(state);
1221 if (!error) {
1222 error = xfs_bmap_finish(&args->trans, args->flist,
1223 &committed);
1224 }
1225 if (error) {
1226 ASSERT(committed);
1227 args->trans = NULL;
1228 xfs_bmap_cancel(args->flist);
1229 goto out;
1230 }
1231
1232 /*
1233 * bmap_finish() may have committed the last trans and started
1234 * a new one. We need the inode to be in all transactions.
1235 */
1236 if (committed)
1237 xfs_trans_ijoin(args->trans, dp, 0);
1238
1239 /*
1240 * Commit the Btree join operation and start a new trans.
1241 */
1242 error = xfs_trans_roll(&args->trans, dp);
1243 if (error)
1244 goto out;
1245 }
1246
1247 /*
1248 * If the result is small enough, push it all into the inode.
1249 */
1250 if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
1251 /*
1252 * Have to get rid of the copy of this dabuf in the state.
1253 */
1254 ASSERT(state->path.active == 1);
1255 ASSERT(state->path.blk[0].bp);
1256 state->path.blk[0].bp = NULL;
1257
1258 error = xfs_attr3_leaf_read(args->trans, args->dp, 0, -1, &bp);
1259 if (error)
1260 goto out;
1261
1262 if ((forkoff = xfs_attr_shortform_allfit(bp, dp))) {
1263 xfs_bmap_init(args->flist, args->firstblock);
1264 error = xfs_attr3_leaf_to_shortform(bp, args, forkoff);
1265 /* bp is gone due to xfs_da_shrink_inode */
1266 if (!error) {
1267 error = xfs_bmap_finish(&args->trans,
1268 args->flist,
1269 &committed);
1270 }
1271 if (error) {
1272 ASSERT(committed);
1273 args->trans = NULL;
1274 xfs_bmap_cancel(args->flist);
1275 goto out;
1276 }
1277
1278 /*
1279 * bmap_finish() may have committed the last trans
1280 * and started a new one. We need the inode to be
1281 * in all transactions.
1282 */
1283 if (committed)
1284 xfs_trans_ijoin(args->trans, dp, 0);
1285 } else
1286 xfs_trans_brelse(args->trans, bp);
1287 }
1288 error = 0;
1289
1290 out:
1291 xfs_da_state_free(state);
1292 return error;
1293 }
1294
1295 /*
1296 * Fill in the disk block numbers in the state structure for the buffers
1297 * that are attached to the state structure.
1298 * This is done so that we can quickly reattach ourselves to those buffers
1299 * after some set of transaction commits have released these buffers.
1300 */
1301 STATIC int
1302 xfs_attr_fillstate(xfs_da_state_t *state)
1303 {
1304 xfs_da_state_path_t *path;
1305 xfs_da_state_blk_t *blk;
1306 int level;
1307
1308 trace_xfs_attr_fillstate(state->args);
1309
1310 /*
1311 * Roll down the "path" in the state structure, storing the on-disk
1312 * block number for those buffers in the "path".
1313 */
1314 path = &state->path;
1315 ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH));
1316 for (blk = path->blk, level = 0; level < path->active; blk++, level++) {
1317 if (blk->bp) {
1318 blk->disk_blkno = XFS_BUF_ADDR(blk->bp);
1319 blk->bp = NULL;
1320 } else {
1321 blk->disk_blkno = 0;
1322 }
1323 }
1324
1325 /*
1326 * Roll down the "altpath" in the state structure, storing the on-disk
1327 * block number for those buffers in the "altpath".
1328 */
1329 path = &state->altpath;
1330 ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH));
1331 for (blk = path->blk, level = 0; level < path->active; blk++, level++) {
1332 if (blk->bp) {
1333 blk->disk_blkno = XFS_BUF_ADDR(blk->bp);
1334 blk->bp = NULL;
1335 } else {
1336 blk->disk_blkno = 0;
1337 }
1338 }
1339
1340 return 0;
1341 }
1342
1343 /*
1344 * Reattach the buffers to the state structure based on the disk block
1345 * numbers stored in the state structure.
1346 * This is done after some set of transaction commits have released those
1347 * buffers from our grip.
1348 */
1349 STATIC int
1350 xfs_attr_refillstate(xfs_da_state_t *state)
1351 {
1352 xfs_da_state_path_t *path;
1353 xfs_da_state_blk_t *blk;
1354 int level, error;
1355
1356 trace_xfs_attr_refillstate(state->args);
1357
1358 /*
1359 * Roll down the "path" in the state structure, storing the on-disk
1360 * block number for those buffers in the "path".
1361 */
1362 path = &state->path;
1363 ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH));
1364 for (blk = path->blk, level = 0; level < path->active; blk++, level++) {
1365 if (blk->disk_blkno) {
1366 error = xfs_da3_node_read(state->args->trans,
1367 state->args->dp,
1368 blk->blkno, blk->disk_blkno,
1369 &blk->bp, XFS_ATTR_FORK);
1370 if (error)
1371 return error;
1372 } else {
1373 blk->bp = NULL;
1374 }
1375 }
1376
1377 /*
1378 * Roll down the "altpath" in the state structure, storing the on-disk
1379 * block number for those buffers in the "altpath".
1380 */
1381 path = &state->altpath;
1382 ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH));
1383 for (blk = path->blk, level = 0; level < path->active; blk++, level++) {
1384 if (blk->disk_blkno) {
1385 error = xfs_da3_node_read(state->args->trans,
1386 state->args->dp,
1387 blk->blkno, blk->disk_blkno,
1388 &blk->bp, XFS_ATTR_FORK);
1389 if (error)
1390 return error;
1391 } else {
1392 blk->bp = NULL;
1393 }
1394 }
1395
1396 return 0;
1397 }
1398
1399 /*
1400 * Look up a filename in a node attribute list.
1401 *
1402 * This routine gets called for any attribute fork that has more than one
1403 * block, ie: both true Btree attr lists and for single-leaf-blocks with
1404 * "remote" values taking up more blocks.
1405 */
1406 STATIC int
1407 xfs_attr_node_get(xfs_da_args_t *args)
1408 {
1409 xfs_da_state_t *state;
1410 xfs_da_state_blk_t *blk;
1411 int error, retval;
1412 int i;
1413
1414 trace_xfs_attr_node_get(args);
1415
1416 state = xfs_da_state_alloc();
1417 state->args = args;
1418 state->mp = args->dp->i_mount;
1419
1420 /*
1421 * Search to see if name exists, and get back a pointer to it.
1422 */
1423 error = xfs_da3_node_lookup_int(state, &retval);
1424 if (error) {
1425 retval = error;
1426 } else if (retval == -EEXIST) {
1427 blk = &state->path.blk[ state->path.active-1 ];
1428 ASSERT(blk->bp != NULL);
1429 ASSERT(blk->magic == XFS_ATTR_LEAF_MAGIC);
1430
1431 /*
1432 * Get the value, local or "remote"
1433 */
1434 retval = xfs_attr3_leaf_getvalue(blk->bp, args);
1435 if (!retval && (args->rmtblkno > 0)
1436 && !(args->flags & ATTR_KERNOVAL)) {
1437 retval = xfs_attr_rmtval_get(args);
1438 }
1439 }
1440
1441 /*
1442 * If not in a transaction, we have to release all the buffers.
1443 */
1444 for (i = 0; i < state->path.active; i++) {
1445 xfs_trans_brelse(args->trans, state->path.blk[i].bp);
1446 state->path.blk[i].bp = NULL;
1447 }
1448
1449 xfs_da_state_free(state);
1450 return retval;
1451 }
Unnamed repository; edit this file 'description' to name the repository.