cifsglob.h 66.8 KB
Newer Older
1
/* SPDX-License-Identifier: LGPL-2.1 */
L
Linus Torvalds 已提交
2 3
/*
 *
S
Steve French 已提交
4
 *   Copyright (C) International Business Machines  Corp., 2002,2008
L
Linus Torvalds 已提交
5
 *   Author(s): Steve French (sfrench@us.ibm.com)
J
[CIFS]  
Jeremy Allison 已提交
6
 *              Jeremy Allison (jra@samba.org)
L
Linus Torvalds 已提交
7 8
 *
 */
9 10 11
#ifndef _CIFS_GLOB_H
#define _CIFS_GLOB_H

L
Linus Torvalds 已提交
12 13
#include <linux/in.h>
#include <linux/in6.h>
14
#include <linux/inet.h>
15
#include <linux/slab.h>
16
#include <linux/mempool.h>
17
#include <linux/workqueue.h>
18
#include <linux/utsname.h>
L
Linus Torvalds 已提交
19
#include "cifs_fs_sb.h"
20
#include "cifsacl.h"
21 22
#include <crypto/internal/hash.h>
#include <linux/scatterlist.h>
23
#include <uapi/linux/cifs/cifs_mount.h>
24
#include "../smbfs_common/smb2pdu.h"
25
#include "smb2pdu.h"
26

27 28
#define CIFS_MAGIC_NUMBER 0xFF534D42      /* the first four bytes of SMB PDUs */

29
#define SMB_PATH_MAX 260
30 31 32
#define CIFS_PORT 445
#define RFC1001_PORT 139

L
Linus Torvalds 已提交
33 34 35 36 37 38 39
/*
 * The sizes of various internal tables and strings
 */
#define MAX_UID_INFO 16
#define MAX_SES_INFO 2
#define MAX_TCON_INFO 4

40
#define MAX_TREE_SIZE (2 + CIFS_NI_MAXHOST + 1 + CIFS_MAX_SHARE_LEN + 1)
L
Linus Torvalds 已提交
41 42 43

#define CIFS_MIN_RCV_POOL 4

44
#define MAX_REOPEN_ATT	5 /* these many maximum attempts to reopen a file */
45 46 47 48 49 50 51 52 53 54
/*
 * default attribute cache timeout (jiffies)
 */
#define CIFS_DEF_ACTIMEO (1 * HZ)

/*
 * max attribute cache timeout (jiffies) - 2^30
 */
#define CIFS_MAX_ACTIMEO (1 << 30)

55 56 57 58 59 60
/*
 * Max persistent and resilient handle timeout (milliseconds).
 * Windows durable max was 960000 (16 minutes)
 */
#define SMB3_MAX_HANDLE_TIMEOUT 960000

L
Linus Torvalds 已提交
61 62
/*
 * MAX_REQ is the maximum number of requests that WE will send
63
 * on one socket concurrently.
L
Linus Torvalds 已提交
64
 */
65
#define CIFS_MAX_REQ 32767
L
Linus Torvalds 已提交
66

67 68 69
#define RFC1001_NAME_LEN 15
#define RFC1001_NAME_LEN_WITH_NULL (RFC1001_NAME_LEN + 1)

70 71
/* maximum length of ip addr as a string (including ipv6 and sctp) */
#define SERVER_NAME_LENGTH 80
L
Linus Torvalds 已提交
72 73
#define SERVER_NAME_LEN_WITH_NULL     (SERVER_NAME_LENGTH + 1)

74 75 76 77
/* echo interval in seconds */
#define SMB_ECHO_INTERVAL_MIN 1
#define SMB_ECHO_INTERVAL_MAX 600
#define SMB_ECHO_INTERVAL_DEFAULT 60
78

79 80
/* dns resolution intervals in seconds */
#define SMB_DNS_RESOLVE_INTERVAL_MIN     120
81 82
#define SMB_DNS_RESOLVE_INTERVAL_DEFAULT 600

83 84 85
/* maximum number of PDUs in one compound */
#define MAX_COMPOUND 5

86 87 88 89 90 91 92 93 94 95 96 97
/*
 * Default number of credits to keep available for SMB3.
 * This value is chosen somewhat arbitrarily. The Windows client
 * defaults to 128 credits, the Windows server allows clients up to
 * 512 credits (or 8K for later versions), and the NetApp server
 * does not limit clients at all.  Choose a high enough default value
 * such that the client shouldn't limit performance, but allow mount
 * to override (until you approach 64K, where we limit credits to 65000
 * to reduce possibility of seeing more server credit overflow bugs.
 */
#define SMB2_MAX_CREDITS_AVAILABLE 32000

L
Linus Torvalds 已提交
98 99 100 101 102 103
#include "cifspdu.h"

#ifndef XATTR_DOS_ATTRIB
#define XATTR_DOS_ATTRIB "user.DOSATTRIB"
#endif

104 105
#define CIFS_MAX_WORKSTATION_LEN  (__NEW_UTS_LEN + 1)  /* reasonable max for client */

L
Linus Torvalds 已提交
106 107 108 109
/*
 * CIFS vfs client Status information (based on what we know.)
 */

110
/* associated with each tcp and smb session */
L
Linus Torvalds 已提交
111 112 113 114
enum statusEnum {
	CifsNew = 0,
	CifsGood,
	CifsExiting,
115 116
	CifsNeedReconnect,
	CifsNeedNegotiate
L
Linus Torvalds 已提交
117 118 119
};

enum securityEnum {
120
	Unspecified = 0,	/* not specified */
L
Linus Torvalds 已提交
121
	NTLMv2,			/* Legacy NTLM auth with NTLMv2 hash */
122
	RawNTLMSSP,		/* NTLMSSP without SPNEGO, NTLMv2 hash */
123
	Kerberos,		/* Kerberos via SPNEGO */
L
Linus Torvalds 已提交
124 125
};

126
struct session_key {
127
	unsigned int len;
128
	char *response;
129 130
};

131 132 133 134 135 136
/* crypto security descriptor definition */
struct sdesc {
	struct shash_desc shash;
	char ctx[];
};

137
/* crypto hashing related structure/fields, not specific to a sec mech */
138 139 140
struct cifs_secmech {
	struct crypto_shash *hmacmd5; /* hmac-md5 hash function */
	struct crypto_shash *md5; /* md5 hash function */
141
	struct crypto_shash *hmacsha256; /* hmac-sha256 hash function */
142
	struct crypto_shash *cmacaes; /* block-cipher based MAC function */
143
	struct crypto_shash *sha512; /* sha512 hash function */
144 145
	struct sdesc *sdeschmacmd5;  /* ctxt to generate ntlmv2 hash, CR1 */
	struct sdesc *sdescmd5; /* ctxt to generate cifs/smb signature */
146
	struct sdesc *sdeschmacsha256;  /* ctxt to generate smb2 signature */
147
	struct sdesc *sdesccmacaes;  /* ctxt to generate smb3 signature */
148
	struct sdesc *sdescsha512; /* ctxt to generate smb3.11 signing key */
149 150
	struct crypto_aead *ccmaesencrypt; /* smb3 encryption aead */
	struct crypto_aead *ccmaesdecrypt; /* smb3 decryption aead */
151 152
};

153
/* per smb session structure/fields */
154
struct ntlmssp_auth {
155
	bool sesskey_per_smbsess; /* whether session key is per smb session */
156 157 158
	__u32 client_flags; /* sent by client in type 1 ntlmsssp exchange */
	__u32 server_flags; /* sent by server in type 2 ntlmssp exchange */
	unsigned char ciphertext[CIFS_CPHTXT_SIZE]; /* sent to server */
159
	char cryptkey[CIFS_CRYPTO_KEY_SIZE]; /* used by ntlmssp */
160 161
};

162 163 164 165 166 167 168 169 170 171 172
struct cifs_cred {
	int uid;
	int gid;
	int mode;
	int cecount;
	struct cifs_sid osid;
	struct cifs_sid gsid;
	struct cifs_ntace *ntaces;
	struct cifs_ace *aces;
};

L
Linus Torvalds 已提交
173 174 175 176 177 178 179
/*
 *****************************************************************
 * Except the CIFS PDUs themselves all the
 * globally interesting structs should go here
 *****************************************************************
 */

180 181 182 183 184 185 186 187 188
/*
 * A smb_rqst represents a complete request to be issued to a server. It's
 * formed by a kvec array, followed by an array of pages. Page data is assumed
 * to start at the beginning of the first page.
 */
struct smb_rqst {
	struct kvec	*rq_iov;	/* array of kvecs */
	unsigned int	rq_nvec;	/* number of kvecs in array */
	struct page	**rq_pages;	/* pointer to array of page ptrs */
189
	unsigned int	rq_offset;	/* the offset to the 1st page */
190 191 192 193 194
	unsigned int	rq_npages;	/* number pages in array */
	unsigned int	rq_pagesz;	/* page size to use */
	unsigned int	rq_tailsz;	/* length of last page */
};

195 196
struct mid_q_entry;
struct TCP_Server_Info;
197
struct cifsFileInfo;
198
struct cifs_ses;
199
struct cifs_tcon;
200
struct dfs_info3_param;
201
struct cifs_fattr;
202
struct smb3_fs_context;
203
struct cifs_fid;
204
struct cifs_readdata;
205
struct cifs_writedata;
206
struct cifs_io_parms;
207
struct cifs_search_info;
208
struct cifsInodeInfo;
209
struct cifs_open_parms;
210
struct cifs_credits;
211

