1 /* 2 * the_nilfs.c - the_nilfs shared structure. 3 * 4 * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation. 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 19 * 20 * Written by Ryusuke Konishi <ryusuke@osrg.net> 21 * 22 */ 23 24 #include <linux/buffer_head.h> 25 #include <linux/slab.h> 26 #include <linux/blkdev.h> 27 #include <linux/backing-dev.h> 28 #include <linux/crc32.h> 29 #include "nilfs.h" 30 #include "segment.h" 31 #include "alloc.h" 32 #include "cpfile.h" 33 #include "sufile.h" 34 #include "dat.h" 35 #include "segbuf.h" 36 37 38 static int nilfs_valid_sb(struct nilfs_super_block *sbp); 39 40 void nilfs_set_last_segment(struct the_nilfs *nilfs, 41 sector_t start_blocknr, u64 seq, __u64 cno) 42 { 43 spin_lock(&nilfs->ns_last_segment_lock); 44 nilfs->ns_last_pseg = start_blocknr; 45 nilfs->ns_last_seq = seq; 46 nilfs->ns_last_cno = cno; 47 48 if (!nilfs_sb_dirty(nilfs)) { 49 if (nilfs->ns_prev_seq == nilfs->ns_last_seq) 50 goto stay_cursor; 51 52 set_nilfs_sb_dirty(nilfs); 53 } 54 nilfs->ns_prev_seq = nilfs->ns_last_seq; 55 56 stay_cursor: 57 spin_unlock(&nilfs->ns_last_segment_lock); 58 } 59 60 /** 61 * alloc_nilfs - allocate a nilfs object 62 * @bdev: block device to which the_nilfs is related 63 * 64 * Return Value: On success, pointer to the_nilfs is returned. 65 * On error, NULL is returned. 66 */ 67 struct the_nilfs *alloc_nilfs(struct block_device *bdev) 68 { 69 struct the_nilfs *nilfs; 70 71 nilfs = kzalloc(sizeof(*nilfs), GFP_KERNEL); 72 if (!nilfs) 73 return NULL; 74 75 nilfs->ns_bdev = bdev; 76 atomic_set(&nilfs->ns_ndirtyblks, 0); 77 init_rwsem(&nilfs->ns_sem); 78 INIT_LIST_HEAD(&nilfs->ns_gc_inodes); 79 spin_lock_init(&nilfs->ns_last_segment_lock); 80 nilfs->ns_cptree = RB_ROOT; 81 spin_lock_init(&nilfs->ns_cptree_lock); 82 init_rwsem(&nilfs->ns_segctor_sem); 83 84 return nilfs; 85 } 86 87 /** 88 * destroy_nilfs - destroy nilfs object 89 * @nilfs: nilfs object to be released 90 */ 91 void destroy_nilfs(struct the_nilfs *nilfs) 92 { 93 might_sleep(); 94 if (nilfs_init(nilfs)) { 95 brelse(nilfs->ns_sbh[0]); 96 brelse(nilfs->ns_sbh[1]); 97 } 98 kfree(nilfs); 99 } 100 101 static int nilfs_load_super_root(struct the_nilfs *nilfs, 102 struct super_block *sb, sector_t sr_block) 103 { 104 struct buffer_head *bh_sr; 105 struct nilfs_super_root *raw_sr; 106 struct nilfs_super_block **sbp = nilfs->ns_sbp; 107 struct nilfs_inode *rawi; 108 unsigned dat_entry_size, segment_usage_size, checkpoint_size; 109 unsigned inode_size; 110 int err; 111 112 err = nilfs_read_super_root_block(nilfs, sr_block, &bh_sr, 1); 113 if (unlikely(err)) 114 return err; 115 116 down_read(&nilfs->ns_sem); 117 dat_entry_size = le16_to_cpu(sbp[0]->s_dat_entry_size); 118 checkpoint_size = le16_to_cpu(sbp[0]->s_checkpoint_size); 119 segment_usage_size = le16_to_cpu(sbp[0]->s_segment_usage_size); 120 up_read(&nilfs->ns_sem); 121 122 inode_size = nilfs->ns_inode_size; 123 124 rawi = (void *)bh_sr->b_data + NILFS_SR_DAT_OFFSET(inode_size); 125 err = nilfs_dat_read(sb, dat_entry_size, rawi, &nilfs->ns_dat); 126 if (err) 127 goto failed; 128 129 rawi = (void *)bh_sr->b_data + NILFS_SR_CPFILE_OFFSET(inode_size); 130 err = nilfs_cpfile_read(sb, checkpoint_size, rawi, &nilfs->ns_cpfile); 131 if (err) 132 goto failed_dat; 133 134 rawi = (void *)bh_sr->b_data + NILFS_SR_SUFILE_OFFSET(inode_size); 135 err = nilfs_sufile_read(sb, segment_usage_size, rawi, 136 &nilfs->ns_sufile); 137 if (err) 138 goto failed_cpfile; 139 140 raw_sr = (struct nilfs_super_root *)bh_sr->b_data; 141 nilfs->ns_nongc_ctime = le64_to_cpu(raw_sr->sr_nongc_ctime); 142 143 failed: 144 brelse(bh_sr); 145 return err; 146 147 failed_cpfile: 148 iput(nilfs->ns_cpfile); 149 150 failed_dat: 151 iput(nilfs->ns_dat); 152 goto failed; 153 } 154 155 static void nilfs_init_recovery_info(struct nilfs_recovery_info *ri) 156 { 157 memset(ri, 0, sizeof(*ri)); 158 INIT_LIST_HEAD(&ri->ri_used_segments); 159 } 160 161 static void nilfs_clear_recovery_info(struct nilfs_recovery_info *ri) 162 { 163 nilfs_dispose_segment_list(&ri->ri_used_segments); 164 } 165 166 /** 167 * nilfs_store_log_cursor - load log cursor from a super block 168 * @nilfs: nilfs object 169 * @sbp: buffer storing super block to be read 170 * 171 * nilfs_store_log_cursor() reads the last position of the log 172 * containing a super root from a given super block, and initializes 173 * relevant information on the nilfs object preparatory for log 174 * scanning and recovery. 175 */ 176 static int nilfs_store_log_cursor(struct the_nilfs *nilfs, 177 struct nilfs_super_block *sbp) 178 { 179 int ret = 0; 180 181 nilfs->ns_last_pseg = le64_to_cpu(sbp->s_last_pseg); 182 nilfs->ns_last_cno = le64_to_cpu(sbp->s_last_cno); 183 nilfs->ns_last_seq = le64_to_cpu(sbp->s_last_seq); 184 185 nilfs->ns_prev_seq = nilfs->ns_last_seq; 186 nilfs->ns_seg_seq = nilfs->ns_last_seq; 187 nilfs->ns_segnum = 188 nilfs_get_segnum_of_block(nilfs, nilfs->ns_last_pseg); 189 nilfs->ns_cno = nilfs->ns_last_cno + 1; 190 if (nilfs->ns_segnum >= nilfs->ns_nsegments) { 191 printk(KERN_ERR "NILFS invalid last segment number.\n"); 192 ret = -EINVAL; 193 } 194 return ret; 195 } 196 197 /** 198 * load_nilfs - load and recover the nilfs 199 * @nilfs: the_nilfs structure to be released 200 * @sbi: nilfs_sb_info used to recover past segment 201 * 202 * load_nilfs() searches and load the latest super root, 203 * attaches the last segment, and does recovery if needed. 204 * The caller must call this exclusively for simultaneous mounts. 205 */ 206 int load_nilfs(struct the_nilfs *nilfs, struct nilfs_sb_info *sbi) 207 { 208 struct nilfs_recovery_info ri; 209 unsigned int s_flags = sbi->s_super->s_flags; 210 int really_read_only = bdev_read_only(nilfs->ns_bdev); 211 int valid_fs = nilfs_valid_fs(nilfs); 212 int err; 213 214 if (!valid_fs) { 215 printk(KERN_WARNING "NILFS warning: mounting unchecked fs\n"); 216 if (s_flags & MS_RDONLY) { 217 printk(KERN_INFO "NILFS: INFO: recovery " 218 "required for readonly filesystem.\n"); 219 printk(KERN_INFO "NILFS: write access will " 220 "be enabled during recovery.\n"); 221 } 222 } 223 224 nilfs_init_recovery_info(&ri); 225 226 err = nilfs_search_super_root(nilfs, &ri); 227 if (unlikely(err)) { 228 struct nilfs_super_block **sbp = nilfs->ns_sbp; 229 int blocksize; 230 231 if (err != -EINVAL) 232 goto scan_error; 233 234 if (!nilfs_valid_sb(sbp[1])) { 235 printk(KERN_WARNING 236 "NILFS warning: unable to fall back to spare" 237 "super block\n"); 238 goto scan_error; 239 } 240 printk(KERN_INFO 241 "NILFS: try rollback from an earlier position\n"); 242 243 /* 244 * restore super block with its spare and reconfigure 245 * relevant states of the nilfs object. 246 */ 247 memcpy(sbp[0], sbp[1], nilfs->ns_sbsize); 248 nilfs->ns_crc_seed = le32_to_cpu(sbp[0]->s_crc_seed); 249 nilfs->ns_sbwtime = le64_to_cpu(sbp[0]->s_wtime); 250 251 /* verify consistency between two super blocks */ 252 blocksize = BLOCK_SIZE << le32_to_cpu(sbp[0]->s_log_block_size); 253 if (blocksize != nilfs->ns_blocksize) { 254 printk(KERN_WARNING 255 "NILFS warning: blocksize differs between " 256 "two super blocks (%d != %d)\n", 257 blocksize, nilfs->ns_blocksize); 258 goto scan_error; 259 } 260 261 err = nilfs_store_log_cursor(nilfs, sbp[0]); 262 if (err) 263 goto scan_error; 264 265 /* drop clean flag to allow roll-forward and recovery */ 266 nilfs->ns_mount_state &= ~NILFS_VALID_FS; 267 valid_fs = 0; 268 269 err = nilfs_search_super_root(nilfs, &ri); 270 if (err) 271 goto scan_error; 272 } 273 274 err = nilfs_load_super_root(nilfs, sbi->s_super, ri.ri_super_root); 275 if (unlikely(err)) { 276 printk(KERN_ERR "NILFS: error loading super root.\n"); 277 goto failed; 278 } 279 280 if (valid_fs) 281 goto skip_recovery; 282 283 if (s_flags & MS_RDONLY) { 284 __u64 features; 285 286 if (nilfs_test_opt(sbi, NORECOVERY)) { 287 printk(KERN_INFO "NILFS: norecovery option specified. " 288 "skipping roll-forward recovery\n"); 289 goto skip_recovery; 290 } 291 features = le64_to_cpu(nilfs->ns_sbp[0]->s_feature_compat_ro) & 292 ~NILFS_FEATURE_COMPAT_RO_SUPP; 293 if (features) { 294 printk(KERN_ERR "NILFS: couldn't proceed with " 295 "recovery because of unsupported optional " 296 "features (%llx)\n", 297 (unsigned long long)features); 298 err = -EROFS; 299 goto failed_unload; 300 } 301 if (really_read_only) { 302 printk(KERN_ERR "NILFS: write access " 303 "unavailable, cannot proceed.\n"); 304 err = -EROFS; 305 goto failed_unload; 306 } 307 sbi->s_super->s_flags &= ~MS_RDONLY; 308 } else if (nilfs_test_opt(sbi, NORECOVERY)) { 309 printk(KERN_ERR "NILFS: recovery cancelled because norecovery " 310 "option was specified for a read/write mount\n"); 311 err = -EINVAL; 312 goto failed_unload; 313 } 314 315 err = nilfs_salvage_orphan_logs(nilfs, sbi, &ri); 316 if (err) 317 goto failed_unload; 318 319 down_write(&nilfs->ns_sem); 320 nilfs->ns_mount_state |= NILFS_VALID_FS; /* set "clean" flag */ 321 err = nilfs_cleanup_super(sbi); 322 up_write(&nilfs->ns_sem); 323 324 if (err) { 325 printk(KERN_ERR "NILFS: failed to update super block. " 326 "recovery unfinished.\n"); 327 goto failed_unload; 328 } 329 printk(KERN_INFO "NILFS: recovery complete.\n"); 330 331 skip_recovery: 332 set_nilfs_loaded(nilfs); 333 nilfs_clear_recovery_info(&ri); 334 sbi->s_super->s_flags = s_flags; 335 return 0; 336 337 scan_error: 338 printk(KERN_ERR "NILFS: error searching super root.\n"); 339 goto failed; 340 341 failed_unload: 342 iput(nilfs->ns_cpfile); 343 iput(nilfs->ns_sufile); 344 iput(nilfs->ns_dat); 345 346 failed: 347 nilfs_clear_recovery_info(&ri); 348 sbi->s_super->s_flags = s_flags; 349 return err; 350 } 351 352 static unsigned long long nilfs_max_size(unsigned int blkbits) 353 { 354 unsigned int max_bits; 355 unsigned long long res = MAX_LFS_FILESIZE; /* page cache limit */ 356 357 max_bits = blkbits + NILFS_BMAP_KEY_BIT; /* bmap size limit */ 358 if (max_bits < 64) 359 res = min_t(unsigned long long, res, (1ULL << max_bits) - 1); 360 return res; 361 } 362 363 static int nilfs_store_disk_layout(struct the_nilfs *nilfs, 364 struct nilfs_super_block *sbp) 365 { 366 if (le32_to_cpu(sbp->s_rev_level) < NILFS_MIN_SUPP_REV) { 367 printk(KERN_ERR "NILFS: unsupported revision " 368 "(superblock rev.=%d.%d, current rev.=%d.%d). " 369 "Please check the version of mkfs.nilfs.\n", 370 le32_to_cpu(sbp->s_rev_level), 371 le16_to_cpu(sbp->s_minor_rev_level), 372 NILFS_CURRENT_REV, NILFS_MINOR_REV); 373 return -EINVAL; 374 } 375 nilfs->ns_sbsize = le16_to_cpu(sbp->s_bytes); 376 if (nilfs->ns_sbsize > BLOCK_SIZE) 377 return -EINVAL; 378 379 nilfs->ns_inode_size = le16_to_cpu(sbp->s_inode_size); 380 nilfs->ns_first_ino = le32_to_cpu(sbp->s_first_ino); 381 382 nilfs->ns_blocks_per_segment = le32_to_cpu(sbp->s_blocks_per_segment); 383 if (nilfs->ns_blocks_per_segment < NILFS_SEG_MIN_BLOCKS) { 384 printk(KERN_ERR "NILFS: too short segment.\n"); 385 return -EINVAL; 386 } 387 388 nilfs->ns_first_data_block = le64_to_cpu(sbp->s_first_data_block); 389 nilfs->ns_nsegments = le64_to_cpu(sbp->s_nsegments); 390 nilfs->ns_r_segments_percentage = 391 le32_to_cpu(sbp->s_r_segments_percentage); 392 nilfs->ns_nrsvsegs = 393 max_t(unsigned long, NILFS_MIN_NRSVSEGS, 394 DIV_ROUND_UP(nilfs->ns_nsegments * 395 nilfs->ns_r_segments_percentage, 100)); 396 nilfs->ns_crc_seed = le32_to_cpu(sbp->s_crc_seed); 397 return 0; 398 } 399 400 static int nilfs_valid_sb(struct nilfs_super_block *sbp) 401 { 402 static unsigned char sum[4]; 403 const int sumoff = offsetof(struct nilfs_super_block, s_sum); 404 size_t bytes; 405 u32 crc; 406 407 if (!sbp || le16_to_cpu(sbp->s_magic) != NILFS_SUPER_MAGIC) 408 return 0; 409 bytes = le16_to_cpu(sbp->s_bytes); 410 if (bytes > BLOCK_SIZE) 411 return 0; 412 crc = crc32_le(le32_to_cpu(sbp->s_crc_seed), (unsigned char *)sbp, 413 sumoff); 414 crc = crc32_le(crc, sum, 4); 415 crc = crc32_le(crc, (unsigned char *)sbp + sumoff + 4, 416 bytes - sumoff - 4); 417 return crc == le32_to_cpu(sbp->s_sum); 418 } 419 420 static int nilfs_sb2_bad_offset(struct nilfs_super_block *sbp, u64 offset) 421 { 422 return offset < ((le64_to_cpu(sbp->s_nsegments) * 423 le32_to_cpu(sbp->s_blocks_per_segment)) << 424 (le32_to_cpu(sbp->s_log_block_size) + 10)); 425 } 426 427 static void nilfs_release_super_block(struct the_nilfs *nilfs) 428 { 429 int i; 430 431 for (i = 0; i < 2; i++) { 432 if (nilfs->ns_sbp[i]) { 433 brelse(nilfs->ns_sbh[i]); 434 nilfs->ns_sbh[i] = NULL; 435 nilfs->ns_sbp[i] = NULL; 436 } 437 } 438 } 439 440 void nilfs_fall_back_super_block(struct the_nilfs *nilfs) 441 { 442 brelse(nilfs->ns_sbh[0]); 443 nilfs->ns_sbh[0] = nilfs->ns_sbh[1]; 444 nilfs->ns_sbp[0] = nilfs->ns_sbp[1]; 445 nilfs->ns_sbh[1] = NULL; 446 nilfs->ns_sbp[1] = NULL; 447 } 448 449 void nilfs_swap_super_block(struct the_nilfs *nilfs) 450 { 451 struct buffer_head *tsbh = nilfs->ns_sbh[0]; 452 struct nilfs_super_block *tsbp = nilfs->ns_sbp[0]; 453 454 nilfs->ns_sbh[0] = nilfs->ns_sbh[1]; 455 nilfs->ns_sbp[0] = nilfs->ns_sbp[1]; 456 nilfs->ns_sbh[1] = tsbh; 457 nilfs->ns_sbp[1] = tsbp; 458 } 459 460 static int nilfs_load_super_block(struct the_nilfs *nilfs, 461 struct super_block *sb, int blocksize, 462 struct nilfs_super_block **sbpp) 463 { 464 struct nilfs_super_block **sbp = nilfs->ns_sbp; 465 struct buffer_head **sbh = nilfs->ns_sbh; 466 u64 sb2off = NILFS_SB2_OFFSET_BYTES(nilfs->ns_bdev->bd_inode->i_size); 467 int valid[2], swp = 0; 468 469 sbp[0] = nilfs_read_super_block(sb, NILFS_SB_OFFSET_BYTES, blocksize, 470 &sbh[0]); 471 sbp[1] = nilfs_read_super_block(sb, sb2off, blocksize, &sbh[1]); 472 473 if (!sbp[0]) { 474 if (!sbp[1]) { 475 printk(KERN_ERR "NILFS: unable to read superblock\n"); 476 return -EIO; 477 } 478 printk(KERN_WARNING 479 "NILFS warning: unable to read primary superblock\n"); 480 } else if (!sbp[1]) 481 printk(KERN_WARNING 482 "NILFS warning: unable to read secondary superblock\n"); 483 484 /* 485 * Compare two super blocks and set 1 in swp if the secondary 486 * super block is valid and newer. Otherwise, set 0 in swp. 487 */ 488 valid[0] = nilfs_valid_sb(sbp[0]); 489 valid[1] = nilfs_valid_sb(sbp[1]); 490 swp = valid[1] && (!valid[0] || 491 le64_to_cpu(sbp[1]->s_last_cno) > 492 le64_to_cpu(sbp[0]->s_last_cno)); 493 494 if (valid[swp] && nilfs_sb2_bad_offset(sbp[swp], sb2off)) { 495 brelse(sbh[1]); 496 sbh[1] = NULL; 497 sbp[1] = NULL; 498 swp = 0; 499 } 500 if (!valid[swp]) { 501 nilfs_release_super_block(nilfs); 502 printk(KERN_ERR "NILFS: Can't find nilfs on dev %s.\n", 503 sb->s_id); 504 return -EINVAL; 505 } 506 507 if (!valid[!swp]) 508 printk(KERN_WARNING "NILFS warning: broken superblock. " 509 "using spare superblock.\n"); 510 if (swp) 511 nilfs_swap_super_block(nilfs); 512 513 nilfs->ns_sbwcount = 0; 514 nilfs->ns_sbwtime = le64_to_cpu(sbp[0]->s_wtime); 515 nilfs->ns_prot_seq = le64_to_cpu(sbp[valid[1] & !swp]->s_last_seq); 516 *sbpp = sbp[0]; 517 return 0; 518 } 519 520 /** 521 * init_nilfs - initialize a NILFS instance. 522 * @nilfs: the_nilfs structure 523 * @sbi: nilfs_sb_info 524 * @sb: super block 525 * @data: mount options 526 * 527 * init_nilfs() performs common initialization per block device (e.g. 528 * reading the super block, getting disk layout information, initializing 529 * shared fields in the_nilfs). 530 * 531 * Return Value: On success, 0 is returned. On error, a negative error 532 * code is returned. 533 */ 534 int init_nilfs(struct the_nilfs *nilfs, struct nilfs_sb_info *sbi, char *data) 535 { 536 struct super_block *sb = sbi->s_super; 537 struct nilfs_super_block *sbp; 538 int blocksize; 539 int err; 540 541 down_write(&nilfs->ns_sem); 542 543 blocksize = sb_min_blocksize(sb, NILFS_MIN_BLOCK_SIZE); 544 if (!blocksize) { 545 printk(KERN_ERR "NILFS: unable to set blocksize\n"); 546 err = -EINVAL; 547 goto out; 548 } 549 err = nilfs_load_super_block(nilfs, sb, blocksize, &sbp); 550 if (err) 551 goto out; 552 553 err = nilfs_store_magic_and_option(sb, sbp, data); 554 if (err) 555 goto failed_sbh; 556 557 err = nilfs_check_feature_compatibility(sb, sbp); 558 if (err) 559 goto failed_sbh; 560 561 blocksize = BLOCK_SIZE << le32_to_cpu(sbp->s_log_block_size); 562 if (blocksize < NILFS_MIN_BLOCK_SIZE || 563 blocksize > NILFS_MAX_BLOCK_SIZE) { 564 printk(KERN_ERR "NILFS: couldn't mount because of unsupported " 565 "filesystem blocksize %d\n", blocksize); 566 err = -EINVAL; 567 goto failed_sbh; 568 } 569 if (sb->s_blocksize != blocksize) { 570 int hw_blocksize = bdev_logical_block_size(sb->s_bdev); 571 572 if (blocksize < hw_blocksize) { 573 printk(KERN_ERR 574 "NILFS: blocksize %d too small for device " 575 "(sector-size = %d).\n", 576 blocksize, hw_blocksize); 577 err = -EINVAL; 578 goto failed_sbh; 579 } 580 nilfs_release_super_block(nilfs); 581 sb_set_blocksize(sb, blocksize); 582 583 err = nilfs_load_super_block(nilfs, sb, blocksize, &sbp); 584 if (err) 585 goto out; 586 /* not failed_sbh; sbh is released automatically 587 when reloading fails. */ 588 } 589 nilfs->ns_blocksize_bits = sb->s_blocksize_bits; 590 nilfs->ns_blocksize = blocksize; 591 592 err = nilfs_store_disk_layout(nilfs, sbp); 593 if (err) 594 goto failed_sbh; 595 596 sb->s_maxbytes = nilfs_max_size(sb->s_blocksize_bits); 597 598 nilfs->ns_mount_state = le16_to_cpu(sbp->s_state); 599 600 err = nilfs_store_log_cursor(nilfs, sbp); 601 if (err) 602 goto failed_sbh; 603 604 set_nilfs_init(nilfs); 605 err = 0; 606 out: 607 up_write(&nilfs->ns_sem); 608 return err; 609 610 failed_sbh: 611 nilfs_release_super_block(nilfs); 612 goto out; 613 } 614 615 int nilfs_discard_segments(struct the_nilfs *nilfs, __u64 *segnump, 616 size_t nsegs) 617 { 618 sector_t seg_start, seg_end; 619 sector_t start = 0, nblocks = 0; 620 unsigned int sects_per_block; 621 __u64 *sn; 622 int ret = 0; 623 624 sects_per_block = (1 << nilfs->ns_blocksize_bits) / 625 bdev_logical_block_size(nilfs->ns_bdev); 626 for (sn = segnump; sn < segnump + nsegs; sn++) { 627 nilfs_get_segment_range(nilfs, *sn, &seg_start, &seg_end); 628 629 if (!nblocks) { 630 start = seg_start; 631 nblocks = seg_end - seg_start + 1; 632 } else if (start + nblocks == seg_start) { 633 nblocks += seg_end - seg_start + 1; 634 } else { 635 ret = blkdev_issue_discard(nilfs->ns_bdev, 636 start * sects_per_block, 637 nblocks * sects_per_block, 638 GFP_NOFS, 0); 639 if (ret < 0) 640 return ret; 641 nblocks = 0; 642 } 643 } 644 if (nblocks) 645 ret = blkdev_issue_discard(nilfs->ns_bdev, 646 start * sects_per_block, 647 nblocks * sects_per_block, 648 GFP_NOFS, 0); 649 return ret; 650 } 651 652 int nilfs_count_free_blocks(struct the_nilfs *nilfs, sector_t *nblocks) 653 { 654 struct inode *dat = nilfs_dat_inode(nilfs); 655 unsigned long ncleansegs; 656 657 down_read(&NILFS_MDT(dat)->mi_sem); /* XXX */ 658 ncleansegs = nilfs_sufile_get_ncleansegs(nilfs->ns_sufile); 659 up_read(&NILFS_MDT(dat)->mi_sem); /* XXX */ 660 *nblocks = (sector_t)ncleansegs * nilfs->ns_blocks_per_segment; 661 return 0; 662 } 663 664 int nilfs_near_disk_full(struct the_nilfs *nilfs) 665 { 666 unsigned long ncleansegs, nincsegs; 667 668 ncleansegs = nilfs_sufile_get_ncleansegs(nilfs->ns_sufile); 669 nincsegs = atomic_read(&nilfs->ns_ndirtyblks) / 670 nilfs->ns_blocks_per_segment + 1; 671 672 return ncleansegs <= nilfs->ns_nrsvsegs + nincsegs; 673 } 674 675 struct nilfs_root *nilfs_lookup_root(struct the_nilfs *nilfs, __u64 cno) 676 { 677 struct rb_node *n; 678 struct nilfs_root *root; 679 680 spin_lock(&nilfs->ns_cptree_lock); 681 n = nilfs->ns_cptree.rb_node; 682 while (n) { 683 root = rb_entry(n, struct nilfs_root, rb_node); 684 685 if (cno < root->cno) { 686 n = n->rb_left; 687 } else if (cno > root->cno) { 688 n = n->rb_right; 689 } else { 690 atomic_inc(&root->count); 691 spin_unlock(&nilfs->ns_cptree_lock); 692 return root; 693 } 694 } 695 spin_unlock(&nilfs->ns_cptree_lock); 696 697 return NULL; 698 } 699 700 struct nilfs_root * 701 nilfs_find_or_create_root(struct the_nilfs *nilfs, __u64 cno) 702 { 703 struct rb_node **p, *parent; 704 struct nilfs_root *root, *new; 705 706 root = nilfs_lookup_root(nilfs, cno); 707 if (root) 708 return root; 709 710 new = kmalloc(sizeof(*root), GFP_KERNEL); 711 if (!new) 712 return NULL; 713 714 spin_lock(&nilfs->ns_cptree_lock); 715 716 p = &nilfs->ns_cptree.rb_node; 717 parent = NULL; 718 719 while (*p) { 720 parent = *p; 721 root = rb_entry(parent, struct nilfs_root, rb_node); 722 723 if (cno < root->cno) { 724 p = &(*p)->rb_left; 725 } else if (cno > root->cno) { 726 p = &(*p)->rb_right; 727 } else { 728 atomic_inc(&root->count); 729 spin_unlock(&nilfs->ns_cptree_lock); 730 kfree(new); 731 return root; 732 } 733 } 734 735 new->cno = cno; 736 new->ifile = NULL; 737 new->nilfs = nilfs; 738 atomic_set(&new->count, 1); 739 atomic_set(&new->inodes_count, 0); 740 atomic_set(&new->blocks_count, 0); 741 742 rb_link_node(&new->rb_node, parent, p); 743 rb_insert_color(&new->rb_node, &nilfs->ns_cptree); 744 745 spin_unlock(&nilfs->ns_cptree_lock); 746 747 return new; 748 } 749 750 void nilfs_put_root(struct nilfs_root *root) 751 { 752 if (atomic_dec_and_test(&root->count)) { 753 struct the_nilfs *nilfs = root->nilfs; 754 755 spin_lock(&nilfs->ns_cptree_lock); 756 rb_erase(&root->rb_node, &nilfs->ns_cptree); 757 spin_unlock(&nilfs->ns_cptree_lock); 758 if (root->ifile) 759 iput(root->ifile); 760 761 kfree(root); 762 } 763 } 764