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