212
struct smb_version_operations {
213
	int (*send_cancel)(struct TCP_Server_Info *, struct smb_rqst *,
214
			   struct mid_q_entry *);
215
	bool (*compare_fids)(struct cifsFileInfo *, struct cifsFileInfo *);
216
	/* setup request: allocate mid, sign message */
217
	struct mid_q_entry *(*setup_request)(struct cifs_ses *,
A
Aurelien Aptel 已提交
218 219
					     struct TCP_Server_Info *,
					     struct smb_rqst *);
220
	/* setup async request: allocate mid, sign message */
221 222
	struct mid_q_entry *(*setup_async_request)(struct TCP_Server_Info *,
						struct smb_rqst *);
223 224 225
	/* check response: verify signature, map error */
	int (*check_receive)(struct mid_q_entry *, struct TCP_Server_Info *,
			     bool);
226 227 228
	void (*add_credits)(struct TCP_Server_Info *server,
			    const struct cifs_credits *credits,
			    const int optype);
229
	void (*set_credits)(struct TCP_Server_Info *, const int);
230 231
	int * (*get_credits_field)(struct TCP_Server_Info *, const int);
	unsigned int (*get_credits)(struct mid_q_entry *);
232
	__u64 (*get_next_mid)(struct TCP_Server_Info *);
233 234
	void (*revert_current_mid)(struct TCP_Server_Info *server,
				   const unsigned int val);
235 236
	/* data offset from read response message */
	unsigned int (*read_data_offset)(char *);
237 238 239 240 241 242 243 244
	/*
	 * Data length from read response message
	 * When in_remaining is true, the returned data length is in
	 * message field DataRemaining for out-of-band data read (e.g through
	 * Memory Registration RDMA write in SMBD).
	 * Otherwise, the returned data length is in message field DataLength.
	 */
	unsigned int (*read_data_length)(char *, bool in_remaining);
245 246
	/* map smb to linux error */
	int (*map_error)(char *, bool);
247 248
	/* find mid corresponding to the response message */
	struct mid_q_entry * (*find_mid)(struct TCP_Server_Info *, char *);
249
	void (*dump_detail)(void *buf, struct TCP_Server_Info *ptcp_info);
250 251
	void (*clear_stats)(struct cifs_tcon *);
	void (*print_stats)(struct seq_file *m, struct cifs_tcon *);
252
	void (*dump_share_caps)(struct seq_file *, struct cifs_tcon *);
253
	/* verify the message */
254
	int (*check_message)(char *, unsigned int, struct TCP_Server_Info *);
255
	bool (*is_oplock_break)(char *, struct TCP_Server_Info *);
256
	int (*handle_cancelled_mid)(struct mid_q_entry *, struct TCP_Server_Info *);
257 258 259
	void (*downgrade_oplock)(struct TCP_Server_Info *server,
				 struct cifsInodeInfo *cinode, __u32 oplock,
				 unsigned int epoch, bool *purge_cache);
260 261 262
	/* process transaction2 response */
	bool (*check_trans2)(struct mid_q_entry *, struct TCP_Server_Info *,
			     char *, int);
263 264 265 266
	/* check if we need to negotiate */
	bool (*need_neg)(struct TCP_Server_Info *);
	/* negotiate to the server */
	int (*negotiate)(const unsigned int, struct cifs_ses *);
267
	/* set negotiated write size */
268
	unsigned int (*negotiate_wsize)(struct cifs_tcon *tcon, struct smb3_fs_context *ctx);
269
	/* set negotiated read size */
270
	unsigned int (*negotiate_rsize)(struct cifs_tcon *tcon, struct smb3_fs_context *ctx);
271 272 273 274 275
	/* setup smb sessionn */
	int (*sess_setup)(const unsigned int, struct cifs_ses *,
			  const struct nls_table *);
	/* close smb session */
	int (*logoff)(const unsigned int, struct cifs_ses *);
276 277 278 279 280
	/* connect to a server share */
	int (*tree_connect)(const unsigned int, struct cifs_ses *, const char *,
			    struct cifs_tcon *, const struct nls_table *);
	/* close tree connecion */
	int (*tree_disconnect)(const unsigned int, struct cifs_tcon *);
281 282 283 284
	/* get DFS referrals */
	int (*get_dfs_refer)(const unsigned int, struct cifs_ses *,
			     const char *, struct dfs_info3_param **,
			     unsigned int *, const struct nls_table *, int);
285
	/* informational QFS call */
286 287
	void (*qfs_tcon)(const unsigned int, struct cifs_tcon *,
			 struct cifs_sb_info *);
288 289 290
	/* check if a path is accessible or not */
	int (*is_path_accessible)(const unsigned int, struct cifs_tcon *,
				  struct cifs_sb_info *, const char *);
291 292 293
	/* query path data from the server */
	int (*query_path_info)(const unsigned int, struct cifs_tcon *,
			       struct cifs_sb_info *, const char *,
294
			       FILE_ALL_INFO *, bool *, bool *);
295 296 297
	/* query file data from the server */
	int (*query_file_info)(const unsigned int, struct cifs_tcon *,
			       struct cifs_fid *, FILE_ALL_INFO *);
298 299 300 301
	/* query reparse tag from srv to determine which type of special file */
	int (*query_reparse_tag)(const unsigned int xid, struct cifs_tcon *tcon,
				struct cifs_sb_info *cifs_sb, const char *path,
				__u32 *reparse_tag);
302 303 304 305
	/* get server index number */
	int (*get_srv_inum)(const unsigned int, struct cifs_tcon *,
			    struct cifs_sb_info *, const char *,
			    u64 *uniqueid, FILE_ALL_INFO *);
306 307 308 309 310 311
	/* set size by path */
	int (*set_path_size)(const unsigned int, struct cifs_tcon *,
			     const char *, __u64, struct cifs_sb_info *, bool);
	/* set size by file handle */
	int (*set_file_size)(const unsigned int, struct cifs_tcon *,
			     struct cifsFileInfo *, __u64, bool);
312 313 314
	/* set attributes */
	int (*set_file_info)(struct inode *, const char *, FILE_BASIC_INFO *,
			     const unsigned int);
315 316
	int (*set_compression)(const unsigned int, struct cifs_tcon *,
			       struct cifsFileInfo *);
317 318 319 320
	/* check if we can send an echo or nor */
	bool (*can_echo)(struct TCP_Server_Info *);
	/* send echo request */
	int (*echo)(struct TCP_Server_Info *);
321
	/* create directory */
322 323 324 325
	int (*posix_mkdir)(const unsigned int xid, struct inode *inode,
			umode_t mode, struct cifs_tcon *tcon,
			const char *full_path,
			struct cifs_sb_info *cifs_sb);
326 327 328
	int (*mkdir)(const unsigned int xid, struct inode *inode, umode_t mode,
		     struct cifs_tcon *tcon, const char *name,
		     struct cifs_sb_info *sb);
329 330 331 332
	/* set info on created directory */
	void (*mkdir_setinfo)(struct inode *, const char *,
			      struct cifs_sb_info *, struct cifs_tcon *,
			      const unsigned int);
333 334 335
	/* remove directory */
	int (*rmdir)(const unsigned int, struct cifs_tcon *, const char *,
		     struct cifs_sb_info *);
336 337 338 339 340 341
	/* unlink file */
	int (*unlink)(const unsigned int, struct cifs_tcon *, const char *,
		      struct cifs_sb_info *);
	/* open, rename and delete file */
	int (*rename_pending_delete)(const char *, struct dentry *,
				     const unsigned int);
342 343 344
	/* send rename request */
	int (*rename)(const unsigned int, struct cifs_tcon *, const char *,
		      const char *, struct cifs_sb_info *);
345 346 347 348
	/* send create hardlink request */
	int (*create_hardlink)(const unsigned int, struct cifs_tcon *,
			       const char *, const char *,
			       struct cifs_sb_info *);
349 350
	/* query symlink target */
	int (*query_symlink)(const unsigned int, struct cifs_tcon *,
351 352
			     struct cifs_sb_info *, const char *,
			     char **, bool);
353
	/* open a file for non-posix mounts */
354 355
	int (*open)(const unsigned int, struct cifs_open_parms *,
		    __u32 *, FILE_ALL_INFO *);
356 357
	/* set fid protocol-specific info */
	void (*set_fid)(struct cifsFileInfo *, struct cifs_fid *, __u32);
358
	/* close a file */
359 360
	void (*close)(const unsigned int, struct cifs_tcon *,
		      struct cifs_fid *);
361 362 363
	/* close a file, returning file attributes and timestamps */
	void (*close_getattr)(const unsigned int xid, struct cifs_tcon *tcon,
		      struct cifsFileInfo *pfile_info);
364 365
	/* send a flush request to the server */
	int (*flush)(const unsigned int, struct cifs_tcon *, struct cifs_fid *);
366 367
	/* async read from the server */
	int (*async_readv)(struct cifs_readdata *);
368
	/* async write to the server */
369 370
	int (*async_writev)(struct cifs_writedata *,
			    void (*release)(struct kref *));
371
	/* sync read from the server */
372
	int (*sync_read)(const unsigned int, struct cifs_fid *,
373 374
			 struct cifs_io_parms *, unsigned int *, char **,
			 int *);
375
	/* sync write to the server */
376
	int (*sync_write)(const unsigned int, struct cifs_fid *,
377 378
			  struct cifs_io_parms *, unsigned int *, struct kvec *,
			  unsigned long);
379 380 381 382 383 384 385 386 387 388 389 390 391
	/* open dir, start readdir */
	int (*query_dir_first)(const unsigned int, struct cifs_tcon *,
			       const char *, struct cifs_sb_info *,
			       struct cifs_fid *, __u16,
			       struct cifs_search_info *);
	/* continue readdir */
	int (*query_dir_next)(const unsigned int, struct cifs_tcon *,
			      struct cifs_fid *,
			      __u16, struct cifs_search_info *srch_inf);
	/* close dir */
	int (*close_dir)(const unsigned int, struct cifs_tcon *,
			 struct cifs_fid *);
	/* calculate a size of SMB message */
392
	unsigned int (*calc_smb_size)(void *buf, struct TCP_Server_Info *ptcpi);
393 394
	/* check for STATUS_PENDING and process the response if yes */
	bool (*is_status_pending)(char *buf, struct TCP_Server_Info *server);
395 396
	/* check for STATUS_NETWORK_SESSION_EXPIRED */
	bool (*is_session_expired)(char *);
397 398 399
	/* send oplock break response */
	int (*oplock_response)(struct cifs_tcon *, struct cifs_fid *,
			       struct cifsInodeInfo *);
400 401
	/* query remote filesystem */
	int (*queryfs)(const unsigned int, struct cifs_tcon *,
402
		       struct cifs_sb_info *, struct kstatfs *);
403 404 405 406 407 408 409 410
	/* send mandatory brlock to the server */
	int (*mand_lock)(const unsigned int, struct cifsFileInfo *, __u64,
			 __u64, __u32, int, int, bool);
	/* unlock range of mandatory locks */
	int (*mand_unlock_range)(struct cifsFileInfo *, struct file_lock *,
				 const unsigned int);
	/* push brlocks from the cache to the server */
	int (*push_mand_locks)(struct cifsFileInfo *);
411
	/* get lease key of the inode */
412
	void (*get_lease_key)(struct inode *, struct cifs_fid *);
413
	/* set lease key of the inode */
414
	void (*set_lease_key)(struct inode *, struct cifs_fid *);
415
	/* generate new lease key */
416
	void (*new_lease_key)(struct cifs_fid *);
417
	int (*generate_signingkey)(struct cifs_ses *);
418 419
	int (*calc_signature)(struct smb_rqst *, struct TCP_Server_Info *,
				bool allocate_crypto);
420 421
	int (*set_integrity)(const unsigned int, struct cifs_tcon *tcon,
			     struct cifsFileInfo *src_file);
422 423
	int (*enum_snapshots)(const unsigned int xid, struct cifs_tcon *tcon,
			     struct cifsFileInfo *src_file, void __user *);
424 425
	int (*notify)(const unsigned int xid, struct file *pfile,
			     void __user *pbuf);
426 427 428
	int (*query_mf_symlink)(unsigned int, struct cifs_tcon *,
				struct cifs_sb_info *, const unsigned char *,
				char *, unsigned int *);
429 430 431
	int (*create_mf_symlink)(unsigned int, struct cifs_tcon *,
				 struct cifs_sb_info *, const unsigned char *,
				 char *, unsigned int *);
432 433 434
	/* if we can do cache read operations */
	bool (*is_read_op)(__u32);
	/* set oplock level for the inode */
435 436
	void (*set_oplock_level)(struct cifsInodeInfo *, __u32, unsigned int,
				 bool *);
437
	/* create lease context buffer for CREATE request */
438
	char * (*create_lease_buf)(u8 *lease_key, u8 oplock);
439
	/* parse lease context buffer and return oplock/epoch info */
440
	__u8 (*parse_lease_buf)(void *buf, unsigned int *epoch, char *lkey);
441
	ssize_t (*copychunk_range)(const unsigned int,
442
			struct cifsFileInfo *src_file,
443 444
			struct cifsFileInfo *target_file,
			u64 src_off, u64 len, u64 dest_off);
445 446 447
	int (*duplicate_extents)(const unsigned int, struct cifsFileInfo *src,
			struct cifsFileInfo *target_file, u64 src_off, u64 len,
			u64 dest_off);
448
	int (*validate_negotiate)(const unsigned int, struct cifs_tcon *);
449 450
	ssize_t (*query_all_EAs)(const unsigned int, struct cifs_tcon *,
			const unsigned char *, const unsigned char *, char *,
451
			size_t, struct cifs_sb_info *);
452 453
	int (*set_EA)(const unsigned int, struct cifs_tcon *, const char *,
			const char *, const void *, const __u16,
454
			const struct nls_table *, struct cifs_sb_info *);
455
	struct cifs_ntsd * (*get_acl)(struct cifs_sb_info *, struct inode *,
456
			const char *, u32 *, u32);
457
	struct cifs_ntsd * (*get_acl_by_fid)(struct cifs_sb_info *,
458
			const struct cifs_fid *, u32 *, u32);
459 460
	int (*set_acl)(struct cifs_ntsd *, __u32, struct inode *, const char *,
			int);
461 462
	/* writepages retry size */
	unsigned int (*wp_retry_size)(struct inode *);
463 464
	/* get mtu credits */
	int (*wait_mtu_credits)(struct TCP_Server_Info *, unsigned int,
465
				unsigned int *, struct cifs_credits *);
466 467 468 469
	/* adjust previously taken mtu credits to request size */
	int (*adjust_credits)(struct TCP_Server_Info *server,
			      struct cifs_credits *credits,
			      const unsigned int payload_size);
470 471
	/* check if we need to issue closedir */
	bool (*dir_needs_close)(struct cifsFileInfo *);
472 473
	long (*fallocate)(struct file *, struct cifs_tcon *, int, loff_t,
			  loff_t);
474
	/* init transform request - used for encryption for now */
475 476
	int (*init_transform_rq)(struct TCP_Server_Info *, int num_rqst,
				 struct smb_rqst *, struct smb_rqst *);
477 478
	int (*is_transform_hdr)(void *buf);
	int (*receive_transform)(struct TCP_Server_Info *,
479
				 struct mid_q_entry **, char **, int *);
480 481
	enum securityEnum (*select_sectype)(struct TCP_Server_Info *,
			    enum securityEnum);
482
	int (*next_header)(char *);
483 484
	/* ioctl passthrough for query_info */
	int (*ioctl_query_info)(const unsigned int xid,
485
				struct cifs_tcon *tcon,
486
				struct cifs_sb_info *cifs_sb,
487
				__le16 *path, int is_dir,
488
				unsigned long p);
489 490 491 492 493
	/* make unix special files (block, char, fifo, socket) */
	int (*make_node)(unsigned int xid,
			 struct inode *inode,
			 struct dentry *dentry,
			 struct cifs_tcon *tcon,
494
			 const char *full_path,
495 496
			 umode_t mode,
			 dev_t device_number);
497 498 499
	/* version specific fiemap implementation */
	int (*fiemap)(struct cifs_tcon *tcon, struct cifsFileInfo *,
		      struct fiemap_extent_info *, u64, u64);
500 501
	/* version specific llseek implementation */
	loff_t (*llseek)(struct file *, struct cifs_tcon *, loff_t, int);
502 503
	/* Check for STATUS_IO_TIMEOUT */
	bool (*is_status_io_timeout)(char *buf);
504 505
	/* Check for STATUS_NETWORK_NAME_DELETED */
	void (*is_network_name_deleted)(char *buf, struct TCP_Server_Info *srv);
506 507 508 509
};

