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

static intcifs_statfs(struct super_block *sb, struct kstatfs *buf){	int xid; 	int rc = -EOPNOTSUPP;	struct cifs_sb_info *cifs_sb;	struct cifsTconInfo *pTcon;	xid = GetXid();	cifs_sb = CIFS_SB(sb);	pTcon = cifs_sb->tcon;	buf->f_type = CIFS_MAGIC_NUMBER;	/* instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO */	buf->f_namelen = PATH_MAX; /* PATH_MAX may be too long - it would 				      presumably be total path, but note				      that some servers (includinng Samba 3)				      have a shorter maximum path */	buf->f_files = 0;	/* undefined */	buf->f_ffree = 0;	/* unlimited */#ifdef CONFIG_CIFS_EXPERIMENTAL/* BB we could add a second check for a QFS Unix capability bit *//* BB FIXME check CIFS_POSIX_EXTENSIONS Unix cap first FIXME BB */    if ((pTcon->ses->capabilities & CAP_UNIX) && (CIFS_POSIX_EXTENSIONS &			le64_to_cpu(pTcon->fsUnixInfo.Capability)))	    rc = CIFSSMBQFSPosixInfo(xid, pTcon, buf);    /* Only need to call the old QFSInfo if failed    on newer one */    if(rc)#endif /* CIFS_EXPERIMENTAL */	rc = CIFSSMBQFSInfo(xid, pTcon, buf);	/*     	   int f_type;	   __fsid_t f_fsid;	   int f_namelen;  */	/* BB get from info in tcon struct at mount time call to QFSAttrInfo */	FreeXid(xid);	return 0;		/* always return success? what if volume is no				   longer available? */}

ssize_t cifs_listxattr(struct dentry * direntry, char * data, 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;	down(&sb->s_vfs_rename_sem);	full_path = build_path_from_dentry(direntry);	up(&sb->s_vfs_rename_sem);	if(full_path == NULL) {		FreeXid(xid);		return -ENOMEM;	}	/* return dos attributes as pseudo xattr */	/* return alt name if available as pseudo attr */	/* if proc/fs/cifs/streamstoxattr is set then		search server for EAs or streams to 		returns as xattrs */	rc = CIFSSMBQAllEAs(xid,pTcon,full_path,data,buf_size,				cifs_sb->local_nls,				cifs_sb->mnt_cifs_flags & 					CIFS_MOUNT_MAP_SPECIAL_CHR);	kfree(full_path);	FreeXid(xid);#endif	return rc;}

intcifs_rmdir(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;	cFYI(1, (" cifs_rmdir, inode = 0x%p with ", inode));	xid = GetXid();	cifs_sb = CIFS_SB(inode->i_sb);	pTcon = cifs_sb->tcon;	down(&inode->i_sb->s_vfs_rename_sem);	full_path = build_path_from_dentry(direntry);	up(&inode->i_sb->s_vfs_rename_sem);	if(full_path == NULL) {		FreeXid(xid);		return -ENOMEM;	}	rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls);	if (!rc) {		inode->i_nlink--;		i_size_write(direntry->d_inode,0);		direntry->d_inode->i_nlink = 0;	}	cifsInode = CIFS_I(direntry->d_inode);	cifsInode->time = 0;	/* force revalidate to go get info when needed */	direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =	    CURRENT_TIME;	if (full_path)		kfree(full_path);	FreeXid(xid);	return rc;}

/* gets root inode */struct inode *cifs_iget(struct super_block *sb, unsigned long ino){	int xid;	struct cifs_sb_info *cifs_sb;	struct inode *inode;	long rc;	inode = iget_locked(sb, ino);	if (!inode)		return ERR_PTR(-ENOMEM);	if (!(inode->i_state & I_NEW))		return inode;	cifs_sb = CIFS_SB(inode->i_sb);	xid = GetXid();	if (cifs_sb->tcon->unix_ext)		rc = cifs_get_inode_info_unix(&inode, "", inode->i_sb, xid);	else		rc = cifs_get_inode_info(&inode, "", NULL, inode->i_sb, xid,					 NULL);	if (rc && cifs_sb->tcon->ipc) {		cFYI(1, ("ipc connection - fake read inode"));		inode->i_mode |= S_IFDIR;		inode->i_nlink = 2;		inode->i_op = &cifs_ipc_inode_ops;		inode->i_fop = &simple_dir_operations;		inode->i_uid = cifs_sb->mnt_uid;		inode->i_gid = cifs_sb->mnt_gid;	} else if (rc) {		_FreeXid(xid);		iget_failed(inode);		return ERR_PTR(rc);	}	unlock_new_inode(inode);	/* can not call macro FreeXid here since in a void func	 * TODO: This is no longer true	 */	_FreeXid(xid);	return inode;}

int cifs_rmdir(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;	cFYI(1, ("cifs_rmdir, inode = 0x%p", inode));	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;	}	rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls,			  cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);	if (!rc) {		drop_nlink(inode);		spin_lock(&direntry->d_inode->i_lock);		i_size_write(direntry->d_inode, 0);		clear_nlink(direntry->d_inode);		spin_unlock(&direntry->d_inode->i_lock);	}	cifsInode = CIFS_I(direntry->d_inode);	cifsInode->time = 0;	/* force revalidate to go get info when				   needed */	direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =		current_fs_time(inode->i_sb);	kfree(full_path);	FreeXid(xid);	return rc;}

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;	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)		rc = -ENOMEM;		if (full_path && (pTcon->ses->capabilities & CAP_UNIX)) {		rc = CIFSSMBUnixSetPerms(xid, pTcon,			full_path, mode, current->euid, current->egid,			device_number, cifs_sb->local_nls);		if(!rc) {			rc = cifs_get_inode_info_unix(&newinode, full_path,						inode->i_sb);			direntry->d_op = &cifs_dentry_ops;			if(rc == 0)				d_instantiate(direntry, newinode);		}	}	if (full_path)		kfree(full_path);	FreeXid(xid);	return rc;}

