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_shared.h" 21 #include "xfs_format.h" 22 #include "xfs_log_format.h" 23 #include "xfs_trans_resv.h" 24 #include "xfs_mount.h" 25 #include "xfs_inode.h" 26 #include "xfs_btree.h" 27 #include "xfs_ialloc.h" 28 #include "xfs_ialloc_btree.h" 29 #include "xfs_itable.h" 30 #include "xfs_error.h" 31 #include "xfs_trace.h" 32 #include "xfs_icache.h" 33 34 STATIC int 35 xfs_internal_inum( 36 xfs_mount_t *mp, 37 xfs_ino_t ino) 38 { 39 return (ino == mp->m_sb.sb_rbmino || ino == mp->m_sb.sb_rsumino || 40 (xfs_sb_version_hasquota(&mp->m_sb) && 41 xfs_is_quota_inode(&mp->m_sb, ino))); 42 } 43 44 /* 45 * Return stat information for one inode. 46 * Return 0 if ok, else errno. 47 */ 48 int 49 xfs_bulkstat_one_int( 50 struct xfs_mount *mp, /* mount point for filesystem */ 51 xfs_ino_t ino, /* inode to get data for */ 52 void __user *buffer, /* buffer to place output in */ 53 int ubsize, /* size of buffer */ 54 bulkstat_one_fmt_pf formatter, /* formatter, copy to user */ 55 int *ubused, /* bytes used by me */ 56 int *stat) /* BULKSTAT_RV_... */ 57 { 58 struct xfs_icdinode *dic; /* dinode core info pointer */ 59 struct xfs_inode *ip; /* incore inode pointer */ 60 struct xfs_bstat *buf; /* return buffer */ 61 int error = 0; /* error value */ 62 63 *stat = BULKSTAT_RV_NOTHING; 64 65 if (!buffer || xfs_internal_inum(mp, ino)) 66 return -EINVAL; 67 68 buf = kmem_alloc(sizeof(*buf), KM_SLEEP | KM_MAYFAIL); 69 if (!buf) 70 return -ENOMEM; 71 72 error = xfs_iget(mp, NULL, ino, 73 (XFS_IGET_DONTCACHE | XFS_IGET_UNTRUSTED), 74 XFS_ILOCK_SHARED, &ip); 75 if (error) 76 goto out_free; 77 78 ASSERT(ip != NULL); 79 ASSERT(ip->i_imap.im_blkno != 0); 80 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_lo = dic->di_projid_lo; 88 buf->bs_projid_hi = dic->di_projid_hi; 89 buf->bs_ino = ino; 90 buf->bs_mode = dic->di_mode; 91 buf->bs_uid = dic->di_uid; 92 buf->bs_gid = dic->di_gid; 93 buf->bs_size = dic->di_size; 94 buf->bs_atime.tv_sec = dic->di_atime.t_sec; 95 buf->bs_atime.tv_nsec = dic->di_atime.t_nsec; 96 buf->bs_mtime.tv_sec = dic->di_mtime.t_sec; 97 buf->bs_mtime.tv_nsec = dic->di_mtime.t_nsec; 98 buf->bs_ctime.tv_sec = dic->di_ctime.t_sec; 99 buf->bs_ctime.tv_nsec = dic->di_ctime.t_nsec; 100 buf->bs_xflags = xfs_ip2xflags(ip); 101 buf->bs_extsize = dic->di_extsize << mp->m_sb.sb_blocklog; 102 buf->bs_extents = dic->di_nextents; 103 buf->bs_gen = dic->di_gen; 104 memset(buf->bs_pad, 0, sizeof(buf->bs_pad)); 105 buf->bs_dmevmask = dic->di_dmevmask; 106 buf->bs_dmstate = dic->di_dmstate; 107 buf->bs_aextents = dic->di_anextents; 108 buf->bs_forkoff = XFS_IFORK_BOFF(ip); 109 110 switch (dic->di_format) { 111 case XFS_DINODE_FMT_DEV: 112 buf->bs_rdev = ip->i_df.if_u2.if_rdev; 113 buf->bs_blksize = BLKDEV_IOSIZE; 114 buf->bs_blocks = 0; 115 break; 116 case XFS_DINODE_FMT_LOCAL: 117 case XFS_DINODE_FMT_UUID: 118 buf->bs_rdev = 0; 119 buf->bs_blksize = mp->m_sb.sb_blocksize; 120 buf->bs_blocks = 0; 121 break; 122 case XFS_DINODE_FMT_EXTENTS: 123 case XFS_DINODE_FMT_BTREE: 124 buf->bs_rdev = 0; 125 buf->bs_blksize = mp->m_sb.sb_blocksize; 126 buf->bs_blocks = dic->di_nblocks + ip->i_delayed_blks; 127 break; 128 } 129 xfs_iunlock(ip, XFS_ILOCK_SHARED); 130 IRELE(ip); 131 132 error = formatter(buffer, ubsize, ubused, buf); 133 if (!error) 134 *stat = BULKSTAT_RV_DIDONE; 135 136 out_free: 137 kmem_free(buf); 138 return error; 139 } 140 141 /* Return 0 on success or positive error */ 142 STATIC int 143 xfs_bulkstat_one_fmt( 144 void __user *ubuffer, 145 int ubsize, 146 int *ubused, 147 const xfs_bstat_t *buffer) 148 { 149 if (ubsize < sizeof(*buffer)) 150 return -ENOMEM; 151 if (copy_to_user(ubuffer, buffer, sizeof(*buffer))) 152 return -EFAULT; 153 if (ubused) 154 *ubused = sizeof(*buffer); 155 return 0; 156 } 157 158 int 159 xfs_bulkstat_one( 160 xfs_mount_t *mp, /* mount point for filesystem */ 161 xfs_ino_t ino, /* inode number to get data for */ 162 void __user *buffer, /* buffer to place output in */ 163 int ubsize, /* size of buffer */ 164 int *ubused, /* bytes used by me */ 165 int *stat) /* BULKSTAT_RV_... */ 166 { 167 return xfs_bulkstat_one_int(mp, ino, buffer, ubsize, 168 xfs_bulkstat_one_fmt, ubused, stat); 169 } 170 171 /* 172 * Loop over all clusters in a chunk for a given incore inode allocation btree 173 * record. Do a readahead if there are any allocated inodes in that cluster. 174 */ 175 STATIC void 176 xfs_bulkstat_ichunk_ra( 177 struct xfs_mount *mp, 178 xfs_agnumber_t agno, 179 struct xfs_inobt_rec_incore *irec) 180 { 181 xfs_agblock_t agbno; 182 struct blk_plug plug; 183 int blks_per_cluster; 184 int inodes_per_cluster; 185 int i; /* inode chunk index */ 186 187 agbno = XFS_AGINO_TO_AGBNO(mp, irec->ir_startino); 188 blks_per_cluster = xfs_icluster_size_fsb(mp); 189 inodes_per_cluster = blks_per_cluster << mp->m_sb.sb_inopblog; 190 191 blk_start_plug(&plug); 192 for (i = 0; i < XFS_INODES_PER_CHUNK; 193 i += inodes_per_cluster, agbno += blks_per_cluster) { 194 if (xfs_inobt_maskn(i, inodes_per_cluster) & ~irec->ir_free) { 195 xfs_btree_reada_bufs(mp, agno, agbno, blks_per_cluster, 196 &xfs_inode_buf_ops); 197 } 198 } 199 blk_finish_plug(&plug); 200 } 201 202 /* 203 * Lookup the inode chunk that the given inode lives in and then get the record 204 * if we found the chunk. If the inode was not the last in the chunk and there 205 * are some left allocated, update the data for the pointed-to record as well as 206 * return the count of grabbed inodes. 207 */ 208 STATIC int 209 xfs_bulkstat_grab_ichunk( 210 struct xfs_btree_cur *cur, /* btree cursor */ 211 xfs_agino_t agino, /* starting inode of chunk */ 212 int *icount,/* return # of inodes grabbed */ 213 struct xfs_inobt_rec_incore *irec) /* btree record */ 214 { 215 int idx; /* index into inode chunk */ 216 int stat; 217 int error = 0; 218 219 /* Lookup the inode chunk that this inode lives in */ 220 error = xfs_inobt_lookup(cur, agino, XFS_LOOKUP_LE, &stat); 221 if (error) 222 return error; 223 if (!stat) { 224 *icount = 0; 225 return error; 226 } 227 228 /* Get the record, should always work */ 229 error = xfs_inobt_get_rec(cur, irec, &stat); 230 if (error) 231 return error; 232 XFS_WANT_CORRUPTED_RETURN(cur->bc_mp, stat == 1); 233 234 /* Check if the record contains the inode in request */ 235 if (irec->ir_startino + XFS_INODES_PER_CHUNK <= agino) { 236 *icount = 0; 237 return 0; 238 } 239 240 idx = agino - irec->ir_startino + 1; 241 if (idx < XFS_INODES_PER_CHUNK && 242 (xfs_inobt_maskn(idx, XFS_INODES_PER_CHUNK - idx) & ~irec->ir_free)) { 243 int i; 244 245 /* We got a right chunk with some left inodes allocated at it. 246 * Grab the chunk record. Mark all the uninteresting inodes 247 * free -- because they're before our start point. 248 */ 249 for (i = 0; i < idx; i++) { 250 if (XFS_INOBT_MASK(i) & ~irec->ir_free) 251 irec->ir_freecount++; 252 } 253 254 irec->ir_free |= xfs_inobt_maskn(0, idx); 255 *icount = irec->ir_count - irec->ir_freecount; 256 } 257 258 return 0; 259 } 260 261 #define XFS_BULKSTAT_UBLEFT(ubleft) ((ubleft) >= statstruct_size) 262 263 struct xfs_bulkstat_agichunk { 264 char __user **ac_ubuffer;/* pointer into user's buffer */ 265 int ac_ubleft; /* bytes left in user's buffer */ 266 int ac_ubelem; /* spaces used in user's buffer */ 267 }; 268 269 /* 270 * Process inodes in chunk with a pointer to a formatter function 271 * that will iget the inode and fill in the appropriate structure. 272 */ 273 static int 274 xfs_bulkstat_ag_ichunk( 275 struct xfs_mount *mp, 276 xfs_agnumber_t agno, 277 struct xfs_inobt_rec_incore *irbp, 278 bulkstat_one_pf formatter, 279 size_t statstruct_size, 280 struct xfs_bulkstat_agichunk *acp, 281 xfs_agino_t *last_agino) 282 { 283 char __user **ubufp = acp->ac_ubuffer; 284 int chunkidx; 285 int error = 0; 286 xfs_agino_t agino = irbp->ir_startino; 287 288 for (chunkidx = 0; chunkidx < XFS_INODES_PER_CHUNK; 289 chunkidx++, agino++) { 290 int fmterror; 291 int ubused; 292 293 /* inode won't fit in buffer, we are done */ 294 if (acp->ac_ubleft < statstruct_size) 295 break; 296 297 /* Skip if this inode is free */ 298 if (XFS_INOBT_MASK(chunkidx) & irbp->ir_free) 299 continue; 300 301 /* Get the inode and fill in a single buffer */ 302 ubused = statstruct_size; 303 error = formatter(mp, XFS_AGINO_TO_INO(mp, agno, agino), 304 *ubufp, acp->ac_ubleft, &ubused, &fmterror); 305 306 if (fmterror == BULKSTAT_RV_GIVEUP || 307 (error && error != -ENOENT && error != -EINVAL)) { 308 acp->ac_ubleft = 0; 309 ASSERT(error); 310 break; 311 } 312 313 /* be careful not to leak error if at end of chunk */ 314 if (fmterror == BULKSTAT_RV_NOTHING || error) { 315 error = 0; 316 continue; 317 } 318 319 *ubufp += ubused; 320 acp->ac_ubleft -= ubused; 321 acp->ac_ubelem++; 322 } 323 324 /* 325 * Post-update *last_agino. At this point, agino will always point one 326 * inode past the last inode we processed successfully. Hence we 327 * substract that inode when setting the *last_agino cursor so that we 328 * return the correct cookie to userspace. On the next bulkstat call, 329 * the inode under the lastino cookie will be skipped as we have already 330 * processed it here. 331 */ 332 *last_agino = agino - 1; 333 334 return error; 335 } 336 337 /* 338 * Return stat information in bulk (by-inode) for the filesystem. 339 */ 340 int /* error status */ 341 xfs_bulkstat( 342 xfs_mount_t *mp, /* mount point for filesystem */ 343 xfs_ino_t *lastinop, /* last inode returned */ 344 int *ubcountp, /* size of buffer/count returned */ 345 bulkstat_one_pf formatter, /* func that'd fill a single buf */ 346 size_t statstruct_size, /* sizeof struct filling */ 347 char __user *ubuffer, /* buffer with inode stats */ 348 int *done) /* 1 if there are more stats to get */ 349 { 350 xfs_buf_t *agbp; /* agi header buffer */ 351 xfs_agino_t agino; /* inode # in allocation group */ 352 xfs_agnumber_t agno; /* allocation group number */ 353 xfs_btree_cur_t *cur; /* btree cursor for ialloc btree */ 354 size_t irbsize; /* size of irec buffer in bytes */ 355 xfs_inobt_rec_incore_t *irbuf; /* start of irec buffer */ 356 int nirbuf; /* size of irbuf */ 357 int ubcount; /* size of user's buffer */ 358 struct xfs_bulkstat_agichunk ac; 359 int error = 0; 360 361 /* 362 * Get the last inode value, see if there's nothing to do. 363 */ 364 agno = XFS_INO_TO_AGNO(mp, *lastinop); 365 agino = XFS_INO_TO_AGINO(mp, *lastinop); 366 if (agno >= mp->m_sb.sb_agcount || 367 *lastinop != XFS_AGINO_TO_INO(mp, agno, agino)) { 368 *done = 1; 369 *ubcountp = 0; 370 return 0; 371 } 372 373 ubcount = *ubcountp; /* statstruct's */ 374 ac.ac_ubuffer = &ubuffer; 375 ac.ac_ubleft = ubcount * statstruct_size; /* bytes */; 376 ac.ac_ubelem = 0; 377 378 *ubcountp = 0; 379 *done = 0; 380 381 irbuf = kmem_zalloc_greedy(&irbsize, PAGE_SIZE, PAGE_SIZE * 4); 382 if (!irbuf) 383 return -ENOMEM; 384 385 nirbuf = irbsize / sizeof(*irbuf); 386 387 /* 388 * Loop over the allocation groups, starting from the last 389 * inode returned; 0 means start of the allocation group. 390 */ 391 while (agno < mp->m_sb.sb_agcount) { 392 struct xfs_inobt_rec_incore *irbp = irbuf; 393 struct xfs_inobt_rec_incore *irbufend = irbuf + nirbuf; 394 bool end_of_ag = false; 395 int icount = 0; 396 int stat; 397 398 error = xfs_ialloc_read_agi(mp, NULL, agno, &agbp); 399 if (error) 400 break; 401 /* 402 * Allocate and initialize a btree cursor for ialloc btree. 403 */ 404 cur = xfs_inobt_init_cursor(mp, NULL, agbp, agno, 405 XFS_BTNUM_INO); 406 if (agino > 0) { 407 /* 408 * In the middle of an allocation group, we need to get 409 * the remainder of the chunk we're in. 410 */ 411 struct xfs_inobt_rec_incore r; 412 413 error = xfs_bulkstat_grab_ichunk(cur, agino, &icount, &r); 414 if (error) 415 goto del_cursor; 416 if (icount) { 417 irbp->ir_startino = r.ir_startino; 418 irbp->ir_holemask = r.ir_holemask; 419 irbp->ir_count = r.ir_count; 420 irbp->ir_freecount = r.ir_freecount; 421 irbp->ir_free = r.ir_free; 422 irbp++; 423 } 424 /* Increment to the next record */ 425 error = xfs_btree_increment(cur, 0, &stat); 426 } else { 427 /* Start of ag. Lookup the first inode chunk */ 428 error = xfs_inobt_lookup(cur, 0, XFS_LOOKUP_GE, &stat); 429 } 430 if (error || stat == 0) { 431 end_of_ag = true; 432 goto del_cursor; 433 } 434 435 /* 436 * Loop through inode btree records in this ag, 437 * until we run out of inodes or space in the buffer. 438 */ 439 while (irbp < irbufend && icount < ubcount) { 440 struct xfs_inobt_rec_incore r; 441 442 error = xfs_inobt_get_rec(cur, &r, &stat); 443 if (error || stat == 0) { 444 end_of_ag = true; 445 goto del_cursor; 446 } 447 448 /* 449 * If this chunk has any allocated inodes, save it. 450 * Also start read-ahead now for this chunk. 451 */ 452 if (r.ir_freecount < r.ir_count) { 453 xfs_bulkstat_ichunk_ra(mp, agno, &r); 454 irbp->ir_startino = r.ir_startino; 455 irbp->ir_holemask = r.ir_holemask; 456 irbp->ir_count = r.ir_count; 457 irbp->ir_freecount = r.ir_freecount; 458 irbp->ir_free = r.ir_free; 459 irbp++; 460 icount += r.ir_count - r.ir_freecount; 461 } 462 error = xfs_btree_increment(cur, 0, &stat); 463 if (error || stat == 0) { 464 end_of_ag = true; 465 goto del_cursor; 466 } 467 cond_resched(); 468 } 469 470 /* 471 * Drop the btree buffers and the agi buffer as we can't hold any 472 * of the locks these represent when calling iget. If there is a 473 * pending error, then we are done. 474 */ 475 del_cursor: 476 xfs_btree_del_cursor(cur, error ? 477 XFS_BTREE_ERROR : XFS_BTREE_NOERROR); 478 xfs_buf_relse(agbp); 479 if (error) 480 break; 481 /* 482 * Now format all the good inodes into the user's buffer. The 483 * call to xfs_bulkstat_ag_ichunk() sets up the agino pointer 484 * for the next loop iteration. 485 */ 486 irbufend = irbp; 487 for (irbp = irbuf; 488 irbp < irbufend && ac.ac_ubleft >= statstruct_size; 489 irbp++) { 490 error = xfs_bulkstat_ag_ichunk(mp, agno, irbp, 491 formatter, statstruct_size, &ac, 492 &agino); 493 if (error) 494 break; 495 496 cond_resched(); 497 } 498 499 /* 500 * If we've run out of space or had a formatting error, we 501 * are now done 502 */ 503 if (ac.ac_ubleft < statstruct_size || error) 504 break; 505 506 if (end_of_ag) { 507 agno++; 508 agino = 0; 509 } 510 } 511 /* 512 * Done, we're either out of filesystem or space to put the data. 513 */ 514 kmem_free(irbuf); 515 *ubcountp = ac.ac_ubelem; 516 517 /* 518 * We found some inodes, so clear the error status and return them. 519 * The lastino pointer will point directly at the inode that triggered 520 * any error that occurred, so on the next call the error will be 521 * triggered again and propagated to userspace as there will be no 522 * formatted inodes in the buffer. 523 */ 524 if (ac.ac_ubelem) 525 error = 0; 526 527 /* 528 * If we ran out of filesystem, lastino will point off the end of 529 * the filesystem so the next call will return immediately. 530 */ 531 *lastinop = XFS_AGINO_TO_INO(mp, agno, agino); 532 if (agno >= mp->m_sb.sb_agcount) 533 *done = 1; 534 535 return error; 536 } 537 538 int 539 xfs_inumbers_fmt( 540 void __user *ubuffer, /* buffer to write to */ 541 const struct xfs_inogrp *buffer, /* buffer to read from */ 542 long count, /* # of elements to read */ 543 long *written) /* # of bytes written */ 544 { 545 if (copy_to_user(ubuffer, buffer, count * sizeof(*buffer))) 546 return -EFAULT; 547 *written = count * sizeof(*buffer); 548 return 0; 549 } 550 551 /* 552 * Return inode number table for the filesystem. 553 */ 554 int /* error status */ 555 xfs_inumbers( 556 struct xfs_mount *mp,/* mount point for filesystem */ 557 xfs_ino_t *lastino,/* last inode returned */ 558 int *count,/* size of buffer/count returned */ 559 void __user *ubuffer,/* buffer with inode descriptions */ 560 inumbers_fmt_pf formatter) 561 { 562 xfs_agnumber_t agno = XFS_INO_TO_AGNO(mp, *lastino); 563 xfs_agino_t agino = XFS_INO_TO_AGINO(mp, *lastino); 564 struct xfs_btree_cur *cur = NULL; 565 struct xfs_buf *agbp = NULL; 566 struct xfs_inogrp *buffer; 567 int bcount; 568 int left = *count; 569 int bufidx = 0; 570 int error = 0; 571 572 *count = 0; 573 if (agno >= mp->m_sb.sb_agcount || 574 *lastino != XFS_AGINO_TO_INO(mp, agno, agino)) 575 return error; 576 577 bcount = MIN(left, (int)(PAGE_SIZE / sizeof(*buffer))); 578 buffer = kmem_alloc(bcount * sizeof(*buffer), KM_SLEEP); 579 do { 580 struct xfs_inobt_rec_incore r; 581 int stat; 582 583 if (!agbp) { 584 error = xfs_ialloc_read_agi(mp, NULL, agno, &agbp); 585 if (error) 586 break; 587 588 cur = xfs_inobt_init_cursor(mp, NULL, agbp, agno, 589 XFS_BTNUM_INO); 590 error = xfs_inobt_lookup(cur, agino, XFS_LOOKUP_GE, 591 &stat); 592 if (error) 593 break; 594 if (!stat) 595 goto next_ag; 596 } 597 598 error = xfs_inobt_get_rec(cur, &r, &stat); 599 if (error) 600 break; 601 if (!stat) 602 goto next_ag; 603 604 agino = r.ir_startino + XFS_INODES_PER_CHUNK - 1; 605 buffer[bufidx].xi_startino = 606 XFS_AGINO_TO_INO(mp, agno, r.ir_startino); 607 buffer[bufidx].xi_alloccount = r.ir_count - r.ir_freecount; 608 buffer[bufidx].xi_allocmask = ~r.ir_free; 609 if (++bufidx == bcount) { 610 long written; 611 612 error = formatter(ubuffer, buffer, bufidx, &written); 613 if (error) 614 break; 615 ubuffer += written; 616 *count += bufidx; 617 bufidx = 0; 618 } 619 if (!--left) 620 break; 621 622 error = xfs_btree_increment(cur, 0, &stat); 623 if (error) 624 break; 625 if (stat) 626 continue; 627 628 next_ag: 629 xfs_btree_del_cursor(cur, XFS_BTREE_ERROR); 630 cur = NULL; 631 xfs_buf_relse(agbp); 632 agbp = NULL; 633 agino = 0; 634 agno++; 635 } while (agno < mp->m_sb.sb_agcount); 636 637 if (!error) { 638 if (bufidx) { 639 long written; 640 641 error = formatter(ubuffer, buffer, bufidx, &written); 642 if (!error) 643 *count += bufidx; 644 } 645 *lastino = XFS_AGINO_TO_INO(mp, agno, agino); 646 } 647 648 kmem_free(buffer); 649 if (cur) 650 xfs_btree_del_cursor(cur, (error ? XFS_BTREE_ERROR : 651 XFS_BTREE_NOERROR)); 652 if (agbp) 653 xfs_buf_relse(agbp); 654 655 return error; 656 } 657