blob: 4e560e6a12c1cc2d4b913292c62714bf78e9ae77 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Olaf Weber3e57ecf2006-06-09 14:48:12 +10002 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
Nathan Scott7b718762005-11-02 14:58:39 +11003 * All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
Nathan Scott7b718762005-11-02 14:58:39 +11005 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * published by the Free Software Foundation.
8 *
Nathan Scott7b718762005-11-02 14:58:39 +11009 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
Nathan Scott7b718762005-11-02 14:58:39 +110014 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 */
Robert P. J. Day40ebd812007-11-23 16:30:51 +110018#include <linux/log2.h>
19
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include "xfs.h"
Nathan Scotta844f452005-11-02 14:38:42 +110021#include "xfs_fs.h"
Dave Chinner70a98832013-10-23 10:36:05 +110022#include "xfs_shared.h"
Dave Chinner239880e2013-10-23 10:50:10 +110023#include "xfs_format.h"
24#include "xfs_log_format.h"
25#include "xfs_trans_resv.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include "xfs_sb.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include "xfs_mount.h"
Darrick J. Wong3ab78df2016-08-03 11:15:38 +100028#include "xfs_defer.h"
Dave Chinnera4fbe6a2013-10-23 10:51:50 +110029#include "xfs_inode.h"
Dave Chinner57062782013-10-15 09:17:51 +110030#include "xfs_da_format.h"
Dave Chinnerc24b5df2013-08-12 20:49:45 +100031#include "xfs_da_btree.h"
Dave Chinnerc24b5df2013-08-12 20:49:45 +100032#include "xfs_dir2.h"
Nathan Scotta844f452005-11-02 14:38:42 +110033#include "xfs_attr_sf.h"
Dave Chinnerc24b5df2013-08-12 20:49:45 +100034#include "xfs_attr.h"
Dave Chinner239880e2013-10-23 10:50:10 +110035#include "xfs_trans_space.h"
36#include "xfs_trans.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include "xfs_buf_item.h"
Nathan Scotta844f452005-11-02 14:38:42 +110038#include "xfs_inode_item.h"
Nathan Scotta844f452005-11-02 14:38:42 +110039#include "xfs_ialloc.h"
40#include "xfs_bmap.h"
Dave Chinner68988112013-08-12 20:49:42 +100041#include "xfs_bmap_util.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include "xfs_error.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include "xfs_quota.h"
David Chinner2a82b8b2007-07-11 11:09:12 +100044#include "xfs_filestream.h"
Christoph Hellwig93848a92013-04-03 16:11:17 +110045#include "xfs_cksum.h"
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000046#include "xfs_trace.h"
Dave Chinner33479e02012-10-08 21:56:11 +110047#include "xfs_icache.h"
Dave Chinnerc24b5df2013-08-12 20:49:45 +100048#include "xfs_symlink.h"
Dave Chinner239880e2013-10-23 10:50:10 +110049#include "xfs_trans_priv.h"
50#include "xfs_log.h"
Dave Chinnera4fbe6a2013-10-23 10:51:50 +110051#include "xfs_bmap_btree.h"
Darrick J. Wongaa8968f2016-10-03 09:11:38 -070052#include "xfs_reflink.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
Linus Torvalds1da177e2005-04-16 15:20:36 -070054kmem_zone_t *xfs_inode_zone;
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
56/*
Christoph Hellwig8f04c472011-07-08 14:34:34 +020057 * Used in xfs_itruncate_extents(). This is the maximum number of extents
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 * freed from a file in a single transaction.
59 */
60#define XFS_ITRUNC_MAX_EXTENTS 2
61
Dave Chinner54d7b5c2016-02-09 16:54:58 +110062STATIC int xfs_iflush_int(struct xfs_inode *, struct xfs_buf *);
63STATIC int xfs_iunlink(struct xfs_trans *, struct xfs_inode *);
64STATIC int xfs_iunlink_remove(struct xfs_trans *, struct xfs_inode *);
Zhi Yong Wuab297432013-12-18 08:22:41 +080065
Dave Chinner2a0ec1d2012-04-23 15:59:02 +100066/*
67 * helper function to extract extent size hint from inode
68 */
69xfs_extlen_t
70xfs_get_extsz_hint(
71 struct xfs_inode *ip)
72{
73 if ((ip->i_d.di_flags & XFS_DIFLAG_EXTSIZE) && ip->i_d.di_extsize)
74 return ip->i_d.di_extsize;
75 if (XFS_IS_REALTIME_INODE(ip))
76 return ip->i_mount->m_sb.sb_rextsize;
77 return 0;
78}
79
Dave Chinnerfa96aca2012-10-08 21:56:10 +110080/*
Darrick J. Wongf7ca3522016-10-03 09:11:43 -070081 * Helper function to extract CoW extent size hint from inode.
82 * Between the extent size hint and the CoW extent size hint, we
Darrick J. Wonge153aa72016-10-03 09:11:49 -070083 * return the greater of the two. If the value is zero (automatic),
84 * use the default size.
Darrick J. Wongf7ca3522016-10-03 09:11:43 -070085 */
86xfs_extlen_t
87xfs_get_cowextsz_hint(
88 struct xfs_inode *ip)
89{
90 xfs_extlen_t a, b;
91
92 a = 0;
93 if (ip->i_d.di_flags2 & XFS_DIFLAG2_COWEXTSIZE)
94 a = ip->i_d.di_cowextsize;
95 b = xfs_get_extsz_hint(ip);
96
Darrick J. Wonge153aa72016-10-03 09:11:49 -070097 a = max(a, b);
98 if (a == 0)
99 return XFS_DEFAULT_COWEXTSZ_HINT;
100 return a;
Darrick J. Wongf7ca3522016-10-03 09:11:43 -0700101}
102
103/*
Christoph Hellwigefa70be2013-12-18 02:14:39 -0800104 * These two are wrapper routines around the xfs_ilock() routine used to
105 * centralize some grungy code. They are used in places that wish to lock the
106 * inode solely for reading the extents. The reason these places can't just
107 * call xfs_ilock(ip, XFS_ILOCK_SHARED) is that the inode lock also guards to
108 * bringing in of the extents from disk for a file in b-tree format. If the
109 * inode is in b-tree format, then we need to lock the inode exclusively until
110 * the extents are read in. Locking it exclusively all the time would limit
111 * our parallelism unnecessarily, though. What we do instead is check to see
112 * if the extents have been read in yet, and only lock the inode exclusively
113 * if they have not.
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100114 *
Christoph Hellwigefa70be2013-12-18 02:14:39 -0800115 * The functions return a value which should be given to the corresponding
Christoph Hellwig01f4f322013-12-06 12:30:08 -0800116 * xfs_iunlock() call.
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100117 */
118uint
Christoph Hellwig309ecac82013-12-06 12:30:09 -0800119xfs_ilock_data_map_shared(
120 struct xfs_inode *ip)
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100121{
Christoph Hellwig309ecac82013-12-06 12:30:09 -0800122 uint lock_mode = XFS_ILOCK_SHARED;
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100123
Christoph Hellwig309ecac82013-12-06 12:30:09 -0800124 if (ip->i_d.di_format == XFS_DINODE_FMT_BTREE &&
125 (ip->i_df.if_flags & XFS_IFEXTENTS) == 0)
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100126 lock_mode = XFS_ILOCK_EXCL;
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100127 xfs_ilock(ip, lock_mode);
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100128 return lock_mode;
129}
130
Christoph Hellwigefa70be2013-12-18 02:14:39 -0800131uint
132xfs_ilock_attr_map_shared(
133 struct xfs_inode *ip)
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100134{
Christoph Hellwigefa70be2013-12-18 02:14:39 -0800135 uint lock_mode = XFS_ILOCK_SHARED;
136
137 if (ip->i_d.di_aformat == XFS_DINODE_FMT_BTREE &&
138 (ip->i_afp->if_flags & XFS_IFEXTENTS) == 0)
139 lock_mode = XFS_ILOCK_EXCL;
140 xfs_ilock(ip, lock_mode);
141 return lock_mode;
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100142}
143
144/*
Dave Chinner653c60b2015-02-23 21:43:37 +1100145 * The xfs inode contains 3 multi-reader locks: the i_iolock the i_mmap_lock and
146 * the i_lock. This routine allows various combinations of the locks to be
147 * obtained.
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100148 *
Dave Chinner653c60b2015-02-23 21:43:37 +1100149 * The 3 locks should always be ordered so that the IO lock is obtained first,
150 * the mmap lock second and the ilock last in order to prevent deadlock.
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100151 *
Dave Chinner653c60b2015-02-23 21:43:37 +1100152 * Basic locking order:
153 *
154 * i_iolock -> i_mmap_lock -> page_lock -> i_ilock
155 *
156 * mmap_sem locking order:
157 *
158 * i_iolock -> page lock -> mmap_sem
159 * mmap_sem -> i_mmap_lock -> page_lock
160 *
161 * The difference in mmap_sem locking order mean that we cannot hold the
162 * i_mmap_lock over syscall based read(2)/write(2) based IO. These IO paths can
163 * fault in pages during copy in/out (for buffered IO) or require the mmap_sem
164 * in get_user_pages() to map the user pages into the kernel address space for
165 * direct IO. Similarly the i_iolock cannot be taken inside a page fault because
166 * page faults already hold the mmap_sem.
167 *
168 * Hence to serialise fully against both syscall and mmap based IO, we need to
169 * take both the i_iolock and the i_mmap_lock. These locks should *only* be both
170 * taken in places where we need to invalidate the page cache in a race
171 * free manner (e.g. truncate, hole punch and other extent manipulation
172 * functions).
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100173 */
174void
175xfs_ilock(
176 xfs_inode_t *ip,
177 uint lock_flags)
178{
179 trace_xfs_ilock(ip, lock_flags, _RET_IP_);
180
181 /*
182 * You can't set both SHARED and EXCL for the same lock,
183 * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
184 * and XFS_ILOCK_EXCL are valid values to set in lock_flags.
185 */
186 ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
187 (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
Dave Chinner653c60b2015-02-23 21:43:37 +1100188 ASSERT((lock_flags & (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL)) !=
189 (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL));
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100190 ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
191 (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
Dave Chinner0952c812015-08-19 10:32:49 +1000192 ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_SUBCLASS_MASK)) == 0);
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100193
194 if (lock_flags & XFS_IOLOCK_EXCL)
195 mrupdate_nested(&ip->i_iolock, XFS_IOLOCK_DEP(lock_flags));
196 else if (lock_flags & XFS_IOLOCK_SHARED)
197 mraccess_nested(&ip->i_iolock, XFS_IOLOCK_DEP(lock_flags));
198
Dave Chinner653c60b2015-02-23 21:43:37 +1100199 if (lock_flags & XFS_MMAPLOCK_EXCL)
200 mrupdate_nested(&ip->i_mmaplock, XFS_MMAPLOCK_DEP(lock_flags));
201 else if (lock_flags & XFS_MMAPLOCK_SHARED)
202 mraccess_nested(&ip->i_mmaplock, XFS_MMAPLOCK_DEP(lock_flags));
203
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100204 if (lock_flags & XFS_ILOCK_EXCL)
205 mrupdate_nested(&ip->i_lock, XFS_ILOCK_DEP(lock_flags));
206 else if (lock_flags & XFS_ILOCK_SHARED)
207 mraccess_nested(&ip->i_lock, XFS_ILOCK_DEP(lock_flags));
208}
209
210/*
211 * This is just like xfs_ilock(), except that the caller
212 * is guaranteed not to sleep. It returns 1 if it gets
213 * the requested locks and 0 otherwise. If the IO lock is
214 * obtained but the inode lock cannot be, then the IO lock
215 * is dropped before returning.
216 *
217 * ip -- the inode being locked
218 * lock_flags -- this parameter indicates the inode's locks to be
219 * to be locked. See the comment for xfs_ilock() for a list
220 * of valid values.
221 */
222int
223xfs_ilock_nowait(
224 xfs_inode_t *ip,
225 uint lock_flags)
226{
227 trace_xfs_ilock_nowait(ip, lock_flags, _RET_IP_);
228
229 /*
230 * You can't set both SHARED and EXCL for the same lock,
231 * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
232 * and XFS_ILOCK_EXCL are valid values to set in lock_flags.
233 */
234 ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
235 (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
Dave Chinner653c60b2015-02-23 21:43:37 +1100236 ASSERT((lock_flags & (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL)) !=
237 (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL));
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100238 ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
239 (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
Dave Chinner0952c812015-08-19 10:32:49 +1000240 ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_SUBCLASS_MASK)) == 0);
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100241
242 if (lock_flags & XFS_IOLOCK_EXCL) {
243 if (!mrtryupdate(&ip->i_iolock))
244 goto out;
245 } else if (lock_flags & XFS_IOLOCK_SHARED) {
246 if (!mrtryaccess(&ip->i_iolock))
247 goto out;
248 }
Dave Chinner653c60b2015-02-23 21:43:37 +1100249
250 if (lock_flags & XFS_MMAPLOCK_EXCL) {
251 if (!mrtryupdate(&ip->i_mmaplock))
252 goto out_undo_iolock;
253 } else if (lock_flags & XFS_MMAPLOCK_SHARED) {
254 if (!mrtryaccess(&ip->i_mmaplock))
255 goto out_undo_iolock;
256 }
257
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100258 if (lock_flags & XFS_ILOCK_EXCL) {
259 if (!mrtryupdate(&ip->i_lock))
Dave Chinner653c60b2015-02-23 21:43:37 +1100260 goto out_undo_mmaplock;
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100261 } else if (lock_flags & XFS_ILOCK_SHARED) {
262 if (!mrtryaccess(&ip->i_lock))
Dave Chinner653c60b2015-02-23 21:43:37 +1100263 goto out_undo_mmaplock;
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100264 }
265 return 1;
266
Dave Chinner653c60b2015-02-23 21:43:37 +1100267out_undo_mmaplock:
268 if (lock_flags & XFS_MMAPLOCK_EXCL)
269 mrunlock_excl(&ip->i_mmaplock);
270 else if (lock_flags & XFS_MMAPLOCK_SHARED)
271 mrunlock_shared(&ip->i_mmaplock);
272out_undo_iolock:
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100273 if (lock_flags & XFS_IOLOCK_EXCL)
274 mrunlock_excl(&ip->i_iolock);
275 else if (lock_flags & XFS_IOLOCK_SHARED)
276 mrunlock_shared(&ip->i_iolock);
Dave Chinner653c60b2015-02-23 21:43:37 +1100277out:
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100278 return 0;
279}
280
281/*
282 * xfs_iunlock() is used to drop the inode locks acquired with
283 * xfs_ilock() and xfs_ilock_nowait(). The caller must pass
284 * in the flags given to xfs_ilock() or xfs_ilock_nowait() so
285 * that we know which locks to drop.
286 *
287 * ip -- the inode being unlocked
288 * lock_flags -- this parameter indicates the inode's locks to be
289 * to be unlocked. See the comment for xfs_ilock() for a list
290 * of valid values for this parameter.
291 *
292 */
293void
294xfs_iunlock(
295 xfs_inode_t *ip,
296 uint lock_flags)
297{
298 /*
299 * You can't set both SHARED and EXCL for the same lock,
300 * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
301 * and XFS_ILOCK_EXCL are valid values to set in lock_flags.
302 */
303 ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
304 (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
Dave Chinner653c60b2015-02-23 21:43:37 +1100305 ASSERT((lock_flags & (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL)) !=
306 (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL));
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100307 ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
308 (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
Dave Chinner0952c812015-08-19 10:32:49 +1000309 ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_SUBCLASS_MASK)) == 0);
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100310 ASSERT(lock_flags != 0);
311
312 if (lock_flags & XFS_IOLOCK_EXCL)
313 mrunlock_excl(&ip->i_iolock);
314 else if (lock_flags & XFS_IOLOCK_SHARED)
315 mrunlock_shared(&ip->i_iolock);
316
Dave Chinner653c60b2015-02-23 21:43:37 +1100317 if (lock_flags & XFS_MMAPLOCK_EXCL)
318 mrunlock_excl(&ip->i_mmaplock);
319 else if (lock_flags & XFS_MMAPLOCK_SHARED)
320 mrunlock_shared(&ip->i_mmaplock);
321
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100322 if (lock_flags & XFS_ILOCK_EXCL)
323 mrunlock_excl(&ip->i_lock);
324 else if (lock_flags & XFS_ILOCK_SHARED)
325 mrunlock_shared(&ip->i_lock);
326
327 trace_xfs_iunlock(ip, lock_flags, _RET_IP_);
328}
329
330/*
331 * give up write locks. the i/o lock cannot be held nested
332 * if it is being demoted.
333 */
334void
335xfs_ilock_demote(
336 xfs_inode_t *ip,
337 uint lock_flags)
338{
Dave Chinner653c60b2015-02-23 21:43:37 +1100339 ASSERT(lock_flags & (XFS_IOLOCK_EXCL|XFS_MMAPLOCK_EXCL|XFS_ILOCK_EXCL));
340 ASSERT((lock_flags &
341 ~(XFS_IOLOCK_EXCL|XFS_MMAPLOCK_EXCL|XFS_ILOCK_EXCL)) == 0);
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100342
343 if (lock_flags & XFS_ILOCK_EXCL)
344 mrdemote(&ip->i_lock);
Dave Chinner653c60b2015-02-23 21:43:37 +1100345 if (lock_flags & XFS_MMAPLOCK_EXCL)
346 mrdemote(&ip->i_mmaplock);
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100347 if (lock_flags & XFS_IOLOCK_EXCL)
348 mrdemote(&ip->i_iolock);
349
350 trace_xfs_ilock_demote(ip, lock_flags, _RET_IP_);
351}
352
Dave Chinner742ae1e2013-04-30 21:39:34 +1000353#if defined(DEBUG) || defined(XFS_WARN)
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100354int
355xfs_isilocked(
356 xfs_inode_t *ip,
357 uint lock_flags)
358{
359 if (lock_flags & (XFS_ILOCK_EXCL|XFS_ILOCK_SHARED)) {
360 if (!(lock_flags & XFS_ILOCK_SHARED))
361 return !!ip->i_lock.mr_writer;
362 return rwsem_is_locked(&ip->i_lock.mr_lock);
363 }
364
Dave Chinner653c60b2015-02-23 21:43:37 +1100365 if (lock_flags & (XFS_MMAPLOCK_EXCL|XFS_MMAPLOCK_SHARED)) {
366 if (!(lock_flags & XFS_MMAPLOCK_SHARED))
367 return !!ip->i_mmaplock.mr_writer;
368 return rwsem_is_locked(&ip->i_mmaplock.mr_lock);
369 }
370
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100371 if (lock_flags & (XFS_IOLOCK_EXCL|XFS_IOLOCK_SHARED)) {
372 if (!(lock_flags & XFS_IOLOCK_SHARED))
373 return !!ip->i_iolock.mr_writer;
374 return rwsem_is_locked(&ip->i_iolock.mr_lock);
375 }
376
377 ASSERT(0);
378 return 0;
379}
380#endif
381
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000382#ifdef DEBUG
383int xfs_locked_n;
384int xfs_small_retries;
385int xfs_middle_retries;
386int xfs_lots_retries;
387int xfs_lock_delays;
388#endif
389
Dave Chinnerb6a99472015-08-25 10:05:13 +1000390/*
391 * xfs_lockdep_subclass_ok() is only used in an ASSERT, so is only called when
392 * DEBUG or XFS_WARN is set. And MAX_LOCKDEP_SUBCLASSES is then only defined
393 * when CONFIG_LOCKDEP is set. Hence the complex define below to avoid build
394 * errors and warnings.
395 */
396#if (defined(DEBUG) || defined(XFS_WARN)) && defined(CONFIG_LOCKDEP)
Dave Chinner3403ccc2015-08-20 09:27:49 +1000397static bool
398xfs_lockdep_subclass_ok(
399 int subclass)
400{
401 return subclass < MAX_LOCKDEP_SUBCLASSES;
402}
403#else
404#define xfs_lockdep_subclass_ok(subclass) (true)
405#endif
406
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000407/*
Dave Chinner653c60b2015-02-23 21:43:37 +1100408 * Bump the subclass so xfs_lock_inodes() acquires each lock with a different
Dave Chinner0952c812015-08-19 10:32:49 +1000409 * value. This can be called for any type of inode lock combination, including
410 * parent locking. Care must be taken to ensure we don't overrun the subclass
411 * storage fields in the class mask we build.
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000412 */
413static inline int
414xfs_lock_inumorder(int lock_mode, int subclass)
415{
Dave Chinner0952c812015-08-19 10:32:49 +1000416 int class = 0;
417
418 ASSERT(!(lock_mode & (XFS_ILOCK_PARENT | XFS_ILOCK_RTBITMAP |
419 XFS_ILOCK_RTSUM)));
Dave Chinner3403ccc2015-08-20 09:27:49 +1000420 ASSERT(xfs_lockdep_subclass_ok(subclass));
Dave Chinner0952c812015-08-19 10:32:49 +1000421
Dave Chinner653c60b2015-02-23 21:43:37 +1100422 if (lock_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL)) {
Dave Chinner0952c812015-08-19 10:32:49 +1000423 ASSERT(subclass <= XFS_IOLOCK_MAX_SUBCLASS);
Dave Chinner3403ccc2015-08-20 09:27:49 +1000424 ASSERT(xfs_lockdep_subclass_ok(subclass +
425 XFS_IOLOCK_PARENT_VAL));
Dave Chinner0952c812015-08-19 10:32:49 +1000426 class += subclass << XFS_IOLOCK_SHIFT;
427 if (lock_mode & XFS_IOLOCK_PARENT)
428 class += XFS_IOLOCK_PARENT_VAL << XFS_IOLOCK_SHIFT;
Dave Chinner653c60b2015-02-23 21:43:37 +1100429 }
430
431 if (lock_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)) {
Dave Chinner0952c812015-08-19 10:32:49 +1000432 ASSERT(subclass <= XFS_MMAPLOCK_MAX_SUBCLASS);
433 class += subclass << XFS_MMAPLOCK_SHIFT;
Dave Chinner653c60b2015-02-23 21:43:37 +1100434 }
435
Dave Chinner0952c812015-08-19 10:32:49 +1000436 if (lock_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)) {
437 ASSERT(subclass <= XFS_ILOCK_MAX_SUBCLASS);
438 class += subclass << XFS_ILOCK_SHIFT;
439 }
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000440
Dave Chinner0952c812015-08-19 10:32:49 +1000441 return (lock_mode & ~XFS_LOCK_SUBCLASS_MASK) | class;
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000442}
443
444/*
Dave Chinner95afcf52015-03-25 14:03:32 +1100445 * The following routine will lock n inodes in exclusive mode. We assume the
446 * caller calls us with the inodes in i_ino order.
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000447 *
Dave Chinner95afcf52015-03-25 14:03:32 +1100448 * We need to detect deadlock where an inode that we lock is in the AIL and we
449 * start waiting for another inode that is locked by a thread in a long running
450 * transaction (such as truncate). This can result in deadlock since the long
451 * running trans might need to wait for the inode we just locked in order to
452 * push the tail and free space in the log.
Dave Chinner0952c812015-08-19 10:32:49 +1000453 *
454 * xfs_lock_inodes() can only be used to lock one type of lock at a time -
455 * the iolock, the mmaplock or the ilock, but not more than one at a time. If we
456 * lock more than one at a time, lockdep will report false positives saying we
457 * have violated locking orders.
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000458 */
Eric Sandeen0d5a75e2016-06-01 17:38:15 +1000459static void
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000460xfs_lock_inodes(
461 xfs_inode_t **ips,
462 int inodes,
463 uint lock_mode)
464{
465 int attempts = 0, i, j, try_lock;
466 xfs_log_item_t *lp;
467
Dave Chinner0952c812015-08-19 10:32:49 +1000468 /*
469 * Currently supports between 2 and 5 inodes with exclusive locking. We
470 * support an arbitrary depth of locking here, but absolute limits on
471 * inodes depend on the the type of locking and the limits placed by
472 * lockdep annotations in xfs_lock_inumorder. These are all checked by
473 * the asserts.
474 */
Dave Chinner95afcf52015-03-25 14:03:32 +1100475 ASSERT(ips && inodes >= 2 && inodes <= 5);
Dave Chinner0952c812015-08-19 10:32:49 +1000476 ASSERT(lock_mode & (XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL |
477 XFS_ILOCK_EXCL));
478 ASSERT(!(lock_mode & (XFS_IOLOCK_SHARED | XFS_MMAPLOCK_SHARED |
479 XFS_ILOCK_SHARED)));
480 ASSERT(!(lock_mode & XFS_IOLOCK_EXCL) ||
481 inodes <= XFS_IOLOCK_MAX_SUBCLASS + 1);
482 ASSERT(!(lock_mode & XFS_MMAPLOCK_EXCL) ||
483 inodes <= XFS_MMAPLOCK_MAX_SUBCLASS + 1);
484 ASSERT(!(lock_mode & XFS_ILOCK_EXCL) ||
485 inodes <= XFS_ILOCK_MAX_SUBCLASS + 1);
486
487 if (lock_mode & XFS_IOLOCK_EXCL) {
488 ASSERT(!(lock_mode & (XFS_MMAPLOCK_EXCL | XFS_ILOCK_EXCL)));
489 } else if (lock_mode & XFS_MMAPLOCK_EXCL)
490 ASSERT(!(lock_mode & XFS_ILOCK_EXCL));
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000491
492 try_lock = 0;
493 i = 0;
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000494again:
495 for (; i < inodes; i++) {
496 ASSERT(ips[i]);
497
Dave Chinner95afcf52015-03-25 14:03:32 +1100498 if (i && (ips[i] == ips[i - 1])) /* Already locked */
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000499 continue;
500
501 /*
Dave Chinner95afcf52015-03-25 14:03:32 +1100502 * If try_lock is not set yet, make sure all locked inodes are
503 * not in the AIL. If any are, set try_lock to be used later.
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000504 */
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000505 if (!try_lock) {
506 for (j = (i - 1); j >= 0 && !try_lock; j--) {
507 lp = (xfs_log_item_t *)ips[j]->i_itemp;
Dave Chinner95afcf52015-03-25 14:03:32 +1100508 if (lp && (lp->li_flags & XFS_LI_IN_AIL))
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000509 try_lock++;
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000510 }
511 }
512
513 /*
514 * If any of the previous locks we have locked is in the AIL,
515 * we must TRY to get the second and subsequent locks. If
516 * we can't get any, we must release all we have
517 * and try again.
518 */
Dave Chinner95afcf52015-03-25 14:03:32 +1100519 if (!try_lock) {
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000520 xfs_ilock(ips[i], xfs_lock_inumorder(lock_mode, i));
Dave Chinner95afcf52015-03-25 14:03:32 +1100521 continue;
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000522 }
Dave Chinner95afcf52015-03-25 14:03:32 +1100523
524 /* try_lock means we have an inode locked that is in the AIL. */
525 ASSERT(i != 0);
526 if (xfs_ilock_nowait(ips[i], xfs_lock_inumorder(lock_mode, i)))
527 continue;
528
529 /*
530 * Unlock all previous guys and try again. xfs_iunlock will try
531 * to push the tail if the inode is in the AIL.
532 */
533 attempts++;
534 for (j = i - 1; j >= 0; j--) {
535 /*
536 * Check to see if we've already unlocked this one. Not
537 * the first one going back, and the inode ptr is the
538 * same.
539 */
540 if (j != (i - 1) && ips[j] == ips[j + 1])
541 continue;
542
543 xfs_iunlock(ips[j], lock_mode);
544 }
545
546 if ((attempts % 5) == 0) {
547 delay(1); /* Don't just spin the CPU */
548#ifdef DEBUG
549 xfs_lock_delays++;
550#endif
551 }
552 i = 0;
553 try_lock = 0;
554 goto again;
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000555 }
556
557#ifdef DEBUG
558 if (attempts) {
559 if (attempts < 5) xfs_small_retries++;
560 else if (attempts < 100) xfs_middle_retries++;
561 else xfs_lots_retries++;
562 } else {
563 xfs_locked_n++;
564 }
565#endif
566}
567
568/*
Dave Chinner653c60b2015-02-23 21:43:37 +1100569 * xfs_lock_two_inodes() can only be used to lock one type of lock at a time -
570 * the iolock, the mmaplock or the ilock, but not more than one at a time. If we
571 * lock more than one at a time, lockdep will report false positives saying we
572 * have violated locking orders.
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000573 */
574void
575xfs_lock_two_inodes(
576 xfs_inode_t *ip0,
577 xfs_inode_t *ip1,
578 uint lock_mode)
579{
580 xfs_inode_t *temp;
581 int attempts = 0;
582 xfs_log_item_t *lp;
583
Dave Chinner653c60b2015-02-23 21:43:37 +1100584 if (lock_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL)) {
585 ASSERT(!(lock_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)));
586 ASSERT(!(lock_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)));
587 } else if (lock_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL))
588 ASSERT(!(lock_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)));
589
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000590 ASSERT(ip0->i_ino != ip1->i_ino);
591
592 if (ip0->i_ino > ip1->i_ino) {
593 temp = ip0;
594 ip0 = ip1;
595 ip1 = temp;
596 }
597
598 again:
599 xfs_ilock(ip0, xfs_lock_inumorder(lock_mode, 0));
600
601 /*
602 * If the first lock we have locked is in the AIL, we must TRY to get
603 * the second lock. If we can't get it, we must release the first one
604 * and try again.
605 */
606 lp = (xfs_log_item_t *)ip0->i_itemp;
607 if (lp && (lp->li_flags & XFS_LI_IN_AIL)) {
608 if (!xfs_ilock_nowait(ip1, xfs_lock_inumorder(lock_mode, 1))) {
609 xfs_iunlock(ip0, lock_mode);
610 if ((++attempts % 5) == 0)
611 delay(1); /* Don't just spin the CPU */
612 goto again;
613 }
614 } else {
615 xfs_ilock(ip1, xfs_lock_inumorder(lock_mode, 1));
616 }
617}
618
619
Dave Chinnerfa96aca2012-10-08 21:56:10 +1100620void
621__xfs_iflock(
622 struct xfs_inode *ip)
623{
624 wait_queue_head_t *wq = bit_waitqueue(&ip->i_flags, __XFS_IFLOCK_BIT);
625 DEFINE_WAIT_BIT(wait, &ip->i_flags, __XFS_IFLOCK_BIT);
626
627 do {
628 prepare_to_wait_exclusive(wq, &wait.wait, TASK_UNINTERRUPTIBLE);
629 if (xfs_isiflocked(ip))
630 io_schedule();
631 } while (!xfs_iflock_nowait(ip));
632
633 finish_wait(wq, &wait.wait);
634}
635
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636STATIC uint
637_xfs_dic2xflags(
Dave Chinner58f88ca2016-01-04 16:44:15 +1100638 __uint16_t di_flags,
639 uint64_t di_flags2,
640 bool has_attr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641{
642 uint flags = 0;
643
644 if (di_flags & XFS_DIFLAG_ANY) {
645 if (di_flags & XFS_DIFLAG_REALTIME)
Dave Chinnere7b89482016-01-04 16:44:15 +1100646 flags |= FS_XFLAG_REALTIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 if (di_flags & XFS_DIFLAG_PREALLOC)
Dave Chinnere7b89482016-01-04 16:44:15 +1100648 flags |= FS_XFLAG_PREALLOC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 if (di_flags & XFS_DIFLAG_IMMUTABLE)
Dave Chinnere7b89482016-01-04 16:44:15 +1100650 flags |= FS_XFLAG_IMMUTABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 if (di_flags & XFS_DIFLAG_APPEND)
Dave Chinnere7b89482016-01-04 16:44:15 +1100652 flags |= FS_XFLAG_APPEND;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 if (di_flags & XFS_DIFLAG_SYNC)
Dave Chinnere7b89482016-01-04 16:44:15 +1100654 flags |= FS_XFLAG_SYNC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 if (di_flags & XFS_DIFLAG_NOATIME)
Dave Chinnere7b89482016-01-04 16:44:15 +1100656 flags |= FS_XFLAG_NOATIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 if (di_flags & XFS_DIFLAG_NODUMP)
Dave Chinnere7b89482016-01-04 16:44:15 +1100658 flags |= FS_XFLAG_NODUMP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 if (di_flags & XFS_DIFLAG_RTINHERIT)
Dave Chinnere7b89482016-01-04 16:44:15 +1100660 flags |= FS_XFLAG_RTINHERIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 if (di_flags & XFS_DIFLAG_PROJINHERIT)
Dave Chinnere7b89482016-01-04 16:44:15 +1100662 flags |= FS_XFLAG_PROJINHERIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 if (di_flags & XFS_DIFLAG_NOSYMLINKS)
Dave Chinnere7b89482016-01-04 16:44:15 +1100664 flags |= FS_XFLAG_NOSYMLINKS;
Nathan Scottdd9f4382006-01-11 15:28:28 +1100665 if (di_flags & XFS_DIFLAG_EXTSIZE)
Dave Chinnere7b89482016-01-04 16:44:15 +1100666 flags |= FS_XFLAG_EXTSIZE;
Nathan Scottdd9f4382006-01-11 15:28:28 +1100667 if (di_flags & XFS_DIFLAG_EXTSZINHERIT)
Dave Chinnere7b89482016-01-04 16:44:15 +1100668 flags |= FS_XFLAG_EXTSZINHERIT;
Barry Naujokd3446ea2006-06-09 14:54:19 +1000669 if (di_flags & XFS_DIFLAG_NODEFRAG)
Dave Chinnere7b89482016-01-04 16:44:15 +1100670 flags |= FS_XFLAG_NODEFRAG;
David Chinner2a82b8b2007-07-11 11:09:12 +1000671 if (di_flags & XFS_DIFLAG_FILESTREAM)
Dave Chinnere7b89482016-01-04 16:44:15 +1100672 flags |= FS_XFLAG_FILESTREAM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 }
674
Dave Chinner58f88ca2016-01-04 16:44:15 +1100675 if (di_flags2 & XFS_DIFLAG2_ANY) {
676 if (di_flags2 & XFS_DIFLAG2_DAX)
677 flags |= FS_XFLAG_DAX;
Darrick J. Wongf7ca3522016-10-03 09:11:43 -0700678 if (di_flags2 & XFS_DIFLAG2_COWEXTSIZE)
679 flags |= FS_XFLAG_COWEXTSIZE;
Dave Chinner58f88ca2016-01-04 16:44:15 +1100680 }
681
682 if (has_attr)
683 flags |= FS_XFLAG_HASATTR;
684
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 return flags;
686}
687
688uint
689xfs_ip2xflags(
Dave Chinner58f88ca2016-01-04 16:44:15 +1100690 struct xfs_inode *ip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691{
Dave Chinner58f88ca2016-01-04 16:44:15 +1100692 struct xfs_icdinode *dic = &ip->i_d;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693
Dave Chinner58f88ca2016-01-04 16:44:15 +1100694 return _xfs_dic2xflags(dic->di_flags, dic->di_flags2, XFS_IFORK_Q(ip));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695}
696
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697/*
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000698 * Lookups up an inode from "name". If ci_name is not NULL, then a CI match
699 * is allowed, otherwise it has to be an exact match. If a CI match is found,
700 * ci_name->name will point to a the actual name (caller must free) or
701 * will be set to NULL if an exact match is found.
702 */
703int
704xfs_lookup(
705 xfs_inode_t *dp,
706 struct xfs_name *name,
707 xfs_inode_t **ipp,
708 struct xfs_name *ci_name)
709{
710 xfs_ino_t inum;
711 int error;
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000712
713 trace_xfs_lookup(dp, name);
714
715 if (XFS_FORCED_SHUTDOWN(dp->i_mount))
Dave Chinner24513372014-06-25 14:58:08 +1000716 return -EIO;
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000717
Dave Chinnerdbad7c92015-08-19 10:33:00 +1000718 xfs_ilock(dp, XFS_IOLOCK_SHARED);
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000719 error = xfs_dir_lookup(NULL, dp, name, &inum, ci_name);
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000720 if (error)
Dave Chinnerdbad7c92015-08-19 10:33:00 +1000721 goto out_unlock;
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000722
723 error = xfs_iget(dp->i_mount, NULL, inum, 0, 0, ipp);
724 if (error)
725 goto out_free_name;
726
Dave Chinnerdbad7c92015-08-19 10:33:00 +1000727 xfs_iunlock(dp, XFS_IOLOCK_SHARED);
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000728 return 0;
729
730out_free_name:
731 if (ci_name)
732 kmem_free(ci_name->name);
Dave Chinnerdbad7c92015-08-19 10:33:00 +1000733out_unlock:
734 xfs_iunlock(dp, XFS_IOLOCK_SHARED);
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000735 *ipp = NULL;
736 return error;
737}
738
739/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 * Allocate an inode on disk and return a copy of its in-core version.
741 * The in-core inode is locked exclusively. Set mode, nlink, and rdev
742 * appropriately within the inode. The uid and gid for the inode are
743 * set according to the contents of the given cred structure.
744 *
745 * Use xfs_dialloc() to allocate the on-disk inode. If xfs_dialloc()
Carlos Maiolinocd856db2012-10-20 11:08:19 -0300746 * has a free inode available, call xfs_iget() to obtain the in-core
747 * version of the allocated inode. Finally, fill in the inode and
748 * log its initial contents. In this case, ialloc_context would be
749 * set to NULL.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 *
Carlos Maiolinocd856db2012-10-20 11:08:19 -0300751 * If xfs_dialloc() does not have an available inode, it will replenish
752 * its supply by doing an allocation. Since we can only do one
753 * allocation within a transaction without deadlocks, we must commit
754 * the current transaction before returning the inode itself.
755 * In this case, therefore, we will set ialloc_context and return.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 * The caller should then commit the current transaction, start a new
757 * transaction, and call xfs_ialloc() again to actually get the inode.
758 *
759 * To ensure that some other process does not grab the inode that
760 * was allocated during the first call to xfs_ialloc(), this routine
761 * also returns the [locked] bp pointing to the head of the freelist
762 * as ialloc_context. The caller should hold this buffer across
763 * the commit and pass it back into this routine on the second call.
David Chinnerb11f94d2007-07-11 11:09:33 +1000764 *
765 * If we are allocating quota inodes, we do not have a parent inode
766 * to attach to or associate with (i.e. pip == NULL) because they
767 * are not linked into the directory structure - they are attached
768 * directly to the superblock - and so have no parent.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 */
Eric Sandeen0d5a75e2016-06-01 17:38:15 +1000770static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771xfs_ialloc(
772 xfs_trans_t *tp,
773 xfs_inode_t *pip,
Al Viro576b1d62011-07-26 02:50:15 -0400774 umode_t mode,
Nathan Scott31b084a2005-05-05 13:25:00 -0700775 xfs_nlink_t nlink,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 xfs_dev_t rdev,
Arkadiusz Mi?kiewicz67430992010-09-26 06:10:18 +0000777 prid_t prid,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 int okalloc,
779 xfs_buf_t **ialloc_context,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780 xfs_inode_t **ipp)
781{
Christoph Hellwig93848a92013-04-03 16:11:17 +1100782 struct xfs_mount *mp = tp->t_mountp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 xfs_ino_t ino;
784 xfs_inode_t *ip;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 uint flags;
786 int error;
Dave Chinnere076b0f2014-10-02 09:18:13 +1000787 struct timespec tv;
Dave Chinner39878482016-02-09 16:54:58 +1100788 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789
790 /*
791 * Call the space management code to pick
792 * the on-disk inode to be allocated.
793 */
David Chinnerb11f94d2007-07-11 11:09:33 +1000794 error = xfs_dialloc(tp, pip ? pip->i_ino : 0, mode, okalloc,
Christoph Hellwig08358902012-07-04 10:54:47 -0400795 ialloc_context, &ino);
David Chinnerbf904242008-10-30 17:36:14 +1100796 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 return error;
Christoph Hellwig08358902012-07-04 10:54:47 -0400798 if (*ialloc_context || ino == NULLFSINO) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 *ipp = NULL;
800 return 0;
801 }
802 ASSERT(*ialloc_context == NULL);
803
804 /*
805 * Get the in-core inode with the lock held exclusively.
806 * This is because we're setting fields here we need
807 * to prevent others from looking at until we're done.
808 */
Christoph Hellwig93848a92013-04-03 16:11:17 +1100809 error = xfs_iget(mp, tp, ino, XFS_IGET_CREATE,
Christoph Hellwigec3ba852011-02-13 13:26:42 +0000810 XFS_ILOCK_EXCL, &ip);
David Chinnerbf904242008-10-30 17:36:14 +1100811 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 ASSERT(ip != NULL);
Dave Chinner39878482016-02-09 16:54:58 +1100814 inode = VFS_I(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815
Dave Chinner263997a2014-05-20 07:46:40 +1000816 /*
817 * We always convert v1 inodes to v2 now - we only support filesystems
818 * with >= v2 inode capability, so there is no reason for ever leaving
819 * an inode in v1 format.
820 */
821 if (ip->i_d.di_version == 1)
822 ip->i_d.di_version = 2;
823
Dave Chinnerc19b3b052016-02-09 16:54:58 +1100824 inode->i_mode = mode;
Dave Chinner54d7b5c2016-02-09 16:54:58 +1100825 set_nlink(inode, nlink);
Dwight Engen7aab1b22013-08-15 14:08:01 -0400826 ip->i_d.di_uid = xfs_kuid_to_uid(current_fsuid());
827 ip->i_d.di_gid = xfs_kgid_to_gid(current_fsgid());
Arkadiusz Mi?kiewicz67430992010-09-26 06:10:18 +0000828 xfs_set_projid(ip, prid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829
Christoph Hellwigbd186aa2007-08-30 17:21:12 +1000830 if (pip && XFS_INHERIT_GID(pip)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 ip->i_d.di_gid = pip->i_d.di_gid;
Dave Chinnerc19b3b052016-02-09 16:54:58 +1100832 if ((VFS_I(pip)->i_mode & S_ISGID) && S_ISDIR(mode))
833 inode->i_mode |= S_ISGID;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 }
835
836 /*
837 * If the group ID of the new file does not match the effective group
838 * ID or one of the supplementary group IDs, the S_ISGID bit is cleared
839 * (and only if the irix_sgid_inherit compatibility variable is set).
840 */
841 if ((irix_sgid_inherit) &&
Dave Chinnerc19b3b052016-02-09 16:54:58 +1100842 (inode->i_mode & S_ISGID) &&
843 (!in_group_p(xfs_gid_to_kgid(ip->i_d.di_gid))))
844 inode->i_mode &= ~S_ISGID;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845
846 ip->i_d.di_size = 0;
847 ip->i_d.di_nextents = 0;
848 ASSERT(ip->i_d.di_nblocks == 0);
Christoph Hellwigdff35fd2008-08-13 16:44:15 +1000849
Deepa Dinamanic2050a42016-09-14 07:48:06 -0700850 tv = current_time(inode);
Dave Chinner39878482016-02-09 16:54:58 +1100851 inode->i_mtime = tv;
852 inode->i_atime = tv;
853 inode->i_ctime = tv;
Christoph Hellwigdff35fd2008-08-13 16:44:15 +1000854
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 ip->i_d.di_extsize = 0;
856 ip->i_d.di_dmevmask = 0;
857 ip->i_d.di_dmstate = 0;
858 ip->i_d.di_flags = 0;
Christoph Hellwig93848a92013-04-03 16:11:17 +1100859
860 if (ip->i_d.di_version == 3) {
Dave Chinner83e06f22016-02-09 16:54:58 +1100861 inode->i_version = 1;
Christoph Hellwig93848a92013-04-03 16:11:17 +1100862 ip->i_d.di_flags2 = 0;
Darrick J. Wongf7ca3522016-10-03 09:11:43 -0700863 ip->i_d.di_cowextsize = 0;
Dave Chinner39878482016-02-09 16:54:58 +1100864 ip->i_d.di_crtime.t_sec = (__int32_t)tv.tv_sec;
865 ip->i_d.di_crtime.t_nsec = (__int32_t)tv.tv_nsec;
Christoph Hellwig93848a92013-04-03 16:11:17 +1100866 }
867
868
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 flags = XFS_ILOG_CORE;
870 switch (mode & S_IFMT) {
871 case S_IFIFO:
872 case S_IFCHR:
873 case S_IFBLK:
874 case S_IFSOCK:
875 ip->i_d.di_format = XFS_DINODE_FMT_DEV;
876 ip->i_df.if_u2.if_rdev = rdev;
877 ip->i_df.if_flags = 0;
878 flags |= XFS_ILOG_DEV;
879 break;
880 case S_IFREG:
881 case S_IFDIR:
David Chinnerb11f94d2007-07-11 11:09:33 +1000882 if (pip && (pip->i_d.di_flags & XFS_DIFLAG_ANY)) {
Dave Chinner58f88ca2016-01-04 16:44:15 +1100883 uint64_t di_flags2 = 0;
884 uint di_flags = 0;
Nathan Scott365ca832005-06-21 15:39:12 +1000885
Al Viroabbede12011-07-26 02:31:30 -0400886 if (S_ISDIR(mode)) {
Nathan Scott365ca832005-06-21 15:39:12 +1000887 if (pip->i_d.di_flags & XFS_DIFLAG_RTINHERIT)
888 di_flags |= XFS_DIFLAG_RTINHERIT;
Nathan Scottdd9f4382006-01-11 15:28:28 +1100889 if (pip->i_d.di_flags & XFS_DIFLAG_EXTSZINHERIT) {
890 di_flags |= XFS_DIFLAG_EXTSZINHERIT;
891 ip->i_d.di_extsize = pip->i_d.di_extsize;
892 }
Dave Chinner9336e3a2014-10-02 09:18:40 +1000893 if (pip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
894 di_flags |= XFS_DIFLAG_PROJINHERIT;
Al Viroabbede12011-07-26 02:31:30 -0400895 } else if (S_ISREG(mode)) {
Christoph Hellwig613d7042007-10-11 17:44:08 +1000896 if (pip->i_d.di_flags & XFS_DIFLAG_RTINHERIT)
Nathan Scott365ca832005-06-21 15:39:12 +1000897 di_flags |= XFS_DIFLAG_REALTIME;
Nathan Scottdd9f4382006-01-11 15:28:28 +1100898 if (pip->i_d.di_flags & XFS_DIFLAG_EXTSZINHERIT) {
899 di_flags |= XFS_DIFLAG_EXTSIZE;
900 ip->i_d.di_extsize = pip->i_d.di_extsize;
901 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 }
903 if ((pip->i_d.di_flags & XFS_DIFLAG_NOATIME) &&
904 xfs_inherit_noatime)
Nathan Scott365ca832005-06-21 15:39:12 +1000905 di_flags |= XFS_DIFLAG_NOATIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 if ((pip->i_d.di_flags & XFS_DIFLAG_NODUMP) &&
907 xfs_inherit_nodump)
Nathan Scott365ca832005-06-21 15:39:12 +1000908 di_flags |= XFS_DIFLAG_NODUMP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909 if ((pip->i_d.di_flags & XFS_DIFLAG_SYNC) &&
910 xfs_inherit_sync)
Nathan Scott365ca832005-06-21 15:39:12 +1000911 di_flags |= XFS_DIFLAG_SYNC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 if ((pip->i_d.di_flags & XFS_DIFLAG_NOSYMLINKS) &&
913 xfs_inherit_nosymlinks)
Nathan Scott365ca832005-06-21 15:39:12 +1000914 di_flags |= XFS_DIFLAG_NOSYMLINKS;
Barry Naujokd3446ea2006-06-09 14:54:19 +1000915 if ((pip->i_d.di_flags & XFS_DIFLAG_NODEFRAG) &&
916 xfs_inherit_nodefrag)
917 di_flags |= XFS_DIFLAG_NODEFRAG;
David Chinner2a82b8b2007-07-11 11:09:12 +1000918 if (pip->i_d.di_flags & XFS_DIFLAG_FILESTREAM)
919 di_flags |= XFS_DIFLAG_FILESTREAM;
Dave Chinner58f88ca2016-01-04 16:44:15 +1100920 if (pip->i_d.di_flags2 & XFS_DIFLAG2_DAX)
921 di_flags2 |= XFS_DIFLAG2_DAX;
922
Nathan Scott365ca832005-06-21 15:39:12 +1000923 ip->i_d.di_flags |= di_flags;
Dave Chinner58f88ca2016-01-04 16:44:15 +1100924 ip->i_d.di_flags2 |= di_flags2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 }
Darrick J. Wongf7ca3522016-10-03 09:11:43 -0700926 if (pip &&
927 (pip->i_d.di_flags2 & XFS_DIFLAG2_ANY) &&
928 pip->i_d.di_version == 3 &&
929 ip->i_d.di_version == 3) {
930 if (pip->i_d.di_flags2 & XFS_DIFLAG2_COWEXTSIZE) {
931 ip->i_d.di_flags2 |= XFS_DIFLAG2_COWEXTSIZE;
932 ip->i_d.di_cowextsize = pip->i_d.di_cowextsize;
933 }
934 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935 /* FALLTHROUGH */
936 case S_IFLNK:
937 ip->i_d.di_format = XFS_DINODE_FMT_EXTENTS;
938 ip->i_df.if_flags = XFS_IFEXTENTS;
939 ip->i_df.if_bytes = ip->i_df.if_real_bytes = 0;
940 ip->i_df.if_u1.if_extents = NULL;
941 break;
942 default:
943 ASSERT(0);
944 }
945 /*
946 * Attribute fork settings for new inode.
947 */
948 ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
949 ip->i_d.di_anextents = 0;
950
951 /*
952 * Log the new values stuffed into the inode.
953 */
Christoph Hellwigddc34152011-09-19 15:00:54 +0000954 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 xfs_trans_log_inode(tp, ip, flags);
956
Dave Chinner58c90472015-02-23 22:38:08 +1100957 /* now that we have an i_mode we can setup the inode structure */
Christoph Hellwig41be8be2008-08-13 16:23:13 +1000958 xfs_setup_inode(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959
960 *ipp = ip;
961 return 0;
962}
963
Dave Chinnere546cb72013-08-12 20:49:47 +1000964/*
965 * Allocates a new inode from disk and return a pointer to the
966 * incore copy. This routine will internally commit the current
967 * transaction and allocate a new one if the Space Manager needed
968 * to do an allocation to replenish the inode free-list.
969 *
970 * This routine is designed to be called from xfs_create and
971 * xfs_create_dir.
972 *
973 */
974int
975xfs_dir_ialloc(
976 xfs_trans_t **tpp, /* input: current transaction;
977 output: may be a new transaction. */
978 xfs_inode_t *dp, /* directory within whose allocate
979 the inode. */
980 umode_t mode,
981 xfs_nlink_t nlink,
982 xfs_dev_t rdev,
983 prid_t prid, /* project id */
984 int okalloc, /* ok to allocate new space */
985 xfs_inode_t **ipp, /* pointer to inode; it will be
986 locked. */
987 int *committed)
988
989{
990 xfs_trans_t *tp;
Dave Chinnere546cb72013-08-12 20:49:47 +1000991 xfs_inode_t *ip;
992 xfs_buf_t *ialloc_context = NULL;
993 int code;
Dave Chinnere546cb72013-08-12 20:49:47 +1000994 void *dqinfo;
995 uint tflags;
996
997 tp = *tpp;
998 ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
999
1000 /*
1001 * xfs_ialloc will return a pointer to an incore inode if
1002 * the Space Manager has an available inode on the free
1003 * list. Otherwise, it will do an allocation and replenish
1004 * the freelist. Since we can only do one allocation per
1005 * transaction without deadlocks, we will need to commit the
1006 * current transaction and start a new one. We will then
1007 * need to call xfs_ialloc again to get the inode.
1008 *
1009 * If xfs_ialloc did an allocation to replenish the freelist,
1010 * it returns the bp containing the head of the freelist as
1011 * ialloc_context. We will hold a lock on it across the
1012 * transaction commit so that no other process can steal
1013 * the inode(s) that we've just allocated.
1014 */
1015 code = xfs_ialloc(tp, dp, mode, nlink, rdev, prid, okalloc,
1016 &ialloc_context, &ip);
1017
1018 /*
1019 * Return an error if we were unable to allocate a new inode.
1020 * This should only happen if we run out of space on disk or
1021 * encounter a disk error.
1022 */
1023 if (code) {
1024 *ipp = NULL;
1025 return code;
1026 }
1027 if (!ialloc_context && !ip) {
1028 *ipp = NULL;
Dave Chinner24513372014-06-25 14:58:08 +10001029 return -ENOSPC;
Dave Chinnere546cb72013-08-12 20:49:47 +10001030 }
1031
1032 /*
1033 * If the AGI buffer is non-NULL, then we were unable to get an
1034 * inode in one operation. We need to commit the current
1035 * transaction and call xfs_ialloc() again. It is guaranteed
1036 * to succeed the second time.
1037 */
1038 if (ialloc_context) {
1039 /*
1040 * Normally, xfs_trans_commit releases all the locks.
1041 * We call bhold to hang on to the ialloc_context across
1042 * the commit. Holding this buffer prevents any other
1043 * processes from doing any allocations in this
1044 * allocation group.
1045 */
1046 xfs_trans_bhold(tp, ialloc_context);
Dave Chinnere546cb72013-08-12 20:49:47 +10001047
1048 /*
1049 * We want the quota changes to be associated with the next
1050 * transaction, NOT this one. So, detach the dqinfo from this
1051 * and attach it to the next transaction.
1052 */
1053 dqinfo = NULL;
1054 tflags = 0;
1055 if (tp->t_dqinfo) {
1056 dqinfo = (void *)tp->t_dqinfo;
1057 tp->t_dqinfo = NULL;
1058 tflags = tp->t_flags & XFS_TRANS_DQ_DIRTY;
1059 tp->t_flags &= ~(XFS_TRANS_DQ_DIRTY);
1060 }
1061
Eryu Guan6e3e6d52016-04-06 09:47:21 +10001062 code = xfs_trans_roll(&tp, NULL);
Christoph Hellwig2e6db6c2015-06-04 13:47:29 +10001063 if (committed != NULL)
Dave Chinnere546cb72013-08-12 20:49:47 +10001064 *committed = 1;
Jie Liu3d3c8b52013-08-12 20:49:59 +10001065
Dave Chinnere546cb72013-08-12 20:49:47 +10001066 /*
1067 * Re-attach the quota info that we detached from prev trx.
1068 */
1069 if (dqinfo) {
1070 tp->t_dqinfo = dqinfo;
1071 tp->t_flags |= tflags;
1072 }
1073
1074 if (code) {
1075 xfs_buf_relse(ialloc_context);
Christoph Hellwig2e6db6c2015-06-04 13:47:29 +10001076 *tpp = tp;
Dave Chinnere546cb72013-08-12 20:49:47 +10001077 *ipp = NULL;
1078 return code;
1079 }
1080 xfs_trans_bjoin(tp, ialloc_context);
1081
1082 /*
1083 * Call ialloc again. Since we've locked out all
1084 * other allocations in this allocation group,
1085 * this call should always succeed.
1086 */
1087 code = xfs_ialloc(tp, dp, mode, nlink, rdev, prid,
1088 okalloc, &ialloc_context, &ip);
1089
1090 /*
1091 * If we get an error at this point, return to the caller
1092 * so that the current transaction can be aborted.
1093 */
1094 if (code) {
1095 *tpp = tp;
1096 *ipp = NULL;
1097 return code;
1098 }
1099 ASSERT(!ialloc_context && ip);
1100
1101 } else {
1102 if (committed != NULL)
1103 *committed = 0;
1104 }
1105
1106 *ipp = ip;
1107 *tpp = tp;
1108
1109 return 0;
1110}
1111
1112/*
Dave Chinner54d7b5c2016-02-09 16:54:58 +11001113 * Decrement the link count on an inode & log the change. If this causes the
1114 * link count to go to zero, move the inode to AGI unlinked list so that it can
1115 * be freed when the last active reference goes away via xfs_inactive().
Dave Chinnere546cb72013-08-12 20:49:47 +10001116 */
Eric Sandeen0d5a75e2016-06-01 17:38:15 +10001117static int /* error */
Dave Chinnere546cb72013-08-12 20:49:47 +10001118xfs_droplink(
1119 xfs_trans_t *tp,
1120 xfs_inode_t *ip)
1121{
Dave Chinnere546cb72013-08-12 20:49:47 +10001122 xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
1123
Dave Chinnere546cb72013-08-12 20:49:47 +10001124 drop_nlink(VFS_I(ip));
1125 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1126
Dave Chinner54d7b5c2016-02-09 16:54:58 +11001127 if (VFS_I(ip)->i_nlink)
1128 return 0;
1129
1130 return xfs_iunlink(tp, ip);
Dave Chinnere546cb72013-08-12 20:49:47 +10001131}
1132
1133/*
Dave Chinnere546cb72013-08-12 20:49:47 +10001134 * Increment the link count on an inode & log the change.
1135 */
Eric Sandeen0d5a75e2016-06-01 17:38:15 +10001136static int
Dave Chinnere546cb72013-08-12 20:49:47 +10001137xfs_bumplink(
1138 xfs_trans_t *tp,
1139 xfs_inode_t *ip)
1140{
1141 xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
1142
Dave Chinner263997a2014-05-20 07:46:40 +10001143 ASSERT(ip->i_d.di_version > 1);
Dave Chinnere546cb72013-08-12 20:49:47 +10001144 inc_nlink(VFS_I(ip));
Dave Chinnere546cb72013-08-12 20:49:47 +10001145 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1146 return 0;
1147}
1148
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001149int
1150xfs_create(
1151 xfs_inode_t *dp,
1152 struct xfs_name *name,
1153 umode_t mode,
1154 xfs_dev_t rdev,
1155 xfs_inode_t **ipp)
1156{
1157 int is_dir = S_ISDIR(mode);
1158 struct xfs_mount *mp = dp->i_mount;
1159 struct xfs_inode *ip = NULL;
1160 struct xfs_trans *tp = NULL;
1161 int error;
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10001162 struct xfs_defer_ops dfops;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001163 xfs_fsblock_t first_block;
1164 bool unlock_dp_on_error = false;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001165 prid_t prid;
1166 struct xfs_dquot *udqp = NULL;
1167 struct xfs_dquot *gdqp = NULL;
1168 struct xfs_dquot *pdqp = NULL;
Brian Foster062647a2014-11-28 14:00:16 +11001169 struct xfs_trans_res *tres;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001170 uint resblks;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001171
1172 trace_xfs_create(dp, name);
1173
1174 if (XFS_FORCED_SHUTDOWN(mp))
Dave Chinner24513372014-06-25 14:58:08 +10001175 return -EIO;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001176
Zhi Yong Wu163467d2013-12-18 08:22:39 +08001177 prid = xfs_get_initial_prid(dp);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001178
1179 /*
1180 * Make sure that we have allocated dquot(s) on disk.
1181 */
Dwight Engen7aab1b22013-08-15 14:08:01 -04001182 error = xfs_qm_vop_dqalloc(dp, xfs_kuid_to_uid(current_fsuid()),
1183 xfs_kgid_to_gid(current_fsgid()), prid,
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001184 XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
1185 &udqp, &gdqp, &pdqp);
1186 if (error)
1187 return error;
1188
1189 if (is_dir) {
1190 rdev = 0;
1191 resblks = XFS_MKDIR_SPACE_RES(mp, name->len);
Brian Foster062647a2014-11-28 14:00:16 +11001192 tres = &M_RES(mp)->tr_mkdir;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001193 } else {
1194 resblks = XFS_CREATE_SPACE_RES(mp, name->len);
Brian Foster062647a2014-11-28 14:00:16 +11001195 tres = &M_RES(mp)->tr_create;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001196 }
1197
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001198 /*
1199 * Initially assume that the file does not exist and
1200 * reserve the resources for that case. If that is not
1201 * the case we'll drop the one we have and get a more
1202 * appropriate transaction later.
1203 */
Christoph Hellwig253f4912016-04-06 09:19:55 +10001204 error = xfs_trans_alloc(mp, tres, resblks, 0, 0, &tp);
Dave Chinner24513372014-06-25 14:58:08 +10001205 if (error == -ENOSPC) {
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001206 /* flush outstanding delalloc blocks and retry */
1207 xfs_flush_inodes(mp);
Christoph Hellwig253f4912016-04-06 09:19:55 +10001208 error = xfs_trans_alloc(mp, tres, resblks, 0, 0, &tp);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001209 }
Dave Chinner24513372014-06-25 14:58:08 +10001210 if (error == -ENOSPC) {
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001211 /* No space at all so try a "no-allocation" reservation */
1212 resblks = 0;
Christoph Hellwig253f4912016-04-06 09:19:55 +10001213 error = xfs_trans_alloc(mp, tres, 0, 0, 0, &tp);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001214 }
Christoph Hellwig4906e212015-06-04 13:47:56 +10001215 if (error)
Christoph Hellwig253f4912016-04-06 09:19:55 +10001216 goto out_release_inode;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001217
Dave Chinnerdbad7c92015-08-19 10:33:00 +10001218 xfs_ilock(dp, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL |
1219 XFS_IOLOCK_PARENT | XFS_ILOCK_PARENT);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001220 unlock_dp_on_error = true;
1221
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10001222 xfs_defer_init(&dfops, &first_block);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001223
1224 /*
1225 * Reserve disk quota and the inode.
1226 */
1227 error = xfs_trans_reserve_quota(tp, mp, udqp, gdqp,
1228 pdqp, resblks, 1, 0);
1229 if (error)
1230 goto out_trans_cancel;
1231
Eric Sandeen94f3cad2014-09-09 11:57:52 +10001232 if (!resblks) {
1233 error = xfs_dir_canenter(tp, dp, name);
1234 if (error)
1235 goto out_trans_cancel;
1236 }
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001237
1238 /*
1239 * A newly created regular or special file just has one directory
1240 * entry pointing to them, but a directory also the "." entry
1241 * pointing to itself.
1242 */
1243 error = xfs_dir_ialloc(&tp, dp, mode, is_dir ? 2 : 1, rdev,
Eric Sandeenf6106ef2016-01-11 11:34:01 +11001244 prid, resblks > 0, &ip, NULL);
Jan Karad6077aa2015-07-29 11:52:08 +10001245 if (error)
Christoph Hellwig4906e212015-06-04 13:47:56 +10001246 goto out_trans_cancel;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001247
1248 /*
1249 * Now we join the directory inode to the transaction. We do not do it
1250 * earlier because xfs_dir_ialloc might commit the previous transaction
1251 * (and release all the locks). An error from here on will result in
1252 * the transaction cancel unlocking dp so don't do it explicitly in the
1253 * error path.
1254 */
Dave Chinnerdbad7c92015-08-19 10:33:00 +10001255 xfs_trans_ijoin(tp, dp, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001256 unlock_dp_on_error = false;
1257
1258 error = xfs_dir_createname(tp, dp, name, ip->i_ino,
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10001259 &first_block, &dfops, resblks ?
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001260 resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
1261 if (error) {
Dave Chinner24513372014-06-25 14:58:08 +10001262 ASSERT(error != -ENOSPC);
Christoph Hellwig4906e212015-06-04 13:47:56 +10001263 goto out_trans_cancel;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001264 }
1265 xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1266 xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
1267
1268 if (is_dir) {
1269 error = xfs_dir_init(tp, ip, dp);
1270 if (error)
1271 goto out_bmap_cancel;
1272
1273 error = xfs_bumplink(tp, dp);
1274 if (error)
1275 goto out_bmap_cancel;
1276 }
1277
1278 /*
1279 * If this is a synchronous mount, make sure that the
1280 * create transaction goes to disk before returning to
1281 * the user.
1282 */
1283 if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
1284 xfs_trans_set_sync(tp);
1285
1286 /*
1287 * Attach the dquot(s) to the inodes and modify them incore.
1288 * These ids of the inode couldn't have changed since the new
1289 * inode has been locked ever since it was created.
1290 */
1291 xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp, pdqp);
1292
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10001293 error = xfs_defer_finish(&tp, &dfops, NULL);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001294 if (error)
1295 goto out_bmap_cancel;
1296
Christoph Hellwig70393312015-06-04 13:48:08 +10001297 error = xfs_trans_commit(tp);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001298 if (error)
1299 goto out_release_inode;
1300
1301 xfs_qm_dqrele(udqp);
1302 xfs_qm_dqrele(gdqp);
1303 xfs_qm_dqrele(pdqp);
1304
1305 *ipp = ip;
1306 return 0;
1307
1308 out_bmap_cancel:
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10001309 xfs_defer_cancel(&dfops);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001310 out_trans_cancel:
Christoph Hellwig4906e212015-06-04 13:47:56 +10001311 xfs_trans_cancel(tp);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001312 out_release_inode:
1313 /*
Dave Chinner58c90472015-02-23 22:38:08 +11001314 * Wait until after the current transaction is aborted to finish the
1315 * setup of the inode and release the inode. This prevents recursive
1316 * transactions and deadlocks from xfs_inactive.
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001317 */
Dave Chinner58c90472015-02-23 22:38:08 +11001318 if (ip) {
1319 xfs_finish_inode_setup(ip);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001320 IRELE(ip);
Dave Chinner58c90472015-02-23 22:38:08 +11001321 }
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001322
1323 xfs_qm_dqrele(udqp);
1324 xfs_qm_dqrele(gdqp);
1325 xfs_qm_dqrele(pdqp);
1326
1327 if (unlock_dp_on_error)
Dave Chinnerdbad7c92015-08-19 10:33:00 +10001328 xfs_iunlock(dp, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001329 return error;
1330}
1331
1332int
Zhi Yong Wu99b64362013-12-18 08:22:40 +08001333xfs_create_tmpfile(
1334 struct xfs_inode *dp,
1335 struct dentry *dentry,
Brian Foster330033d2014-04-17 08:15:30 +10001336 umode_t mode,
1337 struct xfs_inode **ipp)
Zhi Yong Wu99b64362013-12-18 08:22:40 +08001338{
1339 struct xfs_mount *mp = dp->i_mount;
1340 struct xfs_inode *ip = NULL;
1341 struct xfs_trans *tp = NULL;
1342 int error;
Zhi Yong Wu99b64362013-12-18 08:22:40 +08001343 prid_t prid;
1344 struct xfs_dquot *udqp = NULL;
1345 struct xfs_dquot *gdqp = NULL;
1346 struct xfs_dquot *pdqp = NULL;
1347 struct xfs_trans_res *tres;
1348 uint resblks;
1349
1350 if (XFS_FORCED_SHUTDOWN(mp))
Dave Chinner24513372014-06-25 14:58:08 +10001351 return -EIO;
Zhi Yong Wu99b64362013-12-18 08:22:40 +08001352
1353 prid = xfs_get_initial_prid(dp);
1354
1355 /*
1356 * Make sure that we have allocated dquot(s) on disk.
1357 */
1358 error = xfs_qm_vop_dqalloc(dp, xfs_kuid_to_uid(current_fsuid()),
1359 xfs_kgid_to_gid(current_fsgid()), prid,
1360 XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
1361 &udqp, &gdqp, &pdqp);
1362 if (error)
1363 return error;
1364
1365 resblks = XFS_IALLOC_SPACE_RES(mp);
Zhi Yong Wu99b64362013-12-18 08:22:40 +08001366 tres = &M_RES(mp)->tr_create_tmpfile;
Christoph Hellwig253f4912016-04-06 09:19:55 +10001367
1368 error = xfs_trans_alloc(mp, tres, resblks, 0, 0, &tp);
Dave Chinner24513372014-06-25 14:58:08 +10001369 if (error == -ENOSPC) {
Zhi Yong Wu99b64362013-12-18 08:22:40 +08001370 /* No space at all so try a "no-allocation" reservation */
1371 resblks = 0;
Christoph Hellwig253f4912016-04-06 09:19:55 +10001372 error = xfs_trans_alloc(mp, tres, 0, 0, 0, &tp);
Zhi Yong Wu99b64362013-12-18 08:22:40 +08001373 }
Christoph Hellwig4906e212015-06-04 13:47:56 +10001374 if (error)
Christoph Hellwig253f4912016-04-06 09:19:55 +10001375 goto out_release_inode;
Zhi Yong Wu99b64362013-12-18 08:22:40 +08001376
1377 error = xfs_trans_reserve_quota(tp, mp, udqp, gdqp,
1378 pdqp, resblks, 1, 0);
1379 if (error)
1380 goto out_trans_cancel;
1381
1382 error = xfs_dir_ialloc(&tp, dp, mode, 1, 0,
1383 prid, resblks > 0, &ip, NULL);
Jan Karad6077aa2015-07-29 11:52:08 +10001384 if (error)
Christoph Hellwig4906e212015-06-04 13:47:56 +10001385 goto out_trans_cancel;
Zhi Yong Wu99b64362013-12-18 08:22:40 +08001386
1387 if (mp->m_flags & XFS_MOUNT_WSYNC)
1388 xfs_trans_set_sync(tp);
1389
1390 /*
1391 * Attach the dquot(s) to the inodes and modify them incore.
1392 * These ids of the inode couldn't have changed since the new
1393 * inode has been locked ever since it was created.
1394 */
1395 xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp, pdqp);
1396
Zhi Yong Wu99b64362013-12-18 08:22:40 +08001397 error = xfs_iunlink(tp, ip);
1398 if (error)
Christoph Hellwig4906e212015-06-04 13:47:56 +10001399 goto out_trans_cancel;
Zhi Yong Wu99b64362013-12-18 08:22:40 +08001400
Christoph Hellwig70393312015-06-04 13:48:08 +10001401 error = xfs_trans_commit(tp);
Zhi Yong Wu99b64362013-12-18 08:22:40 +08001402 if (error)
1403 goto out_release_inode;
1404
1405 xfs_qm_dqrele(udqp);
1406 xfs_qm_dqrele(gdqp);
1407 xfs_qm_dqrele(pdqp);
1408
Brian Foster330033d2014-04-17 08:15:30 +10001409 *ipp = ip;
Zhi Yong Wu99b64362013-12-18 08:22:40 +08001410 return 0;
1411
Zhi Yong Wu99b64362013-12-18 08:22:40 +08001412 out_trans_cancel:
Christoph Hellwig4906e212015-06-04 13:47:56 +10001413 xfs_trans_cancel(tp);
Zhi Yong Wu99b64362013-12-18 08:22:40 +08001414 out_release_inode:
1415 /*
Dave Chinner58c90472015-02-23 22:38:08 +11001416 * Wait until after the current transaction is aborted to finish the
1417 * setup of the inode and release the inode. This prevents recursive
1418 * transactions and deadlocks from xfs_inactive.
Zhi Yong Wu99b64362013-12-18 08:22:40 +08001419 */
Dave Chinner58c90472015-02-23 22:38:08 +11001420 if (ip) {
1421 xfs_finish_inode_setup(ip);
Zhi Yong Wu99b64362013-12-18 08:22:40 +08001422 IRELE(ip);
Dave Chinner58c90472015-02-23 22:38:08 +11001423 }
Zhi Yong Wu99b64362013-12-18 08:22:40 +08001424
1425 xfs_qm_dqrele(udqp);
1426 xfs_qm_dqrele(gdqp);
1427 xfs_qm_dqrele(pdqp);
1428
1429 return error;
1430}
1431
1432int
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001433xfs_link(
1434 xfs_inode_t *tdp,
1435 xfs_inode_t *sip,
1436 struct xfs_name *target_name)
1437{
1438 xfs_mount_t *mp = tdp->i_mount;
1439 xfs_trans_t *tp;
1440 int error;
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10001441 struct xfs_defer_ops dfops;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001442 xfs_fsblock_t first_block;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001443 int resblks;
1444
1445 trace_xfs_link(tdp, target_name);
1446
Dave Chinnerc19b3b052016-02-09 16:54:58 +11001447 ASSERT(!S_ISDIR(VFS_I(sip)->i_mode));
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001448
1449 if (XFS_FORCED_SHUTDOWN(mp))
Dave Chinner24513372014-06-25 14:58:08 +10001450 return -EIO;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001451
1452 error = xfs_qm_dqattach(sip, 0);
1453 if (error)
1454 goto std_return;
1455
1456 error = xfs_qm_dqattach(tdp, 0);
1457 if (error)
1458 goto std_return;
1459
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001460 resblks = XFS_LINK_SPACE_RES(mp, target_name->len);
Christoph Hellwig253f4912016-04-06 09:19:55 +10001461 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_link, resblks, 0, 0, &tp);
Dave Chinner24513372014-06-25 14:58:08 +10001462 if (error == -ENOSPC) {
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001463 resblks = 0;
Christoph Hellwig253f4912016-04-06 09:19:55 +10001464 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_link, 0, 0, 0, &tp);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001465 }
Christoph Hellwig4906e212015-06-04 13:47:56 +10001466 if (error)
Christoph Hellwig253f4912016-04-06 09:19:55 +10001467 goto std_return;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001468
Dave Chinnerdbad7c92015-08-19 10:33:00 +10001469 xfs_ilock(tdp, XFS_IOLOCK_EXCL | XFS_IOLOCK_PARENT);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001470 xfs_lock_two_inodes(sip, tdp, XFS_ILOCK_EXCL);
1471
1472 xfs_trans_ijoin(tp, sip, XFS_ILOCK_EXCL);
Dave Chinnerdbad7c92015-08-19 10:33:00 +10001473 xfs_trans_ijoin(tp, tdp, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001474
1475 /*
1476 * If we are using project inheritance, we only allow hard link
1477 * creation in our tree when the project IDs are the same; else
1478 * the tree quota mechanism could be circumvented.
1479 */
1480 if (unlikely((tdp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
1481 (xfs_get_projid(tdp) != xfs_get_projid(sip)))) {
Dave Chinner24513372014-06-25 14:58:08 +10001482 error = -EXDEV;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001483 goto error_return;
1484 }
1485
Eric Sandeen94f3cad2014-09-09 11:57:52 +10001486 if (!resblks) {
1487 error = xfs_dir_canenter(tp, tdp, target_name);
1488 if (error)
1489 goto error_return;
1490 }
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001491
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10001492 xfs_defer_init(&dfops, &first_block);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001493
Dave Chinner54d7b5c2016-02-09 16:54:58 +11001494 /*
1495 * Handle initial link state of O_TMPFILE inode
1496 */
1497 if (VFS_I(sip)->i_nlink == 0) {
Zhi Yong Wuab297432013-12-18 08:22:41 +08001498 error = xfs_iunlink_remove(tp, sip);
1499 if (error)
Christoph Hellwig4906e212015-06-04 13:47:56 +10001500 goto error_return;
Zhi Yong Wuab297432013-12-18 08:22:41 +08001501 }
1502
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001503 error = xfs_dir_createname(tp, tdp, target_name, sip->i_ino,
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10001504 &first_block, &dfops, resblks);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001505 if (error)
Christoph Hellwig4906e212015-06-04 13:47:56 +10001506 goto error_return;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001507 xfs_trans_ichgtime(tp, tdp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1508 xfs_trans_log_inode(tp, tdp, XFS_ILOG_CORE);
1509
1510 error = xfs_bumplink(tp, sip);
1511 if (error)
Christoph Hellwig4906e212015-06-04 13:47:56 +10001512 goto error_return;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001513
1514 /*
1515 * If this is a synchronous mount, make sure that the
1516 * link transaction goes to disk before returning to
1517 * the user.
1518 */
Eric Sandeenf6106ef2016-01-11 11:34:01 +11001519 if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001520 xfs_trans_set_sync(tp);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001521
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10001522 error = xfs_defer_finish(&tp, &dfops, NULL);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001523 if (error) {
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10001524 xfs_defer_cancel(&dfops);
Christoph Hellwig4906e212015-06-04 13:47:56 +10001525 goto error_return;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001526 }
1527
Christoph Hellwig70393312015-06-04 13:48:08 +10001528 return xfs_trans_commit(tp);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001529
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001530 error_return:
Christoph Hellwig4906e212015-06-04 13:47:56 +10001531 xfs_trans_cancel(tp);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001532 std_return:
1533 return error;
1534}
1535
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536/*
Christoph Hellwig8f04c472011-07-08 14:34:34 +02001537 * Free up the underlying blocks past new_size. The new size must be smaller
1538 * than the current size. This routine can be used both for the attribute and
1539 * data fork, and does not modify the inode size, which is left to the caller.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540 *
David Chinnerf6485052008-04-17 16:50:04 +10001541 * The transaction passed to this routine must have made a permanent log
1542 * reservation of at least XFS_ITRUNCATE_LOG_RES. This routine may commit the
1543 * given transaction and start new ones, so make sure everything involved in
1544 * the transaction is tidy before calling here. Some transaction will be
1545 * returned to the caller to be committed. The incoming transaction must
1546 * already include the inode, and both inode locks must be held exclusively.
1547 * The inode must also be "held" within the transaction. On return the inode
1548 * will be "held" within the returned transaction. This routine does NOT
1549 * require any disk space to be reserved for it within the transaction.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550 *
David Chinnerf6485052008-04-17 16:50:04 +10001551 * If we get an error, we must return with the inode locked and linked into the
1552 * current transaction. This keeps things simple for the higher level code,
1553 * because it always knows that the inode is locked and held in the transaction
1554 * that returns to it whether errors occur or not. We don't mark the inode
1555 * dirty on error so that transactions can be easily aborted if possible.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556 */
1557int
Christoph Hellwig8f04c472011-07-08 14:34:34 +02001558xfs_itruncate_extents(
1559 struct xfs_trans **tpp,
1560 struct xfs_inode *ip,
1561 int whichfork,
1562 xfs_fsize_t new_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563{
Christoph Hellwig8f04c472011-07-08 14:34:34 +02001564 struct xfs_mount *mp = ip->i_mount;
1565 struct xfs_trans *tp = *tpp;
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10001566 struct xfs_defer_ops dfops;
Christoph Hellwig8f04c472011-07-08 14:34:34 +02001567 xfs_fsblock_t first_block;
1568 xfs_fileoff_t first_unmap_block;
1569 xfs_fileoff_t last_block;
1570 xfs_filblks_t unmap_len;
Christoph Hellwig8f04c472011-07-08 14:34:34 +02001571 int error = 0;
1572 int done = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573
Christoph Hellwig0b561852012-07-04 11:13:31 -04001574 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
1575 ASSERT(!atomic_read(&VFS_I(ip)->i_count) ||
1576 xfs_isilocked(ip, XFS_IOLOCK_EXCL));
Christoph Hellwigce7ae1512011-12-18 20:00:11 +00001577 ASSERT(new_size <= XFS_ISIZE(ip));
Christoph Hellwig8f04c472011-07-08 14:34:34 +02001578 ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579 ASSERT(ip->i_itemp != NULL);
Christoph Hellwig898621d2010-06-24 11:36:58 +10001580 ASSERT(ip->i_itemp->ili_lock_flags == 0);
Christoph Hellwig8f04c472011-07-08 14:34:34 +02001581 ASSERT(!XFS_NOT_DQATTACHED(mp, ip));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582
Christoph Hellwig673e8e52011-12-18 20:00:04 +00001583 trace_xfs_itruncate_extents_start(ip, new_size);
1584
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585 /*
1586 * Since it is possible for space to become allocated beyond
1587 * the end of the file (in a crash where the space is allocated
1588 * but the inode size is not yet updated), simply remove any
1589 * blocks which show up between the new EOF and the maximum
1590 * possible file size. If the first block to be removed is
1591 * beyond the maximum file size (ie it is the same as last_block),
1592 * then there is nothing to do.
1593 */
Christoph Hellwig8f04c472011-07-08 14:34:34 +02001594 first_unmap_block = XFS_B_TO_FSB(mp, (xfs_ufsize_t)new_size);
Dave Chinner32972382012-06-08 15:44:54 +10001595 last_block = XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes);
Christoph Hellwig8f04c472011-07-08 14:34:34 +02001596 if (first_unmap_block == last_block)
1597 return 0;
1598
1599 ASSERT(first_unmap_block < last_block);
1600 unmap_len = last_block - first_unmap_block + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601 while (!done) {
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10001602 xfs_defer_init(&dfops, &first_block);
Christoph Hellwig8f04c472011-07-08 14:34:34 +02001603 error = xfs_bunmapi(tp, ip,
Olaf Weber3e57ecf2006-06-09 14:48:12 +10001604 first_unmap_block, unmap_len,
Christoph Hellwig8f04c472011-07-08 14:34:34 +02001605 xfs_bmapi_aflag(whichfork),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606 XFS_ITRUNC_MAX_EXTENTS,
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10001607 &first_block, &dfops,
Christoph Hellwigb4e91812010-06-23 18:11:15 +10001608 &done);
Christoph Hellwig8f04c472011-07-08 14:34:34 +02001609 if (error)
1610 goto out_bmap_cancel;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611
1612 /*
1613 * Duplicate the transaction that has the permanent
1614 * reservation and commit the old transaction.
1615 */
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10001616 error = xfs_defer_finish(&tp, &dfops, ip);
Christoph Hellwig8f04c472011-07-08 14:34:34 +02001617 if (error)
1618 goto out_bmap_cancel;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619
Christoph Hellwig2e6db6c2015-06-04 13:47:29 +10001620 error = xfs_trans_roll(&tp, ip);
David Chinnerf6485052008-04-17 16:50:04 +10001621 if (error)
Christoph Hellwig8f04c472011-07-08 14:34:34 +02001622 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 }
Christoph Hellwig8f04c472011-07-08 14:34:34 +02001624
Darrick J. Wongaa8968f2016-10-03 09:11:38 -07001625 /* Remove all pending CoW reservations. */
1626 error = xfs_reflink_cancel_cow_blocks(ip, &tp, first_unmap_block,
1627 last_block);
1628 if (error)
1629 goto out;
1630
1631 /*
1632 * Clear the reflink flag if we truncated everything.
1633 */
Darrick J. Wong83104d42016-10-03 09:11:46 -07001634 if (ip->i_d.di_nblocks == 0 && xfs_is_reflink_inode(ip)) {
Darrick J. Wongaa8968f2016-10-03 09:11:38 -07001635 ip->i_d.di_flags2 &= ~XFS_DIFLAG2_REFLINK;
Darrick J. Wong83104d42016-10-03 09:11:46 -07001636 xfs_inode_clear_cowblocks_tag(ip);
1637 }
Darrick J. Wongaa8968f2016-10-03 09:11:38 -07001638
Christoph Hellwig673e8e52011-12-18 20:00:04 +00001639 /*
1640 * Always re-log the inode so that our permanent transaction can keep
1641 * on rolling it forward in the log.
1642 */
1643 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1644
1645 trace_xfs_itruncate_extents_end(ip, new_size);
1646
Christoph Hellwig8f04c472011-07-08 14:34:34 +02001647out:
1648 *tpp = tp;
1649 return error;
1650out_bmap_cancel:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 /*
Christoph Hellwig8f04c472011-07-08 14:34:34 +02001652 * If the bunmapi call encounters an error, return to the caller where
1653 * the transaction can be properly aborted. We just need to make sure
1654 * we're not holding any resources that we were not when we came in.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655 */
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10001656 xfs_defer_cancel(&dfops);
Christoph Hellwig8f04c472011-07-08 14:34:34 +02001657 goto out;
1658}
1659
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001660int
1661xfs_release(
1662 xfs_inode_t *ip)
1663{
1664 xfs_mount_t *mp = ip->i_mount;
1665 int error;
1666
Dave Chinnerc19b3b052016-02-09 16:54:58 +11001667 if (!S_ISREG(VFS_I(ip)->i_mode) || (VFS_I(ip)->i_mode == 0))
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001668 return 0;
1669
1670 /* If this is a read-only mount, don't do this (would generate I/O) */
1671 if (mp->m_flags & XFS_MOUNT_RDONLY)
1672 return 0;
1673
1674 if (!XFS_FORCED_SHUTDOWN(mp)) {
1675 int truncated;
1676
1677 /*
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001678 * If we previously truncated this file and removed old data
1679 * in the process, we want to initiate "early" writeout on
1680 * the last close. This is an attempt to combat the notorious
1681 * NULL files problem which is particularly noticeable from a
1682 * truncate down, buffered (re-)write (delalloc), followed by
1683 * a crash. What we are effectively doing here is
1684 * significantly reducing the time window where we'd otherwise
1685 * be exposed to that problem.
1686 */
1687 truncated = xfs_iflags_test_and_clear(ip, XFS_ITRUNCATED);
1688 if (truncated) {
1689 xfs_iflags_clear(ip, XFS_IDIRTY_RELEASE);
Dave Chinnereac152b2014-08-04 13:22:49 +10001690 if (ip->i_delayed_blks > 0) {
Dave Chinner24513372014-06-25 14:58:08 +10001691 error = filemap_flush(VFS_I(ip)->i_mapping);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001692 if (error)
1693 return error;
1694 }
1695 }
1696 }
1697
Dave Chinner54d7b5c2016-02-09 16:54:58 +11001698 if (VFS_I(ip)->i_nlink == 0)
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001699 return 0;
1700
1701 if (xfs_can_free_eofblocks(ip, false)) {
1702
1703 /*
1704 * If we can't get the iolock just skip truncating the blocks
1705 * past EOF because we could deadlock with the mmap_sem
1706 * otherwise. We'll get another chance to drop them once the
1707 * last reference to the inode is dropped, so we'll never leak
1708 * blocks permanently.
1709 *
1710 * Further, check if the inode is being opened, written and
1711 * closed frequently and we have delayed allocation blocks
1712 * outstanding (e.g. streaming writes from the NFS server),
1713 * truncating the blocks past EOF will cause fragmentation to
1714 * occur.
1715 *
1716 * In this case don't do the truncation, either, but we have to
1717 * be careful how we detect this case. Blocks beyond EOF show
1718 * up as i_delayed_blks even when the inode is clean, so we
1719 * need to truncate them away first before checking for a dirty
1720 * release. Hence on the first dirty close we will still remove
1721 * the speculative allocation, but after that we will leave it
1722 * in place.
1723 */
1724 if (xfs_iflags_test(ip, XFS_IDIRTY_RELEASE))
1725 return 0;
1726
1727 error = xfs_free_eofblocks(mp, ip, true);
Dave Chinner24513372014-06-25 14:58:08 +10001728 if (error && error != -EAGAIN)
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001729 return error;
1730
1731 /* delalloc blocks after truncation means it really is dirty */
1732 if (ip->i_delayed_blks)
1733 xfs_iflags_set(ip, XFS_IDIRTY_RELEASE);
1734 }
1735 return 0;
1736}
1737
1738/*
Brian Fosterf7be2d72013-09-20 11:06:10 -04001739 * xfs_inactive_truncate
1740 *
1741 * Called to perform a truncate when an inode becomes unlinked.
1742 */
1743STATIC int
1744xfs_inactive_truncate(
1745 struct xfs_inode *ip)
1746{
1747 struct xfs_mount *mp = ip->i_mount;
1748 struct xfs_trans *tp;
1749 int error;
1750
Christoph Hellwig253f4912016-04-06 09:19:55 +10001751 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
Brian Fosterf7be2d72013-09-20 11:06:10 -04001752 if (error) {
1753 ASSERT(XFS_FORCED_SHUTDOWN(mp));
Brian Fosterf7be2d72013-09-20 11:06:10 -04001754 return error;
1755 }
1756
1757 xfs_ilock(ip, XFS_ILOCK_EXCL);
1758 xfs_trans_ijoin(tp, ip, 0);
1759
1760 /*
1761 * Log the inode size first to prevent stale data exposure in the event
1762 * of a system crash before the truncate completes. See the related
Jan Kara69bca802016-05-26 14:46:43 +02001763 * comment in xfs_vn_setattr_size() for details.
Brian Fosterf7be2d72013-09-20 11:06:10 -04001764 */
1765 ip->i_d.di_size = 0;
1766 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1767
1768 error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK, 0);
1769 if (error)
1770 goto error_trans_cancel;
1771
1772 ASSERT(ip->i_d.di_nextents == 0);
1773
Christoph Hellwig70393312015-06-04 13:48:08 +10001774 error = xfs_trans_commit(tp);
Brian Fosterf7be2d72013-09-20 11:06:10 -04001775 if (error)
1776 goto error_unlock;
1777
1778 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1779 return 0;
1780
1781error_trans_cancel:
Christoph Hellwig4906e212015-06-04 13:47:56 +10001782 xfs_trans_cancel(tp);
Brian Fosterf7be2d72013-09-20 11:06:10 -04001783error_unlock:
1784 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1785 return error;
1786}
1787
1788/*
Brian Foster88877d22013-09-20 11:06:11 -04001789 * xfs_inactive_ifree()
1790 *
1791 * Perform the inode free when an inode is unlinked.
1792 */
1793STATIC int
1794xfs_inactive_ifree(
1795 struct xfs_inode *ip)
1796{
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10001797 struct xfs_defer_ops dfops;
Brian Foster88877d22013-09-20 11:06:11 -04001798 xfs_fsblock_t first_block;
Brian Foster88877d22013-09-20 11:06:11 -04001799 struct xfs_mount *mp = ip->i_mount;
1800 struct xfs_trans *tp;
1801 int error;
1802
Brian Foster9d43b182014-04-24 16:00:52 +10001803 /*
1804 * The ifree transaction might need to allocate blocks for record
1805 * insertion to the finobt. We don't want to fail here at ENOSPC, so
1806 * allow ifree to dip into the reserved block pool if necessary.
1807 *
1808 * Freeing large sets of inodes generally means freeing inode chunks,
1809 * directory and file data blocks, so this should be relatively safe.
1810 * Only under severe circumstances should it be possible to free enough
1811 * inodes to exhaust the reserve block pool via finobt expansion while
1812 * at the same time not creating free space in the filesystem.
1813 *
1814 * Send a warning if the reservation does happen to fail, as the inode
1815 * now remains allocated and sits on the unlinked list until the fs is
1816 * repaired.
1817 */
Christoph Hellwig253f4912016-04-06 09:19:55 +10001818 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ifree,
1819 XFS_IFREE_SPACE_RES(mp), 0, XFS_TRANS_RESERVE, &tp);
Brian Foster88877d22013-09-20 11:06:11 -04001820 if (error) {
Dave Chinner24513372014-06-25 14:58:08 +10001821 if (error == -ENOSPC) {
Brian Foster9d43b182014-04-24 16:00:52 +10001822 xfs_warn_ratelimited(mp,
1823 "Failed to remove inode(s) from unlinked list. "
1824 "Please free space, unmount and run xfs_repair.");
1825 } else {
1826 ASSERT(XFS_FORCED_SHUTDOWN(mp));
1827 }
Brian Foster88877d22013-09-20 11:06:11 -04001828 return error;
1829 }
1830
1831 xfs_ilock(ip, XFS_ILOCK_EXCL);
1832 xfs_trans_ijoin(tp, ip, 0);
1833
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10001834 xfs_defer_init(&dfops, &first_block);
1835 error = xfs_ifree(tp, ip, &dfops);
Brian Foster88877d22013-09-20 11:06:11 -04001836 if (error) {
1837 /*
1838 * If we fail to free the inode, shut down. The cancel
1839 * might do that, we need to make sure. Otherwise the
1840 * inode might be lost for a long time or forever.
1841 */
1842 if (!XFS_FORCED_SHUTDOWN(mp)) {
1843 xfs_notice(mp, "%s: xfs_ifree returned error %d",
1844 __func__, error);
1845 xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
1846 }
Christoph Hellwig4906e212015-06-04 13:47:56 +10001847 xfs_trans_cancel(tp);
Brian Foster88877d22013-09-20 11:06:11 -04001848 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1849 return error;
1850 }
1851
1852 /*
1853 * Credit the quota account(s). The inode is gone.
1854 */
1855 xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_ICOUNT, -1);
1856
1857 /*
Brian Fosterd4a97a02015-08-19 10:01:40 +10001858 * Just ignore errors at this point. There is nothing we can do except
1859 * to try to keep going. Make sure it's not a silent error.
Brian Foster88877d22013-09-20 11:06:11 -04001860 */
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10001861 error = xfs_defer_finish(&tp, &dfops, NULL);
Brian Fosterd4a97a02015-08-19 10:01:40 +10001862 if (error) {
Darrick J. Wong310a75a2016-08-03 11:18:10 +10001863 xfs_notice(mp, "%s: xfs_defer_finish returned error %d",
Brian Foster88877d22013-09-20 11:06:11 -04001864 __func__, error);
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10001865 xfs_defer_cancel(&dfops);
Brian Fosterd4a97a02015-08-19 10:01:40 +10001866 }
Christoph Hellwig70393312015-06-04 13:48:08 +10001867 error = xfs_trans_commit(tp);
Brian Foster88877d22013-09-20 11:06:11 -04001868 if (error)
1869 xfs_notice(mp, "%s: xfs_trans_commit returned error %d",
1870 __func__, error);
1871
1872 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1873 return 0;
1874}
1875
1876/*
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001877 * xfs_inactive
1878 *
1879 * This is called when the vnode reference count for the vnode
1880 * goes to zero. If the file has been unlinked, then it must
1881 * now be truncated. Also, we clear all of the read-ahead state
1882 * kept for the inode here since the file is now closed.
1883 */
Brian Foster74564fb2013-09-20 11:06:12 -04001884void
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001885xfs_inactive(
1886 xfs_inode_t *ip)
1887{
Jie Liu3d3c8b52013-08-12 20:49:59 +10001888 struct xfs_mount *mp;
Jie Liu3d3c8b52013-08-12 20:49:59 +10001889 int error;
1890 int truncate = 0;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001891
1892 /*
1893 * If the inode is already free, then there can be nothing
1894 * to clean up here.
1895 */
Dave Chinnerc19b3b052016-02-09 16:54:58 +11001896 if (VFS_I(ip)->i_mode == 0) {
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001897 ASSERT(ip->i_df.if_real_bytes == 0);
1898 ASSERT(ip->i_df.if_broot_bytes == 0);
Brian Foster74564fb2013-09-20 11:06:12 -04001899 return;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001900 }
1901
1902 mp = ip->i_mount;
Darrick J. Wong17c12bc2016-10-03 09:11:29 -07001903 ASSERT(!xfs_iflags_test(ip, XFS_IRECOVERY));
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001904
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001905 /* If this is a read-only mount, don't do this (would generate I/O) */
1906 if (mp->m_flags & XFS_MOUNT_RDONLY)
Brian Foster74564fb2013-09-20 11:06:12 -04001907 return;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001908
Dave Chinner54d7b5c2016-02-09 16:54:58 +11001909 if (VFS_I(ip)->i_nlink != 0) {
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001910 /*
1911 * force is true because we are evicting an inode from the
1912 * cache. Post-eof blocks must be freed, lest we end up with
1913 * broken free space accounting.
1914 */
Brian Foster74564fb2013-09-20 11:06:12 -04001915 if (xfs_can_free_eofblocks(ip, true))
1916 xfs_free_eofblocks(mp, ip, false);
1917
1918 return;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001919 }
1920
Dave Chinnerc19b3b052016-02-09 16:54:58 +11001921 if (S_ISREG(VFS_I(ip)->i_mode) &&
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001922 (ip->i_d.di_size != 0 || XFS_ISIZE(ip) != 0 ||
1923 ip->i_d.di_nextents > 0 || ip->i_delayed_blks > 0))
1924 truncate = 1;
1925
1926 error = xfs_qm_dqattach(ip, 0);
1927 if (error)
Brian Foster74564fb2013-09-20 11:06:12 -04001928 return;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001929
Dave Chinnerc19b3b052016-02-09 16:54:58 +11001930 if (S_ISLNK(VFS_I(ip)->i_mode))
Brian Foster36b21dd2013-09-20 11:06:09 -04001931 error = xfs_inactive_symlink(ip);
Brian Fosterf7be2d72013-09-20 11:06:10 -04001932 else if (truncate)
1933 error = xfs_inactive_truncate(ip);
1934 if (error)
Brian Foster74564fb2013-09-20 11:06:12 -04001935 return;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001936
1937 /*
1938 * If there are attributes associated with the file then blow them away
1939 * now. The code calls a routine that recursively deconstructs the
Dave Chinner6dfe5a02015-05-29 07:40:08 +10001940 * attribute fork. If also blows away the in-core attribute fork.
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001941 */
Dave Chinner6dfe5a02015-05-29 07:40:08 +10001942 if (XFS_IFORK_Q(ip)) {
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001943 error = xfs_attr_inactive(ip);
1944 if (error)
Brian Foster74564fb2013-09-20 11:06:12 -04001945 return;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001946 }
1947
Dave Chinner6dfe5a02015-05-29 07:40:08 +10001948 ASSERT(!ip->i_afp);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001949 ASSERT(ip->i_d.di_anextents == 0);
Dave Chinner6dfe5a02015-05-29 07:40:08 +10001950 ASSERT(ip->i_d.di_forkoff == 0);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001951
1952 /*
1953 * Free the inode.
1954 */
Brian Foster88877d22013-09-20 11:06:11 -04001955 error = xfs_inactive_ifree(ip);
1956 if (error)
Brian Foster74564fb2013-09-20 11:06:12 -04001957 return;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001958
1959 /*
1960 * Release the dquots held by inode, if any.
1961 */
1962 xfs_qm_dqdetach(ip);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10001963}
1964
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965/*
Dave Chinner54d7b5c2016-02-09 16:54:58 +11001966 * This is called when the inode's link count goes to 0 or we are creating a
1967 * tmpfile via O_TMPFILE. In the case of a tmpfile, @ignore_linkcount will be
1968 * set to true as the link count is dropped to zero by the VFS after we've
1969 * created the file successfully, so we have to add it to the unlinked list
1970 * while the link count is non-zero.
1971 *
1972 * We place the on-disk inode on a list in the AGI. It will be pulled from this
1973 * list when the inode is freed.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001974 */
Dave Chinner54d7b5c2016-02-09 16:54:58 +11001975STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001976xfs_iunlink(
Dave Chinner54d7b5c2016-02-09 16:54:58 +11001977 struct xfs_trans *tp,
1978 struct xfs_inode *ip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979{
Dave Chinner54d7b5c2016-02-09 16:54:58 +11001980 xfs_mount_t *mp = tp->t_mountp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981 xfs_agi_t *agi;
1982 xfs_dinode_t *dip;
1983 xfs_buf_t *agibp;
1984 xfs_buf_t *ibp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001985 xfs_agino_t agino;
1986 short bucket_index;
1987 int offset;
1988 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989
Dave Chinnerc19b3b052016-02-09 16:54:58 +11001990 ASSERT(VFS_I(ip)->i_mode != 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991
Linus Torvalds1da177e2005-04-16 15:20:36 -07001992 /*
1993 * Get the agi buffer first. It ensures lock ordering
1994 * on the list.
1995 */
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11001996 error = xfs_read_agi(mp, tp, XFS_INO_TO_AGNO(mp, ip->i_ino), &agibp);
Vlad Apostolov859d7182007-10-11 17:44:18 +10001997 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999 agi = XFS_BUF_TO_AGI(agibp);
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11002000
Linus Torvalds1da177e2005-04-16 15:20:36 -07002001 /*
2002 * Get the index into the agi hash table for the
2003 * list this inode will go on.
2004 */
2005 agino = XFS_INO_TO_AGINO(mp, ip->i_ino);
2006 ASSERT(agino != 0);
2007 bucket_index = agino % XFS_AGI_UNLINKED_BUCKETS;
2008 ASSERT(agi->agi_unlinked[bucket_index]);
Christoph Hellwig16259e72005-11-02 15:11:25 +11002009 ASSERT(be32_to_cpu(agi->agi_unlinked[bucket_index]) != agino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002010
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002011 if (agi->agi_unlinked[bucket_index] != cpu_to_be32(NULLAGINO)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002012 /*
2013 * There is already another inode in the bucket we need
2014 * to add ourselves to. Add us at the front of the list.
2015 * Here we put the head pointer into our next pointer,
2016 * and then we fall through to point the head at us.
2017 */
Christoph Hellwig475ee412012-07-03 12:21:22 -04002018 error = xfs_imap_to_bp(mp, tp, &ip->i_imap, &dip, &ibp,
2019 0, 0);
Vlad Apostolovc319b582007-11-23 16:27:51 +11002020 if (error)
2021 return error;
2022
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002023 ASSERT(dip->di_next_unlinked == cpu_to_be32(NULLAGINO));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024 dip->di_next_unlinked = agi->agi_unlinked[bucket_index];
Christoph Hellwig92bfc6e2008-11-28 14:23:41 +11002025 offset = ip->i_imap.im_boffset +
Linus Torvalds1da177e2005-04-16 15:20:36 -07002026 offsetof(xfs_dinode_t, di_next_unlinked);
Dave Chinner0a32c262013-06-05 12:09:08 +10002027
2028 /* need to recalc the inode CRC if appropriate */
2029 xfs_dinode_calc_crc(mp, dip);
2030
Linus Torvalds1da177e2005-04-16 15:20:36 -07002031 xfs_trans_inode_buf(tp, ibp);
2032 xfs_trans_log_buf(tp, ibp, offset,
2033 (offset + sizeof(xfs_agino_t) - 1));
2034 xfs_inobp_check(mp, ibp);
2035 }
2036
2037 /*
2038 * Point the bucket head pointer at the inode being inserted.
2039 */
2040 ASSERT(agino != 0);
Christoph Hellwig16259e72005-11-02 15:11:25 +11002041 agi->agi_unlinked[bucket_index] = cpu_to_be32(agino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042 offset = offsetof(xfs_agi_t, agi_unlinked) +
2043 (sizeof(xfs_agino_t) * bucket_index);
Dave Chinnerf19b8722015-01-22 09:29:40 +11002044 xfs_trans_buf_set_type(tp, agibp, XFS_BLFT_AGI_BUF);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002045 xfs_trans_log_buf(tp, agibp, offset,
2046 (offset + sizeof(xfs_agino_t) - 1));
2047 return 0;
2048}
2049
2050/*
2051 * Pull the on-disk inode from the AGI unlinked list.
2052 */
2053STATIC int
2054xfs_iunlink_remove(
2055 xfs_trans_t *tp,
2056 xfs_inode_t *ip)
2057{
2058 xfs_ino_t next_ino;
2059 xfs_mount_t *mp;
2060 xfs_agi_t *agi;
2061 xfs_dinode_t *dip;
2062 xfs_buf_t *agibp;
2063 xfs_buf_t *ibp;
2064 xfs_agnumber_t agno;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002065 xfs_agino_t agino;
2066 xfs_agino_t next_agino;
2067 xfs_buf_t *last_ibp;
Nathan Scott6fdf8cc2006-06-28 10:13:52 +10002068 xfs_dinode_t *last_dip = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002069 short bucket_index;
Nathan Scott6fdf8cc2006-06-28 10:13:52 +10002070 int offset, last_offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002071 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002072
Linus Torvalds1da177e2005-04-16 15:20:36 -07002073 mp = tp->t_mountp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074 agno = XFS_INO_TO_AGNO(mp, ip->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002075
2076 /*
2077 * Get the agi buffer first. It ensures lock ordering
2078 * on the list.
2079 */
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11002080 error = xfs_read_agi(mp, tp, agno, &agibp);
2081 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002082 return error;
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11002083
Linus Torvalds1da177e2005-04-16 15:20:36 -07002084 agi = XFS_BUF_TO_AGI(agibp);
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11002085
Linus Torvalds1da177e2005-04-16 15:20:36 -07002086 /*
2087 * Get the index into the agi hash table for the
2088 * list this inode will go on.
2089 */
2090 agino = XFS_INO_TO_AGINO(mp, ip->i_ino);
2091 ASSERT(agino != 0);
2092 bucket_index = agino % XFS_AGI_UNLINKED_BUCKETS;
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002093 ASSERT(agi->agi_unlinked[bucket_index] != cpu_to_be32(NULLAGINO));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094 ASSERT(agi->agi_unlinked[bucket_index]);
2095
Christoph Hellwig16259e72005-11-02 15:11:25 +11002096 if (be32_to_cpu(agi->agi_unlinked[bucket_index]) == agino) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097 /*
Christoph Hellwig475ee412012-07-03 12:21:22 -04002098 * We're at the head of the list. Get the inode's on-disk
2099 * buffer to see if there is anyone after us on the list.
2100 * Only modify our next pointer if it is not already NULLAGINO.
2101 * This saves us the overhead of dealing with the buffer when
2102 * there is no need to change it.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103 */
Christoph Hellwig475ee412012-07-03 12:21:22 -04002104 error = xfs_imap_to_bp(mp, tp, &ip->i_imap, &dip, &ibp,
2105 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002106 if (error) {
Christoph Hellwig475ee412012-07-03 12:21:22 -04002107 xfs_warn(mp, "%s: xfs_imap_to_bp returned error %d.",
Dave Chinner0b932cc2011-03-07 10:08:35 +11002108 __func__, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109 return error;
2110 }
Christoph Hellwig347d1c02007-08-28 13:57:51 +10002111 next_agino = be32_to_cpu(dip->di_next_unlinked);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002112 ASSERT(next_agino != 0);
2113 if (next_agino != NULLAGINO) {
Christoph Hellwig347d1c02007-08-28 13:57:51 +10002114 dip->di_next_unlinked = cpu_to_be32(NULLAGINO);
Christoph Hellwig92bfc6e2008-11-28 14:23:41 +11002115 offset = ip->i_imap.im_boffset +
Linus Torvalds1da177e2005-04-16 15:20:36 -07002116 offsetof(xfs_dinode_t, di_next_unlinked);
Dave Chinner0a32c262013-06-05 12:09:08 +10002117
2118 /* need to recalc the inode CRC if appropriate */
2119 xfs_dinode_calc_crc(mp, dip);
2120
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121 xfs_trans_inode_buf(tp, ibp);
2122 xfs_trans_log_buf(tp, ibp, offset,
2123 (offset + sizeof(xfs_agino_t) - 1));
2124 xfs_inobp_check(mp, ibp);
2125 } else {
2126 xfs_trans_brelse(tp, ibp);
2127 }
2128 /*
2129 * Point the bucket head pointer at the next inode.
2130 */
2131 ASSERT(next_agino != 0);
2132 ASSERT(next_agino != agino);
Christoph Hellwig16259e72005-11-02 15:11:25 +11002133 agi->agi_unlinked[bucket_index] = cpu_to_be32(next_agino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134 offset = offsetof(xfs_agi_t, agi_unlinked) +
2135 (sizeof(xfs_agino_t) * bucket_index);
Dave Chinnerf19b8722015-01-22 09:29:40 +11002136 xfs_trans_buf_set_type(tp, agibp, XFS_BLFT_AGI_BUF);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137 xfs_trans_log_buf(tp, agibp, offset,
2138 (offset + sizeof(xfs_agino_t) - 1));
2139 } else {
2140 /*
2141 * We need to search the list for the inode being freed.
2142 */
Christoph Hellwig16259e72005-11-02 15:11:25 +11002143 next_agino = be32_to_cpu(agi->agi_unlinked[bucket_index]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002144 last_ibp = NULL;
2145 while (next_agino != agino) {
Christoph Hellwig129dbc92012-07-03 12:21:51 -04002146 struct xfs_imap imap;
2147
2148 if (last_ibp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002149 xfs_trans_brelse(tp, last_ibp);
Christoph Hellwig129dbc92012-07-03 12:21:51 -04002150
2151 imap.im_blkno = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002152 next_ino = XFS_AGINO_TO_INO(mp, agno, next_agino);
Christoph Hellwig129dbc92012-07-03 12:21:51 -04002153
2154 error = xfs_imap(mp, tp, next_ino, &imap, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002155 if (error) {
Dave Chinner0b932cc2011-03-07 10:08:35 +11002156 xfs_warn(mp,
Christoph Hellwig129dbc92012-07-03 12:21:51 -04002157 "%s: xfs_imap returned error %d.",
2158 __func__, error);
2159 return error;
2160 }
2161
2162 error = xfs_imap_to_bp(mp, tp, &imap, &last_dip,
2163 &last_ibp, 0, 0);
2164 if (error) {
2165 xfs_warn(mp,
2166 "%s: xfs_imap_to_bp returned error %d.",
Dave Chinner0b932cc2011-03-07 10:08:35 +11002167 __func__, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168 return error;
2169 }
Christoph Hellwig129dbc92012-07-03 12:21:51 -04002170
2171 last_offset = imap.im_boffset;
Christoph Hellwig347d1c02007-08-28 13:57:51 +10002172 next_agino = be32_to_cpu(last_dip->di_next_unlinked);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002173 ASSERT(next_agino != NULLAGINO);
2174 ASSERT(next_agino != 0);
2175 }
Christoph Hellwig475ee412012-07-03 12:21:22 -04002176
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177 /*
Christoph Hellwig475ee412012-07-03 12:21:22 -04002178 * Now last_ibp points to the buffer previous to us on the
2179 * unlinked list. Pull us from the list.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002180 */
Christoph Hellwig475ee412012-07-03 12:21:22 -04002181 error = xfs_imap_to_bp(mp, tp, &ip->i_imap, &dip, &ibp,
2182 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002183 if (error) {
Christoph Hellwig475ee412012-07-03 12:21:22 -04002184 xfs_warn(mp, "%s: xfs_imap_to_bp(2) returned error %d.",
Dave Chinner0b932cc2011-03-07 10:08:35 +11002185 __func__, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002186 return error;
2187 }
Christoph Hellwig347d1c02007-08-28 13:57:51 +10002188 next_agino = be32_to_cpu(dip->di_next_unlinked);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002189 ASSERT(next_agino != 0);
2190 ASSERT(next_agino != agino);
2191 if (next_agino != NULLAGINO) {
Christoph Hellwig347d1c02007-08-28 13:57:51 +10002192 dip->di_next_unlinked = cpu_to_be32(NULLAGINO);
Christoph Hellwig92bfc6e2008-11-28 14:23:41 +11002193 offset = ip->i_imap.im_boffset +
Linus Torvalds1da177e2005-04-16 15:20:36 -07002194 offsetof(xfs_dinode_t, di_next_unlinked);
Dave Chinner0a32c262013-06-05 12:09:08 +10002195
2196 /* need to recalc the inode CRC if appropriate */
2197 xfs_dinode_calc_crc(mp, dip);
2198
Linus Torvalds1da177e2005-04-16 15:20:36 -07002199 xfs_trans_inode_buf(tp, ibp);
2200 xfs_trans_log_buf(tp, ibp, offset,
2201 (offset + sizeof(xfs_agino_t) - 1));
2202 xfs_inobp_check(mp, ibp);
2203 } else {
2204 xfs_trans_brelse(tp, ibp);
2205 }
2206 /*
2207 * Point the previous inode on the list to the next inode.
2208 */
Christoph Hellwig347d1c02007-08-28 13:57:51 +10002209 last_dip->di_next_unlinked = cpu_to_be32(next_agino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002210 ASSERT(next_agino != 0);
2211 offset = last_offset + offsetof(xfs_dinode_t, di_next_unlinked);
Dave Chinner0a32c262013-06-05 12:09:08 +10002212
2213 /* need to recalc the inode CRC if appropriate */
2214 xfs_dinode_calc_crc(mp, last_dip);
2215
Linus Torvalds1da177e2005-04-16 15:20:36 -07002216 xfs_trans_inode_buf(tp, last_ibp);
2217 xfs_trans_log_buf(tp, last_ibp, offset,
2218 (offset + sizeof(xfs_agino_t) - 1));
2219 xfs_inobp_check(mp, last_ibp);
2220 }
2221 return 0;
2222}
2223
Dave Chinner5b3eed72010-08-24 11:42:41 +10002224/*
Zhi Yong Wu0b8182d2013-08-12 03:14:59 +00002225 * A big issue when freeing the inode cluster is that we _cannot_ skip any
Dave Chinner5b3eed72010-08-24 11:42:41 +10002226 * inodes that are in memory - they all must be marked stale and attached to
2227 * the cluster buffer.
2228 */
Chandra Seetharaman2a30f36d2011-09-20 13:56:55 +00002229STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230xfs_ifree_cluster(
Brian Foster09b56602015-05-29 09:26:03 +10002231 xfs_inode_t *free_ip,
2232 xfs_trans_t *tp,
2233 struct xfs_icluster *xic)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002234{
2235 xfs_mount_t *mp = free_ip->i_mount;
2236 int blks_per_cluster;
Jie Liu982e9392013-12-13 15:51:49 +11002237 int inodes_per_cluster;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238 int nbufs;
Dave Chinner5b257b42010-06-03 16:22:29 +10002239 int i, j;
Brian Foster3cdaa182015-06-04 13:03:34 +10002240 int ioffset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002241 xfs_daddr_t blkno;
2242 xfs_buf_t *bp;
Dave Chinner5b257b42010-06-03 16:22:29 +10002243 xfs_inode_t *ip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244 xfs_inode_log_item_t *iip;
2245 xfs_log_item_t *lip;
Dave Chinner5017e972010-01-11 11:47:40 +00002246 struct xfs_perag *pag;
Brian Foster09b56602015-05-29 09:26:03 +10002247 xfs_ino_t inum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002248
Brian Foster09b56602015-05-29 09:26:03 +10002249 inum = xic->first_ino;
Dave Chinner5017e972010-01-11 11:47:40 +00002250 pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, inum));
Jie Liu982e9392013-12-13 15:51:49 +11002251 blks_per_cluster = xfs_icluster_size_fsb(mp);
2252 inodes_per_cluster = blks_per_cluster << mp->m_sb.sb_inopblog;
2253 nbufs = mp->m_ialloc_blks / blks_per_cluster;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002254
Jie Liu982e9392013-12-13 15:51:49 +11002255 for (j = 0; j < nbufs; j++, inum += inodes_per_cluster) {
Brian Foster09b56602015-05-29 09:26:03 +10002256 /*
2257 * The allocation bitmap tells us which inodes of the chunk were
2258 * physically allocated. Skip the cluster if an inode falls into
2259 * a sparse region.
2260 */
Brian Foster3cdaa182015-06-04 13:03:34 +10002261 ioffset = inum - xic->first_ino;
2262 if ((xic->alloc & XFS_INOBT_MASK(ioffset)) == 0) {
2263 ASSERT(do_mod(ioffset, inodes_per_cluster) == 0);
Brian Foster09b56602015-05-29 09:26:03 +10002264 continue;
2265 }
2266
Linus Torvalds1da177e2005-04-16 15:20:36 -07002267 blkno = XFS_AGB_TO_DADDR(mp, XFS_INO_TO_AGNO(mp, inum),
2268 XFS_INO_TO_AGBNO(mp, inum));
2269
Linus Torvalds1da177e2005-04-16 15:20:36 -07002270 /*
Dave Chinner5b257b42010-06-03 16:22:29 +10002271 * We obtain and lock the backing buffer first in the process
2272 * here, as we have to ensure that any dirty inode that we
2273 * can't get the flush lock on is attached to the buffer.
2274 * If we scan the in-memory inodes first, then buffer IO can
2275 * complete before we get a lock on it, and hence we may fail
2276 * to mark all the active inodes on the buffer stale.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002277 */
Dave Chinner5b257b42010-06-03 16:22:29 +10002278 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, blkno,
Dave Chinnerb6aff292012-11-02 11:38:42 +11002279 mp->m_bsize * blks_per_cluster,
2280 XBF_UNMAPPED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002281
Chandra Seetharaman2a30f36d2011-09-20 13:56:55 +00002282 if (!bp)
Dave Chinner24513372014-06-25 14:58:08 +10002283 return -ENOMEM;
Dave Chinnerb0f539d2012-11-14 17:53:49 +11002284
2285 /*
2286 * This buffer may not have been correctly initialised as we
2287 * didn't read it from disk. That's not important because we are
2288 * only using to mark the buffer as stale in the log, and to
2289 * attach stale cached inodes on it. That means it will never be
2290 * dispatched for IO. If it is, we want to know about it, and we
2291 * want it to fail. We can acheive this by adding a write
2292 * verifier to the buffer.
2293 */
Dave Chinner1813dd62012-11-14 17:54:40 +11002294 bp->b_ops = &xfs_inode_buf_ops;
Dave Chinnerb0f539d2012-11-14 17:53:49 +11002295
Dave Chinner5b257b42010-06-03 16:22:29 +10002296 /*
2297 * Walk the inodes already attached to the buffer and mark them
2298 * stale. These will all have the flush locks held, so an
Dave Chinner5b3eed72010-08-24 11:42:41 +10002299 * in-memory inode walk can't lock them. By marking them all
2300 * stale first, we will not attempt to lock them in the loop
2301 * below as the XFS_ISTALE flag will be set.
Dave Chinner5b257b42010-06-03 16:22:29 +10002302 */
Christoph Hellwigadadbee2011-07-13 13:43:49 +02002303 lip = bp->b_fspriv;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002304 while (lip) {
2305 if (lip->li_type == XFS_LI_INODE) {
2306 iip = (xfs_inode_log_item_t *)lip;
2307 ASSERT(iip->ili_logged == 1);
Christoph Hellwigca30b2a2010-06-23 18:11:15 +10002308 lip->li_cb = xfs_istale_done;
David Chinner7b2e2a32008-10-30 17:39:12 +11002309 xfs_trans_ail_copy_lsn(mp->m_ail,
2310 &iip->ili_flush_lsn,
2311 &iip->ili_item.li_lsn);
David Chinnere5ffd2b2006-11-21 18:55:33 +11002312 xfs_iflags_set(iip->ili_inode, XFS_ISTALE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002313 }
2314 lip = lip->li_bio_list;
2315 }
2316
Dave Chinner5b3eed72010-08-24 11:42:41 +10002317
Dave Chinner5b257b42010-06-03 16:22:29 +10002318 /*
2319 * For each inode in memory attempt to add it to the inode
2320 * buffer and set it up for being staled on buffer IO
2321 * completion. This is safe as we've locked out tail pushing
2322 * and flushing by locking the buffer.
2323 *
2324 * We have already marked every inode that was part of a
2325 * transaction stale above, which means there is no point in
2326 * even trying to lock them.
2327 */
Jie Liu982e9392013-12-13 15:51:49 +11002328 for (i = 0; i < inodes_per_cluster; i++) {
Dave Chinner5b3eed72010-08-24 11:42:41 +10002329retry:
Dave Chinner1a3e8f32010-12-17 17:29:43 +11002330 rcu_read_lock();
Dave Chinner5b257b42010-06-03 16:22:29 +10002331 ip = radix_tree_lookup(&pag->pag_ici_root,
2332 XFS_INO_TO_AGINO(mp, (inum + i)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002333
Dave Chinner1a3e8f32010-12-17 17:29:43 +11002334 /* Inode not in memory, nothing to do */
2335 if (!ip) {
2336 rcu_read_unlock();
Dave Chinner5b257b42010-06-03 16:22:29 +10002337 continue;
2338 }
2339
Dave Chinner5b3eed72010-08-24 11:42:41 +10002340 /*
Dave Chinner1a3e8f32010-12-17 17:29:43 +11002341 * because this is an RCU protected lookup, we could
2342 * find a recently freed or even reallocated inode
2343 * during the lookup. We need to check under the
2344 * i_flags_lock for a valid inode here. Skip it if it
2345 * is not valid, the wrong inode or stale.
2346 */
2347 spin_lock(&ip->i_flags_lock);
2348 if (ip->i_ino != inum + i ||
2349 __xfs_iflags_test(ip, XFS_ISTALE)) {
2350 spin_unlock(&ip->i_flags_lock);
2351 rcu_read_unlock();
2352 continue;
2353 }
2354 spin_unlock(&ip->i_flags_lock);
2355
2356 /*
Dave Chinner5b3eed72010-08-24 11:42:41 +10002357 * Don't try to lock/unlock the current inode, but we
2358 * _cannot_ skip the other inodes that we did not find
2359 * in the list attached to the buffer and are not
2360 * already marked stale. If we can't lock it, back off
2361 * and retry.
2362 */
Dave Chinner5b257b42010-06-03 16:22:29 +10002363 if (ip != free_ip &&
2364 !xfs_ilock_nowait(ip, XFS_ILOCK_EXCL)) {
Dave Chinner1a3e8f32010-12-17 17:29:43 +11002365 rcu_read_unlock();
Dave Chinner5b3eed72010-08-24 11:42:41 +10002366 delay(1);
2367 goto retry;
Dave Chinner5b257b42010-06-03 16:22:29 +10002368 }
Dave Chinner1a3e8f32010-12-17 17:29:43 +11002369 rcu_read_unlock();
Dave Chinner5b257b42010-06-03 16:22:29 +10002370
Dave Chinner5b3eed72010-08-24 11:42:41 +10002371 xfs_iflock(ip);
Dave Chinner5b257b42010-06-03 16:22:29 +10002372 xfs_iflags_set(ip, XFS_ISTALE);
Dave Chinner5b257b42010-06-03 16:22:29 +10002373
Dave Chinner5b3eed72010-08-24 11:42:41 +10002374 /*
2375 * we don't need to attach clean inodes or those only
2376 * with unlogged changes (which we throw away, anyway).
2377 */
Dave Chinner5b257b42010-06-03 16:22:29 +10002378 iip = ip->i_itemp;
Dave Chinner5b3eed72010-08-24 11:42:41 +10002379 if (!iip || xfs_inode_clean(ip)) {
Dave Chinner5b257b42010-06-03 16:22:29 +10002380 ASSERT(ip != free_ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002381 xfs_ifunlock(ip);
2382 xfs_iunlock(ip, XFS_ILOCK_EXCL);
2383 continue;
2384 }
2385
Christoph Hellwigf5d8d5c2012-02-29 09:53:54 +00002386 iip->ili_last_fields = iip->ili_fields;
2387 iip->ili_fields = 0;
Dave Chinnerfc0561c2015-11-03 13:14:59 +11002388 iip->ili_fsync_fields = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002389 iip->ili_logged = 1;
David Chinner7b2e2a32008-10-30 17:39:12 +11002390 xfs_trans_ail_copy_lsn(mp->m_ail, &iip->ili_flush_lsn,
2391 &iip->ili_item.li_lsn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002392
Christoph Hellwigca30b2a2010-06-23 18:11:15 +10002393 xfs_buf_attach_iodone(bp, xfs_istale_done,
2394 &iip->ili_item);
Dave Chinner5b257b42010-06-03 16:22:29 +10002395
2396 if (ip != free_ip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002397 xfs_iunlock(ip, XFS_ILOCK_EXCL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002398 }
2399
Dave Chinner5b3eed72010-08-24 11:42:41 +10002400 xfs_trans_stale_inode_buf(tp, bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002401 xfs_trans_binval(tp, bp);
2402 }
2403
Dave Chinner5017e972010-01-11 11:47:40 +00002404 xfs_perag_put(pag);
Chandra Seetharaman2a30f36d2011-09-20 13:56:55 +00002405 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002406}
2407
2408/*
2409 * This is called to return an inode to the inode free list.
2410 * The inode should already be truncated to 0 length and have
2411 * no pages associated with it. This routine also assumes that
2412 * the inode is already a part of the transaction.
2413 *
2414 * The on-disk copy of the inode will have been added to the list
2415 * of unlinked inodes in the AGI. We need to remove the inode from
2416 * that list atomically with respect to freeing it here.
2417 */
2418int
2419xfs_ifree(
2420 xfs_trans_t *tp,
2421 xfs_inode_t *ip,
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10002422 struct xfs_defer_ops *dfops)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002423{
2424 int error;
Brian Foster09b56602015-05-29 09:26:03 +10002425 struct xfs_icluster xic = { 0 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07002426
Christoph Hellwig579aa9c2008-04-22 17:34:00 +10002427 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
Dave Chinner54d7b5c2016-02-09 16:54:58 +11002428 ASSERT(VFS_I(ip)->i_nlink == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002429 ASSERT(ip->i_d.di_nextents == 0);
2430 ASSERT(ip->i_d.di_anextents == 0);
Dave Chinnerc19b3b052016-02-09 16:54:58 +11002431 ASSERT(ip->i_d.di_size == 0 || !S_ISREG(VFS_I(ip)->i_mode));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002432 ASSERT(ip->i_d.di_nblocks == 0);
2433
2434 /*
2435 * Pull the on-disk inode from the AGI unlinked list.
2436 */
2437 error = xfs_iunlink_remove(tp, ip);
Dave Chinner1baaed82013-06-27 16:04:50 +10002438 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002439 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002440
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10002441 error = xfs_difree(tp, ip->i_ino, dfops, &xic);
Dave Chinner1baaed82013-06-27 16:04:50 +10002442 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002443 return error;
Dave Chinner1baaed82013-06-27 16:04:50 +10002444
Dave Chinnerc19b3b052016-02-09 16:54:58 +11002445 VFS_I(ip)->i_mode = 0; /* mark incore inode as free */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002446 ip->i_d.di_flags = 0;
2447 ip->i_d.di_dmevmask = 0;
2448 ip->i_d.di_forkoff = 0; /* mark the attr fork not in use */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002449 ip->i_d.di_format = XFS_DINODE_FMT_EXTENTS;
2450 ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
2451 /*
2452 * Bump the generation count so no one will be confused
2453 * by reincarnations of this inode.
2454 */
Dave Chinner9e9a2672016-02-09 16:54:58 +11002455 VFS_I(ip)->i_generation++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002456 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
2457
Brian Foster09b56602015-05-29 09:26:03 +10002458 if (xic.deleted)
2459 error = xfs_ifree_cluster(ip, tp, &xic);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002460
Chandra Seetharaman2a30f36d2011-09-20 13:56:55 +00002461 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002462}
2463
2464/*
Christoph Hellwig60ec6782010-02-17 19:43:56 +00002465 * This is called to unpin an inode. The caller must have the inode locked
2466 * in at least shared mode so that the buffer cannot be subsequently pinned
2467 * once someone is waiting for it to be unpinned.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002468 */
Christoph Hellwig60ec6782010-02-17 19:43:56 +00002469static void
Christoph Hellwigf392e632011-12-18 20:00:10 +00002470xfs_iunpin(
Christoph Hellwig60ec6782010-02-17 19:43:56 +00002471 struct xfs_inode *ip)
David Chinnera3f74ff2008-03-06 13:43:42 +11002472{
Christoph Hellwig579aa9c2008-04-22 17:34:00 +10002473 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
David Chinnera3f74ff2008-03-06 13:43:42 +11002474
Dave Chinner4aaf15d2010-03-08 11:24:07 +11002475 trace_xfs_inode_unpin_nowait(ip, _RET_IP_);
2476
David Chinnera3f74ff2008-03-06 13:43:42 +11002477 /* Give the log a push to start the unpinning I/O */
Christoph Hellwig60ec6782010-02-17 19:43:56 +00002478 xfs_log_force_lsn(ip->i_mount, ip->i_itemp->ili_last_lsn, 0);
Christoph Hellwiga14a3482010-01-19 09:56:46 +00002479
David Chinnera3f74ff2008-03-06 13:43:42 +11002480}
2481
Christoph Hellwigf392e632011-12-18 20:00:10 +00002482static void
2483__xfs_iunpin_wait(
2484 struct xfs_inode *ip)
2485{
2486 wait_queue_head_t *wq = bit_waitqueue(&ip->i_flags, __XFS_IPINNED_BIT);
2487 DEFINE_WAIT_BIT(wait, &ip->i_flags, __XFS_IPINNED_BIT);
2488
2489 xfs_iunpin(ip);
2490
2491 do {
2492 prepare_to_wait(wq, &wait.wait, TASK_UNINTERRUPTIBLE);
2493 if (xfs_ipincount(ip))
2494 io_schedule();
2495 } while (xfs_ipincount(ip));
2496 finish_wait(wq, &wait.wait);
2497}
2498
Dave Chinner777df5a2010-02-06 12:37:26 +11002499void
Linus Torvalds1da177e2005-04-16 15:20:36 -07002500xfs_iunpin_wait(
Christoph Hellwig60ec6782010-02-17 19:43:56 +00002501 struct xfs_inode *ip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002502{
Christoph Hellwigf392e632011-12-18 20:00:10 +00002503 if (xfs_ipincount(ip))
2504 __xfs_iunpin_wait(ip);
David Chinnera3f74ff2008-03-06 13:43:42 +11002505}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002506
Dave Chinner27320362013-10-29 22:11:44 +11002507/*
2508 * Removing an inode from the namespace involves removing the directory entry
2509 * and dropping the link count on the inode. Removing the directory entry can
2510 * result in locking an AGF (directory blocks were freed) and removing a link
2511 * count can result in placing the inode on an unlinked list which results in
2512 * locking an AGI.
2513 *
2514 * The big problem here is that we have an ordering constraint on AGF and AGI
2515 * locking - inode allocation locks the AGI, then can allocate a new extent for
2516 * new inodes, locking the AGF after the AGI. Similarly, freeing the inode
2517 * removes the inode from the unlinked list, requiring that we lock the AGI
2518 * first, and then freeing the inode can result in an inode chunk being freed
2519 * and hence freeing disk space requiring that we lock an AGF.
2520 *
2521 * Hence the ordering that is imposed by other parts of the code is AGI before
2522 * AGF. This means we cannot remove the directory entry before we drop the inode
2523 * reference count and put it on the unlinked list as this results in a lock
2524 * order of AGF then AGI, and this can deadlock against inode allocation and
2525 * freeing. Therefore we must drop the link counts before we remove the
2526 * directory entry.
2527 *
2528 * This is still safe from a transactional point of view - it is not until we
Darrick J. Wong310a75a2016-08-03 11:18:10 +10002529 * get to xfs_defer_finish() that we have the possibility of multiple
Dave Chinner27320362013-10-29 22:11:44 +11002530 * transactions in this operation. Hence as long as we remove the directory
2531 * entry and drop the link count in the first transaction of the remove
2532 * operation, there are no transactional constraints on the ordering here.
2533 */
Dave Chinnerc24b5df2013-08-12 20:49:45 +10002534int
2535xfs_remove(
2536 xfs_inode_t *dp,
2537 struct xfs_name *name,
2538 xfs_inode_t *ip)
2539{
2540 xfs_mount_t *mp = dp->i_mount;
2541 xfs_trans_t *tp = NULL;
Dave Chinnerc19b3b052016-02-09 16:54:58 +11002542 int is_dir = S_ISDIR(VFS_I(ip)->i_mode);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10002543 int error = 0;
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10002544 struct xfs_defer_ops dfops;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10002545 xfs_fsblock_t first_block;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10002546 uint resblks;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10002547
2548 trace_xfs_remove(dp, name);
2549
2550 if (XFS_FORCED_SHUTDOWN(mp))
Dave Chinner24513372014-06-25 14:58:08 +10002551 return -EIO;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10002552
2553 error = xfs_qm_dqattach(dp, 0);
2554 if (error)
2555 goto std_return;
2556
2557 error = xfs_qm_dqattach(ip, 0);
2558 if (error)
2559 goto std_return;
2560
Dave Chinnerc24b5df2013-08-12 20:49:45 +10002561 /*
2562 * We try to get the real space reservation first,
2563 * allowing for directory btree deletion(s) implying
2564 * possible bmap insert(s). If we can't get the space
2565 * reservation then we use 0 instead, and avoid the bmap
2566 * btree insert(s) in the directory code by, if the bmap
2567 * insert tries to happen, instead trimming the LAST
2568 * block from the directory.
2569 */
2570 resblks = XFS_REMOVE_SPACE_RES(mp);
Christoph Hellwig253f4912016-04-06 09:19:55 +10002571 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_remove, resblks, 0, 0, &tp);
Dave Chinner24513372014-06-25 14:58:08 +10002572 if (error == -ENOSPC) {
Dave Chinnerc24b5df2013-08-12 20:49:45 +10002573 resblks = 0;
Christoph Hellwig253f4912016-04-06 09:19:55 +10002574 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_remove, 0, 0, 0,
2575 &tp);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10002576 }
2577 if (error) {
Dave Chinner24513372014-06-25 14:58:08 +10002578 ASSERT(error != -ENOSPC);
Christoph Hellwig253f4912016-04-06 09:19:55 +10002579 goto std_return;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10002580 }
2581
Dave Chinnerdbad7c92015-08-19 10:33:00 +10002582 xfs_ilock(dp, XFS_IOLOCK_EXCL | XFS_IOLOCK_PARENT);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10002583 xfs_lock_two_inodes(dp, ip, XFS_ILOCK_EXCL);
2584
Dave Chinnerdbad7c92015-08-19 10:33:00 +10002585 xfs_trans_ijoin(tp, dp, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10002586 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
2587
2588 /*
2589 * If we're removing a directory perform some additional validation.
2590 */
2591 if (is_dir) {
Dave Chinner54d7b5c2016-02-09 16:54:58 +11002592 ASSERT(VFS_I(ip)->i_nlink >= 2);
2593 if (VFS_I(ip)->i_nlink != 2) {
Dave Chinner24513372014-06-25 14:58:08 +10002594 error = -ENOTEMPTY;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10002595 goto out_trans_cancel;
2596 }
2597 if (!xfs_dir_isempty(ip)) {
Dave Chinner24513372014-06-25 14:58:08 +10002598 error = -ENOTEMPTY;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10002599 goto out_trans_cancel;
2600 }
Dave Chinnerc24b5df2013-08-12 20:49:45 +10002601
Dave Chinner27320362013-10-29 22:11:44 +11002602 /* Drop the link from ip's "..". */
Dave Chinnerc24b5df2013-08-12 20:49:45 +10002603 error = xfs_droplink(tp, dp);
2604 if (error)
Dave Chinner27320362013-10-29 22:11:44 +11002605 goto out_trans_cancel;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10002606
Dave Chinner27320362013-10-29 22:11:44 +11002607 /* Drop the "." link from ip to self. */
Dave Chinnerc24b5df2013-08-12 20:49:45 +10002608 error = xfs_droplink(tp, ip);
2609 if (error)
Dave Chinner27320362013-10-29 22:11:44 +11002610 goto out_trans_cancel;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10002611 } else {
2612 /*
2613 * When removing a non-directory we need to log the parent
2614 * inode here. For a directory this is done implicitly
2615 * by the xfs_droplink call for the ".." entry.
2616 */
2617 xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
2618 }
Dave Chinner27320362013-10-29 22:11:44 +11002619 xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10002620
Dave Chinner27320362013-10-29 22:11:44 +11002621 /* Drop the link from dp to ip. */
Dave Chinnerc24b5df2013-08-12 20:49:45 +10002622 error = xfs_droplink(tp, ip);
2623 if (error)
Dave Chinner27320362013-10-29 22:11:44 +11002624 goto out_trans_cancel;
Dave Chinnerc24b5df2013-08-12 20:49:45 +10002625
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10002626 xfs_defer_init(&dfops, &first_block);
Dave Chinner27320362013-10-29 22:11:44 +11002627 error = xfs_dir_removename(tp, dp, name, ip->i_ino,
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10002628 &first_block, &dfops, resblks);
Dave Chinner27320362013-10-29 22:11:44 +11002629 if (error) {
Dave Chinner24513372014-06-25 14:58:08 +10002630 ASSERT(error != -ENOENT);
Dave Chinner27320362013-10-29 22:11:44 +11002631 goto out_bmap_cancel;
2632 }
2633
Dave Chinnerc24b5df2013-08-12 20:49:45 +10002634 /*
2635 * If this is a synchronous mount, make sure that the
2636 * remove transaction goes to disk before returning to
2637 * the user.
2638 */
2639 if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
2640 xfs_trans_set_sync(tp);
2641
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10002642 error = xfs_defer_finish(&tp, &dfops, NULL);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10002643 if (error)
2644 goto out_bmap_cancel;
2645
Christoph Hellwig70393312015-06-04 13:48:08 +10002646 error = xfs_trans_commit(tp);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10002647 if (error)
2648 goto std_return;
2649
Christoph Hellwig2cd2ef62014-04-23 07:11:51 +10002650 if (is_dir && xfs_inode_is_filestream(ip))
Dave Chinnerc24b5df2013-08-12 20:49:45 +10002651 xfs_filestream_deassociate(ip);
2652
2653 return 0;
2654
2655 out_bmap_cancel:
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10002656 xfs_defer_cancel(&dfops);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10002657 out_trans_cancel:
Christoph Hellwig4906e212015-06-04 13:47:56 +10002658 xfs_trans_cancel(tp);
Dave Chinnerc24b5df2013-08-12 20:49:45 +10002659 std_return:
2660 return error;
2661}
2662
Dave Chinnerf6bba202013-08-12 20:49:46 +10002663/*
2664 * Enter all inodes for a rename transaction into a sorted array.
2665 */
Dave Chinner95afcf52015-03-25 14:03:32 +11002666#define __XFS_SORT_INODES 5
Dave Chinnerf6bba202013-08-12 20:49:46 +10002667STATIC void
2668xfs_sort_for_rename(
Dave Chinner95afcf52015-03-25 14:03:32 +11002669 struct xfs_inode *dp1, /* in: old (source) directory inode */
2670 struct xfs_inode *dp2, /* in: new (target) directory inode */
2671 struct xfs_inode *ip1, /* in: inode of old entry */
2672 struct xfs_inode *ip2, /* in: inode of new entry */
2673 struct xfs_inode *wip, /* in: whiteout inode */
2674 struct xfs_inode **i_tab,/* out: sorted array of inodes */
2675 int *num_inodes) /* in/out: inodes in array */
Dave Chinnerf6bba202013-08-12 20:49:46 +10002676{
Dave Chinnerf6bba202013-08-12 20:49:46 +10002677 int i, j;
2678
Dave Chinner95afcf52015-03-25 14:03:32 +11002679 ASSERT(*num_inodes == __XFS_SORT_INODES);
2680 memset(i_tab, 0, *num_inodes * sizeof(struct xfs_inode *));
2681
Dave Chinnerf6bba202013-08-12 20:49:46 +10002682 /*
2683 * i_tab contains a list of pointers to inodes. We initialize
2684 * the table here & we'll sort it. We will then use it to
2685 * order the acquisition of the inode locks.
2686 *
2687 * Note that the table may contain duplicates. e.g., dp1 == dp2.
2688 */
Dave Chinner95afcf52015-03-25 14:03:32 +11002689 i = 0;
2690 i_tab[i++] = dp1;
2691 i_tab[i++] = dp2;
2692 i_tab[i++] = ip1;
2693 if (ip2)
2694 i_tab[i++] = ip2;
2695 if (wip)
2696 i_tab[i++] = wip;
2697 *num_inodes = i;
Dave Chinnerf6bba202013-08-12 20:49:46 +10002698
2699 /*
2700 * Sort the elements via bubble sort. (Remember, there are at
Dave Chinner95afcf52015-03-25 14:03:32 +11002701 * most 5 elements to sort, so this is adequate.)
Dave Chinnerf6bba202013-08-12 20:49:46 +10002702 */
2703 for (i = 0; i < *num_inodes; i++) {
2704 for (j = 1; j < *num_inodes; j++) {
2705 if (i_tab[j]->i_ino < i_tab[j-1]->i_ino) {
Dave Chinner95afcf52015-03-25 14:03:32 +11002706 struct xfs_inode *temp = i_tab[j];
Dave Chinnerf6bba202013-08-12 20:49:46 +10002707 i_tab[j] = i_tab[j-1];
2708 i_tab[j-1] = temp;
2709 }
2710 }
2711 }
2712}
2713
Dave Chinner310606b2015-03-25 14:06:07 +11002714static int
2715xfs_finish_rename(
2716 struct xfs_trans *tp,
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10002717 struct xfs_defer_ops *dfops)
Dave Chinner310606b2015-03-25 14:06:07 +11002718{
Dave Chinner310606b2015-03-25 14:06:07 +11002719 int error;
2720
2721 /*
2722 * If this is a synchronous mount, make sure that the rename transaction
2723 * goes to disk before returning to the user.
2724 */
2725 if (tp->t_mountp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
2726 xfs_trans_set_sync(tp);
2727
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10002728 error = xfs_defer_finish(&tp, dfops, NULL);
Dave Chinner310606b2015-03-25 14:06:07 +11002729 if (error) {
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10002730 xfs_defer_cancel(dfops);
Christoph Hellwig4906e212015-06-04 13:47:56 +10002731 xfs_trans_cancel(tp);
Dave Chinner310606b2015-03-25 14:06:07 +11002732 return error;
2733 }
2734
Christoph Hellwig70393312015-06-04 13:48:08 +10002735 return xfs_trans_commit(tp);
Dave Chinner310606b2015-03-25 14:06:07 +11002736}
2737
Dave Chinnerf6bba202013-08-12 20:49:46 +10002738/*
Carlos Maiolinod31a1822014-12-24 08:51:42 +11002739 * xfs_cross_rename()
2740 *
2741 * responsible for handling RENAME_EXCHANGE flag in renameat2() sytemcall
2742 */
2743STATIC int
2744xfs_cross_rename(
2745 struct xfs_trans *tp,
2746 struct xfs_inode *dp1,
2747 struct xfs_name *name1,
2748 struct xfs_inode *ip1,
2749 struct xfs_inode *dp2,
2750 struct xfs_name *name2,
2751 struct xfs_inode *ip2,
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10002752 struct xfs_defer_ops *dfops,
Carlos Maiolinod31a1822014-12-24 08:51:42 +11002753 xfs_fsblock_t *first_block,
2754 int spaceres)
2755{
2756 int error = 0;
2757 int ip1_flags = 0;
2758 int ip2_flags = 0;
2759 int dp2_flags = 0;
2760
2761 /* Swap inode number for dirent in first parent */
2762 error = xfs_dir_replace(tp, dp1, name1,
2763 ip2->i_ino,
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10002764 first_block, dfops, spaceres);
Carlos Maiolinod31a1822014-12-24 08:51:42 +11002765 if (error)
Dave Chinnereeacd322015-03-25 14:08:07 +11002766 goto out_trans_abort;
Carlos Maiolinod31a1822014-12-24 08:51:42 +11002767
2768 /* Swap inode number for dirent in second parent */
2769 error = xfs_dir_replace(tp, dp2, name2,
2770 ip1->i_ino,
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10002771 first_block, dfops, spaceres);
Carlos Maiolinod31a1822014-12-24 08:51:42 +11002772 if (error)
Dave Chinnereeacd322015-03-25 14:08:07 +11002773 goto out_trans_abort;
Carlos Maiolinod31a1822014-12-24 08:51:42 +11002774
2775 /*
2776 * If we're renaming one or more directories across different parents,
2777 * update the respective ".." entries (and link counts) to match the new
2778 * parents.
2779 */
2780 if (dp1 != dp2) {
2781 dp2_flags = XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG;
2782
Dave Chinnerc19b3b052016-02-09 16:54:58 +11002783 if (S_ISDIR(VFS_I(ip2)->i_mode)) {
Carlos Maiolinod31a1822014-12-24 08:51:42 +11002784 error = xfs_dir_replace(tp, ip2, &xfs_name_dotdot,
2785 dp1->i_ino, first_block,
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10002786 dfops, spaceres);
Carlos Maiolinod31a1822014-12-24 08:51:42 +11002787 if (error)
Dave Chinnereeacd322015-03-25 14:08:07 +11002788 goto out_trans_abort;
Carlos Maiolinod31a1822014-12-24 08:51:42 +11002789
2790 /* transfer ip2 ".." reference to dp1 */
Dave Chinnerc19b3b052016-02-09 16:54:58 +11002791 if (!S_ISDIR(VFS_I(ip1)->i_mode)) {
Carlos Maiolinod31a1822014-12-24 08:51:42 +11002792 error = xfs_droplink(tp, dp2);
2793 if (error)
Dave Chinnereeacd322015-03-25 14:08:07 +11002794 goto out_trans_abort;
Carlos Maiolinod31a1822014-12-24 08:51:42 +11002795 error = xfs_bumplink(tp, dp1);
2796 if (error)
Dave Chinnereeacd322015-03-25 14:08:07 +11002797 goto out_trans_abort;
Carlos Maiolinod31a1822014-12-24 08:51:42 +11002798 }
2799
2800 /*
2801 * Although ip1 isn't changed here, userspace needs
2802 * to be warned about the change, so that applications
2803 * relying on it (like backup ones), will properly
2804 * notify the change
2805 */
2806 ip1_flags |= XFS_ICHGTIME_CHG;
2807 ip2_flags |= XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG;
2808 }
2809
Dave Chinnerc19b3b052016-02-09 16:54:58 +11002810 if (S_ISDIR(VFS_I(ip1)->i_mode)) {
Carlos Maiolinod31a1822014-12-24 08:51:42 +11002811 error = xfs_dir_replace(tp, ip1, &xfs_name_dotdot,
2812 dp2->i_ino, first_block,
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10002813 dfops, spaceres);
Carlos Maiolinod31a1822014-12-24 08:51:42 +11002814 if (error)
Dave Chinnereeacd322015-03-25 14:08:07 +11002815 goto out_trans_abort;
Carlos Maiolinod31a1822014-12-24 08:51:42 +11002816
2817 /* transfer ip1 ".." reference to dp2 */
Dave Chinnerc19b3b052016-02-09 16:54:58 +11002818 if (!S_ISDIR(VFS_I(ip2)->i_mode)) {
Carlos Maiolinod31a1822014-12-24 08:51:42 +11002819 error = xfs_droplink(tp, dp1);
2820 if (error)
Dave Chinnereeacd322015-03-25 14:08:07 +11002821 goto out_trans_abort;
Carlos Maiolinod31a1822014-12-24 08:51:42 +11002822 error = xfs_bumplink(tp, dp2);
2823 if (error)
Dave Chinnereeacd322015-03-25 14:08:07 +11002824 goto out_trans_abort;
Carlos Maiolinod31a1822014-12-24 08:51:42 +11002825 }
2826
2827 /*
2828 * Although ip2 isn't changed here, userspace needs
2829 * to be warned about the change, so that applications
2830 * relying on it (like backup ones), will properly
2831 * notify the change
2832 */
2833 ip1_flags |= XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG;
2834 ip2_flags |= XFS_ICHGTIME_CHG;
2835 }
2836 }
2837
2838 if (ip1_flags) {
2839 xfs_trans_ichgtime(tp, ip1, ip1_flags);
2840 xfs_trans_log_inode(tp, ip1, XFS_ILOG_CORE);
2841 }
2842 if (ip2_flags) {
2843 xfs_trans_ichgtime(tp, ip2, ip2_flags);
2844 xfs_trans_log_inode(tp, ip2, XFS_ILOG_CORE);
2845 }
2846 if (dp2_flags) {
2847 xfs_trans_ichgtime(tp, dp2, dp2_flags);
2848 xfs_trans_log_inode(tp, dp2, XFS_ILOG_CORE);
2849 }
2850 xfs_trans_ichgtime(tp, dp1, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
2851 xfs_trans_log_inode(tp, dp1, XFS_ILOG_CORE);
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10002852 return xfs_finish_rename(tp, dfops);
Dave Chinnereeacd322015-03-25 14:08:07 +11002853
2854out_trans_abort:
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10002855 xfs_defer_cancel(dfops);
Christoph Hellwig4906e212015-06-04 13:47:56 +10002856 xfs_trans_cancel(tp);
Carlos Maiolinod31a1822014-12-24 08:51:42 +11002857 return error;
2858}
2859
2860/*
Dave Chinner7dcf5c32015-03-25 14:08:08 +11002861 * xfs_rename_alloc_whiteout()
2862 *
2863 * Return a referenced, unlinked, unlocked inode that that can be used as a
2864 * whiteout in a rename transaction. We use a tmpfile inode here so that if we
2865 * crash between allocating the inode and linking it into the rename transaction
2866 * recovery will free the inode and we won't leak it.
2867 */
2868static int
2869xfs_rename_alloc_whiteout(
2870 struct xfs_inode *dp,
2871 struct xfs_inode **wip)
2872{
2873 struct xfs_inode *tmpfile;
2874 int error;
2875
2876 error = xfs_create_tmpfile(dp, NULL, S_IFCHR | WHITEOUT_MODE, &tmpfile);
2877 if (error)
2878 return error;
2879
Brian Foster22419ac2015-05-29 08:14:55 +10002880 /*
2881 * Prepare the tmpfile inode as if it were created through the VFS.
2882 * Otherwise, the link increment paths will complain about nlink 0->1.
2883 * Drop the link count as done by d_tmpfile(), complete the inode setup
2884 * and flag it as linkable.
2885 */
2886 drop_nlink(VFS_I(tmpfile));
Christoph Hellwig2b3d1d42016-04-06 07:48:27 +10002887 xfs_setup_iops(tmpfile);
Dave Chinner7dcf5c32015-03-25 14:08:08 +11002888 xfs_finish_inode_setup(tmpfile);
2889 VFS_I(tmpfile)->i_state |= I_LINKABLE;
2890
2891 *wip = tmpfile;
2892 return 0;
2893}
2894
2895/*
Dave Chinnerf6bba202013-08-12 20:49:46 +10002896 * xfs_rename
2897 */
2898int
2899xfs_rename(
Dave Chinner7dcf5c32015-03-25 14:08:08 +11002900 struct xfs_inode *src_dp,
2901 struct xfs_name *src_name,
2902 struct xfs_inode *src_ip,
2903 struct xfs_inode *target_dp,
2904 struct xfs_name *target_name,
2905 struct xfs_inode *target_ip,
2906 unsigned int flags)
Dave Chinnerf6bba202013-08-12 20:49:46 +10002907{
Dave Chinner7dcf5c32015-03-25 14:08:08 +11002908 struct xfs_mount *mp = src_dp->i_mount;
2909 struct xfs_trans *tp;
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10002910 struct xfs_defer_ops dfops;
Dave Chinner7dcf5c32015-03-25 14:08:08 +11002911 xfs_fsblock_t first_block;
2912 struct xfs_inode *wip = NULL; /* whiteout inode */
2913 struct xfs_inode *inodes[__XFS_SORT_INODES];
2914 int num_inodes = __XFS_SORT_INODES;
Dave Chinner2b936812015-03-25 15:12:30 +11002915 bool new_parent = (src_dp != target_dp);
Dave Chinnerc19b3b052016-02-09 16:54:58 +11002916 bool src_is_directory = S_ISDIR(VFS_I(src_ip)->i_mode);
Dave Chinner7dcf5c32015-03-25 14:08:08 +11002917 int spaceres;
2918 int error;
Dave Chinnerf6bba202013-08-12 20:49:46 +10002919
2920 trace_xfs_rename(src_dp, target_dp, src_name, target_name);
2921
Dave Chinnereeacd322015-03-25 14:08:07 +11002922 if ((flags & RENAME_EXCHANGE) && !target_ip)
2923 return -EINVAL;
Dave Chinnerf6bba202013-08-12 20:49:46 +10002924
Dave Chinner7dcf5c32015-03-25 14:08:08 +11002925 /*
2926 * If we are doing a whiteout operation, allocate the whiteout inode
2927 * we will be placing at the target and ensure the type is set
2928 * appropriately.
2929 */
2930 if (flags & RENAME_WHITEOUT) {
2931 ASSERT(!(flags & (RENAME_NOREPLACE | RENAME_EXCHANGE)));
2932 error = xfs_rename_alloc_whiteout(target_dp, &wip);
2933 if (error)
2934 return error;
Dave Chinnerf6bba202013-08-12 20:49:46 +10002935
Dave Chinner7dcf5c32015-03-25 14:08:08 +11002936 /* setup target dirent info as whiteout */
2937 src_name->type = XFS_DIR3_FT_CHRDEV;
2938 }
2939
2940 xfs_sort_for_rename(src_dp, target_dp, src_ip, target_ip, wip,
Dave Chinnerf6bba202013-08-12 20:49:46 +10002941 inodes, &num_inodes);
2942
Dave Chinnerf6bba202013-08-12 20:49:46 +10002943 spaceres = XFS_RENAME_SPACE_RES(mp, target_name->len);
Christoph Hellwig253f4912016-04-06 09:19:55 +10002944 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_rename, spaceres, 0, 0, &tp);
Dave Chinner24513372014-06-25 14:58:08 +10002945 if (error == -ENOSPC) {
Dave Chinnerf6bba202013-08-12 20:49:46 +10002946 spaceres = 0;
Christoph Hellwig253f4912016-04-06 09:19:55 +10002947 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_rename, 0, 0, 0,
2948 &tp);
Dave Chinnerf6bba202013-08-12 20:49:46 +10002949 }
Dave Chinner445883e2015-03-25 14:05:43 +11002950 if (error)
Christoph Hellwig253f4912016-04-06 09:19:55 +10002951 goto out_release_wip;
Dave Chinnerf6bba202013-08-12 20:49:46 +10002952
2953 /*
2954 * Attach the dquots to the inodes
2955 */
2956 error = xfs_qm_vop_rename_dqattach(inodes);
Dave Chinner445883e2015-03-25 14:05:43 +11002957 if (error)
2958 goto out_trans_cancel;
Dave Chinnerf6bba202013-08-12 20:49:46 +10002959
2960 /*
2961 * Lock all the participating inodes. Depending upon whether
2962 * the target_name exists in the target directory, and
2963 * whether the target directory is the same as the source
2964 * directory, we can lock from 2 to 4 inodes.
2965 */
Dave Chinnerdbad7c92015-08-19 10:33:00 +10002966 if (!new_parent)
2967 xfs_ilock(src_dp, XFS_IOLOCK_EXCL | XFS_IOLOCK_PARENT);
2968 else
2969 xfs_lock_two_inodes(src_dp, target_dp,
2970 XFS_IOLOCK_EXCL | XFS_IOLOCK_PARENT);
2971
Dave Chinnerf6bba202013-08-12 20:49:46 +10002972 xfs_lock_inodes(inodes, num_inodes, XFS_ILOCK_EXCL);
2973
2974 /*
2975 * Join all the inodes to the transaction. From this point on,
2976 * we can rely on either trans_commit or trans_cancel to unlock
2977 * them.
2978 */
Dave Chinnerdbad7c92015-08-19 10:33:00 +10002979 xfs_trans_ijoin(tp, src_dp, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
Dave Chinnerf6bba202013-08-12 20:49:46 +10002980 if (new_parent)
Dave Chinnerdbad7c92015-08-19 10:33:00 +10002981 xfs_trans_ijoin(tp, target_dp, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
Dave Chinnerf6bba202013-08-12 20:49:46 +10002982 xfs_trans_ijoin(tp, src_ip, XFS_ILOCK_EXCL);
2983 if (target_ip)
2984 xfs_trans_ijoin(tp, target_ip, XFS_ILOCK_EXCL);
Dave Chinner7dcf5c32015-03-25 14:08:08 +11002985 if (wip)
2986 xfs_trans_ijoin(tp, wip, XFS_ILOCK_EXCL);
Dave Chinnerf6bba202013-08-12 20:49:46 +10002987
2988 /*
2989 * If we are using project inheritance, we only allow renames
2990 * into our tree when the project IDs are the same; else the
2991 * tree quota mechanism would be circumvented.
2992 */
2993 if (unlikely((target_dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
2994 (xfs_get_projid(target_dp) != xfs_get_projid(src_ip)))) {
Dave Chinner24513372014-06-25 14:58:08 +10002995 error = -EXDEV;
Dave Chinner445883e2015-03-25 14:05:43 +11002996 goto out_trans_cancel;
Dave Chinnerf6bba202013-08-12 20:49:46 +10002997 }
2998
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10002999 xfs_defer_init(&dfops, &first_block);
Dave Chinner445883e2015-03-25 14:05:43 +11003000
Dave Chinnereeacd322015-03-25 14:08:07 +11003001 /* RENAME_EXCHANGE is unique from here on. */
3002 if (flags & RENAME_EXCHANGE)
3003 return xfs_cross_rename(tp, src_dp, src_name, src_ip,
3004 target_dp, target_name, target_ip,
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10003005 &dfops, &first_block, spaceres);
Carlos Maiolinod31a1822014-12-24 08:51:42 +11003006
3007 /*
Dave Chinnerf6bba202013-08-12 20:49:46 +10003008 * Set up the target.
3009 */
3010 if (target_ip == NULL) {
3011 /*
3012 * If there's no space reservation, check the entry will
3013 * fit before actually inserting it.
3014 */
Eric Sandeen94f3cad2014-09-09 11:57:52 +10003015 if (!spaceres) {
3016 error = xfs_dir_canenter(tp, target_dp, target_name);
3017 if (error)
Dave Chinner445883e2015-03-25 14:05:43 +11003018 goto out_trans_cancel;
Eric Sandeen94f3cad2014-09-09 11:57:52 +10003019 }
Dave Chinnerf6bba202013-08-12 20:49:46 +10003020 /*
3021 * If target does not exist and the rename crosses
3022 * directories, adjust the target directory link count
3023 * to account for the ".." reference from the new entry.
3024 */
3025 error = xfs_dir_createname(tp, target_dp, target_name,
3026 src_ip->i_ino, &first_block,
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10003027 &dfops, spaceres);
Dave Chinnerf6bba202013-08-12 20:49:46 +10003028 if (error)
Christoph Hellwig4906e212015-06-04 13:47:56 +10003029 goto out_bmap_cancel;
Dave Chinnerf6bba202013-08-12 20:49:46 +10003030
3031 xfs_trans_ichgtime(tp, target_dp,
3032 XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
3033
3034 if (new_parent && src_is_directory) {
3035 error = xfs_bumplink(tp, target_dp);
3036 if (error)
Christoph Hellwig4906e212015-06-04 13:47:56 +10003037 goto out_bmap_cancel;
Dave Chinnerf6bba202013-08-12 20:49:46 +10003038 }
3039 } else { /* target_ip != NULL */
3040 /*
3041 * If target exists and it's a directory, check that both
3042 * target and source are directories and that target can be
3043 * destroyed, or that neither is a directory.
3044 */
Dave Chinnerc19b3b052016-02-09 16:54:58 +11003045 if (S_ISDIR(VFS_I(target_ip)->i_mode)) {
Dave Chinnerf6bba202013-08-12 20:49:46 +10003046 /*
3047 * Make sure target dir is empty.
3048 */
3049 if (!(xfs_dir_isempty(target_ip)) ||
Dave Chinner54d7b5c2016-02-09 16:54:58 +11003050 (VFS_I(target_ip)->i_nlink > 2)) {
Dave Chinner24513372014-06-25 14:58:08 +10003051 error = -EEXIST;
Dave Chinner445883e2015-03-25 14:05:43 +11003052 goto out_trans_cancel;
Dave Chinnerf6bba202013-08-12 20:49:46 +10003053 }
3054 }
3055
3056 /*
3057 * Link the source inode under the target name.
3058 * If the source inode is a directory and we are moving
3059 * it across directories, its ".." entry will be
3060 * inconsistent until we replace that down below.
3061 *
3062 * In case there is already an entry with the same
3063 * name at the destination directory, remove it first.
3064 */
3065 error = xfs_dir_replace(tp, target_dp, target_name,
3066 src_ip->i_ino,
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10003067 &first_block, &dfops, spaceres);
Dave Chinnerf6bba202013-08-12 20:49:46 +10003068 if (error)
Christoph Hellwig4906e212015-06-04 13:47:56 +10003069 goto out_bmap_cancel;
Dave Chinnerf6bba202013-08-12 20:49:46 +10003070
3071 xfs_trans_ichgtime(tp, target_dp,
3072 XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
3073
3074 /*
3075 * Decrement the link count on the target since the target
3076 * dir no longer points to it.
3077 */
3078 error = xfs_droplink(tp, target_ip);
3079 if (error)
Christoph Hellwig4906e212015-06-04 13:47:56 +10003080 goto out_bmap_cancel;
Dave Chinnerf6bba202013-08-12 20:49:46 +10003081
3082 if (src_is_directory) {
3083 /*
3084 * Drop the link from the old "." entry.
3085 */
3086 error = xfs_droplink(tp, target_ip);
3087 if (error)
Christoph Hellwig4906e212015-06-04 13:47:56 +10003088 goto out_bmap_cancel;
Dave Chinnerf6bba202013-08-12 20:49:46 +10003089 }
3090 } /* target_ip != NULL */
3091
3092 /*
3093 * Remove the source.
3094 */
3095 if (new_parent && src_is_directory) {
3096 /*
3097 * Rewrite the ".." entry to point to the new
3098 * directory.
3099 */
3100 error = xfs_dir_replace(tp, src_ip, &xfs_name_dotdot,
3101 target_dp->i_ino,
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10003102 &first_block, &dfops, spaceres);
Dave Chinner24513372014-06-25 14:58:08 +10003103 ASSERT(error != -EEXIST);
Dave Chinnerf6bba202013-08-12 20:49:46 +10003104 if (error)
Christoph Hellwig4906e212015-06-04 13:47:56 +10003105 goto out_bmap_cancel;
Dave Chinnerf6bba202013-08-12 20:49:46 +10003106 }
3107
3108 /*
3109 * We always want to hit the ctime on the source inode.
3110 *
3111 * This isn't strictly required by the standards since the source
3112 * inode isn't really being changed, but old unix file systems did
3113 * it and some incremental backup programs won't work without it.
3114 */
3115 xfs_trans_ichgtime(tp, src_ip, XFS_ICHGTIME_CHG);
3116 xfs_trans_log_inode(tp, src_ip, XFS_ILOG_CORE);
3117
3118 /*
3119 * Adjust the link count on src_dp. This is necessary when
3120 * renaming a directory, either within one parent when
3121 * the target existed, or across two parent directories.
3122 */
3123 if (src_is_directory && (new_parent || target_ip != NULL)) {
3124
3125 /*
3126 * Decrement link count on src_directory since the
3127 * entry that's moved no longer points to it.
3128 */
3129 error = xfs_droplink(tp, src_dp);
3130 if (error)
Christoph Hellwig4906e212015-06-04 13:47:56 +10003131 goto out_bmap_cancel;
Dave Chinnerf6bba202013-08-12 20:49:46 +10003132 }
3133
Dave Chinner7dcf5c32015-03-25 14:08:08 +11003134 /*
3135 * For whiteouts, we only need to update the source dirent with the
3136 * inode number of the whiteout inode rather than removing it
3137 * altogether.
3138 */
3139 if (wip) {
3140 error = xfs_dir_replace(tp, src_dp, src_name, wip->i_ino,
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10003141 &first_block, &dfops, spaceres);
Dave Chinner7dcf5c32015-03-25 14:08:08 +11003142 } else
3143 error = xfs_dir_removename(tp, src_dp, src_name, src_ip->i_ino,
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10003144 &first_block, &dfops, spaceres);
Dave Chinnerf6bba202013-08-12 20:49:46 +10003145 if (error)
Christoph Hellwig4906e212015-06-04 13:47:56 +10003146 goto out_bmap_cancel;
Dave Chinnerf6bba202013-08-12 20:49:46 +10003147
Dave Chinner7dcf5c32015-03-25 14:08:08 +11003148 /*
3149 * For whiteouts, we need to bump the link count on the whiteout inode.
3150 * This means that failures all the way up to this point leave the inode
3151 * on the unlinked list and so cleanup is a simple matter of dropping
3152 * the remaining reference to it. If we fail here after bumping the link
3153 * count, we're shutting down the filesystem so we'll never see the
3154 * intermediate state on disk.
3155 */
3156 if (wip) {
Dave Chinner54d7b5c2016-02-09 16:54:58 +11003157 ASSERT(VFS_I(wip)->i_nlink == 0);
Dave Chinner7dcf5c32015-03-25 14:08:08 +11003158 error = xfs_bumplink(tp, wip);
3159 if (error)
Christoph Hellwig4906e212015-06-04 13:47:56 +10003160 goto out_bmap_cancel;
Dave Chinner7dcf5c32015-03-25 14:08:08 +11003161 error = xfs_iunlink_remove(tp, wip);
3162 if (error)
Christoph Hellwig4906e212015-06-04 13:47:56 +10003163 goto out_bmap_cancel;
Dave Chinner7dcf5c32015-03-25 14:08:08 +11003164 xfs_trans_log_inode(tp, wip, XFS_ILOG_CORE);
3165
3166 /*
3167 * Now we have a real link, clear the "I'm a tmpfile" state
3168 * flag from the inode so it doesn't accidentally get misused in
3169 * future.
3170 */
3171 VFS_I(wip)->i_state &= ~I_LINKABLE;
3172 }
Dave Chinnerf6bba202013-08-12 20:49:46 +10003173
3174 xfs_trans_ichgtime(tp, src_dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
3175 xfs_trans_log_inode(tp, src_dp, XFS_ILOG_CORE);
3176 if (new_parent)
3177 xfs_trans_log_inode(tp, target_dp, XFS_ILOG_CORE);
3178
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10003179 error = xfs_finish_rename(tp, &dfops);
Dave Chinner7dcf5c32015-03-25 14:08:08 +11003180 if (wip)
3181 IRELE(wip);
3182 return error;
Dave Chinnerf6bba202013-08-12 20:49:46 +10003183
Dave Chinner445883e2015-03-25 14:05:43 +11003184out_bmap_cancel:
Darrick J. Wong2c3234d2016-08-03 11:19:29 +10003185 xfs_defer_cancel(&dfops);
Dave Chinner445883e2015-03-25 14:05:43 +11003186out_trans_cancel:
Christoph Hellwig4906e212015-06-04 13:47:56 +10003187 xfs_trans_cancel(tp);
Christoph Hellwig253f4912016-04-06 09:19:55 +10003188out_release_wip:
Dave Chinner7dcf5c32015-03-25 14:08:08 +11003189 if (wip)
3190 IRELE(wip);
Dave Chinnerf6bba202013-08-12 20:49:46 +10003191 return error;
3192}
3193
David Chinnerbad55842008-03-06 13:43:49 +11003194STATIC int
3195xfs_iflush_cluster(
Dave Chinner19429362016-05-18 14:09:46 +10003196 struct xfs_inode *ip,
3197 struct xfs_buf *bp)
David Chinnerbad55842008-03-06 13:43:49 +11003198{
Dave Chinner19429362016-05-18 14:09:46 +10003199 struct xfs_mount *mp = ip->i_mount;
Dave Chinner5017e972010-01-11 11:47:40 +00003200 struct xfs_perag *pag;
David Chinnerbad55842008-03-06 13:43:49 +11003201 unsigned long first_index, mask;
David Chinnerc8f5f122008-05-20 11:30:15 +10003202 unsigned long inodes_per_cluster;
Dave Chinner19429362016-05-18 14:09:46 +10003203 int cilist_size;
3204 struct xfs_inode **cilist;
3205 struct xfs_inode *cip;
David Chinnerbad55842008-03-06 13:43:49 +11003206 int nr_found;
3207 int clcount = 0;
3208 int bufwasdelwri;
3209 int i;
3210
Dave Chinner5017e972010-01-11 11:47:40 +00003211 pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
David Chinnerbad55842008-03-06 13:43:49 +11003212
Jie Liu0f49efd2013-12-13 15:51:48 +11003213 inodes_per_cluster = mp->m_inode_cluster_size >> mp->m_sb.sb_inodelog;
Dave Chinner19429362016-05-18 14:09:46 +10003214 cilist_size = inodes_per_cluster * sizeof(xfs_inode_t *);
3215 cilist = kmem_alloc(cilist_size, KM_MAYFAIL|KM_NOFS);
3216 if (!cilist)
Dave Chinner44b56e02010-01-11 11:47:43 +00003217 goto out_put;
David Chinnerbad55842008-03-06 13:43:49 +11003218
Jie Liu0f49efd2013-12-13 15:51:48 +11003219 mask = ~(((mp->m_inode_cluster_size >> mp->m_sb.sb_inodelog)) - 1);
David Chinnerbad55842008-03-06 13:43:49 +11003220 first_index = XFS_INO_TO_AGINO(mp, ip->i_ino) & mask;
Dave Chinner1a3e8f32010-12-17 17:29:43 +11003221 rcu_read_lock();
David Chinnerbad55842008-03-06 13:43:49 +11003222 /* really need a gang lookup range call here */
Dave Chinner19429362016-05-18 14:09:46 +10003223 nr_found = radix_tree_gang_lookup(&pag->pag_ici_root, (void**)cilist,
David Chinnerc8f5f122008-05-20 11:30:15 +10003224 first_index, inodes_per_cluster);
David Chinnerbad55842008-03-06 13:43:49 +11003225 if (nr_found == 0)
3226 goto out_free;
3227
3228 for (i = 0; i < nr_found; i++) {
Dave Chinner19429362016-05-18 14:09:46 +10003229 cip = cilist[i];
3230 if (cip == ip)
David Chinnerbad55842008-03-06 13:43:49 +11003231 continue;
Dave Chinner1a3e8f32010-12-17 17:29:43 +11003232
3233 /*
3234 * because this is an RCU protected lookup, we could find a
3235 * recently freed or even reallocated inode during the lookup.
3236 * We need to check under the i_flags_lock for a valid inode
3237 * here. Skip it if it is not valid or the wrong inode.
3238 */
Dave Chinner19429362016-05-18 14:09:46 +10003239 spin_lock(&cip->i_flags_lock);
3240 if (!cip->i_ino ||
3241 __xfs_iflags_test(cip, XFS_ISTALE)) {
3242 spin_unlock(&cip->i_flags_lock);
Dave Chinner1a3e8f32010-12-17 17:29:43 +11003243 continue;
3244 }
Dave Chinner5a90e532016-05-18 14:09:13 +10003245
3246 /*
3247 * Once we fall off the end of the cluster, no point checking
3248 * any more inodes in the list because they will also all be
3249 * outside the cluster.
3250 */
Dave Chinner19429362016-05-18 14:09:46 +10003251 if ((XFS_INO_TO_AGINO(mp, cip->i_ino) & mask) != first_index) {
3252 spin_unlock(&cip->i_flags_lock);
Dave Chinner5a90e532016-05-18 14:09:13 +10003253 break;
3254 }
Dave Chinner19429362016-05-18 14:09:46 +10003255 spin_unlock(&cip->i_flags_lock);
Dave Chinner1a3e8f32010-12-17 17:29:43 +11003256
David Chinnerbad55842008-03-06 13:43:49 +11003257 /*
3258 * Do an un-protected check to see if the inode is dirty and
3259 * is a candidate for flushing. These checks will be repeated
3260 * later after the appropriate locks are acquired.
3261 */
Dave Chinner19429362016-05-18 14:09:46 +10003262 if (xfs_inode_clean(cip) && xfs_ipincount(cip) == 0)
David Chinnerbad55842008-03-06 13:43:49 +11003263 continue;
David Chinnerbad55842008-03-06 13:43:49 +11003264
3265 /*
3266 * Try to get locks. If any are unavailable or it is pinned,
3267 * then this inode cannot be flushed and is skipped.
3268 */
3269
Dave Chinner19429362016-05-18 14:09:46 +10003270 if (!xfs_ilock_nowait(cip, XFS_ILOCK_SHARED))
David Chinnerbad55842008-03-06 13:43:49 +11003271 continue;
Dave Chinner19429362016-05-18 14:09:46 +10003272 if (!xfs_iflock_nowait(cip)) {
3273 xfs_iunlock(cip, XFS_ILOCK_SHARED);
David Chinnerbad55842008-03-06 13:43:49 +11003274 continue;
3275 }
Dave Chinner19429362016-05-18 14:09:46 +10003276 if (xfs_ipincount(cip)) {
3277 xfs_ifunlock(cip);
3278 xfs_iunlock(cip, XFS_ILOCK_SHARED);
David Chinnerbad55842008-03-06 13:43:49 +11003279 continue;
3280 }
3281
Dave Chinner8a17d7d2016-05-18 14:09:12 +10003282
3283 /*
3284 * Check the inode number again, just to be certain we are not
3285 * racing with freeing in xfs_reclaim_inode(). See the comments
3286 * in that function for more information as to why the initial
3287 * check is not sufficient.
3288 */
Dave Chinner19429362016-05-18 14:09:46 +10003289 if (!cip->i_ino) {
3290 xfs_ifunlock(cip);
3291 xfs_iunlock(cip, XFS_ILOCK_SHARED);
David Chinnerbad55842008-03-06 13:43:49 +11003292 continue;
3293 }
3294
3295 /*
3296 * arriving here means that this inode can be flushed. First
3297 * re-check that it's dirty before flushing.
3298 */
Dave Chinner19429362016-05-18 14:09:46 +10003299 if (!xfs_inode_clean(cip)) {
David Chinner33540402008-03-06 13:43:59 +11003300 int error;
Dave Chinner19429362016-05-18 14:09:46 +10003301 error = xfs_iflush_int(cip, bp);
David Chinnerbad55842008-03-06 13:43:49 +11003302 if (error) {
Dave Chinner19429362016-05-18 14:09:46 +10003303 xfs_iunlock(cip, XFS_ILOCK_SHARED);
David Chinnerbad55842008-03-06 13:43:49 +11003304 goto cluster_corrupt_out;
3305 }
3306 clcount++;
3307 } else {
Dave Chinner19429362016-05-18 14:09:46 +10003308 xfs_ifunlock(cip);
David Chinnerbad55842008-03-06 13:43:49 +11003309 }
Dave Chinner19429362016-05-18 14:09:46 +10003310 xfs_iunlock(cip, XFS_ILOCK_SHARED);
David Chinnerbad55842008-03-06 13:43:49 +11003311 }
3312
3313 if (clcount) {
Bill O'Donnellff6d6af2015-10-12 18:21:22 +11003314 XFS_STATS_INC(mp, xs_icluster_flushcnt);
3315 XFS_STATS_ADD(mp, xs_icluster_flushinode, clcount);
David Chinnerbad55842008-03-06 13:43:49 +11003316 }
3317
3318out_free:
Dave Chinner1a3e8f32010-12-17 17:29:43 +11003319 rcu_read_unlock();
Dave Chinner19429362016-05-18 14:09:46 +10003320 kmem_free(cilist);
Dave Chinner44b56e02010-01-11 11:47:43 +00003321out_put:
3322 xfs_perag_put(pag);
David Chinnerbad55842008-03-06 13:43:49 +11003323 return 0;
3324
3325
3326cluster_corrupt_out:
3327 /*
3328 * Corruption detected in the clustering loop. Invalidate the
3329 * inode buffer and shut down the filesystem.
3330 */
Dave Chinner1a3e8f32010-12-17 17:29:43 +11003331 rcu_read_unlock();
David Chinnerbad55842008-03-06 13:43:49 +11003332 /*
Christoph Hellwig43ff2122012-04-23 15:58:39 +10003333 * Clean up the buffer. If it was delwri, just release it --
David Chinnerbad55842008-03-06 13:43:49 +11003334 * brelse can handle it with no problems. If not, shut down the
3335 * filesystem before releasing the buffer.
3336 */
Christoph Hellwig43ff2122012-04-23 15:58:39 +10003337 bufwasdelwri = (bp->b_flags & _XBF_DELWRI_Q);
David Chinnerbad55842008-03-06 13:43:49 +11003338 if (bufwasdelwri)
3339 xfs_buf_relse(bp);
3340
3341 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
3342
3343 if (!bufwasdelwri) {
3344 /*
3345 * Just like incore_relse: if we have b_iodone functions,
3346 * mark the buffer as an error and call them. Otherwise
3347 * mark it as stale and brelse.
3348 */
Christoph Hellwigcb669ca2011-07-13 13:43:49 +02003349 if (bp->b_iodone) {
Dave Chinnerb0388bf2016-02-10 15:01:11 +11003350 bp->b_flags &= ~XBF_DONE;
Christoph Hellwigc867cb62011-10-10 16:52:46 +00003351 xfs_buf_stale(bp);
Dave Chinner24513372014-06-25 14:58:08 +10003352 xfs_buf_ioerror(bp, -EIO);
Dave Chinnere8aaba92014-10-02 09:04:22 +10003353 xfs_buf_ioend(bp);
David Chinnerbad55842008-03-06 13:43:49 +11003354 } else {
Christoph Hellwigc867cb62011-10-10 16:52:46 +00003355 xfs_buf_stale(bp);
David Chinnerbad55842008-03-06 13:43:49 +11003356 xfs_buf_relse(bp);
3357 }
3358 }
3359
3360 /*
3361 * Unlocks the flush lock
3362 */
Dave Chinner19429362016-05-18 14:09:46 +10003363 xfs_iflush_abort(cip, false);
3364 kmem_free(cilist);
Dave Chinner44b56e02010-01-11 11:47:43 +00003365 xfs_perag_put(pag);
Dave Chinner24513372014-06-25 14:58:08 +10003366 return -EFSCORRUPTED;
David Chinnerbad55842008-03-06 13:43:49 +11003367}
3368
Linus Torvalds1da177e2005-04-16 15:20:36 -07003369/*
Christoph Hellwig4c468192012-04-23 15:58:36 +10003370 * Flush dirty inode metadata into the backing buffer.
3371 *
3372 * The caller must have the inode lock and the inode flush lock held. The
3373 * inode lock will still be held upon return to the caller, and the inode
3374 * flush lock will be released after the inode has reached the disk.
3375 *
3376 * The caller must write out the buffer returned in *bpp and release it.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003377 */
3378int
3379xfs_iflush(
Christoph Hellwig4c468192012-04-23 15:58:36 +10003380 struct xfs_inode *ip,
3381 struct xfs_buf **bpp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003382{
Christoph Hellwig4c468192012-04-23 15:58:36 +10003383 struct xfs_mount *mp = ip->i_mount;
Dave Chinnerb1438f42016-05-18 13:53:42 +10003384 struct xfs_buf *bp = NULL;
Christoph Hellwig4c468192012-04-23 15:58:36 +10003385 struct xfs_dinode *dip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003386 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003387
Bill O'Donnellff6d6af2015-10-12 18:21:22 +11003388 XFS_STATS_INC(mp, xs_iflush_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003389
Christoph Hellwig579aa9c2008-04-22 17:34:00 +10003390 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
Christoph Hellwig474fce02011-12-18 20:00:09 +00003391 ASSERT(xfs_isiflocked(ip));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003392 ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE ||
Christoph Hellwig8096b1e2011-12-18 20:00:07 +00003393 ip->i_d.di_nextents > XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003394
Christoph Hellwig4c468192012-04-23 15:58:36 +10003395 *bpp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003396
Linus Torvalds1da177e2005-04-16 15:20:36 -07003397 xfs_iunpin_wait(ip);
3398
3399 /*
Dave Chinner4b6a4682010-01-11 11:45:21 +00003400 * For stale inodes we cannot rely on the backing buffer remaining
3401 * stale in cache for the remaining life of the stale inode and so
Christoph Hellwig475ee412012-07-03 12:21:22 -04003402 * xfs_imap_to_bp() below may give us a buffer that no longer contains
Dave Chinner4b6a4682010-01-11 11:45:21 +00003403 * inodes below. We have to check this after ensuring the inode is
3404 * unpinned so that it is safe to reclaim the stale inode after the
3405 * flush call.
3406 */
3407 if (xfs_iflags_test(ip, XFS_ISTALE)) {
3408 xfs_ifunlock(ip);
3409 return 0;
3410 }
3411
3412 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07003413 * This may have been unpinned because the filesystem is shutting
3414 * down forcibly. If that's the case we must not write this inode
Christoph Hellwig32ce90a2012-04-23 15:58:32 +10003415 * to disk, because the log record didn't make it to disk.
3416 *
3417 * We also have to remove the log item from the AIL in this case,
3418 * as we wait for an empty AIL as part of the unmount process.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003419 */
3420 if (XFS_FORCED_SHUTDOWN(mp)) {
Dave Chinner24513372014-06-25 14:58:08 +10003421 error = -EIO;
Christoph Hellwig32ce90a2012-04-23 15:58:32 +10003422 goto abort_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003423 }
3424
3425 /*
Dave Chinnerb1438f42016-05-18 13:53:42 +10003426 * Get the buffer containing the on-disk inode. We are doing a try-lock
3427 * operation here, so we may get an EAGAIN error. In that case, we
3428 * simply want to return with the inode still dirty.
3429 *
3430 * If we get any other error, we effectively have a corruption situation
3431 * and we cannot flush the inode, so we treat it the same as failing
3432 * xfs_iflush_int().
David Chinnera3f74ff2008-03-06 13:43:42 +11003433 */
Christoph Hellwig475ee412012-07-03 12:21:22 -04003434 error = xfs_imap_to_bp(mp, NULL, &ip->i_imap, &dip, &bp, XBF_TRYLOCK,
3435 0);
Dave Chinnerb1438f42016-05-18 13:53:42 +10003436 if (error == -EAGAIN) {
David Chinnera3f74ff2008-03-06 13:43:42 +11003437 xfs_ifunlock(ip);
3438 return error;
3439 }
Dave Chinnerb1438f42016-05-18 13:53:42 +10003440 if (error)
3441 goto corrupt_out;
David Chinnera3f74ff2008-03-06 13:43:42 +11003442
3443 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07003444 * First flush out the inode that xfs_iflush was called with.
3445 */
3446 error = xfs_iflush_int(ip, bp);
David Chinnerbad55842008-03-06 13:43:49 +11003447 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003448 goto corrupt_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003449
3450 /*
David Chinnera3f74ff2008-03-06 13:43:42 +11003451 * If the buffer is pinned then push on the log now so we won't
3452 * get stuck waiting in the write for too long.
3453 */
Chandra Seetharaman811e64c2011-07-22 23:40:27 +00003454 if (xfs_buf_ispinned(bp))
Christoph Hellwiga14a3482010-01-19 09:56:46 +00003455 xfs_log_force(mp, 0);
David Chinnera3f74ff2008-03-06 13:43:42 +11003456
3457 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07003458 * inode clustering:
3459 * see if other inodes can be gathered into this write
3460 */
David Chinnerbad55842008-03-06 13:43:49 +11003461 error = xfs_iflush_cluster(ip, bp);
3462 if (error)
3463 goto cluster_corrupt_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003464
Christoph Hellwig4c468192012-04-23 15:58:36 +10003465 *bpp = bp;
3466 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003467
3468corrupt_out:
Dave Chinnerb1438f42016-05-18 13:53:42 +10003469 if (bp)
3470 xfs_buf_relse(bp);
Nathan Scott7d04a332006-06-09 14:58:38 +10003471 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003472cluster_corrupt_out:
Dave Chinner24513372014-06-25 14:58:08 +10003473 error = -EFSCORRUPTED;
Christoph Hellwig32ce90a2012-04-23 15:58:32 +10003474abort_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003475 /*
3476 * Unlocks the flush lock
3477 */
Dave Chinner04913fd2012-04-23 15:58:41 +10003478 xfs_iflush_abort(ip, false);
Christoph Hellwig32ce90a2012-04-23 15:58:32 +10003479 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003480}
3481
Linus Torvalds1da177e2005-04-16 15:20:36 -07003482STATIC int
3483xfs_iflush_int(
Christoph Hellwig93848a92013-04-03 16:11:17 +11003484 struct xfs_inode *ip,
3485 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003486{
Christoph Hellwig93848a92013-04-03 16:11:17 +11003487 struct xfs_inode_log_item *iip = ip->i_itemp;
3488 struct xfs_dinode *dip;
3489 struct xfs_mount *mp = ip->i_mount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003490
Christoph Hellwig579aa9c2008-04-22 17:34:00 +10003491 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
Christoph Hellwig474fce02011-12-18 20:00:09 +00003492 ASSERT(xfs_isiflocked(ip));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003493 ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE ||
Christoph Hellwig8096b1e2011-12-18 20:00:07 +00003494 ip->i_d.di_nextents > XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK));
Christoph Hellwig93848a92013-04-03 16:11:17 +11003495 ASSERT(iip != NULL && iip->ili_fields != 0);
Dave Chinner263997a2014-05-20 07:46:40 +10003496 ASSERT(ip->i_d.di_version > 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003497
Linus Torvalds1da177e2005-04-16 15:20:36 -07003498 /* set *dip = inode's place in the buffer */
Christoph Hellwig88ee2df2015-06-22 09:44:29 +10003499 dip = xfs_buf_offset(bp, ip->i_imap.im_boffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003500
Christoph Hellwig69ef9212011-07-08 14:36:05 +02003501 if (XFS_TEST_ERROR(dip->di_magic != cpu_to_be16(XFS_DINODE_MAGIC),
Linus Torvalds1da177e2005-04-16 15:20:36 -07003502 mp, XFS_ERRTAG_IFLUSH_1, XFS_RANDOM_IFLUSH_1)) {
Dave Chinner6a19d932011-03-07 10:02:35 +11003503 xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
3504 "%s: Bad inode %Lu magic number 0x%x, ptr 0x%p",
3505 __func__, ip->i_ino, be16_to_cpu(dip->di_magic), dip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003506 goto corrupt_out;
3507 }
Dave Chinnerc19b3b052016-02-09 16:54:58 +11003508 if (S_ISREG(VFS_I(ip)->i_mode)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003509 if (XFS_TEST_ERROR(
3510 (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS) &&
3511 (ip->i_d.di_format != XFS_DINODE_FMT_BTREE),
3512 mp, XFS_ERRTAG_IFLUSH_3, XFS_RANDOM_IFLUSH_3)) {
Dave Chinner6a19d932011-03-07 10:02:35 +11003513 xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
3514 "%s: Bad regular inode %Lu, ptr 0x%p",
3515 __func__, ip->i_ino, ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003516 goto corrupt_out;
3517 }
Dave Chinnerc19b3b052016-02-09 16:54:58 +11003518 } else if (S_ISDIR(VFS_I(ip)->i_mode)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003519 if (XFS_TEST_ERROR(
3520 (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS) &&
3521 (ip->i_d.di_format != XFS_DINODE_FMT_BTREE) &&
3522 (ip->i_d.di_format != XFS_DINODE_FMT_LOCAL),
3523 mp, XFS_ERRTAG_IFLUSH_4, XFS_RANDOM_IFLUSH_4)) {
Dave Chinner6a19d932011-03-07 10:02:35 +11003524 xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
3525 "%s: Bad directory inode %Lu, ptr 0x%p",
3526 __func__, ip->i_ino, ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003527 goto corrupt_out;
3528 }
3529 }
3530 if (XFS_TEST_ERROR(ip->i_d.di_nextents + ip->i_d.di_anextents >
3531 ip->i_d.di_nblocks, mp, XFS_ERRTAG_IFLUSH_5,
3532 XFS_RANDOM_IFLUSH_5)) {
Dave Chinner6a19d932011-03-07 10:02:35 +11003533 xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
3534 "%s: detected corrupt incore inode %Lu, "
3535 "total extents = %d, nblocks = %Ld, ptr 0x%p",
3536 __func__, ip->i_ino,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003537 ip->i_d.di_nextents + ip->i_d.di_anextents,
Dave Chinner6a19d932011-03-07 10:02:35 +11003538 ip->i_d.di_nblocks, ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003539 goto corrupt_out;
3540 }
3541 if (XFS_TEST_ERROR(ip->i_d.di_forkoff > mp->m_sb.sb_inodesize,
3542 mp, XFS_ERRTAG_IFLUSH_6, XFS_RANDOM_IFLUSH_6)) {
Dave Chinner6a19d932011-03-07 10:02:35 +11003543 xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
3544 "%s: bad inode %Lu, forkoff 0x%x, ptr 0x%p",
3545 __func__, ip->i_ino, ip->i_d.di_forkoff, ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003546 goto corrupt_out;
3547 }
Dave Chinnere60896d2013-07-24 15:47:30 +10003548
Linus Torvalds1da177e2005-04-16 15:20:36 -07003549 /*
Dave Chinner263997a2014-05-20 07:46:40 +10003550 * Inode item log recovery for v2 inodes are dependent on the
Dave Chinnere60896d2013-07-24 15:47:30 +10003551 * di_flushiter count for correct sequencing. We bump the flush
3552 * iteration count so we can detect flushes which postdate a log record
3553 * during recovery. This is redundant as we now log every change and
3554 * hence this can't happen but we need to still do it to ensure
3555 * backwards compatibility with old kernels that predate logging all
3556 * inode changes.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003557 */
Dave Chinnere60896d2013-07-24 15:47:30 +10003558 if (ip->i_d.di_version < 3)
3559 ip->i_d.di_flushiter++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003560
3561 /*
Dave Chinner39878482016-02-09 16:54:58 +11003562 * Copy the dirty parts of the inode into the on-disk inode. We always
3563 * copy out the core of the inode, because if the inode is dirty at all
3564 * the core must be.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003565 */
Dave Chinner93f958f2016-02-09 16:54:58 +11003566 xfs_inode_to_disk(ip, dip, iip->ili_item.li_lsn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003567
3568 /* Wrap, we never let the log put out DI_MAX_FLUSH */
3569 if (ip->i_d.di_flushiter == DI_MAX_FLUSH)
3570 ip->i_d.di_flushiter = 0;
3571
Eric Sandeenfd9fdba2014-04-14 19:04:46 +10003572 xfs_iflush_fork(ip, dip, iip, XFS_DATA_FORK);
David Chinnere4ac9672008-04-10 12:23:58 +10003573 if (XFS_IFORK_Q(ip))
Eric Sandeenfd9fdba2014-04-14 19:04:46 +10003574 xfs_iflush_fork(ip, dip, iip, XFS_ATTR_FORK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003575 xfs_inobp_check(mp, bp);
3576
3577 /*
Christoph Hellwigf5d8d5c2012-02-29 09:53:54 +00003578 * We've recorded everything logged in the inode, so we'd like to clear
3579 * the ili_fields bits so we don't log and flush things unnecessarily.
3580 * However, we can't stop logging all this information until the data
3581 * we've copied into the disk buffer is written to disk. If we did we
3582 * might overwrite the copy of the inode in the log with all the data
3583 * after re-logging only part of it, and in the face of a crash we
3584 * wouldn't have all the data we need to recover.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003585 *
Christoph Hellwigf5d8d5c2012-02-29 09:53:54 +00003586 * What we do is move the bits to the ili_last_fields field. When
3587 * logging the inode, these bits are moved back to the ili_fields field.
3588 * In the xfs_iflush_done() routine we clear ili_last_fields, since we
3589 * know that the information those bits represent is permanently on
3590 * disk. As long as the flush completes before the inode is logged
3591 * again, then both ili_fields and ili_last_fields will be cleared.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003592 *
Christoph Hellwigf5d8d5c2012-02-29 09:53:54 +00003593 * We can play with the ili_fields bits here, because the inode lock
3594 * must be held exclusively in order to set bits there and the flush
3595 * lock protects the ili_last_fields bits. Set ili_logged so the flush
3596 * done routine can tell whether or not to look in the AIL. Also, store
3597 * the current LSN of the inode so that we can tell whether the item has
3598 * moved in the AIL from xfs_iflush_done(). In order to read the lsn we
3599 * need the AIL lock, because it is a 64 bit value that cannot be read
3600 * atomically.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003601 */
Christoph Hellwig93848a92013-04-03 16:11:17 +11003602 iip->ili_last_fields = iip->ili_fields;
3603 iip->ili_fields = 0;
Dave Chinnerfc0561c2015-11-03 13:14:59 +11003604 iip->ili_fsync_fields = 0;
Christoph Hellwig93848a92013-04-03 16:11:17 +11003605 iip->ili_logged = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003606
Christoph Hellwig93848a92013-04-03 16:11:17 +11003607 xfs_trans_ail_copy_lsn(mp->m_ail, &iip->ili_flush_lsn,
3608 &iip->ili_item.li_lsn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003609
Christoph Hellwig93848a92013-04-03 16:11:17 +11003610 /*
3611 * Attach the function xfs_iflush_done to the inode's
3612 * buffer. This will remove the inode from the AIL
3613 * and unlock the inode's flush lock when the inode is
3614 * completely written to disk.
3615 */
3616 xfs_buf_attach_iodone(bp, xfs_iflush_done, &iip->ili_item);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003617
Christoph Hellwig93848a92013-04-03 16:11:17 +11003618 /* generate the checksum. */
3619 xfs_dinode_calc_crc(mp, dip);
3620
3621 ASSERT(bp->b_fspriv != NULL);
3622 ASSERT(bp->b_iodone != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003623 return 0;
3624
3625corrupt_out:
Dave Chinner24513372014-06-25 14:58:08 +10003626 return -EFSCORRUPTED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003627}