自学教程：C++ EXT4_SB函数代码示例

static ssize_text4_file_write(struct kiocb *iocb, const struct iovec *iov,		unsigned long nr_segs, loff_t pos){	struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;	int unaligned_aio = 0;	int ret;	/*	 * If we have encountered a bitmap-format file, the size limit	 * is smaller than s_maxbytes, which is for extent-mapped files.	 */	if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {		struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);		size_t length = iov_length(iov, nr_segs);		if ((pos > sbi->s_bitmap_maxbytes ||		    (pos == sbi->s_bitmap_maxbytes && length > 0)))			return -EFBIG;		if (pos + length > sbi->s_bitmap_maxbytes) {			nr_segs = iov_shorten((struct iovec *)iov, nr_segs,					      sbi->s_bitmap_maxbytes - pos);		}	} else if (unlikely((iocb->ki_filp->f_flags & O_DIRECT) &&		   !is_sync_kiocb(iocb))) {		unaligned_aio = ext4_unaligned_aio(inode, iov, nr_segs, pos);	}	/* Unaligned direct AIO must be serialized; see comment above */	if (unaligned_aio) {		static unsigned long unaligned_warn_time;		/* Warn about this once per day */		if (printk_timed_ratelimit(&unaligned_warn_time, 60*60*24*HZ))			ext4_msg(inode->i_sb, KERN_WARNING,				 "Unaligned AIO/DIO on inode %ld by %s; "				 "performance will be poor.",				 inode->i_ino, current->comm);		mutex_lock(ext4_aio_mutex(inode));		ext4_aiodio_wait(inode);	}	ret = generic_file_aio_write(iocb, iov, nr_segs, pos);	if (unaligned_aio)		mutex_unlock(ext4_aio_mutex(inode));	return ret;}

static int ext4_file_open(struct inode * inode, struct file * filp){	struct super_block *sb = inode->i_sb;	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);	struct ext4_inode_info *ei = EXT4_I(inode);	struct vfsmount *mnt = filp->f_path.mnt;	struct path path;	char buf[64], *cp;	if (unlikely(!(sbi->s_mount_flags & EXT4_MF_MNTDIR_SAMPLED) &&		     !(sb->s_flags & MS_RDONLY))) {		sbi->s_mount_flags |= EXT4_MF_MNTDIR_SAMPLED;		/*		 * Sample where the filesystem has been mounted and		 * store it in the superblock for sysadmin convenience		 * when trying to sort through large numbers of block		 * devices or filesystem images.		 */		memset(buf, 0, sizeof(buf));		path.mnt = mnt;		path.dentry = mnt->mnt_root;		cp = d_path(&path, buf, sizeof(buf));		if (!IS_ERR(cp)) {			strlcpy(sbi->s_es->s_last_mounted, cp,				sizeof(sbi->s_es->s_last_mounted));			ext4_mark_super_dirty(sb);		}	}	/*	 * Set up the jbd2_inode if we are opening the inode for	 * writing and the journal is present	 */	if (sbi->s_journal && !ei->jinode && (filp->f_mode & FMODE_WRITE)) {		struct jbd2_inode *jinode = jbd2_alloc_inode(GFP_KERNEL);		spin_lock(&inode->i_lock);		if (!ei->jinode) {			if (!jinode) {				spin_unlock(&inode->i_lock);				return -ENOMEM;			}			ei->jinode = jinode;			jbd2_journal_init_jbd_inode(ei->jinode, inode);			jinode = NULL;		}		spin_unlock(&inode->i_lock);		if (unlikely(jinode != NULL))			jbd2_free_inode(jinode);	}	return dquot_file_open(inode, filp);}

