blob: aea1eec649116a3891ce00c9ff6d073d7183fc6a [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
Pavel Shilovsky76ec5e32012-09-18 16:20:33 -070035#define CIFS_MAGIC_NUMBER 0xFF534D42 /* the first four bytes of SMB PDUs */
36
Linus Torvalds1da177e2005-04-16 15:20:36 -070037/*
38 * The sizes of various internal tables and strings
39 */
40#define MAX_UID_INFO 16
41#define MAX_SES_INFO 2
42#define MAX_TCON_INFO 4
43
Shirish Pargaonkaref571ca2008-07-24 15:56:05 +000044#define MAX_TREE_SIZE (2 + MAX_SERVER_SIZE + 1 + MAX_SHARE_SIZE + 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#define MAX_SERVER_SIZE 15
Steve French2e325d52011-03-08 05:51:19 +000046#define MAX_SHARE_SIZE 80
Steve French8727c8a2011-02-25 01:11:56 -060047#define MAX_USERNAME_SIZE 256 /* reasonable maximum for current servers */
48#define MAX_PASSWORD_SIZE 512 /* max for windows seems to be 256 wide chars */
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
50#define CIFS_MIN_RCV_POOL 4
51
Shirish Pargaonkar2c0c2a02012-05-21 09:20:12 -050052#define MAX_REOPEN_ATT 5 /* these many maximum attempts to reopen a file */
Linus Torvalds1da177e2005-04-16 15:20:36 -070053/*
Suresh Jayaraman6d20e842010-12-01 14:42:28 +053054 * default attribute cache timeout (jiffies)
55 */
56#define CIFS_DEF_ACTIMEO (1 * HZ)
57
58/*
59 * max attribute cache timeout (jiffies) - 2^30
60 */
61#define CIFS_MAX_ACTIMEO (1 << 30)
62
63/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070064 * MAX_REQ is the maximum number of requests that WE will send
Pavel Shilovsky10b9b982012-03-20 12:55:09 +030065 * on one socket concurrently.
Linus Torvalds1da177e2005-04-16 15:20:36 -070066 */
Pavel Shilovsky10b9b982012-03-20 12:55:09 +030067#define CIFS_MAX_REQ 32767
Linus Torvalds1da177e2005-04-16 15:20:36 -070068
Jeff Layton8ecaf672008-12-01 15:23:50 -050069#define RFC1001_NAME_LEN 15
70#define RFC1001_NAME_LEN_WITH_NULL (RFC1001_NAME_LEN + 1)
71
72/* currently length of NIP6_FMT */
73#define SERVER_NAME_LENGTH 40
Linus Torvalds1da177e2005-04-16 15:20:36 -070074#define SERVER_NAME_LEN_WITH_NULL (SERVER_NAME_LENGTH + 1)
75
76/* used to define string lengths for reversing unicode strings */
77/* (256+1)*2 = 514 */
78/* (max path length + 1 for null) * 2 for unicode */
79#define MAX_NAME 514
80
Pavel Shilovsky9094fad2012-07-12 18:30:44 +040081/* SMB echo "timeout" -- FIXME: tunable? */
82#define SMB_ECHO_INTERVAL (60 * HZ)
83
Linus Torvalds1da177e2005-04-16 15:20:36 -070084#include "cifspdu.h"
85
Linus Torvalds1da177e2005-04-16 15:20:36 -070086#ifndef XATTR_DOS_ATTRIB
87#define XATTR_DOS_ATTRIB "user.DOSATTRIB"
88#endif
89
90/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 * CIFS vfs client Status information (based on what we know.)
92 */
93
Steve French6c0f6212010-10-23 16:51:40 +000094/* associated with each tcp and smb session */
Linus Torvalds1da177e2005-04-16 15:20:36 -070095enum statusEnum {
96 CifsNew = 0,
97 CifsGood,
98 CifsExiting,
Steve Frenchfd88ce92011-04-12 01:01:14 +000099 CifsNeedReconnect,
100 CifsNeedNegotiate
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101};
102
103enum securityEnum {
Jeff Laytondaf5b0b2010-07-06 20:43:02 -0400104 LANMAN = 0, /* Legacy LANMAN auth */
Steve French39798772006-05-31 22:40:51 +0000105 NTLM, /* Legacy NTLM012 auth with NTLM hash */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 NTLMv2, /* Legacy NTLM auth with NTLMv2 hash */
Steve Frenchac683922009-05-06 04:16:04 +0000107 RawNTLMSSP, /* NTLMSSP without SPNEGO, NTLMv2 hash */
Steve Frenchf46c7232009-06-25 03:04:20 +0000108/* NTLMSSP, */ /* can use rawNTLMSSP instead of NTLMSSP via SPNEGO */
Steve Frenchc16fefa2008-08-19 19:35:33 +0000109 Kerberos, /* Kerberos via SPNEGO */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110};
111
112enum protocolEnum {
Steve French3ec332e2008-11-14 03:35:10 +0000113 TCP = 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 SCTP
115 /* Netbios frames protocol not supported at this time */
116};
117
Shirish Pargaonkar5f98ca92010-09-18 22:01:58 -0500118struct session_key {
Steve Frenchb609f062007-07-09 07:55:14 +0000119 unsigned int len;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500120 char *response;
Steve Frenchb609f062007-07-09 07:55:14 +0000121};
122
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500123/* crypto security descriptor definition */
124struct sdesc {
125 struct shash_desc shash;
126 char ctx[];
127};
128
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -0500129/* crypto hashing related structure/fields, not specific to a sec mech */
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500130struct cifs_secmech {
131 struct crypto_shash *hmacmd5; /* hmac-md5 hash function */
132 struct crypto_shash *md5; /* md5 hash function */
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700133 struct crypto_shash *hmacsha256; /* hmac-sha256 hash function */
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500134 struct sdesc *sdeschmacmd5; /* ctxt to generate ntlmv2 hash, CR1 */
135 struct sdesc *sdescmd5; /* ctxt to generate cifs/smb signature */
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700136 struct sdesc *sdeschmacsha256; /* ctxt to generate smb2 signature */
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500137};
138
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500139/* per smb session structure/fields */
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500140struct ntlmssp_auth {
141 __u32 client_flags; /* sent by client in type 1 ntlmsssp exchange */
142 __u32 server_flags; /* sent by server in type 2 ntlmssp exchange */
143 unsigned char ciphertext[CIFS_CPHTXT_SIZE]; /* sent to server */
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500144 char cryptkey[CIFS_CRYPTO_KEY_SIZE]; /* used by ntlmssp */
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500145};
146
Steve French442aa312007-09-24 20:25:46 +0000147struct cifs_cred {
148 int uid;
149 int gid;
150 int mode;
151 int cecount;
152 struct cifs_sid osid;
153 struct cifs_sid gsid;
154 struct cifs_ntace *ntaces;
155 struct cifs_ace *aces;
156};
157
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158/*
159 *****************************************************************
160 * Except the CIFS PDUs themselves all the
161 * globally interesting structs should go here
162 *****************************************************************
163 */
164
Jeff Laytonbf5ea0e2012-09-18 16:20:34 -0700165/*
166 * A smb_rqst represents a complete request to be issued to a server. It's
167 * formed by a kvec array, followed by an array of pages. Page data is assumed
168 * to start at the beginning of the first page.
169 */
170struct smb_rqst {
171 struct kvec *rq_iov; /* array of kvecs */
172 unsigned int rq_nvec; /* number of kvecs in array */
173 struct page **rq_pages; /* pointer to array of page ptrs */
174 unsigned int rq_npages; /* number pages in array */
175 unsigned int rq_pagesz; /* page size to use */
176 unsigned int rq_tailsz; /* length of last page */
177};
178
Jeff Layton23db65f2012-05-15 12:20:51 -0400179enum smb_version {
180 Smb_1 = 1,
Steve Frenchdd446b12012-11-28 23:21:06 -0600181 Smb_20,
Steve French1080ef72011-02-24 18:07:19 +0000182 Smb_21,
Steve Frenche4aa25e2012-10-01 12:26:22 -0500183 Smb_30,
Jeff Layton23db65f2012-05-15 12:20:51 -0400184};
185
Jeff Layton121b0462012-05-15 12:21:10 -0400186struct mid_q_entry;
187struct TCP_Server_Info;
Pavel Shilovsky55157df2012-02-28 14:04:17 +0300188struct cifsFileInfo;
Pavel Shilovsky082d0642012-05-17 12:18:21 +0400189struct cifs_ses;
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +0400190struct cifs_tcon;
Pavel Shilovskyb669f332012-05-27 20:21:53 +0400191struct dfs_info3_param;
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400192struct cifs_fattr;
Pavel Shilovsky9224dfc2012-05-27 20:39:52 +0400193struct smb_vol;
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700194struct cifs_fid;
Pavel Shilovskyfc9c5962012-09-18 16:20:28 -0700195struct cifs_readdata;
Pavel Shilovskyc9de5c82012-09-18 16:20:29 -0700196struct cifs_writedata;
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -0700197struct cifs_io_parms;
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700198struct cifs_search_info;
Pavel Shilovsky95a3f2f2012-09-18 16:20:33 -0700199struct cifsInodeInfo;
Jeff Layton121b0462012-05-15 12:21:10 -0400200
Jeff Layton23db65f2012-05-15 12:20:51 -0400201struct smb_version_operations {
Jeff Layton121b0462012-05-15 12:21:10 -0400202 int (*send_cancel)(struct TCP_Server_Info *, void *,
203 struct mid_q_entry *);
Pavel Shilovsky55157df2012-02-28 14:04:17 +0300204 bool (*compare_fids)(struct cifsFileInfo *, struct cifsFileInfo *);
Pavel Shilovsky082d0642012-05-17 12:18:21 +0400205 /* setup request: allocate mid, sign message */
Jeff Laytonfec344e2012-09-18 16:20:35 -0700206 struct mid_q_entry *(*setup_request)(struct cifs_ses *,
207 struct smb_rqst *);
Pavel Shilovsky45740842012-06-01 14:26:18 +0400208 /* setup async request: allocate mid, sign message */
Jeff Laytonfec344e2012-09-18 16:20:35 -0700209 struct mid_q_entry *(*setup_async_request)(struct TCP_Server_Info *,
210 struct smb_rqst *);
Pavel Shilovsky082d0642012-05-17 12:18:21 +0400211 /* check response: verify signature, map error */
212 int (*check_receive)(struct mid_q_entry *, struct TCP_Server_Info *,
213 bool);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400214 void (*add_credits)(struct TCP_Server_Info *, const unsigned int,
215 const int);
Pavel Shilovsky45275782012-05-17 17:53:29 +0400216 void (*set_credits)(struct TCP_Server_Info *, const int);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400217 int * (*get_credits_field)(struct TCP_Server_Info *, const int);
218 unsigned int (*get_credits)(struct mid_q_entry *);
Pavel Shilovsky88257362012-05-23 14:01:59 +0400219 __u64 (*get_next_mid)(struct TCP_Server_Info *);
Pavel Shilovskyeb378712012-05-17 13:02:51 +0400220 /* data offset from read response message */
221 unsigned int (*read_data_offset)(char *);
222 /* data length from read response message */
223 unsigned int (*read_data_length)(char *);
224 /* map smb to linux error */
225 int (*map_error)(char *, bool);
Pavel Shilovsky8aa26f32012-05-17 13:25:35 +0400226 /* find mid corresponding to the response message */
227 struct mid_q_entry * (*find_mid)(struct TCP_Server_Info *, char *);
228 void (*dump_detail)(void *);
Pavel Shilovsky44c58182012-05-28 14:16:31 +0400229 void (*clear_stats)(struct cifs_tcon *);
230 void (*print_stats)(struct seq_file *m, struct cifs_tcon *);
Pavel Shilovsky8aa26f32012-05-17 13:25:35 +0400231 /* verify the message */
232 int (*check_message)(char *, unsigned int);
233 bool (*is_oplock_break)(char *, struct TCP_Server_Info *);
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 *,
267 FILE_ALL_INFO *, 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);
Pavel Shilovskyf6d76172012-05-25 14:47:16 +0400284 /* check if we can send an echo or nor */
285 bool (*can_echo)(struct TCP_Server_Info *);
286 /* send echo request */
287 int (*echo)(struct TCP_Server_Info *);
Pavel Shilovskyf4367202012-03-17 11:41:12 +0300288 /* create directory */
289 int (*mkdir)(const unsigned int, struct cifs_tcon *, const char *,
290 struct cifs_sb_info *);
291 /* set info on created directory */
292 void (*mkdir_setinfo)(struct inode *, const char *,
293 struct cifs_sb_info *, struct cifs_tcon *,
294 const unsigned int);
Pavel Shilovskyf958ca52012-07-10 16:14:18 +0400295 /* remove directory */
296 int (*rmdir)(const unsigned int, struct cifs_tcon *, const char *,
297 struct cifs_sb_info *);
Pavel Shilovskyed6875e2012-09-18 16:20:25 -0700298 /* unlink file */
299 int (*unlink)(const unsigned int, struct cifs_tcon *, const char *,
300 struct cifs_sb_info *);
301 /* open, rename and delete file */
302 int (*rename_pending_delete)(const char *, struct dentry *,
303 const unsigned int);
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -0700304 /* send rename request */
305 int (*rename)(const unsigned int, struct cifs_tcon *, const char *,
306 const char *, struct cifs_sb_info *);
Steve Frenchd6e906f2012-09-18 16:20:31 -0700307 /* send create hardlink request */
308 int (*create_hardlink)(const unsigned int, struct cifs_tcon *,
309 const char *, const char *,
310 struct cifs_sb_info *);
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700311 /* open a file for non-posix mounts */
312 int (*open)(const unsigned int, struct cifs_tcon *, const char *, int,
313 int, int, struct cifs_fid *, __u32 *, FILE_ALL_INFO *,
314 struct cifs_sb_info *);
315 /* set fid protocol-specific info */
316 void (*set_fid)(struct cifsFileInfo *, struct cifs_fid *, __u32);
Pavel Shilovsky0ff78a22012-09-18 16:20:26 -0700317 /* close a file */
Pavel Shilovsky760ad0c2012-09-25 11:00:07 +0400318 void (*close)(const unsigned int, struct cifs_tcon *,
319 struct cifs_fid *);
Pavel Shilovsky1d8c4c02012-09-18 16:20:27 -0700320 /* send a flush request to the server */
321 int (*flush)(const unsigned int, struct cifs_tcon *, struct cifs_fid *);
Pavel Shilovskyfc9c5962012-09-18 16:20:28 -0700322 /* async read from the server */
323 int (*async_readv)(struct cifs_readdata *);
Pavel Shilovskyc9de5c82012-09-18 16:20:29 -0700324 /* async write to the server */
325 int (*async_writev)(struct cifs_writedata *);
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -0700326 /* sync read from the server */
327 int (*sync_read)(const unsigned int, struct cifsFileInfo *,
328 struct cifs_io_parms *, unsigned int *, char **,
329 int *);
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -0700330 /* sync write to the server */
331 int (*sync_write)(const unsigned int, struct cifsFileInfo *,
332 struct cifs_io_parms *, unsigned int *, struct kvec *,
333 unsigned long);
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700334 /* open dir, start readdir */
335 int (*query_dir_first)(const unsigned int, struct cifs_tcon *,
336 const char *, struct cifs_sb_info *,
337 struct cifs_fid *, __u16,
338 struct cifs_search_info *);
339 /* continue readdir */
340 int (*query_dir_next)(const unsigned int, struct cifs_tcon *,
341 struct cifs_fid *,
342 __u16, struct cifs_search_info *srch_inf);
343 /* close dir */
344 int (*close_dir)(const unsigned int, struct cifs_tcon *,
345 struct cifs_fid *);
346 /* calculate a size of SMB message */
347 unsigned int (*calc_smb_size)(void *);
Pavel Shilovsky2e44b282012-09-18 16:20:33 -0700348 /* check for STATUS_PENDING and process it in a positive case */
349 bool (*is_status_pending)(char *, struct TCP_Server_Info *, int);
Pavel Shilovsky95a3f2f2012-09-18 16:20:33 -0700350 /* send oplock break response */
351 int (*oplock_response)(struct cifs_tcon *, struct cifs_fid *,
352 struct cifsInodeInfo *);
Pavel Shilovsky76ec5e32012-09-18 16:20:33 -0700353 /* query remote filesystem */
354 int (*queryfs)(const unsigned int, struct cifs_tcon *,
355 struct kstatfs *);
Pavel Shilovskyd39a4f72012-09-19 06:22:43 -0700356 /* send mandatory brlock to the server */
357 int (*mand_lock)(const unsigned int, struct cifsFileInfo *, __u64,
358 __u64, __u32, int, int, bool);
359 /* unlock range of mandatory locks */
360 int (*mand_unlock_range)(struct cifsFileInfo *, struct file_lock *,
361 const unsigned int);
362 /* push brlocks from the cache to the server */
363 int (*push_mand_locks)(struct cifsFileInfo *);
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700364 /* get lease key of the inode */
365 void (*get_lease_key)(struct inode *, struct cifs_fid *fid);
366 /* set lease key of the inode */
367 void (*set_lease_key)(struct inode *, struct cifs_fid *fid);
368 /* generate new lease key */
369 void (*new_lease_key)(struct cifs_fid *fid);
Steve French38107d42012-12-08 22:08:06 -0600370 int (*calc_signature)(struct smb_rqst *rqst,
371 struct TCP_Server_Info *server);
Jeff Layton23db65f2012-05-15 12:20:51 -0400372};
373
374struct smb_version_values {
375 char *version_string;
Steve Frenche4aa25e2012-10-01 12:26:22 -0500376 __u16 protocol_id;
377 __u32 req_capabilities;
Pavel Shilovsky106dc532012-02-28 14:23:34 +0300378 __u32 large_lock_type;
379 __u32 exclusive_lock_type;
380 __u32 shared_lock_type;
381 __u32 unlock_lock_type;
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400382 size_t header_size;
383 size_t max_header_size;
Pavel Shilovskyeb378712012-05-17 13:02:51 +0400384 size_t read_rsp_size;
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +0400385 __le16 lock_cmd;
Pavel Shilovsky29e20f92012-07-13 13:58:14 +0400386 unsigned int cap_unix;
387 unsigned int cap_nt_find;
388 unsigned int cap_large_files;
Jeff Layton23db65f2012-05-15 12:20:51 -0400389};
390
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400391#define HEADER_SIZE(server) (server->vals->header_size)
392#define MAX_HEADER_SIZE(server) (server->vals->max_header_size)
393
Steve Frenchf87d39d2011-05-27 03:50:55 +0000394struct smb_vol {
395 char *username;
396 char *password;
397 char *domainname;
398 char *UNC;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000399 char *iocharset; /* local code page for mapping to and from Unicode */
400 char source_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* clnt nb name */
401 char target_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* srvr nb name */
402 uid_t cred_uid;
403 uid_t linux_uid;
404 gid_t linux_gid;
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500405 uid_t backupuid;
406 gid_t backupgid;
Al Viro5206efd2011-07-26 03:22:14 -0400407 umode_t file_mode;
408 umode_t dir_mode;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000409 unsigned secFlg;
410 bool retry:1;
411 bool intr:1;
412 bool setuids:1;
413 bool override_uid:1;
414 bool override_gid:1;
415 bool dynperm:1;
416 bool noperm:1;
417 bool no_psx_acl:1; /* set if posix acl support should be disabled */
418 bool cifs_acl:1;
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500419 bool backupuid_specified; /* mount option backupuid is specified */
420 bool backupgid_specified; /* mount option backupgid is specified */
Steve Frenchf87d39d2011-05-27 03:50:55 +0000421 bool no_xattr:1; /* set if xattr (EA) support should be disabled*/
422 bool server_ino:1; /* use inode numbers from server ie UniqueId */
423 bool direct_io:1;
424 bool strict_io:1; /* strict cache behavior */
425 bool remap:1; /* set to remap seven reserved chars in filenames */
426 bool posix_paths:1; /* unset to not ask for posix pathnames. */
427 bool no_linux_ext:1;
428 bool sfu_emul:1;
429 bool nullauth:1; /* attempt to authenticate with null user */
430 bool nocase:1; /* request case insensitive filenames */
431 bool nobrl:1; /* disable sending byte range locks to srv */
432 bool mand_lock:1; /* send mandatory not posix byte range lock reqs */
433 bool seal:1; /* request transport encryption on share */
434 bool nodfs:1; /* Do not request DFS, even if available */
435 bool local_lease:1; /* check leases only on local system, not remote */
436 bool noblocksnd:1;
437 bool noautotune:1;
438 bool nostrictsync:1; /* do not force expensive SMBflush on every sync */
439 bool fsc:1; /* enable fscache */
440 bool mfsymlinks:1; /* use Minshall+French Symlinks */
441 bool multiuser:1;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000442 bool rwpidforward:1; /* pid forward for read/write operations */
Steve Frenchf87d39d2011-05-27 03:50:55 +0000443 unsigned int rsize;
444 unsigned int wsize;
445 bool sockopt_tcp_nodelay:1;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000446 unsigned long actimeo; /* attribute cache timeout (jiffies) */
Jeff Layton23db65f2012-05-15 12:20:51 -0400447 struct smb_version_operations *ops;
448 struct smb_version_values *vals;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000449 char *prepath;
Jeff Laytonb979aaa2012-11-26 11:09:55 -0500450 struct sockaddr_storage dstaddr; /* destination address */
Steve Frenchf87d39d2011-05-27 03:50:55 +0000451 struct sockaddr_storage srcaddr; /* allow binding to a local IP */
452 struct nls_table *local_nls;
453};
454
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400455#define CIFS_MOUNT_MASK (CIFS_MOUNT_NO_PERM | CIFS_MOUNT_SET_UID | \
456 CIFS_MOUNT_SERVER_INUM | CIFS_MOUNT_DIRECT_IO | \
457 CIFS_MOUNT_NO_XATTR | CIFS_MOUNT_MAP_SPECIAL_CHR | \
458 CIFS_MOUNT_UNX_EMUL | CIFS_MOUNT_NO_BRL | \
459 CIFS_MOUNT_CIFS_ACL | CIFS_MOUNT_OVERR_UID | \
460 CIFS_MOUNT_OVERR_GID | CIFS_MOUNT_DYNPERM | \
461 CIFS_MOUNT_NOPOSIXBRL | CIFS_MOUNT_NOSSYNC | \
462 CIFS_MOUNT_FSCACHE | CIFS_MOUNT_MF_SYMLINKS | \
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500463 CIFS_MOUNT_MULTIUSER | CIFS_MOUNT_STRICT_IO | \
464 CIFS_MOUNT_CIFS_BACKUPUID | CIFS_MOUNT_CIFS_BACKUPGID)
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400465
466#define CIFS_MS_MASK (MS_RDONLY | MS_MANDLOCK | MS_NOEXEC | MS_NOSUID | \
467 MS_NODEV | MS_SYNCHRONOUS)
468
469struct cifs_mnt_data {
470 struct cifs_sb_info *cifs_sb;
471 struct smb_vol *vol;
472 int flags;
473};
474
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400475static inline unsigned int
476get_rfc1002_length(void *buf)
477{
478 return be32_to_cpu(*((__be32 *)buf));
479}
480
Pavel Shilovskyec2e4522011-12-27 16:12:43 +0400481static inline void
482inc_rfc1001_len(void *buf, int count)
483{
484 be32_add_cpu((__be32 *)buf, count);
485}
486
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487struct TCP_Server_Info {
Steve French3b795212008-11-13 19:45:32 +0000488 struct list_head tcp_ses_list;
489 struct list_head smb_ses_list;
Jeff Laytone7ddee92008-11-14 13:44:38 -0500490 int srv_count; /* reference counter */
Steve Frencha10faeb22005-08-22 21:38:31 -0700491 /* 15 character server name + 0x20 16th byte indicating type = srv */
Jeff Layton8ecaf672008-12-01 15:23:50 -0500492 char server_RFC1001_name[RFC1001_NAME_LEN_WITH_NULL];
Jeff Layton23db65f2012-05-15 12:20:51 -0400493 struct smb_version_operations *ops;
494 struct smb_version_values *vals;
Jeff Laytonc3dccf42011-01-20 13:36:50 -0500495 enum statusEnum tcpStatus; /* what we think the status is */
Jeff Laytonc359cf32007-11-16 22:22:06 +0000496 char *hostname; /* hostname portion of UNC string */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 struct socket *ssocket;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300498 struct sockaddr_storage dstaddr;
Ben Greear3eb9a882010-09-01 17:06:02 -0700499 struct sockaddr_storage srcaddr; /* locally bind to this IP */
Rob Landleyf1d0c992011-01-22 15:44:05 -0600500#ifdef CONFIG_NET_NS
501 struct net *net;
502#endif
Steve Frenchd38d8c72007-06-28 19:44:13 +0000503 wait_queue_head_t response_q;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 wait_queue_head_t request_q; /* if more than maxmpx to srvr must block*/
505 struct list_head pending_mid_q;
Steve Frenchedf1ae42008-10-29 00:47:57 +0000506 bool noblocksnd; /* use blocking sendmsg */
507 bool noautotune; /* do not autotune send buf sizes */
Steve French6a5fa2362010-01-01 01:28:43 +0000508 bool tcp_nodelay;
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400509 int credits; /* send no more requests at once */
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300510 unsigned int in_flight; /* number of requests on the wire to server */
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400511 spinlock_t req_lock; /* protect the two values above */
Jeff Layton72ca5452008-12-01 07:09:36 -0500512 struct mutex srv_mutex;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 struct task_struct *tsk;
514 char server_GUID[16];
Pavel Shilovsky286170a2012-05-25 10:43:58 +0400515 __u16 sec_mode;
Jeff Laytonc3dccf42011-01-20 13:36:50 -0500516 bool session_estab; /* mark when very first sess is established */
Pavel Shilovsky28ea5292012-05-23 16:18:00 +0400517#ifdef CONFIG_CIFS_SMB2
518 int echo_credits; /* echo reserved slots */
519 int oplock_credits; /* oplock break reserved slots */
520 bool echoes:1; /* enable echoes */
521#endif
Jeff Laytonc3dccf42011-01-20 13:36:50 -0500522 u16 dialect; /* dialect index that server chose */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 enum securityEnum secType;
Pavel Shilovsky10b9b982012-03-20 12:55:09 +0300524 bool oplocks:1; /* enable oplocks */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 unsigned int maxReq; /* Clients should submit no more */
526 /* than maxReq distinct unanswered SMBs to the server when using */
527 /* multiplexed reads or writes */
528 unsigned int maxBuf; /* maxBuf specifies the maximum */
529 /* message size the server can send or receive for non-raw SMBs */
Steve French7e90d702011-02-08 23:52:32 +0000530 /* maxBuf is returned by SMB NegotiateProtocol so maxBuf is only 0 */
531 /* when socket is setup (and during reconnect) before NegProt sent */
Steve Frencheca6acf2009-02-20 05:43:09 +0000532 unsigned int max_rw; /* maxRw specifies the maximum */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 /* message size the server can send or receive for */
534 /* SMB_COM_WRITE_RAW or SMB_COM_READ_RAW. */
Steve Frencheca6acf2009-02-20 05:43:09 +0000535 unsigned int max_vcs; /* maximum number of smb sessions, at least
536 those that can be specified uniquely with
537 vcnumbers */
Pavel Shilovsky29e20f92012-07-13 13:58:14 +0400538 unsigned int capabilities; /* selective disabling of caps by smb sess */
Steve Frenchde7ed552006-09-30 13:25:52 +0000539 int timeAdj; /* Adjust for difference in server time zone in sec */
Pavel Shilovsky243d04b2012-03-23 14:28:03 -0400540 __u64 CurrentMid; /* multiplex id - rotating counter */
Shirish Pargaonkard3ba50b2010-10-27 15:20:36 -0500541 char cryptkey[CIFS_CRYPTO_KEY_SIZE]; /* used by ntlm, ntlmv2 etc */
Steve Frencha10faeb22005-08-22 21:38:31 -0700542 /* 16th byte of RFC1001 workstation name is always null */
Jeff Layton8ecaf672008-12-01 15:23:50 -0500543 char workstation_RFC1001_name[RFC1001_NAME_LEN_WITH_NULL];
Jeff Laytona0f8b4f2011-01-07 11:30:28 -0500544 __u32 sequence_number; /* for signing, protected by srv_mutex */
Shirish Pargaonkar5f98ca92010-09-18 22:01:58 -0500545 struct session_key session_key;
Steve French3a5ff612006-07-14 22:37:11 +0000546 unsigned long lstrp; /* when we got last response from this server */
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500547 struct cifs_secmech secmech; /* crypto sec mech functs, descriptors */
Jeff Layton26efa0b2010-04-24 07:57:49 -0400548 /* extended security flavors that server supports */
Jeff Laytonc3dccf42011-01-20 13:36:50 -0500549 bool sec_ntlmssp; /* supports NTLMSSP */
550 bool sec_kerberosu2u; /* supports U2U Kerberos */
Jeff Layton26efa0b2010-04-24 07:57:49 -0400551 bool sec_kerberos; /* supports plain Kerberos */
552 bool sec_mskerberos; /* supports legacy MS Kerberos */
Jeff Layton2a37ef92011-10-19 15:29:23 -0400553 bool large_buf; /* is current buffer large? */
Jeff Laytonc74093b2011-01-11 07:24:23 -0500554 struct delayed_work echo; /* echo ping workqueue job */
Jeff Layton1041e3f2011-10-19 15:28:27 -0400555 struct kvec *iov; /* reusable kvec array for receives */
556 unsigned int nr_iov; /* number of kvecs in array */
Jeff Layton2a37ef92011-10-19 15:29:23 -0400557 char *smallbuf; /* pointer to current "small" buffer */
558 char *bigbuf; /* pointer to current "big" buffer */
559 unsigned int total_read; /* total amount of data read in this pass */
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +0530560#ifdef CONFIG_CIFS_FSCACHE
561 struct fscache_cookie *fscache; /* client index cache cookie */
562#endif
Jeff Laytonc3dccf42011-01-20 13:36:50 -0500563#ifdef CONFIG_CIFS_STATS2
Steve French789e6662011-08-09 18:44:44 +0000564 atomic_t in_send; /* requests trying to send */
Jeff Laytonc3dccf42011-01-20 13:36:50 -0500565 atomic_t num_waiters; /* blocked waiting to get in sendrecv */
566#endif
Pavel Shilovskyec2e4522011-12-27 16:12:43 +0400567#ifdef CONFIG_CIFS_SMB2
568 unsigned int max_read;
569 unsigned int max_write;
570#endif /* CONFIG_CIFS_SMB2 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571};
572
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300573static inline unsigned int
574in_flight(struct TCP_Server_Info *server)
575{
576 unsigned int num;
577 spin_lock(&server->req_lock);
578 num = server->in_flight;
579 spin_unlock(&server->req_lock);
580 return num;
581}
582
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400583static inline bool
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300584has_credits(struct TCP_Server_Info *server, int *credits)
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300585{
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400586 int num;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300587 spin_lock(&server->req_lock);
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300588 num = *credits;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300589 spin_unlock(&server->req_lock);
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400590 return num > 0;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300591}
592
Pavel Shilovsky45275782012-05-17 17:53:29 +0400593static inline void
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400594add_credits(struct TCP_Server_Info *server, const unsigned int add,
595 const int optype)
Pavel Shilovsky45275782012-05-17 17:53:29 +0400596{
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400597 server->ops->add_credits(server, add, optype);
Pavel Shilovsky45275782012-05-17 17:53:29 +0400598}
599
600static inline void
601set_credits(struct TCP_Server_Info *server, const int val)
602{
603 server->ops->set_credits(server, val);
604}
605
Pavel Shilovsky88257362012-05-23 14:01:59 +0400606static inline __u64
607get_next_mid(struct TCP_Server_Info *server)
608{
609 return server->ops->get_next_mid(server);
610}
611
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612/*
Pavel Shilovsky24985c52012-09-18 16:20:28 -0700613 * When the server supports very large reads and writes via POSIX extensions,
614 * we can allow up to 2^24-1, minus the size of a READ/WRITE_AND_X header, not
615 * including the RFC1001 length.
616 *
617 * Note that this might make for "interesting" allocation problems during
618 * writeback however as we have to allocate an array of pointers for the
619 * pages. A 16M write means ~32kb page array with PAGE_CACHE_SIZE == 4096.
620 *
621 * For reads, there is a similar problem as we need to allocate an array
622 * of kvecs to handle the receive, though that should only need to be done
623 * once.
624 */
625#define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
626#define CIFS_MAX_RSIZE ((1<<24) - sizeof(READ_RSP) + 4)
627
628/*
629 * When the server doesn't allow large posix writes, only allow a rsize/wsize
630 * of 2^17-1 minus the size of the call header. That allows for a read or
631 * write up to the maximum size described by RFC1002.
632 */
633#define CIFS_MAX_RFC1002_WSIZE ((1<<17) - 1 - sizeof(WRITE_REQ) + 4)
634#define CIFS_MAX_RFC1002_RSIZE ((1<<17) - 1 - sizeof(READ_RSP) + 4)
635
636/*
637 * The default wsize is 1M. find_get_pages seems to return a maximum of 256
638 * pages in a single call. With PAGE_CACHE_SIZE == 4k, this means we can fill
639 * a single wsize request with a single call.
640 */
641#define CIFS_DEFAULT_IOSIZE (1024 * 1024)
642
643/*
644 * Windows only supports a max of 60kb reads and 65535 byte writes. Default to
645 * those values when posix extensions aren't in force. In actuality here, we
646 * use 65536 to allow for a write that is a multiple of 4k. Most servers seem
647 * to be ok with the extra byte even though Windows doesn't send writes that
648 * are that large.
649 *
650 * Citation:
651 *
652 * http://blogs.msdn.com/b/openspecification/archive/2009/04/10/smb-maximum-transmit-buffer-size-and-performance-tuning.aspx
653 */
654#define CIFS_DEFAULT_NON_POSIX_RSIZE (60 * 1024)
655#define CIFS_DEFAULT_NON_POSIX_WSIZE (65536)
656
657/*
Rob Landleyf1d0c992011-01-22 15:44:05 -0600658 * Macros to allow the TCP_Server_Info->net field and related code to drop out
659 * when CONFIG_NET_NS isn't set.
660 */
661
662#ifdef CONFIG_NET_NS
663
664static inline struct net *cifs_net_ns(struct TCP_Server_Info *srv)
665{
666 return srv->net;
667}
668
669static inline void cifs_set_net_ns(struct TCP_Server_Info *srv, struct net *net)
670{
671 srv->net = net;
672}
673
674#else
675
676static inline struct net *cifs_net_ns(struct TCP_Server_Info *srv)
677{
678 return &init_net;
679}
680
681static inline void cifs_set_net_ns(struct TCP_Server_Info *srv, struct net *net)
682{
683}
684
685#endif
686
687/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 * Session structure. One of these for each uid session with a particular host
689 */
Steve French96daf2b2011-05-27 04:34:02 +0000690struct cifs_ses {
Jeff Layton14fbf502008-11-14 13:53:46 -0500691 struct list_head smb_ses_list;
Steve French3b795212008-11-13 19:45:32 +0000692 struct list_head tcon_list;
Steve Frenchd7b619c2010-02-25 05:36:46 +0000693 struct mutex session_mutex;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 struct TCP_Server_Info *server; /* pointer to server info */
Jeff Layton14fbf502008-11-14 13:53:46 -0500695 int ses_count; /* reference counter */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 enum statusEnum status;
Steve French750d1152006-06-27 06:28:30 +0000697 unsigned overrideSecFlg; /* if non-zero override global sec flags */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 __u16 ipc_tid; /* special tid for connection to IPC share */
699 __u16 flags;
Steve Frencheca6acf2009-02-20 05:43:09 +0000700 __u16 vcnum;
Steve Frenchad009ac2005-04-28 22:41:05 -0700701 char *serverOS; /* name of operating system underlying server */
702 char *serverNOS; /* name of network operating system of server */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 char *serverDomain; /* security realm of server */
Pavel Shilovsky286170a2012-05-25 10:43:58 +0400704 __u64 Suid; /* remote smb uid */
Jeff Layton3e4b3e12010-07-19 18:00:17 -0400705 uid_t linux_uid; /* overriding owner of files on the mount */
706 uid_t cred_uid; /* owner of credentials */
Pavel Shilovsky29e20f92012-07-13 13:58:14 +0400707 unsigned int capabilities;
Steve Frenchd38d8c72007-06-28 19:44:13 +0000708 char serverName[SERVER_NAME_LEN_WITH_NULL * 2]; /* BB make bigger for
Steve Frenchad009ac2005-04-28 22:41:05 -0700709 TCP names - will ipv6 and sctp addresses fit? */
Steve French34c87902011-03-01 05:02:57 +0000710 char *user_name; /* must not be null except during init of sess
711 and after mount option parsing we fill it */
Steve Frenchd38d8c72007-06-28 19:44:13 +0000712 char *domainName;
713 char *password;
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -0500714 struct session_key auth_key;
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500715 struct ntlmssp_auth *ntlmssp; /* ciphertext, flags, server challenge */
Steve French3b795212008-11-13 19:45:32 +0000716 bool need_reconnect:1; /* connection reset, uid now invalid */
Pavel Shilovsky5478f9b2011-12-27 16:22:00 +0400717#ifdef CONFIG_CIFS_SMB2
718 __u16 session_flags;
719#endif /* CONFIG_CIFS_SMB2 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720};
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700721
Steve French9ac00b72006-09-30 04:13:17 +0000722/* no more than one of the following three session flags may be set */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723#define CIFS_SES_NT4 1
Steve French9ac00b72006-09-30 04:13:17 +0000724#define CIFS_SES_OS2 2
725#define CIFS_SES_W9X 4
726/* following flag is set for old servers such as OS2 (and Win95?)
727 which do not negotiate NTLM or POSIX dialects, but instead
728 negotiate one of the older LANMAN dialects */
729#define CIFS_SES_LANMAN 8
Pavel Shilovsky29e20f92012-07-13 13:58:14 +0400730
731static inline bool
732cap_unix(struct cifs_ses *ses)
733{
734 return ses->server->vals->cap_unix & ses->capabilities;
735}
736
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737/*
738 * there is one of these for each connection to a resource on a particular
Steve Frenchd38d8c72007-06-28 19:44:13 +0000739 * session
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 */
Steve French96daf2b2011-05-27 04:34:02 +0000741struct cifs_tcon {
Jeff Laytonf1987b42008-11-15 11:12:47 -0500742 struct list_head tcon_list;
743 int tc_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 struct list_head openFileList;
Steve French96daf2b2011-05-27 04:34:02 +0000745 struct cifs_ses *ses; /* pointer to session associated with */
Steve French254e55e2006-06-04 05:53:15 +0000746 char treeName[MAX_TREE_SIZE + 1]; /* UNC name of resource in ASCII */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 char *nativeFileSystem;
Jeff Layton00e485b2008-12-05 20:41:21 -0500748 char *password; /* for share-level security */
Pavel Shilovskyfaaf9462011-12-27 16:04:00 +0400749 __u32 tid; /* The 4 byte tree id */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 __u16 Flags; /* optional support bits */
751 enum statusEnum tidStatus;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752#ifdef CONFIG_CIFS_STATS
753 atomic_t num_smbs_sent;
Pavel Shilovsky44c58182012-05-28 14:16:31 +0400754 union {
755 struct {
756 atomic_t num_writes;
757 atomic_t num_reads;
758 atomic_t num_flushes;
759 atomic_t num_oplock_brks;
760 atomic_t num_opens;
761 atomic_t num_closes;
762 atomic_t num_deletes;
763 atomic_t num_mkdirs;
764 atomic_t num_posixopens;
765 atomic_t num_posixmkdirs;
766 atomic_t num_rmdirs;
767 atomic_t num_renames;
768 atomic_t num_t2renames;
769 atomic_t num_ffirst;
770 atomic_t num_fnext;
771 atomic_t num_fclose;
772 atomic_t num_hardlinks;
773 atomic_t num_symlinks;
774 atomic_t num_locks;
775 atomic_t num_acl_get;
776 atomic_t num_acl_set;
777 } cifs_stats;
Pavel Shilovskyd60622e2012-05-28 15:19:39 +0400778#ifdef CONFIG_CIFS_SMB2
779 struct {
780 atomic_t smb2_com_sent[NUMBER_OF_SMB2_COMMANDS];
781 atomic_t smb2_com_failed[NUMBER_OF_SMB2_COMMANDS];
782 } smb2_stats;
783#endif /* CONFIG_CIFS_SMB2 */
Pavel Shilovsky44c58182012-05-28 14:16:31 +0400784 } stats;
Steve Frencha5a2b482005-08-20 21:42:53 -0700785#ifdef CONFIG_CIFS_STATS2
786 unsigned long long time_writes;
787 unsigned long long time_reads;
788 unsigned long long time_opens;
789 unsigned long long time_deletes;
790 unsigned long long time_closes;
791 unsigned long long time_mkdirs;
792 unsigned long long time_rmdirs;
793 unsigned long long time_renames;
794 unsigned long long time_t2renames;
795 unsigned long long time_ffirst;
796 unsigned long long time_fnext;
797 unsigned long long time_fclose;
798#endif /* CONFIG_CIFS_STATS2 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 __u64 bytes_read;
800 __u64 bytes_written;
801 spinlock_t stat_lock;
Steve Frencha5a2b482005-08-20 21:42:53 -0700802#endif /* CONFIG_CIFS_STATS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 FILE_SYSTEM_DEVICE_INFO fsDevInfo;
Steve French254e55e2006-06-04 05:53:15 +0000804 FILE_SYSTEM_ATTRIBUTE_INFO fsAttrInfo; /* ok if fs name truncated */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 FILE_SYSTEM_UNIX_INFO fsUnixInfo;
Steve French4b18f2a2008-04-29 00:06:05 +0000806 bool ipc:1; /* set if connection to IPC$ eg for RPC/PIPES */
807 bool retry:1;
808 bool nocase:1;
Steve French95b1cb92008-05-15 16:44:38 +0000809 bool seal:1; /* transport encryption for this mounted share */
Steve French4b18f2a2008-04-29 00:06:05 +0000810 bool unix_ext:1; /* if false disable Linux extensions to CIFS protocol
Steve Frenchc18c8422007-07-18 23:21:09 +0000811 for this mount even if server would support */
Steve French84210e92008-10-23 04:42:37 +0000812 bool local_lease:1; /* check leases (only) on local system not remote */
Steve French64cc2c62009-03-04 19:54:08 +0000813 bool broken_posix_open; /* e.g. Samba server versions < 3.3.2, 3.2.9 */
Steve French3b795212008-11-13 19:45:32 +0000814 bool need_reconnect:1; /* connection reset, tid now invalid */
Pavel Shilovskyfaaf9462011-12-27 16:04:00 +0400815#ifdef CONFIG_CIFS_SMB2
816 bool print:1; /* set if connection to printer share */
817 bool bad_network_name:1; /* set if ret status STATUS_BAD_NETWORK_NAME */
818 __u32 capabilities;
819 __u32 share_flags;
820 __u32 maximal_access;
821 __u32 vol_serial_number;
822 __le64 vol_create_time;
823#endif /* CONFIG_CIFS_SMB2 */
Suresh Jayaramand03382c2010-07-05 18:12:27 +0530824#ifdef CONFIG_CIFS_FSCACHE
825 u64 resource_id; /* server resource id */
826 struct fscache_cookie *fscache; /* cookie for share */
827#endif
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700828 struct list_head pending_opens; /* list of incomplete opens */
Steve Frenchc18c8422007-07-18 23:21:09 +0000829 /* BB add field for back pointer to sb struct(s)? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830};
831
832/*
Jeff Layton7ffec372010-09-29 19:51:11 -0400833 * This is a refcounted and timestamped container for a tcon pointer. The
834 * container holds a tcon reference. It is considered safe to free one of
835 * these when the tl_count goes to 0. The tl_time is the time of the last
836 * "get" on the container.
837 */
838struct tcon_link {
Jeff Laytonb647c352010-10-28 11:16:44 -0400839 struct rb_node tl_rbnode;
840 uid_t tl_uid;
Jeff Layton9d002df2010-10-06 19:51:11 -0400841 unsigned long tl_flags;
842#define TCON_LINK_MASTER 0
843#define TCON_LINK_PENDING 1
844#define TCON_LINK_IN_TREE 2
845 unsigned long tl_time;
846 atomic_t tl_count;
Steve French96daf2b2011-05-27 04:34:02 +0000847 struct cifs_tcon *tl_tcon;
Jeff Layton7ffec372010-09-29 19:51:11 -0400848};
849
Jeff Layton9d002df2010-10-06 19:51:11 -0400850extern struct tcon_link *cifs_sb_tlink(struct cifs_sb_info *cifs_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -0400851
Steve French96daf2b2011-05-27 04:34:02 +0000852static inline struct cifs_tcon *
Jeff Layton7ffec372010-09-29 19:51:11 -0400853tlink_tcon(struct tcon_link *tlink)
854{
Jeff Layton9d002df2010-10-06 19:51:11 -0400855 return tlink->tl_tcon;
Jeff Layton7ffec372010-09-29 19:51:11 -0400856}
857
Jeff Layton9d002df2010-10-06 19:51:11 -0400858extern void cifs_put_tlink(struct tcon_link *tlink);
Jeff Layton7ffec372010-09-29 19:51:11 -0400859
Jeff Layton13cfb732010-09-29 19:51:11 -0400860static inline struct tcon_link *
861cifs_get_tlink(struct tcon_link *tlink)
862{
Jeff Layton9d002df2010-10-06 19:51:11 -0400863 if (tlink && !IS_ERR(tlink))
864 atomic_inc(&tlink->tl_count);
Jeff Layton13cfb732010-09-29 19:51:11 -0400865 return tlink;
866}
867
Jeff Layton7ffec372010-09-29 19:51:11 -0400868/* This function is always expected to succeed */
Steve French96daf2b2011-05-27 04:34:02 +0000869extern struct cifs_tcon *cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -0400870
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700871#define CIFS_OPLOCK_NO_CHANGE 0xfe
872
873struct cifs_pending_open {
874 struct list_head olist;
875 struct tcon_link *tlink;
876 __u8 lease_key[16];
877 __u32 oplock;
878};
879
Jeff Layton7ffec372010-09-29 19:51:11 -0400880/*
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000881 * This info hangs off the cifsFileInfo structure, pointed to by llist.
882 * This is used to track byte stream locks on the file
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 */
884struct cifsLockInfo {
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000885 struct list_head llist; /* pointer to next cifsLockInfo */
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400886 struct list_head blist; /* pointer to locks blocked on this */
887 wait_queue_head_t block_q;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000888 __u64 offset;
889 __u64 length;
Pavel Shilovsky03776f42010-08-17 11:26:00 +0400890 __u32 pid;
Pavel Shilovsky04a6aa82012-02-28 14:16:55 +0300891 __u32 type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892};
893
894/*
895 * One of these for each open instance of a file
896 */
897struct cifs_search_info {
898 loff_t index_of_last_entry;
899 __u16 entries_in_buffer;
900 __u16 info_level;
901 __u32 resume_key;
Steve Frenchd38d8c72007-06-28 19:44:13 +0000902 char *ntwrk_buf_start;
903 char *srch_entries_start;
Steve French0752f152008-10-07 20:03:33 +0000904 char *last_entry;
Christoph Hellwigeaf35b12011-07-16 15:24:37 -0400905 const char *presume_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 unsigned int resume_name_len;
Steve French4b18f2a2008-04-29 00:06:05 +0000907 bool endOfSearch:1;
908 bool emptyDir:1;
909 bool unicode:1;
910 bool smallBuf:1; /* so we know which buf_release function to call */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911};
912
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700913struct cifs_fid {
914 __u16 netfid;
Pavel Shilovskyf0df7372012-09-18 16:20:26 -0700915#ifdef CONFIG_CIFS_SMB2
916 __u64 persistent_fid; /* persist file id for smb2 */
917 __u64 volatile_fid; /* volatile file id for smb2 */
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700918 __u8 lease_key[SMB2_LEASE_KEY_SIZE]; /* lease key for smb2 */
Pavel Shilovskyf0df7372012-09-18 16:20:26 -0700919#endif
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700920 struct cifs_pending_open *pending_open;
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700921};
922
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700923struct cifs_fid_locks {
924 struct list_head llist;
925 struct cifsFileInfo *cfile; /* fid that owns locks */
926 struct list_head locks; /* locks held by fid above */
927};
928
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929struct cifsFileInfo {
930 struct list_head tlist; /* pointer to next fid owned by tcon */
931 struct list_head flist; /* next fid (file instance) for this inode */
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700932 struct cifs_fid_locks *llist; /* brlocks held by this fid */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 unsigned int uid; /* allows finding which FileInfo structure */
934 __u32 pid; /* process id who opened file */
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700935 struct cifs_fid fid; /* file id from remote */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 /* BB add lock scope info here if needed */ ;
937 /* lock scope id (0 if none) */
Jeff Laytona5e18bc2010-10-11 15:07:18 -0400938 struct dentry *dentry;
Jeff Layton15886172010-10-15 15:33:59 -0400939 unsigned int f_flags;
Jeff Layton13cfb732010-09-29 19:51:11 -0400940 struct tcon_link *tlink;
Steve French4b18f2a2008-04-29 00:06:05 +0000941 bool invalidHandle:1; /* file closed via session abend */
Jeff Layton3bc303c2009-09-21 06:47:50 -0400942 bool oplock_break_cancelled:1;
Steve French6c0f6212010-10-23 16:51:40 +0000943 int count; /* refcount protected by cifs_file_list_lock */
Steve Frencha6ce4932009-04-09 01:14:32 +0000944 struct mutex fh_mutex; /* prevents reopen race after dead ses*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 struct cifs_search_info srch_inf;
Tejun Heo9b646972010-07-20 22:09:02 +0200946 struct work_struct oplock_break; /* work for oplock breaks */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947};
948
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +0400949struct cifs_io_parms {
950 __u16 netfid;
Pavel Shilovsky09a47072012-09-18 16:20:29 -0700951#ifdef CONFIG_CIFS_SMB2
952 __u64 persistent_fid; /* persist file id for smb2 */
953 __u64 volatile_fid; /* volatile file id for smb2 */
954#endif
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +0400955 __u32 pid;
956 __u64 offset;
957 unsigned int length;
Steve French96daf2b2011-05-27 04:34:02 +0000958 struct cifs_tcon *tcon;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +0400959};
960
Pavel Shilovsky09a47072012-09-18 16:20:29 -0700961struct cifs_readdata;
962
963/* asynchronous read support */
964struct cifs_readdata {
965 struct kref refcount;
966 struct list_head list;
967 struct completion done;
968 struct cifsFileInfo *cfile;
969 struct address_space *mapping;
970 __u64 offset;
971 unsigned int bytes;
972 pid_t pid;
973 int result;
Pavel Shilovsky09a47072012-09-18 16:20:29 -0700974 struct work_struct work;
Jeff Layton8321fec2012-09-19 06:22:32 -0700975 int (*read_into_pages)(struct TCP_Server_Info *server,
976 struct cifs_readdata *rdata,
977 unsigned int len);
Jeff Layton58195752012-09-19 06:22:34 -0700978 struct kvec iov;
Jeff Layton8321fec2012-09-19 06:22:32 -0700979 unsigned int pagesz;
980 unsigned int tailsz;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -0700981 unsigned int nr_pages;
982 struct page *pages[];
Pavel Shilovsky09a47072012-09-18 16:20:29 -0700983};
984
Pavel Shilovsky33319142012-09-18 16:20:29 -0700985struct cifs_writedata;
986
987/* asynchronous write support */
988struct cifs_writedata {
989 struct kref refcount;
990 struct list_head list;
991 struct completion done;
992 enum writeback_sync_modes sync_mode;
993 struct work_struct work;
994 struct cifsFileInfo *cfile;
995 __u64 offset;
996 pid_t pid;
997 unsigned int bytes;
998 int result;
Jeff Laytoneddb0792012-09-18 16:20:35 -0700999 unsigned int pagesz;
1000 unsigned int tailsz;
Pavel Shilovsky33319142012-09-18 16:20:29 -07001001 unsigned int nr_pages;
1002 struct page *pages[1];
1003};
1004
Jeff Layton5f6dbc92010-10-15 15:34:06 -04001005/*
1006 * Take a reference on the file private data. Must be called with
1007 * cifs_file_list_lock held.
1008 */
Jeff Layton764a1b12012-07-25 14:59:54 -04001009static inline void
1010cifsFileInfo_get_locked(struct cifsFileInfo *cifs_file)
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001011{
Jeff Layton5f6dbc92010-10-15 15:34:06 -04001012 ++cifs_file->count;
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001013}
1014
Jeff Layton764a1b12012-07-25 14:59:54 -04001015struct cifsFileInfo *cifsFileInfo_get(struct cifsFileInfo *cifs_file);
Jeff Laytonb33879a2010-10-15 15:34:04 -04001016void cifsFileInfo_put(struct cifsFileInfo *cifs_file);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001017
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018/*
1019 * One of these for each file inode
1020 */
1021
1022struct cifsInodeInfo {
Pavel Shilovskyd59dad22011-09-22 09:53:59 +04001023 bool can_cache_brlcks;
Pavel Shilovskyf45d3412012-09-19 06:22:43 -07001024 struct list_head llist; /* locks helb by this inode */
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -07001025 struct rw_semaphore lock_sem; /* protect the fields above */
Steve Frenchd38d8c72007-06-28 19:44:13 +00001026 /* BB add in lists for dirty pages i.e. write caching info for oplock */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 struct list_head openFileList;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 __u32 cifsAttrs; /* e.g. DOS archive bit, sparse, compressed, system */
Jeff Laytonaae62fd2011-01-20 13:36:50 -05001029 bool clientCanCacheRead; /* read oplock */
1030 bool clientCanCacheAll; /* read and writebehind oplock */
1031 bool delete_pending; /* DELETE_ON_CLOSE is set */
1032 bool invalid_mapping; /* pagecache is invalid */
Pavel Shilovskyc299dd02012-12-06 22:07:52 +04001033 bool leave_pages_clean; /* protected by i_mutex, not set pages dirty */
Jeff Laytonaae62fd2011-01-20 13:36:50 -05001034 unsigned long time; /* jiffies of last update of inode */
Jeff Layton597b0272012-03-23 14:40:56 -04001035 u64 server_eof; /* current file size on server -- protected by i_lock */
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001036 u64 uniqueid; /* server inode number */
Jeff Layton20054bd2011-01-07 11:30:27 -05001037 u64 createtime; /* creation time on server */
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -07001038#ifdef CONFIG_CIFS_SMB2
1039 __u8 lease_key[SMB2_LEASE_KEY_SIZE]; /* lease key for this inode */
1040#endif
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +05301041#ifdef CONFIG_CIFS_FSCACHE
1042 struct fscache_cookie *fscache;
1043#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044 struct inode vfs_inode;
1045};
1046
1047static inline struct cifsInodeInfo *
1048CIFS_I(struct inode *inode)
1049{
1050 return container_of(inode, struct cifsInodeInfo, vfs_inode);
1051}
1052
1053static inline struct cifs_sb_info *
1054CIFS_SB(struct super_block *sb)
1055{
1056 return sb->s_fs_info;
1057}
1058
Steve Frenchab2f2182005-09-15 20:44:50 -07001059static inline char CIFS_DIR_SEP(const struct cifs_sb_info *cifs_sb)
Jeremy Allisonac670552005-06-22 17:26:35 -07001060{
1061 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
1062 return '/';
1063 else
1064 return '\\';
1065}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066
Steve Frenchf87d39d2011-05-27 03:50:55 +00001067static inline void
1068convert_delimiter(char *path, char delim)
1069{
Steve French1cc9bd62012-11-29 18:07:51 -06001070 char old_delim, *pos;
Steve Frenchf87d39d2011-05-27 03:50:55 +00001071
1072 if (delim == '/')
1073 old_delim = '\\';
1074 else
1075 old_delim = '/';
1076
Steve French1cc9bd62012-11-29 18:07:51 -06001077 pos = path;
1078 while ((pos = strchr(pos, old_delim)))
1079 *pos = delim;
Steve Frenchf87d39d2011-05-27 03:50:55 +00001080}
1081
Steve Frencha4544342005-08-24 13:59:35 -07001082#ifdef CONFIG_CIFS_STATS
1083#define cifs_stats_inc atomic_inc
1084
Steve French96daf2b2011-05-27 04:34:02 +00001085static inline void cifs_stats_bytes_written(struct cifs_tcon *tcon,
Steve Frencha4544342005-08-24 13:59:35 -07001086 unsigned int bytes)
1087{
1088 if (bytes) {
1089 spin_lock(&tcon->stat_lock);
1090 tcon->bytes_written += bytes;
1091 spin_unlock(&tcon->stat_lock);
1092 }
1093}
1094
Steve French96daf2b2011-05-27 04:34:02 +00001095static inline void cifs_stats_bytes_read(struct cifs_tcon *tcon,
Steve Frencha4544342005-08-24 13:59:35 -07001096 unsigned int bytes)
1097{
1098 spin_lock(&tcon->stat_lock);
1099 tcon->bytes_read += bytes;
1100 spin_unlock(&tcon->stat_lock);
1101}
1102#else
1103
Steve Frenchd38d8c72007-06-28 19:44:13 +00001104#define cifs_stats_inc(field) do {} while (0)
1105#define cifs_stats_bytes_written(tcon, bytes) do {} while (0)
1106#define cifs_stats_bytes_read(tcon, bytes) do {} while (0)
Steve Frencha4544342005-08-24 13:59:35 -07001107
1108#endif
1109
Jeff Layton2b84a36c2011-01-11 07:24:21 -05001110
1111/*
Jeff Layton44d22d82011-10-19 15:29:49 -04001112 * This is the prototype for the mid receive function. This function is for
1113 * receiving the rest of the SMB frame, starting with the WordCount (which is
1114 * just after the MID in struct smb_hdr). Note:
1115 *
1116 * - This will be called by cifsd, with no locks held.
1117 * - The mid will still be on the pending_mid_q.
1118 * - mid->resp_buf will point to the current buffer.
1119 *
1120 * Returns zero on a successful receive, or an error. The receive state in
1121 * the TCP_Server_Info will also be updated.
1122 */
1123typedef int (mid_receive_t)(struct TCP_Server_Info *server,
1124 struct mid_q_entry *mid);
1125
1126/*
1127 * This is the prototype for the mid callback function. This is called once the
1128 * mid has been received off of the socket. When creating one, take special
1129 * care to avoid deadlocks. Things to bear in mind:
Jeff Layton2b84a36c2011-01-11 07:24:21 -05001130 *
Jeff Layton3c1105d2011-05-22 07:09:13 -04001131 * - it will be called by cifsd, with no locks held
1132 * - the mid will be removed from any lists
Jeff Layton2b84a36c2011-01-11 07:24:21 -05001133 */
1134typedef void (mid_callback_t)(struct mid_q_entry *mid);
1135
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136/* one of these for every pending CIFS request to the server */
1137struct mid_q_entry {
1138 struct list_head qhead; /* mids waiting on reply from this server */
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +04001139 struct TCP_Server_Info *server; /* server corresponding to this mid */
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001140 __u64 mid; /* multiplex id */
1141 __u32 pid; /* process id */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142 __u32 sequence_number; /* for CIFS signing */
Steve French1047abc2005-10-11 19:58:06 -07001143 unsigned long when_alloc; /* when mid was created */
1144#ifdef CONFIG_CIFS_STATS2
1145 unsigned long when_sent; /* time when smb send finished */
1146 unsigned long when_received; /* when demux complete (taken off wire) */
1147#endif
Jeff Layton44d22d82011-10-19 15:29:49 -04001148 mid_receive_t *receive; /* call receive callback */
Jeff Layton2b84a36c2011-01-11 07:24:21 -05001149 mid_callback_t *callback; /* call completion callback */
1150 void *callback_data; /* general purpose pointer for callback */
Pavel Shilovskyd4e48542012-03-23 14:28:02 -04001151 void *resp_buf; /* pointer to received SMB header */
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001152 int mid_state; /* wish this were enum but can not pass to wait_event */
1153 __le16 command; /* smb command code */
1154 bool large_buf:1; /* if valid response, is pointer to large buf */
Steve French4b18f2a2008-04-29 00:06:05 +00001155 bool multiRsp:1; /* multiple trans2 responses for one request */
1156 bool multiEnd:1; /* both received */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157};
1158
Steve French789e6662011-08-09 18:44:44 +00001159/* Make code in transport.c a little cleaner by moving
1160 update of optional stats into function below */
1161#ifdef CONFIG_CIFS_STATS2
1162
1163static inline void cifs_in_send_inc(struct TCP_Server_Info *server)
1164{
1165 atomic_inc(&server->in_send);
1166}
1167
1168static inline void cifs_in_send_dec(struct TCP_Server_Info *server)
1169{
1170 atomic_dec(&server->in_send);
1171}
1172
1173static inline void cifs_num_waiters_inc(struct TCP_Server_Info *server)
1174{
1175 atomic_inc(&server->num_waiters);
1176}
1177
1178static inline void cifs_num_waiters_dec(struct TCP_Server_Info *server)
1179{
1180 atomic_dec(&server->num_waiters);
1181}
1182
1183static inline void cifs_save_when_sent(struct mid_q_entry *mid)
1184{
1185 mid->when_sent = jiffies;
1186}
1187#else
1188static inline void cifs_in_send_inc(struct TCP_Server_Info *server)
1189{
1190}
1191static inline void cifs_in_send_dec(struct TCP_Server_Info *server)
1192{
1193}
1194
1195static inline void cifs_num_waiters_inc(struct TCP_Server_Info *server)
1196{
1197}
1198
1199static inline void cifs_num_waiters_dec(struct TCP_Server_Info *server)
1200{
1201}
1202
1203static inline void cifs_save_when_sent(struct mid_q_entry *mid)
1204{
1205}
1206#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207
Steve Frenchff5dbd92005-08-24 17:10:36 -07001208/* for pending dnotify requests */
1209struct dir_notify_req {
Steve French13cd4b72010-10-07 18:46:32 +00001210 struct list_head lhead;
1211 __le16 Pid;
1212 __le16 PidHigh;
1213 __u16 Mid;
1214 __u16 Tid;
1215 __u16 Uid;
1216 __u16 netfid;
1217 __u32 filter; /* CompletionFilter (for multishot) */
1218 int multishot;
1219 struct file *pfile;
Steve Frenchff5dbd92005-08-24 17:10:36 -07001220};
1221
Steve French366781c2008-01-25 10:12:41 +00001222struct dfs_info3_param {
1223 int flags; /* DFSREF_REFERRAL_SERVER, DFSREF_STORAGE_SERVER*/
Igor Mammedov8aad0182008-02-15 18:21:49 +00001224 int path_consumed;
Steve French366781c2008-01-25 10:12:41 +00001225 int server_type;
1226 int ref_flag;
1227 char *path_name;
1228 char *node_name;
1229};
1230
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001231/*
1232 * common struct for holding inode info when searching for or updating an
1233 * inode with new info
1234 */
1235
1236#define CIFS_FATTR_DFS_REFERRAL 0x1
Jeff Layton0b8f18e2009-07-09 01:46:37 -04001237#define CIFS_FATTR_DELETE_PENDING 0x2
1238#define CIFS_FATTR_NEED_REVAL 0x4
Jeff Layton3d694382010-05-11 14:59:55 -04001239#define CIFS_FATTR_INO_COLLISION 0x8
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001240
1241struct cifs_fattr {
1242 u32 cf_flags;
1243 u32 cf_cifsattrs;
1244 u64 cf_uniqueid;
1245 u64 cf_eof;
1246 u64 cf_bytes;
Jeff Layton20054bd2011-01-07 11:30:27 -05001247 u64 cf_createtime;
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001248 uid_t cf_uid;
1249 gid_t cf_gid;
1250 umode_t cf_mode;
1251 dev_t cf_rdev;
1252 unsigned int cf_nlink;
1253 unsigned int cf_dtype;
1254 struct timespec cf_atime;
1255 struct timespec cf_mtime;
1256 struct timespec cf_ctime;
1257};
1258
Steve French366781c2008-01-25 10:12:41 +00001259static inline void free_dfs_info_param(struct dfs_info3_param *param)
1260{
1261 if (param) {
1262 kfree(param->path_name);
1263 kfree(param->node_name);
1264 kfree(param);
1265 }
1266}
1267
1268static inline void free_dfs_info_array(struct dfs_info3_param *param,
1269 int number_of_items)
1270{
1271 int i;
1272 if ((number_of_items == 0) || (param == NULL))
1273 return;
1274 for (i = 0; i < number_of_items; i++) {
1275 kfree(param[i].path_name);
1276 kfree(param[i].node_name);
1277 }
1278 kfree(param);
1279}
1280
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281#define MID_FREE 0
1282#define MID_REQUEST_ALLOCATED 1
1283#define MID_REQUEST_SUBMITTED 2
1284#define MID_RESPONSE_RECEIVED 4
1285#define MID_RETRY_NEEDED 8 /* session closed while this request out */
Jeff Layton71823ba2011-02-10 08:03:50 -05001286#define MID_RESPONSE_MALFORMED 0x10
Jeff Layton3c1105d2011-05-22 07:09:13 -04001287#define MID_SHUTDOWN 0x20
Steve Frenchec637e32005-12-12 20:53:18 -08001288
1289/* Types of response buffer returned from SendReceive2 */
1290#define CIFS_NO_BUFFER 0 /* Response buffer not returned */
1291#define CIFS_SMALL_BUFFER 1
1292#define CIFS_LARGE_BUFFER 2
1293#define CIFS_IOVEC 4 /* array of response buffers */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294
Steve French133672e2007-11-13 22:41:37 +00001295/* Type of Request to SendReceive2 */
Jeff Layton77499812011-01-11 07:24:23 -05001296#define CIFS_BLOCKING_OP 1 /* operation can block */
1297#define CIFS_ASYNC_OP 2 /* do not wait for response */
1298#define CIFS_TIMEOUT_MASK 0x003 /* only one of above set in req */
Steve French133672e2007-11-13 22:41:37 +00001299#define CIFS_LOG_ERROR 0x010 /* log NT STATUS if non-zero */
1300#define CIFS_LARGE_BUF_OP 0x020 /* large request buffer */
1301#define CIFS_NO_RESP 0x040 /* no response buffer required */
1302
Pavel Shilovskya891f0f2012-05-23 16:14:34 +04001303/* Type of request operation */
1304#define CIFS_ECHO_OP 0x080 /* echo request */
1305#define CIFS_OBREAK_OP 0x0100 /* oplock break request */
Pavel Shilovskyec2e4522011-12-27 16:12:43 +04001306#define CIFS_NEG_OP 0x0200 /* negotiate request */
1307#define CIFS_OP_MASK 0x0380 /* mask request type */
Pavel Shilovskya891f0f2012-05-23 16:14:34 +04001308
Steve French39798772006-05-31 22:40:51 +00001309/* Security Flags: indicate type of session setup needed */
1310#define CIFSSEC_MAY_SIGN 0x00001
1311#define CIFSSEC_MAY_NTLM 0x00002
1312#define CIFSSEC_MAY_NTLMV2 0x00004
1313#define CIFSSEC_MAY_KRB5 0x00008
1314#ifdef CONFIG_CIFS_WEAK_PW_HASH
1315#define CIFSSEC_MAY_LANMAN 0x00010
1316#define CIFSSEC_MAY_PLNTXT 0x00020
Steve French516897a2007-10-12 19:24:06 +00001317#else
1318#define CIFSSEC_MAY_LANMAN 0
1319#define CIFSSEC_MAY_PLNTXT 0
Steve French39798772006-05-31 22:40:51 +00001320#endif /* weak passwords */
1321#define CIFSSEC_MAY_SEAL 0x00040 /* not supported yet */
Steve Frenchac683922009-05-06 04:16:04 +00001322#define CIFSSEC_MAY_NTLMSSP 0x00080 /* raw ntlmssp with ntlmv2 */
Steve French5815449d2006-02-14 01:36:20 +00001323
Steve French39798772006-05-31 22:40:51 +00001324#define CIFSSEC_MUST_SIGN 0x01001
1325/* note that only one of the following can be set so the
1326result of setting MUST flags more than once will be to
1327require use of the stronger protocol */
1328#define CIFSSEC_MUST_NTLM 0x02002
1329#define CIFSSEC_MUST_NTLMV2 0x04004
1330#define CIFSSEC_MUST_KRB5 0x08008
1331#ifdef CONFIG_CIFS_WEAK_PW_HASH
1332#define CIFSSEC_MUST_LANMAN 0x10010
1333#define CIFSSEC_MUST_PLNTXT 0x20020
Jeff Layton0d3a01f2007-10-16 17:32:19 +00001334#ifdef CONFIG_CIFS_UPCALL
Chuck Ebbert20d17522009-09-15 01:53:21 -04001335#define CIFSSEC_MASK 0xBF0BF /* allows weak security but also krb5 */
Steve Frenchd38d8c72007-06-28 19:44:13 +00001336#else
Chuck Ebbert20d17522009-09-15 01:53:21 -04001337#define CIFSSEC_MASK 0xB70B7 /* current flags supported if weak */
Steve French016ec752007-10-16 18:10:10 +00001338#endif /* UPCALL */
Jeff Layton0d3a01f2007-10-16 17:32:19 +00001339#else /* do not allow weak pw hash */
Steve French88a44122012-01-18 17:13:47 -06001340#define CIFSSEC_MUST_LANMAN 0
1341#define CIFSSEC_MUST_PLNTXT 0
Jeff Layton0d3a01f2007-10-16 17:32:19 +00001342#ifdef CONFIG_CIFS_UPCALL
Steve Frenchac683922009-05-06 04:16:04 +00001343#define CIFSSEC_MASK 0x8F08F /* flags supported if no weak allowed */
Jeff Layton0d3a01f2007-10-16 17:32:19 +00001344#else
Steve Frenchac683922009-05-06 04:16:04 +00001345#define CIFSSEC_MASK 0x87087 /* flags supported if no weak allowed */
Steve French016ec752007-10-16 18:10:10 +00001346#endif /* UPCALL */
Steve French39798772006-05-31 22:40:51 +00001347#endif /* WEAK_PW_HASH */
1348#define CIFSSEC_MUST_SEAL 0x40040 /* not supported yet */
Steve Frenchac683922009-05-06 04:16:04 +00001349#define CIFSSEC_MUST_NTLMSSP 0x80080 /* raw ntlmssp with ntlmv2 */
Steve French39798772006-05-31 22:40:51 +00001350
Steve French81bcd8b2012-11-25 00:07:44 -06001351#define CIFSSEC_DEF (CIFSSEC_MAY_SIGN | CIFSSEC_MAY_NTLMSSP)
Shirish Pargaonkaref571ca2008-07-24 15:56:05 +00001352#define CIFSSEC_MAX (CIFSSEC_MUST_SIGN | CIFSSEC_MUST_NTLMV2)
Steve Frenchac683922009-05-06 04:16:04 +00001353#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 -07001354/*
1355 *****************************************************************
1356 * All constants go here
1357 *****************************************************************
1358 */
1359
1360#define UID_HASH (16)
1361
1362/*
1363 * Note that ONE module should define _DECLARE_GLOBALS_HERE to cause the
1364 * following to be declared.
1365 */
1366
1367/****************************************************************************
1368 * Locking notes. All updates to global variables and lists should be
1369 * protected by spinlocks or semaphores.
1370 *
1371 * Spinlocks
1372 * ---------
1373 * GlobalMid_Lock protects:
1374 * list operations on pending_mid_q and oplockQ
1375 * updates to XID counters, multiplex id and SMB sequence numbers
Suresh Jayaraman6573e9b2010-10-18 23:52:18 +05301376 * cifs_file_list_lock protects:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377 * list operations on tcp and SMB session lists and tCon lists
1378 * f_owner.lock protects certain per file struct operations
1379 * mapping->page_lock protects certain per page operations
1380 *
1381 * Semaphores
1382 * ----------
1383 * sesSem operations on smb session
1384 * tconSem operations on tree connection
Steve Frenchd38d8c72007-06-28 19:44:13 +00001385 * fh_sem file handle reconnection operations
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 *
1387 ****************************************************************************/
1388
1389#ifdef DECLARE_GLOBALS_HERE
1390#define GLOBAL_EXTERN
1391#else
1392#define GLOBAL_EXTERN extern
1393#endif
1394
Jeff Laytone7ddee92008-11-14 13:44:38 -05001395/*
1396 * the list of TCP_Server_Info structures, ie each of the sockets
Steve Frenchfb396012008-11-13 20:04:07 +00001397 * connecting our client to a distinct server (ip address), is
Jeff Laytone7ddee92008-11-14 13:44:38 -05001398 * chained together by cifs_tcp_ses_list. The list of all our SMB
Steve Frenchfb396012008-11-13 20:04:07 +00001399 * sessions (and from that the tree connections) can be found
Jeff Laytone7ddee92008-11-14 13:44:38 -05001400 * by iterating over cifs_tcp_ses_list
1401 */
1402GLOBAL_EXTERN struct list_head cifs_tcp_ses_list;
1403
Jeff Laytonf1987b42008-11-15 11:12:47 -05001404/*
1405 * This lock protects the cifs_tcp_ses_list, the list of smb sessions per
1406 * tcp session, and the list of tcon's per smb session. It also protects
1407 * the reference counters for the server, smb session, and tcon. Finally,
1408 * changes to the tcon->tidStatus should be done while holding this lock.
1409 */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301410GLOBAL_EXTERN spinlock_t cifs_tcp_ses_lock;
Steve Frenchddb4cbf2008-11-20 20:00:44 +00001411
1412/*
1413 * This lock protects the cifs_file->llist and cifs_file->flist
1414 * list operations, and updates to some flags (cifs_file->invalidHandle)
1415 * It will be moved to either use the tcon->stat_lock or equivalent later.
1416 * If cifs_tcp_ses_lock and the lock below are both needed to be held, then
1417 * the cifs_tcp_ses_lock must be grabbed first and released last.
1418 */
Jeff Layton44772882010-10-15 15:34:03 -04001419GLOBAL_EXTERN spinlock_t cifs_file_list_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420
Steve French0eff0e22011-02-24 05:39:23 +00001421#ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
Steve French99ee4db2007-02-27 05:35:17 +00001422/* Outstanding dir notify requests */
1423GLOBAL_EXTERN struct list_head GlobalDnotifyReqList;
1424/* DirNotify response queue */
1425GLOBAL_EXTERN struct list_head GlobalDnotifyRsp_Q;
Steve French0eff0e22011-02-24 05:39:23 +00001426#endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
Steve Frenchff5dbd92005-08-24 17:10:36 -07001427
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428/*
1429 * Global transaction id (XID) information
1430 */
1431GLOBAL_EXTERN unsigned int GlobalCurrentXid; /* protected by GlobalMid_Sem */
Steve French254e55e2006-06-04 05:53:15 +00001432GLOBAL_EXTERN unsigned int GlobalTotalActiveXid; /* prot by GlobalMid_Sem */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433GLOBAL_EXTERN unsigned int GlobalMaxActiveXid; /* prot by GlobalMid_Sem */
Steve French254e55e2006-06-04 05:53:15 +00001434GLOBAL_EXTERN spinlock_t GlobalMid_Lock; /* protects above & list operations */
1435 /* on midQ entries */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436/*
1437 * Global counters, updated atomically
1438 */
1439GLOBAL_EXTERN atomic_t sesInfoAllocCount;
1440GLOBAL_EXTERN atomic_t tconInfoAllocCount;
1441GLOBAL_EXTERN atomic_t tcpSesAllocCount;
1442GLOBAL_EXTERN atomic_t tcpSesReconnectCount;
1443GLOBAL_EXTERN atomic_t tconInfoReconnectCount;
1444
Steve Frenchaaa9bbe2008-05-23 17:38:32 +00001445/* Various Debug counters */
Steve French4498eed52005-12-03 13:58:57 -08001446GLOBAL_EXTERN atomic_t bufAllocCount; /* current number allocated */
1447#ifdef CONFIG_CIFS_STATS2
1448GLOBAL_EXTERN atomic_t totBufAllocCount; /* total allocated over all time */
1449GLOBAL_EXTERN atomic_t totSmBufAllocCount;
1450#endif
1451GLOBAL_EXTERN atomic_t smBufAllocCount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452GLOBAL_EXTERN atomic_t midCount;
1453
1454/* Misc globals */
Jeff Layton5e500ed2012-05-16 07:13:17 -04001455GLOBAL_EXTERN bool enable_oplocks; /* enable or disable oplocks */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456GLOBAL_EXTERN unsigned int lookupCacheEnabled;
Jeff Layton04912d62010-04-24 07:57:45 -04001457GLOBAL_EXTERN unsigned int global_secflags; /* if on, session setup sent
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458 with more secure ntlmssp2 challenge/resp */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459GLOBAL_EXTERN unsigned int sign_CIFS_PDUs; /* enable smb packet signing */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460GLOBAL_EXTERN unsigned int linuxExtEnabled;/*enable Linux/Unix CIFS extensions*/
1461GLOBAL_EXTERN unsigned int CIFSMaxBufSize; /* max size not including hdr */
1462GLOBAL_EXTERN unsigned int cifs_min_rcv; /* min size of big ntwrk buf pool */
1463GLOBAL_EXTERN unsigned int cifs_min_small; /* min size of small buf pool */
1464GLOBAL_EXTERN unsigned int cifs_max_pending; /* MAX requests at once to server*/
1465
Shirish Pargaonkar21fed0d2011-08-09 14:30:48 -05001466#ifdef CONFIG_CIFS_ACL
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001467GLOBAL_EXTERN struct rb_root uidtree;
1468GLOBAL_EXTERN struct rb_root gidtree;
1469GLOBAL_EXTERN spinlock_t siduidlock;
1470GLOBAL_EXTERN spinlock_t sidgidlock;
Shirish Pargaonkar21fed0d2011-08-09 14:30:48 -05001471GLOBAL_EXTERN struct rb_root siduidtree;
1472GLOBAL_EXTERN struct rb_root sidgidtree;
1473GLOBAL_EXTERN spinlock_t uidsidlock;
1474GLOBAL_EXTERN spinlock_t gidsidlock;
1475#endif /* CONFIG_CIFS_ACL */
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001476
Tejun Heo9b646972010-07-20 22:09:02 +02001477void cifs_oplock_break(struct work_struct *work);
Linus Torvalds3b7433b2010-08-07 12:42:58 -07001478
Jeff Layton3bc303c2009-09-21 06:47:50 -04001479extern const struct slow_work_ops cifs_oplock_break_ops;
Jeff Laytonda472fc2012-03-23 14:40:53 -04001480extern struct workqueue_struct *cifsiod_wq;
Suresh Jayaramanabd2e442010-06-22 20:52:50 +05301481
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +04001482extern mempool_t *cifs_mid_poolp;
1483
Jeff Layton23db65f2012-05-15 12:20:51 -04001484/* Operations for different SMB versions */
1485#define SMB1_VERSION_STRING "1.0"
1486extern struct smb_version_operations smb1_operations;
1487extern struct smb_version_values smb1_values;
Steve Frenche4aa25e2012-10-01 12:26:22 -05001488#define SMB20_VERSION_STRING "2.0"
1489/*extern struct smb_version_operations smb20_operations; */ /* not needed yet */
1490extern struct smb_version_values smb20_values;
Steve French1080ef72011-02-24 18:07:19 +00001491#define SMB21_VERSION_STRING "2.1"
1492extern struct smb_version_operations smb21_operations;
1493extern struct smb_version_values smb21_values;
Steve Frenche4aa25e2012-10-01 12:26:22 -05001494#define SMB30_VERSION_STRING "3.0"
Steve French38107d42012-12-08 22:08:06 -06001495extern struct smb_version_operations smb30_operations;
Steve Frenche4aa25e2012-10-01 12:26:22 -05001496extern struct smb_version_values smb30_values;
Suresh Jayaramanabd2e442010-06-22 20:52:50 +05301497#endif /* _CIFS_GLOB_H */