static intcifs_statfs(struct super_block *sb, struct kstatfs *buf){	int xid, rc = -EOPNOTSUPP;	struct cifs_sb_info *cifs_sb;	struct cifsTconInfo *pTcon;	xid = GetXid();	cifs_sb = CIFS_SB(sb);	pTcon = cifs_sb->tcon;	buf->f_type = CIFS_MAGIC_NUMBER;	/* instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO */	buf->f_namelen = PATH_MAX;	/* PATH_MAX may be too long - it would presumably					   be length of total path, note that some servers may be 					   able to support more than this, but best to be safe					   since Win2k and others can not handle very long filenames */	buf->f_files = 0;	/* undefined */	buf->f_ffree = 0;	/* unlimited */#ifdef CONFIG_CIFS_EXPERIMENTAL/* BB we could add a second check for a QFS Unix capability bit */    if (pTcon->ses->capabilities & CAP_UNIX)	    rc = CIFSSMBQFSPosixInfo(xid, pTcon, buf, cifs_sb->local_nls);    /* Only need to call the old QFSInfo if failed    on newer one */    if(rc)#endif /* CIFS_EXPERIMENTAL */	rc = CIFSSMBQFSInfo(xid, pTcon, buf, cifs_sb->local_nls);	/*     	   int f_type;	   __fsid_t f_fsid;	   int f_namelen;  */	/* BB get from info put in tcon struct at mount time with call to QFSAttrInfo */	FreeXid(xid);	return 0;		/* always return success? what if volume is no longer available? */}

int set_cifs_acl(struct cifs_ntsd *pnntsd, __u32 acllen,			struct inode *inode, const char *path, int aclflag){	int oplock = 0;	int xid, 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 = GetXid();	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:	FreeXid(xid);	cifs_put_tlink(tlink);	return rc;}

static struct cifs_ntsd *get_cifs_acl_by_fid(struct cifs_sb_info *cifs_sb,		__u16 fid, u32 *pacllen){	struct cifs_ntsd *pntsd = NULL;	int xid, rc;	struct tcon_link *tlink = cifs_sb_tlink(cifs_sb);	if (IS_ERR(tlink))		return ERR_CAST(tlink);	xid = GetXid();	rc = CIFSSMBGetCIFSACL(xid, tlink_tcon(tlink), fid, &pntsd, pacllen);	FreeXid(xid);	cifs_put_tlink(tlink);	cFYI(1, "%s: rc = %d ACL len %d", __func__, rc, *pacllen);	if (rc)		return ERR_PTR(rc);	return pntsd;}

int cifs_xstate_get(struct super_block *sb, struct fs_quota_stat *qstats){	int xid;	int rc = 0;	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);	struct cifsTconInfo *pTcon;	if (cifs_sb)		pTcon = cifs_sb->tcon;	else		return -EIO;	xid = GetXid();	if (pTcon) {		cFYI(1, ("pqstats %p", qstats));	} else		rc = -EIO;	FreeXid(xid);	return rc;}

int cifs_xstate_set(struct super_block *sb, unsigned int flags, int operation){	int xid;	int rc = 0;	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);	struct cifsTconInfo *pTcon;	if (cifs_sb)		pTcon = cifs_sb->tcon;	else		return -EIO;	xid = GetXid();	if (pTcon) {		cFYI(1, ("flags: 0x%x operation: 0x%x", flags, operation));	} else		rc = -EIO;	FreeXid(xid);	return rc;}