struct smb_version_values {
	char		*version_string;
510 511
	__u16		protocol_id;
	__u32		req_capabilities;
512 513 514 515
	__u32		large_lock_type;
	__u32		exclusive_lock_type;
	__u32		shared_lock_type;
	__u32		unlock_lock_type;
516
	size_t		header_preamble_size;
517 518
	size_t		header_size;
	size_t		max_header_size;
519
	size_t		read_rsp_size;
520
	__le16		lock_cmd;
521 522 523
	unsigned int	cap_unix;
	unsigned int	cap_nt_find;
	unsigned int	cap_large_files;
524 525
	__u16		signing_enabled;
	__u16		signing_required;
526
	size_t		create_lease_size;
527 528
};

529 530 531
#define HEADER_SIZE(server) (server->vals->header_size)
#define MAX_HEADER_SIZE(server) (server->vals->max_header_size)

532 533 534 535
/**
 * CIFS superblock mount flags (mnt_cifs_flags) to consider when
 * trying to reuse existing superblock for a new mount
 */
536 537 538
#define CIFS_MOUNT_MASK (CIFS_MOUNT_NO_PERM | CIFS_MOUNT_SET_UID | \
			 CIFS_MOUNT_SERVER_INUM | CIFS_MOUNT_DIRECT_IO | \
			 CIFS_MOUNT_NO_XATTR | CIFS_MOUNT_MAP_SPECIAL_CHR | \
539
			 CIFS_MOUNT_MAP_SFM_CHR | \
540 541 542 543 544
			 CIFS_MOUNT_UNX_EMUL | CIFS_MOUNT_NO_BRL | \
			 CIFS_MOUNT_CIFS_ACL | CIFS_MOUNT_OVERR_UID | \
			 CIFS_MOUNT_OVERR_GID | CIFS_MOUNT_DYNPERM | \
			 CIFS_MOUNT_NOPOSIXBRL | CIFS_MOUNT_NOSSYNC | \
			 CIFS_MOUNT_FSCACHE | CIFS_MOUNT_MF_SYMLINKS | \
545
			 CIFS_MOUNT_MULTIUSER | CIFS_MOUNT_STRICT_IO | \
546
			 CIFS_MOUNT_CIFS_BACKUPUID | CIFS_MOUNT_CIFS_BACKUPGID | \
547
			 CIFS_MOUNT_UID_FROM_ACL | CIFS_MOUNT_NO_HANDLE_CACHE | \
548
			 CIFS_MOUNT_NO_DFS | CIFS_MOUNT_MODE_FROM_SID | \
549
			 CIFS_MOUNT_RO_CACHE | CIFS_MOUNT_RW_CACHE)
550

551 552 553 554
/**
 * Generic VFS superblock mount flags (s_flags) to consider when
 * trying to reuse existing superblock for a new mount
 */
555 556
#define CIFS_MS_MASK (SB_RDONLY | SB_MANDLOCK | SB_NOEXEC | SB_NOSUID | \
		      SB_NODEV | SB_SYNCHRONOUS)
557 558 559

struct cifs_mnt_data {
	struct cifs_sb_info *cifs_sb;
560
	struct smb3_fs_context *ctx;
561 562 563
	int flags;
};

564 565 566
static inline unsigned int
get_rfc1002_length(void *buf)
{
567
	return be32_to_cpu(*((__be32 *)buf)) & 0xffffff;
568 569
}

570 571 572 573 574 575
static inline void
inc_rfc1001_len(void *buf, int count)
{
	be32_add_cpu((__be32 *)buf, count);
}

L
Linus Torvalds 已提交
576
struct TCP_Server_Info {
577 578
	struct list_head tcp_ses_list;
	struct list_head smb_ses_list;
579
	__u64 conn_id; /* connection identifier (useful for debugging) */
580
	int srv_count; /* reference counter */
581
	/* 15 character server name + 0x20 16th byte indicating type = srv */
582
	char server_RFC1001_name[RFC1001_NAME_LEN_WITH_NULL];
583 584
	struct smb_version_operations	*ops;
	struct smb_version_values	*vals;
585
	/* updates to tcpStatus protected by GlobalMid_Lock */
J
Jeff Layton 已提交
586
	enum statusEnum tcpStatus; /* what we think the status is */
587
	char *hostname; /* hostname portion of UNC string */
L
Linus Torvalds 已提交
588
	struct socket *ssocket;
589
	struct sockaddr_storage dstaddr;
590
	struct sockaddr_storage srcaddr; /* locally bind to this IP */
591 592 593
#ifdef CONFIG_NET_NS
	struct net *net;
#endif
S
Steve French 已提交
594
	wait_queue_head_t response_q;
L
Linus Torvalds 已提交
595 596
	wait_queue_head_t request_q; /* if more than maxmpx to srvr must block*/
	struct list_head pending_mid_q;
597 598
	bool noblocksnd;		/* use blocking sendmsg */
	bool noautotune;		/* do not autotune send buf sizes */
599
	bool nosharesock;
600
	bool tcp_nodelay;
601 602
	unsigned int credits;  /* send no more requests at once */
	unsigned int max_credits; /* can override large 32000 default at mnt */
603
	unsigned int in_flight;  /* number of requests on the wire to server */
604
	unsigned int max_in_flight; /* max number of requests that were on wire */
605
	spinlock_t req_lock;  /* protect the two values above */
606
	struct mutex srv_mutex;
L
Linus Torvalds 已提交
607 608
	struct task_struct *tsk;
	char server_GUID[16];
609
	__u16 sec_mode;
610
	bool sign; /* is signing enabled on this connection? */
611
	bool ignore_signature:1; /* skip validation of signatures in SMB2/3 rsp */
J
Jeff Layton 已提交
612
	bool session_estab; /* mark when very first sess is established */
613 614 615
	int echo_credits;  /* echo reserved slots */
	int oplock_credits;  /* oplock break reserved slots */
	bool echoes:1; /* enable echoes */
616
	__u8 client_guid[SMB2_CLIENT_GUID_SIZE]; /* Client GUID */
J
Jeff Layton 已提交
617
	u16 dialect; /* dialect index that server chose */
618
	bool oplocks:1; /* enable oplocks */
L
Linus Torvalds 已提交
619 620
	unsigned int maxReq;	/* Clients should submit no more */
	/* than maxReq distinct unanswered SMBs to the server when using  */
621
	/* multiplexed reads or writes (for SMB1/CIFS only, not SMB2/SMB3) */
L
Linus Torvalds 已提交
622 623
	unsigned int maxBuf;	/* maxBuf specifies the maximum */
	/* message size the server can send or receive for non-raw SMBs */
624 625
	/* maxBuf is returned by SMB NegotiateProtocol so maxBuf is only 0 */
	/* when socket is setup (and during reconnect) before NegProt sent */
626
	unsigned int max_rw;	/* maxRw specifies the maximum */
L
Linus Torvalds 已提交
627 628
	/* message size the server can send or receive for */
	/* SMB_COM_WRITE_RAW or SMB_COM_READ_RAW. */
629
	unsigned int capabilities; /* selective disabling of caps by smb sess */
630
	int timeAdj;  /* Adjust for difference in server time zone in sec */
631
	__u64 CurrentMid;         /* multiplex id - rotating counter, protected by GlobalMid_Lock */
632
	char cryptkey[CIFS_CRYPTO_KEY_SIZE]; /* used by ntlm, ntlmv2 etc */
633
	/* 16th byte of RFC1001 workstation name is always null */
634
	char workstation_RFC1001_name[RFC1001_NAME_LEN_WITH_NULL];
635
	__u32 sequence_number; /* for signing, protected by srv_mutex */
636
	__u32 reconnect_instance; /* incremented on each reconnect */
637
	struct session_key session_key;
638
	unsigned long lstrp; /* when we got last response from this server */
639
	struct cifs_secmech secmech; /* crypto sec mech functs, descriptors */
640 641 642
#define	CIFS_NEGFLAVOR_UNENCAP	1	/* wct == 17, but no ext_sec */
#define	CIFS_NEGFLAVOR_EXTENDED	2	/* wct == 17, ext_sec bit set */
	char	negflavor;	/* NEGOTIATE response flavor */
643
	/* extended security flavors that server supports */
J
Jeff Layton 已提交
644 645
	bool	sec_ntlmssp;		/* supports NTLMSSP */
	bool	sec_kerberosu2u;	/* supports U2U Kerberos */
646 647
	bool	sec_kerberos;		/* supports plain Kerberos */
	bool	sec_mskerberos;		/* supports legacy MS Kerberos */
648
	bool	large_buf;		/* is current buffer large? */
649 650 651 652
	/* use SMBD connection instead of socket */
	bool	rdma;
	/* point to the SMBD connection if RDMA is used instead of socket */
	struct smbd_connection *smbd_conn;
653
	struct delayed_work	echo; /* echo ping workqueue job */
654
	struct delayed_work	resolve; /* dns resolution workqueue job */
655 656
	char	*smallbuf;	/* pointer to current "small" buffer */
	char	*bigbuf;	/* pointer to current "big" buffer */
657 658
	/* Total size of this PDU. Only valid from cifs_demultiplex_thread */
	unsigned int pdu_size;
659
	unsigned int total_read; /* total amount of data read in this pass */
660 661
	atomic_t in_send; /* requests trying to send */
	atomic_t num_waiters;   /* blocked waiting to get in sendrecv */
662 663 664
#ifdef CONFIG_CIFS_FSCACHE
	struct fscache_cookie   *fscache; /* client index cache cookie */
#endif
J
Jeff Layton 已提交
665
#ifdef CONFIG_CIFS_STATS2
666
	atomic_t num_cmds[NUMBER_OF_SMB2_COMMANDS]; /* total requests by cmd */
667
	atomic_t smb2slowcmd[NUMBER_OF_SMB2_COMMANDS]; /* count resps > 1 sec */
668 669 670
	__u64 time_per_cmd[NUMBER_OF_SMB2_COMMANDS]; /* total time per cmd */
	__u32 slowest_cmd[NUMBER_OF_SMB2_COMMANDS];
	__u32 fastest_cmd[NUMBER_OF_SMB2_COMMANDS];
671
#endif /* STATS2 */
672 673
	unsigned int	max_read;
	unsigned int	max_write;
674
	unsigned int	min_offload;
675
	__le16	compress_algorithm;
676
	__u16	signing_algorithm;
677
	__le16	cipher_type;
678 679
	 /* save initital negprot hash */
	__u8	preauth_sha_hash[SMB2_PREAUTH_HASH_SIZE];
680
	bool	signing_negotiated; /* true if valid signing context rcvd from server */
681
	bool	posix_ext_supported;
682 683
	struct delayed_work reconnect; /* reconnect workqueue job */
	struct mutex reconnect_mutex; /* prevent simultaneous reconnects */
684
	unsigned long echo_interval;
685 686 687 688 689 690 691

