xfs: simplify inode teardown
[linux-2.6.git] / fs / xfs / linux-2.6 / xfs_sync.c
1 /*
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"
20 #include "xfs_types.h"
21 #include "xfs_bit.h"
22 #include "xfs_log.h"
23 #include "xfs_inum.h"
24 #include "xfs_trans.h"
25 #include "xfs_sb.h"
26 #include "xfs_ag.h"
27 #include "xfs_dir2.h"
28 #include "xfs_dmapi.h"
29 #include "xfs_mount.h"
30 #include "xfs_bmap_btree.h"
31 #include "xfs_alloc_btree.h"
32 #include "xfs_ialloc_btree.h"
33 #include "xfs_btree.h"
34 #include "xfs_dir2_sf.h"
35 #include "xfs_attr_sf.h"
36 #include "xfs_inode.h"
37 #include "xfs_dinode.h"
38 #include "xfs_error.h"
39 #include "xfs_mru_cache.h"
40 #include "xfs_filestream.h"
41 #include "xfs_vnodeops.h"
42 #include "xfs_utils.h"
43 #include "xfs_buf_item.h"
44 #include "xfs_inode_item.h"
45 #include "xfs_rw.h"
46 #include "xfs_quota.h"
47
48 #include <linux/kthread.h>
49 #include <linux/freezer.h>
50
51
52 STATIC xfs_inode_t *
53 xfs_inode_ag_lookup(
54         struct xfs_mount        *mp,
55         struct xfs_perag        *pag,
56         uint32_t                *first_index,
57         int                     tag)
58 {
59         int                     nr_found;
60         struct xfs_inode        *ip;
61
62         /*
63          * use a gang lookup to find the next inode in the tree
64          * as the tree is sparse and a gang lookup walks to find
65          * the number of objects requested.
66          */
67         read_lock(&pag->pag_ici_lock);
68         if (tag == XFS_ICI_NO_TAG) {
69                 nr_found = radix_tree_gang_lookup(&pag->pag_ici_root,
70                                 (void **)&ip, *first_index, 1);
71         } else {
72                 nr_found = radix_tree_gang_lookup_tag(&pag->pag_ici_root,
73                                 (void **)&ip, *first_index, 1, tag);
74         }
75         if (!nr_found)
76                 goto unlock;
77
78         /*
79          * Update the index for the next lookup. Catch overflows
80          * into the next AG range which can occur if we have inodes
81          * in the last block of the AG and we are currently
82          * pointing to the last inode.
83          */
84         *first_index = XFS_INO_TO_AGINO(mp, ip->i_ino + 1);
85         if (*first_index < XFS_INO_TO_AGINO(mp, ip->i_ino))
86                 goto unlock;
87
88         return ip;
89
90 unlock:
91         read_unlock(&pag->pag_ici_lock);
92         return NULL;
93 }
94
95 STATIC int
96 xfs_inode_ag_walk(
97         struct xfs_mount        *mp,
98         xfs_agnumber_t          ag,
99         int                     (*execute)(struct xfs_inode *ip,
100                                            struct xfs_perag *pag, int flags),
101         int                     flags,
102         int                     tag)
103 {
104         struct xfs_perag        *pag = &mp->m_perag[ag];
105         uint32_t                first_index;
106         int                     last_error = 0;
107         int                     skipped;
108
109 restart:
110         skipped = 0;
111         first_index = 0;
112         do {
113                 int             error = 0;
114                 xfs_inode_t     *ip;
115
116                 ip = xfs_inode_ag_lookup(mp, pag, &first_index, tag);
117                 if (!ip)
118                         break;
119
120                 error = execute(ip, pag, flags);
121                 if (error == EAGAIN) {
122                         skipped++;
123                         continue;
124                 }
125                 if (error)
126                         last_error = error;
127                 /*
128                  * bail out if the filesystem is corrupted.
129                  */
130                 if (error == EFSCORRUPTED)
131                         break;
132
133         } while (1);
134
135         if (skipped) {
136                 delay(1);
137                 goto restart;
138         }
139
140         xfs_put_perag(mp, pag);
141         return last_error;
142 }
143
144 int
145 xfs_inode_ag_iterator(
146         struct xfs_mount        *mp,
147         int                     (*execute)(struct xfs_inode *ip,
148                                            struct xfs_perag *pag, int flags),
149         int                     flags,
150         int                     tag)
151 {
152         int                     error = 0;
153         int                     last_error = 0;
154         xfs_agnumber_t          ag;
155
156         for (ag = 0; ag < mp->m_sb.sb_agcount; ag++) {
157                 if (!mp->m_perag[ag].pag_ici_init)
158                         continue;
159                 error = xfs_inode_ag_walk(mp, ag, execute, flags, tag);
160                 if (error) {
161                         last_error = error;
162                         if (error == EFSCORRUPTED)
163                                 break;
164                 }
165         }
166         return XFS_ERROR(last_error);
167 }
168
169 /* must be called with pag_ici_lock held and releases it */
170 int
171 xfs_sync_inode_valid(
172         struct xfs_inode        *ip,
173         struct xfs_perag        *pag)
174 {
175         struct inode            *inode = VFS_I(ip);
176
177         /* nothing to sync during shutdown */
178         if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
179                 read_unlock(&pag->pag_ici_lock);
180                 return EFSCORRUPTED;
181         }
182
183         /*
184          * If we can't get a reference on the inode, it must be in reclaim.
185          * Leave it for the reclaim code to flush. Also avoid inodes that
186          * haven't been fully initialised.
187          */
188         if (!igrab(inode)) {
189                 read_unlock(&pag->pag_ici_lock);
190                 return ENOENT;
191         }
192         read_unlock(&pag->pag_ici_lock);
193
194         if (is_bad_inode(inode) || xfs_iflags_test(ip, XFS_INEW)) {
195                 IRELE(ip);
196                 return ENOENT;
197         }
198
199         return 0;
200 }
201
202 STATIC int
203 xfs_sync_inode_data(
204         struct xfs_inode        *ip,
205         struct xfs_perag        *pag,
206         int                     flags)
207 {
208         struct inode            *inode = VFS_I(ip);
209         struct address_space *mapping = inode->i_mapping;
210         int                     error = 0;
211
212         error = xfs_sync_inode_valid(ip, pag);
213         if (error)
214                 return error;
215
216         if (!mapping_tagged(mapping, PAGECACHE_TAG_DIRTY))
217                 goto out_wait;
218
219         if (!xfs_ilock_nowait(ip, XFS_IOLOCK_SHARED)) {
220                 if (flags & SYNC_TRYLOCK)
221                         goto out_wait;
222                 xfs_ilock(ip, XFS_IOLOCK_SHARED);
223         }
224
225         error = xfs_flush_pages(ip, 0, -1, (flags & SYNC_WAIT) ?
226                                 0 : XFS_B_ASYNC, FI_NONE);
227         xfs_iunlock(ip, XFS_IOLOCK_SHARED);
228
229  out_wait:
230         if (flags & SYNC_WAIT)
231                 xfs_ioend_wait(ip);
232         IRELE(ip);
233         return error;
234 }
235
236 STATIC int
237 xfs_sync_inode_attr(
238         struct xfs_inode        *ip,
239         struct xfs_perag        *pag,
240         int                     flags)
241 {
242         int                     error = 0;
243
244         error = xfs_sync_inode_valid(ip, pag);
245         if (error)
246                 return error;
247
248         xfs_ilock(ip, XFS_ILOCK_SHARED);
249         if (xfs_inode_clean(ip))
250                 goto out_unlock;
251         if (!xfs_iflock_nowait(ip)) {
252                 if (!(flags & SYNC_WAIT))
253                         goto out_unlock;
254                 xfs_iflock(ip);
255         }
256
257         if (xfs_inode_clean(ip)) {
258                 xfs_ifunlock(ip);
259                 goto out_unlock;
260         }
261
262         error = xfs_iflush(ip, (flags & SYNC_WAIT) ?
263                            XFS_IFLUSH_SYNC : XFS_IFLUSH_DELWRI);
264
265  out_unlock:
266         xfs_iunlock(ip, XFS_ILOCK_SHARED);
267         IRELE(ip);
268         return error;
269 }
270
271 /*
272  * Write out pagecache data for the whole filesystem.
273  */
274 int
275 xfs_sync_data(
276         struct xfs_mount        *mp,
277         int                     flags)
278 {
279         int                     error;
280
281         ASSERT((flags & ~(SYNC_TRYLOCK|SYNC_WAIT)) == 0);
282
283         error = xfs_inode_ag_iterator(mp, xfs_sync_inode_data, flags,
284                                       XFS_ICI_NO_TAG);
285         if (error)
286                 return XFS_ERROR(error);
287
288         xfs_log_force(mp, 0,
289                       (flags & SYNC_WAIT) ?
290                        XFS_LOG_FORCE | XFS_LOG_SYNC :
291                        XFS_LOG_FORCE);
292         return 0;
293 }
294
295 /*
296  * Write out inode metadata (attributes) for the whole filesystem.
297  */
298 int
299 xfs_sync_attr(
300         struct xfs_mount        *mp,
301         int                     flags)
302 {
303         ASSERT((flags & ~SYNC_WAIT) == 0);
304
305         return xfs_inode_ag_iterator(mp, xfs_sync_inode_attr, flags,
306                                      XFS_ICI_NO_TAG);
307 }
308
309 STATIC int
310 xfs_commit_dummy_trans(
311         struct xfs_mount        *mp,
312         uint                    flags)
313 {
314         struct xfs_inode        *ip = mp->m_rootip;
315         struct xfs_trans        *tp;
316         int                     error;
317         int                     log_flags = XFS_LOG_FORCE;
318
319         if (flags & SYNC_WAIT)
320                 log_flags |= XFS_LOG_SYNC;
321
322         /*
323          * Put a dummy transaction in the log to tell recovery
324          * that all others are OK.
325          */
326         tp = xfs_trans_alloc(mp, XFS_TRANS_DUMMY1);
327         error = xfs_trans_reserve(tp, 0, XFS_ICHANGE_LOG_RES(mp), 0, 0, 0);
328         if (error) {
329                 xfs_trans_cancel(tp, 0);
330                 return error;
331         }
332
333         xfs_ilock(ip, XFS_ILOCK_EXCL);
334
335         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
336         xfs_trans_ihold(tp, ip);
337         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
338         error = xfs_trans_commit(tp, 0);
339         xfs_iunlock(ip, XFS_ILOCK_EXCL);
340
341         /* the log force ensures this transaction is pushed to disk */
342         xfs_log_force(mp, 0, log_flags);
343         return error;
344 }
345
346 int
347 xfs_sync_fsdata(
348         struct xfs_mount        *mp,
349         int                     flags)
350 {
351         struct xfs_buf          *bp;
352         struct xfs_buf_log_item *bip;
353         int                     error = 0;
354
355         /*
356          * If this is xfssyncd() then only sync the superblock if we can
357          * lock it without sleeping and it is not pinned.
358          */
359         if (flags & SYNC_TRYLOCK) {
360                 ASSERT(!(flags & SYNC_WAIT));
361
362                 bp = xfs_getsb(mp, XFS_BUF_TRYLOCK);
363                 if (!bp)
364                         goto out;
365
366                 bip = XFS_BUF_FSPRIVATE(bp, struct xfs_buf_log_item *);
367                 if (!bip || !xfs_buf_item_dirty(bip) || XFS_BUF_ISPINNED(bp))
368                         goto out_brelse;
369         } else {
370                 bp = xfs_getsb(mp, 0);
371
372                 /*
373                  * If the buffer is pinned then push on the log so we won't
374                  * get stuck waiting in the write for someone, maybe
375                  * ourselves, to flush the log.
376                  *
377                  * Even though we just pushed the log above, we did not have
378                  * the superblock buffer locked at that point so it can
379                  * become pinned in between there and here.
380                  */
381                 if (XFS_BUF_ISPINNED(bp))
382                         xfs_log_force(mp, 0, XFS_LOG_FORCE);
383         }
384
385
386         if (flags & SYNC_WAIT)
387                 XFS_BUF_UNASYNC(bp);
388         else
389                 XFS_BUF_ASYNC(bp);
390
391         error = xfs_bwrite(mp, bp);
392         if (error)
393                 return error;
394
395         /*
396          * If this is a data integrity sync make sure all pending buffers
397          * are flushed out for the log coverage check below.
398          */
399         if (flags & SYNC_WAIT)
400                 xfs_flush_buftarg(mp->m_ddev_targp, 1);
401
402         if (xfs_log_need_covered(mp))
403                 error = xfs_commit_dummy_trans(mp, flags);
404         return error;
405
406  out_brelse:
407         xfs_buf_relse(bp);
408  out:
409         return error;
410 }
411
412 /*
413  * When remounting a filesystem read-only or freezing the filesystem, we have
414  * two phases to execute. This first phase is syncing the data before we
415  * quiesce the filesystem, and the second is flushing all the inodes out after
416  * we've waited for all the transactions created by the first phase to
417  * complete. The second phase ensures that the inodes are written to their
418  * location on disk rather than just existing in transactions in the log. This
419  * means after a quiesce there is no log replay required to write the inodes to
420  * disk (this is the main difference between a sync and a quiesce).
421  */
422 /*
423  * First stage of freeze - no writers will make progress now we are here,
424  * so we flush delwri and delalloc buffers here, then wait for all I/O to
425  * complete.  Data is frozen at that point. Metadata is not frozen,
426  * transactions can still occur here so don't bother flushing the buftarg
427  * because it'll just get dirty again.
428  */
429 int
430 xfs_quiesce_data(
431         struct xfs_mount        *mp)
432 {
433         int error;
434
435         /* push non-blocking */
436         xfs_sync_data(mp, 0);
437         xfs_qm_sync(mp, SYNC_TRYLOCK);
438
439         /* push and block till complete */
440         xfs_sync_data(mp, SYNC_WAIT);
441         xfs_qm_sync(mp, SYNC_WAIT);
442
443         /* drop inode references pinned by filestreams */
444         xfs_filestream_flush(mp);
445
446         /* write superblock and hoover up shutdown errors */
447         error = xfs_sync_fsdata(mp, SYNC_WAIT);
448
449         /* flush data-only devices */
450         if (mp->m_rtdev_targp)
451                 XFS_bflush(mp->m_rtdev_targp);
452
453         return error;
454 }
455
456 STATIC void
457 xfs_quiesce_fs(
458         struct xfs_mount        *mp)
459 {
460         int     count = 0, pincount;
461
462         xfs_flush_buftarg(mp->m_ddev_targp, 0);
463         xfs_reclaim_inodes(mp, XFS_IFLUSH_DELWRI_ELSE_ASYNC);
464
465         /*
466          * This loop must run at least twice.  The first instance of the loop
467          * will flush most meta data but that will generate more meta data
468          * (typically directory updates).  Which then must be flushed and
469          * logged before we can write the unmount record.
470          */
471         do {
472                 xfs_sync_attr(mp, SYNC_WAIT);
473                 pincount = xfs_flush_buftarg(mp->m_ddev_targp, 1);
474                 if (!pincount) {
475                         delay(50);
476                         count++;
477                 }
478         } while (count < 2);
479 }
480
481 /*
482  * Second stage of a quiesce. The data is already synced, now we have to take
483  * care of the metadata. New transactions are already blocked, so we need to
484  * wait for any remaining transactions to drain out before proceding.
485  */
486 void
487 xfs_quiesce_attr(
488         struct xfs_mount        *mp)
489 {
490         int     error = 0;
491
492         /* wait for all modifications to complete */
493         while (atomic_read(&mp->m_active_trans) > 0)
494                 delay(100);
495
496         /* flush inodes and push all remaining buffers out to disk */
497         xfs_quiesce_fs(mp);
498
499         /*
500          * Just warn here till VFS can correctly support
501          * read-only remount without racing.
502          */
503         WARN_ON(atomic_read(&mp->m_active_trans) != 0);
504
505         /* Push the superblock and write an unmount record */
506         error = xfs_log_sbcount(mp, 1);
507         if (error)
508                 xfs_fs_cmn_err(CE_WARN, mp,
509                                 "xfs_attr_quiesce: failed to log sb changes. "
510                                 "Frozen image may not be consistent.");
511         xfs_log_unmount_write(mp);
512         xfs_unmountfs_writesb(mp);
513 }
514
515 /*
516  * Enqueue a work item to be picked up by the vfs xfssyncd thread.
517  * Doing this has two advantages:
518  * - It saves on stack space, which is tight in certain situations
519  * - It can be used (with care) as a mechanism to avoid deadlocks.
520  * Flushing while allocating in a full filesystem requires both.
521  */
522 STATIC void
523 xfs_syncd_queue_work(
524         struct xfs_mount *mp,
525         void            *data,
526         void            (*syncer)(struct xfs_mount *, void *),
527         struct completion *completion)
528 {
529         struct xfs_sync_work *work;
530
531         work = kmem_alloc(sizeof(struct xfs_sync_work), KM_SLEEP);
532         INIT_LIST_HEAD(&work->w_list);
533         work->w_syncer = syncer;
534         work->w_data = data;
535         work->w_mount = mp;
536         work->w_completion = completion;
537         spin_lock(&mp->m_sync_lock);
538         list_add_tail(&work->w_list, &mp->m_sync_list);
539         spin_unlock(&mp->m_sync_lock);
540         wake_up_process(mp->m_sync_task);
541 }
542
543 /*
544  * Flush delayed allocate data, attempting to free up reserved space
545  * from existing allocations.  At this point a new allocation attempt
546  * has failed with ENOSPC and we are in the process of scratching our
547  * heads, looking about for more room...
548  */
549 STATIC void
550 xfs_flush_inodes_work(
551         struct xfs_mount *mp,
552         void            *arg)
553 {
554         struct inode    *inode = arg;
555         xfs_sync_data(mp, SYNC_TRYLOCK);
556         xfs_sync_data(mp, SYNC_TRYLOCK | SYNC_WAIT);
557         iput(inode);
558 }
559
560 void
561 xfs_flush_inodes(
562         xfs_inode_t     *ip)
563 {
564         struct inode    *inode = VFS_I(ip);
565         DECLARE_COMPLETION_ONSTACK(completion);
566
567         igrab(inode);
568         xfs_syncd_queue_work(ip->i_mount, inode, xfs_flush_inodes_work, &completion);
569         wait_for_completion(&completion);
570         xfs_log_force(ip->i_mount, (xfs_lsn_t)0, XFS_LOG_FORCE|XFS_LOG_SYNC);
571 }
572
573 /*
574  * Every sync period we need to unpin all items, reclaim inodes, sync
575  * quota and write out the superblock. We might need to cover the log
576  * to indicate it is idle.
577  */
578 STATIC void
579 xfs_sync_worker(
580         struct xfs_mount *mp,
581         void            *unused)
582 {
583         int             error;
584
585         if (!(mp->m_flags & XFS_MOUNT_RDONLY)) {
586                 xfs_log_force(mp, (xfs_lsn_t)0, XFS_LOG_FORCE);
587                 xfs_reclaim_inodes(mp, XFS_IFLUSH_DELWRI_ELSE_ASYNC);
588                 /* dgc: errors ignored here */
589                 error = xfs_qm_sync(mp, SYNC_TRYLOCK);
590                 error = xfs_sync_fsdata(mp, SYNC_TRYLOCK);
591         }
592         mp->m_sync_seq++;
593         wake_up(&mp->m_wait_single_sync_task);
594 }
595
596 STATIC int
597 xfssyncd(
598         void                    *arg)
599 {
600         struct xfs_mount        *mp = arg;
601         long                    timeleft;
602         xfs_sync_work_t         *work, *n;
603         LIST_HEAD               (tmp);
604
605         set_freezable();
606         timeleft = xfs_syncd_centisecs * msecs_to_jiffies(10);
607         for (;;) {
608                 timeleft = schedule_timeout_interruptible(timeleft);
609                 /* swsusp */
610                 try_to_freeze();
611                 if (kthread_should_stop() && list_empty(&mp->m_sync_list))
612                         break;
613
614                 spin_lock(&mp->m_sync_lock);
615                 /*
616                  * We can get woken by laptop mode, to do a sync -
617                  * that's the (only!) case where the list would be
618                  * empty with time remaining.
619                  */
620                 if (!timeleft || list_empty(&mp->m_sync_list)) {
621                         if (!timeleft)
622                                 timeleft = xfs_syncd_centisecs *
623                                                         msecs_to_jiffies(10);
624                         INIT_LIST_HEAD(&mp->m_sync_work.w_list);
625                         list_add_tail(&mp->m_sync_work.w_list,
626                                         &mp->m_sync_list);
627                 }
628                 list_for_each_entry_safe(work, n, &mp->m_sync_list, w_list)
629                         list_move(&work->w_list, &tmp);
630                 spin_unlock(&mp->m_sync_lock);
631
632                 list_for_each_entry_safe(work, n, &tmp, w_list) {
633                         (*work->w_syncer)(mp, work->w_data);
634                         list_del(&work->w_list);
635                         if (work == &mp->m_sync_work)
636                                 continue;
637                         if (work->w_completion)
638                                 complete(work->w_completion);
639                         kmem_free(work);
640                 }
641         }
642
643         return 0;
644 }
645
646 int
647 xfs_syncd_init(
648         struct xfs_mount        *mp)
649 {
650         mp->m_sync_work.w_syncer = xfs_sync_worker;
651         mp->m_sync_work.w_mount = mp;
652         mp->m_sync_work.w_completion = NULL;
653         mp->m_sync_task = kthread_run(xfssyncd, mp, "xfssyncd");
654         if (IS_ERR(mp->m_sync_task))
655                 return -PTR_ERR(mp->m_sync_task);
656         return 0;
657 }
658
659 void
660 xfs_syncd_stop(
661         struct xfs_mount        *mp)
662 {
663         kthread_stop(mp->m_sync_task);
664 }
665
666 STATIC int
667 xfs_reclaim_inode(
668         xfs_inode_t     *ip,
669         int             sync_mode)
670 {
671         xfs_perag_t     *pag = xfs_get_perag(ip->i_mount, ip->i_ino);
672
673         /* The hash lock here protects a thread in xfs_iget_core from
674          * racing with us on linking the inode back with a vnode.
675          * Once we have the XFS_IRECLAIM flag set it will not touch
676          * us.
677          */
678         write_lock(&pag->pag_ici_lock);
679         spin_lock(&ip->i_flags_lock);
680         if (__xfs_iflags_test(ip, XFS_IRECLAIM) ||
681             !__xfs_iflags_test(ip, XFS_IRECLAIMABLE)) {
682                 spin_unlock(&ip->i_flags_lock);
683                 write_unlock(&pag->pag_ici_lock);
684                 return -EAGAIN;
685         }
686         __xfs_iflags_set(ip, XFS_IRECLAIM);
687         spin_unlock(&ip->i_flags_lock);
688         write_unlock(&pag->pag_ici_lock);
689         xfs_put_perag(ip->i_mount, pag);
690
691         /*
692          * If the inode is still dirty, then flush it out.  If the inode
693          * is not in the AIL, then it will be OK to flush it delwri as
694          * long as xfs_iflush() does not keep any references to the inode.
695          * We leave that decision up to xfs_iflush() since it has the
696          * knowledge of whether it's OK to simply do a delwri flush of
697          * the inode or whether we need to wait until the inode is
698          * pulled from the AIL.
699          * We get the flush lock regardless, though, just to make sure
700          * we don't free it while it is being flushed.
701          */
702         xfs_ilock(ip, XFS_ILOCK_EXCL);
703         xfs_iflock(ip);
704
705         /*
706          * In the case of a forced shutdown we rely on xfs_iflush() to
707          * wait for the inode to be unpinned before returning an error.
708          */
709         if (!is_bad_inode(VFS_I(ip)) && xfs_iflush(ip, sync_mode) == 0) {
710                 /* synchronize with xfs_iflush_done */
711                 xfs_iflock(ip);
712                 xfs_ifunlock(ip);
713         }
714
715         xfs_iunlock(ip, XFS_ILOCK_EXCL);
716         xfs_ireclaim(ip);
717         return 0;
718 }
719
720 void
721 __xfs_inode_set_reclaim_tag(
722         struct xfs_perag        *pag,
723         struct xfs_inode        *ip)
724 {
725         radix_tree_tag_set(&pag->pag_ici_root,
726                            XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino),
727                            XFS_ICI_RECLAIM_TAG);
728 }
729
730 /*
731  * We set the inode flag atomically with the radix tree tag.
732  * Once we get tag lookups on the radix tree, this inode flag
733  * can go away.
734  */
735 void
736 xfs_inode_set_reclaim_tag(
737         xfs_inode_t     *ip)
738 {
739         xfs_mount_t     *mp = ip->i_mount;
740         xfs_perag_t     *pag = xfs_get_perag(mp, ip->i_ino);
741
742         read_lock(&pag->pag_ici_lock);
743         spin_lock(&ip->i_flags_lock);
744         __xfs_inode_set_reclaim_tag(pag, ip);
745         __xfs_iflags_set(ip, XFS_IRECLAIMABLE);
746         spin_unlock(&ip->i_flags_lock);
747         read_unlock(&pag->pag_ici_lock);
748         xfs_put_perag(mp, pag);
749 }
750
751 void
752 __xfs_inode_clear_reclaim_tag(
753         xfs_mount_t     *mp,
754         xfs_perag_t     *pag,
755         xfs_inode_t     *ip)
756 {
757         radix_tree_tag_clear(&pag->pag_ici_root,
758                         XFS_INO_TO_AGINO(mp, ip->i_ino), XFS_ICI_RECLAIM_TAG);
759 }
760
761 STATIC int
762 xfs_reclaim_inode_now(
763         struct xfs_inode        *ip,
764         struct xfs_perag        *pag,
765         int                     flags)
766 {
767         /* ignore if already under reclaim */
768         if (xfs_iflags_test(ip, XFS_IRECLAIM)) {
769                 read_unlock(&pag->pag_ici_lock);
770                 return 0;
771         }
772         read_unlock(&pag->pag_ici_lock);
773
774         return xfs_reclaim_inode(ip, flags);
775 }
776
777 int
778 xfs_reclaim_inodes(
779         xfs_mount_t     *mp,
780         int             mode)
781 {
782         return xfs_inode_ag_iterator(mp, xfs_reclaim_inode_now, mode,
783                                         XFS_ICI_RECLAIM_TAG);
784 }