• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1  /*
2   *   fs/cifs/cifsglob.h
3   *
4   *   Copyright (C) International Business Machines  Corp., 2002,2008
5   *   Author(s): Steve French (sfrench@us.ibm.com)
6   *              Jeremy Allison (jra@samba.org)
7   *
8   *   This library is free software; you can redistribute it and/or modify
9   *   it under the terms of the GNU Lesser General Public License as published
10   *   by the Free Software Foundation; either version 2.1 of the License, or
11   *   (at your option) any later version.
12   *
13   *   This library is distributed in the hope that it will be useful,
14   *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15   *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
16   *   the GNU Lesser General Public License for more details.
17   *
18   */
19  #ifndef _CIFS_GLOB_H
20  #define _CIFS_GLOB_H
21  
22  #include <linux/in.h>
23  #include <linux/in6.h>
24  #include <linux/slab.h>
25  #include <linux/scatterlist.h>
26  #include <linux/mm.h>
27  #include <linux/mempool.h>
28  #include <linux/workqueue.h>
29  #include "cifs_fs_sb.h"
30  #include "cifsacl.h"
31  #include <crypto/internal/hash.h>
32  #include <linux/scatterlist.h>
33  #include <uapi/linux/cifs/cifs_mount.h>
34  #include "smb2pdu.h"
35  #include "smb2glob.h"
36  
37  #define CIFS_MAGIC_NUMBER 0xFF534D42      /* the first four bytes of SMB PDUs */
38  
39  #define SMB_PATH_MAX 260
40  #define CIFS_PORT 445
41  #define RFC1001_PORT 139
42  
43  /*
44   * The sizes of various internal tables and strings
45   */
46  #define MAX_UID_INFO 16
47  #define MAX_SES_INFO 2
48  #define MAX_TCON_INFO 4
49  
50  #define MAX_TREE_SIZE (2 + CIFS_NI_MAXHOST + 1 + CIFS_MAX_SHARE_LEN + 1)
51  
52  #define CIFS_MIN_RCV_POOL 4
53  
54  #define MAX_REOPEN_ATT	5 /* these many maximum attempts to reopen a file */
55  /*
56   * default attribute cache timeout (jiffies)
57   */
58  #define CIFS_DEF_ACTIMEO (1 * HZ)
59  
60  /*
61   * max attribute cache timeout (jiffies) - 2^30
62   */
63  #define CIFS_MAX_ACTIMEO (1 << 30)
64  
65  /*
66   * Max persistent and resilient handle timeout (milliseconds).
67   * Windows durable max was 960000 (16 minutes)
68   */
69  #define SMB3_MAX_HANDLE_TIMEOUT 960000
70  
71  /*
72   * MAX_REQ is the maximum number of requests that WE will send
73   * on one socket concurrently.
74   */
75  #define CIFS_MAX_REQ 32767
76  
77  #define RFC1001_NAME_LEN 15
78  #define RFC1001_NAME_LEN_WITH_NULL (RFC1001_NAME_LEN + 1)
79  
80  /* maximum length of ip addr as a string (including ipv6 and sctp) */
81  #define SERVER_NAME_LENGTH 80
82  #define SERVER_NAME_LEN_WITH_NULL     (SERVER_NAME_LENGTH + 1)
83  
84  /* echo interval in seconds */
85  #define SMB_ECHO_INTERVAL_MIN 1
86  #define SMB_ECHO_INTERVAL_MAX 600
87  #define SMB_ECHO_INTERVAL_DEFAULT 60
88  
89  /* maximum number of PDUs in one compound */
90  #define MAX_COMPOUND 5
91  
92  /*
93   * Default number of credits to keep available for SMB3.
94   * This value is chosen somewhat arbitrarily. The Windows client
95   * defaults to 128 credits, the Windows server allows clients up to
96   * 512 credits (or 8K for later versions), and the NetApp server
97   * does not limit clients at all.  Choose a high enough default value
98   * such that the client shouldn't limit performance, but allow mount
99   * to override (until you approach 64K, where we limit credits to 65000
100   * to reduce possibility of seeing more server credit overflow bugs.
101   */
102  #define SMB2_MAX_CREDITS_AVAILABLE 32000
103  
104  #include "cifspdu.h"
105  
106  #ifndef XATTR_DOS_ATTRIB
107  #define XATTR_DOS_ATTRIB "user.DOSATTRIB"
108  #endif
109  
110  /*
111   * CIFS vfs client Status information (based on what we know.)
112   */
113  
114  /* associated with each tcp and smb session */
115  enum statusEnum {
116  	CifsNew = 0,
117  	CifsGood,
118  	CifsExiting,
119  	CifsNeedReconnect,
120  	CifsNeedNegotiate
121  };
122  
123  enum securityEnum {
124  	Unspecified = 0,	/* not specified */
125  	LANMAN,			/* Legacy LANMAN auth */
126  	NTLM,			/* Legacy NTLM012 auth with NTLM hash */
127  	NTLMv2,			/* Legacy NTLM auth with NTLMv2 hash */
128  	RawNTLMSSP,		/* NTLMSSP without SPNEGO, NTLMv2 hash */
129  	Kerberos,		/* Kerberos via SPNEGO */
130  };
131  
132  struct session_key {
133  	unsigned int len;
134  	char *response;
135  };
136  
137  /* crypto security descriptor definition */
138  struct sdesc {
139  	struct shash_desc shash;
140  	char ctx[];
141  };
142  
143  /* crypto hashing related structure/fields, not specific to a sec mech */
144  struct cifs_secmech {
145  	struct crypto_shash *hmacmd5; /* hmac-md5 hash function */
146  	struct crypto_shash *md5; /* md5 hash function */
147  	struct crypto_shash *hmacsha256; /* hmac-sha256 hash function */
148  	struct crypto_shash *cmacaes; /* block-cipher based MAC function */
149  	struct crypto_shash *sha512; /* sha512 hash function */
150  	struct sdesc *sdeschmacmd5;  /* ctxt to generate ntlmv2 hash, CR1 */
151  	struct sdesc *sdescmd5; /* ctxt to generate cifs/smb signature */
152  	struct sdesc *sdeschmacsha256;  /* ctxt to generate smb2 signature */
153  	struct sdesc *sdesccmacaes;  /* ctxt to generate smb3 signature */
154  	struct sdesc *sdescsha512; /* ctxt to generate smb3.11 signing key */
155  	struct crypto_aead *ccmaesencrypt; /* smb3 encryption aead */
156  	struct crypto_aead *ccmaesdecrypt; /* smb3 decryption aead */
157  };
158  
159  /* per smb session structure/fields */
160  struct ntlmssp_auth {
161  	bool sesskey_per_smbsess; /* whether session key is per smb session */
162  	__u32 client_flags; /* sent by client in type 1 ntlmsssp exchange */
163  	__u32 server_flags; /* sent by server in type 2 ntlmssp exchange */
164  	unsigned char ciphertext[CIFS_CPHTXT_SIZE]; /* sent to server */
165  	char cryptkey[CIFS_CRYPTO_KEY_SIZE]; /* used by ntlmssp */
166  };
167  
168  struct cifs_cred {
169  	int uid;
170  	int gid;
171  	int mode;
172  	int cecount;
173  	struct cifs_sid osid;
174  	struct cifs_sid gsid;
175  	struct cifs_ntace *ntaces;
176  	struct cifs_ace *aces;
177  };
178  
179  /*
180   *****************************************************************
181   * Except the CIFS PDUs themselves all the
182   * globally interesting structs should go here
183   *****************************************************************
184   */
185  
186  /*
187   * A smb_rqst represents a complete request to be issued to a server. It's
188   * formed by a kvec array, followed by an array of pages. Page data is assumed
189   * to start at the beginning of the first page.
190   */
191  struct smb_rqst {
192  	struct kvec	*rq_iov;	/* array of kvecs */
193  	unsigned int	rq_nvec;	/* number of kvecs in array */
194  	struct page	**rq_pages;	/* pointer to array of page ptrs */
195  	unsigned int	rq_offset;	/* the offset to the 1st page */
196  	unsigned int	rq_npages;	/* number pages in array */
197  	unsigned int	rq_pagesz;	/* page size to use */
198  	unsigned int	rq_tailsz;	/* length of last page */
199  };
200  
201  enum smb_version {
202  	Smb_1 = 1,
203  	Smb_20,
204  	Smb_21,
205  	Smb_30,
206  	Smb_302,
207  	Smb_311,
208  	Smb_3any,
209  	Smb_default,
210  	Smb_version_err
211  };
212  
213  struct mid_q_entry;
214  struct TCP_Server_Info;
215  struct cifsFileInfo;
216  struct cifs_ses;
217  struct cifs_tcon;
218  struct dfs_info3_param;
219  struct cifs_fattr;
220  struct smb_vol;
221  struct cifs_fid;
222  struct cifs_readdata;
223  struct cifs_writedata;
224  struct cifs_io_parms;
225  struct cifs_search_info;
226  struct cifsInodeInfo;
227  struct cifs_open_parms;
228  struct cifs_credits;
229  
230  struct smb_version_operations {
231  	int (*send_cancel)(struct TCP_Server_Info *, struct smb_rqst *,
232  			   struct mid_q_entry *);
233  	bool (*compare_fids)(struct cifsFileInfo *, struct cifsFileInfo *);
234  	/* setup request: allocate mid, sign message */
235  	struct mid_q_entry *(*setup_request)(struct cifs_ses *,
236  						struct smb_rqst *);
237  	/* setup async request: allocate mid, sign message */
238  	struct mid_q_entry *(*setup_async_request)(struct TCP_Server_Info *,
239  						struct smb_rqst *);
240  	/* check response: verify signature, map error */
241  	int (*check_receive)(struct mid_q_entry *, struct TCP_Server_Info *,
242  			     bool);
243  	void (*add_credits)(struct TCP_Server_Info *server,
244  			    const struct cifs_credits *credits,
245  			    const int optype);
246  	void (*set_credits)(struct TCP_Server_Info *, const int);
247  	int * (*get_credits_field)(struct TCP_Server_Info *, const int);
248  	unsigned int (*get_credits)(struct mid_q_entry *);
249  	__u64 (*get_next_mid)(struct TCP_Server_Info *);
250  	void (*revert_current_mid)(struct TCP_Server_Info *server,
251  				   const unsigned int val);
252  	/* data offset from read response message */
253  	unsigned int (*read_data_offset)(char *);
254  	/*
255  	 * Data length from read response message
256  	 * When in_remaining is true, the returned data length is in
257  	 * message field DataRemaining for out-of-band data read (e.g through
258  	 * Memory Registration RDMA write in SMBD).
259  	 * Otherwise, the returned data length is in message field DataLength.
260  	 */
261  	unsigned int (*read_data_length)(char *, bool in_remaining);
262  	/* map smb to linux error */
263  	int (*map_error)(char *, bool);
264  	/* find mid corresponding to the response message */
265  	struct mid_q_entry * (*find_mid)(struct TCP_Server_Info *, char *);
266  	void (*dump_detail)(void *buf, struct TCP_Server_Info *ptcp_info);
267  	void (*clear_stats)(struct cifs_tcon *);
268  	void (*print_stats)(struct seq_file *m, struct cifs_tcon *);
269  	void (*dump_share_caps)(struct seq_file *, struct cifs_tcon *);
270  	/* verify the message */
271  	int (*check_message)(char *, unsigned int, struct TCP_Server_Info *);
272  	bool (*is_oplock_break)(char *, struct TCP_Server_Info *);
273  	int (*handle_cancelled_mid)(char *, struct TCP_Server_Info *);
274  	void (*downgrade_oplock)(struct TCP_Server_Info *server,
275  				 struct cifsInodeInfo *cinode, __u32 oplock,
276  				 unsigned int epoch, bool *purge_cache);
277  	/* process transaction2 response */
278  	bool (*check_trans2)(struct mid_q_entry *, struct TCP_Server_Info *,
279  			     char *, int);
280  	/* check if we need to negotiate */
281  	bool (*need_neg)(struct TCP_Server_Info *);
282  	/* negotiate to the server */
283  	int (*negotiate)(const unsigned int, struct cifs_ses *);
284  	/* set negotiated write size */
285  	unsigned int (*negotiate_wsize)(struct cifs_tcon *, struct smb_vol *);
286  	/* set negotiated read size */
287  	unsigned int (*negotiate_rsize)(struct cifs_tcon *, struct smb_vol *);
288  	/* setup smb sessionn */
289  	int (*sess_setup)(const unsigned int, struct cifs_ses *,
290  			  const struct nls_table *);
291  	/* close smb session */
292  	int (*logoff)(const unsigned int, struct cifs_ses *);
293  	/* connect to a server share */
294  	int (*tree_connect)(const unsigned int, struct cifs_ses *, const char *,
295  			    struct cifs_tcon *, const struct nls_table *);
296  	/* close tree connecion */
297  	int (*tree_disconnect)(const unsigned int, struct cifs_tcon *);
298  	/* get DFS referrals */
299  	int (*get_dfs_refer)(const unsigned int, struct cifs_ses *,
300  			     const char *, struct dfs_info3_param **,
301  			     unsigned int *, const struct nls_table *, int);
302  	/* informational QFS call */
303  	void (*qfs_tcon)(const unsigned int, struct cifs_tcon *,
304  			 struct cifs_sb_info *);
305  	/* check if a path is accessible or not */
306  	int (*is_path_accessible)(const unsigned int, struct cifs_tcon *,
307  				  struct cifs_sb_info *, const char *);
308  	/* query path data from the server */
309  	int (*query_path_info)(const unsigned int, struct cifs_tcon *,
310  			       struct cifs_sb_info *, const char *,
311  			       FILE_ALL_INFO *, bool *, bool *);
312  	/* query file data from the server */
313  	int (*query_file_info)(const unsigned int, struct cifs_tcon *,
314  			       struct cifs_fid *, FILE_ALL_INFO *);
315  	/* get server index number */
316  	int (*get_srv_inum)(const unsigned int, struct cifs_tcon *,
317  			    struct cifs_sb_info *, const char *,
318  			    u64 *uniqueid, FILE_ALL_INFO *);
319  	/* set size by path */
320  	int (*set_path_size)(const unsigned int, struct cifs_tcon *,
321  			     const char *, __u64, struct cifs_sb_info *, bool);
322  	/* set size by file handle */
323  	int (*set_file_size)(const unsigned int, struct cifs_tcon *,
324  			     struct cifsFileInfo *, __u64, bool);
325  	/* set attributes */
326  	int (*set_file_info)(struct inode *, const char *, FILE_BASIC_INFO *,
327  			     const unsigned int);
328  	int (*set_compression)(const unsigned int, struct cifs_tcon *,
329  			       struct cifsFileInfo *);
330  	/* check if we can send an echo or nor */
331  	bool (*can_echo)(struct TCP_Server_Info *);
332  	/* send echo request */
333  	int (*echo)(struct TCP_Server_Info *);
334  	/* create directory */
335  	int (*posix_mkdir)(const unsigned int xid, struct inode *inode,
336  			umode_t mode, struct cifs_tcon *tcon,
337  			const char *full_path,
338  			struct cifs_sb_info *cifs_sb);
339  	int (*mkdir)(const unsigned int xid, struct inode *inode, umode_t mode,
340  		     struct cifs_tcon *tcon, const char *name,
341  		     struct cifs_sb_info *sb);
342  	/* set info on created directory */
343  	void (*mkdir_setinfo)(struct inode *, const char *,
344  			      struct cifs_sb_info *, struct cifs_tcon *,
345  			      const unsigned int);
346  	/* remove directory */
347  	int (*rmdir)(const unsigned int, struct cifs_tcon *, const char *,
348  		     struct cifs_sb_info *);
349  	/* unlink file */
350  	int (*unlink)(const unsigned int, struct cifs_tcon *, const char *,
351  		      struct cifs_sb_info *);
352  	/* open, rename and delete file */
353  	int (*rename_pending_delete)(const char *, struct dentry *,
354  				     const unsigned int);
355  	/* send rename request */
356  	int (*rename)(const unsigned int, struct cifs_tcon *, const char *,
357  		      const char *, struct cifs_sb_info *);
358  	/* send create hardlink request */
359  	int (*create_hardlink)(const unsigned int, struct cifs_tcon *,
360  			       const char *, const char *,
361  			       struct cifs_sb_info *);
362  	/* query symlink target */
363  	int (*query_symlink)(const unsigned int, struct cifs_tcon *,
364  			     struct cifs_sb_info *, const char *,
365  			     char **, bool);
366  	/* open a file for non-posix mounts */
367  	int (*open)(const unsigned int, struct cifs_open_parms *,
368  		    __u32 *, FILE_ALL_INFO *);
369  	/* set fid protocol-specific info */
370  	void (*set_fid)(struct cifsFileInfo *, struct cifs_fid *, __u32);
371  	/* close a file */
372  	void (*close)(const unsigned int, struct cifs_tcon *,
373  		      struct cifs_fid *);
374  	/* send a flush request to the server */
375  	int (*flush)(const unsigned int, struct cifs_tcon *, struct cifs_fid *);
376  	/* async read from the server */
377  	int (*async_readv)(struct cifs_readdata *);
378  	/* async write to the server */
379  	int (*async_writev)(struct cifs_writedata *,
380  			    void (*release)(struct kref *));
381  	/* sync read from the server */
382  	int (*sync_read)(const unsigned int, struct cifs_fid *,
383  			 struct cifs_io_parms *, unsigned int *, char **,
384  			 int *);
385  	/* sync write to the server */
386  	int (*sync_write)(const unsigned int, struct cifs_fid *,
387  			  struct cifs_io_parms *, unsigned int *, struct kvec *,
388  			  unsigned long);
389  	/* open dir, start readdir */
390  	int (*query_dir_first)(const unsigned int, struct cifs_tcon *,
391  			       const char *, struct cifs_sb_info *,
392  			       struct cifs_fid *, __u16,
393  			       struct cifs_search_info *);
394  	/* continue readdir */
395  	int (*query_dir_next)(const unsigned int, struct cifs_tcon *,
396  			      struct cifs_fid *,
397  			      __u16, struct cifs_search_info *srch_inf);
398  	/* close dir */
399  	int (*close_dir)(const unsigned int, struct cifs_tcon *,
400  			 struct cifs_fid *);
401  	/* calculate a size of SMB message */
402  	unsigned int (*calc_smb_size)(void *buf, struct TCP_Server_Info *ptcpi);
403  	/* check for STATUS_PENDING and process the response if yes */
404  	bool (*is_status_pending)(char *buf, struct TCP_Server_Info *server);
405  	/* check for STATUS_NETWORK_SESSION_EXPIRED */
406  	bool (*is_session_expired)(char *);
407  	/* send oplock break response */
408  	int (*oplock_response)(struct cifs_tcon *, struct cifs_fid *,
409  			       struct cifsInodeInfo *);
410  	/* query remote filesystem */
411  	int (*queryfs)(const unsigned int, struct cifs_tcon *,
412  		       struct cifs_sb_info *, struct kstatfs *);
413  	/* send mandatory brlock to the server */
414  	int (*mand_lock)(const unsigned int, struct cifsFileInfo *, __u64,
415  			 __u64, __u32, int, int, bool);
416  	/* unlock range of mandatory locks */
417  	int (*mand_unlock_range)(struct cifsFileInfo *, struct file_lock *,
418  				 const unsigned int);
419  	/* push brlocks from the cache to the server */
420  	int (*push_mand_locks)(struct cifsFileInfo *);
421  	/* get lease key of the inode */
422  	void (*get_lease_key)(struct inode *, struct cifs_fid *);
423  	/* set lease key of the inode */
424  	void (*set_lease_key)(struct inode *, struct cifs_fid *);
425  	/* generate new lease key */
426  	void (*new_lease_key)(struct cifs_fid *);
427  	int (*generate_signingkey)(struct cifs_ses *);
428  	int (*calc_signature)(struct smb_rqst *, struct TCP_Server_Info *);
429  	int (*set_integrity)(const unsigned int, struct cifs_tcon *tcon,
430  			     struct cifsFileInfo *src_file);
431  	int (*enum_snapshots)(const unsigned int xid, struct cifs_tcon *tcon,
432  			     struct cifsFileInfo *src_file, void __user *);
433  	int (*query_mf_symlink)(unsigned int, struct cifs_tcon *,
434  				struct cifs_sb_info *, const unsigned char *,
435  				char *, unsigned int *);
436  	int (*create_mf_symlink)(unsigned int, struct cifs_tcon *,
437  				 struct cifs_sb_info *, const unsigned char *,
438  				 char *, unsigned int *);
439  	/* if we can do cache read operations */
440  	bool (*is_read_op)(__u32);
441  	/* set oplock level for the inode */
442  	void (*set_oplock_level)(struct cifsInodeInfo *, __u32, unsigned int,
443  				 bool *);
444  	/* create lease context buffer for CREATE request */
445  	char * (*create_lease_buf)(u8 *lease_key, u8 oplock);
446  	/* parse lease context buffer and return oplock/epoch info */
447  	__u8 (*parse_lease_buf)(void *buf, unsigned int *epoch, char *lkey);
448  	ssize_t (*copychunk_range)(const unsigned int,
449  			struct cifsFileInfo *src_file,
450  			struct cifsFileInfo *target_file,
451  			u64 src_off, u64 len, u64 dest_off);
452  	int (*duplicate_extents)(const unsigned int, struct cifsFileInfo *src,
453  			struct cifsFileInfo *target_file, u64 src_off, u64 len,
454  			u64 dest_off);
455  	int (*validate_negotiate)(const unsigned int, struct cifs_tcon *);
456  	ssize_t (*query_all_EAs)(const unsigned int, struct cifs_tcon *,
457  			const unsigned char *, const unsigned char *, char *,
458  			size_t, struct cifs_sb_info *);
459  	int (*set_EA)(const unsigned int, struct cifs_tcon *, const char *,
460  			const char *, const void *, const __u16,
461  			const struct nls_table *, struct cifs_sb_info *);
462  	struct cifs_ntsd * (*get_acl)(struct cifs_sb_info *, struct inode *,
463  			const char *, u32 *);
464  	struct cifs_ntsd * (*get_acl_by_fid)(struct cifs_sb_info *,
465  			const struct cifs_fid *, u32 *);
466  	int (*set_acl)(struct cifs_ntsd *, __u32, struct inode *, const char *,
467  			int);
468  	/* writepages retry size */
469  	unsigned int (*wp_retry_size)(struct inode *);
470  	/* get mtu credits */
471  	int (*wait_mtu_credits)(struct TCP_Server_Info *, unsigned int,
472  				unsigned int *, struct cifs_credits *);
473  	/* adjust previously taken mtu credits to request size */
474  	int (*adjust_credits)(struct TCP_Server_Info *server,
475  			      struct cifs_credits *credits,
476  			      const unsigned int payload_size);
477  	/* check if we need to issue closedir */
478  	bool (*dir_needs_close)(struct cifsFileInfo *);
479  	long (*fallocate)(struct file *, struct cifs_tcon *, int, loff_t,
480  			  loff_t);
481  	/* init transform request - used for encryption for now */
482  	int (*init_transform_rq)(struct TCP_Server_Info *, int num_rqst,
483  				 struct smb_rqst *, struct smb_rqst *);
484  	int (*is_transform_hdr)(void *buf);
485  	int (*receive_transform)(struct TCP_Server_Info *,
486  				 struct mid_q_entry **, char **, int *);
487  	enum securityEnum (*select_sectype)(struct TCP_Server_Info *,
488  			    enum securityEnum);
489  	int (*next_header)(char *);
490  	/* ioctl passthrough for query_info */
491  	int (*ioctl_query_info)(const unsigned int xid,
492  				struct cifs_tcon *tcon,
493  				struct cifs_sb_info *cifs_sb,
494  				__le16 *path, int is_dir,
495  				unsigned long p);
496  	/* make unix special files (block, char, fifo, socket) */
497  	int (*make_node)(unsigned int xid,
498  			 struct inode *inode,
499  			 struct dentry *dentry,
500  			 struct cifs_tcon *tcon,
501  			 char *full_path,
502  			 umode_t mode,
503  			 dev_t device_number);
504  	/* version specific fiemap implementation */
505  	int (*fiemap)(struct cifs_tcon *tcon, struct cifsFileInfo *,
506  		      struct fiemap_extent_info *, u64, u64);
507  	/* version specific llseek implementation */
508  	loff_t (*llseek)(struct file *, struct cifs_tcon *, loff_t, int);
509  };
510  
511  struct smb_version_values {
512  	char		*version_string;
513  	__u16		protocol_id;
514  	__u32		req_capabilities;
515  	__u32		large_lock_type;
516  	__u32		exclusive_lock_type;
517  	__u32		shared_lock_type;
518  	__u32		unlock_lock_type;
519  	size_t		header_preamble_size;
520  	size_t		header_size;
521  	size_t		max_header_size;
522  	size_t		read_rsp_size;
523  	__le16		lock_cmd;
524  	unsigned int	cap_unix;
525  	unsigned int	cap_nt_find;
526  	unsigned int	cap_large_files;
527  	__u16		signing_enabled;
528  	__u16		signing_required;
529  	size_t		create_lease_size;
530  };
531  
532  #define HEADER_SIZE(server) (server->vals->header_size)
533  #define MAX_HEADER_SIZE(server) (server->vals->max_header_size)
534  
535  struct smb_vol {
536  	char *username;
537  	char *password;
538  	char *domainname;
539  	char *UNC;
540  	char *iocharset;  /* local code page for mapping to and from Unicode */
541  	char source_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* clnt nb name */
542  	char target_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* srvr nb name */
543  	kuid_t cred_uid;
544  	kuid_t linux_uid;
545  	kgid_t linux_gid;
546  	kuid_t backupuid;
547  	kgid_t backupgid;
548  	umode_t file_mode;
549  	umode_t dir_mode;
550  	enum securityEnum sectype; /* sectype requested via mnt opts */
551  	bool sign; /* was signing requested via mnt opts? */
552  	bool ignore_signature:1;
553  	bool retry:1;
554  	bool intr:1;
555  	bool setuids:1;
556  	bool setuidfromacl:1;
557  	bool override_uid:1;
558  	bool override_gid:1;
559  	bool dynperm:1;
560  	bool noperm:1;
561  	bool mode_ace:1;
562  	bool no_psx_acl:1; /* set if posix acl support should be disabled */
563  	bool cifs_acl:1;
564  	bool backupuid_specified; /* mount option  backupuid  is specified */
565  	bool backupgid_specified; /* mount option  backupgid  is specified */
566  	bool no_xattr:1;   /* set if xattr (EA) support should be disabled*/
567  	bool server_ino:1; /* use inode numbers from server ie UniqueId */
568  	bool direct_io:1;
569  	bool strict_io:1; /* strict cache behavior */
570  	bool cache_ro:1;
571  	bool cache_rw:1;
572  	bool remap:1;      /* set to remap seven reserved chars in filenames */
573  	bool sfu_remap:1;  /* remap seven reserved chars ala SFU */
574  	bool posix_paths:1; /* unset to not ask for posix pathnames. */
575  	bool no_linux_ext:1;
576  	bool linux_ext:1;
577  	bool sfu_emul:1;
578  	bool nullauth:1;   /* attempt to authenticate with null user */
579  	bool nocase:1;     /* request case insensitive filenames */
580  	bool nobrl:1;      /* disable sending byte range locks to srv */
581  	bool nohandlecache:1; /* disable caching dir handles if srvr probs */
582  	bool mand_lock:1;  /* send mandatory not posix byte range lock reqs */
583  	bool seal:1;       /* request transport encryption on share */
584  	bool nodfs:1;      /* Do not request DFS, even if available */
585  	bool local_lease:1; /* check leases only on local system, not remote */
586  	bool noblocksnd:1;
587  	bool noautotune:1;
588  	bool nostrictsync:1; /* do not force expensive SMBflush on every sync */
589  	bool no_lease:1;     /* disable requesting leases */
590  	bool fsc:1;	/* enable fscache */
591  	bool mfsymlinks:1; /* use Minshall+French Symlinks */
592  	bool multiuser:1;
593  	bool rwpidforward:1; /* pid forward for read/write operations */
594  	bool nosharesock:1;
595  	bool persistent:1;
596  	bool nopersistent:1;
597  	bool resilient:1; /* noresilient not required since not fored for CA */
598  	bool domainauto:1;
599  	bool rdma:1;
600  	unsigned int bsize;
601  	unsigned int rsize;
602  	unsigned int wsize;
603  	unsigned int min_offload;
604  	bool sockopt_tcp_nodelay:1;
605  	unsigned long actimeo; /* attribute cache timeout (jiffies) */
606  	struct smb_version_operations *ops;
607  	struct smb_version_values *vals;
608  	char *prepath;
609  	struct sockaddr_storage dstaddr; /* destination address */
610  	struct sockaddr_storage srcaddr; /* allow binding to a local IP */
611  	struct nls_table *local_nls;
612  	unsigned int echo_interval; /* echo interval in secs */
613  	__u64 snapshot_time; /* needed for timewarp tokens */
614  	__u32 handle_timeout; /* persistent and durable handle timeout in ms */
615  	unsigned int max_credits; /* smb3 max_credits 10 < credits < 60000 */
616  	__u16 compression; /* compression algorithm 0xFFFF default 0=disabled */
617  	bool rootfs:1; /* if it's a SMB root file system */
618  };
619  
620  /**
621   * CIFS superblock mount flags (mnt_cifs_flags) to consider when
622   * trying to reuse existing superblock for a new mount
623   */
624  #define CIFS_MOUNT_MASK (CIFS_MOUNT_NO_PERM | CIFS_MOUNT_SET_UID | \
625  			 CIFS_MOUNT_SERVER_INUM | CIFS_MOUNT_DIRECT_IO | \
626  			 CIFS_MOUNT_NO_XATTR | CIFS_MOUNT_MAP_SPECIAL_CHR | \
627  			 CIFS_MOUNT_MAP_SFM_CHR | \
628  			 CIFS_MOUNT_UNX_EMUL | CIFS_MOUNT_NO_BRL | \
629  			 CIFS_MOUNT_CIFS_ACL | CIFS_MOUNT_OVERR_UID | \
630  			 CIFS_MOUNT_OVERR_GID | CIFS_MOUNT_DYNPERM | \
631  			 CIFS_MOUNT_NOPOSIXBRL | CIFS_MOUNT_NOSSYNC | \
632  			 CIFS_MOUNT_FSCACHE | CIFS_MOUNT_MF_SYMLINKS | \
633  			 CIFS_MOUNT_MULTIUSER | CIFS_MOUNT_STRICT_IO | \
634  			 CIFS_MOUNT_CIFS_BACKUPUID | CIFS_MOUNT_CIFS_BACKUPGID | \
635  			 CIFS_MOUNT_UID_FROM_ACL | CIFS_MOUNT_NO_HANDLE_CACHE | \
636  			 CIFS_MOUNT_NO_DFS | CIFS_MOUNT_MODE_FROM_SID | \
637  			 CIFS_MOUNT_RO_CACHE | CIFS_MOUNT_RW_CACHE)
638  
639  /**
640   * Generic VFS superblock mount flags (s_flags) to consider when
641   * trying to reuse existing superblock for a new mount
642   */
643  #define CIFS_MS_MASK (SB_RDONLY | SB_MANDLOCK | SB_NOEXEC | SB_NOSUID | \
644  		      SB_NODEV | SB_SYNCHRONOUS)
645  
646  struct cifs_mnt_data {
647  	struct cifs_sb_info *cifs_sb;
648  	struct smb_vol *vol;
649  	int flags;
650  };
651  
652  static inline unsigned int
get_rfc1002_length(void * buf)653  get_rfc1002_length(void *buf)
654  {
655  	return be32_to_cpu(*((__be32 *)buf)) & 0xffffff;
656  }
657  
658  static inline void
inc_rfc1001_len(void * buf,int count)659  inc_rfc1001_len(void *buf, int count)
660  {
661  	be32_add_cpu((__be32 *)buf, count);
662  }
663  
664  struct TCP_Server_Info {
665  	struct list_head tcp_ses_list;
666  	struct list_head smb_ses_list;
667  	int srv_count; /* reference counter */
668  	/* 15 character server name + 0x20 16th byte indicating type = srv */
669  	char server_RFC1001_name[RFC1001_NAME_LEN_WITH_NULL];
670  	struct smb_version_operations	*ops;
671  	struct smb_version_values	*vals;
672  	enum statusEnum tcpStatus; /* what we think the status is */
673  	char *hostname; /* hostname portion of UNC string */
674  	struct socket *ssocket;
675  	struct sockaddr_storage dstaddr;
676  	struct sockaddr_storage srcaddr; /* locally bind to this IP */
677  #ifdef CONFIG_NET_NS
678  	struct net *net;
679  #endif
680  	wait_queue_head_t response_q;
681  	wait_queue_head_t request_q; /* if more than maxmpx to srvr must block*/
682  	struct list_head pending_mid_q;
683  	bool noblocksnd;		/* use blocking sendmsg */
684  	bool noautotune;		/* do not autotune send buf sizes */
685  	bool tcp_nodelay;
686  	unsigned int credits;  /* send no more requests at once */
687  	unsigned int max_credits; /* can override large 32000 default at mnt */
688  	unsigned int in_flight;  /* number of requests on the wire to server */
689  	unsigned int max_in_flight; /* max number of requests that were on wire */
690  	spinlock_t req_lock;  /* protect the two values above */
691  	struct mutex srv_mutex;
692  	struct task_struct *tsk;
693  	char server_GUID[16];
694  	__u16 sec_mode;
695  	bool sign; /* is signing enabled on this connection? */
696  	bool ignore_signature:1; /* skip validation of signatures in SMB2/3 rsp */
697  	bool session_estab; /* mark when very first sess is established */
698  	int echo_credits;  /* echo reserved slots */
699  	int oplock_credits;  /* oplock break reserved slots */
700  	bool echoes:1; /* enable echoes */
701  	__u8 client_guid[SMB2_CLIENT_GUID_SIZE]; /* Client GUID */
702  	u16 dialect; /* dialect index that server chose */
703  	bool oplocks:1; /* enable oplocks */
704  	unsigned int maxReq;	/* Clients should submit no more */
705  	/* than maxReq distinct unanswered SMBs to the server when using  */
706  	/* multiplexed reads or writes (for SMB1/CIFS only, not SMB2/SMB3) */
707  	unsigned int maxBuf;	/* maxBuf specifies the maximum */
708  	/* message size the server can send or receive for non-raw SMBs */
709  	/* maxBuf is returned by SMB NegotiateProtocol so maxBuf is only 0 */
710  	/* when socket is setup (and during reconnect) before NegProt sent */
711  	unsigned int max_rw;	/* maxRw specifies the maximum */
712  	/* message size the server can send or receive for */
713  	/* SMB_COM_WRITE_RAW or SMB_COM_READ_RAW. */
714  	unsigned int capabilities; /* selective disabling of caps by smb sess */
715  	int timeAdj;  /* Adjust for difference in server time zone in sec */
716  	__u64 CurrentMid;         /* multiplex id - rotating counter */
717  	char cryptkey[CIFS_CRYPTO_KEY_SIZE]; /* used by ntlm, ntlmv2 etc */
718  	/* 16th byte of RFC1001 workstation name is always null */
719  	char workstation_RFC1001_name[RFC1001_NAME_LEN_WITH_NULL];
720  	__u32 sequence_number; /* for signing, protected by srv_mutex */
721  	__u32 reconnect_instance; /* incremented on each reconnect */
722  	struct session_key session_key;
723  	unsigned long lstrp; /* when we got last response from this server */
724  	struct cifs_secmech secmech; /* crypto sec mech functs, descriptors */
725  #define	CIFS_NEGFLAVOR_LANMAN	0	/* wct == 13, LANMAN */
726  #define	CIFS_NEGFLAVOR_UNENCAP	1	/* wct == 17, but no ext_sec */
727  #define	CIFS_NEGFLAVOR_EXTENDED	2	/* wct == 17, ext_sec bit set */
728  	char	negflavor;	/* NEGOTIATE response flavor */
729  	/* extended security flavors that server supports */
730  	bool	sec_ntlmssp;		/* supports NTLMSSP */
731  	bool	sec_kerberosu2u;	/* supports U2U Kerberos */
732  	bool	sec_kerberos;		/* supports plain Kerberos */
733  	bool	sec_mskerberos;		/* supports legacy MS Kerberos */
734  	bool	large_buf;		/* is current buffer large? */
735  	/* use SMBD connection instead of socket */
736  	bool	rdma;
737  	/* point to the SMBD connection if RDMA is used instead of socket */
738  	struct smbd_connection *smbd_conn;
739  	struct delayed_work	echo; /* echo ping workqueue job */
740  	char	*smallbuf;	/* pointer to current "small" buffer */
741  	char	*bigbuf;	/* pointer to current "big" buffer */
742  	/* Total size of this PDU. Only valid from cifs_demultiplex_thread */
743  	unsigned int pdu_size;
744  	unsigned int total_read; /* total amount of data read in this pass */
745  #ifdef CONFIG_CIFS_FSCACHE
746  	struct fscache_cookie   *fscache; /* client index cache cookie */
747  #endif
748  #ifdef CONFIG_CIFS_STATS2
749  	atomic_t in_send; /* requests trying to send */
750  	atomic_t num_waiters;   /* blocked waiting to get in sendrecv */
751  	atomic_t num_cmds[NUMBER_OF_SMB2_COMMANDS]; /* total requests by cmd */
752  	atomic_t smb2slowcmd[NUMBER_OF_SMB2_COMMANDS]; /* count resps > 1 sec */
753  	__u64 time_per_cmd[NUMBER_OF_SMB2_COMMANDS]; /* total time per cmd */
754  	__u32 slowest_cmd[NUMBER_OF_SMB2_COMMANDS];
755  	__u32 fastest_cmd[NUMBER_OF_SMB2_COMMANDS];
756  #endif /* STATS2 */
757  	unsigned int	max_read;
758  	unsigned int	max_write;
759  	unsigned int	min_offload;
760  	__le16	compress_algorithm;
761  	__le16	cipher_type;
762  	 /* save initital negprot hash */
763  	__u8	preauth_sha_hash[SMB2_PREAUTH_HASH_SIZE];
764  	bool	posix_ext_supported;
765  	struct delayed_work reconnect; /* reconnect workqueue job */
766  	struct mutex reconnect_mutex; /* prevent simultaneous reconnects */
767  	unsigned long echo_interval;
768  
769  	/*
770  	 * Number of targets available for reconnect. The more targets
771  	 * the more tasks have to wait to let the demultiplex thread
772  	 * reconnect.
773  	 */
774  	int nr_targets;
775  	bool noblockcnt; /* use non-blocking connect() */
776  };
777  
778  struct cifs_credits {
779  	unsigned int value;
780  	unsigned int instance;
781  };
782  
783  static inline unsigned int
in_flight(struct TCP_Server_Info * server)784  in_flight(struct TCP_Server_Info *server)
785  {
786  	unsigned int num;
787  	spin_lock(&server->req_lock);
788  	num = server->in_flight;
789  	spin_unlock(&server->req_lock);
790  	return num;
791  }
792  
793  static inline bool
has_credits(struct TCP_Server_Info * server,int * credits,int num_credits)794  has_credits(struct TCP_Server_Info *server, int *credits, int num_credits)
795  {
796  	int num;
797  	spin_lock(&server->req_lock);
798  	num = *credits;
799  	spin_unlock(&server->req_lock);
800  	return num >= num_credits;
801  }
802  
803  static inline void
add_credits(struct TCP_Server_Info * server,const struct cifs_credits * credits,const int optype)804  add_credits(struct TCP_Server_Info *server, const struct cifs_credits *credits,
805  	    const int optype)
806  {
807  	server->ops->add_credits(server, credits, optype);
808  }
809  
810  static inline void
add_credits_and_wake_if(struct TCP_Server_Info * server,const struct cifs_credits * credits,const int optype)811  add_credits_and_wake_if(struct TCP_Server_Info *server,
812  			const struct cifs_credits *credits, const int optype)
813  {
814  	if (credits->value) {
815  		server->ops->add_credits(server, credits, optype);
816  		wake_up(&server->request_q);
817  	}
818  }
819  
820  static inline void
set_credits(struct TCP_Server_Info * server,const int val)821  set_credits(struct TCP_Server_Info *server, const int val)
822  {
823  	server->ops->set_credits(server, val);
824  }
825  
826  static inline int
adjust_credits(struct TCP_Server_Info * server,struct cifs_credits * credits,const unsigned int payload_size)827  adjust_credits(struct TCP_Server_Info *server, struct cifs_credits *credits,
828  	       const unsigned int payload_size)
829  {
830  	return server->ops->adjust_credits ?
831  		server->ops->adjust_credits(server, credits, payload_size) : 0;
832  }
833  
834  static inline __le64
get_next_mid64(struct TCP_Server_Info * server)835  get_next_mid64(struct TCP_Server_Info *server)
836  {
837  	return cpu_to_le64(server->ops->get_next_mid(server));
838  }
839  
840  static inline __le16
get_next_mid(struct TCP_Server_Info * server)841  get_next_mid(struct TCP_Server_Info *server)
842  {
843  	__u16 mid = server->ops->get_next_mid(server);
844  	/*
845  	 * The value in the SMB header should be little endian for easy
846  	 * on-the-wire decoding.
847  	 */
848  	return cpu_to_le16(mid);
849  }
850  
851  static inline void
revert_current_mid(struct TCP_Server_Info * server,const unsigned int val)852  revert_current_mid(struct TCP_Server_Info *server, const unsigned int val)
853  {
854  	if (server->ops->revert_current_mid)
855  		server->ops->revert_current_mid(server, val);
856  }
857  
858  static inline void
revert_current_mid_from_hdr(struct TCP_Server_Info * server,const struct smb2_sync_hdr * shdr)859  revert_current_mid_from_hdr(struct TCP_Server_Info *server,
860  			    const struct smb2_sync_hdr *shdr)
861  {
862  	unsigned int num = le16_to_cpu(shdr->CreditCharge);
863  
864  	return revert_current_mid(server, num > 0 ? num : 1);
865  }
866  
867  static inline __u16
get_mid(const struct smb_hdr * smb)868  get_mid(const struct smb_hdr *smb)
869  {
870  	return le16_to_cpu(smb->Mid);
871  }
872  
873  static inline bool
compare_mid(__u16 mid,const struct smb_hdr * smb)874  compare_mid(__u16 mid, const struct smb_hdr *smb)
875  {
876  	return mid == le16_to_cpu(smb->Mid);
877  }
878  
879  /*
880   * When the server supports very large reads and writes via POSIX extensions,
881   * we can allow up to 2^24-1, minus the size of a READ/WRITE_AND_X header, not
882   * including the RFC1001 length.
883   *
884   * Note that this might make for "interesting" allocation problems during
885   * writeback however as we have to allocate an array of pointers for the
886   * pages. A 16M write means ~32kb page array with PAGE_SIZE == 4096.
887   *
888   * For reads, there is a similar problem as we need to allocate an array
889   * of kvecs to handle the receive, though that should only need to be done
890   * once.
891   */
892  #define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
893  #define CIFS_MAX_RSIZE ((1<<24) - sizeof(READ_RSP) + 4)
894  
895  /*
896   * When the server doesn't allow large posix writes, only allow a rsize/wsize
897   * of 2^17-1 minus the size of the call header. That allows for a read or
898   * write up to the maximum size described by RFC1002.
899   */
900  #define CIFS_MAX_RFC1002_WSIZE ((1<<17) - 1 - sizeof(WRITE_REQ) + 4)
901  #define CIFS_MAX_RFC1002_RSIZE ((1<<17) - 1 - sizeof(READ_RSP) + 4)
902  
903  /*
904   * The default wsize is 1M. find_get_pages seems to return a maximum of 256
905   * pages in a single call. With PAGE_SIZE == 4k, this means we can fill
906   * a single wsize request with a single call.
907   */
908  #define CIFS_DEFAULT_IOSIZE (1024 * 1024)
909  #define SMB3_DEFAULT_IOSIZE (4 * 1024 * 1024)
910  
911  /*
912   * Windows only supports a max of 60kb reads and 65535 byte writes. Default to
913   * those values when posix extensions aren't in force. In actuality here, we
914   * use 65536 to allow for a write that is a multiple of 4k. Most servers seem
915   * to be ok with the extra byte even though Windows doesn't send writes that
916   * are that large.
917   *
918   * Citation:
919   *
920   * http://blogs.msdn.com/b/openspecification/archive/2009/04/10/smb-maximum-transmit-buffer-size-and-performance-tuning.aspx
921   */
922  #define CIFS_DEFAULT_NON_POSIX_RSIZE (60 * 1024)
923  #define CIFS_DEFAULT_NON_POSIX_WSIZE (65536)
924  
925  /*
926   * Macros to allow the TCP_Server_Info->net field and related code to drop out
927   * when CONFIG_NET_NS isn't set.
928   */
929  
930  #ifdef CONFIG_NET_NS
931  
cifs_net_ns(struct TCP_Server_Info * srv)932  static inline struct net *cifs_net_ns(struct TCP_Server_Info *srv)
933  {
934  	return srv->net;
935  }
936  
cifs_set_net_ns(struct TCP_Server_Info * srv,struct net * net)937  static inline void cifs_set_net_ns(struct TCP_Server_Info *srv, struct net *net)
938  {
939  	srv->net = net;
940  }
941  
942  #else
943  
cifs_net_ns(struct TCP_Server_Info * srv)944  static inline struct net *cifs_net_ns(struct TCP_Server_Info *srv)
945  {
946  	return &init_net;
947  }
948  
cifs_set_net_ns(struct TCP_Server_Info * srv,struct net * net)949  static inline void cifs_set_net_ns(struct TCP_Server_Info *srv, struct net *net)
950  {
951  }
952  
953  #endif
954  
955  struct cifs_server_iface {
956  	size_t speed;
957  	unsigned int rdma_capable : 1;
958  	unsigned int rss_capable : 1;
959  	struct sockaddr_storage sockaddr;
960  };
961  
962  /*
963   * Session structure.  One of these for each uid session with a particular host
964   */
965  struct cifs_ses {
966  	struct list_head smb_ses_list;
967  	struct list_head tcon_list;
968  	struct cifs_tcon *tcon_ipc;
969  	struct mutex session_mutex;
970  	struct TCP_Server_Info *server;	/* pointer to server info */
971  	int ses_count;		/* reference counter */
972  	enum statusEnum status;  /* updates protected by GlobalMid_Lock */
973  	unsigned overrideSecFlg;  /* if non-zero override global sec flags */
974  	char *serverOS;		/* name of operating system underlying server */
975  	char *serverNOS;	/* name of network operating system of server */
976  	char *serverDomain;	/* security realm of server */
977  	__u64 Suid;		/* remote smb uid  */
978  	kuid_t linux_uid;	/* overriding owner of files on the mount */
979  	kuid_t cred_uid;	/* owner of credentials */
980  	unsigned int capabilities;
981  	char serverName[SERVER_NAME_LEN_WITH_NULL];
982  	char *user_name;	/* must not be null except during init of sess
983  				   and after mount option parsing we fill it */
984  	char *domainName;
985  	char *password;
986  	struct session_key auth_key;
987  	struct ntlmssp_auth *ntlmssp; /* ciphertext, flags, server challenge */
988  	enum securityEnum sectype; /* what security flavor was specified? */
989  	bool sign;		/* is signing required? */
990  	bool need_reconnect:1; /* connection reset, uid now invalid */
991  	bool domainAuto:1;
992  	__u16 session_flags;
993  	__u8 smb3signingkey[SMB3_SIGN_KEY_SIZE];
994  	__u8 smb3encryptionkey[SMB3_SIGN_KEY_SIZE];
995  	__u8 smb3decryptionkey[SMB3_SIGN_KEY_SIZE];
996  	__u8 preauth_sha_hash[SMB2_PREAUTH_HASH_SIZE];
997  
998  	/*
999  	 * Network interfaces available on the server this session is
1000  	 * connected to.
1001  	 *
1002  	 * Other channels can be opened by connecting and binding this
1003  	 * session to interfaces from this list.
1004  	 *
1005  	 * iface_lock should be taken when accessing any of these fields
1006  	 */
1007  	spinlock_t iface_lock;
1008  	struct cifs_server_iface *iface_list;
1009  	size_t iface_count;
1010  	unsigned long iface_last_update; /* jiffies */
1011  };
1012  
1013  static inline bool
cap_unix(struct cifs_ses * ses)1014  cap_unix(struct cifs_ses *ses)
1015  {
1016  	return ses->server->vals->cap_unix & ses->capabilities;
1017  }
1018  
1019  struct cached_fid {
1020  	bool is_valid:1;	/* Do we have a useable root fid */
1021  	bool file_all_info_is_valid:1;
1022  
1023  	struct kref refcount;
1024  	struct cifs_fid *fid;
1025  	struct mutex fid_mutex;
1026  	struct cifs_tcon *tcon;
1027  	struct work_struct lease_break;
1028  	struct smb2_file_all_info file_all_info;
1029  };
1030  
1031  /*
1032   * there is one of these for each connection to a resource on a particular
1033   * session
1034   */
1035  struct cifs_tcon {
1036  	struct list_head tcon_list;
1037  	int tc_count;
1038  	struct list_head rlist; /* reconnect list */
1039  	atomic_t num_local_opens;  /* num of all opens including disconnected */
1040  	atomic_t num_remote_opens; /* num of all network opens on server */
1041  	struct list_head openFileList;
1042  	spinlock_t open_file_lock; /* protects list above */
1043  	struct cifs_ses *ses;	/* pointer to session associated with */
1044  	char treeName[MAX_TREE_SIZE + 1]; /* UNC name of resource in ASCII */
1045  	char *nativeFileSystem;
1046  	char *password;		/* for share-level security */
1047  	__u32 tid;		/* The 4 byte tree id */
1048  	__u16 Flags;		/* optional support bits */
1049  	enum statusEnum tidStatus;
1050  	atomic_t num_smbs_sent;
1051  	union {
1052  		struct {
1053  			atomic_t num_writes;
1054  			atomic_t num_reads;
1055  			atomic_t num_flushes;
1056  			atomic_t num_oplock_brks;
1057  			atomic_t num_opens;
1058  			atomic_t num_closes;
1059  			atomic_t num_deletes;
1060  			atomic_t num_mkdirs;
1061  			atomic_t num_posixopens;
1062  			atomic_t num_posixmkdirs;
1063  			atomic_t num_rmdirs;
1064  			atomic_t num_renames;
1065  			atomic_t num_t2renames;
1066  			atomic_t num_ffirst;
1067  			atomic_t num_fnext;
1068  			atomic_t num_fclose;
1069  			atomic_t num_hardlinks;
1070  			atomic_t num_symlinks;
1071  			atomic_t num_locks;
1072  			atomic_t num_acl_get;
1073  			atomic_t num_acl_set;
1074  		} cifs_stats;
1075  		struct {
1076  			atomic_t smb2_com_sent[NUMBER_OF_SMB2_COMMANDS];
1077  			atomic_t smb2_com_failed[NUMBER_OF_SMB2_COMMANDS];
1078  		} smb2_stats;
1079  	} stats;
1080  	__u64    bytes_read;
1081  	__u64    bytes_written;
1082  	spinlock_t stat_lock;  /* protects the two fields above */
1083  	FILE_SYSTEM_DEVICE_INFO fsDevInfo;
1084  	FILE_SYSTEM_ATTRIBUTE_INFO fsAttrInfo; /* ok if fs name truncated */
1085  	FILE_SYSTEM_UNIX_INFO fsUnixInfo;
1086  	bool ipc:1;   /* set if connection to IPC$ share (always also pipe) */
1087  	bool pipe:1;  /* set if connection to pipe share */
1088  	bool print:1; /* set if connection to printer share */
1089  	bool retry:1;
1090  	bool nocase:1;
1091  	bool nohandlecache:1; /* if strange server resource prob can turn off */
1092  	bool seal:1;      /* transport encryption for this mounted share */
1093  	bool unix_ext:1;  /* if false disable Linux extensions to CIFS protocol
1094  				for this mount even if server would support */
1095  	bool posix_extensions; /* if true SMB3.11 posix extensions enabled */
1096  	bool local_lease:1; /* check leases (only) on local system not remote */
1097  	bool broken_posix_open; /* e.g. Samba server versions < 3.3.2, 3.2.9 */
1098  	bool broken_sparse_sup; /* if server or share does not support sparse */
1099  	bool need_reconnect:1; /* connection reset, tid now invalid */
1100  	bool need_reopen_files:1; /* need to reopen tcon file handles */
1101  	bool use_resilient:1; /* use resilient instead of durable handles */
1102  	bool use_persistent:1; /* use persistent instead of durable handles */
1103  	bool no_lease:1;    /* Do not request leases on files or directories */
1104  	__le32 capabilities;
1105  	__u32 share_flags;
1106  	__u32 maximal_access;
1107  	__u32 vol_serial_number;
1108  	__le64 vol_create_time;
1109  	__u64 snapshot_time; /* for timewarp tokens - timestamp of snapshot */
1110  	__u32 handle_timeout; /* persistent and durable handle timeout in ms */
1111  	__u32 ss_flags;		/* sector size flags */
1112  	__u32 perf_sector_size; /* best sector size for perf */
1113  	__u32 max_chunks;
1114  	__u32 max_bytes_chunk;
1115  	__u32 max_bytes_copy;
1116  #ifdef CONFIG_CIFS_FSCACHE
1117  	u64 resource_id;		/* server resource id */
1118  	struct fscache_cookie *fscache;	/* cookie for share */
1119  #endif
1120  	struct list_head pending_opens;	/* list of incomplete opens */
1121  	struct cached_fid crfid; /* Cached root fid */
1122  	/* BB add field for back pointer to sb struct(s)? */
1123  #ifdef CONFIG_CIFS_DFS_UPCALL
1124  	char *dfs_path;
1125  	int remap:2;
1126  	struct list_head ulist; /* cache update list */
1127  #endif
1128  };
1129  
1130  /*
1131   * This is a refcounted and timestamped container for a tcon pointer. The
1132   * container holds a tcon reference. It is considered safe to free one of
1133   * these when the tl_count goes to 0. The tl_time is the time of the last
1134   * "get" on the container.
1135   */
1136  struct tcon_link {
1137  	struct rb_node		tl_rbnode;
1138  	kuid_t			tl_uid;
1139  	unsigned long		tl_flags;
1140  #define TCON_LINK_MASTER	0
1141  #define TCON_LINK_PENDING	1
1142  #define TCON_LINK_IN_TREE	2
1143  	unsigned long		tl_time;
1144  	atomic_t		tl_count;
1145  	struct cifs_tcon	*tl_tcon;
1146  };
1147  
1148  extern struct tcon_link *cifs_sb_tlink(struct cifs_sb_info *cifs_sb);
1149  extern void smb3_free_compound_rqst(int num_rqst, struct smb_rqst *rqst);
1150  
1151  static inline struct cifs_tcon *
tlink_tcon(struct tcon_link * tlink)1152  tlink_tcon(struct tcon_link *tlink)
1153  {
1154  	return tlink->tl_tcon;
1155  }
1156  
1157  static inline struct tcon_link *
cifs_sb_master_tlink(struct cifs_sb_info * cifs_sb)1158  cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
1159  {
1160  	return cifs_sb->master_tlink;
1161  }
1162  
1163  extern void cifs_put_tlink(struct tcon_link *tlink);
1164  
1165  static inline struct tcon_link *
cifs_get_tlink(struct tcon_link * tlink)1166  cifs_get_tlink(struct tcon_link *tlink)
1167  {
1168  	if (tlink && !IS_ERR(tlink))
1169  		atomic_inc(&tlink->tl_count);
1170  	return tlink;
1171  }
1172  
1173  /* This function is always expected to succeed */
1174  extern struct cifs_tcon *cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb);
1175  
1176  #define CIFS_OPLOCK_NO_CHANGE 0xfe
1177  
1178  struct cifs_pending_open {
1179  	struct list_head olist;
1180  	struct tcon_link *tlink;
1181  	__u8 lease_key[16];
1182  	__u32 oplock;
1183  };
1184  
1185  /*
1186   * This info hangs off the cifsFileInfo structure, pointed to by llist.
1187   * This is used to track byte stream locks on the file
1188   */
1189  struct cifsLockInfo {
1190  	struct list_head llist;	/* pointer to next cifsLockInfo */
1191  	struct list_head blist; /* pointer to locks blocked on this */
1192  	wait_queue_head_t block_q;
1193  	__u64 offset;
1194  	__u64 length;
1195  	__u32 pid;
1196  	__u16 type;
1197  	__u16 flags;
1198  };
1199  
1200  /*
1201   * One of these for each open instance of a file
1202   */
1203  struct cifs_search_info {
1204  	loff_t index_of_last_entry;
1205  	__u16 entries_in_buffer;
1206  	__u16 info_level;
1207  	__u32 resume_key;
1208  	char *ntwrk_buf_start;
1209  	char *srch_entries_start;
1210  	char *last_entry;
1211  	const char *presume_name;
1212  	unsigned int resume_name_len;
1213  	bool endOfSearch:1;
1214  	bool emptyDir:1;
1215  	bool unicode:1;
1216  	bool smallBuf:1; /* so we know which buf_release function to call */
1217  };
1218  
1219  #define ACL_NO_MODE	((umode_t)(-1))
1220  struct cifs_open_parms {
1221  	struct cifs_tcon *tcon;
1222  	struct cifs_sb_info *cifs_sb;
1223  	int disposition;
1224  	int desired_access;
1225  	int create_options;
1226  	const char *path;
1227  	struct cifs_fid *fid;
1228  	umode_t mode;
1229  	bool reconnect:1;
1230  };
1231  
1232  struct cifs_fid {
1233  	__u16 netfid;
1234  	__u64 persistent_fid;	/* persist file id for smb2 */
1235  	__u64 volatile_fid;	/* volatile file id for smb2 */
1236  	__u8 lease_key[SMB2_LEASE_KEY_SIZE];	/* lease key for smb2 */
1237  	__u8 create_guid[16];
1238  	__u32 access;
1239  	struct cifs_pending_open *pending_open;
1240  	unsigned int epoch;
1241  #ifdef CONFIG_CIFS_DEBUG2
1242  	__u64 mid;
1243  #endif /* CIFS_DEBUG2 */
1244  	bool purge_cache;
1245  };
1246  
1247  struct cifs_fid_locks {
1248  	struct list_head llist;
1249  	struct cifsFileInfo *cfile;	/* fid that owns locks */
1250  	struct list_head locks;		/* locks held by fid above */
1251  };
1252  
1253  struct cifsFileInfo {
1254  	/* following two lists are protected by tcon->open_file_lock */
1255  	struct list_head tlist;	/* pointer to next fid owned by tcon */
1256  	struct list_head flist;	/* next fid (file instance) for this inode */
1257  	/* lock list below protected by cifsi->lock_sem */
1258  	struct cifs_fid_locks *llist;	/* brlocks held by this fid */
1259  	kuid_t uid;		/* allows finding which FileInfo structure */
1260  	__u32 pid;		/* process id who opened file */
1261  	struct cifs_fid fid;	/* file id from remote */
1262  	struct list_head rlist; /* reconnect list */
1263  	/* BB add lock scope info here if needed */ ;
1264  	/* lock scope id (0 if none) */
1265  	struct dentry *dentry;
1266  	struct tcon_link *tlink;
1267  	unsigned int f_flags;
1268  	bool invalidHandle:1;	/* file closed via session abend */
1269  	bool oplock_break_cancelled:1;
1270  	unsigned int oplock_epoch; /* epoch from the lease break */
1271  	__u32 oplock_level; /* oplock/lease level from the lease break */
1272  	int count;
1273  	spinlock_t file_info_lock; /* protects four flag/count fields above */
1274  	struct mutex fh_mutex; /* prevents reopen race after dead ses*/
1275  	struct cifs_search_info srch_inf;
1276  	struct work_struct oplock_break; /* work for oplock breaks */
1277  	struct work_struct put; /* work for the final part of _put */
1278  };
1279  
1280  struct cifs_io_parms {
1281  	__u16 netfid;
1282  	__u64 persistent_fid;	/* persist file id for smb2 */
1283  	__u64 volatile_fid;	/* volatile file id for smb2 */
1284  	__u32 pid;
1285  	__u64 offset;
1286  	unsigned int length;
1287  	struct cifs_tcon *tcon;
1288  };
1289  
1290  struct cifs_aio_ctx {
1291  	struct kref		refcount;
1292  	struct list_head	list;
1293  	struct mutex		aio_mutex;
1294  	struct completion	done;
1295  	struct iov_iter		iter;
1296  	struct kiocb		*iocb;
1297  	struct cifsFileInfo	*cfile;
1298  	struct bio_vec		*bv;
1299  	loff_t			pos;
1300  	unsigned int		npages;
1301  	ssize_t			rc;
1302  	unsigned int		len;
1303  	unsigned int		total_len;
1304  	bool			should_dirty;
1305  	/*
1306  	 * Indicates if this aio_ctx is for direct_io,
1307  	 * If yes, iter is a copy of the user passed iov_iter
1308  	 */
1309  	bool			direct_io;
1310  };
1311  
1312  struct cifs_readdata;
1313  
1314  /* asynchronous read support */
1315  struct cifs_readdata {
1316  	struct kref			refcount;
1317  	struct list_head		list;
1318  	struct completion		done;
1319  	struct cifsFileInfo		*cfile;
1320  	struct address_space		*mapping;
1321  	struct cifs_aio_ctx		*ctx;
1322  	__u64				offset;
1323  	unsigned int			bytes;
1324  	unsigned int			got_bytes;
1325  	pid_t				pid;
1326  	int				result;
1327  	struct work_struct		work;
1328  	int (*read_into_pages)(struct TCP_Server_Info *server,
1329  				struct cifs_readdata *rdata,
1330  				unsigned int len);
1331  	int (*copy_into_pages)(struct TCP_Server_Info *server,
1332  				struct cifs_readdata *rdata,
1333  				struct iov_iter *iter);
1334  	struct kvec			iov[2];
1335  #ifdef CONFIG_CIFS_SMB_DIRECT
1336  	struct smbd_mr			*mr;
1337  #endif
1338  	unsigned int			pagesz;
1339  	unsigned int			page_offset;
1340  	unsigned int			tailsz;
1341  	struct cifs_credits		credits;
1342  	unsigned int			nr_pages;
1343  	struct page			**pages;
1344  };
1345  
1346  struct cifs_writedata;
1347  
1348  /* asynchronous write support */
1349  struct cifs_writedata {
1350  	struct kref			refcount;
1351  	struct list_head		list;
1352  	struct completion		done;
1353  	enum writeback_sync_modes	sync_mode;
1354  	struct work_struct		work;
1355  	struct cifsFileInfo		*cfile;
1356  	struct cifs_aio_ctx		*ctx;
1357  	__u64				offset;
1358  	pid_t				pid;
1359  	unsigned int			bytes;
1360  	int				result;
1361  #ifdef CONFIG_CIFS_SMB_DIRECT
1362  	struct smbd_mr			*mr;
1363  #endif
1364  	unsigned int			pagesz;
1365  	unsigned int			page_offset;
1366  	unsigned int			tailsz;
1367  	struct cifs_credits		credits;
1368  	unsigned int			nr_pages;
1369  	struct page			**pages;
1370  };
1371  
1372  /*
1373   * Take a reference on the file private data. Must be called with
1374   * cfile->file_info_lock held.
1375   */
1376  static inline void
cifsFileInfo_get_locked(struct cifsFileInfo * cifs_file)1377  cifsFileInfo_get_locked(struct cifsFileInfo *cifs_file)
1378  {
1379  	++cifs_file->count;
1380  }
1381  
1382  struct cifsFileInfo *cifsFileInfo_get(struct cifsFileInfo *cifs_file);
1383  void _cifsFileInfo_put(struct cifsFileInfo *cifs_file, bool wait_oplock_hdlr,
1384  		       bool offload);
1385  void cifsFileInfo_put(struct cifsFileInfo *cifs_file);
1386  
1387  #define CIFS_CACHE_READ_FLG	1
1388  #define CIFS_CACHE_HANDLE_FLG	2
1389  #define CIFS_CACHE_RH_FLG	(CIFS_CACHE_READ_FLG | CIFS_CACHE_HANDLE_FLG)
1390  #define CIFS_CACHE_WRITE_FLG	4
1391  #define CIFS_CACHE_RW_FLG	(CIFS_CACHE_READ_FLG | CIFS_CACHE_WRITE_FLG)
1392  #define CIFS_CACHE_RHW_FLG	(CIFS_CACHE_RW_FLG | CIFS_CACHE_HANDLE_FLG)
1393  
1394  #define CIFS_CACHE_READ(cinode) ((cinode->oplock & CIFS_CACHE_READ_FLG) || (CIFS_SB(cinode->vfs_inode.i_sb)->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE))
1395  #define CIFS_CACHE_HANDLE(cinode) (cinode->oplock & CIFS_CACHE_HANDLE_FLG)
1396  #define CIFS_CACHE_WRITE(cinode) ((cinode->oplock & CIFS_CACHE_WRITE_FLG) || (CIFS_SB(cinode->vfs_inode.i_sb)->mnt_cifs_flags & CIFS_MOUNT_RW_CACHE))
1397  
1398  /*
1399   * One of these for each file inode
1400   */
1401  
1402  struct cifsInodeInfo {
1403  	bool can_cache_brlcks;
1404  	struct list_head llist;	/* locks helb by this inode */
1405  	/*
1406  	 * NOTE: Some code paths call down_read(lock_sem) twice, so
1407  	 * we must always use use cifs_down_write() instead of down_write()
1408  	 * for this semaphore to avoid deadlocks.
1409  	 */
1410  	struct rw_semaphore lock_sem;	/* protect the fields above */
1411  	/* BB add in lists for dirty pages i.e. write caching info for oplock */
1412  	struct list_head openFileList;
1413  	spinlock_t	open_file_lock;	/* protects openFileList */
1414  	__u32 cifsAttrs; /* e.g. DOS archive bit, sparse, compressed, system */
1415  	unsigned int oplock;		/* oplock/lease level we have */
1416  	unsigned int epoch;		/* used to track lease state changes */
1417  #define CIFS_INODE_PENDING_OPLOCK_BREAK   (0) /* oplock break in progress */
1418  #define CIFS_INODE_PENDING_WRITERS	  (1) /* Writes in progress */
1419  #define CIFS_INODE_FLAG_UNUSED		  (2) /* Unused flag */
1420  #define CIFS_INO_DELETE_PENDING		  (3) /* delete pending on server */
1421  #define CIFS_INO_INVALID_MAPPING	  (4) /* pagecache is invalid */
1422  #define CIFS_INO_LOCK			  (5) /* lock bit for synchronization */
1423  	unsigned long flags;
1424  	spinlock_t writers_lock;
1425  	unsigned int writers;		/* Number of writers on this inode */
1426  	unsigned long time;		/* jiffies of last update of inode */
1427  	u64  server_eof;		/* current file size on server -- protected by i_lock */
1428  	u64  uniqueid;			/* server inode number */
1429  	u64  createtime;		/* creation time on server */
1430  	__u8 lease_key[SMB2_LEASE_KEY_SIZE];	/* lease key for this inode */
1431  #ifdef CONFIG_CIFS_FSCACHE
1432  	struct fscache_cookie *fscache;
1433  #endif
1434  	struct inode vfs_inode;
1435  };
1436  
1437  static inline struct cifsInodeInfo *
CIFS_I(struct inode * inode)1438  CIFS_I(struct inode *inode)
1439  {
1440  	return container_of(inode, struct cifsInodeInfo, vfs_inode);
1441  }
1442  
1443  static inline struct cifs_sb_info *
CIFS_SB(struct super_block * sb)1444  CIFS_SB(struct super_block *sb)
1445  {
1446  	return sb->s_fs_info;
1447  }
1448  
1449  static inline struct cifs_sb_info *
CIFS_FILE_SB(struct file * file)1450  CIFS_FILE_SB(struct file *file)
1451  {
1452  	return CIFS_SB(file_inode(file)->i_sb);
1453  }
1454  
CIFS_DIR_SEP(const struct cifs_sb_info * cifs_sb)1455  static inline char CIFS_DIR_SEP(const struct cifs_sb_info *cifs_sb)
1456  {
1457  	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
1458  		return '/';
1459  	else
1460  		return '\\';
1461  }
1462  
1463  static inline void
convert_delimiter(char * path,char delim)1464  convert_delimiter(char *path, char delim)
1465  {
1466  	char old_delim, *pos;
1467  
1468  	if (delim == '/')
1469  		old_delim = '\\';
1470  	else
1471  		old_delim = '/';
1472  
1473  	pos = path;
1474  	while ((pos = strchr(pos, old_delim)))
1475  		*pos = delim;
1476  }
1477  
1478  #define cifs_stats_inc atomic_inc
1479  
cifs_stats_bytes_written(struct cifs_tcon * tcon,unsigned int bytes)1480  static inline void cifs_stats_bytes_written(struct cifs_tcon *tcon,
1481  					    unsigned int bytes)
1482  {
1483  	if (bytes) {
1484  		spin_lock(&tcon->stat_lock);
1485  		tcon->bytes_written += bytes;
1486  		spin_unlock(&tcon->stat_lock);
1487  	}
1488  }
1489  
cifs_stats_bytes_read(struct cifs_tcon * tcon,unsigned int bytes)1490  static inline void cifs_stats_bytes_read(struct cifs_tcon *tcon,
1491  					 unsigned int bytes)
1492  {
1493  	spin_lock(&tcon->stat_lock);
1494  	tcon->bytes_read += bytes;
1495  	spin_unlock(&tcon->stat_lock);
1496  }
1497  
1498  
1499  /*
1500   * This is the prototype for the mid receive function. This function is for
1501   * receiving the rest of the SMB frame, starting with the WordCount (which is
1502   * just after the MID in struct smb_hdr). Note:
1503   *
1504   * - This will be called by cifsd, with no locks held.
1505   * - The mid will still be on the pending_mid_q.
1506   * - mid->resp_buf will point to the current buffer.
1507   *
1508   * Returns zero on a successful receive, or an error. The receive state in
1509   * the TCP_Server_Info will also be updated.
1510   */
1511  typedef int (mid_receive_t)(struct TCP_Server_Info *server,
1512  			    struct mid_q_entry *mid);
1513  
1514  /*
1515   * This is the prototype for the mid callback function. This is called once the
1516   * mid has been received off of the socket. When creating one, take special
1517   * care to avoid deadlocks. Things to bear in mind:
1518   *
1519   * - it will be called by cifsd, with no locks held
1520   * - the mid will be removed from any lists
1521   */
1522  typedef void (mid_callback_t)(struct mid_q_entry *mid);
1523  
1524  /*
1525   * This is the protopyte for mid handle function. This is called once the mid
1526   * has been recognized after decryption of the message.
1527   */
1528  typedef int (mid_handle_t)(struct TCP_Server_Info *server,
1529  			    struct mid_q_entry *mid);
1530  
1531  /* one of these for every pending CIFS request to the server */
1532  struct mid_q_entry {
1533  	struct list_head qhead;	/* mids waiting on reply from this server */
1534  	struct kref refcount;
1535  	struct TCP_Server_Info *server;	/* server corresponding to this mid */
1536  	__u64 mid;		/* multiplex id */
1537  	__u16 credits;		/* number of credits consumed by this mid */
1538  	__u16 credits_received;	/* number of credits from the response */
1539  	__u32 pid;		/* process id */
1540  	__u32 sequence_number;  /* for CIFS signing */
1541  	unsigned long when_alloc;  /* when mid was created */
1542  #ifdef CONFIG_CIFS_STATS2
1543  	unsigned long when_sent; /* time when smb send finished */
1544  	unsigned long when_received; /* when demux complete (taken off wire) */
1545  #endif
1546  	mid_receive_t *receive; /* call receive callback */
1547  	mid_callback_t *callback; /* call completion callback */
1548  	mid_handle_t *handle; /* call handle mid callback */
1549  	void *callback_data;	  /* general purpose pointer for callback */
1550  	struct task_struct *creator;
1551  	void *resp_buf;		/* pointer to received SMB header */
1552  	unsigned int resp_buf_size;
1553  	int mid_state;	/* wish this were enum but can not pass to wait_event */
1554  	unsigned int mid_flags;
1555  	__le16 command;		/* smb command code */
1556  	unsigned int optype;	/* operation type */
1557  	bool large_buf:1;	/* if valid response, is pointer to large buf */
1558  	bool multiRsp:1;	/* multiple trans2 responses for one request  */
1559  	bool multiEnd:1;	/* both received */
1560  	bool decrypted:1;	/* decrypted entry */
1561  };
1562  
1563  struct close_cancelled_open {
1564  	struct cifs_fid         fid;
1565  	struct cifs_tcon        *tcon;
1566  	struct work_struct      work;
1567  };
1568  
1569  /*	Make code in transport.c a little cleaner by moving
1570  	update of optional stats into function below */
1571  #ifdef CONFIG_CIFS_STATS2
1572  
cifs_in_send_inc(struct TCP_Server_Info * server)1573  static inline void cifs_in_send_inc(struct TCP_Server_Info *server)
1574  {
1575  	atomic_inc(&server->in_send);
1576  }
1577  
cifs_in_send_dec(struct TCP_Server_Info * server)1578  static inline void cifs_in_send_dec(struct TCP_Server_Info *server)
1579  {
1580  	atomic_dec(&server->in_send);
1581  }
1582  
cifs_num_waiters_inc(struct TCP_Server_Info * server)1583  static inline void cifs_num_waiters_inc(struct TCP_Server_Info *server)
1584  {
1585  	atomic_inc(&server->num_waiters);
1586  }
1587  
cifs_num_waiters_dec(struct TCP_Server_Info * server)1588  static inline void cifs_num_waiters_dec(struct TCP_Server_Info *server)
1589  {
1590  	atomic_dec(&server->num_waiters);
1591  }
1592  
cifs_save_when_sent(struct mid_q_entry * mid)1593  static inline void cifs_save_when_sent(struct mid_q_entry *mid)
1594  {
1595  	mid->when_sent = jiffies;
1596  }
1597  #else
cifs_in_send_inc(struct TCP_Server_Info * server)1598  static inline void cifs_in_send_inc(struct TCP_Server_Info *server)
1599  {
1600  }
cifs_in_send_dec(struct TCP_Server_Info * server)1601  static inline void cifs_in_send_dec(struct TCP_Server_Info *server)
1602  {
1603  }
1604  
cifs_num_waiters_inc(struct TCP_Server_Info * server)1605  static inline void cifs_num_waiters_inc(struct TCP_Server_Info *server)
1606  {
1607  }
1608  
cifs_num_waiters_dec(struct TCP_Server_Info * server)1609  static inline void cifs_num_waiters_dec(struct TCP_Server_Info *server)
1610  {
1611  }
1612  
cifs_save_when_sent(struct mid_q_entry * mid)1613  static inline void cifs_save_when_sent(struct mid_q_entry *mid)
1614  {
1615  }
1616  #endif
1617  
1618  /* for pending dnotify requests */
1619  struct dir_notify_req {
1620  	struct list_head lhead;
1621  	__le16 Pid;
1622  	__le16 PidHigh;
1623  	__u16 Mid;
1624  	__u16 Tid;
1625  	__u16 Uid;
1626  	__u16 netfid;
1627  	__u32 filter; /* CompletionFilter (for multishot) */
1628  	int multishot;
1629  	struct file *pfile;
1630  };
1631  
1632  struct dfs_info3_param {
1633  	int flags; /* DFSREF_REFERRAL_SERVER, DFSREF_STORAGE_SERVER*/
1634  	int path_consumed;
1635  	int server_type;
1636  	int ref_flag;
1637  	char *path_name;
1638  	char *node_name;
1639  	int ttl;
1640  };
1641  
1642  /*
1643   * common struct for holding inode info when searching for or updating an
1644   * inode with new info
1645   */
1646  
1647  #define CIFS_FATTR_DFS_REFERRAL		0x1
1648  #define CIFS_FATTR_DELETE_PENDING	0x2
1649  #define CIFS_FATTR_NEED_REVAL		0x4
1650  #define CIFS_FATTR_INO_COLLISION	0x8
1651  #define CIFS_FATTR_UNKNOWN_NLINK	0x10
1652  #define CIFS_FATTR_FAKE_ROOT_INO	0x20
1653  
1654  struct cifs_fattr {
1655  	u32		cf_flags;
1656  	u32		cf_cifsattrs;
1657  	u64		cf_uniqueid;
1658  	u64		cf_eof;
1659  	u64		cf_bytes;
1660  	u64		cf_createtime;
1661  	kuid_t		cf_uid;
1662  	kgid_t		cf_gid;
1663  	umode_t		cf_mode;
1664  	dev_t		cf_rdev;
1665  	unsigned int	cf_nlink;
1666  	unsigned int	cf_dtype;
1667  	struct timespec64 cf_atime;
1668  	struct timespec64 cf_mtime;
1669  	struct timespec64 cf_ctime;
1670  };
1671  
free_dfs_info_param(struct dfs_info3_param * param)1672  static inline void free_dfs_info_param(struct dfs_info3_param *param)
1673  {
1674  	if (param) {
1675  		kfree(param->path_name);
1676  		kfree(param->node_name);
1677  	}
1678  }
1679  
free_dfs_info_array(struct dfs_info3_param * param,int number_of_items)1680  static inline void free_dfs_info_array(struct dfs_info3_param *param,
1681  				       int number_of_items)
1682  {
1683  	int i;
1684  	if ((number_of_items == 0) || (param == NULL))
1685  		return;
1686  	for (i = 0; i < number_of_items; i++) {
1687  		kfree(param[i].path_name);
1688  		kfree(param[i].node_name);
1689  	}
1690  	kfree(param);
1691  }
1692  
is_interrupt_error(int error)1693  static inline bool is_interrupt_error(int error)
1694  {
1695  	switch (error) {
1696  	case -EINTR:
1697  	case -ERESTARTSYS:
1698  	case -ERESTARTNOHAND:
1699  	case -ERESTARTNOINTR:
1700  		return true;
1701  	}
1702  	return false;
1703  }
1704  
is_retryable_error(int error)1705  static inline bool is_retryable_error(int error)
1706  {
1707  	if (is_interrupt_error(error) || error == -EAGAIN)
1708  		return true;
1709  	return false;
1710  }
1711  
1712  
1713  /* cifs_get_writable_file() flags */
1714  #define FIND_WR_ANY         0
1715  #define FIND_WR_FSUID_ONLY  1
1716  #define FIND_WR_WITH_DELETE 2
1717  
1718  #define   MID_FREE 0
1719  #define   MID_REQUEST_ALLOCATED 1
1720  #define   MID_REQUEST_SUBMITTED 2
1721  #define   MID_RESPONSE_RECEIVED 4
1722  #define   MID_RETRY_NEEDED      8 /* session closed while this request out */
1723  #define   MID_RESPONSE_MALFORMED 0x10
1724  #define   MID_SHUTDOWN		 0x20
1725  
1726  /* Flags */
1727  #define   MID_WAIT_CANCELLED	 1 /* Cancelled while waiting for response */
1728  #define   MID_DELETED            2 /* Mid has been dequeued/deleted */
1729  
1730  /* Types of response buffer returned from SendReceive2 */
1731  #define   CIFS_NO_BUFFER        0    /* Response buffer not returned */
1732  #define   CIFS_SMALL_BUFFER     1
1733  #define   CIFS_LARGE_BUFFER     2
1734  #define   CIFS_IOVEC            4    /* array of response buffers */
1735  
1736  /* Type of Request to SendReceive2 */
1737  #define   CIFS_BLOCKING_OP      1    /* operation can block */
1738  #define   CIFS_NON_BLOCKING     2    /* do not block waiting for credits */
1739  #define   CIFS_TIMEOUT_MASK 0x003    /* only one of above set in req */
1740  #define   CIFS_LOG_ERROR    0x010    /* log NT STATUS if non-zero */
1741  #define   CIFS_LARGE_BUF_OP 0x020    /* large request buffer */
1742  #define   CIFS_NO_RSP_BUF   0x040    /* no response buffer required */
1743  
1744  /* Type of request operation */
1745  #define   CIFS_ECHO_OP      0x080    /* echo request */
1746  #define   CIFS_OBREAK_OP   0x0100    /* oplock break request */
1747  #define   CIFS_NEG_OP      0x0200    /* negotiate request */
1748  #define   CIFS_OP_MASK     0x0380    /* mask request type */
1749  
1750  #define   CIFS_HAS_CREDITS 0x0400    /* already has credits */
1751  #define   CIFS_TRANSFORM_REQ 0x0800    /* transform request before sending */
1752  #define   CIFS_NO_SRV_RSP    0x1000    /* there is no server response */
1753  
1754  /* Security Flags: indicate type of session setup needed */
1755  #define   CIFSSEC_MAY_SIGN	0x00001
1756  #define   CIFSSEC_MAY_NTLM	0x00002
1757  #define   CIFSSEC_MAY_NTLMV2	0x00004
1758  #define   CIFSSEC_MAY_KRB5	0x00008
1759  #ifdef CONFIG_CIFS_WEAK_PW_HASH
1760  #define   CIFSSEC_MAY_LANMAN	0x00010
1761  #define   CIFSSEC_MAY_PLNTXT	0x00020
1762  #else
1763  #define   CIFSSEC_MAY_LANMAN    0
1764  #define   CIFSSEC_MAY_PLNTXT    0
1765  #endif /* weak passwords */
1766  #define   CIFSSEC_MAY_SEAL	0x00040 /* not supported yet */
1767  #define   CIFSSEC_MAY_NTLMSSP	0x00080 /* raw ntlmssp with ntlmv2 */
1768  
1769  #define   CIFSSEC_MUST_SIGN	0x01001
1770  /* note that only one of the following can be set so the
1771  result of setting MUST flags more than once will be to
1772  require use of the stronger protocol */
1773  #define   CIFSSEC_MUST_NTLM	0x02002
1774  #define   CIFSSEC_MUST_NTLMV2	0x04004
1775  #define   CIFSSEC_MUST_KRB5	0x08008
1776  #ifdef CONFIG_CIFS_WEAK_PW_HASH
1777  #define   CIFSSEC_MUST_LANMAN	0x10010
1778  #define   CIFSSEC_MUST_PLNTXT	0x20020
1779  #ifdef CONFIG_CIFS_UPCALL
1780  #define   CIFSSEC_MASK          0xBF0BF /* allows weak security but also krb5 */
1781  #else
1782  #define   CIFSSEC_MASK          0xB70B7 /* current flags supported if weak */
1783  #endif /* UPCALL */
1784  #else /* do not allow weak pw hash */
1785  #define   CIFSSEC_MUST_LANMAN	0
1786  #define   CIFSSEC_MUST_PLNTXT	0
1787  #ifdef CONFIG_CIFS_UPCALL
1788  #define   CIFSSEC_MASK          0x8F08F /* flags supported if no weak allowed */
1789  #else
1790  #define	  CIFSSEC_MASK          0x87087 /* flags supported if no weak allowed */
1791  #endif /* UPCALL */
1792  #endif /* WEAK_PW_HASH */
1793  #define   CIFSSEC_MUST_SEAL	0x40040 /* not supported yet */
1794  #define   CIFSSEC_MUST_NTLMSSP	0x80080 /* raw ntlmssp with ntlmv2 */
1795  
1796  #define   CIFSSEC_DEF (CIFSSEC_MAY_SIGN | CIFSSEC_MAY_NTLMV2 | CIFSSEC_MAY_NTLMSSP)
1797  #define   CIFSSEC_MAX (CIFSSEC_MUST_SIGN | CIFSSEC_MUST_NTLMV2)
1798  #define   CIFSSEC_AUTH_MASK (CIFSSEC_MAY_NTLM | CIFSSEC_MAY_NTLMV2 | CIFSSEC_MAY_LANMAN | CIFSSEC_MAY_PLNTXT | CIFSSEC_MAY_KRB5 | CIFSSEC_MAY_NTLMSSP)
1799  /*
1800   *****************************************************************
1801   * All constants go here
1802   *****************************************************************
1803   */
1804  
1805  #define UID_HASH (16)
1806  
1807  /*
1808   * Note that ONE module should define _DECLARE_GLOBALS_HERE to cause the
1809   * following to be declared.
1810   */
1811  
1812  /****************************************************************************
1813   *  Locking notes.  All updates to global variables and lists should be
1814   *                  protected by spinlocks or semaphores.
1815   *
1816   *  Spinlocks
1817   *  ---------
1818   *  GlobalMid_Lock protects:
1819   *	list operations on pending_mid_q and oplockQ
1820   *      updates to XID counters, multiplex id  and SMB sequence numbers
1821   *      list operations on global DnotifyReqList
1822   *      updates to ses->status
1823   *  tcp_ses_lock protects:
1824   *	list operations on tcp and SMB session lists
1825   *  tcon->open_file_lock protects the list of open files hanging off the tcon
1826   *  inode->open_file_lock protects the openFileList hanging off the inode
1827   *  cfile->file_info_lock protects counters and fields in cifs file struct
1828   *  f_owner.lock protects certain per file struct operations
1829   *  mapping->page_lock protects certain per page operations
1830   *
1831   *  Note that the cifs_tcon.open_file_lock should be taken before
1832   *  not after the cifsInodeInfo.open_file_lock
1833   *
1834   *  Semaphores
1835   *  ----------
1836   *  sesSem     operations on smb session
1837   *  tconSem    operations on tree connection
1838   *  fh_sem      file handle reconnection operations
1839   *
1840   ****************************************************************************/
1841  
1842  #ifdef DECLARE_GLOBALS_HERE
1843  #define GLOBAL_EXTERN
1844  #else
1845  #define GLOBAL_EXTERN extern
1846  #endif
1847  
1848  /*
1849   * the list of TCP_Server_Info structures, ie each of the sockets
1850   * connecting our client to a distinct server (ip address), is
1851   * chained together by cifs_tcp_ses_list. The list of all our SMB
1852   * sessions (and from that the tree connections) can be found
1853   * by iterating over cifs_tcp_ses_list
1854   */
1855  GLOBAL_EXTERN struct list_head		cifs_tcp_ses_list;
1856  
1857  /*
1858   * This lock protects the cifs_tcp_ses_list, the list of smb sessions per
1859   * tcp session, and the list of tcon's per smb session. It also protects
1860   * the reference counters for the server, smb session, and tcon. Finally,
1861   * changes to the tcon->tidStatus should be done while holding this lock.
1862   * generally the locks should be taken in order tcp_ses_lock before
1863   * tcon->open_file_lock and that before file->file_info_lock since the
1864   * structure order is cifs_socket-->cifs_ses-->cifs_tcon-->cifs_file
1865   */
1866  GLOBAL_EXTERN spinlock_t		cifs_tcp_ses_lock;
1867  
1868  #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
1869  /* Outstanding dir notify requests */
1870  GLOBAL_EXTERN struct list_head GlobalDnotifyReqList;
1871  /* DirNotify response queue */
1872  GLOBAL_EXTERN struct list_head GlobalDnotifyRsp_Q;
1873  #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
1874  
1875  /*
1876   * Global transaction id (XID) information
1877   */
1878  GLOBAL_EXTERN unsigned int GlobalCurrentXid;	/* protected by GlobalMid_Sem */
1879  GLOBAL_EXTERN unsigned int GlobalTotalActiveXid; /* prot by GlobalMid_Sem */
1880  GLOBAL_EXTERN unsigned int GlobalMaxActiveXid;	/* prot by GlobalMid_Sem */
1881  GLOBAL_EXTERN spinlock_t GlobalMid_Lock;  /* protects above & list operations */
1882  					  /* on midQ entries */
1883  /*
1884   *  Global counters, updated atomically
1885   */
1886  GLOBAL_EXTERN atomic_t sesInfoAllocCount;
1887  GLOBAL_EXTERN atomic_t tconInfoAllocCount;
1888  GLOBAL_EXTERN atomic_t tcpSesAllocCount;
1889  GLOBAL_EXTERN atomic_t tcpSesReconnectCount;
1890  GLOBAL_EXTERN atomic_t tconInfoReconnectCount;
1891  
1892  /* Various Debug counters */
1893  GLOBAL_EXTERN atomic_t bufAllocCount;    /* current number allocated  */
1894  #ifdef CONFIG_CIFS_STATS2
1895  GLOBAL_EXTERN atomic_t totBufAllocCount; /* total allocated over all time */
1896  GLOBAL_EXTERN atomic_t totSmBufAllocCount;
1897  extern unsigned int slow_rsp_threshold; /* number of secs before logging */
1898  #endif
1899  GLOBAL_EXTERN atomic_t smBufAllocCount;
1900  GLOBAL_EXTERN atomic_t midCount;
1901  
1902  /* Misc globals */
1903  extern bool enable_oplocks; /* enable or disable oplocks */
1904  extern bool lookupCacheEnabled;
1905  extern unsigned int global_secflags;	/* if on, session setup sent
1906  				with more secure ntlmssp2 challenge/resp */
1907  extern unsigned int sign_CIFS_PDUs;  /* enable smb packet signing */
1908  extern bool linuxExtEnabled;/*enable Linux/Unix CIFS extensions*/
1909  extern unsigned int CIFSMaxBufSize;  /* max size not including hdr */
1910  extern unsigned int cifs_min_rcv;    /* min size of big ntwrk buf pool */
1911  extern unsigned int cifs_min_small;  /* min size of small buf pool */
1912  extern unsigned int cifs_max_pending; /* MAX requests at once to server*/
1913  extern bool disable_legacy_dialects;  /* forbid vers=1.0 and vers=2.0 mounts */
1914  
1915  GLOBAL_EXTERN struct rb_root uidtree;
1916  GLOBAL_EXTERN struct rb_root gidtree;
1917  GLOBAL_EXTERN spinlock_t siduidlock;
1918  GLOBAL_EXTERN spinlock_t sidgidlock;
1919  GLOBAL_EXTERN struct rb_root siduidtree;
1920  GLOBAL_EXTERN struct rb_root sidgidtree;
1921  GLOBAL_EXTERN spinlock_t uidsidlock;
1922  GLOBAL_EXTERN spinlock_t gidsidlock;
1923  
1924  void cifs_oplock_break(struct work_struct *work);
1925  void cifs_queue_oplock_break(struct cifsFileInfo *cfile);
1926  
1927  extern const struct slow_work_ops cifs_oplock_break_ops;
1928  extern struct workqueue_struct *cifsiod_wq;
1929  extern struct workqueue_struct *decrypt_wq;
1930  extern struct workqueue_struct *fileinfo_put_wq;
1931  extern struct workqueue_struct *cifsoplockd_wq;
1932  extern __u32 cifs_lock_secret;
1933  
1934  extern mempool_t *cifs_mid_poolp;
1935  
1936  /* Operations for different SMB versions */
1937  #define SMB1_VERSION_STRING	"1.0"
1938  #define SMB20_VERSION_STRING    "2.0"
1939  #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1940  extern struct smb_version_operations smb1_operations;
1941  extern struct smb_version_values smb1_values;
1942  extern struct smb_version_operations smb20_operations;
1943  extern struct smb_version_values smb20_values;
1944  #endif /* CIFS_ALLOW_INSECURE_LEGACY */
1945  #define SMB21_VERSION_STRING	"2.1"
1946  extern struct smb_version_operations smb21_operations;
1947  extern struct smb_version_values smb21_values;
1948  #define SMBDEFAULT_VERSION_STRING "default"
1949  extern struct smb_version_values smbdefault_values;
1950  #define SMB3ANY_VERSION_STRING "3"
1951  extern struct smb_version_values smb3any_values;
1952  #define SMB30_VERSION_STRING	"3.0"
1953  extern struct smb_version_operations smb30_operations;
1954  extern struct smb_version_values smb30_values;
1955  #define SMB302_VERSION_STRING	"3.02"
1956  #define ALT_SMB302_VERSION_STRING "3.0.2"
1957  /*extern struct smb_version_operations smb302_operations;*/ /* not needed yet */
1958  extern struct smb_version_values smb302_values;
1959  #define SMB311_VERSION_STRING	"3.1.1"
1960  #define ALT_SMB311_VERSION_STRING "3.11"
1961  extern struct smb_version_operations smb311_operations;
1962  extern struct smb_version_values smb311_values;
1963  
cifs_get_num_sgs(const struct smb_rqst * rqst,int num_rqst,const u8 * sig)1964  static inline unsigned int cifs_get_num_sgs(const struct smb_rqst *rqst,
1965  					    int num_rqst,
1966  					    const u8 *sig)
1967  {
1968  	unsigned int len, skip;
1969  	unsigned int nents = 0;
1970  	unsigned long addr;
1971  	int i, j;
1972  
1973  	/* Assumes the first rqst has a transform header as the first iov.
1974  	 * I.e.
1975  	 * rqst[0].rq_iov[0]  is transform header
1976  	 * rqst[0].rq_iov[1+] data to be encrypted/decrypted
1977  	 * rqst[1+].rq_iov[0+] data to be encrypted/decrypted
1978  	 */
1979  	for (i = 0; i < num_rqst; i++) {
1980  		/*
1981  		 * The first rqst has a transform header where the
1982  		 * first 20 bytes are not part of the encrypted blob.
1983  		 */
1984  		for (j = 0; j < rqst[i].rq_nvec; j++) {
1985  			struct kvec *iov = &rqst[i].rq_iov[j];
1986  
1987  			skip = (i == 0) && (j == 0) ? 20 : 0;
1988  			addr = (unsigned long)iov->iov_base + skip;
1989  			if (unlikely(is_vmalloc_addr((void *)addr))) {
1990  				len = iov->iov_len - skip;
1991  				nents += DIV_ROUND_UP(offset_in_page(addr) + len,
1992  						      PAGE_SIZE);
1993  			} else {
1994  				nents++;
1995  			}
1996  		}
1997  		nents += rqst[i].rq_npages;
1998  	}
1999  	nents += DIV_ROUND_UP(offset_in_page(sig) + SMB2_SIGNATURE_SIZE, PAGE_SIZE);
2000  	return nents;
2001  }
2002  
2003  /* We can not use the normal sg_set_buf() as we will sometimes pass a
2004   * stack object as buf.
2005   */
cifs_sg_set_buf(struct scatterlist * sg,const void * buf,unsigned int buflen)2006  static inline struct scatterlist *cifs_sg_set_buf(struct scatterlist *sg,
2007  						  const void *buf,
2008  						  unsigned int buflen)
2009  {
2010  	unsigned long addr = (unsigned long)buf;
2011  	unsigned int off = offset_in_page(addr);
2012  
2013  	addr &= PAGE_MASK;
2014  	if (unlikely(is_vmalloc_addr((void *)addr))) {
2015  		do {
2016  			unsigned int len = min_t(unsigned int, buflen, PAGE_SIZE - off);
2017  
2018  			sg_set_page(sg++, vmalloc_to_page((void *)addr), len, off);
2019  
2020  			off = 0;
2021  			addr += PAGE_SIZE;
2022  			buflen -= len;
2023  		} while (buflen);
2024  	} else {
2025  		sg_set_page(sg++, virt_to_page(addr), buflen, off);
2026  	}
2027  	return sg;
2028  }
2029  
2030  #endif	/* _CIFS_GLOB_H */
2031