	/*
	 * Number of targets available for reconnect. The more targets
	 * the more tasks have to wait to let the demultiplex thread
	 * reconnect.
	 */
	int nr_targets;
692
	bool noblockcnt; /* use non-blocking connect() */
693 694 695 696 697 698 699 700 701

	/*
	 * If this is a session channel,
	 * primary_server holds the ref-counted
	 * pointer to primary channel connection for the session.
	 */
#define CIFS_SERVER_IS_CHAN(server)	(!!(server)->primary_server)
	struct TCP_Server_Info *primary_server;

702 703 704 705
#ifdef CONFIG_CIFS_SWN_UPCALL
	bool use_swn_dstaddr;
	struct sockaddr_storage swn_dstaddr;
#endif
706 707
#ifdef CONFIG_CIFS_DFS_UPCALL
	bool is_dfs_conn; /* if a dfs connection */
708 709 710 711 712 713 714 715 716 717 718 719 720
	struct mutex refpath_lock; /* protects leaf_fullpath */
	/*
	 * Canonical DFS full paths that were used to chase referrals in mount and reconnect.
	 *
	 * origin_fullpath: first or original referral path
	 * leaf_fullpath: last referral path (might be changed due to nested links in reconnect)
	 *
	 * current_fullpath: pointer to either origin_fullpath or leaf_fullpath
	 * NOTE: cannot be accessed outside cifs_reconnect() and smb2_reconnect()
	 *
	 * format: \\HOST\SHARE\[OPTIONAL PATH]
	 */
	char *origin_fullpath, *leaf_fullpath, *current_fullpath;
721
#endif
L
Linus Torvalds 已提交
722 723
};

724 725 726 727 728
struct cifs_credits {
	unsigned int value;
	unsigned int instance;
};

729 730 731 732 733 734 735 736 737 738
static inline unsigned int
in_flight(struct TCP_Server_Info *server)
{
	unsigned int num;
	spin_lock(&server->req_lock);
	num = server->in_flight;
	spin_unlock(&server->req_lock);
	return num;
}

739
static inline bool
740
has_credits(struct TCP_Server_Info *server, int *credits, int num_credits)
741
{
742
	int num;
743
	spin_lock(&server->req_lock);
744
	num = *credits;
745
	spin_unlock(&server->req_lock);
746
	return num >= num_credits;
747 748
}

749
static inline void
750
add_credits(struct TCP_Server_Info *server, const struct cifs_credits *credits,
751
	    const int optype)
752
{
753
	server->ops->add_credits(server, credits, optype);
754 755
}

756
static inline void
757 758
add_credits_and_wake_if(struct TCP_Server_Info *server,
			const struct cifs_credits *credits, const int optype)
759
{
760 761
	if (credits->value) {
		server->ops->add_credits(server, credits, optype);
762 763 764 765
		wake_up(&server->request_q);
	}
}

766 767 768 769 770 771
static inline void
set_credits(struct TCP_Server_Info *server, const int val)
{
	server->ops->set_credits(server, val);
}

772 773 774 775 776 777 778 779
static inline int
adjust_credits(struct TCP_Server_Info *server, struct cifs_credits *credits,
	       const unsigned int payload_size)
{
	return server->ops->adjust_credits ?
		server->ops->adjust_credits(server, credits, payload_size) : 0;
}

780
static inline __le64
781
get_next_mid64(struct TCP_Server_Info *server)
782
{
783
	return cpu_to_le64(server->ops->get_next_mid(server));
784 785
}

786 787 788
static inline __le16
get_next_mid(struct TCP_Server_Info *server)
{
789
	__u16 mid = server->ops->get_next_mid(server);
790 791 792 793 794 795 796
	/*
	 * The value in the SMB header should be little endian for easy
	 * on-the-wire decoding.
	 */
	return cpu_to_le16(mid);
}

797 798 799 800 801 802 803 804 805
static inline void
revert_current_mid(struct TCP_Server_Info *server, const unsigned int val)
{
	if (server->ops->revert_current_mid)
		server->ops->revert_current_mid(server, val);
}

static inline void
revert_current_mid_from_hdr(struct TCP_Server_Info *server,
806
			    const struct smb2_hdr *shdr)
807 808 809 810 811 812
{
	unsigned int num = le16_to_cpu(shdr->CreditCharge);

	return revert_current_mid(server, num > 0 ? num : 1);
}

813 814 815 816 817 818 819 820 821 822 823 824
static inline __u16
get_mid(const struct smb_hdr *smb)
{
	return le16_to_cpu(smb->Mid);
}

static inline bool
compare_mid(__u16 mid, const struct smb_hdr *smb)
{
	return mid == le16_to_cpu(smb->Mid);
}

825 826 827 828 829 830 831
/*
 * When the server supports very large reads and writes via POSIX extensions,
 * we can allow up to 2^24-1, minus the size of a READ/WRITE_AND_X header, not
 * including the RFC1001 length.
 *
 * Note that this might make for "interesting" allocation problems during
 * writeback however as we have to allocate an array of pointers for the
832
 * pages. A 16M write means ~32kb page array with PAGE_SIZE == 4096.
833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850
 *
 * For reads, there is a similar problem as we need to allocate an array
 * of kvecs to handle the receive, though that should only need to be done
 * once.
 */
#define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
#define CIFS_MAX_RSIZE ((1<<24) - sizeof(READ_RSP) + 4)

/*
 * When the server doesn't allow large posix writes, only allow a rsize/wsize
 * of 2^17-1 minus the size of the call header. That allows for a read or
 * write up to the maximum size described by RFC1002.
 */
#define CIFS_MAX_RFC1002_WSIZE ((1<<17) - 1 - sizeof(WRITE_REQ) + 4)
#define CIFS_MAX_RFC1002_RSIZE ((1<<17) - 1 - sizeof(READ_RSP) + 4)

/*
 * The default wsize is 1M. find_get_pages seems to return a maximum of 256
851
 * pages in a single call. With PAGE_SIZE == 4k, this means we can fill
852 853 854
 * a single wsize request with a single call.
 */
#define CIFS_DEFAULT_IOSIZE (1024 * 1024)
855
#define SMB3_DEFAULT_IOSIZE (4 * 1024 * 1024)
856 857 858 859 860 861 862 863 864 865

/*
 * Windows only supports a max of 60kb reads and 65535 byte writes. Default to
 * those values when posix extensions aren't in force. In actuality here, we
 * use 65536 to allow for a write that is a multiple of 4k. Most servers seem
 * to be ok with the extra byte even though Windows doesn't send writes that
 * are that large.
 *
 * Citation:
 *
866
 * https://blogs.msdn.com/b/openspecification/archive/2009/04/10/smb-maximum-transmit-buffer-size-and-performance-tuning.aspx
867 868 869 870
 */
#define CIFS_DEFAULT_NON_POSIX_RSIZE (60 * 1024)
#define CIFS_DEFAULT_NON_POSIX_WSIZE (65536)

871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900
/*
 * Macros to allow the TCP_Server_Info->net field and related code to drop out
 * when CONFIG_NET_NS isn't set.
 */

#ifdef CONFIG_NET_NS

static inline struct net *cifs_net_ns(struct TCP_Server_Info *srv)
{
	return srv->net;
}

static inline void cifs_set_net_ns(struct TCP_Server_Info *srv, struct net *net)
{
	srv->net = net;
}

#else

static inline struct net *cifs_net_ns(struct TCP_Server_Info *srv)
{
	return &init_net;
}

static inline void cifs_set_net_ns(struct TCP_Server_Info *srv, struct net *net)
{
}

#endif

901 902 903 904 905 906 907
struct cifs_server_iface {
	size_t speed;
	unsigned int rdma_capable : 1;
	unsigned int rss_capable : 1;
	struct sockaddr_storage sockaddr;
};

908 909 910 911 912
struct cifs_chan {
	struct TCP_Server_Info *server;
	__u8 signkey[SMB3_SIGN_KEY_SIZE];
};

L
Linus Torvalds 已提交
913 914 915
/*
 * Session structure.  One of these for each uid session with a particular host
 */
916
struct cifs_ses {
917
	struct list_head smb_ses_list;
918
	struct list_head tcon_list;
919
	struct cifs_tcon *tcon_ipc;
920
	struct mutex session_mutex;
L
Linus Torvalds 已提交
921
	struct TCP_Server_Info *server;	/* pointer to server info */
922
	int ses_count;		/* reference counter */
923
	enum statusEnum status;  /* updates protected by GlobalMid_Lock */
924
	unsigned overrideSecFlg;  /* if non-zero override global sec flags */
925 926
	char *serverOS;		/* name of operating system underlying server */
	char *serverNOS;	/* name of network operating system of server */
L
Linus Torvalds 已提交
927
	char *serverDomain;	/* security realm of server */
928
	__u64 Suid;		/* remote smb uid  */
929 930
	kuid_t linux_uid;	/* overriding owner of files on the mount */
	kuid_t cred_uid;	/* owner of credentials */
931
	unsigned int capabilities;
932
	char ip_addr[INET6_ADDRSTRLEN + 1]; /* Max ipv6 (or v4) addr string len */
933 934
	char *user_name;	/* must not be null except during init of sess
				   and after mount option parsing we fill it */
S
Steve French 已提交
935 936
	char *domainName;
	char *password;
937
	char *workstation_name;
938
	struct session_key auth_key;
939
	struct ntlmssp_auth *ntlmssp; /* ciphertext, flags, server challenge */
940 941
	enum securityEnum sectype; /* what security flavor was specified? */
	bool sign;		/* is signing required? */
942
	bool domainAuto:1;
943
	bool binding:1; /* are we binding the session? */
944
	__u16 session_flags;
945
	__u8 smb3signingkey[SMB3_SIGN_KEY_SIZE];
946 947
	__u8 smb3encryptionkey[SMB3_ENC_DEC_KEY_SIZE];
	__u8 smb3decryptionkey[SMB3_ENC_DEC_KEY_SIZE];
948
	__u8 preauth_sha_hash[SMB2_PREAUTH_HASH_SIZE];
949

950 951
	__u8 binding_preauth_sha_hash[SMB2_PREAUTH_HASH_SIZE];

952 953 954 955 956 957 958 959 960 961
	/*
	 * Network interfaces available on the server this session is
	 * connected to.
	 *
	 * Other channels can be opened by connecting and binding this
	 * session to interfaces from this list.
	 *
	 * iface_lock should be taken when accessing any of these fields
	 */
	spinlock_t iface_lock;
962
	/* ========= begin: protected by iface_lock ======== */
963 964 965
	struct cifs_server_iface *iface_list;
	size_t iface_count;
	unsigned long iface_last_update; /* jiffies */
966
	/* ========= end: protected by iface_lock ======== */
967

968 969
	spinlock_t chan_lock;
	/* ========= begin: protected by chan_lock ======== */
970
#define CIFS_MAX_CHANNELS 16
971 972 973 974 975 976 977
#define CIFS_ALL_CHANNELS_SET(ses)	\
	((1UL << (ses)->chan_count) - 1)
#define CIFS_ALL_CHANS_NEED_RECONNECT(ses)	\
	((ses)->chans_need_reconnect == CIFS_ALL_CHANNELS_SET(ses))
#define CIFS_CHAN_NEEDS_RECONNECT(ses, index)	\
	test_bit((index), &(ses)->chans_need_reconnect)

978
	struct cifs_chan chans[CIFS_MAX_CHANNELS];
979
	struct cifs_chan *binding_chan;
980 981 982
	size_t chan_count;
	size_t chan_max;
	atomic_t chan_seq; /* round robin state */
983 984 985 986 987 988 989

	/*
	 * chans_need_reconnect is a bitmap indicating which of the channels
	 * under this smb session needs to be reconnected.
	 * If not multichannel session, only one bit will be used.
	 */
	unsigned long chans_need_reconnect;
990
	/* ========= end: protected by chan_lock ======== */
L
Linus Torvalds 已提交
991
};
992

993 994
/*
 * When binding a new channel, we need to access the channel which isn't fully
995
 * established yet.
996 997 998 999 1000 1001
 */

static inline
struct cifs_chan *cifs_ses_binding_channel(struct cifs_ses *ses)
{
	if (ses->binding)
1002
		return ses->binding_chan;
1003 1004 1005 1006
	else
		return NULL;
}

1007 1008 1009 1010 1011 1012 1013 1014
/*
 * Returns the server pointer of the session. When binding a new
 * channel this returns the last channel which isn't fully established
 * yet.
 *
 * This function should be use for negprot/sess.setup codepaths. For
 * the other requests see cifs_pick_channel().
 */
1015 1016 1017 1018
static inline
struct TCP_Server_Info *cifs_ses_server(struct cifs_ses *ses)
{
	if (ses->binding)
1019
		return ses->binding_chan->server;
1020 1021 1022 1023
	else
		return ses->server;
}

1024 1025 1026 1027 1028 1029
static inline bool
cap_unix(struct cifs_ses *ses)
{
	return ses->server->vals->cap_unix & ses->capabilities;
}

1030 1031
struct cached_fid {
	bool is_valid:1;	/* Do we have a useable root fid */
1032
	bool file_all_info_is_valid:1;
1033
	bool has_lease:1;
1034
	unsigned long time; /* jiffies of when lease was taken */
1035
	struct kref refcount;
1036 1037 1038
	struct cifs_fid *fid;
	struct mutex fid_mutex;
	struct cifs_tcon *tcon;
1039
	struct dentry *dentry;
1040
	struct work_struct lease_break;
1041
	struct smb2_file_all_info file_all_info;
1042 1043
};

L
Linus Torvalds 已提交
1044 1045
/*
 * there is one of these for each connection to a resource on a particular
S
Steve French 已提交
1046
 * session
L
Linus Torvalds 已提交
1047
 */
1048
struct cifs_tcon {
1049 1050
	struct list_head tcon_list;
	int tc_count;
1051
	struct list_head rlist; /* reconnect list */
1052 1053
	atomic_t num_local_opens;  /* num of all opens including disconnected */
	atomic_t num_remote_opens; /* num of all network opens on server */
L
Linus Torvalds 已提交
1054
	struct list_head openFileList;
1055
	spinlock_t open_file_lock; /* protects list above */
1056
	struct cifs_ses *ses;	/* pointer to session associated with */
1057
	char treeName[MAX_TREE_SIZE + 1]; /* UNC name of resource in ASCII */
L
Linus Torvalds 已提交
1058
	char *nativeFileSystem;
1059
	char *password;		/* for share-level security */
1060
	__u32 tid;		/* The 4 byte tree id */
L
Linus Torvalds 已提交
1061 1062 1063
	__u16 Flags;		/* optional support bits */
	enum statusEnum tidStatus;
	atomic_t num_smbs_sent;
1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087
	union {
		struct {
			atomic_t num_writes;
			atomic_t num_reads;
			atomic_t num_flushes;
			atomic_t num_oplock_brks;
			atomic_t num_opens;
			atomic_t num_closes;
			atomic_t num_deletes;
			atomic_t num_mkdirs;
			atomic_t num_posixopens;
			atomic_t num_posixmkdirs;
			atomic_t num_rmdirs;
			atomic_t num_renames;
			atomic_t num_t2renames;
			atomic_t num_ffirst;
			atomic_t num_fnext;
			atomic_t num_fclose;
			atomic_t num_hardlinks;
			atomic_t num_symlinks;
			atomic_t num_locks;
			atomic_t num_acl_get;
			atomic_t num_acl_set;
		} cifs_stats;
1088 1089 1090 1091
		struct {
			atomic_t smb2_com_sent[NUMBER_OF_SMB2_COMMANDS];
			atomic_t smb2_com_failed[NUMBER_OF_SMB2_COMMANDS];
		} smb2_stats;
1092
	} stats;
L
Linus Torvalds 已提交
1093 1094
	__u64    bytes_read;
	__u64    bytes_written;
1095
	spinlock_t stat_lock;  /* protects the two fields above */
L
Linus Torvalds 已提交
1096
	FILE_SYSTEM_DEVICE_INFO fsDevInfo;
1097
	FILE_SYSTEM_ATTRIBUTE_INFO fsAttrInfo; /* ok if fs name truncated */
L
Linus Torvalds 已提交
1098
	FILE_SYSTEM_UNIX_INFO fsUnixInfo;
1099 1100 1101
	bool ipc:1;   /* set if connection to IPC$ share (always also pipe) */
	bool pipe:1;  /* set if connection to pipe share */
	bool print:1; /* set if connection to printer share */
1102 1103
	bool retry:1;
	bool nocase:1;
1104
	bool nohandlecache:1; /* if strange server resource prob can turn off */
1105
	bool nodelete:1;
1106
	bool seal:1;      /* transport encryption for this mounted share */
1107
	bool unix_ext:1;  /* if false disable Linux extensions to CIFS protocol
1108
				for this mount even if server would support */
1109
	bool posix_extensions; /* if true SMB3.11 posix extensions enabled */
1110
	bool local_lease:1; /* check leases (only) on local system not remote */
1111
	bool broken_posix_open; /* e.g. Samba server versions < 3.3.2, 3.2.9 */
1112
	bool broken_sparse_sup; /* if server or share does not support sparse */
1113
	bool need_reconnect:1; /* connection reset, tid now invalid */
1114
	bool need_reopen_files:1; /* need to reopen tcon file handles */
1115
	bool use_resilient:1; /* use resilient instead of durable handles */
1116
	bool use_persistent:1; /* use persistent instead of durable handles */
1117
	bool no_lease:1;    /* Do not request leases on files or directories */
1118
	bool use_witness:1; /* use witness protocol */
1119
	__le32 capabilities;
1120 1121 1122 1123
	__u32 share_flags;
	__u32 maximal_access;
	__u32 vol_serial_number;
	__le64 vol_create_time;
1124
	__u64 snapshot_time; /* for timewarp tokens - timestamp of snapshot */
1125
	__u32 handle_timeout; /* persistent and durable handle timeout in ms */
1126 1127
	__u32 ss_flags;		/* sector size flags */
	__u32 perf_sector_size; /* best sector size for perf */
1128 1129 1130
	__u32 max_chunks;
	__u32 max_bytes_chunk;
	__u32 max_bytes_copy;
1131 1132 1133 1134
#ifdef CONFIG_CIFS_FSCACHE
	u64 resource_id;		/* server resource id */
	struct fscache_cookie *fscache;	/* cookie for share */
#endif
1135
	struct list_head pending_opens;	/* list of incomplete opens */
1136
	struct cached_fid crfid; /* Cached root fid */
1137
	/* BB add field for back pointer to sb struct(s)? */
1138 1139 1140
#ifdef CONFIG_CIFS_DFS_UPCALL
	struct list_head ulist; /* cache update list */
#endif
L
Linus Torvalds 已提交
1141 1142
};

1143 1144 1145 1146 1147 1148 1149
/*
 * This is a refcounted and timestamped container for a tcon pointer. The
 * container holds a tcon reference. It is considered safe to free one of
 * these when the tl_count goes to 0. The tl_time is the time of the last
 * "get" on the container.
 */
struct tcon_link {
1150
	struct rb_node		tl_rbnode;
1151
	kuid_t			tl_uid;
1152 1153 1154 1155 1156 1157
	unsigned long		tl_flags;
#define TCON_LINK_MASTER	0
#define TCON_LINK_PENDING	1
#define TCON_LINK_IN_TREE	2
	unsigned long		tl_time;
	atomic_t		tl_count;
1158
	struct cifs_tcon	*tl_tcon;
1159 1160
};

1161
extern struct tcon_link *cifs_sb_tlink(struct cifs_sb_info *cifs_sb);
1162
extern void smb3_free_compound_rqst(int num_rqst, struct smb_rqst *rqst);
1163

1164
static inline struct cifs_tcon *
1165 1166
tlink_tcon(struct tcon_link *tlink)
{
1167
	return tlink->tl_tcon;
1168 1169
}

1170 1171 1172 1173 1174 1175
static inline struct tcon_link *
cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
{
	return cifs_sb->master_tlink;
}

1176
extern void cifs_put_tlink(struct tcon_link *tlink);
1177

1178 1179 1180
static inline struct tcon_link *
cifs_get_tlink(struct tcon_link *tlink)
{
1181 1182
	if (tlink && !IS_ERR(tlink))
		atomic_inc(&tlink->tl_count);
1183 1184 1185
	return tlink;
}

1186
/* This function is always expected to succeed */
1187
extern struct cifs_tcon *cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb);
1188

1189 1190 1191 1192 1193 1194 1195 1196 1197
#define CIFS_OPLOCK_NO_CHANGE 0xfe

struct cifs_pending_open {
	struct list_head olist;
	struct tcon_link *tlink;
	__u8 lease_key[16];
	__u32 oplock;
};

1198 1199 1200 1201 1202 1203 1204 1205
struct cifs_deferred_close {
	struct list_head dlist;
	struct tcon_link *tlink;
	__u16  netfid;
	__u64  persistent_fid;
	__u64  volatile_fid;
};

L
Linus Torvalds 已提交
1206
/*
J
[CIFS]  
Jeremy Allison 已提交
1207 1208
 * This info hangs off the cifsFileInfo structure, pointed to by llist.
 * This is used to track byte stream locks on the file
L
Linus Torvalds 已提交
1209 1210
 */
struct cifsLockInfo {
J
[CIFS]  
Jeremy Allison 已提交
1211
	struct list_head llist;	/* pointer to next cifsLockInfo */
1212 1213
	struct list_head blist; /* pointer to locks blocked on this */
	wait_queue_head_t block_q;
J
[CIFS]  
Jeremy Allison 已提交
1214 1215
	__u64 offset;
	__u64 length;
1216
	__u32 pid;
1217 1218
	__u16 type;
	__u16 flags;
L
Linus Torvalds 已提交
1219 1220 1221 1222 1223 1224 1225 1226 1227 1228
};

/*
 * One of these for each open instance of a file
 */
