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

ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos){	struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = len };	struct kiocb kiocb;	ssize_t ret;	init_sync_kiocb(&kiocb, filp);	kiocb.ki_pos = *ppos;	kiocb.ki_left = len;	kiocb.ki_nbytes = len;	for (;;) {		ret = filp->f_op->aio_write(&kiocb, &iov, 1, kiocb.ki_pos);		if (ret != -EIOCBRETRY)			break;		wait_on_retry_sync_kiocb(&kiocb);	}	if (-EIOCBQUEUED == ret)		ret = wait_on_sync_kiocb(&kiocb);	*ppos = kiocb.ki_pos;	return ret;}EXPORT_SYMBOL(do_sync_write);ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos){	ssize_t ret;	struct super_block *sb = file->f_path.dentry->d_sb;	if (!(file->f_mode & FMODE_WRITE))		return -EBADF;	if (!file->f_op || (!file->f_op->write && !file->f_op->aio_write))		return -EINVAL;	if (unlikely(!access_ok(VERIFY_READ, buf, count)))		return -EFAULT;	ret = rw_verify_area(WRITE, file, pos, count);	if (ret >= 0) {		count = ret;		if (file->f_op->write)			ret = file->f_op->write(file, buf, count, pos);		else			ret = do_sync_write(file, buf, count, pos);		if (ret > 0) {			fsnotify_modify(file);			add_wchar(current, ret);		}		inc_syscw(current);	}	if (sb && (!strcmp(sb->s_type->name, "ext4")		|| !strcmp(sb->s_type->name, "fuse")		|| !strcmp(sb->s_type->name, "vfat")))		print_io_dump(WRITE, count);	return ret;}

ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos){   struct kiocb kiocb;   ssize_t ret;   init_sync_kiocb(&kiocb, filp);   kiocb.ki_pos = *ppos;   ret = filp->f_op->aio_write(&kiocb, buf, len, kiocb.ki_pos);   if (-EIOCBQUEUED == ret)      ret = wait_on_sync_kiocb(&kiocb);   *ppos = kiocb.ki_pos;   return ret;}

static ssize_t do_sync_readv_writev(struct file *filp, const struct iovec *iov,		unsigned long nr_segs, size_t len, loff_t *ppos, iov_fn_t fn){	struct kiocb kiocb;	ssize_t ret;	init_sync_kiocb(&kiocb, filp);	kiocb.ki_pos = *ppos;	kiocb.ki_nbytes = len;	ret = fn(&kiocb, iov, nr_segs, kiocb.ki_pos);	if (ret == -EIOCBQUEUED)		ret = wait_on_sync_kiocb(&kiocb);	*ppos = kiocb.ki_pos;	return ret;}

ssize_t do_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos){	struct iovec iov = { .iov_base = buf, .iov_len = len };	struct kiocb kiocb;	ssize_t ret;	init_sync_kiocb(&kiocb, filp);	kiocb.ki_pos = *ppos;	kiocb.ki_nbytes = len;	ret = filp->f_op->aio_read(&kiocb, &iov, 1, kiocb.ki_pos);	if (-EIOCBQUEUED == ret)		ret = wait_on_sync_kiocb(&kiocb);	*ppos = kiocb.ki_pos;	return ret;}

ssize_t new_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos){	struct iovec iov = { .iov_base = buf, .iov_len = len };	struct kiocb kiocb;	struct iov_iter iter;	ssize_t ret;	init_sync_kiocb(&kiocb, filp);	kiocb.ki_pos = *ppos;	kiocb.ki_nbytes = len;	iov_iter_init(&iter, READ, &iov, 1, len);	ret = filp->f_op->read_iter(&kiocb, &iter);	if (-EIOCBQUEUED == ret)		ret = wait_on_sync_kiocb(&kiocb);	*ppos = kiocb.ki_pos;	return ret;}

/** * ecryptfs_read_update_atime * * generic_file_read updates the atime of upper layer inode.  But, it * doesn't give us a chance to update the atime of the lower layer * inode.  This function is a wrapper to generic_file_read.  It * updates the atime of the lower level inode if generic_file_read * returns without any errors. This is to be used only for file reads. * The function to be used for directory reads is ecryptfs_read. */static ssize_t ecryptfs_read_update_atime(struct kiocb *iocb,				struct iov_iter *to){	ssize_t rc;	struct path *path;	struct file *file = iocb->ki_filp;	rc = generic_file_read_iter(iocb, to);	/*	 * Even though this is a async interface, we need to wait	 * for IO to finish to update atime	 */	if (-EIOCBQUEUED == rc)		rc = wait_on_sync_kiocb(iocb);	if (rc >= 0) {		path = ecryptfs_dentry_to_lower_path(file->f_path.dentry);		touch_atime(path);	}	return rc;}

