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/sched/signal.h>
25 #include <linux/list.h>
26 #include <linux/wait.h>
27 #include <linux/slab.h>
28 #include <linux/pagemap.h>
29 #include <linux/ctype.h>
30 #include <linux/utsname.h>
31 #include <linux/mempool.h>
32 #include <linux/delay.h>
33 #include <linux/completion.h>
34 #include <linux/kthread.h>
35 #include <linux/pagevec.h>
36 #include <linux/freezer.h>
37 #include <linux/namei.h>
38 #include <linux/uuid.h>
39 #include <linux/uaccess.h>
40 #include <asm/processor.h>
41 #include <linux/inet.h>
42 #include <linux/module.h>
43 #include <keys/user-type.h>
45 #include <linux/parser.h>
46 #include <linux/bvec.h>
49 #include "cifsproto.h"
50 #include "cifs_unicode.h"
51 #include "cifs_debug.h"
52 #include "cifs_fs_sb.h"
55 #include "rfc1002pdu.h"
57 #include "smb2proto.h"
58 #include "smbdirect.h"
60 extern mempool_t *cifs_req_poolp;
61 extern bool disable_legacy_dialects;
63 /* FIXME: should these be tunable? */
64 #define TLINK_ERROR_EXPIRE (1 * HZ)
65 #define TLINK_IDLE_EXPIRE (600 * HZ)
68 /* Mount options that take no arguments */
69 Opt_user_xattr, Opt_nouser_xattr,
70 Opt_forceuid, Opt_noforceuid,
71 Opt_forcegid, Opt_noforcegid,
72 Opt_noblocksend, Opt_noautotune,
73 Opt_hard, Opt_soft, Opt_perm, Opt_noperm,
74 Opt_mapposix, Opt_nomapposix,
75 Opt_mapchars, Opt_nomapchars, Opt_sfu,
76 Opt_nosfu, Opt_nodfs, Opt_posixpaths,
77 Opt_noposixpaths, Opt_nounix, Opt_unix,
80 Opt_handlecache, Opt_nohandlecache,
81 Opt_forcemandatorylock, Opt_setuidfromacl, Opt_setuids,
82 Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
83 Opt_nohard, Opt_nosoft,
85 Opt_nostrictsync, Opt_strictsync,
86 Opt_serverino, Opt_noserverino,
87 Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
88 Opt_acl, Opt_noacl, Opt_locallease,
89 Opt_sign, Opt_seal, Opt_noac,
90 Opt_fsc, Opt_mfsymlinks,
91 Opt_multiuser, Opt_sloppy, Opt_nosharesock,
92 Opt_persistent, Opt_nopersistent,
93 Opt_resilient, Opt_noresilient,
94 Opt_domainauto, Opt_rdma,
96 /* Mount options which take numeric value */
97 Opt_backupuid, Opt_backupgid, Opt_uid,
98 Opt_cruid, Opt_gid, Opt_file_mode,
99 Opt_dirmode, Opt_port,
100 Opt_rsize, Opt_wsize, Opt_actimeo,
101 Opt_echo_interval, Opt_max_credits,
104 /* Mount options which take string value */
105 Opt_user, Opt_pass, Opt_ip,
106 Opt_domain, Opt_srcaddr, Opt_iocharset,
107 Opt_netbiosname, Opt_servern,
108 Opt_ver, Opt_vers, Opt_sec, Opt_cache,
110 /* Mount options to be ignored */
113 /* Options which could be blank */
121 static const match_table_t cifs_mount_option_tokens = {
123 { Opt_user_xattr, "user_xattr" },
124 { Opt_nouser_xattr, "nouser_xattr" },
125 { Opt_forceuid, "forceuid" },
126 { Opt_noforceuid, "noforceuid" },
127 { Opt_forcegid, "forcegid" },
128 { Opt_noforcegid, "noforcegid" },
129 { Opt_noblocksend, "noblocksend" },
130 { Opt_noautotune, "noautotune" },
131 { Opt_hard, "hard" },
132 { Opt_soft, "soft" },
133 { Opt_perm, "perm" },
134 { Opt_noperm, "noperm" },
135 { Opt_mapchars, "mapchars" }, /* SFU style */
136 { Opt_nomapchars, "nomapchars" },
137 { Opt_mapposix, "mapposix" }, /* SFM style */
138 { Opt_nomapposix, "nomapposix" },
140 { Opt_nosfu, "nosfu" },
141 { Opt_nodfs, "nodfs" },
142 { Opt_posixpaths, "posixpaths" },
143 { Opt_noposixpaths, "noposixpaths" },
144 { Opt_nounix, "nounix" },
145 { Opt_nounix, "nolinux" },
146 { Opt_nounix, "noposix" },
147 { Opt_unix, "unix" },
148 { Opt_unix, "linux" },
149 { Opt_unix, "posix" },
150 { Opt_nocase, "nocase" },
151 { Opt_nocase, "ignorecase" },
153 { Opt_nobrl, "nobrl" },
154 { Opt_handlecache, "handlecache" },
155 { Opt_nohandlecache, "nohandlecache" },
156 { Opt_nobrl, "nolock" },
157 { Opt_forcemandatorylock, "forcemandatorylock" },
158 { Opt_forcemandatorylock, "forcemand" },
159 { Opt_setuids, "setuids" },
160 { Opt_nosetuids, "nosetuids" },
161 { Opt_setuidfromacl, "idsfromsid" },
162 { Opt_dynperm, "dynperm" },
163 { Opt_nodynperm, "nodynperm" },
164 { Opt_nohard, "nohard" },
165 { Opt_nosoft, "nosoft" },
166 { Opt_nointr, "nointr" },
167 { Opt_intr, "intr" },
168 { Opt_nostrictsync, "nostrictsync" },
169 { Opt_strictsync, "strictsync" },
170 { Opt_serverino, "serverino" },
171 { Opt_noserverino, "noserverino" },
172 { Opt_rwpidforward, "rwpidforward" },
173 { Opt_cifsacl, "cifsacl" },
174 { Opt_nocifsacl, "nocifsacl" },
176 { Opt_noacl, "noacl" },
177 { Opt_locallease, "locallease" },
178 { Opt_sign, "sign" },
179 { Opt_seal, "seal" },
180 { Opt_noac, "noac" },
182 { Opt_mfsymlinks, "mfsymlinks" },
183 { Opt_multiuser, "multiuser" },
184 { Opt_sloppy, "sloppy" },
185 { Opt_nosharesock, "nosharesock" },
186 { Opt_persistent, "persistenthandles"},
187 { Opt_nopersistent, "nopersistenthandles"},
188 { Opt_resilient, "resilienthandles"},
189 { Opt_noresilient, "noresilienthandles"},
190 { Opt_domainauto, "domainauto"},
193 { Opt_backupuid, "backupuid=%s" },
194 { Opt_backupgid, "backupgid=%s" },
195 { Opt_uid, "uid=%s" },
196 { Opt_cruid, "cruid=%s" },
197 { Opt_gid, "gid=%s" },
198 { Opt_file_mode, "file_mode=%s" },
199 { Opt_dirmode, "dirmode=%s" },
200 { Opt_dirmode, "dir_mode=%s" },
201 { Opt_port, "port=%s" },
202 { Opt_rsize, "rsize=%s" },
203 { Opt_wsize, "wsize=%s" },
204 { Opt_actimeo, "actimeo=%s" },
205 { Opt_echo_interval, "echo_interval=%s" },
206 { Opt_max_credits, "max_credits=%s" },
207 { Opt_snapshot, "snapshot=%s" },
209 { Opt_blank_user, "user=" },
210 { Opt_blank_user, "username=" },
211 { Opt_user, "user=%s" },
212 { Opt_user, "username=%s" },
213 { Opt_blank_pass, "pass=" },
214 { Opt_blank_pass, "password=" },
215 { Opt_pass, "pass=%s" },
216 { Opt_pass, "password=%s" },
217 { Opt_blank_ip, "ip=" },
218 { Opt_blank_ip, "addr=" },
220 { Opt_ip, "addr=%s" },
221 { Opt_ignore, "unc=%s" },
222 { Opt_ignore, "target=%s" },
223 { Opt_ignore, "path=%s" },
224 { Opt_domain, "dom=%s" },
225 { Opt_domain, "domain=%s" },
226 { Opt_domain, "workgroup=%s" },
227 { Opt_srcaddr, "srcaddr=%s" },
228 { Opt_ignore, "prefixpath=%s" },
229 { Opt_iocharset, "iocharset=%s" },
230 { Opt_netbiosname, "netbiosname=%s" },
231 { Opt_servern, "servern=%s" },
232 { Opt_ver, "ver=%s" },
233 { Opt_vers, "vers=%s" },
234 { Opt_sec, "sec=%s" },
235 { Opt_cache, "cache=%s" },
237 { Opt_ignore, "cred" },
238 { Opt_ignore, "credentials" },
239 { Opt_ignore, "cred=%s" },
240 { Opt_ignore, "credentials=%s" },
241 { Opt_ignore, "guest" },
242 { Opt_ignore, "rw" },
243 { Opt_ignore, "ro" },
244 { Opt_ignore, "suid" },
245 { Opt_ignore, "nosuid" },
246 { Opt_ignore, "exec" },
247 { Opt_ignore, "noexec" },
248 { Opt_ignore, "nodev" },
249 { Opt_ignore, "noauto" },
250 { Opt_ignore, "dev" },
251 { Opt_ignore, "mand" },
252 { Opt_ignore, "nomand" },
253 { Opt_ignore, "_netdev" },
259 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
260 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
261 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
262 Opt_sec_ntlmv2i, Opt_sec_lanman,
268 static const match_table_t cifs_secflavor_tokens = {
269 { Opt_sec_krb5, "krb5" },
270 { Opt_sec_krb5i, "krb5i" },
271 { Opt_sec_krb5p, "krb5p" },
272 { Opt_sec_ntlmsspi, "ntlmsspi" },
273 { Opt_sec_ntlmssp, "ntlmssp" },
274 { Opt_ntlm, "ntlm" },
275 { Opt_sec_ntlmi, "ntlmi" },
276 { Opt_sec_ntlmv2, "nontlm" },
277 { Opt_sec_ntlmv2, "ntlmv2" },
278 { Opt_sec_ntlmv2i, "ntlmv2i" },
279 { Opt_sec_lanman, "lanman" },
280 { Opt_sec_none, "none" },
282 { Opt_sec_err, NULL }
293 static const match_table_t cifs_cacheflavor_tokens = {
294 { Opt_cache_loose, "loose" },
295 { Opt_cache_strict, "strict" },
296 { Opt_cache_none, "none" },
297 { Opt_cache_err, NULL }
300 static const match_table_t cifs_smb_version_tokens = {
301 { Smb_1, SMB1_VERSION_STRING },
302 { Smb_20, SMB20_VERSION_STRING},
303 { Smb_21, SMB21_VERSION_STRING },
304 { Smb_30, SMB30_VERSION_STRING },
305 { Smb_302, SMB302_VERSION_STRING },
306 { Smb_311, SMB311_VERSION_STRING },
307 { Smb_311, ALT_SMB311_VERSION_STRING },
308 { Smb_3any, SMB3ANY_VERSION_STRING },
309 { Smb_default, SMBDEFAULT_VERSION_STRING },
310 { Smb_version_err, NULL }
313 static int ip_connect(struct TCP_Server_Info *server);
314 static int generic_ip_connect(struct TCP_Server_Info *server);
315 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
316 static void cifs_prune_tlinks(struct work_struct *work);
317 static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
318 const char *devname, bool is_smb3);
321 * cifs tcp session reconnection
323 * mark tcp session as reconnecting so temporarily locked
324 * mark all smb sessions as reconnecting for tcp session
325 * reconnect tcp session
326 * wake up waiters on reconnection? - (not needed currently)
329 cifs_reconnect(struct TCP_Server_Info *server)
332 struct list_head *tmp, *tmp2;
333 struct cifs_ses *ses;
334 struct cifs_tcon *tcon;
335 struct mid_q_entry *mid_entry;
336 struct list_head retry_list;
338 spin_lock(&GlobalMid_Lock);
339 if (server->tcpStatus == CifsExiting) {
340 /* the demux thread will exit normally
341 next time through the loop */
342 spin_unlock(&GlobalMid_Lock);
345 server->tcpStatus = CifsNeedReconnect;
346 spin_unlock(&GlobalMid_Lock);
348 server->max_read = 0;
350 cifs_dbg(FYI, "Reconnecting tcp session\n");
351 trace_smb3_reconnect(server->CurrentMid, server->hostname);
353 /* before reconnecting the tcp session, mark the smb session (uid)
354 and the tid bad so they are not used until reconnected */
355 cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
357 spin_lock(&cifs_tcp_ses_lock);
358 list_for_each(tmp, &server->smb_ses_list) {
359 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
360 ses->need_reconnect = true;
361 list_for_each(tmp2, &ses->tcon_list) {
362 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
363 tcon->need_reconnect = true;
366 ses->tcon_ipc->need_reconnect = true;
368 spin_unlock(&cifs_tcp_ses_lock);
370 /* do not want to be sending data on a socket we are freeing */
371 cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
372 mutex_lock(&server->srv_mutex);
373 if (server->ssocket) {
374 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
375 server->ssocket->state, server->ssocket->flags);
376 kernel_sock_shutdown(server->ssocket, SHUT_WR);
377 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
378 server->ssocket->state, server->ssocket->flags);
379 sock_release(server->ssocket);
380 server->ssocket = NULL;
382 server->sequence_number = 0;
383 server->session_estab = false;
384 kfree(server->session_key.response);
385 server->session_key.response = NULL;
386 server->session_key.len = 0;
387 server->lstrp = jiffies;
389 /* mark submitted MIDs for retry and issue callback */
390 INIT_LIST_HEAD(&retry_list);
391 cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
392 spin_lock(&GlobalMid_Lock);
393 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
394 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
395 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
396 mid_entry->mid_state = MID_RETRY_NEEDED;
397 list_move(&mid_entry->qhead, &retry_list);
399 spin_unlock(&GlobalMid_Lock);
400 mutex_unlock(&server->srv_mutex);
402 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
403 list_for_each_safe(tmp, tmp2, &retry_list) {
404 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
405 list_del_init(&mid_entry->qhead);
406 mid_entry->callback(mid_entry);
412 /* we should try only the port we connected to before */
413 mutex_lock(&server->srv_mutex);
414 if (cifs_rdma_enabled(server))
415 rc = smbd_reconnect(server);
417 rc = generic_ip_connect(server);
419 cifs_dbg(FYI, "reconnect error %d\n", rc);
420 mutex_unlock(&server->srv_mutex);
423 atomic_inc(&tcpSesReconnectCount);
424 spin_lock(&GlobalMid_Lock);
425 if (server->tcpStatus != CifsExiting)
426 server->tcpStatus = CifsNeedNegotiate;
427 spin_unlock(&GlobalMid_Lock);
428 mutex_unlock(&server->srv_mutex);
430 } while (server->tcpStatus == CifsNeedReconnect);
432 if (server->tcpStatus == CifsNeedNegotiate)
433 mod_delayed_work(cifsiod_wq, &server->echo, 0);
439 cifs_echo_request(struct work_struct *work)
442 struct TCP_Server_Info *server = container_of(work,
443 struct TCP_Server_Info, echo.work);
444 unsigned long echo_interval;
447 * If we need to renegotiate, set echo interval to zero to
448 * immediately call echo service where we can renegotiate.
450 if (server->tcpStatus == CifsNeedNegotiate)
453 echo_interval = server->echo_interval;
456 * We cannot send an echo if it is disabled.
457 * Also, no need to ping if we got a response recently.
460 if (server->tcpStatus == CifsNeedReconnect ||
461 server->tcpStatus == CifsExiting ||
462 server->tcpStatus == CifsNew ||
463 (server->ops->can_echo && !server->ops->can_echo(server)) ||
464 time_before(jiffies, server->lstrp + echo_interval - HZ))
467 rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
469 cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
473 queue_delayed_work(cifsiod_wq, &server->echo, server->echo_interval);
477 allocate_buffers(struct TCP_Server_Info *server)
479 if (!server->bigbuf) {
480 server->bigbuf = (char *)cifs_buf_get();
481 if (!server->bigbuf) {
482 cifs_dbg(VFS, "No memory for large SMB response\n");
484 /* retry will check if exiting */
487 } else if (server->large_buf) {
488 /* we are reusing a dirty large buf, clear its start */
489 memset(server->bigbuf, 0, HEADER_SIZE(server));
492 if (!server->smallbuf) {
493 server->smallbuf = (char *)cifs_small_buf_get();
494 if (!server->smallbuf) {
495 cifs_dbg(VFS, "No memory for SMB response\n");
497 /* retry will check if exiting */
500 /* beginning of smb buffer is cleared in our buf_get */
502 /* if existing small buf clear beginning */
503 memset(server->smallbuf, 0, HEADER_SIZE(server));
510 server_unresponsive(struct TCP_Server_Info *server)
513 * We need to wait 2 echo intervals to make sure we handle such
515 * 1s client sends a normal SMB request
516 * 2s client gets a response
517 * 30s echo workqueue job pops, and decides we got a response recently
518 * and don't need to send another
520 * 65s kernel_recvmsg times out, and we see that we haven't gotten
521 * a response in >60s.
523 if ((server->tcpStatus == CifsGood ||
524 server->tcpStatus == CifsNeedNegotiate) &&
525 time_after(jiffies, server->lstrp + 2 * server->echo_interval)) {
526 cifs_dbg(VFS, "Server %s has not responded in %lu seconds. Reconnecting...\n",
527 server->hostname, (2 * server->echo_interval) / HZ);
528 cifs_reconnect(server);
529 wake_up(&server->response_q);
537 cifs_readv_from_socket(struct TCP_Server_Info *server, struct msghdr *smb_msg)
542 smb_msg->msg_control = NULL;
543 smb_msg->msg_controllen = 0;
545 for (total_read = 0; msg_data_left(smb_msg); total_read += length) {
548 if (server_unresponsive(server))
549 return -ECONNABORTED;
550 if (cifs_rdma_enabled(server) && server->smbd_conn)
551 length = smbd_recv(server->smbd_conn, smb_msg);
553 length = sock_recvmsg(server->ssocket, smb_msg, 0);
555 if (server->tcpStatus == CifsExiting)
558 if (server->tcpStatus == CifsNeedReconnect) {
559 cifs_reconnect(server);
560 return -ECONNABORTED;
563 if (length == -ERESTARTSYS ||
567 * Minimum sleep to prevent looping, allowing socket
568 * to clear and app threads to set tcpStatus
569 * CifsNeedReconnect if server hung.
571 usleep_range(1000, 2000);
577 cifs_dbg(FYI, "Received no data or error: %d\n", length);
578 cifs_reconnect(server);
579 return -ECONNABORTED;
586 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
587 unsigned int to_read)
589 struct msghdr smb_msg;
590 struct kvec iov = {.iov_base = buf, .iov_len = to_read};
591 iov_iter_kvec(&smb_msg.msg_iter, READ | ITER_KVEC, &iov, 1, to_read);
593 return cifs_readv_from_socket(server, &smb_msg);
597 cifs_read_page_from_socket(struct TCP_Server_Info *server, struct page *page,
598 unsigned int page_offset, unsigned int to_read)
600 struct msghdr smb_msg;
601 struct bio_vec bv = {
602 .bv_page = page, .bv_len = to_read, .bv_offset = page_offset};
603 iov_iter_bvec(&smb_msg.msg_iter, READ | ITER_BVEC, &bv, 1, to_read);
604 return cifs_readv_from_socket(server, &smb_msg);
608 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
611 * The first byte big endian of the length field,
612 * is actually not part of the length but the type
613 * with the most common, zero, as regular data.
616 case RFC1002_SESSION_MESSAGE:
617 /* Regular SMB response */
619 case RFC1002_SESSION_KEEP_ALIVE:
620 cifs_dbg(FYI, "RFC 1002 session keep alive\n");
622 case RFC1002_POSITIVE_SESSION_RESPONSE:
623 cifs_dbg(FYI, "RFC 1002 positive session response\n");
625 case RFC1002_NEGATIVE_SESSION_RESPONSE:
627 * We get this from Windows 98 instead of an error on
628 * SMB negprot response.
630 cifs_dbg(FYI, "RFC 1002 negative session response\n");
631 /* give server a second to clean up */
634 * Always try 445 first on reconnect since we get NACK
635 * on some if we ever connected to port 139 (the NACK
636 * is since we do not begin with RFC1001 session
639 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
640 cifs_reconnect(server);
641 wake_up(&server->response_q);
644 cifs_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
645 cifs_reconnect(server);
652 dequeue_mid(struct mid_q_entry *mid, bool malformed)
654 #ifdef CONFIG_CIFS_STATS2
655 mid->when_received = jiffies;
657 spin_lock(&GlobalMid_Lock);
659 mid->mid_state = MID_RESPONSE_RECEIVED;
661 mid->mid_state = MID_RESPONSE_MALFORMED;
663 * Trying to handle/dequeue a mid after the send_recv()
664 * function has finished processing it is a bug.
666 if (mid->mid_flags & MID_DELETED)
667 printk_once(KERN_WARNING
668 "trying to dequeue a deleted mid\n");
670 list_del_init(&mid->qhead);
671 spin_unlock(&GlobalMid_Lock);
675 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
676 char *buf, int malformed)
678 if (server->ops->check_trans2 &&
679 server->ops->check_trans2(mid, server, buf, malformed))
682 mid->large_buf = server->large_buf;
683 /* Was previous buf put in mpx struct for multi-rsp? */
684 if (!mid->multiRsp) {
685 /* smb buffer will be freed by user thread */
686 if (server->large_buf)
687 server->bigbuf = NULL;
689 server->smallbuf = NULL;
691 dequeue_mid(mid, malformed);
694 static void clean_demultiplex_info(struct TCP_Server_Info *server)
698 /* take it off the list, if it's not already */
699 spin_lock(&cifs_tcp_ses_lock);
700 list_del_init(&server->tcp_ses_list);
701 spin_unlock(&cifs_tcp_ses_lock);
703 spin_lock(&GlobalMid_Lock);
704 server->tcpStatus = CifsExiting;
705 spin_unlock(&GlobalMid_Lock);
706 wake_up_all(&server->response_q);
708 /* check if we have blocked requests that need to free */
709 spin_lock(&server->req_lock);
710 if (server->credits <= 0)
712 spin_unlock(&server->req_lock);
714 * Although there should not be any requests blocked on this queue it
715 * can not hurt to be paranoid and try to wake up requests that may
716 * haven been blocked when more than 50 at time were on the wire to the
717 * same server - they now will see the session is in exit state and get
718 * out of SendReceive.
720 wake_up_all(&server->request_q);
721 /* give those requests time to exit */
723 if (cifs_rdma_enabled(server) && server->smbd_conn) {
724 smbd_destroy(server->smbd_conn);
725 server->smbd_conn = NULL;
727 if (server->ssocket) {
728 sock_release(server->ssocket);
729 server->ssocket = NULL;
732 if (!list_empty(&server->pending_mid_q)) {
733 struct list_head dispose_list;
734 struct mid_q_entry *mid_entry;
735 struct list_head *tmp, *tmp2;
737 INIT_LIST_HEAD(&dispose_list);
738 spin_lock(&GlobalMid_Lock);
739 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
740 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
741 cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid);
742 mid_entry->mid_state = MID_SHUTDOWN;
743 list_move(&mid_entry->qhead, &dispose_list);
745 spin_unlock(&GlobalMid_Lock);
747 /* now walk dispose list and issue callbacks */
748 list_for_each_safe(tmp, tmp2, &dispose_list) {
749 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
750 cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid);
751 list_del_init(&mid_entry->qhead);
752 mid_entry->callback(mid_entry);
754 /* 1/8th of sec is more than enough time for them to exit */
758 if (!list_empty(&server->pending_mid_q)) {
760 * mpx threads have not exited yet give them at least the smb
761 * send timeout time for long ops.
763 * Due to delays on oplock break requests, we need to wait at
764 * least 45 seconds before giving up on a request getting a
765 * response and going ahead and killing cifsd.
767 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
770 * If threads still have not exited they are probably never
771 * coming home not much else we can do but free the memory.
775 kfree(server->hostname);
778 length = atomic_dec_return(&tcpSesAllocCount);
780 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
784 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
787 char *buf = server->smallbuf;
788 unsigned int pdu_length = server->pdu_size;
790 /* make sure this will fit in a large buffer */
791 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) -
792 server->vals->header_preamble_size) {
793 cifs_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
794 cifs_reconnect(server);
795 wake_up(&server->response_q);
796 return -ECONNABORTED;
799 /* switch to large buffer if too big for a small one */
800 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
801 server->large_buf = true;
802 memcpy(server->bigbuf, buf, server->total_read);
803 buf = server->bigbuf;
806 /* now read the rest */
807 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
808 pdu_length - HEADER_SIZE(server) + 1
809 + server->vals->header_preamble_size);
813 server->total_read += length;
815 dump_smb(buf, server->total_read);
817 return cifs_handle_standard(server, mid);
821 cifs_handle_standard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
823 char *buf = server->large_buf ? server->bigbuf : server->smallbuf;
827 * We know that we received enough to get to the MID as we
828 * checked the pdu_length earlier. Now check to see
829 * if the rest of the header is OK. We borrow the length
830 * var for the rest of the loop to avoid a new stack var.
832 * 48 bytes is enough to display the header and a little bit
833 * into the payload for debugging purposes.
835 length = server->ops->check_message(buf, server->total_read, server);
837 cifs_dump_mem("Bad SMB: ", buf,
838 min_t(unsigned int, server->total_read, 48));
840 if (server->ops->is_session_expired &&
841 server->ops->is_session_expired(buf)) {
842 cifs_reconnect(server);
843 wake_up(&server->response_q);
847 if (server->ops->is_status_pending &&
848 server->ops->is_status_pending(buf, server, length))
854 handle_mid(mid, server, buf, length);
859 cifs_demultiplex_thread(void *p)
861 int i, num_mids, length;
862 struct TCP_Server_Info *server = p;
863 unsigned int pdu_length;
864 unsigned int next_offset;
866 struct task_struct *task_to_wake = NULL;
867 struct mid_q_entry *mids[MAX_COMPOUND];
868 char *bufs[MAX_COMPOUND];
870 current->flags |= PF_MEMALLOC;
871 cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
873 length = atomic_inc_return(&tcpSesAllocCount);
875 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
878 while (server->tcpStatus != CifsExiting) {
882 if (!allocate_buffers(server))
885 server->large_buf = false;
886 buf = server->smallbuf;
887 pdu_length = 4; /* enough to get RFC1001 header */
889 length = cifs_read_from_socket(server, buf, pdu_length);
893 if (server->vals->header_preamble_size == 0)
894 server->total_read = 0;
896 server->total_read = length;
899 * The right amount was read from socket - 4 bytes,
900 * so we can now interpret the length field.
902 pdu_length = get_rfc1002_length(buf);
904 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
905 if (!is_smb_response(server, buf[0]))
908 server->pdu_size = pdu_length;
910 /* make sure we have enough to get to the MID */
911 if (server->pdu_size < HEADER_SIZE(server) - 1 -
912 server->vals->header_preamble_size) {
913 cifs_dbg(VFS, "SMB response too short (%u bytes)\n",
915 cifs_reconnect(server);
916 wake_up(&server->response_q);
920 /* read down to the MID */
921 length = cifs_read_from_socket(server,
922 buf + server->vals->header_preamble_size,
923 HEADER_SIZE(server) - 1
924 - server->vals->header_preamble_size);
927 server->total_read += length;
929 if (server->ops->next_header) {
930 next_offset = server->ops->next_header(buf);
932 server->pdu_size = next_offset;
935 memset(mids, 0, sizeof(mids));
936 memset(bufs, 0, sizeof(bufs));
939 if (server->ops->is_transform_hdr &&
940 server->ops->receive_transform &&
941 server->ops->is_transform_hdr(buf)) {
942 length = server->ops->receive_transform(server,
947 mids[0] = server->ops->find_mid(server, buf);
951 if (!mids[0] || !mids[0]->receive)
952 length = standard_receive3(server, mids[0]);
954 length = mids[0]->receive(server, mids[0]);
958 for (i = 0; i < num_mids; i++)
960 cifs_mid_q_entry_release(mids[i]);
964 if (server->large_buf)
965 buf = server->bigbuf;
968 server->lstrp = jiffies;
970 for (i = 0; i < num_mids; i++) {
971 if (mids[i] != NULL) {
972 mids[i]->resp_buf_size = server->pdu_size;
973 if ((mids[i]->mid_flags & MID_WAIT_CANCELLED) &&
974 mids[i]->mid_state == MID_RESPONSE_RECEIVED &&
975 server->ops->handle_cancelled_mid)
976 server->ops->handle_cancelled_mid(
980 if (!mids[i]->multiRsp || mids[i]->multiEnd)
981 mids[i]->callback(mids[i]);
983 cifs_mid_q_entry_release(mids[i]);
984 } else if (server->ops->is_oplock_break &&
985 server->ops->is_oplock_break(bufs[i],
987 cifs_dbg(FYI, "Received oplock break\n");
989 cifs_dbg(VFS, "No task to wake, unknown frame "
990 "received! NumMids %d\n",
991 atomic_read(&midCount));
992 cifs_dump_mem("Received Data is: ", bufs[i],
993 HEADER_SIZE(server));
994 #ifdef CONFIG_CIFS_DEBUG2
995 if (server->ops->dump_detail)
996 server->ops->dump_detail(bufs[i],
998 cifs_dump_mids(server);
999 #endif /* CIFS_DEBUG2 */
1003 if (pdu_length > server->pdu_size) {
1004 if (!allocate_buffers(server))
1006 pdu_length -= server->pdu_size;
1007 server->total_read = 0;
1008 server->large_buf = false;
1009 buf = server->smallbuf;
1012 } /* end while !EXITING */
1014 /* buffer usually freed in free_mid - need to free it here on exit */
1015 cifs_buf_release(server->bigbuf);
1016 if (server->smallbuf) /* no sense logging a debug message if NULL */
1017 cifs_small_buf_release(server->smallbuf);
1019 task_to_wake = xchg(&server->tsk, NULL);
1020 clean_demultiplex_info(server);
1022 /* if server->tsk was NULL then wait for a signal before exiting */
1023 if (!task_to_wake) {
1024 set_current_state(TASK_INTERRUPTIBLE);
1025 while (!signal_pending(current)) {
1027 set_current_state(TASK_INTERRUPTIBLE);
1029 set_current_state(TASK_RUNNING);
1032 module_put_and_exit(0);
1035 /* extract the host portion of the UNC string */
1037 extract_hostname(const char *unc)
1043 /* skip double chars at beginning of string */
1044 /* BB: check validity of these bytes? */
1047 /* delimiter between hostname and sharename is always '\\' now */
1048 delim = strchr(src, '\\');
1050 return ERR_PTR(-EINVAL);
1053 dst = kmalloc((len + 1), GFP_KERNEL);
1055 return ERR_PTR(-ENOMEM);
1057 memcpy(dst, src, len);
1063 static int get_option_ul(substring_t args[], unsigned long *option)
1068 string = match_strdup(args);
1071 rc = kstrtoul(string, 0, option);
1077 static int get_option_uid(substring_t args[], kuid_t *result)
1079 unsigned long value;
1083 rc = get_option_ul(args, &value);
1087 uid = make_kuid(current_user_ns(), value);
1088 if (!uid_valid(uid))
1095 static int get_option_gid(substring_t args[], kgid_t *result)
1097 unsigned long value;
1101 rc = get_option_ul(args, &value);
1105 gid = make_kgid(current_user_ns(), value);
1106 if (!gid_valid(gid))
1113 static int cifs_parse_security_flavors(char *value,
1114 struct smb_vol *vol)
1117 substring_t args[MAX_OPT_ARGS];
1120 * With mount options, the last one should win. Reset any existing
1121 * settings back to default.
1123 vol->sectype = Unspecified;
1126 switch (match_token(value, cifs_secflavor_tokens, args)) {
1128 cifs_dbg(VFS, "sec=krb5p is not supported!\n");
1134 vol->sectype = Kerberos;
1136 case Opt_sec_ntlmsspi:
1139 case Opt_sec_ntlmssp:
1140 vol->sectype = RawNTLMSSP;
1146 vol->sectype = NTLM;
1148 case Opt_sec_ntlmv2i:
1151 case Opt_sec_ntlmv2:
1152 vol->sectype = NTLMv2;
1154 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1155 case Opt_sec_lanman:
1156 vol->sectype = LANMAN;
1163 cifs_dbg(VFS, "bad security option: %s\n", value);
1171 cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1173 substring_t args[MAX_OPT_ARGS];
1175 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1176 case Opt_cache_loose:
1177 vol->direct_io = false;
1178 vol->strict_io = false;
1180 case Opt_cache_strict:
1181 vol->direct_io = false;
1182 vol->strict_io = true;
1184 case Opt_cache_none:
1185 vol->direct_io = true;
1186 vol->strict_io = false;
1189 cifs_dbg(VFS, "bad cache= option: %s\n", value);
1196 cifs_parse_smb_version(char *value, struct smb_vol *vol, bool is_smb3)
1198 substring_t args[MAX_OPT_ARGS];
1200 switch (match_token(value, cifs_smb_version_tokens, args)) {
1201 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1203 if (disable_legacy_dialects) {
1204 cifs_dbg(VFS, "mount with legacy dialect disabled\n");
1208 cifs_dbg(VFS, "vers=1.0 (cifs) not permitted when mounting with smb3\n");
1211 vol->ops = &smb1_operations;
1212 vol->vals = &smb1_values;
1215 if (disable_legacy_dialects) {
1216 cifs_dbg(VFS, "mount with legacy dialect disabled\n");
1220 cifs_dbg(VFS, "vers=2.0 not permitted when mounting with smb3\n");
1223 vol->ops = &smb20_operations;
1224 vol->vals = &smb20_values;
1228 cifs_dbg(VFS, "vers=1.0 (cifs) mount not permitted when legacy dialects disabled\n");
1231 cifs_dbg(VFS, "vers=2.0 mount not permitted when legacy dialects disabled\n");
1233 #endif /* CIFS_ALLOW_INSECURE_LEGACY */
1235 vol->ops = &smb21_operations;
1236 vol->vals = &smb21_values;
1239 vol->ops = &smb30_operations;
1240 vol->vals = &smb30_values;
1243 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1244 vol->vals = &smb302_values;
1247 vol->ops = &smb311_operations;
1248 vol->vals = &smb311_values;
1251 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1252 vol->vals = &smb3any_values;
1255 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1256 vol->vals = &smbdefault_values;
1259 cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
1266 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1267 * fields with the result. Returns 0 on success and an error otherwise.
1270 cifs_parse_devname(const char *devname, struct smb_vol *vol)
1273 const char *delims = "/\\";
1276 /* make sure we have a valid UNC double delimiter prefix */
1277 len = strspn(devname, delims);
1281 /* find delimiter between host and sharename */
1282 pos = strpbrk(devname + 2, delims);
1286 /* skip past delimiter */
1289 /* now go until next delimiter or end of string */
1290 len = strcspn(pos, delims);
1292 /* move "pos" up to delimiter or NULL */
1294 vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1298 convert_delimiter(vol->UNC, '\\');
1300 /* skip any delimiter */
1301 if (*pos == '/' || *pos == '\\')
1304 /* If pos is NULL then no prepath */
1308 vol->prepath = kstrdup(pos, GFP_KERNEL);
1316 cifs_parse_mount_options(const char *mountdata, const char *devname,
1317 struct smb_vol *vol, bool is_smb3)
1320 char *mountdata_copy = NULL, *options;
1321 unsigned int temp_len, i, j;
1323 short int override_uid = -1;
1324 short int override_gid = -1;
1325 bool uid_specified = false;
1326 bool gid_specified = false;
1327 bool sloppy = false;
1328 char *invalid = NULL;
1329 char *nodename = utsname()->nodename;
1330 char *string = NULL;
1331 char *tmp_end, *value;
1333 bool got_ip = false;
1334 bool got_version = false;
1335 unsigned short port = 0;
1336 struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1340 delim = separator[0];
1342 /* ensure we always start with zeroed-out smb_vol */
1343 memset(vol, 0, sizeof(*vol));
1346 * does not have to be perfect mapping since field is
1347 * informational, only used for servers that do not support
1348 * port 445 and it can be overridden at mount time
1350 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1351 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1352 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1354 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1355 /* null target name indicates to use *SMBSERVR default called name
1356 if we end up sending RFC1001 session initialize */
1357 vol->target_rfc1001_name[0] = 0;
1358 vol->cred_uid = current_uid();
1359 vol->linux_uid = current_uid();
1360 vol->linux_gid = current_gid();
1363 * default to SFM style remapping of seven reserved characters
1364 * unless user overrides it or we negotiate CIFS POSIX where
1365 * it is unnecessary. Can not simultaneously use more than one mapping
1366 * since then readdir could list files that open could not open
1370 /* default to only allowing write access to owner of the mount */
1371 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1373 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1374 /* default is always to request posix paths. */
1375 vol->posix_paths = 1;
1376 /* default to using server inode numbers where available */
1377 vol->server_ino = 1;
1379 /* default is to use strict cifs caching semantics */
1380 vol->strict_io = true;
1382 vol->actimeo = CIFS_DEF_ACTIMEO;
1384 /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
1385 vol->ops = &smb30_operations;
1386 vol->vals = &smbdefault_values;
1388 vol->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1391 goto cifs_parse_mount_err;
1393 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1394 if (!mountdata_copy)
1395 goto cifs_parse_mount_err;
1397 options = mountdata_copy;
1398 end = options + strlen(options);
1400 if (strncmp(options, "sep=", 4) == 0) {
1401 if (options[4] != 0) {
1402 separator[0] = options[4];
1405 cifs_dbg(FYI, "Null separator not allowed\n");
1408 vol->backupuid_specified = false; /* no backup intent for a user */
1409 vol->backupgid_specified = false; /* no backup intent for a group */
1411 switch (cifs_parse_devname(devname, vol)) {
1415 cifs_dbg(VFS, "Unable to allocate memory for devname.\n");
1416 goto cifs_parse_mount_err;
1418 cifs_dbg(VFS, "Malformed UNC in devname.\n");
1419 goto cifs_parse_mount_err;
1421 cifs_dbg(VFS, "Unknown error parsing devname.\n");
1422 goto cifs_parse_mount_err;
1425 while ((data = strsep(&options, separator)) != NULL) {
1426 substring_t args[MAX_OPT_ARGS];
1427 unsigned long option;
1433 token = match_token(data, cifs_mount_option_tokens, args);
1437 /* Ingnore the following */
1441 /* Boolean values */
1442 case Opt_user_xattr:
1445 case Opt_nouser_xattr:
1451 case Opt_noforceuid:
1457 case Opt_noforcegid:
1460 case Opt_noblocksend:
1461 vol->noblocksnd = 1;
1463 case Opt_noautotune:
1464 vol->noautotune = 1;
1479 vol->sfu_remap = true;
1480 vol->remap = false; /* disable SFM mapping */
1482 case Opt_nomapchars:
1483 vol->sfu_remap = false;
1487 vol->sfu_remap = false; /* disable SFU mapping */
1489 case Opt_nomapposix:
1501 case Opt_posixpaths:
1502 vol->posix_paths = 1;
1504 case Opt_noposixpaths:
1505 vol->posix_paths = 0;
1510 "conflicting unix mount options\n");
1511 vol->no_linux_ext = 1;
1514 if (vol->no_linux_ext)
1516 "conflicting unix mount options\n");
1528 * turn off mandatory locking in mode
1529 * if remote locking is turned off since the
1530 * local vfs will do advisory
1532 if (vol->file_mode ==
1533 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1534 vol->file_mode = S_IALLUGO;
1536 case Opt_nohandlecache:
1537 vol->nohandlecache = 1;
1539 case Opt_handlecache:
1540 vol->nohandlecache = 0;
1542 case Opt_forcemandatorylock:
1551 case Opt_setuidfromacl:
1552 vol->setuidfromacl = 1;
1555 vol->dynperm = true;
1558 vol->dynperm = false;
1572 case Opt_nostrictsync:
1573 vol->nostrictsync = 1;
1575 case Opt_strictsync:
1576 vol->nostrictsync = 0;
1579 vol->server_ino = 1;
1581 case Opt_noserverino:
1582 vol->server_ino = 0;
1584 case Opt_rwpidforward:
1585 vol->rwpidforward = 1;
1594 vol->no_psx_acl = 0;
1597 vol->no_psx_acl = 1;
1599 case Opt_locallease:
1600 vol->local_lease = 1;
1606 /* we do not do the following in secFlags because seal
1607 * is a per tree connection (mount) not a per socket
1608 * or per-smb connection option in the protocol
1609 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1614 pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1617 #ifndef CONFIG_CIFS_FSCACHE
1618 cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1619 goto cifs_parse_mount_err;
1623 case Opt_mfsymlinks:
1624 vol->mfsymlinks = true;
1627 vol->multiuser = true;
1632 case Opt_nosharesock:
1633 vol->nosharesock = true;
1635 case Opt_nopersistent:
1636 vol->nopersistent = true;
1637 if (vol->persistent) {
1639 "persistenthandles mount options conflict\n");
1640 goto cifs_parse_mount_err;
1643 case Opt_persistent:
1644 vol->persistent = true;
1645 if ((vol->nopersistent) || (vol->resilient)) {
1647 "persistenthandles mount options conflict\n");
1648 goto cifs_parse_mount_err;
1652 vol->resilient = true;
1653 if (vol->persistent) {
1655 "persistenthandles mount options conflict\n");
1656 goto cifs_parse_mount_err;
1659 case Opt_noresilient:
1660 vol->resilient = false; /* already the default */
1662 case Opt_domainauto:
1663 vol->domainauto = true;
1669 /* Numeric Values */
1671 if (get_option_uid(args, &vol->backupuid)) {
1672 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
1674 goto cifs_parse_mount_err;
1676 vol->backupuid_specified = true;
1679 if (get_option_gid(args, &vol->backupgid)) {
1680 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
1682 goto cifs_parse_mount_err;
1684 vol->backupgid_specified = true;
1687 if (get_option_uid(args, &vol->linux_uid)) {
1688 cifs_dbg(VFS, "%s: Invalid uid value\n",
1690 goto cifs_parse_mount_err;
1692 uid_specified = true;
1695 if (get_option_uid(args, &vol->cred_uid)) {
1696 cifs_dbg(VFS, "%s: Invalid cruid value\n",
1698 goto cifs_parse_mount_err;
1702 if (get_option_gid(args, &vol->linux_gid)) {
1703 cifs_dbg(VFS, "%s: Invalid gid value\n",
1705 goto cifs_parse_mount_err;
1707 gid_specified = true;
1710 if (get_option_ul(args, &option)) {
1711 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
1713 goto cifs_parse_mount_err;
1715 vol->file_mode = option;
1718 if (get_option_ul(args, &option)) {
1719 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
1721 goto cifs_parse_mount_err;
1723 vol->dir_mode = option;
1726 if (get_option_ul(args, &option) ||
1727 option > USHRT_MAX) {
1728 cifs_dbg(VFS, "%s: Invalid port value\n",
1730 goto cifs_parse_mount_err;
1732 port = (unsigned short)option;
1735 if (get_option_ul(args, &option)) {
1736 cifs_dbg(VFS, "%s: Invalid rsize value\n",
1738 goto cifs_parse_mount_err;
1740 vol->rsize = option;
1743 if (get_option_ul(args, &option)) {
1744 cifs_dbg(VFS, "%s: Invalid wsize value\n",
1746 goto cifs_parse_mount_err;
1748 vol->wsize = option;
1751 if (get_option_ul(args, &option)) {
1752 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
1754 goto cifs_parse_mount_err;
1756 vol->actimeo = HZ * option;
1757 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1758 cifs_dbg(VFS, "attribute cache timeout too large\n");
1759 goto cifs_parse_mount_err;
1762 case Opt_echo_interval:
1763 if (get_option_ul(args, &option)) {
1764 cifs_dbg(VFS, "%s: Invalid echo interval value\n",
1766 goto cifs_parse_mount_err;
1768 vol->echo_interval = option;
1771 if (get_option_ul(args, &option)) {
1772 cifs_dbg(VFS, "%s: Invalid snapshot time\n",
1774 goto cifs_parse_mount_err;
1776 vol->snapshot_time = option;
1778 case Opt_max_credits:
1779 if (get_option_ul(args, &option) || (option < 20) ||
1781 cifs_dbg(VFS, "%s: Invalid max_credits value\n",
1783 goto cifs_parse_mount_err;
1785 vol->max_credits = option;
1788 /* String Arguments */
1790 case Opt_blank_user:
1791 /* null user, ie. anonymous authentication */
1793 vol->username = NULL;
1796 string = match_strdup(args);
1800 if (strnlen(string, CIFS_MAX_USERNAME_LEN) >
1801 CIFS_MAX_USERNAME_LEN) {
1802 pr_warn("CIFS: username too long\n");
1803 goto cifs_parse_mount_err;
1806 kfree(vol->username);
1807 vol->username = kstrdup(string, GFP_KERNEL);
1809 goto cifs_parse_mount_err;
1811 case Opt_blank_pass:
1812 /* passwords have to be handled differently
1813 * to allow the character used for deliminator
1814 * to be passed within them
1818 * Check if this is a case where the password
1819 * starts with a delimiter
1821 tmp_end = strchr(data, '=');
1823 if (!(tmp_end < end && tmp_end[1] == delim)) {
1824 /* No it is not. Set the password to NULL */
1825 kzfree(vol->password);
1826 vol->password = NULL;
1829 /* Yes it is. Drop down to Opt_pass below.*/
1831 /* Obtain the value string */
1832 value = strchr(data, '=');
1835 /* Set tmp_end to end of the string */
1836 tmp_end = (char *) value + strlen(value);
1838 /* Check if following character is the deliminator
1839 * If yes, we have encountered a double deliminator
1840 * reset the NULL character to the deliminator
1842 if (tmp_end < end && tmp_end[1] == delim) {
1845 /* Keep iterating until we get to a single
1846 * deliminator OR the end
1848 while ((tmp_end = strchr(tmp_end, delim))
1849 != NULL && (tmp_end[1] == delim)) {
1850 tmp_end = (char *) &tmp_end[2];
1853 /* Reset var options to point to next element */
1856 options = (char *) &tmp_end[1];
1858 /* Reached the end of the mount option
1863 kzfree(vol->password);
1864 /* Now build new password string */
1865 temp_len = strlen(value);
1866 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1867 if (vol->password == NULL) {
1868 pr_warn("CIFS: no memory for password\n");
1869 goto cifs_parse_mount_err;
1872 for (i = 0, j = 0; i < temp_len; i++, j++) {
1873 vol->password[j] = value[i];
1874 if ((value[i] == delim) &&
1875 value[i+1] == delim)
1876 /* skip the second deliminator */
1879 vol->password[j] = '\0';
1882 /* FIXME: should this be an error instead? */
1886 string = match_strdup(args);
1890 if (!cifs_convert_address(dstaddr, string,
1892 pr_err("CIFS: bad ip= option (%s).\n", string);
1893 goto cifs_parse_mount_err;
1898 string = match_strdup(args);
1902 if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
1903 == CIFS_MAX_DOMAINNAME_LEN) {
1904 pr_warn("CIFS: domain name too long\n");
1905 goto cifs_parse_mount_err;
1908 kfree(vol->domainname);
1909 vol->domainname = kstrdup(string, GFP_KERNEL);
1910 if (!vol->domainname) {
1911 pr_warn("CIFS: no memory for domainname\n");
1912 goto cifs_parse_mount_err;
1914 cifs_dbg(FYI, "Domain name set\n");
1917 string = match_strdup(args);
1921 if (!cifs_convert_address(
1922 (struct sockaddr *)&vol->srcaddr,
1923 string, strlen(string))) {
1924 pr_warn("CIFS: Could not parse srcaddr: %s\n",
1926 goto cifs_parse_mount_err;
1930 string = match_strdup(args);
1934 if (strnlen(string, 1024) >= 65) {
1935 pr_warn("CIFS: iocharset name too long.\n");
1936 goto cifs_parse_mount_err;
1939 if (strncasecmp(string, "default", 7) != 0) {
1940 kfree(vol->iocharset);
1941 vol->iocharset = kstrdup(string,
1943 if (!vol->iocharset) {
1944 pr_warn("CIFS: no memory for charset\n");
1945 goto cifs_parse_mount_err;
1948 /* if iocharset not set then load_nls_default
1951 cifs_dbg(FYI, "iocharset set to %s\n", string);
1953 case Opt_netbiosname:
1954 string = match_strdup(args);
1958 memset(vol->source_rfc1001_name, 0x20,
1961 * FIXME: are there cases in which a comma can
1962 * be valid in workstation netbios name (and
1963 * need special handling)?
1965 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1966 /* don't ucase netbiosname for user */
1969 vol->source_rfc1001_name[i] = string[i];
1971 /* The string has 16th byte zero still from
1972 * set at top of the function
1974 if (i == RFC1001_NAME_LEN && string[i] != 0)
1975 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
1978 /* servernetbiosname specified override *SMBSERVER */
1979 string = match_strdup(args);
1983 /* last byte, type, is 0x20 for servr type */
1984 memset(vol->target_rfc1001_name, 0x20,
1985 RFC1001_NAME_LEN_WITH_NULL);
1987 /* BB are there cases in which a comma can be
1988 valid in this workstation netbios name
1989 (and need special handling)? */
1991 /* user or mount helper must uppercase the
1993 for (i = 0; i < 15; i++) {
1996 vol->target_rfc1001_name[i] = string[i];
1998 /* The string has 16th byte zero still from
1999 set at top of the function */
2000 if (i == RFC1001_NAME_LEN && string[i] != 0)
2001 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
2004 /* version of mount userspace tools, not dialect */
2005 string = match_strdup(args);
2009 /* If interface changes in mount.cifs bump to new ver */
2010 if (strncasecmp(string, "1", 1) == 0) {
2011 if (strlen(string) > 1) {
2012 pr_warn("Bad mount helper ver=%s. Did "
2013 "you want SMB1 (CIFS) dialect "
2014 "and mean to type vers=1.0 "
2015 "instead?\n", string);
2016 goto cifs_parse_mount_err;
2018 /* This is the default */
2021 /* For all other value, error */
2022 pr_warn("CIFS: Invalid mount helper version specified\n");
2023 goto cifs_parse_mount_err;
2025 /* protocol version (dialect) */
2026 string = match_strdup(args);
2030 if (cifs_parse_smb_version(string, vol, is_smb3) != 0)
2031 goto cifs_parse_mount_err;
2035 string = match_strdup(args);
2039 if (cifs_parse_security_flavors(string, vol) != 0)
2040 goto cifs_parse_mount_err;
2043 string = match_strdup(args);
2047 if (cifs_parse_cache_flavor(string, vol) != 0)
2048 goto cifs_parse_mount_err;
2052 * An option we don't recognize. Save it off for later
2053 * if we haven't already found one
2059 /* Free up any allocated string */
2064 if (!sloppy && invalid) {
2065 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid);
2066 goto cifs_parse_mount_err;
2069 if (vol->rdma && vol->vals->protocol_id < SMB30_PROT_ID) {
2070 cifs_dbg(VFS, "SMB Direct requires Version >=3.0\n");
2071 goto cifs_parse_mount_err;
2075 /* Muliuser mounts require CONFIG_KEYS support */
2076 if (vol->multiuser) {
2077 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
2078 goto cifs_parse_mount_err;
2082 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
2083 goto cifs_parse_mount_err;
2086 /* make sure UNC has a share name */
2087 if (!strchr(vol->UNC + 3, '\\')) {
2088 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
2089 goto cifs_parse_mount_err;
2096 /* No ip= option specified? Try to get it from UNC */
2097 /* Use the address part of the UNC. */
2098 slash = strchr(&vol->UNC[2], '\\');
2099 len = slash - &vol->UNC[2];
2100 if (!cifs_convert_address(dstaddr, &vol->UNC[2], len)) {
2101 pr_err("Unable to determine destination address.\n");
2102 goto cifs_parse_mount_err;
2106 /* set the port that we got earlier */
2107 cifs_set_port(dstaddr, port);
2110 vol->override_uid = override_uid;
2111 else if (override_uid == 1)
2112 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
2115 vol->override_gid = override_gid;
2116 else if (override_gid == 1)
2117 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
2119 if (got_version == false)
2120 pr_warn("No dialect specified on mount. Default has changed to "
2121 "a more secure dialect, SMB2.1 or later (e.g. SMB3), from CIFS "
2122 "(SMB1). To use the less secure SMB1 dialect to access "
2123 "old servers which do not support SMB3 (or SMB2.1) specify vers=1.0"
2126 kfree(mountdata_copy);
2130 pr_warn("Could not allocate temporary buffer\n");
2131 cifs_parse_mount_err:
2133 kfree(mountdata_copy);
2137 /** Returns true if srcaddr isn't specified and rhs isn't
2138 * specified, or if srcaddr is specified and
2139 * matches the IP address of the rhs argument.
2142 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
2144 switch (srcaddr->sa_family) {
2146 return (rhs->sa_family == AF_UNSPEC);
2148 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
2149 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
2150 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
2153 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
2154 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
2155 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
2159 return false; /* don't expect to be here */
2164 * If no port is specified in addr structure, we try to match with 445 port
2165 * and if it fails - with 139 ports. It should be called only if address
2166 * families of server and addr are equal.
2169 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
2171 __be16 port, *sport;
2173 switch (addr->sa_family) {
2175 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
2176 port = ((struct sockaddr_in *) addr)->sin_port;
2179 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
2180 port = ((struct sockaddr_in6 *) addr)->sin6_port;
2188 port = htons(CIFS_PORT);
2192 port = htons(RFC1001_PORT);
2195 return port == *sport;
2199 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
2200 struct sockaddr *srcaddr)
2202 switch (addr->sa_family) {
2204 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2205 struct sockaddr_in *srv_addr4 =
2206 (struct sockaddr_in *)&server->dstaddr;
2208 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
2213 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2214 struct sockaddr_in6 *srv_addr6 =
2215 (struct sockaddr_in6 *)&server->dstaddr;
2217 if (!ipv6_addr_equal(&addr6->sin6_addr,
2218 &srv_addr6->sin6_addr))
2220 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
2226 return false; /* don't expect to be here */
2229 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2236 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2239 * The select_sectype function should either return the vol->sectype
2240 * that was specified, or "Unspecified" if that sectype was not
2241 * compatible with the given NEGOTIATE request.
2243 if (server->ops->select_sectype(server, vol->sectype)
2248 * Now check if signing mode is acceptable. No need to check
2249 * global_secflags at this point since if MUST_SIGN is set then
2250 * the server->sign had better be too.
2252 if (vol->sign && !server->sign)
2258 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2260 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2262 if (vol->nosharesock)
2265 /* BB update this for smb3any and default case */
2266 if ((server->vals != vol->vals) || (server->ops != vol->ops))
2269 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2272 if (!match_address(server, addr,
2273 (struct sockaddr *)&vol->srcaddr))
2276 if (!match_port(server, addr))
2279 if (!match_security(server, vol))
2282 if (server->echo_interval != vol->echo_interval * HZ)
2285 if (server->rdma != vol->rdma)
2291 static struct TCP_Server_Info *
2292 cifs_find_tcp_session(struct smb_vol *vol)
2294 struct TCP_Server_Info *server;
2296 spin_lock(&cifs_tcp_ses_lock);
2297 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2298 if (!match_server(server, vol))
2301 ++server->srv_count;
2302 spin_unlock(&cifs_tcp_ses_lock);
2303 cifs_dbg(FYI, "Existing tcp session with server found\n");
2306 spin_unlock(&cifs_tcp_ses_lock);
2311 cifs_put_tcp_session(struct TCP_Server_Info *server, int from_reconnect)
2313 struct task_struct *task;
2315 spin_lock(&cifs_tcp_ses_lock);
2316 if (--server->srv_count > 0) {
2317 spin_unlock(&cifs_tcp_ses_lock);
2321 put_net(cifs_net_ns(server));
2323 list_del_init(&server->tcp_ses_list);
2324 spin_unlock(&cifs_tcp_ses_lock);
2326 cancel_delayed_work_sync(&server->echo);
2330 * Avoid deadlock here: reconnect work calls
2331 * cifs_put_tcp_session() at its end. Need to be sure
2332 * that reconnect work does nothing with server pointer after
2335 cancel_delayed_work(&server->reconnect);
2337 cancel_delayed_work_sync(&server->reconnect);
2339 spin_lock(&GlobalMid_Lock);
2340 server->tcpStatus = CifsExiting;
2341 spin_unlock(&GlobalMid_Lock);
2343 cifs_crypto_secmech_release(server);
2344 cifs_fscache_release_client_cookie(server);
2346 kfree(server->session_key.response);
2347 server->session_key.response = NULL;
2348 server->session_key.len = 0;
2350 task = xchg(&server->tsk, NULL);
2352 force_sig(SIGKILL, task);
2355 static struct TCP_Server_Info *
2356 cifs_get_tcp_session(struct smb_vol *volume_info)
2358 struct TCP_Server_Info *tcp_ses = NULL;
2361 cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
2363 /* see if we already have a matching tcp_ses */
2364 tcp_ses = cifs_find_tcp_session(volume_info);
2368 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2374 tcp_ses->ops = volume_info->ops;
2375 tcp_ses->vals = volume_info->vals;
2376 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2377 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2378 if (IS_ERR(tcp_ses->hostname)) {
2379 rc = PTR_ERR(tcp_ses->hostname);
2380 goto out_err_crypto_release;
2383 tcp_ses->noblocksnd = volume_info->noblocksnd;
2384 tcp_ses->noautotune = volume_info->noautotune;
2385 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2386 tcp_ses->rdma = volume_info->rdma;
2387 tcp_ses->in_flight = 0;
2388 tcp_ses->credits = 1;
2389 init_waitqueue_head(&tcp_ses->response_q);
2390 init_waitqueue_head(&tcp_ses->request_q);
2391 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2392 mutex_init(&tcp_ses->srv_mutex);
2393 memcpy(tcp_ses->workstation_RFC1001_name,
2394 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2395 memcpy(tcp_ses->server_RFC1001_name,
2396 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2397 tcp_ses->session_estab = false;
2398 tcp_ses->sequence_number = 0;
2399 tcp_ses->lstrp = jiffies;
2400 spin_lock_init(&tcp_ses->req_lock);
2401 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2402 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2403 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2404 INIT_DELAYED_WORK(&tcp_ses->reconnect, smb2_reconnect_server);
2405 mutex_init(&tcp_ses->reconnect_mutex);
2406 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2407 sizeof(tcp_ses->srcaddr));
2408 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2409 sizeof(tcp_ses->dstaddr));
2410 generate_random_uuid(tcp_ses->client_guid);
2412 * at this point we are the only ones with the pointer
2413 * to the struct since the kernel thread not created yet
2414 * no need to spinlock this init of tcpStatus or srv_count
2416 tcp_ses->tcpStatus = CifsNew;
2417 ++tcp_ses->srv_count;
2419 if (volume_info->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
2420 volume_info->echo_interval <= SMB_ECHO_INTERVAL_MAX)
2421 tcp_ses->echo_interval = volume_info->echo_interval * HZ;
2423 tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
2424 if (tcp_ses->rdma) {
2425 #ifndef CONFIG_CIFS_SMB_DIRECT
2426 cifs_dbg(VFS, "CONFIG_CIFS_SMB_DIRECT is not enabled\n");
2428 goto out_err_crypto_release;
2430 tcp_ses->smbd_conn = smbd_get_connection(
2431 tcp_ses, (struct sockaddr *)&volume_info->dstaddr);
2432 if (tcp_ses->smbd_conn) {
2433 cifs_dbg(VFS, "RDMA transport established\n");
2435 goto smbd_connected;
2438 goto out_err_crypto_release;
2441 rc = ip_connect(tcp_ses);
2443 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
2444 goto out_err_crypto_release;
2448 * since we're in a cifs function already, we know that
2449 * this will succeed. No need for try_module_get().
2451 __module_get(THIS_MODULE);
2452 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2454 if (IS_ERR(tcp_ses->tsk)) {
2455 rc = PTR_ERR(tcp_ses->tsk);
2456 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
2457 module_put(THIS_MODULE);
2458 goto out_err_crypto_release;
2460 tcp_ses->tcpStatus = CifsNeedNegotiate;
2462 /* thread spawned, put it on the list */
2463 spin_lock(&cifs_tcp_ses_lock);
2464 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2465 spin_unlock(&cifs_tcp_ses_lock);
2467 cifs_fscache_get_client_cookie(tcp_ses);
2469 /* queue echo request delayed work */
2470 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
2474 out_err_crypto_release:
2475 cifs_crypto_secmech_release(tcp_ses);
2477 put_net(cifs_net_ns(tcp_ses));
2481 if (!IS_ERR(tcp_ses->hostname))
2482 kfree(tcp_ses->hostname);
2483 if (tcp_ses->ssocket)
2484 sock_release(tcp_ses->ssocket);
2490 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2492 if (vol->sectype != Unspecified &&
2493 vol->sectype != ses->sectype)
2496 switch (ses->sectype) {
2498 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2502 /* NULL username means anonymous session */
2503 if (ses->user_name == NULL) {
2509 /* anything else takes username/password */
2510 if (strncmp(ses->user_name,
2511 vol->username ? vol->username : "",
2512 CIFS_MAX_USERNAME_LEN))
2514 if ((vol->username && strlen(vol->username) != 0) &&
2515 ses->password != NULL &&
2516 strncmp(ses->password,
2517 vol->password ? vol->password : "",
2518 CIFS_MAX_PASSWORD_LEN))
2525 * cifs_setup_ipc - helper to setup the IPC tcon for the session
2527 * A new IPC connection is made and stored in the session
2528 * tcon_ipc. The IPC tcon has the same lifetime as the session.
2531 cifs_setup_ipc(struct cifs_ses *ses, struct smb_vol *volume_info)
2534 struct cifs_tcon *tcon;
2535 struct nls_table *nls_codepage;
2536 char unc[SERVER_NAME_LENGTH + sizeof("//x/IPC$")] = {0};
2540 * If the mount request that resulted in the creation of the
2541 * session requires encryption, force IPC to be encrypted too.
2543 if (volume_info->seal) {
2544 if (ses->server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION)
2548 "IPC: server doesn't support encryption\n");
2553 tcon = tconInfoAlloc();
2557 snprintf(unc, sizeof(unc), "\\\\%s\\IPC$", ses->server->hostname);
2560 nls_codepage = load_nls_default();
2566 rc = ses->server->ops->tree_connect(xid, ses, unc, tcon, nls_codepage);
2570 cifs_dbg(VFS, "failed to connect to IPC (rc=%d)\n", rc);
2575 cifs_dbg(FYI, "IPC tcon rc = %d ipc tid = %d\n", rc, tcon->tid);
2577 ses->tcon_ipc = tcon;
2579 unload_nls(nls_codepage);
2584 * cifs_free_ipc - helper to release the session IPC tcon
2586 * Needs to be called everytime a session is destroyed
2589 cifs_free_ipc(struct cifs_ses *ses)
2592 struct cifs_tcon *tcon = ses->tcon_ipc;
2597 if (ses->server->ops->tree_disconnect) {
2599 rc = ses->server->ops->tree_disconnect(xid, tcon);
2604 cifs_dbg(FYI, "failed to disconnect IPC tcon (rc=%d)\n", rc);
2607 ses->tcon_ipc = NULL;
2611 static struct cifs_ses *
2612 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2614 struct cifs_ses *ses;
2616 spin_lock(&cifs_tcp_ses_lock);
2617 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2618 if (ses->status == CifsExiting)
2620 if (!match_session(ses, vol))
2623 spin_unlock(&cifs_tcp_ses_lock);
2626 spin_unlock(&cifs_tcp_ses_lock);
2631 cifs_put_smb_ses(struct cifs_ses *ses)
2633 unsigned int rc, xid;
2634 struct TCP_Server_Info *server = ses->server;
2636 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
2638 spin_lock(&cifs_tcp_ses_lock);
2639 if (ses->status == CifsExiting) {
2640 spin_unlock(&cifs_tcp_ses_lock);
2643 if (--ses->ses_count > 0) {
2644 spin_unlock(&cifs_tcp_ses_lock);
2647 if (ses->status == CifsGood)
2648 ses->status = CifsExiting;
2649 spin_unlock(&cifs_tcp_ses_lock);
2653 if (ses->status == CifsExiting && server->ops->logoff) {
2655 rc = server->ops->logoff(xid, ses);
2657 cifs_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
2662 spin_lock(&cifs_tcp_ses_lock);
2663 list_del_init(&ses->smb_ses_list);
2664 spin_unlock(&cifs_tcp_ses_lock);
2667 cifs_put_tcp_session(server, 0);
2672 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2673 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2675 /* Populate username and pw fields from keyring if possible */
2677 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2680 const char *delim, *payload;
2684 struct TCP_Server_Info *server = ses->server;
2685 struct sockaddr_in *sa;
2686 struct sockaddr_in6 *sa6;
2687 const struct user_key_payload *upayload;
2689 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2693 /* try to find an address key first */
2694 switch (server->dstaddr.ss_family) {
2696 sa = (struct sockaddr_in *)&server->dstaddr;
2697 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2700 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2701 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2704 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2705 server->dstaddr.ss_family);
2710 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2711 key = request_key(&key_type_logon, desc, "");
2713 if (!ses->domainName) {
2714 cifs_dbg(FYI, "domainName is NULL\n");
2719 /* didn't work, try to find a domain key */
2720 sprintf(desc, "cifs:d:%s", ses->domainName);
2721 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2722 key = request_key(&key_type_logon, desc, "");
2729 down_read(&key->sem);
2730 upayload = user_key_payload_locked(key);
2731 if (IS_ERR_OR_NULL(upayload)) {
2732 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2736 /* find first : in payload */
2737 payload = upayload->data;
2738 delim = strnchr(payload, upayload->datalen, ':');
2739 cifs_dbg(FYI, "payload=%s\n", payload);
2741 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
2747 len = delim - payload;
2748 if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
2749 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
2755 vol->username = kstrndup(payload, len, GFP_KERNEL);
2756 if (!vol->username) {
2757 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
2762 cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
2764 len = key->datalen - (len + 1);
2765 if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
2766 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
2768 kfree(vol->username);
2769 vol->username = NULL;
2774 vol->password = kstrndup(delim, len, GFP_KERNEL);
2775 if (!vol->password) {
2776 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
2779 kfree(vol->username);
2780 vol->username = NULL;
2789 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
2792 #else /* ! CONFIG_KEYS */
2794 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2795 struct cifs_ses *ses __attribute__((unused)))
2799 #endif /* CONFIG_KEYS */
2802 * cifs_get_smb_ses - get a session matching @volume_info data from @server
2804 * This function assumes it is being called from cifs_mount() where we
2805 * already got a server reference (server refcount +1). See
2806 * cifs_get_tcon() for refcount explanations.
2808 static struct cifs_ses *
2809 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2813 struct cifs_ses *ses;
2814 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2815 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2819 ses = cifs_find_smb_ses(server, volume_info);
2821 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
2824 mutex_lock(&ses->session_mutex);
2825 rc = cifs_negotiate_protocol(xid, ses);
2827 mutex_unlock(&ses->session_mutex);
2828 /* problem -- put our ses reference */
2829 cifs_put_smb_ses(ses);
2833 if (ses->need_reconnect) {
2834 cifs_dbg(FYI, "Session needs reconnect\n");
2835 rc = cifs_setup_session(xid, ses,
2836 volume_info->local_nls);
2838 mutex_unlock(&ses->session_mutex);
2839 /* problem -- put our reference */
2840 cifs_put_smb_ses(ses);
2845 mutex_unlock(&ses->session_mutex);
2847 /* existing SMB ses has a server reference already */
2848 cifs_put_tcp_session(server, 0);
2853 cifs_dbg(FYI, "Existing smb sess not found\n");
2854 ses = sesInfoAlloc();
2858 /* new SMB session uses our server ref */
2859 ses->server = server;
2860 if (server->dstaddr.ss_family == AF_INET6)
2861 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2863 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2865 if (volume_info->username) {
2866 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2867 if (!ses->user_name)
2871 /* volume_info->password freed at unmount */
2872 if (volume_info->password) {
2873 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2877 if (volume_info->domainname) {
2878 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2879 if (!ses->domainName)
2882 if (volume_info->domainauto)
2883 ses->domainAuto = volume_info->domainauto;
2884 ses->cred_uid = volume_info->cred_uid;
2885 ses->linux_uid = volume_info->linux_uid;
2887 ses->sectype = volume_info->sectype;
2888 ses->sign = volume_info->sign;
2890 mutex_lock(&ses->session_mutex);
2891 rc = cifs_negotiate_protocol(xid, ses);
2893 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2894 mutex_unlock(&ses->session_mutex);
2898 /* success, put it on the list */
2899 spin_lock(&cifs_tcp_ses_lock);
2900 list_add(&ses->smb_ses_list, &server->smb_ses_list);
2901 spin_unlock(&cifs_tcp_ses_lock);
2905 cifs_setup_ipc(ses, volume_info);
2915 static int match_tcon(struct cifs_tcon *tcon, struct smb_vol *volume_info)
2917 if (tcon->tidStatus == CifsExiting)
2919 if (strncmp(tcon->treeName, volume_info->UNC, MAX_TREE_SIZE))
2921 if (tcon->seal != volume_info->seal)
2923 if (tcon->snapshot_time != volume_info->snapshot_time)
2928 static struct cifs_tcon *
2929 cifs_find_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2931 struct list_head *tmp;
2932 struct cifs_tcon *tcon;
2934 spin_lock(&cifs_tcp_ses_lock);
2935 list_for_each(tmp, &ses->tcon_list) {
2936 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2937 if (!match_tcon(tcon, volume_info))
2940 spin_unlock(&cifs_tcp_ses_lock);
2943 spin_unlock(&cifs_tcp_ses_lock);
2948 cifs_put_tcon(struct cifs_tcon *tcon)
2951 struct cifs_ses *ses;
2954 * IPC tcon share the lifetime of their session and are
2955 * destroyed in the session put function
2957 if (tcon == NULL || tcon->ipc)
2961 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2962 spin_lock(&cifs_tcp_ses_lock);
2963 if (--tcon->tc_count > 0) {
2964 spin_unlock(&cifs_tcp_ses_lock);
2968 list_del_init(&tcon->tcon_list);
2969 spin_unlock(&cifs_tcp_ses_lock);
2972 if (ses->server->ops->tree_disconnect)
2973 ses->server->ops->tree_disconnect(xid, tcon);
2976 cifs_fscache_release_super_cookie(tcon);
2978 cifs_put_smb_ses(ses);
2982 * cifs_get_tcon - get a tcon matching @volume_info data from @ses
2984 * - tcon refcount is the number of mount points using the tcon.
2985 * - ses refcount is the number of tcon using the session.
2987 * 1. This function assumes it is being called from cifs_mount() where
2988 * we already got a session reference (ses refcount +1).
2990 * 2. Since we're in the context of adding a mount point, the end
2991 * result should be either:
2993 * a) a new tcon already allocated with refcount=1 (1 mount point) and
2994 * its session refcount incremented (1 new tcon). This +1 was
2995 * already done in (1).
2997 * b) an existing tcon with refcount+1 (add a mount point to it) and
2998 * identical ses refcount (no new tcon). Because of (1) we need to
2999 * decrement the ses refcount.
3001 static struct cifs_tcon *
3002 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
3005 struct cifs_tcon *tcon;
3007 tcon = cifs_find_tcon(ses, volume_info);
3010 * tcon has refcount already incremented but we need to
3011 * decrement extra ses reference gotten by caller (case b)
3013 cifs_dbg(FYI, "Found match on UNC path\n");
3014 cifs_put_smb_ses(ses);
3018 if (!ses->server->ops->tree_connect) {
3023 tcon = tconInfoAlloc();
3029 if (volume_info->snapshot_time) {
3030 if (ses->server->vals->protocol_id == 0) {
3032 "Use SMB2 or later for snapshot mount option\n");
3036 tcon->snapshot_time = volume_info->snapshot_time;
3040 if (volume_info->password) {
3041 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
3042 if (!tcon->password) {
3048 if (volume_info->seal) {
3049 if (ses->server->vals->protocol_id == 0) {
3051 "SMB3 or later required for encryption\n");
3054 } else if (tcon->ses->server->capabilities &
3055 SMB2_GLOBAL_CAP_ENCRYPTION)
3058 cifs_dbg(VFS, "Encryption is not supported on share\n");
3064 if (volume_info->linux_ext) {
3065 if (ses->server->posix_ext_supported) {
3066 tcon->posix_extensions = true;
3067 printk_once(KERN_WARNING
3068 "SMB3.11 POSIX Extensions are experimental\n");
3070 cifs_dbg(VFS, "Server does not support mounting with posix SMB3.11 extensions.\n");
3077 * BB Do we need to wrap session_mutex around this TCon call and Unix
3078 * SetFS as we do on SessSetup and reconnect?
3081 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
3082 volume_info->local_nls);
3084 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
3088 if (volume_info->nodfs) {
3089 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
3090 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
3092 tcon->use_persistent = false;
3093 /* check if SMB2 or later, CIFS does not support persistent handles */
3094 if (volume_info->persistent) {
3095 if (ses->server->vals->protocol_id == 0) {
3097 "SMB3 or later required for persistent handles\n");
3100 } else if (ses->server->capabilities &
3101 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
3102 tcon->use_persistent = true;
3103 else /* persistent handles requested but not supported */ {
3105 "Persistent handles not supported on share\n");
3109 } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
3110 && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
3111 && (volume_info->nopersistent == false)) {
3112 cifs_dbg(FYI, "enabling persistent handles\n");
3113 tcon->use_persistent = true;
3114 } else if (volume_info->resilient) {
3115 if (ses->server->vals->protocol_id == 0) {
3117 "SMB2.1 or later required for resilient handles\n");
3121 tcon->use_resilient = true;
3125 * We can have only one retry value for a connection to a share so for
3126 * resources mounted more than once to the same server share the last
3127 * value passed in for the retry flag is used.
3129 tcon->retry = volume_info->retry;
3130 tcon->nocase = volume_info->nocase;
3131 tcon->nohandlecache = volume_info->nohandlecache;
3132 tcon->local_lease = volume_info->local_lease;
3133 INIT_LIST_HEAD(&tcon->pending_opens);
3135 spin_lock(&cifs_tcp_ses_lock);
3136 list_add(&tcon->tcon_list, &ses->tcon_list);
3137 spin_unlock(&cifs_tcp_ses_lock);
3139 cifs_fscache_get_super_cookie(tcon);
3149 cifs_put_tlink(struct tcon_link *tlink)
3151 if (!tlink || IS_ERR(tlink))
3154 if (!atomic_dec_and_test(&tlink->tl_count) ||
3155 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
3156 tlink->tl_time = jiffies;
3160 if (!IS_ERR(tlink_tcon(tlink)))
3161 cifs_put_tcon(tlink_tcon(tlink));
3167 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
3169 struct cifs_sb_info *old = CIFS_SB(sb);
3170 struct cifs_sb_info *new = mnt_data->cifs_sb;
3172 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
3175 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
3176 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
3180 * We want to share sb only if we don't specify an r/wsize or
3181 * specified r/wsize is greater than or equal to existing one.
3183 if (new->wsize && new->wsize < old->wsize)
3186 if (new->rsize && new->rsize < old->rsize)
3189 if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
3192 if (old->mnt_file_mode != new->mnt_file_mode ||
3193 old->mnt_dir_mode != new->mnt_dir_mode)
3196 if (strcmp(old->local_nls->charset, new->local_nls->charset))
3199 if (old->actimeo != new->actimeo)
3206 match_prepath(struct super_block *sb, struct cifs_mnt_data *mnt_data)
3208 struct cifs_sb_info *old = CIFS_SB(sb);
3209 struct cifs_sb_info *new = mnt_data->cifs_sb;
3210 bool old_set = old->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH;
3211 bool new_set = new->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH;
3213 if (old_set && new_set && !strcmp(new->prepath, old->prepath))
3215 else if (!old_set && !new_set)
3222 cifs_match_super(struct super_block *sb, void *data)
3224 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
3225 struct smb_vol *volume_info;
3226 struct cifs_sb_info *cifs_sb;
3227 struct TCP_Server_Info *tcp_srv;
3228 struct cifs_ses *ses;
3229 struct cifs_tcon *tcon;
3230 struct tcon_link *tlink;
3233 spin_lock(&cifs_tcp_ses_lock);
3234 cifs_sb = CIFS_SB(sb);
3235 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3236 if (IS_ERR(tlink)) {
3237 spin_unlock(&cifs_tcp_ses_lock);
3240 tcon = tlink_tcon(tlink);
3242 tcp_srv = ses->server;
3244 volume_info = mnt_data->vol;
3246 if (!match_server(tcp_srv, volume_info) ||
3247 !match_session(ses, volume_info) ||
3248 !match_tcon(tcon, volume_info) ||
3249 !match_prepath(sb, mnt_data)) {
3254 rc = compare_mount_options(sb, mnt_data);
3256 spin_unlock(&cifs_tcp_ses_lock);
3257 cifs_put_tlink(tlink);
3262 get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
3263 const struct nls_table *nls_codepage, unsigned int *num_referrals,
3264 struct dfs_info3_param **referrals, int remap)
3268 if (!ses->server->ops->get_dfs_refer)
3274 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
3275 referrals, num_referrals,
3276 nls_codepage, remap);
3280 #ifdef CONFIG_DEBUG_LOCK_ALLOC
3281 static struct lock_class_key cifs_key[2];
3282 static struct lock_class_key cifs_slock_key[2];
3285 cifs_reclassify_socket4(struct socket *sock)
3287 struct sock *sk = sock->sk;
3288 BUG_ON(!sock_allow_reclassification(sk));
3289 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
3290 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
3294 cifs_reclassify_socket6(struct socket *sock)
3296 struct sock *sk = sock->sk;
3297 BUG_ON(!sock_allow_reclassification(sk));
3298 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
3299 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
3303 cifs_reclassify_socket4(struct socket *sock)
3308 cifs_reclassify_socket6(struct socket *sock)
3313 /* See RFC1001 section 14 on representation of Netbios names */
3314 static void rfc1002mangle(char *target, char *source, unsigned int length)
3318 for (i = 0, j = 0; i < (length); i++) {
3319 /* mask a nibble at a time and encode */
3320 target[j] = 'A' + (0x0F & (source[i] >> 4));
3321 target[j+1] = 'A' + (0x0F & source[i]);
3328 bind_socket(struct TCP_Server_Info *server)
3331 if (server->srcaddr.ss_family != AF_UNSPEC) {
3332 /* Bind to the specified local IP address */
3333 struct socket *socket = server->ssocket;
3334 rc = socket->ops->bind(socket,
3335 (struct sockaddr *) &server->srcaddr,
3336 sizeof(server->srcaddr));
3338 struct sockaddr_in *saddr4;
3339 struct sockaddr_in6 *saddr6;
3340 saddr4 = (struct sockaddr_in *)&server->srcaddr;
3341 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
3342 if (saddr6->sin6_family == AF_INET6)
3343 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
3344 &saddr6->sin6_addr, rc);
3346 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
3347 &saddr4->sin_addr.s_addr, rc);
3354 ip_rfc1001_connect(struct TCP_Server_Info *server)
3358 * some servers require RFC1001 sessinit before sending
3359 * negprot - BB check reconnection in case where second
3360 * sessinit is sent but no second negprot
3362 struct rfc1002_session_packet *ses_init_buf;
3363 struct smb_hdr *smb_buf;
3364 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
3367 ses_init_buf->trailer.session_req.called_len = 32;
3369 if (server->server_RFC1001_name[0] != 0)
3370 rfc1002mangle(ses_init_buf->trailer.
3371 session_req.called_name,
3372 server->server_RFC1001_name,
3373 RFC1001_NAME_LEN_WITH_NULL);
3375 rfc1002mangle(ses_init_buf->trailer.
3376 session_req.called_name,
3377 DEFAULT_CIFS_CALLED_NAME,
3378 RFC1001_NAME_LEN_WITH_NULL);
3380 ses_init_buf->trailer.session_req.calling_len = 32;
3383 * calling name ends in null (byte 16) from old smb
3386 if (server->workstation_RFC1001_name[0] != 0)
3387 rfc1002mangle(ses_init_buf->trailer.
3388 session_req.calling_name,
3389 server->workstation_RFC1001_name,
3390 RFC1001_NAME_LEN_WITH_NULL);
3392 rfc1002mangle(ses_init_buf->trailer.
3393 session_req.calling_name,
3395 RFC1001_NAME_LEN_WITH_NULL);
3397 ses_init_buf->trailer.session_req.scope1 = 0;
3398 ses_init_buf->trailer.session_req.scope2 = 0;
3399 smb_buf = (struct smb_hdr *)ses_init_buf;
3401 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3402 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3403 rc = smb_send(server, smb_buf, 0x44);
3404 kfree(ses_init_buf);
3406 * RFC1001 layer in at least one server
3407 * requires very short break before negprot
3408 * presumably because not expecting negprot
3409 * to follow so fast. This is a simple
3410 * solution that works without
3411 * complicating the code and causes no
3412 * significant slowing down on mount
3415 usleep_range(1000, 2000);
3418 * else the negprot may still work without this
3419 * even though malloc failed
3426 generic_ip_connect(struct TCP_Server_Info *server)
3431 struct socket *socket = server->ssocket;
3432 struct sockaddr *saddr;
3434 saddr = (struct sockaddr *) &server->dstaddr;
3436 if (server->dstaddr.ss_family == AF_INET6) {
3437 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3438 slen = sizeof(struct sockaddr_in6);
3441 sport = ((struct sockaddr_in *) saddr)->sin_port;
3442 slen = sizeof(struct sockaddr_in);
3446 if (socket == NULL) {
3447 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3448 IPPROTO_TCP, &socket, 1);
3450 cifs_dbg(VFS, "Error %d creating socket\n", rc);
3451 server->ssocket = NULL;
3455 /* BB other socket options to set KEEPALIVE, NODELAY? */
3456 cifs_dbg(FYI, "Socket created\n");
3457 server->ssocket = socket;
3458 socket->sk->sk_allocation = GFP_NOFS;
3459 if (sfamily == AF_INET6)
3460 cifs_reclassify_socket6(socket);
3462 cifs_reclassify_socket4(socket);
3465 rc = bind_socket(server);
3470 * Eventually check for other socket options to change from
3471 * the default. sock_setsockopt not used because it expects
3474 socket->sk->sk_rcvtimeo = 7 * HZ;
3475 socket->sk->sk_sndtimeo = 5 * HZ;
3477 /* make the bufsizes depend on wsize/rsize and max requests */
3478 if (server->noautotune) {
3479 if (socket->sk->sk_sndbuf < (200 * 1024))
3480 socket->sk->sk_sndbuf = 200 * 1024;
3481 if (socket->sk->sk_rcvbuf < (140 * 1024))
3482 socket->sk->sk_rcvbuf = 140 * 1024;
3485 if (server->tcp_nodelay) {
3487 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3488 (char *)&val, sizeof(val));
3490 cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3494 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3495 socket->sk->sk_sndbuf,
3496 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3498 rc = socket->ops->connect(socket, saddr, slen, 0);
3500 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3501 sock_release(socket);
3502 server->ssocket = NULL;
3506 if (sport == htons(RFC1001_PORT))
3507 rc = ip_rfc1001_connect(server);
3513 ip_connect(struct TCP_Server_Info *server)
3516 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3517 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3519 if (server->dstaddr.ss_family == AF_INET6)
3520 sport = &addr6->sin6_port;
3522 sport = &addr->sin_port;
3527 /* try with 445 port at first */
3528 *sport = htons(CIFS_PORT);
3530 rc = generic_ip_connect(server);
3534 /* if it failed, try with 139 port */
3535 *sport = htons(RFC1001_PORT);
3538 return generic_ip_connect(server);
3541 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3542 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3544 /* if we are reconnecting then should we check to see if
3545 * any requested capabilities changed locally e.g. via
3546 * remount but we can not do much about it here
3547 * if they have (even if we could detect it by the following)
3548 * Perhaps we could add a backpointer to array of sb from tcon
3549 * or if we change to make all sb to same share the same
3550 * sb as NFS - then we only have one backpointer to sb.
3551 * What if we wanted to mount the server share twice once with
3552 * and once without posixacls or posix paths? */
3553 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3555 if (vol_info && vol_info->no_linux_ext) {
3556 tcon->fsUnixInfo.Capability = 0;
3557 tcon->unix_ext = 0; /* Unix Extensions disabled */
3558 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
3560 } else if (vol_info)
3561 tcon->unix_ext = 1; /* Unix Extensions supported */
3563 if (tcon->unix_ext == 0) {
3564 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
3568 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3569 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3570 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
3571 /* check for reconnect case in which we do not
3572 want to change the mount behavior if we can avoid it */
3573 if (vol_info == NULL) {
3574 /* turn off POSIX ACL and PATHNAMES if not set
3575 originally at mount time */
3576 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3577 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3578 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3579 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3580 cifs_dbg(VFS, "POSIXPATH support change\n");
3581 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3582 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3583 cifs_dbg(VFS, "possible reconnect error\n");
3584 cifs_dbg(VFS, "server disabled POSIX path support\n");
3588 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3589 cifs_dbg(VFS, "per-share encryption not supported yet\n");
3591 cap &= CIFS_UNIX_CAP_MASK;
3592 if (vol_info && vol_info->no_psx_acl)
3593 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3594 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3595 cifs_dbg(FYI, "negotiated posix acl support\n");
3597 cifs_sb->mnt_cifs_flags |=
3598 CIFS_MOUNT_POSIXACL;
3601 if (vol_info && vol_info->posix_paths == 0)
3602 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3603 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3604 cifs_dbg(FYI, "negotiate posix pathnames\n");
3606 cifs_sb->mnt_cifs_flags |=
3607 CIFS_MOUNT_POSIX_PATHS;
3610 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
3611 #ifdef CONFIG_CIFS_DEBUG2
3612 if (cap & CIFS_UNIX_FCNTL_CAP)
3613 cifs_dbg(FYI, "FCNTL cap\n");
3614 if (cap & CIFS_UNIX_EXTATTR_CAP)
3615 cifs_dbg(FYI, "EXTATTR cap\n");
3616 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3617 cifs_dbg(FYI, "POSIX path cap\n");
3618 if (cap & CIFS_UNIX_XATTR_CAP)
3619 cifs_dbg(FYI, "XATTR cap\n");
3620 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3621 cifs_dbg(FYI, "POSIX ACL cap\n");
3622 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3623 cifs_dbg(FYI, "very large read cap\n");
3624 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3625 cifs_dbg(FYI, "very large write cap\n");
3626 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3627 cifs_dbg(FYI, "transport encryption cap\n");
3628 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3629 cifs_dbg(FYI, "mandatory transport encryption cap\n");
3630 #endif /* CIFS_DEBUG2 */
3631 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3632 if (vol_info == NULL) {
3633 cifs_dbg(FYI, "resetting capabilities failed\n");
3635 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");
3641 int cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3642 struct cifs_sb_info *cifs_sb)
3644 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3646 spin_lock_init(&cifs_sb->tlink_tree_lock);
3647 cifs_sb->tlink_tree = RB_ROOT;
3650 * Temporarily set r/wsize for matching superblock. If we end up using
3651 * new sb then client will later negotiate it downward if needed.
3653 cifs_sb->rsize = pvolume_info->rsize;
3654 cifs_sb->wsize = pvolume_info->wsize;
3656 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3657 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3658 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3659 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3660 cifs_dbg(FYI, "file mode: 0x%hx dir mode: 0x%hx\n",
3661 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3663 cifs_sb->actimeo = pvolume_info->actimeo;
3664 cifs_sb->local_nls = pvolume_info->local_nls;
3666 if (pvolume_info->noperm)
3667 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3668 if (pvolume_info->setuids)
3669 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3670 if (pvolume_info->setuidfromacl)
3671 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
3672 if (pvolume_info->server_ino)
3673 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3674 if (pvolume_info->remap)
3675 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3676 if (pvolume_info->sfu_remap)
3677 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3678 if (pvolume_info->no_xattr)
3679 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3680 if (pvolume_info->sfu_emul)
3681 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3682 if (pvolume_info->nobrl)
3683 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3684 if (pvolume_info->nohandlecache)
3685 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_HANDLE_CACHE;
3686 if (pvolume_info->nostrictsync)
3687 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3688 if (pvolume_info->mand_lock)
3689 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3690 if (pvolume_info->rwpidforward)
3691 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3692 if (pvolume_info->cifs_acl)
3693 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3694 if (pvolume_info->backupuid_specified) {
3695 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3696 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3698 if (pvolume_info->backupgid_specified) {
3699 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3700 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3702 if (pvolume_info->override_uid)
3703 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3704 if (pvolume_info->override_gid)
3705 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3706 if (pvolume_info->dynperm)
3707 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3708 if (pvolume_info->fsc)
3709 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3710 if (pvolume_info->multiuser)
3711 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3712 CIFS_MOUNT_NO_PERM);
3713 if (pvolume_info->strict_io)
3714 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3715 if (pvolume_info->direct_io) {
3716 cifs_dbg(FYI, "mounting share using direct i/o\n");
3717 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3719 if (pvolume_info->mfsymlinks) {
3720 if (pvolume_info->sfu_emul) {
3722 * Our SFU ("Services for Unix" emulation does not allow
3723 * creating symlinks but does allow reading existing SFU
3724 * symlinks (it does allow both creating and reading SFU
3725 * style mknod and FIFOs though). When "mfsymlinks" and
3726 * "sfu" are both enabled at the same time, it allows
3727 * reading both types of symlinks, but will only create
3728 * them with mfsymlinks format. This allows better
3729 * Apple compatibility (probably better for Samba too)
3730 * while still recognizing old Windows style symlinks.
3732 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
3734 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3737 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3738 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
3740 if (pvolume_info->prepath) {
3741 cifs_sb->prepath = kstrdup(pvolume_info->prepath, GFP_KERNEL);
3742 if (cifs_sb->prepath == NULL)
3750 cleanup_volume_info_contents(struct smb_vol *volume_info)
3752 kfree(volume_info->username);
3753 kzfree(volume_info->password);
3754 kfree(volume_info->UNC);
3755 kfree(volume_info->domainname);
3756 kfree(volume_info->iocharset);
3757 kfree(volume_info->prepath);
3761 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3765 cleanup_volume_info_contents(volume_info);
3770 #ifdef CONFIG_CIFS_DFS_UPCALL
3772 * cifs_build_path_to_root returns full path to root when we do not have an
3773 * exiting connection (tcon)
3776 build_unc_path_to_root(const struct smb_vol *vol,
3777 const struct cifs_sb_info *cifs_sb)
3779 char *full_path, *pos;
3780 unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
3781 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3783 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3784 if (full_path == NULL)
3785 return ERR_PTR(-ENOMEM);
3787 strncpy(full_path, vol->UNC, unc_len);
3788 pos = full_path + unc_len;
3791 *pos = CIFS_DIR_SEP(cifs_sb);
3792 strncpy(pos + 1, vol->prepath, pplen);
3796 *pos = '\0'; /* add trailing null */
3797 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3798 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
3803 * Perform a dfs referral query for a share and (optionally) prefix
3805 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3806 * to a string containing updated options for the submount. Otherwise it
3807 * will be left untouched.
3809 * Returns the rc from get_dfs_path to the caller, which can be used to
3810 * determine whether there were referrals.
3813 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
3814 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3818 unsigned int num_referrals = 0;
3819 struct dfs_info3_param *referrals = NULL;
3820 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3822 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3823 if (IS_ERR(full_path))
3824 return PTR_ERR(full_path);
3826 /* For DFS paths, skip the first '\' of the UNC */
3827 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3829 rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
3830 &num_referrals, &referrals, cifs_remap(cifs_sb));
3832 if (!rc && num_referrals > 0) {
3833 char *fake_devname = NULL;
3835 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3836 full_path + 1, referrals,
3839 free_dfs_info_array(referrals, num_referrals);
3841 if (IS_ERR(mdata)) {
3842 rc = PTR_ERR(mdata);
3845 cleanup_volume_info_contents(volume_info);
3846 rc = cifs_setup_volume_info(volume_info, mdata,
3847 fake_devname, false);
3849 kfree(fake_devname);
3850 kfree(cifs_sb->mountdata);
3851 cifs_sb->mountdata = mdata;
3859 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3860 const char *devname, bool is_smb3)
3864 if (cifs_parse_mount_options(mount_data, devname, volume_info, is_smb3))
3867 if (volume_info->nullauth) {
3868 cifs_dbg(FYI, "Anonymous login\n");
3869 kfree(volume_info->username);
3870 volume_info->username = NULL;
3871 } else if (volume_info->username) {
3872 /* BB fixme parse for domain name here */
3873 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
3875 cifs_dbg(VFS, "No username specified\n");
3876 /* In userspace mount helper we can get user name from alternate
3877 locations such as env variables and files on disk */
3881 /* this is needed for ASCII cp to Unicode converts */
3882 if (volume_info->iocharset == NULL) {
3883 /* load_nls_default cannot return null */
3884 volume_info->local_nls = load_nls_default();
3886 volume_info->local_nls = load_nls(volume_info->iocharset);
3887 if (volume_info->local_nls == NULL) {
3888 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
3889 volume_info->iocharset);
3898 cifs_get_volume_info(char *mount_data, const char *devname, bool is_smb3)
3901 struct smb_vol *volume_info;
3903 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
3905 return ERR_PTR(-ENOMEM);
3907 rc = cifs_setup_volume_info(volume_info, mount_data, devname, is_smb3);
3909 cifs_cleanup_volume_info(volume_info);
3910 volume_info = ERR_PTR(rc);
3917 cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
3919 struct cifs_tcon *tcon,
3920 struct cifs_sb_info *cifs_sb,
3927 sep = CIFS_DIR_SEP(cifs_sb);
3930 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
3932 /* skip separators */
3937 /* next separator */
3938 while (*s && *s != sep)
3942 * temporarily null-terminate the path at the end of
3943 * the current component
3947 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3955 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3959 struct cifs_ses *ses;
3960 struct cifs_tcon *tcon;
3961 struct TCP_Server_Info *server;
3963 struct tcon_link *tlink;
3964 #ifdef CONFIG_CIFS_DFS_UPCALL
3965 int referral_walks_count = 0;
3968 #ifdef CONFIG_CIFS_DFS_UPCALL
3970 /* cleanup activities if we're chasing a referral */
3971 if (referral_walks_count) {
3973 cifs_put_tcon(tcon);
3975 cifs_put_smb_ses(ses);
3977 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
3991 /* get a reference to a tcp session */
3992 server = cifs_get_tcp_session(volume_info);
3993 if (IS_ERR(server)) {
3994 rc = PTR_ERR(server);
3997 if ((volume_info->max_credits < 20) ||
3998 (volume_info->max_credits > 60000))
3999 server->max_credits = SMB2_MAX_CREDITS_AVAILABLE;
4001 server->max_credits = volume_info->max_credits;
4002 /* get a reference to a SMB session */
4003 ses = cifs_get_smb_ses(server, volume_info);
4007 goto mount_fail_check;
4010 if ((volume_info->persistent == true) && ((ses->server->capabilities &
4011 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES) == 0)) {
4012 cifs_dbg(VFS, "persistent handles not supported by server\n");
4014 goto mount_fail_check;
4017 /* search for existing tcon to this server share */
4018 tcon = cifs_get_tcon(ses, volume_info);
4023 goto mount_fail_check;
4025 goto remote_path_check;
4028 /* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
4029 if (tcon->posix_extensions)
4030 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_POSIX_PATHS;
4032 /* tell server which Unix caps we support */
4033 if (cap_unix(tcon->ses)) {
4034 /* reset of caps checks mount to see if unix extensions
4035 disabled for just this mount */
4036 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
4037 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
4038 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
4039 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
4041 goto mount_fail_check;
4044 tcon->unix_ext = 0; /* server does not support them */
4046 /* do not care if a following call succeed - informational */
4047 if (!tcon->pipe && server->ops->qfs_tcon)
4048 server->ops->qfs_tcon(xid, tcon);
4050 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
4051 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
4054 #ifdef CONFIG_CIFS_DFS_UPCALL
4056 * Perform an unconditional check for whether there are DFS
4057 * referrals for this path without prefix, to provide support
4058 * for DFS referrals from w2k8 servers which don't seem to respond
4059 * with PATH_NOT_COVERED to requests that include the prefix.
4060 * Chase the referral if found, otherwise continue normally.
4062 if (referral_walks_count == 0) {
4063 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
4066 referral_walks_count++;
4067 goto try_mount_again;
4072 /* check if a whole path is not remote */
4074 if (!server->ops->is_path_accessible) {
4076 goto mount_fail_check;
4079 * cifs_build_path_to_root works only when we have a valid tcon
4081 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon,
4082 tcon->Flags & SMB_SHARE_IS_IN_DFS);
4083 if (full_path == NULL) {
4085 goto mount_fail_check;
4087 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
4089 if (rc != 0 && rc != -EREMOTE) {
4091 goto mount_fail_check;
4094 if (rc != -EREMOTE) {
4095 rc = cifs_are_all_path_components_accessible(server,
4099 cifs_dbg(VFS, "cannot query dirs between root and final path, "
4100 "enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
4101 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
4108 /* get referral if needed */
4109 if (rc == -EREMOTE) {
4110 #ifdef CONFIG_CIFS_DFS_UPCALL
4111 if (referral_walks_count > MAX_NESTED_LINKS) {
4113 * BB: when we implement proper loop detection,
4114 * we will remove this check. But now we need it
4115 * to prevent an indefinite loop if 'DFS tree' is
4116 * misconfigured (i.e. has loops).
4119 goto mount_fail_check;
4122 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
4125 referral_walks_count++;
4126 goto try_mount_again;
4128 goto mount_fail_check;
4129 #else /* No DFS support, return error on mount */
4135 goto mount_fail_check;
4137 /* now, hang the tcon off of the superblock */
4138 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
4139 if (tlink == NULL) {
4141 goto mount_fail_check;
4144 tlink->tl_uid = ses->linux_uid;
4145 tlink->tl_tcon = tcon;
4146 tlink->tl_time = jiffies;
4147 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
4148 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4150 cifs_sb->master_tlink = tlink;
4151 spin_lock(&cifs_sb->tlink_tree_lock);
4152 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4153 spin_unlock(&cifs_sb->tlink_tree_lock);
4155 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4159 /* on error free sesinfo and tcon struct if needed */
4161 /* If find_unc succeeded then rc == 0 so we can not end */
4162 /* up accidentally freeing someone elses tcon struct */
4164 cifs_put_tcon(tcon);
4166 cifs_put_smb_ses(ses);
4168 cifs_put_tcp_session(server, 0);
4177 * Issue a TREE_CONNECT request.
4180 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
4181 const char *tree, struct cifs_tcon *tcon,
4182 const struct nls_table *nls_codepage)
4184 struct smb_hdr *smb_buffer;
4185 struct smb_hdr *smb_buffer_response;
4188 unsigned char *bcc_ptr;
4191 __u16 bytes_left, count;
4196 smb_buffer = cifs_buf_get();
4197 if (smb_buffer == NULL)
4200 smb_buffer_response = smb_buffer;
4202 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
4203 NULL /*no tid */ , 4 /*wct */ );
4205 smb_buffer->Mid = get_next_mid(ses->server);
4206 smb_buffer->Uid = ses->Suid;
4207 pSMB = (TCONX_REQ *) smb_buffer;
4208 pSMBr = (TCONX_RSP *) smb_buffer_response;
4210 pSMB->AndXCommand = 0xFF;
4211 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
4212 bcc_ptr = &pSMB->Password[0];
4213 if (tcon->pipe || (ses->server->sec_mode & SECMODE_USER)) {
4214 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
4215 *bcc_ptr = 0; /* password is null byte */
4216 bcc_ptr++; /* skip password */
4217 /* already aligned so no need to do it below */
4219 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
4220 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
4221 specified as required (when that support is added to
4222 the vfs in the future) as only NTLM or the much
4223 weaker LANMAN (which we do not send by default) is accepted
4224 by Samba (not sure whether other servers allow
4225 NTLMv2 password here) */
4226 #ifdef CONFIG_CIFS_WEAK_PW_HASH
4227 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
4228 (ses->sectype == LANMAN))
4229 calc_lanman_hash(tcon->password, ses->server->cryptkey,
4230 ses->server->sec_mode &
4231 SECMODE_PW_ENCRYPT ? true : false,
4234 #endif /* CIFS_WEAK_PW_HASH */
4235 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
4236 bcc_ptr, nls_codepage);
4238 cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
4240 cifs_buf_release(smb_buffer);
4244 bcc_ptr += CIFS_AUTH_RESP_SIZE;
4245 if (ses->capabilities & CAP_UNICODE) {
4246 /* must align unicode strings */
4247 *bcc_ptr = 0; /* null byte password */
4252 if (ses->server->sign)
4253 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
4255 if (ses->capabilities & CAP_STATUS32) {
4256 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
4258 if (ses->capabilities & CAP_DFS) {
4259 smb_buffer->Flags2 |= SMBFLG2_DFS;
4261 if (ses->capabilities & CAP_UNICODE) {
4262 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
4264 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
4265 6 /* max utf8 char length in bytes */ *
4266 (/* server len*/ + 256 /* share len */), nls_codepage);
4267 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
4268 bcc_ptr += 2; /* skip trailing null */
4269 } else { /* ASCII */
4270 strcpy(bcc_ptr, tree);
4271 bcc_ptr += strlen(tree) + 1;
4273 strcpy(bcc_ptr, "?????");
4274 bcc_ptr += strlen("?????");
4276 count = bcc_ptr - &pSMB->Password[0];
4277 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
4278 pSMB->hdr.smb_buf_length) + count);
4279 pSMB->ByteCount = cpu_to_le16(count);
4281 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
4284 /* above now done in SendReceive */
4288 tcon->tidStatus = CifsGood;
4289 tcon->need_reconnect = false;
4290 tcon->tid = smb_buffer_response->Tid;
4291 bcc_ptr = pByteArea(smb_buffer_response);
4292 bytes_left = get_bcc(smb_buffer_response);
4293 length = strnlen(bcc_ptr, bytes_left - 2);
4294 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
4300 /* skip service field (NB: this field is always ASCII) */
4302 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
4303 (bcc_ptr[2] == 'C')) {
4304 cifs_dbg(FYI, "IPC connection\n");
4308 } else if (length == 2) {
4309 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
4310 /* the most common case */
4311 cifs_dbg(FYI, "disk share connection\n");
4314 bcc_ptr += length + 1;
4315 bytes_left -= (length + 1);
4316 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
4318 /* mostly informational -- no need to fail on error here */
4319 kfree(tcon->nativeFileSystem);
4320 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
4321 bytes_left, is_unicode,
4324 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
4326 if ((smb_buffer_response->WordCount == 3) ||
4327 (smb_buffer_response->WordCount == 7))
4328 /* field is in same location */
4329 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
4332 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
4335 cifs_buf_release(smb_buffer);
4339 static void delayed_free(struct rcu_head *p)
4341 struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
4342 unload_nls(sbi->local_nls);
4347 cifs_umount(struct cifs_sb_info *cifs_sb)
4349 struct rb_root *root = &cifs_sb->tlink_tree;
4350 struct rb_node *node;
4351 struct tcon_link *tlink;
4353 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
4355 spin_lock(&cifs_sb->tlink_tree_lock);
4356 while ((node = rb_first(root))) {
4357 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4358 cifs_get_tlink(tlink);
4359 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4360 rb_erase(node, root);
4362 spin_unlock(&cifs_sb->tlink_tree_lock);
4363 cifs_put_tlink(tlink);
4364 spin_lock(&cifs_sb->tlink_tree_lock);
4366 spin_unlock(&cifs_sb->tlink_tree_lock);
4368 kfree(cifs_sb->mountdata);
4369 kfree(cifs_sb->prepath);
4370 call_rcu(&cifs_sb->rcu, delayed_free);
4374 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
4377 struct TCP_Server_Info *server = ses->server;
4379 if (!server->ops->need_neg || !server->ops->negotiate)
4382 /* only send once per connect */
4383 if (!server->ops->need_neg(server))
4386 set_credits(server, 1);
4388 rc = server->ops->negotiate(xid, ses);
4390 spin_lock(&GlobalMid_Lock);
4391 if (server->tcpStatus == CifsNeedNegotiate)
4392 server->tcpStatus = CifsGood;
4395 spin_unlock(&GlobalMid_Lock);
4402 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
4403 struct nls_table *nls_info)
4406 struct TCP_Server_Info *server = ses->server;
4408 ses->capabilities = server->capabilities;
4409 if (linuxExtEnabled == 0)
4410 ses->capabilities &= (~server->vals->cap_unix);
4412 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
4413 server->sec_mode, server->capabilities, server->timeAdj);
4415 if (ses->auth_key.response) {
4416 cifs_dbg(FYI, "Free previous auth_key.response = %p\n",
4417 ses->auth_key.response);
4418 kfree(ses->auth_key.response);
4419 ses->auth_key.response = NULL;
4420 ses->auth_key.len = 0;
4423 if (server->ops->sess_setup)
4424 rc = server->ops->sess_setup(xid, ses, nls_info);
4427 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
4433 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
4435 vol->sectype = ses->sectype;
4437 /* krb5 is special, since we don't need username or pw */
4438 if (vol->sectype == Kerberos)
4441 return cifs_set_cifscreds(vol, ses);
4444 static struct cifs_tcon *
4445 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
4448 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4449 struct cifs_ses *ses;
4450 struct cifs_tcon *tcon = NULL;
4451 struct smb_vol *vol_info;
4453 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
4454 if (vol_info == NULL)
4455 return ERR_PTR(-ENOMEM);
4457 vol_info->local_nls = cifs_sb->local_nls;
4458 vol_info->linux_uid = fsuid;
4459 vol_info->cred_uid = fsuid;
4460 vol_info->UNC = master_tcon->treeName;
4461 vol_info->retry = master_tcon->retry;
4462 vol_info->nocase = master_tcon->nocase;
4463 vol_info->nohandlecache = master_tcon->nohandlecache;
4464 vol_info->local_lease = master_tcon->local_lease;
4465 vol_info->no_linux_ext = !master_tcon->unix_ext;
4466 vol_info->sectype = master_tcon->ses->sectype;
4467 vol_info->sign = master_tcon->ses->sign;
4469 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4475 /* get a reference for the same TCP session */
4476 spin_lock(&cifs_tcp_ses_lock);
4477 ++master_tcon->ses->server->srv_count;
4478 spin_unlock(&cifs_tcp_ses_lock);
4480 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4482 tcon = (struct cifs_tcon *)ses;
4483 cifs_put_tcp_session(master_tcon->ses->server, 0);
4487 tcon = cifs_get_tcon(ses, vol_info);
4489 cifs_put_smb_ses(ses);
4493 /* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
4494 if (tcon->posix_extensions)
4495 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_POSIX_PATHS;
4498 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4501 kfree(vol_info->username);
4502 kzfree(vol_info->password);
4509 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4511 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4514 /* find and return a tlink with given uid */
4515 static struct tcon_link *
4516 tlink_rb_search(struct rb_root *root, kuid_t uid)
4518 struct rb_node *node = root->rb_node;
4519 struct tcon_link *tlink;
4522 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4524 if (uid_gt(tlink->tl_uid, uid))
4525 node = node->rb_left;
4526 else if (uid_lt(tlink->tl_uid, uid))
4527 node = node->rb_right;
4534 /* insert a tcon_link into the tree */
4536 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4538 struct rb_node **new = &(root->rb_node), *parent = NULL;
4539 struct tcon_link *tlink;
4542 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4545 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
4546 new = &((*new)->rb_left);
4548 new = &((*new)->rb_right);
4551 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4552 rb_insert_color(&new_tlink->tl_rbnode, root);
4556 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4559 * If the superblock doesn't refer to a multiuser mount, then just return
4560 * the master tcon for the mount.
4562 * First, search the rbtree for an existing tcon for this fsuid. If one
4563 * exists, then check to see if it's pending construction. If it is then wait
4564 * for construction to complete. Once it's no longer pending, check to see if
4565 * it failed and either return an error or retry construction, depending on
4568 * If one doesn't exist then insert a new tcon_link struct into the tree and
4569 * try to construct a new one.
4572 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4575 kuid_t fsuid = current_fsuid();
4576 struct tcon_link *tlink, *newtlink;
4578 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4579 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4581 spin_lock(&cifs_sb->tlink_tree_lock);
4582 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4584 cifs_get_tlink(tlink);
4585 spin_unlock(&cifs_sb->tlink_tree_lock);
4587 if (tlink == NULL) {
4588 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4589 if (newtlink == NULL)
4590 return ERR_PTR(-ENOMEM);
4591 newtlink->tl_uid = fsuid;
4592 newtlink->tl_tcon = ERR_PTR(-EACCES);
4593 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4594 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4595 cifs_get_tlink(newtlink);
4597 spin_lock(&cifs_sb->tlink_tree_lock);
4598 /* was one inserted after previous search? */
4599 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4601 cifs_get_tlink(tlink);
4602 spin_unlock(&cifs_sb->tlink_tree_lock);
4604 goto wait_for_construction;
4607 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4608 spin_unlock(&cifs_sb->tlink_tree_lock);
4610 wait_for_construction:
4611 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4612 TASK_INTERRUPTIBLE);
4614 cifs_put_tlink(tlink);
4615 return ERR_PTR(-ERESTARTSYS);
4618 /* if it's good, return it */
4619 if (!IS_ERR(tlink->tl_tcon))
4622 /* return error if we tried this already recently */
4623 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4624 cifs_put_tlink(tlink);
4625 return ERR_PTR(-EACCES);
4628 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4629 goto wait_for_construction;
4632 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4633 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4634 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4636 if (IS_ERR(tlink->tl_tcon)) {
4637 cifs_put_tlink(tlink);
4638 return ERR_PTR(-EACCES);
4645 * periodic workqueue job that scans tcon_tree for a superblock and closes
4649 cifs_prune_tlinks(struct work_struct *work)
4651 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4653 struct rb_root *root = &cifs_sb->tlink_tree;
4654 struct rb_node *node;
4655 struct rb_node *tmp;
4656 struct tcon_link *tlink;
4659 * Because we drop the spinlock in the loop in order to put the tlink
4660 * it's not guarded against removal of links from the tree. The only
4661 * places that remove entries from the tree are this function and
4662 * umounts. Because this function is non-reentrant and is canceled
4663 * before umount can proceed, this is safe.
4665 spin_lock(&cifs_sb->tlink_tree_lock);
4666 node = rb_first(root);
4667 while (node != NULL) {
4669 node = rb_next(tmp);
4670 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4672 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4673 atomic_read(&tlink->tl_count) != 0 ||
4674 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4677 cifs_get_tlink(tlink);
4678 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4679 rb_erase(tmp, root);
4681 spin_unlock(&cifs_sb->tlink_tree_lock);
4682 cifs_put_tlink(tlink);
4683 spin_lock(&cifs_sb->tlink_tree_lock);
4685 spin_unlock(&cifs_sb->tlink_tree_lock);
4687 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,