4 * Copyright (C) International Business Machines Corp., 2002,2011
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>
40 #include <linux/module.h>
41 #include <keys/user-type.h>
43 #include <linux/parser.h>
47 #include "cifsproto.h"
48 #include "cifs_unicode.h"
49 #include "cifs_debug.h"
50 #include "cifs_fs_sb.h"
53 #include "rfc1002pdu.h"
57 #define RFC1001_PORT 139
59 extern mempool_t
*cifs_req_poolp
;
61 /* FIXME: should these be tunable? */
62 #define TLINK_ERROR_EXPIRE (1 * HZ)
63 #define TLINK_IDLE_EXPIRE (600 * HZ)
67 /* Mount options that take no arguments */
68 Opt_user_xattr
, Opt_nouser_xattr
,
69 Opt_forceuid
, Opt_noforceuid
,
70 Opt_forcegid
, Opt_noforcegid
,
71 Opt_noblocksend
, Opt_noautotune
,
72 Opt_hard
, Opt_soft
, Opt_perm
, Opt_noperm
,
73 Opt_mapchars
, Opt_nomapchars
, Opt_sfu
,
74 Opt_nosfu
, Opt_nodfs
, Opt_posixpaths
,
75 Opt_noposixpaths
, Opt_nounix
,
78 Opt_forcemandatorylock
, Opt_setuids
,
79 Opt_nosetuids
, Opt_dynperm
, Opt_nodynperm
,
80 Opt_nohard
, Opt_nosoft
,
82 Opt_nostrictsync
, Opt_strictsync
,
83 Opt_serverino
, Opt_noserverino
,
84 Opt_rwpidforward
, Opt_cifsacl
, Opt_nocifsacl
,
85 Opt_acl
, Opt_noacl
, Opt_locallease
,
86 Opt_sign
, Opt_seal
, Opt_noac
,
87 Opt_fsc
, Opt_mfsymlinks
,
88 Opt_multiuser
, Opt_sloppy
,
90 /* Mount options which take numeric value */
91 Opt_backupuid
, Opt_backupgid
, Opt_uid
,
92 Opt_cruid
, Opt_gid
, Opt_file_mode
,
93 Opt_dirmode
, Opt_port
,
94 Opt_rsize
, Opt_wsize
, Opt_actimeo
,
96 /* Mount options which take string value */
97 Opt_user
, Opt_pass
, Opt_ip
,
99 Opt_srcaddr
, Opt_prefixpath
,
100 Opt_iocharset
, Opt_sockopt
,
101 Opt_netbiosname
, Opt_servern
,
102 Opt_ver
, Opt_vers
, Opt_sec
, Opt_cache
,
104 /* Mount options to be ignored */
107 /* Options which could be blank */
115 static const match_table_t cifs_mount_option_tokens
= {
117 { Opt_user_xattr
, "user_xattr" },
118 { Opt_nouser_xattr
, "nouser_xattr" },
119 { Opt_forceuid
, "forceuid" },
120 { Opt_noforceuid
, "noforceuid" },
121 { Opt_forcegid
, "forcegid" },
122 { Opt_noforcegid
, "noforcegid" },
123 { Opt_noblocksend
, "noblocksend" },
124 { Opt_noautotune
, "noautotune" },
125 { Opt_hard
, "hard" },
126 { Opt_soft
, "soft" },
127 { Opt_perm
, "perm" },
128 { Opt_noperm
, "noperm" },
129 { Opt_mapchars
, "mapchars" },
130 { Opt_nomapchars
, "nomapchars" },
132 { Opt_nosfu
, "nosfu" },
133 { Opt_nodfs
, "nodfs" },
134 { Opt_posixpaths
, "posixpaths" },
135 { Opt_noposixpaths
, "noposixpaths" },
136 { Opt_nounix
, "nounix" },
137 { Opt_nounix
, "nolinux" },
138 { Opt_nocase
, "nocase" },
139 { Opt_nocase
, "ignorecase" },
141 { Opt_nobrl
, "nobrl" },
142 { Opt_nobrl
, "nolock" },
143 { Opt_forcemandatorylock
, "forcemandatorylock" },
144 { Opt_forcemandatorylock
, "forcemand" },
145 { Opt_setuids
, "setuids" },
146 { Opt_nosetuids
, "nosetuids" },
147 { Opt_dynperm
, "dynperm" },
148 { Opt_nodynperm
, "nodynperm" },
149 { Opt_nohard
, "nohard" },
150 { Opt_nosoft
, "nosoft" },
151 { Opt_nointr
, "nointr" },
152 { Opt_intr
, "intr" },
153 { Opt_nostrictsync
, "nostrictsync" },
154 { Opt_strictsync
, "strictsync" },
155 { Opt_serverino
, "serverino" },
156 { Opt_noserverino
, "noserverino" },
157 { Opt_rwpidforward
, "rwpidforward" },
158 { Opt_cifsacl
, "cifsacl" },
159 { Opt_nocifsacl
, "nocifsacl" },
161 { Opt_noacl
, "noacl" },
162 { Opt_locallease
, "locallease" },
163 { Opt_sign
, "sign" },
164 { Opt_seal
, "seal" },
165 { Opt_noac
, "noac" },
167 { Opt_mfsymlinks
, "mfsymlinks" },
168 { Opt_multiuser
, "multiuser" },
169 { Opt_sloppy
, "sloppy" },
171 { Opt_backupuid
, "backupuid=%s" },
172 { Opt_backupgid
, "backupgid=%s" },
173 { Opt_uid
, "uid=%s" },
174 { Opt_cruid
, "cruid=%s" },
175 { Opt_gid
, "gid=%s" },
176 { Opt_file_mode
, "file_mode=%s" },
177 { Opt_dirmode
, "dirmode=%s" },
178 { Opt_dirmode
, "dir_mode=%s" },
179 { Opt_port
, "port=%s" },
180 { Opt_rsize
, "rsize=%s" },
181 { Opt_wsize
, "wsize=%s" },
182 { Opt_actimeo
, "actimeo=%s" },
184 { Opt_blank_user
, "user=" },
185 { Opt_blank_user
, "username=" },
186 { Opt_user
, "user=%s" },
187 { Opt_user
, "username=%s" },
188 { Opt_blank_pass
, "pass=" },
189 { Opt_pass
, "pass=%s" },
190 { Opt_pass
, "password=%s" },
191 { Opt_blank_ip
, "ip=" },
192 { Opt_blank_ip
, "addr=" },
194 { Opt_ip
, "addr=%s" },
195 { Opt_unc
, "unc=%s" },
196 { Opt_unc
, "target=%s" },
197 { Opt_unc
, "path=%s" },
198 { Opt_domain
, "dom=%s" },
199 { Opt_domain
, "domain=%s" },
200 { Opt_domain
, "workgroup=%s" },
201 { Opt_srcaddr
, "srcaddr=%s" },
202 { Opt_prefixpath
, "prefixpath=%s" },
203 { Opt_iocharset
, "iocharset=%s" },
204 { Opt_sockopt
, "sockopt=%s" },
205 { Opt_netbiosname
, "netbiosname=%s" },
206 { Opt_servern
, "servern=%s" },
207 { Opt_ver
, "ver=%s" },
208 { Opt_vers
, "vers=%s" },
209 { Opt_sec
, "sec=%s" },
210 { Opt_cache
, "cache=%s" },
212 { Opt_ignore
, "cred" },
213 { Opt_ignore
, "credentials" },
214 { Opt_ignore
, "cred=%s" },
215 { Opt_ignore
, "credentials=%s" },
216 { Opt_ignore
, "guest" },
217 { Opt_ignore
, "rw" },
218 { Opt_ignore
, "ro" },
219 { Opt_ignore
, "suid" },
220 { Opt_ignore
, "nosuid" },
221 { Opt_ignore
, "exec" },
222 { Opt_ignore
, "noexec" },
223 { Opt_ignore
, "nodev" },
224 { Opt_ignore
, "noauto" },
225 { Opt_ignore
, "dev" },
226 { Opt_ignore
, "mand" },
227 { Opt_ignore
, "nomand" },
228 { Opt_ignore
, "_netdev" },
234 Opt_sec_krb5
, Opt_sec_krb5i
, Opt_sec_krb5p
,
235 Opt_sec_ntlmsspi
, Opt_sec_ntlmssp
,
236 Opt_ntlm
, Opt_sec_ntlmi
, Opt_sec_ntlmv2
,
237 Opt_sec_ntlmv2i
, Opt_sec_lanman
,
243 static const match_table_t cifs_secflavor_tokens
= {
244 { Opt_sec_krb5
, "krb5" },
245 { Opt_sec_krb5i
, "krb5i" },
246 { Opt_sec_krb5p
, "krb5p" },
247 { Opt_sec_ntlmsspi
, "ntlmsspi" },
248 { Opt_sec_ntlmssp
, "ntlmssp" },
249 { Opt_ntlm
, "ntlm" },
250 { Opt_sec_ntlmi
, "ntlmi" },
251 { Opt_sec_ntlmv2
, "nontlm" },
252 { Opt_sec_ntlmv2
, "ntlmv2" },
253 { Opt_sec_ntlmv2i
, "ntlmv2i" },
254 { Opt_sec_lanman
, "lanman" },
255 { Opt_sec_none
, "none" },
257 { Opt_sec_err
, NULL
}
268 static const match_table_t cifs_cacheflavor_tokens
= {
269 { Opt_cache_loose
, "loose" },
270 { Opt_cache_strict
, "strict" },
271 { Opt_cache_none
, "none" },
272 { Opt_cache_err
, NULL
}
275 static const match_table_t cifs_smb_version_tokens
= {
276 { Smb_1
, SMB1_VERSION_STRING
},
277 { Smb_20
, SMB20_VERSION_STRING
},
278 { Smb_21
, SMB21_VERSION_STRING
},
279 { Smb_30
, SMB30_VERSION_STRING
},
282 static int ip_connect(struct TCP_Server_Info
*server
);
283 static int generic_ip_connect(struct TCP_Server_Info
*server
);
284 static void tlink_rb_insert(struct rb_root
*root
, struct tcon_link
*new_tlink
);
285 static void cifs_prune_tlinks(struct work_struct
*work
);
286 static int cifs_setup_volume_info(struct smb_vol
*volume_info
, char *mount_data
,
287 const char *devname
);
290 * cifs tcp session reconnection
292 * mark tcp session as reconnecting so temporarily locked
293 * mark all smb sessions as reconnecting for tcp session
294 * reconnect tcp session
295 * wake up waiters on reconnection? - (not needed currently)
298 cifs_reconnect(struct TCP_Server_Info
*server
)
301 struct list_head
*tmp
, *tmp2
;
302 struct cifs_ses
*ses
;
303 struct cifs_tcon
*tcon
;
304 struct mid_q_entry
*mid_entry
;
305 struct list_head retry_list
;
307 spin_lock(&GlobalMid_Lock
);
308 if (server
->tcpStatus
== CifsExiting
) {
309 /* the demux thread will exit normally
310 next time through the loop */
311 spin_unlock(&GlobalMid_Lock
);
314 server
->tcpStatus
= CifsNeedReconnect
;
315 spin_unlock(&GlobalMid_Lock
);
317 #ifdef CONFIG_CIFS_SMB2
318 server
->max_read
= 0;
321 cFYI(1, "Reconnecting tcp session");
323 /* before reconnecting the tcp session, mark the smb session (uid)
324 and the tid bad so they are not used until reconnected */
325 cFYI(1, "%s: marking sessions and tcons for reconnect", __func__
);
326 spin_lock(&cifs_tcp_ses_lock
);
327 list_for_each(tmp
, &server
->smb_ses_list
) {
328 ses
= list_entry(tmp
, struct cifs_ses
, smb_ses_list
);
329 ses
->need_reconnect
= true;
331 list_for_each(tmp2
, &ses
->tcon_list
) {
332 tcon
= list_entry(tmp2
, struct cifs_tcon
, tcon_list
);
333 tcon
->need_reconnect
= true;
336 spin_unlock(&cifs_tcp_ses_lock
);
338 /* do not want to be sending data on a socket we are freeing */
339 cFYI(1, "%s: tearing down socket", __func__
);
340 mutex_lock(&server
->srv_mutex
);
341 if (server
->ssocket
) {
342 cFYI(1, "State: 0x%x Flags: 0x%lx", server
->ssocket
->state
,
343 server
->ssocket
->flags
);
344 kernel_sock_shutdown(server
->ssocket
, SHUT_WR
);
345 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
346 server
->ssocket
->state
,
347 server
->ssocket
->flags
);
348 sock_release(server
->ssocket
);
349 server
->ssocket
= NULL
;
351 server
->sequence_number
= 0;
352 server
->session_estab
= false;
353 kfree(server
->session_key
.response
);
354 server
->session_key
.response
= NULL
;
355 server
->session_key
.len
= 0;
356 server
->lstrp
= jiffies
;
357 mutex_unlock(&server
->srv_mutex
);
359 /* mark submitted MIDs for retry and issue callback */
360 INIT_LIST_HEAD(&retry_list
);
361 cFYI(1, "%s: moving mids to private list", __func__
);
362 spin_lock(&GlobalMid_Lock
);
363 list_for_each_safe(tmp
, tmp2
, &server
->pending_mid_q
) {
364 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
365 if (mid_entry
->mid_state
== MID_REQUEST_SUBMITTED
)
366 mid_entry
->mid_state
= MID_RETRY_NEEDED
;
367 list_move(&mid_entry
->qhead
, &retry_list
);
369 spin_unlock(&GlobalMid_Lock
);
371 cFYI(1, "%s: issuing mid callbacks", __func__
);
372 list_for_each_safe(tmp
, tmp2
, &retry_list
) {
373 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
374 list_del_init(&mid_entry
->qhead
);
375 mid_entry
->callback(mid_entry
);
381 /* we should try only the port we connected to before */
382 rc
= generic_ip_connect(server
);
384 cFYI(1, "reconnect error %d", rc
);
387 atomic_inc(&tcpSesReconnectCount
);
388 spin_lock(&GlobalMid_Lock
);
389 if (server
->tcpStatus
!= CifsExiting
)
390 server
->tcpStatus
= CifsNeedNegotiate
;
391 spin_unlock(&GlobalMid_Lock
);
393 } while (server
->tcpStatus
== CifsNeedReconnect
);
399 cifs_echo_request(struct work_struct
*work
)
402 struct TCP_Server_Info
*server
= container_of(work
,
403 struct TCP_Server_Info
, echo
.work
);
406 * We cannot send an echo if it is disabled or until the
407 * NEGOTIATE_PROTOCOL request is done, which is indicated by
408 * server->ops->need_neg() == true. Also, no need to ping if
409 * we got a response recently.
411 if (!server
->ops
->need_neg
|| server
->ops
->need_neg(server
) ||
412 (server
->ops
->can_echo
&& !server
->ops
->can_echo(server
)) ||
413 time_before(jiffies
, server
->lstrp
+ SMB_ECHO_INTERVAL
- HZ
))
416 rc
= server
->ops
->echo
? server
->ops
->echo(server
) : -ENOSYS
;
418 cFYI(1, "Unable to send echo request to server: %s",
422 queue_delayed_work(cifsiod_wq
, &server
->echo
, SMB_ECHO_INTERVAL
);
426 allocate_buffers(struct TCP_Server_Info
*server
)
428 if (!server
->bigbuf
) {
429 server
->bigbuf
= (char *)cifs_buf_get();
430 if (!server
->bigbuf
) {
431 cERROR(1, "No memory for large SMB response");
433 /* retry will check if exiting */
436 } else if (server
->large_buf
) {
437 /* we are reusing a dirty large buf, clear its start */
438 memset(server
->bigbuf
, 0, HEADER_SIZE(server
));
441 if (!server
->smallbuf
) {
442 server
->smallbuf
= (char *)cifs_small_buf_get();
443 if (!server
->smallbuf
) {
444 cERROR(1, "No memory for SMB response");
446 /* retry will check if exiting */
449 /* beginning of smb buffer is cleared in our buf_get */
451 /* if existing small buf clear beginning */
452 memset(server
->smallbuf
, 0, HEADER_SIZE(server
));
459 server_unresponsive(struct TCP_Server_Info
*server
)
462 * We need to wait 2 echo intervals to make sure we handle such
464 * 1s client sends a normal SMB request
465 * 2s client gets a response
466 * 30s echo workqueue job pops, and decides we got a response recently
467 * and don't need to send another
469 * 65s kernel_recvmsg times out, and we see that we haven't gotten
470 * a response in >60s.
472 if (server
->tcpStatus
== CifsGood
&&
473 time_after(jiffies
, server
->lstrp
+ 2 * SMB_ECHO_INTERVAL
)) {
474 cERROR(1, "Server %s has not responded in %d seconds. "
475 "Reconnecting...", server
->hostname
,
476 (2 * SMB_ECHO_INTERVAL
) / HZ
);
477 cifs_reconnect(server
);
478 wake_up(&server
->response_q
);
486 * kvec_array_init - clone a kvec array, and advance into it
487 * @new: pointer to memory for cloned array
488 * @iov: pointer to original array
489 * @nr_segs: number of members in original array
490 * @bytes: number of bytes to advance into the cloned array
492 * This function will copy the array provided in iov to a section of memory
493 * and advance the specified number of bytes into the new array. It returns
494 * the number of segments in the new array. "new" must be at least as big as
495 * the original iov array.
498 kvec_array_init(struct kvec
*new, struct kvec
*iov
, unsigned int nr_segs
,
503 while (bytes
|| !iov
->iov_len
) {
504 int copy
= min(bytes
, iov
->iov_len
);
508 if (iov
->iov_len
== base
) {
514 memcpy(new, iov
, sizeof(*iov
) * nr_segs
);
515 new->iov_base
+= base
;
516 new->iov_len
-= base
;
521 get_server_iovec(struct TCP_Server_Info
*server
, unsigned int nr_segs
)
523 struct kvec
*new_iov
;
525 if (server
->iov
&& nr_segs
<= server
->nr_iov
)
528 /* not big enough -- allocate a new one and release the old */
529 new_iov
= kmalloc(sizeof(*new_iov
) * nr_segs
, GFP_NOFS
);
532 server
->iov
= new_iov
;
533 server
->nr_iov
= nr_segs
;
539 cifs_readv_from_socket(struct TCP_Server_Info
*server
, struct kvec
*iov_orig
,
540 unsigned int nr_segs
, unsigned int to_read
)
545 struct msghdr smb_msg
;
548 iov
= get_server_iovec(server
, nr_segs
);
552 smb_msg
.msg_control
= NULL
;
553 smb_msg
.msg_controllen
= 0;
555 for (total_read
= 0; to_read
; total_read
+= length
, to_read
-= length
) {
558 if (server_unresponsive(server
)) {
559 total_read
= -EAGAIN
;
563 segs
= kvec_array_init(iov
, iov_orig
, nr_segs
, total_read
);
565 length
= kernel_recvmsg(server
->ssocket
, &smb_msg
,
566 iov
, segs
, to_read
, 0);
568 if (server
->tcpStatus
== CifsExiting
) {
569 total_read
= -ESHUTDOWN
;
571 } else if (server
->tcpStatus
== CifsNeedReconnect
) {
572 cifs_reconnect(server
);
573 total_read
= -EAGAIN
;
575 } else if (length
== -ERESTARTSYS
||
579 * Minimum sleep to prevent looping, allowing socket
580 * to clear and app threads to set tcpStatus
581 * CifsNeedReconnect if server hung.
583 usleep_range(1000, 2000);
586 } else if (length
<= 0) {
587 cFYI(1, "Received no data or error: expecting %d "
588 "got %d", to_read
, length
);
589 cifs_reconnect(server
);
590 total_read
= -EAGAIN
;
598 cifs_read_from_socket(struct TCP_Server_Info
*server
, char *buf
,
599 unsigned int to_read
)
604 iov
.iov_len
= to_read
;
606 return cifs_readv_from_socket(server
, &iov
, 1, to_read
);
610 is_smb_response(struct TCP_Server_Info
*server
, unsigned char type
)
613 * The first byte big endian of the length field,
614 * is actually not part of the length but the type
615 * with the most common, zero, as regular data.
618 case RFC1002_SESSION_MESSAGE
:
619 /* Regular SMB response */
621 case RFC1002_SESSION_KEEP_ALIVE
:
622 cFYI(1, "RFC 1002 session keep alive");
624 case RFC1002_POSITIVE_SESSION_RESPONSE
:
625 cFYI(1, "RFC 1002 positive session response");
627 case RFC1002_NEGATIVE_SESSION_RESPONSE
:
629 * We get this from Windows 98 instead of an error on
630 * SMB negprot response.
632 cFYI(1, "RFC 1002 negative session response");
633 /* give server a second to clean up */
636 * Always try 445 first on reconnect since we get NACK
637 * on some if we ever connected to port 139 (the NACK
638 * is since we do not begin with RFC1001 session
641 cifs_set_port((struct sockaddr
*)&server
->dstaddr
, CIFS_PORT
);
642 cifs_reconnect(server
);
643 wake_up(&server
->response_q
);
646 cERROR(1, "RFC 1002 unknown response type 0x%x", type
);
647 cifs_reconnect(server
);
654 dequeue_mid(struct mid_q_entry
*mid
, bool malformed
)
656 #ifdef CONFIG_CIFS_STATS2
657 mid
->when_received
= jiffies
;
659 spin_lock(&GlobalMid_Lock
);
661 mid
->mid_state
= MID_RESPONSE_RECEIVED
;
663 mid
->mid_state
= MID_RESPONSE_MALFORMED
;
664 list_del_init(&mid
->qhead
);
665 spin_unlock(&GlobalMid_Lock
);
669 handle_mid(struct mid_q_entry
*mid
, struct TCP_Server_Info
*server
,
670 char *buf
, int malformed
)
672 if (server
->ops
->check_trans2
&&
673 server
->ops
->check_trans2(mid
, server
, buf
, malformed
))
676 mid
->large_buf
= server
->large_buf
;
677 /* Was previous buf put in mpx struct for multi-rsp? */
678 if (!mid
->multiRsp
) {
679 /* smb buffer will be freed by user thread */
680 if (server
->large_buf
)
681 server
->bigbuf
= NULL
;
683 server
->smallbuf
= NULL
;
685 dequeue_mid(mid
, malformed
);
688 static void clean_demultiplex_info(struct TCP_Server_Info
*server
)
692 /* take it off the list, if it's not already */
693 spin_lock(&cifs_tcp_ses_lock
);
694 list_del_init(&server
->tcp_ses_list
);
695 spin_unlock(&cifs_tcp_ses_lock
);
697 spin_lock(&GlobalMid_Lock
);
698 server
->tcpStatus
= CifsExiting
;
699 spin_unlock(&GlobalMid_Lock
);
700 wake_up_all(&server
->response_q
);
702 /* check if we have blocked requests that need to free */
703 spin_lock(&server
->req_lock
);
704 if (server
->credits
<= 0)
706 spin_unlock(&server
->req_lock
);
708 * Although there should not be any requests blocked on this queue it
709 * can not hurt to be paranoid and try to wake up requests that may
710 * haven been blocked when more than 50 at time were on the wire to the
711 * same server - they now will see the session is in exit state and get
712 * out of SendReceive.
714 wake_up_all(&server
->request_q
);
715 /* give those requests time to exit */
718 if (server
->ssocket
) {
719 sock_release(server
->ssocket
);
720 server
->ssocket
= NULL
;
723 if (!list_empty(&server
->pending_mid_q
)) {
724 struct list_head dispose_list
;
725 struct mid_q_entry
*mid_entry
;
726 struct list_head
*tmp
, *tmp2
;
728 INIT_LIST_HEAD(&dispose_list
);
729 spin_lock(&GlobalMid_Lock
);
730 list_for_each_safe(tmp
, tmp2
, &server
->pending_mid_q
) {
731 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
732 cFYI(1, "Clearing mid 0x%llx", mid_entry
->mid
);
733 mid_entry
->mid_state
= MID_SHUTDOWN
;
734 list_move(&mid_entry
->qhead
, &dispose_list
);
736 spin_unlock(&GlobalMid_Lock
);
738 /* now walk dispose list and issue callbacks */
739 list_for_each_safe(tmp
, tmp2
, &dispose_list
) {
740 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
741 cFYI(1, "Callback mid 0x%llx", mid_entry
->mid
);
742 list_del_init(&mid_entry
->qhead
);
743 mid_entry
->callback(mid_entry
);
745 /* 1/8th of sec is more than enough time for them to exit */
749 if (!list_empty(&server
->pending_mid_q
)) {
751 * mpx threads have not exited yet give them at least the smb
752 * send timeout time for long ops.
754 * Due to delays on oplock break requests, we need to wait at
755 * least 45 seconds before giving up on a request getting a
756 * response and going ahead and killing cifsd.
758 cFYI(1, "Wait for exit from demultiplex thread");
761 * If threads still have not exited they are probably never
762 * coming home not much else we can do but free the memory.
766 kfree(server
->hostname
);
770 length
= atomic_dec_return(&tcpSesAllocCount
);
772 mempool_resize(cifs_req_poolp
, length
+ cifs_min_rcv
,
777 standard_receive3(struct TCP_Server_Info
*server
, struct mid_q_entry
*mid
)
780 char *buf
= server
->smallbuf
;
781 unsigned int pdu_length
= get_rfc1002_length(buf
);
783 /* make sure this will fit in a large buffer */
784 if (pdu_length
> CIFSMaxBufSize
+ MAX_HEADER_SIZE(server
) - 4) {
785 cERROR(1, "SMB response too long (%u bytes)",
787 cifs_reconnect(server
);
788 wake_up(&server
->response_q
);
792 /* switch to large buffer if too big for a small one */
793 if (pdu_length
> MAX_CIFS_SMALL_BUFFER_SIZE
- 4) {
794 server
->large_buf
= true;
795 memcpy(server
->bigbuf
, buf
, server
->total_read
);
796 buf
= server
->bigbuf
;
799 /* now read the rest */
800 length
= cifs_read_from_socket(server
, buf
+ HEADER_SIZE(server
) - 1,
801 pdu_length
- HEADER_SIZE(server
) + 1 + 4);
804 server
->total_read
+= length
;
806 dump_smb(buf
, server
->total_read
);
809 * We know that we received enough to get to the MID as we
810 * checked the pdu_length earlier. Now check to see
811 * if the rest of the header is OK. We borrow the length
812 * var for the rest of the loop to avoid a new stack var.
814 * 48 bytes is enough to display the header and a little bit
815 * into the payload for debugging purposes.
817 length
= server
->ops
->check_message(buf
, server
->total_read
);
819 cifs_dump_mem("Bad SMB: ", buf
,
820 min_t(unsigned int, server
->total_read
, 48));
822 if (server
->ops
->is_status_pending
&&
823 server
->ops
->is_status_pending(buf
, server
, length
))
829 handle_mid(mid
, server
, buf
, length
);
834 cifs_demultiplex_thread(void *p
)
837 struct TCP_Server_Info
*server
= p
;
838 unsigned int pdu_length
;
840 struct task_struct
*task_to_wake
= NULL
;
841 struct mid_q_entry
*mid_entry
;
843 current
->flags
|= PF_MEMALLOC
;
844 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current
));
846 length
= atomic_inc_return(&tcpSesAllocCount
);
848 mempool_resize(cifs_req_poolp
, length
+ cifs_min_rcv
,
852 while (server
->tcpStatus
!= CifsExiting
) {
856 if (!allocate_buffers(server
))
859 server
->large_buf
= false;
860 buf
= server
->smallbuf
;
861 pdu_length
= 4; /* enough to get RFC1001 header */
863 length
= cifs_read_from_socket(server
, buf
, pdu_length
);
866 server
->total_read
= length
;
869 * The right amount was read from socket - 4 bytes,
870 * so we can now interpret the length field.
872 pdu_length
= get_rfc1002_length(buf
);
874 cFYI(1, "RFC1002 header 0x%x", pdu_length
);
875 if (!is_smb_response(server
, buf
[0]))
878 /* make sure we have enough to get to the MID */
879 if (pdu_length
< HEADER_SIZE(server
) - 1 - 4) {
880 cERROR(1, "SMB response too short (%u bytes)",
882 cifs_reconnect(server
);
883 wake_up(&server
->response_q
);
887 /* read down to the MID */
888 length
= cifs_read_from_socket(server
, buf
+ 4,
889 HEADER_SIZE(server
) - 1 - 4);
892 server
->total_read
+= length
;
894 mid_entry
= server
->ops
->find_mid(server
, buf
);
896 if (!mid_entry
|| !mid_entry
->receive
)
897 length
= standard_receive3(server
, mid_entry
);
899 length
= mid_entry
->receive(server
, mid_entry
);
904 if (server
->large_buf
)
905 buf
= server
->bigbuf
;
907 server
->lstrp
= jiffies
;
908 if (mid_entry
!= NULL
) {
909 if (!mid_entry
->multiRsp
|| mid_entry
->multiEnd
)
910 mid_entry
->callback(mid_entry
);
911 } else if (!server
->ops
->is_oplock_break
||
912 !server
->ops
->is_oplock_break(buf
, server
)) {
913 cERROR(1, "No task to wake, unknown frame received! "
914 "NumMids %d", atomic_read(&midCount
));
915 cifs_dump_mem("Received Data is: ", buf
,
916 HEADER_SIZE(server
));
917 #ifdef CONFIG_CIFS_DEBUG2
918 if (server
->ops
->dump_detail
)
919 server
->ops
->dump_detail(buf
);
920 cifs_dump_mids(server
);
921 #endif /* CIFS_DEBUG2 */
924 } /* end while !EXITING */
926 /* buffer usually freed in free_mid - need to free it here on exit */
927 cifs_buf_release(server
->bigbuf
);
928 if (server
->smallbuf
) /* no sense logging a debug message if NULL */
929 cifs_small_buf_release(server
->smallbuf
);
931 task_to_wake
= xchg(&server
->tsk
, NULL
);
932 clean_demultiplex_info(server
);
934 /* if server->tsk was NULL then wait for a signal before exiting */
936 set_current_state(TASK_INTERRUPTIBLE
);
937 while (!signal_pending(current
)) {
939 set_current_state(TASK_INTERRUPTIBLE
);
941 set_current_state(TASK_RUNNING
);
944 module_put_and_exit(0);
947 /* extract the host portion of the UNC string */
949 extract_hostname(const char *unc
)
955 /* skip double chars at beginning of string */
956 /* BB: check validity of these bytes? */
959 /* delimiter between hostname and sharename is always '\\' now */
960 delim
= strchr(src
, '\\');
962 return ERR_PTR(-EINVAL
);
965 dst
= kmalloc((len
+ 1), GFP_KERNEL
);
967 return ERR_PTR(-ENOMEM
);
969 memcpy(dst
, src
, len
);
975 static int get_option_ul(substring_t args
[], unsigned long *option
)
980 string
= match_strdup(args
);
983 rc
= kstrtoul(string
, 0, option
);
990 static int cifs_parse_security_flavors(char *value
,
994 substring_t args
[MAX_OPT_ARGS
];
996 switch (match_token(value
, cifs_secflavor_tokens
, args
)) {
998 vol
->secFlg
|= CIFSSEC_MAY_KRB5
;
1001 vol
->secFlg
|= CIFSSEC_MAY_KRB5
| CIFSSEC_MUST_SIGN
;
1004 /* vol->secFlg |= CIFSSEC_MUST_SEAL | CIFSSEC_MAY_KRB5; */
1005 cERROR(1, "Krb5 cifs privacy not supported");
1007 case Opt_sec_ntlmssp
:
1008 vol
->secFlg
|= CIFSSEC_MAY_NTLMSSP
;
1010 case Opt_sec_ntlmsspi
:
1011 vol
->secFlg
|= CIFSSEC_MAY_NTLMSSP
| CIFSSEC_MUST_SIGN
;
1014 /* ntlm is default so can be turned off too */
1015 vol
->secFlg
|= CIFSSEC_MAY_NTLM
;
1018 vol
->secFlg
|= CIFSSEC_MAY_NTLM
| CIFSSEC_MUST_SIGN
;
1020 case Opt_sec_ntlmv2
:
1021 vol
->secFlg
|= CIFSSEC_MAY_NTLMV2
;
1023 case Opt_sec_ntlmv2i
:
1024 vol
->secFlg
|= CIFSSEC_MAY_NTLMV2
| CIFSSEC_MUST_SIGN
;
1026 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1027 case Opt_sec_lanman
:
1028 vol
->secFlg
|= CIFSSEC_MAY_LANMAN
;
1035 cERROR(1, "bad security option: %s", value
);
1043 cifs_parse_cache_flavor(char *value
, struct smb_vol
*vol
)
1045 substring_t args
[MAX_OPT_ARGS
];
1047 switch (match_token(value
, cifs_cacheflavor_tokens
, args
)) {
1048 case Opt_cache_loose
:
1049 vol
->direct_io
= false;
1050 vol
->strict_io
= false;
1052 case Opt_cache_strict
:
1053 vol
->direct_io
= false;
1054 vol
->strict_io
= true;
1056 case Opt_cache_none
:
1057 vol
->direct_io
= true;
1058 vol
->strict_io
= false;
1061 cERROR(1, "bad cache= option: %s", value
);
1068 cifs_parse_smb_version(char *value
, struct smb_vol
*vol
)
1070 substring_t args
[MAX_OPT_ARGS
];
1072 switch (match_token(value
, cifs_smb_version_tokens
, args
)) {
1074 vol
->ops
= &smb1_operations
;
1075 vol
->vals
= &smb1_values
;
1077 #ifdef CONFIG_CIFS_SMB2
1079 vol
->ops
= &smb21_operations
; /* currently identical with 2.1 */
1080 vol
->vals
= &smb20_values
;
1083 vol
->ops
= &smb21_operations
;
1084 vol
->vals
= &smb21_values
;
1087 vol
->ops
= &smb21_operations
; /* currently identical with 2.1 */
1088 vol
->vals
= &smb30_values
;
1092 cERROR(1, "Unknown vers= option specified: %s", value
);
1099 cifs_parse_mount_options(const char *mountdata
, const char *devname
,
1100 struct smb_vol
*vol
)
1103 char *mountdata_copy
= NULL
, *options
;
1104 unsigned int temp_len
, i
, j
;
1106 short int override_uid
= -1;
1107 short int override_gid
= -1;
1108 bool uid_specified
= false;
1109 bool gid_specified
= false;
1110 bool sloppy
= false;
1111 char *invalid
= NULL
;
1112 char *nodename
= utsname()->nodename
;
1113 char *string
= NULL
;
1114 char *tmp_end
, *value
;
1119 delim
= separator
[0];
1122 * does not have to be perfect mapping since field is
1123 * informational, only used for servers that do not support
1124 * port 445 and it can be overridden at mount time
1126 memset(vol
->source_rfc1001_name
, 0x20, RFC1001_NAME_LEN
);
1127 for (i
= 0; i
< strnlen(nodename
, RFC1001_NAME_LEN
); i
++)
1128 vol
->source_rfc1001_name
[i
] = toupper(nodename
[i
]);
1130 vol
->source_rfc1001_name
[RFC1001_NAME_LEN
] = 0;
1131 /* null target name indicates to use *SMBSERVR default called name
1132 if we end up sending RFC1001 session initialize */
1133 vol
->target_rfc1001_name
[0] = 0;
1134 vol
->cred_uid
= current_uid();
1135 vol
->linux_uid
= current_uid();
1136 vol
->linux_gid
= current_gid();
1138 /* default to only allowing write access to owner of the mount */
1139 vol
->dir_mode
= vol
->file_mode
= S_IRUGO
| S_IXUGO
| S_IWUSR
;
1141 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1142 /* default is always to request posix paths. */
1143 vol
->posix_paths
= 1;
1144 /* default to using server inode numbers where available */
1145 vol
->server_ino
= 1;
1147 /* default is to use strict cifs caching semantics */
1148 vol
->strict_io
= true;
1150 vol
->actimeo
= CIFS_DEF_ACTIMEO
;
1152 /* FIXME: add autonegotiation -- for now, SMB1 is default */
1153 vol
->ops
= &smb1_operations
;
1154 vol
->vals
= &smb1_values
;
1157 goto cifs_parse_mount_err
;
1159 mountdata_copy
= kstrndup(mountdata
, PAGE_SIZE
, GFP_KERNEL
);
1160 if (!mountdata_copy
)
1161 goto cifs_parse_mount_err
;
1163 options
= mountdata_copy
;
1164 end
= options
+ strlen(options
);
1166 if (strncmp(options
, "sep=", 4) == 0) {
1167 if (options
[4] != 0) {
1168 separator
[0] = options
[4];
1171 cFYI(1, "Null separator not allowed");
1174 vol
->backupuid_specified
= false; /* no backup intent for a user */
1175 vol
->backupgid_specified
= false; /* no backup intent for a group */
1177 while ((data
= strsep(&options
, separator
)) != NULL
) {
1178 substring_t args
[MAX_OPT_ARGS
];
1179 unsigned long option
;
1185 token
= match_token(data
, cifs_mount_option_tokens
, args
);
1189 /* Ingnore the following */
1193 /* Boolean values */
1194 case Opt_user_xattr
:
1197 case Opt_nouser_xattr
:
1203 case Opt_noforceuid
:
1209 case Opt_noforcegid
:
1212 case Opt_noblocksend
:
1213 vol
->noblocksnd
= 1;
1215 case Opt_noautotune
:
1216 vol
->noautotune
= 1;
1233 case Opt_nomapchars
:
1245 case Opt_posixpaths
:
1246 vol
->posix_paths
= 1;
1248 case Opt_noposixpaths
:
1249 vol
->posix_paths
= 0;
1252 vol
->no_linux_ext
= 1;
1263 * turn off mandatory locking in mode
1264 * if remote locking is turned off since the
1265 * local vfs will do advisory
1267 if (vol
->file_mode
==
1268 (S_IALLUGO
& ~(S_ISUID
| S_IXGRP
)))
1269 vol
->file_mode
= S_IALLUGO
;
1271 case Opt_forcemandatorylock
:
1281 vol
->dynperm
= true;
1284 vol
->dynperm
= false;
1298 case Opt_nostrictsync
:
1299 vol
->nostrictsync
= 1;
1301 case Opt_strictsync
:
1302 vol
->nostrictsync
= 0;
1305 vol
->server_ino
= 1;
1307 case Opt_noserverino
:
1308 vol
->server_ino
= 0;
1310 case Opt_rwpidforward
:
1311 vol
->rwpidforward
= 1;
1320 vol
->no_psx_acl
= 0;
1323 vol
->no_psx_acl
= 1;
1325 case Opt_locallease
:
1326 vol
->local_lease
= 1;
1329 vol
->secFlg
|= CIFSSEC_MUST_SIGN
;
1332 /* we do not do the following in secFlags because seal
1333 * is a per tree connection (mount) not a per socket
1334 * or per-smb connection option in the protocol
1335 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1340 printk(KERN_WARNING
"CIFS: Mount option noac not "
1341 "supported. Instead set "
1342 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1345 #ifndef CONFIG_CIFS_FSCACHE
1346 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE "
1347 "kernel config option set");
1348 goto cifs_parse_mount_err
;
1352 case Opt_mfsymlinks
:
1353 vol
->mfsymlinks
= true;
1356 vol
->multiuser
= true;
1362 /* Numeric Values */
1364 if (get_option_ul(args
, &option
)) {
1365 cERROR(1, "%s: Invalid backupuid value",
1367 goto cifs_parse_mount_err
;
1369 vol
->backupuid
= option
;
1370 vol
->backupuid_specified
= true;
1373 if (get_option_ul(args
, &option
)) {
1374 cERROR(1, "%s: Invalid backupgid value",
1376 goto cifs_parse_mount_err
;
1378 vol
->backupgid
= option
;
1379 vol
->backupgid_specified
= true;
1382 if (get_option_ul(args
, &option
)) {
1383 cERROR(1, "%s: Invalid uid value",
1385 goto cifs_parse_mount_err
;
1387 vol
->linux_uid
= option
;
1388 uid_specified
= true;
1391 if (get_option_ul(args
, &option
)) {
1392 cERROR(1, "%s: Invalid cruid value",
1394 goto cifs_parse_mount_err
;
1396 vol
->cred_uid
= option
;
1399 if (get_option_ul(args
, &option
)) {
1400 cERROR(1, "%s: Invalid gid value",
1402 goto cifs_parse_mount_err
;
1404 vol
->linux_gid
= option
;
1405 gid_specified
= true;
1408 if (get_option_ul(args
, &option
)) {
1409 cERROR(1, "%s: Invalid file_mode value",
1411 goto cifs_parse_mount_err
;
1413 vol
->file_mode
= option
;
1416 if (get_option_ul(args
, &option
)) {
1417 cERROR(1, "%s: Invalid dir_mode value",
1419 goto cifs_parse_mount_err
;
1421 vol
->dir_mode
= option
;
1424 if (get_option_ul(args
, &option
)) {
1425 cERROR(1, "%s: Invalid port value",
1427 goto cifs_parse_mount_err
;
1432 if (get_option_ul(args
, &option
)) {
1433 cERROR(1, "%s: Invalid rsize value",
1435 goto cifs_parse_mount_err
;
1437 vol
->rsize
= option
;
1440 if (get_option_ul(args
, &option
)) {
1441 cERROR(1, "%s: Invalid wsize value",
1443 goto cifs_parse_mount_err
;
1445 vol
->wsize
= option
;
1448 if (get_option_ul(args
, &option
)) {
1449 cERROR(1, "%s: Invalid actimeo value",
1451 goto cifs_parse_mount_err
;
1453 vol
->actimeo
= HZ
* option
;
1454 if (vol
->actimeo
> CIFS_MAX_ACTIMEO
) {
1455 cERROR(1, "CIFS: attribute cache"
1456 "timeout too large");
1457 goto cifs_parse_mount_err
;
1461 /* String Arguments */
1463 case Opt_blank_user
:
1464 /* null user, ie. anonymous authentication */
1466 vol
->username
= NULL
;
1469 string
= match_strdup(args
);
1473 if (strnlen(string
, MAX_USERNAME_SIZE
) >
1474 MAX_USERNAME_SIZE
) {
1475 printk(KERN_WARNING
"CIFS: username too long\n");
1476 goto cifs_parse_mount_err
;
1478 vol
->username
= kstrdup(string
, GFP_KERNEL
);
1479 if (!vol
->username
) {
1480 printk(KERN_WARNING
"CIFS: no memory "
1482 goto cifs_parse_mount_err
;
1485 case Opt_blank_pass
:
1486 vol
->password
= NULL
;
1489 /* passwords have to be handled differently
1490 * to allow the character used for deliminator
1491 * to be passed within them
1494 /* Obtain the value string */
1495 value
= strchr(data
, '=');
1498 /* Set tmp_end to end of the string */
1499 tmp_end
= (char *) value
+ strlen(value
);
1501 /* Check if following character is the deliminator
1502 * If yes, we have encountered a double deliminator
1503 * reset the NULL character to the deliminator
1505 if (tmp_end
< end
&& tmp_end
[1] == delim
) {
1508 /* Keep iterating until we get to a single
1509 * deliminator OR the end
1511 while ((tmp_end
= strchr(tmp_end
, delim
))
1512 != NULL
&& (tmp_end
[1] == delim
)) {
1513 tmp_end
= (char *) &tmp_end
[2];
1516 /* Reset var options to point to next element */
1519 options
= (char *) &tmp_end
[1];
1521 /* Reached the end of the mount option
1526 /* Now build new password string */
1527 temp_len
= strlen(value
);
1528 vol
->password
= kzalloc(temp_len
+1, GFP_KERNEL
);
1529 if (vol
->password
== NULL
) {
1530 printk(KERN_WARNING
"CIFS: no memory "
1532 goto cifs_parse_mount_err
;
1535 for (i
= 0, j
= 0; i
< temp_len
; i
++, j
++) {
1536 vol
->password
[j
] = value
[i
];
1537 if ((value
[i
] == delim
) &&
1538 value
[i
+1] == delim
)
1539 /* skip the second deliminator */
1542 vol
->password
[j
] = '\0';
1548 string
= match_strdup(args
);
1552 if (strnlen(string
, INET6_ADDRSTRLEN
) >
1554 printk(KERN_WARNING
"CIFS: ip address "
1556 goto cifs_parse_mount_err
;
1558 vol
->UNCip
= kstrdup(string
, GFP_KERNEL
);
1560 printk(KERN_WARNING
"CIFS: no memory "
1562 goto cifs_parse_mount_err
;
1566 string
= match_strdup(args
);
1570 temp_len
= strnlen(string
, 300);
1571 if (temp_len
== 300) {
1572 printk(KERN_WARNING
"CIFS: UNC name too long\n");
1573 goto cifs_parse_mount_err
;
1576 vol
->UNC
= kmalloc(temp_len
+1, GFP_KERNEL
);
1577 if (vol
->UNC
== NULL
) {
1578 printk(KERN_WARNING
"CIFS: no memory for UNC\n");
1579 goto cifs_parse_mount_err
;
1581 strcpy(vol
->UNC
, string
);
1583 if (strncmp(string
, "//", 2) == 0) {
1586 } else if (strncmp(string
, "\\\\", 2) != 0) {
1587 printk(KERN_WARNING
"CIFS: UNC Path does not "
1588 "begin with // or \\\\\n");
1589 goto cifs_parse_mount_err
;
1594 string
= match_strdup(args
);
1598 if (strnlen(string
, 256) == 256) {
1599 printk(KERN_WARNING
"CIFS: domain name too"
1601 goto cifs_parse_mount_err
;
1604 vol
->domainname
= kstrdup(string
, GFP_KERNEL
);
1605 if (!vol
->domainname
) {
1606 printk(KERN_WARNING
"CIFS: no memory "
1607 "for domainname\n");
1608 goto cifs_parse_mount_err
;
1610 cFYI(1, "Domain name set");
1613 string
= match_strdup(args
);
1617 if (!cifs_convert_address(
1618 (struct sockaddr
*)&vol
->srcaddr
,
1619 string
, strlen(string
))) {
1620 printk(KERN_WARNING
"CIFS: Could not parse"
1621 " srcaddr: %s\n", string
);
1622 goto cifs_parse_mount_err
;
1625 case Opt_prefixpath
:
1626 string
= match_strdup(args
);
1630 temp_len
= strnlen(string
, 1024);
1631 if (string
[0] != '/')
1632 temp_len
++; /* missing leading slash */
1633 if (temp_len
> 1024) {
1634 printk(KERN_WARNING
"CIFS: prefix too long\n");
1635 goto cifs_parse_mount_err
;
1638 vol
->prepath
= kmalloc(temp_len
+1, GFP_KERNEL
);
1639 if (vol
->prepath
== NULL
) {
1640 printk(KERN_WARNING
"CIFS: no memory "
1641 "for path prefix\n");
1642 goto cifs_parse_mount_err
;
1645 if (string
[0] != '/') {
1646 vol
->prepath
[0] = '/';
1647 strcpy(vol
->prepath
+1, string
);
1649 strcpy(vol
->prepath
, string
);
1653 string
= match_strdup(args
);
1657 if (strnlen(string
, 1024) >= 65) {
1658 printk(KERN_WARNING
"CIFS: iocharset name "
1660 goto cifs_parse_mount_err
;
1663 if (strnicmp(string
, "default", 7) != 0) {
1664 vol
->iocharset
= kstrdup(string
,
1666 if (!vol
->iocharset
) {
1667 printk(KERN_WARNING
"CIFS: no memory"
1669 goto cifs_parse_mount_err
;
1672 /* if iocharset not set then load_nls_default
1675 cFYI(1, "iocharset set to %s", string
);
1678 string
= match_strdup(args
);
1682 if (strnicmp(string
, "TCP_NODELAY", 11) == 0) {
1683 printk(KERN_WARNING
"CIFS: the "
1684 "sockopt=TCP_NODELAY option has been "
1685 "deprecated and will be removed "
1687 vol
->sockopt_tcp_nodelay
= 1;
1690 case Opt_netbiosname
:
1691 string
= match_strdup(args
);
1695 memset(vol
->source_rfc1001_name
, 0x20,
1698 * FIXME: are there cases in which a comma can
1699 * be valid in workstation netbios name (and
1700 * need special handling)?
1702 for (i
= 0; i
< RFC1001_NAME_LEN
; i
++) {
1703 /* don't ucase netbiosname for user */
1706 vol
->source_rfc1001_name
[i
] = string
[i
];
1708 /* The string has 16th byte zero still from
1709 * set at top of the function
1711 if (i
== RFC1001_NAME_LEN
&& string
[i
] != 0)
1712 printk(KERN_WARNING
"CIFS: netbiosname"
1713 " longer than 15 truncated.\n");
1717 /* servernetbiosname specified override *SMBSERVER */
1718 string
= match_strdup(args
);
1722 /* last byte, type, is 0x20 for servr type */
1723 memset(vol
->target_rfc1001_name
, 0x20,
1724 RFC1001_NAME_LEN_WITH_NULL
);
1726 /* BB are there cases in which a comma can be
1727 valid in this workstation netbios name
1728 (and need special handling)? */
1730 /* user or mount helper must uppercase the
1732 for (i
= 0; i
< 15; i
++) {
1735 vol
->target_rfc1001_name
[i
] = string
[i
];
1737 /* The string has 16th byte zero still from
1738 set at top of the function */
1739 if (i
== RFC1001_NAME_LEN
&& string
[i
] != 0)
1740 printk(KERN_WARNING
"CIFS: server net"
1741 "biosname longer than 15 truncated.\n");
1744 string
= match_strdup(args
);
1748 if (strnicmp(string
, "1", 1) == 0) {
1749 /* This is the default */
1752 /* For all other value, error */
1753 printk(KERN_WARNING
"CIFS: Invalid version"
1755 goto cifs_parse_mount_err
;
1757 string
= match_strdup(args
);
1761 if (cifs_parse_smb_version(string
, vol
) != 0)
1762 goto cifs_parse_mount_err
;
1765 string
= match_strdup(args
);
1769 if (cifs_parse_security_flavors(string
, vol
) != 0)
1770 goto cifs_parse_mount_err
;
1773 string
= match_strdup(args
);
1777 if (cifs_parse_cache_flavor(string
, vol
) != 0)
1778 goto cifs_parse_mount_err
;
1782 * An option we don't recognize. Save it off for later
1783 * if we haven't already found one
1789 /* Free up any allocated string */
1794 if (!sloppy
&& invalid
) {
1795 printk(KERN_ERR
"CIFS: Unknown mount option \"%s\"\n", invalid
);
1796 goto cifs_parse_mount_err
;
1800 /* Muliuser mounts require CONFIG_KEYS support */
1801 if (vol
->multiuser
) {
1802 cERROR(1, "Multiuser mounts require kernels with "
1803 "CONFIG_KEYS enabled.");
1804 goto cifs_parse_mount_err
;
1808 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
1809 "unc=\\\\192.168.1.100\\public) specified");
1810 goto cifs_parse_mount_err
;
1813 if (vol
->UNCip
== NULL
)
1814 vol
->UNCip
= &vol
->UNC
[2];
1817 vol
->override_uid
= override_uid
;
1818 else if (override_uid
== 1)
1819 printk(KERN_NOTICE
"CIFS: ignoring forceuid mount option "
1820 "specified with no uid= option.\n");
1823 vol
->override_gid
= override_gid
;
1824 else if (override_gid
== 1)
1825 printk(KERN_NOTICE
"CIFS: ignoring forcegid mount option "
1826 "specified with no gid= option.\n");
1828 kfree(mountdata_copy
);
1832 printk(KERN_WARNING
"Could not allocate temporary buffer\n");
1833 cifs_parse_mount_err
:
1835 kfree(mountdata_copy
);
1839 /** Returns true if srcaddr isn't specified and rhs isn't
1840 * specified, or if srcaddr is specified and
1841 * matches the IP address of the rhs argument.
1844 srcip_matches(struct sockaddr
*srcaddr
, struct sockaddr
*rhs
)
1846 switch (srcaddr
->sa_family
) {
1848 return (rhs
->sa_family
== AF_UNSPEC
);
1850 struct sockaddr_in
*saddr4
= (struct sockaddr_in
*)srcaddr
;
1851 struct sockaddr_in
*vaddr4
= (struct sockaddr_in
*)rhs
;
1852 return (saddr4
->sin_addr
.s_addr
== vaddr4
->sin_addr
.s_addr
);
1855 struct sockaddr_in6
*saddr6
= (struct sockaddr_in6
*)srcaddr
;
1856 struct sockaddr_in6
*vaddr6
= (struct sockaddr_in6
*)&rhs
;
1857 return ipv6_addr_equal(&saddr6
->sin6_addr
, &vaddr6
->sin6_addr
);
1861 return false; /* don't expect to be here */
1866 * If no port is specified in addr structure, we try to match with 445 port
1867 * and if it fails - with 139 ports. It should be called only if address
1868 * families of server and addr are equal.
1871 match_port(struct TCP_Server_Info
*server
, struct sockaddr
*addr
)
1873 __be16 port
, *sport
;
1875 switch (addr
->sa_family
) {
1877 sport
= &((struct sockaddr_in
*) &server
->dstaddr
)->sin_port
;
1878 port
= ((struct sockaddr_in
*) addr
)->sin_port
;
1881 sport
= &((struct sockaddr_in6
*) &server
->dstaddr
)->sin6_port
;
1882 port
= ((struct sockaddr_in6
*) addr
)->sin6_port
;
1890 port
= htons(CIFS_PORT
);
1894 port
= htons(RFC1001_PORT
);
1897 return port
== *sport
;
1901 match_address(struct TCP_Server_Info
*server
, struct sockaddr
*addr
,
1902 struct sockaddr
*srcaddr
)
1904 switch (addr
->sa_family
) {
1906 struct sockaddr_in
*addr4
= (struct sockaddr_in
*)addr
;
1907 struct sockaddr_in
*srv_addr4
=
1908 (struct sockaddr_in
*)&server
->dstaddr
;
1910 if (addr4
->sin_addr
.s_addr
!= srv_addr4
->sin_addr
.s_addr
)
1915 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)addr
;
1916 struct sockaddr_in6
*srv_addr6
=
1917 (struct sockaddr_in6
*)&server
->dstaddr
;
1919 if (!ipv6_addr_equal(&addr6
->sin6_addr
,
1920 &srv_addr6
->sin6_addr
))
1922 if (addr6
->sin6_scope_id
!= srv_addr6
->sin6_scope_id
)
1928 return false; /* don't expect to be here */
1931 if (!srcip_matches(srcaddr
, (struct sockaddr
*)&server
->srcaddr
))
1938 match_security(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
1940 unsigned int secFlags
;
1942 if (vol
->secFlg
& (~(CIFSSEC_MUST_SIGN
| CIFSSEC_MUST_SEAL
)))
1943 secFlags
= vol
->secFlg
;
1945 secFlags
= global_secflags
| vol
->secFlg
;
1947 switch (server
->secType
) {
1949 if (!(secFlags
& (CIFSSEC_MAY_LANMAN
|CIFSSEC_MAY_PLNTXT
)))
1953 if (!(secFlags
& CIFSSEC_MAY_NTLMV2
))
1957 if (!(secFlags
& CIFSSEC_MAY_NTLM
))
1961 if (!(secFlags
& CIFSSEC_MAY_KRB5
))
1965 if (!(secFlags
& CIFSSEC_MAY_NTLMSSP
))
1969 /* shouldn't happen */
1973 /* now check if signing mode is acceptable */
1974 if ((secFlags
& CIFSSEC_MAY_SIGN
) == 0 &&
1975 (server
->sec_mode
& SECMODE_SIGN_REQUIRED
))
1977 else if (((secFlags
& CIFSSEC_MUST_SIGN
) == CIFSSEC_MUST_SIGN
) &&
1979 (SECMODE_SIGN_ENABLED
|SECMODE_SIGN_REQUIRED
)) == 0)
1985 static int match_server(struct TCP_Server_Info
*server
, struct sockaddr
*addr
,
1986 struct smb_vol
*vol
)
1988 if ((server
->vals
!= vol
->vals
) || (server
->ops
!= vol
->ops
))
1991 if (!net_eq(cifs_net_ns(server
), current
->nsproxy
->net_ns
))
1994 if (!match_address(server
, addr
,
1995 (struct sockaddr
*)&vol
->srcaddr
))
1998 if (!match_port(server
, addr
))
2001 if (!match_security(server
, vol
))
2007 static struct TCP_Server_Info
*
2008 cifs_find_tcp_session(struct sockaddr
*addr
, struct smb_vol
*vol
)
2010 struct TCP_Server_Info
*server
;
2012 spin_lock(&cifs_tcp_ses_lock
);
2013 list_for_each_entry(server
, &cifs_tcp_ses_list
, tcp_ses_list
) {
2014 if (!match_server(server
, addr
, vol
))
2017 ++server
->srv_count
;
2018 spin_unlock(&cifs_tcp_ses_lock
);
2019 cFYI(1, "Existing tcp session with server found");
2022 spin_unlock(&cifs_tcp_ses_lock
);
2027 cifs_put_tcp_session(struct TCP_Server_Info
*server
)
2029 struct task_struct
*task
;
2031 spin_lock(&cifs_tcp_ses_lock
);
2032 if (--server
->srv_count
> 0) {
2033 spin_unlock(&cifs_tcp_ses_lock
);
2037 put_net(cifs_net_ns(server
));
2039 list_del_init(&server
->tcp_ses_list
);
2040 spin_unlock(&cifs_tcp_ses_lock
);
2042 cancel_delayed_work_sync(&server
->echo
);
2044 spin_lock(&GlobalMid_Lock
);
2045 server
->tcpStatus
= CifsExiting
;
2046 spin_unlock(&GlobalMid_Lock
);
2048 cifs_crypto_shash_release(server
);
2049 cifs_fscache_release_client_cookie(server
);
2051 kfree(server
->session_key
.response
);
2052 server
->session_key
.response
= NULL
;
2053 server
->session_key
.len
= 0;
2055 task
= xchg(&server
->tsk
, NULL
);
2057 force_sig(SIGKILL
, task
);
2060 static struct TCP_Server_Info
*
2061 cifs_get_tcp_session(struct smb_vol
*volume_info
)
2063 struct TCP_Server_Info
*tcp_ses
= NULL
;
2064 struct sockaddr_storage addr
;
2065 struct sockaddr_in
*sin_server
= (struct sockaddr_in
*) &addr
;
2066 struct sockaddr_in6
*sin_server6
= (struct sockaddr_in6
*) &addr
;
2069 memset(&addr
, 0, sizeof(struct sockaddr_storage
));
2071 cFYI(1, "UNC: %s ip: %s", volume_info
->UNC
, volume_info
->UNCip
);
2073 if (volume_info
->UNCip
&& volume_info
->UNC
) {
2074 rc
= cifs_fill_sockaddr((struct sockaddr
*)&addr
,
2076 strlen(volume_info
->UNCip
),
2079 /* we failed translating address */
2085 /* see if we already have a matching tcp_ses */
2086 tcp_ses
= cifs_find_tcp_session((struct sockaddr
*)&addr
, volume_info
);
2090 tcp_ses
= kzalloc(sizeof(struct TCP_Server_Info
), GFP_KERNEL
);
2096 rc
= cifs_crypto_shash_allocate(tcp_ses
);
2098 cERROR(1, "could not setup hash structures rc %d", rc
);
2102 tcp_ses
->ops
= volume_info
->ops
;
2103 tcp_ses
->vals
= volume_info
->vals
;
2104 cifs_set_net_ns(tcp_ses
, get_net(current
->nsproxy
->net_ns
));
2105 tcp_ses
->hostname
= extract_hostname(volume_info
->UNC
);
2106 if (IS_ERR(tcp_ses
->hostname
)) {
2107 rc
= PTR_ERR(tcp_ses
->hostname
);
2108 goto out_err_crypto_release
;
2111 tcp_ses
->noblocksnd
= volume_info
->noblocksnd
;
2112 tcp_ses
->noautotune
= volume_info
->noautotune
;
2113 tcp_ses
->tcp_nodelay
= volume_info
->sockopt_tcp_nodelay
;
2114 tcp_ses
->in_flight
= 0;
2115 tcp_ses
->credits
= 1;
2116 init_waitqueue_head(&tcp_ses
->response_q
);
2117 init_waitqueue_head(&tcp_ses
->request_q
);
2118 INIT_LIST_HEAD(&tcp_ses
->pending_mid_q
);
2119 mutex_init(&tcp_ses
->srv_mutex
);
2120 memcpy(tcp_ses
->workstation_RFC1001_name
,
2121 volume_info
->source_rfc1001_name
, RFC1001_NAME_LEN_WITH_NULL
);
2122 memcpy(tcp_ses
->server_RFC1001_name
,
2123 volume_info
->target_rfc1001_name
, RFC1001_NAME_LEN_WITH_NULL
);
2124 tcp_ses
->session_estab
= false;
2125 tcp_ses
->sequence_number
= 0;
2126 tcp_ses
->lstrp
= jiffies
;
2127 spin_lock_init(&tcp_ses
->req_lock
);
2128 INIT_LIST_HEAD(&tcp_ses
->tcp_ses_list
);
2129 INIT_LIST_HEAD(&tcp_ses
->smb_ses_list
);
2130 INIT_DELAYED_WORK(&tcp_ses
->echo
, cifs_echo_request
);
2133 * at this point we are the only ones with the pointer
2134 * to the struct since the kernel thread not created yet
2135 * no need to spinlock this init of tcpStatus or srv_count
2137 tcp_ses
->tcpStatus
= CifsNew
;
2138 memcpy(&tcp_ses
->srcaddr
, &volume_info
->srcaddr
,
2139 sizeof(tcp_ses
->srcaddr
));
2140 ++tcp_ses
->srv_count
;
2142 if (addr
.ss_family
== AF_INET6
) {
2143 cFYI(1, "attempting ipv6 connect");
2144 /* BB should we allow ipv6 on port 139? */
2145 /* other OS never observed in Wild doing 139 with v6 */
2146 memcpy(&tcp_ses
->dstaddr
, sin_server6
,
2147 sizeof(struct sockaddr_in6
));
2149 memcpy(&tcp_ses
->dstaddr
, sin_server
,
2150 sizeof(struct sockaddr_in
));
2152 rc
= ip_connect(tcp_ses
);
2154 cERROR(1, "Error connecting to socket. Aborting operation");
2155 goto out_err_crypto_release
;
2159 * since we're in a cifs function already, we know that
2160 * this will succeed. No need for try_module_get().
2162 __module_get(THIS_MODULE
);
2163 tcp_ses
->tsk
= kthread_run(cifs_demultiplex_thread
,
2165 if (IS_ERR(tcp_ses
->tsk
)) {
2166 rc
= PTR_ERR(tcp_ses
->tsk
);
2167 cERROR(1, "error %d create cifsd thread", rc
);
2168 module_put(THIS_MODULE
);
2169 goto out_err_crypto_release
;
2171 tcp_ses
->tcpStatus
= CifsNeedNegotiate
;
2173 /* thread spawned, put it on the list */
2174 spin_lock(&cifs_tcp_ses_lock
);
2175 list_add(&tcp_ses
->tcp_ses_list
, &cifs_tcp_ses_list
);
2176 spin_unlock(&cifs_tcp_ses_lock
);
2178 cifs_fscache_get_client_cookie(tcp_ses
);
2180 /* queue echo request delayed work */
2181 queue_delayed_work(cifsiod_wq
, &tcp_ses
->echo
, SMB_ECHO_INTERVAL
);
2185 out_err_crypto_release
:
2186 cifs_crypto_shash_release(tcp_ses
);
2188 put_net(cifs_net_ns(tcp_ses
));
2192 if (!IS_ERR(tcp_ses
->hostname
))
2193 kfree(tcp_ses
->hostname
);
2194 if (tcp_ses
->ssocket
)
2195 sock_release(tcp_ses
->ssocket
);
2201 static int match_session(struct cifs_ses
*ses
, struct smb_vol
*vol
)
2203 switch (ses
->server
->secType
) {
2205 if (vol
->cred_uid
!= ses
->cred_uid
)
2209 /* NULL username means anonymous session */
2210 if (ses
->user_name
== NULL
) {
2216 /* anything else takes username/password */
2217 if (strncmp(ses
->user_name
,
2218 vol
->username
? vol
->username
: "",
2221 if (strlen(vol
->username
) != 0 &&
2222 ses
->password
!= NULL
&&
2223 strncmp(ses
->password
,
2224 vol
->password
? vol
->password
: "",
2231 static struct cifs_ses
*
2232 cifs_find_smb_ses(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
2234 struct cifs_ses
*ses
;
2236 spin_lock(&cifs_tcp_ses_lock
);
2237 list_for_each_entry(ses
, &server
->smb_ses_list
, smb_ses_list
) {
2238 if (!match_session(ses
, vol
))
2241 spin_unlock(&cifs_tcp_ses_lock
);
2244 spin_unlock(&cifs_tcp_ses_lock
);
2249 cifs_put_smb_ses(struct cifs_ses
*ses
)
2252 struct TCP_Server_Info
*server
= ses
->server
;
2254 cFYI(1, "%s: ses_count=%d", __func__
, ses
->ses_count
);
2255 spin_lock(&cifs_tcp_ses_lock
);
2256 if (--ses
->ses_count
> 0) {
2257 spin_unlock(&cifs_tcp_ses_lock
);
2261 list_del_init(&ses
->smb_ses_list
);
2262 spin_unlock(&cifs_tcp_ses_lock
);
2264 if (ses
->status
== CifsGood
&& server
->ops
->logoff
) {
2266 server
->ops
->logoff(xid
, ses
);
2270 cifs_put_tcp_session(server
);
2275 /* strlen("cifs:a:") + INET6_ADDRSTRLEN + 1 */
2276 #define CIFSCREDS_DESC_SIZE (7 + INET6_ADDRSTRLEN + 1)
2278 /* Populate username and pw fields from keyring if possible */
2280 cifs_set_cifscreds(struct smb_vol
*vol
, struct cifs_ses
*ses
)
2283 char *desc
, *delim
, *payload
;
2286 struct TCP_Server_Info
*server
= ses
->server
;
2287 struct sockaddr_in
*sa
;
2288 struct sockaddr_in6
*sa6
;
2289 struct user_key_payload
*upayload
;
2291 desc
= kmalloc(CIFSCREDS_DESC_SIZE
, GFP_KERNEL
);
2295 /* try to find an address key first */
2296 switch (server
->dstaddr
.ss_family
) {
2298 sa
= (struct sockaddr_in
*)&server
->dstaddr
;
2299 sprintf(desc
, "cifs:a:%pI4", &sa
->sin_addr
.s_addr
);
2302 sa6
= (struct sockaddr_in6
*)&server
->dstaddr
;
2303 sprintf(desc
, "cifs:a:%pI6c", &sa6
->sin6_addr
.s6_addr
);
2306 cFYI(1, "Bad ss_family (%hu)", server
->dstaddr
.ss_family
);
2311 cFYI(1, "%s: desc=%s", __func__
, desc
);
2312 key
= request_key(&key_type_logon
, desc
, "");
2314 if (!ses
->domainName
) {
2315 cFYI(1, "domainName is NULL");
2320 /* didn't work, try to find a domain key */
2321 sprintf(desc
, "cifs:d:%s", ses
->domainName
);
2322 cFYI(1, "%s: desc=%s", __func__
, desc
);
2323 key
= request_key(&key_type_logon
, desc
, "");
2330 down_read(&key
->sem
);
2331 upayload
= key
->payload
.data
;
2332 if (IS_ERR_OR_NULL(upayload
)) {
2333 rc
= upayload
? PTR_ERR(upayload
) : -EINVAL
;
2337 /* find first : in payload */
2338 payload
= (char *)upayload
->data
;
2339 delim
= strnchr(payload
, upayload
->datalen
, ':');
2340 cFYI(1, "payload=%s", payload
);
2342 cFYI(1, "Unable to find ':' in payload (datalen=%d)",
2348 len
= delim
- payload
;
2349 if (len
> MAX_USERNAME_SIZE
|| len
<= 0) {
2350 cFYI(1, "Bad value from username search (len=%zd)", len
);
2355 vol
->username
= kstrndup(payload
, len
, GFP_KERNEL
);
2356 if (!vol
->username
) {
2357 cFYI(1, "Unable to allocate %zd bytes for username", len
);
2361 cFYI(1, "%s: username=%s", __func__
, vol
->username
);
2363 len
= key
->datalen
- (len
+ 1);
2364 if (len
> MAX_PASSWORD_SIZE
|| len
<= 0) {
2365 cFYI(1, "Bad len for password search (len=%zd)", len
);
2367 kfree(vol
->username
);
2368 vol
->username
= NULL
;
2373 vol
->password
= kstrndup(delim
, len
, GFP_KERNEL
);
2374 if (!vol
->password
) {
2375 cFYI(1, "Unable to allocate %zd bytes for password", len
);
2377 kfree(vol
->username
);
2378 vol
->username
= NULL
;
2387 cFYI(1, "%s: returning %d", __func__
, rc
);
2390 #else /* ! CONFIG_KEYS */
2392 cifs_set_cifscreds(struct smb_vol
*vol
__attribute__((unused
)),
2393 struct cifs_ses
*ses
__attribute__((unused
)))
2397 #endif /* CONFIG_KEYS */
2399 static struct cifs_ses
*
2400 cifs_get_smb_ses(struct TCP_Server_Info
*server
, struct smb_vol
*volume_info
)
2404 struct cifs_ses
*ses
;
2405 struct sockaddr_in
*addr
= (struct sockaddr_in
*)&server
->dstaddr
;
2406 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)&server
->dstaddr
;
2410 ses
= cifs_find_smb_ses(server
, volume_info
);
2412 cFYI(1, "Existing smb sess found (status=%d)", ses
->status
);
2414 mutex_lock(&ses
->session_mutex
);
2415 rc
= cifs_negotiate_protocol(xid
, ses
);
2417 mutex_unlock(&ses
->session_mutex
);
2418 /* problem -- put our ses reference */
2419 cifs_put_smb_ses(ses
);
2423 if (ses
->need_reconnect
) {
2424 cFYI(1, "Session needs reconnect");
2425 rc
= cifs_setup_session(xid
, ses
,
2426 volume_info
->local_nls
);
2428 mutex_unlock(&ses
->session_mutex
);
2429 /* problem -- put our reference */
2430 cifs_put_smb_ses(ses
);
2435 mutex_unlock(&ses
->session_mutex
);
2437 /* existing SMB ses has a server reference already */
2438 cifs_put_tcp_session(server
);
2443 cFYI(1, "Existing smb sess not found");
2444 ses
= sesInfoAlloc();
2448 /* new SMB session uses our server ref */
2449 ses
->server
= server
;
2450 if (server
->dstaddr
.ss_family
== AF_INET6
)
2451 sprintf(ses
->serverName
, "%pI6", &addr6
->sin6_addr
);
2453 sprintf(ses
->serverName
, "%pI4", &addr
->sin_addr
);
2455 if (volume_info
->username
) {
2456 ses
->user_name
= kstrdup(volume_info
->username
, GFP_KERNEL
);
2457 if (!ses
->user_name
)
2461 /* volume_info->password freed at unmount */
2462 if (volume_info
->password
) {
2463 ses
->password
= kstrdup(volume_info
->password
, GFP_KERNEL
);
2467 if (volume_info
->domainname
) {
2468 ses
->domainName
= kstrdup(volume_info
->domainname
, GFP_KERNEL
);
2469 if (!ses
->domainName
)
2472 ses
->cred_uid
= volume_info
->cred_uid
;
2473 ses
->linux_uid
= volume_info
->linux_uid
;
2475 ses
->overrideSecFlg
= volume_info
->secFlg
;
2477 mutex_lock(&ses
->session_mutex
);
2478 rc
= cifs_negotiate_protocol(xid
, ses
);
2480 rc
= cifs_setup_session(xid
, ses
, volume_info
->local_nls
);
2481 mutex_unlock(&ses
->session_mutex
);
2485 /* success, put it on the list */
2486 spin_lock(&cifs_tcp_ses_lock
);
2487 list_add(&ses
->smb_ses_list
, &server
->smb_ses_list
);
2488 spin_unlock(&cifs_tcp_ses_lock
);
2499 static int match_tcon(struct cifs_tcon
*tcon
, const char *unc
)
2501 if (tcon
->tidStatus
== CifsExiting
)
2503 if (strncmp(tcon
->treeName
, unc
, MAX_TREE_SIZE
))
2508 static struct cifs_tcon
*
2509 cifs_find_tcon(struct cifs_ses
*ses
, const char *unc
)
2511 struct list_head
*tmp
;
2512 struct cifs_tcon
*tcon
;
2514 spin_lock(&cifs_tcp_ses_lock
);
2515 list_for_each(tmp
, &ses
->tcon_list
) {
2516 tcon
= list_entry(tmp
, struct cifs_tcon
, tcon_list
);
2517 if (!match_tcon(tcon
, unc
))
2520 spin_unlock(&cifs_tcp_ses_lock
);
2523 spin_unlock(&cifs_tcp_ses_lock
);
2528 cifs_put_tcon(struct cifs_tcon
*tcon
)
2531 struct cifs_ses
*ses
= tcon
->ses
;
2533 cFYI(1, "%s: tc_count=%d", __func__
, tcon
->tc_count
);
2534 spin_lock(&cifs_tcp_ses_lock
);
2535 if (--tcon
->tc_count
> 0) {
2536 spin_unlock(&cifs_tcp_ses_lock
);
2540 list_del_init(&tcon
->tcon_list
);
2541 spin_unlock(&cifs_tcp_ses_lock
);
2544 if (ses
->server
->ops
->tree_disconnect
)
2545 ses
->server
->ops
->tree_disconnect(xid
, tcon
);
2548 cifs_fscache_release_super_cookie(tcon
);
2550 cifs_put_smb_ses(ses
);
2553 static struct cifs_tcon
*
2554 cifs_get_tcon(struct cifs_ses
*ses
, struct smb_vol
*volume_info
)
2557 struct cifs_tcon
*tcon
;
2559 tcon
= cifs_find_tcon(ses
, volume_info
->UNC
);
2561 cFYI(1, "Found match on UNC path");
2562 /* existing tcon already has a reference */
2563 cifs_put_smb_ses(ses
);
2564 if (tcon
->seal
!= volume_info
->seal
)
2565 cERROR(1, "transport encryption setting "
2566 "conflicts with existing tid");
2570 if (!ses
->server
->ops
->tree_connect
) {
2575 tcon
= tconInfoAlloc();
2582 if (volume_info
->password
) {
2583 tcon
->password
= kstrdup(volume_info
->password
, GFP_KERNEL
);
2584 if (!tcon
->password
) {
2590 if (strchr(volume_info
->UNC
+ 3, '\\') == NULL
2591 && strchr(volume_info
->UNC
+ 3, '/') == NULL
) {
2592 cERROR(1, "Missing share name");
2598 * BB Do we need to wrap session_mutex around this TCon call and Unix
2599 * SetFS as we do on SessSetup and reconnect?
2602 rc
= ses
->server
->ops
->tree_connect(xid
, ses
, volume_info
->UNC
, tcon
,
2603 volume_info
->local_nls
);
2605 cFYI(1, "Tcon rc = %d", rc
);
2609 if (volume_info
->nodfs
) {
2610 tcon
->Flags
&= ~SMB_SHARE_IS_IN_DFS
;
2611 cFYI(1, "DFS disabled (%d)", tcon
->Flags
);
2613 tcon
->seal
= volume_info
->seal
;
2615 * We can have only one retry value for a connection to a share so for
2616 * resources mounted more than once to the same server share the last
2617 * value passed in for the retry flag is used.
2619 tcon
->retry
= volume_info
->retry
;
2620 tcon
->nocase
= volume_info
->nocase
;
2621 tcon
->local_lease
= volume_info
->local_lease
;
2622 INIT_LIST_HEAD(&tcon
->pending_opens
);
2624 spin_lock(&cifs_tcp_ses_lock
);
2625 list_add(&tcon
->tcon_list
, &ses
->tcon_list
);
2626 spin_unlock(&cifs_tcp_ses_lock
);
2628 cifs_fscache_get_super_cookie(tcon
);
2638 cifs_put_tlink(struct tcon_link
*tlink
)
2640 if (!tlink
|| IS_ERR(tlink
))
2643 if (!atomic_dec_and_test(&tlink
->tl_count
) ||
2644 test_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
)) {
2645 tlink
->tl_time
= jiffies
;
2649 if (!IS_ERR(tlink_tcon(tlink
)))
2650 cifs_put_tcon(tlink_tcon(tlink
));
2655 static inline struct tcon_link
*
2656 cifs_sb_master_tlink(struct cifs_sb_info
*cifs_sb
)
2658 return cifs_sb
->master_tlink
;
2662 compare_mount_options(struct super_block
*sb
, struct cifs_mnt_data
*mnt_data
)
2664 struct cifs_sb_info
*old
= CIFS_SB(sb
);
2665 struct cifs_sb_info
*new = mnt_data
->cifs_sb
;
2667 if ((sb
->s_flags
& CIFS_MS_MASK
) != (mnt_data
->flags
& CIFS_MS_MASK
))
2670 if ((old
->mnt_cifs_flags
& CIFS_MOUNT_MASK
) !=
2671 (new->mnt_cifs_flags
& CIFS_MOUNT_MASK
))
2675 * We want to share sb only if we don't specify an r/wsize or
2676 * specified r/wsize is greater than or equal to existing one.
2678 if (new->wsize
&& new->wsize
< old
->wsize
)
2681 if (new->rsize
&& new->rsize
< old
->rsize
)
2684 if (old
->mnt_uid
!= new->mnt_uid
|| old
->mnt_gid
!= new->mnt_gid
)
2687 if (old
->mnt_file_mode
!= new->mnt_file_mode
||
2688 old
->mnt_dir_mode
!= new->mnt_dir_mode
)
2691 if (strcmp(old
->local_nls
->charset
, new->local_nls
->charset
))
2694 if (old
->actimeo
!= new->actimeo
)
2701 cifs_match_super(struct super_block
*sb
, void *data
)
2703 struct cifs_mnt_data
*mnt_data
= (struct cifs_mnt_data
*)data
;
2704 struct smb_vol
*volume_info
;
2705 struct cifs_sb_info
*cifs_sb
;
2706 struct TCP_Server_Info
*tcp_srv
;
2707 struct cifs_ses
*ses
;
2708 struct cifs_tcon
*tcon
;
2709 struct tcon_link
*tlink
;
2710 struct sockaddr_storage addr
;
2713 memset(&addr
, 0, sizeof(struct sockaddr_storage
));
2715 spin_lock(&cifs_tcp_ses_lock
);
2716 cifs_sb
= CIFS_SB(sb
);
2717 tlink
= cifs_get_tlink(cifs_sb_master_tlink(cifs_sb
));
2718 if (IS_ERR(tlink
)) {
2719 spin_unlock(&cifs_tcp_ses_lock
);
2722 tcon
= tlink_tcon(tlink
);
2724 tcp_srv
= ses
->server
;
2726 volume_info
= mnt_data
->vol
;
2728 rc
= cifs_fill_sockaddr((struct sockaddr
*)&addr
,
2730 strlen(volume_info
->UNCip
),
2735 if (!match_server(tcp_srv
, (struct sockaddr
*)&addr
, volume_info
) ||
2736 !match_session(ses
, volume_info
) ||
2737 !match_tcon(tcon
, volume_info
->UNC
)) {
2742 rc
= compare_mount_options(sb
, mnt_data
);
2744 spin_unlock(&cifs_tcp_ses_lock
);
2745 cifs_put_tlink(tlink
);
2750 get_dfs_path(const unsigned int xid
, struct cifs_ses
*ses
, const char *old_path
,
2751 const struct nls_table
*nls_codepage
, unsigned int *num_referrals
,
2752 struct dfs_info3_param
**referrals
, int remap
)
2757 if (!ses
->server
->ops
->tree_connect
|| !ses
->server
->ops
->get_dfs_refer
)
2763 if (ses
->ipc_tid
== 0) {
2764 temp_unc
= kmalloc(2 /* for slashes */ +
2765 strnlen(ses
->serverName
, SERVER_NAME_LEN_WITH_NULL
* 2)
2766 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL
);
2767 if (temp_unc
== NULL
)
2771 strcpy(temp_unc
+ 2, ses
->serverName
);
2772 strcpy(temp_unc
+ 2 + strlen(ses
->serverName
), "\\IPC$");
2773 rc
= ses
->server
->ops
->tree_connect(xid
, ses
, temp_unc
, NULL
,
2775 cFYI(1, "Tcon rc = %d ipc_tid = %d", rc
, ses
->ipc_tid
);
2779 rc
= ses
->server
->ops
->get_dfs_refer(xid
, ses
, old_path
,
2780 referrals
, num_referrals
,
2781 nls_codepage
, remap
);
2783 * BB - map targetUNCs to dfs_info3 structures, here or in
2784 * ses->server->ops->get_dfs_refer.
2790 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2791 static struct lock_class_key cifs_key
[2];
2792 static struct lock_class_key cifs_slock_key
[2];
2795 cifs_reclassify_socket4(struct socket
*sock
)
2797 struct sock
*sk
= sock
->sk
;
2798 BUG_ON(sock_owned_by_user(sk
));
2799 sock_lock_init_class_and_name(sk
, "slock-AF_INET-CIFS",
2800 &cifs_slock_key
[0], "sk_lock-AF_INET-CIFS", &cifs_key
[0]);
2804 cifs_reclassify_socket6(struct socket
*sock
)
2806 struct sock
*sk
= sock
->sk
;
2807 BUG_ON(sock_owned_by_user(sk
));
2808 sock_lock_init_class_and_name(sk
, "slock-AF_INET6-CIFS",
2809 &cifs_slock_key
[1], "sk_lock-AF_INET6-CIFS", &cifs_key
[1]);
2813 cifs_reclassify_socket4(struct socket
*sock
)
2818 cifs_reclassify_socket6(struct socket
*sock
)
2823 /* See RFC1001 section 14 on representation of Netbios names */
2824 static void rfc1002mangle(char *target
, char *source
, unsigned int length
)
2828 for (i
= 0, j
= 0; i
< (length
); i
++) {
2829 /* mask a nibble at a time and encode */
2830 target
[j
] = 'A' + (0x0F & (source
[i
] >> 4));
2831 target
[j
+1] = 'A' + (0x0F & source
[i
]);
2838 bind_socket(struct TCP_Server_Info
*server
)
2841 if (server
->srcaddr
.ss_family
!= AF_UNSPEC
) {
2842 /* Bind to the specified local IP address */
2843 struct socket
*socket
= server
->ssocket
;
2844 rc
= socket
->ops
->bind(socket
,
2845 (struct sockaddr
*) &server
->srcaddr
,
2846 sizeof(server
->srcaddr
));
2848 struct sockaddr_in
*saddr4
;
2849 struct sockaddr_in6
*saddr6
;
2850 saddr4
= (struct sockaddr_in
*)&server
->srcaddr
;
2851 saddr6
= (struct sockaddr_in6
*)&server
->srcaddr
;
2852 if (saddr6
->sin6_family
== AF_INET6
)
2854 "Failed to bind to: %pI6c, error: %d",
2855 &saddr6
->sin6_addr
, rc
);
2858 "Failed to bind to: %pI4, error: %d",
2859 &saddr4
->sin_addr
.s_addr
, rc
);
2866 ip_rfc1001_connect(struct TCP_Server_Info
*server
)
2870 * some servers require RFC1001 sessinit before sending
2871 * negprot - BB check reconnection in case where second
2872 * sessinit is sent but no second negprot
2874 struct rfc1002_session_packet
*ses_init_buf
;
2875 struct smb_hdr
*smb_buf
;
2876 ses_init_buf
= kzalloc(sizeof(struct rfc1002_session_packet
),
2879 ses_init_buf
->trailer
.session_req
.called_len
= 32;
2881 if (server
->server_RFC1001_name
&&
2882 server
->server_RFC1001_name
[0] != 0)
2883 rfc1002mangle(ses_init_buf
->trailer
.
2884 session_req
.called_name
,
2885 server
->server_RFC1001_name
,
2886 RFC1001_NAME_LEN_WITH_NULL
);
2888 rfc1002mangle(ses_init_buf
->trailer
.
2889 session_req
.called_name
,
2890 DEFAULT_CIFS_CALLED_NAME
,
2891 RFC1001_NAME_LEN_WITH_NULL
);
2893 ses_init_buf
->trailer
.session_req
.calling_len
= 32;
2896 * calling name ends in null (byte 16) from old smb
2899 if (server
->workstation_RFC1001_name
&&
2900 server
->workstation_RFC1001_name
[0] != 0)
2901 rfc1002mangle(ses_init_buf
->trailer
.
2902 session_req
.calling_name
,
2903 server
->workstation_RFC1001_name
,
2904 RFC1001_NAME_LEN_WITH_NULL
);
2906 rfc1002mangle(ses_init_buf
->trailer
.
2907 session_req
.calling_name
,
2909 RFC1001_NAME_LEN_WITH_NULL
);
2911 ses_init_buf
->trailer
.session_req
.scope1
= 0;
2912 ses_init_buf
->trailer
.session_req
.scope2
= 0;
2913 smb_buf
= (struct smb_hdr
*)ses_init_buf
;
2915 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2916 smb_buf
->smb_buf_length
= cpu_to_be32(0x81000044);
2917 rc
= smb_send(server
, smb_buf
, 0x44);
2918 kfree(ses_init_buf
);
2920 * RFC1001 layer in at least one server
2921 * requires very short break before negprot
2922 * presumably because not expecting negprot
2923 * to follow so fast. This is a simple
2924 * solution that works without
2925 * complicating the code and causes no
2926 * significant slowing down on mount
2929 usleep_range(1000, 2000);
2932 * else the negprot may still work without this
2933 * even though malloc failed
2940 generic_ip_connect(struct TCP_Server_Info
*server
)
2945 struct socket
*socket
= server
->ssocket
;
2946 struct sockaddr
*saddr
;
2948 saddr
= (struct sockaddr
*) &server
->dstaddr
;
2950 if (server
->dstaddr
.ss_family
== AF_INET6
) {
2951 sport
= ((struct sockaddr_in6
*) saddr
)->sin6_port
;
2952 slen
= sizeof(struct sockaddr_in6
);
2955 sport
= ((struct sockaddr_in
*) saddr
)->sin_port
;
2956 slen
= sizeof(struct sockaddr_in
);
2960 if (socket
== NULL
) {
2961 rc
= __sock_create(cifs_net_ns(server
), sfamily
, SOCK_STREAM
,
2962 IPPROTO_TCP
, &socket
, 1);
2964 cERROR(1, "Error %d creating socket", rc
);
2965 server
->ssocket
= NULL
;
2969 /* BB other socket options to set KEEPALIVE, NODELAY? */
2970 cFYI(1, "Socket created");
2971 server
->ssocket
= socket
;
2972 socket
->sk
->sk_allocation
= GFP_NOFS
;
2973 if (sfamily
== AF_INET6
)
2974 cifs_reclassify_socket6(socket
);
2976 cifs_reclassify_socket4(socket
);
2979 rc
= bind_socket(server
);
2984 * Eventually check for other socket options to change from
2985 * the default. sock_setsockopt not used because it expects
2988 socket
->sk
->sk_rcvtimeo
= 7 * HZ
;
2989 socket
->sk
->sk_sndtimeo
= 5 * HZ
;
2991 /* make the bufsizes depend on wsize/rsize and max requests */
2992 if (server
->noautotune
) {
2993 if (socket
->sk
->sk_sndbuf
< (200 * 1024))
2994 socket
->sk
->sk_sndbuf
= 200 * 1024;
2995 if (socket
->sk
->sk_rcvbuf
< (140 * 1024))
2996 socket
->sk
->sk_rcvbuf
= 140 * 1024;
2999 if (server
->tcp_nodelay
) {
3001 rc
= kernel_setsockopt(socket
, SOL_TCP
, TCP_NODELAY
,
3002 (char *)&val
, sizeof(val
));
3004 cFYI(1, "set TCP_NODELAY socket option error %d", rc
);
3007 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
3008 socket
->sk
->sk_sndbuf
,
3009 socket
->sk
->sk_rcvbuf
, socket
->sk
->sk_rcvtimeo
);
3011 rc
= socket
->ops
->connect(socket
, saddr
, slen
, 0);
3013 cFYI(1, "Error %d connecting to server", rc
);
3014 sock_release(socket
);
3015 server
->ssocket
= NULL
;
3019 if (sport
== htons(RFC1001_PORT
))
3020 rc
= ip_rfc1001_connect(server
);
3026 ip_connect(struct TCP_Server_Info
*server
)
3029 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)&server
->dstaddr
;
3030 struct sockaddr_in
*addr
= (struct sockaddr_in
*)&server
->dstaddr
;
3032 if (server
->dstaddr
.ss_family
== AF_INET6
)
3033 sport
= &addr6
->sin6_port
;
3035 sport
= &addr
->sin_port
;
3040 /* try with 445 port at first */
3041 *sport
= htons(CIFS_PORT
);
3043 rc
= generic_ip_connect(server
);
3047 /* if it failed, try with 139 port */
3048 *sport
= htons(RFC1001_PORT
);
3051 return generic_ip_connect(server
);
3054 void reset_cifs_unix_caps(unsigned int xid
, struct cifs_tcon
*tcon
,
3055 struct cifs_sb_info
*cifs_sb
, struct smb_vol
*vol_info
)
3057 /* if we are reconnecting then should we check to see if
3058 * any requested capabilities changed locally e.g. via
3059 * remount but we can not do much about it here
3060 * if they have (even if we could detect it by the following)
3061 * Perhaps we could add a backpointer to array of sb from tcon
3062 * or if we change to make all sb to same share the same
3063 * sb as NFS - then we only have one backpointer to sb.
3064 * What if we wanted to mount the server share twice once with
3065 * and once without posixacls or posix paths? */
3066 __u64 saved_cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
3068 if (vol_info
&& vol_info
->no_linux_ext
) {
3069 tcon
->fsUnixInfo
.Capability
= 0;
3070 tcon
->unix_ext
= 0; /* Unix Extensions disabled */
3071 cFYI(1, "Linux protocol extensions disabled");
3073 } else if (vol_info
)
3074 tcon
->unix_ext
= 1; /* Unix Extensions supported */
3076 if (tcon
->unix_ext
== 0) {
3077 cFYI(1, "Unix extensions disabled so not set on reconnect");
3081 if (!CIFSSMBQFSUnixInfo(xid
, tcon
)) {
3082 __u64 cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
3083 cFYI(1, "unix caps which server supports %lld", cap
);
3084 /* check for reconnect case in which we do not
3085 want to change the mount behavior if we can avoid it */
3086 if (vol_info
== NULL
) {
3087 /* turn off POSIX ACL and PATHNAMES if not set
3088 originally at mount time */
3089 if ((saved_cap
& CIFS_UNIX_POSIX_ACL_CAP
) == 0)
3090 cap
&= ~CIFS_UNIX_POSIX_ACL_CAP
;
3091 if ((saved_cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) == 0) {
3092 if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)
3093 cERROR(1, "POSIXPATH support change");
3094 cap
&= ~CIFS_UNIX_POSIX_PATHNAMES_CAP
;
3095 } else if ((cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) == 0) {
3096 cERROR(1, "possible reconnect error");
3097 cERROR(1, "server disabled POSIX path support");
3101 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)
3102 cERROR(1, "per-share encryption not supported yet");
3104 cap
&= CIFS_UNIX_CAP_MASK
;
3105 if (vol_info
&& vol_info
->no_psx_acl
)
3106 cap
&= ~CIFS_UNIX_POSIX_ACL_CAP
;
3107 else if (CIFS_UNIX_POSIX_ACL_CAP
& cap
) {
3108 cFYI(1, "negotiated posix acl support");
3110 cifs_sb
->mnt_cifs_flags
|=
3111 CIFS_MOUNT_POSIXACL
;
3114 if (vol_info
&& vol_info
->posix_paths
== 0)
3115 cap
&= ~CIFS_UNIX_POSIX_PATHNAMES_CAP
;
3116 else if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) {
3117 cFYI(1, "negotiate posix pathnames");
3119 cifs_sb
->mnt_cifs_flags
|=
3120 CIFS_MOUNT_POSIX_PATHS
;
3123 cFYI(1, "Negotiate caps 0x%x", (int)cap
);
3124 #ifdef CONFIG_CIFS_DEBUG2
3125 if (cap
& CIFS_UNIX_FCNTL_CAP
)
3126 cFYI(1, "FCNTL cap");
3127 if (cap
& CIFS_UNIX_EXTATTR_CAP
)
3128 cFYI(1, "EXTATTR cap");
3129 if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)
3130 cFYI(1, "POSIX path cap");
3131 if (cap
& CIFS_UNIX_XATTR_CAP
)
3132 cFYI(1, "XATTR cap");
3133 if (cap
& CIFS_UNIX_POSIX_ACL_CAP
)
3134 cFYI(1, "POSIX ACL cap");
3135 if (cap
& CIFS_UNIX_LARGE_READ_CAP
)
3136 cFYI(1, "very large read cap");
3137 if (cap
& CIFS_UNIX_LARGE_WRITE_CAP
)
3138 cFYI(1, "very large write cap");
3139 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP
)
3140 cFYI(1, "transport encryption cap");
3141 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)
3142 cFYI(1, "mandatory transport encryption cap");
3143 #endif /* CIFS_DEBUG2 */
3144 if (CIFSSMBSetFSUnixInfo(xid
, tcon
, cap
)) {
3145 if (vol_info
== NULL
) {
3146 cFYI(1, "resetting capabilities failed");
3148 cERROR(1, "Negotiating Unix capabilities "
3149 "with the server failed. Consider "
3150 "mounting with the Unix Extensions "
3151 "disabled if problems are found "
3152 "by specifying the nounix mount "
3159 void cifs_setup_cifs_sb(struct smb_vol
*pvolume_info
,
3160 struct cifs_sb_info
*cifs_sb
)
3162 INIT_DELAYED_WORK(&cifs_sb
->prune_tlinks
, cifs_prune_tlinks
);
3164 spin_lock_init(&cifs_sb
->tlink_tree_lock
);
3165 cifs_sb
->tlink_tree
= RB_ROOT
;
3168 * Temporarily set r/wsize for matching superblock. If we end up using
3169 * new sb then client will later negotiate it downward if needed.
3171 cifs_sb
->rsize
= pvolume_info
->rsize
;
3172 cifs_sb
->wsize
= pvolume_info
->wsize
;
3174 cifs_sb
->mnt_uid
= pvolume_info
->linux_uid
;
3175 cifs_sb
->mnt_gid
= pvolume_info
->linux_gid
;
3176 cifs_sb
->mnt_file_mode
= pvolume_info
->file_mode
;
3177 cifs_sb
->mnt_dir_mode
= pvolume_info
->dir_mode
;
3178 cFYI(1, "file mode: 0x%hx dir mode: 0x%hx",
3179 cifs_sb
->mnt_file_mode
, cifs_sb
->mnt_dir_mode
);
3181 cifs_sb
->actimeo
= pvolume_info
->actimeo
;
3182 cifs_sb
->local_nls
= pvolume_info
->local_nls
;
3184 if (pvolume_info
->noperm
)
3185 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_PERM
;
3186 if (pvolume_info
->setuids
)
3187 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_SET_UID
;
3188 if (pvolume_info
->server_ino
)
3189 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_SERVER_INUM
;
3190 if (pvolume_info
->remap
)
3191 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MAP_SPECIAL_CHR
;
3192 if (pvolume_info
->no_xattr
)
3193 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_XATTR
;
3194 if (pvolume_info
->sfu_emul
)
3195 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_UNX_EMUL
;
3196 if (pvolume_info
->nobrl
)
3197 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_BRL
;
3198 if (pvolume_info
->nostrictsync
)
3199 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NOSSYNC
;
3200 if (pvolume_info
->mand_lock
)
3201 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NOPOSIXBRL
;
3202 if (pvolume_info
->rwpidforward
)
3203 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_RWPIDFORWARD
;
3204 if (pvolume_info
->cifs_acl
)
3205 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_ACL
;
3206 if (pvolume_info
->backupuid_specified
) {
3207 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_BACKUPUID
;
3208 cifs_sb
->mnt_backupuid
= pvolume_info
->backupuid
;
3210 if (pvolume_info
->backupgid_specified
) {
3211 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_BACKUPGID
;
3212 cifs_sb
->mnt_backupgid
= pvolume_info
->backupgid
;
3214 if (pvolume_info
->override_uid
)
3215 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_OVERR_UID
;
3216 if (pvolume_info
->override_gid
)
3217 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_OVERR_GID
;
3218 if (pvolume_info
->dynperm
)
3219 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_DYNPERM
;
3220 if (pvolume_info
->fsc
)
3221 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_FSCACHE
;
3222 if (pvolume_info
->multiuser
)
3223 cifs_sb
->mnt_cifs_flags
|= (CIFS_MOUNT_MULTIUSER
|
3224 CIFS_MOUNT_NO_PERM
);
3225 if (pvolume_info
->strict_io
)
3226 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_STRICT_IO
;
3227 if (pvolume_info
->direct_io
) {
3228 cFYI(1, "mounting share using direct i/o");
3229 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_DIRECT_IO
;
3231 if (pvolume_info
->mfsymlinks
) {
3232 if (pvolume_info
->sfu_emul
) {
3233 cERROR(1, "mount option mfsymlinks ignored if sfu "
3234 "mount option is used");
3236 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MF_SYMLINKS
;
3240 if ((pvolume_info
->cifs_acl
) && (pvolume_info
->dynperm
))
3241 cERROR(1, "mount option dynperm ignored if cifsacl "
3242 "mount option supported");
3246 cleanup_volume_info_contents(struct smb_vol
*volume_info
)
3248 kfree(volume_info
->username
);
3249 kzfree(volume_info
->password
);
3250 if (volume_info
->UNCip
!= volume_info
->UNC
+ 2)
3251 kfree(volume_info
->UNCip
);
3252 kfree(volume_info
->UNC
);
3253 kfree(volume_info
->domainname
);
3254 kfree(volume_info
->iocharset
);
3255 kfree(volume_info
->prepath
);
3259 cifs_cleanup_volume_info(struct smb_vol
*volume_info
)
3263 cleanup_volume_info_contents(volume_info
);
3268 #ifdef CONFIG_CIFS_DFS_UPCALL
3270 * cifs_build_path_to_root returns full path to root when we do not have an
3271 * exiting connection (tcon)
3274 build_unc_path_to_root(const struct smb_vol
*vol
,
3275 const struct cifs_sb_info
*cifs_sb
)
3277 char *full_path
, *pos
;
3278 unsigned int pplen
= vol
->prepath
? strlen(vol
->prepath
) : 0;
3279 unsigned int unc_len
= strnlen(vol
->UNC
, MAX_TREE_SIZE
+ 1);
3281 full_path
= kmalloc(unc_len
+ pplen
+ 1, GFP_KERNEL
);
3282 if (full_path
== NULL
)
3283 return ERR_PTR(-ENOMEM
);
3285 strncpy(full_path
, vol
->UNC
, unc_len
);
3286 pos
= full_path
+ unc_len
;
3289 strncpy(pos
, vol
->prepath
, pplen
);
3293 *pos
= '\0'; /* add trailing null */
3294 convert_delimiter(full_path
, CIFS_DIR_SEP(cifs_sb
));
3295 cFYI(1, "%s: full_path=%s", __func__
, full_path
);
3300 * Perform a dfs referral query for a share and (optionally) prefix
3302 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3303 * to a string containing updated options for the submount. Otherwise it
3304 * will be left untouched.
3306 * Returns the rc from get_dfs_path to the caller, which can be used to
3307 * determine whether there were referrals.
3310 expand_dfs_referral(const unsigned int xid
, struct cifs_ses
*ses
,
3311 struct smb_vol
*volume_info
, struct cifs_sb_info
*cifs_sb
,
3315 unsigned int num_referrals
= 0;
3316 struct dfs_info3_param
*referrals
= NULL
;
3317 char *full_path
= NULL
, *ref_path
= NULL
, *mdata
= NULL
;
3319 full_path
= build_unc_path_to_root(volume_info
, cifs_sb
);
3320 if (IS_ERR(full_path
))
3321 return PTR_ERR(full_path
);
3323 /* For DFS paths, skip the first '\' of the UNC */
3324 ref_path
= check_prefix
? full_path
+ 1 : volume_info
->UNC
+ 1;
3326 rc
= get_dfs_path(xid
, ses
, ref_path
, cifs_sb
->local_nls
,
3327 &num_referrals
, &referrals
,
3328 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
3330 if (!rc
&& num_referrals
> 0) {
3331 char *fake_devname
= NULL
;
3333 mdata
= cifs_compose_mount_options(cifs_sb
->mountdata
,
3334 full_path
+ 1, referrals
,
3337 free_dfs_info_array(referrals
, num_referrals
);
3339 if (IS_ERR(mdata
)) {
3340 rc
= PTR_ERR(mdata
);
3343 cleanup_volume_info_contents(volume_info
);
3344 memset(volume_info
, '\0', sizeof(*volume_info
));
3345 rc
= cifs_setup_volume_info(volume_info
, mdata
,
3348 kfree(fake_devname
);
3349 kfree(cifs_sb
->mountdata
);
3350 cifs_sb
->mountdata
= mdata
;
3358 cifs_setup_volume_info(struct smb_vol
*volume_info
, char *mount_data
,
3359 const char *devname
)
3363 if (cifs_parse_mount_options(mount_data
, devname
, volume_info
))
3367 if (volume_info
->nullauth
) {
3368 cFYI(1, "Anonymous login");
3369 kfree(volume_info
->username
);
3370 volume_info
->username
= NULL
;
3371 } else if (volume_info
->username
) {
3372 /* BB fixme parse for domain name here */
3373 cFYI(1, "Username: %s", volume_info
->username
);
3375 cifserror("No username specified");
3376 /* In userspace mount helper we can get user name from alternate
3377 locations such as env variables and files on disk */
3381 /* this is needed for ASCII cp to Unicode converts */
3382 if (volume_info
->iocharset
== NULL
) {
3383 /* load_nls_default cannot return null */
3384 volume_info
->local_nls
= load_nls_default();
3386 volume_info
->local_nls
= load_nls(volume_info
->iocharset
);
3387 if (volume_info
->local_nls
== NULL
) {
3388 cERROR(1, "CIFS mount error: iocharset %s not found",
3389 volume_info
->iocharset
);
3398 cifs_get_volume_info(char *mount_data
, const char *devname
)
3401 struct smb_vol
*volume_info
;
3403 volume_info
= kzalloc(sizeof(struct smb_vol
), GFP_KERNEL
);
3405 return ERR_PTR(-ENOMEM
);
3407 rc
= cifs_setup_volume_info(volume_info
, mount_data
, devname
);
3409 cifs_cleanup_volume_info(volume_info
);
3410 volume_info
= ERR_PTR(rc
);
3417 cifs_mount(struct cifs_sb_info
*cifs_sb
, struct smb_vol
*volume_info
)
3421 struct cifs_ses
*ses
;
3422 struct cifs_tcon
*tcon
;
3423 struct TCP_Server_Info
*server
;
3425 struct tcon_link
*tlink
;
3426 #ifdef CONFIG_CIFS_DFS_UPCALL
3427 int referral_walks_count
= 0;
3430 rc
= bdi_setup_and_register(&cifs_sb
->bdi
, "cifs", BDI_CAP_MAP_COPY
);
3434 #ifdef CONFIG_CIFS_DFS_UPCALL
3436 /* cleanup activities if we're chasing a referral */
3437 if (referral_walks_count
) {
3439 cifs_put_tcon(tcon
);
3441 cifs_put_smb_ses(ses
);
3455 /* get a reference to a tcp session */
3456 server
= cifs_get_tcp_session(volume_info
);
3457 if (IS_ERR(server
)) {
3458 rc
= PTR_ERR(server
);
3459 bdi_destroy(&cifs_sb
->bdi
);
3463 /* get a reference to a SMB session */
3464 ses
= cifs_get_smb_ses(server
, volume_info
);
3468 goto mount_fail_check
;
3471 /* search for existing tcon to this server share */
3472 tcon
= cifs_get_tcon(ses
, volume_info
);
3476 goto remote_path_check
;
3479 /* tell server which Unix caps we support */
3480 if (cap_unix(tcon
->ses
)) {
3481 /* reset of caps checks mount to see if unix extensions
3482 disabled for just this mount */
3483 reset_cifs_unix_caps(xid
, tcon
, cifs_sb
, volume_info
);
3484 if ((tcon
->ses
->server
->tcpStatus
== CifsNeedReconnect
) &&
3485 (le64_to_cpu(tcon
->fsUnixInfo
.Capability
) &
3486 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)) {
3488 goto mount_fail_check
;
3491 tcon
->unix_ext
= 0; /* server does not support them */
3493 /* do not care if a following call succeed - informational */
3494 if (!tcon
->ipc
&& server
->ops
->qfs_tcon
)
3495 server
->ops
->qfs_tcon(xid
, tcon
);
3497 cifs_sb
->wsize
= server
->ops
->negotiate_wsize(tcon
, volume_info
);
3498 cifs_sb
->rsize
= server
->ops
->negotiate_rsize(tcon
, volume_info
);
3500 /* tune readahead according to rsize */
3501 cifs_sb
->bdi
.ra_pages
= cifs_sb
->rsize
/ PAGE_CACHE_SIZE
;
3504 #ifdef CONFIG_CIFS_DFS_UPCALL
3506 * Perform an unconditional check for whether there are DFS
3507 * referrals for this path without prefix, to provide support
3508 * for DFS referrals from w2k8 servers which don't seem to respond
3509 * with PATH_NOT_COVERED to requests that include the prefix.
3510 * Chase the referral if found, otherwise continue normally.
3512 if (referral_walks_count
== 0) {
3513 int refrc
= expand_dfs_referral(xid
, ses
, volume_info
, cifs_sb
,
3516 referral_walks_count
++;
3517 goto try_mount_again
;
3522 /* check if a whole path is not remote */
3524 if (!server
->ops
->is_path_accessible
) {
3526 goto mount_fail_check
;
3529 * cifs_build_path_to_root works only when we have a valid tcon
3531 full_path
= cifs_build_path_to_root(volume_info
, cifs_sb
, tcon
);
3532 if (full_path
== NULL
) {
3534 goto mount_fail_check
;
3536 rc
= server
->ops
->is_path_accessible(xid
, tcon
, cifs_sb
,
3538 if (rc
!= 0 && rc
!= -EREMOTE
) {
3540 goto mount_fail_check
;
3545 /* get referral if needed */
3546 if (rc
== -EREMOTE
) {
3547 #ifdef CONFIG_CIFS_DFS_UPCALL
3548 if (referral_walks_count
> MAX_NESTED_LINKS
) {
3550 * BB: when we implement proper loop detection,
3551 * we will remove this check. But now we need it
3552 * to prevent an indefinite loop if 'DFS tree' is
3553 * misconfigured (i.e. has loops).
3556 goto mount_fail_check
;
3559 rc
= expand_dfs_referral(xid
, ses
, volume_info
, cifs_sb
, true);
3562 referral_walks_count
++;
3563 goto try_mount_again
;
3565 goto mount_fail_check
;
3566 #else /* No DFS support, return error on mount */
3572 goto mount_fail_check
;
3574 /* now, hang the tcon off of the superblock */
3575 tlink
= kzalloc(sizeof *tlink
, GFP_KERNEL
);
3576 if (tlink
== NULL
) {
3578 goto mount_fail_check
;
3581 tlink
->tl_uid
= ses
->linux_uid
;
3582 tlink
->tl_tcon
= tcon
;
3583 tlink
->tl_time
= jiffies
;
3584 set_bit(TCON_LINK_MASTER
, &tlink
->tl_flags
);
3585 set_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
3587 cifs_sb
->master_tlink
= tlink
;
3588 spin_lock(&cifs_sb
->tlink_tree_lock
);
3589 tlink_rb_insert(&cifs_sb
->tlink_tree
, tlink
);
3590 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3592 queue_delayed_work(cifsiod_wq
, &cifs_sb
->prune_tlinks
,
3596 /* on error free sesinfo and tcon struct if needed */
3598 /* If find_unc succeeded then rc == 0 so we can not end */
3599 /* up accidentally freeing someone elses tcon struct */
3601 cifs_put_tcon(tcon
);
3603 cifs_put_smb_ses(ses
);
3605 cifs_put_tcp_session(server
);
3606 bdi_destroy(&cifs_sb
->bdi
);
3615 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3616 * pointer may be NULL.
3619 CIFSTCon(const unsigned int xid
, struct cifs_ses
*ses
,
3620 const char *tree
, struct cifs_tcon
*tcon
,
3621 const struct nls_table
*nls_codepage
)
3623 struct smb_hdr
*smb_buffer
;
3624 struct smb_hdr
*smb_buffer_response
;
3627 unsigned char *bcc_ptr
;
3630 __u16 bytes_left
, count
;
3635 smb_buffer
= cifs_buf_get();
3636 if (smb_buffer
== NULL
)
3639 smb_buffer_response
= smb_buffer
;
3641 header_assemble(smb_buffer
, SMB_COM_TREE_CONNECT_ANDX
,
3642 NULL
/*no tid */ , 4 /*wct */ );
3644 smb_buffer
->Mid
= get_next_mid(ses
->server
);
3645 smb_buffer
->Uid
= ses
->Suid
;
3646 pSMB
= (TCONX_REQ
*) smb_buffer
;
3647 pSMBr
= (TCONX_RSP
*) smb_buffer_response
;
3649 pSMB
->AndXCommand
= 0xFF;
3650 pSMB
->Flags
= cpu_to_le16(TCON_EXTENDED_SECINFO
);
3651 bcc_ptr
= &pSMB
->Password
[0];
3652 if (!tcon
|| (ses
->server
->sec_mode
& SECMODE_USER
)) {
3653 pSMB
->PasswordLength
= cpu_to_le16(1); /* minimum */
3654 *bcc_ptr
= 0; /* password is null byte */
3655 bcc_ptr
++; /* skip password */
3656 /* already aligned so no need to do it below */
3658 pSMB
->PasswordLength
= cpu_to_le16(CIFS_AUTH_RESP_SIZE
);
3659 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3660 specified as required (when that support is added to
3661 the vfs in the future) as only NTLM or the much
3662 weaker LANMAN (which we do not send by default) is accepted
3663 by Samba (not sure whether other servers allow
3664 NTLMv2 password here) */
3665 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3666 if ((global_secflags
& CIFSSEC_MAY_LANMAN
) &&
3667 (ses
->server
->secType
== LANMAN
))
3668 calc_lanman_hash(tcon
->password
, ses
->server
->cryptkey
,
3669 ses
->server
->sec_mode
&
3670 SECMODE_PW_ENCRYPT
? true : false,
3673 #endif /* CIFS_WEAK_PW_HASH */
3674 rc
= SMBNTencrypt(tcon
->password
, ses
->server
->cryptkey
,
3675 bcc_ptr
, nls_codepage
);
3677 bcc_ptr
+= CIFS_AUTH_RESP_SIZE
;
3678 if (ses
->capabilities
& CAP_UNICODE
) {
3679 /* must align unicode strings */
3680 *bcc_ptr
= 0; /* null byte password */
3685 if (ses
->server
->sec_mode
&
3686 (SECMODE_SIGN_REQUIRED
| SECMODE_SIGN_ENABLED
))
3687 smb_buffer
->Flags2
|= SMBFLG2_SECURITY_SIGNATURE
;
3689 if (ses
->capabilities
& CAP_STATUS32
) {
3690 smb_buffer
->Flags2
|= SMBFLG2_ERR_STATUS
;
3692 if (ses
->capabilities
& CAP_DFS
) {
3693 smb_buffer
->Flags2
|= SMBFLG2_DFS
;
3695 if (ses
->capabilities
& CAP_UNICODE
) {
3696 smb_buffer
->Flags2
|= SMBFLG2_UNICODE
;
3698 cifs_strtoUTF16((__le16
*) bcc_ptr
, tree
,
3699 6 /* max utf8 char length in bytes */ *
3700 (/* server len*/ + 256 /* share len */), nls_codepage
);
3701 bcc_ptr
+= 2 * length
; /* convert num 16 bit words to bytes */
3702 bcc_ptr
+= 2; /* skip trailing null */
3703 } else { /* ASCII */
3704 strcpy(bcc_ptr
, tree
);
3705 bcc_ptr
+= strlen(tree
) + 1;
3707 strcpy(bcc_ptr
, "?????");
3708 bcc_ptr
+= strlen("?????");
3710 count
= bcc_ptr
- &pSMB
->Password
[0];
3711 pSMB
->hdr
.smb_buf_length
= cpu_to_be32(be32_to_cpu(
3712 pSMB
->hdr
.smb_buf_length
) + count
);
3713 pSMB
->ByteCount
= cpu_to_le16(count
);
3715 rc
= SendReceive(xid
, ses
, smb_buffer
, smb_buffer_response
, &length
,
3718 /* above now done in SendReceive */
3719 if ((rc
== 0) && (tcon
!= NULL
)) {
3722 tcon
->tidStatus
= CifsGood
;
3723 tcon
->need_reconnect
= false;
3724 tcon
->tid
= smb_buffer_response
->Tid
;
3725 bcc_ptr
= pByteArea(smb_buffer_response
);
3726 bytes_left
= get_bcc(smb_buffer_response
);
3727 length
= strnlen(bcc_ptr
, bytes_left
- 2);
3728 if (smb_buffer
->Flags2
& SMBFLG2_UNICODE
)
3734 /* skip service field (NB: this field is always ASCII) */
3736 if ((bcc_ptr
[0] == 'I') && (bcc_ptr
[1] == 'P') &&
3737 (bcc_ptr
[2] == 'C')) {
3738 cFYI(1, "IPC connection");
3741 } else if (length
== 2) {
3742 if ((bcc_ptr
[0] == 'A') && (bcc_ptr
[1] == ':')) {
3743 /* the most common case */
3744 cFYI(1, "disk share connection");
3747 bcc_ptr
+= length
+ 1;
3748 bytes_left
-= (length
+ 1);
3749 strncpy(tcon
->treeName
, tree
, MAX_TREE_SIZE
);
3751 /* mostly informational -- no need to fail on error here */
3752 kfree(tcon
->nativeFileSystem
);
3753 tcon
->nativeFileSystem
= cifs_strndup_from_utf16(bcc_ptr
,
3754 bytes_left
, is_unicode
,
3757 cFYI(1, "nativeFileSystem=%s", tcon
->nativeFileSystem
);
3759 if ((smb_buffer_response
->WordCount
== 3) ||
3760 (smb_buffer_response
->WordCount
== 7))
3761 /* field is in same location */
3762 tcon
->Flags
= le16_to_cpu(pSMBr
->OptionalSupport
);
3765 cFYI(1, "Tcon flags: 0x%x ", tcon
->Flags
);
3766 } else if ((rc
== 0) && tcon
== NULL
) {
3767 /* all we need to save for IPC$ connection */
3768 ses
->ipc_tid
= smb_buffer_response
->Tid
;
3771 cifs_buf_release(smb_buffer
);
3776 cifs_umount(struct cifs_sb_info
*cifs_sb
)
3778 struct rb_root
*root
= &cifs_sb
->tlink_tree
;
3779 struct rb_node
*node
;
3780 struct tcon_link
*tlink
;
3782 cancel_delayed_work_sync(&cifs_sb
->prune_tlinks
);
3784 spin_lock(&cifs_sb
->tlink_tree_lock
);
3785 while ((node
= rb_first(root
))) {
3786 tlink
= rb_entry(node
, struct tcon_link
, tl_rbnode
);
3787 cifs_get_tlink(tlink
);
3788 clear_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
3789 rb_erase(node
, root
);
3791 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3792 cifs_put_tlink(tlink
);
3793 spin_lock(&cifs_sb
->tlink_tree_lock
);
3795 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3797 bdi_destroy(&cifs_sb
->bdi
);
3798 kfree(cifs_sb
->mountdata
);
3799 unload_nls(cifs_sb
->local_nls
);
3804 cifs_negotiate_protocol(const unsigned int xid
, struct cifs_ses
*ses
)
3807 struct TCP_Server_Info
*server
= ses
->server
;
3809 if (!server
->ops
->need_neg
|| !server
->ops
->negotiate
)
3812 /* only send once per connect */
3813 if (!server
->ops
->need_neg(server
))
3816 set_credits(server
, 1);
3818 rc
= server
->ops
->negotiate(xid
, ses
);
3820 spin_lock(&GlobalMid_Lock
);
3821 if (server
->tcpStatus
== CifsNeedNegotiate
)
3822 server
->tcpStatus
= CifsGood
;
3825 spin_unlock(&GlobalMid_Lock
);
3832 cifs_setup_session(const unsigned int xid
, struct cifs_ses
*ses
,
3833 struct nls_table
*nls_info
)
3836 struct TCP_Server_Info
*server
= ses
->server
;
3839 ses
->capabilities
= server
->capabilities
;
3840 if (linuxExtEnabled
== 0)
3841 ses
->capabilities
&= (~server
->vals
->cap_unix
);
3843 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3844 server
->sec_mode
, server
->capabilities
, server
->timeAdj
);
3846 if (server
->ops
->sess_setup
)
3847 rc
= server
->ops
->sess_setup(xid
, ses
, nls_info
);
3850 cERROR(1, "Send error in SessSetup = %d", rc
);
3852 mutex_lock(&ses
->server
->srv_mutex
);
3853 if (!server
->session_estab
) {
3854 server
->session_key
.response
= ses
->auth_key
.response
;
3855 server
->session_key
.len
= ses
->auth_key
.len
;
3856 server
->sequence_number
= 0x2;
3857 server
->session_estab
= true;
3858 ses
->auth_key
.response
= NULL
;
3860 mutex_unlock(&server
->srv_mutex
);
3862 cFYI(1, "CIFS Session Established successfully");
3863 spin_lock(&GlobalMid_Lock
);
3864 ses
->status
= CifsGood
;
3865 ses
->need_reconnect
= false;
3866 spin_unlock(&GlobalMid_Lock
);
3869 kfree(ses
->auth_key
.response
);
3870 ses
->auth_key
.response
= NULL
;
3871 ses
->auth_key
.len
= 0;
3872 kfree(ses
->ntlmssp
);
3873 ses
->ntlmssp
= NULL
;
3879 cifs_set_vol_auth(struct smb_vol
*vol
, struct cifs_ses
*ses
)
3881 switch (ses
->server
->secType
) {
3883 vol
->secFlg
= CIFSSEC_MUST_KRB5
;
3886 vol
->secFlg
= CIFSSEC_MUST_NTLMV2
;
3889 vol
->secFlg
= CIFSSEC_MUST_NTLM
;
3892 vol
->secFlg
= CIFSSEC_MUST_NTLMSSP
;
3895 vol
->secFlg
= CIFSSEC_MUST_LANMAN
;
3899 return cifs_set_cifscreds(vol
, ses
);
3902 static struct cifs_tcon
*
3903 cifs_construct_tcon(struct cifs_sb_info
*cifs_sb
, uid_t fsuid
)
3906 struct cifs_tcon
*master_tcon
= cifs_sb_master_tcon(cifs_sb
);
3907 struct cifs_ses
*ses
;
3908 struct cifs_tcon
*tcon
= NULL
;
3909 struct smb_vol
*vol_info
;
3911 vol_info
= kzalloc(sizeof(*vol_info
), GFP_KERNEL
);
3912 if (vol_info
== NULL
)
3913 return ERR_PTR(-ENOMEM
);
3915 vol_info
->local_nls
= cifs_sb
->local_nls
;
3916 vol_info
->linux_uid
= fsuid
;
3917 vol_info
->cred_uid
= fsuid
;
3918 vol_info
->UNC
= master_tcon
->treeName
;
3919 vol_info
->retry
= master_tcon
->retry
;
3920 vol_info
->nocase
= master_tcon
->nocase
;
3921 vol_info
->local_lease
= master_tcon
->local_lease
;
3922 vol_info
->no_linux_ext
= !master_tcon
->unix_ext
;
3924 rc
= cifs_set_vol_auth(vol_info
, master_tcon
->ses
);
3930 /* get a reference for the same TCP session */
3931 spin_lock(&cifs_tcp_ses_lock
);
3932 ++master_tcon
->ses
->server
->srv_count
;
3933 spin_unlock(&cifs_tcp_ses_lock
);
3935 ses
= cifs_get_smb_ses(master_tcon
->ses
->server
, vol_info
);
3937 tcon
= (struct cifs_tcon
*)ses
;
3938 cifs_put_tcp_session(master_tcon
->ses
->server
);
3942 tcon
= cifs_get_tcon(ses
, vol_info
);
3944 cifs_put_smb_ses(ses
);
3949 reset_cifs_unix_caps(0, tcon
, NULL
, vol_info
);
3951 kfree(vol_info
->username
);
3952 kfree(vol_info
->password
);
3959 cifs_sb_master_tcon(struct cifs_sb_info
*cifs_sb
)
3961 return tlink_tcon(cifs_sb_master_tlink(cifs_sb
));
3965 cifs_sb_tcon_pending_wait(void *unused
)
3968 return signal_pending(current
) ? -ERESTARTSYS
: 0;
3971 /* find and return a tlink with given uid */
3972 static struct tcon_link
*
3973 tlink_rb_search(struct rb_root
*root
, uid_t uid
)
3975 struct rb_node
*node
= root
->rb_node
;
3976 struct tcon_link
*tlink
;
3979 tlink
= rb_entry(node
, struct tcon_link
, tl_rbnode
);
3981 if (tlink
->tl_uid
> uid
)
3982 node
= node
->rb_left
;
3983 else if (tlink
->tl_uid
< uid
)
3984 node
= node
->rb_right
;
3991 /* insert a tcon_link into the tree */
3993 tlink_rb_insert(struct rb_root
*root
, struct tcon_link
*new_tlink
)
3995 struct rb_node
**new = &(root
->rb_node
), *parent
= NULL
;
3996 struct tcon_link
*tlink
;
3999 tlink
= rb_entry(*new, struct tcon_link
, tl_rbnode
);
4002 if (tlink
->tl_uid
> new_tlink
->tl_uid
)
4003 new = &((*new)->rb_left
);
4005 new = &((*new)->rb_right
);
4008 rb_link_node(&new_tlink
->tl_rbnode
, parent
, new);
4009 rb_insert_color(&new_tlink
->tl_rbnode
, root
);
4013 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4016 * If the superblock doesn't refer to a multiuser mount, then just return
4017 * the master tcon for the mount.
4019 * First, search the rbtree for an existing tcon for this fsuid. If one
4020 * exists, then check to see if it's pending construction. If it is then wait
4021 * for construction to complete. Once it's no longer pending, check to see if
4022 * it failed and either return an error or retry construction, depending on
4025 * If one doesn't exist then insert a new tcon_link struct into the tree and
4026 * try to construct a new one.
4029 cifs_sb_tlink(struct cifs_sb_info
*cifs_sb
)
4032 uid_t fsuid
= current_fsuid();
4033 struct tcon_link
*tlink
, *newtlink
;
4035 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
))
4036 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb
));
4038 spin_lock(&cifs_sb
->tlink_tree_lock
);
4039 tlink
= tlink_rb_search(&cifs_sb
->tlink_tree
, fsuid
);
4041 cifs_get_tlink(tlink
);
4042 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4044 if (tlink
== NULL
) {
4045 newtlink
= kzalloc(sizeof(*tlink
), GFP_KERNEL
);
4046 if (newtlink
== NULL
)
4047 return ERR_PTR(-ENOMEM
);
4048 newtlink
->tl_uid
= fsuid
;
4049 newtlink
->tl_tcon
= ERR_PTR(-EACCES
);
4050 set_bit(TCON_LINK_PENDING
, &newtlink
->tl_flags
);
4051 set_bit(TCON_LINK_IN_TREE
, &newtlink
->tl_flags
);
4052 cifs_get_tlink(newtlink
);
4054 spin_lock(&cifs_sb
->tlink_tree_lock
);
4055 /* was one inserted after previous search? */
4056 tlink
= tlink_rb_search(&cifs_sb
->tlink_tree
, fsuid
);
4058 cifs_get_tlink(tlink
);
4059 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4061 goto wait_for_construction
;
4064 tlink_rb_insert(&cifs_sb
->tlink_tree
, tlink
);
4065 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4067 wait_for_construction
:
4068 ret
= wait_on_bit(&tlink
->tl_flags
, TCON_LINK_PENDING
,
4069 cifs_sb_tcon_pending_wait
,
4070 TASK_INTERRUPTIBLE
);
4072 cifs_put_tlink(tlink
);
4073 return ERR_PTR(ret
);
4076 /* if it's good, return it */
4077 if (!IS_ERR(tlink
->tl_tcon
))
4080 /* return error if we tried this already recently */
4081 if (time_before(jiffies
, tlink
->tl_time
+ TLINK_ERROR_EXPIRE
)) {
4082 cifs_put_tlink(tlink
);
4083 return ERR_PTR(-EACCES
);
4086 if (test_and_set_bit(TCON_LINK_PENDING
, &tlink
->tl_flags
))
4087 goto wait_for_construction
;
4090 tlink
->tl_tcon
= cifs_construct_tcon(cifs_sb
, fsuid
);
4091 clear_bit(TCON_LINK_PENDING
, &tlink
->tl_flags
);
4092 wake_up_bit(&tlink
->tl_flags
, TCON_LINK_PENDING
);
4094 if (IS_ERR(tlink
->tl_tcon
)) {
4095 cifs_put_tlink(tlink
);
4096 return ERR_PTR(-EACCES
);
4103 * periodic workqueue job that scans tcon_tree for a superblock and closes
4107 cifs_prune_tlinks(struct work_struct
*work
)
4109 struct cifs_sb_info
*cifs_sb
= container_of(work
, struct cifs_sb_info
,
4111 struct rb_root
*root
= &cifs_sb
->tlink_tree
;
4112 struct rb_node
*node
= rb_first(root
);
4113 struct rb_node
*tmp
;
4114 struct tcon_link
*tlink
;
4117 * Because we drop the spinlock in the loop in order to put the tlink
4118 * it's not guarded against removal of links from the tree. The only
4119 * places that remove entries from the tree are this function and
4120 * umounts. Because this function is non-reentrant and is canceled
4121 * before umount can proceed, this is safe.
4123 spin_lock(&cifs_sb
->tlink_tree_lock
);
4124 node
= rb_first(root
);
4125 while (node
!= NULL
) {
4127 node
= rb_next(tmp
);
4128 tlink
= rb_entry(tmp
, struct tcon_link
, tl_rbnode
);
4130 if (test_bit(TCON_LINK_MASTER
, &tlink
->tl_flags
) ||
4131 atomic_read(&tlink
->tl_count
) != 0 ||
4132 time_after(tlink
->tl_time
+ TLINK_IDLE_EXPIRE
, jiffies
))
4135 cifs_get_tlink(tlink
);
4136 clear_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
4137 rb_erase(tmp
, root
);
4139 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4140 cifs_put_tlink(tlink
);
4141 spin_lock(&cifs_sb
->tlink_tree_lock
);
4143 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4145 queue_delayed_work(cifsiod_wq
, &cifs_sb
->prune_tlinks
,