int cifs_xquota_get(struct super_block *sb, int quota_type, qid_t qid,		    struct fs_disk_quota *pdquota){	int xid;	int rc = 0;	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);	struct cifsTconInfo *pTcon;	if (cifs_sb)		pTcon = cifs_sb->tcon;	else		return -EIO;	xid = GetXid();	if (pTcon) {		cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));	} else		rc = -EIO;	FreeXid(xid);	return rc;}

intcifs_dir_open(struct inode *inode, struct file *file){				/* NB: currently unused since searches are opened in readdir */	int rc = 0;	int xid;	struct cifs_sb_info *cifs_sb;	struct cifsTconInfo *pTcon;	char *full_path = NULL;	xid = GetXid();	cifs_sb = CIFS_SB(inode->i_sb);	pTcon = cifs_sb->tcon;	full_path = build_wildcard_path_from_dentry(file->f_dentry);	cFYI(1, (" inode = 0x%p and full path is %s", inode, full_path));	if (full_path)		kfree(full_path);	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,//.........这里部分代码省略.........

void *cifs_follow_link(struct dentry *direntry, struct nameidata *nd){	struct inode *inode = direntry->d_inode;	int rc = -EACCES;	int xid;	char *full_path = NULL;	char *target_path = ERR_PTR(-ENOMEM);	struct cifs_sb_info *cifs_sb;	struct cifsTconInfo *pTcon;	xid = GetXid();	full_path = build_path_from_dentry(direntry);	if (!full_path)		goto out_no_free;	cFYI(1, ("Full path: %s inode = 0x%p", full_path, inode));	cifs_sb = CIFS_SB(inode->i_sb);	pTcon = cifs_sb->tcon;	target_path = kmalloc(PATH_MAX, GFP_KERNEL);	if (!target_path) {		target_path = ERR_PTR(-ENOMEM);		goto out;	}	/* We could change this to:		if (pTcon->unix_ext)	   but there does not seem any point in refusing to	   get symlink info if we can, even if unix extensions	   turned off for this mount */	if (pTcon->ses->capabilities & CAP_UNIX)		rc = CIFSSMBUnixQuerySymLink(xid, pTcon, full_path,					     target_path,					     PATH_MAX-1,					     cifs_sb->local_nls);	else {		/* BB add read reparse point symlink code here */		/* rc = CIFSSMBQueryReparseLinkInfo */		/* BB Add code to Query ReparsePoint info */		/* BB Add MAC style xsymlink check here if enabled */	}	if (rc == 0) {/* BB Add special case check for Samba DFS symlinks */		target_path[PATH_MAX-1] = 0;	} else {		kfree(target_path);		target_path = ERR_PTR(rc);	}out:	kfree(full_path);out_no_free:	FreeXid(xid);	nd_set_link(nd, target_path);	return NULL;	/* No cookie */}

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 tcon_link *tlink;	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;	cifs_sb = CIFS_SB(sb);	tlink = cifs_sb_tlink(cifs_sb);	if (IS_ERR(tlink))		return PTR_ERR(tlink);	pTcon = tlink_tcon(tlink);	xid = GetXid();	full_path = build_path_from_dentry(direntry);	if (full_path == NULL) {		rc = -ENOMEM;		goto get_ea_exit;	}	/* 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);#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 /* CONFIG_CIFS_POSIX */	} else if (strncmp(ea_name, CIFS_XATTR_CIFS_ACL,				strlen(CIFS_XATTR_CIFS_ACL)) == 0) {#ifdef CONFIG_CIFS_ACL			u32 acllen;			struct cifs_ntsd *pacl;			pacl = get_cifs_acl(cifs_sb, direntry->d_inode,						full_path, &acllen);			if (IS_ERR(pacl)) {				rc = PTR_ERR(pacl);				cERROR(1, "%s: error %zd getting sec desc",						__func__, rc);			} else {				if (ea_value) {					if (acllen > buf_size)						acllen = -ERANGE;					else						memcpy(ea_value, pacl, acllen);				}//.........这里部分代码省略.........

int cifs_setxattr(struct dentry *direntry, const char *ea_name,		  const void *ea_value, size_t value_size, int flags){	int rc = -EOPNOTSUPP;#ifdef CONFIG_CIFS_XATTR	int xid;	struct cifs_sb_info *cifs_sb;	struct tcon_link *tlink;	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;	cifs_sb = CIFS_SB(sb);	tlink = cifs_sb_tlink(cifs_sb);	if (IS_ERR(tlink))		return PTR_ERR(tlink);	pTcon = tlink_tcon(tlink);	xid = GetXid();	full_path = build_path_from_dentry(direntry);	if (full_path == NULL) {		rc = -ENOMEM;		goto set_ea_exit;	}	/* return dos attributes as pseudo xattr */	/* return alt name if available as pseudo attr */	/* if proc/fs/cifs/streamstoxattr is set then		search server for EAs or streams to		returns as xattrs */	if (value_size > MAX_EA_VALUE_SIZE) {		cFYI(1, "size of EA value too large");		rc = -EOPNOTSUPP;		goto set_ea_exit;	}	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 set_ea_exit;		if (strncmp(ea_name, CIFS_XATTR_DOS_ATTRIB, 14) == 0)			cFYI(1, "attempt to set cifs inode metadata");		ea_name += 5; /* skip past user. prefix */		rc = CIFSSMBSetEA(xid, pTcon, full_path, ea_name, ea_value,			(__u16)value_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 set_ea_exit;		ea_name += 4; /* skip past os2. prefix */		rc = CIFSSMBSetEA(xid, pTcon, full_path, ea_name, ea_value,			(__u16)value_size, cifs_sb->local_nls,			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);	} else {		int temp;		temp = strncmp(ea_name, POSIX_ACL_XATTR_ACCESS,			strlen(POSIX_ACL_XATTR_ACCESS));		if (temp == 0) {#ifdef CONFIG_CIFS_POSIX			if (sb->s_flags & MS_POSIXACL)				rc = CIFSSMBSetPosixACL(xid, pTcon, full_path,					ea_value, (const int)value_size,					ACL_TYPE_ACCESS, cifs_sb->local_nls,					cifs_sb->mnt_cifs_flags &						CIFS_MOUNT_MAP_SPECIAL_CHR);			cFYI(1, "set POSIX ACL rc %d", rc);#else			cFYI(1, "set POSIX ACL not supported");#endif		} 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 = CIFSSMBSetPosixACL(xid, pTcon, full_path,					ea_value, (const int)value_size,					ACL_TYPE_DEFAULT, cifs_sb->local_nls,					cifs_sb->mnt_cifs_flags &						CIFS_MOUNT_MAP_SPECIAL_CHR);			cFYI(1, "set POSIX default ACL rc %d", rc);#else			cFYI(1, "set default POSIX ACL not supported");#endif		} else {			cFYI(1, "illegal xattr request %s (only user namespace"				" supported)", ea_name);		  /* BB what if no namespace prefix? */		  /* Should we just pass them to server, except for		  system and perhaps security prefixes? *///.........这里部分代码省略.........

static struct vfsmount *cifs_dfs_do_automount(struct dentry *mntpt){	struct dfs_info3_param *referrals = NULL;	unsigned int num_referrals = 0;	struct cifs_sb_info *cifs_sb;	struct cifs_ses *ses;	char *full_path;	int xid, i;	int rc;	struct vfsmount *mnt;	struct tcon_link *tlink;	cFYI(1, "in %s", __func__);	BUG_ON(IS_ROOT(mntpt));	mnt = ERR_PTR(-ENOMEM);	full_path = build_path_from_dentry(mntpt);	if (full_path == NULL)		goto cdda_exit;	cifs_sb = CIFS_SB(mntpt->d_inode->i_sb);	tlink = cifs_sb_tlink(cifs_sb);	if (IS_ERR(tlink)) {		mnt = ERR_CAST(tlink);		goto free_full_path;	}	ses = tlink_tcon(tlink)->ses;	xid = GetXid();	rc = get_dfs_path(xid, ses, full_path + 1, cifs_sb->local_nls,		&num_referrals, &referrals,		cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);	FreeXid(xid);	cifs_put_tlink(tlink);	mnt = ERR_PTR(-ENOENT);	for (i = 0; i < num_referrals; i++) {		int len;		dump_referral(referrals + i);				len = strlen(referrals[i].node_name);		if (len < 2) {			cERROR(1, "%s: Net Address path too short: %s",					__func__, referrals[i].node_name);			mnt = ERR_PTR(-EINVAL);			break;		}		mnt = cifs_dfs_do_refmount(cifs_sb,				full_path, referrals + i);		cFYI(1, "%s: cifs_dfs_do_refmount:%s , mnt:%p", __func__,					referrals[i].node_name, mnt);		if (!IS_ERR(mnt))			goto success;	}	if (rc != 0)		mnt = ERR_PTR(rc);success:	free_dfs_info_array(referrals, num_referrals);free_full_path:	kfree(full_path);cdda_exit:	cFYI(1, "leaving %s" , __func__);	return mnt;}

bool pgTrigger::IsUpToDate(){	wxString sql = wxT("SELECT xmin FROM pg_trigger WHERE oid = ") + this->GetOidStr();	if (!this->GetDatabase()->GetConnection() || this->GetDatabase()->ExecuteScalar(sql) != NumToStr(GetXid()))		return false;	else		return true;}

struct dentry *cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,	    struct nameidata *nd){	int xid;	int rc = 0; /* to get around spurious gcc warning, set to zero here */	__u32 oplock = 0;	__u16 fileHandle = 0;	bool posix_open = false;	struct cifs_sb_info *cifs_sb;	struct tcon_link *tlink;	struct cifs_tcon *pTcon;	struct cifsFileInfo *cfile;	struct inode *newInode = NULL;	char *full_path = NULL;	struct file *filp;	xid = GetXid();	cFYI(1, "parent inode = 0x%p name is: %s and dentry = 0x%p",	      parent_dir_inode, direntry->d_name.name, direntry);	/* check whether path exists */	cifs_sb = CIFS_SB(parent_dir_inode->i_sb);	tlink = cifs_sb_tlink(cifs_sb);	if (IS_ERR(tlink)) {		FreeXid(xid);		return (struct dentry *)tlink;	}	pTcon = tlink_tcon(tlink);	/*	 * Don't allow the separator character in a path component.	 * The VFS will not allow "/", but "/" is allowed by posix.	 */	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)) {		int i;		for (i = 0; i < direntry->d_name.len; i++)			if (direntry->d_name.name[i] == '//') {				cFYI(1, "Invalid file name");				rc = -EINVAL;				goto lookup_out;			}	}	/*	 * O_EXCL: optimize away the lookup, but don't hash the dentry. Let	 * the VFS handle the create.	 */	if (nd && (nd->flags & LOOKUP_EXCL)) {		d_instantiate(direntry, NULL);		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;//.........这里部分代码省略.........

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 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 = GetXid();	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 (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;	}	/* FIXME: would WRITE_OWNER | WRITE_DAC be better? */	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;	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));//.........这里部分代码省略.........

