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