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