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_mount.h" 28 #include "xfs_bmap_btree.h" 29 #include "xfs_alloc_btree.h" 30 #include "xfs_ialloc_btree.h" 31 #include "xfs_dinode.h" 32 #include "xfs_inode.h" 33 #include "xfs_ialloc.h" 34 #include "xfs_itable.h" 35 #include "xfs_error.h" 36 #include "xfs_btree.h" 37 #include "xfs_trace.h" 38 39 STATIC int 40 xfs_internal_inum( 41 xfs_mount_t *mp, 42 xfs_ino_t ino) 43 { 44 return (ino == mp->m_sb.sb_rbmino || ino == mp->m_sb.sb_rsumino || 45 (xfs_sb_version_hasquota(&mp->m_sb) && 46 (ino == mp->m_sb.sb_uquotino || ino == mp->m_sb.sb_gquotino))); 47 } 48 49 /* 50 * Return stat information for one inode. 51 * Return 0 if ok, else errno. 52 */ 53 int 54 xfs_bulkstat_one_int( 55 struct xfs_mount *mp, /* mount point for filesystem */ 56 xfs_ino_t ino, /* inode to get data for */ 57 void __user *buffer, /* buffer to place output in */ 58 int ubsize, /* size of buffer */ 59 bulkstat_one_fmt_pf formatter, /* formatter, copy to user */ 60 int *ubused, /* bytes used by me */ 61 int *stat) /* BULKSTAT_RV_... */ 62 { 63 struct xfs_icdinode *dic; /* dinode core info pointer */ 64 struct xfs_inode *ip; /* incore inode pointer */ 65 struct inode *inode; 66 struct xfs_bstat *buf; /* return buffer */ 67 int error = 0; /* error value */ 68 69 *stat = BULKSTAT_RV_NOTHING; 70 71 if (!buffer || xfs_internal_inum(mp, ino)) 72 return XFS_ERROR(EINVAL); 73 74 buf = kmem_alloc(sizeof(*buf), KM_SLEEP | KM_MAYFAIL); 75 if (!buf) 76 return XFS_ERROR(ENOMEM); 77 78 error = xfs_iget(mp, NULL, ino, 79 XFS_IGET_UNTRUSTED, XFS_ILOCK_SHARED, &ip); 80 if (error) { 81 *stat = BULKSTAT_RV_NOTHING; 82 goto out_free; 83 } 84 85 ASSERT(ip != NULL); 86 ASSERT(ip->i_imap.im_blkno != 0); 87 88 dic = &ip->i_d; 89 inode = VFS_I(ip); 90 91 /* xfs_iget returns the following without needing 92 * further change. 93 */ 94 buf->bs_nlink = dic->di_nlink; 95 buf->bs_projid_lo = dic->di_projid_lo; 96 buf->bs_projid_hi = dic->di_projid_hi; 97 buf->bs_ino = ino; 98 buf->bs_mode = dic->di_mode; 99 buf->bs_uid = dic->di_uid; 100 buf->bs_gid = dic->di_gid; 101 buf->bs_size = dic->di_size; 102 103 /* 104 * We need to read the timestamps from the Linux inode because 105 * the VFS keeps writing directly into the inode structure instead 106 * of telling us about the updates. 107 */ 108 buf->bs_atime.tv_sec = inode->i_atime.tv_sec; 109 buf->bs_atime.tv_nsec = inode->i_atime.tv_nsec; 110 buf->bs_mtime.tv_sec = inode->i_mtime.tv_sec; 111 buf->bs_mtime.tv_nsec = inode->i_mtime.tv_nsec; 112 buf->bs_ctime.tv_sec = inode->i_ctime.tv_sec; 113 buf->bs_ctime.tv_nsec = inode->i_ctime.tv_nsec; 114 115 buf->bs_xflags = xfs_ip2xflags(ip); 116 buf->bs_extsize = dic->di_extsize << mp->m_sb.sb_blocklog; 117 buf->bs_extents = dic->di_nextents; 118 buf->bs_gen = dic->di_gen; 119 memset(buf->bs_pad, 0, sizeof(buf->bs_pad)); 120 buf->bs_dmevmask = dic->di_dmevmask; 121 buf->bs_dmstate = dic->di_dmstate; 122 buf->bs_aextents = dic->di_anextents; 123 buf->bs_forkoff = XFS_IFORK_BOFF(ip); 124 125 switch (dic->di_format) { 126 case XFS_DINODE_FMT_DEV: 127 buf->bs_rdev = ip->i_df.if_u2.if_rdev; 128 buf->bs_blksize = BLKDEV_IOSIZE; 129 buf->bs_blocks = 0; 130 break; 131 case XFS_DINODE_FMT_LOCAL: 132 case XFS_DINODE_FMT_UUID: 133 buf->bs_rdev = 0; 134 buf->bs_blksize = mp->m_sb.sb_blocksize; 135 buf->bs_blocks = 0; 136 break; 137 case XFS_DINODE_FMT_EXTENTS: 138 case XFS_DINODE_FMT_BTREE: 139 buf->bs_rdev = 0; 140 buf->bs_blksize = mp->m_sb.sb_blocksize; 141 buf->bs_blocks = dic->di_nblocks + ip->i_delayed_blks; 142 break; 143 } 144 xfs_iunlock(ip, XFS_ILOCK_SHARED); 145 IRELE(ip); 146 147 error = formatter(buffer, ubsize, ubused, buf); 148 149 if (!error) 150 *stat = BULKSTAT_RV_DIDONE; 151 152 out_free: 153 kmem_free(buf); 154 return error; 155 } 156 157 /* Return 0 on success or positive error */ 158 STATIC int 159 xfs_bulkstat_one_fmt( 160 void __user *ubuffer, 161 int ubsize, 162 int *ubused, 163 const xfs_bstat_t *buffer) 164 { 165 if (ubsize < sizeof(*buffer)) 166 return XFS_ERROR(ENOMEM); 167 if (copy_to_user(ubuffer, buffer, sizeof(*buffer))) 168 return XFS_ERROR(EFAULT); 169 if (ubused) 170 *ubused = sizeof(*buffer); 171 return 0; 172 } 173 174 int 175 xfs_bulkstat_one( 176 xfs_mount_t *mp, /* mount point for filesystem */ 177 xfs_ino_t ino, /* inode number to get data for */ 178 void __user *buffer, /* buffer to place output in */ 179 int ubsize, /* size of buffer */ 180 int *ubused, /* bytes used by me */ 181 int *stat) /* BULKSTAT_RV_... */ 182 { 183 return xfs_bulkstat_one_int(mp, ino, buffer, ubsize, 184 xfs_bulkstat_one_fmt, ubused, stat); 185 } 186 187 #define XFS_BULKSTAT_UBLEFT(ubleft) ((ubleft) >= statstruct_size) 188 189 /* 190 * Return stat information in bulk (by-inode) for the filesystem. 191 */ 192 int /* error status */ 193 xfs_bulkstat( 194 xfs_mount_t *mp, /* mount point for filesystem */ 195 xfs_ino_t *lastinop, /* last inode returned */ 196 int *ubcountp, /* size of buffer/count returned */ 197 bulkstat_one_pf formatter, /* func that'd fill a single buf */ 198 size_t statstruct_size, /* sizeof struct filling */ 199 char __user *ubuffer, /* buffer with inode stats */ 200 int *done) /* 1 if there are more stats to get */ 201 { 202 xfs_agblock_t agbno=0;/* allocation group block number */ 203 xfs_buf_t *agbp; /* agi header buffer */ 204 xfs_agi_t *agi; /* agi header data */ 205 xfs_agino_t agino; /* inode # in allocation group */ 206 xfs_agnumber_t agno; /* allocation group number */ 207 xfs_daddr_t bno; /* inode cluster start daddr */ 208 int chunkidx; /* current index into inode chunk */ 209 int clustidx; /* current index into inode cluster */ 210 xfs_btree_cur_t *cur; /* btree cursor for ialloc btree */ 211 int end_of_ag; /* set if we've seen the ag end */ 212 int error; /* error code */ 213 int fmterror;/* bulkstat formatter result */ 214 int i; /* loop index */ 215 int icount; /* count of inodes good in irbuf */ 216 size_t irbsize; /* size of irec buffer in bytes */ 217 xfs_ino_t ino; /* inode number (filesystem) */ 218 xfs_inobt_rec_incore_t *irbp; /* current irec buffer pointer */ 219 xfs_inobt_rec_incore_t *irbuf; /* start of irec buffer */ 220 xfs_inobt_rec_incore_t *irbufend; /* end of good irec buffer entries */ 221 xfs_ino_t lastino; /* last inode number returned */ 222 int nbcluster; /* # of blocks in a cluster */ 223 int nicluster; /* # of inodes in a cluster */ 224 int nimask; /* mask for inode clusters */ 225 int nirbuf; /* size of irbuf */ 226 int rval; /* return value error code */ 227 int tmp; /* result value from btree calls */ 228 int ubcount; /* size of user's buffer */ 229 int ubleft; /* bytes left in user's buffer */ 230 char __user *ubufp; /* pointer into user's buffer */ 231 int ubelem; /* spaces used in user's buffer */ 232 int ubused; /* bytes used by formatter */ 233 xfs_buf_t *bp; /* ptr to on-disk inode cluster buf */ 234 235 /* 236 * Get the last inode value, see if there's nothing to do. 237 */ 238 ino = (xfs_ino_t)*lastinop; 239 lastino = ino; 240 agno = XFS_INO_TO_AGNO(mp, ino); 241 agino = XFS_INO_TO_AGINO(mp, ino); 242 if (agno >= mp->m_sb.sb_agcount || 243 ino != XFS_AGINO_TO_INO(mp, agno, agino)) { 244 *done = 1; 245 *ubcountp = 0; 246 return 0; 247 } 248 if (!ubcountp || *ubcountp <= 0) { 249 return EINVAL; 250 } 251 ubcount = *ubcountp; /* statstruct's */ 252 ubleft = ubcount * statstruct_size; /* bytes */ 253 *ubcountp = ubelem = 0; 254 *done = 0; 255 fmterror = 0; 256 ubufp = ubuffer; 257 nicluster = mp->m_sb.sb_blocksize >= XFS_INODE_CLUSTER_SIZE(mp) ? 258 mp->m_sb.sb_inopblock : 259 (XFS_INODE_CLUSTER_SIZE(mp) >> mp->m_sb.sb_inodelog); 260 nimask = ~(nicluster - 1); 261 nbcluster = nicluster >> mp->m_sb.sb_inopblog; 262 irbuf = kmem_zalloc_greedy(&irbsize, PAGE_SIZE, PAGE_SIZE * 4); 263 if (!irbuf) 264 return ENOMEM; 265 266 nirbuf = irbsize / sizeof(*irbuf); 267 268 /* 269 * Loop over the allocation groups, starting from the last 270 * inode returned; 0 means start of the allocation group. 271 */ 272 rval = 0; 273 while (XFS_BULKSTAT_UBLEFT(ubleft) && agno < mp->m_sb.sb_agcount) { 274 cond_resched(); 275 bp = NULL; 276 error = xfs_ialloc_read_agi(mp, NULL, agno, &agbp); 277 if (error) { 278 /* 279 * Skip this allocation group and go to the next one. 280 */ 281 agno++; 282 agino = 0; 283 continue; 284 } 285 agi = XFS_BUF_TO_AGI(agbp); 286 /* 287 * Allocate and initialize a btree cursor for ialloc btree. 288 */ 289 cur = xfs_inobt_init_cursor(mp, NULL, agbp, agno); 290 irbp = irbuf; 291 irbufend = irbuf + nirbuf; 292 end_of_ag = 0; 293 /* 294 * If we're returning in the middle of an allocation group, 295 * we need to get the remainder of the chunk we're in. 296 */ 297 if (agino > 0) { 298 xfs_inobt_rec_incore_t r; 299 300 /* 301 * Lookup the inode chunk that this inode lives in. 302 */ 303 error = xfs_inobt_lookup(cur, agino, XFS_LOOKUP_LE, 304 &tmp); 305 if (!error && /* no I/O error */ 306 tmp && /* lookup succeeded */ 307 /* got the record, should always work */ 308 !(error = xfs_inobt_get_rec(cur, &r, &i)) && 309 i == 1 && 310 /* this is the right chunk */ 311 agino < r.ir_startino + XFS_INODES_PER_CHUNK && 312 /* lastino was not last in chunk */ 313 (chunkidx = agino - r.ir_startino + 1) < 314 XFS_INODES_PER_CHUNK && 315 /* there are some left allocated */ 316 xfs_inobt_maskn(chunkidx, 317 XFS_INODES_PER_CHUNK - chunkidx) & 318 ~r.ir_free) { 319 /* 320 * Grab the chunk record. Mark all the 321 * uninteresting inodes (because they're 322 * before our start point) free. 323 */ 324 for (i = 0; i < chunkidx; i++) { 325 if (XFS_INOBT_MASK(i) & ~r.ir_free) 326 r.ir_freecount++; 327 } 328 r.ir_free |= xfs_inobt_maskn(0, chunkidx); 329 irbp->ir_startino = r.ir_startino; 330 irbp->ir_freecount = r.ir_freecount; 331 irbp->ir_free = r.ir_free; 332 irbp++; 333 agino = r.ir_startino + XFS_INODES_PER_CHUNK; 334 icount = XFS_INODES_PER_CHUNK - r.ir_freecount; 335 } else { 336 /* 337 * If any of those tests failed, bump the 338 * inode number (just in case). 339 */ 340 agino++; 341 icount = 0; 342 } 343 /* 344 * In any case, increment to the next record. 345 */ 346 if (!error) 347 error = xfs_btree_increment(cur, 0, &tmp); 348 } else { 349 /* 350 * Start of ag. Lookup the first inode chunk. 351 */ 352 error = xfs_inobt_lookup(cur, 0, XFS_LOOKUP_GE, &tmp); 353 icount = 0; 354 } 355 /* 356 * Loop through inode btree records in this ag, 357 * until we run out of inodes or space in the buffer. 358 */ 359 while (irbp < irbufend && icount < ubcount) { 360 xfs_inobt_rec_incore_t r; 361 362 /* 363 * Loop as long as we're unable to read the 364 * inode btree. 365 */ 366 while (error) { 367 agino += XFS_INODES_PER_CHUNK; 368 if (XFS_AGINO_TO_AGBNO(mp, agino) >= 369 be32_to_cpu(agi->agi_length)) 370 break; 371 error = xfs_inobt_lookup(cur, agino, 372 XFS_LOOKUP_GE, &tmp); 373 cond_resched(); 374 } 375 /* 376 * If ran off the end of the ag either with an error, 377 * or the normal way, set end and stop collecting. 378 */ 379 if (error) { 380 end_of_ag = 1; 381 break; 382 } 383 384 error = xfs_inobt_get_rec(cur, &r, &i); 385 if (error || i == 0) { 386 end_of_ag = 1; 387 break; 388 } 389 390 /* 391 * If this chunk has any allocated inodes, save it. 392 * Also start read-ahead now for this chunk. 393 */ 394 if (r.ir_freecount < XFS_INODES_PER_CHUNK) { 395 /* 396 * Loop over all clusters in the next chunk. 397 * Do a readahead if there are any allocated 398 * inodes in that cluster. 399 */ 400 agbno = XFS_AGINO_TO_AGBNO(mp, r.ir_startino); 401 for (chunkidx = 0; 402 chunkidx < XFS_INODES_PER_CHUNK; 403 chunkidx += nicluster, 404 agbno += nbcluster) { 405 if (xfs_inobt_maskn(chunkidx, nicluster) 406 & ~r.ir_free) 407 xfs_btree_reada_bufs(mp, agno, 408 agbno, nbcluster); 409 } 410 irbp->ir_startino = r.ir_startino; 411 irbp->ir_freecount = r.ir_freecount; 412 irbp->ir_free = r.ir_free; 413 irbp++; 414 icount += XFS_INODES_PER_CHUNK - r.ir_freecount; 415 } 416 /* 417 * Set agino to after this chunk and bump the cursor. 418 */ 419 agino = r.ir_startino + XFS_INODES_PER_CHUNK; 420 error = xfs_btree_increment(cur, 0, &tmp); 421 cond_resched(); 422 } 423 /* 424 * Drop the btree buffers and the agi buffer. 425 * We can't hold any of the locks these represent 426 * when calling iget. 427 */ 428 xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR); 429 xfs_buf_relse(agbp); 430 /* 431 * Now format all the good inodes into the user's buffer. 432 */ 433 irbufend = irbp; 434 for (irbp = irbuf; 435 irbp < irbufend && XFS_BULKSTAT_UBLEFT(ubleft); irbp++) { 436 /* 437 * Now process this chunk of inodes. 438 */ 439 for (agino = irbp->ir_startino, chunkidx = clustidx = 0; 440 XFS_BULKSTAT_UBLEFT(ubleft) && 441 irbp->ir_freecount < XFS_INODES_PER_CHUNK; 442 chunkidx++, clustidx++, agino++) { 443 ASSERT(chunkidx < XFS_INODES_PER_CHUNK); 444 /* 445 * Recompute agbno if this is the 446 * first inode of the cluster. 447 * 448 * Careful with clustidx. There can be 449 * multiple clusters per chunk, a single 450 * cluster per chunk or a cluster that has 451 * inodes represented from several different 452 * chunks (if blocksize is large). 453 * 454 * Because of this, the starting clustidx is 455 * initialized to zero in this loop but must 456 * later be reset after reading in the cluster 457 * buffer. 458 */ 459 if ((chunkidx & (nicluster - 1)) == 0) { 460 agbno = XFS_AGINO_TO_AGBNO(mp, 461 irbp->ir_startino) + 462 ((chunkidx & nimask) >> 463 mp->m_sb.sb_inopblog); 464 } 465 ino = XFS_AGINO_TO_INO(mp, agno, agino); 466 bno = XFS_AGB_TO_DADDR(mp, agno, agbno); 467 /* 468 * Skip if this inode is free. 469 */ 470 if (XFS_INOBT_MASK(chunkidx) & irbp->ir_free) { 471 lastino = ino; 472 continue; 473 } 474 /* 475 * Count used inodes as free so we can tell 476 * when the chunk is used up. 477 */ 478 irbp->ir_freecount++; 479 480 /* 481 * Get the inode and fill in a single buffer. 482 */ 483 ubused = statstruct_size; 484 error = formatter(mp, ino, ubufp, ubleft, 485 &ubused, &fmterror); 486 if (fmterror == BULKSTAT_RV_NOTHING) { 487 if (error && error != ENOENT && 488 error != EINVAL) { 489 ubleft = 0; 490 rval = error; 491 break; 492 } 493 lastino = ino; 494 continue; 495 } 496 if (fmterror == BULKSTAT_RV_GIVEUP) { 497 ubleft = 0; 498 ASSERT(error); 499 rval = error; 500 break; 501 } 502 if (ubufp) 503 ubufp += ubused; 504 ubleft -= ubused; 505 ubelem++; 506 lastino = ino; 507 } 508 509 cond_resched(); 510 } 511 512 if (bp) 513 xfs_buf_relse(bp); 514 515 /* 516 * Set up for the next loop iteration. 517 */ 518 if (XFS_BULKSTAT_UBLEFT(ubleft)) { 519 if (end_of_ag) { 520 agno++; 521 agino = 0; 522 } else 523 agino = XFS_INO_TO_AGINO(mp, lastino); 524 } else 525 break; 526 } 527 /* 528 * Done, we're either out of filesystem or space to put the data. 529 */ 530 kmem_free_large(irbuf); 531 *ubcountp = ubelem; 532 /* 533 * Found some inodes, return them now and return the error next time. 534 */ 535 if (ubelem) 536 rval = 0; 537 if (agno >= mp->m_sb.sb_agcount) { 538 /* 539 * If we ran out of filesystem, mark lastino as off 540 * the end of the filesystem, so the next call 541 * will return immediately. 542 */ 543 *lastinop = (xfs_ino_t)XFS_AGINO_TO_INO(mp, agno, 0); 544 *done = 1; 545 } else 546 *lastinop = (xfs_ino_t)lastino; 547 548 return rval; 549 } 550 551 /* 552 * Return stat information in bulk (by-inode) for the filesystem. 553 * Special case for non-sequential one inode bulkstat. 554 */ 555 int /* error status */ 556 xfs_bulkstat_single( 557 xfs_mount_t *mp, /* mount point for filesystem */ 558 xfs_ino_t *lastinop, /* inode to return */ 559 char __user *buffer, /* buffer with inode stats */ 560 int *done) /* 1 if there are more stats to get */ 561 { 562 int count; /* count value for bulkstat call */ 563 int error; /* return value */ 564 xfs_ino_t ino; /* filesystem inode number */ 565 int res; /* result from bs1 */ 566 567 /* 568 * note that requesting valid inode numbers which are not allocated 569 * to inodes will most likely cause xfs_itobp to generate warning 570 * messages about bad magic numbers. This is ok. The fact that 571 * the inode isn't actually an inode is handled by the 572 * error check below. Done this way to make the usual case faster 573 * at the expense of the error case. 574 */ 575 576 ino = (xfs_ino_t)*lastinop; 577 error = xfs_bulkstat_one(mp, ino, buffer, sizeof(xfs_bstat_t), 0, &res); 578 if (error) { 579 /* 580 * Special case way failed, do it the "long" way 581 * to see if that works. 582 */ 583 (*lastinop)--; 584 count = 1; 585 if (xfs_bulkstat(mp, lastinop, &count, xfs_bulkstat_one, 586 sizeof(xfs_bstat_t), buffer, done)) 587 return error; 588 if (count == 0 || (xfs_ino_t)*lastinop != ino) 589 return error == EFSCORRUPTED ? 590 XFS_ERROR(EINVAL) : error; 591 else 592 return 0; 593 } 594 *done = 0; 595 return 0; 596 } 597 598 int 599 xfs_inumbers_fmt( 600 void __user *ubuffer, /* buffer to write to */ 601 const xfs_inogrp_t *buffer, /* buffer to read from */ 602 long count, /* # of elements to read */ 603 long *written) /* # of bytes written */ 604 { 605 if (copy_to_user(ubuffer, buffer, count * sizeof(*buffer))) 606 return -EFAULT; 607 *written = count * sizeof(*buffer); 608 return 0; 609 } 610 611 /* 612 * Return inode number table for the filesystem. 613 */ 614 int /* error status */ 615 xfs_inumbers( 616 xfs_mount_t *mp, /* mount point for filesystem */ 617 xfs_ino_t *lastino, /* last inode returned */ 618 int *count, /* size of buffer/count returned */ 619 void __user *ubuffer,/* buffer with inode descriptions */ 620 inumbers_fmt_pf formatter) 621 { 622 xfs_buf_t *agbp; 623 xfs_agino_t agino; 624 xfs_agnumber_t agno; 625 int bcount; 626 xfs_inogrp_t *buffer; 627 int bufidx; 628 xfs_btree_cur_t *cur; 629 int error; 630 xfs_inobt_rec_incore_t r; 631 int i; 632 xfs_ino_t ino; 633 int left; 634 int tmp; 635 636 ino = (xfs_ino_t)*lastino; 637 agno = XFS_INO_TO_AGNO(mp, ino); 638 agino = XFS_INO_TO_AGINO(mp, ino); 639 left = *count; 640 *count = 0; 641 bcount = MIN(left, (int)(PAGE_SIZE / sizeof(*buffer))); 642 buffer = kmem_alloc(bcount * sizeof(*buffer), KM_SLEEP); 643 error = bufidx = 0; 644 cur = NULL; 645 agbp = NULL; 646 while (left > 0 && agno < mp->m_sb.sb_agcount) { 647 if (agbp == NULL) { 648 error = xfs_ialloc_read_agi(mp, NULL, agno, &agbp); 649 if (error) { 650 /* 651 * If we can't read the AGI of this ag, 652 * then just skip to the next one. 653 */ 654 ASSERT(cur == NULL); 655 agbp = NULL; 656 agno++; 657 agino = 0; 658 continue; 659 } 660 cur = xfs_inobt_init_cursor(mp, NULL, agbp, agno); 661 error = xfs_inobt_lookup(cur, agino, XFS_LOOKUP_GE, 662 &tmp); 663 if (error) { 664 xfs_btree_del_cursor(cur, XFS_BTREE_ERROR); 665 cur = NULL; 666 xfs_buf_relse(agbp); 667 agbp = NULL; 668 /* 669 * Move up the last inode in the current 670 * chunk. The lookup_ge will always get 671 * us the first inode in the next chunk. 672 */ 673 agino += XFS_INODES_PER_CHUNK - 1; 674 continue; 675 } 676 } 677 error = xfs_inobt_get_rec(cur, &r, &i); 678 if (error || i == 0) { 679 xfs_buf_relse(agbp); 680 agbp = NULL; 681 xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR); 682 cur = NULL; 683 agno++; 684 agino = 0; 685 continue; 686 } 687 agino = r.ir_startino + XFS_INODES_PER_CHUNK - 1; 688 buffer[bufidx].xi_startino = 689 XFS_AGINO_TO_INO(mp, agno, r.ir_startino); 690 buffer[bufidx].xi_alloccount = 691 XFS_INODES_PER_CHUNK - r.ir_freecount; 692 buffer[bufidx].xi_allocmask = ~r.ir_free; 693 bufidx++; 694 left--; 695 if (bufidx == bcount) { 696 long written; 697 if (formatter(ubuffer, buffer, bufidx, &written)) { 698 error = XFS_ERROR(EFAULT); 699 break; 700 } 701 ubuffer += written; 702 *count += bufidx; 703 bufidx = 0; 704 } 705 if (left) { 706 error = xfs_btree_increment(cur, 0, &tmp); 707 if (error) { 708 xfs_btree_del_cursor(cur, XFS_BTREE_ERROR); 709 cur = NULL; 710 xfs_buf_relse(agbp); 711 agbp = NULL; 712 /* 713 * The agino value has already been bumped. 714 * Just try to skip up to it. 715 */ 716 agino += XFS_INODES_PER_CHUNK; 717 continue; 718 } 719 } 720 } 721 if (!error) { 722 if (bufidx) { 723 long written; 724 if (formatter(ubuffer, buffer, bufidx, &written)) 725 error = XFS_ERROR(EFAULT); 726 else 727 *count += bufidx; 728 } 729 *lastino = XFS_AGINO_TO_INO(mp, agno, agino); 730 } 731 kmem_free(buffer); 732 if (cur) 733 xfs_btree_del_cursor(cur, (error ? XFS_BTREE_ERROR : 734 XFS_BTREE_NOERROR)); 735 if (agbp) 736 xfs_buf_relse(agbp); 737 return error; 738 } 739