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

static void ext2_sync_super(struct super_block *sb, struct ext2_super_block *es){	es->s_free_blocks_count = cpu_to_le32(ext2_count_free_blocks(sb));	es->s_free_inodes_count = cpu_to_le32(ext2_count_free_inodes(sb));	es->s_wtime = cpu_to_le32(get_seconds());	mark_buffer_dirty(EXT2_SB(sb)->s_sbh);	sync_dirty_buffer(EXT2_SB(sb)->s_sbh);	sb->s_dirt = 0;}

static void simplefs_destroy_inode(struct inode *vfs_inode) {	struct simple_fs_inode_i *inode = SIMPLEFS_INODE(vfs_inode);	struct simple_fs_sb_i *sb = SIMPLEFS_SB(vfs_inode->i_sb);	if (inode->indirect_block) {		if(!buffer_uptodate(inode->indirect_block))			sync_dirty_buffer(inode->indirect_block);		bforget(inode->indirect_block);	}	kmem_cache_free(sb->inode_cachep,inode);}

static int ufs_fmp_run(struct device *dev, uint32_t mode, uint8_t *data,			uint32_t len, uint32_t write){	int ret = 0;	struct ufs_hba *hba;	struct ufs_fmp_work *work;	struct Scsi_Host *host;	static struct buffer_head *bh;	work = dev_get_drvdata(dev);	if (!work) {		dev_err(dev, "Fail to get work from platform device/n");		return -ENODEV;	}	host = work->host;	hba = shost_priv(host);	hba->self_test_mode = mode;	bh = __getblk(work->bdev, work->sector, FMP_BLK_SIZE);	if (!bh) {		dev_err(dev, "Fail to get block from bdev/n");		return -ENODEV;	}	hba->self_test_bh = bh;	get_bh(bh);	if (write == WRITE_MODE) {		memcpy(bh->b_data, data, len);		set_buffer_dirty(bh);		sync_dirty_buffer(bh);		if (buffer_req(bh) && !buffer_uptodate(bh)) {			dev_err(dev, "IO error syncing for FMP fips write/n");			ret = -EIO;			goto out;		}		memset(bh->b_data, 0, FMP_BLK_SIZE);	} else {		lock_buffer(bh);		bh->b_end_io = end_buffer_read_sync;		submit_bh(READ_SYNC, bh);		wait_on_buffer(bh);		if (unlikely(!buffer_uptodate(bh))) {			ret = -EIO;			goto out;		}		memcpy(data, bh->b_data, len);	}out:	hba->self_test_mode = 0;	hba->self_test_bh = NULL;	put_bh(bh);	return ret;}

void dedupfs_sb_sync(struct super_block *vsb){	struct buffer_head *bh;	struct dedupfs_super_block *sb = DEDUPFS_SB(vsb);	bh = (struct buffer_head*)sb_bread(vsb, 									DEDUPFS_SUPERBLOCK_BLOCK_NUMBER);	bh->b_data = (char *)sb;	mark_buffer_dirty(bh);	sync_dirty_buffer(bh);}

void simplefs_sb_sync(struct super_block *vsb){	struct buffer_head *bh;	struct simplefs_super_block *sb = SIMPLEFS_SB(vsb);	bh = (struct buffer_head *)sb_bread(vsb,					    SIMPLEFS_SUPERBLOCK_BLOCK_NUMBER);	bh->b_data = (char *)sb;	mark_buffer_dirty(bh);	sync_dirty_buffer(bh);	brelse(bh);}

static void simplefs_sync_metadata_buffer(struct bufffer_head **bh_table){	struct buffer_head **walker = *bh_table;	while(walker) {			struct buffer_head *bh = *walker;		do		{			if(!buffer_uptodate(bh))				sync_dirty_buffer(bh);			bh=bh->b_this_page;		}while(bh->b_this_page != *walker);		walker++;	}}

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 mark_dirty(struct super_block *s, int remount){	if (hpfs_sb(s)->sb_chkdsk && (remount || !(s->s_flags & MS_RDONLY))) {		struct buffer_head *bh;		struct hpfs_spare_block *sb;		if ((sb = hpfs_map_sector(s, 17, &bh, 0))) {			sb->dirty = 1;			sb->old_wrote = 0;			mark_buffer_dirty(bh);			sync_dirty_buffer(bh);			brelse(bh);		}	}}

