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