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 757798525 : xfs_inode_item_sort(
34 : struct xfs_log_item *lip)
35 : {
36 757798525 : 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 1378152638 : xfs_inode_item_precommit(
71 : struct xfs_trans *tp,
72 : struct xfs_log_item *lip)
73 : {
74 1378152638 : struct xfs_inode_log_item *iip = INODE_ITEM(lip);
75 1378152638 : struct xfs_inode *ip = iip->ili_inode;
76 1378152638 : struct inode *inode = VFS_I(ip);
77 1378152638 : 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 1378152638 : if (inode->i_state & I_DIRTY_TIME) {
86 4 : spin_lock(&inode->i_lock);
87 4 : inode->i_state &= ~I_DIRTY_TIME;
88 4 : 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 1378152638 : if ((flags & (XFS_ILOG_CORE | XFS_ILOG_TIMESTAMP)) &&
96 1032619993 : xfs_has_bigtime(ip->i_mount) &&
97 : !xfs_inode_has_bigtime(ip)) {
98 24 : ip->i_diflags2 |= XFS_DIFLAG2_BIGTIME;
99 24 : 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 1378152638 : if ((ip->i_diflags & XFS_DIFLAG_RTINHERIT) &&
109 0 : (ip->i_diflags & XFS_DIFLAG_EXTSZINHERIT) &&
110 0 : (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 1378152638 : spin_lock(&iip->ili_lock);
125 1378440556 : iip->ili_fsync_fields |= (flags & ~XFS_ILOG_IVERSION);
126 1378440556 : if (flags & XFS_ILOG_IVERSION)
127 806970425 : flags = ((flags & ~XFS_ILOG_IVERSION) | XFS_ILOG_CORE);
128 :
129 1378440556 : if (!iip->ili_item.li_buf) {
130 122564683 : struct xfs_buf *bp;
131 122564683 : 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 122564683 : spin_unlock(&iip->ili_lock);
143 122562220 : error = xfs_imap_to_bp(ip->i_mount, tp, &ip->i_imap, &bp);
144 122565845 : if (error)
145 260 : 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 122565585 : xfs_buf_hold(bp);
155 122560006 : spin_lock(&iip->ili_lock);
156 122567694 : iip->ili_item.li_buf = bp;
157 122567694 : bp->b_flags |= _XBF_INODES;
158 122567694 : list_add_tail(&iip->ili_item.li_bio_list, &bp->b_li_list);
159 122565591 : 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 1378443932 : iip->ili_fields |= (flags | iip->ili_last_fields);
169 1378443932 : 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 1378110472 : iip->ili_dirty_flags = 0;
176 1378110472 : 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 886936869 : xfs_inode_item_data_fork_size(
195 : struct xfs_inode_log_item *iip,
196 : int *nvecs,
197 : int *nbytes)
198 : {
199 886936869 : struct xfs_inode *ip = iip->ili_inode;
200 :
201 886936869 : switch (ip->i_df.if_format) {
202 449906890 : case XFS_DINODE_FMT_EXTENTS:
203 449906890 : if ((iip->ili_fields & XFS_ILOG_DEXT) &&
204 197121521 : ip->i_df.if_nextents > 0 &&
205 176520130 : ip->i_df.if_bytes > 0) {
206 : /* worst case, doesn't subtract delalloc extents */
207 176520130 : *nbytes += xfs_inode_data_fork_size(ip);
208 176520130 : *nvecs += 1;
209 : }
210 : break;
211 324029311 : case XFS_DINODE_FMT_BTREE:
212 324029311 : if ((iip->ili_fields & XFS_ILOG_DBROOT) &&
213 266529851 : ip->i_df.if_broot_bytes > 0) {
214 266529851 : *nbytes += ip->i_df.if_broot_bytes;
215 266529851 : *nvecs += 1;
216 : }
217 : break;
218 101292624 : case XFS_DINODE_FMT_LOCAL:
219 101292624 : if ((iip->ili_fields & XFS_ILOG_DDATA) &&
220 97196360 : ip->i_df.if_bytes > 0) {
221 97196360 : *nbytes += xlog_calc_iovec_len(ip->i_df.if_bytes);
222 97196360 : *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 886936869 : }
233 :
234 : STATIC void
235 145024823 : xfs_inode_item_attr_fork_size(
236 : struct xfs_inode_log_item *iip,
237 : int *nvecs,
238 : int *nbytes)
239 : {
240 145024823 : struct xfs_inode *ip = iip->ili_inode;
241 :
242 145024823 : switch (ip->i_af.if_format) {
243 80593731 : case XFS_DINODE_FMT_EXTENTS:
244 80593731 : if ((iip->ili_fields & XFS_ILOG_AEXT) &&
245 12382323 : ip->i_af.if_nextents > 0 &&
246 11776591 : ip->i_af.if_bytes > 0) {
247 : /* worst case, doesn't subtract unused space */
248 11776591 : *nbytes += xfs_inode_attr_fork_size(ip);
249 11776591 : *nvecs += 1;
250 : }
251 : break;
252 1686 : case XFS_DINODE_FMT_BTREE:
253 1686 : if ((iip->ili_fields & XFS_ILOG_ABROOT) &&
254 1684 : ip->i_af.if_broot_bytes > 0) {
255 1684 : *nbytes += ip->i_af.if_broot_bytes;
256 1684 : *nvecs += 1;
257 : }
258 : break;
259 64429406 : case XFS_DINODE_FMT_LOCAL:
260 64429406 : if ((iip->ili_fields & XFS_ILOG_ADATA) &&
261 33175752 : ip->i_af.if_bytes > 0) {
262 33175752 : *nbytes += xlog_calc_iovec_len(ip->i_af.if_bytes);
263 33175752 : *nvecs += 1;
264 : }
265 : break;
266 0 : default:
267 0 : ASSERT(0);
268 0 : break;
269 : }
270 145024823 : }
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 886908164 : xfs_inode_item_size(
281 : struct xfs_log_item *lip,
282 : int *nvecs,
283 : int *nbytes)
284 : {
285 886908164 : struct xfs_inode_log_item *iip = INODE_ITEM(lip);
286 886908164 : struct xfs_inode *ip = iip->ili_inode;
287 :
288 886908164 : *nvecs += 2;
289 1773816328 : *nbytes += sizeof(struct xfs_inode_log_format) +
290 886908164 : xfs_log_dinode_size(ip->i_mount);
291 :
292 886908164 : xfs_inode_item_data_fork_size(iip, nvecs, nbytes);
293 886921700 : if (xfs_inode_has_attr_fork(ip))
294 145023209 : xfs_inode_item_attr_fork_size(iip, nvecs, nbytes);
295 886924968 : }
296 :
297 : STATIC void
298 886978331 : 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 886978331 : struct xfs_inode *ip = iip->ili_inode;
305 886978331 : size_t data_bytes;
306 :
307 886978331 : switch (ip->i_df.if_format) {
308 449948730 : case XFS_DINODE_FMT_EXTENTS:
309 449948730 : iip->ili_fields &=
310 : ~(XFS_ILOG_DDATA | XFS_ILOG_DBROOT | XFS_ILOG_DEV);
311 :
312 449948730 : if ((iip->ili_fields & XFS_ILOG_DEXT) &&
313 197129059 : ip->i_df.if_nextents > 0 &&
314 176518836 : ip->i_df.if_bytes > 0) {
315 176524242 : struct xfs_bmbt_rec *p;
316 :
317 176524242 : ASSERT(xfs_iext_count(&ip->i_df) > 0);
318 :
319 176524295 : p = xlog_prepare_iovec(lv, vecp, XLOG_REG_TYPE_IEXT);
320 176525106 : data_bytes = xfs_iextents_copy(ip, p, XFS_DATA_FORK);
321 176527029 : xlog_finish_iovec(lv, *vecp, data_bytes);
322 :
323 176524154 : ASSERT(data_bytes <= ip->i_df.if_bytes);
324 :
325 176524154 : ilf->ilf_dsize = data_bytes;
326 176524154 : ilf->ilf_size++;
327 : } else {
328 273424488 : iip->ili_fields &= ~XFS_ILOG_DEXT;
329 : }
330 : break;
331 324029361 : case XFS_DINODE_FMT_BTREE:
332 324029361 : iip->ili_fields &=
333 : ~(XFS_ILOG_DDATA | XFS_ILOG_DEXT | XFS_ILOG_DEV);
334 :
335 324029361 : if ((iip->ili_fields & XFS_ILOG_DBROOT) &&
336 266529835 : ip->i_df.if_broot_bytes > 0) {
337 266529835 : ASSERT(ip->i_df.if_broot != NULL);
338 266529835 : xlog_copy_iovec(lv, vecp, XLOG_REG_TYPE_IBROOT,
339 266529835 : ip->i_df.if_broot,
340 266529835 : ip->i_df.if_broot_bytes);
341 266529814 : ilf->ilf_dsize = ip->i_df.if_broot_bytes;
342 266529814 : ilf->ilf_size++;
343 : } else {
344 57499526 : ASSERT(!(iip->ili_fields &
345 : XFS_ILOG_DBROOT));
346 57499526 : iip->ili_fields &= ~XFS_ILOG_DBROOT;
347 : }
348 : break;
349 101292177 : case XFS_DINODE_FMT_LOCAL:
350 101292177 : iip->ili_fields &=
351 : ~(XFS_ILOG_DEXT | XFS_ILOG_DBROOT | XFS_ILOG_DEV);
352 101292177 : if ((iip->ili_fields & XFS_ILOG_DDATA) &&
353 97196034 : ip->i_df.if_bytes > 0) {
354 97196034 : ASSERT(ip->i_df.if_u1.if_data != NULL);
355 97196034 : ASSERT(ip->i_disk_size > 0);
356 97196034 : xlog_copy_iovec(lv, vecp, XLOG_REG_TYPE_ILOCAL,
357 97196034 : ip->i_df.if_u1.if_data,
358 97196034 : ip->i_df.if_bytes);
359 97197210 : ilf->ilf_dsize = (unsigned)ip->i_df.if_bytes;
360 97197210 : ilf->ilf_size++;
361 : } else {
362 4096143 : iip->ili_fields &= ~XFS_ILOG_DDATA;
363 : }
364 : break;
365 11708063 : case XFS_DINODE_FMT_DEV:
366 11708063 : iip->ili_fields &=
367 : ~(XFS_ILOG_DDATA | XFS_ILOG_DBROOT | XFS_ILOG_DEXT);
368 11708063 : if (iip->ili_fields & XFS_ILOG_DEV)
369 6943350 : 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 886979398 : }
376 :
377 : STATIC void
378 145028251 : 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 145028251 : struct xfs_inode *ip = iip->ili_inode;
385 145028251 : size_t data_bytes;
386 :
387 145028251 : switch (ip->i_af.if_format) {
388 80596160 : case XFS_DINODE_FMT_EXTENTS:
389 80596160 : iip->ili_fields &=
390 : ~(XFS_ILOG_ADATA | XFS_ILOG_ABROOT);
391 :
392 80596160 : if ((iip->ili_fields & XFS_ILOG_AEXT) &&
393 12382051 : ip->i_af.if_nextents > 0 &&
394 11776603 : ip->i_af.if_bytes > 0) {
395 11776478 : struct xfs_bmbt_rec *p;
396 :
397 11776478 : ASSERT(xfs_iext_count(&ip->i_af) ==
398 : ip->i_af.if_nextents);
399 :
400 11776576 : p = xlog_prepare_iovec(lv, vecp, XLOG_REG_TYPE_IATTR_EXT);
401 11776580 : data_bytes = xfs_iextents_copy(ip, p, XFS_ATTR_FORK);
402 11776519 : xlog_finish_iovec(lv, *vecp, data_bytes);
403 :
404 11776579 : ilf->ilf_asize = data_bytes;
405 11776579 : ilf->ilf_size++;
406 : } else {
407 68819682 : iip->ili_fields &= ~XFS_ILOG_AEXT;
408 : }
409 : break;
410 1686 : case XFS_DINODE_FMT_BTREE:
411 1686 : iip->ili_fields &=
412 : ~(XFS_ILOG_ADATA | XFS_ILOG_AEXT);
413 :
414 1686 : if ((iip->ili_fields & XFS_ILOG_ABROOT) &&
415 1684 : ip->i_af.if_broot_bytes > 0) {
416 1684 : ASSERT(ip->i_af.if_broot != NULL);
417 :
418 1684 : xlog_copy_iovec(lv, vecp, XLOG_REG_TYPE_IATTR_BROOT,
419 1684 : ip->i_af.if_broot,
420 1684 : ip->i_af.if_broot_bytes);
421 1684 : ilf->ilf_asize = ip->i_af.if_broot_bytes;
422 1684 : ilf->ilf_size++;
423 : } else {
424 2 : iip->ili_fields &= ~XFS_ILOG_ABROOT;
425 : }
426 : break;
427 64430405 : case XFS_DINODE_FMT_LOCAL:
428 64430405 : iip->ili_fields &=
429 : ~(XFS_ILOG_AEXT | XFS_ILOG_ABROOT);
430 :
431 64430405 : if ((iip->ili_fields & XFS_ILOG_ADATA) &&
432 33175765 : ip->i_af.if_bytes > 0) {
433 33175765 : ASSERT(ip->i_af.if_u1.if_data != NULL);
434 33175765 : xlog_copy_iovec(lv, vecp, XLOG_REG_TYPE_IATTR_LOCAL,
435 33175765 : ip->i_af.if_u1.if_data,
436 33175765 : ip->i_af.if_bytes);
437 33176291 : ilf->ilf_asize = (unsigned)ip->i_af.if_bytes;
438 33176291 : ilf->ilf_size++;
439 : } else {
440 31254640 : iip->ili_fields &= ~XFS_ILOG_ADATA;
441 : }
442 : break;
443 0 : default:
444 0 : ASSERT(0);
445 0 : break;
446 : }
447 145028878 : }
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 3547848079 : struct xfs_log_legacy_timestamp *lits;
459 3547848079 : xfs_log_timestamp_t its;
460 :
461 3547848079 : if (xfs_inode_has_bigtime(ip))
462 3547655042 : return xfs_inode_encode_bigtime(tv);
463 :
464 197820 : lits = (struct xfs_log_legacy_timestamp *)&its;
465 197820 : lits->t_sec = tv.tv_sec;
466 197820 : lits->t_nsec = tv.tv_nsec;
467 :
468 197820 : 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 886911315 : xfs_copy_dm_fields_to_log_dinode(
481 : struct xfs_inode *ip,
482 : struct xfs_log_dinode *to)
483 : {
484 886911315 : struct xfs_dinode *dip;
485 :
486 886911315 : dip = xfs_buf_offset(ip->i_itemp->ili_item.li_buf,
487 886911315 : ip->i_imap.im_boffset);
488 :
489 1773863346 : if (xfs_iflags_test(ip, XFS_IPRESERVE_DM_FIELDS)) {
490 0 : to->di_dmevmask = be32_to_cpu(dip->di_dmevmask);
491 0 : to->di_dmstate = be16_to_cpu(dip->di_dmstate);
492 : } else {
493 886925920 : to->di_dmevmask = 0;
494 886925920 : to->di_dmstate = 0;
495 : }
496 886925920 : }
497 :
498 : static inline void
499 886955658 : xfs_inode_to_log_dinode_iext_counters(
500 : struct xfs_inode *ip,
501 : struct xfs_log_dinode *to)
502 : {
503 886955658 : if (xfs_inode_has_large_extent_counts(ip)) {
504 886793833 : to->di_big_nextents = xfs_ifork_nextents(&ip->i_df);
505 886793833 : to->di_big_anextents = xfs_ifork_nextents(&ip->i_af);
506 886793833 : to->di_nrext64_pad = 0;
507 : } else {
508 161825 : to->di_nextents = xfs_ifork_nextents(&ip->i_df);
509 323650 : to->di_anextents = xfs_ifork_nextents(&ip->i_af);
510 : }
511 886955658 : }
512 :
513 : static void
514 886916475 : xfs_inode_to_log_dinode(
515 : struct xfs_inode *ip,
516 : struct xfs_log_dinode *to,
517 : xfs_lsn_t lsn)
518 : {
519 886916475 : struct inode *inode = VFS_I(ip);
520 :
521 886916475 : to->di_magic = XFS_DINODE_MAGIC;
522 886916475 : to->di_format = xfs_ifork_format(&ip->i_df);
523 886916475 : to->di_uid = i_uid_read(inode);
524 886963979 : to->di_gid = i_gid_read(inode);
525 886968179 : to->di_projid_lo = ip->i_projid & 0xffff;
526 886968179 : to->di_projid_hi = ip->i_projid >> 16;
527 :
528 886968179 : memset(to->di_pad3, 0, sizeof(to->di_pad3));
529 886968179 : to->di_atime = xfs_inode_to_log_dinode_ts(ip, inode->i_atime);
530 886968179 : to->di_mtime = xfs_inode_to_log_dinode_ts(ip, inode->i_mtime);
531 886968179 : to->di_ctime = xfs_inode_to_log_dinode_ts(ip, inode->i_ctime);
532 886968179 : to->di_nlink = inode->i_nlink;
533 886968179 : to->di_gen = inode->i_generation;
534 886968179 : to->di_mode = inode->i_mode;
535 :
536 886968179 : to->di_size = ip->i_disk_size;
537 886968179 : to->di_nblocks = ip->i_nblocks;
538 886968179 : to->di_extsize = ip->i_extsize;
539 886968179 : to->di_forkoff = ip->i_forkoff;
540 886968179 : to->di_aformat = xfs_ifork_format(&ip->i_af);
541 886968179 : to->di_flags = ip->i_diflags;
542 :
543 886968179 : xfs_copy_dm_fields_to_log_dinode(ip, to);
544 :
545 : /* log a dummy value to ensure log structure is fully initialised */
546 886944394 : to->di_next_unlinked = NULLAGINO;
547 :
548 886944394 : if (xfs_has_v3inodes(ip->i_mount)) {
549 886943542 : to->di_version = 3;
550 886943542 : to->di_changecount = inode_peek_iversion(inode);
551 886943542 : to->di_crtime = xfs_inode_to_log_dinode_ts(ip, ip->i_crtime);
552 886943542 : to->di_flags2 = ip->i_diflags2;
553 886943542 : to->di_cowextsize = ip->i_cowextsize;
554 886943542 : to->di_ino = ip->i_ino;
555 886943542 : to->di_lsn = lsn;
556 886943542 : memset(to->di_pad2, 0, sizeof(to->di_pad2));
557 886943542 : uuid_copy(&to->di_uuid, &ip->i_mount->m_sb.sb_meta_uuid);
558 886960942 : to->di_v3_pad = 0;
559 : } else {
560 852 : to->di_version = 2;
561 852 : to->di_flushiter = ip->i_flushiter;
562 1704 : memset(to->di_v2_pad, 0, sizeof(to->di_v2_pad));
563 : }
564 :
565 886961794 : xfs_inode_to_log_dinode_iext_counters(ip, to);
566 886867467 : }
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 886903434 : xfs_inode_item_format_core(
575 : struct xfs_inode *ip,
576 : struct xfs_log_vec *lv,
577 : struct xfs_log_iovec **vecp)
578 : {
579 886903434 : struct xfs_log_dinode *dic;
580 :
581 886903434 : dic = xlog_prepare_iovec(lv, vecp, XLOG_REG_TYPE_ICORE);
582 886929370 : xfs_inode_to_log_dinode(ip, dic, ip->i_itemp->ili_item.li_lsn);
583 886924390 : xlog_finish_iovec(lv, *vecp, xfs_log_dinode_size(ip->i_mount));
584 886943122 : }
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 886871508 : xfs_inode_item_format(
600 : struct xfs_log_item *lip,
601 : struct xfs_log_vec *lv)
602 : {
603 886871508 : struct xfs_inode_log_item *iip = INODE_ITEM(lip);
604 886871508 : struct xfs_inode *ip = iip->ili_inode;
605 886871508 : struct xfs_log_iovec *vecp = NULL;
606 886871508 : struct xfs_inode_log_format *ilf;
607 :
608 886871508 : ilf = xlog_prepare_iovec(lv, &vecp, XLOG_REG_TYPE_IFORMAT);
609 886887154 : ilf->ilf_type = XFS_LI_INODE;
610 886887154 : ilf->ilf_ino = ip->i_ino;
611 886887154 : ilf->ilf_blkno = ip->i_imap.im_blkno;
612 886887154 : ilf->ilf_len = ip->i_imap.im_len;
613 886887154 : ilf->ilf_boffset = ip->i_imap.im_boffset;
614 886887154 : ilf->ilf_fields = XFS_ILOG_CORE;
615 886887154 : 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 886887154 : ilf->ilf_dsize = 0;
622 886887154 : ilf->ilf_asize = 0;
623 886887154 : ilf->ilf_pad = 0;
624 886887154 : memset(&ilf->ilf_u, 0, sizeof(ilf->ilf_u));
625 :
626 886887154 : xlog_finish_iovec(lv, vecp, sizeof(*ilf));
627 :
628 886901999 : xfs_inode_item_format_core(ip, lv, &vecp);
629 886967486 : xfs_inode_item_format_data_fork(iip, ilf, lv, &vecp);
630 886945433 : if (xfs_inode_has_attr_fork(ip)) {
631 145032989 : xfs_inode_item_format_attr_fork(iip, ilf, lv, &vecp);
632 : } else {
633 741912444 : 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 886941098 : ilf->ilf_fields |= (iip->ili_fields & ~XFS_ILOG_TIMESTAMP);
639 886941098 : }
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 228690811 : xfs_inode_item_pin(
647 : struct xfs_log_item *lip)
648 : {
649 228690811 : struct xfs_inode *ip = INODE_ITEM(lip)->ili_inode;
650 :
651 228690811 : ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
652 228697606 : ASSERT(lip->li_buf);
653 :
654 228697606 : trace_xfs_inode_pin(ip, _RET_IP_);
655 228698517 : atomic_inc(&ip->i_pincount);
656 228698987 : }
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 228705900 : xfs_inode_item_unpin(
673 : struct xfs_log_item *lip,
674 : int remove)
675 : {
676 228705900 : struct xfs_inode *ip = INODE_ITEM(lip)->ili_inode;
677 :
678 228705900 : trace_xfs_inode_unpin(ip, _RET_IP_);
679 228708226 : ASSERT(lip->li_buf || xfs_iflags_test(ip, XFS_ISTALE));
680 228705900 : ASSERT(atomic_read(&ip->i_pincount) > 0);
681 457411801 : if (atomic_dec_and_test(&ip->i_pincount))
682 221491574 : wake_up_bit(&ip->i_flags, __XFS_IPINNED_BIT);
683 228705901 : }
684 :
685 : STATIC uint
686 85403845 : 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 85403845 : struct xfs_inode_log_item *iip = INODE_ITEM(lip);
693 85403845 : struct xfs_inode *ip = iip->ili_inode;
694 85403845 : struct xfs_buf *bp = lip->li_buf;
695 85403845 : uint rval = XFS_ITEM_SUCCESS;
696 85403845 : int error;
697 :
698 85403845 : 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 85396985 : if (xfs_ipincount(ip) > 0 || xfs_buf_ispinned(bp))
709 : return XFS_ITEM_PINNED;
710 :
711 168279066 : if (xfs_iflags_test(ip, XFS_IFLUSHING))
712 : return XFS_ITEM_FLUSHING;
713 :
714 20528405 : if (!xfs_buf_trylock(bp))
715 : return XFS_ITEM_LOCKED;
716 :
717 20489739 : 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 20489739 : xfs_buf_hold(bp);
726 20489739 : error = xfs_iflush_cluster(bp);
727 20489739 : if (!error) {
728 20138114 : if (!xfs_buf_delwri_queue(bp, buffer_list))
729 513091 : rval = XFS_ITEM_FLUSHING;
730 20138114 : 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 351625 : if (error == -EAGAIN)
737 105501 : xfs_buf_relse(bp);
738 : rval = XFS_ITEM_LOCKED;
739 : }
740 :
741 20489739 : spin_lock(&lip->li_ailp->ail_lock);
742 20489739 : return rval;
743 : }
744 :
745 : /*
746 : * Unlock the inode associated with the inode log item.
747 : */
748 : STATIC void
749 1156420713 : xfs_inode_item_release(
750 : struct xfs_log_item *lip)
751 : {
752 1156420713 : struct xfs_inode_log_item *iip = INODE_ITEM(lip);
753 1156420713 : struct xfs_inode *ip = iip->ili_inode;
754 1156420713 : unsigned short lock_flags;
755 :
756 1156420713 : ASSERT(ip->i_itemp != NULL);
757 1156420713 : ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
758 :
759 1156449903 : lock_flags = iip->ili_lock_flags;
760 1156449903 : iip->ili_lock_flags = 0;
761 1156449903 : if (lock_flags)
762 373183180 : xfs_iunlock(ip, lock_flags);
763 1156456859 : }
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 228705901 : xfs_inode_item_committed(
789 : struct xfs_log_item *lip,
790 : xfs_lsn_t lsn)
791 : {
792 228705901 : struct xfs_inode_log_item *iip = INODE_ITEM(lip);
793 228705901 : struct xfs_inode *ip = iip->ili_inode;
794 :
795 457411801 : if (xfs_iflags_test(ip, XFS_ISTALE)) {
796 2637598 : xfs_inode_item_unpin(lip, 0);
797 2637598 : return -1;
798 : }
799 : return lsn;
800 : }
801 :
802 : STATIC void
803 1042744509 : xfs_inode_item_committing(
804 : struct xfs_log_item *lip,
805 : xfs_csn_t seq)
806 : {
807 1042744509 : INODE_ITEM(lip)->ili_commit_seq = seq;
808 1042744509 : 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 32936484 : xfs_inode_item_init(
830 : struct xfs_inode *ip,
831 : struct xfs_mount *mp)
832 : {
833 32936484 : struct xfs_inode_log_item *iip;
834 :
835 32936484 : ASSERT(ip->i_itemp == NULL);
836 32936484 : iip = ip->i_itemp = kmem_cache_zalloc(xfs_ili_cache,
837 : GFP_KERNEL | __GFP_NOFAIL);
838 :
839 32936557 : iip->ili_inode = ip;
840 32936557 : spin_lock_init(&iip->ili_lock);
841 32936717 : xfs_log_item_init(mp, &iip->ili_item, XFS_LI_INODE,
842 : &xfs_inode_item_ops);
843 32936777 : }
844 :
845 : /*
846 : * Free the inode log item and any memory hanging off of it.
847 : */
848 : void
849 32874745 : xfs_inode_item_destroy(
850 : struct xfs_inode *ip)
851 : {
852 32874745 : struct xfs_inode_log_item *iip = ip->i_itemp;
853 :
854 32874745 : ASSERT(iip->ili_item.li_buf == NULL);
855 :
856 32874745 : ip->i_itemp = NULL;
857 32874745 : kmem_free(iip->ili_item.li_lv_shadow);
858 32893655 : kmem_cache_free(xfs_ili_cache, iip);
859 32923839 : }
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 20132490 : xfs_iflush_ail_updates(
869 : struct xfs_ail *ailp,
870 : struct list_head *list)
871 : {
872 20132490 : struct xfs_log_item *lip;
873 20132490 : xfs_lsn_t tail_lsn = 0;
874 :
875 : /* this is an opencoded batch version of xfs_trans_ail_delete */
876 20132490 : spin_lock(&ailp->ail_lock);
877 140082695 : list_for_each_entry(lip, list, li_bio_list) {
878 119950205 : xfs_lsn_t lsn;
879 :
880 119950205 : clear_bit(XFS_LI_FAILED, &lip->li_flags);
881 119950205 : if (INODE_ITEM(lip)->ili_flush_lsn != lip->li_lsn)
882 27 : 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 119950178 : 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 119950178 : lsn = xfs_ail_delete_one(ailp, lip);
896 119950178 : if (!tail_lsn && lsn)
897 252567 : tail_lsn = lsn;
898 : }
899 20132490 : xfs_ail_update_finish(ailp, tail_lsn);
900 20132490 : }
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 20591768 : xfs_iflush_finish(
910 : struct xfs_buf *bp,
911 : struct list_head *list)
912 : {
913 20591768 : struct xfs_log_item *lip, *n;
914 :
915 140908207 : list_for_each_entry_safe(lip, n, list, li_bio_list) {
916 120316439 : struct xfs_inode_log_item *iip = INODE_ITEM(lip);
917 120316439 : bool drop_buffer = false;
918 :
919 120316439 : 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 120316439 : ASSERT(iip->ili_item.li_buf == bp);
927 120316439 : if (!iip->ili_fields) {
928 118657561 : iip->ili_item.li_buf = NULL;
929 118657561 : list_del_init(&lip->li_bio_list);
930 118657561 : drop_buffer = true;
931 : }
932 120316439 : iip->ili_last_fields = 0;
933 120316439 : iip->ili_flush_lsn = 0;
934 120316439 : spin_unlock(&iip->ili_lock);
935 120316439 : xfs_iflags_clear(iip->ili_inode, XFS_IFLUSHING);
936 120316439 : if (drop_buffer)
937 118657561 : xfs_buf_rele(bp);
938 : }
939 20591768 : }
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 20591768 : xfs_buf_inode_iodone(
948 : struct xfs_buf *bp)
949 : {
950 20591768 : struct xfs_log_item *lip, *n;
951 20591768 : LIST_HEAD(flushed_inodes);
952 20591768 : 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 148654745 : list_for_each_entry_safe(lip, n, &bp->b_li_list, li_bio_list) {
959 128062977 : struct xfs_inode_log_item *iip = INODE_ITEM(lip);
960 :
961 256125954 : if (xfs_iflags_test(iip->ili_inode, XFS_ISTALE)) {
962 2944694 : xfs_iflush_abort(iip->ili_inode);
963 2944694 : continue;
964 : }
965 125118283 : if (!iip->ili_last_fields)
966 4801844 : continue;
967 :
968 : /* Do an unlocked check for needing the AIL lock. */
969 120682673 : if (iip->ili_flush_lsn == lip->li_lsn ||
970 366234 : test_bit(XFS_LI_FAILED, &lip->li_flags))
971 119950205 : list_move_tail(&lip->li_bio_list, &ail_updates);
972 : else
973 366234 : list_move_tail(&lip->li_bio_list, &flushed_inodes);
974 : }
975 :
976 20591768 : if (!list_empty(&ail_updates)) {
977 20132490 : xfs_iflush_ail_updates(bp->b_mount->m_ail, &ail_updates);
978 20132490 : list_splice_tail(&ail_updates, &flushed_inodes);
979 : }
980 :
981 20591768 : xfs_iflush_finish(bp, &flushed_inodes);
982 20591768 : if (!list_empty(&flushed_inodes))
983 953080 : list_splice_tail(&flushed_inodes, &bp->b_li_list);
984 20591768 : }
985 :
986 : void
987 0 : xfs_buf_inode_io_fail(
988 : struct xfs_buf *bp)
989 : {
990 0 : struct xfs_log_item *lip;
991 :
992 0 : list_for_each_entry(lip, &bp->b_li_list, li_bio_list)
993 0 : set_bit(XFS_LI_FAILED, &lip->li_flags);
994 0 : }
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 4950679 : xfs_iflush_abort_clean(
1004 : struct xfs_inode_log_item *iip)
1005 : {
1006 4950679 : iip->ili_last_fields = 0;
1007 4950679 : iip->ili_fields = 0;
1008 4950679 : iip->ili_fsync_fields = 0;
1009 4950679 : iip->ili_flush_lsn = 0;
1010 4950679 : iip->ili_item.li_buf = NULL;
1011 4950679 : list_del_init(&iip->ili_item.li_bio_list);
1012 4950678 : }
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 4950677 : xfs_iflush_abort(
1028 : struct xfs_inode *ip)
1029 : {
1030 4950677 : struct xfs_inode_log_item *iip = ip->i_itemp;
1031 4950677 : struct xfs_buf *bp;
1032 :
1033 4950677 : 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 4950677 : clear_bit(XFS_LI_FAILED, &iip->ili_item.li_flags);
1051 4950678 : 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 4950679 : spin_lock(&iip->ili_lock);
1058 4950679 : bp = iip->ili_item.li_buf;
1059 4950679 : xfs_iflush_abort_clean(iip);
1060 4950678 : spin_unlock(&iip->ili_lock);
1061 :
1062 4950679 : xfs_iflags_clear(ip, XFS_IFLUSHING);
1063 4950679 : if (bp)
1064 3912015 : 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 262683621 : xfs_iflush_shutdown_abort(
1075 : struct xfs_inode *ip)
1076 : {
1077 262683621 : struct xfs_inode_log_item *iip = ip->i_itemp;
1078 262683621 : struct xfs_buf *bp;
1079 :
1080 262683621 : if (!iip) {
1081 : /* clean inode, nothing to do */
1082 261611384 : xfs_iflags_clear(ip, XFS_IFLUSHING);
1083 261611384 : return;
1084 : }
1085 :
1086 1072237 : spin_lock(&iip->ili_lock);
1087 1072237 : bp = iip->ili_item.li_buf;
1088 1072237 : if (!bp) {
1089 1038664 : spin_unlock(&iip->ili_lock);
1090 1038664 : xfs_iflush_abort(ip);
1091 1038664 : 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 33573 : xfs_buf_hold(bp);
1101 33573 : spin_unlock(&iip->ili_lock);
1102 33573 : xfs_buf_lock(bp);
1103 :
1104 33573 : spin_lock(&iip->ili_lock);
1105 33573 : 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 33573 : ASSERT(iip->ili_item.li_buf == bp);
1128 33573 : spin_unlock(&iip->ili_lock);
1129 33573 : xfs_iflush_abort(ip);
1130 33573 : 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 : }
|