static void unmark_dirty(struct super_block *s){	struct buffer_head *bh;	struct hpfs_spare_block *sb;	if (s->s_flags & MS_RDONLY) return;	sync_blockdev(s->s_bdev);	if ((sb = hpfs_map_sector(s, 17, &bh, 0))) {		sb->dirty = hpfs_sb(s)->sb_chkdsk > 1 - hpfs_sb(s)->sb_was_error;		sb->old_wrote = hpfs_sb(s)->sb_chkdsk >= 2 && !hpfs_sb(s)->sb_was_error;		mark_buffer_dirty(bh);		sync_dirty_buffer(bh);		brelse(bh);	}}

int f2fs_commit_super(struct f2fs_sb_info *sbi){	struct buffer_head *sbh = sbi->raw_super_buf;	sector_t block = sbh->b_blocknr;	int err;	/* write back-up superblock first */	sbh->b_blocknr = block ? 0 : 1;	mark_buffer_dirty(sbh);	err = sync_dirty_buffer(sbh);	sbh->b_blocknr = block;	if (err)		goto out;	/* write current valid superblock */	mark_buffer_dirty(sbh);	err = sync_dirty_buffer(sbh);out:	clear_buffer_write_io_error(sbh);	set_buffer_uptodate(sbh);	return err;}

void ext2_sync_super(struct super_block *sb, struct ext2_super_block *es,		     int wait){	ext2_clear_super_error(sb);	spin_lock(&EXT2_SB(sb)->s_lock);	es->s_free_blocks_count = cpu_to_le32(ext2_count_free_blocks(sb));	es->s_free_inodes_count = cpu_to_le32(ext2_count_free_inodes(sb));	es->s_wtime = cpu_to_le32(get_seconds());	/* unlock before we do IO */	spin_unlock(&EXT2_SB(sb)->s_lock);	mark_buffer_dirty(EXT2_SB(sb)->s_sbh);	if (wait)		sync_dirty_buffer(EXT2_SB(sb)->s_sbh);}

static voidaffs_commit_super(struct super_block *sb, int wait, int clean){	struct affs_sb_info *sbi = AFFS_SB(sb);	struct buffer_head *bh = sbi->s_root_bh;	struct affs_root_tail *tail = AFFS_ROOT_TAIL(sb, bh);	tail->bm_flag = cpu_to_be32(clean);	secs_to_datestamp(get_seconds(), &tail->disk_change);	affs_fix_checksum(sb, bh);	mark_buffer_dirty(bh);	if (wait)		sync_dirty_buffer(bh);}

/* TODO We didn't use address_space/pagecache here.   If we hook file_operations.write = do_sync_write,   and file_operations.aio_write = generic_file_aio_write,   we will use write to pagecache instead. */ssize_t hellofs_write(struct file *filp, const char __user *buf, size_t len,                      loff_t *ppos) {    struct super_block *sb;    struct inode *inode;    struct hellofs_inode *hellofs_inode;    struct buffer_head *bh;    struct hellofs_superblock *hellofs_sb;    char *buffer;    int ret;    inode = filp->f_path.dentry->d_inode;    sb = inode->i_sb;    hellofs_inode = HELLOFS_INODE(inode);    hellofs_sb = HELLOFS_SB(sb);    ret = generic_write_checks(filp, ppos, &len, 0);    if (ret) {        return ret;    }    bh = sb_bread(sb, hellofs_inode->data_block_no);    if (!bh) {        printk(KERN_ERR "Failed to read data block %llu/n",               hellofs_inode->data_block_no);        return 0;    }    buffer = (char *)bh->b_data + *ppos;    if (copy_from_user(buffer, buf, len)) {        brelse(bh);        printk(KERN_ERR               "Error copying file content from userspace buffer "               "to kernel space/n");        return -EFAULT;    }    *ppos += len;    mark_buffer_dirty(bh);    sync_dirty_buffer(bh);    brelse(bh);    hellofs_inode->file_size = max((size_t)(hellofs_inode->file_size),                                   (size_t)(*ppos));    hellofs_save_hellofs_inode(sb, hellofs_inode);    /* TODO We didn't update file size here. To be frank I don't know how. */    return len;}

