4 * Copyright (C) International Business Machines Corp., 2002,2011
5 * Author(s): Steve French (sfrench@us.ibm.com)
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/net.h>
23 #include <linux/string.h>
24 #include <linux/list.h>
25 #include <linux/wait.h>
26 #include <linux/slab.h>
27 #include <linux/pagemap.h>
28 #include <linux/ctype.h>
29 #include <linux/utsname.h>
30 #include <linux/mempool.h>
31 #include <linux/delay.h>
32 #include <linux/completion.h>
33 #include <linux/kthread.h>
34 #include <linux/pagevec.h>
35 #include <linux/freezer.h>
36 #include <linux/namei.h>
37 #include <linux/uaccess.h>
38 #include <asm/processor.h>
39 #include <linux/inet.h>
40 #include <linux/module.h>
41 #include <keys/user-type.h>
43 #include <linux/parser.h>
44 #include <linux/bvec.h>
48 #include "cifsproto.h"
49 #include "cifs_unicode.h"
50 #include "cifs_debug.h"
51 #include "cifs_fs_sb.h"
54 #include "rfc1002pdu.h"
56 #ifdef CONFIG_CIFS_SMB2
57 #include "smb2proto.h"
61 #define RFC1001_PORT 139
63 extern mempool_t *cifs_req_poolp;
65 /* FIXME: should these be tunable? */
66 #define TLINK_ERROR_EXPIRE (1 * HZ)
67 #define TLINK_IDLE_EXPIRE (600 * HZ)
70 /* Mount options that take no arguments */
71 Opt_user_xattr, Opt_nouser_xattr,
72 Opt_forceuid, Opt_noforceuid,
73 Opt_forcegid, Opt_noforcegid,
74 Opt_noblocksend, Opt_noautotune,
75 Opt_hard, Opt_soft, Opt_perm, Opt_noperm,
76 Opt_mapposix, Opt_nomapposix,
77 Opt_mapchars, Opt_nomapchars, Opt_sfu,
78 Opt_nosfu, Opt_nodfs, Opt_posixpaths,
79 Opt_noposixpaths, Opt_nounix,
82 Opt_forcemandatorylock, Opt_setuidfromacl, Opt_setuids,
83 Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
84 Opt_nohard, Opt_nosoft,
86 Opt_nostrictsync, Opt_strictsync,
87 Opt_serverino, Opt_noserverino,
88 Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
89 Opt_acl, Opt_noacl, Opt_locallease,
90 Opt_sign, Opt_seal, Opt_noac,
91 Opt_fsc, Opt_mfsymlinks,
92 Opt_multiuser, Opt_sloppy, Opt_nosharesock,
93 Opt_persistent, Opt_nopersistent,
94 Opt_resilient, Opt_noresilient,
97 /* Mount options which take numeric value */
98 Opt_backupuid, Opt_backupgid, Opt_uid,
99 Opt_cruid, Opt_gid, Opt_file_mode,
100 Opt_dirmode, Opt_port,
101 Opt_rsize, Opt_wsize, Opt_actimeo,
102 Opt_echo_interval, Opt_max_credits,
105 /* Mount options which take string value */
106 Opt_user, Opt_pass, Opt_ip,
107 Opt_domain, Opt_srcaddr, Opt_iocharset,
108 Opt_netbiosname, Opt_servern,
109 Opt_ver, Opt_vers, Opt_sec, Opt_cache,
111 /* Mount options to be ignored */
114 /* Options which could be blank */
122 static const match_table_t cifs_mount_option_tokens = {
124 { Opt_user_xattr, "user_xattr" },
125 { Opt_nouser_xattr, "nouser_xattr" },
126 { Opt_forceuid, "forceuid" },
127 { Opt_noforceuid, "noforceuid" },
128 { Opt_forcegid, "forcegid" },
129 { Opt_noforcegid, "noforcegid" },
130 { Opt_noblocksend, "noblocksend" },
131 { Opt_noautotune, "noautotune" },
132 { Opt_hard, "hard" },
133 { Opt_soft, "soft" },
134 { Opt_perm, "perm" },
135 { Opt_noperm, "noperm" },
136 { Opt_mapchars, "mapchars" }, /* SFU style */
137 { Opt_nomapchars, "nomapchars" },
138 { Opt_mapposix, "mapposix" }, /* SFM style */
139 { Opt_nomapposix, "nomapposix" },
141 { Opt_nosfu, "nosfu" },
142 { Opt_nodfs, "nodfs" },
143 { Opt_posixpaths, "posixpaths" },
144 { Opt_noposixpaths, "noposixpaths" },
145 { Opt_nounix, "nounix" },
146 { Opt_nounix, "nolinux" },
147 { Opt_nocase, "nocase" },
148 { Opt_nocase, "ignorecase" },
150 { Opt_nobrl, "nobrl" },
151 { Opt_nobrl, "nolock" },
152 { Opt_forcemandatorylock, "forcemandatorylock" },
153 { Opt_forcemandatorylock, "forcemand" },
154 { Opt_setuids, "setuids" },
155 { Opt_nosetuids, "nosetuids" },
156 { Opt_setuidfromacl, "idsfromsid" },
157 { Opt_dynperm, "dynperm" },
158 { Opt_nodynperm, "nodynperm" },
159 { Opt_nohard, "nohard" },
160 { Opt_nosoft, "nosoft" },
161 { Opt_nointr, "nointr" },
162 { Opt_intr, "intr" },
163 { Opt_nostrictsync, "nostrictsync" },
164 { Opt_strictsync, "strictsync" },
165 { Opt_serverino, "serverino" },
166 { Opt_noserverino, "noserverino" },
167 { Opt_rwpidforward, "rwpidforward" },
168 { Opt_cifsacl, "cifsacl" },
169 { Opt_nocifsacl, "nocifsacl" },
171 { Opt_noacl, "noacl" },
172 { Opt_locallease, "locallease" },
173 { Opt_sign, "sign" },
174 { Opt_seal, "seal" },
175 { Opt_noac, "noac" },
177 { Opt_mfsymlinks, "mfsymlinks" },
178 { Opt_multiuser, "multiuser" },
179 { Opt_sloppy, "sloppy" },
180 { Opt_nosharesock, "nosharesock" },
181 { Opt_persistent, "persistenthandles"},
182 { Opt_nopersistent, "nopersistenthandles"},
183 { Opt_resilient, "resilienthandles"},
184 { Opt_noresilient, "noresilienthandles"},
185 { Opt_domainauto, "domainauto"},
187 { Opt_backupuid, "backupuid=%s" },
188 { Opt_backupgid, "backupgid=%s" },
189 { Opt_uid, "uid=%s" },
190 { Opt_cruid, "cruid=%s" },
191 { Opt_gid, "gid=%s" },
192 { Opt_file_mode, "file_mode=%s" },
193 { Opt_dirmode, "dirmode=%s" },
194 { Opt_dirmode, "dir_mode=%s" },
195 { Opt_port, "port=%s" },
196 { Opt_rsize, "rsize=%s" },
197 { Opt_wsize, "wsize=%s" },
198 { Opt_actimeo, "actimeo=%s" },
199 { Opt_echo_interval, "echo_interval=%s" },
200 { Opt_max_credits, "max_credits=%s" },
201 { Opt_snapshot, "snapshot=%s" },
203 { Opt_blank_user, "user=" },
204 { Opt_blank_user, "username=" },
205 { Opt_user, "user=%s" },
206 { Opt_user, "username=%s" },
207 { Opt_blank_pass, "pass=" },
208 { Opt_blank_pass, "password=" },
209 { Opt_pass, "pass=%s" },
210 { Opt_pass, "password=%s" },
211 { Opt_blank_ip, "ip=" },
212 { Opt_blank_ip, "addr=" },
214 { Opt_ip, "addr=%s" },
215 { Opt_ignore, "unc=%s" },
216 { Opt_ignore, "target=%s" },
217 { Opt_ignore, "path=%s" },
218 { Opt_domain, "dom=%s" },
219 { Opt_domain, "domain=%s" },
220 { Opt_domain, "workgroup=%s" },
221 { Opt_srcaddr, "srcaddr=%s" },
222 { Opt_ignore, "prefixpath=%s" },
223 { Opt_iocharset, "iocharset=%s" },
224 { Opt_netbiosname, "netbiosname=%s" },
225 { Opt_servern, "servern=%s" },
226 { Opt_ver, "ver=%s" },
227 { Opt_vers, "vers=%s" },
228 { Opt_sec, "sec=%s" },
229 { Opt_cache, "cache=%s" },
231 { Opt_ignore, "cred" },
232 { Opt_ignore, "credentials" },
233 { Opt_ignore, "cred=%s" },
234 { Opt_ignore, "credentials=%s" },
235 { Opt_ignore, "guest" },
236 { Opt_ignore, "rw" },
237 { Opt_ignore, "ro" },
238 { Opt_ignore, "suid" },
239 { Opt_ignore, "nosuid" },
240 { Opt_ignore, "exec" },
241 { Opt_ignore, "noexec" },
242 { Opt_ignore, "nodev" },
243 { Opt_ignore, "noauto" },
244 { Opt_ignore, "dev" },
245 { Opt_ignore, "mand" },
246 { Opt_ignore, "nomand" },
247 { Opt_ignore, "_netdev" },
253 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
254 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
255 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
256 Opt_sec_ntlmv2i, Opt_sec_lanman,
262 static const match_table_t cifs_secflavor_tokens = {
263 { Opt_sec_krb5, "krb5" },
264 { Opt_sec_krb5i, "krb5i" },
265 { Opt_sec_krb5p, "krb5p" },
266 { Opt_sec_ntlmsspi, "ntlmsspi" },
267 { Opt_sec_ntlmssp, "ntlmssp" },
268 { Opt_ntlm, "ntlm" },
269 { Opt_sec_ntlmi, "ntlmi" },
270 { Opt_sec_ntlmv2, "nontlm" },
271 { Opt_sec_ntlmv2, "ntlmv2" },
272 { Opt_sec_ntlmv2i, "ntlmv2i" },
273 { Opt_sec_lanman, "lanman" },
274 { Opt_sec_none, "none" },
276 { Opt_sec_err, NULL }
287 static const match_table_t cifs_cacheflavor_tokens = {
288 { Opt_cache_loose, "loose" },
289 { Opt_cache_strict, "strict" },
290 { Opt_cache_none, "none" },
291 { Opt_cache_err, NULL }
294 static const match_table_t cifs_smb_version_tokens = {
295 { Smb_1, SMB1_VERSION_STRING },
296 { Smb_20, SMB20_VERSION_STRING},
297 { Smb_21, SMB21_VERSION_STRING },
298 { Smb_30, SMB30_VERSION_STRING },
299 { Smb_302, SMB302_VERSION_STRING },
300 #ifdef CONFIG_CIFS_SMB311
301 { Smb_311, SMB311_VERSION_STRING },
302 { Smb_311, ALT_SMB311_VERSION_STRING },
304 { Smb_version_err, NULL }
307 static int ip_connect(struct TCP_Server_Info *server);
308 static int generic_ip_connect(struct TCP_Server_Info *server);
309 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
310 static void cifs_prune_tlinks(struct work_struct *work);
311 static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
312 const char *devname);
315 * cifs tcp session reconnection
317 * mark tcp session as reconnecting so temporarily locked
318 * mark all smb sessions as reconnecting for tcp session
319 * reconnect tcp session
320 * wake up waiters on reconnection? - (not needed currently)
323 cifs_reconnect(struct TCP_Server_Info *server)
326 struct list_head *tmp, *tmp2;
327 struct cifs_ses *ses;
328 struct cifs_tcon *tcon;
329 struct mid_q_entry *mid_entry;
330 struct list_head retry_list;
332 spin_lock(&GlobalMid_Lock);
333 if (server->tcpStatus == CifsExiting) {
334 /* the demux thread will exit normally
335 next time through the loop */
336 spin_unlock(&GlobalMid_Lock);
339 server->tcpStatus = CifsNeedReconnect;
340 spin_unlock(&GlobalMid_Lock);
342 #ifdef CONFIG_CIFS_SMB2
343 server->max_read = 0;
346 cifs_dbg(FYI, "Reconnecting tcp session\n");
348 /* before reconnecting the tcp session, mark the smb session (uid)
349 and the tid bad so they are not used until reconnected */
350 cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
352 spin_lock(&cifs_tcp_ses_lock);
353 list_for_each(tmp, &server->smb_ses_list) {
354 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
355 ses->need_reconnect = true;
357 list_for_each(tmp2, &ses->tcon_list) {
358 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
359 tcon->need_reconnect = true;
362 spin_unlock(&cifs_tcp_ses_lock);
364 /* do not want to be sending data on a socket we are freeing */
365 cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
366 mutex_lock(&server->srv_mutex);
367 if (server->ssocket) {
368 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
369 server->ssocket->state, server->ssocket->flags);
370 kernel_sock_shutdown(server->ssocket, SHUT_WR);
371 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
372 server->ssocket->state, server->ssocket->flags);
373 sock_release(server->ssocket);
374 server->ssocket = NULL;
376 server->sequence_number = 0;
377 server->session_estab = false;
378 kfree(server->session_key.response);
379 server->session_key.response = NULL;
380 server->session_key.len = 0;
381 server->lstrp = jiffies;
383 /* mark submitted MIDs for retry and issue callback */
384 INIT_LIST_HEAD(&retry_list);
385 cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
386 spin_lock(&GlobalMid_Lock);
387 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
388 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
389 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
390 mid_entry->mid_state = MID_RETRY_NEEDED;
391 list_move(&mid_entry->qhead, &retry_list);
393 spin_unlock(&GlobalMid_Lock);
394 mutex_unlock(&server->srv_mutex);
396 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
397 list_for_each_safe(tmp, tmp2, &retry_list) {
398 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
399 list_del_init(&mid_entry->qhead);
400 mid_entry->callback(mid_entry);
406 /* we should try only the port we connected to before */
407 mutex_lock(&server->srv_mutex);
408 rc = generic_ip_connect(server);
410 cifs_dbg(FYI, "reconnect error %d\n", rc);
411 mutex_unlock(&server->srv_mutex);
414 atomic_inc(&tcpSesReconnectCount);
415 spin_lock(&GlobalMid_Lock);
416 if (server->tcpStatus != CifsExiting)
417 server->tcpStatus = CifsNeedNegotiate;
418 spin_unlock(&GlobalMid_Lock);
419 mutex_unlock(&server->srv_mutex);
421 } while (server->tcpStatus == CifsNeedReconnect);
423 if (server->tcpStatus == CifsNeedNegotiate)
424 mod_delayed_work(cifsiod_wq, &server->echo, 0);
430 cifs_echo_request(struct work_struct *work)
433 struct TCP_Server_Info *server = container_of(work,
434 struct TCP_Server_Info, echo.work);
435 unsigned long echo_interval;
438 * If we need to renegotiate, set echo interval to zero to
439 * immediately call echo service where we can renegotiate.
441 if (server->tcpStatus == CifsNeedNegotiate)
444 echo_interval = server->echo_interval;
447 * We cannot send an echo if it is disabled.
448 * Also, no need to ping if we got a response recently.
451 if (server->tcpStatus == CifsNeedReconnect ||
452 server->tcpStatus == CifsExiting ||
453 server->tcpStatus == CifsNew ||
454 (server->ops->can_echo && !server->ops->can_echo(server)) ||
455 time_before(jiffies, server->lstrp + echo_interval - HZ))
458 rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
460 cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
464 queue_delayed_work(cifsiod_wq, &server->echo, server->echo_interval);
468 allocate_buffers(struct TCP_Server_Info *server)
470 if (!server->bigbuf) {
471 server->bigbuf = (char *)cifs_buf_get();
472 if (!server->bigbuf) {
473 cifs_dbg(VFS, "No memory for large SMB response\n");
475 /* retry will check if exiting */
478 } else if (server->large_buf) {
479 /* we are reusing a dirty large buf, clear its start */
480 memset(server->bigbuf, 0, HEADER_SIZE(server));
483 if (!server->smallbuf) {
484 server->smallbuf = (char *)cifs_small_buf_get();
485 if (!server->smallbuf) {
486 cifs_dbg(VFS, "No memory for SMB response\n");
488 /* retry will check if exiting */
491 /* beginning of smb buffer is cleared in our buf_get */
493 /* if existing small buf clear beginning */
494 memset(server->smallbuf, 0, HEADER_SIZE(server));
501 server_unresponsive(struct TCP_Server_Info *server)
504 * We need to wait 2 echo intervals to make sure we handle such
506 * 1s client sends a normal SMB request
507 * 2s client gets a response
508 * 30s echo workqueue job pops, and decides we got a response recently
509 * and don't need to send another
511 * 65s kernel_recvmsg times out, and we see that we haven't gotten
512 * a response in >60s.
514 if (server->tcpStatus == CifsGood &&
515 time_after(jiffies, server->lstrp + 2 * server->echo_interval)) {
516 cifs_dbg(VFS, "Server %s has not responded in %lu seconds. Reconnecting...\n",
517 server->hostname, (2 * server->echo_interval) / HZ);
518 cifs_reconnect(server);
519 wake_up(&server->response_q);
527 cifs_readv_from_socket(struct TCP_Server_Info *server, struct msghdr *smb_msg)
532 smb_msg->msg_control = NULL;
533 smb_msg->msg_controllen = 0;
535 for (total_read = 0; msg_data_left(smb_msg); total_read += length) {
538 if (server_unresponsive(server))
539 return -ECONNABORTED;
541 length = sock_recvmsg(server->ssocket, smb_msg, 0);
543 if (server->tcpStatus == CifsExiting)
546 if (server->tcpStatus == CifsNeedReconnect) {
547 cifs_reconnect(server);
548 return -ECONNABORTED;
551 if (length == -ERESTARTSYS ||
555 * Minimum sleep to prevent looping, allowing socket
556 * to clear and app threads to set tcpStatus
557 * CifsNeedReconnect if server hung.
559 usleep_range(1000, 2000);
565 cifs_dbg(FYI, "Received no data or error: %d\n", length);
566 cifs_reconnect(server);
567 return -ECONNABORTED;
574 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
575 unsigned int to_read)
577 struct msghdr smb_msg;
578 struct kvec iov = {.iov_base = buf, .iov_len = to_read};
579 iov_iter_kvec(&smb_msg.msg_iter, READ | ITER_KVEC, &iov, 1, to_read);
581 return cifs_readv_from_socket(server, &smb_msg);
585 cifs_read_page_from_socket(struct TCP_Server_Info *server, struct page *page,
586 unsigned int to_read)
588 struct msghdr smb_msg;
589 struct bio_vec bv = {.bv_page = page, .bv_len = to_read};
590 iov_iter_bvec(&smb_msg.msg_iter, READ | ITER_BVEC, &bv, 1, to_read);
591 return cifs_readv_from_socket(server, &smb_msg);
595 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
598 * The first byte big endian of the length field,
599 * is actually not part of the length but the type
600 * with the most common, zero, as regular data.
603 case RFC1002_SESSION_MESSAGE:
604 /* Regular SMB response */
606 case RFC1002_SESSION_KEEP_ALIVE:
607 cifs_dbg(FYI, "RFC 1002 session keep alive\n");
609 case RFC1002_POSITIVE_SESSION_RESPONSE:
610 cifs_dbg(FYI, "RFC 1002 positive session response\n");
612 case RFC1002_NEGATIVE_SESSION_RESPONSE:
614 * We get this from Windows 98 instead of an error on
615 * SMB negprot response.
617 cifs_dbg(FYI, "RFC 1002 negative session response\n");
618 /* give server a second to clean up */
621 * Always try 445 first on reconnect since we get NACK
622 * on some if we ever connected to port 139 (the NACK
623 * is since we do not begin with RFC1001 session
626 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
627 cifs_reconnect(server);
628 wake_up(&server->response_q);
631 cifs_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
632 cifs_reconnect(server);
639 dequeue_mid(struct mid_q_entry *mid, bool malformed)
641 #ifdef CONFIG_CIFS_STATS2
642 mid->when_received = jiffies;
644 spin_lock(&GlobalMid_Lock);
646 mid->mid_state = MID_RESPONSE_RECEIVED;
648 mid->mid_state = MID_RESPONSE_MALFORMED;
649 list_del_init(&mid->qhead);
650 spin_unlock(&GlobalMid_Lock);
654 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
655 char *buf, int malformed)
657 if (server->ops->check_trans2 &&
658 server->ops->check_trans2(mid, server, buf, malformed))
661 mid->large_buf = server->large_buf;
662 /* Was previous buf put in mpx struct for multi-rsp? */
663 if (!mid->multiRsp) {
664 /* smb buffer will be freed by user thread */
665 if (server->large_buf)
666 server->bigbuf = NULL;
668 server->smallbuf = NULL;
670 dequeue_mid(mid, malformed);
673 static void clean_demultiplex_info(struct TCP_Server_Info *server)
677 /* take it off the list, if it's not already */
678 spin_lock(&cifs_tcp_ses_lock);
679 list_del_init(&server->tcp_ses_list);
680 spin_unlock(&cifs_tcp_ses_lock);
682 spin_lock(&GlobalMid_Lock);
683 server->tcpStatus = CifsExiting;
684 spin_unlock(&GlobalMid_Lock);
685 wake_up_all(&server->response_q);
687 /* check if we have blocked requests that need to free */
688 spin_lock(&server->req_lock);
689 if (server->credits <= 0)
691 spin_unlock(&server->req_lock);
693 * Although there should not be any requests blocked on this queue it
694 * can not hurt to be paranoid and try to wake up requests that may
695 * haven been blocked when more than 50 at time were on the wire to the
696 * same server - they now will see the session is in exit state and get
697 * out of SendReceive.
699 wake_up_all(&server->request_q);
700 /* give those requests time to exit */
703 if (server->ssocket) {
704 sock_release(server->ssocket);
705 server->ssocket = NULL;
708 if (!list_empty(&server->pending_mid_q)) {
709 struct list_head dispose_list;
710 struct mid_q_entry *mid_entry;
711 struct list_head *tmp, *tmp2;
713 INIT_LIST_HEAD(&dispose_list);
714 spin_lock(&GlobalMid_Lock);
715 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
716 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
717 cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid);
718 mid_entry->mid_state = MID_SHUTDOWN;
719 list_move(&mid_entry->qhead, &dispose_list);
721 spin_unlock(&GlobalMid_Lock);
723 /* now walk dispose list and issue callbacks */
724 list_for_each_safe(tmp, tmp2, &dispose_list) {
725 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
726 cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid);
727 list_del_init(&mid_entry->qhead);
728 mid_entry->callback(mid_entry);
730 /* 1/8th of sec is more than enough time for them to exit */
734 if (!list_empty(&server->pending_mid_q)) {
736 * mpx threads have not exited yet give them at least the smb
737 * send timeout time for long ops.
739 * Due to delays on oplock break requests, we need to wait at
740 * least 45 seconds before giving up on a request getting a
741 * response and going ahead and killing cifsd.
743 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
746 * If threads still have not exited they are probably never
747 * coming home not much else we can do but free the memory.
751 kfree(server->hostname);
754 length = atomic_dec_return(&tcpSesAllocCount);
756 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
760 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
763 char *buf = server->smallbuf;
764 unsigned int pdu_length = get_rfc1002_length(buf);
766 /* make sure this will fit in a large buffer */
767 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) - 4) {
768 cifs_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
769 cifs_reconnect(server);
770 wake_up(&server->response_q);
771 return -ECONNABORTED;
774 /* switch to large buffer if too big for a small one */
775 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
776 server->large_buf = true;
777 memcpy(server->bigbuf, buf, server->total_read);
778 buf = server->bigbuf;
781 /* now read the rest */
782 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
783 pdu_length - HEADER_SIZE(server) + 1 + 4);
786 server->total_read += length;
788 dump_smb(buf, server->total_read);
790 return cifs_handle_standard(server, mid);
794 cifs_handle_standard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
796 char *buf = server->large_buf ? server->bigbuf : server->smallbuf;
800 * We know that we received enough to get to the MID as we
801 * checked the pdu_length earlier. Now check to see
802 * if the rest of the header is OK. We borrow the length
803 * var for the rest of the loop to avoid a new stack var.
805 * 48 bytes is enough to display the header and a little bit
806 * into the payload for debugging purposes.
808 length = server->ops->check_message(buf, server->total_read, server);
810 cifs_dump_mem("Bad SMB: ", buf,
811 min_t(unsigned int, server->total_read, 48));
813 if (server->ops->is_status_pending &&
814 server->ops->is_status_pending(buf, server, length))
820 handle_mid(mid, server, buf, length);
825 cifs_demultiplex_thread(void *p)
828 struct TCP_Server_Info *server = p;
829 unsigned int pdu_length;
831 struct task_struct *task_to_wake = NULL;
832 struct mid_q_entry *mid_entry;
834 current->flags |= PF_MEMALLOC;
835 cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
837 length = atomic_inc_return(&tcpSesAllocCount);
839 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
842 while (server->tcpStatus != CifsExiting) {
846 if (!allocate_buffers(server))
849 server->large_buf = false;
850 buf = server->smallbuf;
851 pdu_length = 4; /* enough to get RFC1001 header */
853 length = cifs_read_from_socket(server, buf, pdu_length);
856 server->total_read = length;
859 * The right amount was read from socket - 4 bytes,
860 * so we can now interpret the length field.
862 pdu_length = get_rfc1002_length(buf);
864 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
865 if (!is_smb_response(server, buf[0]))
868 /* make sure we have enough to get to the MID */
869 if (pdu_length < HEADER_SIZE(server) - 1 - 4) {
870 cifs_dbg(VFS, "SMB response too short (%u bytes)\n",
872 cifs_reconnect(server);
873 wake_up(&server->response_q);
877 /* read down to the MID */
878 length = cifs_read_from_socket(server, buf + 4,
879 HEADER_SIZE(server) - 1 - 4);
882 server->total_read += length;
884 if (server->ops->is_transform_hdr &&
885 server->ops->receive_transform &&
886 server->ops->is_transform_hdr(buf)) {
887 length = server->ops->receive_transform(server,
890 mid_entry = server->ops->find_mid(server, buf);
892 if (!mid_entry || !mid_entry->receive)
893 length = standard_receive3(server, mid_entry);
895 length = mid_entry->receive(server, mid_entry);
901 if (server->large_buf)
902 buf = server->bigbuf;
904 server->lstrp = jiffies;
905 if (mid_entry != NULL) {
906 if (!mid_entry->multiRsp || mid_entry->multiEnd)
907 mid_entry->callback(mid_entry);
908 } else if (!server->ops->is_oplock_break ||
909 !server->ops->is_oplock_break(buf, server)) {
910 cifs_dbg(VFS, "No task to wake, unknown frame received! NumMids %d\n",
911 atomic_read(&midCount));
912 cifs_dump_mem("Received Data is: ", buf,
913 HEADER_SIZE(server));
914 #ifdef CONFIG_CIFS_DEBUG2
915 if (server->ops->dump_detail)
916 server->ops->dump_detail(buf);
917 cifs_dump_mids(server);
918 #endif /* CIFS_DEBUG2 */
921 } /* end while !EXITING */
923 /* buffer usually freed in free_mid - need to free it here on exit */
924 cifs_buf_release(server->bigbuf);
925 if (server->smallbuf) /* no sense logging a debug message if NULL */
926 cifs_small_buf_release(server->smallbuf);
928 task_to_wake = xchg(&server->tsk, NULL);
929 clean_demultiplex_info(server);
931 /* if server->tsk was NULL then wait for a signal before exiting */
933 set_current_state(TASK_INTERRUPTIBLE);
934 while (!signal_pending(current)) {
936 set_current_state(TASK_INTERRUPTIBLE);
938 set_current_state(TASK_RUNNING);
941 module_put_and_exit(0);
944 /* extract the host portion of the UNC string */
946 extract_hostname(const char *unc)
952 /* skip double chars at beginning of string */
953 /* BB: check validity of these bytes? */
956 /* delimiter between hostname and sharename is always '\\' now */
957 delim = strchr(src, '\\');
959 return ERR_PTR(-EINVAL);
962 dst = kmalloc((len + 1), GFP_KERNEL);
964 return ERR_PTR(-ENOMEM);
966 memcpy(dst, src, len);
972 static int get_option_ul(substring_t args[], unsigned long *option)
977 string = match_strdup(args);
980 rc = kstrtoul(string, 0, option);
986 static int get_option_uid(substring_t args[], kuid_t *result)
992 rc = get_option_ul(args, &value);
996 uid = make_kuid(current_user_ns(), value);
1004 static int get_option_gid(substring_t args[], kgid_t *result)
1006 unsigned long value;
1010 rc = get_option_ul(args, &value);
1014 gid = make_kgid(current_user_ns(), value);
1015 if (!gid_valid(gid))
1022 static int cifs_parse_security_flavors(char *value,
1023 struct smb_vol *vol)
1026 substring_t args[MAX_OPT_ARGS];
1029 * With mount options, the last one should win. Reset any existing
1030 * settings back to default.
1032 vol->sectype = Unspecified;
1035 switch (match_token(value, cifs_secflavor_tokens, args)) {
1037 cifs_dbg(VFS, "sec=krb5p is not supported!\n");
1043 vol->sectype = Kerberos;
1045 case Opt_sec_ntlmsspi:
1048 case Opt_sec_ntlmssp:
1049 vol->sectype = RawNTLMSSP;
1055 vol->sectype = NTLM;
1057 case Opt_sec_ntlmv2i:
1060 case Opt_sec_ntlmv2:
1061 vol->sectype = NTLMv2;
1063 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1064 case Opt_sec_lanman:
1065 vol->sectype = LANMAN;
1072 cifs_dbg(VFS, "bad security option: %s\n", value);
1080 cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1082 substring_t args[MAX_OPT_ARGS];
1084 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1085 case Opt_cache_loose:
1086 vol->direct_io = false;
1087 vol->strict_io = false;
1089 case Opt_cache_strict:
1090 vol->direct_io = false;
1091 vol->strict_io = true;
1093 case Opt_cache_none:
1094 vol->direct_io = true;
1095 vol->strict_io = false;
1098 cifs_dbg(VFS, "bad cache= option: %s\n", value);
1105 cifs_parse_smb_version(char *value, struct smb_vol *vol)
1107 substring_t args[MAX_OPT_ARGS];
1109 switch (match_token(value, cifs_smb_version_tokens, args)) {
1111 vol->ops = &smb1_operations;
1112 vol->vals = &smb1_values;
1114 #ifdef CONFIG_CIFS_SMB2
1116 vol->ops = &smb20_operations;
1117 vol->vals = &smb20_values;
1120 vol->ops = &smb21_operations;
1121 vol->vals = &smb21_values;
1124 vol->ops = &smb30_operations;
1125 vol->vals = &smb30_values;
1128 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1129 vol->vals = &smb302_values;
1131 #ifdef CONFIG_CIFS_SMB311
1133 vol->ops = &smb311_operations;
1134 vol->vals = &smb311_values;
1139 cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
1146 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1147 * fields with the result. Returns 0 on success and an error otherwise.
1150 cifs_parse_devname(const char *devname, struct smb_vol *vol)
1153 const char *delims = "/\\";
1156 /* make sure we have a valid UNC double delimiter prefix */
1157 len = strspn(devname, delims);
1161 /* find delimiter between host and sharename */
1162 pos = strpbrk(devname + 2, delims);
1166 /* skip past delimiter */
1169 /* now go until next delimiter or end of string */
1170 len = strcspn(pos, delims);
1172 /* move "pos" up to delimiter or NULL */
1174 vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1178 convert_delimiter(vol->UNC, '\\');
1180 /* skip any delimiter */
1181 if (*pos == '/' || *pos == '\\')
1184 /* If pos is NULL then no prepath */
1188 vol->prepath = kstrdup(pos, GFP_KERNEL);
1196 cifs_parse_mount_options(const char *mountdata, const char *devname,
1197 struct smb_vol *vol)
1200 char *mountdata_copy = NULL, *options;
1201 unsigned int temp_len, i, j;
1203 short int override_uid = -1;
1204 short int override_gid = -1;
1205 bool uid_specified = false;
1206 bool gid_specified = false;
1207 bool sloppy = false;
1208 char *invalid = NULL;
1209 char *nodename = utsname()->nodename;
1210 char *string = NULL;
1211 char *tmp_end, *value;
1213 bool got_ip = false;
1214 unsigned short port = 0;
1215 struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1219 delim = separator[0];
1221 /* ensure we always start with zeroed-out smb_vol */
1222 memset(vol, 0, sizeof(*vol));
1225 * does not have to be perfect mapping since field is
1226 * informational, only used for servers that do not support
1227 * port 445 and it can be overridden at mount time
1229 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1230 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1231 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1233 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1234 /* null target name indicates to use *SMBSERVR default called name
1235 if we end up sending RFC1001 session initialize */
1236 vol->target_rfc1001_name[0] = 0;
1237 vol->cred_uid = current_uid();
1238 vol->linux_uid = current_uid();
1239 vol->linux_gid = current_gid();
1242 * default to SFM style remapping of seven reserved characters
1243 * unless user overrides it or we negotiate CIFS POSIX where
1244 * it is unnecessary. Can not simultaneously use more than one mapping
1245 * since then readdir could list files that open could not open
1249 /* default to only allowing write access to owner of the mount */
1250 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1252 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1253 /* default is always to request posix paths. */
1254 vol->posix_paths = 1;
1255 /* default to using server inode numbers where available */
1256 vol->server_ino = 1;
1258 /* default is to use strict cifs caching semantics */
1259 vol->strict_io = true;
1261 vol->actimeo = CIFS_DEF_ACTIMEO;
1263 /* FIXME: add autonegotiation -- for now, SMB1 is default */
1264 vol->ops = &smb1_operations;
1265 vol->vals = &smb1_values;
1267 vol->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1270 goto cifs_parse_mount_err;
1272 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1273 if (!mountdata_copy)
1274 goto cifs_parse_mount_err;
1276 options = mountdata_copy;
1277 end = options + strlen(options);
1279 if (strncmp(options, "sep=", 4) == 0) {
1280 if (options[4] != 0) {
1281 separator[0] = options[4];
1284 cifs_dbg(FYI, "Null separator not allowed\n");
1287 vol->backupuid_specified = false; /* no backup intent for a user */
1288 vol->backupgid_specified = false; /* no backup intent for a group */
1290 switch (cifs_parse_devname(devname, vol)) {
1294 cifs_dbg(VFS, "Unable to allocate memory for devname.\n");
1295 goto cifs_parse_mount_err;
1297 cifs_dbg(VFS, "Malformed UNC in devname.\n");
1298 goto cifs_parse_mount_err;
1300 cifs_dbg(VFS, "Unknown error parsing devname.\n");
1301 goto cifs_parse_mount_err;
1304 while ((data = strsep(&options, separator)) != NULL) {
1305 substring_t args[MAX_OPT_ARGS];
1306 unsigned long option;
1312 token = match_token(data, cifs_mount_option_tokens, args);
1316 /* Ingnore the following */
1320 /* Boolean values */
1321 case Opt_user_xattr:
1324 case Opt_nouser_xattr:
1330 case Opt_noforceuid:
1336 case Opt_noforcegid:
1339 case Opt_noblocksend:
1340 vol->noblocksnd = 1;
1342 case Opt_noautotune:
1343 vol->noautotune = 1;
1358 vol->sfu_remap = true;
1359 vol->remap = false; /* disable SFM mapping */
1361 case Opt_nomapchars:
1362 vol->sfu_remap = false;
1366 vol->sfu_remap = false; /* disable SFU mapping */
1368 case Opt_nomapposix:
1380 case Opt_posixpaths:
1381 vol->posix_paths = 1;
1383 case Opt_noposixpaths:
1384 vol->posix_paths = 0;
1387 vol->no_linux_ext = 1;
1398 * turn off mandatory locking in mode
1399 * if remote locking is turned off since the
1400 * local vfs will do advisory
1402 if (vol->file_mode ==
1403 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1404 vol->file_mode = S_IALLUGO;
1406 case Opt_forcemandatorylock:
1415 case Opt_setuidfromacl:
1416 vol->setuidfromacl = 1;
1419 vol->dynperm = true;
1422 vol->dynperm = false;
1436 case Opt_nostrictsync:
1437 vol->nostrictsync = 1;
1439 case Opt_strictsync:
1440 vol->nostrictsync = 0;
1443 vol->server_ino = 1;
1445 case Opt_noserverino:
1446 vol->server_ino = 0;
1448 case Opt_rwpidforward:
1449 vol->rwpidforward = 1;
1458 vol->no_psx_acl = 0;
1461 vol->no_psx_acl = 1;
1463 case Opt_locallease:
1464 vol->local_lease = 1;
1470 /* we do not do the following in secFlags because seal
1471 * is a per tree connection (mount) not a per socket
1472 * or per-smb connection option in the protocol
1473 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1478 pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1481 #ifndef CONFIG_CIFS_FSCACHE
1482 cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1483 goto cifs_parse_mount_err;
1487 case Opt_mfsymlinks:
1488 vol->mfsymlinks = true;
1491 vol->multiuser = true;
1496 case Opt_nosharesock:
1497 vol->nosharesock = true;
1499 case Opt_nopersistent:
1500 vol->nopersistent = true;
1501 if (vol->persistent) {
1503 "persistenthandles mount options conflict\n");
1504 goto cifs_parse_mount_err;
1507 case Opt_persistent:
1508 vol->persistent = true;
1509 if ((vol->nopersistent) || (vol->resilient)) {
1511 "persistenthandles mount options conflict\n");
1512 goto cifs_parse_mount_err;
1516 vol->resilient = true;
1517 if (vol->persistent) {
1519 "persistenthandles mount options conflict\n");
1520 goto cifs_parse_mount_err;
1523 case Opt_noresilient:
1524 vol->resilient = false; /* already the default */
1526 case Opt_domainauto:
1527 vol->domainauto = true;
1530 /* Numeric Values */
1532 if (get_option_uid(args, &vol->backupuid)) {
1533 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
1535 goto cifs_parse_mount_err;
1537 vol->backupuid_specified = true;
1540 if (get_option_gid(args, &vol->backupgid)) {
1541 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
1543 goto cifs_parse_mount_err;
1545 vol->backupgid_specified = true;
1548 if (get_option_uid(args, &vol->linux_uid)) {
1549 cifs_dbg(VFS, "%s: Invalid uid value\n",
1551 goto cifs_parse_mount_err;
1553 uid_specified = true;
1556 if (get_option_uid(args, &vol->cred_uid)) {
1557 cifs_dbg(VFS, "%s: Invalid cruid value\n",
1559 goto cifs_parse_mount_err;
1563 if (get_option_gid(args, &vol->linux_gid)) {
1564 cifs_dbg(VFS, "%s: Invalid gid value\n",
1566 goto cifs_parse_mount_err;
1568 gid_specified = true;
1571 if (get_option_ul(args, &option)) {
1572 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
1574 goto cifs_parse_mount_err;
1576 vol->file_mode = option;
1579 if (get_option_ul(args, &option)) {
1580 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
1582 goto cifs_parse_mount_err;
1584 vol->dir_mode = option;
1587 if (get_option_ul(args, &option) ||
1588 option > USHRT_MAX) {
1589 cifs_dbg(VFS, "%s: Invalid port value\n",
1591 goto cifs_parse_mount_err;
1593 port = (unsigned short)option;
1596 if (get_option_ul(args, &option)) {
1597 cifs_dbg(VFS, "%s: Invalid rsize value\n",
1599 goto cifs_parse_mount_err;
1601 vol->rsize = option;
1604 if (get_option_ul(args, &option)) {
1605 cifs_dbg(VFS, "%s: Invalid wsize value\n",
1607 goto cifs_parse_mount_err;
1609 vol->wsize = option;
1612 if (get_option_ul(args, &option)) {
1613 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
1615 goto cifs_parse_mount_err;
1617 vol->actimeo = HZ * option;
1618 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1619 cifs_dbg(VFS, "attribute cache timeout too large\n");
1620 goto cifs_parse_mount_err;
1623 case Opt_echo_interval:
1624 if (get_option_ul(args, &option)) {
1625 cifs_dbg(VFS, "%s: Invalid echo interval value\n",
1627 goto cifs_parse_mount_err;
1629 vol->echo_interval = option;
1632 if (get_option_ul(args, &option)) {
1633 cifs_dbg(VFS, "%s: Invalid snapshot time\n",
1635 goto cifs_parse_mount_err;
1637 vol->snapshot_time = option;
1639 case Opt_max_credits:
1640 if (get_option_ul(args, &option) || (option < 20) ||
1642 cifs_dbg(VFS, "%s: Invalid max_credits value\n",
1644 goto cifs_parse_mount_err;
1646 vol->max_credits = option;
1649 /* String Arguments */
1651 case Opt_blank_user:
1652 /* null user, ie. anonymous authentication */
1654 vol->username = NULL;
1657 string = match_strdup(args);
1661 if (strnlen(string, CIFS_MAX_USERNAME_LEN) >
1662 CIFS_MAX_USERNAME_LEN) {
1663 pr_warn("CIFS: username too long\n");
1664 goto cifs_parse_mount_err;
1667 kfree(vol->username);
1668 vol->username = kstrdup(string, GFP_KERNEL);
1670 goto cifs_parse_mount_err;
1672 case Opt_blank_pass:
1673 /* passwords have to be handled differently
1674 * to allow the character used for deliminator
1675 * to be passed within them
1679 * Check if this is a case where the password
1680 * starts with a delimiter
1682 tmp_end = strchr(data, '=');
1684 if (!(tmp_end < end && tmp_end[1] == delim)) {
1685 /* No it is not. Set the password to NULL */
1686 kfree(vol->password);
1687 vol->password = NULL;
1690 /* Yes it is. Drop down to Opt_pass below.*/
1692 /* Obtain the value string */
1693 value = strchr(data, '=');
1696 /* Set tmp_end to end of the string */
1697 tmp_end = (char *) value + strlen(value);
1699 /* Check if following character is the deliminator
1700 * If yes, we have encountered a double deliminator
1701 * reset the NULL character to the deliminator
1703 if (tmp_end < end && tmp_end[1] == delim) {
1706 /* Keep iterating until we get to a single
1707 * deliminator OR the end
1709 while ((tmp_end = strchr(tmp_end, delim))
1710 != NULL && (tmp_end[1] == delim)) {
1711 tmp_end = (char *) &tmp_end[2];
1714 /* Reset var options to point to next element */
1717 options = (char *) &tmp_end[1];
1719 /* Reached the end of the mount option
1724 kfree(vol->password);
1725 /* Now build new password string */
1726 temp_len = strlen(value);
1727 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1728 if (vol->password == NULL) {
1729 pr_warn("CIFS: no memory for password\n");
1730 goto cifs_parse_mount_err;
1733 for (i = 0, j = 0; i < temp_len; i++, j++) {
1734 vol->password[j] = value[i];
1735 if ((value[i] == delim) &&
1736 value[i+1] == delim)
1737 /* skip the second deliminator */
1740 vol->password[j] = '\0';
1743 /* FIXME: should this be an error instead? */
1747 string = match_strdup(args);
1751 if (!cifs_convert_address(dstaddr, string,
1753 pr_err("CIFS: bad ip= option (%s).\n", string);
1754 goto cifs_parse_mount_err;
1759 string = match_strdup(args);
1763 if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
1764 == CIFS_MAX_DOMAINNAME_LEN) {
1765 pr_warn("CIFS: domain name too long\n");
1766 goto cifs_parse_mount_err;
1769 kfree(vol->domainname);
1770 vol->domainname = kstrdup(string, GFP_KERNEL);
1771 if (!vol->domainname) {
1772 pr_warn("CIFS: no memory for domainname\n");
1773 goto cifs_parse_mount_err;
1775 cifs_dbg(FYI, "Domain name set\n");
1778 string = match_strdup(args);
1782 if (!cifs_convert_address(
1783 (struct sockaddr *)&vol->srcaddr,
1784 string, strlen(string))) {
1785 pr_warn("CIFS: Could not parse srcaddr: %s\n",
1787 goto cifs_parse_mount_err;
1791 string = match_strdup(args);
1795 if (strnlen(string, 1024) >= 65) {
1796 pr_warn("CIFS: iocharset name too long.\n");
1797 goto cifs_parse_mount_err;
1800 if (strncasecmp(string, "default", 7) != 0) {
1801 kfree(vol->iocharset);
1802 vol->iocharset = kstrdup(string,
1804 if (!vol->iocharset) {
1805 pr_warn("CIFS: no memory for charset\n");
1806 goto cifs_parse_mount_err;
1809 /* if iocharset not set then load_nls_default
1812 cifs_dbg(FYI, "iocharset set to %s\n", string);
1814 case Opt_netbiosname:
1815 string = match_strdup(args);
1819 memset(vol->source_rfc1001_name, 0x20,
1822 * FIXME: are there cases in which a comma can
1823 * be valid in workstation netbios name (and
1824 * need special handling)?
1826 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1827 /* don't ucase netbiosname for user */
1830 vol->source_rfc1001_name[i] = string[i];
1832 /* The string has 16th byte zero still from
1833 * set at top of the function
1835 if (i == RFC1001_NAME_LEN && string[i] != 0)
1836 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
1839 /* servernetbiosname specified override *SMBSERVER */
1840 string = match_strdup(args);
1844 /* last byte, type, is 0x20 for servr type */
1845 memset(vol->target_rfc1001_name, 0x20,
1846 RFC1001_NAME_LEN_WITH_NULL);
1848 /* BB are there cases in which a comma can be
1849 valid in this workstation netbios name
1850 (and need special handling)? */
1852 /* user or mount helper must uppercase the
1854 for (i = 0; i < 15; i++) {
1857 vol->target_rfc1001_name[i] = string[i];
1859 /* The string has 16th byte zero still from
1860 set at top of the function */
1861 if (i == RFC1001_NAME_LEN && string[i] != 0)
1862 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
1865 string = match_strdup(args);
1869 if (strncasecmp(string, "1", 1) == 0) {
1870 /* This is the default */
1873 /* For all other value, error */
1874 pr_warn("CIFS: Invalid version specified\n");
1875 goto cifs_parse_mount_err;
1877 string = match_strdup(args);
1881 if (cifs_parse_smb_version(string, vol) != 0)
1882 goto cifs_parse_mount_err;
1885 string = match_strdup(args);
1889 if (cifs_parse_security_flavors(string, vol) != 0)
1890 goto cifs_parse_mount_err;
1893 string = match_strdup(args);
1897 if (cifs_parse_cache_flavor(string, vol) != 0)
1898 goto cifs_parse_mount_err;
1902 * An option we don't recognize. Save it off for later
1903 * if we haven't already found one
1909 /* Free up any allocated string */
1914 if (!sloppy && invalid) {
1915 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid);
1916 goto cifs_parse_mount_err;
1920 /* Muliuser mounts require CONFIG_KEYS support */
1921 if (vol->multiuser) {
1922 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
1923 goto cifs_parse_mount_err;
1927 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
1928 goto cifs_parse_mount_err;
1931 /* make sure UNC has a share name */
1932 if (!strchr(vol->UNC + 3, '\\')) {
1933 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
1934 goto cifs_parse_mount_err;
1938 /* No ip= option specified? Try to get it from UNC */
1939 if (!cifs_convert_address(dstaddr, &vol->UNC[2],
1940 strlen(&vol->UNC[2]))) {
1941 pr_err("Unable to determine destination address.\n");
1942 goto cifs_parse_mount_err;
1946 /* set the port that we got earlier */
1947 cifs_set_port(dstaddr, port);
1950 vol->override_uid = override_uid;
1951 else if (override_uid == 1)
1952 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
1955 vol->override_gid = override_gid;
1956 else if (override_gid == 1)
1957 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
1959 kfree(mountdata_copy);
1963 pr_warn("Could not allocate temporary buffer\n");
1964 cifs_parse_mount_err:
1966 kfree(mountdata_copy);
1970 /** Returns true if srcaddr isn't specified and rhs isn't
1971 * specified, or if srcaddr is specified and
1972 * matches the IP address of the rhs argument.
1975 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1977 switch (srcaddr->sa_family) {
1979 return (rhs->sa_family == AF_UNSPEC);
1981 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1982 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1983 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1986 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1987 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
1988 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1992 return false; /* don't expect to be here */
1997 * If no port is specified in addr structure, we try to match with 445 port
1998 * and if it fails - with 139 ports. It should be called only if address
1999 * families of server and addr are equal.
2002 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
2004 __be16 port, *sport;
2006 switch (addr->sa_family) {
2008 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
2009 port = ((struct sockaddr_in *) addr)->sin_port;
2012 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
2013 port = ((struct sockaddr_in6 *) addr)->sin6_port;
2021 port = htons(CIFS_PORT);
2025 port = htons(RFC1001_PORT);
2028 return port == *sport;
2032 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
2033 struct sockaddr *srcaddr)
2035 switch (addr->sa_family) {
2037 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2038 struct sockaddr_in *srv_addr4 =
2039 (struct sockaddr_in *)&server->dstaddr;
2041 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
2046 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2047 struct sockaddr_in6 *srv_addr6 =
2048 (struct sockaddr_in6 *)&server->dstaddr;
2050 if (!ipv6_addr_equal(&addr6->sin6_addr,
2051 &srv_addr6->sin6_addr))
2053 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
2059 return false; /* don't expect to be here */
2062 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2069 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2072 * The select_sectype function should either return the vol->sectype
2073 * that was specified, or "Unspecified" if that sectype was not
2074 * compatible with the given NEGOTIATE request.
2076 if (select_sectype(server, vol->sectype) == Unspecified)
2080 * Now check if signing mode is acceptable. No need to check
2081 * global_secflags at this point since if MUST_SIGN is set then
2082 * the server->sign had better be too.
2084 if (vol->sign && !server->sign)
2090 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2092 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2094 if (vol->nosharesock)
2097 if ((server->vals != vol->vals) || (server->ops != vol->ops))
2100 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2103 if (!match_address(server, addr,
2104 (struct sockaddr *)&vol->srcaddr))
2107 if (!match_port(server, addr))
2110 if (!match_security(server, vol))
2113 if (server->echo_interval != vol->echo_interval * HZ)
2119 static struct TCP_Server_Info *
2120 cifs_find_tcp_session(struct smb_vol *vol)
2122 struct TCP_Server_Info *server;
2124 spin_lock(&cifs_tcp_ses_lock);
2125 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2126 if (!match_server(server, vol))
2129 ++server->srv_count;
2130 spin_unlock(&cifs_tcp_ses_lock);
2131 cifs_dbg(FYI, "Existing tcp session with server found\n");
2134 spin_unlock(&cifs_tcp_ses_lock);
2139 cifs_put_tcp_session(struct TCP_Server_Info *server, int from_reconnect)
2141 struct task_struct *task;
2143 spin_lock(&cifs_tcp_ses_lock);
2144 if (--server->srv_count > 0) {
2145 spin_unlock(&cifs_tcp_ses_lock);
2149 put_net(cifs_net_ns(server));
2151 list_del_init(&server->tcp_ses_list);
2152 spin_unlock(&cifs_tcp_ses_lock);
2154 cancel_delayed_work_sync(&server->echo);
2156 #ifdef CONFIG_CIFS_SMB2
2159 * Avoid deadlock here: reconnect work calls
2160 * cifs_put_tcp_session() at its end. Need to be sure
2161 * that reconnect work does nothing with server pointer after
2164 cancel_delayed_work(&server->reconnect);
2166 cancel_delayed_work_sync(&server->reconnect);
2169 spin_lock(&GlobalMid_Lock);
2170 server->tcpStatus = CifsExiting;
2171 spin_unlock(&GlobalMid_Lock);
2173 cifs_crypto_secmech_release(server);
2174 cifs_fscache_release_client_cookie(server);
2176 kfree(server->session_key.response);
2177 server->session_key.response = NULL;
2178 server->session_key.len = 0;
2180 task = xchg(&server->tsk, NULL);
2182 force_sig(SIGKILL, task);
2185 static struct TCP_Server_Info *
2186 cifs_get_tcp_session(struct smb_vol *volume_info)
2188 struct TCP_Server_Info *tcp_ses = NULL;
2191 cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
2193 /* see if we already have a matching tcp_ses */
2194 tcp_ses = cifs_find_tcp_session(volume_info);
2198 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2204 tcp_ses->ops = volume_info->ops;
2205 tcp_ses->vals = volume_info->vals;
2206 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2207 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2208 if (IS_ERR(tcp_ses->hostname)) {
2209 rc = PTR_ERR(tcp_ses->hostname);
2210 goto out_err_crypto_release;
2213 tcp_ses->noblocksnd = volume_info->noblocksnd;
2214 tcp_ses->noautotune = volume_info->noautotune;
2215 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2216 tcp_ses->in_flight = 0;
2217 tcp_ses->credits = 1;
2218 init_waitqueue_head(&tcp_ses->response_q);
2219 init_waitqueue_head(&tcp_ses->request_q);
2220 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2221 mutex_init(&tcp_ses->srv_mutex);
2222 memcpy(tcp_ses->workstation_RFC1001_name,
2223 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2224 memcpy(tcp_ses->server_RFC1001_name,
2225 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2226 tcp_ses->session_estab = false;
2227 tcp_ses->sequence_number = 0;
2228 tcp_ses->lstrp = jiffies;
2229 spin_lock_init(&tcp_ses->req_lock);
2230 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2231 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2232 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2233 #ifdef CONFIG_CIFS_SMB2
2234 INIT_DELAYED_WORK(&tcp_ses->reconnect, smb2_reconnect_server);
2235 mutex_init(&tcp_ses->reconnect_mutex);
2237 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2238 sizeof(tcp_ses->srcaddr));
2239 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2240 sizeof(tcp_ses->dstaddr));
2241 #ifdef CONFIG_CIFS_SMB2
2242 generate_random_uuid(tcp_ses->client_guid);
2245 * at this point we are the only ones with the pointer
2246 * to the struct since the kernel thread not created yet
2247 * no need to spinlock this init of tcpStatus or srv_count
2249 tcp_ses->tcpStatus = CifsNew;
2250 ++tcp_ses->srv_count;
2252 if (volume_info->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
2253 volume_info->echo_interval <= SMB_ECHO_INTERVAL_MAX)
2254 tcp_ses->echo_interval = volume_info->echo_interval * HZ;
2256 tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
2258 rc = ip_connect(tcp_ses);
2260 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
2261 goto out_err_crypto_release;
2265 * since we're in a cifs function already, we know that
2266 * this will succeed. No need for try_module_get().
2268 __module_get(THIS_MODULE);
2269 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2271 if (IS_ERR(tcp_ses->tsk)) {
2272 rc = PTR_ERR(tcp_ses->tsk);
2273 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
2274 module_put(THIS_MODULE);
2275 goto out_err_crypto_release;
2277 tcp_ses->tcpStatus = CifsNeedNegotiate;
2279 /* thread spawned, put it on the list */
2280 spin_lock(&cifs_tcp_ses_lock);
2281 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2282 spin_unlock(&cifs_tcp_ses_lock);
2284 cifs_fscache_get_client_cookie(tcp_ses);
2286 /* queue echo request delayed work */
2287 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
2291 out_err_crypto_release:
2292 cifs_crypto_secmech_release(tcp_ses);
2294 put_net(cifs_net_ns(tcp_ses));
2298 if (!IS_ERR(tcp_ses->hostname))
2299 kfree(tcp_ses->hostname);
2300 if (tcp_ses->ssocket)
2301 sock_release(tcp_ses->ssocket);
2307 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2309 if (vol->sectype != Unspecified &&
2310 vol->sectype != ses->sectype)
2313 switch (ses->sectype) {
2315 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2319 /* NULL username means anonymous session */
2320 if (ses->user_name == NULL) {
2326 /* anything else takes username/password */
2327 if (strncmp(ses->user_name,
2328 vol->username ? vol->username : "",
2329 CIFS_MAX_USERNAME_LEN))
2331 if ((vol->username && strlen(vol->username) != 0) &&
2332 ses->password != NULL &&
2333 strncmp(ses->password,
2334 vol->password ? vol->password : "",
2335 CIFS_MAX_PASSWORD_LEN))
2341 static struct cifs_ses *
2342 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2344 struct cifs_ses *ses;
2346 spin_lock(&cifs_tcp_ses_lock);
2347 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2348 if (ses->status == CifsExiting)
2350 if (!match_session(ses, vol))
2353 spin_unlock(&cifs_tcp_ses_lock);
2356 spin_unlock(&cifs_tcp_ses_lock);
2361 cifs_put_smb_ses(struct cifs_ses *ses)
2363 unsigned int rc, xid;
2364 struct TCP_Server_Info *server = ses->server;
2366 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
2368 spin_lock(&cifs_tcp_ses_lock);
2369 if (ses->status == CifsExiting) {
2370 spin_unlock(&cifs_tcp_ses_lock);
2373 if (--ses->ses_count > 0) {
2374 spin_unlock(&cifs_tcp_ses_lock);
2377 if (ses->status == CifsGood)
2378 ses->status = CifsExiting;
2379 spin_unlock(&cifs_tcp_ses_lock);
2381 if (ses->status == CifsExiting && server->ops->logoff) {
2383 rc = server->ops->logoff(xid, ses);
2385 cifs_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
2390 spin_lock(&cifs_tcp_ses_lock);
2391 list_del_init(&ses->smb_ses_list);
2392 spin_unlock(&cifs_tcp_ses_lock);
2395 cifs_put_tcp_session(server, 0);
2400 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2401 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2403 /* Populate username and pw fields from keyring if possible */
2405 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2408 const char *delim, *payload;
2412 struct TCP_Server_Info *server = ses->server;
2413 struct sockaddr_in *sa;
2414 struct sockaddr_in6 *sa6;
2415 const struct user_key_payload *upayload;
2417 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2421 /* try to find an address key first */
2422 switch (server->dstaddr.ss_family) {
2424 sa = (struct sockaddr_in *)&server->dstaddr;
2425 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2428 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2429 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2432 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2433 server->dstaddr.ss_family);
2438 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2439 key = request_key(&key_type_logon, desc, "");
2441 if (!ses->domainName) {
2442 cifs_dbg(FYI, "domainName is NULL\n");
2447 /* didn't work, try to find a domain key */
2448 sprintf(desc, "cifs:d:%s", ses->domainName);
2449 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2450 key = request_key(&key_type_logon, desc, "");
2457 down_read(&key->sem);
2458 upayload = user_key_payload(key);
2459 if (IS_ERR_OR_NULL(upayload)) {
2460 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2464 /* find first : in payload */
2465 payload = upayload->data;
2466 delim = strnchr(payload, upayload->datalen, ':');
2467 cifs_dbg(FYI, "payload=%s\n", payload);
2469 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
2475 len = delim - payload;
2476 if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
2477 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
2483 vol->username = kstrndup(payload, len, GFP_KERNEL);
2484 if (!vol->username) {
2485 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
2490 cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
2492 len = key->datalen - (len + 1);
2493 if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
2494 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
2496 kfree(vol->username);
2497 vol->username = NULL;
2502 vol->password = kstrndup(delim, len, GFP_KERNEL);
2503 if (!vol->password) {
2504 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
2507 kfree(vol->username);
2508 vol->username = NULL;
2517 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
2520 #else /* ! CONFIG_KEYS */
2522 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2523 struct cifs_ses *ses __attribute__((unused)))
2527 #endif /* CONFIG_KEYS */
2529 static struct cifs_ses *
2530 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2534 struct cifs_ses *ses;
2535 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2536 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2540 ses = cifs_find_smb_ses(server, volume_info);
2542 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
2545 mutex_lock(&ses->session_mutex);
2546 rc = cifs_negotiate_protocol(xid, ses);
2548 mutex_unlock(&ses->session_mutex);
2549 /* problem -- put our ses reference */
2550 cifs_put_smb_ses(ses);
2554 if (ses->need_reconnect) {
2555 cifs_dbg(FYI, "Session needs reconnect\n");
2556 rc = cifs_setup_session(xid, ses,
2557 volume_info->local_nls);
2559 mutex_unlock(&ses->session_mutex);
2560 /* problem -- put our reference */
2561 cifs_put_smb_ses(ses);
2566 mutex_unlock(&ses->session_mutex);
2568 /* existing SMB ses has a server reference already */
2569 cifs_put_tcp_session(server, 0);
2574 cifs_dbg(FYI, "Existing smb sess not found\n");
2575 ses = sesInfoAlloc();
2579 /* new SMB session uses our server ref */
2580 ses->server = server;
2581 if (server->dstaddr.ss_family == AF_INET6)
2582 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2584 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2586 if (volume_info->username) {
2587 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2588 if (!ses->user_name)
2592 /* volume_info->password freed at unmount */
2593 if (volume_info->password) {
2594 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2598 if (volume_info->domainname) {
2599 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2600 if (!ses->domainName)
2603 if (volume_info->domainauto)
2604 ses->domainAuto = volume_info->domainauto;
2605 ses->cred_uid = volume_info->cred_uid;
2606 ses->linux_uid = volume_info->linux_uid;
2608 ses->sectype = volume_info->sectype;
2609 ses->sign = volume_info->sign;
2611 mutex_lock(&ses->session_mutex);
2612 rc = cifs_negotiate_protocol(xid, ses);
2614 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2615 mutex_unlock(&ses->session_mutex);
2619 /* success, put it on the list */
2620 spin_lock(&cifs_tcp_ses_lock);
2621 list_add(&ses->smb_ses_list, &server->smb_ses_list);
2622 spin_unlock(&cifs_tcp_ses_lock);
2633 static int match_tcon(struct cifs_tcon *tcon, struct smb_vol *volume_info)
2635 if (tcon->tidStatus == CifsExiting)
2637 if (strncmp(tcon->treeName, volume_info->UNC, MAX_TREE_SIZE))
2639 if (tcon->seal != volume_info->seal)
2641 #ifdef CONFIG_CIFS_SMB2
2642 if (tcon->snapshot_time != volume_info->snapshot_time)
2644 #endif /* CONFIG_CIFS_SMB2 */
2648 static struct cifs_tcon *
2649 cifs_find_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2651 struct list_head *tmp;
2652 struct cifs_tcon *tcon;
2654 spin_lock(&cifs_tcp_ses_lock);
2655 list_for_each(tmp, &ses->tcon_list) {
2656 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2657 if (!match_tcon(tcon, volume_info))
2660 spin_unlock(&cifs_tcp_ses_lock);
2663 spin_unlock(&cifs_tcp_ses_lock);
2668 cifs_put_tcon(struct cifs_tcon *tcon)
2671 struct cifs_ses *ses = tcon->ses;
2673 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2674 spin_lock(&cifs_tcp_ses_lock);
2675 if (--tcon->tc_count > 0) {
2676 spin_unlock(&cifs_tcp_ses_lock);
2680 list_del_init(&tcon->tcon_list);
2681 spin_unlock(&cifs_tcp_ses_lock);
2684 if (ses->server->ops->tree_disconnect)
2685 ses->server->ops->tree_disconnect(xid, tcon);
2688 cifs_fscache_release_super_cookie(tcon);
2690 cifs_put_smb_ses(ses);
2693 static struct cifs_tcon *
2694 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2697 struct cifs_tcon *tcon;
2699 tcon = cifs_find_tcon(ses, volume_info);
2701 cifs_dbg(FYI, "Found match on UNC path\n");
2702 /* existing tcon already has a reference */
2703 cifs_put_smb_ses(ses);
2707 if (!ses->server->ops->tree_connect) {
2712 tcon = tconInfoAlloc();
2718 if (volume_info->snapshot_time) {
2719 #ifdef CONFIG_CIFS_SMB2
2720 if (ses->server->vals->protocol_id == 0) {
2722 "Use SMB2 or later for snapshot mount option\n");
2726 tcon->snapshot_time = volume_info->snapshot_time;
2728 cifs_dbg(VFS, "Snapshot mount option requires SMB2 support\n");
2731 #endif /* CONFIG_CIFS_SMB2 */
2735 if (volume_info->password) {
2736 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2737 if (!tcon->password) {
2744 * BB Do we need to wrap session_mutex around this TCon call and Unix
2745 * SetFS as we do on SessSetup and reconnect?
2748 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2749 volume_info->local_nls);
2751 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
2755 if (volume_info->nodfs) {
2756 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2757 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
2759 tcon->use_persistent = false;
2760 /* check if SMB2 or later, CIFS does not support persistent handles */
2761 if (volume_info->persistent) {
2762 if (ses->server->vals->protocol_id == 0) {
2764 "SMB3 or later required for persistent handles\n");
2767 #ifdef CONFIG_CIFS_SMB2
2768 } else if (ses->server->capabilities &
2769 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2770 tcon->use_persistent = true;
2771 else /* persistent handles requested but not supported */ {
2773 "Persistent handles not supported on share\n");
2776 #endif /* CONFIG_CIFS_SMB2 */
2778 #ifdef CONFIG_CIFS_SMB2
2779 } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
2780 && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2781 && (volume_info->nopersistent == false)) {
2782 cifs_dbg(FYI, "enabling persistent handles\n");
2783 tcon->use_persistent = true;
2784 #endif /* CONFIG_CIFS_SMB2 */
2785 } else if (volume_info->resilient) {
2786 if (ses->server->vals->protocol_id == 0) {
2788 "SMB2.1 or later required for resilient handles\n");
2792 tcon->use_resilient = true;
2795 if (volume_info->seal) {
2796 if (ses->server->vals->protocol_id == 0) {
2798 "SMB3 or later required for encryption\n");
2801 #ifdef CONFIG_CIFS_SMB2
2802 } else if (tcon->ses->server->capabilities &
2803 SMB2_GLOBAL_CAP_ENCRYPTION)
2806 cifs_dbg(VFS, "Encryption is not supported on share\n");
2809 #endif /* CONFIG_CIFS_SMB2 */
2814 * We can have only one retry value for a connection to a share so for
2815 * resources mounted more than once to the same server share the last
2816 * value passed in for the retry flag is used.
2818 tcon->retry = volume_info->retry;
2819 tcon->nocase = volume_info->nocase;
2820 tcon->local_lease = volume_info->local_lease;
2821 INIT_LIST_HEAD(&tcon->pending_opens);
2823 spin_lock(&cifs_tcp_ses_lock);
2824 list_add(&tcon->tcon_list, &ses->tcon_list);
2825 spin_unlock(&cifs_tcp_ses_lock);
2827 cifs_fscache_get_super_cookie(tcon);
2837 cifs_put_tlink(struct tcon_link *tlink)
2839 if (!tlink || IS_ERR(tlink))
2842 if (!atomic_dec_and_test(&tlink->tl_count) ||
2843 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2844 tlink->tl_time = jiffies;
2848 if (!IS_ERR(tlink_tcon(tlink)))
2849 cifs_put_tcon(tlink_tcon(tlink));
2854 static inline struct tcon_link *
2855 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2857 return cifs_sb->master_tlink;
2861 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2863 struct cifs_sb_info *old = CIFS_SB(sb);
2864 struct cifs_sb_info *new = mnt_data->cifs_sb;
2866 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2869 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2870 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2874 * We want to share sb only if we don't specify an r/wsize or
2875 * specified r/wsize is greater than or equal to existing one.
2877 if (new->wsize && new->wsize < old->wsize)
2880 if (new->rsize && new->rsize < old->rsize)
2883 if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
2886 if (old->mnt_file_mode != new->mnt_file_mode ||
2887 old->mnt_dir_mode != new->mnt_dir_mode)
2890 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2893 if (old->actimeo != new->actimeo)
2900 match_prepath(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2902 struct cifs_sb_info *old = CIFS_SB(sb);
2903 struct cifs_sb_info *new = mnt_data->cifs_sb;
2905 if (old->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) {
2906 if (!(new->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH))
2908 /* The prepath should be null terminated strings */
2909 if (strcmp(new->prepath, old->prepath))
2918 cifs_match_super(struct super_block *sb, void *data)
2920 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2921 struct smb_vol *volume_info;
2922 struct cifs_sb_info *cifs_sb;
2923 struct TCP_Server_Info *tcp_srv;
2924 struct cifs_ses *ses;
2925 struct cifs_tcon *tcon;
2926 struct tcon_link *tlink;
2929 spin_lock(&cifs_tcp_ses_lock);
2930 cifs_sb = CIFS_SB(sb);
2931 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2932 if (IS_ERR(tlink)) {
2933 spin_unlock(&cifs_tcp_ses_lock);
2936 tcon = tlink_tcon(tlink);
2938 tcp_srv = ses->server;
2940 volume_info = mnt_data->vol;
2942 if (!match_server(tcp_srv, volume_info) ||
2943 !match_session(ses, volume_info) ||
2944 !match_tcon(tcon, volume_info) ||
2945 !match_prepath(sb, mnt_data)) {
2950 rc = compare_mount_options(sb, mnt_data);
2952 spin_unlock(&cifs_tcp_ses_lock);
2953 cifs_put_tlink(tlink);
2958 get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
2959 const struct nls_table *nls_codepage, unsigned int *num_referrals,
2960 struct dfs_info3_param **referrals, int remap)
2965 if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
2971 if (ses->ipc_tid == 0) {
2972 temp_unc = kmalloc(2 /* for slashes */ +
2973 strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2974 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
2975 if (temp_unc == NULL)
2979 strcpy(temp_unc + 2, ses->serverName);
2980 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2981 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2983 cifs_dbg(FYI, "Tcon rc = %d ipc_tid = %d\n", rc, ses->ipc_tid);
2987 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
2988 referrals, num_referrals,
2989 nls_codepage, remap);
2991 * BB - map targetUNCs to dfs_info3 structures, here or in
2992 * ses->server->ops->get_dfs_refer.
2998 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2999 static struct lock_class_key cifs_key[2];
3000 static struct lock_class_key cifs_slock_key[2];
3003 cifs_reclassify_socket4(struct socket *sock)
3005 struct sock *sk = sock->sk;
3006 BUG_ON(!sock_allow_reclassification(sk));
3007 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
3008 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
3012 cifs_reclassify_socket6(struct socket *sock)
3014 struct sock *sk = sock->sk;
3015 BUG_ON(!sock_allow_reclassification(sk));
3016 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
3017 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
3021 cifs_reclassify_socket4(struct socket *sock)
3026 cifs_reclassify_socket6(struct socket *sock)
3031 /* See RFC1001 section 14 on representation of Netbios names */
3032 static void rfc1002mangle(char *target, char *source, unsigned int length)
3036 for (i = 0, j = 0; i < (length); i++) {
3037 /* mask a nibble at a time and encode */
3038 target[j] = 'A' + (0x0F & (source[i] >> 4));
3039 target[j+1] = 'A' + (0x0F & source[i]);
3046 bind_socket(struct TCP_Server_Info *server)
3049 if (server->srcaddr.ss_family != AF_UNSPEC) {
3050 /* Bind to the specified local IP address */
3051 struct socket *socket = server->ssocket;
3052 rc = socket->ops->bind(socket,
3053 (struct sockaddr *) &server->srcaddr,
3054 sizeof(server->srcaddr));
3056 struct sockaddr_in *saddr4;
3057 struct sockaddr_in6 *saddr6;
3058 saddr4 = (struct sockaddr_in *)&server->srcaddr;
3059 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
3060 if (saddr6->sin6_family == AF_INET6)
3061 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
3062 &saddr6->sin6_addr, rc);
3064 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
3065 &saddr4->sin_addr.s_addr, rc);
3072 ip_rfc1001_connect(struct TCP_Server_Info *server)
3076 * some servers require RFC1001 sessinit before sending
3077 * negprot - BB check reconnection in case where second
3078 * sessinit is sent but no second negprot
3080 struct rfc1002_session_packet *ses_init_buf;
3081 struct smb_hdr *smb_buf;
3082 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
3085 ses_init_buf->trailer.session_req.called_len = 32;
3087 if (server->server_RFC1001_name[0] != 0)
3088 rfc1002mangle(ses_init_buf->trailer.
3089 session_req.called_name,
3090 server->server_RFC1001_name,
3091 RFC1001_NAME_LEN_WITH_NULL);
3093 rfc1002mangle(ses_init_buf->trailer.
3094 session_req.called_name,
3095 DEFAULT_CIFS_CALLED_NAME,
3096 RFC1001_NAME_LEN_WITH_NULL);
3098 ses_init_buf->trailer.session_req.calling_len = 32;
3101 * calling name ends in null (byte 16) from old smb
3104 if (server->workstation_RFC1001_name[0] != 0)
3105 rfc1002mangle(ses_init_buf->trailer.
3106 session_req.calling_name,
3107 server->workstation_RFC1001_name,
3108 RFC1001_NAME_LEN_WITH_NULL);
3110 rfc1002mangle(ses_init_buf->trailer.
3111 session_req.calling_name,
3113 RFC1001_NAME_LEN_WITH_NULL);
3115 ses_init_buf->trailer.session_req.scope1 = 0;
3116 ses_init_buf->trailer.session_req.scope2 = 0;
3117 smb_buf = (struct smb_hdr *)ses_init_buf;
3119 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3120 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3121 rc = smb_send(server, smb_buf, 0x44);
3122 kfree(ses_init_buf);
3124 * RFC1001 layer in at least one server
3125 * requires very short break before negprot
3126 * presumably because not expecting negprot
3127 * to follow so fast. This is a simple
3128 * solution that works without
3129 * complicating the code and causes no
3130 * significant slowing down on mount
3133 usleep_range(1000, 2000);
3136 * else the negprot may still work without this
3137 * even though malloc failed
3144 generic_ip_connect(struct TCP_Server_Info *server)
3149 struct socket *socket = server->ssocket;
3150 struct sockaddr *saddr;
3152 saddr = (struct sockaddr *) &server->dstaddr;
3154 if (server->dstaddr.ss_family == AF_INET6) {
3155 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3156 slen = sizeof(struct sockaddr_in6);
3159 sport = ((struct sockaddr_in *) saddr)->sin_port;
3160 slen = sizeof(struct sockaddr_in);
3164 if (socket == NULL) {
3165 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3166 IPPROTO_TCP, &socket, 1);
3168 cifs_dbg(VFS, "Error %d creating socket\n", rc);
3169 server->ssocket = NULL;
3173 /* BB other socket options to set KEEPALIVE, NODELAY? */
3174 cifs_dbg(FYI, "Socket created\n");
3175 server->ssocket = socket;
3176 socket->sk->sk_allocation = GFP_NOFS;
3177 if (sfamily == AF_INET6)
3178 cifs_reclassify_socket6(socket);
3180 cifs_reclassify_socket4(socket);
3183 rc = bind_socket(server);
3188 * Eventually check for other socket options to change from
3189 * the default. sock_setsockopt not used because it expects
3192 socket->sk->sk_rcvtimeo = 7 * HZ;
3193 socket->sk->sk_sndtimeo = 5 * HZ;
3195 /* make the bufsizes depend on wsize/rsize and max requests */
3196 if (server->noautotune) {
3197 if (socket->sk->sk_sndbuf < (200 * 1024))
3198 socket->sk->sk_sndbuf = 200 * 1024;
3199 if (socket->sk->sk_rcvbuf < (140 * 1024))
3200 socket->sk->sk_rcvbuf = 140 * 1024;
3203 if (server->tcp_nodelay) {
3205 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3206 (char *)&val, sizeof(val));
3208 cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3212 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3213 socket->sk->sk_sndbuf,
3214 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3216 rc = socket->ops->connect(socket, saddr, slen, 0);
3218 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3219 sock_release(socket);
3220 server->ssocket = NULL;
3224 if (sport == htons(RFC1001_PORT))
3225 rc = ip_rfc1001_connect(server);
3231 ip_connect(struct TCP_Server_Info *server)
3234 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3235 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3237 if (server->dstaddr.ss_family == AF_INET6)
3238 sport = &addr6->sin6_port;
3240 sport = &addr->sin_port;
3245 /* try with 445 port at first */
3246 *sport = htons(CIFS_PORT);
3248 rc = generic_ip_connect(server);
3252 /* if it failed, try with 139 port */
3253 *sport = htons(RFC1001_PORT);
3256 return generic_ip_connect(server);
3259 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3260 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3262 /* if we are reconnecting then should we check to see if
3263 * any requested capabilities changed locally e.g. via
3264 * remount but we can not do much about it here
3265 * if they have (even if we could detect it by the following)
3266 * Perhaps we could add a backpointer to array of sb from tcon
3267 * or if we change to make all sb to same share the same
3268 * sb as NFS - then we only have one backpointer to sb.
3269 * What if we wanted to mount the server share twice once with
3270 * and once without posixacls or posix paths? */
3271 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3273 if (vol_info && vol_info->no_linux_ext) {
3274 tcon->fsUnixInfo.Capability = 0;
3275 tcon->unix_ext = 0; /* Unix Extensions disabled */
3276 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
3278 } else if (vol_info)
3279 tcon->unix_ext = 1; /* Unix Extensions supported */
3281 if (tcon->unix_ext == 0) {
3282 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
3286 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3287 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3288 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
3289 /* check for reconnect case in which we do not
3290 want to change the mount behavior if we can avoid it */
3291 if (vol_info == NULL) {
3292 /* turn off POSIX ACL and PATHNAMES if not set
3293 originally at mount time */
3294 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3295 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3296 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3297 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3298 cifs_dbg(VFS, "POSIXPATH support change\n");
3299 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3300 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3301 cifs_dbg(VFS, "possible reconnect error\n");
3302 cifs_dbg(VFS, "server disabled POSIX path support\n");
3306 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3307 cifs_dbg(VFS, "per-share encryption not supported yet\n");
3309 cap &= CIFS_UNIX_CAP_MASK;
3310 if (vol_info && vol_info->no_psx_acl)
3311 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3312 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3313 cifs_dbg(FYI, "negotiated posix acl support\n");
3315 cifs_sb->mnt_cifs_flags |=
3316 CIFS_MOUNT_POSIXACL;
3319 if (vol_info && vol_info->posix_paths == 0)
3320 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3321 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3322 cifs_dbg(FYI, "negotiate posix pathnames\n");
3324 cifs_sb->mnt_cifs_flags |=
3325 CIFS_MOUNT_POSIX_PATHS;
3328 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
3329 #ifdef CONFIG_CIFS_DEBUG2
3330 if (cap & CIFS_UNIX_FCNTL_CAP)
3331 cifs_dbg(FYI, "FCNTL cap\n");
3332 if (cap & CIFS_UNIX_EXTATTR_CAP)
3333 cifs_dbg(FYI, "EXTATTR cap\n");
3334 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3335 cifs_dbg(FYI, "POSIX path cap\n");
3336 if (cap & CIFS_UNIX_XATTR_CAP)
3337 cifs_dbg(FYI, "XATTR cap\n");
3338 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3339 cifs_dbg(FYI, "POSIX ACL cap\n");
3340 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3341 cifs_dbg(FYI, "very large read cap\n");
3342 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3343 cifs_dbg(FYI, "very large write cap\n");
3344 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3345 cifs_dbg(FYI, "transport encryption cap\n");
3346 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3347 cifs_dbg(FYI, "mandatory transport encryption cap\n");
3348 #endif /* CIFS_DEBUG2 */
3349 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3350 if (vol_info == NULL) {
3351 cifs_dbg(FYI, "resetting capabilities failed\n");
3353 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");
3359 int cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3360 struct cifs_sb_info *cifs_sb)
3362 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3364 spin_lock_init(&cifs_sb->tlink_tree_lock);
3365 cifs_sb->tlink_tree = RB_ROOT;
3368 * Temporarily set r/wsize for matching superblock. If we end up using
3369 * new sb then client will later negotiate it downward if needed.
3371 cifs_sb->rsize = pvolume_info->rsize;
3372 cifs_sb->wsize = pvolume_info->wsize;
3374 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3375 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3376 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3377 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3378 cifs_dbg(FYI, "file mode: 0x%hx dir mode: 0x%hx\n",
3379 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3381 cifs_sb->actimeo = pvolume_info->actimeo;
3382 cifs_sb->local_nls = pvolume_info->local_nls;
3384 if (pvolume_info->noperm)
3385 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3386 if (pvolume_info->setuids)
3387 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3388 if (pvolume_info->setuidfromacl)
3389 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
3390 if (pvolume_info->server_ino)
3391 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3392 if (pvolume_info->remap)
3393 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3394 if (pvolume_info->sfu_remap)
3395 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3396 if (pvolume_info->no_xattr)
3397 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3398 if (pvolume_info->sfu_emul)
3399 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3400 if (pvolume_info->nobrl)
3401 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3402 if (pvolume_info->nostrictsync)
3403 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3404 if (pvolume_info->mand_lock)
3405 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3406 if (pvolume_info->rwpidforward)
3407 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3408 if (pvolume_info->cifs_acl)
3409 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3410 if (pvolume_info->backupuid_specified) {
3411 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3412 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3414 if (pvolume_info->backupgid_specified) {
3415 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3416 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3418 if (pvolume_info->override_uid)
3419 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3420 if (pvolume_info->override_gid)
3421 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3422 if (pvolume_info->dynperm)
3423 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3424 if (pvolume_info->fsc)
3425 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3426 if (pvolume_info->multiuser)
3427 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3428 CIFS_MOUNT_NO_PERM);
3429 if (pvolume_info->strict_io)
3430 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3431 if (pvolume_info->direct_io) {
3432 cifs_dbg(FYI, "mounting share using direct i/o\n");
3433 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3435 if (pvolume_info->mfsymlinks) {
3436 if (pvolume_info->sfu_emul) {
3438 * Our SFU ("Services for Unix" emulation does not allow
3439 * creating symlinks but does allow reading existing SFU
3440 * symlinks (it does allow both creating and reading SFU
3441 * style mknod and FIFOs though). When "mfsymlinks" and
3442 * "sfu" are both enabled at the same time, it allows
3443 * reading both types of symlinks, but will only create
3444 * them with mfsymlinks format. This allows better
3445 * Apple compatibility (probably better for Samba too)
3446 * while still recognizing old Windows style symlinks.
3448 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
3450 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3453 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3454 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
3456 if (pvolume_info->prepath) {
3457 cifs_sb->prepath = kstrdup(pvolume_info->prepath, GFP_KERNEL);
3458 if (cifs_sb->prepath == NULL)
3466 cleanup_volume_info_contents(struct smb_vol *volume_info)
3468 kfree(volume_info->username);
3469 kzfree(volume_info->password);
3470 kfree(volume_info->UNC);
3471 kfree(volume_info->domainname);
3472 kfree(volume_info->iocharset);
3473 kfree(volume_info->prepath);
3477 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3481 cleanup_volume_info_contents(volume_info);
3486 #ifdef CONFIG_CIFS_DFS_UPCALL
3488 * cifs_build_path_to_root returns full path to root when we do not have an
3489 * exiting connection (tcon)
3492 build_unc_path_to_root(const struct smb_vol *vol,
3493 const struct cifs_sb_info *cifs_sb)
3495 char *full_path, *pos;
3496 unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
3497 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3499 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3500 if (full_path == NULL)
3501 return ERR_PTR(-ENOMEM);
3503 strncpy(full_path, vol->UNC, unc_len);
3504 pos = full_path + unc_len;
3507 *pos = CIFS_DIR_SEP(cifs_sb);
3508 strncpy(pos + 1, vol->prepath, pplen);
3512 *pos = '\0'; /* add trailing null */
3513 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3514 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
3519 * Perform a dfs referral query for a share and (optionally) prefix
3521 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3522 * to a string containing updated options for the submount. Otherwise it
3523 * will be left untouched.
3525 * Returns the rc from get_dfs_path to the caller, which can be used to
3526 * determine whether there were referrals.
3529 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
3530 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3534 unsigned int num_referrals = 0;
3535 struct dfs_info3_param *referrals = NULL;
3536 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3538 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3539 if (IS_ERR(full_path))
3540 return PTR_ERR(full_path);
3542 /* For DFS paths, skip the first '\' of the UNC */
3543 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3545 rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
3546 &num_referrals, &referrals, cifs_remap(cifs_sb));
3548 if (!rc && num_referrals > 0) {
3549 char *fake_devname = NULL;
3551 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3552 full_path + 1, referrals,
3555 free_dfs_info_array(referrals, num_referrals);
3557 if (IS_ERR(mdata)) {
3558 rc = PTR_ERR(mdata);
3561 cleanup_volume_info_contents(volume_info);
3562 rc = cifs_setup_volume_info(volume_info, mdata,
3565 kfree(fake_devname);
3566 kfree(cifs_sb->mountdata);
3567 cifs_sb->mountdata = mdata;
3575 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3576 const char *devname)
3580 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3583 if (volume_info->nullauth) {
3584 cifs_dbg(FYI, "Anonymous login\n");
3585 kfree(volume_info->username);
3586 volume_info->username = NULL;
3587 } else if (volume_info->username) {
3588 /* BB fixme parse for domain name here */
3589 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
3591 cifs_dbg(VFS, "No username specified\n");
3592 /* In userspace mount helper we can get user name from alternate
3593 locations such as env variables and files on disk */
3597 /* this is needed for ASCII cp to Unicode converts */
3598 if (volume_info->iocharset == NULL) {
3599 /* load_nls_default cannot return null */
3600 volume_info->local_nls = load_nls_default();
3602 volume_info->local_nls = load_nls(volume_info->iocharset);
3603 if (volume_info->local_nls == NULL) {
3604 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
3605 volume_info->iocharset);
3614 cifs_get_volume_info(char *mount_data, const char *devname)
3617 struct smb_vol *volume_info;
3619 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
3621 return ERR_PTR(-ENOMEM);
3623 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3625 cifs_cleanup_volume_info(volume_info);
3626 volume_info = ERR_PTR(rc);
3633 cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
3635 struct cifs_tcon *tcon,
3636 struct cifs_sb_info *cifs_sb,
3643 sep = CIFS_DIR_SEP(cifs_sb);
3646 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
3648 /* skip separators */
3653 /* next separator */
3654 while (*s && *s != sep)
3658 * temporarily null-terminate the path at the end of
3659 * the current component
3663 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3671 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3675 struct cifs_ses *ses;
3676 struct cifs_tcon *tcon;
3677 struct TCP_Server_Info *server;
3679 struct tcon_link *tlink;
3680 #ifdef CONFIG_CIFS_DFS_UPCALL
3681 int referral_walks_count = 0;
3684 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs");
3688 #ifdef CONFIG_CIFS_DFS_UPCALL
3690 /* cleanup activities if we're chasing a referral */
3691 if (referral_walks_count) {
3693 cifs_put_tcon(tcon);
3695 cifs_put_smb_ses(ses);
3697 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
3711 /* get a reference to a tcp session */
3712 server = cifs_get_tcp_session(volume_info);
3713 if (IS_ERR(server)) {
3714 rc = PTR_ERR(server);
3715 bdi_destroy(&cifs_sb->bdi);
3718 if ((volume_info->max_credits < 20) ||
3719 (volume_info->max_credits > 60000))
3720 server->max_credits = SMB2_MAX_CREDITS_AVAILABLE;
3722 server->max_credits = volume_info->max_credits;
3723 /* get a reference to a SMB session */
3724 ses = cifs_get_smb_ses(server, volume_info);
3728 goto mount_fail_check;
3731 #ifdef CONFIG_CIFS_SMB2
3732 if ((volume_info->persistent == true) && ((ses->server->capabilities &
3733 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES) == 0)) {
3734 cifs_dbg(VFS, "persistent handles not supported by server\n");
3736 goto mount_fail_check;
3738 #endif /* CONFIG_CIFS_SMB2*/
3740 /* search for existing tcon to this server share */
3741 tcon = cifs_get_tcon(ses, volume_info);
3745 goto remote_path_check;
3748 /* tell server which Unix caps we support */
3749 if (cap_unix(tcon->ses)) {
3750 /* reset of caps checks mount to see if unix extensions
3751 disabled for just this mount */
3752 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3753 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3754 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3755 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3757 goto mount_fail_check;
3760 tcon->unix_ext = 0; /* server does not support them */
3762 /* do not care if a following call succeed - informational */
3763 if (!tcon->ipc && server->ops->qfs_tcon)
3764 server->ops->qfs_tcon(xid, tcon);
3766 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3767 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
3769 /* tune readahead according to rsize */
3770 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_SIZE;
3773 #ifdef CONFIG_CIFS_DFS_UPCALL
3775 * Perform an unconditional check for whether there are DFS
3776 * referrals for this path without prefix, to provide support
3777 * for DFS referrals from w2k8 servers which don't seem to respond
3778 * with PATH_NOT_COVERED to requests that include the prefix.
3779 * Chase the referral if found, otherwise continue normally.
3781 if (referral_walks_count == 0) {
3782 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3785 referral_walks_count++;
3786 goto try_mount_again;
3791 /* check if a whole path is not remote */
3793 if (!server->ops->is_path_accessible) {
3795 goto mount_fail_check;
3798 * cifs_build_path_to_root works only when we have a valid tcon
3800 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon,
3801 tcon->Flags & SMB_SHARE_IS_IN_DFS);
3802 if (full_path == NULL) {
3804 goto mount_fail_check;
3806 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3808 if (rc != 0 && rc != -EREMOTE) {
3810 goto mount_fail_check;
3813 if (rc != -EREMOTE) {
3814 rc = cifs_are_all_path_components_accessible(server,
3818 cifs_dbg(VFS, "cannot query dirs between root and final path, "
3819 "enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
3820 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
3827 /* get referral if needed */
3828 if (rc == -EREMOTE) {
3829 #ifdef CONFIG_CIFS_DFS_UPCALL
3830 if (referral_walks_count > MAX_NESTED_LINKS) {
3832 * BB: when we implement proper loop detection,
3833 * we will remove this check. But now we need it
3834 * to prevent an indefinite loop if 'DFS tree' is
3835 * misconfigured (i.e. has loops).
3838 goto mount_fail_check;
3841 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
3844 referral_walks_count++;
3845 goto try_mount_again;
3847 goto mount_fail_check;
3848 #else /* No DFS support, return error on mount */
3854 goto mount_fail_check;
3856 /* now, hang the tcon off of the superblock */
3857 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3858 if (tlink == NULL) {
3860 goto mount_fail_check;
3863 tlink->tl_uid = ses->linux_uid;
3864 tlink->tl_tcon = tcon;
3865 tlink->tl_time = jiffies;
3866 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3867 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3869 cifs_sb->master_tlink = tlink;
3870 spin_lock(&cifs_sb->tlink_tree_lock);
3871 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3872 spin_unlock(&cifs_sb->tlink_tree_lock);
3874 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3878 /* on error free sesinfo and tcon struct if needed */
3880 /* If find_unc succeeded then rc == 0 so we can not end */
3881 /* up accidentally freeing someone elses tcon struct */
3883 cifs_put_tcon(tcon);
3885 cifs_put_smb_ses(ses);
3887 cifs_put_tcp_session(server, 0);
3888 bdi_destroy(&cifs_sb->bdi);
3897 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3898 * pointer may be NULL.
3901 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
3902 const char *tree, struct cifs_tcon *tcon,
3903 const struct nls_table *nls_codepage)
3905 struct smb_hdr *smb_buffer;
3906 struct smb_hdr *smb_buffer_response;
3909 unsigned char *bcc_ptr;
3912 __u16 bytes_left, count;
3917 smb_buffer = cifs_buf_get();
3918 if (smb_buffer == NULL)
3921 smb_buffer_response = smb_buffer;
3923 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3924 NULL /*no tid */ , 4 /*wct */ );
3926 smb_buffer->Mid = get_next_mid(ses->server);
3927 smb_buffer->Uid = ses->Suid;
3928 pSMB = (TCONX_REQ *) smb_buffer;
3929 pSMBr = (TCONX_RSP *) smb_buffer_response;
3931 pSMB->AndXCommand = 0xFF;
3932 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3933 bcc_ptr = &pSMB->Password[0];
3934 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3935 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3936 *bcc_ptr = 0; /* password is null byte */
3937 bcc_ptr++; /* skip password */
3938 /* already aligned so no need to do it below */
3940 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3941 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3942 specified as required (when that support is added to
3943 the vfs in the future) as only NTLM or the much
3944 weaker LANMAN (which we do not send by default) is accepted
3945 by Samba (not sure whether other servers allow
3946 NTLMv2 password here) */
3947 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3948 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3949 (ses->sectype == LANMAN))
3950 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3951 ses->server->sec_mode &
3952 SECMODE_PW_ENCRYPT ? true : false,
3955 #endif /* CIFS_WEAK_PW_HASH */
3956 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3957 bcc_ptr, nls_codepage);
3959 cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
3961 cifs_buf_release(smb_buffer);
3965 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3966 if (ses->capabilities & CAP_UNICODE) {
3967 /* must align unicode strings */
3968 *bcc_ptr = 0; /* null byte password */
3973 if (ses->server->sign)
3974 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3976 if (ses->capabilities & CAP_STATUS32) {
3977 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3979 if (ses->capabilities & CAP_DFS) {
3980 smb_buffer->Flags2 |= SMBFLG2_DFS;
3982 if (ses->capabilities & CAP_UNICODE) {
3983 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3985 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3986 6 /* max utf8 char length in bytes */ *
3987 (/* server len*/ + 256 /* share len */), nls_codepage);
3988 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3989 bcc_ptr += 2; /* skip trailing null */
3990 } else { /* ASCII */
3991 strcpy(bcc_ptr, tree);
3992 bcc_ptr += strlen(tree) + 1;
3994 strcpy(bcc_ptr, "?????");
3995 bcc_ptr += strlen("?????");
3997 count = bcc_ptr - &pSMB->Password[0];
3998 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3999 pSMB->hdr.smb_buf_length) + count);
4000 pSMB->ByteCount = cpu_to_le16(count);
4002 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
4005 /* above now done in SendReceive */
4006 if ((rc == 0) && (tcon != NULL)) {
4009 tcon->tidStatus = CifsGood;
4010 tcon->need_reconnect = false;
4011 tcon->tid = smb_buffer_response->Tid;
4012 bcc_ptr = pByteArea(smb_buffer_response);
4013 bytes_left = get_bcc(smb_buffer_response);
4014 length = strnlen(bcc_ptr, bytes_left - 2);
4015 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
4021 /* skip service field (NB: this field is always ASCII) */
4023 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
4024 (bcc_ptr[2] == 'C')) {
4025 cifs_dbg(FYI, "IPC connection\n");
4028 } else if (length == 2) {
4029 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
4030 /* the most common case */
4031 cifs_dbg(FYI, "disk share connection\n");
4034 bcc_ptr += length + 1;
4035 bytes_left -= (length + 1);
4036 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
4038 /* mostly informational -- no need to fail on error here */
4039 kfree(tcon->nativeFileSystem);
4040 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
4041 bytes_left, is_unicode,
4044 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
4046 if ((smb_buffer_response->WordCount == 3) ||
4047 (smb_buffer_response->WordCount == 7))
4048 /* field is in same location */
4049 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
4052 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
4053 } else if ((rc == 0) && tcon == NULL) {
4054 /* all we need to save for IPC$ connection */
4055 ses->ipc_tid = smb_buffer_response->Tid;
4058 cifs_buf_release(smb_buffer);
4062 static void delayed_free(struct rcu_head *p)
4064 struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
4065 unload_nls(sbi->local_nls);
4070 cifs_umount(struct cifs_sb_info *cifs_sb)
4072 struct rb_root *root = &cifs_sb->tlink_tree;
4073 struct rb_node *node;
4074 struct tcon_link *tlink;
4076 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
4078 spin_lock(&cifs_sb->tlink_tree_lock);
4079 while ((node = rb_first(root))) {
4080 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4081 cifs_get_tlink(tlink);
4082 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4083 rb_erase(node, root);
4085 spin_unlock(&cifs_sb->tlink_tree_lock);
4086 cifs_put_tlink(tlink);
4087 spin_lock(&cifs_sb->tlink_tree_lock);
4089 spin_unlock(&cifs_sb->tlink_tree_lock);
4091 bdi_destroy(&cifs_sb->bdi);
4092 kfree(cifs_sb->mountdata);
4093 kfree(cifs_sb->prepath);
4094 call_rcu(&cifs_sb->rcu, delayed_free);
4098 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
4101 struct TCP_Server_Info *server = ses->server;
4103 if (!server->ops->need_neg || !server->ops->negotiate)
4106 /* only send once per connect */
4107 if (!server->ops->need_neg(server))
4110 set_credits(server, 1);
4112 rc = server->ops->negotiate(xid, ses);
4114 spin_lock(&GlobalMid_Lock);
4115 if (server->tcpStatus == CifsNeedNegotiate)
4116 server->tcpStatus = CifsGood;
4119 spin_unlock(&GlobalMid_Lock);
4126 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
4127 struct nls_table *nls_info)
4130 struct TCP_Server_Info *server = ses->server;
4132 ses->capabilities = server->capabilities;
4133 if (linuxExtEnabled == 0)
4134 ses->capabilities &= (~server->vals->cap_unix);
4136 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
4137 server->sec_mode, server->capabilities, server->timeAdj);
4139 if (server->ops->sess_setup)
4140 rc = server->ops->sess_setup(xid, ses, nls_info);
4143 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
4149 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
4151 vol->sectype = ses->sectype;
4153 /* krb5 is special, since we don't need username or pw */
4154 if (vol->sectype == Kerberos)
4157 return cifs_set_cifscreds(vol, ses);
4160 static struct cifs_tcon *
4161 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
4164 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4165 struct cifs_ses *ses;
4166 struct cifs_tcon *tcon = NULL;
4167 struct smb_vol *vol_info;
4169 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
4170 if (vol_info == NULL)
4171 return ERR_PTR(-ENOMEM);
4173 vol_info->local_nls = cifs_sb->local_nls;
4174 vol_info->linux_uid = fsuid;
4175 vol_info->cred_uid = fsuid;
4176 vol_info->UNC = master_tcon->treeName;
4177 vol_info->retry = master_tcon->retry;
4178 vol_info->nocase = master_tcon->nocase;
4179 vol_info->local_lease = master_tcon->local_lease;
4180 vol_info->no_linux_ext = !master_tcon->unix_ext;
4181 vol_info->sectype = master_tcon->ses->sectype;
4182 vol_info->sign = master_tcon->ses->sign;
4184 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4190 /* get a reference for the same TCP session */
4191 spin_lock(&cifs_tcp_ses_lock);
4192 ++master_tcon->ses->server->srv_count;
4193 spin_unlock(&cifs_tcp_ses_lock);
4195 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4197 tcon = (struct cifs_tcon *)ses;
4198 cifs_put_tcp_session(master_tcon->ses->server, 0);
4202 tcon = cifs_get_tcon(ses, vol_info);
4204 cifs_put_smb_ses(ses);
4209 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4211 kfree(vol_info->username);
4212 kfree(vol_info->password);
4219 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4221 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4224 /* find and return a tlink with given uid */
4225 static struct tcon_link *
4226 tlink_rb_search(struct rb_root *root, kuid_t uid)
4228 struct rb_node *node = root->rb_node;
4229 struct tcon_link *tlink;
4232 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4234 if (uid_gt(tlink->tl_uid, uid))
4235 node = node->rb_left;
4236 else if (uid_lt(tlink->tl_uid, uid))
4237 node = node->rb_right;
4244 /* insert a tcon_link into the tree */
4246 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4248 struct rb_node **new = &(root->rb_node), *parent = NULL;
4249 struct tcon_link *tlink;
4252 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4255 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
4256 new = &((*new)->rb_left);
4258 new = &((*new)->rb_right);
4261 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4262 rb_insert_color(&new_tlink->tl_rbnode, root);
4266 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4269 * If the superblock doesn't refer to a multiuser mount, then just return
4270 * the master tcon for the mount.
4272 * First, search the rbtree for an existing tcon for this fsuid. If one
4273 * exists, then check to see if it's pending construction. If it is then wait
4274 * for construction to complete. Once it's no longer pending, check to see if
4275 * it failed and either return an error or retry construction, depending on
4278 * If one doesn't exist then insert a new tcon_link struct into the tree and
4279 * try to construct a new one.
4282 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4285 kuid_t fsuid = current_fsuid();
4286 struct tcon_link *tlink, *newtlink;
4288 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4289 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4291 spin_lock(&cifs_sb->tlink_tree_lock);
4292 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4294 cifs_get_tlink(tlink);
4295 spin_unlock(&cifs_sb->tlink_tree_lock);
4297 if (tlink == NULL) {
4298 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4299 if (newtlink == NULL)
4300 return ERR_PTR(-ENOMEM);
4301 newtlink->tl_uid = fsuid;
4302 newtlink->tl_tcon = ERR_PTR(-EACCES);
4303 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4304 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4305 cifs_get_tlink(newtlink);
4307 spin_lock(&cifs_sb->tlink_tree_lock);
4308 /* was one inserted after previous search? */
4309 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4311 cifs_get_tlink(tlink);
4312 spin_unlock(&cifs_sb->tlink_tree_lock);
4314 goto wait_for_construction;
4317 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4318 spin_unlock(&cifs_sb->tlink_tree_lock);
4320 wait_for_construction:
4321 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4322 TASK_INTERRUPTIBLE);
4324 cifs_put_tlink(tlink);
4325 return ERR_PTR(-ERESTARTSYS);
4328 /* if it's good, return it */
4329 if (!IS_ERR(tlink->tl_tcon))
4332 /* return error if we tried this already recently */
4333 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4334 cifs_put_tlink(tlink);
4335 return ERR_PTR(-EACCES);
4338 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4339 goto wait_for_construction;
4342 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4343 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4344 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4346 if (IS_ERR(tlink->tl_tcon)) {
4347 cifs_put_tlink(tlink);
4348 return ERR_PTR(-EACCES);
4355 * periodic workqueue job that scans tcon_tree for a superblock and closes
4359 cifs_prune_tlinks(struct work_struct *work)
4361 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4363 struct rb_root *root = &cifs_sb->tlink_tree;
4364 struct rb_node *node = rb_first(root);
4365 struct rb_node *tmp;
4366 struct tcon_link *tlink;
4369 * Because we drop the spinlock in the loop in order to put the tlink
4370 * it's not guarded against removal of links from the tree. The only
4371 * places that remove entries from the tree are this function and
4372 * umounts. Because this function is non-reentrant and is canceled
4373 * before umount can proceed, this is safe.
4375 spin_lock(&cifs_sb->tlink_tree_lock);
4376 node = rb_first(root);
4377 while (node != NULL) {
4379 node = rb_next(tmp);
4380 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4382 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4383 atomic_read(&tlink->tl_count) != 0 ||
4384 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4387 cifs_get_tlink(tlink);
4388 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4389 rb_erase(tmp, root);
4391 spin_unlock(&cifs_sb->tlink_tree_lock);
4392 cifs_put_tlink(tlink);
4393 spin_lock(&cifs_sb->tlink_tree_lock);
4395 spin_unlock(&cifs_sb->tlink_tree_lock);
4397 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,