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,
92 /* Mount options which take numeric value */
93 Opt_backupuid, Opt_backupgid, Opt_uid,
94 Opt_cruid, Opt_gid, Opt_file_mode,
95 Opt_dirmode, Opt_port,
96 Opt_rsize, Opt_wsize, Opt_actimeo,
98 /* Mount options which take string value */
99 Opt_user, Opt_pass, Opt_ip,
100 Opt_domain, Opt_srcaddr, Opt_iocharset,
101 Opt_netbiosname, Opt_servern,
102 Opt_ver, Opt_vers, Opt_sec, Opt_cache,
104 /* Mount options to be ignored */
107 /* Options which could be blank */
115 static const match_table_t cifs_mount_option_tokens = {
117 { Opt_user_xattr, "user_xattr" },
118 { Opt_nouser_xattr, "nouser_xattr" },
119 { Opt_forceuid, "forceuid" },
120 { Opt_noforceuid, "noforceuid" },
121 { Opt_forcegid, "forcegid" },
122 { Opt_noforcegid, "noforcegid" },
123 { Opt_noblocksend, "noblocksend" },
124 { Opt_noautotune, "noautotune" },
125 { Opt_hard, "hard" },
126 { Opt_soft, "soft" },
127 { Opt_perm, "perm" },
128 { Opt_noperm, "noperm" },
129 { Opt_mapchars, "mapchars" }, /* SFU style */
130 { Opt_nomapchars, "nomapchars" },
131 { Opt_mapposix, "mapposix" }, /* SFM style */
132 { Opt_nomapposix, "nomapposix" },
134 { Opt_nosfu, "nosfu" },
135 { Opt_nodfs, "nodfs" },
136 { Opt_posixpaths, "posixpaths" },
137 { Opt_noposixpaths, "noposixpaths" },
138 { Opt_nounix, "nounix" },
139 { Opt_nounix, "nolinux" },
140 { Opt_nocase, "nocase" },
141 { Opt_nocase, "ignorecase" },
143 { Opt_nobrl, "nobrl" },
144 { Opt_nobrl, "nolock" },
145 { Opt_forcemandatorylock, "forcemandatorylock" },
146 { Opt_forcemandatorylock, "forcemand" },
147 { Opt_setuids, "setuids" },
148 { Opt_nosetuids, "nosetuids" },
149 { Opt_dynperm, "dynperm" },
150 { Opt_nodynperm, "nodynperm" },
151 { Opt_nohard, "nohard" },
152 { Opt_nosoft, "nosoft" },
153 { Opt_nointr, "nointr" },
154 { Opt_intr, "intr" },
155 { Opt_nostrictsync, "nostrictsync" },
156 { Opt_strictsync, "strictsync" },
157 { Opt_serverino, "serverino" },
158 { Opt_noserverino, "noserverino" },
159 { Opt_rwpidforward, "rwpidforward" },
160 { Opt_cifsacl, "cifsacl" },
161 { Opt_nocifsacl, "nocifsacl" },
163 { Opt_noacl, "noacl" },
164 { Opt_locallease, "locallease" },
165 { Opt_sign, "sign" },
166 { Opt_seal, "seal" },
167 { Opt_noac, "noac" },
169 { Opt_mfsymlinks, "mfsymlinks" },
170 { Opt_multiuser, "multiuser" },
171 { Opt_sloppy, "sloppy" },
172 { Opt_nosharesock, "nosharesock" },
173 { Opt_persistent, "persistenthandles"},
174 { Opt_nopersistent, "nopersistenthandles"},
176 { Opt_backupuid, "backupuid=%s" },
177 { Opt_backupgid, "backupgid=%s" },
178 { Opt_uid, "uid=%s" },
179 { Opt_cruid, "cruid=%s" },
180 { Opt_gid, "gid=%s" },
181 { Opt_file_mode, "file_mode=%s" },
182 { Opt_dirmode, "dirmode=%s" },
183 { Opt_dirmode, "dir_mode=%s" },
184 { Opt_port, "port=%s" },
185 { Opt_rsize, "rsize=%s" },
186 { Opt_wsize, "wsize=%s" },
187 { Opt_actimeo, "actimeo=%s" },
189 { Opt_blank_user, "user=" },
190 { Opt_blank_user, "username=" },
191 { Opt_user, "user=%s" },
192 { Opt_user, "username=%s" },
193 { Opt_blank_pass, "pass=" },
194 { Opt_blank_pass, "password=" },
195 { Opt_pass, "pass=%s" },
196 { Opt_pass, "password=%s" },
197 { Opt_blank_ip, "ip=" },
198 { Opt_blank_ip, "addr=" },
200 { Opt_ip, "addr=%s" },
201 { Opt_ignore, "unc=%s" },
202 { Opt_ignore, "target=%s" },
203 { Opt_ignore, "path=%s" },
204 { Opt_domain, "dom=%s" },
205 { Opt_domain, "domain=%s" },
206 { Opt_domain, "workgroup=%s" },
207 { Opt_srcaddr, "srcaddr=%s" },
208 { Opt_ignore, "prefixpath=%s" },
209 { Opt_iocharset, "iocharset=%s" },
210 { Opt_netbiosname, "netbiosname=%s" },
211 { Opt_servern, "servern=%s" },
212 { Opt_ver, "ver=%s" },
213 { Opt_vers, "vers=%s" },
214 { Opt_sec, "sec=%s" },
215 { Opt_cache, "cache=%s" },
217 { Opt_ignore, "cred" },
218 { Opt_ignore, "credentials" },
219 { Opt_ignore, "cred=%s" },
220 { Opt_ignore, "credentials=%s" },
221 { Opt_ignore, "guest" },
222 { Opt_ignore, "rw" },
223 { Opt_ignore, "ro" },
224 { Opt_ignore, "suid" },
225 { Opt_ignore, "nosuid" },
226 { Opt_ignore, "exec" },
227 { Opt_ignore, "noexec" },
228 { Opt_ignore, "nodev" },
229 { Opt_ignore, "noauto" },
230 { Opt_ignore, "dev" },
231 { Opt_ignore, "mand" },
232 { Opt_ignore, "nomand" },
233 { Opt_ignore, "_netdev" },
239 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
240 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
241 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
242 Opt_sec_ntlmv2i, Opt_sec_lanman,
248 static const match_table_t cifs_secflavor_tokens = {
249 { Opt_sec_krb5, "krb5" },
250 { Opt_sec_krb5i, "krb5i" },
251 { Opt_sec_krb5p, "krb5p" },
252 { Opt_sec_ntlmsspi, "ntlmsspi" },
253 { Opt_sec_ntlmssp, "ntlmssp" },
254 { Opt_ntlm, "ntlm" },
255 { Opt_sec_ntlmi, "ntlmi" },
256 { Opt_sec_ntlmv2, "nontlm" },
257 { Opt_sec_ntlmv2, "ntlmv2" },
258 { Opt_sec_ntlmv2i, "ntlmv2i" },
259 { Opt_sec_lanman, "lanman" },
260 { Opt_sec_none, "none" },
262 { Opt_sec_err, NULL }
273 static const match_table_t cifs_cacheflavor_tokens = {
274 { Opt_cache_loose, "loose" },
275 { Opt_cache_strict, "strict" },
276 { Opt_cache_none, "none" },
277 { Opt_cache_err, NULL }
280 static const match_table_t cifs_smb_version_tokens = {
281 { Smb_1, SMB1_VERSION_STRING },
282 { Smb_20, SMB20_VERSION_STRING},
283 { Smb_21, SMB21_VERSION_STRING },
284 { Smb_30, SMB30_VERSION_STRING },
285 { Smb_302, SMB302_VERSION_STRING },
286 #ifdef CONFIG_CIFS_SMB311
287 { Smb_311, SMB311_VERSION_STRING },
288 { Smb_311, ALT_SMB311_VERSION_STRING },
290 { Smb_version_err, NULL }
293 static int ip_connect(struct TCP_Server_Info *server);
294 static int generic_ip_connect(struct TCP_Server_Info *server);
295 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
296 static void cifs_prune_tlinks(struct work_struct *work);
297 static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
298 const char *devname);
301 * cifs tcp session reconnection
303 * mark tcp session as reconnecting so temporarily locked
304 * mark all smb sessions as reconnecting for tcp session
305 * reconnect tcp session
306 * wake up waiters on reconnection? - (not needed currently)
309 cifs_reconnect(struct TCP_Server_Info *server)
312 struct list_head *tmp, *tmp2;
313 struct cifs_ses *ses;
314 struct cifs_tcon *tcon;
315 struct mid_q_entry *mid_entry;
316 struct list_head retry_list;
318 spin_lock(&GlobalMid_Lock);
319 if (server->tcpStatus == CifsExiting) {
320 /* the demux thread will exit normally
321 next time through the loop */
322 spin_unlock(&GlobalMid_Lock);
325 server->tcpStatus = CifsNeedReconnect;
326 spin_unlock(&GlobalMid_Lock);
328 #ifdef CONFIG_CIFS_SMB2
329 server->max_read = 0;
332 cifs_dbg(FYI, "Reconnecting tcp session\n");
334 /* before reconnecting the tcp session, mark the smb session (uid)
335 and the tid bad so they are not used until reconnected */
336 cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
338 spin_lock(&cifs_tcp_ses_lock);
339 list_for_each(tmp, &server->smb_ses_list) {
340 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
341 ses->need_reconnect = true;
343 list_for_each(tmp2, &ses->tcon_list) {
344 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
345 tcon->need_reconnect = true;
348 spin_unlock(&cifs_tcp_ses_lock);
350 /* do not want to be sending data on a socket we are freeing */
351 cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
352 mutex_lock(&server->srv_mutex);
353 if (server->ssocket) {
354 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
355 server->ssocket->state, server->ssocket->flags);
356 kernel_sock_shutdown(server->ssocket, SHUT_WR);
357 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
358 server->ssocket->state, server->ssocket->flags);
359 sock_release(server->ssocket);
360 server->ssocket = NULL;
362 server->sequence_number = 0;
363 server->session_estab = false;
364 kfree(server->session_key.response);
365 server->session_key.response = NULL;
366 server->session_key.len = 0;
367 server->lstrp = jiffies;
368 mutex_unlock(&server->srv_mutex);
370 /* mark submitted MIDs for retry and issue callback */
371 INIT_LIST_HEAD(&retry_list);
372 cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
373 spin_lock(&GlobalMid_Lock);
374 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
375 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
376 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
377 mid_entry->mid_state = MID_RETRY_NEEDED;
378 list_move(&mid_entry->qhead, &retry_list);
380 spin_unlock(&GlobalMid_Lock);
382 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
383 list_for_each_safe(tmp, tmp2, &retry_list) {
384 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
385 list_del_init(&mid_entry->qhead);
386 mid_entry->callback(mid_entry);
392 /* we should try only the port we connected to before */
393 mutex_lock(&server->srv_mutex);
394 rc = generic_ip_connect(server);
396 cifs_dbg(FYI, "reconnect error %d\n", rc);
397 mutex_unlock(&server->srv_mutex);
400 atomic_inc(&tcpSesReconnectCount);
401 spin_lock(&GlobalMid_Lock);
402 if (server->tcpStatus != CifsExiting)
403 server->tcpStatus = CifsNeedNegotiate;
404 spin_unlock(&GlobalMid_Lock);
405 mutex_unlock(&server->srv_mutex);
407 } while (server->tcpStatus == CifsNeedReconnect);
413 cifs_echo_request(struct work_struct *work)
416 struct TCP_Server_Info *server = container_of(work,
417 struct TCP_Server_Info, echo.work);
420 * We cannot send an echo if it is disabled or until the
421 * NEGOTIATE_PROTOCOL request is done, which is indicated by
422 * server->ops->need_neg() == true. Also, no need to ping if
423 * we got a response recently.
425 if (!server->ops->need_neg || server->ops->need_neg(server) ||
426 (server->ops->can_echo && !server->ops->can_echo(server)) ||
427 time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
430 rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
432 cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
436 queue_delayed_work(cifsiod_wq, &server->echo, SMB_ECHO_INTERVAL);
440 allocate_buffers(struct TCP_Server_Info *server)
442 if (!server->bigbuf) {
443 server->bigbuf = (char *)cifs_buf_get();
444 if (!server->bigbuf) {
445 cifs_dbg(VFS, "No memory for large SMB response\n");
447 /* retry will check if exiting */
450 } else if (server->large_buf) {
451 /* we are reusing a dirty large buf, clear its start */
452 memset(server->bigbuf, 0, HEADER_SIZE(server));
455 if (!server->smallbuf) {
456 server->smallbuf = (char *)cifs_small_buf_get();
457 if (!server->smallbuf) {
458 cifs_dbg(VFS, "No memory for SMB response\n");
460 /* retry will check if exiting */
463 /* beginning of smb buffer is cleared in our buf_get */
465 /* if existing small buf clear beginning */
466 memset(server->smallbuf, 0, HEADER_SIZE(server));
473 server_unresponsive(struct TCP_Server_Info *server)
476 * We need to wait 2 echo intervals to make sure we handle such
478 * 1s client sends a normal SMB request
479 * 2s client gets a response
480 * 30s echo workqueue job pops, and decides we got a response recently
481 * and don't need to send another
483 * 65s kernel_recvmsg times out, and we see that we haven't gotten
484 * a response in >60s.
486 if (server->tcpStatus == CifsGood &&
487 time_after(jiffies, server->lstrp + 2 * SMB_ECHO_INTERVAL)) {
488 cifs_dbg(VFS, "Server %s has not responded in %d seconds. Reconnecting...\n",
489 server->hostname, (2 * SMB_ECHO_INTERVAL) / HZ);
490 cifs_reconnect(server);
491 wake_up(&server->response_q);
499 * kvec_array_init - clone a kvec array, and advance into it
500 * @new: pointer to memory for cloned array
501 * @iov: pointer to original array
502 * @nr_segs: number of members in original array
503 * @bytes: number of bytes to advance into the cloned array
505 * This function will copy the array provided in iov to a section of memory
506 * and advance the specified number of bytes into the new array. It returns
507 * the number of segments in the new array. "new" must be at least as big as
508 * the original iov array.
511 kvec_array_init(struct kvec *new, struct kvec *iov, unsigned int nr_segs,
516 while (bytes || !iov->iov_len) {
517 int copy = min(bytes, iov->iov_len);
521 if (iov->iov_len == base) {
527 memcpy(new, iov, sizeof(*iov) * nr_segs);
528 new->iov_base += base;
529 new->iov_len -= base;
534 get_server_iovec(struct TCP_Server_Info *server, unsigned int nr_segs)
536 struct kvec *new_iov;
538 if (server->iov && nr_segs <= server->nr_iov)
541 /* not big enough -- allocate a new one and release the old */
542 new_iov = kmalloc(sizeof(*new_iov) * nr_segs, GFP_NOFS);
545 server->iov = new_iov;
546 server->nr_iov = nr_segs;
552 cifs_readv_from_socket(struct TCP_Server_Info *server, struct kvec *iov_orig,
553 unsigned int nr_segs, unsigned int to_read)
558 struct msghdr smb_msg;
561 iov = get_server_iovec(server, nr_segs);
565 smb_msg.msg_control = NULL;
566 smb_msg.msg_controllen = 0;
568 for (total_read = 0; to_read; total_read += length, to_read -= length) {
571 if (server_unresponsive(server)) {
572 total_read = -ECONNABORTED;
576 segs = kvec_array_init(iov, iov_orig, nr_segs, total_read);
578 length = kernel_recvmsg(server->ssocket, &smb_msg,
579 iov, segs, to_read, 0);
581 if (server->tcpStatus == CifsExiting) {
582 total_read = -ESHUTDOWN;
584 } else if (server->tcpStatus == CifsNeedReconnect) {
585 cifs_reconnect(server);
586 total_read = -ECONNABORTED;
588 } else if (length == -ERESTARTSYS ||
592 * Minimum sleep to prevent looping, allowing socket
593 * to clear and app threads to set tcpStatus
594 * CifsNeedReconnect if server hung.
596 usleep_range(1000, 2000);
599 } else if (length <= 0) {
600 cifs_dbg(FYI, "Received no data or error: expecting %d\n"
601 "got %d", to_read, length);
602 cifs_reconnect(server);
603 total_read = -ECONNABORTED;
611 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
612 unsigned int to_read)
617 iov.iov_len = to_read;
619 return cifs_readv_from_socket(server, &iov, 1, to_read);
623 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
626 * The first byte big endian of the length field,
627 * is actually not part of the length but the type
628 * with the most common, zero, as regular data.
631 case RFC1002_SESSION_MESSAGE:
632 /* Regular SMB response */
634 case RFC1002_SESSION_KEEP_ALIVE:
635 cifs_dbg(FYI, "RFC 1002 session keep alive\n");
637 case RFC1002_POSITIVE_SESSION_RESPONSE:
638 cifs_dbg(FYI, "RFC 1002 positive session response\n");
640 case RFC1002_NEGATIVE_SESSION_RESPONSE:
642 * We get this from Windows 98 instead of an error on
643 * SMB negprot response.
645 cifs_dbg(FYI, "RFC 1002 negative session response\n");
646 /* give server a second to clean up */
649 * Always try 445 first on reconnect since we get NACK
650 * on some if we ever connected to port 139 (the NACK
651 * is since we do not begin with RFC1001 session
654 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
655 cifs_reconnect(server);
656 wake_up(&server->response_q);
659 cifs_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
660 cifs_reconnect(server);
667 dequeue_mid(struct mid_q_entry *mid, bool malformed)
669 #ifdef CONFIG_CIFS_STATS2
670 mid->when_received = jiffies;
672 spin_lock(&GlobalMid_Lock);
674 mid->mid_state = MID_RESPONSE_RECEIVED;
676 mid->mid_state = MID_RESPONSE_MALFORMED;
677 list_del_init(&mid->qhead);
678 spin_unlock(&GlobalMid_Lock);
682 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
683 char *buf, int malformed)
685 if (server->ops->check_trans2 &&
686 server->ops->check_trans2(mid, server, buf, malformed))
689 mid->large_buf = server->large_buf;
690 /* Was previous buf put in mpx struct for multi-rsp? */
691 if (!mid->multiRsp) {
692 /* smb buffer will be freed by user thread */
693 if (server->large_buf)
694 server->bigbuf = NULL;
696 server->smallbuf = NULL;
698 dequeue_mid(mid, malformed);
701 static void clean_demultiplex_info(struct TCP_Server_Info *server)
705 /* take it off the list, if it's not already */
706 spin_lock(&cifs_tcp_ses_lock);
707 list_del_init(&server->tcp_ses_list);
708 spin_unlock(&cifs_tcp_ses_lock);
710 spin_lock(&GlobalMid_Lock);
711 server->tcpStatus = CifsExiting;
712 spin_unlock(&GlobalMid_Lock);
713 wake_up_all(&server->response_q);
715 /* check if we have blocked requests that need to free */
716 spin_lock(&server->req_lock);
717 if (server->credits <= 0)
719 spin_unlock(&server->req_lock);
721 * Although there should not be any requests blocked on this queue it
722 * can not hurt to be paranoid and try to wake up requests that may
723 * haven been blocked when more than 50 at time were on the wire to the
724 * same server - they now will see the session is in exit state and get
725 * out of SendReceive.
727 wake_up_all(&server->request_q);
728 /* give those requests time to exit */
731 if (server->ssocket) {
732 sock_release(server->ssocket);
733 server->ssocket = NULL;
736 if (!list_empty(&server->pending_mid_q)) {
737 struct list_head dispose_list;
738 struct mid_q_entry *mid_entry;
739 struct list_head *tmp, *tmp2;
741 INIT_LIST_HEAD(&dispose_list);
742 spin_lock(&GlobalMid_Lock);
743 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
744 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
745 cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid);
746 mid_entry->mid_state = MID_SHUTDOWN;
747 list_move(&mid_entry->qhead, &dispose_list);
749 spin_unlock(&GlobalMid_Lock);
751 /* now walk dispose list and issue callbacks */
752 list_for_each_safe(tmp, tmp2, &dispose_list) {
753 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
754 cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid);
755 list_del_init(&mid_entry->qhead);
756 mid_entry->callback(mid_entry);
758 /* 1/8th of sec is more than enough time for them to exit */
762 if (!list_empty(&server->pending_mid_q)) {
764 * mpx threads have not exited yet give them at least the smb
765 * send timeout time for long ops.
767 * Due to delays on oplock break requests, we need to wait at
768 * least 45 seconds before giving up on a request getting a
769 * response and going ahead and killing cifsd.
771 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
774 * If threads still have not exited they are probably never
775 * coming home not much else we can do but free the memory.
779 kfree(server->hostname);
783 length = atomic_dec_return(&tcpSesAllocCount);
785 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
789 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
792 char *buf = server->smallbuf;
793 unsigned int pdu_length = get_rfc1002_length(buf);
795 /* make sure this will fit in a large buffer */
796 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) - 4) {
797 cifs_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
798 cifs_reconnect(server);
799 wake_up(&server->response_q);
800 return -ECONNABORTED;
803 /* switch to large buffer if too big for a small one */
804 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
805 server->large_buf = true;
806 memcpy(server->bigbuf, buf, server->total_read);
807 buf = server->bigbuf;
810 /* now read the rest */
811 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
812 pdu_length - HEADER_SIZE(server) + 1 + 4);
815 server->total_read += length;
817 dump_smb(buf, server->total_read);
820 * We know that we received enough to get to the MID as we
821 * checked the pdu_length earlier. Now check to see
822 * if the rest of the header is OK. We borrow the length
823 * var for the rest of the loop to avoid a new stack var.
825 * 48 bytes is enough to display the header and a little bit
826 * into the payload for debugging purposes.
828 length = server->ops->check_message(buf, server->total_read);
830 cifs_dump_mem("Bad SMB: ", buf,
831 min_t(unsigned int, server->total_read, 48));
833 if (server->ops->is_status_pending &&
834 server->ops->is_status_pending(buf, server, length))
840 handle_mid(mid, server, buf, length);
845 cifs_demultiplex_thread(void *p)
848 struct TCP_Server_Info *server = p;
849 unsigned int pdu_length;
851 struct task_struct *task_to_wake = NULL;
852 struct mid_q_entry *mid_entry;
854 current->flags |= PF_MEMALLOC;
855 cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
857 length = atomic_inc_return(&tcpSesAllocCount);
859 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
862 while (server->tcpStatus != CifsExiting) {
866 if (!allocate_buffers(server))
869 server->large_buf = false;
870 buf = server->smallbuf;
871 pdu_length = 4; /* enough to get RFC1001 header */
873 length = cifs_read_from_socket(server, buf, pdu_length);
876 server->total_read = length;
879 * The right amount was read from socket - 4 bytes,
880 * so we can now interpret the length field.
882 pdu_length = get_rfc1002_length(buf);
884 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
885 if (!is_smb_response(server, buf[0]))
888 /* make sure we have enough to get to the MID */
889 if (pdu_length < HEADER_SIZE(server) - 1 - 4) {
890 cifs_dbg(VFS, "SMB response too short (%u bytes)\n",
892 cifs_reconnect(server);
893 wake_up(&server->response_q);
897 /* read down to the MID */
898 length = cifs_read_from_socket(server, buf + 4,
899 HEADER_SIZE(server) - 1 - 4);
902 server->total_read += length;
904 mid_entry = server->ops->find_mid(server, buf);
906 if (!mid_entry || !mid_entry->receive)
907 length = standard_receive3(server, mid_entry);
909 length = mid_entry->receive(server, mid_entry);
914 if (server->large_buf)
915 buf = server->bigbuf;
917 server->lstrp = jiffies;
918 if (mid_entry != NULL) {
919 if (!mid_entry->multiRsp || mid_entry->multiEnd)
920 mid_entry->callback(mid_entry);
921 } else if (!server->ops->is_oplock_break ||
922 !server->ops->is_oplock_break(buf, server)) {
923 cifs_dbg(VFS, "No task to wake, unknown frame received! NumMids %d\n",
924 atomic_read(&midCount));
925 cifs_dump_mem("Received Data is: ", buf,
926 HEADER_SIZE(server));
927 #ifdef CONFIG_CIFS_DEBUG2
928 if (server->ops->dump_detail)
929 server->ops->dump_detail(buf);
930 cifs_dump_mids(server);
931 #endif /* CIFS_DEBUG2 */
934 } /* end while !EXITING */
936 /* buffer usually freed in free_mid - need to free it here on exit */
937 cifs_buf_release(server->bigbuf);
938 if (server->smallbuf) /* no sense logging a debug message if NULL */
939 cifs_small_buf_release(server->smallbuf);
941 task_to_wake = xchg(&server->tsk, NULL);
942 clean_demultiplex_info(server);
944 /* if server->tsk was NULL then wait for a signal before exiting */
946 set_current_state(TASK_INTERRUPTIBLE);
947 while (!signal_pending(current)) {
949 set_current_state(TASK_INTERRUPTIBLE);
951 set_current_state(TASK_RUNNING);
954 module_put_and_exit(0);
957 /* extract the host portion of the UNC string */
959 extract_hostname(const char *unc)
965 /* skip double chars at beginning of string */
966 /* BB: check validity of these bytes? */
969 /* delimiter between hostname and sharename is always '\\' now */
970 delim = strchr(src, '\\');
972 return ERR_PTR(-EINVAL);
975 dst = kmalloc((len + 1), GFP_KERNEL);
977 return ERR_PTR(-ENOMEM);
979 memcpy(dst, src, len);
985 static int get_option_ul(substring_t args[], unsigned long *option)
990 string = match_strdup(args);
993 rc = kstrtoul(string, 0, option);
999 static int get_option_uid(substring_t args[], kuid_t *result)
1001 unsigned long value;
1005 rc = get_option_ul(args, &value);
1009 uid = make_kuid(current_user_ns(), value);
1010 if (!uid_valid(uid))
1017 static int get_option_gid(substring_t args[], kgid_t *result)
1019 unsigned long value;
1023 rc = get_option_ul(args, &value);
1027 gid = make_kgid(current_user_ns(), value);
1028 if (!gid_valid(gid))
1035 static int cifs_parse_security_flavors(char *value,
1036 struct smb_vol *vol)
1039 substring_t args[MAX_OPT_ARGS];
1042 * With mount options, the last one should win. Reset any existing
1043 * settings back to default.
1045 vol->sectype = Unspecified;
1048 switch (match_token(value, cifs_secflavor_tokens, args)) {
1050 cifs_dbg(VFS, "sec=krb5p is not supported!\n");
1056 vol->sectype = Kerberos;
1058 case Opt_sec_ntlmsspi:
1061 case Opt_sec_ntlmssp:
1062 vol->sectype = RawNTLMSSP;
1068 vol->sectype = NTLM;
1070 case Opt_sec_ntlmv2i:
1073 case Opt_sec_ntlmv2:
1074 vol->sectype = NTLMv2;
1076 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1077 case Opt_sec_lanman:
1078 vol->sectype = LANMAN;
1085 cifs_dbg(VFS, "bad security option: %s\n", value);
1093 cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1095 substring_t args[MAX_OPT_ARGS];
1097 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1098 case Opt_cache_loose:
1099 vol->direct_io = false;
1100 vol->strict_io = false;
1102 case Opt_cache_strict:
1103 vol->direct_io = false;
1104 vol->strict_io = true;
1106 case Opt_cache_none:
1107 vol->direct_io = true;
1108 vol->strict_io = false;
1111 cifs_dbg(VFS, "bad cache= option: %s\n", value);
1118 cifs_parse_smb_version(char *value, struct smb_vol *vol)
1120 substring_t args[MAX_OPT_ARGS];
1122 switch (match_token(value, cifs_smb_version_tokens, args)) {
1124 vol->ops = &smb1_operations;
1125 vol->vals = &smb1_values;
1127 #ifdef CONFIG_CIFS_SMB2
1129 vol->ops = &smb20_operations;
1130 vol->vals = &smb20_values;
1133 vol->ops = &smb21_operations;
1134 vol->vals = &smb21_values;
1137 vol->ops = &smb30_operations;
1138 vol->vals = &smb30_values;
1141 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1142 vol->vals = &smb302_values;
1144 #ifdef CONFIG_CIFS_SMB311
1146 vol->ops = &smb311_operations;
1147 vol->vals = &smb311_values;
1152 cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
1159 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1160 * fields with the result. Returns 0 on success and an error otherwise.
1163 cifs_parse_devname(const char *devname, struct smb_vol *vol)
1166 const char *delims = "/\\";
1169 /* make sure we have a valid UNC double delimiter prefix */
1170 len = strspn(devname, delims);
1174 /* find delimiter between host and sharename */
1175 pos = strpbrk(devname + 2, delims);
1179 /* skip past delimiter */
1182 /* now go until next delimiter or end of string */
1183 len = strcspn(pos, delims);
1185 /* move "pos" up to delimiter or NULL */
1187 vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1191 convert_delimiter(vol->UNC, '\\');
1193 /* If pos is NULL, or is a bogus trailing delimiter then no prepath */
1194 if (!*pos++ || !*pos)
1197 vol->prepath = kstrdup(pos, GFP_KERNEL);
1205 cifs_parse_mount_options(const char *mountdata, const char *devname,
1206 struct smb_vol *vol)
1209 char *mountdata_copy = NULL, *options;
1210 unsigned int temp_len, i, j;
1212 short int override_uid = -1;
1213 short int override_gid = -1;
1214 bool uid_specified = false;
1215 bool gid_specified = false;
1216 bool sloppy = false;
1217 char *invalid = NULL;
1218 char *nodename = utsname()->nodename;
1219 char *string = NULL;
1220 char *tmp_end, *value;
1222 bool got_ip = false;
1223 unsigned short port = 0;
1224 struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1228 delim = separator[0];
1230 /* ensure we always start with zeroed-out smb_vol */
1231 memset(vol, 0, sizeof(*vol));
1234 * does not have to be perfect mapping since field is
1235 * informational, only used for servers that do not support
1236 * port 445 and it can be overridden at mount time
1238 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1239 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1240 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1242 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1243 /* null target name indicates to use *SMBSERVR default called name
1244 if we end up sending RFC1001 session initialize */
1245 vol->target_rfc1001_name[0] = 0;
1246 vol->cred_uid = current_uid();
1247 vol->linux_uid = current_uid();
1248 vol->linux_gid = current_gid();
1251 * default to SFM style remapping of seven reserved characters
1252 * unless user overrides it or we negotiate CIFS POSIX where
1253 * it is unnecessary. Can not simultaneously use more than one mapping
1254 * since then readdir could list files that open could not open
1258 /* default to only allowing write access to owner of the mount */
1259 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1261 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1262 /* default is always to request posix paths. */
1263 vol->posix_paths = 1;
1264 /* default to using server inode numbers where available */
1265 vol->server_ino = 1;
1267 /* default is to use strict cifs caching semantics */
1268 vol->strict_io = true;
1270 vol->actimeo = CIFS_DEF_ACTIMEO;
1272 /* FIXME: add autonegotiation -- for now, SMB1 is default */
1273 vol->ops = &smb1_operations;
1274 vol->vals = &smb1_values;
1277 goto cifs_parse_mount_err;
1279 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1280 if (!mountdata_copy)
1281 goto cifs_parse_mount_err;
1283 options = mountdata_copy;
1284 end = options + strlen(options);
1286 if (strncmp(options, "sep=", 4) == 0) {
1287 if (options[4] != 0) {
1288 separator[0] = options[4];
1291 cifs_dbg(FYI, "Null separator not allowed\n");
1294 vol->backupuid_specified = false; /* no backup intent for a user */
1295 vol->backupgid_specified = false; /* no backup intent for a group */
1297 switch (cifs_parse_devname(devname, vol)) {
1301 cifs_dbg(VFS, "Unable to allocate memory for devname.\n");
1302 goto cifs_parse_mount_err;
1304 cifs_dbg(VFS, "Malformed UNC in devname.\n");
1305 goto cifs_parse_mount_err;
1307 cifs_dbg(VFS, "Unknown error parsing devname.\n");
1308 goto cifs_parse_mount_err;
1311 while ((data = strsep(&options, separator)) != NULL) {
1312 substring_t args[MAX_OPT_ARGS];
1313 unsigned long option;
1319 token = match_token(data, cifs_mount_option_tokens, args);
1323 /* Ingnore the following */
1327 /* Boolean values */
1328 case Opt_user_xattr:
1331 case Opt_nouser_xattr:
1337 case Opt_noforceuid:
1343 case Opt_noforcegid:
1346 case Opt_noblocksend:
1347 vol->noblocksnd = 1;
1349 case Opt_noautotune:
1350 vol->noautotune = 1;
1365 vol->sfu_remap = true;
1366 vol->remap = false; /* disable SFM mapping */
1368 case Opt_nomapchars:
1369 vol->sfu_remap = false;
1373 vol->sfu_remap = false; /* disable SFU mapping */
1375 case Opt_nomapposix:
1387 case Opt_posixpaths:
1388 vol->posix_paths = 1;
1390 case Opt_noposixpaths:
1391 vol->posix_paths = 0;
1394 vol->no_linux_ext = 1;
1405 * turn off mandatory locking in mode
1406 * if remote locking is turned off since the
1407 * local vfs will do advisory
1409 if (vol->file_mode ==
1410 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1411 vol->file_mode = S_IALLUGO;
1413 case Opt_forcemandatorylock:
1423 vol->dynperm = true;
1426 vol->dynperm = false;
1440 case Opt_nostrictsync:
1441 vol->nostrictsync = 1;
1443 case Opt_strictsync:
1444 vol->nostrictsync = 0;
1447 vol->server_ino = 1;
1449 case Opt_noserverino:
1450 vol->server_ino = 0;
1452 case Opt_rwpidforward:
1453 vol->rwpidforward = 1;
1462 vol->no_psx_acl = 0;
1465 vol->no_psx_acl = 1;
1467 case Opt_locallease:
1468 vol->local_lease = 1;
1474 /* we do not do the following in secFlags because seal
1475 * is a per tree connection (mount) not a per socket
1476 * or per-smb connection option in the protocol
1477 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1482 pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1485 #ifndef CONFIG_CIFS_FSCACHE
1486 cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1487 goto cifs_parse_mount_err;
1491 case Opt_mfsymlinks:
1492 vol->mfsymlinks = true;
1495 vol->multiuser = true;
1500 case Opt_nosharesock:
1501 vol->nosharesock = true;
1503 case Opt_nopersistent:
1504 vol->nopersistent = true;
1505 if (vol->persistent) {
1507 "persistenthandles mount options conflict\n");
1508 goto cifs_parse_mount_err;
1511 case Opt_persistent:
1512 vol->persistent = true;
1513 if (vol->nopersistent) {
1515 "persistenthandles mount options conflict\n");
1516 goto cifs_parse_mount_err;
1520 /* Numeric Values */
1522 if (get_option_uid(args, &vol->backupuid)) {
1523 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
1525 goto cifs_parse_mount_err;
1527 vol->backupuid_specified = true;
1530 if (get_option_gid(args, &vol->backupgid)) {
1531 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
1533 goto cifs_parse_mount_err;
1535 vol->backupgid_specified = true;
1538 if (get_option_uid(args, &vol->linux_uid)) {
1539 cifs_dbg(VFS, "%s: Invalid uid value\n",
1541 goto cifs_parse_mount_err;
1543 uid_specified = true;
1546 if (get_option_uid(args, &vol->cred_uid)) {
1547 cifs_dbg(VFS, "%s: Invalid cruid value\n",
1549 goto cifs_parse_mount_err;
1553 if (get_option_gid(args, &vol->linux_gid)) {
1554 cifs_dbg(VFS, "%s: Invalid gid value\n",
1556 goto cifs_parse_mount_err;
1558 gid_specified = true;
1561 if (get_option_ul(args, &option)) {
1562 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
1564 goto cifs_parse_mount_err;
1566 vol->file_mode = option;
1569 if (get_option_ul(args, &option)) {
1570 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
1572 goto cifs_parse_mount_err;
1574 vol->dir_mode = option;
1577 if (get_option_ul(args, &option) ||
1578 option > USHRT_MAX) {
1579 cifs_dbg(VFS, "%s: Invalid port value\n",
1581 goto cifs_parse_mount_err;
1583 port = (unsigned short)option;
1586 if (get_option_ul(args, &option)) {
1587 cifs_dbg(VFS, "%s: Invalid rsize value\n",
1589 goto cifs_parse_mount_err;
1591 vol->rsize = option;
1594 if (get_option_ul(args, &option)) {
1595 cifs_dbg(VFS, "%s: Invalid wsize value\n",
1597 goto cifs_parse_mount_err;
1599 vol->wsize = option;
1602 if (get_option_ul(args, &option)) {
1603 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
1605 goto cifs_parse_mount_err;
1607 vol->actimeo = HZ * option;
1608 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1609 cifs_dbg(VFS, "attribute cache timeout too large\n");
1610 goto cifs_parse_mount_err;
1614 /* String Arguments */
1616 case Opt_blank_user:
1617 /* null user, ie. anonymous authentication */
1619 vol->username = NULL;
1622 string = match_strdup(args);
1626 if (strnlen(string, CIFS_MAX_USERNAME_LEN) >
1627 CIFS_MAX_USERNAME_LEN) {
1628 pr_warn("CIFS: username too long\n");
1629 goto cifs_parse_mount_err;
1632 kfree(vol->username);
1633 vol->username = kstrdup(string, GFP_KERNEL);
1635 goto cifs_parse_mount_err;
1637 case Opt_blank_pass:
1638 /* passwords have to be handled differently
1639 * to allow the character used for deliminator
1640 * to be passed within them
1644 * Check if this is a case where the password
1645 * starts with a delimiter
1647 tmp_end = strchr(data, '=');
1649 if (!(tmp_end < end && tmp_end[1] == delim)) {
1650 /* No it is not. Set the password to NULL */
1651 kfree(vol->password);
1652 vol->password = NULL;
1655 /* Yes it is. Drop down to Opt_pass below.*/
1657 /* Obtain the value string */
1658 value = strchr(data, '=');
1661 /* Set tmp_end to end of the string */
1662 tmp_end = (char *) value + strlen(value);
1664 /* Check if following character is the deliminator
1665 * If yes, we have encountered a double deliminator
1666 * reset the NULL character to the deliminator
1668 if (tmp_end < end && tmp_end[1] == delim) {
1671 /* Keep iterating until we get to a single
1672 * deliminator OR the end
1674 while ((tmp_end = strchr(tmp_end, delim))
1675 != NULL && (tmp_end[1] == delim)) {
1676 tmp_end = (char *) &tmp_end[2];
1679 /* Reset var options to point to next element */
1682 options = (char *) &tmp_end[1];
1684 /* Reached the end of the mount option
1689 kfree(vol->password);
1690 /* Now build new password string */
1691 temp_len = strlen(value);
1692 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1693 if (vol->password == NULL) {
1694 pr_warn("CIFS: no memory for password\n");
1695 goto cifs_parse_mount_err;
1698 for (i = 0, j = 0; i < temp_len; i++, j++) {
1699 vol->password[j] = value[i];
1700 if ((value[i] == delim) &&
1701 value[i+1] == delim)
1702 /* skip the second deliminator */
1705 vol->password[j] = '\0';
1708 /* FIXME: should this be an error instead? */
1712 string = match_strdup(args);
1716 if (!cifs_convert_address(dstaddr, string,
1718 pr_err("CIFS: bad ip= option (%s).\n", string);
1719 goto cifs_parse_mount_err;
1724 string = match_strdup(args);
1728 if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
1729 == CIFS_MAX_DOMAINNAME_LEN) {
1730 pr_warn("CIFS: domain name too long\n");
1731 goto cifs_parse_mount_err;
1734 kfree(vol->domainname);
1735 vol->domainname = kstrdup(string, GFP_KERNEL);
1736 if (!vol->domainname) {
1737 pr_warn("CIFS: no memory for domainname\n");
1738 goto cifs_parse_mount_err;
1740 cifs_dbg(FYI, "Domain name set\n");
1743 string = match_strdup(args);
1747 if (!cifs_convert_address(
1748 (struct sockaddr *)&vol->srcaddr,
1749 string, strlen(string))) {
1750 pr_warn("CIFS: Could not parse srcaddr: %s\n",
1752 goto cifs_parse_mount_err;
1756 string = match_strdup(args);
1760 if (strnlen(string, 1024) >= 65) {
1761 pr_warn("CIFS: iocharset name too long.\n");
1762 goto cifs_parse_mount_err;
1765 if (strncasecmp(string, "default", 7) != 0) {
1766 kfree(vol->iocharset);
1767 vol->iocharset = kstrdup(string,
1769 if (!vol->iocharset) {
1770 pr_warn("CIFS: no memory for charset\n");
1771 goto cifs_parse_mount_err;
1774 /* if iocharset not set then load_nls_default
1777 cifs_dbg(FYI, "iocharset set to %s\n", string);
1779 case Opt_netbiosname:
1780 string = match_strdup(args);
1784 memset(vol->source_rfc1001_name, 0x20,
1787 * FIXME: are there cases in which a comma can
1788 * be valid in workstation netbios name (and
1789 * need special handling)?
1791 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1792 /* don't ucase netbiosname for user */
1795 vol->source_rfc1001_name[i] = string[i];
1797 /* The string has 16th byte zero still from
1798 * set at top of the function
1800 if (i == RFC1001_NAME_LEN && string[i] != 0)
1801 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
1804 /* servernetbiosname specified override *SMBSERVER */
1805 string = match_strdup(args);
1809 /* last byte, type, is 0x20 for servr type */
1810 memset(vol->target_rfc1001_name, 0x20,
1811 RFC1001_NAME_LEN_WITH_NULL);
1813 /* BB are there cases in which a comma can be
1814 valid in this workstation netbios name
1815 (and need special handling)? */
1817 /* user or mount helper must uppercase the
1819 for (i = 0; i < 15; i++) {
1822 vol->target_rfc1001_name[i] = string[i];
1824 /* The string has 16th byte zero still from
1825 set at top of the function */
1826 if (i == RFC1001_NAME_LEN && string[i] != 0)
1827 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
1830 string = match_strdup(args);
1834 if (strncasecmp(string, "1", 1) == 0) {
1835 /* This is the default */
1838 /* For all other value, error */
1839 pr_warn("CIFS: Invalid version specified\n");
1840 goto cifs_parse_mount_err;
1842 string = match_strdup(args);
1846 if (cifs_parse_smb_version(string, vol) != 0)
1847 goto cifs_parse_mount_err;
1850 string = match_strdup(args);
1854 if (cifs_parse_security_flavors(string, vol) != 0)
1855 goto cifs_parse_mount_err;
1858 string = match_strdup(args);
1862 if (cifs_parse_cache_flavor(string, vol) != 0)
1863 goto cifs_parse_mount_err;
1867 * An option we don't recognize. Save it off for later
1868 * if we haven't already found one
1874 /* Free up any allocated string */
1879 if (!sloppy && invalid) {
1880 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid);
1881 goto cifs_parse_mount_err;
1885 /* Muliuser mounts require CONFIG_KEYS support */
1886 if (vol->multiuser) {
1887 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
1888 goto cifs_parse_mount_err;
1892 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
1893 goto cifs_parse_mount_err;
1896 /* make sure UNC has a share name */
1897 if (!strchr(vol->UNC + 3, '\\')) {
1898 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
1899 goto cifs_parse_mount_err;
1903 /* No ip= option specified? Try to get it from UNC */
1904 if (!cifs_convert_address(dstaddr, &vol->UNC[2],
1905 strlen(&vol->UNC[2]))) {
1906 pr_err("Unable to determine destination address.\n");
1907 goto cifs_parse_mount_err;
1911 /* set the port that we got earlier */
1912 cifs_set_port(dstaddr, port);
1915 vol->override_uid = override_uid;
1916 else if (override_uid == 1)
1917 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
1920 vol->override_gid = override_gid;
1921 else if (override_gid == 1)
1922 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
1924 kfree(mountdata_copy);
1928 pr_warn("Could not allocate temporary buffer\n");
1929 cifs_parse_mount_err:
1931 kfree(mountdata_copy);
1935 /** Returns true if srcaddr isn't specified and rhs isn't
1936 * specified, or if srcaddr is specified and
1937 * matches the IP address of the rhs argument.
1940 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1942 switch (srcaddr->sa_family) {
1944 return (rhs->sa_family == AF_UNSPEC);
1946 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1947 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1948 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1951 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1952 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
1953 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1957 return false; /* don't expect to be here */
1962 * If no port is specified in addr structure, we try to match with 445 port
1963 * and if it fails - with 139 ports. It should be called only if address
1964 * families of server and addr are equal.
1967 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1969 __be16 port, *sport;
1971 switch (addr->sa_family) {
1973 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1974 port = ((struct sockaddr_in *) addr)->sin_port;
1977 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1978 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1986 port = htons(CIFS_PORT);
1990 port = htons(RFC1001_PORT);
1993 return port == *sport;
1997 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1998 struct sockaddr *srcaddr)
2000 switch (addr->sa_family) {
2002 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2003 struct sockaddr_in *srv_addr4 =
2004 (struct sockaddr_in *)&server->dstaddr;
2006 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
2011 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2012 struct sockaddr_in6 *srv_addr6 =
2013 (struct sockaddr_in6 *)&server->dstaddr;
2015 if (!ipv6_addr_equal(&addr6->sin6_addr,
2016 &srv_addr6->sin6_addr))
2018 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
2024 return false; /* don't expect to be here */
2027 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2034 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2037 * The select_sectype function should either return the vol->sectype
2038 * that was specified, or "Unspecified" if that sectype was not
2039 * compatible with the given NEGOTIATE request.
2041 if (select_sectype(server, vol->sectype) == Unspecified)
2045 * Now check if signing mode is acceptable. No need to check
2046 * global_secflags at this point since if MUST_SIGN is set then
2047 * the server->sign had better be too.
2049 if (vol->sign && !server->sign)
2055 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2057 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2059 if (vol->nosharesock)
2062 if ((server->vals != vol->vals) || (server->ops != vol->ops))
2065 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2068 if (!match_address(server, addr,
2069 (struct sockaddr *)&vol->srcaddr))
2072 if (!match_port(server, addr))
2075 if (!match_security(server, vol))
2081 static struct TCP_Server_Info *
2082 cifs_find_tcp_session(struct smb_vol *vol)
2084 struct TCP_Server_Info *server;
2086 spin_lock(&cifs_tcp_ses_lock);
2087 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2088 if (!match_server(server, vol))
2091 ++server->srv_count;
2092 spin_unlock(&cifs_tcp_ses_lock);
2093 cifs_dbg(FYI, "Existing tcp session with server found\n");
2096 spin_unlock(&cifs_tcp_ses_lock);
2101 cifs_put_tcp_session(struct TCP_Server_Info *server)
2103 struct task_struct *task;
2105 spin_lock(&cifs_tcp_ses_lock);
2106 if (--server->srv_count > 0) {
2107 spin_unlock(&cifs_tcp_ses_lock);
2111 put_net(cifs_net_ns(server));
2113 list_del_init(&server->tcp_ses_list);
2114 spin_unlock(&cifs_tcp_ses_lock);
2116 cancel_delayed_work_sync(&server->echo);
2118 spin_lock(&GlobalMid_Lock);
2119 server->tcpStatus = CifsExiting;
2120 spin_unlock(&GlobalMid_Lock);
2122 cifs_crypto_shash_release(server);
2123 cifs_fscache_release_client_cookie(server);
2125 kfree(server->session_key.response);
2126 server->session_key.response = NULL;
2127 server->session_key.len = 0;
2129 task = xchg(&server->tsk, NULL);
2131 force_sig(SIGKILL, task);
2134 static struct TCP_Server_Info *
2135 cifs_get_tcp_session(struct smb_vol *volume_info)
2137 struct TCP_Server_Info *tcp_ses = NULL;
2140 cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
2142 /* see if we already have a matching tcp_ses */
2143 tcp_ses = cifs_find_tcp_session(volume_info);
2147 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2153 tcp_ses->ops = volume_info->ops;
2154 tcp_ses->vals = volume_info->vals;
2155 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2156 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2157 if (IS_ERR(tcp_ses->hostname)) {
2158 rc = PTR_ERR(tcp_ses->hostname);
2159 goto out_err_crypto_release;
2162 tcp_ses->noblocksnd = volume_info->noblocksnd;
2163 tcp_ses->noautotune = volume_info->noautotune;
2164 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2165 tcp_ses->in_flight = 0;
2166 tcp_ses->credits = 1;
2167 init_waitqueue_head(&tcp_ses->response_q);
2168 init_waitqueue_head(&tcp_ses->request_q);
2169 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2170 mutex_init(&tcp_ses->srv_mutex);
2171 memcpy(tcp_ses->workstation_RFC1001_name,
2172 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2173 memcpy(tcp_ses->server_RFC1001_name,
2174 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2175 tcp_ses->session_estab = false;
2176 tcp_ses->sequence_number = 0;
2177 tcp_ses->lstrp = jiffies;
2178 spin_lock_init(&tcp_ses->req_lock);
2179 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2180 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2181 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2182 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2183 sizeof(tcp_ses->srcaddr));
2184 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2185 sizeof(tcp_ses->dstaddr));
2186 #ifdef CONFIG_CIFS_SMB2
2187 get_random_bytes(tcp_ses->client_guid, SMB2_CLIENT_GUID_SIZE);
2190 * at this point we are the only ones with the pointer
2191 * to the struct since the kernel thread not created yet
2192 * no need to spinlock this init of tcpStatus or srv_count
2194 tcp_ses->tcpStatus = CifsNew;
2195 ++tcp_ses->srv_count;
2197 rc = ip_connect(tcp_ses);
2199 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
2200 goto out_err_crypto_release;
2204 * since we're in a cifs function already, we know that
2205 * this will succeed. No need for try_module_get().
2207 __module_get(THIS_MODULE);
2208 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2210 if (IS_ERR(tcp_ses->tsk)) {
2211 rc = PTR_ERR(tcp_ses->tsk);
2212 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
2213 module_put(THIS_MODULE);
2214 goto out_err_crypto_release;
2216 tcp_ses->tcpStatus = CifsNeedNegotiate;
2218 /* thread spawned, put it on the list */
2219 spin_lock(&cifs_tcp_ses_lock);
2220 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2221 spin_unlock(&cifs_tcp_ses_lock);
2223 cifs_fscache_get_client_cookie(tcp_ses);
2225 /* queue echo request delayed work */
2226 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
2230 out_err_crypto_release:
2231 cifs_crypto_shash_release(tcp_ses);
2233 put_net(cifs_net_ns(tcp_ses));
2237 if (!IS_ERR(tcp_ses->hostname))
2238 kfree(tcp_ses->hostname);
2239 if (tcp_ses->ssocket)
2240 sock_release(tcp_ses->ssocket);
2246 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2248 if (vol->sectype != Unspecified &&
2249 vol->sectype != ses->sectype)
2252 switch (ses->sectype) {
2254 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2258 /* NULL username means anonymous session */
2259 if (ses->user_name == NULL) {
2265 /* anything else takes username/password */
2266 if (strncmp(ses->user_name,
2267 vol->username ? vol->username : "",
2268 CIFS_MAX_USERNAME_LEN))
2270 if ((vol->username && strlen(vol->username) != 0) &&
2271 ses->password != NULL &&
2272 strncmp(ses->password,
2273 vol->password ? vol->password : "",
2274 CIFS_MAX_PASSWORD_LEN))
2280 static struct cifs_ses *
2281 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2283 struct cifs_ses *ses;
2285 spin_lock(&cifs_tcp_ses_lock);
2286 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2287 if (ses->status == CifsExiting)
2289 if (!match_session(ses, vol))
2292 spin_unlock(&cifs_tcp_ses_lock);
2295 spin_unlock(&cifs_tcp_ses_lock);
2300 cifs_put_smb_ses(struct cifs_ses *ses)
2302 unsigned int rc, xid;
2303 struct TCP_Server_Info *server = ses->server;
2305 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
2307 spin_lock(&cifs_tcp_ses_lock);
2308 if (ses->status == CifsExiting) {
2309 spin_unlock(&cifs_tcp_ses_lock);
2312 if (--ses->ses_count > 0) {
2313 spin_unlock(&cifs_tcp_ses_lock);
2316 if (ses->status == CifsGood)
2317 ses->status = CifsExiting;
2318 spin_unlock(&cifs_tcp_ses_lock);
2320 if (ses->status == CifsExiting && server->ops->logoff) {
2322 rc = server->ops->logoff(xid, ses);
2324 cifs_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
2329 spin_lock(&cifs_tcp_ses_lock);
2330 list_del_init(&ses->smb_ses_list);
2331 spin_unlock(&cifs_tcp_ses_lock);
2334 cifs_put_tcp_session(server);
2339 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2340 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2342 /* Populate username and pw fields from keyring if possible */
2344 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2347 char *desc, *delim, *payload;
2350 struct TCP_Server_Info *server = ses->server;
2351 struct sockaddr_in *sa;
2352 struct sockaddr_in6 *sa6;
2353 struct user_key_payload *upayload;
2355 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2359 /* try to find an address key first */
2360 switch (server->dstaddr.ss_family) {
2362 sa = (struct sockaddr_in *)&server->dstaddr;
2363 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2366 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2367 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2370 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2371 server->dstaddr.ss_family);
2376 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2377 key = request_key(&key_type_logon, desc, "");
2379 if (!ses->domainName) {
2380 cifs_dbg(FYI, "domainName is NULL\n");
2385 /* didn't work, try to find a domain key */
2386 sprintf(desc, "cifs:d:%s", ses->domainName);
2387 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2388 key = request_key(&key_type_logon, desc, "");
2395 down_read(&key->sem);
2396 upayload = key->payload.data;
2397 if (IS_ERR_OR_NULL(upayload)) {
2398 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2402 /* find first : in payload */
2403 payload = (char *)upayload->data;
2404 delim = strnchr(payload, upayload->datalen, ':');
2405 cifs_dbg(FYI, "payload=%s\n", payload);
2407 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
2413 len = delim - payload;
2414 if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
2415 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
2421 vol->username = kstrndup(payload, len, GFP_KERNEL);
2422 if (!vol->username) {
2423 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
2428 cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
2430 len = key->datalen - (len + 1);
2431 if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
2432 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
2434 kfree(vol->username);
2435 vol->username = NULL;
2440 vol->password = kstrndup(delim, len, GFP_KERNEL);
2441 if (!vol->password) {
2442 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
2445 kfree(vol->username);
2446 vol->username = NULL;
2455 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
2458 #else /* ! CONFIG_KEYS */
2460 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2461 struct cifs_ses *ses __attribute__((unused)))
2465 #endif /* CONFIG_KEYS */
2467 static struct cifs_ses *
2468 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2472 struct cifs_ses *ses;
2473 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2474 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2478 ses = cifs_find_smb_ses(server, volume_info);
2480 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
2483 mutex_lock(&ses->session_mutex);
2484 rc = cifs_negotiate_protocol(xid, ses);
2486 mutex_unlock(&ses->session_mutex);
2487 /* problem -- put our ses reference */
2488 cifs_put_smb_ses(ses);
2492 if (ses->need_reconnect) {
2493 cifs_dbg(FYI, "Session needs reconnect\n");
2494 rc = cifs_setup_session(xid, ses,
2495 volume_info->local_nls);
2497 mutex_unlock(&ses->session_mutex);
2498 /* problem -- put our reference */
2499 cifs_put_smb_ses(ses);
2504 mutex_unlock(&ses->session_mutex);
2506 /* existing SMB ses has a server reference already */
2507 cifs_put_tcp_session(server);
2512 cifs_dbg(FYI, "Existing smb sess not found\n");
2513 ses = sesInfoAlloc();
2517 /* new SMB session uses our server ref */
2518 ses->server = server;
2519 if (server->dstaddr.ss_family == AF_INET6)
2520 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2522 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2524 if (volume_info->username) {
2525 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2526 if (!ses->user_name)
2530 /* volume_info->password freed at unmount */
2531 if (volume_info->password) {
2532 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2536 if (volume_info->domainname) {
2537 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2538 if (!ses->domainName)
2541 ses->cred_uid = volume_info->cred_uid;
2542 ses->linux_uid = volume_info->linux_uid;
2544 ses->sectype = volume_info->sectype;
2545 ses->sign = volume_info->sign;
2547 mutex_lock(&ses->session_mutex);
2548 rc = cifs_negotiate_protocol(xid, ses);
2550 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2551 mutex_unlock(&ses->session_mutex);
2555 /* success, put it on the list */
2556 spin_lock(&cifs_tcp_ses_lock);
2557 list_add(&ses->smb_ses_list, &server->smb_ses_list);
2558 spin_unlock(&cifs_tcp_ses_lock);
2569 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2571 if (tcon->tidStatus == CifsExiting)
2573 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2578 static struct cifs_tcon *
2579 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2581 struct list_head *tmp;
2582 struct cifs_tcon *tcon;
2584 spin_lock(&cifs_tcp_ses_lock);
2585 list_for_each(tmp, &ses->tcon_list) {
2586 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2587 if (!match_tcon(tcon, unc))
2590 spin_unlock(&cifs_tcp_ses_lock);
2593 spin_unlock(&cifs_tcp_ses_lock);
2598 cifs_put_tcon(struct cifs_tcon *tcon)
2601 struct cifs_ses *ses = tcon->ses;
2603 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2604 spin_lock(&cifs_tcp_ses_lock);
2605 if (--tcon->tc_count > 0) {
2606 spin_unlock(&cifs_tcp_ses_lock);
2610 list_del_init(&tcon->tcon_list);
2611 spin_unlock(&cifs_tcp_ses_lock);
2614 if (ses->server->ops->tree_disconnect)
2615 ses->server->ops->tree_disconnect(xid, tcon);
2618 cifs_fscache_release_super_cookie(tcon);
2620 cifs_put_smb_ses(ses);
2623 static struct cifs_tcon *
2624 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2627 struct cifs_tcon *tcon;
2629 tcon = cifs_find_tcon(ses, volume_info->UNC);
2631 cifs_dbg(FYI, "Found match on UNC path\n");
2632 /* existing tcon already has a reference */
2633 cifs_put_smb_ses(ses);
2634 if (tcon->seal != volume_info->seal)
2635 cifs_dbg(VFS, "transport encryption setting conflicts with existing tid\n");
2639 if (!ses->server->ops->tree_connect) {
2644 tcon = tconInfoAlloc();
2651 if (volume_info->password) {
2652 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2653 if (!tcon->password) {
2660 * BB Do we need to wrap session_mutex around this TCon call and Unix
2661 * SetFS as we do on SessSetup and reconnect?
2664 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2665 volume_info->local_nls);
2667 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
2671 if (volume_info->nodfs) {
2672 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2673 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
2675 tcon->seal = volume_info->seal;
2676 tcon->use_persistent = false;
2677 /* check if SMB2 or later, CIFS does not support persistent handles */
2678 if (volume_info->persistent) {
2679 if (ses->server->vals->protocol_id == 0) {
2681 "SMB3 or later required for persistent handles\n");
2684 } else if (ses->server->capabilities &
2685 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2686 tcon->use_persistent = true;
2687 else /* persistent handles requested but not supported */ {
2689 "Persistent handles not supported on share\n");
2693 } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
2694 && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2695 && (volume_info->nopersistent == false)) {
2696 cifs_dbg(FYI, "enabling persistent handles\n");
2697 tcon->use_persistent = true;
2701 * We can have only one retry value for a connection to a share so for
2702 * resources mounted more than once to the same server share the last
2703 * value passed in for the retry flag is used.
2705 tcon->retry = volume_info->retry;
2706 tcon->nocase = volume_info->nocase;
2707 tcon->local_lease = volume_info->local_lease;
2708 INIT_LIST_HEAD(&tcon->pending_opens);
2710 spin_lock(&cifs_tcp_ses_lock);
2711 list_add(&tcon->tcon_list, &ses->tcon_list);
2712 spin_unlock(&cifs_tcp_ses_lock);
2714 cifs_fscache_get_super_cookie(tcon);
2724 cifs_put_tlink(struct tcon_link *tlink)
2726 if (!tlink || IS_ERR(tlink))
2729 if (!atomic_dec_and_test(&tlink->tl_count) ||
2730 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2731 tlink->tl_time = jiffies;
2735 if (!IS_ERR(tlink_tcon(tlink)))
2736 cifs_put_tcon(tlink_tcon(tlink));
2741 static inline struct tcon_link *
2742 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2744 return cifs_sb->master_tlink;
2748 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2750 struct cifs_sb_info *old = CIFS_SB(sb);
2751 struct cifs_sb_info *new = mnt_data->cifs_sb;
2753 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2756 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2757 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2761 * We want to share sb only if we don't specify an r/wsize or
2762 * specified r/wsize is greater than or equal to existing one.
2764 if (new->wsize && new->wsize < old->wsize)
2767 if (new->rsize && new->rsize < old->rsize)
2770 if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
2773 if (old->mnt_file_mode != new->mnt_file_mode ||
2774 old->mnt_dir_mode != new->mnt_dir_mode)
2777 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2780 if (old->actimeo != new->actimeo)
2787 cifs_match_super(struct super_block *sb, void *data)
2789 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2790 struct smb_vol *volume_info;
2791 struct cifs_sb_info *cifs_sb;
2792 struct TCP_Server_Info *tcp_srv;
2793 struct cifs_ses *ses;
2794 struct cifs_tcon *tcon;
2795 struct tcon_link *tlink;
2798 spin_lock(&cifs_tcp_ses_lock);
2799 cifs_sb = CIFS_SB(sb);
2800 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2801 if (IS_ERR(tlink)) {
2802 spin_unlock(&cifs_tcp_ses_lock);
2805 tcon = tlink_tcon(tlink);
2807 tcp_srv = ses->server;
2809 volume_info = mnt_data->vol;
2811 if (!match_server(tcp_srv, volume_info) ||
2812 !match_session(ses, volume_info) ||
2813 !match_tcon(tcon, volume_info->UNC)) {
2818 rc = compare_mount_options(sb, mnt_data);
2820 spin_unlock(&cifs_tcp_ses_lock);
2821 cifs_put_tlink(tlink);
2826 get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
2827 const struct nls_table *nls_codepage, unsigned int *num_referrals,
2828 struct dfs_info3_param **referrals, int remap)
2833 if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
2839 if (ses->ipc_tid == 0) {
2840 temp_unc = kmalloc(2 /* for slashes */ +
2841 strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2842 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
2843 if (temp_unc == NULL)
2847 strcpy(temp_unc + 2, ses->serverName);
2848 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2849 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2851 cifs_dbg(FYI, "Tcon rc = %d ipc_tid = %d\n", rc, ses->ipc_tid);
2855 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
2856 referrals, num_referrals,
2857 nls_codepage, remap);
2859 * BB - map targetUNCs to dfs_info3 structures, here or in
2860 * ses->server->ops->get_dfs_refer.
2866 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2867 static struct lock_class_key cifs_key[2];
2868 static struct lock_class_key cifs_slock_key[2];
2871 cifs_reclassify_socket4(struct socket *sock)
2873 struct sock *sk = sock->sk;
2874 BUG_ON(sock_owned_by_user(sk));
2875 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2876 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2880 cifs_reclassify_socket6(struct socket *sock)
2882 struct sock *sk = sock->sk;
2883 BUG_ON(sock_owned_by_user(sk));
2884 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2885 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2889 cifs_reclassify_socket4(struct socket *sock)
2894 cifs_reclassify_socket6(struct socket *sock)
2899 /* See RFC1001 section 14 on representation of Netbios names */
2900 static void rfc1002mangle(char *target, char *source, unsigned int length)
2904 for (i = 0, j = 0; i < (length); i++) {
2905 /* mask a nibble at a time and encode */
2906 target[j] = 'A' + (0x0F & (source[i] >> 4));
2907 target[j+1] = 'A' + (0x0F & source[i]);
2914 bind_socket(struct TCP_Server_Info *server)
2917 if (server->srcaddr.ss_family != AF_UNSPEC) {
2918 /* Bind to the specified local IP address */
2919 struct socket *socket = server->ssocket;
2920 rc = socket->ops->bind(socket,
2921 (struct sockaddr *) &server->srcaddr,
2922 sizeof(server->srcaddr));
2924 struct sockaddr_in *saddr4;
2925 struct sockaddr_in6 *saddr6;
2926 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2927 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2928 if (saddr6->sin6_family == AF_INET6)
2929 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
2930 &saddr6->sin6_addr, rc);
2932 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
2933 &saddr4->sin_addr.s_addr, rc);
2940 ip_rfc1001_connect(struct TCP_Server_Info *server)
2944 * some servers require RFC1001 sessinit before sending
2945 * negprot - BB check reconnection in case where second
2946 * sessinit is sent but no second negprot
2948 struct rfc1002_session_packet *ses_init_buf;
2949 struct smb_hdr *smb_buf;
2950 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2953 ses_init_buf->trailer.session_req.called_len = 32;
2955 if (server->server_RFC1001_name &&
2956 server->server_RFC1001_name[0] != 0)
2957 rfc1002mangle(ses_init_buf->trailer.
2958 session_req.called_name,
2959 server->server_RFC1001_name,
2960 RFC1001_NAME_LEN_WITH_NULL);
2962 rfc1002mangle(ses_init_buf->trailer.
2963 session_req.called_name,
2964 DEFAULT_CIFS_CALLED_NAME,
2965 RFC1001_NAME_LEN_WITH_NULL);
2967 ses_init_buf->trailer.session_req.calling_len = 32;
2970 * calling name ends in null (byte 16) from old smb
2973 if (server->workstation_RFC1001_name[0] != 0)
2974 rfc1002mangle(ses_init_buf->trailer.
2975 session_req.calling_name,
2976 server->workstation_RFC1001_name,
2977 RFC1001_NAME_LEN_WITH_NULL);
2979 rfc1002mangle(ses_init_buf->trailer.
2980 session_req.calling_name,
2982 RFC1001_NAME_LEN_WITH_NULL);
2984 ses_init_buf->trailer.session_req.scope1 = 0;
2985 ses_init_buf->trailer.session_req.scope2 = 0;
2986 smb_buf = (struct smb_hdr *)ses_init_buf;
2988 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2989 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
2990 rc = smb_send(server, smb_buf, 0x44);
2991 kfree(ses_init_buf);
2993 * RFC1001 layer in at least one server
2994 * requires very short break before negprot
2995 * presumably because not expecting negprot
2996 * to follow so fast. This is a simple
2997 * solution that works without
2998 * complicating the code and causes no
2999 * significant slowing down on mount
3002 usleep_range(1000, 2000);
3005 * else the negprot may still work without this
3006 * even though malloc failed
3013 generic_ip_connect(struct TCP_Server_Info *server)
3018 struct socket *socket = server->ssocket;
3019 struct sockaddr *saddr;
3021 saddr = (struct sockaddr *) &server->dstaddr;
3023 if (server->dstaddr.ss_family == AF_INET6) {
3024 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3025 slen = sizeof(struct sockaddr_in6);
3028 sport = ((struct sockaddr_in *) saddr)->sin_port;
3029 slen = sizeof(struct sockaddr_in);
3033 if (socket == NULL) {
3034 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3035 IPPROTO_TCP, &socket, 1);
3037 cifs_dbg(VFS, "Error %d creating socket\n", rc);
3038 server->ssocket = NULL;
3042 /* BB other socket options to set KEEPALIVE, NODELAY? */
3043 cifs_dbg(FYI, "Socket created\n");
3044 server->ssocket = socket;
3045 socket->sk->sk_allocation = GFP_NOFS;
3046 if (sfamily == AF_INET6)
3047 cifs_reclassify_socket6(socket);
3049 cifs_reclassify_socket4(socket);
3052 rc = bind_socket(server);
3057 * Eventually check for other socket options to change from
3058 * the default. sock_setsockopt not used because it expects
3061 socket->sk->sk_rcvtimeo = 7 * HZ;
3062 socket->sk->sk_sndtimeo = 5 * HZ;
3064 /* make the bufsizes depend on wsize/rsize and max requests */
3065 if (server->noautotune) {
3066 if (socket->sk->sk_sndbuf < (200 * 1024))
3067 socket->sk->sk_sndbuf = 200 * 1024;
3068 if (socket->sk->sk_rcvbuf < (140 * 1024))
3069 socket->sk->sk_rcvbuf = 140 * 1024;
3072 if (server->tcp_nodelay) {
3074 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3075 (char *)&val, sizeof(val));
3077 cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3081 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3082 socket->sk->sk_sndbuf,
3083 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3085 rc = socket->ops->connect(socket, saddr, slen, 0);
3087 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3088 sock_release(socket);
3089 server->ssocket = NULL;
3093 if (sport == htons(RFC1001_PORT))
3094 rc = ip_rfc1001_connect(server);
3100 ip_connect(struct TCP_Server_Info *server)
3103 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3104 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3106 if (server->dstaddr.ss_family == AF_INET6)
3107 sport = &addr6->sin6_port;
3109 sport = &addr->sin_port;
3114 /* try with 445 port at first */
3115 *sport = htons(CIFS_PORT);
3117 rc = generic_ip_connect(server);
3121 /* if it failed, try with 139 port */
3122 *sport = htons(RFC1001_PORT);
3125 return generic_ip_connect(server);
3128 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3129 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3131 /* if we are reconnecting then should we check to see if
3132 * any requested capabilities changed locally e.g. via
3133 * remount but we can not do much about it here
3134 * if they have (even if we could detect it by the following)
3135 * Perhaps we could add a backpointer to array of sb from tcon
3136 * or if we change to make all sb to same share the same
3137 * sb as NFS - then we only have one backpointer to sb.
3138 * What if we wanted to mount the server share twice once with
3139 * and once without posixacls or posix paths? */
3140 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3142 if (vol_info && vol_info->no_linux_ext) {
3143 tcon->fsUnixInfo.Capability = 0;
3144 tcon->unix_ext = 0; /* Unix Extensions disabled */
3145 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
3147 } else if (vol_info)
3148 tcon->unix_ext = 1; /* Unix Extensions supported */
3150 if (tcon->unix_ext == 0) {
3151 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
3155 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3156 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3157 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
3158 /* check for reconnect case in which we do not
3159 want to change the mount behavior if we can avoid it */
3160 if (vol_info == NULL) {
3161 /* turn off POSIX ACL and PATHNAMES if not set
3162 originally at mount time */
3163 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3164 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3165 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3166 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3167 cifs_dbg(VFS, "POSIXPATH support change\n");
3168 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3169 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3170 cifs_dbg(VFS, "possible reconnect error\n");
3171 cifs_dbg(VFS, "server disabled POSIX path support\n");
3175 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3176 cifs_dbg(VFS, "per-share encryption not supported yet\n");
3178 cap &= CIFS_UNIX_CAP_MASK;
3179 if (vol_info && vol_info->no_psx_acl)
3180 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3181 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3182 cifs_dbg(FYI, "negotiated posix acl support\n");
3184 cifs_sb->mnt_cifs_flags |=
3185 CIFS_MOUNT_POSIXACL;
3188 if (vol_info && vol_info->posix_paths == 0)
3189 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3190 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3191 cifs_dbg(FYI, "negotiate posix pathnames\n");
3193 cifs_sb->mnt_cifs_flags |=
3194 CIFS_MOUNT_POSIX_PATHS;
3197 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
3198 #ifdef CONFIG_CIFS_DEBUG2
3199 if (cap & CIFS_UNIX_FCNTL_CAP)
3200 cifs_dbg(FYI, "FCNTL cap\n");
3201 if (cap & CIFS_UNIX_EXTATTR_CAP)
3202 cifs_dbg(FYI, "EXTATTR cap\n");
3203 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3204 cifs_dbg(FYI, "POSIX path cap\n");
3205 if (cap & CIFS_UNIX_XATTR_CAP)
3206 cifs_dbg(FYI, "XATTR cap\n");
3207 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3208 cifs_dbg(FYI, "POSIX ACL cap\n");
3209 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3210 cifs_dbg(FYI, "very large read cap\n");
3211 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3212 cifs_dbg(FYI, "very large write cap\n");
3213 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3214 cifs_dbg(FYI, "transport encryption cap\n");
3215 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3216 cifs_dbg(FYI, "mandatory transport encryption cap\n");
3217 #endif /* CIFS_DEBUG2 */
3218 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3219 if (vol_info == NULL) {
3220 cifs_dbg(FYI, "resetting capabilities failed\n");
3222 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");
3228 void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3229 struct cifs_sb_info *cifs_sb)
3231 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3233 spin_lock_init(&cifs_sb->tlink_tree_lock);
3234 cifs_sb->tlink_tree = RB_ROOT;
3237 * Temporarily set r/wsize for matching superblock. If we end up using
3238 * new sb then client will later negotiate it downward if needed.
3240 cifs_sb->rsize = pvolume_info->rsize;
3241 cifs_sb->wsize = pvolume_info->wsize;
3243 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3244 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3245 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3246 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3247 cifs_dbg(FYI, "file mode: 0x%hx dir mode: 0x%hx\n",
3248 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3250 cifs_sb->actimeo = pvolume_info->actimeo;
3251 cifs_sb->local_nls = pvolume_info->local_nls;
3253 if (pvolume_info->noperm)
3254 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3255 if (pvolume_info->setuids)
3256 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3257 if (pvolume_info->server_ino)
3258 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3259 if (pvolume_info->remap)
3260 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3261 if (pvolume_info->sfu_remap)
3262 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3263 if (pvolume_info->no_xattr)
3264 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3265 if (pvolume_info->sfu_emul)
3266 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3267 if (pvolume_info->nobrl)
3268 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3269 if (pvolume_info->nostrictsync)
3270 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3271 if (pvolume_info->mand_lock)
3272 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3273 if (pvolume_info->rwpidforward)
3274 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3275 if (pvolume_info->cifs_acl)
3276 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3277 if (pvolume_info->backupuid_specified) {
3278 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3279 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3281 if (pvolume_info->backupgid_specified) {
3282 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3283 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3285 if (pvolume_info->override_uid)
3286 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3287 if (pvolume_info->override_gid)
3288 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3289 if (pvolume_info->dynperm)
3290 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3291 if (pvolume_info->fsc)
3292 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3293 if (pvolume_info->multiuser)
3294 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3295 CIFS_MOUNT_NO_PERM);
3296 if (pvolume_info->strict_io)
3297 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3298 if (pvolume_info->direct_io) {
3299 cifs_dbg(FYI, "mounting share using direct i/o\n");
3300 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3302 if (pvolume_info->mfsymlinks) {
3303 if (pvolume_info->sfu_emul) {
3305 * Our SFU ("Services for Unix" emulation does not allow
3306 * creating symlinks but does allow reading existing SFU
3307 * symlinks (it does allow both creating and reading SFU
3308 * style mknod and FIFOs though). When "mfsymlinks" and
3309 * "sfu" are both enabled at the same time, it allows
3310 * reading both types of symlinks, but will only create
3311 * them with mfsymlinks format. This allows better
3312 * Apple compatibility (probably better for Samba too)
3313 * while still recognizing old Windows style symlinks.
3315 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
3317 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3320 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3321 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
3325 cleanup_volume_info_contents(struct smb_vol *volume_info)
3327 kfree(volume_info->username);
3328 kzfree(volume_info->password);
3329 kfree(volume_info->UNC);
3330 kfree(volume_info->domainname);
3331 kfree(volume_info->iocharset);
3332 kfree(volume_info->prepath);
3336 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3340 cleanup_volume_info_contents(volume_info);
3345 #ifdef CONFIG_CIFS_DFS_UPCALL
3347 * cifs_build_path_to_root returns full path to root when we do not have an
3348 * exiting connection (tcon)
3351 build_unc_path_to_root(const struct smb_vol *vol,
3352 const struct cifs_sb_info *cifs_sb)
3354 char *full_path, *pos;
3355 unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
3356 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3358 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3359 if (full_path == NULL)
3360 return ERR_PTR(-ENOMEM);
3362 strncpy(full_path, vol->UNC, unc_len);
3363 pos = full_path + unc_len;
3366 *pos = CIFS_DIR_SEP(cifs_sb);
3367 strncpy(pos + 1, vol->prepath, pplen);
3371 *pos = '\0'; /* add trailing null */
3372 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3373 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
3378 * Perform a dfs referral query for a share and (optionally) prefix
3380 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3381 * to a string containing updated options for the submount. Otherwise it
3382 * will be left untouched.
3384 * Returns the rc from get_dfs_path to the caller, which can be used to
3385 * determine whether there were referrals.
3388 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
3389 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3393 unsigned int num_referrals = 0;
3394 struct dfs_info3_param *referrals = NULL;
3395 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3397 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3398 if (IS_ERR(full_path))
3399 return PTR_ERR(full_path);
3401 /* For DFS paths, skip the first '\' of the UNC */
3402 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3404 rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
3405 &num_referrals, &referrals, cifs_remap(cifs_sb));
3407 if (!rc && num_referrals > 0) {
3408 char *fake_devname = NULL;
3410 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3411 full_path + 1, referrals,
3414 free_dfs_info_array(referrals, num_referrals);
3416 if (IS_ERR(mdata)) {
3417 rc = PTR_ERR(mdata);
3420 cleanup_volume_info_contents(volume_info);
3421 rc = cifs_setup_volume_info(volume_info, mdata,
3424 kfree(fake_devname);
3425 kfree(cifs_sb->mountdata);
3426 cifs_sb->mountdata = mdata;
3434 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3435 const char *devname)
3439 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3442 if (volume_info->nullauth) {
3443 cifs_dbg(FYI, "Anonymous login\n");
3444 kfree(volume_info->username);
3445 volume_info->username = NULL;
3446 } else if (volume_info->username) {
3447 /* BB fixme parse for domain name here */
3448 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
3450 cifs_dbg(VFS, "No username specified\n");
3451 /* In userspace mount helper we can get user name from alternate
3452 locations such as env variables and files on disk */
3456 /* this is needed for ASCII cp to Unicode converts */
3457 if (volume_info->iocharset == NULL) {
3458 /* load_nls_default cannot return null */
3459 volume_info->local_nls = load_nls_default();
3461 volume_info->local_nls = load_nls(volume_info->iocharset);
3462 if (volume_info->local_nls == NULL) {
3463 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
3464 volume_info->iocharset);
3473 cifs_get_volume_info(char *mount_data, const char *devname)
3476 struct smb_vol *volume_info;
3478 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
3480 return ERR_PTR(-ENOMEM);
3482 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3484 cifs_cleanup_volume_info(volume_info);
3485 volume_info = ERR_PTR(rc);
3492 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3496 struct cifs_ses *ses;
3497 struct cifs_tcon *tcon;
3498 struct TCP_Server_Info *server;
3500 struct tcon_link *tlink;
3501 #ifdef CONFIG_CIFS_DFS_UPCALL
3502 int referral_walks_count = 0;
3505 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs");
3509 #ifdef CONFIG_CIFS_DFS_UPCALL
3511 /* cleanup activities if we're chasing a referral */
3512 if (referral_walks_count) {
3514 cifs_put_tcon(tcon);
3516 cifs_put_smb_ses(ses);
3518 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
3532 /* get a reference to a tcp session */
3533 server = cifs_get_tcp_session(volume_info);
3534 if (IS_ERR(server)) {
3535 rc = PTR_ERR(server);
3536 bdi_destroy(&cifs_sb->bdi);
3540 /* get a reference to a SMB session */
3541 ses = cifs_get_smb_ses(server, volume_info);
3545 goto mount_fail_check;
3548 if ((volume_info->persistent == true) && ((ses->server->capabilities &
3549 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES) == 0)) {
3550 cifs_dbg(VFS, "persistent handles not supported by server\n");
3552 goto mount_fail_check;
3554 /* search for existing tcon to this server share */
3555 tcon = cifs_get_tcon(ses, volume_info);
3559 goto remote_path_check;
3562 /* tell server which Unix caps we support */
3563 if (cap_unix(tcon->ses)) {
3564 /* reset of caps checks mount to see if unix extensions
3565 disabled for just this mount */
3566 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3567 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3568 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3569 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3571 goto mount_fail_check;
3574 tcon->unix_ext = 0; /* server does not support them */
3576 /* do not care if a following call succeed - informational */
3577 if (!tcon->ipc && server->ops->qfs_tcon)
3578 server->ops->qfs_tcon(xid, tcon);
3580 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3581 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
3583 /* tune readahead according to rsize */
3584 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
3587 #ifdef CONFIG_CIFS_DFS_UPCALL
3589 * Perform an unconditional check for whether there are DFS
3590 * referrals for this path without prefix, to provide support
3591 * for DFS referrals from w2k8 servers which don't seem to respond
3592 * with PATH_NOT_COVERED to requests that include the prefix.
3593 * Chase the referral if found, otherwise continue normally.
3595 if (referral_walks_count == 0) {
3596 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3599 referral_walks_count++;
3600 goto try_mount_again;
3605 /* check if a whole path is not remote */
3607 if (!server->ops->is_path_accessible) {
3609 goto mount_fail_check;
3612 * cifs_build_path_to_root works only when we have a valid tcon
3614 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3615 if (full_path == NULL) {
3617 goto mount_fail_check;
3619 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3621 if (rc != 0 && rc != -EREMOTE) {
3623 goto mount_fail_check;
3628 /* get referral if needed */
3629 if (rc == -EREMOTE) {
3630 #ifdef CONFIG_CIFS_DFS_UPCALL
3631 if (referral_walks_count > MAX_NESTED_LINKS) {
3633 * BB: when we implement proper loop detection,
3634 * we will remove this check. But now we need it
3635 * to prevent an indefinite loop if 'DFS tree' is
3636 * misconfigured (i.e. has loops).
3639 goto mount_fail_check;
3642 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
3645 referral_walks_count++;
3646 goto try_mount_again;
3648 goto mount_fail_check;
3649 #else /* No DFS support, return error on mount */
3655 goto mount_fail_check;
3657 /* now, hang the tcon off of the superblock */
3658 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3659 if (tlink == NULL) {
3661 goto mount_fail_check;
3664 tlink->tl_uid = ses->linux_uid;
3665 tlink->tl_tcon = tcon;
3666 tlink->tl_time = jiffies;
3667 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3668 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3670 cifs_sb->master_tlink = tlink;
3671 spin_lock(&cifs_sb->tlink_tree_lock);
3672 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3673 spin_unlock(&cifs_sb->tlink_tree_lock);
3675 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3679 /* on error free sesinfo and tcon struct if needed */
3681 /* If find_unc succeeded then rc == 0 so we can not end */
3682 /* up accidentally freeing someone elses tcon struct */
3684 cifs_put_tcon(tcon);
3686 cifs_put_smb_ses(ses);
3688 cifs_put_tcp_session(server);
3689 bdi_destroy(&cifs_sb->bdi);
3698 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3699 * pointer may be NULL.
3702 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
3703 const char *tree, struct cifs_tcon *tcon,
3704 const struct nls_table *nls_codepage)
3706 struct smb_hdr *smb_buffer;
3707 struct smb_hdr *smb_buffer_response;
3710 unsigned char *bcc_ptr;
3713 __u16 bytes_left, count;
3718 smb_buffer = cifs_buf_get();
3719 if (smb_buffer == NULL)
3722 smb_buffer_response = smb_buffer;
3724 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3725 NULL /*no tid */ , 4 /*wct */ );
3727 smb_buffer->Mid = get_next_mid(ses->server);
3728 smb_buffer->Uid = ses->Suid;
3729 pSMB = (TCONX_REQ *) smb_buffer;
3730 pSMBr = (TCONX_RSP *) smb_buffer_response;
3732 pSMB->AndXCommand = 0xFF;
3733 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3734 bcc_ptr = &pSMB->Password[0];
3735 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3736 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3737 *bcc_ptr = 0; /* password is null byte */
3738 bcc_ptr++; /* skip password */
3739 /* already aligned so no need to do it below */
3741 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3742 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3743 specified as required (when that support is added to
3744 the vfs in the future) as only NTLM or the much
3745 weaker LANMAN (which we do not send by default) is accepted
3746 by Samba (not sure whether other servers allow
3747 NTLMv2 password here) */
3748 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3749 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3750 (ses->sectype == LANMAN))
3751 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3752 ses->server->sec_mode &
3753 SECMODE_PW_ENCRYPT ? true : false,
3756 #endif /* CIFS_WEAK_PW_HASH */
3757 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3758 bcc_ptr, nls_codepage);
3760 cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
3762 cifs_buf_release(smb_buffer);
3766 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3767 if (ses->capabilities & CAP_UNICODE) {
3768 /* must align unicode strings */
3769 *bcc_ptr = 0; /* null byte password */
3774 if (ses->server->sign)
3775 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3777 if (ses->capabilities & CAP_STATUS32) {
3778 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3780 if (ses->capabilities & CAP_DFS) {
3781 smb_buffer->Flags2 |= SMBFLG2_DFS;
3783 if (ses->capabilities & CAP_UNICODE) {
3784 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3786 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3787 6 /* max utf8 char length in bytes */ *
3788 (/* server len*/ + 256 /* share len */), nls_codepage);
3789 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3790 bcc_ptr += 2; /* skip trailing null */
3791 } else { /* ASCII */
3792 strcpy(bcc_ptr, tree);
3793 bcc_ptr += strlen(tree) + 1;
3795 strcpy(bcc_ptr, "?????");
3796 bcc_ptr += strlen("?????");
3798 count = bcc_ptr - &pSMB->Password[0];
3799 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3800 pSMB->hdr.smb_buf_length) + count);
3801 pSMB->ByteCount = cpu_to_le16(count);
3803 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3806 /* above now done in SendReceive */
3807 if ((rc == 0) && (tcon != NULL)) {
3810 tcon->tidStatus = CifsGood;
3811 tcon->need_reconnect = false;
3812 tcon->tid = smb_buffer_response->Tid;
3813 bcc_ptr = pByteArea(smb_buffer_response);
3814 bytes_left = get_bcc(smb_buffer_response);
3815 length = strnlen(bcc_ptr, bytes_left - 2);
3816 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3822 /* skip service field (NB: this field is always ASCII) */
3824 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3825 (bcc_ptr[2] == 'C')) {
3826 cifs_dbg(FYI, "IPC connection\n");
3829 } else if (length == 2) {
3830 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3831 /* the most common case */
3832 cifs_dbg(FYI, "disk share connection\n");
3835 bcc_ptr += length + 1;
3836 bytes_left -= (length + 1);
3837 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
3839 /* mostly informational -- no need to fail on error here */
3840 kfree(tcon->nativeFileSystem);
3841 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
3842 bytes_left, is_unicode,
3845 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
3847 if ((smb_buffer_response->WordCount == 3) ||
3848 (smb_buffer_response->WordCount == 7))
3849 /* field is in same location */
3850 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3853 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
3854 } else if ((rc == 0) && tcon == NULL) {
3855 /* all we need to save for IPC$ connection */
3856 ses->ipc_tid = smb_buffer_response->Tid;
3859 cifs_buf_release(smb_buffer);
3863 static void delayed_free(struct rcu_head *p)
3865 struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
3866 unload_nls(sbi->local_nls);
3871 cifs_umount(struct cifs_sb_info *cifs_sb)
3873 struct rb_root *root = &cifs_sb->tlink_tree;
3874 struct rb_node *node;
3875 struct tcon_link *tlink;
3877 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3879 spin_lock(&cifs_sb->tlink_tree_lock);
3880 while ((node = rb_first(root))) {
3881 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3882 cifs_get_tlink(tlink);
3883 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3884 rb_erase(node, root);
3886 spin_unlock(&cifs_sb->tlink_tree_lock);
3887 cifs_put_tlink(tlink);
3888 spin_lock(&cifs_sb->tlink_tree_lock);
3890 spin_unlock(&cifs_sb->tlink_tree_lock);
3892 bdi_destroy(&cifs_sb->bdi);
3893 kfree(cifs_sb->mountdata);
3894 call_rcu(&cifs_sb->rcu, delayed_free);
3898 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
3901 struct TCP_Server_Info *server = ses->server;
3903 if (!server->ops->need_neg || !server->ops->negotiate)
3906 /* only send once per connect */
3907 if (!server->ops->need_neg(server))
3910 set_credits(server, 1);
3912 rc = server->ops->negotiate(xid, ses);
3914 spin_lock(&GlobalMid_Lock);
3915 if (server->tcpStatus == CifsNeedNegotiate)
3916 server->tcpStatus = CifsGood;
3919 spin_unlock(&GlobalMid_Lock);
3926 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
3927 struct nls_table *nls_info)
3930 struct TCP_Server_Info *server = ses->server;
3932 ses->capabilities = server->capabilities;
3933 if (linuxExtEnabled == 0)
3934 ses->capabilities &= (~server->vals->cap_unix);
3936 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
3937 server->sec_mode, server->capabilities, server->timeAdj);
3939 if (server->ops->sess_setup)
3940 rc = server->ops->sess_setup(xid, ses, nls_info);
3943 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
3949 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
3951 vol->sectype = ses->sectype;
3953 /* krb5 is special, since we don't need username or pw */
3954 if (vol->sectype == Kerberos)
3957 return cifs_set_cifscreds(vol, ses);
3960 static struct cifs_tcon *
3961 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
3964 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3965 struct cifs_ses *ses;
3966 struct cifs_tcon *tcon = NULL;
3967 struct smb_vol *vol_info;
3969 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3970 if (vol_info == NULL)
3971 return ERR_PTR(-ENOMEM);
3973 vol_info->local_nls = cifs_sb->local_nls;
3974 vol_info->linux_uid = fsuid;
3975 vol_info->cred_uid = fsuid;
3976 vol_info->UNC = master_tcon->treeName;
3977 vol_info->retry = master_tcon->retry;
3978 vol_info->nocase = master_tcon->nocase;
3979 vol_info->local_lease = master_tcon->local_lease;
3980 vol_info->no_linux_ext = !master_tcon->unix_ext;
3981 vol_info->sectype = master_tcon->ses->sectype;
3982 vol_info->sign = master_tcon->ses->sign;
3984 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
3990 /* get a reference for the same TCP session */
3991 spin_lock(&cifs_tcp_ses_lock);
3992 ++master_tcon->ses->server->srv_count;
3993 spin_unlock(&cifs_tcp_ses_lock);
3995 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3997 tcon = (struct cifs_tcon *)ses;
3998 cifs_put_tcp_session(master_tcon->ses->server);
4002 tcon = cifs_get_tcon(ses, vol_info);
4004 cifs_put_smb_ses(ses);
4009 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4011 kfree(vol_info->username);
4012 kfree(vol_info->password);
4019 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4021 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4024 /* find and return a tlink with given uid */
4025 static struct tcon_link *
4026 tlink_rb_search(struct rb_root *root, kuid_t uid)
4028 struct rb_node *node = root->rb_node;
4029 struct tcon_link *tlink;
4032 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4034 if (uid_gt(tlink->tl_uid, uid))
4035 node = node->rb_left;
4036 else if (uid_lt(tlink->tl_uid, uid))
4037 node = node->rb_right;
4044 /* insert a tcon_link into the tree */
4046 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4048 struct rb_node **new = &(root->rb_node), *parent = NULL;
4049 struct tcon_link *tlink;
4052 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4055 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
4056 new = &((*new)->rb_left);
4058 new = &((*new)->rb_right);
4061 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4062 rb_insert_color(&new_tlink->tl_rbnode, root);
4066 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4069 * If the superblock doesn't refer to a multiuser mount, then just return
4070 * the master tcon for the mount.
4072 * First, search the rbtree for an existing tcon for this fsuid. If one
4073 * exists, then check to see if it's pending construction. If it is then wait
4074 * for construction to complete. Once it's no longer pending, check to see if
4075 * it failed and either return an error or retry construction, depending on
4078 * If one doesn't exist then insert a new tcon_link struct into the tree and
4079 * try to construct a new one.
4082 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4085 kuid_t fsuid = current_fsuid();
4086 struct tcon_link *tlink, *newtlink;
4088 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4089 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4091 spin_lock(&cifs_sb->tlink_tree_lock);
4092 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4094 cifs_get_tlink(tlink);
4095 spin_unlock(&cifs_sb->tlink_tree_lock);
4097 if (tlink == NULL) {
4098 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4099 if (newtlink == NULL)
4100 return ERR_PTR(-ENOMEM);
4101 newtlink->tl_uid = fsuid;
4102 newtlink->tl_tcon = ERR_PTR(-EACCES);
4103 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4104 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4105 cifs_get_tlink(newtlink);
4107 spin_lock(&cifs_sb->tlink_tree_lock);
4108 /* was one inserted after previous search? */
4109 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4111 cifs_get_tlink(tlink);
4112 spin_unlock(&cifs_sb->tlink_tree_lock);
4114 goto wait_for_construction;
4117 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4118 spin_unlock(&cifs_sb->tlink_tree_lock);
4120 wait_for_construction:
4121 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4122 TASK_INTERRUPTIBLE);
4124 cifs_put_tlink(tlink);
4125 return ERR_PTR(-ERESTARTSYS);
4128 /* if it's good, return it */
4129 if (!IS_ERR(tlink->tl_tcon))
4132 /* return error if we tried this already recently */
4133 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4134 cifs_put_tlink(tlink);
4135 return ERR_PTR(-EACCES);
4138 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4139 goto wait_for_construction;
4142 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4143 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4144 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4146 if (IS_ERR(tlink->tl_tcon)) {
4147 cifs_put_tlink(tlink);
4148 return ERR_PTR(-EACCES);
4155 * periodic workqueue job that scans tcon_tree for a superblock and closes
4159 cifs_prune_tlinks(struct work_struct *work)
4161 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4163 struct rb_root *root = &cifs_sb->tlink_tree;
4164 struct rb_node *node = rb_first(root);
4165 struct rb_node *tmp;
4166 struct tcon_link *tlink;
4169 * Because we drop the spinlock in the loop in order to put the tlink
4170 * it's not guarded against removal of links from the tree. The only
4171 * places that remove entries from the tree are this function and
4172 * umounts. Because this function is non-reentrant and is canceled
4173 * before umount can proceed, this is safe.
4175 spin_lock(&cifs_sb->tlink_tree_lock);
4176 node = rb_first(root);
4177 while (node != NULL) {
4179 node = rb_next(tmp);
4180 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4182 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4183 atomic_read(&tlink->tl_count) != 0 ||
4184 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4187 cifs_get_tlink(tlink);
4188 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4189 rb_erase(tmp, root);
4191 spin_unlock(&cifs_sb->tlink_tree_lock);
4192 cifs_put_tlink(tlink);
4193 spin_lock(&cifs_sb->tlink_tree_lock);
4195 spin_unlock(&cifs_sb->tlink_tree_lock);
4197 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,