/** * ext4_count_free_blocks() -- count filesystem free blocks * @sb:		superblock * * Adds up the number of free blocks from each block group. */ext4_fsblk_t ext4_count_free_blocks(struct super_block *sb){	ext4_fsblk_t desc_count;	struct ext4_group_desc *gdp;	ext4_group_t i;	ext4_group_t ngroups = ext4_get_groups_count(sb);#ifdef EXT4FS_DEBUG	struct ext4_super_block *es;	ext4_fsblk_t bitmap_count;	unsigned int x;	struct buffer_head *bitmap_bh = NULL;	es = EXT4_SB(sb)->s_es;	desc_count = 0;	bitmap_count = 0;	gdp = NULL;	for (i = 0; i < ngroups; i++) {		gdp = ext4_get_group_desc(sb, i, NULL);		if (!gdp)			continue;		desc_count += ext4_free_blks_count(sb, gdp);		brelse(bitmap_bh);		bitmap_bh = ext4_read_block_bitmap(sb, i);		if (bitmap_bh == NULL)			continue;		x = ext4_count_free(bitmap_bh->b_data,				    EXT4_BLOCKS_PER_GROUP(sb) / 8);		printk(KERN_DEBUG "group %u: stored = %d, counted = %u/n",			i, ext4_free_blks_count(sb, gdp), x);		bitmap_count += x;	}	brelse(bitmap_bh);	printk(KERN_DEBUG "ext4_count_free_blocks: stored = %llu"		", computed = %llu, %llu/n", ext4_free_blocks_count(es),	       desc_count, bitmap_count);	return bitmap_count;#else	desc_count = 0;	for (i = 0; i < ngroups; i++) {		gdp = ext4_get_group_desc(sb, i, NULL);		if (!gdp)			continue;		desc_count += ext4_free_blks_count(sb, gdp);	}	return desc_count;#endif}

int __ext4bf_handle_dirty_metadata(const char *where, unsigned int line,				 handle_t *handle, struct inode *inode,				 struct buffer_head *bh){	int err = 0;	if (ext4bf_handle_valid(handle)) {#ifdef DCHECKSUM        /* ext4bf: handle cases where it is a data block. */        if (bh && bh->b_blocktype == B_BLOCKTYPE_DATA) {#endif#ifdef PARTJ            if (!buffer_new(bh))                err = jbdbf_journal_dirty_metadata(handle, bh);            else#endif#ifdef DCHECKSUM                jbdbf_journal_dirty_data(handle, bh);        } else#endif            err = jbdbf_journal_dirty_metadata(handle, bh);        if (err) {            /* Errors can only happen if there is a bug */            handle->h_err = err;			__ext4bf_journal_stop(where, line, handle);		}	} else {		if (inode)			mark_buffer_dirty_inode(bh, inode);		else			mark_buffer_dirty(bh);		if (inode && inode_needs_sync(inode)) {			sync_dirty_buffer(bh);			if (buffer_req(bh) && !buffer_uptodate(bh)) {				struct ext4bf_super_block *es;				es = EXT4_SB(inode->i_sb)->s_es;				es->s_last_error_block =					cpu_to_le64(bh->b_blocknr);				ext4bf_error_inode(inode, where, line,						 bh->b_blocknr,					"IO error syncing itable block");				err = -EIO;			}		}	}	return err;}

static void reset_inode_seed(struct inode *inode){	struct ext4_inode_info *ei = EXT4_I(inode);	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);	__le32 inum = cpu_to_le32(inode->i_ino);	__le32 gen = cpu_to_le32(inode->i_generation);	__u32 csum;	if (!ext4_has_metadata_csum(inode->i_sb))		return;	csum = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&inum, sizeof(inum));	ei->i_csum_seed = ext4_chksum(sbi, csum, (__u8 *)&gen, sizeof(gen));}

/* * Calculate the block group number and offset, given a block number */void ext4_get_group_no_and_offset(struct super_block *sb, ext4_fsblk_t blocknr,		ext4_group_t *blockgrpp, ext4_grpblk_t *offsetp){	struct ext4_super_block *es = EXT4_SB(sb)->s_es;	ext4_grpblk_t offset;	blocknr = blocknr - le32_to_cpu(es->s_first_data_block);	offset = do_div(blocknr, EXT4_BLOCKS_PER_GROUP(sb));	if (offsetp)		*offsetp = offset;	if (blockgrpp)		*blockgrpp = blocknr;}

static long ext4_ioctl_group_add(struct file *file,				 struct ext4_new_group_data *input){	struct super_block *sb = file_inode(file)->i_sb;	int err, err2=0;	err = ext4_resize_begin(sb);	if (err)		return err;	if (ext4_has_feature_bigalloc(sb)) {		ext4_msg(sb, KERN_ERR,			 "Online resizing not supported with bigalloc");		err = -EOPNOTSUPP;		goto group_add_out;	}	err = mnt_want_write_file(file);	if (err)		goto group_add_out;	err = ext4_group_add(sb, input);	if (EXT4_SB(sb)->s_journal) {		jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);		err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal);		jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);	}	if (err == 0)		err = err2;	mnt_drop_write_file(file);	if (!err && ext4_has_group_desc_csum(sb) &&	    test_opt(sb, INIT_INODE_TABLE))		err = ext4_register_li_request(sb, input->group);group_add_out:	ext4_resize_end(sb);	return err;}

int ext4_sync_file(struct file *file, struct dentry *dentry, int datasync){	struct inode *inode = dentry->d_inode;	struct ext4_inode_info *ei = EXT4_I(inode);	journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;	int ret;	tid_t commit_tid;	bool needs_barrier = false;	J_ASSERT(ext4_journal_current_handle() == NULL);	trace_ext4_sync_file(file, dentry, datasync);	if (inode->i_sb->s_flags & MS_RDONLY)		return 0;	ret = flush_aio_dio_completed_IO(inode);	if (ret < 0)		return ret;	if (!journal)		return simple_fsync(file, dentry, datasync);	/*	 * data=writeback,ordered:	 *  The caller's filemap_fdatawrite()/wait will sync the data.	 *  Metadata is in the journal, we wait for proper transaction to	 *  commit here.	 *	 * data=journal:	 *  filemap_fdatawrite won't do anything (the buffers are clean).	 *  ext4_force_commit will write the file data into the journal and	 *  will wait on that.	 *  filemap_fdatawait() will encounter a ton of newly-dirtied pages	 *  (they were dirtied by commit).  But that's OK - the blocks are	 *  safe in-journal, which is all fsync() needs to ensure.	 */	if (ext4_should_journal_data(inode))		return ext4_force_commit(inode->i_sb);	commit_tid = datasync ? ei->i_datasync_tid : ei->i_sync_tid;	if (journal->j_flags & JBD2_BARRIER &&	    !jbd2_trans_will_send_data_barrier(journal, commit_tid))		needs_barrier = true;	ret = jbd2_complete_transaction(journal, commit_tid);	if (needs_barrier)		blkdev_issue_flush(inode->i_sb->s_bdev, NULL);	return ret;}

