Merge tag 'mips_fixes_5.2_1' of git://git.kernel.org/pub/scm/linux/kernel/git/mips...
[linux-2.6-microblaze.git] / fs / xfs / xfs_inode.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (c) 2000-2006 Silicon Graphics, Inc.
4  * All Rights Reserved.
5  */
6 #include <linux/log2.h>
7 #include <linux/iversion.h>
8
9 #include "xfs.h"
10 #include "xfs_fs.h"
11 #include "xfs_shared.h"
12 #include "xfs_format.h"
13 #include "xfs_log_format.h"
14 #include "xfs_trans_resv.h"
15 #include "xfs_sb.h"
16 #include "xfs_mount.h"
17 #include "xfs_defer.h"
18 #include "xfs_inode.h"
19 #include "xfs_da_format.h"
20 #include "xfs_da_btree.h"
21 #include "xfs_dir2.h"
22 #include "xfs_attr_sf.h"
23 #include "xfs_attr.h"
24 #include "xfs_trans_space.h"
25 #include "xfs_trans.h"
26 #include "xfs_buf_item.h"
27 #include "xfs_inode_item.h"
28 #include "xfs_ialloc.h"
29 #include "xfs_bmap.h"
30 #include "xfs_bmap_util.h"
31 #include "xfs_errortag.h"
32 #include "xfs_error.h"
33 #include "xfs_quota.h"
34 #include "xfs_filestream.h"
35 #include "xfs_cksum.h"
36 #include "xfs_trace.h"
37 #include "xfs_icache.h"
38 #include "xfs_symlink.h"
39 #include "xfs_trans_priv.h"
40 #include "xfs_log.h"
41 #include "xfs_bmap_btree.h"
42 #include "xfs_reflink.h"
43 #include "xfs_dir2_priv.h"
44
45 kmem_zone_t *xfs_inode_zone;
46
47 /*
48  * Used in xfs_itruncate_extents().  This is the maximum number of extents
49  * freed from a file in a single transaction.
50  */
51 #define XFS_ITRUNC_MAX_EXTENTS  2
52
53 STATIC int xfs_iflush_int(struct xfs_inode *, struct xfs_buf *);
54 STATIC int xfs_iunlink(struct xfs_trans *, struct xfs_inode *);
55 STATIC int xfs_iunlink_remove(struct xfs_trans *, struct xfs_inode *);
56
57 /*
58  * helper function to extract extent size hint from inode
59  */
60 xfs_extlen_t
61 xfs_get_extsz_hint(
62         struct xfs_inode        *ip)
63 {
64         if ((ip->i_d.di_flags & XFS_DIFLAG_EXTSIZE) && ip->i_d.di_extsize)
65                 return ip->i_d.di_extsize;
66         if (XFS_IS_REALTIME_INODE(ip))
67                 return ip->i_mount->m_sb.sb_rextsize;
68         return 0;
69 }
70
71 /*
72  * Helper function to extract CoW extent size hint from inode.
73  * Between the extent size hint and the CoW extent size hint, we
74  * return the greater of the two.  If the value is zero (automatic),
75  * use the default size.
76  */
77 xfs_extlen_t
78 xfs_get_cowextsz_hint(
79         struct xfs_inode        *ip)
80 {
81         xfs_extlen_t            a, b;
82
83         a = 0;
84         if (ip->i_d.di_flags2 & XFS_DIFLAG2_COWEXTSIZE)
85                 a = ip->i_d.di_cowextsize;
86         b = xfs_get_extsz_hint(ip);
87
88         a = max(a, b);
89         if (a == 0)
90                 return XFS_DEFAULT_COWEXTSZ_HINT;
91         return a;
92 }
93
94 /*
95  * These two are wrapper routines around the xfs_ilock() routine used to
96  * centralize some grungy code.  They are used in places that wish to lock the
97  * inode solely for reading the extents.  The reason these places can't just
98  * call xfs_ilock(ip, XFS_ILOCK_SHARED) is that the inode lock also guards to
99  * bringing in of the extents from disk for a file in b-tree format.  If the
100  * inode is in b-tree format, then we need to lock the inode exclusively until
101  * the extents are read in.  Locking it exclusively all the time would limit
102  * our parallelism unnecessarily, though.  What we do instead is check to see
103  * if the extents have been read in yet, and only lock the inode exclusively
104  * if they have not.
105  *
106  * The functions return a value which should be given to the corresponding
107  * xfs_iunlock() call.
108  */
109 uint
110 xfs_ilock_data_map_shared(
111         struct xfs_inode        *ip)
112 {
113         uint                    lock_mode = XFS_ILOCK_SHARED;
114
115         if (ip->i_d.di_format == XFS_DINODE_FMT_BTREE &&
116             (ip->i_df.if_flags & XFS_IFEXTENTS) == 0)
117                 lock_mode = XFS_ILOCK_EXCL;
118         xfs_ilock(ip, lock_mode);
119         return lock_mode;
120 }
121
122 uint
123 xfs_ilock_attr_map_shared(
124         struct xfs_inode        *ip)
125 {
126         uint                    lock_mode = XFS_ILOCK_SHARED;
127
128         if (ip->i_d.di_aformat == XFS_DINODE_FMT_BTREE &&
129             (ip->i_afp->if_flags & XFS_IFEXTENTS) == 0)
130                 lock_mode = XFS_ILOCK_EXCL;
131         xfs_ilock(ip, lock_mode);
132         return lock_mode;
133 }
134
135 /*
136  * In addition to i_rwsem in the VFS inode, the xfs inode contains 2
137  * multi-reader locks: i_mmap_lock and the i_lock.  This routine allows
138  * various combinations of the locks to be obtained.
139  *
140  * The 3 locks should always be ordered so that the IO lock is obtained first,
141  * the mmap lock second and the ilock last in order to prevent deadlock.
142  *
143  * Basic locking order:
144  *
145  * i_rwsem -> i_mmap_lock -> page_lock -> i_ilock
146  *
147  * mmap_sem locking order:
148  *
149  * i_rwsem -> page lock -> mmap_sem
150  * mmap_sem -> i_mmap_lock -> page_lock
151  *
152  * The difference in mmap_sem locking order mean that we cannot hold the
153  * i_mmap_lock over syscall based read(2)/write(2) based IO. These IO paths can
154  * fault in pages during copy in/out (for buffered IO) or require the mmap_sem
155  * in get_user_pages() to map the user pages into the kernel address space for
156  * direct IO. Similarly the i_rwsem cannot be taken inside a page fault because
157  * page faults already hold the mmap_sem.
158  *
159  * Hence to serialise fully against both syscall and mmap based IO, we need to
160  * take both the i_rwsem and the i_mmap_lock. These locks should *only* be both
161  * taken in places where we need to invalidate the page cache in a race
162  * free manner (e.g. truncate, hole punch and other extent manipulation
163  * functions).
164  */
165 void
166 xfs_ilock(
167         xfs_inode_t             *ip,
168         uint                    lock_flags)
169 {
170         trace_xfs_ilock(ip, lock_flags, _RET_IP_);
171
172         /*
173          * You can't set both SHARED and EXCL for the same lock,
174          * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
175          * and XFS_ILOCK_EXCL are valid values to set in lock_flags.
176          */
177         ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
178                (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
179         ASSERT((lock_flags & (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL)) !=
180                (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL));
181         ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
182                (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
183         ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_SUBCLASS_MASK)) == 0);
184
185         if (lock_flags & XFS_IOLOCK_EXCL) {
186                 down_write_nested(&VFS_I(ip)->i_rwsem,
187                                   XFS_IOLOCK_DEP(lock_flags));
188         } else if (lock_flags & XFS_IOLOCK_SHARED) {
189                 down_read_nested(&VFS_I(ip)->i_rwsem,
190                                  XFS_IOLOCK_DEP(lock_flags));
191         }
192
193         if (lock_flags & XFS_MMAPLOCK_EXCL)
194                 mrupdate_nested(&ip->i_mmaplock, XFS_MMAPLOCK_DEP(lock_flags));
195         else if (lock_flags & XFS_MMAPLOCK_SHARED)
196                 mraccess_nested(&ip->i_mmaplock, XFS_MMAPLOCK_DEP(lock_flags));
197
198         if (lock_flags & XFS_ILOCK_EXCL)
199                 mrupdate_nested(&ip->i_lock, XFS_ILOCK_DEP(lock_flags));
200         else if (lock_flags & XFS_ILOCK_SHARED)
201                 mraccess_nested(&ip->i_lock, XFS_ILOCK_DEP(lock_flags));
202 }
203
204 /*
205  * This is just like xfs_ilock(), except that the caller
206  * is guaranteed not to sleep.  It returns 1 if it gets
207  * the requested locks and 0 otherwise.  If the IO lock is
208  * obtained but the inode lock cannot be, then the IO lock
209  * is dropped before returning.
210  *
211  * ip -- the inode being locked
212  * lock_flags -- this parameter indicates the inode's locks to be
213  *       to be locked.  See the comment for xfs_ilock() for a list
214  *       of valid values.
215  */
216 int
217 xfs_ilock_nowait(
218         xfs_inode_t             *ip,
219         uint                    lock_flags)
220 {
221         trace_xfs_ilock_nowait(ip, lock_flags, _RET_IP_);
222
223         /*
224          * You can't set both SHARED and EXCL for the same lock,
225          * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
226          * and XFS_ILOCK_EXCL are valid values to set in lock_flags.
227          */
228         ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
229                (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
230         ASSERT((lock_flags & (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL)) !=
231                (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL));
232         ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
233                (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
234         ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_SUBCLASS_MASK)) == 0);
235
236         if (lock_flags & XFS_IOLOCK_EXCL) {
237                 if (!down_write_trylock(&VFS_I(ip)->i_rwsem))
238                         goto out;
239         } else if (lock_flags & XFS_IOLOCK_SHARED) {
240                 if (!down_read_trylock(&VFS_I(ip)->i_rwsem))
241                         goto out;
242         }
243
244         if (lock_flags & XFS_MMAPLOCK_EXCL) {
245                 if (!mrtryupdate(&ip->i_mmaplock))
246                         goto out_undo_iolock;
247         } else if (lock_flags & XFS_MMAPLOCK_SHARED) {
248                 if (!mrtryaccess(&ip->i_mmaplock))
249                         goto out_undo_iolock;
250         }
251
252         if (lock_flags & XFS_ILOCK_EXCL) {
253                 if (!mrtryupdate(&ip->i_lock))
254                         goto out_undo_mmaplock;
255         } else if (lock_flags & XFS_ILOCK_SHARED) {
256                 if (!mrtryaccess(&ip->i_lock))
257                         goto out_undo_mmaplock;
258         }
259         return 1;
260
261 out_undo_mmaplock:
262         if (lock_flags & XFS_MMAPLOCK_EXCL)
263                 mrunlock_excl(&ip->i_mmaplock);
264         else if (lock_flags & XFS_MMAPLOCK_SHARED)
265                 mrunlock_shared(&ip->i_mmaplock);
266 out_undo_iolock:
267         if (lock_flags & XFS_IOLOCK_EXCL)
268                 up_write(&VFS_I(ip)->i_rwsem);
269         else if (lock_flags & XFS_IOLOCK_SHARED)
270                 up_read(&VFS_I(ip)->i_rwsem);
271 out:
272         return 0;
273 }
274
275 /*
276  * xfs_iunlock() is used to drop the inode locks acquired with
277  * xfs_ilock() and xfs_ilock_nowait().  The caller must pass
278  * in the flags given to xfs_ilock() or xfs_ilock_nowait() so
279  * that we know which locks to drop.
280  *
281  * ip -- the inode being unlocked
282  * lock_flags -- this parameter indicates the inode's locks to be
283  *       to be unlocked.  See the comment for xfs_ilock() for a list
284  *       of valid values for this parameter.
285  *
286  */
287 void
288 xfs_iunlock(
289         xfs_inode_t             *ip,
290         uint                    lock_flags)
291 {
292         /*
293          * You can't set both SHARED and EXCL for the same lock,
294          * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
295          * and XFS_ILOCK_EXCL are valid values to set in lock_flags.
296          */
297         ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
298                (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
299         ASSERT((lock_flags & (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL)) !=
300                (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL));
301         ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
302                (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
303         ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_SUBCLASS_MASK)) == 0);
304         ASSERT(lock_flags != 0);
305
306         if (lock_flags & XFS_IOLOCK_EXCL)
307                 up_write(&VFS_I(ip)->i_rwsem);
308         else if (lock_flags & XFS_IOLOCK_SHARED)
309                 up_read(&VFS_I(ip)->i_rwsem);
310
311         if (lock_flags & XFS_MMAPLOCK_EXCL)
312                 mrunlock_excl(&ip->i_mmaplock);
313         else if (lock_flags & XFS_MMAPLOCK_SHARED)
314                 mrunlock_shared(&ip->i_mmaplock);
315
316         if (lock_flags & XFS_ILOCK_EXCL)
317                 mrunlock_excl(&ip->i_lock);
318         else if (lock_flags & XFS_ILOCK_SHARED)
319                 mrunlock_shared(&ip->i_lock);
320
321         trace_xfs_iunlock(ip, lock_flags, _RET_IP_);
322 }
323
324 /*
325  * give up write locks.  the i/o lock cannot be held nested
326  * if it is being demoted.
327  */
328 void
329 xfs_ilock_demote(
330         xfs_inode_t             *ip,
331         uint                    lock_flags)
332 {
333         ASSERT(lock_flags & (XFS_IOLOCK_EXCL|XFS_MMAPLOCK_EXCL|XFS_ILOCK_EXCL));
334         ASSERT((lock_flags &
335                 ~(XFS_IOLOCK_EXCL|XFS_MMAPLOCK_EXCL|XFS_ILOCK_EXCL)) == 0);
336
337         if (lock_flags & XFS_ILOCK_EXCL)
338                 mrdemote(&ip->i_lock);
339         if (lock_flags & XFS_MMAPLOCK_EXCL)
340                 mrdemote(&ip->i_mmaplock);
341         if (lock_flags & XFS_IOLOCK_EXCL)
342                 downgrade_write(&VFS_I(ip)->i_rwsem);
343
344         trace_xfs_ilock_demote(ip, lock_flags, _RET_IP_);
345 }
346
347 #if defined(DEBUG) || defined(XFS_WARN)
348 int
349 xfs_isilocked(
350         xfs_inode_t             *ip,
351         uint                    lock_flags)
352 {
353         if (lock_flags & (XFS_ILOCK_EXCL|XFS_ILOCK_SHARED)) {
354                 if (!(lock_flags & XFS_ILOCK_SHARED))
355                         return !!ip->i_lock.mr_writer;
356                 return rwsem_is_locked(&ip->i_lock.mr_lock);
357         }
358
359         if (lock_flags & (XFS_MMAPLOCK_EXCL|XFS_MMAPLOCK_SHARED)) {
360                 if (!(lock_flags & XFS_MMAPLOCK_SHARED))
361                         return !!ip->i_mmaplock.mr_writer;
362                 return rwsem_is_locked(&ip->i_mmaplock.mr_lock);
363         }
364
365         if (lock_flags & (XFS_IOLOCK_EXCL|XFS_IOLOCK_SHARED)) {
366                 if (!(lock_flags & XFS_IOLOCK_SHARED))
367                         return !debug_locks ||
368                                 lockdep_is_held_type(&VFS_I(ip)->i_rwsem, 0);
369                 return rwsem_is_locked(&VFS_I(ip)->i_rwsem);
370         }
371
372         ASSERT(0);
373         return 0;
374 }
375 #endif
376
377 /*
378  * xfs_lockdep_subclass_ok() is only used in an ASSERT, so is only called when
379  * DEBUG or XFS_WARN is set. And MAX_LOCKDEP_SUBCLASSES is then only defined
380  * when CONFIG_LOCKDEP is set. Hence the complex define below to avoid build
381  * errors and warnings.
382  */
383 #if (defined(DEBUG) || defined(XFS_WARN)) && defined(CONFIG_LOCKDEP)
384 static bool
385 xfs_lockdep_subclass_ok(
386         int subclass)
387 {
388         return subclass < MAX_LOCKDEP_SUBCLASSES;
389 }
390 #else
391 #define xfs_lockdep_subclass_ok(subclass)       (true)
392 #endif
393
394 /*
395  * Bump the subclass so xfs_lock_inodes() acquires each lock with a different
396  * value. This can be called for any type of inode lock combination, including
397  * parent locking. Care must be taken to ensure we don't overrun the subclass
398  * storage fields in the class mask we build.
399  */
400 static inline int
401 xfs_lock_inumorder(int lock_mode, int subclass)
402 {
403         int     class = 0;
404
405         ASSERT(!(lock_mode & (XFS_ILOCK_PARENT | XFS_ILOCK_RTBITMAP |
406                               XFS_ILOCK_RTSUM)));
407         ASSERT(xfs_lockdep_subclass_ok(subclass));
408
409         if (lock_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL)) {
410                 ASSERT(subclass <= XFS_IOLOCK_MAX_SUBCLASS);
411                 class += subclass << XFS_IOLOCK_SHIFT;
412         }
413
414         if (lock_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)) {
415                 ASSERT(subclass <= XFS_MMAPLOCK_MAX_SUBCLASS);
416                 class += subclass << XFS_MMAPLOCK_SHIFT;
417         }
418
419         if (lock_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)) {
420                 ASSERT(subclass <= XFS_ILOCK_MAX_SUBCLASS);
421                 class += subclass << XFS_ILOCK_SHIFT;
422         }
423
424         return (lock_mode & ~XFS_LOCK_SUBCLASS_MASK) | class;
425 }
426
427 /*
428  * The following routine will lock n inodes in exclusive mode.  We assume the
429  * caller calls us with the inodes in i_ino order.
430  *
431  * We need to detect deadlock where an inode that we lock is in the AIL and we
432  * start waiting for another inode that is locked by a thread in a long running
433  * transaction (such as truncate). This can result in deadlock since the long
434  * running trans might need to wait for the inode we just locked in order to
435  * push the tail and free space in the log.
436  *
437  * xfs_lock_inodes() can only be used to lock one type of lock at a time -
438  * the iolock, the mmaplock or the ilock, but not more than one at a time. If we
439  * lock more than one at a time, lockdep will report false positives saying we
440  * have violated locking orders.
441  */
442 static void
443 xfs_lock_inodes(
444         xfs_inode_t     **ips,
445         int             inodes,
446         uint            lock_mode)
447 {
448         int             attempts = 0, i, j, try_lock;
449         xfs_log_item_t  *lp;
450
451         /*
452          * Currently supports between 2 and 5 inodes with exclusive locking.  We
453          * support an arbitrary depth of locking here, but absolute limits on
454          * inodes depend on the the type of locking and the limits placed by
455          * lockdep annotations in xfs_lock_inumorder.  These are all checked by
456          * the asserts.
457          */
458         ASSERT(ips && inodes >= 2 && inodes <= 5);
459         ASSERT(lock_mode & (XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL |
460                             XFS_ILOCK_EXCL));
461         ASSERT(!(lock_mode & (XFS_IOLOCK_SHARED | XFS_MMAPLOCK_SHARED |
462                               XFS_ILOCK_SHARED)));
463         ASSERT(!(lock_mode & XFS_MMAPLOCK_EXCL) ||
464                 inodes <= XFS_MMAPLOCK_MAX_SUBCLASS + 1);
465         ASSERT(!(lock_mode & XFS_ILOCK_EXCL) ||
466                 inodes <= XFS_ILOCK_MAX_SUBCLASS + 1);
467
468         if (lock_mode & XFS_IOLOCK_EXCL) {
469                 ASSERT(!(lock_mode & (XFS_MMAPLOCK_EXCL | XFS_ILOCK_EXCL)));
470         } else if (lock_mode & XFS_MMAPLOCK_EXCL)
471                 ASSERT(!(lock_mode & XFS_ILOCK_EXCL));
472
473         try_lock = 0;
474         i = 0;
475 again:
476         for (; i < inodes; i++) {
477                 ASSERT(ips[i]);
478
479                 if (i && (ips[i] == ips[i - 1]))        /* Already locked */
480                         continue;
481
482                 /*
483                  * If try_lock is not set yet, make sure all locked inodes are
484                  * not in the AIL.  If any are, set try_lock to be used later.
485                  */
486                 if (!try_lock) {
487                         for (j = (i - 1); j >= 0 && !try_lock; j--) {
488                                 lp = (xfs_log_item_t *)ips[j]->i_itemp;
489                                 if (lp && test_bit(XFS_LI_IN_AIL, &lp->li_flags))
490                                         try_lock++;
491                         }
492                 }
493
494                 /*
495                  * If any of the previous locks we have locked is in the AIL,
496                  * we must TRY to get the second and subsequent locks. If
497                  * we can't get any, we must release all we have
498                  * and try again.
499                  */
500                 if (!try_lock) {
501                         xfs_ilock(ips[i], xfs_lock_inumorder(lock_mode, i));
502                         continue;
503                 }
504
505                 /* try_lock means we have an inode locked that is in the AIL. */
506                 ASSERT(i != 0);
507                 if (xfs_ilock_nowait(ips[i], xfs_lock_inumorder(lock_mode, i)))
508                         continue;
509
510                 /*
511                  * Unlock all previous guys and try again.  xfs_iunlock will try
512                  * to push the tail if the inode is in the AIL.
513                  */
514                 attempts++;
515                 for (j = i - 1; j >= 0; j--) {
516                         /*
517                          * Check to see if we've already unlocked this one.  Not
518                          * the first one going back, and the inode ptr is the
519                          * same.
520                          */
521                         if (j != (i - 1) && ips[j] == ips[j + 1])
522                                 continue;
523
524                         xfs_iunlock(ips[j], lock_mode);
525                 }
526
527                 if ((attempts % 5) == 0) {
528                         delay(1); /* Don't just spin the CPU */
529                 }
530                 i = 0;
531                 try_lock = 0;
532                 goto again;
533         }
534 }
535
536 /*
537  * xfs_lock_two_inodes() can only be used to lock one type of lock at a time -
538  * the mmaplock or the ilock, but not more than one type at a time. If we lock
539  * more than one at a time, lockdep will report false positives saying we have
540  * violated locking orders.  The iolock must be double-locked separately since
541  * we use i_rwsem for that.  We now support taking one lock EXCL and the other
542  * SHARED.
543  */
544 void
545 xfs_lock_two_inodes(
546         struct xfs_inode        *ip0,
547         uint                    ip0_mode,
548         struct xfs_inode        *ip1,
549         uint                    ip1_mode)
550 {
551         struct xfs_inode        *temp;
552         uint                    mode_temp;
553         int                     attempts = 0;
554         xfs_log_item_t          *lp;
555
556         ASSERT(hweight32(ip0_mode) == 1);
557         ASSERT(hweight32(ip1_mode) == 1);
558         ASSERT(!(ip0_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL)));
559         ASSERT(!(ip1_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL)));
560         ASSERT(!(ip0_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)) ||
561                !(ip0_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)));
562         ASSERT(!(ip1_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)) ||
563                !(ip1_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)));
564         ASSERT(!(ip1_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)) ||
565                !(ip0_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)));
566         ASSERT(!(ip0_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)) ||
567                !(ip1_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)));
568
569         ASSERT(ip0->i_ino != ip1->i_ino);
570
571         if (ip0->i_ino > ip1->i_ino) {
572                 temp = ip0;
573                 ip0 = ip1;
574                 ip1 = temp;
575                 mode_temp = ip0_mode;
576                 ip0_mode = ip1_mode;
577                 ip1_mode = mode_temp;
578         }
579
580  again:
581         xfs_ilock(ip0, xfs_lock_inumorder(ip0_mode, 0));
582
583         /*
584          * If the first lock we have locked is in the AIL, we must TRY to get
585          * the second lock. If we can't get it, we must release the first one
586          * and try again.
587          */
588         lp = (xfs_log_item_t *)ip0->i_itemp;
589         if (lp && test_bit(XFS_LI_IN_AIL, &lp->li_flags)) {
590                 if (!xfs_ilock_nowait(ip1, xfs_lock_inumorder(ip1_mode, 1))) {
591                         xfs_iunlock(ip0, ip0_mode);
592                         if ((++attempts % 5) == 0)
593                                 delay(1); /* Don't just spin the CPU */
594                         goto again;
595                 }
596         } else {
597                 xfs_ilock(ip1, xfs_lock_inumorder(ip1_mode, 1));
598         }
599 }
600
601 void
602 __xfs_iflock(
603         struct xfs_inode        *ip)
604 {
605         wait_queue_head_t *wq = bit_waitqueue(&ip->i_flags, __XFS_IFLOCK_BIT);
606         DEFINE_WAIT_BIT(wait, &ip->i_flags, __XFS_IFLOCK_BIT);
607
608         do {
609                 prepare_to_wait_exclusive(wq, &wait.wq_entry, TASK_UNINTERRUPTIBLE);
610                 if (xfs_isiflocked(ip))
611                         io_schedule();
612         } while (!xfs_iflock_nowait(ip));
613
614         finish_wait(wq, &wait.wq_entry);
615 }
616
617 STATIC uint
618 _xfs_dic2xflags(
619         uint16_t                di_flags,
620         uint64_t                di_flags2,
621         bool                    has_attr)
622 {
623         uint                    flags = 0;
624
625         if (di_flags & XFS_DIFLAG_ANY) {
626                 if (di_flags & XFS_DIFLAG_REALTIME)
627                         flags |= FS_XFLAG_REALTIME;
628                 if (di_flags & XFS_DIFLAG_PREALLOC)
629                         flags |= FS_XFLAG_PREALLOC;
630                 if (di_flags & XFS_DIFLAG_IMMUTABLE)
631                         flags |= FS_XFLAG_IMMUTABLE;
632                 if (di_flags & XFS_DIFLAG_APPEND)
633                         flags |= FS_XFLAG_APPEND;
634                 if (di_flags & XFS_DIFLAG_SYNC)
635                         flags |= FS_XFLAG_SYNC;
636                 if (di_flags & XFS_DIFLAG_NOATIME)
637                         flags |= FS_XFLAG_NOATIME;
638                 if (di_flags & XFS_DIFLAG_NODUMP)
639                         flags |= FS_XFLAG_NODUMP;
640                 if (di_flags & XFS_DIFLAG_RTINHERIT)
641                         flags |= FS_XFLAG_RTINHERIT;
642                 if (di_flags & XFS_DIFLAG_PROJINHERIT)
643                         flags |= FS_XFLAG_PROJINHERIT;
644                 if (di_flags & XFS_DIFLAG_NOSYMLINKS)
645                         flags |= FS_XFLAG_NOSYMLINKS;
646                 if (di_flags & XFS_DIFLAG_EXTSIZE)
647                         flags |= FS_XFLAG_EXTSIZE;
648                 if (di_flags & XFS_DIFLAG_EXTSZINHERIT)
649                         flags |= FS_XFLAG_EXTSZINHERIT;
650                 if (di_flags & XFS_DIFLAG_NODEFRAG)
651                         flags |= FS_XFLAG_NODEFRAG;
652                 if (di_flags & XFS_DIFLAG_FILESTREAM)
653                         flags |= FS_XFLAG_FILESTREAM;
654         }
655
656         if (di_flags2 & XFS_DIFLAG2_ANY) {
657                 if (di_flags2 & XFS_DIFLAG2_DAX)
658                         flags |= FS_XFLAG_DAX;
659                 if (di_flags2 & XFS_DIFLAG2_COWEXTSIZE)
660                         flags |= FS_XFLAG_COWEXTSIZE;
661         }
662
663         if (has_attr)
664                 flags |= FS_XFLAG_HASATTR;
665
666         return flags;
667 }
668
669 uint
670 xfs_ip2xflags(
671         struct xfs_inode        *ip)
672 {
673         struct xfs_icdinode     *dic = &ip->i_d;
674
675         return _xfs_dic2xflags(dic->di_flags, dic->di_flags2, XFS_IFORK_Q(ip));
676 }
677
678 /*
679  * Lookups up an inode from "name". If ci_name is not NULL, then a CI match
680  * is allowed, otherwise it has to be an exact match. If a CI match is found,
681  * ci_name->name will point to a the actual name (caller must free) or
682  * will be set to NULL if an exact match is found.
683  */
684 int
685 xfs_lookup(
686         xfs_inode_t             *dp,
687         struct xfs_name         *name,
688         xfs_inode_t             **ipp,
689         struct xfs_name         *ci_name)
690 {
691         xfs_ino_t               inum;
692         int                     error;
693
694         trace_xfs_lookup(dp, name);
695
696         if (XFS_FORCED_SHUTDOWN(dp->i_mount))
697                 return -EIO;
698
699         error = xfs_dir_lookup(NULL, dp, name, &inum, ci_name);
700         if (error)
701                 goto out_unlock;
702
703         error = xfs_iget(dp->i_mount, NULL, inum, 0, 0, ipp);
704         if (error)
705                 goto out_free_name;
706
707         return 0;
708
709 out_free_name:
710         if (ci_name)
711                 kmem_free(ci_name->name);
712 out_unlock:
713         *ipp = NULL;
714         return error;
715 }
716
717 /*
718  * Allocate an inode on disk and return a copy of its in-core version.
719  * The in-core inode is locked exclusively.  Set mode, nlink, and rdev
720  * appropriately within the inode.  The uid and gid for the inode are
721  * set according to the contents of the given cred structure.
722  *
723  * Use xfs_dialloc() to allocate the on-disk inode. If xfs_dialloc()
724  * has a free inode available, call xfs_iget() to obtain the in-core
725  * version of the allocated inode.  Finally, fill in the inode and
726  * log its initial contents.  In this case, ialloc_context would be
727  * set to NULL.
728  *
729  * If xfs_dialloc() does not have an available inode, it will replenish
730  * its supply by doing an allocation. Since we can only do one
731  * allocation within a transaction without deadlocks, we must commit
732  * the current transaction before returning the inode itself.
733  * In this case, therefore, we will set ialloc_context and return.
734  * The caller should then commit the current transaction, start a new
735  * transaction, and call xfs_ialloc() again to actually get the inode.
736  *
737  * To ensure that some other process does not grab the inode that
738  * was allocated during the first call to xfs_ialloc(), this routine
739  * also returns the [locked] bp pointing to the head of the freelist
740  * as ialloc_context.  The caller should hold this buffer across
741  * the commit and pass it back into this routine on the second call.
742  *
743  * If we are allocating quota inodes, we do not have a parent inode
744  * to attach to or associate with (i.e. pip == NULL) because they
745  * are not linked into the directory structure - they are attached
746  * directly to the superblock - and so have no parent.
747  */
748 static int
749 xfs_ialloc(
750         xfs_trans_t     *tp,
751         xfs_inode_t     *pip,
752         umode_t         mode,
753         xfs_nlink_t     nlink,
754         dev_t           rdev,
755         prid_t          prid,
756         xfs_buf_t       **ialloc_context,
757         xfs_inode_t     **ipp)
758 {
759         struct xfs_mount *mp = tp->t_mountp;
760         xfs_ino_t       ino;
761         xfs_inode_t     *ip;
762         uint            flags;
763         int             error;
764         struct timespec64 tv;
765         struct inode    *inode;
766
767         /*
768          * Call the space management code to pick
769          * the on-disk inode to be allocated.
770          */
771         error = xfs_dialloc(tp, pip ? pip->i_ino : 0, mode,
772                             ialloc_context, &ino);
773         if (error)
774                 return error;
775         if (*ialloc_context || ino == NULLFSINO) {
776                 *ipp = NULL;
777                 return 0;
778         }
779         ASSERT(*ialloc_context == NULL);
780
781         /*
782          * Protect against obviously corrupt allocation btree records. Later
783          * xfs_iget checks will catch re-allocation of other active in-memory
784          * and on-disk inodes. If we don't catch reallocating the parent inode
785          * here we will deadlock in xfs_iget() so we have to do these checks
786          * first.
787          */
788         if ((pip && ino == pip->i_ino) || !xfs_verify_dir_ino(mp, ino)) {
789                 xfs_alert(mp, "Allocated a known in-use inode 0x%llx!", ino);
790                 return -EFSCORRUPTED;
791         }
792
793         /*
794          * Get the in-core inode with the lock held exclusively.
795          * This is because we're setting fields here we need
796          * to prevent others from looking at until we're done.
797          */
798         error = xfs_iget(mp, tp, ino, XFS_IGET_CREATE,
799                          XFS_ILOCK_EXCL, &ip);
800         if (error)
801                 return error;
802         ASSERT(ip != NULL);
803         inode = VFS_I(ip);
804
805         /*
806          * We always convert v1 inodes to v2 now - we only support filesystems
807          * with >= v2 inode capability, so there is no reason for ever leaving
808          * an inode in v1 format.
809          */
810         if (ip->i_d.di_version == 1)
811                 ip->i_d.di_version = 2;
812
813         inode->i_mode = mode;
814         set_nlink(inode, nlink);
815         ip->i_d.di_uid = xfs_kuid_to_uid(current_fsuid());
816         ip->i_d.di_gid = xfs_kgid_to_gid(current_fsgid());
817         inode->i_rdev = rdev;
818         xfs_set_projid(ip, prid);
819
820         if (pip && XFS_INHERIT_GID(pip)) {
821                 ip->i_d.di_gid = pip->i_d.di_gid;
822                 if ((VFS_I(pip)->i_mode & S_ISGID) && S_ISDIR(mode))
823                         inode->i_mode |= S_ISGID;
824         }
825
826         /*
827          * If the group ID of the new file does not match the effective group
828          * ID or one of the supplementary group IDs, the S_ISGID bit is cleared
829          * (and only if the irix_sgid_inherit compatibility variable is set).
830          */
831         if ((irix_sgid_inherit) &&
832             (inode->i_mode & S_ISGID) &&
833             (!in_group_p(xfs_gid_to_kgid(ip->i_d.di_gid))))
834                 inode->i_mode &= ~S_ISGID;
835
836         ip->i_d.di_size = 0;
837         ip->i_d.di_nextents = 0;
838         ASSERT(ip->i_d.di_nblocks == 0);
839
840         tv = current_time(inode);
841         inode->i_mtime = tv;
842         inode->i_atime = tv;
843         inode->i_ctime = tv;
844
845         ip->i_d.di_extsize = 0;
846         ip->i_d.di_dmevmask = 0;
847         ip->i_d.di_dmstate = 0;
848         ip->i_d.di_flags = 0;
849
850         if (ip->i_d.di_version == 3) {
851                 inode_set_iversion(inode, 1);
852                 ip->i_d.di_flags2 = 0;
853                 ip->i_d.di_cowextsize = 0;
854                 ip->i_d.di_crtime.t_sec = (int32_t)tv.tv_sec;
855                 ip->i_d.di_crtime.t_nsec = (int32_t)tv.tv_nsec;
856         }
857
858
859         flags = XFS_ILOG_CORE;
860         switch (mode & S_IFMT) {
861         case S_IFIFO:
862         case S_IFCHR:
863         case S_IFBLK:
864         case S_IFSOCK:
865                 ip->i_d.di_format = XFS_DINODE_FMT_DEV;
866                 ip->i_df.if_flags = 0;
867                 flags |= XFS_ILOG_DEV;
868                 break;
869         case S_IFREG:
870         case S_IFDIR:
871                 if (pip && (pip->i_d.di_flags & XFS_DIFLAG_ANY)) {
872                         uint            di_flags = 0;
873
874                         if (S_ISDIR(mode)) {
875                                 if (pip->i_d.di_flags & XFS_DIFLAG_RTINHERIT)
876                                         di_flags |= XFS_DIFLAG_RTINHERIT;
877                                 if (pip->i_d.di_flags & XFS_DIFLAG_EXTSZINHERIT) {
878                                         di_flags |= XFS_DIFLAG_EXTSZINHERIT;
879                                         ip->i_d.di_extsize = pip->i_d.di_extsize;
880                                 }
881                                 if (pip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
882                                         di_flags |= XFS_DIFLAG_PROJINHERIT;
883                         } else if (S_ISREG(mode)) {
884                                 if (pip->i_d.di_flags & XFS_DIFLAG_RTINHERIT)
885                                         di_flags |= XFS_DIFLAG_REALTIME;
886                                 if (pip->i_d.di_flags & XFS_DIFLAG_EXTSZINHERIT) {
887                                         di_flags |= XFS_DIFLAG_EXTSIZE;
888                                         ip->i_d.di_extsize = pip->i_d.di_extsize;
889                                 }
890                         }
891                         if ((pip->i_d.di_flags & XFS_DIFLAG_NOATIME) &&
892                             xfs_inherit_noatime)
893                                 di_flags |= XFS_DIFLAG_NOATIME;
894                         if ((pip->i_d.di_flags & XFS_DIFLAG_NODUMP) &&
895                             xfs_inherit_nodump)
896                                 di_flags |= XFS_DIFLAG_NODUMP;
897                         if ((pip->i_d.di_flags & XFS_DIFLAG_SYNC) &&
898                             xfs_inherit_sync)
899                                 di_flags |= XFS_DIFLAG_SYNC;
900                         if ((pip->i_d.di_flags & XFS_DIFLAG_NOSYMLINKS) &&
901                             xfs_inherit_nosymlinks)
902                                 di_flags |= XFS_DIFLAG_NOSYMLINKS;
903                         if ((pip->i_d.di_flags & XFS_DIFLAG_NODEFRAG) &&
904                             xfs_inherit_nodefrag)
905                                 di_flags |= XFS_DIFLAG_NODEFRAG;
906                         if (pip->i_d.di_flags & XFS_DIFLAG_FILESTREAM)
907                                 di_flags |= XFS_DIFLAG_FILESTREAM;
908
909                         ip->i_d.di_flags |= di_flags;
910                 }
911                 if (pip &&
912                     (pip->i_d.di_flags2 & XFS_DIFLAG2_ANY) &&
913                     pip->i_d.di_version == 3 &&
914                     ip->i_d.di_version == 3) {
915                         uint64_t        di_flags2 = 0;
916
917                         if (pip->i_d.di_flags2 & XFS_DIFLAG2_COWEXTSIZE) {
918                                 di_flags2 |= XFS_DIFLAG2_COWEXTSIZE;
919                                 ip->i_d.di_cowextsize = pip->i_d.di_cowextsize;
920                         }
921                         if (pip->i_d.di_flags2 & XFS_DIFLAG2_DAX)
922                                 di_flags2 |= XFS_DIFLAG2_DAX;
923
924                         ip->i_d.di_flags2 |= di_flags2;
925                 }
926                 /* FALLTHROUGH */
927         case S_IFLNK:
928                 ip->i_d.di_format = XFS_DINODE_FMT_EXTENTS;
929                 ip->i_df.if_flags = XFS_IFEXTENTS;
930                 ip->i_df.if_bytes = 0;
931                 ip->i_df.if_u1.if_root = NULL;
932                 break;
933         default:
934                 ASSERT(0);
935         }
936         /*
937          * Attribute fork settings for new inode.
938          */
939         ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
940         ip->i_d.di_anextents = 0;
941
942         /*
943          * Log the new values stuffed into the inode.
944          */
945         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
946         xfs_trans_log_inode(tp, ip, flags);
947
948         /* now that we have an i_mode we can setup the inode structure */
949         xfs_setup_inode(ip);
950
951         *ipp = ip;
952         return 0;
953 }
954
955 /*
956  * Allocates a new inode from disk and return a pointer to the
957  * incore copy. This routine will internally commit the current
958  * transaction and allocate a new one if the Space Manager needed
959  * to do an allocation to replenish the inode free-list.
960  *
961  * This routine is designed to be called from xfs_create and
962  * xfs_create_dir.
963  *
964  */
965 int
966 xfs_dir_ialloc(
967         xfs_trans_t     **tpp,          /* input: current transaction;
968                                            output: may be a new transaction. */
969         xfs_inode_t     *dp,            /* directory within whose allocate
970                                            the inode. */
971         umode_t         mode,
972         xfs_nlink_t     nlink,
973         dev_t           rdev,
974         prid_t          prid,           /* project id */
975         xfs_inode_t     **ipp)          /* pointer to inode; it will be
976                                            locked. */
977 {
978         xfs_trans_t     *tp;
979         xfs_inode_t     *ip;
980         xfs_buf_t       *ialloc_context = NULL;
981         int             code;
982         void            *dqinfo;
983         uint            tflags;
984
985         tp = *tpp;
986         ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
987
988         /*
989          * xfs_ialloc will return a pointer to an incore inode if
990          * the Space Manager has an available inode on the free
991          * list. Otherwise, it will do an allocation and replenish
992          * the freelist.  Since we can only do one allocation per
993          * transaction without deadlocks, we will need to commit the
994          * current transaction and start a new one.  We will then
995          * need to call xfs_ialloc again to get the inode.
996          *
997          * If xfs_ialloc did an allocation to replenish the freelist,
998          * it returns the bp containing the head of the freelist as
999          * ialloc_context. We will hold a lock on it across the
1000          * transaction commit so that no other process can steal
1001          * the inode(s) that we've just allocated.
1002          */
1003         code = xfs_ialloc(tp, dp, mode, nlink, rdev, prid, &ialloc_context,
1004                         &ip);
1005
1006         /*
1007          * Return an error if we were unable to allocate a new inode.
1008          * This should only happen if we run out of space on disk or
1009          * encounter a disk error.
1010          */
1011         if (code) {
1012                 *ipp = NULL;
1013                 return code;
1014         }
1015         if (!ialloc_context && !ip) {
1016                 *ipp = NULL;
1017                 return -ENOSPC;
1018         }
1019
1020         /*
1021          * If the AGI buffer is non-NULL, then we were unable to get an
1022          * inode in one operation.  We need to commit the current
1023          * transaction and call xfs_ialloc() again.  It is guaranteed
1024          * to succeed the second time.
1025          */
1026         if (ialloc_context) {
1027                 /*
1028                  * Normally, xfs_trans_commit releases all the locks.
1029                  * We call bhold to hang on to the ialloc_context across
1030                  * the commit.  Holding this buffer prevents any other
1031                  * processes from doing any allocations in this
1032                  * allocation group.
1033                  */
1034                 xfs_trans_bhold(tp, ialloc_context);
1035
1036                 /*
1037                  * We want the quota changes to be associated with the next
1038                  * transaction, NOT this one. So, detach the dqinfo from this
1039                  * and attach it to the next transaction.
1040                  */
1041                 dqinfo = NULL;
1042                 tflags = 0;
1043                 if (tp->t_dqinfo) {
1044                         dqinfo = (void *)tp->t_dqinfo;
1045                         tp->t_dqinfo = NULL;
1046                         tflags = tp->t_flags & XFS_TRANS_DQ_DIRTY;
1047                         tp->t_flags &= ~(XFS_TRANS_DQ_DIRTY);
1048                 }
1049
1050                 code = xfs_trans_roll(&tp);
1051
1052                 /*
1053                  * Re-attach the quota info that we detached from prev trx.
1054                  */
1055                 if (dqinfo) {
1056                         tp->t_dqinfo = dqinfo;
1057                         tp->t_flags |= tflags;
1058                 }
1059
1060                 if (code) {
1061                         xfs_buf_relse(ialloc_context);
1062                         *tpp = tp;
1063                         *ipp = NULL;
1064                         return code;
1065                 }
1066                 xfs_trans_bjoin(tp, ialloc_context);
1067
1068                 /*
1069                  * Call ialloc again. Since we've locked out all
1070                  * other allocations in this allocation group,
1071                  * this call should always succeed.
1072                  */
1073                 code = xfs_ialloc(tp, dp, mode, nlink, rdev, prid,
1074                                   &ialloc_context, &ip);
1075
1076                 /*
1077                  * If we get an error at this point, return to the caller
1078                  * so that the current transaction can be aborted.
1079                  */
1080                 if (code) {
1081                         *tpp = tp;
1082                         *ipp = NULL;
1083                         return code;
1084                 }
1085                 ASSERT(!ialloc_context && ip);
1086
1087         }
1088
1089         *ipp = ip;
1090         *tpp = tp;
1091
1092         return 0;
1093 }
1094
1095 /*
1096  * Decrement the link count on an inode & log the change.  If this causes the
1097  * link count to go to zero, move the inode to AGI unlinked list so that it can
1098  * be freed when the last active reference goes away via xfs_inactive().
1099  */
1100 static int                      /* error */
1101 xfs_droplink(
1102         xfs_trans_t *tp,
1103         xfs_inode_t *ip)
1104 {
1105         xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
1106
1107         drop_nlink(VFS_I(ip));
1108         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1109
1110         if (VFS_I(ip)->i_nlink)
1111                 return 0;
1112
1113         return xfs_iunlink(tp, ip);
1114 }
1115
1116 /*
1117  * Increment the link count on an inode & log the change.
1118  */
1119 static void
1120 xfs_bumplink(
1121         xfs_trans_t *tp,
1122         xfs_inode_t *ip)
1123 {
1124         xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
1125
1126         ASSERT(ip->i_d.di_version > 1);
1127         inc_nlink(VFS_I(ip));
1128         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1129 }
1130
1131 int
1132 xfs_create(
1133         xfs_inode_t             *dp,
1134         struct xfs_name         *name,
1135         umode_t                 mode,
1136         dev_t                   rdev,
1137         xfs_inode_t             **ipp)
1138 {
1139         int                     is_dir = S_ISDIR(mode);
1140         struct xfs_mount        *mp = dp->i_mount;
1141         struct xfs_inode        *ip = NULL;
1142         struct xfs_trans        *tp = NULL;
1143         int                     error;
1144         bool                    unlock_dp_on_error = false;
1145         prid_t                  prid;
1146         struct xfs_dquot        *udqp = NULL;
1147         struct xfs_dquot        *gdqp = NULL;
1148         struct xfs_dquot        *pdqp = NULL;
1149         struct xfs_trans_res    *tres;
1150         uint                    resblks;
1151
1152         trace_xfs_create(dp, name);
1153
1154         if (XFS_FORCED_SHUTDOWN(mp))
1155                 return -EIO;
1156
1157         prid = xfs_get_initial_prid(dp);
1158
1159         /*
1160          * Make sure that we have allocated dquot(s) on disk.
1161          */
1162         error = xfs_qm_vop_dqalloc(dp, xfs_kuid_to_uid(current_fsuid()),
1163                                         xfs_kgid_to_gid(current_fsgid()), prid,
1164                                         XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
1165                                         &udqp, &gdqp, &pdqp);
1166         if (error)
1167                 return error;
1168
1169         if (is_dir) {
1170                 resblks = XFS_MKDIR_SPACE_RES(mp, name->len);
1171                 tres = &M_RES(mp)->tr_mkdir;
1172         } else {
1173                 resblks = XFS_CREATE_SPACE_RES(mp, name->len);
1174                 tres = &M_RES(mp)->tr_create;
1175         }
1176
1177         /*
1178          * Initially assume that the file does not exist and
1179          * reserve the resources for that case.  If that is not
1180          * the case we'll drop the one we have and get a more
1181          * appropriate transaction later.
1182          */
1183         error = xfs_trans_alloc(mp, tres, resblks, 0, 0, &tp);
1184         if (error == -ENOSPC) {
1185                 /* flush outstanding delalloc blocks and retry */
1186                 xfs_flush_inodes(mp);
1187                 error = xfs_trans_alloc(mp, tres, resblks, 0, 0, &tp);
1188         }
1189         if (error)
1190                 goto out_release_inode;
1191
1192         xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
1193         unlock_dp_on_error = true;
1194
1195         /*
1196          * Reserve disk quota and the inode.
1197          */
1198         error = xfs_trans_reserve_quota(tp, mp, udqp, gdqp,
1199                                                 pdqp, resblks, 1, 0);
1200         if (error)
1201                 goto out_trans_cancel;
1202
1203         /*
1204          * A newly created regular or special file just has one directory
1205          * entry pointing to them, but a directory also the "." entry
1206          * pointing to itself.
1207          */
1208         error = xfs_dir_ialloc(&tp, dp, mode, is_dir ? 2 : 1, rdev, prid, &ip);
1209         if (error)
1210                 goto out_trans_cancel;
1211
1212         /*
1213          * Now we join the directory inode to the transaction.  We do not do it
1214          * earlier because xfs_dir_ialloc might commit the previous transaction
1215          * (and release all the locks).  An error from here on will result in
1216          * the transaction cancel unlocking dp so don't do it explicitly in the
1217          * error path.
1218          */
1219         xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
1220         unlock_dp_on_error = false;
1221
1222         error = xfs_dir_createname(tp, dp, name, ip->i_ino,
1223                                    resblks ?
1224                                         resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
1225         if (error) {
1226                 ASSERT(error != -ENOSPC);
1227                 goto out_trans_cancel;
1228         }
1229         xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1230         xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
1231
1232         if (is_dir) {
1233                 error = xfs_dir_init(tp, ip, dp);
1234                 if (error)
1235                         goto out_trans_cancel;
1236
1237                 xfs_bumplink(tp, dp);
1238         }
1239
1240         /*
1241          * If this is a synchronous mount, make sure that the
1242          * create transaction goes to disk before returning to
1243          * the user.
1244          */
1245         if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
1246                 xfs_trans_set_sync(tp);
1247
1248         /*
1249          * Attach the dquot(s) to the inodes and modify them incore.
1250          * These ids of the inode couldn't have changed since the new
1251          * inode has been locked ever since it was created.
1252          */
1253         xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp, pdqp);
1254
1255         error = xfs_trans_commit(tp);
1256         if (error)
1257                 goto out_release_inode;
1258
1259         xfs_qm_dqrele(udqp);
1260         xfs_qm_dqrele(gdqp);
1261         xfs_qm_dqrele(pdqp);
1262
1263         *ipp = ip;
1264         return 0;
1265
1266  out_trans_cancel:
1267         xfs_trans_cancel(tp);
1268  out_release_inode:
1269         /*
1270          * Wait until after the current transaction is aborted to finish the
1271          * setup of the inode and release the inode.  This prevents recursive
1272          * transactions and deadlocks from xfs_inactive.
1273          */
1274         if (ip) {
1275                 xfs_finish_inode_setup(ip);
1276                 xfs_irele(ip);
1277         }
1278
1279         xfs_qm_dqrele(udqp);
1280         xfs_qm_dqrele(gdqp);
1281         xfs_qm_dqrele(pdqp);
1282
1283         if (unlock_dp_on_error)
1284                 xfs_iunlock(dp, XFS_ILOCK_EXCL);
1285         return error;
1286 }
1287
1288 int
1289 xfs_create_tmpfile(
1290         struct xfs_inode        *dp,
1291         umode_t                 mode,
1292         struct xfs_inode        **ipp)
1293 {
1294         struct xfs_mount        *mp = dp->i_mount;
1295         struct xfs_inode        *ip = NULL;
1296         struct xfs_trans        *tp = NULL;
1297         int                     error;
1298         prid_t                  prid;
1299         struct xfs_dquot        *udqp = NULL;
1300         struct xfs_dquot        *gdqp = NULL;
1301         struct xfs_dquot        *pdqp = NULL;
1302         struct xfs_trans_res    *tres;
1303         uint                    resblks;
1304
1305         if (XFS_FORCED_SHUTDOWN(mp))
1306                 return -EIO;
1307
1308         prid = xfs_get_initial_prid(dp);
1309
1310         /*
1311          * Make sure that we have allocated dquot(s) on disk.
1312          */
1313         error = xfs_qm_vop_dqalloc(dp, xfs_kuid_to_uid(current_fsuid()),
1314                                 xfs_kgid_to_gid(current_fsgid()), prid,
1315                                 XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
1316                                 &udqp, &gdqp, &pdqp);
1317         if (error)
1318                 return error;
1319
1320         resblks = XFS_IALLOC_SPACE_RES(mp);
1321         tres = &M_RES(mp)->tr_create_tmpfile;
1322
1323         error = xfs_trans_alloc(mp, tres, resblks, 0, 0, &tp);
1324         if (error)
1325                 goto out_release_inode;
1326
1327         error = xfs_trans_reserve_quota(tp, mp, udqp, gdqp,
1328                                                 pdqp, resblks, 1, 0);
1329         if (error)
1330                 goto out_trans_cancel;
1331
1332         error = xfs_dir_ialloc(&tp, dp, mode, 0, 0, prid, &ip);
1333         if (error)
1334                 goto out_trans_cancel;
1335
1336         if (mp->m_flags & XFS_MOUNT_WSYNC)
1337                 xfs_trans_set_sync(tp);
1338
1339         /*
1340          * Attach the dquot(s) to the inodes and modify them incore.
1341          * These ids of the inode couldn't have changed since the new
1342          * inode has been locked ever since it was created.
1343          */
1344         xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp, pdqp);
1345
1346         error = xfs_iunlink(tp, ip);
1347         if (error)
1348                 goto out_trans_cancel;
1349
1350         error = xfs_trans_commit(tp);
1351         if (error)
1352                 goto out_release_inode;
1353
1354         xfs_qm_dqrele(udqp);
1355         xfs_qm_dqrele(gdqp);
1356         xfs_qm_dqrele(pdqp);
1357
1358         *ipp = ip;
1359         return 0;
1360
1361  out_trans_cancel:
1362         xfs_trans_cancel(tp);
1363  out_release_inode:
1364         /*
1365          * Wait until after the current transaction is aborted to finish the
1366          * setup of the inode and release the inode.  This prevents recursive
1367          * transactions and deadlocks from xfs_inactive.
1368          */
1369         if (ip) {
1370                 xfs_finish_inode_setup(ip);
1371                 xfs_irele(ip);
1372         }
1373
1374         xfs_qm_dqrele(udqp);
1375         xfs_qm_dqrele(gdqp);
1376         xfs_qm_dqrele(pdqp);
1377
1378         return error;
1379 }
1380
1381 int
1382 xfs_link(
1383         xfs_inode_t             *tdp,
1384         xfs_inode_t             *sip,
1385         struct xfs_name         *target_name)
1386 {
1387         xfs_mount_t             *mp = tdp->i_mount;
1388         xfs_trans_t             *tp;
1389         int                     error;
1390         int                     resblks;
1391
1392         trace_xfs_link(tdp, target_name);
1393
1394         ASSERT(!S_ISDIR(VFS_I(sip)->i_mode));
1395
1396         if (XFS_FORCED_SHUTDOWN(mp))
1397                 return -EIO;
1398
1399         error = xfs_qm_dqattach(sip);
1400         if (error)
1401                 goto std_return;
1402
1403         error = xfs_qm_dqattach(tdp);
1404         if (error)
1405                 goto std_return;
1406
1407         resblks = XFS_LINK_SPACE_RES(mp, target_name->len);
1408         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_link, resblks, 0, 0, &tp);
1409         if (error == -ENOSPC) {
1410                 resblks = 0;
1411                 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_link, 0, 0, 0, &tp);
1412         }
1413         if (error)
1414                 goto std_return;
1415
1416         xfs_lock_two_inodes(sip, XFS_ILOCK_EXCL, tdp, XFS_ILOCK_EXCL);
1417
1418         xfs_trans_ijoin(tp, sip, XFS_ILOCK_EXCL);
1419         xfs_trans_ijoin(tp, tdp, XFS_ILOCK_EXCL);
1420
1421         /*
1422          * If we are using project inheritance, we only allow hard link
1423          * creation in our tree when the project IDs are the same; else
1424          * the tree quota mechanism could be circumvented.
1425          */
1426         if (unlikely((tdp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
1427                      (xfs_get_projid(tdp) != xfs_get_projid(sip)))) {
1428                 error = -EXDEV;
1429                 goto error_return;
1430         }
1431
1432         if (!resblks) {
1433                 error = xfs_dir_canenter(tp, tdp, target_name);
1434                 if (error)
1435                         goto error_return;
1436         }
1437
1438         /*
1439          * Handle initial link state of O_TMPFILE inode
1440          */
1441         if (VFS_I(sip)->i_nlink == 0) {
1442                 error = xfs_iunlink_remove(tp, sip);
1443                 if (error)
1444                         goto error_return;
1445         }
1446
1447         error = xfs_dir_createname(tp, tdp, target_name, sip->i_ino,
1448                                    resblks);
1449         if (error)
1450                 goto error_return;
1451         xfs_trans_ichgtime(tp, tdp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1452         xfs_trans_log_inode(tp, tdp, XFS_ILOG_CORE);
1453
1454         xfs_bumplink(tp, sip);
1455
1456         /*
1457          * If this is a synchronous mount, make sure that the
1458          * link transaction goes to disk before returning to
1459          * the user.
1460          */
1461         if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
1462                 xfs_trans_set_sync(tp);
1463
1464         return xfs_trans_commit(tp);
1465
1466  error_return:
1467         xfs_trans_cancel(tp);
1468  std_return:
1469         return error;
1470 }
1471
1472 /* Clear the reflink flag and the cowblocks tag if possible. */
1473 static void
1474 xfs_itruncate_clear_reflink_flags(
1475         struct xfs_inode        *ip)
1476 {
1477         struct xfs_ifork        *dfork;
1478         struct xfs_ifork        *cfork;
1479
1480         if (!xfs_is_reflink_inode(ip))
1481                 return;
1482         dfork = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
1483         cfork = XFS_IFORK_PTR(ip, XFS_COW_FORK);
1484         if (dfork->if_bytes == 0 && cfork->if_bytes == 0)
1485                 ip->i_d.di_flags2 &= ~XFS_DIFLAG2_REFLINK;
1486         if (cfork->if_bytes == 0)
1487                 xfs_inode_clear_cowblocks_tag(ip);
1488 }
1489
1490 /*
1491  * Free up the underlying blocks past new_size.  The new size must be smaller
1492  * than the current size.  This routine can be used both for the attribute and
1493  * data fork, and does not modify the inode size, which is left to the caller.
1494  *
1495  * The transaction passed to this routine must have made a permanent log
1496  * reservation of at least XFS_ITRUNCATE_LOG_RES.  This routine may commit the
1497  * given transaction and start new ones, so make sure everything involved in
1498  * the transaction is tidy before calling here.  Some transaction will be
1499  * returned to the caller to be committed.  The incoming transaction must
1500  * already include the inode, and both inode locks must be held exclusively.
1501  * The inode must also be "held" within the transaction.  On return the inode
1502  * will be "held" within the returned transaction.  This routine does NOT
1503  * require any disk space to be reserved for it within the transaction.
1504  *
1505  * If we get an error, we must return with the inode locked and linked into the
1506  * current transaction. This keeps things simple for the higher level code,
1507  * because it always knows that the inode is locked and held in the transaction
1508  * that returns to it whether errors occur or not.  We don't mark the inode
1509  * dirty on error so that transactions can be easily aborted if possible.
1510  */
1511 int
1512 xfs_itruncate_extents_flags(
1513         struct xfs_trans        **tpp,
1514         struct xfs_inode        *ip,
1515         int                     whichfork,
1516         xfs_fsize_t             new_size,
1517         int                     flags)
1518 {
1519         struct xfs_mount        *mp = ip->i_mount;
1520         struct xfs_trans        *tp = *tpp;
1521         xfs_fileoff_t           first_unmap_block;
1522         xfs_fileoff_t           last_block;
1523         xfs_filblks_t           unmap_len;
1524         int                     error = 0;
1525         int                     done = 0;
1526
1527         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
1528         ASSERT(!atomic_read(&VFS_I(ip)->i_count) ||
1529                xfs_isilocked(ip, XFS_IOLOCK_EXCL));
1530         ASSERT(new_size <= XFS_ISIZE(ip));
1531         ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
1532         ASSERT(ip->i_itemp != NULL);
1533         ASSERT(ip->i_itemp->ili_lock_flags == 0);
1534         ASSERT(!XFS_NOT_DQATTACHED(mp, ip));
1535
1536         trace_xfs_itruncate_extents_start(ip, new_size);
1537
1538         flags |= xfs_bmapi_aflag(whichfork);
1539
1540         /*
1541          * Since it is possible for space to become allocated beyond
1542          * the end of the file (in a crash where the space is allocated
1543          * but the inode size is not yet updated), simply remove any
1544          * blocks which show up between the new EOF and the maximum
1545          * possible file size.  If the first block to be removed is
1546          * beyond the maximum file size (ie it is the same as last_block),
1547          * then there is nothing to do.
1548          */
1549         first_unmap_block = XFS_B_TO_FSB(mp, (xfs_ufsize_t)new_size);
1550         last_block = XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes);
1551         if (first_unmap_block == last_block)
1552                 return 0;
1553
1554         ASSERT(first_unmap_block < last_block);
1555         unmap_len = last_block - first_unmap_block + 1;
1556         while (!done) {
1557                 ASSERT(tp->t_firstblock == NULLFSBLOCK);
1558                 error = xfs_bunmapi(tp, ip, first_unmap_block, unmap_len, flags,
1559                                     XFS_ITRUNC_MAX_EXTENTS, &done);
1560                 if (error)
1561                         goto out;
1562
1563                 /*
1564                  * Duplicate the transaction that has the permanent
1565                  * reservation and commit the old transaction.
1566                  */
1567                 error = xfs_defer_finish(&tp);
1568                 if (error)
1569                         goto out;
1570
1571                 error = xfs_trans_roll_inode(&tp, ip);
1572                 if (error)
1573                         goto out;
1574         }
1575
1576         if (whichfork == XFS_DATA_FORK) {
1577                 /* Remove all pending CoW reservations. */
1578                 error = xfs_reflink_cancel_cow_blocks(ip, &tp,
1579                                 first_unmap_block, last_block, true);
1580                 if (error)
1581                         goto out;
1582
1583                 xfs_itruncate_clear_reflink_flags(ip);
1584         }
1585
1586         /*
1587          * Always re-log the inode so that our permanent transaction can keep
1588          * on rolling it forward in the log.
1589          */
1590         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1591
1592         trace_xfs_itruncate_extents_end(ip, new_size);
1593
1594 out:
1595         *tpp = tp;
1596         return error;
1597 }
1598
1599 int
1600 xfs_release(
1601         xfs_inode_t     *ip)
1602 {
1603         xfs_mount_t     *mp = ip->i_mount;
1604         int             error;
1605
1606         if (!S_ISREG(VFS_I(ip)->i_mode) || (VFS_I(ip)->i_mode == 0))
1607                 return 0;
1608
1609         /* If this is a read-only mount, don't do this (would generate I/O) */
1610         if (mp->m_flags & XFS_MOUNT_RDONLY)
1611                 return 0;
1612
1613         if (!XFS_FORCED_SHUTDOWN(mp)) {
1614                 int truncated;
1615
1616                 /*
1617                  * If we previously truncated this file and removed old data
1618                  * in the process, we want to initiate "early" writeout on
1619                  * the last close.  This is an attempt to combat the notorious
1620                  * NULL files problem which is particularly noticeable from a
1621                  * truncate down, buffered (re-)write (delalloc), followed by
1622                  * a crash.  What we are effectively doing here is
1623                  * significantly reducing the time window where we'd otherwise
1624                  * be exposed to that problem.
1625                  */
1626                 truncated = xfs_iflags_test_and_clear(ip, XFS_ITRUNCATED);
1627                 if (truncated) {
1628                         xfs_iflags_clear(ip, XFS_IDIRTY_RELEASE);
1629                         if (ip->i_delayed_blks > 0) {
1630                                 error = filemap_flush(VFS_I(ip)->i_mapping);
1631                                 if (error)
1632                                         return error;
1633                         }
1634                 }
1635         }
1636
1637         if (VFS_I(ip)->i_nlink == 0)
1638                 return 0;
1639
1640         if (xfs_can_free_eofblocks(ip, false)) {
1641
1642                 /*
1643                  * Check if the inode is being opened, written and closed
1644                  * frequently and we have delayed allocation blocks outstanding
1645                  * (e.g. streaming writes from the NFS server), truncating the
1646                  * blocks past EOF will cause fragmentation to occur.
1647                  *
1648                  * In this case don't do the truncation, but we have to be
1649                  * careful how we detect this case. Blocks beyond EOF show up as
1650                  * i_delayed_blks even when the inode is clean, so we need to
1651                  * truncate them away first before checking for a dirty release.
1652                  * Hence on the first dirty close we will still remove the
1653                  * speculative allocation, but after that we will leave it in
1654                  * place.
1655                  */
1656                 if (xfs_iflags_test(ip, XFS_IDIRTY_RELEASE))
1657                         return 0;
1658                 /*
1659                  * If we can't get the iolock just skip truncating the blocks
1660                  * past EOF because we could deadlock with the mmap_sem
1661                  * otherwise. We'll get another chance to drop them once the
1662                  * last reference to the inode is dropped, so we'll never leak
1663                  * blocks permanently.
1664                  */
1665                 if (xfs_ilock_nowait(ip, XFS_IOLOCK_EXCL)) {
1666                         error = xfs_free_eofblocks(ip);
1667                         xfs_iunlock(ip, XFS_IOLOCK_EXCL);
1668                         if (error)
1669                                 return error;
1670                 }
1671
1672                 /* delalloc blocks after truncation means it really is dirty */
1673                 if (ip->i_delayed_blks)
1674                         xfs_iflags_set(ip, XFS_IDIRTY_RELEASE);
1675         }
1676         return 0;
1677 }
1678
1679 /*
1680  * xfs_inactive_truncate
1681  *
1682  * Called to perform a truncate when an inode becomes unlinked.
1683  */
1684 STATIC int
1685 xfs_inactive_truncate(
1686         struct xfs_inode *ip)
1687 {
1688         struct xfs_mount        *mp = ip->i_mount;
1689         struct xfs_trans        *tp;
1690         int                     error;
1691
1692         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
1693         if (error) {
1694                 ASSERT(XFS_FORCED_SHUTDOWN(mp));
1695                 return error;
1696         }
1697         xfs_ilock(ip, XFS_ILOCK_EXCL);
1698         xfs_trans_ijoin(tp, ip, 0);
1699
1700         /*
1701          * Log the inode size first to prevent stale data exposure in the event
1702          * of a system crash before the truncate completes. See the related
1703          * comment in xfs_vn_setattr_size() for details.
1704          */
1705         ip->i_d.di_size = 0;
1706         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1707
1708         error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK, 0);
1709         if (error)
1710                 goto error_trans_cancel;
1711
1712         ASSERT(ip->i_d.di_nextents == 0);
1713
1714         error = xfs_trans_commit(tp);
1715         if (error)
1716                 goto error_unlock;
1717
1718         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1719         return 0;
1720
1721 error_trans_cancel:
1722         xfs_trans_cancel(tp);
1723 error_unlock:
1724         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1725         return error;
1726 }
1727
1728 /*
1729  * xfs_inactive_ifree()
1730  *
1731  * Perform the inode free when an inode is unlinked.
1732  */
1733 STATIC int
1734 xfs_inactive_ifree(
1735         struct xfs_inode *ip)
1736 {
1737         struct xfs_mount        *mp = ip->i_mount;
1738         struct xfs_trans        *tp;
1739         int                     error;
1740
1741         /*
1742          * We try to use a per-AG reservation for any block needed by the finobt
1743          * tree, but as the finobt feature predates the per-AG reservation
1744          * support a degraded file system might not have enough space for the
1745          * reservation at mount time.  In that case try to dip into the reserved
1746          * pool and pray.
1747          *
1748          * Send a warning if the reservation does happen to fail, as the inode
1749          * now remains allocated and sits on the unlinked list until the fs is
1750          * repaired.
1751          */
1752         if (unlikely(mp->m_finobt_nores)) {
1753                 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ifree,
1754                                 XFS_IFREE_SPACE_RES(mp), 0, XFS_TRANS_RESERVE,
1755                                 &tp);
1756         } else {
1757                 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ifree, 0, 0, 0, &tp);
1758         }
1759         if (error) {
1760                 if (error == -ENOSPC) {
1761                         xfs_warn_ratelimited(mp,
1762                         "Failed to remove inode(s) from unlinked list. "
1763                         "Please free space, unmount and run xfs_repair.");
1764                 } else {
1765                         ASSERT(XFS_FORCED_SHUTDOWN(mp));
1766                 }
1767                 return error;
1768         }
1769
1770         xfs_ilock(ip, XFS_ILOCK_EXCL);
1771         xfs_trans_ijoin(tp, ip, 0);
1772
1773         error = xfs_ifree(tp, ip);
1774         if (error) {
1775                 /*
1776                  * If we fail to free the inode, shut down.  The cancel
1777                  * might do that, we need to make sure.  Otherwise the
1778                  * inode might be lost for a long time or forever.
1779                  */
1780                 if (!XFS_FORCED_SHUTDOWN(mp)) {
1781                         xfs_notice(mp, "%s: xfs_ifree returned error %d",
1782                                 __func__, error);
1783                         xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
1784                 }
1785                 xfs_trans_cancel(tp);
1786                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1787                 return error;
1788         }
1789
1790         /*
1791          * Credit the quota account(s). The inode is gone.
1792          */
1793         xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_ICOUNT, -1);
1794
1795         /*
1796          * Just ignore errors at this point.  There is nothing we can do except
1797          * to try to keep going. Make sure it's not a silent error.
1798          */
1799         error = xfs_trans_commit(tp);
1800         if (error)
1801                 xfs_notice(mp, "%s: xfs_trans_commit returned error %d",
1802                         __func__, error);
1803
1804         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1805         return 0;
1806 }
1807
1808 /*
1809  * xfs_inactive
1810  *
1811  * This is called when the vnode reference count for the vnode
1812  * goes to zero.  If the file has been unlinked, then it must
1813  * now be truncated.  Also, we clear all of the read-ahead state
1814  * kept for the inode here since the file is now closed.
1815  */
1816 void
1817 xfs_inactive(
1818         xfs_inode_t     *ip)
1819 {
1820         struct xfs_mount        *mp;
1821         int                     error;
1822         int                     truncate = 0;
1823
1824         /*
1825          * If the inode is already free, then there can be nothing
1826          * to clean up here.
1827          */
1828         if (VFS_I(ip)->i_mode == 0) {
1829                 ASSERT(ip->i_df.if_broot_bytes == 0);
1830                 return;
1831         }
1832
1833         mp = ip->i_mount;
1834         ASSERT(!xfs_iflags_test(ip, XFS_IRECOVERY));
1835
1836         /* If this is a read-only mount, don't do this (would generate I/O) */
1837         if (mp->m_flags & XFS_MOUNT_RDONLY)
1838                 return;
1839
1840         /* Try to clean out the cow blocks if there are any. */
1841         if (xfs_inode_has_cow_data(ip))
1842                 xfs_reflink_cancel_cow_range(ip, 0, NULLFILEOFF, true);
1843
1844         if (VFS_I(ip)->i_nlink != 0) {
1845                 /*
1846                  * force is true because we are evicting an inode from the
1847                  * cache. Post-eof blocks must be freed, lest we end up with
1848                  * broken free space accounting.
1849                  *
1850                  * Note: don't bother with iolock here since lockdep complains
1851                  * about acquiring it in reclaim context. We have the only
1852                  * reference to the inode at this point anyways.
1853                  */
1854                 if (xfs_can_free_eofblocks(ip, true))
1855                         xfs_free_eofblocks(ip);
1856
1857                 return;
1858         }
1859
1860         if (S_ISREG(VFS_I(ip)->i_mode) &&
1861             (ip->i_d.di_size != 0 || XFS_ISIZE(ip) != 0 ||
1862              ip->i_d.di_nextents > 0 || ip->i_delayed_blks > 0))
1863                 truncate = 1;
1864
1865         error = xfs_qm_dqattach(ip);
1866         if (error)
1867                 return;
1868
1869         if (S_ISLNK(VFS_I(ip)->i_mode))
1870                 error = xfs_inactive_symlink(ip);
1871         else if (truncate)
1872                 error = xfs_inactive_truncate(ip);
1873         if (error)
1874                 return;
1875
1876         /*
1877          * If there are attributes associated with the file then blow them away
1878          * now.  The code calls a routine that recursively deconstructs the
1879          * attribute fork. If also blows away the in-core attribute fork.
1880          */
1881         if (XFS_IFORK_Q(ip)) {
1882                 error = xfs_attr_inactive(ip);
1883                 if (error)
1884                         return;
1885         }
1886
1887         ASSERT(!ip->i_afp);
1888         ASSERT(ip->i_d.di_anextents == 0);
1889         ASSERT(ip->i_d.di_forkoff == 0);
1890
1891         /*
1892          * Free the inode.
1893          */
1894         error = xfs_inactive_ifree(ip);
1895         if (error)
1896                 return;
1897
1898         /*
1899          * Release the dquots held by inode, if any.
1900          */
1901         xfs_qm_dqdetach(ip);
1902 }
1903
1904 /*
1905  * In-Core Unlinked List Lookups
1906  * =============================
1907  *
1908  * Every inode is supposed to be reachable from some other piece of metadata
1909  * with the exception of the root directory.  Inodes with a connection to a
1910  * file descriptor but not linked from anywhere in the on-disk directory tree
1911  * are collectively known as unlinked inodes, though the filesystem itself
1912  * maintains links to these inodes so that on-disk metadata are consistent.
1913  *
1914  * XFS implements a per-AG on-disk hash table of unlinked inodes.  The AGI
1915  * header contains a number of buckets that point to an inode, and each inode
1916  * record has a pointer to the next inode in the hash chain.  This
1917  * singly-linked list causes scaling problems in the iunlink remove function
1918  * because we must walk that list to find the inode that points to the inode
1919  * being removed from the unlinked hash bucket list.
1920  *
1921  * What if we modelled the unlinked list as a collection of records capturing
1922  * "X.next_unlinked = Y" relations?  If we indexed those records on Y, we'd
1923  * have a fast way to look up unlinked list predecessors, which avoids the
1924  * slow list walk.  That's exactly what we do here (in-core) with a per-AG
1925  * rhashtable.
1926  *
1927  * Because this is a backref cache, we ignore operational failures since the
1928  * iunlink code can fall back to the slow bucket walk.  The only errors that
1929  * should bubble out are for obviously incorrect situations.
1930  *
1931  * All users of the backref cache MUST hold the AGI buffer lock to serialize
1932  * access or have otherwise provided for concurrency control.
1933  */
1934
1935 /* Capture a "X.next_unlinked = Y" relationship. */
1936 struct xfs_iunlink {
1937         struct rhash_head       iu_rhash_head;
1938         xfs_agino_t             iu_agino;               /* X */
1939         xfs_agino_t             iu_next_unlinked;       /* Y */
1940 };
1941
1942 /* Unlinked list predecessor lookup hashtable construction */
1943 static int
1944 xfs_iunlink_obj_cmpfn(
1945         struct rhashtable_compare_arg   *arg,
1946         const void                      *obj)
1947 {
1948         const xfs_agino_t               *key = arg->key;
1949         const struct xfs_iunlink        *iu = obj;
1950
1951         if (iu->iu_next_unlinked != *key)
1952                 return 1;
1953         return 0;
1954 }
1955
1956 static const struct rhashtable_params xfs_iunlink_hash_params = {
1957         .min_size               = XFS_AGI_UNLINKED_BUCKETS,
1958         .key_len                = sizeof(xfs_agino_t),
1959         .key_offset             = offsetof(struct xfs_iunlink,
1960                                            iu_next_unlinked),
1961         .head_offset            = offsetof(struct xfs_iunlink, iu_rhash_head),
1962         .automatic_shrinking    = true,
1963         .obj_cmpfn              = xfs_iunlink_obj_cmpfn,
1964 };
1965
1966 /*
1967  * Return X, where X.next_unlinked == @agino.  Returns NULLAGINO if no such
1968  * relation is found.
1969  */
1970 static xfs_agino_t
1971 xfs_iunlink_lookup_backref(
1972         struct xfs_perag        *pag,
1973         xfs_agino_t             agino)
1974 {
1975         struct xfs_iunlink      *iu;
1976
1977         iu = rhashtable_lookup_fast(&pag->pagi_unlinked_hash, &agino,
1978                         xfs_iunlink_hash_params);
1979         return iu ? iu->iu_agino : NULLAGINO;
1980 }
1981
1982 /*
1983  * Take ownership of an iunlink cache entry and insert it into the hash table.
1984  * If successful, the entry will be owned by the cache; if not, it is freed.
1985  * Either way, the caller does not own @iu after this call.
1986  */
1987 static int
1988 xfs_iunlink_insert_backref(
1989         struct xfs_perag        *pag,
1990         struct xfs_iunlink      *iu)
1991 {
1992         int                     error;
1993
1994         error = rhashtable_insert_fast(&pag->pagi_unlinked_hash,
1995                         &iu->iu_rhash_head, xfs_iunlink_hash_params);
1996         /*
1997          * Fail loudly if there already was an entry because that's a sign of
1998          * corruption of in-memory data.  Also fail loudly if we see an error
1999          * code we didn't anticipate from the rhashtable code.  Currently we
2000          * only anticipate ENOMEM.
2001          */
2002         if (error) {
2003                 WARN(error != -ENOMEM, "iunlink cache insert error %d", error);
2004                 kmem_free(iu);
2005         }
2006         /*
2007          * Absorb any runtime errors that aren't a result of corruption because
2008          * this is a cache and we can always fall back to bucket list scanning.
2009          */
2010         if (error != 0 && error != -EEXIST)
2011                 error = 0;
2012         return error;
2013 }
2014
2015 /* Remember that @prev_agino.next_unlinked = @this_agino. */
2016 static int
2017 xfs_iunlink_add_backref(
2018         struct xfs_perag        *pag,
2019         xfs_agino_t             prev_agino,
2020         xfs_agino_t             this_agino)
2021 {
2022         struct xfs_iunlink      *iu;
2023
2024         if (XFS_TEST_ERROR(false, pag->pag_mount, XFS_ERRTAG_IUNLINK_FALLBACK))
2025                 return 0;
2026
2027         iu = kmem_zalloc(sizeof(*iu), KM_SLEEP | KM_NOFS);
2028         iu->iu_agino = prev_agino;
2029         iu->iu_next_unlinked = this_agino;
2030
2031         return xfs_iunlink_insert_backref(pag, iu);
2032 }
2033
2034 /*
2035  * Replace X.next_unlinked = @agino with X.next_unlinked = @next_unlinked.
2036  * If @next_unlinked is NULLAGINO, we drop the backref and exit.  If there
2037  * wasn't any such entry then we don't bother.
2038  */
2039 static int
2040 xfs_iunlink_change_backref(
2041         struct xfs_perag        *pag,
2042         xfs_agino_t             agino,
2043         xfs_agino_t             next_unlinked)
2044 {
2045         struct xfs_iunlink      *iu;
2046         int                     error;
2047
2048         /* Look up the old entry; if there wasn't one then exit. */
2049         iu = rhashtable_lookup_fast(&pag->pagi_unlinked_hash, &agino,
2050                         xfs_iunlink_hash_params);
2051         if (!iu)
2052                 return 0;
2053
2054         /*
2055          * Remove the entry.  This shouldn't ever return an error, but if we
2056          * couldn't remove the old entry we don't want to add it again to the
2057          * hash table, and if the entry disappeared on us then someone's
2058          * violated the locking rules and we need to fail loudly.  Either way
2059          * we cannot remove the inode because internal state is or would have
2060          * been corrupt.
2061          */
2062         error = rhashtable_remove_fast(&pag->pagi_unlinked_hash,
2063                         &iu->iu_rhash_head, xfs_iunlink_hash_params);
2064         if (error)
2065                 return error;
2066
2067         /* If there is no new next entry just free our item and return. */
2068         if (next_unlinked == NULLAGINO) {
2069                 kmem_free(iu);
2070                 return 0;
2071         }
2072
2073         /* Update the entry and re-add it to the hash table. */
2074         iu->iu_next_unlinked = next_unlinked;
2075         return xfs_iunlink_insert_backref(pag, iu);
2076 }
2077
2078 /* Set up the in-core predecessor structures. */
2079 int
2080 xfs_iunlink_init(
2081         struct xfs_perag        *pag)
2082 {
2083         return rhashtable_init(&pag->pagi_unlinked_hash,
2084                         &xfs_iunlink_hash_params);
2085 }
2086
2087 /* Free the in-core predecessor structures. */
2088 static void
2089 xfs_iunlink_free_item(
2090         void                    *ptr,
2091         void                    *arg)
2092 {
2093         struct xfs_iunlink      *iu = ptr;
2094         bool                    *freed_anything = arg;
2095
2096         *freed_anything = true;
2097         kmem_free(iu);
2098 }
2099
2100 void
2101 xfs_iunlink_destroy(
2102         struct xfs_perag        *pag)
2103 {
2104         bool                    freed_anything = false;
2105
2106         rhashtable_free_and_destroy(&pag->pagi_unlinked_hash,
2107                         xfs_iunlink_free_item, &freed_anything);
2108
2109         ASSERT(freed_anything == false || XFS_FORCED_SHUTDOWN(pag->pag_mount));
2110 }
2111
2112 /*
2113  * Point the AGI unlinked bucket at an inode and log the results.  The caller
2114  * is responsible for validating the old value.
2115  */
2116 STATIC int
2117 xfs_iunlink_update_bucket(
2118         struct xfs_trans        *tp,
2119         xfs_agnumber_t          agno,
2120         struct xfs_buf          *agibp,
2121         unsigned int            bucket_index,
2122         xfs_agino_t             new_agino)
2123 {
2124         struct xfs_agi          *agi = XFS_BUF_TO_AGI(agibp);
2125         xfs_agino_t             old_value;
2126         int                     offset;
2127
2128         ASSERT(xfs_verify_agino_or_null(tp->t_mountp, agno, new_agino));
2129
2130         old_value = be32_to_cpu(agi->agi_unlinked[bucket_index]);
2131         trace_xfs_iunlink_update_bucket(tp->t_mountp, agno, bucket_index,
2132                         old_value, new_agino);
2133
2134         /*
2135          * We should never find the head of the list already set to the value
2136          * passed in because either we're adding or removing ourselves from the
2137          * head of the list.
2138          */
2139         if (old_value == new_agino)
2140                 return -EFSCORRUPTED;
2141
2142         agi->agi_unlinked[bucket_index] = cpu_to_be32(new_agino);
2143         offset = offsetof(struct xfs_agi, agi_unlinked) +
2144                         (sizeof(xfs_agino_t) * bucket_index);
2145         xfs_trans_log_buf(tp, agibp, offset, offset + sizeof(xfs_agino_t) - 1);
2146         return 0;
2147 }
2148
2149 /* Set an on-disk inode's next_unlinked pointer. */
2150 STATIC void
2151 xfs_iunlink_update_dinode(
2152         struct xfs_trans        *tp,
2153         xfs_agnumber_t          agno,
2154         xfs_agino_t             agino,
2155         struct xfs_buf          *ibp,
2156         struct xfs_dinode       *dip,
2157         struct xfs_imap         *imap,
2158         xfs_agino_t             next_agino)
2159 {
2160         struct xfs_mount        *mp = tp->t_mountp;
2161         int                     offset;
2162
2163         ASSERT(xfs_verify_agino_or_null(mp, agno, next_agino));
2164
2165         trace_xfs_iunlink_update_dinode(mp, agno, agino,
2166                         be32_to_cpu(dip->di_next_unlinked), next_agino);
2167
2168         dip->di_next_unlinked = cpu_to_be32(next_agino);
2169         offset = imap->im_boffset +
2170                         offsetof(struct xfs_dinode, di_next_unlinked);
2171
2172         /* need to recalc the inode CRC if appropriate */
2173         xfs_dinode_calc_crc(mp, dip);
2174         xfs_trans_inode_buf(tp, ibp);
2175         xfs_trans_log_buf(tp, ibp, offset, offset + sizeof(xfs_agino_t) - 1);
2176         xfs_inobp_check(mp, ibp);
2177 }
2178
2179 /* Set an in-core inode's unlinked pointer and return the old value. */
2180 STATIC int
2181 xfs_iunlink_update_inode(
2182         struct xfs_trans        *tp,
2183         struct xfs_inode        *ip,
2184         xfs_agnumber_t          agno,
2185         xfs_agino_t             next_agino,
2186         xfs_agino_t             *old_next_agino)
2187 {
2188         struct xfs_mount        *mp = tp->t_mountp;
2189         struct xfs_dinode       *dip;
2190         struct xfs_buf          *ibp;
2191         xfs_agino_t             old_value;
2192         int                     error;
2193
2194         ASSERT(xfs_verify_agino_or_null(mp, agno, next_agino));
2195
2196         error = xfs_imap_to_bp(mp, tp, &ip->i_imap, &dip, &ibp, 0, 0);
2197         if (error)
2198                 return error;
2199
2200         /* Make sure the old pointer isn't garbage. */
2201         old_value = be32_to_cpu(dip->di_next_unlinked);
2202         if (!xfs_verify_agino_or_null(mp, agno, old_value)) {
2203                 error = -EFSCORRUPTED;
2204                 goto out;
2205         }
2206
2207         /*
2208          * Since we're updating a linked list, we should never find that the
2209          * current pointer is the same as the new value, unless we're
2210          * terminating the list.
2211          */
2212         *old_next_agino = old_value;
2213         if (old_value == next_agino) {
2214                 if (next_agino != NULLAGINO)
2215                         error = -EFSCORRUPTED;
2216                 goto out;
2217         }
2218
2219         /* Ok, update the new pointer. */
2220         xfs_iunlink_update_dinode(tp, agno, XFS_INO_TO_AGINO(mp, ip->i_ino),
2221                         ibp, dip, &ip->i_imap, next_agino);
2222         return 0;
2223 out:
2224         xfs_trans_brelse(tp, ibp);
2225         return error;
2226 }
2227
2228 /*
2229  * This is called when the inode's link count has gone to 0 or we are creating
2230  * a tmpfile via O_TMPFILE.  The inode @ip must have nlink == 0.
2231  *
2232  * We place the on-disk inode on a list in the AGI.  It will be pulled from this
2233  * list when the inode is freed.
2234  */
2235 STATIC int
2236 xfs_iunlink(
2237         struct xfs_trans        *tp,
2238         struct xfs_inode        *ip)
2239 {
2240         struct xfs_mount        *mp = tp->t_mountp;
2241         struct xfs_agi          *agi;
2242         struct xfs_buf          *agibp;
2243         xfs_agino_t             next_agino;
2244         xfs_agnumber_t          agno = XFS_INO_TO_AGNO(mp, ip->i_ino);
2245         xfs_agino_t             agino = XFS_INO_TO_AGINO(mp, ip->i_ino);
2246         short                   bucket_index = agino % XFS_AGI_UNLINKED_BUCKETS;
2247         int                     error;
2248
2249         ASSERT(VFS_I(ip)->i_nlink == 0);
2250         ASSERT(VFS_I(ip)->i_mode != 0);
2251         trace_xfs_iunlink(ip);
2252
2253         /* Get the agi buffer first.  It ensures lock ordering on the list. */
2254         error = xfs_read_agi(mp, tp, agno, &agibp);
2255         if (error)
2256                 return error;
2257         agi = XFS_BUF_TO_AGI(agibp);
2258
2259         /*
2260          * Get the index into the agi hash table for the list this inode will
2261          * go on.  Make sure the pointer isn't garbage and that this inode
2262          * isn't already on the list.
2263          */
2264         next_agino = be32_to_cpu(agi->agi_unlinked[bucket_index]);
2265         if (next_agino == agino ||
2266             !xfs_verify_agino_or_null(mp, agno, next_agino))
2267                 return -EFSCORRUPTED;
2268
2269         if (next_agino != NULLAGINO) {
2270                 struct xfs_perag        *pag;
2271                 xfs_agino_t             old_agino;
2272
2273                 /*
2274                  * There is already another inode in the bucket, so point this
2275                  * inode to the current head of the list.
2276                  */
2277                 error = xfs_iunlink_update_inode(tp, ip, agno, next_agino,
2278                                 &old_agino);
2279                 if (error)
2280                         return error;
2281                 ASSERT(old_agino == NULLAGINO);
2282
2283                 /*
2284                  * agino has been unlinked, add a backref from the next inode
2285                  * back to agino.
2286                  */
2287                 pag = xfs_perag_get(mp, agno);
2288                 error = xfs_iunlink_add_backref(pag, agino, next_agino);
2289                 xfs_perag_put(pag);
2290                 if (error)
2291                         return error;
2292         }
2293
2294         /* Point the head of the list to point to this inode. */
2295         return xfs_iunlink_update_bucket(tp, agno, agibp, bucket_index, agino);
2296 }
2297
2298 /* Return the imap, dinode pointer, and buffer for an inode. */
2299 STATIC int
2300 xfs_iunlink_map_ino(
2301         struct xfs_trans        *tp,
2302         xfs_agnumber_t          agno,
2303         xfs_agino_t             agino,
2304         struct xfs_imap         *imap,
2305         struct xfs_dinode       **dipp,
2306         struct xfs_buf          **bpp)
2307 {
2308         struct xfs_mount        *mp = tp->t_mountp;
2309         int                     error;
2310
2311         imap->im_blkno = 0;
2312         error = xfs_imap(mp, tp, XFS_AGINO_TO_INO(mp, agno, agino), imap, 0);
2313         if (error) {
2314                 xfs_warn(mp, "%s: xfs_imap returned error %d.",
2315                                 __func__, error);
2316                 return error;
2317         }
2318
2319         error = xfs_imap_to_bp(mp, tp, imap, dipp, bpp, 0, 0);
2320         if (error) {
2321                 xfs_warn(mp, "%s: xfs_imap_to_bp returned error %d.",
2322                                 __func__, error);
2323                 return error;
2324         }
2325
2326         return 0;
2327 }
2328
2329 /*
2330  * Walk the unlinked chain from @head_agino until we find the inode that
2331  * points to @target_agino.  Return the inode number, map, dinode pointer,
2332  * and inode cluster buffer of that inode as @agino, @imap, @dipp, and @bpp.
2333  *
2334  * @tp, @pag, @head_agino, and @target_agino are input parameters.
2335  * @agino, @imap, @dipp, and @bpp are all output parameters.
2336  *
2337  * Do not call this function if @target_agino is the head of the list.
2338  */
2339 STATIC int
2340 xfs_iunlink_map_prev(
2341         struct xfs_trans        *tp,
2342         xfs_agnumber_t          agno,
2343         xfs_agino_t             head_agino,
2344         xfs_agino_t             target_agino,
2345         xfs_agino_t             *agino,
2346         struct xfs_imap         *imap,
2347         struct xfs_dinode       **dipp,
2348         struct xfs_buf          **bpp,
2349         struct xfs_perag        *pag)
2350 {
2351         struct xfs_mount        *mp = tp->t_mountp;
2352         xfs_agino_t             next_agino;
2353         int                     error;
2354
2355         ASSERT(head_agino != target_agino);
2356         *bpp = NULL;
2357
2358         /* See if our backref cache can find it faster. */
2359         *agino = xfs_iunlink_lookup_backref(pag, target_agino);
2360         if (*agino != NULLAGINO) {
2361                 error = xfs_iunlink_map_ino(tp, agno, *agino, imap, dipp, bpp);
2362                 if (error)
2363                         return error;
2364
2365                 if (be32_to_cpu((*dipp)->di_next_unlinked) == target_agino)
2366                         return 0;
2367
2368                 /*
2369                  * If we get here the cache contents were corrupt, so drop the
2370                  * buffer and fall back to walking the bucket list.
2371                  */
2372                 xfs_trans_brelse(tp, *bpp);
2373                 *bpp = NULL;
2374                 WARN_ON_ONCE(1);
2375         }
2376
2377         trace_xfs_iunlink_map_prev_fallback(mp, agno);
2378
2379         /* Otherwise, walk the entire bucket until we find it. */
2380         next_agino = head_agino;
2381         while (next_agino != target_agino) {
2382                 xfs_agino_t     unlinked_agino;
2383
2384                 if (*bpp)
2385                         xfs_trans_brelse(tp, *bpp);
2386
2387                 *agino = next_agino;
2388                 error = xfs_iunlink_map_ino(tp, agno, next_agino, imap, dipp,
2389                                 bpp);
2390                 if (error)
2391                         return error;
2392
2393                 unlinked_agino = be32_to_cpu((*dipp)->di_next_unlinked);
2394                 /*
2395                  * Make sure this pointer is valid and isn't an obvious
2396                  * infinite loop.
2397                  */
2398                 if (!xfs_verify_agino(mp, agno, unlinked_agino) ||
2399                     next_agino == unlinked_agino) {
2400                         XFS_CORRUPTION_ERROR(__func__,
2401                                         XFS_ERRLEVEL_LOW, mp,
2402                                         *dipp, sizeof(**dipp));
2403                         error = -EFSCORRUPTED;
2404                         return error;
2405                 }
2406                 next_agino = unlinked_agino;
2407         }
2408
2409         return 0;
2410 }
2411
2412 /*
2413  * Pull the on-disk inode from the AGI unlinked list.
2414  */
2415 STATIC int
2416 xfs_iunlink_remove(
2417         struct xfs_trans        *tp,
2418         struct xfs_inode        *ip)
2419 {
2420         struct xfs_mount        *mp = tp->t_mountp;
2421         struct xfs_agi          *agi;
2422         struct xfs_buf          *agibp;
2423         struct xfs_buf          *last_ibp;
2424         struct xfs_dinode       *last_dip = NULL;
2425         struct xfs_perag        *pag = NULL;
2426         xfs_agnumber_t          agno = XFS_INO_TO_AGNO(mp, ip->i_ino);
2427         xfs_agino_t             agino = XFS_INO_TO_AGINO(mp, ip->i_ino);
2428         xfs_agino_t             next_agino;
2429         xfs_agino_t             head_agino;
2430         short                   bucket_index = agino % XFS_AGI_UNLINKED_BUCKETS;
2431         int                     error;
2432
2433         trace_xfs_iunlink_remove(ip);
2434
2435         /* Get the agi buffer first.  It ensures lock ordering on the list. */
2436         error = xfs_read_agi(mp, tp, agno, &agibp);
2437         if (error)
2438                 return error;
2439         agi = XFS_BUF_TO_AGI(agibp);
2440
2441         /*
2442          * Get the index into the agi hash table for the list this inode will
2443          * go on.  Make sure the head pointer isn't garbage.
2444          */
2445         head_agino = be32_to_cpu(agi->agi_unlinked[bucket_index]);
2446         if (!xfs_verify_agino(mp, agno, head_agino)) {
2447                 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
2448                                 agi, sizeof(*agi));
2449                 return -EFSCORRUPTED;
2450         }
2451
2452         /*
2453          * Set our inode's next_unlinked pointer to NULL and then return
2454          * the old pointer value so that we can update whatever was previous
2455          * to us in the list to point to whatever was next in the list.
2456          */
2457         error = xfs_iunlink_update_inode(tp, ip, agno, NULLAGINO, &next_agino);
2458         if (error)
2459                 return error;
2460
2461         /*
2462          * If there was a backref pointing from the next inode back to this
2463          * one, remove it because we've removed this inode from the list.
2464          *
2465          * Later, if this inode was in the middle of the list we'll update
2466          * this inode's backref to point from the next inode.
2467          */
2468         if (next_agino != NULLAGINO) {
2469                 pag = xfs_perag_get(mp, agno);
2470                 error = xfs_iunlink_change_backref(pag, next_agino,
2471                                 NULLAGINO);
2472                 if (error)
2473                         goto out;
2474         }
2475
2476         if (head_agino == agino) {
2477                 /* Point the head of the list to the next unlinked inode. */
2478                 error = xfs_iunlink_update_bucket(tp, agno, agibp, bucket_index,
2479                                 next_agino);
2480                 if (error)
2481                         goto out;
2482         } else {
2483                 struct xfs_imap imap;
2484                 xfs_agino_t     prev_agino;
2485
2486                 if (!pag)
2487                         pag = xfs_perag_get(mp, agno);
2488
2489                 /* We need to search the list for the inode being freed. */
2490                 error = xfs_iunlink_map_prev(tp, agno, head_agino, agino,
2491                                 &prev_agino, &imap, &last_dip, &last_ibp,
2492                                 pag);
2493                 if (error)
2494                         goto out;
2495
2496                 /* Point the previous inode on the list to the next inode. */
2497                 xfs_iunlink_update_dinode(tp, agno, prev_agino, last_ibp,
2498                                 last_dip, &imap, next_agino);
2499
2500                 /*
2501                  * Now we deal with the backref for this inode.  If this inode
2502                  * pointed at a real inode, change the backref that pointed to
2503                  * us to point to our old next.  If this inode was the end of
2504                  * the list, delete the backref that pointed to us.  Note that
2505                  * change_backref takes care of deleting the backref if
2506                  * next_agino is NULLAGINO.
2507                  */
2508                 error = xfs_iunlink_change_backref(pag, agino, next_agino);
2509                 if (error)
2510                         goto out;
2511         }
2512
2513 out:
2514         if (pag)
2515                 xfs_perag_put(pag);
2516         return error;
2517 }
2518
2519 /*
2520  * A big issue when freeing the inode cluster is that we _cannot_ skip any
2521  * inodes that are in memory - they all must be marked stale and attached to
2522  * the cluster buffer.
2523  */
2524 STATIC int
2525 xfs_ifree_cluster(
2526         xfs_inode_t             *free_ip,
2527         xfs_trans_t             *tp,
2528         struct xfs_icluster     *xic)
2529 {
2530         xfs_mount_t             *mp = free_ip->i_mount;
2531         int                     nbufs;
2532         int                     i, j;
2533         int                     ioffset;
2534         xfs_daddr_t             blkno;
2535         xfs_buf_t               *bp;
2536         xfs_inode_t             *ip;
2537         xfs_inode_log_item_t    *iip;
2538         struct xfs_log_item     *lip;
2539         struct xfs_perag        *pag;
2540         xfs_ino_t               inum;
2541
2542         inum = xic->first_ino;
2543         pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, inum));
2544         nbufs = mp->m_ialloc_blks / mp->m_blocks_per_cluster;
2545
2546         for (j = 0; j < nbufs; j++, inum += mp->m_inodes_per_cluster) {
2547                 /*
2548                  * The allocation bitmap tells us which inodes of the chunk were
2549                  * physically allocated. Skip the cluster if an inode falls into
2550                  * a sparse region.
2551                  */
2552                 ioffset = inum - xic->first_ino;
2553                 if ((xic->alloc & XFS_INOBT_MASK(ioffset)) == 0) {
2554                         ASSERT(ioffset % mp->m_inodes_per_cluster == 0);
2555                         continue;
2556                 }
2557
2558                 blkno = XFS_AGB_TO_DADDR(mp, XFS_INO_TO_AGNO(mp, inum),
2559                                          XFS_INO_TO_AGBNO(mp, inum));
2560
2561                 /*
2562                  * We obtain and lock the backing buffer first in the process
2563                  * here, as we have to ensure that any dirty inode that we
2564                  * can't get the flush lock on is attached to the buffer.
2565                  * If we scan the in-memory inodes first, then buffer IO can
2566                  * complete before we get a lock on it, and hence we may fail
2567                  * to mark all the active inodes on the buffer stale.
2568                  */
2569                 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, blkno,
2570                                         mp->m_bsize * mp->m_blocks_per_cluster,
2571                                         XBF_UNMAPPED);
2572
2573                 if (!bp)
2574                         return -ENOMEM;
2575
2576                 /*
2577                  * This buffer may not have been correctly initialised as we
2578                  * didn't read it from disk. That's not important because we are
2579                  * only using to mark the buffer as stale in the log, and to
2580                  * attach stale cached inodes on it. That means it will never be
2581                  * dispatched for IO. If it is, we want to know about it, and we
2582                  * want it to fail. We can acheive this by adding a write
2583                  * verifier to the buffer.
2584                  */
2585                 bp->b_ops = &xfs_inode_buf_ops;
2586
2587                 /*
2588                  * Walk the inodes already attached to the buffer and mark them
2589                  * stale. These will all have the flush locks held, so an
2590                  * in-memory inode walk can't lock them. By marking them all
2591                  * stale first, we will not attempt to lock them in the loop
2592                  * below as the XFS_ISTALE flag will be set.
2593                  */
2594                 list_for_each_entry(lip, &bp->b_li_list, li_bio_list) {
2595                         if (lip->li_type == XFS_LI_INODE) {
2596                                 iip = (xfs_inode_log_item_t *)lip;
2597                                 ASSERT(iip->ili_logged == 1);
2598                                 lip->li_cb = xfs_istale_done;
2599                                 xfs_trans_ail_copy_lsn(mp->m_ail,
2600                                                         &iip->ili_flush_lsn,
2601                                                         &iip->ili_item.li_lsn);
2602                                 xfs_iflags_set(iip->ili_inode, XFS_ISTALE);
2603                         }
2604                 }
2605
2606
2607                 /*
2608                  * For each inode in memory attempt to add it to the inode
2609                  * buffer and set it up for being staled on buffer IO
2610                  * completion.  This is safe as we've locked out tail pushing
2611                  * and flushing by locking the buffer.
2612                  *
2613                  * We have already marked every inode that was part of a
2614                  * transaction stale above, which means there is no point in
2615                  * even trying to lock them.
2616                  */
2617                 for (i = 0; i < mp->m_inodes_per_cluster; i++) {
2618 retry:
2619                         rcu_read_lock();
2620                         ip = radix_tree_lookup(&pag->pag_ici_root,
2621                                         XFS_INO_TO_AGINO(mp, (inum + i)));
2622
2623                         /* Inode not in memory, nothing to do */
2624                         if (!ip) {
2625                                 rcu_read_unlock();
2626                                 continue;
2627                         }
2628
2629                         /*
2630                          * because this is an RCU protected lookup, we could
2631                          * find a recently freed or even reallocated inode
2632                          * during the lookup. We need to check under the
2633                          * i_flags_lock for a valid inode here. Skip it if it
2634                          * is not valid, the wrong inode or stale.
2635                          */
2636                         spin_lock(&ip->i_flags_lock);
2637                         if (ip->i_ino != inum + i ||
2638                             __xfs_iflags_test(ip, XFS_ISTALE)) {
2639                                 spin_unlock(&ip->i_flags_lock);
2640                                 rcu_read_unlock();
2641                                 continue;
2642                         }
2643                         spin_unlock(&ip->i_flags_lock);
2644
2645                         /*
2646                          * Don't try to lock/unlock the current inode, but we
2647                          * _cannot_ skip the other inodes that we did not find
2648                          * in the list attached to the buffer and are not
2649                          * already marked stale. If we can't lock it, back off
2650                          * and retry.
2651                          */
2652                         if (ip != free_ip) {
2653                                 if (!xfs_ilock_nowait(ip, XFS_ILOCK_EXCL)) {
2654                                         rcu_read_unlock();
2655                                         delay(1);
2656                                         goto retry;
2657                                 }
2658
2659                                 /*
2660                                  * Check the inode number again in case we're
2661                                  * racing with freeing in xfs_reclaim_inode().
2662                                  * See the comments in that function for more
2663                                  * information as to why the initial check is
2664                                  * not sufficient.
2665                                  */
2666                                 if (ip->i_ino != inum + i) {
2667                                         xfs_iunlock(ip, XFS_ILOCK_EXCL);
2668                                         rcu_read_unlock();
2669                                         continue;
2670                                 }
2671                         }
2672                         rcu_read_unlock();
2673
2674                         xfs_iflock(ip);
2675                         xfs_iflags_set(ip, XFS_ISTALE);
2676
2677                         /*
2678                          * we don't need to attach clean inodes or those only
2679                          * with unlogged changes (which we throw away, anyway).
2680                          */
2681                         iip = ip->i_itemp;
2682                         if (!iip || xfs_inode_clean(ip)) {
2683                                 ASSERT(ip != free_ip);
2684                                 xfs_ifunlock(ip);
2685                                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
2686                                 continue;
2687                         }
2688
2689                         iip->ili_last_fields = iip->ili_fields;
2690                         iip->ili_fields = 0;
2691                         iip->ili_fsync_fields = 0;
2692                         iip->ili_logged = 1;
2693                         xfs_trans_ail_copy_lsn(mp->m_ail, &iip->ili_flush_lsn,
2694                                                 &iip->ili_item.li_lsn);
2695
2696                         xfs_buf_attach_iodone(bp, xfs_istale_done,
2697                                                   &iip->ili_item);
2698
2699                         if (ip != free_ip)
2700                                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
2701                 }
2702
2703                 xfs_trans_stale_inode_buf(tp, bp);
2704                 xfs_trans_binval(tp, bp);
2705         }
2706
2707         xfs_perag_put(pag);
2708         return 0;
2709 }
2710
2711 /*
2712  * Free any local-format buffers sitting around before we reset to
2713  * extents format.
2714  */
2715 static inline void
2716 xfs_ifree_local_data(
2717         struct xfs_inode        *ip,
2718         int                     whichfork)
2719 {
2720         struct xfs_ifork        *ifp;
2721
2722         if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_LOCAL)
2723                 return;
2724
2725         ifp = XFS_IFORK_PTR(ip, whichfork);
2726         xfs_idata_realloc(ip, -ifp->if_bytes, whichfork);
2727 }
2728
2729 /*
2730  * This is called to return an inode to the inode free list.
2731  * The inode should already be truncated to 0 length and have
2732  * no pages associated with it.  This routine also assumes that
2733  * the inode is already a part of the transaction.
2734  *
2735  * The on-disk copy of the inode will have been added to the list
2736  * of unlinked inodes in the AGI. We need to remove the inode from
2737  * that list atomically with respect to freeing it here.
2738  */
2739 int
2740 xfs_ifree(
2741         struct xfs_trans        *tp,
2742         struct xfs_inode        *ip)
2743 {
2744         int                     error;
2745         struct xfs_icluster     xic = { 0 };
2746
2747         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
2748         ASSERT(VFS_I(ip)->i_nlink == 0);
2749         ASSERT(ip->i_d.di_nextents == 0);
2750         ASSERT(ip->i_d.di_anextents == 0);
2751         ASSERT(ip->i_d.di_size == 0 || !S_ISREG(VFS_I(ip)->i_mode));
2752         ASSERT(ip->i_d.di_nblocks == 0);
2753
2754         /*
2755          * Pull the on-disk inode from the AGI unlinked list.
2756          */
2757         error = xfs_iunlink_remove(tp, ip);
2758         if (error)
2759                 return error;
2760
2761         error = xfs_difree(tp, ip->i_ino, &xic);
2762         if (error)
2763                 return error;
2764
2765         xfs_ifree_local_data(ip, XFS_DATA_FORK);
2766         xfs_ifree_local_data(ip, XFS_ATTR_FORK);
2767
2768         VFS_I(ip)->i_mode = 0;          /* mark incore inode as free */
2769         ip->i_d.di_flags = 0;
2770         ip->i_d.di_flags2 = 0;
2771         ip->i_d.di_dmevmask = 0;
2772         ip->i_d.di_forkoff = 0;         /* mark the attr fork not in use */
2773         ip->i_d.di_format = XFS_DINODE_FMT_EXTENTS;
2774         ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
2775
2776         /* Don't attempt to replay owner changes for a deleted inode */
2777         ip->i_itemp->ili_fields &= ~(XFS_ILOG_AOWNER|XFS_ILOG_DOWNER);
2778
2779         /*
2780          * Bump the generation count so no one will be confused
2781          * by reincarnations of this inode.
2782          */
2783         VFS_I(ip)->i_generation++;
2784         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
2785
2786         if (xic.deleted)
2787                 error = xfs_ifree_cluster(ip, tp, &xic);
2788
2789         return error;
2790 }
2791
2792 /*
2793  * This is called to unpin an inode.  The caller must have the inode locked
2794  * in at least shared mode so that the buffer cannot be subsequently pinned
2795  * once someone is waiting for it to be unpinned.
2796  */
2797 static void
2798 xfs_iunpin(
2799         struct xfs_inode        *ip)
2800 {
2801         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
2802
2803         trace_xfs_inode_unpin_nowait(ip, _RET_IP_);
2804
2805         /* Give the log a push to start the unpinning I/O */
2806         xfs_log_force_lsn(ip->i_mount, ip->i_itemp->ili_last_lsn, 0, NULL);
2807
2808 }
2809
2810 static void
2811 __xfs_iunpin_wait(
2812         struct xfs_inode        *ip)
2813 {
2814         wait_queue_head_t *wq = bit_waitqueue(&ip->i_flags, __XFS_IPINNED_BIT);
2815         DEFINE_WAIT_BIT(wait, &ip->i_flags, __XFS_IPINNED_BIT);
2816
2817         xfs_iunpin(ip);
2818
2819         do {
2820                 prepare_to_wait(wq, &wait.wq_entry, TASK_UNINTERRUPTIBLE);
2821                 if (xfs_ipincount(ip))
2822                         io_schedule();
2823         } while (xfs_ipincount(ip));
2824         finish_wait(wq, &wait.wq_entry);
2825 }
2826
2827 void
2828 xfs_iunpin_wait(
2829         struct xfs_inode        *ip)
2830 {
2831         if (xfs_ipincount(ip))
2832                 __xfs_iunpin_wait(ip);
2833 }
2834
2835 /*
2836  * Removing an inode from the namespace involves removing the directory entry
2837  * and dropping the link count on the inode. Removing the directory entry can
2838  * result in locking an AGF (directory blocks were freed) and removing a link
2839  * count can result in placing the inode on an unlinked list which results in
2840  * locking an AGI.
2841  *
2842  * The big problem here is that we have an ordering constraint on AGF and AGI
2843  * locking - inode allocation locks the AGI, then can allocate a new extent for
2844  * new inodes, locking the AGF after the AGI. Similarly, freeing the inode
2845  * removes the inode from the unlinked list, requiring that we lock the AGI
2846  * first, and then freeing the inode can result in an inode chunk being freed
2847  * and hence freeing disk space requiring that we lock an AGF.
2848  *
2849  * Hence the ordering that is imposed by other parts of the code is AGI before
2850  * AGF. This means we cannot remove the directory entry before we drop the inode
2851  * reference count and put it on the unlinked list as this results in a lock
2852  * order of AGF then AGI, and this can deadlock against inode allocation and
2853  * freeing. Therefore we must drop the link counts before we remove the
2854  * directory entry.
2855  *
2856  * This is still safe from a transactional point of view - it is not until we
2857  * get to xfs_defer_finish() that we have the possibility of multiple
2858  * transactions in this operation. Hence as long as we remove the directory
2859  * entry and drop the link count in the first transaction of the remove
2860  * operation, there are no transactional constraints on the ordering here.
2861  */
2862 int
2863 xfs_remove(
2864         xfs_inode_t             *dp,
2865         struct xfs_name         *name,
2866         xfs_inode_t             *ip)
2867 {
2868         xfs_mount_t             *mp = dp->i_mount;
2869         xfs_trans_t             *tp = NULL;
2870         int                     is_dir = S_ISDIR(VFS_I(ip)->i_mode);
2871         int                     error = 0;
2872         uint                    resblks;
2873
2874         trace_xfs_remove(dp, name);
2875
2876         if (XFS_FORCED_SHUTDOWN(mp))
2877                 return -EIO;
2878
2879         error = xfs_qm_dqattach(dp);
2880         if (error)
2881                 goto std_return;
2882
2883         error = xfs_qm_dqattach(ip);
2884         if (error)
2885                 goto std_return;
2886
2887         /*
2888          * We try to get the real space reservation first,
2889          * allowing for directory btree deletion(s) implying
2890          * possible bmap insert(s).  If we can't get the space
2891          * reservation then we use 0 instead, and avoid the bmap
2892          * btree insert(s) in the directory code by, if the bmap
2893          * insert tries to happen, instead trimming the LAST
2894          * block from the directory.
2895          */
2896         resblks = XFS_REMOVE_SPACE_RES(mp);
2897         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_remove, resblks, 0, 0, &tp);
2898         if (error == -ENOSPC) {
2899                 resblks = 0;
2900                 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_remove, 0, 0, 0,
2901                                 &tp);
2902         }
2903         if (error) {
2904                 ASSERT(error != -ENOSPC);
2905                 goto std_return;
2906         }
2907
2908         xfs_lock_two_inodes(dp, XFS_ILOCK_EXCL, ip, XFS_ILOCK_EXCL);
2909
2910         xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
2911         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
2912
2913         /*
2914          * If we're removing a directory perform some additional validation.
2915          */
2916         if (is_dir) {
2917                 ASSERT(VFS_I(ip)->i_nlink >= 2);
2918                 if (VFS_I(ip)->i_nlink != 2) {
2919                         error = -ENOTEMPTY;
2920                         goto out_trans_cancel;
2921                 }
2922                 if (!xfs_dir_isempty(ip)) {
2923                         error = -ENOTEMPTY;
2924                         goto out_trans_cancel;
2925                 }
2926
2927                 /* Drop the link from ip's "..".  */
2928                 error = xfs_droplink(tp, dp);
2929                 if (error)
2930                         goto out_trans_cancel;
2931
2932                 /* Drop the "." link from ip to self.  */
2933                 error = xfs_droplink(tp, ip);
2934                 if (error)
2935                         goto out_trans_cancel;
2936         } else {
2937                 /*
2938                  * When removing a non-directory we need to log the parent
2939                  * inode here.  For a directory this is done implicitly
2940                  * by the xfs_droplink call for the ".." entry.
2941                  */
2942                 xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
2943         }
2944         xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
2945
2946         /* Drop the link from dp to ip. */
2947         error = xfs_droplink(tp, ip);
2948         if (error)
2949                 goto out_trans_cancel;
2950
2951         error = xfs_dir_removename(tp, dp, name, ip->i_ino, resblks);
2952         if (error) {
2953                 ASSERT(error != -ENOENT);
2954                 goto out_trans_cancel;
2955         }
2956
2957         /*
2958          * If this is a synchronous mount, make sure that the
2959          * remove transaction goes to disk before returning to
2960          * the user.
2961          */
2962         if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
2963                 xfs_trans_set_sync(tp);
2964
2965         error = xfs_trans_commit(tp);
2966         if (error)
2967                 goto std_return;
2968
2969         if (is_dir && xfs_inode_is_filestream(ip))
2970                 xfs_filestream_deassociate(ip);
2971
2972         return 0;
2973
2974  out_trans_cancel:
2975         xfs_trans_cancel(tp);
2976  std_return:
2977         return error;
2978 }
2979
2980 /*
2981  * Enter all inodes for a rename transaction into a sorted array.
2982  */
2983 #define __XFS_SORT_INODES       5
2984 STATIC void
2985 xfs_sort_for_rename(
2986         struct xfs_inode        *dp1,   /* in: old (source) directory inode */
2987         struct xfs_inode        *dp2,   /* in: new (target) directory inode */
2988         struct xfs_inode        *ip1,   /* in: inode of old entry */
2989         struct xfs_inode        *ip2,   /* in: inode of new entry */
2990         struct xfs_inode        *wip,   /* in: whiteout inode */
2991         struct xfs_inode        **i_tab,/* out: sorted array of inodes */
2992         int                     *num_inodes)  /* in/out: inodes in array */
2993 {
2994         int                     i, j;
2995
2996         ASSERT(*num_inodes == __XFS_SORT_INODES);
2997         memset(i_tab, 0, *num_inodes * sizeof(struct xfs_inode *));
2998
2999         /*
3000          * i_tab contains a list of pointers to inodes.  We initialize
3001          * the table here & we'll sort it.  We will then use it to
3002          * order the acquisition of the inode locks.
3003          *
3004          * Note that the table may contain duplicates.  e.g., dp1 == dp2.
3005          */
3006         i = 0;
3007         i_tab[i++] = dp1;
3008         i_tab[i++] = dp2;
3009         i_tab[i++] = ip1;
3010         if (ip2)
3011                 i_tab[i++] = ip2;
3012         if (wip)
3013                 i_tab[i++] = wip;
3014         *num_inodes = i;
3015
3016         /*
3017          * Sort the elements via bubble sort.  (Remember, there are at
3018          * most 5 elements to sort, so this is adequate.)
3019          */
3020         for (i = 0; i < *num_inodes; i++) {
3021                 for (j = 1; j < *num_inodes; j++) {
3022                         if (i_tab[j]->i_ino < i_tab[j-1]->i_ino) {
3023                                 struct xfs_inode *temp = i_tab[j];
3024                                 i_tab[j] = i_tab[j-1];
3025                                 i_tab[j-1] = temp;
3026                         }
3027                 }
3028         }
3029 }
3030
3031 static int
3032 xfs_finish_rename(
3033         struct xfs_trans        *tp)
3034 {
3035         /*
3036          * If this is a synchronous mount, make sure that the rename transaction
3037          * goes to disk before returning to the user.
3038          */
3039         if (tp->t_mountp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
3040                 xfs_trans_set_sync(tp);
3041
3042         return xfs_trans_commit(tp);
3043 }
3044
3045 /*
3046  * xfs_cross_rename()
3047  *
3048  * responsible for handling RENAME_EXCHANGE flag in renameat2() sytemcall
3049  */
3050 STATIC int
3051 xfs_cross_rename(
3052         struct xfs_trans        *tp,
3053         struct xfs_inode        *dp1,
3054         struct xfs_name         *name1,
3055         struct xfs_inode        *ip1,
3056         struct xfs_inode        *dp2,
3057         struct xfs_name         *name2,
3058         struct xfs_inode        *ip2,
3059         int                     spaceres)
3060 {
3061         int             error = 0;
3062         int             ip1_flags = 0;
3063         int             ip2_flags = 0;
3064         int             dp2_flags = 0;
3065
3066         /* Swap inode number for dirent in first parent */
3067         error = xfs_dir_replace(tp, dp1, name1, ip2->i_ino, spaceres);
3068         if (error)
3069                 goto out_trans_abort;
3070
3071         /* Swap inode number for dirent in second parent */
3072         error = xfs_dir_replace(tp, dp2, name2, ip1->i_ino, spaceres);
3073         if (error)
3074                 goto out_trans_abort;
3075
3076         /*
3077          * If we're renaming one or more directories across different parents,
3078          * update the respective ".." entries (and link counts) to match the new
3079          * parents.
3080          */
3081         if (dp1 != dp2) {
3082                 dp2_flags = XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG;
3083
3084                 if (S_ISDIR(VFS_I(ip2)->i_mode)) {
3085                         error = xfs_dir_replace(tp, ip2, &xfs_name_dotdot,
3086                                                 dp1->i_ino, spaceres);
3087                         if (error)
3088                                 goto out_trans_abort;
3089
3090                         /* transfer ip2 ".." reference to dp1 */
3091                         if (!S_ISDIR(VFS_I(ip1)->i_mode)) {
3092                                 error = xfs_droplink(tp, dp2);
3093                                 if (error)
3094                                         goto out_trans_abort;
3095                                 xfs_bumplink(tp, dp1);
3096                         }
3097
3098                         /*
3099                          * Although ip1 isn't changed here, userspace needs
3100                          * to be warned about the change, so that applications
3101                          * relying on it (like backup ones), will properly
3102                          * notify the change
3103                          */
3104                         ip1_flags |= XFS_ICHGTIME_CHG;
3105                         ip2_flags |= XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG;
3106                 }
3107
3108                 if (S_ISDIR(VFS_I(ip1)->i_mode)) {
3109                         error = xfs_dir_replace(tp, ip1, &xfs_name_dotdot,
3110                                                 dp2->i_ino, spaceres);
3111                         if (error)
3112                                 goto out_trans_abort;
3113
3114                         /* transfer ip1 ".." reference to dp2 */
3115                         if (!S_ISDIR(VFS_I(ip2)->i_mode)) {
3116                                 error = xfs_droplink(tp, dp1);
3117                                 if (error)
3118                                         goto out_trans_abort;
3119                                 xfs_bumplink(tp, dp2);
3120                         }
3121
3122                         /*
3123                          * Although ip2 isn't changed here, userspace needs
3124                          * to be warned about the change, so that applications
3125                          * relying on it (like backup ones), will properly
3126                          * notify the change
3127                          */
3128                         ip1_flags |= XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG;
3129                         ip2_flags |= XFS_ICHGTIME_CHG;
3130                 }
3131         }
3132
3133         if (ip1_flags) {
3134                 xfs_trans_ichgtime(tp, ip1, ip1_flags);
3135                 xfs_trans_log_inode(tp, ip1, XFS_ILOG_CORE);
3136         }
3137         if (ip2_flags) {
3138                 xfs_trans_ichgtime(tp, ip2, ip2_flags);
3139                 xfs_trans_log_inode(tp, ip2, XFS_ILOG_CORE);
3140         }
3141         if (dp2_flags) {
3142                 xfs_trans_ichgtime(tp, dp2, dp2_flags);
3143                 xfs_trans_log_inode(tp, dp2, XFS_ILOG_CORE);
3144         }
3145         xfs_trans_ichgtime(tp, dp1, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
3146         xfs_trans_log_inode(tp, dp1, XFS_ILOG_CORE);
3147         return xfs_finish_rename(tp);
3148
3149 out_trans_abort:
3150         xfs_trans_cancel(tp);
3151         return error;
3152 }
3153
3154 /*
3155  * xfs_rename_alloc_whiteout()
3156  *
3157  * Return a referenced, unlinked, unlocked inode that that can be used as a
3158  * whiteout in a rename transaction. We use a tmpfile inode here so that if we
3159  * crash between allocating the inode and linking it into the rename transaction
3160  * recovery will free the inode and we won't leak it.
3161  */
3162 static int
3163 xfs_rename_alloc_whiteout(
3164         struct xfs_inode        *dp,
3165         struct xfs_inode        **wip)
3166 {
3167         struct xfs_inode        *tmpfile;
3168         int                     error;
3169
3170         error = xfs_create_tmpfile(dp, S_IFCHR | WHITEOUT_MODE, &tmpfile);
3171         if (error)
3172                 return error;
3173
3174         /*
3175          * Prepare the tmpfile inode as if it were created through the VFS.
3176          * Complete the inode setup and flag it as linkable.  nlink is already
3177          * zero, so we can skip the drop_nlink.
3178          */
3179         xfs_setup_iops(tmpfile);
3180         xfs_finish_inode_setup(tmpfile);
3181         VFS_I(tmpfile)->i_state |= I_LINKABLE;
3182
3183         *wip = tmpfile;
3184         return 0;
3185 }
3186
3187 /*
3188  * xfs_rename
3189  */
3190 int
3191 xfs_rename(
3192         struct xfs_inode        *src_dp,
3193         struct xfs_name         *src_name,
3194         struct xfs_inode        *src_ip,
3195         struct xfs_inode        *target_dp,
3196         struct xfs_name         *target_name,
3197         struct xfs_inode        *target_ip,
3198         unsigned int            flags)
3199 {
3200         struct xfs_mount        *mp = src_dp->i_mount;
3201         struct xfs_trans        *tp;
3202         struct xfs_inode        *wip = NULL;            /* whiteout inode */
3203         struct xfs_inode        *inodes[__XFS_SORT_INODES];
3204         int                     num_inodes = __XFS_SORT_INODES;
3205         bool                    new_parent = (src_dp != target_dp);
3206         bool                    src_is_directory = S_ISDIR(VFS_I(src_ip)->i_mode);
3207         int                     spaceres;
3208         int                     error;
3209
3210         trace_xfs_rename(src_dp, target_dp, src_name, target_name);
3211
3212         if ((flags & RENAME_EXCHANGE) && !target_ip)
3213                 return -EINVAL;
3214
3215         /*
3216          * If we are doing a whiteout operation, allocate the whiteout inode
3217          * we will be placing at the target and ensure the type is set
3218          * appropriately.
3219          */
3220         if (flags & RENAME_WHITEOUT) {
3221                 ASSERT(!(flags & (RENAME_NOREPLACE | RENAME_EXCHANGE)));
3222                 error = xfs_rename_alloc_whiteout(target_dp, &wip);
3223                 if (error)
3224                         return error;
3225
3226                 /* setup target dirent info as whiteout */
3227                 src_name->type = XFS_DIR3_FT_CHRDEV;
3228         }
3229
3230         xfs_sort_for_rename(src_dp, target_dp, src_ip, target_ip, wip,
3231                                 inodes, &num_inodes);
3232
3233         spaceres = XFS_RENAME_SPACE_RES(mp, target_name->len);
3234         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_rename, spaceres, 0, 0, &tp);
3235         if (error == -ENOSPC) {
3236                 spaceres = 0;
3237                 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_rename, 0, 0, 0,
3238                                 &tp);
3239         }
3240         if (error)
3241                 goto out_release_wip;
3242
3243         /*
3244          * Attach the dquots to the inodes
3245          */
3246         error = xfs_qm_vop_rename_dqattach(inodes);
3247         if (error)
3248                 goto out_trans_cancel;
3249
3250         /*
3251          * Lock all the participating inodes. Depending upon whether
3252          * the target_name exists in the target directory, and
3253          * whether the target directory is the same as the source
3254          * directory, we can lock from 2 to 4 inodes.
3255          */
3256         xfs_lock_inodes(inodes, num_inodes, XFS_ILOCK_EXCL);
3257
3258         /*
3259          * Join all the inodes to the transaction. From this point on,
3260          * we can rely on either trans_commit or trans_cancel to unlock
3261          * them.
3262          */
3263         xfs_trans_ijoin(tp, src_dp, XFS_ILOCK_EXCL);
3264         if (new_parent)
3265                 xfs_trans_ijoin(tp, target_dp, XFS_ILOCK_EXCL);
3266         xfs_trans_ijoin(tp, src_ip, XFS_ILOCK_EXCL);
3267         if (target_ip)
3268                 xfs_trans_ijoin(tp, target_ip, XFS_ILOCK_EXCL);
3269         if (wip)
3270                 xfs_trans_ijoin(tp, wip, XFS_ILOCK_EXCL);
3271
3272         /*
3273          * If we are using project inheritance, we only allow renames
3274          * into our tree when the project IDs are the same; else the
3275          * tree quota mechanism would be circumvented.
3276          */
3277         if (unlikely((target_dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
3278                      (xfs_get_projid(target_dp) != xfs_get_projid(src_ip)))) {
3279                 error = -EXDEV;
3280                 goto out_trans_cancel;
3281         }
3282
3283         /* RENAME_EXCHANGE is unique from here on. */
3284         if (flags & RENAME_EXCHANGE)
3285                 return xfs_cross_rename(tp, src_dp, src_name, src_ip,
3286                                         target_dp, target_name, target_ip,
3287                                         spaceres);
3288
3289         /*
3290          * Set up the target.
3291          */
3292         if (target_ip == NULL) {
3293                 /*
3294                  * If there's no space reservation, check the entry will
3295                  * fit before actually inserting it.
3296                  */
3297                 if (!spaceres) {
3298                         error = xfs_dir_canenter(tp, target_dp, target_name);
3299                         if (error)
3300                                 goto out_trans_cancel;
3301                 }
3302                 /*
3303                  * If target does not exist and the rename crosses
3304                  * directories, adjust the target directory link count
3305                  * to account for the ".." reference from the new entry.
3306                  */
3307                 error = xfs_dir_createname(tp, target_dp, target_name,
3308                                            src_ip->i_ino, spaceres);
3309                 if (error)
3310                         goto out_trans_cancel;
3311
3312                 xfs_trans_ichgtime(tp, target_dp,
3313                                         XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
3314
3315                 if (new_parent && src_is_directory) {
3316                         xfs_bumplink(tp, target_dp);
3317                 }
3318         } else { /* target_ip != NULL */
3319                 /*
3320                  * If target exists and it's a directory, check that both
3321                  * target and source are directories and that target can be
3322                  * destroyed, or that neither is a directory.
3323                  */
3324                 if (S_ISDIR(VFS_I(target_ip)->i_mode)) {
3325                         /*
3326                          * Make sure target dir is empty.
3327                          */
3328                         if (!(xfs_dir_isempty(target_ip)) ||
3329                             (VFS_I(target_ip)->i_nlink > 2)) {
3330                                 error = -EEXIST;
3331                                 goto out_trans_cancel;
3332                         }
3333                 }
3334
3335                 /*
3336                  * Link the source inode under the target name.
3337                  * If the source inode is a directory and we are moving
3338                  * it across directories, its ".." entry will be
3339                  * inconsistent until we replace that down below.
3340                  *
3341                  * In case there is already an entry with the same
3342                  * name at the destination directory, remove it first.
3343                  */
3344                 error = xfs_dir_replace(tp, target_dp, target_name,
3345                                         src_ip->i_ino, spaceres);
3346                 if (error)
3347                         goto out_trans_cancel;
3348
3349                 xfs_trans_ichgtime(tp, target_dp,
3350                                         XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
3351
3352                 /*
3353                  * Decrement the link count on the target since the target
3354                  * dir no longer points to it.
3355                  */
3356                 error = xfs_droplink(tp, target_ip);
3357                 if (error)
3358                         goto out_trans_cancel;
3359
3360                 if (src_is_directory) {
3361                         /*
3362                          * Drop the link from the old "." entry.
3363                          */
3364                         error = xfs_droplink(tp, target_ip);
3365                         if (error)
3366                                 goto out_trans_cancel;
3367                 }
3368         } /* target_ip != NULL */
3369
3370         /*
3371          * Remove the source.
3372          */
3373         if (new_parent && src_is_directory) {
3374                 /*
3375                  * Rewrite the ".." entry to point to the new
3376                  * directory.
3377                  */
3378                 error = xfs_dir_replace(tp, src_ip, &xfs_name_dotdot,
3379                                         target_dp->i_ino, spaceres);
3380                 ASSERT(error != -EEXIST);
3381                 if (error)
3382                         goto out_trans_cancel;
3383         }
3384
3385         /*
3386          * We always want to hit the ctime on the source inode.
3387          *
3388          * This isn't strictly required by the standards since the source
3389          * inode isn't really being changed, but old unix file systems did
3390          * it and some incremental backup programs won't work without it.
3391          */
3392         xfs_trans_ichgtime(tp, src_ip, XFS_ICHGTIME_CHG);
3393         xfs_trans_log_inode(tp, src_ip, XFS_ILOG_CORE);
3394
3395         /*
3396          * Adjust the link count on src_dp.  This is necessary when
3397          * renaming a directory, either within one parent when
3398          * the target existed, or across two parent directories.
3399          */
3400         if (src_is_directory && (new_parent || target_ip != NULL)) {
3401
3402                 /*
3403                  * Decrement link count on src_directory since the
3404                  * entry that's moved no longer points to it.
3405                  */
3406                 error = xfs_droplink(tp, src_dp);
3407                 if (error)
3408                         goto out_trans_cancel;
3409         }
3410
3411         /*
3412          * For whiteouts, we only need to update the source dirent with the
3413          * inode number of the whiteout inode rather than removing it
3414          * altogether.
3415          */
3416         if (wip) {
3417                 error = xfs_dir_replace(tp, src_dp, src_name, wip->i_ino,
3418                                         spaceres);
3419         } else
3420                 error = xfs_dir_removename(tp, src_dp, src_name, src_ip->i_ino,
3421                                            spaceres);
3422         if (error)
3423                 goto out_trans_cancel;
3424
3425         /*
3426          * For whiteouts, we need to bump the link count on the whiteout inode.
3427          * This means that failures all the way up to this point leave the inode
3428          * on the unlinked list and so cleanup is a simple matter of dropping
3429          * the remaining reference to it. If we fail here after bumping the link
3430          * count, we're shutting down the filesystem so we'll never see the
3431          * intermediate state on disk.
3432          */
3433         if (wip) {
3434                 ASSERT(VFS_I(wip)->i_nlink == 0);
3435                 xfs_bumplink(tp, wip);
3436                 error = xfs_iunlink_remove(tp, wip);
3437                 if (error)
3438                         goto out_trans_cancel;
3439                 xfs_trans_log_inode(tp, wip, XFS_ILOG_CORE);
3440
3441                 /*
3442                  * Now we have a real link, clear the "I'm a tmpfile" state
3443                  * flag from the inode so it doesn't accidentally get misused in
3444                  * future.
3445                  */
3446                 VFS_I(wip)->i_state &= ~I_LINKABLE;
3447         }
3448
3449         xfs_trans_ichgtime(tp, src_dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
3450         xfs_trans_log_inode(tp, src_dp, XFS_ILOG_CORE);
3451         if (new_parent)
3452                 xfs_trans_log_inode(tp, target_dp, XFS_ILOG_CORE);
3453
3454         error = xfs_finish_rename(tp);
3455         if (wip)
3456                 xfs_irele(wip);
3457         return error;
3458
3459 out_trans_cancel:
3460         xfs_trans_cancel(tp);
3461 out_release_wip:
3462         if (wip)
3463                 xfs_irele(wip);
3464         return error;
3465 }
3466
3467 STATIC int
3468 xfs_iflush_cluster(
3469         struct xfs_inode        *ip,
3470         struct xfs_buf          *bp)
3471 {
3472         struct xfs_mount        *mp = ip->i_mount;
3473         struct xfs_perag        *pag;
3474         unsigned long           first_index, mask;
3475         unsigned long           inodes_per_cluster;
3476         int                     cilist_size;
3477         struct xfs_inode        **cilist;
3478         struct xfs_inode        *cip;
3479         int                     nr_found;
3480         int                     clcount = 0;
3481         int                     i;
3482
3483         pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
3484
3485         inodes_per_cluster = mp->m_inode_cluster_size >> mp->m_sb.sb_inodelog;
3486         cilist_size = inodes_per_cluster * sizeof(xfs_inode_t *);
3487         cilist = kmem_alloc(cilist_size, KM_MAYFAIL|KM_NOFS);
3488         if (!cilist)
3489                 goto out_put;
3490
3491         mask = ~(((mp->m_inode_cluster_size >> mp->m_sb.sb_inodelog)) - 1);
3492         first_index = XFS_INO_TO_AGINO(mp, ip->i_ino) & mask;
3493         rcu_read_lock();
3494         /* really need a gang lookup range call here */
3495         nr_found = radix_tree_gang_lookup(&pag->pag_ici_root, (void**)cilist,
3496                                         first_index, inodes_per_cluster);
3497         if (nr_found == 0)
3498                 goto out_free;
3499
3500         for (i = 0; i < nr_found; i++) {
3501                 cip = cilist[i];
3502                 if (cip == ip)
3503                         continue;
3504
3505                 /*
3506                  * because this is an RCU protected lookup, we could find a
3507                  * recently freed or even reallocated inode during the lookup.
3508                  * We need to check under the i_flags_lock for a valid inode
3509                  * here. Skip it if it is not valid or the wrong inode.
3510                  */
3511                 spin_lock(&cip->i_flags_lock);
3512                 if (!cip->i_ino ||
3513                     __xfs_iflags_test(cip, XFS_ISTALE)) {
3514                         spin_unlock(&cip->i_flags_lock);
3515                         continue;
3516                 }
3517
3518                 /*
3519                  * Once we fall off the end of the cluster, no point checking
3520                  * any more inodes in the list because they will also all be
3521                  * outside the cluster.
3522                  */
3523                 if ((XFS_INO_TO_AGINO(mp, cip->i_ino) & mask) != first_index) {
3524                         spin_unlock(&cip->i_flags_lock);
3525                         break;
3526                 }
3527                 spin_unlock(&cip->i_flags_lock);
3528
3529                 /*
3530                  * Do an un-protected check to see if the inode is dirty and
3531                  * is a candidate for flushing.  These checks will be repeated
3532                  * later after the appropriate locks are acquired.
3533                  */
3534                 if (xfs_inode_clean(cip) && xfs_ipincount(cip) == 0)
3535                         continue;
3536
3537                 /*
3538                  * Try to get locks.  If any are unavailable or it is pinned,
3539                  * then this inode cannot be flushed and is skipped.
3540                  */
3541
3542                 if (!xfs_ilock_nowait(cip, XFS_ILOCK_SHARED))
3543                         continue;
3544                 if (!xfs_iflock_nowait(cip)) {
3545                         xfs_iunlock(cip, XFS_ILOCK_SHARED);
3546                         continue;
3547                 }
3548                 if (xfs_ipincount(cip)) {
3549                         xfs_ifunlock(cip);
3550                         xfs_iunlock(cip, XFS_ILOCK_SHARED);
3551                         continue;
3552                 }
3553
3554
3555                 /*
3556                  * Check the inode number again, just to be certain we are not
3557                  * racing with freeing in xfs_reclaim_inode(). See the comments
3558                  * in that function for more information as to why the initial
3559                  * check is not sufficient.
3560                  */
3561                 if (!cip->i_ino) {
3562                         xfs_ifunlock(cip);
3563                         xfs_iunlock(cip, XFS_ILOCK_SHARED);
3564                         continue;
3565                 }
3566
3567                 /*
3568                  * arriving here means that this inode can be flushed.  First
3569                  * re-check that it's dirty before flushing.
3570                  */
3571                 if (!xfs_inode_clean(cip)) {
3572                         int     error;
3573                         error = xfs_iflush_int(cip, bp);
3574                         if (error) {
3575                                 xfs_iunlock(cip, XFS_ILOCK_SHARED);
3576                                 goto cluster_corrupt_out;
3577                         }
3578                         clcount++;
3579                 } else {
3580                         xfs_ifunlock(cip);
3581                 }
3582                 xfs_iunlock(cip, XFS_ILOCK_SHARED);
3583         }
3584
3585         if (clcount) {
3586                 XFS_STATS_INC(mp, xs_icluster_flushcnt);
3587                 XFS_STATS_ADD(mp, xs_icluster_flushinode, clcount);
3588         }
3589
3590 out_free:
3591         rcu_read_unlock();
3592         kmem_free(cilist);
3593 out_put:
3594         xfs_perag_put(pag);
3595         return 0;
3596
3597
3598 cluster_corrupt_out:
3599         /*
3600          * Corruption detected in the clustering loop.  Invalidate the
3601          * inode buffer and shut down the filesystem.
3602          */
3603         rcu_read_unlock();
3604
3605         /*
3606          * We'll always have an inode attached to the buffer for completion
3607          * process by the time we are called from xfs_iflush(). Hence we have
3608          * always need to do IO completion processing to abort the inodes
3609          * attached to the buffer.  handle them just like the shutdown case in
3610          * xfs_buf_submit().
3611          */
3612         ASSERT(bp->b_iodone);
3613         bp->b_flags |= XBF_ASYNC;
3614         bp->b_flags &= ~XBF_DONE;
3615         xfs_buf_stale(bp);
3616         xfs_buf_ioerror(bp, -EIO);
3617         xfs_buf_ioend(bp);
3618
3619         xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
3620
3621         /* abort the corrupt inode, as it was not attached to the buffer */
3622         xfs_iflush_abort(cip, false);
3623         kmem_free(cilist);
3624         xfs_perag_put(pag);
3625         return -EFSCORRUPTED;
3626 }
3627
3628 /*
3629  * Flush dirty inode metadata into the backing buffer.
3630  *
3631  * The caller must have the inode lock and the inode flush lock held.  The
3632  * inode lock will still be held upon return to the caller, and the inode
3633  * flush lock will be released after the inode has reached the disk.
3634  *
3635  * The caller must write out the buffer returned in *bpp and release it.
3636  */
3637 int
3638 xfs_iflush(
3639         struct xfs_inode        *ip,
3640         struct xfs_buf          **bpp)
3641 {
3642         struct xfs_mount        *mp = ip->i_mount;
3643         struct xfs_buf          *bp = NULL;
3644         struct xfs_dinode       *dip;
3645         int                     error;
3646
3647         XFS_STATS_INC(mp, xs_iflush_count);
3648
3649         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
3650         ASSERT(xfs_isiflocked(ip));
3651         ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE ||
3652                ip->i_d.di_nextents > XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK));
3653
3654         *bpp = NULL;
3655
3656         xfs_iunpin_wait(ip);
3657
3658         /*
3659          * For stale inodes we cannot rely on the backing buffer remaining
3660          * stale in cache for the remaining life of the stale inode and so
3661          * xfs_imap_to_bp() below may give us a buffer that no longer contains
3662          * inodes below. We have to check this after ensuring the inode is
3663          * unpinned so that it is safe to reclaim the stale inode after the
3664          * flush call.
3665          */
3666         if (xfs_iflags_test(ip, XFS_ISTALE)) {
3667                 xfs_ifunlock(ip);
3668                 return 0;
3669         }
3670
3671         /*
3672          * This may have been unpinned because the filesystem is shutting
3673          * down forcibly. If that's the case we must not write this inode
3674          * to disk, because the log record didn't make it to disk.
3675          *
3676          * We also have to remove the log item from the AIL in this case,
3677          * as we wait for an empty AIL as part of the unmount process.
3678          */
3679         if (XFS_FORCED_SHUTDOWN(mp)) {
3680                 error = -EIO;
3681                 goto abort_out;
3682         }
3683
3684         /*
3685          * Get the buffer containing the on-disk inode. We are doing a try-lock
3686          * operation here, so we may get  an EAGAIN error. In that case, we
3687          * simply want to return with the inode still dirty.
3688          *
3689          * If we get any other error, we effectively have a corruption situation
3690          * and we cannot flush the inode, so we treat it the same as failing
3691          * xfs_iflush_int().
3692          */
3693         error = xfs_imap_to_bp(mp, NULL, &ip->i_imap, &dip, &bp, XBF_TRYLOCK,
3694                                0);
3695         if (error == -EAGAIN) {
3696                 xfs_ifunlock(ip);
3697                 return error;
3698         }
3699         if (error)
3700                 goto corrupt_out;
3701
3702         /*
3703          * First flush out the inode that xfs_iflush was called with.
3704          */
3705         error = xfs_iflush_int(ip, bp);
3706         if (error)
3707                 goto corrupt_out;
3708
3709         /*
3710          * If the buffer is pinned then push on the log now so we won't
3711          * get stuck waiting in the write for too long.
3712          */
3713         if (xfs_buf_ispinned(bp))
3714                 xfs_log_force(mp, 0);
3715
3716         /*
3717          * inode clustering: try to gather other inodes into this write
3718          *
3719          * Note: Any error during clustering will result in the filesystem
3720          * being shut down and completion callbacks run on the cluster buffer.
3721          * As we have already flushed and attached this inode to the buffer,
3722          * it has already been aborted and released by xfs_iflush_cluster() and
3723          * so we have no further error handling to do here.
3724          */
3725         error = xfs_iflush_cluster(ip, bp);
3726         if (error)
3727                 return error;
3728
3729         *bpp = bp;
3730         return 0;
3731
3732 corrupt_out:
3733         if (bp)
3734                 xfs_buf_relse(bp);
3735         xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
3736 abort_out:
3737         /* abort the corrupt inode, as it was not attached to the buffer */
3738         xfs_iflush_abort(ip, false);
3739         return error;
3740 }
3741
3742 /*
3743  * If there are inline format data / attr forks attached to this inode,
3744  * make sure they're not corrupt.
3745  */
3746 bool
3747 xfs_inode_verify_forks(
3748         struct xfs_inode        *ip)
3749 {
3750         struct xfs_ifork        *ifp;
3751         xfs_failaddr_t          fa;
3752
3753         fa = xfs_ifork_verify_data(ip, &xfs_default_ifork_ops);
3754         if (fa) {
3755                 ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
3756                 xfs_inode_verifier_error(ip, -EFSCORRUPTED, "data fork",
3757                                 ifp->if_u1.if_data, ifp->if_bytes, fa);
3758                 return false;
3759         }
3760
3761         fa = xfs_ifork_verify_attr(ip, &xfs_default_ifork_ops);
3762         if (fa) {
3763                 ifp = XFS_IFORK_PTR(ip, XFS_ATTR_FORK);
3764                 xfs_inode_verifier_error(ip, -EFSCORRUPTED, "attr fork",
3765                                 ifp ? ifp->if_u1.if_data : NULL,
3766                                 ifp ? ifp->if_bytes : 0, fa);
3767                 return false;
3768         }
3769         return true;
3770 }
3771
3772 STATIC int
3773 xfs_iflush_int(
3774         struct xfs_inode        *ip,
3775         struct xfs_buf          *bp)
3776 {
3777         struct xfs_inode_log_item *iip = ip->i_itemp;
3778         struct xfs_dinode       *dip;
3779         struct xfs_mount        *mp = ip->i_mount;
3780
3781         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
3782         ASSERT(xfs_isiflocked(ip));
3783         ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE ||
3784                ip->i_d.di_nextents > XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK));
3785         ASSERT(iip != NULL && iip->ili_fields != 0);
3786         ASSERT(ip->i_d.di_version > 1);
3787
3788         /* set *dip = inode's place in the buffer */
3789         dip = xfs_buf_offset(bp, ip->i_imap.im_boffset);
3790
3791         if (XFS_TEST_ERROR(dip->di_magic != cpu_to_be16(XFS_DINODE_MAGIC),
3792                                mp, XFS_ERRTAG_IFLUSH_1)) {
3793                 xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
3794                         "%s: Bad inode %Lu magic number 0x%x, ptr "PTR_FMT,
3795                         __func__, ip->i_ino, be16_to_cpu(dip->di_magic), dip);
3796                 goto corrupt_out;
3797         }
3798         if (S_ISREG(VFS_I(ip)->i_mode)) {
3799                 if (XFS_TEST_ERROR(
3800                     (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS) &&
3801                     (ip->i_d.di_format != XFS_DINODE_FMT_BTREE),
3802                     mp, XFS_ERRTAG_IFLUSH_3)) {
3803                         xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
3804                                 "%s: Bad regular inode %Lu, ptr "PTR_FMT,
3805                                 __func__, ip->i_ino, ip);
3806                         goto corrupt_out;
3807                 }
3808         } else if (S_ISDIR(VFS_I(ip)->i_mode)) {
3809                 if (XFS_TEST_ERROR(
3810                     (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS) &&
3811                     (ip->i_d.di_format != XFS_DINODE_FMT_BTREE) &&
3812                     (ip->i_d.di_format != XFS_DINODE_FMT_LOCAL),
3813                     mp, XFS_ERRTAG_IFLUSH_4)) {
3814                         xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
3815                                 "%s: Bad directory inode %Lu, ptr "PTR_FMT,
3816                                 __func__, ip->i_ino, ip);
3817                         goto corrupt_out;
3818                 }
3819         }
3820         if (XFS_TEST_ERROR(ip->i_d.di_nextents + ip->i_d.di_anextents >
3821                                 ip->i_d.di_nblocks, mp, XFS_ERRTAG_IFLUSH_5)) {
3822                 xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
3823                         "%s: detected corrupt incore inode %Lu, "
3824                         "total extents = %d, nblocks = %Ld, ptr "PTR_FMT,
3825                         __func__, ip->i_ino,
3826                         ip->i_d.di_nextents + ip->i_d.di_anextents,
3827                         ip->i_d.di_nblocks, ip);
3828                 goto corrupt_out;
3829         }
3830         if (XFS_TEST_ERROR(ip->i_d.di_forkoff > mp->m_sb.sb_inodesize,
3831                                 mp, XFS_ERRTAG_IFLUSH_6)) {
3832                 xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
3833                         "%s: bad inode %Lu, forkoff 0x%x, ptr "PTR_FMT,
3834                         __func__, ip->i_ino, ip->i_d.di_forkoff, ip);
3835                 goto corrupt_out;
3836         }
3837
3838         /*
3839          * Inode item log recovery for v2 inodes are dependent on the
3840          * di_flushiter count for correct sequencing. We bump the flush
3841          * iteration count so we can detect flushes which postdate a log record
3842          * during recovery. This is redundant as we now log every change and
3843          * hence this can't happen but we need to still do it to ensure
3844          * backwards compatibility with old kernels that predate logging all
3845          * inode changes.
3846          */
3847         if (ip->i_d.di_version < 3)
3848                 ip->i_d.di_flushiter++;
3849
3850         /* Check the inline fork data before we write out. */
3851         if (!xfs_inode_verify_forks(ip))
3852                 goto corrupt_out;
3853
3854         /*
3855          * Copy the dirty parts of the inode into the on-disk inode.  We always
3856          * copy out the core of the inode, because if the inode is dirty at all
3857          * the core must be.
3858          */
3859         xfs_inode_to_disk(ip, dip, iip->ili_item.li_lsn);
3860
3861         /* Wrap, we never let the log put out DI_MAX_FLUSH */
3862         if (ip->i_d.di_flushiter == DI_MAX_FLUSH)
3863                 ip->i_d.di_flushiter = 0;
3864
3865         xfs_iflush_fork(ip, dip, iip, XFS_DATA_FORK);
3866         if (XFS_IFORK_Q(ip))
3867                 xfs_iflush_fork(ip, dip, iip, XFS_ATTR_FORK);
3868         xfs_inobp_check(mp, bp);
3869
3870         /*
3871          * We've recorded everything logged in the inode, so we'd like to clear
3872          * the ili_fields bits so we don't log and flush things unnecessarily.
3873          * However, we can't stop logging all this information until the data
3874          * we've copied into the disk buffer is written to disk.  If we did we
3875          * might overwrite the copy of the inode in the log with all the data
3876          * after re-logging only part of it, and in the face of a crash we
3877          * wouldn't have all the data we need to recover.
3878          *
3879          * What we do is move the bits to the ili_last_fields field.  When
3880          * logging the inode, these bits are moved back to the ili_fields field.
3881          * In the xfs_iflush_done() routine we clear ili_last_fields, since we
3882          * know that the information those bits represent is permanently on
3883          * disk.  As long as the flush completes before the inode is logged
3884          * again, then both ili_fields and ili_last_fields will be cleared.
3885          *
3886          * We can play with the ili_fields bits here, because the inode lock
3887          * must be held exclusively in order to set bits there and the flush
3888          * lock protects the ili_last_fields bits.  Set ili_logged so the flush
3889          * done routine can tell whether or not to look in the AIL.  Also, store
3890          * the current LSN of the inode so that we can tell whether the item has
3891          * moved in the AIL from xfs_iflush_done().  In order to read the lsn we
3892          * need the AIL lock, because it is a 64 bit value that cannot be read
3893          * atomically.
3894          */
3895         iip->ili_last_fields = iip->ili_fields;
3896         iip->ili_fields = 0;
3897         iip->ili_fsync_fields = 0;
3898         iip->ili_logged = 1;
3899
3900         xfs_trans_ail_copy_lsn(mp->m_ail, &iip->ili_flush_lsn,
3901                                 &iip->ili_item.li_lsn);
3902
3903         /*
3904          * Attach the function xfs_iflush_done to the inode's
3905          * buffer.  This will remove the inode from the AIL
3906          * and unlock the inode's flush lock when the inode is
3907          * completely written to disk.
3908          */
3909         xfs_buf_attach_iodone(bp, xfs_iflush_done, &iip->ili_item);
3910
3911         /* generate the checksum. */
3912         xfs_dinode_calc_crc(mp, dip);
3913
3914         ASSERT(!list_empty(&bp->b_li_list));
3915         ASSERT(bp->b_iodone != NULL);
3916         return 0;
3917
3918 corrupt_out:
3919         return -EFSCORRUPTED;
3920 }
3921
3922 /* Release an inode. */
3923 void
3924 xfs_irele(
3925         struct xfs_inode        *ip)
3926 {
3927         trace_xfs_irele(ip, _RET_IP_);
3928         iput(VFS_I(ip));
3929 }