4 * Copyright (C) International Business Machines Corp., 2002,2011
5 * Author(s): Steve French (sfrench@us.ibm.com)
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/net.h>
23 #include <linux/string.h>
24 #include <linux/list.h>
25 #include <linux/wait.h>
26 #include <linux/slab.h>
27 #include <linux/pagemap.h>
28 #include <linux/ctype.h>
29 #include <linux/utsname.h>
30 #include <linux/mempool.h>
31 #include <linux/delay.h>
32 #include <linux/completion.h>
33 #include <linux/kthread.h>
34 #include <linux/pagevec.h>
35 #include <linux/freezer.h>
36 #include <linux/namei.h>
37 #include <asm/uaccess.h>
38 #include <asm/processor.h>
39 #include <linux/inet.h>
40 #include <linux/module.h>
41 #include <keys/user-type.h>
43 #include <linux/parser.h>
47 #include "cifsproto.h"
48 #include "cifs_unicode.h"
49 #include "cifs_debug.h"
50 #include "cifs_fs_sb.h"
53 #include "rfc1002pdu.h"
57 #define RFC1001_PORT 139
59 extern mempool_t *cifs_req_poolp;
61 /* FIXME: should these be tunable? */
62 #define TLINK_ERROR_EXPIRE (1 * HZ)
63 #define TLINK_IDLE_EXPIRE (600 * HZ)
67 /* Mount options that take no arguments */
68 Opt_user_xattr, Opt_nouser_xattr,
69 Opt_forceuid, Opt_noforceuid,
70 Opt_forcegid, Opt_noforcegid,
71 Opt_noblocksend, Opt_noautotune,
72 Opt_hard, Opt_soft, Opt_perm, Opt_noperm,
73 Opt_mapposix, Opt_nomapposix,
74 Opt_mapchars, Opt_nomapchars, Opt_sfu,
75 Opt_nosfu, Opt_nodfs, Opt_posixpaths,
76 Opt_noposixpaths, Opt_nounix,
79 Opt_forcemandatorylock, Opt_setuids,
80 Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
81 Opt_nohard, Opt_nosoft,
83 Opt_nostrictsync, Opt_strictsync,
84 Opt_serverino, Opt_noserverino,
85 Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
86 Opt_acl, Opt_noacl, Opt_locallease,
87 Opt_sign, Opt_seal, Opt_noac,
88 Opt_fsc, Opt_mfsymlinks,
89 Opt_multiuser, Opt_sloppy, Opt_nosharesock,
90 Opt_persistent, Opt_nopersistent,
91 Opt_resilient, Opt_noresilient,
93 /* Mount options which take numeric value */
94 Opt_backupuid, Opt_backupgid, Opt_uid,
95 Opt_cruid, Opt_gid, Opt_file_mode,
96 Opt_dirmode, Opt_port,
97 Opt_rsize, Opt_wsize, Opt_actimeo,
99 /* Mount options which take string value */
100 Opt_user, Opt_pass, Opt_ip,
101 Opt_domain, Opt_srcaddr, Opt_iocharset,
102 Opt_netbiosname, Opt_servern,
103 Opt_ver, Opt_vers, Opt_sec, Opt_cache,
105 /* Mount options to be ignored */
108 /* Options which could be blank */
116 static const match_table_t cifs_mount_option_tokens = {
118 { Opt_user_xattr, "user_xattr" },
119 { Opt_nouser_xattr, "nouser_xattr" },
120 { Opt_forceuid, "forceuid" },
121 { Opt_noforceuid, "noforceuid" },
122 { Opt_forcegid, "forcegid" },
123 { Opt_noforcegid, "noforcegid" },
124 { Opt_noblocksend, "noblocksend" },
125 { Opt_noautotune, "noautotune" },
126 { Opt_hard, "hard" },
127 { Opt_soft, "soft" },
128 { Opt_perm, "perm" },
129 { Opt_noperm, "noperm" },
130 { Opt_mapchars, "mapchars" }, /* SFU style */
131 { Opt_nomapchars, "nomapchars" },
132 { Opt_mapposix, "mapposix" }, /* SFM style */
133 { Opt_nomapposix, "nomapposix" },
135 { Opt_nosfu, "nosfu" },
136 { Opt_nodfs, "nodfs" },
137 { Opt_posixpaths, "posixpaths" },
138 { Opt_noposixpaths, "noposixpaths" },
139 { Opt_nounix, "nounix" },
140 { Opt_nounix, "nolinux" },
141 { Opt_nocase, "nocase" },
142 { Opt_nocase, "ignorecase" },
144 { Opt_nobrl, "nobrl" },
145 { Opt_nobrl, "nolock" },
146 { Opt_forcemandatorylock, "forcemandatorylock" },
147 { Opt_forcemandatorylock, "forcemand" },
148 { Opt_setuids, "setuids" },
149 { Opt_nosetuids, "nosetuids" },
150 { Opt_dynperm, "dynperm" },
151 { Opt_nodynperm, "nodynperm" },
152 { Opt_nohard, "nohard" },
153 { Opt_nosoft, "nosoft" },
154 { Opt_nointr, "nointr" },
155 { Opt_intr, "intr" },
156 { Opt_nostrictsync, "nostrictsync" },
157 { Opt_strictsync, "strictsync" },
158 { Opt_serverino, "serverino" },
159 { Opt_noserverino, "noserverino" },
160 { Opt_rwpidforward, "rwpidforward" },
161 { Opt_cifsacl, "cifsacl" },
162 { Opt_nocifsacl, "nocifsacl" },
164 { Opt_noacl, "noacl" },
165 { Opt_locallease, "locallease" },
166 { Opt_sign, "sign" },
167 { Opt_seal, "seal" },
168 { Opt_noac, "noac" },
170 { Opt_mfsymlinks, "mfsymlinks" },
171 { Opt_multiuser, "multiuser" },
172 { Opt_sloppy, "sloppy" },
173 { Opt_nosharesock, "nosharesock" },
174 { Opt_persistent, "persistenthandles"},
175 { Opt_nopersistent, "nopersistenthandles"},
176 { Opt_resilient, "resilienthandles"},
177 { Opt_noresilient, "noresilienthandles"},
179 { Opt_backupuid, "backupuid=%s" },
180 { Opt_backupgid, "backupgid=%s" },
181 { Opt_uid, "uid=%s" },
182 { Opt_cruid, "cruid=%s" },
183 { Opt_gid, "gid=%s" },
184 { Opt_file_mode, "file_mode=%s" },
185 { Opt_dirmode, "dirmode=%s" },
186 { Opt_dirmode, "dir_mode=%s" },
187 { Opt_port, "port=%s" },
188 { Opt_rsize, "rsize=%s" },
189 { Opt_wsize, "wsize=%s" },
190 { Opt_actimeo, "actimeo=%s" },
192 { Opt_blank_user, "user=" },
193 { Opt_blank_user, "username=" },
194 { Opt_user, "user=%s" },
195 { Opt_user, "username=%s" },
196 { Opt_blank_pass, "pass=" },
197 { Opt_blank_pass, "password=" },
198 { Opt_pass, "pass=%s" },
199 { Opt_pass, "password=%s" },
200 { Opt_blank_ip, "ip=" },
201 { Opt_blank_ip, "addr=" },
203 { Opt_ip, "addr=%s" },
204 { Opt_ignore, "unc=%s" },
205 { Opt_ignore, "target=%s" },
206 { Opt_ignore, "path=%s" },
207 { Opt_domain, "dom=%s" },
208 { Opt_domain, "domain=%s" },
209 { Opt_domain, "workgroup=%s" },
210 { Opt_srcaddr, "srcaddr=%s" },
211 { Opt_ignore, "prefixpath=%s" },
212 { Opt_iocharset, "iocharset=%s" },
213 { Opt_netbiosname, "netbiosname=%s" },
214 { Opt_servern, "servern=%s" },
215 { Opt_ver, "ver=%s" },
216 { Opt_vers, "vers=%s" },
217 { Opt_sec, "sec=%s" },
218 { Opt_cache, "cache=%s" },
220 { Opt_ignore, "cred" },
221 { Opt_ignore, "credentials" },
222 { Opt_ignore, "cred=%s" },
223 { Opt_ignore, "credentials=%s" },
224 { Opt_ignore, "guest" },
225 { Opt_ignore, "rw" },
226 { Opt_ignore, "ro" },
227 { Opt_ignore, "suid" },
228 { Opt_ignore, "nosuid" },
229 { Opt_ignore, "exec" },
230 { Opt_ignore, "noexec" },
231 { Opt_ignore, "nodev" },
232 { Opt_ignore, "noauto" },
233 { Opt_ignore, "dev" },
234 { Opt_ignore, "mand" },
235 { Opt_ignore, "nomand" },
236 { Opt_ignore, "_netdev" },
242 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
243 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
244 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
245 Opt_sec_ntlmv2i, Opt_sec_lanman,
251 static const match_table_t cifs_secflavor_tokens = {
252 { Opt_sec_krb5, "krb5" },
253 { Opt_sec_krb5i, "krb5i" },
254 { Opt_sec_krb5p, "krb5p" },
255 { Opt_sec_ntlmsspi, "ntlmsspi" },
256 { Opt_sec_ntlmssp, "ntlmssp" },
257 { Opt_ntlm, "ntlm" },
258 { Opt_sec_ntlmi, "ntlmi" },
259 { Opt_sec_ntlmv2, "nontlm" },
260 { Opt_sec_ntlmv2, "ntlmv2" },
261 { Opt_sec_ntlmv2i, "ntlmv2i" },
262 { Opt_sec_lanman, "lanman" },
263 { Opt_sec_none, "none" },
265 { Opt_sec_err, NULL }
276 static const match_table_t cifs_cacheflavor_tokens = {
277 { Opt_cache_loose, "loose" },
278 { Opt_cache_strict, "strict" },
279 { Opt_cache_none, "none" },
280 { Opt_cache_err, NULL }
283 static const match_table_t cifs_smb_version_tokens = {
284 { Smb_1, SMB1_VERSION_STRING },
285 { Smb_20, SMB20_VERSION_STRING},
286 { Smb_21, SMB21_VERSION_STRING },
287 { Smb_30, SMB30_VERSION_STRING },
288 { Smb_302, SMB302_VERSION_STRING },
289 #ifdef CONFIG_CIFS_SMB311
290 { Smb_311, SMB311_VERSION_STRING },
291 { Smb_311, ALT_SMB311_VERSION_STRING },
293 { Smb_version_err, NULL }
296 static int ip_connect(struct TCP_Server_Info *server);
297 static int generic_ip_connect(struct TCP_Server_Info *server);
298 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
299 static void cifs_prune_tlinks(struct work_struct *work);
300 static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
301 const char *devname);
304 * cifs tcp session reconnection
306 * mark tcp session as reconnecting so temporarily locked
307 * mark all smb sessions as reconnecting for tcp session
308 * reconnect tcp session
309 * wake up waiters on reconnection? - (not needed currently)
312 cifs_reconnect(struct TCP_Server_Info *server)
315 struct list_head *tmp, *tmp2;
316 struct cifs_ses *ses;
317 struct cifs_tcon *tcon;
318 struct mid_q_entry *mid_entry;
319 struct list_head retry_list;
321 spin_lock(&GlobalMid_Lock);
322 if (server->tcpStatus == CifsExiting) {
323 /* the demux thread will exit normally
324 next time through the loop */
325 spin_unlock(&GlobalMid_Lock);
328 server->tcpStatus = CifsNeedReconnect;
329 spin_unlock(&GlobalMid_Lock);
331 #ifdef CONFIG_CIFS_SMB2
332 server->max_read = 0;
335 cifs_dbg(FYI, "Reconnecting tcp session\n");
337 /* before reconnecting the tcp session, mark the smb session (uid)
338 and the tid bad so they are not used until reconnected */
339 cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
341 spin_lock(&cifs_tcp_ses_lock);
342 list_for_each(tmp, &server->smb_ses_list) {
343 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
344 ses->need_reconnect = true;
346 list_for_each(tmp2, &ses->tcon_list) {
347 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
348 tcon->need_reconnect = true;
351 spin_unlock(&cifs_tcp_ses_lock);
353 /* do not want to be sending data on a socket we are freeing */
354 cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
355 mutex_lock(&server->srv_mutex);
356 if (server->ssocket) {
357 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
358 server->ssocket->state, server->ssocket->flags);
359 kernel_sock_shutdown(server->ssocket, SHUT_WR);
360 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
361 server->ssocket->state, server->ssocket->flags);
362 sock_release(server->ssocket);
363 server->ssocket = NULL;
365 server->sequence_number = 0;
366 server->session_estab = false;
367 kfree(server->session_key.response);
368 server->session_key.response = NULL;
369 server->session_key.len = 0;
370 server->lstrp = jiffies;
372 /* mark submitted MIDs for retry and issue callback */
373 INIT_LIST_HEAD(&retry_list);
374 cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
375 spin_lock(&GlobalMid_Lock);
376 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
377 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
378 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
379 mid_entry->mid_state = MID_RETRY_NEEDED;
380 list_move(&mid_entry->qhead, &retry_list);
382 spin_unlock(&GlobalMid_Lock);
383 mutex_unlock(&server->srv_mutex);
385 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
386 list_for_each_safe(tmp, tmp2, &retry_list) {
387 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
388 list_del_init(&mid_entry->qhead);
389 mid_entry->callback(mid_entry);
395 /* we should try only the port we connected to before */
396 mutex_lock(&server->srv_mutex);
397 rc = generic_ip_connect(server);
399 cifs_dbg(FYI, "reconnect error %d\n", rc);
400 mutex_unlock(&server->srv_mutex);
403 atomic_inc(&tcpSesReconnectCount);
404 spin_lock(&GlobalMid_Lock);
405 if (server->tcpStatus != CifsExiting)
406 server->tcpStatus = CifsNeedNegotiate;
407 spin_unlock(&GlobalMid_Lock);
408 mutex_unlock(&server->srv_mutex);
410 } while (server->tcpStatus == CifsNeedReconnect);
416 cifs_echo_request(struct work_struct *work)
419 struct TCP_Server_Info *server = container_of(work,
420 struct TCP_Server_Info, echo.work);
423 * We cannot send an echo if it is disabled or until the
424 * NEGOTIATE_PROTOCOL request is done, which is indicated by
425 * server->ops->need_neg() == true. Also, no need to ping if
426 * we got a response recently.
429 if (server->tcpStatus == CifsNeedReconnect ||
430 server->tcpStatus == CifsExiting || server->tcpStatus == CifsNew ||
431 (server->ops->can_echo && !server->ops->can_echo(server)) ||
432 time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
435 rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
437 cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
441 queue_delayed_work(cifsiod_wq, &server->echo, SMB_ECHO_INTERVAL);
445 allocate_buffers(struct TCP_Server_Info *server)
447 if (!server->bigbuf) {
448 server->bigbuf = (char *)cifs_buf_get();
449 if (!server->bigbuf) {
450 cifs_dbg(VFS, "No memory for large SMB response\n");
452 /* retry will check if exiting */
455 } else if (server->large_buf) {
456 /* we are reusing a dirty large buf, clear its start */
457 memset(server->bigbuf, 0, HEADER_SIZE(server));
460 if (!server->smallbuf) {
461 server->smallbuf = (char *)cifs_small_buf_get();
462 if (!server->smallbuf) {
463 cifs_dbg(VFS, "No memory for SMB response\n");
465 /* retry will check if exiting */
468 /* beginning of smb buffer is cleared in our buf_get */
470 /* if existing small buf clear beginning */
471 memset(server->smallbuf, 0, HEADER_SIZE(server));
478 server_unresponsive(struct TCP_Server_Info *server)
481 * We need to wait 2 echo intervals to make sure we handle such
483 * 1s client sends a normal SMB request
484 * 2s client gets a response
485 * 30s echo workqueue job pops, and decides we got a response recently
486 * and don't need to send another
488 * 65s kernel_recvmsg times out, and we see that we haven't gotten
489 * a response in >60s.
491 if (server->tcpStatus == CifsGood &&
492 time_after(jiffies, server->lstrp + 2 * SMB_ECHO_INTERVAL)) {
493 cifs_dbg(VFS, "Server %s has not responded in %d seconds. Reconnecting...\n",
494 server->hostname, (2 * SMB_ECHO_INTERVAL) / HZ);
495 cifs_reconnect(server);
496 wake_up(&server->response_q);
504 * kvec_array_init - clone a kvec array, and advance into it
505 * @new: pointer to memory for cloned array
506 * @iov: pointer to original array
507 * @nr_segs: number of members in original array
508 * @bytes: number of bytes to advance into the cloned array
510 * This function will copy the array provided in iov to a section of memory
511 * and advance the specified number of bytes into the new array. It returns
512 * the number of segments in the new array. "new" must be at least as big as
513 * the original iov array.
516 kvec_array_init(struct kvec *new, struct kvec *iov, unsigned int nr_segs,
521 while (bytes || !iov->iov_len) {
522 int copy = min(bytes, iov->iov_len);
526 if (iov->iov_len == base) {
532 memcpy(new, iov, sizeof(*iov) * nr_segs);
533 new->iov_base += base;
534 new->iov_len -= base;
539 get_server_iovec(struct TCP_Server_Info *server, unsigned int nr_segs)
541 struct kvec *new_iov;
543 if (server->iov && nr_segs <= server->nr_iov)
546 /* not big enough -- allocate a new one and release the old */
547 new_iov = kmalloc(sizeof(*new_iov) * nr_segs, GFP_NOFS);
550 server->iov = new_iov;
551 server->nr_iov = nr_segs;
557 cifs_readv_from_socket(struct TCP_Server_Info *server, struct kvec *iov_orig,
558 unsigned int nr_segs, unsigned int to_read)
563 struct msghdr smb_msg;
566 iov = get_server_iovec(server, nr_segs);
570 smb_msg.msg_control = NULL;
571 smb_msg.msg_controllen = 0;
573 for (total_read = 0; to_read; total_read += length, to_read -= length) {
576 if (server_unresponsive(server)) {
577 total_read = -ECONNABORTED;
581 segs = kvec_array_init(iov, iov_orig, nr_segs, total_read);
583 length = kernel_recvmsg(server->ssocket, &smb_msg,
584 iov, segs, to_read, 0);
586 if (server->tcpStatus == CifsExiting) {
587 total_read = -ESHUTDOWN;
589 } else if (server->tcpStatus == CifsNeedReconnect) {
590 cifs_reconnect(server);
591 total_read = -ECONNABORTED;
593 } else if (length == -ERESTARTSYS ||
597 * Minimum sleep to prevent looping, allowing socket
598 * to clear and app threads to set tcpStatus
599 * CifsNeedReconnect if server hung.
601 usleep_range(1000, 2000);
604 } else if (length <= 0) {
605 cifs_dbg(FYI, "Received no data or error: expecting %d\n"
606 "got %d", to_read, length);
607 cifs_reconnect(server);
608 total_read = -ECONNABORTED;
616 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
617 unsigned int to_read)
622 iov.iov_len = to_read;
624 return cifs_readv_from_socket(server, &iov, 1, to_read);
628 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
631 * The first byte big endian of the length field,
632 * is actually not part of the length but the type
633 * with the most common, zero, as regular data.
636 case RFC1002_SESSION_MESSAGE:
637 /* Regular SMB response */
639 case RFC1002_SESSION_KEEP_ALIVE:
640 cifs_dbg(FYI, "RFC 1002 session keep alive\n");
642 case RFC1002_POSITIVE_SESSION_RESPONSE:
643 cifs_dbg(FYI, "RFC 1002 positive session response\n");
645 case RFC1002_NEGATIVE_SESSION_RESPONSE:
647 * We get this from Windows 98 instead of an error on
648 * SMB negprot response.
650 cifs_dbg(FYI, "RFC 1002 negative session response\n");
651 /* give server a second to clean up */
654 * Always try 445 first on reconnect since we get NACK
655 * on some if we ever connected to port 139 (the NACK
656 * is since we do not begin with RFC1001 session
659 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
660 cifs_reconnect(server);
661 wake_up(&server->response_q);
664 cifs_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
665 cifs_reconnect(server);
672 dequeue_mid(struct mid_q_entry *mid, bool malformed)
674 #ifdef CONFIG_CIFS_STATS2
675 mid->when_received = jiffies;
677 spin_lock(&GlobalMid_Lock);
679 mid->mid_state = MID_RESPONSE_RECEIVED;
681 mid->mid_state = MID_RESPONSE_MALFORMED;
682 list_del_init(&mid->qhead);
683 spin_unlock(&GlobalMid_Lock);
687 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
688 char *buf, int malformed)
690 if (server->ops->check_trans2 &&
691 server->ops->check_trans2(mid, server, buf, malformed))
694 mid->large_buf = server->large_buf;
695 /* Was previous buf put in mpx struct for multi-rsp? */
696 if (!mid->multiRsp) {
697 /* smb buffer will be freed by user thread */
698 if (server->large_buf)
699 server->bigbuf = NULL;
701 server->smallbuf = NULL;
703 dequeue_mid(mid, malformed);
706 static void clean_demultiplex_info(struct TCP_Server_Info *server)
710 /* take it off the list, if it's not already */
711 spin_lock(&cifs_tcp_ses_lock);
712 list_del_init(&server->tcp_ses_list);
713 spin_unlock(&cifs_tcp_ses_lock);
715 spin_lock(&GlobalMid_Lock);
716 server->tcpStatus = CifsExiting;
717 spin_unlock(&GlobalMid_Lock);
718 wake_up_all(&server->response_q);
720 /* check if we have blocked requests that need to free */
721 spin_lock(&server->req_lock);
722 if (server->credits <= 0)
724 spin_unlock(&server->req_lock);
726 * Although there should not be any requests blocked on this queue it
727 * can not hurt to be paranoid and try to wake up requests that may
728 * haven been blocked when more than 50 at time were on the wire to the
729 * same server - they now will see the session is in exit state and get
730 * out of SendReceive.
732 wake_up_all(&server->request_q);
733 /* give those requests time to exit */
736 if (server->ssocket) {
737 sock_release(server->ssocket);
738 server->ssocket = NULL;
741 if (!list_empty(&server->pending_mid_q)) {
742 struct list_head dispose_list;
743 struct mid_q_entry *mid_entry;
744 struct list_head *tmp, *tmp2;
746 INIT_LIST_HEAD(&dispose_list);
747 spin_lock(&GlobalMid_Lock);
748 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
749 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
750 cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid);
751 mid_entry->mid_state = MID_SHUTDOWN;
752 list_move(&mid_entry->qhead, &dispose_list);
754 spin_unlock(&GlobalMid_Lock);
756 /* now walk dispose list and issue callbacks */
757 list_for_each_safe(tmp, tmp2, &dispose_list) {
758 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
759 cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid);
760 list_del_init(&mid_entry->qhead);
761 mid_entry->callback(mid_entry);
763 /* 1/8th of sec is more than enough time for them to exit */
767 if (!list_empty(&server->pending_mid_q)) {
769 * mpx threads have not exited yet give them at least the smb
770 * send timeout time for long ops.
772 * Due to delays on oplock break requests, we need to wait at
773 * least 45 seconds before giving up on a request getting a
774 * response and going ahead and killing cifsd.
776 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
779 * If threads still have not exited they are probably never
780 * coming home not much else we can do but free the memory.
784 kfree(server->hostname);
788 length = atomic_dec_return(&tcpSesAllocCount);
790 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
794 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
797 char *buf = server->smallbuf;
798 unsigned int pdu_length = get_rfc1002_length(buf);
800 /* make sure this will fit in a large buffer */
801 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) - 4) {
802 cifs_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
803 cifs_reconnect(server);
804 wake_up(&server->response_q);
805 return -ECONNABORTED;
808 /* switch to large buffer if too big for a small one */
809 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
810 server->large_buf = true;
811 memcpy(server->bigbuf, buf, server->total_read);
812 buf = server->bigbuf;
815 /* now read the rest */
816 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
817 pdu_length - HEADER_SIZE(server) + 1 + 4);
820 server->total_read += length;
822 dump_smb(buf, server->total_read);
825 * We know that we received enough to get to the MID as we
826 * checked the pdu_length earlier. Now check to see
827 * if the rest of the header is OK. We borrow the length
828 * var for the rest of the loop to avoid a new stack var.
830 * 48 bytes is enough to display the header and a little bit
831 * into the payload for debugging purposes.
833 length = server->ops->check_message(buf, server->total_read);
835 cifs_dump_mem("Bad SMB: ", buf,
836 min_t(unsigned int, server->total_read, 48));
838 if (server->ops->is_status_pending &&
839 server->ops->is_status_pending(buf, server, length))
845 handle_mid(mid, server, buf, length);
850 cifs_demultiplex_thread(void *p)
853 struct TCP_Server_Info *server = p;
854 unsigned int pdu_length;
856 struct task_struct *task_to_wake = NULL;
857 struct mid_q_entry *mid_entry;
859 current->flags |= PF_MEMALLOC;
860 cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
862 length = atomic_inc_return(&tcpSesAllocCount);
864 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
867 while (server->tcpStatus != CifsExiting) {
871 if (!allocate_buffers(server))
874 server->large_buf = false;
875 buf = server->smallbuf;
876 pdu_length = 4; /* enough to get RFC1001 header */
878 length = cifs_read_from_socket(server, buf, pdu_length);
881 server->total_read = length;
884 * The right amount was read from socket - 4 bytes,
885 * so we can now interpret the length field.
887 pdu_length = get_rfc1002_length(buf);
889 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
890 if (!is_smb_response(server, buf[0]))
893 /* make sure we have enough to get to the MID */
894 if (pdu_length < HEADER_SIZE(server) - 1 - 4) {
895 cifs_dbg(VFS, "SMB response too short (%u bytes)\n",
897 cifs_reconnect(server);
898 wake_up(&server->response_q);
902 /* read down to the MID */
903 length = cifs_read_from_socket(server, buf + 4,
904 HEADER_SIZE(server) - 1 - 4);
907 server->total_read += length;
909 mid_entry = server->ops->find_mid(server, buf);
911 if (!mid_entry || !mid_entry->receive)
912 length = standard_receive3(server, mid_entry);
914 length = mid_entry->receive(server, mid_entry);
919 if (server->large_buf)
920 buf = server->bigbuf;
922 server->lstrp = jiffies;
923 if (mid_entry != NULL) {
924 if (!mid_entry->multiRsp || mid_entry->multiEnd)
925 mid_entry->callback(mid_entry);
926 } else if (!server->ops->is_oplock_break ||
927 !server->ops->is_oplock_break(buf, server)) {
928 cifs_dbg(VFS, "No task to wake, unknown frame received! NumMids %d\n",
929 atomic_read(&midCount));
930 cifs_dump_mem("Received Data is: ", buf,
931 HEADER_SIZE(server));
932 #ifdef CONFIG_CIFS_DEBUG2
933 if (server->ops->dump_detail)
934 server->ops->dump_detail(buf);
935 cifs_dump_mids(server);
936 #endif /* CIFS_DEBUG2 */
939 } /* end while !EXITING */
941 /* buffer usually freed in free_mid - need to free it here on exit */
942 cifs_buf_release(server->bigbuf);
943 if (server->smallbuf) /* no sense logging a debug message if NULL */
944 cifs_small_buf_release(server->smallbuf);
946 task_to_wake = xchg(&server->tsk, NULL);
947 clean_demultiplex_info(server);
949 /* if server->tsk was NULL then wait for a signal before exiting */
951 set_current_state(TASK_INTERRUPTIBLE);
952 while (!signal_pending(current)) {
954 set_current_state(TASK_INTERRUPTIBLE);
956 set_current_state(TASK_RUNNING);
959 module_put_and_exit(0);
962 /* extract the host portion of the UNC string */
964 extract_hostname(const char *unc)
970 /* skip double chars at beginning of string */
971 /* BB: check validity of these bytes? */
974 /* delimiter between hostname and sharename is always '\\' now */
975 delim = strchr(src, '\\');
977 return ERR_PTR(-EINVAL);
980 dst = kmalloc((len + 1), GFP_KERNEL);
982 return ERR_PTR(-ENOMEM);
984 memcpy(dst, src, len);
990 static int get_option_ul(substring_t args[], unsigned long *option)
995 string = match_strdup(args);
998 rc = kstrtoul(string, 0, option);
1004 static int get_option_uid(substring_t args[], kuid_t *result)
1006 unsigned long value;
1010 rc = get_option_ul(args, &value);
1014 uid = make_kuid(current_user_ns(), value);
1015 if (!uid_valid(uid))
1022 static int get_option_gid(substring_t args[], kgid_t *result)
1024 unsigned long value;
1028 rc = get_option_ul(args, &value);
1032 gid = make_kgid(current_user_ns(), value);
1033 if (!gid_valid(gid))
1040 static int cifs_parse_security_flavors(char *value,
1041 struct smb_vol *vol)
1044 substring_t args[MAX_OPT_ARGS];
1047 * With mount options, the last one should win. Reset any existing
1048 * settings back to default.
1050 vol->sectype = Unspecified;
1053 switch (match_token(value, cifs_secflavor_tokens, args)) {
1055 cifs_dbg(VFS, "sec=krb5p is not supported!\n");
1061 vol->sectype = Kerberos;
1063 case Opt_sec_ntlmsspi:
1066 case Opt_sec_ntlmssp:
1067 vol->sectype = RawNTLMSSP;
1073 vol->sectype = NTLM;
1075 case Opt_sec_ntlmv2i:
1078 case Opt_sec_ntlmv2:
1079 vol->sectype = NTLMv2;
1081 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1082 case Opt_sec_lanman:
1083 vol->sectype = LANMAN;
1090 cifs_dbg(VFS, "bad security option: %s\n", value);
1098 cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1100 substring_t args[MAX_OPT_ARGS];
1102 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1103 case Opt_cache_loose:
1104 vol->direct_io = false;
1105 vol->strict_io = false;
1107 case Opt_cache_strict:
1108 vol->direct_io = false;
1109 vol->strict_io = true;
1111 case Opt_cache_none:
1112 vol->direct_io = true;
1113 vol->strict_io = false;
1116 cifs_dbg(VFS, "bad cache= option: %s\n", value);
1123 cifs_parse_smb_version(char *value, struct smb_vol *vol)
1125 substring_t args[MAX_OPT_ARGS];
1127 switch (match_token(value, cifs_smb_version_tokens, args)) {
1129 vol->ops = &smb1_operations;
1130 vol->vals = &smb1_values;
1132 #ifdef CONFIG_CIFS_SMB2
1134 vol->ops = &smb20_operations;
1135 vol->vals = &smb20_values;
1138 vol->ops = &smb21_operations;
1139 vol->vals = &smb21_values;
1142 vol->ops = &smb30_operations;
1143 vol->vals = &smb30_values;
1146 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1147 vol->vals = &smb302_values;
1149 #ifdef CONFIG_CIFS_SMB311
1151 vol->ops = &smb311_operations;
1152 vol->vals = &smb311_values;
1157 cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
1164 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1165 * fields with the result. Returns 0 on success and an error otherwise.
1168 cifs_parse_devname(const char *devname, struct smb_vol *vol)
1171 const char *delims = "/\\";
1174 /* make sure we have a valid UNC double delimiter prefix */
1175 len = strspn(devname, delims);
1179 /* find delimiter between host and sharename */
1180 pos = strpbrk(devname + 2, delims);
1184 /* skip past delimiter */
1187 /* now go until next delimiter or end of string */
1188 len = strcspn(pos, delims);
1190 /* move "pos" up to delimiter or NULL */
1192 vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1196 convert_delimiter(vol->UNC, '\\');
1198 /* If pos is NULL, or is a bogus trailing delimiter then no prepath */
1199 if (!*pos++ || !*pos)
1202 vol->prepath = kstrdup(pos, GFP_KERNEL);
1210 cifs_parse_mount_options(const char *mountdata, const char *devname,
1211 struct smb_vol *vol)
1214 char *mountdata_copy = NULL, *options;
1215 unsigned int temp_len, i, j;
1217 short int override_uid = -1;
1218 short int override_gid = -1;
1219 bool uid_specified = false;
1220 bool gid_specified = false;
1221 bool sloppy = false;
1222 char *invalid = NULL;
1223 char *nodename = utsname()->nodename;
1224 char *string = NULL;
1225 char *tmp_end, *value;
1227 bool got_ip = false;
1228 unsigned short port = 0;
1229 struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1233 delim = separator[0];
1235 /* ensure we always start with zeroed-out smb_vol */
1236 memset(vol, 0, sizeof(*vol));
1239 * does not have to be perfect mapping since field is
1240 * informational, only used for servers that do not support
1241 * port 445 and it can be overridden at mount time
1243 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1244 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1245 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1247 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1248 /* null target name indicates to use *SMBSERVR default called name
1249 if we end up sending RFC1001 session initialize */
1250 vol->target_rfc1001_name[0] = 0;
1251 vol->cred_uid = current_uid();
1252 vol->linux_uid = current_uid();
1253 vol->linux_gid = current_gid();
1256 * default to SFM style remapping of seven reserved characters
1257 * unless user overrides it or we negotiate CIFS POSIX where
1258 * it is unnecessary. Can not simultaneously use more than one mapping
1259 * since then readdir could list files that open could not open
1263 /* default to only allowing write access to owner of the mount */
1264 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1266 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1267 /* default is always to request posix paths. */
1268 vol->posix_paths = 1;
1269 /* default to using server inode numbers where available */
1270 vol->server_ino = 1;
1272 /* default is to use strict cifs caching semantics */
1273 vol->strict_io = true;
1275 vol->actimeo = CIFS_DEF_ACTIMEO;
1277 /* FIXME: add autonegotiation -- for now, SMB1 is default */
1278 vol->ops = &smb1_operations;
1279 vol->vals = &smb1_values;
1282 goto cifs_parse_mount_err;
1284 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1285 if (!mountdata_copy)
1286 goto cifs_parse_mount_err;
1288 options = mountdata_copy;
1289 end = options + strlen(options);
1291 if (strncmp(options, "sep=", 4) == 0) {
1292 if (options[4] != 0) {
1293 separator[0] = options[4];
1296 cifs_dbg(FYI, "Null separator not allowed\n");
1299 vol->backupuid_specified = false; /* no backup intent for a user */
1300 vol->backupgid_specified = false; /* no backup intent for a group */
1302 switch (cifs_parse_devname(devname, vol)) {
1306 cifs_dbg(VFS, "Unable to allocate memory for devname.\n");
1307 goto cifs_parse_mount_err;
1309 cifs_dbg(VFS, "Malformed UNC in devname.\n");
1310 goto cifs_parse_mount_err;
1312 cifs_dbg(VFS, "Unknown error parsing devname.\n");
1313 goto cifs_parse_mount_err;
1316 while ((data = strsep(&options, separator)) != NULL) {
1317 substring_t args[MAX_OPT_ARGS];
1318 unsigned long option;
1324 token = match_token(data, cifs_mount_option_tokens, args);
1328 /* Ingnore the following */
1332 /* Boolean values */
1333 case Opt_user_xattr:
1336 case Opt_nouser_xattr:
1342 case Opt_noforceuid:
1348 case Opt_noforcegid:
1351 case Opt_noblocksend:
1352 vol->noblocksnd = 1;
1354 case Opt_noautotune:
1355 vol->noautotune = 1;
1370 vol->sfu_remap = true;
1371 vol->remap = false; /* disable SFM mapping */
1373 case Opt_nomapchars:
1374 vol->sfu_remap = false;
1378 vol->sfu_remap = false; /* disable SFU mapping */
1380 case Opt_nomapposix:
1392 case Opt_posixpaths:
1393 vol->posix_paths = 1;
1395 case Opt_noposixpaths:
1396 vol->posix_paths = 0;
1399 vol->no_linux_ext = 1;
1410 * turn off mandatory locking in mode
1411 * if remote locking is turned off since the
1412 * local vfs will do advisory
1414 if (vol->file_mode ==
1415 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1416 vol->file_mode = S_IALLUGO;
1418 case Opt_forcemandatorylock:
1428 vol->dynperm = true;
1431 vol->dynperm = false;
1445 case Opt_nostrictsync:
1446 vol->nostrictsync = 1;
1448 case Opt_strictsync:
1449 vol->nostrictsync = 0;
1452 vol->server_ino = 1;
1454 case Opt_noserverino:
1455 vol->server_ino = 0;
1457 case Opt_rwpidforward:
1458 vol->rwpidforward = 1;
1467 vol->no_psx_acl = 0;
1470 vol->no_psx_acl = 1;
1472 case Opt_locallease:
1473 vol->local_lease = 1;
1479 /* we do not do the following in secFlags because seal
1480 * is a per tree connection (mount) not a per socket
1481 * or per-smb connection option in the protocol
1482 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1487 pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1490 #ifndef CONFIG_CIFS_FSCACHE
1491 cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1492 goto cifs_parse_mount_err;
1496 case Opt_mfsymlinks:
1497 vol->mfsymlinks = true;
1500 vol->multiuser = true;
1505 case Opt_nosharesock:
1506 vol->nosharesock = true;
1508 case Opt_nopersistent:
1509 vol->nopersistent = true;
1510 if (vol->persistent) {
1512 "persistenthandles mount options conflict\n");
1513 goto cifs_parse_mount_err;
1516 case Opt_persistent:
1517 vol->persistent = true;
1518 if ((vol->nopersistent) || (vol->resilient)) {
1520 "persistenthandles mount options conflict\n");
1521 goto cifs_parse_mount_err;
1525 vol->resilient = true;
1526 if (vol->persistent) {
1528 "persistenthandles mount options conflict\n");
1529 goto cifs_parse_mount_err;
1532 case Opt_noresilient:
1533 vol->resilient = false; /* already the default */
1536 /* Numeric Values */
1538 if (get_option_uid(args, &vol->backupuid)) {
1539 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
1541 goto cifs_parse_mount_err;
1543 vol->backupuid_specified = true;
1546 if (get_option_gid(args, &vol->backupgid)) {
1547 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
1549 goto cifs_parse_mount_err;
1551 vol->backupgid_specified = true;
1554 if (get_option_uid(args, &vol->linux_uid)) {
1555 cifs_dbg(VFS, "%s: Invalid uid value\n",
1557 goto cifs_parse_mount_err;
1559 uid_specified = true;
1562 if (get_option_uid(args, &vol->cred_uid)) {
1563 cifs_dbg(VFS, "%s: Invalid cruid value\n",
1565 goto cifs_parse_mount_err;
1569 if (get_option_gid(args, &vol->linux_gid)) {
1570 cifs_dbg(VFS, "%s: Invalid gid value\n",
1572 goto cifs_parse_mount_err;
1574 gid_specified = true;
1577 if (get_option_ul(args, &option)) {
1578 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
1580 goto cifs_parse_mount_err;
1582 vol->file_mode = option;
1585 if (get_option_ul(args, &option)) {
1586 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
1588 goto cifs_parse_mount_err;
1590 vol->dir_mode = option;
1593 if (get_option_ul(args, &option) ||
1594 option > USHRT_MAX) {
1595 cifs_dbg(VFS, "%s: Invalid port value\n",
1597 goto cifs_parse_mount_err;
1599 port = (unsigned short)option;
1602 if (get_option_ul(args, &option)) {
1603 cifs_dbg(VFS, "%s: Invalid rsize value\n",
1605 goto cifs_parse_mount_err;
1607 vol->rsize = option;
1610 if (get_option_ul(args, &option)) {
1611 cifs_dbg(VFS, "%s: Invalid wsize value\n",
1613 goto cifs_parse_mount_err;
1615 vol->wsize = option;
1618 if (get_option_ul(args, &option)) {
1619 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
1621 goto cifs_parse_mount_err;
1623 vol->actimeo = HZ * option;
1624 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1625 cifs_dbg(VFS, "attribute cache timeout too large\n");
1626 goto cifs_parse_mount_err;
1630 /* String Arguments */
1632 case Opt_blank_user:
1633 /* null user, ie. anonymous authentication */
1635 vol->username = NULL;
1638 string = match_strdup(args);
1642 if (strnlen(string, CIFS_MAX_USERNAME_LEN) >
1643 CIFS_MAX_USERNAME_LEN) {
1644 pr_warn("CIFS: username too long\n");
1645 goto cifs_parse_mount_err;
1648 kfree(vol->username);
1649 vol->username = kstrdup(string, GFP_KERNEL);
1651 goto cifs_parse_mount_err;
1653 case Opt_blank_pass:
1654 /* passwords have to be handled differently
1655 * to allow the character used for deliminator
1656 * to be passed within them
1660 * Check if this is a case where the password
1661 * starts with a delimiter
1663 tmp_end = strchr(data, '=');
1665 if (!(tmp_end < end && tmp_end[1] == delim)) {
1666 /* No it is not. Set the password to NULL */
1667 kfree(vol->password);
1668 vol->password = NULL;
1671 /* Yes it is. Drop down to Opt_pass below.*/
1673 /* Obtain the value string */
1674 value = strchr(data, '=');
1677 /* Set tmp_end to end of the string */
1678 tmp_end = (char *) value + strlen(value);
1680 /* Check if following character is the deliminator
1681 * If yes, we have encountered a double deliminator
1682 * reset the NULL character to the deliminator
1684 if (tmp_end < end && tmp_end[1] == delim) {
1687 /* Keep iterating until we get to a single
1688 * deliminator OR the end
1690 while ((tmp_end = strchr(tmp_end, delim))
1691 != NULL && (tmp_end[1] == delim)) {
1692 tmp_end = (char *) &tmp_end[2];
1695 /* Reset var options to point to next element */
1698 options = (char *) &tmp_end[1];
1700 /* Reached the end of the mount option
1705 kfree(vol->password);
1706 /* Now build new password string */
1707 temp_len = strlen(value);
1708 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1709 if (vol->password == NULL) {
1710 pr_warn("CIFS: no memory for password\n");
1711 goto cifs_parse_mount_err;
1714 for (i = 0, j = 0; i < temp_len; i++, j++) {
1715 vol->password[j] = value[i];
1716 if ((value[i] == delim) &&
1717 value[i+1] == delim)
1718 /* skip the second deliminator */
1721 vol->password[j] = '\0';
1724 /* FIXME: should this be an error instead? */
1728 string = match_strdup(args);
1732 if (!cifs_convert_address(dstaddr, string,
1734 pr_err("CIFS: bad ip= option (%s).\n", string);
1735 goto cifs_parse_mount_err;
1740 string = match_strdup(args);
1744 if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
1745 == CIFS_MAX_DOMAINNAME_LEN) {
1746 pr_warn("CIFS: domain name too long\n");
1747 goto cifs_parse_mount_err;
1750 kfree(vol->domainname);
1751 vol->domainname = kstrdup(string, GFP_KERNEL);
1752 if (!vol->domainname) {
1753 pr_warn("CIFS: no memory for domainname\n");
1754 goto cifs_parse_mount_err;
1756 cifs_dbg(FYI, "Domain name set\n");
1759 string = match_strdup(args);
1763 if (!cifs_convert_address(
1764 (struct sockaddr *)&vol->srcaddr,
1765 string, strlen(string))) {
1766 pr_warn("CIFS: Could not parse srcaddr: %s\n",
1768 goto cifs_parse_mount_err;
1772 string = match_strdup(args);
1776 if (strnlen(string, 1024) >= 65) {
1777 pr_warn("CIFS: iocharset name too long.\n");
1778 goto cifs_parse_mount_err;
1781 if (strncasecmp(string, "default", 7) != 0) {
1782 kfree(vol->iocharset);
1783 vol->iocharset = kstrdup(string,
1785 if (!vol->iocharset) {
1786 pr_warn("CIFS: no memory for charset\n");
1787 goto cifs_parse_mount_err;
1790 /* if iocharset not set then load_nls_default
1793 cifs_dbg(FYI, "iocharset set to %s\n", string);
1795 case Opt_netbiosname:
1796 string = match_strdup(args);
1800 memset(vol->source_rfc1001_name, 0x20,
1803 * FIXME: are there cases in which a comma can
1804 * be valid in workstation netbios name (and
1805 * need special handling)?
1807 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1808 /* don't ucase netbiosname for user */
1811 vol->source_rfc1001_name[i] = string[i];
1813 /* The string has 16th byte zero still from
1814 * set at top of the function
1816 if (i == RFC1001_NAME_LEN && string[i] != 0)
1817 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
1820 /* servernetbiosname specified override *SMBSERVER */
1821 string = match_strdup(args);
1825 /* last byte, type, is 0x20 for servr type */
1826 memset(vol->target_rfc1001_name, 0x20,
1827 RFC1001_NAME_LEN_WITH_NULL);
1829 /* BB are there cases in which a comma can be
1830 valid in this workstation netbios name
1831 (and need special handling)? */
1833 /* user or mount helper must uppercase the
1835 for (i = 0; i < 15; i++) {
1838 vol->target_rfc1001_name[i] = string[i];
1840 /* The string has 16th byte zero still from
1841 set at top of the function */
1842 if (i == RFC1001_NAME_LEN && string[i] != 0)
1843 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
1846 string = match_strdup(args);
1850 if (strncasecmp(string, "1", 1) == 0) {
1851 /* This is the default */
1854 /* For all other value, error */
1855 pr_warn("CIFS: Invalid version specified\n");
1856 goto cifs_parse_mount_err;
1858 string = match_strdup(args);
1862 if (cifs_parse_smb_version(string, vol) != 0)
1863 goto cifs_parse_mount_err;
1866 string = match_strdup(args);
1870 if (cifs_parse_security_flavors(string, vol) != 0)
1871 goto cifs_parse_mount_err;
1874 string = match_strdup(args);
1878 if (cifs_parse_cache_flavor(string, vol) != 0)
1879 goto cifs_parse_mount_err;
1883 * An option we don't recognize. Save it off for later
1884 * if we haven't already found one
1890 /* Free up any allocated string */
1895 if (!sloppy && invalid) {
1896 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid);
1897 goto cifs_parse_mount_err;
1901 /* Muliuser mounts require CONFIG_KEYS support */
1902 if (vol->multiuser) {
1903 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
1904 goto cifs_parse_mount_err;
1908 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
1909 goto cifs_parse_mount_err;
1912 /* make sure UNC has a share name */
1913 if (!strchr(vol->UNC + 3, '\\')) {
1914 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
1915 goto cifs_parse_mount_err;
1919 /* No ip= option specified? Try to get it from UNC */
1920 if (!cifs_convert_address(dstaddr, &vol->UNC[2],
1921 strlen(&vol->UNC[2]))) {
1922 pr_err("Unable to determine destination address.\n");
1923 goto cifs_parse_mount_err;
1927 /* set the port that we got earlier */
1928 cifs_set_port(dstaddr, port);
1931 vol->override_uid = override_uid;
1932 else if (override_uid == 1)
1933 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
1936 vol->override_gid = override_gid;
1937 else if (override_gid == 1)
1938 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
1940 kfree(mountdata_copy);
1944 pr_warn("Could not allocate temporary buffer\n");
1945 cifs_parse_mount_err:
1947 kfree(mountdata_copy);
1951 /** Returns true if srcaddr isn't specified and rhs isn't
1952 * specified, or if srcaddr is specified and
1953 * matches the IP address of the rhs argument.
1956 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1958 switch (srcaddr->sa_family) {
1960 return (rhs->sa_family == AF_UNSPEC);
1962 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1963 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1964 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1967 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1968 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
1969 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1973 return false; /* don't expect to be here */
1978 * If no port is specified in addr structure, we try to match with 445 port
1979 * and if it fails - with 139 ports. It should be called only if address
1980 * families of server and addr are equal.
1983 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1985 __be16 port, *sport;
1987 switch (addr->sa_family) {
1989 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1990 port = ((struct sockaddr_in *) addr)->sin_port;
1993 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1994 port = ((struct sockaddr_in6 *) addr)->sin6_port;
2002 port = htons(CIFS_PORT);
2006 port = htons(RFC1001_PORT);
2009 return port == *sport;
2013 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
2014 struct sockaddr *srcaddr)
2016 switch (addr->sa_family) {
2018 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2019 struct sockaddr_in *srv_addr4 =
2020 (struct sockaddr_in *)&server->dstaddr;
2022 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
2027 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2028 struct sockaddr_in6 *srv_addr6 =
2029 (struct sockaddr_in6 *)&server->dstaddr;
2031 if (!ipv6_addr_equal(&addr6->sin6_addr,
2032 &srv_addr6->sin6_addr))
2034 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
2040 return false; /* don't expect to be here */
2043 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2050 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2053 * The select_sectype function should either return the vol->sectype
2054 * that was specified, or "Unspecified" if that sectype was not
2055 * compatible with the given NEGOTIATE request.
2057 if (select_sectype(server, vol->sectype) == Unspecified)
2061 * Now check if signing mode is acceptable. No need to check
2062 * global_secflags at this point since if MUST_SIGN is set then
2063 * the server->sign had better be too.
2065 if (vol->sign && !server->sign)
2071 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2073 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2075 if (vol->nosharesock)
2078 if ((server->vals != vol->vals) || (server->ops != vol->ops))
2081 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2084 if (!match_address(server, addr,
2085 (struct sockaddr *)&vol->srcaddr))
2088 if (!match_port(server, addr))
2091 if (!match_security(server, vol))
2097 static struct TCP_Server_Info *
2098 cifs_find_tcp_session(struct smb_vol *vol)
2100 struct TCP_Server_Info *server;
2102 spin_lock(&cifs_tcp_ses_lock);
2103 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2104 if (!match_server(server, vol))
2107 ++server->srv_count;
2108 spin_unlock(&cifs_tcp_ses_lock);
2109 cifs_dbg(FYI, "Existing tcp session with server found\n");
2112 spin_unlock(&cifs_tcp_ses_lock);
2117 cifs_put_tcp_session(struct TCP_Server_Info *server)
2119 struct task_struct *task;
2121 spin_lock(&cifs_tcp_ses_lock);
2122 if (--server->srv_count > 0) {
2123 spin_unlock(&cifs_tcp_ses_lock);
2127 put_net(cifs_net_ns(server));
2129 list_del_init(&server->tcp_ses_list);
2130 spin_unlock(&cifs_tcp_ses_lock);
2132 cancel_delayed_work_sync(&server->echo);
2134 spin_lock(&GlobalMid_Lock);
2135 server->tcpStatus = CifsExiting;
2136 spin_unlock(&GlobalMid_Lock);
2138 cifs_crypto_shash_release(server);
2139 cifs_fscache_release_client_cookie(server);
2141 kfree(server->session_key.response);
2142 server->session_key.response = NULL;
2143 server->session_key.len = 0;
2145 task = xchg(&server->tsk, NULL);
2147 force_sig(SIGKILL, task);
2150 static struct TCP_Server_Info *
2151 cifs_get_tcp_session(struct smb_vol *volume_info)
2153 struct TCP_Server_Info *tcp_ses = NULL;
2156 cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
2158 /* see if we already have a matching tcp_ses */
2159 tcp_ses = cifs_find_tcp_session(volume_info);
2163 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2169 tcp_ses->ops = volume_info->ops;
2170 tcp_ses->vals = volume_info->vals;
2171 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2172 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2173 if (IS_ERR(tcp_ses->hostname)) {
2174 rc = PTR_ERR(tcp_ses->hostname);
2175 goto out_err_crypto_release;
2178 tcp_ses->noblocksnd = volume_info->noblocksnd;
2179 tcp_ses->noautotune = volume_info->noautotune;
2180 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2181 tcp_ses->in_flight = 0;
2182 tcp_ses->credits = 1;
2183 init_waitqueue_head(&tcp_ses->response_q);
2184 init_waitqueue_head(&tcp_ses->request_q);
2185 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2186 mutex_init(&tcp_ses->srv_mutex);
2187 memcpy(tcp_ses->workstation_RFC1001_name,
2188 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2189 memcpy(tcp_ses->server_RFC1001_name,
2190 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2191 tcp_ses->session_estab = false;
2192 tcp_ses->sequence_number = 0;
2193 tcp_ses->lstrp = jiffies;
2194 spin_lock_init(&tcp_ses->req_lock);
2195 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2196 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2197 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2198 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2199 sizeof(tcp_ses->srcaddr));
2200 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2201 sizeof(tcp_ses->dstaddr));
2202 #ifdef CONFIG_CIFS_SMB2
2203 get_random_bytes(tcp_ses->client_guid, SMB2_CLIENT_GUID_SIZE);
2206 * at this point we are the only ones with the pointer
2207 * to the struct since the kernel thread not created yet
2208 * no need to spinlock this init of tcpStatus or srv_count
2210 tcp_ses->tcpStatus = CifsNew;
2211 ++tcp_ses->srv_count;
2213 rc = ip_connect(tcp_ses);
2215 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
2216 goto out_err_crypto_release;
2220 * since we're in a cifs function already, we know that
2221 * this will succeed. No need for try_module_get().
2223 __module_get(THIS_MODULE);
2224 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2226 if (IS_ERR(tcp_ses->tsk)) {
2227 rc = PTR_ERR(tcp_ses->tsk);
2228 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
2229 module_put(THIS_MODULE);
2230 goto out_err_crypto_release;
2232 tcp_ses->tcpStatus = CifsNeedNegotiate;
2234 /* thread spawned, put it on the list */
2235 spin_lock(&cifs_tcp_ses_lock);
2236 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2237 spin_unlock(&cifs_tcp_ses_lock);
2239 cifs_fscache_get_client_cookie(tcp_ses);
2241 /* queue echo request delayed work */
2242 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
2246 out_err_crypto_release:
2247 cifs_crypto_shash_release(tcp_ses);
2249 put_net(cifs_net_ns(tcp_ses));
2253 if (!IS_ERR(tcp_ses->hostname))
2254 kfree(tcp_ses->hostname);
2255 if (tcp_ses->ssocket)
2256 sock_release(tcp_ses->ssocket);
2262 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2264 if (vol->sectype != Unspecified &&
2265 vol->sectype != ses->sectype)
2268 switch (ses->sectype) {
2270 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2274 /* NULL username means anonymous session */
2275 if (ses->user_name == NULL) {
2281 /* anything else takes username/password */
2282 if (strncmp(ses->user_name,
2283 vol->username ? vol->username : "",
2284 CIFS_MAX_USERNAME_LEN))
2286 if ((vol->username && strlen(vol->username) != 0) &&
2287 ses->password != NULL &&
2288 strncmp(ses->password,
2289 vol->password ? vol->password : "",
2290 CIFS_MAX_PASSWORD_LEN))
2296 static struct cifs_ses *
2297 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2299 struct cifs_ses *ses;
2301 spin_lock(&cifs_tcp_ses_lock);
2302 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2303 if (ses->status == CifsExiting)
2305 if (!match_session(ses, vol))
2308 spin_unlock(&cifs_tcp_ses_lock);
2311 spin_unlock(&cifs_tcp_ses_lock);
2316 cifs_put_smb_ses(struct cifs_ses *ses)
2318 unsigned int rc, xid;
2319 struct TCP_Server_Info *server = ses->server;
2321 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
2323 spin_lock(&cifs_tcp_ses_lock);
2324 if (ses->status == CifsExiting) {
2325 spin_unlock(&cifs_tcp_ses_lock);
2328 if (--ses->ses_count > 0) {
2329 spin_unlock(&cifs_tcp_ses_lock);
2332 if (ses->status == CifsGood)
2333 ses->status = CifsExiting;
2334 spin_unlock(&cifs_tcp_ses_lock);
2336 if (ses->status == CifsExiting && server->ops->logoff) {
2338 rc = server->ops->logoff(xid, ses);
2340 cifs_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
2345 spin_lock(&cifs_tcp_ses_lock);
2346 list_del_init(&ses->smb_ses_list);
2347 spin_unlock(&cifs_tcp_ses_lock);
2350 cifs_put_tcp_session(server);
2355 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2356 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2358 /* Populate username and pw fields from keyring if possible */
2360 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2363 const char *delim, *payload;
2367 struct TCP_Server_Info *server = ses->server;
2368 struct sockaddr_in *sa;
2369 struct sockaddr_in6 *sa6;
2370 const struct user_key_payload *upayload;
2372 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2376 /* try to find an address key first */
2377 switch (server->dstaddr.ss_family) {
2379 sa = (struct sockaddr_in *)&server->dstaddr;
2380 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2383 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2384 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2387 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2388 server->dstaddr.ss_family);
2393 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2394 key = request_key(&key_type_logon, desc, "");
2396 if (!ses->domainName) {
2397 cifs_dbg(FYI, "domainName is NULL\n");
2402 /* didn't work, try to find a domain key */
2403 sprintf(desc, "cifs:d:%s", ses->domainName);
2404 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2405 key = request_key(&key_type_logon, desc, "");
2412 down_read(&key->sem);
2413 upayload = user_key_payload(key);
2414 if (IS_ERR_OR_NULL(upayload)) {
2415 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2419 /* find first : in payload */
2420 payload = upayload->data;
2421 delim = strnchr(payload, upayload->datalen, ':');
2422 cifs_dbg(FYI, "payload=%s\n", payload);
2424 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
2430 len = delim - payload;
2431 if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
2432 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
2438 vol->username = kstrndup(payload, len, GFP_KERNEL);
2439 if (!vol->username) {
2440 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
2445 cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
2447 len = key->datalen - (len + 1);
2448 if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
2449 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
2451 kfree(vol->username);
2452 vol->username = NULL;
2457 vol->password = kstrndup(delim, len, GFP_KERNEL);
2458 if (!vol->password) {
2459 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
2462 kfree(vol->username);
2463 vol->username = NULL;
2472 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
2475 #else /* ! CONFIG_KEYS */
2477 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2478 struct cifs_ses *ses __attribute__((unused)))
2482 #endif /* CONFIG_KEYS */
2484 static struct cifs_ses *
2485 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2489 struct cifs_ses *ses;
2490 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2491 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2495 ses = cifs_find_smb_ses(server, volume_info);
2497 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
2500 mutex_lock(&ses->session_mutex);
2501 rc = cifs_negotiate_protocol(xid, ses);
2503 mutex_unlock(&ses->session_mutex);
2504 /* problem -- put our ses reference */
2505 cifs_put_smb_ses(ses);
2509 if (ses->need_reconnect) {
2510 cifs_dbg(FYI, "Session needs reconnect\n");
2511 rc = cifs_setup_session(xid, ses,
2512 volume_info->local_nls);
2514 mutex_unlock(&ses->session_mutex);
2515 /* problem -- put our reference */
2516 cifs_put_smb_ses(ses);
2521 mutex_unlock(&ses->session_mutex);
2523 /* existing SMB ses has a server reference already */
2524 cifs_put_tcp_session(server);
2529 cifs_dbg(FYI, "Existing smb sess not found\n");
2530 ses = sesInfoAlloc();
2534 /* new SMB session uses our server ref */
2535 ses->server = server;
2536 if (server->dstaddr.ss_family == AF_INET6)
2537 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2539 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2541 if (volume_info->username) {
2542 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2543 if (!ses->user_name)
2547 /* volume_info->password freed at unmount */
2548 if (volume_info->password) {
2549 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2553 if (volume_info->domainname) {
2554 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2555 if (!ses->domainName)
2558 ses->cred_uid = volume_info->cred_uid;
2559 ses->linux_uid = volume_info->linux_uid;
2561 ses->sectype = volume_info->sectype;
2562 ses->sign = volume_info->sign;
2564 mutex_lock(&ses->session_mutex);
2565 rc = cifs_negotiate_protocol(xid, ses);
2567 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2568 mutex_unlock(&ses->session_mutex);
2572 /* success, put it on the list */
2573 spin_lock(&cifs_tcp_ses_lock);
2574 list_add(&ses->smb_ses_list, &server->smb_ses_list);
2575 spin_unlock(&cifs_tcp_ses_lock);
2586 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2588 if (tcon->tidStatus == CifsExiting)
2590 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2595 static struct cifs_tcon *
2596 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2598 struct list_head *tmp;
2599 struct cifs_tcon *tcon;
2601 spin_lock(&cifs_tcp_ses_lock);
2602 list_for_each(tmp, &ses->tcon_list) {
2603 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2604 if (!match_tcon(tcon, unc))
2607 spin_unlock(&cifs_tcp_ses_lock);
2610 spin_unlock(&cifs_tcp_ses_lock);
2615 cifs_put_tcon(struct cifs_tcon *tcon)
2618 struct cifs_ses *ses = tcon->ses;
2620 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2621 spin_lock(&cifs_tcp_ses_lock);
2622 if (--tcon->tc_count > 0) {
2623 spin_unlock(&cifs_tcp_ses_lock);
2627 list_del_init(&tcon->tcon_list);
2628 spin_unlock(&cifs_tcp_ses_lock);
2631 if (ses->server->ops->tree_disconnect)
2632 ses->server->ops->tree_disconnect(xid, tcon);
2635 cifs_fscache_release_super_cookie(tcon);
2637 cifs_put_smb_ses(ses);
2640 static struct cifs_tcon *
2641 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2644 struct cifs_tcon *tcon;
2646 tcon = cifs_find_tcon(ses, volume_info->UNC);
2648 cifs_dbg(FYI, "Found match on UNC path\n");
2649 /* existing tcon already has a reference */
2650 cifs_put_smb_ses(ses);
2651 if (tcon->seal != volume_info->seal)
2652 cifs_dbg(VFS, "transport encryption setting conflicts with existing tid\n");
2656 if (!ses->server->ops->tree_connect) {
2661 tcon = tconInfoAlloc();
2668 if (volume_info->password) {
2669 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2670 if (!tcon->password) {
2677 * BB Do we need to wrap session_mutex around this TCon call and Unix
2678 * SetFS as we do on SessSetup and reconnect?
2681 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2682 volume_info->local_nls);
2684 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
2688 if (volume_info->nodfs) {
2689 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2690 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
2692 tcon->seal = volume_info->seal;
2693 tcon->use_persistent = false;
2694 /* check if SMB2 or later, CIFS does not support persistent handles */
2695 if (volume_info->persistent) {
2696 if (ses->server->vals->protocol_id == 0) {
2698 "SMB3 or later required for persistent handles\n");
2701 #ifdef CONFIG_CIFS_SMB2
2702 } else if (ses->server->capabilities &
2703 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2704 tcon->use_persistent = true;
2705 else /* persistent handles requested but not supported */ {
2707 "Persistent handles not supported on share\n");
2710 #endif /* CONFIG_CIFS_SMB2 */
2712 #ifdef CONFIG_CIFS_SMB2
2713 } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
2714 && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2715 && (volume_info->nopersistent == false)) {
2716 cifs_dbg(FYI, "enabling persistent handles\n");
2717 tcon->use_persistent = true;
2718 #endif /* CONFIG_CIFS_SMB2 */
2719 } else if (volume_info->resilient) {
2720 if (ses->server->vals->protocol_id == 0) {
2722 "SMB2.1 or later required for resilient handles\n");
2726 tcon->use_resilient = true;
2730 * We can have only one retry value for a connection to a share so for
2731 * resources mounted more than once to the same server share the last
2732 * value passed in for the retry flag is used.
2734 tcon->retry = volume_info->retry;
2735 tcon->nocase = volume_info->nocase;
2736 tcon->local_lease = volume_info->local_lease;
2737 INIT_LIST_HEAD(&tcon->pending_opens);
2739 spin_lock(&cifs_tcp_ses_lock);
2740 list_add(&tcon->tcon_list, &ses->tcon_list);
2741 spin_unlock(&cifs_tcp_ses_lock);
2743 cifs_fscache_get_super_cookie(tcon);
2753 cifs_put_tlink(struct tcon_link *tlink)
2755 if (!tlink || IS_ERR(tlink))
2758 if (!atomic_dec_and_test(&tlink->tl_count) ||
2759 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2760 tlink->tl_time = jiffies;
2764 if (!IS_ERR(tlink_tcon(tlink)))
2765 cifs_put_tcon(tlink_tcon(tlink));
2770 static inline struct tcon_link *
2771 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2773 return cifs_sb->master_tlink;
2777 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2779 struct cifs_sb_info *old = CIFS_SB(sb);
2780 struct cifs_sb_info *new = mnt_data->cifs_sb;
2782 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2785 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2786 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2790 * We want to share sb only if we don't specify an r/wsize or
2791 * specified r/wsize is greater than or equal to existing one.
2793 if (new->wsize && new->wsize < old->wsize)
2796 if (new->rsize && new->rsize < old->rsize)
2799 if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
2802 if (old->mnt_file_mode != new->mnt_file_mode ||
2803 old->mnt_dir_mode != new->mnt_dir_mode)
2806 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2809 if (old->actimeo != new->actimeo)
2816 cifs_match_super(struct super_block *sb, void *data)
2818 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2819 struct smb_vol *volume_info;
2820 struct cifs_sb_info *cifs_sb;
2821 struct TCP_Server_Info *tcp_srv;
2822 struct cifs_ses *ses;
2823 struct cifs_tcon *tcon;
2824 struct tcon_link *tlink;
2827 spin_lock(&cifs_tcp_ses_lock);
2828 cifs_sb = CIFS_SB(sb);
2829 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2830 if (IS_ERR(tlink)) {
2831 spin_unlock(&cifs_tcp_ses_lock);
2834 tcon = tlink_tcon(tlink);
2836 tcp_srv = ses->server;
2838 volume_info = mnt_data->vol;
2840 if (!match_server(tcp_srv, volume_info) ||
2841 !match_session(ses, volume_info) ||
2842 !match_tcon(tcon, volume_info->UNC)) {
2847 rc = compare_mount_options(sb, mnt_data);
2849 spin_unlock(&cifs_tcp_ses_lock);
2850 cifs_put_tlink(tlink);
2855 get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
2856 const struct nls_table *nls_codepage, unsigned int *num_referrals,
2857 struct dfs_info3_param **referrals, int remap)
2862 if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
2868 if (ses->ipc_tid == 0) {
2869 temp_unc = kmalloc(2 /* for slashes */ +
2870 strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2871 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
2872 if (temp_unc == NULL)
2876 strcpy(temp_unc + 2, ses->serverName);
2877 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2878 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2880 cifs_dbg(FYI, "Tcon rc = %d ipc_tid = %d\n", rc, ses->ipc_tid);
2884 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
2885 referrals, num_referrals,
2886 nls_codepage, remap);
2888 * BB - map targetUNCs to dfs_info3 structures, here or in
2889 * ses->server->ops->get_dfs_refer.
2895 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2896 static struct lock_class_key cifs_key[2];
2897 static struct lock_class_key cifs_slock_key[2];
2900 cifs_reclassify_socket4(struct socket *sock)
2902 struct sock *sk = sock->sk;
2903 BUG_ON(sock_owned_by_user(sk));
2904 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2905 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2909 cifs_reclassify_socket6(struct socket *sock)
2911 struct sock *sk = sock->sk;
2912 BUG_ON(sock_owned_by_user(sk));
2913 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2914 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2918 cifs_reclassify_socket4(struct socket *sock)
2923 cifs_reclassify_socket6(struct socket *sock)
2928 /* See RFC1001 section 14 on representation of Netbios names */
2929 static void rfc1002mangle(char *target, char *source, unsigned int length)
2933 for (i = 0, j = 0; i < (length); i++) {
2934 /* mask a nibble at a time and encode */
2935 target[j] = 'A' + (0x0F & (source[i] >> 4));
2936 target[j+1] = 'A' + (0x0F & source[i]);
2943 bind_socket(struct TCP_Server_Info *server)
2946 if (server->srcaddr.ss_family != AF_UNSPEC) {
2947 /* Bind to the specified local IP address */
2948 struct socket *socket = server->ssocket;
2949 rc = socket->ops->bind(socket,
2950 (struct sockaddr *) &server->srcaddr,
2951 sizeof(server->srcaddr));
2953 struct sockaddr_in *saddr4;
2954 struct sockaddr_in6 *saddr6;
2955 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2956 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2957 if (saddr6->sin6_family == AF_INET6)
2958 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
2959 &saddr6->sin6_addr, rc);
2961 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
2962 &saddr4->sin_addr.s_addr, rc);
2969 ip_rfc1001_connect(struct TCP_Server_Info *server)
2973 * some servers require RFC1001 sessinit before sending
2974 * negprot - BB check reconnection in case where second
2975 * sessinit is sent but no second negprot
2977 struct rfc1002_session_packet *ses_init_buf;
2978 struct smb_hdr *smb_buf;
2979 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2982 ses_init_buf->trailer.session_req.called_len = 32;
2984 if (server->server_RFC1001_name &&
2985 server->server_RFC1001_name[0] != 0)
2986 rfc1002mangle(ses_init_buf->trailer.
2987 session_req.called_name,
2988 server->server_RFC1001_name,
2989 RFC1001_NAME_LEN_WITH_NULL);
2991 rfc1002mangle(ses_init_buf->trailer.
2992 session_req.called_name,
2993 DEFAULT_CIFS_CALLED_NAME,
2994 RFC1001_NAME_LEN_WITH_NULL);
2996 ses_init_buf->trailer.session_req.calling_len = 32;
2999 * calling name ends in null (byte 16) from old smb
3002 if (server->workstation_RFC1001_name[0] != 0)
3003 rfc1002mangle(ses_init_buf->trailer.
3004 session_req.calling_name,
3005 server->workstation_RFC1001_name,
3006 RFC1001_NAME_LEN_WITH_NULL);
3008 rfc1002mangle(ses_init_buf->trailer.
3009 session_req.calling_name,
3011 RFC1001_NAME_LEN_WITH_NULL);
3013 ses_init_buf->trailer.session_req.scope1 = 0;
3014 ses_init_buf->trailer.session_req.scope2 = 0;
3015 smb_buf = (struct smb_hdr *)ses_init_buf;
3017 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3018 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3019 rc = smb_send(server, smb_buf, 0x44);
3020 kfree(ses_init_buf);
3022 * RFC1001 layer in at least one server
3023 * requires very short break before negprot
3024 * presumably because not expecting negprot
3025 * to follow so fast. This is a simple
3026 * solution that works without
3027 * complicating the code and causes no
3028 * significant slowing down on mount
3031 usleep_range(1000, 2000);
3034 * else the negprot may still work without this
3035 * even though malloc failed
3042 generic_ip_connect(struct TCP_Server_Info *server)
3047 struct socket *socket = server->ssocket;
3048 struct sockaddr *saddr;
3050 saddr = (struct sockaddr *) &server->dstaddr;
3052 if (server->dstaddr.ss_family == AF_INET6) {
3053 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3054 slen = sizeof(struct sockaddr_in6);
3057 sport = ((struct sockaddr_in *) saddr)->sin_port;
3058 slen = sizeof(struct sockaddr_in);
3062 if (socket == NULL) {
3063 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3064 IPPROTO_TCP, &socket, 1);
3066 cifs_dbg(VFS, "Error %d creating socket\n", rc);
3067 server->ssocket = NULL;
3071 /* BB other socket options to set KEEPALIVE, NODELAY? */
3072 cifs_dbg(FYI, "Socket created\n");
3073 server->ssocket = socket;
3074 socket->sk->sk_allocation = GFP_NOFS;
3075 if (sfamily == AF_INET6)
3076 cifs_reclassify_socket6(socket);
3078 cifs_reclassify_socket4(socket);
3081 rc = bind_socket(server);
3086 * Eventually check for other socket options to change from
3087 * the default. sock_setsockopt not used because it expects
3090 socket->sk->sk_rcvtimeo = 7 * HZ;
3091 socket->sk->sk_sndtimeo = 5 * HZ;
3093 /* make the bufsizes depend on wsize/rsize and max requests */
3094 if (server->noautotune) {
3095 if (socket->sk->sk_sndbuf < (200 * 1024))
3096 socket->sk->sk_sndbuf = 200 * 1024;
3097 if (socket->sk->sk_rcvbuf < (140 * 1024))
3098 socket->sk->sk_rcvbuf = 140 * 1024;
3101 if (server->tcp_nodelay) {
3103 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3104 (char *)&val, sizeof(val));
3106 cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3110 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3111 socket->sk->sk_sndbuf,
3112 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3114 rc = socket->ops->connect(socket, saddr, slen, 0);
3116 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3117 sock_release(socket);
3118 server->ssocket = NULL;
3122 if (sport == htons(RFC1001_PORT))
3123 rc = ip_rfc1001_connect(server);
3129 ip_connect(struct TCP_Server_Info *server)
3132 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3133 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3135 if (server->dstaddr.ss_family == AF_INET6)
3136 sport = &addr6->sin6_port;
3138 sport = &addr->sin_port;
3143 /* try with 445 port at first */
3144 *sport = htons(CIFS_PORT);
3146 rc = generic_ip_connect(server);
3150 /* if it failed, try with 139 port */
3151 *sport = htons(RFC1001_PORT);
3154 return generic_ip_connect(server);
3157 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3158 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3160 /* if we are reconnecting then should we check to see if
3161 * any requested capabilities changed locally e.g. via
3162 * remount but we can not do much about it here
3163 * if they have (even if we could detect it by the following)
3164 * Perhaps we could add a backpointer to array of sb from tcon
3165 * or if we change to make all sb to same share the same
3166 * sb as NFS - then we only have one backpointer to sb.
3167 * What if we wanted to mount the server share twice once with
3168 * and once without posixacls or posix paths? */
3169 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3171 if (vol_info && vol_info->no_linux_ext) {
3172 tcon->fsUnixInfo.Capability = 0;
3173 tcon->unix_ext = 0; /* Unix Extensions disabled */
3174 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
3176 } else if (vol_info)
3177 tcon->unix_ext = 1; /* Unix Extensions supported */
3179 if (tcon->unix_ext == 0) {
3180 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
3184 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3185 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3186 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
3187 /* check for reconnect case in which we do not
3188 want to change the mount behavior if we can avoid it */
3189 if (vol_info == NULL) {
3190 /* turn off POSIX ACL and PATHNAMES if not set
3191 originally at mount time */
3192 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3193 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3194 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3195 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3196 cifs_dbg(VFS, "POSIXPATH support change\n");
3197 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3198 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3199 cifs_dbg(VFS, "possible reconnect error\n");
3200 cifs_dbg(VFS, "server disabled POSIX path support\n");
3204 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3205 cifs_dbg(VFS, "per-share encryption not supported yet\n");
3207 cap &= CIFS_UNIX_CAP_MASK;
3208 if (vol_info && vol_info->no_psx_acl)
3209 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3210 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3211 cifs_dbg(FYI, "negotiated posix acl support\n");
3213 cifs_sb->mnt_cifs_flags |=
3214 CIFS_MOUNT_POSIXACL;
3217 if (vol_info && vol_info->posix_paths == 0)
3218 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3219 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3220 cifs_dbg(FYI, "negotiate posix pathnames\n");
3222 cifs_sb->mnt_cifs_flags |=
3223 CIFS_MOUNT_POSIX_PATHS;
3226 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
3227 #ifdef CONFIG_CIFS_DEBUG2
3228 if (cap & CIFS_UNIX_FCNTL_CAP)
3229 cifs_dbg(FYI, "FCNTL cap\n");
3230 if (cap & CIFS_UNIX_EXTATTR_CAP)
3231 cifs_dbg(FYI, "EXTATTR cap\n");
3232 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3233 cifs_dbg(FYI, "POSIX path cap\n");
3234 if (cap & CIFS_UNIX_XATTR_CAP)
3235 cifs_dbg(FYI, "XATTR cap\n");
3236 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3237 cifs_dbg(FYI, "POSIX ACL cap\n");
3238 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3239 cifs_dbg(FYI, "very large read cap\n");
3240 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3241 cifs_dbg(FYI, "very large write cap\n");
3242 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3243 cifs_dbg(FYI, "transport encryption cap\n");
3244 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3245 cifs_dbg(FYI, "mandatory transport encryption cap\n");
3246 #endif /* CIFS_DEBUG2 */
3247 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3248 if (vol_info == NULL) {
3249 cifs_dbg(FYI, "resetting capabilities failed\n");
3251 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");
3257 void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3258 struct cifs_sb_info *cifs_sb)
3260 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3262 spin_lock_init(&cifs_sb->tlink_tree_lock);
3263 cifs_sb->tlink_tree = RB_ROOT;
3266 * Temporarily set r/wsize for matching superblock. If we end up using
3267 * new sb then client will later negotiate it downward if needed.
3269 cifs_sb->rsize = pvolume_info->rsize;
3270 cifs_sb->wsize = pvolume_info->wsize;
3272 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3273 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3274 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3275 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3276 cifs_dbg(FYI, "file mode: 0x%hx dir mode: 0x%hx\n",
3277 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3279 cifs_sb->actimeo = pvolume_info->actimeo;
3280 cifs_sb->local_nls = pvolume_info->local_nls;
3282 if (pvolume_info->noperm)
3283 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3284 if (pvolume_info->setuids)
3285 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3286 if (pvolume_info->server_ino)
3287 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3288 if (pvolume_info->remap)
3289 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3290 if (pvolume_info->sfu_remap)
3291 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3292 if (pvolume_info->no_xattr)
3293 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3294 if (pvolume_info->sfu_emul)
3295 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3296 if (pvolume_info->nobrl)
3297 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3298 if (pvolume_info->nostrictsync)
3299 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3300 if (pvolume_info->mand_lock)
3301 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3302 if (pvolume_info->rwpidforward)
3303 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3304 if (pvolume_info->cifs_acl)
3305 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3306 if (pvolume_info->backupuid_specified) {
3307 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3308 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3310 if (pvolume_info->backupgid_specified) {
3311 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3312 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3314 if (pvolume_info->override_uid)
3315 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3316 if (pvolume_info->override_gid)
3317 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3318 if (pvolume_info->dynperm)
3319 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3320 if (pvolume_info->fsc)
3321 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3322 if (pvolume_info->multiuser)
3323 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3324 CIFS_MOUNT_NO_PERM);
3325 if (pvolume_info->strict_io)
3326 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3327 if (pvolume_info->direct_io) {
3328 cifs_dbg(FYI, "mounting share using direct i/o\n");
3329 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3331 if (pvolume_info->mfsymlinks) {
3332 if (pvolume_info->sfu_emul) {
3334 * Our SFU ("Services for Unix" emulation does not allow
3335 * creating symlinks but does allow reading existing SFU
3336 * symlinks (it does allow both creating and reading SFU
3337 * style mknod and FIFOs though). When "mfsymlinks" and
3338 * "sfu" are both enabled at the same time, it allows
3339 * reading both types of symlinks, but will only create
3340 * them with mfsymlinks format. This allows better
3341 * Apple compatibility (probably better for Samba too)
3342 * while still recognizing old Windows style symlinks.
3344 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
3346 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3349 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3350 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
3354 cleanup_volume_info_contents(struct smb_vol *volume_info)
3356 kfree(volume_info->username);
3357 kzfree(volume_info->password);
3358 kfree(volume_info->UNC);
3359 kfree(volume_info->domainname);
3360 kfree(volume_info->iocharset);
3361 kfree(volume_info->prepath);
3365 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3369 cleanup_volume_info_contents(volume_info);
3374 #ifdef CONFIG_CIFS_DFS_UPCALL
3376 * cifs_build_path_to_root returns full path to root when we do not have an
3377 * exiting connection (tcon)
3380 build_unc_path_to_root(const struct smb_vol *vol,
3381 const struct cifs_sb_info *cifs_sb)
3383 char *full_path, *pos;
3384 unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
3385 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3387 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3388 if (full_path == NULL)
3389 return ERR_PTR(-ENOMEM);
3391 strncpy(full_path, vol->UNC, unc_len);
3392 pos = full_path + unc_len;
3395 *pos = CIFS_DIR_SEP(cifs_sb);
3396 strncpy(pos + 1, vol->prepath, pplen);
3400 *pos = '\0'; /* add trailing null */
3401 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3402 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
3407 * Perform a dfs referral query for a share and (optionally) prefix
3409 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3410 * to a string containing updated options for the submount. Otherwise it
3411 * will be left untouched.
3413 * Returns the rc from get_dfs_path to the caller, which can be used to
3414 * determine whether there were referrals.
3417 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
3418 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3422 unsigned int num_referrals = 0;
3423 struct dfs_info3_param *referrals = NULL;
3424 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3426 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3427 if (IS_ERR(full_path))
3428 return PTR_ERR(full_path);
3430 /* For DFS paths, skip the first '\' of the UNC */
3431 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3433 rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
3434 &num_referrals, &referrals, cifs_remap(cifs_sb));
3436 if (!rc && num_referrals > 0) {
3437 char *fake_devname = NULL;
3439 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3440 full_path + 1, referrals,
3443 free_dfs_info_array(referrals, num_referrals);
3445 if (IS_ERR(mdata)) {
3446 rc = PTR_ERR(mdata);
3449 cleanup_volume_info_contents(volume_info);
3450 rc = cifs_setup_volume_info(volume_info, mdata,
3453 kfree(fake_devname);
3454 kfree(cifs_sb->mountdata);
3455 cifs_sb->mountdata = mdata;
3463 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3464 const char *devname)
3468 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3471 if (volume_info->nullauth) {
3472 cifs_dbg(FYI, "Anonymous login\n");
3473 kfree(volume_info->username);
3474 volume_info->username = NULL;
3475 } else if (volume_info->username) {
3476 /* BB fixme parse for domain name here */
3477 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
3479 cifs_dbg(VFS, "No username specified\n");
3480 /* In userspace mount helper we can get user name from alternate
3481 locations such as env variables and files on disk */
3485 /* this is needed for ASCII cp to Unicode converts */
3486 if (volume_info->iocharset == NULL) {
3487 /* load_nls_default cannot return null */
3488 volume_info->local_nls = load_nls_default();
3490 volume_info->local_nls = load_nls(volume_info->iocharset);
3491 if (volume_info->local_nls == NULL) {
3492 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
3493 volume_info->iocharset);
3502 cifs_get_volume_info(char *mount_data, const char *devname)
3505 struct smb_vol *volume_info;
3507 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
3509 return ERR_PTR(-ENOMEM);
3511 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3513 cifs_cleanup_volume_info(volume_info);
3514 volume_info = ERR_PTR(rc);
3521 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3525 struct cifs_ses *ses;
3526 struct cifs_tcon *tcon;
3527 struct TCP_Server_Info *server;
3529 struct tcon_link *tlink;
3530 #ifdef CONFIG_CIFS_DFS_UPCALL
3531 int referral_walks_count = 0;
3534 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs");
3538 #ifdef CONFIG_CIFS_DFS_UPCALL
3540 /* cleanup activities if we're chasing a referral */
3541 if (referral_walks_count) {
3543 cifs_put_tcon(tcon);
3545 cifs_put_smb_ses(ses);
3547 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
3561 /* get a reference to a tcp session */
3562 server = cifs_get_tcp_session(volume_info);
3563 if (IS_ERR(server)) {
3564 rc = PTR_ERR(server);
3565 bdi_destroy(&cifs_sb->bdi);
3569 /* get a reference to a SMB session */
3570 ses = cifs_get_smb_ses(server, volume_info);
3574 goto mount_fail_check;
3577 #ifdef CONFIG_CIFS_SMB2
3578 if ((volume_info->persistent == true) && ((ses->server->capabilities &
3579 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES) == 0)) {
3580 cifs_dbg(VFS, "persistent handles not supported by server\n");
3582 goto mount_fail_check;
3584 #endif /* CONFIG_CIFS_SMB2*/
3586 /* search for existing tcon to this server share */
3587 tcon = cifs_get_tcon(ses, volume_info);
3591 goto remote_path_check;
3594 /* tell server which Unix caps we support */
3595 if (cap_unix(tcon->ses)) {
3596 /* reset of caps checks mount to see if unix extensions
3597 disabled for just this mount */
3598 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3599 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3600 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3601 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3603 goto mount_fail_check;
3606 tcon->unix_ext = 0; /* server does not support them */
3608 /* do not care if a following call succeed - informational */
3609 if (!tcon->ipc && server->ops->qfs_tcon)
3610 server->ops->qfs_tcon(xid, tcon);
3612 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3613 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
3615 /* tune readahead according to rsize */
3616 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
3619 #ifdef CONFIG_CIFS_DFS_UPCALL
3621 * Perform an unconditional check for whether there are DFS
3622 * referrals for this path without prefix, to provide support
3623 * for DFS referrals from w2k8 servers which don't seem to respond
3624 * with PATH_NOT_COVERED to requests that include the prefix.
3625 * Chase the referral if found, otherwise continue normally.
3627 if (referral_walks_count == 0) {
3628 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3631 referral_walks_count++;
3632 goto try_mount_again;
3637 /* check if a whole path is not remote */
3639 if (!server->ops->is_path_accessible) {
3641 goto mount_fail_check;
3644 * cifs_build_path_to_root works only when we have a valid tcon
3646 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3647 if (full_path == NULL) {
3649 goto mount_fail_check;
3651 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3653 if (rc != 0 && rc != -EREMOTE) {
3655 goto mount_fail_check;
3660 /* get referral if needed */
3661 if (rc == -EREMOTE) {
3662 #ifdef CONFIG_CIFS_DFS_UPCALL
3663 if (referral_walks_count > MAX_NESTED_LINKS) {
3665 * BB: when we implement proper loop detection,
3666 * we will remove this check. But now we need it
3667 * to prevent an indefinite loop if 'DFS tree' is
3668 * misconfigured (i.e. has loops).
3671 goto mount_fail_check;
3674 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
3677 referral_walks_count++;
3678 goto try_mount_again;
3680 goto mount_fail_check;
3681 #else /* No DFS support, return error on mount */
3687 goto mount_fail_check;
3689 /* now, hang the tcon off of the superblock */
3690 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3691 if (tlink == NULL) {
3693 goto mount_fail_check;
3696 tlink->tl_uid = ses->linux_uid;
3697 tlink->tl_tcon = tcon;
3698 tlink->tl_time = jiffies;
3699 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3700 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3702 cifs_sb->master_tlink = tlink;
3703 spin_lock(&cifs_sb->tlink_tree_lock);
3704 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3705 spin_unlock(&cifs_sb->tlink_tree_lock);
3707 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3711 /* on error free sesinfo and tcon struct if needed */
3713 /* If find_unc succeeded then rc == 0 so we can not end */
3714 /* up accidentally freeing someone elses tcon struct */
3716 cifs_put_tcon(tcon);
3718 cifs_put_smb_ses(ses);
3720 cifs_put_tcp_session(server);
3721 bdi_destroy(&cifs_sb->bdi);
3730 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3731 * pointer may be NULL.
3734 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
3735 const char *tree, struct cifs_tcon *tcon,
3736 const struct nls_table *nls_codepage)
3738 struct smb_hdr *smb_buffer;
3739 struct smb_hdr *smb_buffer_response;
3742 unsigned char *bcc_ptr;
3745 __u16 bytes_left, count;
3750 smb_buffer = cifs_buf_get();
3751 if (smb_buffer == NULL)
3754 smb_buffer_response = smb_buffer;
3756 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3757 NULL /*no tid */ , 4 /*wct */ );
3759 smb_buffer->Mid = get_next_mid(ses->server);
3760 smb_buffer->Uid = ses->Suid;
3761 pSMB = (TCONX_REQ *) smb_buffer;
3762 pSMBr = (TCONX_RSP *) smb_buffer_response;
3764 pSMB->AndXCommand = 0xFF;
3765 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3766 bcc_ptr = &pSMB->Password[0];
3767 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3768 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3769 *bcc_ptr = 0; /* password is null byte */
3770 bcc_ptr++; /* skip password */
3771 /* already aligned so no need to do it below */
3773 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3774 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3775 specified as required (when that support is added to
3776 the vfs in the future) as only NTLM or the much
3777 weaker LANMAN (which we do not send by default) is accepted
3778 by Samba (not sure whether other servers allow
3779 NTLMv2 password here) */
3780 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3781 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3782 (ses->sectype == LANMAN))
3783 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3784 ses->server->sec_mode &
3785 SECMODE_PW_ENCRYPT ? true : false,
3788 #endif /* CIFS_WEAK_PW_HASH */
3789 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3790 bcc_ptr, nls_codepage);
3792 cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
3794 cifs_buf_release(smb_buffer);
3798 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3799 if (ses->capabilities & CAP_UNICODE) {
3800 /* must align unicode strings */
3801 *bcc_ptr = 0; /* null byte password */
3806 if (ses->server->sign)
3807 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3809 if (ses->capabilities & CAP_STATUS32) {
3810 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3812 if (ses->capabilities & CAP_DFS) {
3813 smb_buffer->Flags2 |= SMBFLG2_DFS;
3815 if (ses->capabilities & CAP_UNICODE) {
3816 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3818 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3819 6 /* max utf8 char length in bytes */ *
3820 (/* server len*/ + 256 /* share len */), nls_codepage);
3821 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3822 bcc_ptr += 2; /* skip trailing null */
3823 } else { /* ASCII */
3824 strcpy(bcc_ptr, tree);
3825 bcc_ptr += strlen(tree) + 1;
3827 strcpy(bcc_ptr, "?????");
3828 bcc_ptr += strlen("?????");
3830 count = bcc_ptr - &pSMB->Password[0];
3831 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3832 pSMB->hdr.smb_buf_length) + count);
3833 pSMB->ByteCount = cpu_to_le16(count);
3835 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3838 /* above now done in SendReceive */
3839 if ((rc == 0) && (tcon != NULL)) {
3842 tcon->tidStatus = CifsGood;
3843 tcon->need_reconnect = false;
3844 tcon->tid = smb_buffer_response->Tid;
3845 bcc_ptr = pByteArea(smb_buffer_response);
3846 bytes_left = get_bcc(smb_buffer_response);
3847 length = strnlen(bcc_ptr, bytes_left - 2);
3848 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3854 /* skip service field (NB: this field is always ASCII) */
3856 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3857 (bcc_ptr[2] == 'C')) {
3858 cifs_dbg(FYI, "IPC connection\n");
3861 } else if (length == 2) {
3862 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3863 /* the most common case */
3864 cifs_dbg(FYI, "disk share connection\n");
3867 bcc_ptr += length + 1;
3868 bytes_left -= (length + 1);
3869 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
3871 /* mostly informational -- no need to fail on error here */
3872 kfree(tcon->nativeFileSystem);
3873 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
3874 bytes_left, is_unicode,
3877 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
3879 if ((smb_buffer_response->WordCount == 3) ||
3880 (smb_buffer_response->WordCount == 7))
3881 /* field is in same location */
3882 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3885 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
3886 } else if ((rc == 0) && tcon == NULL) {
3887 /* all we need to save for IPC$ connection */
3888 ses->ipc_tid = smb_buffer_response->Tid;
3891 cifs_buf_release(smb_buffer);
3895 static void delayed_free(struct rcu_head *p)
3897 struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
3898 unload_nls(sbi->local_nls);
3903 cifs_umount(struct cifs_sb_info *cifs_sb)
3905 struct rb_root *root = &cifs_sb->tlink_tree;
3906 struct rb_node *node;
3907 struct tcon_link *tlink;
3909 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3911 spin_lock(&cifs_sb->tlink_tree_lock);
3912 while ((node = rb_first(root))) {
3913 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3914 cifs_get_tlink(tlink);
3915 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3916 rb_erase(node, root);
3918 spin_unlock(&cifs_sb->tlink_tree_lock);
3919 cifs_put_tlink(tlink);
3920 spin_lock(&cifs_sb->tlink_tree_lock);
3922 spin_unlock(&cifs_sb->tlink_tree_lock);
3924 bdi_destroy(&cifs_sb->bdi);
3925 kfree(cifs_sb->mountdata);
3926 call_rcu(&cifs_sb->rcu, delayed_free);
3930 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
3933 struct TCP_Server_Info *server = ses->server;
3935 if (!server->ops->need_neg || !server->ops->negotiate)
3938 /* only send once per connect */
3939 if (!server->ops->need_neg(server))
3942 set_credits(server, 1);
3944 rc = server->ops->negotiate(xid, ses);
3946 spin_lock(&GlobalMid_Lock);
3947 if (server->tcpStatus == CifsNeedNegotiate)
3948 server->tcpStatus = CifsGood;
3951 spin_unlock(&GlobalMid_Lock);
3958 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
3959 struct nls_table *nls_info)
3962 struct TCP_Server_Info *server = ses->server;
3964 ses->capabilities = server->capabilities;
3965 if (linuxExtEnabled == 0)
3966 ses->capabilities &= (~server->vals->cap_unix);
3968 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
3969 server->sec_mode, server->capabilities, server->timeAdj);
3971 if (server->ops->sess_setup)
3972 rc = server->ops->sess_setup(xid, ses, nls_info);
3975 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
3981 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
3983 vol->sectype = ses->sectype;
3985 /* krb5 is special, since we don't need username or pw */
3986 if (vol->sectype == Kerberos)
3989 return cifs_set_cifscreds(vol, ses);
3992 static struct cifs_tcon *
3993 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
3996 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3997 struct cifs_ses *ses;
3998 struct cifs_tcon *tcon = NULL;
3999 struct smb_vol *vol_info;
4001 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
4002 if (vol_info == NULL)
4003 return ERR_PTR(-ENOMEM);
4005 vol_info->local_nls = cifs_sb->local_nls;
4006 vol_info->linux_uid = fsuid;
4007 vol_info->cred_uid = fsuid;
4008 vol_info->UNC = master_tcon->treeName;
4009 vol_info->retry = master_tcon->retry;
4010 vol_info->nocase = master_tcon->nocase;
4011 vol_info->local_lease = master_tcon->local_lease;
4012 vol_info->no_linux_ext = !master_tcon->unix_ext;
4013 vol_info->sectype = master_tcon->ses->sectype;
4014 vol_info->sign = master_tcon->ses->sign;
4016 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4022 /* get a reference for the same TCP session */
4023 spin_lock(&cifs_tcp_ses_lock);
4024 ++master_tcon->ses->server->srv_count;
4025 spin_unlock(&cifs_tcp_ses_lock);
4027 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4029 tcon = (struct cifs_tcon *)ses;
4030 cifs_put_tcp_session(master_tcon->ses->server);
4034 tcon = cifs_get_tcon(ses, vol_info);
4036 cifs_put_smb_ses(ses);
4041 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4043 kfree(vol_info->username);
4044 kfree(vol_info->password);
4051 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4053 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4056 /* find and return a tlink with given uid */
4057 static struct tcon_link *
4058 tlink_rb_search(struct rb_root *root, kuid_t uid)
4060 struct rb_node *node = root->rb_node;
4061 struct tcon_link *tlink;
4064 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4066 if (uid_gt(tlink->tl_uid, uid))
4067 node = node->rb_left;
4068 else if (uid_lt(tlink->tl_uid, uid))
4069 node = node->rb_right;
4076 /* insert a tcon_link into the tree */
4078 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4080 struct rb_node **new = &(root->rb_node), *parent = NULL;
4081 struct tcon_link *tlink;
4084 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4087 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
4088 new = &((*new)->rb_left);
4090 new = &((*new)->rb_right);
4093 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4094 rb_insert_color(&new_tlink->tl_rbnode, root);
4098 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4101 * If the superblock doesn't refer to a multiuser mount, then just return
4102 * the master tcon for the mount.
4104 * First, search the rbtree for an existing tcon for this fsuid. If one
4105 * exists, then check to see if it's pending construction. If it is then wait
4106 * for construction to complete. Once it's no longer pending, check to see if
4107 * it failed and either return an error or retry construction, depending on
4110 * If one doesn't exist then insert a new tcon_link struct into the tree and
4111 * try to construct a new one.
4114 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4117 kuid_t fsuid = current_fsuid();
4118 struct tcon_link *tlink, *newtlink;
4120 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4121 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4123 spin_lock(&cifs_sb->tlink_tree_lock);
4124 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4126 cifs_get_tlink(tlink);
4127 spin_unlock(&cifs_sb->tlink_tree_lock);
4129 if (tlink == NULL) {
4130 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4131 if (newtlink == NULL)
4132 return ERR_PTR(-ENOMEM);
4133 newtlink->tl_uid = fsuid;
4134 newtlink->tl_tcon = ERR_PTR(-EACCES);
4135 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4136 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4137 cifs_get_tlink(newtlink);
4139 spin_lock(&cifs_sb->tlink_tree_lock);
4140 /* was one inserted after previous search? */
4141 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4143 cifs_get_tlink(tlink);
4144 spin_unlock(&cifs_sb->tlink_tree_lock);
4146 goto wait_for_construction;
4149 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4150 spin_unlock(&cifs_sb->tlink_tree_lock);
4152 wait_for_construction:
4153 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4154 TASK_INTERRUPTIBLE);
4156 cifs_put_tlink(tlink);
4157 return ERR_PTR(-ERESTARTSYS);
4160 /* if it's good, return it */
4161 if (!IS_ERR(tlink->tl_tcon))
4164 /* return error if we tried this already recently */
4165 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4166 cifs_put_tlink(tlink);
4167 return ERR_PTR(-EACCES);
4170 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4171 goto wait_for_construction;
4174 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4175 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4176 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4178 if (IS_ERR(tlink->tl_tcon)) {
4179 cifs_put_tlink(tlink);
4180 return ERR_PTR(-EACCES);
4187 * periodic workqueue job that scans tcon_tree for a superblock and closes
4191 cifs_prune_tlinks(struct work_struct *work)
4193 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4195 struct rb_root *root = &cifs_sb->tlink_tree;
4196 struct rb_node *node = rb_first(root);
4197 struct rb_node *tmp;
4198 struct tcon_link *tlink;
4201 * Because we drop the spinlock in the loop in order to put the tlink
4202 * it's not guarded against removal of links from the tree. The only
4203 * places that remove entries from the tree are this function and
4204 * umounts. Because this function is non-reentrant and is canceled
4205 * before umount can proceed, this is safe.
4207 spin_lock(&cifs_sb->tlink_tree_lock);
4208 node = rb_first(root);
4209 while (node != NULL) {
4211 node = rb_next(tmp);
4212 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4214 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4215 atomic_read(&tlink->tl_count) != 0 ||
4216 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4219 cifs_get_tlink(tlink);
4220 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4221 rb_erase(tmp, root);
4223 spin_unlock(&cifs_sb->tlink_tree_lock);
4224 cifs_put_tlink(tlink);
4225 spin_lock(&cifs_sb->tlink_tree_lock);
4227 spin_unlock(&cifs_sb->tlink_tree_lock);
4229 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,