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"
51 #include "dns_resolve.h"
54 #include "rfc1002pdu.h"
56 #ifdef CONFIG_CIFS_SMB2
57 #include "smb2proto.h"
61 #define RFC1001_PORT 139
63 extern mempool_t *cifs_req_poolp;
65 /* FIXME: should these be tunable? */
66 #define TLINK_ERROR_EXPIRE (1 * HZ)
67 #define TLINK_IDLE_EXPIRE (600 * HZ)
71 /* Mount options that take no arguments */
72 Opt_user_xattr, Opt_nouser_xattr,
73 Opt_forceuid, Opt_noforceuid,
74 Opt_forcegid, Opt_noforcegid,
75 Opt_noblocksend, Opt_noautotune,
76 Opt_hard, Opt_soft, Opt_perm, Opt_noperm,
77 Opt_mapposix, Opt_nomapposix,
78 Opt_mapchars, Opt_nomapchars, Opt_sfu,
79 Opt_nosfu, Opt_nodfs, Opt_posixpaths,
80 Opt_noposixpaths, Opt_nounix,
83 Opt_forcemandatorylock, Opt_setuids,
84 Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
85 Opt_nohard, Opt_nosoft,
87 Opt_nostrictsync, Opt_strictsync,
88 Opt_serverino, Opt_noserverino,
89 Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
90 Opt_acl, Opt_noacl, Opt_locallease,
91 Opt_sign, Opt_seal, Opt_noac,
92 Opt_fsc, Opt_mfsymlinks,
93 Opt_multiuser, Opt_sloppy, Opt_nosharesock,
94 Opt_persistent, Opt_nopersistent,
95 Opt_resilient, Opt_noresilient,
97 /* Mount options which take numeric value */
98 Opt_backupuid, Opt_backupgid, Opt_uid,
99 Opt_cruid, Opt_gid, Opt_file_mode,
100 Opt_dirmode, Opt_port,
101 Opt_rsize, Opt_wsize, Opt_actimeo,
103 /* Mount options which take string value */
104 Opt_user, Opt_pass, Opt_ip,
105 Opt_domain, Opt_srcaddr, Opt_iocharset,
106 Opt_netbiosname, Opt_servern,
107 Opt_ver, Opt_vers, Opt_sec, Opt_cache,
109 /* Mount options to be ignored */
112 /* Options which could be blank */
120 static const match_table_t cifs_mount_option_tokens = {
122 { Opt_user_xattr, "user_xattr" },
123 { Opt_nouser_xattr, "nouser_xattr" },
124 { Opt_forceuid, "forceuid" },
125 { Opt_noforceuid, "noforceuid" },
126 { Opt_forcegid, "forcegid" },
127 { Opt_noforcegid, "noforcegid" },
128 { Opt_noblocksend, "noblocksend" },
129 { Opt_noautotune, "noautotune" },
130 { Opt_hard, "hard" },
131 { Opt_soft, "soft" },
132 { Opt_perm, "perm" },
133 { Opt_noperm, "noperm" },
134 { Opt_mapchars, "mapchars" }, /* SFU style */
135 { Opt_nomapchars, "nomapchars" },
136 { Opt_mapposix, "mapposix" }, /* SFM style */
137 { Opt_nomapposix, "nomapposix" },
139 { Opt_nosfu, "nosfu" },
140 { Opt_nodfs, "nodfs" },
141 { Opt_posixpaths, "posixpaths" },
142 { Opt_noposixpaths, "noposixpaths" },
143 { Opt_nounix, "nounix" },
144 { Opt_nounix, "nolinux" },
145 { Opt_nocase, "nocase" },
146 { Opt_nocase, "ignorecase" },
148 { Opt_nobrl, "nobrl" },
149 { Opt_nobrl, "nolock" },
150 { Opt_forcemandatorylock, "forcemandatorylock" },
151 { Opt_forcemandatorylock, "forcemand" },
152 { Opt_setuids, "setuids" },
153 { Opt_nosetuids, "nosetuids" },
154 { Opt_dynperm, "dynperm" },
155 { Opt_nodynperm, "nodynperm" },
156 { Opt_nohard, "nohard" },
157 { Opt_nosoft, "nosoft" },
158 { Opt_nointr, "nointr" },
159 { Opt_intr, "intr" },
160 { Opt_nostrictsync, "nostrictsync" },
161 { Opt_strictsync, "strictsync" },
162 { Opt_serverino, "serverino" },
163 { Opt_noserverino, "noserverino" },
164 { Opt_rwpidforward, "rwpidforward" },
165 { Opt_cifsacl, "cifsacl" },
166 { Opt_nocifsacl, "nocifsacl" },
168 { Opt_noacl, "noacl" },
169 { Opt_locallease, "locallease" },
170 { Opt_sign, "sign" },
171 { Opt_seal, "seal" },
172 { Opt_noac, "noac" },
174 { Opt_mfsymlinks, "mfsymlinks" },
175 { Opt_multiuser, "multiuser" },
176 { Opt_sloppy, "sloppy" },
177 { Opt_nosharesock, "nosharesock" },
178 { Opt_persistent, "persistenthandles"},
179 { Opt_nopersistent, "nopersistenthandles"},
180 { Opt_resilient, "resilienthandles"},
181 { Opt_noresilient, "noresilienthandles"},
183 { Opt_backupuid, "backupuid=%s" },
184 { Opt_backupgid, "backupgid=%s" },
185 { Opt_uid, "uid=%s" },
186 { Opt_cruid, "cruid=%s" },
187 { Opt_gid, "gid=%s" },
188 { Opt_file_mode, "file_mode=%s" },
189 { Opt_dirmode, "dirmode=%s" },
190 { Opt_dirmode, "dir_mode=%s" },
191 { Opt_port, "port=%s" },
192 { Opt_rsize, "rsize=%s" },
193 { Opt_wsize, "wsize=%s" },
194 { Opt_actimeo, "actimeo=%s" },
196 { Opt_blank_user, "user=" },
197 { Opt_blank_user, "username=" },
198 { Opt_user, "user=%s" },
199 { Opt_user, "username=%s" },
200 { Opt_blank_pass, "pass=" },
201 { Opt_blank_pass, "password=" },
202 { Opt_pass, "pass=%s" },
203 { Opt_pass, "password=%s" },
204 { Opt_blank_ip, "ip=" },
205 { Opt_blank_ip, "addr=" },
207 { Opt_ip, "addr=%s" },
208 { Opt_ignore, "unc=%s" },
209 { Opt_ignore, "target=%s" },
210 { Opt_ignore, "path=%s" },
211 { Opt_domain, "dom=%s" },
212 { Opt_domain, "domain=%s" },
213 { Opt_domain, "workgroup=%s" },
214 { Opt_srcaddr, "srcaddr=%s" },
215 { Opt_ignore, "prefixpath=%s" },
216 { Opt_iocharset, "iocharset=%s" },
217 { Opt_netbiosname, "netbiosname=%s" },
218 { Opt_servern, "servern=%s" },
219 { Opt_ver, "ver=%s" },
220 { Opt_vers, "vers=%s" },
221 { Opt_sec, "sec=%s" },
222 { Opt_cache, "cache=%s" },
224 { Opt_ignore, "cred" },
225 { Opt_ignore, "credentials" },
226 { Opt_ignore, "cred=%s" },
227 { Opt_ignore, "credentials=%s" },
228 { Opt_ignore, "guest" },
229 { Opt_ignore, "rw" },
230 { Opt_ignore, "ro" },
231 { Opt_ignore, "suid" },
232 { Opt_ignore, "nosuid" },
233 { Opt_ignore, "exec" },
234 { Opt_ignore, "noexec" },
235 { Opt_ignore, "nodev" },
236 { Opt_ignore, "noauto" },
237 { Opt_ignore, "dev" },
238 { Opt_ignore, "mand" },
239 { Opt_ignore, "nomand" },
240 { Opt_ignore, "_netdev" },
246 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
247 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
248 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
249 Opt_sec_ntlmv2i, Opt_sec_lanman,
255 static const match_table_t cifs_secflavor_tokens = {
256 { Opt_sec_krb5, "krb5" },
257 { Opt_sec_krb5i, "krb5i" },
258 { Opt_sec_krb5p, "krb5p" },
259 { Opt_sec_ntlmsspi, "ntlmsspi" },
260 { Opt_sec_ntlmssp, "ntlmssp" },
261 { Opt_ntlm, "ntlm" },
262 { Opt_sec_ntlmi, "ntlmi" },
263 { Opt_sec_ntlmv2, "nontlm" },
264 { Opt_sec_ntlmv2, "ntlmv2" },
265 { Opt_sec_ntlmv2i, "ntlmv2i" },
266 { Opt_sec_lanman, "lanman" },
267 { Opt_sec_none, "none" },
269 { Opt_sec_err, NULL }
280 static const match_table_t cifs_cacheflavor_tokens = {
281 { Opt_cache_loose, "loose" },
282 { Opt_cache_strict, "strict" },
283 { Opt_cache_none, "none" },
284 { Opt_cache_err, NULL }
287 static const match_table_t cifs_smb_version_tokens = {
288 { Smb_1, SMB1_VERSION_STRING },
289 { Smb_20, SMB20_VERSION_STRING},
290 { Smb_21, SMB21_VERSION_STRING },
291 { Smb_30, SMB30_VERSION_STRING },
292 { Smb_302, SMB302_VERSION_STRING },
293 #ifdef CONFIG_CIFS_SMB311
294 { Smb_311, SMB311_VERSION_STRING },
295 { Smb_311, ALT_SMB311_VERSION_STRING },
297 { Smb_version_err, NULL }
300 static int ip_connect(struct TCP_Server_Info *server);
301 static int generic_ip_connect(struct TCP_Server_Info *server);
302 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
303 static void cifs_prune_tlinks(struct work_struct *work);
304 static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
305 const char *devname);
308 * Resolve hostname and set ip addr in tcp ses. Useful for hostnames that may
309 * get their ip addresses changed at some point.
311 * This should be called with server->srv_mutex held.
313 #ifdef CONFIG_CIFS_DFS_UPCALL
314 static int reconn_set_ipaddr(struct TCP_Server_Info *server)
318 char *unc, *ipaddr = NULL;
320 if (!server->hostname)
323 len = strlen(server->hostname) + 3;
325 unc = kmalloc(len, GFP_KERNEL);
327 cifs_dbg(FYI, "%s: failed to create UNC path\n", __func__);
330 snprintf(unc, len, "\\\\%s", server->hostname);
332 rc = dns_resolve_server_name_to_ip(unc, &ipaddr);
336 cifs_dbg(FYI, "%s: failed to resolve server part of %s to IP: %d\n",
337 __func__, server->hostname, rc);
341 spin_lock(&cifs_tcp_ses_lock);
342 rc = cifs_convert_address((struct sockaddr *)&server->dstaddr, ipaddr,
344 spin_unlock(&cifs_tcp_ses_lock);
350 static inline int reconn_set_ipaddr(struct TCP_Server_Info *server)
357 * cifs tcp session reconnection
359 * mark tcp session as reconnecting so temporarily locked
360 * mark all smb sessions as reconnecting for tcp session
361 * reconnect tcp session
362 * wake up waiters on reconnection? - (not needed currently)
365 cifs_reconnect(struct TCP_Server_Info *server)
368 struct list_head *tmp, *tmp2;
369 struct cifs_ses *ses;
370 struct cifs_tcon *tcon;
371 struct mid_q_entry *mid_entry;
372 struct list_head retry_list;
374 spin_lock(&GlobalMid_Lock);
375 if (server->tcpStatus == CifsExiting) {
376 /* the demux thread will exit normally
377 next time through the loop */
378 spin_unlock(&GlobalMid_Lock);
381 server->tcpStatus = CifsNeedReconnect;
382 spin_unlock(&GlobalMid_Lock);
384 #ifdef CONFIG_CIFS_SMB2
385 server->max_read = 0;
388 cifs_dbg(FYI, "Reconnecting tcp session\n");
390 /* before reconnecting the tcp session, mark the smb session (uid)
391 and the tid bad so they are not used until reconnected */
392 cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
394 spin_lock(&cifs_tcp_ses_lock);
395 list_for_each(tmp, &server->smb_ses_list) {
396 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
397 ses->need_reconnect = true;
399 list_for_each(tmp2, &ses->tcon_list) {
400 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
401 tcon->need_reconnect = true;
404 spin_unlock(&cifs_tcp_ses_lock);
406 /* do not want to be sending data on a socket we are freeing */
407 cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
408 mutex_lock(&server->srv_mutex);
409 if (server->ssocket) {
410 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
411 server->ssocket->state, server->ssocket->flags);
412 kernel_sock_shutdown(server->ssocket, SHUT_WR);
413 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
414 server->ssocket->state, server->ssocket->flags);
415 sock_release(server->ssocket);
416 server->ssocket = NULL;
418 server->sequence_number = 0;
419 server->session_estab = false;
420 kfree(server->session_key.response);
421 server->session_key.response = NULL;
422 server->session_key.len = 0;
423 server->lstrp = jiffies;
425 /* mark submitted MIDs for retry and issue callback */
426 INIT_LIST_HEAD(&retry_list);
427 cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
428 spin_lock(&GlobalMid_Lock);
429 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
430 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
431 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
432 mid_entry->mid_state = MID_RETRY_NEEDED;
433 list_move(&mid_entry->qhead, &retry_list);
435 spin_unlock(&GlobalMid_Lock);
436 mutex_unlock(&server->srv_mutex);
438 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
439 list_for_each_safe(tmp, tmp2, &retry_list) {
440 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
441 list_del_init(&mid_entry->qhead);
442 mid_entry->callback(mid_entry);
448 /* we should try only the port we connected to before */
449 mutex_lock(&server->srv_mutex);
450 rc = generic_ip_connect(server);
452 cifs_dbg(FYI, "reconnect error %d\n", rc);
453 rc = reconn_set_ipaddr(server);
455 cifs_dbg(FYI, "%s: failed to resolve hostname: %d\n",
458 mutex_unlock(&server->srv_mutex);
461 atomic_inc(&tcpSesReconnectCount);
462 spin_lock(&GlobalMid_Lock);
463 if (server->tcpStatus != CifsExiting)
464 server->tcpStatus = CifsNeedNegotiate;
465 spin_unlock(&GlobalMid_Lock);
466 mutex_unlock(&server->srv_mutex);
468 } while (server->tcpStatus == CifsNeedReconnect);
470 if (server->tcpStatus == CifsNeedNegotiate)
471 mod_delayed_work(cifsiod_wq, &server->echo, 0);
477 cifs_echo_request(struct work_struct *work)
480 struct TCP_Server_Info *server = container_of(work,
481 struct TCP_Server_Info, echo.work);
482 unsigned long echo_interval;
485 * If we need to renegotiate, set echo interval to zero to
486 * immediately call echo service where we can renegotiate.
488 if (server->tcpStatus == CifsNeedNegotiate)
491 echo_interval = SMB_ECHO_INTERVAL;
494 * We cannot send an echo if it is disabled.
495 * Also, no need to ping if we got a response recently.
498 if (server->tcpStatus == CifsNeedReconnect ||
499 server->tcpStatus == CifsExiting ||
500 server->tcpStatus == CifsNew ||
501 (server->ops->can_echo && !server->ops->can_echo(server)) ||
502 time_before(jiffies, server->lstrp + echo_interval - HZ))
505 rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
507 cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
511 queue_delayed_work(cifsiod_wq, &server->echo, SMB_ECHO_INTERVAL);
515 allocate_buffers(struct TCP_Server_Info *server)
517 if (!server->bigbuf) {
518 server->bigbuf = (char *)cifs_buf_get();
519 if (!server->bigbuf) {
520 cifs_dbg(VFS, "No memory for large SMB response\n");
522 /* retry will check if exiting */
525 } else if (server->large_buf) {
526 /* we are reusing a dirty large buf, clear its start */
527 memset(server->bigbuf, 0, HEADER_SIZE(server));
530 if (!server->smallbuf) {
531 server->smallbuf = (char *)cifs_small_buf_get();
532 if (!server->smallbuf) {
533 cifs_dbg(VFS, "No memory for SMB response\n");
535 /* retry will check if exiting */
538 /* beginning of smb buffer is cleared in our buf_get */
540 /* if existing small buf clear beginning */
541 memset(server->smallbuf, 0, HEADER_SIZE(server));
548 server_unresponsive(struct TCP_Server_Info *server)
551 * We need to wait 3 echo intervals to make sure we handle such
553 * 1s client sends a normal SMB request
554 * 3s client gets a response
555 * 30s echo workqueue job pops, and decides we got a response recently
556 * and don't need to send another
558 * 65s kernel_recvmsg times out, and we see that we haven't gotten
559 * a response in >60s.
561 if ((server->tcpStatus == CifsGood ||
562 server->tcpStatus == CifsNeedNegotiate) &&
563 time_after(jiffies, server->lstrp + 3 * SMB_ECHO_INTERVAL)) {
564 cifs_dbg(VFS, "Server %s has not responded in %d seconds. Reconnecting...\n",
565 server->hostname, (3 * SMB_ECHO_INTERVAL) / HZ);
566 cifs_reconnect(server);
567 wake_up(&server->response_q);
575 * kvec_array_init - clone a kvec array, and advance into it
576 * @new: pointer to memory for cloned array
577 * @iov: pointer to original array
578 * @nr_segs: number of members in original array
579 * @bytes: number of bytes to advance into the cloned array
581 * This function will copy the array provided in iov to a section of memory
582 * and advance the specified number of bytes into the new array. It returns
583 * the number of segments in the new array. "new" must be at least as big as
584 * the original iov array.
587 kvec_array_init(struct kvec *new, struct kvec *iov, unsigned int nr_segs,
592 while (bytes || !iov->iov_len) {
593 int copy = min(bytes, iov->iov_len);
597 if (iov->iov_len == base) {
603 memcpy(new, iov, sizeof(*iov) * nr_segs);
604 new->iov_base += base;
605 new->iov_len -= base;
610 get_server_iovec(struct TCP_Server_Info *server, unsigned int nr_segs)
612 struct kvec *new_iov;
614 if (server->iov && nr_segs <= server->nr_iov)
617 /* not big enough -- allocate a new one and release the old */
618 new_iov = kmalloc(sizeof(*new_iov) * nr_segs, GFP_NOFS);
621 server->iov = new_iov;
622 server->nr_iov = nr_segs;
628 cifs_readv_from_socket(struct TCP_Server_Info *server, struct kvec *iov_orig,
629 unsigned int nr_segs, unsigned int to_read)
634 struct msghdr smb_msg;
637 iov = get_server_iovec(server, nr_segs);
641 smb_msg.msg_control = NULL;
642 smb_msg.msg_controllen = 0;
644 for (total_read = 0; to_read; total_read += length, to_read -= length) {
647 if (server_unresponsive(server)) {
648 total_read = -ECONNABORTED;
652 segs = kvec_array_init(iov, iov_orig, nr_segs, total_read);
654 length = kernel_recvmsg(server->ssocket, &smb_msg,
655 iov, segs, to_read, 0);
657 if (server->tcpStatus == CifsExiting) {
658 total_read = -ESHUTDOWN;
660 } else if (server->tcpStatus == CifsNeedReconnect) {
661 cifs_reconnect(server);
662 total_read = -ECONNABORTED;
664 } else if (length == -ERESTARTSYS ||
668 * Minimum sleep to prevent looping, allowing socket
669 * to clear and app threads to set tcpStatus
670 * CifsNeedReconnect if server hung.
672 usleep_range(1000, 2000);
675 } else if (length <= 0) {
676 cifs_dbg(FYI, "Received no data or error: expecting %d\n"
677 "got %d", to_read, length);
678 cifs_reconnect(server);
679 total_read = -ECONNABORTED;
687 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
688 unsigned int to_read)
693 iov.iov_len = to_read;
695 return cifs_readv_from_socket(server, &iov, 1, to_read);
699 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
702 * The first byte big endian of the length field,
703 * is actually not part of the length but the type
704 * with the most common, zero, as regular data.
707 case RFC1002_SESSION_MESSAGE:
708 /* Regular SMB response */
710 case RFC1002_SESSION_KEEP_ALIVE:
711 cifs_dbg(FYI, "RFC 1002 session keep alive\n");
713 case RFC1002_POSITIVE_SESSION_RESPONSE:
714 cifs_dbg(FYI, "RFC 1002 positive session response\n");
716 case RFC1002_NEGATIVE_SESSION_RESPONSE:
718 * We get this from Windows 98 instead of an error on
719 * SMB negprot response.
721 cifs_dbg(FYI, "RFC 1002 negative session response\n");
722 /* give server a second to clean up */
725 * Always try 445 first on reconnect since we get NACK
726 * on some if we ever connected to port 139 (the NACK
727 * is since we do not begin with RFC1001 session
730 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
731 cifs_reconnect(server);
732 wake_up(&server->response_q);
735 cifs_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
736 cifs_reconnect(server);
743 dequeue_mid(struct mid_q_entry *mid, bool malformed)
745 #ifdef CONFIG_CIFS_STATS2
746 mid->when_received = jiffies;
748 spin_lock(&GlobalMid_Lock);
750 mid->mid_state = MID_RESPONSE_RECEIVED;
752 mid->mid_state = MID_RESPONSE_MALFORMED;
753 list_del_init(&mid->qhead);
754 spin_unlock(&GlobalMid_Lock);
758 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
759 char *buf, int malformed)
761 if (server->ops->check_trans2 &&
762 server->ops->check_trans2(mid, server, buf, malformed))
765 mid->large_buf = server->large_buf;
766 /* Was previous buf put in mpx struct for multi-rsp? */
767 if (!mid->multiRsp) {
768 /* smb buffer will be freed by user thread */
769 if (server->large_buf)
770 server->bigbuf = NULL;
772 server->smallbuf = NULL;
774 dequeue_mid(mid, malformed);
777 static void clean_demultiplex_info(struct TCP_Server_Info *server)
781 /* take it off the list, if it's not already */
782 spin_lock(&cifs_tcp_ses_lock);
783 list_del_init(&server->tcp_ses_list);
784 spin_unlock(&cifs_tcp_ses_lock);
786 cancel_delayed_work_sync(&server->echo);
788 spin_lock(&GlobalMid_Lock);
789 server->tcpStatus = CifsExiting;
790 spin_unlock(&GlobalMid_Lock);
791 wake_up_all(&server->response_q);
793 /* check if we have blocked requests that need to free */
794 spin_lock(&server->req_lock);
795 if (server->credits <= 0)
797 spin_unlock(&server->req_lock);
799 * Although there should not be any requests blocked on this queue it
800 * can not hurt to be paranoid and try to wake up requests that may
801 * haven been blocked when more than 50 at time were on the wire to the
802 * same server - they now will see the session is in exit state and get
803 * out of SendReceive.
805 wake_up_all(&server->request_q);
806 /* give those requests time to exit */
809 if (server->ssocket) {
810 sock_release(server->ssocket);
811 server->ssocket = NULL;
814 if (!list_empty(&server->pending_mid_q)) {
815 struct list_head dispose_list;
816 struct mid_q_entry *mid_entry;
817 struct list_head *tmp, *tmp2;
819 INIT_LIST_HEAD(&dispose_list);
820 spin_lock(&GlobalMid_Lock);
821 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
822 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
823 cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid);
824 mid_entry->mid_state = MID_SHUTDOWN;
825 list_move(&mid_entry->qhead, &dispose_list);
827 spin_unlock(&GlobalMid_Lock);
829 /* now walk dispose list and issue callbacks */
830 list_for_each_safe(tmp, tmp2, &dispose_list) {
831 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
832 cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid);
833 list_del_init(&mid_entry->qhead);
834 mid_entry->callback(mid_entry);
836 /* 1/8th of sec is more than enough time for them to exit */
840 if (!list_empty(&server->pending_mid_q)) {
842 * mpx threads have not exited yet give them at least the smb
843 * send timeout time for long ops.
845 * Due to delays on oplock break requests, we need to wait at
846 * least 45 seconds before giving up on a request getting a
847 * response and going ahead and killing cifsd.
849 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
852 * If threads still have not exited they are probably never
853 * coming home not much else we can do but free the memory.
857 kfree(server->hostname);
861 length = atomic_dec_return(&tcpSesAllocCount);
863 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
867 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
870 char *buf = server->smallbuf;
871 unsigned int pdu_length = get_rfc1002_length(buf);
873 /* make sure this will fit in a large buffer */
874 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) - 4) {
875 cifs_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
876 cifs_reconnect(server);
877 wake_up(&server->response_q);
878 return -ECONNABORTED;
881 /* switch to large buffer if too big for a small one */
882 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
883 server->large_buf = true;
884 memcpy(server->bigbuf, buf, server->total_read);
885 buf = server->bigbuf;
888 /* now read the rest */
889 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
890 pdu_length - HEADER_SIZE(server) + 1 + 4);
893 server->total_read += length;
895 dump_smb(buf, server->total_read);
898 * We know that we received enough to get to the MID as we
899 * checked the pdu_length earlier. Now check to see
900 * if the rest of the header is OK. We borrow the length
901 * var for the rest of the loop to avoid a new stack var.
903 * 48 bytes is enough to display the header and a little bit
904 * into the payload for debugging purposes.
906 length = server->ops->check_message(buf, server->total_read);
908 cifs_dump_mem("Bad SMB: ", buf,
909 min_t(unsigned int, server->total_read, 48));
911 if (server->ops->is_session_expired &&
912 server->ops->is_session_expired(buf)) {
913 cifs_reconnect(server);
914 wake_up(&server->response_q);
918 if (server->ops->is_status_pending &&
919 server->ops->is_status_pending(buf, server, length))
925 handle_mid(mid, server, buf, length);
930 cifs_demultiplex_thread(void *p)
933 struct TCP_Server_Info *server = p;
934 unsigned int pdu_length;
936 struct task_struct *task_to_wake = NULL;
937 struct mid_q_entry *mid_entry;
939 current->flags |= PF_MEMALLOC;
940 cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
942 length = atomic_inc_return(&tcpSesAllocCount);
944 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
947 allow_kernel_signal(SIGKILL);
948 while (server->tcpStatus != CifsExiting) {
952 if (!allocate_buffers(server))
955 server->large_buf = false;
956 buf = server->smallbuf;
957 pdu_length = 4; /* enough to get RFC1001 header */
959 length = cifs_read_from_socket(server, buf, pdu_length);
962 server->total_read = length;
965 * The right amount was read from socket - 4 bytes,
966 * so we can now interpret the length field.
968 pdu_length = get_rfc1002_length(buf);
970 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
971 if (!is_smb_response(server, buf[0]))
974 /* make sure we have enough to get to the MID */
975 if (pdu_length < HEADER_SIZE(server) - 1 - 4) {
976 cifs_dbg(VFS, "SMB response too short (%u bytes)\n",
978 cifs_reconnect(server);
979 wake_up(&server->response_q);
983 /* read down to the MID */
984 length = cifs_read_from_socket(server, buf + 4,
985 HEADER_SIZE(server) - 1 - 4);
988 server->total_read += length;
990 mid_entry = server->ops->find_mid(server, buf);
992 if (!mid_entry || !mid_entry->receive)
993 length = standard_receive3(server, mid_entry);
995 length = mid_entry->receive(server, mid_entry);
1000 if (server->large_buf)
1001 buf = server->bigbuf;
1003 server->lstrp = jiffies;
1004 if (mid_entry != NULL) {
1005 if ((mid_entry->mid_flags & MID_WAIT_CANCELLED) &&
1006 mid_entry->mid_state == MID_RESPONSE_RECEIVED &&
1007 server->ops->handle_cancelled_mid)
1008 server->ops->handle_cancelled_mid(
1009 mid_entry->resp_buf,
1012 if (!mid_entry->multiRsp || mid_entry->multiEnd)
1013 mid_entry->callback(mid_entry);
1014 } else if (server->ops->is_oplock_break &&
1015 server->ops->is_oplock_break(buf, server)) {
1016 cifs_dbg(FYI, "Received oplock break\n");
1018 cifs_dbg(VFS, "No task to wake, unknown frame received! NumMids %d\n",
1019 atomic_read(&midCount));
1020 cifs_dump_mem("Received Data is: ", buf,
1021 HEADER_SIZE(server));
1022 #ifdef CONFIG_CIFS_DEBUG2
1023 if (server->ops->dump_detail)
1024 server->ops->dump_detail(buf);
1025 cifs_dump_mids(server);
1026 #endif /* CIFS_DEBUG2 */
1029 } /* end while !EXITING */
1031 /* buffer usually freed in free_mid - need to free it here on exit */
1032 cifs_buf_release(server->bigbuf);
1033 if (server->smallbuf) /* no sense logging a debug message if NULL */
1034 cifs_small_buf_release(server->smallbuf);
1036 task_to_wake = xchg(&server->tsk, NULL);
1037 clean_demultiplex_info(server);
1039 /* if server->tsk was NULL then wait for a signal before exiting */
1040 if (!task_to_wake) {
1041 set_current_state(TASK_INTERRUPTIBLE);
1042 while (!signal_pending(current)) {
1044 set_current_state(TASK_INTERRUPTIBLE);
1046 set_current_state(TASK_RUNNING);
1049 module_put_and_exit(0);
1052 /* extract the host portion of the UNC string */
1054 extract_hostname(const char *unc)
1060 /* skip double chars at beginning of string */
1061 /* BB: check validity of these bytes? */
1064 /* delimiter between hostname and sharename is always '\\' now */
1065 delim = strchr(src, '\\');
1067 return ERR_PTR(-EINVAL);
1070 dst = kmalloc((len + 1), GFP_KERNEL);
1072 return ERR_PTR(-ENOMEM);
1074 memcpy(dst, src, len);
1080 static int get_option_ul(substring_t args[], unsigned long *option)
1085 string = match_strdup(args);
1088 rc = kstrtoul(string, 0, option);
1094 static int get_option_uid(substring_t args[], kuid_t *result)
1096 unsigned long value;
1100 rc = get_option_ul(args, &value);
1104 uid = make_kuid(current_user_ns(), value);
1105 if (!uid_valid(uid))
1112 static int get_option_gid(substring_t args[], kgid_t *result)
1114 unsigned long value;
1118 rc = get_option_ul(args, &value);
1122 gid = make_kgid(current_user_ns(), value);
1123 if (!gid_valid(gid))
1130 static int cifs_parse_security_flavors(char *value,
1131 struct smb_vol *vol)
1134 substring_t args[MAX_OPT_ARGS];
1137 * With mount options, the last one should win. Reset any existing
1138 * settings back to default.
1140 vol->sectype = Unspecified;
1143 switch (match_token(value, cifs_secflavor_tokens, args)) {
1145 cifs_dbg(VFS, "sec=krb5p is not supported!\n");
1151 vol->sectype = Kerberos;
1153 case Opt_sec_ntlmsspi:
1156 case Opt_sec_ntlmssp:
1157 vol->sectype = RawNTLMSSP;
1163 vol->sectype = NTLM;
1165 case Opt_sec_ntlmv2i:
1168 case Opt_sec_ntlmv2:
1169 vol->sectype = NTLMv2;
1171 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1172 case Opt_sec_lanman:
1173 vol->sectype = LANMAN;
1180 cifs_dbg(VFS, "bad security option: %s\n", value);
1188 cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1190 substring_t args[MAX_OPT_ARGS];
1192 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1193 case Opt_cache_loose:
1194 vol->direct_io = false;
1195 vol->strict_io = false;
1197 case Opt_cache_strict:
1198 vol->direct_io = false;
1199 vol->strict_io = true;
1201 case Opt_cache_none:
1202 vol->direct_io = true;
1203 vol->strict_io = false;
1206 cifs_dbg(VFS, "bad cache= option: %s\n", value);
1213 cifs_parse_smb_version(char *value, struct smb_vol *vol)
1215 substring_t args[MAX_OPT_ARGS];
1217 switch (match_token(value, cifs_smb_version_tokens, args)) {
1219 vol->ops = &smb1_operations;
1220 vol->vals = &smb1_values;
1222 #ifdef CONFIG_CIFS_SMB2
1224 vol->ops = &smb20_operations;
1225 vol->vals = &smb20_values;
1228 vol->ops = &smb21_operations;
1229 vol->vals = &smb21_values;
1232 vol->ops = &smb30_operations;
1233 vol->vals = &smb30_values;
1236 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1237 vol->vals = &smb302_values;
1239 #ifdef CONFIG_CIFS_SMB311
1241 vol->ops = &smb311_operations;
1242 vol->vals = &smb311_values;
1247 cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
1254 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1255 * fields with the result. Returns 0 on success and an error otherwise.
1258 cifs_parse_devname(const char *devname, struct smb_vol *vol)
1261 const char *delims = "/\\";
1264 if (unlikely(!devname || !*devname)) {
1265 cifs_dbg(VFS, "Device name not specified.\n");
1269 /* make sure we have a valid UNC double delimiter prefix */
1270 len = strspn(devname, delims);
1274 /* find delimiter between host and sharename */
1275 pos = strpbrk(devname + 2, delims);
1279 /* skip past delimiter */
1282 /* now go until next delimiter or end of string */
1283 len = strcspn(pos, delims);
1285 /* move "pos" up to delimiter or NULL */
1287 vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1291 convert_delimiter(vol->UNC, '\\');
1293 /* If pos is NULL, or is a bogus trailing delimiter then no prepath */
1294 if (!*pos++ || !*pos)
1297 vol->prepath = kstrdup(pos, GFP_KERNEL);
1305 cifs_parse_mount_options(const char *mountdata, const char *devname,
1306 struct smb_vol *vol)
1309 char *mountdata_copy = NULL, *options;
1310 unsigned int temp_len, i, j;
1312 short int override_uid = -1;
1313 short int override_gid = -1;
1314 bool uid_specified = false;
1315 bool gid_specified = false;
1316 bool sloppy = false;
1317 char *invalid = NULL;
1318 char *nodename = utsname()->nodename;
1319 char *string = NULL;
1320 char *tmp_end, *value;
1322 bool got_ip = false;
1323 unsigned short port = 0;
1324 struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1328 delim = separator[0];
1330 /* ensure we always start with zeroed-out smb_vol */
1331 memset(vol, 0, sizeof(*vol));
1334 * does not have to be perfect mapping since field is
1335 * informational, only used for servers that do not support
1336 * port 445 and it can be overridden at mount time
1338 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1339 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1340 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1342 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1343 /* null target name indicates to use *SMBSERVR default called name
1344 if we end up sending RFC1001 session initialize */
1345 vol->target_rfc1001_name[0] = 0;
1346 vol->cred_uid = current_uid();
1347 vol->linux_uid = current_uid();
1348 vol->linux_gid = current_gid();
1351 * default to SFM style remapping of seven reserved characters
1352 * unless user overrides it or we negotiate CIFS POSIX where
1353 * it is unnecessary. Can not simultaneously use more than one mapping
1354 * since then readdir could list files that open could not open
1358 /* default to only allowing write access to owner of the mount */
1359 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1361 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1362 /* default is always to request posix paths. */
1363 vol->posix_paths = 1;
1364 /* default to using server inode numbers where available */
1365 vol->server_ino = 1;
1367 /* default is to use strict cifs caching semantics */
1368 vol->strict_io = true;
1370 vol->actimeo = CIFS_DEF_ACTIMEO;
1372 /* FIXME: add autonegotiation -- for now, SMB1 is default */
1373 vol->ops = &smb1_operations;
1374 vol->vals = &smb1_values;
1377 goto cifs_parse_mount_err;
1379 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1380 if (!mountdata_copy)
1381 goto cifs_parse_mount_err;
1383 options = mountdata_copy;
1384 end = options + strlen(options);
1386 if (strncmp(options, "sep=", 4) == 0) {
1387 if (options[4] != 0) {
1388 separator[0] = options[4];
1391 cifs_dbg(FYI, "Null separator not allowed\n");
1394 vol->backupuid_specified = false; /* no backup intent for a user */
1395 vol->backupgid_specified = false; /* no backup intent for a group */
1397 switch (cifs_parse_devname(devname, vol)) {
1401 cifs_dbg(VFS, "Unable to allocate memory for devname.\n");
1402 goto cifs_parse_mount_err;
1404 cifs_dbg(VFS, "Malformed UNC in devname.\n");
1405 goto cifs_parse_mount_err;
1407 cifs_dbg(VFS, "Unknown error parsing devname.\n");
1408 goto cifs_parse_mount_err;
1411 while ((data = strsep(&options, separator)) != NULL) {
1412 substring_t args[MAX_OPT_ARGS];
1413 unsigned long option;
1419 token = match_token(data, cifs_mount_option_tokens, args);
1423 /* Ingnore the following */
1427 /* Boolean values */
1428 case Opt_user_xattr:
1431 case Opt_nouser_xattr:
1437 case Opt_noforceuid:
1443 case Opt_noforcegid:
1446 case Opt_noblocksend:
1447 vol->noblocksnd = 1;
1449 case Opt_noautotune:
1450 vol->noautotune = 1;
1465 vol->sfu_remap = true;
1466 vol->remap = false; /* disable SFM mapping */
1468 case Opt_nomapchars:
1469 vol->sfu_remap = false;
1473 vol->sfu_remap = false; /* disable SFU mapping */
1475 case Opt_nomapposix:
1487 case Opt_posixpaths:
1488 vol->posix_paths = 1;
1490 case Opt_noposixpaths:
1491 vol->posix_paths = 0;
1494 vol->no_linux_ext = 1;
1505 * turn off mandatory locking in mode
1506 * if remote locking is turned off since the
1507 * local vfs will do advisory
1509 if (vol->file_mode ==
1510 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1511 vol->file_mode = S_IALLUGO;
1513 case Opt_forcemandatorylock:
1523 vol->dynperm = true;
1526 vol->dynperm = false;
1540 case Opt_nostrictsync:
1541 vol->nostrictsync = 1;
1543 case Opt_strictsync:
1544 vol->nostrictsync = 0;
1547 vol->server_ino = 1;
1549 case Opt_noserverino:
1550 vol->server_ino = 0;
1552 case Opt_rwpidforward:
1553 vol->rwpidforward = 1;
1562 vol->no_psx_acl = 0;
1565 vol->no_psx_acl = 1;
1567 case Opt_locallease:
1568 vol->local_lease = 1;
1574 /* we do not do the following in secFlags because seal
1575 * is a per tree connection (mount) not a per socket
1576 * or per-smb connection option in the protocol
1577 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1582 pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1585 #ifndef CONFIG_CIFS_FSCACHE
1586 cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1587 goto cifs_parse_mount_err;
1591 case Opt_mfsymlinks:
1592 vol->mfsymlinks = true;
1595 vol->multiuser = true;
1600 case Opt_nosharesock:
1601 vol->nosharesock = true;
1603 case Opt_nopersistent:
1604 vol->nopersistent = true;
1605 if (vol->persistent) {
1607 "persistenthandles mount options conflict\n");
1608 goto cifs_parse_mount_err;
1611 case Opt_persistent:
1612 vol->persistent = true;
1613 if ((vol->nopersistent) || (vol->resilient)) {
1615 "persistenthandles mount options conflict\n");
1616 goto cifs_parse_mount_err;
1620 vol->resilient = true;
1621 if (vol->persistent) {
1623 "persistenthandles mount options conflict\n");
1624 goto cifs_parse_mount_err;
1627 case Opt_noresilient:
1628 vol->resilient = false; /* already the default */
1631 /* Numeric Values */
1633 if (get_option_uid(args, &vol->backupuid)) {
1634 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
1636 goto cifs_parse_mount_err;
1638 vol->backupuid_specified = true;
1641 if (get_option_gid(args, &vol->backupgid)) {
1642 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
1644 goto cifs_parse_mount_err;
1646 vol->backupgid_specified = true;
1649 if (get_option_uid(args, &vol->linux_uid)) {
1650 cifs_dbg(VFS, "%s: Invalid uid value\n",
1652 goto cifs_parse_mount_err;
1654 uid_specified = true;
1657 if (get_option_uid(args, &vol->cred_uid)) {
1658 cifs_dbg(VFS, "%s: Invalid cruid value\n",
1660 goto cifs_parse_mount_err;
1664 if (get_option_gid(args, &vol->linux_gid)) {
1665 cifs_dbg(VFS, "%s: Invalid gid value\n",
1667 goto cifs_parse_mount_err;
1669 gid_specified = true;
1672 if (get_option_ul(args, &option)) {
1673 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
1675 goto cifs_parse_mount_err;
1677 vol->file_mode = option;
1680 if (get_option_ul(args, &option)) {
1681 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
1683 goto cifs_parse_mount_err;
1685 vol->dir_mode = option;
1688 if (get_option_ul(args, &option) ||
1689 option > USHRT_MAX) {
1690 cifs_dbg(VFS, "%s: Invalid port value\n",
1692 goto cifs_parse_mount_err;
1694 port = (unsigned short)option;
1697 if (get_option_ul(args, &option)) {
1698 cifs_dbg(VFS, "%s: Invalid rsize value\n",
1700 goto cifs_parse_mount_err;
1702 vol->rsize = option;
1705 if (get_option_ul(args, &option)) {
1706 cifs_dbg(VFS, "%s: Invalid wsize value\n",
1708 goto cifs_parse_mount_err;
1710 vol->wsize = option;
1713 if (get_option_ul(args, &option)) {
1714 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
1716 goto cifs_parse_mount_err;
1718 vol->actimeo = HZ * option;
1719 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1720 cifs_dbg(VFS, "attribute cache timeout too large\n");
1721 goto cifs_parse_mount_err;
1725 /* String Arguments */
1727 case Opt_blank_user:
1728 /* null user, ie. anonymous authentication */
1730 vol->username = NULL;
1733 string = match_strdup(args);
1737 if (strnlen(string, CIFS_MAX_USERNAME_LEN) >
1738 CIFS_MAX_USERNAME_LEN) {
1739 pr_warn("CIFS: username too long\n");
1740 goto cifs_parse_mount_err;
1743 kfree(vol->username);
1744 vol->username = kstrdup(string, GFP_KERNEL);
1746 goto cifs_parse_mount_err;
1748 case Opt_blank_pass:
1749 /* passwords have to be handled differently
1750 * to allow the character used for deliminator
1751 * to be passed within them
1755 * Check if this is a case where the password
1756 * starts with a delimiter
1758 tmp_end = strchr(data, '=');
1760 if (!(tmp_end < end && tmp_end[1] == delim)) {
1761 /* No it is not. Set the password to NULL */
1762 kzfree(vol->password);
1763 vol->password = NULL;
1766 /* Yes it is. Drop down to Opt_pass below.*/
1768 /* Obtain the value string */
1769 value = strchr(data, '=');
1772 /* Set tmp_end to end of the string */
1773 tmp_end = (char *) value + strlen(value);
1775 /* Check if following character is the deliminator
1776 * If yes, we have encountered a double deliminator
1777 * reset the NULL character to the deliminator
1779 if (tmp_end < end && tmp_end[1] == delim) {
1782 /* Keep iterating until we get to a single
1783 * deliminator OR the end
1785 while ((tmp_end = strchr(tmp_end, delim))
1786 != NULL && (tmp_end[1] == delim)) {
1787 tmp_end = (char *) &tmp_end[2];
1790 /* Reset var options to point to next element */
1793 options = (char *) &tmp_end[1];
1795 /* Reached the end of the mount option
1800 kzfree(vol->password);
1801 /* Now build new password string */
1802 temp_len = strlen(value);
1803 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1804 if (vol->password == NULL) {
1805 pr_warn("CIFS: no memory for password\n");
1806 goto cifs_parse_mount_err;
1809 for (i = 0, j = 0; i < temp_len; i++, j++) {
1810 vol->password[j] = value[i];
1811 if ((value[i] == delim) &&
1812 value[i+1] == delim)
1813 /* skip the second deliminator */
1816 vol->password[j] = '\0';
1819 /* FIXME: should this be an error instead? */
1823 string = match_strdup(args);
1827 if (!cifs_convert_address(dstaddr, string,
1829 pr_err("CIFS: bad ip= option (%s).\n", string);
1830 goto cifs_parse_mount_err;
1835 string = match_strdup(args);
1839 if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
1840 == CIFS_MAX_DOMAINNAME_LEN) {
1841 pr_warn("CIFS: domain name too long\n");
1842 goto cifs_parse_mount_err;
1845 kfree(vol->domainname);
1846 vol->domainname = kstrdup(string, GFP_KERNEL);
1847 if (!vol->domainname) {
1848 pr_warn("CIFS: no memory for domainname\n");
1849 goto cifs_parse_mount_err;
1851 cifs_dbg(FYI, "Domain name set\n");
1854 string = match_strdup(args);
1858 if (!cifs_convert_address(
1859 (struct sockaddr *)&vol->srcaddr,
1860 string, strlen(string))) {
1861 pr_warn("CIFS: Could not parse srcaddr: %s\n",
1863 goto cifs_parse_mount_err;
1867 string = match_strdup(args);
1871 if (strnlen(string, 1024) >= 65) {
1872 pr_warn("CIFS: iocharset name too long.\n");
1873 goto cifs_parse_mount_err;
1876 if (strncasecmp(string, "default", 7) != 0) {
1877 kfree(vol->iocharset);
1878 vol->iocharset = kstrdup(string,
1880 if (!vol->iocharset) {
1881 pr_warn("CIFS: no memory for charset\n");
1882 goto cifs_parse_mount_err;
1885 /* if iocharset not set then load_nls_default
1888 cifs_dbg(FYI, "iocharset set to %s\n", string);
1890 case Opt_netbiosname:
1891 string = match_strdup(args);
1895 memset(vol->source_rfc1001_name, 0x20,
1898 * FIXME: are there cases in which a comma can
1899 * be valid in workstation netbios name (and
1900 * need special handling)?
1902 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1903 /* don't ucase netbiosname for user */
1906 vol->source_rfc1001_name[i] = string[i];
1908 /* The string has 16th byte zero still from
1909 * set at top of the function
1911 if (i == RFC1001_NAME_LEN && string[i] != 0)
1912 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
1915 /* servernetbiosname specified override *SMBSERVER */
1916 string = match_strdup(args);
1920 /* last byte, type, is 0x20 for servr type */
1921 memset(vol->target_rfc1001_name, 0x20,
1922 RFC1001_NAME_LEN_WITH_NULL);
1924 /* BB are there cases in which a comma can be
1925 valid in this workstation netbios name
1926 (and need special handling)? */
1928 /* user or mount helper must uppercase the
1930 for (i = 0; i < 15; i++) {
1933 vol->target_rfc1001_name[i] = string[i];
1935 /* The string has 16th byte zero still from
1936 set at top of the function */
1937 if (i == RFC1001_NAME_LEN && string[i] != 0)
1938 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
1941 string = match_strdup(args);
1945 if (strncasecmp(string, "1", 1) == 0) {
1946 /* This is the default */
1949 /* For all other value, error */
1950 pr_warn("CIFS: Invalid version specified\n");
1951 goto cifs_parse_mount_err;
1953 string = match_strdup(args);
1957 if (cifs_parse_smb_version(string, vol) != 0)
1958 goto cifs_parse_mount_err;
1961 string = match_strdup(args);
1965 if (cifs_parse_security_flavors(string, vol) != 0)
1966 goto cifs_parse_mount_err;
1969 string = match_strdup(args);
1973 if (cifs_parse_cache_flavor(string, vol) != 0)
1974 goto cifs_parse_mount_err;
1978 * An option we don't recognize. Save it off for later
1979 * if we haven't already found one
1985 /* Free up any allocated string */
1990 if (!sloppy && invalid) {
1991 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid);
1992 goto cifs_parse_mount_err;
1996 /* Muliuser mounts require CONFIG_KEYS support */
1997 if (vol->multiuser) {
1998 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
1999 goto cifs_parse_mount_err;
2003 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
2004 goto cifs_parse_mount_err;
2007 /* make sure UNC has a share name */
2008 if (!strchr(vol->UNC + 3, '\\')) {
2009 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
2010 goto cifs_parse_mount_err;
2014 /* No ip= option specified? Try to get it from UNC */
2015 if (!cifs_convert_address(dstaddr, &vol->UNC[2],
2016 strlen(&vol->UNC[2]))) {
2017 pr_err("Unable to determine destination address.\n");
2018 goto cifs_parse_mount_err;
2022 /* set the port that we got earlier */
2023 cifs_set_port(dstaddr, port);
2026 vol->override_uid = override_uid;
2027 else if (override_uid == 1)
2028 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
2031 vol->override_gid = override_gid;
2032 else if (override_gid == 1)
2033 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
2035 kfree(mountdata_copy);
2039 pr_warn("Could not allocate temporary buffer\n");
2040 cifs_parse_mount_err:
2042 kfree(mountdata_copy);
2046 /** Returns true if srcaddr isn't specified and rhs isn't
2047 * specified, or if srcaddr is specified and
2048 * matches the IP address of the rhs argument.
2051 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
2053 switch (srcaddr->sa_family) {
2055 return (rhs->sa_family == AF_UNSPEC);
2057 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
2058 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
2059 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
2062 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
2063 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
2064 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
2068 return false; /* don't expect to be here */
2073 * If no port is specified in addr structure, we try to match with 445 port
2074 * and if it fails - with 139 ports. It should be called only if address
2075 * families of server and addr are equal.
2078 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
2080 __be16 port, *sport;
2082 switch (addr->sa_family) {
2084 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
2085 port = ((struct sockaddr_in *) addr)->sin_port;
2088 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
2089 port = ((struct sockaddr_in6 *) addr)->sin6_port;
2097 port = htons(CIFS_PORT);
2101 port = htons(RFC1001_PORT);
2104 return port == *sport;
2108 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
2109 struct sockaddr *srcaddr)
2111 switch (addr->sa_family) {
2113 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2114 struct sockaddr_in *srv_addr4 =
2115 (struct sockaddr_in *)&server->dstaddr;
2117 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
2122 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2123 struct sockaddr_in6 *srv_addr6 =
2124 (struct sockaddr_in6 *)&server->dstaddr;
2126 if (!ipv6_addr_equal(&addr6->sin6_addr,
2127 &srv_addr6->sin6_addr))
2129 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
2135 return false; /* don't expect to be here */
2138 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2145 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2148 * The select_sectype function should either return the vol->sectype
2149 * that was specified, or "Unspecified" if that sectype was not
2150 * compatible with the given NEGOTIATE request.
2152 if (select_sectype(server, vol->sectype) == Unspecified)
2156 * Now check if signing mode is acceptable. No need to check
2157 * global_secflags at this point since if MUST_SIGN is set then
2158 * the server->sign had better be too.
2160 if (vol->sign && !server->sign)
2166 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2168 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2170 if (vol->nosharesock)
2173 if ((server->vals != vol->vals) || (server->ops != vol->ops))
2176 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2179 if (!match_address(server, addr,
2180 (struct sockaddr *)&vol->srcaddr))
2183 if (!match_port(server, addr))
2186 if (!match_security(server, vol))
2192 static struct TCP_Server_Info *
2193 cifs_find_tcp_session(struct smb_vol *vol)
2195 struct TCP_Server_Info *server;
2197 spin_lock(&cifs_tcp_ses_lock);
2198 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2199 if (!match_server(server, vol))
2202 ++server->srv_count;
2203 spin_unlock(&cifs_tcp_ses_lock);
2204 cifs_dbg(FYI, "Existing tcp session with server found\n");
2207 spin_unlock(&cifs_tcp_ses_lock);
2212 cifs_put_tcp_session(struct TCP_Server_Info *server, int from_reconnect)
2214 struct task_struct *task;
2216 spin_lock(&cifs_tcp_ses_lock);
2217 if (--server->srv_count > 0) {
2218 spin_unlock(&cifs_tcp_ses_lock);
2222 put_net(cifs_net_ns(server));
2224 list_del_init(&server->tcp_ses_list);
2225 spin_unlock(&cifs_tcp_ses_lock);
2227 cancel_delayed_work_sync(&server->echo);
2229 #ifdef CONFIG_CIFS_SMB2
2232 * Avoid deadlock here: reconnect work calls
2233 * cifs_put_tcp_session() at its end. Need to be sure
2234 * that reconnect work does nothing with server pointer after
2237 cancel_delayed_work(&server->reconnect);
2239 cancel_delayed_work_sync(&server->reconnect);
2242 spin_lock(&GlobalMid_Lock);
2243 server->tcpStatus = CifsExiting;
2244 spin_unlock(&GlobalMid_Lock);
2246 cifs_crypto_shash_release(server);
2247 cifs_fscache_release_client_cookie(server);
2249 kfree(server->session_key.response);
2250 server->session_key.response = NULL;
2251 server->session_key.len = 0;
2253 task = xchg(&server->tsk, NULL);
2255 send_sig(SIGKILL, task, 1);
2258 static struct TCP_Server_Info *
2259 cifs_get_tcp_session(struct smb_vol *volume_info)
2261 struct TCP_Server_Info *tcp_ses = NULL;
2264 cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
2266 /* see if we already have a matching tcp_ses */
2267 tcp_ses = cifs_find_tcp_session(volume_info);
2271 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2277 tcp_ses->ops = volume_info->ops;
2278 tcp_ses->vals = volume_info->vals;
2279 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2280 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2281 if (IS_ERR(tcp_ses->hostname)) {
2282 rc = PTR_ERR(tcp_ses->hostname);
2283 goto out_err_crypto_release;
2286 tcp_ses->noblocksnd = volume_info->noblocksnd;
2287 tcp_ses->noautotune = volume_info->noautotune;
2288 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2289 tcp_ses->in_flight = 0;
2290 tcp_ses->credits = 1;
2291 init_waitqueue_head(&tcp_ses->response_q);
2292 init_waitqueue_head(&tcp_ses->request_q);
2293 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2294 mutex_init(&tcp_ses->srv_mutex);
2295 memcpy(tcp_ses->workstation_RFC1001_name,
2296 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2297 memcpy(tcp_ses->server_RFC1001_name,
2298 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2299 tcp_ses->session_estab = false;
2300 tcp_ses->sequence_number = 0;
2301 tcp_ses->lstrp = jiffies;
2302 spin_lock_init(&tcp_ses->req_lock);
2303 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2304 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2305 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2306 #ifdef CONFIG_CIFS_SMB2
2307 INIT_DELAYED_WORK(&tcp_ses->reconnect, smb2_reconnect_server);
2308 mutex_init(&tcp_ses->reconnect_mutex);
2310 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2311 sizeof(tcp_ses->srcaddr));
2312 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2313 sizeof(tcp_ses->dstaddr));
2314 #ifdef CONFIG_CIFS_SMB2
2315 generate_random_uuid(tcp_ses->client_guid);
2318 * at this point we are the only ones with the pointer
2319 * to the struct since the kernel thread not created yet
2320 * no need to spinlock this init of tcpStatus or srv_count
2322 tcp_ses->tcpStatus = CifsNew;
2323 ++tcp_ses->srv_count;
2325 rc = ip_connect(tcp_ses);
2327 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
2328 goto out_err_crypto_release;
2332 * since we're in a cifs function already, we know that
2333 * this will succeed. No need for try_module_get().
2335 __module_get(THIS_MODULE);
2336 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2338 if (IS_ERR(tcp_ses->tsk)) {
2339 rc = PTR_ERR(tcp_ses->tsk);
2340 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
2341 module_put(THIS_MODULE);
2342 goto out_err_crypto_release;
2344 tcp_ses->tcpStatus = CifsNeedNegotiate;
2346 /* thread spawned, put it on the list */
2347 spin_lock(&cifs_tcp_ses_lock);
2348 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2349 spin_unlock(&cifs_tcp_ses_lock);
2351 cifs_fscache_get_client_cookie(tcp_ses);
2353 /* queue echo request delayed work */
2354 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
2358 out_err_crypto_release:
2359 cifs_crypto_shash_release(tcp_ses);
2361 put_net(cifs_net_ns(tcp_ses));
2365 if (!IS_ERR(tcp_ses->hostname))
2366 kfree(tcp_ses->hostname);
2367 if (tcp_ses->ssocket)
2368 sock_release(tcp_ses->ssocket);
2374 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2376 if (vol->sectype != Unspecified &&
2377 vol->sectype != ses->sectype)
2380 switch (ses->sectype) {
2382 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2386 /* NULL username means anonymous session */
2387 if (ses->user_name == NULL) {
2393 /* anything else takes username/password */
2394 if (strncmp(ses->user_name,
2395 vol->username ? vol->username : "",
2396 CIFS_MAX_USERNAME_LEN))
2398 if ((vol->username && strlen(vol->username) != 0) &&
2399 ses->password != NULL &&
2400 strncmp(ses->password,
2401 vol->password ? vol->password : "",
2402 CIFS_MAX_PASSWORD_LEN))
2408 static struct cifs_ses *
2409 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2411 struct cifs_ses *ses;
2413 spin_lock(&cifs_tcp_ses_lock);
2414 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2415 if (ses->status == CifsExiting)
2417 if (!match_session(ses, vol))
2420 spin_unlock(&cifs_tcp_ses_lock);
2423 spin_unlock(&cifs_tcp_ses_lock);
2428 cifs_put_smb_ses(struct cifs_ses *ses)
2430 unsigned int rc, xid;
2431 struct TCP_Server_Info *server = ses->server;
2433 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
2435 spin_lock(&cifs_tcp_ses_lock);
2436 if (ses->status == CifsExiting) {
2437 spin_unlock(&cifs_tcp_ses_lock);
2440 if (--ses->ses_count > 0) {
2441 spin_unlock(&cifs_tcp_ses_lock);
2444 if (ses->status == CifsGood)
2445 ses->status = CifsExiting;
2446 spin_unlock(&cifs_tcp_ses_lock);
2448 if (ses->status == CifsExiting && server->ops->logoff) {
2450 rc = server->ops->logoff(xid, ses);
2452 cifs_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
2457 spin_lock(&cifs_tcp_ses_lock);
2458 list_del_init(&ses->smb_ses_list);
2459 spin_unlock(&cifs_tcp_ses_lock);
2462 cifs_put_tcp_session(server, 0);
2467 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2468 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2470 /* Populate username and pw fields from keyring if possible */
2472 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2476 const char *delim, *payload;
2480 struct TCP_Server_Info *server = ses->server;
2481 struct sockaddr_in *sa;
2482 struct sockaddr_in6 *sa6;
2483 const struct user_key_payload *upayload;
2485 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2489 /* try to find an address key first */
2490 switch (server->dstaddr.ss_family) {
2492 sa = (struct sockaddr_in *)&server->dstaddr;
2493 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2496 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2497 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2500 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2501 server->dstaddr.ss_family);
2506 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2507 key = request_key(&key_type_logon, desc, "");
2509 if (!ses->domainName) {
2510 cifs_dbg(FYI, "domainName is NULL\n");
2515 /* didn't work, try to find a domain key */
2516 sprintf(desc, "cifs:d:%s", ses->domainName);
2517 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2518 key = request_key(&key_type_logon, desc, "");
2526 down_read(&key->sem);
2527 upayload = user_key_payload(key);
2528 if (IS_ERR_OR_NULL(upayload)) {
2529 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2533 /* find first : in payload */
2534 payload = upayload->data;
2535 delim = strnchr(payload, upayload->datalen, ':');
2536 cifs_dbg(FYI, "payload=%s\n", payload);
2538 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
2544 len = delim - payload;
2545 if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
2546 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
2552 vol->username = kstrndup(payload, len, GFP_KERNEL);
2553 if (!vol->username) {
2554 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
2559 cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
2561 len = key->datalen - (len + 1);
2562 if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
2563 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
2565 kfree(vol->username);
2566 vol->username = NULL;
2571 vol->password = kstrndup(delim, len, GFP_KERNEL);
2572 if (!vol->password) {
2573 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
2576 kfree(vol->username);
2577 vol->username = NULL;
2582 * If we have a domain key then we must set the domainName in the
2585 if (is_domain && ses->domainName) {
2586 vol->domainname = kstrndup(ses->domainName,
2587 strlen(ses->domainName),
2589 if (!vol->domainname) {
2590 cifs_dbg(FYI, "Unable to allocate %zd bytes for "
2593 kfree(vol->username);
2594 vol->username = NULL;
2595 kzfree(vol->password);
2596 vol->password = NULL;
2606 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
2609 #else /* ! CONFIG_KEYS */
2611 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2612 struct cifs_ses *ses __attribute__((unused)))
2616 #endif /* CONFIG_KEYS */
2618 static struct cifs_ses *
2619 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2623 struct cifs_ses *ses;
2624 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2625 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2629 ses = cifs_find_smb_ses(server, volume_info);
2631 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
2634 mutex_lock(&ses->session_mutex);
2635 rc = cifs_negotiate_protocol(xid, ses);
2637 mutex_unlock(&ses->session_mutex);
2638 /* problem -- put our ses reference */
2639 cifs_put_smb_ses(ses);
2643 if (ses->need_reconnect) {
2644 cifs_dbg(FYI, "Session needs reconnect\n");
2645 rc = cifs_setup_session(xid, ses,
2646 volume_info->local_nls);
2648 mutex_unlock(&ses->session_mutex);
2649 /* problem -- put our reference */
2650 cifs_put_smb_ses(ses);
2655 mutex_unlock(&ses->session_mutex);
2657 /* existing SMB ses has a server reference already */
2658 cifs_put_tcp_session(server, 0);
2663 cifs_dbg(FYI, "Existing smb sess not found\n");
2664 ses = sesInfoAlloc();
2668 /* new SMB session uses our server ref */
2669 ses->server = server;
2670 if (server->dstaddr.ss_family == AF_INET6)
2671 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2673 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2675 if (volume_info->username) {
2676 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2677 if (!ses->user_name)
2681 /* volume_info->password freed at unmount */
2682 if (volume_info->password) {
2683 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2687 if (volume_info->domainname) {
2688 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2689 if (!ses->domainName)
2692 ses->cred_uid = volume_info->cred_uid;
2693 ses->linux_uid = volume_info->linux_uid;
2695 ses->sectype = volume_info->sectype;
2696 ses->sign = volume_info->sign;
2698 mutex_lock(&ses->session_mutex);
2699 rc = cifs_negotiate_protocol(xid, ses);
2701 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2702 mutex_unlock(&ses->session_mutex);
2706 /* success, put it on the list */
2707 spin_lock(&cifs_tcp_ses_lock);
2708 list_add(&ses->smb_ses_list, &server->smb_ses_list);
2709 spin_unlock(&cifs_tcp_ses_lock);
2720 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2722 if (tcon->tidStatus == CifsExiting)
2724 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2729 static struct cifs_tcon *
2730 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2732 struct list_head *tmp;
2733 struct cifs_tcon *tcon;
2735 spin_lock(&cifs_tcp_ses_lock);
2736 list_for_each(tmp, &ses->tcon_list) {
2737 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2738 if (!match_tcon(tcon, unc))
2741 spin_unlock(&cifs_tcp_ses_lock);
2744 spin_unlock(&cifs_tcp_ses_lock);
2749 cifs_put_tcon(struct cifs_tcon *tcon)
2752 struct cifs_ses *ses = tcon->ses;
2754 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2755 spin_lock(&cifs_tcp_ses_lock);
2756 if (--tcon->tc_count > 0) {
2757 spin_unlock(&cifs_tcp_ses_lock);
2761 list_del_init(&tcon->tcon_list);
2762 spin_unlock(&cifs_tcp_ses_lock);
2765 if (ses->server->ops->tree_disconnect)
2766 ses->server->ops->tree_disconnect(xid, tcon);
2769 cifs_fscache_release_super_cookie(tcon);
2771 cifs_put_smb_ses(ses);
2774 static struct cifs_tcon *
2775 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2778 struct cifs_tcon *tcon;
2780 tcon = cifs_find_tcon(ses, volume_info->UNC);
2782 cifs_dbg(FYI, "Found match on UNC path\n");
2783 /* existing tcon already has a reference */
2784 cifs_put_smb_ses(ses);
2785 if (tcon->seal != volume_info->seal)
2786 cifs_dbg(VFS, "transport encryption setting conflicts with existing tid\n");
2790 if (!ses->server->ops->tree_connect) {
2795 tcon = tconInfoAlloc();
2802 if (volume_info->password) {
2803 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2804 if (!tcon->password) {
2811 * BB Do we need to wrap session_mutex around this TCon call and Unix
2812 * SetFS as we do on SessSetup and reconnect?
2815 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2816 volume_info->local_nls);
2818 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
2822 if (volume_info->nodfs) {
2823 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2824 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
2826 tcon->seal = volume_info->seal;
2827 tcon->use_persistent = false;
2828 /* check if SMB2 or later, CIFS does not support persistent handles */
2829 if (volume_info->persistent) {
2830 if (ses->server->vals->protocol_id == 0) {
2832 "SMB3 or later required for persistent handles\n");
2835 #ifdef CONFIG_CIFS_SMB2
2836 } else if (ses->server->capabilities &
2837 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2838 tcon->use_persistent = true;
2839 else /* persistent handles requested but not supported */ {
2841 "Persistent handles not supported on share\n");
2844 #endif /* CONFIG_CIFS_SMB2 */
2846 #ifdef CONFIG_CIFS_SMB2
2847 } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
2848 && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2849 && (volume_info->nopersistent == false)) {
2850 cifs_dbg(FYI, "enabling persistent handles\n");
2851 tcon->use_persistent = true;
2852 #endif /* CONFIG_CIFS_SMB2 */
2853 } else if (volume_info->resilient) {
2854 if (ses->server->vals->protocol_id == 0) {
2856 "SMB2.1 or later required for resilient handles\n");
2860 tcon->use_resilient = true;
2864 * We can have only one retry value for a connection to a share so for
2865 * resources mounted more than once to the same server share the last
2866 * value passed in for the retry flag is used.
2868 tcon->retry = volume_info->retry;
2869 tcon->nocase = volume_info->nocase;
2870 tcon->local_lease = volume_info->local_lease;
2871 INIT_LIST_HEAD(&tcon->pending_opens);
2873 spin_lock(&cifs_tcp_ses_lock);
2874 list_add(&tcon->tcon_list, &ses->tcon_list);
2875 spin_unlock(&cifs_tcp_ses_lock);
2877 cifs_fscache_get_super_cookie(tcon);
2887 cifs_put_tlink(struct tcon_link *tlink)
2889 if (!tlink || IS_ERR(tlink))
2892 if (!atomic_dec_and_test(&tlink->tl_count) ||
2893 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2894 tlink->tl_time = jiffies;
2898 if (!IS_ERR(tlink_tcon(tlink)))
2899 cifs_put_tcon(tlink_tcon(tlink));
2904 static inline struct tcon_link *
2905 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2907 return cifs_sb->master_tlink;
2911 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2913 struct cifs_sb_info *old = CIFS_SB(sb);
2914 struct cifs_sb_info *new = mnt_data->cifs_sb;
2916 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2919 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2920 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2924 * We want to share sb only if we don't specify an r/wsize or
2925 * specified r/wsize is greater than or equal to existing one.
2927 if (new->wsize && new->wsize < old->wsize)
2930 if (new->rsize && new->rsize < old->rsize)
2933 if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
2936 if (old->mnt_file_mode != new->mnt_file_mode ||
2937 old->mnt_dir_mode != new->mnt_dir_mode)
2940 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2943 if (old->actimeo != new->actimeo)
2950 cifs_match_super(struct super_block *sb, void *data)
2952 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2953 struct smb_vol *volume_info;
2954 struct cifs_sb_info *cifs_sb;
2955 struct TCP_Server_Info *tcp_srv;
2956 struct cifs_ses *ses;
2957 struct cifs_tcon *tcon;
2958 struct tcon_link *tlink;
2961 spin_lock(&cifs_tcp_ses_lock);
2962 cifs_sb = CIFS_SB(sb);
2963 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2964 if (IS_ERR(tlink)) {
2965 spin_unlock(&cifs_tcp_ses_lock);
2968 tcon = tlink_tcon(tlink);
2970 tcp_srv = ses->server;
2972 volume_info = mnt_data->vol;
2974 if (!match_server(tcp_srv, volume_info) ||
2975 !match_session(ses, volume_info) ||
2976 !match_tcon(tcon, volume_info->UNC)) {
2981 rc = compare_mount_options(sb, mnt_data);
2983 spin_unlock(&cifs_tcp_ses_lock);
2984 cifs_put_tlink(tlink);
2989 get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
2990 const struct nls_table *nls_codepage, unsigned int *num_referrals,
2991 struct dfs_info3_param **referrals, int remap)
2996 if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
3002 if (ses->ipc_tid == 0) {
3003 temp_unc = kmalloc(2 /* for slashes */ +
3004 strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
3005 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
3006 if (temp_unc == NULL)
3010 strcpy(temp_unc + 2, ses->serverName);
3011 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
3012 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
3014 cifs_dbg(FYI, "Tcon rc = %d ipc_tid = %d\n", rc, ses->ipc_tid);
3018 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
3019 referrals, num_referrals,
3020 nls_codepage, remap);
3022 * BB - map targetUNCs to dfs_info3 structures, here or in
3023 * ses->server->ops->get_dfs_refer.
3029 #ifdef CONFIG_DEBUG_LOCK_ALLOC
3030 static struct lock_class_key cifs_key[2];
3031 static struct lock_class_key cifs_slock_key[2];
3034 cifs_reclassify_socket4(struct socket *sock)
3036 struct sock *sk = sock->sk;
3037 BUG_ON(sock_owned_by_user(sk));
3038 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
3039 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
3043 cifs_reclassify_socket6(struct socket *sock)
3045 struct sock *sk = sock->sk;
3046 BUG_ON(sock_owned_by_user(sk));
3047 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
3048 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
3052 cifs_reclassify_socket4(struct socket *sock)
3057 cifs_reclassify_socket6(struct socket *sock)
3062 /* See RFC1001 section 14 on representation of Netbios names */
3063 static void rfc1002mangle(char *target, char *source, unsigned int length)
3067 for (i = 0, j = 0; i < (length); i++) {
3068 /* mask a nibble at a time and encode */
3069 target[j] = 'A' + (0x0F & (source[i] >> 4));
3070 target[j+1] = 'A' + (0x0F & source[i]);
3077 bind_socket(struct TCP_Server_Info *server)
3080 if (server->srcaddr.ss_family != AF_UNSPEC) {
3081 /* Bind to the specified local IP address */
3082 struct socket *socket = server->ssocket;
3083 rc = socket->ops->bind(socket,
3084 (struct sockaddr *) &server->srcaddr,
3085 sizeof(server->srcaddr));
3087 struct sockaddr_in *saddr4;
3088 struct sockaddr_in6 *saddr6;
3089 saddr4 = (struct sockaddr_in *)&server->srcaddr;
3090 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
3091 if (saddr6->sin6_family == AF_INET6)
3092 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
3093 &saddr6->sin6_addr, rc);
3095 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
3096 &saddr4->sin_addr.s_addr, rc);
3103 ip_rfc1001_connect(struct TCP_Server_Info *server)
3107 * some servers require RFC1001 sessinit before sending
3108 * negprot - BB check reconnection in case where second
3109 * sessinit is sent but no second negprot
3111 struct rfc1002_session_packet *ses_init_buf;
3112 struct smb_hdr *smb_buf;
3113 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
3116 ses_init_buf->trailer.session_req.called_len = 32;
3118 if (server->server_RFC1001_name &&
3119 server->server_RFC1001_name[0] != 0)
3120 rfc1002mangle(ses_init_buf->trailer.
3121 session_req.called_name,
3122 server->server_RFC1001_name,
3123 RFC1001_NAME_LEN_WITH_NULL);
3125 rfc1002mangle(ses_init_buf->trailer.
3126 session_req.called_name,
3127 DEFAULT_CIFS_CALLED_NAME,
3128 RFC1001_NAME_LEN_WITH_NULL);
3130 ses_init_buf->trailer.session_req.calling_len = 32;
3133 * calling name ends in null (byte 16) from old smb
3136 if (server->workstation_RFC1001_name[0] != 0)
3137 rfc1002mangle(ses_init_buf->trailer.
3138 session_req.calling_name,
3139 server->workstation_RFC1001_name,
3140 RFC1001_NAME_LEN_WITH_NULL);
3142 rfc1002mangle(ses_init_buf->trailer.
3143 session_req.calling_name,
3145 RFC1001_NAME_LEN_WITH_NULL);
3147 ses_init_buf->trailer.session_req.scope1 = 0;
3148 ses_init_buf->trailer.session_req.scope2 = 0;
3149 smb_buf = (struct smb_hdr *)ses_init_buf;
3151 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3152 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3153 rc = smb_send(server, smb_buf, 0x44);
3154 kfree(ses_init_buf);
3156 * RFC1001 layer in at least one server
3157 * requires very short break before negprot
3158 * presumably because not expecting negprot
3159 * to follow so fast. This is a simple
3160 * solution that works without
3161 * complicating the code and causes no
3162 * significant slowing down on mount
3165 usleep_range(1000, 2000);
3168 * else the negprot may still work without this
3169 * even though malloc failed
3176 generic_ip_connect(struct TCP_Server_Info *server)
3181 struct socket *socket = server->ssocket;
3182 struct sockaddr *saddr;
3184 saddr = (struct sockaddr *) &server->dstaddr;
3186 if (server->dstaddr.ss_family == AF_INET6) {
3187 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3188 slen = sizeof(struct sockaddr_in6);
3191 sport = ((struct sockaddr_in *) saddr)->sin_port;
3192 slen = sizeof(struct sockaddr_in);
3196 if (socket == NULL) {
3197 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3198 IPPROTO_TCP, &socket, 1);
3200 cifs_dbg(VFS, "Error %d creating socket\n", rc);
3201 server->ssocket = NULL;
3205 /* BB other socket options to set KEEPALIVE, NODELAY? */
3206 cifs_dbg(FYI, "Socket created\n");
3207 server->ssocket = socket;
3208 socket->sk->sk_allocation = GFP_NOFS;
3209 if (sfamily == AF_INET6)
3210 cifs_reclassify_socket6(socket);
3212 cifs_reclassify_socket4(socket);
3215 rc = bind_socket(server);
3220 * Eventually check for other socket options to change from
3221 * the default. sock_setsockopt not used because it expects
3224 socket->sk->sk_rcvtimeo = 7 * HZ;
3225 socket->sk->sk_sndtimeo = 5 * HZ;
3227 /* make the bufsizes depend on wsize/rsize and max requests */
3228 if (server->noautotune) {
3229 if (socket->sk->sk_sndbuf < (200 * 1024))
3230 socket->sk->sk_sndbuf = 200 * 1024;
3231 if (socket->sk->sk_rcvbuf < (140 * 1024))
3232 socket->sk->sk_rcvbuf = 140 * 1024;
3235 if (server->tcp_nodelay) {
3237 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3238 (char *)&val, sizeof(val));
3240 cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3244 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3245 socket->sk->sk_sndbuf,
3246 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3248 rc = socket->ops->connect(socket, saddr, slen, 0);
3250 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3251 sock_release(socket);
3252 server->ssocket = NULL;
3256 if (sport == htons(RFC1001_PORT))
3257 rc = ip_rfc1001_connect(server);
3263 ip_connect(struct TCP_Server_Info *server)
3266 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3267 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3269 if (server->dstaddr.ss_family == AF_INET6)
3270 sport = &addr6->sin6_port;
3272 sport = &addr->sin_port;
3277 /* try with 445 port at first */
3278 *sport = htons(CIFS_PORT);
3280 rc = generic_ip_connect(server);
3284 /* if it failed, try with 139 port */
3285 *sport = htons(RFC1001_PORT);
3288 return generic_ip_connect(server);
3291 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3292 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3294 /* if we are reconnecting then should we check to see if
3295 * any requested capabilities changed locally e.g. via
3296 * remount but we can not do much about it here
3297 * if they have (even if we could detect it by the following)
3298 * Perhaps we could add a backpointer to array of sb from tcon
3299 * or if we change to make all sb to same share the same
3300 * sb as NFS - then we only have one backpointer to sb.
3301 * What if we wanted to mount the server share twice once with
3302 * and once without posixacls or posix paths? */
3303 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3305 if (vol_info && vol_info->no_linux_ext) {
3306 tcon->fsUnixInfo.Capability = 0;
3307 tcon->unix_ext = 0; /* Unix Extensions disabled */
3308 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
3310 } else if (vol_info)
3311 tcon->unix_ext = 1; /* Unix Extensions supported */
3313 if (tcon->unix_ext == 0) {
3314 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
3318 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3319 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3320 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
3321 /* check for reconnect case in which we do not
3322 want to change the mount behavior if we can avoid it */
3323 if (vol_info == NULL) {
3324 /* turn off POSIX ACL and PATHNAMES if not set
3325 originally at mount time */
3326 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3327 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3328 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3329 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3330 cifs_dbg(VFS, "POSIXPATH support change\n");
3331 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3332 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3333 cifs_dbg(VFS, "possible reconnect error\n");
3334 cifs_dbg(VFS, "server disabled POSIX path support\n");
3338 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3339 cifs_dbg(VFS, "per-share encryption not supported yet\n");
3341 cap &= CIFS_UNIX_CAP_MASK;
3342 if (vol_info && vol_info->no_psx_acl)
3343 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3344 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3345 cifs_dbg(FYI, "negotiated posix acl support\n");
3347 cifs_sb->mnt_cifs_flags |=
3348 CIFS_MOUNT_POSIXACL;
3351 if (vol_info && vol_info->posix_paths == 0)
3352 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3353 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3354 cifs_dbg(FYI, "negotiate posix pathnames\n");
3356 cifs_sb->mnt_cifs_flags |=
3357 CIFS_MOUNT_POSIX_PATHS;
3360 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
3361 #ifdef CONFIG_CIFS_DEBUG2
3362 if (cap & CIFS_UNIX_FCNTL_CAP)
3363 cifs_dbg(FYI, "FCNTL cap\n");
3364 if (cap & CIFS_UNIX_EXTATTR_CAP)
3365 cifs_dbg(FYI, "EXTATTR cap\n");
3366 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3367 cifs_dbg(FYI, "POSIX path cap\n");
3368 if (cap & CIFS_UNIX_XATTR_CAP)
3369 cifs_dbg(FYI, "XATTR cap\n");
3370 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3371 cifs_dbg(FYI, "POSIX ACL cap\n");
3372 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3373 cifs_dbg(FYI, "very large read cap\n");
3374 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3375 cifs_dbg(FYI, "very large write cap\n");
3376 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3377 cifs_dbg(FYI, "transport encryption cap\n");
3378 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3379 cifs_dbg(FYI, "mandatory transport encryption cap\n");
3380 #endif /* CIFS_DEBUG2 */
3381 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3382 if (vol_info == NULL) {
3383 cifs_dbg(FYI, "resetting capabilities failed\n");
3385 cifs_dbg(VFS, "Negotiating Unix capabilities with the server failed. Consider mounting with the Unix Extensions disabled if problems are found by specifying the nounix mount option.\n");
3391 void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3392 struct cifs_sb_info *cifs_sb)
3394 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3396 spin_lock_init(&cifs_sb->tlink_tree_lock);
3397 cifs_sb->tlink_tree = RB_ROOT;
3400 * Temporarily set r/wsize for matching superblock. If we end up using
3401 * new sb then client will later negotiate it downward if needed.
3403 cifs_sb->rsize = pvolume_info->rsize;
3404 cifs_sb->wsize = pvolume_info->wsize;
3406 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3407 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3408 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3409 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3410 cifs_dbg(FYI, "file mode: %04ho dir mode: %04ho\n",
3411 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3413 cifs_sb->actimeo = pvolume_info->actimeo;
3414 cifs_sb->local_nls = pvolume_info->local_nls;
3416 if (pvolume_info->noperm)
3417 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3418 if (pvolume_info->setuids)
3419 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3420 if (pvolume_info->server_ino)
3421 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3422 if (pvolume_info->remap)
3423 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3424 if (pvolume_info->sfu_remap)
3425 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3426 if (pvolume_info->no_xattr)
3427 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3428 if (pvolume_info->sfu_emul)
3429 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3430 if (pvolume_info->nobrl)
3431 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3432 if (pvolume_info->nostrictsync)
3433 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3434 if (pvolume_info->mand_lock)
3435 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3436 if (pvolume_info->rwpidforward)
3437 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3438 if (pvolume_info->cifs_acl)
3439 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3440 if (pvolume_info->backupuid_specified) {
3441 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3442 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3444 if (pvolume_info->backupgid_specified) {
3445 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3446 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3448 if (pvolume_info->override_uid)
3449 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3450 if (pvolume_info->override_gid)
3451 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3452 if (pvolume_info->dynperm)
3453 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3454 if (pvolume_info->fsc)
3455 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3456 if (pvolume_info->multiuser)
3457 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3458 CIFS_MOUNT_NO_PERM);
3459 if (pvolume_info->strict_io)
3460 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3461 if (pvolume_info->direct_io) {
3462 cifs_dbg(FYI, "mounting share using direct i/o\n");
3463 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3465 if (pvolume_info->mfsymlinks) {
3466 if (pvolume_info->sfu_emul) {
3468 * Our SFU ("Services for Unix" emulation does not allow
3469 * creating symlinks but does allow reading existing SFU
3470 * symlinks (it does allow both creating and reading SFU
3471 * style mknod and FIFOs though). When "mfsymlinks" and
3472 * "sfu" are both enabled at the same time, it allows
3473 * reading both types of symlinks, but will only create
3474 * them with mfsymlinks format. This allows better
3475 * Apple compatibility (probably better for Samba too)
3476 * while still recognizing old Windows style symlinks.
3478 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
3480 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3483 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3484 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
3488 cleanup_volume_info_contents(struct smb_vol *volume_info)
3490 kfree(volume_info->username);
3491 kzfree(volume_info->password);
3492 kfree(volume_info->UNC);
3493 kfree(volume_info->domainname);
3494 kfree(volume_info->iocharset);
3495 kfree(volume_info->prepath);
3499 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3503 cleanup_volume_info_contents(volume_info);
3508 #ifdef CONFIG_CIFS_DFS_UPCALL
3510 * cifs_build_path_to_root returns full path to root when we do not have an
3511 * exiting connection (tcon)
3514 build_unc_path_to_root(const struct smb_vol *vol,
3515 const struct cifs_sb_info *cifs_sb)
3517 char *full_path, *pos;
3518 unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
3519 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3521 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3522 if (full_path == NULL)
3523 return ERR_PTR(-ENOMEM);
3525 strncpy(full_path, vol->UNC, unc_len);
3526 pos = full_path + unc_len;
3529 *pos = CIFS_DIR_SEP(cifs_sb);
3530 strncpy(pos + 1, vol->prepath, pplen);
3534 *pos = '\0'; /* add trailing null */
3535 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3536 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
3541 * Perform a dfs referral query for a share and (optionally) prefix
3543 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3544 * to a string containing updated options for the submount. Otherwise it
3545 * will be left untouched.
3547 * Returns the rc from get_dfs_path to the caller, which can be used to
3548 * determine whether there were referrals.
3551 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
3552 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3556 unsigned int num_referrals = 0;
3557 struct dfs_info3_param *referrals = NULL;
3558 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3560 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3561 if (IS_ERR(full_path))
3562 return PTR_ERR(full_path);
3564 /* For DFS paths, skip the first '\' of the UNC */
3565 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3567 rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
3568 &num_referrals, &referrals, cifs_remap(cifs_sb));
3570 if (!rc && num_referrals > 0) {
3571 char *fake_devname = NULL;
3573 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3574 full_path + 1, referrals,
3577 free_dfs_info_array(referrals, num_referrals);
3579 if (IS_ERR(mdata)) {
3580 rc = PTR_ERR(mdata);
3583 cleanup_volume_info_contents(volume_info);
3584 rc = cifs_setup_volume_info(volume_info, mdata,
3587 kfree(fake_devname);
3588 kfree(cifs_sb->mountdata);
3589 cifs_sb->mountdata = mdata;
3597 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3598 const char *devname)
3602 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3605 if (volume_info->nullauth) {
3606 cifs_dbg(FYI, "Anonymous login\n");
3607 kfree(volume_info->username);
3608 volume_info->username = NULL;
3609 } else if (volume_info->username) {
3610 /* BB fixme parse for domain name here */
3611 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
3613 cifs_dbg(VFS, "No username specified\n");
3614 /* In userspace mount helper we can get user name from alternate
3615 locations such as env variables and files on disk */
3619 /* this is needed for ASCII cp to Unicode converts */
3620 if (volume_info->iocharset == NULL) {
3621 /* load_nls_default cannot return null */
3622 volume_info->local_nls = load_nls_default();
3624 volume_info->local_nls = load_nls(volume_info->iocharset);
3625 if (volume_info->local_nls == NULL) {
3626 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
3627 volume_info->iocharset);
3636 cifs_get_volume_info(char *mount_data, const char *devname)
3639 struct smb_vol *volume_info;
3641 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
3643 return ERR_PTR(-ENOMEM);
3645 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3647 cifs_cleanup_volume_info(volume_info);
3648 volume_info = ERR_PTR(rc);
3655 cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
3657 struct cifs_tcon *tcon,
3658 struct cifs_sb_info *cifs_sb,
3665 sep = CIFS_DIR_SEP(cifs_sb);
3668 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
3670 /* skip separators */
3675 /* next separator */
3676 while (*s && *s != sep)
3680 * temporarily null-terminate the path at the end of
3681 * the current component
3685 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3693 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3697 struct cifs_ses *ses;
3698 struct cifs_tcon *tcon;
3699 struct TCP_Server_Info *server;
3701 struct tcon_link *tlink;
3702 #ifdef CONFIG_CIFS_DFS_UPCALL
3703 int referral_walks_count = 0;
3706 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs");
3710 #ifdef CONFIG_CIFS_DFS_UPCALL
3712 /* cleanup activities if we're chasing a referral */
3713 if (referral_walks_count) {
3715 cifs_put_tcon(tcon);
3717 cifs_put_smb_ses(ses);
3719 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
3733 /* get a reference to a tcp session */
3734 server = cifs_get_tcp_session(volume_info);
3735 if (IS_ERR(server)) {
3736 rc = PTR_ERR(server);
3737 bdi_destroy(&cifs_sb->bdi);
3741 /* get a reference to a SMB session */
3742 ses = cifs_get_smb_ses(server, volume_info);
3746 goto mount_fail_check;
3749 #ifdef CONFIG_CIFS_SMB2
3750 if ((volume_info->persistent == true) && ((ses->server->capabilities &
3751 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES) == 0)) {
3752 cifs_dbg(VFS, "persistent handles not supported by server\n");
3754 goto mount_fail_check;
3756 #endif /* CONFIG_CIFS_SMB2*/
3758 /* search for existing tcon to this server share */
3759 tcon = cifs_get_tcon(ses, volume_info);
3764 goto mount_fail_check;
3766 goto remote_path_check;
3769 /* tell server which Unix caps we support */
3770 if (cap_unix(tcon->ses)) {
3771 /* reset of caps checks mount to see if unix extensions
3772 disabled for just this mount */
3773 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3774 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3775 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3776 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3778 goto mount_fail_check;
3781 tcon->unix_ext = 0; /* server does not support them */
3783 /* do not care if a following call succeed - informational */
3784 if (!tcon->ipc && server->ops->qfs_tcon)
3785 server->ops->qfs_tcon(xid, tcon);
3787 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3788 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
3790 /* tune readahead according to rsize */
3791 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
3794 #ifdef CONFIG_CIFS_DFS_UPCALL
3796 * Perform an unconditional check for whether there are DFS
3797 * referrals for this path without prefix, to provide support
3798 * for DFS referrals from w2k8 servers which don't seem to respond
3799 * with PATH_NOT_COVERED to requests that include the prefix.
3800 * Chase the referral if found, otherwise continue normally.
3802 if (referral_walks_count == 0) {
3803 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3806 referral_walks_count++;
3807 goto try_mount_again;
3812 /* check if a whole path is not remote */
3814 if (!server->ops->is_path_accessible) {
3816 goto mount_fail_check;
3819 * cifs_build_path_to_root works only when we have a valid tcon
3821 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3822 if (full_path == NULL) {
3824 goto mount_fail_check;
3826 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3828 if (rc != 0 && rc != -EREMOTE) {
3830 goto mount_fail_check;
3833 if (rc != -EREMOTE) {
3834 rc = cifs_are_all_path_components_accessible(server,
3838 cifs_dbg(VFS, "cannot query dirs between root and final path, "
3839 "enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
3840 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
3847 /* get referral if needed */
3848 if (rc == -EREMOTE) {
3849 #ifdef CONFIG_CIFS_DFS_UPCALL
3850 if (referral_walks_count > MAX_NESTED_LINKS) {
3852 * BB: when we implement proper loop detection,
3853 * we will remove this check. But now we need it
3854 * to prevent an indefinite loop if 'DFS tree' is
3855 * misconfigured (i.e. has loops).
3858 goto mount_fail_check;
3861 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
3864 referral_walks_count++;
3865 goto try_mount_again;
3867 goto mount_fail_check;
3868 #else /* No DFS support, return error on mount */
3874 goto mount_fail_check;
3876 /* now, hang the tcon off of the superblock */
3877 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3878 if (tlink == NULL) {
3880 goto mount_fail_check;
3883 tlink->tl_uid = ses->linux_uid;
3884 tlink->tl_tcon = tcon;
3885 tlink->tl_time = jiffies;
3886 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3887 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3889 cifs_sb->master_tlink = tlink;
3890 spin_lock(&cifs_sb->tlink_tree_lock);
3891 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3892 spin_unlock(&cifs_sb->tlink_tree_lock);
3894 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3898 /* on error free sesinfo and tcon struct if needed */
3900 /* If find_unc succeeded then rc == 0 so we can not end */
3901 /* up accidentally freeing someone elses tcon struct */
3903 cifs_put_tcon(tcon);
3905 cifs_put_smb_ses(ses);
3907 cifs_put_tcp_session(server, 0);
3908 bdi_destroy(&cifs_sb->bdi);
3917 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3918 * pointer may be NULL.
3921 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
3922 const char *tree, struct cifs_tcon *tcon,
3923 const struct nls_table *nls_codepage)
3925 struct smb_hdr *smb_buffer;
3926 struct smb_hdr *smb_buffer_response;
3929 unsigned char *bcc_ptr;
3932 __u16 bytes_left, count;
3937 smb_buffer = cifs_buf_get();
3938 if (smb_buffer == NULL)
3941 smb_buffer_response = smb_buffer;
3943 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3944 NULL /*no tid */ , 4 /*wct */ );
3946 smb_buffer->Mid = get_next_mid(ses->server);
3947 smb_buffer->Uid = ses->Suid;
3948 pSMB = (TCONX_REQ *) smb_buffer;
3949 pSMBr = (TCONX_RSP *) smb_buffer_response;
3951 pSMB->AndXCommand = 0xFF;
3952 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3953 bcc_ptr = &pSMB->Password[0];
3954 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3955 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3956 *bcc_ptr = 0; /* password is null byte */
3957 bcc_ptr++; /* skip password */
3958 /* already aligned so no need to do it below */
3960 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3961 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3962 specified as required (when that support is added to
3963 the vfs in the future) as only NTLM or the much
3964 weaker LANMAN (which we do not send by default) is accepted
3965 by Samba (not sure whether other servers allow
3966 NTLMv2 password here) */
3967 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3968 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3969 (ses->sectype == LANMAN))
3970 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3971 ses->server->sec_mode &
3972 SECMODE_PW_ENCRYPT ? true : false,
3975 #endif /* CIFS_WEAK_PW_HASH */
3976 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3977 bcc_ptr, nls_codepage);
3979 cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
3981 cifs_buf_release(smb_buffer);
3985 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3986 if (ses->capabilities & CAP_UNICODE) {
3987 /* must align unicode strings */
3988 *bcc_ptr = 0; /* null byte password */
3993 if (ses->server->sign)
3994 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3996 if (ses->capabilities & CAP_STATUS32) {
3997 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3999 if (ses->capabilities & CAP_DFS) {
4000 smb_buffer->Flags2 |= SMBFLG2_DFS;
4002 if (ses->capabilities & CAP_UNICODE) {
4003 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
4005 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
4006 6 /* max utf8 char length in bytes */ *
4007 (/* server len*/ + 256 /* share len */), nls_codepage);
4008 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
4009 bcc_ptr += 2; /* skip trailing null */
4010 } else { /* ASCII */
4011 strcpy(bcc_ptr, tree);
4012 bcc_ptr += strlen(tree) + 1;
4014 strcpy(bcc_ptr, "?????");
4015 bcc_ptr += strlen("?????");
4017 count = bcc_ptr - &pSMB->Password[0];
4018 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
4019 pSMB->hdr.smb_buf_length) + count);
4020 pSMB->ByteCount = cpu_to_le16(count);
4022 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
4025 /* above now done in SendReceive */
4026 if ((rc == 0) && (tcon != NULL)) {
4029 tcon->tidStatus = CifsGood;
4030 tcon->need_reconnect = false;
4031 tcon->tid = smb_buffer_response->Tid;
4032 bcc_ptr = pByteArea(smb_buffer_response);
4033 bytes_left = get_bcc(smb_buffer_response);
4034 length = strnlen(bcc_ptr, bytes_left - 2);
4035 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
4041 /* skip service field (NB: this field is always ASCII) */
4043 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
4044 (bcc_ptr[2] == 'C')) {
4045 cifs_dbg(FYI, "IPC connection\n");
4048 } else if (length == 2) {
4049 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
4050 /* the most common case */
4051 cifs_dbg(FYI, "disk share connection\n");
4054 bcc_ptr += length + 1;
4055 bytes_left -= (length + 1);
4056 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
4058 /* mostly informational -- no need to fail on error here */
4059 kfree(tcon->nativeFileSystem);
4060 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
4061 bytes_left, is_unicode,
4064 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
4066 if ((smb_buffer_response->WordCount == 3) ||
4067 (smb_buffer_response->WordCount == 7))
4068 /* field is in same location */
4069 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
4072 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
4073 } else if ((rc == 0) && tcon == NULL) {
4074 /* all we need to save for IPC$ connection */
4075 ses->ipc_tid = smb_buffer_response->Tid;
4078 cifs_buf_release(smb_buffer);
4082 static void delayed_free(struct rcu_head *p)
4084 struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
4085 unload_nls(sbi->local_nls);
4090 cifs_umount(struct cifs_sb_info *cifs_sb)
4092 struct rb_root *root = &cifs_sb->tlink_tree;
4093 struct rb_node *node;
4094 struct tcon_link *tlink;
4096 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
4098 spin_lock(&cifs_sb->tlink_tree_lock);
4099 while ((node = rb_first(root))) {
4100 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4101 cifs_get_tlink(tlink);
4102 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4103 rb_erase(node, root);
4105 spin_unlock(&cifs_sb->tlink_tree_lock);
4106 cifs_put_tlink(tlink);
4107 spin_lock(&cifs_sb->tlink_tree_lock);
4109 spin_unlock(&cifs_sb->tlink_tree_lock);
4111 bdi_destroy(&cifs_sb->bdi);
4112 kfree(cifs_sb->mountdata);
4113 kfree(cifs_sb->prepath);
4114 call_rcu(&cifs_sb->rcu, delayed_free);
4118 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
4121 struct TCP_Server_Info *server = ses->server;
4123 if (!server->ops->need_neg || !server->ops->negotiate)
4126 /* only send once per connect */
4127 if (!server->ops->need_neg(server))
4130 set_credits(server, 1);
4132 rc = server->ops->negotiate(xid, ses);
4134 spin_lock(&GlobalMid_Lock);
4135 if (server->tcpStatus == CifsNeedNegotiate)
4136 server->tcpStatus = CifsGood;
4139 spin_unlock(&GlobalMid_Lock);
4146 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
4147 struct nls_table *nls_info)
4150 struct TCP_Server_Info *server = ses->server;
4152 ses->capabilities = server->capabilities;
4153 if (linuxExtEnabled == 0)
4154 ses->capabilities &= (~server->vals->cap_unix);
4156 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
4157 server->sec_mode, server->capabilities, server->timeAdj);
4159 if (ses->auth_key.response) {
4160 cifs_dbg(VFS, "Free previous auth_key.response = %p\n",
4161 ses->auth_key.response);
4162 kfree(ses->auth_key.response);
4163 ses->auth_key.response = NULL;
4164 ses->auth_key.len = 0;
4167 if (server->ops->sess_setup)
4168 rc = server->ops->sess_setup(xid, ses, nls_info);
4171 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
4177 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
4179 vol->sectype = ses->sectype;
4181 /* krb5 is special, since we don't need username or pw */
4182 if (vol->sectype == Kerberos)
4185 return cifs_set_cifscreds(vol, ses);
4188 static struct cifs_tcon *
4189 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
4192 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4193 struct cifs_ses *ses;
4194 struct cifs_tcon *tcon = NULL;
4195 struct smb_vol *vol_info;
4197 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
4198 if (vol_info == NULL)
4199 return ERR_PTR(-ENOMEM);
4201 vol_info->local_nls = cifs_sb->local_nls;
4202 vol_info->linux_uid = fsuid;
4203 vol_info->cred_uid = fsuid;
4204 vol_info->UNC = master_tcon->treeName;
4205 vol_info->retry = master_tcon->retry;
4206 vol_info->nocase = master_tcon->nocase;
4207 vol_info->local_lease = master_tcon->local_lease;
4208 vol_info->resilient = master_tcon->use_resilient;
4209 vol_info->persistent = master_tcon->use_persistent;
4210 vol_info->no_linux_ext = !master_tcon->unix_ext;
4211 vol_info->sectype = master_tcon->ses->sectype;
4212 vol_info->sign = master_tcon->ses->sign;
4213 vol_info->seal = master_tcon->seal;
4215 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4221 /* get a reference for the same TCP session */
4222 spin_lock(&cifs_tcp_ses_lock);
4223 ++master_tcon->ses->server->srv_count;
4224 spin_unlock(&cifs_tcp_ses_lock);
4226 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4228 tcon = (struct cifs_tcon *)ses;
4229 cifs_put_tcp_session(master_tcon->ses->server, 0);
4233 tcon = cifs_get_tcon(ses, vol_info);
4235 cifs_put_smb_ses(ses);
4240 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4242 kfree(vol_info->username);
4243 kzfree(vol_info->password);
4250 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4252 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4255 /* find and return a tlink with given uid */
4256 static struct tcon_link *
4257 tlink_rb_search(struct rb_root *root, kuid_t uid)
4259 struct rb_node *node = root->rb_node;
4260 struct tcon_link *tlink;
4263 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4265 if (uid_gt(tlink->tl_uid, uid))
4266 node = node->rb_left;
4267 else if (uid_lt(tlink->tl_uid, uid))
4268 node = node->rb_right;
4275 /* insert a tcon_link into the tree */
4277 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4279 struct rb_node **new = &(root->rb_node), *parent = NULL;
4280 struct tcon_link *tlink;
4283 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4286 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
4287 new = &((*new)->rb_left);
4289 new = &((*new)->rb_right);
4292 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4293 rb_insert_color(&new_tlink->tl_rbnode, root);
4297 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4300 * If the superblock doesn't refer to a multiuser mount, then just return
4301 * the master tcon for the mount.
4303 * First, search the rbtree for an existing tcon for this fsuid. If one
4304 * exists, then check to see if it's pending construction. If it is then wait
4305 * for construction to complete. Once it's no longer pending, check to see if
4306 * it failed and either return an error or retry construction, depending on
4309 * If one doesn't exist then insert a new tcon_link struct into the tree and
4310 * try to construct a new one.
4313 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4316 kuid_t fsuid = current_fsuid();
4317 struct tcon_link *tlink, *newtlink;
4319 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4320 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4322 spin_lock(&cifs_sb->tlink_tree_lock);
4323 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4325 cifs_get_tlink(tlink);
4326 spin_unlock(&cifs_sb->tlink_tree_lock);
4328 if (tlink == NULL) {
4329 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4330 if (newtlink == NULL)
4331 return ERR_PTR(-ENOMEM);
4332 newtlink->tl_uid = fsuid;
4333 newtlink->tl_tcon = ERR_PTR(-EACCES);
4334 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4335 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4336 cifs_get_tlink(newtlink);
4338 spin_lock(&cifs_sb->tlink_tree_lock);
4339 /* was one inserted after previous search? */
4340 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4342 cifs_get_tlink(tlink);
4343 spin_unlock(&cifs_sb->tlink_tree_lock);
4345 goto wait_for_construction;
4348 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4349 spin_unlock(&cifs_sb->tlink_tree_lock);
4351 wait_for_construction:
4352 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4353 TASK_INTERRUPTIBLE);
4355 cifs_put_tlink(tlink);
4356 return ERR_PTR(-ERESTARTSYS);
4359 /* if it's good, return it */
4360 if (!IS_ERR(tlink->tl_tcon))
4363 /* return error if we tried this already recently */
4364 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4365 cifs_put_tlink(tlink);
4366 return ERR_PTR(-EACCES);
4369 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4370 goto wait_for_construction;
4373 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4374 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4375 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4377 if (IS_ERR(tlink->tl_tcon)) {
4378 cifs_put_tlink(tlink);
4379 return ERR_PTR(-EACCES);
4386 * periodic workqueue job that scans tcon_tree for a superblock and closes
4390 cifs_prune_tlinks(struct work_struct *work)
4392 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4394 struct rb_root *root = &cifs_sb->tlink_tree;
4395 struct rb_node *node = rb_first(root);
4396 struct rb_node *tmp;
4397 struct tcon_link *tlink;
4400 * Because we drop the spinlock in the loop in order to put the tlink
4401 * it's not guarded against removal of links from the tree. The only
4402 * places that remove entries from the tree are this function and
4403 * umounts. Because this function is non-reentrant and is canceled
4404 * before umount can proceed, this is safe.
4406 spin_lock(&cifs_sb->tlink_tree_lock);
4407 node = rb_first(root);
4408 while (node != NULL) {
4410 node = rb_next(tmp);
4411 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4413 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4414 atomic_read(&tlink->tl_count) != 0 ||
4415 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4418 cifs_get_tlink(tlink);
4419 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4420 rb_erase(tmp, root);
4422 spin_unlock(&cifs_sb->tlink_tree_lock);
4423 cifs_put_tlink(tlink);
4424 spin_lock(&cifs_sb->tlink_tree_lock);
4426 spin_unlock(&cifs_sb->tlink_tree_lock);
4428 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,