blob: 0a326bd64d4e39b3b197437cf6e964bffb4cca0a [file] [log] [blame]
David Chinnerfe4fa4b2008-10-30 17:06:08 +11001/*
2 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
3 * All Rights Reserved.
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18#include "xfs.h"
19#include "xfs_fs.h"
Dave Chinner6ca1c902013-08-12 20:49:26 +100020#include "xfs_format.h"
Dave Chinner239880e2013-10-23 10:50:10 +110021#include "xfs_log_format.h"
22#include "xfs_trans_resv.h"
David Chinnerfe4fa4b2008-10-30 17:06:08 +110023#include "xfs_sb.h"
David Chinnerfe4fa4b2008-10-30 17:06:08 +110024#include "xfs_mount.h"
David Chinnerfe4fa4b2008-10-30 17:06:08 +110025#include "xfs_inode.h"
David Chinnerfe4fa4b2008-10-30 17:06:08 +110026#include "xfs_error.h"
Dave Chinner239880e2013-10-23 10:50:10 +110027#include "xfs_trans.h"
28#include "xfs_trans_priv.h"
David Chinnerfe4fa4b2008-10-30 17:06:08 +110029#include "xfs_inode_item.h"
Christoph Hellwig7d095252009-06-08 15:33:32 +020030#include "xfs_quota.h"
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000031#include "xfs_trace.h"
Dave Chinner6d8b79c2012-10-08 21:56:09 +110032#include "xfs_icache.h"
Dave Chinnerc24b5df2013-08-12 20:49:45 +100033#include "xfs_bmap_util.h"
Brian Fosterdc06f3982014-07-24 19:49:28 +100034#include "xfs_dquot_item.h"
35#include "xfs_dquot.h"
David Chinnerfe4fa4b2008-10-30 17:06:08 +110036
David Chinnera167b172008-10-30 17:06:18 +110037#include <linux/kthread.h>
38#include <linux/freezer.h>
39
Dave Chinner33479e02012-10-08 21:56:11 +110040STATIC void __xfs_inode_clear_reclaim_tag(struct xfs_mount *mp,
41 struct xfs_perag *pag, struct xfs_inode *ip);
42
43/*
44 * Allocate and initialise an xfs_inode.
45 */
Dave Chinner638f44162013-08-30 10:23:45 +100046struct xfs_inode *
Dave Chinner33479e02012-10-08 21:56:11 +110047xfs_inode_alloc(
48 struct xfs_mount *mp,
49 xfs_ino_t ino)
50{
51 struct xfs_inode *ip;
52
53 /*
54 * if this didn't occur in transactions, we could use
55 * KM_MAYFAIL and return NULL here on ENOMEM. Set the
56 * code up to do this anyway.
57 */
58 ip = kmem_zone_alloc(xfs_inode_zone, KM_SLEEP);
59 if (!ip)
60 return NULL;
61 if (inode_init_always(mp->m_super, VFS_I(ip))) {
62 kmem_zone_free(xfs_inode_zone, ip);
63 return NULL;
64 }
65
Dave Chinnercdc9cec2014-12-04 09:42:40 +110066 XFS_STATS_INC(vn_active);
Dave Chinner33479e02012-10-08 21:56:11 +110067 ASSERT(atomic_read(&ip->i_pincount) == 0);
68 ASSERT(!spin_is_locked(&ip->i_flags_lock));
69 ASSERT(!xfs_isiflocked(ip));
70 ASSERT(ip->i_ino == 0);
71
72 mrlock_init(&ip->i_iolock, MRLOCK_BARRIER, "xfsio", ip->i_ino);
73
74 /* initialise the xfs inode */
75 ip->i_ino = ino;
76 ip->i_mount = mp;
77 memset(&ip->i_imap, 0, sizeof(struct xfs_imap));
78 ip->i_afp = NULL;
79 memset(&ip->i_df, 0, sizeof(xfs_ifork_t));
80 ip->i_flags = 0;
81 ip->i_delayed_blks = 0;
82 memset(&ip->i_d, 0, sizeof(xfs_icdinode_t));
83
84 return ip;
85}
86
87STATIC void
88xfs_inode_free_callback(
89 struct rcu_head *head)
90{
91 struct inode *inode = container_of(head, struct inode, i_rcu);
92 struct xfs_inode *ip = XFS_I(inode);
93
94 kmem_zone_free(xfs_inode_zone, ip);
95}
96
Dave Chinner638f44162013-08-30 10:23:45 +100097void
Dave Chinner33479e02012-10-08 21:56:11 +110098xfs_inode_free(
99 struct xfs_inode *ip)
100{
101 switch (ip->i_d.di_mode & S_IFMT) {
102 case S_IFREG:
103 case S_IFDIR:
104 case S_IFLNK:
105 xfs_idestroy_fork(ip, XFS_DATA_FORK);
106 break;
107 }
108
109 if (ip->i_afp)
110 xfs_idestroy_fork(ip, XFS_ATTR_FORK);
111
112 if (ip->i_itemp) {
113 ASSERT(!(ip->i_itemp->ili_item.li_flags & XFS_LI_IN_AIL));
114 xfs_inode_item_destroy(ip);
115 ip->i_itemp = NULL;
116 }
117
Dave Chinner33479e02012-10-08 21:56:11 +1100118 /*
119 * Because we use RCU freeing we need to ensure the inode always
120 * appears to be reclaimed with an invalid inode number when in the
121 * free state. The ip->i_flags_lock provides the barrier against lookup
122 * races.
123 */
124 spin_lock(&ip->i_flags_lock);
125 ip->i_flags = XFS_IRECLAIM;
126 ip->i_ino = 0;
127 spin_unlock(&ip->i_flags_lock);
128
Dave Chinnerb313a5f2013-09-24 16:01:14 +1000129 /* asserts to verify all state is correct here */
130 ASSERT(atomic_read(&ip->i_pincount) == 0);
131 ASSERT(!xfs_isiflocked(ip));
Dave Chinnercdc9cec2014-12-04 09:42:40 +1100132 XFS_STATS_DEC(vn_active);
Dave Chinnerb313a5f2013-09-24 16:01:14 +1000133
Dave Chinner33479e02012-10-08 21:56:11 +1100134 call_rcu(&VFS_I(ip)->i_rcu, xfs_inode_free_callback);
135}
136
137/*
138 * Check the validity of the inode we just found it the cache
139 */
140static int
141xfs_iget_cache_hit(
142 struct xfs_perag *pag,
143 struct xfs_inode *ip,
144 xfs_ino_t ino,
145 int flags,
146 int lock_flags) __releases(RCU)
147{
148 struct inode *inode = VFS_I(ip);
149 struct xfs_mount *mp = ip->i_mount;
150 int error;
151
152 /*
153 * check for re-use of an inode within an RCU grace period due to the
154 * radix tree nodes not being updated yet. We monitor for this by
155 * setting the inode number to zero before freeing the inode structure.
156 * If the inode has been reallocated and set up, then the inode number
157 * will not match, so check for that, too.
158 */
159 spin_lock(&ip->i_flags_lock);
160 if (ip->i_ino != ino) {
161 trace_xfs_iget_skip(ip);
162 XFS_STATS_INC(xs_ig_frecycle);
Dave Chinner24513372014-06-25 14:58:08 +1000163 error = -EAGAIN;
Dave Chinner33479e02012-10-08 21:56:11 +1100164 goto out_error;
165 }
166
167
168 /*
169 * If we are racing with another cache hit that is currently
170 * instantiating this inode or currently recycling it out of
171 * reclaimabe state, wait for the initialisation to complete
172 * before continuing.
173 *
174 * XXX(hch): eventually we should do something equivalent to
175 * wait_on_inode to wait for these flags to be cleared
176 * instead of polling for it.
177 */
178 if (ip->i_flags & (XFS_INEW|XFS_IRECLAIM)) {
179 trace_xfs_iget_skip(ip);
180 XFS_STATS_INC(xs_ig_frecycle);
Dave Chinner24513372014-06-25 14:58:08 +1000181 error = -EAGAIN;
Dave Chinner33479e02012-10-08 21:56:11 +1100182 goto out_error;
183 }
184
185 /*
186 * If lookup is racing with unlink return an error immediately.
187 */
188 if (ip->i_d.di_mode == 0 && !(flags & XFS_IGET_CREATE)) {
Dave Chinner24513372014-06-25 14:58:08 +1000189 error = -ENOENT;
Dave Chinner33479e02012-10-08 21:56:11 +1100190 goto out_error;
191 }
192
193 /*
194 * If IRECLAIMABLE is set, we've torn down the VFS inode already.
195 * Need to carefully get it back into useable state.
196 */
197 if (ip->i_flags & XFS_IRECLAIMABLE) {
198 trace_xfs_iget_reclaim(ip);
199
200 /*
201 * We need to set XFS_IRECLAIM to prevent xfs_reclaim_inode
202 * from stomping over us while we recycle the inode. We can't
203 * clear the radix tree reclaimable tag yet as it requires
204 * pag_ici_lock to be held exclusive.
205 */
206 ip->i_flags |= XFS_IRECLAIM;
207
208 spin_unlock(&ip->i_flags_lock);
209 rcu_read_unlock();
210
Dave Chinner24513372014-06-25 14:58:08 +1000211 error = inode_init_always(mp->m_super, inode);
Dave Chinner33479e02012-10-08 21:56:11 +1100212 if (error) {
213 /*
214 * Re-initializing the inode failed, and we are in deep
215 * trouble. Try to re-add it to the reclaim list.
216 */
217 rcu_read_lock();
218 spin_lock(&ip->i_flags_lock);
219
220 ip->i_flags &= ~(XFS_INEW | XFS_IRECLAIM);
221 ASSERT(ip->i_flags & XFS_IRECLAIMABLE);
222 trace_xfs_iget_reclaim_fail(ip);
223 goto out_error;
224 }
225
226 spin_lock(&pag->pag_ici_lock);
227 spin_lock(&ip->i_flags_lock);
228
229 /*
230 * Clear the per-lifetime state in the inode as we are now
231 * effectively a new inode and need to return to the initial
232 * state before reuse occurs.
233 */
234 ip->i_flags &= ~XFS_IRECLAIM_RESET_FLAGS;
235 ip->i_flags |= XFS_INEW;
236 __xfs_inode_clear_reclaim_tag(mp, pag, ip);
237 inode->i_state = I_NEW;
238
239 ASSERT(!rwsem_is_locked(&ip->i_iolock.mr_lock));
240 mrlock_init(&ip->i_iolock, MRLOCK_BARRIER, "xfsio", ip->i_ino);
241
242 spin_unlock(&ip->i_flags_lock);
243 spin_unlock(&pag->pag_ici_lock);
244 } else {
245 /* If the VFS inode is being torn down, pause and try again. */
246 if (!igrab(inode)) {
247 trace_xfs_iget_skip(ip);
Dave Chinner24513372014-06-25 14:58:08 +1000248 error = -EAGAIN;
Dave Chinner33479e02012-10-08 21:56:11 +1100249 goto out_error;
250 }
251
252 /* We've got a live one. */
253 spin_unlock(&ip->i_flags_lock);
254 rcu_read_unlock();
255 trace_xfs_iget_hit(ip);
256 }
257
258 if (lock_flags != 0)
259 xfs_ilock(ip, lock_flags);
260
261 xfs_iflags_clear(ip, XFS_ISTALE | XFS_IDONTCACHE);
262 XFS_STATS_INC(xs_ig_found);
263
264 return 0;
265
266out_error:
267 spin_unlock(&ip->i_flags_lock);
268 rcu_read_unlock();
269 return error;
270}
271
272
273static int
274xfs_iget_cache_miss(
275 struct xfs_mount *mp,
276 struct xfs_perag *pag,
277 xfs_trans_t *tp,
278 xfs_ino_t ino,
279 struct xfs_inode **ipp,
280 int flags,
281 int lock_flags)
282{
283 struct xfs_inode *ip;
284 int error;
285 xfs_agino_t agino = XFS_INO_TO_AGINO(mp, ino);
286 int iflags;
287
288 ip = xfs_inode_alloc(mp, ino);
289 if (!ip)
Dave Chinner24513372014-06-25 14:58:08 +1000290 return -ENOMEM;
Dave Chinner33479e02012-10-08 21:56:11 +1100291
292 error = xfs_iread(mp, tp, ip, flags);
293 if (error)
294 goto out_destroy;
295
296 trace_xfs_iget_miss(ip);
297
298 if ((ip->i_d.di_mode == 0) && !(flags & XFS_IGET_CREATE)) {
Dave Chinner24513372014-06-25 14:58:08 +1000299 error = -ENOENT;
Dave Chinner33479e02012-10-08 21:56:11 +1100300 goto out_destroy;
301 }
302
303 /*
304 * Preload the radix tree so we can insert safely under the
305 * write spinlock. Note that we cannot sleep inside the preload
306 * region. Since we can be called from transaction context, don't
307 * recurse into the file system.
308 */
309 if (radix_tree_preload(GFP_NOFS)) {
Dave Chinner24513372014-06-25 14:58:08 +1000310 error = -EAGAIN;
Dave Chinner33479e02012-10-08 21:56:11 +1100311 goto out_destroy;
312 }
313
314 /*
315 * Because the inode hasn't been added to the radix-tree yet it can't
316 * be found by another thread, so we can do the non-sleeping lock here.
317 */
318 if (lock_flags) {
319 if (!xfs_ilock_nowait(ip, lock_flags))
320 BUG();
321 }
322
323 /*
324 * These values must be set before inserting the inode into the radix
325 * tree as the moment it is inserted a concurrent lookup (allowed by the
326 * RCU locking mechanism) can find it and that lookup must see that this
327 * is an inode currently under construction (i.e. that XFS_INEW is set).
328 * The ip->i_flags_lock that protects the XFS_INEW flag forms the
329 * memory barrier that ensures this detection works correctly at lookup
330 * time.
331 */
332 iflags = XFS_INEW;
333 if (flags & XFS_IGET_DONTCACHE)
334 iflags |= XFS_IDONTCACHE;
Chandra Seetharaman113a5682013-06-27 17:25:07 -0500335 ip->i_udquot = NULL;
336 ip->i_gdquot = NULL;
Chandra Seetharaman92f8ff72013-07-11 00:00:40 -0500337 ip->i_pdquot = NULL;
Dave Chinner33479e02012-10-08 21:56:11 +1100338 xfs_iflags_set(ip, iflags);
339
340 /* insert the new inode */
341 spin_lock(&pag->pag_ici_lock);
342 error = radix_tree_insert(&pag->pag_ici_root, agino, ip);
343 if (unlikely(error)) {
344 WARN_ON(error != -EEXIST);
345 XFS_STATS_INC(xs_ig_dup);
Dave Chinner24513372014-06-25 14:58:08 +1000346 error = -EAGAIN;
Dave Chinner33479e02012-10-08 21:56:11 +1100347 goto out_preload_end;
348 }
349 spin_unlock(&pag->pag_ici_lock);
350 radix_tree_preload_end();
351
352 *ipp = ip;
353 return 0;
354
355out_preload_end:
356 spin_unlock(&pag->pag_ici_lock);
357 radix_tree_preload_end();
358 if (lock_flags)
359 xfs_iunlock(ip, lock_flags);
360out_destroy:
361 __destroy_inode(VFS_I(ip));
362 xfs_inode_free(ip);
363 return error;
364}
365
366/*
367 * Look up an inode by number in the given file system.
368 * The inode is looked up in the cache held in each AG.
369 * If the inode is found in the cache, initialise the vfs inode
370 * if necessary.
371 *
372 * If it is not in core, read it in from the file system's device,
373 * add it to the cache and initialise the vfs inode.
374 *
375 * The inode is locked according to the value of the lock_flags parameter.
376 * This flag parameter indicates how and if the inode's IO lock and inode lock
377 * should be taken.
378 *
379 * mp -- the mount point structure for the current file system. It points
380 * to the inode hash table.
381 * tp -- a pointer to the current transaction if there is one. This is
382 * simply passed through to the xfs_iread() call.
383 * ino -- the number of the inode desired. This is the unique identifier
384 * within the file system for the inode being requested.
385 * lock_flags -- flags indicating how to lock the inode. See the comment
386 * for xfs_ilock() for a list of valid values.
387 */
388int
389xfs_iget(
390 xfs_mount_t *mp,
391 xfs_trans_t *tp,
392 xfs_ino_t ino,
393 uint flags,
394 uint lock_flags,
395 xfs_inode_t **ipp)
396{
397 xfs_inode_t *ip;
398 int error;
399 xfs_perag_t *pag;
400 xfs_agino_t agino;
401
402 /*
403 * xfs_reclaim_inode() uses the ILOCK to ensure an inode
404 * doesn't get freed while it's being referenced during a
405 * radix tree traversal here. It assumes this function
406 * aqcuires only the ILOCK (and therefore it has no need to
407 * involve the IOLOCK in this synchronization).
408 */
409 ASSERT((lock_flags & (XFS_IOLOCK_EXCL | XFS_IOLOCK_SHARED)) == 0);
410
411 /* reject inode numbers outside existing AGs */
412 if (!ino || XFS_INO_TO_AGNO(mp, ino) >= mp->m_sb.sb_agcount)
Dave Chinner24513372014-06-25 14:58:08 +1000413 return -EINVAL;
Dave Chinner33479e02012-10-08 21:56:11 +1100414
Lucas Stach8774cf82015-08-28 14:50:56 +1000415 XFS_STATS_INC(xs_ig_attempts);
416
Dave Chinner33479e02012-10-08 21:56:11 +1100417 /* get the perag structure and ensure that it's inode capable */
418 pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ino));
419 agino = XFS_INO_TO_AGINO(mp, ino);
420
421again:
422 error = 0;
423 rcu_read_lock();
424 ip = radix_tree_lookup(&pag->pag_ici_root, agino);
425
426 if (ip) {
427 error = xfs_iget_cache_hit(pag, ip, ino, flags, lock_flags);
428 if (error)
429 goto out_error_or_again;
430 } else {
431 rcu_read_unlock();
432 XFS_STATS_INC(xs_ig_missed);
433
434 error = xfs_iget_cache_miss(mp, pag, tp, ino, &ip,
435 flags, lock_flags);
436 if (error)
437 goto out_error_or_again;
438 }
439 xfs_perag_put(pag);
440
441 *ipp = ip;
442
443 /*
Dave Chinner58c90472015-02-23 22:38:08 +1100444 * If we have a real type for an on-disk inode, we can setup the inode
Dave Chinner33479e02012-10-08 21:56:11 +1100445 * now. If it's a new inode being created, xfs_ialloc will handle it.
446 */
447 if (xfs_iflags_test(ip, XFS_INEW) && ip->i_d.di_mode != 0)
Dave Chinner58c90472015-02-23 22:38:08 +1100448 xfs_setup_existing_inode(ip);
Dave Chinner33479e02012-10-08 21:56:11 +1100449 return 0;
450
451out_error_or_again:
Dave Chinner24513372014-06-25 14:58:08 +1000452 if (error == -EAGAIN) {
Dave Chinner33479e02012-10-08 21:56:11 +1100453 delay(1);
454 goto again;
455 }
456 xfs_perag_put(pag);
457 return error;
458}
459
Dave Chinner78ae5252010-09-28 12:28:19 +1000460/*
461 * The inode lookup is done in batches to keep the amount of lock traffic and
462 * radix tree lookups to a minimum. The batch size is a trade off between
463 * lookup reduction and stack usage. This is in the reclaim path, so we can't
464 * be too greedy.
465 */
466#define XFS_LOOKUP_BATCH 32
467
Dave Chinnere13de952010-09-28 12:28:06 +1000468STATIC int
469xfs_inode_ag_walk_grab(
470 struct xfs_inode *ip)
471{
472 struct inode *inode = VFS_I(ip);
473
Dave Chinner1a3e8f32010-12-17 17:29:43 +1100474 ASSERT(rcu_read_lock_held());
475
476 /*
477 * check for stale RCU freed inode
478 *
479 * If the inode has been reallocated, it doesn't matter if it's not in
480 * the AG we are walking - we are walking for writeback, so if it
481 * passes all the "valid inode" checks and is dirty, then we'll write
482 * it back anyway. If it has been reallocated and still being
483 * initialised, the XFS_INEW check below will catch it.
484 */
485 spin_lock(&ip->i_flags_lock);
486 if (!ip->i_ino)
487 goto out_unlock_noent;
488
489 /* avoid new or reclaimable inodes. Leave for reclaim code to flush */
490 if (__xfs_iflags_test(ip, XFS_INEW | XFS_IRECLAIMABLE | XFS_IRECLAIM))
491 goto out_unlock_noent;
492 spin_unlock(&ip->i_flags_lock);
493
Dave Chinnere13de952010-09-28 12:28:06 +1000494 /* nothing to sync during shutdown */
495 if (XFS_FORCED_SHUTDOWN(ip->i_mount))
Dave Chinner24513372014-06-25 14:58:08 +1000496 return -EFSCORRUPTED;
Dave Chinnere13de952010-09-28 12:28:06 +1000497
Dave Chinnere13de952010-09-28 12:28:06 +1000498 /* If we can't grab the inode, it must on it's way to reclaim. */
499 if (!igrab(inode))
Dave Chinner24513372014-06-25 14:58:08 +1000500 return -ENOENT;
Dave Chinnere13de952010-09-28 12:28:06 +1000501
Dave Chinnere13de952010-09-28 12:28:06 +1000502 /* inode is valid */
503 return 0;
Dave Chinner1a3e8f32010-12-17 17:29:43 +1100504
505out_unlock_noent:
506 spin_unlock(&ip->i_flags_lock);
Dave Chinner24513372014-06-25 14:58:08 +1000507 return -ENOENT;
Dave Chinnere13de952010-09-28 12:28:06 +1000508}
509
Dave Chinner75f3cb12009-06-08 15:35:14 +0200510STATIC int
511xfs_inode_ag_walk(
512 struct xfs_mount *mp,
Dave Chinner5017e972010-01-11 11:47:40 +0000513 struct xfs_perag *pag,
Eric Sandeene0094002014-04-14 19:04:19 +1000514 int (*execute)(struct xfs_inode *ip, int flags,
Brian Fostera454f742012-11-06 09:50:39 -0500515 void *args),
516 int flags,
517 void *args,
518 int tag)
Dave Chinner75f3cb12009-06-08 15:35:14 +0200519{
Dave Chinner75f3cb12009-06-08 15:35:14 +0200520 uint32_t first_index;
521 int last_error = 0;
522 int skipped;
Dave Chinner65d0f202010-09-24 18:40:15 +1000523 int done;
Dave Chinner78ae5252010-09-28 12:28:19 +1000524 int nr_found;
Dave Chinner75f3cb12009-06-08 15:35:14 +0200525
526restart:
Dave Chinner65d0f202010-09-24 18:40:15 +1000527 done = 0;
Dave Chinner75f3cb12009-06-08 15:35:14 +0200528 skipped = 0;
529 first_index = 0;
Dave Chinner78ae5252010-09-28 12:28:19 +1000530 nr_found = 0;
Dave Chinner75f3cb12009-06-08 15:35:14 +0200531 do {
Dave Chinner78ae5252010-09-28 12:28:19 +1000532 struct xfs_inode *batch[XFS_LOOKUP_BATCH];
Dave Chinner75f3cb12009-06-08 15:35:14 +0200533 int error = 0;
Dave Chinner78ae5252010-09-28 12:28:19 +1000534 int i;
Dave Chinner75f3cb12009-06-08 15:35:14 +0200535
Dave Chinner1a3e8f32010-12-17 17:29:43 +1100536 rcu_read_lock();
Brian Fostera454f742012-11-06 09:50:39 -0500537
538 if (tag == -1)
539 nr_found = radix_tree_gang_lookup(&pag->pag_ici_root,
Dave Chinner78ae5252010-09-28 12:28:19 +1000540 (void **)batch, first_index,
541 XFS_LOOKUP_BATCH);
Brian Fostera454f742012-11-06 09:50:39 -0500542 else
543 nr_found = radix_tree_gang_lookup_tag(
544 &pag->pag_ici_root,
545 (void **) batch, first_index,
546 XFS_LOOKUP_BATCH, tag);
547
Dave Chinner65d0f202010-09-24 18:40:15 +1000548 if (!nr_found) {
Dave Chinner1a3e8f32010-12-17 17:29:43 +1100549 rcu_read_unlock();
Dave Chinner75f3cb12009-06-08 15:35:14 +0200550 break;
Dave Chinnerc8e20be2010-01-10 23:51:45 +0000551 }
Dave Chinner75f3cb12009-06-08 15:35:14 +0200552
Dave Chinner65d0f202010-09-24 18:40:15 +1000553 /*
Dave Chinner78ae5252010-09-28 12:28:19 +1000554 * Grab the inodes before we drop the lock. if we found
555 * nothing, nr == 0 and the loop will be skipped.
Dave Chinner65d0f202010-09-24 18:40:15 +1000556 */
Dave Chinner78ae5252010-09-28 12:28:19 +1000557 for (i = 0; i < nr_found; i++) {
558 struct xfs_inode *ip = batch[i];
Dave Chinner65d0f202010-09-24 18:40:15 +1000559
Dave Chinner78ae5252010-09-28 12:28:19 +1000560 if (done || xfs_inode_ag_walk_grab(ip))
561 batch[i] = NULL;
562
563 /*
Dave Chinner1a3e8f32010-12-17 17:29:43 +1100564 * Update the index for the next lookup. Catch
565 * overflows into the next AG range which can occur if
566 * we have inodes in the last block of the AG and we
567 * are currently pointing to the last inode.
568 *
569 * Because we may see inodes that are from the wrong AG
570 * due to RCU freeing and reallocation, only update the
571 * index if it lies in this AG. It was a race that lead
572 * us to see this inode, so another lookup from the
573 * same index will not find it again.
Dave Chinner78ae5252010-09-28 12:28:19 +1000574 */
Dave Chinner1a3e8f32010-12-17 17:29:43 +1100575 if (XFS_INO_TO_AGNO(mp, ip->i_ino) != pag->pag_agno)
576 continue;
Dave Chinner78ae5252010-09-28 12:28:19 +1000577 first_index = XFS_INO_TO_AGINO(mp, ip->i_ino + 1);
578 if (first_index < XFS_INO_TO_AGINO(mp, ip->i_ino))
579 done = 1;
Dave Chinnere13de952010-09-28 12:28:06 +1000580 }
Dave Chinner78ae5252010-09-28 12:28:19 +1000581
582 /* unlock now we've grabbed the inodes. */
Dave Chinner1a3e8f32010-12-17 17:29:43 +1100583 rcu_read_unlock();
Dave Chinnere13de952010-09-28 12:28:06 +1000584
Dave Chinner78ae5252010-09-28 12:28:19 +1000585 for (i = 0; i < nr_found; i++) {
586 if (!batch[i])
587 continue;
Eric Sandeene0094002014-04-14 19:04:19 +1000588 error = execute(batch[i], flags, args);
Dave Chinner78ae5252010-09-28 12:28:19 +1000589 IRELE(batch[i]);
Dave Chinner24513372014-06-25 14:58:08 +1000590 if (error == -EAGAIN) {
Dave Chinner78ae5252010-09-28 12:28:19 +1000591 skipped++;
592 continue;
593 }
Dave Chinner24513372014-06-25 14:58:08 +1000594 if (error && last_error != -EFSCORRUPTED)
Dave Chinner78ae5252010-09-28 12:28:19 +1000595 last_error = error;
Dave Chinner75f3cb12009-06-08 15:35:14 +0200596 }
Dave Chinnerc8e20be2010-01-10 23:51:45 +0000597
598 /* bail out if the filesystem is corrupted. */
Dave Chinner24513372014-06-25 14:58:08 +1000599 if (error == -EFSCORRUPTED)
Dave Chinner75f3cb12009-06-08 15:35:14 +0200600 break;
601
Dave Chinner8daaa832011-07-08 14:14:46 +1000602 cond_resched();
603
Dave Chinner78ae5252010-09-28 12:28:19 +1000604 } while (nr_found && !done);
Dave Chinner75f3cb12009-06-08 15:35:14 +0200605
606 if (skipped) {
607 delay(1);
608 goto restart;
609 }
Dave Chinner75f3cb12009-06-08 15:35:14 +0200610 return last_error;
611}
612
Brian Foster579b62f2012-11-06 09:50:47 -0500613/*
614 * Background scanning to trim post-EOF preallocated space. This is queued
Dwight Engenb9fe5052013-08-15 14:08:02 -0400615 * based on the 'speculative_prealloc_lifetime' tunable (5m by default).
Brian Foster579b62f2012-11-06 09:50:47 -0500616 */
617STATIC void
618xfs_queue_eofblocks(
619 struct xfs_mount *mp)
620{
621 rcu_read_lock();
622 if (radix_tree_tagged(&mp->m_perag_tree, XFS_ICI_EOFBLOCKS_TAG))
623 queue_delayed_work(mp->m_eofblocks_workqueue,
624 &mp->m_eofblocks_work,
625 msecs_to_jiffies(xfs_eofb_secs * 1000));
626 rcu_read_unlock();
627}
628
629void
630xfs_eofblocks_worker(
631 struct work_struct *work)
632{
633 struct xfs_mount *mp = container_of(to_delayed_work(work),
634 struct xfs_mount, m_eofblocks_work);
635 xfs_icache_free_eofblocks(mp, NULL);
636 xfs_queue_eofblocks(mp);
637}
638
Christoph Hellwigfe588ed2009-06-08 15:35:27 +0200639int
Dave Chinner75f3cb12009-06-08 15:35:14 +0200640xfs_inode_ag_iterator(
641 struct xfs_mount *mp,
Eric Sandeene0094002014-04-14 19:04:19 +1000642 int (*execute)(struct xfs_inode *ip, int flags,
Brian Fostera454f742012-11-06 09:50:39 -0500643 void *args),
644 int flags,
645 void *args)
Dave Chinner75f3cb12009-06-08 15:35:14 +0200646{
Dave Chinner16fd5362010-07-20 09:43:39 +1000647 struct xfs_perag *pag;
Dave Chinner75f3cb12009-06-08 15:35:14 +0200648 int error = 0;
649 int last_error = 0;
650 xfs_agnumber_t ag;
651
Dave Chinner16fd5362010-07-20 09:43:39 +1000652 ag = 0;
Dave Chinner65d0f202010-09-24 18:40:15 +1000653 while ((pag = xfs_perag_get(mp, ag))) {
654 ag = pag->pag_agno + 1;
Brian Fostera454f742012-11-06 09:50:39 -0500655 error = xfs_inode_ag_walk(mp, pag, execute, flags, args, -1);
656 xfs_perag_put(pag);
657 if (error) {
658 last_error = error;
Dave Chinner24513372014-06-25 14:58:08 +1000659 if (error == -EFSCORRUPTED)
Brian Fostera454f742012-11-06 09:50:39 -0500660 break;
661 }
662 }
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000663 return last_error;
Brian Fostera454f742012-11-06 09:50:39 -0500664}
665
666int
667xfs_inode_ag_iterator_tag(
668 struct xfs_mount *mp,
Eric Sandeene0094002014-04-14 19:04:19 +1000669 int (*execute)(struct xfs_inode *ip, int flags,
Brian Fostera454f742012-11-06 09:50:39 -0500670 void *args),
671 int flags,
672 void *args,
673 int tag)
674{
675 struct xfs_perag *pag;
676 int error = 0;
677 int last_error = 0;
678 xfs_agnumber_t ag;
679
680 ag = 0;
681 while ((pag = xfs_perag_get_tag(mp, ag, tag))) {
682 ag = pag->pag_agno + 1;
683 error = xfs_inode_ag_walk(mp, pag, execute, flags, args, tag);
Dave Chinner5017e972010-01-11 11:47:40 +0000684 xfs_perag_put(pag);
Dave Chinner75f3cb12009-06-08 15:35:14 +0200685 if (error) {
686 last_error = error;
Dave Chinner24513372014-06-25 14:58:08 +1000687 if (error == -EFSCORRUPTED)
Dave Chinner75f3cb12009-06-08 15:35:14 +0200688 break;
689 }
690 }
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000691 return last_error;
Dave Chinner75f3cb12009-06-08 15:35:14 +0200692}
693
David Chinner76bf1052008-10-30 17:16:21 +1100694/*
Dave Chinnera7b339f2011-04-08 12:45:07 +1000695 * Queue a new inode reclaim pass if there are reclaimable inodes and there
696 * isn't a reclaim pass already in progress. By default it runs every 5s based
Dave Chinner58896082012-10-08 21:56:05 +1100697 * on the xfs periodic sync default of 30s. Perhaps this should have it's own
Dave Chinnera7b339f2011-04-08 12:45:07 +1000698 * tunable, but that can be done if this method proves to be ineffective or too
699 * aggressive.
700 */
701static void
Dave Chinner58896082012-10-08 21:56:05 +1100702xfs_reclaim_work_queue(
Dave Chinnera7b339f2011-04-08 12:45:07 +1000703 struct xfs_mount *mp)
David Chinnera167b172008-10-30 17:06:18 +1100704{
David Chinnera167b172008-10-30 17:06:18 +1100705
Dave Chinnera7b339f2011-04-08 12:45:07 +1000706 rcu_read_lock();
707 if (radix_tree_tagged(&mp->m_perag_tree, XFS_ICI_RECLAIM_TAG)) {
Dave Chinner58896082012-10-08 21:56:05 +1100708 queue_delayed_work(mp->m_reclaim_workqueue, &mp->m_reclaim_work,
Dave Chinnera7b339f2011-04-08 12:45:07 +1000709 msecs_to_jiffies(xfs_syncd_centisecs / 6 * 10));
David Chinnera167b172008-10-30 17:06:18 +1100710 }
Dave Chinnera7b339f2011-04-08 12:45:07 +1000711 rcu_read_unlock();
712}
David Chinnera167b172008-10-30 17:06:18 +1100713
Dave Chinnera7b339f2011-04-08 12:45:07 +1000714/*
715 * This is a fast pass over the inode cache to try to get reclaim moving on as
716 * many inodes as possible in a short period of time. It kicks itself every few
717 * seconds, as well as being kicked by the inode cache shrinker when memory
718 * goes low. It scans as quickly as possible avoiding locked inodes or those
719 * already being flushed, and once done schedules a future pass.
720 */
Dave Chinner33c7a2b2012-10-08 21:55:59 +1100721void
Dave Chinnera7b339f2011-04-08 12:45:07 +1000722xfs_reclaim_worker(
723 struct work_struct *work)
724{
725 struct xfs_mount *mp = container_of(to_delayed_work(work),
726 struct xfs_mount, m_reclaim_work);
727
728 xfs_reclaim_inodes(mp, SYNC_TRYLOCK);
Dave Chinner58896082012-10-08 21:56:05 +1100729 xfs_reclaim_work_queue(mp);
Dave Chinnera7b339f2011-04-08 12:45:07 +1000730}
731
Dave Chinner33479e02012-10-08 21:56:11 +1100732static void
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400733__xfs_inode_set_reclaim_tag(
734 struct xfs_perag *pag,
735 struct xfs_inode *ip)
736{
737 radix_tree_tag_set(&pag->pag_ici_root,
738 XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino),
739 XFS_ICI_RECLAIM_TAG);
Dave Chinner16fd5362010-07-20 09:43:39 +1000740
741 if (!pag->pag_ici_reclaimable) {
742 /* propagate the reclaim tag up into the perag radix tree */
743 spin_lock(&ip->i_mount->m_perag_lock);
744 radix_tree_tag_set(&ip->i_mount->m_perag_tree,
745 XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino),
746 XFS_ICI_RECLAIM_TAG);
747 spin_unlock(&ip->i_mount->m_perag_lock);
Dave Chinnera7b339f2011-04-08 12:45:07 +1000748
749 /* schedule periodic background inode reclaim */
Dave Chinner58896082012-10-08 21:56:05 +1100750 xfs_reclaim_work_queue(ip->i_mount);
Dave Chinnera7b339f2011-04-08 12:45:07 +1000751
Dave Chinner16fd5362010-07-20 09:43:39 +1000752 trace_xfs_perag_set_reclaim(ip->i_mount, pag->pag_agno,
753 -1, _RET_IP_);
754 }
Dave Chinner9bf729c2010-04-29 09:55:50 +1000755 pag->pag_ici_reclaimable++;
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400756}
757
David Chinner11654512008-10-30 17:37:49 +1100758/*
759 * We set the inode flag atomically with the radix tree tag.
760 * Once we get tag lookups on the radix tree, this inode flag
761 * can go away.
762 */
David Chinner396beb82008-10-30 17:37:26 +1100763void
764xfs_inode_set_reclaim_tag(
765 xfs_inode_t *ip)
766{
Dave Chinner5017e972010-01-11 11:47:40 +0000767 struct xfs_mount *mp = ip->i_mount;
768 struct xfs_perag *pag;
David Chinner396beb82008-10-30 17:37:26 +1100769
Dave Chinner5017e972010-01-11 11:47:40 +0000770 pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
Dave Chinner1a427ab2010-12-16 17:08:41 +1100771 spin_lock(&pag->pag_ici_lock);
David Chinner396beb82008-10-30 17:37:26 +1100772 spin_lock(&ip->i_flags_lock);
Christoph Hellwigbc990f52009-08-16 20:36:34 -0400773 __xfs_inode_set_reclaim_tag(pag, ip);
David Chinner11654512008-10-30 17:37:49 +1100774 __xfs_iflags_set(ip, XFS_IRECLAIMABLE);
David Chinner396beb82008-10-30 17:37:26 +1100775 spin_unlock(&ip->i_flags_lock);
Dave Chinner1a427ab2010-12-16 17:08:41 +1100776 spin_unlock(&pag->pag_ici_lock);
Dave Chinner5017e972010-01-11 11:47:40 +0000777 xfs_perag_put(pag);
David Chinner396beb82008-10-30 17:37:26 +1100778}
779
Johannes Weiner081003f2010-10-01 07:43:54 +0000780STATIC void
781__xfs_inode_clear_reclaim(
David Chinner396beb82008-10-30 17:37:26 +1100782 xfs_perag_t *pag,
783 xfs_inode_t *ip)
784{
Dave Chinner9bf729c2010-04-29 09:55:50 +1000785 pag->pag_ici_reclaimable--;
Dave Chinner16fd5362010-07-20 09:43:39 +1000786 if (!pag->pag_ici_reclaimable) {
787 /* clear the reclaim tag from the perag radix tree */
788 spin_lock(&ip->i_mount->m_perag_lock);
789 radix_tree_tag_clear(&ip->i_mount->m_perag_tree,
790 XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino),
791 XFS_ICI_RECLAIM_TAG);
792 spin_unlock(&ip->i_mount->m_perag_lock);
793 trace_xfs_perag_clear_reclaim(ip->i_mount, pag->pag_agno,
794 -1, _RET_IP_);
795 }
David Chinner396beb82008-10-30 17:37:26 +1100796}
797
Dave Chinner33479e02012-10-08 21:56:11 +1100798STATIC void
Johannes Weiner081003f2010-10-01 07:43:54 +0000799__xfs_inode_clear_reclaim_tag(
800 xfs_mount_t *mp,
801 xfs_perag_t *pag,
802 xfs_inode_t *ip)
803{
804 radix_tree_tag_clear(&pag->pag_ici_root,
805 XFS_INO_TO_AGINO(mp, ip->i_ino), XFS_ICI_RECLAIM_TAG);
806 __xfs_inode_clear_reclaim(pag, ip);
807}
808
Dave Chinner777df5a2010-02-06 12:37:26 +1100809/*
Dave Chinnere3a20c02010-09-24 19:51:50 +1000810 * Grab the inode for reclaim exclusively.
811 * Return 0 if we grabbed it, non-zero otherwise.
812 */
813STATIC int
814xfs_reclaim_inode_grab(
815 struct xfs_inode *ip,
816 int flags)
817{
Dave Chinner1a3e8f32010-12-17 17:29:43 +1100818 ASSERT(rcu_read_lock_held());
819
820 /* quick check for stale RCU freed inode */
821 if (!ip->i_ino)
822 return 1;
Dave Chinnere3a20c02010-09-24 19:51:50 +1000823
824 /*
Christoph Hellwig474fce02011-12-18 20:00:09 +0000825 * If we are asked for non-blocking operation, do unlocked checks to
826 * see if the inode already is being flushed or in reclaim to avoid
827 * lock traffic.
Dave Chinnere3a20c02010-09-24 19:51:50 +1000828 */
829 if ((flags & SYNC_TRYLOCK) &&
Christoph Hellwig474fce02011-12-18 20:00:09 +0000830 __xfs_iflags_test(ip, XFS_IFLOCK | XFS_IRECLAIM))
Dave Chinnere3a20c02010-09-24 19:51:50 +1000831 return 1;
Dave Chinnere3a20c02010-09-24 19:51:50 +1000832
833 /*
834 * The radix tree lock here protects a thread in xfs_iget from racing
835 * with us starting reclaim on the inode. Once we have the
836 * XFS_IRECLAIM flag set it will not touch us.
Dave Chinner1a3e8f32010-12-17 17:29:43 +1100837 *
838 * Due to RCU lookup, we may find inodes that have been freed and only
839 * have XFS_IRECLAIM set. Indeed, we may see reallocated inodes that
840 * aren't candidates for reclaim at all, so we must check the
841 * XFS_IRECLAIMABLE is set first before proceeding to reclaim.
Dave Chinnere3a20c02010-09-24 19:51:50 +1000842 */
843 spin_lock(&ip->i_flags_lock);
Dave Chinner1a3e8f32010-12-17 17:29:43 +1100844 if (!__xfs_iflags_test(ip, XFS_IRECLAIMABLE) ||
845 __xfs_iflags_test(ip, XFS_IRECLAIM)) {
846 /* not a reclaim candidate. */
Dave Chinnere3a20c02010-09-24 19:51:50 +1000847 spin_unlock(&ip->i_flags_lock);
848 return 1;
849 }
850 __xfs_iflags_set(ip, XFS_IRECLAIM);
851 spin_unlock(&ip->i_flags_lock);
852 return 0;
853}
854
855/*
Christoph Hellwig8a480882012-04-23 15:58:35 +1000856 * Inodes in different states need to be treated differently. The following
857 * table lists the inode states and the reclaim actions necessary:
Dave Chinner777df5a2010-02-06 12:37:26 +1100858 *
859 * inode state iflush ret required action
860 * --------------- ---------- ---------------
861 * bad - reclaim
862 * shutdown EIO unpin and reclaim
863 * clean, unpinned 0 reclaim
864 * stale, unpinned 0 reclaim
Dave Chinnerc8543632010-02-06 12:39:36 +1100865 * clean, pinned(*) 0 requeue
866 * stale, pinned EAGAIN requeue
Christoph Hellwig8a480882012-04-23 15:58:35 +1000867 * dirty, async - requeue
868 * dirty, sync 0 reclaim
Dave Chinner777df5a2010-02-06 12:37:26 +1100869 *
870 * (*) dgc: I don't think the clean, pinned state is possible but it gets
871 * handled anyway given the order of checks implemented.
872 *
Dave Chinnerc8543632010-02-06 12:39:36 +1100873 * Also, because we get the flush lock first, we know that any inode that has
874 * been flushed delwri has had the flush completed by the time we check that
Christoph Hellwig8a480882012-04-23 15:58:35 +1000875 * the inode is clean.
Dave Chinnerc8543632010-02-06 12:39:36 +1100876 *
Christoph Hellwig8a480882012-04-23 15:58:35 +1000877 * Note that because the inode is flushed delayed write by AIL pushing, the
878 * flush lock may already be held here and waiting on it can result in very
879 * long latencies. Hence for sync reclaims, where we wait on the flush lock,
880 * the caller should push the AIL first before trying to reclaim inodes to
881 * minimise the amount of time spent waiting. For background relaim, we only
882 * bother to reclaim clean inodes anyway.
Dave Chinnerc8543632010-02-06 12:39:36 +1100883 *
Dave Chinner777df5a2010-02-06 12:37:26 +1100884 * Hence the order of actions after gaining the locks should be:
885 * bad => reclaim
886 * shutdown => unpin and reclaim
Christoph Hellwig8a480882012-04-23 15:58:35 +1000887 * pinned, async => requeue
Dave Chinnerc8543632010-02-06 12:39:36 +1100888 * pinned, sync => unpin
Dave Chinner777df5a2010-02-06 12:37:26 +1100889 * stale => reclaim
890 * clean => reclaim
Christoph Hellwig8a480882012-04-23 15:58:35 +1000891 * dirty, async => requeue
Dave Chinnerc8543632010-02-06 12:39:36 +1100892 * dirty, sync => flush, wait and reclaim
Dave Chinner777df5a2010-02-06 12:37:26 +1100893 */
Dave Chinner75f3cb12009-06-08 15:35:14 +0200894STATIC int
Dave Chinnerc8e20be2010-01-10 23:51:45 +0000895xfs_reclaim_inode(
Dave Chinner75f3cb12009-06-08 15:35:14 +0200896 struct xfs_inode *ip,
897 struct xfs_perag *pag,
Dave Chinnerc8e20be2010-01-10 23:51:45 +0000898 int sync_mode)
David Chinner7a3be022008-10-30 17:37:37 +1100899{
Christoph Hellwig4c468192012-04-23 15:58:36 +1000900 struct xfs_buf *bp = NULL;
901 int error;
Dave Chinner777df5a2010-02-06 12:37:26 +1100902
Dave Chinner1bfd8d02011-03-26 09:13:55 +1100903restart:
904 error = 0;
Dave Chinnerc8e20be2010-01-10 23:51:45 +0000905 xfs_ilock(ip, XFS_ILOCK_EXCL);
Dave Chinnerc8543632010-02-06 12:39:36 +1100906 if (!xfs_iflock_nowait(ip)) {
907 if (!(sync_mode & SYNC_WAIT))
908 goto out;
909 xfs_iflock(ip);
910 }
Dave Chinnerc8e20be2010-01-10 23:51:45 +0000911
Dave Chinner777df5a2010-02-06 12:37:26 +1100912 if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
913 xfs_iunpin_wait(ip);
Dave Chinner04913fd2012-04-23 15:58:41 +1000914 xfs_iflush_abort(ip, false);
Dave Chinner777df5a2010-02-06 12:37:26 +1100915 goto reclaim;
916 }
Dave Chinnerc8543632010-02-06 12:39:36 +1100917 if (xfs_ipincount(ip)) {
Christoph Hellwig8a480882012-04-23 15:58:35 +1000918 if (!(sync_mode & SYNC_WAIT))
919 goto out_ifunlock;
Dave Chinner777df5a2010-02-06 12:37:26 +1100920 xfs_iunpin_wait(ip);
Dave Chinnerc8543632010-02-06 12:39:36 +1100921 }
Dave Chinner777df5a2010-02-06 12:37:26 +1100922 if (xfs_iflags_test(ip, XFS_ISTALE))
923 goto reclaim;
924 if (xfs_inode_clean(ip))
925 goto reclaim;
926
Dave Chinner1bfd8d02011-03-26 09:13:55 +1100927 /*
Christoph Hellwig8a480882012-04-23 15:58:35 +1000928 * Never flush out dirty data during non-blocking reclaim, as it would
929 * just contend with AIL pushing trying to do the same job.
930 */
931 if (!(sync_mode & SYNC_WAIT))
932 goto out_ifunlock;
933
934 /*
Dave Chinner1bfd8d02011-03-26 09:13:55 +1100935 * Now we have an inode that needs flushing.
936 *
Christoph Hellwig4c468192012-04-23 15:58:36 +1000937 * Note that xfs_iflush will never block on the inode buffer lock, as
Dave Chinner1bfd8d02011-03-26 09:13:55 +1100938 * xfs_ifree_cluster() can lock the inode buffer before it locks the
Christoph Hellwig4c468192012-04-23 15:58:36 +1000939 * ip->i_lock, and we are doing the exact opposite here. As a result,
Christoph Hellwig475ee412012-07-03 12:21:22 -0400940 * doing a blocking xfs_imap_to_bp() to get the cluster buffer would
941 * result in an ABBA deadlock with xfs_ifree_cluster().
Dave Chinner1bfd8d02011-03-26 09:13:55 +1100942 *
943 * As xfs_ifree_cluser() must gather all inodes that are active in the
944 * cache to mark them stale, if we hit this case we don't actually want
945 * to do IO here - we want the inode marked stale so we can simply
Christoph Hellwig4c468192012-04-23 15:58:36 +1000946 * reclaim it. Hence if we get an EAGAIN error here, just unlock the
947 * inode, back off and try again. Hopefully the next pass through will
948 * see the stale flag set on the inode.
Dave Chinner1bfd8d02011-03-26 09:13:55 +1100949 */
Christoph Hellwig4c468192012-04-23 15:58:36 +1000950 error = xfs_iflush(ip, &bp);
Dave Chinner24513372014-06-25 14:58:08 +1000951 if (error == -EAGAIN) {
Christoph Hellwig8a480882012-04-23 15:58:35 +1000952 xfs_iunlock(ip, XFS_ILOCK_EXCL);
953 /* backoff longer than in xfs_ifree_cluster */
954 delay(2);
955 goto restart;
Dave Chinnerc8e20be2010-01-10 23:51:45 +0000956 }
Dave Chinnerc8543632010-02-06 12:39:36 +1100957
Christoph Hellwig4c468192012-04-23 15:58:36 +1000958 if (!error) {
959 error = xfs_bwrite(bp);
960 xfs_buf_relse(bp);
961 }
962
963 xfs_iflock(ip);
Dave Chinner777df5a2010-02-06 12:37:26 +1100964reclaim:
965 xfs_ifunlock(ip);
Dave Chinnerc8e20be2010-01-10 23:51:45 +0000966 xfs_iunlock(ip, XFS_ILOCK_EXCL);
Dave Chinner2f11fea2010-07-20 17:53:25 +1000967
968 XFS_STATS_INC(xs_ig_reclaims);
969 /*
970 * Remove the inode from the per-AG radix tree.
971 *
972 * Because radix_tree_delete won't complain even if the item was never
973 * added to the tree assert that it's been there before to catch
974 * problems with the inode life time early on.
975 */
Dave Chinner1a427ab2010-12-16 17:08:41 +1100976 spin_lock(&pag->pag_ici_lock);
Dave Chinner2f11fea2010-07-20 17:53:25 +1000977 if (!radix_tree_delete(&pag->pag_ici_root,
978 XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino)))
979 ASSERT(0);
Johannes Weiner081003f2010-10-01 07:43:54 +0000980 __xfs_inode_clear_reclaim(pag, ip);
Dave Chinner1a427ab2010-12-16 17:08:41 +1100981 spin_unlock(&pag->pag_ici_lock);
Dave Chinner2f11fea2010-07-20 17:53:25 +1000982
983 /*
984 * Here we do an (almost) spurious inode lock in order to coordinate
985 * with inode cache radix tree lookups. This is because the lookup
986 * can reference the inodes in the cache without taking references.
987 *
988 * We make that OK here by ensuring that we wait until the inode is
Alex Elderad637a12012-02-16 22:01:00 +0000989 * unlocked after the lookup before we go ahead and free it.
Dave Chinner2f11fea2010-07-20 17:53:25 +1000990 */
Alex Elderad637a12012-02-16 22:01:00 +0000991 xfs_ilock(ip, XFS_ILOCK_EXCL);
Dave Chinner2f11fea2010-07-20 17:53:25 +1000992 xfs_qm_dqdetach(ip);
Alex Elderad637a12012-02-16 22:01:00 +0000993 xfs_iunlock(ip, XFS_ILOCK_EXCL);
Dave Chinner2f11fea2010-07-20 17:53:25 +1000994
995 xfs_inode_free(ip);
Alex Elderad637a12012-02-16 22:01:00 +0000996 return error;
Christoph Hellwig8a480882012-04-23 15:58:35 +1000997
998out_ifunlock:
999 xfs_ifunlock(ip);
1000out:
1001 xfs_iflags_clear(ip, XFS_IRECLAIM);
1002 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1003 /*
Dave Chinner24513372014-06-25 14:58:08 +10001004 * We could return -EAGAIN here to make reclaim rescan the inode tree in
Christoph Hellwig8a480882012-04-23 15:58:35 +10001005 * a short while. However, this just burns CPU time scanning the tree
Dave Chinner58896082012-10-08 21:56:05 +11001006 * waiting for IO to complete and the reclaim work never goes back to
1007 * the idle state. Instead, return 0 to let the next scheduled
1008 * background reclaim attempt to reclaim the inode again.
Christoph Hellwig8a480882012-04-23 15:58:35 +10001009 */
1010 return 0;
David Chinner7a3be022008-10-30 17:37:37 +11001011}
1012
Dave Chinner65d0f202010-09-24 18:40:15 +10001013/*
1014 * Walk the AGs and reclaim the inodes in them. Even if the filesystem is
1015 * corrupted, we still want to try to reclaim all the inodes. If we don't,
1016 * then a shut down during filesystem unmount reclaim walk leak all the
1017 * unreclaimed inodes.
1018 */
Dave Chinner33479e02012-10-08 21:56:11 +11001019STATIC int
Dave Chinner65d0f202010-09-24 18:40:15 +10001020xfs_reclaim_inodes_ag(
1021 struct xfs_mount *mp,
1022 int flags,
1023 int *nr_to_scan)
1024{
1025 struct xfs_perag *pag;
1026 int error = 0;
1027 int last_error = 0;
1028 xfs_agnumber_t ag;
Dave Chinner69b491c2010-09-27 11:09:51 +10001029 int trylock = flags & SYNC_TRYLOCK;
1030 int skipped;
Dave Chinner65d0f202010-09-24 18:40:15 +10001031
Dave Chinner69b491c2010-09-27 11:09:51 +10001032restart:
Dave Chinner65d0f202010-09-24 18:40:15 +10001033 ag = 0;
Dave Chinner69b491c2010-09-27 11:09:51 +10001034 skipped = 0;
Dave Chinner65d0f202010-09-24 18:40:15 +10001035 while ((pag = xfs_perag_get_tag(mp, ag, XFS_ICI_RECLAIM_TAG))) {
1036 unsigned long first_index = 0;
1037 int done = 0;
Dave Chinnere3a20c02010-09-24 19:51:50 +10001038 int nr_found = 0;
Dave Chinner65d0f202010-09-24 18:40:15 +10001039
1040 ag = pag->pag_agno + 1;
1041
Dave Chinner69b491c2010-09-27 11:09:51 +10001042 if (trylock) {
1043 if (!mutex_trylock(&pag->pag_ici_reclaim_lock)) {
1044 skipped++;
Dave Chinnerf83282a2010-11-08 08:55:04 +00001045 xfs_perag_put(pag);
Dave Chinner69b491c2010-09-27 11:09:51 +10001046 continue;
1047 }
1048 first_index = pag->pag_ici_reclaim_cursor;
1049 } else
1050 mutex_lock(&pag->pag_ici_reclaim_lock);
1051
Dave Chinner65d0f202010-09-24 18:40:15 +10001052 do {
Dave Chinnere3a20c02010-09-24 19:51:50 +10001053 struct xfs_inode *batch[XFS_LOOKUP_BATCH];
1054 int i;
Dave Chinner65d0f202010-09-24 18:40:15 +10001055
Dave Chinner1a3e8f32010-12-17 17:29:43 +11001056 rcu_read_lock();
Dave Chinnere3a20c02010-09-24 19:51:50 +10001057 nr_found = radix_tree_gang_lookup_tag(
1058 &pag->pag_ici_root,
1059 (void **)batch, first_index,
1060 XFS_LOOKUP_BATCH,
Dave Chinner65d0f202010-09-24 18:40:15 +10001061 XFS_ICI_RECLAIM_TAG);
1062 if (!nr_found) {
Dave Chinnerb2232212011-05-06 02:54:04 +00001063 done = 1;
Dave Chinner1a3e8f32010-12-17 17:29:43 +11001064 rcu_read_unlock();
Dave Chinner65d0f202010-09-24 18:40:15 +10001065 break;
1066 }
1067
1068 /*
Dave Chinnere3a20c02010-09-24 19:51:50 +10001069 * Grab the inodes before we drop the lock. if we found
1070 * nothing, nr == 0 and the loop will be skipped.
Dave Chinner65d0f202010-09-24 18:40:15 +10001071 */
Dave Chinnere3a20c02010-09-24 19:51:50 +10001072 for (i = 0; i < nr_found; i++) {
1073 struct xfs_inode *ip = batch[i];
Dave Chinner65d0f202010-09-24 18:40:15 +10001074
Dave Chinnere3a20c02010-09-24 19:51:50 +10001075 if (done || xfs_reclaim_inode_grab(ip, flags))
1076 batch[i] = NULL;
Dave Chinner65d0f202010-09-24 18:40:15 +10001077
Dave Chinnere3a20c02010-09-24 19:51:50 +10001078 /*
1079 * Update the index for the next lookup. Catch
1080 * overflows into the next AG range which can
1081 * occur if we have inodes in the last block of
1082 * the AG and we are currently pointing to the
1083 * last inode.
Dave Chinner1a3e8f32010-12-17 17:29:43 +11001084 *
1085 * Because we may see inodes that are from the
1086 * wrong AG due to RCU freeing and
1087 * reallocation, only update the index if it
1088 * lies in this AG. It was a race that lead us
1089 * to see this inode, so another lookup from
1090 * the same index will not find it again.
Dave Chinnere3a20c02010-09-24 19:51:50 +10001091 */
Dave Chinner1a3e8f32010-12-17 17:29:43 +11001092 if (XFS_INO_TO_AGNO(mp, ip->i_ino) !=
1093 pag->pag_agno)
1094 continue;
Dave Chinnere3a20c02010-09-24 19:51:50 +10001095 first_index = XFS_INO_TO_AGINO(mp, ip->i_ino + 1);
1096 if (first_index < XFS_INO_TO_AGINO(mp, ip->i_ino))
1097 done = 1;
1098 }
1099
1100 /* unlock now we've grabbed the inodes. */
Dave Chinner1a3e8f32010-12-17 17:29:43 +11001101 rcu_read_unlock();
Dave Chinnere3a20c02010-09-24 19:51:50 +10001102
1103 for (i = 0; i < nr_found; i++) {
1104 if (!batch[i])
1105 continue;
1106 error = xfs_reclaim_inode(batch[i], pag, flags);
Dave Chinner24513372014-06-25 14:58:08 +10001107 if (error && last_error != -EFSCORRUPTED)
Dave Chinnere3a20c02010-09-24 19:51:50 +10001108 last_error = error;
1109 }
1110
1111 *nr_to_scan -= XFS_LOOKUP_BATCH;
1112
Dave Chinner8daaa832011-07-08 14:14:46 +10001113 cond_resched();
1114
Dave Chinnere3a20c02010-09-24 19:51:50 +10001115 } while (nr_found && !done && *nr_to_scan > 0);
Dave Chinner65d0f202010-09-24 18:40:15 +10001116
Dave Chinner69b491c2010-09-27 11:09:51 +10001117 if (trylock && !done)
1118 pag->pag_ici_reclaim_cursor = first_index;
1119 else
1120 pag->pag_ici_reclaim_cursor = 0;
1121 mutex_unlock(&pag->pag_ici_reclaim_lock);
Dave Chinner65d0f202010-09-24 18:40:15 +10001122 xfs_perag_put(pag);
1123 }
Dave Chinner69b491c2010-09-27 11:09:51 +10001124
1125 /*
1126 * if we skipped any AG, and we still have scan count remaining, do
1127 * another pass this time using blocking reclaim semantics (i.e
1128 * waiting on the reclaim locks and ignoring the reclaim cursors). This
1129 * ensure that when we get more reclaimers than AGs we block rather
1130 * than spin trying to execute reclaim.
1131 */
Dave Chinner8daaa832011-07-08 14:14:46 +10001132 if (skipped && (flags & SYNC_WAIT) && *nr_to_scan > 0) {
Dave Chinner69b491c2010-09-27 11:09:51 +10001133 trylock = 0;
1134 goto restart;
1135 }
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001136 return last_error;
Dave Chinner65d0f202010-09-24 18:40:15 +10001137}
1138
David Chinnerfce08f22008-10-30 17:37:03 +11001139int
David Chinner1dc33182008-10-30 17:37:15 +11001140xfs_reclaim_inodes(
David Chinnerfce08f22008-10-30 17:37:03 +11001141 xfs_mount_t *mp,
David Chinnerfce08f22008-10-30 17:37:03 +11001142 int mode)
1143{
Dave Chinner65d0f202010-09-24 18:40:15 +10001144 int nr_to_scan = INT_MAX;
1145
1146 return xfs_reclaim_inodes_ag(mp, mode, &nr_to_scan);
Dave Chinner9bf729c2010-04-29 09:55:50 +10001147}
1148
1149/*
Dave Chinner8daaa832011-07-08 14:14:46 +10001150 * Scan a certain number of inodes for reclaim.
Dave Chinnera7b339f2011-04-08 12:45:07 +10001151 *
1152 * When called we make sure that there is a background (fast) inode reclaim in
Dave Chinner8daaa832011-07-08 14:14:46 +10001153 * progress, while we will throttle the speed of reclaim via doing synchronous
Dave Chinnera7b339f2011-04-08 12:45:07 +10001154 * reclaim of inodes. That means if we come across dirty inodes, we wait for
1155 * them to be cleaned, which we hope will not be very long due to the
1156 * background walker having already kicked the IO off on those dirty inodes.
Dave Chinner9bf729c2010-04-29 09:55:50 +10001157 */
Dave Chinner0a234c62013-08-28 10:17:57 +10001158long
Dave Chinner8daaa832011-07-08 14:14:46 +10001159xfs_reclaim_inodes_nr(
1160 struct xfs_mount *mp,
1161 int nr_to_scan)
Dave Chinner9bf729c2010-04-29 09:55:50 +10001162{
Dave Chinner8daaa832011-07-08 14:14:46 +10001163 /* kick background reclaimer and push the AIL */
Dave Chinner58896082012-10-08 21:56:05 +11001164 xfs_reclaim_work_queue(mp);
Dave Chinner8daaa832011-07-08 14:14:46 +10001165 xfs_ail_push_all(mp->m_ail);
Dave Chinner9bf729c2010-04-29 09:55:50 +10001166
Dave Chinner0a234c62013-08-28 10:17:57 +10001167 return xfs_reclaim_inodes_ag(mp, SYNC_TRYLOCK | SYNC_WAIT, &nr_to_scan);
Dave Chinner8daaa832011-07-08 14:14:46 +10001168}
Dave Chinnera7b339f2011-04-08 12:45:07 +10001169
Dave Chinner8daaa832011-07-08 14:14:46 +10001170/*
1171 * Return the number of reclaimable inodes in the filesystem for
1172 * the shrinker to determine how much to reclaim.
1173 */
1174int
1175xfs_reclaim_inodes_count(
1176 struct xfs_mount *mp)
1177{
1178 struct xfs_perag *pag;
1179 xfs_agnumber_t ag = 0;
1180 int reclaimable = 0;
Dave Chinner9bf729c2010-04-29 09:55:50 +10001181
Dave Chinner65d0f202010-09-24 18:40:15 +10001182 while ((pag = xfs_perag_get_tag(mp, ag, XFS_ICI_RECLAIM_TAG))) {
1183 ag = pag->pag_agno + 1;
Dave Chinner70e60ce2010-07-20 08:07:02 +10001184 reclaimable += pag->pag_ici_reclaimable;
1185 xfs_perag_put(pag);
Dave Chinner9bf729c2010-04-29 09:55:50 +10001186 }
Dave Chinner9bf729c2010-04-29 09:55:50 +10001187 return reclaimable;
1188}
1189
Brian Foster41176a62012-11-06 09:50:42 -05001190STATIC int
Brian Foster3e3f9f52012-11-07 12:21:13 -05001191xfs_inode_match_id(
1192 struct xfs_inode *ip,
1193 struct xfs_eofblocks *eofb)
1194{
Dwight Engenb9fe5052013-08-15 14:08:02 -04001195 if ((eofb->eof_flags & XFS_EOF_FLAGS_UID) &&
1196 !uid_eq(VFS_I(ip)->i_uid, eofb->eof_uid))
Brian Foster1b556042012-11-06 09:50:45 -05001197 return 0;
Brian Foster3e3f9f52012-11-07 12:21:13 -05001198
Dwight Engenb9fe5052013-08-15 14:08:02 -04001199 if ((eofb->eof_flags & XFS_EOF_FLAGS_GID) &&
1200 !gid_eq(VFS_I(ip)->i_gid, eofb->eof_gid))
Brian Foster1b556042012-11-06 09:50:45 -05001201 return 0;
1202
Dwight Engenb9fe5052013-08-15 14:08:02 -04001203 if ((eofb->eof_flags & XFS_EOF_FLAGS_PRID) &&
Brian Foster1b556042012-11-06 09:50:45 -05001204 xfs_get_projid(ip) != eofb->eof_prid)
1205 return 0;
1206
1207 return 1;
Brian Foster3e3f9f52012-11-07 12:21:13 -05001208}
1209
Brian Fosterf4526392014-07-24 19:44:28 +10001210/*
1211 * A union-based inode filtering algorithm. Process the inode if any of the
1212 * criteria match. This is for global/internal scans only.
1213 */
1214STATIC int
1215xfs_inode_match_id_union(
1216 struct xfs_inode *ip,
1217 struct xfs_eofblocks *eofb)
1218{
1219 if ((eofb->eof_flags & XFS_EOF_FLAGS_UID) &&
1220 uid_eq(VFS_I(ip)->i_uid, eofb->eof_uid))
1221 return 1;
1222
1223 if ((eofb->eof_flags & XFS_EOF_FLAGS_GID) &&
1224 gid_eq(VFS_I(ip)->i_gid, eofb->eof_gid))
1225 return 1;
1226
1227 if ((eofb->eof_flags & XFS_EOF_FLAGS_PRID) &&
1228 xfs_get_projid(ip) == eofb->eof_prid)
1229 return 1;
1230
1231 return 0;
1232}
1233
Brian Foster3e3f9f52012-11-07 12:21:13 -05001234STATIC int
Brian Foster41176a62012-11-06 09:50:42 -05001235xfs_inode_free_eofblocks(
1236 struct xfs_inode *ip,
Brian Foster41176a62012-11-06 09:50:42 -05001237 int flags,
1238 void *args)
1239{
1240 int ret;
Brian Foster3e3f9f52012-11-07 12:21:13 -05001241 struct xfs_eofblocks *eofb = args;
Brian Foster5400da72014-07-24 19:40:22 +10001242 bool need_iolock = true;
Brian Fosterf4526392014-07-24 19:44:28 +10001243 int match;
Brian Foster5400da72014-07-24 19:40:22 +10001244
1245 ASSERT(!eofb || (eofb && eofb->eof_scan_owner != 0));
Brian Foster41176a62012-11-06 09:50:42 -05001246
1247 if (!xfs_can_free_eofblocks(ip, false)) {
1248 /* inode could be preallocated or append-only */
1249 trace_xfs_inode_free_eofblocks_invalid(ip);
1250 xfs_inode_clear_eofblocks_tag(ip);
1251 return 0;
1252 }
1253
1254 /*
1255 * If the mapping is dirty the operation can block and wait for some
1256 * time. Unless we are waiting, skip it.
1257 */
1258 if (!(flags & SYNC_WAIT) &&
1259 mapping_tagged(VFS_I(ip)->i_mapping, PAGECACHE_TAG_DIRTY))
1260 return 0;
1261
Brian Foster00ca79a2012-11-07 12:21:14 -05001262 if (eofb) {
Brian Fosterf4526392014-07-24 19:44:28 +10001263 if (eofb->eof_flags & XFS_EOF_FLAGS_UNION)
1264 match = xfs_inode_match_id_union(ip, eofb);
1265 else
1266 match = xfs_inode_match_id(ip, eofb);
1267 if (!match)
Brian Foster00ca79a2012-11-07 12:21:14 -05001268 return 0;
1269
1270 /* skip the inode if the file size is too small */
1271 if (eofb->eof_flags & XFS_EOF_FLAGS_MINFILESIZE &&
1272 XFS_ISIZE(ip) < eofb->eof_min_file_size)
1273 return 0;
Brian Foster5400da72014-07-24 19:40:22 +10001274
1275 /*
1276 * A scan owner implies we already hold the iolock. Skip it in
1277 * xfs_free_eofblocks() to avoid deadlock. This also eliminates
1278 * the possibility of EAGAIN being returned.
1279 */
1280 if (eofb->eof_scan_owner == ip->i_ino)
1281 need_iolock = false;
Brian Foster00ca79a2012-11-07 12:21:14 -05001282 }
Brian Foster3e3f9f52012-11-07 12:21:13 -05001283
Brian Foster5400da72014-07-24 19:40:22 +10001284 ret = xfs_free_eofblocks(ip->i_mount, ip, need_iolock);
Brian Foster41176a62012-11-06 09:50:42 -05001285
1286 /* don't revisit the inode if we're not waiting */
Dave Chinner24513372014-06-25 14:58:08 +10001287 if (ret == -EAGAIN && !(flags & SYNC_WAIT))
Brian Foster41176a62012-11-06 09:50:42 -05001288 ret = 0;
1289
1290 return ret;
1291}
1292
1293int
1294xfs_icache_free_eofblocks(
1295 struct xfs_mount *mp,
Brian Foster8ca149d2012-11-07 12:21:12 -05001296 struct xfs_eofblocks *eofb)
Brian Foster41176a62012-11-06 09:50:42 -05001297{
Brian Foster8ca149d2012-11-07 12:21:12 -05001298 int flags = SYNC_TRYLOCK;
1299
1300 if (eofb && (eofb->eof_flags & XFS_EOF_FLAGS_SYNC))
1301 flags = SYNC_WAIT;
1302
Brian Foster41176a62012-11-06 09:50:42 -05001303 return xfs_inode_ag_iterator_tag(mp, xfs_inode_free_eofblocks, flags,
Brian Foster8ca149d2012-11-07 12:21:12 -05001304 eofb, XFS_ICI_EOFBLOCKS_TAG);
Brian Foster41176a62012-11-06 09:50:42 -05001305}
1306
Brian Fosterdc06f3982014-07-24 19:49:28 +10001307/*
1308 * Run eofblocks scans on the quotas applicable to the inode. For inodes with
1309 * multiple quotas, we don't know exactly which quota caused an allocation
1310 * failure. We make a best effort by including each quota under low free space
1311 * conditions (less than 1% free space) in the scan.
1312 */
1313int
1314xfs_inode_free_quota_eofblocks(
1315 struct xfs_inode *ip)
1316{
1317 int scan = 0;
1318 struct xfs_eofblocks eofb = {0};
1319 struct xfs_dquot *dq;
1320
1321 ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
1322
1323 /*
1324 * Set the scan owner to avoid a potential livelock. Otherwise, the scan
1325 * can repeatedly trylock on the inode we're currently processing. We
1326 * run a sync scan to increase effectiveness and use the union filter to
1327 * cover all applicable quotas in a single scan.
1328 */
1329 eofb.eof_scan_owner = ip->i_ino;
1330 eofb.eof_flags = XFS_EOF_FLAGS_UNION|XFS_EOF_FLAGS_SYNC;
1331
1332 if (XFS_IS_UQUOTA_ENFORCED(ip->i_mount)) {
1333 dq = xfs_inode_dquot(ip, XFS_DQ_USER);
1334 if (dq && xfs_dquot_lowsp(dq)) {
1335 eofb.eof_uid = VFS_I(ip)->i_uid;
1336 eofb.eof_flags |= XFS_EOF_FLAGS_UID;
1337 scan = 1;
1338 }
1339 }
1340
1341 if (XFS_IS_GQUOTA_ENFORCED(ip->i_mount)) {
1342 dq = xfs_inode_dquot(ip, XFS_DQ_GROUP);
1343 if (dq && xfs_dquot_lowsp(dq)) {
1344 eofb.eof_gid = VFS_I(ip)->i_gid;
1345 eofb.eof_flags |= XFS_EOF_FLAGS_GID;
1346 scan = 1;
1347 }
1348 }
1349
1350 if (scan)
1351 xfs_icache_free_eofblocks(ip->i_mount, &eofb);
1352
1353 return scan;
1354}
1355
Brian Foster27b52862012-11-06 09:50:38 -05001356void
1357xfs_inode_set_eofblocks_tag(
1358 xfs_inode_t *ip)
1359{
1360 struct xfs_mount *mp = ip->i_mount;
1361 struct xfs_perag *pag;
1362 int tagged;
1363
1364 pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
1365 spin_lock(&pag->pag_ici_lock);
1366 trace_xfs_inode_set_eofblocks_tag(ip);
1367
1368 tagged = radix_tree_tagged(&pag->pag_ici_root,
1369 XFS_ICI_EOFBLOCKS_TAG);
1370 radix_tree_tag_set(&pag->pag_ici_root,
1371 XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino),
1372 XFS_ICI_EOFBLOCKS_TAG);
1373 if (!tagged) {
1374 /* propagate the eofblocks tag up into the perag radix tree */
1375 spin_lock(&ip->i_mount->m_perag_lock);
1376 radix_tree_tag_set(&ip->i_mount->m_perag_tree,
1377 XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino),
1378 XFS_ICI_EOFBLOCKS_TAG);
1379 spin_unlock(&ip->i_mount->m_perag_lock);
1380
Brian Foster579b62f2012-11-06 09:50:47 -05001381 /* kick off background trimming */
1382 xfs_queue_eofblocks(ip->i_mount);
1383
Brian Foster27b52862012-11-06 09:50:38 -05001384 trace_xfs_perag_set_eofblocks(ip->i_mount, pag->pag_agno,
1385 -1, _RET_IP_);
1386 }
1387
1388 spin_unlock(&pag->pag_ici_lock);
1389 xfs_perag_put(pag);
1390}
1391
1392void
1393xfs_inode_clear_eofblocks_tag(
1394 xfs_inode_t *ip)
1395{
1396 struct xfs_mount *mp = ip->i_mount;
1397 struct xfs_perag *pag;
1398
1399 pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
1400 spin_lock(&pag->pag_ici_lock);
1401 trace_xfs_inode_clear_eofblocks_tag(ip);
1402
1403 radix_tree_tag_clear(&pag->pag_ici_root,
1404 XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino),
1405 XFS_ICI_EOFBLOCKS_TAG);
1406 if (!radix_tree_tagged(&pag->pag_ici_root, XFS_ICI_EOFBLOCKS_TAG)) {
1407 /* clear the eofblocks tag from the perag radix tree */
1408 spin_lock(&ip->i_mount->m_perag_lock);
1409 radix_tree_tag_clear(&ip->i_mount->m_perag_tree,
1410 XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino),
1411 XFS_ICI_EOFBLOCKS_TAG);
1412 spin_unlock(&ip->i_mount->m_perag_lock);
1413 trace_xfs_perag_clear_eofblocks(ip->i_mount, pag->pag_agno,
1414 -1, _RET_IP_);
1415 }
1416
1417 spin_unlock(&pag->pag_ici_lock);
1418 xfs_perag_put(pag);
1419}
1420