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