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