xfs: drop dmapi hooks
[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_mount.h"
29 #include "xfs_bmap_btree.h"
30 #include "xfs_alloc_btree.h"
31 #include "xfs_ialloc_btree.h"
32 #include "xfs_btree.h"
33 #include "xfs_dir2_sf.h"
34 #include "xfs_attr_sf.h"
35 #include "xfs_inode.h"
36 #include "xfs_dinode.h"
37 #include "xfs_error.h"
38 #include "xfs_mru_cache.h"
39 #include "xfs_filestream.h"
40 #include "xfs_vnodeops.h"
41 #include "xfs_utils.h"
42 #include "xfs_buf_item.h"
43 #include "xfs_inode_item.h"
44 #include "xfs_rw.h"
45 #include "xfs_quota.h"
46 #include "xfs_trace.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         if (tag == XFS_ICI_NO_TAG) {
68                 nr_found = radix_tree_gang_lookup(&pag->pag_ici_root,
69                                 (void **)&ip, *first_index, 1);
70         } else {
71                 nr_found = radix_tree_gang_lookup_tag(&pag->pag_ici_root,
72                                 (void **)&ip, *first_index, 1, tag);
73         }
74         if (!nr_found)
75                 return NULL;
76
77         /*
78          * Update the index for the next lookup. Catch overflows
79          * into the next AG range which can occur if we have inodes
80          * in the last block of the AG and we are currently
81          * pointing to the last inode.
82          */
83         *first_index = XFS_INO_TO_AGINO(mp, ip->i_ino + 1);
84         if (*first_index < XFS_INO_TO_AGINO(mp, ip->i_ino))
85                 return NULL;
86         return ip;
87 }
88
89 STATIC int
90 xfs_inode_ag_walk(
91         struct xfs_mount        *mp,
92         struct xfs_perag        *pag,
93         int                     (*execute)(struct xfs_inode *ip,
94                                            struct xfs_perag *pag, int flags),
95         int                     flags,
96         int                     tag,
97         int                     exclusive,
98         int                     *nr_to_scan)
99 {
100         uint32_t                first_index;
101         int                     last_error = 0;
102         int                     skipped;
103
104 restart:
105         skipped = 0;
106         first_index = 0;
107         do {
108                 int             error = 0;
109                 xfs_inode_t     *ip;
110
111                 if (exclusive)
112                         write_lock(&pag->pag_ici_lock);
113                 else
114                         read_lock(&pag->pag_ici_lock);
115                 ip = xfs_inode_ag_lookup(mp, pag, &first_index, tag);
116                 if (!ip) {
117                         if (exclusive)
118                                 write_unlock(&pag->pag_ici_lock);
119                         else
120                                 read_unlock(&pag->pag_ici_lock);
121                         break;
122                 }
123
124                 /* execute releases pag->pag_ici_lock */
125                 error = execute(ip, pag, flags);
126                 if (error == EAGAIN) {
127                         skipped++;
128                         continue;
129                 }
130                 if (error)
131                         last_error = error;
132
133                 /* bail out if the filesystem is corrupted.  */
134                 if (error == EFSCORRUPTED)
135                         break;
136
137         } while ((*nr_to_scan)--);
138
139         if (skipped) {
140                 delay(1);
141                 goto restart;
142         }
143         return last_error;
144 }
145
146 /*
147  * Select the next per-ag structure to iterate during the walk. The reclaim
148  * walk is optimised only to walk AGs with reclaimable inodes in them.
149  */
150 static struct xfs_perag *
151 xfs_inode_ag_iter_next_pag(
152         struct xfs_mount        *mp,
153         xfs_agnumber_t          *first,
154         int                     tag)
155 {
156         struct xfs_perag        *pag = NULL;
157
158         if (tag == XFS_ICI_RECLAIM_TAG) {
159                 int found;
160                 int ref;
161
162                 spin_lock(&mp->m_perag_lock);
163                 found = radix_tree_gang_lookup_tag(&mp->m_perag_tree,
164                                 (void **)&pag, *first, 1, tag);
165                 if (found <= 0) {
166                         spin_unlock(&mp->m_perag_lock);
167                         return NULL;
168                 }
169                 *first = pag->pag_agno + 1;
170                 /* open coded pag reference increment */
171                 ref = atomic_inc_return(&pag->pag_ref);
172                 spin_unlock(&mp->m_perag_lock);
173                 trace_xfs_perag_get_reclaim(mp, pag->pag_agno, ref, _RET_IP_);
174         } else {
175                 pag = xfs_perag_get(mp, *first);
176                 (*first)++;
177         }
178         return pag;
179 }
180
181 int
182 xfs_inode_ag_iterator(
183         struct xfs_mount        *mp,
184         int                     (*execute)(struct xfs_inode *ip,
185                                            struct xfs_perag *pag, int flags),
186         int                     flags,
187         int                     tag,
188         int                     exclusive,
189         int                     *nr_to_scan)
190 {
191         struct xfs_perag        *pag;
192         int                     error = 0;
193         int                     last_error = 0;
194         xfs_agnumber_t          ag;
195         int                     nr;
196
197         nr = nr_to_scan ? *nr_to_scan : INT_MAX;
198         ag = 0;
199         while ((pag = xfs_inode_ag_iter_next_pag(mp, &ag, tag))) {
200                 error = xfs_inode_ag_walk(mp, pag, execute, flags, tag,
201                                                 exclusive, &nr);
202                 xfs_perag_put(pag);
203                 if (error) {
204                         last_error = error;
205                         if (error == EFSCORRUPTED)
206                                 break;
207                 }
208                 if (nr <= 0)
209                         break;
210         }
211         if (nr_to_scan)
212                 *nr_to_scan = nr;
213         return XFS_ERROR(last_error);
214 }
215
216 /* must be called with pag_ici_lock held and releases it */
217 int
218 xfs_sync_inode_valid(
219         struct xfs_inode        *ip,
220         struct xfs_perag        *pag)
221 {
222         struct inode            *inode = VFS_I(ip);
223         int                     error = EFSCORRUPTED;
224
225         /* nothing to sync during shutdown */
226         if (XFS_FORCED_SHUTDOWN(ip->i_mount))
227                 goto out_unlock;
228
229         /* avoid new or reclaimable inodes. Leave for reclaim code to flush */
230         error = ENOENT;
231         if (xfs_iflags_test(ip, XFS_INEW | XFS_IRECLAIMABLE | XFS_IRECLAIM))
232                 goto out_unlock;
233
234         /* If we can't grab the inode, it must on it's way to reclaim. */
235         if (!igrab(inode))
236                 goto out_unlock;
237
238         if (is_bad_inode(inode)) {
239                 IRELE(ip);
240                 goto out_unlock;
241         }
242
243         /* inode is valid */
244         error = 0;
245 out_unlock:
246         read_unlock(&pag->pag_ici_lock);
247         return error;
248 }
249
250 STATIC int
251 xfs_sync_inode_data(
252         struct xfs_inode        *ip,
253         struct xfs_perag        *pag,
254         int                     flags)
255 {
256         struct inode            *inode = VFS_I(ip);
257         struct address_space *mapping = inode->i_mapping;
258         int                     error = 0;
259
260         error = xfs_sync_inode_valid(ip, pag);
261         if (error)
262                 return error;
263
264         if (!mapping_tagged(mapping, PAGECACHE_TAG_DIRTY))
265                 goto out_wait;
266
267         if (!xfs_ilock_nowait(ip, XFS_IOLOCK_SHARED)) {
268                 if (flags & SYNC_TRYLOCK)
269                         goto out_wait;
270                 xfs_ilock(ip, XFS_IOLOCK_SHARED);
271         }
272
273         error = xfs_flush_pages(ip, 0, -1, (flags & SYNC_WAIT) ?
274                                 0 : XBF_ASYNC, FI_NONE);
275         xfs_iunlock(ip, XFS_IOLOCK_SHARED);
276
277  out_wait:
278         if (flags & SYNC_WAIT)
279                 xfs_ioend_wait(ip);
280         IRELE(ip);
281         return error;
282 }
283
284 STATIC int
285 xfs_sync_inode_attr(
286         struct xfs_inode        *ip,
287         struct xfs_perag        *pag,
288         int                     flags)
289 {
290         int                     error = 0;
291
292         error = xfs_sync_inode_valid(ip, pag);
293         if (error)
294                 return error;
295
296         xfs_ilock(ip, XFS_ILOCK_SHARED);
297         if (xfs_inode_clean(ip))
298                 goto out_unlock;
299         if (!xfs_iflock_nowait(ip)) {
300                 if (!(flags & SYNC_WAIT))
301                         goto out_unlock;
302                 xfs_iflock(ip);
303         }
304
305         if (xfs_inode_clean(ip)) {
306                 xfs_ifunlock(ip);
307                 goto out_unlock;
308         }
309
310         error = xfs_iflush(ip, flags);
311
312  out_unlock:
313         xfs_iunlock(ip, XFS_ILOCK_SHARED);
314         IRELE(ip);
315         return error;
316 }
317
318 /*
319  * Write out pagecache data for the whole filesystem.
320  */
321 int
322 xfs_sync_data(
323         struct xfs_mount        *mp,
324         int                     flags)
325 {
326         int                     error;
327
328         ASSERT((flags & ~(SYNC_TRYLOCK|SYNC_WAIT)) == 0);
329
330         error = xfs_inode_ag_iterator(mp, xfs_sync_inode_data, flags,
331                                       XFS_ICI_NO_TAG, 0, NULL);
332         if (error)
333                 return XFS_ERROR(error);
334
335         xfs_log_force(mp, (flags & SYNC_WAIT) ? XFS_LOG_SYNC : 0);
336         return 0;
337 }
338
339 /*
340  * Write out inode metadata (attributes) for the whole filesystem.
341  */
342 int
343 xfs_sync_attr(
344         struct xfs_mount        *mp,
345         int                     flags)
346 {
347         ASSERT((flags & ~SYNC_WAIT) == 0);
348
349         return xfs_inode_ag_iterator(mp, xfs_sync_inode_attr, flags,
350                                      XFS_ICI_NO_TAG, 0, NULL);
351 }
352
353 STATIC int
354 xfs_commit_dummy_trans(
355         struct xfs_mount        *mp,
356         uint                    flags)
357 {
358         struct xfs_inode        *ip = mp->m_rootip;
359         struct xfs_trans        *tp;
360         int                     error;
361
362         /*
363          * Put a dummy transaction in the log to tell recovery
364          * that all others are OK.
365          */
366         tp = xfs_trans_alloc(mp, XFS_TRANS_DUMMY1);
367         error = xfs_trans_reserve(tp, 0, XFS_ICHANGE_LOG_RES(mp), 0, 0, 0);
368         if (error) {
369                 xfs_trans_cancel(tp, 0);
370                 return error;
371         }
372
373         xfs_ilock(ip, XFS_ILOCK_EXCL);
374
375         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
376         xfs_trans_ihold(tp, ip);
377         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
378         error = xfs_trans_commit(tp, 0);
379         xfs_iunlock(ip, XFS_ILOCK_EXCL);
380
381         /* the log force ensures this transaction is pushed to disk */
382         xfs_log_force(mp, (flags & SYNC_WAIT) ? XFS_LOG_SYNC : 0);
383         return error;
384 }
385
386 STATIC int
387 xfs_sync_fsdata(
388         struct xfs_mount        *mp)
389 {
390         struct xfs_buf          *bp;
391
392         /*
393          * If the buffer is pinned then push on the log so we won't get stuck
394          * waiting in the write for someone, maybe ourselves, to flush the log.
395          *
396          * Even though we just pushed the log above, we did not have the
397          * superblock buffer locked at that point so it can become pinned in
398          * between there and here.
399          */
400         bp = xfs_getsb(mp, 0);
401         if (XFS_BUF_ISPINNED(bp))
402                 xfs_log_force(mp, 0);
403
404         return xfs_bwrite(mp, bp);
405 }
406
407 /*
408  * When remounting a filesystem read-only or freezing the filesystem, we have
409  * two phases to execute. This first phase is syncing the data before we
410  * quiesce the filesystem, and the second is flushing all the inodes out after
411  * we've waited for all the transactions created by the first phase to
412  * complete. The second phase ensures that the inodes are written to their
413  * location on disk rather than just existing in transactions in the log. This
414  * means after a quiesce there is no log replay required to write the inodes to
415  * disk (this is the main difference between a sync and a quiesce).
416  */
417 /*
418  * First stage of freeze - no writers will make progress now we are here,
419  * so we flush delwri and delalloc buffers here, then wait for all I/O to
420  * complete.  Data is frozen at that point. Metadata is not frozen,
421  * transactions can still occur here so don't bother flushing the buftarg
422  * because it'll just get dirty again.
423  */
424 int
425 xfs_quiesce_data(
426         struct xfs_mount        *mp)
427 {
428         int                     error, error2 = 0;
429
430         /* push non-blocking */
431         xfs_sync_data(mp, 0);
432         xfs_qm_sync(mp, SYNC_TRYLOCK);
433
434         /* push and block till complete */
435         xfs_sync_data(mp, SYNC_WAIT);
436         xfs_qm_sync(mp, SYNC_WAIT);
437
438         /* write superblock and hoover up shutdown errors */
439         error = xfs_sync_fsdata(mp);
440
441         /* make sure all delwri buffers are written out */
442         xfs_flush_buftarg(mp->m_ddev_targp, 1);
443
444         /* mark the log as covered if needed */
445         if (xfs_log_need_covered(mp))
446                 error2 = xfs_commit_dummy_trans(mp, SYNC_WAIT);
447
448         /* flush data-only devices */
449         if (mp->m_rtdev_targp)
450                 XFS_bflush(mp->m_rtdev_targp);
451
452         return error ? error : error2;
453 }
454
455 STATIC void
456 xfs_quiesce_fs(
457         struct xfs_mount        *mp)
458 {
459         int     count = 0, pincount;
460
461         xfs_reclaim_inodes(mp, 0);
462         xfs_flush_buftarg(mp->m_ddev_targp, 0);
463
464         /*
465          * This loop must run at least twice.  The first instance of the loop
466          * will flush most meta data but that will generate more meta data
467          * (typically directory updates).  Which then must be flushed and
468          * logged before we can write the unmount record. We also so sync
469          * reclaim of inodes to catch any that the above delwri flush skipped.
470          */
471         do {
472                 xfs_reclaim_inodes(mp, SYNC_WAIT);
473                 xfs_sync_attr(mp, SYNC_WAIT);
474                 pincount = xfs_flush_buftarg(mp->m_ddev_targp, 1);
475                 if (!pincount) {
476                         delay(50);
477                         count++;
478                 }
479         } while (count < 2);
480 }
481
482 /*
483  * Second stage of a quiesce. The data is already synced, now we have to take
484  * care of the metadata. New transactions are already blocked, so we need to
485  * wait for any remaining transactions to drain out before proceding.
486  */
487 void
488 xfs_quiesce_attr(
489         struct xfs_mount        *mp)
490 {
491         int     error = 0;
492
493         /* wait for all modifications to complete */
494         while (atomic_read(&mp->m_active_trans) > 0)
495                 delay(100);
496
497         /* flush inodes and push all remaining buffers out to disk */
498         xfs_quiesce_fs(mp);
499
500         /*
501          * Just warn here till VFS can correctly support
502          * read-only remount without racing.
503          */
504         WARN_ON(atomic_read(&mp->m_active_trans) != 0);
505
506         /* Push the superblock and write an unmount record */
507         error = xfs_log_sbcount(mp, 1);
508         if (error)
509                 xfs_fs_cmn_err(CE_WARN, mp,
510                                 "xfs_attr_quiesce: failed to log sb changes. "
511                                 "Frozen image may not be consistent.");
512         xfs_log_unmount_write(mp);
513         xfs_unmountfs_writesb(mp);
514 }
515
516 /*
517  * Enqueue a work item to be picked up by the vfs xfssyncd thread.
518  * Doing this has two advantages:
519  * - It saves on stack space, which is tight in certain situations
520  * - It can be used (with care) as a mechanism to avoid deadlocks.
521  * Flushing while allocating in a full filesystem requires both.
522  */
523 STATIC void
524 xfs_syncd_queue_work(
525         struct xfs_mount *mp,
526         void            *data,
527         void            (*syncer)(struct xfs_mount *, void *),
528         struct completion *completion)
529 {
530         struct xfs_sync_work *work;
531
532         work = kmem_alloc(sizeof(struct xfs_sync_work), KM_SLEEP);
533         INIT_LIST_HEAD(&work->w_list);
534         work->w_syncer = syncer;
535         work->w_data = data;
536         work->w_mount = mp;
537         work->w_completion = completion;
538         spin_lock(&mp->m_sync_lock);
539         list_add_tail(&work->w_list, &mp->m_sync_list);
540         spin_unlock(&mp->m_sync_lock);
541         wake_up_process(mp->m_sync_task);
542 }
543
544 /*
545  * Flush delayed allocate data, attempting to free up reserved space
546  * from existing allocations.  At this point a new allocation attempt
547  * has failed with ENOSPC and we are in the process of scratching our
548  * heads, looking about for more room...
549  */
550 STATIC void
551 xfs_flush_inodes_work(
552         struct xfs_mount *mp,
553         void            *arg)
554 {
555         struct inode    *inode = arg;
556         xfs_sync_data(mp, SYNC_TRYLOCK);
557         xfs_sync_data(mp, SYNC_TRYLOCK | SYNC_WAIT);
558         iput(inode);
559 }
560
561 void
562 xfs_flush_inodes(
563         xfs_inode_t     *ip)
564 {
565         struct inode    *inode = VFS_I(ip);
566         DECLARE_COMPLETION_ONSTACK(completion);
567
568         igrab(inode);
569         xfs_syncd_queue_work(ip->i_mount, inode, xfs_flush_inodes_work, &completion);
570         wait_for_completion(&completion);
571         xfs_log_force(ip->i_mount, XFS_LOG_SYNC);
572 }
573
574 /*
575  * Every sync period we need to unpin all items, reclaim inodes and sync
576  * disk quotas.  We might need to cover the log to indicate that the
577  * filesystem is idle.
578  */
579 STATIC void
580 xfs_sync_worker(
581         struct xfs_mount *mp,
582         void            *unused)
583 {
584         int             error;
585
586         if (!(mp->m_flags & XFS_MOUNT_RDONLY)) {
587                 xfs_log_force(mp, 0);
588                 xfs_reclaim_inodes(mp, 0);
589                 /* dgc: errors ignored here */
590                 error = xfs_qm_sync(mp, SYNC_TRYLOCK);
591                 if (xfs_log_need_covered(mp))
592                         error = xfs_commit_dummy_trans(mp, 0);
593         }
594         mp->m_sync_seq++;
595         wake_up(&mp->m_wait_single_sync_task);
596 }
597
598 STATIC int
599 xfssyncd(
600         void                    *arg)
601 {
602         struct xfs_mount        *mp = arg;
603         long                    timeleft;
604         xfs_sync_work_t         *work, *n;
605         LIST_HEAD               (tmp);
606
607         set_freezable();
608         timeleft = xfs_syncd_centisecs * msecs_to_jiffies(10);
609         for (;;) {
610                 if (list_empty(&mp->m_sync_list))
611                         timeleft = schedule_timeout_interruptible(timeleft);
612                 /* swsusp */
613                 try_to_freeze();
614                 if (kthread_should_stop() && list_empty(&mp->m_sync_list))
615                         break;
616
617                 spin_lock(&mp->m_sync_lock);
618                 /*
619                  * We can get woken by laptop mode, to do a sync -
620                  * that's the (only!) case where the list would be
621                  * empty with time remaining.
622                  */
623                 if (!timeleft || list_empty(&mp->m_sync_list)) {
624                         if (!timeleft)
625                                 timeleft = xfs_syncd_centisecs *
626                                                         msecs_to_jiffies(10);
627                         INIT_LIST_HEAD(&mp->m_sync_work.w_list);
628                         list_add_tail(&mp->m_sync_work.w_list,
629                                         &mp->m_sync_list);
630                 }
631                 list_splice_init(&mp->m_sync_list, &tmp);
632                 spin_unlock(&mp->m_sync_lock);
633
634                 list_for_each_entry_safe(work, n, &tmp, w_list) {
635                         (*work->w_syncer)(mp, work->w_data);
636                         list_del(&work->w_list);
637                         if (work == &mp->m_sync_work)
638                                 continue;
639                         if (work->w_completion)
640                                 complete(work->w_completion);
641                         kmem_free(work);
642                 }
643         }
644
645         return 0;
646 }
647
648 int
649 xfs_syncd_init(
650         struct xfs_mount        *mp)
651 {
652         mp->m_sync_work.w_syncer = xfs_sync_worker;
653         mp->m_sync_work.w_mount = mp;
654         mp->m_sync_work.w_completion = NULL;
655         mp->m_sync_task = kthread_run(xfssyncd, mp, "xfssyncd/%s", mp->m_fsname);
656         if (IS_ERR(mp->m_sync_task))
657                 return -PTR_ERR(mp->m_sync_task);
658         return 0;
659 }
660
661 void
662 xfs_syncd_stop(
663         struct xfs_mount        *mp)
664 {
665         kthread_stop(mp->m_sync_task);
666 }
667
668 void
669 __xfs_inode_set_reclaim_tag(
670         struct xfs_perag        *pag,
671         struct xfs_inode        *ip)
672 {
673         radix_tree_tag_set(&pag->pag_ici_root,
674                            XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino),
675                            XFS_ICI_RECLAIM_TAG);
676
677         if (!pag->pag_ici_reclaimable) {
678                 /* propagate the reclaim tag up into the perag radix tree */
679                 spin_lock(&ip->i_mount->m_perag_lock);
680                 radix_tree_tag_set(&ip->i_mount->m_perag_tree,
681                                 XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino),
682                                 XFS_ICI_RECLAIM_TAG);
683                 spin_unlock(&ip->i_mount->m_perag_lock);
684                 trace_xfs_perag_set_reclaim(ip->i_mount, pag->pag_agno,
685                                                         -1, _RET_IP_);
686         }
687         pag->pag_ici_reclaimable++;
688 }
689
690 /*
691  * We set the inode flag atomically with the radix tree tag.
692  * Once we get tag lookups on the radix tree, this inode flag
693  * can go away.
694  */
695 void
696 xfs_inode_set_reclaim_tag(
697         xfs_inode_t     *ip)
698 {
699         struct xfs_mount *mp = ip->i_mount;
700         struct xfs_perag *pag;
701
702         pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
703         write_lock(&pag->pag_ici_lock);
704         spin_lock(&ip->i_flags_lock);
705         __xfs_inode_set_reclaim_tag(pag, ip);
706         __xfs_iflags_set(ip, XFS_IRECLAIMABLE);
707         spin_unlock(&ip->i_flags_lock);
708         write_unlock(&pag->pag_ici_lock);
709         xfs_perag_put(pag);
710 }
711
712 void
713 __xfs_inode_clear_reclaim_tag(
714         xfs_mount_t     *mp,
715         xfs_perag_t     *pag,
716         xfs_inode_t     *ip)
717 {
718         radix_tree_tag_clear(&pag->pag_ici_root,
719                         XFS_INO_TO_AGINO(mp, ip->i_ino), XFS_ICI_RECLAIM_TAG);
720         pag->pag_ici_reclaimable--;
721         if (!pag->pag_ici_reclaimable) {
722                 /* clear the reclaim tag from the perag radix tree */
723                 spin_lock(&ip->i_mount->m_perag_lock);
724                 radix_tree_tag_clear(&ip->i_mount->m_perag_tree,
725                                 XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino),
726                                 XFS_ICI_RECLAIM_TAG);
727                 spin_unlock(&ip->i_mount->m_perag_lock);
728                 trace_xfs_perag_clear_reclaim(ip->i_mount, pag->pag_agno,
729                                                         -1, _RET_IP_);
730         }
731 }
732
733 /*
734  * Inodes in different states need to be treated differently, and the return
735  * value of xfs_iflush is not sufficient to get this right. The following table
736  * lists the inode states and the reclaim actions necessary for non-blocking
737  * reclaim:
738  *
739  *
740  *      inode state          iflush ret         required action
741  *      ---------------      ----------         ---------------
742  *      bad                     -               reclaim
743  *      shutdown                EIO             unpin and reclaim
744  *      clean, unpinned         0               reclaim
745  *      stale, unpinned         0               reclaim
746  *      clean, pinned(*)        0               requeue
747  *      stale, pinned           EAGAIN          requeue
748  *      dirty, delwri ok        0               requeue
749  *      dirty, delwri blocked   EAGAIN          requeue
750  *      dirty, sync flush       0               reclaim
751  *
752  * (*) dgc: I don't think the clean, pinned state is possible but it gets
753  * handled anyway given the order of checks implemented.
754  *
755  * As can be seen from the table, the return value of xfs_iflush() is not
756  * sufficient to correctly decide the reclaim action here. The checks in
757  * xfs_iflush() might look like duplicates, but they are not.
758  *
759  * Also, because we get the flush lock first, we know that any inode that has
760  * been flushed delwri has had the flush completed by the time we check that
761  * the inode is clean. The clean inode check needs to be done before flushing
762  * the inode delwri otherwise we would loop forever requeuing clean inodes as
763  * we cannot tell apart a successful delwri flush and a clean inode from the
764  * return value of xfs_iflush().
765  *
766  * Note that because the inode is flushed delayed write by background
767  * writeback, the flush lock may already be held here and waiting on it can
768  * result in very long latencies. Hence for sync reclaims, where we wait on the
769  * flush lock, the caller should push out delayed write inodes first before
770  * trying to reclaim them to minimise the amount of time spent waiting. For
771  * background relaim, we just requeue the inode for the next pass.
772  *
773  * Hence the order of actions after gaining the locks should be:
774  *      bad             => reclaim
775  *      shutdown        => unpin and reclaim
776  *      pinned, delwri  => requeue
777  *      pinned, sync    => unpin
778  *      stale           => reclaim
779  *      clean           => reclaim
780  *      dirty, delwri   => flush and requeue
781  *      dirty, sync     => flush, wait and reclaim
782  */
783 STATIC int
784 xfs_reclaim_inode(
785         struct xfs_inode        *ip,
786         struct xfs_perag        *pag,
787         int                     sync_mode)
788 {
789         int     error = 0;
790
791         /*
792          * The radix tree lock here protects a thread in xfs_iget from racing
793          * with us starting reclaim on the inode.  Once we have the
794          * XFS_IRECLAIM flag set it will not touch us.
795          */
796         spin_lock(&ip->i_flags_lock);
797         ASSERT_ALWAYS(__xfs_iflags_test(ip, XFS_IRECLAIMABLE));
798         if (__xfs_iflags_test(ip, XFS_IRECLAIM)) {
799                 /* ignore as it is already under reclaim */
800                 spin_unlock(&ip->i_flags_lock);
801                 write_unlock(&pag->pag_ici_lock);
802                 return 0;
803         }
804         __xfs_iflags_set(ip, XFS_IRECLAIM);
805         spin_unlock(&ip->i_flags_lock);
806         write_unlock(&pag->pag_ici_lock);
807
808         xfs_ilock(ip, XFS_ILOCK_EXCL);
809         if (!xfs_iflock_nowait(ip)) {
810                 if (!(sync_mode & SYNC_WAIT))
811                         goto out;
812                 xfs_iflock(ip);
813         }
814
815         if (is_bad_inode(VFS_I(ip)))
816                 goto reclaim;
817         if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
818                 xfs_iunpin_wait(ip);
819                 goto reclaim;
820         }
821         if (xfs_ipincount(ip)) {
822                 if (!(sync_mode & SYNC_WAIT)) {
823                         xfs_ifunlock(ip);
824                         goto out;
825                 }
826                 xfs_iunpin_wait(ip);
827         }
828         if (xfs_iflags_test(ip, XFS_ISTALE))
829                 goto reclaim;
830         if (xfs_inode_clean(ip))
831                 goto reclaim;
832
833         /* Now we have an inode that needs flushing */
834         error = xfs_iflush(ip, sync_mode);
835         if (sync_mode & SYNC_WAIT) {
836                 xfs_iflock(ip);
837                 goto reclaim;
838         }
839
840         /*
841          * When we have to flush an inode but don't have SYNC_WAIT set, we
842          * flush the inode out using a delwri buffer and wait for the next
843          * call into reclaim to find it in a clean state instead of waiting for
844          * it now. We also don't return errors here - if the error is transient
845          * then the next reclaim pass will flush the inode, and if the error
846          * is permanent then the next sync reclaim will reclaim the inode and
847          * pass on the error.
848          */
849         if (error && error != EAGAIN && !XFS_FORCED_SHUTDOWN(ip->i_mount)) {
850                 xfs_fs_cmn_err(CE_WARN, ip->i_mount,
851                         "inode 0x%llx background reclaim flush failed with %d",
852                         (long long)ip->i_ino, error);
853         }
854 out:
855         xfs_iflags_clear(ip, XFS_IRECLAIM);
856         xfs_iunlock(ip, XFS_ILOCK_EXCL);
857         /*
858          * We could return EAGAIN here to make reclaim rescan the inode tree in
859          * a short while. However, this just burns CPU time scanning the tree
860          * waiting for IO to complete and xfssyncd never goes back to the idle
861          * state. Instead, return 0 to let the next scheduled background reclaim
862          * attempt to reclaim the inode again.
863          */
864         return 0;
865
866 reclaim:
867         xfs_ifunlock(ip);
868         xfs_iunlock(ip, XFS_ILOCK_EXCL);
869         xfs_ireclaim(ip);
870         return error;
871
872 }
873
874 int
875 xfs_reclaim_inodes(
876         xfs_mount_t     *mp,
877         int             mode)
878 {
879         return xfs_inode_ag_iterator(mp, xfs_reclaim_inode, mode,
880                                         XFS_ICI_RECLAIM_TAG, 1, NULL);
881 }
882
883 /*
884  * Shrinker infrastructure.
885  */
886 static int
887 xfs_reclaim_inode_shrink(
888         struct shrinker *shrink,
889         int             nr_to_scan,
890         gfp_t           gfp_mask)
891 {
892         struct xfs_mount *mp;
893         struct xfs_perag *pag;
894         xfs_agnumber_t  ag;
895         int             reclaimable;
896
897         mp = container_of(shrink, struct xfs_mount, m_inode_shrink);
898         if (nr_to_scan) {
899                 if (!(gfp_mask & __GFP_FS))
900                         return -1;
901
902                 xfs_inode_ag_iterator(mp, xfs_reclaim_inode, 0,
903                                         XFS_ICI_RECLAIM_TAG, 1, &nr_to_scan);
904                 /* if we don't exhaust the scan, don't bother coming back */
905                 if (nr_to_scan > 0)
906                         return -1;
907        }
908
909         reclaimable = 0;
910         ag = 0;
911         while ((pag = xfs_inode_ag_iter_next_pag(mp, &ag,
912                                         XFS_ICI_RECLAIM_TAG))) {
913                 reclaimable += pag->pag_ici_reclaimable;
914                 xfs_perag_put(pag);
915         }
916         return reclaimable;
917 }
918
919 void
920 xfs_inode_shrinker_register(
921         struct xfs_mount        *mp)
922 {
923         mp->m_inode_shrink.shrink = xfs_reclaim_inode_shrink;
924         mp->m_inode_shrink.seeks = DEFAULT_SEEKS;
925         register_shrinker(&mp->m_inode_shrink);
926 }
927
928 void
929 xfs_inode_shrinker_unregister(
930         struct xfs_mount        *mp)
931 {
932         unregister_shrinker(&mp->m_inode_shrink);
933 }