Commit | Line | Data |
---|---|---|
fd920008 AH |
1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* | |
3 | * Copyright (C) 2022 Oracle. All Rights Reserved. | |
4 | * Author: Allison Henderson <allison.henderson@oracle.com> | |
5 | */ | |
6 | ||
7 | #include "xfs.h" | |
8 | #include "xfs_fs.h" | |
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" | |
1d08e11d | 16 | #include "xfs_bmap_btree.h" |
fd920008 AH |
17 | #include "xfs_trans_priv.h" |
18 | #include "xfs_log.h" | |
19 | #include "xfs_inode.h" | |
20 | #include "xfs_da_format.h" | |
21 | #include "xfs_da_btree.h" | |
22 | #include "xfs_attr.h" | |
23 | #include "xfs_attr_item.h" | |
24 | #include "xfs_trace.h" | |
fd920008 | 25 | #include "xfs_trans_space.h" |
abd61ca3 | 26 | #include "xfs_errortag.h" |
fd920008 AH |
27 | #include "xfs_error.h" |
28 | #include "xfs_log_priv.h" | |
29 | #include "xfs_log_recover.h" | |
30 | ||
4136e38a DW |
31 | struct kmem_cache *xfs_attri_cache; |
32 | struct kmem_cache *xfs_attrd_cache; | |
33 | ||
fd920008 AH |
34 | static const struct xfs_item_ops xfs_attri_item_ops; |
35 | static const struct xfs_item_ops xfs_attrd_item_ops; | |
1d08e11d AH |
36 | static struct xfs_attrd_log_item *xfs_trans_get_attrd(struct xfs_trans *tp, |
37 | struct xfs_attri_log_item *attrip); | |
fd920008 AH |
38 | |
39 | static inline struct xfs_attri_log_item *ATTRI_ITEM(struct xfs_log_item *lip) | |
40 | { | |
41 | return container_of(lip, struct xfs_attri_log_item, attri_item); | |
42 | } | |
43 | ||
4183e4f2 DW |
44 | /* |
45 | * Shared xattr name/value buffers for logged extended attribute operations | |
46 | * | |
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. | |
53 | */ | |
54 | ||
55 | static inline struct xfs_attri_log_nameval * | |
56 | xfs_attri_log_nameval_get( | |
57 | struct xfs_attri_log_nameval *nv) | |
58 | { | |
59 | if (!refcount_inc_not_zero(&nv->refcount)) | |
60 | return NULL; | |
61 | return nv; | |
62 | } | |
63 | ||
64 | static inline void | |
65 | xfs_attri_log_nameval_put( | |
66 | struct xfs_attri_log_nameval *nv) | |
67 | { | |
68 | if (!nv) | |
69 | return; | |
70 | if (refcount_dec_and_test(&nv->refcount)) | |
71 | kvfree(nv); | |
72 | } | |
73 | ||
74 | static inline struct xfs_attri_log_nameval * | |
75 | xfs_attri_log_nameval_alloc( | |
76 | const void *name, | |
77 | unsigned int name_len, | |
78 | const void *value, | |
79 | unsigned int value_len) | |
80 | { | |
81 | struct xfs_attri_log_nameval *nv; | |
82 | ||
83 | /* | |
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. | |
86 | */ | |
87 | nv = xlog_kvmalloc(sizeof(struct xfs_attri_log_nameval) + | |
88 | name_len + value_len); | |
4183e4f2 DW |
89 | |
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); | |
94 | ||
95 | if (value_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); | |
99 | } else { | |
100 | nv->value.i_addr = NULL; | |
101 | nv->value.i_len = 0; | |
102 | } | |
103 | nv->value.i_type = XLOG_REG_TYPE_ATTR_VALUE; | |
104 | ||
105 | refcount_set(&nv->refcount, 1); | |
106 | return nv; | |
107 | } | |
108 | ||
fd920008 AH |
109 | STATIC void |
110 | xfs_attri_item_free( | |
111 | struct xfs_attri_log_item *attrip) | |
112 | { | |
113 | kmem_free(attrip->attri_item.li_lv_shadow); | |
4183e4f2 DW |
114 | xfs_attri_log_nameval_put(attrip->attri_nameval); |
115 | kmem_cache_free(xfs_attri_cache, attrip); | |
fd920008 AH |
116 | } |
117 | ||
118 | /* | |
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. | |
124 | */ | |
125 | STATIC void | |
126 | xfs_attri_release( | |
127 | struct xfs_attri_log_item *attrip) | |
128 | { | |
129 | ASSERT(atomic_read(&attrip->attri_refcount) > 0); | |
130 | if (!atomic_dec_and_test(&attrip->attri_refcount)) | |
131 | return; | |
132 | ||
133 | xfs_trans_ail_delete(&attrip->attri_item, 0); | |
134 | xfs_attri_item_free(attrip); | |
135 | } | |
136 | ||
137 | STATIC void | |
138 | xfs_attri_item_size( | |
139 | struct xfs_log_item *lip, | |
140 | int *nvecs, | |
141 | int *nbytes) | |
142 | { | |
143 | struct xfs_attri_log_item *attrip = ATTRI_ITEM(lip); | |
4183e4f2 | 144 | struct xfs_attri_log_nameval *nv = attrip->attri_nameval; |
fd920008 AH |
145 | |
146 | *nvecs += 2; | |
147 | *nbytes += sizeof(struct xfs_attri_log_format) + | |
4183e4f2 | 148 | xlog_calc_iovec_len(nv->name.i_len); |
fd920008 | 149 | |
4183e4f2 | 150 | if (!nv->value.i_len) |
fd920008 AH |
151 | return; |
152 | ||
153 | *nvecs += 1; | |
4183e4f2 | 154 | *nbytes += xlog_calc_iovec_len(nv->value.i_len); |
fd920008 AH |
155 | } |
156 | ||
157 | /* | |
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 | |
161 | */ | |
162 | STATIC void | |
163 | xfs_attri_item_format( | |
164 | struct xfs_log_item *lip, | |
165 | struct xfs_log_vec *lv) | |
166 | { | |
167 | struct xfs_attri_log_item *attrip = ATTRI_ITEM(lip); | |
168 | struct xfs_log_iovec *vecp = NULL; | |
4183e4f2 | 169 | struct xfs_attri_log_nameval *nv = attrip->attri_nameval; |
fd920008 AH |
170 | |
171 | attrip->attri_format.alfi_type = XFS_LI_ATTRI; | |
172 | attrip->attri_format.alfi_size = 1; | |
173 | ||
174 | /* | |
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 | |
178 | * the log recovery. | |
179 | */ | |
180 | ||
4183e4f2 | 181 | ASSERT(nv->name.i_len > 0); |
fd920008 AH |
182 | attrip->attri_format.alfi_size++; |
183 | ||
4183e4f2 | 184 | if (nv->value.i_len > 0) |
fd920008 AH |
185 | attrip->attri_format.alfi_size++; |
186 | ||
187 | xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_ATTRI_FORMAT, | |
188 | &attrip->attri_format, | |
189 | sizeof(struct xfs_attri_log_format)); | |
4183e4f2 DW |
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); | |
fd920008 AH |
193 | } |
194 | ||
195 | /* | |
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 | |
202 | * it. | |
203 | */ | |
204 | STATIC void | |
205 | xfs_attri_item_unpin( | |
206 | struct xfs_log_item *lip, | |
207 | int remove) | |
208 | { | |
209 | xfs_attri_release(ATTRI_ITEM(lip)); | |
210 | } | |
211 | ||
212 | ||
213 | STATIC void | |
214 | xfs_attri_item_release( | |
215 | struct xfs_log_item *lip) | |
216 | { | |
217 | xfs_attri_release(ATTRI_ITEM(lip)); | |
218 | } | |
219 | ||
220 | /* | |
221 | * Allocate and initialize an attri item. Caller may allocate an additional | |
222 | * trailing buffer for name and value | |
223 | */ | |
224 | STATIC struct xfs_attri_log_item * | |
225 | xfs_attri_init( | |
226 | struct xfs_mount *mp, | |
4183e4f2 | 227 | struct xfs_attri_log_nameval *nv) |
fd920008 AH |
228 | { |
229 | struct xfs_attri_log_item *attrip; | |
fd920008 | 230 | |
4183e4f2 | 231 | attrip = kmem_cache_zalloc(xfs_attri_cache, GFP_NOFS | __GFP_NOFAIL); |
fd920008 | 232 | |
4183e4f2 DW |
233 | /* |
234 | * Grab an extra reference to the name/value buffer for this log item. | |
235 | * The caller retains its own reference! | |
236 | */ | |
237 | attrip->attri_nameval = xfs_attri_log_nameval_get(nv); | |
238 | ASSERT(attrip->attri_nameval); | |
fd920008 AH |
239 | |
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); | |
244 | ||
245 | return attrip; | |
246 | } | |
247 | ||
fd920008 AH |
248 | static inline struct xfs_attrd_log_item *ATTRD_ITEM(struct xfs_log_item *lip) |
249 | { | |
250 | return container_of(lip, struct xfs_attrd_log_item, attrd_item); | |
251 | } | |
252 | ||
253 | STATIC void | |
254 | xfs_attrd_item_free(struct xfs_attrd_log_item *attrdp) | |
255 | { | |
256 | kmem_free(attrdp->attrd_item.li_lv_shadow); | |
2fe3ffcf | 257 | kmem_cache_free(xfs_attrd_cache, attrdp); |
fd920008 AH |
258 | } |
259 | ||
260 | STATIC void | |
261 | xfs_attrd_item_size( | |
262 | struct xfs_log_item *lip, | |
263 | int *nvecs, | |
264 | int *nbytes) | |
265 | { | |
266 | *nvecs += 1; | |
267 | *nbytes += sizeof(struct xfs_attrd_log_format); | |
268 | } | |
269 | ||
270 | /* | |
271 | * This is called to fill in the log iovecs for the given attrd log item. We use | |
272 | * only 1 iovec for the attrd_format, and we point that at the attr_log_format | |
273 | * structure embedded in the attrd item. | |
274 | */ | |
275 | STATIC void | |
276 | xfs_attrd_item_format( | |
277 | struct xfs_log_item *lip, | |
278 | struct xfs_log_vec *lv) | |
279 | { | |
280 | struct xfs_attrd_log_item *attrdp = ATTRD_ITEM(lip); | |
281 | struct xfs_log_iovec *vecp = NULL; | |
282 | ||
283 | attrdp->attrd_format.alfd_type = XFS_LI_ATTRD; | |
284 | attrdp->attrd_format.alfd_size = 1; | |
285 | ||
286 | xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_ATTRD_FORMAT, | |
287 | &attrdp->attrd_format, | |
288 | sizeof(struct xfs_attrd_log_format)); | |
289 | } | |
290 | ||
291 | /* | |
292 | * The ATTRD is either committed or aborted if the transaction is canceled. If | |
293 | * the transaction is canceled, drop our reference to the ATTRI and free the | |
294 | * ATTRD. | |
295 | */ | |
296 | STATIC void | |
297 | xfs_attrd_item_release( | |
298 | struct xfs_log_item *lip) | |
299 | { | |
300 | struct xfs_attrd_log_item *attrdp = ATTRD_ITEM(lip); | |
301 | ||
302 | xfs_attri_release(attrdp->attrd_attrip); | |
303 | xfs_attrd_item_free(attrdp); | |
304 | } | |
305 | ||
1d08e11d AH |
306 | static struct xfs_log_item * |
307 | xfs_attrd_item_intent( | |
308 | struct xfs_log_item *lip) | |
309 | { | |
310 | return &ATTRD_ITEM(lip)->attrd_attrip->attri_item; | |
311 | } | |
312 | ||
313 | /* | |
314 | * Performs one step of an attribute update intent and marks the attrd item | |
315 | * dirty.. An attr operation may be a set or a remove. Note that the | |
316 | * transaction is marked dirty regardless of whether the operation succeeds or | |
317 | * fails to support the ATTRI/ATTRD lifecycle rules. | |
318 | */ | |
319 | STATIC int | |
320 | xfs_xattri_finish_update( | |
e3c5de22 | 321 | struct xfs_attr_intent *attr, |
4b9879b1 | 322 | struct xfs_attrd_log_item *attrdp) |
1d08e11d | 323 | { |
d68c51e9 | 324 | struct xfs_da_args *args = attr->xattri_da_args; |
1d08e11d AH |
325 | int error; |
326 | ||
abd61ca3 AH |
327 | if (XFS_TEST_ERROR(false, args->dp->i_mount, XFS_ERRTAG_LARP)) { |
328 | error = -EIO; | |
329 | goto out; | |
330 | } | |
331 | ||
4b9879b1 DC |
332 | error = xfs_attr_set_iter(attr); |
333 | if (!error && attr->xattri_dela_state != XFS_DAS_DONE) | |
334 | error = -EAGAIN; | |
abd61ca3 | 335 | out: |
1d08e11d AH |
336 | /* |
337 | * Mark the transaction dirty, even on error. This ensures the | |
338 | * transaction is aborted, which: | |
339 | * | |
340 | * 1.) releases the ATTRI and frees the ATTRD | |
341 | * 2.) shuts down the filesystem | |
342 | */ | |
343 | args->trans->t_flags |= XFS_TRANS_DIRTY | XFS_TRANS_HAS_INTENT_DONE; | |
344 | ||
345 | /* | |
346 | * attr intent/done items are null when logged attributes are disabled | |
347 | */ | |
348 | if (attrdp) | |
349 | set_bit(XFS_LI_DIRTY, &attrdp->attrd_item.li_flags); | |
350 | ||
351 | return error; | |
352 | } | |
353 | ||
354 | /* Log an attr to the intent item. */ | |
355 | STATIC void | |
356 | xfs_attr_log_item( | |
357 | struct xfs_trans *tp, | |
358 | struct xfs_attri_log_item *attrip, | |
e3c5de22 | 359 | const struct xfs_attr_intent *attr) |
1d08e11d AH |
360 | { |
361 | struct xfs_attri_log_format *attrp; | |
362 | ||
363 | tp->t_flags |= XFS_TRANS_DIRTY; | |
364 | set_bit(XFS_LI_DIRTY, &attrip->attri_item.li_flags); | |
365 | ||
366 | /* | |
e3c5de22 | 367 | * At this point the xfs_attr_intent has been constructed, and we've |
1d08e11d | 368 | * created the log intent. Fill in the attri log item and log format |
e3c5de22 | 369 | * structure with fields from this xfs_attr_intent |
1d08e11d AH |
370 | */ |
371 | attrp = &attrip->attri_format; | |
d68c51e9 | 372 | attrp->alfi_ino = attr->xattri_da_args->dp->i_ino; |
b53d212b | 373 | ASSERT(!(attr->xattri_op_flags & ~XFS_ATTRI_OP_FLAGS_TYPE_MASK)); |
1d08e11d | 374 | attrp->alfi_op_flags = attr->xattri_op_flags; |
4183e4f2 DW |
375 | attrp->alfi_value_len = attr->xattri_nameval->value.i_len; |
376 | attrp->alfi_name_len = attr->xattri_nameval->name.i_len; | |
85d76aec DW |
377 | ASSERT(!(attr->xattri_da_args->attr_filter & ~XFS_ATTRI_FILTER_MASK)); |
378 | attrp->alfi_attr_filter = attr->xattri_da_args->attr_filter; | |
1d08e11d AH |
379 | } |
380 | ||
381 | /* Get an ATTRI. */ | |
382 | static struct xfs_log_item * | |
383 | xfs_attr_create_intent( | |
384 | struct xfs_trans *tp, | |
385 | struct list_head *items, | |
386 | unsigned int count, | |
387 | bool sort) | |
388 | { | |
389 | struct xfs_mount *mp = tp->t_mountp; | |
390 | struct xfs_attri_log_item *attrip; | |
e3c5de22 | 391 | struct xfs_attr_intent *attr; |
f4288f01 | 392 | struct xfs_da_args *args; |
1d08e11d AH |
393 | |
394 | ASSERT(count == 1); | |
395 | ||
1d08e11d AH |
396 | /* |
397 | * Each attr item only performs one attribute operation at a time, so | |
398 | * this is a list of one | |
399 | */ | |
4183e4f2 DW |
400 | attr = list_first_entry_or_null(items, struct xfs_attr_intent, |
401 | xattri_list); | |
f4288f01 DW |
402 | args = attr->xattri_da_args; |
403 | ||
404 | if (!(args->op_flags & XFS_DA_OP_LOGGED)) | |
405 | return NULL; | |
4183e4f2 DW |
406 | |
407 | /* | |
408 | * Create a buffer to store the attribute name and value. This buffer | |
409 | * will be shared between the higher level deferred xattr work state | |
410 | * and the lower level xattr log items. | |
411 | */ | |
412 | if (!attr->xattri_nameval) { | |
4183e4f2 DW |
413 | /* |
414 | * Transfer our reference to the name/value buffer to the | |
415 | * deferred work state structure. | |
416 | */ | |
417 | attr->xattri_nameval = xfs_attri_log_nameval_alloc(args->name, | |
418 | args->namelen, args->value, args->valuelen); | |
1d08e11d | 419 | } |
4183e4f2 DW |
420 | |
421 | attrip = xfs_attri_init(mp, attr->xattri_nameval); | |
422 | xfs_trans_add_item(tp, &attrip->attri_item); | |
423 | xfs_attr_log_item(tp, attrip, attr); | |
1d08e11d AH |
424 | |
425 | return &attrip->attri_item; | |
426 | } | |
427 | ||
309001c2 DW |
428 | static inline void |
429 | xfs_attr_free_item( | |
e3c5de22 | 430 | struct xfs_attr_intent *attr) |
309001c2 DW |
431 | { |
432 | if (attr->xattri_da_state) | |
433 | xfs_da_state_free(attr->xattri_da_state); | |
4183e4f2 | 434 | xfs_attri_log_nameval_put(attr->xattri_nameval); |
e2c78949 DW |
435 | if (attr->xattri_da_args->op_flags & XFS_DA_OP_RECOVERY) |
436 | kmem_free(attr); | |
437 | else | |
438 | kmem_cache_free(xfs_attr_intent_cache, attr); | |
309001c2 DW |
439 | } |
440 | ||
1d08e11d AH |
441 | /* Process an attr. */ |
442 | STATIC int | |
443 | xfs_attr_finish_item( | |
444 | struct xfs_trans *tp, | |
445 | struct xfs_log_item *done, | |
446 | struct list_head *item, | |
447 | struct xfs_btree_cur **state) | |
448 | { | |
e3c5de22 | 449 | struct xfs_attr_intent *attr; |
1d08e11d AH |
450 | struct xfs_attrd_log_item *done_item = NULL; |
451 | int error; | |
1d08e11d | 452 | |
e3c5de22 | 453 | attr = container_of(item, struct xfs_attr_intent, xattri_list); |
1d08e11d AH |
454 | if (done) |
455 | done_item = ATTRD_ITEM(done); | |
456 | ||
457 | /* | |
458 | * Always reset trans after EAGAIN cycle | |
459 | * since the transaction is new | |
460 | */ | |
d68c51e9 | 461 | attr->xattri_da_args->trans = tp; |
1d08e11d | 462 | |
4b9879b1 | 463 | error = xfs_xattri_finish_update(attr, done_item); |
1d08e11d | 464 | if (error != -EAGAIN) |
309001c2 | 465 | xfs_attr_free_item(attr); |
1d08e11d AH |
466 | |
467 | return error; | |
468 | } | |
469 | ||
470 | /* Abort all pending ATTRs. */ | |
471 | STATIC void | |
472 | xfs_attr_abort_intent( | |
473 | struct xfs_log_item *intent) | |
474 | { | |
475 | xfs_attri_release(ATTRI_ITEM(intent)); | |
476 | } | |
477 | ||
478 | /* Cancel an attr */ | |
479 | STATIC void | |
480 | xfs_attr_cancel_item( | |
481 | struct list_head *item) | |
482 | { | |
e3c5de22 | 483 | struct xfs_attr_intent *attr; |
1d08e11d | 484 | |
e3c5de22 | 485 | attr = container_of(item, struct xfs_attr_intent, xattri_list); |
309001c2 | 486 | xfs_attr_free_item(attr); |
1d08e11d AH |
487 | } |
488 | ||
fd920008 AH |
489 | STATIC bool |
490 | xfs_attri_item_match( | |
491 | struct xfs_log_item *lip, | |
492 | uint64_t intent_id) | |
493 | { | |
494 | return ATTRI_ITEM(lip)->attri_format.alfi_id == intent_id; | |
495 | } | |
496 | ||
497 | /* Is this recovered ATTRI format ok? */ | |
498 | static inline bool | |
499 | xfs_attri_validate( | |
500 | struct xfs_mount *mp, | |
501 | struct xfs_attri_log_format *attrp) | |
502 | { | |
503 | unsigned int op = attrp->alfi_op_flags & | |
b53d212b | 504 | XFS_ATTRI_OP_FLAGS_TYPE_MASK; |
fd920008 AH |
505 | |
506 | if (attrp->__pad != 0) | |
507 | return false; | |
508 | ||
b53d212b | 509 | if (attrp->alfi_op_flags & ~XFS_ATTRI_OP_FLAGS_TYPE_MASK) |
356cb708 DW |
510 | return false; |
511 | ||
85d76aec DW |
512 | if (attrp->alfi_attr_filter & ~XFS_ATTRI_FILTER_MASK) |
513 | return false; | |
514 | ||
fd920008 | 515 | /* alfi_op_flags should be either a set or remove */ |
709c8632 | 516 | switch (op) { |
b53d212b DW |
517 | case XFS_ATTRI_OP_FLAGS_SET: |
518 | case XFS_ATTRI_OP_FLAGS_REPLACE: | |
519 | case XFS_ATTRI_OP_FLAGS_REMOVE: | |
709c8632 DC |
520 | break; |
521 | default: | |
fd920008 | 522 | return false; |
709c8632 | 523 | } |
fd920008 AH |
524 | |
525 | if (attrp->alfi_value_len > XATTR_SIZE_MAX) | |
526 | return false; | |
527 | ||
528 | if ((attrp->alfi_name_len > XATTR_NAME_MAX) || | |
529 | (attrp->alfi_name_len == 0)) | |
530 | return false; | |
531 | ||
532 | return xfs_verify_ino(mp, attrp->alfi_ino); | |
533 | } | |
534 | ||
1d08e11d AH |
535 | /* |
536 | * Process an attr intent item that was recovered from the log. We need to | |
537 | * delete the attr that it describes. | |
538 | */ | |
539 | STATIC int | |
540 | xfs_attri_item_recover( | |
541 | struct xfs_log_item *lip, | |
542 | struct list_head *capture_list) | |
543 | { | |
544 | struct xfs_attri_log_item *attrip = ATTRI_ITEM(lip); | |
e3c5de22 | 545 | struct xfs_attr_intent *attr; |
1d08e11d AH |
546 | struct xfs_mount *mp = lip->li_log->l_mp; |
547 | struct xfs_inode *ip; | |
548 | struct xfs_da_args *args; | |
549 | struct xfs_trans *tp; | |
550 | struct xfs_trans_res tres; | |
551 | struct xfs_attri_log_format *attrp; | |
4183e4f2 | 552 | struct xfs_attri_log_nameval *nv = attrip->attri_nameval; |
f94e08b6 | 553 | int error; |
1d08e11d AH |
554 | int total; |
555 | int local; | |
556 | struct xfs_attrd_log_item *done_item = NULL; | |
557 | ||
558 | /* | |
559 | * First check the validity of the attr described by the ATTRI. If any | |
560 | * are bad, then assume that all are bad and just toss the ATTRI. | |
561 | */ | |
562 | attrp = &attrip->attri_format; | |
563 | if (!xfs_attri_validate(mp, attrp) || | |
4183e4f2 | 564 | !xfs_attr_namecheck(nv->name.i_addr, nv->name.i_len)) |
1d08e11d AH |
565 | return -EFSCORRUPTED; |
566 | ||
567 | error = xlog_recover_iget(mp, attrp->alfi_ino, &ip); | |
568 | if (error) | |
569 | return error; | |
570 | ||
e3c5de22 | 571 | attr = kmem_zalloc(sizeof(struct xfs_attr_intent) + |
1d08e11d AH |
572 | sizeof(struct xfs_da_args), KM_NOFS); |
573 | args = (struct xfs_da_args *)(attr + 1); | |
574 | ||
d68c51e9 | 575 | attr->xattri_da_args = args; |
356cb708 | 576 | attr->xattri_op_flags = attrp->alfi_op_flags & |
b53d212b | 577 | XFS_ATTRI_OP_FLAGS_TYPE_MASK; |
1d08e11d | 578 | |
4183e4f2 DW |
579 | /* |
580 | * We're reconstructing the deferred work state structure from the | |
581 | * recovered log item. Grab a reference to the name/value buffer and | |
582 | * attach it to the new work state. | |
583 | */ | |
584 | attr->xattri_nameval = xfs_attri_log_nameval_get(nv); | |
585 | ASSERT(attr->xattri_nameval); | |
586 | ||
1d08e11d AH |
587 | args->dp = ip; |
588 | args->geo = mp->m_attr_geo; | |
589 | args->whichfork = XFS_ATTR_FORK; | |
4183e4f2 DW |
590 | args->name = nv->name.i_addr; |
591 | args->namelen = nv->name.i_len; | |
1d08e11d | 592 | args->hashval = xfs_da_hashname(args->name, args->namelen); |
85d76aec | 593 | args->attr_filter = attrp->alfi_attr_filter & XFS_ATTRI_FILTER_MASK; |
f4288f01 DW |
594 | args->op_flags = XFS_DA_OP_RECOVERY | XFS_DA_OP_OKNOENT | |
595 | XFS_DA_OP_LOGGED; | |
596 | ||
597 | ASSERT(xfs_sb_version_haslogxattrs(&mp->m_sb)); | |
1d08e11d | 598 | |
356cb708 | 599 | switch (attr->xattri_op_flags) { |
b53d212b DW |
600 | case XFS_ATTRI_OP_FLAGS_SET: |
601 | case XFS_ATTRI_OP_FLAGS_REPLACE: | |
4183e4f2 DW |
602 | args->value = nv->value.i_addr; |
603 | args->valuelen = nv->value.i_len; | |
1d08e11d | 604 | args->total = xfs_attr_calc_size(args, &local); |
fdaf1bb3 DC |
605 | if (xfs_inode_hasattr(args->dp)) |
606 | attr->xattri_dela_state = xfs_attr_init_replace_state(args); | |
607 | else | |
608 | attr->xattri_dela_state = xfs_attr_init_add_state(args); | |
e0c41089 | 609 | break; |
b53d212b | 610 | case XFS_ATTRI_OP_FLAGS_REMOVE: |
fdaf1bb3 DC |
611 | if (!xfs_inode_hasattr(args->dp)) |
612 | goto out; | |
4b9879b1 | 613 | attr->xattri_dela_state = xfs_attr_init_remove_state(args); |
e0c41089 DC |
614 | break; |
615 | default: | |
616 | ASSERT(0); | |
617 | error = -EFSCORRUPTED; | |
618 | goto out; | |
1d08e11d | 619 | } |
c3546cf5 AH |
620 | |
621 | xfs_init_attr_trans(args, &tres, &total); | |
1d08e11d AH |
622 | error = xfs_trans_alloc(mp, &tres, total, 0, XFS_TRANS_RESERVE, &tp); |
623 | if (error) | |
624 | goto out; | |
625 | ||
626 | args->trans = tp; | |
627 | done_item = xfs_trans_get_attrd(tp, attrip); | |
628 | ||
629 | xfs_ilock(ip, XFS_ILOCK_EXCL); | |
630 | xfs_trans_ijoin(tp, ip, 0); | |
631 | ||
f94e08b6 DW |
632 | error = xfs_xattri_finish_update(attr, done_item); |
633 | if (error == -EAGAIN) { | |
634 | /* | |
635 | * There's more work to do, so add the intent item to this | |
636 | * transaction so that we can continue it later. | |
637 | */ | |
1d08e11d | 638 | xfs_defer_add(tp, XFS_DEFER_OPS_TYPE_ATTR, &attr->xattri_list); |
f94e08b6 DW |
639 | error = xfs_defer_ops_capture_and_commit(tp, capture_list); |
640 | if (error) | |
641 | goto out_unlock; | |
642 | ||
f94e08b6 DW |
643 | xfs_iunlock(ip, XFS_ILOCK_EXCL); |
644 | xfs_irele(ip); | |
645 | return 0; | |
646 | } | |
1d08e11d AH |
647 | if (error) { |
648 | xfs_trans_cancel(tp); | |
649 | goto out_unlock; | |
650 | } | |
651 | ||
652 | error = xfs_defer_ops_capture_and_commit(tp, capture_list); | |
1d08e11d | 653 | out_unlock: |
1d08e11d AH |
654 | xfs_iunlock(ip, XFS_ILOCK_EXCL); |
655 | xfs_irele(ip); | |
656 | out: | |
f94e08b6 | 657 | xfs_attr_free_item(attr); |
1d08e11d AH |
658 | return error; |
659 | } | |
660 | ||
661 | /* Re-log an intent item to push the log tail forward. */ | |
662 | static struct xfs_log_item * | |
663 | xfs_attri_item_relog( | |
664 | struct xfs_log_item *intent, | |
665 | struct xfs_trans *tp) | |
666 | { | |
667 | struct xfs_attrd_log_item *attrdp; | |
668 | struct xfs_attri_log_item *old_attrip; | |
669 | struct xfs_attri_log_item *new_attrip; | |
670 | struct xfs_attri_log_format *new_attrp; | |
671 | struct xfs_attri_log_format *old_attrp; | |
672 | ||
673 | old_attrip = ATTRI_ITEM(intent); | |
674 | old_attrp = &old_attrip->attri_format; | |
675 | ||
676 | tp->t_flags |= XFS_TRANS_DIRTY; | |
677 | attrdp = xfs_trans_get_attrd(tp, old_attrip); | |
678 | set_bit(XFS_LI_DIRTY, &attrdp->attrd_item.li_flags); | |
679 | ||
4183e4f2 DW |
680 | /* |
681 | * Create a new log item that shares the same name/value buffer as the | |
682 | * old log item. | |
683 | */ | |
684 | new_attrip = xfs_attri_init(tp->t_mountp, old_attrip->attri_nameval); | |
1d08e11d AH |
685 | new_attrp = &new_attrip->attri_format; |
686 | ||
687 | new_attrp->alfi_ino = old_attrp->alfi_ino; | |
688 | new_attrp->alfi_op_flags = old_attrp->alfi_op_flags; | |
689 | new_attrp->alfi_value_len = old_attrp->alfi_value_len; | |
690 | new_attrp->alfi_name_len = old_attrp->alfi_name_len; | |
85d76aec | 691 | new_attrp->alfi_attr_filter = old_attrp->alfi_attr_filter; |
1d08e11d | 692 | |
1d08e11d AH |
693 | xfs_trans_add_item(tp, &new_attrip->attri_item); |
694 | set_bit(XFS_LI_DIRTY, &new_attrip->attri_item.li_flags); | |
695 | ||
696 | return &new_attrip->attri_item; | |
697 | } | |
698 | ||
fd920008 AH |
699 | STATIC int |
700 | xlog_recover_attri_commit_pass2( | |
701 | struct xlog *log, | |
702 | struct list_head *buffer_list, | |
703 | struct xlog_recover_item *item, | |
704 | xfs_lsn_t lsn) | |
705 | { | |
fd920008 AH |
706 | struct xfs_mount *mp = log->l_mp; |
707 | struct xfs_attri_log_item *attrip; | |
708 | struct xfs_attri_log_format *attri_formatp; | |
4183e4f2 DW |
709 | struct xfs_attri_log_nameval *nv; |
710 | const void *attr_value = NULL; | |
25b1e9dc | 711 | const void *attr_name; |
59da7ff4 | 712 | size_t len; |
fd920008 | 713 | |
4183e4f2 | 714 | attri_formatp = item->ri_buf[0].i_addr; |
25b1e9dc | 715 | attr_name = item->ri_buf[1].i_addr; |
fd920008 | 716 | |
25b1e9dc | 717 | /* Validate xfs_attri_log_format before the large memory allocation */ |
59da7ff4 DW |
718 | len = sizeof(struct xfs_attri_log_format); |
719 | if (item->ri_buf[0].i_len != len) { | |
950f0d50 DW |
720 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, |
721 | item->ri_buf[0].i_addr, item->ri_buf[0].i_len); | |
59da7ff4 DW |
722 | return -EFSCORRUPTED; |
723 | } | |
724 | ||
fd920008 | 725 | if (!xfs_attri_validate(mp, attri_formatp)) { |
950f0d50 DW |
726 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, |
727 | item->ri_buf[0].i_addr, item->ri_buf[0].i_len); | |
fd920008 AH |
728 | return -EFSCORRUPTED; |
729 | } | |
730 | ||
59da7ff4 DW |
731 | /* Validate the attr name */ |
732 | if (item->ri_buf[1].i_len != | |
733 | xlog_calc_iovec_len(attri_formatp->alfi_name_len)) { | |
950f0d50 DW |
734 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, |
735 | item->ri_buf[0].i_addr, item->ri_buf[0].i_len); | |
59da7ff4 DW |
736 | return -EFSCORRUPTED; |
737 | } | |
738 | ||
25b1e9dc | 739 | if (!xfs_attr_namecheck(attr_name, attri_formatp->alfi_name_len)) { |
950f0d50 DW |
740 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, |
741 | item->ri_buf[1].i_addr, item->ri_buf[1].i_len); | |
25b1e9dc DW |
742 | return -EFSCORRUPTED; |
743 | } | |
744 | ||
59da7ff4 DW |
745 | /* Validate the attr value, if present */ |
746 | if (attri_formatp->alfi_value_len != 0) { | |
747 | if (item->ri_buf[2].i_len != xlog_calc_iovec_len(attri_formatp->alfi_value_len)) { | |
950f0d50 DW |
748 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, |
749 | item->ri_buf[0].i_addr, | |
750 | item->ri_buf[0].i_len); | |
59da7ff4 DW |
751 | return -EFSCORRUPTED; |
752 | } | |
753 | ||
4183e4f2 | 754 | attr_value = item->ri_buf[2].i_addr; |
59da7ff4 | 755 | } |
4183e4f2 DW |
756 | |
757 | /* | |
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 | |
760 | * reference. | |
761 | */ | |
762 | nv = xfs_attri_log_nameval_alloc(attr_name, | |
763 | attri_formatp->alfi_name_len, attr_value, | |
764 | attri_formatp->alfi_value_len); | |
fd920008 | 765 | |
4183e4f2 | 766 | attrip = xfs_attri_init(mp, nv); |
59da7ff4 | 767 | memcpy(&attrip->attri_format, attri_formatp, len); |
fd920008 | 768 | |
fd920008 AH |
769 | /* |
770 | * The ATTRI has two references. One for the ATTRD and one for ATTRI to | |
771 | * ensure it makes it into the AIL. Insert the ATTRI into the AIL | |
772 | * directly and drop the ATTRI reference. Note that | |
773 | * xfs_trans_ail_update() drops the AIL lock. | |
774 | */ | |
775 | xfs_trans_ail_insert(log->l_ailp, &attrip->attri_item, lsn); | |
776 | xfs_attri_release(attrip); | |
4183e4f2 | 777 | xfs_attri_log_nameval_put(nv); |
fd920008 | 778 | return 0; |
fd920008 AH |
779 | } |
780 | ||
1d08e11d AH |
781 | /* |
782 | * This routine is called to allocate an "attr free done" log item. | |
783 | */ | |
784 | static struct xfs_attrd_log_item * | |
785 | xfs_trans_get_attrd(struct xfs_trans *tp, | |
786 | struct xfs_attri_log_item *attrip) | |
787 | { | |
788 | struct xfs_attrd_log_item *attrdp; | |
789 | ||
790 | ASSERT(tp != NULL); | |
791 | ||
f3d430ff | 792 | attrdp = kmem_cache_zalloc(xfs_attrd_cache, GFP_NOFS | __GFP_NOFAIL); |
1d08e11d AH |
793 | |
794 | xfs_log_item_init(tp->t_mountp, &attrdp->attrd_item, XFS_LI_ATTRD, | |
795 | &xfs_attrd_item_ops); | |
796 | attrdp->attrd_attrip = attrip; | |
797 | attrdp->attrd_format.alfd_alf_id = attrip->attri_format.alfi_id; | |
798 | ||
799 | xfs_trans_add_item(tp, &attrdp->attrd_item); | |
800 | return attrdp; | |
801 | } | |
802 | ||
803 | /* Get an ATTRD so we can process all the attrs. */ | |
804 | static struct xfs_log_item * | |
805 | xfs_attr_create_done( | |
806 | struct xfs_trans *tp, | |
807 | struct xfs_log_item *intent, | |
808 | unsigned int count) | |
809 | { | |
810 | if (!intent) | |
811 | return NULL; | |
812 | ||
813 | return &xfs_trans_get_attrd(tp, ATTRI_ITEM(intent))->attrd_item; | |
814 | } | |
815 | ||
816 | const struct xfs_defer_op_type xfs_attr_defer_type = { | |
817 | .max_items = 1, | |
818 | .create_intent = xfs_attr_create_intent, | |
819 | .abort_intent = xfs_attr_abort_intent, | |
820 | .create_done = xfs_attr_create_done, | |
821 | .finish_item = xfs_attr_finish_item, | |
822 | .cancel_item = xfs_attr_cancel_item, | |
823 | }; | |
824 | ||
fd920008 AH |
825 | /* |
826 | * This routine is called when an ATTRD format structure is found in a committed | |
827 | * transaction in the log. Its purpose is to cancel the corresponding ATTRI if | |
828 | * it was still in the log. To do this it searches the AIL for the ATTRI with | |
829 | * an id equal to that in the ATTRD format structure. If we find it we drop | |
830 | * the ATTRD reference, which removes the ATTRI from the AIL and frees it. | |
831 | */ | |
832 | STATIC int | |
833 | xlog_recover_attrd_commit_pass2( | |
834 | struct xlog *log, | |
835 | struct list_head *buffer_list, | |
836 | struct xlog_recover_item *item, | |
837 | xfs_lsn_t lsn) | |
838 | { | |
839 | struct xfs_attrd_log_format *attrd_formatp; | |
840 | ||
841 | attrd_formatp = item->ri_buf[0].i_addr; | |
842 | if (item->ri_buf[0].i_len != sizeof(struct xfs_attrd_log_format)) { | |
950f0d50 DW |
843 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, log->l_mp, |
844 | item->ri_buf[0].i_addr, item->ri_buf[0].i_len); | |
fd920008 AH |
845 | return -EFSCORRUPTED; |
846 | } | |
847 | ||
848 | xlog_recover_release_intent(log, XFS_LI_ATTRI, | |
849 | attrd_formatp->alfd_alf_id); | |
850 | return 0; | |
851 | } | |
852 | ||
853 | static const struct xfs_item_ops xfs_attri_item_ops = { | |
854 | .flags = XFS_ITEM_INTENT, | |
855 | .iop_size = xfs_attri_item_size, | |
856 | .iop_format = xfs_attri_item_format, | |
857 | .iop_unpin = xfs_attri_item_unpin, | |
fd920008 | 858 | .iop_release = xfs_attri_item_release, |
1d08e11d | 859 | .iop_recover = xfs_attri_item_recover, |
fd920008 | 860 | .iop_match = xfs_attri_item_match, |
1d08e11d | 861 | .iop_relog = xfs_attri_item_relog, |
fd920008 AH |
862 | }; |
863 | ||
864 | const struct xlog_recover_item_ops xlog_attri_item_ops = { | |
865 | .item_type = XFS_LI_ATTRI, | |
866 | .commit_pass2 = xlog_recover_attri_commit_pass2, | |
867 | }; | |
868 | ||
869 | static const struct xfs_item_ops xfs_attrd_item_ops = { | |
870 | .flags = XFS_ITEM_RELEASE_WHEN_COMMITTED | | |
871 | XFS_ITEM_INTENT_DONE, | |
872 | .iop_size = xfs_attrd_item_size, | |
873 | .iop_format = xfs_attrd_item_format, | |
874 | .iop_release = xfs_attrd_item_release, | |
1d08e11d | 875 | .iop_intent = xfs_attrd_item_intent, |
fd920008 AH |
876 | }; |
877 | ||
878 | const struct xlog_recover_item_ops xlog_attrd_item_ops = { | |
879 | .item_type = XFS_LI_ATTRD, | |
880 | .commit_pass2 = xlog_recover_attrd_commit_pass2, | |
881 | }; |