void ext4_inode_bitmap_csum_set(struct super_block *sb, ext4_group_t group,				struct ext4_group_desc *gdp,				struct buffer_head *bh, int sz){	__u32 csum;	struct ext4_sb_info *sbi = EXT4_SB(sb);	if (!ext4_has_metadata_csum(sb))		return;	csum = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)bh->b_data, sz);	gdp->bg_inode_bitmap_csum_lo = cpu_to_le16(csum & 0xFFFF);	if (sbi->s_desc_size >= EXT4_BG_INODE_BITMAP_CSUM_HI_END)		gdp->bg_inode_bitmap_csum_hi = cpu_to_le16(csum >> 16);}

int __ext4bf_handle_dirty_super(const char *where, unsigned int line,			      handle_t *handle, struct super_block *sb){	struct buffer_head *bh = EXT4_SB(sb)->s_sbh;	int err = 0;	if (ext4bf_handle_valid(handle)) {		err = jbdbf_journal_dirty_metadata(handle, bh);		if (err)			ext4bf_journal_abort_handle(where, line, __func__,						  bh, handle, err);	} else		sb->s_dirt = 1;	return err;}

int __ext4_handle_dirty_metadata(const char *where, unsigned int line,				 handle_t *handle, struct inode *inode,				 struct buffer_head *bh){	int err = 0;	might_sleep();	set_buffer_meta(bh);	set_buffer_prio(bh);	if (ext4_handle_valid(handle)) {		err = jbd2_journal_dirty_metadata(handle, bh);		/* Errors can only happen if there is a bug */		if (WARN_ON_ONCE(err)) {			ext4_journal_abort_handle(where, line, __func__, bh,						  handle, err);			ext4_error_inode(inode, where, line,					 bh->b_blocknr,					 "journal_dirty_metadata failed: "					 "handle type %u started at line %u, "					 "credits %u/%u, errcode %d",					 handle->h_type,					 handle->h_line_no,					 handle->h_requested_credits,					 handle->h_buffer_credits, err);		}	} else {		if (inode)			mark_buffer_dirty_inode(bh, inode);		else			mark_buffer_dirty(bh);		if (inode && inode_needs_sync(inode)) {			sync_dirty_buffer(bh);			if (buffer_req(bh) && !buffer_uptodate(bh)) {				struct ext4_super_block *es;				es = EXT4_SB(inode->i_sb)->s_es;				es->s_last_error_block =					cpu_to_le64(bh->b_blocknr);				ext4_error_inode(inode, where, line,						 bh->b_blocknr,					"IO error syncing itable block");				err = -EIO;			}		}	}	return err;}

static ssize_text4_file_write(struct kiocb *iocb, const struct iovec *iov,                unsigned long nr_segs, loff_t pos){    struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;    int unaligned_aio = 0;    int ret;    trace_ext4_file_write(iocb->ki_filp->f_path.dentry, iocb->ki_left);    if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {        struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);        size_t length = iov_length(iov, nr_segs);        if ((pos > sbi->s_bitmap_maxbytes ||                (pos == sbi->s_bitmap_maxbytes && length > 0)))            return -EFBIG;        if (pos + length > sbi->s_bitmap_maxbytes) {            nr_segs = iov_shorten((struct iovec *)iov, nr_segs,                                  sbi->s_bitmap_maxbytes - pos);        }    } else if (unlikely((iocb->ki_filp->f_flags & O_DIRECT) &&                        !is_sync_kiocb(iocb))) {        unaligned_aio = ext4_unaligned_aio(inode, iov, nr_segs, pos);    }    if (unaligned_aio) {        static unsigned long unaligned_warn_time;        if (printk_timed_ratelimit(&unaligned_warn_time, 60*60*24*HZ))            ext4_msg(inode->i_sb, KERN_WARNING,                     "Unaligned AIO/DIO on inode %ld by %s; "                     "performance will be poor.",                     inode->i_ino, current->comm);        mutex_lock(ext4_aio_mutex(inode));        ext4_aiodio_wait(inode);    }    ret = generic_file_aio_write(iocb, iov, nr_segs, pos);    if (unaligned_aio)        mutex_unlock(ext4_aio_mutex(inode));    return ret;}

void ext4_block_bitmap_csum_set(struct super_block *sb, ext4_group_t group,				struct ext4_group_desc *gdp,				struct buffer_head *bh, int sz){	__u32 csum;	struct ext4_sb_info *sbi = EXT4_SB(sb);	if (!EXT4_HAS_RO_COMPAT_FEATURE(sb,			EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))		return;	csum = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)bh->b_data, sz);	gdp->bg_block_bitmap_csum_lo = cpu_to_le16(csum & 0xFFFF);	if (sbi->s_desc_size >= EXT4_BG_BLOCK_BITMAP_CSUM_HI_END)		gdp->bg_block_bitmap_csum_hi = cpu_to_le16(csum >> 16);}

