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