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