handle_t *__ext4_journal_start_sb(struct super_block *sb, unsigned int line,				  int type, int blocks, int rsv_blocks){	journal_t *journal;	int err;	trace_ext4_journal_start(sb, blocks, rsv_blocks, _RET_IP_);	err = ext4_journal_check_start(sb);	if (err < 0)		return ERR_PTR(err);	journal = EXT4_SB(sb)->s_journal;	if (!journal)		return ext4_get_nojournal();	return jbd2__journal_start(journal, blocks, rsv_blocks, GFP_NOFS,				   type, line);}

static int ext4_shutdown(struct super_block *sb, unsigned long arg){	struct ext4_sb_info *sbi = EXT4_SB(sb);	__u32 flags;	if (!capable(CAP_SYS_ADMIN))		return -EPERM;	if (get_user(flags, (__u32 __user *)arg))		return -EFAULT;	if (flags > EXT4_GOING_FLAGS_NOLOGFLUSH)		return -EINVAL;	if (ext4_forced_shutdown(sbi))		return 0;	ext4_msg(sb, KERN_ALERT, "shut down requested (%d)", flags);	switch (flags) {	case EXT4_GOING_FLAGS_DEFAULT:		freeze_bdev(sb->s_bdev);		set_bit(EXT4_FLAGS_SHUTDOWN, &sbi->s_ext4_flags);		thaw_bdev(sb->s_bdev, sb);		break;	case EXT4_GOING_FLAGS_LOGFLUSH:		set_bit(EXT4_FLAGS_SHUTDOWN, &sbi->s_ext4_flags);		if (sbi->s_journal && !is_journal_aborted(sbi->s_journal)) {			(void) ext4_force_commit(sb);			jbd2_journal_abort(sbi->s_journal, 0);		}		break;	case EXT4_GOING_FLAGS_NOLOGFLUSH:		set_bit(EXT4_FLAGS_SHUTDOWN, &sbi->s_ext4_flags);		if (sbi->s_journal && !is_journal_aborted(sbi->s_journal)) {			msleep(100);			jbd2_journal_abort(sbi->s_journal, 0);		}		break;	default:		return -EINVAL;	}	clear_opt(sb, DISCARD);	return 0;}

/* * work on completed aio dio IO, to convert unwritten extents to extents */static void ext4_end_io_work(struct work_struct *work){	ext4_io_end_t		*io = container_of(work, ext4_io_end_t, work);	struct inode		*inode = io->inode;	struct ext4_inode_info	*ei = EXT4_I(inode);	unsigned long		flags;	spin_lock_irqsave(&ei->i_completed_io_lock, flags);	if (io->flag & EXT4_IO_END_IN_FSYNC)		goto requeue;	if (list_empty(&io->list)) {		spin_unlock_irqrestore(&ei->i_completed_io_lock, flags);		goto free;	}	if (!mutex_trylock(&inode->i_mutex)) {		bool was_queued;requeue:		was_queued = !!(io->flag & EXT4_IO_END_QUEUED);		io->flag |= EXT4_IO_END_QUEUED;		spin_unlock_irqrestore(&ei->i_completed_io_lock, flags);		/*		 * Requeue the work instead of waiting so that the work		 * items queued after this can be processed.		 */		queue_work(EXT4_SB(inode->i_sb)->dio_unwritten_wq, &io->work);		/*		 * To prevent the ext4-dio-unwritten thread from keeping		 * requeueing end_io requests and occupying cpu for too long,		 * yield the cpu if it sees an end_io request that has already		 * been requeued.		 */		if (was_queued)			yield();		return;	}	list_del_init(&io->list);	spin_unlock_irqrestore(&ei->i_completed_io_lock, flags);	(void) ext4_end_io_nolock(io);	mutex_unlock(&inode->i_mutex);free:	ext4_free_io_end(io);}

/* * Wrappers for jbd2_journal_start/end. */static int ext4_journal_check_start(struct super_block *sb){	journal_t *journal;	might_sleep();	if (sb->s_flags & MS_RDONLY)		return -EROFS;	WARN_ON(sb->s_writers.frozen == SB_FREEZE_COMPLETE);	journal = EXT4_SB(sb)->s_journal;	/*	 * Special case here: if the journal has aborted behind our	 * backs (eg. EIO in the commit thread), then we still need to	 * take the FS itself readonly cleanly.	 */	if (journal && is_journal_aborted(journal)) {		ext4_abort(sb, "Detected aborted journal");		return -EROFS;	}	return 0;}

