1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Copyright (c) 2000-2002,2005 Silicon Graphics, 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_inode_item.h" |
16 | #include "xfs_trace.h" |
17 | #include "xfs_trans_priv.h" |
18 | #include "xfs_buf_item.h" |
19 | #include "xfs_log.h" |
20 | #include "xfs_log_priv.h" |
21 | #include "xfs_error.h" |
22 | #include "xfs_rtbitmap.h" |
23 | |
24 | #include <linux/iversion.h> |
25 | |
26 | struct kmem_cache *xfs_ili_cache; /* inode log item */ |
27 | |
28 | static inline struct xfs_inode_log_item *INODE_ITEM(struct xfs_log_item *lip) |
29 | { |
30 | return container_of(lip, struct xfs_inode_log_item, ili_item); |
31 | } |
32 | |
33 | static uint64_t |
34 | xfs_inode_item_sort( |
35 | struct xfs_log_item *lip) |
36 | { |
37 | return INODE_ITEM(lip)->ili_inode->i_ino; |
38 | } |
39 | |
40 | /* |
41 | * Prior to finally logging the inode, we have to ensure that all the |
42 | * per-modification inode state changes are applied. This includes VFS inode |
43 | * state updates, format conversions, verifier state synchronisation and |
44 | * ensuring the inode buffer remains in memory whilst the inode is dirty. |
45 | * |
46 | * We have to be careful when we grab the inode cluster buffer due to lock |
47 | * ordering constraints. The unlinked inode modifications (xfs_iunlink_item) |
48 | * require AGI -> inode cluster buffer lock order. The inode cluster buffer is |
49 | * not locked until ->precommit, so it happens after everything else has been |
50 | * modified. |
51 | * |
52 | * Further, we have AGI -> AGF lock ordering, and with O_TMPFILE handling we |
53 | * have AGI -> AGF -> iunlink item -> inode cluster buffer lock order. Hence we |
54 | * cannot safely lock the inode cluster buffer in xfs_trans_log_inode() because |
55 | * it can be called on a inode (e.g. via bumplink/droplink) before we take the |
56 | * AGF lock modifying directory blocks. |
57 | * |
58 | * Rather than force a complete rework of all the transactions to call |
59 | * xfs_trans_log_inode() once and once only at the end of every transaction, we |
60 | * move the pinning of the inode cluster buffer to a ->precommit operation. This |
61 | * matches how the xfs_iunlink_item locks the inode cluster buffer, and it |
62 | * ensures that the inode cluster buffer locking is always done last in a |
63 | * transaction. i.e. we ensure the lock order is always AGI -> AGF -> inode |
64 | * cluster buffer. |
65 | * |
66 | * If we return the inode number as the precommit sort key then we'll also |
67 | * guarantee that the order all inode cluster buffer locking is the same all the |
68 | * inodes and unlink items in the transaction. |
69 | */ |
70 | static int |
71 | xfs_inode_item_precommit( |
72 | struct xfs_trans *tp, |
73 | struct xfs_log_item *lip) |
74 | { |
75 | struct xfs_inode_log_item *iip = INODE_ITEM(lip); |
76 | struct xfs_inode *ip = iip->ili_inode; |
77 | struct inode *inode = VFS_I(ip); |
78 | unsigned int flags = iip->ili_dirty_flags; |
79 | |
80 | /* |
81 | * Don't bother with i_lock for the I_DIRTY_TIME check here, as races |
82 | * don't matter - we either will need an extra transaction in 24 hours |
83 | * to log the timestamps, or will clear already cleared fields in the |
84 | * worst case. |
85 | */ |
86 | if (inode->i_state & I_DIRTY_TIME) { |
87 | spin_lock(lock: &inode->i_lock); |
88 | inode->i_state &= ~I_DIRTY_TIME; |
89 | spin_unlock(lock: &inode->i_lock); |
90 | } |
91 | |
92 | /* |
93 | * If we're updating the inode core or the timestamps and it's possible |
94 | * to upgrade this inode to bigtime format, do so now. |
95 | */ |
96 | if ((flags & (XFS_ILOG_CORE | XFS_ILOG_TIMESTAMP)) && |
97 | xfs_has_bigtime(ip->i_mount) && |
98 | !xfs_inode_has_bigtime(ip)) { |
99 | ip->i_diflags2 |= XFS_DIFLAG2_BIGTIME; |
100 | flags |= XFS_ILOG_CORE; |
101 | } |
102 | |
103 | /* |
104 | * Inode verifiers do not check that the extent size hint is an integer |
105 | * multiple of the rt extent size on a directory with both rtinherit |
106 | * and extszinherit flags set. If we're logging a directory that is |
107 | * misconfigured in this way, clear the hint. |
108 | */ |
109 | if ((ip->i_diflags & XFS_DIFLAG_RTINHERIT) && |
110 | (ip->i_diflags & XFS_DIFLAG_EXTSZINHERIT) && |
111 | xfs_extlen_to_rtxmod(ip->i_mount, ip->i_extsize) > 0) { |
112 | ip->i_diflags &= ~(XFS_DIFLAG_EXTSIZE | |
113 | XFS_DIFLAG_EXTSZINHERIT); |
114 | ip->i_extsize = 0; |
115 | flags |= XFS_ILOG_CORE; |
116 | } |
117 | |
118 | /* |
119 | * Record the specific change for fdatasync optimisation. This allows |
120 | * fdatasync to skip log forces for inodes that are only timestamp |
121 | * dirty. Once we've processed the XFS_ILOG_IVERSION flag, convert it |
122 | * to XFS_ILOG_CORE so that the actual on-disk dirty tracking |
123 | * (ili_fields) correctly tracks that the version has changed. |
124 | */ |
125 | spin_lock(lock: &iip->ili_lock); |
126 | iip->ili_fsync_fields |= (flags & ~XFS_ILOG_IVERSION); |
127 | if (flags & XFS_ILOG_IVERSION) |
128 | flags = ((flags & ~XFS_ILOG_IVERSION) | XFS_ILOG_CORE); |
129 | |
130 | if (!iip->ili_item.li_buf) { |
131 | struct xfs_buf *bp; |
132 | int error; |
133 | |
134 | /* |
135 | * We hold the ILOCK here, so this inode is not going to be |
136 | * flushed while we are here. Further, because there is no |
137 | * buffer attached to the item, we know that there is no IO in |
138 | * progress, so nothing will clear the ili_fields while we read |
139 | * in the buffer. Hence we can safely drop the spin lock and |
140 | * read the buffer knowing that the state will not change from |
141 | * here. |
142 | */ |
143 | spin_unlock(lock: &iip->ili_lock); |
144 | error = xfs_imap_to_bp(ip->i_mount, tp, &ip->i_imap, &bp); |
145 | if (error) |
146 | return error; |
147 | |
148 | /* |
149 | * We need an explicit buffer reference for the log item but |
150 | * don't want the buffer to remain attached to the transaction. |
151 | * Hold the buffer but release the transaction reference once |
152 | * we've attached the inode log item to the buffer log item |
153 | * list. |
154 | */ |
155 | xfs_buf_hold(bp); |
156 | spin_lock(lock: &iip->ili_lock); |
157 | iip->ili_item.li_buf = bp; |
158 | bp->b_flags |= _XBF_INODES; |
159 | list_add_tail(new: &iip->ili_item.li_bio_list, head: &bp->b_li_list); |
160 | xfs_trans_brelse(tp, bp); |
161 | } |
162 | |
163 | /* |
164 | * Always OR in the bits from the ili_last_fields field. This is to |
165 | * coordinate with the xfs_iflush() and xfs_buf_inode_iodone() routines |
166 | * in the eventual clearing of the ili_fields bits. See the big comment |
167 | * in xfs_iflush() for an explanation of this coordination mechanism. |
168 | */ |
169 | iip->ili_fields |= (flags | iip->ili_last_fields); |
170 | spin_unlock(lock: &iip->ili_lock); |
171 | |
172 | /* |
173 | * We are done with the log item transaction dirty state, so clear it so |
174 | * that it doesn't pollute future transactions. |
175 | */ |
176 | iip->ili_dirty_flags = 0; |
177 | return 0; |
178 | } |
179 | |
180 | /* |
181 | * The logged size of an inode fork is always the current size of the inode |
182 | * fork. This means that when an inode fork is relogged, the size of the logged |
183 | * region is determined by the current state, not the combination of the |
184 | * previously logged state + the current state. This is different relogging |
185 | * behaviour to most other log items which will retain the size of the |
186 | * previously logged changes when smaller regions are relogged. |
187 | * |
188 | * Hence operations that remove data from the inode fork (e.g. shortform |
189 | * dir/attr remove, extent form extent removal, etc), the size of the relogged |
190 | * inode gets -smaller- rather than stays the same size as the previously logged |
191 | * size and this can result in the committing transaction reducing the amount of |
192 | * space being consumed by the CIL. |
193 | */ |
194 | STATIC void |
195 | xfs_inode_item_data_fork_size( |
196 | struct xfs_inode_log_item *iip, |
197 | int *nvecs, |
198 | int *nbytes) |
199 | { |
200 | struct xfs_inode *ip = iip->ili_inode; |
201 | |
202 | switch (ip->i_df.if_format) { |
203 | case XFS_DINODE_FMT_EXTENTS: |
204 | if ((iip->ili_fields & XFS_ILOG_DEXT) && |
205 | ip->i_df.if_nextents > 0 && |
206 | ip->i_df.if_bytes > 0) { |
207 | /* worst case, doesn't subtract delalloc extents */ |
208 | *nbytes += xfs_inode_data_fork_size(ip); |
209 | *nvecs += 1; |
210 | } |
211 | break; |
212 | case XFS_DINODE_FMT_BTREE: |
213 | if ((iip->ili_fields & XFS_ILOG_DBROOT) && |
214 | ip->i_df.if_broot_bytes > 0) { |
215 | *nbytes += ip->i_df.if_broot_bytes; |
216 | *nvecs += 1; |
217 | } |
218 | break; |
219 | case XFS_DINODE_FMT_LOCAL: |
220 | if ((iip->ili_fields & XFS_ILOG_DDATA) && |
221 | ip->i_df.if_bytes > 0) { |
222 | *nbytes += xlog_calc_iovec_len(len: ip->i_df.if_bytes); |
223 | *nvecs += 1; |
224 | } |
225 | break; |
226 | |
227 | case XFS_DINODE_FMT_DEV: |
228 | break; |
229 | default: |
230 | ASSERT(0); |
231 | break; |
232 | } |
233 | } |
234 | |
235 | STATIC void |
236 | xfs_inode_item_attr_fork_size( |
237 | struct xfs_inode_log_item *iip, |
238 | int *nvecs, |
239 | int *nbytes) |
240 | { |
241 | struct xfs_inode *ip = iip->ili_inode; |
242 | |
243 | switch (ip->i_af.if_format) { |
244 | case XFS_DINODE_FMT_EXTENTS: |
245 | if ((iip->ili_fields & XFS_ILOG_AEXT) && |
246 | ip->i_af.if_nextents > 0 && |
247 | ip->i_af.if_bytes > 0) { |
248 | /* worst case, doesn't subtract unused space */ |
249 | *nbytes += xfs_inode_attr_fork_size(ip); |
250 | *nvecs += 1; |
251 | } |
252 | break; |
253 | case XFS_DINODE_FMT_BTREE: |
254 | if ((iip->ili_fields & XFS_ILOG_ABROOT) && |
255 | ip->i_af.if_broot_bytes > 0) { |
256 | *nbytes += ip->i_af.if_broot_bytes; |
257 | *nvecs += 1; |
258 | } |
259 | break; |
260 | case XFS_DINODE_FMT_LOCAL: |
261 | if ((iip->ili_fields & XFS_ILOG_ADATA) && |
262 | ip->i_af.if_bytes > 0) { |
263 | *nbytes += xlog_calc_iovec_len(len: ip->i_af.if_bytes); |
264 | *nvecs += 1; |
265 | } |
266 | break; |
267 | default: |
268 | ASSERT(0); |
269 | break; |
270 | } |
271 | } |
272 | |
273 | /* |
274 | * This returns the number of iovecs needed to log the given inode item. |
275 | * |
276 | * We need one iovec for the inode log format structure, one for the |
277 | * inode core, and possibly one for the inode data/extents/b-tree root |
278 | * and one for the inode attribute data/extents/b-tree root. |
279 | */ |
280 | STATIC void |
281 | xfs_inode_item_size( |
282 | struct xfs_log_item *lip, |
283 | int *nvecs, |
284 | int *nbytes) |
285 | { |
286 | struct xfs_inode_log_item *iip = INODE_ITEM(lip); |
287 | struct xfs_inode *ip = iip->ili_inode; |
288 | |
289 | *nvecs += 2; |
290 | *nbytes += sizeof(struct xfs_inode_log_format) + |
291 | xfs_log_dinode_size(ip->i_mount); |
292 | |
293 | xfs_inode_item_data_fork_size(iip, nvecs, nbytes); |
294 | if (xfs_inode_has_attr_fork(ip)) |
295 | xfs_inode_item_attr_fork_size(iip, nvecs, nbytes); |
296 | } |
297 | |
298 | STATIC void |
299 | xfs_inode_item_format_data_fork( |
300 | struct xfs_inode_log_item *iip, |
301 | struct xfs_inode_log_format *ilf, |
302 | struct xfs_log_vec *lv, |
303 | struct xfs_log_iovec **vecp) |
304 | { |
305 | struct xfs_inode *ip = iip->ili_inode; |
306 | size_t data_bytes; |
307 | |
308 | switch (ip->i_df.if_format) { |
309 | case XFS_DINODE_FMT_EXTENTS: |
310 | iip->ili_fields &= |
311 | ~(XFS_ILOG_DDATA | XFS_ILOG_DBROOT | XFS_ILOG_DEV); |
312 | |
313 | if ((iip->ili_fields & XFS_ILOG_DEXT) && |
314 | ip->i_df.if_nextents > 0 && |
315 | ip->i_df.if_bytes > 0) { |
316 | struct xfs_bmbt_rec *p; |
317 | |
318 | ASSERT(xfs_iext_count(&ip->i_df) > 0); |
319 | |
320 | p = xlog_prepare_iovec(lv, vecp, XLOG_REG_TYPE_IEXT); |
321 | data_bytes = xfs_iextents_copy(ip, p, XFS_DATA_FORK); |
322 | xlog_finish_iovec(lv, vec: *vecp, data_len: data_bytes); |
323 | |
324 | ASSERT(data_bytes <= ip->i_df.if_bytes); |
325 | |
326 | ilf->ilf_dsize = data_bytes; |
327 | ilf->ilf_size++; |
328 | } else { |
329 | iip->ili_fields &= ~XFS_ILOG_DEXT; |
330 | } |
331 | break; |
332 | case XFS_DINODE_FMT_BTREE: |
333 | iip->ili_fields &= |
334 | ~(XFS_ILOG_DDATA | XFS_ILOG_DEXT | XFS_ILOG_DEV); |
335 | |
336 | if ((iip->ili_fields & XFS_ILOG_DBROOT) && |
337 | ip->i_df.if_broot_bytes > 0) { |
338 | ASSERT(ip->i_df.if_broot != NULL); |
339 | xlog_copy_iovec(lv, vecp, XLOG_REG_TYPE_IBROOT, |
340 | ip->i_df.if_broot, |
341 | ip->i_df.if_broot_bytes); |
342 | ilf->ilf_dsize = ip->i_df.if_broot_bytes; |
343 | ilf->ilf_size++; |
344 | } else { |
345 | ASSERT(!(iip->ili_fields & |
346 | XFS_ILOG_DBROOT)); |
347 | iip->ili_fields &= ~XFS_ILOG_DBROOT; |
348 | } |
349 | break; |
350 | case XFS_DINODE_FMT_LOCAL: |
351 | iip->ili_fields &= |
352 | ~(XFS_ILOG_DEXT | XFS_ILOG_DBROOT | XFS_ILOG_DEV); |
353 | if ((iip->ili_fields & XFS_ILOG_DDATA) && |
354 | ip->i_df.if_bytes > 0) { |
355 | ASSERT(ip->i_df.if_data != NULL); |
356 | ASSERT(ip->i_disk_size > 0); |
357 | xlog_copy_iovec(lv, vecp, XLOG_REG_TYPE_ILOCAL, |
358 | ip->i_df.if_data, ip->i_df.if_bytes); |
359 | ilf->ilf_dsize = (unsigned)ip->i_df.if_bytes; |
360 | ilf->ilf_size++; |
361 | } else { |
362 | iip->ili_fields &= ~XFS_ILOG_DDATA; |
363 | } |
364 | break; |
365 | case XFS_DINODE_FMT_DEV: |
366 | iip->ili_fields &= |
367 | ~(XFS_ILOG_DDATA | XFS_ILOG_DBROOT | XFS_ILOG_DEXT); |
368 | if (iip->ili_fields & XFS_ILOG_DEV) |
369 | ilf->ilf_u.ilfu_rdev = sysv_encode_dev(dev: VFS_I(ip)->i_rdev); |
370 | break; |
371 | default: |
372 | ASSERT(0); |
373 | break; |
374 | } |
375 | } |
376 | |
377 | STATIC void |
378 | xfs_inode_item_format_attr_fork( |
379 | struct xfs_inode_log_item *iip, |
380 | struct xfs_inode_log_format *ilf, |
381 | struct xfs_log_vec *lv, |
382 | struct xfs_log_iovec **vecp) |
383 | { |
384 | struct xfs_inode *ip = iip->ili_inode; |
385 | size_t data_bytes; |
386 | |
387 | switch (ip->i_af.if_format) { |
388 | case XFS_DINODE_FMT_EXTENTS: |
389 | iip->ili_fields &= |
390 | ~(XFS_ILOG_ADATA | XFS_ILOG_ABROOT); |
391 | |
392 | if ((iip->ili_fields & XFS_ILOG_AEXT) && |
393 | ip->i_af.if_nextents > 0 && |
394 | ip->i_af.if_bytes > 0) { |
395 | struct xfs_bmbt_rec *p; |
396 | |
397 | ASSERT(xfs_iext_count(&ip->i_af) == |
398 | ip->i_af.if_nextents); |
399 | |
400 | p = xlog_prepare_iovec(lv, vecp, XLOG_REG_TYPE_IATTR_EXT); |
401 | data_bytes = xfs_iextents_copy(ip, p, XFS_ATTR_FORK); |
402 | xlog_finish_iovec(lv, vec: *vecp, data_len: data_bytes); |
403 | |
404 | ilf->ilf_asize = data_bytes; |
405 | ilf->ilf_size++; |
406 | } else { |
407 | iip->ili_fields &= ~XFS_ILOG_AEXT; |
408 | } |
409 | break; |
410 | case XFS_DINODE_FMT_BTREE: |
411 | iip->ili_fields &= |
412 | ~(XFS_ILOG_ADATA | XFS_ILOG_AEXT); |
413 | |
414 | if ((iip->ili_fields & XFS_ILOG_ABROOT) && |
415 | ip->i_af.if_broot_bytes > 0) { |
416 | ASSERT(ip->i_af.if_broot != NULL); |
417 | |
418 | xlog_copy_iovec(lv, vecp, XLOG_REG_TYPE_IATTR_BROOT, |
419 | ip->i_af.if_broot, |
420 | ip->i_af.if_broot_bytes); |
421 | ilf->ilf_asize = ip->i_af.if_broot_bytes; |
422 | ilf->ilf_size++; |
423 | } else { |
424 | iip->ili_fields &= ~XFS_ILOG_ABROOT; |
425 | } |
426 | break; |
427 | case XFS_DINODE_FMT_LOCAL: |
428 | iip->ili_fields &= |
429 | ~(XFS_ILOG_AEXT | XFS_ILOG_ABROOT); |
430 | |
431 | if ((iip->ili_fields & XFS_ILOG_ADATA) && |
432 | ip->i_af.if_bytes > 0) { |
433 | ASSERT(ip->i_af.if_data != NULL); |
434 | xlog_copy_iovec(lv, vecp, XLOG_REG_TYPE_IATTR_LOCAL, |
435 | ip->i_af.if_data, ip->i_af.if_bytes); |
436 | ilf->ilf_asize = (unsigned)ip->i_af.if_bytes; |
437 | ilf->ilf_size++; |
438 | } else { |
439 | iip->ili_fields &= ~XFS_ILOG_ADATA; |
440 | } |
441 | break; |
442 | default: |
443 | ASSERT(0); |
444 | break; |
445 | } |
446 | } |
447 | |
448 | /* |
449 | * Convert an incore timestamp to a log timestamp. Note that the log format |
450 | * specifies host endian format! |
451 | */ |
452 | static inline xfs_log_timestamp_t |
453 | xfs_inode_to_log_dinode_ts( |
454 | struct xfs_inode *ip, |
455 | const struct timespec64 tv) |
456 | { |
457 | struct xfs_log_legacy_timestamp *lits; |
458 | xfs_log_timestamp_t its; |
459 | |
460 | if (xfs_inode_has_bigtime(ip)) |
461 | return xfs_inode_encode_bigtime(tv); |
462 | |
463 | lits = (struct xfs_log_legacy_timestamp *)&its; |
464 | lits->t_sec = tv.tv_sec; |
465 | lits->t_nsec = tv.tv_nsec; |
466 | |
467 | return its; |
468 | } |
469 | |
470 | /* |
471 | * The legacy DMAPI fields are only present in the on-disk and in-log inodes, |
472 | * but not in the in-memory one. But we are guaranteed to have an inode buffer |
473 | * in memory when logging an inode, so we can just copy it from the on-disk |
474 | * inode to the in-log inode here so that recovery of file system with these |
475 | * fields set to non-zero values doesn't lose them. For all other cases we zero |
476 | * the fields. |
477 | */ |
478 | static void |
479 | xfs_copy_dm_fields_to_log_dinode( |
480 | struct xfs_inode *ip, |
481 | struct xfs_log_dinode *to) |
482 | { |
483 | struct xfs_dinode *dip; |
484 | |
485 | dip = xfs_buf_offset(ip->i_itemp->ili_item.li_buf, |
486 | ip->i_imap.im_boffset); |
487 | |
488 | if (xfs_iflags_test(ip, XFS_IPRESERVE_DM_FIELDS)) { |
489 | to->di_dmevmask = be32_to_cpu(dip->di_dmevmask); |
490 | to->di_dmstate = be16_to_cpu(dip->di_dmstate); |
491 | } else { |
492 | to->di_dmevmask = 0; |
493 | to->di_dmstate = 0; |
494 | } |
495 | } |
496 | |
497 | static inline void |
498 | xfs_inode_to_log_dinode_iext_counters( |
499 | struct xfs_inode *ip, |
500 | struct xfs_log_dinode *to) |
501 | { |
502 | if (xfs_inode_has_large_extent_counts(ip)) { |
503 | to->di_big_nextents = xfs_ifork_nextents(&ip->i_df); |
504 | to->di_big_anextents = xfs_ifork_nextents(&ip->i_af); |
505 | to->di_nrext64_pad = 0; |
506 | } else { |
507 | to->di_nextents = xfs_ifork_nextents(&ip->i_df); |
508 | to->di_anextents = xfs_ifork_nextents(&ip->i_af); |
509 | } |
510 | } |
511 | |
512 | static void |
513 | xfs_inode_to_log_dinode( |
514 | struct xfs_inode *ip, |
515 | struct xfs_log_dinode *to, |
516 | xfs_lsn_t lsn) |
517 | { |
518 | struct inode *inode = VFS_I(ip); |
519 | |
520 | to->di_magic = XFS_DINODE_MAGIC; |
521 | to->di_format = xfs_ifork_format(&ip->i_df); |
522 | to->di_uid = i_uid_read(inode); |
523 | to->di_gid = i_gid_read(inode); |
524 | to->di_projid_lo = ip->i_projid & 0xffff; |
525 | to->di_projid_hi = ip->i_projid >> 16; |
526 | |
527 | memset(to->di_pad3, 0, sizeof(to->di_pad3)); |
528 | to->di_atime = xfs_inode_to_log_dinode_ts(ip, inode_get_atime(inode)); |
529 | to->di_mtime = xfs_inode_to_log_dinode_ts(ip, inode_get_mtime(inode)); |
530 | to->di_ctime = xfs_inode_to_log_dinode_ts(ip, inode_get_ctime(inode)); |
531 | to->di_nlink = inode->i_nlink; |
532 | to->di_gen = inode->i_generation; |
533 | to->di_mode = inode->i_mode; |
534 | |
535 | to->di_size = ip->i_disk_size; |
536 | to->di_nblocks = ip->i_nblocks; |
537 | to->di_extsize = ip->i_extsize; |
538 | to->di_forkoff = ip->i_forkoff; |
539 | to->di_aformat = xfs_ifork_format(&ip->i_af); |
540 | to->di_flags = ip->i_diflags; |
541 | |
542 | xfs_copy_dm_fields_to_log_dinode(ip, to); |
543 | |
544 | /* log a dummy value to ensure log structure is fully initialised */ |
545 | to->di_next_unlinked = NULLAGINO; |
546 | |
547 | if (xfs_has_v3inodes(mp: ip->i_mount)) { |
548 | to->di_version = 3; |
549 | to->di_changecount = inode_peek_iversion(inode); |
550 | to->di_crtime = xfs_inode_to_log_dinode_ts(ip, ip->i_crtime); |
551 | to->di_flags2 = ip->i_diflags2; |
552 | to->di_cowextsize = ip->i_cowextsize; |
553 | to->di_ino = ip->i_ino; |
554 | to->di_lsn = lsn; |
555 | memset(to->di_pad2, 0, sizeof(to->di_pad2)); |
556 | uuid_copy(dst: &to->di_uuid, src: &ip->i_mount->m_sb.sb_meta_uuid); |
557 | to->di_v3_pad = 0; |
558 | |
559 | /* dummy value for initialisation */ |
560 | to->di_crc = 0; |
561 | } else { |
562 | to->di_version = 2; |
563 | to->di_flushiter = ip->i_flushiter; |
564 | memset(to->di_v2_pad, 0, sizeof(to->di_v2_pad)); |
565 | } |
566 | |
567 | xfs_inode_to_log_dinode_iext_counters(ip, to); |
568 | } |
569 | |
570 | /* |
571 | * Format the inode core. Current timestamp data is only in the VFS inode |
572 | * fields, so we need to grab them from there. Hence rather than just copying |
573 | * the XFS inode core structure, format the fields directly into the iovec. |
574 | */ |
575 | static void |
576 | xfs_inode_item_format_core( |
577 | struct xfs_inode *ip, |
578 | struct xfs_log_vec *lv, |
579 | struct xfs_log_iovec **vecp) |
580 | { |
581 | struct xfs_log_dinode *dic; |
582 | |
583 | dic = xlog_prepare_iovec(lv, vecp, XLOG_REG_TYPE_ICORE); |
584 | xfs_inode_to_log_dinode(ip, dic, ip->i_itemp->ili_item.li_lsn); |
585 | xlog_finish_iovec(lv, vec: *vecp, data_len: xfs_log_dinode_size(ip->i_mount)); |
586 | } |
587 | |
588 | /* |
589 | * This is called to fill in the vector of log iovecs for the given inode |
590 | * log item. It fills the first item with an inode log format structure, |
591 | * the second with the on-disk inode structure, and a possible third and/or |
592 | * fourth with the inode data/extents/b-tree root and inode attributes |
593 | * data/extents/b-tree root. |
594 | * |
595 | * Note: Always use the 64 bit inode log format structure so we don't |
596 | * leave an uninitialised hole in the format item on 64 bit systems. Log |
597 | * recovery on 32 bit systems handles this just fine, so there's no reason |
598 | * for not using an initialising the properly padded structure all the time. |
599 | */ |
600 | STATIC void |
601 | xfs_inode_item_format( |
602 | struct xfs_log_item *lip, |
603 | struct xfs_log_vec *lv) |
604 | { |
605 | struct xfs_inode_log_item *iip = INODE_ITEM(lip); |
606 | struct xfs_inode *ip = iip->ili_inode; |
607 | struct xfs_log_iovec *vecp = NULL; |
608 | struct xfs_inode_log_format *ilf; |
609 | |
610 | ilf = xlog_prepare_iovec(lv, &vecp, XLOG_REG_TYPE_IFORMAT); |
611 | ilf->ilf_type = XFS_LI_INODE; |
612 | ilf->ilf_ino = ip->i_ino; |
613 | ilf->ilf_blkno = ip->i_imap.im_blkno; |
614 | ilf->ilf_len = ip->i_imap.im_len; |
615 | ilf->ilf_boffset = ip->i_imap.im_boffset; |
616 | ilf->ilf_fields = XFS_ILOG_CORE; |
617 | ilf->ilf_size = 2; /* format + core */ |
618 | |
619 | /* |
620 | * make sure we don't leak uninitialised data into the log in the case |
621 | * when we don't log every field in the inode. |
622 | */ |
623 | ilf->ilf_dsize = 0; |
624 | ilf->ilf_asize = 0; |
625 | ilf->ilf_pad = 0; |
626 | memset(&ilf->ilf_u, 0, sizeof(ilf->ilf_u)); |
627 | |
628 | xlog_finish_iovec(lv, vecp, sizeof(*ilf)); |
629 | |
630 | xfs_inode_item_format_core(ip, lv, vecp: &vecp); |
631 | xfs_inode_item_format_data_fork(iip, ilf, lv, vecp: &vecp); |
632 | if (xfs_inode_has_attr_fork(ip)) { |
633 | xfs_inode_item_format_attr_fork(iip, ilf, lv, vecp: &vecp); |
634 | } else { |
635 | iip->ili_fields &= |
636 | ~(XFS_ILOG_ADATA | XFS_ILOG_ABROOT | XFS_ILOG_AEXT); |
637 | } |
638 | |
639 | /* update the format with the exact fields we actually logged */ |
640 | ilf->ilf_fields |= (iip->ili_fields & ~XFS_ILOG_TIMESTAMP); |
641 | } |
642 | |
643 | /* |
644 | * This is called to pin the inode associated with the inode log |
645 | * item in memory so it cannot be written out. |
646 | */ |
647 | STATIC void |
648 | xfs_inode_item_pin( |
649 | struct xfs_log_item *lip) |
650 | { |
651 | struct xfs_inode *ip = INODE_ITEM(lip)->ili_inode; |
652 | |
653 | xfs_assert_ilocked(ip, XFS_ILOCK_EXCL); |
654 | ASSERT(lip->li_buf); |
655 | |
656 | trace_xfs_inode_pin(ip, _RET_IP_); |
657 | atomic_inc(v: &ip->i_pincount); |
658 | } |
659 | |
660 | |
661 | /* |
662 | * This is called to unpin the inode associated with the inode log |
663 | * item which was previously pinned with a call to xfs_inode_item_pin(). |
664 | * |
665 | * Also wake up anyone in xfs_iunpin_wait() if the count goes to 0. |
666 | * |
667 | * Note that unpin can race with inode cluster buffer freeing marking the buffer |
668 | * stale. In that case, flush completions are run from the buffer unpin call, |
669 | * which may happen before the inode is unpinned. If we lose the race, there |
670 | * will be no buffer attached to the log item, but the inode will be marked |
671 | * XFS_ISTALE. |
672 | */ |
673 | STATIC void |
674 | xfs_inode_item_unpin( |
675 | struct xfs_log_item *lip, |
676 | int remove) |
677 | { |
678 | struct xfs_inode *ip = INODE_ITEM(lip)->ili_inode; |
679 | |
680 | trace_xfs_inode_unpin(ip, _RET_IP_); |
681 | ASSERT(lip->li_buf || xfs_iflags_test(ip, XFS_ISTALE)); |
682 | ASSERT(atomic_read(&ip->i_pincount) > 0); |
683 | if (atomic_dec_and_test(v: &ip->i_pincount)) |
684 | wake_up_bit(word: &ip->i_flags, __XFS_IPINNED_BIT); |
685 | } |
686 | |
687 | STATIC uint |
688 | xfs_inode_item_push( |
689 | struct xfs_log_item *lip, |
690 | struct list_head *buffer_list) |
691 | __releases(&lip->li_ailp->ail_lock) |
692 | __acquires(&lip->li_ailp->ail_lock) |
693 | { |
694 | struct xfs_inode_log_item *iip = INODE_ITEM(lip); |
695 | struct xfs_inode *ip = iip->ili_inode; |
696 | struct xfs_buf *bp = lip->li_buf; |
697 | uint rval = XFS_ITEM_SUCCESS; |
698 | int error; |
699 | |
700 | if (!bp || (ip->i_flags & XFS_ISTALE)) { |
701 | /* |
702 | * Inode item/buffer is being aborted due to cluster |
703 | * buffer deletion. Trigger a log force to have that operation |
704 | * completed and items removed from the AIL before the next push |
705 | * attempt. |
706 | */ |
707 | return XFS_ITEM_PINNED; |
708 | } |
709 | |
710 | if (xfs_ipincount(ip) > 0 || xfs_buf_ispinned(bp)) |
711 | return XFS_ITEM_PINNED; |
712 | |
713 | if (xfs_iflags_test(ip, XFS_IFLUSHING)) |
714 | return XFS_ITEM_FLUSHING; |
715 | |
716 | if (!xfs_buf_trylock(bp)) |
717 | return XFS_ITEM_LOCKED; |
718 | |
719 | spin_unlock(lock: &lip->li_ailp->ail_lock); |
720 | |
721 | /* |
722 | * We need to hold a reference for flushing the cluster buffer as it may |
723 | * fail the buffer without IO submission. In which case, we better get a |
724 | * reference for that completion because otherwise we don't get a |
725 | * reference for IO until we queue the buffer for delwri submission. |
726 | */ |
727 | xfs_buf_hold(bp); |
728 | error = xfs_iflush_cluster(bp); |
729 | if (!error) { |
730 | if (!xfs_buf_delwri_queue(bp, buffer_list)) |
731 | rval = XFS_ITEM_FLUSHING; |
732 | xfs_buf_relse(bp); |
733 | } else { |
734 | /* |
735 | * Release the buffer if we were unable to flush anything. On |
736 | * any other error, the buffer has already been released. |
737 | */ |
738 | if (error == -EAGAIN) |
739 | xfs_buf_relse(bp); |
740 | rval = XFS_ITEM_LOCKED; |
741 | } |
742 | |
743 | spin_lock(lock: &lip->li_ailp->ail_lock); |
744 | return rval; |
745 | } |
746 | |
747 | /* |
748 | * Unlock the inode associated with the inode log item. |
749 | */ |
750 | STATIC void |
751 | xfs_inode_item_release( |
752 | struct xfs_log_item *lip) |
753 | { |
754 | struct xfs_inode_log_item *iip = INODE_ITEM(lip); |
755 | struct xfs_inode *ip = iip->ili_inode; |
756 | unsigned short lock_flags; |
757 | |
758 | ASSERT(ip->i_itemp != NULL); |
759 | xfs_assert_ilocked(ip, XFS_ILOCK_EXCL); |
760 | |
761 | lock_flags = iip->ili_lock_flags; |
762 | iip->ili_lock_flags = 0; |
763 | if (lock_flags) |
764 | xfs_iunlock(ip, lock_flags); |
765 | } |
766 | |
767 | /* |
768 | * This is called to find out where the oldest active copy of the inode log |
769 | * item in the on disk log resides now that the last log write of it completed |
770 | * at the given lsn. Since we always re-log all dirty data in an inode, the |
771 | * latest copy in the on disk log is the only one that matters. Therefore, |
772 | * simply return the given lsn. |
773 | * |
774 | * If the inode has been marked stale because the cluster is being freed, we |
775 | * don't want to (re-)insert this inode into the AIL. There is a race condition |
776 | * where the cluster buffer may be unpinned before the inode is inserted into |
777 | * the AIL during transaction committed processing. If the buffer is unpinned |
778 | * before the inode item has been committed and inserted, then it is possible |
779 | * for the buffer to be written and IO completes before the inode is inserted |
780 | * into the AIL. In that case, we'd be inserting a clean, stale inode into the |
781 | * AIL which will never get removed. It will, however, get reclaimed which |
782 | * triggers an assert in xfs_inode_free() complaining about freein an inode |
783 | * still in the AIL. |
784 | * |
785 | * To avoid this, just unpin the inode directly and return a LSN of -1 so the |
786 | * transaction committed code knows that it does not need to do any further |
787 | * processing on the item. |
788 | */ |
789 | STATIC xfs_lsn_t |
790 | xfs_inode_item_committed( |
791 | struct xfs_log_item *lip, |
792 | xfs_lsn_t lsn) |
793 | { |
794 | struct xfs_inode_log_item *iip = INODE_ITEM(lip); |
795 | struct xfs_inode *ip = iip->ili_inode; |
796 | |
797 | if (xfs_iflags_test(ip, XFS_ISTALE)) { |
798 | xfs_inode_item_unpin(lip, remove: 0); |
799 | return -1; |
800 | } |
801 | return lsn; |
802 | } |
803 | |
804 | STATIC void |
805 | xfs_inode_item_committing( |
806 | struct xfs_log_item *lip, |
807 | xfs_csn_t seq) |
808 | { |
809 | INODE_ITEM(lip)->ili_commit_seq = seq; |
810 | return xfs_inode_item_release(lip); |
811 | } |
812 | |
813 | static const struct xfs_item_ops xfs_inode_item_ops = { |
814 | .iop_sort = xfs_inode_item_sort, |
815 | .iop_precommit = xfs_inode_item_precommit, |
816 | .iop_size = xfs_inode_item_size, |
817 | .iop_format = xfs_inode_item_format, |
818 | .iop_pin = xfs_inode_item_pin, |
819 | .iop_unpin = xfs_inode_item_unpin, |
820 | .iop_release = xfs_inode_item_release, |
821 | .iop_committed = xfs_inode_item_committed, |
822 | .iop_push = xfs_inode_item_push, |
823 | .iop_committing = xfs_inode_item_committing, |
824 | }; |
825 | |
826 | |
827 | /* |
828 | * Initialize the inode log item for a newly allocated (in-core) inode. |
829 | */ |
830 | void |
831 | xfs_inode_item_init( |
832 | struct xfs_inode *ip, |
833 | struct xfs_mount *mp) |
834 | { |
835 | struct xfs_inode_log_item *iip; |
836 | |
837 | ASSERT(ip->i_itemp == NULL); |
838 | iip = ip->i_itemp = kmem_cache_zalloc(k: xfs_ili_cache, |
839 | GFP_KERNEL | __GFP_NOFAIL); |
840 | |
841 | iip->ili_inode = ip; |
842 | spin_lock_init(&iip->ili_lock); |
843 | xfs_log_item_init(mp, &iip->ili_item, XFS_LI_INODE, |
844 | &xfs_inode_item_ops); |
845 | } |
846 | |
847 | /* |
848 | * Free the inode log item and any memory hanging off of it. |
849 | */ |
850 | void |
851 | xfs_inode_item_destroy( |
852 | struct xfs_inode *ip) |
853 | { |
854 | struct xfs_inode_log_item *iip = ip->i_itemp; |
855 | |
856 | ASSERT(iip->ili_item.li_buf == NULL); |
857 | |
858 | ip->i_itemp = NULL; |
859 | kvfree(addr: iip->ili_item.li_lv_shadow); |
860 | kmem_cache_free(s: xfs_ili_cache, objp: iip); |
861 | } |
862 | |
863 | |
864 | /* |
865 | * We only want to pull the item from the AIL if it is actually there |
866 | * and its location in the log has not changed since we started the |
867 | * flush. Thus, we only bother if the inode's lsn has not changed. |
868 | */ |
869 | static void |
870 | xfs_iflush_ail_updates( |
871 | struct xfs_ail *ailp, |
872 | struct list_head *list) |
873 | { |
874 | struct xfs_log_item *lip; |
875 | xfs_lsn_t tail_lsn = 0; |
876 | |
877 | /* this is an opencoded batch version of xfs_trans_ail_delete */ |
878 | spin_lock(lock: &ailp->ail_lock); |
879 | list_for_each_entry(lip, list, li_bio_list) { |
880 | xfs_lsn_t lsn; |
881 | |
882 | clear_bit(XFS_LI_FAILED, addr: &lip->li_flags); |
883 | if (INODE_ITEM(lip)->ili_flush_lsn != lip->li_lsn) |
884 | continue; |
885 | |
886 | /* |
887 | * dgc: Not sure how this happens, but it happens very |
888 | * occassionaly via generic/388. xfs_iflush_abort() also |
889 | * silently handles this same "under writeback but not in AIL at |
890 | * shutdown" condition via xfs_trans_ail_delete(). |
891 | */ |
892 | if (!test_bit(XFS_LI_IN_AIL, &lip->li_flags)) { |
893 | ASSERT(xlog_is_shutdown(lip->li_log)); |
894 | continue; |
895 | } |
896 | |
897 | lsn = xfs_ail_delete_one(ailp, lip); |
898 | if (!tail_lsn && lsn) |
899 | tail_lsn = lsn; |
900 | } |
901 | xfs_ail_update_finish(ailp, tail_lsn); |
902 | } |
903 | |
904 | /* |
905 | * Walk the list of inodes that have completed their IOs. If they are clean |
906 | * remove them from the list and dissociate them from the buffer. Buffers that |
907 | * are still dirty remain linked to the buffer and on the list. Caller must |
908 | * handle them appropriately. |
909 | */ |
910 | static void |
911 | xfs_iflush_finish( |
912 | struct xfs_buf *bp, |
913 | struct list_head *list) |
914 | { |
915 | struct xfs_log_item *lip, *n; |
916 | |
917 | list_for_each_entry_safe(lip, n, list, li_bio_list) { |
918 | struct xfs_inode_log_item *iip = INODE_ITEM(lip); |
919 | bool drop_buffer = false; |
920 | |
921 | spin_lock(lock: &iip->ili_lock); |
922 | |
923 | /* |
924 | * Remove the reference to the cluster buffer if the inode is |
925 | * clean in memory and drop the buffer reference once we've |
926 | * dropped the locks we hold. |
927 | */ |
928 | ASSERT(iip->ili_item.li_buf == bp); |
929 | if (!iip->ili_fields) { |
930 | iip->ili_item.li_buf = NULL; |
931 | list_del_init(entry: &lip->li_bio_list); |
932 | drop_buffer = true; |
933 | } |
934 | iip->ili_last_fields = 0; |
935 | iip->ili_flush_lsn = 0; |
936 | spin_unlock(lock: &iip->ili_lock); |
937 | xfs_iflags_clear(ip: iip->ili_inode, XFS_IFLUSHING); |
938 | if (drop_buffer) |
939 | xfs_buf_rele(bp); |
940 | } |
941 | } |
942 | |
943 | /* |
944 | * Inode buffer IO completion routine. It is responsible for removing inodes |
945 | * attached to the buffer from the AIL if they have not been re-logged and |
946 | * completing the inode flush. |
947 | */ |
948 | void |
949 | xfs_buf_inode_iodone( |
950 | struct xfs_buf *bp) |
951 | { |
952 | struct xfs_log_item *lip, *n; |
953 | LIST_HEAD(flushed_inodes); |
954 | LIST_HEAD(ail_updates); |
955 | |
956 | /* |
957 | * Pull the attached inodes from the buffer one at a time and take the |
958 | * appropriate action on them. |
959 | */ |
960 | list_for_each_entry_safe(lip, n, &bp->b_li_list, li_bio_list) { |
961 | struct xfs_inode_log_item *iip = INODE_ITEM(lip); |
962 | |
963 | if (xfs_iflags_test(ip: iip->ili_inode, XFS_ISTALE)) { |
964 | xfs_iflush_abort(iip->ili_inode); |
965 | continue; |
966 | } |
967 | if (!iip->ili_last_fields) |
968 | continue; |
969 | |
970 | /* Do an unlocked check for needing the AIL lock. */ |
971 | if (iip->ili_flush_lsn == lip->li_lsn || |
972 | test_bit(XFS_LI_FAILED, &lip->li_flags)) |
973 | list_move_tail(list: &lip->li_bio_list, head: &ail_updates); |
974 | else |
975 | list_move_tail(list: &lip->li_bio_list, head: &flushed_inodes); |
976 | } |
977 | |
978 | if (!list_empty(head: &ail_updates)) { |
979 | xfs_iflush_ail_updates(ailp: bp->b_mount->m_ail, list: &ail_updates); |
980 | list_splice_tail(list: &ail_updates, head: &flushed_inodes); |
981 | } |
982 | |
983 | xfs_iflush_finish(bp, list: &flushed_inodes); |
984 | if (!list_empty(head: &flushed_inodes)) |
985 | list_splice_tail(list: &flushed_inodes, head: &bp->b_li_list); |
986 | } |
987 | |
988 | void |
989 | xfs_buf_inode_io_fail( |
990 | struct xfs_buf *bp) |
991 | { |
992 | struct xfs_log_item *lip; |
993 | |
994 | list_for_each_entry(lip, &bp->b_li_list, li_bio_list) |
995 | set_bit(XFS_LI_FAILED, addr: &lip->li_flags); |
996 | } |
997 | |
998 | /* |
999 | * Clear the inode logging fields so no more flushes are attempted. If we are |
1000 | * on a buffer list, it is now safe to remove it because the buffer is |
1001 | * guaranteed to be locked. The caller will drop the reference to the buffer |
1002 | * the log item held. |
1003 | */ |
1004 | static void |
1005 | xfs_iflush_abort_clean( |
1006 | struct xfs_inode_log_item *iip) |
1007 | { |
1008 | iip->ili_last_fields = 0; |
1009 | iip->ili_fields = 0; |
1010 | iip->ili_fsync_fields = 0; |
1011 | iip->ili_flush_lsn = 0; |
1012 | iip->ili_item.li_buf = NULL; |
1013 | list_del_init(entry: &iip->ili_item.li_bio_list); |
1014 | } |
1015 | |
1016 | /* |
1017 | * Abort flushing the inode from a context holding the cluster buffer locked. |
1018 | * |
1019 | * This is the normal runtime method of aborting writeback of an inode that is |
1020 | * attached to a cluster buffer. It occurs when the inode and the backing |
1021 | * cluster buffer have been freed (i.e. inode is XFS_ISTALE), or when cluster |
1022 | * flushing or buffer IO completion encounters a log shutdown situation. |
1023 | * |
1024 | * If we need to abort inode writeback and we don't already hold the buffer |
1025 | * locked, call xfs_iflush_shutdown_abort() instead as this should only ever be |
1026 | * necessary in a shutdown situation. |
1027 | */ |
1028 | void |
1029 | xfs_iflush_abort( |
1030 | struct xfs_inode *ip) |
1031 | { |
1032 | struct xfs_inode_log_item *iip = ip->i_itemp; |
1033 | struct xfs_buf *bp; |
1034 | |
1035 | if (!iip) { |
1036 | /* clean inode, nothing to do */ |
1037 | xfs_iflags_clear(ip, XFS_IFLUSHING); |
1038 | return; |
1039 | } |
1040 | |
1041 | /* |
1042 | * Remove the inode item from the AIL before we clear its internal |
1043 | * state. Whilst the inode is in the AIL, it should have a valid buffer |
1044 | * pointer for push operations to access - it is only safe to remove the |
1045 | * inode from the buffer once it has been removed from the AIL. |
1046 | * |
1047 | * We also clear the failed bit before removing the item from the AIL |
1048 | * as xfs_trans_ail_delete()->xfs_clear_li_failed() will release buffer |
1049 | * references the inode item owns and needs to hold until we've fully |
1050 | * aborted the inode log item and detached it from the buffer. |
1051 | */ |
1052 | clear_bit(XFS_LI_FAILED, addr: &iip->ili_item.li_flags); |
1053 | xfs_trans_ail_delete(lip: &iip->ili_item, shutdown_type: 0); |
1054 | |
1055 | /* |
1056 | * Grab the inode buffer so can we release the reference the inode log |
1057 | * item holds on it. |
1058 | */ |
1059 | spin_lock(lock: &iip->ili_lock); |
1060 | bp = iip->ili_item.li_buf; |
1061 | xfs_iflush_abort_clean(iip); |
1062 | spin_unlock(lock: &iip->ili_lock); |
1063 | |
1064 | xfs_iflags_clear(ip, XFS_IFLUSHING); |
1065 | if (bp) |
1066 | xfs_buf_rele(bp); |
1067 | } |
1068 | |
1069 | /* |
1070 | * Abort an inode flush in the case of a shutdown filesystem. This can be called |
1071 | * from anywhere with just an inode reference and does not require holding the |
1072 | * inode cluster buffer locked. If the inode is attached to a cluster buffer, |
1073 | * it will grab and lock it safely, then abort the inode flush. |
1074 | */ |
1075 | void |
1076 | xfs_iflush_shutdown_abort( |
1077 | struct xfs_inode *ip) |
1078 | { |
1079 | struct xfs_inode_log_item *iip = ip->i_itemp; |
1080 | struct xfs_buf *bp; |
1081 | |
1082 | if (!iip) { |
1083 | /* clean inode, nothing to do */ |
1084 | xfs_iflags_clear(ip, XFS_IFLUSHING); |
1085 | return; |
1086 | } |
1087 | |
1088 | spin_lock(lock: &iip->ili_lock); |
1089 | bp = iip->ili_item.li_buf; |
1090 | if (!bp) { |
1091 | spin_unlock(lock: &iip->ili_lock); |
1092 | xfs_iflush_abort(ip); |
1093 | return; |
1094 | } |
1095 | |
1096 | /* |
1097 | * We have to take a reference to the buffer so that it doesn't get |
1098 | * freed when we drop the ili_lock and then wait to lock the buffer. |
1099 | * We'll clean up the extra reference after we pick up the ili_lock |
1100 | * again. |
1101 | */ |
1102 | xfs_buf_hold(bp); |
1103 | spin_unlock(lock: &iip->ili_lock); |
1104 | xfs_buf_lock(bp); |
1105 | |
1106 | spin_lock(lock: &iip->ili_lock); |
1107 | if (!iip->ili_item.li_buf) { |
1108 | /* |
1109 | * Raced with another removal, hold the only reference |
1110 | * to bp now. Inode should not be in the AIL now, so just clean |
1111 | * up and return; |
1112 | */ |
1113 | ASSERT(list_empty(&iip->ili_item.li_bio_list)); |
1114 | ASSERT(!test_bit(XFS_LI_IN_AIL, &iip->ili_item.li_flags)); |
1115 | xfs_iflush_abort_clean(iip); |
1116 | spin_unlock(lock: &iip->ili_lock); |
1117 | xfs_iflags_clear(ip, XFS_IFLUSHING); |
1118 | xfs_buf_relse(bp); |
1119 | return; |
1120 | } |
1121 | |
1122 | /* |
1123 | * Got two references to bp. The first will get dropped by |
1124 | * xfs_iflush_abort() when the item is removed from the buffer list, but |
1125 | * we can't drop our reference until _abort() returns because we have to |
1126 | * unlock the buffer as well. Hence we abort and then unlock and release |
1127 | * our reference to the buffer. |
1128 | */ |
1129 | ASSERT(iip->ili_item.li_buf == bp); |
1130 | spin_unlock(lock: &iip->ili_lock); |
1131 | xfs_iflush_abort(ip); |
1132 | xfs_buf_relse(bp); |
1133 | } |
1134 | |
1135 | |
1136 | /* |
1137 | * convert an xfs_inode_log_format struct from the old 32 bit version |
1138 | * (which can have different field alignments) to the native 64 bit version |
1139 | */ |
1140 | int |
1141 | xfs_inode_item_format_convert( |
1142 | struct xfs_log_iovec *buf, |
1143 | struct xfs_inode_log_format *in_f) |
1144 | { |
1145 | struct xfs_inode_log_format_32 *in_f32 = buf->i_addr; |
1146 | |
1147 | if (buf->i_len != sizeof(*in_f32)) { |
1148 | XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, NULL); |
1149 | return -EFSCORRUPTED; |
1150 | } |
1151 | |
1152 | in_f->ilf_type = in_f32->ilf_type; |
1153 | in_f->ilf_size = in_f32->ilf_size; |
1154 | in_f->ilf_fields = in_f32->ilf_fields; |
1155 | in_f->ilf_asize = in_f32->ilf_asize; |
1156 | in_f->ilf_dsize = in_f32->ilf_dsize; |
1157 | in_f->ilf_ino = in_f32->ilf_ino; |
1158 | memcpy(&in_f->ilf_u, &in_f32->ilf_u, sizeof(in_f->ilf_u)); |
1159 | in_f->ilf_blkno = in_f32->ilf_blkno; |
1160 | in_f->ilf_len = in_f32->ilf_len; |
1161 | in_f->ilf_boffset = in_f32->ilf_boffset; |
1162 | return 0; |
1163 | } |
1164 | |