/** * void journal_update_superblock() - Update journal sb on disk. * @journal: The journal to update. * @wait: Set to '0' if you don't want to wait for IO completion. * * Update a journal's dynamic superblock fields and write it to disk, * optionally waiting for the IO to complete. */void journal_update_superblock(journal_t *journal, int wait){    journal_superblock_t *sb = journal->j_superblock;    struct buffer_head *bh = journal->j_sb_buffer;    /*     * As a special case, if the on-disk copy is already marked as needing     * no recovery (s_start == 0) and there are no outstanding transactions     * in the filesystem, then we can safely defer the superblock update     * until the next commit by setting JFS_FLUSHED.  This avoids     * attempting a write to a potential-readonly device.     */    if (sb->s_start == 0 && journal->j_tail_sequence ==            journal->j_transaction_sequence) {        jbd_debug(1,"JBD: Skipping superblock update on recovered sb "                  "(start %ld, seq %d, errno %d)/n",                  journal->j_tail, journal->j_tail_sequence,                  journal->j_errno);        goto out;    }    jbd_lock(&journal->j_state_lock);    jbd_debug(1,"JBD: updating superblock (start %ld, seq %d, errno %d)/n",              journal->j_tail, journal->j_tail_sequence, journal->j_errno);    sb->s_sequence = cpu_to_be32(journal->j_tail_sequence);    sb->s_start    = cpu_to_be32(journal->j_tail);    sb->s_errno    = cpu_to_be32(journal->j_errno);    jbd_unlock(&journal->j_state_lock);    BUFFER_TRACE(bh, "marking dirty");    mark_buffer_dirty(bh);    if (wait)        sync_dirty_buffer(bh);    else        ll_rw_block(SWRITE, 1, &bh);out:    /* If we have just flushed the log (by marking s_start==0), then     * any future commit will have to be careful to update the     * superblock again to re-record the true start of the log. */    jbd_lock(&journal->j_state_lock);    if (sb->s_start)        journal->j_flags &= ~JFS_FLUSHED;    else        journal->j_flags |= JFS_FLUSHED;    jbd_unlock(&journal->j_state_lock);}

static int __sysv_write_inode(struct inode *inode, int wait){	struct super_block * sb = inode->i_sb;	struct sysv_sb_info * sbi = SYSV_SB(sb);	struct buffer_head * bh;	struct sysv_inode * raw_inode;	struct sysv_inode_info * si;	unsigned int ino, block;	int err = 0;	ino = inode->i_ino;	if (!ino || ino > sbi->s_ninodes) {		printk("Bad inode number on dev %s: %d is out of range/n",		       inode->i_sb->s_id, ino);		return -EIO;	}	raw_inode = sysv_raw_inode(sb, ino, &bh);	if (!raw_inode) {		printk("unable to read i-node block/n");		return -EIO;	}	raw_inode->i_mode = cpu_to_fs16(sbi, inode->i_mode);	raw_inode->i_uid = cpu_to_fs16(sbi, fs_high2lowuid(inode->i_uid));	raw_inode->i_gid = cpu_to_fs16(sbi, fs_high2lowgid(inode->i_gid));	raw_inode->i_nlink = cpu_to_fs16(sbi, inode->i_nlink);	raw_inode->i_size = cpu_to_fs32(sbi, inode->i_size);	raw_inode->i_atime = cpu_to_fs32(sbi, inode->i_atime.tv_sec);	raw_inode->i_mtime = cpu_to_fs32(sbi, inode->i_mtime.tv_sec);	raw_inode->i_ctime = cpu_to_fs32(sbi, inode->i_ctime.tv_sec);	si = SYSV_I(inode);	if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))		si->i_data[0] = cpu_to_fs32(sbi, old_encode_dev(inode->i_rdev));	for (block = 0; block < 10+1+1+1; block++)		write3byte(sbi, (u8 *)&si->i_data[block],			&raw_inode->i_data[3*block]);	mark_buffer_dirty(bh);	if (wait) {                sync_dirty_buffer(bh);                if (buffer_req(bh) && !buffer_uptodate(bh)) {                        printk ("IO error syncing sysv inode [%s:%08x]/n",                                sb->s_id, ino);                        err = -EIO;                }        }	brelse(bh);	return 0;}

