Merge tag 'irqchip-fixes-5.4-2' of git://git.kernel.org/pub/scm/linux/kernel/git...
[platform/kernel/linux-rpi.git] / fs / xfs / xfs_inode_item.c
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 }