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

static struct cifs_ntsd *get_cifs_acl_by_path(struct cifs_sb_info *cifs_sb,		const char *path, u32 *pacllen){	struct cifs_ntsd *pntsd = NULL;	int oplock = 0;	int xid, rc, create_options = 0;	__u16 fid;	struct cifs_tcon *tcon;	struct tcon_link *tlink = cifs_sb_tlink(cifs_sb);	if (IS_ERR(tlink))		return ERR_CAST(tlink);	tcon = tlink_tcon(tlink);	xid = GetXid();	if (backup_cred(cifs_sb))		create_options |= CREATE_OPEN_BACKUP_INTENT;	rc = CIFSSMBOpen(xid, tcon, path, FILE_OPEN, READ_CONTROL,			create_options, &fid, &oplock, NULL, cifs_sb->local_nls,			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);	if (!rc) {		rc = CIFSSMBGetCIFSACL(xid, tcon, fid, &pntsd, pacllen);		CIFSSMBClose(xid, tcon, fid);	}	cifs_put_tlink(tlink);	FreeXid(xid);	cFYI(1, "%s: rc = %d ACL len %d", __func__, rc, *pacllen);	if (rc)		return ERR_PTR(rc);	return pntsd;}

static struct cifs_ntsd *get_cifs_acl_by_path(struct cifs_sb_info *cifs_sb,		const char *path, u32 *pacllen){	struct cifs_ntsd *pntsd = NULL;	int oplock = 0;	int xid, rc;	__u16 fid;	xid = GetXid();	rc = CIFSSMBOpen(xid, cifs_sb->tcon, path, FILE_OPEN, READ_CONTROL, 0,			 &fid, &oplock, NULL, cifs_sb->local_nls,			 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);	if (rc) {		cERROR(1, "Unable to open file to get ACL");		goto out;	}	rc = CIFSSMBGetCIFSACL(xid, cifs_sb->tcon, fid, &pntsd, pacllen);	cFYI(1, "GetCIFSACL rc = %d ACL len %d", rc, *pacllen);	CIFSSMBClose(xid, cifs_sb->tcon, fid); out:	FreeXid(xid);	return pntsd;}

static int set_cifs_acl_by_path(struct cifs_sb_info *cifs_sb, const char *path,		struct cifs_ntsd *pnntsd, u32 acllen){	int oplock = 0;	int xid, rc;	__u16 fid;	xid = GetXid();	rc = CIFSSMBOpen(xid, cifs_sb->tcon, path, FILE_OPEN, WRITE_DAC, 0,			 &fid, &oplock, NULL, cifs_sb->local_nls,			 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);	if (rc) {		cERROR(1, "Unable to open file to set ACL");		goto out;	}	rc = CIFSSMBSetCIFSACL(xid, cifs_sb->tcon, fid, pnntsd, acllen);	cFYI(DBG2, "SetCIFSACL rc = %d", rc);	CIFSSMBClose(xid, cifs_sb->tcon, fid); out:	FreeXid(xid);	return rc;}

