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