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