blob: bba106cdc43c4c5703568ac82016714983e1d7bc [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/cifsglob.h
3 *
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 *
8 * This library is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License as published
10 * by the Free Software Foundation; either version 2.1 of the License, or
11 * (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
16 * the GNU Lesser General Public License for more details.
Steve Frenchd38d8c72007-06-28 19:44:13 +000017 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 */
Suresh Jayaramanabd2e442010-06-22 20:52:50 +053019#ifndef _CIFS_GLOB_H
20#define _CIFS_GLOB_H
21
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/in.h>
23#include <linux/in6.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090024#include <linux/slab.h>
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +040025#include <linux/mempool.h>
Tejun Heo9b646972010-07-20 22:09:02 +020026#include <linux/workqueue.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include "cifs_fs_sb.h"
Steve French442aa312007-09-24 20:25:46 +000028#include "cifsacl.h"
Shirish Pargaonkard2b91522010-10-21 14:25:08 -050029#include <crypto/internal/hash.h>
30#include <linux/scatterlist.h>
Scott Lovenberg8c3a2b42013-08-09 08:47:17 -040031#include <uapi/linux/cifs/cifs_mount.h>
Pavel Shilovskyd60622e2012-05-28 15:19:39 +040032#ifdef CONFIG_CIFS_SMB2
33#include "smb2pdu.h"
34#endif
Shirish Pargaonkard2b91522010-10-21 14:25:08 -050035
Pavel Shilovsky76ec5e32012-09-18 16:20:33 -070036#define CIFS_MAGIC_NUMBER 0xFF534D42 /* the first four bytes of SMB PDUs */
37
Linus Torvalds1da177e2005-04-16 15:20:36 -070038/*
39 * The sizes of various internal tables and strings
40 */
41#define MAX_UID_INFO 16
42#define MAX_SES_INFO 2
43#define MAX_TCON_INFO 4
44
Scott Lovenbergcdf12462013-08-09 08:47:19 -040045#define MAX_TREE_SIZE (2 + CIFS_NI_MAXHOST + 1 + CIFS_MAX_SHARE_LEN + 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
47#define CIFS_MIN_RCV_POOL 4
48
Shirish Pargaonkar2c0c2a02012-05-21 09:20:12 -050049#define MAX_REOPEN_ATT 5 /* these many maximum attempts to reopen a file */
Linus Torvalds1da177e2005-04-16 15:20:36 -070050/*
Suresh Jayaraman6d20e842010-12-01 14:42:28 +053051 * default attribute cache timeout (jiffies)
52 */
53#define CIFS_DEF_ACTIMEO (1 * HZ)
54
55/*
56 * max attribute cache timeout (jiffies) - 2^30
57 */
58#define CIFS_MAX_ACTIMEO (1 << 30)
59
60/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 * MAX_REQ is the maximum number of requests that WE will send
Pavel Shilovsky10b9b982012-03-20 12:55:09 +030062 * on one socket concurrently.
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 */
Pavel Shilovsky10b9b982012-03-20 12:55:09 +030064#define CIFS_MAX_REQ 32767
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
Jeff Layton8ecaf672008-12-01 15:23:50 -050066#define RFC1001_NAME_LEN 15
67#define RFC1001_NAME_LEN_WITH_NULL (RFC1001_NAME_LEN + 1)
68
69/* currently length of NIP6_FMT */
70#define SERVER_NAME_LENGTH 40
Linus Torvalds1da177e2005-04-16 15:20:36 -070071#define SERVER_NAME_LEN_WITH_NULL (SERVER_NAME_LENGTH + 1)
72
Steve Frenchadfeb3e2015-12-18 12:31:36 -060073/* echo interval in seconds */
74#define SMB_ECHO_INTERVAL_MIN 1
75#define SMB_ECHO_INTERVAL_MAX 600
76#define SMB_ECHO_INTERVAL_DEFAULT 60
Pavel Shilovsky9094fad2012-07-12 18:30:44 +040077
Linus Torvalds1da177e2005-04-16 15:20:36 -070078#include "cifspdu.h"
79
Linus Torvalds1da177e2005-04-16 15:20:36 -070080#ifndef XATTR_DOS_ATTRIB
81#define XATTR_DOS_ATTRIB "user.DOSATTRIB"
82#endif
83
84/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070085 * CIFS vfs client Status information (based on what we know.)
86 */
87
Steve French6c0f6212010-10-23 16:51:40 +000088/* associated with each tcp and smb session */
Linus Torvalds1da177e2005-04-16 15:20:36 -070089enum statusEnum {
90 CifsNew = 0,
91 CifsGood,
92 CifsExiting,
Steve Frenchfd88ce92011-04-12 01:01:14 +000093 CifsNeedReconnect,
94 CifsNeedNegotiate
Linus Torvalds1da177e2005-04-16 15:20:36 -070095};
96
97enum securityEnum {
Jeff Layton515d82f2013-05-26 07:00:58 -040098 Unspecified = 0, /* not specified */
99 LANMAN, /* Legacy LANMAN auth */
Steve French39798772006-05-31 22:40:51 +0000100 NTLM, /* Legacy NTLM012 auth with NTLM hash */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 NTLMv2, /* Legacy NTLM auth with NTLMv2 hash */
Steve Frenchac683922009-05-06 04:16:04 +0000102 RawNTLMSSP, /* NTLMSSP without SPNEGO, NTLMv2 hash */
Steve Frenchc16fefa2008-08-19 19:35:33 +0000103 Kerberos, /* Kerberos via SPNEGO */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104};
105
Shirish Pargaonkar5f98ca92010-09-18 22:01:58 -0500106struct session_key {
Steve Frenchb609f062007-07-09 07:55:14 +0000107 unsigned int len;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500108 char *response;
Steve Frenchb609f062007-07-09 07:55:14 +0000109};
110
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500111/* crypto security descriptor definition */
112struct sdesc {
113 struct shash_desc shash;
114 char ctx[];
115};
116
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -0500117/* crypto hashing related structure/fields, not specific to a sec mech */
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500118struct cifs_secmech {
119 struct crypto_shash *hmacmd5; /* hmac-md5 hash function */
120 struct crypto_shash *md5; /* md5 hash function */
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700121 struct crypto_shash *hmacsha256; /* hmac-sha256 hash function */
Steve French429b46f2013-06-26 23:45:05 -0500122 struct crypto_shash *cmacaes; /* block-cipher based MAC function */
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500123 struct sdesc *sdeschmacmd5; /* ctxt to generate ntlmv2 hash, CR1 */
124 struct sdesc *sdescmd5; /* ctxt to generate cifs/smb signature */
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700125 struct sdesc *sdeschmacsha256; /* ctxt to generate smb2 signature */
Steve French429b46f2013-06-26 23:45:05 -0500126 struct sdesc *sdesccmacaes; /* ctxt to generate smb3 signature */
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500127};
128
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500129/* per smb session structure/fields */
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500130struct ntlmssp_auth {
Shirish Pargaonkar5c234aa2013-08-29 08:35:10 -0500131 bool sesskey_per_smbsess; /* whether session key is per smb session */
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500132 __u32 client_flags; /* sent by client in type 1 ntlmsssp exchange */
133 __u32 server_flags; /* sent by server in type 2 ntlmssp exchange */
134 unsigned char ciphertext[CIFS_CPHTXT_SIZE]; /* sent to server */
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500135 char cryptkey[CIFS_CRYPTO_KEY_SIZE]; /* used by ntlmssp */
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500136};
137
Steve French442aa312007-09-24 20:25:46 +0000138struct cifs_cred {
139 int uid;
140 int gid;
141 int mode;
142 int cecount;
143 struct cifs_sid osid;
144 struct cifs_sid gsid;
145 struct cifs_ntace *ntaces;
146 struct cifs_ace *aces;
147};
148
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149/*
150 *****************************************************************
151 * Except the CIFS PDUs themselves all the
152 * globally interesting structs should go here
153 *****************************************************************
154 */
155
Jeff Laytonbf5ea0e2012-09-18 16:20:34 -0700156/*
157 * A smb_rqst represents a complete request to be issued to a server. It's
158 * formed by a kvec array, followed by an array of pages. Page data is assumed
159 * to start at the beginning of the first page.
160 */
161struct smb_rqst {
162 struct kvec *rq_iov; /* array of kvecs */
163 unsigned int rq_nvec; /* number of kvecs in array */
164 struct page **rq_pages; /* pointer to array of page ptrs */
165 unsigned int rq_npages; /* number pages in array */
166 unsigned int rq_pagesz; /* page size to use */
167 unsigned int rq_tailsz; /* length of last page */
168};
169
Jeff Layton23db65f2012-05-15 12:20:51 -0400170enum smb_version {
171 Smb_1 = 1,
Steve Frenchdd446b12012-11-28 23:21:06 -0600172 Smb_20,
Steve French1080ef72011-02-24 18:07:19 +0000173 Smb_21,
Steve Frenche4aa25e2012-10-01 12:26:22 -0500174 Smb_30,
Steve French20b6d8b2013-06-12 22:48:41 -0500175 Smb_302,
Steve French5f7fbf72014-12-17 22:52:58 -0600176#ifdef CONFIG_CIFS_SMB311
177 Smb_311,
178#endif /* SMB311 */
179 Smb_version_err
Jeff Layton23db65f2012-05-15 12:20:51 -0400180};
181
Jeff Layton121b0462012-05-15 12:21:10 -0400182struct mid_q_entry;
183struct TCP_Server_Info;
Pavel Shilovsky55157df2012-02-28 14:04:17 +0300184struct cifsFileInfo;
Pavel Shilovsky082d0642012-05-17 12:18:21 +0400185struct cifs_ses;
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +0400186struct cifs_tcon;
Pavel Shilovskyb669f332012-05-27 20:21:53 +0400187struct dfs_info3_param;
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400188struct cifs_fattr;
Pavel Shilovsky9224dfc2012-05-27 20:39:52 +0400189struct smb_vol;
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700190struct cifs_fid;
Pavel Shilovskyfc9c5962012-09-18 16:20:28 -0700191struct cifs_readdata;
Pavel Shilovskyc9de5c82012-09-18 16:20:29 -0700192struct cifs_writedata;
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -0700193struct cifs_io_parms;
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700194struct cifs_search_info;
Pavel Shilovsky95a3f2f2012-09-18 16:20:33 -0700195struct cifsInodeInfo;
Pavel Shilovsky226730b2013-07-05 12:00:30 +0400196struct cifs_open_parms;
Jeff Layton121b0462012-05-15 12:21:10 -0400197
Jeff Layton23db65f2012-05-15 12:20:51 -0400198struct smb_version_operations {
Jeff Layton121b0462012-05-15 12:21:10 -0400199 int (*send_cancel)(struct TCP_Server_Info *, void *,
200 struct mid_q_entry *);
Pavel Shilovsky55157df2012-02-28 14:04:17 +0300201 bool (*compare_fids)(struct cifsFileInfo *, struct cifsFileInfo *);
Pavel Shilovsky082d0642012-05-17 12:18:21 +0400202 /* setup request: allocate mid, sign message */
Jeff Laytonfec344e2012-09-18 16:20:35 -0700203 struct mid_q_entry *(*setup_request)(struct cifs_ses *,
204 struct smb_rqst *);
Pavel Shilovsky45740842012-06-01 14:26:18 +0400205 /* setup async request: allocate mid, sign message */
Jeff Laytonfec344e2012-09-18 16:20:35 -0700206 struct mid_q_entry *(*setup_async_request)(struct TCP_Server_Info *,
207 struct smb_rqst *);
Pavel Shilovsky082d0642012-05-17 12:18:21 +0400208 /* check response: verify signature, map error */
209 int (*check_receive)(struct mid_q_entry *, struct TCP_Server_Info *,
210 bool);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400211 void (*add_credits)(struct TCP_Server_Info *, const unsigned int,
212 const int);
Pavel Shilovsky45275782012-05-17 17:53:29 +0400213 void (*set_credits)(struct TCP_Server_Info *, const int);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400214 int * (*get_credits_field)(struct TCP_Server_Info *, const int);
215 unsigned int (*get_credits)(struct mid_q_entry *);
Pavel Shilovsky88257362012-05-23 14:01:59 +0400216 __u64 (*get_next_mid)(struct TCP_Server_Info *);
Pavel Shilovskyeb378712012-05-17 13:02:51 +0400217 /* data offset from read response message */
218 unsigned int (*read_data_offset)(char *);
219 /* data length from read response message */
220 unsigned int (*read_data_length)(char *);
221 /* map smb to linux error */
222 int (*map_error)(char *, bool);
Pavel Shilovsky8aa26f32012-05-17 13:25:35 +0400223 /* find mid corresponding to the response message */
224 struct mid_q_entry * (*find_mid)(struct TCP_Server_Info *, char *);
225 void (*dump_detail)(void *);
Pavel Shilovsky44c58182012-05-28 14:16:31 +0400226 void (*clear_stats)(struct cifs_tcon *);
227 void (*print_stats)(struct seq_file *m, struct cifs_tcon *);
Steve French769ee6a2013-06-19 14:15:30 -0500228 void (*dump_share_caps)(struct seq_file *, struct cifs_tcon *);
Pavel Shilovsky8aa26f32012-05-17 13:25:35 +0400229 /* verify the message */
Steve French373512e2015-12-18 13:05:30 -0600230 int (*check_message)(char *, unsigned int, struct TCP_Server_Info *);
Pavel Shilovsky8aa26f32012-05-17 13:25:35 +0400231 bool (*is_oplock_break)(char *, struct TCP_Server_Info *);
Sachin Prabhuc11f1df2014-03-11 16:11:47 +0000232 void (*downgrade_oplock)(struct TCP_Server_Info *,
233 struct cifsInodeInfo *, bool);
Pavel Shilovsky316cf942012-05-23 14:31:03 +0400234 /* process transaction2 response */
235 bool (*check_trans2)(struct mid_q_entry *, struct TCP_Server_Info *,
236 char *, int);
Pavel Shilovsky286170a2012-05-25 10:43:58 +0400237 /* check if we need to negotiate */
238 bool (*need_neg)(struct TCP_Server_Info *);
239 /* negotiate to the server */
240 int (*negotiate)(const unsigned int, struct cifs_ses *);
Pavel Shilovsky24985c52012-09-18 16:20:28 -0700241 /* set negotiated write size */
242 unsigned int (*negotiate_wsize)(struct cifs_tcon *, struct smb_vol *);
243 /* set negotiated read size */
244 unsigned int (*negotiate_rsize)(struct cifs_tcon *, struct smb_vol *);
Pavel Shilovsky58c45c52012-05-25 10:54:49 +0400245 /* setup smb sessionn */
246 int (*sess_setup)(const unsigned int, struct cifs_ses *,
247 const struct nls_table *);
248 /* close smb session */
249 int (*logoff)(const unsigned int, struct cifs_ses *);
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +0400250 /* connect to a server share */
251 int (*tree_connect)(const unsigned int, struct cifs_ses *, const char *,
252 struct cifs_tcon *, const struct nls_table *);
253 /* close tree connecion */
254 int (*tree_disconnect)(const unsigned int, struct cifs_tcon *);
Pavel Shilovskyb669f332012-05-27 20:21:53 +0400255 /* get DFS referrals */
256 int (*get_dfs_refer)(const unsigned int, struct cifs_ses *,
257 const char *, struct dfs_info3_param **,
258 unsigned int *, const struct nls_table *, int);
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +0400259 /* informational QFS call */
260 void (*qfs_tcon)(const unsigned int, struct cifs_tcon *);
Pavel Shilovsky68889f22012-05-25 14:40:22 +0400261 /* check if a path is accessible or not */
262 int (*is_path_accessible)(const unsigned int, struct cifs_tcon *,
263 struct cifs_sb_info *, const char *);
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400264 /* query path data from the server */
265 int (*query_path_info)(const unsigned int, struct cifs_tcon *,
266 struct cifs_sb_info *, const char *,
Pavel Shilovskyeb85d94b2013-10-23 17:49:47 +0400267 FILE_ALL_INFO *, bool *, bool *);
Pavel Shilovsky4ad65042012-09-18 16:20:26 -0700268 /* query file data from the server */
269 int (*query_file_info)(const unsigned int, struct cifs_tcon *,
270 struct cifs_fid *, FILE_ALL_INFO *);
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400271 /* get server index number */
272 int (*get_srv_inum)(const unsigned int, struct cifs_tcon *,
273 struct cifs_sb_info *, const char *,
274 u64 *uniqueid, FILE_ALL_INFO *);
Pavel Shilovskyd1433412012-09-18 16:20:31 -0700275 /* set size by path */
276 int (*set_path_size)(const unsigned int, struct cifs_tcon *,
277 const char *, __u64, struct cifs_sb_info *, bool);
278 /* set size by file handle */
279 int (*set_file_size)(const unsigned int, struct cifs_tcon *,
280 struct cifsFileInfo *, __u64, bool);
Pavel Shilovsky6bdf6db2012-09-18 16:20:32 -0700281 /* set attributes */
282 int (*set_file_info)(struct inode *, const char *, FILE_BASIC_INFO *,
283 const unsigned int);
Steve French64a5cfa2013-10-14 15:31:32 -0500284 int (*set_compression)(const unsigned int, struct cifs_tcon *,
285 struct cifsFileInfo *);
Pavel Shilovskyf6d76172012-05-25 14:47:16 +0400286 /* check if we can send an echo or nor */
287 bool (*can_echo)(struct TCP_Server_Info *);
288 /* send echo request */
289 int (*echo)(struct TCP_Server_Info *);
Pavel Shilovskyf4367202012-03-17 11:41:12 +0300290 /* create directory */
291 int (*mkdir)(const unsigned int, struct cifs_tcon *, const char *,
292 struct cifs_sb_info *);
293 /* set info on created directory */
294 void (*mkdir_setinfo)(struct inode *, const char *,
295 struct cifs_sb_info *, struct cifs_tcon *,
296 const unsigned int);
Pavel Shilovskyf958ca52012-07-10 16:14:18 +0400297 /* remove directory */
298 int (*rmdir)(const unsigned int, struct cifs_tcon *, const char *,
299 struct cifs_sb_info *);
Pavel Shilovskyed6875e2012-09-18 16:20:25 -0700300 /* unlink file */
301 int (*unlink)(const unsigned int, struct cifs_tcon *, const char *,
302 struct cifs_sb_info *);
303 /* open, rename and delete file */
304 int (*rename_pending_delete)(const char *, struct dentry *,
305 const unsigned int);
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -0700306 /* send rename request */
307 int (*rename)(const unsigned int, struct cifs_tcon *, const char *,
308 const char *, struct cifs_sb_info *);
Steve Frenchd6e906f2012-09-18 16:20:31 -0700309 /* send create hardlink request */
310 int (*create_hardlink)(const unsigned int, struct cifs_tcon *,
311 const char *, const char *,
312 struct cifs_sb_info *);
Pavel Shilovskyb42bf882013-08-14 19:25:21 +0400313 /* query symlink target */
314 int (*query_symlink)(const unsigned int, struct cifs_tcon *,
315 const char *, char **, struct cifs_sb_info *);
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700316 /* open a file for non-posix mounts */
Pavel Shilovsky226730b2013-07-05 12:00:30 +0400317 int (*open)(const unsigned int, struct cifs_open_parms *,
318 __u32 *, FILE_ALL_INFO *);
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700319 /* set fid protocol-specific info */
320 void (*set_fid)(struct cifsFileInfo *, struct cifs_fid *, __u32);
Pavel Shilovsky0ff78a22012-09-18 16:20:26 -0700321 /* close a file */
Pavel Shilovsky760ad0c2012-09-25 11:00:07 +0400322 void (*close)(const unsigned int, struct cifs_tcon *,
323 struct cifs_fid *);
Pavel Shilovsky1d8c4c02012-09-18 16:20:27 -0700324 /* send a flush request to the server */
325 int (*flush)(const unsigned int, struct cifs_tcon *, struct cifs_fid *);
Pavel Shilovskyfc9c5962012-09-18 16:20:28 -0700326 /* async read from the server */
327 int (*async_readv)(struct cifs_readdata *);
Pavel Shilovskyc9de5c82012-09-18 16:20:29 -0700328 /* async write to the server */
Steve French4a5c80d2014-02-07 20:45:12 -0600329 int (*async_writev)(struct cifs_writedata *,
330 void (*release)(struct kref *));
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -0700331 /* sync read from the server */
Steve Frenchdb8b6312014-09-22 05:13:55 -0500332 int (*sync_read)(const unsigned int, struct cifs_fid *,
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -0700333 struct cifs_io_parms *, unsigned int *, char **,
334 int *);
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -0700335 /* sync write to the server */
Steve Frenchdb8b6312014-09-22 05:13:55 -0500336 int (*sync_write)(const unsigned int, struct cifs_fid *,
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -0700337 struct cifs_io_parms *, unsigned int *, struct kvec *,
338 unsigned long);
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700339 /* open dir, start readdir */
340 int (*query_dir_first)(const unsigned int, struct cifs_tcon *,
341 const char *, struct cifs_sb_info *,
342 struct cifs_fid *, __u16,
343 struct cifs_search_info *);
344 /* continue readdir */
345 int (*query_dir_next)(const unsigned int, struct cifs_tcon *,
346 struct cifs_fid *,
347 __u16, struct cifs_search_info *srch_inf);
348 /* close dir */
349 int (*close_dir)(const unsigned int, struct cifs_tcon *,
350 struct cifs_fid *);
351 /* calculate a size of SMB message */
352 unsigned int (*calc_smb_size)(void *);
Pavel Shilovsky2e44b282012-09-18 16:20:33 -0700353 /* check for STATUS_PENDING and process it in a positive case */
354 bool (*is_status_pending)(char *, struct TCP_Server_Info *, int);
Pavel Shilovsky95a3f2f2012-09-18 16:20:33 -0700355 /* send oplock break response */
356 int (*oplock_response)(struct cifs_tcon *, struct cifs_fid *,
357 struct cifsInodeInfo *);
Pavel Shilovsky76ec5e32012-09-18 16:20:33 -0700358 /* query remote filesystem */
359 int (*queryfs)(const unsigned int, struct cifs_tcon *,
360 struct kstatfs *);
Pavel Shilovskyd39a4f72012-09-19 06:22:43 -0700361 /* send mandatory brlock to the server */
362 int (*mand_lock)(const unsigned int, struct cifsFileInfo *, __u64,
363 __u64, __u32, int, int, bool);
364 /* unlock range of mandatory locks */
365 int (*mand_unlock_range)(struct cifsFileInfo *, struct file_lock *,
366 const unsigned int);
367 /* push brlocks from the cache to the server */
368 int (*push_mand_locks)(struct cifsFileInfo *);
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700369 /* get lease key of the inode */
Pavel Shilovskya41a28b2013-09-04 13:07:41 +0400370 void (*get_lease_key)(struct inode *, struct cifs_fid *);
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700371 /* set lease key of the inode */
Pavel Shilovskya41a28b2013-09-04 13:07:41 +0400372 void (*set_lease_key)(struct inode *, struct cifs_fid *);
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700373 /* generate new lease key */
Pavel Shilovskya41a28b2013-09-04 13:07:41 +0400374 void (*new_lease_key)(struct cifs_fid *);
Shirish Pargaonkar32811d22013-08-29 08:35:11 -0500375 int (*generate_signingkey)(struct cifs_ses *);
Pavel Shilovsky53ef1012013-09-05 16:11:28 +0400376 int (*calc_signature)(struct smb_rqst *, struct TCP_Server_Info *);
Steve Frenchb3152e22015-06-24 03:17:02 -0500377 int (*set_integrity)(const unsigned int, struct cifs_tcon *tcon,
378 struct cifsFileInfo *src_file);
Sachin Prabhub5be1a12013-11-25 17:09:49 +0000379 int (*query_mf_symlink)(unsigned int, struct cifs_tcon *,
380 struct cifs_sb_info *, const unsigned char *,
381 char *, unsigned int *);
Sachin Prabhucbb0aba2013-11-25 17:09:52 +0000382 int (*create_mf_symlink)(unsigned int, struct cifs_tcon *,
383 struct cifs_sb_info *, const unsigned char *,
384 char *, unsigned int *);
Pavel Shilovsky53ef1012013-09-05 16:11:28 +0400385 /* if we can do cache read operations */
386 bool (*is_read_op)(__u32);
387 /* set oplock level for the inode */
Pavel Shilovsky42873b02013-09-05 21:30:16 +0400388 void (*set_oplock_level)(struct cifsInodeInfo *, __u32, unsigned int,
389 bool *);
Pavel Shilovskya41a28b2013-09-04 13:07:41 +0400390 /* create lease context buffer for CREATE request */
391 char * (*create_lease_buf)(u8 *, u8);
Pavel Shilovsky42873b02013-09-05 21:30:16 +0400392 /* parse lease context buffer and return oplock/epoch info */
393 __u8 (*parse_lease_buf)(void *, unsigned int *);
Steve French41c13582013-11-14 00:05:36 -0600394 int (*clone_range)(const unsigned int, struct cifsFileInfo *src_file,
395 struct cifsFileInfo *target_file, u64 src_off, u64 len,
396 u64 dest_off);
Steve French02b16662015-06-27 21:18:36 -0700397 int (*duplicate_extents)(const unsigned int, struct cifsFileInfo *src,
398 struct cifsFileInfo *target_file, u64 src_off, u64 len,
399 u64 dest_off);
Steve Frenchff1c0382013-11-19 23:44:46 -0600400 int (*validate_negotiate)(const unsigned int, struct cifs_tcon *);
Steve French666753c2014-01-26 23:53:43 -0600401 ssize_t (*query_all_EAs)(const unsigned int, struct cifs_tcon *,
402 const unsigned char *, const unsigned char *, char *,
403 size_t, const struct nls_table *, int);
404 int (*set_EA)(const unsigned int, struct cifs_tcon *, const char *,
405 const char *, const void *, const __u16,
406 const struct nls_table *, int);
Steve French83e3bc22014-02-02 23:31:47 -0600407 struct cifs_ntsd * (*get_acl)(struct cifs_sb_info *, struct inode *,
408 const char *, u32 *);
Steve French42eacf92014-02-10 14:08:16 -0600409 struct cifs_ntsd * (*get_acl_by_fid)(struct cifs_sb_info *,
410 const struct cifs_fid *, u32 *);
Steve French83e3bc22014-02-02 23:31:47 -0600411 int (*set_acl)(struct cifs_ntsd *, __u32, struct inode *, const char *,
412 int);
Pavel Shilovsky7f6c5002014-06-22 11:03:22 +0400413 /* writepages retry size */
414 unsigned int (*wp_retry_size)(struct inode *);
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +0400415 /* get mtu credits */
416 int (*wait_mtu_credits)(struct TCP_Server_Info *, unsigned int,
417 unsigned int *, unsigned int *);
Pavel Shilovsky52755802014-08-18 20:49:57 +0400418 /* check if we need to issue closedir */
419 bool (*dir_needs_close)(struct cifsFileInfo *);
Steve French31742c52014-08-17 08:38:47 -0500420 long (*fallocate)(struct file *, struct cifs_tcon *, int, loff_t,
421 loff_t);
Jeff Layton23db65f2012-05-15 12:20:51 -0400422};
423
424struct smb_version_values {
425 char *version_string;
Steve Frenche4aa25e2012-10-01 12:26:22 -0500426 __u16 protocol_id;
427 __u32 req_capabilities;
Pavel Shilovsky106dc532012-02-28 14:23:34 +0300428 __u32 large_lock_type;
429 __u32 exclusive_lock_type;
430 __u32 shared_lock_type;
431 __u32 unlock_lock_type;
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400432 size_t header_size;
433 size_t max_header_size;
Pavel Shilovskyeb378712012-05-17 13:02:51 +0400434 size_t read_rsp_size;
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +0400435 __le16 lock_cmd;
Pavel Shilovsky29e20f92012-07-13 13:58:14 +0400436 unsigned int cap_unix;
437 unsigned int cap_nt_find;
438 unsigned int cap_large_files;
Jeff Layton50285882013-06-27 12:45:00 -0400439 __u16 signing_enabled;
440 __u16 signing_required;
Pavel Shilovskya41a28b2013-09-04 13:07:41 +0400441 size_t create_lease_size;
Jeff Layton23db65f2012-05-15 12:20:51 -0400442};
443
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400444#define HEADER_SIZE(server) (server->vals->header_size)
445#define MAX_HEADER_SIZE(server) (server->vals->max_header_size)
446
Steve Frenchf87d39d2011-05-27 03:50:55 +0000447struct smb_vol {
448 char *username;
449 char *password;
450 char *domainname;
451 char *UNC;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000452 char *iocharset; /* local code page for mapping to and from Unicode */
453 char source_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* clnt nb name */
454 char target_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* srvr nb name */
Eric W. Biederman3da46562013-02-06 01:37:39 -0800455 kuid_t cred_uid;
456 kuid_t linux_uid;
457 kgid_t linux_gid;
458 kuid_t backupuid;
459 kgid_t backupgid;
Al Viro5206efd2011-07-26 03:22:14 -0400460 umode_t file_mode;
461 umode_t dir_mode;
Jeff Layton1e3cc572013-06-10 17:12:23 -0500462 enum securityEnum sectype; /* sectype requested via mnt opts */
463 bool sign; /* was signing requested via mnt opts? */
Steve Frenchf87d39d2011-05-27 03:50:55 +0000464 bool retry:1;
465 bool intr:1;
466 bool setuids:1;
467 bool override_uid:1;
468 bool override_gid:1;
469 bool dynperm:1;
470 bool noperm:1;
471 bool no_psx_acl:1; /* set if posix acl support should be disabled */
472 bool cifs_acl:1;
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500473 bool backupuid_specified; /* mount option backupuid is specified */
474 bool backupgid_specified; /* mount option backupgid is specified */
Steve Frenchf87d39d2011-05-27 03:50:55 +0000475 bool no_xattr:1; /* set if xattr (EA) support should be disabled*/
476 bool server_ino:1; /* use inode numbers from server ie UniqueId */
477 bool direct_io:1;
478 bool strict_io:1; /* strict cache behavior */
479 bool remap:1; /* set to remap seven reserved chars in filenames */
Steve French2baa2682014-09-27 02:19:01 -0500480 bool sfu_remap:1; /* remap seven reserved chars ala SFU */
Steve Frenchf87d39d2011-05-27 03:50:55 +0000481 bool posix_paths:1; /* unset to not ask for posix pathnames. */
482 bool no_linux_ext:1;
483 bool sfu_emul:1;
484 bool nullauth:1; /* attempt to authenticate with null user */
485 bool nocase:1; /* request case insensitive filenames */
486 bool nobrl:1; /* disable sending byte range locks to srv */
487 bool mand_lock:1; /* send mandatory not posix byte range lock reqs */
488 bool seal:1; /* request transport encryption on share */
489 bool nodfs:1; /* Do not request DFS, even if available */
490 bool local_lease:1; /* check leases only on local system, not remote */
491 bool noblocksnd:1;
492 bool noautotune:1;
493 bool nostrictsync:1; /* do not force expensive SMBflush on every sync */
494 bool fsc:1; /* enable fscache */
495 bool mfsymlinks:1; /* use Minshall+French Symlinks */
496 bool multiuser:1;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000497 bool rwpidforward:1; /* pid forward for read/write operations */
Steve Frenchb2a30772015-09-29 21:49:28 -0500498 bool nosharesock:1;
499 bool persistent:1;
500 bool nopersistent:1;
Steve French592fafe2015-11-03 10:08:53 -0600501 bool resilient:1; /* noresilient not required since not fored for CA */
Steve Frenchf87d39d2011-05-27 03:50:55 +0000502 unsigned int rsize;
503 unsigned int wsize;
504 bool sockopt_tcp_nodelay:1;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000505 unsigned long actimeo; /* attribute cache timeout (jiffies) */
Jeff Layton23db65f2012-05-15 12:20:51 -0400506 struct smb_version_operations *ops;
507 struct smb_version_values *vals;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000508 char *prepath;
Jeff Laytonb979aaa2012-11-26 11:09:55 -0500509 struct sockaddr_storage dstaddr; /* destination address */
Steve Frenchf87d39d2011-05-27 03:50:55 +0000510 struct sockaddr_storage srcaddr; /* allow binding to a local IP */
511 struct nls_table *local_nls;
Steve Frenchadfeb3e2015-12-18 12:31:36 -0600512 unsigned int echo_interval; /* echo interval in secs */
Steve Frenchf87d39d2011-05-27 03:50:55 +0000513};
514
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400515#define CIFS_MOUNT_MASK (CIFS_MOUNT_NO_PERM | CIFS_MOUNT_SET_UID | \
516 CIFS_MOUNT_SERVER_INUM | CIFS_MOUNT_DIRECT_IO | \
517 CIFS_MOUNT_NO_XATTR | CIFS_MOUNT_MAP_SPECIAL_CHR | \
Steve French2baa2682014-09-27 02:19:01 -0500518 CIFS_MOUNT_MAP_SFM_CHR | \
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400519 CIFS_MOUNT_UNX_EMUL | CIFS_MOUNT_NO_BRL | \
520 CIFS_MOUNT_CIFS_ACL | CIFS_MOUNT_OVERR_UID | \
521 CIFS_MOUNT_OVERR_GID | CIFS_MOUNT_DYNPERM | \
522 CIFS_MOUNT_NOPOSIXBRL | CIFS_MOUNT_NOSSYNC | \
523 CIFS_MOUNT_FSCACHE | CIFS_MOUNT_MF_SYMLINKS | \
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500524 CIFS_MOUNT_MULTIUSER | CIFS_MOUNT_STRICT_IO | \
525 CIFS_MOUNT_CIFS_BACKUPUID | CIFS_MOUNT_CIFS_BACKUPGID)
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400526
527#define CIFS_MS_MASK (MS_RDONLY | MS_MANDLOCK | MS_NOEXEC | MS_NOSUID | \
528 MS_NODEV | MS_SYNCHRONOUS)
529
530struct cifs_mnt_data {
531 struct cifs_sb_info *cifs_sb;
532 struct smb_vol *vol;
533 int flags;
534};
535
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400536static inline unsigned int
537get_rfc1002_length(void *buf)
538{
Jeff Laytondca1c8d2014-02-22 19:35:38 -0500539 return be32_to_cpu(*((__be32 *)buf)) & 0xffffff;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400540}
541
Pavel Shilovskyec2e4522011-12-27 16:12:43 +0400542static inline void
543inc_rfc1001_len(void *buf, int count)
544{
545 be32_add_cpu((__be32 *)buf, count);
546}
547
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548struct TCP_Server_Info {
Steve French3b795212008-11-13 19:45:32 +0000549 struct list_head tcp_ses_list;
550 struct list_head smb_ses_list;
Jeff Laytone7ddee92008-11-14 13:44:38 -0500551 int srv_count; /* reference counter */
Steve Frencha10faeb22005-08-22 21:38:31 -0700552 /* 15 character server name + 0x20 16th byte indicating type = srv */
Jeff Layton8ecaf672008-12-01 15:23:50 -0500553 char server_RFC1001_name[RFC1001_NAME_LEN_WITH_NULL];
Jeff Layton23db65f2012-05-15 12:20:51 -0400554 struct smb_version_operations *ops;
555 struct smb_version_values *vals;
Jeff Laytonc3dccf42011-01-20 13:36:50 -0500556 enum statusEnum tcpStatus; /* what we think the status is */
Jeff Laytonc359cf32007-11-16 22:22:06 +0000557 char *hostname; /* hostname portion of UNC string */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 struct socket *ssocket;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300559 struct sockaddr_storage dstaddr;
Ben Greear3eb9a882010-09-01 17:06:02 -0700560 struct sockaddr_storage srcaddr; /* locally bind to this IP */
Rob Landleyf1d0c992011-01-22 15:44:05 -0600561#ifdef CONFIG_NET_NS
562 struct net *net;
563#endif
Steve Frenchd38d8c72007-06-28 19:44:13 +0000564 wait_queue_head_t response_q;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 wait_queue_head_t request_q; /* if more than maxmpx to srvr must block*/
566 struct list_head pending_mid_q;
Steve Frenchedf1ae42008-10-29 00:47:57 +0000567 bool noblocksnd; /* use blocking sendmsg */
568 bool noautotune; /* do not autotune send buf sizes */
Steve French6a5fa2362010-01-01 01:28:43 +0000569 bool tcp_nodelay;
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400570 int credits; /* send no more requests at once */
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300571 unsigned int in_flight; /* number of requests on the wire to server */
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400572 spinlock_t req_lock; /* protect the two values above */
Jeff Layton72ca5452008-12-01 07:09:36 -0500573 struct mutex srv_mutex;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 struct task_struct *tsk;
575 char server_GUID[16];
Pavel Shilovsky286170a2012-05-25 10:43:58 +0400576 __u16 sec_mode;
Jeff Layton38d77c52013-05-26 07:01:00 -0400577 bool sign; /* is signing enabled on this connection? */
Jeff Laytonc3dccf42011-01-20 13:36:50 -0500578 bool session_estab; /* mark when very first sess is established */
Pavel Shilovsky28ea5292012-05-23 16:18:00 +0400579#ifdef CONFIG_CIFS_SMB2
580 int echo_credits; /* echo reserved slots */
581 int oplock_credits; /* oplock break reserved slots */
582 bool echoes:1; /* enable echoes */
Sachin Prabhu39552ea2014-05-13 00:48:12 +0100583 __u8 client_guid[SMB2_CLIENT_GUID_SIZE]; /* Client GUID */
Pavel Shilovsky28ea5292012-05-23 16:18:00 +0400584#endif
Jeff Laytonc3dccf42011-01-20 13:36:50 -0500585 u16 dialect; /* dialect index that server chose */
Pavel Shilovsky10b9b982012-03-20 12:55:09 +0300586 bool oplocks:1; /* enable oplocks */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 unsigned int maxReq; /* Clients should submit no more */
588 /* than maxReq distinct unanswered SMBs to the server when using */
589 /* multiplexed reads or writes */
590 unsigned int maxBuf; /* maxBuf specifies the maximum */
591 /* message size the server can send or receive for non-raw SMBs */
Steve French7e90d702011-02-08 23:52:32 +0000592 /* maxBuf is returned by SMB NegotiateProtocol so maxBuf is only 0 */
593 /* when socket is setup (and during reconnect) before NegProt sent */
Steve Frencheca6acf2009-02-20 05:43:09 +0000594 unsigned int max_rw; /* maxRw specifies the maximum */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 /* message size the server can send or receive for */
596 /* SMB_COM_WRITE_RAW or SMB_COM_READ_RAW. */
Pavel Shilovsky29e20f92012-07-13 13:58:14 +0400597 unsigned int capabilities; /* selective disabling of caps by smb sess */
Steve Frenchde7ed552006-09-30 13:25:52 +0000598 int timeAdj; /* Adjust for difference in server time zone in sec */
Pavel Shilovsky243d04b2012-03-23 14:28:03 -0400599 __u64 CurrentMid; /* multiplex id - rotating counter */
Shirish Pargaonkard3ba50b2010-10-27 15:20:36 -0500600 char cryptkey[CIFS_CRYPTO_KEY_SIZE]; /* used by ntlm, ntlmv2 etc */
Steve Frencha10faeb22005-08-22 21:38:31 -0700601 /* 16th byte of RFC1001 workstation name is always null */
Jeff Layton8ecaf672008-12-01 15:23:50 -0500602 char workstation_RFC1001_name[RFC1001_NAME_LEN_WITH_NULL];
Jeff Laytona0f8b4f2011-01-07 11:30:28 -0500603 __u32 sequence_number; /* for signing, protected by srv_mutex */
Shirish Pargaonkar5f98ca92010-09-18 22:01:58 -0500604 struct session_key session_key;
Steve French3a5ff612006-07-14 22:37:11 +0000605 unsigned long lstrp; /* when we got last response from this server */
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500606 struct cifs_secmech secmech; /* crypto sec mech functs, descriptors */
Jeff Laytone598d1d82013-05-26 07:00:59 -0400607#define CIFS_NEGFLAVOR_LANMAN 0 /* wct == 13, LANMAN */
608#define CIFS_NEGFLAVOR_UNENCAP 1 /* wct == 17, but no ext_sec */
609#define CIFS_NEGFLAVOR_EXTENDED 2 /* wct == 17, ext_sec bit set */
610 char negflavor; /* NEGOTIATE response flavor */
Jeff Layton26efa0b2010-04-24 07:57:49 -0400611 /* extended security flavors that server supports */
Jeff Laytonc3dccf42011-01-20 13:36:50 -0500612 bool sec_ntlmssp; /* supports NTLMSSP */
613 bool sec_kerberosu2u; /* supports U2U Kerberos */
Jeff Layton26efa0b2010-04-24 07:57:49 -0400614 bool sec_kerberos; /* supports plain Kerberos */
615 bool sec_mskerberos; /* supports legacy MS Kerberos */
Jeff Layton2a37ef92011-10-19 15:29:23 -0400616 bool large_buf; /* is current buffer large? */
Jeff Laytonc74093b2011-01-11 07:24:23 -0500617 struct delayed_work echo; /* echo ping workqueue job */
Jeff Layton2a37ef92011-10-19 15:29:23 -0400618 char *smallbuf; /* pointer to current "small" buffer */
619 char *bigbuf; /* pointer to current "big" buffer */
620 unsigned int total_read; /* total amount of data read in this pass */
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +0530621#ifdef CONFIG_CIFS_FSCACHE
622 struct fscache_cookie *fscache; /* client index cache cookie */
623#endif
Jeff Laytonc3dccf42011-01-20 13:36:50 -0500624#ifdef CONFIG_CIFS_STATS2
Steve French789e6662011-08-09 18:44:44 +0000625 atomic_t in_send; /* requests trying to send */
Jeff Laytonc3dccf42011-01-20 13:36:50 -0500626 atomic_t num_waiters; /* blocked waiting to get in sendrecv */
627#endif
Pavel Shilovskyec2e4522011-12-27 16:12:43 +0400628#ifdef CONFIG_CIFS_SMB2
629 unsigned int max_read;
630 unsigned int max_write;
Steve French373512e2015-12-18 13:05:30 -0600631 __u8 preauth_hash[512];
Pavel Shilovskyec2e4522011-12-27 16:12:43 +0400632#endif /* CONFIG_CIFS_SMB2 */
Steve Frenchadfeb3e2015-12-18 12:31:36 -0600633 unsigned long echo_interval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634};
635
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300636static inline unsigned int
637in_flight(struct TCP_Server_Info *server)
638{
639 unsigned int num;
640 spin_lock(&server->req_lock);
641 num = server->in_flight;
642 spin_unlock(&server->req_lock);
643 return num;
644}
645
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400646static inline bool
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300647has_credits(struct TCP_Server_Info *server, int *credits)
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300648{
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400649 int num;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300650 spin_lock(&server->req_lock);
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300651 num = *credits;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300652 spin_unlock(&server->req_lock);
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400653 return num > 0;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300654}
655
Pavel Shilovsky45275782012-05-17 17:53:29 +0400656static inline void
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400657add_credits(struct TCP_Server_Info *server, const unsigned int add,
658 const int optype)
Pavel Shilovsky45275782012-05-17 17:53:29 +0400659{
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400660 server->ops->add_credits(server, add, optype);
Pavel Shilovsky45275782012-05-17 17:53:29 +0400661}
662
663static inline void
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +0400664add_credits_and_wake_if(struct TCP_Server_Info *server, const unsigned int add,
665 const int optype)
666{
667 if (add) {
668 server->ops->add_credits(server, add, optype);
669 wake_up(&server->request_q);
670 }
671}
672
673static inline void
Pavel Shilovsky45275782012-05-17 17:53:29 +0400674set_credits(struct TCP_Server_Info *server, const int val)
675{
676 server->ops->set_credits(server, val);
677}
678
Sachin Prabhu9235d092014-12-09 17:37:00 +0000679static inline __le64
Tim Gardner3d378d32013-11-02 12:50:34 -0500680get_next_mid64(struct TCP_Server_Info *server)
Pavel Shilovsky88257362012-05-23 14:01:59 +0400681{
Sachin Prabhu9235d092014-12-09 17:37:00 +0000682 return cpu_to_le64(server->ops->get_next_mid(server));
Pavel Shilovsky88257362012-05-23 14:01:59 +0400683}
684
Tim Gardner3d378d32013-11-02 12:50:34 -0500685static inline __le16
686get_next_mid(struct TCP_Server_Info *server)
687{
Sachin Prabhu9235d092014-12-09 17:37:00 +0000688 __u16 mid = server->ops->get_next_mid(server);
Tim Gardner3d378d32013-11-02 12:50:34 -0500689 /*
690 * The value in the SMB header should be little endian for easy
691 * on-the-wire decoding.
692 */
693 return cpu_to_le16(mid);
694}
695
696static inline __u16
697get_mid(const struct smb_hdr *smb)
698{
699 return le16_to_cpu(smb->Mid);
700}
701
702static inline bool
703compare_mid(__u16 mid, const struct smb_hdr *smb)
704{
705 return mid == le16_to_cpu(smb->Mid);
706}
707
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708/*
Pavel Shilovsky24985c52012-09-18 16:20:28 -0700709 * When the server supports very large reads and writes via POSIX extensions,
710 * we can allow up to 2^24-1, minus the size of a READ/WRITE_AND_X header, not
711 * including the RFC1001 length.
712 *
713 * Note that this might make for "interesting" allocation problems during
714 * writeback however as we have to allocate an array of pointers for the
Kirill A. Shutemovea1754a2016-04-01 15:29:48 +0300715 * pages. A 16M write means ~32kb page array with PAGE_SIZE == 4096.
Pavel Shilovsky24985c52012-09-18 16:20:28 -0700716 *
717 * For reads, there is a similar problem as we need to allocate an array
718 * of kvecs to handle the receive, though that should only need to be done
719 * once.
720 */
721#define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
722#define CIFS_MAX_RSIZE ((1<<24) - sizeof(READ_RSP) + 4)
723
724/*
725 * When the server doesn't allow large posix writes, only allow a rsize/wsize
726 * of 2^17-1 minus the size of the call header. That allows for a read or
727 * write up to the maximum size described by RFC1002.
728 */
729#define CIFS_MAX_RFC1002_WSIZE ((1<<17) - 1 - sizeof(WRITE_REQ) + 4)
730#define CIFS_MAX_RFC1002_RSIZE ((1<<17) - 1 - sizeof(READ_RSP) + 4)
731
732/*
733 * The default wsize is 1M. find_get_pages seems to return a maximum of 256
Kirill A. Shutemovea1754a2016-04-01 15:29:48 +0300734 * pages in a single call. With PAGE_SIZE == 4k, this means we can fill
Pavel Shilovsky24985c52012-09-18 16:20:28 -0700735 * a single wsize request with a single call.
736 */
737#define CIFS_DEFAULT_IOSIZE (1024 * 1024)
738
739/*
740 * Windows only supports a max of 60kb reads and 65535 byte writes. Default to
741 * those values when posix extensions aren't in force. In actuality here, we
742 * use 65536 to allow for a write that is a multiple of 4k. Most servers seem
743 * to be ok with the extra byte even though Windows doesn't send writes that
744 * are that large.
745 *
746 * Citation:
747 *
748 * http://blogs.msdn.com/b/openspecification/archive/2009/04/10/smb-maximum-transmit-buffer-size-and-performance-tuning.aspx
749 */
750#define CIFS_DEFAULT_NON_POSIX_RSIZE (60 * 1024)
751#define CIFS_DEFAULT_NON_POSIX_WSIZE (65536)
752
753/*
Rob Landleyf1d0c992011-01-22 15:44:05 -0600754 * Macros to allow the TCP_Server_Info->net field and related code to drop out
755 * when CONFIG_NET_NS isn't set.
756 */
757
758#ifdef CONFIG_NET_NS
759
760static inline struct net *cifs_net_ns(struct TCP_Server_Info *srv)
761{
762 return srv->net;
763}
764
765static inline void cifs_set_net_ns(struct TCP_Server_Info *srv, struct net *net)
766{
767 srv->net = net;
768}
769
770#else
771
772static inline struct net *cifs_net_ns(struct TCP_Server_Info *srv)
773{
774 return &init_net;
775}
776
777static inline void cifs_set_net_ns(struct TCP_Server_Info *srv, struct net *net)
778{
779}
780
781#endif
782
783/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 * Session structure. One of these for each uid session with a particular host
785 */
Steve French96daf2b2011-05-27 04:34:02 +0000786struct cifs_ses {
Jeff Layton14fbf502008-11-14 13:53:46 -0500787 struct list_head smb_ses_list;
Steve French3b795212008-11-13 19:45:32 +0000788 struct list_head tcon_list;
Steve Frenchd7b619c2010-02-25 05:36:46 +0000789 struct mutex session_mutex;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 struct TCP_Server_Info *server; /* pointer to server info */
Jeff Layton14fbf502008-11-14 13:53:46 -0500791 int ses_count; /* reference counter */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 enum statusEnum status;
Steve French750d1152006-06-27 06:28:30 +0000793 unsigned overrideSecFlg; /* if non-zero override global sec flags */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 __u16 ipc_tid; /* special tid for connection to IPC share */
Steve Frenchad009ac2005-04-28 22:41:05 -0700795 char *serverOS; /* name of operating system underlying server */
796 char *serverNOS; /* name of network operating system of server */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 char *serverDomain; /* security realm of server */
Pavel Shilovsky286170a2012-05-25 10:43:58 +0400798 __u64 Suid; /* remote smb uid */
Eric W. Biederman64ed39d2013-02-06 02:30:39 -0800799 kuid_t linux_uid; /* overriding owner of files on the mount */
800 kuid_t cred_uid; /* owner of credentials */
Pavel Shilovsky29e20f92012-07-13 13:58:14 +0400801 unsigned int capabilities;
Steve Frenchd38d8c72007-06-28 19:44:13 +0000802 char serverName[SERVER_NAME_LEN_WITH_NULL * 2]; /* BB make bigger for
Steve Frenchad009ac2005-04-28 22:41:05 -0700803 TCP names - will ipv6 and sctp addresses fit? */
Steve French34c87902011-03-01 05:02:57 +0000804 char *user_name; /* must not be null except during init of sess
805 and after mount option parsing we fill it */
Steve Frenchd38d8c72007-06-28 19:44:13 +0000806 char *domainName;
807 char *password;
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -0500808 struct session_key auth_key;
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500809 struct ntlmssp_auth *ntlmssp; /* ciphertext, flags, server challenge */
Jeff Layton28e11bd2013-05-26 07:01:00 -0400810 enum securityEnum sectype; /* what security flavor was specified? */
811 bool sign; /* is signing required? */
Steve French3b795212008-11-13 19:45:32 +0000812 bool need_reconnect:1; /* connection reset, uid now invalid */
Pavel Shilovsky5478f9b2011-12-27 16:22:00 +0400813#ifdef CONFIG_CIFS_SMB2
814 __u16 session_flags;
Steve French373512e2015-12-18 13:05:30 -0600815 __u8 smb3signingkey[SMB3_SIGN_KEY_SIZE];
816 __u8 smb3encryptionkey[SMB3_SIGN_KEY_SIZE];
817 __u8 smb3decryptionkey[SMB3_SIGN_KEY_SIZE];
818 __u8 preauth_hash[512];
Pavel Shilovsky5478f9b2011-12-27 16:22:00 +0400819#endif /* CONFIG_CIFS_SMB2 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820};
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700821
Pavel Shilovsky29e20f92012-07-13 13:58:14 +0400822static inline bool
823cap_unix(struct cifs_ses *ses)
824{
825 return ses->server->vals->cap_unix & ses->capabilities;
826}
827
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828/*
829 * there is one of these for each connection to a resource on a particular
Steve Frenchd38d8c72007-06-28 19:44:13 +0000830 * session
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 */
Steve French96daf2b2011-05-27 04:34:02 +0000832struct cifs_tcon {
Jeff Laytonf1987b42008-11-15 11:12:47 -0500833 struct list_head tcon_list;
834 int tc_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 struct list_head openFileList;
Steve French96daf2b2011-05-27 04:34:02 +0000836 struct cifs_ses *ses; /* pointer to session associated with */
Steve French254e55e2006-06-04 05:53:15 +0000837 char treeName[MAX_TREE_SIZE + 1]; /* UNC name of resource in ASCII */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 char *nativeFileSystem;
Jeff Layton00e485b2008-12-05 20:41:21 -0500839 char *password; /* for share-level security */
Pavel Shilovskyfaaf9462011-12-27 16:04:00 +0400840 __u32 tid; /* The 4 byte tree id */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 __u16 Flags; /* optional support bits */
842 enum statusEnum tidStatus;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843#ifdef CONFIG_CIFS_STATS
844 atomic_t num_smbs_sent;
Pavel Shilovsky44c58182012-05-28 14:16:31 +0400845 union {
846 struct {
847 atomic_t num_writes;
848 atomic_t num_reads;
849 atomic_t num_flushes;
850 atomic_t num_oplock_brks;
851 atomic_t num_opens;
852 atomic_t num_closes;
853 atomic_t num_deletes;
854 atomic_t num_mkdirs;
855 atomic_t num_posixopens;
856 atomic_t num_posixmkdirs;
857 atomic_t num_rmdirs;
858 atomic_t num_renames;
859 atomic_t num_t2renames;
860 atomic_t num_ffirst;
861 atomic_t num_fnext;
862 atomic_t num_fclose;
863 atomic_t num_hardlinks;
864 atomic_t num_symlinks;
865 atomic_t num_locks;
866 atomic_t num_acl_get;
867 atomic_t num_acl_set;
868 } cifs_stats;
Pavel Shilovskyd60622e2012-05-28 15:19:39 +0400869#ifdef CONFIG_CIFS_SMB2
870 struct {
871 atomic_t smb2_com_sent[NUMBER_OF_SMB2_COMMANDS];
872 atomic_t smb2_com_failed[NUMBER_OF_SMB2_COMMANDS];
873 } smb2_stats;
874#endif /* CONFIG_CIFS_SMB2 */
Pavel Shilovsky44c58182012-05-28 14:16:31 +0400875 } stats;
Steve Frencha5a2b482005-08-20 21:42:53 -0700876#ifdef CONFIG_CIFS_STATS2
877 unsigned long long time_writes;
878 unsigned long long time_reads;
879 unsigned long long time_opens;
880 unsigned long long time_deletes;
881 unsigned long long time_closes;
882 unsigned long long time_mkdirs;
883 unsigned long long time_rmdirs;
884 unsigned long long time_renames;
885 unsigned long long time_t2renames;
886 unsigned long long time_ffirst;
887 unsigned long long time_fnext;
888 unsigned long long time_fclose;
889#endif /* CONFIG_CIFS_STATS2 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 __u64 bytes_read;
891 __u64 bytes_written;
892 spinlock_t stat_lock;
Steve Frencha5a2b482005-08-20 21:42:53 -0700893#endif /* CONFIG_CIFS_STATS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 FILE_SYSTEM_DEVICE_INFO fsDevInfo;
Steve French254e55e2006-06-04 05:53:15 +0000895 FILE_SYSTEM_ATTRIBUTE_INFO fsAttrInfo; /* ok if fs name truncated */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 FILE_SYSTEM_UNIX_INFO fsUnixInfo;
Steve French4b18f2a2008-04-29 00:06:05 +0000897 bool ipc:1; /* set if connection to IPC$ eg for RPC/PIPES */
898 bool retry:1;
899 bool nocase:1;
Steve French95b1cb92008-05-15 16:44:38 +0000900 bool seal:1; /* transport encryption for this mounted share */
Steve French4b18f2a2008-04-29 00:06:05 +0000901 bool unix_ext:1; /* if false disable Linux extensions to CIFS protocol
Steve Frenchc18c8422007-07-18 23:21:09 +0000902 for this mount even if server would support */
Steve French84210e92008-10-23 04:42:37 +0000903 bool local_lease:1; /* check leases (only) on local system not remote */
Steve French64cc2c62009-03-04 19:54:08 +0000904 bool broken_posix_open; /* e.g. Samba server versions < 3.3.2, 3.2.9 */
Steve French3d1a3742014-08-11 21:05:25 -0500905 bool broken_sparse_sup; /* if server or share does not support sparse */
Steve French3b795212008-11-13 19:45:32 +0000906 bool need_reconnect:1; /* connection reset, tid now invalid */
Steve French592fafe2015-11-03 10:08:53 -0600907 bool use_resilient:1; /* use resilient instead of durable handles */
Steve Frenchb618f002015-11-03 09:15:03 -0600908 bool use_persistent:1; /* use persistent instead of durable handles */
Pavel Shilovskyfaaf9462011-12-27 16:04:00 +0400909#ifdef CONFIG_CIFS_SMB2
910 bool print:1; /* set if connection to printer share */
911 bool bad_network_name:1; /* set if ret status STATUS_BAD_NETWORK_NAME */
Steve French769ee6a2013-06-19 14:15:30 -0500912 __le32 capabilities;
Pavel Shilovskyfaaf9462011-12-27 16:04:00 +0400913 __u32 share_flags;
914 __u32 maximal_access;
915 __u32 vol_serial_number;
916 __le64 vol_create_time;
Steven Frenchaf6a12e2013-10-09 20:55:53 -0500917 __u32 ss_flags; /* sector size flags */
918 __u32 perf_sector_size; /* best sector size for perf */
Steve Frenchde9f68d2013-11-15 11:26:24 -0600919 __u32 max_chunks;
920 __u32 max_bytes_chunk;
921 __u32 max_bytes_copy;
Pavel Shilovskyfaaf9462011-12-27 16:04:00 +0400922#endif /* CONFIG_CIFS_SMB2 */
Suresh Jayaramand03382c2010-07-05 18:12:27 +0530923#ifdef CONFIG_CIFS_FSCACHE
924 u64 resource_id; /* server resource id */
925 struct fscache_cookie *fscache; /* cookie for share */
926#endif
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700927 struct list_head pending_opens; /* list of incomplete opens */
Steve Frenchc18c8422007-07-18 23:21:09 +0000928 /* BB add field for back pointer to sb struct(s)? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929};
930
931/*
Jeff Layton7ffec372010-09-29 19:51:11 -0400932 * This is a refcounted and timestamped container for a tcon pointer. The
933 * container holds a tcon reference. It is considered safe to free one of
934 * these when the tl_count goes to 0. The tl_time is the time of the last
935 * "get" on the container.
936 */
937struct tcon_link {
Jeff Laytonb647c352010-10-28 11:16:44 -0400938 struct rb_node tl_rbnode;
Eric W. Biederman6d4a0832013-02-06 01:48:56 -0800939 kuid_t tl_uid;
Jeff Layton9d002df2010-10-06 19:51:11 -0400940 unsigned long tl_flags;
941#define TCON_LINK_MASTER 0
942#define TCON_LINK_PENDING 1
943#define TCON_LINK_IN_TREE 2
944 unsigned long tl_time;
945 atomic_t tl_count;
Steve French96daf2b2011-05-27 04:34:02 +0000946 struct cifs_tcon *tl_tcon;
Jeff Layton7ffec372010-09-29 19:51:11 -0400947};
948
Jeff Layton9d002df2010-10-06 19:51:11 -0400949extern struct tcon_link *cifs_sb_tlink(struct cifs_sb_info *cifs_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -0400950
Steve French96daf2b2011-05-27 04:34:02 +0000951static inline struct cifs_tcon *
Jeff Layton7ffec372010-09-29 19:51:11 -0400952tlink_tcon(struct tcon_link *tlink)
953{
Jeff Layton9d002df2010-10-06 19:51:11 -0400954 return tlink->tl_tcon;
Jeff Layton7ffec372010-09-29 19:51:11 -0400955}
956
Jeff Layton9d002df2010-10-06 19:51:11 -0400957extern void cifs_put_tlink(struct tcon_link *tlink);
Jeff Layton7ffec372010-09-29 19:51:11 -0400958
Jeff Layton13cfb732010-09-29 19:51:11 -0400959static inline struct tcon_link *
960cifs_get_tlink(struct tcon_link *tlink)
961{
Jeff Layton9d002df2010-10-06 19:51:11 -0400962 if (tlink && !IS_ERR(tlink))
963 atomic_inc(&tlink->tl_count);
Jeff Layton13cfb732010-09-29 19:51:11 -0400964 return tlink;
965}
966
Jeff Layton7ffec372010-09-29 19:51:11 -0400967/* This function is always expected to succeed */
Steve French96daf2b2011-05-27 04:34:02 +0000968extern struct cifs_tcon *cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -0400969
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700970#define CIFS_OPLOCK_NO_CHANGE 0xfe
971
972struct cifs_pending_open {
973 struct list_head olist;
974 struct tcon_link *tlink;
975 __u8 lease_key[16];
976 __u32 oplock;
977};
978
Jeff Layton7ffec372010-09-29 19:51:11 -0400979/*
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000980 * This info hangs off the cifsFileInfo structure, pointed to by llist.
981 * This is used to track byte stream locks on the file
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982 */
983struct cifsLockInfo {
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000984 struct list_head llist; /* pointer to next cifsLockInfo */
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400985 struct list_head blist; /* pointer to locks blocked on this */
986 wait_queue_head_t block_q;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000987 __u64 offset;
988 __u64 length;
Pavel Shilovsky03776f42010-08-17 11:26:00 +0400989 __u32 pid;
Pavel Shilovsky04a6aa82012-02-28 14:16:55 +0300990 __u32 type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991};
992
993/*
994 * One of these for each open instance of a file
995 */
996struct cifs_search_info {
997 loff_t index_of_last_entry;
998 __u16 entries_in_buffer;
999 __u16 info_level;
1000 __u32 resume_key;
Steve Frenchd38d8c72007-06-28 19:44:13 +00001001 char *ntwrk_buf_start;
1002 char *srch_entries_start;
Steve French0752f152008-10-07 20:03:33 +00001003 char *last_entry;
Christoph Hellwigeaf35b12011-07-16 15:24:37 -04001004 const char *presume_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 unsigned int resume_name_len;
Steve French4b18f2a2008-04-29 00:06:05 +00001006 bool endOfSearch:1;
1007 bool emptyDir:1;
1008 bool unicode:1;
1009 bool smallBuf:1; /* so we know which buf_release function to call */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010};
1011
Pavel Shilovsky226730b2013-07-05 12:00:30 +04001012struct cifs_open_parms {
1013 struct cifs_tcon *tcon;
1014 struct cifs_sb_info *cifs_sb;
1015 int disposition;
1016 int desired_access;
1017 int create_options;
1018 const char *path;
1019 struct cifs_fid *fid;
Pavel Shilovsky9cbc0b72013-07-09 18:40:58 +04001020 bool reconnect:1;
Pavel Shilovsky226730b2013-07-05 12:00:30 +04001021};
1022
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07001023struct cifs_fid {
1024 __u16 netfid;
Pavel Shilovskyf0df7372012-09-18 16:20:26 -07001025#ifdef CONFIG_CIFS_SMB2
1026 __u64 persistent_fid; /* persist file id for smb2 */
1027 __u64 volatile_fid; /* volatile file id for smb2 */
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -07001028 __u8 lease_key[SMB2_LEASE_KEY_SIZE]; /* lease key for smb2 */
Steve Frenchb56eae42015-11-03 09:26:27 -06001029 __u8 create_guid[16];
Pavel Shilovskyf0df7372012-09-18 16:20:26 -07001030#endif
Pavel Shilovsky233839b2012-09-19 06:22:45 -07001031 struct cifs_pending_open *pending_open;
Pavel Shilovsky42873b02013-09-05 21:30:16 +04001032 unsigned int epoch;
1033 bool purge_cache;
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07001034};
1035
Pavel Shilovskyf45d3412012-09-19 06:22:43 -07001036struct cifs_fid_locks {
1037 struct list_head llist;
1038 struct cifsFileInfo *cfile; /* fid that owns locks */
1039 struct list_head locks; /* locks held by fid above */
1040};
1041
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042struct cifsFileInfo {
1043 struct list_head tlist; /* pointer to next fid owned by tcon */
1044 struct list_head flist; /* next fid (file instance) for this inode */
Pavel Shilovskyf45d3412012-09-19 06:22:43 -07001045 struct cifs_fid_locks *llist; /* brlocks held by this fid */
Eric W. Biedermanfef59fd2013-02-06 02:23:02 -08001046 kuid_t uid; /* allows finding which FileInfo structure */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047 __u32 pid; /* process id who opened file */
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07001048 struct cifs_fid fid; /* file id from remote */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 /* BB add lock scope info here if needed */ ;
1050 /* lock scope id (0 if none) */
Jeff Laytona5e18bc2010-10-11 15:07:18 -04001051 struct dentry *dentry;
Jeff Layton15886172010-10-15 15:33:59 -04001052 unsigned int f_flags;
Jeff Layton13cfb732010-09-29 19:51:11 -04001053 struct tcon_link *tlink;
Steve French4b18f2a2008-04-29 00:06:05 +00001054 bool invalidHandle:1; /* file closed via session abend */
Jeff Layton3bc303c2009-09-21 06:47:50 -04001055 bool oplock_break_cancelled:1;
Steve French6c0f6212010-10-23 16:51:40 +00001056 int count; /* refcount protected by cifs_file_list_lock */
Steve Frencha6ce4932009-04-09 01:14:32 +00001057 struct mutex fh_mutex; /* prevents reopen race after dead ses*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058 struct cifs_search_info srch_inf;
Tejun Heo9b646972010-07-20 22:09:02 +02001059 struct work_struct oplock_break; /* work for oplock breaks */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060};
1061
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001062struct cifs_io_parms {
1063 __u16 netfid;
Pavel Shilovsky09a47072012-09-18 16:20:29 -07001064#ifdef CONFIG_CIFS_SMB2
1065 __u64 persistent_fid; /* persist file id for smb2 */
1066 __u64 volatile_fid; /* volatile file id for smb2 */
1067#endif
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001068 __u32 pid;
1069 __u64 offset;
1070 unsigned int length;
Steve French96daf2b2011-05-27 04:34:02 +00001071 struct cifs_tcon *tcon;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001072};
1073
Pavel Shilovsky09a47072012-09-18 16:20:29 -07001074struct cifs_readdata;
1075
1076/* asynchronous read support */
1077struct cifs_readdata {
1078 struct kref refcount;
1079 struct list_head list;
1080 struct completion done;
1081 struct cifsFileInfo *cfile;
1082 struct address_space *mapping;
1083 __u64 offset;
1084 unsigned int bytes;
Pavel Shilovsky34a54d62014-07-10 10:03:29 +04001085 unsigned int got_bytes;
Pavel Shilovsky09a47072012-09-18 16:20:29 -07001086 pid_t pid;
1087 int result;
Pavel Shilovsky09a47072012-09-18 16:20:29 -07001088 struct work_struct work;
Jeff Layton8321fec2012-09-19 06:22:32 -07001089 int (*read_into_pages)(struct TCP_Server_Info *server,
1090 struct cifs_readdata *rdata,
1091 unsigned int len);
Jeff Layton58195752012-09-19 06:22:34 -07001092 struct kvec iov;
Jeff Layton8321fec2012-09-19 06:22:32 -07001093 unsigned int pagesz;
1094 unsigned int tailsz;
Pavel Shilovskybed9da02014-06-25 11:28:57 +04001095 unsigned int credits;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07001096 unsigned int nr_pages;
1097 struct page *pages[];
Pavel Shilovsky09a47072012-09-18 16:20:29 -07001098};
1099
Pavel Shilovsky33319142012-09-18 16:20:29 -07001100struct cifs_writedata;
1101
1102/* asynchronous write support */
1103struct cifs_writedata {
1104 struct kref refcount;
1105 struct list_head list;
1106 struct completion done;
1107 enum writeback_sync_modes sync_mode;
1108 struct work_struct work;
1109 struct cifsFileInfo *cfile;
1110 __u64 offset;
1111 pid_t pid;
1112 unsigned int bytes;
1113 int result;
Jeff Laytoneddb0792012-09-18 16:20:35 -07001114 unsigned int pagesz;
1115 unsigned int tailsz;
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04001116 unsigned int credits;
Pavel Shilovsky33319142012-09-18 16:20:29 -07001117 unsigned int nr_pages;
Jeff Layton26c8f0d2014-02-07 11:04:04 -05001118 struct page *pages[];
Pavel Shilovsky33319142012-09-18 16:20:29 -07001119};
1120
Jeff Layton5f6dbc92010-10-15 15:34:06 -04001121/*
1122 * Take a reference on the file private data. Must be called with
1123 * cifs_file_list_lock held.
1124 */
Jeff Layton764a1b12012-07-25 14:59:54 -04001125static inline void
1126cifsFileInfo_get_locked(struct cifsFileInfo *cifs_file)
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001127{
Jeff Layton5f6dbc92010-10-15 15:34:06 -04001128 ++cifs_file->count;
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001129}
1130
Jeff Layton764a1b12012-07-25 14:59:54 -04001131struct cifsFileInfo *cifsFileInfo_get(struct cifsFileInfo *cifs_file);
Jeff Laytonb33879a2010-10-15 15:34:04 -04001132void cifsFileInfo_put(struct cifsFileInfo *cifs_file);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001133
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04001134#define CIFS_CACHE_READ_FLG 1
1135#define CIFS_CACHE_HANDLE_FLG 2
Pavel Shilovsky42873b02013-09-05 21:30:16 +04001136#define CIFS_CACHE_RH_FLG (CIFS_CACHE_READ_FLG | CIFS_CACHE_HANDLE_FLG)
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04001137#define CIFS_CACHE_WRITE_FLG 4
Pavel Shilovsky42873b02013-09-05 21:30:16 +04001138#define CIFS_CACHE_RW_FLG (CIFS_CACHE_READ_FLG | CIFS_CACHE_WRITE_FLG)
1139#define CIFS_CACHE_RHW_FLG (CIFS_CACHE_RW_FLG | CIFS_CACHE_HANDLE_FLG)
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04001140
1141#define CIFS_CACHE_READ(cinode) (cinode->oplock & CIFS_CACHE_READ_FLG)
Pavel Shilovsky53ef1012013-09-05 16:11:28 +04001142#define CIFS_CACHE_HANDLE(cinode) (cinode->oplock & CIFS_CACHE_HANDLE_FLG)
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04001143#define CIFS_CACHE_WRITE(cinode) (cinode->oplock & CIFS_CACHE_WRITE_FLG)
1144
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145/*
1146 * One of these for each file inode
1147 */
1148
1149struct cifsInodeInfo {
Pavel Shilovskyd59dad22011-09-22 09:53:59 +04001150 bool can_cache_brlcks;
Pavel Shilovskyf45d3412012-09-19 06:22:43 -07001151 struct list_head llist; /* locks helb by this inode */
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -07001152 struct rw_semaphore lock_sem; /* protect the fields above */
Steve Frenchd38d8c72007-06-28 19:44:13 +00001153 /* BB add in lists for dirty pages i.e. write caching info for oplock */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 struct list_head openFileList;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155 __u32 cifsAttrs; /* e.g. DOS archive bit, sparse, compressed, system */
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04001156 unsigned int oplock; /* oplock/lease level we have */
Pavel Shilovsky42873b02013-09-05 21:30:16 +04001157 unsigned int epoch; /* used to track lease state changes */
Sachin Prabhuc11f1df2014-03-11 16:11:47 +00001158#define CIFS_INODE_PENDING_OPLOCK_BREAK (0) /* oplock break in progress */
1159#define CIFS_INODE_PENDING_WRITERS (1) /* Writes in progress */
1160#define CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2 (2) /* Downgrade oplock to L2 */
Jeff Laytonaff8d5c2014-04-30 09:31:45 -04001161#define CIFS_INO_DELETE_PENDING (3) /* delete pending on server */
1162#define CIFS_INO_INVALID_MAPPING (4) /* pagecache is invalid */
Jeff Layton4f73c7d2014-04-30 09:31:47 -04001163#define CIFS_INO_LOCK (5) /* lock bit for synchronization */
Jeff Laytonaff8d5c2014-04-30 09:31:45 -04001164 unsigned long flags;
Sachin Prabhuc11f1df2014-03-11 16:11:47 +00001165 spinlock_t writers_lock;
1166 unsigned int writers; /* Number of writers on this inode */
Jeff Laytonaae62fd2011-01-20 13:36:50 -05001167 unsigned long time; /* jiffies of last update of inode */
Jeff Layton597b0272012-03-23 14:40:56 -04001168 u64 server_eof; /* current file size on server -- protected by i_lock */
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001169 u64 uniqueid; /* server inode number */
Jeff Layton20054bd2011-01-07 11:30:27 -05001170 u64 createtime; /* creation time on server */
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -07001171#ifdef CONFIG_CIFS_SMB2
1172 __u8 lease_key[SMB2_LEASE_KEY_SIZE]; /* lease key for this inode */
1173#endif
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +05301174#ifdef CONFIG_CIFS_FSCACHE
1175 struct fscache_cookie *fscache;
1176#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 struct inode vfs_inode;
1178};
1179
1180static inline struct cifsInodeInfo *
1181CIFS_I(struct inode *inode)
1182{
1183 return container_of(inode, struct cifsInodeInfo, vfs_inode);
1184}
1185
1186static inline struct cifs_sb_info *
1187CIFS_SB(struct super_block *sb)
1188{
1189 return sb->s_fs_info;
1190}
1191
Al Viro7119e222014-10-22 00:25:12 -04001192static inline struct cifs_sb_info *
1193CIFS_FILE_SB(struct file *file)
1194{
1195 return CIFS_SB(file_inode(file)->i_sb);
1196}
1197
Steve Frenchab2f2182005-09-15 20:44:50 -07001198static inline char CIFS_DIR_SEP(const struct cifs_sb_info *cifs_sb)
Jeremy Allisonac670552005-06-22 17:26:35 -07001199{
1200 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
1201 return '/';
1202 else
1203 return '\\';
1204}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205
Steve Frenchf87d39d2011-05-27 03:50:55 +00001206static inline void
1207convert_delimiter(char *path, char delim)
1208{
Steve French1cc9bd62012-11-29 18:07:51 -06001209 char old_delim, *pos;
Steve Frenchf87d39d2011-05-27 03:50:55 +00001210
1211 if (delim == '/')
1212 old_delim = '\\';
1213 else
1214 old_delim = '/';
1215
Steve French1cc9bd62012-11-29 18:07:51 -06001216 pos = path;
1217 while ((pos = strchr(pos, old_delim)))
1218 *pos = delim;
Steve Frenchf87d39d2011-05-27 03:50:55 +00001219}
1220
Steve Frencha4544342005-08-24 13:59:35 -07001221#ifdef CONFIG_CIFS_STATS
1222#define cifs_stats_inc atomic_inc
1223
Steve French96daf2b2011-05-27 04:34:02 +00001224static inline void cifs_stats_bytes_written(struct cifs_tcon *tcon,
Steve Frencha4544342005-08-24 13:59:35 -07001225 unsigned int bytes)
1226{
1227 if (bytes) {
1228 spin_lock(&tcon->stat_lock);
1229 tcon->bytes_written += bytes;
1230 spin_unlock(&tcon->stat_lock);
1231 }
1232}
1233
Steve French96daf2b2011-05-27 04:34:02 +00001234static inline void cifs_stats_bytes_read(struct cifs_tcon *tcon,
Steve Frencha4544342005-08-24 13:59:35 -07001235 unsigned int bytes)
1236{
1237 spin_lock(&tcon->stat_lock);
1238 tcon->bytes_read += bytes;
1239 spin_unlock(&tcon->stat_lock);
1240}
1241#else
1242
Steve Frenchd38d8c72007-06-28 19:44:13 +00001243#define cifs_stats_inc(field) do {} while (0)
1244#define cifs_stats_bytes_written(tcon, bytes) do {} while (0)
1245#define cifs_stats_bytes_read(tcon, bytes) do {} while (0)
Steve Frencha4544342005-08-24 13:59:35 -07001246
1247#endif
1248
Jeff Layton2b84a36c2011-01-11 07:24:21 -05001249
1250/*
Jeff Layton44d22d82011-10-19 15:29:49 -04001251 * This is the prototype for the mid receive function. This function is for
1252 * receiving the rest of the SMB frame, starting with the WordCount (which is
1253 * just after the MID in struct smb_hdr). Note:
1254 *
1255 * - This will be called by cifsd, with no locks held.
1256 * - The mid will still be on the pending_mid_q.
1257 * - mid->resp_buf will point to the current buffer.
1258 *
1259 * Returns zero on a successful receive, or an error. The receive state in
1260 * the TCP_Server_Info will also be updated.
1261 */
1262typedef int (mid_receive_t)(struct TCP_Server_Info *server,
1263 struct mid_q_entry *mid);
1264
1265/*
1266 * This is the prototype for the mid callback function. This is called once the
1267 * mid has been received off of the socket. When creating one, take special
1268 * care to avoid deadlocks. Things to bear in mind:
Jeff Layton2b84a36c2011-01-11 07:24:21 -05001269 *
Jeff Layton3c1105d2011-05-22 07:09:13 -04001270 * - it will be called by cifsd, with no locks held
1271 * - the mid will be removed from any lists
Jeff Layton2b84a36c2011-01-11 07:24:21 -05001272 */
1273typedef void (mid_callback_t)(struct mid_q_entry *mid);
1274
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275/* one of these for every pending CIFS request to the server */
1276struct mid_q_entry {
1277 struct list_head qhead; /* mids waiting on reply from this server */
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +04001278 struct TCP_Server_Info *server; /* server corresponding to this mid */
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001279 __u64 mid; /* multiplex id */
1280 __u32 pid; /* process id */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 __u32 sequence_number; /* for CIFS signing */
Steve French1047abc2005-10-11 19:58:06 -07001282 unsigned long when_alloc; /* when mid was created */
1283#ifdef CONFIG_CIFS_STATS2
1284 unsigned long when_sent; /* time when smb send finished */
1285 unsigned long when_received; /* when demux complete (taken off wire) */
1286#endif
Jeff Layton44d22d82011-10-19 15:29:49 -04001287 mid_receive_t *receive; /* call receive callback */
Jeff Layton2b84a36c2011-01-11 07:24:21 -05001288 mid_callback_t *callback; /* call completion callback */
1289 void *callback_data; /* general purpose pointer for callback */
Pavel Shilovskyd4e48542012-03-23 14:28:02 -04001290 void *resp_buf; /* pointer to received SMB header */
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001291 int mid_state; /* wish this were enum but can not pass to wait_event */
1292 __le16 command; /* smb command code */
1293 bool large_buf:1; /* if valid response, is pointer to large buf */
Steve French4b18f2a2008-04-29 00:06:05 +00001294 bool multiRsp:1; /* multiple trans2 responses for one request */
1295 bool multiEnd:1; /* both received */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296};
1297
Steve French789e6662011-08-09 18:44:44 +00001298/* Make code in transport.c a little cleaner by moving
1299 update of optional stats into function below */
1300#ifdef CONFIG_CIFS_STATS2
1301
1302static inline void cifs_in_send_inc(struct TCP_Server_Info *server)
1303{
1304 atomic_inc(&server->in_send);
1305}
1306
1307static inline void cifs_in_send_dec(struct TCP_Server_Info *server)
1308{
1309 atomic_dec(&server->in_send);
1310}
1311
1312static inline void cifs_num_waiters_inc(struct TCP_Server_Info *server)
1313{
1314 atomic_inc(&server->num_waiters);
1315}
1316
1317static inline void cifs_num_waiters_dec(struct TCP_Server_Info *server)
1318{
1319 atomic_dec(&server->num_waiters);
1320}
1321
1322static inline void cifs_save_when_sent(struct mid_q_entry *mid)
1323{
1324 mid->when_sent = jiffies;
1325}
1326#else
1327static inline void cifs_in_send_inc(struct TCP_Server_Info *server)
1328{
1329}
1330static inline void cifs_in_send_dec(struct TCP_Server_Info *server)
1331{
1332}
1333
1334static inline void cifs_num_waiters_inc(struct TCP_Server_Info *server)
1335{
1336}
1337
1338static inline void cifs_num_waiters_dec(struct TCP_Server_Info *server)
1339{
1340}
1341
1342static inline void cifs_save_when_sent(struct mid_q_entry *mid)
1343{
1344}
1345#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346
Steve Frenchff5dbd92005-08-24 17:10:36 -07001347/* for pending dnotify requests */
1348struct dir_notify_req {
Steve French13cd4b72010-10-07 18:46:32 +00001349 struct list_head lhead;
1350 __le16 Pid;
1351 __le16 PidHigh;
1352 __u16 Mid;
1353 __u16 Tid;
1354 __u16 Uid;
1355 __u16 netfid;
1356 __u32 filter; /* CompletionFilter (for multishot) */
1357 int multishot;
1358 struct file *pfile;
Steve Frenchff5dbd92005-08-24 17:10:36 -07001359};
1360
Steve French366781c2008-01-25 10:12:41 +00001361struct dfs_info3_param {
1362 int flags; /* DFSREF_REFERRAL_SERVER, DFSREF_STORAGE_SERVER*/
Igor Mammedov8aad0182008-02-15 18:21:49 +00001363 int path_consumed;
Steve French366781c2008-01-25 10:12:41 +00001364 int server_type;
1365 int ref_flag;
1366 char *path_name;
1367 char *node_name;
1368};
1369
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001370/*
1371 * common struct for holding inode info when searching for or updating an
1372 * inode with new info
1373 */
1374
1375#define CIFS_FATTR_DFS_REFERRAL 0x1
Jeff Layton0b8f18e2009-07-09 01:46:37 -04001376#define CIFS_FATTR_DELETE_PENDING 0x2
1377#define CIFS_FATTR_NEED_REVAL 0x4
Jeff Layton3d694382010-05-11 14:59:55 -04001378#define CIFS_FATTR_INO_COLLISION 0x8
Jim McDonough74d290d2013-09-21 10:36:10 -05001379#define CIFS_FATTR_UNKNOWN_NLINK 0x10
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001380
1381struct cifs_fattr {
1382 u32 cf_flags;
1383 u32 cf_cifsattrs;
1384 u64 cf_uniqueid;
1385 u64 cf_eof;
1386 u64 cf_bytes;
Jeff Layton20054bd2011-01-07 11:30:27 -05001387 u64 cf_createtime;
Eric W. Biederman4a2c8cf2013-02-06 01:53:25 -08001388 kuid_t cf_uid;
1389 kgid_t cf_gid;
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001390 umode_t cf_mode;
1391 dev_t cf_rdev;
1392 unsigned int cf_nlink;
1393 unsigned int cf_dtype;
1394 struct timespec cf_atime;
1395 struct timespec cf_mtime;
1396 struct timespec cf_ctime;
1397};
1398
Steve French366781c2008-01-25 10:12:41 +00001399static inline void free_dfs_info_param(struct dfs_info3_param *param)
1400{
1401 if (param) {
1402 kfree(param->path_name);
1403 kfree(param->node_name);
1404 kfree(param);
1405 }
1406}
1407
1408static inline void free_dfs_info_array(struct dfs_info3_param *param,
1409 int number_of_items)
1410{
1411 int i;
1412 if ((number_of_items == 0) || (param == NULL))
1413 return;
1414 for (i = 0; i < number_of_items; i++) {
1415 kfree(param[i].path_name);
1416 kfree(param[i].node_name);
1417 }
1418 kfree(param);
1419}
1420
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421#define MID_FREE 0
1422#define MID_REQUEST_ALLOCATED 1
1423#define MID_REQUEST_SUBMITTED 2
1424#define MID_RESPONSE_RECEIVED 4
1425#define MID_RETRY_NEEDED 8 /* session closed while this request out */
Jeff Layton71823ba2011-02-10 08:03:50 -05001426#define MID_RESPONSE_MALFORMED 0x10
Jeff Layton3c1105d2011-05-22 07:09:13 -04001427#define MID_SHUTDOWN 0x20
Steve Frenchec637e32005-12-12 20:53:18 -08001428
1429/* Types of response buffer returned from SendReceive2 */
1430#define CIFS_NO_BUFFER 0 /* Response buffer not returned */
1431#define CIFS_SMALL_BUFFER 1
1432#define CIFS_LARGE_BUFFER 2
1433#define CIFS_IOVEC 4 /* array of response buffers */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434
Steve French133672e2007-11-13 22:41:37 +00001435/* Type of Request to SendReceive2 */
Jeff Layton77499812011-01-11 07:24:23 -05001436#define CIFS_BLOCKING_OP 1 /* operation can block */
1437#define CIFS_ASYNC_OP 2 /* do not wait for response */
1438#define CIFS_TIMEOUT_MASK 0x003 /* only one of above set in req */
Steve French133672e2007-11-13 22:41:37 +00001439#define CIFS_LOG_ERROR 0x010 /* log NT STATUS if non-zero */
1440#define CIFS_LARGE_BUF_OP 0x020 /* large request buffer */
1441#define CIFS_NO_RESP 0x040 /* no response buffer required */
1442
Pavel Shilovskya891f0f2012-05-23 16:14:34 +04001443/* Type of request operation */
1444#define CIFS_ECHO_OP 0x080 /* echo request */
1445#define CIFS_OBREAK_OP 0x0100 /* oplock break request */
Pavel Shilovskyec2e4522011-12-27 16:12:43 +04001446#define CIFS_NEG_OP 0x0200 /* negotiate request */
1447#define CIFS_OP_MASK 0x0380 /* mask request type */
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04001448#define CIFS_HAS_CREDITS 0x0400 /* already has credits */
Pavel Shilovskya891f0f2012-05-23 16:14:34 +04001449
Steve French39798772006-05-31 22:40:51 +00001450/* Security Flags: indicate type of session setup needed */
1451#define CIFSSEC_MAY_SIGN 0x00001
1452#define CIFSSEC_MAY_NTLM 0x00002
1453#define CIFSSEC_MAY_NTLMV2 0x00004
1454#define CIFSSEC_MAY_KRB5 0x00008
1455#ifdef CONFIG_CIFS_WEAK_PW_HASH
1456#define CIFSSEC_MAY_LANMAN 0x00010
1457#define CIFSSEC_MAY_PLNTXT 0x00020
Steve French516897a2007-10-12 19:24:06 +00001458#else
1459#define CIFSSEC_MAY_LANMAN 0
1460#define CIFSSEC_MAY_PLNTXT 0
Steve French39798772006-05-31 22:40:51 +00001461#endif /* weak passwords */
1462#define CIFSSEC_MAY_SEAL 0x00040 /* not supported yet */
Steve Frenchac683922009-05-06 04:16:04 +00001463#define CIFSSEC_MAY_NTLMSSP 0x00080 /* raw ntlmssp with ntlmv2 */
Steve French5815449d2006-02-14 01:36:20 +00001464
Steve French39798772006-05-31 22:40:51 +00001465#define CIFSSEC_MUST_SIGN 0x01001
1466/* note that only one of the following can be set so the
1467result of setting MUST flags more than once will be to
1468require use of the stronger protocol */
1469#define CIFSSEC_MUST_NTLM 0x02002
1470#define CIFSSEC_MUST_NTLMV2 0x04004
1471#define CIFSSEC_MUST_KRB5 0x08008
1472#ifdef CONFIG_CIFS_WEAK_PW_HASH
1473#define CIFSSEC_MUST_LANMAN 0x10010
1474#define CIFSSEC_MUST_PLNTXT 0x20020
Jeff Layton0d3a01f2007-10-16 17:32:19 +00001475#ifdef CONFIG_CIFS_UPCALL
Chuck Ebbert20d17522009-09-15 01:53:21 -04001476#define CIFSSEC_MASK 0xBF0BF /* allows weak security but also krb5 */
Steve Frenchd38d8c72007-06-28 19:44:13 +00001477#else
Chuck Ebbert20d17522009-09-15 01:53:21 -04001478#define CIFSSEC_MASK 0xB70B7 /* current flags supported if weak */
Steve French016ec752007-10-16 18:10:10 +00001479#endif /* UPCALL */
Jeff Layton0d3a01f2007-10-16 17:32:19 +00001480#else /* do not allow weak pw hash */
Steve French88a44122012-01-18 17:13:47 -06001481#define CIFSSEC_MUST_LANMAN 0
1482#define CIFSSEC_MUST_PLNTXT 0
Jeff Layton0d3a01f2007-10-16 17:32:19 +00001483#ifdef CONFIG_CIFS_UPCALL
Steve Frenchac683922009-05-06 04:16:04 +00001484#define CIFSSEC_MASK 0x8F08F /* flags supported if no weak allowed */
Jeff Layton0d3a01f2007-10-16 17:32:19 +00001485#else
Steve Frenchac683922009-05-06 04:16:04 +00001486#define CIFSSEC_MASK 0x87087 /* flags supported if no weak allowed */
Steve French016ec752007-10-16 18:10:10 +00001487#endif /* UPCALL */
Steve French39798772006-05-31 22:40:51 +00001488#endif /* WEAK_PW_HASH */
1489#define CIFSSEC_MUST_SEAL 0x40040 /* not supported yet */
Steve Frenchac683922009-05-06 04:16:04 +00001490#define CIFSSEC_MUST_NTLMSSP 0x80080 /* raw ntlmssp with ntlmv2 */
Steve French39798772006-05-31 22:40:51 +00001491
Jeff Layton896a8fc2013-05-26 07:01:01 -04001492#define CIFSSEC_DEF (CIFSSEC_MAY_SIGN | CIFSSEC_MAY_NTLMV2 | CIFSSEC_MAY_NTLMSSP)
Shirish Pargaonkaref571ca2008-07-24 15:56:05 +00001493#define CIFSSEC_MAX (CIFSSEC_MUST_SIGN | CIFSSEC_MUST_NTLMV2)
Steve Frenchac683922009-05-06 04:16:04 +00001494#define CIFSSEC_AUTH_MASK (CIFSSEC_MAY_NTLM | CIFSSEC_MAY_NTLMV2 | CIFSSEC_MAY_LANMAN | CIFSSEC_MAY_PLNTXT | CIFSSEC_MAY_KRB5 | CIFSSEC_MAY_NTLMSSP)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495/*
1496 *****************************************************************
1497 * All constants go here
1498 *****************************************************************
1499 */
1500
1501#define UID_HASH (16)
1502
1503/*
1504 * Note that ONE module should define _DECLARE_GLOBALS_HERE to cause the
1505 * following to be declared.
1506 */
1507
1508/****************************************************************************
1509 * Locking notes. All updates to global variables and lists should be
1510 * protected by spinlocks or semaphores.
1511 *
1512 * Spinlocks
1513 * ---------
1514 * GlobalMid_Lock protects:
1515 * list operations on pending_mid_q and oplockQ
1516 * updates to XID counters, multiplex id and SMB sequence numbers
Suresh Jayaraman6573e9b2010-10-18 23:52:18 +05301517 * cifs_file_list_lock protects:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518 * list operations on tcp and SMB session lists and tCon lists
1519 * f_owner.lock protects certain per file struct operations
1520 * mapping->page_lock protects certain per page operations
1521 *
1522 * Semaphores
1523 * ----------
1524 * sesSem operations on smb session
1525 * tconSem operations on tree connection
Steve Frenchd38d8c72007-06-28 19:44:13 +00001526 * fh_sem file handle reconnection operations
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527 *
1528 ****************************************************************************/
1529
1530#ifdef DECLARE_GLOBALS_HERE
1531#define GLOBAL_EXTERN
1532#else
1533#define GLOBAL_EXTERN extern
1534#endif
1535
Jeff Laytone7ddee92008-11-14 13:44:38 -05001536/*
1537 * the list of TCP_Server_Info structures, ie each of the sockets
Steve Frenchfb396012008-11-13 20:04:07 +00001538 * connecting our client to a distinct server (ip address), is
Jeff Laytone7ddee92008-11-14 13:44:38 -05001539 * chained together by cifs_tcp_ses_list. The list of all our SMB
Steve Frenchfb396012008-11-13 20:04:07 +00001540 * sessions (and from that the tree connections) can be found
Jeff Laytone7ddee92008-11-14 13:44:38 -05001541 * by iterating over cifs_tcp_ses_list
1542 */
1543GLOBAL_EXTERN struct list_head cifs_tcp_ses_list;
1544
Jeff Laytonf1987b42008-11-15 11:12:47 -05001545/*
1546 * This lock protects the cifs_tcp_ses_list, the list of smb sessions per
1547 * tcp session, and the list of tcon's per smb session. It also protects
1548 * the reference counters for the server, smb session, and tcon. Finally,
1549 * changes to the tcon->tidStatus should be done while holding this lock.
1550 */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301551GLOBAL_EXTERN spinlock_t cifs_tcp_ses_lock;
Steve Frenchddb4cbf2008-11-20 20:00:44 +00001552
1553/*
1554 * This lock protects the cifs_file->llist and cifs_file->flist
1555 * list operations, and updates to some flags (cifs_file->invalidHandle)
1556 * It will be moved to either use the tcon->stat_lock or equivalent later.
1557 * If cifs_tcp_ses_lock and the lock below are both needed to be held, then
1558 * the cifs_tcp_ses_lock must be grabbed first and released last.
1559 */
Jeff Layton44772882010-10-15 15:34:03 -04001560GLOBAL_EXTERN spinlock_t cifs_file_list_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561
Steve French0eff0e22011-02-24 05:39:23 +00001562#ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
Steve French99ee4db2007-02-27 05:35:17 +00001563/* Outstanding dir notify requests */
1564GLOBAL_EXTERN struct list_head GlobalDnotifyReqList;
1565/* DirNotify response queue */
1566GLOBAL_EXTERN struct list_head GlobalDnotifyRsp_Q;
Steve French0eff0e22011-02-24 05:39:23 +00001567#endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
Steve Frenchff5dbd92005-08-24 17:10:36 -07001568
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569/*
1570 * Global transaction id (XID) information
1571 */
1572GLOBAL_EXTERN unsigned int GlobalCurrentXid; /* protected by GlobalMid_Sem */
Steve French254e55e2006-06-04 05:53:15 +00001573GLOBAL_EXTERN unsigned int GlobalTotalActiveXid; /* prot by GlobalMid_Sem */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574GLOBAL_EXTERN unsigned int GlobalMaxActiveXid; /* prot by GlobalMid_Sem */
Steve French254e55e2006-06-04 05:53:15 +00001575GLOBAL_EXTERN spinlock_t GlobalMid_Lock; /* protects above & list operations */
1576 /* on midQ entries */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577/*
1578 * Global counters, updated atomically
1579 */
1580GLOBAL_EXTERN atomic_t sesInfoAllocCount;
1581GLOBAL_EXTERN atomic_t tconInfoAllocCount;
1582GLOBAL_EXTERN atomic_t tcpSesAllocCount;
1583GLOBAL_EXTERN atomic_t tcpSesReconnectCount;
1584GLOBAL_EXTERN atomic_t tconInfoReconnectCount;
1585
Steve Frenchaaa9bbe2008-05-23 17:38:32 +00001586/* Various Debug counters */
Steve French4498eed52005-12-03 13:58:57 -08001587GLOBAL_EXTERN atomic_t bufAllocCount; /* current number allocated */
1588#ifdef CONFIG_CIFS_STATS2
1589GLOBAL_EXTERN atomic_t totBufAllocCount; /* total allocated over all time */
1590GLOBAL_EXTERN atomic_t totSmBufAllocCount;
1591#endif
1592GLOBAL_EXTERN atomic_t smBufAllocCount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593GLOBAL_EXTERN atomic_t midCount;
1594
1595/* Misc globals */
Jeff Layton5e500ed2012-05-16 07:13:17 -04001596GLOBAL_EXTERN bool enable_oplocks; /* enable or disable oplocks */
Kees Cook14042972016-03-17 14:22:54 -07001597GLOBAL_EXTERN bool lookupCacheEnabled;
Jeff Layton04912d62010-04-24 07:57:45 -04001598GLOBAL_EXTERN unsigned int global_secflags; /* if on, session setup sent
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599 with more secure ntlmssp2 challenge/resp */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600GLOBAL_EXTERN unsigned int sign_CIFS_PDUs; /* enable smb packet signing */
Kees Cook14042972016-03-17 14:22:54 -07001601GLOBAL_EXTERN bool linuxExtEnabled;/*enable Linux/Unix CIFS extensions*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602GLOBAL_EXTERN unsigned int CIFSMaxBufSize; /* max size not including hdr */
1603GLOBAL_EXTERN unsigned int cifs_min_rcv; /* min size of big ntwrk buf pool */
1604GLOBAL_EXTERN unsigned int cifs_min_small; /* min size of small buf pool */
1605GLOBAL_EXTERN unsigned int cifs_max_pending; /* MAX requests at once to server*/
1606
Shirish Pargaonkar21fed0d2011-08-09 14:30:48 -05001607#ifdef CONFIG_CIFS_ACL
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001608GLOBAL_EXTERN struct rb_root uidtree;
1609GLOBAL_EXTERN struct rb_root gidtree;
1610GLOBAL_EXTERN spinlock_t siduidlock;
1611GLOBAL_EXTERN spinlock_t sidgidlock;
Shirish Pargaonkar21fed0d2011-08-09 14:30:48 -05001612GLOBAL_EXTERN struct rb_root siduidtree;
1613GLOBAL_EXTERN struct rb_root sidgidtree;
1614GLOBAL_EXTERN spinlock_t uidsidlock;
1615GLOBAL_EXTERN spinlock_t gidsidlock;
1616#endif /* CONFIG_CIFS_ACL */
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001617
Tejun Heo9b646972010-07-20 22:09:02 +02001618void cifs_oplock_break(struct work_struct *work);
Linus Torvalds3b7433b2010-08-07 12:42:58 -07001619
Jeff Layton3bc303c2009-09-21 06:47:50 -04001620extern const struct slow_work_ops cifs_oplock_break_ops;
Jeff Laytonda472fc2012-03-23 14:40:53 -04001621extern struct workqueue_struct *cifsiod_wq;
Suresh Jayaramanabd2e442010-06-22 20:52:50 +05301622
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +04001623extern mempool_t *cifs_mid_poolp;
1624
Jeff Layton23db65f2012-05-15 12:20:51 -04001625/* Operations for different SMB versions */
1626#define SMB1_VERSION_STRING "1.0"
1627extern struct smb_version_operations smb1_operations;
1628extern struct smb_version_values smb1_values;
Steve Frenche4aa25e2012-10-01 12:26:22 -05001629#define SMB20_VERSION_STRING "2.0"
Pavel Shilovsky53ef1012013-09-05 16:11:28 +04001630extern struct smb_version_operations smb20_operations;
Steve Frenche4aa25e2012-10-01 12:26:22 -05001631extern struct smb_version_values smb20_values;
Steve French1080ef72011-02-24 18:07:19 +00001632#define SMB21_VERSION_STRING "2.1"
1633extern struct smb_version_operations smb21_operations;
1634extern struct smb_version_values smb21_values;
Steve Frenche4aa25e2012-10-01 12:26:22 -05001635#define SMB30_VERSION_STRING "3.0"
Steve French38107d42012-12-08 22:08:06 -06001636extern struct smb_version_operations smb30_operations;
Steve Frenche4aa25e2012-10-01 12:26:22 -05001637extern struct smb_version_values smb30_values;
Steve French20b6d8b2013-06-12 22:48:41 -05001638#define SMB302_VERSION_STRING "3.02"
1639/*extern struct smb_version_operations smb302_operations;*/ /* not needed yet */
1640extern struct smb_version_values smb302_values;
Steve French5f7fbf72014-12-17 22:52:58 -06001641#define SMB311_VERSION_STRING "3.1.1"
Steve Frenchaab18932015-06-23 23:37:11 -05001642#define ALT_SMB311_VERSION_STRING "3.11"
1643extern struct smb_version_operations smb311_operations;
Steve French5f7fbf72014-12-17 22:52:58 -06001644extern struct smb_version_values smb311_values;
Suresh Jayaramanabd2e442010-06-22 20:52:50 +05301645#endif /* _CIFS_GLOB_H */