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"
55 #ifdef CONFIG_CIFS_SMB2
56 #include "smb2proto.h"
60 #define RFC1001_PORT 139
62 extern mempool_t *cifs_req_poolp;
64 /* FIXME: should these be tunable? */
65 #define TLINK_ERROR_EXPIRE (1 * HZ)
66 #define TLINK_IDLE_EXPIRE (600 * HZ)
70 /* Mount options that take no arguments */
71 Opt_user_xattr, Opt_nouser_xattr,
72 Opt_forceuid, Opt_noforceuid,
73 Opt_forcegid, Opt_noforcegid,
74 Opt_noblocksend, Opt_noautotune,
75 Opt_hard, Opt_soft, Opt_perm, Opt_noperm,
76 Opt_mapposix, Opt_nomapposix,
77 Opt_mapchars, Opt_nomapchars, Opt_sfu,
78 Opt_nosfu, Opt_nodfs, Opt_posixpaths,
79 Opt_noposixpaths, Opt_nounix,
82 Opt_forcemandatorylock, Opt_setuids,
83 Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
84 Opt_nohard, Opt_nosoft,
86 Opt_nostrictsync, Opt_strictsync,
87 Opt_serverino, Opt_noserverino,
88 Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
89 Opt_acl, Opt_noacl, Opt_locallease,
90 Opt_sign, Opt_seal, Opt_noac,
91 Opt_fsc, Opt_mfsymlinks,
92 Opt_multiuser, Opt_sloppy, Opt_nosharesock,
93 Opt_persistent, Opt_nopersistent,
94 Opt_resilient, Opt_noresilient,
96 /* Mount options which take numeric value */
97 Opt_backupuid, Opt_backupgid, Opt_uid,
98 Opt_cruid, Opt_gid, Opt_file_mode,
99 Opt_dirmode, Opt_port,
100 Opt_rsize, Opt_wsize, Opt_actimeo,
102 /* Mount options which take string value */
103 Opt_user, Opt_pass, Opt_ip,
104 Opt_domain, Opt_srcaddr, Opt_iocharset,
105 Opt_netbiosname, Opt_servern,
106 Opt_ver, Opt_vers, Opt_sec, Opt_cache,
108 /* Mount options to be ignored */
111 /* Options which could be blank */
119 static const match_table_t cifs_mount_option_tokens = {
121 { Opt_user_xattr, "user_xattr" },
122 { Opt_nouser_xattr, "nouser_xattr" },
123 { Opt_forceuid, "forceuid" },
124 { Opt_noforceuid, "noforceuid" },
125 { Opt_forcegid, "forcegid" },
126 { Opt_noforcegid, "noforcegid" },
127 { Opt_noblocksend, "noblocksend" },
128 { Opt_noautotune, "noautotune" },
129 { Opt_hard, "hard" },
130 { Opt_soft, "soft" },
131 { Opt_perm, "perm" },
132 { Opt_noperm, "noperm" },
133 { Opt_mapchars, "mapchars" }, /* SFU style */
134 { Opt_nomapchars, "nomapchars" },
135 { Opt_mapposix, "mapposix" }, /* SFM style */
136 { Opt_nomapposix, "nomapposix" },
138 { Opt_nosfu, "nosfu" },
139 { Opt_nodfs, "nodfs" },
140 { Opt_posixpaths, "posixpaths" },
141 { Opt_noposixpaths, "noposixpaths" },
142 { Opt_nounix, "nounix" },
143 { Opt_nounix, "nolinux" },
144 { Opt_nocase, "nocase" },
145 { Opt_nocase, "ignorecase" },
147 { Opt_nobrl, "nobrl" },
148 { Opt_nobrl, "nolock" },
149 { Opt_forcemandatorylock, "forcemandatorylock" },
150 { Opt_forcemandatorylock, "forcemand" },
151 { Opt_setuids, "setuids" },
152 { Opt_nosetuids, "nosetuids" },
153 { Opt_dynperm, "dynperm" },
154 { Opt_nodynperm, "nodynperm" },
155 { Opt_nohard, "nohard" },
156 { Opt_nosoft, "nosoft" },
157 { Opt_nointr, "nointr" },
158 { Opt_intr, "intr" },
159 { Opt_nostrictsync, "nostrictsync" },
160 { Opt_strictsync, "strictsync" },
161 { Opt_serverino, "serverino" },
162 { Opt_noserverino, "noserverino" },
163 { Opt_rwpidforward, "rwpidforward" },
164 { Opt_cifsacl, "cifsacl" },
165 { Opt_nocifsacl, "nocifsacl" },
167 { Opt_noacl, "noacl" },
168 { Opt_locallease, "locallease" },
169 { Opt_sign, "sign" },
170 { Opt_seal, "seal" },
171 { Opt_noac, "noac" },
173 { Opt_mfsymlinks, "mfsymlinks" },
174 { Opt_multiuser, "multiuser" },
175 { Opt_sloppy, "sloppy" },
176 { Opt_nosharesock, "nosharesock" },
177 { Opt_persistent, "persistenthandles"},
178 { Opt_nopersistent, "nopersistenthandles"},
179 { Opt_resilient, "resilienthandles"},
180 { Opt_noresilient, "noresilienthandles"},
182 { Opt_backupuid, "backupuid=%s" },
183 { Opt_backupgid, "backupgid=%s" },
184 { Opt_uid, "uid=%s" },
185 { Opt_cruid, "cruid=%s" },
186 { Opt_gid, "gid=%s" },
187 { Opt_file_mode, "file_mode=%s" },
188 { Opt_dirmode, "dirmode=%s" },
189 { Opt_dirmode, "dir_mode=%s" },
190 { Opt_port, "port=%s" },
191 { Opt_rsize, "rsize=%s" },
192 { Opt_wsize, "wsize=%s" },
193 { Opt_actimeo, "actimeo=%s" },
195 { Opt_blank_user, "user=" },
196 { Opt_blank_user, "username=" },
197 { Opt_user, "user=%s" },
198 { Opt_user, "username=%s" },
199 { Opt_blank_pass, "pass=" },
200 { Opt_blank_pass, "password=" },
201 { Opt_pass, "pass=%s" },
202 { Opt_pass, "password=%s" },
203 { Opt_blank_ip, "ip=" },
204 { Opt_blank_ip, "addr=" },
206 { Opt_ip, "addr=%s" },
207 { Opt_ignore, "unc=%s" },
208 { Opt_ignore, "target=%s" },
209 { Opt_ignore, "path=%s" },
210 { Opt_domain, "dom=%s" },
211 { Opt_domain, "domain=%s" },
212 { Opt_domain, "workgroup=%s" },
213 { Opt_srcaddr, "srcaddr=%s" },
214 { Opt_ignore, "prefixpath=%s" },
215 { Opt_iocharset, "iocharset=%s" },
216 { Opt_netbiosname, "netbiosname=%s" },
217 { Opt_servern, "servern=%s" },
218 { Opt_ver, "ver=%s" },
219 { Opt_vers, "vers=%s" },
220 { Opt_sec, "sec=%s" },
221 { Opt_cache, "cache=%s" },
223 { Opt_ignore, "cred" },
224 { Opt_ignore, "credentials" },
225 { Opt_ignore, "cred=%s" },
226 { Opt_ignore, "credentials=%s" },
227 { Opt_ignore, "guest" },
228 { Opt_ignore, "rw" },
229 { Opt_ignore, "ro" },
230 { Opt_ignore, "suid" },
231 { Opt_ignore, "nosuid" },
232 { Opt_ignore, "exec" },
233 { Opt_ignore, "noexec" },
234 { Opt_ignore, "nodev" },
235 { Opt_ignore, "noauto" },
236 { Opt_ignore, "dev" },
237 { Opt_ignore, "mand" },
238 { Opt_ignore, "nomand" },
239 { Opt_ignore, "_netdev" },
245 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
246 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
247 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
248 Opt_sec_ntlmv2i, Opt_sec_lanman,
254 static const match_table_t cifs_secflavor_tokens = {
255 { Opt_sec_krb5, "krb5" },
256 { Opt_sec_krb5i, "krb5i" },
257 { Opt_sec_krb5p, "krb5p" },
258 { Opt_sec_ntlmsspi, "ntlmsspi" },
259 { Opt_sec_ntlmssp, "ntlmssp" },
260 { Opt_ntlm, "ntlm" },
261 { Opt_sec_ntlmi, "ntlmi" },
262 { Opt_sec_ntlmv2, "nontlm" },
263 { Opt_sec_ntlmv2, "ntlmv2" },
264 { Opt_sec_ntlmv2i, "ntlmv2i" },
265 { Opt_sec_lanman, "lanman" },
266 { Opt_sec_none, "none" },
268 { Opt_sec_err, NULL }
279 static const match_table_t cifs_cacheflavor_tokens = {
280 { Opt_cache_loose, "loose" },
281 { Opt_cache_strict, "strict" },
282 { Opt_cache_none, "none" },
283 { Opt_cache_err, NULL }
286 static const match_table_t cifs_smb_version_tokens = {
287 { Smb_1, SMB1_VERSION_STRING },
288 { Smb_20, SMB20_VERSION_STRING},
289 { Smb_21, SMB21_VERSION_STRING },
290 { Smb_30, SMB30_VERSION_STRING },
291 { Smb_302, SMB302_VERSION_STRING },
292 #ifdef CONFIG_CIFS_SMB311
293 { Smb_311, SMB311_VERSION_STRING },
294 { Smb_311, ALT_SMB311_VERSION_STRING },
296 { Smb_version_err, NULL }
299 static int ip_connect(struct TCP_Server_Info *server);
300 static int generic_ip_connect(struct TCP_Server_Info *server);
301 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
302 static void cifs_prune_tlinks(struct work_struct *work);
303 static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
304 const char *devname);
307 * cifs tcp session reconnection
309 * mark tcp session as reconnecting so temporarily locked
310 * mark all smb sessions as reconnecting for tcp session
311 * reconnect tcp session
312 * wake up waiters on reconnection? - (not needed currently)
315 cifs_reconnect(struct TCP_Server_Info *server)
318 struct list_head *tmp, *tmp2;
319 struct cifs_ses *ses;
320 struct cifs_tcon *tcon;
321 struct mid_q_entry *mid_entry;
322 struct list_head retry_list;
324 spin_lock(&GlobalMid_Lock);
325 if (server->tcpStatus == CifsExiting) {
326 /* the demux thread will exit normally
327 next time through the loop */
328 spin_unlock(&GlobalMid_Lock);
331 server->tcpStatus = CifsNeedReconnect;
332 spin_unlock(&GlobalMid_Lock);
334 #ifdef CONFIG_CIFS_SMB2
335 server->max_read = 0;
338 cifs_dbg(FYI, "Reconnecting tcp session\n");
340 /* before reconnecting the tcp session, mark the smb session (uid)
341 and the tid bad so they are not used until reconnected */
342 cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
344 spin_lock(&cifs_tcp_ses_lock);
345 list_for_each(tmp, &server->smb_ses_list) {
346 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
347 ses->need_reconnect = true;
349 list_for_each(tmp2, &ses->tcon_list) {
350 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
351 tcon->need_reconnect = true;
354 spin_unlock(&cifs_tcp_ses_lock);
356 /* do not want to be sending data on a socket we are freeing */
357 cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
358 mutex_lock(&server->srv_mutex);
359 if (server->ssocket) {
360 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
361 server->ssocket->state, server->ssocket->flags);
362 kernel_sock_shutdown(server->ssocket, SHUT_WR);
363 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
364 server->ssocket->state, server->ssocket->flags);
365 sock_release(server->ssocket);
366 server->ssocket = NULL;
368 server->sequence_number = 0;
369 server->session_estab = false;
370 kfree(server->session_key.response);
371 server->session_key.response = NULL;
372 server->session_key.len = 0;
373 server->lstrp = jiffies;
375 /* mark submitted MIDs for retry and issue callback */
376 INIT_LIST_HEAD(&retry_list);
377 cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
378 spin_lock(&GlobalMid_Lock);
379 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
380 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
381 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
382 mid_entry->mid_state = MID_RETRY_NEEDED;
383 list_move(&mid_entry->qhead, &retry_list);
385 spin_unlock(&GlobalMid_Lock);
386 mutex_unlock(&server->srv_mutex);
388 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
389 list_for_each_safe(tmp, tmp2, &retry_list) {
390 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
391 list_del_init(&mid_entry->qhead);
392 mid_entry->callback(mid_entry);
398 /* we should try only the port we connected to before */
399 mutex_lock(&server->srv_mutex);
400 rc = generic_ip_connect(server);
402 cifs_dbg(FYI, "reconnect error %d\n", rc);
403 mutex_unlock(&server->srv_mutex);
406 atomic_inc(&tcpSesReconnectCount);
407 spin_lock(&GlobalMid_Lock);
408 if (server->tcpStatus != CifsExiting)
409 server->tcpStatus = CifsNeedNegotiate;
410 spin_unlock(&GlobalMid_Lock);
411 mutex_unlock(&server->srv_mutex);
413 } while (server->tcpStatus == CifsNeedReconnect);
419 cifs_echo_request(struct work_struct *work)
422 struct TCP_Server_Info *server = container_of(work,
423 struct TCP_Server_Info, echo.work);
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 + SMB_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, SMB_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 * SMB_ECHO_INTERVAL)) {
496 cifs_dbg(VFS, "Server %s has not responded in %d seconds. Reconnecting...\n",
497 server->hostname, (2 * SMB_ECHO_INTERVAL) / HZ);
498 cifs_reconnect(server);
499 wake_up(&server->response_q);
507 * kvec_array_init - clone a kvec array, and advance into it
508 * @new: pointer to memory for cloned array
509 * @iov: pointer to original array
510 * @nr_segs: number of members in original array
511 * @bytes: number of bytes to advance into the cloned array
513 * This function will copy the array provided in iov to a section of memory
514 * and advance the specified number of bytes into the new array. It returns
515 * the number of segments in the new array. "new" must be at least as big as
516 * the original iov array.
519 kvec_array_init(struct kvec *new, struct kvec *iov, unsigned int nr_segs,
524 while (bytes || !iov->iov_len) {
525 int copy = min(bytes, iov->iov_len);
529 if (iov->iov_len == base) {
535 memcpy(new, iov, sizeof(*iov) * nr_segs);
536 new->iov_base += base;
537 new->iov_len -= base;
542 get_server_iovec(struct TCP_Server_Info *server, unsigned int nr_segs)
544 struct kvec *new_iov;
546 if (server->iov && nr_segs <= server->nr_iov)
549 /* not big enough -- allocate a new one and release the old */
550 new_iov = kmalloc(sizeof(*new_iov) * nr_segs, GFP_NOFS);
553 server->iov = new_iov;
554 server->nr_iov = nr_segs;
560 cifs_readv_from_socket(struct TCP_Server_Info *server, struct kvec *iov_orig,
561 unsigned int nr_segs, unsigned int to_read)
566 struct msghdr smb_msg;
569 iov = get_server_iovec(server, nr_segs);
573 smb_msg.msg_control = NULL;
574 smb_msg.msg_controllen = 0;
576 for (total_read = 0; to_read; total_read += length, to_read -= length) {
579 if (server_unresponsive(server)) {
580 total_read = -ECONNABORTED;
584 segs = kvec_array_init(iov, iov_orig, nr_segs, total_read);
586 length = kernel_recvmsg(server->ssocket, &smb_msg,
587 iov, segs, to_read, 0);
589 if (server->tcpStatus == CifsExiting) {
590 total_read = -ESHUTDOWN;
592 } else if (server->tcpStatus == CifsNeedReconnect) {
593 cifs_reconnect(server);
594 total_read = -ECONNABORTED;
596 } else if (length == -ERESTARTSYS ||
600 * Minimum sleep to prevent looping, allowing socket
601 * to clear and app threads to set tcpStatus
602 * CifsNeedReconnect if server hung.
604 usleep_range(1000, 2000);
607 } else if (length <= 0) {
608 cifs_dbg(FYI, "Received no data or error: expecting %d\n"
609 "got %d", to_read, length);
610 cifs_reconnect(server);
611 total_read = -ECONNABORTED;
619 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
620 unsigned int to_read)
625 iov.iov_len = to_read;
627 return cifs_readv_from_socket(server, &iov, 1, to_read);
631 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
634 * The first byte big endian of the length field,
635 * is actually not part of the length but the type
636 * with the most common, zero, as regular data.
639 case RFC1002_SESSION_MESSAGE:
640 /* Regular SMB response */
642 case RFC1002_SESSION_KEEP_ALIVE:
643 cifs_dbg(FYI, "RFC 1002 session keep alive\n");
645 case RFC1002_POSITIVE_SESSION_RESPONSE:
646 cifs_dbg(FYI, "RFC 1002 positive session response\n");
648 case RFC1002_NEGATIVE_SESSION_RESPONSE:
650 * We get this from Windows 98 instead of an error on
651 * SMB negprot response.
653 cifs_dbg(FYI, "RFC 1002 negative session response\n");
654 /* give server a second to clean up */
657 * Always try 445 first on reconnect since we get NACK
658 * on some if we ever connected to port 139 (the NACK
659 * is since we do not begin with RFC1001 session
662 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
663 cifs_reconnect(server);
664 wake_up(&server->response_q);
667 cifs_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
668 cifs_reconnect(server);
675 dequeue_mid(struct mid_q_entry *mid, bool malformed)
677 #ifdef CONFIG_CIFS_STATS2
678 mid->when_received = jiffies;
680 spin_lock(&GlobalMid_Lock);
682 mid->mid_state = MID_RESPONSE_RECEIVED;
684 mid->mid_state = MID_RESPONSE_MALFORMED;
685 list_del_init(&mid->qhead);
686 spin_unlock(&GlobalMid_Lock);
690 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
691 char *buf, int malformed)
693 if (server->ops->check_trans2 &&
694 server->ops->check_trans2(mid, server, buf, malformed))
697 mid->large_buf = server->large_buf;
698 /* Was previous buf put in mpx struct for multi-rsp? */
699 if (!mid->multiRsp) {
700 /* smb buffer will be freed by user thread */
701 if (server->large_buf)
702 server->bigbuf = NULL;
704 server->smallbuf = NULL;
706 dequeue_mid(mid, malformed);
709 static void clean_demultiplex_info(struct TCP_Server_Info *server)
713 /* take it off the list, if it's not already */
714 spin_lock(&cifs_tcp_ses_lock);
715 list_del_init(&server->tcp_ses_list);
716 spin_unlock(&cifs_tcp_ses_lock);
718 spin_lock(&GlobalMid_Lock);
719 server->tcpStatus = CifsExiting;
720 spin_unlock(&GlobalMid_Lock);
721 wake_up_all(&server->response_q);
723 /* check if we have blocked requests that need to free */
724 spin_lock(&server->req_lock);
725 if (server->credits <= 0)
727 spin_unlock(&server->req_lock);
729 * Although there should not be any requests blocked on this queue it
730 * can not hurt to be paranoid and try to wake up requests that may
731 * haven been blocked when more than 50 at time were on the wire to the
732 * same server - they now will see the session is in exit state and get
733 * out of SendReceive.
735 wake_up_all(&server->request_q);
736 /* give those requests time to exit */
739 if (server->ssocket) {
740 sock_release(server->ssocket);
741 server->ssocket = NULL;
744 if (!list_empty(&server->pending_mid_q)) {
745 struct list_head dispose_list;
746 struct mid_q_entry *mid_entry;
747 struct list_head *tmp, *tmp2;
749 INIT_LIST_HEAD(&dispose_list);
750 spin_lock(&GlobalMid_Lock);
751 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
752 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
753 cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid);
754 mid_entry->mid_state = MID_SHUTDOWN;
755 list_move(&mid_entry->qhead, &dispose_list);
757 spin_unlock(&GlobalMid_Lock);
759 /* now walk dispose list and issue callbacks */
760 list_for_each_safe(tmp, tmp2, &dispose_list) {
761 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
762 cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid);
763 list_del_init(&mid_entry->qhead);
764 mid_entry->callback(mid_entry);
766 /* 1/8th of sec is more than enough time for them to exit */
770 if (!list_empty(&server->pending_mid_q)) {
772 * mpx threads have not exited yet give them at least the smb
773 * send timeout time for long ops.
775 * Due to delays on oplock break requests, we need to wait at
776 * least 45 seconds before giving up on a request getting a
777 * response and going ahead and killing cifsd.
779 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
782 * If threads still have not exited they are probably never
783 * coming home not much else we can do but free the memory.
787 kfree(server->hostname);
791 length = atomic_dec_return(&tcpSesAllocCount);
793 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
797 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
800 char *buf = server->smallbuf;
801 unsigned int pdu_length = get_rfc1002_length(buf);
803 /* make sure this will fit in a large buffer */
804 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) - 4) {
805 cifs_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
806 cifs_reconnect(server);
807 wake_up(&server->response_q);
808 return -ECONNABORTED;
811 /* switch to large buffer if too big for a small one */
812 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
813 server->large_buf = true;
814 memcpy(server->bigbuf, buf, server->total_read);
815 buf = server->bigbuf;
818 /* now read the rest */
819 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
820 pdu_length - HEADER_SIZE(server) + 1 + 4);
823 server->total_read += length;
825 dump_smb(buf, server->total_read);
828 * We know that we received enough to get to the MID as we
829 * checked the pdu_length earlier. Now check to see
830 * if the rest of the header is OK. We borrow the length
831 * var for the rest of the loop to avoid a new stack var.
833 * 48 bytes is enough to display the header and a little bit
834 * into the payload for debugging purposes.
836 length = server->ops->check_message(buf, server->total_read);
838 cifs_dump_mem("Bad SMB: ", buf,
839 min_t(unsigned int, server->total_read, 48));
841 if (server->ops->is_status_pending &&
842 server->ops->is_status_pending(buf, server, length))
848 handle_mid(mid, server, buf, length);
853 cifs_demultiplex_thread(void *p)
856 struct TCP_Server_Info *server = p;
857 unsigned int pdu_length;
859 struct task_struct *task_to_wake = NULL;
860 struct mid_q_entry *mid_entry;
862 current->flags |= PF_MEMALLOC;
863 cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
865 length = atomic_inc_return(&tcpSesAllocCount);
867 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
870 while (server->tcpStatus != CifsExiting) {
874 if (!allocate_buffers(server))
877 server->large_buf = false;
878 buf = server->smallbuf;
879 pdu_length = 4; /* enough to get RFC1001 header */
881 length = cifs_read_from_socket(server, buf, pdu_length);
884 server->total_read = length;
887 * The right amount was read from socket - 4 bytes,
888 * so we can now interpret the length field.
890 pdu_length = get_rfc1002_length(buf);
892 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
893 if (!is_smb_response(server, buf[0]))
896 /* make sure we have enough to get to the MID */
897 if (pdu_length < HEADER_SIZE(server) - 1 - 4) {
898 cifs_dbg(VFS, "SMB response too short (%u bytes)\n",
900 cifs_reconnect(server);
901 wake_up(&server->response_q);
905 /* read down to the MID */
906 length = cifs_read_from_socket(server, buf + 4,
907 HEADER_SIZE(server) - 1 - 4);
910 server->total_read += length;
912 mid_entry = server->ops->find_mid(server, buf);
914 if (!mid_entry || !mid_entry->receive)
915 length = standard_receive3(server, mid_entry);
917 length = mid_entry->receive(server, mid_entry);
922 if (server->large_buf)
923 buf = server->bigbuf;
925 server->lstrp = jiffies;
926 if (mid_entry != NULL) {
927 if (!mid_entry->multiRsp || mid_entry->multiEnd)
928 mid_entry->callback(mid_entry);
929 } else if (!server->ops->is_oplock_break ||
930 !server->ops->is_oplock_break(buf, server)) {
931 cifs_dbg(VFS, "No task to wake, unknown frame received! NumMids %d\n",
932 atomic_read(&midCount));
933 cifs_dump_mem("Received Data is: ", buf,
934 HEADER_SIZE(server));
935 #ifdef CONFIG_CIFS_DEBUG2
936 if (server->ops->dump_detail)
937 server->ops->dump_detail(buf);
938 cifs_dump_mids(server);
939 #endif /* CIFS_DEBUG2 */
942 } /* end while !EXITING */
944 /* buffer usually freed in free_mid - need to free it here on exit */
945 cifs_buf_release(server->bigbuf);
946 if (server->smallbuf) /* no sense logging a debug message if NULL */
947 cifs_small_buf_release(server->smallbuf);
949 task_to_wake = xchg(&server->tsk, NULL);
950 clean_demultiplex_info(server);
952 /* if server->tsk was NULL then wait for a signal before exiting */
954 set_current_state(TASK_INTERRUPTIBLE);
955 while (!signal_pending(current)) {
957 set_current_state(TASK_INTERRUPTIBLE);
959 set_current_state(TASK_RUNNING);
962 module_put_and_exit(0);
965 /* extract the host portion of the UNC string */
967 extract_hostname(const char *unc)
973 /* skip double chars at beginning of string */
974 /* BB: check validity of these bytes? */
977 /* delimiter between hostname and sharename is always '\\' now */
978 delim = strchr(src, '\\');
980 return ERR_PTR(-EINVAL);
983 dst = kmalloc((len + 1), GFP_KERNEL);
985 return ERR_PTR(-ENOMEM);
987 memcpy(dst, src, len);
993 static int get_option_ul(substring_t args[], unsigned long *option)
998 string = match_strdup(args);
1001 rc = kstrtoul(string, 0, option);
1007 static int get_option_uid(substring_t args[], kuid_t *result)
1009 unsigned long value;
1013 rc = get_option_ul(args, &value);
1017 uid = make_kuid(current_user_ns(), value);
1018 if (!uid_valid(uid))
1025 static int get_option_gid(substring_t args[], kgid_t *result)
1027 unsigned long value;
1031 rc = get_option_ul(args, &value);
1035 gid = make_kgid(current_user_ns(), value);
1036 if (!gid_valid(gid))
1043 static int cifs_parse_security_flavors(char *value,
1044 struct smb_vol *vol)
1047 substring_t args[MAX_OPT_ARGS];
1050 * With mount options, the last one should win. Reset any existing
1051 * settings back to default.
1053 vol->sectype = Unspecified;
1056 switch (match_token(value, cifs_secflavor_tokens, args)) {
1058 cifs_dbg(VFS, "sec=krb5p is not supported!\n");
1064 vol->sectype = Kerberos;
1066 case Opt_sec_ntlmsspi:
1069 case Opt_sec_ntlmssp:
1070 vol->sectype = RawNTLMSSP;
1076 vol->sectype = NTLM;
1078 case Opt_sec_ntlmv2i:
1081 case Opt_sec_ntlmv2:
1082 vol->sectype = NTLMv2;
1084 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1085 case Opt_sec_lanman:
1086 vol->sectype = LANMAN;
1093 cifs_dbg(VFS, "bad security option: %s\n", value);
1101 cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1103 substring_t args[MAX_OPT_ARGS];
1105 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1106 case Opt_cache_loose:
1107 vol->direct_io = false;
1108 vol->strict_io = false;
1110 case Opt_cache_strict:
1111 vol->direct_io = false;
1112 vol->strict_io = true;
1114 case Opt_cache_none:
1115 vol->direct_io = true;
1116 vol->strict_io = false;
1119 cifs_dbg(VFS, "bad cache= option: %s\n", value);
1126 cifs_parse_smb_version(char *value, struct smb_vol *vol)
1128 substring_t args[MAX_OPT_ARGS];
1130 switch (match_token(value, cifs_smb_version_tokens, args)) {
1132 vol->ops = &smb1_operations;
1133 vol->vals = &smb1_values;
1135 #ifdef CONFIG_CIFS_SMB2
1137 vol->ops = &smb20_operations;
1138 vol->vals = &smb20_values;
1141 vol->ops = &smb21_operations;
1142 vol->vals = &smb21_values;
1145 vol->ops = &smb30_operations;
1146 vol->vals = &smb30_values;
1149 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1150 vol->vals = &smb302_values;
1152 #ifdef CONFIG_CIFS_SMB311
1154 vol->ops = &smb311_operations;
1155 vol->vals = &smb311_values;
1160 cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
1167 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1168 * fields with the result. Returns 0 on success and an error otherwise.
1171 cifs_parse_devname(const char *devname, struct smb_vol *vol)
1174 const char *delims = "/\\";
1177 /* make sure we have a valid UNC double delimiter prefix */
1178 len = strspn(devname, delims);
1182 /* find delimiter between host and sharename */
1183 pos = strpbrk(devname + 2, delims);
1187 /* skip past delimiter */
1190 /* now go until next delimiter or end of string */
1191 len = strcspn(pos, delims);
1193 /* move "pos" up to delimiter or NULL */
1195 vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1199 convert_delimiter(vol->UNC, '\\');
1201 /* If pos is NULL, or is a bogus trailing delimiter then no prepath */
1202 if (!*pos++ || !*pos)
1205 vol->prepath = kstrdup(pos, GFP_KERNEL);
1213 cifs_parse_mount_options(const char *mountdata, const char *devname,
1214 struct smb_vol *vol)
1217 char *mountdata_copy = NULL, *options;
1218 unsigned int temp_len, i, j;
1220 short int override_uid = -1;
1221 short int override_gid = -1;
1222 bool uid_specified = false;
1223 bool gid_specified = false;
1224 bool sloppy = false;
1225 char *invalid = NULL;
1226 char *nodename = utsname()->nodename;
1227 char *string = NULL;
1228 char *tmp_end, *value;
1230 bool got_ip = false;
1231 unsigned short port = 0;
1232 struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1236 delim = separator[0];
1238 /* ensure we always start with zeroed-out smb_vol */
1239 memset(vol, 0, sizeof(*vol));
1242 * does not have to be perfect mapping since field is
1243 * informational, only used for servers that do not support
1244 * port 445 and it can be overridden at mount time
1246 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1247 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1248 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1250 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1251 /* null target name indicates to use *SMBSERVR default called name
1252 if we end up sending RFC1001 session initialize */
1253 vol->target_rfc1001_name[0] = 0;
1254 vol->cred_uid = current_uid();
1255 vol->linux_uid = current_uid();
1256 vol->linux_gid = current_gid();
1259 * default to SFM style remapping of seven reserved characters
1260 * unless user overrides it or we negotiate CIFS POSIX where
1261 * it is unnecessary. Can not simultaneously use more than one mapping
1262 * since then readdir could list files that open could not open
1266 /* default to only allowing write access to owner of the mount */
1267 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1269 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1270 /* default is always to request posix paths. */
1271 vol->posix_paths = 1;
1272 /* default to using server inode numbers where available */
1273 vol->server_ino = 1;
1275 /* default is to use strict cifs caching semantics */
1276 vol->strict_io = true;
1278 vol->actimeo = CIFS_DEF_ACTIMEO;
1280 /* FIXME: add autonegotiation -- for now, SMB1 is default */
1281 vol->ops = &smb1_operations;
1282 vol->vals = &smb1_values;
1285 goto cifs_parse_mount_err;
1287 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1288 if (!mountdata_copy)
1289 goto cifs_parse_mount_err;
1291 options = mountdata_copy;
1292 end = options + strlen(options);
1294 if (strncmp(options, "sep=", 4) == 0) {
1295 if (options[4] != 0) {
1296 separator[0] = options[4];
1299 cifs_dbg(FYI, "Null separator not allowed\n");
1302 vol->backupuid_specified = false; /* no backup intent for a user */
1303 vol->backupgid_specified = false; /* no backup intent for a group */
1305 switch (cifs_parse_devname(devname, vol)) {
1309 cifs_dbg(VFS, "Unable to allocate memory for devname.\n");
1310 goto cifs_parse_mount_err;
1312 cifs_dbg(VFS, "Malformed UNC in devname.\n");
1313 goto cifs_parse_mount_err;
1315 cifs_dbg(VFS, "Unknown error parsing devname.\n");
1316 goto cifs_parse_mount_err;
1319 while ((data = strsep(&options, separator)) != NULL) {
1320 substring_t args[MAX_OPT_ARGS];
1321 unsigned long option;
1327 token = match_token(data, cifs_mount_option_tokens, args);
1331 /* Ingnore the following */
1335 /* Boolean values */
1336 case Opt_user_xattr:
1339 case Opt_nouser_xattr:
1345 case Opt_noforceuid:
1351 case Opt_noforcegid:
1354 case Opt_noblocksend:
1355 vol->noblocksnd = 1;
1357 case Opt_noautotune:
1358 vol->noautotune = 1;
1373 vol->sfu_remap = true;
1374 vol->remap = false; /* disable SFM mapping */
1376 case Opt_nomapchars:
1377 vol->sfu_remap = false;
1381 vol->sfu_remap = false; /* disable SFU mapping */
1383 case Opt_nomapposix:
1395 case Opt_posixpaths:
1396 vol->posix_paths = 1;
1398 case Opt_noposixpaths:
1399 vol->posix_paths = 0;
1402 vol->no_linux_ext = 1;
1413 * turn off mandatory locking in mode
1414 * if remote locking is turned off since the
1415 * local vfs will do advisory
1417 if (vol->file_mode ==
1418 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1419 vol->file_mode = S_IALLUGO;
1421 case Opt_forcemandatorylock:
1431 vol->dynperm = true;
1434 vol->dynperm = false;
1448 case Opt_nostrictsync:
1449 vol->nostrictsync = 1;
1451 case Opt_strictsync:
1452 vol->nostrictsync = 0;
1455 vol->server_ino = 1;
1457 case Opt_noserverino:
1458 vol->server_ino = 0;
1460 case Opt_rwpidforward:
1461 vol->rwpidforward = 1;
1470 vol->no_psx_acl = 0;
1473 vol->no_psx_acl = 1;
1475 case Opt_locallease:
1476 vol->local_lease = 1;
1482 /* we do not do the following in secFlags because seal
1483 * is a per tree connection (mount) not a per socket
1484 * or per-smb connection option in the protocol
1485 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1490 pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1493 #ifndef CONFIG_CIFS_FSCACHE
1494 cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1495 goto cifs_parse_mount_err;
1499 case Opt_mfsymlinks:
1500 vol->mfsymlinks = true;
1503 vol->multiuser = true;
1508 case Opt_nosharesock:
1509 vol->nosharesock = true;
1511 case Opt_nopersistent:
1512 vol->nopersistent = true;
1513 if (vol->persistent) {
1515 "persistenthandles mount options conflict\n");
1516 goto cifs_parse_mount_err;
1519 case Opt_persistent:
1520 vol->persistent = true;
1521 if ((vol->nopersistent) || (vol->resilient)) {
1523 "persistenthandles mount options conflict\n");
1524 goto cifs_parse_mount_err;
1528 vol->resilient = true;
1529 if (vol->persistent) {
1531 "persistenthandles mount options conflict\n");
1532 goto cifs_parse_mount_err;
1535 case Opt_noresilient:
1536 vol->resilient = false; /* already the default */
1539 /* Numeric Values */
1541 if (get_option_uid(args, &vol->backupuid)) {
1542 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
1544 goto cifs_parse_mount_err;
1546 vol->backupuid_specified = true;
1549 if (get_option_gid(args, &vol->backupgid)) {
1550 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
1552 goto cifs_parse_mount_err;
1554 vol->backupgid_specified = true;
1557 if (get_option_uid(args, &vol->linux_uid)) {
1558 cifs_dbg(VFS, "%s: Invalid uid value\n",
1560 goto cifs_parse_mount_err;
1562 uid_specified = true;
1565 if (get_option_uid(args, &vol->cred_uid)) {
1566 cifs_dbg(VFS, "%s: Invalid cruid value\n",
1568 goto cifs_parse_mount_err;
1572 if (get_option_gid(args, &vol->linux_gid)) {
1573 cifs_dbg(VFS, "%s: Invalid gid value\n",
1575 goto cifs_parse_mount_err;
1577 gid_specified = true;
1580 if (get_option_ul(args, &option)) {
1581 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
1583 goto cifs_parse_mount_err;
1585 vol->file_mode = option;
1588 if (get_option_ul(args, &option)) {
1589 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
1591 goto cifs_parse_mount_err;
1593 vol->dir_mode = option;
1596 if (get_option_ul(args, &option) ||
1597 option > USHRT_MAX) {
1598 cifs_dbg(VFS, "%s: Invalid port value\n",
1600 goto cifs_parse_mount_err;
1602 port = (unsigned short)option;
1605 if (get_option_ul(args, &option)) {
1606 cifs_dbg(VFS, "%s: Invalid rsize value\n",
1608 goto cifs_parse_mount_err;
1610 vol->rsize = option;
1613 if (get_option_ul(args, &option)) {
1614 cifs_dbg(VFS, "%s: Invalid wsize value\n",
1616 goto cifs_parse_mount_err;
1618 vol->wsize = option;
1621 if (get_option_ul(args, &option)) {
1622 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
1624 goto cifs_parse_mount_err;
1626 vol->actimeo = HZ * option;
1627 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1628 cifs_dbg(VFS, "attribute cache timeout too large\n");
1629 goto cifs_parse_mount_err;
1633 /* String Arguments */
1635 case Opt_blank_user:
1636 /* null user, ie. anonymous authentication */
1638 vol->username = NULL;
1641 string = match_strdup(args);
1645 if (strnlen(string, CIFS_MAX_USERNAME_LEN) >
1646 CIFS_MAX_USERNAME_LEN) {
1647 pr_warn("CIFS: username too long\n");
1648 goto cifs_parse_mount_err;
1651 kfree(vol->username);
1652 vol->username = kstrdup(string, GFP_KERNEL);
1654 goto cifs_parse_mount_err;
1656 case Opt_blank_pass:
1657 /* passwords have to be handled differently
1658 * to allow the character used for deliminator
1659 * to be passed within them
1663 * Check if this is a case where the password
1664 * starts with a delimiter
1666 tmp_end = strchr(data, '=');
1668 if (!(tmp_end < end && tmp_end[1] == delim)) {
1669 /* No it is not. Set the password to NULL */
1670 kfree(vol->password);
1671 vol->password = NULL;
1674 /* Yes it is. Drop down to Opt_pass below.*/
1676 /* Obtain the value string */
1677 value = strchr(data, '=');
1680 /* Set tmp_end to end of the string */
1681 tmp_end = (char *) value + strlen(value);
1683 /* Check if following character is the deliminator
1684 * If yes, we have encountered a double deliminator
1685 * reset the NULL character to the deliminator
1687 if (tmp_end < end && tmp_end[1] == delim) {
1690 /* Keep iterating until we get to a single
1691 * deliminator OR the end
1693 while ((tmp_end = strchr(tmp_end, delim))
1694 != NULL && (tmp_end[1] == delim)) {
1695 tmp_end = (char *) &tmp_end[2];
1698 /* Reset var options to point to next element */
1701 options = (char *) &tmp_end[1];
1703 /* Reached the end of the mount option
1708 kfree(vol->password);
1709 /* Now build new password string */
1710 temp_len = strlen(value);
1711 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1712 if (vol->password == NULL) {
1713 pr_warn("CIFS: no memory for password\n");
1714 goto cifs_parse_mount_err;
1717 for (i = 0, j = 0; i < temp_len; i++, j++) {
1718 vol->password[j] = value[i];
1719 if ((value[i] == delim) &&
1720 value[i+1] == delim)
1721 /* skip the second deliminator */
1724 vol->password[j] = '\0';
1727 /* FIXME: should this be an error instead? */
1731 string = match_strdup(args);
1735 if (!cifs_convert_address(dstaddr, string,
1737 pr_err("CIFS: bad ip= option (%s).\n", string);
1738 goto cifs_parse_mount_err;
1743 string = match_strdup(args);
1747 if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
1748 == CIFS_MAX_DOMAINNAME_LEN) {
1749 pr_warn("CIFS: domain name too long\n");
1750 goto cifs_parse_mount_err;
1753 kfree(vol->domainname);
1754 vol->domainname = kstrdup(string, GFP_KERNEL);
1755 if (!vol->domainname) {
1756 pr_warn("CIFS: no memory for domainname\n");
1757 goto cifs_parse_mount_err;
1759 cifs_dbg(FYI, "Domain name set\n");
1762 string = match_strdup(args);
1766 if (!cifs_convert_address(
1767 (struct sockaddr *)&vol->srcaddr,
1768 string, strlen(string))) {
1769 pr_warn("CIFS: Could not parse srcaddr: %s\n",
1771 goto cifs_parse_mount_err;
1775 string = match_strdup(args);
1779 if (strnlen(string, 1024) >= 65) {
1780 pr_warn("CIFS: iocharset name too long.\n");
1781 goto cifs_parse_mount_err;
1784 if (strncasecmp(string, "default", 7) != 0) {
1785 kfree(vol->iocharset);
1786 vol->iocharset = kstrdup(string,
1788 if (!vol->iocharset) {
1789 pr_warn("CIFS: no memory for charset\n");
1790 goto cifs_parse_mount_err;
1793 /* if iocharset not set then load_nls_default
1796 cifs_dbg(FYI, "iocharset set to %s\n", string);
1798 case Opt_netbiosname:
1799 string = match_strdup(args);
1803 memset(vol->source_rfc1001_name, 0x20,
1806 * FIXME: are there cases in which a comma can
1807 * be valid in workstation netbios name (and
1808 * need special handling)?
1810 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1811 /* don't ucase netbiosname for user */
1814 vol->source_rfc1001_name[i] = string[i];
1816 /* The string has 16th byte zero still from
1817 * set at top of the function
1819 if (i == RFC1001_NAME_LEN && string[i] != 0)
1820 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
1823 /* servernetbiosname specified override *SMBSERVER */
1824 string = match_strdup(args);
1828 /* last byte, type, is 0x20 for servr type */
1829 memset(vol->target_rfc1001_name, 0x20,
1830 RFC1001_NAME_LEN_WITH_NULL);
1832 /* BB are there cases in which a comma can be
1833 valid in this workstation netbios name
1834 (and need special handling)? */
1836 /* user or mount helper must uppercase the
1838 for (i = 0; i < 15; i++) {
1841 vol->target_rfc1001_name[i] = string[i];
1843 /* The string has 16th byte zero still from
1844 set at top of the function */
1845 if (i == RFC1001_NAME_LEN && string[i] != 0)
1846 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
1849 string = match_strdup(args);
1853 if (strncasecmp(string, "1", 1) == 0) {
1854 /* This is the default */
1857 /* For all other value, error */
1858 pr_warn("CIFS: Invalid version specified\n");
1859 goto cifs_parse_mount_err;
1861 string = match_strdup(args);
1865 if (cifs_parse_smb_version(string, vol) != 0)
1866 goto cifs_parse_mount_err;
1869 string = match_strdup(args);
1873 if (cifs_parse_security_flavors(string, vol) != 0)
1874 goto cifs_parse_mount_err;
1877 string = match_strdup(args);
1881 if (cifs_parse_cache_flavor(string, vol) != 0)
1882 goto cifs_parse_mount_err;
1886 * An option we don't recognize. Save it off for later
1887 * if we haven't already found one
1893 /* Free up any allocated string */
1898 if (!sloppy && invalid) {
1899 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid);
1900 goto cifs_parse_mount_err;
1904 /* Muliuser mounts require CONFIG_KEYS support */
1905 if (vol->multiuser) {
1906 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
1907 goto cifs_parse_mount_err;
1911 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
1912 goto cifs_parse_mount_err;
1915 /* make sure UNC has a share name */
1916 if (!strchr(vol->UNC + 3, '\\')) {
1917 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
1918 goto cifs_parse_mount_err;
1922 /* No ip= option specified? Try to get it from UNC */
1923 if (!cifs_convert_address(dstaddr, &vol->UNC[2],
1924 strlen(&vol->UNC[2]))) {
1925 pr_err("Unable to determine destination address.\n");
1926 goto cifs_parse_mount_err;
1930 /* set the port that we got earlier */
1931 cifs_set_port(dstaddr, port);
1934 vol->override_uid = override_uid;
1935 else if (override_uid == 1)
1936 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
1939 vol->override_gid = override_gid;
1940 else if (override_gid == 1)
1941 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
1943 kfree(mountdata_copy);
1947 pr_warn("Could not allocate temporary buffer\n");
1948 cifs_parse_mount_err:
1950 kfree(mountdata_copy);
1954 /** Returns true if srcaddr isn't specified and rhs isn't
1955 * specified, or if srcaddr is specified and
1956 * matches the IP address of the rhs argument.
1959 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1961 switch (srcaddr->sa_family) {
1963 return (rhs->sa_family == AF_UNSPEC);
1965 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1966 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1967 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1970 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1971 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
1972 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1976 return false; /* don't expect to be here */
1981 * If no port is specified in addr structure, we try to match with 445 port
1982 * and if it fails - with 139 ports. It should be called only if address
1983 * families of server and addr are equal.
1986 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1988 __be16 port, *sport;
1990 switch (addr->sa_family) {
1992 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1993 port = ((struct sockaddr_in *) addr)->sin_port;
1996 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1997 port = ((struct sockaddr_in6 *) addr)->sin6_port;
2005 port = htons(CIFS_PORT);
2009 port = htons(RFC1001_PORT);
2012 return port == *sport;
2016 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
2017 struct sockaddr *srcaddr)
2019 switch (addr->sa_family) {
2021 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2022 struct sockaddr_in *srv_addr4 =
2023 (struct sockaddr_in *)&server->dstaddr;
2025 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
2030 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2031 struct sockaddr_in6 *srv_addr6 =
2032 (struct sockaddr_in6 *)&server->dstaddr;
2034 if (!ipv6_addr_equal(&addr6->sin6_addr,
2035 &srv_addr6->sin6_addr))
2037 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
2043 return false; /* don't expect to be here */
2046 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2053 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2056 * The select_sectype function should either return the vol->sectype
2057 * that was specified, or "Unspecified" if that sectype was not
2058 * compatible with the given NEGOTIATE request.
2060 if (select_sectype(server, vol->sectype) == Unspecified)
2064 * Now check if signing mode is acceptable. No need to check
2065 * global_secflags at this point since if MUST_SIGN is set then
2066 * the server->sign had better be too.
2068 if (vol->sign && !server->sign)
2074 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2076 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2078 if (vol->nosharesock)
2081 if ((server->vals != vol->vals) || (server->ops != vol->ops))
2084 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2087 if (!match_address(server, addr,
2088 (struct sockaddr *)&vol->srcaddr))
2091 if (!match_port(server, addr))
2094 if (!match_security(server, vol))
2100 static struct TCP_Server_Info *
2101 cifs_find_tcp_session(struct smb_vol *vol)
2103 struct TCP_Server_Info *server;
2105 spin_lock(&cifs_tcp_ses_lock);
2106 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2107 if (!match_server(server, vol))
2110 ++server->srv_count;
2111 spin_unlock(&cifs_tcp_ses_lock);
2112 cifs_dbg(FYI, "Existing tcp session with server found\n");
2115 spin_unlock(&cifs_tcp_ses_lock);
2120 cifs_put_tcp_session(struct TCP_Server_Info *server, int from_reconnect)
2122 struct task_struct *task;
2124 spin_lock(&cifs_tcp_ses_lock);
2125 if (--server->srv_count > 0) {
2126 spin_unlock(&cifs_tcp_ses_lock);
2130 put_net(cifs_net_ns(server));
2132 list_del_init(&server->tcp_ses_list);
2133 spin_unlock(&cifs_tcp_ses_lock);
2135 cancel_delayed_work_sync(&server->echo);
2137 #ifdef CONFIG_CIFS_SMB2
2140 * Avoid deadlock here: reconnect work calls
2141 * cifs_put_tcp_session() at its end. Need to be sure
2142 * that reconnect work does nothing with server pointer after
2145 cancel_delayed_work(&server->reconnect);
2147 cancel_delayed_work_sync(&server->reconnect);
2150 spin_lock(&GlobalMid_Lock);
2151 server->tcpStatus = CifsExiting;
2152 spin_unlock(&GlobalMid_Lock);
2154 cifs_crypto_shash_release(server);
2155 cifs_fscache_release_client_cookie(server);
2157 kfree(server->session_key.response);
2158 server->session_key.response = NULL;
2159 server->session_key.len = 0;
2161 task = xchg(&server->tsk, NULL);
2163 force_sig(SIGKILL, task);
2166 static struct TCP_Server_Info *
2167 cifs_get_tcp_session(struct smb_vol *volume_info)
2169 struct TCP_Server_Info *tcp_ses = NULL;
2172 cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
2174 /* see if we already have a matching tcp_ses */
2175 tcp_ses = cifs_find_tcp_session(volume_info);
2179 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2185 tcp_ses->ops = volume_info->ops;
2186 tcp_ses->vals = volume_info->vals;
2187 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2188 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2189 if (IS_ERR(tcp_ses->hostname)) {
2190 rc = PTR_ERR(tcp_ses->hostname);
2191 goto out_err_crypto_release;
2194 tcp_ses->noblocksnd = volume_info->noblocksnd;
2195 tcp_ses->noautotune = volume_info->noautotune;
2196 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2197 tcp_ses->in_flight = 0;
2198 tcp_ses->credits = 1;
2199 init_waitqueue_head(&tcp_ses->response_q);
2200 init_waitqueue_head(&tcp_ses->request_q);
2201 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2202 mutex_init(&tcp_ses->srv_mutex);
2203 memcpy(tcp_ses->workstation_RFC1001_name,
2204 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2205 memcpy(tcp_ses->server_RFC1001_name,
2206 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2207 tcp_ses->session_estab = false;
2208 tcp_ses->sequence_number = 0;
2209 tcp_ses->lstrp = jiffies;
2210 spin_lock_init(&tcp_ses->req_lock);
2211 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2212 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2213 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2214 #ifdef CONFIG_CIFS_SMB2
2215 INIT_DELAYED_WORK(&tcp_ses->reconnect, smb2_reconnect_server);
2216 mutex_init(&tcp_ses->reconnect_mutex);
2218 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2219 sizeof(tcp_ses->srcaddr));
2220 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2221 sizeof(tcp_ses->dstaddr));
2222 #ifdef CONFIG_CIFS_SMB2
2223 generate_random_uuid(tcp_ses->client_guid);
2226 * at this point we are the only ones with the pointer
2227 * to the struct since the kernel thread not created yet
2228 * no need to spinlock this init of tcpStatus or srv_count
2230 tcp_ses->tcpStatus = CifsNew;
2231 ++tcp_ses->srv_count;
2233 rc = ip_connect(tcp_ses);
2235 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
2236 goto out_err_crypto_release;
2240 * since we're in a cifs function already, we know that
2241 * this will succeed. No need for try_module_get().
2243 __module_get(THIS_MODULE);
2244 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2246 if (IS_ERR(tcp_ses->tsk)) {
2247 rc = PTR_ERR(tcp_ses->tsk);
2248 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
2249 module_put(THIS_MODULE);
2250 goto out_err_crypto_release;
2252 tcp_ses->tcpStatus = CifsNeedNegotiate;
2254 /* thread spawned, put it on the list */
2255 spin_lock(&cifs_tcp_ses_lock);
2256 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2257 spin_unlock(&cifs_tcp_ses_lock);
2259 cifs_fscache_get_client_cookie(tcp_ses);
2261 /* queue echo request delayed work */
2262 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
2266 out_err_crypto_release:
2267 cifs_crypto_shash_release(tcp_ses);
2269 put_net(cifs_net_ns(tcp_ses));
2273 if (!IS_ERR(tcp_ses->hostname))
2274 kfree(tcp_ses->hostname);
2275 if (tcp_ses->ssocket)
2276 sock_release(tcp_ses->ssocket);
2282 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2284 if (vol->sectype != Unspecified &&
2285 vol->sectype != ses->sectype)
2288 switch (ses->sectype) {
2290 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2294 /* NULL username means anonymous session */
2295 if (ses->user_name == NULL) {
2301 /* anything else takes username/password */
2302 if (strncmp(ses->user_name,
2303 vol->username ? vol->username : "",
2304 CIFS_MAX_USERNAME_LEN))
2306 if ((vol->username && strlen(vol->username) != 0) &&
2307 ses->password != NULL &&
2308 strncmp(ses->password,
2309 vol->password ? vol->password : "",
2310 CIFS_MAX_PASSWORD_LEN))
2316 static struct cifs_ses *
2317 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2319 struct cifs_ses *ses;
2321 spin_lock(&cifs_tcp_ses_lock);
2322 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2323 if (ses->status == CifsExiting)
2325 if (!match_session(ses, vol))
2328 spin_unlock(&cifs_tcp_ses_lock);
2331 spin_unlock(&cifs_tcp_ses_lock);
2336 cifs_put_smb_ses(struct cifs_ses *ses)
2338 unsigned int rc, xid;
2339 struct TCP_Server_Info *server = ses->server;
2341 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
2343 spin_lock(&cifs_tcp_ses_lock);
2344 if (ses->status == CifsExiting) {
2345 spin_unlock(&cifs_tcp_ses_lock);
2348 if (--ses->ses_count > 0) {
2349 spin_unlock(&cifs_tcp_ses_lock);
2352 if (ses->status == CifsGood)
2353 ses->status = CifsExiting;
2354 spin_unlock(&cifs_tcp_ses_lock);
2356 if (ses->status == CifsExiting && server->ops->logoff) {
2358 rc = server->ops->logoff(xid, ses);
2360 cifs_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
2365 spin_lock(&cifs_tcp_ses_lock);
2366 list_del_init(&ses->smb_ses_list);
2367 spin_unlock(&cifs_tcp_ses_lock);
2370 cifs_put_tcp_session(server, 0);
2375 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2376 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2378 /* Populate username and pw fields from keyring if possible */
2380 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2383 const char *delim, *payload;
2387 struct TCP_Server_Info *server = ses->server;
2388 struct sockaddr_in *sa;
2389 struct sockaddr_in6 *sa6;
2390 const struct user_key_payload *upayload;
2392 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2396 /* try to find an address key first */
2397 switch (server->dstaddr.ss_family) {
2399 sa = (struct sockaddr_in *)&server->dstaddr;
2400 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2403 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2404 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2407 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2408 server->dstaddr.ss_family);
2413 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2414 key = request_key(&key_type_logon, desc, "");
2416 if (!ses->domainName) {
2417 cifs_dbg(FYI, "domainName is NULL\n");
2422 /* didn't work, try to find a domain key */
2423 sprintf(desc, "cifs:d:%s", ses->domainName);
2424 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2425 key = request_key(&key_type_logon, desc, "");
2432 down_read(&key->sem);
2433 upayload = user_key_payload(key);
2434 if (IS_ERR_OR_NULL(upayload)) {
2435 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2439 /* find first : in payload */
2440 payload = upayload->data;
2441 delim = strnchr(payload, upayload->datalen, ':');
2442 cifs_dbg(FYI, "payload=%s\n", payload);
2444 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
2450 len = delim - payload;
2451 if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
2452 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
2458 vol->username = kstrndup(payload, len, GFP_KERNEL);
2459 if (!vol->username) {
2460 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
2465 cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
2467 len = key->datalen - (len + 1);
2468 if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
2469 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
2471 kfree(vol->username);
2472 vol->username = NULL;
2477 vol->password = kstrndup(delim, len, GFP_KERNEL);
2478 if (!vol->password) {
2479 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
2482 kfree(vol->username);
2483 vol->username = NULL;
2492 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
2495 #else /* ! CONFIG_KEYS */
2497 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2498 struct cifs_ses *ses __attribute__((unused)))
2502 #endif /* CONFIG_KEYS */
2504 static struct cifs_ses *
2505 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2509 struct cifs_ses *ses;
2510 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2511 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2515 ses = cifs_find_smb_ses(server, volume_info);
2517 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
2520 mutex_lock(&ses->session_mutex);
2521 rc = cifs_negotiate_protocol(xid, ses);
2523 mutex_unlock(&ses->session_mutex);
2524 /* problem -- put our ses reference */
2525 cifs_put_smb_ses(ses);
2529 if (ses->need_reconnect) {
2530 cifs_dbg(FYI, "Session needs reconnect\n");
2531 rc = cifs_setup_session(xid, ses,
2532 volume_info->local_nls);
2534 mutex_unlock(&ses->session_mutex);
2535 /* problem -- put our reference */
2536 cifs_put_smb_ses(ses);
2541 mutex_unlock(&ses->session_mutex);
2543 /* existing SMB ses has a server reference already */
2544 cifs_put_tcp_session(server, 0);
2549 cifs_dbg(FYI, "Existing smb sess not found\n");
2550 ses = sesInfoAlloc();
2554 /* new SMB session uses our server ref */
2555 ses->server = server;
2556 if (server->dstaddr.ss_family == AF_INET6)
2557 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2559 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2561 if (volume_info->username) {
2562 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2563 if (!ses->user_name)
2567 /* volume_info->password freed at unmount */
2568 if (volume_info->password) {
2569 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2573 if (volume_info->domainname) {
2574 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2575 if (!ses->domainName)
2578 ses->cred_uid = volume_info->cred_uid;
2579 ses->linux_uid = volume_info->linux_uid;
2581 ses->sectype = volume_info->sectype;
2582 ses->sign = volume_info->sign;
2584 mutex_lock(&ses->session_mutex);
2585 rc = cifs_negotiate_protocol(xid, ses);
2587 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2588 mutex_unlock(&ses->session_mutex);
2592 /* success, put it on the list */
2593 spin_lock(&cifs_tcp_ses_lock);
2594 list_add(&ses->smb_ses_list, &server->smb_ses_list);
2595 spin_unlock(&cifs_tcp_ses_lock);
2606 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2608 if (tcon->tidStatus == CifsExiting)
2610 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2615 static struct cifs_tcon *
2616 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2618 struct list_head *tmp;
2619 struct cifs_tcon *tcon;
2621 spin_lock(&cifs_tcp_ses_lock);
2622 list_for_each(tmp, &ses->tcon_list) {
2623 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2624 if (!match_tcon(tcon, unc))
2627 spin_unlock(&cifs_tcp_ses_lock);
2630 spin_unlock(&cifs_tcp_ses_lock);
2635 cifs_put_tcon(struct cifs_tcon *tcon)
2638 struct cifs_ses *ses = tcon->ses;
2640 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2641 spin_lock(&cifs_tcp_ses_lock);
2642 if (--tcon->tc_count > 0) {
2643 spin_unlock(&cifs_tcp_ses_lock);
2647 list_del_init(&tcon->tcon_list);
2648 spin_unlock(&cifs_tcp_ses_lock);
2651 if (ses->server->ops->tree_disconnect)
2652 ses->server->ops->tree_disconnect(xid, tcon);
2655 cifs_fscache_release_super_cookie(tcon);
2657 cifs_put_smb_ses(ses);
2660 static struct cifs_tcon *
2661 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2664 struct cifs_tcon *tcon;
2666 tcon = cifs_find_tcon(ses, volume_info->UNC);
2668 cifs_dbg(FYI, "Found match on UNC path\n");
2669 /* existing tcon already has a reference */
2670 cifs_put_smb_ses(ses);
2671 if (tcon->seal != volume_info->seal)
2672 cifs_dbg(VFS, "transport encryption setting conflicts with existing tid\n");
2676 if (!ses->server->ops->tree_connect) {
2681 tcon = tconInfoAlloc();
2688 if (volume_info->password) {
2689 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2690 if (!tcon->password) {
2697 * BB Do we need to wrap session_mutex around this TCon call and Unix
2698 * SetFS as we do on SessSetup and reconnect?
2701 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2702 volume_info->local_nls);
2704 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
2708 if (volume_info->nodfs) {
2709 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2710 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
2712 tcon->seal = volume_info->seal;
2713 tcon->use_persistent = false;
2714 /* check if SMB2 or later, CIFS does not support persistent handles */
2715 if (volume_info->persistent) {
2716 if (ses->server->vals->protocol_id == 0) {
2718 "SMB3 or later required for persistent handles\n");
2721 #ifdef CONFIG_CIFS_SMB2
2722 } else if (ses->server->capabilities &
2723 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2724 tcon->use_persistent = true;
2725 else /* persistent handles requested but not supported */ {
2727 "Persistent handles not supported on share\n");
2730 #endif /* CONFIG_CIFS_SMB2 */
2732 #ifdef CONFIG_CIFS_SMB2
2733 } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
2734 && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2735 && (volume_info->nopersistent == false)) {
2736 cifs_dbg(FYI, "enabling persistent handles\n");
2737 tcon->use_persistent = true;
2738 #endif /* CONFIG_CIFS_SMB2 */
2739 } else if (volume_info->resilient) {
2740 if (ses->server->vals->protocol_id == 0) {
2742 "SMB2.1 or later required for resilient handles\n");
2746 tcon->use_resilient = true;
2750 * We can have only one retry value for a connection to a share so for
2751 * resources mounted more than once to the same server share the last
2752 * value passed in for the retry flag is used.
2754 tcon->retry = volume_info->retry;
2755 tcon->nocase = volume_info->nocase;
2756 tcon->local_lease = volume_info->local_lease;
2757 INIT_LIST_HEAD(&tcon->pending_opens);
2759 spin_lock(&cifs_tcp_ses_lock);
2760 list_add(&tcon->tcon_list, &ses->tcon_list);
2761 spin_unlock(&cifs_tcp_ses_lock);
2763 cifs_fscache_get_super_cookie(tcon);
2773 cifs_put_tlink(struct tcon_link *tlink)
2775 if (!tlink || IS_ERR(tlink))
2778 if (!atomic_dec_and_test(&tlink->tl_count) ||
2779 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2780 tlink->tl_time = jiffies;
2784 if (!IS_ERR(tlink_tcon(tlink)))
2785 cifs_put_tcon(tlink_tcon(tlink));
2790 static inline struct tcon_link *
2791 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2793 return cifs_sb->master_tlink;
2797 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2799 struct cifs_sb_info *old = CIFS_SB(sb);
2800 struct cifs_sb_info *new = mnt_data->cifs_sb;
2802 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2805 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2806 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2810 * We want to share sb only if we don't specify an r/wsize or
2811 * specified r/wsize is greater than or equal to existing one.
2813 if (new->wsize && new->wsize < old->wsize)
2816 if (new->rsize && new->rsize < old->rsize)
2819 if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
2822 if (old->mnt_file_mode != new->mnt_file_mode ||
2823 old->mnt_dir_mode != new->mnt_dir_mode)
2826 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2829 if (old->actimeo != new->actimeo)
2836 cifs_match_super(struct super_block *sb, void *data)
2838 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2839 struct smb_vol *volume_info;
2840 struct cifs_sb_info *cifs_sb;
2841 struct TCP_Server_Info *tcp_srv;
2842 struct cifs_ses *ses;
2843 struct cifs_tcon *tcon;
2844 struct tcon_link *tlink;
2847 spin_lock(&cifs_tcp_ses_lock);
2848 cifs_sb = CIFS_SB(sb);
2849 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2850 if (IS_ERR(tlink)) {
2851 spin_unlock(&cifs_tcp_ses_lock);
2854 tcon = tlink_tcon(tlink);
2856 tcp_srv = ses->server;
2858 volume_info = mnt_data->vol;
2860 if (!match_server(tcp_srv, volume_info) ||
2861 !match_session(ses, volume_info) ||
2862 !match_tcon(tcon, volume_info->UNC)) {
2867 rc = compare_mount_options(sb, mnt_data);
2869 spin_unlock(&cifs_tcp_ses_lock);
2870 cifs_put_tlink(tlink);
2875 get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
2876 const struct nls_table *nls_codepage, unsigned int *num_referrals,
2877 struct dfs_info3_param **referrals, int remap)
2882 if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
2888 if (ses->ipc_tid == 0) {
2889 temp_unc = kmalloc(2 /* for slashes */ +
2890 strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2891 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
2892 if (temp_unc == NULL)
2896 strcpy(temp_unc + 2, ses->serverName);
2897 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2898 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2900 cifs_dbg(FYI, "Tcon rc = %d ipc_tid = %d\n", rc, ses->ipc_tid);
2904 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
2905 referrals, num_referrals,
2906 nls_codepage, remap);
2908 * BB - map targetUNCs to dfs_info3 structures, here or in
2909 * ses->server->ops->get_dfs_refer.
2915 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2916 static struct lock_class_key cifs_key[2];
2917 static struct lock_class_key cifs_slock_key[2];
2920 cifs_reclassify_socket4(struct socket *sock)
2922 struct sock *sk = sock->sk;
2923 BUG_ON(sock_owned_by_user(sk));
2924 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2925 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2929 cifs_reclassify_socket6(struct socket *sock)
2931 struct sock *sk = sock->sk;
2932 BUG_ON(sock_owned_by_user(sk));
2933 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2934 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2938 cifs_reclassify_socket4(struct socket *sock)
2943 cifs_reclassify_socket6(struct socket *sock)
2948 /* See RFC1001 section 14 on representation of Netbios names */
2949 static void rfc1002mangle(char *target, char *source, unsigned int length)
2953 for (i = 0, j = 0; i < (length); i++) {
2954 /* mask a nibble at a time and encode */
2955 target[j] = 'A' + (0x0F & (source[i] >> 4));
2956 target[j+1] = 'A' + (0x0F & source[i]);
2963 bind_socket(struct TCP_Server_Info *server)
2966 if (server->srcaddr.ss_family != AF_UNSPEC) {
2967 /* Bind to the specified local IP address */
2968 struct socket *socket = server->ssocket;
2969 rc = socket->ops->bind(socket,
2970 (struct sockaddr *) &server->srcaddr,
2971 sizeof(server->srcaddr));
2973 struct sockaddr_in *saddr4;
2974 struct sockaddr_in6 *saddr6;
2975 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2976 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2977 if (saddr6->sin6_family == AF_INET6)
2978 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
2979 &saddr6->sin6_addr, rc);
2981 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
2982 &saddr4->sin_addr.s_addr, rc);
2989 ip_rfc1001_connect(struct TCP_Server_Info *server)
2993 * some servers require RFC1001 sessinit before sending
2994 * negprot - BB check reconnection in case where second
2995 * sessinit is sent but no second negprot
2997 struct rfc1002_session_packet *ses_init_buf;
2998 struct smb_hdr *smb_buf;
2999 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
3002 ses_init_buf->trailer.session_req.called_len = 32;
3004 if (server->server_RFC1001_name &&
3005 server->server_RFC1001_name[0] != 0)
3006 rfc1002mangle(ses_init_buf->trailer.
3007 session_req.called_name,
3008 server->server_RFC1001_name,
3009 RFC1001_NAME_LEN_WITH_NULL);
3011 rfc1002mangle(ses_init_buf->trailer.
3012 session_req.called_name,
3013 DEFAULT_CIFS_CALLED_NAME,
3014 RFC1001_NAME_LEN_WITH_NULL);
3016 ses_init_buf->trailer.session_req.calling_len = 32;
3019 * calling name ends in null (byte 16) from old smb
3022 if (server->workstation_RFC1001_name[0] != 0)
3023 rfc1002mangle(ses_init_buf->trailer.
3024 session_req.calling_name,
3025 server->workstation_RFC1001_name,
3026 RFC1001_NAME_LEN_WITH_NULL);
3028 rfc1002mangle(ses_init_buf->trailer.
3029 session_req.calling_name,
3031 RFC1001_NAME_LEN_WITH_NULL);
3033 ses_init_buf->trailer.session_req.scope1 = 0;
3034 ses_init_buf->trailer.session_req.scope2 = 0;
3035 smb_buf = (struct smb_hdr *)ses_init_buf;
3037 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3038 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3039 rc = smb_send(server, smb_buf, 0x44);
3040 kfree(ses_init_buf);
3042 * RFC1001 layer in at least one server
3043 * requires very short break before negprot
3044 * presumably because not expecting negprot
3045 * to follow so fast. This is a simple
3046 * solution that works without
3047 * complicating the code and causes no
3048 * significant slowing down on mount
3051 usleep_range(1000, 2000);
3054 * else the negprot may still work without this
3055 * even though malloc failed
3062 generic_ip_connect(struct TCP_Server_Info *server)
3067 struct socket *socket = server->ssocket;
3068 struct sockaddr *saddr;
3070 saddr = (struct sockaddr *) &server->dstaddr;
3072 if (server->dstaddr.ss_family == AF_INET6) {
3073 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3074 slen = sizeof(struct sockaddr_in6);
3077 sport = ((struct sockaddr_in *) saddr)->sin_port;
3078 slen = sizeof(struct sockaddr_in);
3082 if (socket == NULL) {
3083 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3084 IPPROTO_TCP, &socket, 1);
3086 cifs_dbg(VFS, "Error %d creating socket\n", rc);
3087 server->ssocket = NULL;
3091 /* BB other socket options to set KEEPALIVE, NODELAY? */
3092 cifs_dbg(FYI, "Socket created\n");
3093 server->ssocket = socket;
3094 socket->sk->sk_allocation = GFP_NOFS;
3095 if (sfamily == AF_INET6)
3096 cifs_reclassify_socket6(socket);
3098 cifs_reclassify_socket4(socket);
3101 rc = bind_socket(server);
3106 * Eventually check for other socket options to change from
3107 * the default. sock_setsockopt not used because it expects
3110 socket->sk->sk_rcvtimeo = 7 * HZ;
3111 socket->sk->sk_sndtimeo = 5 * HZ;
3113 /* make the bufsizes depend on wsize/rsize and max requests */
3114 if (server->noautotune) {
3115 if (socket->sk->sk_sndbuf < (200 * 1024))
3116 socket->sk->sk_sndbuf = 200 * 1024;
3117 if (socket->sk->sk_rcvbuf < (140 * 1024))
3118 socket->sk->sk_rcvbuf = 140 * 1024;
3121 if (server->tcp_nodelay) {
3123 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3124 (char *)&val, sizeof(val));
3126 cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3130 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3131 socket->sk->sk_sndbuf,
3132 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3134 rc = socket->ops->connect(socket, saddr, slen, 0);
3136 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3137 sock_release(socket);
3138 server->ssocket = NULL;
3142 if (sport == htons(RFC1001_PORT))
3143 rc = ip_rfc1001_connect(server);
3149 ip_connect(struct TCP_Server_Info *server)
3152 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3153 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3155 if (server->dstaddr.ss_family == AF_INET6)
3156 sport = &addr6->sin6_port;
3158 sport = &addr->sin_port;
3163 /* try with 445 port at first */
3164 *sport = htons(CIFS_PORT);
3166 rc = generic_ip_connect(server);
3170 /* if it failed, try with 139 port */
3171 *sport = htons(RFC1001_PORT);
3174 return generic_ip_connect(server);
3177 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3178 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3180 /* if we are reconnecting then should we check to see if
3181 * any requested capabilities changed locally e.g. via
3182 * remount but we can not do much about it here
3183 * if they have (even if we could detect it by the following)
3184 * Perhaps we could add a backpointer to array of sb from tcon
3185 * or if we change to make all sb to same share the same
3186 * sb as NFS - then we only have one backpointer to sb.
3187 * What if we wanted to mount the server share twice once with
3188 * and once without posixacls or posix paths? */
3189 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3191 if (vol_info && vol_info->no_linux_ext) {
3192 tcon->fsUnixInfo.Capability = 0;
3193 tcon->unix_ext = 0; /* Unix Extensions disabled */
3194 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
3196 } else if (vol_info)
3197 tcon->unix_ext = 1; /* Unix Extensions supported */
3199 if (tcon->unix_ext == 0) {
3200 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
3204 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3205 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3206 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
3207 /* check for reconnect case in which we do not
3208 want to change the mount behavior if we can avoid it */
3209 if (vol_info == NULL) {
3210 /* turn off POSIX ACL and PATHNAMES if not set
3211 originally at mount time */
3212 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3213 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3214 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3215 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3216 cifs_dbg(VFS, "POSIXPATH support change\n");
3217 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3218 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3219 cifs_dbg(VFS, "possible reconnect error\n");
3220 cifs_dbg(VFS, "server disabled POSIX path support\n");
3224 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3225 cifs_dbg(VFS, "per-share encryption not supported yet\n");
3227 cap &= CIFS_UNIX_CAP_MASK;
3228 if (vol_info && vol_info->no_psx_acl)
3229 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3230 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3231 cifs_dbg(FYI, "negotiated posix acl support\n");
3233 cifs_sb->mnt_cifs_flags |=
3234 CIFS_MOUNT_POSIXACL;
3237 if (vol_info && vol_info->posix_paths == 0)
3238 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3239 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3240 cifs_dbg(FYI, "negotiate posix pathnames\n");
3242 cifs_sb->mnt_cifs_flags |=
3243 CIFS_MOUNT_POSIX_PATHS;
3246 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
3247 #ifdef CONFIG_CIFS_DEBUG2
3248 if (cap & CIFS_UNIX_FCNTL_CAP)
3249 cifs_dbg(FYI, "FCNTL cap\n");
3250 if (cap & CIFS_UNIX_EXTATTR_CAP)
3251 cifs_dbg(FYI, "EXTATTR cap\n");
3252 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3253 cifs_dbg(FYI, "POSIX path cap\n");
3254 if (cap & CIFS_UNIX_XATTR_CAP)
3255 cifs_dbg(FYI, "XATTR cap\n");
3256 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3257 cifs_dbg(FYI, "POSIX ACL cap\n");
3258 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3259 cifs_dbg(FYI, "very large read cap\n");
3260 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3261 cifs_dbg(FYI, "very large write cap\n");
3262 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3263 cifs_dbg(FYI, "transport encryption cap\n");
3264 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3265 cifs_dbg(FYI, "mandatory transport encryption cap\n");
3266 #endif /* CIFS_DEBUG2 */
3267 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3268 if (vol_info == NULL) {
3269 cifs_dbg(FYI, "resetting capabilities failed\n");
3271 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");
3277 void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3278 struct cifs_sb_info *cifs_sb)
3280 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3282 spin_lock_init(&cifs_sb->tlink_tree_lock);
3283 cifs_sb->tlink_tree = RB_ROOT;
3286 * Temporarily set r/wsize for matching superblock. If we end up using
3287 * new sb then client will later negotiate it downward if needed.
3289 cifs_sb->rsize = pvolume_info->rsize;
3290 cifs_sb->wsize = pvolume_info->wsize;
3292 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3293 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3294 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3295 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3296 cifs_dbg(FYI, "file mode: 0x%hx dir mode: 0x%hx\n",
3297 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3299 cifs_sb->actimeo = pvolume_info->actimeo;
3300 cifs_sb->local_nls = pvolume_info->local_nls;
3302 if (pvolume_info->noperm)
3303 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3304 if (pvolume_info->setuids)
3305 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3306 if (pvolume_info->server_ino)
3307 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3308 if (pvolume_info->remap)
3309 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3310 if (pvolume_info->sfu_remap)
3311 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3312 if (pvolume_info->no_xattr)
3313 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3314 if (pvolume_info->sfu_emul)
3315 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3316 if (pvolume_info->nobrl)
3317 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3318 if (pvolume_info->nostrictsync)
3319 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3320 if (pvolume_info->mand_lock)
3321 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3322 if (pvolume_info->rwpidforward)
3323 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3324 if (pvolume_info->cifs_acl)
3325 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3326 if (pvolume_info->backupuid_specified) {
3327 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3328 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3330 if (pvolume_info->backupgid_specified) {
3331 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3332 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3334 if (pvolume_info->override_uid)
3335 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3336 if (pvolume_info->override_gid)
3337 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3338 if (pvolume_info->dynperm)
3339 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3340 if (pvolume_info->fsc)
3341 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3342 if (pvolume_info->multiuser)
3343 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3344 CIFS_MOUNT_NO_PERM);
3345 if (pvolume_info->strict_io)
3346 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3347 if (pvolume_info->direct_io) {
3348 cifs_dbg(FYI, "mounting share using direct i/o\n");
3349 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3351 if (pvolume_info->mfsymlinks) {
3352 if (pvolume_info->sfu_emul) {
3354 * Our SFU ("Services for Unix" emulation does not allow
3355 * creating symlinks but does allow reading existing SFU
3356 * symlinks (it does allow both creating and reading SFU
3357 * style mknod and FIFOs though). When "mfsymlinks" and
3358 * "sfu" are both enabled at the same time, it allows
3359 * reading both types of symlinks, but will only create
3360 * them with mfsymlinks format. This allows better
3361 * Apple compatibility (probably better for Samba too)
3362 * while still recognizing old Windows style symlinks.
3364 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
3366 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3369 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3370 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
3374 cleanup_volume_info_contents(struct smb_vol *volume_info)
3376 kfree(volume_info->username);
3377 kzfree(volume_info->password);
3378 kfree(volume_info->UNC);
3379 kfree(volume_info->domainname);
3380 kfree(volume_info->iocharset);
3381 kfree(volume_info->prepath);
3385 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3389 cleanup_volume_info_contents(volume_info);
3394 #ifdef CONFIG_CIFS_DFS_UPCALL
3396 * cifs_build_path_to_root returns full path to root when we do not have an
3397 * exiting connection (tcon)
3400 build_unc_path_to_root(const struct smb_vol *vol,
3401 const struct cifs_sb_info *cifs_sb)
3403 char *full_path, *pos;
3404 unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
3405 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3407 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3408 if (full_path == NULL)
3409 return ERR_PTR(-ENOMEM);
3411 strncpy(full_path, vol->UNC, unc_len);
3412 pos = full_path + unc_len;
3415 *pos = CIFS_DIR_SEP(cifs_sb);
3416 strncpy(pos + 1, vol->prepath, pplen);
3420 *pos = '\0'; /* add trailing null */
3421 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3422 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
3427 * Perform a dfs referral query for a share and (optionally) prefix
3429 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3430 * to a string containing updated options for the submount. Otherwise it
3431 * will be left untouched.
3433 * Returns the rc from get_dfs_path to the caller, which can be used to
3434 * determine whether there were referrals.
3437 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
3438 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3442 unsigned int num_referrals = 0;
3443 struct dfs_info3_param *referrals = NULL;
3444 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3446 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3447 if (IS_ERR(full_path))
3448 return PTR_ERR(full_path);
3450 /* For DFS paths, skip the first '\' of the UNC */
3451 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3453 rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
3454 &num_referrals, &referrals, cifs_remap(cifs_sb));
3456 if (!rc && num_referrals > 0) {
3457 char *fake_devname = NULL;
3459 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3460 full_path + 1, referrals,
3463 free_dfs_info_array(referrals, num_referrals);
3465 if (IS_ERR(mdata)) {
3466 rc = PTR_ERR(mdata);
3469 cleanup_volume_info_contents(volume_info);
3470 rc = cifs_setup_volume_info(volume_info, mdata,
3473 kfree(fake_devname);
3474 kfree(cifs_sb->mountdata);
3475 cifs_sb->mountdata = mdata;
3483 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3484 const char *devname)
3488 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3491 if (volume_info->nullauth) {
3492 cifs_dbg(FYI, "Anonymous login\n");
3493 kfree(volume_info->username);
3494 volume_info->username = NULL;
3495 } else if (volume_info->username) {
3496 /* BB fixme parse for domain name here */
3497 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
3499 cifs_dbg(VFS, "No username specified\n");
3500 /* In userspace mount helper we can get user name from alternate
3501 locations such as env variables and files on disk */
3505 /* this is needed for ASCII cp to Unicode converts */
3506 if (volume_info->iocharset == NULL) {
3507 /* load_nls_default cannot return null */
3508 volume_info->local_nls = load_nls_default();
3510 volume_info->local_nls = load_nls(volume_info->iocharset);
3511 if (volume_info->local_nls == NULL) {
3512 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
3513 volume_info->iocharset);
3522 cifs_get_volume_info(char *mount_data, const char *devname)
3525 struct smb_vol *volume_info;
3527 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
3529 return ERR_PTR(-ENOMEM);
3531 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3533 cifs_cleanup_volume_info(volume_info);
3534 volume_info = ERR_PTR(rc);
3541 cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
3543 struct cifs_tcon *tcon,
3544 struct cifs_sb_info *cifs_sb,
3551 sep = CIFS_DIR_SEP(cifs_sb);
3554 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
3556 /* skip separators */
3561 /* next separator */
3562 while (*s && *s != sep)
3566 * temporarily null-terminate the path at the end of
3567 * the current component
3571 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3579 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3583 struct cifs_ses *ses;
3584 struct cifs_tcon *tcon;
3585 struct TCP_Server_Info *server;
3587 struct tcon_link *tlink;
3588 #ifdef CONFIG_CIFS_DFS_UPCALL
3589 int referral_walks_count = 0;
3592 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs");
3596 #ifdef CONFIG_CIFS_DFS_UPCALL
3598 /* cleanup activities if we're chasing a referral */
3599 if (referral_walks_count) {
3601 cifs_put_tcon(tcon);
3603 cifs_put_smb_ses(ses);
3605 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
3619 /* get a reference to a tcp session */
3620 server = cifs_get_tcp_session(volume_info);
3621 if (IS_ERR(server)) {
3622 rc = PTR_ERR(server);
3623 bdi_destroy(&cifs_sb->bdi);
3627 /* get a reference to a SMB session */
3628 ses = cifs_get_smb_ses(server, volume_info);
3632 goto mount_fail_check;
3635 #ifdef CONFIG_CIFS_SMB2
3636 if ((volume_info->persistent == true) && ((ses->server->capabilities &
3637 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES) == 0)) {
3638 cifs_dbg(VFS, "persistent handles not supported by server\n");
3640 goto mount_fail_check;
3642 #endif /* CONFIG_CIFS_SMB2*/
3644 /* search for existing tcon to this server share */
3645 tcon = cifs_get_tcon(ses, volume_info);
3649 goto remote_path_check;
3652 /* tell server which Unix caps we support */
3653 if (cap_unix(tcon->ses)) {
3654 /* reset of caps checks mount to see if unix extensions
3655 disabled for just this mount */
3656 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3657 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3658 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3659 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3661 goto mount_fail_check;
3664 tcon->unix_ext = 0; /* server does not support them */
3666 /* do not care if a following call succeed - informational */
3667 if (!tcon->ipc && server->ops->qfs_tcon)
3668 server->ops->qfs_tcon(xid, tcon);
3670 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3671 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
3673 /* tune readahead according to rsize */
3674 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
3677 #ifdef CONFIG_CIFS_DFS_UPCALL
3679 * Perform an unconditional check for whether there are DFS
3680 * referrals for this path without prefix, to provide support
3681 * for DFS referrals from w2k8 servers which don't seem to respond
3682 * with PATH_NOT_COVERED to requests that include the prefix.
3683 * Chase the referral if found, otherwise continue normally.
3685 if (referral_walks_count == 0) {
3686 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3689 referral_walks_count++;
3690 goto try_mount_again;
3695 /* check if a whole path is not remote */
3697 if (!server->ops->is_path_accessible) {
3699 goto mount_fail_check;
3702 * cifs_build_path_to_root works only when we have a valid tcon
3704 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3705 if (full_path == NULL) {
3707 goto mount_fail_check;
3709 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3711 if (rc != 0 && rc != -EREMOTE) {
3713 goto mount_fail_check;
3716 if (rc != -EREMOTE) {
3717 rc = cifs_are_all_path_components_accessible(server,
3721 cifs_dbg(VFS, "cannot query dirs between root and final path, "
3722 "enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
3723 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
3730 /* get referral if needed */
3731 if (rc == -EREMOTE) {
3732 #ifdef CONFIG_CIFS_DFS_UPCALL
3733 if (referral_walks_count > MAX_NESTED_LINKS) {
3735 * BB: when we implement proper loop detection,
3736 * we will remove this check. But now we need it
3737 * to prevent an indefinite loop if 'DFS tree' is
3738 * misconfigured (i.e. has loops).
3741 goto mount_fail_check;
3744 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
3747 referral_walks_count++;
3748 goto try_mount_again;
3750 goto mount_fail_check;
3751 #else /* No DFS support, return error on mount */
3757 goto mount_fail_check;
3759 /* now, hang the tcon off of the superblock */
3760 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3761 if (tlink == NULL) {
3763 goto mount_fail_check;
3766 tlink->tl_uid = ses->linux_uid;
3767 tlink->tl_tcon = tcon;
3768 tlink->tl_time = jiffies;
3769 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3770 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3772 cifs_sb->master_tlink = tlink;
3773 spin_lock(&cifs_sb->tlink_tree_lock);
3774 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3775 spin_unlock(&cifs_sb->tlink_tree_lock);
3777 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3781 /* on error free sesinfo and tcon struct if needed */
3783 /* If find_unc succeeded then rc == 0 so we can not end */
3784 /* up accidentally freeing someone elses tcon struct */
3786 cifs_put_tcon(tcon);
3788 cifs_put_smb_ses(ses);
3790 cifs_put_tcp_session(server, 0);
3791 bdi_destroy(&cifs_sb->bdi);
3800 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3801 * pointer may be NULL.
3804 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
3805 const char *tree, struct cifs_tcon *tcon,
3806 const struct nls_table *nls_codepage)
3808 struct smb_hdr *smb_buffer;
3809 struct smb_hdr *smb_buffer_response;
3812 unsigned char *bcc_ptr;
3815 __u16 bytes_left, count;
3820 smb_buffer = cifs_buf_get();
3821 if (smb_buffer == NULL)
3824 smb_buffer_response = smb_buffer;
3826 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3827 NULL /*no tid */ , 4 /*wct */ );
3829 smb_buffer->Mid = get_next_mid(ses->server);
3830 smb_buffer->Uid = ses->Suid;
3831 pSMB = (TCONX_REQ *) smb_buffer;
3832 pSMBr = (TCONX_RSP *) smb_buffer_response;
3834 pSMB->AndXCommand = 0xFF;
3835 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3836 bcc_ptr = &pSMB->Password[0];
3837 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3838 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3839 *bcc_ptr = 0; /* password is null byte */
3840 bcc_ptr++; /* skip password */
3841 /* already aligned so no need to do it below */
3843 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3844 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3845 specified as required (when that support is added to
3846 the vfs in the future) as only NTLM or the much
3847 weaker LANMAN (which we do not send by default) is accepted
3848 by Samba (not sure whether other servers allow
3849 NTLMv2 password here) */
3850 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3851 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3852 (ses->sectype == LANMAN))
3853 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3854 ses->server->sec_mode &
3855 SECMODE_PW_ENCRYPT ? true : false,
3858 #endif /* CIFS_WEAK_PW_HASH */
3859 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3860 bcc_ptr, nls_codepage);
3862 cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
3864 cifs_buf_release(smb_buffer);
3868 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3869 if (ses->capabilities & CAP_UNICODE) {
3870 /* must align unicode strings */
3871 *bcc_ptr = 0; /* null byte password */
3876 if (ses->server->sign)
3877 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3879 if (ses->capabilities & CAP_STATUS32) {
3880 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3882 if (ses->capabilities & CAP_DFS) {
3883 smb_buffer->Flags2 |= SMBFLG2_DFS;
3885 if (ses->capabilities & CAP_UNICODE) {
3886 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3888 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3889 6 /* max utf8 char length in bytes */ *
3890 (/* server len*/ + 256 /* share len */), nls_codepage);
3891 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3892 bcc_ptr += 2; /* skip trailing null */
3893 } else { /* ASCII */
3894 strcpy(bcc_ptr, tree);
3895 bcc_ptr += strlen(tree) + 1;
3897 strcpy(bcc_ptr, "?????");
3898 bcc_ptr += strlen("?????");
3900 count = bcc_ptr - &pSMB->Password[0];
3901 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3902 pSMB->hdr.smb_buf_length) + count);
3903 pSMB->ByteCount = cpu_to_le16(count);
3905 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3908 /* above now done in SendReceive */
3909 if ((rc == 0) && (tcon != NULL)) {
3912 tcon->tidStatus = CifsGood;
3913 tcon->need_reconnect = false;
3914 tcon->tid = smb_buffer_response->Tid;
3915 bcc_ptr = pByteArea(smb_buffer_response);
3916 bytes_left = get_bcc(smb_buffer_response);
3917 length = strnlen(bcc_ptr, bytes_left - 2);
3918 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3924 /* skip service field (NB: this field is always ASCII) */
3926 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3927 (bcc_ptr[2] == 'C')) {
3928 cifs_dbg(FYI, "IPC connection\n");
3931 } else if (length == 2) {
3932 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3933 /* the most common case */
3934 cifs_dbg(FYI, "disk share connection\n");
3937 bcc_ptr += length + 1;
3938 bytes_left -= (length + 1);
3939 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
3941 /* mostly informational -- no need to fail on error here */
3942 kfree(tcon->nativeFileSystem);
3943 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
3944 bytes_left, is_unicode,
3947 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
3949 if ((smb_buffer_response->WordCount == 3) ||
3950 (smb_buffer_response->WordCount == 7))
3951 /* field is in same location */
3952 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3955 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
3956 } else if ((rc == 0) && tcon == NULL) {
3957 /* all we need to save for IPC$ connection */
3958 ses->ipc_tid = smb_buffer_response->Tid;
3961 cifs_buf_release(smb_buffer);
3965 static void delayed_free(struct rcu_head *p)
3967 struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
3968 unload_nls(sbi->local_nls);
3973 cifs_umount(struct cifs_sb_info *cifs_sb)
3975 struct rb_root *root = &cifs_sb->tlink_tree;
3976 struct rb_node *node;
3977 struct tcon_link *tlink;
3979 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3981 spin_lock(&cifs_sb->tlink_tree_lock);
3982 while ((node = rb_first(root))) {
3983 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3984 cifs_get_tlink(tlink);
3985 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3986 rb_erase(node, root);
3988 spin_unlock(&cifs_sb->tlink_tree_lock);
3989 cifs_put_tlink(tlink);
3990 spin_lock(&cifs_sb->tlink_tree_lock);
3992 spin_unlock(&cifs_sb->tlink_tree_lock);
3994 bdi_destroy(&cifs_sb->bdi);
3995 kfree(cifs_sb->mountdata);
3996 kfree(cifs_sb->prepath);
3997 call_rcu(&cifs_sb->rcu, delayed_free);
4001 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
4004 struct TCP_Server_Info *server = ses->server;
4006 if (!server->ops->need_neg || !server->ops->negotiate)
4009 /* only send once per connect */
4010 if (!server->ops->need_neg(server))
4013 set_credits(server, 1);
4015 rc = server->ops->negotiate(xid, ses);
4017 spin_lock(&GlobalMid_Lock);
4018 if (server->tcpStatus == CifsNeedNegotiate)
4019 server->tcpStatus = CifsGood;
4022 spin_unlock(&GlobalMid_Lock);
4029 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
4030 struct nls_table *nls_info)
4033 struct TCP_Server_Info *server = ses->server;
4035 ses->capabilities = server->capabilities;
4036 if (linuxExtEnabled == 0)
4037 ses->capabilities &= (~server->vals->cap_unix);
4039 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
4040 server->sec_mode, server->capabilities, server->timeAdj);
4042 if (server->ops->sess_setup)
4043 rc = server->ops->sess_setup(xid, ses, nls_info);
4046 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
4052 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
4054 vol->sectype = ses->sectype;
4056 /* krb5 is special, since we don't need username or pw */
4057 if (vol->sectype == Kerberos)
4060 return cifs_set_cifscreds(vol, ses);
4063 static struct cifs_tcon *
4064 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
4067 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4068 struct cifs_ses *ses;
4069 struct cifs_tcon *tcon = NULL;
4070 struct smb_vol *vol_info;
4072 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
4073 if (vol_info == NULL)
4074 return ERR_PTR(-ENOMEM);
4076 vol_info->local_nls = cifs_sb->local_nls;
4077 vol_info->linux_uid = fsuid;
4078 vol_info->cred_uid = fsuid;
4079 vol_info->UNC = master_tcon->treeName;
4080 vol_info->retry = master_tcon->retry;
4081 vol_info->nocase = master_tcon->nocase;
4082 vol_info->local_lease = master_tcon->local_lease;
4083 vol_info->no_linux_ext = !master_tcon->unix_ext;
4084 vol_info->sectype = master_tcon->ses->sectype;
4085 vol_info->sign = master_tcon->ses->sign;
4087 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4093 /* get a reference for the same TCP session */
4094 spin_lock(&cifs_tcp_ses_lock);
4095 ++master_tcon->ses->server->srv_count;
4096 spin_unlock(&cifs_tcp_ses_lock);
4098 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4100 tcon = (struct cifs_tcon *)ses;
4101 cifs_put_tcp_session(master_tcon->ses->server, 0);
4105 tcon = cifs_get_tcon(ses, vol_info);
4107 cifs_put_smb_ses(ses);
4112 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4114 kfree(vol_info->username);
4115 kfree(vol_info->password);
4122 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4124 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4127 /* find and return a tlink with given uid */
4128 static struct tcon_link *
4129 tlink_rb_search(struct rb_root *root, kuid_t uid)
4131 struct rb_node *node = root->rb_node;
4132 struct tcon_link *tlink;
4135 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4137 if (uid_gt(tlink->tl_uid, uid))
4138 node = node->rb_left;
4139 else if (uid_lt(tlink->tl_uid, uid))
4140 node = node->rb_right;
4147 /* insert a tcon_link into the tree */
4149 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4151 struct rb_node **new = &(root->rb_node), *parent = NULL;
4152 struct tcon_link *tlink;
4155 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4158 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
4159 new = &((*new)->rb_left);
4161 new = &((*new)->rb_right);
4164 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4165 rb_insert_color(&new_tlink->tl_rbnode, root);
4169 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4172 * If the superblock doesn't refer to a multiuser mount, then just return
4173 * the master tcon for the mount.
4175 * First, search the rbtree for an existing tcon for this fsuid. If one
4176 * exists, then check to see if it's pending construction. If it is then wait
4177 * for construction to complete. Once it's no longer pending, check to see if
4178 * it failed and either return an error or retry construction, depending on
4181 * If one doesn't exist then insert a new tcon_link struct into the tree and
4182 * try to construct a new one.
4185 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4188 kuid_t fsuid = current_fsuid();
4189 struct tcon_link *tlink, *newtlink;
4191 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4192 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4194 spin_lock(&cifs_sb->tlink_tree_lock);
4195 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4197 cifs_get_tlink(tlink);
4198 spin_unlock(&cifs_sb->tlink_tree_lock);
4200 if (tlink == NULL) {
4201 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4202 if (newtlink == NULL)
4203 return ERR_PTR(-ENOMEM);
4204 newtlink->tl_uid = fsuid;
4205 newtlink->tl_tcon = ERR_PTR(-EACCES);
4206 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4207 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4208 cifs_get_tlink(newtlink);
4210 spin_lock(&cifs_sb->tlink_tree_lock);
4211 /* was one inserted after previous search? */
4212 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4214 cifs_get_tlink(tlink);
4215 spin_unlock(&cifs_sb->tlink_tree_lock);
4217 goto wait_for_construction;
4220 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4221 spin_unlock(&cifs_sb->tlink_tree_lock);
4223 wait_for_construction:
4224 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4225 TASK_INTERRUPTIBLE);
4227 cifs_put_tlink(tlink);
4228 return ERR_PTR(-ERESTARTSYS);
4231 /* if it's good, return it */
4232 if (!IS_ERR(tlink->tl_tcon))
4235 /* return error if we tried this already recently */
4236 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4237 cifs_put_tlink(tlink);
4238 return ERR_PTR(-EACCES);
4241 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4242 goto wait_for_construction;
4245 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4246 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4247 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4249 if (IS_ERR(tlink->tl_tcon)) {
4250 cifs_put_tlink(tlink);
4251 return ERR_PTR(-EACCES);
4258 * periodic workqueue job that scans tcon_tree for a superblock and closes
4262 cifs_prune_tlinks(struct work_struct *work)
4264 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4266 struct rb_root *root = &cifs_sb->tlink_tree;
4267 struct rb_node *node = rb_first(root);
4268 struct rb_node *tmp;
4269 struct tcon_link *tlink;
4272 * Because we drop the spinlock in the loop in order to put the tlink
4273 * it's not guarded against removal of links from the tree. The only
4274 * places that remove entries from the tree are this function and
4275 * umounts. Because this function is non-reentrant and is canceled
4276 * before umount can proceed, this is safe.
4278 spin_lock(&cifs_sb->tlink_tree_lock);
4279 node = rb_first(root);
4280 while (node != NULL) {
4282 node = rb_next(tmp);
4283 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4285 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4286 atomic_read(&tlink->tl_count) != 0 ||
4287 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4290 cifs_get_tlink(tlink);
4291 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4292 rb_erase(tmp, root);
4294 spin_unlock(&cifs_sb->tlink_tree_lock);
4295 cifs_put_tlink(tlink);
4296 spin_lock(&cifs_sb->tlink_tree_lock);
4298 spin_unlock(&cifs_sb->tlink_tree_lock);
4300 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,