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