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 * kvec_array_init - clone a kvec array, and advance into it
380 * @new: pointer to memory for cloned array
381 * @iov: pointer to original array
382 * @nr_segs: number of members in original array
383 * @bytes: number of bytes to advance into the cloned array
385 * This function will copy the array provided in iov to a section of memory
386 * and advance the specified number of bytes into the new array. It returns
387 * the number of segments in the new array. "new" must be at least as big as
388 * the original iov array.
391 kvec_array_init(struct kvec
*new, struct kvec
*iov
, unsigned int nr_segs
,
396 while (bytes
|| !iov
->iov_len
) {
397 int copy
= min(bytes
, iov
->iov_len
);
401 if (iov
->iov_len
== base
) {
407 memcpy(new, iov
, sizeof(*iov
) * nr_segs
);
408 new->iov_base
+= base
;
409 new->iov_len
-= base
;
414 get_server_iovec(struct TCP_Server_Info
*server
, unsigned int nr_segs
)
416 struct kvec
*new_iov
;
418 if (server
->iov
&& nr_segs
<= server
->nr_iov
)
421 /* not big enough -- allocate a new one and release the old */
422 new_iov
= kmalloc(sizeof(*new_iov
) * nr_segs
, GFP_NOFS
);
425 server
->iov
= new_iov
;
426 server
->nr_iov
= nr_segs
;
432 readv_from_socket(struct TCP_Server_Info
*server
, struct kvec
*iov_orig
,
433 unsigned int nr_segs
, unsigned int to_read
)
438 struct msghdr smb_msg
;
441 iov
= get_server_iovec(server
, nr_segs
);
445 smb_msg
.msg_control
= NULL
;
446 smb_msg
.msg_controllen
= 0;
448 for (total_read
= 0; to_read
; total_read
+= length
, to_read
-= length
) {
449 if (server_unresponsive(server
)) {
450 total_read
= -EAGAIN
;
454 segs
= kvec_array_init(iov
, iov_orig
, nr_segs
, total_read
);
456 length
= kernel_recvmsg(server
->ssocket
, &smb_msg
,
457 iov
, segs
, to_read
, 0);
459 if (server
->tcpStatus
== CifsExiting
) {
460 total_read
= -ESHUTDOWN
;
462 } else if (server
->tcpStatus
== CifsNeedReconnect
) {
463 cifs_reconnect(server
);
464 total_read
= -EAGAIN
;
466 } else if (length
== -ERESTARTSYS
||
470 * Minimum sleep to prevent looping, allowing socket
471 * to clear and app threads to set tcpStatus
472 * CifsNeedReconnect if server hung.
474 usleep_range(1000, 2000);
477 } else if (length
<= 0) {
478 cFYI(1, "Received no data or error: expecting %d "
479 "got %d", to_read
, length
);
480 cifs_reconnect(server
);
481 total_read
= -EAGAIN
;
489 read_from_socket(struct TCP_Server_Info
*server
, char *buf
,
490 unsigned int to_read
)
495 iov
.iov_len
= to_read
;
497 return readv_from_socket(server
, &iov
, 1, to_read
);
501 is_smb_response(struct TCP_Server_Info
*server
, unsigned char type
)
504 * The first byte big endian of the length field,
505 * is actually not part of the length but the type
506 * with the most common, zero, as regular data.
509 case RFC1002_SESSION_MESSAGE
:
510 /* Regular SMB response */
512 case RFC1002_SESSION_KEEP_ALIVE
:
513 cFYI(1, "RFC 1002 session keep alive");
515 case RFC1002_POSITIVE_SESSION_RESPONSE
:
516 cFYI(1, "RFC 1002 positive session response");
518 case RFC1002_NEGATIVE_SESSION_RESPONSE
:
520 * We get this from Windows 98 instead of an error on
521 * SMB negprot response.
523 cFYI(1, "RFC 1002 negative session response");
524 /* give server a second to clean up */
527 * Always try 445 first on reconnect since we get NACK
528 * on some if we ever connected to port 139 (the NACK
529 * is since we do not begin with RFC1001 session
532 cifs_set_port((struct sockaddr
*)&server
->dstaddr
, CIFS_PORT
);
533 cifs_reconnect(server
);
534 wake_up(&server
->response_q
);
537 cERROR(1, "RFC 1002 unknown response type 0x%x", type
);
538 cifs_reconnect(server
);
544 static struct mid_q_entry
*
545 find_mid(struct TCP_Server_Info
*server
, struct smb_hdr
*buf
)
547 struct mid_q_entry
*mid
;
549 spin_lock(&GlobalMid_Lock
);
550 list_for_each_entry(mid
, &server
->pending_mid_q
, qhead
) {
551 if (mid
->mid
== buf
->Mid
&&
552 mid
->midState
== MID_REQUEST_SUBMITTED
&&
553 mid
->command
== buf
->Command
) {
554 spin_unlock(&GlobalMid_Lock
);
558 spin_unlock(&GlobalMid_Lock
);
563 dequeue_mid(struct mid_q_entry
*mid
, int malformed
)
565 #ifdef CONFIG_CIFS_STATS2
566 mid
->when_received
= jiffies
;
568 spin_lock(&GlobalMid_Lock
);
570 mid
->midState
= MID_RESPONSE_RECEIVED
;
572 mid
->midState
= MID_RESPONSE_MALFORMED
;
573 list_del_init(&mid
->qhead
);
574 spin_unlock(&GlobalMid_Lock
);
577 static struct mid_q_entry
*
578 find_cifs_mid(struct TCP_Server_Info
*server
, struct smb_hdr
*buf
,
579 int malformed
, bool is_large_buf
, char **bigbuf
)
581 struct mid_q_entry
*mid
= NULL
;
583 mid
= find_mid(server
, buf
);
587 if (malformed
== 0 && check2ndT2(buf
) > 0) {
588 mid
->multiRsp
= true;
590 /* merge response - fix up 1st*/
591 malformed
= coalesce_t2(buf
, mid
->resp_buf
);
595 /* All parts received or packet is malformed. */
596 mid
->multiEnd
= true;
600 /*FIXME: switch to already allocated largebuf?*/
601 cERROR(1, "1st trans2 resp needs bigbuf");
603 /* Have first buffer */
605 mid
->largeBuf
= true;
611 mid
->largeBuf
= is_large_buf
;
613 dequeue_mid(mid
, malformed
);
617 static void clean_demultiplex_info(struct TCP_Server_Info
*server
)
621 /* take it off the list, if it's not already */
622 spin_lock(&cifs_tcp_ses_lock
);
623 list_del_init(&server
->tcp_ses_list
);
624 spin_unlock(&cifs_tcp_ses_lock
);
626 spin_lock(&GlobalMid_Lock
);
627 server
->tcpStatus
= CifsExiting
;
628 spin_unlock(&GlobalMid_Lock
);
629 wake_up_all(&server
->response_q
);
632 * Check if we have blocked requests that need to free. Note that
633 * cifs_max_pending is normally 50, but can be set at module install
634 * time to as little as two.
636 spin_lock(&GlobalMid_Lock
);
637 if (atomic_read(&server
->inFlight
) >= cifs_max_pending
)
638 atomic_set(&server
->inFlight
, cifs_max_pending
- 1);
640 * We do not want to set the max_pending too low or we could end up
641 * with the counter going negative.
643 spin_unlock(&GlobalMid_Lock
);
645 * Although there should not be any requests blocked on this queue it
646 * can not hurt to be paranoid and try to wake up requests that may
647 * haven been blocked when more than 50 at time were on the wire to the
648 * same server - they now will see the session is in exit state and get
649 * out of SendReceive.
651 wake_up_all(&server
->request_q
);
652 /* give those requests time to exit */
655 if (server
->ssocket
) {
656 sock_release(server
->ssocket
);
657 server
->ssocket
= NULL
;
660 if (!list_empty(&server
->pending_mid_q
)) {
661 struct list_head dispose_list
;
662 struct mid_q_entry
*mid_entry
;
663 struct list_head
*tmp
, *tmp2
;
665 INIT_LIST_HEAD(&dispose_list
);
666 spin_lock(&GlobalMid_Lock
);
667 list_for_each_safe(tmp
, tmp2
, &server
->pending_mid_q
) {
668 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
669 cFYI(1, "Clearing mid 0x%x", mid_entry
->mid
);
670 mid_entry
->midState
= MID_SHUTDOWN
;
671 list_move(&mid_entry
->qhead
, &dispose_list
);
673 spin_unlock(&GlobalMid_Lock
);
675 /* now walk dispose list and issue callbacks */
676 list_for_each_safe(tmp
, tmp2
, &dispose_list
) {
677 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
678 cFYI(1, "Callback mid 0x%x", mid_entry
->mid
);
679 list_del_init(&mid_entry
->qhead
);
680 mid_entry
->callback(mid_entry
);
682 /* 1/8th of sec is more than enough time for them to exit */
686 if (!list_empty(&server
->pending_mid_q
)) {
688 * mpx threads have not exited yet give them at least the smb
689 * send timeout time for long ops.
691 * Due to delays on oplock break requests, we need to wait at
692 * least 45 seconds before giving up on a request getting a
693 * response and going ahead and killing cifsd.
695 cFYI(1, "Wait for exit from demultiplex thread");
698 * If threads still have not exited they are probably never
699 * coming home not much else we can do but free the memory.
703 kfree(server
->hostname
);
707 length
= atomic_dec_return(&tcpSesAllocCount
);
709 mempool_resize(cifs_req_poolp
, length
+ cifs_min_rcv
,
714 cifs_demultiplex_thread(void *p
)
717 struct TCP_Server_Info
*server
= p
;
718 unsigned int pdu_length
, total_read
;
719 char *buf
= NULL
, *bigbuf
= NULL
, *smallbuf
= NULL
;
720 struct smb_hdr
*smb_buffer
= NULL
;
721 struct task_struct
*task_to_wake
= NULL
;
722 struct mid_q_entry
*mid_entry
;
723 bool isLargeBuf
= false;
725 current
->flags
|= PF_MEMALLOC
;
726 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current
));
728 length
= atomic_inc_return(&tcpSesAllocCount
);
730 mempool_resize(cifs_req_poolp
, length
+ cifs_min_rcv
,
734 while (server
->tcpStatus
!= CifsExiting
) {
738 if (!allocate_buffers(&bigbuf
, &smallbuf
,
739 sizeof(struct smb_hdr
), isLargeBuf
))
743 smb_buffer
= (struct smb_hdr
*)smallbuf
;
745 pdu_length
= 4; /* enough to get RFC1001 header */
747 length
= read_from_socket(server
, buf
, pdu_length
);
753 * The right amount was read from socket - 4 bytes,
754 * so we can now interpret the length field.
756 pdu_length
= be32_to_cpu(smb_buffer
->smb_buf_length
);
758 cFYI(1, "RFC1002 header 0x%x", pdu_length
);
759 if (!is_smb_response(server
, buf
[0]))
762 /* make sure we have enough to get to the MID */
763 if (pdu_length
< sizeof(struct smb_hdr
) - 1 - 4) {
764 cERROR(1, "SMB response too short (%u bytes)",
766 cifs_reconnect(server
);
767 wake_up(&server
->response_q
);
771 /* read down to the MID */
772 length
= read_from_socket(server
, buf
+ 4,
773 sizeof(struct smb_hdr
) - 1 - 4);
776 total_read
+= length
;
778 if (pdu_length
> CIFSMaxBufSize
+ MAX_CIFS_HDR_SIZE
- 4) {
779 cERROR(1, "SMB response too long (%u bytes)",
781 cifs_reconnect(server
);
782 wake_up(&server
->response_q
);
787 if (pdu_length
> MAX_CIFS_SMALL_BUFFER_SIZE
- 4) {
789 memcpy(bigbuf
, smallbuf
, total_read
);
790 smb_buffer
= (struct smb_hdr
*)bigbuf
;
794 /* now read the rest */
795 length
= read_from_socket(server
,
796 buf
+ sizeof(struct smb_hdr
) - 1,
797 pdu_length
- sizeof(struct smb_hdr
) + 1 + 4);
800 total_read
+= length
;
802 dump_smb(smb_buffer
, total_read
);
805 * We know that we received enough to get to the MID as we
806 * checked the pdu_length earlier. Now check to see
807 * if the rest of the header is OK. We borrow the length
808 * var for the rest of the loop to avoid a new stack var.
810 * 48 bytes is enough to display the header and a little bit
811 * into the payload for debugging purposes.
813 length
= checkSMB(smb_buffer
, smb_buffer
->Mid
, total_read
);
815 cifs_dump_mem("Bad SMB: ", buf
,
816 min_t(unsigned int, total_read
, 48));
818 server
->lstrp
= jiffies
;
820 mid_entry
= find_cifs_mid(server
, smb_buffer
, length
,
821 isLargeBuf
, &bigbuf
);
822 if (mid_entry
!= NULL
) {
823 if (mid_entry
->multiRsp
&& !mid_entry
->multiEnd
)
826 /* Was previous buf put in mpx struct for multi-rsp? */
827 if (!mid_entry
->multiRsp
) {
828 /* smb buffer will be freed by user thread */
834 mid_entry
->callback(mid_entry
);
835 } else if (length
!= 0) {
836 /* response sanity checks failed */
838 } else if (!is_valid_oplock_break(smb_buffer
, server
)) {
839 cERROR(1, "No task to wake, unknown frame received! "
840 "NumMids %d", atomic_read(&midCount
));
841 cifs_dump_mem("Received Data is: ", buf
,
842 sizeof(struct smb_hdr
));
843 #ifdef CONFIG_CIFS_DEBUG2
844 cifs_dump_detail(smb_buffer
);
845 cifs_dump_mids(server
);
846 #endif /* CIFS_DEBUG2 */
849 } /* end while !EXITING */
851 /* buffer usually freed in free_mid - need to free it here on exit */
852 cifs_buf_release(bigbuf
);
853 if (smallbuf
) /* no sense logging a debug message if NULL */
854 cifs_small_buf_release(smallbuf
);
856 task_to_wake
= xchg(&server
->tsk
, NULL
);
857 clean_demultiplex_info(server
);
859 /* if server->tsk was NULL then wait for a signal before exiting */
861 set_current_state(TASK_INTERRUPTIBLE
);
862 while (!signal_pending(current
)) {
864 set_current_state(TASK_INTERRUPTIBLE
);
866 set_current_state(TASK_RUNNING
);
869 module_put_and_exit(0);
872 /* extract the host portion of the UNC string */
874 extract_hostname(const char *unc
)
880 /* skip double chars at beginning of string */
881 /* BB: check validity of these bytes? */
884 /* delimiter between hostname and sharename is always '\\' now */
885 delim
= strchr(src
, '\\');
887 return ERR_PTR(-EINVAL
);
890 dst
= kmalloc((len
+ 1), GFP_KERNEL
);
892 return ERR_PTR(-ENOMEM
);
894 memcpy(dst
, src
, len
);
901 cifs_parse_mount_options(const char *mountdata
, const char *devname
,
904 char *value
, *data
, *end
;
905 char *mountdata_copy
= NULL
, *options
;
907 unsigned int temp_len
, i
, j
;
909 short int override_uid
= -1;
910 short int override_gid
= -1;
911 bool uid_specified
= false;
912 bool gid_specified
= false;
913 char *nodename
= utsname()->nodename
;
919 * does not have to be perfect mapping since field is
920 * informational, only used for servers that do not support
921 * port 445 and it can be overridden at mount time
923 memset(vol
->source_rfc1001_name
, 0x20, RFC1001_NAME_LEN
);
924 for (i
= 0; i
< strnlen(nodename
, RFC1001_NAME_LEN
); i
++)
925 vol
->source_rfc1001_name
[i
] = toupper(nodename
[i
]);
927 vol
->source_rfc1001_name
[RFC1001_NAME_LEN
] = 0;
928 /* null target name indicates to use *SMBSERVR default called name
929 if we end up sending RFC1001 session initialize */
930 vol
->target_rfc1001_name
[0] = 0;
931 vol
->cred_uid
= current_uid();
932 vol
->linux_uid
= current_uid();
933 vol
->linux_gid
= current_gid();
935 /* default to only allowing write access to owner of the mount */
936 vol
->dir_mode
= vol
->file_mode
= S_IRUGO
| S_IXUGO
| S_IWUSR
;
938 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
939 /* default is always to request posix paths. */
940 vol
->posix_paths
= 1;
941 /* default to using server inode numbers where available */
944 vol
->actimeo
= CIFS_DEF_ACTIMEO
;
947 goto cifs_parse_mount_err
;
949 mountdata_copy
= kstrndup(mountdata
, PAGE_SIZE
, GFP_KERNEL
);
951 goto cifs_parse_mount_err
;
953 options
= mountdata_copy
;
954 end
= options
+ strlen(options
);
955 if (strncmp(options
, "sep=", 4) == 0) {
956 if (options
[4] != 0) {
957 separator
[0] = options
[4];
960 cFYI(1, "Null separator not allowed");
963 vol
->backupuid_specified
= false; /* no backup intent for a user */
964 vol
->backupgid_specified
= false; /* no backup intent for a group */
966 while ((data
= strsep(&options
, separator
)) != NULL
) {
969 if ((value
= strchr(data
, '=')) != NULL
)
972 /* Have to parse this before we parse for "user" */
973 if (strnicmp(data
, "user_xattr", 10) == 0) {
975 } else if (strnicmp(data
, "nouser_xattr", 12) == 0) {
977 } else if (strnicmp(data
, "user", 4) == 0) {
980 "CIFS: invalid or missing username\n");
981 goto cifs_parse_mount_err
;
982 } else if (!*value
) {
983 /* null user, ie anonymous, authentication */
986 if (strnlen(value
, MAX_USERNAME_SIZE
) <
988 vol
->username
= kstrdup(value
, GFP_KERNEL
);
989 if (!vol
->username
) {
990 printk(KERN_WARNING
"CIFS: no memory "
992 goto cifs_parse_mount_err
;
995 printk(KERN_WARNING
"CIFS: username too long\n");
996 goto cifs_parse_mount_err
;
998 } else if (strnicmp(data
, "pass", 4) == 0) {
1000 vol
->password
= NULL
;
1002 } else if (value
[0] == 0) {
1003 /* check if string begins with double comma
1004 since that would mean the password really
1005 does start with a comma, and would not
1006 indicate an empty string */
1007 if (value
[1] != separator
[0]) {
1008 vol
->password
= NULL
;
1012 temp_len
= strlen(value
);
1013 /* removed password length check, NTLM passwords
1014 can be arbitrarily long */
1016 /* if comma in password, the string will be
1017 prematurely null terminated. Commas in password are
1018 specified across the cifs mount interface by a double
1019 comma ie ,, and a comma used as in other cases ie ','
1020 as a parameter delimiter/separator is single and due
1021 to the strsep above is temporarily zeroed. */
1023 /* NB: password legally can have multiple commas and
1024 the only illegal character in a password is null */
1026 if ((value
[temp_len
] == 0) &&
1027 (value
+ temp_len
< end
) &&
1028 (value
[temp_len
+1] == separator
[0])) {
1029 /* reinsert comma */
1030 value
[temp_len
] = separator
[0];
1031 temp_len
+= 2; /* move after second comma */
1032 while (value
[temp_len
] != 0) {
1033 if (value
[temp_len
] == separator
[0]) {
1034 if (value
[temp_len
+1] ==
1036 /* skip second comma */
1039 /* single comma indicating start
1046 if (value
[temp_len
] == 0) {
1049 value
[temp_len
] = 0;
1050 /* point option to start of next parm */
1051 options
= value
+ temp_len
+ 1;
1053 /* go from value to value + temp_len condensing
1054 double commas to singles. Note that this ends up
1055 allocating a few bytes too many, which is ok */
1056 vol
->password
= kzalloc(temp_len
, GFP_KERNEL
);
1057 if (vol
->password
== NULL
) {
1058 printk(KERN_WARNING
"CIFS: no memory "
1060 goto cifs_parse_mount_err
;
1062 for (i
= 0, j
= 0; i
< temp_len
; i
++, j
++) {
1063 vol
->password
[j
] = value
[i
];
1064 if (value
[i
] == separator
[0]
1065 && value
[i
+1] == separator
[0]) {
1066 /* skip second comma */
1070 vol
->password
[j
] = 0;
1072 vol
->password
= kzalloc(temp_len
+1, GFP_KERNEL
);
1073 if (vol
->password
== NULL
) {
1074 printk(KERN_WARNING
"CIFS: no memory "
1076 goto cifs_parse_mount_err
;
1078 strcpy(vol
->password
, value
);
1080 } else if (!strnicmp(data
, "ip", 2) ||
1081 !strnicmp(data
, "addr", 4)) {
1082 if (!value
|| !*value
) {
1084 } else if (strnlen(value
, INET6_ADDRSTRLEN
) <
1086 vol
->UNCip
= kstrdup(value
, GFP_KERNEL
);
1088 printk(KERN_WARNING
"CIFS: no memory "
1090 goto cifs_parse_mount_err
;
1093 printk(KERN_WARNING
"CIFS: ip address "
1095 goto cifs_parse_mount_err
;
1097 } else if (strnicmp(data
, "sec", 3) == 0) {
1098 if (!value
|| !*value
) {
1099 cERROR(1, "no security value specified");
1101 } else if (strnicmp(value
, "krb5i", 5) == 0) {
1102 vol
->secFlg
|= CIFSSEC_MAY_KRB5
|
1104 } else if (strnicmp(value
, "krb5p", 5) == 0) {
1105 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
1106 CIFSSEC_MAY_KRB5; */
1107 cERROR(1, "Krb5 cifs privacy not supported");
1108 goto cifs_parse_mount_err
;
1109 } else if (strnicmp(value
, "krb5", 4) == 0) {
1110 vol
->secFlg
|= CIFSSEC_MAY_KRB5
;
1111 } else if (strnicmp(value
, "ntlmsspi", 8) == 0) {
1112 vol
->secFlg
|= CIFSSEC_MAY_NTLMSSP
|
1114 } else if (strnicmp(value
, "ntlmssp", 7) == 0) {
1115 vol
->secFlg
|= CIFSSEC_MAY_NTLMSSP
;
1116 } else if (strnicmp(value
, "ntlmv2i", 7) == 0) {
1117 vol
->secFlg
|= CIFSSEC_MAY_NTLMV2
|
1119 } else if (strnicmp(value
, "ntlmv2", 6) == 0) {
1120 vol
->secFlg
|= CIFSSEC_MAY_NTLMV2
;
1121 } else if (strnicmp(value
, "ntlmi", 5) == 0) {
1122 vol
->secFlg
|= CIFSSEC_MAY_NTLM
|
1124 } else if (strnicmp(value
, "ntlm", 4) == 0) {
1125 /* ntlm is default so can be turned off too */
1126 vol
->secFlg
|= CIFSSEC_MAY_NTLM
;
1127 } else if (strnicmp(value
, "nontlm", 6) == 0) {
1128 /* BB is there a better way to do this? */
1129 vol
->secFlg
|= CIFSSEC_MAY_NTLMV2
;
1130 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1131 } else if (strnicmp(value
, "lanman", 6) == 0) {
1132 vol
->secFlg
|= CIFSSEC_MAY_LANMAN
;
1134 } else if (strnicmp(value
, "none", 4) == 0) {
1137 cERROR(1, "bad security option: %s", value
);
1138 goto cifs_parse_mount_err
;
1140 } else if (strnicmp(data
, "vers", 3) == 0) {
1141 if (!value
|| !*value
) {
1142 cERROR(1, "no protocol version specified"
1143 " after vers= mount option");
1144 } else if ((strnicmp(value
, "cifs", 4) == 0) ||
1145 (strnicmp(value
, "1", 1) == 0)) {
1146 /* this is the default */
1149 } else if ((strnicmp(data
, "unc", 3) == 0)
1150 || (strnicmp(data
, "target", 6) == 0)
1151 || (strnicmp(data
, "path", 4) == 0)) {
1152 if (!value
|| !*value
) {
1153 printk(KERN_WARNING
"CIFS: invalid path to "
1154 "network resource\n");
1155 goto cifs_parse_mount_err
;
1157 if ((temp_len
= strnlen(value
, 300)) < 300) {
1158 vol
->UNC
= kmalloc(temp_len
+1, GFP_KERNEL
);
1159 if (vol
->UNC
== NULL
)
1160 goto cifs_parse_mount_err
;
1161 strcpy(vol
->UNC
, value
);
1162 if (strncmp(vol
->UNC
, "//", 2) == 0) {
1165 } else if (strncmp(vol
->UNC
, "\\\\", 2) != 0) {
1167 "CIFS: UNC Path does not begin "
1168 "with // or \\\\ \n");
1169 goto cifs_parse_mount_err
;
1172 printk(KERN_WARNING
"CIFS: UNC name too long\n");
1173 goto cifs_parse_mount_err
;
1175 } else if ((strnicmp(data
, "domain", 3) == 0)
1176 || (strnicmp(data
, "workgroup", 5) == 0)) {
1177 if (!value
|| !*value
) {
1178 printk(KERN_WARNING
"CIFS: invalid domain name\n");
1179 goto cifs_parse_mount_err
;
1181 /* BB are there cases in which a comma can be valid in
1182 a domain name and need special handling? */
1183 if (strnlen(value
, 256) < 256) {
1184 vol
->domainname
= kstrdup(value
, GFP_KERNEL
);
1185 if (!vol
->domainname
) {
1186 printk(KERN_WARNING
"CIFS: no memory "
1187 "for domainname\n");
1188 goto cifs_parse_mount_err
;
1190 cFYI(1, "Domain name set");
1192 printk(KERN_WARNING
"CIFS: domain name too "
1194 goto cifs_parse_mount_err
;
1196 } else if (strnicmp(data
, "srcaddr", 7) == 0) {
1197 vol
->srcaddr
.ss_family
= AF_UNSPEC
;
1199 if (!value
|| !*value
) {
1200 printk(KERN_WARNING
"CIFS: srcaddr value"
1201 " not specified.\n");
1202 goto cifs_parse_mount_err
;
1204 i
= cifs_convert_address((struct sockaddr
*)&vol
->srcaddr
,
1205 value
, strlen(value
));
1207 printk(KERN_WARNING
"CIFS: Could not parse"
1210 goto cifs_parse_mount_err
;
1212 } else if (strnicmp(data
, "prefixpath", 10) == 0) {
1213 if (!value
|| !*value
) {
1215 "CIFS: invalid path prefix\n");
1216 goto cifs_parse_mount_err
;
1218 if ((temp_len
= strnlen(value
, 1024)) < 1024) {
1219 if (value
[0] != '/')
1220 temp_len
++; /* missing leading slash */
1221 vol
->prepath
= kmalloc(temp_len
+1, GFP_KERNEL
);
1222 if (vol
->prepath
== NULL
)
1223 goto cifs_parse_mount_err
;
1224 if (value
[0] != '/') {
1225 vol
->prepath
[0] = '/';
1226 strcpy(vol
->prepath
+1, value
);
1228 strcpy(vol
->prepath
, value
);
1229 cFYI(1, "prefix path %s", vol
->prepath
);
1231 printk(KERN_WARNING
"CIFS: prefix too long\n");
1232 goto cifs_parse_mount_err
;
1234 } else if (strnicmp(data
, "iocharset", 9) == 0) {
1235 if (!value
|| !*value
) {
1236 printk(KERN_WARNING
"CIFS: invalid iocharset "
1238 goto cifs_parse_mount_err
;
1240 if (strnlen(value
, 65) < 65) {
1241 if (strnicmp(value
, "default", 7)) {
1242 vol
->iocharset
= kstrdup(value
,
1245 if (!vol
->iocharset
) {
1246 printk(KERN_WARNING
"CIFS: no "
1249 goto cifs_parse_mount_err
;
1252 /* if iocharset not set then load_nls_default
1253 is used by caller */
1254 cFYI(1, "iocharset set to %s", value
);
1256 printk(KERN_WARNING
"CIFS: iocharset name "
1258 goto cifs_parse_mount_err
;
1260 } else if (!strnicmp(data
, "uid", 3) && value
&& *value
) {
1261 vol
->linux_uid
= simple_strtoul(value
, &value
, 0);
1262 uid_specified
= true;
1263 } else if (!strnicmp(data
, "cruid", 5) && value
&& *value
) {
1264 vol
->cred_uid
= simple_strtoul(value
, &value
, 0);
1265 } else if (!strnicmp(data
, "forceuid", 8)) {
1267 } else if (!strnicmp(data
, "noforceuid", 10)) {
1269 } else if (!strnicmp(data
, "gid", 3) && value
&& *value
) {
1270 vol
->linux_gid
= simple_strtoul(value
, &value
, 0);
1271 gid_specified
= true;
1272 } else if (!strnicmp(data
, "forcegid", 8)) {
1274 } else if (!strnicmp(data
, "noforcegid", 10)) {
1276 } else if (strnicmp(data
, "file_mode", 4) == 0) {
1277 if (value
&& *value
) {
1279 simple_strtoul(value
, &value
, 0);
1281 } else if (strnicmp(data
, "dir_mode", 4) == 0) {
1282 if (value
&& *value
) {
1284 simple_strtoul(value
, &value
, 0);
1286 } else if (strnicmp(data
, "dirmode", 4) == 0) {
1287 if (value
&& *value
) {
1289 simple_strtoul(value
, &value
, 0);
1291 } else if (strnicmp(data
, "port", 4) == 0) {
1292 if (value
&& *value
) {
1294 simple_strtoul(value
, &value
, 0);
1296 } else if (strnicmp(data
, "rsize", 5) == 0) {
1297 if (value
&& *value
) {
1299 simple_strtoul(value
, &value
, 0);
1301 } else if (strnicmp(data
, "wsize", 5) == 0) {
1302 if (value
&& *value
) {
1304 simple_strtoul(value
, &value
, 0);
1306 } else if (strnicmp(data
, "sockopt", 5) == 0) {
1307 if (!value
|| !*value
) {
1308 cERROR(1, "no socket option specified");
1310 } else if (strnicmp(value
, "TCP_NODELAY", 11) == 0) {
1311 vol
->sockopt_tcp_nodelay
= 1;
1313 } else if (strnicmp(data
, "netbiosname", 4) == 0) {
1314 if (!value
|| !*value
|| (*value
== ' ')) {
1315 cFYI(1, "invalid (empty) netbiosname");
1317 memset(vol
->source_rfc1001_name
, 0x20,
1320 * FIXME: are there cases in which a comma can
1321 * be valid in workstation netbios name (and
1322 * need special handling)?
1324 for (i
= 0; i
< RFC1001_NAME_LEN
; i
++) {
1325 /* don't ucase netbiosname for user */
1328 vol
->source_rfc1001_name
[i
] = value
[i
];
1330 /* The string has 16th byte zero still from
1331 set at top of the function */
1332 if (i
== RFC1001_NAME_LEN
&& value
[i
] != 0)
1333 printk(KERN_WARNING
"CIFS: netbiosname"
1334 " longer than 15 truncated.\n");
1336 } else if (strnicmp(data
, "servern", 7) == 0) {
1337 /* servernetbiosname specified override *SMBSERVER */
1338 if (!value
|| !*value
|| (*value
== ' ')) {
1339 cFYI(1, "empty server netbiosname specified");
1341 /* last byte, type, is 0x20 for servr type */
1342 memset(vol
->target_rfc1001_name
, 0x20,
1343 RFC1001_NAME_LEN_WITH_NULL
);
1345 for (i
= 0; i
< 15; i
++) {
1346 /* BB are there cases in which a comma can be
1347 valid in this workstation netbios name
1348 (and need special handling)? */
1350 /* user or mount helper must uppercase
1355 vol
->target_rfc1001_name
[i
] =
1358 /* The string has 16th byte zero still from
1359 set at top of the function */
1360 if (i
== RFC1001_NAME_LEN
&& value
[i
] != 0)
1361 printk(KERN_WARNING
"CIFS: server net"
1362 "biosname longer than 15 truncated.\n");
1364 } else if (strnicmp(data
, "actimeo", 7) == 0) {
1365 if (value
&& *value
) {
1366 vol
->actimeo
= HZ
* simple_strtoul(value
,
1368 if (vol
->actimeo
> CIFS_MAX_ACTIMEO
) {
1369 cERROR(1, "CIFS: attribute cache"
1370 "timeout too large");
1371 goto cifs_parse_mount_err
;
1374 } else if (strnicmp(data
, "credentials", 4) == 0) {
1376 } else if (strnicmp(data
, "version", 3) == 0) {
1378 } else if (strnicmp(data
, "guest", 5) == 0) {
1380 } else if (strnicmp(data
, "rw", 2) == 0 && strlen(data
) == 2) {
1382 } else if (strnicmp(data
, "ro", 2) == 0) {
1384 } else if (strnicmp(data
, "noblocksend", 11) == 0) {
1385 vol
->noblocksnd
= 1;
1386 } else if (strnicmp(data
, "noautotune", 10) == 0) {
1387 vol
->noautotune
= 1;
1388 } else if ((strnicmp(data
, "suid", 4) == 0) ||
1389 (strnicmp(data
, "nosuid", 6) == 0) ||
1390 (strnicmp(data
, "exec", 4) == 0) ||
1391 (strnicmp(data
, "noexec", 6) == 0) ||
1392 (strnicmp(data
, "nodev", 5) == 0) ||
1393 (strnicmp(data
, "noauto", 6) == 0) ||
1394 (strnicmp(data
, "dev", 3) == 0)) {
1395 /* The mount tool or mount.cifs helper (if present)
1396 uses these opts to set flags, and the flags are read
1397 by the kernel vfs layer before we get here (ie
1398 before read super) so there is no point trying to
1399 parse these options again and set anything and it
1400 is ok to just ignore them */
1402 } else if (strnicmp(data
, "hard", 4) == 0) {
1404 } else if (strnicmp(data
, "soft", 4) == 0) {
1406 } else if (strnicmp(data
, "perm", 4) == 0) {
1408 } else if (strnicmp(data
, "noperm", 6) == 0) {
1410 } else if (strnicmp(data
, "mapchars", 8) == 0) {
1412 } else if (strnicmp(data
, "nomapchars", 10) == 0) {
1414 } else if (strnicmp(data
, "sfu", 3) == 0) {
1416 } else if (strnicmp(data
, "nosfu", 5) == 0) {
1418 } else if (strnicmp(data
, "nodfs", 5) == 0) {
1420 } else if (strnicmp(data
, "posixpaths", 10) == 0) {
1421 vol
->posix_paths
= 1;
1422 } else if (strnicmp(data
, "noposixpaths", 12) == 0) {
1423 vol
->posix_paths
= 0;
1424 } else if (strnicmp(data
, "nounix", 6) == 0) {
1425 vol
->no_linux_ext
= 1;
1426 } else if (strnicmp(data
, "nolinux", 7) == 0) {
1427 vol
->no_linux_ext
= 1;
1428 } else if ((strnicmp(data
, "nocase", 6) == 0) ||
1429 (strnicmp(data
, "ignorecase", 10) == 0)) {
1431 } else if (strnicmp(data
, "mand", 4) == 0) {
1433 } else if (strnicmp(data
, "nomand", 6) == 0) {
1435 } else if (strnicmp(data
, "_netdev", 7) == 0) {
1437 } else if (strnicmp(data
, "brl", 3) == 0) {
1439 } else if ((strnicmp(data
, "nobrl", 5) == 0) ||
1440 (strnicmp(data
, "nolock", 6) == 0)) {
1442 /* turn off mandatory locking in mode
1443 if remote locking is turned off since the
1444 local vfs will do advisory */
1445 if (vol
->file_mode
==
1446 (S_IALLUGO
& ~(S_ISUID
| S_IXGRP
)))
1447 vol
->file_mode
= S_IALLUGO
;
1448 } else if (strnicmp(data
, "forcemandatorylock", 9) == 0) {
1449 /* will take the shorter form "forcemand" as well */
1450 /* This mount option will force use of mandatory
1451 (DOS/Windows style) byte range locks, instead of
1452 using posix advisory byte range locks, even if the
1453 Unix extensions are available and posix locks would
1454 be supported otherwise. If Unix extensions are not
1455 negotiated this has no effect since mandatory locks
1456 would be used (mandatory locks is all that those
1457 those servers support) */
1459 } else if (strnicmp(data
, "setuids", 7) == 0) {
1461 } else if (strnicmp(data
, "nosetuids", 9) == 0) {
1463 } else if (strnicmp(data
, "dynperm", 7) == 0) {
1464 vol
->dynperm
= true;
1465 } else if (strnicmp(data
, "nodynperm", 9) == 0) {
1466 vol
->dynperm
= false;
1467 } else if (strnicmp(data
, "nohard", 6) == 0) {
1469 } else if (strnicmp(data
, "nosoft", 6) == 0) {
1471 } else if (strnicmp(data
, "nointr", 6) == 0) {
1473 } else if (strnicmp(data
, "intr", 4) == 0) {
1475 } else if (strnicmp(data
, "nostrictsync", 12) == 0) {
1476 vol
->nostrictsync
= 1;
1477 } else if (strnicmp(data
, "strictsync", 10) == 0) {
1478 vol
->nostrictsync
= 0;
1479 } else if (strnicmp(data
, "serverino", 7) == 0) {
1480 vol
->server_ino
= 1;
1481 } else if (strnicmp(data
, "noserverino", 9) == 0) {
1482 vol
->server_ino
= 0;
1483 } else if (strnicmp(data
, "rwpidforward", 12) == 0) {
1484 vol
->rwpidforward
= 1;
1485 } else if (strnicmp(data
, "cifsacl", 7) == 0) {
1487 } else if (strnicmp(data
, "nocifsacl", 9) == 0) {
1489 } else if (strnicmp(data
, "acl", 3) == 0) {
1490 vol
->no_psx_acl
= 0;
1491 } else if (strnicmp(data
, "noacl", 5) == 0) {
1492 vol
->no_psx_acl
= 1;
1493 } else if (strnicmp(data
, "locallease", 6) == 0) {
1494 vol
->local_lease
= 1;
1495 } else if (strnicmp(data
, "sign", 4) == 0) {
1496 vol
->secFlg
|= CIFSSEC_MUST_SIGN
;
1497 } else if (strnicmp(data
, "seal", 4) == 0) {
1498 /* we do not do the following in secFlags because seal
1499 is a per tree connection (mount) not a per socket
1500 or per-smb connection option in the protocol */
1501 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1503 } else if (strnicmp(data
, "direct", 6) == 0) {
1505 } else if (strnicmp(data
, "forcedirectio", 13) == 0) {
1507 } else if (strnicmp(data
, "strictcache", 11) == 0) {
1509 } else if (strnicmp(data
, "noac", 4) == 0) {
1510 printk(KERN_WARNING
"CIFS: Mount option noac not "
1511 "supported. Instead set "
1512 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1513 } else if (strnicmp(data
, "fsc", 3) == 0) {
1514 #ifndef CONFIG_CIFS_FSCACHE
1515 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE "
1516 "kernel config option set");
1517 goto cifs_parse_mount_err
;
1520 } else if (strnicmp(data
, "mfsymlinks", 10) == 0) {
1521 vol
->mfsymlinks
= true;
1522 } else if (strnicmp(data
, "multiuser", 8) == 0) {
1523 vol
->multiuser
= true;
1524 } else if (!strnicmp(data
, "backupuid", 9) && value
&& *value
) {
1525 err
= kstrtouint(value
, 0, &vol
->backupuid
);
1527 cERROR(1, "%s: Invalid backupuid value",
1529 goto cifs_parse_mount_err
;
1531 vol
->backupuid_specified
= true;
1532 } else if (!strnicmp(data
, "backupgid", 9) && value
&& *value
) {
1533 err
= kstrtouint(value
, 0, &vol
->backupgid
);
1535 cERROR(1, "%s: Invalid backupgid value",
1537 goto cifs_parse_mount_err
;
1539 vol
->backupgid_specified
= true;
1541 printk(KERN_WARNING
"CIFS: Unknown mount option %s\n",
1544 if (vol
->UNC
== NULL
) {
1545 if (devname
== NULL
) {
1546 printk(KERN_WARNING
"CIFS: Missing UNC name for mount "
1548 goto cifs_parse_mount_err
;
1550 if ((temp_len
= strnlen(devname
, 300)) < 300) {
1551 vol
->UNC
= kmalloc(temp_len
+1, GFP_KERNEL
);
1552 if (vol
->UNC
== NULL
)
1553 goto cifs_parse_mount_err
;
1554 strcpy(vol
->UNC
, devname
);
1555 if (strncmp(vol
->UNC
, "//", 2) == 0) {
1558 } else if (strncmp(vol
->UNC
, "\\\\", 2) != 0) {
1559 printk(KERN_WARNING
"CIFS: UNC Path does not "
1560 "begin with // or \\\\ \n");
1561 goto cifs_parse_mount_err
;
1563 value
= strpbrk(vol
->UNC
+2, "/\\");
1567 printk(KERN_WARNING
"CIFS: UNC name too long\n");
1568 goto cifs_parse_mount_err
;
1572 if (vol
->multiuser
&& !(vol
->secFlg
& CIFSSEC_MAY_KRB5
)) {
1573 cERROR(1, "Multiuser mounts currently require krb5 "
1575 goto cifs_parse_mount_err
;
1578 if (vol
->UNCip
== NULL
)
1579 vol
->UNCip
= &vol
->UNC
[2];
1582 vol
->override_uid
= override_uid
;
1583 else if (override_uid
== 1)
1584 printk(KERN_NOTICE
"CIFS: ignoring forceuid mount option "
1585 "specified with no uid= option.\n");
1588 vol
->override_gid
= override_gid
;
1589 else if (override_gid
== 1)
1590 printk(KERN_NOTICE
"CIFS: ignoring forcegid mount option "
1591 "specified with no gid= option.\n");
1593 kfree(mountdata_copy
);
1596 cifs_parse_mount_err
:
1597 kfree(mountdata_copy
);
1601 /** Returns true if srcaddr isn't specified and rhs isn't
1602 * specified, or if srcaddr is specified and
1603 * matches the IP address of the rhs argument.
1606 srcip_matches(struct sockaddr
*srcaddr
, struct sockaddr
*rhs
)
1608 switch (srcaddr
->sa_family
) {
1610 return (rhs
->sa_family
== AF_UNSPEC
);
1612 struct sockaddr_in
*saddr4
= (struct sockaddr_in
*)srcaddr
;
1613 struct sockaddr_in
*vaddr4
= (struct sockaddr_in
*)rhs
;
1614 return (saddr4
->sin_addr
.s_addr
== vaddr4
->sin_addr
.s_addr
);
1617 struct sockaddr_in6
*saddr6
= (struct sockaddr_in6
*)srcaddr
;
1618 struct sockaddr_in6
*vaddr6
= (struct sockaddr_in6
*)&rhs
;
1619 return ipv6_addr_equal(&saddr6
->sin6_addr
, &vaddr6
->sin6_addr
);
1623 return false; /* don't expect to be here */
1628 * If no port is specified in addr structure, we try to match with 445 port
1629 * and if it fails - with 139 ports. It should be called only if address
1630 * families of server and addr are equal.
1633 match_port(struct TCP_Server_Info
*server
, struct sockaddr
*addr
)
1635 __be16 port
, *sport
;
1637 switch (addr
->sa_family
) {
1639 sport
= &((struct sockaddr_in
*) &server
->dstaddr
)->sin_port
;
1640 port
= ((struct sockaddr_in
*) addr
)->sin_port
;
1643 sport
= &((struct sockaddr_in6
*) &server
->dstaddr
)->sin6_port
;
1644 port
= ((struct sockaddr_in6
*) addr
)->sin6_port
;
1652 port
= htons(CIFS_PORT
);
1656 port
= htons(RFC1001_PORT
);
1659 return port
== *sport
;
1663 match_address(struct TCP_Server_Info
*server
, struct sockaddr
*addr
,
1664 struct sockaddr
*srcaddr
)
1666 switch (addr
->sa_family
) {
1668 struct sockaddr_in
*addr4
= (struct sockaddr_in
*)addr
;
1669 struct sockaddr_in
*srv_addr4
=
1670 (struct sockaddr_in
*)&server
->dstaddr
;
1672 if (addr4
->sin_addr
.s_addr
!= srv_addr4
->sin_addr
.s_addr
)
1677 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)addr
;
1678 struct sockaddr_in6
*srv_addr6
=
1679 (struct sockaddr_in6
*)&server
->dstaddr
;
1681 if (!ipv6_addr_equal(&addr6
->sin6_addr
,
1682 &srv_addr6
->sin6_addr
))
1684 if (addr6
->sin6_scope_id
!= srv_addr6
->sin6_scope_id
)
1690 return false; /* don't expect to be here */
1693 if (!srcip_matches(srcaddr
, (struct sockaddr
*)&server
->srcaddr
))
1700 match_security(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
1702 unsigned int secFlags
;
1704 if (vol
->secFlg
& (~(CIFSSEC_MUST_SIGN
| CIFSSEC_MUST_SEAL
)))
1705 secFlags
= vol
->secFlg
;
1707 secFlags
= global_secflags
| vol
->secFlg
;
1709 switch (server
->secType
) {
1711 if (!(secFlags
& (CIFSSEC_MAY_LANMAN
|CIFSSEC_MAY_PLNTXT
)))
1715 if (!(secFlags
& CIFSSEC_MAY_NTLMV2
))
1719 if (!(secFlags
& CIFSSEC_MAY_NTLM
))
1723 if (!(secFlags
& CIFSSEC_MAY_KRB5
))
1727 if (!(secFlags
& CIFSSEC_MAY_NTLMSSP
))
1731 /* shouldn't happen */
1735 /* now check if signing mode is acceptable */
1736 if ((secFlags
& CIFSSEC_MAY_SIGN
) == 0 &&
1737 (server
->sec_mode
& SECMODE_SIGN_REQUIRED
))
1739 else if (((secFlags
& CIFSSEC_MUST_SIGN
) == CIFSSEC_MUST_SIGN
) &&
1741 (SECMODE_SIGN_ENABLED
|SECMODE_SIGN_REQUIRED
)) == 0)
1747 static int match_server(struct TCP_Server_Info
*server
, struct sockaddr
*addr
,
1748 struct smb_vol
*vol
)
1750 if (!net_eq(cifs_net_ns(server
), current
->nsproxy
->net_ns
))
1753 if (!match_address(server
, addr
,
1754 (struct sockaddr
*)&vol
->srcaddr
))
1757 if (!match_port(server
, addr
))
1760 if (!match_security(server
, vol
))
1766 static struct TCP_Server_Info
*
1767 cifs_find_tcp_session(struct sockaddr
*addr
, struct smb_vol
*vol
)
1769 struct TCP_Server_Info
*server
;
1771 spin_lock(&cifs_tcp_ses_lock
);
1772 list_for_each_entry(server
, &cifs_tcp_ses_list
, tcp_ses_list
) {
1773 if (!match_server(server
, addr
, vol
))
1776 ++server
->srv_count
;
1777 spin_unlock(&cifs_tcp_ses_lock
);
1778 cFYI(1, "Existing tcp session with server found");
1781 spin_unlock(&cifs_tcp_ses_lock
);
1786 cifs_put_tcp_session(struct TCP_Server_Info
*server
)
1788 struct task_struct
*task
;
1790 spin_lock(&cifs_tcp_ses_lock
);
1791 if (--server
->srv_count
> 0) {
1792 spin_unlock(&cifs_tcp_ses_lock
);
1796 put_net(cifs_net_ns(server
));
1798 list_del_init(&server
->tcp_ses_list
);
1799 spin_unlock(&cifs_tcp_ses_lock
);
1801 cancel_delayed_work_sync(&server
->echo
);
1803 spin_lock(&GlobalMid_Lock
);
1804 server
->tcpStatus
= CifsExiting
;
1805 spin_unlock(&GlobalMid_Lock
);
1807 cifs_crypto_shash_release(server
);
1808 cifs_fscache_release_client_cookie(server
);
1810 kfree(server
->session_key
.response
);
1811 server
->session_key
.response
= NULL
;
1812 server
->session_key
.len
= 0;
1814 task
= xchg(&server
->tsk
, NULL
);
1816 force_sig(SIGKILL
, task
);
1819 static struct TCP_Server_Info
*
1820 cifs_get_tcp_session(struct smb_vol
*volume_info
)
1822 struct TCP_Server_Info
*tcp_ses
= NULL
;
1823 struct sockaddr_storage addr
;
1824 struct sockaddr_in
*sin_server
= (struct sockaddr_in
*) &addr
;
1825 struct sockaddr_in6
*sin_server6
= (struct sockaddr_in6
*) &addr
;
1828 memset(&addr
, 0, sizeof(struct sockaddr_storage
));
1830 cFYI(1, "UNC: %s ip: %s", volume_info
->UNC
, volume_info
->UNCip
);
1832 if (volume_info
->UNCip
&& volume_info
->UNC
) {
1833 rc
= cifs_fill_sockaddr((struct sockaddr
*)&addr
,
1835 strlen(volume_info
->UNCip
),
1838 /* we failed translating address */
1842 } else if (volume_info
->UNCip
) {
1843 /* BB using ip addr as tcp_ses name to connect to the
1845 cERROR(1, "Connecting to DFS root not implemented yet");
1848 } else /* which tcp_sess DFS root would we conect to */ {
1849 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
1850 "unc=//192.168.1.100/public) specified");
1855 /* see if we already have a matching tcp_ses */
1856 tcp_ses
= cifs_find_tcp_session((struct sockaddr
*)&addr
, volume_info
);
1860 tcp_ses
= kzalloc(sizeof(struct TCP_Server_Info
), GFP_KERNEL
);
1866 rc
= cifs_crypto_shash_allocate(tcp_ses
);
1868 cERROR(1, "could not setup hash structures rc %d", rc
);
1872 cifs_set_net_ns(tcp_ses
, get_net(current
->nsproxy
->net_ns
));
1873 tcp_ses
->hostname
= extract_hostname(volume_info
->UNC
);
1874 if (IS_ERR(tcp_ses
->hostname
)) {
1875 rc
= PTR_ERR(tcp_ses
->hostname
);
1876 goto out_err_crypto_release
;
1879 tcp_ses
->noblocksnd
= volume_info
->noblocksnd
;
1880 tcp_ses
->noautotune
= volume_info
->noautotune
;
1881 tcp_ses
->tcp_nodelay
= volume_info
->sockopt_tcp_nodelay
;
1882 atomic_set(&tcp_ses
->inFlight
, 0);
1883 init_waitqueue_head(&tcp_ses
->response_q
);
1884 init_waitqueue_head(&tcp_ses
->request_q
);
1885 INIT_LIST_HEAD(&tcp_ses
->pending_mid_q
);
1886 mutex_init(&tcp_ses
->srv_mutex
);
1887 memcpy(tcp_ses
->workstation_RFC1001_name
,
1888 volume_info
->source_rfc1001_name
, RFC1001_NAME_LEN_WITH_NULL
);
1889 memcpy(tcp_ses
->server_RFC1001_name
,
1890 volume_info
->target_rfc1001_name
, RFC1001_NAME_LEN_WITH_NULL
);
1891 tcp_ses
->session_estab
= false;
1892 tcp_ses
->sequence_number
= 0;
1893 tcp_ses
->lstrp
= jiffies
;
1894 INIT_LIST_HEAD(&tcp_ses
->tcp_ses_list
);
1895 INIT_LIST_HEAD(&tcp_ses
->smb_ses_list
);
1896 INIT_DELAYED_WORK(&tcp_ses
->echo
, cifs_echo_request
);
1899 * at this point we are the only ones with the pointer
1900 * to the struct since the kernel thread not created yet
1901 * no need to spinlock this init of tcpStatus or srv_count
1903 tcp_ses
->tcpStatus
= CifsNew
;
1904 memcpy(&tcp_ses
->srcaddr
, &volume_info
->srcaddr
,
1905 sizeof(tcp_ses
->srcaddr
));
1906 ++tcp_ses
->srv_count
;
1908 if (addr
.ss_family
== AF_INET6
) {
1909 cFYI(1, "attempting ipv6 connect");
1910 /* BB should we allow ipv6 on port 139? */
1911 /* other OS never observed in Wild doing 139 with v6 */
1912 memcpy(&tcp_ses
->dstaddr
, sin_server6
,
1913 sizeof(struct sockaddr_in6
));
1915 memcpy(&tcp_ses
->dstaddr
, sin_server
,
1916 sizeof(struct sockaddr_in
));
1918 rc
= ip_connect(tcp_ses
);
1920 cERROR(1, "Error connecting to socket. Aborting operation");
1921 goto out_err_crypto_release
;
1925 * since we're in a cifs function already, we know that
1926 * this will succeed. No need for try_module_get().
1928 __module_get(THIS_MODULE
);
1929 tcp_ses
->tsk
= kthread_run(cifs_demultiplex_thread
,
1931 if (IS_ERR(tcp_ses
->tsk
)) {
1932 rc
= PTR_ERR(tcp_ses
->tsk
);
1933 cERROR(1, "error %d create cifsd thread", rc
);
1934 module_put(THIS_MODULE
);
1935 goto out_err_crypto_release
;
1937 tcp_ses
->tcpStatus
= CifsNeedNegotiate
;
1939 /* thread spawned, put it on the list */
1940 spin_lock(&cifs_tcp_ses_lock
);
1941 list_add(&tcp_ses
->tcp_ses_list
, &cifs_tcp_ses_list
);
1942 spin_unlock(&cifs_tcp_ses_lock
);
1944 cifs_fscache_get_client_cookie(tcp_ses
);
1946 /* queue echo request delayed work */
1947 queue_delayed_work(system_nrt_wq
, &tcp_ses
->echo
, SMB_ECHO_INTERVAL
);
1951 out_err_crypto_release
:
1952 cifs_crypto_shash_release(tcp_ses
);
1954 put_net(cifs_net_ns(tcp_ses
));
1958 if (!IS_ERR(tcp_ses
->hostname
))
1959 kfree(tcp_ses
->hostname
);
1960 if (tcp_ses
->ssocket
)
1961 sock_release(tcp_ses
->ssocket
);
1967 static int match_session(struct cifs_ses
*ses
, struct smb_vol
*vol
)
1969 switch (ses
->server
->secType
) {
1971 if (vol
->cred_uid
!= ses
->cred_uid
)
1975 /* anything else takes username/password */
1976 if (ses
->user_name
== NULL
)
1978 if (strncmp(ses
->user_name
, vol
->username
,
1981 if (strlen(vol
->username
) != 0 &&
1982 ses
->password
!= NULL
&&
1983 strncmp(ses
->password
,
1984 vol
->password
? vol
->password
: "",
1991 static struct cifs_ses
*
1992 cifs_find_smb_ses(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
1994 struct cifs_ses
*ses
;
1996 spin_lock(&cifs_tcp_ses_lock
);
1997 list_for_each_entry(ses
, &server
->smb_ses_list
, smb_ses_list
) {
1998 if (!match_session(ses
, vol
))
2001 spin_unlock(&cifs_tcp_ses_lock
);
2004 spin_unlock(&cifs_tcp_ses_lock
);
2009 cifs_put_smb_ses(struct cifs_ses
*ses
)
2012 struct TCP_Server_Info
*server
= ses
->server
;
2014 cFYI(1, "%s: ses_count=%d\n", __func__
, ses
->ses_count
);
2015 spin_lock(&cifs_tcp_ses_lock
);
2016 if (--ses
->ses_count
> 0) {
2017 spin_unlock(&cifs_tcp_ses_lock
);
2021 list_del_init(&ses
->smb_ses_list
);
2022 spin_unlock(&cifs_tcp_ses_lock
);
2024 if (ses
->status
== CifsGood
) {
2026 CIFSSMBLogoff(xid
, ses
);
2030 cifs_put_tcp_session(server
);
2033 static bool warned_on_ntlm
; /* globals init to false automatically */
2035 static struct cifs_ses
*
2036 cifs_get_smb_ses(struct TCP_Server_Info
*server
, struct smb_vol
*volume_info
)
2038 int rc
= -ENOMEM
, xid
;
2039 struct cifs_ses
*ses
;
2040 struct sockaddr_in
*addr
= (struct sockaddr_in
*)&server
->dstaddr
;
2041 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)&server
->dstaddr
;
2045 ses
= cifs_find_smb_ses(server
, volume_info
);
2047 cFYI(1, "Existing smb sess found (status=%d)", ses
->status
);
2049 mutex_lock(&ses
->session_mutex
);
2050 rc
= cifs_negotiate_protocol(xid
, ses
);
2052 mutex_unlock(&ses
->session_mutex
);
2053 /* problem -- put our ses reference */
2054 cifs_put_smb_ses(ses
);
2058 if (ses
->need_reconnect
) {
2059 cFYI(1, "Session needs reconnect");
2060 rc
= cifs_setup_session(xid
, ses
,
2061 volume_info
->local_nls
);
2063 mutex_unlock(&ses
->session_mutex
);
2064 /* problem -- put our reference */
2065 cifs_put_smb_ses(ses
);
2070 mutex_unlock(&ses
->session_mutex
);
2072 /* existing SMB ses has a server reference already */
2073 cifs_put_tcp_session(server
);
2078 cFYI(1, "Existing smb sess not found");
2079 ses
= sesInfoAlloc();
2083 /* new SMB session uses our server ref */
2084 ses
->server
= server
;
2085 if (server
->dstaddr
.ss_family
== AF_INET6
)
2086 sprintf(ses
->serverName
, "%pI6", &addr6
->sin6_addr
);
2088 sprintf(ses
->serverName
, "%pI4", &addr
->sin_addr
);
2090 if (volume_info
->username
) {
2091 ses
->user_name
= kstrdup(volume_info
->username
, GFP_KERNEL
);
2092 if (!ses
->user_name
)
2096 /* volume_info->password freed at unmount */
2097 if (volume_info
->password
) {
2098 ses
->password
= kstrdup(volume_info
->password
, GFP_KERNEL
);
2102 if (volume_info
->domainname
) {
2103 ses
->domainName
= kstrdup(volume_info
->domainname
, GFP_KERNEL
);
2104 if (!ses
->domainName
)
2107 ses
->cred_uid
= volume_info
->cred_uid
;
2108 ses
->linux_uid
= volume_info
->linux_uid
;
2110 /* ntlmv2 is much stronger than ntlm security, and has been broadly
2111 supported for many years, time to update default security mechanism */
2112 if ((volume_info
->secFlg
== 0) && warned_on_ntlm
== false) {
2113 warned_on_ntlm
= true;
2114 cERROR(1, "default security mechanism requested. The default "
2115 "security mechanism will be upgraded from ntlm to "
2116 "ntlmv2 in kernel release 3.2");
2118 ses
->overrideSecFlg
= volume_info
->secFlg
;
2120 mutex_lock(&ses
->session_mutex
);
2121 rc
= cifs_negotiate_protocol(xid
, ses
);
2123 rc
= cifs_setup_session(xid
, ses
, volume_info
->local_nls
);
2124 mutex_unlock(&ses
->session_mutex
);
2128 /* success, put it on the list */
2129 spin_lock(&cifs_tcp_ses_lock
);
2130 list_add(&ses
->smb_ses_list
, &server
->smb_ses_list
);
2131 spin_unlock(&cifs_tcp_ses_lock
);
2142 static int match_tcon(struct cifs_tcon
*tcon
, const char *unc
)
2144 if (tcon
->tidStatus
== CifsExiting
)
2146 if (strncmp(tcon
->treeName
, unc
, MAX_TREE_SIZE
))
2151 static struct cifs_tcon
*
2152 cifs_find_tcon(struct cifs_ses
*ses
, const char *unc
)
2154 struct list_head
*tmp
;
2155 struct cifs_tcon
*tcon
;
2157 spin_lock(&cifs_tcp_ses_lock
);
2158 list_for_each(tmp
, &ses
->tcon_list
) {
2159 tcon
= list_entry(tmp
, struct cifs_tcon
, tcon_list
);
2160 if (!match_tcon(tcon
, unc
))
2163 spin_unlock(&cifs_tcp_ses_lock
);
2166 spin_unlock(&cifs_tcp_ses_lock
);
2171 cifs_put_tcon(struct cifs_tcon
*tcon
)
2174 struct cifs_ses
*ses
= tcon
->ses
;
2176 cFYI(1, "%s: tc_count=%d\n", __func__
, tcon
->tc_count
);
2177 spin_lock(&cifs_tcp_ses_lock
);
2178 if (--tcon
->tc_count
> 0) {
2179 spin_unlock(&cifs_tcp_ses_lock
);
2183 list_del_init(&tcon
->tcon_list
);
2184 spin_unlock(&cifs_tcp_ses_lock
);
2187 CIFSSMBTDis(xid
, tcon
);
2190 cifs_fscache_release_super_cookie(tcon
);
2192 cifs_put_smb_ses(ses
);
2195 static struct cifs_tcon
*
2196 cifs_get_tcon(struct cifs_ses
*ses
, struct smb_vol
*volume_info
)
2199 struct cifs_tcon
*tcon
;
2201 tcon
= cifs_find_tcon(ses
, volume_info
->UNC
);
2203 cFYI(1, "Found match on UNC path");
2204 /* existing tcon already has a reference */
2205 cifs_put_smb_ses(ses
);
2206 if (tcon
->seal
!= volume_info
->seal
)
2207 cERROR(1, "transport encryption setting "
2208 "conflicts with existing tid");
2212 tcon
= tconInfoAlloc();
2219 if (volume_info
->password
) {
2220 tcon
->password
= kstrdup(volume_info
->password
, GFP_KERNEL
);
2221 if (!tcon
->password
) {
2227 if (strchr(volume_info
->UNC
+ 3, '\\') == NULL
2228 && strchr(volume_info
->UNC
+ 3, '/') == NULL
) {
2229 cERROR(1, "Missing share name");
2234 /* BB Do we need to wrap session_mutex around
2235 * this TCon call and Unix SetFS as
2236 * we do on SessSetup and reconnect? */
2238 rc
= CIFSTCon(xid
, ses
, volume_info
->UNC
, tcon
, volume_info
->local_nls
);
2240 cFYI(1, "CIFS Tcon rc = %d", rc
);
2244 if (volume_info
->nodfs
) {
2245 tcon
->Flags
&= ~SMB_SHARE_IS_IN_DFS
;
2246 cFYI(1, "DFS disabled (%d)", tcon
->Flags
);
2248 tcon
->seal
= volume_info
->seal
;
2249 /* we can have only one retry value for a connection
2250 to a share so for resources mounted more than once
2251 to the same server share the last value passed in
2252 for the retry flag is used */
2253 tcon
->retry
= volume_info
->retry
;
2254 tcon
->nocase
= volume_info
->nocase
;
2255 tcon
->local_lease
= volume_info
->local_lease
;
2257 spin_lock(&cifs_tcp_ses_lock
);
2258 list_add(&tcon
->tcon_list
, &ses
->tcon_list
);
2259 spin_unlock(&cifs_tcp_ses_lock
);
2261 cifs_fscache_get_super_cookie(tcon
);
2271 cifs_put_tlink(struct tcon_link
*tlink
)
2273 if (!tlink
|| IS_ERR(tlink
))
2276 if (!atomic_dec_and_test(&tlink
->tl_count
) ||
2277 test_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
)) {
2278 tlink
->tl_time
= jiffies
;
2282 if (!IS_ERR(tlink_tcon(tlink
)))
2283 cifs_put_tcon(tlink_tcon(tlink
));
2288 static inline struct tcon_link
*
2289 cifs_sb_master_tlink(struct cifs_sb_info
*cifs_sb
)
2291 return cifs_sb
->master_tlink
;
2295 compare_mount_options(struct super_block
*sb
, struct cifs_mnt_data
*mnt_data
)
2297 struct cifs_sb_info
*old
= CIFS_SB(sb
);
2298 struct cifs_sb_info
*new = mnt_data
->cifs_sb
;
2300 if ((sb
->s_flags
& CIFS_MS_MASK
) != (mnt_data
->flags
& CIFS_MS_MASK
))
2303 if ((old
->mnt_cifs_flags
& CIFS_MOUNT_MASK
) !=
2304 (new->mnt_cifs_flags
& CIFS_MOUNT_MASK
))
2307 if (old
->rsize
!= new->rsize
)
2311 * We want to share sb only if we don't specify wsize or specified wsize
2312 * is greater or equal than existing one.
2314 if (new->wsize
&& new->wsize
< old
->wsize
)
2317 if (old
->mnt_uid
!= new->mnt_uid
|| old
->mnt_gid
!= new->mnt_gid
)
2320 if (old
->mnt_file_mode
!= new->mnt_file_mode
||
2321 old
->mnt_dir_mode
!= new->mnt_dir_mode
)
2324 if (strcmp(old
->local_nls
->charset
, new->local_nls
->charset
))
2327 if (old
->actimeo
!= new->actimeo
)
2334 cifs_match_super(struct super_block
*sb
, void *data
)
2336 struct cifs_mnt_data
*mnt_data
= (struct cifs_mnt_data
*)data
;
2337 struct smb_vol
*volume_info
;
2338 struct cifs_sb_info
*cifs_sb
;
2339 struct TCP_Server_Info
*tcp_srv
;
2340 struct cifs_ses
*ses
;
2341 struct cifs_tcon
*tcon
;
2342 struct tcon_link
*tlink
;
2343 struct sockaddr_storage addr
;
2346 memset(&addr
, 0, sizeof(struct sockaddr_storage
));
2348 spin_lock(&cifs_tcp_ses_lock
);
2349 cifs_sb
= CIFS_SB(sb
);
2350 tlink
= cifs_get_tlink(cifs_sb_master_tlink(cifs_sb
));
2351 if (IS_ERR(tlink
)) {
2352 spin_unlock(&cifs_tcp_ses_lock
);
2355 tcon
= tlink_tcon(tlink
);
2357 tcp_srv
= ses
->server
;
2359 volume_info
= mnt_data
->vol
;
2361 if (!volume_info
->UNCip
|| !volume_info
->UNC
)
2364 rc
= cifs_fill_sockaddr((struct sockaddr
*)&addr
,
2366 strlen(volume_info
->UNCip
),
2371 if (!match_server(tcp_srv
, (struct sockaddr
*)&addr
, volume_info
) ||
2372 !match_session(ses
, volume_info
) ||
2373 !match_tcon(tcon
, volume_info
->UNC
)) {
2378 rc
= compare_mount_options(sb
, mnt_data
);
2380 spin_unlock(&cifs_tcp_ses_lock
);
2381 cifs_put_tlink(tlink
);
2386 get_dfs_path(int xid
, struct cifs_ses
*pSesInfo
, const char *old_path
,
2387 const struct nls_table
*nls_codepage
, unsigned int *pnum_referrals
,
2388 struct dfs_info3_param
**preferrals
, int remap
)
2393 *pnum_referrals
= 0;
2396 if (pSesInfo
->ipc_tid
== 0) {
2397 temp_unc
= kmalloc(2 /* for slashes */ +
2398 strnlen(pSesInfo
->serverName
,
2399 SERVER_NAME_LEN_WITH_NULL
* 2)
2400 + 1 + 4 /* slash IPC$ */ + 2,
2402 if (temp_unc
== NULL
)
2406 strcpy(temp_unc
+ 2, pSesInfo
->serverName
);
2407 strcpy(temp_unc
+ 2 + strlen(pSesInfo
->serverName
), "\\IPC$");
2408 rc
= CIFSTCon(xid
, pSesInfo
, temp_unc
, NULL
, nls_codepage
);
2409 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc
, pSesInfo
->ipc_tid
);
2413 rc
= CIFSGetDFSRefer(xid
, pSesInfo
, old_path
, preferrals
,
2414 pnum_referrals
, nls_codepage
, remap
);
2415 /* BB map targetUNCs to dfs_info3 structures, here or
2416 in CIFSGetDFSRefer BB */
2421 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2422 static struct lock_class_key cifs_key
[2];
2423 static struct lock_class_key cifs_slock_key
[2];
2426 cifs_reclassify_socket4(struct socket
*sock
)
2428 struct sock
*sk
= sock
->sk
;
2429 BUG_ON(sock_owned_by_user(sk
));
2430 sock_lock_init_class_and_name(sk
, "slock-AF_INET-CIFS",
2431 &cifs_slock_key
[0], "sk_lock-AF_INET-CIFS", &cifs_key
[0]);
2435 cifs_reclassify_socket6(struct socket
*sock
)
2437 struct sock
*sk
= sock
->sk
;
2438 BUG_ON(sock_owned_by_user(sk
));
2439 sock_lock_init_class_and_name(sk
, "slock-AF_INET6-CIFS",
2440 &cifs_slock_key
[1], "sk_lock-AF_INET6-CIFS", &cifs_key
[1]);
2444 cifs_reclassify_socket4(struct socket
*sock
)
2449 cifs_reclassify_socket6(struct socket
*sock
)
2454 /* See RFC1001 section 14 on representation of Netbios names */
2455 static void rfc1002mangle(char *target
, char *source
, unsigned int length
)
2459 for (i
= 0, j
= 0; i
< (length
); i
++) {
2460 /* mask a nibble at a time and encode */
2461 target
[j
] = 'A' + (0x0F & (source
[i
] >> 4));
2462 target
[j
+1] = 'A' + (0x0F & source
[i
]);
2469 bind_socket(struct TCP_Server_Info
*server
)
2472 if (server
->srcaddr
.ss_family
!= AF_UNSPEC
) {
2473 /* Bind to the specified local IP address */
2474 struct socket
*socket
= server
->ssocket
;
2475 rc
= socket
->ops
->bind(socket
,
2476 (struct sockaddr
*) &server
->srcaddr
,
2477 sizeof(server
->srcaddr
));
2479 struct sockaddr_in
*saddr4
;
2480 struct sockaddr_in6
*saddr6
;
2481 saddr4
= (struct sockaddr_in
*)&server
->srcaddr
;
2482 saddr6
= (struct sockaddr_in6
*)&server
->srcaddr
;
2483 if (saddr6
->sin6_family
== AF_INET6
)
2485 "Failed to bind to: %pI6c, error: %d\n",
2486 &saddr6
->sin6_addr
, rc
);
2489 "Failed to bind to: %pI4, error: %d\n",
2490 &saddr4
->sin_addr
.s_addr
, rc
);
2497 ip_rfc1001_connect(struct TCP_Server_Info
*server
)
2501 * some servers require RFC1001 sessinit before sending
2502 * negprot - BB check reconnection in case where second
2503 * sessinit is sent but no second negprot
2505 struct rfc1002_session_packet
*ses_init_buf
;
2506 struct smb_hdr
*smb_buf
;
2507 ses_init_buf
= kzalloc(sizeof(struct rfc1002_session_packet
),
2510 ses_init_buf
->trailer
.session_req
.called_len
= 32;
2512 if (server
->server_RFC1001_name
&&
2513 server
->server_RFC1001_name
[0] != 0)
2514 rfc1002mangle(ses_init_buf
->trailer
.
2515 session_req
.called_name
,
2516 server
->server_RFC1001_name
,
2517 RFC1001_NAME_LEN_WITH_NULL
);
2519 rfc1002mangle(ses_init_buf
->trailer
.
2520 session_req
.called_name
,
2521 DEFAULT_CIFS_CALLED_NAME
,
2522 RFC1001_NAME_LEN_WITH_NULL
);
2524 ses_init_buf
->trailer
.session_req
.calling_len
= 32;
2527 * calling name ends in null (byte 16) from old smb
2530 if (server
->workstation_RFC1001_name
&&
2531 server
->workstation_RFC1001_name
[0] != 0)
2532 rfc1002mangle(ses_init_buf
->trailer
.
2533 session_req
.calling_name
,
2534 server
->workstation_RFC1001_name
,
2535 RFC1001_NAME_LEN_WITH_NULL
);
2537 rfc1002mangle(ses_init_buf
->trailer
.
2538 session_req
.calling_name
,
2540 RFC1001_NAME_LEN_WITH_NULL
);
2542 ses_init_buf
->trailer
.session_req
.scope1
= 0;
2543 ses_init_buf
->trailer
.session_req
.scope2
= 0;
2544 smb_buf
= (struct smb_hdr
*)ses_init_buf
;
2546 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2547 smb_buf
->smb_buf_length
= cpu_to_be32(0x81000044);
2548 rc
= smb_send(server
, smb_buf
, 0x44);
2549 kfree(ses_init_buf
);
2551 * RFC1001 layer in at least one server
2552 * requires very short break before negprot
2553 * presumably because not expecting negprot
2554 * to follow so fast. This is a simple
2555 * solution that works without
2556 * complicating the code and causes no
2557 * significant slowing down on mount
2560 usleep_range(1000, 2000);
2563 * else the negprot may still work without this
2564 * even though malloc failed
2571 generic_ip_connect(struct TCP_Server_Info
*server
)
2576 struct socket
*socket
= server
->ssocket
;
2577 struct sockaddr
*saddr
;
2579 saddr
= (struct sockaddr
*) &server
->dstaddr
;
2581 if (server
->dstaddr
.ss_family
== AF_INET6
) {
2582 sport
= ((struct sockaddr_in6
*) saddr
)->sin6_port
;
2583 slen
= sizeof(struct sockaddr_in6
);
2586 sport
= ((struct sockaddr_in
*) saddr
)->sin_port
;
2587 slen
= sizeof(struct sockaddr_in
);
2591 if (socket
== NULL
) {
2592 rc
= __sock_create(cifs_net_ns(server
), sfamily
, SOCK_STREAM
,
2593 IPPROTO_TCP
, &socket
, 1);
2595 cERROR(1, "Error %d creating socket", rc
);
2596 server
->ssocket
= NULL
;
2600 /* BB other socket options to set KEEPALIVE, NODELAY? */
2601 cFYI(1, "Socket created");
2602 server
->ssocket
= socket
;
2603 socket
->sk
->sk_allocation
= GFP_NOFS
;
2604 if (sfamily
== AF_INET6
)
2605 cifs_reclassify_socket6(socket
);
2607 cifs_reclassify_socket4(socket
);
2610 rc
= bind_socket(server
);
2615 * Eventually check for other socket options to change from
2616 * the default. sock_setsockopt not used because it expects
2619 socket
->sk
->sk_rcvtimeo
= 7 * HZ
;
2620 socket
->sk
->sk_sndtimeo
= 5 * HZ
;
2622 /* make the bufsizes depend on wsize/rsize and max requests */
2623 if (server
->noautotune
) {
2624 if (socket
->sk
->sk_sndbuf
< (200 * 1024))
2625 socket
->sk
->sk_sndbuf
= 200 * 1024;
2626 if (socket
->sk
->sk_rcvbuf
< (140 * 1024))
2627 socket
->sk
->sk_rcvbuf
= 140 * 1024;
2630 if (server
->tcp_nodelay
) {
2632 rc
= kernel_setsockopt(socket
, SOL_TCP
, TCP_NODELAY
,
2633 (char *)&val
, sizeof(val
));
2635 cFYI(1, "set TCP_NODELAY socket option error %d", rc
);
2638 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
2639 socket
->sk
->sk_sndbuf
,
2640 socket
->sk
->sk_rcvbuf
, socket
->sk
->sk_rcvtimeo
);
2642 rc
= socket
->ops
->connect(socket
, saddr
, slen
, 0);
2644 cFYI(1, "Error %d connecting to server", rc
);
2645 sock_release(socket
);
2646 server
->ssocket
= NULL
;
2650 if (sport
== htons(RFC1001_PORT
))
2651 rc
= ip_rfc1001_connect(server
);
2657 ip_connect(struct TCP_Server_Info
*server
)
2660 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)&server
->dstaddr
;
2661 struct sockaddr_in
*addr
= (struct sockaddr_in
*)&server
->dstaddr
;
2663 if (server
->dstaddr
.ss_family
== AF_INET6
)
2664 sport
= &addr6
->sin6_port
;
2666 sport
= &addr
->sin_port
;
2671 /* try with 445 port at first */
2672 *sport
= htons(CIFS_PORT
);
2674 rc
= generic_ip_connect(server
);
2678 /* if it failed, try with 139 port */
2679 *sport
= htons(RFC1001_PORT
);
2682 return generic_ip_connect(server
);
2685 void reset_cifs_unix_caps(int xid
, struct cifs_tcon
*tcon
,
2686 struct cifs_sb_info
*cifs_sb
, struct smb_vol
*vol_info
)
2688 /* if we are reconnecting then should we check to see if
2689 * any requested capabilities changed locally e.g. via
2690 * remount but we can not do much about it here
2691 * if they have (even if we could detect it by the following)
2692 * Perhaps we could add a backpointer to array of sb from tcon
2693 * or if we change to make all sb to same share the same
2694 * sb as NFS - then we only have one backpointer to sb.
2695 * What if we wanted to mount the server share twice once with
2696 * and once without posixacls or posix paths? */
2697 __u64 saved_cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
2699 if (vol_info
&& vol_info
->no_linux_ext
) {
2700 tcon
->fsUnixInfo
.Capability
= 0;
2701 tcon
->unix_ext
= 0; /* Unix Extensions disabled */
2702 cFYI(1, "Linux protocol extensions disabled");
2704 } else if (vol_info
)
2705 tcon
->unix_ext
= 1; /* Unix Extensions supported */
2707 if (tcon
->unix_ext
== 0) {
2708 cFYI(1, "Unix extensions disabled so not set on reconnect");
2712 if (!CIFSSMBQFSUnixInfo(xid
, tcon
)) {
2713 __u64 cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
2714 cFYI(1, "unix caps which server supports %lld", cap
);
2715 /* check for reconnect case in which we do not
2716 want to change the mount behavior if we can avoid it */
2717 if (vol_info
== NULL
) {
2718 /* turn off POSIX ACL and PATHNAMES if not set
2719 originally at mount time */
2720 if ((saved_cap
& CIFS_UNIX_POSIX_ACL_CAP
) == 0)
2721 cap
&= ~CIFS_UNIX_POSIX_ACL_CAP
;
2722 if ((saved_cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) == 0) {
2723 if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)
2724 cERROR(1, "POSIXPATH support change");
2725 cap
&= ~CIFS_UNIX_POSIX_PATHNAMES_CAP
;
2726 } else if ((cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) == 0) {
2727 cERROR(1, "possible reconnect error");
2728 cERROR(1, "server disabled POSIX path support");
2732 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)
2733 cERROR(1, "per-share encryption not supported yet");
2735 cap
&= CIFS_UNIX_CAP_MASK
;
2736 if (vol_info
&& vol_info
->no_psx_acl
)
2737 cap
&= ~CIFS_UNIX_POSIX_ACL_CAP
;
2738 else if (CIFS_UNIX_POSIX_ACL_CAP
& cap
) {
2739 cFYI(1, "negotiated posix acl support");
2741 cifs_sb
->mnt_cifs_flags
|=
2742 CIFS_MOUNT_POSIXACL
;
2745 if (vol_info
&& vol_info
->posix_paths
== 0)
2746 cap
&= ~CIFS_UNIX_POSIX_PATHNAMES_CAP
;
2747 else if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) {
2748 cFYI(1, "negotiate posix pathnames");
2750 cifs_sb
->mnt_cifs_flags
|=
2751 CIFS_MOUNT_POSIX_PATHS
;
2754 if (cifs_sb
&& (cifs_sb
->rsize
> 127 * 1024)) {
2755 if ((cap
& CIFS_UNIX_LARGE_READ_CAP
) == 0) {
2756 cifs_sb
->rsize
= 127 * 1024;
2757 cFYI(DBG2
, "larger reads not supported by srv");
2762 cFYI(1, "Negotiate caps 0x%x", (int)cap
);
2763 #ifdef CONFIG_CIFS_DEBUG2
2764 if (cap
& CIFS_UNIX_FCNTL_CAP
)
2765 cFYI(1, "FCNTL cap");
2766 if (cap
& CIFS_UNIX_EXTATTR_CAP
)
2767 cFYI(1, "EXTATTR cap");
2768 if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)
2769 cFYI(1, "POSIX path cap");
2770 if (cap
& CIFS_UNIX_XATTR_CAP
)
2771 cFYI(1, "XATTR cap");
2772 if (cap
& CIFS_UNIX_POSIX_ACL_CAP
)
2773 cFYI(1, "POSIX ACL cap");
2774 if (cap
& CIFS_UNIX_LARGE_READ_CAP
)
2775 cFYI(1, "very large read cap");
2776 if (cap
& CIFS_UNIX_LARGE_WRITE_CAP
)
2777 cFYI(1, "very large write cap");
2778 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP
)
2779 cFYI(1, "transport encryption cap");
2780 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)
2781 cFYI(1, "mandatory transport encryption cap");
2782 #endif /* CIFS_DEBUG2 */
2783 if (CIFSSMBSetFSUnixInfo(xid
, tcon
, cap
)) {
2784 if (vol_info
== NULL
) {
2785 cFYI(1, "resetting capabilities failed");
2787 cERROR(1, "Negotiating Unix capabilities "
2788 "with the server failed. Consider "
2789 "mounting with the Unix Extensions\n"
2790 "disabled, if problems are found, "
2791 "by specifying the nounix mount "
2798 void cifs_setup_cifs_sb(struct smb_vol
*pvolume_info
,
2799 struct cifs_sb_info
*cifs_sb
)
2801 INIT_DELAYED_WORK(&cifs_sb
->prune_tlinks
, cifs_prune_tlinks
);
2803 spin_lock_init(&cifs_sb
->tlink_tree_lock
);
2804 cifs_sb
->tlink_tree
= RB_ROOT
;
2806 if (pvolume_info
->rsize
> CIFSMaxBufSize
) {
2807 cERROR(1, "rsize %d too large, using MaxBufSize",
2808 pvolume_info
->rsize
);
2809 cifs_sb
->rsize
= CIFSMaxBufSize
;
2810 } else if ((pvolume_info
->rsize
) &&
2811 (pvolume_info
->rsize
<= CIFSMaxBufSize
))
2812 cifs_sb
->rsize
= pvolume_info
->rsize
;
2814 cifs_sb
->rsize
= CIFSMaxBufSize
;
2816 if (cifs_sb
->rsize
< 2048) {
2817 cifs_sb
->rsize
= 2048;
2818 /* Windows ME may prefer this */
2819 cFYI(1, "readsize set to minimum: 2048");
2823 * Temporarily set wsize for matching superblock. If we end up using
2824 * new sb then cifs_negotiate_wsize will later negotiate it downward
2827 cifs_sb
->wsize
= pvolume_info
->wsize
;
2829 cifs_sb
->mnt_uid
= pvolume_info
->linux_uid
;
2830 cifs_sb
->mnt_gid
= pvolume_info
->linux_gid
;
2831 if (pvolume_info
->backupuid_specified
)
2832 cifs_sb
->mnt_backupuid
= pvolume_info
->backupuid
;
2833 if (pvolume_info
->backupgid_specified
)
2834 cifs_sb
->mnt_backupgid
= pvolume_info
->backupgid
;
2835 cifs_sb
->mnt_file_mode
= pvolume_info
->file_mode
;
2836 cifs_sb
->mnt_dir_mode
= pvolume_info
->dir_mode
;
2837 cFYI(1, "file mode: 0x%x dir mode: 0x%x",
2838 cifs_sb
->mnt_file_mode
, cifs_sb
->mnt_dir_mode
);
2840 cifs_sb
->actimeo
= pvolume_info
->actimeo
;
2841 cifs_sb
->local_nls
= pvolume_info
->local_nls
;
2843 if (pvolume_info
->noperm
)
2844 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_PERM
;
2845 if (pvolume_info
->setuids
)
2846 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_SET_UID
;
2847 if (pvolume_info
->server_ino
)
2848 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_SERVER_INUM
;
2849 if (pvolume_info
->remap
)
2850 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MAP_SPECIAL_CHR
;
2851 if (pvolume_info
->no_xattr
)
2852 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_XATTR
;
2853 if (pvolume_info
->sfu_emul
)
2854 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_UNX_EMUL
;
2855 if (pvolume_info
->nobrl
)
2856 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_BRL
;
2857 if (pvolume_info
->nostrictsync
)
2858 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NOSSYNC
;
2859 if (pvolume_info
->mand_lock
)
2860 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NOPOSIXBRL
;
2861 if (pvolume_info
->rwpidforward
)
2862 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_RWPIDFORWARD
;
2863 if (pvolume_info
->cifs_acl
)
2864 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_ACL
;
2865 if (pvolume_info
->backupuid_specified
)
2866 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_BACKUPUID
;
2867 if (pvolume_info
->backupgid_specified
)
2868 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_BACKUPGID
;
2869 if (pvolume_info
->override_uid
)
2870 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_OVERR_UID
;
2871 if (pvolume_info
->override_gid
)
2872 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_OVERR_GID
;
2873 if (pvolume_info
->dynperm
)
2874 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_DYNPERM
;
2875 if (pvolume_info
->fsc
)
2876 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_FSCACHE
;
2877 if (pvolume_info
->multiuser
)
2878 cifs_sb
->mnt_cifs_flags
|= (CIFS_MOUNT_MULTIUSER
|
2879 CIFS_MOUNT_NO_PERM
);
2880 if (pvolume_info
->strict_io
)
2881 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_STRICT_IO
;
2882 if (pvolume_info
->direct_io
) {
2883 cFYI(1, "mounting share using direct i/o");
2884 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_DIRECT_IO
;
2886 if (pvolume_info
->mfsymlinks
) {
2887 if (pvolume_info
->sfu_emul
) {
2888 cERROR(1, "mount option mfsymlinks ignored if sfu "
2889 "mount option is used");
2891 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MF_SYMLINKS
;
2895 if ((pvolume_info
->cifs_acl
) && (pvolume_info
->dynperm
))
2896 cERROR(1, "mount option dynperm ignored if cifsacl "
2897 "mount option supported");
2901 * When the server supports very large writes via POSIX extensions, we can
2902 * allow up to 2^24-1, minus the size of a WRITE_AND_X header, not including
2903 * the RFC1001 length.
2905 * Note that this might make for "interesting" allocation problems during
2906 * writeback however as we have to allocate an array of pointers for the
2907 * pages. A 16M write means ~32kb page array with PAGE_CACHE_SIZE == 4096.
2909 #define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
2912 * When the server doesn't allow large posix writes, only allow a wsize of
2913 * 2^17-1 minus the size of the WRITE_AND_X header. That allows for a write up
2914 * to the maximum size described by RFC1002.
2916 #define CIFS_MAX_RFC1002_WSIZE ((1<<17) - 1 - sizeof(WRITE_REQ) + 4)
2919 * The default wsize is 1M. find_get_pages seems to return a maximum of 256
2920 * pages in a single call. With PAGE_CACHE_SIZE == 4k, this means we can fill
2921 * a single wsize request with a single call.
2923 #define CIFS_DEFAULT_WSIZE (1024 * 1024)
2926 cifs_negotiate_wsize(struct cifs_tcon
*tcon
, struct smb_vol
*pvolume_info
)
2928 __u64 unix_cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
2929 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
2930 unsigned int wsize
= pvolume_info
->wsize
? pvolume_info
->wsize
:
2933 /* can server support 24-bit write sizes? (via UNIX extensions) */
2934 if (!tcon
->unix_ext
|| !(unix_cap
& CIFS_UNIX_LARGE_WRITE_CAP
))
2935 wsize
= min_t(unsigned int, wsize
, CIFS_MAX_RFC1002_WSIZE
);
2938 * no CAP_LARGE_WRITE_X or is signing enabled without CAP_UNIX set?
2939 * Limit it to max buffer offered by the server, minus the size of the
2940 * WRITEX header, not including the 4 byte RFC1001 length.
2942 if (!(server
->capabilities
& CAP_LARGE_WRITE_X
) ||
2943 (!(server
->capabilities
& CAP_UNIX
) &&
2944 (server
->sec_mode
& (SECMODE_SIGN_ENABLED
|SECMODE_SIGN_REQUIRED
))))
2945 wsize
= min_t(unsigned int, wsize
,
2946 server
->maxBuf
- sizeof(WRITE_REQ
) + 4);
2948 /* hard limit of CIFS_MAX_WSIZE */
2949 wsize
= min_t(unsigned int, wsize
, CIFS_MAX_WSIZE
);
2955 is_path_accessible(int xid
, struct cifs_tcon
*tcon
,
2956 struct cifs_sb_info
*cifs_sb
, const char *full_path
)
2959 FILE_ALL_INFO
*pfile_info
;
2961 pfile_info
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
2962 if (pfile_info
== NULL
)
2965 rc
= CIFSSMBQPathInfo(xid
, tcon
, full_path
, pfile_info
,
2966 0 /* not legacy */, cifs_sb
->local_nls
,
2967 cifs_sb
->mnt_cifs_flags
&
2968 CIFS_MOUNT_MAP_SPECIAL_CHR
);
2970 if (rc
== -EOPNOTSUPP
|| rc
== -EINVAL
)
2971 rc
= SMBQueryInformation(xid
, tcon
, full_path
, pfile_info
,
2972 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
2973 CIFS_MOUNT_MAP_SPECIAL_CHR
);
2979 cleanup_volume_info_contents(struct smb_vol
*volume_info
)
2981 kfree(volume_info
->username
);
2982 kzfree(volume_info
->password
);
2983 kfree(volume_info
->UNC
);
2984 if (volume_info
->UNCip
!= volume_info
->UNC
+ 2)
2985 kfree(volume_info
->UNCip
);
2986 kfree(volume_info
->domainname
);
2987 kfree(volume_info
->iocharset
);
2988 kfree(volume_info
->prepath
);
2992 cifs_cleanup_volume_info(struct smb_vol
*volume_info
)
2996 cleanup_volume_info_contents(volume_info
);
3001 #ifdef CONFIG_CIFS_DFS_UPCALL
3002 /* build_path_to_root returns full path to root when
3003 * we do not have an exiting connection (tcon) */
3005 build_unc_path_to_root(const struct smb_vol
*vol
,
3006 const struct cifs_sb_info
*cifs_sb
)
3008 char *full_path
, *pos
;
3009 unsigned int pplen
= vol
->prepath
? strlen(vol
->prepath
) : 0;
3010 unsigned int unc_len
= strnlen(vol
->UNC
, MAX_TREE_SIZE
+ 1);
3012 full_path
= kmalloc(unc_len
+ pplen
+ 1, GFP_KERNEL
);
3013 if (full_path
== NULL
)
3014 return ERR_PTR(-ENOMEM
);
3016 strncpy(full_path
, vol
->UNC
, unc_len
);
3017 pos
= full_path
+ unc_len
;
3020 strncpy(pos
, vol
->prepath
, pplen
);
3024 *pos
= '\0'; /* add trailing null */
3025 convert_delimiter(full_path
, CIFS_DIR_SEP(cifs_sb
));
3026 cFYI(1, "%s: full_path=%s", __func__
, full_path
);
3031 * Perform a dfs referral query for a share and (optionally) prefix
3033 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3034 * to a string containing updated options for the submount. Otherwise it
3035 * will be left untouched.
3037 * Returns the rc from get_dfs_path to the caller, which can be used to
3038 * determine whether there were referrals.
3041 expand_dfs_referral(int xid
, struct cifs_ses
*pSesInfo
,
3042 struct smb_vol
*volume_info
, struct cifs_sb_info
*cifs_sb
,
3046 unsigned int num_referrals
= 0;
3047 struct dfs_info3_param
*referrals
= NULL
;
3048 char *full_path
= NULL
, *ref_path
= NULL
, *mdata
= NULL
;
3050 full_path
= build_unc_path_to_root(volume_info
, cifs_sb
);
3051 if (IS_ERR(full_path
))
3052 return PTR_ERR(full_path
);
3054 /* For DFS paths, skip the first '\' of the UNC */
3055 ref_path
= check_prefix
? full_path
+ 1 : volume_info
->UNC
+ 1;
3057 rc
= get_dfs_path(xid
, pSesInfo
, ref_path
, cifs_sb
->local_nls
,
3058 &num_referrals
, &referrals
,
3059 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
3061 if (!rc
&& num_referrals
> 0) {
3062 char *fake_devname
= NULL
;
3064 mdata
= cifs_compose_mount_options(cifs_sb
->mountdata
,
3065 full_path
+ 1, referrals
,
3068 free_dfs_info_array(referrals
, num_referrals
);
3070 if (IS_ERR(mdata
)) {
3071 rc
= PTR_ERR(mdata
);
3074 cleanup_volume_info_contents(volume_info
);
3075 memset(volume_info
, '\0', sizeof(*volume_info
));
3076 rc
= cifs_setup_volume_info(volume_info
, mdata
,
3079 kfree(fake_devname
);
3080 kfree(cifs_sb
->mountdata
);
3081 cifs_sb
->mountdata
= mdata
;
3089 cifs_setup_volume_info(struct smb_vol
*volume_info
, char *mount_data
,
3090 const char *devname
)
3094 if (cifs_parse_mount_options(mount_data
, devname
, volume_info
))
3097 if (volume_info
->nullauth
) {
3098 cFYI(1, "null user");
3099 volume_info
->username
= kzalloc(1, GFP_KERNEL
);
3100 if (volume_info
->username
== NULL
)
3102 } else if (volume_info
->username
) {
3103 /* BB fixme parse for domain name here */
3104 cFYI(1, "Username: %s", volume_info
->username
);
3106 cifserror("No username specified");
3107 /* In userspace mount helper we can get user name from alternate
3108 locations such as env variables and files on disk */
3112 /* this is needed for ASCII cp to Unicode converts */
3113 if (volume_info
->iocharset
== NULL
) {
3114 /* load_nls_default cannot return null */
3115 volume_info
->local_nls
= load_nls_default();
3117 volume_info
->local_nls
= load_nls(volume_info
->iocharset
);
3118 if (volume_info
->local_nls
== NULL
) {
3119 cERROR(1, "CIFS mount error: iocharset %s not found",
3120 volume_info
->iocharset
);
3129 cifs_get_volume_info(char *mount_data
, const char *devname
)
3132 struct smb_vol
*volume_info
;
3134 volume_info
= kzalloc(sizeof(struct smb_vol
), GFP_KERNEL
);
3136 return ERR_PTR(-ENOMEM
);
3138 rc
= cifs_setup_volume_info(volume_info
, mount_data
, devname
);
3140 cifs_cleanup_volume_info(volume_info
);
3141 volume_info
= ERR_PTR(rc
);
3148 cifs_mount(struct cifs_sb_info
*cifs_sb
, struct smb_vol
*volume_info
)
3152 struct cifs_ses
*pSesInfo
;
3153 struct cifs_tcon
*tcon
;
3154 struct TCP_Server_Info
*srvTcp
;
3156 struct tcon_link
*tlink
;
3157 #ifdef CONFIG_CIFS_DFS_UPCALL
3158 int referral_walks_count
= 0;
3161 rc
= bdi_setup_and_register(&cifs_sb
->bdi
, "cifs", BDI_CAP_MAP_COPY
);
3165 cifs_sb
->bdi
.ra_pages
= default_backing_dev_info
.ra_pages
;
3167 #ifdef CONFIG_CIFS_DFS_UPCALL
3169 /* cleanup activities if we're chasing a referral */
3170 if (referral_walks_count
) {
3172 cifs_put_tcon(tcon
);
3174 cifs_put_smb_ses(pSesInfo
);
3187 /* get a reference to a tcp session */
3188 srvTcp
= cifs_get_tcp_session(volume_info
);
3189 if (IS_ERR(srvTcp
)) {
3190 rc
= PTR_ERR(srvTcp
);
3191 bdi_destroy(&cifs_sb
->bdi
);
3195 /* get a reference to a SMB session */
3196 pSesInfo
= cifs_get_smb_ses(srvTcp
, volume_info
);
3197 if (IS_ERR(pSesInfo
)) {
3198 rc
= PTR_ERR(pSesInfo
);
3200 goto mount_fail_check
;
3203 /* search for existing tcon to this server share */
3204 tcon
= cifs_get_tcon(pSesInfo
, volume_info
);
3208 goto remote_path_check
;
3211 /* tell server which Unix caps we support */
3212 if (tcon
->ses
->capabilities
& CAP_UNIX
) {
3213 /* reset of caps checks mount to see if unix extensions
3214 disabled for just this mount */
3215 reset_cifs_unix_caps(xid
, tcon
, cifs_sb
, volume_info
);
3216 if ((tcon
->ses
->server
->tcpStatus
== CifsNeedReconnect
) &&
3217 (le64_to_cpu(tcon
->fsUnixInfo
.Capability
) &
3218 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)) {
3220 goto mount_fail_check
;
3223 tcon
->unix_ext
= 0; /* server does not support them */
3225 /* do not care if following two calls succeed - informational */
3227 CIFSSMBQFSDeviceInfo(xid
, tcon
);
3228 CIFSSMBQFSAttributeInfo(xid
, tcon
);
3231 if ((tcon
->unix_ext
== 0) && (cifs_sb
->rsize
> (1024 * 127))) {
3232 cifs_sb
->rsize
= 1024 * 127;
3233 cFYI(DBG2
, "no very large read support, rsize now 127K");
3235 if (!(tcon
->ses
->capabilities
& CAP_LARGE_READ_X
))
3236 cifs_sb
->rsize
= min(cifs_sb
->rsize
, CIFSMaxBufSize
);
3238 cifs_sb
->wsize
= cifs_negotiate_wsize(tcon
, volume_info
);
3241 #ifdef CONFIG_CIFS_DFS_UPCALL
3243 * Perform an unconditional check for whether there are DFS
3244 * referrals for this path without prefix, to provide support
3245 * for DFS referrals from w2k8 servers which don't seem to respond
3246 * with PATH_NOT_COVERED to requests that include the prefix.
3247 * Chase the referral if found, otherwise continue normally.
3249 if (referral_walks_count
== 0) {
3250 int refrc
= expand_dfs_referral(xid
, pSesInfo
, volume_info
,
3253 referral_walks_count
++;
3254 goto try_mount_again
;
3259 /* check if a whole path is not remote */
3261 /* build_path_to_root works only when we have a valid tcon */
3262 full_path
= cifs_build_path_to_root(volume_info
, cifs_sb
, tcon
);
3263 if (full_path
== NULL
) {
3265 goto mount_fail_check
;
3267 rc
= is_path_accessible(xid
, tcon
, cifs_sb
, full_path
);
3268 if (rc
!= 0 && rc
!= -EREMOTE
) {
3270 goto mount_fail_check
;
3275 /* get referral if needed */
3276 if (rc
== -EREMOTE
) {
3277 #ifdef CONFIG_CIFS_DFS_UPCALL
3278 if (referral_walks_count
> MAX_NESTED_LINKS
) {
3280 * BB: when we implement proper loop detection,
3281 * we will remove this check. But now we need it
3282 * to prevent an indefinite loop if 'DFS tree' is
3283 * misconfigured (i.e. has loops).
3286 goto mount_fail_check
;
3289 rc
= expand_dfs_referral(xid
, pSesInfo
, volume_info
, cifs_sb
,
3293 referral_walks_count
++;
3294 goto try_mount_again
;
3296 goto mount_fail_check
;
3297 #else /* No DFS support, return error on mount */
3303 goto mount_fail_check
;
3305 /* now, hang the tcon off of the superblock */
3306 tlink
= kzalloc(sizeof *tlink
, GFP_KERNEL
);
3307 if (tlink
== NULL
) {
3309 goto mount_fail_check
;
3312 tlink
->tl_uid
= pSesInfo
->linux_uid
;
3313 tlink
->tl_tcon
= tcon
;
3314 tlink
->tl_time
= jiffies
;
3315 set_bit(TCON_LINK_MASTER
, &tlink
->tl_flags
);
3316 set_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
3318 cifs_sb
->master_tlink
= tlink
;
3319 spin_lock(&cifs_sb
->tlink_tree_lock
);
3320 tlink_rb_insert(&cifs_sb
->tlink_tree
, tlink
);
3321 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3323 queue_delayed_work(system_nrt_wq
, &cifs_sb
->prune_tlinks
,
3327 /* on error free sesinfo and tcon struct if needed */
3329 /* If find_unc succeeded then rc == 0 so we can not end */
3330 /* up accidentally freeing someone elses tcon struct */
3332 cifs_put_tcon(tcon
);
3334 cifs_put_smb_ses(pSesInfo
);
3336 cifs_put_tcp_session(srvTcp
);
3337 bdi_destroy(&cifs_sb
->bdi
);
3346 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3347 * pointer may be NULL.
3350 CIFSTCon(unsigned int xid
, struct cifs_ses
*ses
,
3351 const char *tree
, struct cifs_tcon
*tcon
,
3352 const struct nls_table
*nls_codepage
)
3354 struct smb_hdr
*smb_buffer
;
3355 struct smb_hdr
*smb_buffer_response
;
3358 unsigned char *bcc_ptr
;
3361 __u16 bytes_left
, count
;
3366 smb_buffer
= cifs_buf_get();
3367 if (smb_buffer
== NULL
)
3370 smb_buffer_response
= smb_buffer
;
3372 header_assemble(smb_buffer
, SMB_COM_TREE_CONNECT_ANDX
,
3373 NULL
/*no tid */ , 4 /*wct */ );
3375 smb_buffer
->Mid
= GetNextMid(ses
->server
);
3376 smb_buffer
->Uid
= ses
->Suid
;
3377 pSMB
= (TCONX_REQ
*) smb_buffer
;
3378 pSMBr
= (TCONX_RSP
*) smb_buffer_response
;
3380 pSMB
->AndXCommand
= 0xFF;
3381 pSMB
->Flags
= cpu_to_le16(TCON_EXTENDED_SECINFO
);
3382 bcc_ptr
= &pSMB
->Password
[0];
3383 if (!tcon
|| (ses
->server
->sec_mode
& SECMODE_USER
)) {
3384 pSMB
->PasswordLength
= cpu_to_le16(1); /* minimum */
3385 *bcc_ptr
= 0; /* password is null byte */
3386 bcc_ptr
++; /* skip password */
3387 /* already aligned so no need to do it below */
3389 pSMB
->PasswordLength
= cpu_to_le16(CIFS_AUTH_RESP_SIZE
);
3390 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3391 specified as required (when that support is added to
3392 the vfs in the future) as only NTLM or the much
3393 weaker LANMAN (which we do not send by default) is accepted
3394 by Samba (not sure whether other servers allow
3395 NTLMv2 password here) */
3396 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3397 if ((global_secflags
& CIFSSEC_MAY_LANMAN
) &&
3398 (ses
->server
->secType
== LANMAN
))
3399 calc_lanman_hash(tcon
->password
, ses
->server
->cryptkey
,
3400 ses
->server
->sec_mode
&
3401 SECMODE_PW_ENCRYPT
? true : false,
3404 #endif /* CIFS_WEAK_PW_HASH */
3405 rc
= SMBNTencrypt(tcon
->password
, ses
->server
->cryptkey
,
3408 bcc_ptr
+= CIFS_AUTH_RESP_SIZE
;
3409 if (ses
->capabilities
& CAP_UNICODE
) {
3410 /* must align unicode strings */
3411 *bcc_ptr
= 0; /* null byte password */
3416 if (ses
->server
->sec_mode
&
3417 (SECMODE_SIGN_REQUIRED
| SECMODE_SIGN_ENABLED
))
3418 smb_buffer
->Flags2
|= SMBFLG2_SECURITY_SIGNATURE
;
3420 if (ses
->capabilities
& CAP_STATUS32
) {
3421 smb_buffer
->Flags2
|= SMBFLG2_ERR_STATUS
;
3423 if (ses
->capabilities
& CAP_DFS
) {
3424 smb_buffer
->Flags2
|= SMBFLG2_DFS
;
3426 if (ses
->capabilities
& CAP_UNICODE
) {
3427 smb_buffer
->Flags2
|= SMBFLG2_UNICODE
;
3429 cifs_strtoUCS((__le16
*) bcc_ptr
, tree
,
3430 6 /* max utf8 char length in bytes */ *
3431 (/* server len*/ + 256 /* share len */), nls_codepage
);
3432 bcc_ptr
+= 2 * length
; /* convert num 16 bit words to bytes */
3433 bcc_ptr
+= 2; /* skip trailing null */
3434 } else { /* ASCII */
3435 strcpy(bcc_ptr
, tree
);
3436 bcc_ptr
+= strlen(tree
) + 1;
3438 strcpy(bcc_ptr
, "?????");
3439 bcc_ptr
+= strlen("?????");
3441 count
= bcc_ptr
- &pSMB
->Password
[0];
3442 pSMB
->hdr
.smb_buf_length
= cpu_to_be32(be32_to_cpu(
3443 pSMB
->hdr
.smb_buf_length
) + count
);
3444 pSMB
->ByteCount
= cpu_to_le16(count
);
3446 rc
= SendReceive(xid
, ses
, smb_buffer
, smb_buffer_response
, &length
,
3449 /* above now done in SendReceive */
3450 if ((rc
== 0) && (tcon
!= NULL
)) {
3453 tcon
->tidStatus
= CifsGood
;
3454 tcon
->need_reconnect
= false;
3455 tcon
->tid
= smb_buffer_response
->Tid
;
3456 bcc_ptr
= pByteArea(smb_buffer_response
);
3457 bytes_left
= get_bcc(smb_buffer_response
);
3458 length
= strnlen(bcc_ptr
, bytes_left
- 2);
3459 if (smb_buffer
->Flags2
& SMBFLG2_UNICODE
)
3465 /* skip service field (NB: this field is always ASCII) */
3467 if ((bcc_ptr
[0] == 'I') && (bcc_ptr
[1] == 'P') &&
3468 (bcc_ptr
[2] == 'C')) {
3469 cFYI(1, "IPC connection");
3472 } else if (length
== 2) {
3473 if ((bcc_ptr
[0] == 'A') && (bcc_ptr
[1] == ':')) {
3474 /* the most common case */
3475 cFYI(1, "disk share connection");
3478 bcc_ptr
+= length
+ 1;
3479 bytes_left
-= (length
+ 1);
3480 strncpy(tcon
->treeName
, tree
, MAX_TREE_SIZE
);
3482 /* mostly informational -- no need to fail on error here */
3483 kfree(tcon
->nativeFileSystem
);
3484 tcon
->nativeFileSystem
= cifs_strndup_from_ucs(bcc_ptr
,
3485 bytes_left
, is_unicode
,
3488 cFYI(1, "nativeFileSystem=%s", tcon
->nativeFileSystem
);
3490 if ((smb_buffer_response
->WordCount
== 3) ||
3491 (smb_buffer_response
->WordCount
== 7))
3492 /* field is in same location */
3493 tcon
->Flags
= le16_to_cpu(pSMBr
->OptionalSupport
);
3496 cFYI(1, "Tcon flags: 0x%x ", tcon
->Flags
);
3497 } else if ((rc
== 0) && tcon
== NULL
) {
3498 /* all we need to save for IPC$ connection */
3499 ses
->ipc_tid
= smb_buffer_response
->Tid
;
3502 cifs_buf_release(smb_buffer
);
3507 cifs_umount(struct cifs_sb_info
*cifs_sb
)
3509 struct rb_root
*root
= &cifs_sb
->tlink_tree
;
3510 struct rb_node
*node
;
3511 struct tcon_link
*tlink
;
3513 cancel_delayed_work_sync(&cifs_sb
->prune_tlinks
);
3515 spin_lock(&cifs_sb
->tlink_tree_lock
);
3516 while ((node
= rb_first(root
))) {
3517 tlink
= rb_entry(node
, struct tcon_link
, tl_rbnode
);
3518 cifs_get_tlink(tlink
);
3519 clear_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
3520 rb_erase(node
, root
);
3522 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3523 cifs_put_tlink(tlink
);
3524 spin_lock(&cifs_sb
->tlink_tree_lock
);
3526 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3528 bdi_destroy(&cifs_sb
->bdi
);
3529 kfree(cifs_sb
->mountdata
);
3530 unload_nls(cifs_sb
->local_nls
);
3534 int cifs_negotiate_protocol(unsigned int xid
, struct cifs_ses
*ses
)
3537 struct TCP_Server_Info
*server
= ses
->server
;
3539 /* only send once per connect */
3540 if (server
->maxBuf
!= 0)
3543 rc
= CIFSSMBNegotiate(xid
, ses
);
3544 if (rc
== -EAGAIN
) {
3545 /* retry only once on 1st time connection */
3546 rc
= CIFSSMBNegotiate(xid
, ses
);
3551 spin_lock(&GlobalMid_Lock
);
3552 if (server
->tcpStatus
== CifsNeedNegotiate
)
3553 server
->tcpStatus
= CifsGood
;
3556 spin_unlock(&GlobalMid_Lock
);
3564 int cifs_setup_session(unsigned int xid
, struct cifs_ses
*ses
,
3565 struct nls_table
*nls_info
)
3568 struct TCP_Server_Info
*server
= ses
->server
;
3571 ses
->capabilities
= server
->capabilities
;
3572 if (linuxExtEnabled
== 0)
3573 ses
->capabilities
&= (~CAP_UNIX
);
3575 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3576 server
->sec_mode
, server
->capabilities
, server
->timeAdj
);
3578 rc
= CIFS_SessSetup(xid
, ses
, nls_info
);
3580 cERROR(1, "Send error in SessSetup = %d", rc
);
3582 mutex_lock(&ses
->server
->srv_mutex
);
3583 if (!server
->session_estab
) {
3584 server
->session_key
.response
= ses
->auth_key
.response
;
3585 server
->session_key
.len
= ses
->auth_key
.len
;
3586 server
->sequence_number
= 0x2;
3587 server
->session_estab
= true;
3588 ses
->auth_key
.response
= NULL
;
3590 mutex_unlock(&server
->srv_mutex
);
3592 cFYI(1, "CIFS Session Established successfully");
3593 spin_lock(&GlobalMid_Lock
);
3594 ses
->status
= CifsGood
;
3595 ses
->need_reconnect
= false;
3596 spin_unlock(&GlobalMid_Lock
);
3599 kfree(ses
->auth_key
.response
);
3600 ses
->auth_key
.response
= NULL
;
3601 ses
->auth_key
.len
= 0;
3602 kfree(ses
->ntlmssp
);
3603 ses
->ntlmssp
= NULL
;
3608 static struct cifs_tcon
*
3609 cifs_construct_tcon(struct cifs_sb_info
*cifs_sb
, uid_t fsuid
)
3611 struct cifs_tcon
*master_tcon
= cifs_sb_master_tcon(cifs_sb
);
3612 struct cifs_ses
*ses
;
3613 struct cifs_tcon
*tcon
= NULL
;
3614 struct smb_vol
*vol_info
;
3615 char username
[28]; /* big enough for "krb50x" + hex of ULONG_MAX 6+16 */
3616 /* We used to have this as MAX_USERNAME which is */
3617 /* way too big now (256 instead of 32) */
3619 vol_info
= kzalloc(sizeof(*vol_info
), GFP_KERNEL
);
3620 if (vol_info
== NULL
) {
3621 tcon
= ERR_PTR(-ENOMEM
);
3625 snprintf(username
, sizeof(username
), "krb50x%x", fsuid
);
3626 vol_info
->username
= username
;
3627 vol_info
->local_nls
= cifs_sb
->local_nls
;
3628 vol_info
->linux_uid
= fsuid
;
3629 vol_info
->cred_uid
= fsuid
;
3630 vol_info
->UNC
= master_tcon
->treeName
;
3631 vol_info
->retry
= master_tcon
->retry
;
3632 vol_info
->nocase
= master_tcon
->nocase
;
3633 vol_info
->local_lease
= master_tcon
->local_lease
;
3634 vol_info
->no_linux_ext
= !master_tcon
->unix_ext
;
3636 /* FIXME: allow for other secFlg settings */
3637 vol_info
->secFlg
= CIFSSEC_MUST_KRB5
;
3639 /* get a reference for the same TCP session */
3640 spin_lock(&cifs_tcp_ses_lock
);
3641 ++master_tcon
->ses
->server
->srv_count
;
3642 spin_unlock(&cifs_tcp_ses_lock
);
3644 ses
= cifs_get_smb_ses(master_tcon
->ses
->server
, vol_info
);
3646 tcon
= (struct cifs_tcon
*)ses
;
3647 cifs_put_tcp_session(master_tcon
->ses
->server
);
3651 tcon
= cifs_get_tcon(ses
, vol_info
);
3653 cifs_put_smb_ses(ses
);
3657 if (ses
->capabilities
& CAP_UNIX
)
3658 reset_cifs_unix_caps(0, tcon
, NULL
, vol_info
);
3666 cifs_sb_master_tcon(struct cifs_sb_info
*cifs_sb
)
3668 return tlink_tcon(cifs_sb_master_tlink(cifs_sb
));
3672 cifs_sb_tcon_pending_wait(void *unused
)
3675 return signal_pending(current
) ? -ERESTARTSYS
: 0;
3678 /* find and return a tlink with given uid */
3679 static struct tcon_link
*
3680 tlink_rb_search(struct rb_root
*root
, uid_t uid
)
3682 struct rb_node
*node
= root
->rb_node
;
3683 struct tcon_link
*tlink
;
3686 tlink
= rb_entry(node
, struct tcon_link
, tl_rbnode
);
3688 if (tlink
->tl_uid
> uid
)
3689 node
= node
->rb_left
;
3690 else if (tlink
->tl_uid
< uid
)
3691 node
= node
->rb_right
;
3698 /* insert a tcon_link into the tree */
3700 tlink_rb_insert(struct rb_root
*root
, struct tcon_link
*new_tlink
)
3702 struct rb_node
**new = &(root
->rb_node
), *parent
= NULL
;
3703 struct tcon_link
*tlink
;
3706 tlink
= rb_entry(*new, struct tcon_link
, tl_rbnode
);
3709 if (tlink
->tl_uid
> new_tlink
->tl_uid
)
3710 new = &((*new)->rb_left
);
3712 new = &((*new)->rb_right
);
3715 rb_link_node(&new_tlink
->tl_rbnode
, parent
, new);
3716 rb_insert_color(&new_tlink
->tl_rbnode
, root
);
3720 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3723 * If the superblock doesn't refer to a multiuser mount, then just return
3724 * the master tcon for the mount.
3726 * First, search the rbtree for an existing tcon for this fsuid. If one
3727 * exists, then check to see if it's pending construction. If it is then wait
3728 * for construction to complete. Once it's no longer pending, check to see if
3729 * it failed and either return an error or retry construction, depending on
3732 * If one doesn't exist then insert a new tcon_link struct into the tree and
3733 * try to construct a new one.
3736 cifs_sb_tlink(struct cifs_sb_info
*cifs_sb
)
3739 uid_t fsuid
= current_fsuid();
3740 struct tcon_link
*tlink
, *newtlink
;
3742 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
))
3743 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb
));
3745 spin_lock(&cifs_sb
->tlink_tree_lock
);
3746 tlink
= tlink_rb_search(&cifs_sb
->tlink_tree
, fsuid
);
3748 cifs_get_tlink(tlink
);
3749 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3751 if (tlink
== NULL
) {
3752 newtlink
= kzalloc(sizeof(*tlink
), GFP_KERNEL
);
3753 if (newtlink
== NULL
)
3754 return ERR_PTR(-ENOMEM
);
3755 newtlink
->tl_uid
= fsuid
;
3756 newtlink
->tl_tcon
= ERR_PTR(-EACCES
);
3757 set_bit(TCON_LINK_PENDING
, &newtlink
->tl_flags
);
3758 set_bit(TCON_LINK_IN_TREE
, &newtlink
->tl_flags
);
3759 cifs_get_tlink(newtlink
);
3761 spin_lock(&cifs_sb
->tlink_tree_lock
);
3762 /* was one inserted after previous search? */
3763 tlink
= tlink_rb_search(&cifs_sb
->tlink_tree
, fsuid
);
3765 cifs_get_tlink(tlink
);
3766 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3768 goto wait_for_construction
;
3771 tlink_rb_insert(&cifs_sb
->tlink_tree
, tlink
);
3772 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3774 wait_for_construction
:
3775 ret
= wait_on_bit(&tlink
->tl_flags
, TCON_LINK_PENDING
,
3776 cifs_sb_tcon_pending_wait
,
3777 TASK_INTERRUPTIBLE
);
3779 cifs_put_tlink(tlink
);
3780 return ERR_PTR(ret
);
3783 /* if it's good, return it */
3784 if (!IS_ERR(tlink
->tl_tcon
))
3787 /* return error if we tried this already recently */
3788 if (time_before(jiffies
, tlink
->tl_time
+ TLINK_ERROR_EXPIRE
)) {
3789 cifs_put_tlink(tlink
);
3790 return ERR_PTR(-EACCES
);
3793 if (test_and_set_bit(TCON_LINK_PENDING
, &tlink
->tl_flags
))
3794 goto wait_for_construction
;
3797 tlink
->tl_tcon
= cifs_construct_tcon(cifs_sb
, fsuid
);
3798 clear_bit(TCON_LINK_PENDING
, &tlink
->tl_flags
);
3799 wake_up_bit(&tlink
->tl_flags
, TCON_LINK_PENDING
);
3801 if (IS_ERR(tlink
->tl_tcon
)) {
3802 cifs_put_tlink(tlink
);
3803 return ERR_PTR(-EACCES
);
3810 * periodic workqueue job that scans tcon_tree for a superblock and closes
3814 cifs_prune_tlinks(struct work_struct
*work
)
3816 struct cifs_sb_info
*cifs_sb
= container_of(work
, struct cifs_sb_info
,
3818 struct rb_root
*root
= &cifs_sb
->tlink_tree
;
3819 struct rb_node
*node
= rb_first(root
);
3820 struct rb_node
*tmp
;
3821 struct tcon_link
*tlink
;
3824 * Because we drop the spinlock in the loop in order to put the tlink
3825 * it's not guarded against removal of links from the tree. The only
3826 * places that remove entries from the tree are this function and
3827 * umounts. Because this function is non-reentrant and is canceled
3828 * before umount can proceed, this is safe.
3830 spin_lock(&cifs_sb
->tlink_tree_lock
);
3831 node
= rb_first(root
);
3832 while (node
!= NULL
) {
3834 node
= rb_next(tmp
);
3835 tlink
= rb_entry(tmp
, struct tcon_link
, tl_rbnode
);
3837 if (test_bit(TCON_LINK_MASTER
, &tlink
->tl_flags
) ||
3838 atomic_read(&tlink
->tl_count
) != 0 ||
3839 time_after(tlink
->tl_time
+ TLINK_IDLE_EXPIRE
, jiffies
))
3842 cifs_get_tlink(tlink
);
3843 clear_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
3844 rb_erase(tmp
, root
);
3846 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3847 cifs_put_tlink(tlink
);
3848 spin_lock(&cifs_sb
->tlink_tree_lock
);
3850 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3852 queue_delayed_work(system_nrt_wq
, &cifs_sb
->prune_tlinks
,