brintos / linux-shallow public Read only

1/* SPDX-License-Identifier: LGPL-2.1 */2/*3 *4 *   Copyright (C) International Business Machines  Corp., 2002,20085 *   Author(s): Steve French (sfrench@us.ibm.com)6 *              Jeremy Allison (jra@samba.org)7 *8 */9#ifndef _CIFS_GLOB_H10#define _CIFS_GLOB_H11 12#include <linux/in.h>13#include <linux/in6.h>14#include <linux/inet.h>15#include <linux/slab.h>16#include <linux/scatterlist.h>17#include <linux/mm.h>18#include <linux/mempool.h>19#include <linux/workqueue.h>20#include <linux/utsname.h>21#include <linux/sched/mm.h>22#include <linux/netfs.h>23#include "cifs_fs_sb.h"24#include "cifsacl.h"25#include <crypto/internal/hash.h>26#include <uapi/linux/cifs/cifs_mount.h>27#include "../common/smb2pdu.h"28#include "smb2pdu.h"29#include <linux/filelock.h>30 31#define SMB_PATH_MAX 26032#define CIFS_PORT 44533#define RFC1001_PORT 13934 35/*36 * The sizes of various internal tables and strings37 */38#define MAX_UID_INFO 1639#define MAX_SES_INFO 240#define MAX_TCON_INFO 441 42#define MAX_TREE_SIZE (2 + CIFS_NI_MAXHOST + 1 + CIFS_MAX_SHARE_LEN + 1)43 44#define CIFS_MIN_RCV_POOL 445 46#define MAX_REOPEN_ATT	5 /* these many maximum attempts to reopen a file */47/*48 * default attribute cache timeout (jiffies)49 */50#define CIFS_DEF_ACTIMEO (1 * HZ)51 52/*53 * max sleep time before retry to server54 */55#define CIFS_MAX_SLEEP 200056 57/*58 * max attribute cache timeout (jiffies) - 2^3059 */60#define CIFS_MAX_ACTIMEO (1 << 30)61 62/*63 * Max persistent and resilient handle timeout (milliseconds).64 * Windows durable max was 960000 (16 minutes)65 */66#define SMB3_MAX_HANDLE_TIMEOUT 96000067 68/*69 * MAX_REQ is the maximum number of requests that WE will send70 * on one socket concurrently.71 */72#define CIFS_MAX_REQ 3276773 74#define RFC1001_NAME_LEN 1575#define RFC1001_NAME_LEN_WITH_NULL (RFC1001_NAME_LEN + 1)76 77/* maximum length of ip addr as a string (including ipv6 and sctp) */78#define SERVER_NAME_LENGTH 8079#define SERVER_NAME_LEN_WITH_NULL     (SERVER_NAME_LENGTH + 1)80 81/* echo interval in seconds */82#define SMB_ECHO_INTERVAL_MIN 183#define SMB_ECHO_INTERVAL_MAX 60084#define SMB_ECHO_INTERVAL_DEFAULT 6085 86/* smb multichannel query server interfaces interval in seconds */87#define SMB_INTERFACE_POLL_INTERVAL	60088 89/* maximum number of PDUs in one compound */90#define MAX_COMPOUND 791 92/*93 * Default number of credits to keep available for SMB3.94 * This value is chosen somewhat arbitrarily. The Windows client95 * defaults to 128 credits, the Windows server allows clients up to96 * 512 credits (or 8K for later versions), and the NetApp server97 * does not limit clients at all.  Choose a high enough default value98 * such that the client shouldn't limit performance, but allow mount99 * to override (until you approach 64K, where we limit credits to 65000100 * to reduce possibility of seeing more server credit overflow bugs.101 */102#define SMB2_MAX_CREDITS_AVAILABLE 32000103 104#include "cifspdu.h"105 106#ifndef XATTR_DOS_ATTRIB107#define XATTR_DOS_ATTRIB "user.DOSATTRIB"108#endif109 110#define CIFS_MAX_WORKSTATION_LEN  (__NEW_UTS_LEN + 1)  /* reasonable max for client */111 112#define CIFS_DFS_ROOT_SES(ses) ((ses)->dfs_root_ses ?: (ses))113 114/*115 * CIFS vfs client Status information (based on what we know.)116 */117 118/* associated with each connection */119enum statusEnum {120	CifsNew = 0,121	CifsGood,122	CifsExiting,123	CifsNeedReconnect,124	CifsNeedNegotiate,125	CifsInNegotiate,126};127 128/* associated with each smb session */129enum ses_status_enum {130	SES_NEW = 0,131	SES_GOOD,132	SES_EXITING,133	SES_NEED_RECON,134	SES_IN_SETUP135};136 137/* associated with each tree connection to the server */138enum tid_status_enum {139	TID_NEW = 0,140	TID_GOOD,141	TID_EXITING,142	TID_NEED_RECON,143	TID_NEED_TCON,144	TID_IN_TCON,145	TID_NEED_FILES_INVALIDATE, /* currently unused */146	TID_IN_FILES_INVALIDATE147};148 149enum securityEnum {150	Unspecified = 0,	/* not specified */151	NTLMv2,			/* Legacy NTLM auth with NTLMv2 hash */152	RawNTLMSSP,		/* NTLMSSP without SPNEGO, NTLMv2 hash */153	Kerberos,		/* Kerberos via SPNEGO */154};155 156enum cifs_reparse_type {157	CIFS_REPARSE_TYPE_NFS,158	CIFS_REPARSE_TYPE_WSL,159	CIFS_REPARSE_TYPE_DEFAULT = CIFS_REPARSE_TYPE_NFS,160};161 162static inline const char *cifs_reparse_type_str(enum cifs_reparse_type type)163{164	switch (type) {165	case CIFS_REPARSE_TYPE_NFS:166		return "nfs";167	case CIFS_REPARSE_TYPE_WSL:168		return "wsl";169	default:170		return "unknown";171	}172}173 174struct session_key {175	unsigned int len;176	char *response;177};178 179/* crypto hashing related structure/fields, not specific to a sec mech */180struct cifs_secmech {181	struct shash_desc *md5; /* md5 hash function, for CIFS/SMB1 signatures */182	struct shash_desc *hmacsha256; /* hmac-sha256 hash function, for SMB2 signatures */183	struct shash_desc *sha512; /* sha512 hash function, for SMB3.1.1 preauth hash */184	struct shash_desc *aes_cmac; /* block-cipher based MAC function, for SMB3 signatures */185 186	struct crypto_aead *enc; /* smb3 encryption AEAD TFM (AES-CCM and AES-GCM) */187	struct crypto_aead *dec; /* smb3 decryption AEAD TFM (AES-CCM and AES-GCM) */188};189 190/* per smb session structure/fields */191struct ntlmssp_auth {192	bool sesskey_per_smbsess; /* whether session key is per smb session */193	__u32 client_flags; /* sent by client in type 1 ntlmsssp exchange */194	__u32 server_flags; /* sent by server in type 2 ntlmssp exchange */195	unsigned char ciphertext[CIFS_CPHTXT_SIZE]; /* sent to server */196	char cryptkey[CIFS_CRYPTO_KEY_SIZE]; /* used by ntlmssp */197};198 199struct cifs_cred {200	int uid;201	int gid;202	int mode;203	int cecount;204	struct smb_sid osid;205	struct smb_sid gsid;206	struct cifs_ntace *ntaces;207	struct smb_ace *aces;208};209 210struct cifs_open_info_data {211	bool adjust_tz;212	union {213		bool reparse_point;214		bool symlink;215	};216	struct {217		/* ioctl response buffer */218		struct {219			int buftype;220			struct kvec iov;221		} io;222		__u32 tag;223		union {224			struct reparse_data_buffer *buf;225			struct reparse_posix_data *posix;226		};227	} reparse;228	struct {229		__u8		eas[SMB2_WSL_MAX_QUERY_EA_RESP_SIZE];230		unsigned int	eas_len;231	} wsl;232	char *symlink_target;233	struct smb_sid posix_owner;234	struct smb_sid posix_group;235	union {236		struct smb2_file_all_info fi;237		struct smb311_posix_qinfo posix_fi;238	};239};240 241/*242 *****************************************************************243 * Except the CIFS PDUs themselves all the244 * globally interesting structs should go here245 *****************************************************************246 */247 248/*249 * A smb_rqst represents a complete request to be issued to a server. It's250 * formed by a kvec array, followed by an array of pages. Page data is assumed251 * to start at the beginning of the first page.252 */253struct smb_rqst {254	struct kvec	*rq_iov;	/* array of kvecs */255	unsigned int	rq_nvec;	/* number of kvecs in array */256	struct iov_iter	rq_iter;	/* Data iterator */257	struct folio_queue *rq_buffer;	/* Buffer for encryption */258};259 260struct mid_q_entry;261struct TCP_Server_Info;262struct cifsFileInfo;263struct cifs_ses;264struct cifs_tcon;265struct dfs_info3_param;266struct cifs_fattr;267struct smb3_fs_context;268struct cifs_fid;269struct cifs_io_subrequest;270struct cifs_io_parms;271struct cifs_search_info;272struct cifsInodeInfo;273struct cifs_open_parms;274struct cifs_credits;275 276struct smb_version_operations {277	int (*send_cancel)(struct TCP_Server_Info *, struct smb_rqst *,278			   struct mid_q_entry *);279	bool (*compare_fids)(struct cifsFileInfo *, struct cifsFileInfo *);280	/* setup request: allocate mid, sign message */281	struct mid_q_entry *(*setup_request)(struct cifs_ses *,282					     struct TCP_Server_Info *,283					     struct smb_rqst *);284	/* setup async request: allocate mid, sign message */285	struct mid_q_entry *(*setup_async_request)(struct TCP_Server_Info *,286						struct smb_rqst *);287	/* check response: verify signature, map error */288	int (*check_receive)(struct mid_q_entry *, struct TCP_Server_Info *,289			     bool);290	void (*add_credits)(struct TCP_Server_Info *server,291			    struct cifs_credits *credits,292			    const int optype);293	void (*set_credits)(struct TCP_Server_Info *, const int);294	int * (*get_credits_field)(struct TCP_Server_Info *, const int);295	unsigned int (*get_credits)(struct mid_q_entry *);296	__u64 (*get_next_mid)(struct TCP_Server_Info *);297	void (*revert_current_mid)(struct TCP_Server_Info *server,298				   const unsigned int val);299	/* data offset from read response message */300	unsigned int (*read_data_offset)(char *);301	/*302	 * Data length from read response message303	 * When in_remaining is true, the returned data length is in304	 * message field DataRemaining for out-of-band data read (e.g through305	 * Memory Registration RDMA write in SMBD).306	 * Otherwise, the returned data length is in message field DataLength.307	 */308	unsigned int (*read_data_length)(char *, bool in_remaining);309	/* map smb to linux error */310	int (*map_error)(char *, bool);311	/* find mid corresponding to the response message */312	struct mid_q_entry * (*find_mid)(struct TCP_Server_Info *, char *);313	void (*dump_detail)(void *buf, struct TCP_Server_Info *ptcp_info);314	void (*clear_stats)(struct cifs_tcon *);315	void (*print_stats)(struct seq_file *m, struct cifs_tcon *);316	void (*dump_share_caps)(struct seq_file *, struct cifs_tcon *);317	/* verify the message */318	int (*check_message)(char *, unsigned int, struct TCP_Server_Info *);319	bool (*is_oplock_break)(char *, struct TCP_Server_Info *);320	int (*handle_cancelled_mid)(struct mid_q_entry *, struct TCP_Server_Info *);321	void (*downgrade_oplock)(struct TCP_Server_Info *server,322				 struct cifsInodeInfo *cinode, __u32 oplock,323				 unsigned int epoch, bool *purge_cache);324	/* process transaction2 response */325	bool (*check_trans2)(struct mid_q_entry *, struct TCP_Server_Info *,326			     char *, int);327	/* check if we need to negotiate */328	bool (*need_neg)(struct TCP_Server_Info *);329	/* negotiate to the server */330	int (*negotiate)(const unsigned int xid,331			 struct cifs_ses *ses,332			 struct TCP_Server_Info *server);333	/* set negotiated write size */334	unsigned int (*negotiate_wsize)(struct cifs_tcon *tcon, struct smb3_fs_context *ctx);335	/* set negotiated read size */336	unsigned int (*negotiate_rsize)(struct cifs_tcon *tcon, struct smb3_fs_context *ctx);337	/* setup smb sessionn */338	int (*sess_setup)(const unsigned int, struct cifs_ses *,339			  struct TCP_Server_Info *server,340			  const struct nls_table *);341	/* close smb session */342	int (*logoff)(const unsigned int, struct cifs_ses *);343	/* connect to a server share */344	int (*tree_connect)(const unsigned int, struct cifs_ses *, const char *,345			    struct cifs_tcon *, const struct nls_table *);346	/* close tree connection */347	int (*tree_disconnect)(const unsigned int, struct cifs_tcon *);348	/* get DFS referrals */349	int (*get_dfs_refer)(const unsigned int, struct cifs_ses *,350			     const char *, struct dfs_info3_param **,351			     unsigned int *, const struct nls_table *, int);352	/* informational QFS call */353	void (*qfs_tcon)(const unsigned int, struct cifs_tcon *,354			 struct cifs_sb_info *);355	/* query for server interfaces */356	int (*query_server_interfaces)(const unsigned int, struct cifs_tcon *,357				       bool);358	/* check if a path is accessible or not */359	int (*is_path_accessible)(const unsigned int, struct cifs_tcon *,360				  struct cifs_sb_info *, const char *);361	/* query path data from the server */362	int (*query_path_info)(const unsigned int xid,363			       struct cifs_tcon *tcon,364			       struct cifs_sb_info *cifs_sb,365			       const char *full_path,366			       struct cifs_open_info_data *data);367	/* query file data from the server */368	int (*query_file_info)(const unsigned int xid, struct cifs_tcon *tcon,369			       struct cifsFileInfo *cfile, struct cifs_open_info_data *data);370	/* query reparse point to determine which type of special file */371	int (*query_reparse_point)(const unsigned int xid,372				   struct cifs_tcon *tcon,373				   struct cifs_sb_info *cifs_sb,374				   const char *full_path,375				   u32 *tag, struct kvec *rsp,376				   int *rsp_buftype);377	/* get server index number */378	int (*get_srv_inum)(const unsigned int xid, struct cifs_tcon *tcon,379			    struct cifs_sb_info *cifs_sb, const char *full_path, u64 *uniqueid,380			    struct cifs_open_info_data *data);381	/* set size by path */382	int (*set_path_size)(const unsigned int, struct cifs_tcon *,383			     const char *, __u64, struct cifs_sb_info *, bool,384				 struct dentry *);385	/* set size by file handle */386	int (*set_file_size)(const unsigned int, struct cifs_tcon *,387			     struct cifsFileInfo *, __u64, bool);388	/* set attributes */389	int (*set_file_info)(struct inode *, const char *, FILE_BASIC_INFO *,390			     const unsigned int);391	int (*set_compression)(const unsigned int, struct cifs_tcon *,392			       struct cifsFileInfo *);393	/* check if we can send an echo or nor */394	bool (*can_echo)(struct TCP_Server_Info *);395	/* send echo request */396	int (*echo)(struct TCP_Server_Info *);397	/* create directory */398	int (*posix_mkdir)(const unsigned int xid, struct inode *inode,399			umode_t mode, struct cifs_tcon *tcon,400			const char *full_path,401			struct cifs_sb_info *cifs_sb);402	int (*mkdir)(const unsigned int xid, struct inode *inode, umode_t mode,403		     struct cifs_tcon *tcon, const char *name,404		     struct cifs_sb_info *sb);405	/* set info on created directory */406	void (*mkdir_setinfo)(struct inode *, const char *,407			      struct cifs_sb_info *, struct cifs_tcon *,408			      const unsigned int);409	/* remove directory */410	int (*rmdir)(const unsigned int, struct cifs_tcon *, const char *,411		     struct cifs_sb_info *);412	/* unlink file */413	int (*unlink)(const unsigned int, struct cifs_tcon *, const char *,414		      struct cifs_sb_info *, struct dentry *);415	/* open, rename and delete file */416	int (*rename_pending_delete)(const char *, struct dentry *,417				     const unsigned int);418	/* send rename request */419	int (*rename)(const unsigned int xid,420		      struct cifs_tcon *tcon,421		      struct dentry *source_dentry,422		      const char *from_name, const char *to_name,423		      struct cifs_sb_info *cifs_sb);424	/* send create hardlink request */425	int (*create_hardlink)(const unsigned int xid,426			       struct cifs_tcon *tcon,427			       struct dentry *source_dentry,428			       const char *from_name, const char *to_name,429			       struct cifs_sb_info *cifs_sb);430	/* query symlink target */431	int (*query_symlink)(const unsigned int xid,432			     struct cifs_tcon *tcon,433			     struct cifs_sb_info *cifs_sb,434			     const char *full_path,435			     char **target_path);436	/* open a file for non-posix mounts */437	int (*open)(const unsigned int xid, struct cifs_open_parms *oparms, __u32 *oplock,438		    void *buf);439	/* set fid protocol-specific info */440	void (*set_fid)(struct cifsFileInfo *, struct cifs_fid *, __u32);441	/* close a file */442	int (*close)(const unsigned int, struct cifs_tcon *,443		      struct cifs_fid *);444	/* close a file, returning file attributes and timestamps */445	int (*close_getattr)(const unsigned int xid, struct cifs_tcon *tcon,446		      struct cifsFileInfo *pfile_info);447	/* send a flush request to the server */448	int (*flush)(const unsigned int, struct cifs_tcon *, struct cifs_fid *);449	/* async read from the server */450	int (*async_readv)(struct cifs_io_subrequest *);451	/* async write to the server */452	void (*async_writev)(struct cifs_io_subrequest *);453	/* sync read from the server */454	int (*sync_read)(const unsigned int, struct cifs_fid *,455			 struct cifs_io_parms *, unsigned int *, char **,456			 int *);457	/* sync write to the server */458	int (*sync_write)(const unsigned int, struct cifs_fid *,459			  struct cifs_io_parms *, unsigned int *, struct kvec *,460			  unsigned long);461	/* open dir, start readdir */462	int (*query_dir_first)(const unsigned int, struct cifs_tcon *,463			       const char *, struct cifs_sb_info *,464			       struct cifs_fid *, __u16,465			       struct cifs_search_info *);466	/* continue readdir */467	int (*query_dir_next)(const unsigned int, struct cifs_tcon *,468			      struct cifs_fid *,469			      __u16, struct cifs_search_info *srch_inf);470	/* close dir */471	int (*close_dir)(const unsigned int, struct cifs_tcon *,472			 struct cifs_fid *);473	/* calculate a size of SMB message */474	unsigned int (*calc_smb_size)(void *buf);475	/* check for STATUS_PENDING and process the response if yes */476	bool (*is_status_pending)(char *buf, struct TCP_Server_Info *server);477	/* check for STATUS_NETWORK_SESSION_EXPIRED */478	bool (*is_session_expired)(char *);479	/* send oplock break response */480	int (*oplock_response)(struct cifs_tcon *tcon, __u64 persistent_fid, __u64 volatile_fid,481			__u16 net_fid, struct cifsInodeInfo *cifs_inode);482	/* query remote filesystem */483	int (*queryfs)(const unsigned int, struct cifs_tcon *,484		       const char *, struct cifs_sb_info *, struct kstatfs *);485	/* send mandatory brlock to the server */486	int (*mand_lock)(const unsigned int, struct cifsFileInfo *, __u64,487			 __u64, __u32, int, int, bool);488	/* unlock range of mandatory locks */489	int (*mand_unlock_range)(struct cifsFileInfo *, struct file_lock *,490				 const unsigned int);491	/* push brlocks from the cache to the server */492	int (*push_mand_locks)(struct cifsFileInfo *);493	/* get lease key of the inode */494	void (*get_lease_key)(struct inode *, struct cifs_fid *);495	/* set lease key of the inode */496	void (*set_lease_key)(struct inode *, struct cifs_fid *);497	/* generate new lease key */498	void (*new_lease_key)(struct cifs_fid *);499	int (*generate_signingkey)(struct cifs_ses *ses,500				   struct TCP_Server_Info *server);501	int (*calc_signature)(struct smb_rqst *, struct TCP_Server_Info *,502				bool allocate_crypto);503	int (*set_integrity)(const unsigned int, struct cifs_tcon *tcon,504			     struct cifsFileInfo *src_file);505	int (*enum_snapshots)(const unsigned int xid, struct cifs_tcon *tcon,506			     struct cifsFileInfo *src_file, void __user *);507	int (*notify)(const unsigned int xid, struct file *pfile,508			     void __user *pbuf, bool return_changes);509	int (*query_mf_symlink)(unsigned int, struct cifs_tcon *,510				struct cifs_sb_info *, const unsigned char *,511				char *, unsigned int *);512	int (*create_mf_symlink)(unsigned int, struct cifs_tcon *,513				 struct cifs_sb_info *, const unsigned char *,514				 char *, unsigned int *);515	/* if we can do cache read operations */516	bool (*is_read_op)(__u32);517	/* set oplock level for the inode */518	void (*set_oplock_level)(struct cifsInodeInfo *, __u32, unsigned int,519				 bool *);520	/* create lease context buffer for CREATE request */521	char * (*create_lease_buf)(u8 *lease_key, u8 oplock);522	/* parse lease context buffer and return oplock/epoch info */523	__u8 (*parse_lease_buf)(void *buf, unsigned int *epoch, char *lkey);524	ssize_t (*copychunk_range)(const unsigned int,525			struct cifsFileInfo *src_file,526			struct cifsFileInfo *target_file,527			u64 src_off, u64 len, u64 dest_off);528	int (*duplicate_extents)(const unsigned int, struct cifsFileInfo *src,529			struct cifsFileInfo *target_file, u64 src_off, u64 len,530			u64 dest_off);531	int (*validate_negotiate)(const unsigned int, struct cifs_tcon *);532	ssize_t (*query_all_EAs)(const unsigned int, struct cifs_tcon *,533			const unsigned char *, const unsigned char *, char *,534			size_t, struct cifs_sb_info *);535	int (*set_EA)(const unsigned int, struct cifs_tcon *, const char *,536			const char *, const void *, const __u16,537			const struct nls_table *, struct cifs_sb_info *);538	struct smb_ntsd * (*get_acl)(struct cifs_sb_info *cifssb, struct inode *ino,539			const char *patch, u32 *plen, u32 info);540	struct smb_ntsd * (*get_acl_by_fid)(struct cifs_sb_info *cifssmb,541			const struct cifs_fid *pfid, u32 *plen, u32 info);542	int (*set_acl)(struct smb_ntsd *pntsd, __u32 len, struct inode *ino, const char *path,543			int flag);544	/* writepages retry size */545	unsigned int (*wp_retry_size)(struct inode *);546	/* get mtu credits */547	int (*wait_mtu_credits)(struct TCP_Server_Info *, size_t,548				size_t *, struct cifs_credits *);549	/* adjust previously taken mtu credits to request size */550	int (*adjust_credits)(struct TCP_Server_Info *server,551			      struct cifs_io_subrequest *subreq,552			      unsigned int /*enum smb3_rw_credits_trace*/ trace);553	/* check if we need to issue closedir */554	bool (*dir_needs_close)(struct cifsFileInfo *);555	long (*fallocate)(struct file *, struct cifs_tcon *, int, loff_t,556			  loff_t);557	/* init transform (compress/encrypt) request */558	int (*init_transform_rq)(struct TCP_Server_Info *, int num_rqst,559				 struct smb_rqst *, struct smb_rqst *);560	int (*is_transform_hdr)(void *buf);561	int (*receive_transform)(struct TCP_Server_Info *,562				 struct mid_q_entry **, char **, int *);563	enum securityEnum (*select_sectype)(struct TCP_Server_Info *,564			    enum securityEnum);565	int (*next_header)(struct TCP_Server_Info *server, char *buf,566			   unsigned int *noff);567	/* ioctl passthrough for query_info */568	int (*ioctl_query_info)(const unsigned int xid,569				struct cifs_tcon *tcon,570				struct cifs_sb_info *cifs_sb,571				__le16 *path, int is_dir,572				unsigned long p);573	/* make unix special files (block, char, fifo, socket) */574	int (*make_node)(unsigned int xid,575			 struct inode *inode,576			 struct dentry *dentry,577			 struct cifs_tcon *tcon,578			 const char *full_path,579			 umode_t mode,580			 dev_t device_number);581	/* version specific fiemap implementation */582	int (*fiemap)(struct cifs_tcon *tcon, struct cifsFileInfo *,583		      struct fiemap_extent_info *, u64, u64);584	/* version specific llseek implementation */585	loff_t (*llseek)(struct file *, struct cifs_tcon *, loff_t, int);586	/* Check for STATUS_IO_TIMEOUT */587	bool (*is_status_io_timeout)(char *buf);588	/* Check for STATUS_NETWORK_NAME_DELETED */589	bool (*is_network_name_deleted)(char *buf, struct TCP_Server_Info *srv);590	int (*parse_reparse_point)(struct cifs_sb_info *cifs_sb,591				   struct kvec *rsp_iov,592				   struct cifs_open_info_data *data);593	int (*create_reparse_symlink)(const unsigned int xid,594				      struct inode *inode,595				      struct dentry *dentry,596				      struct cifs_tcon *tcon,597				      const char *full_path,598				      const char *symname);599};600 601struct smb_version_values {602	char		*version_string;603	__u16		protocol_id;604	__u32		req_capabilities;605	__u32		large_lock_type;606	__u32		exclusive_lock_type;607	__u32		shared_lock_type;608	__u32		unlock_lock_type;609	size_t		header_preamble_size;610	size_t		header_size;611	size_t		max_header_size;612	size_t		read_rsp_size;613	__le16		lock_cmd;614	unsigned int	cap_unix;615	unsigned int	cap_nt_find;616	unsigned int	cap_large_files;617	__u16		signing_enabled;618	__u16		signing_required;619	size_t		create_lease_size;620};621 622#define HEADER_SIZE(server) (server->vals->header_size)623#define MAX_HEADER_SIZE(server) (server->vals->max_header_size)624#define HEADER_PREAMBLE_SIZE(server) (server->vals->header_preamble_size)625#define MID_HEADER_SIZE(server) (HEADER_SIZE(server) - 1 - HEADER_PREAMBLE_SIZE(server))626 627/**628 * CIFS superblock mount flags (mnt_cifs_flags) to consider when629 * trying to reuse existing superblock for a new mount630 */631#define CIFS_MOUNT_MASK (CIFS_MOUNT_NO_PERM | CIFS_MOUNT_SET_UID | \632			 CIFS_MOUNT_SERVER_INUM | CIFS_MOUNT_DIRECT_IO | \633			 CIFS_MOUNT_NO_XATTR | CIFS_MOUNT_MAP_SPECIAL_CHR | \634			 CIFS_MOUNT_MAP_SFM_CHR | \635			 CIFS_MOUNT_UNX_EMUL | CIFS_MOUNT_NO_BRL | \636			 CIFS_MOUNT_CIFS_ACL | CIFS_MOUNT_OVERR_UID | \637			 CIFS_MOUNT_OVERR_GID | CIFS_MOUNT_DYNPERM | \638			 CIFS_MOUNT_NOPOSIXBRL | CIFS_MOUNT_NOSSYNC | \639			 CIFS_MOUNT_FSCACHE | CIFS_MOUNT_MF_SYMLINKS | \640			 CIFS_MOUNT_MULTIUSER | CIFS_MOUNT_STRICT_IO | \641			 CIFS_MOUNT_CIFS_BACKUPUID | CIFS_MOUNT_CIFS_BACKUPGID | \642			 CIFS_MOUNT_UID_FROM_ACL | CIFS_MOUNT_NO_HANDLE_CACHE | \643			 CIFS_MOUNT_NO_DFS | CIFS_MOUNT_MODE_FROM_SID | \644			 CIFS_MOUNT_RO_CACHE | CIFS_MOUNT_RW_CACHE)645 646/**647 * Generic VFS superblock mount flags (s_flags) to consider when648 * trying to reuse existing superblock for a new mount649 */650#define CIFS_MS_MASK (SB_RDONLY | SB_MANDLOCK | SB_NOEXEC | SB_NOSUID | \651		      SB_NODEV | SB_SYNCHRONOUS)652 653struct cifs_mnt_data {654	struct cifs_sb_info *cifs_sb;655	struct smb3_fs_context *ctx;656	int flags;657};658 659static inline unsigned int660get_rfc1002_length(void *buf)661{662	return be32_to_cpu(*((__be32 *)buf)) & 0xffffff;663}664 665static inline void666inc_rfc1001_len(void *buf, int count)667{668	be32_add_cpu((__be32 *)buf, count);669}670 671struct TCP_Server_Info {672	struct list_head tcp_ses_list;673	struct list_head smb_ses_list;674	spinlock_t srv_lock;  /* protect anything here that is not protected */675	__u64 conn_id; /* connection identifier (useful for debugging) */676	int srv_count; /* reference counter */677	/* 15 character server name + 0x20 16th byte indicating type = srv */678	char server_RFC1001_name[RFC1001_NAME_LEN_WITH_NULL];679	struct smb_version_operations	*ops;680	struct smb_version_values	*vals;681	/* updates to tcpStatus protected by cifs_tcp_ses_lock */682	enum statusEnum tcpStatus; /* what we think the status is */683	char *hostname; /* hostname portion of UNC string */684	struct socket *ssocket;685	struct sockaddr_storage dstaddr;686	struct sockaddr_storage srcaddr; /* locally bind to this IP */687#ifdef CONFIG_NET_NS688	struct net *net;689#endif690	wait_queue_head_t response_q;691	wait_queue_head_t request_q; /* if more than maxmpx to srvr must block*/692	spinlock_t mid_lock;  /* protect mid queue and it's entries */693	struct list_head pending_mid_q;694	bool noblocksnd;		/* use blocking sendmsg */695	bool noautotune;		/* do not autotune send buf sizes */696	bool nosharesock;697	bool tcp_nodelay;698	bool terminate;699	unsigned int credits;  /* send no more requests at once */700	unsigned int max_credits; /* can override large 32000 default at mnt */701	unsigned int in_flight;  /* number of requests on the wire to server */702	unsigned int max_in_flight; /* max number of requests that were on wire */703	spinlock_t req_lock;  /* protect the two values above */704	struct mutex _srv_mutex;705	unsigned int nofs_flag;706	struct task_struct *tsk;707	char server_GUID[16];708	__u16 sec_mode;709	bool sign; /* is signing enabled on this connection? */710	bool ignore_signature:1; /* skip validation of signatures in SMB2/3 rsp */711	bool session_estab; /* mark when very first sess is established */712	int echo_credits;  /* echo reserved slots */713	int oplock_credits;  /* oplock break reserved slots */714	bool echoes:1; /* enable echoes */715	__u8 client_guid[SMB2_CLIENT_GUID_SIZE]; /* Client GUID */716	u16 dialect; /* dialect index that server chose */717	bool oplocks:1; /* enable oplocks */718	unsigned int maxReq;	/* Clients should submit no more */719	/* than maxReq distinct unanswered SMBs to the server when using  */720	/* multiplexed reads or writes (for SMB1/CIFS only, not SMB2/SMB3) */721	unsigned int maxBuf;	/* maxBuf specifies the maximum */722	/* message size the server can send or receive for non-raw SMBs */723	/* maxBuf is returned by SMB NegotiateProtocol so maxBuf is only 0 */724	/* when socket is setup (and during reconnect) before NegProt sent */725	unsigned int max_rw;	/* maxRw specifies the maximum */726	/* message size the server can send or receive for */727	/* SMB_COM_WRITE_RAW or SMB_COM_READ_RAW. */728	unsigned int capabilities; /* selective disabling of caps by smb sess */729	int timeAdj;  /* Adjust for difference in server time zone in sec */730	__u64 CurrentMid;         /* multiplex id - rotating counter, protected by GlobalMid_Lock */731	char cryptkey[CIFS_CRYPTO_KEY_SIZE]; /* used by ntlm, ntlmv2 etc */732	/* 16th byte of RFC1001 workstation name is always null */733	char workstation_RFC1001_name[RFC1001_NAME_LEN_WITH_NULL];734	__u32 sequence_number; /* for signing, protected by srv_mutex */735	__u32 reconnect_instance; /* incremented on each reconnect */736	struct session_key session_key;737	unsigned long lstrp; /* when we got last response from this server */738	struct cifs_secmech secmech; /* crypto sec mech functs, descriptors */739#define	CIFS_NEGFLAVOR_UNENCAP	1	/* wct == 17, but no ext_sec */740#define	CIFS_NEGFLAVOR_EXTENDED	2	/* wct == 17, ext_sec bit set */741	char	negflavor;	/* NEGOTIATE response flavor */742	/* extended security flavors that server supports */743	bool	sec_ntlmssp;		/* supports NTLMSSP */744	bool	sec_kerberosu2u;	/* supports U2U Kerberos */745	bool	sec_kerberos;		/* supports plain Kerberos */746	bool	sec_mskerberos;		/* supports legacy MS Kerberos */747	bool	large_buf;		/* is current buffer large? */748	/* use SMBD connection instead of socket */749	bool	rdma;750	/* point to the SMBD connection if RDMA is used instead of socket */751	struct smbd_connection *smbd_conn;752	struct delayed_work	echo; /* echo ping workqueue job */753	char	*smallbuf;	/* pointer to current "small" buffer */754	char	*bigbuf;	/* pointer to current "big" buffer */755	/* Total size of this PDU. Only valid from cifs_demultiplex_thread */756	unsigned int pdu_size;757	unsigned int total_read; /* total amount of data read in this pass */758	atomic_t in_send; /* requests trying to send */759	atomic_t num_waiters;   /* blocked waiting to get in sendrecv */760#ifdef CONFIG_CIFS_STATS2761	atomic_t num_cmds[NUMBER_OF_SMB2_COMMANDS]; /* total requests by cmd */762	atomic_t smb2slowcmd[NUMBER_OF_SMB2_COMMANDS]; /* count resps > 1 sec */763	__u64 time_per_cmd[NUMBER_OF_SMB2_COMMANDS]; /* total time per cmd */764	__u32 slowest_cmd[NUMBER_OF_SMB2_COMMANDS];765	__u32 fastest_cmd[NUMBER_OF_SMB2_COMMANDS];766#endif /* STATS2 */767	unsigned int	max_read;768	unsigned int	max_write;769	unsigned int	min_offload;770	unsigned int	retrans;771	struct {772		bool requested; /* "compress" mount option set*/773		bool enabled; /* actually negotiated with server */774		__le16 alg; /* preferred alg negotiated with server */775	} compression;776	__u16	signing_algorithm;777	__le16	cipher_type;778	 /* save initial negprot hash */779	__u8	preauth_sha_hash[SMB2_PREAUTH_HASH_SIZE];780	bool	signing_negotiated; /* true if valid signing context rcvd from server */781	bool	posix_ext_supported;782	struct delayed_work reconnect; /* reconnect workqueue job */783	struct mutex reconnect_mutex; /* prevent simultaneous reconnects */784	unsigned long echo_interval;785 786	/*787	 * Number of targets available for reconnect. The more targets788	 * the more tasks have to wait to let the demultiplex thread789	 * reconnect.790	 */791	int nr_targets;792	bool noblockcnt; /* use non-blocking connect() */793 794	/*795	 * If this is a session channel,796	 * primary_server holds the ref-counted797	 * pointer to primary channel connection for the session.798	 */799#define SERVER_IS_CHAN(server)	(!!(server)->primary_server)800	struct TCP_Server_Info *primary_server;801	__u16 channel_sequence_num;  /* incremented on primary channel on each chan reconnect */802 803#ifdef CONFIG_CIFS_SWN_UPCALL804	bool use_swn_dstaddr;805	struct sockaddr_storage swn_dstaddr;806#endif807	struct mutex refpath_lock; /* protects leaf_fullpath */808	/*809	 * leaf_fullpath: Canonical DFS referral path related to this810	 *                connection.811	 *                It is used in DFS cache refresher, reconnect and may812	 *                change due to nested DFS links.813	 *814	 * Protected by @refpath_lock and @srv_lock.  The @refpath_lock is815	 * mostly used for not requiring a copy of @leaf_fullpath when getting816	 * cached or new DFS referrals (which might also sleep during I/O).817	 * While @srv_lock is held for making string and NULL comparisons against818	 * both fields as in mount(2) and cache refresh.819	 *820	 * format: \\HOST\SHARE[\OPTIONAL PATH]821	 */822	char *leaf_fullpath;823	bool dfs_conn:1;824};825 826static inline bool is_smb1(struct TCP_Server_Info *server)827{828	return HEADER_PREAMBLE_SIZE(server) != 0;829}830 831static inline void cifs_server_lock(struct TCP_Server_Info *server)832{833	unsigned int nofs_flag = memalloc_nofs_save();834 835	mutex_lock(&server->_srv_mutex);836	server->nofs_flag = nofs_flag;837}838 839static inline void cifs_server_unlock(struct TCP_Server_Info *server)840{841	unsigned int nofs_flag = server->nofs_flag;842 843	mutex_unlock(&server->_srv_mutex);844	memalloc_nofs_restore(nofs_flag);845}846 847struct cifs_credits {848	unsigned int value;849	unsigned int instance;850	unsigned int in_flight_check;851	unsigned int rreq_debug_id;852	unsigned int rreq_debug_index;853};854 855static inline unsigned int856in_flight(struct TCP_Server_Info *server)857{858	unsigned int num;859 860	spin_lock(&server->req_lock);861	num = server->in_flight;862	spin_unlock(&server->req_lock);863	return num;864}865 866static inline bool867has_credits(struct TCP_Server_Info *server, int *credits, int num_credits)868{869	int num;870 871	spin_lock(&server->req_lock);872	num = *credits;873	spin_unlock(&server->req_lock);874	return num >= num_credits;875}876 877static inline void878add_credits(struct TCP_Server_Info *server, struct cifs_credits *credits,879	    const int optype)880{881	server->ops->add_credits(server, credits, optype);882}883 884static inline void885add_credits_and_wake_if(struct TCP_Server_Info *server,886			struct cifs_credits *credits, const int optype)887{888	if (credits->value) {889		server->ops->add_credits(server, credits, optype);890		wake_up(&server->request_q);891		credits->value = 0;892	}893}894 895static inline void896set_credits(struct TCP_Server_Info *server, const int val)897{898	server->ops->set_credits(server, val);899}900 901static inline int902adjust_credits(struct TCP_Server_Info *server, struct cifs_io_subrequest *subreq,903	       unsigned int /* enum smb3_rw_credits_trace */ trace)904{905	return server->ops->adjust_credits ?906		server->ops->adjust_credits(server, subreq, trace) : 0;907}908 909static inline __le64910get_next_mid64(struct TCP_Server_Info *server)911{912	return cpu_to_le64(server->ops->get_next_mid(server));913}914 915static inline __le16916get_next_mid(struct TCP_Server_Info *server)917{918	__u16 mid = server->ops->get_next_mid(server);919	/*920	 * The value in the SMB header should be little endian for easy921	 * on-the-wire decoding.922	 */923	return cpu_to_le16(mid);924}925 926static inline void927revert_current_mid(struct TCP_Server_Info *server, const unsigned int val)928{929	if (server->ops->revert_current_mid)930		server->ops->revert_current_mid(server, val);931}932 933static inline void934revert_current_mid_from_hdr(struct TCP_Server_Info *server,935			    const struct smb2_hdr *shdr)936{937	unsigned int num = le16_to_cpu(shdr->CreditCharge);938 939	return revert_current_mid(server, num > 0 ? num : 1);940}941 942static inline __u16943get_mid(const struct smb_hdr *smb)944{945	return le16_to_cpu(smb->Mid);946}947 948static inline bool949compare_mid(__u16 mid, const struct smb_hdr *smb)950{951	return mid == le16_to_cpu(smb->Mid);952}953 954/*955 * When the server supports very large reads and writes via POSIX extensions,956 * we can allow up to 2^24-1, minus the size of a READ/WRITE_AND_X header, not957 * including the RFC1001 length.958 *959 * Note that this might make for "interesting" allocation problems during960 * writeback however as we have to allocate an array of pointers for the961 * pages. A 16M write means ~32kb page array with PAGE_SIZE == 4096.962 *963 * For reads, there is a similar problem as we need to allocate an array964 * of kvecs to handle the receive, though that should only need to be done965 * once.966 */967#define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)968#define CIFS_MAX_RSIZE ((1<<24) - sizeof(READ_RSP) + 4)969 970/*971 * When the server doesn't allow large posix writes, only allow a rsize/wsize972 * of 2^17-1 minus the size of the call header. That allows for a read or973 * write up to the maximum size described by RFC1002.974 */975#define CIFS_MAX_RFC1002_WSIZE ((1<<17) - 1 - sizeof(WRITE_REQ) + 4)976#define CIFS_MAX_RFC1002_RSIZE ((1<<17) - 1 - sizeof(READ_RSP) + 4)977 978#define CIFS_DEFAULT_IOSIZE (1024 * 1024)979 980/*981 * Windows only supports a max of 60kb reads and 65535 byte writes. Default to982 * those values when posix extensions aren't in force. In actuality here, we983 * use 65536 to allow for a write that is a multiple of 4k. Most servers seem984 * to be ok with the extra byte even though Windows doesn't send writes that985 * are that large.986 *987 * Citation:988 *989 * https://blogs.msdn.com/b/openspecification/archive/2009/04/10/smb-maximum-transmit-buffer-size-and-performance-tuning.aspx990 */991#define CIFS_DEFAULT_NON_POSIX_RSIZE (60 * 1024)992#define CIFS_DEFAULT_NON_POSIX_WSIZE (65536)993 994/*995 * Macros to allow the TCP_Server_Info->net field and related code to drop out996 * when CONFIG_NET_NS isn't set.997 */998 999#ifdef CONFIG_NET_NS1000 1001static inline struct net *cifs_net_ns(struct TCP_Server_Info *srv)1002{1003	return srv->net;1004}1005 1006static inline void cifs_set_net_ns(struct TCP_Server_Info *srv, struct net *net)1007{1008	srv->net = net;1009}1010 1011#else1012 1013static inline struct net *cifs_net_ns(struct TCP_Server_Info *srv)1014{1015	return &init_net;1016}1017 1018static inline void cifs_set_net_ns(struct TCP_Server_Info *srv, struct net *net)1019{1020}1021 1022#endif1023 1024struct cifs_server_iface {1025	struct list_head iface_head;1026	struct kref refcount;1027	size_t speed;1028	size_t weight_fulfilled;1029	unsigned int num_channels;1030	unsigned int rdma_capable : 1;1031	unsigned int rss_capable : 1;1032	unsigned int is_active : 1; /* unset if non existent */1033	struct sockaddr_storage sockaddr;1034};1035 1036/* release iface when last ref is dropped */1037static inline void1038release_iface(struct kref *ref)1039{1040	struct cifs_server_iface *iface = container_of(ref,1041						       struct cifs_server_iface,1042						       refcount);1043	kfree(iface);1044}1045 1046struct cifs_chan {1047	unsigned int in_reconnect : 1; /* if session setup in progress for this channel */1048	struct TCP_Server_Info *server;1049	struct cifs_server_iface *iface; /* interface in use */1050	__u8 signkey[SMB3_SIGN_KEY_SIZE];1051};1052 1053#define CIFS_SES_FLAG_SCALE_CHANNELS (0x1)1054 1055/*1056 * Session structure.  One of these for each uid session with a particular host1057 */1058struct cifs_ses {1059	struct list_head smb_ses_list;1060	struct list_head rlist; /* reconnect list */1061	struct list_head tcon_list;1062	struct list_head dlist; /* dfs list */1063	struct cifs_tcon *tcon_ipc;1064	spinlock_t ses_lock;  /* protect anything here that is not protected */1065	struct mutex session_mutex;1066	struct TCP_Server_Info *server;	/* pointer to server info */1067	int ses_count;		/* reference counter */1068	enum ses_status_enum ses_status;  /* updates protected by cifs_tcp_ses_lock */1069	unsigned int overrideSecFlg; /* if non-zero override global sec flags */1070	char *serverOS;		/* name of operating system underlying server */1071	char *serverNOS;	/* name of network operating system of server */1072	char *serverDomain;	/* security realm of server */1073	__u64 Suid;		/* remote smb uid  */1074	kuid_t linux_uid;	/* overriding owner of files on the mount */1075	kuid_t cred_uid;	/* owner of credentials */1076	unsigned int capabilities;1077	char ip_addr[INET6_ADDRSTRLEN + 1]; /* Max ipv6 (or v4) addr string len */1078	char *user_name;	/* must not be null except during init of sess1079				   and after mount option parsing we fill it */1080	char *domainName;1081	char *password;1082	char *password2; /* When key rotation used, new password may be set before it expires */1083	char workstation_name[CIFS_MAX_WORKSTATION_LEN];1084	struct session_key auth_key;1085	struct ntlmssp_auth *ntlmssp; /* ciphertext, flags, server challenge */1086	enum securityEnum sectype; /* what security flavor was specified? */1087	bool sign;		/* is signing required? */1088	bool domainAuto:1;1089	bool expired_pwd;  /* track if access denied or expired pwd so can know if need to update */1090	unsigned int flags;1091	__u16 session_flags;1092	__u8 smb3signingkey[SMB3_SIGN_KEY_SIZE];1093	__u8 smb3encryptionkey[SMB3_ENC_DEC_KEY_SIZE];1094	__u8 smb3decryptionkey[SMB3_ENC_DEC_KEY_SIZE];1095	__u8 preauth_sha_hash[SMB2_PREAUTH_HASH_SIZE];1096 1097	/*1098	 * Network interfaces available on the server this session is1099	 * connected to.1100	 *1101	 * Other channels can be opened by connecting and binding this1102	 * session to interfaces from this list.1103	 *1104	 * iface_lock should be taken when accessing any of these fields1105	 */1106	spinlock_t iface_lock;1107	/* ========= begin: protected by iface_lock ======== */1108	struct list_head iface_list;1109	size_t iface_count;1110	unsigned long iface_last_update; /* jiffies */1111	/* ========= end: protected by iface_lock ======== */1112 1113	spinlock_t chan_lock;1114	/* ========= begin: protected by chan_lock ======== */1115#define CIFS_MAX_CHANNELS 161116#define CIFS_INVAL_CHAN_INDEX (-1)1117#define CIFS_ALL_CHANNELS_SET(ses)	\1118	((1UL << (ses)->chan_count) - 1)1119#define CIFS_ALL_CHANS_GOOD(ses)		\1120	(!(ses)->chans_need_reconnect)1121#define CIFS_ALL_CHANS_NEED_RECONNECT(ses)	\1122	((ses)->chans_need_reconnect == CIFS_ALL_CHANNELS_SET(ses))1123#define CIFS_SET_ALL_CHANS_NEED_RECONNECT(ses)	\1124	((ses)->chans_need_reconnect = CIFS_ALL_CHANNELS_SET(ses))1125#define CIFS_CHAN_NEEDS_RECONNECT(ses, index)	\1126	test_bit((index), &(ses)->chans_need_reconnect)1127#define CIFS_CHAN_IN_RECONNECT(ses, index)	\1128	((ses)->chans[(index)].in_reconnect)1129 1130	struct cifs_chan chans[CIFS_MAX_CHANNELS];1131	size_t chan_count;1132	size_t chan_max;1133	atomic_t chan_seq; /* round robin state */1134 1135	/*1136	 * chans_need_reconnect is a bitmap indicating which of the channels1137	 * under this smb session needs to be reconnected.1138	 * If not multichannel session, only one bit will be used.1139	 *1140	 * We will ask for sess and tcon reconnection only if all the1141	 * channels are marked for needing reconnection. This will1142	 * enable the sessions on top to continue to live till any1143	 * of the channels below are active.1144	 */1145	unsigned long chans_need_reconnect;1146	/* ========= end: protected by chan_lock ======== */1147	struct cifs_ses *dfs_root_ses;1148	struct nls_table *local_nls;1149};1150 1151static inline bool1152cap_unix(struct cifs_ses *ses)1153{1154	return ses->server->vals->cap_unix & ses->capabilities;1155}1156 1157/*1158 * common struct for holding inode info when searching for or updating an1159 * inode with new info1160 */1161 1162#define CIFS_FATTR_JUNCTION		0x11163#define CIFS_FATTR_DELETE_PENDING	0x21164#define CIFS_FATTR_NEED_REVAL		0x41165#define CIFS_FATTR_INO_COLLISION	0x81166#define CIFS_FATTR_UNKNOWN_NLINK	0x101167#define CIFS_FATTR_FAKE_ROOT_INO	0x201168 1169struct cifs_fattr {1170	u32		cf_flags;1171	u32		cf_cifsattrs;1172	u64		cf_uniqueid;1173	u64		cf_eof;1174	u64		cf_bytes;1175	u64		cf_createtime;1176	kuid_t		cf_uid;1177	kgid_t		cf_gid;1178	umode_t		cf_mode;1179	dev_t		cf_rdev;1180	unsigned int	cf_nlink;1181	unsigned int	cf_dtype;1182	struct timespec64 cf_atime;1183	struct timespec64 cf_mtime;1184	struct timespec64 cf_ctime;1185	u32             cf_cifstag;1186	char            *cf_symlink_target;1187};1188 1189/*1190 * there is one of these for each connection to a resource on a particular1191 * session1192 */1193struct cifs_tcon {1194	struct list_head tcon_list;1195	int debug_id;		/* Debugging for tracing */1196	int tc_count;1197	struct list_head rlist; /* reconnect list */1198	spinlock_t tc_lock;  /* protect anything here that is not protected */1199	atomic_t num_local_opens;  /* num of all opens including disconnected */1200	atomic_t num_remote_opens; /* num of all network opens on server */1201	struct list_head openFileList;1202	spinlock_t open_file_lock; /* protects list above */1203	struct cifs_ses *ses;	/* pointer to session associated with */1204	char tree_name[MAX_TREE_SIZE + 1]; /* UNC name of resource in ASCII */1205	char *nativeFileSystem;1206	char *password;		/* for share-level security */1207	__u32 tid;		/* The 4 byte tree id */1208	__u16 Flags;		/* optional support bits */1209	enum tid_status_enum status;1210	atomic_t num_smbs_sent;1211	union {1212		struct {1213			atomic_t num_writes;1214			atomic_t num_reads;1215			atomic_t num_flushes;1216			atomic_t num_oplock_brks;1217			atomic_t num_opens;1218			atomic_t num_closes;1219			atomic_t num_deletes;1220			atomic_t num_mkdirs;1221			atomic_t num_posixopens;1222			atomic_t num_posixmkdirs;1223			atomic_t num_rmdirs;1224			atomic_t num_renames;1225			atomic_t num_t2renames;1226			atomic_t num_ffirst;1227			atomic_t num_fnext;1228			atomic_t num_fclose;1229			atomic_t num_hardlinks;1230			atomic_t num_symlinks;1231			atomic_t num_locks;1232			atomic_t num_acl_get;1233			atomic_t num_acl_set;1234		} cifs_stats;1235		struct {1236			atomic_t smb2_com_sent[NUMBER_OF_SMB2_COMMANDS];1237			atomic_t smb2_com_failed[NUMBER_OF_SMB2_COMMANDS];1238		} smb2_stats;1239	} stats;1240	__u64    bytes_read;1241	__u64    bytes_written;1242	spinlock_t stat_lock;  /* protects the two fields above */1243	time64_t stats_from_time;1244	FILE_SYSTEM_DEVICE_INFO fsDevInfo;1245	FILE_SYSTEM_ATTRIBUTE_INFO fsAttrInfo; /* ok if fs name truncated */1246	FILE_SYSTEM_UNIX_INFO fsUnixInfo;1247	bool ipc:1;   /* set if connection to IPC$ share (always also pipe) */1248	bool pipe:1;  /* set if connection to pipe share */1249	bool print:1; /* set if connection to printer share */1250	bool retry:1;1251	bool nocase:1;1252	bool nohandlecache:1; /* if strange server resource prob can turn off */1253	bool nodelete:1;1254	bool seal:1;      /* transport encryption for this mounted share */1255	bool unix_ext:1;  /* if false disable Linux extensions to CIFS protocol1256				for this mount even if server would support */1257	bool posix_extensions; /* if true SMB3.11 posix extensions enabled */1258	bool local_lease:1; /* check leases (only) on local system not remote */1259	bool broken_posix_open; /* e.g. Samba server versions < 3.3.2, 3.2.9 */1260	bool broken_sparse_sup; /* if server or share does not support sparse */1261	bool need_reconnect:1; /* connection reset, tid now invalid */1262	bool need_reopen_files:1; /* need to reopen tcon file handles */1263	bool use_resilient:1; /* use resilient instead of durable handles */1264	bool use_persistent:1; /* use persistent instead of durable handles */1265	bool no_lease:1;    /* Do not request leases on files or directories */1266	bool use_witness:1; /* use witness protocol */1267	__le32 capabilities;1268	__u32 share_flags;1269	__u32 maximal_access;1270	__u32 vol_serial_number;1271	__le64 vol_create_time;1272	__u64 snapshot_time; /* for timewarp tokens - timestamp of snapshot */1273	__u32 handle_timeout; /* persistent and durable handle timeout in ms */1274	__u32 ss_flags;		/* sector size flags */1275	__u32 perf_sector_size; /* best sector size for perf */1276	__u32 max_chunks;1277	__u32 max_bytes_chunk;1278	__u32 max_bytes_copy;1279	__u32 max_cached_dirs;1280#ifdef CONFIG_CIFS_FSCACHE1281	u64 resource_id;		/* server resource id */1282	bool fscache_acquired;		/* T if we've tried acquiring a cookie */1283	struct fscache_volume *fscache;	/* cookie for share */1284	struct mutex fscache_lock;	/* Prevent regetting a cookie */1285#endif1286	struct list_head pending_opens;	/* list of incomplete opens */1287	struct cached_fids *cfids;1288	/* BB add field for back pointer to sb struct(s)? */1289#ifdef CONFIG_CIFS_DFS_UPCALL1290	struct delayed_work dfs_cache_work;1291	struct list_head dfs_ses_list;1292#endif1293	struct delayed_work	query_interfaces; /* query interfaces workqueue job */1294	char *origin_fullpath; /* canonical copy of smb3_fs_context::source */1295};1296 1297/*1298 * This is a refcounted and timestamped container for a tcon pointer. The1299 * container holds a tcon reference. It is considered safe to free one of1300 * these when the tl_count goes to 0. The tl_time is the time of the last1301 * "get" on the container.1302 */1303struct tcon_link {1304	struct rb_node		tl_rbnode;1305	kuid_t			tl_uid;1306	unsigned long		tl_flags;1307#define TCON_LINK_MASTER	01308#define TCON_LINK_PENDING	11309#define TCON_LINK_IN_TREE	21310	unsigned long		tl_time;1311	atomic_t		tl_count;1312	struct cifs_tcon	*tl_tcon;1313};1314 1315extern struct tcon_link *cifs_sb_tlink(struct cifs_sb_info *cifs_sb);1316extern void smb3_free_compound_rqst(int num_rqst, struct smb_rqst *rqst);1317 1318static inline struct cifs_tcon *1319tlink_tcon(struct tcon_link *tlink)1320{1321	return tlink->tl_tcon;1322}1323 1324static inline struct tcon_link *1325cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)1326{1327	return cifs_sb->master_tlink;1328}1329 1330extern void cifs_put_tlink(struct tcon_link *tlink);1331 1332static inline struct tcon_link *1333cifs_get_tlink(struct tcon_link *tlink)1334{1335	if (tlink && !IS_ERR(tlink))1336		atomic_inc(&tlink->tl_count);1337	return tlink;1338}1339 1340/* This function is always expected to succeed */1341extern struct cifs_tcon *cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb);1342 1343#define CIFS_OPLOCK_NO_CHANGE 0xfe1344 1345struct cifs_pending_open {1346	struct list_head olist;1347	struct tcon_link *tlink;1348	__u8 lease_key[16];1349	__u32 oplock;1350};1351 1352struct cifs_deferred_close {1353	struct list_head dlist;1354	struct tcon_link *tlink;1355	__u16  netfid;1356	__u64  persistent_fid;1357	__u64  volatile_fid;1358};1359 1360/*1361 * This info hangs off the cifsFileInfo structure, pointed to by llist.1362 * This is used to track byte stream locks on the file1363 */1364struct cifsLockInfo {1365	struct list_head llist;	/* pointer to next cifsLockInfo */1366	struct list_head blist; /* pointer to locks blocked on this */1367	wait_queue_head_t block_q;1368	__u64 offset;1369	__u64 length;1370	__u32 pid;1371	__u16 type;1372	__u16 flags;1373};1374 1375/*1376 * One of these for each open instance of a file1377 */1378struct cifs_search_info {1379	loff_t index_of_last_entry;1380	__u16 entries_in_buffer;1381	__u16 info_level;1382	__u32 resume_key;1383	char *ntwrk_buf_start;1384	char *srch_entries_start;1385	char *last_entry;1386	const char *presume_name;1387	unsigned int resume_name_len;1388	bool endOfSearch:1;1389	bool emptyDir:1;1390	bool unicode:1;1391	bool smallBuf:1; /* so we know which buf_release function to call */1392};1393 1394#define ACL_NO_MODE	((umode_t)(-1))1395struct cifs_open_parms {1396	struct cifs_tcon *tcon;1397	struct cifs_sb_info *cifs_sb;1398	int disposition;1399	int desired_access;1400	int create_options;1401	const char *path;1402	struct cifs_fid *fid;1403	umode_t mode;1404	bool reconnect:1;1405	bool replay:1; /* indicates that this open is for a replay */1406	struct kvec *ea_cctx;1407};1408 1409struct cifs_fid {1410	__u16 netfid;1411	__u64 persistent_fid;	/* persist file id for smb2 */1412	__u64 volatile_fid;	/* volatile file id for smb2 */1413	__u8 lease_key[SMB2_LEASE_KEY_SIZE];	/* lease key for smb2 */1414	__u8 create_guid[16];1415	__u32 access;1416	struct cifs_pending_open *pending_open;1417	unsigned int epoch;1418#ifdef CONFIG_CIFS_DEBUG21419	__u64 mid;1420#endif /* CIFS_DEBUG2 */1421	bool purge_cache;1422};1423 1424struct cifs_fid_locks {1425	struct list_head llist;1426	struct cifsFileInfo *cfile;	/* fid that owns locks */1427	struct list_head locks;		/* locks held by fid above */1428};1429 1430struct cifsFileInfo {1431	/* following two lists are protected by tcon->open_file_lock */1432	struct list_head tlist;	/* pointer to next fid owned by tcon */1433	struct list_head flist;	/* next fid (file instance) for this inode */1434	/* lock list below protected by cifsi->lock_sem */1435	struct cifs_fid_locks *llist;	/* brlocks held by this fid */1436	kuid_t uid;		/* allows finding which FileInfo structure */1437	__u32 pid;		/* process id who opened file */1438	struct cifs_fid fid;	/* file id from remote */1439	struct list_head rlist; /* reconnect list */1440	/* BB add lock scope info here if needed */1441	/* lock scope id (0 if none) */1442	struct dentry *dentry;1443	struct tcon_link *tlink;1444	unsigned int f_flags;1445	bool invalidHandle:1;	/* file closed via session abend */1446	bool swapfile:1;1447	bool oplock_break_cancelled:1;1448	bool status_file_deleted:1; /* file has been deleted */1449	bool offload:1; /* offload final part of _put to a wq */1450	unsigned int oplock_epoch; /* epoch from the lease break */1451	__u32 oplock_level; /* oplock/lease level from the lease break */1452	int count;1453	spinlock_t file_info_lock; /* protects four flag/count fields above */1454	struct mutex fh_mutex; /* prevents reopen race after dead ses*/1455	struct cifs_search_info srch_inf;1456	struct work_struct oplock_break; /* work for oplock breaks */1457	struct work_struct put; /* work for the final part of _put */1458	struct work_struct serverclose; /* work for serverclose */1459	struct delayed_work deferred;1460	bool deferred_close_scheduled; /* Flag to indicate close is scheduled */1461	char *symlink_target;1462};1463 1464struct cifs_io_parms {1465	__u16 netfid;1466	__u64 persistent_fid;	/* persist file id for smb2 */1467	__u64 volatile_fid;	/* volatile file id for smb2 */1468	__u32 pid;1469	__u64 offset;1470	unsigned int length;1471	struct cifs_tcon *tcon;1472	struct TCP_Server_Info *server;1473};1474 1475struct cifs_io_request {1476	struct netfs_io_request		rreq;1477	struct cifsFileInfo		*cfile;1478	struct TCP_Server_Info		*server;1479	pid_t				pid;1480};1481 1482/* asynchronous read support */1483struct cifs_io_subrequest {1484	union {1485		struct netfs_io_subrequest subreq;1486		struct netfs_io_request *rreq;1487		struct cifs_io_request *req;1488	};1489	ssize_t				got_bytes;1490	unsigned int			xid;1491	int				result;1492	bool				have_xid;1493	bool				replay;1494	struct kvec			iov[2];1495	struct TCP_Server_Info		*server;1496#ifdef CONFIG_CIFS_SMB_DIRECT1497	struct smbd_mr			*mr;1498#endif1499	struct cifs_credits		credits;1500};1501 1502/*1503 * Take a reference on the file private data. Must be called with1504 * cfile->file_info_lock held.1505 */1506static inline void1507cifsFileInfo_get_locked(struct cifsFileInfo *cifs_file)1508{1509	++cifs_file->count;1510}1511 1512struct cifsFileInfo *cifsFileInfo_get(struct cifsFileInfo *cifs_file);1513void _cifsFileInfo_put(struct cifsFileInfo *cifs_file, bool wait_oplock_hdlr,1514		       bool offload);1515void cifsFileInfo_put(struct cifsFileInfo *cifs_file);1516 1517#define CIFS_CACHE_READ_FLG	11518#define CIFS_CACHE_HANDLE_FLG	21519#define CIFS_CACHE_RH_FLG	(CIFS_CACHE_READ_FLG | CIFS_CACHE_HANDLE_FLG)1520#define CIFS_CACHE_WRITE_FLG	41521#define CIFS_CACHE_RW_FLG	(CIFS_CACHE_READ_FLG | CIFS_CACHE_WRITE_FLG)1522#define CIFS_CACHE_RHW_FLG	(CIFS_CACHE_RW_FLG | CIFS_CACHE_HANDLE_FLG)1523 1524#define CIFS_CACHE_READ(cinode) ((cinode->oplock & CIFS_CACHE_READ_FLG) || (CIFS_SB(cinode->netfs.inode.i_sb)->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE))1525#define CIFS_CACHE_HANDLE(cinode) (cinode->oplock & CIFS_CACHE_HANDLE_FLG)1526#define CIFS_CACHE_WRITE(cinode) ((cinode->oplock & CIFS_CACHE_WRITE_FLG) || (CIFS_SB(cinode->netfs.inode.i_sb)->mnt_cifs_flags & CIFS_MOUNT_RW_CACHE))1527 1528/*1529 * One of these for each file inode1530 */1531 1532struct cifsInodeInfo {1533	struct netfs_inode netfs; /* Netfslib context and vfs inode */1534	bool can_cache_brlcks;1535	struct list_head llist;	/* locks helb by this inode */1536	/*1537	 * NOTE: Some code paths call down_read(lock_sem) twice, so1538	 * we must always use cifs_down_write() instead of down_write()1539	 * for this semaphore to avoid deadlocks.1540	 */1541	struct rw_semaphore lock_sem;	/* protect the fields above */1542	/* BB add in lists for dirty pages i.e. write caching info for oplock */1543	struct list_head openFileList;1544	spinlock_t	open_file_lock;	/* protects openFileList */1545	__u32 cifsAttrs; /* e.g. DOS archive bit, sparse, compressed, system */1546	unsigned int oplock;		/* oplock/lease level we have */1547	unsigned int epoch;		/* used to track lease state changes */1548#define CIFS_INODE_PENDING_OPLOCK_BREAK   (0) /* oplock break in progress */1549#define CIFS_INODE_PENDING_WRITERS	  (1) /* Writes in progress */1550#define CIFS_INODE_FLAG_UNUSED		  (2) /* Unused flag */1551#define CIFS_INO_DELETE_PENDING		  (3) /* delete pending on server */1552#define CIFS_INO_INVALID_MAPPING	  (4) /* pagecache is invalid */1553#define CIFS_INO_LOCK			  (5) /* lock bit for synchronization */1554#define CIFS_INO_CLOSE_ON_LOCK            (7) /* Not to defer the close when lock is set */1555	unsigned long flags;1556	spinlock_t writers_lock;1557	unsigned int writers;		/* Number of writers on this inode */1558	unsigned long time;		/* jiffies of last update of inode */1559	u64  uniqueid;			/* server inode number */1560	u64  createtime;		/* creation time on server */1561	__u8 lease_key[SMB2_LEASE_KEY_SIZE];	/* lease key for this inode */1562	struct list_head deferred_closes; /* list of deferred closes */1563	spinlock_t deferred_lock; /* protection on deferred list */1564	bool lease_granted; /* Flag to indicate whether lease or oplock is granted. */1565	char *symlink_target;1566	__u32 reparse_tag;1567};1568 1569static inline struct cifsInodeInfo *1570CIFS_I(struct inode *inode)1571{1572	return container_of(inode, struct cifsInodeInfo, netfs.inode);1573}1574 1575static inline struct cifs_sb_info *1576CIFS_SB(struct super_block *sb)1577{1578	return sb->s_fs_info;1579}1580 1581static inline struct cifs_sb_info *1582CIFS_FILE_SB(struct file *file)1583{1584	return CIFS_SB(file_inode(file)->i_sb);1585}1586 1587static inline char CIFS_DIR_SEP(const struct cifs_sb_info *cifs_sb)1588{1589	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)1590		return '/';1591	else1592		return '\\';1593}1594 1595static inline void1596convert_delimiter(char *path, char delim)1597{1598	char old_delim, *pos;1599 1600	if (delim == '/')1601		old_delim = '\\';1602	else1603		old_delim = '/';1604 1605	pos = path;1606	while ((pos = strchr(pos, old_delim)))1607		*pos = delim;1608}1609 1610#define cifs_stats_inc atomic_inc1611 1612static inline void cifs_stats_bytes_written(struct cifs_tcon *tcon,1613					    unsigned int bytes)1614{1615	if (bytes) {1616		spin_lock(&tcon->stat_lock);1617		tcon->bytes_written += bytes;1618		spin_unlock(&tcon->stat_lock);1619	}1620}1621 1622static inline void cifs_stats_bytes_read(struct cifs_tcon *tcon,1623					 unsigned int bytes)1624{1625	spin_lock(&tcon->stat_lock);1626	tcon->bytes_read += bytes;1627	spin_unlock(&tcon->stat_lock);1628}1629 1630 1631/*1632 * This is the prototype for the mid receive function. This function is for1633 * receiving the rest of the SMB frame, starting with the WordCount (which is1634 * just after the MID in struct smb_hdr). Note:1635 *1636 * - This will be called by cifsd, with no locks held.1637 * - The mid will still be on the pending_mid_q.1638 * - mid->resp_buf will point to the current buffer.1639 *1640 * Returns zero on a successful receive, or an error. The receive state in1641 * the TCP_Server_Info will also be updated.1642 */1643typedef int (mid_receive_t)(struct TCP_Server_Info *server,1644			    struct mid_q_entry *mid);1645 1646/*1647 * This is the prototype for the mid callback function. This is called once the1648 * mid has been received off of the socket. When creating one, take special1649 * care to avoid deadlocks. Things to bear in mind:1650 *1651 * - it will be called by cifsd, with no locks held1652 * - the mid will be removed from any lists1653 */1654typedef void (mid_callback_t)(struct mid_q_entry *mid);1655 1656/*1657 * This is the protopyte for mid handle function. This is called once the mid1658 * has been recognized after decryption of the message.1659 */1660typedef int (mid_handle_t)(struct TCP_Server_Info *server,1661			    struct mid_q_entry *mid);1662 1663/* one of these for every pending CIFS request to the server */1664struct mid_q_entry {1665	struct list_head qhead;	/* mids waiting on reply from this server */1666	struct kref refcount;1667	struct TCP_Server_Info *server;	/* server corresponding to this mid */1668	__u64 mid;		/* multiplex id */1669	__u16 credits;		/* number of credits consumed by this mid */1670	__u16 credits_received;	/* number of credits from the response */1671	__u32 pid;		/* process id */1672	__u32 sequence_number;  /* for CIFS signing */1673	unsigned long when_alloc;  /* when mid was created */1674#ifdef CONFIG_CIFS_STATS21675	unsigned long when_sent; /* time when smb send finished */1676	unsigned long when_received; /* when demux complete (taken off wire) */1677#endif1678	mid_receive_t *receive; /* call receive callback */1679	mid_callback_t *callback; /* call completion callback */1680	mid_handle_t *handle; /* call handle mid callback */1681	void *callback_data;	  /* general purpose pointer for callback */1682	struct task_struct *creator;1683	void *resp_buf;		/* pointer to received SMB header */1684	unsigned int resp_buf_size;1685	int mid_state;	/* wish this were enum but can not pass to wait_event */1686	unsigned int mid_flags;1687	__le16 command;		/* smb command code */1688	unsigned int optype;	/* operation type */1689	bool large_buf:1;	/* if valid response, is pointer to large buf */1690	bool multiRsp:1;	/* multiple trans2 responses for one request  */1691	bool multiEnd:1;	/* both received */1692	bool decrypted:1;	/* decrypted entry */1693};1694 1695struct close_cancelled_open {1696	struct cifs_fid         fid;1697	struct cifs_tcon        *tcon;1698	struct work_struct      work;1699	__u64 mid;1700	__u16 cmd;1701};1702 1703/*	Make code in transport.c a little cleaner by moving1704	update of optional stats into function below */1705static inline void cifs_in_send_inc(struct TCP_Server_Info *server)1706{1707	atomic_inc(&server->in_send);1708}1709 1710static inline void cifs_in_send_dec(struct TCP_Server_Info *server)1711{1712	atomic_dec(&server->in_send);1713}1714 1715static inline void cifs_num_waiters_inc(struct TCP_Server_Info *server)1716{1717	atomic_inc(&server->num_waiters);1718}1719 1720static inline void cifs_num_waiters_dec(struct TCP_Server_Info *server)1721{1722	atomic_dec(&server->num_waiters);1723}1724 1725#ifdef CONFIG_CIFS_STATS21726static inline void cifs_save_when_sent(struct mid_q_entry *mid)1727{1728	mid->when_sent = jiffies;1729}1730#else1731static inline void cifs_save_when_sent(struct mid_q_entry *mid)1732{1733}1734#endif1735 1736/* for pending dnotify requests */1737struct dir_notify_req {1738	struct list_head lhead;1739	__le16 Pid;1740	__le16 PidHigh;1741	__u16 Mid;1742	__u16 Tid;1743	__u16 Uid;1744	__u16 netfid;1745	__u32 filter; /* CompletionFilter (for multishot) */1746	int multishot;1747	struct file *pfile;1748};1749 1750struct dfs_info3_param {1751	int flags; /* DFSREF_REFERRAL_SERVER, DFSREF_STORAGE_SERVER*/1752	int path_consumed;1753	int server_type;1754	int ref_flag;1755	char *path_name;1756	char *node_name;1757	int ttl;1758};1759 1760struct file_list {1761	struct list_head list;1762	struct cifsFileInfo *cfile;1763};1764 1765struct cifs_mount_ctx {1766	struct cifs_sb_info *cifs_sb;1767	struct smb3_fs_context *fs_ctx;1768	unsigned int xid;1769	struct TCP_Server_Info *server;1770	struct cifs_ses *ses;1771	struct cifs_tcon *tcon;1772};1773 1774static inline void __free_dfs_info_param(struct dfs_info3_param *param)1775{1776	kfree(param->path_name);1777	kfree(param->node_name);1778}1779 1780static inline void free_dfs_info_param(struct dfs_info3_param *param)1781{1782	if (param)1783		__free_dfs_info_param(param);1784}1785 1786static inline void zfree_dfs_info_param(struct dfs_info3_param *param)1787{1788	if (param) {1789		__free_dfs_info_param(param);1790		memset(param, 0, sizeof(*param));1791	}1792}1793 1794static inline void free_dfs_info_array(struct dfs_info3_param *param,1795				       int number_of_items)1796{1797	int i;1798 1799	if ((number_of_items == 0) || (param == NULL))1800		return;1801	for (i = 0; i < number_of_items; i++) {1802		kfree(param[i].path_name);1803		kfree(param[i].node_name);1804	}1805	kfree(param);1806}1807 1808static inline bool is_interrupt_error(int error)1809{1810	switch (error) {1811	case -EINTR:1812	case -ERESTARTSYS:1813	case -ERESTARTNOHAND:1814	case -ERESTARTNOINTR:1815		return true;1816	}1817	return false;1818}1819 1820static inline bool is_retryable_error(int error)1821{1822	if (is_interrupt_error(error) || error == -EAGAIN)1823		return true;1824	return false;1825}1826 1827static inline bool is_replayable_error(int error)1828{1829	if (error == -EAGAIN || error == -ECONNABORTED)1830		return true;1831	return false;1832}1833 1834 1835/* cifs_get_writable_file() flags */1836#define FIND_WR_ANY         01837#define FIND_WR_FSUID_ONLY  11838#define FIND_WR_WITH_DELETE 21839 1840#define   MID_FREE 01841#define   MID_REQUEST_ALLOCATED 11842#define   MID_REQUEST_SUBMITTED 21843#define   MID_RESPONSE_RECEIVED 41844#define   MID_RETRY_NEEDED      8 /* session closed while this request out */1845#define   MID_RESPONSE_MALFORMED 0x101846#define   MID_SHUTDOWN		 0x201847#define   MID_RESPONSE_READY 0x40 /* ready for other process handle the rsp */1848 1849/* Flags */1850#define   MID_WAIT_CANCELLED	 1 /* Cancelled while waiting for response */1851#define   MID_DELETED            2 /* Mid has been dequeued/deleted */1852 1853/* Types of response buffer returned from SendReceive2 */1854#define   CIFS_NO_BUFFER        0    /* Response buffer not returned */1855#define   CIFS_SMALL_BUFFER     11856#define   CIFS_LARGE_BUFFER     21857#define   CIFS_IOVEC            4    /* array of response buffers */1858 1859/* Type of Request to SendReceive2 */1860#define   CIFS_BLOCKING_OP      1    /* operation can block */1861#define   CIFS_NON_BLOCKING     2    /* do not block waiting for credits */1862#define   CIFS_TIMEOUT_MASK 0x003    /* only one of above set in req */1863#define   CIFS_LOG_ERROR    0x010    /* log NT STATUS if non-zero */1864#define   CIFS_LARGE_BUF_OP 0x020    /* large request buffer */1865#define   CIFS_NO_RSP_BUF   0x040    /* no response buffer required */1866 1867/* Type of request operation */1868#define   CIFS_ECHO_OP            0x080  /* echo request */1869#define   CIFS_OBREAK_OP          0x0100 /* oplock break request */1870#define   CIFS_NEG_OP             0x0200 /* negotiate request */1871#define   CIFS_CP_CREATE_CLOSE_OP 0x0400 /* compound create+close request */1872/* Lower bitmask values are reserved by others below. */1873#define   CIFS_SESS_OP            0x2000 /* session setup request */1874#define   CIFS_OP_MASK            0x2780 /* mask request type */1875 1876#define   CIFS_HAS_CREDITS        0x0400 /* already has credits */1877#define   CIFS_TRANSFORM_REQ      0x0800 /* transform request before sending */1878#define   CIFS_NO_SRV_RSP         0x1000 /* there is no server response */1879#define   CIFS_COMPRESS_REQ       0x4000 /* compress request before sending */1880 1881/* Security Flags: indicate type of session setup needed */1882#define   CIFSSEC_MAY_SIGN	0x000011883#define   CIFSSEC_MAY_NTLMV2	0x000041884#define   CIFSSEC_MAY_KRB5	0x000081885#define   CIFSSEC_MAY_SEAL	0x000401886#define   CIFSSEC_MAY_NTLMSSP	0x00080 /* raw ntlmssp with ntlmv2 */1887 1888#define   CIFSSEC_MUST_SIGN	0x010011889/* note that only one of the following can be set so the1890result of setting MUST flags more than once will be to1891require use of the stronger protocol */1892#define   CIFSSEC_MUST_NTLMV2	0x040041893#define   CIFSSEC_MUST_KRB5	0x080081894#ifdef CONFIG_CIFS_UPCALL1895#define   CIFSSEC_MASK          0xCF0CF /* flags supported if no weak allowed */1896#else1897#define	  CIFSSEC_MASK          0xC70C7 /* flags supported if no weak allowed */1898#endif /* UPCALL */1899#define   CIFSSEC_MUST_SEAL	0x400401900#define   CIFSSEC_MUST_NTLMSSP	0x80080 /* raw ntlmssp with ntlmv2 */1901 1902#define   CIFSSEC_DEF (CIFSSEC_MAY_SIGN | CIFSSEC_MAY_NTLMV2 | CIFSSEC_MAY_NTLMSSP | CIFSSEC_MAY_SEAL)1903#define   CIFSSEC_MAX (CIFSSEC_MAY_SIGN | CIFSSEC_MUST_KRB5 | CIFSSEC_MAY_SEAL)1904#define   CIFSSEC_AUTH_MASK (CIFSSEC_MAY_NTLMV2 | CIFSSEC_MAY_KRB5 | CIFSSEC_MAY_NTLMSSP)1905/*1906 *****************************************************************1907 * All constants go here1908 *****************************************************************1909 */1910 1911#define UID_HASH (16)1912 1913/*1914 * Note that ONE module should define _DECLARE_GLOBALS_HERE to cause the1915 * following to be declared.1916 */1917 1918/****************************************************************************1919 * Here are all the locks (spinlock, mutex, semaphore) in cifs.ko, arranged according1920 * to the locking order. i.e. if two locks are to be held together, the lock that1921 * appears higher in this list needs to be taken before the other.1922 *1923 * If you hold a lock that is lower in this list, and you need to take a higher lock1924 * (or if you think that one of the functions that you're calling may need to), first1925 * drop the lock you hold, pick up the higher lock, then the lower one. This will1926 * ensure that locks are picked up only in one direction in the below table1927 * (top to bottom).1928 *1929 * Also, if you expect a function to be called with a lock held, explicitly document1930 * this in the comments on top of your function definition.1931 *1932 * And also, try to keep the critical sections (lock hold time) to be as minimal as1933 * possible. Blocking / calling other functions with a lock held always increase1934 * the risk of a possible deadlock.1935 *1936 * Following this rule will avoid unnecessary deadlocks, which can get really hard to1937 * debug. Also, any new lock that you introduce, please add to this list in the correct1938 * order.1939 *1940 * Please populate this list whenever you introduce new locks in your changes. Or in1941 * case I've missed some existing locks. Please ensure that it's added in the list1942 * based on the locking order expected.1943 *1944 * =====================================================================================1945 * Lock				Protects			Initialization fn1946 * =====================================================================================1947 * vol_list_lock1948 * vol_info->ctx_lock		vol_info->ctx1949 * cifs_sb_info->tlink_tree_lock	cifs_sb_info->tlink_tree	cifs_setup_cifs_sb1950 * TCP_Server_Info->		TCP_Server_Info			cifs_get_tcp_session1951 * reconnect_mutex1952 * TCP_Server_Info->srv_mutex	TCP_Server_Info			cifs_get_tcp_session1953 * cifs_ses->session_mutex		cifs_ses		sesInfoAlloc1954 *				cifs_tcon1955 * cifs_tcon->open_file_lock	cifs_tcon->openFileList		tconInfoAlloc1956 *				cifs_tcon->pending_opens1957 * cifs_tcon->stat_lock		cifs_tcon->bytes_read		tconInfoAlloc1958 *				cifs_tcon->bytes_written1959 * cifs_tcp_ses_lock		cifs_tcp_ses_list		sesInfoAlloc1960 * GlobalMid_Lock		GlobalMaxActiveXid		init_cifs1961 *				GlobalCurrentXid1962 *				GlobalTotalActiveXid1963 * TCP_Server_Info->srv_lock	(anything in struct not protected by another lock and can change)1964 * TCP_Server_Info->mid_lock	TCP_Server_Info->pending_mid_q	cifs_get_tcp_session1965 *				->CurrentMid1966 *				(any changes in mid_q_entry fields)1967 * TCP_Server_Info->req_lock	TCP_Server_Info->in_flight	cifs_get_tcp_session1968 *				->credits1969 *				->echo_credits1970 *				->oplock_credits1971 *				->reconnect_instance1972 * cifs_ses->ses_lock		(anything that is not protected by another lock and can change)1973 * cifs_ses->iface_lock		cifs_ses->iface_list		sesInfoAlloc1974 *				->iface_count1975 *				->iface_last_update1976 * cifs_ses->chan_lock		cifs_ses->chans1977 *				->chans_need_reconnect1978 *				->chans_in_reconnect1979 * cifs_tcon->tc_lock		(anything that is not protected by another lock and can change)1980 * inode->i_rwsem, taken by fs/netfs/locking.c e.g. should be taken before cifsInodeInfo locks1981 * cifsInodeInfo->open_file_lock	cifsInodeInfo->openFileList	cifs_alloc_inode1982 * cifsInodeInfo->writers_lock	cifsInodeInfo->writers		cifsInodeInfo_alloc1983 * cifsInodeInfo->lock_sem	cifsInodeInfo->llist		cifs_init_once1984 *				->can_cache_brlcks1985 * cifsInodeInfo->deferred_lock	cifsInodeInfo->deferred_closes	cifsInodeInfo_alloc1986 * cached_fid->fid_mutex		cifs_tcon->crfid		tcon_info_alloc1987 * cifsFileInfo->fh_mutex		cifsFileInfo			cifs_new_fileinfo1988 * cifsFileInfo->file_info_lock	cifsFileInfo->count		cifs_new_fileinfo1989 *				->invalidHandle			initiate_cifs_search1990 *				->oplock_break_cancelled1991 ****************************************************************************/1992 1993#ifdef DECLARE_GLOBALS_HERE1994#define GLOBAL_EXTERN1995#else1996#define GLOBAL_EXTERN extern1997#endif1998 1999/*2000 * the list of TCP_Server_Info structures, ie each of the sockets2001 * connecting our client to a distinct server (ip address), is2002 * chained together by cifs_tcp_ses_list. The list of all our SMB2003 * sessions (and from that the tree connections) can be found2004 * by iterating over cifs_tcp_ses_list2005 */2006extern struct list_head		cifs_tcp_ses_list;2007 2008/*2009 * This lock protects the cifs_tcp_ses_list, the list of smb sessions per2010 * tcp session, and the list of tcon's per smb session. It also protects2011 * the reference counters for the server, smb session, and tcon.2012 * generally the locks should be taken in order tcp_ses_lock before2013 * tcon->open_file_lock and that before file->file_info_lock since the2014 * structure order is cifs_socket-->cifs_ses-->cifs_tcon-->cifs_file2015 */2016extern spinlock_t		cifs_tcp_ses_lock;2017 2018/*2019 * Global transaction id (XID) information2020 */2021extern unsigned int GlobalCurrentXid;	/* protected by GlobalMid_Lock */2022extern unsigned int GlobalTotalActiveXid; /* prot by GlobalMid_Lock */2023extern unsigned int GlobalMaxActiveXid;	/* prot by GlobalMid_Lock */2024extern spinlock_t GlobalMid_Lock; /* protects above & list operations on midQ entries */2025 2026/*2027 *  Global counters, updated atomically2028 */2029extern atomic_t sesInfoAllocCount;2030extern atomic_t tconInfoAllocCount;2031extern atomic_t tcpSesNextId;2032extern atomic_t tcpSesAllocCount;2033extern atomic_t tcpSesReconnectCount;2034extern atomic_t tconInfoReconnectCount;2035 2036/* Various Debug counters */2037extern atomic_t buf_alloc_count;	/* current number allocated  */2038extern atomic_t small_buf_alloc_count;2039#ifdef CONFIG_CIFS_STATS22040extern atomic_t total_buf_alloc_count; /* total allocated over all time */2041extern atomic_t total_small_buf_alloc_count;2042extern unsigned int slow_rsp_threshold; /* number of secs before logging */2043#endif2044 2045/* Misc globals */2046extern bool enable_oplocks; /* enable or disable oplocks */2047extern bool lookupCacheEnabled;2048extern unsigned int global_secflags;	/* if on, session setup sent2049				with more secure ntlmssp2 challenge/resp */2050extern unsigned int sign_CIFS_PDUs;  /* enable smb packet signing */2051extern bool enable_gcm_256; /* allow optional negotiate of strongest signing (aes-gcm-256) */2052extern bool require_gcm_256; /* require use of strongest signing (aes-gcm-256) */2053extern bool enable_negotiate_signing; /* request use of faster (GMAC) signing if available */2054extern bool linuxExtEnabled;/*enable Linux/Unix CIFS extensions*/2055extern unsigned int CIFSMaxBufSize;  /* max size not including hdr */2056extern unsigned int cifs_min_rcv;    /* min size of big ntwrk buf pool */2057extern unsigned int cifs_min_small;  /* min size of small buf pool */2058extern unsigned int cifs_max_pending; /* MAX requests at once to server*/2059extern unsigned int dir_cache_timeout; /* max time for directory lease caching of dir */2060extern bool disable_legacy_dialects;  /* forbid vers=1.0 and vers=2.0 mounts */2061extern atomic_t mid_count;2062 2063void cifs_oplock_break(struct work_struct *work);2064void cifs_queue_oplock_break(struct cifsFileInfo *cfile);2065void smb2_deferred_work_close(struct work_struct *work);2066 2067extern const struct slow_work_ops cifs_oplock_break_ops;2068extern struct workqueue_struct *cifsiod_wq;2069extern struct workqueue_struct *decrypt_wq;2070extern struct workqueue_struct *fileinfo_put_wq;2071extern struct workqueue_struct *cifsoplockd_wq;2072extern struct workqueue_struct *deferredclose_wq;2073extern struct workqueue_struct *serverclose_wq;2074extern __u32 cifs_lock_secret;2075 2076extern mempool_t *cifs_sm_req_poolp;2077extern mempool_t *cifs_req_poolp;2078extern mempool_t *cifs_mid_poolp;2079extern mempool_t cifs_io_request_pool;2080extern mempool_t cifs_io_subrequest_pool;2081 2082/* Operations for different SMB versions */2083#define SMB1_VERSION_STRING	"1.0"2084#define SMB20_VERSION_STRING    "2.0"2085#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY2086extern struct smb_version_operations smb1_operations;2087extern struct smb_version_values smb1_values;2088extern struct smb_version_operations smb20_operations;2089extern struct smb_version_values smb20_values;2090#endif /* CIFS_ALLOW_INSECURE_LEGACY */2091#define SMB21_VERSION_STRING	"2.1"2092extern struct smb_version_operations smb21_operations;2093extern struct smb_version_values smb21_values;2094#define SMBDEFAULT_VERSION_STRING "default"2095extern struct smb_version_values smbdefault_values;2096#define SMB3ANY_VERSION_STRING "3"2097extern struct smb_version_values smb3any_values;2098#define SMB30_VERSION_STRING	"3.0"2099extern struct smb_version_operations smb30_operations;2100extern struct smb_version_values smb30_values;2101#define SMB302_VERSION_STRING	"3.02"2102#define ALT_SMB302_VERSION_STRING "3.0.2"2103/*extern struct smb_version_operations smb302_operations;*/ /* not needed yet */2104extern struct smb_version_values smb302_values;2105#define SMB311_VERSION_STRING	"3.1.1"2106#define ALT_SMB311_VERSION_STRING "3.11"2107extern struct smb_version_operations smb311_operations;2108extern struct smb_version_values smb311_values;2109 2110static inline char *get_security_type_str(enum securityEnum sectype)2111{2112	switch (sectype) {2113	case RawNTLMSSP:2114		return "RawNTLMSSP";2115	case Kerberos:2116		return "Kerberos";2117	case NTLMv2:2118		return "NTLMv2";2119	default:2120		return "Unknown";2121	}2122}2123 2124static inline bool is_smb1_server(struct TCP_Server_Info *server)2125{2126	return strcmp(server->vals->version_string, SMB1_VERSION_STRING) == 0;2127}2128 2129static inline bool is_tcon_dfs(struct cifs_tcon *tcon)2130{2131	/*2132	 * For SMB1, see MS-CIFS 2.4.55 SMB_COM_TREE_CONNECT_ANDX (0x75) and MS-CIFS 3.3.4.4 DFS2133	 * Subsystem Notifies That a Share Is a DFS Share.2134	 *2135	 * For SMB2+, see MS-SMB2 2.2.10 SMB2 TREE_CONNECT Response and MS-SMB2 3.3.4.14 Server2136	 * Application Updates a Share.2137	 */2138	if (!tcon || !tcon->ses || !tcon->ses->server)2139		return false;2140	return is_smb1_server(tcon->ses->server) ? tcon->Flags & SMB_SHARE_IS_IN_DFS :2141		tcon->share_flags & (SHI1005_FLAGS_DFS | SHI1005_FLAGS_DFS_ROOT);2142}2143 2144static inline bool cifs_is_referral_server(struct cifs_tcon *tcon,2145					   const struct dfs_info3_param *ref)2146{2147	/*2148	 * Check if all targets are capable of handling DFS referrals as per2149	 * MS-DFSC 2.2.4 RESP_GET_DFS_REFERRAL.2150	 */2151	return is_tcon_dfs(tcon) || (ref && (ref->flags & DFSREF_REFERRAL_SERVER));2152}2153 2154static inline u64 cifs_flock_len(const struct file_lock *fl)2155{2156	return (u64)fl->fl_end - fl->fl_start + 1;2157}2158 2159static inline size_t ntlmssp_workstation_name_size(const struct cifs_ses *ses)2160{2161	if (WARN_ON_ONCE(!ses || !ses->server))2162		return 0;2163	/*2164	 * Make workstation name no more than 15 chars when using insecure dialects as some legacy2165	 * servers do require it during NTLMSSP.2166	 */2167	if (ses->server->dialect <= SMB20_PROT_ID)2168		return min_t(size_t, sizeof(ses->workstation_name), RFC1001_NAME_LEN_WITH_NULL);2169	return sizeof(ses->workstation_name);2170}2171 2172static inline void move_cifs_info_to_smb2(struct smb2_file_all_info *dst, const FILE_ALL_INFO *src)2173{2174	memcpy(dst, src, (size_t)((u8 *)&src->AccessFlags - (u8 *)src));2175	dst->AccessFlags = src->AccessFlags;2176	dst->CurrentByteOffset = src->CurrentByteOffset;2177	dst->Mode = src->Mode;2178	dst->AlignmentRequirement = src->AlignmentRequirement;2179	dst->FileNameLength = src->FileNameLength;2180}2181 2182static inline int cifs_get_num_sgs(const struct smb_rqst *rqst,2183				   int num_rqst,2184				   const u8 *sig)2185{2186	unsigned int len, skip;2187	unsigned int nents = 0;2188	unsigned long addr;2189	size_t data_size;2190	int i, j;2191 2192	/*2193	 * The first rqst has a transform header where the first 20 bytes are2194	 * not part of the encrypted blob.2195	 */2196	skip = 20;2197 2198	/* Assumes the first rqst has a transform header as the first iov.2199	 * I.e.2200	 * rqst[0].rq_iov[0]  is transform header2201	 * rqst[0].rq_iov[1+] data to be encrypted/decrypted2202	 * rqst[1+].rq_iov[0+] data to be encrypted/decrypted2203	 */2204	for (i = 0; i < num_rqst; i++) {2205		data_size = iov_iter_count(&rqst[i].rq_iter);2206 2207		/* We really don't want a mixture of pinned and unpinned pages2208		 * in the sglist.  It's hard to keep track of which is what.2209		 * Instead, we convert to a BVEC-type iterator higher up.2210		 */2211		if (data_size &&2212		    WARN_ON_ONCE(user_backed_iter(&rqst[i].rq_iter)))2213			return -EIO;2214 2215		/* We also don't want to have any extra refs or pins to clean2216		 * up in the sglist.2217		 */2218		if (data_size &&2219		    WARN_ON_ONCE(iov_iter_extract_will_pin(&rqst[i].rq_iter)))2220			return -EIO;2221 2222		for (j = 0; j < rqst[i].rq_nvec; j++) {2223			struct kvec *iov = &rqst[i].rq_iov[j];2224 2225			addr = (unsigned long)iov->iov_base + skip;2226			if (unlikely(is_vmalloc_addr((void *)addr))) {2227				len = iov->iov_len - skip;2228				nents += DIV_ROUND_UP(offset_in_page(addr) + len,2229						      PAGE_SIZE);2230			} else {2231				nents++;2232			}2233			skip = 0;2234		}2235		if (data_size)2236			nents += iov_iter_npages(&rqst[i].rq_iter, INT_MAX);2237	}2238	nents += DIV_ROUND_UP(offset_in_page(sig) + SMB2_SIGNATURE_SIZE, PAGE_SIZE);2239	return nents;2240}2241 2242/* We can not use the normal sg_set_buf() as we will sometimes pass a2243 * stack object as buf.2244 */2245static inline void cifs_sg_set_buf(struct sg_table *sgtable,2246				   const void *buf,2247				   unsigned int buflen)2248{2249	unsigned long addr = (unsigned long)buf;2250	unsigned int off = offset_in_page(addr);2251 2252	addr &= PAGE_MASK;2253	if (unlikely(is_vmalloc_addr((void *)addr))) {2254		do {2255			unsigned int len = min_t(unsigned int, buflen, PAGE_SIZE - off);2256 2257			sg_set_page(&sgtable->sgl[sgtable->nents++],2258				    vmalloc_to_page((void *)addr), len, off);2259 2260			off = 0;2261			addr += PAGE_SIZE;2262			buflen -= len;2263		} while (buflen);2264	} else {2265		sg_set_page(&sgtable->sgl[sgtable->nents++],2266			    virt_to_page((void *)addr), buflen, off);2267	}2268}2269 2270#define CIFS_OPARMS(_cifs_sb, _tcon, _path, _da, _cd, _co, _mode) \2271	((struct cifs_open_parms) { \2272		.tcon = _tcon, \2273		.path = _path, \2274		.desired_access = (_da), \2275		.disposition = (_cd), \2276		.create_options = cifs_create_options(_cifs_sb, (_co)), \2277		.mode = (_mode), \2278		.cifs_sb = _cifs_sb, \2279	})2280 2281struct smb2_compound_vars {2282	struct cifs_open_parms oparms;2283	struct kvec rsp_iov[MAX_COMPOUND];2284	struct smb_rqst rqst[MAX_COMPOUND];2285	struct kvec open_iov[SMB2_CREATE_IOV_SIZE];2286	struct kvec qi_iov;2287	struct kvec io_iov[SMB2_IOCTL_IOV_SIZE];2288	struct kvec si_iov[SMB2_SET_INFO_IOV_SIZE];2289	struct kvec close_iov;2290	struct smb2_file_rename_info rename_info;2291	struct smb2_file_link_info link_info;2292	struct kvec ea_iov;2293};2294 2295static inline bool cifs_ses_exiting(struct cifs_ses *ses)2296{2297	bool ret;2298 2299	spin_lock(&ses->ses_lock);2300	ret = ses->ses_status == SES_EXITING;2301	spin_unlock(&ses->ses_lock);2302	return ret;2303}2304 2305#endif	/* _CIFS_GLOB_H */2306