blob: 4ba35faff79c44f91a628208f10558d0527eb98d [file] [log] [blame]
Steve French929be902021-06-18 00:31:49 -05001/* SPDX-License-Identifier: LGPL-2.1 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
Steve French366781c2008-01-25 10:12:41 +00004 * Copyright (C) International Business Machines Corp., 2002,2008
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * Author(s): Steve French (sfrench@us.ibm.com)
Jeremy Allison7ee1af72006-08-02 21:56:33 +00006 * Jeremy Allison (jra@samba.org)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 */
Suresh Jayaramanabd2e442010-06-22 20:52:50 +05309#ifndef _CIFS_GLOB_H
10#define _CIFS_GLOB_H
11
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/in.h>
13#include <linux/in6.h>
Steve Frenchb438fcf2021-02-20 19:24:11 -060014#include <linux/inet.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090015#include <linux/slab.h>
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +040016#include <linux/mempool.h>
Tejun Heo9b646972010-07-20 22:09:02 +020017#include <linux/workqueue.h>
Shyam Prasad N49bd49f2021-11-05 19:03:57 +000018#include <linux/utsname.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include "cifs_fs_sb.h"
Steve French442aa312007-09-24 20:25:46 +000020#include "cifsacl.h"
Shirish Pargaonkard2b91522010-10-21 14:25:08 -050021#include <crypto/internal/hash.h>
22#include <linux/scatterlist.h>
Scott Lovenberg8c3a2b42013-08-09 08:47:17 -040023#include <uapi/linux/cifs/cifs_mount.h>
Ronnie Sahlberg0d35e382021-11-05 08:39:01 +090024#include "../smbfs_common/smb2pdu.h"
Pavel Shilovskyd60622e2012-05-28 15:19:39 +040025#include "smb2pdu.h"
Shirish Pargaonkard2b91522010-10-21 14:25:08 -050026
Pavel Shilovsky76ec5e32012-09-18 16:20:33 -070027#define CIFS_MAGIC_NUMBER 0xFF534D42 /* the first four bytes of SMB PDUs */
28
Ronnie Sahlberg8d8b26e2018-10-17 05:47:58 +100029#define SMB_PATH_MAX 260
Aurelien Aptele2292432018-06-14 15:43:16 +020030#define CIFS_PORT 445
31#define RFC1001_PORT 139
32
Linus Torvalds1da177e2005-04-16 15:20:36 -070033/*
34 * The sizes of various internal tables and strings
35 */
36#define MAX_UID_INFO 16
37#define MAX_SES_INFO 2
38#define MAX_TCON_INFO 4
39
Scott Lovenbergcdf12462013-08-09 08:47:19 -040040#define MAX_TREE_SIZE (2 + CIFS_NI_MAXHOST + 1 + CIFS_MAX_SHARE_LEN + 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
42#define CIFS_MIN_RCV_POOL 4
43
Shirish Pargaonkar2c0c2a02012-05-21 09:20:12 -050044#define MAX_REOPEN_ATT 5 /* these many maximum attempts to reopen a file */
Linus Torvalds1da177e2005-04-16 15:20:36 -070045/*
Suresh Jayaraman6d20e842010-12-01 14:42:28 +053046 * default attribute cache timeout (jiffies)
47 */
48#define CIFS_DEF_ACTIMEO (1 * HZ)
49
50/*
51 * max attribute cache timeout (jiffies) - 2^30
52 */
53#define CIFS_MAX_ACTIMEO (1 << 30)
54
55/*
Steve Frenchca567eb2019-03-29 16:31:07 -050056 * Max persistent and resilient handle timeout (milliseconds).
57 * Windows durable max was 960000 (16 minutes)
58 */
59#define SMB3_MAX_HANDLE_TIMEOUT 960000
60
61/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 * MAX_REQ is the maximum number of requests that WE will send
Pavel Shilovsky10b9b982012-03-20 12:55:09 +030063 * on one socket concurrently.
Linus Torvalds1da177e2005-04-16 15:20:36 -070064 */
Pavel Shilovsky10b9b982012-03-20 12:55:09 +030065#define CIFS_MAX_REQ 32767
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
Jeff Layton8ecaf672008-12-01 15:23:50 -050067#define RFC1001_NAME_LEN 15
68#define RFC1001_NAME_LEN_WITH_NULL (RFC1001_NAME_LEN + 1)
69
Aurelien Aptelb327a712018-01-24 13:46:10 +010070/* maximum length of ip addr as a string (including ipv6 and sctp) */
71#define SERVER_NAME_LENGTH 80
Linus Torvalds1da177e2005-04-16 15:20:36 -070072#define SERVER_NAME_LEN_WITH_NULL (SERVER_NAME_LENGTH + 1)
73
Steve Frenchadfeb3e2015-12-18 12:31:36 -060074/* echo interval in seconds */
75#define SMB_ECHO_INTERVAL_MIN 1
76#define SMB_ECHO_INTERVAL_MAX 600
77#define SMB_ECHO_INTERVAL_DEFAULT 60
Pavel Shilovsky9094fad2012-07-12 18:30:44 +040078
Paulo Alcantara4ac05362021-11-04 13:13:28 -030079/* dns resolution intervals in seconds */
80#define SMB_DNS_RESOLVE_INTERVAL_MIN 120
Shyam Prasad N506c1da2021-05-18 15:05:50 +000081#define SMB_DNS_RESOLVE_INTERVAL_DEFAULT 600
82
Ronnie Sahlbergb24df3e2018-08-08 15:07:45 +100083/* maximum number of PDUs in one compound */
84#define MAX_COMPOUND 5
85
Steve French141891f2016-09-23 00:44:16 -050086/*
87 * Default number of credits to keep available for SMB3.
88 * This value is chosen somewhat arbitrarily. The Windows client
89 * defaults to 128 credits, the Windows server allows clients up to
90 * 512 credits (or 8K for later versions), and the NetApp server
91 * does not limit clients at all. Choose a high enough default value
92 * such that the client shouldn't limit performance, but allow mount
93 * to override (until you approach 64K, where we limit credits to 65000
94 * to reduce possibility of seeing more server credit overflow bugs.
95 */
96#define SMB2_MAX_CREDITS_AVAILABLE 32000
97
Linus Torvalds1da177e2005-04-16 15:20:36 -070098#include "cifspdu.h"
99
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100#ifndef XATTR_DOS_ATTRIB
101#define XATTR_DOS_ATTRIB "user.DOSATTRIB"
102#endif
103
Shyam Prasad N49bd49f2021-11-05 19:03:57 +0000104#define CIFS_MAX_WORKSTATION_LEN (__NEW_UTS_LEN + 1) /* reasonable max for client */
105
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 * CIFS vfs client Status information (based on what we know.)
108 */
109
Steve French6c0f6212010-10-23 16:51:40 +0000110/* associated with each tcp and smb session */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111enum statusEnum {
112 CifsNew = 0,
113 CifsGood,
114 CifsExiting,
Steve Frenchfd88ce92011-04-12 01:01:14 +0000115 CifsNeedReconnect,
116 CifsNeedNegotiate
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117};
118
119enum securityEnum {
Jeff Layton515d82f2013-05-26 07:00:58 -0400120 Unspecified = 0, /* not specified */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 NTLMv2, /* Legacy NTLM auth with NTLMv2 hash */
Steve Frenchac683922009-05-06 04:16:04 +0000122 RawNTLMSSP, /* NTLMSSP without SPNEGO, NTLMv2 hash */
Steve Frenchc16fefa2008-08-19 19:35:33 +0000123 Kerberos, /* Kerberos via SPNEGO */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124};
125
Shirish Pargaonkar5f98ca92010-09-18 22:01:58 -0500126struct session_key {
Steve Frenchb609f062007-07-09 07:55:14 +0000127 unsigned int len;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500128 char *response;
Steve Frenchb609f062007-07-09 07:55:14 +0000129};
130
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500131/* crypto security descriptor definition */
132struct sdesc {
133 struct shash_desc shash;
134 char ctx[];
135};
136
Shirish Pargaonkarf7c5445a2010-10-26 18:10:24 -0500137/* crypto hashing related structure/fields, not specific to a sec mech */
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500138struct cifs_secmech {
139 struct crypto_shash *hmacmd5; /* hmac-md5 hash function */
140 struct crypto_shash *md5; /* md5 hash function */
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700141 struct crypto_shash *hmacsha256; /* hmac-sha256 hash function */
Steve French429b46f2013-06-26 23:45:05 -0500142 struct crypto_shash *cmacaes; /* block-cipher based MAC function */
Aurelien Aptel5fcd7f32018-02-16 19:19:28 +0100143 struct crypto_shash *sha512; /* sha512 hash function */
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500144 struct sdesc *sdeschmacmd5; /* ctxt to generate ntlmv2 hash, CR1 */
145 struct sdesc *sdescmd5; /* ctxt to generate cifs/smb signature */
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700146 struct sdesc *sdeschmacsha256; /* ctxt to generate smb2 signature */
Steve French429b46f2013-06-26 23:45:05 -0500147 struct sdesc *sdesccmacaes; /* ctxt to generate smb3 signature */
Aurelien Aptel5fcd7f32018-02-16 19:19:28 +0100148 struct sdesc *sdescsha512; /* ctxt to generate smb3.11 signing key */
Pavel Shilovsky026e93d2016-11-03 16:47:37 -0700149 struct crypto_aead *ccmaesencrypt; /* smb3 encryption aead */
150 struct crypto_aead *ccmaesdecrypt; /* smb3 decryption aead */
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500151};
152
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500153/* per smb session structure/fields */
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500154struct ntlmssp_auth {
Shirish Pargaonkar5c234aa2013-08-29 08:35:10 -0500155 bool sesskey_per_smbsess; /* whether session key is per smb session */
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500156 __u32 client_flags; /* sent by client in type 1 ntlmsssp exchange */
157 __u32 server_flags; /* sent by server in type 2 ntlmssp exchange */
158 unsigned char ciphertext[CIFS_CPHTXT_SIZE]; /* sent to server */
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500159 char cryptkey[CIFS_CRYPTO_KEY_SIZE]; /* used by ntlmssp */
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500160};
161
Steve French442aa312007-09-24 20:25:46 +0000162struct cifs_cred {
163 int uid;
164 int gid;
165 int mode;
166 int cecount;
167 struct cifs_sid osid;
168 struct cifs_sid gsid;
169 struct cifs_ntace *ntaces;
170 struct cifs_ace *aces;
171};
172
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173/*
174 *****************************************************************
175 * Except the CIFS PDUs themselves all the
176 * globally interesting structs should go here
177 *****************************************************************
178 */
179
Jeff Laytonbf5ea0e2012-09-18 16:20:34 -0700180/*
181 * A smb_rqst represents a complete request to be issued to a server. It's
182 * formed by a kvec array, followed by an array of pages. Page data is assumed
183 * to start at the beginning of the first page.
184 */
185struct smb_rqst {
186 struct kvec *rq_iov; /* array of kvecs */
187 unsigned int rq_nvec; /* number of kvecs in array */
188 struct page **rq_pages; /* pointer to array of page ptrs */
Long Li57a929a2018-05-30 12:47:53 -0700189 unsigned int rq_offset; /* the offset to the 1st page */
Jeff Laytonbf5ea0e2012-09-18 16:20:34 -0700190 unsigned int rq_npages; /* number pages in array */
191 unsigned int rq_pagesz; /* page size to use */
192 unsigned int rq_tailsz; /* length of last page */
193};
194
Jeff Layton121b0462012-05-15 12:21:10 -0400195struct mid_q_entry;
196struct TCP_Server_Info;
Pavel Shilovsky55157df2012-02-28 14:04:17 +0300197struct cifsFileInfo;
Pavel Shilovsky082d0642012-05-17 12:18:21 +0400198struct cifs_ses;
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +0400199struct cifs_tcon;
Pavel Shilovskyb669f332012-05-27 20:21:53 +0400200struct dfs_info3_param;
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400201struct cifs_fattr;
Ronnie Sahlberg3fa1c6d2020-12-09 23:07:12 -0600202struct smb3_fs_context;
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700203struct cifs_fid;
Pavel Shilovskyfc9c5962012-09-18 16:20:28 -0700204struct cifs_readdata;
Pavel Shilovskyc9de5c82012-09-18 16:20:29 -0700205struct cifs_writedata;
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -0700206struct cifs_io_parms;
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700207struct cifs_search_info;
Pavel Shilovsky95a3f2f2012-09-18 16:20:33 -0700208struct cifsInodeInfo;
Pavel Shilovsky226730b2013-07-05 12:00:30 +0400209struct cifs_open_parms;
Pavel Shilovsky335b7b62019-01-16 11:12:41 -0800210struct cifs_credits;
Jeff Layton121b0462012-05-15 12:21:10 -0400211
Jeff Layton23db65f2012-05-15 12:20:51 -0400212struct smb_version_operations {
Pavel Shilovskyfb2036d2016-11-23 15:08:14 -0800213 int (*send_cancel)(struct TCP_Server_Info *, struct smb_rqst *,
Jeff Layton121b0462012-05-15 12:21:10 -0400214 struct mid_q_entry *);
Pavel Shilovsky55157df2012-02-28 14:04:17 +0300215 bool (*compare_fids)(struct cifsFileInfo *, struct cifsFileInfo *);
Pavel Shilovsky082d0642012-05-17 12:18:21 +0400216 /* setup request: allocate mid, sign message */
Jeff Laytonfec344e2012-09-18 16:20:35 -0700217 struct mid_q_entry *(*setup_request)(struct cifs_ses *,
Aurelien Aptelf780bd32019-09-20 06:08:34 +0200218 struct TCP_Server_Info *,
219 struct smb_rqst *);
Pavel Shilovsky45740842012-06-01 14:26:18 +0400220 /* setup async request: allocate mid, sign message */
Jeff Laytonfec344e2012-09-18 16:20:35 -0700221 struct mid_q_entry *(*setup_async_request)(struct TCP_Server_Info *,
222 struct smb_rqst *);
Pavel Shilovsky082d0642012-05-17 12:18:21 +0400223 /* check response: verify signature, map error */
224 int (*check_receive)(struct mid_q_entry *, struct TCP_Server_Info *,
225 bool);
Pavel Shilovsky335b7b62019-01-16 11:12:41 -0800226 void (*add_credits)(struct TCP_Server_Info *server,
227 const struct cifs_credits *credits,
228 const int optype);
Pavel Shilovsky45275782012-05-17 17:53:29 +0400229 void (*set_credits)(struct TCP_Server_Info *, const int);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400230 int * (*get_credits_field)(struct TCP_Server_Info *, const int);
231 unsigned int (*get_credits)(struct mid_q_entry *);
Pavel Shilovsky88257362012-05-23 14:01:59 +0400232 __u64 (*get_next_mid)(struct TCP_Server_Info *);
Pavel Shilovskyc781af72019-03-04 14:02:50 -0800233 void (*revert_current_mid)(struct TCP_Server_Info *server,
234 const unsigned int val);
Pavel Shilovskyeb378712012-05-17 13:02:51 +0400235 /* data offset from read response message */
236 unsigned int (*read_data_offset)(char *);
Long Li74dcf412017-11-22 17:38:46 -0700237 /*
238 * Data length from read response message
239 * When in_remaining is true, the returned data length is in
240 * message field DataRemaining for out-of-band data read (e.g through
241 * Memory Registration RDMA write in SMBD).
242 * Otherwise, the returned data length is in message field DataLength.
243 */
244 unsigned int (*read_data_length)(char *, bool in_remaining);
Pavel Shilovskyeb378712012-05-17 13:02:51 +0400245 /* map smb to linux error */
246 int (*map_error)(char *, bool);
Pavel Shilovsky8aa26f32012-05-17 13:25:35 +0400247 /* find mid corresponding to the response message */
248 struct mid_q_entry * (*find_mid)(struct TCP_Server_Info *, char *);
Ronnie Sahlberg14547f72018-04-22 14:45:53 -0600249 void (*dump_detail)(void *buf, struct TCP_Server_Info *ptcp_info);
Pavel Shilovsky44c58182012-05-28 14:16:31 +0400250 void (*clear_stats)(struct cifs_tcon *);
251 void (*print_stats)(struct seq_file *m, struct cifs_tcon *);
Steve French769ee6a2013-06-19 14:15:30 -0500252 void (*dump_share_caps)(struct seq_file *, struct cifs_tcon *);
Pavel Shilovsky8aa26f32012-05-17 13:25:35 +0400253 /* verify the message */
Steve French373512e2015-12-18 13:05:30 -0600254 int (*check_message)(char *, unsigned int, struct TCP_Server_Info *);
Pavel Shilovsky8aa26f32012-05-17 13:25:35 +0400255 bool (*is_oplock_break)(char *, struct TCP_Server_Info *);
Paulo Alcantara04ad69c2021-03-08 12:00:50 -0300256 int (*handle_cancelled_mid)(struct mid_q_entry *, struct TCP_Server_Info *);
Pavel Shilovsky9bd45402019-10-29 16:51:19 -0700257 void (*downgrade_oplock)(struct TCP_Server_Info *server,
258 struct cifsInodeInfo *cinode, __u32 oplock,
259 unsigned int epoch, bool *purge_cache);
Pavel Shilovsky316cf942012-05-23 14:31:03 +0400260 /* process transaction2 response */
261 bool (*check_trans2)(struct mid_q_entry *, struct TCP_Server_Info *,
262 char *, int);
Pavel Shilovsky286170a2012-05-25 10:43:58 +0400263 /* check if we need to negotiate */
264 bool (*need_neg)(struct TCP_Server_Info *);
265 /* negotiate to the server */
Shyam Prasad Nf486ef82021-07-19 13:54:16 +0000266 int (*negotiate)(const unsigned int xid,
267 struct cifs_ses *ses,
268 struct TCP_Server_Info *server);
Pavel Shilovsky24985c52012-09-18 16:20:28 -0700269 /* set negotiated write size */
Ronnie Sahlberg3fa1c6d2020-12-09 23:07:12 -0600270 unsigned int (*negotiate_wsize)(struct cifs_tcon *tcon, struct smb3_fs_context *ctx);
Pavel Shilovsky24985c52012-09-18 16:20:28 -0700271 /* set negotiated read size */
Ronnie Sahlberg3fa1c6d2020-12-09 23:07:12 -0600272 unsigned int (*negotiate_rsize)(struct cifs_tcon *tcon, struct smb3_fs_context *ctx);
Pavel Shilovsky58c45c52012-05-25 10:54:49 +0400273 /* setup smb sessionn */
274 int (*sess_setup)(const unsigned int, struct cifs_ses *,
Shyam Prasad Nf486ef82021-07-19 13:54:16 +0000275 struct TCP_Server_Info *server,
Pavel Shilovsky58c45c52012-05-25 10:54:49 +0400276 const struct nls_table *);
277 /* close smb session */
278 int (*logoff)(const unsigned int, struct cifs_ses *);
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +0400279 /* connect to a server share */
280 int (*tree_connect)(const unsigned int, struct cifs_ses *, const char *,
281 struct cifs_tcon *, const struct nls_table *);
282 /* close tree connecion */
283 int (*tree_disconnect)(const unsigned int, struct cifs_tcon *);
Pavel Shilovskyb669f332012-05-27 20:21:53 +0400284 /* get DFS referrals */
285 int (*get_dfs_refer)(const unsigned int, struct cifs_ses *,
286 const char *, struct dfs_info3_param **,
287 unsigned int *, const struct nls_table *, int);
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +0400288 /* informational QFS call */
Amir Goldstein0f060932020-02-03 21:46:43 +0200289 void (*qfs_tcon)(const unsigned int, struct cifs_tcon *,
290 struct cifs_sb_info *);
Pavel Shilovsky68889f22012-05-25 14:40:22 +0400291 /* check if a path is accessible or not */
292 int (*is_path_accessible)(const unsigned int, struct cifs_tcon *,
293 struct cifs_sb_info *, const char *);
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400294 /* query path data from the server */
295 int (*query_path_info)(const unsigned int, struct cifs_tcon *,
296 struct cifs_sb_info *, const char *,
Pavel Shilovskyeb85d94b2013-10-23 17:49:47 +0400297 FILE_ALL_INFO *, bool *, bool *);
Pavel Shilovsky4ad65042012-09-18 16:20:26 -0700298 /* query file data from the server */
299 int (*query_file_info)(const unsigned int, struct cifs_tcon *,
300 struct cifs_fid *, FILE_ALL_INFO *);
Steve French2e4564b2020-10-22 22:03:14 -0500301 /* query reparse tag from srv to determine which type of special file */
302 int (*query_reparse_tag)(const unsigned int xid, struct cifs_tcon *tcon,
303 struct cifs_sb_info *cifs_sb, const char *path,
304 __u32 *reparse_tag);
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400305 /* get server index number */
306 int (*get_srv_inum)(const unsigned int, struct cifs_tcon *,
307 struct cifs_sb_info *, const char *,
308 u64 *uniqueid, FILE_ALL_INFO *);
Pavel Shilovskyd1433412012-09-18 16:20:31 -0700309 /* set size by path */
310 int (*set_path_size)(const unsigned int, struct cifs_tcon *,
311 const char *, __u64, struct cifs_sb_info *, bool);
312 /* set size by file handle */
313 int (*set_file_size)(const unsigned int, struct cifs_tcon *,
314 struct cifsFileInfo *, __u64, bool);
Pavel Shilovsky6bdf6db2012-09-18 16:20:32 -0700315 /* set attributes */
316 int (*set_file_info)(struct inode *, const char *, FILE_BASIC_INFO *,
317 const unsigned int);
Steve French64a5cfa2013-10-14 15:31:32 -0500318 int (*set_compression)(const unsigned int, struct cifs_tcon *,
319 struct cifsFileInfo *);
Pavel Shilovskyf6d76172012-05-25 14:47:16 +0400320 /* check if we can send an echo or nor */
321 bool (*can_echo)(struct TCP_Server_Info *);
322 /* send echo request */
323 int (*echo)(struct TCP_Server_Info *);
Pavel Shilovskyf4367202012-03-17 11:41:12 +0300324 /* create directory */
Steve Frenchbea851b2018-06-14 21:56:32 -0500325 int (*posix_mkdir)(const unsigned int xid, struct inode *inode,
326 umode_t mode, struct cifs_tcon *tcon,
327 const char *full_path,
328 struct cifs_sb_info *cifs_sb);
Steve Frenchc3ca78e2019-09-25 00:32:13 -0500329 int (*mkdir)(const unsigned int xid, struct inode *inode, umode_t mode,
330 struct cifs_tcon *tcon, const char *name,
331 struct cifs_sb_info *sb);
Pavel Shilovskyf4367202012-03-17 11:41:12 +0300332 /* set info on created directory */
333 void (*mkdir_setinfo)(struct inode *, const char *,
334 struct cifs_sb_info *, struct cifs_tcon *,
335 const unsigned int);
Pavel Shilovskyf958ca52012-07-10 16:14:18 +0400336 /* remove directory */
337 int (*rmdir)(const unsigned int, struct cifs_tcon *, const char *,
338 struct cifs_sb_info *);
Pavel Shilovskyed6875e2012-09-18 16:20:25 -0700339 /* unlink file */
340 int (*unlink)(const unsigned int, struct cifs_tcon *, const char *,
341 struct cifs_sb_info *);
342 /* open, rename and delete file */
343 int (*rename_pending_delete)(const char *, struct dentry *,
344 const unsigned int);
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -0700345 /* send rename request */
346 int (*rename)(const unsigned int, struct cifs_tcon *, const char *,
347 const char *, struct cifs_sb_info *);
Steve Frenchd6e906f2012-09-18 16:20:31 -0700348 /* send create hardlink request */
349 int (*create_hardlink)(const unsigned int, struct cifs_tcon *,
350 const char *, const char *,
351 struct cifs_sb_info *);
Pavel Shilovskyb42bf882013-08-14 19:25:21 +0400352 /* query symlink target */
353 int (*query_symlink)(const unsigned int, struct cifs_tcon *,
Ronnie Sahlbergebaf5462019-04-10 08:44:46 +1000354 struct cifs_sb_info *, const char *,
355 char **, bool);
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700356 /* open a file for non-posix mounts */
Pavel Shilovsky226730b2013-07-05 12:00:30 +0400357 int (*open)(const unsigned int, struct cifs_open_parms *,
358 __u32 *, FILE_ALL_INFO *);
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700359 /* set fid protocol-specific info */
360 void (*set_fid)(struct cifsFileInfo *, struct cifs_fid *, __u32);
Pavel Shilovsky0ff78a22012-09-18 16:20:26 -0700361 /* close a file */
Pavel Shilovsky760ad0c2012-09-25 11:00:07 +0400362 void (*close)(const unsigned int, struct cifs_tcon *,
363 struct cifs_fid *);
Steve French43f8a6a2019-12-02 21:46:54 -0600364 /* close a file, returning file attributes and timestamps */
365 void (*close_getattr)(const unsigned int xid, struct cifs_tcon *tcon,
366 struct cifsFileInfo *pfile_info);
Pavel Shilovsky1d8c4c02012-09-18 16:20:27 -0700367 /* send a flush request to the server */
368 int (*flush)(const unsigned int, struct cifs_tcon *, struct cifs_fid *);
Pavel Shilovskyfc9c5962012-09-18 16:20:28 -0700369 /* async read from the server */
370 int (*async_readv)(struct cifs_readdata *);
Pavel Shilovskyc9de5c82012-09-18 16:20:29 -0700371 /* async write to the server */
Steve French4a5c80d2014-02-07 20:45:12 -0600372 int (*async_writev)(struct cifs_writedata *,
373 void (*release)(struct kref *));
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -0700374 /* sync read from the server */
Steve Frenchdb8b6312014-09-22 05:13:55 -0500375 int (*sync_read)(const unsigned int, struct cifs_fid *,
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -0700376 struct cifs_io_parms *, unsigned int *, char **,
377 int *);
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -0700378 /* sync write to the server */
Steve Frenchdb8b6312014-09-22 05:13:55 -0500379 int (*sync_write)(const unsigned int, struct cifs_fid *,
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -0700380 struct cifs_io_parms *, unsigned int *, struct kvec *,
381 unsigned long);
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700382 /* open dir, start readdir */
383 int (*query_dir_first)(const unsigned int, struct cifs_tcon *,
384 const char *, struct cifs_sb_info *,
385 struct cifs_fid *, __u16,
386 struct cifs_search_info *);
387 /* continue readdir */
388 int (*query_dir_next)(const unsigned int, struct cifs_tcon *,
389 struct cifs_fid *,
390 __u16, struct cifs_search_info *srch_inf);
391 /* close dir */
392 int (*close_dir)(const unsigned int, struct cifs_tcon *,
393 struct cifs_fid *);
394 /* calculate a size of SMB message */
Ronnie Sahlberg9ec672b2018-04-22 15:30:12 -0600395 unsigned int (*calc_smb_size)(void *buf, struct TCP_Server_Info *ptcpi);
Pavel Shilovsky66265f12019-01-23 17:11:16 -0800396 /* check for STATUS_PENDING and process the response if yes */
397 bool (*is_status_pending)(char *buf, struct TCP_Server_Info *server);
Pavel Shilovsky511c54a2017-07-08 14:32:00 -0700398 /* check for STATUS_NETWORK_SESSION_EXPIRED */
399 bool (*is_session_expired)(char *);
Pavel Shilovsky95a3f2f2012-09-18 16:20:33 -0700400 /* send oplock break response */
401 int (*oplock_response)(struct cifs_tcon *, struct cifs_fid *,
402 struct cifsInodeInfo *);
Pavel Shilovsky76ec5e32012-09-18 16:20:33 -0700403 /* query remote filesystem */
404 int (*queryfs)(const unsigned int, struct cifs_tcon *,
Amir Goldstein0f060932020-02-03 21:46:43 +0200405 struct cifs_sb_info *, struct kstatfs *);
Pavel Shilovskyd39a4f72012-09-19 06:22:43 -0700406 /* send mandatory brlock to the server */
407 int (*mand_lock)(const unsigned int, struct cifsFileInfo *, __u64,
408 __u64, __u32, int, int, bool);
409 /* unlock range of mandatory locks */
410 int (*mand_unlock_range)(struct cifsFileInfo *, struct file_lock *,
411 const unsigned int);
412 /* push brlocks from the cache to the server */
413 int (*push_mand_locks)(struct cifsFileInfo *);
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700414 /* get lease key of the inode */
Pavel Shilovskya41a28b2013-09-04 13:07:41 +0400415 void (*get_lease_key)(struct inode *, struct cifs_fid *);
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700416 /* set lease key of the inode */
Pavel Shilovskya41a28b2013-09-04 13:07:41 +0400417 void (*set_lease_key)(struct inode *, struct cifs_fid *);
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700418 /* generate new lease key */
Pavel Shilovskya41a28b2013-09-04 13:07:41 +0400419 void (*new_lease_key)(struct cifs_fid *);
Shyam Prasad Nf486ef82021-07-19 13:54:16 +0000420 int (*generate_signingkey)(struct cifs_ses *ses,
421 struct TCP_Server_Info *server);
Long Lieda1c542020-03-31 16:21:43 -0700422 int (*calc_signature)(struct smb_rqst *, struct TCP_Server_Info *,
423 bool allocate_crypto);
Steve Frenchb3152e22015-06-24 03:17:02 -0500424 int (*set_integrity)(const unsigned int, struct cifs_tcon *tcon,
425 struct cifsFileInfo *src_file);
Steve French834170c2016-09-30 21:14:26 -0500426 int (*enum_snapshots)(const unsigned int xid, struct cifs_tcon *tcon,
427 struct cifsFileInfo *src_file, void __user *);
Steve Frenchd26c2dd2020-02-06 06:00:14 -0600428 int (*notify)(const unsigned int xid, struct file *pfile,
429 void __user *pbuf);
Sachin Prabhub5be1a12013-11-25 17:09:49 +0000430 int (*query_mf_symlink)(unsigned int, struct cifs_tcon *,
431 struct cifs_sb_info *, const unsigned char *,
432 char *, unsigned int *);
Sachin Prabhucbb0aba2013-11-25 17:09:52 +0000433 int (*create_mf_symlink)(unsigned int, struct cifs_tcon *,
434 struct cifs_sb_info *, const unsigned char *,
435 char *, unsigned int *);
Pavel Shilovsky53ef1012013-09-05 16:11:28 +0400436 /* if we can do cache read operations */
437 bool (*is_read_op)(__u32);
438 /* set oplock level for the inode */
Pavel Shilovsky42873b02013-09-05 21:30:16 +0400439 void (*set_oplock_level)(struct cifsInodeInfo *, __u32, unsigned int,
440 bool *);
Pavel Shilovskya41a28b2013-09-04 13:07:41 +0400441 /* create lease context buffer for CREATE request */
Stefano Brivio729c0c92018-07-05 15:10:02 +0200442 char * (*create_lease_buf)(u8 *lease_key, u8 oplock);
Pavel Shilovsky42873b02013-09-05 21:30:16 +0400443 /* parse lease context buffer and return oplock/epoch info */
Ronnie Sahlberg96164ab2018-04-26 08:10:18 -0600444 __u8 (*parse_lease_buf)(void *buf, unsigned int *epoch, char *lkey);
Sachin Prabhu620d8742017-02-10 16:03:51 +0530445 ssize_t (*copychunk_range)(const unsigned int,
Sachin Prabhu312bbc52017-04-04 02:12:04 -0500446 struct cifsFileInfo *src_file,
Sachin Prabhu620d8742017-02-10 16:03:51 +0530447 struct cifsFileInfo *target_file,
448 u64 src_off, u64 len, u64 dest_off);
Steve French02b16662015-06-27 21:18:36 -0700449 int (*duplicate_extents)(const unsigned int, struct cifsFileInfo *src,
450 struct cifsFileInfo *target_file, u64 src_off, u64 len,
451 u64 dest_off);
Steve Frenchff1c0382013-11-19 23:44:46 -0600452 int (*validate_negotiate)(const unsigned int, struct cifs_tcon *);
Steve French666753c2014-01-26 23:53:43 -0600453 ssize_t (*query_all_EAs)(const unsigned int, struct cifs_tcon *,
454 const unsigned char *, const unsigned char *, char *,
Steve French67b4c882017-05-12 20:59:10 -0500455 size_t, struct cifs_sb_info *);
Steve French666753c2014-01-26 23:53:43 -0600456 int (*set_EA)(const unsigned int, struct cifs_tcon *, const char *,
457 const char *, const void *, const __u16,
Ronnie Sahlberg55175542017-08-24 11:24:56 +1000458 const struct nls_table *, struct cifs_sb_info *);
Steve French83e3bc22014-02-02 23:31:47 -0600459 struct cifs_ntsd * (*get_acl)(struct cifs_sb_info *, struct inode *,
Boris Protopopov3970acf2020-12-18 11:30:12 -0600460 const char *, u32 *, u32);
Steve French42eacf92014-02-10 14:08:16 -0600461 struct cifs_ntsd * (*get_acl_by_fid)(struct cifs_sb_info *,
Boris Protopopov3970acf2020-12-18 11:30:12 -0600462 const struct cifs_fid *, u32 *, u32);
Steve French83e3bc22014-02-02 23:31:47 -0600463 int (*set_acl)(struct cifs_ntsd *, __u32, struct inode *, const char *,
464 int);
Pavel Shilovsky7f6c5002014-06-22 11:03:22 +0400465 /* writepages retry size */
466 unsigned int (*wp_retry_size)(struct inode *);
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +0400467 /* get mtu credits */
468 int (*wait_mtu_credits)(struct TCP_Server_Info *, unsigned int,
Pavel Shilovsky335b7b62019-01-16 11:12:41 -0800469 unsigned int *, struct cifs_credits *);
Pavel Shilovsky9a1c67e2019-01-23 18:15:52 -0800470 /* adjust previously taken mtu credits to request size */
471 int (*adjust_credits)(struct TCP_Server_Info *server,
472 struct cifs_credits *credits,
473 const unsigned int payload_size);
Pavel Shilovsky52755802014-08-18 20:49:57 +0400474 /* check if we need to issue closedir */
475 bool (*dir_needs_close)(struct cifsFileInfo *);
Steve French31742c52014-08-17 08:38:47 -0500476 long (*fallocate)(struct file *, struct cifs_tcon *, int, loff_t,
477 loff_t);
Pavel Shilovsky7fb89862016-10-31 13:49:30 -0700478 /* init transform request - used for encryption for now */
Ronnie Sahlbergb2c96de2018-08-01 09:26:11 +1000479 int (*init_transform_rq)(struct TCP_Server_Info *, int num_rqst,
480 struct smb_rqst *, struct smb_rqst *);
Pavel Shilovsky9bb17e02016-11-17 15:24:34 -0800481 int (*is_transform_hdr)(void *buf);
482 int (*receive_transform)(struct TCP_Server_Info *,
Ronnie Sahlbergb24df3e2018-08-08 15:07:45 +1000483 struct mid_q_entry **, char **, int *);
Sachin Prabhuef65aae2017-01-18 15:35:57 +0530484 enum securityEnum (*select_sectype)(struct TCP_Server_Info *,
485 enum securityEnum);
Ronnie Sahlberg8ce79ec2018-06-01 10:53:08 +1000486 int (*next_header)(char *);
Ronnie Sahlbergf5b05d62018-10-07 19:19:58 -0500487 /* ioctl passthrough for query_info */
488 int (*ioctl_query_info)(const unsigned int xid,
Ronnie Sahlberg8d8b26e2018-10-17 05:47:58 +1000489 struct cifs_tcon *tcon,
Amir Goldstein0f060932020-02-03 21:46:43 +0200490 struct cifs_sb_info *cifs_sb,
Ronnie Sahlberg8d8b26e2018-10-17 05:47:58 +1000491 __le16 *path, int is_dir,
Ronnie Sahlbergf5b05d62018-10-07 19:19:58 -0500492 unsigned long p);
Aurelien Aptelc847dcc2019-03-14 00:29:17 -0500493 /* make unix special files (block, char, fifo, socket) */
494 int (*make_node)(unsigned int xid,
495 struct inode *inode,
496 struct dentry *dentry,
497 struct cifs_tcon *tcon,
Al Viro55869132021-03-18 01:38:53 -0400498 const char *full_path,
Aurelien Aptelc847dcc2019-03-14 00:29:17 -0500499 umode_t mode,
500 dev_t device_number);
Ronnie Sahlberg2f3ebab2019-04-25 16:45:29 +1000501 /* version specific fiemap implementation */
502 int (*fiemap)(struct cifs_tcon *tcon, struct cifsFileInfo *,
503 struct fiemap_extent_info *, u64, u64);
Ronnie Sahlbergdece44e2019-05-15 07:17:02 +1000504 /* version specific llseek implementation */
505 loff_t (*llseek)(struct file *, struct cifs_tcon *, loff_t, int);
Rohith Surabattula8e670f72020-09-18 05:37:28 +0000506 /* Check for STATUS_IO_TIMEOUT */
507 bool (*is_status_io_timeout)(char *buf);
Rohith Surabattula9e550b02021-02-16 10:40:45 +0000508 /* Check for STATUS_NETWORK_NAME_DELETED */
509 void (*is_network_name_deleted)(char *buf, struct TCP_Server_Info *srv);
Jeff Layton23db65f2012-05-15 12:20:51 -0400510};
511
512struct smb_version_values {
513 char *version_string;
Steve Frenche4aa25e2012-10-01 12:26:22 -0500514 __u16 protocol_id;
515 __u32 req_capabilities;
Pavel Shilovsky106dc532012-02-28 14:23:34 +0300516 __u32 large_lock_type;
517 __u32 exclusive_lock_type;
518 __u32 shared_lock_type;
519 __u32 unlock_lock_type;
Ronnie Sahlberg93012bf2018-03-31 11:45:31 +1100520 size_t header_preamble_size;
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400521 size_t header_size;
522 size_t max_header_size;
Pavel Shilovskyeb378712012-05-17 13:02:51 +0400523 size_t read_rsp_size;
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +0400524 __le16 lock_cmd;
Pavel Shilovsky29e20f92012-07-13 13:58:14 +0400525 unsigned int cap_unix;
526 unsigned int cap_nt_find;
527 unsigned int cap_large_files;
Jeff Layton502858822013-06-27 12:45:00 -0400528 __u16 signing_enabled;
529 __u16 signing_required;
Pavel Shilovskya41a28b2013-09-04 13:07:41 +0400530 size_t create_lease_size;
Jeff Layton23db65f2012-05-15 12:20:51 -0400531};
532
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400533#define HEADER_SIZE(server) (server->vals->header_size)
534#define MAX_HEADER_SIZE(server) (server->vals->max_header_size)
535
Aurelien Apteld070f9d2019-04-02 13:00:33 +0200536/**
537 * CIFS superblock mount flags (mnt_cifs_flags) to consider when
538 * trying to reuse existing superblock for a new mount
539 */
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400540#define CIFS_MOUNT_MASK (CIFS_MOUNT_NO_PERM | CIFS_MOUNT_SET_UID | \
541 CIFS_MOUNT_SERVER_INUM | CIFS_MOUNT_DIRECT_IO | \
542 CIFS_MOUNT_NO_XATTR | CIFS_MOUNT_MAP_SPECIAL_CHR | \
Steve French2baa2682014-09-27 02:19:01 -0500543 CIFS_MOUNT_MAP_SFM_CHR | \
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400544 CIFS_MOUNT_UNX_EMUL | CIFS_MOUNT_NO_BRL | \
545 CIFS_MOUNT_CIFS_ACL | CIFS_MOUNT_OVERR_UID | \
546 CIFS_MOUNT_OVERR_GID | CIFS_MOUNT_DYNPERM | \
547 CIFS_MOUNT_NOPOSIXBRL | CIFS_MOUNT_NOSSYNC | \
548 CIFS_MOUNT_FSCACHE | CIFS_MOUNT_MF_SYMLINKS | \
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500549 CIFS_MOUNT_MULTIUSER | CIFS_MOUNT_STRICT_IO | \
Aurelien Apteld070f9d2019-04-02 13:00:33 +0200550 CIFS_MOUNT_CIFS_BACKUPUID | CIFS_MOUNT_CIFS_BACKUPGID | \
Steve French6552d6a2019-06-24 01:19:52 -0500551 CIFS_MOUNT_UID_FROM_ACL | CIFS_MOUNT_NO_HANDLE_CACHE | \
Steve French83bbfa72019-08-27 23:58:54 -0500552 CIFS_MOUNT_NO_DFS | CIFS_MOUNT_MODE_FROM_SID | \
Steve French41e033f2019-08-30 02:12:41 -0500553 CIFS_MOUNT_RO_CACHE | CIFS_MOUNT_RW_CACHE)
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400554
Aurelien Apteld070f9d2019-04-02 13:00:33 +0200555/**
556 * Generic VFS superblock mount flags (s_flags) to consider when
557 * trying to reuse existing superblock for a new mount
558 */
Linus Torvalds1751e8a2017-11-27 13:05:09 -0800559#define CIFS_MS_MASK (SB_RDONLY | SB_MANDLOCK | SB_NOEXEC | SB_NOSUID | \
560 SB_NODEV | SB_SYNCHRONOUS)
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400561
562struct cifs_mnt_data {
563 struct cifs_sb_info *cifs_sb;
Ronnie Sahlberg3fa1c6d2020-12-09 23:07:12 -0600564 struct smb3_fs_context *ctx;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400565 int flags;
566};
567
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400568static inline unsigned int
569get_rfc1002_length(void *buf)
570{
Jeff Laytondca1c8d2014-02-22 19:35:38 -0500571 return be32_to_cpu(*((__be32 *)buf)) & 0xffffff;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400572}
573
Pavel Shilovskyec2e4522011-12-27 16:12:43 +0400574static inline void
575inc_rfc1001_len(void *buf, int count)
576{
577 be32_add_cpu((__be32 *)buf, count);
578}
579
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580struct TCP_Server_Info {
Steve French3b795212008-11-13 19:45:32 +0000581 struct list_head tcp_ses_list;
582 struct list_head smb_ses_list;
Shyam Prasad N6d82c272021-02-03 23:20:46 -0800583 __u64 conn_id; /* connection identifier (useful for debugging) */
Jeff Laytone7ddee92008-11-14 13:44:38 -0500584 int srv_count; /* reference counter */
Steve Frencha10faeb22005-08-22 21:38:31 -0700585 /* 15 character server name + 0x20 16th byte indicating type = srv */
Jeff Layton8ecaf672008-12-01 15:23:50 -0500586 char server_RFC1001_name[RFC1001_NAME_LEN_WITH_NULL];
Jeff Layton23db65f2012-05-15 12:20:51 -0400587 struct smb_version_operations *ops;
588 struct smb_version_values *vals;
Shyam Prasad N080dc5e2021-07-19 17:05:53 +0000589 /* updates to tcpStatus protected by cifs_tcp_ses_lock */
Jeff Laytonc3dccf42011-01-20 13:36:50 -0500590 enum statusEnum tcpStatus; /* what we think the status is */
Jeff Laytonc359cf32007-11-16 22:22:06 +0000591 char *hostname; /* hostname portion of UNC string */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 struct socket *ssocket;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300593 struct sockaddr_storage dstaddr;
Ben Greear3eb9a882010-09-01 17:06:02 -0700594 struct sockaddr_storage srcaddr; /* locally bind to this IP */
Rob Landleyf1d0c992011-01-22 15:44:05 -0600595#ifdef CONFIG_NET_NS
596 struct net *net;
597#endif
Steve Frenchd38d8c72007-06-28 19:44:13 +0000598 wait_queue_head_t response_q;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 wait_queue_head_t request_q; /* if more than maxmpx to srvr must block*/
600 struct list_head pending_mid_q;
Steve Frenchedf1ae42008-10-29 00:47:57 +0000601 bool noblocksnd; /* use blocking sendmsg */
602 bool noautotune; /* do not autotune send buf sizes */
Shyam Prasad Nc9f1c192021-11-06 11:31:53 +0000603 bool nosharesock;
Steve French6a5fa2362010-01-01 01:28:43 +0000604 bool tcp_nodelay;
Steve French141891f2016-09-23 00:44:16 -0500605 unsigned int credits; /* send no more requests at once */
606 unsigned int max_credits; /* can override large 32000 default at mnt */
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300607 unsigned int in_flight; /* number of requests on the wire to server */
Steve French1b63f182019-09-09 22:57:11 -0500608 unsigned int max_in_flight; /* max number of requests that were on wire */
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400609 spinlock_t req_lock; /* protect the two values above */
Jeff Layton72ca5452008-12-01 07:09:36 -0500610 struct mutex srv_mutex;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 struct task_struct *tsk;
612 char server_GUID[16];
Pavel Shilovsky286170a2012-05-25 10:43:58 +0400613 __u16 sec_mode;
Jeff Layton38d77c52013-05-26 07:01:00 -0400614 bool sign; /* is signing enabled on this connection? */
Steve French4f5c10f2019-09-03 21:18:49 -0500615 bool ignore_signature:1; /* skip validation of signatures in SMB2/3 rsp */
Jeff Laytonc3dccf42011-01-20 13:36:50 -0500616 bool session_estab; /* mark when very first sess is established */
Pavel Shilovsky28ea5292012-05-23 16:18:00 +0400617 int echo_credits; /* echo reserved slots */
618 int oplock_credits; /* oplock break reserved slots */
619 bool echoes:1; /* enable echoes */
Sachin Prabhu39552ea2014-05-13 00:48:12 +0100620 __u8 client_guid[SMB2_CLIENT_GUID_SIZE]; /* Client GUID */
Jeff Laytonc3dccf42011-01-20 13:36:50 -0500621 u16 dialect; /* dialect index that server chose */
Pavel Shilovsky10b9b982012-03-20 12:55:09 +0300622 bool oplocks:1; /* enable oplocks */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 unsigned int maxReq; /* Clients should submit no more */
624 /* than maxReq distinct unanswered SMBs to the server when using */
Steve French11911b92018-05-24 02:09:20 -0500625 /* multiplexed reads or writes (for SMB1/CIFS only, not SMB2/SMB3) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 unsigned int maxBuf; /* maxBuf specifies the maximum */
627 /* message size the server can send or receive for non-raw SMBs */
Steve French7e90d702011-02-08 23:52:32 +0000628 /* maxBuf is returned by SMB NegotiateProtocol so maxBuf is only 0 */
629 /* when socket is setup (and during reconnect) before NegProt sent */
Steve Frencheca6acf2009-02-20 05:43:09 +0000630 unsigned int max_rw; /* maxRw specifies the maximum */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 /* message size the server can send or receive for */
632 /* SMB_COM_WRITE_RAW or SMB_COM_READ_RAW. */
Pavel Shilovsky29e20f92012-07-13 13:58:14 +0400633 unsigned int capabilities; /* selective disabling of caps by smb sess */
Steve Frenchde7ed552006-09-30 13:25:52 +0000634 int timeAdj; /* Adjust for difference in server time zone in sec */
Steve French0fa757b2021-06-25 13:54:32 -0500635 __u64 CurrentMid; /* multiplex id - rotating counter, protected by GlobalMid_Lock */
Shirish Pargaonkard3ba50b2010-10-27 15:20:36 -0500636 char cryptkey[CIFS_CRYPTO_KEY_SIZE]; /* used by ntlm, ntlmv2 etc */
Steve Frencha10faeb22005-08-22 21:38:31 -0700637 /* 16th byte of RFC1001 workstation name is always null */
Jeff Layton8ecaf672008-12-01 15:23:50 -0500638 char workstation_RFC1001_name[RFC1001_NAME_LEN_WITH_NULL];
Jeff Laytona0f8b4f2011-01-07 11:30:28 -0500639 __u32 sequence_number; /* for signing, protected by srv_mutex */
Steve French9e1a37d2018-09-19 02:38:17 -0500640 __u32 reconnect_instance; /* incremented on each reconnect */
Shirish Pargaonkar5f98ca92010-09-18 22:01:58 -0500641 struct session_key session_key;
Steve French3a5ff612006-07-14 22:37:11 +0000642 unsigned long lstrp; /* when we got last response from this server */
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500643 struct cifs_secmech secmech; /* crypto sec mech functs, descriptors */
Jeff Laytone598d1d82013-05-26 07:00:59 -0400644#define CIFS_NEGFLAVOR_UNENCAP 1 /* wct == 17, but no ext_sec */
645#define CIFS_NEGFLAVOR_EXTENDED 2 /* wct == 17, ext_sec bit set */
646 char negflavor; /* NEGOTIATE response flavor */
Jeff Layton26efa0b2010-04-24 07:57:49 -0400647 /* extended security flavors that server supports */
Jeff Laytonc3dccf42011-01-20 13:36:50 -0500648 bool sec_ntlmssp; /* supports NTLMSSP */
649 bool sec_kerberosu2u; /* supports U2U Kerberos */
Jeff Layton26efa0b2010-04-24 07:57:49 -0400650 bool sec_kerberos; /* supports plain Kerberos */
651 bool sec_mskerberos; /* supports legacy MS Kerberos */
Jeff Layton2a37ef92011-10-19 15:29:23 -0400652 bool large_buf; /* is current buffer large? */
Long Li8339dd32017-11-07 01:54:55 -0700653 /* use SMBD connection instead of socket */
654 bool rdma;
655 /* point to the SMBD connection if RDMA is used instead of socket */
656 struct smbd_connection *smbd_conn;
Jeff Laytonc74093b2011-01-11 07:24:23 -0500657 struct delayed_work echo; /* echo ping workqueue job */
Shyam Prasad N506c1da2021-05-18 15:05:50 +0000658 struct delayed_work resolve; /* dns resolution workqueue job */
Jeff Layton2a37ef92011-10-19 15:29:23 -0400659 char *smallbuf; /* pointer to current "small" buffer */
660 char *bigbuf; /* pointer to current "big" buffer */
Ronnie Sahlberg2e964672018-04-09 18:06:26 +1000661 /* Total size of this PDU. Only valid from cifs_demultiplex_thread */
662 unsigned int pdu_size;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400663 unsigned int total_read; /* total amount of data read in this pass */
Steve French1ae9a5a2019-11-21 17:26:35 -0600664 atomic_t in_send; /* requests trying to send */
665 atomic_t num_waiters; /* blocked waiting to get in sendrecv */
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +0530666#ifdef CONFIG_CIFS_FSCACHE
667 struct fscache_cookie *fscache; /* client index cache cookie */
668#endif
Jeff Laytonc3dccf42011-01-20 13:36:50 -0500669#ifdef CONFIG_CIFS_STATS2
Steve French433b8dd2019-03-26 13:53:21 -0500670 atomic_t num_cmds[NUMBER_OF_SMB2_COMMANDS]; /* total requests by cmd */
Steve French468d6772018-08-04 05:24:34 -0500671 atomic_t smb2slowcmd[NUMBER_OF_SMB2_COMMANDS]; /* count resps > 1 sec */
Steve French433b8dd2019-03-26 13:53:21 -0500672 __u64 time_per_cmd[NUMBER_OF_SMB2_COMMANDS]; /* total time per cmd */
673 __u32 slowest_cmd[NUMBER_OF_SMB2_COMMANDS];
674 __u32 fastest_cmd[NUMBER_OF_SMB2_COMMANDS];
Steve French468d6772018-08-04 05:24:34 -0500675#endif /* STATS2 */
Pavel Shilovskyec2e4522011-12-27 16:12:43 +0400676 unsigned int max_read;
677 unsigned int max_write;
Steve French563317e2019-09-08 23:22:02 -0500678 unsigned int min_offload;
Steve French26ea8882019-04-26 20:36:08 -0700679 __le16 compress_algorithm;
Steve French53d31a32021-07-05 15:05:39 -0500680 __u16 signing_algorithm;
Steve French5100d8a2018-04-09 10:47:14 -0500681 __le16 cipher_type;
Aurelien Aptel8bd68c62018-02-16 19:19:29 +0100682 /* save initital negprot hash */
683 __u8 preauth_sha_hash[SMB2_PREAUTH_HASH_SIZE];
Steve French53d31a32021-07-05 15:05:39 -0500684 bool signing_negotiated; /* true if valid signing context rcvd from server */
Steve Frenchfcef0db2018-05-19 20:45:27 -0500685 bool posix_ext_supported;
Pavel Shilovsky53e0e112016-11-04 11:50:31 -0700686 struct delayed_work reconnect; /* reconnect workqueue job */
687 struct mutex reconnect_mutex; /* prevent simultaneous reconnects */
Steve Frenchadfeb3e2015-12-18 12:31:36 -0600688 unsigned long echo_interval;
Paulo Alcantara93d5cb52018-11-14 17:13:25 -0200689
690 /*
691 * Number of targets available for reconnect. The more targets
692 * the more tasks have to wait to let the demultiplex thread
693 * reconnect.
694 */
695 int nr_targets;
Paulo Alcantara (SUSE)8eecd1c2019-07-16 19:04:50 -0300696 bool noblockcnt; /* use non-blocking connect() */
Shyam Prasad N0f2b3052021-07-19 11:26:24 +0000697
698 /*
699 * If this is a session channel,
700 * primary_server holds the ref-counted
701 * pointer to primary channel connection for the session.
702 */
703#define CIFS_SERVER_IS_CHAN(server) (!!(server)->primary_server)
704 struct TCP_Server_Info *primary_server;
705
Samuel Cabrero121d9472020-11-30 19:02:56 +0100706#ifdef CONFIG_CIFS_SWN_UPCALL
707 bool use_swn_dstaddr;
708 struct sockaddr_storage swn_dstaddr;
709#endif
Paulo Alcantaracdc33632021-07-15 21:53:53 -0300710#ifdef CONFIG_CIFS_DFS_UPCALL
711 bool is_dfs_conn; /* if a dfs connection */
Paulo Alcantarac88f7dc2021-11-03 13:53:29 -0300712 struct mutex refpath_lock; /* protects leaf_fullpath */
713 /*
714 * Canonical DFS full paths that were used to chase referrals in mount and reconnect.
715 *
716 * origin_fullpath: first or original referral path
717 * leaf_fullpath: last referral path (might be changed due to nested links in reconnect)
718 *
719 * current_fullpath: pointer to either origin_fullpath or leaf_fullpath
720 * NOTE: cannot be accessed outside cifs_reconnect() and smb2_reconnect()
721 *
722 * format: \\HOST\SHARE\[OPTIONAL PATH]
723 */
724 char *origin_fullpath, *leaf_fullpath, *current_fullpath;
Paulo Alcantaracdc33632021-07-15 21:53:53 -0300725#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726};
727
Pavel Shilovsky335b7b62019-01-16 11:12:41 -0800728struct cifs_credits {
729 unsigned int value;
730 unsigned int instance;
731};
732
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300733static inline unsigned int
734in_flight(struct TCP_Server_Info *server)
735{
736 unsigned int num;
737 spin_lock(&server->req_lock);
738 num = server->in_flight;
739 spin_unlock(&server->req_lock);
740 return num;
741}
742
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400743static inline bool
Ronnie Sahlbergb227d212019-03-08 12:58:20 +1000744has_credits(struct TCP_Server_Info *server, int *credits, int num_credits)
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300745{
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400746 int num;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300747 spin_lock(&server->req_lock);
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300748 num = *credits;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300749 spin_unlock(&server->req_lock);
Ronnie Sahlbergb227d212019-03-08 12:58:20 +1000750 return num >= num_credits;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300751}
752
Pavel Shilovsky45275782012-05-17 17:53:29 +0400753static inline void
Pavel Shilovsky34f4deb2019-01-16 11:22:29 -0800754add_credits(struct TCP_Server_Info *server, const struct cifs_credits *credits,
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400755 const int optype)
Pavel Shilovsky45275782012-05-17 17:53:29 +0400756{
Pavel Shilovsky34f4deb2019-01-16 11:22:29 -0800757 server->ops->add_credits(server, credits, optype);
Pavel Shilovsky45275782012-05-17 17:53:29 +0400758}
759
760static inline void
Pavel Shilovsky335b7b62019-01-16 11:12:41 -0800761add_credits_and_wake_if(struct TCP_Server_Info *server,
762 const struct cifs_credits *credits, const int optype)
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +0400763{
Pavel Shilovsky335b7b62019-01-16 11:12:41 -0800764 if (credits->value) {
765 server->ops->add_credits(server, credits, optype);
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +0400766 wake_up(&server->request_q);
767 }
768}
769
770static inline void
Pavel Shilovsky45275782012-05-17 17:53:29 +0400771set_credits(struct TCP_Server_Info *server, const int val)
772{
773 server->ops->set_credits(server, val);
774}
775
Pavel Shilovsky9a1c67e2019-01-23 18:15:52 -0800776static inline int
777adjust_credits(struct TCP_Server_Info *server, struct cifs_credits *credits,
778 const unsigned int payload_size)
779{
780 return server->ops->adjust_credits ?
781 server->ops->adjust_credits(server, credits, payload_size) : 0;
782}
783
Sachin Prabhu9235d092014-12-09 17:37:00 +0000784static inline __le64
Tim Gardner3d378d32013-11-02 12:50:34 -0500785get_next_mid64(struct TCP_Server_Info *server)
Pavel Shilovsky88257362012-05-23 14:01:59 +0400786{
Sachin Prabhu9235d092014-12-09 17:37:00 +0000787 return cpu_to_le64(server->ops->get_next_mid(server));
Pavel Shilovsky88257362012-05-23 14:01:59 +0400788}
789
Tim Gardner3d378d32013-11-02 12:50:34 -0500790static inline __le16
791get_next_mid(struct TCP_Server_Info *server)
792{
Sachin Prabhu9235d092014-12-09 17:37:00 +0000793 __u16 mid = server->ops->get_next_mid(server);
Tim Gardner3d378d32013-11-02 12:50:34 -0500794 /*
795 * The value in the SMB header should be little endian for easy
796 * on-the-wire decoding.
797 */
798 return cpu_to_le16(mid);
799}
800
Pavel Shilovskyc781af72019-03-04 14:02:50 -0800801static inline void
802revert_current_mid(struct TCP_Server_Info *server, const unsigned int val)
803{
804 if (server->ops->revert_current_mid)
805 server->ops->revert_current_mid(server, val);
806}
807
808static inline void
809revert_current_mid_from_hdr(struct TCP_Server_Info *server,
Ronnie Sahlberg0d35e382021-11-05 08:39:01 +0900810 const struct smb2_hdr *shdr)
Pavel Shilovskyc781af72019-03-04 14:02:50 -0800811{
812 unsigned int num = le16_to_cpu(shdr->CreditCharge);
813
814 return revert_current_mid(server, num > 0 ? num : 1);
815}
816
Tim Gardner3d378d32013-11-02 12:50:34 -0500817static inline __u16
818get_mid(const struct smb_hdr *smb)
819{
820 return le16_to_cpu(smb->Mid);
821}
822
823static inline bool
824compare_mid(__u16 mid, const struct smb_hdr *smb)
825{
826 return mid == le16_to_cpu(smb->Mid);
827}
828
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829/*
Pavel Shilovsky24985c52012-09-18 16:20:28 -0700830 * When the server supports very large reads and writes via POSIX extensions,
831 * we can allow up to 2^24-1, minus the size of a READ/WRITE_AND_X header, not
832 * including the RFC1001 length.
833 *
834 * Note that this might make for "interesting" allocation problems during
835 * writeback however as we have to allocate an array of pointers for the
Kirill A. Shutemovea1754a2016-04-01 15:29:48 +0300836 * pages. A 16M write means ~32kb page array with PAGE_SIZE == 4096.
Pavel Shilovsky24985c52012-09-18 16:20:28 -0700837 *
838 * For reads, there is a similar problem as we need to allocate an array
839 * of kvecs to handle the receive, though that should only need to be done
840 * once.
841 */
842#define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
843#define CIFS_MAX_RSIZE ((1<<24) - sizeof(READ_RSP) + 4)
844
845/*
846 * When the server doesn't allow large posix writes, only allow a rsize/wsize
847 * of 2^17-1 minus the size of the call header. That allows for a read or
848 * write up to the maximum size described by RFC1002.
849 */
850#define CIFS_MAX_RFC1002_WSIZE ((1<<17) - 1 - sizeof(WRITE_REQ) + 4)
851#define CIFS_MAX_RFC1002_RSIZE ((1<<17) - 1 - sizeof(READ_RSP) + 4)
852
853/*
854 * The default wsize is 1M. find_get_pages seems to return a maximum of 256
Kirill A. Shutemovea1754a2016-04-01 15:29:48 +0300855 * pages in a single call. With PAGE_SIZE == 4k, this means we can fill
Pavel Shilovsky24985c52012-09-18 16:20:28 -0700856 * a single wsize request with a single call.
857 */
858#define CIFS_DEFAULT_IOSIZE (1024 * 1024)
Steve French3d621232018-09-25 15:33:47 -0500859#define SMB3_DEFAULT_IOSIZE (4 * 1024 * 1024)
Pavel Shilovsky24985c52012-09-18 16:20:28 -0700860
861/*
862 * Windows only supports a max of 60kb reads and 65535 byte writes. Default to
863 * those values when posix extensions aren't in force. In actuality here, we
864 * use 65536 to allow for a write that is a multiple of 4k. Most servers seem
865 * to be ok with the extra byte even though Windows doesn't send writes that
866 * are that large.
867 *
868 * Citation:
869 *
Alexander A. Klimovcba22b12020-06-27 12:31:25 +0200870 * https://blogs.msdn.com/b/openspecification/archive/2009/04/10/smb-maximum-transmit-buffer-size-and-performance-tuning.aspx
Pavel Shilovsky24985c52012-09-18 16:20:28 -0700871 */
872#define CIFS_DEFAULT_NON_POSIX_RSIZE (60 * 1024)
873#define CIFS_DEFAULT_NON_POSIX_WSIZE (65536)
874
875/*
Rob Landleyf1d0c992011-01-22 15:44:05 -0600876 * Macros to allow the TCP_Server_Info->net field and related code to drop out
877 * when CONFIG_NET_NS isn't set.
878 */
879
880#ifdef CONFIG_NET_NS
881
882static inline struct net *cifs_net_ns(struct TCP_Server_Info *srv)
883{
884 return srv->net;
885}
886
887static inline void cifs_set_net_ns(struct TCP_Server_Info *srv, struct net *net)
888{
889 srv->net = net;
890}
891
892#else
893
894static inline struct net *cifs_net_ns(struct TCP_Server_Info *srv)
895{
896 return &init_net;
897}
898
899static inline void cifs_set_net_ns(struct TCP_Server_Info *srv, struct net *net)
900{
901}
902
903#endif
904
Aurelien Aptelb6f0dd52018-06-14 15:43:18 +0200905struct cifs_server_iface {
906 size_t speed;
907 unsigned int rdma_capable : 1;
908 unsigned int rss_capable : 1;
909 struct sockaddr_storage sockaddr;
910};
911
Aurelien Aptelbcc88802019-09-20 04:32:20 +0200912struct cifs_chan {
913 struct TCP_Server_Info *server;
914 __u8 signkey[SMB3_SIGN_KEY_SIZE];
915};
916
Rob Landleyf1d0c992011-01-22 15:44:05 -0600917/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 * Session structure. One of these for each uid session with a particular host
919 */
Steve French96daf2b2011-05-27 04:34:02 +0000920struct cifs_ses {
Jeff Layton14fbf502008-11-14 13:53:46 -0500921 struct list_head smb_ses_list;
Steve French3b795212008-11-13 19:45:32 +0000922 struct list_head tcon_list;
Aurelien Aptelb327a712018-01-24 13:46:10 +0100923 struct cifs_tcon *tcon_ipc;
Steve Frenchd7b619c2010-02-25 05:36:46 +0000924 struct mutex session_mutex;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 struct TCP_Server_Info *server; /* pointer to server info */
Jeff Layton14fbf502008-11-14 13:53:46 -0500926 int ses_count; /* reference counter */
Shyam Prasad N080dc5e2021-07-19 17:05:53 +0000927 enum statusEnum status; /* updates protected by cifs_tcp_ses_lock */
Steve French750d1152006-06-27 06:28:30 +0000928 unsigned overrideSecFlg; /* if non-zero override global sec flags */
Steve Frenchad009ac2005-04-28 22:41:05 -0700929 char *serverOS; /* name of operating system underlying server */
930 char *serverNOS; /* name of network operating system of server */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 char *serverDomain; /* security realm of server */
Pavel Shilovsky286170a2012-05-25 10:43:58 +0400932 __u64 Suid; /* remote smb uid */
Eric W. Biederman64ed39d2013-02-06 02:30:39 -0800933 kuid_t linux_uid; /* overriding owner of files on the mount */
934 kuid_t cred_uid; /* owner of credentials */
Pavel Shilovsky29e20f92012-07-13 13:58:14 +0400935 unsigned int capabilities;
Steve Frenchb438fcf2021-02-20 19:24:11 -0600936 char ip_addr[INET6_ADDRSTRLEN + 1]; /* Max ipv6 (or v4) addr string len */
Steve French34c87902011-03-01 05:02:57 +0000937 char *user_name; /* must not be null except during init of sess
938 and after mount option parsing we fill it */
Steve Frenchd38d8c72007-06-28 19:44:13 +0000939 char *domainName;
940 char *password;
Shyam Prasad N49bd49f2021-11-05 19:03:57 +0000941 char *workstation_name;
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -0500942 struct session_key auth_key;
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500943 struct ntlmssp_auth *ntlmssp; /* ciphertext, flags, server challenge */
Jeff Layton28e11bd2013-05-26 07:01:00 -0400944 enum securityEnum sectype; /* what security flavor was specified? */
945 bool sign; /* is signing required? */
Germano Percossi39566442016-12-15 12:31:18 +0530946 bool domainAuto:1;
Pavel Shilovsky5478f9b2011-12-27 16:22:00 +0400947 __u16 session_flags;
Steve French373512e2015-12-18 13:05:30 -0600948 __u8 smb3signingkey[SMB3_SIGN_KEY_SIZE];
Shyam Prasad N45a45462021-03-25 12:34:54 +0000949 __u8 smb3encryptionkey[SMB3_ENC_DEC_KEY_SIZE];
950 __u8 smb3decryptionkey[SMB3_ENC_DEC_KEY_SIZE];
Aurelien Aptel8bd68c62018-02-16 19:19:29 +0100951 __u8 preauth_sha_hash[SMB2_PREAUTH_HASH_SIZE];
Aurelien Aptelb6f0dd52018-06-14 15:43:18 +0200952
953 /*
954 * Network interfaces available on the server this session is
955 * connected to.
956 *
957 * Other channels can be opened by connecting and binding this
958 * session to interfaces from this list.
959 *
960 * iface_lock should be taken when accessing any of these fields
961 */
962 spinlock_t iface_lock;
Shyam Prasad N724244c2021-07-19 10:54:46 +0000963 /* ========= begin: protected by iface_lock ======== */
Aurelien Aptelb6f0dd52018-06-14 15:43:18 +0200964 struct cifs_server_iface *iface_list;
965 size_t iface_count;
966 unsigned long iface_last_update; /* jiffies */
Shyam Prasad N724244c2021-07-19 10:54:46 +0000967 /* ========= end: protected by iface_lock ======== */
Aurelien Aptelbcc88802019-09-20 04:32:20 +0200968
Shyam Prasad N724244c2021-07-19 10:54:46 +0000969 spinlock_t chan_lock;
970 /* ========= begin: protected by chan_lock ======== */
Aurelien Aptelbcc88802019-09-20 04:32:20 +0200971#define CIFS_MAX_CHANNELS 16
Shyam Prasad Nd1a931c2021-07-19 12:46:53 +0000972#define CIFS_ALL_CHANNELS_SET(ses) \
973 ((1UL << (ses)->chan_count) - 1)
974#define CIFS_ALL_CHANS_NEED_RECONNECT(ses) \
975 ((ses)->chans_need_reconnect == CIFS_ALL_CHANNELS_SET(ses))
Shyam Prasad N183eea22021-07-19 14:14:46 +0000976#define CIFS_SET_ALL_CHANS_NEED_RECONNECT(ses) \
977 ((ses)->chans_need_reconnect = CIFS_ALL_CHANNELS_SET(ses))
Shyam Prasad Nd1a931c2021-07-19 12:46:53 +0000978#define CIFS_CHAN_NEEDS_RECONNECT(ses, index) \
979 test_bit((index), &(ses)->chans_need_reconnect)
980
Aurelien Aptelbcc88802019-09-20 04:32:20 +0200981 struct cifs_chan chans[CIFS_MAX_CHANNELS];
982 size_t chan_count;
983 size_t chan_max;
984 atomic_t chan_seq; /* round robin state */
Shyam Prasad Nd1a931c2021-07-19 12:46:53 +0000985
986 /*
987 * chans_need_reconnect is a bitmap indicating which of the channels
988 * under this smb session needs to be reconnected.
989 * If not multichannel session, only one bit will be used.
Shyam Prasad Nf486ef82021-07-19 13:54:16 +0000990 *
991 * We will ask for sess and tcon reconnection only if all the
992 * channels are marked for needing reconnection. This will
993 * enable the sessions on top to continue to live till any
994 * of the channels below are active.
Shyam Prasad Nd1a931c2021-07-19 12:46:53 +0000995 */
996 unsigned long chans_need_reconnect;
Shyam Prasad N724244c2021-07-19 10:54:46 +0000997 /* ========= end: protected by chan_lock ======== */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998};
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700999
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001000static inline bool
1001cap_unix(struct cifs_ses *ses)
1002{
1003 return ses->server->vals->cap_unix & ses->capabilities;
1004}
1005
Ronnie Sahlberga93864d2018-06-14 06:48:35 +10001006struct cached_fid {
1007 bool is_valid:1; /* Do we have a useable root fid */
Ronnie Sahlbergb0f6df72019-03-12 13:58:31 +10001008 bool file_all_info_is_valid:1;
Pavel Shilovskyd9191312019-12-10 11:44:52 -08001009 bool has_lease:1;
Ronnie Sahlberged20f542021-03-09 09:07:33 +10001010 unsigned long time; /* jiffies of when lease was taken */
Ronnie Sahlberg9da6ec72018-07-31 08:48:22 +10001011 struct kref refcount;
Ronnie Sahlberga93864d2018-06-14 06:48:35 +10001012 struct cifs_fid *fid;
1013 struct mutex fid_mutex;
1014 struct cifs_tcon *tcon;
Ronnie Sahlberg5e9c89d2021-03-09 09:07:31 +10001015 struct dentry *dentry;
Ronnie Sahlberga93864d2018-06-14 06:48:35 +10001016 struct work_struct lease_break;
Ronnie Sahlbergb0f6df72019-03-12 13:58:31 +10001017 struct smb2_file_all_info file_all_info;
Ronnie Sahlberga93864d2018-06-14 06:48:35 +10001018};
1019
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020/*
1021 * there is one of these for each connection to a resource on a particular
Steve Frenchd38d8c72007-06-28 19:44:13 +00001022 * session
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 */
Steve French96daf2b2011-05-27 04:34:02 +00001024struct cifs_tcon {
Jeff Laytonf1987b42008-11-15 11:12:47 -05001025 struct list_head tcon_list;
1026 int tc_count;
Pavel Shilovsky53e0e112016-11-04 11:50:31 -07001027 struct list_head rlist; /* reconnect list */
Steve Frenchfae80442018-10-19 17:14:32 -05001028 atomic_t num_local_opens; /* num of all opens including disconnected */
1029 atomic_t num_remote_opens; /* num of all network opens on server */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 struct list_head openFileList;
Steve French3afca262016-09-22 18:58:16 -05001031 spinlock_t open_file_lock; /* protects list above */
Steve French96daf2b2011-05-27 04:34:02 +00001032 struct cifs_ses *ses; /* pointer to session associated with */
Steve French254e55e2006-06-04 05:53:15 +00001033 char treeName[MAX_TREE_SIZE + 1]; /* UNC name of resource in ASCII */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 char *nativeFileSystem;
Jeff Layton00e485b2008-12-05 20:41:21 -05001035 char *password; /* for share-level security */
Pavel Shilovskyfaaf9462011-12-27 16:04:00 +04001036 __u32 tid; /* The 4 byte tree id */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 __u16 Flags; /* optional support bits */
1038 enum statusEnum tidStatus;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039 atomic_t num_smbs_sent;
Pavel Shilovsky44c58182012-05-28 14:16:31 +04001040 union {
1041 struct {
1042 atomic_t num_writes;
1043 atomic_t num_reads;
1044 atomic_t num_flushes;
1045 atomic_t num_oplock_brks;
1046 atomic_t num_opens;
1047 atomic_t num_closes;
1048 atomic_t num_deletes;
1049 atomic_t num_mkdirs;
1050 atomic_t num_posixopens;
1051 atomic_t num_posixmkdirs;
1052 atomic_t num_rmdirs;
1053 atomic_t num_renames;
1054 atomic_t num_t2renames;
1055 atomic_t num_ffirst;
1056 atomic_t num_fnext;
1057 atomic_t num_fclose;
1058 atomic_t num_hardlinks;
1059 atomic_t num_symlinks;
1060 atomic_t num_locks;
1061 atomic_t num_acl_get;
1062 atomic_t num_acl_set;
1063 } cifs_stats;
Pavel Shilovskyd60622e2012-05-28 15:19:39 +04001064 struct {
1065 atomic_t smb2_com_sent[NUMBER_OF_SMB2_COMMANDS];
1066 atomic_t smb2_com_failed[NUMBER_OF_SMB2_COMMANDS];
1067 } smb2_stats;
Pavel Shilovsky44c58182012-05-28 14:16:31 +04001068 } stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069 __u64 bytes_read;
1070 __u64 bytes_written;
Steve French3afca262016-09-22 18:58:16 -05001071 spinlock_t stat_lock; /* protects the two fields above */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 FILE_SYSTEM_DEVICE_INFO fsDevInfo;
Steve French254e55e2006-06-04 05:53:15 +00001073 FILE_SYSTEM_ATTRIBUTE_INFO fsAttrInfo; /* ok if fs name truncated */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 FILE_SYSTEM_UNIX_INFO fsUnixInfo;
Aurelien Aptelb327a712018-01-24 13:46:10 +01001075 bool ipc:1; /* set if connection to IPC$ share (always also pipe) */
1076 bool pipe:1; /* set if connection to pipe share */
1077 bool print:1; /* set if connection to printer share */
Steve French4b18f2a2008-04-29 00:06:05 +00001078 bool retry:1;
1079 bool nocase:1;
Steve French3d4ef9a2018-04-25 22:19:09 -05001080 bool nohandlecache:1; /* if strange server resource prob can turn off */
Steve French82e93672020-05-19 03:06:57 -05001081 bool nodelete:1;
Steve French95b1cb92008-05-15 16:44:38 +00001082 bool seal:1; /* transport encryption for this mounted share */
Steve French4b18f2a2008-04-29 00:06:05 +00001083 bool unix_ext:1; /* if false disable Linux extensions to CIFS protocol
Steve Frenchc18c8422007-07-18 23:21:09 +00001084 for this mount even if server would support */
Steve Frenchb3266142018-05-20 23:41:10 -05001085 bool posix_extensions; /* if true SMB3.11 posix extensions enabled */
Steve French84210e92008-10-23 04:42:37 +00001086 bool local_lease:1; /* check leases (only) on local system not remote */
Steve French64cc2c62009-03-04 19:54:08 +00001087 bool broken_posix_open; /* e.g. Samba server versions < 3.3.2, 3.2.9 */
Steve French3d1a3742014-08-11 21:05:25 -05001088 bool broken_sparse_sup; /* if server or share does not support sparse */
Steve French3b795212008-11-13 19:45:32 +00001089 bool need_reconnect:1; /* connection reset, tid now invalid */
Pavel Shilovsky96a988f2016-11-29 11:31:23 -08001090 bool need_reopen_files:1; /* need to reopen tcon file handles */
Steve French592fafe2015-11-03 10:08:53 -06001091 bool use_resilient:1; /* use resilient instead of durable handles */
Steve Frenchb618f002015-11-03 09:15:03 -06001092 bool use_persistent:1; /* use persistent instead of durable handles */
Steve French3e7a02d2019-09-11 21:46:20 -05001093 bool no_lease:1; /* Do not request leases on files or directories */
Aurelien Aptelb7fd0fa2021-04-09 16:31:37 +02001094 bool use_witness:1; /* use witness protocol */
Steve French769ee6a2013-06-19 14:15:30 -05001095 __le32 capabilities;
Pavel Shilovskyfaaf9462011-12-27 16:04:00 +04001096 __u32 share_flags;
1097 __u32 maximal_access;
1098 __u32 vol_serial_number;
1099 __le64 vol_create_time;
Steve French8b217fe2016-11-11 22:36:20 -06001100 __u64 snapshot_time; /* for timewarp tokens - timestamp of snapshot */
Steve Frenchca567eb2019-03-29 16:31:07 -05001101 __u32 handle_timeout; /* persistent and durable handle timeout in ms */
Steven Frenchaf6a12e2013-10-09 20:55:53 -05001102 __u32 ss_flags; /* sector size flags */
1103 __u32 perf_sector_size; /* best sector size for perf */
Steve Frenchde9f68df2013-11-15 11:26:24 -06001104 __u32 max_chunks;
1105 __u32 max_bytes_chunk;
1106 __u32 max_bytes_copy;
Suresh Jayaramand03382c2010-07-05 18:12:27 +05301107#ifdef CONFIG_CIFS_FSCACHE
1108 u64 resource_id; /* server resource id */
1109 struct fscache_cookie *fscache; /* cookie for share */
1110#endif
Pavel Shilovsky233839b2012-09-19 06:22:45 -07001111 struct list_head pending_opens; /* list of incomplete opens */
Ronnie Sahlberga93864d2018-06-14 06:48:35 +10001112 struct cached_fid crfid; /* Cached root fid */
Steve Frenchc18c8422007-07-18 23:21:09 +00001113 /* BB add field for back pointer to sb struct(s)? */
Paulo Alcantara54be1f62018-11-14 16:01:21 -02001114#ifdef CONFIG_CIFS_DFS_UPCALL
Paulo Alcantara54be1f62018-11-14 16:01:21 -02001115 struct list_head ulist; /* cache update list */
1116#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117};
1118
1119/*
Jeff Layton7ffec372010-09-29 19:51:11 -04001120 * This is a refcounted and timestamped container for a tcon pointer. The
1121 * container holds a tcon reference. It is considered safe to free one of
1122 * these when the tl_count goes to 0. The tl_time is the time of the last
1123 * "get" on the container.
1124 */
1125struct tcon_link {
Jeff Laytonb647c352010-10-28 11:16:44 -04001126 struct rb_node tl_rbnode;
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08001127 kuid_t tl_uid;
Jeff Layton9d002df2010-10-06 19:51:11 -04001128 unsigned long tl_flags;
1129#define TCON_LINK_MASTER 0
1130#define TCON_LINK_PENDING 1
1131#define TCON_LINK_IN_TREE 2
1132 unsigned long tl_time;
1133 atomic_t tl_count;
Steve French96daf2b2011-05-27 04:34:02 +00001134 struct cifs_tcon *tl_tcon;
Jeff Layton7ffec372010-09-29 19:51:11 -04001135};
1136
Jeff Layton9d002df2010-10-06 19:51:11 -04001137extern struct tcon_link *cifs_sb_tlink(struct cifs_sb_info *cifs_sb);
Ronnie Sahlbergb2c96de2018-08-01 09:26:11 +10001138extern void smb3_free_compound_rqst(int num_rqst, struct smb_rqst *rqst);
Jeff Layton7ffec372010-09-29 19:51:11 -04001139
Steve French96daf2b2011-05-27 04:34:02 +00001140static inline struct cifs_tcon *
Jeff Layton7ffec372010-09-29 19:51:11 -04001141tlink_tcon(struct tcon_link *tlink)
1142{
Jeff Layton9d002df2010-10-06 19:51:11 -04001143 return tlink->tl_tcon;
Jeff Layton7ffec372010-09-29 19:51:11 -04001144}
1145
Aurelien Aptel8ddecf52018-06-04 22:29:35 +02001146static inline struct tcon_link *
1147cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
1148{
1149 return cifs_sb->master_tlink;
1150}
1151
Jeff Layton9d002df2010-10-06 19:51:11 -04001152extern void cifs_put_tlink(struct tcon_link *tlink);
Jeff Layton7ffec372010-09-29 19:51:11 -04001153
Jeff Layton13cfb732010-09-29 19:51:11 -04001154static inline struct tcon_link *
1155cifs_get_tlink(struct tcon_link *tlink)
1156{
Jeff Layton9d002df2010-10-06 19:51:11 -04001157 if (tlink && !IS_ERR(tlink))
1158 atomic_inc(&tlink->tl_count);
Jeff Layton13cfb732010-09-29 19:51:11 -04001159 return tlink;
1160}
1161
Jeff Layton7ffec372010-09-29 19:51:11 -04001162/* This function is always expected to succeed */
Steve French96daf2b2011-05-27 04:34:02 +00001163extern struct cifs_tcon *cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001164
Pavel Shilovsky233839b2012-09-19 06:22:45 -07001165#define CIFS_OPLOCK_NO_CHANGE 0xfe
1166
1167struct cifs_pending_open {
1168 struct list_head olist;
1169 struct tcon_link *tlink;
1170 __u8 lease_key[16];
1171 __u32 oplock;
1172};
1173
Rohith Surabattulac3f207a2021-04-13 00:26:42 -05001174struct cifs_deferred_close {
1175 struct list_head dlist;
1176 struct tcon_link *tlink;
1177 __u16 netfid;
1178 __u64 persistent_fid;
1179 __u64 volatile_fid;
1180};
1181
Jeff Layton7ffec372010-09-29 19:51:11 -04001182/*
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001183 * This info hangs off the cifsFileInfo structure, pointed to by llist.
1184 * This is used to track byte stream locks on the file
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185 */
1186struct cifsLockInfo {
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001187 struct list_head llist; /* pointer to next cifsLockInfo */
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001188 struct list_head blist; /* pointer to locks blocked on this */
1189 wait_queue_head_t block_q;
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001190 __u64 offset;
1191 __u64 length;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001192 __u32 pid;
Ronnie Sahlberg96457592018-10-04 09:24:38 +10001193 __u16 type;
1194 __u16 flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195};
1196
1197/*
1198 * One of these for each open instance of a file
1199 */
1200struct cifs_search_info {
1201 loff_t index_of_last_entry;
1202 __u16 entries_in_buffer;
1203 __u16 info_level;
1204 __u32 resume_key;
Steve Frenchd38d8c72007-06-28 19:44:13 +00001205 char *ntwrk_buf_start;
1206 char *srch_entries_start;
Steve French0752f152008-10-07 20:03:33 +00001207 char *last_entry;
Christoph Hellwigeaf35b12011-07-16 15:24:37 -04001208 const char *presume_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209 unsigned int resume_name_len;
Steve French4b18f2a2008-04-29 00:06:05 +00001210 bool endOfSearch:1;
1211 bool emptyDir:1;
1212 bool unicode:1;
1213 bool smallBuf:1; /* so we know which buf_release function to call */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214};
1215
Steve Frenchd0959b02019-10-05 10:53:58 -05001216#define ACL_NO_MODE ((umode_t)(-1))
Pavel Shilovsky226730b2013-07-05 12:00:30 +04001217struct cifs_open_parms {
1218 struct cifs_tcon *tcon;
1219 struct cifs_sb_info *cifs_sb;
1220 int disposition;
1221 int desired_access;
1222 int create_options;
1223 const char *path;
1224 struct cifs_fid *fid;
Steve Frenchce558b02018-05-31 19:16:54 -05001225 umode_t mode;
Pavel Shilovsky9cbc0b72013-07-09 18:40:58 +04001226 bool reconnect:1;
Pavel Shilovsky226730b2013-07-05 12:00:30 +04001227};
1228
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07001229struct cifs_fid {
1230 __u16 netfid;
Pavel Shilovskyf0df7372012-09-18 16:20:26 -07001231 __u64 persistent_fid; /* persist file id for smb2 */
1232 __u64 volatile_fid; /* volatile file id for smb2 */
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -07001233 __u8 lease_key[SMB2_LEASE_KEY_SIZE]; /* lease key for smb2 */
Steve Frenchb56eae42015-11-03 09:26:27 -06001234 __u8 create_guid[16];
Aurelien Aptel86f740f2020-02-21 11:19:06 +01001235 __u32 access;
Pavel Shilovsky233839b2012-09-19 06:22:45 -07001236 struct cifs_pending_open *pending_open;
Pavel Shilovsky42873b02013-09-05 21:30:16 +04001237 unsigned int epoch;
Steve Frenchdfe33f92018-10-30 19:50:31 -05001238#ifdef CONFIG_CIFS_DEBUG2
1239 __u64 mid;
1240#endif /* CIFS_DEBUG2 */
Pavel Shilovsky42873b02013-09-05 21:30:16 +04001241 bool purge_cache;
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07001242};
1243
Pavel Shilovskyf45d3412012-09-19 06:22:43 -07001244struct cifs_fid_locks {
1245 struct list_head llist;
1246 struct cifsFileInfo *cfile; /* fid that owns locks */
1247 struct list_head locks; /* locks held by fid above */
1248};
1249
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250struct cifsFileInfo {
Steve French3afca262016-09-22 18:58:16 -05001251 /* following two lists are protected by tcon->open_file_lock */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 struct list_head tlist; /* pointer to next fid owned by tcon */
1253 struct list_head flist; /* next fid (file instance) for this inode */
Steve French3afca262016-09-22 18:58:16 -05001254 /* lock list below protected by cifsi->lock_sem */
Pavel Shilovskyf45d3412012-09-19 06:22:43 -07001255 struct cifs_fid_locks *llist; /* brlocks held by this fid */
Eric W. Biedermanfef59fd2013-02-06 02:23:02 -08001256 kuid_t uid; /* allows finding which FileInfo structure */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 __u32 pid; /* process id who opened file */
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07001258 struct cifs_fid fid; /* file id from remote */
Pavel Shilovskyf2cca6a2016-10-07 17:26:36 -07001259 struct list_head rlist; /* reconnect list */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260 /* BB add lock scope info here if needed */ ;
1261 /* lock scope id (0 if none) */
Jeff Laytona5e18bc2010-10-11 15:07:18 -04001262 struct dentry *dentry;
Jeff Layton13cfb732010-09-29 19:51:11 -04001263 struct tcon_link *tlink;
Steve French3afca262016-09-22 18:58:16 -05001264 unsigned int f_flags;
Steve French4b18f2a2008-04-29 00:06:05 +00001265 bool invalidHandle:1; /* file closed via session abend */
Steve French4e8aea32020-04-09 21:42:18 -05001266 bool swapfile:1;
Jeff Layton3bc303c2009-09-21 06:47:50 -04001267 bool oplock_break_cancelled:1;
Pavel Shilovsky9bd45402019-10-29 16:51:19 -07001268 unsigned int oplock_epoch; /* epoch from the lease break */
1269 __u32 oplock_level; /* oplock/lease level from the lease break */
Steve French3afca262016-09-22 18:58:16 -05001270 int count;
1271 spinlock_t file_info_lock; /* protects four flag/count fields above */
Steve Frencha6ce4932009-04-09 01:14:32 +00001272 struct mutex fh_mutex; /* prevents reopen race after dead ses*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273 struct cifs_search_info srch_inf;
Tejun Heo9b646972010-07-20 22:09:02 +02001274 struct work_struct oplock_break; /* work for oplock breaks */
Ronnie Sahlberg32546a92019-11-03 13:06:37 +10001275 struct work_struct put; /* work for the final part of _put */
Rohith Surabattulac3f207a2021-04-13 00:26:42 -05001276 struct delayed_work deferred;
Rohith Surabattula860b69a2021-05-05 10:56:47 +00001277 bool deferred_close_scheduled; /* Flag to indicate close is scheduled */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278};
1279
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001280struct cifs_io_parms {
1281 __u16 netfid;
Pavel Shilovsky09a47072012-09-18 16:20:29 -07001282 __u64 persistent_fid; /* persist file id for smb2 */
1283 __u64 volatile_fid; /* volatile file id for smb2 */
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001284 __u32 pid;
1285 __u64 offset;
1286 unsigned int length;
Steve French96daf2b2011-05-27 04:34:02 +00001287 struct cifs_tcon *tcon;
Aurelien Aptel352d96f2020-05-31 12:38:22 -05001288 struct TCP_Server_Info *server;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001289};
1290
Pavel Shilovskyccf7f402017-04-25 11:52:29 -07001291struct cifs_aio_ctx {
1292 struct kref refcount;
1293 struct list_head list;
1294 struct mutex aio_mutex;
1295 struct completion done;
1296 struct iov_iter iter;
1297 struct kiocb *iocb;
1298 struct cifsFileInfo *cfile;
1299 struct bio_vec *bv;
Pavel Shilovskyc610c4b2017-04-25 11:52:31 -07001300 loff_t pos;
Pavel Shilovskyccf7f402017-04-25 11:52:29 -07001301 unsigned int npages;
1302 ssize_t rc;
1303 unsigned int len;
1304 unsigned int total_len;
1305 bool should_dirty;
Long Li6e6e2b82018-10-31 22:13:09 +00001306 /*
1307 * Indicates if this aio_ctx is for direct_io,
1308 * If yes, iter is a copy of the user passed iov_iter
1309 */
1310 bool direct_io;
Pavel Shilovskyccf7f402017-04-25 11:52:29 -07001311};
1312
Pavel Shilovsky09a47072012-09-18 16:20:29 -07001313/* asynchronous read support */
1314struct cifs_readdata {
1315 struct kref refcount;
1316 struct list_head list;
1317 struct completion done;
1318 struct cifsFileInfo *cfile;
1319 struct address_space *mapping;
Pavel Shilovsky6685c5e2017-04-25 11:52:30 -07001320 struct cifs_aio_ctx *ctx;
Pavel Shilovsky09a47072012-09-18 16:20:29 -07001321 __u64 offset;
1322 unsigned int bytes;
Pavel Shilovsky34a54d62014-07-10 10:03:29 +04001323 unsigned int got_bytes;
Pavel Shilovsky09a47072012-09-18 16:20:29 -07001324 pid_t pid;
1325 int result;
Pavel Shilovsky09a47072012-09-18 16:20:29 -07001326 struct work_struct work;
Jeff Layton8321fec2012-09-19 06:22:32 -07001327 int (*read_into_pages)(struct TCP_Server_Info *server,
1328 struct cifs_readdata *rdata,
1329 unsigned int len);
Pavel Shilovskyd70b9102016-11-17 16:20:18 -08001330 int (*copy_into_pages)(struct TCP_Server_Info *server,
1331 struct cifs_readdata *rdata,
1332 struct iov_iter *iter);
Pavel Shilovsky738f9de2016-11-23 15:14:57 -08001333 struct kvec iov[2];
Aurelien Aptel352d96f2020-05-31 12:38:22 -05001334 struct TCP_Server_Info *server;
Long Li74dcf412017-11-22 17:38:46 -07001335#ifdef CONFIG_CIFS_SMB_DIRECT
1336 struct smbd_mr *mr;
1337#endif
Jeff Layton8321fec2012-09-19 06:22:32 -07001338 unsigned int pagesz;
Long Li57a929a2018-05-30 12:47:53 -07001339 unsigned int page_offset;
Jeff Layton8321fec2012-09-19 06:22:32 -07001340 unsigned int tailsz;
Pavel Shilovsky335b7b62019-01-16 11:12:41 -08001341 struct cifs_credits credits;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07001342 unsigned int nr_pages;
Long Lif9f5aca2018-05-30 12:47:54 -07001343 struct page **pages;
Pavel Shilovsky09a47072012-09-18 16:20:29 -07001344};
1345
Pavel Shilovsky33319142012-09-18 16:20:29 -07001346/* asynchronous write support */
1347struct cifs_writedata {
1348 struct kref refcount;
1349 struct list_head list;
1350 struct completion done;
1351 enum writeback_sync_modes sync_mode;
1352 struct work_struct work;
1353 struct cifsFileInfo *cfile;
Pavel Shilovskyc610c4b2017-04-25 11:52:31 -07001354 struct cifs_aio_ctx *ctx;
Pavel Shilovsky33319142012-09-18 16:20:29 -07001355 __u64 offset;
1356 pid_t pid;
1357 unsigned int bytes;
1358 int result;
Aurelien Aptel352d96f2020-05-31 12:38:22 -05001359 struct TCP_Server_Info *server;
Long Lidb223a52017-11-22 17:38:45 -07001360#ifdef CONFIG_CIFS_SMB_DIRECT
1361 struct smbd_mr *mr;
1362#endif
Jeff Laytoneddb0792012-09-18 16:20:35 -07001363 unsigned int pagesz;
Long Li57a929a2018-05-30 12:47:53 -07001364 unsigned int page_offset;
Jeff Laytoneddb0792012-09-18 16:20:35 -07001365 unsigned int tailsz;
Pavel Shilovsky335b7b62019-01-16 11:12:41 -08001366 struct cifs_credits credits;
Pavel Shilovsky33319142012-09-18 16:20:29 -07001367 unsigned int nr_pages;
Long Li8e7360f2018-05-30 12:47:56 -07001368 struct page **pages;
Pavel Shilovsky33319142012-09-18 16:20:29 -07001369};
1370
Jeff Layton5f6dbc92010-10-15 15:34:06 -04001371/*
1372 * Take a reference on the file private data. Must be called with
Steve French3afca262016-09-22 18:58:16 -05001373 * cfile->file_info_lock held.
Jeff Layton5f6dbc92010-10-15 15:34:06 -04001374 */
Jeff Layton764a1b12012-07-25 14:59:54 -04001375static inline void
1376cifsFileInfo_get_locked(struct cifsFileInfo *cifs_file)
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001377{
Jeff Layton5f6dbc92010-10-15 15:34:06 -04001378 ++cifs_file->count;
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001379}
1380
Jeff Layton764a1b12012-07-25 14:59:54 -04001381struct cifsFileInfo *cifsFileInfo_get(struct cifsFileInfo *cifs_file);
Ronnie Sahlberg32546a92019-11-03 13:06:37 +10001382void _cifsFileInfo_put(struct cifsFileInfo *cifs_file, bool wait_oplock_hdlr,
1383 bool offload);
Jeff Laytonb33879a2010-10-15 15:34:04 -04001384void cifsFileInfo_put(struct cifsFileInfo *cifs_file);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001385
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04001386#define CIFS_CACHE_READ_FLG 1
1387#define CIFS_CACHE_HANDLE_FLG 2
Pavel Shilovsky42873b02013-09-05 21:30:16 +04001388#define CIFS_CACHE_RH_FLG (CIFS_CACHE_READ_FLG | CIFS_CACHE_HANDLE_FLG)
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04001389#define CIFS_CACHE_WRITE_FLG 4
Pavel Shilovsky42873b02013-09-05 21:30:16 +04001390#define CIFS_CACHE_RW_FLG (CIFS_CACHE_READ_FLG | CIFS_CACHE_WRITE_FLG)
1391#define CIFS_CACHE_RHW_FLG (CIFS_CACHE_RW_FLG | CIFS_CACHE_HANDLE_FLG)
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04001392
Steve French83bbfa72019-08-27 23:58:54 -05001393#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))
Pavel Shilovsky53ef1012013-09-05 16:11:28 +04001394#define CIFS_CACHE_HANDLE(cinode) (cinode->oplock & CIFS_CACHE_HANDLE_FLG)
Steve French41e033f2019-08-30 02:12:41 -05001395#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))
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04001396
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397/*
1398 * One of these for each file inode
1399 */
1400
1401struct cifsInodeInfo {
Pavel Shilovskyd59dad22011-09-22 09:53:59 +04001402 bool can_cache_brlcks;
Pavel Shilovskyf45d3412012-09-19 06:22:43 -07001403 struct list_head llist; /* locks helb by this inode */
Dave Wysochanskid46b0da2019-10-23 05:02:33 -04001404 /*
1405 * NOTE: Some code paths call down_read(lock_sem) twice, so
Randy Dunlapa03f5072020-07-19 17:13:16 -07001406 * we must always use cifs_down_write() instead of down_write()
Dave Wysochanskid46b0da2019-10-23 05:02:33 -04001407 * for this semaphore to avoid deadlocks.
1408 */
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -07001409 struct rw_semaphore lock_sem; /* protect the fields above */
Steve Frenchd38d8c72007-06-28 19:44:13 +00001410 /* BB add in lists for dirty pages i.e. write caching info for oplock */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411 struct list_head openFileList;
Ronnie Sahlberg487317c2019-06-05 10:38:38 +10001412 spinlock_t open_file_lock; /* protects openFileList */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 __u32 cifsAttrs; /* e.g. DOS archive bit, sparse, compressed, system */
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04001414 unsigned int oplock; /* oplock/lease level we have */
Pavel Shilovsky42873b02013-09-05 21:30:16 +04001415 unsigned int epoch; /* used to track lease state changes */
Sachin Prabhuc11f1df2014-03-11 16:11:47 +00001416#define CIFS_INODE_PENDING_OPLOCK_BREAK (0) /* oplock break in progress */
1417#define CIFS_INODE_PENDING_WRITERS (1) /* Writes in progress */
Pavel Shilovsky9bd45402019-10-29 16:51:19 -07001418#define CIFS_INODE_FLAG_UNUSED (2) /* Unused flag */
Jeff Laytonaff8d5c2014-04-30 09:31:45 -04001419#define CIFS_INO_DELETE_PENDING (3) /* delete pending on server */
1420#define CIFS_INO_INVALID_MAPPING (4) /* pagecache is invalid */
Jeff Layton4f73c7d2014-04-30 09:31:47 -04001421#define CIFS_INO_LOCK (5) /* lock bit for synchronization */
Rohith Surabattulac3f207a2021-04-13 00:26:42 -05001422#define CIFS_INO_MODIFIED_ATTR (6) /* Indicate change in mtime/ctime */
Rohith Surabattula35866f32021-09-17 16:50:40 -05001423#define CIFS_INO_CLOSE_ON_LOCK (7) /* Not to defer the close when lock is set */
Jeff Laytonaff8d5c2014-04-30 09:31:45 -04001424 unsigned long flags;
Sachin Prabhuc11f1df2014-03-11 16:11:47 +00001425 spinlock_t writers_lock;
1426 unsigned int writers; /* Number of writers on this inode */
Jeff Laytonaae62fd2011-01-20 13:36:50 -05001427 unsigned long time; /* jiffies of last update of inode */
Jeff Layton597b0272012-03-23 14:40:56 -04001428 u64 server_eof; /* current file size on server -- protected by i_lock */
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001429 u64 uniqueid; /* server inode number */
Jeff Layton20054bd2011-01-07 11:30:27 -05001430 u64 createtime; /* creation time on server */
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -07001431 __u8 lease_key[SMB2_LEASE_KEY_SIZE]; /* lease key for this inode */
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +05301432#ifdef CONFIG_CIFS_FSCACHE
1433 struct fscache_cookie *fscache;
1434#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 struct inode vfs_inode;
Rohith Surabattulac3f207a2021-04-13 00:26:42 -05001436 struct list_head deferred_closes; /* list of deferred closes */
1437 spinlock_t deferred_lock; /* protection on deferred list */
Rohith Surabattula0ab95c22021-05-17 11:28:34 +00001438 bool lease_granted; /* Flag to indicate whether lease or oplock is granted. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439};
1440
1441static inline struct cifsInodeInfo *
1442CIFS_I(struct inode *inode)
1443{
1444 return container_of(inode, struct cifsInodeInfo, vfs_inode);
1445}
1446
1447static inline struct cifs_sb_info *
1448CIFS_SB(struct super_block *sb)
1449{
1450 return sb->s_fs_info;
1451}
1452
Al Viro7119e222014-10-22 00:25:12 -04001453static inline struct cifs_sb_info *
1454CIFS_FILE_SB(struct file *file)
1455{
1456 return CIFS_SB(file_inode(file)->i_sb);
1457}
1458
Steve Frenchab2f2182005-09-15 20:44:50 -07001459static inline char CIFS_DIR_SEP(const struct cifs_sb_info *cifs_sb)
Jeremy Allisonac670552005-06-22 17:26:35 -07001460{
1461 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
1462 return '/';
1463 else
1464 return '\\';
1465}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466
Steve Frenchf87d39d2011-05-27 03:50:55 +00001467static inline void
1468convert_delimiter(char *path, char delim)
1469{
Steve French1cc9bd62012-11-29 18:07:51 -06001470 char old_delim, *pos;
Steve Frenchf87d39d2011-05-27 03:50:55 +00001471
1472 if (delim == '/')
1473 old_delim = '\\';
1474 else
1475 old_delim = '/';
1476
Steve French1cc9bd62012-11-29 18:07:51 -06001477 pos = path;
1478 while ((pos = strchr(pos, old_delim)))
1479 *pos = delim;
Steve Frenchf87d39d2011-05-27 03:50:55 +00001480}
1481
Steve Frencha4544342005-08-24 13:59:35 -07001482#define cifs_stats_inc atomic_inc
1483
Steve French96daf2b2011-05-27 04:34:02 +00001484static inline void cifs_stats_bytes_written(struct cifs_tcon *tcon,
Steve Frencha4544342005-08-24 13:59:35 -07001485 unsigned int bytes)
1486{
1487 if (bytes) {
1488 spin_lock(&tcon->stat_lock);
1489 tcon->bytes_written += bytes;
1490 spin_unlock(&tcon->stat_lock);
1491 }
1492}
1493
Steve French96daf2b2011-05-27 04:34:02 +00001494static inline void cifs_stats_bytes_read(struct cifs_tcon *tcon,
Steve Frencha4544342005-08-24 13:59:35 -07001495 unsigned int bytes)
1496{
1497 spin_lock(&tcon->stat_lock);
1498 tcon->bytes_read += bytes;
1499 spin_unlock(&tcon->stat_lock);
1500}
Steve Frencha4544342005-08-24 13:59:35 -07001501
Jeff Layton2b84a36c2011-01-11 07:24:21 -05001502
1503/*
Jeff Layton44d22d82011-10-19 15:29:49 -04001504 * This is the prototype for the mid receive function. This function is for
1505 * receiving the rest of the SMB frame, starting with the WordCount (which is
1506 * just after the MID in struct smb_hdr). Note:
1507 *
1508 * - This will be called by cifsd, with no locks held.
1509 * - The mid will still be on the pending_mid_q.
1510 * - mid->resp_buf will point to the current buffer.
1511 *
1512 * Returns zero on a successful receive, or an error. The receive state in
1513 * the TCP_Server_Info will also be updated.
1514 */
1515typedef int (mid_receive_t)(struct TCP_Server_Info *server,
1516 struct mid_q_entry *mid);
1517
1518/*
1519 * This is the prototype for the mid callback function. This is called once the
1520 * mid has been received off of the socket. When creating one, take special
1521 * care to avoid deadlocks. Things to bear in mind:
Jeff Layton2b84a36c2011-01-11 07:24:21 -05001522 *
Jeff Layton3c1105d2011-05-22 07:09:13 -04001523 * - it will be called by cifsd, with no locks held
1524 * - the mid will be removed from any lists
Jeff Layton2b84a36c2011-01-11 07:24:21 -05001525 */
1526typedef void (mid_callback_t)(struct mid_q_entry *mid);
1527
Pavel Shilovsky9b7c18a2016-11-16 14:06:17 -08001528/*
1529 * This is the protopyte for mid handle function. This is called once the mid
1530 * has been recognized after decryption of the message.
1531 */
1532typedef int (mid_handle_t)(struct TCP_Server_Info *server,
1533 struct mid_q_entry *mid);
1534
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535/* one of these for every pending CIFS request to the server */
1536struct mid_q_entry {
1537 struct list_head qhead; /* mids waiting on reply from this server */
Lars Persson696e4202018-06-25 14:05:25 +02001538 struct kref refcount;
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +04001539 struct TCP_Server_Info *server; /* server corresponding to this mid */
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001540 __u64 mid; /* multiplex id */
Pavel Shilovskyc781af72019-03-04 14:02:50 -08001541 __u16 credits; /* number of credits consumed by this mid */
Pavel Shilovsky86a79642019-11-21 11:35:13 -08001542 __u16 credits_received; /* number of credits from the response */
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001543 __u32 pid; /* process id */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544 __u32 sequence_number; /* for CIFS signing */
Steve French1047abc2005-10-11 19:58:06 -07001545 unsigned long when_alloc; /* when mid was created */
1546#ifdef CONFIG_CIFS_STATS2
1547 unsigned long when_sent; /* time when smb send finished */
1548 unsigned long when_received; /* when demux complete (taken off wire) */
1549#endif
Jeff Layton44d22d82011-10-19 15:29:49 -04001550 mid_receive_t *receive; /* call receive callback */
Jeff Layton2b84a36c2011-01-11 07:24:21 -05001551 mid_callback_t *callback; /* call completion callback */
Pavel Shilovsky9b7c18a2016-11-16 14:06:17 -08001552 mid_handle_t *handle; /* call handle mid callback */
Jeff Layton2b84a36c2011-01-11 07:24:21 -05001553 void *callback_data; /* general purpose pointer for callback */
Vincent Whitchurchf1f27ad2020-01-23 17:09:06 +01001554 struct task_struct *creator;
Pavel Shilovskyd4e48542012-03-23 14:28:02 -04001555 void *resp_buf; /* pointer to received SMB header */
Ronnie Sahlberge19b2bc2018-04-09 18:06:28 +10001556 unsigned int resp_buf_size;
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001557 int mid_state; /* wish this were enum but can not pass to wait_event */
Sachin Prabhu38bd4902017-03-03 15:41:38 -08001558 unsigned int mid_flags;
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001559 __le16 command; /* smb command code */
Pavel Shilovsky8a26f0f2019-01-03 16:45:27 -08001560 unsigned int optype; /* operation type */
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001561 bool large_buf:1; /* if valid response, is pointer to large buf */
Steve French4b18f2a2008-04-29 00:06:05 +00001562 bool multiRsp:1; /* multiple trans2 responses for one request */
1563 bool multiEnd:1; /* both received */
Pavel Shilovsky4326ed22016-11-17 15:24:46 -08001564 bool decrypted:1; /* decrypted entry */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565};
1566
Sachin Prabhu38bd4902017-03-03 15:41:38 -08001567struct close_cancelled_open {
1568 struct cifs_fid fid;
1569 struct cifs_tcon *tcon;
1570 struct work_struct work;
Ronnie Sahlberg87bc2372019-11-14 12:32:12 -06001571 __u64 mid;
1572 __u16 cmd;
Sachin Prabhu38bd4902017-03-03 15:41:38 -08001573};
1574
Steve French789e6662011-08-09 18:44:44 +00001575/* Make code in transport.c a little cleaner by moving
1576 update of optional stats into function below */
Steve French789e6662011-08-09 18:44:44 +00001577static inline void cifs_in_send_inc(struct TCP_Server_Info *server)
1578{
1579 atomic_inc(&server->in_send);
1580}
1581
1582static inline void cifs_in_send_dec(struct TCP_Server_Info *server)
1583{
1584 atomic_dec(&server->in_send);
1585}
1586
1587static inline void cifs_num_waiters_inc(struct TCP_Server_Info *server)
1588{
1589 atomic_inc(&server->num_waiters);
1590}
1591
1592static inline void cifs_num_waiters_dec(struct TCP_Server_Info *server)
1593{
1594 atomic_dec(&server->num_waiters);
1595}
1596
Steve French1ae9a5a2019-11-21 17:26:35 -06001597#ifdef CONFIG_CIFS_STATS2
Steve French789e6662011-08-09 18:44:44 +00001598static inline void cifs_save_when_sent(struct mid_q_entry *mid)
1599{
1600 mid->when_sent = jiffies;
1601}
1602#else
Steve French789e6662011-08-09 18:44:44 +00001603static inline void cifs_save_when_sent(struct mid_q_entry *mid)
1604{
1605}
1606#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607
Steve Frenchff5dbd92005-08-24 17:10:36 -07001608/* for pending dnotify requests */
1609struct dir_notify_req {
Steve French13cd4b72010-10-07 18:46:32 +00001610 struct list_head lhead;
1611 __le16 Pid;
1612 __le16 PidHigh;
1613 __u16 Mid;
1614 __u16 Tid;
1615 __u16 Uid;
1616 __u16 netfid;
1617 __u32 filter; /* CompletionFilter (for multishot) */
1618 int multishot;
1619 struct file *pfile;
Steve Frenchff5dbd92005-08-24 17:10:36 -07001620};
1621
Steve French366781c2008-01-25 10:12:41 +00001622struct dfs_info3_param {
1623 int flags; /* DFSREF_REFERRAL_SERVER, DFSREF_STORAGE_SERVER*/
Igor Mammedov8aad0182008-02-15 18:21:49 +00001624 int path_consumed;
Steve French366781c2008-01-25 10:12:41 +00001625 int server_type;
1626 int ref_flag;
1627 char *path_name;
1628 char *node_name;
Paulo Alcantarae7b602f2018-11-14 15:38:51 -02001629 int ttl;
Steve French366781c2008-01-25 10:12:41 +00001630};
1631
Rohith Surabattula9e992752021-08-09 09:32:46 +00001632struct file_list {
1633 struct list_head list;
1634 struct cifsFileInfo *cfile;
1635};
1636
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001637/*
1638 * common struct for holding inode info when searching for or updating an
1639 * inode with new info
1640 */
1641
1642#define CIFS_FATTR_DFS_REFERRAL 0x1
Jeff Layton0b8f18e2009-07-09 01:46:37 -04001643#define CIFS_FATTR_DELETE_PENDING 0x2
1644#define CIFS_FATTR_NEED_REVAL 0x4
Jeff Layton3d694382010-05-11 14:59:55 -04001645#define CIFS_FATTR_INO_COLLISION 0x8
Jim McDonough74d290d2013-09-21 10:36:10 -05001646#define CIFS_FATTR_UNKNOWN_NLINK 0x10
Steve French7ea884c2018-03-31 18:13:38 -05001647#define CIFS_FATTR_FAKE_ROOT_INO 0x20
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001648
1649struct cifs_fattr {
1650 u32 cf_flags;
1651 u32 cf_cifsattrs;
1652 u64 cf_uniqueid;
1653 u64 cf_eof;
1654 u64 cf_bytes;
Jeff Layton20054bd2011-01-07 11:30:27 -05001655 u64 cf_createtime;
Eric W. Biederman4a2c8cf2013-02-06 01:53:25 -08001656 kuid_t cf_uid;
1657 kgid_t cf_gid;
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001658 umode_t cf_mode;
1659 dev_t cf_rdev;
1660 unsigned int cf_nlink;
1661 unsigned int cf_dtype;
Arnd Bergmann95390202018-06-19 17:27:58 +02001662 struct timespec64 cf_atime;
1663 struct timespec64 cf_mtime;
1664 struct timespec64 cf_ctime;
Paulo Alcantara (SUSE)046aca32019-12-18 18:11:37 -03001665 u32 cf_cifstag;
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001666};
1667
Steve French366781c2008-01-25 10:12:41 +00001668static inline void free_dfs_info_param(struct dfs_info3_param *param)
1669{
1670 if (param) {
1671 kfree(param->path_name);
1672 kfree(param->node_name);
Steve French366781c2008-01-25 10:12:41 +00001673 }
1674}
1675
1676static inline void free_dfs_info_array(struct dfs_info3_param *param,
1677 int number_of_items)
1678{
1679 int i;
1680 if ((number_of_items == 0) || (param == NULL))
1681 return;
1682 for (i = 0; i < number_of_items; i++) {
1683 kfree(param[i].path_name);
1684 kfree(param[i].node_name);
1685 }
1686 kfree(param);
1687}
1688
Pavel Shilovsky9a663962019-01-08 11:15:28 -08001689static inline bool is_interrupt_error(int error)
1690{
1691 switch (error) {
1692 case -EINTR:
1693 case -ERESTARTSYS:
1694 case -ERESTARTNOHAND:
1695 case -ERESTARTNOINTR:
1696 return true;
1697 }
1698 return false;
1699}
1700
1701static inline bool is_retryable_error(int error)
1702{
1703 if (is_interrupt_error(error) || error == -EAGAIN)
1704 return true;
1705 return false;
1706}
1707
Aurelien Aptel86f740f2020-02-21 11:19:06 +01001708
1709/* cifs_get_writable_file() flags */
1710#define FIND_WR_ANY 0
1711#define FIND_WR_FSUID_ONLY 1
1712#define FIND_WR_WITH_DELETE 2
1713
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714#define MID_FREE 0
1715#define MID_REQUEST_ALLOCATED 1
1716#define MID_REQUEST_SUBMITTED 2
1717#define MID_RESPONSE_RECEIVED 4
1718#define MID_RETRY_NEEDED 8 /* session closed while this request out */
Jeff Layton71823ba2011-02-10 08:03:50 -05001719#define MID_RESPONSE_MALFORMED 0x10
Jeff Layton3c1105d2011-05-22 07:09:13 -04001720#define MID_SHUTDOWN 0x20
Steve Frenchec637e32005-12-12 20:53:18 -08001721
Sachin Prabhu38bd4902017-03-03 15:41:38 -08001722/* Flags */
1723#define MID_WAIT_CANCELLED 1 /* Cancelled while waiting for response */
Ronnie Sahlbergddf83af2018-08-30 10:12:59 +10001724#define MID_DELETED 2 /* Mid has been dequeued/deleted */
Sachin Prabhu38bd4902017-03-03 15:41:38 -08001725
Steve Frenchec637e32005-12-12 20:53:18 -08001726/* Types of response buffer returned from SendReceive2 */
1727#define CIFS_NO_BUFFER 0 /* Response buffer not returned */
1728#define CIFS_SMALL_BUFFER 1
1729#define CIFS_LARGE_BUFFER 2
1730#define CIFS_IOVEC 4 /* array of response buffers */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731
Steve French133672e2007-11-13 22:41:37 +00001732/* Type of Request to SendReceive2 */
Jeff Layton77499812011-01-11 07:24:23 -05001733#define CIFS_BLOCKING_OP 1 /* operation can block */
Ronnie Sahlberg392e1c52019-05-06 10:00:02 +10001734#define CIFS_NON_BLOCKING 2 /* do not block waiting for credits */
Jeff Layton77499812011-01-11 07:24:23 -05001735#define CIFS_TIMEOUT_MASK 0x003 /* only one of above set in req */
Steve French133672e2007-11-13 22:41:37 +00001736#define CIFS_LOG_ERROR 0x010 /* log NT STATUS if non-zero */
1737#define CIFS_LARGE_BUF_OP 0x020 /* large request buffer */
Ronnie Sahlberg392e1c52019-05-06 10:00:02 +10001738#define CIFS_NO_RSP_BUF 0x040 /* no response buffer required */
Steve French133672e2007-11-13 22:41:37 +00001739
Pavel Shilovskya891f0f2012-05-23 16:14:34 +04001740/* Type of request operation */
Paulo Alcantara04ad69c2021-03-08 12:00:50 -03001741#define CIFS_ECHO_OP 0x080 /* echo request */
1742#define CIFS_OBREAK_OP 0x0100 /* oplock break request */
1743#define CIFS_NEG_OP 0x0200 /* negotiate request */
1744#define CIFS_CP_CREATE_CLOSE_OP 0x0400 /* compound create+close request */
Shyam Prasad N0f56db82021-02-03 22:49:52 -08001745/* Lower bitmask values are reserved by others below. */
Paulo Alcantara04ad69c2021-03-08 12:00:50 -03001746#define CIFS_SESS_OP 0x2000 /* session setup request */
1747#define CIFS_OP_MASK 0x2780 /* mask request type */
Pavel Shilovsky7fb89862016-10-31 13:49:30 -07001748
Paulo Alcantara04ad69c2021-03-08 12:00:50 -03001749#define CIFS_HAS_CREDITS 0x0400 /* already has credits */
1750#define CIFS_TRANSFORM_REQ 0x0800 /* transform request before sending */
1751#define CIFS_NO_SRV_RSP 0x1000 /* there is no server response */
Pavel Shilovskya891f0f2012-05-23 16:14:34 +04001752
Steve French39798772006-05-31 22:40:51 +00001753/* Security Flags: indicate type of session setup needed */
1754#define CIFSSEC_MAY_SIGN 0x00001
Steve French39798772006-05-31 22:40:51 +00001755#define CIFSSEC_MAY_NTLMV2 0x00004
1756#define CIFSSEC_MAY_KRB5 0x00008
Steve French39798772006-05-31 22:40:51 +00001757#define CIFSSEC_MAY_SEAL 0x00040 /* not supported yet */
Steve Frenchac683922009-05-06 04:16:04 +00001758#define CIFSSEC_MAY_NTLMSSP 0x00080 /* raw ntlmssp with ntlmv2 */
Steve French5815449d2006-02-14 01:36:20 +00001759
Steve French39798772006-05-31 22:40:51 +00001760#define CIFSSEC_MUST_SIGN 0x01001
1761/* note that only one of the following can be set so the
1762result of setting MUST flags more than once will be to
1763require use of the stronger protocol */
Steve French39798772006-05-31 22:40:51 +00001764#define CIFSSEC_MUST_NTLMV2 0x04004
1765#define CIFSSEC_MUST_KRB5 0x08008
Jeff Layton0d3a01f2007-10-16 17:32:19 +00001766#ifdef CONFIG_CIFS_UPCALL
Steve Frenchac683922009-05-06 04:16:04 +00001767#define CIFSSEC_MASK 0x8F08F /* flags supported if no weak allowed */
Jeff Layton0d3a01f2007-10-16 17:32:19 +00001768#else
Steve Frenchac683922009-05-06 04:16:04 +00001769#define CIFSSEC_MASK 0x87087 /* flags supported if no weak allowed */
Steve French016ec752007-10-16 18:10:10 +00001770#endif /* UPCALL */
Steve French39798772006-05-31 22:40:51 +00001771#define CIFSSEC_MUST_SEAL 0x40040 /* not supported yet */
Steve Frenchac683922009-05-06 04:16:04 +00001772#define CIFSSEC_MUST_NTLMSSP 0x80080 /* raw ntlmssp with ntlmv2 */
Steve French39798772006-05-31 22:40:51 +00001773
Jeff Layton896a8fc2013-05-26 07:01:01 -04001774#define CIFSSEC_DEF (CIFSSEC_MAY_SIGN | CIFSSEC_MAY_NTLMV2 | CIFSSEC_MAY_NTLMSSP)
Ronnie Sahlberg76a3c922021-08-19 20:34:58 +10001775#define CIFSSEC_MAX (CIFSSEC_MUST_NTLMV2)
1776#define CIFSSEC_AUTH_MASK (CIFSSEC_MAY_NTLMV2 | CIFSSEC_MAY_KRB5 | CIFSSEC_MAY_NTLMSSP)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777/*
1778 *****************************************************************
1779 * All constants go here
1780 *****************************************************************
1781 */
1782
1783#define UID_HASH (16)
1784
1785/*
1786 * Note that ONE module should define _DECLARE_GLOBALS_HERE to cause the
1787 * following to be declared.
1788 */
1789
1790/****************************************************************************
1791 * Locking notes. All updates to global variables and lists should be
1792 * protected by spinlocks or semaphores.
1793 *
1794 * Spinlocks
1795 * ---------
1796 * GlobalMid_Lock protects:
1797 * list operations on pending_mid_q and oplockQ
1798 * updates to XID counters, multiplex id and SMB sequence numbers
Steve French65525802019-03-13 18:21:38 -05001799 * list operations on global DnotifyReqList
Steve French01cf3082021-07-01 12:22:47 -05001800 * updates to ses->status and TCP_Server_Info->tcpStatus
Steve French0fa757b2021-06-25 13:54:32 -05001801 * updates to server->CurrentMid
Steve French3afca262016-09-22 18:58:16 -05001802 * tcp_ses_lock protects:
1803 * list operations on tcp and SMB session lists
1804 * tcon->open_file_lock protects the list of open files hanging off the tcon
Ronnie Sahlberg487317c2019-06-05 10:38:38 +10001805 * inode->open_file_lock protects the openFileList hanging off the inode
Steve French3afca262016-09-22 18:58:16 -05001806 * cfile->file_info_lock protects counters and fields in cifs file struct
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807 * f_owner.lock protects certain per file struct operations
1808 * mapping->page_lock protects certain per page operations
1809 *
Ronnie Sahlberg487317c2019-06-05 10:38:38 +10001810 * Note that the cifs_tcon.open_file_lock should be taken before
1811 * not after the cifsInodeInfo.open_file_lock
1812 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 * Semaphores
1814 * ----------
Steve Frenchedc9dd12021-04-09 14:49:15 -05001815 * cifsInodeInfo->lock_sem protects:
1816 * the list of locks held by the inode
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817 *
1818 ****************************************************************************/
1819
1820#ifdef DECLARE_GLOBALS_HERE
1821#define GLOBAL_EXTERN
1822#else
1823#define GLOBAL_EXTERN extern
1824#endif
1825
Jeff Laytone7ddee92008-11-14 13:44:38 -05001826/*
1827 * the list of TCP_Server_Info structures, ie each of the sockets
Steve Frenchfb396012008-11-13 20:04:07 +00001828 * connecting our client to a distinct server (ip address), is
Jeff Laytone7ddee92008-11-14 13:44:38 -05001829 * chained together by cifs_tcp_ses_list. The list of all our SMB
Steve Frenchfb396012008-11-13 20:04:07 +00001830 * sessions (and from that the tree connections) can be found
Jeff Laytone7ddee92008-11-14 13:44:38 -05001831 * by iterating over cifs_tcp_ses_list
1832 */
1833GLOBAL_EXTERN struct list_head cifs_tcp_ses_list;
1834
Jeff Laytonf1987b42008-11-15 11:12:47 -05001835/*
1836 * This lock protects the cifs_tcp_ses_list, the list of smb sessions per
1837 * tcp session, and the list of tcon's per smb session. It also protects
Steve Frenchd92c7ce2020-04-21 23:51:18 -05001838 * the reference counters for the server, smb session, and tcon. It also
1839 * protects some fields in the TCP_Server_Info struct such as dstaddr. Finally,
Jeff Laytonf1987b42008-11-15 11:12:47 -05001840 * changes to the tcon->tidStatus should be done while holding this lock.
Steve French3afca262016-09-22 18:58:16 -05001841 * generally the locks should be taken in order tcp_ses_lock before
1842 * tcon->open_file_lock and that before file->file_info_lock since the
1843 * structure order is cifs_socket-->cifs_ses-->cifs_tcon-->cifs_file
Jeff Laytonf1987b42008-11-15 11:12:47 -05001844 */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301845GLOBAL_EXTERN spinlock_t cifs_tcp_ses_lock;
Steve Frenchddb4cbf2008-11-20 20:00:44 +00001846
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847/*
1848 * Global transaction id (XID) information
1849 */
1850GLOBAL_EXTERN unsigned int GlobalCurrentXid; /* protected by GlobalMid_Sem */
Steve French254e55e2006-06-04 05:53:15 +00001851GLOBAL_EXTERN unsigned int GlobalTotalActiveXid; /* prot by GlobalMid_Sem */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852GLOBAL_EXTERN unsigned int GlobalMaxActiveXid; /* prot by GlobalMid_Sem */
Steve French254e55e2006-06-04 05:53:15 +00001853GLOBAL_EXTERN spinlock_t GlobalMid_Lock; /* protects above & list operations */
1854 /* on midQ entries */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855/*
1856 * Global counters, updated atomically
1857 */
1858GLOBAL_EXTERN atomic_t sesInfoAllocCount;
1859GLOBAL_EXTERN atomic_t tconInfoAllocCount;
Shyam Prasad N6d82c272021-02-03 23:20:46 -08001860GLOBAL_EXTERN atomic_t tcpSesNextId;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861GLOBAL_EXTERN atomic_t tcpSesAllocCount;
1862GLOBAL_EXTERN atomic_t tcpSesReconnectCount;
1863GLOBAL_EXTERN atomic_t tconInfoReconnectCount;
1864
Steve Frenchaaa9bbe2008-05-23 17:38:32 +00001865/* Various Debug counters */
Steve French4498eed52005-12-03 13:58:57 -08001866GLOBAL_EXTERN atomic_t bufAllocCount; /* current number allocated */
1867#ifdef CONFIG_CIFS_STATS2
1868GLOBAL_EXTERN atomic_t totBufAllocCount; /* total allocated over all time */
1869GLOBAL_EXTERN atomic_t totSmBufAllocCount;
Steve French00778e22018-09-18 14:05:18 -05001870extern unsigned int slow_rsp_threshold; /* number of secs before logging */
Steve French4498eed52005-12-03 13:58:57 -08001871#endif
1872GLOBAL_EXTERN atomic_t smBufAllocCount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873GLOBAL_EXTERN atomic_t midCount;
1874
1875/* Misc globals */
Steve Frenchf92a7202018-05-24 04:11:07 -05001876extern bool enable_oplocks; /* enable or disable oplocks */
1877extern bool lookupCacheEnabled;
1878extern unsigned int global_secflags; /* if on, session setup sent
Linus Torvalds1da177e2005-04-16 15:20:36 -07001879 with more secure ntlmssp2 challenge/resp */
Steve Frenchf92a7202018-05-24 04:11:07 -05001880extern unsigned int sign_CIFS_PDUs; /* enable smb packet signing */
Steve French29e27922020-10-14 20:24:09 -05001881extern bool enable_gcm_256; /* allow optional negotiate of strongest signing (aes-gcm-256) */
Steve Frenchfbfd0b42020-09-11 16:19:28 -05001882extern bool require_gcm_256; /* require use of strongest signing (aes-gcm-256) */
Steve French53d31a32021-07-05 15:05:39 -05001883extern bool enable_negotiate_signing; /* request use of faster (GMAC) signing if available */
Steve Frenchf92a7202018-05-24 04:11:07 -05001884extern bool linuxExtEnabled;/*enable Linux/Unix CIFS extensions*/
1885extern unsigned int CIFSMaxBufSize; /* max size not including hdr */
1886extern unsigned int cifs_min_rcv; /* min size of big ntwrk buf pool */
1887extern unsigned int cifs_min_small; /* min size of small buf pool */
1888extern unsigned int cifs_max_pending; /* MAX requests at once to server*/
1889extern bool disable_legacy_dialects; /* forbid vers=1.0 and vers=2.0 mounts */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890
Tejun Heo9b646972010-07-20 22:09:02 +02001891void cifs_oplock_break(struct work_struct *work);
Aurelien Aptelb98749c2019-03-29 10:49:12 +01001892void cifs_queue_oplock_break(struct cifsFileInfo *cfile);
Rohith Surabattulac3f207a2021-04-13 00:26:42 -05001893void smb2_deferred_work_close(struct work_struct *work);
Linus Torvalds3b7433b2010-08-07 12:42:58 -07001894
Rohith Surabattulac3f207a2021-04-13 00:26:42 -05001895extern const struct slow_work_ops cifs_oplock_break_ops;
Jeff Laytonda472fc2012-03-23 14:40:53 -04001896extern struct workqueue_struct *cifsiod_wq;
Steve French35cf94a2019-09-07 01:09:49 -05001897extern struct workqueue_struct *decrypt_wq;
Ronnie Sahlberg32546a92019-11-03 13:06:37 +10001898extern struct workqueue_struct *fileinfo_put_wq;
Rabin Vincent3998e6b82017-05-03 17:54:01 +02001899extern struct workqueue_struct *cifsoplockd_wq;
Rohith Surabattulac3f207a2021-04-13 00:26:42 -05001900extern struct workqueue_struct *deferredclose_wq;
Jeff Layton3d224622016-05-24 06:27:44 -04001901extern __u32 cifs_lock_secret;
Suresh Jayaramanabd2e442010-06-22 20:52:50 +05301902
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +04001903extern mempool_t *cifs_mid_poolp;
1904
Jeff Layton23db65f2012-05-15 12:20:51 -04001905/* Operations for different SMB versions */
1906#define SMB1_VERSION_STRING "1.0"
1907extern struct smb_version_operations smb1_operations;
1908extern struct smb_version_values smb1_values;
Steve Frenche4aa25e2012-10-01 12:26:22 -05001909#define SMB20_VERSION_STRING "2.0"
Pavel Shilovsky53ef1012013-09-05 16:11:28 +04001910extern struct smb_version_operations smb20_operations;
Steve Frenche4aa25e2012-10-01 12:26:22 -05001911extern struct smb_version_values smb20_values;
Steve French1080ef72011-02-24 18:07:19 +00001912#define SMB21_VERSION_STRING "2.1"
1913extern struct smb_version_operations smb21_operations;
1914extern struct smb_version_values smb21_values;
Steve French9764c022017-09-17 10:41:35 -05001915#define SMBDEFAULT_VERSION_STRING "default"
1916extern struct smb_version_values smbdefault_values;
1917#define SMB3ANY_VERSION_STRING "3"
1918extern struct smb_version_values smb3any_values;
Steve Frenche4aa25e2012-10-01 12:26:22 -05001919#define SMB30_VERSION_STRING "3.0"
Steve French38107d42012-12-08 22:08:06 -06001920extern struct smb_version_operations smb30_operations;
Steve Frenche4aa25e2012-10-01 12:26:22 -05001921extern struct smb_version_values smb30_values;
Steve French20b6d8b2013-06-12 22:48:41 -05001922#define SMB302_VERSION_STRING "3.02"
Kenneth D'souza4a3b38a2018-11-17 10:33:30 +05301923#define ALT_SMB302_VERSION_STRING "3.0.2"
Steve French20b6d8b2013-06-12 22:48:41 -05001924/*extern struct smb_version_operations smb302_operations;*/ /* not needed yet */
1925extern struct smb_version_values smb302_values;
Steve French5f7fbf72014-12-17 22:52:58 -06001926#define SMB311_VERSION_STRING "3.1.1"
Steve Frenchaab18932015-06-23 23:37:11 -05001927#define ALT_SMB311_VERSION_STRING "3.11"
1928extern struct smb_version_operations smb311_operations;
Steve French5f7fbf72014-12-17 22:52:58 -06001929extern struct smb_version_values smb311_values;
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +01001930
Kenneth D'souza0b0430c2020-06-09 10:12:10 +05301931static inline char *get_security_type_str(enum securityEnum sectype)
1932{
1933 switch (sectype) {
1934 case RawNTLMSSP:
1935 return "RawNTLMSSP";
1936 case Kerberos:
1937 return "Kerberos";
1938 case NTLMv2:
1939 return "NTLMv2";
Kenneth D'souza0b0430c2020-06-09 10:12:10 +05301940 default:
1941 return "Unknown";
1942 }
1943}
1944
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +01001945static inline bool is_smb1_server(struct TCP_Server_Info *server)
1946{
1947 return strcmp(server->vals->version_string, SMB1_VERSION_STRING) == 0;
1948}
1949
Paulo Alcantarae1837852020-08-27 11:20:19 -03001950static inline bool is_tcon_dfs(struct cifs_tcon *tcon)
1951{
1952 /*
1953 * For SMB1, see MS-CIFS 2.4.55 SMB_COM_TREE_CONNECT_ANDX (0x75) and MS-CIFS 3.3.4.4 DFS
1954 * Subsystem Notifies That a Share Is a DFS Share.
1955 *
1956 * For SMB2+, see MS-SMB2 2.2.10 SMB2 TREE_CONNECT Response and MS-SMB2 3.3.4.14 Server
1957 * Application Updates a Share.
1958 */
1959 if (!tcon || !tcon->ses || !tcon->ses->server)
1960 return false;
1961 return is_smb1_server(tcon->ses->server) ? tcon->Flags & SMB_SHARE_IS_IN_DFS :
1962 tcon->share_flags & (SHI1005_FLAGS_DFS | SHI1005_FLAGS_DFS_ROOT);
1963}
1964
Paulo Alcantarac88f7dc2021-11-03 13:53:29 -03001965static inline bool cifs_is_referral_server(struct cifs_tcon *tcon,
1966 const struct dfs_info3_param *ref)
1967{
1968 /*
1969 * Check if all targets are capable of handling DFS referrals as per
1970 * MS-DFSC 2.2.4 RESP_GET_DFS_REFERRAL.
1971 */
1972 return is_tcon_dfs(tcon) || (ref && (ref->flags & DFSREF_REFERRAL_SERVER));
1973}
1974
Suresh Jayaramanabd2e442010-06-22 20:52:50 +05301975#endif /* _CIFS_GLOB_H */