struct cifs_search_info {
	loff_t index_of_last_entry;
	__u16 entries_in_buffer;
	__u16 info_level;
	__u32 resume_key;
S
Steve French 已提交
1229 1230
	char *ntwrk_buf_start;
	char *srch_entries_start;
1231
	char *last_entry;
1232
	const char *presume_name;
L
Linus Torvalds 已提交
1233
	unsigned int resume_name_len;
1234 1235 1236 1237
	bool endOfSearch:1;
	bool emptyDir:1;
	bool unicode:1;
	bool smallBuf:1; /* so we know which buf_release function to call */
L
Linus Torvalds 已提交
1238 1239
};

1240
#define ACL_NO_MODE	((umode_t)(-1))
1241 1242 1243 1244 1245 1246 1247 1248
struct cifs_open_parms {
	struct cifs_tcon *tcon;
	struct cifs_sb_info *cifs_sb;
	int disposition;
	int desired_access;
	int create_options;
	const char *path;
	struct cifs_fid *fid;
1249
	umode_t mode;
1250
	bool reconnect:1;
1251 1252
};

1253 1254
struct cifs_fid {
	__u16 netfid;
1255 1256
	__u64 persistent_fid;	/* persist file id for smb2 */
	__u64 volatile_fid;	/* volatile file id for smb2 */
1257
	__u8 lease_key[SMB2_LEASE_KEY_SIZE];	/* lease key for smb2 */
1258
	__u8 create_guid[16];
1259
	__u32 access;
1260
	struct cifs_pending_open *pending_open;
1261
	unsigned int epoch;
1262 1263 1264
#ifdef CONFIG_CIFS_DEBUG2
	__u64 mid;
#endif /* CIFS_DEBUG2 */
1265
	bool purge_cache;
1266 1267
};

1268 1269 1270 1271 1272 1273
struct cifs_fid_locks {
	struct list_head llist;
	struct cifsFileInfo *cfile;	/* fid that owns locks */
	struct list_head locks;		/* locks held by fid above */
};

L
Linus Torvalds 已提交
1274
struct cifsFileInfo {
1275
	/* following two lists are protected by tcon->open_file_lock */
L
Linus Torvalds 已提交
1276 1277
	struct list_head tlist;	/* pointer to next fid owned by tcon */
	struct list_head flist;	/* next fid (file instance) for this inode */
1278
	/* lock list below protected by cifsi->lock_sem */
1279
	struct cifs_fid_locks *llist;	/* brlocks held by this fid */
1280
	kuid_t uid;		/* allows finding which FileInfo structure */
L
Linus Torvalds 已提交
1281
	__u32 pid;		/* process id who opened file */
1282
	struct cifs_fid fid;	/* file id from remote */
1283
	struct list_head rlist; /* reconnect list */
L
Linus Torvalds 已提交
1284 1285
	/* BB add lock scope info here if needed */ ;
	/* lock scope id (0 if none) */
1286
	struct dentry *dentry;
1287
	struct tcon_link *tlink;
1288
	unsigned int f_flags;
1289
	bool invalidHandle:1;	/* file closed via session abend */
1290
	bool swapfile:1;
1291
	bool oplock_break_cancelled:1;
1292 1293
	unsigned int oplock_epoch; /* epoch from the lease break */
	__u32 oplock_level; /* oplock/lease level from the lease break */
1294 1295
	int count;
	spinlock_t file_info_lock; /* protects four flag/count fields above */
1296
	struct mutex fh_mutex; /* prevents reopen race after dead ses*/
L
Linus Torvalds 已提交
1297
	struct cifs_search_info srch_inf;
1298
	struct work_struct oplock_break; /* work for oplock breaks */
1299
	struct work_struct put; /* work for the final part of _put */
1300
	struct delayed_work deferred;
1301
	bool deferred_close_scheduled; /* Flag to indicate close is scheduled */
L
Linus Torvalds 已提交
1302 1303
};

1304 1305
struct cifs_io_parms {
	__u16 netfid;
1306 1307
	__u64 persistent_fid;	/* persist file id for smb2 */
	__u64 volatile_fid;	/* volatile file id for smb2 */
1308 1309 1310
	__u32 pid;
	__u64 offset;
	unsigned int length;
1311
	struct cifs_tcon *tcon;
1312
	struct TCP_Server_Info *server;
1313 1314
};

1315 1316 1317 1318 1319 1320 1321 1322 1323
struct cifs_aio_ctx {
	struct kref		refcount;
	struct list_head	list;
	struct mutex		aio_mutex;
	struct completion	done;
	struct iov_iter		iter;
	struct kiocb		*iocb;
	struct cifsFileInfo	*cfile;
	struct bio_vec		*bv;
1324
	loff_t			pos;
1325 1326 1327 1328 1329
	unsigned int		npages;
	ssize_t			rc;
	unsigned int		len;
	unsigned int		total_len;
	bool			should_dirty;
1330 1331 1332 1333 1334
	/*
	 * Indicates if this aio_ctx is for direct_io,
	 * If yes, iter is a copy of the user passed iov_iter
	 */
	bool			direct_io;
1335 1336
};

1337 1338 1339 1340 1341 1342 1343
/* asynchronous read support */
struct cifs_readdata {
	struct kref			refcount;
	struct list_head		list;
	struct completion		done;
	struct cifsFileInfo		*cfile;
	struct address_space		*mapping;
1344
	struct cifs_aio_ctx		*ctx;
1345 1346
	__u64				offset;
	unsigned int			bytes;
1347
	unsigned int			got_bytes;
1348 1349 1350
	pid_t				pid;
	int				result;
	struct work_struct		work;
1351 1352 1353
	int (*read_into_pages)(struct TCP_Server_Info *server,
				struct cifs_readdata *rdata,
				unsigned int len);
1354 1355 1356
	int (*copy_into_pages)(struct TCP_Server_Info *server,
				struct cifs_readdata *rdata,
				struct iov_iter *iter);
1357
	struct kvec			iov[2];
1358
	struct TCP_Server_Info		*server;
1359 1360 1361
#ifdef CONFIG_CIFS_SMB_DIRECT
	struct smbd_mr			*mr;
#endif
1362
	unsigned int			pagesz;
1363
	unsigned int			page_offset;
1364
	unsigned int			tailsz;
1365
	struct cifs_credits		credits;
1366
	unsigned int			nr_pages;
1367
	struct page			**pages;
1368 1369
};

1370 1371 1372 1373 1374 1375 1376 1377
/* asynchronous write support */
struct cifs_writedata {
	struct kref			refcount;
	struct list_head		list;
	struct completion		done;
	enum writeback_sync_modes	sync_mode;
	struct work_struct		work;
	struct cifsFileInfo		*cfile;
1378
	struct cifs_aio_ctx		*ctx;
1379 1380 1381 1382
	__u64				offset;
	pid_t				pid;
	unsigned int			bytes;
	int				result;
1383
	struct TCP_Server_Info		*server;
1384 1385 1386
#ifdef CONFIG_CIFS_SMB_DIRECT
	struct smbd_mr			*mr;
#endif
1387
	unsigned int			pagesz;
1388
	unsigned int			page_offset;
1389
	unsigned int			tailsz;
1390
	struct cifs_credits		credits;
1391
	unsigned int			nr_pages;
1392
	struct page			**pages;
1393 1394
};

1395 1396
/*
 * Take a reference on the file private data. Must be called with
1397
 * cfile->file_info_lock held.
1398
 */
1399 1400
static inline void
cifsFileInfo_get_locked(struct cifsFileInfo *cifs_file)
1401
{
1402
	++cifs_file->count;
1403 1404
}

1405
struct cifsFileInfo *cifsFileInfo_get(struct cifsFileInfo *cifs_file);
1406 1407
void _cifsFileInfo_put(struct cifsFileInfo *cifs_file, bool wait_oplock_hdlr,
		       bool offload);
1408
void cifsFileInfo_put(struct cifsFileInfo *cifs_file);
1409

1410 1411
#define CIFS_CACHE_READ_FLG	1
#define CIFS_CACHE_HANDLE_FLG	2
1412
#define CIFS_CACHE_RH_FLG	(CIFS_CACHE_READ_FLG | CIFS_CACHE_HANDLE_FLG)
1413
#define CIFS_CACHE_WRITE_FLG	4
1414 1415
#define CIFS_CACHE_RW_FLG	(CIFS_CACHE_READ_FLG | CIFS_CACHE_WRITE_FLG)
#define CIFS_CACHE_RHW_FLG	(CIFS_CACHE_RW_FLG | CIFS_CACHE_HANDLE_FLG)
1416

1417
#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))
1418
#define CIFS_CACHE_HANDLE(cinode) (cinode->oplock & CIFS_CACHE_HANDLE_FLG)
1419
#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))
1420

L
Linus Torvalds 已提交
1421 1422 1423 1424 1425
/*
 * One of these for each file inode
 */

struct cifsInodeInfo {
1426
	bool can_cache_brlcks;
1427
	struct list_head llist;	/* locks helb by this inode */
1428 1429
	/*
	 * NOTE: Some code paths call down_read(lock_sem) twice, so
1430
	 * we must always use cifs_down_write() instead of down_write()
1431 1432
	 * for this semaphore to avoid deadlocks.
	 */
1433
	struct rw_semaphore lock_sem;	/* protect the fields above */
S
Steve French 已提交
1434
	/* BB add in lists for dirty pages i.e. write caching info for oplock */
L
Linus Torvalds 已提交
1435
	struct list_head openFileList;
1436
	spinlock_t	open_file_lock;	/* protects openFileList */
L
Linus Torvalds 已提交
1437
	__u32 cifsAttrs; /* e.g. DOS archive bit, sparse, compressed, system */
1438
	unsigned int oplock;		/* oplock/lease level we have */
1439
	unsigned int epoch;		/* used to track lease state changes */
1440 1441
#define CIFS_INODE_PENDING_OPLOCK_BREAK   (0) /* oplock break in progress */
#define CIFS_INODE_PENDING_WRITERS	  (1) /* Writes in progress */
1442
#define CIFS_INODE_FLAG_UNUSED		  (2) /* Unused flag */
1443 1444
#define CIFS_INO_DELETE_PENDING		  (3) /* delete pending on server */
#define CIFS_INO_INVALID_MAPPING	  (4) /* pagecache is invalid */
1445
#define CIFS_INO_LOCK			  (5) /* lock bit for synchronization */
1446
#define CIFS_INO_MODIFIED_ATTR            (6) /* Indicate change in mtime/ctime */
1447
#define CIFS_INO_CLOSE_ON_LOCK            (7) /* Not to defer the close when lock is set */
1448
	unsigned long flags;
1449 1450
	spinlock_t writers_lock;
	unsigned int writers;		/* Number of writers on this inode */
1451
	unsigned long time;		/* jiffies of last update of inode */
1452
	u64  server_eof;		/* current file size on server -- protected by i_lock */
1453
	u64  uniqueid;			/* server inode number */
1454
	u64  createtime;		/* creation time on server */
1455
	__u8 lease_key[SMB2_LEASE_KEY_SIZE];	/* lease key for this inode */
1456 1457 1458
#ifdef CONFIG_CIFS_FSCACHE
	struct fscache_cookie *fscache;
#endif
L
Linus Torvalds 已提交
1459
	struct inode vfs_inode;
1460 1461
	struct list_head deferred_closes; /* list of deferred closes */
	spinlock_t deferred_lock; /* protection on deferred list */
1462
	bool lease_granted; /* Flag to indicate whether lease or oplock is granted. */
L
Linus Torvalds 已提交
1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476
};

static inline struct cifsInodeInfo *
CIFS_I(struct inode *inode)
{
	return container_of(inode, struct cifsInodeInfo, vfs_inode);
}

static inline struct cifs_sb_info *
CIFS_SB(struct super_block *sb)
{
	return sb->s_fs_info;
}

1477 1478 1479 1480 1481 1482
static inline struct cifs_sb_info *
CIFS_FILE_SB(struct file *file)
{
	return CIFS_SB(file_inode(file)->i_sb);
}

