1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Copyright (C) 2022 Oracle. All Rights Reserved.
4 * Author: Allison Henderson <allison.henderson@oracle.com>
9 #include "xfs_format.h"
10 #include "xfs_trans_resv.h"
11 #include "xfs_shared.h"
12 #include "xfs_mount.h"
13 #include "xfs_defer.h"
14 #include "xfs_log_format.h"
15 #include "xfs_trans.h"
16 #include "xfs_bmap_btree.h"
17 #include "xfs_trans_priv.h"
19 #include "xfs_inode.h"
20 #include "xfs_da_format.h"
21 #include "xfs_da_btree.h"
23 #include "xfs_attr_item.h"
24 #include "xfs_trace.h"
25 #include "xfs_trans_space.h"
26 #include "xfs_errortag.h"
27 #include "xfs_error.h"
28 #include "xfs_log_priv.h"
29 #include "xfs_log_recover.h"
31 struct kmem_cache
*xfs_attri_cache
;
32 struct kmem_cache
*xfs_attrd_cache
;
34 static const struct xfs_item_ops xfs_attri_item_ops
;
35 static const struct xfs_item_ops xfs_attrd_item_ops
;
36 static struct xfs_attrd_log_item
*xfs_trans_get_attrd(struct xfs_trans
*tp
,
37 struct xfs_attri_log_item
*attrip
);
39 static inline struct xfs_attri_log_item
*ATTRI_ITEM(struct xfs_log_item
*lip
)
41 return container_of(lip
, struct xfs_attri_log_item
, attri_item
);
45 * Shared xattr name/value buffers for logged extended attribute operations
47 * When logging updates to extended attributes, we can create quite a few
48 * attribute log intent items for a single xattr update. To avoid cycling the
49 * memory allocator and memcpy overhead, the name (and value, for setxattr)
50 * are kept in a refcounted object that is shared across all related log items
51 * and the upper-level deferred work state structure. The shared buffer has
52 * a control structure, followed by the name, and then the value.
55 static inline struct xfs_attri_log_nameval
*
56 xfs_attri_log_nameval_get(
57 struct xfs_attri_log_nameval
*nv
)
59 if (!refcount_inc_not_zero(&nv
->refcount
))
65 xfs_attri_log_nameval_put(
66 struct xfs_attri_log_nameval
*nv
)
70 if (refcount_dec_and_test(&nv
->refcount
))
74 static inline struct xfs_attri_log_nameval
*
75 xfs_attri_log_nameval_alloc(
77 unsigned int name_len
,
79 unsigned int value_len
)
81 struct xfs_attri_log_nameval
*nv
;
84 * This could be over 64kB in length, so we have to use kvmalloc() for
85 * this. But kvmalloc() utterly sucks, so we use our own version.
87 nv
= xlog_kvmalloc(sizeof(struct xfs_attri_log_nameval
) +
88 name_len
+ value_len
);
92 nv
->name
.i_addr
= nv
+ 1;
93 nv
->name
.i_len
= name_len
;
94 nv
->name
.i_type
= XLOG_REG_TYPE_ATTR_NAME
;
95 memcpy(nv
->name
.i_addr
, name
, name_len
);
98 nv
->value
.i_addr
= nv
->name
.i_addr
+ name_len
;
99 nv
->value
.i_len
= value_len
;
100 memcpy(nv
->value
.i_addr
, value
, value_len
);
102 nv
->value
.i_addr
= NULL
;
105 nv
->value
.i_type
= XLOG_REG_TYPE_ATTR_VALUE
;
107 refcount_set(&nv
->refcount
, 1);
113 struct xfs_attri_log_item
*attrip
)
115 kmem_free(attrip
->attri_item
.li_lv_shadow
);
116 xfs_attri_log_nameval_put(attrip
->attri_nameval
);
117 kmem_cache_free(xfs_attri_cache
, attrip
);
121 * Freeing the attrip requires that we remove it from the AIL if it has already
122 * been placed there. However, the ATTRI may not yet have been placed in the
123 * AIL when called by xfs_attri_release() from ATTRD processing due to the
124 * ordering of committed vs unpin operations in bulk insert operations. Hence
125 * the reference count to ensure only the last caller frees the ATTRI.
129 struct xfs_attri_log_item
*attrip
)
131 ASSERT(atomic_read(&attrip
->attri_refcount
) > 0);
132 if (!atomic_dec_and_test(&attrip
->attri_refcount
))
135 xfs_trans_ail_delete(&attrip
->attri_item
, 0);
136 xfs_attri_item_free(attrip
);
141 struct xfs_log_item
*lip
,
145 struct xfs_attri_log_item
*attrip
= ATTRI_ITEM(lip
);
146 struct xfs_attri_log_nameval
*nv
= attrip
->attri_nameval
;
149 *nbytes
+= sizeof(struct xfs_attri_log_format
) +
150 xlog_calc_iovec_len(nv
->name
.i_len
);
152 if (!nv
->value
.i_len
)
156 *nbytes
+= xlog_calc_iovec_len(nv
->value
.i_len
);
160 * This is called to fill in the log iovecs for the given attri log
161 * item. We use 1 iovec for the attri_format_item, 1 for the name, and
162 * another for the value if it is present
165 xfs_attri_item_format(
166 struct xfs_log_item
*lip
,
167 struct xfs_log_vec
*lv
)
169 struct xfs_attri_log_item
*attrip
= ATTRI_ITEM(lip
);
170 struct xfs_log_iovec
*vecp
= NULL
;
171 struct xfs_attri_log_nameval
*nv
= attrip
->attri_nameval
;
173 attrip
->attri_format
.alfi_type
= XFS_LI_ATTRI
;
174 attrip
->attri_format
.alfi_size
= 1;
177 * This size accounting must be done before copying the attrip into the
178 * iovec. If we do it after, the wrong size will be recorded to the log
179 * and we trip across assertion checks for bad region sizes later during
183 ASSERT(nv
->name
.i_len
> 0);
184 attrip
->attri_format
.alfi_size
++;
186 if (nv
->value
.i_len
> 0)
187 attrip
->attri_format
.alfi_size
++;
189 xlog_copy_iovec(lv
, &vecp
, XLOG_REG_TYPE_ATTRI_FORMAT
,
190 &attrip
->attri_format
,
191 sizeof(struct xfs_attri_log_format
));
192 xlog_copy_from_iovec(lv
, &vecp
, &nv
->name
);
193 if (nv
->value
.i_len
> 0)
194 xlog_copy_from_iovec(lv
, &vecp
, &nv
->value
);
198 * The unpin operation is the last place an ATTRI is manipulated in the log. It
199 * is either inserted in the AIL or aborted in the event of a log I/O error. In
200 * either case, the ATTRI transaction has been successfully committed to make
201 * it this far. Therefore, we expect whoever committed the ATTRI to either
202 * construct and commit the ATTRD or drop the ATTRD's reference in the event of
203 * error. Simply drop the log's ATTRI reference now that the log is done with
207 xfs_attri_item_unpin(
208 struct xfs_log_item
*lip
,
211 xfs_attri_release(ATTRI_ITEM(lip
));
216 xfs_attri_item_release(
217 struct xfs_log_item
*lip
)
219 xfs_attri_release(ATTRI_ITEM(lip
));
223 * Allocate and initialize an attri item. Caller may allocate an additional
224 * trailing buffer for name and value
226 STATIC
struct xfs_attri_log_item
*
228 struct xfs_mount
*mp
,
229 struct xfs_attri_log_nameval
*nv
)
231 struct xfs_attri_log_item
*attrip
;
233 attrip
= kmem_cache_zalloc(xfs_attri_cache
, GFP_NOFS
| __GFP_NOFAIL
);
236 * Grab an extra reference to the name/value buffer for this log item.
237 * The caller retains its own reference!
239 attrip
->attri_nameval
= xfs_attri_log_nameval_get(nv
);
240 ASSERT(attrip
->attri_nameval
);
242 xfs_log_item_init(mp
, &attrip
->attri_item
, XFS_LI_ATTRI
,
243 &xfs_attri_item_ops
);
244 attrip
->attri_format
.alfi_id
= (uintptr_t)(void *)attrip
;
245 atomic_set(&attrip
->attri_refcount
, 2);
251 * Copy an attr format buffer from the given buf, and into the destination attr
255 xfs_attri_copy_format(
256 struct xfs_log_iovec
*buf
,
257 struct xfs_attri_log_format
*dst_attr_fmt
)
259 struct xfs_attri_log_format
*src_attr_fmt
= buf
->i_addr
;
262 len
= sizeof(struct xfs_attri_log_format
);
263 if (buf
->i_len
!= len
) {
264 XFS_ERROR_REPORT(__func__
, XFS_ERRLEVEL_LOW
, NULL
);
265 return -EFSCORRUPTED
;
268 memcpy((char *)dst_attr_fmt
, (char *)src_attr_fmt
, len
);
272 static inline struct xfs_attrd_log_item
*ATTRD_ITEM(struct xfs_log_item
*lip
)
274 return container_of(lip
, struct xfs_attrd_log_item
, attrd_item
);
278 xfs_attrd_item_free(struct xfs_attrd_log_item
*attrdp
)
280 kmem_free(attrdp
->attrd_item
.li_lv_shadow
);
281 kmem_cache_free(xfs_attrd_cache
, attrdp
);
286 struct xfs_log_item
*lip
,
291 *nbytes
+= sizeof(struct xfs_attrd_log_format
);
295 * This is called to fill in the log iovecs for the given attrd log item. We use
296 * only 1 iovec for the attrd_format, and we point that at the attr_log_format
297 * structure embedded in the attrd item.
300 xfs_attrd_item_format(
301 struct xfs_log_item
*lip
,
302 struct xfs_log_vec
*lv
)
304 struct xfs_attrd_log_item
*attrdp
= ATTRD_ITEM(lip
);
305 struct xfs_log_iovec
*vecp
= NULL
;
307 attrdp
->attrd_format
.alfd_type
= XFS_LI_ATTRD
;
308 attrdp
->attrd_format
.alfd_size
= 1;
310 xlog_copy_iovec(lv
, &vecp
, XLOG_REG_TYPE_ATTRD_FORMAT
,
311 &attrdp
->attrd_format
,
312 sizeof(struct xfs_attrd_log_format
));
316 * The ATTRD is either committed or aborted if the transaction is canceled. If
317 * the transaction is canceled, drop our reference to the ATTRI and free the
321 xfs_attrd_item_release(
322 struct xfs_log_item
*lip
)
324 struct xfs_attrd_log_item
*attrdp
= ATTRD_ITEM(lip
);
326 xfs_attri_release(attrdp
->attrd_attrip
);
327 xfs_attrd_item_free(attrdp
);
330 static struct xfs_log_item
*
331 xfs_attrd_item_intent(
332 struct xfs_log_item
*lip
)
334 return &ATTRD_ITEM(lip
)->attrd_attrip
->attri_item
;
338 * Performs one step of an attribute update intent and marks the attrd item
339 * dirty.. An attr operation may be a set or a remove. Note that the
340 * transaction is marked dirty regardless of whether the operation succeeds or
341 * fails to support the ATTRI/ATTRD lifecycle rules.
344 xfs_xattri_finish_update(
345 struct xfs_attr_intent
*attr
,
346 struct xfs_attrd_log_item
*attrdp
)
348 struct xfs_da_args
*args
= attr
->xattri_da_args
;
351 if (XFS_TEST_ERROR(false, args
->dp
->i_mount
, XFS_ERRTAG_LARP
)) {
356 error
= xfs_attr_set_iter(attr
);
357 if (!error
&& attr
->xattri_dela_state
!= XFS_DAS_DONE
)
361 * Mark the transaction dirty, even on error. This ensures the
362 * transaction is aborted, which:
364 * 1.) releases the ATTRI and frees the ATTRD
365 * 2.) shuts down the filesystem
367 args
->trans
->t_flags
|= XFS_TRANS_DIRTY
| XFS_TRANS_HAS_INTENT_DONE
;
370 * attr intent/done items are null when logged attributes are disabled
373 set_bit(XFS_LI_DIRTY
, &attrdp
->attrd_item
.li_flags
);
378 /* Log an attr to the intent item. */
381 struct xfs_trans
*tp
,
382 struct xfs_attri_log_item
*attrip
,
383 const struct xfs_attr_intent
*attr
)
385 struct xfs_attri_log_format
*attrp
;
387 tp
->t_flags
|= XFS_TRANS_DIRTY
;
388 set_bit(XFS_LI_DIRTY
, &attrip
->attri_item
.li_flags
);
391 * At this point the xfs_attr_intent has been constructed, and we've
392 * created the log intent. Fill in the attri log item and log format
393 * structure with fields from this xfs_attr_intent
395 attrp
= &attrip
->attri_format
;
396 attrp
->alfi_ino
= attr
->xattri_da_args
->dp
->i_ino
;
397 ASSERT(!(attr
->xattri_op_flags
& ~XFS_ATTRI_OP_FLAGS_TYPE_MASK
));
398 attrp
->alfi_op_flags
= attr
->xattri_op_flags
;
399 attrp
->alfi_value_len
= attr
->xattri_nameval
->value
.i_len
;
400 attrp
->alfi_name_len
= attr
->xattri_nameval
->name
.i_len
;
401 ASSERT(!(attr
->xattri_da_args
->attr_filter
& ~XFS_ATTRI_FILTER_MASK
));
402 attrp
->alfi_attr_filter
= attr
->xattri_da_args
->attr_filter
;
406 static struct xfs_log_item
*
407 xfs_attr_create_intent(
408 struct xfs_trans
*tp
,
409 struct list_head
*items
,
413 struct xfs_mount
*mp
= tp
->t_mountp
;
414 struct xfs_attri_log_item
*attrip
;
415 struct xfs_attr_intent
*attr
;
416 struct xfs_da_args
*args
;
421 * Each attr item only performs one attribute operation at a time, so
422 * this is a list of one
424 attr
= list_first_entry_or_null(items
, struct xfs_attr_intent
,
426 args
= attr
->xattri_da_args
;
428 if (!(args
->op_flags
& XFS_DA_OP_LOGGED
))
432 * Create a buffer to store the attribute name and value. This buffer
433 * will be shared between the higher level deferred xattr work state
434 * and the lower level xattr log items.
436 if (!attr
->xattri_nameval
) {
438 * Transfer our reference to the name/value buffer to the
439 * deferred work state structure.
441 attr
->xattri_nameval
= xfs_attri_log_nameval_alloc(args
->name
,
442 args
->namelen
, args
->value
, args
->valuelen
);
444 if (!attr
->xattri_nameval
)
445 return ERR_PTR(-ENOMEM
);
447 attrip
= xfs_attri_init(mp
, attr
->xattri_nameval
);
448 xfs_trans_add_item(tp
, &attrip
->attri_item
);
449 xfs_attr_log_item(tp
, attrip
, attr
);
451 return &attrip
->attri_item
;
456 struct xfs_attr_intent
*attr
)
458 if (attr
->xattri_da_state
)
459 xfs_da_state_free(attr
->xattri_da_state
);
460 xfs_attri_log_nameval_put(attr
->xattri_nameval
);
461 if (attr
->xattri_da_args
->op_flags
& XFS_DA_OP_RECOVERY
)
464 kmem_cache_free(xfs_attr_intent_cache
, attr
);
467 /* Process an attr. */
469 xfs_attr_finish_item(
470 struct xfs_trans
*tp
,
471 struct xfs_log_item
*done
,
472 struct list_head
*item
,
473 struct xfs_btree_cur
**state
)
475 struct xfs_attr_intent
*attr
;
476 struct xfs_attrd_log_item
*done_item
= NULL
;
479 attr
= container_of(item
, struct xfs_attr_intent
, xattri_list
);
481 done_item
= ATTRD_ITEM(done
);
484 * Always reset trans after EAGAIN cycle
485 * since the transaction is new
487 attr
->xattri_da_args
->trans
= tp
;
489 error
= xfs_xattri_finish_update(attr
, done_item
);
490 if (error
!= -EAGAIN
)
491 xfs_attr_free_item(attr
);
496 /* Abort all pending ATTRs. */
498 xfs_attr_abort_intent(
499 struct xfs_log_item
*intent
)
501 xfs_attri_release(ATTRI_ITEM(intent
));
506 xfs_attr_cancel_item(
507 struct list_head
*item
)
509 struct xfs_attr_intent
*attr
;
511 attr
= container_of(item
, struct xfs_attr_intent
, xattri_list
);
512 xfs_attr_free_item(attr
);
516 xfs_attri_item_match(
517 struct xfs_log_item
*lip
,
520 return ATTRI_ITEM(lip
)->attri_format
.alfi_id
== intent_id
;
523 /* Is this recovered ATTRI format ok? */
526 struct xfs_mount
*mp
,
527 struct xfs_attri_log_format
*attrp
)
529 unsigned int op
= attrp
->alfi_op_flags
&
530 XFS_ATTRI_OP_FLAGS_TYPE_MASK
;
532 if (attrp
->__pad
!= 0)
535 if (attrp
->alfi_op_flags
& ~XFS_ATTRI_OP_FLAGS_TYPE_MASK
)
538 if (attrp
->alfi_attr_filter
& ~XFS_ATTRI_FILTER_MASK
)
541 /* alfi_op_flags should be either a set or remove */
543 case XFS_ATTRI_OP_FLAGS_SET
:
544 case XFS_ATTRI_OP_FLAGS_REPLACE
:
545 case XFS_ATTRI_OP_FLAGS_REMOVE
:
551 if (attrp
->alfi_value_len
> XATTR_SIZE_MAX
)
554 if ((attrp
->alfi_name_len
> XATTR_NAME_MAX
) ||
555 (attrp
->alfi_name_len
== 0))
558 return xfs_verify_ino(mp
, attrp
->alfi_ino
);
562 * Process an attr intent item that was recovered from the log. We need to
563 * delete the attr that it describes.
566 xfs_attri_item_recover(
567 struct xfs_log_item
*lip
,
568 struct list_head
*capture_list
)
570 struct xfs_attri_log_item
*attrip
= ATTRI_ITEM(lip
);
571 struct xfs_attr_intent
*attr
;
572 struct xfs_mount
*mp
= lip
->li_log
->l_mp
;
573 struct xfs_inode
*ip
;
574 struct xfs_da_args
*args
;
575 struct xfs_trans
*tp
;
576 struct xfs_trans_res tres
;
577 struct xfs_attri_log_format
*attrp
;
578 struct xfs_attri_log_nameval
*nv
= attrip
->attri_nameval
;
582 struct xfs_attrd_log_item
*done_item
= NULL
;
585 * First check the validity of the attr described by the ATTRI. If any
586 * are bad, then assume that all are bad and just toss the ATTRI.
588 attrp
= &attrip
->attri_format
;
589 if (!xfs_attri_validate(mp
, attrp
) ||
590 !xfs_attr_namecheck(nv
->name
.i_addr
, nv
->name
.i_len
))
591 return -EFSCORRUPTED
;
593 error
= xlog_recover_iget(mp
, attrp
->alfi_ino
, &ip
);
597 attr
= kmem_zalloc(sizeof(struct xfs_attr_intent
) +
598 sizeof(struct xfs_da_args
), KM_NOFS
);
599 args
= (struct xfs_da_args
*)(attr
+ 1);
601 attr
->xattri_da_args
= args
;
602 attr
->xattri_op_flags
= attrp
->alfi_op_flags
&
603 XFS_ATTRI_OP_FLAGS_TYPE_MASK
;
606 * We're reconstructing the deferred work state structure from the
607 * recovered log item. Grab a reference to the name/value buffer and
608 * attach it to the new work state.
610 attr
->xattri_nameval
= xfs_attri_log_nameval_get(nv
);
611 ASSERT(attr
->xattri_nameval
);
614 args
->geo
= mp
->m_attr_geo
;
615 args
->whichfork
= XFS_ATTR_FORK
;
616 args
->name
= nv
->name
.i_addr
;
617 args
->namelen
= nv
->name
.i_len
;
618 args
->hashval
= xfs_da_hashname(args
->name
, args
->namelen
);
619 args
->attr_filter
= attrp
->alfi_attr_filter
& XFS_ATTRI_FILTER_MASK
;
620 args
->op_flags
= XFS_DA_OP_RECOVERY
| XFS_DA_OP_OKNOENT
|
623 ASSERT(xfs_sb_version_haslogxattrs(&mp
->m_sb
));
625 switch (attr
->xattri_op_flags
) {
626 case XFS_ATTRI_OP_FLAGS_SET
:
627 case XFS_ATTRI_OP_FLAGS_REPLACE
:
628 args
->value
= nv
->value
.i_addr
;
629 args
->valuelen
= nv
->value
.i_len
;
630 args
->total
= xfs_attr_calc_size(args
, &local
);
631 if (xfs_inode_hasattr(args
->dp
))
632 attr
->xattri_dela_state
= xfs_attr_init_replace_state(args
);
634 attr
->xattri_dela_state
= xfs_attr_init_add_state(args
);
636 case XFS_ATTRI_OP_FLAGS_REMOVE
:
637 if (!xfs_inode_hasattr(args
->dp
))
639 attr
->xattri_dela_state
= xfs_attr_init_remove_state(args
);
643 error
= -EFSCORRUPTED
;
647 xfs_init_attr_trans(args
, &tres
, &total
);
648 error
= xfs_trans_alloc(mp
, &tres
, total
, 0, XFS_TRANS_RESERVE
, &tp
);
653 done_item
= xfs_trans_get_attrd(tp
, attrip
);
655 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
656 xfs_trans_ijoin(tp
, ip
, 0);
658 error
= xfs_xattri_finish_update(attr
, done_item
);
659 if (error
== -EAGAIN
) {
661 * There's more work to do, so add the intent item to this
662 * transaction so that we can continue it later.
664 xfs_defer_add(tp
, XFS_DEFER_OPS_TYPE_ATTR
, &attr
->xattri_list
);
665 error
= xfs_defer_ops_capture_and_commit(tp
, capture_list
);
669 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
674 xfs_trans_cancel(tp
);
678 error
= xfs_defer_ops_capture_and_commit(tp
, capture_list
);
680 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
683 xfs_attr_free_item(attr
);
687 /* Re-log an intent item to push the log tail forward. */
688 static struct xfs_log_item
*
689 xfs_attri_item_relog(
690 struct xfs_log_item
*intent
,
691 struct xfs_trans
*tp
)
693 struct xfs_attrd_log_item
*attrdp
;
694 struct xfs_attri_log_item
*old_attrip
;
695 struct xfs_attri_log_item
*new_attrip
;
696 struct xfs_attri_log_format
*new_attrp
;
697 struct xfs_attri_log_format
*old_attrp
;
699 old_attrip
= ATTRI_ITEM(intent
);
700 old_attrp
= &old_attrip
->attri_format
;
702 tp
->t_flags
|= XFS_TRANS_DIRTY
;
703 attrdp
= xfs_trans_get_attrd(tp
, old_attrip
);
704 set_bit(XFS_LI_DIRTY
, &attrdp
->attrd_item
.li_flags
);
707 * Create a new log item that shares the same name/value buffer as the
710 new_attrip
= xfs_attri_init(tp
->t_mountp
, old_attrip
->attri_nameval
);
711 new_attrp
= &new_attrip
->attri_format
;
713 new_attrp
->alfi_ino
= old_attrp
->alfi_ino
;
714 new_attrp
->alfi_op_flags
= old_attrp
->alfi_op_flags
;
715 new_attrp
->alfi_value_len
= old_attrp
->alfi_value_len
;
716 new_attrp
->alfi_name_len
= old_attrp
->alfi_name_len
;
717 new_attrp
->alfi_attr_filter
= old_attrp
->alfi_attr_filter
;
719 xfs_trans_add_item(tp
, &new_attrip
->attri_item
);
720 set_bit(XFS_LI_DIRTY
, &new_attrip
->attri_item
.li_flags
);
722 return &new_attrip
->attri_item
;
726 xlog_recover_attri_commit_pass2(
728 struct list_head
*buffer_list
,
729 struct xlog_recover_item
*item
,
732 struct xfs_mount
*mp
= log
->l_mp
;
733 struct xfs_attri_log_item
*attrip
;
734 struct xfs_attri_log_format
*attri_formatp
;
735 struct xfs_attri_log_nameval
*nv
;
736 const void *attr_value
= NULL
;
737 const void *attr_name
;
740 attri_formatp
= item
->ri_buf
[0].i_addr
;
741 attr_name
= item
->ri_buf
[1].i_addr
;
743 /* Validate xfs_attri_log_format before the large memory allocation */
744 if (!xfs_attri_validate(mp
, attri_formatp
)) {
745 XFS_ERROR_REPORT(__func__
, XFS_ERRLEVEL_LOW
, mp
);
746 return -EFSCORRUPTED
;
749 if (!xfs_attr_namecheck(attr_name
, attri_formatp
->alfi_name_len
)) {
750 XFS_ERROR_REPORT(__func__
, XFS_ERRLEVEL_LOW
, mp
);
751 return -EFSCORRUPTED
;
754 if (attri_formatp
->alfi_value_len
)
755 attr_value
= item
->ri_buf
[2].i_addr
;
758 * Memory alloc failure will cause replay to abort. We attach the
759 * name/value buffer to the recovered incore log item and drop our
762 nv
= xfs_attri_log_nameval_alloc(attr_name
,
763 attri_formatp
->alfi_name_len
, attr_value
,
764 attri_formatp
->alfi_value_len
);
768 attrip
= xfs_attri_init(mp
, nv
);
769 error
= xfs_attri_copy_format(&item
->ri_buf
[0], &attrip
->attri_format
);
774 * The ATTRI has two references. One for the ATTRD and one for ATTRI to
775 * ensure it makes it into the AIL. Insert the ATTRI into the AIL
776 * directly and drop the ATTRI reference. Note that
777 * xfs_trans_ail_update() drops the AIL lock.
779 xfs_trans_ail_insert(log
->l_ailp
, &attrip
->attri_item
, lsn
);
780 xfs_attri_release(attrip
);
781 xfs_attri_log_nameval_put(nv
);
784 xfs_attri_item_free(attrip
);
785 xfs_attri_log_nameval_put(nv
);
790 * This routine is called to allocate an "attr free done" log item.
792 static struct xfs_attrd_log_item
*
793 xfs_trans_get_attrd(struct xfs_trans
*tp
,
794 struct xfs_attri_log_item
*attrip
)
796 struct xfs_attrd_log_item
*attrdp
;
800 attrdp
= kmem_cache_zalloc(xfs_attrd_cache
, GFP_NOFS
| __GFP_NOFAIL
);
802 xfs_log_item_init(tp
->t_mountp
, &attrdp
->attrd_item
, XFS_LI_ATTRD
,
803 &xfs_attrd_item_ops
);
804 attrdp
->attrd_attrip
= attrip
;
805 attrdp
->attrd_format
.alfd_alf_id
= attrip
->attri_format
.alfi_id
;
807 xfs_trans_add_item(tp
, &attrdp
->attrd_item
);
811 /* Get an ATTRD so we can process all the attrs. */
812 static struct xfs_log_item
*
813 xfs_attr_create_done(
814 struct xfs_trans
*tp
,
815 struct xfs_log_item
*intent
,
821 return &xfs_trans_get_attrd(tp
, ATTRI_ITEM(intent
))->attrd_item
;
824 const struct xfs_defer_op_type xfs_attr_defer_type
= {
826 .create_intent
= xfs_attr_create_intent
,
827 .abort_intent
= xfs_attr_abort_intent
,
828 .create_done
= xfs_attr_create_done
,
829 .finish_item
= xfs_attr_finish_item
,
830 .cancel_item
= xfs_attr_cancel_item
,
834 * This routine is called when an ATTRD format structure is found in a committed
835 * transaction in the log. Its purpose is to cancel the corresponding ATTRI if
836 * it was still in the log. To do this it searches the AIL for the ATTRI with
837 * an id equal to that in the ATTRD format structure. If we find it we drop
838 * the ATTRD reference, which removes the ATTRI from the AIL and frees it.
841 xlog_recover_attrd_commit_pass2(
843 struct list_head
*buffer_list
,
844 struct xlog_recover_item
*item
,
847 struct xfs_attrd_log_format
*attrd_formatp
;
849 attrd_formatp
= item
->ri_buf
[0].i_addr
;
850 if (item
->ri_buf
[0].i_len
!= sizeof(struct xfs_attrd_log_format
)) {
851 XFS_ERROR_REPORT(__func__
, XFS_ERRLEVEL_LOW
, NULL
);
852 return -EFSCORRUPTED
;
855 xlog_recover_release_intent(log
, XFS_LI_ATTRI
,
856 attrd_formatp
->alfd_alf_id
);
860 static const struct xfs_item_ops xfs_attri_item_ops
= {
861 .flags
= XFS_ITEM_INTENT
,
862 .iop_size
= xfs_attri_item_size
,
863 .iop_format
= xfs_attri_item_format
,
864 .iop_unpin
= xfs_attri_item_unpin
,
865 .iop_release
= xfs_attri_item_release
,
866 .iop_recover
= xfs_attri_item_recover
,
867 .iop_match
= xfs_attri_item_match
,
868 .iop_relog
= xfs_attri_item_relog
,
871 const struct xlog_recover_item_ops xlog_attri_item_ops
= {
872 .item_type
= XFS_LI_ATTRI
,
873 .commit_pass2
= xlog_recover_attri_commit_pass2
,
876 static const struct xfs_item_ops xfs_attrd_item_ops
= {
877 .flags
= XFS_ITEM_RELEASE_WHEN_COMMITTED
|
878 XFS_ITEM_INTENT_DONE
,
879 .iop_size
= xfs_attrd_item_size
,
880 .iop_format
= xfs_attrd_item_format
,
881 .iop_release
= xfs_attrd_item_release
,
882 .iop_intent
= xfs_attrd_item_intent
,
885 const struct xlog_recover_item_ops xlog_attrd_item_ops
= {
886 .item_type
= XFS_LI_ATTRD
,
887 .commit_pass2
= xlog_recover_attrd_commit_pass2
,