2 * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
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.
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.
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
20 #include "xfs_types.h"
24 #include "xfs_trans.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"
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
)));
53 * Return stat information for one inode.
54 * Return 0 if ok, else errno.
58 struct xfs_mount
*mp
, /* mount point for filesystem */
59 xfs_ino_t ino
, /* inode to get data for */
60 void __user
*buffer
, /* buffer to place output in */
61 int ubsize
, /* size of buffer */
62 bulkstat_one_fmt_pf formatter
, /* formatter, copy to user */
63 int *ubused
, /* bytes used by me */
64 int *stat
) /* BULKSTAT_RV_... */
66 struct xfs_icdinode
*dic
; /* dinode core info pointer */
67 struct xfs_inode
*ip
; /* incore inode pointer */
69 struct xfs_bstat
*buf
; /* return buffer */
70 int error
= 0; /* error value */
72 *stat
= BULKSTAT_RV_NOTHING
;
74 if (!buffer
|| xfs_internal_inum(mp
, ino
))
75 return XFS_ERROR(EINVAL
);
77 buf
= kmem_alloc(sizeof(*buf
), KM_SLEEP
| KM_MAYFAIL
);
79 return XFS_ERROR(ENOMEM
);
81 error
= xfs_iget(mp
, NULL
, ino
,
82 XFS_IGET_UNTRUSTED
, XFS_ILOCK_SHARED
, &ip
);
84 *stat
= BULKSTAT_RV_NOTHING
;
89 ASSERT(ip
->i_imap
.im_blkno
!= 0);
94 /* xfs_iget returns the following without needing
97 buf
->bs_nlink
= dic
->di_nlink
;
98 buf
->bs_projid
= dic
->di_projid
;
100 buf
->bs_mode
= dic
->di_mode
;
101 buf
->bs_uid
= dic
->di_uid
;
102 buf
->bs_gid
= dic
->di_gid
;
103 buf
->bs_size
= dic
->di_size
;
106 * We need to read the timestamps from the Linux inode because
107 * the VFS keeps writing directly into the inode structure instead
108 * of telling us about the updates.
110 buf
->bs_atime
.tv_sec
= inode
->i_atime
.tv_sec
;
111 buf
->bs_atime
.tv_nsec
= inode
->i_atime
.tv_nsec
;
112 buf
->bs_mtime
.tv_sec
= inode
->i_mtime
.tv_sec
;
113 buf
->bs_mtime
.tv_nsec
= inode
->i_mtime
.tv_nsec
;
114 buf
->bs_ctime
.tv_sec
= inode
->i_ctime
.tv_sec
;
115 buf
->bs_ctime
.tv_nsec
= inode
->i_ctime
.tv_nsec
;
117 buf
->bs_xflags
= xfs_ip2xflags(ip
);
118 buf
->bs_extsize
= dic
->di_extsize
<< mp
->m_sb
.sb_blocklog
;
119 buf
->bs_extents
= dic
->di_nextents
;
120 buf
->bs_gen
= dic
->di_gen
;
121 memset(buf
->bs_pad
, 0, sizeof(buf
->bs_pad
));
122 buf
->bs_dmevmask
= dic
->di_dmevmask
;
123 buf
->bs_dmstate
= dic
->di_dmstate
;
124 buf
->bs_aextents
= dic
->di_anextents
;
125 buf
->bs_forkoff
= XFS_IFORK_BOFF(ip
);
127 switch (dic
->di_format
) {
128 case XFS_DINODE_FMT_DEV
:
129 buf
->bs_rdev
= ip
->i_df
.if_u2
.if_rdev
;
130 buf
->bs_blksize
= BLKDEV_IOSIZE
;
133 case XFS_DINODE_FMT_LOCAL
:
134 case XFS_DINODE_FMT_UUID
:
136 buf
->bs_blksize
= mp
->m_sb
.sb_blocksize
;
139 case XFS_DINODE_FMT_EXTENTS
:
140 case XFS_DINODE_FMT_BTREE
:
142 buf
->bs_blksize
= mp
->m_sb
.sb_blocksize
;
143 buf
->bs_blocks
= dic
->di_nblocks
+ ip
->i_delayed_blks
;
146 xfs_iput(ip
, XFS_ILOCK_SHARED
);
148 error
= formatter(buffer
, ubsize
, ubused
, buf
);
151 *stat
= BULKSTAT_RV_DIDONE
;
158 /* Return 0 on success or positive error */
160 xfs_bulkstat_one_fmt(
161 void __user
*ubuffer
,
164 const xfs_bstat_t
*buffer
)
166 if (ubsize
< sizeof(*buffer
))
167 return XFS_ERROR(ENOMEM
);
168 if (copy_to_user(ubuffer
, buffer
, sizeof(*buffer
)))
169 return XFS_ERROR(EFAULT
);
171 *ubused
= sizeof(*buffer
);
177 xfs_mount_t
*mp
, /* mount point for filesystem */
178 xfs_ino_t ino
, /* inode number to get data for */
179 void __user
*buffer
, /* buffer to place output in */
180 int ubsize
, /* size of buffer */
181 int *ubused
, /* bytes used by me */
182 int *stat
) /* BULKSTAT_RV_... */
184 return xfs_bulkstat_one_int(mp
, ino
, buffer
, ubsize
,
185 xfs_bulkstat_one_fmt
, ubused
, stat
);
188 #define XFS_BULKSTAT_UBLEFT(ubleft) ((ubleft) >= statstruct_size)
191 * Return stat information in bulk (by-inode) for the filesystem.
193 int /* error status */
195 xfs_mount_t
*mp
, /* mount point for filesystem */
196 xfs_ino_t
*lastinop
, /* last inode returned */
197 int *ubcountp
, /* size of buffer/count returned */
198 bulkstat_one_pf formatter
, /* func that'd fill a single buf */
199 size_t statstruct_size
, /* sizeof struct filling */
200 char __user
*ubuffer
, /* buffer with inode stats */
201 int *done
) /* 1 if there are more stats to get */
203 xfs_agblock_t agbno
=0;/* allocation group block number */
204 xfs_buf_t
*agbp
; /* agi header buffer */
205 xfs_agi_t
*agi
; /* agi header data */
206 xfs_agino_t agino
; /* inode # in allocation group */
207 xfs_agnumber_t agno
; /* allocation group number */
208 xfs_daddr_t bno
; /* inode cluster start daddr */
209 int chunkidx
; /* current index into inode chunk */
210 int clustidx
; /* current index into inode cluster */
211 xfs_btree_cur_t
*cur
; /* btree cursor for ialloc btree */
212 int end_of_ag
; /* set if we've seen the ag end */
213 int error
; /* error code */
214 int fmterror
;/* bulkstat formatter result */
215 int i
; /* loop index */
216 int icount
; /* count of inodes good in irbuf */
217 size_t irbsize
; /* size of irec buffer in bytes */
218 xfs_ino_t ino
; /* inode number (filesystem) */
219 xfs_inobt_rec_incore_t
*irbp
; /* current irec buffer pointer */
220 xfs_inobt_rec_incore_t
*irbuf
; /* start of irec buffer */
221 xfs_inobt_rec_incore_t
*irbufend
; /* end of good irec buffer entries */
222 xfs_ino_t lastino
; /* last inode number returned */
223 int nbcluster
; /* # of blocks in a cluster */
224 int nicluster
; /* # of inodes in a cluster */
225 int nimask
; /* mask for inode clusters */
226 int nirbuf
; /* size of irbuf */
227 int rval
; /* return value error code */
228 int tmp
; /* result value from btree calls */
229 int ubcount
; /* size of user's buffer */
230 int ubleft
; /* bytes left in user's buffer */
231 char __user
*ubufp
; /* pointer into user's buffer */
232 int ubelem
; /* spaces used in user's buffer */
233 int ubused
; /* bytes used by formatter */
234 xfs_buf_t
*bp
; /* ptr to on-disk inode cluster buf */
237 * Get the last inode value, see if there's nothing to do.
239 ino
= (xfs_ino_t
)*lastinop
;
241 agno
= XFS_INO_TO_AGNO(mp
, ino
);
242 agino
= XFS_INO_TO_AGINO(mp
, ino
);
243 if (agno
>= mp
->m_sb
.sb_agcount
||
244 ino
!= XFS_AGINO_TO_INO(mp
, agno
, agino
)) {
249 if (!ubcountp
|| *ubcountp
<= 0) {
252 ubcount
= *ubcountp
; /* statstruct's */
253 ubleft
= ubcount
* statstruct_size
; /* bytes */
254 *ubcountp
= ubelem
= 0;
258 nicluster
= mp
->m_sb
.sb_blocksize
>= XFS_INODE_CLUSTER_SIZE(mp
) ?
259 mp
->m_sb
.sb_inopblock
:
260 (XFS_INODE_CLUSTER_SIZE(mp
) >> mp
->m_sb
.sb_inodelog
);
261 nimask
= ~(nicluster
- 1);
262 nbcluster
= nicluster
>> mp
->m_sb
.sb_inopblog
;
263 irbuf
= kmem_zalloc_greedy(&irbsize
, PAGE_SIZE
, PAGE_SIZE
* 4);
267 nirbuf
= irbsize
/ sizeof(*irbuf
);
270 * Loop over the allocation groups, starting from the last
271 * inode returned; 0 means start of the allocation group.
274 while (XFS_BULKSTAT_UBLEFT(ubleft
) && agno
< mp
->m_sb
.sb_agcount
) {
277 error
= xfs_ialloc_read_agi(mp
, NULL
, agno
, &agbp
);
280 * Skip this allocation group and go to the next one.
286 agi
= XFS_BUF_TO_AGI(agbp
);
288 * Allocate and initialize a btree cursor for ialloc btree.
290 cur
= xfs_inobt_init_cursor(mp
, NULL
, agbp
, agno
);
292 irbufend
= irbuf
+ nirbuf
;
295 * If we're returning in the middle of an allocation group,
296 * we need to get the remainder of the chunk we're in.
299 xfs_inobt_rec_incore_t r
;
302 * Lookup the inode chunk that this inode lives in.
304 error
= xfs_inobt_lookup(cur
, agino
, XFS_LOOKUP_LE
,
306 if (!error
&& /* no I/O error */
307 tmp
&& /* lookup succeeded */
308 /* got the record, should always work */
309 !(error
= xfs_inobt_get_rec(cur
, &r
, &i
)) &&
311 /* this is the right chunk */
312 agino
< r
.ir_startino
+ XFS_INODES_PER_CHUNK
&&
313 /* lastino was not last in chunk */
314 (chunkidx
= agino
- r
.ir_startino
+ 1) <
315 XFS_INODES_PER_CHUNK
&&
316 /* there are some left allocated */
317 xfs_inobt_maskn(chunkidx
,
318 XFS_INODES_PER_CHUNK
- chunkidx
) &
321 * Grab the chunk record. Mark all the
322 * uninteresting inodes (because they're
323 * before our start point) free.
325 for (i
= 0; i
< chunkidx
; i
++) {
326 if (XFS_INOBT_MASK(i
) & ~r
.ir_free
)
329 r
.ir_free
|= xfs_inobt_maskn(0, chunkidx
);
330 irbp
->ir_startino
= r
.ir_startino
;
331 irbp
->ir_freecount
= r
.ir_freecount
;
332 irbp
->ir_free
= r
.ir_free
;
334 agino
= r
.ir_startino
+ XFS_INODES_PER_CHUNK
;
335 icount
= XFS_INODES_PER_CHUNK
- r
.ir_freecount
;
338 * If any of those tests failed, bump the
339 * inode number (just in case).
345 * In any case, increment to the next record.
348 error
= xfs_btree_increment(cur
, 0, &tmp
);
351 * Start of ag. Lookup the first inode chunk.
353 error
= xfs_inobt_lookup(cur
, 0, XFS_LOOKUP_GE
, &tmp
);
357 * Loop through inode btree records in this ag,
358 * until we run out of inodes or space in the buffer.
360 while (irbp
< irbufend
&& icount
< ubcount
) {
361 xfs_inobt_rec_incore_t r
;
364 * Loop as long as we're unable to read the
368 agino
+= XFS_INODES_PER_CHUNK
;
369 if (XFS_AGINO_TO_AGBNO(mp
, agino
) >=
370 be32_to_cpu(agi
->agi_length
))
372 error
= xfs_inobt_lookup(cur
, agino
,
373 XFS_LOOKUP_GE
, &tmp
);
377 * If ran off the end of the ag either with an error,
378 * or the normal way, set end and stop collecting.
385 error
= xfs_inobt_get_rec(cur
, &r
, &i
);
386 if (error
|| i
== 0) {
392 * If this chunk has any allocated inodes, save it.
393 * Also start read-ahead now for this chunk.
395 if (r
.ir_freecount
< XFS_INODES_PER_CHUNK
) {
397 * Loop over all clusters in the next chunk.
398 * Do a readahead if there are any allocated
399 * inodes in that cluster.
401 agbno
= XFS_AGINO_TO_AGBNO(mp
, r
.ir_startino
);
403 chunkidx
< XFS_INODES_PER_CHUNK
;
404 chunkidx
+= nicluster
,
405 agbno
+= nbcluster
) {
406 if (xfs_inobt_maskn(chunkidx
, nicluster
)
408 xfs_btree_reada_bufs(mp
, agno
,
411 irbp
->ir_startino
= r
.ir_startino
;
412 irbp
->ir_freecount
= r
.ir_freecount
;
413 irbp
->ir_free
= r
.ir_free
;
415 icount
+= XFS_INODES_PER_CHUNK
- r
.ir_freecount
;
418 * Set agino to after this chunk and bump the cursor.
420 agino
= r
.ir_startino
+ XFS_INODES_PER_CHUNK
;
421 error
= xfs_btree_increment(cur
, 0, &tmp
);
425 * Drop the btree buffers and the agi buffer.
426 * We can't hold any of the locks these represent
429 xfs_btree_del_cursor(cur
, XFS_BTREE_NOERROR
);
432 * Now format all the good inodes into the user's buffer.
436 irbp
< irbufend
&& XFS_BULKSTAT_UBLEFT(ubleft
); irbp
++) {
438 * Now process this chunk of inodes.
440 for (agino
= irbp
->ir_startino
, chunkidx
= clustidx
= 0;
441 XFS_BULKSTAT_UBLEFT(ubleft
) &&
442 irbp
->ir_freecount
< XFS_INODES_PER_CHUNK
;
443 chunkidx
++, clustidx
++, agino
++) {
444 ASSERT(chunkidx
< XFS_INODES_PER_CHUNK
);
446 * Recompute agbno if this is the
447 * first inode of the cluster.
449 * Careful with clustidx. There can be
450 * multiple clusters per chunk, a single
451 * cluster per chunk or a cluster that has
452 * inodes represented from several different
453 * chunks (if blocksize is large).
455 * Because of this, the starting clustidx is
456 * initialized to zero in this loop but must
457 * later be reset after reading in the cluster
460 if ((chunkidx
& (nicluster
- 1)) == 0) {
461 agbno
= XFS_AGINO_TO_AGBNO(mp
,
463 ((chunkidx
& nimask
) >>
464 mp
->m_sb
.sb_inopblog
);
466 ino
= XFS_AGINO_TO_INO(mp
, agno
, agino
);
467 bno
= XFS_AGB_TO_DADDR(mp
, agno
, agbno
);
469 * Skip if this inode is free.
471 if (XFS_INOBT_MASK(chunkidx
) & irbp
->ir_free
) {
476 * Count used inodes as free so we can tell
477 * when the chunk is used up.
479 irbp
->ir_freecount
++;
482 * Get the inode and fill in a single buffer.
484 ubused
= statstruct_size
;
485 error
= formatter(mp
, ino
, ubufp
, ubleft
,
487 if (fmterror
== BULKSTAT_RV_NOTHING
) {
488 if (error
&& error
!= ENOENT
&&
497 if (fmterror
== BULKSTAT_RV_GIVEUP
) {
517 * Set up for the next loop iteration.
519 if (XFS_BULKSTAT_UBLEFT(ubleft
)) {
524 agino
= XFS_INO_TO_AGINO(mp
, lastino
);
529 * Done, we're either out of filesystem or space to put the data.
531 kmem_free_large(irbuf
);
534 * Found some inodes, return them now and return the error next time.
538 if (agno
>= mp
->m_sb
.sb_agcount
) {
540 * If we ran out of filesystem, mark lastino as off
541 * the end of the filesystem, so the next call
542 * will return immediately.
544 *lastinop
= (xfs_ino_t
)XFS_AGINO_TO_INO(mp
, agno
, 0);
547 *lastinop
= (xfs_ino_t
)lastino
;
553 * Return stat information in bulk (by-inode) for the filesystem.
554 * Special case for non-sequential one inode bulkstat.
556 int /* error status */
558 xfs_mount_t
*mp
, /* mount point for filesystem */
559 xfs_ino_t
*lastinop
, /* inode to return */
560 char __user
*buffer
, /* buffer with inode stats */
561 int *done
) /* 1 if there are more stats to get */
563 int count
; /* count value for bulkstat call */
564 int error
; /* return value */
565 xfs_ino_t ino
; /* filesystem inode number */
566 int res
; /* result from bs1 */
569 * note that requesting valid inode numbers which are not allocated
570 * to inodes will most likely cause xfs_itobp to generate warning
571 * messages about bad magic numbers. This is ok. The fact that
572 * the inode isn't actually an inode is handled by the
573 * error check below. Done this way to make the usual case faster
574 * at the expense of the error case.
577 ino
= (xfs_ino_t
)*lastinop
;
578 error
= xfs_bulkstat_one(mp
, ino
, buffer
, sizeof(xfs_bstat_t
), 0, &res
);
581 * Special case way failed, do it the "long" way
582 * to see if that works.
586 if (xfs_bulkstat(mp
, lastinop
, &count
, xfs_bulkstat_one
,
587 sizeof(xfs_bstat_t
), buffer
, done
))
589 if (count
== 0 || (xfs_ino_t
)*lastinop
!= ino
)
590 return error
== EFSCORRUPTED
?
591 XFS_ERROR(EINVAL
) : error
;
601 void __user
*ubuffer
, /* buffer to write to */
602 const xfs_inogrp_t
*buffer
, /* buffer to read from */
603 long count
, /* # of elements to read */
604 long *written
) /* # of bytes written */
606 if (copy_to_user(ubuffer
, buffer
, count
* sizeof(*buffer
)))
608 *written
= count
* sizeof(*buffer
);
613 * Return inode number table for the filesystem.
615 int /* error status */
617 xfs_mount_t
*mp
, /* mount point for filesystem */
618 xfs_ino_t
*lastino
, /* last inode returned */
619 int *count
, /* size of buffer/count returned */
620 void __user
*ubuffer
,/* buffer with inode descriptions */
621 inumbers_fmt_pf formatter
)
627 xfs_inogrp_t
*buffer
;
629 xfs_btree_cur_t
*cur
;
631 xfs_inobt_rec_incore_t r
;
637 ino
= (xfs_ino_t
)*lastino
;
638 agno
= XFS_INO_TO_AGNO(mp
, ino
);
639 agino
= XFS_INO_TO_AGINO(mp
, ino
);
642 bcount
= MIN(left
, (int)(PAGE_SIZE
/ sizeof(*buffer
)));
643 buffer
= kmem_alloc(bcount
* sizeof(*buffer
), KM_SLEEP
);
647 while (left
> 0 && agno
< mp
->m_sb
.sb_agcount
) {
649 error
= xfs_ialloc_read_agi(mp
, NULL
, agno
, &agbp
);
652 * If we can't read the AGI of this ag,
653 * then just skip to the next one.
661 cur
= xfs_inobt_init_cursor(mp
, NULL
, agbp
, agno
);
662 error
= xfs_inobt_lookup(cur
, agino
, XFS_LOOKUP_GE
,
665 xfs_btree_del_cursor(cur
, XFS_BTREE_ERROR
);
670 * Move up the last inode in the current
671 * chunk. The lookup_ge will always get
672 * us the first inode in the next chunk.
674 agino
+= XFS_INODES_PER_CHUNK
- 1;
678 error
= xfs_inobt_get_rec(cur
, &r
, &i
);
679 if (error
|| i
== 0) {
682 xfs_btree_del_cursor(cur
, XFS_BTREE_NOERROR
);
688 agino
= r
.ir_startino
+ XFS_INODES_PER_CHUNK
- 1;
689 buffer
[bufidx
].xi_startino
=
690 XFS_AGINO_TO_INO(mp
, agno
, r
.ir_startino
);
691 buffer
[bufidx
].xi_alloccount
=
692 XFS_INODES_PER_CHUNK
- r
.ir_freecount
;
693 buffer
[bufidx
].xi_allocmask
= ~r
.ir_free
;
696 if (bufidx
== bcount
) {
698 if (formatter(ubuffer
, buffer
, bufidx
, &written
)) {
699 error
= XFS_ERROR(EFAULT
);
707 error
= xfs_btree_increment(cur
, 0, &tmp
);
709 xfs_btree_del_cursor(cur
, XFS_BTREE_ERROR
);
714 * The agino value has already been bumped.
715 * Just try to skip up to it.
717 agino
+= XFS_INODES_PER_CHUNK
;
725 if (formatter(ubuffer
, buffer
, bufidx
, &written
))
726 error
= XFS_ERROR(EFAULT
);
730 *lastino
= XFS_AGINO_TO_INO(mp
, agno
, agino
);
734 xfs_btree_del_cursor(cur
, (error
? XFS_BTREE_ERROR
: