4 * Copyright (C) International Business Machines Corp., 2002,2011
5 * Author(s): Steve French (sfrench@us.ibm.com)
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/net.h>
23 #include <linux/string.h>
24 #include <linux/list.h>
25 #include <linux/wait.h>
26 #include <linux/slab.h>
27 #include <linux/pagemap.h>
28 #include <linux/ctype.h>
29 #include <linux/utsname.h>
30 #include <linux/mempool.h>
31 #include <linux/delay.h>
32 #include <linux/completion.h>
33 #include <linux/kthread.h>
34 #include <linux/pagevec.h>
35 #include <linux/freezer.h>
36 #include <linux/namei.h>
37 #include <asm/uaccess.h>
38 #include <asm/processor.h>
39 #include <linux/inet.h>
40 #include <linux/module.h>
41 #include <keys/user-type.h>
43 #include <linux/parser.h>
47 #include "cifsproto.h"
48 #include "cifs_unicode.h"
49 #include "cifs_debug.h"
50 #include "cifs_fs_sb.h"
53 #include "rfc1002pdu.h"
57 #define RFC1001_PORT 139
59 extern mempool_t *cifs_req_poolp;
61 /* FIXME: should these be tunable? */
62 #define TLINK_ERROR_EXPIRE (1 * HZ)
63 #define TLINK_IDLE_EXPIRE (600 * HZ)
66 /* Mount options that take no arguments */
67 Opt_user_xattr, Opt_nouser_xattr,
68 Opt_forceuid, Opt_noforceuid,
69 Opt_forcegid, Opt_noforcegid,
70 Opt_noblocksend, Opt_noautotune,
71 Opt_hard, Opt_soft, Opt_perm, Opt_noperm,
72 Opt_mapposix, Opt_nomapposix,
73 Opt_mapchars, Opt_nomapchars, Opt_sfu,
74 Opt_nosfu, Opt_nodfs, Opt_posixpaths,
75 Opt_noposixpaths, Opt_nounix,
78 Opt_forcemandatorylock, Opt_setuids,
79 Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
80 Opt_nohard, Opt_nosoft,
82 Opt_nostrictsync, Opt_strictsync,
83 Opt_serverino, Opt_noserverino,
84 Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
85 Opt_acl, Opt_noacl, Opt_locallease,
86 Opt_sign, Opt_seal, Opt_noac,
87 Opt_fsc, Opt_mfsymlinks,
88 Opt_multiuser, Opt_sloppy, Opt_nosharesock,
89 Opt_persistent, Opt_nopersistent,
90 Opt_resilient, Opt_noresilient,
92 /* Mount options which take numeric value */
93 Opt_backupuid, Opt_backupgid, Opt_uid,
94 Opt_cruid, Opt_gid, Opt_file_mode,
95 Opt_dirmode, Opt_port,
96 Opt_rsize, Opt_wsize, Opt_actimeo,
97 Opt_echo_interval, Opt_max_credits,
99 /* Mount options which take string value */
100 Opt_user, Opt_pass, Opt_ip,
101 Opt_domain, Opt_srcaddr, Opt_iocharset,
102 Opt_netbiosname, Opt_servern,
103 Opt_ver, Opt_vers, Opt_sec, Opt_cache,
105 /* Mount options to be ignored */
108 /* Options which could be blank */
116 static const match_table_t cifs_mount_option_tokens = {
118 { Opt_user_xattr, "user_xattr" },
119 { Opt_nouser_xattr, "nouser_xattr" },
120 { Opt_forceuid, "forceuid" },
121 { Opt_noforceuid, "noforceuid" },
122 { Opt_forcegid, "forcegid" },
123 { Opt_noforcegid, "noforcegid" },
124 { Opt_noblocksend, "noblocksend" },
125 { Opt_noautotune, "noautotune" },
126 { Opt_hard, "hard" },
127 { Opt_soft, "soft" },
128 { Opt_perm, "perm" },
129 { Opt_noperm, "noperm" },
130 { Opt_mapchars, "mapchars" }, /* SFU style */
131 { Opt_nomapchars, "nomapchars" },
132 { Opt_mapposix, "mapposix" }, /* SFM style */
133 { Opt_nomapposix, "nomapposix" },
135 { Opt_nosfu, "nosfu" },
136 { Opt_nodfs, "nodfs" },
137 { Opt_posixpaths, "posixpaths" },
138 { Opt_noposixpaths, "noposixpaths" },
139 { Opt_nounix, "nounix" },
140 { Opt_nounix, "nolinux" },
141 { Opt_nocase, "nocase" },
142 { Opt_nocase, "ignorecase" },
144 { Opt_nobrl, "nobrl" },
145 { Opt_nobrl, "nolock" },
146 { Opt_forcemandatorylock, "forcemandatorylock" },
147 { Opt_forcemandatorylock, "forcemand" },
148 { Opt_setuids, "setuids" },
149 { Opt_nosetuids, "nosetuids" },
150 { Opt_dynperm, "dynperm" },
151 { Opt_nodynperm, "nodynperm" },
152 { Opt_nohard, "nohard" },
153 { Opt_nosoft, "nosoft" },
154 { Opt_nointr, "nointr" },
155 { Opt_intr, "intr" },
156 { Opt_nostrictsync, "nostrictsync" },
157 { Opt_strictsync, "strictsync" },
158 { Opt_serverino, "serverino" },
159 { Opt_noserverino, "noserverino" },
160 { Opt_rwpidforward, "rwpidforward" },
161 { Opt_cifsacl, "cifsacl" },
162 { Opt_nocifsacl, "nocifsacl" },
164 { Opt_noacl, "noacl" },
165 { Opt_locallease, "locallease" },
166 { Opt_sign, "sign" },
167 { Opt_seal, "seal" },
168 { Opt_noac, "noac" },
170 { Opt_mfsymlinks, "mfsymlinks" },
171 { Opt_multiuser, "multiuser" },
172 { Opt_sloppy, "sloppy" },
173 { Opt_nosharesock, "nosharesock" },
174 { Opt_persistent, "persistenthandles"},
175 { Opt_nopersistent, "nopersistenthandles"},
176 { Opt_resilient, "resilienthandles"},
177 { Opt_noresilient, "noresilienthandles"},
179 { Opt_backupuid, "backupuid=%s" },
180 { Opt_backupgid, "backupgid=%s" },
181 { Opt_uid, "uid=%s" },
182 { Opt_cruid, "cruid=%s" },
183 { Opt_gid, "gid=%s" },
184 { Opt_file_mode, "file_mode=%s" },
185 { Opt_dirmode, "dirmode=%s" },
186 { Opt_dirmode, "dir_mode=%s" },
187 { Opt_port, "port=%s" },
188 { Opt_rsize, "rsize=%s" },
189 { Opt_wsize, "wsize=%s" },
190 { Opt_actimeo, "actimeo=%s" },
191 { Opt_echo_interval, "echo_interval=%s" },
192 { Opt_max_credits, "max_credits=%s" },
194 { Opt_blank_user, "user=" },
195 { Opt_blank_user, "username=" },
196 { Opt_user, "user=%s" },
197 { Opt_user, "username=%s" },
198 { Opt_blank_pass, "pass=" },
199 { Opt_blank_pass, "password=" },
200 { Opt_pass, "pass=%s" },
201 { Opt_pass, "password=%s" },
202 { Opt_blank_ip, "ip=" },
203 { Opt_blank_ip, "addr=" },
205 { Opt_ip, "addr=%s" },
206 { Opt_ignore, "unc=%s" },
207 { Opt_ignore, "target=%s" },
208 { Opt_ignore, "path=%s" },
209 { Opt_domain, "dom=%s" },
210 { Opt_domain, "domain=%s" },
211 { Opt_domain, "workgroup=%s" },
212 { Opt_srcaddr, "srcaddr=%s" },
213 { Opt_ignore, "prefixpath=%s" },
214 { Opt_iocharset, "iocharset=%s" },
215 { Opt_netbiosname, "netbiosname=%s" },
216 { Opt_servern, "servern=%s" },
217 { Opt_ver, "ver=%s" },
218 { Opt_vers, "vers=%s" },
219 { Opt_sec, "sec=%s" },
220 { Opt_cache, "cache=%s" },
222 { Opt_ignore, "cred" },
223 { Opt_ignore, "credentials" },
224 { Opt_ignore, "cred=%s" },
225 { Opt_ignore, "credentials=%s" },
226 { Opt_ignore, "guest" },
227 { Opt_ignore, "rw" },
228 { Opt_ignore, "ro" },
229 { Opt_ignore, "suid" },
230 { Opt_ignore, "nosuid" },
231 { Opt_ignore, "exec" },
232 { Opt_ignore, "noexec" },
233 { Opt_ignore, "nodev" },
234 { Opt_ignore, "noauto" },
235 { Opt_ignore, "dev" },
236 { Opt_ignore, "mand" },
237 { Opt_ignore, "nomand" },
238 { Opt_ignore, "_netdev" },
244 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
245 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
246 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
247 Opt_sec_ntlmv2i, Opt_sec_lanman,
253 static const match_table_t cifs_secflavor_tokens = {
254 { Opt_sec_krb5, "krb5" },
255 { Opt_sec_krb5i, "krb5i" },
256 { Opt_sec_krb5p, "krb5p" },
257 { Opt_sec_ntlmsspi, "ntlmsspi" },
258 { Opt_sec_ntlmssp, "ntlmssp" },
259 { Opt_ntlm, "ntlm" },
260 { Opt_sec_ntlmi, "ntlmi" },
261 { Opt_sec_ntlmv2, "nontlm" },
262 { Opt_sec_ntlmv2, "ntlmv2" },
263 { Opt_sec_ntlmv2i, "ntlmv2i" },
264 { Opt_sec_lanman, "lanman" },
265 { Opt_sec_none, "none" },
267 { Opt_sec_err, NULL }
278 static const match_table_t cifs_cacheflavor_tokens = {
279 { Opt_cache_loose, "loose" },
280 { Opt_cache_strict, "strict" },
281 { Opt_cache_none, "none" },
282 { Opt_cache_err, NULL }
285 static const match_table_t cifs_smb_version_tokens = {
286 { Smb_1, SMB1_VERSION_STRING },
287 { Smb_20, SMB20_VERSION_STRING},
288 { Smb_21, SMB21_VERSION_STRING },
289 { Smb_30, SMB30_VERSION_STRING },
290 { Smb_302, SMB302_VERSION_STRING },
291 #ifdef CONFIG_CIFS_SMB311
292 { Smb_311, SMB311_VERSION_STRING },
293 { Smb_311, ALT_SMB311_VERSION_STRING },
295 { Smb_version_err, NULL }
298 static int ip_connect(struct TCP_Server_Info *server);
299 static int generic_ip_connect(struct TCP_Server_Info *server);
300 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
301 static void cifs_prune_tlinks(struct work_struct *work);
302 static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
303 const char *devname);
306 * cifs tcp session reconnection
308 * mark tcp session as reconnecting so temporarily locked
309 * mark all smb sessions as reconnecting for tcp session
310 * reconnect tcp session
311 * wake up waiters on reconnection? - (not needed currently)
314 cifs_reconnect(struct TCP_Server_Info *server)
317 struct list_head *tmp, *tmp2;
318 struct cifs_ses *ses;
319 struct cifs_tcon *tcon;
320 struct mid_q_entry *mid_entry;
321 struct list_head retry_list;
323 spin_lock(&GlobalMid_Lock);
324 if (server->tcpStatus == CifsExiting) {
325 /* the demux thread will exit normally
326 next time through the loop */
327 spin_unlock(&GlobalMid_Lock);
330 server->tcpStatus = CifsNeedReconnect;
331 spin_unlock(&GlobalMid_Lock);
333 #ifdef CONFIG_CIFS_SMB2
334 server->max_read = 0;
337 cifs_dbg(FYI, "Reconnecting tcp session\n");
339 /* before reconnecting the tcp session, mark the smb session (uid)
340 and the tid bad so they are not used until reconnected */
341 cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
343 spin_lock(&cifs_tcp_ses_lock);
344 list_for_each(tmp, &server->smb_ses_list) {
345 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
346 ses->need_reconnect = true;
348 list_for_each(tmp2, &ses->tcon_list) {
349 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
350 tcon->need_reconnect = true;
353 spin_unlock(&cifs_tcp_ses_lock);
355 /* do not want to be sending data on a socket we are freeing */
356 cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
357 mutex_lock(&server->srv_mutex);
358 if (server->ssocket) {
359 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
360 server->ssocket->state, server->ssocket->flags);
361 kernel_sock_shutdown(server->ssocket, SHUT_WR);
362 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
363 server->ssocket->state, server->ssocket->flags);
364 sock_release(server->ssocket);
365 server->ssocket = NULL;
367 server->sequence_number = 0;
368 server->session_estab = false;
369 kfree(server->session_key.response);
370 server->session_key.response = NULL;
371 server->session_key.len = 0;
372 server->lstrp = jiffies;
374 /* mark submitted MIDs for retry and issue callback */
375 INIT_LIST_HEAD(&retry_list);
376 cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
377 spin_lock(&GlobalMid_Lock);
378 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
379 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
380 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
381 mid_entry->mid_state = MID_RETRY_NEEDED;
382 list_move(&mid_entry->qhead, &retry_list);
384 spin_unlock(&GlobalMid_Lock);
385 mutex_unlock(&server->srv_mutex);
387 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
388 list_for_each_safe(tmp, tmp2, &retry_list) {
389 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
390 list_del_init(&mid_entry->qhead);
391 mid_entry->callback(mid_entry);
397 /* we should try only the port we connected to before */
398 mutex_lock(&server->srv_mutex);
399 rc = generic_ip_connect(server);
401 cifs_dbg(FYI, "reconnect error %d\n", rc);
402 mutex_unlock(&server->srv_mutex);
405 atomic_inc(&tcpSesReconnectCount);
406 spin_lock(&GlobalMid_Lock);
407 if (server->tcpStatus != CifsExiting)
408 server->tcpStatus = CifsNeedNegotiate;
409 spin_unlock(&GlobalMid_Lock);
410 mutex_unlock(&server->srv_mutex);
412 } while (server->tcpStatus == CifsNeedReconnect);
418 cifs_echo_request(struct work_struct *work)
421 struct TCP_Server_Info *server = container_of(work,
422 struct TCP_Server_Info, echo.work);
423 unsigned long echo_interval = server->echo_interval;
426 * We cannot send an echo if it is disabled or until the
427 * NEGOTIATE_PROTOCOL request is done, which is indicated by
428 * server->ops->need_neg() == true. Also, no need to ping if
429 * we got a response recently.
432 if (server->tcpStatus == CifsNeedReconnect ||
433 server->tcpStatus == CifsExiting || server->tcpStatus == CifsNew ||
434 (server->ops->can_echo && !server->ops->can_echo(server)) ||
435 time_before(jiffies, server->lstrp + echo_interval - HZ))
438 rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
440 cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
444 queue_delayed_work(cifsiod_wq, &server->echo, echo_interval);
448 allocate_buffers(struct TCP_Server_Info *server)
450 if (!server->bigbuf) {
451 server->bigbuf = (char *)cifs_buf_get();
452 if (!server->bigbuf) {
453 cifs_dbg(VFS, "No memory for large SMB response\n");
455 /* retry will check if exiting */
458 } else if (server->large_buf) {
459 /* we are reusing a dirty large buf, clear its start */
460 memset(server->bigbuf, 0, HEADER_SIZE(server));
463 if (!server->smallbuf) {
464 server->smallbuf = (char *)cifs_small_buf_get();
465 if (!server->smallbuf) {
466 cifs_dbg(VFS, "No memory for SMB response\n");
468 /* retry will check if exiting */
471 /* beginning of smb buffer is cleared in our buf_get */
473 /* if existing small buf clear beginning */
474 memset(server->smallbuf, 0, HEADER_SIZE(server));
481 server_unresponsive(struct TCP_Server_Info *server)
484 * We need to wait 2 echo intervals to make sure we handle such
486 * 1s client sends a normal SMB request
487 * 2s client gets a response
488 * 30s echo workqueue job pops, and decides we got a response recently
489 * and don't need to send another
491 * 65s kernel_recvmsg times out, and we see that we haven't gotten
492 * a response in >60s.
494 if (server->tcpStatus == CifsGood &&
495 time_after(jiffies, server->lstrp + 2 * server->echo_interval)) {
496 cifs_dbg(VFS, "Server %s has not responded in %lu seconds. Reconnecting...\n",
497 server->hostname, (2 * server->echo_interval) / HZ);
498 cifs_reconnect(server);
499 wake_up(&server->response_q);
507 cifs_readv_from_socket(struct TCP_Server_Info *server, struct msghdr *smb_msg)
512 smb_msg->msg_control = NULL;
513 smb_msg->msg_controllen = 0;
515 for (total_read = 0; msg_data_left(smb_msg); total_read += length) {
518 if (server_unresponsive(server))
519 return -ECONNABORTED;
521 length = sock_recvmsg(server->ssocket, smb_msg, 0);
523 if (server->tcpStatus == CifsExiting)
526 if (server->tcpStatus == CifsNeedReconnect) {
527 cifs_reconnect(server);
528 return -ECONNABORTED;
531 if (length == -ERESTARTSYS ||
535 * Minimum sleep to prevent looping, allowing socket
536 * to clear and app threads to set tcpStatus
537 * CifsNeedReconnect if server hung.
539 usleep_range(1000, 2000);
545 cifs_dbg(FYI, "Received no data or error: %d\n", length);
546 cifs_reconnect(server);
547 return -ECONNABORTED;
554 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
555 unsigned int to_read)
557 struct msghdr smb_msg;
558 struct kvec iov = {.iov_base = buf, .iov_len = to_read};
559 iov_iter_kvec(&smb_msg.msg_iter, READ | ITER_KVEC, &iov, 1, to_read);
561 return cifs_readv_from_socket(server, &smb_msg);
565 cifs_read_page_from_socket(struct TCP_Server_Info *server, struct page *page,
566 unsigned int to_read)
568 struct msghdr smb_msg;
569 struct bio_vec bv = {.bv_page = page, .bv_len = to_read};
570 iov_iter_bvec(&smb_msg.msg_iter, READ | ITER_BVEC, &bv, 1, to_read);
571 return cifs_readv_from_socket(server, &smb_msg);
575 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
578 * The first byte big endian of the length field,
579 * is actually not part of the length but the type
580 * with the most common, zero, as regular data.
583 case RFC1002_SESSION_MESSAGE:
584 /* Regular SMB response */
586 case RFC1002_SESSION_KEEP_ALIVE:
587 cifs_dbg(FYI, "RFC 1002 session keep alive\n");
589 case RFC1002_POSITIVE_SESSION_RESPONSE:
590 cifs_dbg(FYI, "RFC 1002 positive session response\n");
592 case RFC1002_NEGATIVE_SESSION_RESPONSE:
594 * We get this from Windows 98 instead of an error on
595 * SMB negprot response.
597 cifs_dbg(FYI, "RFC 1002 negative session response\n");
598 /* give server a second to clean up */
601 * Always try 445 first on reconnect since we get NACK
602 * on some if we ever connected to port 139 (the NACK
603 * is since we do not begin with RFC1001 session
606 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
607 cifs_reconnect(server);
608 wake_up(&server->response_q);
611 cifs_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
612 cifs_reconnect(server);
619 dequeue_mid(struct mid_q_entry *mid, bool malformed)
621 #ifdef CONFIG_CIFS_STATS2
622 mid->when_received = jiffies;
624 spin_lock(&GlobalMid_Lock);
626 mid->mid_state = MID_RESPONSE_RECEIVED;
628 mid->mid_state = MID_RESPONSE_MALFORMED;
629 list_del_init(&mid->qhead);
630 spin_unlock(&GlobalMid_Lock);
634 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
635 char *buf, int malformed)
637 if (server->ops->check_trans2 &&
638 server->ops->check_trans2(mid, server, buf, malformed))
641 mid->large_buf = server->large_buf;
642 /* Was previous buf put in mpx struct for multi-rsp? */
643 if (!mid->multiRsp) {
644 /* smb buffer will be freed by user thread */
645 if (server->large_buf)
646 server->bigbuf = NULL;
648 server->smallbuf = NULL;
650 dequeue_mid(mid, malformed);
653 static void clean_demultiplex_info(struct TCP_Server_Info *server)
657 /* take it off the list, if it's not already */
658 spin_lock(&cifs_tcp_ses_lock);
659 list_del_init(&server->tcp_ses_list);
660 spin_unlock(&cifs_tcp_ses_lock);
662 spin_lock(&GlobalMid_Lock);
663 server->tcpStatus = CifsExiting;
664 spin_unlock(&GlobalMid_Lock);
665 wake_up_all(&server->response_q);
667 /* check if we have blocked requests that need to free */
668 spin_lock(&server->req_lock);
669 if (server->credits <= 0)
671 spin_unlock(&server->req_lock);
673 * Although there should not be any requests blocked on this queue it
674 * can not hurt to be paranoid and try to wake up requests that may
675 * haven been blocked when more than 50 at time were on the wire to the
676 * same server - they now will see the session is in exit state and get
677 * out of SendReceive.
679 wake_up_all(&server->request_q);
680 /* give those requests time to exit */
683 if (server->ssocket) {
684 sock_release(server->ssocket);
685 server->ssocket = NULL;
688 if (!list_empty(&server->pending_mid_q)) {
689 struct list_head dispose_list;
690 struct mid_q_entry *mid_entry;
691 struct list_head *tmp, *tmp2;
693 INIT_LIST_HEAD(&dispose_list);
694 spin_lock(&GlobalMid_Lock);
695 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
696 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
697 cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid);
698 mid_entry->mid_state = MID_SHUTDOWN;
699 list_move(&mid_entry->qhead, &dispose_list);
701 spin_unlock(&GlobalMid_Lock);
703 /* now walk dispose list and issue callbacks */
704 list_for_each_safe(tmp, tmp2, &dispose_list) {
705 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
706 cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid);
707 list_del_init(&mid_entry->qhead);
708 mid_entry->callback(mid_entry);
710 /* 1/8th of sec is more than enough time for them to exit */
714 if (!list_empty(&server->pending_mid_q)) {
716 * mpx threads have not exited yet give them at least the smb
717 * send timeout time for long ops.
719 * Due to delays on oplock break requests, we need to wait at
720 * least 45 seconds before giving up on a request getting a
721 * response and going ahead and killing cifsd.
723 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
726 * If threads still have not exited they are probably never
727 * coming home not much else we can do but free the memory.
731 kfree(server->hostname);
734 length = atomic_dec_return(&tcpSesAllocCount);
736 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
740 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
743 char *buf = server->smallbuf;
744 unsigned int pdu_length = get_rfc1002_length(buf);
746 /* make sure this will fit in a large buffer */
747 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) - 4) {
748 cifs_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
749 cifs_reconnect(server);
750 wake_up(&server->response_q);
751 return -ECONNABORTED;
754 /* switch to large buffer if too big for a small one */
755 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
756 server->large_buf = true;
757 memcpy(server->bigbuf, buf, server->total_read);
758 buf = server->bigbuf;
761 /* now read the rest */
762 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
763 pdu_length - HEADER_SIZE(server) + 1 + 4);
766 server->total_read += length;
768 dump_smb(buf, server->total_read);
771 * We know that we received enough to get to the MID as we
772 * checked the pdu_length earlier. Now check to see
773 * if the rest of the header is OK. We borrow the length
774 * var for the rest of the loop to avoid a new stack var.
776 * 48 bytes is enough to display the header and a little bit
777 * into the payload for debugging purposes.
779 length = server->ops->check_message(buf, server->total_read, server);
781 cifs_dump_mem("Bad SMB: ", buf,
782 min_t(unsigned int, server->total_read, 48));
784 if (server->ops->is_status_pending &&
785 server->ops->is_status_pending(buf, server, length))
791 handle_mid(mid, server, buf, length);
796 cifs_demultiplex_thread(void *p)
799 struct TCP_Server_Info *server = p;
800 unsigned int pdu_length;
802 struct task_struct *task_to_wake = NULL;
803 struct mid_q_entry *mid_entry;
805 current->flags |= PF_MEMALLOC;
806 cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
808 length = atomic_inc_return(&tcpSesAllocCount);
810 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
813 while (server->tcpStatus != CifsExiting) {
817 if (!allocate_buffers(server))
820 server->large_buf = false;
821 buf = server->smallbuf;
822 pdu_length = 4; /* enough to get RFC1001 header */
824 length = cifs_read_from_socket(server, buf, pdu_length);
827 server->total_read = length;
830 * The right amount was read from socket - 4 bytes,
831 * so we can now interpret the length field.
833 pdu_length = get_rfc1002_length(buf);
835 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
836 if (!is_smb_response(server, buf[0]))
839 /* make sure we have enough to get to the MID */
840 if (pdu_length < HEADER_SIZE(server) - 1 - 4) {
841 cifs_dbg(VFS, "SMB response too short (%u bytes)\n",
843 cifs_reconnect(server);
844 wake_up(&server->response_q);
848 /* read down to the MID */
849 length = cifs_read_from_socket(server, buf + 4,
850 HEADER_SIZE(server) - 1 - 4);
853 server->total_read += length;
855 mid_entry = server->ops->find_mid(server, buf);
857 if (!mid_entry || !mid_entry->receive)
858 length = standard_receive3(server, mid_entry);
860 length = mid_entry->receive(server, mid_entry);
865 if (server->large_buf)
866 buf = server->bigbuf;
868 server->lstrp = jiffies;
869 if (mid_entry != NULL) {
870 if (!mid_entry->multiRsp || mid_entry->multiEnd)
871 mid_entry->callback(mid_entry);
872 } else if (!server->ops->is_oplock_break ||
873 !server->ops->is_oplock_break(buf, server)) {
874 cifs_dbg(VFS, "No task to wake, unknown frame received! NumMids %d\n",
875 atomic_read(&midCount));
876 cifs_dump_mem("Received Data is: ", buf,
877 HEADER_SIZE(server));
878 #ifdef CONFIG_CIFS_DEBUG2
879 if (server->ops->dump_detail)
880 server->ops->dump_detail(buf);
881 cifs_dump_mids(server);
882 #endif /* CIFS_DEBUG2 */
885 } /* end while !EXITING */
887 /* buffer usually freed in free_mid - need to free it here on exit */
888 cifs_buf_release(server->bigbuf);
889 if (server->smallbuf) /* no sense logging a debug message if NULL */
890 cifs_small_buf_release(server->smallbuf);
892 task_to_wake = xchg(&server->tsk, NULL);
893 clean_demultiplex_info(server);
895 /* if server->tsk was NULL then wait for a signal before exiting */
897 set_current_state(TASK_INTERRUPTIBLE);
898 while (!signal_pending(current)) {
900 set_current_state(TASK_INTERRUPTIBLE);
902 set_current_state(TASK_RUNNING);
905 module_put_and_exit(0);
908 /* extract the host portion of the UNC string */
910 extract_hostname(const char *unc)
916 /* skip double chars at beginning of string */
917 /* BB: check validity of these bytes? */
920 /* delimiter between hostname and sharename is always '\\' now */
921 delim = strchr(src, '\\');
923 return ERR_PTR(-EINVAL);
926 dst = kmalloc((len + 1), GFP_KERNEL);
928 return ERR_PTR(-ENOMEM);
930 memcpy(dst, src, len);
936 static int get_option_ul(substring_t args[], unsigned long *option)
941 string = match_strdup(args);
944 rc = kstrtoul(string, 0, option);
950 static int get_option_uid(substring_t args[], kuid_t *result)
956 rc = get_option_ul(args, &value);
960 uid = make_kuid(current_user_ns(), value);
968 static int get_option_gid(substring_t args[], kgid_t *result)
974 rc = get_option_ul(args, &value);
978 gid = make_kgid(current_user_ns(), value);
986 static int cifs_parse_security_flavors(char *value,
990 substring_t args[MAX_OPT_ARGS];
993 * With mount options, the last one should win. Reset any existing
994 * settings back to default.
996 vol->sectype = Unspecified;
999 switch (match_token(value, cifs_secflavor_tokens, args)) {
1001 cifs_dbg(VFS, "sec=krb5p is not supported!\n");
1007 vol->sectype = Kerberos;
1009 case Opt_sec_ntlmsspi:
1012 case Opt_sec_ntlmssp:
1013 vol->sectype = RawNTLMSSP;
1019 vol->sectype = NTLM;
1021 case Opt_sec_ntlmv2i:
1024 case Opt_sec_ntlmv2:
1025 vol->sectype = NTLMv2;
1027 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1028 case Opt_sec_lanman:
1029 vol->sectype = LANMAN;
1036 cifs_dbg(VFS, "bad security option: %s\n", value);
1044 cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1046 substring_t args[MAX_OPT_ARGS];
1048 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1049 case Opt_cache_loose:
1050 vol->direct_io = false;
1051 vol->strict_io = false;
1053 case Opt_cache_strict:
1054 vol->direct_io = false;
1055 vol->strict_io = true;
1057 case Opt_cache_none:
1058 vol->direct_io = true;
1059 vol->strict_io = false;
1062 cifs_dbg(VFS, "bad cache= option: %s\n", value);
1069 cifs_parse_smb_version(char *value, struct smb_vol *vol)
1071 substring_t args[MAX_OPT_ARGS];
1073 switch (match_token(value, cifs_smb_version_tokens, args)) {
1075 vol->ops = &smb1_operations;
1076 vol->vals = &smb1_values;
1078 #ifdef CONFIG_CIFS_SMB2
1080 vol->ops = &smb20_operations;
1081 vol->vals = &smb20_values;
1084 vol->ops = &smb21_operations;
1085 vol->vals = &smb21_values;
1088 vol->ops = &smb30_operations;
1089 vol->vals = &smb30_values;
1092 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1093 vol->vals = &smb302_values;
1095 #ifdef CONFIG_CIFS_SMB311
1097 vol->ops = &smb311_operations;
1098 vol->vals = &smb311_values;
1103 cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
1110 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1111 * fields with the result. Returns 0 on success and an error otherwise.
1114 cifs_parse_devname(const char *devname, struct smb_vol *vol)
1117 const char *delims = "/\\";
1120 /* make sure we have a valid UNC double delimiter prefix */
1121 len = strspn(devname, delims);
1125 /* find delimiter between host and sharename */
1126 pos = strpbrk(devname + 2, delims);
1130 /* skip past delimiter */
1133 /* now go until next delimiter or end of string */
1134 len = strcspn(pos, delims);
1136 /* move "pos" up to delimiter or NULL */
1138 vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1142 convert_delimiter(vol->UNC, '\\');
1144 /* skip any delimiter */
1145 if (*pos == '/' || *pos == '\\')
1148 /* If pos is NULL then no prepath */
1152 vol->prepath = kstrdup(pos, GFP_KERNEL);
1160 cifs_parse_mount_options(const char *mountdata, const char *devname,
1161 struct smb_vol *vol)
1164 char *mountdata_copy = NULL, *options;
1165 unsigned int temp_len, i, j;
1167 short int override_uid = -1;
1168 short int override_gid = -1;
1169 bool uid_specified = false;
1170 bool gid_specified = false;
1171 bool sloppy = false;
1172 char *invalid = NULL;
1173 char *nodename = utsname()->nodename;
1174 char *string = NULL;
1175 char *tmp_end, *value;
1177 bool got_ip = false;
1178 unsigned short port = 0;
1179 struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1183 delim = separator[0];
1185 /* ensure we always start with zeroed-out smb_vol */
1186 memset(vol, 0, sizeof(*vol));
1189 * does not have to be perfect mapping since field is
1190 * informational, only used for servers that do not support
1191 * port 445 and it can be overridden at mount time
1193 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1194 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1195 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1197 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1198 /* null target name indicates to use *SMBSERVR default called name
1199 if we end up sending RFC1001 session initialize */
1200 vol->target_rfc1001_name[0] = 0;
1201 vol->cred_uid = current_uid();
1202 vol->linux_uid = current_uid();
1203 vol->linux_gid = current_gid();
1206 * default to SFM style remapping of seven reserved characters
1207 * unless user overrides it or we negotiate CIFS POSIX where
1208 * it is unnecessary. Can not simultaneously use more than one mapping
1209 * since then readdir could list files that open could not open
1213 /* default to only allowing write access to owner of the mount */
1214 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1216 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1217 /* default is always to request posix paths. */
1218 vol->posix_paths = 1;
1219 /* default to using server inode numbers where available */
1220 vol->server_ino = 1;
1222 /* default is to use strict cifs caching semantics */
1223 vol->strict_io = true;
1225 vol->actimeo = CIFS_DEF_ACTIMEO;
1227 /* FIXME: add autonegotiation -- for now, SMB1 is default */
1228 vol->ops = &smb1_operations;
1229 vol->vals = &smb1_values;
1231 vol->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1234 goto cifs_parse_mount_err;
1236 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1237 if (!mountdata_copy)
1238 goto cifs_parse_mount_err;
1240 options = mountdata_copy;
1241 end = options + strlen(options);
1243 if (strncmp(options, "sep=", 4) == 0) {
1244 if (options[4] != 0) {
1245 separator[0] = options[4];
1248 cifs_dbg(FYI, "Null separator not allowed\n");
1251 vol->backupuid_specified = false; /* no backup intent for a user */
1252 vol->backupgid_specified = false; /* no backup intent for a group */
1254 switch (cifs_parse_devname(devname, vol)) {
1258 cifs_dbg(VFS, "Unable to allocate memory for devname.\n");
1259 goto cifs_parse_mount_err;
1261 cifs_dbg(VFS, "Malformed UNC in devname.\n");
1262 goto cifs_parse_mount_err;
1264 cifs_dbg(VFS, "Unknown error parsing devname.\n");
1265 goto cifs_parse_mount_err;
1268 while ((data = strsep(&options, separator)) != NULL) {
1269 substring_t args[MAX_OPT_ARGS];
1270 unsigned long option;
1276 token = match_token(data, cifs_mount_option_tokens, args);
1280 /* Ingnore the following */
1284 /* Boolean values */
1285 case Opt_user_xattr:
1288 case Opt_nouser_xattr:
1294 case Opt_noforceuid:
1300 case Opt_noforcegid:
1303 case Opt_noblocksend:
1304 vol->noblocksnd = 1;
1306 case Opt_noautotune:
1307 vol->noautotune = 1;
1322 vol->sfu_remap = true;
1323 vol->remap = false; /* disable SFM mapping */
1325 case Opt_nomapchars:
1326 vol->sfu_remap = false;
1330 vol->sfu_remap = false; /* disable SFU mapping */
1332 case Opt_nomapposix:
1344 case Opt_posixpaths:
1345 vol->posix_paths = 1;
1347 case Opt_noposixpaths:
1348 vol->posix_paths = 0;
1351 vol->no_linux_ext = 1;
1362 * turn off mandatory locking in mode
1363 * if remote locking is turned off since the
1364 * local vfs will do advisory
1366 if (vol->file_mode ==
1367 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1368 vol->file_mode = S_IALLUGO;
1370 case Opt_forcemandatorylock:
1380 vol->dynperm = true;
1383 vol->dynperm = false;
1397 case Opt_nostrictsync:
1398 vol->nostrictsync = 1;
1400 case Opt_strictsync:
1401 vol->nostrictsync = 0;
1404 vol->server_ino = 1;
1406 case Opt_noserverino:
1407 vol->server_ino = 0;
1409 case Opt_rwpidforward:
1410 vol->rwpidforward = 1;
1419 vol->no_psx_acl = 0;
1422 vol->no_psx_acl = 1;
1424 case Opt_locallease:
1425 vol->local_lease = 1;
1431 /* we do not do the following in secFlags because seal
1432 * is a per tree connection (mount) not a per socket
1433 * or per-smb connection option in the protocol
1434 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1439 pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1442 #ifndef CONFIG_CIFS_FSCACHE
1443 cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1444 goto cifs_parse_mount_err;
1448 case Opt_mfsymlinks:
1449 vol->mfsymlinks = true;
1452 vol->multiuser = true;
1457 case Opt_nosharesock:
1458 vol->nosharesock = true;
1460 case Opt_nopersistent:
1461 vol->nopersistent = true;
1462 if (vol->persistent) {
1464 "persistenthandles mount options conflict\n");
1465 goto cifs_parse_mount_err;
1468 case Opt_persistent:
1469 vol->persistent = true;
1470 if ((vol->nopersistent) || (vol->resilient)) {
1472 "persistenthandles mount options conflict\n");
1473 goto cifs_parse_mount_err;
1477 vol->resilient = true;
1478 if (vol->persistent) {
1480 "persistenthandles mount options conflict\n");
1481 goto cifs_parse_mount_err;
1484 case Opt_noresilient:
1485 vol->resilient = false; /* already the default */
1488 /* Numeric Values */
1490 if (get_option_uid(args, &vol->backupuid)) {
1491 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
1493 goto cifs_parse_mount_err;
1495 vol->backupuid_specified = true;
1498 if (get_option_gid(args, &vol->backupgid)) {
1499 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
1501 goto cifs_parse_mount_err;
1503 vol->backupgid_specified = true;
1506 if (get_option_uid(args, &vol->linux_uid)) {
1507 cifs_dbg(VFS, "%s: Invalid uid value\n",
1509 goto cifs_parse_mount_err;
1511 uid_specified = true;
1514 if (get_option_uid(args, &vol->cred_uid)) {
1515 cifs_dbg(VFS, "%s: Invalid cruid value\n",
1517 goto cifs_parse_mount_err;
1521 if (get_option_gid(args, &vol->linux_gid)) {
1522 cifs_dbg(VFS, "%s: Invalid gid value\n",
1524 goto cifs_parse_mount_err;
1526 gid_specified = true;
1529 if (get_option_ul(args, &option)) {
1530 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
1532 goto cifs_parse_mount_err;
1534 vol->file_mode = option;
1537 if (get_option_ul(args, &option)) {
1538 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
1540 goto cifs_parse_mount_err;
1542 vol->dir_mode = option;
1545 if (get_option_ul(args, &option) ||
1546 option > USHRT_MAX) {
1547 cifs_dbg(VFS, "%s: Invalid port value\n",
1549 goto cifs_parse_mount_err;
1551 port = (unsigned short)option;
1554 if (get_option_ul(args, &option)) {
1555 cifs_dbg(VFS, "%s: Invalid rsize value\n",
1557 goto cifs_parse_mount_err;
1559 vol->rsize = option;
1562 if (get_option_ul(args, &option)) {
1563 cifs_dbg(VFS, "%s: Invalid wsize value\n",
1565 goto cifs_parse_mount_err;
1567 vol->wsize = option;
1570 if (get_option_ul(args, &option)) {
1571 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
1573 goto cifs_parse_mount_err;
1575 vol->actimeo = HZ * option;
1576 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1577 cifs_dbg(VFS, "attribute cache timeout too large\n");
1578 goto cifs_parse_mount_err;
1581 case Opt_echo_interval:
1582 if (get_option_ul(args, &option)) {
1583 cifs_dbg(VFS, "%s: Invalid echo interval value\n",
1585 goto cifs_parse_mount_err;
1587 vol->echo_interval = option;
1589 case Opt_max_credits:
1590 if (get_option_ul(args, &option) || (option < 20) ||
1592 cifs_dbg(VFS, "%s: Invalid max_credits value\n",
1594 goto cifs_parse_mount_err;
1596 vol->max_credits = option;
1599 /* String Arguments */
1601 case Opt_blank_user:
1602 /* null user, ie. anonymous authentication */
1604 vol->username = NULL;
1607 string = match_strdup(args);
1611 if (strnlen(string, CIFS_MAX_USERNAME_LEN) >
1612 CIFS_MAX_USERNAME_LEN) {
1613 pr_warn("CIFS: username too long\n");
1614 goto cifs_parse_mount_err;
1617 kfree(vol->username);
1618 vol->username = kstrdup(string, GFP_KERNEL);
1620 goto cifs_parse_mount_err;
1622 case Opt_blank_pass:
1623 /* passwords have to be handled differently
1624 * to allow the character used for deliminator
1625 * to be passed within them
1629 * Check if this is a case where the password
1630 * starts with a delimiter
1632 tmp_end = strchr(data, '=');
1634 if (!(tmp_end < end && tmp_end[1] == delim)) {
1635 /* No it is not. Set the password to NULL */
1636 kfree(vol->password);
1637 vol->password = NULL;
1640 /* Yes it is. Drop down to Opt_pass below.*/
1642 /* Obtain the value string */
1643 value = strchr(data, '=');
1646 /* Set tmp_end to end of the string */
1647 tmp_end = (char *) value + strlen(value);
1649 /* Check if following character is the deliminator
1650 * If yes, we have encountered a double deliminator
1651 * reset the NULL character to the deliminator
1653 if (tmp_end < end && tmp_end[1] == delim) {
1656 /* Keep iterating until we get to a single
1657 * deliminator OR the end
1659 while ((tmp_end = strchr(tmp_end, delim))
1660 != NULL && (tmp_end[1] == delim)) {
1661 tmp_end = (char *) &tmp_end[2];
1664 /* Reset var options to point to next element */
1667 options = (char *) &tmp_end[1];
1669 /* Reached the end of the mount option
1674 kfree(vol->password);
1675 /* Now build new password string */
1676 temp_len = strlen(value);
1677 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1678 if (vol->password == NULL) {
1679 pr_warn("CIFS: no memory for password\n");
1680 goto cifs_parse_mount_err;
1683 for (i = 0, j = 0; i < temp_len; i++, j++) {
1684 vol->password[j] = value[i];
1685 if ((value[i] == delim) &&
1686 value[i+1] == delim)
1687 /* skip the second deliminator */
1690 vol->password[j] = '\0';
1693 /* FIXME: should this be an error instead? */
1697 string = match_strdup(args);
1701 if (!cifs_convert_address(dstaddr, string,
1703 pr_err("CIFS: bad ip= option (%s).\n", string);
1704 goto cifs_parse_mount_err;
1709 string = match_strdup(args);
1713 if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
1714 == CIFS_MAX_DOMAINNAME_LEN) {
1715 pr_warn("CIFS: domain name too long\n");
1716 goto cifs_parse_mount_err;
1719 kfree(vol->domainname);
1720 vol->domainname = kstrdup(string, GFP_KERNEL);
1721 if (!vol->domainname) {
1722 pr_warn("CIFS: no memory for domainname\n");
1723 goto cifs_parse_mount_err;
1725 cifs_dbg(FYI, "Domain name set\n");
1728 string = match_strdup(args);
1732 if (!cifs_convert_address(
1733 (struct sockaddr *)&vol->srcaddr,
1734 string, strlen(string))) {
1735 pr_warn("CIFS: Could not parse srcaddr: %s\n",
1737 goto cifs_parse_mount_err;
1741 string = match_strdup(args);
1745 if (strnlen(string, 1024) >= 65) {
1746 pr_warn("CIFS: iocharset name too long.\n");
1747 goto cifs_parse_mount_err;
1750 if (strncasecmp(string, "default", 7) != 0) {
1751 kfree(vol->iocharset);
1752 vol->iocharset = kstrdup(string,
1754 if (!vol->iocharset) {
1755 pr_warn("CIFS: no memory for charset\n");
1756 goto cifs_parse_mount_err;
1759 /* if iocharset not set then load_nls_default
1762 cifs_dbg(FYI, "iocharset set to %s\n", string);
1764 case Opt_netbiosname:
1765 string = match_strdup(args);
1769 memset(vol->source_rfc1001_name, 0x20,
1772 * FIXME: are there cases in which a comma can
1773 * be valid in workstation netbios name (and
1774 * need special handling)?
1776 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1777 /* don't ucase netbiosname for user */
1780 vol->source_rfc1001_name[i] = string[i];
1782 /* The string has 16th byte zero still from
1783 * set at top of the function
1785 if (i == RFC1001_NAME_LEN && string[i] != 0)
1786 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
1789 /* servernetbiosname specified override *SMBSERVER */
1790 string = match_strdup(args);
1794 /* last byte, type, is 0x20 for servr type */
1795 memset(vol->target_rfc1001_name, 0x20,
1796 RFC1001_NAME_LEN_WITH_NULL);
1798 /* BB are there cases in which a comma can be
1799 valid in this workstation netbios name
1800 (and need special handling)? */
1802 /* user or mount helper must uppercase the
1804 for (i = 0; i < 15; i++) {
1807 vol->target_rfc1001_name[i] = string[i];
1809 /* The string has 16th byte zero still from
1810 set at top of the function */
1811 if (i == RFC1001_NAME_LEN && string[i] != 0)
1812 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
1815 string = match_strdup(args);
1819 if (strncasecmp(string, "1", 1) == 0) {
1820 /* This is the default */
1823 /* For all other value, error */
1824 pr_warn("CIFS: Invalid version specified\n");
1825 goto cifs_parse_mount_err;
1827 string = match_strdup(args);
1831 if (cifs_parse_smb_version(string, vol) != 0)
1832 goto cifs_parse_mount_err;
1835 string = match_strdup(args);
1839 if (cifs_parse_security_flavors(string, vol) != 0)
1840 goto cifs_parse_mount_err;
1843 string = match_strdup(args);
1847 if (cifs_parse_cache_flavor(string, vol) != 0)
1848 goto cifs_parse_mount_err;
1852 * An option we don't recognize. Save it off for later
1853 * if we haven't already found one
1859 /* Free up any allocated string */
1864 if (!sloppy && invalid) {
1865 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid);
1866 goto cifs_parse_mount_err;
1870 /* Muliuser mounts require CONFIG_KEYS support */
1871 if (vol->multiuser) {
1872 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
1873 goto cifs_parse_mount_err;
1877 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
1878 goto cifs_parse_mount_err;
1881 /* make sure UNC has a share name */
1882 if (!strchr(vol->UNC + 3, '\\')) {
1883 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
1884 goto cifs_parse_mount_err;
1888 /* No ip= option specified? Try to get it from UNC */
1889 if (!cifs_convert_address(dstaddr, &vol->UNC[2],
1890 strlen(&vol->UNC[2]))) {
1891 pr_err("Unable to determine destination address.\n");
1892 goto cifs_parse_mount_err;
1896 /* set the port that we got earlier */
1897 cifs_set_port(dstaddr, port);
1900 vol->override_uid = override_uid;
1901 else if (override_uid == 1)
1902 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
1905 vol->override_gid = override_gid;
1906 else if (override_gid == 1)
1907 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
1909 kfree(mountdata_copy);
1913 pr_warn("Could not allocate temporary buffer\n");
1914 cifs_parse_mount_err:
1916 kfree(mountdata_copy);
1920 /** Returns true if srcaddr isn't specified and rhs isn't
1921 * specified, or if srcaddr is specified and
1922 * matches the IP address of the rhs argument.
1925 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1927 switch (srcaddr->sa_family) {
1929 return (rhs->sa_family == AF_UNSPEC);
1931 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1932 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1933 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1936 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1937 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
1938 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1942 return false; /* don't expect to be here */
1947 * If no port is specified in addr structure, we try to match with 445 port
1948 * and if it fails - with 139 ports. It should be called only if address
1949 * families of server and addr are equal.
1952 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1954 __be16 port, *sport;
1956 switch (addr->sa_family) {
1958 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1959 port = ((struct sockaddr_in *) addr)->sin_port;
1962 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1963 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1971 port = htons(CIFS_PORT);
1975 port = htons(RFC1001_PORT);
1978 return port == *sport;
1982 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1983 struct sockaddr *srcaddr)
1985 switch (addr->sa_family) {
1987 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1988 struct sockaddr_in *srv_addr4 =
1989 (struct sockaddr_in *)&server->dstaddr;
1991 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1996 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1997 struct sockaddr_in6 *srv_addr6 =
1998 (struct sockaddr_in6 *)&server->dstaddr;
2000 if (!ipv6_addr_equal(&addr6->sin6_addr,
2001 &srv_addr6->sin6_addr))
2003 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
2009 return false; /* don't expect to be here */
2012 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2019 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2022 * The select_sectype function should either return the vol->sectype
2023 * that was specified, or "Unspecified" if that sectype was not
2024 * compatible with the given NEGOTIATE request.
2026 if (select_sectype(server, vol->sectype) == Unspecified)
2030 * Now check if signing mode is acceptable. No need to check
2031 * global_secflags at this point since if MUST_SIGN is set then
2032 * the server->sign had better be too.
2034 if (vol->sign && !server->sign)
2040 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2042 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2044 if (vol->nosharesock)
2047 if ((server->vals != vol->vals) || (server->ops != vol->ops))
2050 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2053 if (!match_address(server, addr,
2054 (struct sockaddr *)&vol->srcaddr))
2057 if (!match_port(server, addr))
2060 if (!match_security(server, vol))
2063 if (server->echo_interval != vol->echo_interval * HZ)
2069 static struct TCP_Server_Info *
2070 cifs_find_tcp_session(struct smb_vol *vol)
2072 struct TCP_Server_Info *server;
2074 spin_lock(&cifs_tcp_ses_lock);
2075 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2076 if (!match_server(server, vol))
2079 ++server->srv_count;
2080 spin_unlock(&cifs_tcp_ses_lock);
2081 cifs_dbg(FYI, "Existing tcp session with server found\n");
2084 spin_unlock(&cifs_tcp_ses_lock);
2089 cifs_put_tcp_session(struct TCP_Server_Info *server)
2091 struct task_struct *task;
2093 spin_lock(&cifs_tcp_ses_lock);
2094 if (--server->srv_count > 0) {
2095 spin_unlock(&cifs_tcp_ses_lock);
2099 put_net(cifs_net_ns(server));
2101 list_del_init(&server->tcp_ses_list);
2102 spin_unlock(&cifs_tcp_ses_lock);
2104 cancel_delayed_work_sync(&server->echo);
2106 spin_lock(&GlobalMid_Lock);
2107 server->tcpStatus = CifsExiting;
2108 spin_unlock(&GlobalMid_Lock);
2110 cifs_crypto_shash_release(server);
2111 cifs_fscache_release_client_cookie(server);
2113 kfree(server->session_key.response);
2114 server->session_key.response = NULL;
2115 server->session_key.len = 0;
2117 task = xchg(&server->tsk, NULL);
2119 force_sig(SIGKILL, task);
2122 static struct TCP_Server_Info *
2123 cifs_get_tcp_session(struct smb_vol *volume_info)
2125 struct TCP_Server_Info *tcp_ses = NULL;
2128 cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
2130 /* see if we already have a matching tcp_ses */
2131 tcp_ses = cifs_find_tcp_session(volume_info);
2135 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2141 tcp_ses->ops = volume_info->ops;
2142 tcp_ses->vals = volume_info->vals;
2143 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2144 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2145 if (IS_ERR(tcp_ses->hostname)) {
2146 rc = PTR_ERR(tcp_ses->hostname);
2147 goto out_err_crypto_release;
2150 tcp_ses->noblocksnd = volume_info->noblocksnd;
2151 tcp_ses->noautotune = volume_info->noautotune;
2152 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2153 tcp_ses->in_flight = 0;
2154 tcp_ses->credits = 1;
2155 init_waitqueue_head(&tcp_ses->response_q);
2156 init_waitqueue_head(&tcp_ses->request_q);
2157 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2158 mutex_init(&tcp_ses->srv_mutex);
2159 memcpy(tcp_ses->workstation_RFC1001_name,
2160 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2161 memcpy(tcp_ses->server_RFC1001_name,
2162 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2163 tcp_ses->session_estab = false;
2164 tcp_ses->sequence_number = 0;
2165 tcp_ses->lstrp = jiffies;
2166 spin_lock_init(&tcp_ses->req_lock);
2167 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2168 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2169 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2170 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2171 sizeof(tcp_ses->srcaddr));
2172 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2173 sizeof(tcp_ses->dstaddr));
2174 #ifdef CONFIG_CIFS_SMB2
2175 generate_random_uuid(tcp_ses->client_guid);
2178 * at this point we are the only ones with the pointer
2179 * to the struct since the kernel thread not created yet
2180 * no need to spinlock this init of tcpStatus or srv_count
2182 tcp_ses->tcpStatus = CifsNew;
2183 ++tcp_ses->srv_count;
2185 if (volume_info->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
2186 volume_info->echo_interval <= SMB_ECHO_INTERVAL_MAX)
2187 tcp_ses->echo_interval = volume_info->echo_interval * HZ;
2189 tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
2191 rc = ip_connect(tcp_ses);
2193 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
2194 goto out_err_crypto_release;
2198 * since we're in a cifs function already, we know that
2199 * this will succeed. No need for try_module_get().
2201 __module_get(THIS_MODULE);
2202 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2204 if (IS_ERR(tcp_ses->tsk)) {
2205 rc = PTR_ERR(tcp_ses->tsk);
2206 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
2207 module_put(THIS_MODULE);
2208 goto out_err_crypto_release;
2210 tcp_ses->tcpStatus = CifsNeedNegotiate;
2212 /* thread spawned, put it on the list */
2213 spin_lock(&cifs_tcp_ses_lock);
2214 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2215 spin_unlock(&cifs_tcp_ses_lock);
2217 cifs_fscache_get_client_cookie(tcp_ses);
2219 /* queue echo request delayed work */
2220 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
2224 out_err_crypto_release:
2225 cifs_crypto_shash_release(tcp_ses);
2227 put_net(cifs_net_ns(tcp_ses));
2231 if (!IS_ERR(tcp_ses->hostname))
2232 kfree(tcp_ses->hostname);
2233 if (tcp_ses->ssocket)
2234 sock_release(tcp_ses->ssocket);
2240 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2242 if (vol->sectype != Unspecified &&
2243 vol->sectype != ses->sectype)
2246 switch (ses->sectype) {
2248 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2252 /* NULL username means anonymous session */
2253 if (ses->user_name == NULL) {
2259 /* anything else takes username/password */
2260 if (strncmp(ses->user_name,
2261 vol->username ? vol->username : "",
2262 CIFS_MAX_USERNAME_LEN))
2264 if ((vol->username && strlen(vol->username) != 0) &&
2265 ses->password != NULL &&
2266 strncmp(ses->password,
2267 vol->password ? vol->password : "",
2268 CIFS_MAX_PASSWORD_LEN))
2274 static struct cifs_ses *
2275 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2277 struct cifs_ses *ses;
2279 spin_lock(&cifs_tcp_ses_lock);
2280 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2281 if (ses->status == CifsExiting)
2283 if (!match_session(ses, vol))
2286 spin_unlock(&cifs_tcp_ses_lock);
2289 spin_unlock(&cifs_tcp_ses_lock);
2294 cifs_put_smb_ses(struct cifs_ses *ses)
2296 unsigned int rc, xid;
2297 struct TCP_Server_Info *server = ses->server;
2299 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
2301 spin_lock(&cifs_tcp_ses_lock);
2302 if (ses->status == CifsExiting) {
2303 spin_unlock(&cifs_tcp_ses_lock);
2306 if (--ses->ses_count > 0) {
2307 spin_unlock(&cifs_tcp_ses_lock);
2310 if (ses->status == CifsGood)
2311 ses->status = CifsExiting;
2312 spin_unlock(&cifs_tcp_ses_lock);
2314 if (ses->status == CifsExiting && server->ops->logoff) {
2316 rc = server->ops->logoff(xid, ses);
2318 cifs_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
2323 spin_lock(&cifs_tcp_ses_lock);
2324 list_del_init(&ses->smb_ses_list);
2325 spin_unlock(&cifs_tcp_ses_lock);
2328 cifs_put_tcp_session(server);
2333 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2334 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2336 /* Populate username and pw fields from keyring if possible */
2338 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2341 const char *delim, *payload;
2345 struct TCP_Server_Info *server = ses->server;
2346 struct sockaddr_in *sa;
2347 struct sockaddr_in6 *sa6;
2348 const struct user_key_payload *upayload;
2350 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2354 /* try to find an address key first */
2355 switch (server->dstaddr.ss_family) {
2357 sa = (struct sockaddr_in *)&server->dstaddr;
2358 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2361 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2362 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2365 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2366 server->dstaddr.ss_family);
2371 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2372 key = request_key(&key_type_logon, desc, "");
2374 if (!ses->domainName) {
2375 cifs_dbg(FYI, "domainName is NULL\n");
2380 /* didn't work, try to find a domain key */
2381 sprintf(desc, "cifs:d:%s", ses->domainName);
2382 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2383 key = request_key(&key_type_logon, desc, "");
2390 down_read(&key->sem);
2391 upayload = user_key_payload(key);
2392 if (IS_ERR_OR_NULL(upayload)) {
2393 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2397 /* find first : in payload */
2398 payload = upayload->data;
2399 delim = strnchr(payload, upayload->datalen, ':');
2400 cifs_dbg(FYI, "payload=%s\n", payload);
2402 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
2408 len = delim - payload;
2409 if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
2410 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
2416 vol->username = kstrndup(payload, len, GFP_KERNEL);
2417 if (!vol->username) {
2418 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
2423 cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
2425 len = key->datalen - (len + 1);
2426 if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
2427 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
2429 kfree(vol->username);
2430 vol->username = NULL;
2435 vol->password = kstrndup(delim, len, GFP_KERNEL);
2436 if (!vol->password) {
2437 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
2440 kfree(vol->username);
2441 vol->username = NULL;
2450 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
2453 #else /* ! CONFIG_KEYS */
2455 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2456 struct cifs_ses *ses __attribute__((unused)))
2460 #endif /* CONFIG_KEYS */
2462 static struct cifs_ses *
2463 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2467 struct cifs_ses *ses;
2468 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2469 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2473 ses = cifs_find_smb_ses(server, volume_info);
2475 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
2478 mutex_lock(&ses->session_mutex);
2479 rc = cifs_negotiate_protocol(xid, ses);
2481 mutex_unlock(&ses->session_mutex);
2482 /* problem -- put our ses reference */
2483 cifs_put_smb_ses(ses);
2487 if (ses->need_reconnect) {
2488 cifs_dbg(FYI, "Session needs reconnect\n");
2489 rc = cifs_setup_session(xid, ses,
2490 volume_info->local_nls);
2492 mutex_unlock(&ses->session_mutex);
2493 /* problem -- put our reference */
2494 cifs_put_smb_ses(ses);
2499 mutex_unlock(&ses->session_mutex);
2501 /* existing SMB ses has a server reference already */
2502 cifs_put_tcp_session(server);
2507 cifs_dbg(FYI, "Existing smb sess not found\n");
2508 ses = sesInfoAlloc();
2512 /* new SMB session uses our server ref */
2513 ses->server = server;
2514 if (server->dstaddr.ss_family == AF_INET6)
2515 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2517 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2519 if (volume_info->username) {
2520 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2521 if (!ses->user_name)
2525 /* volume_info->password freed at unmount */
2526 if (volume_info->password) {
2527 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2531 if (volume_info->domainname) {
2532 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2533 if (!ses->domainName)
2536 ses->cred_uid = volume_info->cred_uid;
2537 ses->linux_uid = volume_info->linux_uid;
2539 ses->sectype = volume_info->sectype;
2540 ses->sign = volume_info->sign;
2542 mutex_lock(&ses->session_mutex);
2543 rc = cifs_negotiate_protocol(xid, ses);
2545 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2546 mutex_unlock(&ses->session_mutex);
2550 /* success, put it on the list */
2551 spin_lock(&cifs_tcp_ses_lock);
2552 list_add(&ses->smb_ses_list, &server->smb_ses_list);
2553 spin_unlock(&cifs_tcp_ses_lock);
2564 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2566 if (tcon->tidStatus == CifsExiting)
2568 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2573 static struct cifs_tcon *
2574 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2576 struct list_head *tmp;
2577 struct cifs_tcon *tcon;
2579 spin_lock(&cifs_tcp_ses_lock);
2580 list_for_each(tmp, &ses->tcon_list) {
2581 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2582 if (!match_tcon(tcon, unc))
2585 spin_unlock(&cifs_tcp_ses_lock);
2588 spin_unlock(&cifs_tcp_ses_lock);
2593 cifs_put_tcon(struct cifs_tcon *tcon)
2596 struct cifs_ses *ses = tcon->ses;
2598 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2599 spin_lock(&cifs_tcp_ses_lock);
2600 if (--tcon->tc_count > 0) {
2601 spin_unlock(&cifs_tcp_ses_lock);
2605 list_del_init(&tcon->tcon_list);
2606 spin_unlock(&cifs_tcp_ses_lock);
2609 if (ses->server->ops->tree_disconnect)
2610 ses->server->ops->tree_disconnect(xid, tcon);
2613 cifs_fscache_release_super_cookie(tcon);
2615 cifs_put_smb_ses(ses);
2618 static struct cifs_tcon *
2619 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2622 struct cifs_tcon *tcon;
2624 tcon = cifs_find_tcon(ses, volume_info->UNC);
2626 cifs_dbg(FYI, "Found match on UNC path\n");
2627 /* existing tcon already has a reference */
2628 cifs_put_smb_ses(ses);
2629 if (tcon->seal != volume_info->seal)
2630 cifs_dbg(VFS, "transport encryption setting conflicts with existing tid\n");
2634 if (!ses->server->ops->tree_connect) {
2639 tcon = tconInfoAlloc();
2646 if (volume_info->password) {
2647 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2648 if (!tcon->password) {
2655 * BB Do we need to wrap session_mutex around this TCon call and Unix
2656 * SetFS as we do on SessSetup and reconnect?
2659 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2660 volume_info->local_nls);
2662 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
2666 if (volume_info->nodfs) {
2667 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2668 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
2670 tcon->seal = volume_info->seal;
2671 tcon->use_persistent = false;
2672 /* check if SMB2 or later, CIFS does not support persistent handles */
2673 if (volume_info->persistent) {
2674 if (ses->server->vals->protocol_id == 0) {
2676 "SMB3 or later required for persistent handles\n");
2679 #ifdef CONFIG_CIFS_SMB2
2680 } else if (ses->server->capabilities &
2681 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2682 tcon->use_persistent = true;
2683 else /* persistent handles requested but not supported */ {
2685 "Persistent handles not supported on share\n");
2688 #endif /* CONFIG_CIFS_SMB2 */
2690 #ifdef CONFIG_CIFS_SMB2
2691 } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
2692 && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2693 && (volume_info->nopersistent == false)) {
2694 cifs_dbg(FYI, "enabling persistent handles\n");
2695 tcon->use_persistent = true;
2696 #endif /* CONFIG_CIFS_SMB2 */
2697 } else if (volume_info->resilient) {
2698 if (ses->server->vals->protocol_id == 0) {
2700 "SMB2.1 or later required for resilient handles\n");
2704 tcon->use_resilient = true;
2708 * We can have only one retry value for a connection to a share so for
2709 * resources mounted more than once to the same server share the last
2710 * value passed in for the retry flag is used.
2712 tcon->retry = volume_info->retry;
2713 tcon->nocase = volume_info->nocase;
2714 tcon->local_lease = volume_info->local_lease;
2715 INIT_LIST_HEAD(&tcon->pending_opens);
2717 spin_lock(&cifs_tcp_ses_lock);
2718 list_add(&tcon->tcon_list, &ses->tcon_list);
2719 spin_unlock(&cifs_tcp_ses_lock);
2721 cifs_fscache_get_super_cookie(tcon);
2731 cifs_put_tlink(struct tcon_link *tlink)
2733 if (!tlink || IS_ERR(tlink))
2736 if (!atomic_dec_and_test(&tlink->tl_count) ||
2737 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2738 tlink->tl_time = jiffies;
2742 if (!IS_ERR(tlink_tcon(tlink)))
2743 cifs_put_tcon(tlink_tcon(tlink));
2748 static inline struct tcon_link *
2749 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2751 return cifs_sb->master_tlink;
2755 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2757 struct cifs_sb_info *old = CIFS_SB(sb);
2758 struct cifs_sb_info *new = mnt_data->cifs_sb;
2760 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2763 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2764 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2768 * We want to share sb only if we don't specify an r/wsize or
2769 * specified r/wsize is greater than or equal to existing one.
2771 if (new->wsize && new->wsize < old->wsize)
2774 if (new->rsize && new->rsize < old->rsize)
2777 if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
2780 if (old->mnt_file_mode != new->mnt_file_mode ||
2781 old->mnt_dir_mode != new->mnt_dir_mode)
2784 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2787 if (old->actimeo != new->actimeo)
2794 match_prepath(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2796 struct cifs_sb_info *old = CIFS_SB(sb);
2797 struct cifs_sb_info *new = mnt_data->cifs_sb;
2799 if (old->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) {
2800 if (!(new->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH))
2802 /* The prepath should be null terminated strings */
2803 if (strcmp(new->prepath, old->prepath))
2812 cifs_match_super(struct super_block *sb, void *data)
2814 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2815 struct smb_vol *volume_info;
2816 struct cifs_sb_info *cifs_sb;
2817 struct TCP_Server_Info *tcp_srv;
2818 struct cifs_ses *ses;
2819 struct cifs_tcon *tcon;
2820 struct tcon_link *tlink;
2823 spin_lock(&cifs_tcp_ses_lock);
2824 cifs_sb = CIFS_SB(sb);
2825 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2826 if (IS_ERR(tlink)) {
2827 spin_unlock(&cifs_tcp_ses_lock);
2830 tcon = tlink_tcon(tlink);
2832 tcp_srv = ses->server;
2834 volume_info = mnt_data->vol;
2836 if (!match_server(tcp_srv, volume_info) ||
2837 !match_session(ses, volume_info) ||
2838 !match_tcon(tcon, volume_info->UNC) ||
2839 !match_prepath(sb, mnt_data)) {
2844 rc = compare_mount_options(sb, mnt_data);
2846 spin_unlock(&cifs_tcp_ses_lock);
2847 cifs_put_tlink(tlink);
2852 get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
2853 const struct nls_table *nls_codepage, unsigned int *num_referrals,
2854 struct dfs_info3_param **referrals, int remap)
2859 if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
2865 if (ses->ipc_tid == 0) {
2866 temp_unc = kmalloc(2 /* for slashes */ +
2867 strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2868 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
2869 if (temp_unc == NULL)
2873 strcpy(temp_unc + 2, ses->serverName);
2874 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2875 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2877 cifs_dbg(FYI, "Tcon rc = %d ipc_tid = %d\n", rc, ses->ipc_tid);
2881 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
2882 referrals, num_referrals,
2883 nls_codepage, remap);
2885 * BB - map targetUNCs to dfs_info3 structures, here or in
2886 * ses->server->ops->get_dfs_refer.
2892 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2893 static struct lock_class_key cifs_key[2];
2894 static struct lock_class_key cifs_slock_key[2];
2897 cifs_reclassify_socket4(struct socket *sock)
2899 struct sock *sk = sock->sk;
2900 BUG_ON(!sock_allow_reclassification(sk));
2901 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2902 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2906 cifs_reclassify_socket6(struct socket *sock)
2908 struct sock *sk = sock->sk;
2909 BUG_ON(!sock_allow_reclassification(sk));
2910 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2911 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2915 cifs_reclassify_socket4(struct socket *sock)
2920 cifs_reclassify_socket6(struct socket *sock)
2925 /* See RFC1001 section 14 on representation of Netbios names */
2926 static void rfc1002mangle(char *target, char *source, unsigned int length)
2930 for (i = 0, j = 0; i < (length); i++) {
2931 /* mask a nibble at a time and encode */
2932 target[j] = 'A' + (0x0F & (source[i] >> 4));
2933 target[j+1] = 'A' + (0x0F & source[i]);
2940 bind_socket(struct TCP_Server_Info *server)
2943 if (server->srcaddr.ss_family != AF_UNSPEC) {
2944 /* Bind to the specified local IP address */
2945 struct socket *socket = server->ssocket;
2946 rc = socket->ops->bind(socket,
2947 (struct sockaddr *) &server->srcaddr,
2948 sizeof(server->srcaddr));
2950 struct sockaddr_in *saddr4;
2951 struct sockaddr_in6 *saddr6;
2952 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2953 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2954 if (saddr6->sin6_family == AF_INET6)
2955 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
2956 &saddr6->sin6_addr, rc);
2958 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
2959 &saddr4->sin_addr.s_addr, rc);
2966 ip_rfc1001_connect(struct TCP_Server_Info *server)
2970 * some servers require RFC1001 sessinit before sending
2971 * negprot - BB check reconnection in case where second
2972 * sessinit is sent but no second negprot
2974 struct rfc1002_session_packet *ses_init_buf;
2975 struct smb_hdr *smb_buf;
2976 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2979 ses_init_buf->trailer.session_req.called_len = 32;
2981 if (server->server_RFC1001_name[0] != 0)
2982 rfc1002mangle(ses_init_buf->trailer.
2983 session_req.called_name,
2984 server->server_RFC1001_name,
2985 RFC1001_NAME_LEN_WITH_NULL);
2987 rfc1002mangle(ses_init_buf->trailer.
2988 session_req.called_name,
2989 DEFAULT_CIFS_CALLED_NAME,
2990 RFC1001_NAME_LEN_WITH_NULL);
2992 ses_init_buf->trailer.session_req.calling_len = 32;
2995 * calling name ends in null (byte 16) from old smb
2998 if (server->workstation_RFC1001_name[0] != 0)
2999 rfc1002mangle(ses_init_buf->trailer.
3000 session_req.calling_name,
3001 server->workstation_RFC1001_name,
3002 RFC1001_NAME_LEN_WITH_NULL);
3004 rfc1002mangle(ses_init_buf->trailer.
3005 session_req.calling_name,
3007 RFC1001_NAME_LEN_WITH_NULL);
3009 ses_init_buf->trailer.session_req.scope1 = 0;
3010 ses_init_buf->trailer.session_req.scope2 = 0;
3011 smb_buf = (struct smb_hdr *)ses_init_buf;
3013 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3014 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3015 rc = smb_send(server, smb_buf, 0x44);
3016 kfree(ses_init_buf);
3018 * RFC1001 layer in at least one server
3019 * requires very short break before negprot
3020 * presumably because not expecting negprot
3021 * to follow so fast. This is a simple
3022 * solution that works without
3023 * complicating the code and causes no
3024 * significant slowing down on mount
3027 usleep_range(1000, 2000);
3030 * else the negprot may still work without this
3031 * even though malloc failed
3038 generic_ip_connect(struct TCP_Server_Info *server)
3043 struct socket *socket = server->ssocket;
3044 struct sockaddr *saddr;
3046 saddr = (struct sockaddr *) &server->dstaddr;
3048 if (server->dstaddr.ss_family == AF_INET6) {
3049 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3050 slen = sizeof(struct sockaddr_in6);
3053 sport = ((struct sockaddr_in *) saddr)->sin_port;
3054 slen = sizeof(struct sockaddr_in);
3058 if (socket == NULL) {
3059 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3060 IPPROTO_TCP, &socket, 1);
3062 cifs_dbg(VFS, "Error %d creating socket\n", rc);
3063 server->ssocket = NULL;
3067 /* BB other socket options to set KEEPALIVE, NODELAY? */
3068 cifs_dbg(FYI, "Socket created\n");
3069 server->ssocket = socket;
3070 socket->sk->sk_allocation = GFP_NOFS;
3071 if (sfamily == AF_INET6)
3072 cifs_reclassify_socket6(socket);
3074 cifs_reclassify_socket4(socket);
3077 rc = bind_socket(server);
3082 * Eventually check for other socket options to change from
3083 * the default. sock_setsockopt not used because it expects
3086 socket->sk->sk_rcvtimeo = 7 * HZ;
3087 socket->sk->sk_sndtimeo = 5 * HZ;
3089 /* make the bufsizes depend on wsize/rsize and max requests */
3090 if (server->noautotune) {
3091 if (socket->sk->sk_sndbuf < (200 * 1024))
3092 socket->sk->sk_sndbuf = 200 * 1024;
3093 if (socket->sk->sk_rcvbuf < (140 * 1024))
3094 socket->sk->sk_rcvbuf = 140 * 1024;
3097 if (server->tcp_nodelay) {
3099 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3100 (char *)&val, sizeof(val));
3102 cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3106 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3107 socket->sk->sk_sndbuf,
3108 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3110 rc = socket->ops->connect(socket, saddr, slen, 0);
3112 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3113 sock_release(socket);
3114 server->ssocket = NULL;
3118 if (sport == htons(RFC1001_PORT))
3119 rc = ip_rfc1001_connect(server);
3125 ip_connect(struct TCP_Server_Info *server)
3128 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3129 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3131 if (server->dstaddr.ss_family == AF_INET6)
3132 sport = &addr6->sin6_port;
3134 sport = &addr->sin_port;
3139 /* try with 445 port at first */
3140 *sport = htons(CIFS_PORT);
3142 rc = generic_ip_connect(server);
3146 /* if it failed, try with 139 port */
3147 *sport = htons(RFC1001_PORT);
3150 return generic_ip_connect(server);
3153 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3154 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3156 /* if we are reconnecting then should we check to see if
3157 * any requested capabilities changed locally e.g. via
3158 * remount but we can not do much about it here
3159 * if they have (even if we could detect it by the following)
3160 * Perhaps we could add a backpointer to array of sb from tcon
3161 * or if we change to make all sb to same share the same
3162 * sb as NFS - then we only have one backpointer to sb.
3163 * What if we wanted to mount the server share twice once with
3164 * and once without posixacls or posix paths? */
3165 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3167 if (vol_info && vol_info->no_linux_ext) {
3168 tcon->fsUnixInfo.Capability = 0;
3169 tcon->unix_ext = 0; /* Unix Extensions disabled */
3170 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
3172 } else if (vol_info)
3173 tcon->unix_ext = 1; /* Unix Extensions supported */
3175 if (tcon->unix_ext == 0) {
3176 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
3180 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3181 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3182 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
3183 /* check for reconnect case in which we do not
3184 want to change the mount behavior if we can avoid it */
3185 if (vol_info == NULL) {
3186 /* turn off POSIX ACL and PATHNAMES if not set
3187 originally at mount time */
3188 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3189 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3190 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3191 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3192 cifs_dbg(VFS, "POSIXPATH support change\n");
3193 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3194 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3195 cifs_dbg(VFS, "possible reconnect error\n");
3196 cifs_dbg(VFS, "server disabled POSIX path support\n");
3200 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3201 cifs_dbg(VFS, "per-share encryption not supported yet\n");
3203 cap &= CIFS_UNIX_CAP_MASK;
3204 if (vol_info && vol_info->no_psx_acl)
3205 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3206 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3207 cifs_dbg(FYI, "negotiated posix acl support\n");
3209 cifs_sb->mnt_cifs_flags |=
3210 CIFS_MOUNT_POSIXACL;
3213 if (vol_info && vol_info->posix_paths == 0)
3214 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3215 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3216 cifs_dbg(FYI, "negotiate posix pathnames\n");
3218 cifs_sb->mnt_cifs_flags |=
3219 CIFS_MOUNT_POSIX_PATHS;
3222 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
3223 #ifdef CONFIG_CIFS_DEBUG2
3224 if (cap & CIFS_UNIX_FCNTL_CAP)
3225 cifs_dbg(FYI, "FCNTL cap\n");
3226 if (cap & CIFS_UNIX_EXTATTR_CAP)
3227 cifs_dbg(FYI, "EXTATTR cap\n");
3228 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3229 cifs_dbg(FYI, "POSIX path cap\n");
3230 if (cap & CIFS_UNIX_XATTR_CAP)
3231 cifs_dbg(FYI, "XATTR cap\n");
3232 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3233 cifs_dbg(FYI, "POSIX ACL cap\n");
3234 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3235 cifs_dbg(FYI, "very large read cap\n");
3236 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3237 cifs_dbg(FYI, "very large write cap\n");
3238 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3239 cifs_dbg(FYI, "transport encryption cap\n");
3240 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3241 cifs_dbg(FYI, "mandatory transport encryption cap\n");
3242 #endif /* CIFS_DEBUG2 */
3243 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3244 if (vol_info == NULL) {
3245 cifs_dbg(FYI, "resetting capabilities failed\n");
3247 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");
3253 int cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3254 struct cifs_sb_info *cifs_sb)
3256 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3258 spin_lock_init(&cifs_sb->tlink_tree_lock);
3259 cifs_sb->tlink_tree = RB_ROOT;
3262 * Temporarily set r/wsize for matching superblock. If we end up using
3263 * new sb then client will later negotiate it downward if needed.
3265 cifs_sb->rsize = pvolume_info->rsize;
3266 cifs_sb->wsize = pvolume_info->wsize;
3268 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3269 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3270 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3271 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3272 cifs_dbg(FYI, "file mode: 0x%hx dir mode: 0x%hx\n",
3273 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3275 cifs_sb->actimeo = pvolume_info->actimeo;
3276 cifs_sb->local_nls = pvolume_info->local_nls;
3278 if (pvolume_info->noperm)
3279 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3280 if (pvolume_info->setuids)
3281 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3282 if (pvolume_info->server_ino)
3283 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3284 if (pvolume_info->remap)
3285 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3286 if (pvolume_info->sfu_remap)
3287 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3288 if (pvolume_info->no_xattr)
3289 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3290 if (pvolume_info->sfu_emul)
3291 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3292 if (pvolume_info->nobrl)
3293 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3294 if (pvolume_info->nostrictsync)
3295 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3296 if (pvolume_info->mand_lock)
3297 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3298 if (pvolume_info->rwpidforward)
3299 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3300 if (pvolume_info->cifs_acl)
3301 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3302 if (pvolume_info->backupuid_specified) {
3303 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3304 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3306 if (pvolume_info->backupgid_specified) {
3307 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3308 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3310 if (pvolume_info->override_uid)
3311 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3312 if (pvolume_info->override_gid)
3313 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3314 if (pvolume_info->dynperm)
3315 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3316 if (pvolume_info->fsc)
3317 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3318 if (pvolume_info->multiuser)
3319 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3320 CIFS_MOUNT_NO_PERM);
3321 if (pvolume_info->strict_io)
3322 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3323 if (pvolume_info->direct_io) {
3324 cifs_dbg(FYI, "mounting share using direct i/o\n");
3325 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3327 if (pvolume_info->mfsymlinks) {
3328 if (pvolume_info->sfu_emul) {
3330 * Our SFU ("Services for Unix" emulation does not allow
3331 * creating symlinks but does allow reading existing SFU
3332 * symlinks (it does allow both creating and reading SFU
3333 * style mknod and FIFOs though). When "mfsymlinks" and
3334 * "sfu" are both enabled at the same time, it allows
3335 * reading both types of symlinks, but will only create
3336 * them with mfsymlinks format. This allows better
3337 * Apple compatibility (probably better for Samba too)
3338 * while still recognizing old Windows style symlinks.
3340 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
3342 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3345 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3346 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
3348 if (pvolume_info->prepath) {
3349 cifs_sb->prepath = kstrdup(pvolume_info->prepath, GFP_KERNEL);
3350 if (cifs_sb->prepath == NULL)
3358 cleanup_volume_info_contents(struct smb_vol *volume_info)
3360 kfree(volume_info->username);
3361 kzfree(volume_info->password);
3362 kfree(volume_info->UNC);
3363 kfree(volume_info->domainname);
3364 kfree(volume_info->iocharset);
3365 kfree(volume_info->prepath);
3369 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3373 cleanup_volume_info_contents(volume_info);
3378 #ifdef CONFIG_CIFS_DFS_UPCALL
3380 * cifs_build_path_to_root returns full path to root when we do not have an
3381 * exiting connection (tcon)
3384 build_unc_path_to_root(const struct smb_vol *vol,
3385 const struct cifs_sb_info *cifs_sb)
3387 char *full_path, *pos;
3388 unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
3389 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3391 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3392 if (full_path == NULL)
3393 return ERR_PTR(-ENOMEM);
3395 strncpy(full_path, vol->UNC, unc_len);
3396 pos = full_path + unc_len;
3399 *pos = CIFS_DIR_SEP(cifs_sb);
3400 strncpy(pos + 1, vol->prepath, pplen);
3404 *pos = '\0'; /* add trailing null */
3405 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3406 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
3411 * Perform a dfs referral query for a share and (optionally) prefix
3413 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3414 * to a string containing updated options for the submount. Otherwise it
3415 * will be left untouched.
3417 * Returns the rc from get_dfs_path to the caller, which can be used to
3418 * determine whether there were referrals.
3421 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
3422 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3426 unsigned int num_referrals = 0;
3427 struct dfs_info3_param *referrals = NULL;
3428 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3430 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3431 if (IS_ERR(full_path))
3432 return PTR_ERR(full_path);
3434 /* For DFS paths, skip the first '\' of the UNC */
3435 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3437 rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
3438 &num_referrals, &referrals, cifs_remap(cifs_sb));
3440 if (!rc && num_referrals > 0) {
3441 char *fake_devname = NULL;
3443 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3444 full_path + 1, referrals,
3447 free_dfs_info_array(referrals, num_referrals);
3449 if (IS_ERR(mdata)) {
3450 rc = PTR_ERR(mdata);
3453 cleanup_volume_info_contents(volume_info);
3454 rc = cifs_setup_volume_info(volume_info, mdata,
3457 kfree(fake_devname);
3458 kfree(cifs_sb->mountdata);
3459 cifs_sb->mountdata = mdata;
3467 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3468 const char *devname)
3472 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3475 if (volume_info->nullauth) {
3476 cifs_dbg(FYI, "Anonymous login\n");
3477 kfree(volume_info->username);
3478 volume_info->username = NULL;
3479 } else if (volume_info->username) {
3480 /* BB fixme parse for domain name here */
3481 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
3483 cifs_dbg(VFS, "No username specified\n");
3484 /* In userspace mount helper we can get user name from alternate
3485 locations such as env variables and files on disk */
3489 /* this is needed for ASCII cp to Unicode converts */
3490 if (volume_info->iocharset == NULL) {
3491 /* load_nls_default cannot return null */
3492 volume_info->local_nls = load_nls_default();
3494 volume_info->local_nls = load_nls(volume_info->iocharset);
3495 if (volume_info->local_nls == NULL) {
3496 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
3497 volume_info->iocharset);
3506 cifs_get_volume_info(char *mount_data, const char *devname)
3509 struct smb_vol *volume_info;
3511 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
3513 return ERR_PTR(-ENOMEM);
3515 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3517 cifs_cleanup_volume_info(volume_info);
3518 volume_info = ERR_PTR(rc);
3525 cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
3527 struct cifs_tcon *tcon,
3528 struct cifs_sb_info *cifs_sb,
3535 sep = CIFS_DIR_SEP(cifs_sb);
3538 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
3540 /* skip separators */
3545 /* next separator */
3546 while (*s && *s != sep)
3550 * temporarily null-terminate the path at the end of
3551 * the current component
3555 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3563 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3567 struct cifs_ses *ses;
3568 struct cifs_tcon *tcon;
3569 struct TCP_Server_Info *server;
3571 struct tcon_link *tlink;
3572 #ifdef CONFIG_CIFS_DFS_UPCALL
3573 int referral_walks_count = 0;
3576 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs");
3580 #ifdef CONFIG_CIFS_DFS_UPCALL
3582 /* cleanup activities if we're chasing a referral */
3583 if (referral_walks_count) {
3585 cifs_put_tcon(tcon);
3587 cifs_put_smb_ses(ses);
3589 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
3603 /* get a reference to a tcp session */
3604 server = cifs_get_tcp_session(volume_info);
3605 if (IS_ERR(server)) {
3606 rc = PTR_ERR(server);
3607 bdi_destroy(&cifs_sb->bdi);
3610 if ((volume_info->max_credits < 20) ||
3611 (volume_info->max_credits > 60000))
3612 server->max_credits = SMB2_MAX_CREDITS_AVAILABLE;
3614 server->max_credits = volume_info->max_credits;
3615 /* get a reference to a SMB session */
3616 ses = cifs_get_smb_ses(server, volume_info);
3620 goto mount_fail_check;
3623 #ifdef CONFIG_CIFS_SMB2
3624 if ((volume_info->persistent == true) && ((ses->server->capabilities &
3625 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES) == 0)) {
3626 cifs_dbg(VFS, "persistent handles not supported by server\n");
3628 goto mount_fail_check;
3630 #endif /* CONFIG_CIFS_SMB2*/
3632 /* search for existing tcon to this server share */
3633 tcon = cifs_get_tcon(ses, volume_info);
3637 goto remote_path_check;
3640 /* tell server which Unix caps we support */
3641 if (cap_unix(tcon->ses)) {
3642 /* reset of caps checks mount to see if unix extensions
3643 disabled for just this mount */
3644 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3645 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3646 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3647 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3649 goto mount_fail_check;
3652 tcon->unix_ext = 0; /* server does not support them */
3654 /* do not care if a following call succeed - informational */
3655 if (!tcon->ipc && server->ops->qfs_tcon)
3656 server->ops->qfs_tcon(xid, tcon);
3658 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3659 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
3661 /* tune readahead according to rsize */
3662 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_SIZE;
3665 #ifdef CONFIG_CIFS_DFS_UPCALL
3667 * Perform an unconditional check for whether there are DFS
3668 * referrals for this path without prefix, to provide support
3669 * for DFS referrals from w2k8 servers which don't seem to respond
3670 * with PATH_NOT_COVERED to requests that include the prefix.
3671 * Chase the referral if found, otherwise continue normally.
3673 if (referral_walks_count == 0) {
3674 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3677 referral_walks_count++;
3678 goto try_mount_again;
3683 /* check if a whole path is not remote */
3685 if (!server->ops->is_path_accessible) {
3687 goto mount_fail_check;
3690 * cifs_build_path_to_root works only when we have a valid tcon
3692 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3693 if (full_path == NULL) {
3695 goto mount_fail_check;
3697 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3699 if (rc != 0 && rc != -EREMOTE) {
3701 goto mount_fail_check;
3704 if (rc != -EREMOTE) {
3705 rc = cifs_are_all_path_components_accessible(server,
3709 cifs_dbg(VFS, "cannot query dirs between root and final path, "
3710 "enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
3711 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
3718 /* get referral if needed */
3719 if (rc == -EREMOTE) {
3720 #ifdef CONFIG_CIFS_DFS_UPCALL
3721 if (referral_walks_count > MAX_NESTED_LINKS) {
3723 * BB: when we implement proper loop detection,
3724 * we will remove this check. But now we need it
3725 * to prevent an indefinite loop if 'DFS tree' is
3726 * misconfigured (i.e. has loops).
3729 goto mount_fail_check;
3732 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
3735 referral_walks_count++;
3736 goto try_mount_again;
3738 goto mount_fail_check;
3739 #else /* No DFS support, return error on mount */
3745 goto mount_fail_check;
3747 /* now, hang the tcon off of the superblock */
3748 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3749 if (tlink == NULL) {
3751 goto mount_fail_check;
3754 tlink->tl_uid = ses->linux_uid;
3755 tlink->tl_tcon = tcon;
3756 tlink->tl_time = jiffies;
3757 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3758 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3760 cifs_sb->master_tlink = tlink;
3761 spin_lock(&cifs_sb->tlink_tree_lock);
3762 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3763 spin_unlock(&cifs_sb->tlink_tree_lock);
3765 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3769 /* on error free sesinfo and tcon struct if needed */
3771 /* If find_unc succeeded then rc == 0 so we can not end */
3772 /* up accidentally freeing someone elses tcon struct */
3774 cifs_put_tcon(tcon);
3776 cifs_put_smb_ses(ses);
3778 cifs_put_tcp_session(server);
3779 bdi_destroy(&cifs_sb->bdi);
3788 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3789 * pointer may be NULL.
3792 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
3793 const char *tree, struct cifs_tcon *tcon,
3794 const struct nls_table *nls_codepage)
3796 struct smb_hdr *smb_buffer;
3797 struct smb_hdr *smb_buffer_response;
3800 unsigned char *bcc_ptr;
3803 __u16 bytes_left, count;
3808 smb_buffer = cifs_buf_get();
3809 if (smb_buffer == NULL)
3812 smb_buffer_response = smb_buffer;
3814 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3815 NULL /*no tid */ , 4 /*wct */ );
3817 smb_buffer->Mid = get_next_mid(ses->server);
3818 smb_buffer->Uid = ses->Suid;
3819 pSMB = (TCONX_REQ *) smb_buffer;
3820 pSMBr = (TCONX_RSP *) smb_buffer_response;
3822 pSMB->AndXCommand = 0xFF;
3823 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3824 bcc_ptr = &pSMB->Password[0];
3825 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3826 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3827 *bcc_ptr = 0; /* password is null byte */
3828 bcc_ptr++; /* skip password */
3829 /* already aligned so no need to do it below */
3831 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3832 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3833 specified as required (when that support is added to
3834 the vfs in the future) as only NTLM or the much
3835 weaker LANMAN (which we do not send by default) is accepted
3836 by Samba (not sure whether other servers allow
3837 NTLMv2 password here) */
3838 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3839 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3840 (ses->sectype == LANMAN))
3841 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3842 ses->server->sec_mode &
3843 SECMODE_PW_ENCRYPT ? true : false,
3846 #endif /* CIFS_WEAK_PW_HASH */
3847 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3848 bcc_ptr, nls_codepage);
3850 cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
3852 cifs_buf_release(smb_buffer);
3856 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3857 if (ses->capabilities & CAP_UNICODE) {
3858 /* must align unicode strings */
3859 *bcc_ptr = 0; /* null byte password */
3864 if (ses->server->sign)
3865 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3867 if (ses->capabilities & CAP_STATUS32) {
3868 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3870 if (ses->capabilities & CAP_DFS) {
3871 smb_buffer->Flags2 |= SMBFLG2_DFS;
3873 if (ses->capabilities & CAP_UNICODE) {
3874 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3876 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3877 6 /* max utf8 char length in bytes */ *
3878 (/* server len*/ + 256 /* share len */), nls_codepage);
3879 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3880 bcc_ptr += 2; /* skip trailing null */
3881 } else { /* ASCII */
3882 strcpy(bcc_ptr, tree);
3883 bcc_ptr += strlen(tree) + 1;
3885 strcpy(bcc_ptr, "?????");
3886 bcc_ptr += strlen("?????");
3888 count = bcc_ptr - &pSMB->Password[0];
3889 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3890 pSMB->hdr.smb_buf_length) + count);
3891 pSMB->ByteCount = cpu_to_le16(count);
3893 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3896 /* above now done in SendReceive */
3897 if ((rc == 0) && (tcon != NULL)) {
3900 tcon->tidStatus = CifsGood;
3901 tcon->need_reconnect = false;
3902 tcon->tid = smb_buffer_response->Tid;
3903 bcc_ptr = pByteArea(smb_buffer_response);
3904 bytes_left = get_bcc(smb_buffer_response);
3905 length = strnlen(bcc_ptr, bytes_left - 2);
3906 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3912 /* skip service field (NB: this field is always ASCII) */
3914 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3915 (bcc_ptr[2] == 'C')) {
3916 cifs_dbg(FYI, "IPC connection\n");
3919 } else if (length == 2) {
3920 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3921 /* the most common case */
3922 cifs_dbg(FYI, "disk share connection\n");
3925 bcc_ptr += length + 1;
3926 bytes_left -= (length + 1);
3927 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
3929 /* mostly informational -- no need to fail on error here */
3930 kfree(tcon->nativeFileSystem);
3931 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
3932 bytes_left, is_unicode,
3935 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
3937 if ((smb_buffer_response->WordCount == 3) ||
3938 (smb_buffer_response->WordCount == 7))
3939 /* field is in same location */
3940 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3943 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
3944 } else if ((rc == 0) && tcon == NULL) {
3945 /* all we need to save for IPC$ connection */
3946 ses->ipc_tid = smb_buffer_response->Tid;
3949 cifs_buf_release(smb_buffer);
3953 static void delayed_free(struct rcu_head *p)
3955 struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
3956 unload_nls(sbi->local_nls);
3961 cifs_umount(struct cifs_sb_info *cifs_sb)
3963 struct rb_root *root = &cifs_sb->tlink_tree;
3964 struct rb_node *node;
3965 struct tcon_link *tlink;
3967 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3969 spin_lock(&cifs_sb->tlink_tree_lock);
3970 while ((node = rb_first(root))) {
3971 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3972 cifs_get_tlink(tlink);
3973 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3974 rb_erase(node, root);
3976 spin_unlock(&cifs_sb->tlink_tree_lock);
3977 cifs_put_tlink(tlink);
3978 spin_lock(&cifs_sb->tlink_tree_lock);
3980 spin_unlock(&cifs_sb->tlink_tree_lock);
3982 bdi_destroy(&cifs_sb->bdi);
3983 kfree(cifs_sb->mountdata);
3984 kfree(cifs_sb->prepath);
3985 call_rcu(&cifs_sb->rcu, delayed_free);
3989 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
3992 struct TCP_Server_Info *server = ses->server;
3994 if (!server->ops->need_neg || !server->ops->negotiate)
3997 /* only send once per connect */
3998 if (!server->ops->need_neg(server))
4001 set_credits(server, 1);
4003 rc = server->ops->negotiate(xid, ses);
4005 spin_lock(&GlobalMid_Lock);
4006 if (server->tcpStatus == CifsNeedNegotiate)
4007 server->tcpStatus = CifsGood;
4010 spin_unlock(&GlobalMid_Lock);
4017 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
4018 struct nls_table *nls_info)
4021 struct TCP_Server_Info *server = ses->server;
4023 ses->capabilities = server->capabilities;
4024 if (linuxExtEnabled == 0)
4025 ses->capabilities &= (~server->vals->cap_unix);
4027 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
4028 server->sec_mode, server->capabilities, server->timeAdj);
4030 if (server->ops->sess_setup)
4031 rc = server->ops->sess_setup(xid, ses, nls_info);
4034 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
4040 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
4042 vol->sectype = ses->sectype;
4044 /* krb5 is special, since we don't need username or pw */
4045 if (vol->sectype == Kerberos)
4048 return cifs_set_cifscreds(vol, ses);
4051 static struct cifs_tcon *
4052 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
4055 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4056 struct cifs_ses *ses;
4057 struct cifs_tcon *tcon = NULL;
4058 struct smb_vol *vol_info;
4060 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
4061 if (vol_info == NULL)
4062 return ERR_PTR(-ENOMEM);
4064 vol_info->local_nls = cifs_sb->local_nls;
4065 vol_info->linux_uid = fsuid;
4066 vol_info->cred_uid = fsuid;
4067 vol_info->UNC = master_tcon->treeName;
4068 vol_info->retry = master_tcon->retry;
4069 vol_info->nocase = master_tcon->nocase;
4070 vol_info->local_lease = master_tcon->local_lease;
4071 vol_info->no_linux_ext = !master_tcon->unix_ext;
4072 vol_info->sectype = master_tcon->ses->sectype;
4073 vol_info->sign = master_tcon->ses->sign;
4075 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4081 /* get a reference for the same TCP session */
4082 spin_lock(&cifs_tcp_ses_lock);
4083 ++master_tcon->ses->server->srv_count;
4084 spin_unlock(&cifs_tcp_ses_lock);
4086 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4088 tcon = (struct cifs_tcon *)ses;
4089 cifs_put_tcp_session(master_tcon->ses->server);
4093 tcon = cifs_get_tcon(ses, vol_info);
4095 cifs_put_smb_ses(ses);
4100 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4102 kfree(vol_info->username);
4103 kfree(vol_info->password);
4110 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4112 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4115 /* find and return a tlink with given uid */
4116 static struct tcon_link *
4117 tlink_rb_search(struct rb_root *root, kuid_t uid)
4119 struct rb_node *node = root->rb_node;
4120 struct tcon_link *tlink;
4123 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4125 if (uid_gt(tlink->tl_uid, uid))
4126 node = node->rb_left;
4127 else if (uid_lt(tlink->tl_uid, uid))
4128 node = node->rb_right;
4135 /* insert a tcon_link into the tree */
4137 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4139 struct rb_node **new = &(root->rb_node), *parent = NULL;
4140 struct tcon_link *tlink;
4143 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4146 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
4147 new = &((*new)->rb_left);
4149 new = &((*new)->rb_right);
4152 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4153 rb_insert_color(&new_tlink->tl_rbnode, root);
4157 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4160 * If the superblock doesn't refer to a multiuser mount, then just return
4161 * the master tcon for the mount.
4163 * First, search the rbtree for an existing tcon for this fsuid. If one
4164 * exists, then check to see if it's pending construction. If it is then wait
4165 * for construction to complete. Once it's no longer pending, check to see if
4166 * it failed and either return an error or retry construction, depending on
4169 * If one doesn't exist then insert a new tcon_link struct into the tree and
4170 * try to construct a new one.
4173 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4176 kuid_t fsuid = current_fsuid();
4177 struct tcon_link *tlink, *newtlink;
4179 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4180 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4182 spin_lock(&cifs_sb->tlink_tree_lock);
4183 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4185 cifs_get_tlink(tlink);
4186 spin_unlock(&cifs_sb->tlink_tree_lock);
4188 if (tlink == NULL) {
4189 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4190 if (newtlink == NULL)
4191 return ERR_PTR(-ENOMEM);
4192 newtlink->tl_uid = fsuid;
4193 newtlink->tl_tcon = ERR_PTR(-EACCES);
4194 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4195 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4196 cifs_get_tlink(newtlink);
4198 spin_lock(&cifs_sb->tlink_tree_lock);
4199 /* was one inserted after previous search? */
4200 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4202 cifs_get_tlink(tlink);
4203 spin_unlock(&cifs_sb->tlink_tree_lock);
4205 goto wait_for_construction;
4208 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4209 spin_unlock(&cifs_sb->tlink_tree_lock);
4211 wait_for_construction:
4212 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4213 TASK_INTERRUPTIBLE);
4215 cifs_put_tlink(tlink);
4216 return ERR_PTR(-ERESTARTSYS);
4219 /* if it's good, return it */
4220 if (!IS_ERR(tlink->tl_tcon))
4223 /* return error if we tried this already recently */
4224 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4225 cifs_put_tlink(tlink);
4226 return ERR_PTR(-EACCES);
4229 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4230 goto wait_for_construction;
4233 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4234 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4235 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4237 if (IS_ERR(tlink->tl_tcon)) {
4238 cifs_put_tlink(tlink);
4239 return ERR_PTR(-EACCES);
4246 * periodic workqueue job that scans tcon_tree for a superblock and closes
4250 cifs_prune_tlinks(struct work_struct *work)
4252 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4254 struct rb_root *root = &cifs_sb->tlink_tree;
4255 struct rb_node *node = rb_first(root);
4256 struct rb_node *tmp;
4257 struct tcon_link *tlink;
4260 * Because we drop the spinlock in the loop in order to put the tlink
4261 * it's not guarded against removal of links from the tree. The only
4262 * places that remove entries from the tree are this function and
4263 * umounts. Because this function is non-reentrant and is canceled
4264 * before umount can proceed, this is safe.
4266 spin_lock(&cifs_sb->tlink_tree_lock);
4267 node = rb_first(root);
4268 while (node != NULL) {
4270 node = rb_next(tmp);
4271 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4273 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4274 atomic_read(&tlink->tl_count) != 0 ||
4275 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4278 cifs_get_tlink(tlink);
4279 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4280 rb_erase(tmp, root);
4282 spin_unlock(&cifs_sb->tlink_tree_lock);
4283 cifs_put_tlink(tlink);
4284 spin_lock(&cifs_sb->tlink_tree_lock);
4286 spin_unlock(&cifs_sb->tlink_tree_lock);
4288 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,