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_shared.h"
21 #include "xfs_format.h"
22 #include "xfs_log_format.h"
23 #include "xfs_trans_resv.h"
27 #include "xfs_mount.h"
28 #include "xfs_inode.h"
29 #include "xfs_btree.h"
30 #include "xfs_ialloc.h"
31 #include "xfs_ialloc_btree.h"
32 #include "xfs_itable.h"
33 #include "xfs_error.h"
34 #include "xfs_trace.h"
35 #include "xfs_icache.h"
36 #include "xfs_dinode.h"
43 return (ino
== mp
->m_sb
.sb_rbmino
|| ino
== mp
->m_sb
.sb_rsumino
||
44 (xfs_sb_version_hasquota(&mp
->m_sb
) &&
45 xfs_is_quota_inode(&mp
->m_sb
, ino
)));
49 * Return stat information for one inode.
50 * Return 0 if ok, else errno.
54 struct xfs_mount
*mp
, /* mount point for filesystem */
55 xfs_ino_t ino
, /* inode to get data for */
56 void __user
*buffer
, /* buffer to place output in */
57 int ubsize
, /* size of buffer */
58 bulkstat_one_fmt_pf formatter
, /* formatter, copy to user */
59 int *ubused
, /* bytes used by me */
60 int *stat
) /* BULKSTAT_RV_... */
62 struct xfs_icdinode
*dic
; /* dinode core info pointer */
63 struct xfs_inode
*ip
; /* incore inode pointer */
64 struct xfs_bstat
*buf
; /* return buffer */
65 int error
= 0; /* error value */
67 *stat
= BULKSTAT_RV_NOTHING
;
69 if (!buffer
|| xfs_internal_inum(mp
, ino
))
72 buf
= kmem_alloc(sizeof(*buf
), KM_SLEEP
| KM_MAYFAIL
);
76 error
= xfs_iget(mp
, NULL
, ino
,
77 (XFS_IGET_DONTCACHE
| XFS_IGET_UNTRUSTED
),
78 XFS_ILOCK_SHARED
, &ip
);
83 ASSERT(ip
->i_imap
.im_blkno
!= 0);
87 /* xfs_iget returns the following without needing
90 buf
->bs_nlink
= dic
->di_nlink
;
91 buf
->bs_projid_lo
= dic
->di_projid_lo
;
92 buf
->bs_projid_hi
= dic
->di_projid_hi
;
94 buf
->bs_mode
= dic
->di_mode
;
95 buf
->bs_uid
= dic
->di_uid
;
96 buf
->bs_gid
= dic
->di_gid
;
97 buf
->bs_size
= dic
->di_size
;
98 buf
->bs_atime
.tv_sec
= dic
->di_atime
.t_sec
;
99 buf
->bs_atime
.tv_nsec
= dic
->di_atime
.t_nsec
;
100 buf
->bs_mtime
.tv_sec
= dic
->di_mtime
.t_sec
;
101 buf
->bs_mtime
.tv_nsec
= dic
->di_mtime
.t_nsec
;
102 buf
->bs_ctime
.tv_sec
= dic
->di_ctime
.t_sec
;
103 buf
->bs_ctime
.tv_nsec
= dic
->di_ctime
.t_nsec
;
104 buf
->bs_xflags
= xfs_ip2xflags(ip
);
105 buf
->bs_extsize
= dic
->di_extsize
<< mp
->m_sb
.sb_blocklog
;
106 buf
->bs_extents
= dic
->di_nextents
;
107 buf
->bs_gen
= dic
->di_gen
;
108 memset(buf
->bs_pad
, 0, sizeof(buf
->bs_pad
));
109 buf
->bs_dmevmask
= dic
->di_dmevmask
;
110 buf
->bs_dmstate
= dic
->di_dmstate
;
111 buf
->bs_aextents
= dic
->di_anextents
;
112 buf
->bs_forkoff
= XFS_IFORK_BOFF(ip
);
114 switch (dic
->di_format
) {
115 case XFS_DINODE_FMT_DEV
:
116 buf
->bs_rdev
= ip
->i_df
.if_u2
.if_rdev
;
117 buf
->bs_blksize
= BLKDEV_IOSIZE
;
120 case XFS_DINODE_FMT_LOCAL
:
121 case XFS_DINODE_FMT_UUID
:
123 buf
->bs_blksize
= mp
->m_sb
.sb_blocksize
;
126 case XFS_DINODE_FMT_EXTENTS
:
127 case XFS_DINODE_FMT_BTREE
:
129 buf
->bs_blksize
= mp
->m_sb
.sb_blocksize
;
130 buf
->bs_blocks
= dic
->di_nblocks
+ ip
->i_delayed_blks
;
133 xfs_iunlock(ip
, XFS_ILOCK_SHARED
);
136 error
= formatter(buffer
, ubsize
, ubused
, buf
);
138 *stat
= BULKSTAT_RV_DIDONE
;
145 /* Return 0 on success or positive error */
147 xfs_bulkstat_one_fmt(
148 void __user
*ubuffer
,
151 const xfs_bstat_t
*buffer
)
153 if (ubsize
< sizeof(*buffer
))
155 if (copy_to_user(ubuffer
, buffer
, sizeof(*buffer
)))
158 *ubused
= sizeof(*buffer
);
164 xfs_mount_t
*mp
, /* mount point for filesystem */
165 xfs_ino_t ino
, /* inode number to get data for */
166 void __user
*buffer
, /* buffer to place output in */
167 int ubsize
, /* size of buffer */
168 int *ubused
, /* bytes used by me */
169 int *stat
) /* BULKSTAT_RV_... */
171 return xfs_bulkstat_one_int(mp
, ino
, buffer
, ubsize
,
172 xfs_bulkstat_one_fmt
, ubused
, stat
);
176 * Loop over all clusters in a chunk for a given incore inode allocation btree
177 * record. Do a readahead if there are any allocated inodes in that cluster.
180 xfs_bulkstat_ichunk_ra(
181 struct xfs_mount
*mp
,
183 struct xfs_inobt_rec_incore
*irec
)
186 struct blk_plug plug
;
187 int blks_per_cluster
;
188 int inodes_per_cluster
;
189 int i
; /* inode chunk index */
191 agbno
= XFS_AGINO_TO_AGBNO(mp
, irec
->ir_startino
);
192 blks_per_cluster
= xfs_icluster_size_fsb(mp
);
193 inodes_per_cluster
= blks_per_cluster
<< mp
->m_sb
.sb_inopblog
;
195 blk_start_plug(&plug
);
196 for (i
= 0; i
< XFS_INODES_PER_CHUNK
;
197 i
+= inodes_per_cluster
, agbno
+= blks_per_cluster
) {
198 if (xfs_inobt_maskn(i
, inodes_per_cluster
) & ~irec
->ir_free
) {
199 xfs_btree_reada_bufs(mp
, agno
, agbno
, blks_per_cluster
,
203 blk_finish_plug(&plug
);
207 * Lookup the inode chunk that the given inode lives in and then get the record
208 * if we found the chunk. If the inode was not the last in the chunk and there
209 * are some left allocated, update the data for the pointed-to record as well as
210 * return the count of grabbed inodes.
213 xfs_bulkstat_grab_ichunk(
214 struct xfs_btree_cur
*cur
, /* btree cursor */
215 xfs_agino_t agino
, /* starting inode of chunk */
216 int *icount
,/* return # of inodes grabbed */
217 struct xfs_inobt_rec_incore
*irec
) /* btree record */
219 int idx
; /* index into inode chunk */
223 /* Lookup the inode chunk that this inode lives in */
224 error
= xfs_inobt_lookup(cur
, agino
, XFS_LOOKUP_LE
, &stat
);
232 /* Get the record, should always work */
233 error
= xfs_inobt_get_rec(cur
, irec
, &stat
);
236 XFS_WANT_CORRUPTED_RETURN(stat
== 1);
238 /* Check if the record contains the inode in request */
239 if (irec
->ir_startino
+ XFS_INODES_PER_CHUNK
<= agino
) {
244 idx
= agino
- irec
->ir_startino
+ 1;
245 if (idx
< XFS_INODES_PER_CHUNK
&&
246 (xfs_inobt_maskn(idx
, XFS_INODES_PER_CHUNK
- idx
) & ~irec
->ir_free
)) {
249 /* We got a right chunk with some left inodes allocated at it.
250 * Grab the chunk record. Mark all the uninteresting inodes
251 * free -- because they're before our start point.
253 for (i
= 0; i
< idx
; i
++) {
254 if (XFS_INOBT_MASK(i
) & ~irec
->ir_free
)
255 irec
->ir_freecount
++;
258 irec
->ir_free
|= xfs_inobt_maskn(0, idx
);
259 *icount
= XFS_INODES_PER_CHUNK
- irec
->ir_freecount
;
265 #define XFS_BULKSTAT_UBLEFT(ubleft) ((ubleft) >= statstruct_size)
267 struct xfs_bulkstat_agichunk
{
268 char __user
**ac_ubuffer
;/* pointer into user's buffer */
269 int ac_ubleft
; /* bytes left in user's buffer */
270 int ac_ubelem
; /* spaces used in user's buffer */
274 * Process inodes in chunk with a pointer to a formatter function
275 * that will iget the inode and fill in the appropriate structure.
278 xfs_bulkstat_ag_ichunk(
279 struct xfs_mount
*mp
,
281 struct xfs_inobt_rec_incore
*irbp
,
282 bulkstat_one_pf formatter
,
283 size_t statstruct_size
,
284 struct xfs_bulkstat_agichunk
*acp
,
287 char __user
**ubufp
= acp
->ac_ubuffer
;
292 agino
= irbp
->ir_startino
;
293 for (chunkidx
= 0; chunkidx
< XFS_INODES_PER_CHUNK
;
294 chunkidx
++, agino
++) {
297 xfs_ino_t ino
= XFS_AGINO_TO_INO(mp
, agno
, agino
);
299 /* Skip if this inode is free */
300 if (XFS_INOBT_MASK(chunkidx
) & irbp
->ir_free
) {
305 /* Get the inode and fill in a single buffer */
306 ubused
= statstruct_size
;
307 error
= formatter(mp
, ino
, *ubufp
, acp
->ac_ubleft
,
309 if (fmterror
== BULKSTAT_RV_GIVEUP
||
310 (error
&& error
!= -ENOENT
&& error
!= -EINVAL
)) {
316 /* be careful not to leak error if at end of chunk */
317 if (fmterror
== BULKSTAT_RV_NOTHING
|| error
) {
324 acp
->ac_ubleft
-= ubused
;
328 if (acp
->ac_ubleft
< statstruct_size
)
336 * Return stat information in bulk (by-inode) for the filesystem.
338 int /* error status */
340 xfs_mount_t
*mp
, /* mount point for filesystem */
341 xfs_ino_t
*lastinop
, /* last inode returned */
342 int *ubcountp
, /* size of buffer/count returned */
343 bulkstat_one_pf formatter
, /* func that'd fill a single buf */
344 size_t statstruct_size
, /* sizeof struct filling */
345 char __user
*ubuffer
, /* buffer with inode stats */
346 int *done
) /* 1 if there are more stats to get */
348 xfs_buf_t
*agbp
; /* agi header buffer */
349 xfs_agi_t
*agi
; /* agi header data */
350 xfs_agino_t agino
; /* inode # in allocation group */
351 xfs_agnumber_t agno
; /* allocation group number */
352 xfs_btree_cur_t
*cur
; /* btree cursor for ialloc btree */
353 size_t irbsize
; /* size of irec buffer in bytes */
354 xfs_inobt_rec_incore_t
*irbuf
; /* start of irec buffer */
355 xfs_ino_t lastino
; /* last inode number returned */
356 int nirbuf
; /* size of irbuf */
357 int ubcount
; /* size of user's buffer */
358 struct xfs_bulkstat_agichunk ac
;
362 * Get the last inode value, see if there's nothing to do.
365 agno
= XFS_INO_TO_AGNO(mp
, lastino
);
366 agino
= XFS_INO_TO_AGINO(mp
, lastino
);
367 if (agno
>= mp
->m_sb
.sb_agcount
||
368 lastino
!= XFS_AGINO_TO_INO(mp
, agno
, agino
)) {
374 ubcount
= *ubcountp
; /* statstruct's */
375 ac
.ac_ubuffer
= &ubuffer
;
376 ac
.ac_ubleft
= ubcount
* statstruct_size
; /* bytes */;
382 irbuf
= kmem_zalloc_greedy(&irbsize
, PAGE_SIZE
, PAGE_SIZE
* 4);
386 nirbuf
= irbsize
/ sizeof(*irbuf
);
389 * Loop over the allocation groups, starting from the last
390 * inode returned; 0 means start of the allocation group.
392 while (agno
< mp
->m_sb
.sb_agcount
) {
393 struct xfs_inobt_rec_incore
*irbp
= irbuf
;
394 struct xfs_inobt_rec_incore
*irbufend
= irbuf
+ nirbuf
;
395 bool end_of_ag
= false;
399 error
= xfs_ialloc_read_agi(mp
, NULL
, agno
, &agbp
);
402 agi
= XFS_BUF_TO_AGI(agbp
);
404 * Allocate and initialize a btree cursor for ialloc btree.
406 cur
= xfs_inobt_init_cursor(mp
, NULL
, agbp
, agno
,
410 * In the middle of an allocation group, we need to get
411 * the remainder of the chunk we're in.
413 struct xfs_inobt_rec_incore r
;
415 error
= xfs_bulkstat_grab_ichunk(cur
, agino
, &icount
, &r
);
419 irbp
->ir_startino
= r
.ir_startino
;
420 irbp
->ir_freecount
= r
.ir_freecount
;
421 irbp
->ir_free
= r
.ir_free
;
423 agino
= r
.ir_startino
+ XFS_INODES_PER_CHUNK
;
425 /* Increment to the next record */
426 error
= xfs_btree_increment(cur
, 0, &stat
);
428 /* Start of ag. Lookup the first inode chunk */
429 error
= xfs_inobt_lookup(cur
, 0, XFS_LOOKUP_GE
, &stat
);
431 if (error
|| stat
== 0) {
437 * Loop through inode btree records in this ag,
438 * until we run out of inodes or space in the buffer.
440 while (irbp
< irbufend
&& icount
< ubcount
) {
441 struct xfs_inobt_rec_incore r
;
443 error
= xfs_inobt_get_rec(cur
, &r
, &stat
);
444 if (error
|| stat
== 0) {
450 * If this chunk has any allocated inodes, save it.
451 * Also start read-ahead now for this chunk.
453 if (r
.ir_freecount
< XFS_INODES_PER_CHUNK
) {
454 xfs_bulkstat_ichunk_ra(mp
, agno
, &r
);
455 irbp
->ir_startino
= r
.ir_startino
;
456 irbp
->ir_freecount
= r
.ir_freecount
;
457 irbp
->ir_free
= r
.ir_free
;
459 icount
+= XFS_INODES_PER_CHUNK
- r
.ir_freecount
;
462 * Set agino to after this chunk and bump the cursor.
464 agino
= r
.ir_startino
+ XFS_INODES_PER_CHUNK
;
465 error
= xfs_btree_increment(cur
, 0, &stat
);
466 if (error
|| stat
== 0) {
474 * Drop the btree buffers and the agi buffer as we can't hold any
475 * of the locks these represent when calling iget. If there is a
476 * pending error, then we are done.
479 xfs_btree_del_cursor(cur
, XFS_BTREE_NOERROR
);
484 * Now format all the good inodes into the user's buffer.
488 irbp
< irbufend
&& ac
.ac_ubleft
>= statstruct_size
;
490 error
= xfs_bulkstat_ag_ichunk(mp
, agno
, irbp
,
491 formatter
, statstruct_size
, &ac
,
500 * If we've run out of space or had a formatting error, we
503 if (ac
.ac_ubleft
< statstruct_size
|| error
)
510 agino
= XFS_INO_TO_AGINO(mp
, lastino
);
513 * Done, we're either out of filesystem or space to put the data.
516 *ubcountp
= ac
.ac_ubelem
;
519 * We found some inodes, so clear the error status and return them.
520 * The lastino pointer will point directly at the inode that triggered
521 * any error that occurred, so on the next call the error will be
522 * triggered again and propagated to userspace as there will be no
523 * formatted inodes in the buffer.
528 if (agno
>= mp
->m_sb
.sb_agcount
) {
530 * If we ran out of filesystem, mark lastino as off
531 * the end of the filesystem, so the next call
532 * will return immediately.
534 *lastinop
= (xfs_ino_t
)XFS_AGINO_TO_INO(mp
, agno
, 0);
537 *lastinop
= (xfs_ino_t
)lastino
;
544 void __user
*ubuffer
, /* buffer to write to */
545 const struct xfs_inogrp
*buffer
, /* buffer to read from */
546 long count
, /* # of elements to read */
547 long *written
) /* # of bytes written */
549 if (copy_to_user(ubuffer
, buffer
, count
* sizeof(*buffer
)))
551 *written
= count
* sizeof(*buffer
);
556 * Return inode number table for the filesystem.
558 int /* error status */
560 struct xfs_mount
*mp
,/* mount point for filesystem */
561 xfs_ino_t
*lastino
,/* last inode returned */
562 int *count
,/* size of buffer/count returned */
563 void __user
*ubuffer
,/* buffer with inode descriptions */
564 inumbers_fmt_pf formatter
)
566 xfs_agnumber_t agno
= XFS_INO_TO_AGNO(mp
, *lastino
);
567 xfs_agino_t agino
= XFS_INO_TO_AGINO(mp
, *lastino
);
568 struct xfs_btree_cur
*cur
= NULL
;
569 struct xfs_buf
*agbp
= NULL
;
570 struct xfs_inogrp
*buffer
;
577 if (agno
>= mp
->m_sb
.sb_agcount
||
578 *lastino
!= XFS_AGINO_TO_INO(mp
, agno
, agino
))
581 bcount
= MIN(left
, (int)(PAGE_SIZE
/ sizeof(*buffer
)));
582 buffer
= kmem_alloc(bcount
* sizeof(*buffer
), KM_SLEEP
);
584 struct xfs_inobt_rec_incore r
;
588 error
= xfs_ialloc_read_agi(mp
, NULL
, agno
, &agbp
);
592 cur
= xfs_inobt_init_cursor(mp
, NULL
, agbp
, agno
,
594 error
= xfs_inobt_lookup(cur
, agino
, XFS_LOOKUP_GE
,
602 error
= xfs_inobt_get_rec(cur
, &r
, &stat
);
608 agino
= r
.ir_startino
+ XFS_INODES_PER_CHUNK
- 1;
609 buffer
[bufidx
].xi_startino
=
610 XFS_AGINO_TO_INO(mp
, agno
, r
.ir_startino
);
611 buffer
[bufidx
].xi_alloccount
=
612 XFS_INODES_PER_CHUNK
- r
.ir_freecount
;
613 buffer
[bufidx
].xi_allocmask
= ~r
.ir_free
;
614 if (++bufidx
== bcount
) {
617 error
= formatter(ubuffer
, buffer
, bufidx
, &written
);
627 error
= xfs_btree_increment(cur
, 0, &stat
);
634 xfs_btree_del_cursor(cur
, XFS_BTREE_ERROR
);
640 } while (agno
< mp
->m_sb
.sb_agcount
);
646 error
= formatter(ubuffer
, buffer
, bufidx
, &written
);
650 *lastino
= XFS_AGINO_TO_INO(mp
, agno
, agino
);
655 xfs_btree_del_cursor(cur
, (error
? XFS_BTREE_ERROR
: