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