1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (c) 2020-2022, Red Hat, 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_inode.h"
14#include "xfs_trans.h"
15#include "xfs_trans_priv.h"
16#include "xfs_ag.h"
17#include "xfs_iunlink_item.h"
18#include "xfs_trace.h"
19#include "xfs_error.h"
20
21struct kmem_cache *xfs_iunlink_cache;
22
23static inline struct xfs_iunlink_item *IUL_ITEM(struct xfs_log_item *lip)
24{
25 return container_of(lip, struct xfs_iunlink_item, item);
26}
27
28static void
29xfs_iunlink_item_release(
30 struct xfs_log_item *lip)
31{
32 struct xfs_iunlink_item *iup = IUL_ITEM(lip);
33
34 xfs_perag_put(iup->pag);
35 kmem_cache_free(s: xfs_iunlink_cache, objp: IUL_ITEM(lip));
36}
37
38
39static uint64_t
40xfs_iunlink_item_sort(
41 struct xfs_log_item *lip)
42{
43 return IUL_ITEM(lip)->ip->i_ino;
44}
45
46/*
47 * Look up the inode cluster buffer and log the on-disk unlinked inode change
48 * we need to make.
49 */
50static int
51xfs_iunlink_log_dinode(
52 struct xfs_trans *tp,
53 struct xfs_iunlink_item *iup)
54{
55 struct xfs_inode *ip = iup->ip;
56 struct xfs_dinode *dip;
57 struct xfs_buf *ibp;
58 xfs_agino_t old_ptr;
59 int offset;
60 int error;
61
62 error = xfs_imap_to_bp(tp->t_mountp, tp, &ip->i_imap, &ibp);
63 if (error)
64 return error;
65 /*
66 * Don't log the unlinked field on stale buffers as this may be the
67 * transaction that frees the inode cluster and relogging the buffer
68 * here will incorrectly remove the stale state.
69 */
70 if (ibp->b_flags & XBF_STALE)
71 goto out;
72
73 dip = xfs_buf_offset(bp: ibp, offset: ip->i_imap.im_boffset);
74
75 /* Make sure the old pointer isn't garbage. */
76 old_ptr = be32_to_cpu(dip->di_next_unlinked);
77 if (old_ptr != iup->old_agino) {
78 xfs_inode_verifier_error(ip, -EFSCORRUPTED, __func__, dip,
79 sizeof(*dip), __this_address);
80 error = -EFSCORRUPTED;
81 goto out;
82 }
83
84 trace_xfs_iunlink_update_dinode(iup, old_ptr);
85
86 dip->di_next_unlinked = cpu_to_be32(iup->next_agino);
87 offset = ip->i_imap.im_boffset +
88 offsetof(struct xfs_dinode, di_next_unlinked);
89
90 xfs_dinode_calc_crc(tp->t_mountp, dip);
91 xfs_trans_inode_buf(tp, ibp);
92 xfs_trans_log_buf(tp, ibp, offset, offset + sizeof(xfs_agino_t) - 1);
93 return 0;
94out:
95 xfs_trans_brelse(tp, ibp);
96 return error;
97}
98
99/*
100 * On precommit, we grab the inode cluster buffer for the inode number we were
101 * passed, then update the next unlinked field for that inode in the buffer and
102 * log the buffer. This ensures that the inode cluster buffer was logged in the
103 * correct order w.r.t. other inode cluster buffers. We can then remove the
104 * iunlink item from the transaction and release it as it is has now served it's
105 * purpose.
106 */
107static int
108xfs_iunlink_item_precommit(
109 struct xfs_trans *tp,
110 struct xfs_log_item *lip)
111{
112 struct xfs_iunlink_item *iup = IUL_ITEM(lip);
113 int error;
114
115 error = xfs_iunlink_log_dinode(tp, iup);
116 list_del(entry: &lip->li_trans);
117 xfs_iunlink_item_release(lip);
118 return error;
119}
120
121static const struct xfs_item_ops xfs_iunlink_item_ops = {
122 .iop_release = xfs_iunlink_item_release,
123 .iop_sort = xfs_iunlink_item_sort,
124 .iop_precommit = xfs_iunlink_item_precommit,
125};
126
127
128/*
129 * Initialize the inode log item for a newly allocated (in-core) inode.
130 *
131 * Inode extents can only reside within an AG. Hence specify the starting
132 * block for the inode chunk by offset within an AG as well as the
133 * length of the allocated extent.
134 *
135 * This joins the item to the transaction and marks it dirty so
136 * that we don't need a separate call to do this, nor does the
137 * caller need to know anything about the iunlink item.
138 */
139int
140xfs_iunlink_log_inode(
141 struct xfs_trans *tp,
142 struct xfs_inode *ip,
143 struct xfs_perag *pag,
144 xfs_agino_t next_agino)
145{
146 struct xfs_mount *mp = tp->t_mountp;
147 struct xfs_iunlink_item *iup;
148
149 ASSERT(xfs_verify_agino_or_null(pag, next_agino));
150 ASSERT(xfs_verify_agino_or_null(pag, ip->i_next_unlinked));
151
152 /*
153 * Since we're updating a linked list, we should never find that the
154 * current pointer is the same as the new value, unless we're
155 * terminating the list.
156 */
157 if (ip->i_next_unlinked == next_agino) {
158 if (next_agino != NULLAGINO)
159 return -EFSCORRUPTED;
160 return 0;
161 }
162
163 iup = kmem_cache_zalloc(xfs_iunlink_cache, GFP_KERNEL | __GFP_NOFAIL);
164 xfs_log_item_init(mp, &iup->item, XFS_LI_IUNLINK,
165 &xfs_iunlink_item_ops);
166
167 iup->ip = ip;
168 iup->next_agino = next_agino;
169 iup->old_agino = ip->i_next_unlinked;
170 iup->pag = xfs_perag_hold(pag);
171
172 xfs_trans_add_item(tp, &iup->item);
173 tp->t_flags |= XFS_TRANS_DIRTY;
174 set_bit(XFS_LI_DIRTY, addr: &iup->item.li_flags);
175 return 0;
176}
177
178

source code of linux/fs/xfs/xfs_iunlink_item.c