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_mapchars, Opt_nomapchars, Opt_sfu,
74 Opt_nosfu, Opt_nodfs, Opt_posixpaths,
75 Opt_noposixpaths, Opt_nounix,
78 Opt_forcemandatorylock, Opt_setuids,
79 Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
80 Opt_nohard, Opt_nosoft,
82 Opt_nostrictsync, Opt_strictsync,
83 Opt_serverino, Opt_noserverino,
84 Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
85 Opt_acl, Opt_noacl, Opt_locallease,
86 Opt_sign, Opt_seal, Opt_noac,
87 Opt_fsc, Opt_mfsymlinks,
88 Opt_multiuser, Opt_sloppy,
90 /* Mount options which take numeric value */
91 Opt_backupuid, Opt_backupgid, Opt_uid,
92 Opt_cruid, Opt_gid, Opt_file_mode,
93 Opt_dirmode, Opt_port,
94 Opt_rsize, Opt_wsize, Opt_actimeo,
96 /* Mount options which take string value */
97 Opt_user, Opt_pass, Opt_ip,
99 Opt_srcaddr, Opt_prefixpath,
100 Opt_iocharset, Opt_sockopt,
101 Opt_netbiosname, Opt_servern,
102 Opt_ver, Opt_vers, Opt_sec, Opt_cache,
104 /* Mount options to be ignored */
107 /* Options which could be blank */
115 static const match_table_t cifs_mount_option_tokens = {
117 { Opt_user_xattr, "user_xattr" },
118 { Opt_nouser_xattr, "nouser_xattr" },
119 { Opt_forceuid, "forceuid" },
120 { Opt_noforceuid, "noforceuid" },
121 { Opt_forcegid, "forcegid" },
122 { Opt_noforcegid, "noforcegid" },
123 { Opt_noblocksend, "noblocksend" },
124 { Opt_noautotune, "noautotune" },
125 { Opt_hard, "hard" },
126 { Opt_soft, "soft" },
127 { Opt_perm, "perm" },
128 { Opt_noperm, "noperm" },
129 { Opt_mapchars, "mapchars" },
130 { Opt_nomapchars, "nomapchars" },
132 { Opt_nosfu, "nosfu" },
133 { Opt_nodfs, "nodfs" },
134 { Opt_posixpaths, "posixpaths" },
135 { Opt_noposixpaths, "noposixpaths" },
136 { Opt_nounix, "nounix" },
137 { Opt_nounix, "nolinux" },
138 { Opt_nocase, "nocase" },
139 { Opt_nocase, "ignorecase" },
141 { Opt_nobrl, "nobrl" },
142 { Opt_nobrl, "nolock" },
143 { Opt_forcemandatorylock, "forcemandatorylock" },
144 { Opt_forcemandatorylock, "forcemand" },
145 { Opt_setuids, "setuids" },
146 { Opt_nosetuids, "nosetuids" },
147 { Opt_dynperm, "dynperm" },
148 { Opt_nodynperm, "nodynperm" },
149 { Opt_nohard, "nohard" },
150 { Opt_nosoft, "nosoft" },
151 { Opt_nointr, "nointr" },
152 { Opt_intr, "intr" },
153 { Opt_nostrictsync, "nostrictsync" },
154 { Opt_strictsync, "strictsync" },
155 { Opt_serverino, "serverino" },
156 { Opt_noserverino, "noserverino" },
157 { Opt_rwpidforward, "rwpidforward" },
158 { Opt_cifsacl, "cifsacl" },
159 { Opt_nocifsacl, "nocifsacl" },
161 { Opt_noacl, "noacl" },
162 { Opt_locallease, "locallease" },
163 { Opt_sign, "sign" },
164 { Opt_seal, "seal" },
165 { Opt_noac, "noac" },
167 { Opt_mfsymlinks, "mfsymlinks" },
168 { Opt_multiuser, "multiuser" },
169 { Opt_sloppy, "sloppy" },
171 { Opt_backupuid, "backupuid=%s" },
172 { Opt_backupgid, "backupgid=%s" },
173 { Opt_uid, "uid=%s" },
174 { Opt_cruid, "cruid=%s" },
175 { Opt_gid, "gid=%s" },
176 { Opt_file_mode, "file_mode=%s" },
177 { Opt_dirmode, "dirmode=%s" },
178 { Opt_dirmode, "dir_mode=%s" },
179 { Opt_port, "port=%s" },
180 { Opt_rsize, "rsize=%s" },
181 { Opt_wsize, "wsize=%s" },
182 { Opt_actimeo, "actimeo=%s" },
184 { Opt_blank_user, "user=" },
185 { Opt_blank_user, "username=" },
186 { Opt_user, "user=%s" },
187 { Opt_user, "username=%s" },
188 { Opt_blank_pass, "pass=" },
189 { Opt_blank_pass, "password=" },
190 { Opt_pass, "pass=%s" },
191 { Opt_pass, "password=%s" },
192 { Opt_blank_ip, "ip=" },
193 { Opt_blank_ip, "addr=" },
195 { Opt_ip, "addr=%s" },
196 { Opt_unc, "unc=%s" },
197 { Opt_unc, "target=%s" },
198 { Opt_unc, "path=%s" },
199 { Opt_domain, "dom=%s" },
200 { Opt_domain, "domain=%s" },
201 { Opt_domain, "workgroup=%s" },
202 { Opt_srcaddr, "srcaddr=%s" },
203 { Opt_prefixpath, "prefixpath=%s" },
204 { Opt_iocharset, "iocharset=%s" },
205 { Opt_sockopt, "sockopt=%s" },
206 { Opt_netbiosname, "netbiosname=%s" },
207 { Opt_servern, "servern=%s" },
208 { Opt_ver, "ver=%s" },
209 { Opt_vers, "vers=%s" },
210 { Opt_sec, "sec=%s" },
211 { Opt_cache, "cache=%s" },
213 { Opt_ignore, "cred" },
214 { Opt_ignore, "credentials" },
215 { Opt_ignore, "cred=%s" },
216 { Opt_ignore, "credentials=%s" },
217 { Opt_ignore, "guest" },
218 { Opt_ignore, "rw" },
219 { Opt_ignore, "ro" },
220 { Opt_ignore, "suid" },
221 { Opt_ignore, "nosuid" },
222 { Opt_ignore, "exec" },
223 { Opt_ignore, "noexec" },
224 { Opt_ignore, "nodev" },
225 { Opt_ignore, "noauto" },
226 { Opt_ignore, "dev" },
227 { Opt_ignore, "mand" },
228 { Opt_ignore, "nomand" },
229 { Opt_ignore, "_netdev" },
235 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
236 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
237 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
238 Opt_sec_ntlmv2i, Opt_sec_lanman,
244 static const match_table_t cifs_secflavor_tokens = {
245 { Opt_sec_krb5, "krb5" },
246 { Opt_sec_krb5i, "krb5i" },
247 { Opt_sec_krb5p, "krb5p" },
248 { Opt_sec_ntlmsspi, "ntlmsspi" },
249 { Opt_sec_ntlmssp, "ntlmssp" },
250 { Opt_ntlm, "ntlm" },
251 { Opt_sec_ntlmi, "ntlmi" },
252 { Opt_sec_ntlmv2, "nontlm" },
253 { Opt_sec_ntlmv2, "ntlmv2" },
254 { Opt_sec_ntlmv2i, "ntlmv2i" },
255 { Opt_sec_lanman, "lanman" },
256 { Opt_sec_none, "none" },
258 { Opt_sec_err, NULL }
269 static const match_table_t cifs_cacheflavor_tokens = {
270 { Opt_cache_loose, "loose" },
271 { Opt_cache_strict, "strict" },
272 { Opt_cache_none, "none" },
273 { Opt_cache_err, NULL }
276 static const match_table_t cifs_smb_version_tokens = {
277 { Smb_1, SMB1_VERSION_STRING },
278 { Smb_20, SMB20_VERSION_STRING},
279 { Smb_21, SMB21_VERSION_STRING },
280 { Smb_30, SMB30_VERSION_STRING },
283 static int ip_connect(struct TCP_Server_Info *server);
284 static int generic_ip_connect(struct TCP_Server_Info *server);
285 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
286 static void cifs_prune_tlinks(struct work_struct *work);
287 static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
288 const char *devname);
291 * cifs tcp session reconnection
293 * mark tcp session as reconnecting so temporarily locked
294 * mark all smb sessions as reconnecting for tcp session
295 * reconnect tcp session
296 * wake up waiters on reconnection? - (not needed currently)
299 cifs_reconnect(struct TCP_Server_Info *server)
302 struct list_head *tmp, *tmp2;
303 struct cifs_ses *ses;
304 struct cifs_tcon *tcon;
305 struct mid_q_entry *mid_entry;
306 struct list_head retry_list;
308 spin_lock(&GlobalMid_Lock);
309 if (server->tcpStatus == CifsExiting) {
310 /* the demux thread will exit normally
311 next time through the loop */
312 spin_unlock(&GlobalMid_Lock);
315 server->tcpStatus = CifsNeedReconnect;
316 spin_unlock(&GlobalMid_Lock);
318 #ifdef CONFIG_CIFS_SMB2
319 server->max_read = 0;
322 cFYI(1, "Reconnecting tcp session");
324 /* before reconnecting the tcp session, mark the smb session (uid)
325 and the tid bad so they are not used until reconnected */
326 cFYI(1, "%s: marking sessions and tcons for reconnect", __func__);
327 spin_lock(&cifs_tcp_ses_lock);
328 list_for_each(tmp, &server->smb_ses_list) {
329 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
330 ses->need_reconnect = true;
332 list_for_each(tmp2, &ses->tcon_list) {
333 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
334 tcon->need_reconnect = true;
337 spin_unlock(&cifs_tcp_ses_lock);
339 /* do not want to be sending data on a socket we are freeing */
340 cFYI(1, "%s: tearing down socket", __func__);
341 mutex_lock(&server->srv_mutex);
342 if (server->ssocket) {
343 cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
344 server->ssocket->flags);
345 kernel_sock_shutdown(server->ssocket, SHUT_WR);
346 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
347 server->ssocket->state,
348 server->ssocket->flags);
349 sock_release(server->ssocket);
350 server->ssocket = NULL;
352 server->sequence_number = 0;
353 server->session_estab = false;
354 kfree(server->session_key.response);
355 server->session_key.response = NULL;
356 server->session_key.len = 0;
357 server->lstrp = jiffies;
358 mutex_unlock(&server->srv_mutex);
360 /* mark submitted MIDs for retry and issue callback */
361 INIT_LIST_HEAD(&retry_list);
362 cFYI(1, "%s: moving mids to private list", __func__);
363 spin_lock(&GlobalMid_Lock);
364 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
365 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
366 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
367 mid_entry->mid_state = MID_RETRY_NEEDED;
368 list_move(&mid_entry->qhead, &retry_list);
370 spin_unlock(&GlobalMid_Lock);
372 cFYI(1, "%s: issuing mid callbacks", __func__);
373 list_for_each_safe(tmp, tmp2, &retry_list) {
374 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
375 list_del_init(&mid_entry->qhead);
376 mid_entry->callback(mid_entry);
382 /* we should try only the port we connected to before */
383 rc = generic_ip_connect(server);
385 cFYI(1, "reconnect error %d", rc);
388 atomic_inc(&tcpSesReconnectCount);
389 spin_lock(&GlobalMid_Lock);
390 if (server->tcpStatus != CifsExiting)
391 server->tcpStatus = CifsNeedNegotiate;
392 spin_unlock(&GlobalMid_Lock);
394 } while (server->tcpStatus == CifsNeedReconnect);
400 cifs_echo_request(struct work_struct *work)
403 struct TCP_Server_Info *server = container_of(work,
404 struct TCP_Server_Info, echo.work);
407 * We cannot send an echo if it is disabled or until the
408 * NEGOTIATE_PROTOCOL request is done, which is indicated by
409 * server->ops->need_neg() == true. Also, no need to ping if
410 * we got a response recently.
412 if (!server->ops->need_neg || server->ops->need_neg(server) ||
413 (server->ops->can_echo && !server->ops->can_echo(server)) ||
414 time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
417 rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
419 cFYI(1, "Unable to send echo request to server: %s",
423 queue_delayed_work(cifsiod_wq, &server->echo, SMB_ECHO_INTERVAL);
427 allocate_buffers(struct TCP_Server_Info *server)
429 if (!server->bigbuf) {
430 server->bigbuf = (char *)cifs_buf_get();
431 if (!server->bigbuf) {
432 cERROR(1, "No memory for large SMB response");
434 /* retry will check if exiting */
437 } else if (server->large_buf) {
438 /* we are reusing a dirty large buf, clear its start */
439 memset(server->bigbuf, 0, HEADER_SIZE(server));
442 if (!server->smallbuf) {
443 server->smallbuf = (char *)cifs_small_buf_get();
444 if (!server->smallbuf) {
445 cERROR(1, "No memory for SMB response");
447 /* retry will check if exiting */
450 /* beginning of smb buffer is cleared in our buf_get */
452 /* if existing small buf clear beginning */
453 memset(server->smallbuf, 0, HEADER_SIZE(server));
460 server_unresponsive(struct TCP_Server_Info *server)
463 * We need to wait 2 echo intervals to make sure we handle such
465 * 1s client sends a normal SMB request
466 * 2s client gets a response
467 * 30s echo workqueue job pops, and decides we got a response recently
468 * and don't need to send another
470 * 65s kernel_recvmsg times out, and we see that we haven't gotten
471 * a response in >60s.
473 if (server->tcpStatus == CifsGood &&
474 time_after(jiffies, server->lstrp + 2 * SMB_ECHO_INTERVAL)) {
475 cERROR(1, "Server %s has not responded in %d seconds. "
476 "Reconnecting...", server->hostname,
477 (2 * SMB_ECHO_INTERVAL) / HZ);
478 cifs_reconnect(server);
479 wake_up(&server->response_q);
487 * kvec_array_init - clone a kvec array, and advance into it
488 * @new: pointer to memory for cloned array
489 * @iov: pointer to original array
490 * @nr_segs: number of members in original array
491 * @bytes: number of bytes to advance into the cloned array
493 * This function will copy the array provided in iov to a section of memory
494 * and advance the specified number of bytes into the new array. It returns
495 * the number of segments in the new array. "new" must be at least as big as
496 * the original iov array.
499 kvec_array_init(struct kvec *new, struct kvec *iov, unsigned int nr_segs,
504 while (bytes || !iov->iov_len) {
505 int copy = min(bytes, iov->iov_len);
509 if (iov->iov_len == base) {
515 memcpy(new, iov, sizeof(*iov) * nr_segs);
516 new->iov_base += base;
517 new->iov_len -= base;
522 get_server_iovec(struct TCP_Server_Info *server, unsigned int nr_segs)
524 struct kvec *new_iov;
526 if (server->iov && nr_segs <= server->nr_iov)
529 /* not big enough -- allocate a new one and release the old */
530 new_iov = kmalloc(sizeof(*new_iov) * nr_segs, GFP_NOFS);
533 server->iov = new_iov;
534 server->nr_iov = nr_segs;
540 cifs_readv_from_socket(struct TCP_Server_Info *server, struct kvec *iov_orig,
541 unsigned int nr_segs, unsigned int to_read)
546 struct msghdr smb_msg;
549 iov = get_server_iovec(server, nr_segs);
553 smb_msg.msg_control = NULL;
554 smb_msg.msg_controllen = 0;
556 for (total_read = 0; to_read; total_read += length, to_read -= length) {
559 if (server_unresponsive(server)) {
560 total_read = -EAGAIN;
564 segs = kvec_array_init(iov, iov_orig, nr_segs, total_read);
566 length = kernel_recvmsg(server->ssocket, &smb_msg,
567 iov, segs, to_read, 0);
569 if (server->tcpStatus == CifsExiting) {
570 total_read = -ESHUTDOWN;
572 } else if (server->tcpStatus == CifsNeedReconnect) {
573 cifs_reconnect(server);
574 total_read = -EAGAIN;
576 } else if (length == -ERESTARTSYS ||
580 * Minimum sleep to prevent looping, allowing socket
581 * to clear and app threads to set tcpStatus
582 * CifsNeedReconnect if server hung.
584 usleep_range(1000, 2000);
587 } else if (length <= 0) {
588 cFYI(1, "Received no data or error: expecting %d "
589 "got %d", to_read, length);
590 cifs_reconnect(server);
591 total_read = -EAGAIN;
599 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
600 unsigned int to_read)
605 iov.iov_len = to_read;
607 return cifs_readv_from_socket(server, &iov, 1, to_read);
611 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
614 * The first byte big endian of the length field,
615 * is actually not part of the length but the type
616 * with the most common, zero, as regular data.
619 case RFC1002_SESSION_MESSAGE:
620 /* Regular SMB response */
622 case RFC1002_SESSION_KEEP_ALIVE:
623 cFYI(1, "RFC 1002 session keep alive");
625 case RFC1002_POSITIVE_SESSION_RESPONSE:
626 cFYI(1, "RFC 1002 positive session response");
628 case RFC1002_NEGATIVE_SESSION_RESPONSE:
630 * We get this from Windows 98 instead of an error on
631 * SMB negprot response.
633 cFYI(1, "RFC 1002 negative session response");
634 /* give server a second to clean up */
637 * Always try 445 first on reconnect since we get NACK
638 * on some if we ever connected to port 139 (the NACK
639 * is since we do not begin with RFC1001 session
642 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
643 cifs_reconnect(server);
644 wake_up(&server->response_q);
647 cERROR(1, "RFC 1002 unknown response type 0x%x", type);
648 cifs_reconnect(server);
655 dequeue_mid(struct mid_q_entry *mid, bool malformed)
657 #ifdef CONFIG_CIFS_STATS2
658 mid->when_received = jiffies;
660 spin_lock(&GlobalMid_Lock);
662 mid->mid_state = MID_RESPONSE_RECEIVED;
664 mid->mid_state = MID_RESPONSE_MALFORMED;
665 list_del_init(&mid->qhead);
666 spin_unlock(&GlobalMid_Lock);
670 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
671 char *buf, int malformed)
673 if (server->ops->check_trans2 &&
674 server->ops->check_trans2(mid, server, buf, malformed))
677 mid->large_buf = server->large_buf;
678 /* Was previous buf put in mpx struct for multi-rsp? */
679 if (!mid->multiRsp) {
680 /* smb buffer will be freed by user thread */
681 if (server->large_buf)
682 server->bigbuf = NULL;
684 server->smallbuf = NULL;
686 dequeue_mid(mid, malformed);
689 static void clean_demultiplex_info(struct TCP_Server_Info *server)
693 /* take it off the list, if it's not already */
694 spin_lock(&cifs_tcp_ses_lock);
695 list_del_init(&server->tcp_ses_list);
696 spin_unlock(&cifs_tcp_ses_lock);
698 spin_lock(&GlobalMid_Lock);
699 server->tcpStatus = CifsExiting;
700 spin_unlock(&GlobalMid_Lock);
701 wake_up_all(&server->response_q);
703 /* check if we have blocked requests that need to free */
704 spin_lock(&server->req_lock);
705 if (server->credits <= 0)
707 spin_unlock(&server->req_lock);
709 * Although there should not be any requests blocked on this queue it
710 * can not hurt to be paranoid and try to wake up requests that may
711 * haven been blocked when more than 50 at time were on the wire to the
712 * same server - they now will see the session is in exit state and get
713 * out of SendReceive.
715 wake_up_all(&server->request_q);
716 /* give those requests time to exit */
719 if (server->ssocket) {
720 sock_release(server->ssocket);
721 server->ssocket = NULL;
724 if (!list_empty(&server->pending_mid_q)) {
725 struct list_head dispose_list;
726 struct mid_q_entry *mid_entry;
727 struct list_head *tmp, *tmp2;
729 INIT_LIST_HEAD(&dispose_list);
730 spin_lock(&GlobalMid_Lock);
731 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
732 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
733 cFYI(1, "Clearing mid 0x%llx", mid_entry->mid);
734 mid_entry->mid_state = MID_SHUTDOWN;
735 list_move(&mid_entry->qhead, &dispose_list);
737 spin_unlock(&GlobalMid_Lock);
739 /* now walk dispose list and issue callbacks */
740 list_for_each_safe(tmp, tmp2, &dispose_list) {
741 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
742 cFYI(1, "Callback mid 0x%llx", mid_entry->mid);
743 list_del_init(&mid_entry->qhead);
744 mid_entry->callback(mid_entry);
746 /* 1/8th of sec is more than enough time for them to exit */
750 if (!list_empty(&server->pending_mid_q)) {
752 * mpx threads have not exited yet give them at least the smb
753 * send timeout time for long ops.
755 * Due to delays on oplock break requests, we need to wait at
756 * least 45 seconds before giving up on a request getting a
757 * response and going ahead and killing cifsd.
759 cFYI(1, "Wait for exit from demultiplex thread");
762 * If threads still have not exited they are probably never
763 * coming home not much else we can do but free the memory.
767 kfree(server->hostname);
771 length = atomic_dec_return(&tcpSesAllocCount);
773 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
778 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
781 char *buf = server->smallbuf;
782 unsigned int pdu_length = get_rfc1002_length(buf);
784 /* make sure this will fit in a large buffer */
785 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) - 4) {
786 cERROR(1, "SMB response too long (%u bytes)",
788 cifs_reconnect(server);
789 wake_up(&server->response_q);
793 /* switch to large buffer if too big for a small one */
794 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
795 server->large_buf = true;
796 memcpy(server->bigbuf, buf, server->total_read);
797 buf = server->bigbuf;
800 /* now read the rest */
801 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
802 pdu_length - HEADER_SIZE(server) + 1 + 4);
805 server->total_read += length;
807 dump_smb(buf, server->total_read);
810 * We know that we received enough to get to the MID as we
811 * checked the pdu_length earlier. Now check to see
812 * if the rest of the header is OK. We borrow the length
813 * var for the rest of the loop to avoid a new stack var.
815 * 48 bytes is enough to display the header and a little bit
816 * into the payload for debugging purposes.
818 length = server->ops->check_message(buf, server->total_read);
820 cifs_dump_mem("Bad SMB: ", buf,
821 min_t(unsigned int, server->total_read, 48));
823 if (server->ops->is_status_pending &&
824 server->ops->is_status_pending(buf, server, length))
830 handle_mid(mid, server, buf, length);
835 cifs_demultiplex_thread(void *p)
838 struct TCP_Server_Info *server = p;
839 unsigned int pdu_length;
841 struct task_struct *task_to_wake = NULL;
842 struct mid_q_entry *mid_entry;
844 current->flags |= PF_MEMALLOC;
845 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
847 length = atomic_inc_return(&tcpSesAllocCount);
849 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
853 while (server->tcpStatus != CifsExiting) {
857 if (!allocate_buffers(server))
860 server->large_buf = false;
861 buf = server->smallbuf;
862 pdu_length = 4; /* enough to get RFC1001 header */
864 length = cifs_read_from_socket(server, buf, pdu_length);
867 server->total_read = length;
870 * The right amount was read from socket - 4 bytes,
871 * so we can now interpret the length field.
873 pdu_length = get_rfc1002_length(buf);
875 cFYI(1, "RFC1002 header 0x%x", pdu_length);
876 if (!is_smb_response(server, buf[0]))
879 /* make sure we have enough to get to the MID */
880 if (pdu_length < HEADER_SIZE(server) - 1 - 4) {
881 cERROR(1, "SMB response too short (%u bytes)",
883 cifs_reconnect(server);
884 wake_up(&server->response_q);
888 /* read down to the MID */
889 length = cifs_read_from_socket(server, buf + 4,
890 HEADER_SIZE(server) - 1 - 4);
893 server->total_read += length;
895 mid_entry = server->ops->find_mid(server, buf);
897 if (!mid_entry || !mid_entry->receive)
898 length = standard_receive3(server, mid_entry);
900 length = mid_entry->receive(server, mid_entry);
905 if (server->large_buf)
906 buf = server->bigbuf;
908 server->lstrp = jiffies;
909 if (mid_entry != NULL) {
910 if (!mid_entry->multiRsp || mid_entry->multiEnd)
911 mid_entry->callback(mid_entry);
912 } else if (!server->ops->is_oplock_break ||
913 !server->ops->is_oplock_break(buf, server)) {
914 cERROR(1, "No task to wake, unknown frame received! "
915 "NumMids %d", atomic_read(&midCount));
916 cifs_dump_mem("Received Data is: ", buf,
917 HEADER_SIZE(server));
918 #ifdef CONFIG_CIFS_DEBUG2
919 if (server->ops->dump_detail)
920 server->ops->dump_detail(buf);
921 cifs_dump_mids(server);
922 #endif /* CIFS_DEBUG2 */
925 } /* end while !EXITING */
927 /* buffer usually freed in free_mid - need to free it here on exit */
928 cifs_buf_release(server->bigbuf);
929 if (server->smallbuf) /* no sense logging a debug message if NULL */
930 cifs_small_buf_release(server->smallbuf);
932 task_to_wake = xchg(&server->tsk, NULL);
933 clean_demultiplex_info(server);
935 /* if server->tsk was NULL then wait for a signal before exiting */
937 set_current_state(TASK_INTERRUPTIBLE);
938 while (!signal_pending(current)) {
940 set_current_state(TASK_INTERRUPTIBLE);
942 set_current_state(TASK_RUNNING);
945 module_put_and_exit(0);
948 /* extract the host portion of the UNC string */
950 extract_hostname(const char *unc)
956 /* skip double chars at beginning of string */
957 /* BB: check validity of these bytes? */
960 /* delimiter between hostname and sharename is always '\\' now */
961 delim = strchr(src, '\\');
963 return ERR_PTR(-EINVAL);
966 dst = kmalloc((len + 1), GFP_KERNEL);
968 return ERR_PTR(-ENOMEM);
970 memcpy(dst, src, len);
976 static int get_option_ul(substring_t args[], unsigned long *option)
981 string = match_strdup(args);
984 rc = kstrtoul(string, 0, option);
991 static int cifs_parse_security_flavors(char *value,
995 substring_t args[MAX_OPT_ARGS];
997 switch (match_token(value, cifs_secflavor_tokens, args)) {
999 vol->secFlg |= CIFSSEC_MAY_KRB5;
1002 vol->secFlg |= CIFSSEC_MAY_KRB5 | CIFSSEC_MUST_SIGN;
1005 /* vol->secFlg |= CIFSSEC_MUST_SEAL | CIFSSEC_MAY_KRB5; */
1006 cERROR(1, "Krb5 cifs privacy not supported");
1008 case Opt_sec_ntlmssp:
1009 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
1011 case Opt_sec_ntlmsspi:
1012 vol->secFlg |= CIFSSEC_MAY_NTLMSSP | CIFSSEC_MUST_SIGN;
1015 /* ntlm is default so can be turned off too */
1016 vol->secFlg |= CIFSSEC_MAY_NTLM;
1019 vol->secFlg |= CIFSSEC_MAY_NTLM | CIFSSEC_MUST_SIGN;
1021 case Opt_sec_ntlmv2:
1022 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1024 case Opt_sec_ntlmv2i:
1025 vol->secFlg |= CIFSSEC_MAY_NTLMV2 | CIFSSEC_MUST_SIGN;
1027 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1028 case Opt_sec_lanman:
1029 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1036 cERROR(1, "bad security option: %s", value);
1044 cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1046 substring_t args[MAX_OPT_ARGS];
1048 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1049 case Opt_cache_loose:
1050 vol->direct_io = false;
1051 vol->strict_io = false;
1053 case Opt_cache_strict:
1054 vol->direct_io = false;
1055 vol->strict_io = true;
1057 case Opt_cache_none:
1058 vol->direct_io = true;
1059 vol->strict_io = false;
1062 cERROR(1, "bad cache= option: %s", value);
1069 cifs_parse_smb_version(char *value, struct smb_vol *vol)
1071 substring_t args[MAX_OPT_ARGS];
1073 switch (match_token(value, cifs_smb_version_tokens, args)) {
1075 vol->ops = &smb1_operations;
1076 vol->vals = &smb1_values;
1078 #ifdef CONFIG_CIFS_SMB2
1080 vol->ops = &smb21_operations; /* currently identical with 2.1 */
1081 vol->vals = &smb20_values;
1084 vol->ops = &smb21_operations;
1085 vol->vals = &smb21_values;
1088 vol->ops = &smb30_operations;
1089 vol->vals = &smb30_values;
1093 cERROR(1, "Unknown vers= option specified: %s", value);
1100 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1101 * fields with the result. Returns 0 on success and an error otherwise.
1104 cifs_parse_devname(const char *devname, struct smb_vol *vol)
1107 const char *delims = "/\\";
1110 /* make sure we have a valid UNC double delimiter prefix */
1111 len = strspn(devname, delims);
1115 /* find delimiter between host and sharename */
1116 pos = strpbrk(devname + 2, delims);
1120 /* skip past delimiter */
1123 /* now go until next delimiter or end of string */
1124 len = strcspn(pos, delims);
1126 /* move "pos" up to delimiter or NULL */
1128 vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1132 convert_delimiter(vol->UNC, '\\');
1134 /* If pos is NULL, or is a bogus trailing delimiter then no prepath */
1135 if (!*pos++ || !*pos)
1138 vol->prepath = kstrdup(pos, GFP_KERNEL);
1146 cifs_parse_mount_options(const char *mountdata, const char *devname,
1147 struct smb_vol *vol)
1150 char *mountdata_copy = NULL, *options;
1151 unsigned int temp_len, i, j;
1153 short int override_uid = -1;
1154 short int override_gid = -1;
1155 bool uid_specified = false;
1156 bool gid_specified = false;
1157 bool sloppy = false;
1158 char *invalid = NULL;
1159 char *nodename = utsname()->nodename;
1160 char *string = NULL;
1161 char *tmp_end, *value;
1163 bool got_ip = false;
1164 unsigned short port = 0;
1165 struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1169 delim = separator[0];
1171 /* ensure we always start with zeroed-out smb_vol */
1172 memset(vol, 0, sizeof(*vol));
1175 * does not have to be perfect mapping since field is
1176 * informational, only used for servers that do not support
1177 * port 445 and it can be overridden at mount time
1179 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1180 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1181 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1183 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1184 /* null target name indicates to use *SMBSERVR default called name
1185 if we end up sending RFC1001 session initialize */
1186 vol->target_rfc1001_name[0] = 0;
1187 vol->cred_uid = current_uid();
1188 vol->linux_uid = current_uid();
1189 vol->linux_gid = current_gid();
1191 /* default to only allowing write access to owner of the mount */
1192 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1194 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1195 /* default is always to request posix paths. */
1196 vol->posix_paths = 1;
1197 /* default to using server inode numbers where available */
1198 vol->server_ino = 1;
1200 /* default is to use strict cifs caching semantics */
1201 vol->strict_io = true;
1203 vol->actimeo = CIFS_DEF_ACTIMEO;
1205 /* FIXME: add autonegotiation -- for now, SMB1 is default */
1206 vol->ops = &smb1_operations;
1207 vol->vals = &smb1_values;
1210 goto cifs_parse_mount_err;
1212 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1213 if (!mountdata_copy)
1214 goto cifs_parse_mount_err;
1216 options = mountdata_copy;
1217 end = options + strlen(options);
1219 if (strncmp(options, "sep=", 4) == 0) {
1220 if (options[4] != 0) {
1221 separator[0] = options[4];
1224 cFYI(1, "Null separator not allowed");
1227 vol->backupuid_specified = false; /* no backup intent for a user */
1228 vol->backupgid_specified = false; /* no backup intent for a group */
1231 * For now, we ignore -EINVAL errors under the assumption that the
1232 * unc= and prefixpath= options will be usable.
1234 if (cifs_parse_devname(devname, vol) == -ENOMEM) {
1235 printk(KERN_ERR "CIFS: Unable to allocate memory to parse "
1236 "device string.\n");
1240 while ((data = strsep(&options, separator)) != NULL) {
1241 substring_t args[MAX_OPT_ARGS];
1242 unsigned long option;
1248 token = match_token(data, cifs_mount_option_tokens, args);
1252 /* Ingnore the following */
1256 /* Boolean values */
1257 case Opt_user_xattr:
1260 case Opt_nouser_xattr:
1266 case Opt_noforceuid:
1272 case Opt_noforcegid:
1275 case Opt_noblocksend:
1276 vol->noblocksnd = 1;
1278 case Opt_noautotune:
1279 vol->noautotune = 1;
1296 case Opt_nomapchars:
1308 case Opt_posixpaths:
1309 vol->posix_paths = 1;
1311 case Opt_noposixpaths:
1312 vol->posix_paths = 0;
1315 vol->no_linux_ext = 1;
1326 * turn off mandatory locking in mode
1327 * if remote locking is turned off since the
1328 * local vfs will do advisory
1330 if (vol->file_mode ==
1331 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1332 vol->file_mode = S_IALLUGO;
1334 case Opt_forcemandatorylock:
1344 vol->dynperm = true;
1347 vol->dynperm = false;
1361 case Opt_nostrictsync:
1362 vol->nostrictsync = 1;
1364 case Opt_strictsync:
1365 vol->nostrictsync = 0;
1368 vol->server_ino = 1;
1370 case Opt_noserverino:
1371 vol->server_ino = 0;
1373 case Opt_rwpidforward:
1374 vol->rwpidforward = 1;
1383 vol->no_psx_acl = 0;
1386 vol->no_psx_acl = 1;
1388 case Opt_locallease:
1389 vol->local_lease = 1;
1392 vol->secFlg |= CIFSSEC_MUST_SIGN;
1395 /* we do not do the following in secFlags because seal
1396 * is a per tree connection (mount) not a per socket
1397 * or per-smb connection option in the protocol
1398 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1403 printk(KERN_WARNING "CIFS: Mount option noac not "
1404 "supported. Instead set "
1405 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1408 #ifndef CONFIG_CIFS_FSCACHE
1409 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE "
1410 "kernel config option set");
1411 goto cifs_parse_mount_err;
1415 case Opt_mfsymlinks:
1416 vol->mfsymlinks = true;
1419 vol->multiuser = true;
1425 /* Numeric Values */
1427 if (get_option_ul(args, &option)) {
1428 cERROR(1, "%s: Invalid backupuid value",
1430 goto cifs_parse_mount_err;
1432 vol->backupuid = option;
1433 vol->backupuid_specified = true;
1436 if (get_option_ul(args, &option)) {
1437 cERROR(1, "%s: Invalid backupgid value",
1439 goto cifs_parse_mount_err;
1441 vol->backupgid = option;
1442 vol->backupgid_specified = true;
1445 if (get_option_ul(args, &option)) {
1446 cERROR(1, "%s: Invalid uid value",
1448 goto cifs_parse_mount_err;
1450 vol->linux_uid = option;
1451 uid_specified = true;
1454 if (get_option_ul(args, &option)) {
1455 cERROR(1, "%s: Invalid cruid value",
1457 goto cifs_parse_mount_err;
1459 vol->cred_uid = option;
1462 if (get_option_ul(args, &option)) {
1463 cERROR(1, "%s: Invalid gid value",
1465 goto cifs_parse_mount_err;
1467 vol->linux_gid = option;
1468 gid_specified = true;
1471 if (get_option_ul(args, &option)) {
1472 cERROR(1, "%s: Invalid file_mode value",
1474 goto cifs_parse_mount_err;
1476 vol->file_mode = option;
1479 if (get_option_ul(args, &option)) {
1480 cERROR(1, "%s: Invalid dir_mode value",
1482 goto cifs_parse_mount_err;
1484 vol->dir_mode = option;
1487 if (get_option_ul(args, &option) ||
1488 option > USHRT_MAX) {
1489 cERROR(1, "%s: Invalid port value", __func__);
1490 goto cifs_parse_mount_err;
1492 port = (unsigned short)option;
1495 if (get_option_ul(args, &option)) {
1496 cERROR(1, "%s: Invalid rsize value",
1498 goto cifs_parse_mount_err;
1500 vol->rsize = option;
1503 if (get_option_ul(args, &option)) {
1504 cERROR(1, "%s: Invalid wsize value",
1506 goto cifs_parse_mount_err;
1508 vol->wsize = option;
1511 if (get_option_ul(args, &option)) {
1512 cERROR(1, "%s: Invalid actimeo value",
1514 goto cifs_parse_mount_err;
1516 vol->actimeo = HZ * option;
1517 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1518 cERROR(1, "CIFS: attribute cache"
1519 "timeout too large");
1520 goto cifs_parse_mount_err;
1524 /* String Arguments */
1526 case Opt_blank_user:
1527 /* null user, ie. anonymous authentication */
1529 vol->username = NULL;
1532 string = match_strdup(args);
1536 if (strnlen(string, MAX_USERNAME_SIZE) >
1537 MAX_USERNAME_SIZE) {
1538 printk(KERN_WARNING "CIFS: username too long\n");
1539 goto cifs_parse_mount_err;
1541 vol->username = kstrdup(string, GFP_KERNEL);
1542 if (!vol->username) {
1543 printk(KERN_WARNING "CIFS: no memory "
1545 goto cifs_parse_mount_err;
1548 case Opt_blank_pass:
1549 vol->password = NULL;
1552 /* passwords have to be handled differently
1553 * to allow the character used for deliminator
1554 * to be passed within them
1557 /* Obtain the value string */
1558 value = strchr(data, '=');
1561 /* Set tmp_end to end of the string */
1562 tmp_end = (char *) value + strlen(value);
1564 /* Check if following character is the deliminator
1565 * If yes, we have encountered a double deliminator
1566 * reset the NULL character to the deliminator
1568 if (tmp_end < end && tmp_end[1] == delim) {
1571 /* Keep iterating until we get to a single
1572 * deliminator OR the end
1574 while ((tmp_end = strchr(tmp_end, delim))
1575 != NULL && (tmp_end[1] == delim)) {
1576 tmp_end = (char *) &tmp_end[2];
1579 /* Reset var options to point to next element */
1582 options = (char *) &tmp_end[1];
1584 /* Reached the end of the mount option
1589 /* Now build new password string */
1590 temp_len = strlen(value);
1591 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1592 if (vol->password == NULL) {
1593 printk(KERN_WARNING "CIFS: no memory "
1595 goto cifs_parse_mount_err;
1598 for (i = 0, j = 0; i < temp_len; i++, j++) {
1599 vol->password[j] = value[i];
1600 if ((value[i] == delim) &&
1601 value[i+1] == delim)
1602 /* skip the second deliminator */
1605 vol->password[j] = '\0';
1608 /* FIXME: should this be an error instead? */
1612 string = match_strdup(args);
1616 if (!cifs_convert_address(dstaddr, string,
1618 printk(KERN_ERR "CIFS: bad ip= option (%s).\n",
1620 goto cifs_parse_mount_err;
1626 vol->UNC = match_strdup(args);
1627 if (vol->UNC == NULL) {
1632 convert_delimiter(vol->UNC, '\\');
1633 if (vol->UNC[0] != '\\' || vol->UNC[1] != '\\') {
1635 printk(KERN_ERR "CIFS: UNC Path does not "
1636 "begin with // or \\\\\n");
1637 goto cifs_parse_mount_err;
1640 /* Compare old unc= option to new one */
1641 if (!string || strcmp(string, vol->UNC))
1642 printk(KERN_WARNING "CIFS: the value of the "
1643 "unc= mount option does not match the "
1644 "device string. Using the unc= option "
1645 "for now. In 3.10, that option will "
1646 "be ignored and the contents of the "
1647 "device string will be used "
1648 "instead. (%s != %s)\n", string,
1652 string = match_strdup(args);
1656 if (strnlen(string, 256) == 256) {
1657 printk(KERN_WARNING "CIFS: domain name too"
1659 goto cifs_parse_mount_err;
1662 vol->domainname = kstrdup(string, GFP_KERNEL);
1663 if (!vol->domainname) {
1664 printk(KERN_WARNING "CIFS: no memory "
1665 "for domainname\n");
1666 goto cifs_parse_mount_err;
1668 cFYI(1, "Domain name set");
1671 string = match_strdup(args);
1675 if (!cifs_convert_address(
1676 (struct sockaddr *)&vol->srcaddr,
1677 string, strlen(string))) {
1678 printk(KERN_WARNING "CIFS: Could not parse"
1679 " srcaddr: %s\n", string);
1680 goto cifs_parse_mount_err;
1683 case Opt_prefixpath:
1684 /* skip over any leading delimiter */
1685 if (*args[0].from == '/' || *args[0].from == '\\')
1688 string = vol->prepath;
1689 vol->prepath = match_strdup(args);
1690 if (vol->prepath == NULL) {
1694 /* Compare old prefixpath= option to new one */
1695 if (!string || strcmp(string, vol->prepath))
1696 printk(KERN_WARNING "CIFS: the value of the "
1697 "prefixpath= mount option does not "
1698 "match the device string. Using the "
1699 "prefixpath= option for now. In 3.10, "
1700 "that option will be ignored and the "
1701 "contents of the device string will be "
1702 "used instead.(%s != %s)\n", string,
1706 string = match_strdup(args);
1710 if (strnlen(string, 1024) >= 65) {
1711 printk(KERN_WARNING "CIFS: iocharset name "
1713 goto cifs_parse_mount_err;
1716 if (strnicmp(string, "default", 7) != 0) {
1717 vol->iocharset = kstrdup(string,
1719 if (!vol->iocharset) {
1720 printk(KERN_WARNING "CIFS: no memory"
1722 goto cifs_parse_mount_err;
1725 /* if iocharset not set then load_nls_default
1728 cFYI(1, "iocharset set to %s", string);
1731 string = match_strdup(args);
1735 if (strnicmp(string, "TCP_NODELAY", 11) == 0) {
1736 printk(KERN_WARNING "CIFS: the "
1737 "sockopt=TCP_NODELAY option has been "
1738 "deprecated and will be removed "
1740 vol->sockopt_tcp_nodelay = 1;
1743 case Opt_netbiosname:
1744 string = match_strdup(args);
1748 memset(vol->source_rfc1001_name, 0x20,
1751 * FIXME: are there cases in which a comma can
1752 * be valid in workstation netbios name (and
1753 * need special handling)?
1755 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1756 /* don't ucase netbiosname for user */
1759 vol->source_rfc1001_name[i] = string[i];
1761 /* The string has 16th byte zero still from
1762 * set at top of the function
1764 if (i == RFC1001_NAME_LEN && string[i] != 0)
1765 printk(KERN_WARNING "CIFS: netbiosname"
1766 " longer than 15 truncated.\n");
1770 /* servernetbiosname specified override *SMBSERVER */
1771 string = match_strdup(args);
1775 /* last byte, type, is 0x20 for servr type */
1776 memset(vol->target_rfc1001_name, 0x20,
1777 RFC1001_NAME_LEN_WITH_NULL);
1779 /* BB are there cases in which a comma can be
1780 valid in this workstation netbios name
1781 (and need special handling)? */
1783 /* user or mount helper must uppercase the
1785 for (i = 0; i < 15; i++) {
1788 vol->target_rfc1001_name[i] = string[i];
1790 /* The string has 16th byte zero still from
1791 set at top of the function */
1792 if (i == RFC1001_NAME_LEN && string[i] != 0)
1793 printk(KERN_WARNING "CIFS: server net"
1794 "biosname longer than 15 truncated.\n");
1797 string = match_strdup(args);
1801 if (strnicmp(string, "1", 1) == 0) {
1802 /* This is the default */
1805 /* For all other value, error */
1806 printk(KERN_WARNING "CIFS: Invalid version"
1808 goto cifs_parse_mount_err;
1810 string = match_strdup(args);
1814 if (cifs_parse_smb_version(string, vol) != 0)
1815 goto cifs_parse_mount_err;
1818 string = match_strdup(args);
1822 if (cifs_parse_security_flavors(string, vol) != 0)
1823 goto cifs_parse_mount_err;
1826 string = match_strdup(args);
1830 if (cifs_parse_cache_flavor(string, vol) != 0)
1831 goto cifs_parse_mount_err;
1835 * An option we don't recognize. Save it off for later
1836 * if we haven't already found one
1842 /* Free up any allocated string */
1847 if (!sloppy && invalid) {
1848 printk(KERN_ERR "CIFS: Unknown mount option \"%s\"\n", invalid);
1849 goto cifs_parse_mount_err;
1853 /* Muliuser mounts require CONFIG_KEYS support */
1854 if (vol->multiuser) {
1855 cERROR(1, "Multiuser mounts require kernels with "
1856 "CONFIG_KEYS enabled.");
1857 goto cifs_parse_mount_err;
1861 cERROR(1, "CIFS mount error: No usable UNC path provided in "
1862 "device string or in unc= option!");
1863 goto cifs_parse_mount_err;
1866 /* make sure UNC has a share name */
1867 if (!strchr(vol->UNC + 3, '\\')) {
1868 cERROR(1, "Malformed UNC. Unable to find share name.");
1869 goto cifs_parse_mount_err;
1873 /* No ip= option specified? Try to get it from UNC */
1874 if (!cifs_convert_address(dstaddr, &vol->UNC[2],
1875 strlen(&vol->UNC[2]))) {
1876 printk(KERN_ERR "Unable to determine destination "
1878 goto cifs_parse_mount_err;
1882 /* set the port that we got earlier */
1883 cifs_set_port(dstaddr, port);
1886 vol->override_uid = override_uid;
1887 else if (override_uid == 1)
1888 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1889 "specified with no uid= option.\n");
1892 vol->override_gid = override_gid;
1893 else if (override_gid == 1)
1894 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1895 "specified with no gid= option.\n");
1897 kfree(mountdata_copy);
1901 printk(KERN_WARNING "Could not allocate temporary buffer\n");
1902 cifs_parse_mount_err:
1904 kfree(mountdata_copy);
1908 /** Returns true if srcaddr isn't specified and rhs isn't
1909 * specified, or if srcaddr is specified and
1910 * matches the IP address of the rhs argument.
1913 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1915 switch (srcaddr->sa_family) {
1917 return (rhs->sa_family == AF_UNSPEC);
1919 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1920 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1921 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1924 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1925 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1926 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1930 return false; /* don't expect to be here */
1935 * If no port is specified in addr structure, we try to match with 445 port
1936 * and if it fails - with 139 ports. It should be called only if address
1937 * families of server and addr are equal.
1940 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1942 __be16 port, *sport;
1944 switch (addr->sa_family) {
1946 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1947 port = ((struct sockaddr_in *) addr)->sin_port;
1950 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1951 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1959 port = htons(CIFS_PORT);
1963 port = htons(RFC1001_PORT);
1966 return port == *sport;
1970 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1971 struct sockaddr *srcaddr)
1973 switch (addr->sa_family) {
1975 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1976 struct sockaddr_in *srv_addr4 =
1977 (struct sockaddr_in *)&server->dstaddr;
1979 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1984 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1985 struct sockaddr_in6 *srv_addr6 =
1986 (struct sockaddr_in6 *)&server->dstaddr;
1988 if (!ipv6_addr_equal(&addr6->sin6_addr,
1989 &srv_addr6->sin6_addr))
1991 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
1997 return false; /* don't expect to be here */
2000 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2007 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2009 unsigned int secFlags;
2011 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
2012 secFlags = vol->secFlg;
2014 secFlags = global_secflags | vol->secFlg;
2016 switch (server->secType) {
2018 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
2022 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
2026 if (!(secFlags & CIFSSEC_MAY_NTLM))
2030 if (!(secFlags & CIFSSEC_MAY_KRB5))
2034 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
2038 /* shouldn't happen */
2042 /* now check if signing mode is acceptable */
2043 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
2044 (server->sec_mode & SECMODE_SIGN_REQUIRED))
2046 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
2048 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
2054 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2056 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2058 if ((server->vals != vol->vals) || (server->ops != vol->ops))
2061 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2064 if (!match_address(server, addr,
2065 (struct sockaddr *)&vol->srcaddr))
2068 if (!match_port(server, addr))
2071 if (!match_security(server, vol))
2077 static struct TCP_Server_Info *
2078 cifs_find_tcp_session(struct smb_vol *vol)
2080 struct TCP_Server_Info *server;
2082 spin_lock(&cifs_tcp_ses_lock);
2083 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2084 if (!match_server(server, vol))
2087 ++server->srv_count;
2088 spin_unlock(&cifs_tcp_ses_lock);
2089 cFYI(1, "Existing tcp session with server found");
2092 spin_unlock(&cifs_tcp_ses_lock);
2097 cifs_put_tcp_session(struct TCP_Server_Info *server)
2099 struct task_struct *task;
2101 spin_lock(&cifs_tcp_ses_lock);
2102 if (--server->srv_count > 0) {
2103 spin_unlock(&cifs_tcp_ses_lock);
2107 put_net(cifs_net_ns(server));
2109 list_del_init(&server->tcp_ses_list);
2110 spin_unlock(&cifs_tcp_ses_lock);
2112 cancel_delayed_work_sync(&server->echo);
2114 spin_lock(&GlobalMid_Lock);
2115 server->tcpStatus = CifsExiting;
2116 spin_unlock(&GlobalMid_Lock);
2118 cifs_crypto_shash_release(server);
2119 cifs_fscache_release_client_cookie(server);
2121 kfree(server->session_key.response);
2122 server->session_key.response = NULL;
2123 server->session_key.len = 0;
2125 task = xchg(&server->tsk, NULL);
2127 force_sig(SIGKILL, task);
2130 static struct TCP_Server_Info *
2131 cifs_get_tcp_session(struct smb_vol *volume_info)
2133 struct TCP_Server_Info *tcp_ses = NULL;
2136 cFYI(1, "UNC: %s", volume_info->UNC);
2138 /* see if we already have a matching tcp_ses */
2139 tcp_ses = cifs_find_tcp_session(volume_info);
2143 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2149 rc = cifs_crypto_shash_allocate(tcp_ses);
2151 cERROR(1, "could not setup hash structures rc %d", rc);
2155 tcp_ses->ops = volume_info->ops;
2156 tcp_ses->vals = volume_info->vals;
2157 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2158 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2159 if (IS_ERR(tcp_ses->hostname)) {
2160 rc = PTR_ERR(tcp_ses->hostname);
2161 goto out_err_crypto_release;
2164 tcp_ses->noblocksnd = volume_info->noblocksnd;
2165 tcp_ses->noautotune = volume_info->noautotune;
2166 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2167 tcp_ses->in_flight = 0;
2168 tcp_ses->credits = 1;
2169 init_waitqueue_head(&tcp_ses->response_q);
2170 init_waitqueue_head(&tcp_ses->request_q);
2171 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2172 mutex_init(&tcp_ses->srv_mutex);
2173 memcpy(tcp_ses->workstation_RFC1001_name,
2174 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2175 memcpy(tcp_ses->server_RFC1001_name,
2176 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2177 tcp_ses->session_estab = false;
2178 tcp_ses->sequence_number = 0;
2179 tcp_ses->lstrp = jiffies;
2180 spin_lock_init(&tcp_ses->req_lock);
2181 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2182 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2183 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2184 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2185 sizeof(tcp_ses->srcaddr));
2186 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2187 sizeof(tcp_ses->dstaddr));
2189 * at this point we are the only ones with the pointer
2190 * to the struct since the kernel thread not created yet
2191 * no need to spinlock this init of tcpStatus or srv_count
2193 tcp_ses->tcpStatus = CifsNew;
2194 ++tcp_ses->srv_count;
2196 rc = ip_connect(tcp_ses);
2198 cERROR(1, "Error connecting to socket. Aborting operation");
2199 goto out_err_crypto_release;
2203 * since we're in a cifs function already, we know that
2204 * this will succeed. No need for try_module_get().
2206 __module_get(THIS_MODULE);
2207 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2209 if (IS_ERR(tcp_ses->tsk)) {
2210 rc = PTR_ERR(tcp_ses->tsk);
2211 cERROR(1, "error %d create cifsd thread", rc);
2212 module_put(THIS_MODULE);
2213 goto out_err_crypto_release;
2215 tcp_ses->tcpStatus = CifsNeedNegotiate;
2217 /* thread spawned, put it on the list */
2218 spin_lock(&cifs_tcp_ses_lock);
2219 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2220 spin_unlock(&cifs_tcp_ses_lock);
2222 cifs_fscache_get_client_cookie(tcp_ses);
2224 /* queue echo request delayed work */
2225 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
2229 out_err_crypto_release:
2230 cifs_crypto_shash_release(tcp_ses);
2232 put_net(cifs_net_ns(tcp_ses));
2236 if (!IS_ERR(tcp_ses->hostname))
2237 kfree(tcp_ses->hostname);
2238 if (tcp_ses->ssocket)
2239 sock_release(tcp_ses->ssocket);
2245 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2247 switch (ses->server->secType) {
2249 if (vol->cred_uid != ses->cred_uid)
2253 /* NULL username means anonymous session */
2254 if (ses->user_name == NULL) {
2260 /* anything else takes username/password */
2261 if (strncmp(ses->user_name,
2262 vol->username ? vol->username : "",
2265 if (strlen(vol->username) != 0 &&
2266 ses->password != NULL &&
2267 strncmp(ses->password,
2268 vol->password ? vol->password : "",
2275 static struct cifs_ses *
2276 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2278 struct cifs_ses *ses;
2280 spin_lock(&cifs_tcp_ses_lock);
2281 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2282 if (!match_session(ses, vol))
2285 spin_unlock(&cifs_tcp_ses_lock);
2288 spin_unlock(&cifs_tcp_ses_lock);
2293 cifs_put_smb_ses(struct cifs_ses *ses)
2296 struct TCP_Server_Info *server = ses->server;
2298 cFYI(1, "%s: ses_count=%d", __func__, ses->ses_count);
2299 spin_lock(&cifs_tcp_ses_lock);
2300 if (--ses->ses_count > 0) {
2301 spin_unlock(&cifs_tcp_ses_lock);
2305 list_del_init(&ses->smb_ses_list);
2306 spin_unlock(&cifs_tcp_ses_lock);
2308 if (ses->status == CifsGood && server->ops->logoff) {
2310 server->ops->logoff(xid, ses);
2314 cifs_put_tcp_session(server);
2319 /* strlen("cifs:a:") + INET6_ADDRSTRLEN + 1 */
2320 #define CIFSCREDS_DESC_SIZE (7 + INET6_ADDRSTRLEN + 1)
2322 /* Populate username and pw fields from keyring if possible */
2324 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2327 char *desc, *delim, *payload;
2330 struct TCP_Server_Info *server = ses->server;
2331 struct sockaddr_in *sa;
2332 struct sockaddr_in6 *sa6;
2333 struct user_key_payload *upayload;
2335 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2339 /* try to find an address key first */
2340 switch (server->dstaddr.ss_family) {
2342 sa = (struct sockaddr_in *)&server->dstaddr;
2343 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2346 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2347 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2350 cFYI(1, "Bad ss_family (%hu)", server->dstaddr.ss_family);
2355 cFYI(1, "%s: desc=%s", __func__, desc);
2356 key = request_key(&key_type_logon, desc, "");
2358 if (!ses->domainName) {
2359 cFYI(1, "domainName is NULL");
2364 /* didn't work, try to find a domain key */
2365 sprintf(desc, "cifs:d:%s", ses->domainName);
2366 cFYI(1, "%s: desc=%s", __func__, desc);
2367 key = request_key(&key_type_logon, desc, "");
2374 down_read(&key->sem);
2375 upayload = key->payload.data;
2376 if (IS_ERR_OR_NULL(upayload)) {
2377 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2381 /* find first : in payload */
2382 payload = (char *)upayload->data;
2383 delim = strnchr(payload, upayload->datalen, ':');
2384 cFYI(1, "payload=%s", payload);
2386 cFYI(1, "Unable to find ':' in payload (datalen=%d)",
2392 len = delim - payload;
2393 if (len > MAX_USERNAME_SIZE || len <= 0) {
2394 cFYI(1, "Bad value from username search (len=%zd)", len);
2399 vol->username = kstrndup(payload, len, GFP_KERNEL);
2400 if (!vol->username) {
2401 cFYI(1, "Unable to allocate %zd bytes for username", len);
2405 cFYI(1, "%s: username=%s", __func__, vol->username);
2407 len = key->datalen - (len + 1);
2408 if (len > MAX_PASSWORD_SIZE || len <= 0) {
2409 cFYI(1, "Bad len for password search (len=%zd)", len);
2411 kfree(vol->username);
2412 vol->username = NULL;
2417 vol->password = kstrndup(delim, len, GFP_KERNEL);
2418 if (!vol->password) {
2419 cFYI(1, "Unable to allocate %zd bytes for password", len);
2421 kfree(vol->username);
2422 vol->username = NULL;
2431 cFYI(1, "%s: returning %d", __func__, rc);
2434 #else /* ! CONFIG_KEYS */
2436 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2437 struct cifs_ses *ses __attribute__((unused)))
2441 #endif /* CONFIG_KEYS */
2443 static struct cifs_ses *
2444 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2448 struct cifs_ses *ses;
2449 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2450 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2454 ses = cifs_find_smb_ses(server, volume_info);
2456 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
2458 mutex_lock(&ses->session_mutex);
2459 rc = cifs_negotiate_protocol(xid, ses);
2461 mutex_unlock(&ses->session_mutex);
2462 /* problem -- put our ses reference */
2463 cifs_put_smb_ses(ses);
2467 if (ses->need_reconnect) {
2468 cFYI(1, "Session needs reconnect");
2469 rc = cifs_setup_session(xid, ses,
2470 volume_info->local_nls);
2472 mutex_unlock(&ses->session_mutex);
2473 /* problem -- put our reference */
2474 cifs_put_smb_ses(ses);
2479 mutex_unlock(&ses->session_mutex);
2481 /* existing SMB ses has a server reference already */
2482 cifs_put_tcp_session(server);
2487 cFYI(1, "Existing smb sess not found");
2488 ses = sesInfoAlloc();
2492 /* new SMB session uses our server ref */
2493 ses->server = server;
2494 if (server->dstaddr.ss_family == AF_INET6)
2495 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2497 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2499 if (volume_info->username) {
2500 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2501 if (!ses->user_name)
2505 /* volume_info->password freed at unmount */
2506 if (volume_info->password) {
2507 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2511 if (volume_info->domainname) {
2512 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2513 if (!ses->domainName)
2516 ses->cred_uid = volume_info->cred_uid;
2517 ses->linux_uid = volume_info->linux_uid;
2519 ses->overrideSecFlg = volume_info->secFlg;
2521 mutex_lock(&ses->session_mutex);
2522 rc = cifs_negotiate_protocol(xid, ses);
2524 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2525 mutex_unlock(&ses->session_mutex);
2529 /* success, put it on the list */
2530 spin_lock(&cifs_tcp_ses_lock);
2531 list_add(&ses->smb_ses_list, &server->smb_ses_list);
2532 spin_unlock(&cifs_tcp_ses_lock);
2543 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2545 if (tcon->tidStatus == CifsExiting)
2547 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2552 static struct cifs_tcon *
2553 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2555 struct list_head *tmp;
2556 struct cifs_tcon *tcon;
2558 spin_lock(&cifs_tcp_ses_lock);
2559 list_for_each(tmp, &ses->tcon_list) {
2560 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2561 if (!match_tcon(tcon, unc))
2564 spin_unlock(&cifs_tcp_ses_lock);
2567 spin_unlock(&cifs_tcp_ses_lock);
2572 cifs_put_tcon(struct cifs_tcon *tcon)
2575 struct cifs_ses *ses = tcon->ses;
2577 cFYI(1, "%s: tc_count=%d", __func__, tcon->tc_count);
2578 spin_lock(&cifs_tcp_ses_lock);
2579 if (--tcon->tc_count > 0) {
2580 spin_unlock(&cifs_tcp_ses_lock);
2584 list_del_init(&tcon->tcon_list);
2585 spin_unlock(&cifs_tcp_ses_lock);
2588 if (ses->server->ops->tree_disconnect)
2589 ses->server->ops->tree_disconnect(xid, tcon);
2592 cifs_fscache_release_super_cookie(tcon);
2594 cifs_put_smb_ses(ses);
2597 static struct cifs_tcon *
2598 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2601 struct cifs_tcon *tcon;
2603 tcon = cifs_find_tcon(ses, volume_info->UNC);
2605 cFYI(1, "Found match on UNC path");
2606 /* existing tcon already has a reference */
2607 cifs_put_smb_ses(ses);
2608 if (tcon->seal != volume_info->seal)
2609 cERROR(1, "transport encryption setting "
2610 "conflicts with existing tid");
2614 if (!ses->server->ops->tree_connect) {
2619 tcon = tconInfoAlloc();
2626 if (volume_info->password) {
2627 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2628 if (!tcon->password) {
2635 * BB Do we need to wrap session_mutex around this TCon call and Unix
2636 * SetFS as we do on SessSetup and reconnect?
2639 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2640 volume_info->local_nls);
2642 cFYI(1, "Tcon rc = %d", rc);
2646 if (volume_info->nodfs) {
2647 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2648 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2650 tcon->seal = volume_info->seal;
2652 * We can have only one retry value for a connection to a share so for
2653 * resources mounted more than once to the same server share the last
2654 * value passed in for the retry flag is used.
2656 tcon->retry = volume_info->retry;
2657 tcon->nocase = volume_info->nocase;
2658 tcon->local_lease = volume_info->local_lease;
2659 INIT_LIST_HEAD(&tcon->pending_opens);
2661 spin_lock(&cifs_tcp_ses_lock);
2662 list_add(&tcon->tcon_list, &ses->tcon_list);
2663 spin_unlock(&cifs_tcp_ses_lock);
2665 cifs_fscache_get_super_cookie(tcon);
2675 cifs_put_tlink(struct tcon_link *tlink)
2677 if (!tlink || IS_ERR(tlink))
2680 if (!atomic_dec_and_test(&tlink->tl_count) ||
2681 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2682 tlink->tl_time = jiffies;
2686 if (!IS_ERR(tlink_tcon(tlink)))
2687 cifs_put_tcon(tlink_tcon(tlink));
2692 static inline struct tcon_link *
2693 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2695 return cifs_sb->master_tlink;
2699 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2701 struct cifs_sb_info *old = CIFS_SB(sb);
2702 struct cifs_sb_info *new = mnt_data->cifs_sb;
2704 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2707 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2708 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2712 * We want to share sb only if we don't specify an r/wsize or
2713 * specified r/wsize is greater than or equal to existing one.
2715 if (new->wsize && new->wsize < old->wsize)
2718 if (new->rsize && new->rsize < old->rsize)
2721 if (old->mnt_uid != new->mnt_uid || old->mnt_gid != new->mnt_gid)
2724 if (old->mnt_file_mode != new->mnt_file_mode ||
2725 old->mnt_dir_mode != new->mnt_dir_mode)
2728 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2731 if (old->actimeo != new->actimeo)
2738 cifs_match_super(struct super_block *sb, void *data)
2740 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2741 struct smb_vol *volume_info;
2742 struct cifs_sb_info *cifs_sb;
2743 struct TCP_Server_Info *tcp_srv;
2744 struct cifs_ses *ses;
2745 struct cifs_tcon *tcon;
2746 struct tcon_link *tlink;
2749 spin_lock(&cifs_tcp_ses_lock);
2750 cifs_sb = CIFS_SB(sb);
2751 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2752 if (IS_ERR(tlink)) {
2753 spin_unlock(&cifs_tcp_ses_lock);
2756 tcon = tlink_tcon(tlink);
2758 tcp_srv = ses->server;
2760 volume_info = mnt_data->vol;
2762 if (!match_server(tcp_srv, volume_info) ||
2763 !match_session(ses, volume_info) ||
2764 !match_tcon(tcon, volume_info->UNC)) {
2769 rc = compare_mount_options(sb, mnt_data);
2771 spin_unlock(&cifs_tcp_ses_lock);
2772 cifs_put_tlink(tlink);
2777 get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
2778 const struct nls_table *nls_codepage, unsigned int *num_referrals,
2779 struct dfs_info3_param **referrals, int remap)
2784 if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
2790 if (ses->ipc_tid == 0) {
2791 temp_unc = kmalloc(2 /* for slashes */ +
2792 strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2793 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
2794 if (temp_unc == NULL)
2798 strcpy(temp_unc + 2, ses->serverName);
2799 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2800 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2802 cFYI(1, "Tcon rc = %d ipc_tid = %d", rc, ses->ipc_tid);
2806 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
2807 referrals, num_referrals,
2808 nls_codepage, remap);
2810 * BB - map targetUNCs to dfs_info3 structures, here or in
2811 * ses->server->ops->get_dfs_refer.
2817 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2818 static struct lock_class_key cifs_key[2];
2819 static struct lock_class_key cifs_slock_key[2];
2822 cifs_reclassify_socket4(struct socket *sock)
2824 struct sock *sk = sock->sk;
2825 BUG_ON(sock_owned_by_user(sk));
2826 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2827 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2831 cifs_reclassify_socket6(struct socket *sock)
2833 struct sock *sk = sock->sk;
2834 BUG_ON(sock_owned_by_user(sk));
2835 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2836 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2840 cifs_reclassify_socket4(struct socket *sock)
2845 cifs_reclassify_socket6(struct socket *sock)
2850 /* See RFC1001 section 14 on representation of Netbios names */
2851 static void rfc1002mangle(char *target, char *source, unsigned int length)
2855 for (i = 0, j = 0; i < (length); i++) {
2856 /* mask a nibble at a time and encode */
2857 target[j] = 'A' + (0x0F & (source[i] >> 4));
2858 target[j+1] = 'A' + (0x0F & source[i]);
2865 bind_socket(struct TCP_Server_Info *server)
2868 if (server->srcaddr.ss_family != AF_UNSPEC) {
2869 /* Bind to the specified local IP address */
2870 struct socket *socket = server->ssocket;
2871 rc = socket->ops->bind(socket,
2872 (struct sockaddr *) &server->srcaddr,
2873 sizeof(server->srcaddr));
2875 struct sockaddr_in *saddr4;
2876 struct sockaddr_in6 *saddr6;
2877 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2878 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2879 if (saddr6->sin6_family == AF_INET6)
2881 "Failed to bind to: %pI6c, error: %d",
2882 &saddr6->sin6_addr, rc);
2885 "Failed to bind to: %pI4, error: %d",
2886 &saddr4->sin_addr.s_addr, rc);
2893 ip_rfc1001_connect(struct TCP_Server_Info *server)
2897 * some servers require RFC1001 sessinit before sending
2898 * negprot - BB check reconnection in case where second
2899 * sessinit is sent but no second negprot
2901 struct rfc1002_session_packet *ses_init_buf;
2902 struct smb_hdr *smb_buf;
2903 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2906 ses_init_buf->trailer.session_req.called_len = 32;
2908 if (server->server_RFC1001_name &&
2909 server->server_RFC1001_name[0] != 0)
2910 rfc1002mangle(ses_init_buf->trailer.
2911 session_req.called_name,
2912 server->server_RFC1001_name,
2913 RFC1001_NAME_LEN_WITH_NULL);
2915 rfc1002mangle(ses_init_buf->trailer.
2916 session_req.called_name,
2917 DEFAULT_CIFS_CALLED_NAME,
2918 RFC1001_NAME_LEN_WITH_NULL);
2920 ses_init_buf->trailer.session_req.calling_len = 32;
2923 * calling name ends in null (byte 16) from old smb
2926 if (server->workstation_RFC1001_name &&
2927 server->workstation_RFC1001_name[0] != 0)
2928 rfc1002mangle(ses_init_buf->trailer.
2929 session_req.calling_name,
2930 server->workstation_RFC1001_name,
2931 RFC1001_NAME_LEN_WITH_NULL);
2933 rfc1002mangle(ses_init_buf->trailer.
2934 session_req.calling_name,
2936 RFC1001_NAME_LEN_WITH_NULL);
2938 ses_init_buf->trailer.session_req.scope1 = 0;
2939 ses_init_buf->trailer.session_req.scope2 = 0;
2940 smb_buf = (struct smb_hdr *)ses_init_buf;
2942 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2943 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
2944 rc = smb_send(server, smb_buf, 0x44);
2945 kfree(ses_init_buf);
2947 * RFC1001 layer in at least one server
2948 * requires very short break before negprot
2949 * presumably because not expecting negprot
2950 * to follow so fast. This is a simple
2951 * solution that works without
2952 * complicating the code and causes no
2953 * significant slowing down on mount
2956 usleep_range(1000, 2000);
2959 * else the negprot may still work without this
2960 * even though malloc failed
2967 generic_ip_connect(struct TCP_Server_Info *server)
2972 struct socket *socket = server->ssocket;
2973 struct sockaddr *saddr;
2975 saddr = (struct sockaddr *) &server->dstaddr;
2977 if (server->dstaddr.ss_family == AF_INET6) {
2978 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2979 slen = sizeof(struct sockaddr_in6);
2982 sport = ((struct sockaddr_in *) saddr)->sin_port;
2983 slen = sizeof(struct sockaddr_in);
2987 if (socket == NULL) {
2988 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2989 IPPROTO_TCP, &socket, 1);
2991 cERROR(1, "Error %d creating socket", rc);
2992 server->ssocket = NULL;
2996 /* BB other socket options to set KEEPALIVE, NODELAY? */
2997 cFYI(1, "Socket created");
2998 server->ssocket = socket;
2999 socket->sk->sk_allocation = GFP_NOFS;
3000 if (sfamily == AF_INET6)
3001 cifs_reclassify_socket6(socket);
3003 cifs_reclassify_socket4(socket);
3006 rc = bind_socket(server);
3011 * Eventually check for other socket options to change from
3012 * the default. sock_setsockopt not used because it expects
3015 socket->sk->sk_rcvtimeo = 7 * HZ;
3016 socket->sk->sk_sndtimeo = 5 * HZ;
3018 /* make the bufsizes depend on wsize/rsize and max requests */
3019 if (server->noautotune) {
3020 if (socket->sk->sk_sndbuf < (200 * 1024))
3021 socket->sk->sk_sndbuf = 200 * 1024;
3022 if (socket->sk->sk_rcvbuf < (140 * 1024))
3023 socket->sk->sk_rcvbuf = 140 * 1024;
3026 if (server->tcp_nodelay) {
3028 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3029 (char *)&val, sizeof(val));
3031 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
3034 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
3035 socket->sk->sk_sndbuf,
3036 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3038 rc = socket->ops->connect(socket, saddr, slen, 0);
3040 cFYI(1, "Error %d connecting to server", rc);
3041 sock_release(socket);
3042 server->ssocket = NULL;
3046 if (sport == htons(RFC1001_PORT))
3047 rc = ip_rfc1001_connect(server);
3053 ip_connect(struct TCP_Server_Info *server)
3056 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3057 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3059 if (server->dstaddr.ss_family == AF_INET6)
3060 sport = &addr6->sin6_port;
3062 sport = &addr->sin_port;
3067 /* try with 445 port at first */
3068 *sport = htons(CIFS_PORT);
3070 rc = generic_ip_connect(server);
3074 /* if it failed, try with 139 port */
3075 *sport = htons(RFC1001_PORT);
3078 return generic_ip_connect(server);
3081 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3082 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3084 /* if we are reconnecting then should we check to see if
3085 * any requested capabilities changed locally e.g. via
3086 * remount but we can not do much about it here
3087 * if they have (even if we could detect it by the following)
3088 * Perhaps we could add a backpointer to array of sb from tcon
3089 * or if we change to make all sb to same share the same
3090 * sb as NFS - then we only have one backpointer to sb.
3091 * What if we wanted to mount the server share twice once with
3092 * and once without posixacls or posix paths? */
3093 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3095 if (vol_info && vol_info->no_linux_ext) {
3096 tcon->fsUnixInfo.Capability = 0;
3097 tcon->unix_ext = 0; /* Unix Extensions disabled */
3098 cFYI(1, "Linux protocol extensions disabled");
3100 } else if (vol_info)
3101 tcon->unix_ext = 1; /* Unix Extensions supported */
3103 if (tcon->unix_ext == 0) {
3104 cFYI(1, "Unix extensions disabled so not set on reconnect");
3108 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3109 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3110 cFYI(1, "unix caps which server supports %lld", cap);
3111 /* check for reconnect case in which we do not
3112 want to change the mount behavior if we can avoid it */
3113 if (vol_info == NULL) {
3114 /* turn off POSIX ACL and PATHNAMES if not set
3115 originally at mount time */
3116 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3117 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3118 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3119 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3120 cERROR(1, "POSIXPATH support change");
3121 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3122 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3123 cERROR(1, "possible reconnect error");
3124 cERROR(1, "server disabled POSIX path support");
3128 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3129 cERROR(1, "per-share encryption not supported yet");
3131 cap &= CIFS_UNIX_CAP_MASK;
3132 if (vol_info && vol_info->no_psx_acl)
3133 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3134 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3135 cFYI(1, "negotiated posix acl support");
3137 cifs_sb->mnt_cifs_flags |=
3138 CIFS_MOUNT_POSIXACL;
3141 if (vol_info && vol_info->posix_paths == 0)
3142 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3143 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3144 cFYI(1, "negotiate posix pathnames");
3146 cifs_sb->mnt_cifs_flags |=
3147 CIFS_MOUNT_POSIX_PATHS;
3150 cFYI(1, "Negotiate caps 0x%x", (int)cap);
3151 #ifdef CONFIG_CIFS_DEBUG2
3152 if (cap & CIFS_UNIX_FCNTL_CAP)
3153 cFYI(1, "FCNTL cap");
3154 if (cap & CIFS_UNIX_EXTATTR_CAP)
3155 cFYI(1, "EXTATTR cap");
3156 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3157 cFYI(1, "POSIX path cap");
3158 if (cap & CIFS_UNIX_XATTR_CAP)
3159 cFYI(1, "XATTR cap");
3160 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3161 cFYI(1, "POSIX ACL cap");
3162 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3163 cFYI(1, "very large read cap");
3164 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3165 cFYI(1, "very large write cap");
3166 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3167 cFYI(1, "transport encryption cap");
3168 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3169 cFYI(1, "mandatory transport encryption cap");
3170 #endif /* CIFS_DEBUG2 */
3171 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3172 if (vol_info == NULL) {
3173 cFYI(1, "resetting capabilities failed");
3175 cERROR(1, "Negotiating Unix capabilities "
3176 "with the server failed. Consider "
3177 "mounting with the Unix Extensions "
3178 "disabled if problems are found "
3179 "by specifying the nounix mount "
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 cFYI(1, "file mode: 0x%hx dir mode: 0x%hx",
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_SPECIAL_CHR;
3219 if (pvolume_info->no_xattr)
3220 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3221 if (pvolume_info->sfu_emul)
3222 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3223 if (pvolume_info->nobrl)
3224 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3225 if (pvolume_info->nostrictsync)
3226 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3227 if (pvolume_info->mand_lock)
3228 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3229 if (pvolume_info->rwpidforward)
3230 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3231 if (pvolume_info->cifs_acl)
3232 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3233 if (pvolume_info->backupuid_specified) {
3234 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3235 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3237 if (pvolume_info->backupgid_specified) {
3238 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3239 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3241 if (pvolume_info->override_uid)
3242 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3243 if (pvolume_info->override_gid)
3244 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3245 if (pvolume_info->dynperm)
3246 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3247 if (pvolume_info->fsc)
3248 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3249 if (pvolume_info->multiuser)
3250 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3251 CIFS_MOUNT_NO_PERM);
3252 if (pvolume_info->strict_io)
3253 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3254 if (pvolume_info->direct_io) {
3255 cFYI(1, "mounting share using direct i/o");
3256 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3258 if (pvolume_info->mfsymlinks) {
3259 if (pvolume_info->sfu_emul) {
3260 cERROR(1, "mount option mfsymlinks ignored if sfu "
3261 "mount option is used");
3263 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3267 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3268 cERROR(1, "mount option dynperm ignored if cifsacl "
3269 "mount option supported");
3273 cleanup_volume_info_contents(struct smb_vol *volume_info)
3275 kfree(volume_info->username);
3276 kzfree(volume_info->password);
3277 kfree(volume_info->UNC);
3278 kfree(volume_info->domainname);
3279 kfree(volume_info->iocharset);
3280 kfree(volume_info->prepath);
3284 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3288 cleanup_volume_info_contents(volume_info);
3293 #ifdef CONFIG_CIFS_DFS_UPCALL
3295 * cifs_build_path_to_root returns full path to root when we do not have an
3296 * exiting connection (tcon)
3299 build_unc_path_to_root(const struct smb_vol *vol,
3300 const struct cifs_sb_info *cifs_sb)
3302 char *full_path, *pos;
3303 unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
3304 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3306 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3307 if (full_path == NULL)
3308 return ERR_PTR(-ENOMEM);
3310 strncpy(full_path, vol->UNC, unc_len);
3311 pos = full_path + unc_len;
3314 *pos++ = CIFS_DIR_SEP(cifs_sb);
3315 strncpy(pos, vol->prepath, pplen);
3319 *pos = '\0'; /* add trailing null */
3320 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3321 cFYI(1, "%s: full_path=%s", __func__, full_path);
3326 * Perform a dfs referral query for a share and (optionally) prefix
3328 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3329 * to a string containing updated options for the submount. Otherwise it
3330 * will be left untouched.
3332 * Returns the rc from get_dfs_path to the caller, which can be used to
3333 * determine whether there were referrals.
3336 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
3337 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3341 unsigned int num_referrals = 0;
3342 struct dfs_info3_param *referrals = NULL;
3343 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3345 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3346 if (IS_ERR(full_path))
3347 return PTR_ERR(full_path);
3349 /* For DFS paths, skip the first '\' of the UNC */
3350 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3352 rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
3353 &num_referrals, &referrals,
3354 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
3356 if (!rc && num_referrals > 0) {
3357 char *fake_devname = NULL;
3359 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3360 full_path + 1, referrals,
3363 free_dfs_info_array(referrals, num_referrals);
3365 if (IS_ERR(mdata)) {
3366 rc = PTR_ERR(mdata);
3369 cleanup_volume_info_contents(volume_info);
3370 rc = cifs_setup_volume_info(volume_info, mdata,
3373 kfree(fake_devname);
3374 kfree(cifs_sb->mountdata);
3375 cifs_sb->mountdata = mdata;
3383 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3384 const char *devname)
3388 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3391 if (volume_info->nullauth) {
3392 cFYI(1, "Anonymous login");
3393 kfree(volume_info->username);
3394 volume_info->username = NULL;
3395 } else if (volume_info->username) {
3396 /* BB fixme parse for domain name here */
3397 cFYI(1, "Username: %s", volume_info->username);
3399 cifserror("No username specified");
3400 /* In userspace mount helper we can get user name from alternate
3401 locations such as env variables and files on disk */
3405 /* this is needed for ASCII cp to Unicode converts */
3406 if (volume_info->iocharset == NULL) {
3407 /* load_nls_default cannot return null */
3408 volume_info->local_nls = load_nls_default();
3410 volume_info->local_nls = load_nls(volume_info->iocharset);
3411 if (volume_info->local_nls == NULL) {
3412 cERROR(1, "CIFS mount error: iocharset %s not found",
3413 volume_info->iocharset);
3422 cifs_get_volume_info(char *mount_data, const char *devname)
3425 struct smb_vol *volume_info;
3427 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
3429 return ERR_PTR(-ENOMEM);
3431 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3433 cifs_cleanup_volume_info(volume_info);
3434 volume_info = ERR_PTR(rc);
3441 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3445 struct cifs_ses *ses;
3446 struct cifs_tcon *tcon;
3447 struct TCP_Server_Info *server;
3449 struct tcon_link *tlink;
3450 #ifdef CONFIG_CIFS_DFS_UPCALL
3451 int referral_walks_count = 0;
3454 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3458 #ifdef CONFIG_CIFS_DFS_UPCALL
3460 /* cleanup activities if we're chasing a referral */
3461 if (referral_walks_count) {
3463 cifs_put_tcon(tcon);
3465 cifs_put_smb_ses(ses);
3479 /* get a reference to a tcp session */
3480 server = cifs_get_tcp_session(volume_info);
3481 if (IS_ERR(server)) {
3482 rc = PTR_ERR(server);
3483 bdi_destroy(&cifs_sb->bdi);
3487 /* get a reference to a SMB session */
3488 ses = cifs_get_smb_ses(server, volume_info);
3492 goto mount_fail_check;
3495 /* search for existing tcon to this server share */
3496 tcon = cifs_get_tcon(ses, volume_info);
3500 goto remote_path_check;
3503 /* tell server which Unix caps we support */
3504 if (cap_unix(tcon->ses)) {
3505 /* reset of caps checks mount to see if unix extensions
3506 disabled for just this mount */
3507 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3508 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3509 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3510 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3512 goto mount_fail_check;
3515 tcon->unix_ext = 0; /* server does not support them */
3517 /* do not care if a following call succeed - informational */
3518 if (!tcon->ipc && server->ops->qfs_tcon)
3519 server->ops->qfs_tcon(xid, tcon);
3521 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3522 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
3524 /* tune readahead according to rsize */
3525 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
3528 #ifdef CONFIG_CIFS_DFS_UPCALL
3530 * Perform an unconditional check for whether there are DFS
3531 * referrals for this path without prefix, to provide support
3532 * for DFS referrals from w2k8 servers which don't seem to respond
3533 * with PATH_NOT_COVERED to requests that include the prefix.
3534 * Chase the referral if found, otherwise continue normally.
3536 if (referral_walks_count == 0) {
3537 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3540 referral_walks_count++;
3541 goto try_mount_again;
3546 /* check if a whole path is not remote */
3548 if (!server->ops->is_path_accessible) {
3550 goto mount_fail_check;
3553 * cifs_build_path_to_root works only when we have a valid tcon
3555 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3556 if (full_path == NULL) {
3558 goto mount_fail_check;
3560 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3562 if (rc != 0 && rc != -EREMOTE) {
3564 goto mount_fail_check;
3569 /* get referral if needed */
3570 if (rc == -EREMOTE) {
3571 #ifdef CONFIG_CIFS_DFS_UPCALL
3572 if (referral_walks_count > MAX_NESTED_LINKS) {
3574 * BB: when we implement proper loop detection,
3575 * we will remove this check. But now we need it
3576 * to prevent an indefinite loop if 'DFS tree' is
3577 * misconfigured (i.e. has loops).
3580 goto mount_fail_check;
3583 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
3586 referral_walks_count++;
3587 goto try_mount_again;
3589 goto mount_fail_check;
3590 #else /* No DFS support, return error on mount */
3596 goto mount_fail_check;
3598 /* now, hang the tcon off of the superblock */
3599 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3600 if (tlink == NULL) {
3602 goto mount_fail_check;
3605 tlink->tl_uid = ses->linux_uid;
3606 tlink->tl_tcon = tcon;
3607 tlink->tl_time = jiffies;
3608 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3609 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3611 cifs_sb->master_tlink = tlink;
3612 spin_lock(&cifs_sb->tlink_tree_lock);
3613 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3614 spin_unlock(&cifs_sb->tlink_tree_lock);
3616 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3620 /* on error free sesinfo and tcon struct if needed */
3622 /* If find_unc succeeded then rc == 0 so we can not end */
3623 /* up accidentally freeing someone elses tcon struct */
3625 cifs_put_tcon(tcon);
3627 cifs_put_smb_ses(ses);
3629 cifs_put_tcp_session(server);
3630 bdi_destroy(&cifs_sb->bdi);
3639 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3640 * pointer may be NULL.
3643 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
3644 const char *tree, struct cifs_tcon *tcon,
3645 const struct nls_table *nls_codepage)
3647 struct smb_hdr *smb_buffer;
3648 struct smb_hdr *smb_buffer_response;
3651 unsigned char *bcc_ptr;
3654 __u16 bytes_left, count;
3659 smb_buffer = cifs_buf_get();
3660 if (smb_buffer == NULL)
3663 smb_buffer_response = smb_buffer;
3665 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3666 NULL /*no tid */ , 4 /*wct */ );
3668 smb_buffer->Mid = get_next_mid(ses->server);
3669 smb_buffer->Uid = ses->Suid;
3670 pSMB = (TCONX_REQ *) smb_buffer;
3671 pSMBr = (TCONX_RSP *) smb_buffer_response;
3673 pSMB->AndXCommand = 0xFF;
3674 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3675 bcc_ptr = &pSMB->Password[0];
3676 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3677 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3678 *bcc_ptr = 0; /* password is null byte */
3679 bcc_ptr++; /* skip password */
3680 /* already aligned so no need to do it below */
3682 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3683 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3684 specified as required (when that support is added to
3685 the vfs in the future) as only NTLM or the much
3686 weaker LANMAN (which we do not send by default) is accepted
3687 by Samba (not sure whether other servers allow
3688 NTLMv2 password here) */
3689 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3690 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3691 (ses->server->secType == LANMAN))
3692 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3693 ses->server->sec_mode &
3694 SECMODE_PW_ENCRYPT ? true : false,
3697 #endif /* CIFS_WEAK_PW_HASH */
3698 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3699 bcc_ptr, nls_codepage);
3701 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3702 if (ses->capabilities & CAP_UNICODE) {
3703 /* must align unicode strings */
3704 *bcc_ptr = 0; /* null byte password */
3709 if (ses->server->sec_mode &
3710 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3711 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3713 if (ses->capabilities & CAP_STATUS32) {
3714 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3716 if (ses->capabilities & CAP_DFS) {
3717 smb_buffer->Flags2 |= SMBFLG2_DFS;
3719 if (ses->capabilities & CAP_UNICODE) {
3720 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3722 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3723 6 /* max utf8 char length in bytes */ *
3724 (/* server len*/ + 256 /* share len */), nls_codepage);
3725 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3726 bcc_ptr += 2; /* skip trailing null */
3727 } else { /* ASCII */
3728 strcpy(bcc_ptr, tree);
3729 bcc_ptr += strlen(tree) + 1;
3731 strcpy(bcc_ptr, "?????");
3732 bcc_ptr += strlen("?????");
3734 count = bcc_ptr - &pSMB->Password[0];
3735 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3736 pSMB->hdr.smb_buf_length) + count);
3737 pSMB->ByteCount = cpu_to_le16(count);
3739 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3742 /* above now done in SendReceive */
3743 if ((rc == 0) && (tcon != NULL)) {
3746 tcon->tidStatus = CifsGood;
3747 tcon->need_reconnect = false;
3748 tcon->tid = smb_buffer_response->Tid;
3749 bcc_ptr = pByteArea(smb_buffer_response);
3750 bytes_left = get_bcc(smb_buffer_response);
3751 length = strnlen(bcc_ptr, bytes_left - 2);
3752 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3758 /* skip service field (NB: this field is always ASCII) */
3760 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3761 (bcc_ptr[2] == 'C')) {
3762 cFYI(1, "IPC connection");
3765 } else if (length == 2) {
3766 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3767 /* the most common case */
3768 cFYI(1, "disk share connection");
3771 bcc_ptr += length + 1;
3772 bytes_left -= (length + 1);
3773 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3775 /* mostly informational -- no need to fail on error here */
3776 kfree(tcon->nativeFileSystem);
3777 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
3778 bytes_left, is_unicode,
3781 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
3783 if ((smb_buffer_response->WordCount == 3) ||
3784 (smb_buffer_response->WordCount == 7))
3785 /* field is in same location */
3786 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3789 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
3790 } else if ((rc == 0) && tcon == NULL) {
3791 /* all we need to save for IPC$ connection */
3792 ses->ipc_tid = smb_buffer_response->Tid;
3795 cifs_buf_release(smb_buffer);
3800 cifs_umount(struct cifs_sb_info *cifs_sb)
3802 struct rb_root *root = &cifs_sb->tlink_tree;
3803 struct rb_node *node;
3804 struct tcon_link *tlink;
3806 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3808 spin_lock(&cifs_sb->tlink_tree_lock);
3809 while ((node = rb_first(root))) {
3810 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3811 cifs_get_tlink(tlink);
3812 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3813 rb_erase(node, root);
3815 spin_unlock(&cifs_sb->tlink_tree_lock);
3816 cifs_put_tlink(tlink);
3817 spin_lock(&cifs_sb->tlink_tree_lock);
3819 spin_unlock(&cifs_sb->tlink_tree_lock);
3821 bdi_destroy(&cifs_sb->bdi);
3822 kfree(cifs_sb->mountdata);
3823 unload_nls(cifs_sb->local_nls);
3828 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
3831 struct TCP_Server_Info *server = ses->server;
3833 if (!server->ops->need_neg || !server->ops->negotiate)
3836 /* only send once per connect */
3837 if (!server->ops->need_neg(server))
3840 set_credits(server, 1);
3842 rc = server->ops->negotiate(xid, ses);
3844 spin_lock(&GlobalMid_Lock);
3845 if (server->tcpStatus == CifsNeedNegotiate)
3846 server->tcpStatus = CifsGood;
3849 spin_unlock(&GlobalMid_Lock);
3856 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
3857 struct nls_table *nls_info)
3860 struct TCP_Server_Info *server = ses->server;
3863 ses->capabilities = server->capabilities;
3864 if (linuxExtEnabled == 0)
3865 ses->capabilities &= (~server->vals->cap_unix);
3867 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3868 server->sec_mode, server->capabilities, server->timeAdj);
3870 if (server->ops->sess_setup)
3871 rc = server->ops->sess_setup(xid, ses, nls_info);
3874 cERROR(1, "Send error in SessSetup = %d", rc);
3876 mutex_lock(&ses->server->srv_mutex);
3877 if (!server->session_estab) {
3878 server->session_key.response = ses->auth_key.response;
3879 server->session_key.len = ses->auth_key.len;
3880 server->sequence_number = 0x2;
3881 server->session_estab = true;
3882 ses->auth_key.response = NULL;
3884 mutex_unlock(&server->srv_mutex);
3886 cFYI(1, "CIFS Session Established successfully");
3887 spin_lock(&GlobalMid_Lock);
3888 ses->status = CifsGood;
3889 ses->need_reconnect = false;
3890 spin_unlock(&GlobalMid_Lock);
3893 kfree(ses->auth_key.response);
3894 ses->auth_key.response = NULL;
3895 ses->auth_key.len = 0;
3896 kfree(ses->ntlmssp);
3897 ses->ntlmssp = NULL;
3903 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
3905 switch (ses->server->secType) {
3907 vol->secFlg = CIFSSEC_MUST_KRB5;
3910 vol->secFlg = CIFSSEC_MUST_NTLMV2;
3913 vol->secFlg = CIFSSEC_MUST_NTLM;
3916 vol->secFlg = CIFSSEC_MUST_NTLMSSP;
3919 vol->secFlg = CIFSSEC_MUST_LANMAN;
3923 return cifs_set_cifscreds(vol, ses);
3926 static struct cifs_tcon *
3927 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
3930 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3931 struct cifs_ses *ses;
3932 struct cifs_tcon *tcon = NULL;
3933 struct smb_vol *vol_info;
3935 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3936 if (vol_info == NULL)
3937 return ERR_PTR(-ENOMEM);
3939 vol_info->local_nls = cifs_sb->local_nls;
3940 vol_info->linux_uid = fsuid;
3941 vol_info->cred_uid = fsuid;
3942 vol_info->UNC = master_tcon->treeName;
3943 vol_info->retry = master_tcon->retry;
3944 vol_info->nocase = master_tcon->nocase;
3945 vol_info->local_lease = master_tcon->local_lease;
3946 vol_info->no_linux_ext = !master_tcon->unix_ext;
3948 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
3954 /* get a reference for the same TCP session */
3955 spin_lock(&cifs_tcp_ses_lock);
3956 ++master_tcon->ses->server->srv_count;
3957 spin_unlock(&cifs_tcp_ses_lock);
3959 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3961 tcon = (struct cifs_tcon *)ses;
3962 cifs_put_tcp_session(master_tcon->ses->server);
3966 tcon = cifs_get_tcon(ses, vol_info);
3968 cifs_put_smb_ses(ses);
3973 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3975 kfree(vol_info->username);
3976 kfree(vol_info->password);
3983 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3985 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3989 cifs_sb_tcon_pending_wait(void *unused)
3992 return signal_pending(current) ? -ERESTARTSYS : 0;
3995 /* find and return a tlink with given uid */
3996 static struct tcon_link *
3997 tlink_rb_search(struct rb_root *root, uid_t uid)
3999 struct rb_node *node = root->rb_node;
4000 struct tcon_link *tlink;
4003 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4005 if (tlink->tl_uid > uid)
4006 node = node->rb_left;
4007 else if (tlink->tl_uid < uid)
4008 node = node->rb_right;
4015 /* insert a tcon_link into the tree */
4017 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4019 struct rb_node **new = &(root->rb_node), *parent = NULL;
4020 struct tcon_link *tlink;
4023 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4026 if (tlink->tl_uid > new_tlink->tl_uid)
4027 new = &((*new)->rb_left);
4029 new = &((*new)->rb_right);
4032 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4033 rb_insert_color(&new_tlink->tl_rbnode, root);
4037 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4040 * If the superblock doesn't refer to a multiuser mount, then just return
4041 * the master tcon for the mount.
4043 * First, search the rbtree for an existing tcon for this fsuid. If one
4044 * exists, then check to see if it's pending construction. If it is then wait
4045 * for construction to complete. Once it's no longer pending, check to see if
4046 * it failed and either return an error or retry construction, depending on
4049 * If one doesn't exist then insert a new tcon_link struct into the tree and
4050 * try to construct a new one.
4053 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4056 uid_t fsuid = current_fsuid();
4057 struct tcon_link *tlink, *newtlink;
4059 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4060 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4062 spin_lock(&cifs_sb->tlink_tree_lock);
4063 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4065 cifs_get_tlink(tlink);
4066 spin_unlock(&cifs_sb->tlink_tree_lock);
4068 if (tlink == NULL) {
4069 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4070 if (newtlink == NULL)
4071 return ERR_PTR(-ENOMEM);
4072 newtlink->tl_uid = fsuid;
4073 newtlink->tl_tcon = ERR_PTR(-EACCES);
4074 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4075 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4076 cifs_get_tlink(newtlink);
4078 spin_lock(&cifs_sb->tlink_tree_lock);
4079 /* was one inserted after previous search? */
4080 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4082 cifs_get_tlink(tlink);
4083 spin_unlock(&cifs_sb->tlink_tree_lock);
4085 goto wait_for_construction;
4088 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4089 spin_unlock(&cifs_sb->tlink_tree_lock);
4091 wait_for_construction:
4092 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4093 cifs_sb_tcon_pending_wait,
4094 TASK_INTERRUPTIBLE);
4096 cifs_put_tlink(tlink);
4097 return ERR_PTR(ret);
4100 /* if it's good, return it */
4101 if (!IS_ERR(tlink->tl_tcon))
4104 /* return error if we tried this already recently */
4105 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4106 cifs_put_tlink(tlink);
4107 return ERR_PTR(-EACCES);
4110 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4111 goto wait_for_construction;
4114 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4115 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4116 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4118 if (IS_ERR(tlink->tl_tcon)) {
4119 cifs_put_tlink(tlink);
4120 return ERR_PTR(-EACCES);
4127 * periodic workqueue job that scans tcon_tree for a superblock and closes
4131 cifs_prune_tlinks(struct work_struct *work)
4133 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4135 struct rb_root *root = &cifs_sb->tlink_tree;
4136 struct rb_node *node = rb_first(root);
4137 struct rb_node *tmp;
4138 struct tcon_link *tlink;
4141 * Because we drop the spinlock in the loop in order to put the tlink
4142 * it's not guarded against removal of links from the tree. The only
4143 * places that remove entries from the tree are this function and
4144 * umounts. Because this function is non-reentrant and is canceled
4145 * before umount can proceed, this is safe.
4147 spin_lock(&cifs_sb->tlink_tree_lock);
4148 node = rb_first(root);
4149 while (node != NULL) {
4151 node = rb_next(tmp);
4152 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4154 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4155 atomic_read(&tlink->tl_count) != 0 ||
4156 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4159 cifs_get_tlink(tlink);
4160 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4161 rb_erase(tmp, root);
4163 spin_unlock(&cifs_sb->tlink_tree_lock);
4164 cifs_put_tlink(tlink);
4165 spin_lock(&cifs_sb->tlink_tree_lock);
4167 spin_unlock(&cifs_sb->tlink_tree_lock);
4169 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,