blob: 19dcfb2aac9a3e1a371db437554b928251f5ede5 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Nathan Scott7b718762005-11-02 14:58:39 +11002 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
3 * 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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include "xfs.h"
Nathan Scotta844f452005-11-02 14:38:42 +110019#include "xfs_fs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include "xfs_types.h"
Christoph Hellwigef14f0c2009-06-10 17:07:47 +020021#include "xfs_acl.h"
Nathan Scotta844f452005-11-02 14:38:42 +110022#include "xfs_bit.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include "xfs_log.h"
Nathan Scotta844f452005-11-02 14:38:42 +110024#include "xfs_inum.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include "xfs_trans.h"
26#include "xfs_sb.h"
27#include "xfs_ag.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include "xfs_mount.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include "xfs_bmap_btree.h"
Nathan Scotta844f452005-11-02 14:38:42 +110030#include "xfs_alloc_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include "xfs_ialloc_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include "xfs_dinode.h"
33#include "xfs_inode.h"
Nathan Scotta844f452005-11-02 14:38:42 +110034#include "xfs_btree.h"
35#include "xfs_ialloc.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include "xfs_quota.h"
37#include "xfs_utils.h"
David Chinner783a2f62008-10-30 17:39:58 +110038#include "xfs_trans_priv.h"
39#include "xfs_inode_item.h"
Christoph Hellwig24f211b2008-11-28 14:23:42 +110040#include "xfs_bmap.h"
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000041#include "xfs_trace.h"
Christoph Hellwig24f211b2008-11-28 14:23:42 +110042
43
44/*
Dave Chinnerdcfcf202010-12-23 11:57:13 +110045 * Define xfs inode iolock lockdep classes. We need to ensure that all active
46 * inodes are considered the same for lockdep purposes, including inodes that
47 * are recycled through the XFS_IRECLAIMABLE state. This is the the only way to
48 * guarantee the locks are considered the same when there are multiple lock
49 * initialisation siteѕ. Also, define a reclaimable inode class so it is
50 * obvious in lockdep reports which class the report is against.
51 */
52static struct lock_class_key xfs_iolock_active;
53struct lock_class_key xfs_iolock_reclaimable;
54
55/*
Christoph Hellwig24f211b2008-11-28 14:23:42 +110056 * Allocate and initialise an xfs_inode.
57 */
58STATIC struct xfs_inode *
59xfs_inode_alloc(
60 struct xfs_mount *mp,
61 xfs_ino_t ino)
62{
63 struct xfs_inode *ip;
64
65 /*
66 * if this didn't occur in transactions, we could use
67 * KM_MAYFAIL and return NULL here on ENOMEM. Set the
68 * code up to do this anyway.
69 */
70 ip = kmem_zone_alloc(xfs_inode_zone, KM_SLEEP);
71 if (!ip)
72 return NULL;
Christoph Hellwig54e34622009-08-07 14:38:25 -030073 if (inode_init_always(mp->m_super, VFS_I(ip))) {
74 kmem_zone_free(xfs_inode_zone, ip);
75 return NULL;
76 }
Christoph Hellwig24f211b2008-11-28 14:23:42 +110077
Christoph Hellwig24f211b2008-11-28 14:23:42 +110078 ASSERT(atomic_read(&ip->i_pincount) == 0);
79 ASSERT(!spin_is_locked(&ip->i_flags_lock));
Christoph Hellwig474fce02011-12-18 20:00:09 +000080 ASSERT(!xfs_isiflocked(ip));
Dave Chinner1a3e8f32010-12-17 17:29:43 +110081 ASSERT(ip->i_ino == 0);
Christoph Hellwig033da482009-10-19 04:05:26 +000082
83 mrlock_init(&ip->i_iolock, MRLOCK_BARRIER, "xfsio", ip->i_ino);
Dave Chinnerdcfcf202010-12-23 11:57:13 +110084 lockdep_set_class_and_name(&ip->i_iolock.mr_lock,
85 &xfs_iolock_active, "xfs_iolock_active");
Christoph Hellwig24f211b2008-11-28 14:23:42 +110086
Christoph Hellwig24f211b2008-11-28 14:23:42 +110087 /* initialise the xfs inode */
88 ip->i_ino = ino;
89 ip->i_mount = mp;
90 memset(&ip->i_imap, 0, sizeof(struct xfs_imap));
91 ip->i_afp = NULL;
92 memset(&ip->i_df, 0, sizeof(xfs_ifork_t));
93 ip->i_flags = 0;
94 ip->i_update_core = 0;
Christoph Hellwig24f211b2008-11-28 14:23:42 +110095 ip->i_delayed_blks = 0;
96 memset(&ip->i_d, 0, sizeof(xfs_icdinode_t));
Christoph Hellwig24f211b2008-11-28 14:23:42 +110097
Christoph Hellwig24f211b2008-11-28 14:23:42 +110098 return ip;
99}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +1100101STATIC void
102xfs_inode_free_callback(
103 struct rcu_head *head)
104{
105 struct inode *inode = container_of(head, struct inode, i_rcu);
106 struct xfs_inode *ip = XFS_I(inode);
107
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +1100108 kmem_zone_free(xfs_inode_zone, ip);
109}
110
Dave Chinner2f11fea2010-07-20 17:53:25 +1000111void
Christoph Hellwigb36ec042009-08-07 14:38:34 -0300112xfs_inode_free(
113 struct xfs_inode *ip)
114{
115 switch (ip->i_d.di_mode & S_IFMT) {
116 case S_IFREG:
117 case S_IFDIR:
118 case S_IFLNK:
119 xfs_idestroy_fork(ip, XFS_DATA_FORK);
120 break;
121 }
122
123 if (ip->i_afp)
124 xfs_idestroy_fork(ip, XFS_ATTR_FORK);
125
Christoph Hellwigb36ec042009-08-07 14:38:34 -0300126 if (ip->i_itemp) {
127 /*
128 * Only if we are shutting down the fs will we see an
129 * inode still in the AIL. If it is there, we should remove
130 * it to prevent a use-after-free from occurring.
131 */
132 xfs_log_item_t *lip = &ip->i_itemp->ili_item;
133 struct xfs_ail *ailp = lip->li_ailp;
134
135 ASSERT(((lip->li_flags & XFS_LI_IN_AIL) == 0) ||
136 XFS_FORCED_SHUTDOWN(ip->i_mount));
137 if (lip->li_flags & XFS_LI_IN_AIL) {
138 spin_lock(&ailp->xa_lock);
139 if (lip->li_flags & XFS_LI_IN_AIL)
140 xfs_trans_ail_delete(ailp, lip);
141 else
142 spin_unlock(&ailp->xa_lock);
143 }
144 xfs_inode_item_destroy(ip);
145 ip->i_itemp = NULL;
146 }
147
148 /* asserts to verify all state is correct here */
Christoph Hellwigb36ec042009-08-07 14:38:34 -0300149 ASSERT(atomic_read(&ip->i_pincount) == 0);
150 ASSERT(!spin_is_locked(&ip->i_flags_lock));
Christoph Hellwig474fce02011-12-18 20:00:09 +0000151 ASSERT(!xfs_isiflocked(ip));
Christoph Hellwigb36ec042009-08-07 14:38:34 -0300152
Dave Chinner1a3e8f32010-12-17 17:29:43 +1100153 /*
154 * Because we use RCU freeing we need to ensure the inode always
155 * appears to be reclaimed with an invalid inode number when in the
156 * free state. The ip->i_flags_lock provides the barrier against lookup
157 * races.
158 */
159 spin_lock(&ip->i_flags_lock);
160 ip->i_flags = XFS_IRECLAIM;
161 ip->i_ino = 0;
162 spin_unlock(&ip->i_flags_lock);
Alex Elder92f1c002011-01-10 21:35:55 -0600163
164 call_rcu(&VFS_I(ip)->i_rcu, xfs_inode_free_callback);
Christoph Hellwigb36ec042009-08-07 14:38:34 -0300165}
166
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167/*
David Chinner6441e542008-10-30 17:21:19 +1100168 * Check the validity of the inode we just found it the cache
169 */
170static int
171xfs_iget_cache_hit(
David Chinner6441e542008-10-30 17:21:19 +1100172 struct xfs_perag *pag,
173 struct xfs_inode *ip,
Dave Chinner1a3e8f32010-12-17 17:29:43 +1100174 xfs_ino_t ino,
David Chinner6441e542008-10-30 17:21:19 +1100175 int flags,
Dave Chinner1a3e8f32010-12-17 17:29:43 +1100176 int lock_flags) __releases(RCU)
David Chinner6441e542008-10-30 17:21:19 +1100177{
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400178 struct inode *inode = VFS_I(ip);
David Chinner6441e542008-10-30 17:21:19 +1100179 struct xfs_mount *mp = ip->i_mount;
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400180 int error;
181
Dave Chinner1a3e8f32010-12-17 17:29:43 +1100182 /*
183 * check for re-use of an inode within an RCU grace period due to the
184 * radix tree nodes not being updated yet. We monitor for this by
185 * setting the inode number to zero before freeing the inode structure.
186 * If the inode has been reallocated and set up, then the inode number
187 * will not match, so check for that, too.
188 */
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400189 spin_lock(&ip->i_flags_lock);
Dave Chinner1a3e8f32010-12-17 17:29:43 +1100190 if (ip->i_ino != ino) {
191 trace_xfs_iget_skip(ip);
192 XFS_STATS_INC(xs_ig_frecycle);
193 error = EAGAIN;
194 goto out_error;
195 }
196
David Chinner6441e542008-10-30 17:21:19 +1100197
198 /*
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400199 * If we are racing with another cache hit that is currently
200 * instantiating this inode or currently recycling it out of
201 * reclaimabe state, wait for the initialisation to complete
202 * before continuing.
203 *
204 * XXX(hch): eventually we should do something equivalent to
205 * wait_on_inode to wait for these flags to be cleared
206 * instead of polling for it.
David Chinner6441e542008-10-30 17:21:19 +1100207 */
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400208 if (ip->i_flags & (XFS_INEW|XFS_IRECLAIM)) {
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000209 trace_xfs_iget_skip(ip);
David Chinner6441e542008-10-30 17:21:19 +1100210 XFS_STATS_INC(xs_ig_frecycle);
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400211 error = EAGAIN;
David Chinner6441e542008-10-30 17:21:19 +1100212 goto out_error;
213 }
214
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400215 /*
216 * If lookup is racing with unlink return an error immediately.
217 */
218 if (ip->i_d.di_mode == 0 && !(flags & XFS_IGET_CREATE)) {
219 error = ENOENT;
220 goto out_error;
221 }
David Chinner6441e542008-10-30 17:21:19 +1100222
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400223 /*
224 * If IRECLAIMABLE is set, we've torn down the VFS inode already.
225 * Need to carefully get it back into useable state.
226 */
227 if (ip->i_flags & XFS_IRECLAIMABLE) {
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000228 trace_xfs_iget_reclaim(ip);
David Chinner6441e542008-10-30 17:21:19 +1100229
David Chinnerbf904242008-10-30 17:36:14 +1100230 /*
Christoph Hellwigf1f724e2010-03-01 11:30:31 +0000231 * We need to set XFS_IRECLAIM to prevent xfs_reclaim_inode
232 * from stomping over us while we recycle the inode. We can't
233 * clear the radix tree reclaimable tag yet as it requires
234 * pag_ici_lock to be held exclusive.
David Chinnerbf904242008-10-30 17:36:14 +1100235 */
Christoph Hellwigf1f724e2010-03-01 11:30:31 +0000236 ip->i_flags |= XFS_IRECLAIM;
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400237
238 spin_unlock(&ip->i_flags_lock);
Dave Chinner1a3e8f32010-12-17 17:29:43 +1100239 rcu_read_unlock();
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400240
241 error = -inode_init_always(mp->m_super, inode);
242 if (error) {
243 /*
244 * Re-initializing the inode failed, and we are in deep
245 * trouble. Try to re-add it to the reclaim list.
246 */
Dave Chinner1a3e8f32010-12-17 17:29:43 +1100247 rcu_read_lock();
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400248 spin_lock(&ip->i_flags_lock);
249
Dave Chinner778e24b2011-06-23 01:34:59 +0000250 ip->i_flags &= ~(XFS_INEW | XFS_IRECLAIM);
251 ASSERT(ip->i_flags & XFS_IRECLAIMABLE);
Christoph Hellwigd2e078c2010-06-24 11:50:22 +1000252 trace_xfs_iget_reclaim_fail(ip);
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400253 goto out_error;
254 }
Christoph Hellwigf1f724e2010-03-01 11:30:31 +0000255
Dave Chinner1a427ab2010-12-16 17:08:41 +1100256 spin_lock(&pag->pag_ici_lock);
Christoph Hellwigf1f724e2010-03-01 11:30:31 +0000257 spin_lock(&ip->i_flags_lock);
Dave Chinner778e24b2011-06-23 01:34:59 +0000258
259 /*
260 * Clear the per-lifetime state in the inode as we are now
261 * effectively a new inode and need to return to the initial
262 * state before reuse occurs.
263 */
264 ip->i_flags &= ~XFS_IRECLAIM_RESET_FLAGS;
Christoph Hellwigf1f724e2010-03-01 11:30:31 +0000265 ip->i_flags |= XFS_INEW;
266 __xfs_inode_clear_reclaim_tag(mp, pag, ip);
Christoph Hellwigeaff8072009-12-17 14:25:01 +0100267 inode->i_state = I_NEW;
Dave Chinnerdcfcf202010-12-23 11:57:13 +1100268
269 ASSERT(!rwsem_is_locked(&ip->i_iolock.mr_lock));
270 mrlock_init(&ip->i_iolock, MRLOCK_BARRIER, "xfsio", ip->i_ino);
271 lockdep_set_class_and_name(&ip->i_iolock.mr_lock,
272 &xfs_iolock_active, "xfs_iolock_active");
273
Christoph Hellwigf1f724e2010-03-01 11:30:31 +0000274 spin_unlock(&ip->i_flags_lock);
Dave Chinner1a427ab2010-12-16 17:08:41 +1100275 spin_unlock(&pag->pag_ici_lock);
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400276 } else {
277 /* If the VFS inode is being torn down, pause and try again. */
278 if (!igrab(inode)) {
Christoph Hellwigd2e078c2010-06-24 11:50:22 +1000279 trace_xfs_iget_skip(ip);
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400280 error = EAGAIN;
David Chinnerbf904242008-10-30 17:36:14 +1100281 goto out_error;
282 }
David Chinner6bfb3d02008-10-30 18:32:43 +1100283
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400284 /* We've got a live one. */
285 spin_unlock(&ip->i_flags_lock);
Dave Chinner1a3e8f32010-12-17 17:29:43 +1100286 rcu_read_unlock();
Christoph Hellwigd2e078c2010-06-24 11:50:22 +1000287 trace_xfs_iget_hit(ip);
David Chinner6441e542008-10-30 17:21:19 +1100288 }
289
David Chinner6441e542008-10-30 17:21:19 +1100290 if (lock_flags != 0)
291 xfs_ilock(ip, lock_flags);
292
293 xfs_iflags_clear(ip, XFS_ISTALE);
David Chinner6441e542008-10-30 17:21:19 +1100294 XFS_STATS_INC(xs_ig_found);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000295
David Chinner6441e542008-10-30 17:21:19 +1100296 return 0;
297
298out_error:
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400299 spin_unlock(&ip->i_flags_lock);
Dave Chinner1a3e8f32010-12-17 17:29:43 +1100300 rcu_read_unlock();
David Chinner6441e542008-10-30 17:21:19 +1100301 return error;
302}
303
304
305static int
306xfs_iget_cache_miss(
307 struct xfs_mount *mp,
308 struct xfs_perag *pag,
309 xfs_trans_t *tp,
310 xfs_ino_t ino,
311 struct xfs_inode **ipp,
David Chinner6441e542008-10-30 17:21:19 +1100312 int flags,
Christoph Hellwig0c3dc2b2009-11-14 16:17:23 +0000313 int lock_flags)
David Chinner6441e542008-10-30 17:21:19 +1100314{
315 struct xfs_inode *ip;
316 int error;
David Chinner6441e542008-10-30 17:21:19 +1100317 xfs_agino_t agino = XFS_INO_TO_AGINO(mp, ino);
318
Christoph Hellwig24f211b2008-11-28 14:23:42 +1100319 ip = xfs_inode_alloc(mp, ino);
320 if (!ip)
321 return ENOMEM;
322
Dave Chinner7b6259e2010-06-24 11:35:17 +1000323 error = xfs_iread(mp, tp, ip, flags);
David Chinner6441e542008-10-30 17:21:19 +1100324 if (error)
Christoph Hellwig24f211b2008-11-28 14:23:42 +1100325 goto out_destroy;
David Chinner6441e542008-10-30 17:21:19 +1100326
Christoph Hellwigd2e078c2010-06-24 11:50:22 +1000327 trace_xfs_iget_miss(ip);
David Chinner6441e542008-10-30 17:21:19 +1100328
329 if ((ip->i_d.di_mode == 0) && !(flags & XFS_IGET_CREATE)) {
330 error = ENOENT;
331 goto out_destroy;
332 }
333
334 /*
335 * Preload the radix tree so we can insert safely under the
David Chinner56e73ec2008-10-30 17:55:27 +1100336 * write spinlock. Note that we cannot sleep inside the preload
337 * region.
David Chinner6441e542008-10-30 17:21:19 +1100338 */
339 if (radix_tree_preload(GFP_KERNEL)) {
340 error = EAGAIN;
Christoph Hellwiged93ec32009-03-03 14:48:35 -0500341 goto out_destroy;
342 }
343
344 /*
345 * Because the inode hasn't been added to the radix-tree yet it can't
346 * be found by another thread, so we can do the non-sleeping lock here.
347 */
348 if (lock_flags) {
349 if (!xfs_ilock_nowait(ip, lock_flags))
350 BUG();
David Chinner6441e542008-10-30 17:21:19 +1100351 }
352
Dave Chinner1a427ab2010-12-16 17:08:41 +1100353 spin_lock(&pag->pag_ici_lock);
David Chinner6441e542008-10-30 17:21:19 +1100354
355 /* insert the new inode */
356 error = radix_tree_insert(&pag->pag_ici_root, agino, ip);
357 if (unlikely(error)) {
358 WARN_ON(error != -EEXIST);
359 XFS_STATS_INC(xs_ig_dup);
360 error = EAGAIN;
David Chinner56e73ec2008-10-30 17:55:27 +1100361 goto out_preload_end;
David Chinner6441e542008-10-30 17:21:19 +1100362 }
363
364 /* These values _must_ be set before releasing the radix tree lock! */
365 ip->i_udquot = ip->i_gdquot = NULL;
366 xfs_iflags_set(ip, XFS_INEW);
367
Dave Chinner1a427ab2010-12-16 17:08:41 +1100368 spin_unlock(&pag->pag_ici_lock);
David Chinner6441e542008-10-30 17:21:19 +1100369 radix_tree_preload_end();
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000370
David Chinner6441e542008-10-30 17:21:19 +1100371 *ipp = ip;
372 return 0;
373
David Chinner56e73ec2008-10-30 17:55:27 +1100374out_preload_end:
Dave Chinner1a427ab2010-12-16 17:08:41 +1100375 spin_unlock(&pag->pag_ici_lock);
David Chinner6441e542008-10-30 17:21:19 +1100376 radix_tree_preload_end();
David Chinner56e73ec2008-10-30 17:55:27 +1100377 if (lock_flags)
378 xfs_iunlock(ip, lock_flags);
David Chinner6441e542008-10-30 17:21:19 +1100379out_destroy:
Christoph Hellwigb36ec042009-08-07 14:38:34 -0300380 __destroy_inode(VFS_I(ip));
381 xfs_inode_free(ip);
David Chinner6441e542008-10-30 17:21:19 +1100382 return error;
383}
384
385/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 * Look up an inode by number in the given file system.
David Chinnerda353b02007-08-28 14:00:13 +1000387 * The inode is looked up in the cache held in each AG.
David Chinnerbf904242008-10-30 17:36:14 +1100388 * If the inode is found in the cache, initialise the vfs inode
389 * if necessary.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 *
David Chinnerda353b02007-08-28 14:00:13 +1000391 * If it is not in core, read it in from the file system's device,
David Chinnerbf904242008-10-30 17:36:14 +1100392 * add it to the cache and initialise the vfs inode.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 *
394 * The inode is locked according to the value of the lock_flags parameter.
395 * This flag parameter indicates how and if the inode's IO lock and inode lock
396 * should be taken.
397 *
398 * mp -- the mount point structure for the current file system. It points
399 * to the inode hash table.
400 * tp -- a pointer to the current transaction if there is one. This is
401 * simply passed through to the xfs_iread() call.
402 * ino -- the number of the inode desired. This is the unique identifier
403 * within the file system for the inode being requested.
404 * lock_flags -- flags indicating how to lock the inode. See the comment
405 * for xfs_ilock() for a list of valid values.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 */
David Chinnerbf904242008-10-30 17:36:14 +1100407int
408xfs_iget(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 xfs_mount_t *mp,
410 xfs_trans_t *tp,
411 xfs_ino_t ino,
412 uint flags,
413 uint lock_flags,
Dave Chinner7b6259e2010-06-24 11:35:17 +1000414 xfs_inode_t **ipp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 xfs_inode_t *ip;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 int error;
David Chinnerda353b02007-08-28 14:00:13 +1000418 xfs_perag_t *pag;
419 xfs_agino_t agino;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420
Christoph Hellwigd2767342010-10-06 18:31:23 +0000421 /* reject inode numbers outside existing AGs */
Dave Chinner1a3e8f32010-12-17 17:29:43 +1100422 if (!ino || XFS_INO_TO_AGNO(mp, ino) >= mp->m_sb.sb_agcount)
David Chinnerda353b02007-08-28 14:00:13 +1000423 return EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424
David Chinnerda353b02007-08-28 14:00:13 +1000425 /* get the perag structure and ensure that it's inode capable */
Dave Chinner5017e972010-01-11 11:47:40 +0000426 pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ino));
David Chinnerda353b02007-08-28 14:00:13 +1000427 agino = XFS_INO_TO_AGINO(mp, ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428
429again:
David Chinner6441e542008-10-30 17:21:19 +1100430 error = 0;
Dave Chinner1a3e8f32010-12-17 17:29:43 +1100431 rcu_read_lock();
David Chinnerda353b02007-08-28 14:00:13 +1000432 ip = radix_tree_lookup(&pag->pag_ici_root, agino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433
David Chinner6441e542008-10-30 17:21:19 +1100434 if (ip) {
Dave Chinner1a3e8f32010-12-17 17:29:43 +1100435 error = xfs_iget_cache_hit(pag, ip, ino, flags, lock_flags);
David Chinner6441e542008-10-30 17:21:19 +1100436 if (error)
437 goto out_error_or_again;
438 } else {
Dave Chinner1a3e8f32010-12-17 17:29:43 +1100439 rcu_read_unlock();
David Chinner6441e542008-10-30 17:21:19 +1100440 XFS_STATS_INC(xs_ig_missed);
David Chinnerda353b02007-08-28 14:00:13 +1000441
Dave Chinner7b6259e2010-06-24 11:35:17 +1000442 error = xfs_iget_cache_miss(mp, pag, tp, ino, &ip,
David Chinner6441e542008-10-30 17:21:19 +1100443 flags, lock_flags);
444 if (error)
445 goto out_error_or_again;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 }
Dave Chinner5017e972010-01-11 11:47:40 +0000447 xfs_perag_put(pag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 *ipp = ip;
450
Christoph Hellwig41be8be2008-08-13 16:23:13 +1000451 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 * If we have a real type for an on-disk inode, we can set ops(&unlock)
453 * now. If it's a new inode being created, xfs_ialloc will handle it.
454 */
David Chinnerbf904242008-10-30 17:36:14 +1100455 if (xfs_iflags_test(ip, XFS_INEW) && ip->i_d.di_mode != 0)
Christoph Hellwig41be8be2008-08-13 16:23:13 +1000456 xfs_setup_inode(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 return 0;
David Chinner6441e542008-10-30 17:21:19 +1100458
459out_error_or_again:
460 if (error == EAGAIN) {
461 delay(1);
462 goto again;
463 }
Dave Chinner5017e972010-01-11 11:47:40 +0000464 xfs_perag_put(pag);
David Chinner6441e542008-10-30 17:21:19 +1100465 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466}
467
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 * This is a wrapper routine around the xfs_ilock() routine
470 * used to centralize some grungy code. It is used in places
471 * that wish to lock the inode solely for reading the extents.
472 * The reason these places can't just call xfs_ilock(SHARED)
473 * is that the inode lock also guards to bringing in of the
474 * extents from disk for a file in b-tree format. If the inode
475 * is in b-tree format, then we need to lock the inode exclusively
476 * until the extents are read in. Locking it exclusively all
477 * the time would limit our parallelism unnecessarily, though.
478 * What we do instead is check to see if the extents have been
479 * read in yet, and only lock the inode exclusively if they
480 * have not.
481 *
482 * The function returns a value which should be given to the
483 * corresponding xfs_iunlock_map_shared(). This value is
484 * the mode in which the lock was actually taken.
485 */
486uint
487xfs_ilock_map_shared(
488 xfs_inode_t *ip)
489{
490 uint lock_mode;
491
492 if ((ip->i_d.di_format == XFS_DINODE_FMT_BTREE) &&
493 ((ip->i_df.if_flags & XFS_IFEXTENTS) == 0)) {
494 lock_mode = XFS_ILOCK_EXCL;
495 } else {
496 lock_mode = XFS_ILOCK_SHARED;
497 }
498
499 xfs_ilock(ip, lock_mode);
500
501 return lock_mode;
502}
503
504/*
505 * This is simply the unlock routine to go with xfs_ilock_map_shared().
506 * All it does is call xfs_iunlock() with the given lock_mode.
507 */
508void
509xfs_iunlock_map_shared(
510 xfs_inode_t *ip,
511 unsigned int lock_mode)
512{
513 xfs_iunlock(ip, lock_mode);
514}
515
516/*
517 * The xfs inode contains 2 locks: a multi-reader lock called the
518 * i_iolock and a multi-reader lock called the i_lock. This routine
519 * allows either or both of the locks to be obtained.
520 *
521 * The 2 locks should always be ordered so that the IO lock is
522 * obtained first in order to prevent deadlock.
523 *
524 * ip -- the inode being locked
525 * lock_flags -- this parameter indicates the inode's locks
526 * to be locked. It can be:
527 * XFS_IOLOCK_SHARED,
528 * XFS_IOLOCK_EXCL,
529 * XFS_ILOCK_SHARED,
530 * XFS_ILOCK_EXCL,
531 * XFS_IOLOCK_SHARED | XFS_ILOCK_SHARED,
532 * XFS_IOLOCK_SHARED | XFS_ILOCK_EXCL,
533 * XFS_IOLOCK_EXCL | XFS_ILOCK_SHARED,
534 * XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL
535 */
536void
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000537xfs_ilock(
538 xfs_inode_t *ip,
539 uint lock_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540{
541 /*
542 * You can't set both SHARED and EXCL for the same lock,
543 * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
544 * and XFS_ILOCK_EXCL are valid values to set in lock_flags.
545 */
546 ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
547 (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
548 ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
549 (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
Lachlan McIlroyf7c66ce2007-05-08 13:50:19 +1000550 ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_DEP_MASK)) == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000552 if (lock_flags & XFS_IOLOCK_EXCL)
Lachlan McIlroyf7c66ce2007-05-08 13:50:19 +1000553 mrupdate_nested(&ip->i_iolock, XFS_IOLOCK_DEP(lock_flags));
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000554 else if (lock_flags & XFS_IOLOCK_SHARED)
Lachlan McIlroyf7c66ce2007-05-08 13:50:19 +1000555 mraccess_nested(&ip->i_iolock, XFS_IOLOCK_DEP(lock_flags));
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000556
557 if (lock_flags & XFS_ILOCK_EXCL)
Lachlan McIlroyf7c66ce2007-05-08 13:50:19 +1000558 mrupdate_nested(&ip->i_lock, XFS_ILOCK_DEP(lock_flags));
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000559 else if (lock_flags & XFS_ILOCK_SHARED)
Lachlan McIlroyf7c66ce2007-05-08 13:50:19 +1000560 mraccess_nested(&ip->i_lock, XFS_ILOCK_DEP(lock_flags));
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000561
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000562 trace_xfs_ilock(ip, lock_flags, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563}
564
565/*
566 * This is just like xfs_ilock(), except that the caller
567 * is guaranteed not to sleep. It returns 1 if it gets
568 * the requested locks and 0 otherwise. If the IO lock is
569 * obtained but the inode lock cannot be, then the IO lock
570 * is dropped before returning.
571 *
572 * ip -- the inode being locked
573 * lock_flags -- this parameter indicates the inode's locks to be
574 * to be locked. See the comment for xfs_ilock() for a list
575 * of valid values.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 */
577int
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000578xfs_ilock_nowait(
579 xfs_inode_t *ip,
580 uint lock_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 /*
583 * You can't set both SHARED and EXCL for the same lock,
584 * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
585 * and XFS_ILOCK_EXCL are valid values to set in lock_flags.
586 */
587 ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
588 (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
589 ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
590 (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
Lachlan McIlroyf7c66ce2007-05-08 13:50:19 +1000591 ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_DEP_MASK)) == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 if (lock_flags & XFS_IOLOCK_EXCL) {
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000594 if (!mrtryupdate(&ip->i_iolock))
595 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 } else if (lock_flags & XFS_IOLOCK_SHARED) {
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000597 if (!mrtryaccess(&ip->i_iolock))
598 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 }
600 if (lock_flags & XFS_ILOCK_EXCL) {
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000601 if (!mrtryupdate(&ip->i_lock))
602 goto out_undo_iolock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 } else if (lock_flags & XFS_ILOCK_SHARED) {
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000604 if (!mrtryaccess(&ip->i_lock))
605 goto out_undo_iolock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 }
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000607 trace_xfs_ilock_nowait(ip, lock_flags, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 return 1;
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000609
610 out_undo_iolock:
611 if (lock_flags & XFS_IOLOCK_EXCL)
612 mrunlock_excl(&ip->i_iolock);
613 else if (lock_flags & XFS_IOLOCK_SHARED)
614 mrunlock_shared(&ip->i_iolock);
615 out:
616 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617}
618
619/*
620 * xfs_iunlock() is used to drop the inode locks acquired with
621 * xfs_ilock() and xfs_ilock_nowait(). The caller must pass
622 * in the flags given to xfs_ilock() or xfs_ilock_nowait() so
623 * that we know which locks to drop.
624 *
625 * ip -- the inode being unlocked
626 * lock_flags -- this parameter indicates the inode's locks to be
627 * to be unlocked. See the comment for xfs_ilock() for a list
628 * of valid values for this parameter.
629 *
630 */
631void
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000632xfs_iunlock(
633 xfs_inode_t *ip,
634 uint lock_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635{
636 /*
637 * You can't set both SHARED and EXCL for the same lock,
638 * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
639 * and XFS_ILOCK_EXCL are valid values to set in lock_flags.
640 */
641 ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
642 (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
643 ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
644 (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
Christoph Hellwig5b03ff12012-02-20 02:31:22 +0000645 ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_DEP_MASK)) == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 ASSERT(lock_flags != 0);
647
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000648 if (lock_flags & XFS_IOLOCK_EXCL)
649 mrunlock_excl(&ip->i_iolock);
650 else if (lock_flags & XFS_IOLOCK_SHARED)
651 mrunlock_shared(&ip->i_iolock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000653 if (lock_flags & XFS_ILOCK_EXCL)
654 mrunlock_excl(&ip->i_lock);
655 else if (lock_flags & XFS_ILOCK_SHARED)
656 mrunlock_shared(&ip->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000658 trace_xfs_iunlock(ip, lock_flags, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659}
660
661/*
662 * give up write locks. the i/o lock cannot be held nested
663 * if it is being demoted.
664 */
665void
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000666xfs_ilock_demote(
667 xfs_inode_t *ip,
668 uint lock_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669{
670 ASSERT(lock_flags & (XFS_IOLOCK_EXCL|XFS_ILOCK_EXCL));
671 ASSERT((lock_flags & ~(XFS_IOLOCK_EXCL|XFS_ILOCK_EXCL)) == 0);
672
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000673 if (lock_flags & XFS_ILOCK_EXCL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 mrdemote(&ip->i_lock);
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000675 if (lock_flags & XFS_IOLOCK_EXCL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 mrdemote(&ip->i_iolock);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000677
678 trace_xfs_ilock_demote(ip, lock_flags, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679}
680
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000681#ifdef DEBUG
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000682int
683xfs_isilocked(
684 xfs_inode_t *ip,
685 uint lock_flags)
686{
Christoph Hellwigf9369722010-06-03 16:22:29 +1000687 if (lock_flags & (XFS_ILOCK_EXCL|XFS_ILOCK_SHARED)) {
688 if (!(lock_flags & XFS_ILOCK_SHARED))
689 return !!ip->i_lock.mr_writer;
690 return rwsem_is_locked(&ip->i_lock.mr_lock);
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000691 }
692
Christoph Hellwigf9369722010-06-03 16:22:29 +1000693 if (lock_flags & (XFS_IOLOCK_EXCL|XFS_IOLOCK_SHARED)) {
694 if (!(lock_flags & XFS_IOLOCK_SHARED))
695 return !!ip->i_iolock.mr_writer;
696 return rwsem_is_locked(&ip->i_iolock.mr_lock);
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000697 }
698
Christoph Hellwigf9369722010-06-03 16:22:29 +1000699 ASSERT(0);
700 return 0;
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000701}
702#endif
Christoph Hellwig474fce02011-12-18 20:00:09 +0000703
704void
705__xfs_iflock(
706 struct xfs_inode *ip)
707{
708 wait_queue_head_t *wq = bit_waitqueue(&ip->i_flags, __XFS_IFLOCK_BIT);
709 DEFINE_WAIT_BIT(wait, &ip->i_flags, __XFS_IFLOCK_BIT);
710
711 do {
712 prepare_to_wait_exclusive(wq, &wait.wait, TASK_UNINTERRUPTIBLE);
713 if (xfs_isiflocked(ip))
714 io_schedule();
715 } while (!xfs_iflock_nowait(ip));
716
717 finish_wait(wq, &wait.wait);
718}