int cifs_dir_notify(struct file *file, unsigned long arg){	int xid;	int rc = -EINVAL;	int oplock = FALSE;	struct cifs_sb_info *cifs_sb;	struct cifsTconInfo *pTcon;	char *full_path = NULL;	__u32 filter = FILE_NOTIFY_CHANGE_NAME | FILE_NOTIFY_CHANGE_ATTRIBUTES;	__u16 netfid;	if (experimEnabled == 0)		return 0;	xid = GetXid();#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)	cifs_sb = CIFS_SB(file->f_dentry->d_sb);	pTcon = cifs_sb->tcon;	full_path = build_path_from_dentry(file->f_dentry);#else	cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);	pTcon = cifs_sb->tcon;	full_path = build_path_from_dentry(file->f_path.dentry);#endif	if (full_path == NULL) {		rc = -ENOMEM;	} else {		cFYI(1, ("dir notify on file %s Arg 0x%lx", full_path, arg));		rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN,			GENERIC_READ | SYNCHRONIZE, FILE_SHARE_ALL, 0 /* create options */,			&netfid, &oplock, NULL, cifs_sb->local_nls,			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);		/* BB fixme - add this handle to a notify handle list */		if (rc) {			cFYI(1, ("Could not open directory for notify"));		} else {			filter = convert_to_cifs_notify_flags(arg);			if (filter != 0) {				rc = CIFSSMBNotify(xid, pTcon,					0 /* no subdirs */, netfid,					filter, file, arg & DN_MULTISHOT,					cifs_sb->local_nls);			} else {				rc = -EINVAL;			}			/* BB add code to close file eventually (at unmount			it would close automatically but may be a way			to do it easily when inode freed or when			notify info is cleared/changed */			cFYI(1, ("notify rc %d", rc));		}	}	FreeXid(xid);	return rc;}

/* Retrieve an ACL from the server */static struct cifs_ntsd *get_cifs_acl(u32 *pacllen, struct inode *inode,				       const char *path, const __u16 *pfid){	struct cifsFileInfo *open_file = NULL;	bool unlock_file = false;	int xid;	int rc = -EIO;	__u16 fid;	struct super_block *sb;	struct cifs_sb_info *cifs_sb;	struct cifs_ntsd *pntsd = NULL;	cFYI(1, ("get mode from ACL for %s", path));	if (inode == NULL)		return NULL;	xid = GetXid();	if (pfid == NULL)		open_file = find_readable_file(CIFS_I(inode));	else		fid = *pfid;	sb = inode->i_sb;	if (sb == NULL) {		FreeXid(xid);		return NULL;	}	cifs_sb = CIFS_SB(sb);	if (open_file) {		unlock_file = true;		fid = open_file->netfid;	} else if (pfid == NULL) {		int oplock = 0;		/* open file */		rc = CIFSSMBOpen(xid, cifs_sb->tcon, path, FILE_OPEN,				READ_CONTROL, 0, &fid, &oplock, NULL,				cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &					CIFS_MOUNT_MAP_SPECIAL_CHR);		if (rc != 0) {			cERROR(1, ("Unable to open file to get ACL"));			FreeXid(xid);			return NULL;		}	}	rc = CIFSSMBGetCIFSACL(xid, cifs_sb->tcon, fid, &pntsd, pacllen);	cFYI(1, ("GetCIFSACL rc = %d ACL len %d", rc, *pacllen));	if (unlock_file == true) /* find_readable_file increments ref count */		atomic_dec(&open_file->wrtPending);	else if (pfid == NULL) /* if opened above we have to close the handle */		CIFSSMBClose(xid, cifs_sb->tcon, fid);	/* else handle was passed in by caller */	FreeXid(xid);	return pntsd;}

static intCIFSCreateMFSymLink(const int xid, struct cifs_tcon *tcon,		    const char *fromName, const char *toName,		    struct cifs_sb_info *cifs_sb){	int rc;	int oplock = 0;	int remap;	int create_options = CREATE_NOT_DIR;	__u16 netfid = 0;	u8 *buf;	unsigned int bytes_written = 0;	struct cifs_io_parms io_parms;	struct nls_table *nls_codepage;	nls_codepage = cifs_sb->local_nls;	remap = cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR;	buf = kmalloc(CIFS_MF_SYMLINK_FILE_SIZE, GFP_KERNEL);	if (!buf)		return -ENOMEM;	rc = CIFSFormatMFSymlink(buf, CIFS_MF_SYMLINK_FILE_SIZE, toName);	if (rc != 0) {		kfree(buf);		return rc;	}	if (backup_cred(cifs_sb))		create_options |= CREATE_OPEN_BACKUP_INTENT;	rc = CIFSSMBOpen(xid, tcon, fromName, FILE_CREATE, GENERIC_WRITE,			 create_options, &netfid, &oplock, NULL,			 nls_codepage, remap);	if (rc != 0) {		kfree(buf);		return rc;	}	io_parms.netfid = netfid;	io_parms.pid = current->tgid;	io_parms.tcon = tcon;	io_parms.offset = 0;	io_parms.length = CIFS_MF_SYMLINK_FILE_SIZE;	rc = CIFSSMBWrite(xid, &io_parms, &bytes_written, buf, NULL, 0);	CIFSSMBClose(xid, tcon, netfid);	kfree(buf);	if (rc != 0)		return rc;	if (bytes_written != CIFS_MF_SYMLINK_FILE_SIZE)		return -EIO;	return 0;}

static intCIFSQueryMFSymLink(const int xid, struct cifs_tcon *tcon,		   const unsigned char *searchName, char **symlinkinfo,		   const struct nls_table *nls_codepage, int remap){	int rc;	int oplock = 0;	__u16 netfid = 0;	u8 *buf;	char *pbuf;	unsigned int bytes_read = 0;	int buf_type = CIFS_NO_BUFFER;	unsigned int link_len = 0;	struct cifs_io_parms io_parms;	FILE_ALL_INFO file_info;	rc = CIFSSMBOpen(xid, tcon, searchName, FILE_OPEN, GENERIC_READ,			 CREATE_NOT_DIR, &netfid, &oplock, &file_info,			 nls_codepage, remap);	if (rc != 0)		return rc;	if (file_info.EndOfFile != cpu_to_le64(CIFS_MF_SYMLINK_FILE_SIZE)) {		CIFSSMBClose(xid, tcon, netfid);		/* it's not a symlink */		return -EINVAL;	}	buf = kmalloc(CIFS_MF_SYMLINK_FILE_SIZE, GFP_KERNEL);	if (!buf)		return -ENOMEM;	pbuf = buf;	io_parms.netfid = netfid;	io_parms.pid = current->tgid;	io_parms.tcon = tcon;	io_parms.offset = 0;	io_parms.length = CIFS_MF_SYMLINK_FILE_SIZE;	rc = CIFSSMBRead(xid, &io_parms, &bytes_read, &pbuf, &buf_type);	CIFSSMBClose(xid, tcon, netfid);	if (rc != 0) {		kfree(buf);		return rc;	}	rc = CIFSParseMFSymlink(buf, bytes_read, &link_len, symlinkinfo);	kfree(buf);	if (rc != 0)		return rc;	return 0;}

/* Set an ACL on the server */static int set_cifs_acl(struct cifs_ntsd *pnntsd, __u32 acllen,				struct inode *inode, const char *path){	struct cifsFileInfo *open_file;	bool unlock_file = false;	int xid;	int rc = -EIO;	__u16 fid;	struct super_block *sb;	struct cifs_sb_info *cifs_sb;	cFYI(DBG2, ("set ACL for %s from mode 0x%x", path, inode->i_mode));	if (!inode)		return rc;	sb = inode->i_sb;	if (sb == NULL)		return rc;	cifs_sb = CIFS_SB(sb);	xid = GetXid();	open_file = find_readable_file(CIFS_I(inode));	if (open_file) {		unlock_file = true;		fid = open_file->netfid;	} else {		int oplock = 0;		/* open file */		rc = CIFSSMBOpen(xid, cifs_sb->tcon, path, FILE_OPEN,				WRITE_DAC, 0, &fid, &oplock, NULL,				cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &					CIFS_MOUNT_MAP_SPECIAL_CHR);		if (rc != 0) {			cERROR(1, ("Unable to open file to set ACL"));			FreeXid(xid);			return rc;		}	}	rc = CIFSSMBSetCIFSACL(xid, cifs_sb->tcon, fid, pnntsd, acllen);	cFYI(DBG2, ("SetCIFSACL rc = %d", rc));	if (unlock_file)		atomic_dec(&open_file->wrtPending);	else		CIFSSMBClose(xid, cifs_sb->tcon, fid);	FreeXid(xid);	return rc;}

int cifs_dir_notify(struct file * file, unsigned long arg){	int xid;	int rc = -EINVAL;	int oplock = FALSE;	struct cifs_sb_info *cifs_sb;	struct cifsTconInfo *pTcon;	char *full_path = NULL;	__u32 filter = FILE_NOTIFY_CHANGE_NAME | FILE_NOTIFY_CHANGE_ATTRIBUTES;	__u16 netfid;	xid = GetXid();	cifs_sb = CIFS_SB(file->f_dentry->d_sb);	pTcon = cifs_sb->tcon;	down(&file->f_dentry->d_sb->s_vfs_rename_sem);	full_path = build_path_from_dentry(file->f_dentry);	up(&file->f_dentry->d_sb->s_vfs_rename_sem);	if(full_path == NULL) {		rc = -ENOMEM;	} else {		cERROR(1,("cifs dir notify on file %s with arg 0x%lx",full_path,arg)); /* BB removeme BB */		rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN, 			GENERIC_READ | SYNCHRONIZE, 0 /* create options */,			&netfid, &oplock,NULL, cifs_sb->local_nls);		/* BB fixme - add this handle to a notify handle list */		if(rc) {			cERROR(1,("Could not open directory for notify"));  /* BB remove BB */		} else {			filter = convert_to_cifs_notify_flags(arg);			if(filter != 0) {				rc = CIFSSMBNotify(xid, pTcon, 0 /* no subdirs */, netfid, 					filter, cifs_sb->local_nls);			} else {				rc = -EINVAL;			}			/* BB add code to close file eventually (at unmount			it would close automatically but may be a way			to do it easily when inode freed or when			notify info is cleared/changed */            cERROR(1,("notify rc %d",rc));		}	}		FreeXid(xid);	return rc;}

static intCIFSCreateMFSymLink(const int xid, struct cifs_tcon *tcon,		    const char *fromName, const char *toName,		    const struct nls_table *nls_codepage, int remap){	int rc;	int oplock = 0;	__u16 netfid = 0;	u8 *buf;	unsigned int bytes_written = 0;	struct cifs_io_parms io_parms;	buf = kmalloc(CIFS_MF_SYMLINK_FILE_SIZE, GFP_KERNEL);	if (!buf)		return -ENOMEM;	rc = CIFSFormatMFSymlink(buf, CIFS_MF_SYMLINK_FILE_SIZE, toName);	if (rc != 0) {		kfree(buf);		return rc;	}	rc = CIFSSMBOpen(xid, tcon, fromName, FILE_CREATE, GENERIC_WRITE,			 CREATE_NOT_DIR, &netfid, &oplock, NULL,			 nls_codepage, remap);	if (rc != 0) {		kfree(buf);		return rc;	}	io_parms.netfid = netfid;	io_parms.pid = current->tgid;	io_parms.tcon = tcon;	io_parms.offset = 0;	io_parms.length = CIFS_MF_SYMLINK_FILE_SIZE;	rc = CIFSSMBWrite(xid, &io_parms, &bytes_written, buf, NULL, 0);	CIFSSMBClose(xid, tcon, netfid);	kfree(buf);	if (rc != 0)		return rc;	if (bytes_written != CIFS_MF_SYMLINK_FILE_SIZE)		return -EIO;	return 0;}

 /* Set an ACL on the server */int set_cifs_acl(struct cifs_ntsd *pnntsd, __u32 acllen,			struct inode *inode, const char *path, int aclflag){	int oplock = 0;	unsigned int xid;	int rc, access_flags, create_options = 0;	__u16 fid;	struct cifs_tcon *tcon;	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);	struct tcon_link *tlink = cifs_sb_tlink(cifs_sb);	if (IS_ERR(tlink))		return PTR_ERR(tlink);	tcon = tlink_tcon(tlink);	xid = get_xid();	if (backup_cred(cifs_sb))		create_options |= CREATE_OPEN_BACKUP_INTENT;	if (aclflag == CIFS_ACL_OWNER || aclflag == CIFS_ACL_GROUP)		access_flags = WRITE_OWNER;	else		access_flags = WRITE_DAC;	rc = CIFSSMBOpen(xid, tcon, path, FILE_OPEN, access_flags,			create_options, &fid, &oplock, NULL, cifs_sb->local_nls,			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);	if (rc) {		cERROR(1, "Unable to open file to set ACL");		goto out;	}	rc = CIFSSMBSetCIFSACL(xid, tcon, fid, pnntsd, acllen, aclflag);	cFYI(DBG2, "SetCIFSACL rc = %d", rc);	CIFSSMBClose(xid, tcon, fid);out:	free_xid(xid);	cifs_put_tlink(tlink);	return rc;}

int cifs_mknod(struct inode *inode, struct dentry *direntry, umode_t mode,		dev_t device_number){	int rc = -EPERM;	unsigned int xid;	int create_options = CREATE_NOT_DIR | CREATE_OPTION_SPECIAL;	struct cifs_sb_info *cifs_sb;	struct tcon_link *tlink;	struct cifs_tcon *pTcon;	struct cifs_io_parms io_parms;	char *full_path = NULL;	struct inode *newinode = NULL;	int oplock = 0;	u16 fileHandle;	FILE_ALL_INFO *buf = NULL;	unsigned int bytes_written;	struct win_dev *pdev;	if (!old_valid_dev(device_number))		return -EINVAL;	cifs_sb = CIFS_SB(inode->i_sb);	tlink = cifs_sb_tlink(cifs_sb);	if (IS_ERR(tlink))		return PTR_ERR(tlink);	pTcon = tlink_tcon(tlink);	xid = get_xid();	full_path = build_path_from_dentry(direntry);	if (full_path == NULL) {		rc = -ENOMEM;		goto mknod_out;	}	if (pTcon->unix_ext) {		struct cifs_unix_set_info_args args = {			.mode	= mode & ~current_umask(),			.ctime	= NO_CHANGE_64,			.atime	= NO_CHANGE_64,			.mtime	= NO_CHANGE_64,			.device	= device_number,		};		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {			args.uid = current_fsuid();			args.gid = current_fsgid();		} else {			args.uid = INVALID_UID; /* no change */			args.gid = INVALID_GID; /* no change */		}		rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,					    cifs_sb->local_nls,					    cifs_sb->mnt_cifs_flags &						CIFS_MOUNT_MAP_SPECIAL_CHR);		if (rc)			goto mknod_out;		rc = cifs_get_inode_info_unix(&newinode, full_path,						inode->i_sb, xid);		if (rc == 0)			d_instantiate(direntry, newinode);		goto mknod_out;	}	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL))		goto mknod_out;	cifs_dbg(FYI, "sfu compat create special file/n");	buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);	if (buf == NULL) {		kfree(full_path);		rc = -ENOMEM;		free_xid(xid);		return rc;	}	if (backup_cred(cifs_sb))		create_options |= CREATE_OPEN_BACKUP_INTENT;	rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_CREATE,			 GENERIC_WRITE, create_options,			 &fileHandle, &oplock, buf, cifs_sb->local_nls,			 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);	if (rc)		goto mknod_out;	/* BB Do not bother to decode buf since no local inode yet to put	 * timestamps in, but we can reuse it safely */	pdev = (struct win_dev *)buf;	io_parms.netfid = fileHandle;	io_parms.pid = current->tgid;	io_parms.tcon = pTcon;	io_parms.offset = 0;	io_parms.length = sizeof(struct win_dev);	if (S_ISCHR(mode)) {//.........这里部分代码省略.........

int cifs_rename(struct inode *source_inode, struct dentry *source_direntry,	struct inode *target_inode, struct dentry *target_direntry){	char *fromName;	char *toName;	struct cifs_sb_info *cifs_sb_source;	struct cifs_sb_info *cifs_sb_target;	struct cifsTconInfo *pTcon;	int xid;	int rc = 0;	xid = GetXid();	cifs_sb_target = CIFS_SB(target_inode->i_sb);	cifs_sb_source = CIFS_SB(source_inode->i_sb);	pTcon = cifs_sb_source->tcon;	if (pTcon != cifs_sb_target->tcon) {		FreeXid(xid);		return -EXDEV;	/* BB actually could be allowed if same server,				   but different share.				   Might eventually add support for this */	}	/* we already  have the rename sem so we do not need to grab it again	   here to protect the path integrity */	fromName = build_path_from_dentry(source_direntry);	toName = build_path_from_dentry(target_direntry);	if ((fromName == NULL) || (toName == NULL)) {		rc = -ENOMEM;		goto cifs_rename_exit;	}	rc = CIFSSMBRename(xid, pTcon, fromName, toName,			   cifs_sb_source->local_nls,			   cifs_sb_source->mnt_cifs_flags &				CIFS_MOUNT_MAP_SPECIAL_CHR);	if (rc == -EEXIST) {		/* check if they are the same file because rename of hardlinked		   files is a noop */		FILE_UNIX_BASIC_INFO *info_buf_source;		FILE_UNIX_BASIC_INFO *info_buf_target;		info_buf_source =			kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);		if (info_buf_source != NULL) {			info_buf_target = info_buf_source + 1;			if (pTcon->unix_ext)				rc = CIFSSMBUnixQPathInfo(xid, pTcon, fromName,					info_buf_source,					cifs_sb_source->local_nls,					cifs_sb_source->mnt_cifs_flags &						CIFS_MOUNT_MAP_SPECIAL_CHR);			/* else rc is still EEXIST so will fall through to			   unlink the target and retry rename */			if (rc == 0) {				rc = CIFSSMBUnixQPathInfo(xid, pTcon, toName,						info_buf_target,						cifs_sb_target->local_nls,						/* remap based on source sb */						cifs_sb_source->mnt_cifs_flags &						    CIFS_MOUNT_MAP_SPECIAL_CHR);			}			if ((rc == 0) &&			    (info_buf_source->UniqueId ==			     info_buf_target->UniqueId)) {			/* do not rename since the files are hardlinked which			   is a noop */			} else {			/* we either can not tell the files are hardlinked			   (as with Windows servers) or files are not			   hardlinked so delete the target manually before			   renaming to follow POSIX rather than Windows			   semantics */				cifs_unlink(target_inode, target_direntry);				rc = CIFSSMBRename(xid, pTcon, fromName,						   toName,						   cifs_sb_source->local_nls,						   cifs_sb_source->mnt_cifs_flags						   & CIFS_MOUNT_MAP_SPECIAL_CHR);			}			kfree(info_buf_source);		} /* if we can not get memory just leave rc as EEXIST */	}	if (rc)		cFYI(1, ("rename rc %d", rc));	if ((rc == -EIO) || (rc == -EEXIST)) {		int oplock = FALSE;		__u16 netfid;		/* BB FIXME Is Generic Read correct for rename? */		/* if renaming directory - we should not say CREATE_NOT_DIR,		   need to test renaming open directory, also GENERIC_READ		   might not right be right access to request */		rc = CIFSSMBOpen(xid, pTcon, fromName, FILE_OPEN, GENERIC_READ, FILE_SHARE_ALL,				 CREATE_NOT_DIR, &netfid, &oplock, NULL,				 cifs_sb_source->local_nls,				 cifs_sb_source->mnt_cifs_flags &//.........这里部分代码省略.........

intcifs_create(struct inode *inode, struct dentry *direntry, int mode,		struct nameidata *nd){	int rc = -ENOENT;	int xid;	int create_options = CREATE_NOT_DIR;	int oplock = 0;	int desiredAccess = GENERIC_READ | GENERIC_WRITE;	__u16 fileHandle;	struct cifs_sb_info *cifs_sb;	struct cifsTconInfo *pTcon;	char *full_path = NULL;	FILE_ALL_INFO *buf = NULL;	struct inode *newinode = NULL;	struct cifsFileInfo *pCifsFile = NULL;	struct cifsInodeInfo *pCifsInode;	int disposition = FILE_OVERWRITE_IF;	bool write_only = false;	xid = GetXid();	cifs_sb = CIFS_SB(inode->i_sb);	pTcon = cifs_sb->tcon;	full_path = build_path_from_dentry(direntry);	if (full_path == NULL) {		FreeXid(xid);		return -ENOMEM;	}	if (nd && (nd->flags & LOOKUP_OPEN)) {		int oflags = nd->intent.open.flags;		desiredAccess = 0;		if (oflags & FMODE_READ)			desiredAccess |= GENERIC_READ;		if (oflags & FMODE_WRITE) {			desiredAccess |= GENERIC_WRITE;			if (!(oflags & FMODE_READ))				write_only = true;		}		if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))			disposition = FILE_CREATE;		else if ((oflags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))			disposition = FILE_OVERWRITE_IF;		else if ((oflags & O_CREAT) == O_CREAT)			disposition = FILE_OPEN_IF;		else			cFYI(1, ("Create flag not set in create function"));	}	/* BB add processing to set equivalent of mode - e.g. via CreateX with	   ACLs */	if (oplockEnabled)		oplock = REQ_OPLOCK;	buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);	if (buf == NULL) {		kfree(full_path);		FreeXid(xid);		return -ENOMEM;	}	mode &= ~current->fs->umask;	/*	 * if we're not using unix extensions, see if we need to set	 * ATTR_READONLY on the create call	 */	if (!pTcon->unix_ext && (mode & S_IWUGO) == 0)		create_options |= CREATE_OPTION_READONLY;	if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)		rc = CIFSSMBOpen(xid, pTcon, full_path, disposition,			 desiredAccess, create_options,			 &fileHandle, &oplock, buf, cifs_sb->local_nls,			 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);	else		rc = -EIO; /* no NT SMB support fall into legacy open below */	if (rc == -EIO) {		/* old server, retry the open legacy style */		rc = SMBLegacyOpen(xid, pTcon, full_path, disposition,			desiredAccess, create_options,			&fileHandle, &oplock, buf, cifs_sb->local_nls,			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);	}	if (rc) {		cFYI(1, ("cifs_create returned 0x%x", rc));	} else {		/* If Open reported that we actually created a file		then we now have to set the mode if possible */		if ((pTcon->unix_ext) && (oplock & CIFS_CREATE_ACTION)) {			struct cifs_unix_set_info_args args = {				.mode	= mode,				.ctime	= NO_CHANGE_64,				.atime	= NO_CHANGE_64,				.mtime	= NO_CHANGE_64,//.........这里部分代码省略.........

int cifs_unlink(struct inode *inode, struct dentry *direntry){	int rc = 0;	int xid;	struct cifs_sb_info *cifs_sb;	struct cifsTconInfo *pTcon;	char *full_path = NULL;	struct cifsInodeInfo *cifsInode;	FILE_BASIC_INFO *pinfo_buf;	cFYI(1, (" cifs_unlink, inode = 0x%p with ", inode));	xid = GetXid();	cifs_sb = CIFS_SB(inode->i_sb);	pTcon = cifs_sb->tcon;	/* Unlink can be called from rename so we can not grab the sem here	   since we deadlock otherwise *//*	down(&direntry->d_sb->s_vfs_rename_sem);*/	full_path = build_path_from_dentry(direntry);/*	up(&direntry->d_sb->s_vfs_rename_sem);*/	if (full_path == NULL) {		FreeXid(xid);		return -ENOMEM;	}	rc = CIFSSMBDelFile(xid, pTcon, full_path, cifs_sb->local_nls,			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);	if (!rc) {		if (direntry->d_inode)			direntry->d_inode->i_nlink--;	} else if (rc == -ENOENT) {		d_drop(direntry);	} else if (rc == -ETXTBSY) {		int oplock = FALSE;		__u16 netfid;		rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN, DELETE,				 CREATE_NOT_DIR | CREATE_DELETE_ON_CLOSE,				 &netfid, &oplock, NULL, cifs_sb->local_nls,				 cifs_sb->mnt_cifs_flags & 					CIFS_MOUNT_MAP_SPECIAL_CHR);		if (rc==0) {			CIFSSMBRenameOpenFile(xid, pTcon, netfid, NULL,					      cifs_sb->local_nls, 					      cifs_sb->mnt_cifs_flags & 						CIFS_MOUNT_MAP_SPECIAL_CHR);			CIFSSMBClose(xid, pTcon, netfid);			if (direntry->d_inode)				direntry->d_inode->i_nlink--;		}	} else if (rc == -EACCES) {		/* try only if r/o attribute set in local lookup data? */		pinfo_buf = kmalloc(sizeof(FILE_BASIC_INFO), GFP_KERNEL);		if (pinfo_buf) {			memset(pinfo_buf, 0, sizeof(FILE_BASIC_INFO));			/* ATTRS set to normal clears r/o bit */			pinfo_buf->Attributes = cpu_to_le32(ATTR_NORMAL);			if (!(pTcon->ses->flags & CIFS_SES_NT4))				rc = CIFSSMBSetTimes(xid, pTcon, full_path,						     pinfo_buf,						     cifs_sb->local_nls,						     cifs_sb->mnt_cifs_flags & 							CIFS_MOUNT_MAP_SPECIAL_CHR);			else				rc = -EOPNOTSUPP;			if (rc == -EOPNOTSUPP) {				int oplock = FALSE;				__u16 netfid;			/*	rc = CIFSSMBSetAttrLegacy(xid, pTcon,							  full_path,							  (__u16)ATTR_NORMAL,							  cifs_sb->local_nls); 			   For some strange reason it seems that NT4 eats the			   old setattr call without actually setting the			   attributes so on to the third attempted workaround			   */			/* BB could scan to see if we already have it open			   and pass in pid of opener to function */				rc = CIFSSMBOpen(xid, pTcon, full_path,						 FILE_OPEN, SYNCHRONIZE |						 FILE_WRITE_ATTRIBUTES, 0,						 &netfid, &oplock, NULL,						 cifs_sb->local_nls,						 cifs_sb->mnt_cifs_flags & 						    CIFS_MOUNT_MAP_SPECIAL_CHR);				if (rc==0) {					rc = CIFSSMBSetFileTimes(xid, pTcon,								 pinfo_buf,								 netfid);					CIFSSMBClose(xid, pTcon, netfid);				}			}			kfree(pinfo_buf);		}		if (rc==0) {			rc = CIFSSMBDelFile(xid, pTcon, full_path, //.........这里部分代码省略.........

//.........这里部分代码省略.........		desiredAccess = 0;		if (OPEN_FMODE(oflags) & FMODE_READ)			desiredAccess |= GENERIC_READ; /* is this too little? */		if (OPEN_FMODE(oflags) & FMODE_WRITE)			desiredAccess |= GENERIC_WRITE;		if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))			disposition = FILE_CREATE;		else if ((oflags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))			disposition = FILE_OVERWRITE_IF;		else if ((oflags & O_CREAT) == O_CREAT)			disposition = FILE_OPEN_IF;		else			cFYI(1, "Create flag not set in create function");	}	/* BB add processing to set equivalent of mode - e.g. via CreateX with	   ACLs */	buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);	if (buf == NULL) {		rc = -ENOMEM;		goto cifs_create_out;	}	/*	 * if we're not using unix extensions, see if we need to set	 * ATTR_READONLY on the create call	 */	if (!tcon->unix_ext && (mode & S_IWUGO) == 0)		create_options |= CREATE_OPTION_READONLY;	if (tcon->ses->capabilities & CAP_NT_SMBS)		rc = CIFSSMBOpen(xid, tcon, full_path, disposition,			 desiredAccess, create_options,			 &fileHandle, &oplock, buf, cifs_sb->local_nls,			 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);	else		rc = -EIO; /* no NT SMB support fall into legacy open below */	if (rc == -EIO) {		/* old server, retry the open legacy style */		rc = SMBLegacyOpen(xid, tcon, full_path, disposition,			desiredAccess, create_options,			&fileHandle, &oplock, buf, cifs_sb->local_nls,			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);	}	if (rc) {		cFYI(1, "cifs_create returned 0x%x", rc);		goto cifs_create_out;	}	/* If Open reported that we actually created a file	   then we now have to set the mode if possible */	if ((tcon->unix_ext) && (oplock & CIFS_CREATE_ACTION)) {		struct cifs_unix_set_info_args args = {				.mode	= mode,				.ctime	= NO_CHANGE_64,				.atime	= NO_CHANGE_64,				.mtime	= NO_CHANGE_64,				.device	= 0,		};		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {			args.uid = (__u64) current_fsuid();			if (inode->i_mode & S_ISGID)

int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode,		dev_t device_number){	int rc = -EPERM;	int xid;	struct cifs_sb_info *cifs_sb;	struct cifsTconInfo *pTcon;	char *full_path = NULL;	struct inode *newinode = NULL;	int oplock = 0;	u16 fileHandle;	FILE_ALL_INFO *buf = NULL;	unsigned int bytes_written;	struct win_dev *pdev;	if (!old_valid_dev(device_number))		return -EINVAL;	xid = GetXid();	cifs_sb = CIFS_SB(inode->i_sb);	pTcon = cifs_sb->tcon;	full_path = build_path_from_dentry(direntry);	if (full_path == NULL) {		rc = -ENOMEM;		goto mknod_out;	}	if (pTcon->unix_ext) {		struct cifs_unix_set_info_args args = {			.mode	= mode & ~current_umask(),			.ctime	= NO_CHANGE_64,			.atime	= NO_CHANGE_64,			.mtime	= NO_CHANGE_64,			.device	= device_number,		};		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {			args.uid = (__u64) current_fsuid();			args.gid = (__u64) current_fsgid();		} else {			args.uid = NO_CHANGE_64;			args.gid = NO_CHANGE_64;		}		rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,					    cifs_sb->local_nls,					    cifs_sb->mnt_cifs_flags &						CIFS_MOUNT_MAP_SPECIAL_CHR);		if (rc)			goto mknod_out;		rc = cifs_get_inode_info_unix(&newinode, full_path,						inode->i_sb, xid);		if (pTcon->nocase)			direntry->d_op = &cifs_ci_dentry_ops;		else			direntry->d_op = &cifs_dentry_ops;		if (rc == 0)			d_instantiate(direntry, newinode);		goto mknod_out;	}	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL))		goto mknod_out;	cFYI(1, "sfu compat create special file");	buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);	if (buf == NULL) {		kfree(full_path);		rc = -ENOMEM;		FreeXid(xid);		return rc;	}	rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_CREATE,			 GENERIC_WRITE, CREATE_NOT_DIR | CREATE_OPTION_SPECIAL,			 &fileHandle, &oplock, buf, cifs_sb->local_nls,			 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);	if (rc)		goto mknod_out;	/* BB Do not bother to decode buf since no local inode yet to put	 * timestamps in, but we can reuse it safely */	pdev = (struct win_dev *)buf;	if (S_ISCHR(mode)) {		memcpy(pdev->type, "IntxCHR", 8);		pdev->major =		      cpu_to_le64(MAJOR(device_number));		pdev->minor =		      cpu_to_le64(MINOR(device_number));		rc = CIFSSMBWrite(xid, pTcon,			fileHandle,			sizeof(struct win_dev),			0, &bytes_written, (char *)pdev,			NULL, 0);	} else if (S_ISBLK(mode)) {//.........这里部分代码省略.........

intcifs_unlink(struct inode *inode, struct dentry *direntry){	int rc = 0;	int xid;	struct cifs_sb_info *cifs_sb;	struct cifsTconInfo *pTcon;	char *full_path = NULL;	struct cifsInodeInfo *cifsInode;	FILE_BASIC_INFO * pinfo_buf;	cFYI(1, (" cifs_unlink, inode = 0x%p with ", inode));	xid = GetXid();	cifs_sb = CIFS_SB(inode->i_sb);	pTcon = cifs_sb->tcon;/* Unlink can be called from rename so we can not grab	the sem here since we deadlock otherwise *//*	down(&direntry->d_sb->s_vfs_rename_sem);*/	full_path = build_path_from_dentry(direntry);/*	up(&direntry->d_sb->s_vfs_rename_sem);*/	if(full_path == NULL) {		FreeXid(xid);		return -ENOMEM;	}	rc = CIFSSMBDelFile(xid, pTcon, full_path, cifs_sb->local_nls);	if (!rc) {		direntry->d_inode->i_nlink--;	} else if (rc == -ENOENT) {		d_drop(direntry);	} else if (rc == -ETXTBSY) {		int oplock = FALSE;		__u16 netfid;		rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN, DELETE, 				CREATE_NOT_DIR | CREATE_DELETE_ON_CLOSE,				&netfid, &oplock, NULL, cifs_sb->local_nls);		if(rc==0) {			CIFSSMBRenameOpenFile(xid,pTcon,netfid,				NULL, cifs_sb->local_nls);			CIFSSMBClose(xid, pTcon, netfid);			direntry->d_inode->i_nlink--;		}	} else if (rc == -EACCES) {		/* try only if r/o attribute set in local lookup data? */		pinfo_buf = (FILE_BASIC_INFO *)kmalloc(sizeof(FILE_BASIC_INFO),GFP_KERNEL);		if(pinfo_buf) {			memset(pinfo_buf,0,sizeof(FILE_BASIC_INFO));        		/* ATTRS set to normal clears r/o bit */			pinfo_buf->Attributes = cpu_to_le32(ATTR_NORMAL);			rc = CIFSSMBSetTimes(xid, pTcon, full_path, pinfo_buf,				cifs_sb->local_nls);			kfree(pinfo_buf);		}		if(rc==0) {			rc = CIFSSMBDelFile(xid, pTcon, full_path, cifs_sb->local_nls);			if (!rc) {				direntry->d_inode->i_nlink--;			} else if (rc == -ETXTBSY) {				int oplock = FALSE;				__u16 netfid;				rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN, DELETE,						CREATE_NOT_DIR | CREATE_DELETE_ON_CLOSE,						&netfid, &oplock, NULL, cifs_sb->local_nls);				if(rc==0) {					CIFSSMBRenameOpenFile(xid,pTcon,netfid,NULL,cifs_sb->local_nls);					CIFSSMBClose(xid, pTcon, netfid);		                        direntry->d_inode->i_nlink--;				}			/* BB if rc = -ETXTBUSY goto the rename logic BB */			}		}	}	cifsInode = CIFS_I(direntry->d_inode);	cifsInode->time = 0;	/* will force revalidate to get info when needed */	direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =	    CURRENT_TIME;	cifsInode = CIFS_I(inode);	cifsInode->time = 0;	/* force revalidate of dir as well */	if (full_path)		kfree(full_path);	FreeXid(xid);	return rc;}