1483
static inline char CIFS_DIR_SEP(const struct cifs_sb_info *cifs_sb)
1484 1485 1486 1487 1488 1489
{
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
		return '/';
	else
		return '\\';
}
L
Linus Torvalds 已提交
1490

1491 1492 1493
static inline void
convert_delimiter(char *path, char delim)
{
1494
	char old_delim, *pos;
1495 1496 1497 1498 1499 1500

	if (delim == '/')
		old_delim = '\\';
	else
		old_delim = '/';

1501 1502 1503
	pos = path;
	while ((pos = strchr(pos, old_delim)))
		*pos = delim;
1504 1505
}

1506 1507
#define cifs_stats_inc atomic_inc

1508
static inline void cifs_stats_bytes_written(struct cifs_tcon *tcon,
1509 1510 1511 1512 1513 1514 1515 1516 1517
					    unsigned int bytes)
{
	if (bytes) {
		spin_lock(&tcon->stat_lock);
		tcon->bytes_written += bytes;
		spin_unlock(&tcon->stat_lock);
	}
}

1518
static inline void cifs_stats_bytes_read(struct cifs_tcon *tcon,
1519 1520 1521 1522 1523 1524 1525
					 unsigned int bytes)
{
	spin_lock(&tcon->stat_lock);
	tcon->bytes_read += bytes;
	spin_unlock(&tcon->stat_lock);
}

1526 1527

/*
1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545
 * This is the prototype for the mid receive function. This function is for
 * receiving the rest of the SMB frame, starting with the WordCount (which is
 * just after the MID in struct smb_hdr). Note:
 *
 * - This will be called by cifsd, with no locks held.
 * - The mid will still be on the pending_mid_q.
 * - mid->resp_buf will point to the current buffer.
 *
 * Returns zero on a successful receive, or an error. The receive state in
 * the TCP_Server_Info will also be updated.
 */
typedef int (mid_receive_t)(struct TCP_Server_Info *server,
			    struct mid_q_entry *mid);

/*
 * This is the prototype for the mid callback function. This is called once the
 * mid has been received off of the socket. When creating one, take special
 * care to avoid deadlocks. Things to bear in mind:
1546
 *
1547 1548
 * - it will be called by cifsd, with no locks held
 * - the mid will be removed from any lists
1549 1550 1551
 */
typedef void (mid_callback_t)(struct mid_q_entry *mid);

1552 1553 1554 1555 1556 1557 1558
/*
 * This is the protopyte for mid handle function. This is called once the mid
 * has been recognized after decryption of the message.
 */
typedef int (mid_handle_t)(struct TCP_Server_Info *server,
			    struct mid_q_entry *mid);

L
Linus Torvalds 已提交
1559 1560 1561
/* one of these for every pending CIFS request to the server */
struct mid_q_entry {
	struct list_head qhead;	/* mids waiting on reply from this server */
1562
	struct kref refcount;
1563
	struct TCP_Server_Info *server;	/* server corresponding to this mid */
1564
	__u64 mid;		/* multiplex id */
1565
	__u16 credits;		/* number of credits consumed by this mid */
1566
	__u16 credits_received;	/* number of credits from the response */
1567
	__u32 pid;		/* process id */
L
Linus Torvalds 已提交
1568
	__u32 sequence_number;  /* for CIFS signing */
1569 1570 1571 1572 1573
	unsigned long when_alloc;  /* when mid was created */
#ifdef CONFIG_CIFS_STATS2
	unsigned long when_sent; /* time when smb send finished */
	unsigned long when_received; /* when demux complete (taken off wire) */
#endif
1574
	mid_receive_t *receive; /* call receive callback */
1575
	mid_callback_t *callback; /* call completion callback */
1576
	mid_handle_t *handle; /* call handle mid callback */
1577
	void *callback_data;	  /* general purpose pointer for callback */
1578
	struct task_struct *creator;
1579
	void *resp_buf;		/* pointer to received SMB header */
1580
	unsigned int resp_buf_size;
1581
	int mid_state;	/* wish this were enum but can not pass to wait_event */
1582
	unsigned int mid_flags;
1583
	__le16 command;		/* smb command code */
1584
	unsigned int optype;	/* operation type */
1585
	bool large_buf:1;	/* if valid response, is pointer to large buf */
1586 1587
	bool multiRsp:1;	/* multiple trans2 responses for one request  */
	bool multiEnd:1;	/* both received */
1588
	bool decrypted:1;	/* decrypted entry */
L
Linus Torvalds 已提交
1589 1590
};

1591 1592 1593 1594
struct close_cancelled_open {
	struct cifs_fid         fid;
	struct cifs_tcon        *tcon;
	struct work_struct      work;
1595 1596
	__u64 mid;
	__u16 cmd;
1597 1598
};

1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620
/*	Make code in transport.c a little cleaner by moving
	update of optional stats into function below */
static inline void cifs_in_send_inc(struct TCP_Server_Info *server)
{
	atomic_inc(&server->in_send);
}

static inline void cifs_in_send_dec(struct TCP_Server_Info *server)
{
	atomic_dec(&server->in_send);
}

static inline void cifs_num_waiters_inc(struct TCP_Server_Info *server)
{
	atomic_inc(&server->num_waiters);
}

static inline void cifs_num_waiters_dec(struct TCP_Server_Info *server)
{
	atomic_dec(&server->num_waiters);
}

1621
#ifdef CONFIG_CIFS_STATS2
1622 1623 1624 1625 1626 1627 1628 1629 1630
static inline void cifs_save_when_sent(struct mid_q_entry *mid)
{
	mid->when_sent = jiffies;
}
#else
static inline void cifs_save_when_sent(struct mid_q_entry *mid)
{
}
#endif
L
Linus Torvalds 已提交
1631

1632 1633
/* for pending dnotify requests */
struct dir_notify_req {
1634 1635 1636 1637 1638 1639 1640 1641 1642 1643
	struct list_head lhead;
	__le16 Pid;
	__le16 PidHigh;
	__u16 Mid;
	__u16 Tid;
	__u16 Uid;
	__u16 netfid;
	__u32 filter; /* CompletionFilter (for multishot) */
	int multishot;
	struct file *pfile;
1644 1645
};

S
Steve French 已提交
1646 1647
struct dfs_info3_param {
	int flags; /* DFSREF_REFERRAL_SERVER, DFSREF_STORAGE_SERVER*/
1648
	int path_consumed;
S
Steve French 已提交
1649 1650 1651 1652
	int server_type;
	int ref_flag;
	char *path_name;
	char *node_name;
1653
	int ttl;
S
Steve French 已提交
1654 1655
};

1656 1657 1658 1659 1660
struct file_list {
	struct list_head list;
	struct cifsFileInfo *cfile;
};

1661 1662 1663 1664 1665 1666
/*
 * common struct for holding inode info when searching for or updating an
 * inode with new info
 */

#define CIFS_FATTR_DFS_REFERRAL		0x1
1667 1668
#define CIFS_FATTR_DELETE_PENDING	0x2
#define CIFS_FATTR_NEED_REVAL		0x4
1669
#define CIFS_FATTR_INO_COLLISION	0x8
1670
#define CIFS_FATTR_UNKNOWN_NLINK	0x10
1671
#define CIFS_FATTR_FAKE_ROOT_INO	0x20
1672 1673 1674 1675 1676 1677 1678

struct cifs_fattr {
	u32		cf_flags;
	u32		cf_cifsattrs;
	u64		cf_uniqueid;
	u64		cf_eof;
	u64		cf_bytes;
1679
	u64		cf_createtime;
1680 1681
	kuid_t		cf_uid;
	kgid_t		cf_gid;
1682 1683 1684 1685
	umode_t		cf_mode;
	dev_t		cf_rdev;
	unsigned int	cf_nlink;
	unsigned int	cf_dtype;
1686 1687 1688
	struct timespec64 cf_atime;
	struct timespec64 cf_mtime;
	struct timespec64 cf_ctime;
1689
	u32             cf_cifstag;
1690 1691
};

S
Steve French 已提交
1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712
static inline void free_dfs_info_param(struct dfs_info3_param *param)
{
	if (param) {
		kfree(param->path_name);
		kfree(param->node_name);
	}
}

static inline void free_dfs_info_array(struct dfs_info3_param *param,
				       int number_of_items)
{
	int i;
	if ((number_of_items == 0) || (param == NULL))
		return;
	for (i = 0; i < number_of_items; i++) {
		kfree(param[i].path_name);
		kfree(param[i].node_name);
	}
	kfree(param);
}

1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731
static inline bool is_interrupt_error(int error)
{
	switch (error) {
	case -EINTR:
	case -ERESTARTSYS:
	case -ERESTARTNOHAND:
	case -ERESTARTNOINTR:
		return true;
	}
	return false;
}

static inline bool is_retryable_error(int error)
{
	if (is_interrupt_error(error) || error == -EAGAIN)
		return true;
	return false;
}

1732 1733 1734 1735 1736 1737

/* cifs_get_writable_file() flags */
#define FIND_WR_ANY         0
#define FIND_WR_FSUID_ONLY  1
#define FIND_WR_WITH_DELETE 2

L
Linus Torvalds 已提交
1738 1739 1740 1741 1742
#define   MID_FREE 0
#define   MID_REQUEST_ALLOCATED 1
#define   MID_REQUEST_SUBMITTED 2
#define   MID_RESPONSE_RECEIVED 4
#define   MID_RETRY_NEEDED      8 /* session closed while this request out */
1743
#define   MID_RESPONSE_MALFORMED 0x10
1744
#define   MID_SHUTDOWN		 0x20
1745

1746 1747
/* Flags */
#define   MID_WAIT_CANCELLED	 1 /* Cancelled while waiting for response */
1748
#define   MID_DELETED            2 /* Mid has been dequeued/deleted */
1749

1750 1751 1752 1753 1754
/* Types of response buffer returned from SendReceive2 */
#define   CIFS_NO_BUFFER        0    /* Response buffer not returned */
#define   CIFS_SMALL_BUFFER     1
#define   CIFS_LARGE_BUFFER     2
#define   CIFS_IOVEC            4    /* array of response buffers */
L
Linus Torvalds 已提交
1755

1756
/* Type of Request to SendReceive2 */
1757
#define   CIFS_BLOCKING_OP      1    /* operation can block */
1758
#define   CIFS_NON_BLOCKING     2    /* do not block waiting for credits */
1759
#define   CIFS_TIMEOUT_MASK 0x003    /* only one of above set in req */
1760 1761
#define   CIFS_LOG_ERROR    0x010    /* log NT STATUS if non-zero */
#define   CIFS_LARGE_BUF_OP 0x020    /* large request buffer */
1762
#define   CIFS_NO_RSP_BUF   0x040    /* no response buffer required */
1763

1764
/* Type of request operation */
1765 1766 1767 1768
#define   CIFS_ECHO_OP            0x080  /* echo request */
#define   CIFS_OBREAK_OP          0x0100 /* oplock break request */
#define   CIFS_NEG_OP             0x0200 /* negotiate request */
#define   CIFS_CP_CREATE_CLOSE_OP 0x0400 /* compound create+close request */
1769
/* Lower bitmask values are reserved by others below. */
1770 1771
#define   CIFS_SESS_OP            0x2000 /* session setup request */
#define   CIFS_OP_MASK            0x2780 /* mask request type */
1772

1773 1774 1775
#define   CIFS_HAS_CREDITS        0x0400 /* already has credits */
#define   CIFS_TRANSFORM_REQ      0x0800 /* transform request before sending */
#define   CIFS_NO_SRV_RSP         0x1000 /* there is no server response */
1776

1777 1778 1779 1780 1781
/* Security Flags: indicate type of session setup needed */
#define   CIFSSEC_MAY_SIGN	0x00001
#define   CIFSSEC_MAY_NTLMV2	0x00004
#define   CIFSSEC_MAY_KRB5	0x00008
#define   CIFSSEC_MAY_SEAL	0x00040 /* not supported yet */
1782
#define   CIFSSEC_MAY_NTLMSSP	0x00080 /* raw ntlmssp with ntlmv2 */
1783 1784 1785 1786 1787 1788 1789