void *cifs_follow_link(struct dentry *direntry, struct nameidata *nd){	struct inode *inode = direntry->d_inode;	int rc = -ENOMEM;	int xid;	char *full_path = NULL;	char *target_path = NULL;	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);	struct tcon_link *tlink = NULL;	struct cifsTconInfo *tcon;	xid = GetXid();	tlink = cifs_sb_tlink(cifs_sb);	if (IS_ERR(tlink)) {		rc = PTR_ERR(tlink);		tlink = NULL;		goto out;	}	tcon = tlink_tcon(tlink);	/*	 * For now, we just handle symlinks with unix extensions enabled.	 * Eventually we should handle NTFS reparse points, and MacOS	 * symlink support. For instance...	 *	 * rc = CIFSSMBQueryReparseLinkInfo(...)	 *	 * For now, just return -EACCES when the server doesn't support posix	 * extensions. Note that we still allow querying symlinks when posix	 * extensions are manually disabled. We could disable these as well	 * but there doesn't seem to be any harm in allowing the client to	 * read them.	 */	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)	    && !(tcon->ses->capabilities & CAP_UNIX)) {		rc = -EACCES;		goto out;	}	full_path = build_path_from_dentry(direntry);	if (!full_path)		goto out;	cFYI(1, "Full path: %s inode = 0x%p", full_path, inode);	rc = -EACCES;	/*	 * First try Minshall+French Symlinks, if configured	 * and fallback to UNIX Extensions Symlinks.	 */	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)		rc = CIFSQueryMFSymLink(xid, tcon, full_path, &target_path,					cifs_sb->local_nls,					cifs_sb->mnt_cifs_flags &						CIFS_MOUNT_MAP_SPECIAL_CHR);	if ((rc != 0) && (tcon->ses->capabilities & CAP_UNIX))		rc = CIFSSMBUnixQuerySymLink(xid, tcon, full_path, &target_path,					     cifs_sb->local_nls);	kfree(full_path);out:	if (rc != 0) {		kfree(target_path);		target_path = ERR_PTR(rc);	}	FreeXid(xid);	if (tlink)		cifs_put_tlink(tlink);	nd_set_link(nd, target_path);	return NULL;}

