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);
990 static int get_option_uid(substring_t args[], kuid_t *result)
996 rc = get_option_ul(args, &value);
1000 uid = make_kuid(current_user_ns(), value);
1001 if (!uid_valid(uid))
1008 static int get_option_gid(substring_t args[], kgid_t *result)
1010 unsigned long value;
1014 rc = get_option_ul(args, &value);
1018 gid = make_kgid(current_user_ns(), value);
1019 if (!gid_valid(gid))
1026 static int cifs_parse_security_flavors(char *value,
1027 struct smb_vol *vol)
1030 substring_t args[MAX_OPT_ARGS];
1032 switch (match_token(value, cifs_secflavor_tokens, args)) {
1034 vol->secFlg |= CIFSSEC_MAY_KRB5 | CIFSSEC_MAY_SIGN;
1037 vol->secFlg |= CIFSSEC_MAY_KRB5 | CIFSSEC_MUST_SIGN;
1040 /* vol->secFlg |= CIFSSEC_MUST_SEAL | CIFSSEC_MAY_KRB5; */
1041 cERROR(1, "Krb5 cifs privacy not supported");
1043 case Opt_sec_ntlmssp:
1044 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
1046 case Opt_sec_ntlmsspi:
1047 vol->secFlg |= CIFSSEC_MAY_NTLMSSP | CIFSSEC_MUST_SIGN;
1050 /* ntlm is default so can be turned off too */
1051 vol->secFlg |= CIFSSEC_MAY_NTLM;
1054 vol->secFlg |= CIFSSEC_MAY_NTLM | CIFSSEC_MUST_SIGN;
1056 case Opt_sec_ntlmv2:
1057 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1059 case Opt_sec_ntlmv2i:
1060 vol->secFlg |= CIFSSEC_MAY_NTLMV2 | CIFSSEC_MUST_SIGN;
1062 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1063 case Opt_sec_lanman:
1064 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1071 cERROR(1, "bad security option: %s", value);
1079 cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1081 substring_t args[MAX_OPT_ARGS];
1083 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1084 case Opt_cache_loose:
1085 vol->direct_io = false;
1086 vol->strict_io = false;
1088 case Opt_cache_strict:
1089 vol->direct_io = false;
1090 vol->strict_io = true;
1092 case Opt_cache_none:
1093 vol->direct_io = true;
1094 vol->strict_io = false;
1097 cERROR(1, "bad cache= option: %s", value);
1104 cifs_parse_smb_version(char *value, struct smb_vol *vol)
1106 substring_t args[MAX_OPT_ARGS];
1108 switch (match_token(value, cifs_smb_version_tokens, args)) {
1110 vol->ops = &smb1_operations;
1111 vol->vals = &smb1_values;
1113 #ifdef CONFIG_CIFS_SMB2
1115 vol->ops = &smb21_operations; /* currently identical with 2.1 */
1116 vol->vals = &smb20_values;
1119 vol->ops = &smb21_operations;
1120 vol->vals = &smb21_values;
1123 vol->ops = &smb30_operations;
1124 vol->vals = &smb30_values;
1128 cERROR(1, "Unknown vers= option specified: %s", value);
1135 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1136 * fields with the result. Returns 0 on success and an error otherwise.
1139 cifs_parse_devname(const char *devname, struct smb_vol *vol)
1142 const char *delims = "/\\";
1145 /* make sure we have a valid UNC double delimiter prefix */
1146 len = strspn(devname, delims);
1150 /* find delimiter between host and sharename */
1151 pos = strpbrk(devname + 2, delims);
1155 /* skip past delimiter */
1158 /* now go until next delimiter or end of string */
1159 len = strcspn(pos, delims);
1161 /* move "pos" up to delimiter or NULL */
1163 vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1167 convert_delimiter(vol->UNC, '\\');
1169 /* If pos is NULL, or is a bogus trailing delimiter then no prepath */
1170 if (!*pos++ || !*pos)
1173 vol->prepath = kstrdup(pos, GFP_KERNEL);
1181 cifs_parse_mount_options(const char *mountdata, const char *devname,
1182 struct smb_vol *vol)
1185 char *mountdata_copy = NULL, *options;
1186 unsigned int temp_len, i, j;
1188 short int override_uid = -1;
1189 short int override_gid = -1;
1190 bool uid_specified = false;
1191 bool gid_specified = false;
1192 bool sloppy = false;
1193 char *invalid = NULL;
1194 char *nodename = utsname()->nodename;
1195 char *string = NULL;
1196 char *tmp_end, *value;
1198 bool got_ip = false;
1199 unsigned short port = 0;
1200 struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1204 delim = separator[0];
1206 /* ensure we always start with zeroed-out smb_vol */
1207 memset(vol, 0, sizeof(*vol));
1210 * does not have to be perfect mapping since field is
1211 * informational, only used for servers that do not support
1212 * port 445 and it can be overridden at mount time
1214 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1215 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1216 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1218 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1219 /* null target name indicates to use *SMBSERVR default called name
1220 if we end up sending RFC1001 session initialize */
1221 vol->target_rfc1001_name[0] = 0;
1222 vol->cred_uid = current_uid();
1223 vol->linux_uid = current_uid();
1224 vol->linux_gid = current_gid();
1226 /* default to only allowing write access to owner of the mount */
1227 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1229 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1230 /* default is always to request posix paths. */
1231 vol->posix_paths = 1;
1232 /* default to using server inode numbers where available */
1233 vol->server_ino = 1;
1235 /* default is to use strict cifs caching semantics */
1236 vol->strict_io = true;
1238 vol->actimeo = CIFS_DEF_ACTIMEO;
1240 /* FIXME: add autonegotiation -- for now, SMB1 is default */
1241 vol->ops = &smb1_operations;
1242 vol->vals = &smb1_values;
1245 goto cifs_parse_mount_err;
1247 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1248 if (!mountdata_copy)
1249 goto cifs_parse_mount_err;
1251 options = mountdata_copy;
1252 end = options + strlen(options);
1254 if (strncmp(options, "sep=", 4) == 0) {
1255 if (options[4] != 0) {
1256 separator[0] = options[4];
1259 cFYI(1, "Null separator not allowed");
1262 vol->backupuid_specified = false; /* no backup intent for a user */
1263 vol->backupgid_specified = false; /* no backup intent for a group */
1266 * For now, we ignore -EINVAL errors under the assumption that the
1267 * unc= and prefixpath= options will be usable.
1269 if (cifs_parse_devname(devname, vol) == -ENOMEM) {
1270 printk(KERN_ERR "CIFS: Unable to allocate memory to parse "
1271 "device string.\n");
1275 while ((data = strsep(&options, separator)) != NULL) {
1276 substring_t args[MAX_OPT_ARGS];
1277 unsigned long option;
1283 token = match_token(data, cifs_mount_option_tokens, args);
1287 /* Ingnore the following */
1291 /* Boolean values */
1292 case Opt_user_xattr:
1295 case Opt_nouser_xattr:
1301 case Opt_noforceuid:
1307 case Opt_noforcegid:
1310 case Opt_noblocksend:
1311 vol->noblocksnd = 1;
1313 case Opt_noautotune:
1314 vol->noautotune = 1;
1331 case Opt_nomapchars:
1343 case Opt_posixpaths:
1344 vol->posix_paths = 1;
1346 case Opt_noposixpaths:
1347 vol->posix_paths = 0;
1350 vol->no_linux_ext = 1;
1361 * turn off mandatory locking in mode
1362 * if remote locking is turned off since the
1363 * local vfs will do advisory
1365 if (vol->file_mode ==
1366 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1367 vol->file_mode = S_IALLUGO;
1369 case Opt_forcemandatorylock:
1379 vol->dynperm = true;
1382 vol->dynperm = false;
1396 case Opt_nostrictsync:
1397 vol->nostrictsync = 1;
1399 case Opt_strictsync:
1400 vol->nostrictsync = 0;
1403 vol->server_ino = 1;
1405 case Opt_noserverino:
1406 vol->server_ino = 0;
1408 case Opt_rwpidforward:
1409 vol->rwpidforward = 1;
1418 vol->no_psx_acl = 0;
1421 vol->no_psx_acl = 1;
1423 case Opt_locallease:
1424 vol->local_lease = 1;
1427 vol->secFlg |= CIFSSEC_MUST_SIGN;
1430 /* we do not do the following in secFlags because seal
1431 * is a per tree connection (mount) not a per socket
1432 * or per-smb connection option in the protocol
1433 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1438 printk(KERN_WARNING "CIFS: Mount option noac not "
1439 "supported. Instead set "
1440 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1443 #ifndef CONFIG_CIFS_FSCACHE
1444 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE "
1445 "kernel config option set");
1446 goto cifs_parse_mount_err;
1450 case Opt_mfsymlinks:
1451 vol->mfsymlinks = true;
1454 vol->multiuser = true;
1460 /* Numeric Values */
1462 if (get_option_uid(args, &vol->backupuid)) {
1463 cERROR(1, "%s: Invalid backupuid value",
1465 goto cifs_parse_mount_err;
1467 vol->backupuid_specified = true;
1470 if (get_option_gid(args, &vol->backupgid)) {
1471 cERROR(1, "%s: Invalid backupgid value",
1473 goto cifs_parse_mount_err;
1475 vol->backupgid_specified = true;
1478 if (get_option_uid(args, &vol->linux_uid)) {
1479 cERROR(1, "%s: Invalid uid value",
1481 goto cifs_parse_mount_err;
1483 uid_specified = true;
1486 if (get_option_uid(args, &vol->cred_uid)) {
1487 cERROR(1, "%s: Invalid cruid value",
1489 goto cifs_parse_mount_err;
1493 if (get_option_gid(args, &vol->linux_gid)) {
1494 cERROR(1, "%s: Invalid gid value",
1496 goto cifs_parse_mount_err;
1498 gid_specified = true;
1501 if (get_option_ul(args, &option)) {
1502 cERROR(1, "%s: Invalid file_mode value",
1504 goto cifs_parse_mount_err;
1506 vol->file_mode = option;
1509 if (get_option_ul(args, &option)) {
1510 cERROR(1, "%s: Invalid dir_mode value",
1512 goto cifs_parse_mount_err;
1514 vol->dir_mode = option;
1517 if (get_option_ul(args, &option) ||
1518 option > USHRT_MAX) {
1519 cERROR(1, "%s: Invalid port value", __func__);
1520 goto cifs_parse_mount_err;
1522 port = (unsigned short)option;
1525 if (get_option_ul(args, &option)) {
1526 cERROR(1, "%s: Invalid rsize value",
1528 goto cifs_parse_mount_err;
1530 vol->rsize = option;
1533 if (get_option_ul(args, &option)) {
1534 cERROR(1, "%s: Invalid wsize value",
1536 goto cifs_parse_mount_err;
1538 vol->wsize = option;
1541 if (get_option_ul(args, &option)) {
1542 cERROR(1, "%s: Invalid actimeo value",
1544 goto cifs_parse_mount_err;
1546 vol->actimeo = HZ * option;
1547 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1548 cERROR(1, "CIFS: attribute cache"
1549 "timeout too large");
1550 goto cifs_parse_mount_err;
1554 /* String Arguments */
1556 case Opt_blank_user:
1557 /* null user, ie. anonymous authentication */
1559 vol->username = NULL;
1562 string = match_strdup(args);
1566 if (strnlen(string, MAX_USERNAME_SIZE) >
1567 MAX_USERNAME_SIZE) {
1568 printk(KERN_WARNING "CIFS: username too long\n");
1569 goto cifs_parse_mount_err;
1571 vol->username = kstrdup(string, GFP_KERNEL);
1572 if (!vol->username) {
1573 printk(KERN_WARNING "CIFS: no memory "
1575 goto cifs_parse_mount_err;
1578 case Opt_blank_pass:
1579 vol->password = NULL;
1582 /* passwords have to be handled differently
1583 * to allow the character used for deliminator
1584 * to be passed within them
1587 /* Obtain the value string */
1588 value = strchr(data, '=');
1591 /* Set tmp_end to end of the string */
1592 tmp_end = (char *) value + strlen(value);
1594 /* Check if following character is the deliminator
1595 * If yes, we have encountered a double deliminator
1596 * reset the NULL character to the deliminator
1598 if (tmp_end < end && tmp_end[1] == delim) {
1601 /* Keep iterating until we get to a single
1602 * deliminator OR the end
1604 while ((tmp_end = strchr(tmp_end, delim))
1605 != NULL && (tmp_end[1] == delim)) {
1606 tmp_end = (char *) &tmp_end[2];
1609 /* Reset var options to point to next element */
1612 options = (char *) &tmp_end[1];
1614 /* Reached the end of the mount option
1619 /* Now build new password string */
1620 temp_len = strlen(value);
1621 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1622 if (vol->password == NULL) {
1623 printk(KERN_WARNING "CIFS: no memory "
1625 goto cifs_parse_mount_err;
1628 for (i = 0, j = 0; i < temp_len; i++, j++) {
1629 vol->password[j] = value[i];
1630 if ((value[i] == delim) &&
1631 value[i+1] == delim)
1632 /* skip the second deliminator */
1635 vol->password[j] = '\0';
1638 /* FIXME: should this be an error instead? */
1642 string = match_strdup(args);
1646 if (!cifs_convert_address(dstaddr, string,
1648 printk(KERN_ERR "CIFS: bad ip= option (%s).\n",
1650 goto cifs_parse_mount_err;
1656 vol->UNC = match_strdup(args);
1657 if (vol->UNC == NULL)
1660 convert_delimiter(vol->UNC, '\\');
1661 if (vol->UNC[0] != '\\' || vol->UNC[1] != '\\') {
1662 printk(KERN_ERR "CIFS: UNC Path does not "
1663 "begin with // or \\\\\n");
1664 goto cifs_parse_mount_err;
1667 /* Compare old unc= option to new one */
1668 if (!string || strcmp(string, vol->UNC))
1669 printk(KERN_WARNING "CIFS: the value of the "
1670 "unc= mount option does not match the "
1671 "device string. Using the unc= option "
1672 "for now. In 3.10, that option will "
1673 "be ignored and the contents of the "
1674 "device string will be used "
1675 "instead. (%s != %s)\n", string,
1679 string = match_strdup(args);
1683 if (strnlen(string, 256) == 256) {
1684 printk(KERN_WARNING "CIFS: domain name too"
1686 goto cifs_parse_mount_err;
1689 vol->domainname = kstrdup(string, GFP_KERNEL);
1690 if (!vol->domainname) {
1691 printk(KERN_WARNING "CIFS: no memory "
1692 "for domainname\n");
1693 goto cifs_parse_mount_err;
1695 cFYI(1, "Domain name set");
1698 string = match_strdup(args);
1702 if (!cifs_convert_address(
1703 (struct sockaddr *)&vol->srcaddr,
1704 string, strlen(string))) {
1705 printk(KERN_WARNING "CIFS: Could not parse"
1706 " srcaddr: %s\n", string);
1707 goto cifs_parse_mount_err;
1710 case Opt_prefixpath:
1711 /* skip over any leading delimiter */
1712 if (*args[0].from == '/' || *args[0].from == '\\')
1715 string = vol->prepath;
1716 vol->prepath = match_strdup(args);
1717 if (vol->prepath == NULL)
1719 /* Compare old prefixpath= option to new one */
1720 if (!string || strcmp(string, vol->prepath))
1721 printk(KERN_WARNING "CIFS: the value of the "
1722 "prefixpath= mount option does not "
1723 "match the device string. Using the "
1724 "prefixpath= option for now. In 3.10, "
1725 "that option will be ignored and the "
1726 "contents of the device string will be "
1727 "used instead.(%s != %s)\n", string,
1731 string = match_strdup(args);
1735 if (strnlen(string, 1024) >= 65) {
1736 printk(KERN_WARNING "CIFS: iocharset name "
1738 goto cifs_parse_mount_err;
1741 if (strnicmp(string, "default", 7) != 0) {
1742 vol->iocharset = kstrdup(string,
1744 if (!vol->iocharset) {
1745 printk(KERN_WARNING "CIFS: no memory"
1747 goto cifs_parse_mount_err;
1750 /* if iocharset not set then load_nls_default
1753 cFYI(1, "iocharset set to %s", string);
1756 string = match_strdup(args);
1760 if (strnicmp(string, "TCP_NODELAY", 11) == 0) {
1761 printk(KERN_WARNING "CIFS: the "
1762 "sockopt=TCP_NODELAY option has been "
1763 "deprecated and will be removed "
1765 vol->sockopt_tcp_nodelay = 1;
1768 case Opt_netbiosname:
1769 string = match_strdup(args);
1773 memset(vol->source_rfc1001_name, 0x20,
1776 * FIXME: are there cases in which a comma can
1777 * be valid in workstation netbios name (and
1778 * need special handling)?
1780 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1781 /* don't ucase netbiosname for user */
1784 vol->source_rfc1001_name[i] = string[i];
1786 /* The string has 16th byte zero still from
1787 * set at top of the function
1789 if (i == RFC1001_NAME_LEN && string[i] != 0)
1790 printk(KERN_WARNING "CIFS: netbiosname"
1791 " longer than 15 truncated.\n");
1795 /* servernetbiosname specified override *SMBSERVER */
1796 string = match_strdup(args);
1800 /* last byte, type, is 0x20 for servr type */
1801 memset(vol->target_rfc1001_name, 0x20,
1802 RFC1001_NAME_LEN_WITH_NULL);
1804 /* BB are there cases in which a comma can be
1805 valid in this workstation netbios name
1806 (and need special handling)? */
1808 /* user or mount helper must uppercase the
1810 for (i = 0; i < 15; i++) {
1813 vol->target_rfc1001_name[i] = string[i];
1815 /* The string has 16th byte zero still from
1816 set at top of the function */
1817 if (i == RFC1001_NAME_LEN && string[i] != 0)
1818 printk(KERN_WARNING "CIFS: server net"
1819 "biosname longer than 15 truncated.\n");
1822 string = match_strdup(args);
1826 if (strnicmp(string, "1", 1) == 0) {
1827 /* This is the default */
1830 /* For all other value, error */
1831 printk(KERN_WARNING "CIFS: Invalid version"
1833 goto cifs_parse_mount_err;
1835 string = match_strdup(args);
1839 if (cifs_parse_smb_version(string, vol) != 0)
1840 goto cifs_parse_mount_err;
1843 string = match_strdup(args);
1847 if (cifs_parse_security_flavors(string, vol) != 0)
1848 goto cifs_parse_mount_err;
1851 string = match_strdup(args);
1855 if (cifs_parse_cache_flavor(string, vol) != 0)
1856 goto cifs_parse_mount_err;
1860 * An option we don't recognize. Save it off for later
1861 * if we haven't already found one
1867 /* Free up any allocated string */
1872 if (!sloppy && invalid) {
1873 printk(KERN_ERR "CIFS: Unknown mount option \"%s\"\n", invalid);
1874 goto cifs_parse_mount_err;
1878 /* Muliuser mounts require CONFIG_KEYS support */
1879 if (vol->multiuser) {
1880 cERROR(1, "Multiuser mounts require kernels with "
1881 "CONFIG_KEYS enabled.");
1882 goto cifs_parse_mount_err;
1886 cERROR(1, "CIFS mount error: No usable UNC path provided in "
1887 "device string or in unc= option!");
1888 goto cifs_parse_mount_err;
1891 /* make sure UNC has a share name */
1892 if (!strchr(vol->UNC + 3, '\\')) {
1893 cERROR(1, "Malformed UNC. Unable to find share name.");
1894 goto cifs_parse_mount_err;
1898 /* No ip= option specified? Try to get it from UNC */
1899 if (!cifs_convert_address(dstaddr, &vol->UNC[2],
1900 strlen(&vol->UNC[2]))) {
1901 printk(KERN_ERR "Unable to determine destination "
1903 goto cifs_parse_mount_err;
1907 /* set the port that we got earlier */
1908 cifs_set_port(dstaddr, port);
1911 vol->override_uid = override_uid;
1912 else if (override_uid == 1)
1913 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1914 "specified with no uid= option.\n");
1917 vol->override_gid = override_gid;
1918 else if (override_gid == 1)
1919 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1920 "specified with no gid= option.\n");
1922 kfree(mountdata_copy);
1926 printk(KERN_WARNING "Could not allocate temporary buffer\n");
1927 cifs_parse_mount_err:
1929 kfree(mountdata_copy);
1933 /** Returns true if srcaddr isn't specified and rhs isn't
1934 * specified, or if srcaddr is specified and
1935 * matches the IP address of the rhs argument.
1938 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1940 switch (srcaddr->sa_family) {
1942 return (rhs->sa_family == AF_UNSPEC);
1944 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1945 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1946 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1949 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1950 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
1951 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1955 return false; /* don't expect to be here */
1960 * If no port is specified in addr structure, we try to match with 445 port
1961 * and if it fails - with 139 ports. It should be called only if address
1962 * families of server and addr are equal.
1965 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1967 __be16 port, *sport;
1969 switch (addr->sa_family) {
1971 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1972 port = ((struct sockaddr_in *) addr)->sin_port;
1975 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1976 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1984 port = htons(CIFS_PORT);
1988 port = htons(RFC1001_PORT);
1991 return port == *sport;
1995 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1996 struct sockaddr *srcaddr)
1998 switch (addr->sa_family) {
2000 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2001 struct sockaddr_in *srv_addr4 =
2002 (struct sockaddr_in *)&server->dstaddr;
2004 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
2009 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2010 struct sockaddr_in6 *srv_addr6 =
2011 (struct sockaddr_in6 *)&server->dstaddr;
2013 if (!ipv6_addr_equal(&addr6->sin6_addr,
2014 &srv_addr6->sin6_addr))
2016 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
2022 return false; /* don't expect to be here */
2025 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2032 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2034 unsigned int secFlags;
2036 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
2037 secFlags = vol->secFlg;
2039 secFlags = global_secflags | vol->secFlg;
2041 switch (server->secType) {
2043 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
2047 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
2051 if (!(secFlags & CIFSSEC_MAY_NTLM))
2055 if (!(secFlags & CIFSSEC_MAY_KRB5))
2059 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
2063 /* shouldn't happen */
2067 /* now check if signing mode is acceptable */
2068 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
2069 (server->sec_mode & SECMODE_SIGN_REQUIRED))
2071 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
2073 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
2079 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2081 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2083 if ((server->vals != vol->vals) || (server->ops != vol->ops))
2086 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2089 if (!match_address(server, addr,
2090 (struct sockaddr *)&vol->srcaddr))
2093 if (!match_port(server, addr))
2096 if (!match_security(server, vol))
2102 static struct TCP_Server_Info *
2103 cifs_find_tcp_session(struct smb_vol *vol)
2105 struct TCP_Server_Info *server;
2107 spin_lock(&cifs_tcp_ses_lock);
2108 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2109 if (!match_server(server, vol))
2112 ++server->srv_count;
2113 spin_unlock(&cifs_tcp_ses_lock);
2114 cFYI(1, "Existing tcp session with server found");
2117 spin_unlock(&cifs_tcp_ses_lock);
2122 cifs_put_tcp_session(struct TCP_Server_Info *server)
2124 struct task_struct *task;
2126 spin_lock(&cifs_tcp_ses_lock);
2127 if (--server->srv_count > 0) {
2128 spin_unlock(&cifs_tcp_ses_lock);
2132 put_net(cifs_net_ns(server));
2134 list_del_init(&server->tcp_ses_list);
2135 spin_unlock(&cifs_tcp_ses_lock);
2137 cancel_delayed_work_sync(&server->echo);
2139 spin_lock(&GlobalMid_Lock);
2140 server->tcpStatus = CifsExiting;
2141 spin_unlock(&GlobalMid_Lock);
2143 cifs_crypto_shash_release(server);
2144 cifs_fscache_release_client_cookie(server);
2146 kfree(server->session_key.response);
2147 server->session_key.response = NULL;
2148 server->session_key.len = 0;
2150 task = xchg(&server->tsk, NULL);
2152 force_sig(SIGKILL, task);
2155 static struct TCP_Server_Info *
2156 cifs_get_tcp_session(struct smb_vol *volume_info)
2158 struct TCP_Server_Info *tcp_ses = NULL;
2161 cFYI(1, "UNC: %s", volume_info->UNC);
2163 /* see if we already have a matching tcp_ses */
2164 tcp_ses = cifs_find_tcp_session(volume_info);
2168 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2174 rc = cifs_crypto_shash_allocate(tcp_ses);
2176 cERROR(1, "could not setup hash structures rc %d", rc);
2180 tcp_ses->ops = volume_info->ops;
2181 tcp_ses->vals = volume_info->vals;
2182 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2183 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2184 if (IS_ERR(tcp_ses->hostname)) {
2185 rc = PTR_ERR(tcp_ses->hostname);
2186 goto out_err_crypto_release;
2189 tcp_ses->noblocksnd = volume_info->noblocksnd;
2190 tcp_ses->noautotune = volume_info->noautotune;
2191 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2192 tcp_ses->in_flight = 0;
2193 tcp_ses->credits = 1;
2194 init_waitqueue_head(&tcp_ses->response_q);
2195 init_waitqueue_head(&tcp_ses->request_q);
2196 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2197 mutex_init(&tcp_ses->srv_mutex);
2198 memcpy(tcp_ses->workstation_RFC1001_name,
2199 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2200 memcpy(tcp_ses->server_RFC1001_name,
2201 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2202 tcp_ses->session_estab = false;
2203 tcp_ses->sequence_number = 0;
2204 tcp_ses->lstrp = jiffies;
2205 spin_lock_init(&tcp_ses->req_lock);
2206 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2207 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2208 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2209 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2210 sizeof(tcp_ses->srcaddr));
2211 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2212 sizeof(tcp_ses->dstaddr));
2214 * at this point we are the only ones with the pointer
2215 * to the struct since the kernel thread not created yet
2216 * no need to spinlock this init of tcpStatus or srv_count
2218 tcp_ses->tcpStatus = CifsNew;
2219 ++tcp_ses->srv_count;
2221 rc = ip_connect(tcp_ses);
2223 cERROR(1, "Error connecting to socket. Aborting operation");
2224 goto out_err_crypto_release;
2228 * since we're in a cifs function already, we know that
2229 * this will succeed. No need for try_module_get().
2231 __module_get(THIS_MODULE);
2232 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2234 if (IS_ERR(tcp_ses->tsk)) {
2235 rc = PTR_ERR(tcp_ses->tsk);
2236 cERROR(1, "error %d create cifsd thread", rc);
2237 module_put(THIS_MODULE);
2238 goto out_err_crypto_release;
2240 tcp_ses->tcpStatus = CifsNeedNegotiate;
2242 /* thread spawned, put it on the list */
2243 spin_lock(&cifs_tcp_ses_lock);
2244 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2245 spin_unlock(&cifs_tcp_ses_lock);
2247 cifs_fscache_get_client_cookie(tcp_ses);
2249 /* queue echo request delayed work */
2250 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
2254 out_err_crypto_release:
2255 cifs_crypto_shash_release(tcp_ses);
2257 put_net(cifs_net_ns(tcp_ses));
2261 if (!IS_ERR(tcp_ses->hostname))
2262 kfree(tcp_ses->hostname);
2263 if (tcp_ses->ssocket)
2264 sock_release(tcp_ses->ssocket);
2270 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2272 switch (ses->server->secType) {
2274 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2278 /* NULL username means anonymous session */
2279 if (ses->user_name == NULL) {
2285 /* anything else takes username/password */
2286 if (strncmp(ses->user_name,
2287 vol->username ? vol->username : "",
2290 if (strlen(vol->username) != 0 &&
2291 ses->password != NULL &&
2292 strncmp(ses->password,
2293 vol->password ? vol->password : "",
2300 static struct cifs_ses *
2301 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2303 struct cifs_ses *ses;
2305 spin_lock(&cifs_tcp_ses_lock);
2306 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2307 if (!match_session(ses, vol))
2310 spin_unlock(&cifs_tcp_ses_lock);
2313 spin_unlock(&cifs_tcp_ses_lock);
2318 cifs_put_smb_ses(struct cifs_ses *ses)
2321 struct TCP_Server_Info *server = ses->server;
2323 cFYI(1, "%s: ses_count=%d", __func__, ses->ses_count);
2324 spin_lock(&cifs_tcp_ses_lock);
2325 if (--ses->ses_count > 0) {
2326 spin_unlock(&cifs_tcp_ses_lock);
2330 list_del_init(&ses->smb_ses_list);
2331 spin_unlock(&cifs_tcp_ses_lock);
2333 if (ses->status == CifsGood && server->ops->logoff) {
2335 server->ops->logoff(xid, ses);
2339 cifs_put_tcp_session(server);
2344 /* strlen("cifs:a:") + INET6_ADDRSTRLEN + 1 */
2345 #define CIFSCREDS_DESC_SIZE (7 + INET6_ADDRSTRLEN + 1)
2347 /* Populate username and pw fields from keyring if possible */
2349 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2352 char *desc, *delim, *payload;
2355 struct TCP_Server_Info *server = ses->server;
2356 struct sockaddr_in *sa;
2357 struct sockaddr_in6 *sa6;
2358 struct user_key_payload *upayload;
2360 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2364 /* try to find an address key first */
2365 switch (server->dstaddr.ss_family) {
2367 sa = (struct sockaddr_in *)&server->dstaddr;
2368 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2371 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2372 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2375 cFYI(1, "Bad ss_family (%hu)", server->dstaddr.ss_family);
2380 cFYI(1, "%s: desc=%s", __func__, desc);
2381 key = request_key(&key_type_logon, desc, "");
2383 if (!ses->domainName) {
2384 cFYI(1, "domainName is NULL");
2389 /* didn't work, try to find a domain key */
2390 sprintf(desc, "cifs:d:%s", ses->domainName);
2391 cFYI(1, "%s: desc=%s", __func__, desc);
2392 key = request_key(&key_type_logon, desc, "");
2399 down_read(&key->sem);
2400 upayload = key->payload.data;
2401 if (IS_ERR_OR_NULL(upayload)) {
2402 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2406 /* find first : in payload */
2407 payload = (char *)upayload->data;
2408 delim = strnchr(payload, upayload->datalen, ':');
2409 cFYI(1, "payload=%s", payload);
2411 cFYI(1, "Unable to find ':' in payload (datalen=%d)",
2417 len = delim - payload;
2418 if (len > MAX_USERNAME_SIZE || len <= 0) {
2419 cFYI(1, "Bad value from username search (len=%zd)", len);
2424 vol->username = kstrndup(payload, len, GFP_KERNEL);
2425 if (!vol->username) {
2426 cFYI(1, "Unable to allocate %zd bytes for username", len);
2430 cFYI(1, "%s: username=%s", __func__, vol->username);
2432 len = key->datalen - (len + 1);
2433 if (len > MAX_PASSWORD_SIZE || len <= 0) {
2434 cFYI(1, "Bad len for password search (len=%zd)", len);
2436 kfree(vol->username);
2437 vol->username = NULL;
2442 vol->password = kstrndup(delim, len, GFP_KERNEL);
2443 if (!vol->password) {
2444 cFYI(1, "Unable to allocate %zd bytes for password", len);
2446 kfree(vol->username);
2447 vol->username = NULL;
2456 cFYI(1, "%s: returning %d", __func__, rc);
2459 #else /* ! CONFIG_KEYS */
2461 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2462 struct cifs_ses *ses __attribute__((unused)))
2466 #endif /* CONFIG_KEYS */
2468 static struct cifs_ses *
2469 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2473 struct cifs_ses *ses;
2474 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2475 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2479 ses = cifs_find_smb_ses(server, volume_info);
2481 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
2483 mutex_lock(&ses->session_mutex);
2484 rc = cifs_negotiate_protocol(xid, ses);
2486 mutex_unlock(&ses->session_mutex);
2487 /* problem -- put our ses reference */
2488 cifs_put_smb_ses(ses);
2492 if (ses->need_reconnect) {
2493 cFYI(1, "Session needs reconnect");
2494 rc = cifs_setup_session(xid, ses,
2495 volume_info->local_nls);
2497 mutex_unlock(&ses->session_mutex);
2498 /* problem -- put our reference */
2499 cifs_put_smb_ses(ses);
2504 mutex_unlock(&ses->session_mutex);
2506 /* existing SMB ses has a server reference already */
2507 cifs_put_tcp_session(server);
2512 cFYI(1, "Existing smb sess not found");
2513 ses = sesInfoAlloc();
2517 /* new SMB session uses our server ref */
2518 ses->server = server;
2519 if (server->dstaddr.ss_family == AF_INET6)
2520 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2522 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2524 if (volume_info->username) {
2525 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2526 if (!ses->user_name)
2530 /* volume_info->password freed at unmount */
2531 if (volume_info->password) {
2532 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2536 if (volume_info->domainname) {
2537 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2538 if (!ses->domainName)
2541 ses->cred_uid = volume_info->cred_uid;
2542 ses->linux_uid = volume_info->linux_uid;
2544 ses->overrideSecFlg = volume_info->secFlg;
2546 mutex_lock(&ses->session_mutex);
2547 rc = cifs_negotiate_protocol(xid, ses);
2549 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2550 mutex_unlock(&ses->session_mutex);
2554 /* success, put it on the list */
2555 spin_lock(&cifs_tcp_ses_lock);
2556 list_add(&ses->smb_ses_list, &server->smb_ses_list);
2557 spin_unlock(&cifs_tcp_ses_lock);
2568 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2570 if (tcon->tidStatus == CifsExiting)
2572 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2577 static struct cifs_tcon *
2578 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2580 struct list_head *tmp;
2581 struct cifs_tcon *tcon;
2583 spin_lock(&cifs_tcp_ses_lock);
2584 list_for_each(tmp, &ses->tcon_list) {
2585 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2586 if (!match_tcon(tcon, unc))
2589 spin_unlock(&cifs_tcp_ses_lock);
2592 spin_unlock(&cifs_tcp_ses_lock);
2597 cifs_put_tcon(struct cifs_tcon *tcon)
2600 struct cifs_ses *ses = tcon->ses;
2602 cFYI(1, "%s: tc_count=%d", __func__, tcon->tc_count);
2603 spin_lock(&cifs_tcp_ses_lock);
2604 if (--tcon->tc_count > 0) {
2605 spin_unlock(&cifs_tcp_ses_lock);
2609 list_del_init(&tcon->tcon_list);
2610 spin_unlock(&cifs_tcp_ses_lock);
2613 if (ses->server->ops->tree_disconnect)
2614 ses->server->ops->tree_disconnect(xid, tcon);
2617 cifs_fscache_release_super_cookie(tcon);
2619 cifs_put_smb_ses(ses);
2622 static struct cifs_tcon *
2623 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2626 struct cifs_tcon *tcon;
2628 tcon = cifs_find_tcon(ses, volume_info->UNC);
2630 cFYI(1, "Found match on UNC path");
2631 /* existing tcon already has a reference */
2632 cifs_put_smb_ses(ses);
2633 if (tcon->seal != volume_info->seal)
2634 cERROR(1, "transport encryption setting "
2635 "conflicts with existing tid");
2639 if (!ses->server->ops->tree_connect) {
2644 tcon = tconInfoAlloc();
2651 if (volume_info->password) {
2652 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2653 if (!tcon->password) {
2660 * BB Do we need to wrap session_mutex around this TCon call and Unix
2661 * SetFS as we do on SessSetup and reconnect?
2664 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2665 volume_info->local_nls);
2667 cFYI(1, "Tcon rc = %d", rc);
2671 if (volume_info->nodfs) {
2672 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2673 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2675 tcon->seal = volume_info->seal;
2677 * We can have only one retry value for a connection to a share so for
2678 * resources mounted more than once to the same server share the last
2679 * value passed in for the retry flag is used.
2681 tcon->retry = volume_info->retry;
2682 tcon->nocase = volume_info->nocase;
2683 tcon->local_lease = volume_info->local_lease;
2684 INIT_LIST_HEAD(&tcon->pending_opens);
2686 spin_lock(&cifs_tcp_ses_lock);
2687 list_add(&tcon->tcon_list, &ses->tcon_list);
2688 spin_unlock(&cifs_tcp_ses_lock);
2690 cifs_fscache_get_super_cookie(tcon);
2700 cifs_put_tlink(struct tcon_link *tlink)
2702 if (!tlink || IS_ERR(tlink))
2705 if (!atomic_dec_and_test(&tlink->tl_count) ||
2706 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2707 tlink->tl_time = jiffies;
2711 if (!IS_ERR(tlink_tcon(tlink)))
2712 cifs_put_tcon(tlink_tcon(tlink));
2717 static inline struct tcon_link *
2718 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2720 return cifs_sb->master_tlink;
2724 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2726 struct cifs_sb_info *old = CIFS_SB(sb);
2727 struct cifs_sb_info *new = mnt_data->cifs_sb;
2729 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2732 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2733 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2737 * We want to share sb only if we don't specify an r/wsize or
2738 * specified r/wsize is greater than or equal to existing one.
2740 if (new->wsize && new->wsize < old->wsize)
2743 if (new->rsize && new->rsize < old->rsize)
2746 if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
2749 if (old->mnt_file_mode != new->mnt_file_mode ||
2750 old->mnt_dir_mode != new->mnt_dir_mode)
2753 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2756 if (old->actimeo != new->actimeo)
2763 cifs_match_super(struct super_block *sb, void *data)
2765 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2766 struct smb_vol *volume_info;
2767 struct cifs_sb_info *cifs_sb;
2768 struct TCP_Server_Info *tcp_srv;
2769 struct cifs_ses *ses;
2770 struct cifs_tcon *tcon;
2771 struct tcon_link *tlink;
2774 spin_lock(&cifs_tcp_ses_lock);
2775 cifs_sb = CIFS_SB(sb);
2776 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2777 if (IS_ERR(tlink)) {
2778 spin_unlock(&cifs_tcp_ses_lock);
2781 tcon = tlink_tcon(tlink);
2783 tcp_srv = ses->server;
2785 volume_info = mnt_data->vol;
2787 if (!match_server(tcp_srv, volume_info) ||
2788 !match_session(ses, volume_info) ||
2789 !match_tcon(tcon, volume_info->UNC)) {
2794 rc = compare_mount_options(sb, mnt_data);
2796 spin_unlock(&cifs_tcp_ses_lock);
2797 cifs_put_tlink(tlink);
2802 get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
2803 const struct nls_table *nls_codepage, unsigned int *num_referrals,
2804 struct dfs_info3_param **referrals, int remap)
2809 if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
2815 if (ses->ipc_tid == 0) {
2816 temp_unc = kmalloc(2 /* for slashes */ +
2817 strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2818 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
2819 if (temp_unc == NULL)
2823 strcpy(temp_unc + 2, ses->serverName);
2824 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2825 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2827 cFYI(1, "Tcon rc = %d ipc_tid = %d", rc, ses->ipc_tid);
2831 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
2832 referrals, num_referrals,
2833 nls_codepage, remap);
2835 * BB - map targetUNCs to dfs_info3 structures, here or in
2836 * ses->server->ops->get_dfs_refer.
2842 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2843 static struct lock_class_key cifs_key[2];
2844 static struct lock_class_key cifs_slock_key[2];
2847 cifs_reclassify_socket4(struct socket *sock)
2849 struct sock *sk = sock->sk;
2850 BUG_ON(sock_owned_by_user(sk));
2851 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2852 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2856 cifs_reclassify_socket6(struct socket *sock)
2858 struct sock *sk = sock->sk;
2859 BUG_ON(sock_owned_by_user(sk));
2860 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2861 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2865 cifs_reclassify_socket4(struct socket *sock)
2870 cifs_reclassify_socket6(struct socket *sock)
2875 /* See RFC1001 section 14 on representation of Netbios names */
2876 static void rfc1002mangle(char *target, char *source, unsigned int length)
2880 for (i = 0, j = 0; i < (length); i++) {
2881 /* mask a nibble at a time and encode */
2882 target[j] = 'A' + (0x0F & (source[i] >> 4));
2883 target[j+1] = 'A' + (0x0F & source[i]);
2890 bind_socket(struct TCP_Server_Info *server)
2893 if (server->srcaddr.ss_family != AF_UNSPEC) {
2894 /* Bind to the specified local IP address */
2895 struct socket *socket = server->ssocket;
2896 rc = socket->ops->bind(socket,
2897 (struct sockaddr *) &server->srcaddr,
2898 sizeof(server->srcaddr));
2900 struct sockaddr_in *saddr4;
2901 struct sockaddr_in6 *saddr6;
2902 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2903 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2904 if (saddr6->sin6_family == AF_INET6)
2906 "Failed to bind to: %pI6c, error: %d",
2907 &saddr6->sin6_addr, rc);
2910 "Failed to bind to: %pI4, error: %d",
2911 &saddr4->sin_addr.s_addr, rc);
2918 ip_rfc1001_connect(struct TCP_Server_Info *server)
2922 * some servers require RFC1001 sessinit before sending
2923 * negprot - BB check reconnection in case where second
2924 * sessinit is sent but no second negprot
2926 struct rfc1002_session_packet *ses_init_buf;
2927 struct smb_hdr *smb_buf;
2928 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2931 ses_init_buf->trailer.session_req.called_len = 32;
2933 if (server->server_RFC1001_name &&
2934 server->server_RFC1001_name[0] != 0)
2935 rfc1002mangle(ses_init_buf->trailer.
2936 session_req.called_name,
2937 server->server_RFC1001_name,
2938 RFC1001_NAME_LEN_WITH_NULL);
2940 rfc1002mangle(ses_init_buf->trailer.
2941 session_req.called_name,
2942 DEFAULT_CIFS_CALLED_NAME,
2943 RFC1001_NAME_LEN_WITH_NULL);
2945 ses_init_buf->trailer.session_req.calling_len = 32;
2948 * calling name ends in null (byte 16) from old smb
2951 if (server->workstation_RFC1001_name &&
2952 server->workstation_RFC1001_name[0] != 0)
2953 rfc1002mangle(ses_init_buf->trailer.
2954 session_req.calling_name,
2955 server->workstation_RFC1001_name,
2956 RFC1001_NAME_LEN_WITH_NULL);
2958 rfc1002mangle(ses_init_buf->trailer.
2959 session_req.calling_name,
2961 RFC1001_NAME_LEN_WITH_NULL);
2963 ses_init_buf->trailer.session_req.scope1 = 0;
2964 ses_init_buf->trailer.session_req.scope2 = 0;
2965 smb_buf = (struct smb_hdr *)ses_init_buf;
2967 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2968 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
2969 rc = smb_send(server, smb_buf, 0x44);
2970 kfree(ses_init_buf);
2972 * RFC1001 layer in at least one server
2973 * requires very short break before negprot
2974 * presumably because not expecting negprot
2975 * to follow so fast. This is a simple
2976 * solution that works without
2977 * complicating the code and causes no
2978 * significant slowing down on mount
2981 usleep_range(1000, 2000);
2984 * else the negprot may still work without this
2985 * even though malloc failed
2992 generic_ip_connect(struct TCP_Server_Info *server)
2997 struct socket *socket = server->ssocket;
2998 struct sockaddr *saddr;
3000 saddr = (struct sockaddr *) &server->dstaddr;
3002 if (server->dstaddr.ss_family == AF_INET6) {
3003 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3004 slen = sizeof(struct sockaddr_in6);
3007 sport = ((struct sockaddr_in *) saddr)->sin_port;
3008 slen = sizeof(struct sockaddr_in);
3012 if (socket == NULL) {
3013 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3014 IPPROTO_TCP, &socket, 1);
3016 cERROR(1, "Error %d creating socket", rc);
3017 server->ssocket = NULL;
3021 /* BB other socket options to set KEEPALIVE, NODELAY? */
3022 cFYI(1, "Socket created");
3023 server->ssocket = socket;
3024 socket->sk->sk_allocation = GFP_NOFS;
3025 if (sfamily == AF_INET6)
3026 cifs_reclassify_socket6(socket);
3028 cifs_reclassify_socket4(socket);
3031 rc = bind_socket(server);
3036 * Eventually check for other socket options to change from
3037 * the default. sock_setsockopt not used because it expects
3040 socket->sk->sk_rcvtimeo = 7 * HZ;
3041 socket->sk->sk_sndtimeo = 5 * HZ;
3043 /* make the bufsizes depend on wsize/rsize and max requests */
3044 if (server->noautotune) {
3045 if (socket->sk->sk_sndbuf < (200 * 1024))
3046 socket->sk->sk_sndbuf = 200 * 1024;
3047 if (socket->sk->sk_rcvbuf < (140 * 1024))
3048 socket->sk->sk_rcvbuf = 140 * 1024;
3051 if (server->tcp_nodelay) {
3053 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3054 (char *)&val, sizeof(val));
3056 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
3059 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
3060 socket->sk->sk_sndbuf,
3061 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3063 rc = socket->ops->connect(socket, saddr, slen, 0);
3065 cFYI(1, "Error %d connecting to server", rc);
3066 sock_release(socket);
3067 server->ssocket = NULL;
3071 if (sport == htons(RFC1001_PORT))
3072 rc = ip_rfc1001_connect(server);
3078 ip_connect(struct TCP_Server_Info *server)
3081 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3082 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3084 if (server->dstaddr.ss_family == AF_INET6)
3085 sport = &addr6->sin6_port;
3087 sport = &addr->sin_port;
3092 /* try with 445 port at first */
3093 *sport = htons(CIFS_PORT);
3095 rc = generic_ip_connect(server);
3099 /* if it failed, try with 139 port */
3100 *sport = htons(RFC1001_PORT);
3103 return generic_ip_connect(server);
3106 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3107 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3109 /* if we are reconnecting then should we check to see if
3110 * any requested capabilities changed locally e.g. via
3111 * remount but we can not do much about it here
3112 * if they have (even if we could detect it by the following)
3113 * Perhaps we could add a backpointer to array of sb from tcon
3114 * or if we change to make all sb to same share the same
3115 * sb as NFS - then we only have one backpointer to sb.
3116 * What if we wanted to mount the server share twice once with
3117 * and once without posixacls or posix paths? */
3118 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3120 if (vol_info && vol_info->no_linux_ext) {
3121 tcon->fsUnixInfo.Capability = 0;
3122 tcon->unix_ext = 0; /* Unix Extensions disabled */
3123 cFYI(1, "Linux protocol extensions disabled");
3125 } else if (vol_info)
3126 tcon->unix_ext = 1; /* Unix Extensions supported */
3128 if (tcon->unix_ext == 0) {
3129 cFYI(1, "Unix extensions disabled so not set on reconnect");
3133 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3134 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3135 cFYI(1, "unix caps which server supports %lld", cap);
3136 /* check for reconnect case in which we do not
3137 want to change the mount behavior if we can avoid it */
3138 if (vol_info == NULL) {
3139 /* turn off POSIX ACL and PATHNAMES if not set
3140 originally at mount time */
3141 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3142 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3143 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3144 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3145 cERROR(1, "POSIXPATH support change");
3146 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3147 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3148 cERROR(1, "possible reconnect error");
3149 cERROR(1, "server disabled POSIX path support");
3153 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3154 cERROR(1, "per-share encryption not supported yet");
3156 cap &= CIFS_UNIX_CAP_MASK;
3157 if (vol_info && vol_info->no_psx_acl)
3158 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3159 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3160 cFYI(1, "negotiated posix acl support");
3162 cifs_sb->mnt_cifs_flags |=
3163 CIFS_MOUNT_POSIXACL;
3166 if (vol_info && vol_info->posix_paths == 0)
3167 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3168 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3169 cFYI(1, "negotiate posix pathnames");
3171 cifs_sb->mnt_cifs_flags |=
3172 CIFS_MOUNT_POSIX_PATHS;
3175 cFYI(1, "Negotiate caps 0x%x", (int)cap);
3176 #ifdef CONFIG_CIFS_DEBUG2
3177 if (cap & CIFS_UNIX_FCNTL_CAP)
3178 cFYI(1, "FCNTL cap");
3179 if (cap & CIFS_UNIX_EXTATTR_CAP)
3180 cFYI(1, "EXTATTR cap");
3181 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3182 cFYI(1, "POSIX path cap");
3183 if (cap & CIFS_UNIX_XATTR_CAP)
3184 cFYI(1, "XATTR cap");
3185 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3186 cFYI(1, "POSIX ACL cap");
3187 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3188 cFYI(1, "very large read cap");
3189 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3190 cFYI(1, "very large write cap");
3191 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3192 cFYI(1, "transport encryption cap");
3193 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3194 cFYI(1, "mandatory transport encryption cap");
3195 #endif /* CIFS_DEBUG2 */
3196 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3197 if (vol_info == NULL) {
3198 cFYI(1, "resetting capabilities failed");
3200 cERROR(1, "Negotiating Unix capabilities "
3201 "with the server failed. Consider "
3202 "mounting with the Unix Extensions "
3203 "disabled if problems are found "
3204 "by specifying the nounix mount "
3211 void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3212 struct cifs_sb_info *cifs_sb)
3214 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3216 spin_lock_init(&cifs_sb->tlink_tree_lock);
3217 cifs_sb->tlink_tree = RB_ROOT;
3220 * Temporarily set r/wsize for matching superblock. If we end up using
3221 * new sb then client will later negotiate it downward if needed.
3223 cifs_sb->rsize = pvolume_info->rsize;
3224 cifs_sb->wsize = pvolume_info->wsize;
3226 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3227 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3228 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3229 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3230 cFYI(1, "file mode: 0x%hx dir mode: 0x%hx",
3231 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3233 cifs_sb->actimeo = pvolume_info->actimeo;
3234 cifs_sb->local_nls = pvolume_info->local_nls;
3236 if (pvolume_info->noperm)
3237 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3238 if (pvolume_info->setuids)
3239 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3240 if (pvolume_info->server_ino)
3241 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3242 if (pvolume_info->remap)
3243 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3244 if (pvolume_info->no_xattr)
3245 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3246 if (pvolume_info->sfu_emul)
3247 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3248 if (pvolume_info->nobrl)
3249 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3250 if (pvolume_info->nostrictsync)
3251 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3252 if (pvolume_info->mand_lock)
3253 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3254 if (pvolume_info->rwpidforward)
3255 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3256 if (pvolume_info->cifs_acl)
3257 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3258 if (pvolume_info->backupuid_specified) {
3259 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3260 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3262 if (pvolume_info->backupgid_specified) {
3263 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3264 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3266 if (pvolume_info->override_uid)
3267 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3268 if (pvolume_info->override_gid)
3269 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3270 if (pvolume_info->dynperm)
3271 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3272 if (pvolume_info->fsc)
3273 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3274 if (pvolume_info->multiuser)
3275 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3276 CIFS_MOUNT_NO_PERM);
3277 if (pvolume_info->strict_io)
3278 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3279 if (pvolume_info->direct_io) {
3280 cFYI(1, "mounting share using direct i/o");
3281 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3283 if (pvolume_info->mfsymlinks) {
3284 if (pvolume_info->sfu_emul) {
3285 cERROR(1, "mount option mfsymlinks ignored if sfu "
3286 "mount option is used");
3288 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3292 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3293 cERROR(1, "mount option dynperm ignored if cifsacl "
3294 "mount option supported");
3298 cleanup_volume_info_contents(struct smb_vol *volume_info)
3300 kfree(volume_info->username);
3301 kzfree(volume_info->password);
3302 kfree(volume_info->UNC);
3303 kfree(volume_info->domainname);
3304 kfree(volume_info->iocharset);
3305 kfree(volume_info->prepath);
3309 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3313 cleanup_volume_info_contents(volume_info);
3318 #ifdef CONFIG_CIFS_DFS_UPCALL
3320 * cifs_build_path_to_root returns full path to root when we do not have an
3321 * exiting connection (tcon)
3324 build_unc_path_to_root(const struct smb_vol *vol,
3325 const struct cifs_sb_info *cifs_sb)
3327 char *full_path, *pos;
3328 unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
3329 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3331 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3332 if (full_path == NULL)
3333 return ERR_PTR(-ENOMEM);
3335 strncpy(full_path, vol->UNC, unc_len);
3336 pos = full_path + unc_len;
3339 *pos++ = CIFS_DIR_SEP(cifs_sb);
3340 strncpy(pos, vol->prepath, pplen);
3344 *pos = '\0'; /* add trailing null */
3345 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3346 cFYI(1, "%s: full_path=%s", __func__, full_path);
3351 * Perform a dfs referral query for a share and (optionally) prefix
3353 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3354 * to a string containing updated options for the submount. Otherwise it
3355 * will be left untouched.
3357 * Returns the rc from get_dfs_path to the caller, which can be used to
3358 * determine whether there were referrals.
3361 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
3362 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3366 unsigned int num_referrals = 0;
3367 struct dfs_info3_param *referrals = NULL;
3368 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3370 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3371 if (IS_ERR(full_path))
3372 return PTR_ERR(full_path);
3374 /* For DFS paths, skip the first '\' of the UNC */
3375 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3377 rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
3378 &num_referrals, &referrals,
3379 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
3381 if (!rc && num_referrals > 0) {
3382 char *fake_devname = NULL;
3384 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3385 full_path + 1, referrals,
3388 free_dfs_info_array(referrals, num_referrals);
3390 if (IS_ERR(mdata)) {
3391 rc = PTR_ERR(mdata);
3394 cleanup_volume_info_contents(volume_info);
3395 rc = cifs_setup_volume_info(volume_info, mdata,
3398 kfree(fake_devname);
3399 kfree(cifs_sb->mountdata);
3400 cifs_sb->mountdata = mdata;
3408 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3409 const char *devname)
3413 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3416 if (volume_info->nullauth) {
3417 cFYI(1, "Anonymous login");
3418 kfree(volume_info->username);
3419 volume_info->username = NULL;
3420 } else if (volume_info->username) {
3421 /* BB fixme parse for domain name here */
3422 cFYI(1, "Username: %s", volume_info->username);
3424 cifserror("No username specified");
3425 /* In userspace mount helper we can get user name from alternate
3426 locations such as env variables and files on disk */
3430 /* this is needed for ASCII cp to Unicode converts */
3431 if (volume_info->iocharset == NULL) {
3432 /* load_nls_default cannot return null */
3433 volume_info->local_nls = load_nls_default();
3435 volume_info->local_nls = load_nls(volume_info->iocharset);
3436 if (volume_info->local_nls == NULL) {
3437 cERROR(1, "CIFS mount error: iocharset %s not found",
3438 volume_info->iocharset);
3447 cifs_get_volume_info(char *mount_data, const char *devname)
3450 struct smb_vol *volume_info;
3452 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
3454 return ERR_PTR(-ENOMEM);
3456 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3458 cifs_cleanup_volume_info(volume_info);
3459 volume_info = ERR_PTR(rc);
3466 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3470 struct cifs_ses *ses;
3471 struct cifs_tcon *tcon;
3472 struct TCP_Server_Info *server;
3474 struct tcon_link *tlink;
3475 #ifdef CONFIG_CIFS_DFS_UPCALL
3476 int referral_walks_count = 0;
3479 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3483 #ifdef CONFIG_CIFS_DFS_UPCALL
3485 /* cleanup activities if we're chasing a referral */
3486 if (referral_walks_count) {
3488 cifs_put_tcon(tcon);
3490 cifs_put_smb_ses(ses);
3504 /* get a reference to a tcp session */
3505 server = cifs_get_tcp_session(volume_info);
3506 if (IS_ERR(server)) {
3507 rc = PTR_ERR(server);
3508 bdi_destroy(&cifs_sb->bdi);
3512 /* get a reference to a SMB session */
3513 ses = cifs_get_smb_ses(server, volume_info);
3517 goto mount_fail_check;
3520 /* search for existing tcon to this server share */
3521 tcon = cifs_get_tcon(ses, volume_info);
3525 goto remote_path_check;
3528 /* tell server which Unix caps we support */
3529 if (cap_unix(tcon->ses)) {
3530 /* reset of caps checks mount to see if unix extensions
3531 disabled for just this mount */
3532 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3533 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3534 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3535 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3537 goto mount_fail_check;
3540 tcon->unix_ext = 0; /* server does not support them */
3542 /* do not care if a following call succeed - informational */
3543 if (!tcon->ipc && server->ops->qfs_tcon)
3544 server->ops->qfs_tcon(xid, tcon);
3546 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3547 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
3549 /* tune readahead according to rsize */
3550 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
3553 #ifdef CONFIG_CIFS_DFS_UPCALL
3555 * Perform an unconditional check for whether there are DFS
3556 * referrals for this path without prefix, to provide support
3557 * for DFS referrals from w2k8 servers which don't seem to respond
3558 * with PATH_NOT_COVERED to requests that include the prefix.
3559 * Chase the referral if found, otherwise continue normally.
3561 if (referral_walks_count == 0) {
3562 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3565 referral_walks_count++;
3566 goto try_mount_again;
3571 /* check if a whole path is not remote */
3573 if (!server->ops->is_path_accessible) {
3575 goto mount_fail_check;
3578 * cifs_build_path_to_root works only when we have a valid tcon
3580 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3581 if (full_path == NULL) {
3583 goto mount_fail_check;
3585 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3587 if (rc != 0 && rc != -EREMOTE) {
3589 goto mount_fail_check;
3594 /* get referral if needed */
3595 if (rc == -EREMOTE) {
3596 #ifdef CONFIG_CIFS_DFS_UPCALL
3597 if (referral_walks_count > MAX_NESTED_LINKS) {
3599 * BB: when we implement proper loop detection,
3600 * we will remove this check. But now we need it
3601 * to prevent an indefinite loop if 'DFS tree' is
3602 * misconfigured (i.e. has loops).
3605 goto mount_fail_check;
3608 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
3611 referral_walks_count++;
3612 goto try_mount_again;
3614 goto mount_fail_check;
3615 #else /* No DFS support, return error on mount */
3621 goto mount_fail_check;
3623 /* now, hang the tcon off of the superblock */
3624 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3625 if (tlink == NULL) {
3627 goto mount_fail_check;
3630 tlink->tl_uid = ses->linux_uid;
3631 tlink->tl_tcon = tcon;
3632 tlink->tl_time = jiffies;
3633 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3634 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3636 cifs_sb->master_tlink = tlink;
3637 spin_lock(&cifs_sb->tlink_tree_lock);
3638 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3639 spin_unlock(&cifs_sb->tlink_tree_lock);
3641 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3645 /* on error free sesinfo and tcon struct if needed */
3647 /* If find_unc succeeded then rc == 0 so we can not end */
3648 /* up accidentally freeing someone elses tcon struct */
3650 cifs_put_tcon(tcon);
3652 cifs_put_smb_ses(ses);
3654 cifs_put_tcp_session(server);
3655 bdi_destroy(&cifs_sb->bdi);
3664 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3665 * pointer may be NULL.
3668 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
3669 const char *tree, struct cifs_tcon *tcon,
3670 const struct nls_table *nls_codepage)
3672 struct smb_hdr *smb_buffer;
3673 struct smb_hdr *smb_buffer_response;
3676 unsigned char *bcc_ptr;
3679 __u16 bytes_left, count;
3684 smb_buffer = cifs_buf_get();
3685 if (smb_buffer == NULL)
3688 smb_buffer_response = smb_buffer;
3690 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3691 NULL /*no tid */ , 4 /*wct */ );
3693 smb_buffer->Mid = get_next_mid(ses->server);
3694 smb_buffer->Uid = ses->Suid;
3695 pSMB = (TCONX_REQ *) smb_buffer;
3696 pSMBr = (TCONX_RSP *) smb_buffer_response;
3698 pSMB->AndXCommand = 0xFF;
3699 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3700 bcc_ptr = &pSMB->Password[0];
3701 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3702 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3703 *bcc_ptr = 0; /* password is null byte */
3704 bcc_ptr++; /* skip password */
3705 /* already aligned so no need to do it below */
3707 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3708 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3709 specified as required (when that support is added to
3710 the vfs in the future) as only NTLM or the much
3711 weaker LANMAN (which we do not send by default) is accepted
3712 by Samba (not sure whether other servers allow
3713 NTLMv2 password here) */
3714 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3715 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3716 (ses->server->secType == LANMAN))
3717 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3718 ses->server->sec_mode &
3719 SECMODE_PW_ENCRYPT ? true : false,
3722 #endif /* CIFS_WEAK_PW_HASH */
3723 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3724 bcc_ptr, nls_codepage);
3726 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3727 if (ses->capabilities & CAP_UNICODE) {
3728 /* must align unicode strings */
3729 *bcc_ptr = 0; /* null byte password */
3734 if (ses->server->sec_mode &
3735 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3736 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3738 if (ses->capabilities & CAP_STATUS32) {
3739 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3741 if (ses->capabilities & CAP_DFS) {
3742 smb_buffer->Flags2 |= SMBFLG2_DFS;
3744 if (ses->capabilities & CAP_UNICODE) {
3745 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3747 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3748 6 /* max utf8 char length in bytes */ *
3749 (/* server len*/ + 256 /* share len */), nls_codepage);
3750 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3751 bcc_ptr += 2; /* skip trailing null */
3752 } else { /* ASCII */
3753 strcpy(bcc_ptr, tree);
3754 bcc_ptr += strlen(tree) + 1;
3756 strcpy(bcc_ptr, "?????");
3757 bcc_ptr += strlen("?????");
3759 count = bcc_ptr - &pSMB->Password[0];
3760 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3761 pSMB->hdr.smb_buf_length) + count);
3762 pSMB->ByteCount = cpu_to_le16(count);
3764 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3767 /* above now done in SendReceive */
3768 if ((rc == 0) && (tcon != NULL)) {
3771 tcon->tidStatus = CifsGood;
3772 tcon->need_reconnect = false;
3773 tcon->tid = smb_buffer_response->Tid;
3774 bcc_ptr = pByteArea(smb_buffer_response);
3775 bytes_left = get_bcc(smb_buffer_response);
3776 length = strnlen(bcc_ptr, bytes_left - 2);
3777 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3783 /* skip service field (NB: this field is always ASCII) */
3785 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3786 (bcc_ptr[2] == 'C')) {
3787 cFYI(1, "IPC connection");
3790 } else if (length == 2) {
3791 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3792 /* the most common case */
3793 cFYI(1, "disk share connection");
3796 bcc_ptr += length + 1;
3797 bytes_left -= (length + 1);
3798 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3800 /* mostly informational -- no need to fail on error here */
3801 kfree(tcon->nativeFileSystem);
3802 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
3803 bytes_left, is_unicode,
3806 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
3808 if ((smb_buffer_response->WordCount == 3) ||
3809 (smb_buffer_response->WordCount == 7))
3810 /* field is in same location */
3811 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3814 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
3815 } else if ((rc == 0) && tcon == NULL) {
3816 /* all we need to save for IPC$ connection */
3817 ses->ipc_tid = smb_buffer_response->Tid;
3820 cifs_buf_release(smb_buffer);
3825 cifs_umount(struct cifs_sb_info *cifs_sb)
3827 struct rb_root *root = &cifs_sb->tlink_tree;
3828 struct rb_node *node;
3829 struct tcon_link *tlink;
3831 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3833 spin_lock(&cifs_sb->tlink_tree_lock);
3834 while ((node = rb_first(root))) {
3835 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3836 cifs_get_tlink(tlink);
3837 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3838 rb_erase(node, root);
3840 spin_unlock(&cifs_sb->tlink_tree_lock);
3841 cifs_put_tlink(tlink);
3842 spin_lock(&cifs_sb->tlink_tree_lock);
3844 spin_unlock(&cifs_sb->tlink_tree_lock);
3846 bdi_destroy(&cifs_sb->bdi);
3847 kfree(cifs_sb->mountdata);
3848 unload_nls(cifs_sb->local_nls);
3853 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
3856 struct TCP_Server_Info *server = ses->server;
3858 if (!server->ops->need_neg || !server->ops->negotiate)
3861 /* only send once per connect */
3862 if (!server->ops->need_neg(server))
3865 set_credits(server, 1);
3867 rc = server->ops->negotiate(xid, ses);
3869 spin_lock(&GlobalMid_Lock);
3870 if (server->tcpStatus == CifsNeedNegotiate)
3871 server->tcpStatus = CifsGood;
3874 spin_unlock(&GlobalMid_Lock);
3881 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
3882 struct nls_table *nls_info)
3885 struct TCP_Server_Info *server = ses->server;
3888 ses->capabilities = server->capabilities;
3889 if (linuxExtEnabled == 0)
3890 ses->capabilities &= (~server->vals->cap_unix);
3892 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3893 server->sec_mode, server->capabilities, server->timeAdj);
3895 if (server->ops->sess_setup)
3896 rc = server->ops->sess_setup(xid, ses, nls_info);
3899 cERROR(1, "Send error in SessSetup = %d", rc);
3901 mutex_lock(&ses->server->srv_mutex);
3902 if (!server->session_estab) {
3903 server->session_key.response = ses->auth_key.response;
3904 server->session_key.len = ses->auth_key.len;
3905 server->sequence_number = 0x2;
3906 server->session_estab = true;
3907 ses->auth_key.response = NULL;
3909 mutex_unlock(&server->srv_mutex);
3911 cFYI(1, "CIFS Session Established successfully");
3912 spin_lock(&GlobalMid_Lock);
3913 ses->status = CifsGood;
3914 ses->need_reconnect = false;
3915 spin_unlock(&GlobalMid_Lock);
3918 kfree(ses->auth_key.response);
3919 ses->auth_key.response = NULL;
3920 ses->auth_key.len = 0;
3921 kfree(ses->ntlmssp);
3922 ses->ntlmssp = NULL;
3928 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
3930 switch (ses->server->secType) {
3932 vol->secFlg = CIFSSEC_MUST_KRB5;
3935 vol->secFlg = CIFSSEC_MUST_NTLMV2;
3938 vol->secFlg = CIFSSEC_MUST_NTLM;
3941 vol->secFlg = CIFSSEC_MUST_NTLMSSP;
3944 vol->secFlg = CIFSSEC_MUST_LANMAN;
3948 return cifs_set_cifscreds(vol, ses);
3951 static struct cifs_tcon *
3952 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
3955 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3956 struct cifs_ses *ses;
3957 struct cifs_tcon *tcon = NULL;
3958 struct smb_vol *vol_info;
3960 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3961 if (vol_info == NULL)
3962 return ERR_PTR(-ENOMEM);
3964 vol_info->local_nls = cifs_sb->local_nls;
3965 vol_info->linux_uid = fsuid;
3966 vol_info->cred_uid = fsuid;
3967 vol_info->UNC = master_tcon->treeName;
3968 vol_info->retry = master_tcon->retry;
3969 vol_info->nocase = master_tcon->nocase;
3970 vol_info->local_lease = master_tcon->local_lease;
3971 vol_info->no_linux_ext = !master_tcon->unix_ext;
3973 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
3979 /* get a reference for the same TCP session */
3980 spin_lock(&cifs_tcp_ses_lock);
3981 ++master_tcon->ses->server->srv_count;
3982 spin_unlock(&cifs_tcp_ses_lock);
3984 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3986 tcon = (struct cifs_tcon *)ses;
3987 cifs_put_tcp_session(master_tcon->ses->server);
3991 tcon = cifs_get_tcon(ses, vol_info);
3993 cifs_put_smb_ses(ses);
3998 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4000 kfree(vol_info->username);
4001 kfree(vol_info->password);
4008 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4010 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4014 cifs_sb_tcon_pending_wait(void *unused)
4017 return signal_pending(current) ? -ERESTARTSYS : 0;
4020 /* find and return a tlink with given uid */
4021 static struct tcon_link *
4022 tlink_rb_search(struct rb_root *root, kuid_t uid)
4024 struct rb_node *node = root->rb_node;
4025 struct tcon_link *tlink;
4028 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4030 if (uid_gt(tlink->tl_uid, uid))
4031 node = node->rb_left;
4032 else if (uid_lt(tlink->tl_uid, uid))
4033 node = node->rb_right;
4040 /* insert a tcon_link into the tree */
4042 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4044 struct rb_node **new = &(root->rb_node), *parent = NULL;
4045 struct tcon_link *tlink;
4048 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4051 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
4052 new = &((*new)->rb_left);
4054 new = &((*new)->rb_right);
4057 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4058 rb_insert_color(&new_tlink->tl_rbnode, root);
4062 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4065 * If the superblock doesn't refer to a multiuser mount, then just return
4066 * the master tcon for the mount.
4068 * First, search the rbtree for an existing tcon for this fsuid. If one
4069 * exists, then check to see if it's pending construction. If it is then wait
4070 * for construction to complete. Once it's no longer pending, check to see if
4071 * it failed and either return an error or retry construction, depending on
4074 * If one doesn't exist then insert a new tcon_link struct into the tree and
4075 * try to construct a new one.
4078 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4081 kuid_t fsuid = current_fsuid();
4082 struct tcon_link *tlink, *newtlink;
4084 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4085 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4087 spin_lock(&cifs_sb->tlink_tree_lock);
4088 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4090 cifs_get_tlink(tlink);
4091 spin_unlock(&cifs_sb->tlink_tree_lock);
4093 if (tlink == NULL) {
4094 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4095 if (newtlink == NULL)
4096 return ERR_PTR(-ENOMEM);
4097 newtlink->tl_uid = fsuid;
4098 newtlink->tl_tcon = ERR_PTR(-EACCES);
4099 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4100 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4101 cifs_get_tlink(newtlink);
4103 spin_lock(&cifs_sb->tlink_tree_lock);
4104 /* was one inserted after previous search? */
4105 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4107 cifs_get_tlink(tlink);
4108 spin_unlock(&cifs_sb->tlink_tree_lock);
4110 goto wait_for_construction;
4113 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4114 spin_unlock(&cifs_sb->tlink_tree_lock);
4116 wait_for_construction:
4117 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4118 cifs_sb_tcon_pending_wait,
4119 TASK_INTERRUPTIBLE);
4121 cifs_put_tlink(tlink);
4122 return ERR_PTR(ret);
4125 /* if it's good, return it */
4126 if (!IS_ERR(tlink->tl_tcon))
4129 /* return error if we tried this already recently */
4130 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4131 cifs_put_tlink(tlink);
4132 return ERR_PTR(-EACCES);
4135 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4136 goto wait_for_construction;
4139 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4140 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4141 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4143 if (IS_ERR(tlink->tl_tcon)) {
4144 cifs_put_tlink(tlink);
4145 return ERR_PTR(-EACCES);
4152 * periodic workqueue job that scans tcon_tree for a superblock and closes
4156 cifs_prune_tlinks(struct work_struct *work)
4158 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4160 struct rb_root *root = &cifs_sb->tlink_tree;
4161 struct rb_node *node = rb_first(root);
4162 struct rb_node *tmp;
4163 struct tcon_link *tlink;
4166 * Because we drop the spinlock in the loop in order to put the tlink
4167 * it's not guarded against removal of links from the tree. The only
4168 * places that remove entries from the tree are this function and
4169 * umounts. Because this function is non-reentrant and is canceled
4170 * before umount can proceed, this is safe.
4172 spin_lock(&cifs_sb->tlink_tree_lock);
4173 node = rb_first(root);
4174 while (node != NULL) {
4176 node = rb_next(tmp);
4177 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4179 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4180 atomic_read(&tlink->tl_count) != 0 ||
4181 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4184 cifs_get_tlink(tlink);
4185 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4186 rb_erase(tmp, root);
4188 spin_unlock(&cifs_sb->tlink_tree_lock);
4189 cifs_put_tlink(tlink);
4190 spin_lock(&cifs_sb->tlink_tree_lock);
4192 spin_unlock(&cifs_sb->tlink_tree_lock);
4194 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,