~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/xfs/xfs_inode.c

Version: ~ [ linux-5.8-rc4 ] ~ [ linux-5.7.7 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.50 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.131 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.187 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.229 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.229 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp