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

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

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

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

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

 /* 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;	struct cifs_tcon *tcon;	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);	struct tcon_link *tlink = cifs_sb_tlink(cifs_sb);	struct cifs_fid fid;	struct cifs_open_parms oparms;	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;	oparms.tcon = tcon;	oparms.cifs_sb = cifs_sb;	oparms.desired_access = access_flags;	oparms.share_access = FILE_SHARE_ALL;	oparms.create_options = create_options;	oparms.disposition = FILE_OPEN;	oparms.path = path;	oparms.fid = &fid;	oparms.reconnect = false;	rc = CIFS_open(xid, &oparms, &oplock, NULL);	if (rc) {		cifs_dbg(VFS, "Unable to open file to set ACL/n");		goto out;	}	rc = CIFSSMBSetCIFSACL(xid, tcon, fid.netfid, pnntsd, acllen, aclflag);	cifs_dbg(NOISY, "SetCIFSACL rc = %d/n", rc);	CIFSSMBClose(xid, tcon, fid.netfid);out:	free_xid(xid);	cifs_put_tlink(tlink);	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;}

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;	unsigned int xid;	int rc, create_options = 0;	struct cifs_tcon *tcon;	struct tcon_link *tlink = cifs_sb_tlink(cifs_sb);	struct cifs_fid fid;	struct cifs_open_parms oparms;	if (IS_ERR(tlink))		return ERR_CAST(tlink);	tcon = tlink_tcon(tlink);	xid = get_xid();	if (backup_cred(cifs_sb))		create_options |= CREATE_OPEN_BACKUP_INTENT;	oparms.tcon = tcon;	oparms.cifs_sb = cifs_sb;	oparms.desired_access = READ_CONTROL;	oparms.share_access = FILE_SHARE_ALL;	oparms.create_options = create_options;	oparms.disposition = FILE_OPEN;	oparms.path = path;	oparms.fid = &fid;	oparms.reconnect = false;	rc = CIFS_open(xid, &oparms, &oplock, NULL);	if (!rc) {		rc = CIFSSMBGetCIFSACL(xid, tcon, fid.netfid, &pntsd, pacllen);		CIFSSMBClose(xid, tcon, fid.netfid);	}	cifs_put_tlink(tlink);	free_xid(xid);	cifs_dbg(FYI, "%s: rc = %d ACL len %d/n", __func__, rc, *pacllen);	if (rc)		return ERR_PTR(rc);	return pntsd;}

intcifs_query_mf_symlink(unsigned int xid, struct cifs_tcon *tcon,		      struct cifs_sb_info *cifs_sb, const unsigned char *path,		      char *pbuf, unsigned int *pbytes_read){	int rc;	int oplock = 0;	struct cifs_fid fid;	struct cifs_open_parms oparms;	struct cifs_io_parms io_parms;	int buf_type = CIFS_NO_BUFFER;	FILE_ALL_INFO file_info;	oparms.tcon = tcon;	oparms.cifs_sb = cifs_sb;	oparms.desired_access = GENERIC_READ;	oparms.create_options = CREATE_NOT_DIR;	oparms.disposition = FILE_OPEN;	oparms.path = path;	oparms.fid = &fid;	oparms.reconnect = false;	rc = CIFS_open(xid, &oparms, &oplock, &file_info);	if (rc)		return rc;	if (file_info.EndOfFile != cpu_to_le64(CIFS_MF_SYMLINK_FILE_SIZE)) {		rc = -ENOENT;		/* it's not a symlink */		goto out;	}	io_parms.netfid = fid.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, pbytes_read, &pbuf, &buf_type);out:	CIFSSMBClose(xid, tcon, fid.netfid);	return rc;}

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

intcifs_create_mf_symlink(unsigned int xid, struct cifs_tcon *tcon,		       struct cifs_sb_info *cifs_sb, const unsigned char *path,		       char *pbuf, unsigned int *pbytes_written){	int rc;	int oplock = 0;	struct cifs_fid fid;	struct cifs_open_parms oparms;	struct cifs_io_parms io_parms;	int create_options = CREATE_NOT_DIR;	if (backup_cred(cifs_sb))		create_options |= CREATE_OPEN_BACKUP_INTENT;	oparms.tcon = tcon;	oparms.cifs_sb = cifs_sb;	oparms.desired_access = GENERIC_WRITE;	oparms.share_access = FILE_SHARE_ALL;	oparms.create_options = create_options;	oparms.disposition = FILE_CREATE;	oparms.path = path;	oparms.fid = &fid;	oparms.reconnect = false;	rc = CIFS_open(xid, &oparms, &oplock, NULL);	if (rc)		return rc;	io_parms.netfid = fid.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, pbytes_written, pbuf, NULL, 0);	CIFSSMBClose(xid, tcon, fid.netfid);	return rc;}

