projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
CIFS: Move protocol specific demultiplex thread calls to ops struct
[deliverable/linux.git] / fs / cifs / connect.c
CommitLineData
1da177e4
LT		 1/*
2 * fs/cifs/connect.c
3 *
d185cda7 4 * Copyright (C) International Business Machines Corp., 2002,2009
1da177e4
LT		 5 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
fb8c4b14 19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
1da177e4
LT		 20 */
21#include <linux/fs.h>
22#include <linux/net.h>
23#include <linux/string.h>
24#include <linux/list.h>
25#include <linux/wait.h>
5a0e3ad6 26#include <linux/slab.h>
1da177e4
LT		 27#include <linux/pagemap.h>
28#include <linux/ctype.h>
29#include <linux/utsname.h>
30#include <linux/mempool.h>
b8643e1b 31#include <linux/delay.h>
f191401f 32#include <linux/completion.h>
aaf737ad 33#include <linux/kthread.h>
0ae0efad 34#include <linux/pagevec.h>
7dfb7103 35#include <linux/freezer.h>
5c2503a8 36#include <linux/namei.h>
1da177e4
LT		 37#include <asm/uaccess.h>
38#include <asm/processor.h>
50b64e3b 39#include <linux/inet.h>
143cb494 40#include <linux/module.h>
8a8798a5 41#include <keys/user-type.h>
0e2bedaa 42#include <net/ipv6.h>
8830d7e0
SP		 43#include <linux/parser.h>
44
1da177e4
LT		 45#include "cifspdu.h"
46#include "cifsglob.h"
47#include "cifsproto.h"
48#include "cifs_unicode.h"
49#include "cifs_debug.h"
50#include "cifs_fs_sb.h"
51#include "ntlmssp.h"
52#include "nterr.h"
53#include "rfc1002pdu.h"
488f1d2d 54#include "fscache.h"
1da177e4
LT		 55
56#define CIFS_PORT 445
57#define RFC1001_PORT 139
58
c74093b6
JL		 59/* SMB echo "timeout" -- FIXME: tunable? */
60#define SMB_ECHO_INTERVAL (60 * HZ)
61
1da177e4
LT		 62extern mempool_t *cifs_req_poolp;
63
2de970ff 64/* FIXME: should these be tunable? */
9d002df4 65#define TLINK_ERROR_EXPIRE (1 * HZ)
2de970ff 66#define TLINK_IDLE_EXPIRE (600 * HZ)
9d002df4 67
8830d7e0
SP		 68enum {
69
70 /* Mount options that take no arguments */
71 Opt_user_xattr, Opt_nouser_xattr,
72 Opt_forceuid, Opt_noforceuid,
73 Opt_noblocksend, Opt_noautotune,
74 Opt_hard, Opt_soft, Opt_perm, Opt_noperm,
75 Opt_mapchars, Opt_nomapchars, Opt_sfu,
76 Opt_nosfu, Opt_nodfs, Opt_posixpaths,
77 Opt_noposixpaths, Opt_nounix,
78 Opt_nocase,
79 Opt_brl, Opt_nobrl,
80 Opt_forcemandatorylock, Opt_setuids,
81 Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
82 Opt_nohard, Opt_nosoft,
83 Opt_nointr, Opt_intr,
84 Opt_nostrictsync, Opt_strictsync,
85 Opt_serverino, Opt_noserverino,
86 Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
87 Opt_acl, Opt_noacl, Opt_locallease,
88 Opt_sign, Opt_seal, Opt_direct,
89 Opt_strictcache, Opt_noac,
90 Opt_fsc, Opt_mfsymlinks,
d8162558 91 Opt_multiuser, Opt_sloppy,
8830d7e0
SP		 92
93 /* Mount options which take numeric value */
94 Opt_backupuid, Opt_backupgid, Opt_uid,
95 Opt_cruid, Opt_gid, Opt_file_mode,
96 Opt_dirmode, Opt_port,
97 Opt_rsize, Opt_wsize, Opt_actimeo,
98
99 /* Mount options which take string value */
100 Opt_user, Opt_pass, Opt_ip,
101 Opt_unc, Opt_domain,
102 Opt_srcaddr, Opt_prefixpath,
103 Opt_iocharset, Opt_sockopt,
104 Opt_netbiosname, Opt_servern,
23db65f5 105 Opt_ver, Opt_vers, Opt_sec, Opt_cache,
8830d7e0
SP		 106
107 /* Mount options to be ignored */
108 Opt_ignore,
109
110 /* Options which could be blank */
111 Opt_blank_pass,
4fe9e963
SP		 112 Opt_blank_user,
113 Opt_blank_ip,
8830d7e0
SP		 114
115 Opt_err
116};
117
118static const match_table_t cifs_mount_option_tokens = {
119
120 { Opt_user_xattr, "user_xattr" },
121 { Opt_nouser_xattr, "nouser_xattr" },
122 { Opt_forceuid, "forceuid" },
123 { Opt_noforceuid, "noforceuid" },
124 { Opt_noblocksend, "noblocksend" },
125 { Opt_noautotune, "noautotune" },
126 { Opt_hard, "hard" },
127 { Opt_soft, "soft" },
128 { Opt_perm, "perm" },
129 { Opt_noperm, "noperm" },
130 { Opt_mapchars, "mapchars" },
131 { Opt_nomapchars, "nomapchars" },
132 { Opt_sfu, "sfu" },
133 { Opt_nosfu, "nosfu" },
134 { Opt_nodfs, "nodfs" },
135 { Opt_posixpaths, "posixpaths" },
136 { Opt_noposixpaths, "noposixpaths" },
137 { Opt_nounix, "nounix" },
138 { Opt_nounix, "nolinux" },
139 { Opt_nocase, "nocase" },
140 { Opt_nocase, "ignorecase" },
141 { Opt_brl, "brl" },
142 { Opt_nobrl, "nobrl" },
143 { Opt_nobrl, "nolock" },
144 { Opt_forcemandatorylock, "forcemandatorylock" },
5cfdddcf 145 { Opt_forcemandatorylock, "forcemand" },
8830d7e0
SP		 146 { Opt_setuids, "setuids" },
147 { Opt_nosetuids, "nosetuids" },
148 { Opt_dynperm, "dynperm" },
149 { Opt_nodynperm, "nodynperm" },
150 { Opt_nohard, "nohard" },
151 { Opt_nosoft, "nosoft" },
152 { Opt_nointr, "nointr" },
153 { Opt_intr, "intr" },
154 { Opt_nostrictsync, "nostrictsync" },
155 { Opt_strictsync, "strictsync" },
156 { Opt_serverino, "serverino" },
157 { Opt_noserverino, "noserverino" },
158 { Opt_rwpidforward, "rwpidforward" },
159 { Opt_cifsacl, "cifsacl" },
160 { Opt_nocifsacl, "nocifsacl" },
161 { Opt_acl, "acl" },
162 { Opt_noacl, "noacl" },
163 { Opt_locallease, "locallease" },
164 { Opt_sign, "sign" },
165 { Opt_seal, "seal" },
166 { Opt_direct, "direct" },
531c8ff0
JL		 167 { Opt_direct, "directio" },
168 { Opt_direct, "forcedirectio" },
8830d7e0
SP		 169 { Opt_strictcache, "strictcache" },
170 { Opt_noac, "noac" },
171 { Opt_fsc, "fsc" },
172 { Opt_mfsymlinks, "mfsymlinks" },
173 { Opt_multiuser, "multiuser" },
d8162558 174 { Opt_sloppy, "sloppy" },
8830d7e0
SP		 175
176 { Opt_backupuid, "backupuid=%s" },
177 { Opt_backupgid, "backupgid=%s" },
178 { Opt_uid, "uid=%s" },
179 { Opt_cruid, "cruid=%s" },
180 { Opt_gid, "gid=%s" },
181 { Opt_file_mode, "file_mode=%s" },
182 { Opt_dirmode, "dirmode=%s" },
183 { Opt_dirmode, "dir_mode=%s" },
184 { Opt_port, "port=%s" },
185 { Opt_rsize, "rsize=%s" },
186 { Opt_wsize, "wsize=%s" },
187 { Opt_actimeo, "actimeo=%s" },
188
4fe9e963
SP		 189 { Opt_blank_user, "user=" },
190 { Opt_blank_user, "username=" },
8830d7e0
SP		 191 { Opt_user, "user=%s" },
192 { Opt_user, "username=%s" },
193 { Opt_blank_pass, "pass=" },
194 { Opt_pass, "pass=%s" },
195 { Opt_pass, "password=%s" },
4fe9e963
SP		 196 { Opt_blank_ip, "ip=" },
197 { Opt_blank_ip, "addr=" },
8830d7e0
SP		 198 { Opt_ip, "ip=%s" },
199 { Opt_ip, "addr=%s" },
200 { Opt_unc, "unc=%s" },
201 { Opt_unc, "target=%s" },
202 { Opt_unc, "path=%s" },
203 { Opt_domain, "dom=%s" },
204 { Opt_domain, "domain=%s" },
205 { Opt_domain, "workgroup=%s" },
206 { Opt_srcaddr, "srcaddr=%s" },
207 { Opt_prefixpath, "prefixpath=%s" },
208 { Opt_iocharset, "iocharset=%s" },
209 { Opt_sockopt, "sockopt=%s" },
210 { Opt_netbiosname, "netbiosname=%s" },
211 { Opt_servern, "servern=%s" },
212 { Opt_ver, "ver=%s" },
23db65f5 213 { Opt_vers, "vers=%s" },
8830d7e0 214 { Opt_sec, "sec=%s" },
15b6a473 215 { Opt_cache, "cache=%s" },
8830d7e0
SP		 216
217 { Opt_ignore, "cred" },
218 { Opt_ignore, "credentials" },
a557b976
JL		 219 { Opt_ignore, "cred=%s" },
220 { Opt_ignore, "credentials=%s" },
8830d7e0
SP		 221 { Opt_ignore, "guest" },
222 { Opt_ignore, "rw" },
223 { Opt_ignore, "ro" },
224 { Opt_ignore, "suid" },
225 { Opt_ignore, "nosuid" },
226 { Opt_ignore, "exec" },
227 { Opt_ignore, "noexec" },
228 { Opt_ignore, "nodev" },
229 { Opt_ignore, "noauto" },
230 { Opt_ignore, "dev" },
231 { Opt_ignore, "mand" },
232 { Opt_ignore, "nomand" },
233 { Opt_ignore, "_netdev" },
234
235 { Opt_err, NULL }
236};
237
238enum {
239 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
240 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
241 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2i,
242 Opt_sec_nontlm, Opt_sec_lanman,
243 Opt_sec_none,
244
245 Opt_sec_err
246};
247
248static const match_table_t cifs_secflavor_tokens = {
249 { Opt_sec_krb5, "krb5" },
250 { Opt_sec_krb5i, "krb5i" },
251 { Opt_sec_krb5p, "krb5p" },
252 { Opt_sec_ntlmsspi, "ntlmsspi" },
253 { Opt_sec_ntlmssp, "ntlmssp" },
254 { Opt_ntlm, "ntlm" },
255 { Opt_sec_ntlmi, "ntlmi" },
256 { Opt_sec_ntlmv2i, "ntlmv2i" },
257 { Opt_sec_nontlm, "nontlm" },
258 { Opt_sec_lanman, "lanman" },
259 { Opt_sec_none, "none" },
260
261 { Opt_sec_err, NULL }
262};
263
15b6a473
JL		 264/* cache flavors */
265enum {
266 Opt_cache_loose,
267 Opt_cache_strict,
268 Opt_cache_none,
269 Opt_cache_err
270};
271
272static const match_table_t cifs_cacheflavor_tokens = {
273 { Opt_cache_loose, "loose" },
274 { Opt_cache_strict, "strict" },
275 { Opt_cache_none, "none" },
276 { Opt_cache_err, NULL }
277};
278
23db65f5
JL		 279static const match_table_t cifs_smb_version_tokens = {
280 { Smb_1, SMB1_VERSION_STRING },
281};
282
a9f1b85e
PS		 283static int ip_connect(struct TCP_Server_Info *server);
284static int generic_ip_connect(struct TCP_Server_Info *server);
b647c35f 285static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
2de970ff 286static void cifs_prune_tlinks(struct work_struct *work);
b9bce2e9
JL		 287static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
288 const char *devname);
1da177e4 289
d5c5605c
JL		 290/*
291 * cifs tcp session reconnection
292 *
293 * mark tcp session as reconnecting so temporarily locked
294 * mark all smb sessions as reconnecting for tcp session
295 * reconnect tcp session
296 * wake up waiters on reconnection? - (not needed currently)
297 */
2cd646a2 298static int
1da177e4
LT		 299cifs_reconnect(struct TCP_Server_Info *server)
300{
301 int rc = 0;
f1987b44 302 struct list_head *tmp, *tmp2;
96daf2b0
SF		 303 struct cifs_ses *ses;
304 struct cifs_tcon *tcon;
fb8c4b14 305 struct mid_q_entry *mid_entry;
3c1105df 306 struct list_head retry_list;
50c2f753 307
1da177e4 308 spin_lock(&GlobalMid_Lock);
469ee614 309 if (server->tcpStatus == CifsExiting) {
fb8c4b14 310 /* the demux thread will exit normally
1da177e4
LT		 311 next time through the loop */
312 spin_unlock(&GlobalMid_Lock);
313 return rc;
314 } else
315 server->tcpStatus = CifsNeedReconnect;
316 spin_unlock(&GlobalMid_Lock);
317 server->maxBuf = 0;
318
b6b38f70 319 cFYI(1, "Reconnecting tcp session");
1da177e4
LT		 320
321 /* before reconnecting the tcp session, mark the smb session (uid)
322 and the tid bad so they are not used until reconnected */
2b84a36c 323 cFYI(1, "%s: marking sessions and tcons for reconnect", __func__);
3f9bcca7 324 spin_lock(&cifs_tcp_ses_lock);
14fbf50d 325 list_for_each(tmp, &server->smb_ses_list) {
96daf2b0 326 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
14fbf50d
JL		 327 ses->need_reconnect = true;
328 ses->ipc_tid = 0;
f1987b44 329 list_for_each(tmp2, &ses->tcon_list) {
96daf2b0 330 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
3b795210 331 tcon->need_reconnect = true;
1da177e4 332 }
1da177e4 333 }
3f9bcca7 334 spin_unlock(&cifs_tcp_ses_lock);
2b84a36c 335
1da177e4 336 /* do not want to be sending data on a socket we are freeing */
2b84a36c 337 cFYI(1, "%s: tearing down socket", __func__);
72ca545b 338 mutex_lock(&server->srv_mutex);
fb8c4b14 339 if (server->ssocket) {
b6b38f70
JP		 340 cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
341 server->ssocket->flags);
91cf45f0 342 kernel_sock_shutdown(server->ssocket, SHUT_WR);
b6b38f70 343 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
467a8f8d 344 server->ssocket->state,
b6b38f70 345 server->ssocket->flags);
1da177e4
LT		 346 sock_release(server->ssocket);
347 server->ssocket = NULL;
348 }
5d0d2882
SP		 349 server->sequence_number = 0;
350 server->session_estab = false;
21e73393
SP		 351 kfree(server->session_key.response);
352 server->session_key.response = NULL;
353 server->session_key.len = 0;
fda35943 354 server->lstrp = jiffies;
2b84a36c 355 mutex_unlock(&server->srv_mutex);
1da177e4 356
2b84a36c 357 /* mark submitted MIDs for retry and issue callback */
3c1105df
JL		 358 INIT_LIST_HEAD(&retry_list);
359 cFYI(1, "%s: moving mids to private list", __func__);
1da177e4 360 spin_lock(&GlobalMid_Lock);
2b84a36c
JL		 361 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
362 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
7c9421e1
PS		 363 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
364 mid_entry->mid_state = MID_RETRY_NEEDED;
3c1105df
JL		 365 list_move(&mid_entry->qhead, &retry_list);
366 }
367 spin_unlock(&GlobalMid_Lock);
368
369 cFYI(1, "%s: issuing mid callbacks", __func__);
370 list_for_each_safe(tmp, tmp2, &retry_list) {
371 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
2b84a36c
JL		 372 list_del_init(&mid_entry->qhead);
373 mid_entry->callback(mid_entry);
1da177e4 374 }
1da177e4 375
7fdbaa1b 376 do {
6c3d8909 377 try_to_freeze();
a9f1b85e
PS		 378
379 /* we should try only the port we connected to before */
380 rc = generic_ip_connect(server);
fb8c4b14 381 if (rc) {
b6b38f70 382 cFYI(1, "reconnect error %d", rc);
0cb766ae 383 msleep(3000);
1da177e4
LT		 384 } else {
385 atomic_inc(&tcpSesReconnectCount);
386 spin_lock(&GlobalMid_Lock);
469ee614 387 if (server->tcpStatus != CifsExiting)
fd88ce93 388 server->tcpStatus = CifsNeedNegotiate;
fb8c4b14 389 spin_unlock(&GlobalMid_Lock);
1da177e4 390 }
7fdbaa1b 391 } while (server->tcpStatus == CifsNeedReconnect);
2b84a36c 392
1da177e4
LT		 393 return rc;
394}
395
fb8c4b14 396/*
e4eb295d
SF		 397 return codes:
398 0 not a transact2, or all data present
399 >0 transact2 with that much data missing
400 -EINVAL = invalid transact2
401
402 */
d4e4854f 403static int check2ndT2(char *buf)
e4eb295d 404{
d4e4854f 405 struct smb_hdr *pSMB = (struct smb_hdr *)buf;
fb8c4b14 406 struct smb_t2_rsp *pSMBt;
e4eb295d 407 int remaining;
26ec2548 408 __u16 total_data_size, data_in_this_rsp;
e4eb295d 409
fb8c4b14 410 if (pSMB->Command != SMB_COM_TRANSACTION2)
e4eb295d
SF		 411 return 0;
412
fb8c4b14
SF		 413 /* check for plausible wct, bcc and t2 data and parm sizes */
414 /* check for parm and data offset going beyond end of smb */
415 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
b6b38f70 416 cFYI(1, "invalid transact2 word count");
e4eb295d
SF		 417 return -EINVAL;
418 }
419
420 pSMBt = (struct smb_t2_rsp *)pSMB;
421
26ec2548
JL		 422 total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
423 data_in_this_rsp = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
e4eb295d 424
c0c7b905 425 if (total_data_size == data_in_this_rsp)
e4eb295d 426 return 0;
c0c7b905 427 else if (total_data_size < data_in_this_rsp) {
b6b38f70
JP		 428 cFYI(1, "total data %d smaller than data in frame %d",
429 total_data_size, data_in_this_rsp);
e4eb295d 430 return -EINVAL;
e4eb295d 431 }
c0c7b905
JL		 432
433 remaining = total_data_size - data_in_this_rsp;
434
435 cFYI(1, "missing %d bytes from transact2, check next response",
436 remaining);
c974befa 437 if (total_data_size > CIFSMaxBufSize) {
c0c7b905 438 cERROR(1, "TotalDataSize %d is over maximum buffer %d",
c974befa 439 total_data_size, CIFSMaxBufSize);
c0c7b905
JL		 440 return -EINVAL;
441 }
442 return remaining;
e4eb295d
SF		 443}
444
d4e4854f 445static int coalesce_t2(char *second_buf, struct smb_hdr *target_hdr)
e4eb295d 446{
d4e4854f
PS		 447 struct smb_t2_rsp *pSMBs = (struct smb_t2_rsp *)second_buf;
448 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)target_hdr;
f5fffcee
JL		 449 char *data_area_of_tgt;
450 char *data_area_of_src;
26ec2548 451 int remaining;
f5fffcee
JL		 452 unsigned int byte_count, total_in_tgt;
453 __u16 tgt_total_cnt, src_total_cnt, total_in_src;
e4eb295d 454
f5fffcee
JL		 455 src_total_cnt = get_unaligned_le16(&pSMBs->t2_rsp.TotalDataCount);
456 tgt_total_cnt = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
e4eb295d 457
f5fffcee
JL		 458 if (tgt_total_cnt != src_total_cnt)
459 cFYI(1, "total data count of primary and secondary t2 differ "
460 "source=%hu target=%hu", src_total_cnt, tgt_total_cnt);
e4eb295d 461
f5fffcee 462 total_in_tgt = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
e4eb295d 463
f5fffcee 464 remaining = tgt_total_cnt - total_in_tgt;
50c2f753 465
f5fffcee
JL		 466 if (remaining < 0) {
467 cFYI(1, "Server sent too much data. tgt_total_cnt=%hu "
468 "total_in_tgt=%hu", tgt_total_cnt, total_in_tgt);
2a2047bc 469 return -EPROTO;
f5fffcee 470 }
e4eb295d 471
f5fffcee
JL		 472 if (remaining == 0) {
473 /* nothing to do, ignore */
474 cFYI(1, "no more data remains");
e4eb295d 475 return 0;
f5fffcee 476 }
50c2f753 477
f5fffcee
JL		 478 total_in_src = get_unaligned_le16(&pSMBs->t2_rsp.DataCount);
479 if (remaining < total_in_src)
b6b38f70 480 cFYI(1, "transact2 2nd response contains too much data");
e4eb295d
SF		 481
482 /* find end of first SMB data area */
f5fffcee 483 data_area_of_tgt = (char *)&pSMBt->hdr.Protocol +
26ec2548 484 get_unaligned_le16(&pSMBt->t2_rsp.DataOffset);
e4eb295d 485
f5fffcee
JL		 486 /* validate target area */
487 data_area_of_src = (char *)&pSMBs->hdr.Protocol +
488 get_unaligned_le16(&pSMBs->t2_rsp.DataOffset);
e4eb295d 489
f5fffcee 490 data_area_of_tgt += total_in_tgt;
e4eb295d 491
f5fffcee 492 total_in_tgt += total_in_src;
2a2047bc 493 /* is the result too big for the field? */
f5fffcee
JL		 494 if (total_in_tgt > USHRT_MAX) {
495 cFYI(1, "coalesced DataCount too large (%u)", total_in_tgt);
2a2047bc 496 return -EPROTO;
f5fffcee
JL		 497 }
498 put_unaligned_le16(total_in_tgt, &pSMBt->t2_rsp.DataCount);
2a2047bc
JL		 499
500 /* fix up the BCC */
d4e4854f 501 byte_count = get_bcc(target_hdr);
f5fffcee 502 byte_count += total_in_src;
2a2047bc 503 /* is the result too big for the field? */
f5fffcee
JL		 504 if (byte_count > USHRT_MAX) {
505 cFYI(1, "coalesced BCC too large (%u)", byte_count);
2a2047bc 506 return -EPROTO;
f5fffcee 507 }
d4e4854f 508 put_bcc(byte_count, target_hdr);
e4eb295d 509
d4e4854f 510 byte_count = be32_to_cpu(target_hdr->smb_buf_length);
f5fffcee 511 byte_count += total_in_src;
2a2047bc 512 /* don't allow buffer to overflow */
f5fffcee
JL		 513 if (byte_count > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
514 cFYI(1, "coalesced BCC exceeds buffer size (%u)", byte_count);
2a2047bc 515 return -ENOBUFS;
f5fffcee 516 }
d4e4854f 517 target_hdr->smb_buf_length = cpu_to_be32(byte_count);
e4eb295d 518
f5fffcee
JL		 519 /* copy second buffer into end of first buffer */
520 memcpy(data_area_of_tgt, data_area_of_src, total_in_src);
2a2047bc 521
f5fffcee
JL		 522 if (remaining != total_in_src) {
523 /* more responses to go */
524 cFYI(1, "waiting for more secondary responses");
e4eb295d 525 return 1;
f5fffcee
JL		 526 }
527
528 /* we are done */
529 cFYI(1, "found the last secondary response");
530 return 0;
e4eb295d
SF		 531}
532
c74093b6
JL		 533static void
534cifs_echo_request(struct work_struct *work)
535{
536 int rc;
537 struct TCP_Server_Info *server = container_of(work,
538 struct TCP_Server_Info, echo.work);
539
247ec9b4 540 /*
195291e6
JL		 541 * We cannot send an echo until the NEGOTIATE_PROTOCOL request is
542 * done, which is indicated by maxBuf != 0. Also, no need to ping if
543 * we got a response recently
247ec9b4 544 */
195291e6 545 if (server->maxBuf == 0 ||
247ec9b4 546 time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
c74093b6
JL		 547 goto requeue_echo;
548
549 rc = CIFSSMBEcho(server);
550 if (rc)
551 cFYI(1, "Unable to send echo request to server: %s",
552 server->hostname);
553
554requeue_echo:
da472fc8 555 queue_delayed_work(cifsiod_wq, &server->echo, SMB_ECHO_INTERVAL);
c74093b6
JL		 556}
557
3d9c2472 558static bool
2a37ef94 559allocate_buffers(struct TCP_Server_Info *server)
3d9c2472 560{
2a37ef94
JL		 561 if (!server->bigbuf) {
562 server->bigbuf = (char *)cifs_buf_get();
563 if (!server->bigbuf) {
3d9c2472
PS		 564 cERROR(1, "No memory for large SMB response");
565 msleep(3000);
566 /* retry will check if exiting */
567 return false;
568 }
2a37ef94 569 } else if (server->large_buf) {
3d9c2472 570 /* we are reusing a dirty large buf, clear its start */
1887f601 571 memset(server->bigbuf, 0, HEADER_SIZE(server));
3d9c2472
PS		 572 }
573
2a37ef94
JL		 574 if (!server->smallbuf) {
575 server->smallbuf = (char *)cifs_small_buf_get();
576 if (!server->smallbuf) {
3d9c2472
PS		 577 cERROR(1, "No memory for SMB response");
578 msleep(1000);
579 /* retry will check if exiting */
580 return false;
581 }
582 /* beginning of smb buffer is cleared in our buf_get */
583 } else {
584 /* if existing small buf clear beginning */
1887f601 585 memset(server->smallbuf, 0, HEADER_SIZE(server));
3d9c2472
PS		 586 }
587
3d9c2472
PS		 588 return true;
589}
590
ba749e6d
JL		 591static bool
592server_unresponsive(struct TCP_Server_Info *server)
593{
6dae51a5
PS		 594 /*
595 * We need to wait 2 echo intervals to make sure we handle such
596 * situations right:
597 * 1s client sends a normal SMB request
598 * 2s client gets a response
599 * 30s echo workqueue job pops, and decides we got a response recently
600 * and don't need to send another
601 * ...
602 * 65s kernel_recvmsg times out, and we see that we haven't gotten
603 * a response in >60s.
604 */
605 if (server->tcpStatus == CifsGood &&
606 time_after(jiffies, server->lstrp + 2 * SMB_ECHO_INTERVAL)) {
ba749e6d
JL		 607 cERROR(1, "Server %s has not responded in %d seconds. "
608 "Reconnecting...", server->hostname,
6dae51a5 609 (2 * SMB_ECHO_INTERVAL) / HZ);
ba749e6d
JL		 610 cifs_reconnect(server);
611 wake_up(&server->response_q);
612 return true;
613 }
614
615 return false;
616}
617
42c4dfc2
JL		 618/*
619 * kvec_array_init - clone a kvec array, and advance into it
620 * @new: pointer to memory for cloned array
621 * @iov: pointer to original array
622 * @nr_segs: number of members in original array
623 * @bytes: number of bytes to advance into the cloned array
624 *
625 * This function will copy the array provided in iov to a section of memory
626 * and advance the specified number of bytes into the new array. It returns
627 * the number of segments in the new array. "new" must be at least as big as
628 * the original iov array.
629 */
630static unsigned int
631kvec_array_init(struct kvec *new, struct kvec *iov, unsigned int nr_segs,
632 size_t bytes)
633{
634 size_t base = 0;
635
636 while (bytes || !iov->iov_len) {
637 int copy = min(bytes, iov->iov_len);
638
639 bytes -= copy;
640 base += copy;
641 if (iov->iov_len == base) {
642 iov++;
643 nr_segs--;
644 base = 0;
645 }
646 }
647 memcpy(new, iov, sizeof(*iov) * nr_segs);
648 new->iov_base += base;
649 new->iov_len -= base;
650 return nr_segs;
651}
652
1041e3f9
JL		 653static struct kvec *
654get_server_iovec(struct TCP_Server_Info *server, unsigned int nr_segs)
e7015fb1 655{
1041e3f9
JL		 656 struct kvec *new_iov;
657
658 if (server->iov && nr_segs <= server->nr_iov)
659 return server->iov;
660
661 /* not big enough -- allocate a new one and release the old */
662 new_iov = kmalloc(sizeof(*new_iov) * nr_segs, GFP_NOFS);
663 if (new_iov) {
664 kfree(server->iov);
665 server->iov = new_iov;
666 server->nr_iov = nr_segs;
667 }
668 return new_iov;
669}
670
e28bc5b1
JL		 671int
672cifs_readv_from_socket(struct TCP_Server_Info *server, struct kvec *iov_orig,
673 unsigned int nr_segs, unsigned int to_read)
e7015fb1 674{
a52c1eb7
JL		 675 int length = 0;
676 int total_read;
42c4dfc2 677 unsigned int segs;
e831e6cf 678 struct msghdr smb_msg;
42c4dfc2
JL		 679 struct kvec *iov;
680
1041e3f9 681 iov = get_server_iovec(server, nr_segs);
42c4dfc2
JL		 682 if (!iov)
683 return -ENOMEM;
e7015fb1 684
e831e6cf
JL		 685 smb_msg.msg_control = NULL;
686 smb_msg.msg_controllen = 0;
687
a52c1eb7 688 for (total_read = 0; to_read; total_read += length, to_read -= length) {
95edcff4
JL		 689 try_to_freeze();
690
ba749e6d 691 if (server_unresponsive(server)) {
a52c1eb7 692 total_read = -EAGAIN;
ba749e6d
JL		 693 break;
694 }
695
42c4dfc2
JL		 696 segs = kvec_array_init(iov, iov_orig, nr_segs, total_read);
697
698 length = kernel_recvmsg(server->ssocket, &smb_msg,
699 iov, segs, to_read, 0);
e7015fb1 700
e7015fb1 701 if (server->tcpStatus == CifsExiting) {
a52c1eb7 702 total_read = -ESHUTDOWN;
e7015fb1
PS		 703 break;
704 } else if (server->tcpStatus == CifsNeedReconnect) {
705 cifs_reconnect(server);
a52c1eb7 706 total_read = -EAGAIN;
e7015fb1
PS		 707 break;
708 } else if (length == -ERESTARTSYS ||
709 length == -EAGAIN ||
710 length == -EINTR) {
711 /*
712 * Minimum sleep to prevent looping, allowing socket
713 * to clear and app threads to set tcpStatus
714 * CifsNeedReconnect if server hung.
715 */
716 usleep_range(1000, 2000);
717 length = 0;
a52c1eb7 718 continue;
e7015fb1 719 } else if (length <= 0) {
a52c1eb7
JL		 720 cFYI(1, "Received no data or error: expecting %d "
721 "got %d", to_read, length);
e7015fb1 722 cifs_reconnect(server);
a52c1eb7 723 total_read = -EAGAIN;
e7015fb1
PS		 724 break;
725 }
726 }
a52c1eb7 727 return total_read;
e7015fb1 728}
e7015fb1 729
e28bc5b1
JL		 730int
731cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
732 unsigned int to_read)
42c4dfc2
JL		 733{
734 struct kvec iov;
735
736 iov.iov_base = buf;
737 iov.iov_len = to_read;
738
e28bc5b1 739 return cifs_readv_from_socket(server, &iov, 1, to_read);
e7015fb1
PS		 740}
741
98bac62c 742static bool
fe11e4cc 743is_smb_response(struct TCP_Server_Info *server, unsigned char type)
98bac62c 744{
98bac62c
PS		 745 /*
746 * The first byte big endian of the length field,
747 * is actually not part of the length but the type
748 * with the most common, zero, as regular data.
749 */
fe11e4cc
JL		 750 switch (type) {
751 case RFC1002_SESSION_MESSAGE:
752 /* Regular SMB response */
753 return true;
754 case RFC1002_SESSION_KEEP_ALIVE:
755 cFYI(1, "RFC 1002 session keep alive");
756 break;
757 case RFC1002_POSITIVE_SESSION_RESPONSE:
758 cFYI(1, "RFC 1002 positive session response");
759 break;
760 case RFC1002_NEGATIVE_SESSION_RESPONSE:
98bac62c
PS		 761 /*
762 * We get this from Windows 98 instead of an error on
763 * SMB negprot response.
764 */
fe11e4cc 765 cFYI(1, "RFC 1002 negative session response");
98bac62c
PS		 766 /* give server a second to clean up */
767 msleep(1000);
768 /*
769 * Always try 445 first on reconnect since we get NACK
770 * on some if we ever connected to port 139 (the NACK
771 * is since we do not begin with RFC1001 session
772 * initialize frame).
773 */
fe11e4cc 774 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
98bac62c
PS		 775 cifs_reconnect(server);
776 wake_up(&server->response_q);
fe11e4cc
JL		 777 break;
778 default:
779 cERROR(1, "RFC 1002 unknown response type 0x%x", type);
98bac62c 780 cifs_reconnect(server);
98bac62c
PS		 781 }
782
fe11e4cc 783 return false;
98bac62c
PS		 784}
785
e28bc5b1
JL		 786void
787dequeue_mid(struct mid_q_entry *mid, bool malformed)
ea1f4502 788{
ad69bae1 789#ifdef CONFIG_CIFS_STATS2
ea1f4502 790 mid->when_received = jiffies;
ad69bae1 791#endif
ea1f4502
JL		 792 spin_lock(&GlobalMid_Lock);
793 if (!malformed)
7c9421e1 794 mid->mid_state = MID_RESPONSE_RECEIVED;
ea1f4502 795 else
7c9421e1 796 mid->mid_state = MID_RESPONSE_MALFORMED;
ea1f4502 797 list_del_init(&mid->qhead);
ad69bae1 798 spin_unlock(&GlobalMid_Lock);
ea1f4502 799}
ad69bae1 800
c8054ebd
JL		 801static void
802handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
d4e4854f 803 char *buf, int malformed)
ea1f4502 804{
ffc00e27
JL		 805 if (malformed == 0 && check2ndT2(buf) > 0) {
806 mid->multiRsp = true;
ea1f4502
JL		 807 if (mid->resp_buf) {
808 /* merge response - fix up 1st*/
ffc00e27
JL		 809 malformed = coalesce_t2(buf, mid->resp_buf);
810 if (malformed > 0)
c8054ebd 811 return;
ffc00e27 812
ea1f4502
JL		 813 /* All parts received or packet is malformed. */
814 mid->multiEnd = true;
c8054ebd 815 return dequeue_mid(mid, malformed);
ea1f4502 816 }
2a37ef94 817 if (!server->large_buf) {
ea1f4502
JL		 818 /*FIXME: switch to already allocated largebuf?*/
819 cERROR(1, "1st trans2 resp needs bigbuf");
820 } else {
821 /* Have first buffer */
822 mid->resp_buf = buf;
7c9421e1 823 mid->large_buf = true;
2a37ef94 824 server->bigbuf = NULL;
ea1f4502 825 }
c8054ebd 826 return;
ea1f4502
JL		 827 }
828 mid->resp_buf = buf;
7c9421e1 829 mid->large_buf = server->large_buf;
2a37ef94
JL		 830 /* Was previous buf put in mpx struct for multi-rsp? */
831 if (!mid->multiRsp) {
832 /* smb buffer will be freed by user thread */
833 if (server->large_buf)
834 server->bigbuf = NULL;
835 else
836 server->smallbuf = NULL;
837 }
ffc00e27 838 dequeue_mid(mid, malformed);
ad69bae1
PS		 839}
840
762dfd10
PS		 841static void clean_demultiplex_info(struct TCP_Server_Info *server)
842{
843 int length;
844
845 /* take it off the list, if it's not already */
846 spin_lock(&cifs_tcp_ses_lock);
847 list_del_init(&server->tcp_ses_list);
848 spin_unlock(&cifs_tcp_ses_lock);
849
850 spin_lock(&GlobalMid_Lock);
851 server->tcpStatus = CifsExiting;
852 spin_unlock(&GlobalMid_Lock);
853 wake_up_all(&server->response_q);
854
2d86dbc9 855 /* check if we have blocked requests that need to free */
fc40f9cf 856 spin_lock(&server->req_lock);
2d86dbc9
PS		 857 if (server->credits <= 0)
858 server->credits = 1;
fc40f9cf 859 spin_unlock(&server->req_lock);
762dfd10
PS		 860 /*
861 * Although there should not be any requests blocked on this queue it
862 * can not hurt to be paranoid and try to wake up requests that may
863 * haven been blocked when more than 50 at time were on the wire to the
864 * same server - they now will see the session is in exit state and get
865 * out of SendReceive.
866 */
867 wake_up_all(&server->request_q);
868 /* give those requests time to exit */
869 msleep(125);
870
871 if (server->ssocket) {
872 sock_release(server->ssocket);
873 server->ssocket = NULL;
874 }
875
876 if (!list_empty(&server->pending_mid_q)) {
877 struct list_head dispose_list;
878 struct mid_q_entry *mid_entry;
879 struct list_head *tmp, *tmp2;
880
881 INIT_LIST_HEAD(&dispose_list);
882 spin_lock(&GlobalMid_Lock);
883 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
884 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
7c9421e1
PS		 885 cFYI(1, "Clearing mid 0x%llx", mid_entry->mid);
886 mid_entry->mid_state = MID_SHUTDOWN;
762dfd10
PS		 887 list_move(&mid_entry->qhead, &dispose_list);
888 }
889 spin_unlock(&GlobalMid_Lock);
890
891 /* now walk dispose list and issue callbacks */
892 list_for_each_safe(tmp, tmp2, &dispose_list) {
893 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
7c9421e1 894 cFYI(1, "Callback mid 0x%llx", mid_entry->mid);
762dfd10
PS		 895 list_del_init(&mid_entry->qhead);
896 mid_entry->callback(mid_entry);
897 }
898 /* 1/8th of sec is more than enough time for them to exit */
899 msleep(125);
900 }
901
902 if (!list_empty(&server->pending_mid_q)) {
903 /*
904 * mpx threads have not exited yet give them at least the smb
905 * send timeout time for long ops.
906 *
907 * Due to delays on oplock break requests, we need to wait at
908 * least 45 seconds before giving up on a request getting a
909 * response and going ahead and killing cifsd.
910 */
911 cFYI(1, "Wait for exit from demultiplex thread");
912 msleep(46000);
913 /*
914 * If threads still have not exited they are probably never
915 * coming home not much else we can do but free the memory.
916 */
917 }
918
919 kfree(server->hostname);
1041e3f9 920 kfree(server->iov);
762dfd10
PS		 921 kfree(server);
922
923 length = atomic_dec_return(&tcpSesAllocCount);
924 if (length > 0)
925 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
926 GFP_KERNEL);
927}
928
e9097ab4
JL		 929static int
930standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
931{
932 int length;
933 char *buf = server->smallbuf;
d4e4854f 934 unsigned int pdu_length = get_rfc1002_length(buf);
e9097ab4
JL		 935
936 /* make sure this will fit in a large buffer */
1887f601 937 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) - 4) {
e9097ab4
JL		 938 cERROR(1, "SMB response too long (%u bytes)",
939 pdu_length);
940 cifs_reconnect(server);
941 wake_up(&server->response_q);
942 return -EAGAIN;
943 }
944
945 /* switch to large buffer if too big for a small one */
946 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
947 server->large_buf = true;
d4e4854f 948 memcpy(server->bigbuf, buf, server->total_read);
e9097ab4 949 buf = server->bigbuf;
e9097ab4
JL		 950 }
951
952 /* now read the rest */
1887f601
PS		 953 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
954 pdu_length - HEADER_SIZE(server) + 1 + 4);
e9097ab4
JL		 955 if (length < 0)
956 return length;
957 server->total_read += length;
958
d4e4854f 959 dump_smb(buf, server->total_read);
e9097ab4
JL		 960
961 /*
962 * We know that we received enough to get to the MID as we
963 * checked the pdu_length earlier. Now check to see
964 * if the rest of the header is OK. We borrow the length
965 * var for the rest of the loop to avoid a new stack var.
966 *
967 * 48 bytes is enough to display the header and a little bit
968 * into the payload for debugging purposes.
969 */
8aa26f3e 970 length = server->ops->check_message(buf, server->total_read);
e9097ab4
JL		 971 if (length != 0)
972 cifs_dump_mem("Bad SMB: ", buf,
973 min_t(unsigned int, server->total_read, 48));
974
ff4fa4a2
JL		 975 if (!mid)
976 return length;
e9097ab4 977
d4e4854f 978 handle_mid(mid, server, buf, length);
ff4fa4a2 979 return 0;
e9097ab4
JL		 980}
981
1da177e4 982static int
7c97c200 983cifs_demultiplex_thread(void *p)
1da177e4
LT		 984{
985 int length;
7c97c200 986 struct TCP_Server_Info *server = p;
2a37ef94
JL		 987 unsigned int pdu_length;
988 char *buf = NULL;
1da177e4
LT		 989 struct task_struct *task_to_wake = NULL;
990 struct mid_q_entry *mid_entry;
1da177e4 991
1da177e4 992 current->flags |= PF_MEMALLOC;
b6b38f70 993 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
93d0ec85
JL		 994
995 length = atomic_inc_return(&tcpSesAllocCount);
996 if (length > 1)
26f57364
SF		 997 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
998 GFP_KERNEL);
1da177e4 999
83144186 1000 set_freezable();
469ee614 1001 while (server->tcpStatus != CifsExiting) {
ede1327e
SF		 1002 if (try_to_freeze())
1003 continue;
b8643e1b 1004
2a37ef94 1005 if (!allocate_buffers(server))
3d9c2472 1006 continue;
b8643e1b 1007
2a37ef94 1008 server->large_buf = false;
2a37ef94 1009 buf = server->smallbuf;
f01d5e14 1010 pdu_length = 4; /* enough to get RFC1001 header */
fda35943 1011
e28bc5b1 1012 length = cifs_read_from_socket(server, buf, pdu_length);
a52c1eb7 1013 if (length < 0)
1da177e4 1014 continue;
2a37ef94 1015 server->total_read = length;
1da177e4 1016
98bac62c
PS		 1017 /*
1018 * The right amount was read from socket - 4 bytes,
1019 * so we can now interpret the length field.
1020 */
d4e4854f 1021 pdu_length = get_rfc1002_length(buf);
70ca734a 1022
fe11e4cc
JL		 1023 cFYI(1, "RFC1002 header 0x%x", pdu_length);
1024 if (!is_smb_response(server, buf[0]))
fb8c4b14 1025 continue;
e4eb295d 1026
89482a56 1027 /* make sure we have enough to get to the MID */
1887f601 1028 if (pdu_length < HEADER_SIZE(server) - 1 - 4) {
89482a56
JL		 1029 cERROR(1, "SMB response too short (%u bytes)",
1030 pdu_length);
1031 cifs_reconnect(server);
1032 wake_up(&server->response_q);
1033 continue;
e4eb295d 1034 }
e7015fb1 1035
89482a56 1036 /* read down to the MID */
e28bc5b1 1037 length = cifs_read_from_socket(server, buf + 4,
1887f601 1038 HEADER_SIZE(server) - 1 - 4);
89482a56 1039 if (length < 0)
e4eb295d 1040 continue;
2a37ef94 1041 server->total_read += length;
1da177e4 1042
8aa26f3e 1043 mid_entry = server->ops->find_mid(server, buf);
50c2f753 1044
44d22d84
JL		 1045 if (!mid_entry || !mid_entry->receive)
1046 length = standard_receive3(server, mid_entry);
1047 else
1048 length = mid_entry->receive(server, mid_entry);
71823baf 1049
e9097ab4 1050 if (length < 0)
fe11e4cc 1051 continue;
1da177e4 1052
d4e4854f 1053 if (server->large_buf)
2a37ef94 1054 buf = server->bigbuf;
fda35943 1055
fda35943 1056 server->lstrp = jiffies;
2b84a36c 1057 if (mid_entry != NULL) {
2a37ef94
JL		 1058 if (!mid_entry->multiRsp || mid_entry->multiEnd)
1059 mid_entry->callback(mid_entry);
8aa26f3e 1060 } else if (!server->ops->is_oplock_break(buf, server)) {
b6b38f70 1061 cERROR(1, "No task to wake, unknown frame received! "
8097531a 1062 "NumMids %d", atomic_read(&midCount));
1887f601
PS		 1063 cifs_dump_mem("Received Data is: ", buf,
1064 HEADER_SIZE(server));
3979877e 1065#ifdef CONFIG_CIFS_DEBUG2
8aa26f3e 1066 server->ops->dump_detail(buf);
3979877e
SF		 1067 cifs_dump_mids(server);
1068#endif /* CIFS_DEBUG2 */
50c2f753 1069
e4eb295d
SF		 1070 }
1071 } /* end while !EXITING */
1072
fd62cb7e 1073 /* buffer usually freed in free_mid - need to free it here on exit */
2a37ef94
JL		 1074 cifs_buf_release(server->bigbuf);
1075 if (server->smallbuf) /* no sense logging a debug message if NULL */
1076 cifs_small_buf_release(server->smallbuf);
1da177e4 1077
b1c8d2b4 1078 task_to_wake = xchg(&server->tsk, NULL);
762dfd10 1079 clean_demultiplex_info(server);
50c2f753 1080
b1c8d2b4
JL		 1081 /* if server->tsk was NULL then wait for a signal before exiting */
1082 if (!task_to_wake) {
1083 set_current_state(TASK_INTERRUPTIBLE);
1084 while (!signal_pending(current)) {
1085 schedule();
1086 set_current_state(TASK_INTERRUPTIBLE);
1087 }
1088 set_current_state(TASK_RUNNING);
1089 }
1090
0468a2cf 1091 module_put_and_exit(0);
1da177e4
LT		 1092}
1093
c359cf3c
JL		 1094/* extract the host portion of the UNC string */
1095static char *
1096extract_hostname(const char *unc)
1097{
1098 const char *src;
1099 char *dst, *delim;
1100 unsigned int len;
1101
1102 /* skip double chars at beginning of string */
1103 /* BB: check validity of these bytes? */
1104 src = unc + 2;
1105
1106 /* delimiter between hostname and sharename is always '\\' now */
1107 delim = strchr(src, '\\');
1108 if (!delim)
1109 return ERR_PTR(-EINVAL);
1110
1111 len = delim - src;
1112 dst = kmalloc((len + 1), GFP_KERNEL);
1113 if (dst == NULL)
1114 return ERR_PTR(-ENOMEM);
1115
1116 memcpy(dst, src, len);
1117 dst[len] = '\0';
1118
1119 return dst;
1120}
1121
8830d7e0
SP		 1122static int get_option_ul(substring_t args[], unsigned long *option)
1123{
1124 int rc;
1125 char *string;
1126
1127 string = match_strdup(args);
1128 if (string == NULL)
1129 return -ENOMEM;
bfa890a3 1130 rc = kstrtoul(string, 0, option);
8830d7e0
SP		 1131 kfree(string);
1132
1133 return rc;
1134}
1135
1136
1137static int cifs_parse_security_flavors(char *value,
1138 struct smb_vol *vol)
1139{
1140
1141 substring_t args[MAX_OPT_ARGS];
1142
1143 switch (match_token(value, cifs_secflavor_tokens, args)) {
1144 case Opt_sec_krb5:
1145 vol->secFlg |= CIFSSEC_MAY_KRB5;
1146 break;
1147 case Opt_sec_krb5i:
1148 vol->secFlg |= CIFSSEC_MAY_KRB5 | CIFSSEC_MUST_SIGN;
1149 break;
1150 case Opt_sec_krb5p:
1151 /* vol->secFlg |= CIFSSEC_MUST_SEAL | CIFSSEC_MAY_KRB5; */
1152 cERROR(1, "Krb5 cifs privacy not supported");
1153 break;
1154 case Opt_sec_ntlmssp:
1155 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
1156 break;
1157 case Opt_sec_ntlmsspi:
1158 vol->secFlg |= CIFSSEC_MAY_NTLMSSP | CIFSSEC_MUST_SIGN;
1159 break;
1160 case Opt_ntlm:
1161 /* ntlm is default so can be turned off too */
1162 vol->secFlg |= CIFSSEC_MAY_NTLM;
1163 break;
1164 case Opt_sec_ntlmi:
1165 vol->secFlg |= CIFSSEC_MAY_NTLM | CIFSSEC_MUST_SIGN;
1166 break;
1167 case Opt_sec_nontlm:
1168 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1169 break;
1170 case Opt_sec_ntlmv2i:
1171 vol->secFlg |= CIFSSEC_MAY_NTLMV2 | CIFSSEC_MUST_SIGN;
1172 break;
1173#ifdef CONFIG_CIFS_WEAK_PW_HASH
1174 case Opt_sec_lanman:
1175 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1176 break;
1177#endif
1178 case Opt_sec_none:
1179 vol->nullauth = 1;
1180 break;
1181 default:
1182 cERROR(1, "bad security option: %s", value);
1183 return 1;
1184 }
1185
1186 return 0;
1187}
1188
15b6a473
JL		 1189static int
1190cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1191{
1192 substring_t args[MAX_OPT_ARGS];
1193
1194 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1195 case Opt_cache_loose:
1196 vol->direct_io = false;
1197 vol->strict_io = false;
1198 break;
1199 case Opt_cache_strict:
1200 vol->direct_io = false;
1201 vol->strict_io = true;
1202 break;
1203 case Opt_cache_none:
1204 vol->direct_io = true;
1205 vol->strict_io = false;
1206 break;
1207 default:
1208 cERROR(1, "bad cache= option: %s", value);
1209 return 1;
1210 }
1211 return 0;
1212}
1213
23db65f5
JL		 1214static int
1215cifs_parse_smb_version(char *value, struct smb_vol *vol)
1216{
1217 substring_t args[MAX_OPT_ARGS];
1218
1219 switch (match_token(value, cifs_smb_version_tokens, args)) {
1220 case Smb_1:
1221 vol->ops = &smb1_operations;
1222 vol->vals = &smb1_values;
1223 break;
1224 default:
1225 cERROR(1, "Unknown vers= option specified: %s", value);
1226 return 1;
1227 }
1228 return 0;
1229}
1230
1da177e4 1231static int
b946845a 1232cifs_parse_mount_options(const char *mountdata, const char *devname,
50c2f753 1233 struct smb_vol *vol)
1da177e4 1234{
8830d7e0 1235 char *data, *end;
957df453 1236 char *mountdata_copy = NULL, *options;
1da177e4
LT		 1237 unsigned int temp_len, i, j;
1238 char separator[2];
9b9d6b24
JL		 1239 short int override_uid = -1;
1240 short int override_gid = -1;
1241 bool uid_specified = false;
1242 bool gid_specified = false;
d8162558
JL		 1243 bool sloppy = false;
1244 char *invalid = NULL;
88463999 1245 char *nodename = utsname()->nodename;
8830d7e0
SP		 1246 char *string = NULL;
1247 char *tmp_end, *value;
1248 char delim;
296838b1
JL		 1249 bool cache_specified = false;
1250 static bool cache_warned = false;
1da177e4
LT		 1251
1252 separator[0] = ',';
50c2f753 1253 separator[1] = 0;
8830d7e0 1254 delim = separator[0];
1da177e4 1255
88463999
JL		 1256 /*
1257 * does not have to be perfect mapping since field is
1258 * informational, only used for servers that do not support
1259 * port 445 and it can be overridden at mount time
1260 */
1397f2ee
JL		 1261 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1262 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
88463999
JL		 1263 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1264
1397f2ee 1265 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
a10faeb2
SF		 1266 /* null target name indicates to use *SMBSERVR default called name
1267 if we end up sending RFC1001 session initialize */
1268 vol->target_rfc1001_name[0] = 0;
3e4b3e1f
JL		 1269 vol->cred_uid = current_uid();
1270 vol->linux_uid = current_uid();
a001e5b5 1271 vol->linux_gid = current_gid();
f55ed1a8
JL		 1272
1273 /* default to only allowing write access to owner of the mount */
1274 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1da177e4
LT		 1275
1276 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
ac67055e
JA		 1277 /* default is always to request posix paths. */
1278 vol->posix_paths = 1;
a0c9217f
JL		 1279 /* default to using server inode numbers where available */
1280 vol->server_ino = 1;
ac67055e 1281
6d20e840
SJ		 1282 vol->actimeo = CIFS_DEF_ACTIMEO;
1283
23db65f5
JL		 1284 /* FIXME: add autonegotiation -- for now, SMB1 is default */
1285 vol->ops = &smb1_operations;
1286 vol->vals = &smb1_values;
1287
b946845a
SF		 1288 if (!mountdata)
1289 goto cifs_parse_mount_err;
1290
1291 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1292 if (!mountdata_copy)
1293 goto cifs_parse_mount_err;
1da177e4 1294
b946845a 1295 options = mountdata_copy;
4906e50b 1296 end = options + strlen(options);
8830d7e0 1297
50c2f753 1298 if (strncmp(options, "sep=", 4) == 0) {
fb8c4b14 1299 if (options[4] != 0) {
1da177e4
LT		 1300 separator[0] = options[4];
1301 options += 5;
1302 } else {
b6b38f70 1303 cFYI(1, "Null separator not allowed");
1da177e4
LT		 1304 }
1305 }
3d3ea8e6
SP		 1306 vol->backupuid_specified = false; /* no backup intent for a user */
1307 vol->backupgid_specified = false; /* no backup intent for a group */
50c2f753 1308
1da177e4 1309 while ((data = strsep(&options, separator)) != NULL) {
8830d7e0
SP		 1310 substring_t args[MAX_OPT_ARGS];
1311 unsigned long option;
1312 int token;
1313
1da177e4
LT		 1314 if (!*data)
1315 continue;
1da177e4 1316
8830d7e0
SP		 1317 token = match_token(data, cifs_mount_option_tokens, args);
1318
1319 switch (token) {
1320
1321 /* Ingnore the following */
1322 case Opt_ignore:
1323 break;
1324
1325 /* Boolean values */
1326 case Opt_user_xattr:
1da177e4 1327 vol->no_xattr = 0;
8830d7e0
SP		 1328 break;
1329 case Opt_nouser_xattr:
1da177e4 1330 vol->no_xattr = 1;
8830d7e0
SP		 1331 break;
1332 case Opt_forceuid:
9b9d6b24 1333 override_uid = 1;
8830d7e0
SP		 1334 break;
1335 case Opt_noforceuid:
9b9d6b24 1336 override_uid = 0;
8830d7e0
SP		 1337 break;
1338 case Opt_noblocksend:
edf1ae40 1339 vol->noblocksnd = 1;
8830d7e0
SP		 1340 break;
1341 case Opt_noautotune:
edf1ae40 1342 vol->noautotune = 1;
8830d7e0
SP		 1343 break;
1344 case Opt_hard:
1da177e4 1345 vol->retry = 1;
8830d7e0
SP		 1346 break;
1347 case Opt_soft:
1da177e4 1348 vol->retry = 0;
8830d7e0
SP		 1349 break;
1350 case Opt_perm:
1da177e4 1351 vol->noperm = 0;
8830d7e0
SP		 1352 break;
1353 case Opt_noperm:
1da177e4 1354 vol->noperm = 1;
8830d7e0
SP		 1355 break;
1356 case Opt_mapchars:
6a0b4824 1357 vol->remap = 1;
8830d7e0
SP		 1358 break;
1359 case Opt_nomapchars:
6a0b4824 1360 vol->remap = 0;
8830d7e0
SP		 1361 break;
1362 case Opt_sfu:
50c2f753 1363 vol->sfu_emul = 1;
8830d7e0
SP		 1364 break;
1365 case Opt_nosfu:
50c2f753 1366 vol->sfu_emul = 0;
8830d7e0
SP		 1367 break;
1368 case Opt_nodfs:
2c1b8615 1369 vol->nodfs = 1;
8830d7e0
SP		 1370 break;
1371 case Opt_posixpaths:
ac67055e 1372 vol->posix_paths = 1;
8830d7e0
SP		 1373 break;
1374 case Opt_noposixpaths:
ac67055e 1375 vol->posix_paths = 0;
8830d7e0
SP		 1376 break;
1377 case Opt_nounix:
c18c842b 1378 vol->no_linux_ext = 1;
8830d7e0
SP		 1379 break;
1380 case Opt_nocase:
50c2f753 1381 vol->nocase = 1;
8830d7e0
SP		 1382 break;
1383 case Opt_brl:
c46fa8ac 1384 vol->nobrl = 0;
8830d7e0
SP		 1385 break;
1386 case Opt_nobrl:
c46fa8ac 1387 vol->nobrl = 1;
5cfdddcf
PS		 1388 /*
1389 * turn off mandatory locking in mode
8830d7e0 1390 * if remote locking is turned off since the
5cfdddcf
PS		 1391 * local vfs will do advisory
1392 */
50c2f753
SF		 1393 if (vol->file_mode ==
1394 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
d3485d37 1395 vol->file_mode = S_IALLUGO;
8830d7e0
SP		 1396 break;
1397 case Opt_forcemandatorylock:
13a6e42a 1398 vol->mand_lock = 1;
8830d7e0
SP		 1399 break;
1400 case Opt_setuids:
1da177e4 1401 vol->setuids = 1;
8830d7e0
SP		 1402 break;
1403 case Opt_nosetuids:
1da177e4 1404 vol->setuids = 0;
8830d7e0
SP		 1405 break;
1406 case Opt_dynperm:
d0a9c078 1407 vol->dynperm = true;
8830d7e0
SP		 1408 break;
1409 case Opt_nodynperm:
d0a9c078 1410 vol->dynperm = false;
8830d7e0
SP		 1411 break;
1412 case Opt_nohard:
1da177e4 1413 vol->retry = 0;
8830d7e0
SP		 1414 break;
1415 case Opt_nosoft:
1da177e4 1416 vol->retry = 1;
8830d7e0
SP		 1417 break;
1418 case Opt_nointr:
1da177e4 1419 vol->intr = 0;
8830d7e0
SP		 1420 break;
1421 case Opt_intr:
1da177e4 1422 vol->intr = 1;
8830d7e0
SP		 1423 break;
1424 case Opt_nostrictsync:
be652445 1425 vol->nostrictsync = 1;
8830d7e0
SP		 1426 break;
1427 case Opt_strictsync:
be652445 1428 vol->nostrictsync = 0;
8830d7e0
SP		 1429 break;
1430 case Opt_serverino:
1da177e4 1431 vol->server_ino = 1;
8830d7e0
SP		 1432 break;
1433 case Opt_noserverino:
1da177e4 1434 vol->server_ino = 0;
8830d7e0
SP		 1435 break;
1436 case Opt_rwpidforward:
d4ffff1f 1437 vol->rwpidforward = 1;
8830d7e0
SP		 1438 break;
1439 case Opt_cifsacl:
0a4b92c0 1440 vol->cifs_acl = 1;
8830d7e0
SP		 1441 break;
1442 case Opt_nocifsacl:
0a4b92c0 1443 vol->cifs_acl = 0;
8830d7e0
SP		 1444 break;
1445 case Opt_acl:
1da177e4 1446 vol->no_psx_acl = 0;
8830d7e0
SP		 1447 break;
1448 case Opt_noacl:
1da177e4 1449 vol->no_psx_acl = 1;
8830d7e0
SP		 1450 break;
1451 case Opt_locallease:
84210e91 1452 vol->local_lease = 1;
8830d7e0
SP		 1453 break;
1454 case Opt_sign:
750d1151 1455 vol->secFlg |= CIFSSEC_MUST_SIGN;
8830d7e0
SP		 1456 break;
1457 case Opt_seal:
95b1cb90 1458 /* we do not do the following in secFlags because seal
8830d7e0
SP		 1459 * is a per tree connection (mount) not a per socket
1460 * or per-smb connection option in the protocol
1461 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1462 */
95b1cb90 1463 vol->seal = 1;
8830d7e0
SP		 1464 break;
1465 case Opt_direct:
296838b1 1466 cache_specified = true;
15b6a473
JL		 1467 vol->direct_io = true;
1468 vol->strict_io = false;
09983b2f
JL		 1469 cERROR(1, "The \"directio\" option will be removed in "
1470 "3.7. Please switch to the \"cache=none\" "
1471 "option.");
8830d7e0
SP		 1472 break;
1473 case Opt_strictcache:
296838b1 1474 cache_specified = true;
15b6a473
JL		 1475 vol->direct_io = false;
1476 vol->strict_io = true;
09983b2f
JL		 1477 cERROR(1, "The \"strictcache\" option will be removed "
1478 "in 3.7. Please switch to the \"cache=strict\" "
1479 "option.");
8830d7e0
SP		 1480 break;
1481 case Opt_noac:
50c2f753
SF		 1482 printk(KERN_WARNING "CIFS: Mount option noac not "
1483 "supported. Instead set "
1484 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
8830d7e0
SP		 1485 break;
1486 case Opt_fsc:
607a569d 1487#ifndef CONFIG_CIFS_FSCACHE
83fb086e 1488 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE "
607a569d 1489 "kernel config option set");
b946845a 1490 goto cifs_parse_mount_err;
607a569d 1491#endif
fa1df75d 1492 vol->fsc = true;
8830d7e0
SP		 1493 break;
1494 case Opt_mfsymlinks:
736a3320 1495 vol->mfsymlinks = true;
8830d7e0
SP		 1496 break;
1497 case Opt_multiuser:
0eb8a132 1498 vol->multiuser = true;
8830d7e0 1499 break;
d8162558
JL		 1500 case Opt_sloppy:
1501 sloppy = true;
1502 break;
8830d7e0
SP		 1503
1504 /* Numeric Values */
1505 case Opt_backupuid:
1506 if (get_option_ul(args, &option)) {
3d3ea8e6
SP		 1507 cERROR(1, "%s: Invalid backupuid value",
1508 __func__);
1509 goto cifs_parse_mount_err;
1510 }
8830d7e0 1511 vol->backupuid = option;
3d3ea8e6 1512 vol->backupuid_specified = true;
8830d7e0
SP		 1513 break;
1514 case Opt_backupgid:
1515 if (get_option_ul(args, &option)) {
3d3ea8e6
SP		 1516 cERROR(1, "%s: Invalid backupgid value",
1517 __func__);
1518 goto cifs_parse_mount_err;
1519 }
8830d7e0 1520 vol->backupgid = option;
3d3ea8e6 1521 vol->backupgid_specified = true;
8830d7e0
SP		 1522 break;
1523 case Opt_uid:
1524 if (get_option_ul(args, &option)) {
1525 cERROR(1, "%s: Invalid uid value",
1526 __func__);
1527 goto cifs_parse_mount_err;
1528 }
1529 vol->linux_uid = option;
1530 uid_specified = true;
1531 break;
1532 case Opt_cruid:
1533 if (get_option_ul(args, &option)) {
1534 cERROR(1, "%s: Invalid cruid value",
1535 __func__);
1536 goto cifs_parse_mount_err;
1537 }
1538 vol->cred_uid = option;
1539 break;
1540 case Opt_gid:
1541 if (get_option_ul(args, &option)) {
1542 cERROR(1, "%s: Invalid gid value",
1543 __func__);
1544 goto cifs_parse_mount_err;
1545 }
1546 vol->linux_gid = option;
1547 gid_specified = true;
1548 break;
1549 case Opt_file_mode:
1550 if (get_option_ul(args, &option)) {
1551 cERROR(1, "%s: Invalid file_mode value",
1552 __func__);
1553 goto cifs_parse_mount_err;
1554 }
1555 vol->file_mode = option;
1556 break;
1557 case Opt_dirmode:
1558 if (get_option_ul(args, &option)) {
1559 cERROR(1, "%s: Invalid dir_mode value",
1560 __func__);
1561 goto cifs_parse_mount_err;
1562 }
1563 vol->dir_mode = option;
1564 break;
1565 case Opt_port:
1566 if (get_option_ul(args, &option)) {
1567 cERROR(1, "%s: Invalid port value",
1568 __func__);
1569 goto cifs_parse_mount_err;
1570 }
1571 vol->port = option;
1572 break;
1573 case Opt_rsize:
1574 if (get_option_ul(args, &option)) {
1575 cERROR(1, "%s: Invalid rsize value",
1576 __func__);
b946845a 1577 goto cifs_parse_mount_err;
8830d7e0
SP		 1578 }
1579 vol->rsize = option;
1580 break;
1581 case Opt_wsize:
1582 if (get_option_ul(args, &option)) {
1583 cERROR(1, "%s: Invalid wsize value",
1584 __func__);
1585 goto cifs_parse_mount_err;
1586 }
1587 vol->wsize = option;
1588 break;
1589 case Opt_actimeo:
1590 if (get_option_ul(args, &option)) {
1591 cERROR(1, "%s: Invalid actimeo value",
1592 __func__);
1593 goto cifs_parse_mount_err;
1594 }
1595 vol->actimeo = HZ * option;
1596 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1597 cERROR(1, "CIFS: attribute cache"
1598 "timeout too large");
1599 goto cifs_parse_mount_err;
1600 }
1601 break;
1602
1603 /* String Arguments */
1604
4fe9e963
SP		 1605 case Opt_blank_user:
1606 /* null user, ie. anonymous authentication */
1607 vol->nullauth = 1;
1608 vol->username = NULL;
1609 break;
8830d7e0
SP		 1610 case Opt_user:
1611 string = match_strdup(args);
1612 if (string == NULL)
1613 goto out_nomem;
1614
4fe9e963 1615 if (strnlen(string, MAX_USERNAME_SIZE) >
8830d7e0
SP		 1616 MAX_USERNAME_SIZE) {
1617 printk(KERN_WARNING "CIFS: username too long\n");
1618 goto cifs_parse_mount_err;
1619 }
1620 vol->username = kstrdup(string, GFP_KERNEL);
1621 if (!vol->username) {
1622 printk(KERN_WARNING "CIFS: no memory "
1623 "for username\n");
1624 goto cifs_parse_mount_err;
1625 }
1626 break;
1627 case Opt_blank_pass:
1628 vol->password = NULL;
1629 break;
1630 case Opt_pass:
1631 /* passwords have to be handled differently
1632 * to allow the character used for deliminator
1633 * to be passed within them
1634 */
1635
1636 /* Obtain the value string */
1637 value = strchr(data, '=');
10238074 1638 value++;
8830d7e0
SP		 1639
1640 /* Set tmp_end to end of the string */
1641 tmp_end = (char *) value + strlen(value);
1642
1643 /* Check if following character is the deliminator
1644 * If yes, we have encountered a double deliminator
1645 * reset the NULL character to the deliminator
1646 */
1647 if (tmp_end < end && tmp_end[1] == delim)
1648 tmp_end[0] = delim;
1649
1650 /* Keep iterating until we get to a single deliminator
1651 * OR the end
1652 */
1653 while ((tmp_end = strchr(tmp_end, delim)) != NULL &&
1654 (tmp_end[1] == delim)) {
1655 tmp_end = (char *) &tmp_end[2];
1656 }
1657
1658 /* Reset var options to point to next element */
1659 if (tmp_end) {
1660 tmp_end[0] = '\0';
1661 options = (char *) &tmp_end[1];
1662 } else
1663 /* Reached the end of the mount option string */
1664 options = end;
1665
1666 /* Now build new password string */
1667 temp_len = strlen(value);
1668 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1669 if (vol->password == NULL) {
1670 printk(KERN_WARNING "CIFS: no memory "
1671 "for password\n");
1672 goto cifs_parse_mount_err;
1673 }
1674
1675 for (i = 0, j = 0; i < temp_len; i++, j++) {
1676 vol->password[j] = value[i];
1677 if ((value[i] == delim) &&
1678 value[i+1] == delim)
1679 /* skip the second deliminator */
1680 i++;
1681 }
1682 vol->password[j] = '\0';
1683 break;
4fe9e963
SP		 1684 case Opt_blank_ip:
1685 vol->UNCip = NULL;
1686 break;
8830d7e0
SP		 1687 case Opt_ip:
1688 string = match_strdup(args);
1689 if (string == NULL)
1690 goto out_nomem;
1691
4fe9e963 1692 if (strnlen(string, INET6_ADDRSTRLEN) >
8830d7e0
SP		 1693 INET6_ADDRSTRLEN) {
1694 printk(KERN_WARNING "CIFS: ip address "
1695 "too long\n");
1696 goto cifs_parse_mount_err;
1697 }
1698 vol->UNCip = kstrdup(string, GFP_KERNEL);
1699 if (!vol->UNCip) {
1700 printk(KERN_WARNING "CIFS: no memory "
1701 "for UNC IP\n");
1702 goto cifs_parse_mount_err;
1703 }
1704 break;
1705 case Opt_unc:
1706 string = match_strdup(args);
1707 if (string == NULL)
1708 goto out_nomem;
1709
8830d7e0
SP		 1710 temp_len = strnlen(string, 300);
1711 if (temp_len == 300) {
1712 printk(KERN_WARNING "CIFS: UNC name too long\n");
1713 goto cifs_parse_mount_err;
1714 }
1715
e4b41fb9
SP		 1716 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1717 if (vol->UNC == NULL) {
1718 printk(KERN_WARNING "CIFS: no memory for UNC\n");
1719 goto cifs_parse_mount_err;
1720 }
1721 strcpy(vol->UNC, string);
1722
8830d7e0 1723 if (strncmp(string, "//", 2) == 0) {
1da177e4
LT		 1724 vol->UNC[0] = '\\';
1725 vol->UNC[1] = '\\';
8830d7e0 1726 } else if (strncmp(string, "\\\\", 2) != 0) {
50c2f753 1727 printk(KERN_WARNING "CIFS: UNC Path does not "
8830d7e0 1728 "begin with // or \\\\\n");
b946845a 1729 goto cifs_parse_mount_err;
1da177e4 1730 }
8830d7e0 1731
8830d7e0
SP		 1732 break;
1733 case Opt_domain:
1734 string = match_strdup(args);
1735 if (string == NULL)
1736 goto out_nomem;
1737
4fe9e963 1738 if (strnlen(string, 256) == 256) {
8830d7e0
SP		 1739 printk(KERN_WARNING "CIFS: domain name too"
1740 " long\n");
1741 goto cifs_parse_mount_err;
1742 }
1743
1744 vol->domainname = kstrdup(string, GFP_KERNEL);
1745 if (!vol->domainname) {
1746 printk(KERN_WARNING "CIFS: no memory "
1747 "for domainname\n");
1748 goto cifs_parse_mount_err;
1749 }
1750 cFYI(1, "Domain name set");
1751 break;
1752 case Opt_srcaddr:
1753 string = match_strdup(args);
1754 if (string == NULL)
1755 goto out_nomem;
1756
4fe9e963 1757 if (!cifs_convert_address(
8830d7e0
SP		 1758 (struct sockaddr *)&vol->srcaddr,
1759 string, strlen(string))) {
1760 printk(KERN_WARNING "CIFS: Could not parse"
1761 " srcaddr: %s\n", string);
1762 goto cifs_parse_mount_err;
1763 }
1764 break;
1765 case Opt_prefixpath:
1766 string = match_strdup(args);
1767 if (string == NULL)
1768 goto out_nomem;
1769
8830d7e0
SP		 1770 temp_len = strnlen(string, 1024);
1771 if (string[0] != '/')
1772 temp_len++; /* missing leading slash */
1773 if (temp_len > 1024) {
1774 printk(KERN_WARNING "CIFS: prefix too long\n");
1775 goto cifs_parse_mount_err;
1776 }
1777
1778 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1779 if (vol->prepath == NULL) {
1780 printk(KERN_WARNING "CIFS: no memory "
1781 "for path prefix\n");
1782 goto cifs_parse_mount_err;
1783 }
1784
1785 if (string[0] != '/') {
1786 vol->prepath[0] = '/';
1787 strcpy(vol->prepath+1, string);
1788 } else
1789 strcpy(vol->prepath, string);
1790
1791 break;
1792 case Opt_iocharset:
1793 string = match_strdup(args);
1794 if (string == NULL)
1795 goto out_nomem;
1796
4fe9e963 1797 if (strnlen(string, 1024) >= 65) {
8830d7e0
SP		 1798 printk(KERN_WARNING "CIFS: iocharset name "
1799 "too long.\n");
1800 goto cifs_parse_mount_err;
1801 }
1802
1803 if (strnicmp(string, "default", 7) != 0) {
1804 vol->iocharset = kstrdup(string,
1805 GFP_KERNEL);
1806 if (!vol->iocharset) {
1807 printk(KERN_WARNING "CIFS: no memory"
1808 "for charset\n");
1809 goto cifs_parse_mount_err;
1810 }
1811 }
1812 /* if iocharset not set then load_nls_default
1813 * is used by caller
1814 */
1815 cFYI(1, "iocharset set to %s", string);
1816 break;
1817 case Opt_sockopt:
1818 string = match_strdup(args);
1819 if (string == NULL)
1820 goto out_nomem;
1821
8830d7e0
SP		 1822 if (strnicmp(string, "TCP_NODELAY", 11) == 0)
1823 vol->sockopt_tcp_nodelay = 1;
1824 break;
1825 case Opt_netbiosname:
1826 string = match_strdup(args);
1827 if (string == NULL)
1828 goto out_nomem;
1829
8830d7e0
SP		 1830 memset(vol->source_rfc1001_name, 0x20,
1831 RFC1001_NAME_LEN);
1832 /*
1833 * FIXME: are there cases in which a comma can
1834 * be valid in workstation netbios name (and
1835 * need special handling)?
1836 */
1837 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1838 /* don't ucase netbiosname for user */
1839 if (string[i] == 0)
1840 break;
1841 vol->source_rfc1001_name[i] = string[i];
1842 }
1843 /* The string has 16th byte zero still from
1844 * set at top of the function
1845 */
1846 if (i == RFC1001_NAME_LEN && string[i] != 0)
1847 printk(KERN_WARNING "CIFS: netbiosname"
1848 " longer than 15 truncated.\n");
1849
1850 break;
1851 case Opt_servern:
1852 /* servernetbiosname specified override *SMBSERVER */
1853 string = match_strdup(args);
1854 if (string == NULL)
1855 goto out_nomem;
1856
8830d7e0
SP		 1857 /* last byte, type, is 0x20 for servr type */
1858 memset(vol->target_rfc1001_name, 0x20,
1859 RFC1001_NAME_LEN_WITH_NULL);
1860
1861 /* BB are there cases in which a comma can be
1862 valid in this workstation netbios name
1863 (and need special handling)? */
1864
1865 /* user or mount helper must uppercase the
1866 netbios name */
1867 for (i = 0; i < 15; i++) {
1868 if (string[i] == 0)
1869 break;
1870 vol->target_rfc1001_name[i] = string[i];
1871 }
1872 /* The string has 16th byte zero still from
1873 set at top of the function */
1874 if (i == RFC1001_NAME_LEN && string[i] != 0)
1875 printk(KERN_WARNING "CIFS: server net"
1876 "biosname longer than 15 truncated.\n");
1877 break;
1878 case Opt_ver:
1879 string = match_strdup(args);
1880 if (string == NULL)
1881 goto out_nomem;
1882
5249af32 1883 if (strnicmp(string, "1", 1) == 0) {
8830d7e0
SP		 1884 /* This is the default */
1885 break;
1886 }
1887 /* For all other value, error */
1888 printk(KERN_WARNING "CIFS: Invalid version"
1889 " specified\n");
b946845a 1890 goto cifs_parse_mount_err;
23db65f5
JL		 1891 case Opt_vers:
1892 string = match_strdup(args);
1893 if (string == NULL)
1894 goto out_nomem;
1895
1896 if (cifs_parse_smb_version(string, vol) != 0)
1897 goto cifs_parse_mount_err;
1898 break;
8830d7e0
SP		 1899 case Opt_sec:
1900 string = match_strdup(args);
1901 if (string == NULL)
1902 goto out_nomem;
1903
8830d7e0
SP		 1904 if (cifs_parse_security_flavors(string, vol) != 0)
1905 goto cifs_parse_mount_err;
1906 break;
15b6a473 1907 case Opt_cache:
296838b1 1908 cache_specified = true;
15b6a473
JL		 1909 string = match_strdup(args);
1910 if (string == NULL)
1911 goto out_nomem;
1912
1913 if (cifs_parse_cache_flavor(string, vol) != 0)
1914 goto cifs_parse_mount_err;
1915 break;
8830d7e0 1916 default:
d8162558
JL		 1917 /*
1918 * An option we don't recognize. Save it off for later
1919 * if we haven't already found one
1920 */
1921 if (!invalid)
1922 invalid = data;
8830d7e0 1923 break;
1da177e4 1924 }
8830d7e0
SP		 1925 /* Free up any allocated string */
1926 kfree(string);
1927 string = NULL;
1da177e4 1928 }
0eb8a132 1929
d8162558
JL		 1930 if (!sloppy && invalid) {
1931 printk(KERN_ERR "CIFS: Unknown mount option \"%s\"\n", invalid);
1932 goto cifs_parse_mount_err;
1933 }
1934
8a8798a5
JL		 1935#ifndef CONFIG_KEYS
1936 /* Muliuser mounts require CONFIG_KEYS support */
1937 if (vol->multiuser) {
1938 cERROR(1, "Multiuser mounts require kernels with "
1939 "CONFIG_KEYS enabled.");
b946845a 1940 goto cifs_parse_mount_err;
0eb8a132 1941 }
8a8798a5 1942#endif
0eb8a132 1943
fb8c4b14 1944 if (vol->UNCip == NULL)
1da177e4
LT		 1945 vol->UNCip = &vol->UNC[2];
1946
9b9d6b24
JL		 1947 if (uid_specified)
1948 vol->override_uid = override_uid;
1949 else if (override_uid == 1)
1950 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1951 "specified with no uid= option.\n");
1952
1953 if (gid_specified)
1954 vol->override_gid = override_gid;
1955 else if (override_gid == 1)
1956 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1957 "specified with no gid= option.\n");
1958
296838b1
JL		 1959 /* FIXME: remove this block in 3.7 */
1960 if (!cache_specified && !cache_warned) {
1961 cache_warned = true;
1962 printk(KERN_NOTICE "CIFS: no cache= option specified, using "
1963 "\"cache=loose\". This default will change "
1964 "to \"cache=strict\" in 3.7.\n");
1965 }
1966
b946845a 1967 kfree(mountdata_copy);
1da177e4 1968 return 0;
b946845a 1969
8830d7e0
SP		 1970out_nomem:
1971 printk(KERN_WARNING "Could not allocate temporary buffer\n");
b946845a 1972cifs_parse_mount_err:
8830d7e0 1973 kfree(string);
b946845a
SF		 1974 kfree(mountdata_copy);
1975 return 1;
1da177e4
LT		 1976}
1977
3eb9a889
BG		 1978/** Returns true if srcaddr isn't specified and rhs isn't
1979 * specified, or if srcaddr is specified and
1980 * matches the IP address of the rhs argument.
1981 */
1982static bool
1983srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1984{
1985 switch (srcaddr->sa_family) {
1986 case AF_UNSPEC:
1987 return (rhs->sa_family == AF_UNSPEC);
1988 case AF_INET: {
1989 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1990 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1991 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1992 }
1993 case AF_INET6: {
1994 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1995 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1996 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1997 }
1998 default:
1999 WARN_ON(1);
2000 return false; /* don't expect to be here */
2001 }
2002}
2003
4b886136
PS		 2004/*
2005 * If no port is specified in addr structure, we try to match with 445 port
2006 * and if it fails - with 139 ports. It should be called only if address
2007 * families of server and addr are equal.
2008 */
2009static bool
2010match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
2011{
6da97910 2012 __be16 port, *sport;
4b886136
PS		 2013
2014 switch (addr->sa_family) {
2015 case AF_INET:
2016 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
2017 port = ((struct sockaddr_in *) addr)->sin_port;
2018 break;
2019 case AF_INET6:
2020 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
2021 port = ((struct sockaddr_in6 *) addr)->sin6_port;
2022 break;
2023 default:
2024 WARN_ON(1);
2025 return false;
2026 }
2027
2028 if (!port) {
2029 port = htons(CIFS_PORT);
2030 if (port == *sport)
2031 return true;
2032
2033 port = htons(RFC1001_PORT);
2034 }
2035
2036 return port == *sport;
2037}
3eb9a889 2038
4515148e 2039static bool
3eb9a889
BG		 2040match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
2041 struct sockaddr *srcaddr)
4515148e 2042{
4515148e 2043 switch (addr->sa_family) {
a9f1b85e
PS		 2044 case AF_INET: {
2045 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2046 struct sockaddr_in *srv_addr4 =
2047 (struct sockaddr_in *)&server->dstaddr;
2048
2049 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
4515148e 2050 return false;
4515148e 2051 break;
a9f1b85e
PS		 2052 }
2053 case AF_INET6: {
2054 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2055 struct sockaddr_in6 *srv_addr6 =
2056 (struct sockaddr_in6 *)&server->dstaddr;
2057
4515148e 2058 if (!ipv6_addr_equal(&addr6->sin6_addr,
a9f1b85e 2059 &srv_addr6->sin6_addr))
4515148e 2060 return false;
a9f1b85e 2061 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
4515148e 2062 return false;
4515148e
JL		 2063 break;
2064 }
a9f1b85e
PS		 2065 default:
2066 WARN_ON(1);
2067 return false; /* don't expect to be here */
2068 }
4515148e 2069
3eb9a889
BG		 2070 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2071 return false;
2072
4515148e
JL		 2073 return true;
2074}
2075
daf5b0b6
JL		 2076static bool
2077match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2078{
2079 unsigned int secFlags;
2080
2081 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
2082 secFlags = vol->secFlg;
2083 else
2084 secFlags = global_secflags | vol->secFlg;
2085
2086 switch (server->secType) {
2087 case LANMAN:
2088 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
2089 return false;
2090 break;
2091 case NTLMv2:
2092 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
2093 return false;
2094 break;
2095 case NTLM:
2096 if (!(secFlags & CIFSSEC_MAY_NTLM))
2097 return false;
2098 break;
2099 case Kerberos:
2100 if (!(secFlags & CIFSSEC_MAY_KRB5))
2101 return false;
2102 break;
2103 case RawNTLMSSP:
2104 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
2105 return false;
2106 break;
2107 default:
2108 /* shouldn't happen */
2109 return false;
2110 }
2111
25985edc 2112 /* now check if signing mode is acceptable */
daf5b0b6 2113 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
96daf2b0 2114 (server->sec_mode & SECMODE_SIGN_REQUIRED))
daf5b0b6
JL		 2115 return false;
2116 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
96daf2b0 2117 (server->sec_mode &
daf5b0b6
JL		 2118 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
2119 return false;
2120
2121 return true;
2122}
2123
37bb04e5
PS		 2124static int match_server(struct TCP_Server_Info *server, struct sockaddr *addr,
2125 struct smb_vol *vol)
2126{
23db65f5
JL		 2127 if ((server->vals != vol->vals) || (server->ops != vol->ops))
2128 return 0;
2129
37bb04e5
PS		 2130 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2131 return 0;
2132
2133 if (!match_address(server, addr,
2134 (struct sockaddr *)&vol->srcaddr))
2135 return 0;
2136
2137 if (!match_port(server, addr))
2138 return 0;
2139
2140 if (!match_security(server, vol))
2141 return 0;
2142
2143 return 1;
2144}
2145
e7ddee90 2146static struct TCP_Server_Info *
daf5b0b6 2147cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
1da177e4 2148{
e7ddee90 2149 struct TCP_Server_Info *server;
e7ddee90 2150
3f9bcca7 2151 spin_lock(&cifs_tcp_ses_lock);
4515148e 2152 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
37bb04e5 2153 if (!match_server(server, addr, vol))
daf5b0b6
JL		 2154 continue;
2155
e7ddee90 2156 ++server->srv_count;
3f9bcca7 2157 spin_unlock(&cifs_tcp_ses_lock);
b6b38f70 2158 cFYI(1, "Existing tcp session with server found");
e7ddee90 2159 return server;
1da177e4 2160 }
3f9bcca7 2161 spin_unlock(&cifs_tcp_ses_lock);
1da177e4
LT		 2162 return NULL;
2163}
1b20d672 2164
14fbf50d 2165static void
e7ddee90 2166cifs_put_tcp_session(struct TCP_Server_Info *server)
1da177e4 2167{
e7ddee90 2168 struct task_struct *task;
1b20d672 2169
3f9bcca7 2170 spin_lock(&cifs_tcp_ses_lock);
e7ddee90 2171 if (--server->srv_count > 0) {
3f9bcca7 2172 spin_unlock(&cifs_tcp_ses_lock);
e7ddee90 2173 return;
1da177e4 2174 }
1b20d672 2175
f1d0c998
RL		 2176 put_net(cifs_net_ns(server));
2177
e7ddee90 2178 list_del_init(&server->tcp_ses_list);
3f9bcca7 2179 spin_unlock(&cifs_tcp_ses_lock);
dea570e0 2180
c74093b6
JL		 2181 cancel_delayed_work_sync(&server->echo);
2182
e7ddee90
JL		 2183 spin_lock(&GlobalMid_Lock);
2184 server->tcpStatus = CifsExiting;
2185 spin_unlock(&GlobalMid_Lock);
dea570e0 2186
d2b91521 2187 cifs_crypto_shash_release(server);
488f1d2d
SJ		 2188 cifs_fscache_release_client_cookie(server);
2189
21e73393
SP		 2190 kfree(server->session_key.response);
2191 server->session_key.response = NULL;
2192 server->session_key.len = 0;
2193
e7ddee90
JL		 2194 task = xchg(&server->tsk, NULL);
2195 if (task)
2196 force_sig(SIGKILL, task);
1da177e4
LT		 2197}
2198
63c038c2
JL		 2199static struct TCP_Server_Info *
2200cifs_get_tcp_session(struct smb_vol *volume_info)
2201{
2202 struct TCP_Server_Info *tcp_ses = NULL;
a9ac49d3 2203 struct sockaddr_storage addr;
63c038c2
JL		 2204 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
2205 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
2206 int rc;
2207
a9ac49d3 2208 memset(&addr, 0, sizeof(struct sockaddr_storage));
63c038c2 2209
b6b38f70 2210 cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
63c038c2 2211
1e68b2b2 2212 if (volume_info->UNCip && volume_info->UNC) {
50d97160
JL		 2213 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
2214 volume_info->UNCip,
67b7626a 2215 strlen(volume_info->UNCip),
50d97160 2216 volume_info->port);
1e68b2b2 2217 if (!rc) {
63c038c2
JL		 2218 /* we failed translating address */
2219 rc = -EINVAL;
2220 goto out_err;
2221 }
63c038c2
JL		 2222 } else if (volume_info->UNCip) {
2223 /* BB using ip addr as tcp_ses name to connect to the
2224 DFS root below */
b6b38f70 2225 cERROR(1, "Connecting to DFS root not implemented yet");
63c038c2
JL		 2226 rc = -EINVAL;
2227 goto out_err;
2228 } else /* which tcp_sess DFS root would we conect to */ {
b6b38f70
JP		 2229 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
2230 "unc=//192.168.1.100/public) specified");
63c038c2
JL		 2231 rc = -EINVAL;
2232 goto out_err;
2233 }
2234
2235 /* see if we already have a matching tcp_ses */
daf5b0b6 2236 tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
63c038c2
JL		 2237 if (tcp_ses)
2238 return tcp_ses;
2239
2240 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2241 if (!tcp_ses) {
2242 rc = -ENOMEM;
2243 goto out_err;
2244 }
2245
d2b91521
SP		 2246 rc = cifs_crypto_shash_allocate(tcp_ses);
2247 if (rc) {
2248 cERROR(1, "could not setup hash structures rc %d", rc);
2249 goto out_err;
2250 }
2251
23db65f5
JL		 2252 tcp_ses->ops = volume_info->ops;
2253 tcp_ses->vals = volume_info->vals;
f1d0c998 2254 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
63c038c2
JL		 2255 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2256 if (IS_ERR(tcp_ses->hostname)) {
2257 rc = PTR_ERR(tcp_ses->hostname);
f7c5445a 2258 goto out_err_crypto_release;
63c038c2
JL		 2259 }
2260
2261 tcp_ses->noblocksnd = volume_info->noblocksnd;
2262 tcp_ses->noautotune = volume_info->noautotune;
6a5fa236 2263 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
fc40f9cf 2264 tcp_ses->in_flight = 0;
2d86dbc9 2265 tcp_ses->credits = 1;
63c038c2
JL		 2266 init_waitqueue_head(&tcp_ses->response_q);
2267 init_waitqueue_head(&tcp_ses->request_q);
2268 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2269 mutex_init(&tcp_ses->srv_mutex);
2270 memcpy(tcp_ses->workstation_RFC1001_name,
2271 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2272 memcpy(tcp_ses->server_RFC1001_name,
2273 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
5d0d2882 2274 tcp_ses->session_estab = false;
63c038c2 2275 tcp_ses->sequence_number = 0;
fda35943 2276 tcp_ses->lstrp = jiffies;
58fa015f 2277 spin_lock_init(&tcp_ses->req_lock);
63c038c2
JL		 2278 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2279 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
c74093b6 2280 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
63c038c2
JL		 2281
2282 /*
2283 * at this point we are the only ones with the pointer
2284 * to the struct since the kernel thread not created yet
2285 * no need to spinlock this init of tcpStatus or srv_count
2286 */
2287 tcp_ses->tcpStatus = CifsNew;
3eb9a889
BG		 2288 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2289 sizeof(tcp_ses->srcaddr));
63c038c2
JL		 2290 ++tcp_ses->srv_count;
2291
a9ac49d3 2292 if (addr.ss_family == AF_INET6) {
b6b38f70 2293 cFYI(1, "attempting ipv6 connect");
63c038c2
JL		 2294 /* BB should we allow ipv6 on port 139? */
2295 /* other OS never observed in Wild doing 139 with v6 */
a9f1b85e
PS		 2296 memcpy(&tcp_ses->dstaddr, sin_server6,
2297 sizeof(struct sockaddr_in6));
2298 } else
2299 memcpy(&tcp_ses->dstaddr, sin_server,
2300 sizeof(struct sockaddr_in));
2301
2302 rc = ip_connect(tcp_ses);
63c038c2 2303 if (rc < 0) {
b6b38f70 2304 cERROR(1, "Error connecting to socket. Aborting operation");
f7c5445a 2305 goto out_err_crypto_release;
63c038c2
JL		 2306 }
2307
2308 /*
2309 * since we're in a cifs function already, we know that
2310 * this will succeed. No need for try_module_get().
2311 */
2312 __module_get(THIS_MODULE);
7c97c200 2313 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
63c038c2
JL		 2314 tcp_ses, "cifsd");
2315 if (IS_ERR(tcp_ses->tsk)) {
2316 rc = PTR_ERR(tcp_ses->tsk);
b6b38f70 2317 cERROR(1, "error %d create cifsd thread", rc);
63c038c2 2318 module_put(THIS_MODULE);
f7c5445a 2319 goto out_err_crypto_release;
63c038c2 2320 }
fd88ce93 2321 tcp_ses->tcpStatus = CifsNeedNegotiate;
63c038c2
JL		 2322
2323 /* thread spawned, put it on the list */
3f9bcca7 2324 spin_lock(&cifs_tcp_ses_lock);
63c038c2 2325 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
3f9bcca7 2326 spin_unlock(&cifs_tcp_ses_lock);
63c038c2 2327
488f1d2d
SJ		 2328 cifs_fscache_get_client_cookie(tcp_ses);
2329
c74093b6 2330 /* queue echo request delayed work */
da472fc8 2331 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
c74093b6 2332
63c038c2
JL		 2333 return tcp_ses;
2334
f7c5445a 2335out_err_crypto_release:
d2b91521
SP		 2336 cifs_crypto_shash_release(tcp_ses);
2337
f1d0c998
RL		 2338 put_net(cifs_net_ns(tcp_ses));
2339
63c038c2
JL		 2340out_err:
2341 if (tcp_ses) {
8347a5cd
SF		 2342 if (!IS_ERR(tcp_ses->hostname))
2343 kfree(tcp_ses->hostname);
63c038c2
JL		 2344 if (tcp_ses->ssocket)
2345 sock_release(tcp_ses->ssocket);
2346 kfree(tcp_ses);
2347 }
2348 return ERR_PTR(rc);
2349}
2350
96daf2b0 2351static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
37bb04e5
PS		 2352{
2353 switch (ses->server->secType) {
2354 case Kerberos:
2355 if (vol->cred_uid != ses->cred_uid)
2356 return 0;
2357 break;
2358 default:
04febabc
JL		 2359 /* NULL username means anonymous session */
2360 if (ses->user_name == NULL) {
2361 if (!vol->nullauth)
2362 return 0;
2363 break;
2364 }
2365
37bb04e5 2366 /* anything else takes username/password */
04febabc
JL		 2367 if (strncmp(ses->user_name,
2368 vol->username ? vol->username : "",
37bb04e5
PS		 2369 MAX_USERNAME_SIZE))
2370 return 0;
2371 if (strlen(vol->username) != 0 &&
2372 ses->password != NULL &&
2373 strncmp(ses->password,
2374 vol->password ? vol->password : "",
2375 MAX_PASSWORD_SIZE))
2376 return 0;
2377 }
2378 return 1;
2379}
2380
96daf2b0 2381static struct cifs_ses *
4ff67b72 2382cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
1da177e4 2383{
96daf2b0 2384 struct cifs_ses *ses;
dea570e0 2385
3f9bcca7 2386 spin_lock(&cifs_tcp_ses_lock);
4ff67b72 2387 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
37bb04e5
PS		 2388 if (!match_session(ses, vol))
2389 continue;
14fbf50d 2390 ++ses->ses_count;
3f9bcca7 2391 spin_unlock(&cifs_tcp_ses_lock);
14fbf50d
JL		 2392 return ses;
2393 }
3f9bcca7 2394 spin_unlock(&cifs_tcp_ses_lock);
14fbf50d
JL		 2395 return NULL;
2396}
dea570e0 2397
14fbf50d 2398static void
96daf2b0 2399cifs_put_smb_ses(struct cifs_ses *ses)
14fbf50d
JL		 2400{
2401 int xid;
2402 struct TCP_Server_Info *server = ses->server;
dea570e0 2403
36988c76 2404 cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
3f9bcca7 2405 spin_lock(&cifs_tcp_ses_lock);
14fbf50d 2406 if (--ses->ses_count > 0) {
3f9bcca7 2407 spin_unlock(&cifs_tcp_ses_lock);
14fbf50d
JL		 2408 return;
2409 }
dea570e0 2410
14fbf50d 2411 list_del_init(&ses->smb_ses_list);
3f9bcca7 2412 spin_unlock(&cifs_tcp_ses_lock);
dea570e0 2413
14fbf50d
JL		 2414 if (ses->status == CifsGood) {
2415 xid = GetXid();
2416 CIFSSMBLogoff(xid, ses);
2417 _FreeXid(xid);
2418 }
2419 sesInfoFree(ses);
2420 cifs_put_tcp_session(server);
2421}
dea570e0 2422
8a8798a5
JL		 2423#ifdef CONFIG_KEYS
2424
2425/* strlen("cifs:a:") + INET6_ADDRSTRLEN + 1 */
2426#define CIFSCREDS_DESC_SIZE (7 + INET6_ADDRSTRLEN + 1)
2427
2428/* Populate username and pw fields from keyring if possible */
2429static int
2430cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2431{
2432 int rc = 0;
2433 char *desc, *delim, *payload;
2434 ssize_t len;
2435 struct key *key;
2436 struct TCP_Server_Info *server = ses->server;
2437 struct sockaddr_in *sa;
2438 struct sockaddr_in6 *sa6;
2439 struct user_key_payload *upayload;
2440
2441 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2442 if (!desc)
2443 return -ENOMEM;
2444
2445 /* try to find an address key first */
2446 switch (server->dstaddr.ss_family) {
2447 case AF_INET:
2448 sa = (struct sockaddr_in *)&server->dstaddr;
2449 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2450 break;
2451 case AF_INET6:
2452 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2453 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2454 break;
2455 default:
2456 cFYI(1, "Bad ss_family (%hu)", server->dstaddr.ss_family);
2457 rc = -EINVAL;
2458 goto out_err;
2459 }
2460
2461 cFYI(1, "%s: desc=%s", __func__, desc);
2462 key = request_key(&key_type_logon, desc, "");
2463 if (IS_ERR(key)) {
2464 if (!ses->domainName) {
2465 cFYI(1, "domainName is NULL");
2466 rc = PTR_ERR(key);
2467 goto out_err;
2468 }
2469
2470 /* didn't work, try to find a domain key */
2471 sprintf(desc, "cifs:d:%s", ses->domainName);
2472 cFYI(1, "%s: desc=%s", __func__, desc);
2473 key = request_key(&key_type_logon, desc, "");
2474 if (IS_ERR(key)) {
2475 rc = PTR_ERR(key);
2476 goto out_err;
2477 }
2478 }
2479
2480 down_read(&key->sem);
2481 upayload = key->payload.data;
2482 if (IS_ERR_OR_NULL(upayload)) {
4edc53c1 2483 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
8a8798a5
JL		 2484 goto out_key_put;
2485 }
2486
2487 /* find first : in payload */
2488 payload = (char *)upayload->data;
2489 delim = strnchr(payload, upayload->datalen, ':');
2490 cFYI(1, "payload=%s", payload);
2491 if (!delim) {
2492 cFYI(1, "Unable to find ':' in payload (datalen=%d)",
2493 upayload->datalen);
2494 rc = -EINVAL;
2495 goto out_key_put;
2496 }
2497
2498 len = delim - payload;
2499 if (len > MAX_USERNAME_SIZE || len <= 0) {
000f9bb8 2500 cFYI(1, "Bad value from username search (len=%zd)", len);
8a8798a5
JL		 2501 rc = -EINVAL;
2502 goto out_key_put;
2503 }
2504
2505 vol->username = kstrndup(payload, len, GFP_KERNEL);
2506 if (!vol->username) {
000f9bb8 2507 cFYI(1, "Unable to allocate %zd bytes for username", len);
8a8798a5
JL		 2508 rc = -ENOMEM;
2509 goto out_key_put;
2510 }
2511 cFYI(1, "%s: username=%s", __func__, vol->username);
2512
2513 len = key->datalen - (len + 1);
2514 if (len > MAX_PASSWORD_SIZE || len <= 0) {
000f9bb8 2515 cFYI(1, "Bad len for password search (len=%zd)", len);
8a8798a5
JL		 2516 rc = -EINVAL;
2517 kfree(vol->username);
2518 vol->username = NULL;
2519 goto out_key_put;
2520 }
2521
2522 ++delim;
2523 vol->password = kstrndup(delim, len, GFP_KERNEL);
2524 if (!vol->password) {
000f9bb8 2525 cFYI(1, "Unable to allocate %zd bytes for password", len);
8a8798a5
JL		 2526 rc = -ENOMEM;
2527 kfree(vol->username);
2528 vol->username = NULL;
2529 goto out_key_put;
2530 }
2531
2532out_key_put:
2533 up_read(&key->sem);
2534 key_put(key);
2535out_err:
2536 kfree(desc);
2537 cFYI(1, "%s: returning %d", __func__, rc);
2538 return rc;
2539}
2540#else /* ! CONFIG_KEYS */
2541static inline int
2542cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2543 struct cifs_ses *ses __attribute__((unused)))
2544{
2545 return -ENOSYS;
2546}
2547#endif /* CONFIG_KEYS */
2548
d9b94201
SF		 2549static bool warned_on_ntlm; /* globals init to false automatically */
2550
96daf2b0 2551static struct cifs_ses *
36988c76
JL		 2552cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2553{
2554 int rc = -ENOMEM, xid;
96daf2b0 2555 struct cifs_ses *ses;
a9f1b85e
PS		 2556 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2557 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
36988c76
JL		 2558
2559 xid = GetXid();
2560
4ff67b72 2561 ses = cifs_find_smb_ses(server, volume_info);
36988c76
JL		 2562 if (ses) {
2563 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
2564
36988c76 2565 mutex_lock(&ses->session_mutex);
198b5682
JL		 2566 rc = cifs_negotiate_protocol(xid, ses);
2567 if (rc) {
2568 mutex_unlock(&ses->session_mutex);
2569 /* problem -- put our ses reference */
2570 cifs_put_smb_ses(ses);
2571 FreeXid(xid);
2572 return ERR_PTR(rc);
2573 }
36988c76
JL		 2574 if (ses->need_reconnect) {
2575 cFYI(1, "Session needs reconnect");
2576 rc = cifs_setup_session(xid, ses,
2577 volume_info->local_nls);
2578 if (rc) {
2579 mutex_unlock(&ses->session_mutex);
2580 /* problem -- put our reference */
2581 cifs_put_smb_ses(ses);
2582 FreeXid(xid);
2583 return ERR_PTR(rc);
2584 }
2585 }
2586 mutex_unlock(&ses->session_mutex);
460cf341
JL		 2587
2588 /* existing SMB ses has a server reference already */
2589 cifs_put_tcp_session(server);
36988c76
JL		 2590 FreeXid(xid);
2591 return ses;
2592 }
2593
2594 cFYI(1, "Existing smb sess not found");
2595 ses = sesInfoAlloc();
2596 if (ses == NULL)
2597 goto get_ses_fail;
2598
2599 /* new SMB session uses our server ref */
2600 ses->server = server;
a9f1b85e
PS		 2601 if (server->dstaddr.ss_family == AF_INET6)
2602 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
36988c76 2603 else
a9f1b85e 2604 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
36988c76 2605
8727c8a8
SF		 2606 if (volume_info->username) {
2607 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2608 if (!ses->user_name)
2609 goto get_ses_fail;
2610 }
36988c76
JL		 2611
2612 /* volume_info->password freed at unmount */
2613 if (volume_info->password) {
2614 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2615 if (!ses->password)
2616 goto get_ses_fail;
2617 }
2618 if (volume_info->domainname) {
d3686d54
SP		 2619 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2620 if (!ses->domainName)
2621 goto get_ses_fail;
36988c76 2622 }
3e4b3e1f 2623 ses->cred_uid = volume_info->cred_uid;
36988c76 2624 ses->linux_uid = volume_info->linux_uid;
d9b94201
SF		 2625
2626 /* ntlmv2 is much stronger than ntlm security, and has been broadly
2627 supported for many years, time to update default security mechanism */
2628 if ((volume_info->secFlg == 0) && warned_on_ntlm == false) {
2629 warned_on_ntlm = true;
2630 cERROR(1, "default security mechanism requested. The default "
2631 "security mechanism will be upgraded from ntlm to "
225de11e 2632 "ntlmv2 in kernel release 3.3");
d9b94201 2633 }
36988c76
JL		 2634 ses->overrideSecFlg = volume_info->secFlg;
2635
2636 mutex_lock(&ses->session_mutex);
198b5682
JL		 2637 rc = cifs_negotiate_protocol(xid, ses);
2638 if (!rc)
2639 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
36988c76 2640 mutex_unlock(&ses->session_mutex);
c8e56f1f 2641 if (rc)
36988c76
JL		 2642 goto get_ses_fail;
2643
2644 /* success, put it on the list */
3f9bcca7 2645 spin_lock(&cifs_tcp_ses_lock);
36988c76 2646 list_add(&ses->smb_ses_list, &server->smb_ses_list);
3f9bcca7 2647 spin_unlock(&cifs_tcp_ses_lock);
36988c76
JL		 2648
2649 FreeXid(xid);
2650 return ses;
2651
2652get_ses_fail:
2653 sesInfoFree(ses);
2654 FreeXid(xid);
2655 return ERR_PTR(rc);
2656}
2657
96daf2b0 2658static int match_tcon(struct cifs_tcon *tcon, const char *unc)
37bb04e5
PS		 2659{
2660 if (tcon->tidStatus == CifsExiting)
2661 return 0;
2662 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2663 return 0;
2664 return 1;
2665}
2666
96daf2b0
SF		 2667static struct cifs_tcon *
2668cifs_find_tcon(struct cifs_ses *ses, const char *unc)
f1987b44
JL		 2669{
2670 struct list_head *tmp;
96daf2b0 2671 struct cifs_tcon *tcon;
f1987b44 2672
3f9bcca7 2673 spin_lock(&cifs_tcp_ses_lock);
f1987b44 2674 list_for_each(tmp, &ses->tcon_list) {
96daf2b0 2675 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
37bb04e5 2676 if (!match_tcon(tcon, unc))
f1987b44 2677 continue;
f1987b44 2678 ++tcon->tc_count;
3f9bcca7 2679 spin_unlock(&cifs_tcp_ses_lock);
dea570e0 2680 return tcon;
1da177e4 2681 }
3f9bcca7 2682 spin_unlock(&cifs_tcp_ses_lock);
1da177e4
LT		 2683 return NULL;
2684}
2685
f1987b44 2686static void
96daf2b0 2687cifs_put_tcon(struct cifs_tcon *tcon)
f1987b44
JL		 2688{
2689 int xid;
96daf2b0 2690 struct cifs_ses *ses = tcon->ses;
f1987b44 2691
d00c28de 2692 cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
3f9bcca7 2693 spin_lock(&cifs_tcp_ses_lock);
f1987b44 2694 if (--tcon->tc_count > 0) {
3f9bcca7 2695 spin_unlock(&cifs_tcp_ses_lock);
f1987b44
JL		 2696 return;
2697 }
2698
2699 list_del_init(&tcon->tcon_list);
3f9bcca7 2700 spin_unlock(&cifs_tcp_ses_lock);
f1987b44
JL		 2701
2702 xid = GetXid();
2703 CIFSSMBTDis(xid, tcon);
2704 _FreeXid(xid);
2705
d03382ce 2706 cifs_fscache_release_super_cookie(tcon);
9f841593 2707 tconInfoFree(tcon);
f1987b44
JL		 2708 cifs_put_smb_ses(ses);
2709}
2710
96daf2b0
SF		 2711static struct cifs_tcon *
2712cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
d00c28de
JL		 2713{
2714 int rc, xid;
96daf2b0 2715 struct cifs_tcon *tcon;
d00c28de
JL		 2716
2717 tcon = cifs_find_tcon(ses, volume_info->UNC);
2718 if (tcon) {
2719 cFYI(1, "Found match on UNC path");
2720 /* existing tcon already has a reference */
2721 cifs_put_smb_ses(ses);
2722 if (tcon->seal != volume_info->seal)
2723 cERROR(1, "transport encryption setting "
2724 "conflicts with existing tid");
2725 return tcon;
2726 }
2727
2728 tcon = tconInfoAlloc();
2729 if (tcon == NULL) {
2730 rc = -ENOMEM;
2731 goto out_fail;
2732 }
2733
2734 tcon->ses = ses;
2735 if (volume_info->password) {
2736 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2737 if (!tcon->password) {
2738 rc = -ENOMEM;
2739 goto out_fail;
2740 }
2741 }
2742
2743 if (strchr(volume_info->UNC + 3, '\\') == NULL
2744 && strchr(volume_info->UNC + 3, '/') == NULL) {
2745 cERROR(1, "Missing share name");
2746 rc = -ENODEV;
2747 goto out_fail;
2748 }
2749
2750 /* BB Do we need to wrap session_mutex around
2751 * this TCon call and Unix SetFS as
2752 * we do on SessSetup and reconnect? */
2753 xid = GetXid();
2754 rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
2755 FreeXid(xid);
2756 cFYI(1, "CIFS Tcon rc = %d", rc);
2757 if (rc)
2758 goto out_fail;
2759
2760 if (volume_info->nodfs) {
2761 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2762 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2763 }
2764 tcon->seal = volume_info->seal;
2765 /* we can have only one retry value for a connection
2766 to a share so for resources mounted more than once
2767 to the same server share the last value passed in
2768 for the retry flag is used */
2769 tcon->retry = volume_info->retry;
2770 tcon->nocase = volume_info->nocase;
2771 tcon->local_lease = volume_info->local_lease;
2772
3f9bcca7 2773 spin_lock(&cifs_tcp_ses_lock);
d00c28de 2774 list_add(&tcon->tcon_list, &ses->tcon_list);
3f9bcca7 2775 spin_unlock(&cifs_tcp_ses_lock);
d00c28de 2776
d03382ce
SJ		 2777 cifs_fscache_get_super_cookie(tcon);
2778
d00c28de
JL		 2779 return tcon;
2780
2781out_fail:
2782 tconInfoFree(tcon);
2783 return ERR_PTR(rc);
2784}
2785
9d002df4
JL		 2786void
2787cifs_put_tlink(struct tcon_link *tlink)
2788{
2789 if (!tlink || IS_ERR(tlink))
2790 return;
2791
2792 if (!atomic_dec_and_test(&tlink->tl_count) ||
2793 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2794 tlink->tl_time = jiffies;
2795 return;
2796 }
2797
2798 if (!IS_ERR(tlink_tcon(tlink)))
2799 cifs_put_tcon(tlink_tcon(tlink));
2800 kfree(tlink);
2801 return;
2802}
d00c28de 2803
25c7f41e 2804static inline struct tcon_link *
cd51875d
PS		 2805cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2806{
2807 return cifs_sb->master_tlink;
2808}
25c7f41e
PS		 2809
2810static int
2811compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2812{
2813 struct cifs_sb_info *old = CIFS_SB(sb);
2814 struct cifs_sb_info *new = mnt_data->cifs_sb;
2815
2816 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2817 return 0;
2818
2819 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2820 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2821 return 0;
2822
25c7f41e 2823 /*
5eba8ab3
JL		 2824 * We want to share sb only if we don't specify an r/wsize or
2825 * specified r/wsize is greater than or equal to existing one.
25c7f41e
PS		 2826 */
2827 if (new->wsize && new->wsize < old->wsize)
2828 return 0;
2829
5eba8ab3
JL		 2830 if (new->rsize && new->rsize < old->rsize)
2831 return 0;
2832
25c7f41e
PS		 2833 if (old->mnt_uid != new->mnt_uid || old->mnt_gid != new->mnt_gid)
2834 return 0;
2835
2836 if (old->mnt_file_mode != new->mnt_file_mode ||
2837 old->mnt_dir_mode != new->mnt_dir_mode)
2838 return 0;
2839
2840 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2841 return 0;
2842
2843 if (old->actimeo != new->actimeo)
2844 return 0;
2845
2846 return 1;
2847}
2848
2849int
2850cifs_match_super(struct super_block *sb, void *data)
2851{
2852 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2853 struct smb_vol *volume_info;
2854 struct cifs_sb_info *cifs_sb;
2855 struct TCP_Server_Info *tcp_srv;
96daf2b0
SF		 2856 struct cifs_ses *ses;
2857 struct cifs_tcon *tcon;
25c7f41e
PS		 2858 struct tcon_link *tlink;
2859 struct sockaddr_storage addr;
2860 int rc = 0;
2861
2862 memset(&addr, 0, sizeof(struct sockaddr_storage));
2863
2864 spin_lock(&cifs_tcp_ses_lock);
2865 cifs_sb = CIFS_SB(sb);
2866 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2867 if (IS_ERR(tlink)) {
2868 spin_unlock(&cifs_tcp_ses_lock);
2869 return rc;
2870 }
2871 tcon = tlink_tcon(tlink);
2872 ses = tcon->ses;
2873 tcp_srv = ses->server;
2874
2875 volume_info = mnt_data->vol;
2876
2877 if (!volume_info->UNCip || !volume_info->UNC)
2878 goto out;
2879
2880 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
2881 volume_info->UNCip,
2882 strlen(volume_info->UNCip),
2883 volume_info->port);
2884 if (!rc)
2885 goto out;
2886
2887 if (!match_server(tcp_srv, (struct sockaddr *)&addr, volume_info) ||
2888 !match_session(ses, volume_info) ||
2889 !match_tcon(tcon, volume_info->UNC)) {
2890 rc = 0;
2891 goto out;
2892 }
2893
2894 rc = compare_mount_options(sb, mnt_data);
2895out:
25c7f41e 2896 spin_unlock(&cifs_tcp_ses_lock);
f484b5d0 2897 cifs_put_tlink(tlink);
25c7f41e
PS		 2898 return rc;
2899}
2900
1da177e4 2901int
96daf2b0 2902get_dfs_path(int xid, struct cifs_ses *pSesInfo, const char *old_path,
50c2f753 2903 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
366781c1 2904 struct dfs_info3_param **preferrals, int remap)
1da177e4
LT		 2905{
2906 char *temp_unc;
2907 int rc = 0;
2908
2909 *pnum_referrals = 0;
366781c1 2910 *preferrals = NULL;
1da177e4
LT		 2911
2912 if (pSesInfo->ipc_tid == 0) {
2913 temp_unc = kmalloc(2 /* for slashes */ +
50c2f753
SF		 2914 strnlen(pSesInfo->serverName,
2915 SERVER_NAME_LEN_WITH_NULL * 2)
1da177e4
LT		 2916 + 1 + 4 /* slash IPC$ */ + 2,
2917 GFP_KERNEL);
2918 if (temp_unc == NULL)
2919 return -ENOMEM;
2920 temp_unc[0] = '\\';
2921 temp_unc[1] = '\\';
2922 strcpy(temp_unc + 2, pSesInfo->serverName);
2923 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2924 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
b6b38f70 2925 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
1da177e4
LT		 2926 kfree(temp_unc);
2927 }
2928 if (rc == 0)
c2cf07d5 2929 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
737b758c 2930 pnum_referrals, nls_codepage, remap);
366781c1
SF		 2931 /* BB map targetUNCs to dfs_info3 structures, here or
2932 in CIFSGetDFSRefer BB */
1da177e4
LT		 2933
2934 return rc;
2935}
2936
09e50d55
JL		 2937#ifdef CONFIG_DEBUG_LOCK_ALLOC
2938static struct lock_class_key cifs_key[2];
2939static struct lock_class_key cifs_slock_key[2];
2940
2941static inline void
2942cifs_reclassify_socket4(struct socket *sock)
2943{
2944 struct sock *sk = sock->sk;
2945 BUG_ON(sock_owned_by_user(sk));
2946 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2947 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2948}
2949
2950static inline void
2951cifs_reclassify_socket6(struct socket *sock)
2952{
2953 struct sock *sk = sock->sk;
2954 BUG_ON(sock_owned_by_user(sk));
2955 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2956 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2957}
2958#else
2959static inline void
2960cifs_reclassify_socket4(struct socket *sock)
2961{
2962}
2963
2964static inline void
2965cifs_reclassify_socket6(struct socket *sock)
2966{
2967}
2968#endif
2969
1da177e4 2970/* See RFC1001 section 14 on representation of Netbios names */
50c2f753 2971static void rfc1002mangle(char *target, char *source, unsigned int length)
1da177e4 2972{
50c2f753 2973 unsigned int i, j;
1da177e4 2974
50c2f753 2975 for (i = 0, j = 0; i < (length); i++) {
1da177e4
LT		 2976 /* mask a nibble at a time and encode */
2977 target[j] = 'A' + (0x0F & (source[i] >> 4));
2978 target[j+1] = 'A' + (0x0F & source[i]);
50c2f753 2979 j += 2;
1da177e4
LT		 2980 }
2981
2982}
2983
3eb9a889
BG		 2984static int
2985bind_socket(struct TCP_Server_Info *server)
2986{
2987 int rc = 0;
2988 if (server->srcaddr.ss_family != AF_UNSPEC) {
2989 /* Bind to the specified local IP address */
2990 struct socket *socket = server->ssocket;
2991 rc = socket->ops->bind(socket,
2992 (struct sockaddr *) &server->srcaddr,
2993 sizeof(server->srcaddr));
2994 if (rc < 0) {
2995 struct sockaddr_in *saddr4;
2996 struct sockaddr_in6 *saddr6;
2997 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2998 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2999 if (saddr6->sin6_family == AF_INET6)
3000 cERROR(1, "cifs: "
3001 "Failed to bind to: %pI6c, error: %d\n",
3002 &saddr6->sin6_addr, rc);
3003 else
3004 cERROR(1, "cifs: "
3005 "Failed to bind to: %pI4, error: %d\n",
3006 &saddr4->sin_addr.s_addr, rc);
3007 }
3008 }
3009 return rc;
3010}
1da177e4
LT		 3011
3012static int
a9f1b85e 3013ip_rfc1001_connect(struct TCP_Server_Info *server)
1da177e4
LT		 3014{
3015 int rc = 0;
a9f1b85e
PS		 3016 /*
3017 * some servers require RFC1001 sessinit before sending
3018 * negprot - BB check reconnection in case where second
3019 * sessinit is sent but no second negprot
3020 */
3021 struct rfc1002_session_packet *ses_init_buf;
3022 struct smb_hdr *smb_buf;
3023 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
3024 GFP_KERNEL);
3025 if (ses_init_buf) {
3026 ses_init_buf->trailer.session_req.called_len = 32;
3027
3028 if (server->server_RFC1001_name &&
3029 server->server_RFC1001_name[0] != 0)
3030 rfc1002mangle(ses_init_buf->trailer.
3031 session_req.called_name,
3032 server->server_RFC1001_name,
3033 RFC1001_NAME_LEN_WITH_NULL);
3034 else
3035 rfc1002mangle(ses_init_buf->trailer.
3036 session_req.called_name,
3037 DEFAULT_CIFS_CALLED_NAME,
3038 RFC1001_NAME_LEN_WITH_NULL);
3039
3040 ses_init_buf->trailer.session_req.calling_len = 32;
3041
3042 /*
3043 * calling name ends in null (byte 16) from old smb
3044 * convention.
3045 */
3046 if (server->workstation_RFC1001_name &&
3047 server->workstation_RFC1001_name[0] != 0)
3048 rfc1002mangle(ses_init_buf->trailer.
3049 session_req.calling_name,
3050 server->workstation_RFC1001_name,
3051 RFC1001_NAME_LEN_WITH_NULL);
3052 else
3053 rfc1002mangle(ses_init_buf->trailer.
3054 session_req.calling_name,
3055 "LINUX_CIFS_CLNT",
3056 RFC1001_NAME_LEN_WITH_NULL);
3057
3058 ses_init_buf->trailer.session_req.scope1 = 0;
3059 ses_init_buf->trailer.session_req.scope2 = 0;
3060 smb_buf = (struct smb_hdr *)ses_init_buf;
3061
3062 /* sizeof RFC1002_SESSION_REQUEST with no scope */
be8e3b00 3063 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
a9f1b85e
PS		 3064 rc = smb_send(server, smb_buf, 0x44);
3065 kfree(ses_init_buf);
3066 /*
3067 * RFC1001 layer in at least one server
3068 * requires very short break before negprot
3069 * presumably because not expecting negprot
3070 * to follow so fast. This is a simple
3071 * solution that works without
3072 * complicating the code and causes no
3073 * significant slowing down on mount
3074 * for everyone else
3075 */
3076 usleep_range(1000, 2000);
3077 }
3078 /*
3079 * else the negprot may still work without this
3080 * even though malloc failed
3081 */
3082
3083 return rc;
3084}
3085
3086static int
3087generic_ip_connect(struct TCP_Server_Info *server)
3088{
3089 int rc = 0;
6da97910 3090 __be16 sport;
a9f1b85e 3091 int slen, sfamily;
bcf4b106 3092 struct socket *socket = server->ssocket;
a9f1b85e
PS		 3093 struct sockaddr *saddr;
3094
3095 saddr = (struct sockaddr *) &server->dstaddr;
3096
3097 if (server->dstaddr.ss_family == AF_INET6) {
3098 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3099 slen = sizeof(struct sockaddr_in6);
3100 sfamily = AF_INET6;
3101 } else {
3102 sport = ((struct sockaddr_in *) saddr)->sin_port;
3103 slen = sizeof(struct sockaddr_in);
3104 sfamily = AF_INET;
3105 }
1da177e4 3106
bcf4b106 3107 if (socket == NULL) {
f1d0c998
RL		 3108 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3109 IPPROTO_TCP, &socket, 1);
1da177e4 3110 if (rc < 0) {
b6b38f70 3111 cERROR(1, "Error %d creating socket", rc);
a9f1b85e 3112 server->ssocket = NULL;
1da177e4 3113 return rc;
1da177e4 3114 }
bcf4b106
JL		 3115
3116 /* BB other socket options to set KEEPALIVE, NODELAY? */
b6b38f70 3117 cFYI(1, "Socket created");
bcf4b106
JL		 3118 server->ssocket = socket;
3119 socket->sk->sk_allocation = GFP_NOFS;
a9f1b85e
PS		 3120 if (sfamily == AF_INET6)
3121 cifs_reclassify_socket6(socket);
3122 else
3123 cifs_reclassify_socket4(socket);
1da177e4
LT		 3124 }
3125
3eb9a889
BG		 3126 rc = bind_socket(server);
3127 if (rc < 0)
3128 return rc;
3129
bcf4b106
JL		 3130 /*
3131 * Eventually check for other socket options to change from
a9f1b85e
PS		 3132 * the default. sock_setsockopt not used because it expects
3133 * user space buffer
bcf4b106
JL		 3134 */
3135 socket->sk->sk_rcvtimeo = 7 * HZ;
da505c38 3136 socket->sk->sk_sndtimeo = 5 * HZ;
edf1ae40 3137
b387eaeb 3138 /* make the bufsizes depend on wsize/rsize and max requests */
bcf4b106
JL		 3139 if (server->noautotune) {
3140 if (socket->sk->sk_sndbuf < (200 * 1024))
3141 socket->sk->sk_sndbuf = 200 * 1024;
3142 if (socket->sk->sk_rcvbuf < (140 * 1024))
3143 socket->sk->sk_rcvbuf = 140 * 1024;
edf1ae40 3144 }
1da177e4 3145
6a5fa236 3146 if (server->tcp_nodelay) {
a9f1b85e 3147 int val = 1;
6a5fa236
SF		 3148 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3149 (char *)&val, sizeof(val));
3150 if (rc)
b6b38f70 3151 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
6a5fa236
SF		 3152 }
3153
b6b38f70 3154 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
bcf4b106 3155 socket->sk->sk_sndbuf,
b6b38f70 3156 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
bcf4b106 3157
ee1b3ea9
JL		 3158 rc = socket->ops->connect(socket, saddr, slen, 0);
3159 if (rc < 0) {
3160 cFYI(1, "Error %d connecting to server", rc);
3161 sock_release(socket);
3162 server->ssocket = NULL;
3163 return rc;
3164 }
3165
a9f1b85e
PS		 3166 if (sport == htons(RFC1001_PORT))
3167 rc = ip_rfc1001_connect(server);
50c2f753 3168
1da177e4
LT		 3169 return rc;
3170}
3171
3172static int
a9f1b85e 3173ip_connect(struct TCP_Server_Info *server)
1da177e4 3174{
6da97910 3175 __be16 *sport;
a9f1b85e
PS		 3176 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3177 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
1da177e4 3178
a9f1b85e
PS		 3179 if (server->dstaddr.ss_family == AF_INET6)
3180 sport = &addr6->sin6_port;
3181 else
3182 sport = &addr->sin_port;
1da177e4 3183
a9f1b85e
PS		 3184 if (*sport == 0) {
3185 int rc;
1da177e4 3186
a9f1b85e
PS		 3187 /* try with 445 port at first */
3188 *sport = htons(CIFS_PORT);
3eb9a889 3189
a9f1b85e 3190 rc = generic_ip_connect(server);
1da177e4 3191 if (rc >= 0)
a9f1b85e 3192 return rc;
6a5fa236 3193
a9f1b85e
PS		 3194 /* if it failed, try with 139 port */
3195 *sport = htons(RFC1001_PORT);
6a5fa236
SF		 3196 }
3197
a9f1b85e 3198 return generic_ip_connect(server);
1da177e4
LT		 3199}
3200
96daf2b0 3201void reset_cifs_unix_caps(int xid, struct cifs_tcon *tcon,
2c6292ae 3202 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
8af18971
SF		 3203{
3204 /* if we are reconnecting then should we check to see if
3205 * any requested capabilities changed locally e.g. via
3206 * remount but we can not do much about it here
3207 * if they have (even if we could detect it by the following)
3208 * Perhaps we could add a backpointer to array of sb from tcon
3209 * or if we change to make all sb to same share the same
3210 * sb as NFS - then we only have one backpointer to sb.
3211 * What if we wanted to mount the server share twice once with
3212 * and once without posixacls or posix paths? */
3213 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
50c2f753 3214
c18c842b
SF		 3215 if (vol_info && vol_info->no_linux_ext) {
3216 tcon->fsUnixInfo.Capability = 0;
3217 tcon->unix_ext = 0; /* Unix Extensions disabled */
b6b38f70 3218 cFYI(1, "Linux protocol extensions disabled");
c18c842b
SF		 3219 return;
3220 } else if (vol_info)
3221 tcon->unix_ext = 1; /* Unix Extensions supported */
3222
3223 if (tcon->unix_ext == 0) {
b6b38f70 3224 cFYI(1, "Unix extensions disabled so not set on reconnect");
c18c842b
SF		 3225 return;
3226 }
50c2f753 3227
fb8c4b14 3228 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
8af18971 3229 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
6848b733 3230 cFYI(1, "unix caps which server supports %lld", cap);
8af18971
SF		 3231 /* check for reconnect case in which we do not
3232 want to change the mount behavior if we can avoid it */
fb8c4b14 3233 if (vol_info == NULL) {
50c2f753 3234 /* turn off POSIX ACL and PATHNAMES if not set
8af18971
SF		 3235 originally at mount time */
3236 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3237 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
11b6d645
IM		 3238 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3239 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
b6b38f70 3240 cERROR(1, "POSIXPATH support change");
8af18971 3241 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
11b6d645 3242 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
b6b38f70
JP		 3243 cERROR(1, "possible reconnect error");
3244 cERROR(1, "server disabled POSIX path support");
11b6d645 3245 }
8af18971 3246 }
50c2f753 3247
6848b733
SF		 3248 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3249 cERROR(1, "per-share encryption not supported yet");
3250
8af18971 3251 cap &= CIFS_UNIX_CAP_MASK;
75865f8c 3252 if (vol_info && vol_info->no_psx_acl)
8af18971 3253 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
75865f8c 3254 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
b6b38f70 3255 cFYI(1, "negotiated posix acl support");
2c6292ae
AV		 3256 if (cifs_sb)
3257 cifs_sb->mnt_cifs_flags |=
3258 CIFS_MOUNT_POSIXACL;
8af18971
SF		 3259 }
3260
75865f8c 3261 if (vol_info && vol_info->posix_paths == 0)
8af18971 3262 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
75865f8c 3263 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
b6b38f70 3264 cFYI(1, "negotiate posix pathnames");
2c6292ae
AV		 3265 if (cifs_sb)
3266 cifs_sb->mnt_cifs_flags |=
8af18971
SF		 3267 CIFS_MOUNT_POSIX_PATHS;
3268 }
50c2f753 3269
b6b38f70 3270 cFYI(1, "Negotiate caps 0x%x", (int)cap);
8af18971 3271#ifdef CONFIG_CIFS_DEBUG2
75865f8c 3272 if (cap & CIFS_UNIX_FCNTL_CAP)
b6b38f70 3273 cFYI(1, "FCNTL cap");
75865f8c 3274 if (cap & CIFS_UNIX_EXTATTR_CAP)
b6b38f70 3275 cFYI(1, "EXTATTR cap");
75865f8c 3276 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
b6b38f70 3277 cFYI(1, "POSIX path cap");
75865f8c 3278 if (cap & CIFS_UNIX_XATTR_CAP)
b6b38f70 3279 cFYI(1, "XATTR cap");
75865f8c 3280 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
b6b38f70 3281 cFYI(1, "POSIX ACL cap");
75865f8c 3282 if (cap & CIFS_UNIX_LARGE_READ_CAP)
b6b38f70 3283 cFYI(1, "very large read cap");
75865f8c 3284 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
b6b38f70 3285 cFYI(1, "very large write cap");
6848b733
SF		 3286 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3287 cFYI(1, "transport encryption cap");
3288 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3289 cFYI(1, "mandatory transport encryption cap");
8af18971
SF		 3290#endif /* CIFS_DEBUG2 */
3291 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
442aa310 3292 if (vol_info == NULL) {
b6b38f70 3293 cFYI(1, "resetting capabilities failed");
442aa310 3294 } else
b6b38f70 3295 cERROR(1, "Negotiating Unix capabilities "
5a44b319
SF		 3296 "with the server failed. Consider "
3297 "mounting with the Unix Extensions\n"
3298 "disabled, if problems are found, "
3299 "by specifying the nounix mount "
b6b38f70 3300 "option.");
5a44b319 3301
8af18971
SF		 3302 }
3303 }
3304}
3305
724d9f1c
PS		 3306void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3307 struct cifs_sb_info *cifs_sb)
b1c8d2b4 3308{
2de970ff
JL		 3309 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3310
2ced6f69
AV		 3311 spin_lock_init(&cifs_sb->tlink_tree_lock);
3312 cifs_sb->tlink_tree = RB_ROOT;
3313
25c7f41e 3314 /*
5eba8ab3
JL		 3315 * Temporarily set r/wsize for matching superblock. If we end up using
3316 * new sb then client will later negotiate it downward if needed.
25c7f41e 3317 */
5eba8ab3 3318 cifs_sb->rsize = pvolume_info->rsize;
25c7f41e
PS		 3319 cifs_sb->wsize = pvolume_info->wsize;
3320
3b795210
SF		 3321 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3322 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3323 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3324 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
5206efd6 3325 cFYI(1, "file mode: 0x%hx dir mode: 0x%hx",
b6b38f70 3326 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3b795210 3327
6d20e840 3328 cifs_sb->actimeo = pvolume_info->actimeo;
724d9f1c 3329 cifs_sb->local_nls = pvolume_info->local_nls;
6d20e840 3330
3b795210
SF		 3331 if (pvolume_info->noperm)
3332 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3333 if (pvolume_info->setuids)
3334 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3335 if (pvolume_info->server_ino)
3336 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3337 if (pvolume_info->remap)
3338 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3339 if (pvolume_info->no_xattr)
3340 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3341 if (pvolume_info->sfu_emul)
3342 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3343 if (pvolume_info->nobrl)
3344 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
be652445 3345 if (pvolume_info->nostrictsync)
4717bed6 3346 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
13a6e42a
SF		 3347 if (pvolume_info->mand_lock)
3348 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
d4ffff1f
PS		 3349 if (pvolume_info->rwpidforward)
3350 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3b795210
SF		 3351 if (pvolume_info->cifs_acl)
3352 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3c7c87fd 3353 if (pvolume_info->backupuid_specified) {
3d3ea8e6 3354 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3c7c87fd
SP		 3355 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3356 }
3357 if (pvolume_info->backupgid_specified) {
3d3ea8e6 3358 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3c7c87fd
SP		 3359 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3360 }
3b795210
SF		 3361 if (pvolume_info->override_uid)
3362 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3363 if (pvolume_info->override_gid)
3364 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3365 if (pvolume_info->dynperm)
3366 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
fa1df75d
SJ		 3367 if (pvolume_info->fsc)
3368 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
0eb8a132
JL		 3369 if (pvolume_info->multiuser)
3370 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3371 CIFS_MOUNT_NO_PERM);
d39454ff
PS		 3372 if (pvolume_info->strict_io)
3373 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3b795210 3374 if (pvolume_info->direct_io) {
b6b38f70 3375 cFYI(1, "mounting share using direct i/o");
3b795210
SF		 3376 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3377 }
736a3320
SM		 3378 if (pvolume_info->mfsymlinks) {
3379 if (pvolume_info->sfu_emul) {
3380 cERROR(1, "mount option mfsymlinks ignored if sfu "
3381 "mount option is used");
3382 } else {
3383 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3384 }
3385 }
3b795210
SF		 3386
3387 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
b6b38f70
JP		 3388 cERROR(1, "mount option dynperm ignored if cifsacl "
3389 "mount option supported");
b1c8d2b4
JL		 3390}
3391
f7910cbd 3392/*
5eba8ab3
JL		 3393 * When the server supports very large reads and writes via POSIX extensions,
3394 * we can allow up to 2^24-1, minus the size of a READ/WRITE_AND_X header, not
3395 * including the RFC1001 length.
f7910cbd
JL		 3396 *
3397 * Note that this might make for "interesting" allocation problems during
1190f6a0
JL		 3398 * writeback however as we have to allocate an array of pointers for the
3399 * pages. A 16M write means ~32kb page array with PAGE_CACHE_SIZE == 4096.
5eba8ab3
JL		 3400 *
3401 * For reads, there is a similar problem as we need to allocate an array
3402 * of kvecs to handle the receive, though that should only need to be done
3403 * once.
f7910cbd 3404 */
1190f6a0 3405#define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
5eba8ab3 3406#define CIFS_MAX_RSIZE ((1<<24) - sizeof(READ_RSP) + 4)
f7910cbd
JL		 3407
3408/*
5eba8ab3
JL		 3409 * When the server doesn't allow large posix writes, only allow a rsize/wsize
3410 * of 2^17-1 minus the size of the call header. That allows for a read or
3411 * write up to the maximum size described by RFC1002.
f7910cbd 3412 */
94443f43 3413#define CIFS_MAX_RFC1002_WSIZE ((1<<17) - 1 - sizeof(WRITE_REQ) + 4)
5eba8ab3 3414#define CIFS_MAX_RFC1002_RSIZE ((1<<17) - 1 - sizeof(READ_RSP) + 4)
f7910cbd
JL		 3415
3416/*
3417 * The default wsize is 1M. find_get_pages seems to return a maximum of 256
3418 * pages in a single call. With PAGE_CACHE_SIZE == 4k, this means we can fill
3419 * a single wsize request with a single call.
3420 */
5eba8ab3
JL		 3421#define CIFS_DEFAULT_IOSIZE (1024 * 1024)
3422
3423/*
ce91acb3
JL		 3424 * Windows only supports a max of 60kb reads and 65535 byte writes. Default to
3425 * those values when posix extensions aren't in force. In actuality here, we
3426 * use 65536 to allow for a write that is a multiple of 4k. Most servers seem
3427 * to be ok with the extra byte even though Windows doesn't send writes that
3428 * are that large.
3429 *
3430 * Citation:
3431 *
3432 * http://blogs.msdn.com/b/openspecification/archive/2009/04/10/smb-maximum-transmit-buffer-size-and-performance-tuning.aspx
5eba8ab3
JL		 3433 */
3434#define CIFS_DEFAULT_NON_POSIX_RSIZE (60 * 1024)
ce91acb3 3435#define CIFS_DEFAULT_NON_POSIX_WSIZE (65536)
f7910cbd
JL		 3436
3437static unsigned int
96daf2b0 3438cifs_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
f7910cbd
JL		 3439{
3440 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3441 struct TCP_Server_Info *server = tcon->ses->server;
ce91acb3
JL		 3442 unsigned int wsize;
3443
3444 /* start with specified wsize, or default */
3445 if (pvolume_info->wsize)
3446 wsize = pvolume_info->wsize;
3447 else if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
3448 wsize = CIFS_DEFAULT_IOSIZE;
3449 else
3450 wsize = CIFS_DEFAULT_NON_POSIX_WSIZE;
f7910cbd
JL		 3451
3452 /* can server support 24-bit write sizes? (via UNIX extensions) */
3453 if (!tcon->unix_ext || !(unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
1190f6a0 3454 wsize = min_t(unsigned int, wsize, CIFS_MAX_RFC1002_WSIZE);
f7910cbd 3455
1190f6a0
JL		 3456 /*
3457 * no CAP_LARGE_WRITE_X or is signing enabled without CAP_UNIX set?
3458 * Limit it to max buffer offered by the server, minus the size of the
3459 * WRITEX header, not including the 4 byte RFC1001 length.
3460 */
3461 if (!(server->capabilities & CAP_LARGE_WRITE_X) ||
3462 (!(server->capabilities & CAP_UNIX) &&
3463 (server->sec_mode & (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED))))
3464 wsize = min_t(unsigned int, wsize,
3465 server->maxBuf - sizeof(WRITE_REQ) + 4);
f7910cbd
JL		 3466
3467 /* hard limit of CIFS_MAX_WSIZE */
3468 wsize = min_t(unsigned int, wsize, CIFS_MAX_WSIZE);
3469
3470 return wsize;
3471}
3472
5eba8ab3
JL		 3473static unsigned int
3474cifs_negotiate_rsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
3475{
3476 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3477 struct TCP_Server_Info *server = tcon->ses->server;
3478 unsigned int rsize, defsize;
3479
3480 /*
3481 * Set default value...
3482 *
3483 * HACK alert! Ancient servers have very small buffers. Even though
3484 * MS-CIFS indicates that servers are only limited by the client's
3485 * bufsize for reads, testing against win98se shows that it throws
3486 * INVALID_PARAMETER errors if you try to request too large a read.
3487 *
3488 * If the server advertises a MaxBufferSize of less than one page,
3489 * assume that it also can't satisfy reads larger than that either.
3490 *
3491 * FIXME: Is there a better heuristic for this?
3492 */
3493 if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_READ_CAP))
3494 defsize = CIFS_DEFAULT_IOSIZE;
3495 else if (server->capabilities & CAP_LARGE_READ_X)
3496 defsize = CIFS_DEFAULT_NON_POSIX_RSIZE;
3497 else if (server->maxBuf >= PAGE_CACHE_SIZE)
3498 defsize = CIFSMaxBufSize;
3499 else
3500 defsize = server->maxBuf - sizeof(READ_RSP);
3501
3502 rsize = pvolume_info->rsize ? pvolume_info->rsize : defsize;
3503
3504 /*
3505 * no CAP_LARGE_READ_X? Then MS-CIFS states that we must limit this to
3506 * the client's MaxBufferSize.
3507 */
3508 if (!(server->capabilities & CAP_LARGE_READ_X))
3509 rsize = min_t(unsigned int, CIFSMaxBufSize, rsize);
3510
3511 /* hard limit of CIFS_MAX_RSIZE */
3512 rsize = min_t(unsigned int, rsize, CIFS_MAX_RSIZE);
3513
3514 return rsize;
3515}
3516
e4cce94c 3517static int
96daf2b0 3518is_path_accessible(int xid, struct cifs_tcon *tcon,
e4cce94c
IM		 3519 struct cifs_sb_info *cifs_sb, const char *full_path)
3520{
3521 int rc;
e4cce94c
IM		 3522 FILE_ALL_INFO *pfile_info;
3523
e4cce94c
IM		 3524 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
3525 if (pfile_info == NULL)
3526 return -ENOMEM;
3527
3528 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
3529 0 /* not legacy */, cifs_sb->local_nls,
3530 cifs_sb->mnt_cifs_flags &
3531 CIFS_MOUNT_MAP_SPECIAL_CHR);
221d1d79
JL		 3532
3533 if (rc == -EOPNOTSUPP || rc == -EINVAL)
3534 rc = SMBQueryInformation(xid, tcon, full_path, pfile_info,
3535 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
3536 CIFS_MOUNT_MAP_SPECIAL_CHR);
e4cce94c
IM		 3537 kfree(pfile_info);
3538 return rc;
3539}
3540
b9bce2e9
JL		 3541static void
3542cleanup_volume_info_contents(struct smb_vol *volume_info)
1bfe73c2 3543{
b946845a 3544 kfree(volume_info->username);
1bfe73c2 3545 kzfree(volume_info->password);
13589c43
SF		 3546 if (volume_info->UNCip != volume_info->UNC + 2)
3547 kfree(volume_info->UNCip);
95c75454 3548 kfree(volume_info->UNC);
b946845a
SF		 3549 kfree(volume_info->domainname);
3550 kfree(volume_info->iocharset);
1bfe73c2 3551 kfree(volume_info->prepath);
b9bce2e9
JL		 3552}
3553
3554void
3555cifs_cleanup_volume_info(struct smb_vol *volume_info)
3556{
3557 if (!volume_info)
3558 return;
3559 cleanup_volume_info_contents(volume_info);
1bfe73c2 3560 kfree(volume_info);
1bfe73c2
IM		 3561}
3562
b9bce2e9 3563
2d6d589d 3564#ifdef CONFIG_CIFS_DFS_UPCALL
1bfe73c2
IM		 3565/* build_path_to_root returns full path to root when
3566 * we do not have an exiting connection (tcon) */
3567static char *
b2a0fa15 3568build_unc_path_to_root(const struct smb_vol *vol,
1bfe73c2
IM		 3569 const struct cifs_sb_info *cifs_sb)
3570{
b2a0fa15
JL		 3571 char *full_path, *pos;
3572 unsigned int pplen = vol->prepath ? strlen(vol->prepath) : 0;
3573 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
1bfe73c2 3574
b2a0fa15 3575 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
1bfe73c2
IM		 3576 if (full_path == NULL)
3577 return ERR_PTR(-ENOMEM);
3578
b2a0fa15
JL		 3579 strncpy(full_path, vol->UNC, unc_len);
3580 pos = full_path + unc_len;
3581
3582 if (pplen) {
3583 strncpy(pos, vol->prepath, pplen);
3584 pos += pplen;
3585 }
3586
3587 *pos = '\0'; /* add trailing null */
f87d39d9 3588 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
b2a0fa15 3589 cFYI(1, "%s: full_path=%s", __func__, full_path);
1bfe73c2
IM		 3590 return full_path;
3591}
dd613945
SF		 3592
3593/*
3594 * Perform a dfs referral query for a share and (optionally) prefix
3595 *
046462ab
SF		 3596 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3597 * to a string containing updated options for the submount. Otherwise it
3598 * will be left untouched.
dd613945
SF		 3599 *
3600 * Returns the rc from get_dfs_path to the caller, which can be used to
3601 * determine whether there were referrals.
3602 */
3603static int
96daf2b0 3604expand_dfs_referral(int xid, struct cifs_ses *pSesInfo,
dd613945 3605 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
046462ab 3606 int check_prefix)
dd613945
SF		 3607{
3608 int rc;
3609 unsigned int num_referrals = 0;
3610 struct dfs_info3_param *referrals = NULL;
3611 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3612
3613 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3614 if (IS_ERR(full_path))
3615 return PTR_ERR(full_path);
3616
3617 /* For DFS paths, skip the first '\' of the UNC */
3618 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3619
3620 rc = get_dfs_path(xid, pSesInfo , ref_path, cifs_sb->local_nls,
3621 &num_referrals, &referrals,
3622 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
3623
3624 if (!rc && num_referrals > 0) {
3625 char *fake_devname = NULL;
3626
3627 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3628 full_path + 1, referrals,
3629 &fake_devname);
3630
3631 free_dfs_info_array(referrals, num_referrals);
046462ab 3632
dd613945
SF		 3633 if (IS_ERR(mdata)) {
3634 rc = PTR_ERR(mdata);
3635 mdata = NULL;
b9bce2e9
JL		 3636 } else {
3637 cleanup_volume_info_contents(volume_info);
3638 memset(volume_info, '\0', sizeof(*volume_info));
3639 rc = cifs_setup_volume_info(volume_info, mdata,
3640 fake_devname);
dd613945 3641 }
b9bce2e9
JL		 3642 kfree(fake_devname);
3643 kfree(cifs_sb->mountdata);
046462ab 3644 cifs_sb->mountdata = mdata;
dd613945
SF		 3645 }
3646 kfree(full_path);
3647 return rc;
3648}
2d6d589d 3649#endif
1bfe73c2 3650
04db79b0
JL		 3651static int
3652cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3653 const char *devname)
1da177e4 3654{
724d9f1c 3655 int rc = 0;
1da177e4 3656
04db79b0
JL		 3657 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3658 return -EINVAL;
1da177e4 3659
23db65f5 3660
7586b765 3661 if (volume_info->nullauth) {
04febabc
JL		 3662 cFYI(1, "Anonymous login");
3663 kfree(volume_info->username);
3664 volume_info->username = NULL;
7586b765 3665 } else if (volume_info->username) {
1da177e4 3666 /* BB fixme parse for domain name here */
b6b38f70 3667 cFYI(1, "Username: %s", volume_info->username);
1da177e4 3668 } else {
bf820679 3669 cifserror("No username specified");
50c2f753
SF		 3670 /* In userspace mount helper we can get user name from alternate
3671 locations such as env variables and files on disk */
04db79b0 3672 return -EINVAL;
1da177e4
LT		 3673 }
3674
1da177e4 3675 /* this is needed for ASCII cp to Unicode converts */
7586b765 3676 if (volume_info->iocharset == NULL) {
a5fc4ce0
JL		 3677 /* load_nls_default cannot return null */
3678 volume_info->local_nls = load_nls_default();
1da177e4 3679 } else {
a5fc4ce0
JL		 3680 volume_info->local_nls = load_nls(volume_info->iocharset);
3681 if (volume_info->local_nls == NULL) {
b6b38f70
JP		 3682 cERROR(1, "CIFS mount error: iocharset %s not found",
3683 volume_info->iocharset);
04db79b0 3684 return -ELIBACC;
1da177e4
LT		 3685 }
3686 }
724d9f1c 3687
724d9f1c
PS		 3688 return rc;
3689}
3690
04db79b0
JL		 3691struct smb_vol *
3692cifs_get_volume_info(char *mount_data, const char *devname)
3693{
3694 int rc;
3695 struct smb_vol *volume_info;
3696
3697 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
3698 if (!volume_info)
3699 return ERR_PTR(-ENOMEM);
3700
3701 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3702 if (rc) {
3703 cifs_cleanup_volume_info(volume_info);
3704 volume_info = ERR_PTR(rc);
3705 }
3706
3707 return volume_info;
3708}
3709
724d9f1c 3710int
2c6292ae 3711cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
724d9f1c 3712{
1daaae8f 3713 int rc;
724d9f1c 3714 int xid;
96daf2b0
SF		 3715 struct cifs_ses *pSesInfo;
3716 struct cifs_tcon *tcon;
724d9f1c
PS		 3717 struct TCP_Server_Info *srvTcp;
3718 char *full_path;
3719 struct tcon_link *tlink;
3720#ifdef CONFIG_CIFS_DFS_UPCALL
3721 int referral_walks_count = 0;
20547490 3722#endif
dd854466
AV		 3723
3724 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3725 if (rc)
3726 return rc;
3727
20547490 3728#ifdef CONFIG_CIFS_DFS_UPCALL
724d9f1c
PS		 3729try_mount_again:
3730 /* cleanup activities if we're chasing a referral */
3731 if (referral_walks_count) {
3732 if (tcon)
3733 cifs_put_tcon(tcon);
3734 else if (pSesInfo)
3735 cifs_put_smb_ses(pSesInfo);
3736
724d9f1c
PS		 3737 FreeXid(xid);
3738 }
3739#endif
1daaae8f 3740 rc = 0;
724d9f1c
PS		 3741 tcon = NULL;
3742 pSesInfo = NULL;
3743 srvTcp = NULL;
3744 full_path = NULL;
3745 tlink = NULL;
3746
3747 xid = GetXid();
1da177e4 3748
63c038c2 3749 /* get a reference to a tcp session */
7586b765 3750 srvTcp = cifs_get_tcp_session(volume_info);
63c038c2
JL		 3751 if (IS_ERR(srvTcp)) {
3752 rc = PTR_ERR(srvTcp);
dd854466 3753 bdi_destroy(&cifs_sb->bdi);
63c038c2 3754 goto out;
1da177e4
LT		 3755 }
3756
36988c76
JL		 3757 /* get a reference to a SMB session */
3758 pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
3759 if (IS_ERR(pSesInfo)) {
3760 rc = PTR_ERR(pSesInfo);
3761 pSesInfo = NULL;
3762 goto mount_fail_check;
1da177e4 3763 }
50c2f753 3764
d00c28de
JL		 3765 /* search for existing tcon to this server share */
3766 tcon = cifs_get_tcon(pSesInfo, volume_info);
3767 if (IS_ERR(tcon)) {
3768 rc = PTR_ERR(tcon);
3769 tcon = NULL;
1bfe73c2 3770 goto remote_path_check;
d00c28de 3771 }
1bfe73c2 3772
d82c2df5 3773 /* tell server which Unix caps we support */
6848b733 3774 if (tcon->ses->capabilities & CAP_UNIX) {
d82c2df5
SF		 3775 /* reset of caps checks mount to see if unix extensions
3776 disabled for just this mount */
2c6292ae 3777 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
6848b733
SF		 3778 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3779 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3780 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3781 rc = -EACCES;
3782 goto mount_fail_check;
3783 }
3784 } else
d82c2df5 3785 tcon->unix_ext = 0; /* server does not support them */
c18c842b 3786
6848b733
SF		 3787 /* do not care if following two calls succeed - informational */
3788 if (!tcon->ipc) {
3789 CIFSSMBQFSDeviceInfo(xid, tcon);
3790 CIFSSMBQFSAttributeInfo(xid, tcon);
3791 }
3792
f7910cbd 3793 cifs_sb->wsize = cifs_negotiate_wsize(tcon, volume_info);
5eba8ab3 3794 cifs_sb->rsize = cifs_negotiate_rsize(tcon, volume_info);
f7910cbd 3795
66bfaadc 3796 /* tune readahead according to rsize */
8f71465c 3797 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
f7910cbd 3798
1bfe73c2 3799remote_path_check:
c1508ca2
SF		 3800#ifdef CONFIG_CIFS_DFS_UPCALL
3801 /*
3802 * Perform an unconditional check for whether there are DFS
3803 * referrals for this path without prefix, to provide support
3804 * for DFS referrals from w2k8 servers which don't seem to respond
3805 * with PATH_NOT_COVERED to requests that include the prefix.
3806 * Chase the referral if found, otherwise continue normally.
3807 */
3808 if (referral_walks_count == 0) {
3809 int refrc = expand_dfs_referral(xid, pSesInfo, volume_info,
046462ab 3810 cifs_sb, false);
c1508ca2
SF		 3811 if (!refrc) {
3812 referral_walks_count++;
3813 goto try_mount_again;
3814 }
3815 }
3816#endif
3817
f87d39d9 3818 /* check if a whole path is not remote */
70945643 3819 if (!rc && tcon) {
e4cce94c 3820 /* build_path_to_root works only when we have a valid tcon */
f87d39d9 3821 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
e4cce94c
IM		 3822 if (full_path == NULL) {
3823 rc = -ENOMEM;
3824 goto mount_fail_check;
3825 }
3826 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
03ceace5 3827 if (rc != 0 && rc != -EREMOTE) {
e4cce94c
IM		 3828 kfree(full_path);
3829 goto mount_fail_check;
3830 }
3831 kfree(full_path);
3832 }
3833
1bfe73c2
IM		 3834 /* get referral if needed */
3835 if (rc == -EREMOTE) {
d036f50f 3836#ifdef CONFIG_CIFS_DFS_UPCALL
5c2503a8
IM		 3837 if (referral_walks_count > MAX_NESTED_LINKS) {
3838 /*
3839 * BB: when we implement proper loop detection,
3840 * we will remove this check. But now we need it
3841 * to prevent an indefinite loop if 'DFS tree' is
3842 * misconfigured (i.e. has loops).
3843 */
3844 rc = -ELOOP;
3845 goto mount_fail_check;
3846 }
1bfe73c2 3847
dd613945 3848 rc = expand_dfs_referral(xid, pSesInfo, volume_info, cifs_sb,
046462ab 3849 true);
7b91e266 3850
dd613945 3851 if (!rc) {
5c2503a8 3852 referral_walks_count++;
1bfe73c2
IM		 3853 goto try_mount_again;
3854 }
dd613945 3855 goto mount_fail_check;
d036f50f
SF		 3856#else /* No DFS support, return error on mount */
3857 rc = -EOPNOTSUPP;
3858#endif
1bfe73c2
IM		 3859 }
3860
9d002df4
JL		 3861 if (rc)
3862 goto mount_fail_check;
3863
3864 /* now, hang the tcon off of the superblock */
3865 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3866 if (tlink == NULL) {
3867 rc = -ENOMEM;
3868 goto mount_fail_check;
3869 }
3870
b647c35f 3871 tlink->tl_uid = pSesInfo->linux_uid;
9d002df4
JL		 3872 tlink->tl_tcon = tcon;
3873 tlink->tl_time = jiffies;
3874 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3875 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3876
b647c35f 3877 cifs_sb->master_tlink = tlink;
9d002df4 3878 spin_lock(&cifs_sb->tlink_tree_lock);
b647c35f 3879 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
9d002df4 3880 spin_unlock(&cifs_sb->tlink_tree_lock);
413e661c 3881
da472fc8 3882 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
2de970ff
JL		 3883 TLINK_IDLE_EXPIRE);
3884
1bfe73c2
IM		 3885mount_fail_check:
3886 /* on error free sesinfo and tcon struct if needed */
3887 if (rc) {
1bfe73c2 3888 /* If find_unc succeeded then rc == 0 so we can not end */
25985edc 3889 /* up accidentally freeing someone elses tcon struct */
1bfe73c2
IM		 3890 if (tcon)
3891 cifs_put_tcon(tcon);
3892 else if (pSesInfo)
3893 cifs_put_smb_ses(pSesInfo);
3894 else
3895 cifs_put_tcp_session(srvTcp);
dd854466 3896 bdi_destroy(&cifs_sb->bdi);
1bfe73c2
IM		 3897 }
3898
70fe7dc0 3899out:
1da177e4
LT		 3900 FreeXid(xid);
3901 return rc;
3902}
3903
8d1bca32
JL		 3904/*
3905 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3906 * pointer may be NULL.
3907 */
1da177e4 3908int
96daf2b0
SF		 3909CIFSTCon(unsigned int xid, struct cifs_ses *ses,
3910 const char *tree, struct cifs_tcon *tcon,
1da177e4
LT		 3911 const struct nls_table *nls_codepage)
3912{
3913 struct smb_hdr *smb_buffer;
3914 struct smb_hdr *smb_buffer_response;
3915 TCONX_REQ *pSMB;
3916 TCONX_RSP *pSMBr;
3917 unsigned char *bcc_ptr;
3918 int rc = 0;
690c522f
JL		 3919 int length;
3920 __u16 bytes_left, count;
1da177e4
LT		 3921
3922 if (ses == NULL)
3923 return -EIO;
3924
3925 smb_buffer = cifs_buf_get();
ca43e3be 3926 if (smb_buffer == NULL)
1da177e4 3927 return -ENOMEM;
ca43e3be 3928
1da177e4
LT		 3929 smb_buffer_response = smb_buffer;
3930
3931 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3932 NULL /*no tid */ , 4 /*wct */ );
1982c344
SF		 3933
3934 smb_buffer->Mid = GetNextMid(ses->server);
1da177e4
LT		 3935 smb_buffer->Uid = ses->Suid;
3936 pSMB = (TCONX_REQ *) smb_buffer;
3937 pSMBr = (TCONX_RSP *) smb_buffer_response;
3938
3939 pSMB->AndXCommand = 0xFF;
3940 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
1da177e4 3941 bcc_ptr = &pSMB->Password[0];
8d1bca32 3942 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
eeac8047 3943 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
7c7b25bc 3944 *bcc_ptr = 0; /* password is null byte */
eeac8047 3945 bcc_ptr++; /* skip password */
7c7b25bc 3946 /* already aligned so no need to do it below */
eeac8047 3947 } else {
540b2e37 3948 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
eeac8047
SF		 3949 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3950 specified as required (when that support is added to
3951 the vfs in the future) as only NTLM or the much
7c7b25bc 3952 weaker LANMAN (which we do not send by default) is accepted
eeac8047
SF		 3953 by Samba (not sure whether other servers allow
3954 NTLMv2 password here) */
7c7b25bc 3955#ifdef CONFIG_CIFS_WEAK_PW_HASH
04912d6a 3956 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
00e485b0 3957 (ses->server->secType == LANMAN))
d3ba50b1 3958 calc_lanman_hash(tcon->password, ses->server->cryptkey,
96daf2b0 3959 ses->server->sec_mode &
4e53a3fb
JL		 3960 SECMODE_PW_ENCRYPT ? true : false,
3961 bcc_ptr);
7c7b25bc
SF		 3962 else
3963#endif /* CIFS_WEAK_PW_HASH */
ee2c9258 3964 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
9ef5992e 3965 bcc_ptr, nls_codepage);
eeac8047 3966
540b2e37 3967 bcc_ptr += CIFS_AUTH_RESP_SIZE;
fb8c4b14 3968 if (ses->capabilities & CAP_UNICODE) {
7c7b25bc
SF		 3969 /* must align unicode strings */
3970 *bcc_ptr = 0; /* null byte password */
3971 bcc_ptr++;
3972 }
eeac8047 3973 }
1da177e4 3974
96daf2b0 3975 if (ses->server->sec_mode &
a878fb22 3976 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1da177e4
LT		 3977 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3978
3979 if (ses->capabilities & CAP_STATUS32) {
3980 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3981 }
3982 if (ses->capabilities & CAP_DFS) {
3983 smb_buffer->Flags2 |= SMBFLG2_DFS;
3984 }
3985 if (ses->capabilities & CAP_UNICODE) {
3986 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3987 length =
acbbb76a 3988 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
50c2f753 3989 6 /* max utf8 char length in bytes */ *
a878fb22
SF		 3990 (/* server len*/ + 256 /* share len */), nls_codepage);
3991 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
1da177e4
LT		 3992 bcc_ptr += 2; /* skip trailing null */
3993 } else { /* ASCII */
1da177e4
LT		 3994 strcpy(bcc_ptr, tree);
3995 bcc_ptr += strlen(tree) + 1;
3996 }
3997 strcpy(bcc_ptr, "?????");
3998 bcc_ptr += strlen("?????");
3999 bcc_ptr += 1;
4000 count = bcc_ptr - &pSMB->Password[0];
be8e3b00
SF		 4001 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
4002 pSMB->hdr.smb_buf_length) + count);
1da177e4
LT		 4003 pSMB->ByteCount = cpu_to_le16(count);
4004
133672ef 4005 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
7749981e 4006 0);
1da177e4 4007
1da177e4
LT		 4008 /* above now done in SendReceive */
4009 if ((rc == 0) && (tcon != NULL)) {
0e0d2cf3
SF		 4010 bool is_unicode;
4011
1da177e4 4012 tcon->tidStatus = CifsGood;
3b795210 4013 tcon->need_reconnect = false;
1da177e4
LT		 4014 tcon->tid = smb_buffer_response->Tid;
4015 bcc_ptr = pByteArea(smb_buffer_response);
690c522f 4016 bytes_left = get_bcc(smb_buffer_response);
cc20c031 4017 length = strnlen(bcc_ptr, bytes_left - 2);
0e0d2cf3
SF		 4018 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
4019 is_unicode = true;
4020 else
4021 is_unicode = false;
4022
cc20c031 4023
50c2f753 4024 /* skip service field (NB: this field is always ASCII) */
7f8ed420
SF		 4025 if (length == 3) {
4026 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
4027 (bcc_ptr[2] == 'C')) {
b6b38f70 4028 cFYI(1, "IPC connection");
7f8ed420
SF		 4029 tcon->ipc = 1;
4030 }
4031 } else if (length == 2) {
4032 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
4033 /* the most common case */
b6b38f70 4034 cFYI(1, "disk share connection");
7f8ed420
SF		 4035 }
4036 }
50c2f753 4037 bcc_ptr += length + 1;
cc20c031 4038 bytes_left -= (length + 1);
1da177e4 4039 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
cc20c031
JL		 4040
4041 /* mostly informational -- no need to fail on error here */
90a98b2f 4042 kfree(tcon->nativeFileSystem);
acbbb76a 4043 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
0e0d2cf3 4044 bytes_left, is_unicode,
cc20c031
JL		 4045 nls_codepage);
4046
b6b38f70 4047 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
cc20c031 4048
fb8c4b14 4049 if ((smb_buffer_response->WordCount == 3) ||
1a4e15a0
SF		 4050 (smb_buffer_response->WordCount == 7))
4051 /* field is in same location */
3979877e
SF		 4052 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
4053 else
4054 tcon->Flags = 0;
b6b38f70 4055 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
1da177e4 4056 } else if ((rc == 0) && tcon == NULL) {
50c2f753 4057 /* all we need to save for IPC$ connection */
1da177e4
LT		 4058 ses->ipc_tid = smb_buffer_response->Tid;
4059 }
4060
a8a11d39 4061 cifs_buf_release(smb_buffer);
1da177e4
LT		 4062 return rc;
4063}
4064
2a9b9951
AV		 4065void
4066cifs_umount(struct cifs_sb_info *cifs_sb)
1da177e4 4067{
b647c35f
JL		 4068 struct rb_root *root = &cifs_sb->tlink_tree;
4069 struct rb_node *node;
4070 struct tcon_link *tlink;
9d002df4 4071
2de970ff
JL		 4072 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
4073
b647c35f
JL		 4074 spin_lock(&cifs_sb->tlink_tree_lock);
4075 while ((node = rb_first(root))) {
4076 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4077 cifs_get_tlink(tlink);
4078 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4079 rb_erase(node, root);
1da177e4 4080
b647c35f
JL		 4081 spin_unlock(&cifs_sb->tlink_tree_lock);
4082 cifs_put_tlink(tlink);
4083 spin_lock(&cifs_sb->tlink_tree_lock);
4084 }
4085 spin_unlock(&cifs_sb->tlink_tree_lock);
50c2f753 4086
dd854466 4087 bdi_destroy(&cifs_sb->bdi);
d757d71b
AV		 4088 kfree(cifs_sb->mountdata);
4089 unload_nls(cifs_sb->local_nls);
4090 kfree(cifs_sb);
50c2f753 4091}
1da177e4 4092
96daf2b0 4093int cifs_negotiate_protocol(unsigned int xid, struct cifs_ses *ses)
1da177e4
LT		 4094{
4095 int rc = 0;
198b5682 4096 struct TCP_Server_Info *server = ses->server;
1da177e4 4097
198b5682
JL		 4098 /* only send once per connect */
4099 if (server->maxBuf != 0)
4100 return 0;
4101
2d86dbc9 4102 cifs_set_credits(server, 1);
198b5682
JL		 4103 rc = CIFSSMBNegotiate(xid, ses);
4104 if (rc == -EAGAIN) {
4105 /* retry only once on 1st time connection */
2d86dbc9 4106 cifs_set_credits(server, 1);
198b5682
JL		 4107 rc = CIFSSMBNegotiate(xid, ses);
4108 if (rc == -EAGAIN)
4109 rc = -EHOSTDOWN;
1da177e4 4110 }
198b5682
JL		 4111 if (rc == 0) {
4112 spin_lock(&GlobalMid_Lock);
7fdbaa1b 4113 if (server->tcpStatus == CifsNeedNegotiate)
198b5682
JL		 4114 server->tcpStatus = CifsGood;
4115 else
4116 rc = -EHOSTDOWN;
4117 spin_unlock(&GlobalMid_Lock);
26b994fa 4118
198b5682
JL		 4119 }
4120
4121 return rc;
4122}
4123
4124
96daf2b0 4125int cifs_setup_session(unsigned int xid, struct cifs_ses *ses,
198b5682
JL		 4126 struct nls_table *nls_info)
4127{
4128 int rc = 0;
4129 struct TCP_Server_Info *server = ses->server;
26b994fa 4130
198b5682
JL		 4131 ses->flags = 0;
4132 ses->capabilities = server->capabilities;
26b994fa 4133 if (linuxExtEnabled == 0)
198b5682 4134 ses->capabilities &= (~CAP_UNIX);
20418acd 4135
b6b38f70 4136 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
96daf2b0 4137 server->sec_mode, server->capabilities, server->timeAdj);
cb7691b6 4138
198b5682 4139 rc = CIFS_SessSetup(xid, ses, nls_info);
26b994fa 4140 if (rc) {
b6b38f70 4141 cERROR(1, "Send error in SessSetup = %d", rc);
26b994fa 4142 } else {
5d0d2882
SP		 4143 mutex_lock(&ses->server->srv_mutex);
4144 if (!server->session_estab) {
21e73393 4145 server->session_key.response = ses->auth_key.response;
5d0d2882 4146 server->session_key.len = ses->auth_key.len;
21e73393
SP		 4147 server->sequence_number = 0x2;
4148 server->session_estab = true;
4149 ses->auth_key.response = NULL;
5d0d2882
SP		 4150 }
4151 mutex_unlock(&server->srv_mutex);
4152
b6b38f70 4153 cFYI(1, "CIFS Session Established successfully");
20418acd 4154 spin_lock(&GlobalMid_Lock);
198b5682
JL		 4155 ses->status = CifsGood;
4156 ses->need_reconnect = false;
20418acd 4157 spin_unlock(&GlobalMid_Lock);
1da177e4 4158 }
26b994fa 4159
21e73393
SP		 4160 kfree(ses->auth_key.response);
4161 ses->auth_key.response = NULL;
4162 ses->auth_key.len = 0;
d3686d54
SP		 4163 kfree(ses->ntlmssp);
4164 ses->ntlmssp = NULL;
21e73393 4165
1da177e4
LT		 4166 return rc;
4167}
4168
8a8798a5
JL		 4169static int
4170cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
4171{
4172 switch (ses->server->secType) {
4173 case Kerberos:
4174 vol->secFlg = CIFSSEC_MUST_KRB5;
4175 return 0;
4176 case NTLMv2:
4177 vol->secFlg = CIFSSEC_MUST_NTLMV2;
4178 break;
4179 case NTLM:
4180 vol->secFlg = CIFSSEC_MUST_NTLM;
4181 break;
4182 case RawNTLMSSP:
4183 vol->secFlg = CIFSSEC_MUST_NTLMSSP;
4184 break;
4185 case LANMAN:
4186 vol->secFlg = CIFSSEC_MUST_LANMAN;
4187 break;
4188 }
4189
4190 return cifs_set_cifscreds(vol, ses);
4191}
4192
96daf2b0 4193static struct cifs_tcon *
9d002df4
JL		 4194cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
4195{
8a8798a5 4196 int rc;
96daf2b0
SF		 4197 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4198 struct cifs_ses *ses;
4199 struct cifs_tcon *tcon = NULL;
9d002df4 4200 struct smb_vol *vol_info;
9d002df4
JL		 4201
4202 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
803ab977
DC		 4203 if (vol_info == NULL)
4204 return ERR_PTR(-ENOMEM);
9d002df4 4205
9d002df4
JL		 4206 vol_info->local_nls = cifs_sb->local_nls;
4207 vol_info->linux_uid = fsuid;
4208 vol_info->cred_uid = fsuid;
4209 vol_info->UNC = master_tcon->treeName;
4210 vol_info->retry = master_tcon->retry;
4211 vol_info->nocase = master_tcon->nocase;
4212 vol_info->local_lease = master_tcon->local_lease;
4213 vol_info->no_linux_ext = !master_tcon->unix_ext;
4214
8a8798a5
JL		 4215 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4216 if (rc) {
4217 tcon = ERR_PTR(rc);
4218 goto out;
4219 }
9d002df4
JL		 4220
4221 /* get a reference for the same TCP session */
3f9bcca7 4222 spin_lock(&cifs_tcp_ses_lock);
9d002df4 4223 ++master_tcon->ses->server->srv_count;
3f9bcca7 4224 spin_unlock(&cifs_tcp_ses_lock);
9d002df4
JL		 4225
4226 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4227 if (IS_ERR(ses)) {
96daf2b0 4228 tcon = (struct cifs_tcon *)ses;
9d002df4
JL		 4229 cifs_put_tcp_session(master_tcon->ses->server);
4230 goto out;
4231 }
4232
4233 tcon = cifs_get_tcon(ses, vol_info);
4234 if (IS_ERR(tcon)) {
4235 cifs_put_smb_ses(ses);
4236 goto out;
4237 }
4238
4239 if (ses->capabilities & CAP_UNIX)
4240 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4241out:
8a8798a5
JL		 4242 kfree(vol_info->username);
4243 kfree(vol_info->password);
9d002df4
JL		 4244 kfree(vol_info);
4245
4246 return tcon;
4247}
4248
96daf2b0 4249struct cifs_tcon *
9d002df4
JL		 4250cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4251{
4252 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4253}
4254
4255static int
4256cifs_sb_tcon_pending_wait(void *unused)
4257{
4258 schedule();
4259 return signal_pending(current) ? -ERESTARTSYS : 0;
4260}
4261
b647c35f
JL		 4262/* find and return a tlink with given uid */
4263static struct tcon_link *
4264tlink_rb_search(struct rb_root *root, uid_t uid)
4265{
4266 struct rb_node *node = root->rb_node;
4267 struct tcon_link *tlink;
4268
4269 while (node) {
4270 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4271
4272 if (tlink->tl_uid > uid)
4273 node = node->rb_left;
4274 else if (tlink->tl_uid < uid)
4275 node = node->rb_right;
4276 else
4277 return tlink;
4278 }
4279 return NULL;
4280}
4281
4282/* insert a tcon_link into the tree */
4283static void
4284tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4285{
4286 struct rb_node **new = &(root->rb_node), *parent = NULL;
4287 struct tcon_link *tlink;
4288
4289 while (*new) {
4290 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4291 parent = *new;
4292
4293 if (tlink->tl_uid > new_tlink->tl_uid)
4294 new = &((*new)->rb_left);
4295 else
4296 new = &((*new)->rb_right);
4297 }
4298
4299 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4300 rb_insert_color(&new_tlink->tl_rbnode, root);
4301}
4302
9d002df4
JL		 4303/*
4304 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4305 * current task.
4306 *
4307 * If the superblock doesn't refer to a multiuser mount, then just return
4308 * the master tcon for the mount.
4309 *
6ef933a3 4310 * First, search the rbtree for an existing tcon for this fsuid. If one
9d002df4
JL		 4311 * exists, then check to see if it's pending construction. If it is then wait
4312 * for construction to complete. Once it's no longer pending, check to see if
4313 * it failed and either return an error or retry construction, depending on
4314 * the timeout.
4315 *
4316 * If one doesn't exist then insert a new tcon_link struct into the tree and
4317 * try to construct a new one.
4318 */
4319struct tcon_link *
4320cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4321{
4322 int ret;
b647c35f 4323 uid_t fsuid = current_fsuid();
9d002df4
JL		 4324 struct tcon_link *tlink, *newtlink;
4325
4326 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4327 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4328
4329 spin_lock(&cifs_sb->tlink_tree_lock);
b647c35f 4330 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
9d002df4
JL		 4331 if (tlink)
4332 cifs_get_tlink(tlink);
4333 spin_unlock(&cifs_sb->tlink_tree_lock);
4334
4335 if (tlink == NULL) {
4336 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4337 if (newtlink == NULL)
4338 return ERR_PTR(-ENOMEM);
b647c35f 4339 newtlink->tl_uid = fsuid;
9d002df4
JL		 4340 newtlink->tl_tcon = ERR_PTR(-EACCES);
4341 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4342 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4343 cifs_get_tlink(newtlink);
4344
9d002df4
JL		 4345 spin_lock(&cifs_sb->tlink_tree_lock);
4346 /* was one inserted after previous search? */
b647c35f 4347 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
9d002df4
JL		 4348 if (tlink) {
4349 cifs_get_tlink(tlink);
4350 spin_unlock(&cifs_sb->tlink_tree_lock);
9d002df4
JL		 4351 kfree(newtlink);
4352 goto wait_for_construction;
4353 }
9d002df4 4354 tlink = newtlink;
b647c35f
JL		 4355 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4356 spin_unlock(&cifs_sb->tlink_tree_lock);
9d002df4
JL		 4357 } else {
4358wait_for_construction:
4359 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4360 cifs_sb_tcon_pending_wait,
4361 TASK_INTERRUPTIBLE);
4362 if (ret) {
4363 cifs_put_tlink(tlink);
4364 return ERR_PTR(ret);
4365 }
4366
4367 /* if it's good, return it */
4368 if (!IS_ERR(tlink->tl_tcon))
4369 return tlink;
4370
4371 /* return error if we tried this already recently */
4372 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4373 cifs_put_tlink(tlink);
4374 return ERR_PTR(-EACCES);
4375 }
4376
4377 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4378 goto wait_for_construction;
4379 }
4380
4381 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4382 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4383 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4384
4385 if (IS_ERR(tlink->tl_tcon)) {
4386 cifs_put_tlink(tlink);
4387 return ERR_PTR(-EACCES);
4388 }
4389
4390 return tlink;
4391}
2de970ff
JL		 4392
4393/*
4394 * periodic workqueue job that scans tcon_tree for a superblock and closes
4395 * out tcons.
4396 */
4397static void
4398cifs_prune_tlinks(struct work_struct *work)
4399{
4400 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4401 prune_tlinks.work);
b647c35f
JL		 4402 struct rb_root *root = &cifs_sb->tlink_tree;
4403 struct rb_node *node = rb_first(root);
4404 struct rb_node *tmp;
4405 struct tcon_link *tlink;
2de970ff 4406
b647c35f
JL		 4407 /*
4408 * Because we drop the spinlock in the loop in order to put the tlink
4409 * it's not guarded against removal of links from the tree. The only
4410 * places that remove entries from the tree are this function and
4411 * umounts. Because this function is non-reentrant and is canceled
4412 * before umount can proceed, this is safe.
4413 */
4414 spin_lock(&cifs_sb->tlink_tree_lock);
4415 node = rb_first(root);
4416 while (node != NULL) {
4417 tmp = node;
4418 node = rb_next(tmp);
4419 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4420
4421 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4422 atomic_read(&tlink->tl_count) != 0 ||
4423 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4424 continue;
2de970ff 4425
b647c35f
JL		 4426 cifs_get_tlink(tlink);
4427 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4428 rb_erase(tmp, root);
4429
4430 spin_unlock(&cifs_sb->tlink_tree_lock);
4431 cifs_put_tlink(tlink);
4432 spin_lock(&cifs_sb->tlink_tree_lock);
4433 }
4434 spin_unlock(&cifs_sb->tlink_tree_lock);
2de970ff 4435
da472fc8 4436 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
2de970ff
JL		 4437 TLINK_IDLE_EXPIRE);
4438}
Linux kernel - Deliverables
This page took 2.155588 seconds and 5 git commands to generate.