static void*cifs_dfs_follow_mountpoint(struct dentry *dentry, struct nameidata *nd){	struct dfs_info3_param *referrals = NULL;	unsigned int num_referrals = 0;	struct cifs_sb_info *cifs_sb;	struct cifsSesInfo *ses;	char *full_path = NULL;	int xid, i;	int rc = 0;	struct vfsmount *mnt = ERR_PTR(-ENOENT);	cFYI(1, "in %s", __func__);	BUG_ON(IS_ROOT(dentry));	xid = GetXid();	dput(nd->path.dentry);	nd->path.dentry = dget(dentry);	cifs_sb = CIFS_SB(dentry->d_inode->i_sb);	ses = cifs_sb->tcon->ses;	if (!ses) {		rc = -EINVAL;		goto out_err;	}	/*	 * The MSDFS spec states that paths in DFS referral requests and	 * responses must be prefixed by a single '/' character instead of	 * the double backslashes usually used in the UNC. This function	 * gives us the latter, so we must adjust the result.	 */	full_path = build_path_from_dentry(dentry);	if (full_path == NULL) {		rc = -ENOMEM;		goto out_err;	}	rc = get_dfs_path(xid, ses , full_path + 1, cifs_sb->local_nls,		&num_referrals, &referrals,		cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);	for (i = 0; i < num_referrals; i++) {		int len;		dump_referral(referrals+i);		/* connect to a node */		len = strlen(referrals[i].node_name);		if (len < 2) {			cERROR(1, "%s: Net Address path too short: %s",					__func__, referrals[i].node_name);			rc = -EINVAL;			goto out_err;		}		mnt = cifs_dfs_do_refmount(cifs_sb,				full_path, referrals + i);		cFYI(1, "%s: cifs_dfs_do_refmount:%s , mnt:%p", __func__,					referrals[i].node_name, mnt);		/* complete mount procedure if we accured submount */		if (!IS_ERR(mnt))			break;	}	/* we need it cause for() above could exit without valid submount */	rc = PTR_ERR(mnt);	if (IS_ERR(mnt))		goto out_err;	rc = add_mount_helper(mnt, nd, &cifs_dfs_automount_list);out:	FreeXid(xid);	free_dfs_info_array(referrals, num_referrals);	kfree(full_path);	cFYI(1, "leaving %s" , __func__);	return ERR_PTR(rc);out_err:	path_put(&nd->path);	goto out;}