static int ext4_file_open(struct inode * inode, struct file * filp){	struct super_block *sb = inode->i_sb;	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);	struct ext4_inode_info *ei = EXT4_I(inode);	struct vfsmount *mnt = filp->f_path.mnt;	struct path path;	char buf[64], *cp;	if (unlikely(!(sbi->s_mount_flags & EXT4_MF_MNTDIR_SAMPLED) &&		     !(sb->s_flags & MS_RDONLY))) {		sbi->s_mount_flags |= EXT4_MF_MNTDIR_SAMPLED;		memset(buf, 0, sizeof(buf));		path.mnt = mnt;		path.dentry = mnt->mnt_root;		cp = d_path(&path, buf, sizeof(buf));		if (!IS_ERR(cp)) {			strlcpy(sbi->s_es->s_last_mounted, cp,				sizeof(sbi->s_es->s_last_mounted));			ext4_mark_super_dirty(sb);		}	}	if (sbi->s_journal && !ei->jinode && (filp->f_mode & FMODE_WRITE)) {		struct jbd2_inode *jinode = jbd2_alloc_inode(GFP_KERNEL);		spin_lock(&inode->i_lock);		if (!ei->jinode) {			if (!jinode) {				spin_unlock(&inode->i_lock);				return -ENOMEM;			}			ei->jinode = jinode;			jbd2_journal_init_jbd_inode(ei->jinode, inode);			jinode = NULL;		}		spin_unlock(&inode->i_lock);		if (unlikely(jinode != NULL))			jbd2_free_inode(jinode);	}	return dquot_file_open(inode, filp);}

int ext4_inode_bitmap_csum_verify(struct super_block *sb, ext4_group_t group,				  struct ext4_group_desc *gdp,				  struct buffer_head *bh, int sz){	__u32 hi;	__u32 provided, calculated;	struct ext4_sb_info *sbi = EXT4_SB(sb);	if (!ext4_has_metadata_csum(sb))		return 1;	provided = le16_to_cpu(gdp->bg_inode_bitmap_csum_lo);	calculated = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)bh->b_data, sz);	if (sbi->s_desc_size >= EXT4_BG_INODE_BITMAP_CSUM_HI_END) {		hi = le16_to_cpu(gdp->bg_inode_bitmap_csum_hi);		provided |= (hi << 16);	} else		calculated &= 0xFFFF;	return provided == calculated;}

int __ext4_handle_dirty_super(const char *where, unsigned int line,			      handle_t *handle, struct super_block *sb,			      int now){	struct buffer_head *bh = EXT4_SB(sb)->s_sbh;	int err = 0;	if (ext4_handle_valid(handle)) {		ext4_superblock_csum_set(sb,				(struct ext4_super_block *)bh->b_data);		err = jbd2_journal_dirty_metadata(handle, bh);		if (err)			ext4_journal_abort_handle(where, line, __func__,						  bh, handle, err);	} else if (now) {		ext4_superblock_csum_set(sb,				(struct ext4_super_block *)bh->b_data);		mark_buffer_dirty(bh);	} else		sb->s_dirt = 1;	return err;}

int __ext4_handle_dirty_metadata(const char *where, unsigned int line,				 handle_t *handle, struct inode *inode,				 struct buffer_head *bh){	int err = 0;	might_sleep();	set_buffer_meta(bh);	set_buffer_prio(bh);	if (ext4_handle_valid(handle)) {		err = jbd2_journal_dirty_metadata(handle, bh);		if (err) {			/* Errors can only happen if there is a bug */			handle->h_err = err;			__ext4_journal_stop(where, line, handle);		}	} else {		if (inode)			mark_buffer_dirty_inode(bh, inode);		else			mark_buffer_dirty(bh);		if (inode && inode_needs_sync(inode)) {			sync_dirty_buffer(bh);			if (buffer_req(bh) && !buffer_uptodate(bh)) {				struct ext4_super_block *es;				es = EXT4_SB(inode->i_sb)->s_es;				es->s_last_error_block =					cpu_to_le64(bh->b_blocknr);				ext4_error_inode(inode, where, line,						 bh->b_blocknr,					"IO error syncing itable block");				err = -EIO;			}		}	}	return err;}

/* * write the buffer to the inline inode. * If 'create' is set, we don't need to do the extra copy in the xattr * value since it is already handled by ext4_xattr_ibody_inline_set. * That saves us one memcpy. */static void ext4_write_inline_data(struct inode *inode, struct ext4_iloc *iloc,				   void *buffer, loff_t pos, unsigned int len){	struct ext4_xattr_entry *entry;	struct ext4_xattr_ibody_header *header;	struct ext4_inode *raw_inode;	int cp_len = 0;	if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))		return;	BUG_ON(!EXT4_I(inode)->i_inline_off);	BUG_ON(pos + len > EXT4_I(inode)->i_inline_size);	raw_inode = ext4_raw_inode(iloc);	buffer += pos;	if (pos < EXT4_MIN_INLINE_DATA_SIZE) {		cp_len = pos + len > EXT4_MIN_INLINE_DATA_SIZE ?			 EXT4_MIN_INLINE_DATA_SIZE - pos : len;		memcpy((void *)raw_inode->i_block + pos, buffer, cp_len);		len -= cp_len;		buffer += cp_len;		pos += cp_len;	}	if (!len)		return;	pos -= EXT4_MIN_INLINE_DATA_SIZE;	header = IHDR(inode, raw_inode);	entry = (struct ext4_xattr_entry *)((void *)raw_inode +					    EXT4_I(inode)->i_inline_off);	memcpy((void *)IFIRST(header) + le16_to_cpu(entry->e_value_offs) + pos,	       buffer, len);}

