1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include "xfs.h"
19#include "xfs_fs.h"
20#include "xfs_format.h"
21#include "xfs_types.h"
22#include "xfs_log.h"
23#include "xfs_log_priv.h"
24#include "xfs_inum.h"
25#include "xfs_trans.h"
26#include "xfs_trans_priv.h"
27#include "xfs_sb.h"
28#include "xfs_ag.h"
29#include "xfs_mount.h"
30#include "xfs_bmap_btree.h"
31#include "xfs_inode.h"
32#include "xfs_dinode.h"
33#include "xfs_error.h"
34#include "xfs_filestream.h"
35#include "xfs_inode_item.h"
36#include "xfs_quota.h"
37#include "xfs_trace.h"
38#include "xfs_fsops.h"
39#include "xfs_icache.h"
40#include "xfs_bmap_util.h"
41
42#include <linux/kthread.h>
43#include <linux/freezer.h>
44
45STATIC void __xfs_inode_clear_reclaim_tag(struct xfs_mount *mp,
46 struct xfs_perag *pag, struct xfs_inode *ip);
47
48
49
50
51struct xfs_inode *
52xfs_inode_alloc(
53 struct xfs_mount *mp,
54 xfs_ino_t ino)
55{
56 struct xfs_inode *ip;
57
58
59
60
61
62
63 ip = kmem_zone_alloc(xfs_inode_zone, KM_SLEEP);
64 if (!ip)
65 return NULL;
66 if (inode_init_always(mp->m_super, VFS_I(ip))) {
67 kmem_zone_free(xfs_inode_zone, ip);
68 return NULL;
69 }
70
71 ASSERT(atomic_read(&ip->i_pincount) == 0);
72 ASSERT(!spin_is_locked(&ip->i_flags_lock));
73 ASSERT(!xfs_isiflocked(ip));
74 ASSERT(ip->i_ino == 0);
75
76 mrlock_init(&ip->i_iolock, MRLOCK_BARRIER, "xfsio", ip->i_ino);
77
78
79 ip->i_ino = ino;
80 ip->i_mount = mp;
81 memset(&ip->i_imap, 0, sizeof(struct xfs_imap));
82 ip->i_afp = NULL;
83 memset(&ip->i_df, 0, sizeof(xfs_ifork_t));
84 ip->i_flags = 0;
85 ip->i_delayed_blks = 0;
86 memset(&ip->i_d, 0, sizeof(xfs_icdinode_t));
87
88 return ip;
89}
90
91STATIC void
92xfs_inode_free_callback(
93 struct rcu_head *head)
94{
95 struct inode *inode = container_of(head, struct inode, i_rcu);
96 struct xfs_inode *ip = XFS_I(inode);
97
98 kmem_zone_free(xfs_inode_zone, ip);
99}
100
101void
102xfs_inode_free(
103 struct xfs_inode *ip)
104{
105 switch (ip->i_d.di_mode & S_IFMT) {
106 case S_IFREG:
107 case S_IFDIR:
108 case S_IFLNK:
109 xfs_idestroy_fork(ip, XFS_DATA_FORK);
110 break;
111 }
112
113 if (ip->i_afp)
114 xfs_idestroy_fork(ip, XFS_ATTR_FORK);
115
116 if (ip->i_itemp) {
117 ASSERT(!(ip->i_itemp->ili_item.li_flags & XFS_LI_IN_AIL));
118 xfs_inode_item_destroy(ip);
119 ip->i_itemp = NULL;
120 }
121
122
123
124
125
126
127
128 spin_lock(&ip->i_flags_lock);
129 ip->i_flags = XFS_IRECLAIM;
130 ip->i_ino = 0;
131 spin_unlock(&ip->i_flags_lock);
132
133
134 ASSERT(atomic_read(&ip->i_pincount) == 0);
135 ASSERT(!xfs_isiflocked(ip));
136
137 call_rcu(&VFS_I(ip)->i_rcu, xfs_inode_free_callback);
138}
139
140
141
142
143static int
144xfs_iget_cache_hit(
145 struct xfs_perag *pag,
146 struct xfs_inode *ip,
147 xfs_ino_t ino,
148 int flags,
149 int lock_flags) __releases(RCU)
150{
151 struct inode *inode = VFS_I(ip);
152 struct xfs_mount *mp = ip->i_mount;
153 int error;
154
155
156
157
158
159
160
161
162 spin_lock(&ip->i_flags_lock);
163 if (ip->i_ino != ino) {
164 trace_xfs_iget_skip(ip);
165 XFS_STATS_INC(xs_ig_frecycle);
166 error = EAGAIN;
167 goto out_error;
168 }
169
170
171
172
173
174
175
176
177
178
179
180
181 if (ip->i_flags & (XFS_INEW|XFS_IRECLAIM)) {
182 trace_xfs_iget_skip(ip);
183 XFS_STATS_INC(xs_ig_frecycle);
184 error = EAGAIN;
185 goto out_error;
186 }
187
188
189
190
191 if (ip->i_d.di_mode == 0 && !(flags & XFS_IGET_CREATE)) {
192 error = ENOENT;
193 goto out_error;
194 }
195
196
197
198
199
200 if (ip->i_flags & XFS_IRECLAIMABLE) {
201 trace_xfs_iget_reclaim(ip);
202
203
204
205
206
207
208
209 ip->i_flags |= XFS_IRECLAIM;
210
211 spin_unlock(&ip->i_flags_lock);
212 rcu_read_unlock();
213
214 error = -inode_init_always(mp->m_super, inode);
215 if (error) {
216
217
218
219
220 rcu_read_lock();
221 spin_lock(&ip->i_flags_lock);
222
223 ip->i_flags &= ~(XFS_INEW | XFS_IRECLAIM);
224 ASSERT(ip->i_flags & XFS_IRECLAIMABLE);
225 trace_xfs_iget_reclaim_fail(ip);
226 goto out_error;
227 }
228
229 spin_lock(&pag->pag_ici_lock);
230 spin_lock(&ip->i_flags_lock);
231
232
233
234
235
236
237 ip->i_flags &= ~XFS_IRECLAIM_RESET_FLAGS;
238 ip->i_flags |= XFS_INEW;
239 __xfs_inode_clear_reclaim_tag(mp, pag, ip);
240 inode->i_state = I_NEW;
241
242 ASSERT(!rwsem_is_locked(&ip->i_iolock.mr_lock));
243 mrlock_init(&ip->i_iolock, MRLOCK_BARRIER, "xfsio", ip->i_ino);
244
245 spin_unlock(&ip->i_flags_lock);
246 spin_unlock(&pag->pag_ici_lock);
247 } else {
248
249 if (!igrab(inode)) {
250 trace_xfs_iget_skip(ip);
251 error = EAGAIN;
252 goto out_error;
253 }
254
255
256 spin_unlock(&ip->i_flags_lock);
257 rcu_read_unlock();
258 trace_xfs_iget_hit(ip);
259 }
260
261 if (lock_flags != 0)
262 xfs_ilock(ip, lock_flags);
263
264 xfs_iflags_clear(ip, XFS_ISTALE | XFS_IDONTCACHE);
265 XFS_STATS_INC(xs_ig_found);
266
267 return 0;
268
269out_error:
270 spin_unlock(&ip->i_flags_lock);
271 rcu_read_unlock();
272 return error;
273}
274
275
276static int
277xfs_iget_cache_miss(
278 struct xfs_mount *mp,
279 struct xfs_perag *pag,
280 xfs_trans_t *tp,
281 xfs_ino_t ino,
282 struct xfs_inode **ipp,
283 int flags,
284 int lock_flags)
285{
286 struct xfs_inode *ip;
287 int error;
288 xfs_agino_t agino = XFS_INO_TO_AGINO(mp, ino);
289 int iflags;
290
291 ip = xfs_inode_alloc(mp, ino);
292 if (!ip)
293 return ENOMEM;
294
295 error = xfs_iread(mp, tp, ip, flags);
296 if (error)
297 goto out_destroy;
298
299 trace_xfs_iget_miss(ip);
300
301 if ((ip->i_d.di_mode == 0) && !(flags & XFS_IGET_CREATE)) {
302 error = ENOENT;
303 goto out_destroy;
304 }
305
306
307
308
309
310
311
312 if (radix_tree_preload(GFP_NOFS)) {
313 error = EAGAIN;
314 goto out_destroy;
315 }
316
317
318
319
320
321 if (lock_flags) {
322 if (!xfs_ilock_nowait(ip, lock_flags))
323 BUG();
324 }
325
326
327
328
329
330
331
332
333
334
335 iflags = XFS_INEW;
336 if (flags & XFS_IGET_DONTCACHE)
337 iflags |= XFS_IDONTCACHE;
338 ip->i_udquot = NULL;
339 ip->i_gdquot = NULL;
340 ip->i_pdquot = NULL;
341 xfs_iflags_set(ip, iflags);
342
343
344 spin_lock(&pag->pag_ici_lock);
345 error = radix_tree_insert(&pag->pag_ici_root, agino, ip);
346 if (unlikely(error)) {
347 WARN_ON(error != -EEXIST);
348 XFS_STATS_INC(xs_ig_dup);
349 error = EAGAIN;
350 goto out_preload_end;
351 }
352 spin_unlock(&pag->pag_ici_lock);
353 radix_tree_preload_end();
354
355 *ipp = ip;
356 return 0;
357
358out_preload_end:
359 spin_unlock(&pag->pag_ici_lock);
360 radix_tree_preload_end();
361 if (lock_flags)
362 xfs_iunlock(ip, lock_flags);
363out_destroy:
364 __destroy_inode(VFS_I(ip));
365 xfs_inode_free(ip);
366 return error;
367}
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391int
392xfs_iget(
393 xfs_mount_t *mp,
394 xfs_trans_t *tp,
395 xfs_ino_t ino,
396 uint flags,
397 uint lock_flags,
398 xfs_inode_t **ipp)
399{
400 xfs_inode_t *ip;
401 int error;
402 xfs_perag_t *pag;
403 xfs_agino_t agino;
404
405
406
407
408
409
410
411
412 ASSERT((lock_flags & (XFS_IOLOCK_EXCL | XFS_IOLOCK_SHARED)) == 0);
413
414
415 if (!ino || XFS_INO_TO_AGNO(mp, ino) >= mp->m_sb.sb_agcount)
416 return EINVAL;
417
418
419 pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ino));
420 agino = XFS_INO_TO_AGINO(mp, ino);
421
422again:
423 error = 0;
424 rcu_read_lock();
425 ip = radix_tree_lookup(&pag->pag_ici_root, agino);
426
427 if (ip) {
428 error = xfs_iget_cache_hit(pag, ip, ino, flags, lock_flags);
429 if (error)
430 goto out_error_or_again;
431 } else {
432 rcu_read_unlock();
433 XFS_STATS_INC(xs_ig_missed);
434
435 error = xfs_iget_cache_miss(mp, pag, tp, ino, &ip,
436 flags, lock_flags);
437 if (error)
438 goto out_error_or_again;
439 }
440 xfs_perag_put(pag);
441
442 *ipp = ip;
443
444
445
446
447
448 if (xfs_iflags_test(ip, XFS_INEW) && ip->i_d.di_mode != 0)
449 xfs_setup_inode(ip);
450 return 0;
451
452out_error_or_again:
453 if (error == EAGAIN) {
454 delay(1);
455 goto again;
456 }
457 xfs_perag_put(pag);
458 return error;
459}
460
461
462
463
464
465
466
467#define XFS_LOOKUP_BATCH 32
468
469STATIC int
470xfs_inode_ag_walk_grab(
471 struct xfs_inode *ip)
472{
473 struct inode *inode = VFS_I(ip);
474
475 ASSERT(rcu_read_lock_held());
476
477
478
479
480
481
482
483
484
485
486 spin_lock(&ip->i_flags_lock);
487 if (!ip->i_ino)
488 goto out_unlock_noent;
489
490
491 if (__xfs_iflags_test(ip, XFS_INEW | XFS_IRECLAIMABLE | XFS_IRECLAIM))
492 goto out_unlock_noent;
493 spin_unlock(&ip->i_flags_lock);
494
495
496 if (XFS_FORCED_SHUTDOWN(ip->i_mount))
497 return EFSCORRUPTED;
498
499
500 if (!igrab(inode))
501 return ENOENT;
502
503 if (is_bad_inode(inode)) {
504 IRELE(ip);
505 return ENOENT;
506 }
507
508
509 return 0;
510
511out_unlock_noent:
512 spin_unlock(&ip->i_flags_lock);
513 return ENOENT;
514}
515
516STATIC int
517xfs_inode_ag_walk(
518 struct xfs_mount *mp,
519 struct xfs_perag *pag,
520 int (*execute)(struct xfs_inode *ip,
521 struct xfs_perag *pag, int flags,
522 void *args),
523 int flags,
524 void *args,
525 int tag)
526{
527 uint32_t first_index;
528 int last_error = 0;
529 int skipped;
530 int done;
531 int nr_found;
532
533restart:
534 done = 0;
535 skipped = 0;
536 first_index = 0;
537 nr_found = 0;
538 do {
539 struct xfs_inode *batch[XFS_LOOKUP_BATCH];
540 int error = 0;
541 int i;
542
543 rcu_read_lock();
544
545 if (tag == -1)
546 nr_found = radix_tree_gang_lookup(&pag->pag_ici_root,
547 (void **)batch, first_index,
548 XFS_LOOKUP_BATCH);
549 else
550 nr_found = radix_tree_gang_lookup_tag(
551 &pag->pag_ici_root,
552 (void **) batch, first_index,
553 XFS_LOOKUP_BATCH, tag);
554
555 if (!nr_found) {
556 rcu_read_unlock();
557 break;
558 }
559
560
561
562
563
564 for (i = 0; i < nr_found; i++) {
565 struct xfs_inode *ip = batch[i];
566
567 if (done || xfs_inode_ag_walk_grab(ip))
568 batch[i] = NULL;
569
570
571
572
573
574
575
576
577
578
579
580
581
582 if (XFS_INO_TO_AGNO(mp, ip->i_ino) != pag->pag_agno)
583 continue;
584 first_index = XFS_INO_TO_AGINO(mp, ip->i_ino + 1);
585 if (first_index < XFS_INO_TO_AGINO(mp, ip->i_ino))
586 done = 1;
587 }
588
589
590 rcu_read_unlock();
591
592 for (i = 0; i < nr_found; i++) {
593 if (!batch[i])
594 continue;
595 error = execute(batch[i], pag, flags, args);
596 IRELE(batch[i]);
597 if (error == EAGAIN) {
598 skipped++;
599 continue;
600 }
601 if (error && last_error != EFSCORRUPTED)
602 last_error = error;
603 }
604
605
606 if (error == EFSCORRUPTED)
607 break;
608
609 cond_resched();
610
611 } while (nr_found && !done);
612
613 if (skipped) {
614 delay(1);
615 goto restart;
616 }
617 return last_error;
618}
619
620
621
622
623
624STATIC void
625xfs_queue_eofblocks(
626 struct xfs_mount *mp)
627{
628 rcu_read_lock();
629 if (radix_tree_tagged(&mp->m_perag_tree, XFS_ICI_EOFBLOCKS_TAG))
630 queue_delayed_work(mp->m_eofblocks_workqueue,
631 &mp->m_eofblocks_work,
632 msecs_to_jiffies(xfs_eofb_secs * 1000));
633 rcu_read_unlock();
634}
635
636void
637xfs_eofblocks_worker(
638 struct work_struct *work)
639{
640 struct xfs_mount *mp = container_of(to_delayed_work(work),
641 struct xfs_mount, m_eofblocks_work);
642 xfs_icache_free_eofblocks(mp, NULL);
643 xfs_queue_eofblocks(mp);
644}
645
646int
647xfs_inode_ag_iterator(
648 struct xfs_mount *mp,
649 int (*execute)(struct xfs_inode *ip,
650 struct xfs_perag *pag, int flags,
651 void *args),
652 int flags,
653 void *args)
654{
655 struct xfs_perag *pag;
656 int error = 0;
657 int last_error = 0;
658 xfs_agnumber_t ag;
659
660 ag = 0;
661 while ((pag = xfs_perag_get(mp, ag))) {
662 ag = pag->pag_agno + 1;
663 error = xfs_inode_ag_walk(mp, pag, execute, flags, args, -1);
664 xfs_perag_put(pag);
665 if (error) {
666 last_error = error;
667 if (error == EFSCORRUPTED)
668 break;
669 }
670 }
671 return XFS_ERROR(last_error);
672}
673
674int
675xfs_inode_ag_iterator_tag(
676 struct xfs_mount *mp,
677 int (*execute)(struct xfs_inode *ip,
678 struct xfs_perag *pag, int flags,
679 void *args),
680 int flags,
681 void *args,
682 int tag)
683{
684 struct xfs_perag *pag;
685 int error = 0;
686 int last_error = 0;
687 xfs_agnumber_t ag;
688
689 ag = 0;
690 while ((pag = xfs_perag_get_tag(mp, ag, tag))) {
691 ag = pag->pag_agno + 1;
692 error = xfs_inode_ag_walk(mp, pag, execute, flags, args, tag);
693 xfs_perag_put(pag);
694 if (error) {
695 last_error = error;
696 if (error == EFSCORRUPTED)
697 break;
698 }
699 }
700 return XFS_ERROR(last_error);
701}
702
703
704
705
706
707
708
709
710static void
711xfs_reclaim_work_queue(
712 struct xfs_mount *mp)
713{
714
715 rcu_read_lock();
716 if (radix_tree_tagged(&mp->m_perag_tree, XFS_ICI_RECLAIM_TAG)) {
717 queue_delayed_work(mp->m_reclaim_workqueue, &mp->m_reclaim_work,
718 msecs_to_jiffies(xfs_syncd_centisecs / 6 * 10));
719 }
720 rcu_read_unlock();
721}
722
723
724
725
726
727
728
729
730void
731xfs_reclaim_worker(
732 struct work_struct *work)
733{
734 struct xfs_mount *mp = container_of(to_delayed_work(work),
735 struct xfs_mount, m_reclaim_work);
736
737 xfs_reclaim_inodes(mp, SYNC_TRYLOCK);
738 xfs_reclaim_work_queue(mp);
739}
740
741static void
742__xfs_inode_set_reclaim_tag(
743 struct xfs_perag *pag,
744 struct xfs_inode *ip)
745{
746 radix_tree_tag_set(&pag->pag_ici_root,
747 XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino),
748 XFS_ICI_RECLAIM_TAG);
749
750 if (!pag->pag_ici_reclaimable) {
751
752 spin_lock(&ip->i_mount->m_perag_lock);
753 radix_tree_tag_set(&ip->i_mount->m_perag_tree,
754 XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino),
755 XFS_ICI_RECLAIM_TAG);
756 spin_unlock(&ip->i_mount->m_perag_lock);
757
758
759 xfs_reclaim_work_queue(ip->i_mount);
760
761 trace_xfs_perag_set_reclaim(ip->i_mount, pag->pag_agno,
762 -1, _RET_IP_);
763 }
764 pag->pag_ici_reclaimable++;
765}
766
767
768
769
770
771
772void
773xfs_inode_set_reclaim_tag(
774 xfs_inode_t *ip)
775{
776 struct xfs_mount *mp = ip->i_mount;
777 struct xfs_perag *pag;
778
779 pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
780 spin_lock(&pag->pag_ici_lock);
781 spin_lock(&ip->i_flags_lock);
782 __xfs_inode_set_reclaim_tag(pag, ip);
783 __xfs_iflags_set(ip, XFS_IRECLAIMABLE);
784 spin_unlock(&ip->i_flags_lock);
785 spin_unlock(&pag->pag_ici_lock);
786 xfs_perag_put(pag);
787}
788
789STATIC void
790__xfs_inode_clear_reclaim(
791 xfs_perag_t *pag,
792 xfs_inode_t *ip)
793{
794 pag->pag_ici_reclaimable--;
795 if (!pag->pag_ici_reclaimable) {
796
797 spin_lock(&ip->i_mount->m_perag_lock);
798 radix_tree_tag_clear(&ip->i_mount->m_perag_tree,
799 XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino),
800 XFS_ICI_RECLAIM_TAG);
801 spin_unlock(&ip->i_mount->m_perag_lock);
802 trace_xfs_perag_clear_reclaim(ip->i_mount, pag->pag_agno,
803 -1, _RET_IP_);
804 }
805}
806
807STATIC void
808__xfs_inode_clear_reclaim_tag(
809 xfs_mount_t *mp,
810 xfs_perag_t *pag,
811 xfs_inode_t *ip)
812{
813 radix_tree_tag_clear(&pag->pag_ici_root,
814 XFS_INO_TO_AGINO(mp, ip->i_ino), XFS_ICI_RECLAIM_TAG);
815 __xfs_inode_clear_reclaim(pag, ip);
816}
817
818
819
820
821
822STATIC int
823xfs_reclaim_inode_grab(
824 struct xfs_inode *ip,
825 int flags)
826{
827 ASSERT(rcu_read_lock_held());
828
829
830 if (!ip->i_ino)
831 return 1;
832
833
834
835
836
837
838 if ((flags & SYNC_TRYLOCK) &&
839 __xfs_iflags_test(ip, XFS_IFLOCK | XFS_IRECLAIM))
840 return 1;
841
842
843
844
845
846
847
848
849
850
851
852 spin_lock(&ip->i_flags_lock);
853 if (!__xfs_iflags_test(ip, XFS_IRECLAIMABLE) ||
854 __xfs_iflags_test(ip, XFS_IRECLAIM)) {
855
856 spin_unlock(&ip->i_flags_lock);
857 return 1;
858 }
859 __xfs_iflags_set(ip, XFS_IRECLAIM);
860 spin_unlock(&ip->i_flags_lock);
861 return 0;
862}
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903STATIC int
904xfs_reclaim_inode(
905 struct xfs_inode *ip,
906 struct xfs_perag *pag,
907 int sync_mode)
908{
909 struct xfs_buf *bp = NULL;
910 int error;
911
912restart:
913 error = 0;
914 xfs_ilock(ip, XFS_ILOCK_EXCL);
915 if (!xfs_iflock_nowait(ip)) {
916 if (!(sync_mode & SYNC_WAIT))
917 goto out;
918 xfs_iflock(ip);
919 }
920
921 if (is_bad_inode(VFS_I(ip)))
922 goto reclaim;
923 if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
924 xfs_iunpin_wait(ip);
925 xfs_iflush_abort(ip, false);
926 goto reclaim;
927 }
928 if (xfs_ipincount(ip)) {
929 if (!(sync_mode & SYNC_WAIT))
930 goto out_ifunlock;
931 xfs_iunpin_wait(ip);
932 }
933 if (xfs_iflags_test(ip, XFS_ISTALE))
934 goto reclaim;
935 if (xfs_inode_clean(ip))
936 goto reclaim;
937
938
939
940
941
942 if (!(sync_mode & SYNC_WAIT))
943 goto out_ifunlock;
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961 error = xfs_iflush(ip, &bp);
962 if (error == EAGAIN) {
963 xfs_iunlock(ip, XFS_ILOCK_EXCL);
964
965 delay(2);
966 goto restart;
967 }
968
969 if (!error) {
970 error = xfs_bwrite(bp);
971 xfs_buf_relse(bp);
972 }
973
974 xfs_iflock(ip);
975reclaim:
976 xfs_ifunlock(ip);
977 xfs_iunlock(ip, XFS_ILOCK_EXCL);
978
979 XFS_STATS_INC(xs_ig_reclaims);
980
981
982
983
984
985
986
987 spin_lock(&pag->pag_ici_lock);
988 if (!radix_tree_delete(&pag->pag_ici_root,
989 XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino)))
990 ASSERT(0);
991 __xfs_inode_clear_reclaim(pag, ip);
992 spin_unlock(&pag->pag_ici_lock);
993
994
995
996
997
998
999
1000
1001
1002 xfs_ilock(ip, XFS_ILOCK_EXCL);
1003 xfs_qm_dqdetach(ip);
1004 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1005
1006 xfs_inode_free(ip);
1007 return error;
1008
1009out_ifunlock:
1010 xfs_ifunlock(ip);
1011out:
1012 xfs_iflags_clear(ip, XFS_IRECLAIM);
1013 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1014
1015
1016
1017
1018
1019
1020
1021 return 0;
1022}
1023
1024
1025
1026
1027
1028
1029
1030STATIC int
1031xfs_reclaim_inodes_ag(
1032 struct xfs_mount *mp,
1033 int flags,
1034 int *nr_to_scan)
1035{
1036 struct xfs_perag *pag;
1037 int error = 0;
1038 int last_error = 0;
1039 xfs_agnumber_t ag;
1040 int trylock = flags & SYNC_TRYLOCK;
1041 int skipped;
1042
1043restart:
1044 ag = 0;
1045 skipped = 0;
1046 while ((pag = xfs_perag_get_tag(mp, ag, XFS_ICI_RECLAIM_TAG))) {
1047 unsigned long first_index = 0;
1048 int done = 0;
1049 int nr_found = 0;
1050
1051 ag = pag->pag_agno + 1;
1052
1053 if (trylock) {
1054 if (!mutex_trylock(&pag->pag_ici_reclaim_lock)) {
1055 skipped++;
1056 xfs_perag_put(pag);
1057 continue;
1058 }
1059 first_index = pag->pag_ici_reclaim_cursor;
1060 } else
1061 mutex_lock(&pag->pag_ici_reclaim_lock);
1062
1063 do {
1064 struct xfs_inode *batch[XFS_LOOKUP_BATCH];
1065 int i;
1066
1067 rcu_read_lock();
1068 nr_found = radix_tree_gang_lookup_tag(
1069 &pag->pag_ici_root,
1070 (void **)batch, first_index,
1071 XFS_LOOKUP_BATCH,
1072 XFS_ICI_RECLAIM_TAG);
1073 if (!nr_found) {
1074 done = 1;
1075 rcu_read_unlock();
1076 break;
1077 }
1078
1079
1080
1081
1082
1083 for (i = 0; i < nr_found; i++) {
1084 struct xfs_inode *ip = batch[i];
1085
1086 if (done || xfs_reclaim_inode_grab(ip, flags))
1087 batch[i] = NULL;
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103 if (XFS_INO_TO_AGNO(mp, ip->i_ino) !=
1104 pag->pag_agno)
1105 continue;
1106 first_index = XFS_INO_TO_AGINO(mp, ip->i_ino + 1);
1107 if (first_index < XFS_INO_TO_AGINO(mp, ip->i_ino))
1108 done = 1;
1109 }
1110
1111
1112 rcu_read_unlock();
1113
1114 for (i = 0; i < nr_found; i++) {
1115 if (!batch[i])
1116 continue;
1117 error = xfs_reclaim_inode(batch[i], pag, flags);
1118 if (error && last_error != EFSCORRUPTED)
1119 last_error = error;
1120 }
1121
1122 *nr_to_scan -= XFS_LOOKUP_BATCH;
1123
1124 cond_resched();
1125
1126 } while (nr_found && !done && *nr_to_scan > 0);
1127
1128 if (trylock && !done)
1129 pag->pag_ici_reclaim_cursor = first_index;
1130 else
1131 pag->pag_ici_reclaim_cursor = 0;
1132 mutex_unlock(&pag->pag_ici_reclaim_lock);
1133 xfs_perag_put(pag);
1134 }
1135
1136
1137
1138
1139
1140
1141
1142
1143 if (skipped && (flags & SYNC_WAIT) && *nr_to_scan > 0) {
1144 trylock = 0;
1145 goto restart;
1146 }
1147 return XFS_ERROR(last_error);
1148}
1149
1150int
1151xfs_reclaim_inodes(
1152 xfs_mount_t *mp,
1153 int mode)
1154{
1155 int nr_to_scan = INT_MAX;
1156
1157 return xfs_reclaim_inodes_ag(mp, mode, &nr_to_scan);
1158}
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169long
1170xfs_reclaim_inodes_nr(
1171 struct xfs_mount *mp,
1172 int nr_to_scan)
1173{
1174
1175 xfs_reclaim_work_queue(mp);
1176 xfs_ail_push_all(mp->m_ail);
1177
1178 return xfs_reclaim_inodes_ag(mp, SYNC_TRYLOCK | SYNC_WAIT, &nr_to_scan);
1179}
1180
1181
1182
1183
1184
1185int
1186xfs_reclaim_inodes_count(
1187 struct xfs_mount *mp)
1188{
1189 struct xfs_perag *pag;
1190 xfs_agnumber_t ag = 0;
1191 int reclaimable = 0;
1192
1193 while ((pag = xfs_perag_get_tag(mp, ag, XFS_ICI_RECLAIM_TAG))) {
1194 ag = pag->pag_agno + 1;
1195 reclaimable += pag->pag_ici_reclaimable;
1196 xfs_perag_put(pag);
1197 }
1198 return reclaimable;
1199}
1200
1201STATIC int
1202xfs_inode_match_id(
1203 struct xfs_inode *ip,
1204 struct xfs_eofblocks *eofb)
1205{
1206 if ((eofb->eof_flags & XFS_EOF_FLAGS_UID) &&
1207 !uid_eq(VFS_I(ip)->i_uid, eofb->eof_uid))
1208 return 0;
1209
1210 if ((eofb->eof_flags & XFS_EOF_FLAGS_GID) &&
1211 !gid_eq(VFS_I(ip)->i_gid, eofb->eof_gid))
1212 return 0;
1213
1214 if ((eofb->eof_flags & XFS_EOF_FLAGS_PRID) &&
1215 xfs_get_projid(ip) != eofb->eof_prid)
1216 return 0;
1217
1218 return 1;
1219}
1220
1221STATIC int
1222xfs_inode_free_eofblocks(
1223 struct xfs_inode *ip,
1224 struct xfs_perag *pag,
1225 int flags,
1226 void *args)
1227{
1228 int ret;
1229 struct xfs_eofblocks *eofb = args;
1230
1231 if (!xfs_can_free_eofblocks(ip, false)) {
1232
1233 trace_xfs_inode_free_eofblocks_invalid(ip);
1234 xfs_inode_clear_eofblocks_tag(ip);
1235 return 0;
1236 }
1237
1238
1239
1240
1241
1242 if (!(flags & SYNC_WAIT) &&
1243 mapping_tagged(VFS_I(ip)->i_mapping, PAGECACHE_TAG_DIRTY))
1244 return 0;
1245
1246 if (eofb) {
1247 if (!xfs_inode_match_id(ip, eofb))
1248 return 0;
1249
1250
1251 if (eofb->eof_flags & XFS_EOF_FLAGS_MINFILESIZE &&
1252 XFS_ISIZE(ip) < eofb->eof_min_file_size)
1253 return 0;
1254 }
1255
1256 ret = xfs_free_eofblocks(ip->i_mount, ip, true);
1257
1258
1259 if (ret == EAGAIN && !(flags & SYNC_WAIT))
1260 ret = 0;
1261
1262 return ret;
1263}
1264
1265int
1266xfs_icache_free_eofblocks(
1267 struct xfs_mount *mp,
1268 struct xfs_eofblocks *eofb)
1269{
1270 int flags = SYNC_TRYLOCK;
1271
1272 if (eofb && (eofb->eof_flags & XFS_EOF_FLAGS_SYNC))
1273 flags = SYNC_WAIT;
1274
1275 return xfs_inode_ag_iterator_tag(mp, xfs_inode_free_eofblocks, flags,
1276 eofb, XFS_ICI_EOFBLOCKS_TAG);
1277}
1278
1279void
1280xfs_inode_set_eofblocks_tag(
1281 xfs_inode_t *ip)
1282{
1283 struct xfs_mount *mp = ip->i_mount;
1284 struct xfs_perag *pag;
1285 int tagged;
1286
1287 pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
1288 spin_lock(&pag->pag_ici_lock);
1289 trace_xfs_inode_set_eofblocks_tag(ip);
1290
1291 tagged = radix_tree_tagged(&pag->pag_ici_root,
1292 XFS_ICI_EOFBLOCKS_TAG);
1293 radix_tree_tag_set(&pag->pag_ici_root,
1294 XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino),
1295 XFS_ICI_EOFBLOCKS_TAG);
1296 if (!tagged) {
1297
1298 spin_lock(&ip->i_mount->m_perag_lock);
1299 radix_tree_tag_set(&ip->i_mount->m_perag_tree,
1300 XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino),
1301 XFS_ICI_EOFBLOCKS_TAG);
1302 spin_unlock(&ip->i_mount->m_perag_lock);
1303
1304
1305 xfs_queue_eofblocks(ip->i_mount);
1306
1307 trace_xfs_perag_set_eofblocks(ip->i_mount, pag->pag_agno,
1308 -1, _RET_IP_);
1309 }
1310
1311 spin_unlock(&pag->pag_ici_lock);
1312 xfs_perag_put(pag);
1313}
1314
1315void
1316xfs_inode_clear_eofblocks_tag(
1317 xfs_inode_t *ip)
1318{
1319 struct xfs_mount *mp = ip->i_mount;
1320 struct xfs_perag *pag;
1321
1322 pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
1323 spin_lock(&pag->pag_ici_lock);
1324 trace_xfs_inode_clear_eofblocks_tag(ip);
1325
1326 radix_tree_tag_clear(&pag->pag_ici_root,
1327 XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino),
1328 XFS_ICI_EOFBLOCKS_TAG);
1329 if (!radix_tree_tagged(&pag->pag_ici_root, XFS_ICI_EOFBLOCKS_TAG)) {
1330
1331 spin_lock(&ip->i_mount->m_perag_lock);
1332 radix_tree_tag_clear(&ip->i_mount->m_perag_tree,
1333 XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino),
1334 XFS_ICI_EOFBLOCKS_TAG);
1335 spin_unlock(&ip->i_mount->m_perag_lock);
1336 trace_xfs_perag_clear_eofblocks(ip->i_mount, pag->pag_agno,
1337 -1, _RET_IP_);
1338 }
1339
1340 spin_unlock(&pag->pag_ici_lock);
1341 xfs_perag_put(pag);
1342}
1343
1344