blob: 9adf211ca95a37959665aa6c8eff23c7174ee85b [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>
Pavel Shilovskyd60622e2012-05-28 15:19:39 +040031#ifdef CONFIG_CIFS_SMB2
32#include "smb2pdu.h"
33#endif
Shirish Pargaonkard2b91522010-10-21 14:25:08 -050034
Linus Torvalds1da177e2005-04-16 15:20:36 -070035/*
36 * The sizes of various internal tables and strings
37 */
38#define MAX_UID_INFO 16
39#define MAX_SES_INFO 2
40#define MAX_TCON_INFO 4
41
Shirish Pargaonkaref571ca2008-07-24 15:56:05 +000042#define MAX_TREE_SIZE (2 + MAX_SERVER_SIZE + 1 + MAX_SHARE_SIZE + 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#define MAX_SERVER_SIZE 15
Steve French2e325d52011-03-08 05:51:19 +000044#define MAX_SHARE_SIZE 80
Steve French8727c8a2011-02-25 01:11:56 -060045#define MAX_USERNAME_SIZE 256 /* reasonable maximum for current servers */
46#define MAX_PASSWORD_SIZE 512 /* max for windows seems to be 256 wide chars */
Linus Torvalds1da177e2005-04-16 15:20:36 -070047
48#define CIFS_MIN_RCV_POOL 4
49
Shirish Pargaonkar2c0c2a02012-05-21 09:20:12 -050050#define MAX_REOPEN_ATT 5 /* these many maximum attempts to reopen a file */
Linus Torvalds1da177e2005-04-16 15:20:36 -070051/*
Suresh Jayaraman6d20e842010-12-01 14:42:28 +053052 * default attribute cache timeout (jiffies)
53 */
54#define CIFS_DEF_ACTIMEO (1 * HZ)
55
56/*
57 * max attribute cache timeout (jiffies) - 2^30
58 */
59#define CIFS_MAX_ACTIMEO (1 << 30)
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
70/* currently length of NIP6_FMT */
71#define SERVER_NAME_LENGTH 40
Linus Torvalds1da177e2005-04-16 15:20:36 -070072#define SERVER_NAME_LEN_WITH_NULL (SERVER_NAME_LENGTH + 1)
73
74/* used to define string lengths for reversing unicode strings */
75/* (256+1)*2 = 514 */
76/* (max path length + 1 for null) * 2 for unicode */
77#define MAX_NAME 514
78
Pavel Shilovsky9094fad2012-07-12 18:30:44 +040079/* SMB echo "timeout" -- FIXME: tunable? */
80#define SMB_ECHO_INTERVAL (60 * HZ)
81
Linus Torvalds1da177e2005-04-16 15:20:36 -070082#include "cifspdu.h"
83
Linus Torvalds1da177e2005-04-16 15:20:36 -070084#ifndef XATTR_DOS_ATTRIB
85#define XATTR_DOS_ATTRIB "user.DOSATTRIB"
86#endif
87
88/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 * CIFS vfs client Status information (based on what we know.)
90 */
91
Steve French6c0f6212010-10-23 16:51:40 +000092/* associated with each tcp and smb session */
Linus Torvalds1da177e2005-04-16 15:20:36 -070093enum statusEnum {
94 CifsNew = 0,
95 CifsGood,
96 CifsExiting,
Steve Frenchfd88ce92011-04-12 01:01:14 +000097 CifsNeedReconnect,
98 CifsNeedNegotiate
Linus Torvalds1da177e2005-04-16 15:20:36 -070099};
100
101enum securityEnum {
Jeff Laytondaf5b0b2010-07-06 20:43:02 -0400102 LANMAN = 0, /* Legacy LANMAN auth */
Steve French39798772006-05-31 22:40:51 +0000103 NTLM, /* Legacy NTLM012 auth with NTLM hash */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 NTLMv2, /* Legacy NTLM auth with NTLMv2 hash */
Steve Frenchac683922009-05-06 04:16:04 +0000105 RawNTLMSSP, /* NTLMSSP without SPNEGO, NTLMv2 hash */
Steve Frenchf46c7232009-06-25 03:04:20 +0000106/* NTLMSSP, */ /* can use rawNTLMSSP instead of NTLMSSP via SPNEGO */
Steve Frenchc16fefa2008-08-19 19:35:33 +0000107 Kerberos, /* Kerberos via SPNEGO */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108};
109
110enum protocolEnum {
Steve French3ec332e2008-11-14 03:35:10 +0000111 TCP = 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 SCTP
113 /* Netbios frames protocol not supported at this time */
114};
115
Shirish Pargaonkar5f98ca92010-09-18 22:01:58 -0500116struct session_key {
Steve Frenchb609f062007-07-09 07:55:14 +0000117 unsigned int len;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500118 char *response;
Steve Frenchb609f062007-07-09 07:55:14 +0000119};
120
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500121/* crypto security descriptor definition */
122struct sdesc {
123 struct shash_desc shash;
124 char ctx[];
125};
126
Shirish Pargaonkarf7c5445a2010-10-26 18:10:24 -0500127/* crypto hashing related structure/fields, not specific to a sec mech */
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500128struct cifs_secmech {
129 struct crypto_shash *hmacmd5; /* hmac-md5 hash function */
130 struct crypto_shash *md5; /* md5 hash function */
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700131 struct crypto_shash *hmacsha256; /* hmac-sha256 hash function */
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500132 struct sdesc *sdeschmacmd5; /* ctxt to generate ntlmv2 hash, CR1 */
133 struct sdesc *sdescmd5; /* ctxt to generate cifs/smb signature */
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700134 struct sdesc *sdeschmacsha256; /* ctxt to generate smb2 signature */
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500135};
136
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500137/* per smb session structure/fields */
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500138struct ntlmssp_auth {
139 __u32 client_flags; /* sent by client in type 1 ntlmsssp exchange */
140 __u32 server_flags; /* sent by server in type 2 ntlmssp exchange */
141 unsigned char ciphertext[CIFS_CPHTXT_SIZE]; /* sent to server */
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500142 char cryptkey[CIFS_CRYPTO_KEY_SIZE]; /* used by ntlmssp */
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500143};
144
Steve French442aa312007-09-24 20:25:46 +0000145struct cifs_cred {
146 int uid;
147 int gid;
148 int mode;
149 int cecount;
150 struct cifs_sid osid;
151 struct cifs_sid gsid;
152 struct cifs_ntace *ntaces;
153 struct cifs_ace *aces;
154};
155
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156/*
157 *****************************************************************
158 * Except the CIFS PDUs themselves all the
159 * globally interesting structs should go here
160 *****************************************************************
161 */
162
Jeff Layton23db65f2012-05-15 12:20:51 -0400163enum smb_version {
164 Smb_1 = 1,
Steve French1080ef72011-02-24 18:07:19 +0000165 Smb_21,
Jeff Layton23db65f2012-05-15 12:20:51 -0400166};
167
Jeff Layton121b0462012-05-15 12:21:10 -0400168struct mid_q_entry;
169struct TCP_Server_Info;
Pavel Shilovsky55157df2012-02-28 14:04:17 +0300170struct cifsFileInfo;
Pavel Shilovsky082d0642012-05-17 12:18:21 +0400171struct cifs_ses;
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +0400172struct cifs_tcon;
Pavel Shilovskyb669f332012-05-27 20:21:53 +0400173struct dfs_info3_param;
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400174struct cifs_fattr;
Pavel Shilovsky9224dfc2012-05-27 20:39:52 +0400175struct smb_vol;
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700176struct cifs_fid;
Pavel Shilovskyfc9c5962012-09-18 16:20:28 -0700177struct cifs_readdata;
Pavel Shilovskyc9de5c82012-09-18 16:20:29 -0700178struct cifs_writedata;
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -0700179struct cifs_io_parms;
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700180struct cifs_search_info;
Jeff Layton121b0462012-05-15 12:21:10 -0400181
Jeff Layton23db65f2012-05-15 12:20:51 -0400182struct smb_version_operations {
Jeff Layton121b0462012-05-15 12:21:10 -0400183 int (*send_cancel)(struct TCP_Server_Info *, void *,
184 struct mid_q_entry *);
Pavel Shilovsky55157df2012-02-28 14:04:17 +0300185 bool (*compare_fids)(struct cifsFileInfo *, struct cifsFileInfo *);
Pavel Shilovsky082d0642012-05-17 12:18:21 +0400186 /* setup request: allocate mid, sign message */
187 int (*setup_request)(struct cifs_ses *, struct kvec *, unsigned int,
188 struct mid_q_entry **);
Pavel Shilovsky45740842012-06-01 14:26:18 +0400189 /* setup async request: allocate mid, sign message */
190 int (*setup_async_request)(struct TCP_Server_Info *, struct kvec *,
191 unsigned int, struct mid_q_entry **);
Pavel Shilovsky082d0642012-05-17 12:18:21 +0400192 /* check response: verify signature, map error */
193 int (*check_receive)(struct mid_q_entry *, struct TCP_Server_Info *,
194 bool);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400195 void (*add_credits)(struct TCP_Server_Info *, const unsigned int,
196 const int);
Pavel Shilovsky45275782012-05-17 17:53:29 +0400197 void (*set_credits)(struct TCP_Server_Info *, const int);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400198 int * (*get_credits_field)(struct TCP_Server_Info *, const int);
199 unsigned int (*get_credits)(struct mid_q_entry *);
Pavel Shilovsky88257362012-05-23 14:01:59 +0400200 __u64 (*get_next_mid)(struct TCP_Server_Info *);
Pavel Shilovskyeb378712012-05-17 13:02:51 +0400201 /* data offset from read response message */
202 unsigned int (*read_data_offset)(char *);
203 /* data length from read response message */
204 unsigned int (*read_data_length)(char *);
205 /* map smb to linux error */
206 int (*map_error)(char *, bool);
Pavel Shilovsky8aa26f32012-05-17 13:25:35 +0400207 /* find mid corresponding to the response message */
208 struct mid_q_entry * (*find_mid)(struct TCP_Server_Info *, char *);
209 void (*dump_detail)(void *);
Pavel Shilovsky44c58182012-05-28 14:16:31 +0400210 void (*clear_stats)(struct cifs_tcon *);
211 void (*print_stats)(struct seq_file *m, struct cifs_tcon *);
Pavel Shilovsky8aa26f32012-05-17 13:25:35 +0400212 /* verify the message */
213 int (*check_message)(char *, unsigned int);
214 bool (*is_oplock_break)(char *, struct TCP_Server_Info *);
Pavel Shilovsky316cf942012-05-23 14:31:03 +0400215 /* process transaction2 response */
216 bool (*check_trans2)(struct mid_q_entry *, struct TCP_Server_Info *,
217 char *, int);
Pavel Shilovsky286170a2012-05-25 10:43:58 +0400218 /* check if we need to negotiate */
219 bool (*need_neg)(struct TCP_Server_Info *);
220 /* negotiate to the server */
221 int (*negotiate)(const unsigned int, struct cifs_ses *);
Pavel Shilovsky24985c52012-09-18 16:20:28 -0700222 /* set negotiated write size */
223 unsigned int (*negotiate_wsize)(struct cifs_tcon *, struct smb_vol *);
224 /* set negotiated read size */
225 unsigned int (*negotiate_rsize)(struct cifs_tcon *, struct smb_vol *);
Pavel Shilovsky58c45c52012-05-25 10:54:49 +0400226 /* setup smb sessionn */
227 int (*sess_setup)(const unsigned int, struct cifs_ses *,
228 const struct nls_table *);
229 /* close smb session */
230 int (*logoff)(const unsigned int, struct cifs_ses *);
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +0400231 /* connect to a server share */
232 int (*tree_connect)(const unsigned int, struct cifs_ses *, const char *,
233 struct cifs_tcon *, const struct nls_table *);
234 /* close tree connecion */
235 int (*tree_disconnect)(const unsigned int, struct cifs_tcon *);
Pavel Shilovskyb669f332012-05-27 20:21:53 +0400236 /* get DFS referrals */
237 int (*get_dfs_refer)(const unsigned int, struct cifs_ses *,
238 const char *, struct dfs_info3_param **,
239 unsigned int *, const struct nls_table *, int);
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +0400240 /* informational QFS call */
241 void (*qfs_tcon)(const unsigned int, struct cifs_tcon *);
Pavel Shilovsky68889f22012-05-25 14:40:22 +0400242 /* check if a path is accessible or not */
243 int (*is_path_accessible)(const unsigned int, struct cifs_tcon *,
244 struct cifs_sb_info *, const char *);
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400245 /* query path data from the server */
246 int (*query_path_info)(const unsigned int, struct cifs_tcon *,
247 struct cifs_sb_info *, const char *,
248 FILE_ALL_INFO *, bool *);
Pavel Shilovsky4ad65042012-09-18 16:20:26 -0700249 /* query file data from the server */
250 int (*query_file_info)(const unsigned int, struct cifs_tcon *,
251 struct cifs_fid *, FILE_ALL_INFO *);
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400252 /* get server index number */
253 int (*get_srv_inum)(const unsigned int, struct cifs_tcon *,
254 struct cifs_sb_info *, const char *,
255 u64 *uniqueid, FILE_ALL_INFO *);
Pavel Shilovskyd1433412012-09-18 16:20:31 -0700256 /* set size by path */
257 int (*set_path_size)(const unsigned int, struct cifs_tcon *,
258 const char *, __u64, struct cifs_sb_info *, bool);
259 /* set size by file handle */
260 int (*set_file_size)(const unsigned int, struct cifs_tcon *,
261 struct cifsFileInfo *, __u64, bool);
Pavel Shilovsky6bdf6db2012-09-18 16:20:32 -0700262 /* set attributes */
263 int (*set_file_info)(struct inode *, const char *, FILE_BASIC_INFO *,
264 const unsigned int);
Pavel Shilovsky9224dfc2012-05-27 20:39:52 +0400265 /* build a full path to the root of the mount */
266 char * (*build_path_to_root)(struct smb_vol *, struct cifs_sb_info *,
267 struct cifs_tcon *);
Pavel Shilovskyf6d76172012-05-25 14:47:16 +0400268 /* check if we can send an echo or nor */
269 bool (*can_echo)(struct TCP_Server_Info *);
270 /* send echo request */
271 int (*echo)(struct TCP_Server_Info *);
Pavel Shilovskyf4367202012-03-17 11:41:12 +0300272 /* create directory */
273 int (*mkdir)(const unsigned int, struct cifs_tcon *, const char *,
274 struct cifs_sb_info *);
275 /* set info on created directory */
276 void (*mkdir_setinfo)(struct inode *, const char *,
277 struct cifs_sb_info *, struct cifs_tcon *,
278 const unsigned int);
Pavel Shilovskyf958ca52012-07-10 16:14:18 +0400279 /* remove directory */
280 int (*rmdir)(const unsigned int, struct cifs_tcon *, const char *,
281 struct cifs_sb_info *);
Pavel Shilovskyed6875e2012-09-18 16:20:25 -0700282 /* unlink file */
283 int (*unlink)(const unsigned int, struct cifs_tcon *, const char *,
284 struct cifs_sb_info *);
285 /* open, rename and delete file */
286 int (*rename_pending_delete)(const char *, struct dentry *,
287 const unsigned int);
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -0700288 /* send rename request */
289 int (*rename)(const unsigned int, struct cifs_tcon *, const char *,
290 const char *, struct cifs_sb_info *);
Steve Frenchd6e906f2012-09-18 16:20:31 -0700291 /* send create hardlink request */
292 int (*create_hardlink)(const unsigned int, struct cifs_tcon *,
293 const char *, const char *,
294 struct cifs_sb_info *);
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700295 /* open a file for non-posix mounts */
296 int (*open)(const unsigned int, struct cifs_tcon *, const char *, int,
297 int, int, struct cifs_fid *, __u32 *, FILE_ALL_INFO *,
298 struct cifs_sb_info *);
299 /* set fid protocol-specific info */
300 void (*set_fid)(struct cifsFileInfo *, struct cifs_fid *, __u32);
Pavel Shilovsky0ff78a22012-09-18 16:20:26 -0700301 /* close a file */
302 int (*close)(const unsigned int, struct cifs_tcon *, struct cifs_fid *);
Pavel Shilovsky1d8c4c02012-09-18 16:20:27 -0700303 /* send a flush request to the server */
304 int (*flush)(const unsigned int, struct cifs_tcon *, struct cifs_fid *);
Pavel Shilovskyfc9c5962012-09-18 16:20:28 -0700305 /* async read from the server */
306 int (*async_readv)(struct cifs_readdata *);
Pavel Shilovskyc9de5c82012-09-18 16:20:29 -0700307 /* async write to the server */
308 int (*async_writev)(struct cifs_writedata *);
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -0700309 /* sync read from the server */
310 int (*sync_read)(const unsigned int, struct cifsFileInfo *,
311 struct cifs_io_parms *, unsigned int *, char **,
312 int *);
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -0700313 /* sync write to the server */
314 int (*sync_write)(const unsigned int, struct cifsFileInfo *,
315 struct cifs_io_parms *, unsigned int *, struct kvec *,
316 unsigned long);
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700317 /* open dir, start readdir */
318 int (*query_dir_first)(const unsigned int, struct cifs_tcon *,
319 const char *, struct cifs_sb_info *,
320 struct cifs_fid *, __u16,
321 struct cifs_search_info *);
322 /* continue readdir */
323 int (*query_dir_next)(const unsigned int, struct cifs_tcon *,
324 struct cifs_fid *,
325 __u16, struct cifs_search_info *srch_inf);
326 /* close dir */
327 int (*close_dir)(const unsigned int, struct cifs_tcon *,
328 struct cifs_fid *);
329 /* calculate a size of SMB message */
330 unsigned int (*calc_smb_size)(void *);
Jeff Layton23db65f2012-05-15 12:20:51 -0400331};
332
333struct smb_version_values {
334 char *version_string;
Pavel Shilovsky106dc532012-02-28 14:23:34 +0300335 __u32 large_lock_type;
336 __u32 exclusive_lock_type;
337 __u32 shared_lock_type;
338 __u32 unlock_lock_type;
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400339 size_t header_size;
340 size_t max_header_size;
Pavel Shilovskyeb378712012-05-17 13:02:51 +0400341 size_t read_rsp_size;
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +0400342 __le16 lock_cmd;
Pavel Shilovsky29e20f92012-07-13 13:58:14 +0400343 unsigned int cap_unix;
344 unsigned int cap_nt_find;
345 unsigned int cap_large_files;
Jeff Layton23db65f2012-05-15 12:20:51 -0400346};
347
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400348#define HEADER_SIZE(server) (server->vals->header_size)
349#define MAX_HEADER_SIZE(server) (server->vals->max_header_size)
350
Steve Frenchf87d39d2011-05-27 03:50:55 +0000351struct smb_vol {
352 char *username;
353 char *password;
354 char *domainname;
355 char *UNC;
356 char *UNCip;
357 char *iocharset; /* local code page for mapping to and from Unicode */
358 char source_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* clnt nb name */
359 char target_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* srvr nb name */
360 uid_t cred_uid;
361 uid_t linux_uid;
362 gid_t linux_gid;
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500363 uid_t backupuid;
364 gid_t backupgid;
Al Viro5206efd2011-07-26 03:22:14 -0400365 umode_t file_mode;
366 umode_t dir_mode;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000367 unsigned secFlg;
368 bool retry:1;
369 bool intr:1;
370 bool setuids:1;
371 bool override_uid:1;
372 bool override_gid:1;
373 bool dynperm:1;
374 bool noperm:1;
375 bool no_psx_acl:1; /* set if posix acl support should be disabled */
376 bool cifs_acl:1;
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500377 bool backupuid_specified; /* mount option backupuid is specified */
378 bool backupgid_specified; /* mount option backupgid is specified */
Steve Frenchf87d39d2011-05-27 03:50:55 +0000379 bool no_xattr:1; /* set if xattr (EA) support should be disabled*/
380 bool server_ino:1; /* use inode numbers from server ie UniqueId */
381 bool direct_io:1;
382 bool strict_io:1; /* strict cache behavior */
383 bool remap:1; /* set to remap seven reserved chars in filenames */
384 bool posix_paths:1; /* unset to not ask for posix pathnames. */
385 bool no_linux_ext:1;
386 bool sfu_emul:1;
387 bool nullauth:1; /* attempt to authenticate with null user */
388 bool nocase:1; /* request case insensitive filenames */
389 bool nobrl:1; /* disable sending byte range locks to srv */
390 bool mand_lock:1; /* send mandatory not posix byte range lock reqs */
391 bool seal:1; /* request transport encryption on share */
392 bool nodfs:1; /* Do not request DFS, even if available */
393 bool local_lease:1; /* check leases only on local system, not remote */
394 bool noblocksnd:1;
395 bool noautotune:1;
396 bool nostrictsync:1; /* do not force expensive SMBflush on every sync */
397 bool fsc:1; /* enable fscache */
398 bool mfsymlinks:1; /* use Minshall+French Symlinks */
399 bool multiuser:1;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000400 bool rwpidforward:1; /* pid forward for read/write operations */
Steve Frenchf87d39d2011-05-27 03:50:55 +0000401 unsigned int rsize;
402 unsigned int wsize;
403 bool sockopt_tcp_nodelay:1;
404 unsigned short int port;
405 unsigned long actimeo; /* attribute cache timeout (jiffies) */
Jeff Layton23db65f2012-05-15 12:20:51 -0400406 struct smb_version_operations *ops;
407 struct smb_version_values *vals;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000408 char *prepath;
409 struct sockaddr_storage srcaddr; /* allow binding to a local IP */
410 struct nls_table *local_nls;
411};
412
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400413#define CIFS_MOUNT_MASK (CIFS_MOUNT_NO_PERM | CIFS_MOUNT_SET_UID | \
414 CIFS_MOUNT_SERVER_INUM | CIFS_MOUNT_DIRECT_IO | \
415 CIFS_MOUNT_NO_XATTR | CIFS_MOUNT_MAP_SPECIAL_CHR | \
416 CIFS_MOUNT_UNX_EMUL | CIFS_MOUNT_NO_BRL | \
417 CIFS_MOUNT_CIFS_ACL | CIFS_MOUNT_OVERR_UID | \
418 CIFS_MOUNT_OVERR_GID | CIFS_MOUNT_DYNPERM | \
419 CIFS_MOUNT_NOPOSIXBRL | CIFS_MOUNT_NOSSYNC | \
420 CIFS_MOUNT_FSCACHE | CIFS_MOUNT_MF_SYMLINKS | \
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500421 CIFS_MOUNT_MULTIUSER | CIFS_MOUNT_STRICT_IO | \
422 CIFS_MOUNT_CIFS_BACKUPUID | CIFS_MOUNT_CIFS_BACKUPGID)
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400423
424#define CIFS_MS_MASK (MS_RDONLY | MS_MANDLOCK | MS_NOEXEC | MS_NOSUID | \
425 MS_NODEV | MS_SYNCHRONOUS)
426
427struct cifs_mnt_data {
428 struct cifs_sb_info *cifs_sb;
429 struct smb_vol *vol;
430 int flags;
431};
432
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400433static inline unsigned int
434get_rfc1002_length(void *buf)
435{
436 return be32_to_cpu(*((__be32 *)buf));
437}
438
Pavel Shilovskyec2e4522011-12-27 16:12:43 +0400439static inline void
440inc_rfc1001_len(void *buf, int count)
441{
442 be32_add_cpu((__be32 *)buf, count);
443}
444
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445struct TCP_Server_Info {
Steve French3b795212008-11-13 19:45:32 +0000446 struct list_head tcp_ses_list;
447 struct list_head smb_ses_list;
Jeff Laytone7ddee92008-11-14 13:44:38 -0500448 int srv_count; /* reference counter */
Steve Frencha10faeb22005-08-22 21:38:31 -0700449 /* 15 character server name + 0x20 16th byte indicating type = srv */
Jeff Layton8ecaf672008-12-01 15:23:50 -0500450 char server_RFC1001_name[RFC1001_NAME_LEN_WITH_NULL];
Jeff Layton23db65f2012-05-15 12:20:51 -0400451 struct smb_version_operations *ops;
452 struct smb_version_values *vals;
Jeff Laytonc3dccf42011-01-20 13:36:50 -0500453 enum statusEnum tcpStatus; /* what we think the status is */
Jeff Laytonc359cf32007-11-16 22:22:06 +0000454 char *hostname; /* hostname portion of UNC string */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 struct socket *ssocket;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300456 struct sockaddr_storage dstaddr;
Ben Greear3eb9a882010-09-01 17:06:02 -0700457 struct sockaddr_storage srcaddr; /* locally bind to this IP */
Rob Landleyf1d0c992011-01-22 15:44:05 -0600458#ifdef CONFIG_NET_NS
459 struct net *net;
460#endif
Steve Frenchd38d8c72007-06-28 19:44:13 +0000461 wait_queue_head_t response_q;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 wait_queue_head_t request_q; /* if more than maxmpx to srvr must block*/
463 struct list_head pending_mid_q;
Steve Frenchedf1ae42008-10-29 00:47:57 +0000464 bool noblocksnd; /* use blocking sendmsg */
465 bool noautotune; /* do not autotune send buf sizes */
Steve French6a5fa2362010-01-01 01:28:43 +0000466 bool tcp_nodelay;
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400467 int credits; /* send no more requests at once */
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300468 unsigned int in_flight; /* number of requests on the wire to server */
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400469 spinlock_t req_lock; /* protect the two values above */
Jeff Layton72ca5452008-12-01 07:09:36 -0500470 struct mutex srv_mutex;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 struct task_struct *tsk;
472 char server_GUID[16];
Pavel Shilovsky286170a2012-05-25 10:43:58 +0400473 __u16 sec_mode;
Jeff Laytonc3dccf42011-01-20 13:36:50 -0500474 bool session_estab; /* mark when very first sess is established */
Pavel Shilovsky28ea5292012-05-23 16:18:00 +0400475#ifdef CONFIG_CIFS_SMB2
476 int echo_credits; /* echo reserved slots */
477 int oplock_credits; /* oplock break reserved slots */
478 bool echoes:1; /* enable echoes */
479#endif
Jeff Laytonc3dccf42011-01-20 13:36:50 -0500480 u16 dialect; /* dialect index that server chose */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 enum securityEnum secType;
Pavel Shilovsky10b9b982012-03-20 12:55:09 +0300482 bool oplocks:1; /* enable oplocks */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 unsigned int maxReq; /* Clients should submit no more */
484 /* than maxReq distinct unanswered SMBs to the server when using */
485 /* multiplexed reads or writes */
486 unsigned int maxBuf; /* maxBuf specifies the maximum */
487 /* message size the server can send or receive for non-raw SMBs */
Steve French7e90d702011-02-08 23:52:32 +0000488 /* maxBuf is returned by SMB NegotiateProtocol so maxBuf is only 0 */
489 /* when socket is setup (and during reconnect) before NegProt sent */
Steve Frencheca6acf2009-02-20 05:43:09 +0000490 unsigned int max_rw; /* maxRw specifies the maximum */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 /* message size the server can send or receive for */
492 /* SMB_COM_WRITE_RAW or SMB_COM_READ_RAW. */
Steve Frencheca6acf2009-02-20 05:43:09 +0000493 unsigned int max_vcs; /* maximum number of smb sessions, at least
494 those that can be specified uniquely with
495 vcnumbers */
Pavel Shilovsky29e20f92012-07-13 13:58:14 +0400496 unsigned int capabilities; /* selective disabling of caps by smb sess */
Steve Frenchde7ed552006-09-30 13:25:52 +0000497 int timeAdj; /* Adjust for difference in server time zone in sec */
Pavel Shilovsky243d04b2012-03-23 14:28:03 -0400498 __u64 CurrentMid; /* multiplex id - rotating counter */
Shirish Pargaonkard3ba50b2010-10-27 15:20:36 -0500499 char cryptkey[CIFS_CRYPTO_KEY_SIZE]; /* used by ntlm, ntlmv2 etc */
Steve Frencha10faeb22005-08-22 21:38:31 -0700500 /* 16th byte of RFC1001 workstation name is always null */
Jeff Layton8ecaf672008-12-01 15:23:50 -0500501 char workstation_RFC1001_name[RFC1001_NAME_LEN_WITH_NULL];
Jeff Laytona0f8b4f2011-01-07 11:30:28 -0500502 __u32 sequence_number; /* for signing, protected by srv_mutex */
Shirish Pargaonkar5f98ca92010-09-18 22:01:58 -0500503 struct session_key session_key;
Steve French3a5ff612006-07-14 22:37:11 +0000504 unsigned long lstrp; /* when we got last response from this server */
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500505 struct cifs_secmech secmech; /* crypto sec mech functs, descriptors */
Jeff Layton26efa0b2010-04-24 07:57:49 -0400506 /* extended security flavors that server supports */
Jeff Laytonc3dccf42011-01-20 13:36:50 -0500507 bool sec_ntlmssp; /* supports NTLMSSP */
508 bool sec_kerberosu2u; /* supports U2U Kerberos */
Jeff Layton26efa0b2010-04-24 07:57:49 -0400509 bool sec_kerberos; /* supports plain Kerberos */
510 bool sec_mskerberos; /* supports legacy MS Kerberos */
Jeff Layton2a37ef92011-10-19 15:29:23 -0400511 bool large_buf; /* is current buffer large? */
Jeff Laytonc74093b2011-01-11 07:24:23 -0500512 struct delayed_work echo; /* echo ping workqueue job */
Jeff Layton1041e3f2011-10-19 15:28:27 -0400513 struct kvec *iov; /* reusable kvec array for receives */
514 unsigned int nr_iov; /* number of kvecs in array */
Jeff Layton2a37ef92011-10-19 15:29:23 -0400515 char *smallbuf; /* pointer to current "small" buffer */
516 char *bigbuf; /* pointer to current "big" buffer */
517 unsigned int total_read; /* total amount of data read in this pass */
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +0530518#ifdef CONFIG_CIFS_FSCACHE
519 struct fscache_cookie *fscache; /* client index cache cookie */
520#endif
Jeff Laytonc3dccf42011-01-20 13:36:50 -0500521#ifdef CONFIG_CIFS_STATS2
Steve French789e6662011-08-09 18:44:44 +0000522 atomic_t in_send; /* requests trying to send */
Jeff Laytonc3dccf42011-01-20 13:36:50 -0500523 atomic_t num_waiters; /* blocked waiting to get in sendrecv */
524#endif
Pavel Shilovskyec2e4522011-12-27 16:12:43 +0400525#ifdef CONFIG_CIFS_SMB2
526 unsigned int max_read;
527 unsigned int max_write;
528#endif /* CONFIG_CIFS_SMB2 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529};
530
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300531static inline unsigned int
532in_flight(struct TCP_Server_Info *server)
533{
534 unsigned int num;
535 spin_lock(&server->req_lock);
536 num = server->in_flight;
537 spin_unlock(&server->req_lock);
538 return num;
539}
540
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400541static inline bool
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300542has_credits(struct TCP_Server_Info *server, int *credits)
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300543{
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400544 int num;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300545 spin_lock(&server->req_lock);
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300546 num = *credits;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300547 spin_unlock(&server->req_lock);
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400548 return num > 0;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300549}
550
Pavel Shilovsky45275782012-05-17 17:53:29 +0400551static inline void
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400552add_credits(struct TCP_Server_Info *server, const unsigned int add,
553 const int optype)
Pavel Shilovsky45275782012-05-17 17:53:29 +0400554{
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400555 server->ops->add_credits(server, add, optype);
Pavel Shilovsky45275782012-05-17 17:53:29 +0400556}
557
558static inline void
559set_credits(struct TCP_Server_Info *server, const int val)
560{
561 server->ops->set_credits(server, val);
562}
563
Pavel Shilovsky88257362012-05-23 14:01:59 +0400564static inline __u64
565get_next_mid(struct TCP_Server_Info *server)
566{
567 return server->ops->get_next_mid(server);
568}
569
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570/*
Pavel Shilovsky24985c52012-09-18 16:20:28 -0700571 * When the server supports very large reads and writes via POSIX extensions,
572 * we can allow up to 2^24-1, minus the size of a READ/WRITE_AND_X header, not
573 * including the RFC1001 length.
574 *
575 * Note that this might make for "interesting" allocation problems during
576 * writeback however as we have to allocate an array of pointers for the
577 * pages. A 16M write means ~32kb page array with PAGE_CACHE_SIZE == 4096.
578 *
579 * For reads, there is a similar problem as we need to allocate an array
580 * of kvecs to handle the receive, though that should only need to be done
581 * once.
582 */
583#define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
584#define CIFS_MAX_RSIZE ((1<<24) - sizeof(READ_RSP) + 4)
585
586/*
587 * When the server doesn't allow large posix writes, only allow a rsize/wsize
588 * of 2^17-1 minus the size of the call header. That allows for a read or
589 * write up to the maximum size described by RFC1002.
590 */
591#define CIFS_MAX_RFC1002_WSIZE ((1<<17) - 1 - sizeof(WRITE_REQ) + 4)
592#define CIFS_MAX_RFC1002_RSIZE ((1<<17) - 1 - sizeof(READ_RSP) + 4)
593
594/*
595 * The default wsize is 1M. find_get_pages seems to return a maximum of 256
596 * pages in a single call. With PAGE_CACHE_SIZE == 4k, this means we can fill
597 * a single wsize request with a single call.
598 */
599#define CIFS_DEFAULT_IOSIZE (1024 * 1024)
600
601/*
602 * Windows only supports a max of 60kb reads and 65535 byte writes. Default to
603 * those values when posix extensions aren't in force. In actuality here, we
604 * use 65536 to allow for a write that is a multiple of 4k. Most servers seem
605 * to be ok with the extra byte even though Windows doesn't send writes that
606 * are that large.
607 *
608 * Citation:
609 *
610 * http://blogs.msdn.com/b/openspecification/archive/2009/04/10/smb-maximum-transmit-buffer-size-and-performance-tuning.aspx
611 */
612#define CIFS_DEFAULT_NON_POSIX_RSIZE (60 * 1024)
613#define CIFS_DEFAULT_NON_POSIX_WSIZE (65536)
614
615/*
616 * On hosts with high memory, we can't currently support wsize/rsize that are
617 * larger than we can kmap at once. Cap the rsize/wsize at
618 * LAST_PKMAP * PAGE_SIZE. We'll never be able to fill a read or write request
619 * larger than that anyway.
620 */
621#ifdef CONFIG_HIGHMEM
622#define CIFS_KMAP_SIZE_LIMIT (LAST_PKMAP * PAGE_CACHE_SIZE)
623#else /* CONFIG_HIGHMEM */
624#define CIFS_KMAP_SIZE_LIMIT (1<<24)
625#endif /* CONFIG_HIGHMEM */
626
Pavel Shilovsky33319142012-09-18 16:20:29 -0700627#ifdef CONFIG_HIGHMEM
628/*
629 * On arches that have high memory, kmap address space is limited. By
630 * serializing the kmap operations on those arches, we ensure that we don't
631 * end up with a bunch of threads in writeback with partially mapped page
632 * arrays, stuck waiting for kmap to come back. That situation prevents
633 * progress and can deadlock.
634 */
635
636extern struct mutex cifs_kmap_mutex;
637
638static inline void
639cifs_kmap_lock(void)
640{
641 mutex_lock(&cifs_kmap_mutex);
642}
643
644static inline void
645cifs_kmap_unlock(void)
646{
647 mutex_unlock(&cifs_kmap_mutex);
648}
649#else /* !CONFIG_HIGHMEM */
650#define cifs_kmap_lock() do { ; } while (0)
651#define cifs_kmap_unlock() do { ; } while (0)
652#endif /* CONFIG_HIGHMEM */
653
Pavel Shilovsky24985c52012-09-18 16:20:28 -0700654/*
Rob Landleyf1d0c992011-01-22 15:44:05 -0600655 * Macros to allow the TCP_Server_Info->net field and related code to drop out
656 * when CONFIG_NET_NS isn't set.
657 */
658
659#ifdef CONFIG_NET_NS
660
661static inline struct net *cifs_net_ns(struct TCP_Server_Info *srv)
662{
663 return srv->net;
664}
665
666static inline void cifs_set_net_ns(struct TCP_Server_Info *srv, struct net *net)
667{
668 srv->net = net;
669}
670
671#else
672
673static inline struct net *cifs_net_ns(struct TCP_Server_Info *srv)
674{
675 return &init_net;
676}
677
678static inline void cifs_set_net_ns(struct TCP_Server_Info *srv, struct net *net)
679{
680}
681
682#endif
683
684/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 * Session structure. One of these for each uid session with a particular host
686 */
Steve French96daf2b2011-05-27 04:34:02 +0000687struct cifs_ses {
Jeff Layton14fbf502008-11-14 13:53:46 -0500688 struct list_head smb_ses_list;
Steve French3b795212008-11-13 19:45:32 +0000689 struct list_head tcon_list;
Steve Frenchd7b619c2010-02-25 05:36:46 +0000690 struct mutex session_mutex;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 struct TCP_Server_Info *server; /* pointer to server info */
Jeff Layton14fbf502008-11-14 13:53:46 -0500692 int ses_count; /* reference counter */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 enum statusEnum status;
Steve French750d1152006-06-27 06:28:30 +0000694 unsigned overrideSecFlg; /* if non-zero override global sec flags */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 __u16 ipc_tid; /* special tid for connection to IPC share */
696 __u16 flags;
Steve Frencheca6acf2009-02-20 05:43:09 +0000697 __u16 vcnum;
Steve Frenchad009ac2005-04-28 22:41:05 -0700698 char *serverOS; /* name of operating system underlying server */
699 char *serverNOS; /* name of network operating system of server */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 char *serverDomain; /* security realm of server */
Pavel Shilovsky286170a2012-05-25 10:43:58 +0400701 __u64 Suid; /* remote smb uid */
Jeff Layton3e4b3e12010-07-19 18:00:17 -0400702 uid_t linux_uid; /* overriding owner of files on the mount */
703 uid_t cred_uid; /* owner of credentials */
Pavel Shilovsky29e20f92012-07-13 13:58:14 +0400704 unsigned int capabilities;
Steve Frenchd38d8c72007-06-28 19:44:13 +0000705 char serverName[SERVER_NAME_LEN_WITH_NULL * 2]; /* BB make bigger for
Steve Frenchad009ac2005-04-28 22:41:05 -0700706 TCP names - will ipv6 and sctp addresses fit? */
Steve French34c87902011-03-01 05:02:57 +0000707 char *user_name; /* must not be null except during init of sess
708 and after mount option parsing we fill it */
Steve Frenchd38d8c72007-06-28 19:44:13 +0000709 char *domainName;
710 char *password;
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -0500711 struct session_key auth_key;
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500712 struct ntlmssp_auth *ntlmssp; /* ciphertext, flags, server challenge */
Steve French3b795212008-11-13 19:45:32 +0000713 bool need_reconnect:1; /* connection reset, uid now invalid */
Pavel Shilovsky5478f9b2011-12-27 16:22:00 +0400714#ifdef CONFIG_CIFS_SMB2
715 __u16 session_flags;
716#endif /* CONFIG_CIFS_SMB2 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717};
Steve French9ac00b72006-09-30 04:13:17 +0000718/* no more than one of the following three session flags may be set */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719#define CIFS_SES_NT4 1
Steve French9ac00b72006-09-30 04:13:17 +0000720#define CIFS_SES_OS2 2
721#define CIFS_SES_W9X 4
722/* following flag is set for old servers such as OS2 (and Win95?)
723 which do not negotiate NTLM or POSIX dialects, but instead
724 negotiate one of the older LANMAN dialects */
725#define CIFS_SES_LANMAN 8
Pavel Shilovsky29e20f92012-07-13 13:58:14 +0400726
727static inline bool
728cap_unix(struct cifs_ses *ses)
729{
730 return ses->server->vals->cap_unix & ses->capabilities;
731}
732
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733/*
734 * there is one of these for each connection to a resource on a particular
Steve Frenchd38d8c72007-06-28 19:44:13 +0000735 * session
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 */
Steve French96daf2b2011-05-27 04:34:02 +0000737struct cifs_tcon {
Jeff Laytonf1987b42008-11-15 11:12:47 -0500738 struct list_head tcon_list;
739 int tc_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 struct list_head openFileList;
Steve French96daf2b2011-05-27 04:34:02 +0000741 struct cifs_ses *ses; /* pointer to session associated with */
Steve French254e55e2006-06-04 05:53:15 +0000742 char treeName[MAX_TREE_SIZE + 1]; /* UNC name of resource in ASCII */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 char *nativeFileSystem;
Jeff Layton00e485b2008-12-05 20:41:21 -0500744 char *password; /* for share-level security */
Pavel Shilovskyfaaf9462011-12-27 16:04:00 +0400745 __u32 tid; /* The 4 byte tree id */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 __u16 Flags; /* optional support bits */
747 enum statusEnum tidStatus;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748#ifdef CONFIG_CIFS_STATS
749 atomic_t num_smbs_sent;
Pavel Shilovsky44c58182012-05-28 14:16:31 +0400750 union {
751 struct {
752 atomic_t num_writes;
753 atomic_t num_reads;
754 atomic_t num_flushes;
755 atomic_t num_oplock_brks;
756 atomic_t num_opens;
757 atomic_t num_closes;
758 atomic_t num_deletes;
759 atomic_t num_mkdirs;
760 atomic_t num_posixopens;
761 atomic_t num_posixmkdirs;
762 atomic_t num_rmdirs;
763 atomic_t num_renames;
764 atomic_t num_t2renames;
765 atomic_t num_ffirst;
766 atomic_t num_fnext;
767 atomic_t num_fclose;
768 atomic_t num_hardlinks;
769 atomic_t num_symlinks;
770 atomic_t num_locks;
771 atomic_t num_acl_get;
772 atomic_t num_acl_set;
773 } cifs_stats;
Pavel Shilovskyd60622e2012-05-28 15:19:39 +0400774#ifdef CONFIG_CIFS_SMB2
775 struct {
776 atomic_t smb2_com_sent[NUMBER_OF_SMB2_COMMANDS];
777 atomic_t smb2_com_failed[NUMBER_OF_SMB2_COMMANDS];
778 } smb2_stats;
779#endif /* CONFIG_CIFS_SMB2 */
Pavel Shilovsky44c58182012-05-28 14:16:31 +0400780 } stats;
Steve Frencha5a2b482005-08-20 21:42:53 -0700781#ifdef CONFIG_CIFS_STATS2
782 unsigned long long time_writes;
783 unsigned long long time_reads;
784 unsigned long long time_opens;
785 unsigned long long time_deletes;
786 unsigned long long time_closes;
787 unsigned long long time_mkdirs;
788 unsigned long long time_rmdirs;
789 unsigned long long time_renames;
790 unsigned long long time_t2renames;
791 unsigned long long time_ffirst;
792 unsigned long long time_fnext;
793 unsigned long long time_fclose;
794#endif /* CONFIG_CIFS_STATS2 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 __u64 bytes_read;
796 __u64 bytes_written;
797 spinlock_t stat_lock;
Steve Frencha5a2b482005-08-20 21:42:53 -0700798#endif /* CONFIG_CIFS_STATS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 FILE_SYSTEM_DEVICE_INFO fsDevInfo;
Steve French254e55e2006-06-04 05:53:15 +0000800 FILE_SYSTEM_ATTRIBUTE_INFO fsAttrInfo; /* ok if fs name truncated */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 FILE_SYSTEM_UNIX_INFO fsUnixInfo;
Steve French4b18f2a2008-04-29 00:06:05 +0000802 bool ipc:1; /* set if connection to IPC$ eg for RPC/PIPES */
803 bool retry:1;
804 bool nocase:1;
Steve French95b1cb92008-05-15 16:44:38 +0000805 bool seal:1; /* transport encryption for this mounted share */
Steve French4b18f2a2008-04-29 00:06:05 +0000806 bool unix_ext:1; /* if false disable Linux extensions to CIFS protocol
Steve Frenchc18c8422007-07-18 23:21:09 +0000807 for this mount even if server would support */
Steve French84210e92008-10-23 04:42:37 +0000808 bool local_lease:1; /* check leases (only) on local system not remote */
Steve French64cc2c62009-03-04 19:54:08 +0000809 bool broken_posix_open; /* e.g. Samba server versions < 3.3.2, 3.2.9 */
Steve French3b795212008-11-13 19:45:32 +0000810 bool need_reconnect:1; /* connection reset, tid now invalid */
Pavel Shilovskyfaaf9462011-12-27 16:04:00 +0400811#ifdef CONFIG_CIFS_SMB2
812 bool print:1; /* set if connection to printer share */
813 bool bad_network_name:1; /* set if ret status STATUS_BAD_NETWORK_NAME */
814 __u32 capabilities;
815 __u32 share_flags;
816 __u32 maximal_access;
817 __u32 vol_serial_number;
818 __le64 vol_create_time;
819#endif /* CONFIG_CIFS_SMB2 */
Suresh Jayaramand03382c2010-07-05 18:12:27 +0530820#ifdef CONFIG_CIFS_FSCACHE
821 u64 resource_id; /* server resource id */
822 struct fscache_cookie *fscache; /* cookie for share */
823#endif
Steve Frenchc18c8422007-07-18 23:21:09 +0000824 /* BB add field for back pointer to sb struct(s)? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825};
826
827/*
Jeff Layton7ffec372010-09-29 19:51:11 -0400828 * This is a refcounted and timestamped container for a tcon pointer. The
829 * container holds a tcon reference. It is considered safe to free one of
830 * these when the tl_count goes to 0. The tl_time is the time of the last
831 * "get" on the container.
832 */
833struct tcon_link {
Jeff Laytonb647c352010-10-28 11:16:44 -0400834 struct rb_node tl_rbnode;
835 uid_t tl_uid;
Jeff Layton9d002df2010-10-06 19:51:11 -0400836 unsigned long tl_flags;
837#define TCON_LINK_MASTER 0
838#define TCON_LINK_PENDING 1
839#define TCON_LINK_IN_TREE 2
840 unsigned long tl_time;
841 atomic_t tl_count;
Steve French96daf2b2011-05-27 04:34:02 +0000842 struct cifs_tcon *tl_tcon;
Jeff Layton7ffec372010-09-29 19:51:11 -0400843};
844
Jeff Layton9d002df2010-10-06 19:51:11 -0400845extern struct tcon_link *cifs_sb_tlink(struct cifs_sb_info *cifs_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -0400846
Steve French96daf2b2011-05-27 04:34:02 +0000847static inline struct cifs_tcon *
Jeff Layton7ffec372010-09-29 19:51:11 -0400848tlink_tcon(struct tcon_link *tlink)
849{
Jeff Layton9d002df2010-10-06 19:51:11 -0400850 return tlink->tl_tcon;
Jeff Layton7ffec372010-09-29 19:51:11 -0400851}
852
Jeff Layton9d002df2010-10-06 19:51:11 -0400853extern void cifs_put_tlink(struct tcon_link *tlink);
Jeff Layton7ffec372010-09-29 19:51:11 -0400854
Jeff Layton13cfb732010-09-29 19:51:11 -0400855static inline struct tcon_link *
856cifs_get_tlink(struct tcon_link *tlink)
857{
Jeff Layton9d002df2010-10-06 19:51:11 -0400858 if (tlink && !IS_ERR(tlink))
859 atomic_inc(&tlink->tl_count);
Jeff Layton13cfb732010-09-29 19:51:11 -0400860 return tlink;
861}
862
Jeff Layton7ffec372010-09-29 19:51:11 -0400863/* This function is always expected to succeed */
Steve French96daf2b2011-05-27 04:34:02 +0000864extern struct cifs_tcon *cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -0400865
866/*
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000867 * This info hangs off the cifsFileInfo structure, pointed to by llist.
868 * This is used to track byte stream locks on the file
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 */
870struct cifsLockInfo {
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000871 struct list_head llist; /* pointer to next cifsLockInfo */
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400872 struct list_head blist; /* pointer to locks blocked on this */
873 wait_queue_head_t block_q;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000874 __u64 offset;
875 __u64 length;
Pavel Shilovsky03776f42010-08-17 11:26:00 +0400876 __u32 pid;
Pavel Shilovsky04a6aa82012-02-28 14:16:55 +0300877 __u32 type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878};
879
880/*
881 * One of these for each open instance of a file
882 */
883struct cifs_search_info {
884 loff_t index_of_last_entry;
885 __u16 entries_in_buffer;
886 __u16 info_level;
887 __u32 resume_key;
Steve Frenchd38d8c72007-06-28 19:44:13 +0000888 char *ntwrk_buf_start;
889 char *srch_entries_start;
Steve French0752f152008-10-07 20:03:33 +0000890 char *last_entry;
Christoph Hellwigeaf35b12011-07-16 15:24:37 -0400891 const char *presume_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 unsigned int resume_name_len;
Steve French4b18f2a2008-04-29 00:06:05 +0000893 bool endOfSearch:1;
894 bool emptyDir:1;
895 bool unicode:1;
896 bool smallBuf:1; /* so we know which buf_release function to call */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897};
898
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700899struct cifs_fid {
900 __u16 netfid;
Pavel Shilovskyf0df7372012-09-18 16:20:26 -0700901#ifdef CONFIG_CIFS_SMB2
902 __u64 persistent_fid; /* persist file id for smb2 */
903 __u64 volatile_fid; /* volatile file id for smb2 */
904#endif
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700905};
906
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907struct cifsFileInfo {
908 struct list_head tlist; /* pointer to next fid owned by tcon */
909 struct list_head flist; /* next fid (file instance) for this inode */
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300910 struct list_head llist; /*
911 * brlocks held by this fid, protected by
912 * lock_mutex from cifsInodeInfo structure
913 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914 unsigned int uid; /* allows finding which FileInfo structure */
915 __u32 pid; /* process id who opened file */
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700916 struct cifs_fid fid; /* file id from remote */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 /* BB add lock scope info here if needed */ ;
918 /* lock scope id (0 if none) */
Jeff Laytona5e18bc2010-10-11 15:07:18 -0400919 struct dentry *dentry;
Jeff Layton15886172010-10-15 15:33:59 -0400920 unsigned int f_flags;
Jeff Layton13cfb732010-09-29 19:51:11 -0400921 struct tcon_link *tlink;
Steve French4b18f2a2008-04-29 00:06:05 +0000922 bool invalidHandle:1; /* file closed via session abend */
Jeff Layton3bc303c2009-09-21 06:47:50 -0400923 bool oplock_break_cancelled:1;
Steve French6c0f6212010-10-23 16:51:40 +0000924 int count; /* refcount protected by cifs_file_list_lock */
Steve Frencha6ce4932009-04-09 01:14:32 +0000925 struct mutex fh_mutex; /* prevents reopen race after dead ses*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 struct cifs_search_info srch_inf;
Tejun Heo9b646972010-07-20 22:09:02 +0200927 struct work_struct oplock_break; /* work for oplock breaks */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928};
929
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +0400930struct cifs_io_parms {
931 __u16 netfid;
Pavel Shilovsky09a47072012-09-18 16:20:29 -0700932#ifdef CONFIG_CIFS_SMB2
933 __u64 persistent_fid; /* persist file id for smb2 */
934 __u64 volatile_fid; /* volatile file id for smb2 */
935#endif
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +0400936 __u32 pid;
937 __u64 offset;
938 unsigned int length;
Steve French96daf2b2011-05-27 04:34:02 +0000939 struct cifs_tcon *tcon;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +0400940};
941
Pavel Shilovsky09a47072012-09-18 16:20:29 -0700942struct cifs_readdata;
943
944/* asynchronous read support */
945struct cifs_readdata {
946 struct kref refcount;
947 struct list_head list;
948 struct completion done;
949 struct cifsFileInfo *cfile;
950 struct address_space *mapping;
951 __u64 offset;
952 unsigned int bytes;
953 pid_t pid;
954 int result;
955 struct list_head pages;
956 struct work_struct work;
957 int (*marshal_iov) (struct cifs_readdata *rdata,
958 unsigned int remaining);
959 unsigned int nr_iov;
960 struct kvec iov[1];
961};
962
Pavel Shilovsky33319142012-09-18 16:20:29 -0700963struct cifs_writedata;
964
965/* asynchronous write support */
966struct cifs_writedata {
967 struct kref refcount;
968 struct list_head list;
969 struct completion done;
970 enum writeback_sync_modes sync_mode;
971 struct work_struct work;
972 struct cifsFileInfo *cfile;
973 __u64 offset;
974 pid_t pid;
975 unsigned int bytes;
976 int result;
977 void (*marshal_iov) (struct kvec *iov,
978 struct cifs_writedata *wdata);
979 unsigned int nr_pages;
980 struct page *pages[1];
981};
982
Jeff Layton5f6dbc92010-10-15 15:34:06 -0400983/*
984 * Take a reference on the file private data. Must be called with
985 * cifs_file_list_lock held.
986 */
Jeff Layton764a1b12012-07-25 14:59:54 -0400987static inline void
988cifsFileInfo_get_locked(struct cifsFileInfo *cifs_file)
Dave Kleikamp6ab409b2009-08-31 11:07:12 -0400989{
Jeff Layton5f6dbc92010-10-15 15:34:06 -0400990 ++cifs_file->count;
Dave Kleikamp6ab409b2009-08-31 11:07:12 -0400991}
992
Jeff Layton764a1b12012-07-25 14:59:54 -0400993struct cifsFileInfo *cifsFileInfo_get(struct cifsFileInfo *cifs_file);
Jeff Laytonb33879a2010-10-15 15:34:04 -0400994void cifsFileInfo_put(struct cifsFileInfo *cifs_file);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -0400995
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996/*
997 * One of these for each file inode
998 */
999
1000struct cifsInodeInfo {
Pavel Shilovskyd59dad22011-09-22 09:53:59 +04001001 bool can_cache_brlcks;
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +03001002 struct mutex lock_mutex; /*
1003 * protect the field above and llist
1004 * from every cifsFileInfo structure
1005 * from openFileList
1006 */
Steve Frenchd38d8c72007-06-28 19:44:13 +00001007 /* BB add in lists for dirty pages i.e. write caching info for oplock */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 struct list_head openFileList;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 __u32 cifsAttrs; /* e.g. DOS archive bit, sparse, compressed, system */
Jeff Laytonaae62fd2011-01-20 13:36:50 -05001010 bool clientCanCacheRead; /* read oplock */
1011 bool clientCanCacheAll; /* read and writebehind oplock */
1012 bool delete_pending; /* DELETE_ON_CLOSE is set */
1013 bool invalid_mapping; /* pagecache is invalid */
1014 unsigned long time; /* jiffies of last update of inode */
Jeff Layton597b0272012-03-23 14:40:56 -04001015 u64 server_eof; /* current file size on server -- protected by i_lock */
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001016 u64 uniqueid; /* server inode number */
Jeff Layton20054bd2011-01-07 11:30:27 -05001017 u64 createtime; /* creation time on server */
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +05301018#ifdef CONFIG_CIFS_FSCACHE
1019 struct fscache_cookie *fscache;
1020#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021 struct inode vfs_inode;
1022};
1023
1024static inline struct cifsInodeInfo *
1025CIFS_I(struct inode *inode)
1026{
1027 return container_of(inode, struct cifsInodeInfo, vfs_inode);
1028}
1029
1030static inline struct cifs_sb_info *
1031CIFS_SB(struct super_block *sb)
1032{
1033 return sb->s_fs_info;
1034}
1035
Steve Frenchab2f2182005-09-15 20:44:50 -07001036static inline char CIFS_DIR_SEP(const struct cifs_sb_info *cifs_sb)
Jeremy Allisonac670552005-06-22 17:26:35 -07001037{
1038 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
1039 return '/';
1040 else
1041 return '\\';
1042}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043
Steve Frenchf87d39d2011-05-27 03:50:55 +00001044static inline void
1045convert_delimiter(char *path, char delim)
1046{
1047 int i;
1048 char old_delim;
1049
1050 if (path == NULL)
1051 return;
1052
1053 if (delim == '/')
1054 old_delim = '\\';
1055 else
1056 old_delim = '/';
1057
1058 for (i = 0; path[i] != '\0'; i++) {
1059 if (path[i] == old_delim)
1060 path[i] = delim;
1061 }
1062}
1063
Pavel Shilovsky9224dfc2012-05-27 20:39:52 +04001064static inline char *
1065build_path_to_root(struct smb_vol *vol, struct cifs_sb_info *cifs_sb,
1066 struct cifs_tcon *tcon)
1067{
1068 if (!vol->ops->build_path_to_root)
1069 return NULL;
1070 return vol->ops->build_path_to_root(vol, cifs_sb, tcon);
1071}
1072
Steve Frencha4544342005-08-24 13:59:35 -07001073#ifdef CONFIG_CIFS_STATS
1074#define cifs_stats_inc atomic_inc
1075
Steve French96daf2b2011-05-27 04:34:02 +00001076static inline void cifs_stats_bytes_written(struct cifs_tcon *tcon,
Steve Frencha4544342005-08-24 13:59:35 -07001077 unsigned int bytes)
1078{
1079 if (bytes) {
1080 spin_lock(&tcon->stat_lock);
1081 tcon->bytes_written += bytes;
1082 spin_unlock(&tcon->stat_lock);
1083 }
1084}
1085
Steve French96daf2b2011-05-27 04:34:02 +00001086static inline void cifs_stats_bytes_read(struct cifs_tcon *tcon,
Steve Frencha4544342005-08-24 13:59:35 -07001087 unsigned int bytes)
1088{
1089 spin_lock(&tcon->stat_lock);
1090 tcon->bytes_read += bytes;
1091 spin_unlock(&tcon->stat_lock);
1092}
1093#else
1094
Steve Frenchd38d8c72007-06-28 19:44:13 +00001095#define cifs_stats_inc(field) do {} while (0)
1096#define cifs_stats_bytes_written(tcon, bytes) do {} while (0)
1097#define cifs_stats_bytes_read(tcon, bytes) do {} while (0)
Steve Frencha4544342005-08-24 13:59:35 -07001098
1099#endif
1100
Jeff Layton2b84a36c2011-01-11 07:24:21 -05001101
1102/*
Jeff Layton44d22d82011-10-19 15:29:49 -04001103 * This is the prototype for the mid receive function. This function is for
1104 * receiving the rest of the SMB frame, starting with the WordCount (which is
1105 * just after the MID in struct smb_hdr). Note:
1106 *
1107 * - This will be called by cifsd, with no locks held.
1108 * - The mid will still be on the pending_mid_q.
1109 * - mid->resp_buf will point to the current buffer.
1110 *
1111 * Returns zero on a successful receive, or an error. The receive state in
1112 * the TCP_Server_Info will also be updated.
1113 */
1114typedef int (mid_receive_t)(struct TCP_Server_Info *server,
1115 struct mid_q_entry *mid);
1116
1117/*
1118 * This is the prototype for the mid callback function. This is called once the
1119 * mid has been received off of the socket. When creating one, take special
1120 * care to avoid deadlocks. Things to bear in mind:
Jeff Layton2b84a36c2011-01-11 07:24:21 -05001121 *
Jeff Layton3c1105d2011-05-22 07:09:13 -04001122 * - it will be called by cifsd, with no locks held
1123 * - the mid will be removed from any lists
Jeff Layton2b84a36c2011-01-11 07:24:21 -05001124 */
1125typedef void (mid_callback_t)(struct mid_q_entry *mid);
1126
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127/* one of these for every pending CIFS request to the server */
1128struct mid_q_entry {
1129 struct list_head qhead; /* mids waiting on reply from this server */
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +04001130 struct TCP_Server_Info *server; /* server corresponding to this mid */
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001131 __u64 mid; /* multiplex id */
1132 __u32 pid; /* process id */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 __u32 sequence_number; /* for CIFS signing */
Steve French1047abc2005-10-11 19:58:06 -07001134 unsigned long when_alloc; /* when mid was created */
1135#ifdef CONFIG_CIFS_STATS2
1136 unsigned long when_sent; /* time when smb send finished */
1137 unsigned long when_received; /* when demux complete (taken off wire) */
1138#endif
Jeff Layton44d22d82011-10-19 15:29:49 -04001139 mid_receive_t *receive; /* call receive callback */
Jeff Layton2b84a36c2011-01-11 07:24:21 -05001140 mid_callback_t *callback; /* call completion callback */
1141 void *callback_data; /* general purpose pointer for callback */
Pavel Shilovskyd4e48542012-03-23 14:28:02 -04001142 void *resp_buf; /* pointer to received SMB header */
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001143 int mid_state; /* wish this were enum but can not pass to wait_event */
1144 __le16 command; /* smb command code */
1145 bool large_buf:1; /* if valid response, is pointer to large buf */
Steve French4b18f2a2008-04-29 00:06:05 +00001146 bool multiRsp:1; /* multiple trans2 responses for one request */
1147 bool multiEnd:1; /* both received */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148};
1149
Steve French789e6662011-08-09 18:44:44 +00001150/* Make code in transport.c a little cleaner by moving
1151 update of optional stats into function below */
1152#ifdef CONFIG_CIFS_STATS2
1153
1154static inline void cifs_in_send_inc(struct TCP_Server_Info *server)
1155{
1156 atomic_inc(&server->in_send);
1157}
1158
1159static inline void cifs_in_send_dec(struct TCP_Server_Info *server)
1160{
1161 atomic_dec(&server->in_send);
1162}
1163
1164static inline void cifs_num_waiters_inc(struct TCP_Server_Info *server)
1165{
1166 atomic_inc(&server->num_waiters);
1167}
1168
1169static inline void cifs_num_waiters_dec(struct TCP_Server_Info *server)
1170{
1171 atomic_dec(&server->num_waiters);
1172}
1173
1174static inline void cifs_save_when_sent(struct mid_q_entry *mid)
1175{
1176 mid->when_sent = jiffies;
1177}
1178#else
1179static inline void cifs_in_send_inc(struct TCP_Server_Info *server)
1180{
1181}
1182static inline void cifs_in_send_dec(struct TCP_Server_Info *server)
1183{
1184}
1185
1186static inline void cifs_num_waiters_inc(struct TCP_Server_Info *server)
1187{
1188}
1189
1190static inline void cifs_num_waiters_dec(struct TCP_Server_Info *server)
1191{
1192}
1193
1194static inline void cifs_save_when_sent(struct mid_q_entry *mid)
1195{
1196}
1197#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198
Steve Frenchff5dbd92005-08-24 17:10:36 -07001199/* for pending dnotify requests */
1200struct dir_notify_req {
Steve French13cd4b72010-10-07 18:46:32 +00001201 struct list_head lhead;
1202 __le16 Pid;
1203 __le16 PidHigh;
1204 __u16 Mid;
1205 __u16 Tid;
1206 __u16 Uid;
1207 __u16 netfid;
1208 __u32 filter; /* CompletionFilter (for multishot) */
1209 int multishot;
1210 struct file *pfile;
Steve Frenchff5dbd92005-08-24 17:10:36 -07001211};
1212
Steve French366781c2008-01-25 10:12:41 +00001213struct dfs_info3_param {
1214 int flags; /* DFSREF_REFERRAL_SERVER, DFSREF_STORAGE_SERVER*/
Igor Mammedov8aad0182008-02-15 18:21:49 +00001215 int path_consumed;
Steve French366781c2008-01-25 10:12:41 +00001216 int server_type;
1217 int ref_flag;
1218 char *path_name;
1219 char *node_name;
1220};
1221
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001222/*
1223 * common struct for holding inode info when searching for or updating an
1224 * inode with new info
1225 */
1226
1227#define CIFS_FATTR_DFS_REFERRAL 0x1
Jeff Layton0b8f18e2009-07-09 01:46:37 -04001228#define CIFS_FATTR_DELETE_PENDING 0x2
1229#define CIFS_FATTR_NEED_REVAL 0x4
Jeff Layton3d694382010-05-11 14:59:55 -04001230#define CIFS_FATTR_INO_COLLISION 0x8
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001231
1232struct cifs_fattr {
1233 u32 cf_flags;
1234 u32 cf_cifsattrs;
1235 u64 cf_uniqueid;
1236 u64 cf_eof;
1237 u64 cf_bytes;
Jeff Layton20054bd2011-01-07 11:30:27 -05001238 u64 cf_createtime;
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001239 uid_t cf_uid;
1240 gid_t cf_gid;
1241 umode_t cf_mode;
1242 dev_t cf_rdev;
1243 unsigned int cf_nlink;
1244 unsigned int cf_dtype;
1245 struct timespec cf_atime;
1246 struct timespec cf_mtime;
1247 struct timespec cf_ctime;
1248};
1249
Steve French366781c2008-01-25 10:12:41 +00001250static inline void free_dfs_info_param(struct dfs_info3_param *param)
1251{
1252 if (param) {
1253 kfree(param->path_name);
1254 kfree(param->node_name);
1255 kfree(param);
1256 }
1257}
1258
1259static inline void free_dfs_info_array(struct dfs_info3_param *param,
1260 int number_of_items)
1261{
1262 int i;
1263 if ((number_of_items == 0) || (param == NULL))
1264 return;
1265 for (i = 0; i < number_of_items; i++) {
1266 kfree(param[i].path_name);
1267 kfree(param[i].node_name);
1268 }
1269 kfree(param);
1270}
1271
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272#define MID_FREE 0
1273#define MID_REQUEST_ALLOCATED 1
1274#define MID_REQUEST_SUBMITTED 2
1275#define MID_RESPONSE_RECEIVED 4
1276#define MID_RETRY_NEEDED 8 /* session closed while this request out */
Jeff Layton71823ba2011-02-10 08:03:50 -05001277#define MID_RESPONSE_MALFORMED 0x10
Jeff Layton3c1105d2011-05-22 07:09:13 -04001278#define MID_SHUTDOWN 0x20
Steve Frenchec637e32005-12-12 20:53:18 -08001279
1280/* Types of response buffer returned from SendReceive2 */
1281#define CIFS_NO_BUFFER 0 /* Response buffer not returned */
1282#define CIFS_SMALL_BUFFER 1
1283#define CIFS_LARGE_BUFFER 2
1284#define CIFS_IOVEC 4 /* array of response buffers */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285
Steve French133672e2007-11-13 22:41:37 +00001286/* Type of Request to SendReceive2 */
Jeff Layton77499812011-01-11 07:24:23 -05001287#define CIFS_BLOCKING_OP 1 /* operation can block */
1288#define CIFS_ASYNC_OP 2 /* do not wait for response */
1289#define CIFS_TIMEOUT_MASK 0x003 /* only one of above set in req */
Steve French133672e2007-11-13 22:41:37 +00001290#define CIFS_LOG_ERROR 0x010 /* log NT STATUS if non-zero */
1291#define CIFS_LARGE_BUF_OP 0x020 /* large request buffer */
1292#define CIFS_NO_RESP 0x040 /* no response buffer required */
1293
Pavel Shilovskya891f0f2012-05-23 16:14:34 +04001294/* Type of request operation */
1295#define CIFS_ECHO_OP 0x080 /* echo request */
1296#define CIFS_OBREAK_OP 0x0100 /* oplock break request */
Pavel Shilovskyec2e4522011-12-27 16:12:43 +04001297#define CIFS_NEG_OP 0x0200 /* negotiate request */
1298#define CIFS_OP_MASK 0x0380 /* mask request type */
Pavel Shilovskya891f0f2012-05-23 16:14:34 +04001299
Steve French39798772006-05-31 22:40:51 +00001300/* Security Flags: indicate type of session setup needed */
1301#define CIFSSEC_MAY_SIGN 0x00001
1302#define CIFSSEC_MAY_NTLM 0x00002
1303#define CIFSSEC_MAY_NTLMV2 0x00004
1304#define CIFSSEC_MAY_KRB5 0x00008
1305#ifdef CONFIG_CIFS_WEAK_PW_HASH
1306#define CIFSSEC_MAY_LANMAN 0x00010
1307#define CIFSSEC_MAY_PLNTXT 0x00020
Steve French516897a2007-10-12 19:24:06 +00001308#else
1309#define CIFSSEC_MAY_LANMAN 0
1310#define CIFSSEC_MAY_PLNTXT 0
Steve French39798772006-05-31 22:40:51 +00001311#endif /* weak passwords */
1312#define CIFSSEC_MAY_SEAL 0x00040 /* not supported yet */
Steve Frenchac683922009-05-06 04:16:04 +00001313#define CIFSSEC_MAY_NTLMSSP 0x00080 /* raw ntlmssp with ntlmv2 */
Steve French5815449d2006-02-14 01:36:20 +00001314
Steve French39798772006-05-31 22:40:51 +00001315#define CIFSSEC_MUST_SIGN 0x01001
1316/* note that only one of the following can be set so the
1317result of setting MUST flags more than once will be to
1318require use of the stronger protocol */
1319#define CIFSSEC_MUST_NTLM 0x02002
1320#define CIFSSEC_MUST_NTLMV2 0x04004
1321#define CIFSSEC_MUST_KRB5 0x08008
1322#ifdef CONFIG_CIFS_WEAK_PW_HASH
1323#define CIFSSEC_MUST_LANMAN 0x10010
1324#define CIFSSEC_MUST_PLNTXT 0x20020
Jeff Layton0d3a01f2007-10-16 17:32:19 +00001325#ifdef CONFIG_CIFS_UPCALL
Chuck Ebbert20d17522009-09-15 01:53:21 -04001326#define CIFSSEC_MASK 0xBF0BF /* allows weak security but also krb5 */
Steve Frenchd38d8c72007-06-28 19:44:13 +00001327#else
Chuck Ebbert20d17522009-09-15 01:53:21 -04001328#define CIFSSEC_MASK 0xB70B7 /* current flags supported if weak */
Steve French016ec752007-10-16 18:10:10 +00001329#endif /* UPCALL */
Jeff Layton0d3a01f2007-10-16 17:32:19 +00001330#else /* do not allow weak pw hash */
Steve French88a44122012-01-18 17:13:47 -06001331#define CIFSSEC_MUST_LANMAN 0
1332#define CIFSSEC_MUST_PLNTXT 0
Jeff Layton0d3a01f2007-10-16 17:32:19 +00001333#ifdef CONFIG_CIFS_UPCALL
Steve Frenchac683922009-05-06 04:16:04 +00001334#define CIFSSEC_MASK 0x8F08F /* flags supported if no weak allowed */
Jeff Layton0d3a01f2007-10-16 17:32:19 +00001335#else
Steve Frenchac683922009-05-06 04:16:04 +00001336#define CIFSSEC_MASK 0x87087 /* flags supported if no weak allowed */
Steve French016ec752007-10-16 18:10:10 +00001337#endif /* UPCALL */
Steve French39798772006-05-31 22:40:51 +00001338#endif /* WEAK_PW_HASH */
1339#define CIFSSEC_MUST_SEAL 0x40040 /* not supported yet */
Steve Frenchac683922009-05-06 04:16:04 +00001340#define CIFSSEC_MUST_NTLMSSP 0x80080 /* raw ntlmssp with ntlmv2 */
Steve French39798772006-05-31 22:40:51 +00001341
Shirish Pargaonkaref571ca2008-07-24 15:56:05 +00001342#define CIFSSEC_DEF (CIFSSEC_MAY_SIGN | CIFSSEC_MAY_NTLM | CIFSSEC_MAY_NTLMV2)
1343#define CIFSSEC_MAX (CIFSSEC_MUST_SIGN | CIFSSEC_MUST_NTLMV2)
Steve Frenchac683922009-05-06 04:16:04 +00001344#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 -07001345/*
1346 *****************************************************************
1347 * All constants go here
1348 *****************************************************************
1349 */
1350
1351#define UID_HASH (16)
1352
1353/*
1354 * Note that ONE module should define _DECLARE_GLOBALS_HERE to cause the
1355 * following to be declared.
1356 */
1357
1358/****************************************************************************
1359 * Locking notes. All updates to global variables and lists should be
1360 * protected by spinlocks or semaphores.
1361 *
1362 * Spinlocks
1363 * ---------
1364 * GlobalMid_Lock protects:
1365 * list operations on pending_mid_q and oplockQ
1366 * updates to XID counters, multiplex id and SMB sequence numbers
Suresh Jayaraman6573e9b2010-10-18 23:52:18 +05301367 * cifs_file_list_lock protects:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 * list operations on tcp and SMB session lists and tCon lists
1369 * f_owner.lock protects certain per file struct operations
1370 * mapping->page_lock protects certain per page operations
1371 *
1372 * Semaphores
1373 * ----------
1374 * sesSem operations on smb session
1375 * tconSem operations on tree connection
Steve Frenchd38d8c72007-06-28 19:44:13 +00001376 * fh_sem file handle reconnection operations
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377 *
1378 ****************************************************************************/
1379
1380#ifdef DECLARE_GLOBALS_HERE
1381#define GLOBAL_EXTERN
1382#else
1383#define GLOBAL_EXTERN extern
1384#endif
1385
Jeff Laytone7ddee92008-11-14 13:44:38 -05001386/*
1387 * the list of TCP_Server_Info structures, ie each of the sockets
Steve Frenchfb396012008-11-13 20:04:07 +00001388 * connecting our client to a distinct server (ip address), is
Jeff Laytone7ddee92008-11-14 13:44:38 -05001389 * chained together by cifs_tcp_ses_list. The list of all our SMB
Steve Frenchfb396012008-11-13 20:04:07 +00001390 * sessions (and from that the tree connections) can be found
Jeff Laytone7ddee92008-11-14 13:44:38 -05001391 * by iterating over cifs_tcp_ses_list
1392 */
1393GLOBAL_EXTERN struct list_head cifs_tcp_ses_list;
1394
Jeff Laytonf1987b42008-11-15 11:12:47 -05001395/*
1396 * This lock protects the cifs_tcp_ses_list, the list of smb sessions per
1397 * tcp session, and the list of tcon's per smb session. It also protects
1398 * the reference counters for the server, smb session, and tcon. Finally,
1399 * changes to the tcon->tidStatus should be done while holding this lock.
1400 */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301401GLOBAL_EXTERN spinlock_t cifs_tcp_ses_lock;
Steve Frenchddb4cbf2008-11-20 20:00:44 +00001402
1403/*
1404 * This lock protects the cifs_file->llist and cifs_file->flist
1405 * list operations, and updates to some flags (cifs_file->invalidHandle)
1406 * It will be moved to either use the tcon->stat_lock or equivalent later.
1407 * If cifs_tcp_ses_lock and the lock below are both needed to be held, then
1408 * the cifs_tcp_ses_lock must be grabbed first and released last.
1409 */
Jeff Layton44772882010-10-15 15:34:03 -04001410GLOBAL_EXTERN spinlock_t cifs_file_list_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411
Steve French0eff0e22011-02-24 05:39:23 +00001412#ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
Steve French99ee4db2007-02-27 05:35:17 +00001413/* Outstanding dir notify requests */
1414GLOBAL_EXTERN struct list_head GlobalDnotifyReqList;
1415/* DirNotify response queue */
1416GLOBAL_EXTERN struct list_head GlobalDnotifyRsp_Q;
Steve French0eff0e22011-02-24 05:39:23 +00001417#endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
Steve Frenchff5dbd92005-08-24 17:10:36 -07001418
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419/*
1420 * Global transaction id (XID) information
1421 */
1422GLOBAL_EXTERN unsigned int GlobalCurrentXid; /* protected by GlobalMid_Sem */
Steve French254e55e2006-06-04 05:53:15 +00001423GLOBAL_EXTERN unsigned int GlobalTotalActiveXid; /* prot by GlobalMid_Sem */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424GLOBAL_EXTERN unsigned int GlobalMaxActiveXid; /* prot by GlobalMid_Sem */
Steve French254e55e2006-06-04 05:53:15 +00001425GLOBAL_EXTERN spinlock_t GlobalMid_Lock; /* protects above & list operations */
1426 /* on midQ entries */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427/*
1428 * Global counters, updated atomically
1429 */
1430GLOBAL_EXTERN atomic_t sesInfoAllocCount;
1431GLOBAL_EXTERN atomic_t tconInfoAllocCount;
1432GLOBAL_EXTERN atomic_t tcpSesAllocCount;
1433GLOBAL_EXTERN atomic_t tcpSesReconnectCount;
1434GLOBAL_EXTERN atomic_t tconInfoReconnectCount;
1435
Steve Frenchaaa9bbe2008-05-23 17:38:32 +00001436/* Various Debug counters */
Steve French4498eed52005-12-03 13:58:57 -08001437GLOBAL_EXTERN atomic_t bufAllocCount; /* current number allocated */
1438#ifdef CONFIG_CIFS_STATS2
1439GLOBAL_EXTERN atomic_t totBufAllocCount; /* total allocated over all time */
1440GLOBAL_EXTERN atomic_t totSmBufAllocCount;
1441#endif
1442GLOBAL_EXTERN atomic_t smBufAllocCount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443GLOBAL_EXTERN atomic_t midCount;
1444
1445/* Misc globals */
Jeff Layton5e500ed2012-05-16 07:13:17 -04001446GLOBAL_EXTERN bool enable_oplocks; /* enable or disable oplocks */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447GLOBAL_EXTERN unsigned int lookupCacheEnabled;
Jeff Layton04912d62010-04-24 07:57:45 -04001448GLOBAL_EXTERN unsigned int global_secflags; /* if on, session setup sent
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449 with more secure ntlmssp2 challenge/resp */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450GLOBAL_EXTERN unsigned int sign_CIFS_PDUs; /* enable smb packet signing */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451GLOBAL_EXTERN unsigned int linuxExtEnabled;/*enable Linux/Unix CIFS extensions*/
1452GLOBAL_EXTERN unsigned int CIFSMaxBufSize; /* max size not including hdr */
1453GLOBAL_EXTERN unsigned int cifs_min_rcv; /* min size of big ntwrk buf pool */
1454GLOBAL_EXTERN unsigned int cifs_min_small; /* min size of small buf pool */
1455GLOBAL_EXTERN unsigned int cifs_max_pending; /* MAX requests at once to server*/
1456
Shirish Pargaonkar21fed0d2011-08-09 14:30:48 -05001457#ifdef CONFIG_CIFS_ACL
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001458GLOBAL_EXTERN struct rb_root uidtree;
1459GLOBAL_EXTERN struct rb_root gidtree;
1460GLOBAL_EXTERN spinlock_t siduidlock;
1461GLOBAL_EXTERN spinlock_t sidgidlock;
Shirish Pargaonkar21fed0d2011-08-09 14:30:48 -05001462GLOBAL_EXTERN struct rb_root siduidtree;
1463GLOBAL_EXTERN struct rb_root sidgidtree;
1464GLOBAL_EXTERN spinlock_t uidsidlock;
1465GLOBAL_EXTERN spinlock_t gidsidlock;
1466#endif /* CONFIG_CIFS_ACL */
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001467
Tejun Heo9b646972010-07-20 22:09:02 +02001468void cifs_oplock_break(struct work_struct *work);
Linus Torvalds3b7433b2010-08-07 12:42:58 -07001469
Jeff Layton3bc303c2009-09-21 06:47:50 -04001470extern const struct slow_work_ops cifs_oplock_break_ops;
Jeff Laytonda472fc2012-03-23 14:40:53 -04001471extern struct workqueue_struct *cifsiod_wq;
Suresh Jayaramanabd2e442010-06-22 20:52:50 +05301472
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +04001473extern mempool_t *cifs_mid_poolp;
1474
Jeff Layton23db65f2012-05-15 12:20:51 -04001475/* Operations for different SMB versions */
1476#define SMB1_VERSION_STRING "1.0"
1477extern struct smb_version_operations smb1_operations;
1478extern struct smb_version_values smb1_values;
Steve French1080ef72011-02-24 18:07:19 +00001479#define SMB21_VERSION_STRING "2.1"
1480extern struct smb_version_operations smb21_operations;
1481extern struct smb_version_values smb21_values;
Suresh Jayaramanabd2e442010-06-22 20:52:50 +05301482#endif /* _CIFS_GLOB_H */