blob: fa402a6bbbcf3272ee002700aa85ca118cbbc86e [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_dir2.h"
29#include "xfs_dmapi.h"
30#include "xfs_mount.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include "xfs_bmap_btree.h"
Nathan Scotta844f452005-11-02 14:38:42 +110032#include "xfs_alloc_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include "xfs_ialloc_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include "xfs_dir2_sf.h"
Nathan Scotta844f452005-11-02 14:38:42 +110035#include "xfs_attr_sf.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include "xfs_dinode.h"
37#include "xfs_inode.h"
Nathan Scotta844f452005-11-02 14:38:42 +110038#include "xfs_btree.h"
39#include "xfs_ialloc.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include "xfs_quota.h"
41#include "xfs_utils.h"
David Chinner783a2f62008-10-30 17:39:58 +110042#include "xfs_trans_priv.h"
43#include "xfs_inode_item.h"
Christoph Hellwig24f211b2008-11-28 14:23:42 +110044#include "xfs_bmap.h"
45#include "xfs_btree_trace.h"
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000046#include "xfs_trace.h"
Christoph Hellwig24f211b2008-11-28 14:23:42 +110047
48
49/*
50 * Allocate and initialise an xfs_inode.
51 */
52STATIC struct xfs_inode *
53xfs_inode_alloc(
54 struct xfs_mount *mp,
55 xfs_ino_t ino)
56{
57 struct xfs_inode *ip;
58
59 /*
60 * if this didn't occur in transactions, we could use
61 * KM_MAYFAIL and return NULL here on ENOMEM. Set the
62 * code up to do this anyway.
63 */
64 ip = kmem_zone_alloc(xfs_inode_zone, KM_SLEEP);
65 if (!ip)
66 return NULL;
Christoph Hellwig54e34622009-08-07 14:38:25 -030067 if (inode_init_always(mp->m_super, VFS_I(ip))) {
68 kmem_zone_free(xfs_inode_zone, ip);
69 return NULL;
70 }
Christoph Hellwig24f211b2008-11-28 14:23:42 +110071
72 ASSERT(atomic_read(&ip->i_iocount) == 0);
73 ASSERT(atomic_read(&ip->i_pincount) == 0);
74 ASSERT(!spin_is_locked(&ip->i_flags_lock));
75 ASSERT(completion_done(&ip->i_flush));
Christoph Hellwig033da482009-10-19 04:05:26 +000076 ASSERT(!rwsem_is_locked(&ip->i_iolock.mr_lock));
77
78 mrlock_init(&ip->i_iolock, MRLOCK_BARRIER, "xfsio", ip->i_ino);
Christoph Hellwig24f211b2008-11-28 14:23:42 +110079
Christoph Hellwig24f211b2008-11-28 14:23:42 +110080 /* initialise the xfs inode */
81 ip->i_ino = ino;
82 ip->i_mount = mp;
83 memset(&ip->i_imap, 0, sizeof(struct xfs_imap));
84 ip->i_afp = NULL;
85 memset(&ip->i_df, 0, sizeof(xfs_ifork_t));
86 ip->i_flags = 0;
87 ip->i_update_core = 0;
Christoph Hellwig24f211b2008-11-28 14:23:42 +110088 ip->i_delayed_blks = 0;
89 memset(&ip->i_d, 0, sizeof(xfs_icdinode_t));
90 ip->i_size = 0;
91 ip->i_new_size = 0;
92
Dave Chinner705db3f2009-04-06 18:40:17 +020093 /* prevent anyone from using this yet */
Christoph Hellwigeaff8072009-12-17 14:25:01 +010094 VFS_I(ip)->i_state = I_NEW;
Christoph Hellwig24f211b2008-11-28 14:23:42 +110095
96 return ip;
97}
Linus Torvalds1da177e2005-04-16 15:20:36 -070098
Christoph Hellwigb36ec042009-08-07 14:38:34 -030099STATIC void
100xfs_inode_free(
101 struct xfs_inode *ip)
102{
103 switch (ip->i_d.di_mode & S_IFMT) {
104 case S_IFREG:
105 case S_IFDIR:
106 case S_IFLNK:
107 xfs_idestroy_fork(ip, XFS_DATA_FORK);
108 break;
109 }
110
111 if (ip->i_afp)
112 xfs_idestroy_fork(ip, XFS_ATTR_FORK);
113
Christoph Hellwigb36ec042009-08-07 14:38:34 -0300114 if (ip->i_itemp) {
115 /*
116 * Only if we are shutting down the fs will we see an
117 * inode still in the AIL. If it is there, we should remove
118 * it to prevent a use-after-free from occurring.
119 */
120 xfs_log_item_t *lip = &ip->i_itemp->ili_item;
121 struct xfs_ail *ailp = lip->li_ailp;
122
123 ASSERT(((lip->li_flags & XFS_LI_IN_AIL) == 0) ||
124 XFS_FORCED_SHUTDOWN(ip->i_mount));
125 if (lip->li_flags & XFS_LI_IN_AIL) {
126 spin_lock(&ailp->xa_lock);
127 if (lip->li_flags & XFS_LI_IN_AIL)
128 xfs_trans_ail_delete(ailp, lip);
129 else
130 spin_unlock(&ailp->xa_lock);
131 }
132 xfs_inode_item_destroy(ip);
133 ip->i_itemp = NULL;
134 }
135
136 /* asserts to verify all state is correct here */
137 ASSERT(atomic_read(&ip->i_iocount) == 0);
138 ASSERT(atomic_read(&ip->i_pincount) == 0);
139 ASSERT(!spin_is_locked(&ip->i_flags_lock));
140 ASSERT(completion_done(&ip->i_flush));
141
142 kmem_zone_free(xfs_inode_zone, ip);
143}
144
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145/*
David Chinner6441e542008-10-30 17:21:19 +1100146 * Check the validity of the inode we just found it the cache
147 */
148static int
149xfs_iget_cache_hit(
David Chinner6441e542008-10-30 17:21:19 +1100150 struct xfs_perag *pag,
151 struct xfs_inode *ip,
152 int flags,
153 int lock_flags) __releases(pag->pag_ici_lock)
154{
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400155 struct inode *inode = VFS_I(ip);
David Chinner6441e542008-10-30 17:21:19 +1100156 struct xfs_mount *mp = ip->i_mount;
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400157 int error;
158
159 spin_lock(&ip->i_flags_lock);
David Chinner6441e542008-10-30 17:21:19 +1100160
161 /*
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400162 * If we are racing with another cache hit that is currently
163 * instantiating this inode or currently recycling it out of
164 * reclaimabe state, wait for the initialisation to complete
165 * before continuing.
166 *
167 * XXX(hch): eventually we should do something equivalent to
168 * wait_on_inode to wait for these flags to be cleared
169 * instead of polling for it.
David Chinner6441e542008-10-30 17:21:19 +1100170 */
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400171 if (ip->i_flags & (XFS_INEW|XFS_IRECLAIM)) {
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000172 trace_xfs_iget_skip(ip);
David Chinner6441e542008-10-30 17:21:19 +1100173 XFS_STATS_INC(xs_ig_frecycle);
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400174 error = EAGAIN;
David Chinner6441e542008-10-30 17:21:19 +1100175 goto out_error;
176 }
177
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400178 /*
179 * If lookup is racing with unlink return an error immediately.
180 */
181 if (ip->i_d.di_mode == 0 && !(flags & XFS_IGET_CREATE)) {
182 error = ENOENT;
183 goto out_error;
184 }
David Chinner6441e542008-10-30 17:21:19 +1100185
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400186 /*
187 * If IRECLAIMABLE is set, we've torn down the VFS inode already.
188 * Need to carefully get it back into useable state.
189 */
190 if (ip->i_flags & XFS_IRECLAIMABLE) {
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000191 trace_xfs_iget_reclaim(ip);
David Chinner6441e542008-10-30 17:21:19 +1100192
David Chinnerbf904242008-10-30 17:36:14 +1100193 /*
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400194 * We need to set XFS_INEW atomically with clearing the
195 * reclaimable tag so that we do have an indicator of the
196 * inode still being initialized.
David Chinnerbf904242008-10-30 17:36:14 +1100197 */
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400198 ip->i_flags |= XFS_INEW;
199 ip->i_flags &= ~XFS_IRECLAIMABLE;
200 __xfs_inode_clear_reclaim_tag(mp, pag, ip);
201
202 spin_unlock(&ip->i_flags_lock);
203 read_unlock(&pag->pag_ici_lock);
204
205 error = -inode_init_always(mp->m_super, inode);
206 if (error) {
207 /*
208 * Re-initializing the inode failed, and we are in deep
209 * trouble. Try to re-add it to the reclaim list.
210 */
211 read_lock(&pag->pag_ici_lock);
212 spin_lock(&ip->i_flags_lock);
213
214 ip->i_flags &= ~XFS_INEW;
215 ip->i_flags |= XFS_IRECLAIMABLE;
216 __xfs_inode_set_reclaim_tag(pag, ip);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000217 trace_xfs_iget_reclaim(ip);
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400218 goto out_error;
219 }
Christoph Hellwigeaff8072009-12-17 14:25:01 +0100220 inode->i_state = I_NEW;
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400221 } else {
222 /* If the VFS inode is being torn down, pause and try again. */
223 if (!igrab(inode)) {
224 error = EAGAIN;
David Chinnerbf904242008-10-30 17:36:14 +1100225 goto out_error;
226 }
David Chinner6bfb3d02008-10-30 18:32:43 +1100227
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400228 /* We've got a live one. */
229 spin_unlock(&ip->i_flags_lock);
230 read_unlock(&pag->pag_ici_lock);
David Chinner6441e542008-10-30 17:21:19 +1100231 }
232
David Chinner6441e542008-10-30 17:21:19 +1100233 if (lock_flags != 0)
234 xfs_ilock(ip, lock_flags);
235
236 xfs_iflags_clear(ip, XFS_ISTALE);
David Chinner6441e542008-10-30 17:21:19 +1100237 XFS_STATS_INC(xs_ig_found);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000238
239 trace_xfs_iget_found(ip);
David Chinner6441e542008-10-30 17:21:19 +1100240 return 0;
241
242out_error:
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400243 spin_unlock(&ip->i_flags_lock);
David Chinner6441e542008-10-30 17:21:19 +1100244 read_unlock(&pag->pag_ici_lock);
David Chinner6441e542008-10-30 17:21:19 +1100245 return error;
246}
247
248
249static int
250xfs_iget_cache_miss(
251 struct xfs_mount *mp,
252 struct xfs_perag *pag,
253 xfs_trans_t *tp,
254 xfs_ino_t ino,
255 struct xfs_inode **ipp,
256 xfs_daddr_t bno,
257 int flags,
Christoph Hellwig0c3dc2b2009-11-14 16:17:23 +0000258 int lock_flags)
David Chinner6441e542008-10-30 17:21:19 +1100259{
260 struct xfs_inode *ip;
261 int error;
262 unsigned long first_index, mask;
263 xfs_agino_t agino = XFS_INO_TO_AGINO(mp, ino);
264
Christoph Hellwig24f211b2008-11-28 14:23:42 +1100265 ip = xfs_inode_alloc(mp, ino);
266 if (!ip)
267 return ENOMEM;
268
269 error = xfs_iread(mp, tp, ip, bno, flags);
David Chinner6441e542008-10-30 17:21:19 +1100270 if (error)
Christoph Hellwig24f211b2008-11-28 14:23:42 +1100271 goto out_destroy;
David Chinner6441e542008-10-30 17:21:19 +1100272
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000273 xfs_itrace_entry(ip);
David Chinner6441e542008-10-30 17:21:19 +1100274
275 if ((ip->i_d.di_mode == 0) && !(flags & XFS_IGET_CREATE)) {
276 error = ENOENT;
277 goto out_destroy;
278 }
279
280 /*
281 * Preload the radix tree so we can insert safely under the
David Chinner56e73ec2008-10-30 17:55:27 +1100282 * write spinlock. Note that we cannot sleep inside the preload
283 * region.
David Chinner6441e542008-10-30 17:21:19 +1100284 */
285 if (radix_tree_preload(GFP_KERNEL)) {
286 error = EAGAIN;
Christoph Hellwiged93ec32009-03-03 14:48:35 -0500287 goto out_destroy;
288 }
289
290 /*
291 * Because the inode hasn't been added to the radix-tree yet it can't
292 * be found by another thread, so we can do the non-sleeping lock here.
293 */
294 if (lock_flags) {
295 if (!xfs_ilock_nowait(ip, lock_flags))
296 BUG();
David Chinner6441e542008-10-30 17:21:19 +1100297 }
298
David Chinner6441e542008-10-30 17:21:19 +1100299 mask = ~(((XFS_INODE_CLUSTER_SIZE(mp) >> mp->m_sb.sb_inodelog)) - 1);
300 first_index = agino & mask;
301 write_lock(&pag->pag_ici_lock);
302
303 /* insert the new inode */
304 error = radix_tree_insert(&pag->pag_ici_root, agino, ip);
305 if (unlikely(error)) {
306 WARN_ON(error != -EEXIST);
307 XFS_STATS_INC(xs_ig_dup);
308 error = EAGAIN;
David Chinner56e73ec2008-10-30 17:55:27 +1100309 goto out_preload_end;
David Chinner6441e542008-10-30 17:21:19 +1100310 }
311
312 /* These values _must_ be set before releasing the radix tree lock! */
313 ip->i_udquot = ip->i_gdquot = NULL;
314 xfs_iflags_set(ip, XFS_INEW);
315
316 write_unlock(&pag->pag_ici_lock);
317 radix_tree_preload_end();
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000318
319 trace_xfs_iget_alloc(ip);
David Chinner6441e542008-10-30 17:21:19 +1100320 *ipp = ip;
321 return 0;
322
David Chinner56e73ec2008-10-30 17:55:27 +1100323out_preload_end:
David Chinner6441e542008-10-30 17:21:19 +1100324 write_unlock(&pag->pag_ici_lock);
325 radix_tree_preload_end();
David Chinner56e73ec2008-10-30 17:55:27 +1100326 if (lock_flags)
327 xfs_iunlock(ip, lock_flags);
David Chinner6441e542008-10-30 17:21:19 +1100328out_destroy:
Christoph Hellwigb36ec042009-08-07 14:38:34 -0300329 __destroy_inode(VFS_I(ip));
330 xfs_inode_free(ip);
David Chinner6441e542008-10-30 17:21:19 +1100331 return error;
332}
333
334/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 * Look up an inode by number in the given file system.
David Chinnerda353b02007-08-28 14:00:13 +1000336 * The inode is looked up in the cache held in each AG.
David Chinnerbf904242008-10-30 17:36:14 +1100337 * If the inode is found in the cache, initialise the vfs inode
338 * if necessary.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 *
David Chinnerda353b02007-08-28 14:00:13 +1000340 * If it is not in core, read it in from the file system's device,
David Chinnerbf904242008-10-30 17:36:14 +1100341 * add it to the cache and initialise the vfs inode.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 *
343 * The inode is locked according to the value of the lock_flags parameter.
344 * This flag parameter indicates how and if the inode's IO lock and inode lock
345 * should be taken.
346 *
347 * mp -- the mount point structure for the current file system. It points
348 * to the inode hash table.
349 * tp -- a pointer to the current transaction if there is one. This is
350 * simply passed through to the xfs_iread() call.
351 * ino -- the number of the inode desired. This is the unique identifier
352 * within the file system for the inode being requested.
353 * lock_flags -- flags indicating how to lock the inode. See the comment
354 * for xfs_ilock() for a list of valid values.
355 * bno -- the block number starting the buffer containing the inode,
356 * if known (as by bulkstat), else 0.
357 */
David Chinnerbf904242008-10-30 17:36:14 +1100358int
359xfs_iget(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 xfs_mount_t *mp,
361 xfs_trans_t *tp,
362 xfs_ino_t ino,
363 uint flags,
364 uint lock_flags,
365 xfs_inode_t **ipp,
366 xfs_daddr_t bno)
367{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 xfs_inode_t *ip;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 int error;
David Chinnerda353b02007-08-28 14:00:13 +1000370 xfs_perag_t *pag;
371 xfs_agino_t agino;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372
David Chinnerda353b02007-08-28 14:00:13 +1000373 /* the radix tree exists only in inode capable AGs */
374 if (XFS_INO_TO_AGNO(mp, ino) >= mp->m_maxagi)
375 return EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376
David Chinnerda353b02007-08-28 14:00:13 +1000377 /* get the perag structure and ensure that it's inode capable */
378 pag = xfs_get_perag(mp, ino);
379 if (!pag->pagi_inodeok)
380 return EINVAL;
381 ASSERT(pag->pag_ici_init);
382 agino = XFS_INO_TO_AGINO(mp, ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383
384again:
David Chinner6441e542008-10-30 17:21:19 +1100385 error = 0;
David Chinnerda353b02007-08-28 14:00:13 +1000386 read_lock(&pag->pag_ici_lock);
387 ip = radix_tree_lookup(&pag->pag_ici_root, agino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388
David Chinner6441e542008-10-30 17:21:19 +1100389 if (ip) {
David Chinnerbf904242008-10-30 17:36:14 +1100390 error = xfs_iget_cache_hit(pag, ip, flags, lock_flags);
David Chinner6441e542008-10-30 17:21:19 +1100391 if (error)
392 goto out_error_or_again;
393 } else {
David Chinnerda353b02007-08-28 14:00:13 +1000394 read_unlock(&pag->pag_ici_lock);
David Chinner6441e542008-10-30 17:21:19 +1100395 XFS_STATS_INC(xs_ig_missed);
David Chinnerda353b02007-08-28 14:00:13 +1000396
David Chinner6441e542008-10-30 17:21:19 +1100397 error = xfs_iget_cache_miss(mp, pag, tp, ino, &ip, bno,
398 flags, lock_flags);
399 if (error)
400 goto out_error_or_again;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 }
David Chinnerda353b02007-08-28 14:00:13 +1000402 xfs_put_perag(mp, pag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 *ipp = ip;
405
David Chinnerbf904242008-10-30 17:36:14 +1100406 ASSERT(ip->i_df.if_ext_max ==
407 XFS_IFORK_DSIZE(ip) / sizeof(xfs_bmbt_rec_t));
Christoph Hellwig41be8be2008-08-13 16:23:13 +1000408 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 * If we have a real type for an on-disk inode, we can set ops(&unlock)
410 * now. If it's a new inode being created, xfs_ialloc will handle it.
411 */
David Chinnerbf904242008-10-30 17:36:14 +1100412 if (xfs_iflags_test(ip, XFS_INEW) && ip->i_d.di_mode != 0)
Christoph Hellwig41be8be2008-08-13 16:23:13 +1000413 xfs_setup_inode(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 return 0;
David Chinner6441e542008-10-30 17:21:19 +1100415
416out_error_or_again:
417 if (error == EAGAIN) {
418 delay(1);
419 goto again;
420 }
421 xfs_put_perag(mp, pag);
422 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423}
424
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425/*
426 * Decrement reference count of an inode structure and unlock it.
427 *
428 * ip -- the inode being released
429 * lock_flags -- this parameter indicates the inode's locks to be
430 * to be released. See the comment on xfs_iunlock() for a list
431 * of valid values.
432 */
433void
434xfs_iput(xfs_inode_t *ip,
435 uint lock_flags)
436{
Lachlan McIlroycf441ee2008-02-07 16:42:19 +1100437 xfs_itrace_entry(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 xfs_iunlock(ip, lock_flags);
Christoph Hellwig10090be2007-10-11 18:11:03 +1000439 IRELE(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440}
441
442/*
443 * Special iput for brand-new inodes that are still locked
444 */
445void
David Chinner01651642008-08-13 15:45:15 +1000446xfs_iput_new(
447 xfs_inode_t *ip,
448 uint lock_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449{
David Chinner01651642008-08-13 15:45:15 +1000450 struct inode *inode = VFS_I(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451
Lachlan McIlroycf441ee2008-02-07 16:42:19 +1100452 xfs_itrace_entry(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453
454 if ((ip->i_d.di_mode == 0)) {
David Chinner7a18c382006-11-11 18:04:54 +1100455 ASSERT(!xfs_iflags_test(ip, XFS_IRECLAIMABLE));
Christoph Hellwig10090be2007-10-11 18:11:03 +1000456 make_bad_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 }
458 if (inode->i_state & I_NEW)
459 unlock_new_inode(inode);
460 if (lock_flags)
461 xfs_iunlock(ip, lock_flags);
Christoph Hellwig10090be2007-10-11 18:11:03 +1000462 IRELE(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463}
464
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465/*
Christoph Hellwig5cafdeb2008-12-03 12:20:25 +0100466 * This is called free all the memory associated with an inode.
467 * It must free the inode itself and any buffers allocated for
468 * if_extents/if_data and if_broot. It must also free the lock
469 * associated with the inode.
470 *
471 * Note: because we don't initialise everything on reallocation out
472 * of the zone, we must ensure we nullify everything correctly before
473 * freeing the structure.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 */
475void
Christoph Hellwig5cafdeb2008-12-03 12:20:25 +0100476xfs_ireclaim(
477 struct xfs_inode *ip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478{
Christoph Hellwig5cafdeb2008-12-03 12:20:25 +0100479 struct xfs_mount *mp = ip->i_mount;
480 struct xfs_perag *pag;
Christoph Hellwigb44b1122009-12-01 18:12:29 +0000481 xfs_agino_t agino = XFS_INO_TO_AGINO(mp, ip->i_ino);
Christoph Hellwig5cafdeb2008-12-03 12:20:25 +0100482
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 XFS_STATS_INC(xs_ig_reclaims);
484
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 /*
Christoph Hellwigb44b1122009-12-01 18:12:29 +0000486 * Remove the inode from the per-AG radix tree.
487 *
488 * Because radix_tree_delete won't complain even if the item was never
489 * added to the tree assert that it's been there before to catch
490 * problems with the inode life time early on.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 */
Christoph Hellwig5cafdeb2008-12-03 12:20:25 +0100492 pag = xfs_get_perag(mp, ip->i_ino);
David Chinnerda353b02007-08-28 14:00:13 +1000493 write_lock(&pag->pag_ici_lock);
Christoph Hellwigb44b1122009-12-01 18:12:29 +0000494 if (!radix_tree_delete(&pag->pag_ici_root, agino))
495 ASSERT(0);
David Chinnerda353b02007-08-28 14:00:13 +1000496 write_unlock(&pag->pag_ici_lock);
497 xfs_put_perag(mp, pag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498
Christoph Hellwig5cafdeb2008-12-03 12:20:25 +0100499 /*
500 * Here we do an (almost) spurious inode lock in order to coordinate
501 * with inode cache radix tree lookups. This is because the lookup
502 * can reference the inodes in the cache without taking references.
503 *
504 * We make that OK here by ensuring that we wait until the inode is
505 * unlocked after the lookup before we go ahead and free it. We get
506 * both the ilock and the iolock because the code may need to drop the
507 * ilock one but will still hold the iolock.
508 */
509 xfs_ilock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
Christoph Hellwig7d095252009-06-08 15:33:32 +0200510 xfs_qm_dqdetach(ip);
Christoph Hellwig5cafdeb2008-12-03 12:20:25 +0100511 xfs_iunlock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
512
Christoph Hellwigb36ec042009-08-07 14:38:34 -0300513 xfs_inode_free(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514}
515
516/*
517 * This is a wrapper routine around the xfs_ilock() routine
518 * used to centralize some grungy code. It is used in places
519 * that wish to lock the inode solely for reading the extents.
520 * The reason these places can't just call xfs_ilock(SHARED)
521 * is that the inode lock also guards to bringing in of the
522 * extents from disk for a file in b-tree format. If the inode
523 * is in b-tree format, then we need to lock the inode exclusively
524 * until the extents are read in. Locking it exclusively all
525 * the time would limit our parallelism unnecessarily, though.
526 * What we do instead is check to see if the extents have been
527 * read in yet, and only lock the inode exclusively if they
528 * have not.
529 *
530 * The function returns a value which should be given to the
531 * corresponding xfs_iunlock_map_shared(). This value is
532 * the mode in which the lock was actually taken.
533 */
534uint
535xfs_ilock_map_shared(
536 xfs_inode_t *ip)
537{
538 uint lock_mode;
539
540 if ((ip->i_d.di_format == XFS_DINODE_FMT_BTREE) &&
541 ((ip->i_df.if_flags & XFS_IFEXTENTS) == 0)) {
542 lock_mode = XFS_ILOCK_EXCL;
543 } else {
544 lock_mode = XFS_ILOCK_SHARED;
545 }
546
547 xfs_ilock(ip, lock_mode);
548
549 return lock_mode;
550}
551
552/*
553 * This is simply the unlock routine to go with xfs_ilock_map_shared().
554 * All it does is call xfs_iunlock() with the given lock_mode.
555 */
556void
557xfs_iunlock_map_shared(
558 xfs_inode_t *ip,
559 unsigned int lock_mode)
560{
561 xfs_iunlock(ip, lock_mode);
562}
563
564/*
565 * The xfs inode contains 2 locks: a multi-reader lock called the
566 * i_iolock and a multi-reader lock called the i_lock. This routine
567 * allows either or both of the locks to be obtained.
568 *
569 * The 2 locks should always be ordered so that the IO lock is
570 * obtained first in order to prevent deadlock.
571 *
572 * ip -- the inode being locked
573 * lock_flags -- this parameter indicates the inode's locks
574 * to be locked. It can be:
575 * XFS_IOLOCK_SHARED,
576 * XFS_IOLOCK_EXCL,
577 * XFS_ILOCK_SHARED,
578 * XFS_ILOCK_EXCL,
579 * XFS_IOLOCK_SHARED | XFS_ILOCK_SHARED,
580 * XFS_IOLOCK_SHARED | XFS_ILOCK_EXCL,
581 * XFS_IOLOCK_EXCL | XFS_ILOCK_SHARED,
582 * XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL
583 */
584void
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000585xfs_ilock(
586 xfs_inode_t *ip,
587 uint lock_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588{
589 /*
590 * You can't set both SHARED and EXCL for the same lock,
591 * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
592 * and XFS_ILOCK_EXCL are valid values to set in lock_flags.
593 */
594 ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
595 (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
596 ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
597 (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
Lachlan McIlroyf7c66ce2007-05-08 13:50:19 +1000598 ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_DEP_MASK)) == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000600 if (lock_flags & XFS_IOLOCK_EXCL)
Lachlan McIlroyf7c66ce2007-05-08 13:50:19 +1000601 mrupdate_nested(&ip->i_iolock, XFS_IOLOCK_DEP(lock_flags));
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000602 else if (lock_flags & XFS_IOLOCK_SHARED)
Lachlan McIlroyf7c66ce2007-05-08 13:50:19 +1000603 mraccess_nested(&ip->i_iolock, XFS_IOLOCK_DEP(lock_flags));
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000604
605 if (lock_flags & XFS_ILOCK_EXCL)
Lachlan McIlroyf7c66ce2007-05-08 13:50:19 +1000606 mrupdate_nested(&ip->i_lock, XFS_ILOCK_DEP(lock_flags));
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000607 else if (lock_flags & XFS_ILOCK_SHARED)
Lachlan McIlroyf7c66ce2007-05-08 13:50:19 +1000608 mraccess_nested(&ip->i_lock, XFS_ILOCK_DEP(lock_flags));
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000609
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000610 trace_xfs_ilock(ip, lock_flags, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611}
612
613/*
614 * This is just like xfs_ilock(), except that the caller
615 * is guaranteed not to sleep. It returns 1 if it gets
616 * the requested locks and 0 otherwise. If the IO lock is
617 * obtained but the inode lock cannot be, then the IO lock
618 * is dropped before returning.
619 *
620 * ip -- the inode being locked
621 * lock_flags -- this parameter indicates the inode's locks to be
622 * to be locked. See the comment for xfs_ilock() for a list
623 * of valid values.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 */
625int
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000626xfs_ilock_nowait(
627 xfs_inode_t *ip,
628 uint lock_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 /*
631 * You can't set both SHARED and EXCL for the same lock,
632 * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
633 * and XFS_ILOCK_EXCL are valid values to set in lock_flags.
634 */
635 ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
636 (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
637 ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
638 (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
Lachlan McIlroyf7c66ce2007-05-08 13:50:19 +1000639 ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_DEP_MASK)) == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 if (lock_flags & XFS_IOLOCK_EXCL) {
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000642 if (!mrtryupdate(&ip->i_iolock))
643 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 } else if (lock_flags & XFS_IOLOCK_SHARED) {
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000645 if (!mrtryaccess(&ip->i_iolock))
646 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 }
648 if (lock_flags & XFS_ILOCK_EXCL) {
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000649 if (!mrtryupdate(&ip->i_lock))
650 goto out_undo_iolock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 } else if (lock_flags & XFS_ILOCK_SHARED) {
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000652 if (!mrtryaccess(&ip->i_lock))
653 goto out_undo_iolock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 }
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000655 trace_xfs_ilock_nowait(ip, lock_flags, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 return 1;
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000657
658 out_undo_iolock:
659 if (lock_flags & XFS_IOLOCK_EXCL)
660 mrunlock_excl(&ip->i_iolock);
661 else if (lock_flags & XFS_IOLOCK_SHARED)
662 mrunlock_shared(&ip->i_iolock);
663 out:
664 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665}
666
667/*
668 * xfs_iunlock() is used to drop the inode locks acquired with
669 * xfs_ilock() and xfs_ilock_nowait(). The caller must pass
670 * in the flags given to xfs_ilock() or xfs_ilock_nowait() so
671 * that we know which locks to drop.
672 *
673 * ip -- the inode being unlocked
674 * lock_flags -- this parameter indicates the inode's locks to be
675 * to be unlocked. See the comment for xfs_ilock() for a list
676 * of valid values for this parameter.
677 *
678 */
679void
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000680xfs_iunlock(
681 xfs_inode_t *ip,
682 uint lock_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683{
684 /*
685 * You can't set both SHARED and EXCL for the same lock,
686 * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
687 * and XFS_ILOCK_EXCL are valid values to set in lock_flags.
688 */
689 ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
690 (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
691 ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
692 (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
Lachlan McIlroyf7c66ce2007-05-08 13:50:19 +1000693 ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_IUNLOCK_NONOTIFY |
694 XFS_LOCK_DEP_MASK)) == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 ASSERT(lock_flags != 0);
696
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000697 if (lock_flags & XFS_IOLOCK_EXCL)
698 mrunlock_excl(&ip->i_iolock);
699 else if (lock_flags & XFS_IOLOCK_SHARED)
700 mrunlock_shared(&ip->i_iolock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000702 if (lock_flags & XFS_ILOCK_EXCL)
703 mrunlock_excl(&ip->i_lock);
704 else if (lock_flags & XFS_ILOCK_SHARED)
705 mrunlock_shared(&ip->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000707 if ((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) &&
708 !(lock_flags & XFS_IUNLOCK_NONOTIFY) && ip->i_itemp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 /*
710 * Let the AIL know that this item has been unlocked in case
711 * it is in the AIL and anyone is waiting on it. Don't do
712 * this if the caller has asked us not to.
713 */
David Chinner783a2f62008-10-30 17:39:58 +1100714 xfs_trans_unlocked_item(ip->i_itemp->ili_item.li_ailp,
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000715 (xfs_log_item_t*)(ip->i_itemp));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 }
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000717 trace_xfs_iunlock(ip, lock_flags, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718}
719
720/*
721 * give up write locks. the i/o lock cannot be held nested
722 * if it is being demoted.
723 */
724void
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000725xfs_ilock_demote(
726 xfs_inode_t *ip,
727 uint lock_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728{
729 ASSERT(lock_flags & (XFS_IOLOCK_EXCL|XFS_ILOCK_EXCL));
730 ASSERT((lock_flags & ~(XFS_IOLOCK_EXCL|XFS_ILOCK_EXCL)) == 0);
731
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000732 if (lock_flags & XFS_ILOCK_EXCL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 mrdemote(&ip->i_lock);
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000734 if (lock_flags & XFS_IOLOCK_EXCL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 mrdemote(&ip->i_iolock);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000736
737 trace_xfs_ilock_demote(ip, lock_flags, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738}
739
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000740#ifdef DEBUG
741/*
742 * Debug-only routine, without additional rw_semaphore APIs, we can
743 * now only answer requests regarding whether we hold the lock for write
744 * (reader state is outside our visibility, we only track writer state).
745 *
746 * Note: this means !xfs_isilocked would give false positives, so don't do that.
747 */
748int
749xfs_isilocked(
750 xfs_inode_t *ip,
751 uint lock_flags)
752{
753 if ((lock_flags & (XFS_ILOCK_EXCL|XFS_ILOCK_SHARED)) ==
754 XFS_ILOCK_EXCL) {
755 if (!ip->i_lock.mr_writer)
756 return 0;
757 }
758
759 if ((lock_flags & (XFS_IOLOCK_EXCL|XFS_IOLOCK_SHARED)) ==
760 XFS_IOLOCK_EXCL) {
761 if (!ip->i_iolock.mr_writer)
762 return 0;
763 }
764
765 return 1;
766}
767#endif