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