intcifs_rename(struct inode *source_inode, struct dentry *source_direntry,	    struct inode *target_inode, struct dentry *target_direntry){	char *fromName;	char *toName;	struct cifs_sb_info *cifs_sb_source;	struct cifs_sb_info *cifs_sb_target;	struct cifsTconInfo *pTcon;	int xid;	int rc = 0;	xid = GetXid();	cifs_sb_target = CIFS_SB(target_inode->i_sb);	cifs_sb_source = CIFS_SB(source_inode->i_sb);	pTcon = cifs_sb_source->tcon;	if (pTcon != cifs_sb_target->tcon) {		FreeXid(xid);    		return -EXDEV;	/* BB actually could be allowed if same server, but                     different share. Might eventually add support for this */	}	/* we already  have the rename sem so we do not need	to grab it again here to protect the path integrity */	fromName = build_path_from_dentry(source_direntry);	toName = build_path_from_dentry(target_direntry);	if((fromName == NULL) || (toName == NULL)) {		rc = -ENOMEM;		goto cifs_rename_exit;	}	rc = CIFSSMBRename(xid, pTcon, fromName, toName,			   cifs_sb_source->local_nls);	if(rc == -EEXIST) {		/* check if they are the same file 		because rename of hardlinked files is a noop */		FILE_UNIX_BASIC_INFO * info_buf_source;		FILE_UNIX_BASIC_INFO * info_buf_target;		info_buf_source = 			kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),GFP_KERNEL);		if(info_buf_source != NULL) {			info_buf_target = info_buf_source+1;			rc = CIFSSMBUnixQPathInfo(xid, pTcon, fromName, 				info_buf_source, cifs_sb_source->local_nls);			if(rc == 0) {				rc = CIFSSMBUnixQPathInfo(xid,pTcon,toName,						info_buf_target,						cifs_sb_target->local_nls);			}			if((rc == 0) && 				(info_buf_source->UniqueId == 				 info_buf_target->UniqueId)) {			/* do not rename since the files are hardlinked 			   which is a noop */			} else {			/* we either can not tell the files are hardlinked			(as with Windows servers) or files are not hardlinked 			so delete the target manually before renaming to			follow POSIX rather than Windows semantics */				cifs_unlink(target_inode, target_direntry);				rc = CIFSSMBRename(xid, pTcon, fromName, toName,					cifs_sb_source->local_nls);			}			kfree(info_buf_source);		} /* if we can not get memory just leave rc as EEXIST */	}	if((rc == -EIO)||(rc == -EEXIST)) {		int oplock = FALSE;		__u16 netfid;		rc = CIFSSMBOpen(xid, pTcon, fromName, FILE_OPEN, GENERIC_READ,					CREATE_NOT_DIR,					&netfid, &oplock, NULL, cifs_sb_source->local_nls);		if(rc==0) {			CIFSSMBRenameOpenFile(xid,pTcon,netfid,					toName, cifs_sb_source->local_nls);			CIFSSMBClose(xid, pTcon, netfid);		}	}cifs_rename_exit:	if (fromName)		kfree(fromName);	if (toName)		kfree(toName);	FreeXid(xid);	return rc;}

