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