static intadfs_fplus_sync(struct adfs_dir *dir){	int err = 0;	int i;	for (i = dir->nr_buffers - 1; i >= 0; i--) {		struct buffer_head *bh = dir->bh[i];		sync_dirty_buffer(bh);		if (buffer_req(bh) && !buffer_uptodate(bh))			err = -EIO;	}	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;}

/* *	updateSuper() * * update synchronously superblock if it is mounted read-write. */int updateSuper(struct super_block *sb, uint state){	struct jfs_superblock *j_sb;	struct jfs_sb_info *sbi = JFS_SBI(sb);	struct buffer_head *bh;	int rc;	if (sbi->flag & JFS_NOINTEGRITY) {		if (state == FM_DIRTY) {			sbi->p_state = state;			return 0;		} else if (state == FM_MOUNT) {			sbi->p_state = sbi->state;			state = FM_DIRTY;		} else if (state == FM_CLEAN) {			state = sbi->p_state;		} else			jfs_err("updateSuper: bad state");	} else if (sbi->state == FM_DIRTY)		return 0;		if ((rc = readSuper(sb, &bh)))		return rc;	j_sb = (struct jfs_superblock *)bh->b_data;	j_sb->s_state = cpu_to_le32(state);	sbi->state = state;	if (state == FM_MOUNT) {		/* record log's dev_t and mount serial number */		j_sb->s_logdev = cpu_to_le32(new_encode_dev(sbi->log->bdev->bd_dev));		j_sb->s_logserial = cpu_to_le32(sbi->log->serial);	} else if (state == FM_CLEAN) {		/*		 * If this volume is shared with OS/2, OS/2 will need to		 * recalculate DASD usage, since we don't deal with it.		 */		if (j_sb->s_flag & cpu_to_le32(JFS_DASD_ENABLED))			j_sb->s_flag |= cpu_to_le32(JFS_DASD_PRIME);	}	mark_buffer_dirty(bh);	sync_dirty_buffer(bh);	brelse(bh);	return 0;}

