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