Commit | Line | Data |
---|---|---|
784eb7d8 DC |
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 | ||
21 | struct kmem_cache *xfs_iunlink_cache; | |
22 | ||
23 | static 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 | ||
28 | static void | |
29 | xfs_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(xfs_iunlink_cache, IUL_ITEM(lip)); | |
36 | } | |
37 | ||
38 | ||
39 | static uint64_t | |
40 | xfs_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 | */ | |
50 | static int | |
51 | xfs_iunlink_log_dinode( | |
52 | struct xfs_trans *tp, | |
53 | struct xfs_iunlink_item *iup) | |
54 | { | |
55 | struct xfs_mount *mp = tp->t_mountp; | |
56 | struct xfs_inode *ip = iup->ip; | |
57 | struct xfs_dinode *dip; | |
58 | struct xfs_buf *ibp; | |
59 | int offset; | |
60 | int error; | |
61 | ||
62 | error = xfs_imap_to_bp(mp, 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(ibp, ip->i_imap.im_boffset); | |
74 | ||
75 | /* Make sure the old pointer isn't garbage. */ | |
76 | if (be32_to_cpu(dip->di_next_unlinked) != iup->old_agino) { | |
77 | xfs_inode_verifier_error(ip, -EFSCORRUPTED, __func__, dip, | |
78 | sizeof(*dip), __this_address); | |
79 | error = -EFSCORRUPTED; | |
80 | goto out; | |
81 | } | |
82 | ||
83 | trace_xfs_iunlink_update_dinode(mp, iup->pag->pag_agno, | |
84 | XFS_INO_TO_AGINO(mp, ip->i_ino), | |
85 | be32_to_cpu(dip->di_next_unlinked), iup->next_agino); | |
86 | ||
87 | dip->di_next_unlinked = cpu_to_be32(iup->next_agino); | |
88 | offset = ip->i_imap.im_boffset + | |
89 | offsetof(struct xfs_dinode, di_next_unlinked); | |
90 | ||
91 | xfs_dinode_calc_crc(mp, dip); | |
92 | xfs_trans_inode_buf(tp, ibp); | |
93 | xfs_trans_log_buf(tp, ibp, offset, offset + sizeof(xfs_agino_t) - 1); | |
94 | return 0; | |
95 | out: | |
96 | xfs_trans_brelse(tp, ibp); | |
97 | return error; | |
98 | } | |
99 | ||
100 | /* | |
101 | * On precommit, we grab the inode cluster buffer for the inode number we were | |
102 | * passed, then update the next unlinked field for that inode in the buffer and | |
103 | * log the buffer. This ensures that the inode cluster buffer was logged in the | |
104 | * correct order w.r.t. other inode cluster buffers. We can then remove the | |
105 | * iunlink item from the transaction and release it as it is has now served it's | |
106 | * purpose. | |
107 | */ | |
108 | static int | |
109 | xfs_iunlink_item_precommit( | |
110 | struct xfs_trans *tp, | |
111 | struct xfs_log_item *lip) | |
112 | { | |
113 | struct xfs_iunlink_item *iup = IUL_ITEM(lip); | |
114 | int error; | |
115 | ||
116 | error = xfs_iunlink_log_dinode(tp, iup); | |
117 | list_del(&lip->li_trans); | |
118 | xfs_iunlink_item_release(lip); | |
119 | return error; | |
120 | } | |
121 | ||
122 | static const struct xfs_item_ops xfs_iunlink_item_ops = { | |
123 | .iop_release = xfs_iunlink_item_release, | |
124 | .iop_sort = xfs_iunlink_item_sort, | |
125 | .iop_precommit = xfs_iunlink_item_precommit, | |
126 | }; | |
127 | ||
128 | ||
129 | /* | |
130 | * Initialize the inode log item for a newly allocated (in-core) inode. | |
131 | * | |
132 | * Inode extents can only reside within an AG. Hence specify the starting | |
133 | * block for the inode chunk by offset within an AG as well as the | |
134 | * length of the allocated extent. | |
135 | * | |
136 | * This joins the item to the transaction and marks it dirty so | |
137 | * that we don't need a separate call to do this, nor does the | |
138 | * caller need to know anything about the iunlink item. | |
139 | */ | |
140 | int | |
141 | xfs_iunlink_log_inode( | |
142 | struct xfs_trans *tp, | |
143 | struct xfs_inode *ip, | |
144 | struct xfs_perag *pag, | |
145 | xfs_agino_t next_agino) | |
146 | { | |
147 | struct xfs_mount *mp = tp->t_mountp; | |
148 | struct xfs_iunlink_item *iup; | |
149 | ||
150 | ASSERT(xfs_verify_agino_or_null(pag, next_agino)); | |
151 | ASSERT(xfs_verify_agino_or_null(pag, ip->i_next_unlinked)); | |
152 | ||
153 | /* | |
154 | * Since we're updating a linked list, we should never find that the | |
155 | * current pointer is the same as the new value, unless we're | |
156 | * terminating the list. | |
157 | */ | |
158 | if (ip->i_next_unlinked == next_agino) { | |
159 | if (next_agino != NULLAGINO) | |
160 | return -EFSCORRUPTED; | |
161 | return 0; | |
162 | } | |
163 | ||
164 | iup = kmem_cache_zalloc(xfs_iunlink_cache, GFP_KERNEL | __GFP_NOFAIL); | |
165 | xfs_log_item_init(mp, &iup->item, XFS_LI_IUNLINK, | |
166 | &xfs_iunlink_item_ops); | |
167 | ||
168 | iup->ip = ip; | |
169 | iup->next_agino = next_agino; | |
170 | iup->old_agino = ip->i_next_unlinked; | |
9b2e5a23 | 171 | iup->pag = xfs_perag_hold(pag); |
784eb7d8 DC |
172 | |
173 | xfs_trans_add_item(tp, &iup->item); | |
174 | tp->t_flags |= XFS_TRANS_DIRTY; | |
175 | set_bit(XFS_LI_DIRTY, &iup->item.li_flags); | |
176 | return 0; | |
177 | } | |
178 |