intcifs_readlink(struct dentry *direntry, char __user *pBuffer, int buflen){	struct inode *inode = direntry->d_inode;	int rc = -EACCES;	int xid;	int oplock = 0;	struct cifs_sb_info *cifs_sb;	struct cifsTconInfo *pTcon;	char *full_path = NULL;	char *tmpbuffer;	int len;	__u16 fid;	xid = GetXid();	cifs_sb = CIFS_SB(inode->i_sb);	pTcon = cifs_sb->tcon;/* BB would it be safe against deadlock to grab this sem      even though rename itself grabs the sem and calls lookup? *//*       mutex_lock(&inode->i_sb->s_vfs_rename_mutex);*/	full_path = build_path_from_dentry(direntry);/*       mutex_unlock(&inode->i_sb->s_vfs_rename_mutex);*/	if (full_path == NULL) {		FreeXid(xid);		return -ENOMEM;	}	cFYI(1,	     ("Full path: %s inode = 0x%p pBuffer = 0x%p buflen = %d",	      full_path, inode, pBuffer, buflen));	if (buflen > PATH_MAX)		len = PATH_MAX;	else		len = buflen;	tmpbuffer = kmalloc(len, GFP_KERNEL);	if (tmpbuffer == NULL) {		kfree(full_path);		FreeXid(xid);		return -ENOMEM;	}/* BB add read reparse point symlink code and	Unix extensions symlink code here BB *//* We could disable this based on pTcon->unix_ext flag instead ... but why? */	if (cifs_sb->tcon->ses->capabilities & CAP_UNIX)		rc = CIFSSMBUnixQuerySymLink(xid, pTcon, full_path,				tmpbuffer,				len - 1,				cifs_sb->local_nls);	else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {		cERROR(1, ("SFU style symlinks not implemented yet"));		/* add open and read as in fs/cifs/inode.c */	} else {		rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN, GENERIC_READ, FILE_SHARE_ALL,				OPEN_REPARSE_POINT, &fid, &oplock, NULL,				cifs_sb->local_nls,				cifs_sb->mnt_cifs_flags &					CIFS_MOUNT_MAP_SPECIAL_CHR);		if (!rc) {			rc = CIFSSMBQueryReparseLinkInfo(xid, pTcon, full_path,				tmpbuffer,				len - 1,				fid,				cifs_sb->local_nls);			if (CIFSSMBClose(xid, pTcon, fid)) {				cFYI(1, ("Error closing junction point "					 "(open for ioctl)"));			}			/* If it is a DFS junction earlier we would have gotten			   PATH_NOT_COVERED returned from server so we do			   not need to request the DFS info here */		}	}	/* BB Anything else to do to handle recursive links? */	/* BB Should we be using page ops here? */	/* BB null terminate returned string in pBuffer? BB */	if (rc == 0) {		rc = vfs_readlink(direntry, pBuffer, len, tmpbuffer);		cFYI(1,		     ("vfs_readlink called from cifs_readlink returned %d",		      rc));	}	kfree(tmpbuffer);	kfree(full_path);	FreeXid(xid);	return rc;}