int cifs_readdir(struct file *file, void *direntry, filldir_t filldir){	int rc = 0;	int xid, i;	struct cifs_sb_info *cifs_sb;	struct cifsTconInfo *pTcon;	struct cifsFileInfo *cifsFile = NULL;	char *current_entry;	int num_to_fill = 0;	char *tmp_buf = NULL;	char *end_of_smb;	int max_len;	xid = GetXid();	cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);	pTcon = cifs_sb->tcon;	if (pTcon == NULL)		return -EINVAL;	switch ((int) file->f_pos) {	case 0:		if (filldir(direntry, ".", 1, file->f_pos,		     file->f_path.dentry->d_inode->i_ino, DT_DIR) < 0) {			cERROR(1, ("Filldir for current dir failed"));			rc = -ENOMEM;			break;		}		file->f_pos++;	case 1:		if (filldir(direntry, "..", 2, file->f_pos,		     file->f_path.dentry->d_parent->d_inode->i_ino, DT_DIR) < 0) {			cERROR(1, ("Filldir for parent dir failed"));			rc = -ENOMEM;			break;		}		file->f_pos++;	default:		/* 1) If search is active,			is in current search buffer?			if it before then restart search			if after then keep searching till find it */		if (file->private_data == NULL) {			rc = initiate_cifs_search(xid, file);			cFYI(1, ("initiate cifs search rc %d", rc));			if (rc) {				FreeXid(xid);				return rc;			}		}		if (file->private_data == NULL) {			rc = -EINVAL;			FreeXid(xid);			return rc;		}		cifsFile = file->private_data;		if (cifsFile->srch_inf.endOfSearch) {			if (cifsFile->srch_inf.emptyDir) {				cFYI(1, ("End of search, empty dir"));				rc = 0;				break;			}		} /* else {			cifsFile->invalidHandle = true;			CIFSFindClose(xid, pTcon, cifsFile->netfid);		} */		rc = find_cifs_entry(xid, pTcon, file,				&current_entry, &num_to_fill);		if (rc) {			cFYI(1, ("fce error %d", rc));			goto rddir2_exit;		} else if (current_entry != NULL) {			cFYI(1, ("entry %lld found", file->f_pos));		} else {			cFYI(1, ("could not find entry"));			goto rddir2_exit;		}		cFYI(1, ("loop through %d times filling dir for net buf %p",			num_to_fill, cifsFile->srch_inf.ntwrk_buf_start));		max_len = smbCalcSize((struct smb_hdr *)				cifsFile->srch_inf.ntwrk_buf_start);		end_of_smb = cifsFile->srch_inf.ntwrk_buf_start + max_len;		/* To be safe - for UCS to UTF-8 with strings loaded		with the rare long characters alloc more to account for		such multibyte target UTF-8 characters. cifs_unicode.c,		which actually does the conversion, has the same limit */		tmp_buf = kmalloc((2 * NAME_MAX) + 4, GFP_KERNEL);		for (i = 0; (i < num_to_fill) && (rc == 0); i++) {			if (current_entry == NULL) {				/* evaluate whether this case is an error */				cERROR(1, ("past SMB end,  num to fill %d i %d",					  num_to_fill, i));				break;			}			/* if buggy server returns . and .. late do			we want to check for that here? */			rc = cifs_filldir(current_entry, file,//.........这里部分代码省略.........

int cifs_readdir(struct file *file, void *direntry, filldir_t filldir){	int rc = 0;	int xid, i;	struct cifs_tcon *pTcon;	struct cifsFileInfo *cifsFile = NULL;	char *current_entry;	int num_to_fill = 0;	char *tmp_buf = NULL;	char *end_of_smb;	unsigned int max_len;	xid = GetXid();	if (file->private_data == NULL) {		rc = initiate_cifs_search(xid, file);		cFYI(1, "initiate cifs search rc %d", rc);		if (rc)			goto rddir2_exit;	}	switch ((int) file->f_pos) {	case 0:		if (filldir(direntry, ".", 1, file->f_pos,		     file->f_path.dentry->d_inode->i_ino, DT_DIR) < 0) {			cERROR(1, "Filldir for current dir failed");			rc = -ENOMEM;			break;		}		file->f_pos++;	case 1:		if (filldir(direntry, "..", 2, file->f_pos,		     parent_ino(file->f_path.dentry), DT_DIR) < 0) {			cERROR(1, "Filldir for parent dir failed");			rc = -ENOMEM;			break;		}		file->f_pos++;	default:		if (file->private_data == NULL) {			rc = -EINVAL;			FreeXid(xid);			return rc;		}		cifsFile = file->private_data;		if (cifsFile->srch_inf.endOfSearch) {			if (cifsFile->srch_inf.emptyDir) {				cFYI(1, "End of search, empty dir");				rc = 0;				break;			}		} 		pTcon = tlink_tcon(cifsFile->tlink);		rc = find_cifs_entry(xid, pTcon, file,				&current_entry, &num_to_fill);		if (rc) {			cFYI(1, "fce error %d", rc);			goto rddir2_exit;		} else if (current_entry != NULL) {			cFYI(1, "entry %lld found", file->f_pos);		} else {			cFYI(1, "could not find entry");			goto rddir2_exit;		}		cFYI(1, "loop through %d times filling dir for net buf %p",			num_to_fill, cifsFile->srch_inf.ntwrk_buf_start);		max_len = smbCalcSize((struct smb_hdr *)				cifsFile->srch_inf.ntwrk_buf_start);		end_of_smb = cifsFile->srch_inf.ntwrk_buf_start + max_len;		tmp_buf = kmalloc(UNICODE_NAME_MAX, GFP_KERNEL);		if (tmp_buf == NULL) {			rc = -ENOMEM;			break;		}		for (i = 0; (i < num_to_fill) && (rc == 0); i++) {			if (current_entry == NULL) {								cERROR(1, "past SMB end,  num to fill %d i %d",					  num_to_fill, i);				break;			}			rc = cifs_filldir(current_entry, file,					filldir, direntry, tmp_buf, max_len);			if (rc == -EOVERFLOW) {				rc = 0;				break;			}			file->f_pos++;			if (file->f_pos ==				cifsFile->srch_inf.index_of_last_entry) {				cFYI(1, "last entry in buf at pos %lld %s",					file->f_pos, tmp_buf);				cifs_save_resume_key(current_entry, cifsFile);				break;			} else//.........这里部分代码省略.........

intcifs_hardlink(struct dentry *old_file, struct inode *inode,	      struct dentry *direntry){	int rc = -EACCES;	int xid;	char *fromName = NULL;	char *toName = NULL;	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);	struct tcon_link *tlink;	struct cifsTconInfo *pTcon;	struct cifsInodeInfo *cifsInode;	tlink = cifs_sb_tlink(cifs_sb);	if (IS_ERR(tlink))		return PTR_ERR(tlink);	pTcon = tlink_tcon(tlink);	xid = GetXid();	fromName = build_path_from_dentry(old_file);	toName = build_path_from_dentry(direntry);	if ((fromName == NULL) || (toName == NULL)) {		rc = -ENOMEM;		goto cifs_hl_exit;	}	if (pTcon->unix_ext)		rc = CIFSUnixCreateHardLink(xid, pTcon, fromName, toName,					    cifs_sb->local_nls,					    cifs_sb->mnt_cifs_flags &						CIFS_MOUNT_MAP_SPECIAL_CHR);	else {		rc = CIFSCreateHardLink(xid, pTcon, fromName, toName,					cifs_sb->local_nls,					cifs_sb->mnt_cifs_flags &						CIFS_MOUNT_MAP_SPECIAL_CHR);		if ((rc == -EIO) || (rc == -EINVAL))			rc = -EOPNOTSUPP;	}	d_drop(direntry);	/* force new lookup from server of target */	/* if source file is cached (oplocked) revalidate will not go to server	   until the file is closed or oplock broken so update nlinks locally */	if (old_file->d_inode) {		cifsInode = CIFS_I(old_file->d_inode);		if (rc == 0) {			old_file->d_inode->i_nlink++;/* BB should we make this contingent on superblock flag NOATIME? *//*			old_file->d_inode->i_ctime = CURRENT_TIME;*/			/* parent dir timestamps will update from srv			within a second, would it really be worth it			to set the parent dir cifs inode time to zero			to force revalidate (faster) for it too? */		}		/* if not oplocked will force revalidate to get info		   on source file from srv */		cifsInode->time = 0;		/* Will update parent dir timestamps from srv within a second.		   Would it really be worth it to set the parent dir (cifs		   inode) time field to zero to force revalidate on parent		   directory faster ie			CIFS_I(inode)->time = 0;  */	}cifs_hl_exit:	kfree(fromName);	kfree(toName);	FreeXid(xid);	cifs_put_tlink(tlink);	return rc;}

intcifs_symlink(struct inode *inode, struct dentry *direntry, const char *symname){	int rc = -EOPNOTSUPP;	int xid;	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);	struct tcon_link *tlink;	struct cifsTconInfo *pTcon;	char *full_path = NULL;	struct inode *newinode = NULL;	xid = GetXid();	tlink = cifs_sb_tlink(cifs_sb);	if (IS_ERR(tlink)) {		rc = PTR_ERR(tlink);		goto symlink_exit;	}	pTcon = tlink_tcon(tlink);	full_path = build_path_from_dentry(direntry);	if (full_path == NULL) {		rc = -ENOMEM;		goto symlink_exit;	}	cFYI(1, "Full path: %s", full_path);	cFYI(1, "symname is %s", symname);	/* BB what if DFS and this volume is on different share? BB */	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)		rc = CIFSCreateMFSymLink(xid, pTcon, full_path, symname,					 cifs_sb->local_nls,					 cifs_sb->mnt_cifs_flags &						CIFS_MOUNT_MAP_SPECIAL_CHR);	else if (pTcon->unix_ext)		rc = CIFSUnixCreateSymLink(xid, pTcon, full_path, symname,					   cifs_sb->local_nls);	/* else	   rc = CIFSCreateReparseSymLink(xid, pTcon, fromName, toName,					cifs_sb_target->local_nls); */	if (rc == 0) {		if (pTcon->unix_ext)			rc = cifs_get_inode_info_unix(&newinode, full_path,						      inode->i_sb, xid);		else			rc = cifs_get_inode_info(&newinode, full_path, NULL,						 inode->i_sb, xid, NULL);		if (rc != 0) {			cFYI(1, "Create symlink ok, getinodeinfo fail rc = %d",			      rc);		} else {			d_instantiate(direntry, newinode);		}	}symlink_exit:	kfree(full_path);	cifs_put_tlink(tlink);	FreeXid(xid);	return rc;}

intcifs_create(struct inode *inode, struct dentry *direntry, int mode,		struct nameidata *nd){	int rc = -ENOENT;	int xid;	int create_options = CREATE_NOT_DIR;	__u32 oplock = 0;	int oflags;	/*	 * 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.	 */	int desiredAccess = GENERIC_READ | GENERIC_WRITE;	__u16 fileHandle;	struct cifs_sb_info *cifs_sb;	struct tcon_link *tlink;	struct cifs_tcon *tcon;	char *full_path = NULL;	FILE_ALL_INFO *buf = NULL;	struct inode *newinode = NULL;	int disposition = FILE_OVERWRITE_IF;	xid = GetXid();	cifs_sb = CIFS_SB(inode->i_sb);	tlink = cifs_sb_tlink(cifs_sb);	if (IS_ERR(tlink)) {		FreeXid(xid);		return PTR_ERR(tlink);	}	tcon = tlink_tcon(tlink);	if (oplockEnabled)		oplock = REQ_OPLOCK;	if (nd)		oflags = nd->intent.open.file->f_flags;	else		oflags = O_RDONLY | O_CREAT;	full_path = build_path_from_dentry(direntry);	if (full_path == NULL) {		rc = -ENOMEM;		goto cifs_create_out;	}	if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&	    (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, &fileHandle, xid);		/* EIO could indicate that (posix open) operation is not		   supported, despite what server claimed in capability		   negotiation.  EREMOTE indicates DFS junction, which is not		   handled in posix open */		if (rc == 0) {			if (newinode == NULL) /* query inode info */				goto cifs_create_get_file_info;			else /* success, no need to query */				goto cifs_create_set_dentry;		} else if ((rc != -EIO) && (rc != -EREMOTE) &&			 (rc != -EOPNOTSUPP) && (rc != -EINVAL))			goto cifs_create_out;		/* else 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) */	}	if (nd) {		/* if the file is going to stay open, then we		   need to set the desired access properly */		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;//.........这里部分代码省略.........