ssize_t vfs_iter_write(struct file *file, struct iov_iter *iter, loff_t *ppos){	struct kiocb kiocb;	ssize_t ret;	if (!file->f_op->write_iter)		return -EINVAL;	init_sync_kiocb(&kiocb, file);	kiocb.ki_pos = *ppos;	kiocb.ki_nbytes = iov_iter_count(iter);	iter->type |= WRITE;	ret = file->f_op->write_iter(&kiocb, iter);	if (ret == -EIOCBQUEUED)		ret = wait_on_sync_kiocb(&kiocb);	if (ret > 0)		*ppos = kiocb.ki_pos;	return ret;}

/** * ecryptfs_read_update_atime * * generic_file_read updates the atime of upper layer inode.  But, it * doesn't give us a chance to update the atime of the lower layer * inode.  This function is a wrapper to generic_file_read.  It * updates the atime of the lower level inode if generic_file_read * returns without any errors. This is to be used only for file reads. * The function to be used for directory reads is ecryptfs_read. */static ssize_t ecryptfs_read_update_atime(struct kiocb *iocb,				const struct iovec *iov,				unsigned long nr_segs, loff_t pos){	ssize_t rc;	struct path *path;	struct file *file = iocb->ki_filp;	rc = generic_file_aio_read(iocb, iov, nr_segs, pos);	/*	 * Even though this is a async interface, we need to wait	 * for IO to finish to update atime	 */	if (-EIOCBQUEUED == rc)		rc = wait_on_sync_kiocb(iocb);	if (rc >= 0) {		path = ecryptfs_dentry_to_lower_path(file->f_path.dentry);		touch_atime(path);	}	return rc;}