//.........这里部分代码省略.........	disposition = FILE_OVERWRITE_IF;	if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))		disposition = FILE_CREATE;	else if ((oflags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))		disposition = FILE_OVERWRITE_IF;	else if ((oflags & O_CREAT) == O_CREAT)		disposition = FILE_OPEN_IF;	else		cFYI(1, "Create flag not set in create function");	share_access = cifs_get_share_flags(oflags);	/* BB add processing to set equivalent of mode - e.g. via CreateX with	   ACLs */	buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);	if (buf == NULL) {		rc = -ENOMEM;		goto out;	}	/*	 * if we're not using unix extensions, see if we need to set	 * ATTR_READONLY on the create call	 */	if (!tcon->unix_ext && (mode & S_IWUGO) == 0)		create_options |= CREATE_OPTION_READONLY;	if (backup_cred(cifs_sb))		create_options |= CREATE_OPEN_BACKUP_INTENT;	if (tcon->ses->capabilities & CAP_NT_SMBS)		rc = CIFSSMBOpen(xid, tcon, full_path, disposition,			 desiredAccess, share_access, create_options,			 fileHandle, oplock, buf, cifs_sb->local_nls,			 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);	else		rc = -EIO; /* no NT SMB support fall into legacy open below */	if (rc == -EIO) {		/* old server, retry the open legacy style */		rc = SMBLegacyOpen(xid, tcon, full_path, disposition,			desiredAccess, create_options,			fileHandle, oplock, buf, cifs_sb->local_nls,			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);	}	if (rc) {		cFYI(1, "cifs_create returned 0x%x", rc);		goto out;	}	/* If Open reported that we actually created a file	   then we now have to set the mode if possible */	if ((tcon->unix_ext) && (*oplock & CIFS_CREATE_ACTION)) {		struct cifs_unix_set_info_args args = {				.mode	= mode,				.ctime	= NO_CHANGE_64,				.atime	= NO_CHANGE_64,				.mtime	= NO_CHANGE_64,				.device	= 0,		};		*created |= FILE_CREATED;		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {			args.uid = (__u64) current_fsuid();