/* * ext4_llseek() copied from generic_file_llseek() to handle both * block-mapped and extent-mapped maxbytes values. This should * otherwise be identical with generic_file_llseek(). */loff_t ext4_llseek(struct file *file, loff_t offset, int origin){	struct inode *inode = file->f_mapping->host;	loff_t maxbytes;	if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))		maxbytes = EXT4_SB(inode->i_sb)->s_bitmap_maxbytes;	else		maxbytes = inode->i_sb->s_maxbytes;	mutex_lock(&inode->i_mutex);	switch (origin) {	case SEEK_END:		offset += inode->i_size;		break;	case SEEK_CUR:		if (offset == 0) {			mutex_unlock(&inode->i_mutex);			return file->f_pos;		}		offset += file->f_pos;		break;	}	if (offset < 0 || offset > maxbytes) {		mutex_unlock(&inode->i_mutex);		return -EINVAL;	}	if (offset != file->f_pos) {		file->f_pos = offset;		file->f_version = 0;	}	mutex_unlock(&inode->i_mutex);	return offset;}

/** * ext4_get_group_desc() -- load group descriptor from disk * @sb:			super block * @block_group:	given block group * @bh:			pointer to the buffer head to store the block *			group descriptor */struct ext4_group_desc * ext4_get_group_desc(struct super_block *sb,					     ext4_group_t block_group,					     struct buffer_head **bh){	unsigned int group_desc;	unsigned int offset;	ext4_group_t ngroups = ext4_get_groups_count(sb);	struct ext4_group_desc *desc;	struct ext4_sb_info *sbi = EXT4_SB(sb);	if (block_group >= ngroups) {		ext4_error(sb, "ext4_get_group_desc",			   "block_group >= groups_count - "			   "block_group = %u, groups_count = %u",			   block_group, ngroups);		return NULL;	}	group_desc = block_group >> EXT4_DESC_PER_BLOCK_BITS(sb);	offset = block_group & (EXT4_DESC_PER_BLOCK(sb) - 1);	if (!sbi->s_group_desc[group_desc]) {		ext4_error(sb, "ext4_get_group_desc",			   "Group descriptor not loaded - "			   "block_group = %u, group_desc = %u, desc = %u",			   block_group, group_desc, offset);		return NULL;	}	desc = (struct ext4_group_desc *)(		(__u8 *)sbi->s_group_desc[group_desc]->b_data +		offset * EXT4_DESC_SIZE(sb));	if (bh)		*bh = sbi->s_group_desc[group_desc];	return desc;}