#define   CIFSSEC_MUST_SIGN	0x01001
/* note that only one of the following can be set so the
result of setting MUST flags more than once will be to
require use of the stronger protocol */
#define   CIFSSEC_MUST_NTLMV2	0x04004
#define   CIFSSEC_MUST_KRB5	0x08008
1790
#ifdef CONFIG_CIFS_UPCALL
1791
#define   CIFSSEC_MASK          0x8F08F /* flags supported if no weak allowed */
S
Steve French 已提交
1792
#else
1793
#define	  CIFSSEC_MASK          0x87087 /* flags supported if no weak allowed */
1794
#endif /* UPCALL */
1795
#define   CIFSSEC_MUST_SEAL	0x40040 /* not supported yet */
1796
#define   CIFSSEC_MUST_NTLMSSP	0x80080 /* raw ntlmssp with ntlmv2 */
1797

1798
#define   CIFSSEC_DEF (CIFSSEC_MAY_SIGN | CIFSSEC_MAY_NTLMV2 | CIFSSEC_MAY_NTLMSSP)
1799 1800
#define   CIFSSEC_MAX (CIFSSEC_MUST_NTLMV2)
#define   CIFSSEC_AUTH_MASK (CIFSSEC_MAY_NTLMV2 | CIFSSEC_MAY_KRB5 | CIFSSEC_MAY_NTLMSSP)
L
Linus Torvalds 已提交
1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822
/*
 *****************************************************************
 * All constants go here
 *****************************************************************
 */

#define UID_HASH (16)

/*
 * Note that ONE module should define _DECLARE_GLOBALS_HERE to cause the
 * following to be declared.
 */

/****************************************************************************
 *  Locking notes.  All updates to global variables and lists should be
 *                  protected by spinlocks or semaphores.
 *
 *  Spinlocks
 *  ---------
 *  GlobalMid_Lock protects:
 *	list operations on pending_mid_q and oplockQ
 *      updates to XID counters, multiplex id  and SMB sequence numbers
1823
 *      list operations on global DnotifyReqList
1824
 *      updates to ses->status and TCP_Server_Info->tcpStatus
1825
 *      updates to server->CurrentMid
1826 1827 1828
 *  tcp_ses_lock protects:
 *	list operations on tcp and SMB session lists
 *  tcon->open_file_lock protects the list of open files hanging off the tcon
1829
 *  inode->open_file_lock protects the openFileList hanging off the inode
1830
 *  cfile->file_info_lock protects counters and fields in cifs file struct
L
Linus Torvalds 已提交
1831 1832 1833
 *  f_owner.lock protects certain per file struct operations
 *  mapping->page_lock protects certain per page operations
 *
1834 1835 1836
 *  Note that the cifs_tcon.open_file_lock should be taken before
 *  not after the cifsInodeInfo.open_file_lock
 *
L
Linus Torvalds 已提交
1837 1838
 *  Semaphores
 *  ----------
1839 1840
 *  cifsInodeInfo->lock_sem protects:
 *	the list of locks held by the inode
L
Linus Torvalds 已提交
1841 1842 1843 1844 1845 1846 1847 1848 1849
 *
 ****************************************************************************/

#ifdef DECLARE_GLOBALS_HERE
#define GLOBAL_EXTERN
#else
#define GLOBAL_EXTERN extern
#endif

1850 1851
/*
 * the list of TCP_Server_Info structures, ie each of the sockets
1852
 * connecting our client to a distinct server (ip address), is
1853
 * chained together by cifs_tcp_ses_list. The list of all our SMB
1854
 * sessions (and from that the tree connections) can be found
1855 1856 1857 1858
 * by iterating over cifs_tcp_ses_list
 */
GLOBAL_EXTERN struct list_head		cifs_tcp_ses_list;

1859 1860 1861
/*
 * This lock protects the cifs_tcp_ses_list, the list of smb sessions per
 * tcp session, and the list of tcon's per smb session. It also protects
1862 1863
 * the reference counters for the server, smb session, and tcon. It also
 * protects some fields in the TCP_Server_Info struct such as dstaddr. Finally,
1864
 * changes to the tcon->tidStatus should be done while holding this lock.
1865 1866 1867
 * generally the locks should be taken in order tcp_ses_lock before
 * tcon->open_file_lock and that before file->file_info_lock since the
 * structure order is cifs_socket-->cifs_ses-->cifs_tcon-->cifs_file
1868
 */
1869
GLOBAL_EXTERN spinlock_t		cifs_tcp_ses_lock;
1870

L
Linus Torvalds 已提交
1871 1872 1873 1874
/*
 * Global transaction id (XID) information
 */
GLOBAL_EXTERN unsigned int GlobalCurrentXid;	/* protected by GlobalMid_Sem */
1875
GLOBAL_EXTERN unsigned int GlobalTotalActiveXid; /* prot by GlobalMid_Sem */
L
Linus Torvalds 已提交
1876
GLOBAL_EXTERN unsigned int GlobalMaxActiveXid;	/* prot by GlobalMid_Sem */
1877 1878
GLOBAL_EXTERN spinlock_t GlobalMid_Lock;  /* protects above & list operations */
					  /* on midQ entries */
L
Linus Torvalds 已提交
1879 1880 1881 1882 1883
/*
 *  Global counters, updated atomically
 */
GLOBAL_EXTERN atomic_t sesInfoAllocCount;
GLOBAL_EXTERN atomic_t tconInfoAllocCount;
1884
GLOBAL_EXTERN atomic_t tcpSesNextId;
L
Linus Torvalds 已提交
1885 1886 1887 1888
GLOBAL_EXTERN atomic_t tcpSesAllocCount;
GLOBAL_EXTERN atomic_t tcpSesReconnectCount;
GLOBAL_EXTERN atomic_t tconInfoReconnectCount;

1889
/* Various Debug counters */
1890 1891 1892 1893
GLOBAL_EXTERN atomic_t bufAllocCount;    /* current number allocated  */
#ifdef CONFIG_CIFS_STATS2
GLOBAL_EXTERN atomic_t totBufAllocCount; /* total allocated over all time */
GLOBAL_EXTERN atomic_t totSmBufAllocCount;
1894
extern unsigned int slow_rsp_threshold; /* number of secs before logging */
1895 1896
#endif
GLOBAL_EXTERN atomic_t smBufAllocCount;
L
Linus Torvalds 已提交
1897 1898 1899
GLOBAL_EXTERN atomic_t midCount;

/* Misc globals */
1900 1901 1902
extern bool enable_oplocks; /* enable or disable oplocks */
extern bool lookupCacheEnabled;
extern unsigned int global_secflags;	/* if on, session setup sent
L
Linus Torvalds 已提交
1903
				with more secure ntlmssp2 challenge/resp */
1904
extern unsigned int sign_CIFS_PDUs;  /* enable smb packet signing */
1905
extern bool enable_gcm_256; /* allow optional negotiate of strongest signing (aes-gcm-256) */
1906
extern bool require_gcm_256; /* require use of strongest signing (aes-gcm-256) */
1907
extern bool enable_negotiate_signing; /* request use of faster (GMAC) signing if available */
1908 1909 1910 1911 1912 1913
extern bool linuxExtEnabled;/*enable Linux/Unix CIFS extensions*/
extern unsigned int CIFSMaxBufSize;  /* max size not including hdr */
extern unsigned int cifs_min_rcv;    /* min size of big ntwrk buf pool */
extern unsigned int cifs_min_small;  /* min size of small buf pool */
extern unsigned int cifs_max_pending; /* MAX requests at once to server*/
extern bool disable_legacy_dialects;  /* forbid vers=1.0 and vers=2.0 mounts */
L
Linus Torvalds 已提交
1914

1915
void cifs_oplock_break(struct work_struct *work);
1916
void cifs_queue_oplock_break(struct cifsFileInfo *cfile);
1917
void smb2_deferred_work_close(struct work_struct *work);
1918

1919
extern const struct slow_work_ops cifs_oplock_break_ops;
1920
extern struct workqueue_struct *cifsiod_wq;
1921
extern struct workqueue_struct *decrypt_wq;
1922
extern struct workqueue_struct *fileinfo_put_wq;
1923
extern struct workqueue_struct *cifsoplockd_wq;
1924
extern struct workqueue_struct *deferredclose_wq;
1925
extern __u32 cifs_lock_secret;
1926

1927 1928
extern mempool_t *cifs_mid_poolp;

1929 1930 1931 1932
/* Operations for different SMB versions */
#define SMB1_VERSION_STRING	"1.0"
extern struct smb_version_operations smb1_operations;
extern struct smb_version_values smb1_values;
1933
#define SMB20_VERSION_STRING	"2.0"
1934
extern struct smb_version_operations smb20_operations;
1935
extern struct smb_version_values smb20_values;
1936 1937 1938
#define SMB21_VERSION_STRING	"2.1"
extern struct smb_version_operations smb21_operations;
extern struct smb_version_values smb21_values;
1939 1940 1941 1942
#define SMBDEFAULT_VERSION_STRING "default"
extern struct smb_version_values smbdefault_values;
#define SMB3ANY_VERSION_STRING "3"
extern struct smb_version_values smb3any_values;
1943
#define SMB30_VERSION_STRING	"3.0"
1944
extern struct smb_version_operations smb30_operations;
1945
extern struct smb_version_values smb30_values;
1946
#define SMB302_VERSION_STRING	"3.02"
1947
#define ALT_SMB302_VERSION_STRING "3.0.2"
1948 1949
/*extern struct smb_version_operations smb302_operations;*/ /* not needed yet */
extern struct smb_version_values smb302_values;
1950
#define SMB311_VERSION_STRING	"3.1.1"
1951 1952
#define ALT_SMB311_VERSION_STRING "3.11"
extern struct smb_version_operations smb311_operations;
1953
extern struct smb_version_values smb311_values;
1954

1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968
static inline char *get_security_type_str(enum securityEnum sectype)
{
	switch (sectype) {
	case RawNTLMSSP:
		return "RawNTLMSSP";
	case Kerberos:
		return "Kerberos";
	case NTLMv2:
		return "NTLMv2";
	default:
		return "Unknown";
	}
}

1969 1970 1971 1972 1973
static inline bool is_smb1_server(struct TCP_Server_Info *server)
{
	return strcmp(server->vals->version_string, SMB1_VERSION_STRING) == 0;
}

1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988
static inline bool is_tcon_dfs(struct cifs_tcon *tcon)
{
	/*
	 * For SMB1, see MS-CIFS 2.4.55 SMB_COM_TREE_CONNECT_ANDX (0x75) and MS-CIFS 3.3.4.4 DFS
	 * Subsystem Notifies That a Share Is a DFS Share.
	 *
	 * For SMB2+, see MS-SMB2 2.2.10 SMB2 TREE_CONNECT Response and MS-SMB2 3.3.4.14 Server
	 * Application Updates a Share.
	 */
	if (!tcon || !tcon->ses || !tcon->ses->server)
		return false;
	return is_smb1_server(tcon->ses->server) ? tcon->Flags & SMB_SHARE_IS_IN_DFS :
		tcon->share_flags & (SHI1005_FLAGS_DFS | SHI1005_FLAGS_DFS_ROOT);
}

1989 1990 1991 1992 1993 1994 1995 1996 1997 1998
static inline bool cifs_is_referral_server(struct cifs_tcon *tcon,
					   const struct dfs_info3_param *ref)
{
	/*
	 * Check if all targets are capable of handling DFS referrals as per
	 * MS-DFSC 2.2.4 RESP_GET_DFS_REFERRAL.
	 */
	return is_tcon_dfs(tcon) || (ref && (ref->flags & DFSREF_REFERRAL_SERVER));
}

1999
#endif	/* _CIFS_GLOB_H */