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,
91 /* Mount options which take numeric value */
92 Opt_backupuid, Opt_backupgid, Opt_uid,
93 Opt_cruid, Opt_gid, Opt_file_mode,
94 Opt_dirmode, Opt_port,
95 Opt_rsize, Opt_wsize, Opt_actimeo,
97 /* Mount options which take string value */
98 Opt_user, Opt_pass, Opt_ip,
99 Opt_domain, Opt_srcaddr, Opt_iocharset,
100 Opt_netbiosname, Opt_servern,
101 Opt_ver, Opt_vers, Opt_sec, Opt_cache,
103 /* Mount options to be ignored */
106 /* Options which could be blank */
114 static const match_table_t cifs_mount_option_tokens = {
116 { Opt_user_xattr, "user_xattr" },
117 { Opt_nouser_xattr, "nouser_xattr" },
118 { Opt_forceuid, "forceuid" },
119 { Opt_noforceuid, "noforceuid" },
120 { Opt_forcegid, "forcegid" },
121 { Opt_noforcegid, "noforcegid" },
122 { Opt_noblocksend, "noblocksend" },
123 { Opt_noautotune, "noautotune" },
124 { Opt_hard, "hard" },
125 { Opt_soft, "soft" },
126 { Opt_perm, "perm" },
127 { Opt_noperm, "noperm" },
128 { Opt_mapchars, "mapchars" }, /* SFU style */
129 { Opt_nomapchars, "nomapchars" },
130 { Opt_mapposix, "mapposix" }, /* SFM style */
131 { Opt_nomapposix, "nomapposix" },
133 { Opt_nosfu, "nosfu" },
134 { Opt_nodfs, "nodfs" },
135 { Opt_posixpaths, "posixpaths" },
136 { Opt_noposixpaths, "noposixpaths" },
137 { Opt_nounix, "nounix" },
138 { Opt_nounix, "nolinux" },
139 { Opt_nocase, "nocase" },
140 { Opt_nocase, "ignorecase" },
142 { Opt_nobrl, "nobrl" },
143 { Opt_nobrl, "nolock" },
144 { Opt_forcemandatorylock, "forcemandatorylock" },
145 { Opt_forcemandatorylock, "forcemand" },
146 { Opt_setuids, "setuids" },
147 { Opt_nosetuids, "nosetuids" },
148 { Opt_dynperm, "dynperm" },
149 { Opt_nodynperm, "nodynperm" },
150 { Opt_nohard, "nohard" },
151 { Opt_nosoft, "nosoft" },
152 { Opt_nointr, "nointr" },
153 { Opt_intr, "intr" },
154 { Opt_nostrictsync, "nostrictsync" },
155 { Opt_strictsync, "strictsync" },
156 { Opt_serverino, "serverino" },
157 { Opt_noserverino, "noserverino" },
158 { Opt_rwpidforward, "rwpidforward" },
159 { Opt_cifsacl, "cifsacl" },
160 { Opt_nocifsacl, "nocifsacl" },
162 { Opt_noacl, "noacl" },
163 { Opt_locallease, "locallease" },
164 { Opt_sign, "sign" },
165 { Opt_seal, "seal" },
166 { Opt_noac, "noac" },
168 { Opt_mfsymlinks, "mfsymlinks" },
169 { Opt_multiuser, "multiuser" },
170 { Opt_sloppy, "sloppy" },
171 { Opt_nosharesock, "nosharesock" },
173 { Opt_backupuid, "backupuid=%s" },
174 { Opt_backupgid, "backupgid=%s" },
175 { Opt_uid, "uid=%s" },
176 { Opt_cruid, "cruid=%s" },
177 { Opt_gid, "gid=%s" },
178 { Opt_file_mode, "file_mode=%s" },
179 { Opt_dirmode, "dirmode=%s" },
180 { Opt_dirmode, "dir_mode=%s" },
181 { Opt_port, "port=%s" },
182 { Opt_rsize, "rsize=%s" },
183 { Opt_wsize, "wsize=%s" },
184 { Opt_actimeo, "actimeo=%s" },
186 { Opt_blank_user, "user=" },
187 { Opt_blank_user, "username=" },
188 { Opt_user, "user=%s" },
189 { Opt_user, "username=%s" },
190 { Opt_blank_pass, "pass=" },
191 { Opt_blank_pass, "password=" },
192 { Opt_pass, "pass=%s" },
193 { Opt_pass, "password=%s" },
194 { Opt_blank_ip, "ip=" },
195 { Opt_blank_ip, "addr=" },
197 { Opt_ip, "addr=%s" },
198 { Opt_ignore, "unc=%s" },
199 { Opt_ignore, "target=%s" },
200 { Opt_ignore, "path=%s" },
201 { Opt_domain, "dom=%s" },
202 { Opt_domain, "domain=%s" },
203 { Opt_domain, "workgroup=%s" },
204 { Opt_srcaddr, "srcaddr=%s" },
205 { Opt_ignore, "prefixpath=%s" },
206 { Opt_iocharset, "iocharset=%s" },
207 { Opt_netbiosname, "netbiosname=%s" },
208 { Opt_servern, "servern=%s" },
209 { Opt_ver, "ver=%s" },
210 { Opt_vers, "vers=%s" },
211 { Opt_sec, "sec=%s" },
212 { Opt_cache, "cache=%s" },
214 { Opt_ignore, "cred" },
215 { Opt_ignore, "credentials" },
216 { Opt_ignore, "cred=%s" },
217 { Opt_ignore, "credentials=%s" },
218 { Opt_ignore, "guest" },
219 { Opt_ignore, "rw" },
220 { Opt_ignore, "ro" },
221 { Opt_ignore, "suid" },
222 { Opt_ignore, "nosuid" },
223 { Opt_ignore, "exec" },
224 { Opt_ignore, "noexec" },
225 { Opt_ignore, "nodev" },
226 { Opt_ignore, "noauto" },
227 { Opt_ignore, "dev" },
228 { Opt_ignore, "mand" },
229 { Opt_ignore, "nomand" },
230 { Opt_ignore, "_netdev" },
236 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
237 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
238 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
239 Opt_sec_ntlmv2i, Opt_sec_lanman,
245 static const match_table_t cifs_secflavor_tokens = {
246 { Opt_sec_krb5, "krb5" },
247 { Opt_sec_krb5i, "krb5i" },
248 { Opt_sec_krb5p, "krb5p" },
249 { Opt_sec_ntlmsspi, "ntlmsspi" },
250 { Opt_sec_ntlmssp, "ntlmssp" },
251 { Opt_ntlm, "ntlm" },
252 { Opt_sec_ntlmi, "ntlmi" },
253 { Opt_sec_ntlmv2, "nontlm" },
254 { Opt_sec_ntlmv2, "ntlmv2" },
255 { Opt_sec_ntlmv2i, "ntlmv2i" },
256 { Opt_sec_lanman, "lanman" },
257 { Opt_sec_none, "none" },
259 { Opt_sec_err, NULL }
270 static const match_table_t cifs_cacheflavor_tokens = {
271 { Opt_cache_loose, "loose" },
272 { Opt_cache_strict, "strict" },
273 { Opt_cache_none, "none" },
274 { Opt_cache_err, NULL }
277 static const match_table_t cifs_smb_version_tokens = {
278 { Smb_1, SMB1_VERSION_STRING },
279 { Smb_20, SMB20_VERSION_STRING},
280 { Smb_21, SMB21_VERSION_STRING },
281 { Smb_30, SMB30_VERSION_STRING },
282 { Smb_302, SMB302_VERSION_STRING },
283 #ifdef CONFIG_CIFS_SMB311
284 { Smb_311, SMB311_VERSION_STRING },
285 { Smb_311, ALT_SMB311_VERSION_STRING },
287 { Smb_version_err, NULL }
290 static int ip_connect(struct TCP_Server_Info *server);
291 static int generic_ip_connect(struct TCP_Server_Info *server);
292 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
293 static void cifs_prune_tlinks(struct work_struct *work);
294 static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
295 const char *devname);
298 * cifs tcp session reconnection
300 * mark tcp session as reconnecting so temporarily locked
301 * mark all smb sessions as reconnecting for tcp session
302 * reconnect tcp session
303 * wake up waiters on reconnection? - (not needed currently)
306 cifs_reconnect(struct TCP_Server_Info *server)
309 struct list_head *tmp, *tmp2;
310 struct cifs_ses *ses;
311 struct cifs_tcon *tcon;
312 struct mid_q_entry *mid_entry;
313 struct list_head retry_list;
315 spin_lock(&GlobalMid_Lock);
316 if (server->tcpStatus == CifsExiting) {
317 /* the demux thread will exit normally
318 next time through the loop */
319 spin_unlock(&GlobalMid_Lock);
322 server->tcpStatus = CifsNeedReconnect;
323 spin_unlock(&GlobalMid_Lock);
325 #ifdef CONFIG_CIFS_SMB2
326 server->max_read = 0;
329 cifs_dbg(FYI, "Reconnecting tcp session\n");
331 /* before reconnecting the tcp session, mark the smb session (uid)
332 and the tid bad so they are not used until reconnected */
333 cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
335 spin_lock(&cifs_tcp_ses_lock);
336 list_for_each(tmp, &server->smb_ses_list) {
337 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
338 ses->need_reconnect = true;
340 list_for_each(tmp2, &ses->tcon_list) {
341 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
342 tcon->need_reconnect = true;
345 spin_unlock(&cifs_tcp_ses_lock);
347 /* do not want to be sending data on a socket we are freeing */
348 cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
349 mutex_lock(&server->srv_mutex);
350 if (server->ssocket) {
351 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
352 server->ssocket->state, server->ssocket->flags);
353 kernel_sock_shutdown(server->ssocket, SHUT_WR);
354 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
355 server->ssocket->state, server->ssocket->flags);
356 sock_release(server->ssocket);
357 server->ssocket = NULL;
359 server->sequence_number = 0;
360 server->session_estab = false;
361 kfree(server->session_key.response);
362 server->session_key.response = NULL;
363 server->session_key.len = 0;
364 server->lstrp = jiffies;
365 mutex_unlock(&server->srv_mutex);
367 /* mark submitted MIDs for retry and issue callback */
368 INIT_LIST_HEAD(&retry_list);
369 cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
370 spin_lock(&GlobalMid_Lock);
371 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
372 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
373 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
374 mid_entry->mid_state = MID_RETRY_NEEDED;
375 list_move(&mid_entry->qhead, &retry_list);
377 spin_unlock(&GlobalMid_Lock);
379 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
380 list_for_each_safe(tmp, tmp2, &retry_list) {
381 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
382 list_del_init(&mid_entry->qhead);
383 mid_entry->callback(mid_entry);
389 /* we should try only the port we connected to before */
390 mutex_lock(&server->srv_mutex);
391 rc = generic_ip_connect(server);
393 cifs_dbg(FYI, "reconnect error %d\n", rc);
394 mutex_unlock(&server->srv_mutex);
397 atomic_inc(&tcpSesReconnectCount);
398 spin_lock(&GlobalMid_Lock);
399 if (server->tcpStatus != CifsExiting)
400 server->tcpStatus = CifsNeedNegotiate;
401 spin_unlock(&GlobalMid_Lock);
402 mutex_unlock(&server->srv_mutex);
404 } while (server->tcpStatus == CifsNeedReconnect);
410 cifs_echo_request(struct work_struct *work)
413 struct TCP_Server_Info *server = container_of(work,
414 struct TCP_Server_Info, echo.work);
417 * We cannot send an echo if it is disabled or until the
418 * NEGOTIATE_PROTOCOL request is done, which is indicated by
419 * server->ops->need_neg() == true. Also, no need to ping if
420 * we got a response recently.
422 if (!server->ops->need_neg || server->ops->need_neg(server) ||
423 (server->ops->can_echo && !server->ops->can_echo(server)) ||
424 time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
427 rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
429 cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
433 queue_delayed_work(cifsiod_wq, &server->echo, SMB_ECHO_INTERVAL);
437 allocate_buffers(struct TCP_Server_Info *server)
439 if (!server->bigbuf) {
440 server->bigbuf = (char *)cifs_buf_get();
441 if (!server->bigbuf) {
442 cifs_dbg(VFS, "No memory for large SMB response\n");
444 /* retry will check if exiting */
447 } else if (server->large_buf) {
448 /* we are reusing a dirty large buf, clear its start */
449 memset(server->bigbuf, 0, HEADER_SIZE(server));
452 if (!server->smallbuf) {
453 server->smallbuf = (char *)cifs_small_buf_get();
454 if (!server->smallbuf) {
455 cifs_dbg(VFS, "No memory for SMB response\n");
457 /* retry will check if exiting */
460 /* beginning of smb buffer is cleared in our buf_get */
462 /* if existing small buf clear beginning */
463 memset(server->smallbuf, 0, HEADER_SIZE(server));
470 server_unresponsive(struct TCP_Server_Info *server)
473 * We need to wait 2 echo intervals to make sure we handle such
475 * 1s client sends a normal SMB request
476 * 2s client gets a response
477 * 30s echo workqueue job pops, and decides we got a response recently
478 * and don't need to send another
480 * 65s kernel_recvmsg times out, and we see that we haven't gotten
481 * a response in >60s.
483 if (server->tcpStatus == CifsGood &&
484 time_after(jiffies, server->lstrp + 2 * SMB_ECHO_INTERVAL)) {
485 cifs_dbg(VFS, "Server %s has not responded in %d seconds. Reconnecting...\n",
486 server->hostname, (2 * SMB_ECHO_INTERVAL) / HZ);
487 cifs_reconnect(server);
488 wake_up(&server->response_q);
496 * kvec_array_init - clone a kvec array, and advance into it
497 * @new: pointer to memory for cloned array
498 * @iov: pointer to original array
499 * @nr_segs: number of members in original array
500 * @bytes: number of bytes to advance into the cloned array
502 * This function will copy the array provided in iov to a section of memory
503 * and advance the specified number of bytes into the new array. It returns
504 * the number of segments in the new array. "new" must be at least as big as
505 * the original iov array.
508 kvec_array_init(struct kvec *new, struct kvec *iov, unsigned int nr_segs,
513 while (bytes || !iov->iov_len) {
514 int copy = min(bytes, iov->iov_len);
518 if (iov->iov_len == base) {
524 memcpy(new, iov, sizeof(*iov) * nr_segs);
525 new->iov_base += base;
526 new->iov_len -= base;
531 get_server_iovec(struct TCP_Server_Info *server, unsigned int nr_segs)
533 struct kvec *new_iov;
535 if (server->iov && nr_segs <= server->nr_iov)
538 /* not big enough -- allocate a new one and release the old */
539 new_iov = kmalloc(sizeof(*new_iov) * nr_segs, GFP_NOFS);
542 server->iov = new_iov;
543 server->nr_iov = nr_segs;
549 cifs_readv_from_socket(struct TCP_Server_Info *server, struct kvec *iov_orig,
550 unsigned int nr_segs, unsigned int to_read)
555 struct msghdr smb_msg;
558 iov = get_server_iovec(server, nr_segs);
562 smb_msg.msg_control = NULL;
563 smb_msg.msg_controllen = 0;
565 for (total_read = 0; to_read; total_read += length, to_read -= length) {
568 if (server_unresponsive(server)) {
569 total_read = -ECONNABORTED;
573 segs = kvec_array_init(iov, iov_orig, nr_segs, total_read);
575 length = kernel_recvmsg(server->ssocket, &smb_msg,
576 iov, segs, to_read, 0);
578 if (server->tcpStatus == CifsExiting) {
579 total_read = -ESHUTDOWN;
581 } else if (server->tcpStatus == CifsNeedReconnect) {
582 cifs_reconnect(server);
583 total_read = -ECONNABORTED;
585 } else if (length == -ERESTARTSYS ||
589 * Minimum sleep to prevent looping, allowing socket
590 * to clear and app threads to set tcpStatus
591 * CifsNeedReconnect if server hung.
593 usleep_range(1000, 2000);
596 } else if (length <= 0) {
597 cifs_dbg(FYI, "Received no data or error: expecting %d\n"
598 "got %d", to_read, length);
599 cifs_reconnect(server);
600 total_read = -ECONNABORTED;
608 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
609 unsigned int to_read)
614 iov.iov_len = to_read;
616 return cifs_readv_from_socket(server, &iov, 1, to_read);
620 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
623 * The first byte big endian of the length field,
624 * is actually not part of the length but the type
625 * with the most common, zero, as regular data.
628 case RFC1002_SESSION_MESSAGE:
629 /* Regular SMB response */
631 case RFC1002_SESSION_KEEP_ALIVE:
632 cifs_dbg(FYI, "RFC 1002 session keep alive\n");
634 case RFC1002_POSITIVE_SESSION_RESPONSE:
635 cifs_dbg(FYI, "RFC 1002 positive session response\n");
637 case RFC1002_NEGATIVE_SESSION_RESPONSE:
639 * We get this from Windows 98 instead of an error on
640 * SMB negprot response.
642 cifs_dbg(FYI, "RFC 1002 negative session response\n");
643 /* give server a second to clean up */
646 * Always try 445 first on reconnect since we get NACK
647 * on some if we ever connected to port 139 (the NACK
648 * is since we do not begin with RFC1001 session
651 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
652 cifs_reconnect(server);
653 wake_up(&server->response_q);
656 cifs_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
657 cifs_reconnect(server);
664 dequeue_mid(struct mid_q_entry *mid, bool malformed)
666 #ifdef CONFIG_CIFS_STATS2
667 mid->when_received = jiffies;
669 spin_lock(&GlobalMid_Lock);
671 mid->mid_state = MID_RESPONSE_RECEIVED;
673 mid->mid_state = MID_RESPONSE_MALFORMED;
674 list_del_init(&mid->qhead);
675 spin_unlock(&GlobalMid_Lock);
679 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
680 char *buf, int malformed)
682 if (server->ops->check_trans2 &&
683 server->ops->check_trans2(mid, server, buf, malformed))
686 mid->large_buf = server->large_buf;
687 /* Was previous buf put in mpx struct for multi-rsp? */
688 if (!mid->multiRsp) {
689 /* smb buffer will be freed by user thread */
690 if (server->large_buf)
691 server->bigbuf = NULL;
693 server->smallbuf = NULL;
695 dequeue_mid(mid, malformed);
698 static void clean_demultiplex_info(struct TCP_Server_Info *server)
702 /* take it off the list, if it's not already */
703 spin_lock(&cifs_tcp_ses_lock);
704 list_del_init(&server->tcp_ses_list);
705 spin_unlock(&cifs_tcp_ses_lock);
707 spin_lock(&GlobalMid_Lock);
708 server->tcpStatus = CifsExiting;
709 spin_unlock(&GlobalMid_Lock);
710 wake_up_all(&server->response_q);
712 /* check if we have blocked requests that need to free */
713 spin_lock(&server->req_lock);
714 if (server->credits <= 0)
716 spin_unlock(&server->req_lock);
718 * Although there should not be any requests blocked on this queue it
719 * can not hurt to be paranoid and try to wake up requests that may
720 * haven been blocked when more than 50 at time were on the wire to the
721 * same server - they now will see the session is in exit state and get
722 * out of SendReceive.
724 wake_up_all(&server->request_q);
725 /* give those requests time to exit */
728 if (server->ssocket) {
729 sock_release(server->ssocket);
730 server->ssocket = NULL;
733 if (!list_empty(&server->pending_mid_q)) {
734 struct list_head dispose_list;
735 struct mid_q_entry *mid_entry;
736 struct list_head *tmp, *tmp2;
738 INIT_LIST_HEAD(&dispose_list);
739 spin_lock(&GlobalMid_Lock);
740 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
741 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
742 cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid);
743 mid_entry->mid_state = MID_SHUTDOWN;
744 list_move(&mid_entry->qhead, &dispose_list);
746 spin_unlock(&GlobalMid_Lock);
748 /* now walk dispose list and issue callbacks */
749 list_for_each_safe(tmp, tmp2, &dispose_list) {
750 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
751 cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid);
752 list_del_init(&mid_entry->qhead);
753 mid_entry->callback(mid_entry);
755 /* 1/8th of sec is more than enough time for them to exit */
759 if (!list_empty(&server->pending_mid_q)) {
761 * mpx threads have not exited yet give them at least the smb
762 * send timeout time for long ops.
764 * Due to delays on oplock break requests, we need to wait at
765 * least 45 seconds before giving up on a request getting a
766 * response and going ahead and killing cifsd.
768 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
771 * If threads still have not exited they are probably never
772 * coming home not much else we can do but free the memory.
776 kfree(server->hostname);
780 length = atomic_dec_return(&tcpSesAllocCount);
782 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
786 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
789 char *buf = server->smallbuf;
790 unsigned int pdu_length = get_rfc1002_length(buf);
792 /* make sure this will fit in a large buffer */
793 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) - 4) {
794 cifs_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
795 cifs_reconnect(server);
796 wake_up(&server->response_q);
797 return -ECONNABORTED;
800 /* switch to large buffer if too big for a small one */
801 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
802 server->large_buf = true;
803 memcpy(server->bigbuf, buf, server->total_read);
804 buf = server->bigbuf;
807 /* now read the rest */
808 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
809 pdu_length - HEADER_SIZE(server) + 1 + 4);
812 server->total_read += length;
814 dump_smb(buf, server->total_read);
817 * We know that we received enough to get to the MID as we
818 * checked the pdu_length earlier. Now check to see
819 * if the rest of the header is OK. We borrow the length
820 * var for the rest of the loop to avoid a new stack var.
822 * 48 bytes is enough to display the header and a little bit
823 * into the payload for debugging purposes.
825 length = server->ops->check_message(buf, server->total_read);
827 cifs_dump_mem("Bad SMB: ", buf,
828 min_t(unsigned int, server->total_read, 48));
830 if (server->ops->is_status_pending &&
831 server->ops->is_status_pending(buf, server, length))
837 handle_mid(mid, server, buf, length);
842 cifs_demultiplex_thread(void *p)
845 struct TCP_Server_Info *server = p;
846 unsigned int pdu_length;
848 struct task_struct *task_to_wake = NULL;
849 struct mid_q_entry *mid_entry;
851 current->flags |= PF_MEMALLOC;
852 cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
854 length = atomic_inc_return(&tcpSesAllocCount);
856 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
859 while (server->tcpStatus != CifsExiting) {
863 if (!allocate_buffers(server))
866 server->large_buf = false;
867 buf = server->smallbuf;
868 pdu_length = 4; /* enough to get RFC1001 header */
870 length = cifs_read_from_socket(server, buf, pdu_length);
873 server->total_read = length;
876 * The right amount was read from socket - 4 bytes,
877 * so we can now interpret the length field.
879 pdu_length = get_rfc1002_length(buf);
881 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
882 if (!is_smb_response(server, buf[0]))
885 /* make sure we have enough to get to the MID */
886 if (pdu_length < HEADER_SIZE(server) - 1 - 4) {
887 cifs_dbg(VFS, "SMB response too short (%u bytes)\n",
889 cifs_reconnect(server);
890 wake_up(&server->response_q);
894 /* read down to the MID */
895 length = cifs_read_from_socket(server, buf + 4,
896 HEADER_SIZE(server) - 1 - 4);
899 server->total_read += length;
901 mid_entry = server->ops->find_mid(server, buf);
903 if (!mid_entry || !mid_entry->receive)
904 length = standard_receive3(server, mid_entry);
906 length = mid_entry->receive(server, mid_entry);
911 if (server->large_buf)
912 buf = server->bigbuf;
914 server->lstrp = jiffies;
915 if (mid_entry != NULL) {
916 if (!mid_entry->multiRsp || mid_entry->multiEnd)
917 mid_entry->callback(mid_entry);
918 } else if (!server->ops->is_oplock_break ||
919 !server->ops->is_oplock_break(buf, server)) {
920 cifs_dbg(VFS, "No task to wake, unknown frame received! NumMids %d\n",
921 atomic_read(&midCount));
922 cifs_dump_mem("Received Data is: ", buf,
923 HEADER_SIZE(server));
924 #ifdef CONFIG_CIFS_DEBUG2
925 if (server->ops->dump_detail)
926 server->ops->dump_detail(buf);
927 cifs_dump_mids(server);
928 #endif /* CIFS_DEBUG2 */
931 } /* end while !EXITING */
933 /* buffer usually freed in free_mid - need to free it here on exit */
934 cifs_buf_release(server->bigbuf);
935 if (server->smallbuf) /* no sense logging a debug message if NULL */
936 cifs_small_buf_release(server->smallbuf);
938 task_to_wake = xchg(&server->tsk, NULL);
939 clean_demultiplex_info(server);
941 /* if server->tsk was NULL then wait for a signal before exiting */
943 set_current_state(TASK_INTERRUPTIBLE);
944 while (!signal_pending(current)) {
946 set_current_state(TASK_INTERRUPTIBLE);
948 set_current_state(TASK_RUNNING);
951 module_put_and_exit(0);
954 /* extract the host portion of the UNC string */
956 extract_hostname(const char *unc)
962 /* skip double chars at beginning of string */
963 /* BB: check validity of these bytes? */
966 /* delimiter between hostname and sharename is always '\\' now */
967 delim = strchr(src, '\\');
969 return ERR_PTR(-EINVAL);
972 dst = kmalloc((len + 1), GFP_KERNEL);
974 return ERR_PTR(-ENOMEM);
976 memcpy(dst, src, len);
982 static int get_option_ul(substring_t args[], unsigned long *option)
987 string = match_strdup(args);
990 rc = kstrtoul(string, 0, option);
996 static int get_option_uid(substring_t args[], kuid_t *result)
1002 rc = get_option_ul(args, &value);
1006 uid = make_kuid(current_user_ns(), value);
1007 if (!uid_valid(uid))
1014 static int get_option_gid(substring_t args[], kgid_t *result)
1016 unsigned long value;
1020 rc = get_option_ul(args, &value);
1024 gid = make_kgid(current_user_ns(), value);
1025 if (!gid_valid(gid))
1032 static int cifs_parse_security_flavors(char *value,
1033 struct smb_vol *vol)
1036 substring_t args[MAX_OPT_ARGS];
1039 * With mount options, the last one should win. Reset any existing
1040 * settings back to default.
1042 vol->sectype = Unspecified;
1045 switch (match_token(value, cifs_secflavor_tokens, args)) {
1047 cifs_dbg(VFS, "sec=krb5p is not supported!\n");
1053 vol->sectype = Kerberos;
1055 case Opt_sec_ntlmsspi:
1058 case Opt_sec_ntlmssp:
1059 vol->sectype = RawNTLMSSP;
1065 vol->sectype = NTLM;
1067 case Opt_sec_ntlmv2i:
1070 case Opt_sec_ntlmv2:
1071 vol->sectype = NTLMv2;
1073 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1074 case Opt_sec_lanman:
1075 vol->sectype = LANMAN;
1082 cifs_dbg(VFS, "bad security option: %s\n", value);
1090 cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1092 substring_t args[MAX_OPT_ARGS];
1094 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1095 case Opt_cache_loose:
1096 vol->direct_io = false;
1097 vol->strict_io = false;
1099 case Opt_cache_strict:
1100 vol->direct_io = false;
1101 vol->strict_io = true;
1103 case Opt_cache_none:
1104 vol->direct_io = true;
1105 vol->strict_io = false;
1108 cifs_dbg(VFS, "bad cache= option: %s\n", value);
1115 cifs_parse_smb_version(char *value, struct smb_vol *vol)
1117 substring_t args[MAX_OPT_ARGS];
1119 switch (match_token(value, cifs_smb_version_tokens, args)) {
1121 vol->ops = &smb1_operations;
1122 vol->vals = &smb1_values;
1124 #ifdef CONFIG_CIFS_SMB2
1126 vol->ops = &smb20_operations;
1127 vol->vals = &smb20_values;
1130 vol->ops = &smb21_operations;
1131 vol->vals = &smb21_values;
1134 vol->ops = &smb30_operations;
1135 vol->vals = &smb30_values;
1138 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1139 vol->vals = &smb302_values;
1141 #ifdef CONFIG_CIFS_SMB311
1143 vol->ops = &smb311_operations;
1144 vol->vals = &smb311_values;
1149 cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
1156 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1157 * fields with the result. Returns 0 on success and an error otherwise.
1160 cifs_parse_devname(const char *devname, struct smb_vol *vol)
1163 const char *delims = "/\\";
1166 /* make sure we have a valid UNC double delimiter prefix */
1167 len = strspn(devname, delims);
1171 /* find delimiter between host and sharename */
1172 pos = strpbrk(devname + 2, delims);
1176 /* skip past delimiter */
1179 /* now go until next delimiter or end of string */
1180 len = strcspn(pos, delims);
1182 /* move "pos" up to delimiter or NULL */
1184 vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1188 convert_delimiter(vol->UNC, '\\');
1190 /* If pos is NULL, or is a bogus trailing delimiter then no prepath */
1191 if (!*pos++ || !*pos)
1194 vol->prepath = kstrdup(pos, GFP_KERNEL);
1202 cifs_parse_mount_options(const char *mountdata, const char *devname,
1203 struct smb_vol *vol)
1206 char *mountdata_copy = NULL, *options;
1207 unsigned int temp_len, i, j;
1209 short int override_uid = -1;
1210 short int override_gid = -1;
1211 bool uid_specified = false;
1212 bool gid_specified = false;
1213 bool sloppy = false;
1214 char *invalid = NULL;
1215 char *nodename = utsname()->nodename;
1216 char *string = NULL;
1217 char *tmp_end, *value;
1219 bool got_ip = false;
1220 unsigned short port = 0;
1221 struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1225 delim = separator[0];
1227 /* ensure we always start with zeroed-out smb_vol */
1228 memset(vol, 0, sizeof(*vol));
1231 * does not have to be perfect mapping since field is
1232 * informational, only used for servers that do not support
1233 * port 445 and it can be overridden at mount time
1235 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1236 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1237 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1239 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1240 /* null target name indicates to use *SMBSERVR default called name
1241 if we end up sending RFC1001 session initialize */
1242 vol->target_rfc1001_name[0] = 0;
1243 vol->cred_uid = current_uid();
1244 vol->linux_uid = current_uid();
1245 vol->linux_gid = current_gid();
1248 * default to SFM style remapping of seven reserved characters
1249 * unless user overrides it or we negotiate CIFS POSIX where
1250 * it is unnecessary. Can not simultaneously use more than one mapping
1251 * since then readdir could list files that open could not open
1255 /* default to only allowing write access to owner of the mount */
1256 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1258 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1259 /* default is always to request posix paths. */
1260 vol->posix_paths = 1;
1261 /* default to using server inode numbers where available */
1262 vol->server_ino = 1;
1264 /* default is to use strict cifs caching semantics */
1265 vol->strict_io = true;
1267 vol->actimeo = CIFS_DEF_ACTIMEO;
1269 /* FIXME: add autonegotiation -- for now, SMB1 is default */
1270 vol->ops = &smb1_operations;
1271 vol->vals = &smb1_values;
1274 goto cifs_parse_mount_err;
1276 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1277 if (!mountdata_copy)
1278 goto cifs_parse_mount_err;
1280 options = mountdata_copy;
1281 end = options + strlen(options);
1283 if (strncmp(options, "sep=", 4) == 0) {
1284 if (options[4] != 0) {
1285 separator[0] = options[4];
1288 cifs_dbg(FYI, "Null separator not allowed\n");
1291 vol->backupuid_specified = false; /* no backup intent for a user */
1292 vol->backupgid_specified = false; /* no backup intent for a group */
1294 switch (cifs_parse_devname(devname, vol)) {
1298 cifs_dbg(VFS, "Unable to allocate memory for devname.\n");
1299 goto cifs_parse_mount_err;
1301 cifs_dbg(VFS, "Malformed UNC in devname.\n");
1302 goto cifs_parse_mount_err;
1304 cifs_dbg(VFS, "Unknown error parsing devname.\n");
1305 goto cifs_parse_mount_err;
1308 while ((data = strsep(&options, separator)) != NULL) {
1309 substring_t args[MAX_OPT_ARGS];
1310 unsigned long option;
1316 token = match_token(data, cifs_mount_option_tokens, args);
1320 /* Ingnore the following */
1324 /* Boolean values */
1325 case Opt_user_xattr:
1328 case Opt_nouser_xattr:
1334 case Opt_noforceuid:
1340 case Opt_noforcegid:
1343 case Opt_noblocksend:
1344 vol->noblocksnd = 1;
1346 case Opt_noautotune:
1347 vol->noautotune = 1;
1362 vol->sfu_remap = true;
1363 vol->remap = false; /* disable SFM mapping */
1365 case Opt_nomapchars:
1366 vol->sfu_remap = false;
1370 vol->sfu_remap = false; /* disable SFU mapping */
1372 case Opt_nomapposix:
1384 case Opt_posixpaths:
1385 vol->posix_paths = 1;
1387 case Opt_noposixpaths:
1388 vol->posix_paths = 0;
1391 vol->no_linux_ext = 1;
1402 * turn off mandatory locking in mode
1403 * if remote locking is turned off since the
1404 * local vfs will do advisory
1406 if (vol->file_mode ==
1407 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1408 vol->file_mode = S_IALLUGO;
1410 case Opt_forcemandatorylock:
1420 vol->dynperm = true;
1423 vol->dynperm = false;
1437 case Opt_nostrictsync:
1438 vol->nostrictsync = 1;
1440 case Opt_strictsync:
1441 vol->nostrictsync = 0;
1444 vol->server_ino = 1;
1446 case Opt_noserverino:
1447 vol->server_ino = 0;
1449 case Opt_rwpidforward:
1450 vol->rwpidforward = 1;
1459 vol->no_psx_acl = 0;
1462 vol->no_psx_acl = 1;
1464 case Opt_locallease:
1465 vol->local_lease = 1;
1471 /* we do not do the following in secFlags because seal
1472 * is a per tree connection (mount) not a per socket
1473 * or per-smb connection option in the protocol
1474 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1479 pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1482 #ifndef CONFIG_CIFS_FSCACHE
1483 cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1484 goto cifs_parse_mount_err;
1488 case Opt_mfsymlinks:
1489 vol->mfsymlinks = true;
1492 vol->multiuser = true;
1497 case Opt_nosharesock:
1498 vol->nosharesock = true;
1501 /* Numeric Values */
1503 if (get_option_uid(args, &vol->backupuid)) {
1504 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
1506 goto cifs_parse_mount_err;
1508 vol->backupuid_specified = true;
1511 if (get_option_gid(args, &vol->backupgid)) {
1512 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
1514 goto cifs_parse_mount_err;
1516 vol->backupgid_specified = true;
1519 if (get_option_uid(args, &vol->linux_uid)) {
1520 cifs_dbg(VFS, "%s: Invalid uid value\n",
1522 goto cifs_parse_mount_err;
1524 uid_specified = true;
1527 if (get_option_uid(args, &vol->cred_uid)) {
1528 cifs_dbg(VFS, "%s: Invalid cruid value\n",
1530 goto cifs_parse_mount_err;
1534 if (get_option_gid(args, &vol->linux_gid)) {
1535 cifs_dbg(VFS, "%s: Invalid gid value\n",
1537 goto cifs_parse_mount_err;
1539 gid_specified = true;
1542 if (get_option_ul(args, &option)) {
1543 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
1545 goto cifs_parse_mount_err;
1547 vol->file_mode = option;
1550 if (get_option_ul(args, &option)) {
1551 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
1553 goto cifs_parse_mount_err;
1555 vol->dir_mode = option;
1558 if (get_option_ul(args, &option) ||
1559 option > USHRT_MAX) {
1560 cifs_dbg(VFS, "%s: Invalid port value\n",
1562 goto cifs_parse_mount_err;
1564 port = (unsigned short)option;
1567 if (get_option_ul(args, &option)) {
1568 cifs_dbg(VFS, "%s: Invalid rsize value\n",
1570 goto cifs_parse_mount_err;
1572 vol->rsize = option;
1575 if (get_option_ul(args, &option)) {
1576 cifs_dbg(VFS, "%s: Invalid wsize value\n",
1578 goto cifs_parse_mount_err;
1580 vol->wsize = option;
1583 if (get_option_ul(args, &option)) {
1584 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
1586 goto cifs_parse_mount_err;
1588 vol->actimeo = HZ * option;
1589 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1590 cifs_dbg(VFS, "attribute cache timeout too large\n");
1591 goto cifs_parse_mount_err;
1595 /* String Arguments */
1597 case Opt_blank_user:
1598 /* null user, ie. anonymous authentication */
1600 vol->username = NULL;
1603 string = match_strdup(args);
1607 if (strnlen(string, CIFS_MAX_USERNAME_LEN) >
1608 CIFS_MAX_USERNAME_LEN) {
1609 pr_warn("CIFS: username too long\n");
1610 goto cifs_parse_mount_err;
1613 kfree(vol->username);
1614 vol->username = kstrdup(string, GFP_KERNEL);
1616 goto cifs_parse_mount_err;
1618 case Opt_blank_pass:
1619 /* passwords have to be handled differently
1620 * to allow the character used for deliminator
1621 * to be passed within them
1625 * Check if this is a case where the password
1626 * starts with a delimiter
1628 tmp_end = strchr(data, '=');
1630 if (!(tmp_end < end && tmp_end[1] == delim)) {
1631 /* No it is not. Set the password to NULL */
1632 kfree(vol->password);
1633 vol->password = NULL;
1636 /* Yes it is. Drop down to Opt_pass below.*/
1638 /* Obtain the value string */
1639 value = strchr(data, '=');
1642 /* Set tmp_end to end of the string */
1643 tmp_end = (char *) value + strlen(value);
1645 /* Check if following character is the deliminator
1646 * If yes, we have encountered a double deliminator
1647 * reset the NULL character to the deliminator
1649 if (tmp_end < end && tmp_end[1] == delim) {
1652 /* Keep iterating until we get to a single
1653 * deliminator OR the end
1655 while ((tmp_end = strchr(tmp_end, delim))
1656 != NULL && (tmp_end[1] == delim)) {
1657 tmp_end = (char *) &tmp_end[2];
1660 /* Reset var options to point to next element */
1663 options = (char *) &tmp_end[1];
1665 /* Reached the end of the mount option
1670 kfree(vol->password);
1671 /* Now build new password string */
1672 temp_len = strlen(value);
1673 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1674 if (vol->password == NULL) {
1675 pr_warn("CIFS: no memory for password\n");
1676 goto cifs_parse_mount_err;
1679 for (i = 0, j = 0; i < temp_len; i++, j++) {
1680 vol->password[j] = value[i];
1681 if ((value[i] == delim) &&
1682 value[i+1] == delim)
1683 /* skip the second deliminator */
1686 vol->password[j] = '\0';
1689 /* FIXME: should this be an error instead? */
1693 string = match_strdup(args);
1697 if (!cifs_convert_address(dstaddr, string,
1699 pr_err("CIFS: bad ip= option (%s).\n", string);
1700 goto cifs_parse_mount_err;
1705 string = match_strdup(args);
1709 if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
1710 == CIFS_MAX_DOMAINNAME_LEN) {
1711 pr_warn("CIFS: domain name too long\n");
1712 goto cifs_parse_mount_err;
1715 kfree(vol->domainname);
1716 vol->domainname = kstrdup(string, GFP_KERNEL);
1717 if (!vol->domainname) {
1718 pr_warn("CIFS: no memory for domainname\n");
1719 goto cifs_parse_mount_err;
1721 cifs_dbg(FYI, "Domain name set\n");
1724 string = match_strdup(args);
1728 if (!cifs_convert_address(
1729 (struct sockaddr *)&vol->srcaddr,
1730 string, strlen(string))) {
1731 pr_warn("CIFS: Could not parse srcaddr: %s\n",
1733 goto cifs_parse_mount_err;
1737 string = match_strdup(args);
1741 if (strnlen(string, 1024) >= 65) {
1742 pr_warn("CIFS: iocharset name too long.\n");
1743 goto cifs_parse_mount_err;
1746 if (strncasecmp(string, "default", 7) != 0) {
1747 kfree(vol->iocharset);
1748 vol->iocharset = kstrdup(string,
1750 if (!vol->iocharset) {
1751 pr_warn("CIFS: no memory for charset\n");
1752 goto cifs_parse_mount_err;
1755 /* if iocharset not set then load_nls_default
1758 cifs_dbg(FYI, "iocharset set to %s\n", string);
1760 case Opt_netbiosname:
1761 string = match_strdup(args);
1765 memset(vol->source_rfc1001_name, 0x20,
1768 * FIXME: are there cases in which a comma can
1769 * be valid in workstation netbios name (and
1770 * need special handling)?
1772 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1773 /* don't ucase netbiosname for user */
1776 vol->source_rfc1001_name[i] = string[i];
1778 /* The string has 16th byte zero still from
1779 * set at top of the function
1781 if (i == RFC1001_NAME_LEN && string[i] != 0)
1782 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
1785 /* servernetbiosname specified override *SMBSERVER */
1786 string = match_strdup(args);
1790 /* last byte, type, is 0x20 for servr type */
1791 memset(vol->target_rfc1001_name, 0x20,
1792 RFC1001_NAME_LEN_WITH_NULL);
1794 /* BB are there cases in which a comma can be
1795 valid in this workstation netbios name
1796 (and need special handling)? */
1798 /* user or mount helper must uppercase the
1800 for (i = 0; i < 15; i++) {
1803 vol->target_rfc1001_name[i] = string[i];
1805 /* The string has 16th byte zero still from
1806 set at top of the function */
1807 if (i == RFC1001_NAME_LEN && string[i] != 0)
1808 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
1811 string = match_strdup(args);
1815 if (strncasecmp(string, "1", 1) == 0) {
1816 /* This is the default */
1819 /* For all other value, error */
1820 pr_warn("CIFS: Invalid version specified\n");
1821 goto cifs_parse_mount_err;
1823 string = match_strdup(args);
1827 if (cifs_parse_smb_version(string, vol) != 0)
1828 goto cifs_parse_mount_err;
1831 string = match_strdup(args);
1835 if (cifs_parse_security_flavors(string, vol) != 0)
1836 goto cifs_parse_mount_err;
1839 string = match_strdup(args);
1843 if (cifs_parse_cache_flavor(string, vol) != 0)
1844 goto cifs_parse_mount_err;
1848 * An option we don't recognize. Save it off for later
1849 * if we haven't already found one
1855 /* Free up any allocated string */
1860 if (!sloppy && invalid) {
1861 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid);
1862 goto cifs_parse_mount_err;
1866 /* Muliuser mounts require CONFIG_KEYS support */
1867 if (vol->multiuser) {
1868 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
1869 goto cifs_parse_mount_err;
1873 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
1874 goto cifs_parse_mount_err;
1877 /* make sure UNC has a share name */
1878 if (!strchr(vol->UNC + 3, '\\')) {
1879 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
1880 goto cifs_parse_mount_err;
1884 /* No ip= option specified? Try to get it from UNC */
1885 if (!cifs_convert_address(dstaddr, &vol->UNC[2],
1886 strlen(&vol->UNC[2]))) {
1887 pr_err("Unable to determine destination address.\n");
1888 goto cifs_parse_mount_err;
1892 /* set the port that we got earlier */
1893 cifs_set_port(dstaddr, port);
1896 vol->override_uid = override_uid;
1897 else if (override_uid == 1)
1898 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
1901 vol->override_gid = override_gid;
1902 else if (override_gid == 1)
1903 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
1905 kfree(mountdata_copy);
1909 pr_warn("Could not allocate temporary buffer\n");
1910 cifs_parse_mount_err:
1912 kfree(mountdata_copy);
1916 /** Returns true if srcaddr isn't specified and rhs isn't
1917 * specified, or if srcaddr is specified and
1918 * matches the IP address of the rhs argument.
1921 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1923 switch (srcaddr->sa_family) {
1925 return (rhs->sa_family == AF_UNSPEC);
1927 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1928 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1929 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1932 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1933 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
1934 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1938 return false; /* don't expect to be here */
1943 * If no port is specified in addr structure, we try to match with 445 port
1944 * and if it fails - with 139 ports. It should be called only if address
1945 * families of server and addr are equal.
1948 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1950 __be16 port, *sport;
1952 switch (addr->sa_family) {
1954 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1955 port = ((struct sockaddr_in *) addr)->sin_port;
1958 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1959 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1967 port = htons(CIFS_PORT);
1971 port = htons(RFC1001_PORT);
1974 return port == *sport;
1978 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1979 struct sockaddr *srcaddr)
1981 switch (addr->sa_family) {
1983 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1984 struct sockaddr_in *srv_addr4 =
1985 (struct sockaddr_in *)&server->dstaddr;
1987 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1992 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1993 struct sockaddr_in6 *srv_addr6 =
1994 (struct sockaddr_in6 *)&server->dstaddr;
1996 if (!ipv6_addr_equal(&addr6->sin6_addr,
1997 &srv_addr6->sin6_addr))
1999 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
2005 return false; /* don't expect to be here */
2008 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2015 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2018 * The select_sectype function should either return the vol->sectype
2019 * that was specified, or "Unspecified" if that sectype was not
2020 * compatible with the given NEGOTIATE request.
2022 if (select_sectype(server, vol->sectype) == Unspecified)
2026 * Now check if signing mode is acceptable. No need to check
2027 * global_secflags at this point since if MUST_SIGN is set then
2028 * the server->sign had better be too.
2030 if (vol->sign && !server->sign)
2036 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2038 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2040 if (vol->nosharesock)
2043 if ((server->vals != vol->vals) || (server->ops != vol->ops))
2046 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2049 if (!match_address(server, addr,
2050 (struct sockaddr *)&vol->srcaddr))
2053 if (!match_port(server, addr))
2056 if (!match_security(server, vol))
2062 static struct TCP_Server_Info *
2063 cifs_find_tcp_session(struct smb_vol *vol)
2065 struct TCP_Server_Info *server;
2067 spin_lock(&cifs_tcp_ses_lock);
2068 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2069 if (!match_server(server, vol))
2072 ++server->srv_count;
2073 spin_unlock(&cifs_tcp_ses_lock);
2074 cifs_dbg(FYI, "Existing tcp session with server found\n");
2077 spin_unlock(&cifs_tcp_ses_lock);
2082 cifs_put_tcp_session(struct TCP_Server_Info *server)
2084 struct task_struct *task;
2086 spin_lock(&cifs_tcp_ses_lock);
2087 if (--server->srv_count > 0) {
2088 spin_unlock(&cifs_tcp_ses_lock);
2092 put_net(cifs_net_ns(server));
2094 list_del_init(&server->tcp_ses_list);
2095 spin_unlock(&cifs_tcp_ses_lock);
2097 cancel_delayed_work_sync(&server->echo);
2099 spin_lock(&GlobalMid_Lock);
2100 server->tcpStatus = CifsExiting;
2101 spin_unlock(&GlobalMid_Lock);
2103 cifs_crypto_shash_release(server);
2104 cifs_fscache_release_client_cookie(server);
2106 kfree(server->session_key.response);
2107 server->session_key.response = NULL;
2108 server->session_key.len = 0;
2110 task = xchg(&server->tsk, NULL);
2112 force_sig(SIGKILL, task);
2115 static struct TCP_Server_Info *
2116 cifs_get_tcp_session(struct smb_vol *volume_info)
2118 struct TCP_Server_Info *tcp_ses = NULL;
2121 cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
2123 /* see if we already have a matching tcp_ses */
2124 tcp_ses = cifs_find_tcp_session(volume_info);
2128 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2134 tcp_ses->ops = volume_info->ops;
2135 tcp_ses->vals = volume_info->vals;
2136 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2137 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2138 if (IS_ERR(tcp_ses->hostname)) {
2139 rc = PTR_ERR(tcp_ses->hostname);
2140 goto out_err_crypto_release;
2143 tcp_ses->noblocksnd = volume_info->noblocksnd;
2144 tcp_ses->noautotune = volume_info->noautotune;
2145 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2146 tcp_ses->in_flight = 0;
2147 tcp_ses->credits = 1;
2148 init_waitqueue_head(&tcp_ses->response_q);
2149 init_waitqueue_head(&tcp_ses->request_q);
2150 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2151 mutex_init(&tcp_ses->srv_mutex);
2152 memcpy(tcp_ses->workstation_RFC1001_name,
2153 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2154 memcpy(tcp_ses->server_RFC1001_name,
2155 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2156 tcp_ses->session_estab = false;
2157 tcp_ses->sequence_number = 0;
2158 tcp_ses->lstrp = jiffies;
2159 spin_lock_init(&tcp_ses->req_lock);
2160 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2161 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2162 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2163 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2164 sizeof(tcp_ses->srcaddr));
2165 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2166 sizeof(tcp_ses->dstaddr));
2167 #ifdef CONFIG_CIFS_SMB2
2168 get_random_bytes(tcp_ses->client_guid, SMB2_CLIENT_GUID_SIZE);
2171 * at this point we are the only ones with the pointer
2172 * to the struct since the kernel thread not created yet
2173 * no need to spinlock this init of tcpStatus or srv_count
2175 tcp_ses->tcpStatus = CifsNew;
2176 ++tcp_ses->srv_count;
2178 rc = ip_connect(tcp_ses);
2180 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
2181 goto out_err_crypto_release;
2185 * since we're in a cifs function already, we know that
2186 * this will succeed. No need for try_module_get().
2188 __module_get(THIS_MODULE);
2189 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2191 if (IS_ERR(tcp_ses->tsk)) {
2192 rc = PTR_ERR(tcp_ses->tsk);
2193 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
2194 module_put(THIS_MODULE);
2195 goto out_err_crypto_release;
2197 tcp_ses->tcpStatus = CifsNeedNegotiate;
2199 /* thread spawned, put it on the list */
2200 spin_lock(&cifs_tcp_ses_lock);
2201 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2202 spin_unlock(&cifs_tcp_ses_lock);
2204 cifs_fscache_get_client_cookie(tcp_ses);
2206 /* queue echo request delayed work */
2207 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
2211 out_err_crypto_release:
2212 cifs_crypto_shash_release(tcp_ses);
2214 put_net(cifs_net_ns(tcp_ses));
2218 if (!IS_ERR(tcp_ses->hostname))
2219 kfree(tcp_ses->hostname);
2220 if (tcp_ses->ssocket)
2221 sock_release(tcp_ses->ssocket);
2227 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2229 if (vol->sectype != Unspecified &&
2230 vol->sectype != ses->sectype)
2233 switch (ses->sectype) {
2235 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2239 /* NULL username means anonymous session */
2240 if (ses->user_name == NULL) {
2246 /* anything else takes username/password */
2247 if (strncmp(ses->user_name,
2248 vol->username ? vol->username : "",
2249 CIFS_MAX_USERNAME_LEN))
2251 if ((vol->username && strlen(vol->username) != 0) &&
2252 ses->password != NULL &&
2253 strncmp(ses->password,
2254 vol->password ? vol->password : "",
2255 CIFS_MAX_PASSWORD_LEN))
2261 static struct cifs_ses *
2262 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2264 struct cifs_ses *ses;
2266 spin_lock(&cifs_tcp_ses_lock);
2267 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2268 if (ses->status == CifsExiting)
2270 if (!match_session(ses, vol))
2273 spin_unlock(&cifs_tcp_ses_lock);
2276 spin_unlock(&cifs_tcp_ses_lock);
2281 cifs_put_smb_ses(struct cifs_ses *ses)
2283 unsigned int rc, xid;
2284 struct TCP_Server_Info *server = ses->server;
2286 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
2288 spin_lock(&cifs_tcp_ses_lock);
2289 if (ses->status == CifsExiting) {
2290 spin_unlock(&cifs_tcp_ses_lock);
2293 if (--ses->ses_count > 0) {
2294 spin_unlock(&cifs_tcp_ses_lock);
2297 if (ses->status == CifsGood)
2298 ses->status = CifsExiting;
2299 spin_unlock(&cifs_tcp_ses_lock);
2301 if (ses->status == CifsExiting && server->ops->logoff) {
2303 rc = server->ops->logoff(xid, ses);
2305 cifs_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
2310 spin_lock(&cifs_tcp_ses_lock);
2311 list_del_init(&ses->smb_ses_list);
2312 spin_unlock(&cifs_tcp_ses_lock);
2315 cifs_put_tcp_session(server);
2320 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2321 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2323 /* Populate username and pw fields from keyring if possible */
2325 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2328 const char *delim, *payload;
2332 struct TCP_Server_Info *server = ses->server;
2333 struct sockaddr_in *sa;
2334 struct sockaddr_in6 *sa6;
2335 const struct user_key_payload *upayload;
2337 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2341 /* try to find an address key first */
2342 switch (server->dstaddr.ss_family) {
2344 sa = (struct sockaddr_in *)&server->dstaddr;
2345 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2348 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2349 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2352 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2353 server->dstaddr.ss_family);
2358 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2359 key = request_key(&key_type_logon, desc, "");
2361 if (!ses->domainName) {
2362 cifs_dbg(FYI, "domainName is NULL\n");
2367 /* didn't work, try to find a domain key */
2368 sprintf(desc, "cifs:d:%s", ses->domainName);
2369 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2370 key = request_key(&key_type_logon, desc, "");
2377 down_read(&key->sem);
2378 upayload = user_key_payload(key);
2379 if (IS_ERR_OR_NULL(upayload)) {
2380 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2384 /* find first : in payload */
2385 payload = upayload->data;
2386 delim = strnchr(payload, upayload->datalen, ':');
2387 cifs_dbg(FYI, "payload=%s\n", payload);
2389 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
2395 len = delim - payload;
2396 if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
2397 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
2403 vol->username = kstrndup(payload, len, GFP_KERNEL);
2404 if (!vol->username) {
2405 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
2410 cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
2412 len = key->datalen - (len + 1);
2413 if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
2414 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
2416 kfree(vol->username);
2417 vol->username = NULL;
2422 vol->password = kstrndup(delim, len, GFP_KERNEL);
2423 if (!vol->password) {
2424 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
2427 kfree(vol->username);
2428 vol->username = NULL;
2437 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
2440 #else /* ! CONFIG_KEYS */
2442 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2443 struct cifs_ses *ses __attribute__((unused)))
2447 #endif /* CONFIG_KEYS */
2449 static struct cifs_ses *
2450 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2454 struct cifs_ses *ses;
2455 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2456 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2460 ses = cifs_find_smb_ses(server, volume_info);
2462 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
2465 mutex_lock(&ses->session_mutex);
2466 rc = cifs_negotiate_protocol(xid, ses);
2468 mutex_unlock(&ses->session_mutex);
2469 /* problem -- put our ses reference */
2470 cifs_put_smb_ses(ses);
2474 if (ses->need_reconnect) {
2475 cifs_dbg(FYI, "Session needs reconnect\n");
2476 rc = cifs_setup_session(xid, ses,
2477 volume_info->local_nls);
2479 mutex_unlock(&ses->session_mutex);
2480 /* problem -- put our reference */
2481 cifs_put_smb_ses(ses);
2486 mutex_unlock(&ses->session_mutex);
2488 /* existing SMB ses has a server reference already */
2489 cifs_put_tcp_session(server);
2494 cifs_dbg(FYI, "Existing smb sess not found\n");
2495 ses = sesInfoAlloc();
2499 /* new SMB session uses our server ref */
2500 ses->server = server;
2501 if (server->dstaddr.ss_family == AF_INET6)
2502 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2504 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2506 if (volume_info->username) {
2507 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2508 if (!ses->user_name)
2512 /* volume_info->password freed at unmount */
2513 if (volume_info->password) {
2514 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2518 if (volume_info->domainname) {
2519 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2520 if (!ses->domainName)
2523 ses->cred_uid = volume_info->cred_uid;
2524 ses->linux_uid = volume_info->linux_uid;
2526 ses->sectype = volume_info->sectype;
2527 ses->sign = volume_info->sign;
2529 mutex_lock(&ses->session_mutex);
2530 rc = cifs_negotiate_protocol(xid, ses);
2532 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2533 mutex_unlock(&ses->session_mutex);
2537 /* success, put it on the list */
2538 spin_lock(&cifs_tcp_ses_lock);
2539 list_add(&ses->smb_ses_list, &server->smb_ses_list);
2540 spin_unlock(&cifs_tcp_ses_lock);
2551 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2553 if (tcon->tidStatus == CifsExiting)
2555 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2560 static struct cifs_tcon *
2561 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2563 struct list_head *tmp;
2564 struct cifs_tcon *tcon;
2566 spin_lock(&cifs_tcp_ses_lock);
2567 list_for_each(tmp, &ses->tcon_list) {
2568 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2569 if (!match_tcon(tcon, unc))
2572 spin_unlock(&cifs_tcp_ses_lock);
2575 spin_unlock(&cifs_tcp_ses_lock);
2580 cifs_put_tcon(struct cifs_tcon *tcon)
2583 struct cifs_ses *ses = tcon->ses;
2585 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2586 spin_lock(&cifs_tcp_ses_lock);
2587 if (--tcon->tc_count > 0) {
2588 spin_unlock(&cifs_tcp_ses_lock);
2592 list_del_init(&tcon->tcon_list);
2593 spin_unlock(&cifs_tcp_ses_lock);
2596 if (ses->server->ops->tree_disconnect)
2597 ses->server->ops->tree_disconnect(xid, tcon);
2600 cifs_fscache_release_super_cookie(tcon);
2602 cifs_put_smb_ses(ses);
2605 static struct cifs_tcon *
2606 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2609 struct cifs_tcon *tcon;
2611 tcon = cifs_find_tcon(ses, volume_info->UNC);
2613 cifs_dbg(FYI, "Found match on UNC path\n");
2614 /* existing tcon already has a reference */
2615 cifs_put_smb_ses(ses);
2616 if (tcon->seal != volume_info->seal)
2617 cifs_dbg(VFS, "transport encryption setting conflicts with existing tid\n");
2621 if (!ses->server->ops->tree_connect) {
2626 tcon = tconInfoAlloc();
2633 if (volume_info->password) {
2634 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2635 if (!tcon->password) {
2642 * BB Do we need to wrap session_mutex around this TCon call and Unix
2643 * SetFS as we do on SessSetup and reconnect?
2646 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2647 volume_info->local_nls);
2649 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
2653 if (volume_info->nodfs) {
2654 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2655 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
2657 tcon->seal = volume_info->seal;
2659 * We can have only one retry value for a connection to a share so for
2660 * resources mounted more than once to the same server share the last
2661 * value passed in for the retry flag is used.
2663 tcon->retry = volume_info->retry;
2664 tcon->nocase = volume_info->nocase;
2665 tcon->local_lease = volume_info->local_lease;
2666 INIT_LIST_HEAD(&tcon->pending_opens);
2668 spin_lock(&cifs_tcp_ses_lock);
2669 list_add(&tcon->tcon_list, &ses->tcon_list);
2670 spin_unlock(&cifs_tcp_ses_lock);
2672 cifs_fscache_get_super_cookie(tcon);
2682 cifs_put_tlink(struct tcon_link *tlink)
2684 if (!tlink || IS_ERR(tlink))
2687 if (!atomic_dec_and_test(&tlink->tl_count) ||
2688 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2689 tlink->tl_time = jiffies;
2693 if (!IS_ERR(tlink_tcon(tlink)))
2694 cifs_put_tcon(tlink_tcon(tlink));
2699 static inline struct tcon_link *
2700 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2702 return cifs_sb->master_tlink;
2706 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2708 struct cifs_sb_info *old = CIFS_SB(sb);
2709 struct cifs_sb_info *new = mnt_data->cifs_sb;
2711 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2714 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2715 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2719 * We want to share sb only if we don't specify an r/wsize or
2720 * specified r/wsize is greater than or equal to existing one.
2722 if (new->wsize && new->wsize < old->wsize)
2725 if (new->rsize && new->rsize < old->rsize)
2728 if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
2731 if (old->mnt_file_mode != new->mnt_file_mode ||
2732 old->mnt_dir_mode != new->mnt_dir_mode)
2735 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2738 if (old->actimeo != new->actimeo)
2745 cifs_match_super(struct super_block *sb, void *data)
2747 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2748 struct smb_vol *volume_info;
2749 struct cifs_sb_info *cifs_sb;
2750 struct TCP_Server_Info *tcp_srv;
2751 struct cifs_ses *ses;
2752 struct cifs_tcon *tcon;
2753 struct tcon_link *tlink;
2756 spin_lock(&cifs_tcp_ses_lock);
2757 cifs_sb = CIFS_SB(sb);
2758 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2759 if (IS_ERR(tlink)) {
2760 spin_unlock(&cifs_tcp_ses_lock);
2763 tcon = tlink_tcon(tlink);
2765 tcp_srv = ses->server;
2767 volume_info = mnt_data->vol;
2769 if (!match_server(tcp_srv, volume_info) ||
2770 !match_session(ses, volume_info) ||
2771 !match_tcon(tcon, volume_info->UNC)) {
2776 rc = compare_mount_options(sb, mnt_data);
2778 spin_unlock(&cifs_tcp_ses_lock);
2779 cifs_put_tlink(tlink);
2784 get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
2785 const struct nls_table *nls_codepage, unsigned int *num_referrals,
2786 struct dfs_info3_param **referrals, int remap)
2791 if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
2797 if (ses->ipc_tid == 0) {
2798 temp_unc = kmalloc(2 /* for slashes */ +
2799 strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2800 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
2801 if (temp_unc == NULL)
2805 strcpy(temp_unc + 2, ses->serverName);
2806 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2807 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2809 cifs_dbg(FYI, "Tcon rc = %d ipc_tid = %d\n", rc, ses->ipc_tid);
2813 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
2814 referrals, num_referrals,
2815 nls_codepage, remap);
2817 * BB - map targetUNCs to dfs_info3 structures, here or in
2818 * ses->server->ops->get_dfs_refer.
2824 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2825 static struct lock_class_key cifs_key[2];
2826 static struct lock_class_key cifs_slock_key[2];
2829 cifs_reclassify_socket4(struct socket *sock)
2831 struct sock *sk = sock->sk;
2832 BUG_ON(sock_owned_by_user(sk));
2833 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2834 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2838 cifs_reclassify_socket6(struct socket *sock)
2840 struct sock *sk = sock->sk;
2841 BUG_ON(sock_owned_by_user(sk));
2842 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2843 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2847 cifs_reclassify_socket4(struct socket *sock)
2852 cifs_reclassify_socket6(struct socket *sock)
2857 /* See RFC1001 section 14 on representation of Netbios names */
2858 static void rfc1002mangle(char *target, char *source, unsigned int length)
2862 for (i = 0, j = 0; i < (length); i++) {
2863 /* mask a nibble at a time and encode */
2864 target[j] = 'A' + (0x0F & (source[i] >> 4));
2865 target[j+1] = 'A' + (0x0F & source[i]);
2872 bind_socket(struct TCP_Server_Info *server)
2875 if (server->srcaddr.ss_family != AF_UNSPEC) {
2876 /* Bind to the specified local IP address */
2877 struct socket *socket = server->ssocket;
2878 rc = socket->ops->bind(socket,
2879 (struct sockaddr *) &server->srcaddr,
2880 sizeof(server->srcaddr));
2882 struct sockaddr_in *saddr4;
2883 struct sockaddr_in6 *saddr6;
2884 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2885 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2886 if (saddr6->sin6_family == AF_INET6)
2887 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
2888 &saddr6->sin6_addr, rc);
2890 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
2891 &saddr4->sin_addr.s_addr, rc);
2898 ip_rfc1001_connect(struct TCP_Server_Info *server)
2902 * some servers require RFC1001 sessinit before sending
2903 * negprot - BB check reconnection in case where second
2904 * sessinit is sent but no second negprot
2906 struct rfc1002_session_packet *ses_init_buf;
2907 struct smb_hdr *smb_buf;
2908 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2911 ses_init_buf->trailer.session_req.called_len = 32;
2913 if (server->server_RFC1001_name &&
2914 server->server_RFC1001_name[0] != 0)
2915 rfc1002mangle(ses_init_buf->trailer.
2916 session_req.called_name,
2917 server->server_RFC1001_name,
2918 RFC1001_NAME_LEN_WITH_NULL);
2920 rfc1002mangle(ses_init_buf->trailer.
2921 session_req.called_name,
2922 DEFAULT_CIFS_CALLED_NAME,
2923 RFC1001_NAME_LEN_WITH_NULL);
2925 ses_init_buf->trailer.session_req.calling_len = 32;
2928 * calling name ends in null (byte 16) from old smb
2931 if (server->workstation_RFC1001_name[0] != 0)
2932 rfc1002mangle(ses_init_buf->trailer.
2933 session_req.calling_name,
2934 server->workstation_RFC1001_name,
2935 RFC1001_NAME_LEN_WITH_NULL);
2937 rfc1002mangle(ses_init_buf->trailer.
2938 session_req.calling_name,
2940 RFC1001_NAME_LEN_WITH_NULL);
2942 ses_init_buf->trailer.session_req.scope1 = 0;
2943 ses_init_buf->trailer.session_req.scope2 = 0;
2944 smb_buf = (struct smb_hdr *)ses_init_buf;
2946 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2947 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
2948 rc = smb_send(server, smb_buf, 0x44);
2949 kfree(ses_init_buf);
2951 * RFC1001 layer in at least one server
2952 * requires very short break before negprot
2953 * presumably because not expecting negprot
2954 * to follow so fast. This is a simple
2955 * solution that works without
2956 * complicating the code and causes no
2957 * significant slowing down on mount
2960 usleep_range(1000, 2000);
2963 * else the negprot may still work without this
2964 * even though malloc failed
2971 generic_ip_connect(struct TCP_Server_Info *server)
2976 struct socket *socket = server->ssocket;
2977 struct sockaddr *saddr;
2979 saddr = (struct sockaddr *) &server->dstaddr;
2981 if (server->dstaddr.ss_family == AF_INET6) {
2982 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2983 slen = sizeof(struct sockaddr_in6);
2986 sport = ((struct sockaddr_in *) saddr)->sin_port;
2987 slen = sizeof(struct sockaddr_in);
2991 if (socket == NULL) {
2992 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2993 IPPROTO_TCP, &socket, 1);
2995 cifs_dbg(VFS, "Error %d creating socket\n", rc);
2996 server->ssocket = NULL;
3000 /* BB other socket options to set KEEPALIVE, NODELAY? */
3001 cifs_dbg(FYI, "Socket created\n");
3002 server->ssocket = socket;
3003 socket->sk->sk_allocation = GFP_NOFS;
3004 if (sfamily == AF_INET6)
3005 cifs_reclassify_socket6(socket);
3007 cifs_reclassify_socket4(socket);
3010 rc = bind_socket(server);
3015 * Eventually check for other socket options to change from
3016 * the default. sock_setsockopt not used because it expects
3019 socket->sk->sk_rcvtimeo = 7 * HZ;
3020 socket->sk->sk_sndtimeo = 5 * HZ;
3022 /* make the bufsizes depend on wsize/rsize and max requests */
3023 if (server->noautotune) {
3024 if (socket->sk->sk_sndbuf < (200 * 1024))
3025 socket->sk->sk_sndbuf = 200 * 1024;
3026 if (socket->sk->sk_rcvbuf < (140 * 1024))
3027 socket->sk->sk_rcvbuf = 140 * 1024;
3030 if (server->tcp_nodelay) {
3032 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3033 (char *)&val, sizeof(val));
3035 cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3039 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3040 socket->sk->sk_sndbuf,
3041 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3043 rc = socket->ops->connect(socket, saddr, slen, 0);
3045 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3046 sock_release(socket);
3047 server->ssocket = NULL;
3051 if (sport == htons(RFC1001_PORT))
3052 rc = ip_rfc1001_connect(server);
3058 ip_connect(struct TCP_Server_Info *server)
3061 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3062 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3064 if (server->dstaddr.ss_family == AF_INET6)
3065 sport = &addr6->sin6_port;
3067 sport = &addr->sin_port;
3072 /* try with 445 port at first */
3073 *sport = htons(CIFS_PORT);
3075 rc = generic_ip_connect(server);
3079 /* if it failed, try with 139 port */
3080 *sport = htons(RFC1001_PORT);
3083 return generic_ip_connect(server);
3086 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3087 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3089 /* if we are reconnecting then should we check to see if
3090 * any requested capabilities changed locally e.g. via
3091 * remount but we can not do much about it here
3092 * if they have (even if we could detect it by the following)
3093 * Perhaps we could add a backpointer to array of sb from tcon
3094 * or if we change to make all sb to same share the same
3095 * sb as NFS - then we only have one backpointer to sb.
3096 * What if we wanted to mount the server share twice once with
3097 * and once without posixacls or posix paths? */
3098 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3100 if (vol_info && vol_info->no_linux_ext) {
3101 tcon->fsUnixInfo.Capability = 0;
3102 tcon->unix_ext = 0; /* Unix Extensions disabled */
3103 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
3105 } else if (vol_info)
3106 tcon->unix_ext = 1; /* Unix Extensions supported */
3108 if (tcon->unix_ext == 0) {
3109 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
3113 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3114 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3115 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
3116 /* check for reconnect case in which we do not
3117 want to change the mount behavior if we can avoid it */
3118 if (vol_info == NULL) {
3119 /* turn off POSIX ACL and PATHNAMES if not set
3120 originally at mount time */
3121 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3122 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3123 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3124 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3125 cifs_dbg(VFS, "POSIXPATH support change\n");
3126 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3127 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3128 cifs_dbg(VFS, "possible reconnect error\n");
3129 cifs_dbg(VFS, "server disabled POSIX path support\n");
3133 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3134 cifs_dbg(VFS, "per-share encryption not supported yet\n");
3136 cap &= CIFS_UNIX_CAP_MASK;
3137 if (vol_info && vol_info->no_psx_acl)
3138 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3139 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3140 cifs_dbg(FYI, "negotiated posix acl support\n");
3142 cifs_sb->mnt_cifs_flags |=
3143 CIFS_MOUNT_POSIXACL;
3146 if (vol_info && vol_info->posix_paths == 0)
3147 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3148 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3149 cifs_dbg(FYI, "negotiate posix pathnames\n");
3151 cifs_sb->mnt_cifs_flags |=
3152 CIFS_MOUNT_POSIX_PATHS;
3155 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
3156 #ifdef CONFIG_CIFS_DEBUG2
3157 if (cap & CIFS_UNIX_FCNTL_CAP)
3158 cifs_dbg(FYI, "FCNTL cap\n");
3159 if (cap & CIFS_UNIX_EXTATTR_CAP)
3160 cifs_dbg(FYI, "EXTATTR cap\n");
3161 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3162 cifs_dbg(FYI, "POSIX path cap\n");
3163 if (cap & CIFS_UNIX_XATTR_CAP)
3164 cifs_dbg(FYI, "XATTR cap\n");
3165 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3166 cifs_dbg(FYI, "POSIX ACL cap\n");
3167 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3168 cifs_dbg(FYI, "very large read cap\n");
3169 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3170 cifs_dbg(FYI, "very large write cap\n");
3171 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3172 cifs_dbg(FYI, "transport encryption cap\n");
3173 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3174 cifs_dbg(FYI, "mandatory transport encryption cap\n");
3175 #endif /* CIFS_DEBUG2 */
3176 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3177 if (vol_info == NULL) {
3178 cifs_dbg(FYI, "resetting capabilities failed\n");
3180 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");
3186 void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3187 struct cifs_sb_info *cifs_sb)
3189 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3191 spin_lock_init(&cifs_sb->tlink_tree_lock);
3192 cifs_sb->tlink_tree = RB_ROOT;
3195 * Temporarily set r/wsize for matching superblock. If we end up using
3196 * new sb then client will later negotiate it downward if needed.
3198 cifs_sb->rsize = pvolume_info->rsize;
3199 cifs_sb->wsize = pvolume_info->wsize;
3201 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3202 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3203 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3204 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3205 cifs_dbg(FYI, "file mode: 0x%hx dir mode: 0x%hx\n",
3206 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3208 cifs_sb->actimeo = pvolume_info->actimeo;
3209 cifs_sb->local_nls = pvolume_info->local_nls;
3211 if (pvolume_info->noperm)
3212 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3213 if (pvolume_info->setuids)
3214 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3215 if (pvolume_info->server_ino)
3216 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3217 if (pvolume_info->remap)
3218 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3219 if (pvolume_info->sfu_remap)
3220 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3221 if (pvolume_info->no_xattr)
3222 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3223 if (pvolume_info->sfu_emul)
3224 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3225 if (pvolume_info->nobrl)
3226 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3227 if (pvolume_info->nostrictsync)
3228 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3229 if (pvolume_info->mand_lock)
3230 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3231 if (pvolume_info->rwpidforward)
3232 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3233 if (pvolume_info->cifs_acl)
3234 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3235 if (pvolume_info->backupuid_specified) {
3236 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3237 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3239 if (pvolume_info->backupgid_specified) {
3240 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3241 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3243 if (pvolume_info->override_uid)
3244 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3245 if (pvolume_info->override_gid)
3246 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3247 if (pvolume_info->dynperm)
3248 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3249 if (pvolume_info->fsc)
3250 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3251 if (pvolume_info->multiuser)
3252 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3253 CIFS_MOUNT_NO_PERM);
3254 if (pvolume_info->strict_io)
3255 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3256 if (pvolume_info->direct_io) {
3257 cifs_dbg(FYI, "mounting share using direct i/o\n");
3258 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3260 if (pvolume_info->mfsymlinks) {
3261 if (pvolume_info->sfu_emul) {
3263 * Our SFU ("Services for Unix" emulation does not allow
3264 * creating symlinks but does allow reading existing SFU
3265 * symlinks (it does allow both creating and reading SFU
3266 * style mknod and FIFOs though). When "mfsymlinks" and
3267 * "sfu" are both enabled at the same time, it allows
3268 * reading both types of symlinks, but will only create
3269 * them with mfsymlinks format. This allows better
3270 * Apple compatibility (probably better for Samba too)
3271 * while still recognizing old Windows style symlinks.
3273 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
3275 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3278 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3279 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
3283 cleanup_volume_info_contents(struct smb_vol *volume_info)
3285 kfree(volume_info->username);
3286 kzfree(volume_info->password);
3287 kfree(volume_info->UNC);
3288 kfree(volume_info->domainname);
3289 kfree(volume_info->iocharset);
3290 kfree(volume_info->prepath);
3294 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3298 cleanup_volume_info_contents(volume_info);
3303 #ifdef CONFIG_CIFS_DFS_UPCALL
3305 * cifs_build_path_to_root returns full path to root when we do not have an
3306 * exiting connection (tcon)
3309 build_unc_path_to_root(const struct smb_vol *vol,
3310 const struct cifs_sb_info *cifs_sb)
3312 char *full_path, *pos;
3313 unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
3314 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3316 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3317 if (full_path == NULL)
3318 return ERR_PTR(-ENOMEM);
3320 strncpy(full_path, vol->UNC, unc_len);
3321 pos = full_path + unc_len;
3324 *pos = CIFS_DIR_SEP(cifs_sb);
3325 strncpy(pos + 1, vol->prepath, pplen);
3329 *pos = '\0'; /* add trailing null */
3330 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3331 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
3336 * Perform a dfs referral query for a share and (optionally) prefix
3338 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3339 * to a string containing updated options for the submount. Otherwise it
3340 * will be left untouched.
3342 * Returns the rc from get_dfs_path to the caller, which can be used to
3343 * determine whether there were referrals.
3346 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
3347 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3351 unsigned int num_referrals = 0;
3352 struct dfs_info3_param *referrals = NULL;
3353 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3355 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3356 if (IS_ERR(full_path))
3357 return PTR_ERR(full_path);
3359 /* For DFS paths, skip the first '\' of the UNC */
3360 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3362 rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
3363 &num_referrals, &referrals, cifs_remap(cifs_sb));
3365 if (!rc && num_referrals > 0) {
3366 char *fake_devname = NULL;
3368 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3369 full_path + 1, referrals,
3372 free_dfs_info_array(referrals, num_referrals);
3374 if (IS_ERR(mdata)) {
3375 rc = PTR_ERR(mdata);
3378 cleanup_volume_info_contents(volume_info);
3379 rc = cifs_setup_volume_info(volume_info, mdata,
3382 kfree(fake_devname);
3383 kfree(cifs_sb->mountdata);
3384 cifs_sb->mountdata = mdata;
3392 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3393 const char *devname)
3397 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3400 if (volume_info->nullauth) {
3401 cifs_dbg(FYI, "Anonymous login\n");
3402 kfree(volume_info->username);
3403 volume_info->username = NULL;
3404 } else if (volume_info->username) {
3405 /* BB fixme parse for domain name here */
3406 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
3408 cifs_dbg(VFS, "No username specified\n");
3409 /* In userspace mount helper we can get user name from alternate
3410 locations such as env variables and files on disk */
3414 /* this is needed for ASCII cp to Unicode converts */
3415 if (volume_info->iocharset == NULL) {
3416 /* load_nls_default cannot return null */
3417 volume_info->local_nls = load_nls_default();
3419 volume_info->local_nls = load_nls(volume_info->iocharset);
3420 if (volume_info->local_nls == NULL) {
3421 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
3422 volume_info->iocharset);
3431 cifs_get_volume_info(char *mount_data, const char *devname)
3434 struct smb_vol *volume_info;
3436 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
3438 return ERR_PTR(-ENOMEM);
3440 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3442 cifs_cleanup_volume_info(volume_info);
3443 volume_info = ERR_PTR(rc);
3450 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3454 struct cifs_ses *ses;
3455 struct cifs_tcon *tcon;
3456 struct TCP_Server_Info *server;
3458 struct tcon_link *tlink;
3459 #ifdef CONFIG_CIFS_DFS_UPCALL
3460 int referral_walks_count = 0;
3463 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs");
3467 #ifdef CONFIG_CIFS_DFS_UPCALL
3469 /* cleanup activities if we're chasing a referral */
3470 if (referral_walks_count) {
3472 cifs_put_tcon(tcon);
3474 cifs_put_smb_ses(ses);
3476 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
3490 /* get a reference to a tcp session */
3491 server = cifs_get_tcp_session(volume_info);
3492 if (IS_ERR(server)) {
3493 rc = PTR_ERR(server);
3494 bdi_destroy(&cifs_sb->bdi);
3498 /* get a reference to a SMB session */
3499 ses = cifs_get_smb_ses(server, volume_info);
3503 goto mount_fail_check;
3506 /* search for existing tcon to this server share */
3507 tcon = cifs_get_tcon(ses, volume_info);
3511 goto remote_path_check;
3514 /* tell server which Unix caps we support */
3515 if (cap_unix(tcon->ses)) {
3516 /* reset of caps checks mount to see if unix extensions
3517 disabled for just this mount */
3518 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3519 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3520 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3521 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3523 goto mount_fail_check;
3526 tcon->unix_ext = 0; /* server does not support them */
3528 /* do not care if a following call succeed - informational */
3529 if (!tcon->ipc && server->ops->qfs_tcon)
3530 server->ops->qfs_tcon(xid, tcon);
3532 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3533 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
3535 /* tune readahead according to rsize */
3536 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
3539 #ifdef CONFIG_CIFS_DFS_UPCALL
3541 * Perform an unconditional check for whether there are DFS
3542 * referrals for this path without prefix, to provide support
3543 * for DFS referrals from w2k8 servers which don't seem to respond
3544 * with PATH_NOT_COVERED to requests that include the prefix.
3545 * Chase the referral if found, otherwise continue normally.
3547 if (referral_walks_count == 0) {
3548 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3551 referral_walks_count++;
3552 goto try_mount_again;
3557 /* check if a whole path is not remote */
3559 if (!server->ops->is_path_accessible) {
3561 goto mount_fail_check;
3564 * cifs_build_path_to_root works only when we have a valid tcon
3566 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3567 if (full_path == NULL) {
3569 goto mount_fail_check;
3571 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3573 if (rc != 0 && rc != -EREMOTE) {
3575 goto mount_fail_check;
3580 /* get referral if needed */
3581 if (rc == -EREMOTE) {
3582 #ifdef CONFIG_CIFS_DFS_UPCALL
3583 if (referral_walks_count > MAX_NESTED_LINKS) {
3585 * BB: when we implement proper loop detection,
3586 * we will remove this check. But now we need it
3587 * to prevent an indefinite loop if 'DFS tree' is
3588 * misconfigured (i.e. has loops).
3591 goto mount_fail_check;
3594 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
3597 referral_walks_count++;
3598 goto try_mount_again;
3600 goto mount_fail_check;
3601 #else /* No DFS support, return error on mount */
3607 goto mount_fail_check;
3609 /* now, hang the tcon off of the superblock */
3610 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3611 if (tlink == NULL) {
3613 goto mount_fail_check;
3616 tlink->tl_uid = ses->linux_uid;
3617 tlink->tl_tcon = tcon;
3618 tlink->tl_time = jiffies;
3619 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3620 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3622 cifs_sb->master_tlink = tlink;
3623 spin_lock(&cifs_sb->tlink_tree_lock);
3624 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3625 spin_unlock(&cifs_sb->tlink_tree_lock);
3627 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3631 /* on error free sesinfo and tcon struct if needed */
3633 /* If find_unc succeeded then rc == 0 so we can not end */
3634 /* up accidentally freeing someone elses tcon struct */
3636 cifs_put_tcon(tcon);
3638 cifs_put_smb_ses(ses);
3640 cifs_put_tcp_session(server);
3641 bdi_destroy(&cifs_sb->bdi);
3650 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3651 * pointer may be NULL.
3654 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
3655 const char *tree, struct cifs_tcon *tcon,
3656 const struct nls_table *nls_codepage)
3658 struct smb_hdr *smb_buffer;
3659 struct smb_hdr *smb_buffer_response;
3662 unsigned char *bcc_ptr;
3665 __u16 bytes_left, count;
3670 smb_buffer = cifs_buf_get();
3671 if (smb_buffer == NULL)
3674 smb_buffer_response = smb_buffer;
3676 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3677 NULL /*no tid */ , 4 /*wct */ );
3679 smb_buffer->Mid = get_next_mid(ses->server);
3680 smb_buffer->Uid = ses->Suid;
3681 pSMB = (TCONX_REQ *) smb_buffer;
3682 pSMBr = (TCONX_RSP *) smb_buffer_response;
3684 pSMB->AndXCommand = 0xFF;
3685 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3686 bcc_ptr = &pSMB->Password[0];
3687 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3688 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3689 *bcc_ptr = 0; /* password is null byte */
3690 bcc_ptr++; /* skip password */
3691 /* already aligned so no need to do it below */
3693 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3694 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3695 specified as required (when that support is added to
3696 the vfs in the future) as only NTLM or the much
3697 weaker LANMAN (which we do not send by default) is accepted
3698 by Samba (not sure whether other servers allow
3699 NTLMv2 password here) */
3700 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3701 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3702 (ses->sectype == LANMAN))
3703 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3704 ses->server->sec_mode &
3705 SECMODE_PW_ENCRYPT ? true : false,
3708 #endif /* CIFS_WEAK_PW_HASH */
3709 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3710 bcc_ptr, nls_codepage);
3712 cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
3714 cifs_buf_release(smb_buffer);
3718 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3719 if (ses->capabilities & CAP_UNICODE) {
3720 /* must align unicode strings */
3721 *bcc_ptr = 0; /* null byte password */
3726 if (ses->server->sign)
3727 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3729 if (ses->capabilities & CAP_STATUS32) {
3730 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3732 if (ses->capabilities & CAP_DFS) {
3733 smb_buffer->Flags2 |= SMBFLG2_DFS;
3735 if (ses->capabilities & CAP_UNICODE) {
3736 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3738 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3739 6 /* max utf8 char length in bytes */ *
3740 (/* server len*/ + 256 /* share len */), nls_codepage);
3741 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3742 bcc_ptr += 2; /* skip trailing null */
3743 } else { /* ASCII */
3744 strcpy(bcc_ptr, tree);
3745 bcc_ptr += strlen(tree) + 1;
3747 strcpy(bcc_ptr, "?????");
3748 bcc_ptr += strlen("?????");
3750 count = bcc_ptr - &pSMB->Password[0];
3751 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3752 pSMB->hdr.smb_buf_length) + count);
3753 pSMB->ByteCount = cpu_to_le16(count);
3755 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3758 /* above now done in SendReceive */
3759 if ((rc == 0) && (tcon != NULL)) {
3762 tcon->tidStatus = CifsGood;
3763 tcon->need_reconnect = false;
3764 tcon->tid = smb_buffer_response->Tid;
3765 bcc_ptr = pByteArea(smb_buffer_response);
3766 bytes_left = get_bcc(smb_buffer_response);
3767 length = strnlen(bcc_ptr, bytes_left - 2);
3768 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3774 /* skip service field (NB: this field is always ASCII) */
3776 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3777 (bcc_ptr[2] == 'C')) {
3778 cifs_dbg(FYI, "IPC connection\n");
3781 } else if (length == 2) {
3782 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3783 /* the most common case */
3784 cifs_dbg(FYI, "disk share connection\n");
3787 bcc_ptr += length + 1;
3788 bytes_left -= (length + 1);
3789 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
3791 /* mostly informational -- no need to fail on error here */
3792 kfree(tcon->nativeFileSystem);
3793 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
3794 bytes_left, is_unicode,
3797 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
3799 if ((smb_buffer_response->WordCount == 3) ||
3800 (smb_buffer_response->WordCount == 7))
3801 /* field is in same location */
3802 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3805 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
3806 } else if ((rc == 0) && tcon == NULL) {
3807 /* all we need to save for IPC$ connection */
3808 ses->ipc_tid = smb_buffer_response->Tid;
3811 cifs_buf_release(smb_buffer);
3815 static void delayed_free(struct rcu_head *p)
3817 struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
3818 unload_nls(sbi->local_nls);
3823 cifs_umount(struct cifs_sb_info *cifs_sb)
3825 struct rb_root *root = &cifs_sb->tlink_tree;
3826 struct rb_node *node;
3827 struct tcon_link *tlink;
3829 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3831 spin_lock(&cifs_sb->tlink_tree_lock);
3832 while ((node = rb_first(root))) {
3833 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3834 cifs_get_tlink(tlink);
3835 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3836 rb_erase(node, root);
3838 spin_unlock(&cifs_sb->tlink_tree_lock);
3839 cifs_put_tlink(tlink);
3840 spin_lock(&cifs_sb->tlink_tree_lock);
3842 spin_unlock(&cifs_sb->tlink_tree_lock);
3844 bdi_destroy(&cifs_sb->bdi);
3845 kfree(cifs_sb->mountdata);
3846 call_rcu(&cifs_sb->rcu, delayed_free);
3850 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
3853 struct TCP_Server_Info *server = ses->server;
3855 if (!server->ops->need_neg || !server->ops->negotiate)
3858 /* only send once per connect */
3859 if (!server->ops->need_neg(server))
3862 set_credits(server, 1);
3864 rc = server->ops->negotiate(xid, ses);
3866 spin_lock(&GlobalMid_Lock);
3867 if (server->tcpStatus == CifsNeedNegotiate)
3868 server->tcpStatus = CifsGood;
3871 spin_unlock(&GlobalMid_Lock);
3878 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
3879 struct nls_table *nls_info)
3882 struct TCP_Server_Info *server = ses->server;
3884 ses->capabilities = server->capabilities;
3885 if (linuxExtEnabled == 0)
3886 ses->capabilities &= (~server->vals->cap_unix);
3888 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
3889 server->sec_mode, server->capabilities, server->timeAdj);
3891 if (server->ops->sess_setup)
3892 rc = server->ops->sess_setup(xid, ses, nls_info);
3895 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
3901 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
3903 vol->sectype = ses->sectype;
3905 /* krb5 is special, since we don't need username or pw */
3906 if (vol->sectype == Kerberos)
3909 return cifs_set_cifscreds(vol, ses);
3912 static struct cifs_tcon *
3913 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
3916 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3917 struct cifs_ses *ses;
3918 struct cifs_tcon *tcon = NULL;
3919 struct smb_vol *vol_info;
3921 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3922 if (vol_info == NULL)
3923 return ERR_PTR(-ENOMEM);
3925 vol_info->local_nls = cifs_sb->local_nls;
3926 vol_info->linux_uid = fsuid;
3927 vol_info->cred_uid = fsuid;
3928 vol_info->UNC = master_tcon->treeName;
3929 vol_info->retry = master_tcon->retry;
3930 vol_info->nocase = master_tcon->nocase;
3931 vol_info->local_lease = master_tcon->local_lease;
3932 vol_info->no_linux_ext = !master_tcon->unix_ext;
3933 vol_info->sectype = master_tcon->ses->sectype;
3934 vol_info->sign = master_tcon->ses->sign;
3936 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
3942 /* get a reference for the same TCP session */
3943 spin_lock(&cifs_tcp_ses_lock);
3944 ++master_tcon->ses->server->srv_count;
3945 spin_unlock(&cifs_tcp_ses_lock);
3947 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3949 tcon = (struct cifs_tcon *)ses;
3950 cifs_put_tcp_session(master_tcon->ses->server);
3954 tcon = cifs_get_tcon(ses, vol_info);
3956 cifs_put_smb_ses(ses);
3961 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3963 kfree(vol_info->username);
3964 kfree(vol_info->password);
3971 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3973 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3976 /* find and return a tlink with given uid */
3977 static struct tcon_link *
3978 tlink_rb_search(struct rb_root *root, kuid_t uid)
3980 struct rb_node *node = root->rb_node;
3981 struct tcon_link *tlink;
3984 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3986 if (uid_gt(tlink->tl_uid, uid))
3987 node = node->rb_left;
3988 else if (uid_lt(tlink->tl_uid, uid))
3989 node = node->rb_right;
3996 /* insert a tcon_link into the tree */
3998 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4000 struct rb_node **new = &(root->rb_node), *parent = NULL;
4001 struct tcon_link *tlink;
4004 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4007 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
4008 new = &((*new)->rb_left);
4010 new = &((*new)->rb_right);
4013 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4014 rb_insert_color(&new_tlink->tl_rbnode, root);
4018 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4021 * If the superblock doesn't refer to a multiuser mount, then just return
4022 * the master tcon for the mount.
4024 * First, search the rbtree for an existing tcon for this fsuid. If one
4025 * exists, then check to see if it's pending construction. If it is then wait
4026 * for construction to complete. Once it's no longer pending, check to see if
4027 * it failed and either return an error or retry construction, depending on
4030 * If one doesn't exist then insert a new tcon_link struct into the tree and
4031 * try to construct a new one.
4034 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4037 kuid_t fsuid = current_fsuid();
4038 struct tcon_link *tlink, *newtlink;
4040 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4041 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4043 spin_lock(&cifs_sb->tlink_tree_lock);
4044 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4046 cifs_get_tlink(tlink);
4047 spin_unlock(&cifs_sb->tlink_tree_lock);
4049 if (tlink == NULL) {
4050 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4051 if (newtlink == NULL)
4052 return ERR_PTR(-ENOMEM);
4053 newtlink->tl_uid = fsuid;
4054 newtlink->tl_tcon = ERR_PTR(-EACCES);
4055 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4056 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4057 cifs_get_tlink(newtlink);
4059 spin_lock(&cifs_sb->tlink_tree_lock);
4060 /* was one inserted after previous search? */
4061 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4063 cifs_get_tlink(tlink);
4064 spin_unlock(&cifs_sb->tlink_tree_lock);
4066 goto wait_for_construction;
4069 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4070 spin_unlock(&cifs_sb->tlink_tree_lock);
4072 wait_for_construction:
4073 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4074 TASK_INTERRUPTIBLE);
4076 cifs_put_tlink(tlink);
4077 return ERR_PTR(-ERESTARTSYS);
4080 /* if it's good, return it */
4081 if (!IS_ERR(tlink->tl_tcon))
4084 /* return error if we tried this already recently */
4085 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4086 cifs_put_tlink(tlink);
4087 return ERR_PTR(-EACCES);
4090 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4091 goto wait_for_construction;
4094 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4095 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4096 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4098 if (IS_ERR(tlink->tl_tcon)) {
4099 cifs_put_tlink(tlink);
4100 return ERR_PTR(-EACCES);
4107 * periodic workqueue job that scans tcon_tree for a superblock and closes
4111 cifs_prune_tlinks(struct work_struct *work)
4113 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4115 struct rb_root *root = &cifs_sb->tlink_tree;
4116 struct rb_node *node = rb_first(root);
4117 struct rb_node *tmp;
4118 struct tcon_link *tlink;
4121 * Because we drop the spinlock in the loop in order to put the tlink
4122 * it's not guarded against removal of links from the tree. The only
4123 * places that remove entries from the tree are this function and
4124 * umounts. Because this function is non-reentrant and is canceled
4125 * before umount can proceed, this is safe.
4127 spin_lock(&cifs_sb->tlink_tree_lock);
4128 node = rb_first(root);
4129 while (node != NULL) {
4131 node = rb_next(tmp);
4132 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4134 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4135 atomic_read(&tlink->tl_count) != 0 ||
4136 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4139 cifs_get_tlink(tlink);
4140 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4141 rb_erase(tmp, root);
4143 spin_unlock(&cifs_sb->tlink_tree_lock);
4144 cifs_put_tlink(tlink);
4145 spin_lock(&cifs_sb->tlink_tree_lock);
4147 spin_unlock(&cifs_sb->tlink_tree_lock);
4149 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,