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);
90 nv->name.i_addr = nv + 1;
91 nv->name.i_len = name_len;
92 nv->name.i_type = XLOG_REG_TYPE_ATTR_NAME;
93 memcpy(nv->name.i_addr, name, name_len);
96 nv->value.i_addr = nv->name.i_addr + name_len;
97 nv->value.i_len = value_len;
98 memcpy(nv->value.i_addr, value, value_len);
100 nv->value.i_addr = NULL;
103 nv->value.i_type = XLOG_REG_TYPE_ATTR_VALUE;
105 refcount_set(&nv->refcount, 1);
111 struct xfs_attri_log_item *attrip)
113 kmem_free(attrip->attri_item.li_lv_shadow);
114 xfs_attri_log_nameval_put(attrip->attri_nameval);
115 kmem_cache_free(xfs_attri_cache, attrip);
119 * Freeing the attrip requires that we remove it from the AIL if it has already
120 * been placed there. However, the ATTRI may not yet have been placed in the
121 * AIL when called by xfs_attri_release() from ATTRD processing due to the
122 * ordering of committed vs unpin operations in bulk insert operations. Hence
123 * the reference count to ensure only the last caller frees the ATTRI.
127 struct xfs_attri_log_item *attrip)
129 ASSERT(atomic_read(&attrip->attri_refcount) > 0);
130 if (!atomic_dec_and_test(&attrip->attri_refcount))
133 xfs_trans_ail_delete(&attrip->attri_item, 0);
134 xfs_attri_item_free(attrip);
139 struct xfs_log_item *lip,
143 struct xfs_attri_log_item *attrip = ATTRI_ITEM(lip);
144 struct xfs_attri_log_nameval *nv = attrip->attri_nameval;
147 *nbytes += sizeof(struct xfs_attri_log_format) +
148 xlog_calc_iovec_len(nv->name.i_len);
150 if (!nv->value.i_len)
154 *nbytes += xlog_calc_iovec_len(nv->value.i_len);
158 * This is called to fill in the log iovecs for the given attri log
159 * item. We use 1 iovec for the attri_format_item, 1 for the name, and
160 * another for the value if it is present
163 xfs_attri_item_format(
164 struct xfs_log_item *lip,
165 struct xfs_log_vec *lv)
167 struct xfs_attri_log_item *attrip = ATTRI_ITEM(lip);
168 struct xfs_log_iovec *vecp = NULL;
169 struct xfs_attri_log_nameval *nv = attrip->attri_nameval;
171 attrip->attri_format.alfi_type = XFS_LI_ATTRI;
172 attrip->attri_format.alfi_size = 1;
175 * This size accounting must be done before copying the attrip into the
176 * iovec. If we do it after, the wrong size will be recorded to the log
177 * and we trip across assertion checks for bad region sizes later during
181 ASSERT(nv->name.i_len > 0);
182 attrip->attri_format.alfi_size++;
184 if (nv->value.i_len > 0)
185 attrip->attri_format.alfi_size++;
187 xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_ATTRI_FORMAT,
188 &attrip->attri_format,
189 sizeof(struct xfs_attri_log_format));
190 xlog_copy_from_iovec(lv, &vecp, &nv->name);
191 if (nv->value.i_len > 0)
192 xlog_copy_from_iovec(lv, &vecp, &nv->value);
196 * The unpin operation is the last place an ATTRI is manipulated in the log. It
197 * is either inserted in the AIL or aborted in the event of a log I/O error. In
198 * either case, the ATTRI transaction has been successfully committed to make
199 * it this far. Therefore, we expect whoever committed the ATTRI to either
200 * construct and commit the ATTRD or drop the ATTRD's reference in the event of
201 * error. Simply drop the log's ATTRI reference now that the log is done with
205 xfs_attri_item_unpin(
206 struct xfs_log_item *lip,
209 xfs_attri_release(ATTRI_ITEM(lip));
214 xfs_attri_item_release(
215 struct xfs_log_item *lip)
217 xfs_attri_release(ATTRI_ITEM(lip));
221 * Allocate and initialize an attri item. Caller may allocate an additional
222 * trailing buffer for name and value
224 STATIC struct xfs_attri_log_item *
226 struct xfs_mount *mp,
227 struct xfs_attri_log_nameval *nv)
229 struct xfs_attri_log_item *attrip;
231 attrip = kmem_cache_zalloc(xfs_attri_cache, GFP_NOFS | __GFP_NOFAIL);
234 * Grab an extra reference to the name/value buffer for this log item.
235 * The caller retains its own reference!
237 attrip->attri_nameval = xfs_attri_log_nameval_get(nv);
238 ASSERT(attrip->attri_nameval);
240 xfs_log_item_init(mp, &attrip->attri_item, XFS_LI_ATTRI,
241 &xfs_attri_item_ops);
242 attrip->attri_format.alfi_id = (uintptr_t)(void *)attrip;
243 atomic_set(&attrip->attri_refcount, 2);
249 * Copy an attr format buffer from the given buf, and into the destination attr
253 xfs_attri_copy_format(
254 struct xfs_log_iovec *buf,
255 struct xfs_attri_log_format *dst_attr_fmt)
257 struct xfs_attri_log_format *src_attr_fmt = buf->i_addr;
260 len = sizeof(struct xfs_attri_log_format);
261 if (buf->i_len != len) {
262 XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, NULL);
263 return -EFSCORRUPTED;
266 memcpy((char *)dst_attr_fmt, (char *)src_attr_fmt, len);
270 static inline struct xfs_attrd_log_item *ATTRD_ITEM(struct xfs_log_item *lip)
272 return container_of(lip, struct xfs_attrd_log_item, attrd_item);
276 xfs_attrd_item_free(struct xfs_attrd_log_item *attrdp)
278 kmem_free(attrdp->attrd_item.li_lv_shadow);
279 kmem_cache_free(xfs_attrd_cache, attrdp);
284 struct xfs_log_item *lip,
289 *nbytes += sizeof(struct xfs_attrd_log_format);
293 * This is called to fill in the log iovecs for the given attrd log item. We use
294 * only 1 iovec for the attrd_format, and we point that at the attr_log_format
295 * structure embedded in the attrd item.
298 xfs_attrd_item_format(
299 struct xfs_log_item *lip,
300 struct xfs_log_vec *lv)
302 struct xfs_attrd_log_item *attrdp = ATTRD_ITEM(lip);
303 struct xfs_log_iovec *vecp = NULL;
305 attrdp->attrd_format.alfd_type = XFS_LI_ATTRD;
306 attrdp->attrd_format.alfd_size = 1;
308 xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_ATTRD_FORMAT,
309 &attrdp->attrd_format,
310 sizeof(struct xfs_attrd_log_format));
314 * The ATTRD is either committed or aborted if the transaction is canceled. If
315 * the transaction is canceled, drop our reference to the ATTRI and free the
319 xfs_attrd_item_release(
320 struct xfs_log_item *lip)
322 struct xfs_attrd_log_item *attrdp = ATTRD_ITEM(lip);
324 xfs_attri_release(attrdp->attrd_attrip);
325 xfs_attrd_item_free(attrdp);
328 static struct xfs_log_item *
329 xfs_attrd_item_intent(
330 struct xfs_log_item *lip)
332 return &ATTRD_ITEM(lip)->attrd_attrip->attri_item;
336 * Performs one step of an attribute update intent and marks the attrd item
337 * dirty.. An attr operation may be a set or a remove. Note that the
338 * transaction is marked dirty regardless of whether the operation succeeds or
339 * fails to support the ATTRI/ATTRD lifecycle rules.
342 xfs_xattri_finish_update(
343 struct xfs_attr_intent *attr,
344 struct xfs_attrd_log_item *attrdp)
346 struct xfs_da_args *args = attr->xattri_da_args;
349 if (XFS_TEST_ERROR(false, args->dp->i_mount, XFS_ERRTAG_LARP)) {
354 error = xfs_attr_set_iter(attr);
355 if (!error && attr->xattri_dela_state != XFS_DAS_DONE)
359 * Mark the transaction dirty, even on error. This ensures the
360 * transaction is aborted, which:
362 * 1.) releases the ATTRI and frees the ATTRD
363 * 2.) shuts down the filesystem
365 args->trans->t_flags |= XFS_TRANS_DIRTY | XFS_TRANS_HAS_INTENT_DONE;
368 * attr intent/done items are null when logged attributes are disabled
371 set_bit(XFS_LI_DIRTY, &attrdp->attrd_item.li_flags);
376 /* Log an attr to the intent item. */
379 struct xfs_trans *tp,
380 struct xfs_attri_log_item *attrip,
381 const struct xfs_attr_intent *attr)
383 struct xfs_attri_log_format *attrp;
385 tp->t_flags |= XFS_TRANS_DIRTY;
386 set_bit(XFS_LI_DIRTY, &attrip->attri_item.li_flags);
389 * At this point the xfs_attr_intent has been constructed, and we've
390 * created the log intent. Fill in the attri log item and log format
391 * structure with fields from this xfs_attr_intent
393 attrp = &attrip->attri_format;
394 attrp->alfi_ino = attr->xattri_da_args->dp->i_ino;
395 ASSERT(!(attr->xattri_op_flags & ~XFS_ATTRI_OP_FLAGS_TYPE_MASK));
396 attrp->alfi_op_flags = attr->xattri_op_flags;
397 attrp->alfi_value_len = attr->xattri_nameval->value.i_len;
398 attrp->alfi_name_len = attr->xattri_nameval->name.i_len;
399 ASSERT(!(attr->xattri_da_args->attr_filter & ~XFS_ATTRI_FILTER_MASK));
400 attrp->alfi_attr_filter = attr->xattri_da_args->attr_filter;
404 static struct xfs_log_item *
405 xfs_attr_create_intent(
406 struct xfs_trans *tp,
407 struct list_head *items,
411 struct xfs_mount *mp = tp->t_mountp;
412 struct xfs_attri_log_item *attrip;
413 struct xfs_attr_intent *attr;
414 struct xfs_da_args *args;
419 * Each attr item only performs one attribute operation at a time, so
420 * this is a list of one
422 attr = list_first_entry_or_null(items, struct xfs_attr_intent,
424 args = attr->xattri_da_args;
426 if (!(args->op_flags & XFS_DA_OP_LOGGED))
430 * Create a buffer to store the attribute name and value. This buffer
431 * will be shared between the higher level deferred xattr work state
432 * and the lower level xattr log items.
434 if (!attr->xattri_nameval) {
436 * Transfer our reference to the name/value buffer to the
437 * deferred work state structure.
439 attr->xattri_nameval = xfs_attri_log_nameval_alloc(args->name,
440 args->namelen, args->value, args->valuelen);
443 attrip = xfs_attri_init(mp, attr->xattri_nameval);
444 xfs_trans_add_item(tp, &attrip->attri_item);
445 xfs_attr_log_item(tp, attrip, attr);
447 return &attrip->attri_item;
452 struct xfs_attr_intent *attr)
454 if (attr->xattri_da_state)
455 xfs_da_state_free(attr->xattri_da_state);
456 xfs_attri_log_nameval_put(attr->xattri_nameval);
457 if (attr->xattri_da_args->op_flags & XFS_DA_OP_RECOVERY)
460 kmem_cache_free(xfs_attr_intent_cache, attr);
463 /* Process an attr. */
465 xfs_attr_finish_item(
466 struct xfs_trans *tp,
467 struct xfs_log_item *done,
468 struct list_head *item,
469 struct xfs_btree_cur **state)
471 struct xfs_attr_intent *attr;
472 struct xfs_attrd_log_item *done_item = NULL;
475 attr = container_of(item, struct xfs_attr_intent, xattri_list);
477 done_item = ATTRD_ITEM(done);
480 * Always reset trans after EAGAIN cycle
481 * since the transaction is new
483 attr->xattri_da_args->trans = tp;
485 error = xfs_xattri_finish_update(attr, done_item);
486 if (error != -EAGAIN)
487 xfs_attr_free_item(attr);
492 /* Abort all pending ATTRs. */
494 xfs_attr_abort_intent(
495 struct xfs_log_item *intent)
497 xfs_attri_release(ATTRI_ITEM(intent));
502 xfs_attr_cancel_item(
503 struct list_head *item)
505 struct xfs_attr_intent *attr;
507 attr = container_of(item, struct xfs_attr_intent, xattri_list);
508 xfs_attr_free_item(attr);
512 xfs_attri_item_match(
513 struct xfs_log_item *lip,
516 return ATTRI_ITEM(lip)->attri_format.alfi_id == intent_id;
519 /* Is this recovered ATTRI format ok? */
522 struct xfs_mount *mp,
523 struct xfs_attri_log_format *attrp)
525 unsigned int op = attrp->alfi_op_flags &
526 XFS_ATTRI_OP_FLAGS_TYPE_MASK;
528 if (attrp->__pad != 0)
531 if (attrp->alfi_op_flags & ~XFS_ATTRI_OP_FLAGS_TYPE_MASK)
534 if (attrp->alfi_attr_filter & ~XFS_ATTRI_FILTER_MASK)
537 /* alfi_op_flags should be either a set or remove */
539 case XFS_ATTRI_OP_FLAGS_SET:
540 case XFS_ATTRI_OP_FLAGS_REPLACE:
541 case XFS_ATTRI_OP_FLAGS_REMOVE:
547 if (attrp->alfi_value_len > XATTR_SIZE_MAX)
550 if ((attrp->alfi_name_len > XATTR_NAME_MAX) ||
551 (attrp->alfi_name_len == 0))
554 return xfs_verify_ino(mp, attrp->alfi_ino);
558 * Process an attr intent item that was recovered from the log. We need to
559 * delete the attr that it describes.
562 xfs_attri_item_recover(
563 struct xfs_log_item *lip,
564 struct list_head *capture_list)
566 struct xfs_attri_log_item *attrip = ATTRI_ITEM(lip);
567 struct xfs_attr_intent *attr;
568 struct xfs_mount *mp = lip->li_log->l_mp;
569 struct xfs_inode *ip;
570 struct xfs_da_args *args;
571 struct xfs_trans *tp;
572 struct xfs_trans_res tres;
573 struct xfs_attri_log_format *attrp;
574 struct xfs_attri_log_nameval *nv = attrip->attri_nameval;
578 struct xfs_attrd_log_item *done_item = NULL;
581 * First check the validity of the attr described by the ATTRI. If any
582 * are bad, then assume that all are bad and just toss the ATTRI.
584 attrp = &attrip->attri_format;
585 if (!xfs_attri_validate(mp, attrp) ||
586 !xfs_attr_namecheck(nv->name.i_addr, nv->name.i_len))
587 return -EFSCORRUPTED;
589 error = xlog_recover_iget(mp, attrp->alfi_ino, &ip);
593 attr = kmem_zalloc(sizeof(struct xfs_attr_intent) +
594 sizeof(struct xfs_da_args), KM_NOFS);
595 args = (struct xfs_da_args *)(attr + 1);
597 attr->xattri_da_args = args;
598 attr->xattri_op_flags = attrp->alfi_op_flags &
599 XFS_ATTRI_OP_FLAGS_TYPE_MASK;
602 * We're reconstructing the deferred work state structure from the
603 * recovered log item. Grab a reference to the name/value buffer and
604 * attach it to the new work state.
606 attr->xattri_nameval = xfs_attri_log_nameval_get(nv);
607 ASSERT(attr->xattri_nameval);
610 args->geo = mp->m_attr_geo;
611 args->whichfork = XFS_ATTR_FORK;
612 args->name = nv->name.i_addr;
613 args->namelen = nv->name.i_len;
614 args->hashval = xfs_da_hashname(args->name, args->namelen);
615 args->attr_filter = attrp->alfi_attr_filter & XFS_ATTRI_FILTER_MASK;
616 args->op_flags = XFS_DA_OP_RECOVERY | XFS_DA_OP_OKNOENT |
619 ASSERT(xfs_sb_version_haslogxattrs(&mp->m_sb));
621 switch (attr->xattri_op_flags) {
622 case XFS_ATTRI_OP_FLAGS_SET:
623 case XFS_ATTRI_OP_FLAGS_REPLACE:
624 args->value = nv->value.i_addr;
625 args->valuelen = nv->value.i_len;
626 args->total = xfs_attr_calc_size(args, &local);
627 if (xfs_inode_hasattr(args->dp))
628 attr->xattri_dela_state = xfs_attr_init_replace_state(args);
630 attr->xattri_dela_state = xfs_attr_init_add_state(args);
632 case XFS_ATTRI_OP_FLAGS_REMOVE:
633 if (!xfs_inode_hasattr(args->dp))
635 attr->xattri_dela_state = xfs_attr_init_remove_state(args);
639 error = -EFSCORRUPTED;
643 xfs_init_attr_trans(args, &tres, &total);
644 error = xfs_trans_alloc(mp, &tres, total, 0, XFS_TRANS_RESERVE, &tp);
649 done_item = xfs_trans_get_attrd(tp, attrip);
651 xfs_ilock(ip, XFS_ILOCK_EXCL);
652 xfs_trans_ijoin(tp, ip, 0);
654 error = xfs_xattri_finish_update(attr, done_item);
655 if (error == -EAGAIN) {
657 * There's more work to do, so add the intent item to this
658 * transaction so that we can continue it later.
660 xfs_defer_add(tp, XFS_DEFER_OPS_TYPE_ATTR, &attr->xattri_list);
661 error = xfs_defer_ops_capture_and_commit(tp, capture_list);
665 xfs_iunlock(ip, XFS_ILOCK_EXCL);
670 xfs_trans_cancel(tp);
674 error = xfs_defer_ops_capture_and_commit(tp, capture_list);
676 xfs_iunlock(ip, XFS_ILOCK_EXCL);
679 xfs_attr_free_item(attr);
683 /* Re-log an intent item to push the log tail forward. */
684 static struct xfs_log_item *
685 xfs_attri_item_relog(
686 struct xfs_log_item *intent,
687 struct xfs_trans *tp)
689 struct xfs_attrd_log_item *attrdp;
690 struct xfs_attri_log_item *old_attrip;
691 struct xfs_attri_log_item *new_attrip;
692 struct xfs_attri_log_format *new_attrp;
693 struct xfs_attri_log_format *old_attrp;
695 old_attrip = ATTRI_ITEM(intent);
696 old_attrp = &old_attrip->attri_format;
698 tp->t_flags |= XFS_TRANS_DIRTY;
699 attrdp = xfs_trans_get_attrd(tp, old_attrip);
700 set_bit(XFS_LI_DIRTY, &attrdp->attrd_item.li_flags);
703 * Create a new log item that shares the same name/value buffer as the
706 new_attrip = xfs_attri_init(tp->t_mountp, old_attrip->attri_nameval);
707 new_attrp = &new_attrip->attri_format;
709 new_attrp->alfi_ino = old_attrp->alfi_ino;
710 new_attrp->alfi_op_flags = old_attrp->alfi_op_flags;
711 new_attrp->alfi_value_len = old_attrp->alfi_value_len;
712 new_attrp->alfi_name_len = old_attrp->alfi_name_len;
713 new_attrp->alfi_attr_filter = old_attrp->alfi_attr_filter;
715 xfs_trans_add_item(tp, &new_attrip->attri_item);
716 set_bit(XFS_LI_DIRTY, &new_attrip->attri_item.li_flags);
718 return &new_attrip->attri_item;
722 xlog_recover_attri_commit_pass2(
724 struct list_head *buffer_list,
725 struct xlog_recover_item *item,
728 struct xfs_mount *mp = log->l_mp;
729 struct xfs_attri_log_item *attrip;
730 struct xfs_attri_log_format *attri_formatp;
731 struct xfs_attri_log_nameval *nv;
732 const void *attr_value = NULL;
733 const void *attr_name;
736 attri_formatp = item->ri_buf[0].i_addr;
737 attr_name = item->ri_buf[1].i_addr;
739 /* Validate xfs_attri_log_format before the large memory allocation */
740 if (!xfs_attri_validate(mp, attri_formatp)) {
741 XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
742 return -EFSCORRUPTED;
745 if (!xfs_attr_namecheck(attr_name, attri_formatp->alfi_name_len)) {
746 XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
747 return -EFSCORRUPTED;
750 if (attri_formatp->alfi_value_len)
751 attr_value = item->ri_buf[2].i_addr;
754 * Memory alloc failure will cause replay to abort. We attach the
755 * name/value buffer to the recovered incore log item and drop our
758 nv = xfs_attri_log_nameval_alloc(attr_name,
759 attri_formatp->alfi_name_len, attr_value,
760 attri_formatp->alfi_value_len);
762 attrip = xfs_attri_init(mp, nv);
763 error = xfs_attri_copy_format(&item->ri_buf[0], &attrip->attri_format);
768 * The ATTRI has two references. One for the ATTRD and one for ATTRI to
769 * ensure it makes it into the AIL. Insert the ATTRI into the AIL
770 * directly and drop the ATTRI reference. Note that
771 * xfs_trans_ail_update() drops the AIL lock.
773 xfs_trans_ail_insert(log->l_ailp, &attrip->attri_item, lsn);
774 xfs_attri_release(attrip);
775 xfs_attri_log_nameval_put(nv);
778 xfs_attri_item_free(attrip);
779 xfs_attri_log_nameval_put(nv);
784 * This routine is called to allocate an "attr free done" log item.
786 static struct xfs_attrd_log_item *
787 xfs_trans_get_attrd(struct xfs_trans *tp,
788 struct xfs_attri_log_item *attrip)
790 struct xfs_attrd_log_item *attrdp;
794 attrdp = kmem_cache_zalloc(xfs_attrd_cache, GFP_NOFS | __GFP_NOFAIL);
796 xfs_log_item_init(tp->t_mountp, &attrdp->attrd_item, XFS_LI_ATTRD,
797 &xfs_attrd_item_ops);
798 attrdp->attrd_attrip = attrip;
799 attrdp->attrd_format.alfd_alf_id = attrip->attri_format.alfi_id;
801 xfs_trans_add_item(tp, &attrdp->attrd_item);
805 /* Get an ATTRD so we can process all the attrs. */
806 static struct xfs_log_item *
807 xfs_attr_create_done(
808 struct xfs_trans *tp,
809 struct xfs_log_item *intent,
815 return &xfs_trans_get_attrd(tp, ATTRI_ITEM(intent))->attrd_item;
818 const struct xfs_defer_op_type xfs_attr_defer_type = {
820 .create_intent = xfs_attr_create_intent,
821 .abort_intent = xfs_attr_abort_intent,
822 .create_done = xfs_attr_create_done,
823 .finish_item = xfs_attr_finish_item,
824 .cancel_item = xfs_attr_cancel_item,
828 * This routine is called when an ATTRD format structure is found in a committed
829 * transaction in the log. Its purpose is to cancel the corresponding ATTRI if
830 * it was still in the log. To do this it searches the AIL for the ATTRI with
831 * an id equal to that in the ATTRD format structure. If we find it we drop
832 * the ATTRD reference, which removes the ATTRI from the AIL and frees it.
835 xlog_recover_attrd_commit_pass2(
837 struct list_head *buffer_list,
838 struct xlog_recover_item *item,
841 struct xfs_attrd_log_format *attrd_formatp;
843 attrd_formatp = item->ri_buf[0].i_addr;
844 if (item->ri_buf[0].i_len != sizeof(struct xfs_attrd_log_format)) {
845 XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, NULL);
846 return -EFSCORRUPTED;
849 xlog_recover_release_intent(log, XFS_LI_ATTRI,
850 attrd_formatp->alfd_alf_id);
854 static const struct xfs_item_ops xfs_attri_item_ops = {
855 .flags = XFS_ITEM_INTENT,
856 .iop_size = xfs_attri_item_size,
857 .iop_format = xfs_attri_item_format,
858 .iop_unpin = xfs_attri_item_unpin,
859 .iop_release = xfs_attri_item_release,
860 .iop_recover = xfs_attri_item_recover,
861 .iop_match = xfs_attri_item_match,
862 .iop_relog = xfs_attri_item_relog,
865 const struct xlog_recover_item_ops xlog_attri_item_ops = {
866 .item_type = XFS_LI_ATTRI,
867 .commit_pass2 = xlog_recover_attri_commit_pass2,
870 static const struct xfs_item_ops xfs_attrd_item_ops = {
871 .flags = XFS_ITEM_RELEASE_WHEN_COMMITTED |
872 XFS_ITEM_INTENT_DONE,
873 .iop_size = xfs_attrd_item_size,
874 .iop_format = xfs_attrd_item_format,
875 .iop_release = xfs_attrd_item_release,
876 .iop_intent = xfs_attrd_item_intent,
879 const struct xlog_recover_item_ops xlog_attrd_item_ops = {
880 .item_type = XFS_LI_ATTRD,
881 .commit_pass2 = xlog_recover_attrd_commit_pass2,