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