4 * Copyright (C) International Business Machines Corp., 2002,2009
5 * Author(s): Steve French (sfrench@us.ibm.com)
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.
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.
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
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>
43 #include "cifsproto.h"
44 #include "cifs_unicode.h"
45 #include "cifs_debug.h"
46 #include "cifs_fs_sb.h"
49 #include "rfc1002pdu.h"
53 #define RFC1001_PORT 139
55 /* SMB echo "timeout" -- FIXME: tunable? */
56 #define SMB_ECHO_INTERVAL (60 * HZ)
58 extern mempool_t
*cifs_req_poolp
;
60 /* FIXME: should these be tunable? */
61 #define TLINK_ERROR_EXPIRE (1 * HZ)
62 #define TLINK_IDLE_EXPIRE (600 * HZ)
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
,
72 * cifs tcp session reconnection
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)
80 cifs_reconnect(struct TCP_Server_Info
*server
)
83 struct list_head
*tmp
, *tmp2
;
85 struct cifs_tcon
*tcon
;
86 struct mid_q_entry
*mid_entry
;
87 struct list_head retry_list
;
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
);
96 server
->tcpStatus
= CifsNeedReconnect
;
97 spin_unlock(&GlobalMid_Lock
);
100 cFYI(1, "Reconnecting tcp session");
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;
110 list_for_each(tmp2
, &ses
->tcon_list
) {
111 tcon
= list_entry(tmp2
, struct cifs_tcon
, tcon_list
);
112 tcon
->need_reconnect
= true;
115 spin_unlock(&cifs_tcp_ses_lock
);
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
;
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
);
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
);
148 spin_unlock(&GlobalMid_Lock
);
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
);
160 /* we should try only the port we connected to before */
161 rc
= generic_ip_connect(server
);
163 cFYI(1, "reconnect error %d", rc
);
166 atomic_inc(&tcpSesReconnectCount
);
167 spin_lock(&GlobalMid_Lock
);
168 if (server
->tcpStatus
!= CifsExiting
)
169 server
->tcpStatus
= CifsNeedNegotiate
;
170 spin_unlock(&GlobalMid_Lock
);
172 } while (server
->tcpStatus
== CifsNeedReconnect
);
179 0 not a transact2, or all data present
180 >0 transact2 with that much data missing
181 -EINVAL = invalid transact2
184 static int check2ndT2(struct smb_hdr
*pSMB
)
186 struct smb_t2_rsp
*pSMBt
;
188 __u16 total_data_size
, data_in_this_rsp
;
190 if (pSMB
->Command
!= SMB_COM_TRANSACTION2
)
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");
200 pSMBt
= (struct smb_t2_rsp
*)pSMB
;
202 total_data_size
= get_unaligned_le16(&pSMBt
->t2_rsp
.TotalDataCount
);
203 data_in_this_rsp
= get_unaligned_le16(&pSMBt
->t2_rsp
.DataCount
);
205 if (total_data_size
== data_in_this_rsp
)
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
);
213 remaining
= total_data_size
- data_in_this_rsp
;
215 cFYI(1, "missing %d bytes from transact2, check next response",
217 if (total_data_size
> CIFSMaxBufSize
) {
218 cERROR(1, "TotalDataSize %d is over maximum buffer %d",
219 total_data_size
, CIFSMaxBufSize
);
225 static int coalesce_t2(struct smb_hdr
*psecond
, struct smb_hdr
*pTargetSMB
)
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
;
232 unsigned int byte_count
, total_in_buf
;
233 __u16 total_data_size
, total_in_buf2
;
235 total_data_size
= get_unaligned_le16(&pSMBt
->t2_rsp
.TotalDataCount
);
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");
241 total_in_buf
= get_unaligned_le16(&pSMBt
->t2_rsp
.DataCount
);
243 remaining
= total_data_size
- total_in_buf
;
248 if (remaining
== 0) /* nothing to do, ignore */
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");
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 */
261 data_area_of_buf2
= (char *)&pSMB2
->hdr
.Protocol
+
262 get_unaligned_le16(&pSMB2
->t2_rsp
.DataOffset
);
264 data_area_of_target
+= total_in_buf
;
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
)
271 put_unaligned_le16(total_in_buf
, &pSMBt
->t2_rsp
.DataCount
);
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
)
279 put_bcc(byte_count
, pTargetSMB
);
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
)
286 pTargetSMB
->smb_buf_length
= cpu_to_be32(byte_count
);
288 memcpy(data_area_of_target
, data_area_of_buf2
, total_in_buf2
);
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 */
298 cifs_echo_request(struct work_struct
*work
)
301 struct TCP_Server_Info
*server
= container_of(work
,
302 struct TCP_Server_Info
, echo
.work
);
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
309 if (server
->maxBuf
== 0 ||
310 time_before(jiffies
, server
->lstrp
+ SMB_ECHO_INTERVAL
- HZ
))
313 rc
= CIFSSMBEcho(server
);
315 cFYI(1, "Unable to send echo request to server: %s",
319 queue_delayed_work(system_nrt_wq
, &server
->echo
, SMB_ECHO_INTERVAL
);
323 allocate_buffers(char **bigbuf
, char **smallbuf
, unsigned int size
,
326 char *bbuf
= *bigbuf
, *sbuf
= *smallbuf
;
329 bbuf
= (char *)cifs_buf_get();
331 cERROR(1, "No memory for large SMB response");
333 /* retry will check if exiting */
336 } else if (is_large_buf
) {
337 /* we are reusing a dirty large buf, clear its start */
338 memset(bbuf
, 0, size
);
342 sbuf
= (char *)cifs_small_buf_get();
344 cERROR(1, "No memory for SMB response");
346 /* retry will check if exiting */
349 /* beginning of smb buffer is cleared in our buf_get */
351 /* if existing small buf clear beginning */
352 memset(sbuf
, 0, size
);
362 server_unresponsive(struct TCP_Server_Info
*server
)
364 if (echo_retries
> 0 && server
->tcpStatus
== CifsGood
&&
365 time_after(jiffies
, server
->lstrp
+
366 (echo_retries
* SMB_ECHO_INTERVAL
))) {
367 cERROR(1, "Server %s has not responded in %d seconds. "
368 "Reconnecting...", server
->hostname
,
369 (echo_retries
* SMB_ECHO_INTERVAL
/ HZ
));
370 cifs_reconnect(server
);
371 wake_up(&server
->response_q
);
379 read_from_socket(struct TCP_Server_Info
*server
,
380 struct kvec
*iov
, unsigned int to_read
,
381 unsigned int *ptotal_read
, bool is_header_read
)
384 unsigned int total_read
;
385 struct msghdr smb_msg
;
386 char *buf
= iov
->iov_base
;
388 smb_msg
.msg_control
= NULL
;
389 smb_msg
.msg_controllen
= 0;
391 for (total_read
= 0; total_read
< to_read
; total_read
+= length
) {
392 if (server_unresponsive(server
)) {
397 length
= kernel_recvmsg(server
->ssocket
, &smb_msg
, iov
, 1,
398 to_read
- total_read
, 0);
399 if (server
->tcpStatus
== CifsExiting
) {
403 } else if (server
->tcpStatus
== CifsNeedReconnect
) {
404 cifs_reconnect(server
);
405 /* Reconnect wakes up rspns q */
406 /* Now we will reread sock */
409 } else if (length
== -ERESTARTSYS
||
413 * Minimum sleep to prevent looping, allowing socket
414 * to clear and app threads to set tcpStatus
415 * CifsNeedReconnect if server hung.
417 usleep_range(1000, 2000);
421 /* Special handling for header read */
423 iov
->iov_base
= (to_read
- total_read
) +
425 iov
->iov_len
= to_read
- total_read
;
430 } else if (length
<= 0) {
431 cERROR(1, "Received no data, expecting %d",
432 to_read
- total_read
);
433 cifs_reconnect(server
);
439 *ptotal_read
= total_read
;
444 check_rfc1002_header(struct TCP_Server_Info
*server
, char *buf
)
447 unsigned int pdu_length
= be32_to_cpu(
448 ((struct smb_hdr
*)buf
)->smb_buf_length
);
451 * The first byte big endian of the length field,
452 * is actually not part of the length but the type
453 * with the most common, zero, as regular data.
455 if (temp
== (char) RFC1002_SESSION_KEEP_ALIVE
) {
457 } else if (temp
== (char)RFC1002_POSITIVE_SESSION_RESPONSE
) {
458 cFYI(1, "Good RFC 1002 session rsp");
460 } else if (temp
== (char)RFC1002_NEGATIVE_SESSION_RESPONSE
) {
462 * We get this from Windows 98 instead of an error on
463 * SMB negprot response.
465 cFYI(1, "Negative RFC1002 Session Response Error 0x%x)",
467 /* give server a second to clean up */
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
475 cifs_set_port((struct sockaddr
*)
476 &server
->dstaddr
, CIFS_PORT
);
477 cifs_reconnect(server
);
478 wake_up(&server
->response_q
);
480 } else if (temp
!= (char) 0) {
481 cERROR(1, "Unknown RFC 1002 frame");
482 cifs_dump_mem(" Received Data: ", buf
, 4);
483 cifs_reconnect(server
);
487 /* else we have an SMB response */
488 if ((pdu_length
> CIFSMaxBufSize
+ MAX_CIFS_HDR_SIZE
- 4) ||
489 (pdu_length
< sizeof(struct smb_hdr
) - 1 - 4)) {
490 cERROR(1, "Invalid size SMB length %d pdu_length %d",
492 cifs_reconnect(server
);
493 wake_up(&server
->response_q
);
500 static struct mid_q_entry
*
501 find_cifs_mid(struct TCP_Server_Info
*server
, struct smb_hdr
*buf
,
502 int *length
, bool is_large_buf
, bool *is_multi_rsp
, char **bigbuf
)
504 struct mid_q_entry
*mid
= NULL
, *tmp_mid
, *ret
= NULL
;
506 spin_lock(&GlobalMid_Lock
);
507 list_for_each_entry_safe(mid
, tmp_mid
, &server
->pending_mid_q
, qhead
) {
508 if (mid
->mid
!= buf
->Mid
||
509 mid
->midState
!= MID_REQUEST_SUBMITTED
||
510 mid
->command
!= buf
->Command
)
513 if (*length
== 0 && check2ndT2(buf
) > 0) {
514 /* We have a multipart transact2 resp */
515 *is_multi_rsp
= true;
517 /* merge response - fix up 1st*/
518 *length
= coalesce_t2(buf
, mid
->resp_buf
);
521 mid
->multiRsp
= true;
524 /* All parts received or packet is malformed. */
525 mid
->multiEnd
= true;
529 /*FIXME: switch to already allocated largebuf?*/
530 cERROR(1, "1st trans2 resp needs bigbuf");
532 /* Have first buffer */
534 mid
->largeBuf
= true;
540 mid
->largeBuf
= is_large_buf
;
543 mid
->midState
= MID_RESPONSE_RECEIVED
;
545 mid
->midState
= MID_RESPONSE_MALFORMED
;
546 #ifdef CONFIG_CIFS_STATS2
547 mid
->when_received
= jiffies
;
549 list_del_init(&mid
->qhead
);
553 spin_unlock(&GlobalMid_Lock
);
558 static void clean_demultiplex_info(struct TCP_Server_Info
*server
)
562 /* take it off the list, if it's not already */
563 spin_lock(&cifs_tcp_ses_lock
);
564 list_del_init(&server
->tcp_ses_list
);
565 spin_unlock(&cifs_tcp_ses_lock
);
567 spin_lock(&GlobalMid_Lock
);
568 server
->tcpStatus
= CifsExiting
;
569 spin_unlock(&GlobalMid_Lock
);
570 wake_up_all(&server
->response_q
);
573 * Check if we have blocked requests that need to free. Note that
574 * cifs_max_pending is normally 50, but can be set at module install
575 * time to as little as two.
577 spin_lock(&GlobalMid_Lock
);
578 if (atomic_read(&server
->inFlight
) >= cifs_max_pending
)
579 atomic_set(&server
->inFlight
, cifs_max_pending
- 1);
581 * We do not want to set the max_pending too low or we could end up
582 * with the counter going negative.
584 spin_unlock(&GlobalMid_Lock
);
586 * Although there should not be any requests blocked on this queue it
587 * can not hurt to be paranoid and try to wake up requests that may
588 * haven been blocked when more than 50 at time were on the wire to the
589 * same server - they now will see the session is in exit state and get
590 * out of SendReceive.
592 wake_up_all(&server
->request_q
);
593 /* give those requests time to exit */
596 if (server
->ssocket
) {
597 sock_release(server
->ssocket
);
598 server
->ssocket
= NULL
;
601 if (!list_empty(&server
->pending_mid_q
)) {
602 struct list_head dispose_list
;
603 struct mid_q_entry
*mid_entry
;
604 struct list_head
*tmp
, *tmp2
;
606 INIT_LIST_HEAD(&dispose_list
);
607 spin_lock(&GlobalMid_Lock
);
608 list_for_each_safe(tmp
, tmp2
, &server
->pending_mid_q
) {
609 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
610 cFYI(1, "Clearing mid 0x%x", mid_entry
->mid
);
611 mid_entry
->midState
= MID_SHUTDOWN
;
612 list_move(&mid_entry
->qhead
, &dispose_list
);
614 spin_unlock(&GlobalMid_Lock
);
616 /* now walk dispose list and issue callbacks */
617 list_for_each_safe(tmp
, tmp2
, &dispose_list
) {
618 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
619 cFYI(1, "Callback mid 0x%x", mid_entry
->mid
);
620 list_del_init(&mid_entry
->qhead
);
621 mid_entry
->callback(mid_entry
);
623 /* 1/8th of sec is more than enough time for them to exit */
627 if (!list_empty(&server
->pending_mid_q
)) {
629 * mpx threads have not exited yet give them at least the smb
630 * send timeout time for long ops.
632 * Due to delays on oplock break requests, we need to wait at
633 * least 45 seconds before giving up on a request getting a
634 * response and going ahead and killing cifsd.
636 cFYI(1, "Wait for exit from demultiplex thread");
639 * If threads still have not exited they are probably never
640 * coming home not much else we can do but free the memory.
644 kfree(server
->hostname
);
647 length
= atomic_dec_return(&tcpSesAllocCount
);
649 mempool_resize(cifs_req_poolp
, length
+ cifs_min_rcv
,
654 cifs_demultiplex_thread(void *p
)
657 struct TCP_Server_Info
*server
= p
;
658 unsigned int pdu_length
, total_read
;
659 char *buf
= NULL
, *bigbuf
= NULL
, *smallbuf
= NULL
;
660 struct smb_hdr
*smb_buffer
= NULL
;
662 struct task_struct
*task_to_wake
= NULL
;
663 struct mid_q_entry
*mid_entry
;
664 bool isLargeBuf
= false;
665 bool isMultiRsp
= false;
668 current
->flags
|= PF_MEMALLOC
;
669 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current
));
671 length
= atomic_inc_return(&tcpSesAllocCount
);
673 mempool_resize(cifs_req_poolp
, length
+ cifs_min_rcv
,
677 while (server
->tcpStatus
!= CifsExiting
) {
681 if (!allocate_buffers(&bigbuf
, &smallbuf
,
682 sizeof(struct smb_hdr
), isLargeBuf
))
687 smb_buffer
= (struct smb_hdr
*)smallbuf
;
691 pdu_length
= 4; /* enough to get RFC1001 header */
694 rc
= read_from_socket(server
, &iov
, pdu_length
,
695 &total_read
, true /* header read */);
704 * The right amount was read from socket - 4 bytes,
705 * so we can now interpret the length field.
707 pdu_length
= be32_to_cpu(smb_buffer
->smb_buf_length
);
709 cFYI(1, "rfc1002 length 0x%x", pdu_length
+4);
710 if (!check_rfc1002_header(server
, buf
))
714 if (pdu_length
> MAX_CIFS_SMALL_BUFFER_SIZE
- 4) {
716 memcpy(bigbuf
, smallbuf
, 4);
717 smb_buffer
= (struct smb_hdr
*)bigbuf
;
721 iov
.iov_base
= 4 + buf
;
722 iov
.iov_len
= pdu_length
;
723 rc
= read_from_socket(server
, &iov
, pdu_length
,
730 total_read
+= 4; /* account for rfc1002 hdr */
732 dump_smb(smb_buffer
, total_read
);
735 * We know that we received enough to get to the MID as we
736 * checked the pdu_length earlier. Now check to see
737 * if the rest of the header is OK. We borrow the length
738 * var for the rest of the loop to avoid a new stack var.
740 * 48 bytes is enough to display the header and a little bit
741 * into the payload for debugging purposes.
743 length
= checkSMB(smb_buffer
, smb_buffer
->Mid
, total_read
);
745 cifs_dump_mem("Bad SMB: ", buf
,
746 min_t(unsigned int, total_read
, 48));
748 server
->lstrp
= jiffies
;
750 mid_entry
= find_cifs_mid(server
, smb_buffer
, &length
,
751 isLargeBuf
, &isMultiRsp
, &bigbuf
);
752 if (mid_entry
!= NULL
) {
753 mid_entry
->callback(mid_entry
);
754 /* Was previous buf put in mpx struct for multi-rsp? */
756 /* smb buffer will be freed by user thread */
762 } else if (length
!= 0) {
763 /* response sanity checks failed */
765 } else if (!is_valid_oplock_break(smb_buffer
, server
) &&
767 cERROR(1, "No task to wake, unknown frame received! "
768 "NumMids %d", atomic_read(&midCount
));
769 cifs_dump_mem("Received Data is: ", buf
,
770 sizeof(struct smb_hdr
));
771 #ifdef CONFIG_CIFS_DEBUG2
772 cifs_dump_detail(smb_buffer
);
773 cifs_dump_mids(server
);
774 #endif /* CIFS_DEBUG2 */
777 } /* end while !EXITING */
779 /* buffer usually freed in free_mid - need to free it here on exit */
780 cifs_buf_release(bigbuf
);
781 if (smallbuf
) /* no sense logging a debug message if NULL */
782 cifs_small_buf_release(smallbuf
);
784 task_to_wake
= xchg(&server
->tsk
, NULL
);
785 clean_demultiplex_info(server
);
787 /* if server->tsk was NULL then wait for a signal before exiting */
789 set_current_state(TASK_INTERRUPTIBLE
);
790 while (!signal_pending(current
)) {
792 set_current_state(TASK_INTERRUPTIBLE
);
794 set_current_state(TASK_RUNNING
);
797 module_put_and_exit(0);
800 /* extract the host portion of the UNC string */
802 extract_hostname(const char *unc
)
808 /* skip double chars at beginning of string */
809 /* BB: check validity of these bytes? */
812 /* delimiter between hostname and sharename is always '\\' now */
813 delim
= strchr(src
, '\\');
815 return ERR_PTR(-EINVAL
);
818 dst
= kmalloc((len
+ 1), GFP_KERNEL
);
820 return ERR_PTR(-ENOMEM
);
822 memcpy(dst
, src
, len
);
829 cifs_parse_mount_options(const char *mountdata
, const char *devname
,
832 char *value
, *data
, *end
;
833 char *mountdata_copy
= NULL
, *options
;
835 unsigned int temp_len
, i
, j
;
837 short int override_uid
= -1;
838 short int override_gid
= -1;
839 bool uid_specified
= false;
840 bool gid_specified
= false;
841 char *nodename
= utsname()->nodename
;
847 * does not have to be perfect mapping since field is
848 * informational, only used for servers that do not support
849 * port 445 and it can be overridden at mount time
851 memset(vol
->source_rfc1001_name
, 0x20, RFC1001_NAME_LEN
);
852 for (i
= 0; i
< strnlen(nodename
, RFC1001_NAME_LEN
); i
++)
853 vol
->source_rfc1001_name
[i
] = toupper(nodename
[i
]);
855 vol
->source_rfc1001_name
[RFC1001_NAME_LEN
] = 0;
856 /* null target name indicates to use *SMBSERVR default called name
857 if we end up sending RFC1001 session initialize */
858 vol
->target_rfc1001_name
[0] = 0;
859 vol
->cred_uid
= current_uid();
860 vol
->linux_uid
= current_uid();
861 vol
->linux_gid
= current_gid();
863 /* default to only allowing write access to owner of the mount */
864 vol
->dir_mode
= vol
->file_mode
= S_IRUGO
| S_IXUGO
| S_IWUSR
;
866 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
867 /* default is always to request posix paths. */
868 vol
->posix_paths
= 1;
869 /* default to using server inode numbers where available */
872 vol
->actimeo
= CIFS_DEF_ACTIMEO
;
875 goto cifs_parse_mount_err
;
877 mountdata_copy
= kstrndup(mountdata
, PAGE_SIZE
, GFP_KERNEL
);
879 goto cifs_parse_mount_err
;
881 options
= mountdata_copy
;
882 end
= options
+ strlen(options
);
883 if (strncmp(options
, "sep=", 4) == 0) {
884 if (options
[4] != 0) {
885 separator
[0] = options
[4];
888 cFYI(1, "Null separator not allowed");
891 vol
->backupuid_specified
= false; /* no backup intent for a user */
892 vol
->backupgid_specified
= false; /* no backup intent for a group */
894 while ((data
= strsep(&options
, separator
)) != NULL
) {
897 if ((value
= strchr(data
, '=')) != NULL
)
900 /* Have to parse this before we parse for "user" */
901 if (strnicmp(data
, "user_xattr", 10) == 0) {
903 } else if (strnicmp(data
, "nouser_xattr", 12) == 0) {
905 } else if (strnicmp(data
, "user", 4) == 0) {
908 "CIFS: invalid or missing username\n");
909 goto cifs_parse_mount_err
;
910 } else if (!*value
) {
911 /* null user, ie anonymous, authentication */
914 if (strnlen(value
, MAX_USERNAME_SIZE
) <
916 vol
->username
= kstrdup(value
, GFP_KERNEL
);
917 if (!vol
->username
) {
918 printk(KERN_WARNING
"CIFS: no memory "
920 goto cifs_parse_mount_err
;
923 printk(KERN_WARNING
"CIFS: username too long\n");
924 goto cifs_parse_mount_err
;
926 } else if (strnicmp(data
, "pass", 4) == 0) {
928 vol
->password
= NULL
;
930 } else if (value
[0] == 0) {
931 /* check if string begins with double comma
932 since that would mean the password really
933 does start with a comma, and would not
934 indicate an empty string */
935 if (value
[1] != separator
[0]) {
936 vol
->password
= NULL
;
940 temp_len
= strlen(value
);
941 /* removed password length check, NTLM passwords
942 can be arbitrarily long */
944 /* if comma in password, the string will be
945 prematurely null terminated. Commas in password are
946 specified across the cifs mount interface by a double
947 comma ie ,, and a comma used as in other cases ie ','
948 as a parameter delimiter/separator is single and due
949 to the strsep above is temporarily zeroed. */
951 /* NB: password legally can have multiple commas and
952 the only illegal character in a password is null */
954 if ((value
[temp_len
] == 0) &&
955 (value
+ temp_len
< end
) &&
956 (value
[temp_len
+1] == separator
[0])) {
958 value
[temp_len
] = separator
[0];
959 temp_len
+= 2; /* move after second comma */
960 while (value
[temp_len
] != 0) {
961 if (value
[temp_len
] == separator
[0]) {
962 if (value
[temp_len
+1] ==
964 /* skip second comma */
967 /* single comma indicating start
974 if (value
[temp_len
] == 0) {
978 /* point option to start of next parm */
979 options
= value
+ temp_len
+ 1;
981 /* go from value to value + temp_len condensing
982 double commas to singles. Note that this ends up
983 allocating a few bytes too many, which is ok */
984 vol
->password
= kzalloc(temp_len
, GFP_KERNEL
);
985 if (vol
->password
== NULL
) {
986 printk(KERN_WARNING
"CIFS: no memory "
988 goto cifs_parse_mount_err
;
990 for (i
= 0, j
= 0; i
< temp_len
; i
++, j
++) {
991 vol
->password
[j
] = value
[i
];
992 if (value
[i
] == separator
[0]
993 && value
[i
+1] == separator
[0]) {
994 /* skip second comma */
998 vol
->password
[j
] = 0;
1000 vol
->password
= kzalloc(temp_len
+1, GFP_KERNEL
);
1001 if (vol
->password
== NULL
) {
1002 printk(KERN_WARNING
"CIFS: no memory "
1004 goto cifs_parse_mount_err
;
1006 strcpy(vol
->password
, value
);
1008 } else if (!strnicmp(data
, "ip", 2) ||
1009 !strnicmp(data
, "addr", 4)) {
1010 if (!value
|| !*value
) {
1012 } else if (strnlen(value
, INET6_ADDRSTRLEN
) <
1014 vol
->UNCip
= kstrdup(value
, GFP_KERNEL
);
1016 printk(KERN_WARNING
"CIFS: no memory "
1018 goto cifs_parse_mount_err
;
1021 printk(KERN_WARNING
"CIFS: ip address "
1023 goto cifs_parse_mount_err
;
1025 } else if (strnicmp(data
, "sec", 3) == 0) {
1026 if (!value
|| !*value
) {
1027 cERROR(1, "no security value specified");
1029 } else if (strnicmp(value
, "krb5i", 5) == 0) {
1030 vol
->secFlg
|= CIFSSEC_MAY_KRB5
|
1032 } else if (strnicmp(value
, "krb5p", 5) == 0) {
1033 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
1034 CIFSSEC_MAY_KRB5; */
1035 cERROR(1, "Krb5 cifs privacy not supported");
1036 goto cifs_parse_mount_err
;
1037 } else if (strnicmp(value
, "krb5", 4) == 0) {
1038 vol
->secFlg
|= CIFSSEC_MAY_KRB5
;
1039 } else if (strnicmp(value
, "ntlmsspi", 8) == 0) {
1040 vol
->secFlg
|= CIFSSEC_MAY_NTLMSSP
|
1042 } else if (strnicmp(value
, "ntlmssp", 7) == 0) {
1043 vol
->secFlg
|= CIFSSEC_MAY_NTLMSSP
;
1044 } else if (strnicmp(value
, "ntlmv2i", 7) == 0) {
1045 vol
->secFlg
|= CIFSSEC_MAY_NTLMV2
|
1047 } else if (strnicmp(value
, "ntlmv2", 6) == 0) {
1048 vol
->secFlg
|= CIFSSEC_MAY_NTLMV2
;
1049 } else if (strnicmp(value
, "ntlmi", 5) == 0) {
1050 vol
->secFlg
|= CIFSSEC_MAY_NTLM
|
1052 } else if (strnicmp(value
, "ntlm", 4) == 0) {
1053 /* ntlm is default so can be turned off too */
1054 vol
->secFlg
|= CIFSSEC_MAY_NTLM
;
1055 } else if (strnicmp(value
, "nontlm", 6) == 0) {
1056 /* BB is there a better way to do this? */
1057 vol
->secFlg
|= CIFSSEC_MAY_NTLMV2
;
1058 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1059 } else if (strnicmp(value
, "lanman", 6) == 0) {
1060 vol
->secFlg
|= CIFSSEC_MAY_LANMAN
;
1062 } else if (strnicmp(value
, "none", 4) == 0) {
1065 cERROR(1, "bad security option: %s", value
);
1066 goto cifs_parse_mount_err
;
1068 } else if (strnicmp(data
, "vers", 3) == 0) {
1069 if (!value
|| !*value
) {
1070 cERROR(1, "no protocol version specified"
1071 " after vers= mount option");
1072 } else if ((strnicmp(value
, "cifs", 4) == 0) ||
1073 (strnicmp(value
, "1", 1) == 0)) {
1074 /* this is the default */
1077 } else if ((strnicmp(data
, "unc", 3) == 0)
1078 || (strnicmp(data
, "target", 6) == 0)
1079 || (strnicmp(data
, "path", 4) == 0)) {
1080 if (!value
|| !*value
) {
1081 printk(KERN_WARNING
"CIFS: invalid path to "
1082 "network resource\n");
1083 goto cifs_parse_mount_err
;
1085 if ((temp_len
= strnlen(value
, 300)) < 300) {
1086 vol
->UNC
= kmalloc(temp_len
+1, GFP_KERNEL
);
1087 if (vol
->UNC
== NULL
)
1088 goto cifs_parse_mount_err
;
1089 strcpy(vol
->UNC
, value
);
1090 if (strncmp(vol
->UNC
, "//", 2) == 0) {
1093 } else if (strncmp(vol
->UNC
, "\\\\", 2) != 0) {
1095 "CIFS: UNC Path does not begin "
1096 "with // or \\\\ \n");
1097 goto cifs_parse_mount_err
;
1100 printk(KERN_WARNING
"CIFS: UNC name too long\n");
1101 goto cifs_parse_mount_err
;
1103 } else if ((strnicmp(data
, "domain", 3) == 0)
1104 || (strnicmp(data
, "workgroup", 5) == 0)) {
1105 if (!value
|| !*value
) {
1106 printk(KERN_WARNING
"CIFS: invalid domain name\n");
1107 goto cifs_parse_mount_err
;
1109 /* BB are there cases in which a comma can be valid in
1110 a domain name and need special handling? */
1111 if (strnlen(value
, 256) < 256) {
1112 vol
->domainname
= kstrdup(value
, GFP_KERNEL
);
1113 if (!vol
->domainname
) {
1114 printk(KERN_WARNING
"CIFS: no memory "
1115 "for domainname\n");
1116 goto cifs_parse_mount_err
;
1118 cFYI(1, "Domain name set");
1120 printk(KERN_WARNING
"CIFS: domain name too "
1122 goto cifs_parse_mount_err
;
1124 } else if (strnicmp(data
, "srcaddr", 7) == 0) {
1125 vol
->srcaddr
.ss_family
= AF_UNSPEC
;
1127 if (!value
|| !*value
) {
1128 printk(KERN_WARNING
"CIFS: srcaddr value"
1129 " not specified.\n");
1130 goto cifs_parse_mount_err
;
1132 i
= cifs_convert_address((struct sockaddr
*)&vol
->srcaddr
,
1133 value
, strlen(value
));
1135 printk(KERN_WARNING
"CIFS: Could not parse"
1138 goto cifs_parse_mount_err
;
1140 } else if (strnicmp(data
, "prefixpath", 10) == 0) {
1141 if (!value
|| !*value
) {
1143 "CIFS: invalid path prefix\n");
1144 goto cifs_parse_mount_err
;
1146 if ((temp_len
= strnlen(value
, 1024)) < 1024) {
1147 if (value
[0] != '/')
1148 temp_len
++; /* missing leading slash */
1149 vol
->prepath
= kmalloc(temp_len
+1, GFP_KERNEL
);
1150 if (vol
->prepath
== NULL
)
1151 goto cifs_parse_mount_err
;
1152 if (value
[0] != '/') {
1153 vol
->prepath
[0] = '/';
1154 strcpy(vol
->prepath
+1, value
);
1156 strcpy(vol
->prepath
, value
);
1157 cFYI(1, "prefix path %s", vol
->prepath
);
1159 printk(KERN_WARNING
"CIFS: prefix too long\n");
1160 goto cifs_parse_mount_err
;
1162 } else if (strnicmp(data
, "iocharset", 9) == 0) {
1163 if (!value
|| !*value
) {
1164 printk(KERN_WARNING
"CIFS: invalid iocharset "
1166 goto cifs_parse_mount_err
;
1168 if (strnlen(value
, 65) < 65) {
1169 if (strnicmp(value
, "default", 7)) {
1170 vol
->iocharset
= kstrdup(value
,
1173 if (!vol
->iocharset
) {
1174 printk(KERN_WARNING
"CIFS: no "
1177 goto cifs_parse_mount_err
;
1180 /* if iocharset not set then load_nls_default
1181 is used by caller */
1182 cFYI(1, "iocharset set to %s", value
);
1184 printk(KERN_WARNING
"CIFS: iocharset name "
1186 goto cifs_parse_mount_err
;
1188 } else if (!strnicmp(data
, "uid", 3) && value
&& *value
) {
1189 vol
->linux_uid
= simple_strtoul(value
, &value
, 0);
1190 uid_specified
= true;
1191 } else if (!strnicmp(data
, "cruid", 5) && value
&& *value
) {
1192 vol
->cred_uid
= simple_strtoul(value
, &value
, 0);
1193 } else if (!strnicmp(data
, "forceuid", 8)) {
1195 } else if (!strnicmp(data
, "noforceuid", 10)) {
1197 } else if (!strnicmp(data
, "gid", 3) && value
&& *value
) {
1198 vol
->linux_gid
= simple_strtoul(value
, &value
, 0);
1199 gid_specified
= true;
1200 } else if (!strnicmp(data
, "forcegid", 8)) {
1202 } else if (!strnicmp(data
, "noforcegid", 10)) {
1204 } else if (strnicmp(data
, "file_mode", 4) == 0) {
1205 if (value
&& *value
) {
1207 simple_strtoul(value
, &value
, 0);
1209 } else if (strnicmp(data
, "dir_mode", 4) == 0) {
1210 if (value
&& *value
) {
1212 simple_strtoul(value
, &value
, 0);
1214 } else if (strnicmp(data
, "dirmode", 4) == 0) {
1215 if (value
&& *value
) {
1217 simple_strtoul(value
, &value
, 0);
1219 } else if (strnicmp(data
, "port", 4) == 0) {
1220 if (value
&& *value
) {
1222 simple_strtoul(value
, &value
, 0);
1224 } else if (strnicmp(data
, "rsize", 5) == 0) {
1225 if (value
&& *value
) {
1227 simple_strtoul(value
, &value
, 0);
1229 } else if (strnicmp(data
, "wsize", 5) == 0) {
1230 if (value
&& *value
) {
1232 simple_strtoul(value
, &value
, 0);
1234 } else if (strnicmp(data
, "sockopt", 5) == 0) {
1235 if (!value
|| !*value
) {
1236 cERROR(1, "no socket option specified");
1238 } else if (strnicmp(value
, "TCP_NODELAY", 11) == 0) {
1239 vol
->sockopt_tcp_nodelay
= 1;
1241 } else if (strnicmp(data
, "netbiosname", 4) == 0) {
1242 if (!value
|| !*value
|| (*value
== ' ')) {
1243 cFYI(1, "invalid (empty) netbiosname");
1245 memset(vol
->source_rfc1001_name
, 0x20,
1248 * FIXME: are there cases in which a comma can
1249 * be valid in workstation netbios name (and
1250 * need special handling)?
1252 for (i
= 0; i
< RFC1001_NAME_LEN
; i
++) {
1253 /* don't ucase netbiosname for user */
1256 vol
->source_rfc1001_name
[i
] = value
[i
];
1258 /* The string has 16th byte zero still from
1259 set at top of the function */
1260 if (i
== RFC1001_NAME_LEN
&& value
[i
] != 0)
1261 printk(KERN_WARNING
"CIFS: netbiosname"
1262 " longer than 15 truncated.\n");
1264 } else if (strnicmp(data
, "servern", 7) == 0) {
1265 /* servernetbiosname specified override *SMBSERVER */
1266 if (!value
|| !*value
|| (*value
== ' ')) {
1267 cFYI(1, "empty server netbiosname specified");
1269 /* last byte, type, is 0x20 for servr type */
1270 memset(vol
->target_rfc1001_name
, 0x20,
1271 RFC1001_NAME_LEN_WITH_NULL
);
1273 for (i
= 0; i
< 15; i
++) {
1274 /* BB are there cases in which a comma can be
1275 valid in this workstation netbios name
1276 (and need special handling)? */
1278 /* user or mount helper must uppercase
1283 vol
->target_rfc1001_name
[i
] =
1286 /* The string has 16th byte zero still from
1287 set at top of the function */
1288 if (i
== RFC1001_NAME_LEN
&& value
[i
] != 0)
1289 printk(KERN_WARNING
"CIFS: server net"
1290 "biosname longer than 15 truncated.\n");
1292 } else if (strnicmp(data
, "actimeo", 7) == 0) {
1293 if (value
&& *value
) {
1294 vol
->actimeo
= HZ
* simple_strtoul(value
,
1296 if (vol
->actimeo
> CIFS_MAX_ACTIMEO
) {
1297 cERROR(1, "CIFS: attribute cache"
1298 "timeout too large");
1299 goto cifs_parse_mount_err
;
1302 } else if (strnicmp(data
, "credentials", 4) == 0) {
1304 } else if (strnicmp(data
, "version", 3) == 0) {
1306 } else if (strnicmp(data
, "guest", 5) == 0) {
1308 } else if (strnicmp(data
, "rw", 2) == 0 && strlen(data
) == 2) {
1310 } else if (strnicmp(data
, "ro", 2) == 0) {
1312 } else if (strnicmp(data
, "noblocksend", 11) == 0) {
1313 vol
->noblocksnd
= 1;
1314 } else if (strnicmp(data
, "noautotune", 10) == 0) {
1315 vol
->noautotune
= 1;
1316 } else if ((strnicmp(data
, "suid", 4) == 0) ||
1317 (strnicmp(data
, "nosuid", 6) == 0) ||
1318 (strnicmp(data
, "exec", 4) == 0) ||
1319 (strnicmp(data
, "noexec", 6) == 0) ||
1320 (strnicmp(data
, "nodev", 5) == 0) ||
1321 (strnicmp(data
, "noauto", 6) == 0) ||
1322 (strnicmp(data
, "dev", 3) == 0)) {
1323 /* The mount tool or mount.cifs helper (if present)
1324 uses these opts to set flags, and the flags are read
1325 by the kernel vfs layer before we get here (ie
1326 before read super) so there is no point trying to
1327 parse these options again and set anything and it
1328 is ok to just ignore them */
1330 } else if (strnicmp(data
, "hard", 4) == 0) {
1332 } else if (strnicmp(data
, "soft", 4) == 0) {
1334 } else if (strnicmp(data
, "perm", 4) == 0) {
1336 } else if (strnicmp(data
, "noperm", 6) == 0) {
1338 } else if (strnicmp(data
, "mapchars", 8) == 0) {
1340 } else if (strnicmp(data
, "nomapchars", 10) == 0) {
1342 } else if (strnicmp(data
, "sfu", 3) == 0) {
1344 } else if (strnicmp(data
, "nosfu", 5) == 0) {
1346 } else if (strnicmp(data
, "nodfs", 5) == 0) {
1348 } else if (strnicmp(data
, "posixpaths", 10) == 0) {
1349 vol
->posix_paths
= 1;
1350 } else if (strnicmp(data
, "noposixpaths", 12) == 0) {
1351 vol
->posix_paths
= 0;
1352 } else if (strnicmp(data
, "nounix", 6) == 0) {
1353 vol
->no_linux_ext
= 1;
1354 } else if (strnicmp(data
, "nolinux", 7) == 0) {
1355 vol
->no_linux_ext
= 1;
1356 } else if ((strnicmp(data
, "nocase", 6) == 0) ||
1357 (strnicmp(data
, "ignorecase", 10) == 0)) {
1359 } else if (strnicmp(data
, "mand", 4) == 0) {
1361 } else if (strnicmp(data
, "nomand", 6) == 0) {
1363 } else if (strnicmp(data
, "_netdev", 7) == 0) {
1365 } else if (strnicmp(data
, "brl", 3) == 0) {
1367 } else if ((strnicmp(data
, "nobrl", 5) == 0) ||
1368 (strnicmp(data
, "nolock", 6) == 0)) {
1370 /* turn off mandatory locking in mode
1371 if remote locking is turned off since the
1372 local vfs will do advisory */
1373 if (vol
->file_mode
==
1374 (S_IALLUGO
& ~(S_ISUID
| S_IXGRP
)))
1375 vol
->file_mode
= S_IALLUGO
;
1376 } else if (strnicmp(data
, "forcemandatorylock", 9) == 0) {
1377 /* will take the shorter form "forcemand" as well */
1378 /* This mount option will force use of mandatory
1379 (DOS/Windows style) byte range locks, instead of
1380 using posix advisory byte range locks, even if the
1381 Unix extensions are available and posix locks would
1382 be supported otherwise. If Unix extensions are not
1383 negotiated this has no effect since mandatory locks
1384 would be used (mandatory locks is all that those
1385 those servers support) */
1387 } else if (strnicmp(data
, "setuids", 7) == 0) {
1389 } else if (strnicmp(data
, "nosetuids", 9) == 0) {
1391 } else if (strnicmp(data
, "dynperm", 7) == 0) {
1392 vol
->dynperm
= true;
1393 } else if (strnicmp(data
, "nodynperm", 9) == 0) {
1394 vol
->dynperm
= false;
1395 } else if (strnicmp(data
, "nohard", 6) == 0) {
1397 } else if (strnicmp(data
, "nosoft", 6) == 0) {
1399 } else if (strnicmp(data
, "nointr", 6) == 0) {
1401 } else if (strnicmp(data
, "intr", 4) == 0) {
1403 } else if (strnicmp(data
, "nostrictsync", 12) == 0) {
1404 vol
->nostrictsync
= 1;
1405 } else if (strnicmp(data
, "strictsync", 10) == 0) {
1406 vol
->nostrictsync
= 0;
1407 } else if (strnicmp(data
, "serverino", 7) == 0) {
1408 vol
->server_ino
= 1;
1409 } else if (strnicmp(data
, "noserverino", 9) == 0) {
1410 vol
->server_ino
= 0;
1411 } else if (strnicmp(data
, "rwpidforward", 12) == 0) {
1412 vol
->rwpidforward
= 1;
1413 } else if (strnicmp(data
, "cifsacl", 7) == 0) {
1415 } else if (strnicmp(data
, "nocifsacl", 9) == 0) {
1417 } else if (strnicmp(data
, "acl", 3) == 0) {
1418 vol
->no_psx_acl
= 0;
1419 } else if (strnicmp(data
, "noacl", 5) == 0) {
1420 vol
->no_psx_acl
= 1;
1421 } else if (strnicmp(data
, "locallease", 6) == 0) {
1422 vol
->local_lease
= 1;
1423 } else if (strnicmp(data
, "sign", 4) == 0) {
1424 vol
->secFlg
|= CIFSSEC_MUST_SIGN
;
1425 } else if (strnicmp(data
, "seal", 4) == 0) {
1426 /* we do not do the following in secFlags because seal
1427 is a per tree connection (mount) not a per socket
1428 or per-smb connection option in the protocol */
1429 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1431 } else if (strnicmp(data
, "direct", 6) == 0) {
1433 } else if (strnicmp(data
, "forcedirectio", 13) == 0) {
1435 } else if (strnicmp(data
, "strictcache", 11) == 0) {
1437 } else if (strnicmp(data
, "noac", 4) == 0) {
1438 printk(KERN_WARNING
"CIFS: Mount option noac not "
1439 "supported. Instead set "
1440 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1441 } else if (strnicmp(data
, "fsc", 3) == 0) {
1442 #ifndef CONFIG_CIFS_FSCACHE
1443 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE "
1444 "kernel config option set");
1445 goto cifs_parse_mount_err
;
1448 } else if (strnicmp(data
, "mfsymlinks", 10) == 0) {
1449 vol
->mfsymlinks
= true;
1450 } else if (strnicmp(data
, "multiuser", 8) == 0) {
1451 vol
->multiuser
= true;
1452 } else if (!strnicmp(data
, "backupuid", 9) && value
&& *value
) {
1453 err
= kstrtouint(value
, 0, &vol
->backupuid
);
1455 cERROR(1, "%s: Invalid backupuid value",
1457 goto cifs_parse_mount_err
;
1459 vol
->backupuid_specified
= true;
1460 } else if (!strnicmp(data
, "backupgid", 9) && value
&& *value
) {
1461 err
= kstrtouint(value
, 0, &vol
->backupgid
);
1463 cERROR(1, "%s: Invalid backupgid value",
1465 goto cifs_parse_mount_err
;
1467 vol
->backupgid_specified
= true;
1469 printk(KERN_WARNING
"CIFS: Unknown mount option %s\n",
1472 if (vol
->UNC
== NULL
) {
1473 if (devname
== NULL
) {
1474 printk(KERN_WARNING
"CIFS: Missing UNC name for mount "
1476 goto cifs_parse_mount_err
;
1478 if ((temp_len
= strnlen(devname
, 300)) < 300) {
1479 vol
->UNC
= kmalloc(temp_len
+1, GFP_KERNEL
);
1480 if (vol
->UNC
== NULL
)
1481 goto cifs_parse_mount_err
;
1482 strcpy(vol
->UNC
, devname
);
1483 if (strncmp(vol
->UNC
, "//", 2) == 0) {
1486 } else if (strncmp(vol
->UNC
, "\\\\", 2) != 0) {
1487 printk(KERN_WARNING
"CIFS: UNC Path does not "
1488 "begin with // or \\\\ \n");
1489 goto cifs_parse_mount_err
;
1491 value
= strpbrk(vol
->UNC
+2, "/\\");
1495 printk(KERN_WARNING
"CIFS: UNC name too long\n");
1496 goto cifs_parse_mount_err
;
1500 if (vol
->multiuser
&& !(vol
->secFlg
& CIFSSEC_MAY_KRB5
)) {
1501 cERROR(1, "Multiuser mounts currently require krb5 "
1503 goto cifs_parse_mount_err
;
1506 if (vol
->UNCip
== NULL
)
1507 vol
->UNCip
= &vol
->UNC
[2];
1510 vol
->override_uid
= override_uid
;
1511 else if (override_uid
== 1)
1512 printk(KERN_NOTICE
"CIFS: ignoring forceuid mount option "
1513 "specified with no uid= option.\n");
1516 vol
->override_gid
= override_gid
;
1517 else if (override_gid
== 1)
1518 printk(KERN_NOTICE
"CIFS: ignoring forcegid mount option "
1519 "specified with no gid= option.\n");
1521 kfree(mountdata_copy
);
1524 cifs_parse_mount_err
:
1525 kfree(mountdata_copy
);
1529 /** Returns true if srcaddr isn't specified and rhs isn't
1530 * specified, or if srcaddr is specified and
1531 * matches the IP address of the rhs argument.
1534 srcip_matches(struct sockaddr
*srcaddr
, struct sockaddr
*rhs
)
1536 switch (srcaddr
->sa_family
) {
1538 return (rhs
->sa_family
== AF_UNSPEC
);
1540 struct sockaddr_in
*saddr4
= (struct sockaddr_in
*)srcaddr
;
1541 struct sockaddr_in
*vaddr4
= (struct sockaddr_in
*)rhs
;
1542 return (saddr4
->sin_addr
.s_addr
== vaddr4
->sin_addr
.s_addr
);
1545 struct sockaddr_in6
*saddr6
= (struct sockaddr_in6
*)srcaddr
;
1546 struct sockaddr_in6
*vaddr6
= (struct sockaddr_in6
*)&rhs
;
1547 return ipv6_addr_equal(&saddr6
->sin6_addr
, &vaddr6
->sin6_addr
);
1551 return false; /* don't expect to be here */
1556 * If no port is specified in addr structure, we try to match with 445 port
1557 * and if it fails - with 139 ports. It should be called only if address
1558 * families of server and addr are equal.
1561 match_port(struct TCP_Server_Info
*server
, struct sockaddr
*addr
)
1563 __be16 port
, *sport
;
1565 switch (addr
->sa_family
) {
1567 sport
= &((struct sockaddr_in
*) &server
->dstaddr
)->sin_port
;
1568 port
= ((struct sockaddr_in
*) addr
)->sin_port
;
1571 sport
= &((struct sockaddr_in6
*) &server
->dstaddr
)->sin6_port
;
1572 port
= ((struct sockaddr_in6
*) addr
)->sin6_port
;
1580 port
= htons(CIFS_PORT
);
1584 port
= htons(RFC1001_PORT
);
1587 return port
== *sport
;
1591 match_address(struct TCP_Server_Info
*server
, struct sockaddr
*addr
,
1592 struct sockaddr
*srcaddr
)
1594 switch (addr
->sa_family
) {
1596 struct sockaddr_in
*addr4
= (struct sockaddr_in
*)addr
;
1597 struct sockaddr_in
*srv_addr4
=
1598 (struct sockaddr_in
*)&server
->dstaddr
;
1600 if (addr4
->sin_addr
.s_addr
!= srv_addr4
->sin_addr
.s_addr
)
1605 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)addr
;
1606 struct sockaddr_in6
*srv_addr6
=
1607 (struct sockaddr_in6
*)&server
->dstaddr
;
1609 if (!ipv6_addr_equal(&addr6
->sin6_addr
,
1610 &srv_addr6
->sin6_addr
))
1612 if (addr6
->sin6_scope_id
!= srv_addr6
->sin6_scope_id
)
1618 return false; /* don't expect to be here */
1621 if (!srcip_matches(srcaddr
, (struct sockaddr
*)&server
->srcaddr
))
1628 match_security(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
1630 unsigned int secFlags
;
1632 if (vol
->secFlg
& (~(CIFSSEC_MUST_SIGN
| CIFSSEC_MUST_SEAL
)))
1633 secFlags
= vol
->secFlg
;
1635 secFlags
= global_secflags
| vol
->secFlg
;
1637 switch (server
->secType
) {
1639 if (!(secFlags
& (CIFSSEC_MAY_LANMAN
|CIFSSEC_MAY_PLNTXT
)))
1643 if (!(secFlags
& CIFSSEC_MAY_NTLMV2
))
1647 if (!(secFlags
& CIFSSEC_MAY_NTLM
))
1651 if (!(secFlags
& CIFSSEC_MAY_KRB5
))
1655 if (!(secFlags
& CIFSSEC_MAY_NTLMSSP
))
1659 /* shouldn't happen */
1663 /* now check if signing mode is acceptable */
1664 if ((secFlags
& CIFSSEC_MAY_SIGN
) == 0 &&
1665 (server
->sec_mode
& SECMODE_SIGN_REQUIRED
))
1667 else if (((secFlags
& CIFSSEC_MUST_SIGN
) == CIFSSEC_MUST_SIGN
) &&
1669 (SECMODE_SIGN_ENABLED
|SECMODE_SIGN_REQUIRED
)) == 0)
1675 static int match_server(struct TCP_Server_Info
*server
, struct sockaddr
*addr
,
1676 struct smb_vol
*vol
)
1678 if (!net_eq(cifs_net_ns(server
), current
->nsproxy
->net_ns
))
1681 if (!match_address(server
, addr
,
1682 (struct sockaddr
*)&vol
->srcaddr
))
1685 if (!match_port(server
, addr
))
1688 if (!match_security(server
, vol
))
1694 static struct TCP_Server_Info
*
1695 cifs_find_tcp_session(struct sockaddr
*addr
, struct smb_vol
*vol
)
1697 struct TCP_Server_Info
*server
;
1699 spin_lock(&cifs_tcp_ses_lock
);
1700 list_for_each_entry(server
, &cifs_tcp_ses_list
, tcp_ses_list
) {
1701 if (!match_server(server
, addr
, vol
))
1704 ++server
->srv_count
;
1705 spin_unlock(&cifs_tcp_ses_lock
);
1706 cFYI(1, "Existing tcp session with server found");
1709 spin_unlock(&cifs_tcp_ses_lock
);
1714 cifs_put_tcp_session(struct TCP_Server_Info
*server
)
1716 struct task_struct
*task
;
1718 spin_lock(&cifs_tcp_ses_lock
);
1719 if (--server
->srv_count
> 0) {
1720 spin_unlock(&cifs_tcp_ses_lock
);
1724 put_net(cifs_net_ns(server
));
1726 list_del_init(&server
->tcp_ses_list
);
1727 spin_unlock(&cifs_tcp_ses_lock
);
1729 cancel_delayed_work_sync(&server
->echo
);
1731 spin_lock(&GlobalMid_Lock
);
1732 server
->tcpStatus
= CifsExiting
;
1733 spin_unlock(&GlobalMid_Lock
);
1735 cifs_crypto_shash_release(server
);
1736 cifs_fscache_release_client_cookie(server
);
1738 kfree(server
->session_key
.response
);
1739 server
->session_key
.response
= NULL
;
1740 server
->session_key
.len
= 0;
1742 task
= xchg(&server
->tsk
, NULL
);
1744 force_sig(SIGKILL
, task
);
1747 static struct TCP_Server_Info
*
1748 cifs_get_tcp_session(struct smb_vol
*volume_info
)
1750 struct TCP_Server_Info
*tcp_ses
= NULL
;
1751 struct sockaddr_storage addr
;
1752 struct sockaddr_in
*sin_server
= (struct sockaddr_in
*) &addr
;
1753 struct sockaddr_in6
*sin_server6
= (struct sockaddr_in6
*) &addr
;
1756 memset(&addr
, 0, sizeof(struct sockaddr_storage
));
1758 cFYI(1, "UNC: %s ip: %s", volume_info
->UNC
, volume_info
->UNCip
);
1760 if (volume_info
->UNCip
&& volume_info
->UNC
) {
1761 rc
= cifs_fill_sockaddr((struct sockaddr
*)&addr
,
1763 strlen(volume_info
->UNCip
),
1766 /* we failed translating address */
1770 } else if (volume_info
->UNCip
) {
1771 /* BB using ip addr as tcp_ses name to connect to the
1773 cERROR(1, "Connecting to DFS root not implemented yet");
1776 } else /* which tcp_sess DFS root would we conect to */ {
1777 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
1778 "unc=//192.168.1.100/public) specified");
1783 /* see if we already have a matching tcp_ses */
1784 tcp_ses
= cifs_find_tcp_session((struct sockaddr
*)&addr
, volume_info
);
1788 tcp_ses
= kzalloc(sizeof(struct TCP_Server_Info
), GFP_KERNEL
);
1794 rc
= cifs_crypto_shash_allocate(tcp_ses
);
1796 cERROR(1, "could not setup hash structures rc %d", rc
);
1800 cifs_set_net_ns(tcp_ses
, get_net(current
->nsproxy
->net_ns
));
1801 tcp_ses
->hostname
= extract_hostname(volume_info
->UNC
);
1802 if (IS_ERR(tcp_ses
->hostname
)) {
1803 rc
= PTR_ERR(tcp_ses
->hostname
);
1804 goto out_err_crypto_release
;
1807 tcp_ses
->noblocksnd
= volume_info
->noblocksnd
;
1808 tcp_ses
->noautotune
= volume_info
->noautotune
;
1809 tcp_ses
->tcp_nodelay
= volume_info
->sockopt_tcp_nodelay
;
1810 atomic_set(&tcp_ses
->inFlight
, 0);
1811 init_waitqueue_head(&tcp_ses
->response_q
);
1812 init_waitqueue_head(&tcp_ses
->request_q
);
1813 INIT_LIST_HEAD(&tcp_ses
->pending_mid_q
);
1814 mutex_init(&tcp_ses
->srv_mutex
);
1815 memcpy(tcp_ses
->workstation_RFC1001_name
,
1816 volume_info
->source_rfc1001_name
, RFC1001_NAME_LEN_WITH_NULL
);
1817 memcpy(tcp_ses
->server_RFC1001_name
,
1818 volume_info
->target_rfc1001_name
, RFC1001_NAME_LEN_WITH_NULL
);
1819 tcp_ses
->session_estab
= false;
1820 tcp_ses
->sequence_number
= 0;
1821 tcp_ses
->lstrp
= jiffies
;
1822 INIT_LIST_HEAD(&tcp_ses
->tcp_ses_list
);
1823 INIT_LIST_HEAD(&tcp_ses
->smb_ses_list
);
1824 INIT_DELAYED_WORK(&tcp_ses
->echo
, cifs_echo_request
);
1827 * at this point we are the only ones with the pointer
1828 * to the struct since the kernel thread not created yet
1829 * no need to spinlock this init of tcpStatus or srv_count
1831 tcp_ses
->tcpStatus
= CifsNew
;
1832 memcpy(&tcp_ses
->srcaddr
, &volume_info
->srcaddr
,
1833 sizeof(tcp_ses
->srcaddr
));
1834 ++tcp_ses
->srv_count
;
1836 if (addr
.ss_family
== AF_INET6
) {
1837 cFYI(1, "attempting ipv6 connect");
1838 /* BB should we allow ipv6 on port 139? */
1839 /* other OS never observed in Wild doing 139 with v6 */
1840 memcpy(&tcp_ses
->dstaddr
, sin_server6
,
1841 sizeof(struct sockaddr_in6
));
1843 memcpy(&tcp_ses
->dstaddr
, sin_server
,
1844 sizeof(struct sockaddr_in
));
1846 rc
= ip_connect(tcp_ses
);
1848 cERROR(1, "Error connecting to socket. Aborting operation");
1849 goto out_err_crypto_release
;
1853 * since we're in a cifs function already, we know that
1854 * this will succeed. No need for try_module_get().
1856 __module_get(THIS_MODULE
);
1857 tcp_ses
->tsk
= kthread_run(cifs_demultiplex_thread
,
1859 if (IS_ERR(tcp_ses
->tsk
)) {
1860 rc
= PTR_ERR(tcp_ses
->tsk
);
1861 cERROR(1, "error %d create cifsd thread", rc
);
1862 module_put(THIS_MODULE
);
1863 goto out_err_crypto_release
;
1865 tcp_ses
->tcpStatus
= CifsNeedNegotiate
;
1867 /* thread spawned, put it on the list */
1868 spin_lock(&cifs_tcp_ses_lock
);
1869 list_add(&tcp_ses
->tcp_ses_list
, &cifs_tcp_ses_list
);
1870 spin_unlock(&cifs_tcp_ses_lock
);
1872 cifs_fscache_get_client_cookie(tcp_ses
);
1874 /* queue echo request delayed work */
1875 queue_delayed_work(system_nrt_wq
, &tcp_ses
->echo
, SMB_ECHO_INTERVAL
);
1879 out_err_crypto_release
:
1880 cifs_crypto_shash_release(tcp_ses
);
1882 put_net(cifs_net_ns(tcp_ses
));
1886 if (!IS_ERR(tcp_ses
->hostname
))
1887 kfree(tcp_ses
->hostname
);
1888 if (tcp_ses
->ssocket
)
1889 sock_release(tcp_ses
->ssocket
);
1895 static int match_session(struct cifs_ses
*ses
, struct smb_vol
*vol
)
1897 switch (ses
->server
->secType
) {
1899 if (vol
->cred_uid
!= ses
->cred_uid
)
1903 /* anything else takes username/password */
1904 if (ses
->user_name
== NULL
)
1906 if (strncmp(ses
->user_name
, vol
->username
,
1909 if (strlen(vol
->username
) != 0 &&
1910 ses
->password
!= NULL
&&
1911 strncmp(ses
->password
,
1912 vol
->password
? vol
->password
: "",
1919 static struct cifs_ses
*
1920 cifs_find_smb_ses(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
1922 struct cifs_ses
*ses
;
1924 spin_lock(&cifs_tcp_ses_lock
);
1925 list_for_each_entry(ses
, &server
->smb_ses_list
, smb_ses_list
) {
1926 if (!match_session(ses
, vol
))
1929 spin_unlock(&cifs_tcp_ses_lock
);
1932 spin_unlock(&cifs_tcp_ses_lock
);
1937 cifs_put_smb_ses(struct cifs_ses
*ses
)
1940 struct TCP_Server_Info
*server
= ses
->server
;
1942 cFYI(1, "%s: ses_count=%d\n", __func__
, ses
->ses_count
);
1943 spin_lock(&cifs_tcp_ses_lock
);
1944 if (--ses
->ses_count
> 0) {
1945 spin_unlock(&cifs_tcp_ses_lock
);
1949 list_del_init(&ses
->smb_ses_list
);
1950 spin_unlock(&cifs_tcp_ses_lock
);
1952 if (ses
->status
== CifsGood
) {
1954 CIFSSMBLogoff(xid
, ses
);
1958 cifs_put_tcp_session(server
);
1961 static bool warned_on_ntlm
; /* globals init to false automatically */
1963 static struct cifs_ses
*
1964 cifs_get_smb_ses(struct TCP_Server_Info
*server
, struct smb_vol
*volume_info
)
1966 int rc
= -ENOMEM
, xid
;
1967 struct cifs_ses
*ses
;
1968 struct sockaddr_in
*addr
= (struct sockaddr_in
*)&server
->dstaddr
;
1969 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)&server
->dstaddr
;
1973 ses
= cifs_find_smb_ses(server
, volume_info
);
1975 cFYI(1, "Existing smb sess found (status=%d)", ses
->status
);
1977 mutex_lock(&ses
->session_mutex
);
1978 rc
= cifs_negotiate_protocol(xid
, ses
);
1980 mutex_unlock(&ses
->session_mutex
);
1981 /* problem -- put our ses reference */
1982 cifs_put_smb_ses(ses
);
1986 if (ses
->need_reconnect
) {
1987 cFYI(1, "Session needs reconnect");
1988 rc
= cifs_setup_session(xid
, ses
,
1989 volume_info
->local_nls
);
1991 mutex_unlock(&ses
->session_mutex
);
1992 /* problem -- put our reference */
1993 cifs_put_smb_ses(ses
);
1998 mutex_unlock(&ses
->session_mutex
);
2000 /* existing SMB ses has a server reference already */
2001 cifs_put_tcp_session(server
);
2006 cFYI(1, "Existing smb sess not found");
2007 ses
= sesInfoAlloc();
2011 /* new SMB session uses our server ref */
2012 ses
->server
= server
;
2013 if (server
->dstaddr
.ss_family
== AF_INET6
)
2014 sprintf(ses
->serverName
, "%pI6", &addr6
->sin6_addr
);
2016 sprintf(ses
->serverName
, "%pI4", &addr
->sin_addr
);
2018 if (volume_info
->username
) {
2019 ses
->user_name
= kstrdup(volume_info
->username
, GFP_KERNEL
);
2020 if (!ses
->user_name
)
2024 /* volume_info->password freed at unmount */
2025 if (volume_info
->password
) {
2026 ses
->password
= kstrdup(volume_info
->password
, GFP_KERNEL
);
2030 if (volume_info
->domainname
) {
2031 ses
->domainName
= kstrdup(volume_info
->domainname
, GFP_KERNEL
);
2032 if (!ses
->domainName
)
2035 ses
->cred_uid
= volume_info
->cred_uid
;
2036 ses
->linux_uid
= volume_info
->linux_uid
;
2038 /* ntlmv2 is much stronger than ntlm security, and has been broadly
2039 supported for many years, time to update default security mechanism */
2040 if ((volume_info
->secFlg
== 0) && warned_on_ntlm
== false) {
2041 warned_on_ntlm
= true;
2042 cERROR(1, "default security mechanism requested. The default "
2043 "security mechanism will be upgraded from ntlm to "
2044 "ntlmv2 in kernel release 3.2");
2046 ses
->overrideSecFlg
= volume_info
->secFlg
;
2048 mutex_lock(&ses
->session_mutex
);
2049 rc
= cifs_negotiate_protocol(xid
, ses
);
2051 rc
= cifs_setup_session(xid
, ses
, volume_info
->local_nls
);
2052 mutex_unlock(&ses
->session_mutex
);
2056 /* success, put it on the list */
2057 spin_lock(&cifs_tcp_ses_lock
);
2058 list_add(&ses
->smb_ses_list
, &server
->smb_ses_list
);
2059 spin_unlock(&cifs_tcp_ses_lock
);
2070 static int match_tcon(struct cifs_tcon
*tcon
, const char *unc
)
2072 if (tcon
->tidStatus
== CifsExiting
)
2074 if (strncmp(tcon
->treeName
, unc
, MAX_TREE_SIZE
))
2079 static struct cifs_tcon
*
2080 cifs_find_tcon(struct cifs_ses
*ses
, const char *unc
)
2082 struct list_head
*tmp
;
2083 struct cifs_tcon
*tcon
;
2085 spin_lock(&cifs_tcp_ses_lock
);
2086 list_for_each(tmp
, &ses
->tcon_list
) {
2087 tcon
= list_entry(tmp
, struct cifs_tcon
, tcon_list
);
2088 if (!match_tcon(tcon
, unc
))
2091 spin_unlock(&cifs_tcp_ses_lock
);
2094 spin_unlock(&cifs_tcp_ses_lock
);
2099 cifs_put_tcon(struct cifs_tcon
*tcon
)
2102 struct cifs_ses
*ses
= tcon
->ses
;
2104 cFYI(1, "%s: tc_count=%d\n", __func__
, tcon
->tc_count
);
2105 spin_lock(&cifs_tcp_ses_lock
);
2106 if (--tcon
->tc_count
> 0) {
2107 spin_unlock(&cifs_tcp_ses_lock
);
2111 list_del_init(&tcon
->tcon_list
);
2112 spin_unlock(&cifs_tcp_ses_lock
);
2115 CIFSSMBTDis(xid
, tcon
);
2118 cifs_fscache_release_super_cookie(tcon
);
2120 cifs_put_smb_ses(ses
);
2123 static struct cifs_tcon
*
2124 cifs_get_tcon(struct cifs_ses
*ses
, struct smb_vol
*volume_info
)
2127 struct cifs_tcon
*tcon
;
2129 tcon
= cifs_find_tcon(ses
, volume_info
->UNC
);
2131 cFYI(1, "Found match on UNC path");
2132 /* existing tcon already has a reference */
2133 cifs_put_smb_ses(ses
);
2134 if (tcon
->seal
!= volume_info
->seal
)
2135 cERROR(1, "transport encryption setting "
2136 "conflicts with existing tid");
2140 tcon
= tconInfoAlloc();
2147 if (volume_info
->password
) {
2148 tcon
->password
= kstrdup(volume_info
->password
, GFP_KERNEL
);
2149 if (!tcon
->password
) {
2155 if (strchr(volume_info
->UNC
+ 3, '\\') == NULL
2156 && strchr(volume_info
->UNC
+ 3, '/') == NULL
) {
2157 cERROR(1, "Missing share name");
2162 /* BB Do we need to wrap session_mutex around
2163 * this TCon call and Unix SetFS as
2164 * we do on SessSetup and reconnect? */
2166 rc
= CIFSTCon(xid
, ses
, volume_info
->UNC
, tcon
, volume_info
->local_nls
);
2168 cFYI(1, "CIFS Tcon rc = %d", rc
);
2172 if (volume_info
->nodfs
) {
2173 tcon
->Flags
&= ~SMB_SHARE_IS_IN_DFS
;
2174 cFYI(1, "DFS disabled (%d)", tcon
->Flags
);
2176 tcon
->seal
= volume_info
->seal
;
2177 /* we can have only one retry value for a connection
2178 to a share so for resources mounted more than once
2179 to the same server share the last value passed in
2180 for the retry flag is used */
2181 tcon
->retry
= volume_info
->retry
;
2182 tcon
->nocase
= volume_info
->nocase
;
2183 tcon
->local_lease
= volume_info
->local_lease
;
2185 spin_lock(&cifs_tcp_ses_lock
);
2186 list_add(&tcon
->tcon_list
, &ses
->tcon_list
);
2187 spin_unlock(&cifs_tcp_ses_lock
);
2189 cifs_fscache_get_super_cookie(tcon
);
2199 cifs_put_tlink(struct tcon_link
*tlink
)
2201 if (!tlink
|| IS_ERR(tlink
))
2204 if (!atomic_dec_and_test(&tlink
->tl_count
) ||
2205 test_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
)) {
2206 tlink
->tl_time
= jiffies
;
2210 if (!IS_ERR(tlink_tcon(tlink
)))
2211 cifs_put_tcon(tlink_tcon(tlink
));
2216 static inline struct tcon_link
*
2217 cifs_sb_master_tlink(struct cifs_sb_info
*cifs_sb
)
2219 return cifs_sb
->master_tlink
;
2223 compare_mount_options(struct super_block
*sb
, struct cifs_mnt_data
*mnt_data
)
2225 struct cifs_sb_info
*old
= CIFS_SB(sb
);
2226 struct cifs_sb_info
*new = mnt_data
->cifs_sb
;
2228 if ((sb
->s_flags
& CIFS_MS_MASK
) != (mnt_data
->flags
& CIFS_MS_MASK
))
2231 if ((old
->mnt_cifs_flags
& CIFS_MOUNT_MASK
) !=
2232 (new->mnt_cifs_flags
& CIFS_MOUNT_MASK
))
2235 if (old
->rsize
!= new->rsize
)
2239 * We want to share sb only if we don't specify wsize or specified wsize
2240 * is greater or equal than existing one.
2242 if (new->wsize
&& new->wsize
< old
->wsize
)
2245 if (old
->mnt_uid
!= new->mnt_uid
|| old
->mnt_gid
!= new->mnt_gid
)
2248 if (old
->mnt_file_mode
!= new->mnt_file_mode
||
2249 old
->mnt_dir_mode
!= new->mnt_dir_mode
)
2252 if (strcmp(old
->local_nls
->charset
, new->local_nls
->charset
))
2255 if (old
->actimeo
!= new->actimeo
)
2262 cifs_match_super(struct super_block
*sb
, void *data
)
2264 struct cifs_mnt_data
*mnt_data
= (struct cifs_mnt_data
*)data
;
2265 struct smb_vol
*volume_info
;
2266 struct cifs_sb_info
*cifs_sb
;
2267 struct TCP_Server_Info
*tcp_srv
;
2268 struct cifs_ses
*ses
;
2269 struct cifs_tcon
*tcon
;
2270 struct tcon_link
*tlink
;
2271 struct sockaddr_storage addr
;
2274 memset(&addr
, 0, sizeof(struct sockaddr_storage
));
2276 spin_lock(&cifs_tcp_ses_lock
);
2277 cifs_sb
= CIFS_SB(sb
);
2278 tlink
= cifs_get_tlink(cifs_sb_master_tlink(cifs_sb
));
2279 if (IS_ERR(tlink
)) {
2280 spin_unlock(&cifs_tcp_ses_lock
);
2283 tcon
= tlink_tcon(tlink
);
2285 tcp_srv
= ses
->server
;
2287 volume_info
= mnt_data
->vol
;
2289 if (!volume_info
->UNCip
|| !volume_info
->UNC
)
2292 rc
= cifs_fill_sockaddr((struct sockaddr
*)&addr
,
2294 strlen(volume_info
->UNCip
),
2299 if (!match_server(tcp_srv
, (struct sockaddr
*)&addr
, volume_info
) ||
2300 !match_session(ses
, volume_info
) ||
2301 !match_tcon(tcon
, volume_info
->UNC
)) {
2306 rc
= compare_mount_options(sb
, mnt_data
);
2308 spin_unlock(&cifs_tcp_ses_lock
);
2309 cifs_put_tlink(tlink
);
2314 get_dfs_path(int xid
, struct cifs_ses
*pSesInfo
, const char *old_path
,
2315 const struct nls_table
*nls_codepage
, unsigned int *pnum_referrals
,
2316 struct dfs_info3_param
**preferrals
, int remap
)
2321 *pnum_referrals
= 0;
2324 if (pSesInfo
->ipc_tid
== 0) {
2325 temp_unc
= kmalloc(2 /* for slashes */ +
2326 strnlen(pSesInfo
->serverName
,
2327 SERVER_NAME_LEN_WITH_NULL
* 2)
2328 + 1 + 4 /* slash IPC$ */ + 2,
2330 if (temp_unc
== NULL
)
2334 strcpy(temp_unc
+ 2, pSesInfo
->serverName
);
2335 strcpy(temp_unc
+ 2 + strlen(pSesInfo
->serverName
), "\\IPC$");
2336 rc
= CIFSTCon(xid
, pSesInfo
, temp_unc
, NULL
, nls_codepage
);
2337 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc
, pSesInfo
->ipc_tid
);
2341 rc
= CIFSGetDFSRefer(xid
, pSesInfo
, old_path
, preferrals
,
2342 pnum_referrals
, nls_codepage
, remap
);
2343 /* BB map targetUNCs to dfs_info3 structures, here or
2344 in CIFSGetDFSRefer BB */
2349 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2350 static struct lock_class_key cifs_key
[2];
2351 static struct lock_class_key cifs_slock_key
[2];
2354 cifs_reclassify_socket4(struct socket
*sock
)
2356 struct sock
*sk
= sock
->sk
;
2357 BUG_ON(sock_owned_by_user(sk
));
2358 sock_lock_init_class_and_name(sk
, "slock-AF_INET-CIFS",
2359 &cifs_slock_key
[0], "sk_lock-AF_INET-CIFS", &cifs_key
[0]);
2363 cifs_reclassify_socket6(struct socket
*sock
)
2365 struct sock
*sk
= sock
->sk
;
2366 BUG_ON(sock_owned_by_user(sk
));
2367 sock_lock_init_class_and_name(sk
, "slock-AF_INET6-CIFS",
2368 &cifs_slock_key
[1], "sk_lock-AF_INET6-CIFS", &cifs_key
[1]);
2372 cifs_reclassify_socket4(struct socket
*sock
)
2377 cifs_reclassify_socket6(struct socket
*sock
)
2382 /* See RFC1001 section 14 on representation of Netbios names */
2383 static void rfc1002mangle(char *target
, char *source
, unsigned int length
)
2387 for (i
= 0, j
= 0; i
< (length
); i
++) {
2388 /* mask a nibble at a time and encode */
2389 target
[j
] = 'A' + (0x0F & (source
[i
] >> 4));
2390 target
[j
+1] = 'A' + (0x0F & source
[i
]);
2397 bind_socket(struct TCP_Server_Info
*server
)
2400 if (server
->srcaddr
.ss_family
!= AF_UNSPEC
) {
2401 /* Bind to the specified local IP address */
2402 struct socket
*socket
= server
->ssocket
;
2403 rc
= socket
->ops
->bind(socket
,
2404 (struct sockaddr
*) &server
->srcaddr
,
2405 sizeof(server
->srcaddr
));
2407 struct sockaddr_in
*saddr4
;
2408 struct sockaddr_in6
*saddr6
;
2409 saddr4
= (struct sockaddr_in
*)&server
->srcaddr
;
2410 saddr6
= (struct sockaddr_in6
*)&server
->srcaddr
;
2411 if (saddr6
->sin6_family
== AF_INET6
)
2413 "Failed to bind to: %pI6c, error: %d\n",
2414 &saddr6
->sin6_addr
, rc
);
2417 "Failed to bind to: %pI4, error: %d\n",
2418 &saddr4
->sin_addr
.s_addr
, rc
);
2425 ip_rfc1001_connect(struct TCP_Server_Info
*server
)
2429 * some servers require RFC1001 sessinit before sending
2430 * negprot - BB check reconnection in case where second
2431 * sessinit is sent but no second negprot
2433 struct rfc1002_session_packet
*ses_init_buf
;
2434 struct smb_hdr
*smb_buf
;
2435 ses_init_buf
= kzalloc(sizeof(struct rfc1002_session_packet
),
2438 ses_init_buf
->trailer
.session_req
.called_len
= 32;
2440 if (server
->server_RFC1001_name
&&
2441 server
->server_RFC1001_name
[0] != 0)
2442 rfc1002mangle(ses_init_buf
->trailer
.
2443 session_req
.called_name
,
2444 server
->server_RFC1001_name
,
2445 RFC1001_NAME_LEN_WITH_NULL
);
2447 rfc1002mangle(ses_init_buf
->trailer
.
2448 session_req
.called_name
,
2449 DEFAULT_CIFS_CALLED_NAME
,
2450 RFC1001_NAME_LEN_WITH_NULL
);
2452 ses_init_buf
->trailer
.session_req
.calling_len
= 32;
2455 * calling name ends in null (byte 16) from old smb
2458 if (server
->workstation_RFC1001_name
&&
2459 server
->workstation_RFC1001_name
[0] != 0)
2460 rfc1002mangle(ses_init_buf
->trailer
.
2461 session_req
.calling_name
,
2462 server
->workstation_RFC1001_name
,
2463 RFC1001_NAME_LEN_WITH_NULL
);
2465 rfc1002mangle(ses_init_buf
->trailer
.
2466 session_req
.calling_name
,
2468 RFC1001_NAME_LEN_WITH_NULL
);
2470 ses_init_buf
->trailer
.session_req
.scope1
= 0;
2471 ses_init_buf
->trailer
.session_req
.scope2
= 0;
2472 smb_buf
= (struct smb_hdr
*)ses_init_buf
;
2474 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2475 smb_buf
->smb_buf_length
= cpu_to_be32(0x81000044);
2476 rc
= smb_send(server
, smb_buf
, 0x44);
2477 kfree(ses_init_buf
);
2479 * RFC1001 layer in at least one server
2480 * requires very short break before negprot
2481 * presumably because not expecting negprot
2482 * to follow so fast. This is a simple
2483 * solution that works without
2484 * complicating the code and causes no
2485 * significant slowing down on mount
2488 usleep_range(1000, 2000);
2491 * else the negprot may still work without this
2492 * even though malloc failed
2499 generic_ip_connect(struct TCP_Server_Info
*server
)
2504 struct socket
*socket
= server
->ssocket
;
2505 struct sockaddr
*saddr
;
2507 saddr
= (struct sockaddr
*) &server
->dstaddr
;
2509 if (server
->dstaddr
.ss_family
== AF_INET6
) {
2510 sport
= ((struct sockaddr_in6
*) saddr
)->sin6_port
;
2511 slen
= sizeof(struct sockaddr_in6
);
2514 sport
= ((struct sockaddr_in
*) saddr
)->sin_port
;
2515 slen
= sizeof(struct sockaddr_in
);
2519 if (socket
== NULL
) {
2520 rc
= __sock_create(cifs_net_ns(server
), sfamily
, SOCK_STREAM
,
2521 IPPROTO_TCP
, &socket
, 1);
2523 cERROR(1, "Error %d creating socket", rc
);
2524 server
->ssocket
= NULL
;
2528 /* BB other socket options to set KEEPALIVE, NODELAY? */
2529 cFYI(1, "Socket created");
2530 server
->ssocket
= socket
;
2531 socket
->sk
->sk_allocation
= GFP_NOFS
;
2532 if (sfamily
== AF_INET6
)
2533 cifs_reclassify_socket6(socket
);
2535 cifs_reclassify_socket4(socket
);
2538 rc
= bind_socket(server
);
2543 * Eventually check for other socket options to change from
2544 * the default. sock_setsockopt not used because it expects
2547 socket
->sk
->sk_rcvtimeo
= 7 * HZ
;
2548 socket
->sk
->sk_sndtimeo
= 5 * HZ
;
2550 /* make the bufsizes depend on wsize/rsize and max requests */
2551 if (server
->noautotune
) {
2552 if (socket
->sk
->sk_sndbuf
< (200 * 1024))
2553 socket
->sk
->sk_sndbuf
= 200 * 1024;
2554 if (socket
->sk
->sk_rcvbuf
< (140 * 1024))
2555 socket
->sk
->sk_rcvbuf
= 140 * 1024;
2558 if (server
->tcp_nodelay
) {
2560 rc
= kernel_setsockopt(socket
, SOL_TCP
, TCP_NODELAY
,
2561 (char *)&val
, sizeof(val
));
2563 cFYI(1, "set TCP_NODELAY socket option error %d", rc
);
2566 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
2567 socket
->sk
->sk_sndbuf
,
2568 socket
->sk
->sk_rcvbuf
, socket
->sk
->sk_rcvtimeo
);
2570 rc
= socket
->ops
->connect(socket
, saddr
, slen
, 0);
2572 cFYI(1, "Error %d connecting to server", rc
);
2573 sock_release(socket
);
2574 server
->ssocket
= NULL
;
2578 if (sport
== htons(RFC1001_PORT
))
2579 rc
= ip_rfc1001_connect(server
);
2585 ip_connect(struct TCP_Server_Info
*server
)
2588 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)&server
->dstaddr
;
2589 struct sockaddr_in
*addr
= (struct sockaddr_in
*)&server
->dstaddr
;
2591 if (server
->dstaddr
.ss_family
== AF_INET6
)
2592 sport
= &addr6
->sin6_port
;
2594 sport
= &addr
->sin_port
;
2599 /* try with 445 port at first */
2600 *sport
= htons(CIFS_PORT
);
2602 rc
= generic_ip_connect(server
);
2606 /* if it failed, try with 139 port */
2607 *sport
= htons(RFC1001_PORT
);
2610 return generic_ip_connect(server
);
2613 void reset_cifs_unix_caps(int xid
, struct cifs_tcon
*tcon
,
2614 struct cifs_sb_info
*cifs_sb
, struct smb_vol
*vol_info
)
2616 /* if we are reconnecting then should we check to see if
2617 * any requested capabilities changed locally e.g. via
2618 * remount but we can not do much about it here
2619 * if they have (even if we could detect it by the following)
2620 * Perhaps we could add a backpointer to array of sb from tcon
2621 * or if we change to make all sb to same share the same
2622 * sb as NFS - then we only have one backpointer to sb.
2623 * What if we wanted to mount the server share twice once with
2624 * and once without posixacls or posix paths? */
2625 __u64 saved_cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
2627 if (vol_info
&& vol_info
->no_linux_ext
) {
2628 tcon
->fsUnixInfo
.Capability
= 0;
2629 tcon
->unix_ext
= 0; /* Unix Extensions disabled */
2630 cFYI(1, "Linux protocol extensions disabled");
2632 } else if (vol_info
)
2633 tcon
->unix_ext
= 1; /* Unix Extensions supported */
2635 if (tcon
->unix_ext
== 0) {
2636 cFYI(1, "Unix extensions disabled so not set on reconnect");
2640 if (!CIFSSMBQFSUnixInfo(xid
, tcon
)) {
2641 __u64 cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
2642 cFYI(1, "unix caps which server supports %lld", cap
);
2643 /* check for reconnect case in which we do not
2644 want to change the mount behavior if we can avoid it */
2645 if (vol_info
== NULL
) {
2646 /* turn off POSIX ACL and PATHNAMES if not set
2647 originally at mount time */
2648 if ((saved_cap
& CIFS_UNIX_POSIX_ACL_CAP
) == 0)
2649 cap
&= ~CIFS_UNIX_POSIX_ACL_CAP
;
2650 if ((saved_cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) == 0) {
2651 if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)
2652 cERROR(1, "POSIXPATH support change");
2653 cap
&= ~CIFS_UNIX_POSIX_PATHNAMES_CAP
;
2654 } else if ((cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) == 0) {
2655 cERROR(1, "possible reconnect error");
2656 cERROR(1, "server disabled POSIX path support");
2660 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)
2661 cERROR(1, "per-share encryption not supported yet");
2663 cap
&= CIFS_UNIX_CAP_MASK
;
2664 if (vol_info
&& vol_info
->no_psx_acl
)
2665 cap
&= ~CIFS_UNIX_POSIX_ACL_CAP
;
2666 else if (CIFS_UNIX_POSIX_ACL_CAP
& cap
) {
2667 cFYI(1, "negotiated posix acl support");
2669 cifs_sb
->mnt_cifs_flags
|=
2670 CIFS_MOUNT_POSIXACL
;
2673 if (vol_info
&& vol_info
->posix_paths
== 0)
2674 cap
&= ~CIFS_UNIX_POSIX_PATHNAMES_CAP
;
2675 else if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) {
2676 cFYI(1, "negotiate posix pathnames");
2678 cifs_sb
->mnt_cifs_flags
|=
2679 CIFS_MOUNT_POSIX_PATHS
;
2682 if (cifs_sb
&& (cifs_sb
->rsize
> 127 * 1024)) {
2683 if ((cap
& CIFS_UNIX_LARGE_READ_CAP
) == 0) {
2684 cifs_sb
->rsize
= 127 * 1024;
2685 cFYI(DBG2
, "larger reads not supported by srv");
2690 cFYI(1, "Negotiate caps 0x%x", (int)cap
);
2691 #ifdef CONFIG_CIFS_DEBUG2
2692 if (cap
& CIFS_UNIX_FCNTL_CAP
)
2693 cFYI(1, "FCNTL cap");
2694 if (cap
& CIFS_UNIX_EXTATTR_CAP
)
2695 cFYI(1, "EXTATTR cap");
2696 if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)
2697 cFYI(1, "POSIX path cap");
2698 if (cap
& CIFS_UNIX_XATTR_CAP
)
2699 cFYI(1, "XATTR cap");
2700 if (cap
& CIFS_UNIX_POSIX_ACL_CAP
)
2701 cFYI(1, "POSIX ACL cap");
2702 if (cap
& CIFS_UNIX_LARGE_READ_CAP
)
2703 cFYI(1, "very large read cap");
2704 if (cap
& CIFS_UNIX_LARGE_WRITE_CAP
)
2705 cFYI(1, "very large write cap");
2706 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP
)
2707 cFYI(1, "transport encryption cap");
2708 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)
2709 cFYI(1, "mandatory transport encryption cap");
2710 #endif /* CIFS_DEBUG2 */
2711 if (CIFSSMBSetFSUnixInfo(xid
, tcon
, cap
)) {
2712 if (vol_info
== NULL
) {
2713 cFYI(1, "resetting capabilities failed");
2715 cERROR(1, "Negotiating Unix capabilities "
2716 "with the server failed. Consider "
2717 "mounting with the Unix Extensions\n"
2718 "disabled, if problems are found, "
2719 "by specifying the nounix mount "
2726 void cifs_setup_cifs_sb(struct smb_vol
*pvolume_info
,
2727 struct cifs_sb_info
*cifs_sb
)
2729 INIT_DELAYED_WORK(&cifs_sb
->prune_tlinks
, cifs_prune_tlinks
);
2731 spin_lock_init(&cifs_sb
->tlink_tree_lock
);
2732 cifs_sb
->tlink_tree
= RB_ROOT
;
2734 if (pvolume_info
->rsize
> CIFSMaxBufSize
) {
2735 cERROR(1, "rsize %d too large, using MaxBufSize",
2736 pvolume_info
->rsize
);
2737 cifs_sb
->rsize
= CIFSMaxBufSize
;
2738 } else if ((pvolume_info
->rsize
) &&
2739 (pvolume_info
->rsize
<= CIFSMaxBufSize
))
2740 cifs_sb
->rsize
= pvolume_info
->rsize
;
2742 cifs_sb
->rsize
= CIFSMaxBufSize
;
2744 if (cifs_sb
->rsize
< 2048) {
2745 cifs_sb
->rsize
= 2048;
2746 /* Windows ME may prefer this */
2747 cFYI(1, "readsize set to minimum: 2048");
2751 * Temporarily set wsize for matching superblock. If we end up using
2752 * new sb then cifs_negotiate_wsize will later negotiate it downward
2755 cifs_sb
->wsize
= pvolume_info
->wsize
;
2757 cifs_sb
->mnt_uid
= pvolume_info
->linux_uid
;
2758 cifs_sb
->mnt_gid
= pvolume_info
->linux_gid
;
2759 if (pvolume_info
->backupuid_specified
)
2760 cifs_sb
->mnt_backupuid
= pvolume_info
->backupuid
;
2761 if (pvolume_info
->backupgid_specified
)
2762 cifs_sb
->mnt_backupgid
= pvolume_info
->backupgid
;
2763 cifs_sb
->mnt_file_mode
= pvolume_info
->file_mode
;
2764 cifs_sb
->mnt_dir_mode
= pvolume_info
->dir_mode
;
2765 cFYI(1, "file mode: 0x%x dir mode: 0x%x",
2766 cifs_sb
->mnt_file_mode
, cifs_sb
->mnt_dir_mode
);
2768 cifs_sb
->actimeo
= pvolume_info
->actimeo
;
2769 cifs_sb
->local_nls
= pvolume_info
->local_nls
;
2771 if (pvolume_info
->noperm
)
2772 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_PERM
;
2773 if (pvolume_info
->setuids
)
2774 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_SET_UID
;
2775 if (pvolume_info
->server_ino
)
2776 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_SERVER_INUM
;
2777 if (pvolume_info
->remap
)
2778 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MAP_SPECIAL_CHR
;
2779 if (pvolume_info
->no_xattr
)
2780 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_XATTR
;
2781 if (pvolume_info
->sfu_emul
)
2782 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_UNX_EMUL
;
2783 if (pvolume_info
->nobrl
)
2784 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_BRL
;
2785 if (pvolume_info
->nostrictsync
)
2786 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NOSSYNC
;
2787 if (pvolume_info
->mand_lock
)
2788 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NOPOSIXBRL
;
2789 if (pvolume_info
->rwpidforward
)
2790 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_RWPIDFORWARD
;
2791 if (pvolume_info
->cifs_acl
)
2792 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_ACL
;
2793 if (pvolume_info
->backupuid_specified
)
2794 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_BACKUPUID
;
2795 if (pvolume_info
->backupgid_specified
)
2796 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_BACKUPGID
;
2797 if (pvolume_info
->override_uid
)
2798 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_OVERR_UID
;
2799 if (pvolume_info
->override_gid
)
2800 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_OVERR_GID
;
2801 if (pvolume_info
->dynperm
)
2802 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_DYNPERM
;
2803 if (pvolume_info
->fsc
)
2804 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_FSCACHE
;
2805 if (pvolume_info
->multiuser
)
2806 cifs_sb
->mnt_cifs_flags
|= (CIFS_MOUNT_MULTIUSER
|
2807 CIFS_MOUNT_NO_PERM
);
2808 if (pvolume_info
->strict_io
)
2809 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_STRICT_IO
;
2810 if (pvolume_info
->direct_io
) {
2811 cFYI(1, "mounting share using direct i/o");
2812 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_DIRECT_IO
;
2814 if (pvolume_info
->mfsymlinks
) {
2815 if (pvolume_info
->sfu_emul
) {
2816 cERROR(1, "mount option mfsymlinks ignored if sfu "
2817 "mount option is used");
2819 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MF_SYMLINKS
;
2823 if ((pvolume_info
->cifs_acl
) && (pvolume_info
->dynperm
))
2824 cERROR(1, "mount option dynperm ignored if cifsacl "
2825 "mount option supported");
2829 * When the server supports very large writes via POSIX extensions, we can
2830 * allow up to 2^24-1, minus the size of a WRITE_AND_X header, not including
2831 * the RFC1001 length.
2833 * Note that this might make for "interesting" allocation problems during
2834 * writeback however as we have to allocate an array of pointers for the
2835 * pages. A 16M write means ~32kb page array with PAGE_CACHE_SIZE == 4096.
2837 #define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
2840 * When the server doesn't allow large posix writes, only allow a wsize of
2841 * 128k minus the size of the WRITE_AND_X header. That allows for a write up
2842 * to the maximum size described by RFC1002.
2844 #define CIFS_MAX_RFC1002_WSIZE (128 * 1024 - sizeof(WRITE_REQ) + 4)
2847 * The default wsize is 1M. find_get_pages seems to return a maximum of 256
2848 * pages in a single call. With PAGE_CACHE_SIZE == 4k, this means we can fill
2849 * a single wsize request with a single call.
2851 #define CIFS_DEFAULT_WSIZE (1024 * 1024)
2854 cifs_negotiate_wsize(struct cifs_tcon
*tcon
, struct smb_vol
*pvolume_info
)
2856 __u64 unix_cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
2857 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
2858 unsigned int wsize
= pvolume_info
->wsize
? pvolume_info
->wsize
:
2861 /* can server support 24-bit write sizes? (via UNIX extensions) */
2862 if (!tcon
->unix_ext
|| !(unix_cap
& CIFS_UNIX_LARGE_WRITE_CAP
))
2863 wsize
= min_t(unsigned int, wsize
, CIFS_MAX_RFC1002_WSIZE
);
2866 * no CAP_LARGE_WRITE_X or is signing enabled without CAP_UNIX set?
2867 * Limit it to max buffer offered by the server, minus the size of the
2868 * WRITEX header, not including the 4 byte RFC1001 length.
2870 if (!(server
->capabilities
& CAP_LARGE_WRITE_X
) ||
2871 (!(server
->capabilities
& CAP_UNIX
) &&
2872 (server
->sec_mode
& (SECMODE_SIGN_ENABLED
|SECMODE_SIGN_REQUIRED
))))
2873 wsize
= min_t(unsigned int, wsize
,
2874 server
->maxBuf
- sizeof(WRITE_REQ
) + 4);
2876 /* hard limit of CIFS_MAX_WSIZE */
2877 wsize
= min_t(unsigned int, wsize
, CIFS_MAX_WSIZE
);
2883 is_path_accessible(int xid
, struct cifs_tcon
*tcon
,
2884 struct cifs_sb_info
*cifs_sb
, const char *full_path
)
2887 FILE_ALL_INFO
*pfile_info
;
2889 pfile_info
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
2890 if (pfile_info
== NULL
)
2893 rc
= CIFSSMBQPathInfo(xid
, tcon
, full_path
, pfile_info
,
2894 0 /* not legacy */, cifs_sb
->local_nls
,
2895 cifs_sb
->mnt_cifs_flags
&
2896 CIFS_MOUNT_MAP_SPECIAL_CHR
);
2898 if (rc
== -EOPNOTSUPP
|| rc
== -EINVAL
)
2899 rc
= SMBQueryInformation(xid
, tcon
, full_path
, pfile_info
,
2900 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
2901 CIFS_MOUNT_MAP_SPECIAL_CHR
);
2907 cleanup_volume_info_contents(struct smb_vol
*volume_info
)
2909 kfree(volume_info
->username
);
2910 kzfree(volume_info
->password
);
2911 kfree(volume_info
->UNC
);
2912 if (volume_info
->UNCip
!= volume_info
->UNC
+ 2)
2913 kfree(volume_info
->UNCip
);
2914 kfree(volume_info
->domainname
);
2915 kfree(volume_info
->iocharset
);
2916 kfree(volume_info
->prepath
);
2920 cifs_cleanup_volume_info(struct smb_vol
*volume_info
)
2924 cleanup_volume_info_contents(volume_info
);
2929 #ifdef CONFIG_CIFS_DFS_UPCALL
2930 /* build_path_to_root returns full path to root when
2931 * we do not have an exiting connection (tcon) */
2933 build_unc_path_to_root(const struct smb_vol
*vol
,
2934 const struct cifs_sb_info
*cifs_sb
)
2936 char *full_path
, *pos
;
2937 unsigned int pplen
= vol
->prepath
? strlen(vol
->prepath
) : 0;
2938 unsigned int unc_len
= strnlen(vol
->UNC
, MAX_TREE_SIZE
+ 1);
2940 full_path
= kmalloc(unc_len
+ pplen
+ 1, GFP_KERNEL
);
2941 if (full_path
== NULL
)
2942 return ERR_PTR(-ENOMEM
);
2944 strncpy(full_path
, vol
->UNC
, unc_len
);
2945 pos
= full_path
+ unc_len
;
2948 strncpy(pos
, vol
->prepath
, pplen
);
2952 *pos
= '\0'; /* add trailing null */
2953 convert_delimiter(full_path
, CIFS_DIR_SEP(cifs_sb
));
2954 cFYI(1, "%s: full_path=%s", __func__
, full_path
);
2959 * Perform a dfs referral query for a share and (optionally) prefix
2961 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
2962 * to a string containing updated options for the submount. Otherwise it
2963 * will be left untouched.
2965 * Returns the rc from get_dfs_path to the caller, which can be used to
2966 * determine whether there were referrals.
2969 expand_dfs_referral(int xid
, struct cifs_ses
*pSesInfo
,
2970 struct smb_vol
*volume_info
, struct cifs_sb_info
*cifs_sb
,
2974 unsigned int num_referrals
= 0;
2975 struct dfs_info3_param
*referrals
= NULL
;
2976 char *full_path
= NULL
, *ref_path
= NULL
, *mdata
= NULL
;
2978 full_path
= build_unc_path_to_root(volume_info
, cifs_sb
);
2979 if (IS_ERR(full_path
))
2980 return PTR_ERR(full_path
);
2982 /* For DFS paths, skip the first '\' of the UNC */
2983 ref_path
= check_prefix
? full_path
+ 1 : volume_info
->UNC
+ 1;
2985 rc
= get_dfs_path(xid
, pSesInfo
, ref_path
, cifs_sb
->local_nls
,
2986 &num_referrals
, &referrals
,
2987 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
2989 if (!rc
&& num_referrals
> 0) {
2990 char *fake_devname
= NULL
;
2992 mdata
= cifs_compose_mount_options(cifs_sb
->mountdata
,
2993 full_path
+ 1, referrals
,
2996 free_dfs_info_array(referrals
, num_referrals
);
2998 if (IS_ERR(mdata
)) {
2999 rc
= PTR_ERR(mdata
);
3002 cleanup_volume_info_contents(volume_info
);
3003 memset(volume_info
, '\0', sizeof(*volume_info
));
3004 rc
= cifs_setup_volume_info(volume_info
, mdata
,
3007 kfree(fake_devname
);
3008 kfree(cifs_sb
->mountdata
);
3009 cifs_sb
->mountdata
= mdata
;
3017 cifs_setup_volume_info(struct smb_vol
*volume_info
, char *mount_data
,
3018 const char *devname
)
3022 if (cifs_parse_mount_options(mount_data
, devname
, volume_info
))
3025 if (volume_info
->nullauth
) {
3026 cFYI(1, "null user");
3027 volume_info
->username
= kzalloc(1, GFP_KERNEL
);
3028 if (volume_info
->username
== NULL
)
3030 } else if (volume_info
->username
) {
3031 /* BB fixme parse for domain name here */
3032 cFYI(1, "Username: %s", volume_info
->username
);
3034 cifserror("No username specified");
3035 /* In userspace mount helper we can get user name from alternate
3036 locations such as env variables and files on disk */
3040 /* this is needed for ASCII cp to Unicode converts */
3041 if (volume_info
->iocharset
== NULL
) {
3042 /* load_nls_default cannot return null */
3043 volume_info
->local_nls
= load_nls_default();
3045 volume_info
->local_nls
= load_nls(volume_info
->iocharset
);
3046 if (volume_info
->local_nls
== NULL
) {
3047 cERROR(1, "CIFS mount error: iocharset %s not found",
3048 volume_info
->iocharset
);
3057 cifs_get_volume_info(char *mount_data
, const char *devname
)
3060 struct smb_vol
*volume_info
;
3062 volume_info
= kzalloc(sizeof(struct smb_vol
), GFP_KERNEL
);
3064 return ERR_PTR(-ENOMEM
);
3066 rc
= cifs_setup_volume_info(volume_info
, mount_data
, devname
);
3068 cifs_cleanup_volume_info(volume_info
);
3069 volume_info
= ERR_PTR(rc
);
3076 cifs_mount(struct cifs_sb_info
*cifs_sb
, struct smb_vol
*volume_info
)
3080 struct cifs_ses
*pSesInfo
;
3081 struct cifs_tcon
*tcon
;
3082 struct TCP_Server_Info
*srvTcp
;
3084 struct tcon_link
*tlink
;
3085 #ifdef CONFIG_CIFS_DFS_UPCALL
3086 int referral_walks_count
= 0;
3089 rc
= bdi_setup_and_register(&cifs_sb
->bdi
, "cifs", BDI_CAP_MAP_COPY
);
3093 cifs_sb
->bdi
.ra_pages
= default_backing_dev_info
.ra_pages
;
3095 #ifdef CONFIG_CIFS_DFS_UPCALL
3097 /* cleanup activities if we're chasing a referral */
3098 if (referral_walks_count
) {
3100 cifs_put_tcon(tcon
);
3102 cifs_put_smb_ses(pSesInfo
);
3115 /* get a reference to a tcp session */
3116 srvTcp
= cifs_get_tcp_session(volume_info
);
3117 if (IS_ERR(srvTcp
)) {
3118 rc
= PTR_ERR(srvTcp
);
3119 bdi_destroy(&cifs_sb
->bdi
);
3123 /* get a reference to a SMB session */
3124 pSesInfo
= cifs_get_smb_ses(srvTcp
, volume_info
);
3125 if (IS_ERR(pSesInfo
)) {
3126 rc
= PTR_ERR(pSesInfo
);
3128 goto mount_fail_check
;
3131 /* search for existing tcon to this server share */
3132 tcon
= cifs_get_tcon(pSesInfo
, volume_info
);
3136 goto remote_path_check
;
3139 /* tell server which Unix caps we support */
3140 if (tcon
->ses
->capabilities
& CAP_UNIX
) {
3141 /* reset of caps checks mount to see if unix extensions
3142 disabled for just this mount */
3143 reset_cifs_unix_caps(xid
, tcon
, cifs_sb
, volume_info
);
3144 if ((tcon
->ses
->server
->tcpStatus
== CifsNeedReconnect
) &&
3145 (le64_to_cpu(tcon
->fsUnixInfo
.Capability
) &
3146 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)) {
3148 goto mount_fail_check
;
3151 tcon
->unix_ext
= 0; /* server does not support them */
3153 /* do not care if following two calls succeed - informational */
3155 CIFSSMBQFSDeviceInfo(xid
, tcon
);
3156 CIFSSMBQFSAttributeInfo(xid
, tcon
);
3159 if ((tcon
->unix_ext
== 0) && (cifs_sb
->rsize
> (1024 * 127))) {
3160 cifs_sb
->rsize
= 1024 * 127;
3161 cFYI(DBG2
, "no very large read support, rsize now 127K");
3163 if (!(tcon
->ses
->capabilities
& CAP_LARGE_READ_X
))
3164 cifs_sb
->rsize
= min(cifs_sb
->rsize
, CIFSMaxBufSize
);
3166 cifs_sb
->wsize
= cifs_negotiate_wsize(tcon
, volume_info
);
3169 #ifdef CONFIG_CIFS_DFS_UPCALL
3171 * Perform an unconditional check for whether there are DFS
3172 * referrals for this path without prefix, to provide support
3173 * for DFS referrals from w2k8 servers which don't seem to respond
3174 * with PATH_NOT_COVERED to requests that include the prefix.
3175 * Chase the referral if found, otherwise continue normally.
3177 if (referral_walks_count
== 0) {
3178 int refrc
= expand_dfs_referral(xid
, pSesInfo
, volume_info
,
3181 referral_walks_count
++;
3182 goto try_mount_again
;
3187 /* check if a whole path is not remote */
3189 /* build_path_to_root works only when we have a valid tcon */
3190 full_path
= cifs_build_path_to_root(volume_info
, cifs_sb
, tcon
);
3191 if (full_path
== NULL
) {
3193 goto mount_fail_check
;
3195 rc
= is_path_accessible(xid
, tcon
, cifs_sb
, full_path
);
3196 if (rc
!= 0 && rc
!= -EREMOTE
) {
3198 goto mount_fail_check
;
3203 /* get referral if needed */
3204 if (rc
== -EREMOTE
) {
3205 #ifdef CONFIG_CIFS_DFS_UPCALL
3206 if (referral_walks_count
> MAX_NESTED_LINKS
) {
3208 * BB: when we implement proper loop detection,
3209 * we will remove this check. But now we need it
3210 * to prevent an indefinite loop if 'DFS tree' is
3211 * misconfigured (i.e. has loops).
3214 goto mount_fail_check
;
3217 rc
= expand_dfs_referral(xid
, pSesInfo
, volume_info
, cifs_sb
,
3221 referral_walks_count
++;
3222 goto try_mount_again
;
3224 goto mount_fail_check
;
3225 #else /* No DFS support, return error on mount */
3231 goto mount_fail_check
;
3233 /* now, hang the tcon off of the superblock */
3234 tlink
= kzalloc(sizeof *tlink
, GFP_KERNEL
);
3235 if (tlink
== NULL
) {
3237 goto mount_fail_check
;
3240 tlink
->tl_uid
= pSesInfo
->linux_uid
;
3241 tlink
->tl_tcon
= tcon
;
3242 tlink
->tl_time
= jiffies
;
3243 set_bit(TCON_LINK_MASTER
, &tlink
->tl_flags
);
3244 set_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
3246 cifs_sb
->master_tlink
= tlink
;
3247 spin_lock(&cifs_sb
->tlink_tree_lock
);
3248 tlink_rb_insert(&cifs_sb
->tlink_tree
, tlink
);
3249 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3251 queue_delayed_work(system_nrt_wq
, &cifs_sb
->prune_tlinks
,
3255 /* on error free sesinfo and tcon struct if needed */
3257 /* If find_unc succeeded then rc == 0 so we can not end */
3258 /* up accidentally freeing someone elses tcon struct */
3260 cifs_put_tcon(tcon
);
3262 cifs_put_smb_ses(pSesInfo
);
3264 cifs_put_tcp_session(srvTcp
);
3265 bdi_destroy(&cifs_sb
->bdi
);
3274 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3275 * pointer may be NULL.
3278 CIFSTCon(unsigned int xid
, struct cifs_ses
*ses
,
3279 const char *tree
, struct cifs_tcon
*tcon
,
3280 const struct nls_table
*nls_codepage
)
3282 struct smb_hdr
*smb_buffer
;
3283 struct smb_hdr
*smb_buffer_response
;
3286 unsigned char *bcc_ptr
;
3289 __u16 bytes_left
, count
;
3294 smb_buffer
= cifs_buf_get();
3295 if (smb_buffer
== NULL
)
3298 smb_buffer_response
= smb_buffer
;
3300 header_assemble(smb_buffer
, SMB_COM_TREE_CONNECT_ANDX
,
3301 NULL
/*no tid */ , 4 /*wct */ );
3303 smb_buffer
->Mid
= GetNextMid(ses
->server
);
3304 smb_buffer
->Uid
= ses
->Suid
;
3305 pSMB
= (TCONX_REQ
*) smb_buffer
;
3306 pSMBr
= (TCONX_RSP
*) smb_buffer_response
;
3308 pSMB
->AndXCommand
= 0xFF;
3309 pSMB
->Flags
= cpu_to_le16(TCON_EXTENDED_SECINFO
);
3310 bcc_ptr
= &pSMB
->Password
[0];
3311 if (!tcon
|| (ses
->server
->sec_mode
& SECMODE_USER
)) {
3312 pSMB
->PasswordLength
= cpu_to_le16(1); /* minimum */
3313 *bcc_ptr
= 0; /* password is null byte */
3314 bcc_ptr
++; /* skip password */
3315 /* already aligned so no need to do it below */
3317 pSMB
->PasswordLength
= cpu_to_le16(CIFS_AUTH_RESP_SIZE
);
3318 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3319 specified as required (when that support is added to
3320 the vfs in the future) as only NTLM or the much
3321 weaker LANMAN (which we do not send by default) is accepted
3322 by Samba (not sure whether other servers allow
3323 NTLMv2 password here) */
3324 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3325 if ((global_secflags
& CIFSSEC_MAY_LANMAN
) &&
3326 (ses
->server
->secType
== LANMAN
))
3327 calc_lanman_hash(tcon
->password
, ses
->server
->cryptkey
,
3328 ses
->server
->sec_mode
&
3329 SECMODE_PW_ENCRYPT
? true : false,
3332 #endif /* CIFS_WEAK_PW_HASH */
3333 rc
= SMBNTencrypt(tcon
->password
, ses
->server
->cryptkey
,
3336 bcc_ptr
+= CIFS_AUTH_RESP_SIZE
;
3337 if (ses
->capabilities
& CAP_UNICODE
) {
3338 /* must align unicode strings */
3339 *bcc_ptr
= 0; /* null byte password */
3344 if (ses
->server
->sec_mode
&
3345 (SECMODE_SIGN_REQUIRED
| SECMODE_SIGN_ENABLED
))
3346 smb_buffer
->Flags2
|= SMBFLG2_SECURITY_SIGNATURE
;
3348 if (ses
->capabilities
& CAP_STATUS32
) {
3349 smb_buffer
->Flags2
|= SMBFLG2_ERR_STATUS
;
3351 if (ses
->capabilities
& CAP_DFS
) {
3352 smb_buffer
->Flags2
|= SMBFLG2_DFS
;
3354 if (ses
->capabilities
& CAP_UNICODE
) {
3355 smb_buffer
->Flags2
|= SMBFLG2_UNICODE
;
3357 cifs_strtoUCS((__le16
*) bcc_ptr
, tree
,
3358 6 /* max utf8 char length in bytes */ *
3359 (/* server len*/ + 256 /* share len */), nls_codepage
);
3360 bcc_ptr
+= 2 * length
; /* convert num 16 bit words to bytes */
3361 bcc_ptr
+= 2; /* skip trailing null */
3362 } else { /* ASCII */
3363 strcpy(bcc_ptr
, tree
);
3364 bcc_ptr
+= strlen(tree
) + 1;
3366 strcpy(bcc_ptr
, "?????");
3367 bcc_ptr
+= strlen("?????");
3369 count
= bcc_ptr
- &pSMB
->Password
[0];
3370 pSMB
->hdr
.smb_buf_length
= cpu_to_be32(be32_to_cpu(
3371 pSMB
->hdr
.smb_buf_length
) + count
);
3372 pSMB
->ByteCount
= cpu_to_le16(count
);
3374 rc
= SendReceive(xid
, ses
, smb_buffer
, smb_buffer_response
, &length
,
3377 /* above now done in SendReceive */
3378 if ((rc
== 0) && (tcon
!= NULL
)) {
3381 tcon
->tidStatus
= CifsGood
;
3382 tcon
->need_reconnect
= false;
3383 tcon
->tid
= smb_buffer_response
->Tid
;
3384 bcc_ptr
= pByteArea(smb_buffer_response
);
3385 bytes_left
= get_bcc(smb_buffer_response
);
3386 length
= strnlen(bcc_ptr
, bytes_left
- 2);
3387 if (smb_buffer
->Flags2
& SMBFLG2_UNICODE
)
3393 /* skip service field (NB: this field is always ASCII) */
3395 if ((bcc_ptr
[0] == 'I') && (bcc_ptr
[1] == 'P') &&
3396 (bcc_ptr
[2] == 'C')) {
3397 cFYI(1, "IPC connection");
3400 } else if (length
== 2) {
3401 if ((bcc_ptr
[0] == 'A') && (bcc_ptr
[1] == ':')) {
3402 /* the most common case */
3403 cFYI(1, "disk share connection");
3406 bcc_ptr
+= length
+ 1;
3407 bytes_left
-= (length
+ 1);
3408 strncpy(tcon
->treeName
, tree
, MAX_TREE_SIZE
);
3410 /* mostly informational -- no need to fail on error here */
3411 kfree(tcon
->nativeFileSystem
);
3412 tcon
->nativeFileSystem
= cifs_strndup_from_ucs(bcc_ptr
,
3413 bytes_left
, is_unicode
,
3416 cFYI(1, "nativeFileSystem=%s", tcon
->nativeFileSystem
);
3418 if ((smb_buffer_response
->WordCount
== 3) ||
3419 (smb_buffer_response
->WordCount
== 7))
3420 /* field is in same location */
3421 tcon
->Flags
= le16_to_cpu(pSMBr
->OptionalSupport
);
3424 cFYI(1, "Tcon flags: 0x%x ", tcon
->Flags
);
3425 } else if ((rc
== 0) && tcon
== NULL
) {
3426 /* all we need to save for IPC$ connection */
3427 ses
->ipc_tid
= smb_buffer_response
->Tid
;
3430 cifs_buf_release(smb_buffer
);
3435 cifs_umount(struct cifs_sb_info
*cifs_sb
)
3437 struct rb_root
*root
= &cifs_sb
->tlink_tree
;
3438 struct rb_node
*node
;
3439 struct tcon_link
*tlink
;
3441 cancel_delayed_work_sync(&cifs_sb
->prune_tlinks
);
3443 spin_lock(&cifs_sb
->tlink_tree_lock
);
3444 while ((node
= rb_first(root
))) {
3445 tlink
= rb_entry(node
, struct tcon_link
, tl_rbnode
);
3446 cifs_get_tlink(tlink
);
3447 clear_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
3448 rb_erase(node
, root
);
3450 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3451 cifs_put_tlink(tlink
);
3452 spin_lock(&cifs_sb
->tlink_tree_lock
);
3454 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3456 bdi_destroy(&cifs_sb
->bdi
);
3457 kfree(cifs_sb
->mountdata
);
3458 unload_nls(cifs_sb
->local_nls
);
3462 int cifs_negotiate_protocol(unsigned int xid
, struct cifs_ses
*ses
)
3465 struct TCP_Server_Info
*server
= ses
->server
;
3467 /* only send once per connect */
3468 if (server
->maxBuf
!= 0)
3471 rc
= CIFSSMBNegotiate(xid
, ses
);
3472 if (rc
== -EAGAIN
) {
3473 /* retry only once on 1st time connection */
3474 rc
= CIFSSMBNegotiate(xid
, ses
);
3479 spin_lock(&GlobalMid_Lock
);
3480 if (server
->tcpStatus
== CifsNeedNegotiate
)
3481 server
->tcpStatus
= CifsGood
;
3484 spin_unlock(&GlobalMid_Lock
);
3492 int cifs_setup_session(unsigned int xid
, struct cifs_ses
*ses
,
3493 struct nls_table
*nls_info
)
3496 struct TCP_Server_Info
*server
= ses
->server
;
3499 ses
->capabilities
= server
->capabilities
;
3500 if (linuxExtEnabled
== 0)
3501 ses
->capabilities
&= (~CAP_UNIX
);
3503 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3504 server
->sec_mode
, server
->capabilities
, server
->timeAdj
);
3506 rc
= CIFS_SessSetup(xid
, ses
, nls_info
);
3508 cERROR(1, "Send error in SessSetup = %d", rc
);
3510 mutex_lock(&ses
->server
->srv_mutex
);
3511 if (!server
->session_estab
) {
3512 server
->session_key
.response
= ses
->auth_key
.response
;
3513 server
->session_key
.len
= ses
->auth_key
.len
;
3514 server
->sequence_number
= 0x2;
3515 server
->session_estab
= true;
3516 ses
->auth_key
.response
= NULL
;
3518 mutex_unlock(&server
->srv_mutex
);
3520 cFYI(1, "CIFS Session Established successfully");
3521 spin_lock(&GlobalMid_Lock
);
3522 ses
->status
= CifsGood
;
3523 ses
->need_reconnect
= false;
3524 spin_unlock(&GlobalMid_Lock
);
3527 kfree(ses
->auth_key
.response
);
3528 ses
->auth_key
.response
= NULL
;
3529 ses
->auth_key
.len
= 0;
3530 kfree(ses
->ntlmssp
);
3531 ses
->ntlmssp
= NULL
;
3536 static struct cifs_tcon
*
3537 cifs_construct_tcon(struct cifs_sb_info
*cifs_sb
, uid_t fsuid
)
3539 struct cifs_tcon
*master_tcon
= cifs_sb_master_tcon(cifs_sb
);
3540 struct cifs_ses
*ses
;
3541 struct cifs_tcon
*tcon
= NULL
;
3542 struct smb_vol
*vol_info
;
3543 char username
[28]; /* big enough for "krb50x" + hex of ULONG_MAX 6+16 */
3544 /* We used to have this as MAX_USERNAME which is */
3545 /* way too big now (256 instead of 32) */
3547 vol_info
= kzalloc(sizeof(*vol_info
), GFP_KERNEL
);
3548 if (vol_info
== NULL
) {
3549 tcon
= ERR_PTR(-ENOMEM
);
3553 snprintf(username
, sizeof(username
), "krb50x%x", fsuid
);
3554 vol_info
->username
= username
;
3555 vol_info
->local_nls
= cifs_sb
->local_nls
;
3556 vol_info
->linux_uid
= fsuid
;
3557 vol_info
->cred_uid
= fsuid
;
3558 vol_info
->UNC
= master_tcon
->treeName
;
3559 vol_info
->retry
= master_tcon
->retry
;
3560 vol_info
->nocase
= master_tcon
->nocase
;
3561 vol_info
->local_lease
= master_tcon
->local_lease
;
3562 vol_info
->no_linux_ext
= !master_tcon
->unix_ext
;
3564 /* FIXME: allow for other secFlg settings */
3565 vol_info
->secFlg
= CIFSSEC_MUST_KRB5
;
3567 /* get a reference for the same TCP session */
3568 spin_lock(&cifs_tcp_ses_lock
);
3569 ++master_tcon
->ses
->server
->srv_count
;
3570 spin_unlock(&cifs_tcp_ses_lock
);
3572 ses
= cifs_get_smb_ses(master_tcon
->ses
->server
, vol_info
);
3574 tcon
= (struct cifs_tcon
*)ses
;
3575 cifs_put_tcp_session(master_tcon
->ses
->server
);
3579 tcon
= cifs_get_tcon(ses
, vol_info
);
3581 cifs_put_smb_ses(ses
);
3585 if (ses
->capabilities
& CAP_UNIX
)
3586 reset_cifs_unix_caps(0, tcon
, NULL
, vol_info
);
3594 cifs_sb_master_tcon(struct cifs_sb_info
*cifs_sb
)
3596 return tlink_tcon(cifs_sb_master_tlink(cifs_sb
));
3600 cifs_sb_tcon_pending_wait(void *unused
)
3603 return signal_pending(current
) ? -ERESTARTSYS
: 0;
3606 /* find and return a tlink with given uid */
3607 static struct tcon_link
*
3608 tlink_rb_search(struct rb_root
*root
, uid_t uid
)
3610 struct rb_node
*node
= root
->rb_node
;
3611 struct tcon_link
*tlink
;
3614 tlink
= rb_entry(node
, struct tcon_link
, tl_rbnode
);
3616 if (tlink
->tl_uid
> uid
)
3617 node
= node
->rb_left
;
3618 else if (tlink
->tl_uid
< uid
)
3619 node
= node
->rb_right
;
3626 /* insert a tcon_link into the tree */
3628 tlink_rb_insert(struct rb_root
*root
, struct tcon_link
*new_tlink
)
3630 struct rb_node
**new = &(root
->rb_node
), *parent
= NULL
;
3631 struct tcon_link
*tlink
;
3634 tlink
= rb_entry(*new, struct tcon_link
, tl_rbnode
);
3637 if (tlink
->tl_uid
> new_tlink
->tl_uid
)
3638 new = &((*new)->rb_left
);
3640 new = &((*new)->rb_right
);
3643 rb_link_node(&new_tlink
->tl_rbnode
, parent
, new);
3644 rb_insert_color(&new_tlink
->tl_rbnode
, root
);
3648 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3651 * If the superblock doesn't refer to a multiuser mount, then just return
3652 * the master tcon for the mount.
3654 * First, search the rbtree for an existing tcon for this fsuid. If one
3655 * exists, then check to see if it's pending construction. If it is then wait
3656 * for construction to complete. Once it's no longer pending, check to see if
3657 * it failed and either return an error or retry construction, depending on
3660 * If one doesn't exist then insert a new tcon_link struct into the tree and
3661 * try to construct a new one.
3664 cifs_sb_tlink(struct cifs_sb_info
*cifs_sb
)
3667 uid_t fsuid
= current_fsuid();
3668 struct tcon_link
*tlink
, *newtlink
;
3670 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
))
3671 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb
));
3673 spin_lock(&cifs_sb
->tlink_tree_lock
);
3674 tlink
= tlink_rb_search(&cifs_sb
->tlink_tree
, fsuid
);
3676 cifs_get_tlink(tlink
);
3677 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3679 if (tlink
== NULL
) {
3680 newtlink
= kzalloc(sizeof(*tlink
), GFP_KERNEL
);
3681 if (newtlink
== NULL
)
3682 return ERR_PTR(-ENOMEM
);
3683 newtlink
->tl_uid
= fsuid
;
3684 newtlink
->tl_tcon
= ERR_PTR(-EACCES
);
3685 set_bit(TCON_LINK_PENDING
, &newtlink
->tl_flags
);
3686 set_bit(TCON_LINK_IN_TREE
, &newtlink
->tl_flags
);
3687 cifs_get_tlink(newtlink
);
3689 spin_lock(&cifs_sb
->tlink_tree_lock
);
3690 /* was one inserted after previous search? */
3691 tlink
= tlink_rb_search(&cifs_sb
->tlink_tree
, fsuid
);
3693 cifs_get_tlink(tlink
);
3694 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3696 goto wait_for_construction
;
3699 tlink_rb_insert(&cifs_sb
->tlink_tree
, tlink
);
3700 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3702 wait_for_construction
:
3703 ret
= wait_on_bit(&tlink
->tl_flags
, TCON_LINK_PENDING
,
3704 cifs_sb_tcon_pending_wait
,
3705 TASK_INTERRUPTIBLE
);
3707 cifs_put_tlink(tlink
);
3708 return ERR_PTR(ret
);
3711 /* if it's good, return it */
3712 if (!IS_ERR(tlink
->tl_tcon
))
3715 /* return error if we tried this already recently */
3716 if (time_before(jiffies
, tlink
->tl_time
+ TLINK_ERROR_EXPIRE
)) {
3717 cifs_put_tlink(tlink
);
3718 return ERR_PTR(-EACCES
);
3721 if (test_and_set_bit(TCON_LINK_PENDING
, &tlink
->tl_flags
))
3722 goto wait_for_construction
;
3725 tlink
->tl_tcon
= cifs_construct_tcon(cifs_sb
, fsuid
);
3726 clear_bit(TCON_LINK_PENDING
, &tlink
->tl_flags
);
3727 wake_up_bit(&tlink
->tl_flags
, TCON_LINK_PENDING
);
3729 if (IS_ERR(tlink
->tl_tcon
)) {
3730 cifs_put_tlink(tlink
);
3731 return ERR_PTR(-EACCES
);
3738 * periodic workqueue job that scans tcon_tree for a superblock and closes
3742 cifs_prune_tlinks(struct work_struct
*work
)
3744 struct cifs_sb_info
*cifs_sb
= container_of(work
, struct cifs_sb_info
,
3746 struct rb_root
*root
= &cifs_sb
->tlink_tree
;
3747 struct rb_node
*node
= rb_first(root
);
3748 struct rb_node
*tmp
;
3749 struct tcon_link
*tlink
;
3752 * Because we drop the spinlock in the loop in order to put the tlink
3753 * it's not guarded against removal of links from the tree. The only
3754 * places that remove entries from the tree are this function and
3755 * umounts. Because this function is non-reentrant and is canceled
3756 * before umount can proceed, this is safe.
3758 spin_lock(&cifs_sb
->tlink_tree_lock
);
3759 node
= rb_first(root
);
3760 while (node
!= NULL
) {
3762 node
= rb_next(tmp
);
3763 tlink
= rb_entry(tmp
, struct tcon_link
, tl_rbnode
);
3765 if (test_bit(TCON_LINK_MASTER
, &tlink
->tl_flags
) ||
3766 atomic_read(&tlink
->tl_count
) != 0 ||
3767 time_after(tlink
->tl_time
+ TLINK_IDLE_EXPIRE
, jiffies
))
3770 cifs_get_tlink(tlink
);
3771 clear_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
3772 rb_erase(tmp
, root
);
3774 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3775 cifs_put_tlink(tlink
);
3776 spin_lock(&cifs_sb
->tlink_tree_lock
);
3778 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3780 queue_delayed_work(system_nrt_wq
, &cifs_sb
->prune_tlinks
,