?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
RDMA/nes: Fix off-by-one
[linux-2.6/kvm.git] / fs / xfs / xfs_itable.c
blob658aab6b1bbfc193a9276d33bd002f4a1586dce7
1 /*
2 * Copyright (c) 2000-2002,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_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
42 int
43 xfs_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
52 STATIC int
53 xfs_bulkstat_one_iget(
54 xfs_mount_t *mp, /* mount point for filesystem */
55 xfs_ino_t ino, /* inode number to get data for */
56 xfs_daddr_t bno, /* starting bno of inode cluster */
57 xfs_bstat_t *buf, /* return buffer */
58 int *stat) /* BULKSTAT_RV_... */
59 {
60 xfs_icdinode_t *dic; /* dinode core info pointer */
61 xfs_inode_t *ip; /* incore inode pointer */
62 bhv_vnode_t *vp;
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_blkno != (xfs_daddr_t)0);
74 if (ip->i_d.di_mode == 0) {
75 *stat = BULKSTAT_RV_NOTHING;
76 error = XFS_ERROR(ENOENT);
77 goto out_iput;
78 }
79
80 vp = XFS_ITOV(ip);
81 dic = &ip->i_d;
82
83 /* xfs_iget returns the following without needing
84 * further change.
85 */
86 buf->bs_nlink = dic->di_nlink;
87 buf->bs_projid = dic->di_projid;
88 buf->bs_ino = ino;
89 buf->bs_mode = dic->di_mode;
90 buf->bs_uid = dic->di_uid;
91 buf->bs_gid = dic->di_gid;
92 buf->bs_size = dic->di_size;
93 vn_atime_to_bstime(vp, &buf->bs_atime);
94 buf->bs_mtime.tv_sec = dic->di_mtime.t_sec;
95 buf->bs_mtime.tv_nsec = dic->di_mtime.t_nsec;
96 buf->bs_ctime.tv_sec = dic->di_ctime.t_sec;
97 buf->bs_ctime.tv_nsec = dic->di_ctime.t_nsec;
98 buf->bs_xflags = xfs_ip2xflags(ip);
99 buf->bs_extsize = dic->di_extsize << mp->m_sb.sb_blocklog;
100 buf->bs_extents = dic->di_nextents;
101 buf->bs_gen = dic->di_gen;
102 memset(buf->bs_pad, 0, sizeof(buf->bs_pad));
103 buf->bs_dmevmask = dic->di_dmevmask;
104 buf->bs_dmstate = dic->di_dmstate;
105 buf->bs_aextents = dic->di_anextents;
106
107 switch (dic->di_format) {
108 case XFS_DINODE_FMT_DEV:
109 buf->bs_rdev = ip->i_df.if_u2.if_rdev;
110 buf->bs_blksize = BLKDEV_IOSIZE;
111 buf->bs_blocks = 0;
112 break;
113 case XFS_DINODE_FMT_LOCAL:
114 case XFS_DINODE_FMT_UUID:
115 buf->bs_rdev = 0;
116 buf->bs_blksize = mp->m_sb.sb_blocksize;
117 buf->bs_blocks = 0;
118 break;
119 case XFS_DINODE_FMT_EXTENTS:
120 case XFS_DINODE_FMT_BTREE:
121 buf->bs_rdev = 0;
122 buf->bs_blksize = mp->m_sb.sb_blocksize;
123 buf->bs_blocks = dic->di_nblocks + ip->i_delayed_blks;
124 break;
125 }
126
127 out_iput:
128 xfs_iput(ip, XFS_ILOCK_SHARED);
129 return error;
130 }
131
132 STATIC int
133 xfs_bulkstat_one_dinode(
134 xfs_mount_t *mp, /* mount point for filesystem */
135 xfs_ino_t ino, /* inode number to get data for */
136 xfs_dinode_t *dip, /* dinode inode pointer */
137 xfs_bstat_t *buf) /* return buffer */
138 {
139 xfs_dinode_core_t *dic; /* dinode core info pointer */
140
141 dic = &dip->di_core;
142
143 /*
144 * The inode format changed when we moved the link count and
145 * made it 32 bits long. If this is an old format inode,
146 * convert it in memory to look like a new one. If it gets
147 * flushed to disk we will convert back before flushing or
148 * logging it. We zero out the new projid field and the old link
149 * count field. We'll handle clearing the pad field (the remains
150 * of the old uuid field) when we actually convert the inode to
151 * the new format. We don't change the version number so that we
152 * can distinguish this from a real new format inode.
153 */
154 if (dic->di_version == XFS_DINODE_VERSION_1) {
155 buf->bs_nlink = be16_to_cpu(dic->di_onlink);
156 buf->bs_projid = 0;
157 } else {
158 buf->bs_nlink = be32_to_cpu(dic->di_nlink);
159 buf->bs_projid = be16_to_cpu(dic->di_projid);
160 }
161
162 buf->bs_ino = ino;
163 buf->bs_mode = be16_to_cpu(dic->di_mode);
164 buf->bs_uid = be32_to_cpu(dic->di_uid);
165 buf->bs_gid = be32_to_cpu(dic->di_gid);
166 buf->bs_size = be64_to_cpu(dic->di_size);
167 buf->bs_atime.tv_sec = be32_to_cpu(dic->di_atime.t_sec);
168 buf->bs_atime.tv_nsec = be32_to_cpu(dic->di_atime.t_nsec);
169 buf->bs_mtime.tv_sec = be32_to_cpu(dic->di_mtime.t_sec);
170 buf->bs_mtime.tv_nsec = be32_to_cpu(dic->di_mtime.t_nsec);
171 buf->bs_ctime.tv_sec = be32_to_cpu(dic->di_ctime.t_sec);
172 buf->bs_ctime.tv_nsec = be32_to_cpu(dic->di_ctime.t_nsec);
173 buf->bs_xflags = xfs_dic2xflags(dip);
174 buf->bs_extsize = be32_to_cpu(dic->di_extsize) << mp->m_sb.sb_blocklog;
175 buf->bs_extents = be32_to_cpu(dic->di_nextents);
176 buf->bs_gen = be32_to_cpu(dic->di_gen);
177 memset(buf->bs_pad, 0, sizeof(buf->bs_pad));
178 buf->bs_dmevmask = be32_to_cpu(dic->di_dmevmask);
179 buf->bs_dmstate = be16_to_cpu(dic->di_dmstate);
180 buf->bs_aextents = be16_to_cpu(dic->di_anextents);
181
182 switch (dic->di_format) {
183 case XFS_DINODE_FMT_DEV:
184 buf->bs_rdev = be32_to_cpu(dip->di_u.di_dev);
185 buf->bs_blksize = BLKDEV_IOSIZE;
186 buf->bs_blocks = 0;
187 break;
188 case XFS_DINODE_FMT_LOCAL:
189 case XFS_DINODE_FMT_UUID:
190 buf->bs_rdev = 0;
191 buf->bs_blksize = mp->m_sb.sb_blocksize;
192 buf->bs_blocks = 0;
193 break;
194 case XFS_DINODE_FMT_EXTENTS:
195 case XFS_DINODE_FMT_BTREE:
196 buf->bs_rdev = 0;
197 buf->bs_blksize = mp->m_sb.sb_blocksize;
198 buf->bs_blocks = be64_to_cpu(dic->di_nblocks);
199 break;
200 }
201
202 return 0;
203 }
204
205 STATIC int
206 xfs_bulkstat_one_fmt(
207 void __user *ubuffer,
208 const xfs_bstat_t *buffer)
209 {
210 if (copy_to_user(ubuffer, buffer, sizeof(*buffer)))
211 return -EFAULT;
212 return sizeof(*buffer);
213 }
214
215 /*
216 * Return stat information for one inode.
217 * Return 0 if ok, else errno.
218 */
219 int /* error status */
220 xfs_bulkstat_one(
221 xfs_mount_t *mp, /* mount point for filesystem */
222 xfs_ino_t ino, /* inode number to get data for */
223 void __user *buffer, /* buffer to place output in */
224 int ubsize, /* size of buffer */
225 void *private_data, /* my private data */
226 xfs_daddr_t bno, /* starting bno of inode cluster */
227 int *ubused, /* bytes used by me */
228 void *dibuff, /* on-disk inode buffer */
229 int *stat) /* BULKSTAT_RV_... */
230 {
231 xfs_bstat_t *buf; /* return buffer */
232 int error = 0; /* error value */
233 xfs_dinode_t *dip; /* dinode inode pointer */
234 bulkstat_one_fmt_pf formatter = private_data ? : xfs_bulkstat_one_fmt;
235
236 dip = (xfs_dinode_t *)dibuff;
237 *stat = BULKSTAT_RV_NOTHING;
238
239 if (!buffer || xfs_internal_inum(mp, ino))
240 return XFS_ERROR(EINVAL);
241 if (ubsize < sizeof(*buf))
242 return XFS_ERROR(ENOMEM);
243
244 buf = kmem_alloc(sizeof(*buf), KM_SLEEP);
245
246 if (dip == NULL) {
247 /* We're not being passed a pointer to a dinode. This happens
248 * if BULKSTAT_FG_IGET is selected. Do the iget.
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, buf);
258 if (error < 0) {
259 error = EFAULT;
260 goto out_free;
261 }
262
263 *stat = BULKSTAT_RV_DIDONE;
264 if (ubused)
265 *ubused = error;
266
267 out_free:
268 kmem_free(buf, sizeof(*buf));
269 return error;
270 }
271
272 /*
273 * Test to see whether we can use the ondisk inode directly, based
274 * on the given bulkstat flags, filling in dipp accordingly.
275 * Returns zero if the inode is dodgey.
276 */
277 STATIC int
278 xfs_bulkstat_use_dinode(
279 xfs_mount_t *mp,
280 int flags,
281 xfs_buf_t *bp,
282 int clustidx,
283 xfs_dinode_t **dipp)
284 {
285 xfs_dinode_t *dip;
286 unsigned int aformat;
287
288 *dipp = NULL;
289 if (!bp || (flags & BULKSTAT_FG_IGET))
290 return 1;
291 dip = (xfs_dinode_t *)
292 xfs_buf_offset(bp, clustidx << mp->m_sb.sb_inodelog);
293 /*
294 * Check the buffer containing the on-disk inode for di_mode == 0.
295 * This is to prevent xfs_bulkstat from picking up just reclaimed
296 * inodes that have their in-core state initialized but not flushed
297 * to disk yet. This is a temporary hack that would require a proper
298 * fix in the future.
299 */
300 if (be16_to_cpu(dip->di_core.di_magic) != XFS_DINODE_MAGIC ||
301 !XFS_DINODE_GOOD_VERSION(dip->di_core.di_version) ||
302 !dip->di_core.di_mode)
303 return 0;
304 if (flags & BULKSTAT_FG_QUICK) {
305 *dipp = dip;
306 return 1;
307 }
308 /* BULKSTAT_FG_INLINE: if attr fork is local, or not there, use it */
309 aformat = dip->di_core.di_aformat;
310 if ((XFS_DFORK_Q(dip) == 0) ||
311 (aformat == XFS_DINODE_FMT_LOCAL) ||
312 (aformat == XFS_DINODE_FMT_EXTENTS && !dip->di_core.di_anextents)) {
313 *dipp = dip;
314 return 1;
315 }
316 return 1;
317 }
318
319 #define XFS_BULKSTAT_UBLEFT(ubleft) ((ubleft) >= statstruct_size)
320
321 /*
322 * Return stat information in bulk (by-inode) for the filesystem.
323 */
324 int /* error status */
325 xfs_bulkstat(
326 xfs_mount_t *mp, /* mount point for filesystem */
327 xfs_ino_t *lastinop, /* last inode returned */
328 int *ubcountp, /* size of buffer/count returned */
329 bulkstat_one_pf formatter, /* func that'd fill a single buf */
330 void *private_data,/* private data for formatter */
331 size_t statstruct_size, /* sizeof struct filling */
332 char __user *ubuffer, /* buffer with inode stats */
333 int flags, /* defined in xfs_itable.h */
334 int *done) /* 1 if there are more stats to get */
335 {
336 xfs_agblock_t agbno=0;/* allocation group block number */
337 xfs_buf_t *agbp; /* agi header buffer */
338 xfs_agi_t *agi; /* agi header data */
339 xfs_agino_t agino; /* inode # in allocation group */
340 xfs_agnumber_t agno; /* allocation group number */
341 xfs_daddr_t bno; /* inode cluster start daddr */
342 int chunkidx; /* current index into inode chunk */
343 int clustidx; /* current index into inode cluster */
344 xfs_btree_cur_t *cur; /* btree cursor for ialloc btree */
345 int end_of_ag; /* set if we've seen the ag end */
346 int error; /* error code */
347 int fmterror;/* bulkstat formatter result */
348 __int32_t gcnt; /* current btree rec's count */
349 xfs_inofree_t gfree; /* current btree rec's free mask */
350 xfs_agino_t gino; /* current btree rec's start inode */
351 int i; /* loop index */
352 int icount; /* count of inodes good in irbuf */
353 size_t irbsize; /* size of irec buffer in bytes */
354 xfs_ino_t ino; /* inode number (filesystem) */
355 xfs_inobt_rec_incore_t *irbp; /* current irec buffer pointer */
356 xfs_inobt_rec_incore_t *irbuf; /* start of irec buffer */
357 xfs_inobt_rec_incore_t *irbufend; /* end of good irec buffer entries */
358 xfs_ino_t lastino; /* last inode number returned */
359 int nbcluster; /* # of blocks in a cluster */
360 int nicluster; /* # of inodes in a cluster */
361 int nimask; /* mask for inode clusters */
362 int nirbuf; /* size of irbuf */
363 int rval; /* return value error code */
364 int tmp; /* result value from btree calls */
365 int ubcount; /* size of user's buffer */
366 int ubleft; /* bytes left in user's buffer */
367 char __user *ubufp; /* pointer into user's buffer */
368 int ubelem; /* spaces used in user's buffer */
369 int ubused; /* bytes used by formatter */
370 xfs_buf_t *bp; /* ptr to on-disk inode cluster buf */
371 xfs_dinode_t *dip; /* ptr into bp for specific inode */
372 xfs_inode_t *ip; /* ptr to in-core inode struct */
373
374 /*
375 * Get the last inode value, see if there's nothing to do.
376 */
377 ino = (xfs_ino_t)*lastinop;
378 lastino = ino;
379 dip = NULL;
380 agno = XFS_INO_TO_AGNO(mp, ino);
381 agino = XFS_INO_TO_AGINO(mp, ino);
382 if (agno >= mp->m_sb.sb_agcount ||
383 ino != XFS_AGINO_TO_INO(mp, agno, agino)) {
384 *done = 1;
385 *ubcountp = 0;
386 return 0;
387 }
388 if (!ubcountp || *ubcountp <= 0) {
389 return EINVAL;
390 }
391 ubcount = *ubcountp; /* statstruct's */
392 ubleft = ubcount * statstruct_size; /* bytes */
393 *ubcountp = ubelem = 0;
394 *done = 0;
395 fmterror = 0;
396 ubufp = ubuffer;
397 nicluster = mp->m_sb.sb_blocksize >= XFS_INODE_CLUSTER_SIZE(mp) ?
398 mp->m_sb.sb_inopblock :
399 (XFS_INODE_CLUSTER_SIZE(mp) >> mp->m_sb.sb_inodelog);
400 nimask = ~(nicluster - 1);
401 nbcluster = nicluster >> mp->m_sb.sb_inopblog;
402 irbuf = kmem_zalloc_greedy(&irbsize, PAGE_SIZE, PAGE_SIZE * 4,
403 KM_SLEEP | KM_MAYFAIL | KM_LARGE);
404 nirbuf = irbsize / sizeof(*irbuf);
405
406 /*
407 * Loop over the allocation groups, starting from the last
408 * inode returned; 0 means start of the allocation group.
409 */
410 rval = 0;
411 while (XFS_BULKSTAT_UBLEFT(ubleft) && agno < mp->m_sb.sb_agcount) {
412 cond_resched();
413 bp = NULL;
414 down_read(&mp->m_peraglock);
415 error = xfs_ialloc_read_agi(mp, NULL, agno, &agbp);
416 up_read(&mp->m_peraglock);
417 if (error) {
418 /*
419 * Skip this allocation group and go to the next one.
420 */
421 agno++;
422 agino = 0;
423 continue;
424 }
425 agi = XFS_BUF_TO_AGI(agbp);
426 /*
427 * Allocate and initialize a btree cursor for ialloc btree.
428 */
429 cur = xfs_btree_init_cursor(mp, NULL, agbp, agno, XFS_BTNUM_INO,
430 (xfs_inode_t *)0, 0);
431 irbp = irbuf;
432 irbufend = irbuf + nirbuf;
433 end_of_ag = 0;
434 /*
435 * If we're returning in the middle of an allocation group,
436 * we need to get the remainder of the chunk we're in.
437 */
438 if (agino > 0) {
439 /*
440 * Lookup the inode chunk that this inode lives in.
441 */
442 error = xfs_inobt_lookup_le(cur, agino, 0, 0, &tmp);
443 if (!error && /* no I/O error */
444 tmp && /* lookup succeeded */
445 /* got the record, should always work */
446 !(error = xfs_inobt_get_rec(cur, &gino, &gcnt,
447 &gfree, &i)) &&
448 i == 1 &&
449 /* this is the right chunk */
450 agino < gino + XFS_INODES_PER_CHUNK &&
451 /* lastino was not last in chunk */
452 (chunkidx = agino - gino + 1) <
453 XFS_INODES_PER_CHUNK &&
454 /* there are some left allocated */
455 XFS_INOBT_MASKN(chunkidx,
456 XFS_INODES_PER_CHUNK - chunkidx) & ~gfree) {
457 /*
458 * Grab the chunk record. Mark all the
459 * uninteresting inodes (because they're
460 * before our start point) free.
461 */
462 for (i = 0; i < chunkidx; i++) {
463 if (XFS_INOBT_MASK(i) & ~gfree)
464 gcnt++;
465 }
466 gfree |= XFS_INOBT_MASKN(0, chunkidx);
467 irbp->ir_startino = gino;
468 irbp->ir_freecount = gcnt;
469 irbp->ir_free = gfree;
470 irbp++;
471 agino = gino + XFS_INODES_PER_CHUNK;
472 icount = XFS_INODES_PER_CHUNK - gcnt;
473 } else {
474 /*
475 * If any of those tests failed, bump the
476 * inode number (just in case).
477 */
478 agino++;
479 icount = 0;
480 }
481 /*
482 * In any case, increment to the next record.
483 */
484 if (!error)
485 error = xfs_inobt_increment(cur, 0, &tmp);
486 } else {
487 /*
488 * Start of ag. Lookup the first inode chunk.
489 */
490 error = xfs_inobt_lookup_ge(cur, 0, 0, 0, &tmp);
491 icount = 0;
492 }
493 /*
494 * Loop through inode btree records in this ag,
495 * until we run out of inodes or space in the buffer.
496 */
497 while (irbp < irbufend && icount < ubcount) {
498 /*
499 * Loop as long as we're unable to read the
500 * inode btree.
501 */
502 while (error) {
503 agino += XFS_INODES_PER_CHUNK;
504 if (XFS_AGINO_TO_AGBNO(mp, agino) >=
505 be32_to_cpu(agi->agi_length))
506 break;
507 error = xfs_inobt_lookup_ge(cur, agino, 0, 0,
508 &tmp);
509 cond_resched();
510 }
511 /*
512 * If ran off the end of the ag either with an error,
513 * or the normal way, set end and stop collecting.
514 */
515 if (error ||
516 (error = xfs_inobt_get_rec(cur, &gino, &gcnt,
517 &gfree, &i)) ||
518 i == 0) {
519 end_of_ag = 1;
520 break;
521 }
522 /*
523 * If this chunk has any allocated inodes, save it.
524 * Also start read-ahead now for this chunk.
525 */
526 if (gcnt < XFS_INODES_PER_CHUNK) {
527 /*
528 * Loop over all clusters in the next chunk.
529 * Do a readahead if there are any allocated
530 * inodes in that cluster.
531 */
532 for (agbno = XFS_AGINO_TO_AGBNO(mp, gino),
533 chunkidx = 0;
534 chunkidx < XFS_INODES_PER_CHUNK;
535 chunkidx += nicluster,
536 agbno += nbcluster) {
537 if (XFS_INOBT_MASKN(chunkidx,
538 nicluster) & ~gfree)
539 xfs_btree_reada_bufs(mp, agno,
540 agbno, nbcluster);
541 }
542 irbp->ir_startino = gino;
543 irbp->ir_freecount = gcnt;
544 irbp->ir_free = gfree;
545 irbp++;
546 icount += XFS_INODES_PER_CHUNK - gcnt;
547 }
548 /*
549 * Set agino to after this chunk and bump the cursor.
550 */
551 agino = gino + XFS_INODES_PER_CHUNK;
552 error = xfs_inobt_increment(cur, 0, &tmp);
553 cond_resched();
554 }
555 /*
556 * Drop the btree buffers and the agi buffer.
557 * We can't hold any of the locks these represent
558 * when calling iget.
559 */
560 xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
561 xfs_buf_relse(agbp);
562 /*
563 * Now format all the good inodes into the user's buffer.
564 */
565 irbufend = irbp;
566 for (irbp = irbuf;
567 irbp < irbufend && XFS_BULKSTAT_UBLEFT(ubleft); irbp++) {
568 /*
569 * Now process this chunk of inodes.
570 */
571 for (agino = irbp->ir_startino, chunkidx = clustidx = 0;
572 XFS_BULKSTAT_UBLEFT(ubleft) &&
573 irbp->ir_freecount < XFS_INODES_PER_CHUNK;
574 chunkidx++, clustidx++, agino++) {
575 ASSERT(chunkidx < XFS_INODES_PER_CHUNK);
576 /*
577 * Recompute agbno if this is the
578 * first inode of the cluster.
579 *
580 * Careful with clustidx. There can be
581 * multple clusters per chunk, a single
582 * cluster per chunk or a cluster that has
583 * inodes represented from several different
584 * chunks (if blocksize is large).
585 *
586 * Because of this, the starting clustidx is
587 * initialized to zero in this loop but must
588 * later be reset after reading in the cluster
589 * buffer.
590 */
591 if ((chunkidx & (nicluster - 1)) == 0) {
592 agbno = XFS_AGINO_TO_AGBNO(mp,
593 irbp->ir_startino) +
594 ((chunkidx & nimask) >>
595 mp->m_sb.sb_inopblog);
596
597 if (flags & (BULKSTAT_FG_QUICK |
598 BULKSTAT_FG_INLINE)) {
599 ino = XFS_AGINO_TO_INO(mp, agno,
600 agino);
601 bno = XFS_AGB_TO_DADDR(mp, agno,
602 agbno);
603
604 /*
605 * Get the inode cluster buffer
606 */
607 ASSERT(xfs_inode_zone != NULL);
608 ip = kmem_zone_zalloc(xfs_inode_zone,
609 KM_SLEEP);
610 ip->i_ino = ino;
611 ip->i_mount = mp;
612 spin_lock_init(&ip->i_flags_lock);
613 if (bp)
614 xfs_buf_relse(bp);
615 error = xfs_itobp(mp, NULL, ip,
616 &dip, &bp, bno,
617 XFS_IMAP_BULKSTAT);
618 if (!error)
619 clustidx = ip->i_boffset / mp->m_sb.sb_inodesize;
620 kmem_zone_free(xfs_inode_zone, ip);
621 if (XFS_TEST_ERROR(error != 0,
622 mp, XFS_ERRTAG_BULKSTAT_READ_CHUNK,
623 XFS_RANDOM_BULKSTAT_READ_CHUNK)) {
624 bp = NULL;
625 ubleft = 0;
626 rval = error;
627 break;
628 }
629 }
630 }
631 ino = XFS_AGINO_TO_INO(mp, agno, agino);
632 bno = XFS_AGB_TO_DADDR(mp, agno, agbno);
633 /*
634 * Skip if this inode is free.
635 */
636 if (XFS_INOBT_MASK(chunkidx) & irbp->ir_free) {
637 lastino = ino;
638 continue;
639 }
640 /*
641 * Count used inodes as free so we can tell
642 * when the chunk is used up.
643 */
644 irbp->ir_freecount++;
645 if (!xfs_bulkstat_use_dinode(mp, flags, bp,
646 clustidx, &dip)) {
647 lastino = ino;
648 continue;
649 }
650 /*
651 * If we need to do an iget, cannot hold bp.
652 * Drop it, until starting the next cluster.
653 */
654 if ((flags & BULKSTAT_FG_INLINE) && !dip) {
655 if (bp)
656 xfs_buf_relse(bp);
657 bp = NULL;
658 }
659
660 /*
661 * Get the inode and fill in a single buffer.
662 * BULKSTAT_FG_QUICK uses dip to fill it in.
663 * BULKSTAT_FG_IGET uses igets.
664 * BULKSTAT_FG_INLINE uses dip if we have an
665 * inline attr fork, else igets.
666 * See: xfs_bulkstat_one & xfs_dm_bulkstat_one.
667 * This is also used to count inodes/blks, etc
668 * in xfs_qm_quotacheck.
669 */
670 ubused = statstruct_size;
671 error = formatter(mp, ino, ubufp,
672 ubleft, private_data,
673 bno, &ubused, dip, &fmterror);
674 if (fmterror == BULKSTAT_RV_NOTHING) {
675 if (error && error != ENOENT &&
676 error != EINVAL) {
677 ubleft = 0;
678 rval = error;
679 break;
680 }
681 lastino = ino;
682 continue;
683 }
684 if (fmterror == BULKSTAT_RV_GIVEUP) {
685 ubleft = 0;
686 ASSERT(error);
687 rval = error;
688 break;
689 }
690 if (ubufp)
691 ubufp += ubused;
692 ubleft -= ubused;
693 ubelem++;
694 lastino = ino;
695 }
696
697 cond_resched();
698 }
699
700 if (bp)
701 xfs_buf_relse(bp);
702
703 /*
704 * Set up for the next loop iteration.
705 */
706 if (XFS_BULKSTAT_UBLEFT(ubleft)) {
707 if (end_of_ag) {
708 agno++;
709 agino = 0;
710 } else
711 agino = XFS_INO_TO_AGINO(mp, lastino);
712 } else
713 break;
714 }
715 /*
716 * Done, we're either out of filesystem or space to put the data.
717 */
718 kmem_free(irbuf, irbsize);
719 *ubcountp = ubelem;
720 /*
721 * Found some inodes, return them now and return the error next time.
722 */
723 if (ubelem)
724 rval = 0;
725 if (agno >= mp->m_sb.sb_agcount) {
726 /*
727 * If we ran out of filesystem, mark lastino as off
728 * the end of the filesystem, so the next call
729 * will return immediately.
730 */
731 *lastinop = (xfs_ino_t)XFS_AGINO_TO_INO(mp, agno, 0);
732 *done = 1;
733 } else
734 *lastinop = (xfs_ino_t)lastino;
735
736 return rval;
737 }
738
739 /*
740 * Return stat information in bulk (by-inode) for the filesystem.
741 * Special case for non-sequential one inode bulkstat.
742 */
743 int /* error status */
744 xfs_bulkstat_single(
745 xfs_mount_t *mp, /* mount point for filesystem */
746 xfs_ino_t *lastinop, /* inode to return */
747 char __user *buffer, /* buffer with inode stats */
748 int *done) /* 1 if there are more stats to get */
749 {
750 int count; /* count value for bulkstat call */
751 int error; /* return value */
752 xfs_ino_t ino; /* filesystem inode number */
753 int res; /* result from bs1 */
754
755 /*
756 * note that requesting valid inode numbers which are not allocated
757 * to inodes will most likely cause xfs_itobp to generate warning
758 * messages about bad magic numbers. This is ok. The fact that
759 * the inode isn't actually an inode is handled by the
760 * error check below. Done this way to make the usual case faster
761 * at the expense of the error case.
762 */
763
764 ino = (xfs_ino_t)*lastinop;
765 error = xfs_bulkstat_one(mp, ino, buffer, sizeof(xfs_bstat_t),
766 NULL, 0, NULL, NULL, &res);
767 if (error) {
768 /*
769 * Special case way failed, do it the "long" way
770 * to see if that works.
771 */
772 (*lastinop)--;
773 count = 1;
774 if (xfs_bulkstat(mp, lastinop, &count, xfs_bulkstat_one,
775 NULL, sizeof(xfs_bstat_t), buffer,
776 BULKSTAT_FG_IGET, done))
777 return error;
778 if (count == 0 || (xfs_ino_t)*lastinop != ino)
779 return error == EFSCORRUPTED ?
780 XFS_ERROR(EINVAL) : error;
781 else
782 return 0;
783 }
784 *done = 0;
785 return 0;
786 }
787
788 int
789 xfs_inumbers_fmt(
790 void __user *ubuffer, /* buffer to write to */
791 const xfs_inogrp_t *buffer, /* buffer to read from */
792 long count, /* # of elements to read */
793 long *written) /* # of bytes written */
794 {
795 if (copy_to_user(ubuffer, buffer, count * sizeof(*buffer)))
796 return -EFAULT;
797 *written = count * sizeof(*buffer);
798 return 0;
799 }
800
801 /*
802 * Return inode number table for the filesystem.
803 */
804 int /* error status */
805 xfs_inumbers(
806 xfs_mount_t *mp, /* mount point for filesystem */
807 xfs_ino_t *lastino, /* last inode returned */
808 int *count, /* size of buffer/count returned */
809 void __user *ubuffer,/* buffer with inode descriptions */
810 inumbers_fmt_pf formatter)
811 {
812 xfs_buf_t *agbp;
813 xfs_agino_t agino;
814 xfs_agnumber_t agno;
815 int bcount;
816 xfs_inogrp_t *buffer;
817 int bufidx;
818 xfs_btree_cur_t *cur;
819 int error;
820 __int32_t gcnt;
821 xfs_inofree_t gfree;
822 xfs_agino_t gino;
823 int i;
824 xfs_ino_t ino;
825 int left;
826 int tmp;
827
828 ino = (xfs_ino_t)*lastino;
829 agno = XFS_INO_TO_AGNO(mp, ino);
830 agino = XFS_INO_TO_AGINO(mp, ino);
831 left = *count;
832 *count = 0;
833 bcount = MIN(left, (int)(PAGE_SIZE / sizeof(*buffer)));
834 buffer = kmem_alloc(bcount * sizeof(*buffer), KM_SLEEP);
835 error = bufidx = 0;
836 cur = NULL;
837 agbp = NULL;
838 while (left > 0 && agno < mp->m_sb.sb_agcount) {
839 if (agbp == NULL) {
840 down_read(&mp->m_peraglock);
841 error = xfs_ialloc_read_agi(mp, NULL, agno, &agbp);
842 up_read(&mp->m_peraglock);
843 if (error) {
844 /*
845 * If we can't read the AGI of this ag,
846 * then just skip to the next one.
847 */
848 ASSERT(cur == NULL);
849 agbp = NULL;
850 agno++;
851 agino = 0;
852 continue;
853 }
854 cur = xfs_btree_init_cursor(mp, NULL, agbp, agno,
855 XFS_BTNUM_INO, (xfs_inode_t *)0, 0);
856 error = xfs_inobt_lookup_ge(cur, agino, 0, 0, &tmp);
857 if (error) {
858 xfs_btree_del_cursor(cur, XFS_BTREE_ERROR);
859 cur = NULL;
860 xfs_buf_relse(agbp);
861 agbp = NULL;
862 /*
863 * Move up the last inode in the current
864 * chunk. The lookup_ge will always get
865 * us the first inode in the next chunk.
866 */
867 agino += XFS_INODES_PER_CHUNK - 1;
868 continue;
869 }
870 }
871 if ((error = xfs_inobt_get_rec(cur, &gino, &gcnt, &gfree,
872 &i)) ||
873 i == 0) {
874 xfs_buf_relse(agbp);
875 agbp = NULL;
876 xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
877 cur = NULL;
878 agno++;
879 agino = 0;
880 continue;
881 }
882 agino = gino + XFS_INODES_PER_CHUNK - 1;
883 buffer[bufidx].xi_startino = XFS_AGINO_TO_INO(mp, agno, gino);
884 buffer[bufidx].xi_alloccount = XFS_INODES_PER_CHUNK - gcnt;
885 buffer[bufidx].xi_allocmask = ~gfree;
886 bufidx++;
887 left--;
888 if (bufidx == bcount) {
889 long written;
890 if (formatter(ubuffer, buffer, bufidx, &written)) {
891 error = XFS_ERROR(EFAULT);
892 break;
893 }
894 ubuffer += written;
895 *count += bufidx;
896 bufidx = 0;
897 }
898 if (left) {
899 error = xfs_inobt_increment(cur, 0, &tmp);
900 if (error) {
901 xfs_btree_del_cursor(cur, XFS_BTREE_ERROR);
902 cur = NULL;
903 xfs_buf_relse(agbp);
904 agbp = NULL;
905 /*
906 * The agino value has already been bumped.
907 * Just try to skip up to it.
908 */
909 agino += XFS_INODES_PER_CHUNK;
910 continue;
911 }
912 }
913 }
914 if (!error) {
915 if (bufidx) {
916 long written;
917 if (formatter(ubuffer, buffer, bufidx, &written))
918 error = XFS_ERROR(EFAULT);
919 else
920 *count += bufidx;
921 }
922 *lastino = XFS_AGINO_TO_INO(mp, agno, agino);
923 }
924 kmem_free(buffer, bcount * sizeof(*buffer));
925 if (cur)
926 xfs_btree_del_cursor(cur, (error ? XFS_BTREE_ERROR :
927 XFS_BTREE_NOERROR));
928 if (agbp)
929 xfs_buf_relse(agbp);
930 return error;
931 }
kernel-based virtual machine