ssize_t locfs_write(struct file *filp,                       const char __user *buf,                       size_t len,                      loff_t *ppos) {    struct super_block *sb;    struct inode *inode;    struct locfs_inode *locfs_inode;    struct buffer_head *bh;    struct locfs_super_block *locfs_sb;    char *buffer;    // Get inode from dentry cache    inode = filp->f_path.dentry->d_inode;    sb = inode->i_sb;    locfs_inode = LOCFS_INODE(inode);    locfs_sb = LOCFS_SB(sb);    bh = sb_bread(sb, locfs_inode->data_block_no);    if (!bh) {        printk(KERN_ERR "Failed to read data block %llu/n",               locfs_inode->data_block_no);        return 0;    }    buffer = (char *)bh->b_data + *ppos;    if (copy_from_user(buffer, buf, len)) {        brelse(bh);        printk(KERN_ERR               "Error while copying file content from userspace buffer "               "to kernel space/n");        return -EFAULT;    }    *ppos += len;    mark_buffer_dirty(bh);    sync_dirty_buffer(bh);    brelse(bh);    // Update the inode and save it back    locfs_inode->file_size = max((size_t)(locfs_inode->file_size),                                   (size_t)(*ppos));    locfs_save_locfs_inode(sb, locfs_inode);    return len;}

struct inode *testfs_new_inode(struct inode *dir, int mode){	struct super_block *sb = dir->i_sb;	struct testfs_sb_info *tsbi = TESTFS_SB(sb);	struct testfs_inode_info *tsi;	struct buffer_head *bitmap_bh = NULL;	struct inode *inode;	unsigned int ino = 0;	inode = new_inode(sb);	if(!inode)	{		testfs_debug("Could not allocate inode from inode cache/n");		return ERR_PTR(-ENOMEM);	}	tsi = TESTFS_I(inode);	bitmap_bh = read_inode_bitmap(sb);	ino = testfs_find_free_inode(bitmap_bh->b_data, sb);	if(!ino)	{		testfs_debug("Could not find any free inode. File system full/n");		return ERR_PTR(-ENOSPC);	}	testfs_debug("Allocated new inode (%u)/n",ino);	testfs_set_inode_bit(bitmap_bh->b_data, ino);	inode->i_ino = ino;	inode->i_mode = mode;	inode->i_gid = current->fsgid;	inode->i_uid = current->fsuid;	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;	testfs_debug("Successfully allocated inodes..../n");	memset(tsi->i_data, 0 ,sizeof(tsi->i_data));	tsi->i_data[0] = ino;	tsi->state = TESTFS_INODE_ALLOCATED;	tsbi->s_free_inodes--;	sb->s_dirt = 1;	insert_inode_hash(inode);	mark_inode_dirty(inode);	mark_buffer_dirty(bitmap_bh);	sync_dirty_buffer(bitmap_bh);	testfs_debug("returning now/n");	return inode;}

/* * write back super block information to disk * * @vsb: the VFS super block structure * @wait: whether to wait for the super block to be synced to disk * * return: 0 on success, error code otherwise */int wtfs_sync_super(struct super_block * vsb, int wait){	struct wtfs_sb_info * sbi = WTFS_SB_INFO(vsb);	struct wtfs_super_block * sb = NULL;	struct buffer_head * bh = NULL;	int ret = -EIO;	if ((bh = sb_bread(vsb, WTFS_RB_SUPER)) == NULL) {		wtfs_error("unable to read the super block/n");		goto error;	}	sb = (struct wtfs_super_block *)bh->b_data;	sb->version = cpu_to_wtfs64(sbi->version);	sb->magic = cpu_to_wtfs64(sbi->magic);	sb->block_size = cpu_to_wtfs64(sbi->block_size);	sb->block_count = cpu_to_wtfs64(sbi->block_count);	sb->inode_table_first = cpu_to_wtfs64(sbi->inode_table_first);	sb->inode_table_count = cpu_to_wtfs64(sbi->inode_table_count);	sb->block_bitmap_first = cpu_to_wtfs64(sbi->block_bitmap_first);	sb->block_bitmap_count = cpu_to_wtfs64(sbi->block_bitmap_count);	sb->inode_bitmap_first = cpu_to_wtfs64(sbi->inode_bitmap_first);	sb->inode_bitmap_count = cpu_to_wtfs64(sbi->inode_bitmap_count);	sb->inode_count = cpu_to_wtfs64(sbi->inode_count);	sb->free_block_count = cpu_to_wtfs64(sbi->free_block_count);	mark_buffer_dirty(bh);	if (wait) {		sync_dirty_buffer(bh);		if (buffer_req(bh) && !buffer_uptodate(bh)) {			wtfs_error("super block sync failed/n");			goto error;		}	}	brelse(bh);	return 0;error:	if (bh != NULL) {		brelse(bh);	}	return ret;}

int updateSuper(struct super_block *sb, uint state){	struct jfs_superblock *j_sb;	struct jfs_sb_info *sbi = JFS_SBI(sb);	struct buffer_head *bh;	int rc;	if (sbi->flag & JFS_NOINTEGRITY) {		if (state == FM_DIRTY) {			sbi->p_state = state;			return 0;		} else if (state == FM_MOUNT) {			sbi->p_state = sbi->state;			state = FM_DIRTY;		} else if (state == FM_CLEAN) {			state = sbi->p_state;		} else			jfs_err("updateSuper: bad state");	} else if (sbi->state == FM_DIRTY)		return 0;	if ((rc = readSuper(sb, &bh)))		return rc;	j_sb = (struct jfs_superblock *)bh->b_data;	j_sb->s_state = cpu_to_le32(state);	sbi->state = state;	if (state == FM_MOUNT) {				j_sb->s_logdev = cpu_to_le32(new_encode_dev(sbi->log->bdev->bd_dev));		j_sb->s_logserial = cpu_to_le32(sbi->log->serial);	} else if (state == FM_CLEAN) {		if (j_sb->s_flag & cpu_to_le32(JFS_DASD_ENABLED))			j_sb->s_flag |= cpu_to_le32(JFS_DASD_PRIME);	}	mark_buffer_dirty(bh);	sync_dirty_buffer(bh);	brelse(bh);	return 0;}

static int simplefs_write_inode(struct inode *inode, struct writeback_control *wbc) {	int err = 0;	struct buffer_head *bh;	struct simplefs_inode *raw_inode;	printk(KERN_INFO "simplefs_write_inode: %ld/n", inode->i_ino);	if (!(raw_inode = simplefs_iget_raw(inode->i_sb, inode->i_ino, &bh)))		return -EIO;	raw_inode->i_mode = inode->i_mode;	raw_inode->i_nlink = inode->i_nlink;	raw_inode->i_size = inode->i_size;	raw_inode->i_time = inode->i_mtime.tv_sec;	mark_buffer_dirty(bh);	if (wbc->sync_mode == WB_SYNC_ALL && buffer_dirty(bh)) {		sync_dirty_buffer(bh);	}	brelse(bh);	return err;}

int sysv_sync_inode(struct inode * inode){        int err = 0;        struct buffer_head *bh;        bh = sysv_update_inode(inode);        if (bh && buffer_dirty(bh)) {                sync_dirty_buffer(bh);                if (buffer_req(bh) && !buffer_uptodate(bh)) {                        printk ("IO error syncing sysv inode [%s:%08lx]/n",                                inode->i_sb->s_id, inode->i_ino);                        err = -1;                }        }        else if (!bh)                err = -1;        brelse (bh);        return err;}

/*==================================================================================	Function	:me2fsSyncSuper	Input		:struct super_block *sb				 < vfs super block >				 struct ext2_super_block *esb				 < buffer cache address of ext2 super block >				 int wait				 < blocking flag >	Output		:void	Return		:void	Description	:synchronize super block==================================================================================*/static void me2fsSyncSuper( struct super_block *sb,							struct ext2_super_block *esb,							int wait ){	struct me2fs_sb_info	*msi;	msi = ME2FS_SB( sb );	clearSuperError( sb );	spin_lock( &msi->s_lock );	esb->s_free_blocks_count = cpu_to_le32( me2fsCountFreeBlocks( sb ) );	esb->s_free_inodes_count = cpu_to_le32( me2fsCountFreeInodes( sb ) );	/* unlock before i/o														*/	spin_unlock( &msi->s_lock );	mark_buffer_dirty( msi->s_sbh );	if( wait )	{		sync_dirty_buffer( msi->s_sbh );	}}

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;}

