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_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_dir2_sf.h"
34#include "xfs_attr_sf.h"
35#include "xfs_dinode.h"
36#include "xfs_inode.h"
37#include "xfs_ialloc.h"
38#include "xfs_itable.h"
39#include "xfs_error.h"
40#include "xfs_btree.h"
41
42STATIC int
43xfs_internal_inum(
44 xfs_mount_t *mp,
45 xfs_ino_t ino)
46{
47 return (ino == mp->m_sb.sb_rbmino || ino == mp->m_sb.sb_rsumino ||
48 (xfs_sb_version_hasquota(&mp->m_sb) &&
49 (ino == mp->m_sb.sb_uquotino || ino == mp->m_sb.sb_gquotino)));
50}
51
52STATIC int
53xfs_bulkstat_one_iget(
54 xfs_mount_t *mp,
55 xfs_ino_t ino,
56 xfs_daddr_t bno,
57 xfs_bstat_t *buf,
58 int *stat)
59{
60 xfs_icdinode_t *dic;
61 xfs_inode_t *ip;
62 struct inode *inode;
63 int error;
64
65 error = xfs_iget(mp, NULL, ino,
66 XFS_IGET_BULKSTAT, XFS_ILOCK_SHARED, &ip, bno);
67 if (error) {
68 *stat = BULKSTAT_RV_NOTHING;
69 return error;
70 }
71
72 ASSERT(ip != NULL);
73 ASSERT(ip->i_imap.im_blkno != 0);
74
75 dic = &ip->i_d;
76 inode = VFS_I(ip);
77
78
79
80
81 buf->bs_nlink = dic->di_nlink;
82 buf->bs_projid = dic->di_projid;
83 buf->bs_ino = ino;
84 buf->bs_mode = dic->di_mode;
85 buf->bs_uid = dic->di_uid;
86 buf->bs_gid = dic->di_gid;
87 buf->bs_size = dic->di_size;
88
89
90
91
92
93
94 buf->bs_atime.tv_sec = inode->i_atime.tv_sec;
95 buf->bs_atime.tv_nsec = inode->i_atime.tv_nsec;
96 buf->bs_mtime.tv_sec = inode->i_mtime.tv_sec;
97 buf->bs_mtime.tv_nsec = inode->i_mtime.tv_nsec;
98 buf->bs_ctime.tv_sec = inode->i_ctime.tv_sec;
99 buf->bs_ctime.tv_nsec = inode->i_ctime.tv_nsec;
100
101 buf->bs_xflags = xfs_ip2xflags(ip);
102 buf->bs_extsize = dic->di_extsize << mp->m_sb.sb_blocklog;
103 buf->bs_extents = dic->di_nextents;
104 buf->bs_gen = dic->di_gen;
105 memset(buf->bs_pad, 0, sizeof(buf->bs_pad));
106 buf->bs_dmevmask = dic->di_dmevmask;
107 buf->bs_dmstate = dic->di_dmstate;
108 buf->bs_aextents = dic->di_anextents;
109
110 switch (dic->di_format) {
111 case XFS_DINODE_FMT_DEV:
112 buf->bs_rdev = ip->i_df.if_u2.if_rdev;
113 buf->bs_blksize = BLKDEV_IOSIZE;
114 buf->bs_blocks = 0;
115 break;
116 case XFS_DINODE_FMT_LOCAL:
117 case XFS_DINODE_FMT_UUID:
118 buf->bs_rdev = 0;
119 buf->bs_blksize = mp->m_sb.sb_blocksize;
120 buf->bs_blocks = 0;
121 break;
122 case XFS_DINODE_FMT_EXTENTS:
123 case XFS_DINODE_FMT_BTREE:
124 buf->bs_rdev = 0;
125 buf->bs_blksize = mp->m_sb.sb_blocksize;
126 buf->bs_blocks = dic->di_nblocks + ip->i_delayed_blks;
127 break;
128 }
129
130 xfs_iput(ip, XFS_ILOCK_SHARED);
131 return error;
132}
133
134STATIC void
135xfs_bulkstat_one_dinode(
136 xfs_mount_t *mp,
137 xfs_ino_t ino,
138 xfs_dinode_t *dic,
139 xfs_bstat_t *buf)
140{
141
142
143
144
145
146
147
148
149
150
151
152 if (dic->di_version == 1) {
153 buf->bs_nlink = be16_to_cpu(dic->di_onlink);
154 buf->bs_projid = 0;
155 } else {
156 buf->bs_nlink = be32_to_cpu(dic->di_nlink);
157 buf->bs_projid = be16_to_cpu(dic->di_projid);
158 }
159
160 buf->bs_ino = ino;
161 buf->bs_mode = be16_to_cpu(dic->di_mode);
162 buf->bs_uid = be32_to_cpu(dic->di_uid);
163 buf->bs_gid = be32_to_cpu(dic->di_gid);
164 buf->bs_size = be64_to_cpu(dic->di_size);
165 buf->bs_atime.tv_sec = be32_to_cpu(dic->di_atime.t_sec);
166 buf->bs_atime.tv_nsec = be32_to_cpu(dic->di_atime.t_nsec);
167 buf->bs_mtime.tv_sec = be32_to_cpu(dic->di_mtime.t_sec);
168 buf->bs_mtime.tv_nsec = be32_to_cpu(dic->di_mtime.t_nsec);
169 buf->bs_ctime.tv_sec = be32_to_cpu(dic->di_ctime.t_sec);
170 buf->bs_ctime.tv_nsec = be32_to_cpu(dic->di_ctime.t_nsec);
171 buf->bs_xflags = xfs_dic2xflags(dic);
172 buf->bs_extsize = be32_to_cpu(dic->di_extsize) << mp->m_sb.sb_blocklog;
173 buf->bs_extents = be32_to_cpu(dic->di_nextents);
174 buf->bs_gen = be32_to_cpu(dic->di_gen);
175 memset(buf->bs_pad, 0, sizeof(buf->bs_pad));
176 buf->bs_dmevmask = be32_to_cpu(dic->di_dmevmask);
177 buf->bs_dmstate = be16_to_cpu(dic->di_dmstate);
178 buf->bs_aextents = be16_to_cpu(dic->di_anextents);
179
180 switch (dic->di_format) {
181 case XFS_DINODE_FMT_DEV:
182 buf->bs_rdev = xfs_dinode_get_rdev(dic);
183 buf->bs_blksize = BLKDEV_IOSIZE;
184 buf->bs_blocks = 0;
185 break;
186 case XFS_DINODE_FMT_LOCAL:
187 case XFS_DINODE_FMT_UUID:
188 buf->bs_rdev = 0;
189 buf->bs_blksize = mp->m_sb.sb_blocksize;
190 buf->bs_blocks = 0;
191 break;
192 case XFS_DINODE_FMT_EXTENTS:
193 case XFS_DINODE_FMT_BTREE:
194 buf->bs_rdev = 0;
195 buf->bs_blksize = mp->m_sb.sb_blocksize;
196 buf->bs_blocks = be64_to_cpu(dic->di_nblocks);
197 break;
198 }
199}
200
201
202STATIC int
203xfs_bulkstat_one_fmt(
204 void __user *ubuffer,
205 int ubsize,
206 int *ubused,
207 const xfs_bstat_t *buffer)
208{
209 if (ubsize < sizeof(*buffer))
210 return XFS_ERROR(ENOMEM);
211 if (copy_to_user(ubuffer, buffer, sizeof(*buffer)))
212 return XFS_ERROR(EFAULT);
213 if (ubused)
214 *ubused = sizeof(*buffer);
215 return 0;
216}
217
218
219
220
221
222int
223xfs_bulkstat_one_int(
224 xfs_mount_t *mp,
225 xfs_ino_t ino,
226 void __user *buffer,
227 int ubsize,
228 bulkstat_one_fmt_pf formatter,
229 xfs_daddr_t bno,
230 int *ubused,
231 void *dibuff,
232 int *stat)
233{
234 xfs_bstat_t *buf;
235 int error = 0;
236 xfs_dinode_t *dip;
237
238 dip = (xfs_dinode_t *)dibuff;
239 *stat = BULKSTAT_RV_NOTHING;
240
241 if (!buffer || xfs_internal_inum(mp, ino))
242 return XFS_ERROR(EINVAL);
243
244 buf = kmem_alloc(sizeof(*buf), KM_SLEEP);
245
246 if (dip == NULL) {
247
248
249
250 error = xfs_bulkstat_one_iget(mp, ino, bno, buf, stat);
251 if (error)
252 goto out_free;
253 } else {
254 xfs_bulkstat_one_dinode(mp, ino, dip, buf);
255 }
256
257 error = formatter(buffer, ubsize, ubused, buf);
258 if (error)
259 goto out_free;
260
261 *stat = BULKSTAT_RV_DIDONE;
262
263 out_free:
264 kmem_free(buf);
265 return error;
266}
267
268int
269xfs_bulkstat_one(
270 xfs_mount_t *mp,
271 xfs_ino_t ino,
272 void __user *buffer,
273 int ubsize,
274 void *private_data,
275 xfs_daddr_t bno,
276 int *ubused,
277 void *dibuff,
278 int *stat)
279{
280 return xfs_bulkstat_one_int(mp, ino, buffer, ubsize,
281 xfs_bulkstat_one_fmt, bno,
282 ubused, dibuff, stat);
283}
284
285
286
287
288
289
290STATIC int
291xfs_bulkstat_use_dinode(
292 xfs_mount_t *mp,
293 int flags,
294 xfs_buf_t *bp,
295 int clustidx,
296 xfs_dinode_t **dipp)
297{
298 xfs_dinode_t *dip;
299 unsigned int aformat;
300
301 *dipp = NULL;
302 if (!bp || (flags & BULKSTAT_FG_IGET))
303 return 1;
304 dip = (xfs_dinode_t *)
305 xfs_buf_offset(bp, clustidx << mp->m_sb.sb_inodelog);
306
307
308
309
310
311
312
313 if (be16_to_cpu(dip->di_magic) != XFS_DINODE_MAGIC ||
314 !XFS_DINODE_GOOD_VERSION(dip->di_version) ||
315 !dip->di_mode)
316 return 0;
317 if (flags & BULKSTAT_FG_QUICK) {
318 *dipp = dip;
319 return 1;
320 }
321
322 aformat = dip->di_aformat;
323 if ((XFS_DFORK_Q(dip) == 0) ||
324 (aformat == XFS_DINODE_FMT_LOCAL) ||
325 (aformat == XFS_DINODE_FMT_EXTENTS && !dip->di_anextents)) {
326 *dipp = dip;
327 return 1;
328 }
329 return 1;
330}
331
332#define XFS_BULKSTAT_UBLEFT(ubleft) ((ubleft) >= statstruct_size)
333
334
335
336
337int
338xfs_bulkstat(
339 xfs_mount_t *mp,
340 xfs_ino_t *lastinop,
341 int *ubcountp,
342 bulkstat_one_pf formatter,
343 void *private_data,
344 size_t statstruct_size,
345 char __user *ubuffer,
346 int flags,
347 int *done)
348{
349 xfs_agblock_t agbno=0;
350 xfs_buf_t *agbp;
351 xfs_agi_t *agi;
352 xfs_agino_t agino;
353 xfs_agnumber_t agno;
354 xfs_daddr_t bno;
355 int chunkidx;
356 int clustidx;
357 xfs_btree_cur_t *cur;
358 int end_of_ag;
359 int error;
360 int fmterror;
361 int i;
362 int icount;
363 size_t irbsize;
364 xfs_ino_t ino;
365 xfs_inobt_rec_incore_t *irbp;
366 xfs_inobt_rec_incore_t *irbuf;
367 xfs_inobt_rec_incore_t *irbufend;
368 xfs_ino_t lastino;
369 int nbcluster;
370 int nicluster;
371 int nimask;
372 int nirbuf;
373 int rval;
374 int tmp;
375 int ubcount;
376 int ubleft;
377 char __user *ubufp;
378 int ubelem;
379 int ubused;
380 xfs_buf_t *bp;
381 xfs_dinode_t *dip;
382
383
384
385
386 ino = (xfs_ino_t)*lastinop;
387 lastino = ino;
388 dip = NULL;
389 agno = XFS_INO_TO_AGNO(mp, ino);
390 agino = XFS_INO_TO_AGINO(mp, ino);
391 if (agno >= mp->m_sb.sb_agcount ||
392 ino != XFS_AGINO_TO_INO(mp, agno, agino)) {
393 *done = 1;
394 *ubcountp = 0;
395 return 0;
396 }
397 if (!ubcountp || *ubcountp <= 0) {
398 return EINVAL;
399 }
400 ubcount = *ubcountp;
401 ubleft = ubcount * statstruct_size;
402 *ubcountp = ubelem = 0;
403 *done = 0;
404 fmterror = 0;
405 ubufp = ubuffer;
406 nicluster = mp->m_sb.sb_blocksize >= XFS_INODE_CLUSTER_SIZE(mp) ?
407 mp->m_sb.sb_inopblock :
408 (XFS_INODE_CLUSTER_SIZE(mp) >> mp->m_sb.sb_inodelog);
409 nimask = ~(nicluster - 1);
410 nbcluster = nicluster >> mp->m_sb.sb_inopblog;
411 irbuf = kmem_zalloc_greedy(&irbsize, PAGE_SIZE, PAGE_SIZE * 4,
412 KM_SLEEP | KM_MAYFAIL | KM_LARGE);
413 nirbuf = irbsize / sizeof(*irbuf);
414
415
416
417
418
419 rval = 0;
420 while (XFS_BULKSTAT_UBLEFT(ubleft) && agno < mp->m_sb.sb_agcount) {
421 cond_resched();
422 bp = NULL;
423 down_read(&mp->m_peraglock);
424 error = xfs_ialloc_read_agi(mp, NULL, agno, &agbp);
425 up_read(&mp->m_peraglock);
426 if (error) {
427
428
429
430 agno++;
431 agino = 0;
432 continue;
433 }
434 agi = XFS_BUF_TO_AGI(agbp);
435
436
437
438 cur = xfs_inobt_init_cursor(mp, NULL, agbp, agno);
439 irbp = irbuf;
440 irbufend = irbuf + nirbuf;
441 end_of_ag = 0;
442
443
444
445
446 if (agino > 0) {
447 xfs_inobt_rec_incore_t r;
448
449
450
451
452 error = xfs_inobt_lookup(cur, agino, XFS_LOOKUP_LE,
453 &tmp);
454 if (!error &&
455 tmp &&
456
457 !(error = xfs_inobt_get_rec(cur, &r, &i)) &&
458 i == 1 &&
459
460 agino < r.ir_startino + XFS_INODES_PER_CHUNK &&
461
462 (chunkidx = agino - r.ir_startino + 1) <
463 XFS_INODES_PER_CHUNK &&
464
465 xfs_inobt_maskn(chunkidx,
466 XFS_INODES_PER_CHUNK - chunkidx) &
467 ~r.ir_free) {
468
469
470
471
472
473 for (i = 0; i < chunkidx; i++) {
474 if (XFS_INOBT_MASK(i) & ~r.ir_free)
475 r.ir_freecount++;
476 }
477 r.ir_free |= xfs_inobt_maskn(0, chunkidx);
478 irbp->ir_startino = r.ir_startino;
479 irbp->ir_freecount = r.ir_freecount;
480 irbp->ir_free = r.ir_free;
481 irbp++;
482 agino = r.ir_startino + XFS_INODES_PER_CHUNK;
483 icount = XFS_INODES_PER_CHUNK - r.ir_freecount;
484 } else {
485
486
487
488
489 agino++;
490 icount = 0;
491 }
492
493
494
495 if (!error)
496 error = xfs_btree_increment(cur, 0, &tmp);
497 } else {
498
499
500
501 error = xfs_inobt_lookup(cur, 0, XFS_LOOKUP_GE, &tmp);
502 icount = 0;
503 }
504
505
506
507
508 while (irbp < irbufend && icount < ubcount) {
509 xfs_inobt_rec_incore_t r;
510
511
512
513
514
515 while (error) {
516 agino += XFS_INODES_PER_CHUNK;
517 if (XFS_AGINO_TO_AGBNO(mp, agino) >=
518 be32_to_cpu(agi->agi_length))
519 break;
520 error = xfs_inobt_lookup(cur, agino,
521 XFS_LOOKUP_GE, &tmp);
522 cond_resched();
523 }
524
525
526
527
528 if (error) {
529 end_of_ag = 1;
530 break;
531 }
532
533 error = xfs_inobt_get_rec(cur, &r, &i);
534 if (error || i == 0) {
535 end_of_ag = 1;
536 break;
537 }
538
539
540
541
542
543 if (r.ir_freecount < XFS_INODES_PER_CHUNK) {
544
545
546
547
548
549 agbno = XFS_AGINO_TO_AGBNO(mp, r.ir_startino);
550 for (chunkidx = 0;
551 chunkidx < XFS_INODES_PER_CHUNK;
552 chunkidx += nicluster,
553 agbno += nbcluster) {
554 if (xfs_inobt_maskn(chunkidx, nicluster)
555 & ~r.ir_free)
556 xfs_btree_reada_bufs(mp, agno,
557 agbno, nbcluster);
558 }
559 irbp->ir_startino = r.ir_startino;
560 irbp->ir_freecount = r.ir_freecount;
561 irbp->ir_free = r.ir_free;
562 irbp++;
563 icount += XFS_INODES_PER_CHUNK - r.ir_freecount;
564 }
565
566
567
568 agino = r.ir_startino + XFS_INODES_PER_CHUNK;
569 error = xfs_btree_increment(cur, 0, &tmp);
570 cond_resched();
571 }
572
573
574
575
576
577 xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
578 xfs_buf_relse(agbp);
579
580
581
582 irbufend = irbp;
583 for (irbp = irbuf;
584 irbp < irbufend && XFS_BULKSTAT_UBLEFT(ubleft); irbp++) {
585
586
587
588 for (agino = irbp->ir_startino, chunkidx = clustidx = 0;
589 XFS_BULKSTAT_UBLEFT(ubleft) &&
590 irbp->ir_freecount < XFS_INODES_PER_CHUNK;
591 chunkidx++, clustidx++, agino++) {
592 ASSERT(chunkidx < XFS_INODES_PER_CHUNK);
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608 if ((chunkidx & (nicluster - 1)) == 0) {
609 agbno = XFS_AGINO_TO_AGBNO(mp,
610 irbp->ir_startino) +
611 ((chunkidx & nimask) >>
612 mp->m_sb.sb_inopblog);
613
614 if (flags & (BULKSTAT_FG_QUICK |
615 BULKSTAT_FG_INLINE)) {
616 int offset;
617
618 ino = XFS_AGINO_TO_INO(mp, agno,
619 agino);
620 bno = XFS_AGB_TO_DADDR(mp, agno,
621 agbno);
622
623
624
625
626 if (bp)
627 xfs_buf_relse(bp);
628
629 error = xfs_inotobp(mp, NULL, ino, &dip,
630 &bp, &offset,
631 XFS_IGET_BULKSTAT);
632
633 if (!error)
634 clustidx = offset / mp->m_sb.sb_inodesize;
635 if (XFS_TEST_ERROR(error != 0,
636 mp, XFS_ERRTAG_BULKSTAT_READ_CHUNK,
637 XFS_RANDOM_BULKSTAT_READ_CHUNK)) {
638 bp = NULL;
639 ubleft = 0;
640 rval = error;
641 break;
642 }
643 }
644 }
645 ino = XFS_AGINO_TO_INO(mp, agno, agino);
646 bno = XFS_AGB_TO_DADDR(mp, agno, agbno);
647
648
649
650 if (XFS_INOBT_MASK(chunkidx) & irbp->ir_free) {
651 lastino = ino;
652 continue;
653 }
654
655
656
657
658 irbp->ir_freecount++;
659 if (!xfs_bulkstat_use_dinode(mp, flags, bp,
660 clustidx, &dip)) {
661 lastino = ino;
662 continue;
663 }
664
665
666
667
668 if ((flags & BULKSTAT_FG_INLINE) && !dip) {
669 if (bp)
670 xfs_buf_relse(bp);
671 bp = NULL;
672 }
673
674
675
676
677
678
679
680
681
682
683
684 ubused = statstruct_size;
685 error = formatter(mp, ino, ubufp,
686 ubleft, private_data,
687 bno, &ubused, dip, &fmterror);
688 if (fmterror == BULKSTAT_RV_NOTHING) {
689 if (error && error != ENOENT &&
690 error != EINVAL) {
691 ubleft = 0;
692 rval = error;
693 break;
694 }
695 lastino = ino;
696 continue;
697 }
698 if (fmterror == BULKSTAT_RV_GIVEUP) {
699 ubleft = 0;
700 ASSERT(error);
701 rval = error;
702 break;
703 }
704 if (ubufp)
705 ubufp += ubused;
706 ubleft -= ubused;
707 ubelem++;
708 lastino = ino;
709 }
710
711 cond_resched();
712 }
713
714 if (bp)
715 xfs_buf_relse(bp);
716
717
718
719
720 if (XFS_BULKSTAT_UBLEFT(ubleft)) {
721 if (end_of_ag) {
722 agno++;
723 agino = 0;
724 } else
725 agino = XFS_INO_TO_AGINO(mp, lastino);
726 } else
727 break;
728 }
729
730
731
732 kmem_free(irbuf);
733 *ubcountp = ubelem;
734
735
736
737 if (ubelem)
738 rval = 0;
739 if (agno >= mp->m_sb.sb_agcount) {
740
741
742
743
744
745 *lastinop = (xfs_ino_t)XFS_AGINO_TO_INO(mp, agno, 0);
746 *done = 1;
747 } else
748 *lastinop = (xfs_ino_t)lastino;
749
750 return rval;
751}
752
753
754
755
756
757int
758xfs_bulkstat_single(
759 xfs_mount_t *mp,
760 xfs_ino_t *lastinop,
761 char __user *buffer,
762 int *done)
763{
764 int count;
765 int error;
766 xfs_ino_t ino;
767 int res;
768
769
770
771
772
773
774
775
776
777
778 ino = (xfs_ino_t)*lastinop;
779 error = xfs_bulkstat_one(mp, ino, buffer, sizeof(xfs_bstat_t),
780 NULL, 0, NULL, NULL, &res);
781 if (error) {
782
783
784
785
786 (*lastinop)--;
787 count = 1;
788 if (xfs_bulkstat(mp, lastinop, &count, xfs_bulkstat_one,
789 NULL, sizeof(xfs_bstat_t), buffer,
790 BULKSTAT_FG_IGET, done))
791 return error;
792 if (count == 0 || (xfs_ino_t)*lastinop != ino)
793 return error == EFSCORRUPTED ?
794 XFS_ERROR(EINVAL) : error;
795 else
796 return 0;
797 }
798 *done = 0;
799 return 0;
800}
801
802int
803xfs_inumbers_fmt(
804 void __user *ubuffer,
805 const xfs_inogrp_t *buffer,
806 long count,
807 long *written)
808{
809 if (copy_to_user(ubuffer, buffer, count * sizeof(*buffer)))
810 return -EFAULT;
811 *written = count * sizeof(*buffer);
812 return 0;
813}
814
815
816
817
818int
819xfs_inumbers(
820 xfs_mount_t *mp,
821 xfs_ino_t *lastino,
822 int *count,
823 void __user *ubuffer,
824 inumbers_fmt_pf formatter)
825{
826 xfs_buf_t *agbp;
827 xfs_agino_t agino;
828 xfs_agnumber_t agno;
829 int bcount;
830 xfs_inogrp_t *buffer;
831 int bufidx;
832 xfs_btree_cur_t *cur;
833 int error;
834 xfs_inobt_rec_incore_t r;
835 int i;
836 xfs_ino_t ino;
837 int left;
838 int tmp;
839
840 ino = (xfs_ino_t)*lastino;
841 agno = XFS_INO_TO_AGNO(mp, ino);
842 agino = XFS_INO_TO_AGINO(mp, ino);
843 left = *count;
844 *count = 0;
845 bcount = MIN(left, (int)(PAGE_SIZE / sizeof(*buffer)));
846 buffer = kmem_alloc(bcount * sizeof(*buffer), KM_SLEEP);
847 error = bufidx = 0;
848 cur = NULL;
849 agbp = NULL;
850 while (left > 0 && agno < mp->m_sb.sb_agcount) {
851 if (agbp == NULL) {
852 down_read(&mp->m_peraglock);
853 error = xfs_ialloc_read_agi(mp, NULL, agno, &agbp);
854 up_read(&mp->m_peraglock);
855 if (error) {
856
857
858
859
860 ASSERT(cur == NULL);
861 agbp = NULL;
862 agno++;
863 agino = 0;
864 continue;
865 }
866 cur = xfs_inobt_init_cursor(mp, NULL, agbp, agno);
867 error = xfs_inobt_lookup(cur, agino, XFS_LOOKUP_GE,
868 &tmp);
869 if (error) {
870 xfs_btree_del_cursor(cur, XFS_BTREE_ERROR);
871 cur = NULL;
872 xfs_buf_relse(agbp);
873 agbp = NULL;
874
875
876
877
878
879 agino += XFS_INODES_PER_CHUNK - 1;
880 continue;
881 }
882 }
883 error = xfs_inobt_get_rec(cur, &r, &i);
884 if (error || i == 0) {
885 xfs_buf_relse(agbp);
886 agbp = NULL;
887 xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
888 cur = NULL;
889 agno++;
890 agino = 0;
891 continue;
892 }
893 agino = r.ir_startino + XFS_INODES_PER_CHUNK - 1;
894 buffer[bufidx].xi_startino =
895 XFS_AGINO_TO_INO(mp, agno, r.ir_startino);
896 buffer[bufidx].xi_alloccount =
897 XFS_INODES_PER_CHUNK - r.ir_freecount;
898 buffer[bufidx].xi_allocmask = ~r.ir_free;
899 bufidx++;
900 left--;
901 if (bufidx == bcount) {
902 long written;
903 if (formatter(ubuffer, buffer, bufidx, &written)) {
904 error = XFS_ERROR(EFAULT);
905 break;
906 }
907 ubuffer += written;
908 *count += bufidx;
909 bufidx = 0;
910 }
911 if (left) {
912 error = xfs_btree_increment(cur, 0, &tmp);
913 if (error) {
914 xfs_btree_del_cursor(cur, XFS_BTREE_ERROR);
915 cur = NULL;
916 xfs_buf_relse(agbp);
917 agbp = NULL;
918
919
920
921
922 agino += XFS_INODES_PER_CHUNK;
923 continue;
924 }
925 }
926 }
927 if (!error) {
928 if (bufidx) {
929 long written;
930 if (formatter(ubuffer, buffer, bufidx, &written))
931 error = XFS_ERROR(EFAULT);
932 else
933 *count += bufidx;
934 }
935 *lastino = XFS_AGINO_TO_INO(mp, agno, agino);
936 }
937 kmem_free(buffer);
938 if (cur)
939 xfs_btree_del_cursor(cur, (error ? XFS_BTREE_ERROR :
940 XFS_BTREE_NOERROR));
941 if (agbp)
942 xfs_buf_relse(agbp);
943 return error;
944}
945