//.........这里部分代码省略.........			desiredAccess |= GENERIC_WRITE;			if (!(oflags & FMODE_READ))				write_only = true;		}		if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))			disposition = FILE_CREATE;		else if ((oflags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))			disposition = FILE_OVERWRITE_IF;		else if ((oflags & O_CREAT) == O_CREAT)			disposition = FILE_OPEN_IF;		else			cFYI(1, ("Create flag not set in create function"));	}	/* BB add processing to set equivalent of mode - e.g. via CreateX with	   ACLs */	buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);	if (buf == NULL) {		kfree(full_path);		FreeXid(xid);		return -ENOMEM;	}	/*	 * if we're not using unix extensions, see if we need to set	 * ATTR_READONLY on the create call	 */	if (!tcon->unix_ext && (mode & S_IWUGO) == 0)		create_options |= CREATE_OPTION_READONLY;	if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)		rc = CIFSSMBOpen(xid, tcon, full_path, disposition,			 desiredAccess, create_options,			 &fileHandle, &oplock, buf, cifs_sb->local_nls,			 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);	else		rc = -EIO; /* no NT SMB support fall into legacy open below */	if (rc == -EIO) {		/* old server, retry the open legacy style */		rc = SMBLegacyOpen(xid, tcon, full_path, disposition,			desiredAccess, create_options,			&fileHandle, &oplock, buf, cifs_sb->local_nls,			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);	}	if (rc) {		cFYI(1, ("CVE_2010_1148_linux2_6_29_cifs_create returned 0x%x", rc));		goto CVE_2010_1148_linux2_6_29_cifs_create_out;	}	/* If Open reported that we actually created a file	   then we now have to set the mode if possible */	if ((tcon->unix_ext) && (oplock & CIFS_CREATE_ACTION)) {		struct cifs_unix_set_info_args args = {				.mode	= mode,				.ctime	= NO_CHANGE_64,				.atime	= NO_CHANGE_64,				.mtime	= NO_CHANGE_64,				.device	= 0,		};		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {			args.uid = (__u64) current_fsuid();			if (inode->i_mode & S_ISGID)