ssize_t do_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos){	struct iovec iov = { .iov_base = buf, .iov_len = len };	struct kiocb kiocb;	ssize_t ret;	init_sync_kiocb(&kiocb, filp);	kiocb.ki_pos = *ppos;	kiocb.ki_left = len;	kiocb.ki_nbytes = len;	for (;;) {		ret = do_aio_read(&kiocb, &iov, 1, kiocb.ki_pos);		if (ret != -EIOCBRETRY)			break;		wait_on_retry_sync_kiocb(&kiocb);	}	if (-EIOCBQUEUED == ret)		ret = wait_on_sync_kiocb(&kiocb);	*ppos = kiocb.ki_pos;	return ret;}

ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos){	struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = len };	struct kiocb kiocb;	ssize_t ret;	init_sync_kiocb(&kiocb, filp);	kiocb.ki_pos = *ppos;	kiocb.ki_left = len;	kiocb.ki_nbytes = len;	for (;;) {		ret = filp->f_op->aio_write(&kiocb, &iov, 1, kiocb.ki_pos);		if (ret != -EIOCBRETRY)			break;		wait_on_retry_sync_kiocb(&kiocb);	}	if (-EIOCBQUEUED == ret)		ret = wait_on_sync_kiocb(&kiocb);	*ppos = kiocb.ki_pos;	return ret;}EXPORT_SYMBOL(do_sync_write);ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos){	ssize_t ret;	struct task_struct *tsk = current;	struct kstatfs stat;	static long long store = 0;	unsigned char num = 0;	struct mount *mount_data;	char *file_list[10] = {"ccci_fsd", NULL};#if IO_LOGGER_ENABLE	unsigned long long time1 = 0,timeoffset = 0;	bool add_trace_e = false;	char path_c[20]={0}; 	char *path = NULL;	const char *mount_point = NULL;#endif		mount_data = real_mount(file->f_path.mnt);	if (!memcmp(mount_data->mnt_mountpoint->d_name.name, "data", 5)) {		//printk(KERN_ERR "write data detect %s",file->f_path.dentry->d_name.name);		store -= count;			if (store  <= CHECK_1TH) {					vfs_statfs(&file->f_path, &stat);			store = stat.f_bfree * stat.f_bsize;			if (store <= CHECK_2TH) {				store -= count;				for (; file_list[num] != NULL; num ++) {					if (!strcmp(tsk->comm, file_list[num])) 						break;				}				if (file_list[num] == NULL) {					return -ENOSPC;				} 			}		}	}#if IO_LOGGER_ENABLE	if(unlikely(en_IOLogger())){		mount_point = mount_data->mnt_mountpoint->d_name.name;		if (mount_point){			if((!memcmp(mount_point,"data",4))||(!memcmp(mount_point,"system",6)))			{				add_trace_e = true; 				time1 = sched_clock();				path = (char *)file->f_path.dentry->d_name.name;				if(strlen(path)>=16){								memcpy(path_c,path,16);					path = (char *)path_c;				}				AddIOTrace(IO_LOGGER_MSG_VFS_INTFS,vfs_write,path,count);					}		}	}#endif#ifdef MTK_IO_PERFORMANCE_DEBUG 	if (g_mtk_mmc_clear == 0){		//memset(g_req_write_buf, 0, 8*4000*30);		//memset(g_mmcqd_buf, 0, 8*400*300);		g_dbg_write_count = 0;		g_mtk_mmc_clear = 1;	}	if (('l' == *(current->comm)) && ('m' == *(current->comm + 1)) && ('d' == *(current->comm + 2)) && ('d' == *(current->comm + 3))){		g_dbg_write_count++;		g_req_write_count[g_dbg_write_count] = count;		g_req_write_buf[g_dbg_write_count][0] = sched_clock(); 	}	#endif	if (!(file->f_mode & FMODE_WRITE))		return -EBADF;	if (!file->f_op || (!file->f_op->write && !file->f_op->aio_write))		return -EINVAL;	if (unlikely(!access_ok(VERIFY_READ, buf, count)))		return -EFAULT;//.........这里部分代码省略.........

//.........这里部分代码省略.........			need_isem = 0;		} 		xfs_rw_enter_trace(XFS_DIOWR_ENTER, io, (void *)iovp, segs,				*offset, ioflags);		ret = generic_file_direct_write(iocb, iovp,				&segs, pos, offset, count, ocount);		/*		 * direct-io write to a hole: fall through to buffered I/O		 * for completing the rest of the request.		 */		if (ret >= 0 && ret != count) {			XFS_STATS_ADD(xs_write_bytes, ret);			pos += ret;			count -= ret;			need_isem = 1;			ioflags &= ~IO_ISDIRECT;			xfs_iunlock(xip, iolock);			goto relock;		}	} else {		xfs_rw_enter_trace(XFS_WRITE_ENTER, io, (void *)iovp, segs,				*offset, ioflags);		ret = generic_file_buffered_write(iocb, iovp, segs,				pos, offset, count, ret);	}	current->backing_dev_info = NULL;	if (ret == -EIOCBQUEUED)		ret = wait_on_sync_kiocb(iocb);	if ((ret == -ENOSPC) &&	    DM_EVENT_ENABLED(vp->v_vfsp, xip, DM_EVENT_NOSPACE) &&	    !(ioflags & IO_INVIS)) {		xfs_rwunlock(bdp, locktype);		error = XFS_SEND_NAMESP(xip->i_mount, DM_EVENT_NOSPACE, vp,				DM_RIGHT_NULL, vp, DM_RIGHT_NULL, NULL, NULL,				0, 0, 0); /* Delay flag intentionally  unused */		if (error)			goto out_unlock_isem;		xfs_rwlock(bdp, locktype);		pos = xip->i_d.di_size;		goto retry;	}	if (*offset > xip->i_d.di_size) {		xfs_ilock(xip, XFS_ILOCK_EXCL);		if (*offset > xip->i_d.di_size) {			xip->i_d.di_size = *offset;			i_size_write(inode, *offset);			xip->i_update_core = 1;			xip->i_update_size = 1;		}		xfs_iunlock(xip, XFS_ILOCK_EXCL);	}	error = -ret;	if (ret <= 0)		goto out_unlock_internal;	XFS_STATS_ADD(xs_write_bytes, ret);

//.........这里部分代码省略.........			need_i_mutex = 0;		} 		xfs_rw_enter_trace(XFS_DIOWR_ENTER, io, (void *)iovp, segs,				*offset, ioflags);		ret = generic_file_direct_write(iocb, iovp,				&segs, pos, offset, count, ocount);		/*		 * direct-io write to a hole: fall through to buffered I/O		 * for completing the rest of the request.		 */		if (ret >= 0 && ret != count) {			XFS_STATS_ADD(xs_write_bytes, ret);			pos += ret;			count -= ret;			need_i_mutex = 1;			ioflags &= ~IO_ISDIRECT;			xfs_iunlock(xip, iolock);			goto relock;		}	} else {		xfs_rw_enter_trace(XFS_WRITE_ENTER, io, (void *)iovp, segs,				*offset, ioflags);		ret = generic_file_buffered_write(iocb, iovp, segs,				pos, offset, count, ret);	}	current->backing_dev_info = NULL;	if (ret == -EIOCBQUEUED && !(ioflags & IO_ISAIO))		ret = wait_on_sync_kiocb(iocb);	if ((ret == -ENOSPC) &&	    DM_EVENT_ENABLED(vp->v_vfsp, xip, DM_EVENT_NOSPACE) &&	    !(ioflags & IO_INVIS)) {		xfs_rwunlock(bdp, locktype);		if (need_i_mutex)			mutex_unlock(&inode->i_mutex);		error = XFS_SEND_NAMESP(xip->i_mount, DM_EVENT_NOSPACE, vp,				DM_RIGHT_NULL, vp, DM_RIGHT_NULL, NULL, NULL,				0, 0, 0); /* Delay flag intentionally  unused */		if (error)			goto out_nounlocks;		if (need_i_mutex)			mutex_lock(&inode->i_mutex);		xfs_rwlock(bdp, locktype);		pos = xip->i_d.di_size;		ret = 0;		goto retry;	}	isize = i_size_read(inode);	if (unlikely(ret < 0 && ret != -EFAULT && *offset > isize))		*offset = isize;	if (*offset > xip->i_d.di_size) {		xfs_ilock(xip, XFS_ILOCK_EXCL);		if (*offset > xip->i_d.di_size) {			xip->i_d.di_size = *offset;			i_size_write(inode, *offset);			xip->i_update_core = 1;			xip->i_update_size = 1;

ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos){	struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = len };	struct kiocb kiocb;	ssize_t ret;	init_sync_kiocb(&kiocb, filp);	kiocb.ki_pos = *ppos;	kiocb.ki_left = len;	kiocb.ki_nbytes = len;	for (;;) {		ret = filp->f_op->aio_write(&kiocb, &iov, 1, kiocb.ki_pos);		if (ret != -EIOCBRETRY)			break;		wait_on_retry_sync_kiocb(&kiocb);	}	if (-EIOCBQUEUED == ret)		ret = wait_on_sync_kiocb(&kiocb);	*ppos = kiocb.ki_pos;	return ret;}EXPORT_SYMBOL(do_sync_write);ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos){	ssize_t ret;	if (infocoll_data.fs == file->f_vfsmnt->mnt_root) {		char data[40] = {0};		loff_t offset = pos ? *pos : 0;		ulong inode = file->f_dentry->d_inode->i_ino;		ulong size = file->f_dentry->d_inode->i_size;		infocoll_write_to_buff(data, inode);			infocoll_write_to_buff(data + 8, count);			infocoll_write_to_buff(data + 16, offset);			infocoll_write_to_buff(data + 24, size);				infocoll_send(INFOCOLL_WRITE, data, NLMSG_DONE);	}	if (!(file->f_mode & FMODE_WRITE))		return -EBADF;	if (!file->f_op || (!file->f_op->write && !file->f_op->aio_write))		return -EINVAL;	if (unlikely(!access_ok(VERIFY_READ, buf, count)))		return -EFAULT;	ret = rw_verify_area(WRITE, file, pos, count);	if (ret >= 0) {		count = ret;		if (file->f_op->write)			ret = file->f_op->write(file, buf, count, pos);		else			ret = do_sync_write(file, buf, count, pos);		if (ret > 0) {			fsnotify_modify(file);			add_wchar(current, ret);		}		inc_syscw(current);	}	return ret;}