int cifs_create(struct inode *inode, struct dentry *direntry, umode_t mode,		bool excl){	int rc;	unsigned int xid = get_xid();	/*	 * BB below access is probably too much for mknod to request	 *    but we have to do query and setpathinfo so requesting	 *    less could fail (unless we want to request getatr and setatr	 *    permissions (only).  At least for POSIX we do not have to	 *    request so much.	 */	unsigned oflags = O_EXCL | O_CREAT | O_RDWR;	struct tcon_link *tlink;	__u16 fileHandle;	__u32 oplock;	int created = FILE_CREATED;	cFYI(1, "cifs_create parent inode = 0x%p name is: %s and dentry = 0x%p",	     inode, direntry->d_name.name, direntry);	tlink = cifs_sb_tlink(CIFS_SB(inode->i_sb));	rc = PTR_ERR(tlink);	if (IS_ERR(tlink))		goto out_free_xid;	rc = cifs_do_create(inode, direntry, xid, tlink, oflags, mode,			    &oplock, &fileHandle, &created);	if (!rc)		CIFSSMBClose(xid, tlink_tcon(tlink), fileHandle);	cifs_put_tlink(tlink);out_free_xid:	free_xid(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;}

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, //.........这里部分代码省略.........

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

//.........这里部分代码省略.........		rc = 0;		goto lookup_out;	}	/* can not grab the rename sem here since it would	deadlock in the cases (beginning of sys_rename itself)	in which we already have the sb rename sem */	full_path = build_path_from_dentry(direntry);	if (full_path == NULL) {		rc = -ENOMEM;		goto lookup_out;	}	if (direntry->d_inode != NULL) {		cFYI(1, "non-NULL inode in lookup");	} else {		cFYI(1, "NULL inode in lookup");	}	cFYI(1, "Full path: %s inode = 0x%p", full_path, direntry->d_inode);	/* Posix open is only called (at lookup time) for file create now.	 * For opens (rather than creates), because we do not know if it	 * is a file or directory yet, and current Samba no longer allows	 * us to do posix open on dirs, we could end up wasting an open call	 * on what turns out to be a dir. For file opens, we wait to call posix	 * open till cifs_open.  It could be added here (lookup) in the future	 * but the performance tradeoff of the extra network request when EISDIR	 * or EACCES is returned would have to be weighed against the 50%	 * reduction in network traffic in the other paths.	 */	if (pTcon->unix_ext) {		if (nd && !(nd->flags & LOOKUP_DIRECTORY) &&		     (nd->flags & LOOKUP_OPEN) && !pTcon->broken_posix_open &&		     (nd->intent.open.file->f_flags & O_CREAT)) {			rc = cifs_posix_open(full_path, &newInode,					parent_dir_inode->i_sb,					nd->intent.open.create_mode,					nd->intent.open.file->f_flags, &oplock,					&fileHandle, xid);			/*			 * The check below works around a bug in POSIX			 * open in samba versions 3.3.1 and earlier where			 * open could incorrectly fail with invalid parameter.			 * If either that or op not supported returned, follow			 * the normal lookup.			 */			if ((rc == 0) || (rc == -ENOENT))				posix_open = true;			else if ((rc == -EINVAL) || (rc != -EOPNOTSUPP))				pTcon->broken_posix_open = true;		}		if (!posix_open)			rc = cifs_get_inode_info_unix(&newInode, full_path,						parent_dir_inode->i_sb, xid);	} else		rc = cifs_get_inode_info(&newInode, full_path, NULL,				parent_dir_inode->i_sb, xid, NULL);	if ((rc == 0) && (newInode != NULL)) {		d_add(direntry, newInode);		if (posix_open) {			filp = lookup_instantiate_filp(nd, direntry,						       generic_file_open);			if (IS_ERR(filp)) {				rc = PTR_ERR(filp);				CIFSSMBClose(xid, pTcon, fileHandle);				goto lookup_out;			}			cfile = cifs_new_fileinfo(fileHandle, filp, tlink,						  oplock);			if (cfile == NULL) {				fput(filp);				CIFSSMBClose(xid, pTcon, fileHandle);				rc = -ENOMEM;				goto lookup_out;			}		}		/* since paths are not looked up by component - the parent		   directories are presumed to be good here */		renew_parental_timestamps(direntry);	} else if (rc == -ENOENT) {		rc = 0;		direntry->d_time = jiffies;		d_add(direntry, NULL);	/*	if it was once a directory (but how can we tell?) we could do		shrink_dcache_parent(direntry); */	} else if (rc != -EACCES) {		cERROR(1, "Unexpected lookup error %d", rc);		/* We special case check for Access Denied - since that		is a common return code */	}lookup_out:	kfree(full_path);	cifs_put_tlink(tlink);	FreeXid(xid);	return ERR_PTR(rc);}

//.........这里部分代码省略.........	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)				args.gid = (__u64) inode->i_gid;			else				args.gid = (__u64) current_fsgid();		} else {			args.uid = NO_CHANGE_64;			args.gid = NO_CHANGE_64;		}		CIFSSMBUnixSetFileInfo(xid, tcon, &args, fileHandle,					current->tgid);	} else {		/* BB implement mode setting via Windows security		   descriptors e.g. */		/* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/		/* Could set r/o dos attribute if mode & 0222 == 0 */	}cifs_create_get_file_info:	/* server might mask mode so we have to query for it */	if (tcon->unix_ext)		rc = cifs_get_inode_info_unix(&newinode, full_path,					      inode->i_sb, xid);	else {		rc = cifs_get_inode_info(&newinode, full_path, buf,					 inode->i_sb, xid, &fileHandle);		if (newinode) {			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)				newinode->i_mode = mode;			if ((oplock & CIFS_CREATE_ACTION) &&			    (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)) {				newinode->i_uid = current_fsuid();				if (inode->i_mode & S_ISGID)					newinode->i_gid = inode->i_gid;				else					newinode->i_gid = current_fsgid();			}		}	}cifs_create_set_dentry:	if (rc == 0)		d_instantiate(direntry, newinode);	else		cFYI(1, "Create worked, get_inode_info failed rc = %d", rc);	if (newinode && nd) {		struct cifsFileInfo *pfile_info;		struct file *filp;		filp = lookup_instantiate_filp(nd, direntry, generic_file_open);		if (IS_ERR(filp)) {			rc = PTR_ERR(filp);			CIFSSMBClose(xid, tcon, fileHandle);			goto cifs_create_out;		}		pfile_info = cifs_new_fileinfo(fileHandle, filp, tlink, oplock);		if (pfile_info == NULL) {			fput(filp);			CIFSSMBClose(xid, tcon, fileHandle);			rc = -ENOMEM;		}	} else {		CIFSSMBClose(xid, tcon, fileHandle);	}cifs_create_out:	kfree(buf);	kfree(full_path);	cifs_put_tlink(tlink);	FreeXid(xid);	return rc;}

//.........这里部分代码省略.........	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)) {		memcpy(pdev->type, "IntxBLK", 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_ISFIFO) */	CIFSSMBClose(xid, pTcon, fileHandle);	d_drop(direntry);mknod_out:	kfree(full_path);	kfree(buf);	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 = 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,//.........这里部分代码省略.........

static intcifs_do_create(struct inode *inode, struct dentry *direntry, unsigned int xid,	       struct tcon_link *tlink, unsigned oflags, umode_t mode,	       __u32 *oplock, struct cifs_fid *fid, int *created){	int rc = -ENOENT;	int create_options = CREATE_NOT_DIR;	int desired_access;	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);	struct cifs_tcon *tcon = tlink_tcon(tlink);	char *full_path = NULL;	FILE_ALL_INFO *buf = NULL;	struct inode *newinode = NULL;	int disposition;	struct TCP_Server_Info *server = tcon->ses->server;	*oplock = 0;	if (tcon->ses->server->oplocks)		*oplock = REQ_OPLOCK;	full_path = build_path_from_dentry(direntry);	if (full_path == NULL) {		rc = -ENOMEM;		goto out;	}	if (tcon->unix_ext && cap_unix(tcon->ses) && !tcon->broken_posix_open &&	    (CIFS_UNIX_POSIX_PATH_OPS_CAP &			le64_to_cpu(tcon->fsUnixInfo.Capability))) {		rc = cifs_posix_open(full_path, &newinode, inode->i_sb, mode,				     oflags, oplock, &fid->netfid, xid);		switch (rc) {		case 0:			if (newinode == NULL) {				/* query inode info */				goto cifs_create_get_file_info;			}			if (S_ISDIR(newinode->i_mode)) {				CIFSSMBClose(xid, tcon, fid->netfid);				iput(newinode);				rc = -EISDIR;				goto out;			}			if (!S_ISREG(newinode->i_mode)) {				/*				 * The server may allow us to open things like				 * FIFOs, but the client isn't set up to deal				 * with that. If it's not a regular file, just				 * close it and proceed as if it were a normal				 * lookup.				 */				CIFSSMBClose(xid, tcon, fid->netfid);				goto cifs_create_get_file_info;			}			/* success, no need to query */			goto cifs_create_set_dentry;		case -ENOENT:			goto cifs_create_get_file_info;		case -EIO:		case -EINVAL:			/*			 * EIO could indicate that (posix open) operation is not			 * supported, despite what server claimed in capability			 * negotiation.			 *			 * POSIX open in samba versions 3.3.1 and earlier could			 * incorrectly fail with invalid parameter.			 */			tcon->broken_posix_open = true;			break;		case -EREMOTE:		case -EOPNOTSUPP:			/*			 * EREMOTE indicates DFS junction, which is not handled			 * in posix open.  If either that or op not supported			 * returned, follow the normal lookup.			 */			break;		default:			goto out;		}		/*		 * fallthrough to retry, using older open call, this is case		 * where server does not support this SMB level, and falsely		 * claims capability (also get here for DFS case which should be		 * rare for path not covered on files)		 */	}	desired_access = 0;	if (OPEN_FMODE(oflags) & FMODE_READ)		desired_access |= GENERIC_READ; /* is this too little? */	if (OPEN_FMODE(oflags) & FMODE_WRITE)		desired_access |= GENERIC_WRITE;//.........这里部分代码省略.........

//.........这里部分代码省略.........		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {			args.uid = (__u64) current_fsuid();			if (inode->i_mode & S_ISGID)				args.gid = (__u64) inode->i_gid;			else				args.gid = (__u64) current_fsgid();		} else {			args.uid = NO_CHANGE_64;			args.gid = NO_CHANGE_64;		}		CIFSSMBUnixSetInfo(xid, tcon, full_path, &args,			cifs_sb->local_nls,			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);	} else {		/* BB implement mode setting via Windows security		   descriptors e.g. */		/* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/		/* Could set r/o dos attribute if mode & 0222 == 0 */	}CVE_2010_1148_linux2_6_29_cifs_create_get_file_info:	/* server might mask mode so we have to query for it */	if (tcon->unix_ext)		rc = cifs_get_inode_info_unix(&newinode, full_path,					      inode->i_sb, xid);	else {		rc = cifs_get_inode_info(&newinode, full_path, buf,					 inode->i_sb, xid, &fileHandle);		if (newinode) {			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)				newinode->i_mode = mode;			if ((oplock & CIFS_CREATE_ACTION) &&			    (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)) {				newinode->i_uid = current_fsuid();				if (inode->i_mode & S_ISGID)					newinode->i_gid = inode->i_gid;				else					newinode->i_gid = current_fsgid();			}		}	}CVE_2010_1148_linux2_6_29_cifs_create_set_dentry:	if (rc == 0)		setup_cifs_dentry(tcon, direntry, newinode);	else		cFYI(1, ("Create worked, get_inode_info failed rc = %d", rc));	/* nfsd case - nfs srv does not set nd */	if ((nd == NULL) || (!(nd->flags & LOOKUP_OPEN))) {		/* mknod case - do not leave file open */		CIFSSMBClose(xid, tcon, fileHandle);	} else if (newinode) {		struct cifsFileInfo *pCifsFile =			kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);		if (pCifsFile == NULL)			goto CVE_2010_1148_linux2_6_29_cifs_create_out;		pCifsFile->netfid = fileHandle;		pCifsFile->pid = current->tgid;		pCifsFile->pInode = newinode;		pCifsFile->invalidHandle = false;		pCifsFile->closePend     = false;		init_MUTEX(&pCifsFile->fh_sem);		mutex_init(&pCifsFile->lock_mutex);		INIT_LIST_HEAD(&pCifsFile->llist);		atomic_set(&pCifsFile->wrtPending, 0);		/* set the following in open now				pCifsFile->pfile = file; */		write_lock(&GlobalSMBSeslock);		list_add(&pCifsFile->tlist, &tcon->openFileList);		pCifsInode = CIFS_I(newinode);		if (pCifsInode) {			/* if readable file instance put first in list*/			if (write_only) {				list_add_tail(&pCifsFile->flist,					      &pCifsInode->openFileList);			} else {				list_add(&pCifsFile->flist,					 &pCifsInode->openFileList);			}			if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {				pCifsInode->clientCanCacheAll = true;				pCifsInode->clientCanCacheRead = true;				cFYI(1, ("Exclusive Oplock inode %p",					newinode));			} else if ((oplock & 0xF) == OPLOCK_READ)				pCifsInode->clientCanCacheRead = true;		}		write_unlock(&GlobalSMBSeslock);	}CVE_2010_1148_linux2_6_29_cifs_create_out:	kfree(buf);	kfree(full_path);	FreeXid(xid);	return rc;}

//.........这里部分代码省略.........		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));					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_ISFIFO */				CIFSSMBClose(xid, pTcon, fileHandle);				d_drop(direntry);			}			kfree(buf);			/* add code here to set EAs */		}	}	kfree(full_path);	FreeXid(xid);	return rc;}

//.........这里部分代码省略.........	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)) {		memcpy(pdev->type, "IntxCHR", 8);		pdev->major =		      cpu_to_le64(MAJOR(device_number));		pdev->minor =		      cpu_to_le64(MINOR(device_number));		rc = CIFSSMBWrite(xid, &io_parms,			&bytes_written, (char *)pdev,			NULL, 0);	} else if (S_ISBLK(mode)) {		memcpy(pdev->type, "IntxBLK", 8);		pdev->major =		      cpu_to_le64(MAJOR(device_number));		pdev->minor =		      cpu_to_le64(MINOR(device_number));		rc = CIFSSMBWrite(xid, &io_parms,			&bytes_written, (char *)pdev,			NULL, 0);	} /* else if (S_ISFIFO) */	CIFSSMBClose(xid, pTcon, fileHandle);	d_drop(direntry);	/* FIXME: add code here to set EAs */mknod_out:	kfree(full_path);	kfree(buf);	free_xid(xid);	cifs_put_tlink(tlink);	return rc;}

intcifs_atomic_open(struct inode *inode, struct dentry *direntry,		 struct file *file, unsigned oflags, umode_t mode,		 int *opened){	int rc;	unsigned int xid;	struct tcon_link *tlink;	struct cifs_tcon *tcon;	__u16 fileHandle;	__u32 oplock;	struct cifsFileInfo *pfile_info;	/* Posix open is only called (at lookup time) for file create now.  For	 * opens (rather than creates), because we do not know if it is a file	 * or directory yet, and current Samba no longer allows us to do posix	 * open on dirs, we could end up wasting an open call on what turns out	 * to be a dir. For file opens, we wait to call posix open till	 * cifs_open.  It could be added to atomic_open in the future but the	 * performance tradeoff of the extra network request when EISDIR or	 * EACCES is returned would have to be weighed against the 50% reduction	 * in network traffic in the other paths.	 */	if (!(oflags & O_CREAT)) {		struct dentry *res;		/*		 * Check for hashed negative dentry. We have already revalidated		 * the dentry and it is fine. No need to perform another lookup.		 */		if (!d_unhashed(direntry))			return -ENOENT;		res = cifs_lookup(inode, direntry, 0);		if (IS_ERR(res))			return PTR_ERR(res);		return finish_no_open(file, res);	}	rc = check_name(direntry);	if (rc)		return rc;	xid = get_xid();	cFYI(1, "parent inode = 0x%p name is: %s and dentry = 0x%p",	     inode, direntry->d_name.name, direntry);	tlink = cifs_sb_tlink(CIFS_SB(inode->i_sb));	if (IS_ERR(tlink))		goto out_free_xid;	tcon = tlink_tcon(tlink);	rc = cifs_do_create(inode, direntry, xid, tlink, oflags, mode,			    &oplock, &fileHandle, opened);	if (rc)		goto out;	rc = finish_open(file, direntry, generic_file_open, opened);	if (rc) {		CIFSSMBClose(xid, tcon, fileHandle);		goto out;	}	pfile_info = cifs_new_fileinfo(fileHandle, file, tlink, oplock);	if (pfile_info == NULL) {		CIFSSMBClose(xid, tcon, fileHandle);		rc = -ENOMEM;	}out:	cifs_put_tlink(tlink);out_free_xid:	free_xid(xid);	return rc;}

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,//.........这里部分代码省略.........