int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode,		dev_t device_number){	int rc = -EPERM;	int xid;	struct cifs_sb_info *cifs_sb;	struct cifsTconInfo *pTcon;	char *full_path = NULL;	struct inode * newinode = NULL;	if (!old_valid_dev(device_number))		return -EINVAL;	xid = GetXid();	cifs_sb = CIFS_SB(inode->i_sb);	pTcon = cifs_sb->tcon;	full_path = build_path_from_dentry(direntry);	if (full_path == NULL)		rc = -ENOMEM;	else if (pTcon->ses->capabilities & CAP_UNIX) {		mode &= ~current->fs->umask;		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {			rc = CIFSSMBUnixSetPerms(xid, pTcon, full_path,				mode, (__u64)current->fsuid,				(__u64)current->fsgid,				device_number, cifs_sb->local_nls,				cifs_sb->mnt_cifs_flags &					CIFS_MOUNT_MAP_SPECIAL_CHR);		} else {			rc = CIFSSMBUnixSetPerms(xid, pTcon,				full_path, mode, (__u64)-1, (__u64)-1,				device_number, cifs_sb->local_nls,				cifs_sb->mnt_cifs_flags &					CIFS_MOUNT_MAP_SPECIAL_CHR);		}		if (!rc) {			rc = cifs_get_inode_info_unix(&newinode, full_path,						inode->i_sb, xid);			if (pTcon->nocase)				direntry->d_op = &cifs_ci_dentry_ops;			else				direntry->d_op = &cifs_dentry_ops;			if (rc == 0)				d_instantiate(direntry, newinode);		}	} else {		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {			int oplock = 0;			u16 fileHandle;			FILE_ALL_INFO * buf;			cFYI(1, ("sfu compat create special file"));			buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);			if (buf == NULL) {				kfree(full_path);				FreeXid(xid);				return -ENOMEM;			}			rc = CIFSSMBOpen(xid, pTcon, full_path,					 FILE_CREATE, /* fail if exists */					 GENERIC_WRITE /* BB would					  WRITE_OWNER | WRITE_DAC be better? */,					 /* Create a file and set the					    file attribute to SYSTEM */					 CREATE_NOT_DIR | CREATE_OPTION_SPECIAL,					 &fileHandle, &oplock, buf,					 cifs_sb->local_nls,					 cifs_sb->mnt_cifs_flags &					    CIFS_MOUNT_MAP_SPECIAL_CHR);			/* BB FIXME - add handling for backlevel servers			   which need legacy open and check for all			   calls to SMBOpen for fallback to SMBLeagcyOpen */			if (!rc) {				/* BB Do not bother to decode buf since no				   local inode yet to put timestamps in,				   but we can reuse it safely */				int bytes_written;				struct win_dev *pdev;				pdev = (struct win_dev *)buf;				if (S_ISCHR(mode)) {					memcpy(pdev->type, "IntxCHR", 8);					pdev->major =					      cpu_to_le64(MAJOR(device_number));					pdev->minor =					      cpu_to_le64(MINOR(device_number));					rc = CIFSSMBWrite(xid, pTcon,						fileHandle,						sizeof(struct win_dev),						0, &bytes_written, (char *)pdev,						NULL, 0);				} else if (S_ISBLK(mode)) {					memcpy(pdev->type, "IntxBLK", 8);					pdev->major =					      cpu_to_le64(MAJOR(device_number));//.........这里部分代码省略.........

intcifs_readlink(struct dentry *direntry, char __user *pBuffer, int buflen){	struct inode *inode = direntry->d_inode;	int rc = -EACCES;	int xid;	int oplock = FALSE;	struct cifs_sb_info *cifs_sb;	struct cifsTconInfo *pTcon;	char *full_path = NULL;	char *tmp_path = NULL;	char *tmpbuffer;	unsigned char *referrals = NULL;	unsigned int num_referrals = 0;	int len;	__u16 fid;	xid = GetXid();	cifs_sb = CIFS_SB(inode->i_sb);	pTcon = cifs_sb->tcon;/* BB would it be safe against deadlock to grab this sem      even though rename itself grabs the sem and calls lookup? *//*       mutex_lock(&inode->i_sb->s_vfs_rename_mutex);*/	full_path = build_path_from_dentry(direntry);/*       mutex_unlock(&inode->i_sb->s_vfs_rename_mutex);*/	if (full_path == NULL) {		FreeXid(xid);		return -ENOMEM;	}	cFYI(1,	     ("Full path: %s inode = 0x%p pBuffer = 0x%p buflen = %d",	      full_path, inode, pBuffer, buflen));	if (buflen > PATH_MAX)		len = PATH_MAX;	else		len = buflen;	tmpbuffer = kmalloc(len, GFP_KERNEL);	if (tmpbuffer == NULL) {		kfree(full_path);		FreeXid(xid);		return -ENOMEM;	}/* BB add read reparse point symlink code and	Unix extensions symlink code here BB *//* We could disable this based on pTcon->unix_ext flag instead ... but why? */	if (cifs_sb->tcon->ses->capabilities & CAP_UNIX)		rc = CIFSSMBUnixQuerySymLink(xid, pTcon, full_path,				tmpbuffer,				len - 1,				cifs_sb->local_nls);	else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {		cERROR(1, ("SFU style symlinks not implemented yet"));		/* add open and read as in fs/cifs/inode.c */	} else {		rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN, GENERIC_READ,				OPEN_REPARSE_POINT, &fid, &oplock, NULL,				cifs_sb->local_nls,				cifs_sb->mnt_cifs_flags &					CIFS_MOUNT_MAP_SPECIAL_CHR);		if (!rc) {			rc = CIFSSMBQueryReparseLinkInfo(xid, pTcon, full_path,				tmpbuffer,				len - 1,				fid,				cifs_sb->local_nls);			if (CIFSSMBClose(xid, pTcon, fid)) {				cFYI(1, ("Error closing junction point "					 "(open for ioctl)"));			}			if (rc == -EIO) {				/* Query if DFS Junction */				tmp_path =					kmalloc(MAX_TREE_SIZE + MAX_PATHCONF + 1,						GFP_KERNEL);				if (tmp_path) {					strncpy(tmp_path, pTcon->treeName,						MAX_TREE_SIZE);					strncat(tmp_path, full_path,						MAX_PATHCONF);					rc = get_dfs_path(xid, pTcon->ses,						tmp_path,						cifs_sb->local_nls,						&num_referrals, &referrals,						cifs_sb->mnt_cifs_flags &						    CIFS_MOUNT_MAP_SPECIAL_CHR);					cFYI(1, ("Get DFS for %s rc = %d ",						tmp_path, rc));					if ((num_referrals == 0) && (rc == 0))						rc = -EACCES;					else {						cFYI(1, ("num referral: %d",							num_referrals));						if (referrals) {							cFYI(1,("referral string: %s", referrals));							strncpy(tmpbuffer,								referrals,//.........这里部分代码省略.........

intCIFSCheckMFSymlink(struct cifs_fattr *fattr,		   const unsigned char *path,		   struct cifs_sb_info *cifs_sb, int xid){	int rc;	int oplock = 0;	__u16 netfid = 0;	struct tcon_link *tlink;	struct cifsTconInfo *pTcon;	u8 *buf;	char *pbuf;	unsigned int bytes_read = 0;	int buf_type = CIFS_NO_BUFFER;	unsigned int link_len = 0;	FILE_ALL_INFO file_info;	if (!CIFSCouldBeMFSymlink(fattr))		/* it's not a symlink */		return 0;	tlink = cifs_sb_tlink(cifs_sb);	if (IS_ERR(tlink))		return PTR_ERR(tlink);	pTcon = tlink_tcon(tlink);	rc = CIFSSMBOpen(xid, pTcon, path, FILE_OPEN, GENERIC_READ,			 CREATE_NOT_DIR, &netfid, &oplock, &file_info,			 cifs_sb->local_nls,			 cifs_sb->mnt_cifs_flags &				CIFS_MOUNT_MAP_SPECIAL_CHR);	if (rc != 0)		goto out;	if (file_info.EndOfFile != CIFS_MF_SYMLINK_FILE_SIZE) {		CIFSSMBClose(xid, pTcon, netfid);		/* it's not a symlink */		goto out;	}	buf = kmalloc(CIFS_MF_SYMLINK_FILE_SIZE, GFP_KERNEL);	if (!buf) {		rc = -ENOMEM;		goto out;	}	pbuf = buf;	rc = CIFSSMBRead(xid, pTcon, netfid,			 CIFS_MF_SYMLINK_FILE_SIZE /* length */,			 0 /* offset */,			 &bytes_read, &pbuf, &buf_type);	CIFSSMBClose(xid, pTcon, netfid);	if (rc != 0) {		kfree(buf);		goto out;	}	rc = CIFSParseMFSymlink(buf, bytes_read, &link_len, NULL);	kfree(buf);	if (rc == -EINVAL) {		/* it's not a symlink */		rc = 0;		goto out;	}	if (rc != 0)		goto out;	/* it is a symlink */	fattr->cf_eof = link_len;	fattr->cf_mode &= ~S_IFMT;	fattr->cf_mode |= S_IFLNK | S_IRWXU | S_IRWXG | S_IRWXO;	fattr->cf_dtype = DT_LNK;out:	cifs_put_tlink(tlink);	return rc;}

ssize_t cifs_getxattr(struct dentry *direntry, const char *ea_name,	void *ea_value, size_t buf_size){	ssize_t rc = -EOPNOTSUPP;#ifdef CONFIG_CIFS_XATTR	int xid;	struct cifs_sb_info *cifs_sb;	struct cifsTconInfo *pTcon;	struct super_block *sb;	char *full_path;	if (direntry == NULL)		return -EIO;	if (direntry->d_inode == NULL)		return -EIO;	sb = direntry->d_inode->i_sb;	if (sb == NULL)		return -EIO;	xid = GetXid();	cifs_sb = CIFS_SB(sb);	pTcon = cifs_sb->tcon;	full_path = build_path_from_dentry(direntry);	if (full_path == NULL) {		rc = -ENOMEM;		FreeXid(xid);		return rc;	}	/* return dos attributes as pseudo xattr */	/* return alt name if available as pseudo attr */	if (ea_name == NULL) {		cFYI(1, "Null xattr names not supported");	} else if (strncmp(ea_name, CIFS_XATTR_USER_PREFIX, 5) == 0) {		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)			goto get_ea_exit;		if (strncmp(ea_name, CIFS_XATTR_DOS_ATTRIB, 14) == 0) {			cFYI(1, "attempt to query cifs inode metadata");			/* revalidate/getattr then populate from inode */		} /* BB add else when above is implemented */		ea_name += 5; /* skip past user. prefix */		rc = CIFSSMBQAllEAs(xid, pTcon, full_path, ea_name, ea_value,			buf_size, cifs_sb->local_nls,			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);	} else if (strncmp(ea_name, CIFS_XATTR_OS2_PREFIX, 4) == 0) {		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)			goto get_ea_exit;		ea_name += 4; /* skip past os2. prefix */		rc = CIFSSMBQAllEAs(xid, pTcon, full_path, ea_name, ea_value,			buf_size, cifs_sb->local_nls,			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);	} else if (strncmp(ea_name, POSIX_ACL_XATTR_ACCESS,			  strlen(POSIX_ACL_XATTR_ACCESS)) == 0) {#ifdef CONFIG_CIFS_POSIX		if (sb->s_flags & MS_POSIXACL)			rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,				ea_value, buf_size, ACL_TYPE_ACCESS,				cifs_sb->local_nls,				cifs_sb->mnt_cifs_flags &					CIFS_MOUNT_MAP_SPECIAL_CHR);#ifdef CONFIG_CIFS_EXPERIMENTAL		else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {			__u16 fid;			int oplock = 0;			struct cifs_ntsd *pacl = NULL;			__u32 buflen = 0;			if (experimEnabled)				rc = CIFSSMBOpen(xid, pTcon, full_path,					FILE_OPEN, GENERIC_READ, FILE_SHARE_ALL, 0, &fid,					&oplock, NULL, cifs_sb->local_nls,					cifs_sb->mnt_cifs_flags &					CIFS_MOUNT_MAP_SPECIAL_CHR);			/* else rc is EOPNOTSUPP from above */			if (rc == 0) {				rc = CIFSSMBGetCIFSACL(xid, pTcon, fid, &pacl,						      &buflen);				CIFSSMBClose(xid, pTcon, fid);			}		}#endif /* EXPERIMENTAL */#else		cFYI(1, "query POSIX ACL not supported yet");#endif /* CONFIG_CIFS_POSIX */	} else if (strncmp(ea_name, POSIX_ACL_XATTR_DEFAULT,			  strlen(POSIX_ACL_XATTR_DEFAULT)) == 0) {#ifdef CONFIG_CIFS_POSIX		if (sb->s_flags & MS_POSIXACL)			rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,				ea_value, buf_size, ACL_TYPE_DEFAULT,				cifs_sb->local_nls,				cifs_sb->mnt_cifs_flags &					CIFS_MOUNT_MAP_SPECIAL_CHR);#else		cFYI(1, "query POSIX default ACL not supported yet");#endif	} else if (strncmp(ea_name,//.........这里部分代码省略.........