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