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
21 #include <linux/iversion.h>
22
23 kmem_zone_t *xfs_ili_zone; /* inode log item zone */
24
INODE_ITEM(struct xfs_log_item * lip)25 static inline struct xfs_inode_log_item *INODE_ITEM(struct xfs_log_item *lip)
26 {
27 return container_of(lip, struct xfs_inode_log_item, ili_item);
28 }
29
30 STATIC void
xfs_inode_item_data_fork_size(struct xfs_inode_log_item * iip,int * nvecs,int * nbytes)31 xfs_inode_item_data_fork_size(
32 struct xfs_inode_log_item *iip,
33 int *nvecs,
34 int *nbytes)
35 {
36 struct xfs_inode *ip = iip->ili_inode;
37
38 switch (ip->i_d.di_format) {
39 case XFS_DINODE_FMT_EXTENTS:
40 if ((iip->ili_fields & XFS_ILOG_DEXT) &&
41 ip->i_d.di_nextents > 0 &&
42 ip->i_df.if_bytes > 0) {
43 /* worst case, doesn't subtract delalloc extents */
44 *nbytes += XFS_IFORK_DSIZE(ip);
45 *nvecs += 1;
46 }
47 break;
48 case XFS_DINODE_FMT_BTREE:
49 if ((iip->ili_fields & XFS_ILOG_DBROOT) &&
50 ip->i_df.if_broot_bytes > 0) {
51 *nbytes += ip->i_df.if_broot_bytes;
52 *nvecs += 1;
53 }
54 break;
55 case XFS_DINODE_FMT_LOCAL:
56 if ((iip->ili_fields & XFS_ILOG_DDATA) &&
57 ip->i_df.if_bytes > 0) {
58 *nbytes += roundup(ip->i_df.if_bytes, 4);
59 *nvecs += 1;
60 }
61 break;
62
63 case XFS_DINODE_FMT_DEV:
64 break;
65 default:
66 ASSERT(0);
67 break;
68 }
69 }
70
71 STATIC void
xfs_inode_item_attr_fork_size(struct xfs_inode_log_item * iip,int * nvecs,int * nbytes)72 xfs_inode_item_attr_fork_size(
73 struct xfs_inode_log_item *iip,
74 int *nvecs,
75 int *nbytes)
76 {
77 struct xfs_inode *ip = iip->ili_inode;
78
79 switch (ip->i_d.di_aformat) {
80 case XFS_DINODE_FMT_EXTENTS:
81 if ((iip->ili_fields & XFS_ILOG_AEXT) &&
82 ip->i_d.di_anextents > 0 &&
83 ip->i_afp->if_bytes > 0) {
84 /* worst case, doesn't subtract unused space */
85 *nbytes += XFS_IFORK_ASIZE(ip);
86 *nvecs += 1;
87 }
88 break;
89 case XFS_DINODE_FMT_BTREE:
90 if ((iip->ili_fields & XFS_ILOG_ABROOT) &&
91 ip->i_afp->if_broot_bytes > 0) {
92 *nbytes += ip->i_afp->if_broot_bytes;
93 *nvecs += 1;
94 }
95 break;
96 case XFS_DINODE_FMT_LOCAL:
97 if ((iip->ili_fields & XFS_ILOG_ADATA) &&
98 ip->i_afp->if_bytes > 0) {
99 *nbytes += roundup(ip->i_afp->if_bytes, 4);
100 *nvecs += 1;
101 }
102 break;
103 default:
104 ASSERT(0);
105 break;
106 }
107 }
108
109 /*
110 * This returns the number of iovecs needed to log the given inode item.
111 *
112 * We need one iovec for the inode log format structure, one for the
113 * inode core, and possibly one for the inode data/extents/b-tree root
114 * and one for the inode attribute data/extents/b-tree root.
115 */
116 STATIC void
xfs_inode_item_size(struct xfs_log_item * lip,int * nvecs,int * nbytes)117 xfs_inode_item_size(
118 struct xfs_log_item *lip,
119 int *nvecs,
120 int *nbytes)
121 {
122 struct xfs_inode_log_item *iip = INODE_ITEM(lip);
123 struct xfs_inode *ip = iip->ili_inode;
124
125 *nvecs += 2;
126 *nbytes += sizeof(struct xfs_inode_log_format) +
127 xfs_log_dinode_size(ip->i_d.di_version);
128
129 xfs_inode_item_data_fork_size(iip, nvecs, nbytes);
130 if (XFS_IFORK_Q(ip))
131 xfs_inode_item_attr_fork_size(iip, nvecs, nbytes);
132 }
133
134 STATIC void
xfs_inode_item_format_data_fork(struct xfs_inode_log_item * iip,struct xfs_inode_log_format * ilf,struct xfs_log_vec * lv,struct xfs_log_iovec ** vecp)135 xfs_inode_item_format_data_fork(
136 struct xfs_inode_log_item *iip,
137 struct xfs_inode_log_format *ilf,
138 struct xfs_log_vec *lv,
139 struct xfs_log_iovec **vecp)
140 {
141 struct xfs_inode *ip = iip->ili_inode;
142 size_t data_bytes;
143
144 switch (ip->i_d.di_format) {
145 case XFS_DINODE_FMT_EXTENTS:
146 iip->ili_fields &=
147 ~(XFS_ILOG_DDATA | XFS_ILOG_DBROOT | XFS_ILOG_DEV);
148
149 if ((iip->ili_fields & XFS_ILOG_DEXT) &&
150 ip->i_d.di_nextents > 0 &&
151 ip->i_df.if_bytes > 0) {
152 struct xfs_bmbt_rec *p;
153
154 ASSERT(xfs_iext_count(&ip->i_df) > 0);
155
156 p = xlog_prepare_iovec(lv, vecp, XLOG_REG_TYPE_IEXT);
157 data_bytes = xfs_iextents_copy(ip, p, XFS_DATA_FORK);
158 xlog_finish_iovec(lv, *vecp, data_bytes);
159
160 ASSERT(data_bytes <= ip->i_df.if_bytes);
161
162 ilf->ilf_dsize = data_bytes;
163 ilf->ilf_size++;
164 } else {
165 iip->ili_fields &= ~XFS_ILOG_DEXT;
166 }
167 break;
168 case XFS_DINODE_FMT_BTREE:
169 iip->ili_fields &=
170 ~(XFS_ILOG_DDATA | XFS_ILOG_DEXT | XFS_ILOG_DEV);
171
172 if ((iip->ili_fields & XFS_ILOG_DBROOT) &&
173 ip->i_df.if_broot_bytes > 0) {
174 ASSERT(ip->i_df.if_broot != NULL);
175 xlog_copy_iovec(lv, vecp, XLOG_REG_TYPE_IBROOT,
176 ip->i_df.if_broot,
177 ip->i_df.if_broot_bytes);
178 ilf->ilf_dsize = ip->i_df.if_broot_bytes;
179 ilf->ilf_size++;
180 } else {
181 ASSERT(!(iip->ili_fields &
182 XFS_ILOG_DBROOT));
183 iip->ili_fields &= ~XFS_ILOG_DBROOT;
184 }
185 break;
186 case XFS_DINODE_FMT_LOCAL:
187 iip->ili_fields &=
188 ~(XFS_ILOG_DEXT | XFS_ILOG_DBROOT | XFS_ILOG_DEV);
189 if ((iip->ili_fields & XFS_ILOG_DDATA) &&
190 ip->i_df.if_bytes > 0) {
191 /*
192 * Round i_bytes up to a word boundary.
193 * The underlying memory is guaranteed to
194 * to be there by xfs_idata_realloc().
195 */
196 data_bytes = roundup(ip->i_df.if_bytes, 4);
197 ASSERT(ip->i_df.if_u1.if_data != NULL);
198 ASSERT(ip->i_d.di_size > 0);
199 xlog_copy_iovec(lv, vecp, XLOG_REG_TYPE_ILOCAL,
200 ip->i_df.if_u1.if_data, data_bytes);
201 ilf->ilf_dsize = (unsigned)data_bytes;
202 ilf->ilf_size++;
203 } else {
204 iip->ili_fields &= ~XFS_ILOG_DDATA;
205 }
206 break;
207 case XFS_DINODE_FMT_DEV:
208 iip->ili_fields &=
209 ~(XFS_ILOG_DDATA | XFS_ILOG_DBROOT | XFS_ILOG_DEXT);
210 if (iip->ili_fields & XFS_ILOG_DEV)
211 ilf->ilf_u.ilfu_rdev = sysv_encode_dev(VFS_I(ip)->i_rdev);
212 break;
213 default:
214 ASSERT(0);
215 break;
216 }
217 }
218
219 STATIC void
xfs_inode_item_format_attr_fork(struct xfs_inode_log_item * iip,struct xfs_inode_log_format * ilf,struct xfs_log_vec * lv,struct xfs_log_iovec ** vecp)220 xfs_inode_item_format_attr_fork(
221 struct xfs_inode_log_item *iip,
222 struct xfs_inode_log_format *ilf,
223 struct xfs_log_vec *lv,
224 struct xfs_log_iovec **vecp)
225 {
226 struct xfs_inode *ip = iip->ili_inode;
227 size_t data_bytes;
228
229 switch (ip->i_d.di_aformat) {
230 case XFS_DINODE_FMT_EXTENTS:
231 iip->ili_fields &=
232 ~(XFS_ILOG_ADATA | XFS_ILOG_ABROOT);
233
234 if ((iip->ili_fields & XFS_ILOG_AEXT) &&
235 ip->i_d.di_anextents > 0 &&
236 ip->i_afp->if_bytes > 0) {
237 struct xfs_bmbt_rec *p;
238
239 ASSERT(xfs_iext_count(ip->i_afp) ==
240 ip->i_d.di_anextents);
241
242 p = xlog_prepare_iovec(lv, vecp, XLOG_REG_TYPE_IATTR_EXT);
243 data_bytes = xfs_iextents_copy(ip, p, XFS_ATTR_FORK);
244 xlog_finish_iovec(lv, *vecp, data_bytes);
245
246 ilf->ilf_asize = data_bytes;
247 ilf->ilf_size++;
248 } else {
249 iip->ili_fields &= ~XFS_ILOG_AEXT;
250 }
251 break;
252 case XFS_DINODE_FMT_BTREE:
253 iip->ili_fields &=
254 ~(XFS_ILOG_ADATA | XFS_ILOG_AEXT);
255
256 if ((iip->ili_fields & XFS_ILOG_ABROOT) &&
257 ip->i_afp->if_broot_bytes > 0) {
258 ASSERT(ip->i_afp->if_broot != NULL);
259
260 xlog_copy_iovec(lv, vecp, XLOG_REG_TYPE_IATTR_BROOT,
261 ip->i_afp->if_broot,
262 ip->i_afp->if_broot_bytes);
263 ilf->ilf_asize = ip->i_afp->if_broot_bytes;
264 ilf->ilf_size++;
265 } else {
266 iip->ili_fields &= ~XFS_ILOG_ABROOT;
267 }
268 break;
269 case XFS_DINODE_FMT_LOCAL:
270 iip->ili_fields &=
271 ~(XFS_ILOG_AEXT | XFS_ILOG_ABROOT);
272
273 if ((iip->ili_fields & XFS_ILOG_ADATA) &&
274 ip->i_afp->if_bytes > 0) {
275 /*
276 * Round i_bytes up to a word boundary.
277 * The underlying memory is guaranteed to
278 * to be there by xfs_idata_realloc().
279 */
280 data_bytes = roundup(ip->i_afp->if_bytes, 4);
281 ASSERT(ip->i_afp->if_u1.if_data != NULL);
282 xlog_copy_iovec(lv, vecp, XLOG_REG_TYPE_IATTR_LOCAL,
283 ip->i_afp->if_u1.if_data,
284 data_bytes);
285 ilf->ilf_asize = (unsigned)data_bytes;
286 ilf->ilf_size++;
287 } else {
288 iip->ili_fields &= ~XFS_ILOG_ADATA;
289 }
290 break;
291 default:
292 ASSERT(0);
293 break;
294 }
295 }
296
297 static void
xfs_inode_to_log_dinode(struct xfs_inode * ip,struct xfs_log_dinode * to,xfs_lsn_t lsn)298 xfs_inode_to_log_dinode(
299 struct xfs_inode *ip,
300 struct xfs_log_dinode *to,
301 xfs_lsn_t lsn)
302 {
303 struct xfs_icdinode *from = &ip->i_d;
304 struct inode *inode = VFS_I(ip);
305
306 to->di_magic = XFS_DINODE_MAGIC;
307
308 to->di_version = from->di_version;
309 to->di_format = from->di_format;
310 to->di_uid = from->di_uid;
311 to->di_gid = from->di_gid;
312 to->di_projid_lo = from->di_projid_lo;
313 to->di_projid_hi = from->di_projid_hi;
314
315 memset(to->di_pad, 0, sizeof(to->di_pad));
316 memset(to->di_pad3, 0, sizeof(to->di_pad3));
317 to->di_atime.t_sec = inode->i_atime.tv_sec;
318 to->di_atime.t_nsec = inode->i_atime.tv_nsec;
319 to->di_mtime.t_sec = inode->i_mtime.tv_sec;
320 to->di_mtime.t_nsec = inode->i_mtime.tv_nsec;
321 to->di_ctime.t_sec = inode->i_ctime.tv_sec;
322 to->di_ctime.t_nsec = inode->i_ctime.tv_nsec;
323 to->di_nlink = inode->i_nlink;
324 to->di_gen = inode->i_generation;
325 to->di_mode = inode->i_mode;
326
327 to->di_size = from->di_size;
328 to->di_nblocks = from->di_nblocks;
329 to->di_extsize = from->di_extsize;
330 to->di_nextents = from->di_nextents;
331 to->di_anextents = from->di_anextents;
332 to->di_forkoff = from->di_forkoff;
333 to->di_aformat = from->di_aformat;
334 to->di_dmevmask = from->di_dmevmask;
335 to->di_dmstate = from->di_dmstate;
336 to->di_flags = from->di_flags;
337
338 /* log a dummy value to ensure log structure is fully initialised */
339 to->di_next_unlinked = NULLAGINO;
340
341 if (from->di_version == 3) {
342 to->di_changecount = inode_peek_iversion(inode);
343 to->di_crtime.t_sec = from->di_crtime.t_sec;
344 to->di_crtime.t_nsec = from->di_crtime.t_nsec;
345 to->di_flags2 = from->di_flags2;
346 to->di_cowextsize = from->di_cowextsize;
347 to->di_ino = ip->i_ino;
348 to->di_lsn = lsn;
349 memset(to->di_pad2, 0, sizeof(to->di_pad2));
350 uuid_copy(&to->di_uuid, &ip->i_mount->m_sb.sb_meta_uuid);
351 to->di_flushiter = 0;
352 } else {
353 to->di_flushiter = from->di_flushiter;
354 }
355 }
356
357 /*
358 * Format the inode core. Current timestamp data is only in the VFS inode
359 * fields, so we need to grab them from there. Hence rather than just copying
360 * the XFS inode core structure, format the fields directly into the iovec.
361 */
362 static void
xfs_inode_item_format_core(struct xfs_inode * ip,struct xfs_log_vec * lv,struct xfs_log_iovec ** vecp)363 xfs_inode_item_format_core(
364 struct xfs_inode *ip,
365 struct xfs_log_vec *lv,
366 struct xfs_log_iovec **vecp)
367 {
368 struct xfs_log_dinode *dic;
369
370 dic = xlog_prepare_iovec(lv, vecp, XLOG_REG_TYPE_ICORE);
371 xfs_inode_to_log_dinode(ip, dic, ip->i_itemp->ili_item.li_lsn);
372 xlog_finish_iovec(lv, *vecp, xfs_log_dinode_size(ip->i_d.di_version));
373 }
374
375 /*
376 * This is called to fill in the vector of log iovecs for the given inode
377 * log item. It fills the first item with an inode log format structure,
378 * the second with the on-disk inode structure, and a possible third and/or
379 * fourth with the inode data/extents/b-tree root and inode attributes
380 * data/extents/b-tree root.
381 *
382 * Note: Always use the 64 bit inode log format structure so we don't
383 * leave an uninitialised hole in the format item on 64 bit systems. Log
384 * recovery on 32 bit systems handles this just fine, so there's no reason
385 * for not using an initialising the properly padded structure all the time.
386 */
387 STATIC void
xfs_inode_item_format(struct xfs_log_item * lip,struct xfs_log_vec * lv)388 xfs_inode_item_format(
389 struct xfs_log_item *lip,
390 struct xfs_log_vec *lv)
391 {
392 struct xfs_inode_log_item *iip = INODE_ITEM(lip);
393 struct xfs_inode *ip = iip->ili_inode;
394 struct xfs_log_iovec *vecp = NULL;
395 struct xfs_inode_log_format *ilf;
396
397 ASSERT(ip->i_d.di_version > 1);
398
399 ilf = xlog_prepare_iovec(lv, &vecp, XLOG_REG_TYPE_IFORMAT);
400 ilf->ilf_type = XFS_LI_INODE;
401 ilf->ilf_ino = ip->i_ino;
402 ilf->ilf_blkno = ip->i_imap.im_blkno;
403 ilf->ilf_len = ip->i_imap.im_len;
404 ilf->ilf_boffset = ip->i_imap.im_boffset;
405 ilf->ilf_fields = XFS_ILOG_CORE;
406 ilf->ilf_size = 2; /* format + core */
407
408 /*
409 * make sure we don't leak uninitialised data into the log in the case
410 * when we don't log every field in the inode.
411 */
412 ilf->ilf_dsize = 0;
413 ilf->ilf_asize = 0;
414 ilf->ilf_pad = 0;
415 memset(&ilf->ilf_u, 0, sizeof(ilf->ilf_u));
416
417 xlog_finish_iovec(lv, vecp, sizeof(*ilf));
418
419 xfs_inode_item_format_core(ip, lv, &vecp);
420 xfs_inode_item_format_data_fork(iip, ilf, lv, &vecp);
421 if (XFS_IFORK_Q(ip)) {
422 xfs_inode_item_format_attr_fork(iip, ilf, lv, &vecp);
423 } else {
424 iip->ili_fields &=
425 ~(XFS_ILOG_ADATA | XFS_ILOG_ABROOT | XFS_ILOG_AEXT);
426 }
427
428 /* update the format with the exact fields we actually logged */
429 ilf->ilf_fields |= (iip->ili_fields & ~XFS_ILOG_TIMESTAMP);
430 }
431
432 /*
433 * This is called to pin the inode associated with the inode log
434 * item in memory so it cannot be written out.
435 */
436 STATIC void
xfs_inode_item_pin(struct xfs_log_item * lip)437 xfs_inode_item_pin(
438 struct xfs_log_item *lip)
439 {
440 struct xfs_inode *ip = INODE_ITEM(lip)->ili_inode;
441
442 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
443
444 trace_xfs_inode_pin(ip, _RET_IP_);
445 atomic_inc(&ip->i_pincount);
446 }
447
448
449 /*
450 * This is called to unpin the inode associated with the inode log
451 * item which was previously pinned with a call to xfs_inode_item_pin().
452 *
453 * Also wake up anyone in xfs_iunpin_wait() if the count goes to 0.
454 */
455 STATIC void
xfs_inode_item_unpin(struct xfs_log_item * lip,int remove)456 xfs_inode_item_unpin(
457 struct xfs_log_item *lip,
458 int remove)
459 {
460 struct xfs_inode *ip = INODE_ITEM(lip)->ili_inode;
461
462 trace_xfs_inode_unpin(ip, _RET_IP_);
463 ASSERT(atomic_read(&ip->i_pincount) > 0);
464 if (atomic_dec_and_test(&ip->i_pincount))
465 wake_up_bit(&ip->i_flags, __XFS_IPINNED_BIT);
466 }
467
468 /*
469 * Callback used to mark a buffer with XFS_LI_FAILED when items in the buffer
470 * have been failed during writeback
471 *
472 * This informs the AIL that the inode is already flush locked on the next push,
473 * and acquires a hold on the buffer to ensure that it isn't reclaimed before
474 * dirty data makes it to disk.
475 */
476 STATIC void
xfs_inode_item_error(struct xfs_log_item * lip,struct xfs_buf * bp)477 xfs_inode_item_error(
478 struct xfs_log_item *lip,
479 struct xfs_buf *bp)
480 {
481 ASSERT(xfs_isiflocked(INODE_ITEM(lip)->ili_inode));
482 xfs_set_li_failed(lip, bp);
483 }
484
485 STATIC uint
xfs_inode_item_push(struct xfs_log_item * lip,struct list_head * buffer_list)486 xfs_inode_item_push(
487 struct xfs_log_item *lip,
488 struct list_head *buffer_list)
489 __releases(&lip->li_ailp->ail_lock)
490 __acquires(&lip->li_ailp->ail_lock)
491 {
492 struct xfs_inode_log_item *iip = INODE_ITEM(lip);
493 struct xfs_inode *ip = iip->ili_inode;
494 struct xfs_buf *bp = lip->li_buf;
495 uint rval = XFS_ITEM_SUCCESS;
496 int error;
497
498 if (xfs_ipincount(ip) > 0)
499 return XFS_ITEM_PINNED;
500
501 /*
502 * The buffer containing this item failed to be written back
503 * previously. Resubmit the buffer for IO.
504 */
505 if (test_bit(XFS_LI_FAILED, &lip->li_flags)) {
506 if (!xfs_buf_trylock(bp))
507 return XFS_ITEM_LOCKED;
508
509 if (!xfs_buf_resubmit_failed_buffers(bp, buffer_list))
510 rval = XFS_ITEM_FLUSHING;
511
512 xfs_buf_unlock(bp);
513 return rval;
514 }
515
516 if (!xfs_ilock_nowait(ip, XFS_ILOCK_SHARED))
517 return XFS_ITEM_LOCKED;
518
519 /*
520 * Re-check the pincount now that we stabilized the value by
521 * taking the ilock.
522 */
523 if (xfs_ipincount(ip) > 0) {
524 rval = XFS_ITEM_PINNED;
525 goto out_unlock;
526 }
527
528 /*
529 * Stale inode items should force out the iclog.
530 */
531 if (ip->i_flags & XFS_ISTALE) {
532 rval = XFS_ITEM_PINNED;
533 goto out_unlock;
534 }
535
536 /*
537 * Someone else is already flushing the inode. Nothing we can do
538 * here but wait for the flush to finish and remove the item from
539 * the AIL.
540 */
541 if (!xfs_iflock_nowait(ip)) {
542 rval = XFS_ITEM_FLUSHING;
543 goto out_unlock;
544 }
545
546 ASSERT(iip->ili_fields != 0 || XFS_FORCED_SHUTDOWN(ip->i_mount));
547 ASSERT(iip->ili_logged == 0 || XFS_FORCED_SHUTDOWN(ip->i_mount));
548
549 spin_unlock(&lip->li_ailp->ail_lock);
550
551 error = xfs_iflush(ip, &bp);
552 if (!error) {
553 if (!xfs_buf_delwri_queue(bp, buffer_list))
554 rval = XFS_ITEM_FLUSHING;
555 xfs_buf_relse(bp);
556 }
557
558 spin_lock(&lip->li_ailp->ail_lock);
559 out_unlock:
560 xfs_iunlock(ip, XFS_ILOCK_SHARED);
561 return rval;
562 }
563
564 /*
565 * Unlock the inode associated with the inode log item.
566 */
567 STATIC void
xfs_inode_item_release(struct xfs_log_item * lip)568 xfs_inode_item_release(
569 struct xfs_log_item *lip)
570 {
571 struct xfs_inode_log_item *iip = INODE_ITEM(lip);
572 struct xfs_inode *ip = iip->ili_inode;
573 unsigned short lock_flags;
574
575 ASSERT(ip->i_itemp != NULL);
576 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
577
578 lock_flags = iip->ili_lock_flags;
579 iip->ili_lock_flags = 0;
580 if (lock_flags)
581 xfs_iunlock(ip, lock_flags);
582 }
583
584 /*
585 * This is called to find out where the oldest active copy of the inode log
586 * item in the on disk log resides now that the last log write of it completed
587 * at the given lsn. Since we always re-log all dirty data in an inode, the
588 * latest copy in the on disk log is the only one that matters. Therefore,
589 * simply return the given lsn.
590 *
591 * If the inode has been marked stale because the cluster is being freed, we
592 * don't want to (re-)insert this inode into the AIL. There is a race condition
593 * where the cluster buffer may be unpinned before the inode is inserted into
594 * the AIL during transaction committed processing. If the buffer is unpinned
595 * before the inode item has been committed and inserted, then it is possible
596 * for the buffer to be written and IO completes before the inode is inserted
597 * into the AIL. In that case, we'd be inserting a clean, stale inode into the
598 * AIL which will never get removed. It will, however, get reclaimed which
599 * triggers an assert in xfs_inode_free() complaining about freein an inode
600 * still in the AIL.
601 *
602 * To avoid this, just unpin the inode directly and return a LSN of -1 so the
603 * transaction committed code knows that it does not need to do any further
604 * processing on the item.
605 */
606 STATIC xfs_lsn_t
xfs_inode_item_committed(struct xfs_log_item * lip,xfs_lsn_t lsn)607 xfs_inode_item_committed(
608 struct xfs_log_item *lip,
609 xfs_lsn_t lsn)
610 {
611 struct xfs_inode_log_item *iip = INODE_ITEM(lip);
612 struct xfs_inode *ip = iip->ili_inode;
613
614 if (xfs_iflags_test(ip, XFS_ISTALE)) {
615 xfs_inode_item_unpin(lip, 0);
616 return -1;
617 }
618 return lsn;
619 }
620
621 STATIC void
xfs_inode_item_committing(struct xfs_log_item * lip,xfs_lsn_t commit_lsn)622 xfs_inode_item_committing(
623 struct xfs_log_item *lip,
624 xfs_lsn_t commit_lsn)
625 {
626 INODE_ITEM(lip)->ili_last_lsn = commit_lsn;
627 return xfs_inode_item_release(lip);
628 }
629
630 static const struct xfs_item_ops xfs_inode_item_ops = {
631 .iop_size = xfs_inode_item_size,
632 .iop_format = xfs_inode_item_format,
633 .iop_pin = xfs_inode_item_pin,
634 .iop_unpin = xfs_inode_item_unpin,
635 .iop_release = xfs_inode_item_release,
636 .iop_committed = xfs_inode_item_committed,
637 .iop_push = xfs_inode_item_push,
638 .iop_committing = xfs_inode_item_committing,
639 .iop_error = xfs_inode_item_error
640 };
641
642
643 /*
644 * Initialize the inode log item for a newly allocated (in-core) inode.
645 */
646 void
xfs_inode_item_init(struct xfs_inode * ip,struct xfs_mount * mp)647 xfs_inode_item_init(
648 struct xfs_inode *ip,
649 struct xfs_mount *mp)
650 {
651 struct xfs_inode_log_item *iip;
652
653 ASSERT(ip->i_itemp == NULL);
654 iip = ip->i_itemp = kmem_zone_zalloc(xfs_ili_zone, 0);
655
656 iip->ili_inode = ip;
657 xfs_log_item_init(mp, &iip->ili_item, XFS_LI_INODE,
658 &xfs_inode_item_ops);
659 }
660
661 /*
662 * Free the inode log item and any memory hanging off of it.
663 */
664 void
xfs_inode_item_destroy(xfs_inode_t * ip)665 xfs_inode_item_destroy(
666 xfs_inode_t *ip)
667 {
668 kmem_free(ip->i_itemp->ili_item.li_lv_shadow);
669 kmem_zone_free(xfs_ili_zone, ip->i_itemp);
670 }
671
672
673 /*
674 * This is the inode flushing I/O completion routine. It is called
675 * from interrupt level when the buffer containing the inode is
676 * flushed to disk. It is responsible for removing the inode item
677 * from the AIL if it has not been re-logged, and unlocking the inode's
678 * flush lock.
679 *
680 * To reduce AIL lock traffic as much as possible, we scan the buffer log item
681 * list for other inodes that will run this function. We remove them from the
682 * buffer list so we can process all the inode IO completions in one AIL lock
683 * traversal.
684 */
685 void
xfs_iflush_done(struct xfs_buf * bp,struct xfs_log_item * lip)686 xfs_iflush_done(
687 struct xfs_buf *bp,
688 struct xfs_log_item *lip)
689 {
690 struct xfs_inode_log_item *iip;
691 struct xfs_log_item *blip, *n;
692 struct xfs_ail *ailp = lip->li_ailp;
693 int need_ail = 0;
694 LIST_HEAD(tmp);
695
696 /*
697 * Scan the buffer IO completions for other inodes being completed and
698 * attach them to the current inode log item.
699 */
700
701 list_add_tail(&lip->li_bio_list, &tmp);
702
703 list_for_each_entry_safe(blip, n, &bp->b_li_list, li_bio_list) {
704 if (lip->li_cb != xfs_iflush_done)
705 continue;
706
707 list_move_tail(&blip->li_bio_list, &tmp);
708 /*
709 * while we have the item, do the unlocked check for needing
710 * the AIL lock.
711 */
712 iip = INODE_ITEM(blip);
713 if ((iip->ili_logged && blip->li_lsn == iip->ili_flush_lsn) ||
714 test_bit(XFS_LI_FAILED, &blip->li_flags))
715 need_ail++;
716 }
717
718 /* make sure we capture the state of the initial inode. */
719 iip = INODE_ITEM(lip);
720 if ((iip->ili_logged && lip->li_lsn == iip->ili_flush_lsn) ||
721 test_bit(XFS_LI_FAILED, &lip->li_flags))
722 need_ail++;
723
724 /*
725 * We only want to pull the item from the AIL if it is
726 * actually there and its location in the log has not
727 * changed since we started the flush. Thus, we only bother
728 * if the ili_logged flag is set and the inode's lsn has not
729 * changed. First we check the lsn outside
730 * the lock since it's cheaper, and then we recheck while
731 * holding the lock before removing the inode from the AIL.
732 */
733 if (need_ail) {
734 bool mlip_changed = false;
735
736 /* this is an opencoded batch version of xfs_trans_ail_delete */
737 spin_lock(&ailp->ail_lock);
738 list_for_each_entry(blip, &tmp, li_bio_list) {
739 if (INODE_ITEM(blip)->ili_logged &&
740 blip->li_lsn == INODE_ITEM(blip)->ili_flush_lsn)
741 mlip_changed |= xfs_ail_delete_one(ailp, blip);
742 else {
743 xfs_clear_li_failed(blip);
744 }
745 }
746
747 if (mlip_changed) {
748 if (!XFS_FORCED_SHUTDOWN(ailp->ail_mount))
749 xlog_assign_tail_lsn_locked(ailp->ail_mount);
750 if (list_empty(&ailp->ail_head))
751 wake_up_all(&ailp->ail_empty);
752 }
753 spin_unlock(&ailp->ail_lock);
754
755 if (mlip_changed)
756 xfs_log_space_wake(ailp->ail_mount);
757 }
758
759 /*
760 * clean up and unlock the flush lock now we are done. We can clear the
761 * ili_last_fields bits now that we know that the data corresponding to
762 * them is safely on disk.
763 */
764 list_for_each_entry_safe(blip, n, &tmp, li_bio_list) {
765 list_del_init(&blip->li_bio_list);
766 iip = INODE_ITEM(blip);
767 iip->ili_logged = 0;
768 iip->ili_last_fields = 0;
769 xfs_ifunlock(iip->ili_inode);
770 }
771 list_del(&tmp);
772 }
773
774 /*
775 * This is the inode flushing abort routine. It is called from xfs_iflush when
776 * the filesystem is shutting down to clean up the inode state. It is
777 * responsible for removing the inode item from the AIL if it has not been
778 * re-logged, and unlocking the inode's flush lock.
779 */
780 void
xfs_iflush_abort(xfs_inode_t * ip,bool stale)781 xfs_iflush_abort(
782 xfs_inode_t *ip,
783 bool stale)
784 {
785 xfs_inode_log_item_t *iip = ip->i_itemp;
786
787 if (iip) {
788 if (test_bit(XFS_LI_IN_AIL, &iip->ili_item.li_flags)) {
789 xfs_trans_ail_remove(&iip->ili_item,
790 stale ? SHUTDOWN_LOG_IO_ERROR :
791 SHUTDOWN_CORRUPT_INCORE);
792 }
793 iip->ili_logged = 0;
794 /*
795 * Clear the ili_last_fields bits now that we know that the
796 * data corresponding to them is safely on disk.
797 */
798 iip->ili_last_fields = 0;
799 /*
800 * Clear the inode logging fields so no more flushes are
801 * attempted.
802 */
803 iip->ili_fields = 0;
804 iip->ili_fsync_fields = 0;
805 }
806 /*
807 * Release the inode's flush lock since we're done with it.
808 */
809 xfs_ifunlock(ip);
810 }
811
812 void
xfs_istale_done(struct xfs_buf * bp,struct xfs_log_item * lip)813 xfs_istale_done(
814 struct xfs_buf *bp,
815 struct xfs_log_item *lip)
816 {
817 xfs_iflush_abort(INODE_ITEM(lip)->ili_inode, true);
818 }
819
820 /*
821 * convert an xfs_inode_log_format struct from the old 32 bit version
822 * (which can have different field alignments) to the native 64 bit version
823 */
824 int
xfs_inode_item_format_convert(struct xfs_log_iovec * buf,struct xfs_inode_log_format * in_f)825 xfs_inode_item_format_convert(
826 struct xfs_log_iovec *buf,
827 struct xfs_inode_log_format *in_f)
828 {
829 struct xfs_inode_log_format_32 *in_f32 = buf->i_addr;
830
831 if (buf->i_len != sizeof(*in_f32))
832 return -EFSCORRUPTED;
833
834 in_f->ilf_type = in_f32->ilf_type;
835 in_f->ilf_size = in_f32->ilf_size;
836 in_f->ilf_fields = in_f32->ilf_fields;
837 in_f->ilf_asize = in_f32->ilf_asize;
838 in_f->ilf_dsize = in_f32->ilf_dsize;
839 in_f->ilf_ino = in_f32->ilf_ino;
840 memcpy(&in_f->ilf_u, &in_f32->ilf_u, sizeof(in_f->ilf_u));
841 in_f->ilf_blkno = in_f32->ilf_blkno;
842 in_f->ilf_len = in_f32->ilf_len;
843 in_f->ilf_boffset = in_f32->ilf_boffset;
844 return 0;
845 }
846