ssize_t			/* bytes read, or (-)  error */xfs_read(	xfs_inode_t		*ip,	struct kiocb		*iocb,	const struct iovec	*iovp,	unsigned int		segs,	loff_t			*offset,	int			ioflags){	struct file		*file = iocb->ki_filp;	struct inode		*inode = file->f_mapping->host;	xfs_mount_t		*mp = ip->i_mount;	size_t			size = 0;	ssize_t			ret = 0;	xfs_fsize_t		n;	unsigned long		seg;	XFS_STATS_INC(xs_read_calls);	/* START copy & waste from filemap.c */	for (seg = 0; seg < segs; seg++) {		const struct iovec *iv = &iovp[seg];		/*		 * If any segment has a negative length, or the cumulative		 * length ever wraps negative then return -EINVAL.		 */		size += iv->iov_len;		if (unlikely((ssize_t)(size|iv->iov_len) < 0))			return XFS_ERROR(-EINVAL);	}	/* END copy & waste from filemap.c */	if (unlikely(ioflags & IO_ISDIRECT)) {		xfs_buftarg_t	*target =			XFS_IS_REALTIME_INODE(ip) ?				mp->m_rtdev_targp : mp->m_ddev_targp;		if ((*offset & target->bt_smask) ||		    (size & target->bt_smask)) {			if (*offset == ip->i_size) {				return (0);			}			return -XFS_ERROR(EINVAL);		}	}	n = XFS_MAXIOFFSET(mp) - *offset;	if ((n <= 0) || (size == 0))		return 0;	if (n < size)		size = n;	if (XFS_FORCED_SHUTDOWN(mp))		return -EIO;	if (unlikely(ioflags & IO_ISDIRECT))		mutex_lock(&inode->i_mutex);	xfs_ilock(ip, XFS_IOLOCK_SHARED);	if (DM_EVENT_ENABLED(ip, DM_EVENT_READ) && !(ioflags & IO_INVIS)) {		int dmflags = FILP_DELAY_FLAG(file) | DM_SEM_FLAG_RD(ioflags);		int iolock = XFS_IOLOCK_SHARED;		ret = -XFS_SEND_DATA(mp, DM_EVENT_READ, ip, *offset, size,					dmflags, &iolock);		if (ret) {			xfs_iunlock(ip, XFS_IOLOCK_SHARED);			if (unlikely(ioflags & IO_ISDIRECT))				mutex_unlock(&inode->i_mutex);			return ret;		}	}	if (unlikely(ioflags & IO_ISDIRECT)) {		if (inode->i_mapping->nrpages)			ret = -xfs_flushinval_pages(ip, (*offset & PAGE_CACHE_MASK),						    -1, FI_REMAPF_LOCKED);		mutex_unlock(&inode->i_mutex);		if (ret) {			xfs_iunlock(ip, XFS_IOLOCK_SHARED);			return ret;		}	}	xfs_rw_enter_trace(XFS_READ_ENTER, ip,				(void *)iovp, segs, *offset, ioflags);	iocb->ki_pos = *offset;	ret = generic_file_aio_read(iocb, iovp, segs, *offset);	if (ret == -EIOCBQUEUED && !(ioflags & IO_ISAIO))		ret = wait_on_sync_kiocb(iocb);	if (ret > 0)		XFS_STATS_ADD(xs_read_bytes, ret);	xfs_iunlock(ip, XFS_IOLOCK_SHARED);	return ret;}

ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos){	struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = len };	struct kiocb kiocb;	ssize_t ret;	init_sync_kiocb(&kiocb, filp);	kiocb.ki_pos = *ppos;	kiocb.ki_nbytes = len;	ret = filp->f_op->aio_write(&kiocb, &iov, 1, kiocb.ki_pos);	if (-EIOCBQUEUED == ret)		ret = wait_on_sync_kiocb(&kiocb);	*ppos = kiocb.ki_pos;	return ret;}EXPORT_SYMBOL(do_sync_write);ssize_t new_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos){	struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = len };	struct kiocb kiocb;	struct iov_iter iter;	ssize_t ret;	init_sync_kiocb(&kiocb, filp);	kiocb.ki_pos = *ppos;	kiocb.ki_nbytes = len;	iov_iter_init(&iter, WRITE, &iov, 1, len);	ret = filp->f_op->write_iter(&kiocb, &iter);	if (-EIOCBQUEUED == ret)		ret = wait_on_sync_kiocb(&kiocb);	*ppos = kiocb.ki_pos;	return ret;}EXPORT_SYMBOL(new_sync_write);ssize_t __kernel_write(struct file *file, const char *buf, size_t count, loff_t *pos){	mm_segment_t old_fs;	const char __user *p;	ssize_t ret;	if (!(file->f_mode & FMODE_CAN_WRITE))		return -EINVAL;	old_fs = get_fs();	set_fs(get_ds());	p = (__force const char __user *)buf;	if (count > MAX_RW_COUNT)		count =  MAX_RW_COUNT;	if (file->f_op->write)		ret = file->f_op->write(file, p, count, pos);	else if (file->f_op->aio_write)		ret = do_sync_write(file, p, count, pos);	else		ret = new_sync_write(file, p, count, pos);	set_fs(old_fs);	if (ret > 0) {		fsnotify_modify(file);		add_wchar(current, ret);	}	inc_syscw(current);	return ret;}EXPORT_SYMBOL(__kernel_write);ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos){	ssize_t ret;	if (!(file->f_mode & FMODE_WRITE))		return -EBADF;	if (!(file->f_mode & FMODE_CAN_WRITE))		return -EINVAL;	if (unlikely(!access_ok(VERIFY_READ, buf, count)))		return -EFAULT;	ret = rw_verify_area(WRITE, file, pos, count);	if (ret >= 0) {		count = ret;		file_start_write(file);		if (file->f_op->write)			ret = file->f_op->write(file, buf, count, pos);		else if (file->f_op->aio_write)			ret = do_sync_write(file, buf, count, pos);		else			ret = new_sync_write(file, buf, count, pos);		if (ret > 0) {			fsnotify_modify(file);			add_wchar(current, ret);		}		inc_syscw(current);		file_end_write(file);	}//.........这里部分代码省略.........

ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos){	struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = len };	struct kiocb kiocb;	ssize_t ret;	init_sync_kiocb(&kiocb, filp);	kiocb.ki_pos = *ppos;	kiocb.ki_left = len;	kiocb.ki_nbytes = len;	for (;;) {		ret = filp->f_op->aio_write(&kiocb, &iov, 1, kiocb.ki_pos);		if (ret != -EIOCBRETRY)			break;		wait_on_retry_sync_kiocb(&kiocb);	}	if (-EIOCBQUEUED == ret)		ret = wait_on_sync_kiocb(&kiocb);	*ppos = kiocb.ki_pos;	return ret;}EXPORT_SYMBOL(do_sync_write);ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos){	ssize_t ret;	struct task_struct *tsk = current;	struct kstatfs stat;	static long long store = 0;	unsigned char num = 0;	struct mount *mount_data;	char *file_list[10] = {"ccci_fsd", NULL};		mount_data = real_mount(file->f_path.mnt);	if (!memcmp(mount_data->mnt_mountpoint->d_name.name, "data", 5)) {		//printk(KERN_ERR "write data detect %s",file->f_path.dentry->d_name.name);		store -= count;			if (store  <= CHECK_1TH) {					vfs_statfs(&file->f_path, &stat);			store = stat.f_bfree * stat.f_bsize;			if (store <= CHECK_2TH) {				store -= count;				for (; file_list[num] != NULL; num ++) {					if (!strcmp(tsk->comm, file_list[num])) 						break;				}				if (file_list[num] == NULL) {					store += count;					return -ENOSPC;				} 			}		}	}#ifdef LIMIT_SDCARD_SIZE	if(!memcmp(file->f_path.mnt->mnt_sb->s_type->name, "fuse", 5)){			store -= count;		if(store <= (data_free_size_th  + CHECK_1TH*2)){					vfs_statfs(&file->f_path, &stat);			store = stat.f_bfree * stat.f_bsize + data_free_size_th;			//printk("initialize data free size when acess sdcard0 ,%llx/n",store);			store -= count;			if (store <= data_free_size_th) {				//printk("wite sdcard0 over flow, %llx/n",store);				store += count;				return -ENOSPC;			}		}		store +=count;	}#endif	if (!(file->f_mode & FMODE_WRITE))		return -EBADF;	if (!file->f_op || (!file->f_op->write && !file->f_op->aio_write))		return -EINVAL;	if (unlikely(!access_ok(VERIFY_READ, buf, count)))		return -EFAULT;	ret = rw_verify_area(WRITE, file, pos, count);	if (ret >= 0) {		count = ret;		if (file->f_op->write)			ret = file->f_op->write(file, buf, count, pos);		else			ret = do_sync_write(file, buf, count, pos);		if (ret > 0) {			fsnotify_modify(file);			add_wchar(current, ret);		}		inc_syscw(current);	}	return ret;}