static int minix_write_inode(struct inode *inode, struct writeback_control *wbc){	int err = 0;	struct buffer_head *bh;	if (INODE_VERSION(inode) == MINIX_V1)		bh = V1_minix_update_inode(inode);	else		bh = V2_minix_update_inode(inode);	if (!bh)		return -EIO;	if (wbc->sync_mode == WB_SYNC_ALL && buffer_dirty(bh)) {		sync_dirty_buffer(bh);		if (buffer_req(bh) && !buffer_uptodate(bh)) {			printk("IO error syncing minix inode [%s:%08lx]/n",				inode->i_sb->s_id, inode->i_ino);			err = -EIO;		}	}	brelse (bh);	return err;}

int sfs_write_inode(struct inode *inode, struct writeback_control *wbc){	int err = 0;	struct buffer_head *bh;	pr_debug("Enter: sfs_write_inode (ino = %ld)/n", inode->i_ino);	bh = sfs_update_inode(inode);	if (!bh)		return -EIO;		if (wbc->sync_mode == WB_SYNC_ALL && buffer_dirty(bh)) {		sync_dirty_buffer(bh);		if (buffer_req(bh) && !buffer_uptodate(bh)) {			pr_debug("IO error syncing sfs inode 0x%lx/n", 				inode->i_ino);			err = -EIO;		}	}	pr_debug("Leave: sfs_write_inode (ino = %ld)/n", inode->i_ino);	brelse(bh);	return err;}