Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  * the_nilfs shared structure.
0004  *
0005  * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
0006  *
0007  * Written by Ryusuke Konishi.
0008  *
0009  */
0010 
0011 #include <linux/buffer_head.h>
0012 #include <linux/slab.h>
0013 #include <linux/blkdev.h>
0014 #include <linux/backing-dev.h>
0015 #include <linux/random.h>
0016 #include <linux/crc32.h>
0017 #include "nilfs.h"
0018 #include "segment.h"
0019 #include "alloc.h"
0020 #include "cpfile.h"
0021 #include "sufile.h"
0022 #include "dat.h"
0023 #include "segbuf.h"
0024 
0025 
0026 static int nilfs_valid_sb(struct nilfs_super_block *sbp);
0027 
0028 void nilfs_set_last_segment(struct the_nilfs *nilfs,
0029                 sector_t start_blocknr, u64 seq, __u64 cno)
0030 {
0031     spin_lock(&nilfs->ns_last_segment_lock);
0032     nilfs->ns_last_pseg = start_blocknr;
0033     nilfs->ns_last_seq = seq;
0034     nilfs->ns_last_cno = cno;
0035 
0036     if (!nilfs_sb_dirty(nilfs)) {
0037         if (nilfs->ns_prev_seq == nilfs->ns_last_seq)
0038             goto stay_cursor;
0039 
0040         set_nilfs_sb_dirty(nilfs);
0041     }
0042     nilfs->ns_prev_seq = nilfs->ns_last_seq;
0043 
0044  stay_cursor:
0045     spin_unlock(&nilfs->ns_last_segment_lock);
0046 }
0047 
0048 /**
0049  * alloc_nilfs - allocate a nilfs object
0050  * @sb: super block instance
0051  *
0052  * Return Value: On success, pointer to the_nilfs is returned.
0053  * On error, NULL is returned.
0054  */
0055 struct the_nilfs *alloc_nilfs(struct super_block *sb)
0056 {
0057     struct the_nilfs *nilfs;
0058 
0059     nilfs = kzalloc(sizeof(*nilfs), GFP_KERNEL);
0060     if (!nilfs)
0061         return NULL;
0062 
0063     nilfs->ns_sb = sb;
0064     nilfs->ns_bdev = sb->s_bdev;
0065     atomic_set(&nilfs->ns_ndirtyblks, 0);
0066     init_rwsem(&nilfs->ns_sem);
0067     mutex_init(&nilfs->ns_snapshot_mount_mutex);
0068     INIT_LIST_HEAD(&nilfs->ns_dirty_files);
0069     INIT_LIST_HEAD(&nilfs->ns_gc_inodes);
0070     spin_lock_init(&nilfs->ns_inode_lock);
0071     spin_lock_init(&nilfs->ns_next_gen_lock);
0072     spin_lock_init(&nilfs->ns_last_segment_lock);
0073     nilfs->ns_cptree = RB_ROOT;
0074     spin_lock_init(&nilfs->ns_cptree_lock);
0075     init_rwsem(&nilfs->ns_segctor_sem);
0076     nilfs->ns_sb_update_freq = NILFS_SB_FREQ;
0077 
0078     return nilfs;
0079 }
0080 
0081 /**
0082  * destroy_nilfs - destroy nilfs object
0083  * @nilfs: nilfs object to be released
0084  */
0085 void destroy_nilfs(struct the_nilfs *nilfs)
0086 {
0087     might_sleep();
0088     if (nilfs_init(nilfs)) {
0089         nilfs_sysfs_delete_device_group(nilfs);
0090         brelse(nilfs->ns_sbh[0]);
0091         brelse(nilfs->ns_sbh[1]);
0092     }
0093     kfree(nilfs);
0094 }
0095 
0096 static int nilfs_load_super_root(struct the_nilfs *nilfs,
0097                  struct super_block *sb, sector_t sr_block)
0098 {
0099     struct buffer_head *bh_sr;
0100     struct nilfs_super_root *raw_sr;
0101     struct nilfs_super_block **sbp = nilfs->ns_sbp;
0102     struct nilfs_inode *rawi;
0103     unsigned int dat_entry_size, segment_usage_size, checkpoint_size;
0104     unsigned int inode_size;
0105     int err;
0106 
0107     err = nilfs_read_super_root_block(nilfs, sr_block, &bh_sr, 1);
0108     if (unlikely(err))
0109         return err;
0110 
0111     down_read(&nilfs->ns_sem);
0112     dat_entry_size = le16_to_cpu(sbp[0]->s_dat_entry_size);
0113     checkpoint_size = le16_to_cpu(sbp[0]->s_checkpoint_size);
0114     segment_usage_size = le16_to_cpu(sbp[0]->s_segment_usage_size);
0115     up_read(&nilfs->ns_sem);
0116 
0117     inode_size = nilfs->ns_inode_size;
0118 
0119     rawi = (void *)bh_sr->b_data + NILFS_SR_DAT_OFFSET(inode_size);
0120     err = nilfs_dat_read(sb, dat_entry_size, rawi, &nilfs->ns_dat);
0121     if (err)
0122         goto failed;
0123 
0124     rawi = (void *)bh_sr->b_data + NILFS_SR_CPFILE_OFFSET(inode_size);
0125     err = nilfs_cpfile_read(sb, checkpoint_size, rawi, &nilfs->ns_cpfile);
0126     if (err)
0127         goto failed_dat;
0128 
0129     rawi = (void *)bh_sr->b_data + NILFS_SR_SUFILE_OFFSET(inode_size);
0130     err = nilfs_sufile_read(sb, segment_usage_size, rawi,
0131                 &nilfs->ns_sufile);
0132     if (err)
0133         goto failed_cpfile;
0134 
0135     raw_sr = (struct nilfs_super_root *)bh_sr->b_data;
0136     nilfs->ns_nongc_ctime = le64_to_cpu(raw_sr->sr_nongc_ctime);
0137 
0138  failed:
0139     brelse(bh_sr);
0140     return err;
0141 
0142  failed_cpfile:
0143     iput(nilfs->ns_cpfile);
0144 
0145  failed_dat:
0146     iput(nilfs->ns_dat);
0147     goto failed;
0148 }
0149 
0150 static void nilfs_init_recovery_info(struct nilfs_recovery_info *ri)
0151 {
0152     memset(ri, 0, sizeof(*ri));
0153     INIT_LIST_HEAD(&ri->ri_used_segments);
0154 }
0155 
0156 static void nilfs_clear_recovery_info(struct nilfs_recovery_info *ri)
0157 {
0158     nilfs_dispose_segment_list(&ri->ri_used_segments);
0159 }
0160 
0161 /**
0162  * nilfs_store_log_cursor - load log cursor from a super block
0163  * @nilfs: nilfs object
0164  * @sbp: buffer storing super block to be read
0165  *
0166  * nilfs_store_log_cursor() reads the last position of the log
0167  * containing a super root from a given super block, and initializes
0168  * relevant information on the nilfs object preparatory for log
0169  * scanning and recovery.
0170  */
0171 static int nilfs_store_log_cursor(struct the_nilfs *nilfs,
0172                   struct nilfs_super_block *sbp)
0173 {
0174     int ret = 0;
0175 
0176     nilfs->ns_last_pseg = le64_to_cpu(sbp->s_last_pseg);
0177     nilfs->ns_last_cno = le64_to_cpu(sbp->s_last_cno);
0178     nilfs->ns_last_seq = le64_to_cpu(sbp->s_last_seq);
0179 
0180     nilfs->ns_prev_seq = nilfs->ns_last_seq;
0181     nilfs->ns_seg_seq = nilfs->ns_last_seq;
0182     nilfs->ns_segnum =
0183         nilfs_get_segnum_of_block(nilfs, nilfs->ns_last_pseg);
0184     nilfs->ns_cno = nilfs->ns_last_cno + 1;
0185     if (nilfs->ns_segnum >= nilfs->ns_nsegments) {
0186         nilfs_err(nilfs->ns_sb,
0187               "pointed segment number is out of range: segnum=%llu, nsegments=%lu",
0188               (unsigned long long)nilfs->ns_segnum,
0189               nilfs->ns_nsegments);
0190         ret = -EINVAL;
0191     }
0192     return ret;
0193 }
0194 
0195 /**
0196  * load_nilfs - load and recover the nilfs
0197  * @nilfs: the_nilfs structure to be released
0198  * @sb: super block instance used to recover past segment
0199  *
0200  * load_nilfs() searches and load the latest super root,
0201  * attaches the last segment, and does recovery if needed.
0202  * The caller must call this exclusively for simultaneous mounts.
0203  */
0204 int load_nilfs(struct the_nilfs *nilfs, struct super_block *sb)
0205 {
0206     struct nilfs_recovery_info ri;
0207     unsigned int s_flags = sb->s_flags;
0208     int really_read_only = bdev_read_only(nilfs->ns_bdev);
0209     int valid_fs = nilfs_valid_fs(nilfs);
0210     int err;
0211 
0212     if (!valid_fs) {
0213         nilfs_warn(sb, "mounting unchecked fs");
0214         if (s_flags & SB_RDONLY) {
0215             nilfs_info(sb,
0216                    "recovery required for readonly filesystem");
0217             nilfs_info(sb,
0218                    "write access will be enabled during recovery");
0219         }
0220     }
0221 
0222     nilfs_init_recovery_info(&ri);
0223 
0224     err = nilfs_search_super_root(nilfs, &ri);
0225     if (unlikely(err)) {
0226         struct nilfs_super_block **sbp = nilfs->ns_sbp;
0227         int blocksize;
0228 
0229         if (err != -EINVAL)
0230             goto scan_error;
0231 
0232         if (!nilfs_valid_sb(sbp[1])) {
0233             nilfs_warn(sb,
0234                    "unable to fall back to spare super block");
0235             goto scan_error;
0236         }
0237         nilfs_info(sb, "trying rollback from an earlier position");
0238 
0239         /*
0240          * restore super block with its spare and reconfigure
0241          * relevant states of the nilfs object.
0242          */
0243         memcpy(sbp[0], sbp[1], nilfs->ns_sbsize);
0244         nilfs->ns_crc_seed = le32_to_cpu(sbp[0]->s_crc_seed);
0245         nilfs->ns_sbwtime = le64_to_cpu(sbp[0]->s_wtime);
0246 
0247         /* verify consistency between two super blocks */
0248         blocksize = BLOCK_SIZE << le32_to_cpu(sbp[0]->s_log_block_size);
0249         if (blocksize != nilfs->ns_blocksize) {
0250             nilfs_warn(sb,
0251                    "blocksize differs between two super blocks (%d != %d)",
0252                    blocksize, nilfs->ns_blocksize);
0253             goto scan_error;
0254         }
0255 
0256         err = nilfs_store_log_cursor(nilfs, sbp[0]);
0257         if (err)
0258             goto scan_error;
0259 
0260         /* drop clean flag to allow roll-forward and recovery */
0261         nilfs->ns_mount_state &= ~NILFS_VALID_FS;
0262         valid_fs = 0;
0263 
0264         err = nilfs_search_super_root(nilfs, &ri);
0265         if (err)
0266             goto scan_error;
0267     }
0268 
0269     err = nilfs_load_super_root(nilfs, sb, ri.ri_super_root);
0270     if (unlikely(err)) {
0271         nilfs_err(sb, "error %d while loading super root", err);
0272         goto failed;
0273     }
0274 
0275     if (valid_fs)
0276         goto skip_recovery;
0277 
0278     if (s_flags & SB_RDONLY) {
0279         __u64 features;
0280 
0281         if (nilfs_test_opt(nilfs, NORECOVERY)) {
0282             nilfs_info(sb,
0283                    "norecovery option specified, skipping roll-forward recovery");
0284             goto skip_recovery;
0285         }
0286         features = le64_to_cpu(nilfs->ns_sbp[0]->s_feature_compat_ro) &
0287             ~NILFS_FEATURE_COMPAT_RO_SUPP;
0288         if (features) {
0289             nilfs_err(sb,
0290                   "couldn't proceed with recovery because of unsupported optional features (%llx)",
0291                   (unsigned long long)features);
0292             err = -EROFS;
0293             goto failed_unload;
0294         }
0295         if (really_read_only) {
0296             nilfs_err(sb,
0297                   "write access unavailable, cannot proceed");
0298             err = -EROFS;
0299             goto failed_unload;
0300         }
0301         sb->s_flags &= ~SB_RDONLY;
0302     } else if (nilfs_test_opt(nilfs, NORECOVERY)) {
0303         nilfs_err(sb,
0304               "recovery cancelled because norecovery option was specified for a read/write mount");
0305         err = -EINVAL;
0306         goto failed_unload;
0307     }
0308 
0309     err = nilfs_salvage_orphan_logs(nilfs, sb, &ri);
0310     if (err)
0311         goto failed_unload;
0312 
0313     down_write(&nilfs->ns_sem);
0314     nilfs->ns_mount_state |= NILFS_VALID_FS; /* set "clean" flag */
0315     err = nilfs_cleanup_super(sb);
0316     up_write(&nilfs->ns_sem);
0317 
0318     if (err) {
0319         nilfs_err(sb,
0320               "error %d updating super block. recovery unfinished.",
0321               err);
0322         goto failed_unload;
0323     }
0324     nilfs_info(sb, "recovery complete");
0325 
0326  skip_recovery:
0327     nilfs_clear_recovery_info(&ri);
0328     sb->s_flags = s_flags;
0329     return 0;
0330 
0331  scan_error:
0332     nilfs_err(sb, "error %d while searching super root", err);
0333     goto failed;
0334 
0335  failed_unload:
0336     iput(nilfs->ns_cpfile);
0337     iput(nilfs->ns_sufile);
0338     iput(nilfs->ns_dat);
0339 
0340  failed:
0341     nilfs_clear_recovery_info(&ri);
0342     sb->s_flags = s_flags;
0343     return err;
0344 }
0345 
0346 static unsigned long long nilfs_max_size(unsigned int blkbits)
0347 {
0348     unsigned int max_bits;
0349     unsigned long long res = MAX_LFS_FILESIZE; /* page cache limit */
0350 
0351     max_bits = blkbits + NILFS_BMAP_KEY_BIT; /* bmap size limit */
0352     if (max_bits < 64)
0353         res = min_t(unsigned long long, res, (1ULL << max_bits) - 1);
0354     return res;
0355 }
0356 
0357 /**
0358  * nilfs_nrsvsegs - calculate the number of reserved segments
0359  * @nilfs: nilfs object
0360  * @nsegs: total number of segments
0361  */
0362 unsigned long nilfs_nrsvsegs(struct the_nilfs *nilfs, unsigned long nsegs)
0363 {
0364     return max_t(unsigned long, NILFS_MIN_NRSVSEGS,
0365              DIV_ROUND_UP(nsegs * nilfs->ns_r_segments_percentage,
0366                   100));
0367 }
0368 
0369 void nilfs_set_nsegments(struct the_nilfs *nilfs, unsigned long nsegs)
0370 {
0371     nilfs->ns_nsegments = nsegs;
0372     nilfs->ns_nrsvsegs = nilfs_nrsvsegs(nilfs, nsegs);
0373 }
0374 
0375 static int nilfs_store_disk_layout(struct the_nilfs *nilfs,
0376                    struct nilfs_super_block *sbp)
0377 {
0378     if (le32_to_cpu(sbp->s_rev_level) < NILFS_MIN_SUPP_REV) {
0379         nilfs_err(nilfs->ns_sb,
0380               "unsupported revision (superblock rev.=%d.%d, current rev.=%d.%d). Please check the version of mkfs.nilfs(2).",
0381               le32_to_cpu(sbp->s_rev_level),
0382               le16_to_cpu(sbp->s_minor_rev_level),
0383               NILFS_CURRENT_REV, NILFS_MINOR_REV);
0384         return -EINVAL;
0385     }
0386     nilfs->ns_sbsize = le16_to_cpu(sbp->s_bytes);
0387     if (nilfs->ns_sbsize > BLOCK_SIZE)
0388         return -EINVAL;
0389 
0390     nilfs->ns_inode_size = le16_to_cpu(sbp->s_inode_size);
0391     if (nilfs->ns_inode_size > nilfs->ns_blocksize) {
0392         nilfs_err(nilfs->ns_sb, "too large inode size: %d bytes",
0393               nilfs->ns_inode_size);
0394         return -EINVAL;
0395     } else if (nilfs->ns_inode_size < NILFS_MIN_INODE_SIZE) {
0396         nilfs_err(nilfs->ns_sb, "too small inode size: %d bytes",
0397               nilfs->ns_inode_size);
0398         return -EINVAL;
0399     }
0400 
0401     nilfs->ns_first_ino = le32_to_cpu(sbp->s_first_ino);
0402 
0403     nilfs->ns_blocks_per_segment = le32_to_cpu(sbp->s_blocks_per_segment);
0404     if (nilfs->ns_blocks_per_segment < NILFS_SEG_MIN_BLOCKS) {
0405         nilfs_err(nilfs->ns_sb, "too short segment: %lu blocks",
0406               nilfs->ns_blocks_per_segment);
0407         return -EINVAL;
0408     }
0409 
0410     nilfs->ns_first_data_block = le64_to_cpu(sbp->s_first_data_block);
0411     nilfs->ns_r_segments_percentage =
0412         le32_to_cpu(sbp->s_r_segments_percentage);
0413     if (nilfs->ns_r_segments_percentage < 1 ||
0414         nilfs->ns_r_segments_percentage > 99) {
0415         nilfs_err(nilfs->ns_sb,
0416               "invalid reserved segments percentage: %lu",
0417               nilfs->ns_r_segments_percentage);
0418         return -EINVAL;
0419     }
0420 
0421     nilfs_set_nsegments(nilfs, le64_to_cpu(sbp->s_nsegments));
0422     nilfs->ns_crc_seed = le32_to_cpu(sbp->s_crc_seed);
0423     return 0;
0424 }
0425 
0426 static int nilfs_valid_sb(struct nilfs_super_block *sbp)
0427 {
0428     static unsigned char sum[4];
0429     const int sumoff = offsetof(struct nilfs_super_block, s_sum);
0430     size_t bytes;
0431     u32 crc;
0432 
0433     if (!sbp || le16_to_cpu(sbp->s_magic) != NILFS_SUPER_MAGIC)
0434         return 0;
0435     bytes = le16_to_cpu(sbp->s_bytes);
0436     if (bytes < sumoff + 4 || bytes > BLOCK_SIZE)
0437         return 0;
0438     crc = crc32_le(le32_to_cpu(sbp->s_crc_seed), (unsigned char *)sbp,
0439                sumoff);
0440     crc = crc32_le(crc, sum, 4);
0441     crc = crc32_le(crc, (unsigned char *)sbp + sumoff + 4,
0442                bytes - sumoff - 4);
0443     return crc == le32_to_cpu(sbp->s_sum);
0444 }
0445 
0446 static int nilfs_sb2_bad_offset(struct nilfs_super_block *sbp, u64 offset)
0447 {
0448     return offset < ((le64_to_cpu(sbp->s_nsegments) *
0449               le32_to_cpu(sbp->s_blocks_per_segment)) <<
0450              (le32_to_cpu(sbp->s_log_block_size) + 10));
0451 }
0452 
0453 static void nilfs_release_super_block(struct the_nilfs *nilfs)
0454 {
0455     int i;
0456 
0457     for (i = 0; i < 2; i++) {
0458         if (nilfs->ns_sbp[i]) {
0459             brelse(nilfs->ns_sbh[i]);
0460             nilfs->ns_sbh[i] = NULL;
0461             nilfs->ns_sbp[i] = NULL;
0462         }
0463     }
0464 }
0465 
0466 void nilfs_fall_back_super_block(struct the_nilfs *nilfs)
0467 {
0468     brelse(nilfs->ns_sbh[0]);
0469     nilfs->ns_sbh[0] = nilfs->ns_sbh[1];
0470     nilfs->ns_sbp[0] = nilfs->ns_sbp[1];
0471     nilfs->ns_sbh[1] = NULL;
0472     nilfs->ns_sbp[1] = NULL;
0473 }
0474 
0475 void nilfs_swap_super_block(struct the_nilfs *nilfs)
0476 {
0477     struct buffer_head *tsbh = nilfs->ns_sbh[0];
0478     struct nilfs_super_block *tsbp = nilfs->ns_sbp[0];
0479 
0480     nilfs->ns_sbh[0] = nilfs->ns_sbh[1];
0481     nilfs->ns_sbp[0] = nilfs->ns_sbp[1];
0482     nilfs->ns_sbh[1] = tsbh;
0483     nilfs->ns_sbp[1] = tsbp;
0484 }
0485 
0486 static int nilfs_load_super_block(struct the_nilfs *nilfs,
0487                   struct super_block *sb, int blocksize,
0488                   struct nilfs_super_block **sbpp)
0489 {
0490     struct nilfs_super_block **sbp = nilfs->ns_sbp;
0491     struct buffer_head **sbh = nilfs->ns_sbh;
0492     u64 sb2off = NILFS_SB2_OFFSET_BYTES(bdev_nr_bytes(nilfs->ns_bdev));
0493     int valid[2], swp = 0;
0494 
0495     sbp[0] = nilfs_read_super_block(sb, NILFS_SB_OFFSET_BYTES, blocksize,
0496                     &sbh[0]);
0497     sbp[1] = nilfs_read_super_block(sb, sb2off, blocksize, &sbh[1]);
0498 
0499     if (!sbp[0]) {
0500         if (!sbp[1]) {
0501             nilfs_err(sb, "unable to read superblock");
0502             return -EIO;
0503         }
0504         nilfs_warn(sb,
0505                "unable to read primary superblock (blocksize = %d)",
0506                blocksize);
0507     } else if (!sbp[1]) {
0508         nilfs_warn(sb,
0509                "unable to read secondary superblock (blocksize = %d)",
0510                blocksize);
0511     }
0512 
0513     /*
0514      * Compare two super blocks and set 1 in swp if the secondary
0515      * super block is valid and newer.  Otherwise, set 0 in swp.
0516      */
0517     valid[0] = nilfs_valid_sb(sbp[0]);
0518     valid[1] = nilfs_valid_sb(sbp[1]);
0519     swp = valid[1] && (!valid[0] ||
0520                le64_to_cpu(sbp[1]->s_last_cno) >
0521                le64_to_cpu(sbp[0]->s_last_cno));
0522 
0523     if (valid[swp] && nilfs_sb2_bad_offset(sbp[swp], sb2off)) {
0524         brelse(sbh[1]);
0525         sbh[1] = NULL;
0526         sbp[1] = NULL;
0527         valid[1] = 0;
0528         swp = 0;
0529     }
0530     if (!valid[swp]) {
0531         nilfs_release_super_block(nilfs);
0532         nilfs_err(sb, "couldn't find nilfs on the device");
0533         return -EINVAL;
0534     }
0535 
0536     if (!valid[!swp])
0537         nilfs_warn(sb,
0538                "broken superblock, retrying with spare superblock (blocksize = %d)",
0539                blocksize);
0540     if (swp)
0541         nilfs_swap_super_block(nilfs);
0542 
0543     nilfs->ns_sbwcount = 0;
0544     nilfs->ns_sbwtime = le64_to_cpu(sbp[0]->s_wtime);
0545     nilfs->ns_prot_seq = le64_to_cpu(sbp[valid[1] & !swp]->s_last_seq);
0546     *sbpp = sbp[0];
0547     return 0;
0548 }
0549 
0550 /**
0551  * init_nilfs - initialize a NILFS instance.
0552  * @nilfs: the_nilfs structure
0553  * @sb: super block
0554  * @data: mount options
0555  *
0556  * init_nilfs() performs common initialization per block device (e.g.
0557  * reading the super block, getting disk layout information, initializing
0558  * shared fields in the_nilfs).
0559  *
0560  * Return Value: On success, 0 is returned. On error, a negative error
0561  * code is returned.
0562  */
0563 int init_nilfs(struct the_nilfs *nilfs, struct super_block *sb, char *data)
0564 {
0565     struct nilfs_super_block *sbp;
0566     int blocksize;
0567     int err;
0568 
0569     down_write(&nilfs->ns_sem);
0570 
0571     blocksize = sb_min_blocksize(sb, NILFS_MIN_BLOCK_SIZE);
0572     if (!blocksize) {
0573         nilfs_err(sb, "unable to set blocksize");
0574         err = -EINVAL;
0575         goto out;
0576     }
0577     err = nilfs_load_super_block(nilfs, sb, blocksize, &sbp);
0578     if (err)
0579         goto out;
0580 
0581     err = nilfs_store_magic_and_option(sb, sbp, data);
0582     if (err)
0583         goto failed_sbh;
0584 
0585     err = nilfs_check_feature_compatibility(sb, sbp);
0586     if (err)
0587         goto failed_sbh;
0588 
0589     blocksize = BLOCK_SIZE << le32_to_cpu(sbp->s_log_block_size);
0590     if (blocksize < NILFS_MIN_BLOCK_SIZE ||
0591         blocksize > NILFS_MAX_BLOCK_SIZE) {
0592         nilfs_err(sb,
0593               "couldn't mount because of unsupported filesystem blocksize %d",
0594               blocksize);
0595         err = -EINVAL;
0596         goto failed_sbh;
0597     }
0598     if (sb->s_blocksize != blocksize) {
0599         int hw_blocksize = bdev_logical_block_size(sb->s_bdev);
0600 
0601         if (blocksize < hw_blocksize) {
0602             nilfs_err(sb,
0603                   "blocksize %d too small for device (sector-size = %d)",
0604                   blocksize, hw_blocksize);
0605             err = -EINVAL;
0606             goto failed_sbh;
0607         }
0608         nilfs_release_super_block(nilfs);
0609         sb_set_blocksize(sb, blocksize);
0610 
0611         err = nilfs_load_super_block(nilfs, sb, blocksize, &sbp);
0612         if (err)
0613             goto out;
0614             /*
0615              * Not to failed_sbh; sbh is released automatically
0616              * when reloading fails.
0617              */
0618     }
0619     nilfs->ns_blocksize_bits = sb->s_blocksize_bits;
0620     nilfs->ns_blocksize = blocksize;
0621 
0622     get_random_bytes(&nilfs->ns_next_generation,
0623              sizeof(nilfs->ns_next_generation));
0624 
0625     err = nilfs_store_disk_layout(nilfs, sbp);
0626     if (err)
0627         goto failed_sbh;
0628 
0629     sb->s_maxbytes = nilfs_max_size(sb->s_blocksize_bits);
0630 
0631     nilfs->ns_mount_state = le16_to_cpu(sbp->s_state);
0632 
0633     err = nilfs_store_log_cursor(nilfs, sbp);
0634     if (err)
0635         goto failed_sbh;
0636 
0637     err = nilfs_sysfs_create_device_group(sb);
0638     if (err)
0639         goto failed_sbh;
0640 
0641     set_nilfs_init(nilfs);
0642     err = 0;
0643  out:
0644     up_write(&nilfs->ns_sem);
0645     return err;
0646 
0647  failed_sbh:
0648     nilfs_release_super_block(nilfs);
0649     goto out;
0650 }
0651 
0652 int nilfs_discard_segments(struct the_nilfs *nilfs, __u64 *segnump,
0653                 size_t nsegs)
0654 {
0655     sector_t seg_start, seg_end;
0656     sector_t start = 0, nblocks = 0;
0657     unsigned int sects_per_block;
0658     __u64 *sn;
0659     int ret = 0;
0660 
0661     sects_per_block = (1 << nilfs->ns_blocksize_bits) /
0662         bdev_logical_block_size(nilfs->ns_bdev);
0663     for (sn = segnump; sn < segnump + nsegs; sn++) {
0664         nilfs_get_segment_range(nilfs, *sn, &seg_start, &seg_end);
0665 
0666         if (!nblocks) {
0667             start = seg_start;
0668             nblocks = seg_end - seg_start + 1;
0669         } else if (start + nblocks == seg_start) {
0670             nblocks += seg_end - seg_start + 1;
0671         } else {
0672             ret = blkdev_issue_discard(nilfs->ns_bdev,
0673                            start * sects_per_block,
0674                            nblocks * sects_per_block,
0675                            GFP_NOFS);
0676             if (ret < 0)
0677                 return ret;
0678             nblocks = 0;
0679         }
0680     }
0681     if (nblocks)
0682         ret = blkdev_issue_discard(nilfs->ns_bdev,
0683                        start * sects_per_block,
0684                        nblocks * sects_per_block,
0685                        GFP_NOFS);
0686     return ret;
0687 }
0688 
0689 int nilfs_count_free_blocks(struct the_nilfs *nilfs, sector_t *nblocks)
0690 {
0691     unsigned long ncleansegs;
0692 
0693     down_read(&NILFS_MDT(nilfs->ns_dat)->mi_sem);
0694     ncleansegs = nilfs_sufile_get_ncleansegs(nilfs->ns_sufile);
0695     up_read(&NILFS_MDT(nilfs->ns_dat)->mi_sem);
0696     *nblocks = (sector_t)ncleansegs * nilfs->ns_blocks_per_segment;
0697     return 0;
0698 }
0699 
0700 int nilfs_near_disk_full(struct the_nilfs *nilfs)
0701 {
0702     unsigned long ncleansegs, nincsegs;
0703 
0704     ncleansegs = nilfs_sufile_get_ncleansegs(nilfs->ns_sufile);
0705     nincsegs = atomic_read(&nilfs->ns_ndirtyblks) /
0706         nilfs->ns_blocks_per_segment + 1;
0707 
0708     return ncleansegs <= nilfs->ns_nrsvsegs + nincsegs;
0709 }
0710 
0711 struct nilfs_root *nilfs_lookup_root(struct the_nilfs *nilfs, __u64 cno)
0712 {
0713     struct rb_node *n;
0714     struct nilfs_root *root;
0715 
0716     spin_lock(&nilfs->ns_cptree_lock);
0717     n = nilfs->ns_cptree.rb_node;
0718     while (n) {
0719         root = rb_entry(n, struct nilfs_root, rb_node);
0720 
0721         if (cno < root->cno) {
0722             n = n->rb_left;
0723         } else if (cno > root->cno) {
0724             n = n->rb_right;
0725         } else {
0726             refcount_inc(&root->count);
0727             spin_unlock(&nilfs->ns_cptree_lock);
0728             return root;
0729         }
0730     }
0731     spin_unlock(&nilfs->ns_cptree_lock);
0732 
0733     return NULL;
0734 }
0735 
0736 struct nilfs_root *
0737 nilfs_find_or_create_root(struct the_nilfs *nilfs, __u64 cno)
0738 {
0739     struct rb_node **p, *parent;
0740     struct nilfs_root *root, *new;
0741     int err;
0742 
0743     root = nilfs_lookup_root(nilfs, cno);
0744     if (root)
0745         return root;
0746 
0747     new = kzalloc(sizeof(*root), GFP_KERNEL);
0748     if (!new)
0749         return NULL;
0750 
0751     spin_lock(&nilfs->ns_cptree_lock);
0752 
0753     p = &nilfs->ns_cptree.rb_node;
0754     parent = NULL;
0755 
0756     while (*p) {
0757         parent = *p;
0758         root = rb_entry(parent, struct nilfs_root, rb_node);
0759 
0760         if (cno < root->cno) {
0761             p = &(*p)->rb_left;
0762         } else if (cno > root->cno) {
0763             p = &(*p)->rb_right;
0764         } else {
0765             refcount_inc(&root->count);
0766             spin_unlock(&nilfs->ns_cptree_lock);
0767             kfree(new);
0768             return root;
0769         }
0770     }
0771 
0772     new->cno = cno;
0773     new->ifile = NULL;
0774     new->nilfs = nilfs;
0775     refcount_set(&new->count, 1);
0776     atomic64_set(&new->inodes_count, 0);
0777     atomic64_set(&new->blocks_count, 0);
0778 
0779     rb_link_node(&new->rb_node, parent, p);
0780     rb_insert_color(&new->rb_node, &nilfs->ns_cptree);
0781 
0782     spin_unlock(&nilfs->ns_cptree_lock);
0783 
0784     err = nilfs_sysfs_create_snapshot_group(new);
0785     if (err) {
0786         kfree(new);
0787         new = NULL;
0788     }
0789 
0790     return new;
0791 }
0792 
0793 void nilfs_put_root(struct nilfs_root *root)
0794 {
0795     struct the_nilfs *nilfs = root->nilfs;
0796 
0797     if (refcount_dec_and_lock(&root->count, &nilfs->ns_cptree_lock)) {
0798         rb_erase(&root->rb_node, &nilfs->ns_cptree);
0799         spin_unlock(&nilfs->ns_cptree_lock);
0800 
0801         nilfs_sysfs_delete_snapshot_group(root);
0802         iput(root->ifile);
0803 
0804         kfree(root);
0805     }
0806 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!