/** * Swap the information from the given @inode and the inode * EXT4_BOOT_LOADER_INO. It will basically swap i_data and all other * important fields of the inodes. * * @sb:         the super block of the filesystem * @inode:      the inode to swap with EXT4_BOOT_LOADER_INO * */static long swap_inode_boot_loader(struct super_block *sb,				struct inode *inode){	handle_t *handle;	int err;	struct inode *inode_bl;	struct ext4_inode_info *ei_bl;	struct ext4_sb_info *sbi = EXT4_SB(sb);	if (inode->i_nlink != 1 || !S_ISREG(inode->i_mode)) {		err = -EINVAL;		goto swap_boot_out;	}	if (!inode_owner_or_capable(inode) || !capable(CAP_SYS_ADMIN)) {		err = -EPERM;		goto swap_boot_out;	}	inode_bl = ext4_iget(sb, EXT4_BOOT_LOADER_INO);	if (IS_ERR(inode_bl)) {		err = PTR_ERR(inode_bl);		goto swap_boot_out;	}	ei_bl = EXT4_I(inode_bl);	filemap_flush(inode->i_mapping);	filemap_flush(inode_bl->i_mapping);	/* Protect orig inodes against a truncate and make sure,	 * that only 1 swap_inode_boot_loader is running. */	lock_two_nondirectories(inode, inode_bl);	truncate_inode_pages(&inode->i_data, 0);	truncate_inode_pages(&inode_bl->i_data, 0);	/* Wait for all existing dio workers */	ext4_inode_block_unlocked_dio(inode);	ext4_inode_block_unlocked_dio(inode_bl);	inode_dio_wait(inode);	inode_dio_wait(inode_bl);	handle = ext4_journal_start(inode_bl, EXT4_HT_MOVE_EXTENTS, 2);	if (IS_ERR(handle)) {		err = -EINVAL;		goto journal_err_out;	}	/* Protect extent tree against block allocations via delalloc */	ext4_double_down_write_data_sem(inode, inode_bl);	if (inode_bl->i_nlink == 0) {		/* this inode has never been used as a BOOT_LOADER */		set_nlink(inode_bl, 1);		i_uid_write(inode_bl, 0);		i_gid_write(inode_bl, 0);		inode_bl->i_flags = 0;		ei_bl->i_flags = 0;		inode_bl->i_version = 1;		i_size_write(inode_bl, 0);		inode_bl->i_mode = S_IFREG;		if (EXT4_HAS_INCOMPAT_FEATURE(sb,					      EXT4_FEATURE_INCOMPAT_EXTENTS)) {			ext4_set_inode_flag(inode_bl, EXT4_INODE_EXTENTS);			ext4_ext_tree_init(handle, inode_bl);		} else			memset(ei_bl->i_data, 0, sizeof(ei_bl->i_data));	}	swap_inode_data(inode, inode_bl);	inode->i_ctime = inode_bl->i_ctime = ext4_current_time(inode);	spin_lock(&sbi->s_next_gen_lock);	inode->i_generation = sbi->s_next_generation++;	inode_bl->i_generation = sbi->s_next_generation++;	spin_unlock(&sbi->s_next_gen_lock);	ext4_discard_preallocations(inode);	err = ext4_mark_inode_dirty(handle, inode);	if (err < 0) {		ext4_warning(inode->i_sb,			"couldn't mark inode #%lu dirty (err %d)",			inode->i_ino, err);		/* Revert all changes: */		swap_inode_data(inode, inode_bl);	} else {		err = ext4_mark_inode_dirty(handle, inode_bl);		if (err < 0) {			ext4_warning(inode_bl->i_sb,//.........这里部分代码省略.........

//.........这里部分代码省略.........		ext4_journal_stop(handle);unlock_out:		mutex_unlock(&inode->i_mutex);setversion_out:		mnt_drop_write_file(filp);		return err;	}	case EXT4_IOC_GROUP_EXTEND: {		ext4_fsblk_t n_blocks_count;		int err, err2=0;		err = ext4_resize_begin(sb);		if (err)			return err;		if (get_user(n_blocks_count, (__u32 __user *)arg)) {			err = -EFAULT;			goto group_extend_out;		}		if (EXT4_HAS_RO_COMPAT_FEATURE(sb,			       EXT4_FEATURE_RO_COMPAT_BIGALLOC)) {			ext4_msg(sb, KERN_ERR,				 "Online resizing not supported with bigalloc");			err = -EOPNOTSUPP;			goto group_extend_out;		}		err = mnt_want_write_file(filp);		if (err)			goto group_extend_out;		err = ext4_group_extend(sb, EXT4_SB(sb)->s_es, n_blocks_count);		if (EXT4_SB(sb)->s_journal) {			jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);			err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal);			jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);		}		if (err == 0)			err = err2;		mnt_drop_write_file(filp);group_extend_out:		ext4_resize_end(sb);		return err;	}	case EXT4_IOC_MOVE_EXT: {		struct move_extent me;		struct fd donor;		int err;		if (!(filp->f_mode & FMODE_READ) ||		    !(filp->f_mode & FMODE_WRITE))			return -EBADF;		if (copy_from_user(&me,			(struct move_extent __user *)arg, sizeof(me)))			return -EFAULT;		me.moved_len = 0;		donor = fdget(me.donor_fd);		if (!donor.file)			return -EBADF;		if (!(donor.file->f_mode & FMODE_WRITE)) {

static unsigned long ext4_bg_num_gdb_nometa(struct super_block *sb,					ext4_group_t group){	return ext4_bg_has_super(sb, group) ? EXT4_SB(sb)->s_gdb_count : 0;}

/* Initializes an uninitialized block bitmap if given, and returns the * number of blocks free in the group. */unsigned ext4_init_block_bitmap(struct super_block *sb, struct buffer_head *bh,		 ext4_group_t block_group, struct ext4_group_desc *gdp){	int bit, bit_max;	ext4_group_t ngroups = ext4_get_groups_count(sb);	unsigned free_blocks, group_blocks;	struct ext4_sb_info *sbi = EXT4_SB(sb);	if (bh) {		J_ASSERT_BH(bh, buffer_locked(bh));		/* If checksum is bad mark all blocks used to prevent allocation		 * essentially implementing a per-group read-only flag. */		if (!ext4_group_desc_csum_verify(sbi, block_group, gdp)) {			ext4_error(sb, __func__,				  "Checksum bad for group %u", block_group);			ext4_free_blks_set(sb, gdp, 0);			ext4_free_inodes_set(sb, gdp, 0);			ext4_itable_unused_set(sb, gdp, 0);			memset(bh->b_data, 0xff, sb->s_blocksize);			return 0;		}		memset(bh->b_data, 0, sb->s_blocksize);	}	/* Check for superblock and gdt backups in this group */	bit_max = ext4_bg_has_super(sb, block_group);	if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG) ||	    block_group < le32_to_cpu(sbi->s_es->s_first_meta_bg) *			  sbi->s_desc_per_block) {		if (bit_max) {			bit_max += ext4_bg_num_gdb(sb, block_group);			bit_max +=				le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks);		}	} else { /* For META_BG_BLOCK_GROUPS */		bit_max += ext4_bg_num_gdb(sb, block_group);	}	if (block_group == ngroups - 1) {		/*		 * Even though mke2fs always initialize first and last group		 * if some other tool enabled the EXT4_BG_BLOCK_UNINIT we need		 * to make sure we calculate the right free blocks		 */		group_blocks = ext4_blocks_count(sbi->s_es) -			le32_to_cpu(sbi->s_es->s_first_data_block) -			(EXT4_BLOCKS_PER_GROUP(sb) * (ngroups - 1));	} else {		group_blocks = EXT4_BLOCKS_PER_GROUP(sb);	}	free_blocks = group_blocks - bit_max;	if (bh) {		ext4_fsblk_t start, tmp;		int flex_bg = 0;		for (bit = 0; bit < bit_max; bit++)			ext4_set_bit(bit, bh->b_data);		start = ext4_group_first_block_no(sb, block_group);		if (EXT4_HAS_INCOMPAT_FEATURE(sb,					      EXT4_FEATURE_INCOMPAT_FLEX_BG))			flex_bg = 1;		/* Set bits for block and inode bitmaps, and inode table */		tmp = ext4_block_bitmap(sb, gdp);		if (!flex_bg || ext4_block_in_group(sb, tmp, block_group))			ext4_set_bit(tmp - start, bh->b_data);		tmp = ext4_inode_bitmap(sb, gdp);		if (!flex_bg || ext4_block_in_group(sb, tmp, block_group))			ext4_set_bit(tmp - start, bh->b_data);		tmp = ext4_inode_table(sb, gdp);		for (; tmp < ext4_inode_table(sb, gdp) +				sbi->s_itb_per_group; tmp++) {			if (!flex_bg ||				ext4_block_in_group(sb, tmp, block_group))				ext4_set_bit(tmp - start, bh->b_data);		}		/*		 * Also if the number of blocks within the group is		 * less than the blocksize * 8 ( which is the size		 * of bitmap ), set rest of the block bitmap to 1		 */		mark_bitmap_end(group_blocks, sb->s_blocksize * 8, bh->b_data);	}	return free_blocks - ext4_group_used_meta_blocks(sb, block_group, gdp);}

/** * ext4_add_groupblocks() -- Add given blocks to an existing group * @handle:			handle to this transaction * @sb:				super block * @block:			start physcial block to add to the block group * @count:			number of blocks to free * * This marks the blocks as free in the bitmap. We ask the * mballoc to reload the buddy after this by setting group * EXT4_GROUP_INFO_NEED_INIT_BIT flag */void ext4_add_groupblocks(handle_t *handle, struct super_block *sb,			 ext4_fsblk_t block, unsigned long count){	struct buffer_head *bitmap_bh = NULL;	struct buffer_head *gd_bh;	ext4_group_t block_group;	ext4_grpblk_t bit;	unsigned int i;	struct ext4_group_desc *desc;	struct ext4_sb_info *sbi = EXT4_SB(sb);	int err = 0, ret, blk_free_count;	ext4_grpblk_t blocks_freed;	struct ext4_group_info *grp;	ext4_debug("Adding block(s) %llu-%llu/n", block, block + count - 1);	ext4_get_group_no_and_offset(sb, block, &block_group, &bit);	grp = ext4_get_group_info(sb, block_group);	/*	 * Check to see if we are freeing blocks across a group	 * boundary.	 */	if (bit + count > EXT4_BLOCKS_PER_GROUP(sb)) {		goto error_return;	}	bitmap_bh = ext4_read_block_bitmap(sb, block_group);	if (!bitmap_bh)		goto error_return;	desc = ext4_get_group_desc(sb, block_group, &gd_bh);	if (!desc)		goto error_return;	if (in_range(ext4_block_bitmap(sb, desc), block, count) ||	    in_range(ext4_inode_bitmap(sb, desc), block, count) ||	    in_range(block, ext4_inode_table(sb, desc), sbi->s_itb_per_group) ||	    in_range(block + count - 1, ext4_inode_table(sb, desc),		     sbi->s_itb_per_group)) {		ext4_error(sb, __func__,			   "Adding blocks in system zones - "			   "Block = %llu, count = %lu",			   block, count);		goto error_return;	}	/*	 * We are about to add blocks to the bitmap,	 * so we need undo access.	 */	BUFFER_TRACE(bitmap_bh, "getting undo access");	err = ext4_journal_get_undo_access(handle, bitmap_bh);	if (err)		goto error_return;	/*	 * We are about to modify some metadata.  Call the journal APIs	 * to unshare ->b_data if a currently-committing transaction is	 * using it	 */	BUFFER_TRACE(gd_bh, "get_write_access");	err = ext4_journal_get_write_access(handle, gd_bh);	if (err)		goto error_return;	/*	 * make sure we don't allow a parallel init on other groups in the	 * same buddy cache	 */	down_write(&grp->alloc_sem);	for (i = 0, blocks_freed = 0; i < count; i++) {		BUFFER_TRACE(bitmap_bh, "clear bit");		if (!ext4_clear_bit_atomic(ext4_group_lock_ptr(sb, block_group),						bit + i, bitmap_bh->b_data)) {			ext4_error(sb, __func__,				   "bit already cleared for block %llu",				   (ext4_fsblk_t)(block + i));			BUFFER_TRACE(bitmap_bh, "bit already cleared");		} else {			blocks_freed++;		}	}	ext4_lock_group(sb, block_group);	blk_free_count = blocks_freed + ext4_free_blks_count(sb, desc);	ext4_free_blks_set(sb, desc, blk_free_count);	desc->bg_checksum = ext4_group_desc_csum(sbi, block_group, desc);	ext4_unlock_group(sb, block_group);	percpu_counter_mod(&sbi->s_freeblocks_counter, blocks_freed);	if (sbi->s_log_groups_per_flex) {		ext4_group_t flex_group = ext4_flex_group(sbi, block_group);		atomic_add(blocks_freed,//.........这里部分代码省略.........