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 /* SMB echo "timeout" -- FIXME: tunable? */
60 #define SMB_ECHO_INTERVAL (60 * HZ)
62 extern mempool_t *cifs_req_poolp;
64 /* FIXME: should these be tunable? */
65 #define TLINK_ERROR_EXPIRE (1 * HZ)
66 #define TLINK_IDLE_EXPIRE (600 * HZ)
70 /* Mount options that take no arguments */
71 Opt_user_xattr, Opt_nouser_xattr,
72 Opt_forceuid, Opt_noforceuid,
73 Opt_noblocksend, Opt_noautotune,
74 Opt_hard, Opt_soft, Opt_perm, Opt_noperm,
75 Opt_mapchars, Opt_nomapchars, Opt_sfu,
76 Opt_nosfu, Opt_nodfs, Opt_posixpaths,
77 Opt_noposixpaths, Opt_nounix,
80 Opt_forcemandatorylock, Opt_setuids,
81 Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
82 Opt_nohard, Opt_nosoft,
84 Opt_nostrictsync, Opt_strictsync,
85 Opt_serverino, Opt_noserverino,
86 Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
87 Opt_acl, Opt_noacl, Opt_locallease,
88 Opt_sign, Opt_seal, Opt_direct,
89 Opt_strictcache, Opt_noac,
90 Opt_fsc, Opt_mfsymlinks,
91 Opt_multiuser, Opt_sloppy,
93 /* Mount options which take numeric value */
94 Opt_backupuid, Opt_backupgid, Opt_uid,
95 Opt_cruid, Opt_gid, Opt_file_mode,
96 Opt_dirmode, Opt_port,
97 Opt_rsize, Opt_wsize, Opt_actimeo,
99 /* Mount options which take string value */
100 Opt_user, Opt_pass, Opt_ip,
102 Opt_srcaddr, Opt_prefixpath,
103 Opt_iocharset, Opt_sockopt,
104 Opt_netbiosname, Opt_servern,
105 Opt_ver, Opt_vers, Opt_sec, Opt_cache,
107 /* Mount options to be ignored */
110 /* Options which could be blank */
118 static const match_table_t cifs_mount_option_tokens = {
120 { Opt_user_xattr, "user_xattr" },
121 { Opt_nouser_xattr, "nouser_xattr" },
122 { Opt_forceuid, "forceuid" },
123 { Opt_noforceuid, "noforceuid" },
124 { Opt_noblocksend, "noblocksend" },
125 { Opt_noautotune, "noautotune" },
126 { Opt_hard, "hard" },
127 { Opt_soft, "soft" },
128 { Opt_perm, "perm" },
129 { Opt_noperm, "noperm" },
130 { Opt_mapchars, "mapchars" },
131 { Opt_nomapchars, "nomapchars" },
133 { Opt_nosfu, "nosfu" },
134 { Opt_nodfs, "nodfs" },
135 { Opt_posixpaths, "posixpaths" },
136 { Opt_noposixpaths, "noposixpaths" },
137 { Opt_nounix, "nounix" },
138 { Opt_nounix, "nolinux" },
139 { Opt_nocase, "nocase" },
140 { Opt_nocase, "ignorecase" },
142 { Opt_nobrl, "nobrl" },
143 { Opt_nobrl, "nolock" },
144 { Opt_forcemandatorylock, "forcemandatorylock" },
145 { Opt_forcemandatorylock, "forcemand" },
146 { Opt_setuids, "setuids" },
147 { Opt_nosetuids, "nosetuids" },
148 { Opt_dynperm, "dynperm" },
149 { Opt_nodynperm, "nodynperm" },
150 { Opt_nohard, "nohard" },
151 { Opt_nosoft, "nosoft" },
152 { Opt_nointr, "nointr" },
153 { Opt_intr, "intr" },
154 { Opt_nostrictsync, "nostrictsync" },
155 { Opt_strictsync, "strictsync" },
156 { Opt_serverino, "serverino" },
157 { Opt_noserverino, "noserverino" },
158 { Opt_rwpidforward, "rwpidforward" },
159 { Opt_cifsacl, "cifsacl" },
160 { Opt_nocifsacl, "nocifsacl" },
162 { Opt_noacl, "noacl" },
163 { Opt_locallease, "locallease" },
164 { Opt_sign, "sign" },
165 { Opt_seal, "seal" },
166 { Opt_direct, "direct" },
167 { Opt_direct, "directio" },
168 { Opt_direct, "forcedirectio" },
169 { Opt_strictcache, "strictcache" },
170 { Opt_noac, "noac" },
172 { Opt_mfsymlinks, "mfsymlinks" },
173 { Opt_multiuser, "multiuser" },
174 { Opt_sloppy, "sloppy" },
176 { Opt_backupuid, "backupuid=%s" },
177 { Opt_backupgid, "backupgid=%s" },
178 { Opt_uid, "uid=%s" },
179 { Opt_cruid, "cruid=%s" },
180 { Opt_gid, "gid=%s" },
181 { Opt_file_mode, "file_mode=%s" },
182 { Opt_dirmode, "dirmode=%s" },
183 { Opt_dirmode, "dir_mode=%s" },
184 { Opt_port, "port=%s" },
185 { Opt_rsize, "rsize=%s" },
186 { Opt_wsize, "wsize=%s" },
187 { Opt_actimeo, "actimeo=%s" },
189 { Opt_blank_user, "user=" },
190 { Opt_blank_user, "username=" },
191 { Opt_user, "user=%s" },
192 { Opt_user, "username=%s" },
193 { Opt_blank_pass, "pass=" },
194 { Opt_pass, "pass=%s" },
195 { Opt_pass, "password=%s" },
196 { Opt_blank_ip, "ip=" },
197 { Opt_blank_ip, "addr=" },
199 { Opt_ip, "addr=%s" },
200 { Opt_unc, "unc=%s" },
201 { Opt_unc, "target=%s" },
202 { Opt_unc, "path=%s" },
203 { Opt_domain, "dom=%s" },
204 { Opt_domain, "domain=%s" },
205 { Opt_domain, "workgroup=%s" },
206 { Opt_srcaddr, "srcaddr=%s" },
207 { Opt_prefixpath, "prefixpath=%s" },
208 { Opt_iocharset, "iocharset=%s" },
209 { Opt_sockopt, "sockopt=%s" },
210 { Opt_netbiosname, "netbiosname=%s" },
211 { Opt_servern, "servern=%s" },
212 { Opt_ver, "ver=%s" },
213 { Opt_vers, "vers=%s" },
214 { Opt_sec, "sec=%s" },
215 { Opt_cache, "cache=%s" },
217 { Opt_ignore, "cred" },
218 { Opt_ignore, "credentials" },
219 { Opt_ignore, "cred=%s" },
220 { Opt_ignore, "credentials=%s" },
221 { Opt_ignore, "guest" },
222 { Opt_ignore, "rw" },
223 { Opt_ignore, "ro" },
224 { Opt_ignore, "suid" },
225 { Opt_ignore, "nosuid" },
226 { Opt_ignore, "exec" },
227 { Opt_ignore, "noexec" },
228 { Opt_ignore, "nodev" },
229 { Opt_ignore, "noauto" },
230 { Opt_ignore, "dev" },
231 { Opt_ignore, "mand" },
232 { Opt_ignore, "nomand" },
233 { Opt_ignore, "_netdev" },
239 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
240 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
241 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
242 Opt_sec_ntlmv2i, Opt_sec_lanman,
248 static const match_table_t cifs_secflavor_tokens = {
249 { Opt_sec_krb5, "krb5" },
250 { Opt_sec_krb5i, "krb5i" },
251 { Opt_sec_krb5p, "krb5p" },
252 { Opt_sec_ntlmsspi, "ntlmsspi" },
253 { Opt_sec_ntlmssp, "ntlmssp" },
254 { Opt_ntlm, "ntlm" },
255 { Opt_sec_ntlmi, "ntlmi" },
256 { Opt_sec_ntlmv2, "nontlm" },
257 { Opt_sec_ntlmv2, "ntlmv2" },
258 { Opt_sec_ntlmv2i, "ntlmv2i" },
259 { Opt_sec_lanman, "lanman" },
260 { Opt_sec_none, "none" },
262 { Opt_sec_err, NULL }
273 static const match_table_t cifs_cacheflavor_tokens = {
274 { Opt_cache_loose, "loose" },
275 { Opt_cache_strict, "strict" },
276 { Opt_cache_none, "none" },
277 { Opt_cache_err, NULL }
280 static const match_table_t cifs_smb_version_tokens = {
281 { Smb_1, SMB1_VERSION_STRING },
282 { Smb_21, SMB21_VERSION_STRING },
285 static int ip_connect(struct TCP_Server_Info *server);
286 static int generic_ip_connect(struct TCP_Server_Info *server);
287 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
288 static void cifs_prune_tlinks(struct work_struct *work);
289 static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
290 const char *devname);
293 * cifs tcp session reconnection
295 * mark tcp session as reconnecting so temporarily locked
296 * mark all smb sessions as reconnecting for tcp session
297 * reconnect tcp session
298 * wake up waiters on reconnection? - (not needed currently)
301 cifs_reconnect(struct TCP_Server_Info *server)
304 struct list_head *tmp, *tmp2;
305 struct cifs_ses *ses;
306 struct cifs_tcon *tcon;
307 struct mid_q_entry *mid_entry;
308 struct list_head retry_list;
310 spin_lock(&GlobalMid_Lock);
311 if (server->tcpStatus == CifsExiting) {
312 /* the demux thread will exit normally
313 next time through the loop */
314 spin_unlock(&GlobalMid_Lock);
317 server->tcpStatus = CifsNeedReconnect;
318 spin_unlock(&GlobalMid_Lock);
321 cFYI(1, "Reconnecting tcp session");
323 /* before reconnecting the tcp session, mark the smb session (uid)
324 and the tid bad so they are not used until reconnected */
325 cFYI(1, "%s: marking sessions and tcons for reconnect", __func__);
326 spin_lock(&cifs_tcp_ses_lock);
327 list_for_each(tmp, &server->smb_ses_list) {
328 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
329 ses->need_reconnect = true;
331 list_for_each(tmp2, &ses->tcon_list) {
332 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
333 tcon->need_reconnect = true;
336 spin_unlock(&cifs_tcp_ses_lock);
338 /* do not want to be sending data on a socket we are freeing */
339 cFYI(1, "%s: tearing down socket", __func__);
340 mutex_lock(&server->srv_mutex);
341 if (server->ssocket) {
342 cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
343 server->ssocket->flags);
344 kernel_sock_shutdown(server->ssocket, SHUT_WR);
345 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
346 server->ssocket->state,
347 server->ssocket->flags);
348 sock_release(server->ssocket);
349 server->ssocket = NULL;
351 server->sequence_number = 0;
352 server->session_estab = false;
353 kfree(server->session_key.response);
354 server->session_key.response = NULL;
355 server->session_key.len = 0;
356 server->lstrp = jiffies;
357 mutex_unlock(&server->srv_mutex);
359 /* mark submitted MIDs for retry and issue callback */
360 INIT_LIST_HEAD(&retry_list);
361 cFYI(1, "%s: moving mids to private list", __func__);
362 spin_lock(&GlobalMid_Lock);
363 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
364 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
365 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
366 mid_entry->mid_state = MID_RETRY_NEEDED;
367 list_move(&mid_entry->qhead, &retry_list);
369 spin_unlock(&GlobalMid_Lock);
371 cFYI(1, "%s: issuing mid callbacks", __func__);
372 list_for_each_safe(tmp, tmp2, &retry_list) {
373 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
374 list_del_init(&mid_entry->qhead);
375 mid_entry->callback(mid_entry);
381 /* we should try only the port we connected to before */
382 rc = generic_ip_connect(server);
384 cFYI(1, "reconnect error %d", rc);
387 atomic_inc(&tcpSesReconnectCount);
388 spin_lock(&GlobalMid_Lock);
389 if (server->tcpStatus != CifsExiting)
390 server->tcpStatus = CifsNeedNegotiate;
391 spin_unlock(&GlobalMid_Lock);
393 } while (server->tcpStatus == CifsNeedReconnect);
399 cifs_echo_request(struct work_struct *work)
402 struct TCP_Server_Info *server = container_of(work,
403 struct TCP_Server_Info, echo.work);
406 * We cannot send an echo until the NEGOTIATE_PROTOCOL request is
407 * done, which is indicated by maxBuf != 0. Also, no need to ping if
408 * we got a response recently
410 if (!server->ops->need_neg || server->ops->need_neg(server) ||
411 time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
414 rc = CIFSSMBEcho(server);
416 cFYI(1, "Unable to send echo request to server: %s",
420 queue_delayed_work(cifsiod_wq, &server->echo, SMB_ECHO_INTERVAL);
424 allocate_buffers(struct TCP_Server_Info *server)
426 if (!server->bigbuf) {
427 server->bigbuf = (char *)cifs_buf_get();
428 if (!server->bigbuf) {
429 cERROR(1, "No memory for large SMB response");
431 /* retry will check if exiting */
434 } else if (server->large_buf) {
435 /* we are reusing a dirty large buf, clear its start */
436 memset(server->bigbuf, 0, HEADER_SIZE(server));
439 if (!server->smallbuf) {
440 server->smallbuf = (char *)cifs_small_buf_get();
441 if (!server->smallbuf) {
442 cERROR(1, "No memory for SMB response");
444 /* retry will check if exiting */
447 /* beginning of smb buffer is cleared in our buf_get */
449 /* if existing small buf clear beginning */
450 memset(server->smallbuf, 0, HEADER_SIZE(server));
457 server_unresponsive(struct TCP_Server_Info *server)
460 * We need to wait 2 echo intervals to make sure we handle such
462 * 1s client sends a normal SMB request
463 * 2s client gets a response
464 * 30s echo workqueue job pops, and decides we got a response recently
465 * and don't need to send another
467 * 65s kernel_recvmsg times out, and we see that we haven't gotten
468 * a response in >60s.
470 if (server->tcpStatus == CifsGood &&
471 time_after(jiffies, server->lstrp + 2 * SMB_ECHO_INTERVAL)) {
472 cERROR(1, "Server %s has not responded in %d seconds. "
473 "Reconnecting...", server->hostname,
474 (2 * SMB_ECHO_INTERVAL) / HZ);
475 cifs_reconnect(server);
476 wake_up(&server->response_q);
484 * kvec_array_init - clone a kvec array, and advance into it
485 * @new: pointer to memory for cloned array
486 * @iov: pointer to original array
487 * @nr_segs: number of members in original array
488 * @bytes: number of bytes to advance into the cloned array
490 * This function will copy the array provided in iov to a section of memory
491 * and advance the specified number of bytes into the new array. It returns
492 * the number of segments in the new array. "new" must be at least as big as
493 * the original iov array.
496 kvec_array_init(struct kvec *new, struct kvec *iov, unsigned int nr_segs,
501 while (bytes || !iov->iov_len) {
502 int copy = min(bytes, iov->iov_len);
506 if (iov->iov_len == base) {
512 memcpy(new, iov, sizeof(*iov) * nr_segs);
513 new->iov_base += base;
514 new->iov_len -= base;
519 get_server_iovec(struct TCP_Server_Info *server, unsigned int nr_segs)
521 struct kvec *new_iov;
523 if (server->iov && nr_segs <= server->nr_iov)
526 /* not big enough -- allocate a new one and release the old */
527 new_iov = kmalloc(sizeof(*new_iov) * nr_segs, GFP_NOFS);
530 server->iov = new_iov;
531 server->nr_iov = nr_segs;
537 cifs_readv_from_socket(struct TCP_Server_Info *server, struct kvec *iov_orig,
538 unsigned int nr_segs, unsigned int to_read)
543 struct msghdr smb_msg;
546 iov = get_server_iovec(server, nr_segs);
550 smb_msg.msg_control = NULL;
551 smb_msg.msg_controllen = 0;
553 for (total_read = 0; to_read; total_read += length, to_read -= length) {
556 if (server_unresponsive(server)) {
557 total_read = -EAGAIN;
561 segs = kvec_array_init(iov, iov_orig, nr_segs, total_read);
563 length = kernel_recvmsg(server->ssocket, &smb_msg,
564 iov, segs, to_read, 0);
566 if (server->tcpStatus == CifsExiting) {
567 total_read = -ESHUTDOWN;
569 } else if (server->tcpStatus == CifsNeedReconnect) {
570 cifs_reconnect(server);
571 total_read = -EAGAIN;
573 } else if (length == -ERESTARTSYS ||
577 * Minimum sleep to prevent looping, allowing socket
578 * to clear and app threads to set tcpStatus
579 * CifsNeedReconnect if server hung.
581 usleep_range(1000, 2000);
584 } else if (length <= 0) {
585 cFYI(1, "Received no data or error: expecting %d "
586 "got %d", to_read, length);
587 cifs_reconnect(server);
588 total_read = -EAGAIN;
596 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
597 unsigned int to_read)
602 iov.iov_len = to_read;
604 return cifs_readv_from_socket(server, &iov, 1, to_read);
608 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
611 * The first byte big endian of the length field,
612 * is actually not part of the length but the type
613 * with the most common, zero, as regular data.
616 case RFC1002_SESSION_MESSAGE:
617 /* Regular SMB response */
619 case RFC1002_SESSION_KEEP_ALIVE:
620 cFYI(1, "RFC 1002 session keep alive");
622 case RFC1002_POSITIVE_SESSION_RESPONSE:
623 cFYI(1, "RFC 1002 positive session response");
625 case RFC1002_NEGATIVE_SESSION_RESPONSE:
627 * We get this from Windows 98 instead of an error on
628 * SMB negprot response.
630 cFYI(1, "RFC 1002 negative session response");
631 /* give server a second to clean up */
634 * Always try 445 first on reconnect since we get NACK
635 * on some if we ever connected to port 139 (the NACK
636 * is since we do not begin with RFC1001 session
639 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
640 cifs_reconnect(server);
641 wake_up(&server->response_q);
644 cERROR(1, "RFC 1002 unknown response type 0x%x", type);
645 cifs_reconnect(server);
652 dequeue_mid(struct mid_q_entry *mid, bool malformed)
654 #ifdef CONFIG_CIFS_STATS2
655 mid->when_received = jiffies;
657 spin_lock(&GlobalMid_Lock);
659 mid->mid_state = MID_RESPONSE_RECEIVED;
661 mid->mid_state = MID_RESPONSE_MALFORMED;
662 list_del_init(&mid->qhead);
663 spin_unlock(&GlobalMid_Lock);
667 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
668 char *buf, int malformed)
670 if (server->ops->check_trans2 &&
671 server->ops->check_trans2(mid, server, buf, malformed))
674 mid->large_buf = server->large_buf;
675 /* Was previous buf put in mpx struct for multi-rsp? */
676 if (!mid->multiRsp) {
677 /* smb buffer will be freed by user thread */
678 if (server->large_buf)
679 server->bigbuf = NULL;
681 server->smallbuf = NULL;
683 dequeue_mid(mid, malformed);
686 static void clean_demultiplex_info(struct TCP_Server_Info *server)
690 /* take it off the list, if it's not already */
691 spin_lock(&cifs_tcp_ses_lock);
692 list_del_init(&server->tcp_ses_list);
693 spin_unlock(&cifs_tcp_ses_lock);
695 spin_lock(&GlobalMid_Lock);
696 server->tcpStatus = CifsExiting;
697 spin_unlock(&GlobalMid_Lock);
698 wake_up_all(&server->response_q);
700 /* check if we have blocked requests that need to free */
701 spin_lock(&server->req_lock);
702 if (server->credits <= 0)
704 spin_unlock(&server->req_lock);
706 * Although there should not be any requests blocked on this queue it
707 * can not hurt to be paranoid and try to wake up requests that may
708 * haven been blocked when more than 50 at time were on the wire to the
709 * same server - they now will see the session is in exit state and get
710 * out of SendReceive.
712 wake_up_all(&server->request_q);
713 /* give those requests time to exit */
716 if (server->ssocket) {
717 sock_release(server->ssocket);
718 server->ssocket = NULL;
721 if (!list_empty(&server->pending_mid_q)) {
722 struct list_head dispose_list;
723 struct mid_q_entry *mid_entry;
724 struct list_head *tmp, *tmp2;
726 INIT_LIST_HEAD(&dispose_list);
727 spin_lock(&GlobalMid_Lock);
728 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
729 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
730 cFYI(1, "Clearing mid 0x%llx", mid_entry->mid);
731 mid_entry->mid_state = MID_SHUTDOWN;
732 list_move(&mid_entry->qhead, &dispose_list);
734 spin_unlock(&GlobalMid_Lock);
736 /* now walk dispose list and issue callbacks */
737 list_for_each_safe(tmp, tmp2, &dispose_list) {
738 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
739 cFYI(1, "Callback mid 0x%llx", mid_entry->mid);
740 list_del_init(&mid_entry->qhead);
741 mid_entry->callback(mid_entry);
743 /* 1/8th of sec is more than enough time for them to exit */
747 if (!list_empty(&server->pending_mid_q)) {
749 * mpx threads have not exited yet give them at least the smb
750 * send timeout time for long ops.
752 * Due to delays on oplock break requests, we need to wait at
753 * least 45 seconds before giving up on a request getting a
754 * response and going ahead and killing cifsd.
756 cFYI(1, "Wait for exit from demultiplex thread");
759 * If threads still have not exited they are probably never
760 * coming home not much else we can do but free the memory.
764 kfree(server->hostname);
768 length = atomic_dec_return(&tcpSesAllocCount);
770 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
775 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
778 char *buf = server->smallbuf;
779 unsigned int pdu_length = get_rfc1002_length(buf);
781 /* make sure this will fit in a large buffer */
782 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) - 4) {
783 cERROR(1, "SMB response too long (%u bytes)",
785 cifs_reconnect(server);
786 wake_up(&server->response_q);
790 /* switch to large buffer if too big for a small one */
791 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
792 server->large_buf = true;
793 memcpy(server->bigbuf, buf, server->total_read);
794 buf = server->bigbuf;
797 /* now read the rest */
798 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
799 pdu_length - HEADER_SIZE(server) + 1 + 4);
802 server->total_read += length;
804 dump_smb(buf, server->total_read);
807 * We know that we received enough to get to the MID as we
808 * checked the pdu_length earlier. Now check to see
809 * if the rest of the header is OK. We borrow the length
810 * var for the rest of the loop to avoid a new stack var.
812 * 48 bytes is enough to display the header and a little bit
813 * into the payload for debugging purposes.
815 length = server->ops->check_message(buf, server->total_read);
817 cifs_dump_mem("Bad SMB: ", buf,
818 min_t(unsigned int, server->total_read, 48));
823 handle_mid(mid, server, buf, length);
828 cifs_demultiplex_thread(void *p)
831 struct TCP_Server_Info *server = p;
832 unsigned int pdu_length;
834 struct task_struct *task_to_wake = NULL;
835 struct mid_q_entry *mid_entry;
837 current->flags |= PF_MEMALLOC;
838 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
840 length = atomic_inc_return(&tcpSesAllocCount);
842 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
846 while (server->tcpStatus != CifsExiting) {
850 if (!allocate_buffers(server))
853 server->large_buf = false;
854 buf = server->smallbuf;
855 pdu_length = 4; /* enough to get RFC1001 header */
857 length = cifs_read_from_socket(server, buf, pdu_length);
860 server->total_read = length;
863 * The right amount was read from socket - 4 bytes,
864 * so we can now interpret the length field.
866 pdu_length = get_rfc1002_length(buf);
868 cFYI(1, "RFC1002 header 0x%x", pdu_length);
869 if (!is_smb_response(server, buf[0]))
872 /* make sure we have enough to get to the MID */
873 if (pdu_length < HEADER_SIZE(server) - 1 - 4) {
874 cERROR(1, "SMB response too short (%u bytes)",
876 cifs_reconnect(server);
877 wake_up(&server->response_q);
881 /* read down to the MID */
882 length = cifs_read_from_socket(server, buf + 4,
883 HEADER_SIZE(server) - 1 - 4);
886 server->total_read += length;
888 mid_entry = server->ops->find_mid(server, buf);
890 if (!mid_entry || !mid_entry->receive)
891 length = standard_receive3(server, mid_entry);
893 length = mid_entry->receive(server, mid_entry);
898 if (server->large_buf)
899 buf = server->bigbuf;
901 server->lstrp = jiffies;
902 if (mid_entry != NULL) {
903 if (!mid_entry->multiRsp || mid_entry->multiEnd)
904 mid_entry->callback(mid_entry);
905 } else if (!server->ops->is_oplock_break ||
906 !server->ops->is_oplock_break(buf, server)) {
907 cERROR(1, "No task to wake, unknown frame received! "
908 "NumMids %d", atomic_read(&midCount));
909 cifs_dump_mem("Received Data is: ", buf,
910 HEADER_SIZE(server));
911 #ifdef CONFIG_CIFS_DEBUG2
912 if (server->ops->dump_detail)
913 server->ops->dump_detail(buf);
914 cifs_dump_mids(server);
915 #endif /* CIFS_DEBUG2 */
918 } /* end while !EXITING */
920 /* buffer usually freed in free_mid - need to free it here on exit */
921 cifs_buf_release(server->bigbuf);
922 if (server->smallbuf) /* no sense logging a debug message if NULL */
923 cifs_small_buf_release(server->smallbuf);
925 task_to_wake = xchg(&server->tsk, NULL);
926 clean_demultiplex_info(server);
928 /* if server->tsk was NULL then wait for a signal before exiting */
930 set_current_state(TASK_INTERRUPTIBLE);
931 while (!signal_pending(current)) {
933 set_current_state(TASK_INTERRUPTIBLE);
935 set_current_state(TASK_RUNNING);
938 module_put_and_exit(0);
941 /* extract the host portion of the UNC string */
943 extract_hostname(const char *unc)
949 /* skip double chars at beginning of string */
950 /* BB: check validity of these bytes? */
953 /* delimiter between hostname and sharename is always '\\' now */
954 delim = strchr(src, '\\');
956 return ERR_PTR(-EINVAL);
959 dst = kmalloc((len + 1), GFP_KERNEL);
961 return ERR_PTR(-ENOMEM);
963 memcpy(dst, src, len);
969 static int get_option_ul(substring_t args[], unsigned long *option)
974 string = match_strdup(args);
977 rc = kstrtoul(string, 0, option);
984 static int cifs_parse_security_flavors(char *value,
988 substring_t args[MAX_OPT_ARGS];
990 switch (match_token(value, cifs_secflavor_tokens, args)) {
992 vol->secFlg |= CIFSSEC_MAY_KRB5;
995 vol->secFlg |= CIFSSEC_MAY_KRB5 | CIFSSEC_MUST_SIGN;
998 /* vol->secFlg |= CIFSSEC_MUST_SEAL | CIFSSEC_MAY_KRB5; */
999 cERROR(1, "Krb5 cifs privacy not supported");
1001 case Opt_sec_ntlmssp:
1002 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
1004 case Opt_sec_ntlmsspi:
1005 vol->secFlg |= CIFSSEC_MAY_NTLMSSP | CIFSSEC_MUST_SIGN;
1008 /* ntlm is default so can be turned off too */
1009 vol->secFlg |= CIFSSEC_MAY_NTLM;
1012 vol->secFlg |= CIFSSEC_MAY_NTLM | CIFSSEC_MUST_SIGN;
1014 case Opt_sec_ntlmv2:
1015 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1017 case Opt_sec_ntlmv2i:
1018 vol->secFlg |= CIFSSEC_MAY_NTLMV2 | CIFSSEC_MUST_SIGN;
1020 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1021 case Opt_sec_lanman:
1022 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1029 cERROR(1, "bad security option: %s", value);
1037 cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1039 substring_t args[MAX_OPT_ARGS];
1041 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1042 case Opt_cache_loose:
1043 vol->direct_io = false;
1044 vol->strict_io = false;
1046 case Opt_cache_strict:
1047 vol->direct_io = false;
1048 vol->strict_io = true;
1050 case Opt_cache_none:
1051 vol->direct_io = true;
1052 vol->strict_io = false;
1055 cERROR(1, "bad cache= option: %s", value);
1062 cifs_parse_smb_version(char *value, struct smb_vol *vol)
1064 substring_t args[MAX_OPT_ARGS];
1066 switch (match_token(value, cifs_smb_version_tokens, args)) {
1068 vol->ops = &smb1_operations;
1069 vol->vals = &smb1_values;
1071 #ifdef CONFIG_CIFS_SMB2
1073 vol->ops = &smb21_operations;
1074 vol->vals = &smb21_values;
1078 cERROR(1, "Unknown vers= option specified: %s", value);
1085 cifs_parse_mount_options(const char *mountdata, const char *devname,
1086 struct smb_vol *vol)
1089 char *mountdata_copy = NULL, *options;
1090 unsigned int temp_len, i, j;
1092 short int override_uid = -1;
1093 short int override_gid = -1;
1094 bool uid_specified = false;
1095 bool gid_specified = false;
1096 bool sloppy = false;
1097 char *invalid = NULL;
1098 char *nodename = utsname()->nodename;
1099 char *string = NULL;
1100 char *tmp_end, *value;
1102 bool cache_specified = false;
1103 static bool cache_warned = false;
1107 delim = separator[0];
1110 * does not have to be perfect mapping since field is
1111 * informational, only used for servers that do not support
1112 * port 445 and it can be overridden at mount time
1114 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1115 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1116 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1118 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1119 /* null target name indicates to use *SMBSERVR default called name
1120 if we end up sending RFC1001 session initialize */
1121 vol->target_rfc1001_name[0] = 0;
1122 vol->cred_uid = current_uid();
1123 vol->linux_uid = current_uid();
1124 vol->linux_gid = current_gid();
1126 /* default to only allowing write access to owner of the mount */
1127 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1129 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1130 /* default is always to request posix paths. */
1131 vol->posix_paths = 1;
1132 /* default to using server inode numbers where available */
1133 vol->server_ino = 1;
1135 vol->actimeo = CIFS_DEF_ACTIMEO;
1137 /* FIXME: add autonegotiation -- for now, SMB1 is default */
1138 vol->ops = &smb1_operations;
1139 vol->vals = &smb1_values;
1142 goto cifs_parse_mount_err;
1144 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1145 if (!mountdata_copy)
1146 goto cifs_parse_mount_err;
1148 options = mountdata_copy;
1149 end = options + strlen(options);
1151 if (strncmp(options, "sep=", 4) == 0) {
1152 if (options[4] != 0) {
1153 separator[0] = options[4];
1156 cFYI(1, "Null separator not allowed");
1159 vol->backupuid_specified = false; /* no backup intent for a user */
1160 vol->backupgid_specified = false; /* no backup intent for a group */
1162 while ((data = strsep(&options, separator)) != NULL) {
1163 substring_t args[MAX_OPT_ARGS];
1164 unsigned long option;
1170 token = match_token(data, cifs_mount_option_tokens, args);
1174 /* Ingnore the following */
1178 /* Boolean values */
1179 case Opt_user_xattr:
1182 case Opt_nouser_xattr:
1188 case Opt_noforceuid:
1191 case Opt_noblocksend:
1192 vol->noblocksnd = 1;
1194 case Opt_noautotune:
1195 vol->noautotune = 1;
1212 case Opt_nomapchars:
1224 case Opt_posixpaths:
1225 vol->posix_paths = 1;
1227 case Opt_noposixpaths:
1228 vol->posix_paths = 0;
1231 vol->no_linux_ext = 1;
1242 * turn off mandatory locking in mode
1243 * if remote locking is turned off since the
1244 * local vfs will do advisory
1246 if (vol->file_mode ==
1247 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1248 vol->file_mode = S_IALLUGO;
1250 case Opt_forcemandatorylock:
1260 vol->dynperm = true;
1263 vol->dynperm = false;
1277 case Opt_nostrictsync:
1278 vol->nostrictsync = 1;
1280 case Opt_strictsync:
1281 vol->nostrictsync = 0;
1284 vol->server_ino = 1;
1286 case Opt_noserverino:
1287 vol->server_ino = 0;
1289 case Opt_rwpidforward:
1290 vol->rwpidforward = 1;
1299 vol->no_psx_acl = 0;
1302 vol->no_psx_acl = 1;
1304 case Opt_locallease:
1305 vol->local_lease = 1;
1308 vol->secFlg |= CIFSSEC_MUST_SIGN;
1311 /* we do not do the following in secFlags because seal
1312 * is a per tree connection (mount) not a per socket
1313 * or per-smb connection option in the protocol
1314 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1319 cache_specified = true;
1320 vol->direct_io = true;
1321 vol->strict_io = false;
1322 cERROR(1, "The \"directio\" option will be removed in "
1323 "3.7. Please switch to the \"cache=none\" "
1326 case Opt_strictcache:
1327 cache_specified = true;
1328 vol->direct_io = false;
1329 vol->strict_io = true;
1330 cERROR(1, "The \"strictcache\" option will be removed "
1331 "in 3.7. Please switch to the \"cache=strict\" "
1335 printk(KERN_WARNING "CIFS: Mount option noac not "
1336 "supported. Instead set "
1337 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1340 #ifndef CONFIG_CIFS_FSCACHE
1341 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE "
1342 "kernel config option set");
1343 goto cifs_parse_mount_err;
1347 case Opt_mfsymlinks:
1348 vol->mfsymlinks = true;
1351 vol->multiuser = true;
1357 /* Numeric Values */
1359 if (get_option_ul(args, &option)) {
1360 cERROR(1, "%s: Invalid backupuid value",
1362 goto cifs_parse_mount_err;
1364 vol->backupuid = option;
1365 vol->backupuid_specified = true;
1368 if (get_option_ul(args, &option)) {
1369 cERROR(1, "%s: Invalid backupgid value",
1371 goto cifs_parse_mount_err;
1373 vol->backupgid = option;
1374 vol->backupgid_specified = true;
1377 if (get_option_ul(args, &option)) {
1378 cERROR(1, "%s: Invalid uid value",
1380 goto cifs_parse_mount_err;
1382 vol->linux_uid = option;
1383 uid_specified = true;
1386 if (get_option_ul(args, &option)) {
1387 cERROR(1, "%s: Invalid cruid value",
1389 goto cifs_parse_mount_err;
1391 vol->cred_uid = option;
1394 if (get_option_ul(args, &option)) {
1395 cERROR(1, "%s: Invalid gid value",
1397 goto cifs_parse_mount_err;
1399 vol->linux_gid = option;
1400 gid_specified = true;
1403 if (get_option_ul(args, &option)) {
1404 cERROR(1, "%s: Invalid file_mode value",
1406 goto cifs_parse_mount_err;
1408 vol->file_mode = option;
1411 if (get_option_ul(args, &option)) {
1412 cERROR(1, "%s: Invalid dir_mode value",
1414 goto cifs_parse_mount_err;
1416 vol->dir_mode = option;
1419 if (get_option_ul(args, &option)) {
1420 cERROR(1, "%s: Invalid port value",
1422 goto cifs_parse_mount_err;
1427 if (get_option_ul(args, &option)) {
1428 cERROR(1, "%s: Invalid rsize value",
1430 goto cifs_parse_mount_err;
1432 vol->rsize = option;
1435 if (get_option_ul(args, &option)) {
1436 cERROR(1, "%s: Invalid wsize value",
1438 goto cifs_parse_mount_err;
1440 vol->wsize = option;
1443 if (get_option_ul(args, &option)) {
1444 cERROR(1, "%s: Invalid actimeo value",
1446 goto cifs_parse_mount_err;
1448 vol->actimeo = HZ * option;
1449 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1450 cERROR(1, "CIFS: attribute cache"
1451 "timeout too large");
1452 goto cifs_parse_mount_err;
1456 /* String Arguments */
1458 case Opt_blank_user:
1459 /* null user, ie. anonymous authentication */
1461 vol->username = NULL;
1464 string = match_strdup(args);
1468 if (strnlen(string, MAX_USERNAME_SIZE) >
1469 MAX_USERNAME_SIZE) {
1470 printk(KERN_WARNING "CIFS: username too long\n");
1471 goto cifs_parse_mount_err;
1473 vol->username = kstrdup(string, GFP_KERNEL);
1474 if (!vol->username) {
1475 printk(KERN_WARNING "CIFS: no memory "
1477 goto cifs_parse_mount_err;
1480 case Opt_blank_pass:
1481 vol->password = NULL;
1484 /* passwords have to be handled differently
1485 * to allow the character used for deliminator
1486 * to be passed within them
1489 /* Obtain the value string */
1490 value = strchr(data, '=');
1493 /* Set tmp_end to end of the string */
1494 tmp_end = (char *) value + strlen(value);
1496 /* Check if following character is the deliminator
1497 * If yes, we have encountered a double deliminator
1498 * reset the NULL character to the deliminator
1500 if (tmp_end < end && tmp_end[1] == delim) {
1503 /* Keep iterating until we get to a single
1504 * deliminator OR the end
1506 while ((tmp_end = strchr(tmp_end, delim))
1507 != NULL && (tmp_end[1] == delim)) {
1508 tmp_end = (char *) &tmp_end[2];
1511 /* Reset var options to point to next element */
1514 options = (char *) &tmp_end[1];
1516 /* Reached the end of the mount option
1521 /* Now build new password string */
1522 temp_len = strlen(value);
1523 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1524 if (vol->password == NULL) {
1525 printk(KERN_WARNING "CIFS: no memory "
1527 goto cifs_parse_mount_err;
1530 for (i = 0, j = 0; i < temp_len; i++, j++) {
1531 vol->password[j] = value[i];
1532 if ((value[i] == delim) &&
1533 value[i+1] == delim)
1534 /* skip the second deliminator */
1537 vol->password[j] = '\0';
1543 string = match_strdup(args);
1547 if (strnlen(string, INET6_ADDRSTRLEN) >
1549 printk(KERN_WARNING "CIFS: ip address "
1551 goto cifs_parse_mount_err;
1553 vol->UNCip = kstrdup(string, GFP_KERNEL);
1555 printk(KERN_WARNING "CIFS: no memory "
1557 goto cifs_parse_mount_err;
1561 string = match_strdup(args);
1565 temp_len = strnlen(string, 300);
1566 if (temp_len == 300) {
1567 printk(KERN_WARNING "CIFS: UNC name too long\n");
1568 goto cifs_parse_mount_err;
1571 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1572 if (vol->UNC == NULL) {
1573 printk(KERN_WARNING "CIFS: no memory for UNC\n");
1574 goto cifs_parse_mount_err;
1576 strcpy(vol->UNC, string);
1578 if (strncmp(string, "//", 2) == 0) {
1581 } else if (strncmp(string, "\\\\", 2) != 0) {
1582 printk(KERN_WARNING "CIFS: UNC Path does not "
1583 "begin with // or \\\\\n");
1584 goto cifs_parse_mount_err;
1589 string = match_strdup(args);
1593 if (strnlen(string, 256) == 256) {
1594 printk(KERN_WARNING "CIFS: domain name too"
1596 goto cifs_parse_mount_err;
1599 vol->domainname = kstrdup(string, GFP_KERNEL);
1600 if (!vol->domainname) {
1601 printk(KERN_WARNING "CIFS: no memory "
1602 "for domainname\n");
1603 goto cifs_parse_mount_err;
1605 cFYI(1, "Domain name set");
1608 string = match_strdup(args);
1612 if (!cifs_convert_address(
1613 (struct sockaddr *)&vol->srcaddr,
1614 string, strlen(string))) {
1615 printk(KERN_WARNING "CIFS: Could not parse"
1616 " srcaddr: %s\n", string);
1617 goto cifs_parse_mount_err;
1620 case Opt_prefixpath:
1621 string = match_strdup(args);
1625 temp_len = strnlen(string, 1024);
1626 if (string[0] != '/')
1627 temp_len++; /* missing leading slash */
1628 if (temp_len > 1024) {
1629 printk(KERN_WARNING "CIFS: prefix too long\n");
1630 goto cifs_parse_mount_err;
1633 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1634 if (vol->prepath == NULL) {
1635 printk(KERN_WARNING "CIFS: no memory "
1636 "for path prefix\n");
1637 goto cifs_parse_mount_err;
1640 if (string[0] != '/') {
1641 vol->prepath[0] = '/';
1642 strcpy(vol->prepath+1, string);
1644 strcpy(vol->prepath, string);
1648 string = match_strdup(args);
1652 if (strnlen(string, 1024) >= 65) {
1653 printk(KERN_WARNING "CIFS: iocharset name "
1655 goto cifs_parse_mount_err;
1658 if (strnicmp(string, "default", 7) != 0) {
1659 vol->iocharset = kstrdup(string,
1661 if (!vol->iocharset) {
1662 printk(KERN_WARNING "CIFS: no memory"
1664 goto cifs_parse_mount_err;
1667 /* if iocharset not set then load_nls_default
1670 cFYI(1, "iocharset set to %s", string);
1673 string = match_strdup(args);
1677 if (strnicmp(string, "TCP_NODELAY", 11) == 0)
1678 vol->sockopt_tcp_nodelay = 1;
1680 case Opt_netbiosname:
1681 string = match_strdup(args);
1685 memset(vol->source_rfc1001_name, 0x20,
1688 * FIXME: are there cases in which a comma can
1689 * be valid in workstation netbios name (and
1690 * need special handling)?
1692 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1693 /* don't ucase netbiosname for user */
1696 vol->source_rfc1001_name[i] = string[i];
1698 /* The string has 16th byte zero still from
1699 * set at top of the function
1701 if (i == RFC1001_NAME_LEN && string[i] != 0)
1702 printk(KERN_WARNING "CIFS: netbiosname"
1703 " longer than 15 truncated.\n");
1707 /* servernetbiosname specified override *SMBSERVER */
1708 string = match_strdup(args);
1712 /* last byte, type, is 0x20 for servr type */
1713 memset(vol->target_rfc1001_name, 0x20,
1714 RFC1001_NAME_LEN_WITH_NULL);
1716 /* BB are there cases in which a comma can be
1717 valid in this workstation netbios name
1718 (and need special handling)? */
1720 /* user or mount helper must uppercase the
1722 for (i = 0; i < 15; i++) {
1725 vol->target_rfc1001_name[i] = string[i];
1727 /* The string has 16th byte zero still from
1728 set at top of the function */
1729 if (i == RFC1001_NAME_LEN && string[i] != 0)
1730 printk(KERN_WARNING "CIFS: server net"
1731 "biosname longer than 15 truncated.\n");
1734 string = match_strdup(args);
1738 if (strnicmp(string, "1", 1) == 0) {
1739 /* This is the default */
1742 /* For all other value, error */
1743 printk(KERN_WARNING "CIFS: Invalid version"
1745 goto cifs_parse_mount_err;
1747 string = match_strdup(args);
1751 if (cifs_parse_smb_version(string, vol) != 0)
1752 goto cifs_parse_mount_err;
1755 string = match_strdup(args);
1759 if (cifs_parse_security_flavors(string, vol) != 0)
1760 goto cifs_parse_mount_err;
1763 cache_specified = true;
1764 string = match_strdup(args);
1768 if (cifs_parse_cache_flavor(string, vol) != 0)
1769 goto cifs_parse_mount_err;
1773 * An option we don't recognize. Save it off for later
1774 * if we haven't already found one
1780 /* Free up any allocated string */
1785 if (!sloppy && invalid) {
1786 printk(KERN_ERR "CIFS: Unknown mount option \"%s\"\n", invalid);
1787 goto cifs_parse_mount_err;
1791 /* Muliuser mounts require CONFIG_KEYS support */
1792 if (vol->multiuser) {
1793 cERROR(1, "Multiuser mounts require kernels with "
1794 "CONFIG_KEYS enabled.");
1795 goto cifs_parse_mount_err;
1799 if (vol->UNCip == NULL)
1800 vol->UNCip = &vol->UNC[2];
1803 vol->override_uid = override_uid;
1804 else if (override_uid == 1)
1805 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1806 "specified with no uid= option.\n");
1809 vol->override_gid = override_gid;
1810 else if (override_gid == 1)
1811 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1812 "specified with no gid= option.\n");
1814 /* FIXME: remove this block in 3.7 */
1815 if (!cache_specified && !cache_warned) {
1816 cache_warned = true;
1817 printk(KERN_NOTICE "CIFS: no cache= option specified, using "
1818 "\"cache=loose\". This default will change "
1819 "to \"cache=strict\" in 3.7.\n");
1822 kfree(mountdata_copy);
1826 printk(KERN_WARNING "Could not allocate temporary buffer\n");
1827 cifs_parse_mount_err:
1829 kfree(mountdata_copy);
1833 /** Returns true if srcaddr isn't specified and rhs isn't
1834 * specified, or if srcaddr is specified and
1835 * matches the IP address of the rhs argument.
1838 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1840 switch (srcaddr->sa_family) {
1842 return (rhs->sa_family == AF_UNSPEC);
1844 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1845 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1846 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1849 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1850 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1851 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1855 return false; /* don't expect to be here */
1860 * If no port is specified in addr structure, we try to match with 445 port
1861 * and if it fails - with 139 ports. It should be called only if address
1862 * families of server and addr are equal.
1865 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1867 __be16 port, *sport;
1869 switch (addr->sa_family) {
1871 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1872 port = ((struct sockaddr_in *) addr)->sin_port;
1875 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1876 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1884 port = htons(CIFS_PORT);
1888 port = htons(RFC1001_PORT);
1891 return port == *sport;
1895 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1896 struct sockaddr *srcaddr)
1898 switch (addr->sa_family) {
1900 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1901 struct sockaddr_in *srv_addr4 =
1902 (struct sockaddr_in *)&server->dstaddr;
1904 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1909 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1910 struct sockaddr_in6 *srv_addr6 =
1911 (struct sockaddr_in6 *)&server->dstaddr;
1913 if (!ipv6_addr_equal(&addr6->sin6_addr,
1914 &srv_addr6->sin6_addr))
1916 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
1922 return false; /* don't expect to be here */
1925 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1932 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
1934 unsigned int secFlags;
1936 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
1937 secFlags = vol->secFlg;
1939 secFlags = global_secflags | vol->secFlg;
1941 switch (server->secType) {
1943 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
1947 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
1951 if (!(secFlags & CIFSSEC_MAY_NTLM))
1955 if (!(secFlags & CIFSSEC_MAY_KRB5))
1959 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
1963 /* shouldn't happen */
1967 /* now check if signing mode is acceptable */
1968 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
1969 (server->sec_mode & SECMODE_SIGN_REQUIRED))
1971 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
1973 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
1979 static int match_server(struct TCP_Server_Info *server, struct sockaddr *addr,
1980 struct smb_vol *vol)
1982 if ((server->vals != vol->vals) || (server->ops != vol->ops))
1985 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
1988 if (!match_address(server, addr,
1989 (struct sockaddr *)&vol->srcaddr))
1992 if (!match_port(server, addr))
1995 if (!match_security(server, vol))
2001 static struct TCP_Server_Info *
2002 cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
2004 struct TCP_Server_Info *server;
2006 spin_lock(&cifs_tcp_ses_lock);
2007 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2008 if (!match_server(server, addr, vol))
2011 ++server->srv_count;
2012 spin_unlock(&cifs_tcp_ses_lock);
2013 cFYI(1, "Existing tcp session with server found");
2016 spin_unlock(&cifs_tcp_ses_lock);
2021 cifs_put_tcp_session(struct TCP_Server_Info *server)
2023 struct task_struct *task;
2025 spin_lock(&cifs_tcp_ses_lock);
2026 if (--server->srv_count > 0) {
2027 spin_unlock(&cifs_tcp_ses_lock);
2031 put_net(cifs_net_ns(server));
2033 list_del_init(&server->tcp_ses_list);
2034 spin_unlock(&cifs_tcp_ses_lock);
2036 cancel_delayed_work_sync(&server->echo);
2038 spin_lock(&GlobalMid_Lock);
2039 server->tcpStatus = CifsExiting;
2040 spin_unlock(&GlobalMid_Lock);
2042 cifs_crypto_shash_release(server);
2043 cifs_fscache_release_client_cookie(server);
2045 kfree(server->session_key.response);
2046 server->session_key.response = NULL;
2047 server->session_key.len = 0;
2049 task = xchg(&server->tsk, NULL);
2051 force_sig(SIGKILL, task);
2054 static struct TCP_Server_Info *
2055 cifs_get_tcp_session(struct smb_vol *volume_info)
2057 struct TCP_Server_Info *tcp_ses = NULL;
2058 struct sockaddr_storage addr;
2059 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
2060 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
2063 memset(&addr, 0, sizeof(struct sockaddr_storage));
2065 cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
2067 if (volume_info->UNCip && volume_info->UNC) {
2068 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
2070 strlen(volume_info->UNCip),
2073 /* we failed translating address */
2077 } else if (volume_info->UNCip) {
2078 /* BB using ip addr as tcp_ses name to connect to the
2080 cERROR(1, "Connecting to DFS root not implemented yet");
2083 } else /* which tcp_sess DFS root would we conect to */ {
2084 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
2085 "unc=//192.168.1.100/public) specified");
2090 /* see if we already have a matching tcp_ses */
2091 tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
2095 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2101 rc = cifs_crypto_shash_allocate(tcp_ses);
2103 cERROR(1, "could not setup hash structures rc %d", rc);
2107 tcp_ses->ops = volume_info->ops;
2108 tcp_ses->vals = volume_info->vals;
2109 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2110 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2111 if (IS_ERR(tcp_ses->hostname)) {
2112 rc = PTR_ERR(tcp_ses->hostname);
2113 goto out_err_crypto_release;
2116 tcp_ses->noblocksnd = volume_info->noblocksnd;
2117 tcp_ses->noautotune = volume_info->noautotune;
2118 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2119 tcp_ses->in_flight = 0;
2120 tcp_ses->credits = 1;
2121 init_waitqueue_head(&tcp_ses->response_q);
2122 init_waitqueue_head(&tcp_ses->request_q);
2123 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2124 mutex_init(&tcp_ses->srv_mutex);
2125 memcpy(tcp_ses->workstation_RFC1001_name,
2126 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2127 memcpy(tcp_ses->server_RFC1001_name,
2128 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2129 tcp_ses->session_estab = false;
2130 tcp_ses->sequence_number = 0;
2131 tcp_ses->lstrp = jiffies;
2132 spin_lock_init(&tcp_ses->req_lock);
2133 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2134 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2135 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2138 * at this point we are the only ones with the pointer
2139 * to the struct since the kernel thread not created yet
2140 * no need to spinlock this init of tcpStatus or srv_count
2142 tcp_ses->tcpStatus = CifsNew;
2143 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2144 sizeof(tcp_ses->srcaddr));
2145 ++tcp_ses->srv_count;
2147 if (addr.ss_family == AF_INET6) {
2148 cFYI(1, "attempting ipv6 connect");
2149 /* BB should we allow ipv6 on port 139? */
2150 /* other OS never observed in Wild doing 139 with v6 */
2151 memcpy(&tcp_ses->dstaddr, sin_server6,
2152 sizeof(struct sockaddr_in6));
2154 memcpy(&tcp_ses->dstaddr, sin_server,
2155 sizeof(struct sockaddr_in));
2157 rc = ip_connect(tcp_ses);
2159 cERROR(1, "Error connecting to socket. Aborting operation");
2160 goto out_err_crypto_release;
2164 * since we're in a cifs function already, we know that
2165 * this will succeed. No need for try_module_get().
2167 __module_get(THIS_MODULE);
2168 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2170 if (IS_ERR(tcp_ses->tsk)) {
2171 rc = PTR_ERR(tcp_ses->tsk);
2172 cERROR(1, "error %d create cifsd thread", rc);
2173 module_put(THIS_MODULE);
2174 goto out_err_crypto_release;
2176 tcp_ses->tcpStatus = CifsNeedNegotiate;
2178 /* thread spawned, put it on the list */
2179 spin_lock(&cifs_tcp_ses_lock);
2180 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2181 spin_unlock(&cifs_tcp_ses_lock);
2183 cifs_fscache_get_client_cookie(tcp_ses);
2185 /* queue echo request delayed work */
2186 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
2190 out_err_crypto_release:
2191 cifs_crypto_shash_release(tcp_ses);
2193 put_net(cifs_net_ns(tcp_ses));
2197 if (!IS_ERR(tcp_ses->hostname))
2198 kfree(tcp_ses->hostname);
2199 if (tcp_ses->ssocket)
2200 sock_release(tcp_ses->ssocket);
2206 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2208 switch (ses->server->secType) {
2210 if (vol->cred_uid != ses->cred_uid)
2214 /* NULL username means anonymous session */
2215 if (ses->user_name == NULL) {
2221 /* anything else takes username/password */
2222 if (strncmp(ses->user_name,
2223 vol->username ? vol->username : "",
2226 if (strlen(vol->username) != 0 &&
2227 ses->password != NULL &&
2228 strncmp(ses->password,
2229 vol->password ? vol->password : "",
2236 static struct cifs_ses *
2237 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2239 struct cifs_ses *ses;
2241 spin_lock(&cifs_tcp_ses_lock);
2242 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2243 if (!match_session(ses, vol))
2246 spin_unlock(&cifs_tcp_ses_lock);
2249 spin_unlock(&cifs_tcp_ses_lock);
2254 cifs_put_smb_ses(struct cifs_ses *ses)
2257 struct TCP_Server_Info *server = ses->server;
2259 cFYI(1, "%s: ses_count=%d", __func__, ses->ses_count);
2260 spin_lock(&cifs_tcp_ses_lock);
2261 if (--ses->ses_count > 0) {
2262 spin_unlock(&cifs_tcp_ses_lock);
2266 list_del_init(&ses->smb_ses_list);
2267 spin_unlock(&cifs_tcp_ses_lock);
2269 if (ses->status == CifsGood) {
2271 CIFSSMBLogoff(xid, ses);
2275 cifs_put_tcp_session(server);
2280 /* strlen("cifs:a:") + INET6_ADDRSTRLEN + 1 */
2281 #define CIFSCREDS_DESC_SIZE (7 + INET6_ADDRSTRLEN + 1)
2283 /* Populate username and pw fields from keyring if possible */
2285 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2288 char *desc, *delim, *payload;
2291 struct TCP_Server_Info *server = ses->server;
2292 struct sockaddr_in *sa;
2293 struct sockaddr_in6 *sa6;
2294 struct user_key_payload *upayload;
2296 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2300 /* try to find an address key first */
2301 switch (server->dstaddr.ss_family) {
2303 sa = (struct sockaddr_in *)&server->dstaddr;
2304 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2307 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2308 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2311 cFYI(1, "Bad ss_family (%hu)", server->dstaddr.ss_family);
2316 cFYI(1, "%s: desc=%s", __func__, desc);
2317 key = request_key(&key_type_logon, desc, "");
2319 if (!ses->domainName) {
2320 cFYI(1, "domainName is NULL");
2325 /* didn't work, try to find a domain key */
2326 sprintf(desc, "cifs:d:%s", ses->domainName);
2327 cFYI(1, "%s: desc=%s", __func__, desc);
2328 key = request_key(&key_type_logon, desc, "");
2335 down_read(&key->sem);
2336 upayload = key->payload.data;
2337 if (IS_ERR_OR_NULL(upayload)) {
2338 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2342 /* find first : in payload */
2343 payload = (char *)upayload->data;
2344 delim = strnchr(payload, upayload->datalen, ':');
2345 cFYI(1, "payload=%s", payload);
2347 cFYI(1, "Unable to find ':' in payload (datalen=%d)",
2353 len = delim - payload;
2354 if (len > MAX_USERNAME_SIZE || len <= 0) {
2355 cFYI(1, "Bad value from username search (len=%zd)", len);
2360 vol->username = kstrndup(payload, len, GFP_KERNEL);
2361 if (!vol->username) {
2362 cFYI(1, "Unable to allocate %zd bytes for username", len);
2366 cFYI(1, "%s: username=%s", __func__, vol->username);
2368 len = key->datalen - (len + 1);
2369 if (len > MAX_PASSWORD_SIZE || len <= 0) {
2370 cFYI(1, "Bad len for password search (len=%zd)", len);
2372 kfree(vol->username);
2373 vol->username = NULL;
2378 vol->password = kstrndup(delim, len, GFP_KERNEL);
2379 if (!vol->password) {
2380 cFYI(1, "Unable to allocate %zd bytes for password", len);
2382 kfree(vol->username);
2383 vol->username = NULL;
2392 cFYI(1, "%s: returning %d", __func__, rc);
2395 #else /* ! CONFIG_KEYS */
2397 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2398 struct cifs_ses *ses __attribute__((unused)))
2402 #endif /* CONFIG_KEYS */
2404 static bool warned_on_ntlm; /* globals init to false automatically */
2406 static struct cifs_ses *
2407 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2411 struct cifs_ses *ses;
2412 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2413 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2417 ses = cifs_find_smb_ses(server, volume_info);
2419 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
2421 mutex_lock(&ses->session_mutex);
2422 rc = cifs_negotiate_protocol(xid, ses);
2424 mutex_unlock(&ses->session_mutex);
2425 /* problem -- put our ses reference */
2426 cifs_put_smb_ses(ses);
2430 if (ses->need_reconnect) {
2431 cFYI(1, "Session needs reconnect");
2432 rc = cifs_setup_session(xid, ses,
2433 volume_info->local_nls);
2435 mutex_unlock(&ses->session_mutex);
2436 /* problem -- put our reference */
2437 cifs_put_smb_ses(ses);
2442 mutex_unlock(&ses->session_mutex);
2444 /* existing SMB ses has a server reference already */
2445 cifs_put_tcp_session(server);
2450 cFYI(1, "Existing smb sess not found");
2451 ses = sesInfoAlloc();
2455 /* new SMB session uses our server ref */
2456 ses->server = server;
2457 if (server->dstaddr.ss_family == AF_INET6)
2458 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2460 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2462 if (volume_info->username) {
2463 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2464 if (!ses->user_name)
2468 /* volume_info->password freed at unmount */
2469 if (volume_info->password) {
2470 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2474 if (volume_info->domainname) {
2475 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2476 if (!ses->domainName)
2479 ses->cred_uid = volume_info->cred_uid;
2480 ses->linux_uid = volume_info->linux_uid;
2482 /* ntlmv2 is much stronger than ntlm security, and has been broadly
2483 supported for many years, time to update default security mechanism */
2484 if ((volume_info->secFlg == 0) && warned_on_ntlm == false) {
2485 warned_on_ntlm = true;
2486 cERROR(1, "default security mechanism requested. The default "
2487 "security mechanism will be upgraded from ntlm to "
2488 "ntlmv2 in kernel release 3.3");
2490 ses->overrideSecFlg = volume_info->secFlg;
2492 mutex_lock(&ses->session_mutex);
2493 rc = cifs_negotiate_protocol(xid, ses);
2495 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2496 mutex_unlock(&ses->session_mutex);
2500 /* success, put it on the list */
2501 spin_lock(&cifs_tcp_ses_lock);
2502 list_add(&ses->smb_ses_list, &server->smb_ses_list);
2503 spin_unlock(&cifs_tcp_ses_lock);
2514 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2516 if (tcon->tidStatus == CifsExiting)
2518 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2523 static struct cifs_tcon *
2524 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2526 struct list_head *tmp;
2527 struct cifs_tcon *tcon;
2529 spin_lock(&cifs_tcp_ses_lock);
2530 list_for_each(tmp, &ses->tcon_list) {
2531 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2532 if (!match_tcon(tcon, unc))
2535 spin_unlock(&cifs_tcp_ses_lock);
2538 spin_unlock(&cifs_tcp_ses_lock);
2543 cifs_put_tcon(struct cifs_tcon *tcon)
2546 struct cifs_ses *ses = tcon->ses;
2548 cFYI(1, "%s: tc_count=%d", __func__, tcon->tc_count);
2549 spin_lock(&cifs_tcp_ses_lock);
2550 if (--tcon->tc_count > 0) {
2551 spin_unlock(&cifs_tcp_ses_lock);
2555 list_del_init(&tcon->tcon_list);
2556 spin_unlock(&cifs_tcp_ses_lock);
2559 CIFSSMBTDis(xid, tcon);
2562 cifs_fscache_release_super_cookie(tcon);
2564 cifs_put_smb_ses(ses);
2567 static struct cifs_tcon *
2568 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2571 struct cifs_tcon *tcon;
2573 tcon = cifs_find_tcon(ses, volume_info->UNC);
2575 cFYI(1, "Found match on UNC path");
2576 /* existing tcon already has a reference */
2577 cifs_put_smb_ses(ses);
2578 if (tcon->seal != volume_info->seal)
2579 cERROR(1, "transport encryption setting "
2580 "conflicts with existing tid");
2584 tcon = tconInfoAlloc();
2591 if (volume_info->password) {
2592 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2593 if (!tcon->password) {
2599 if (strchr(volume_info->UNC + 3, '\\') == NULL
2600 && strchr(volume_info->UNC + 3, '/') == NULL) {
2601 cERROR(1, "Missing share name");
2606 /* BB Do we need to wrap session_mutex around
2607 * this TCon call and Unix SetFS as
2608 * we do on SessSetup and reconnect? */
2610 rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
2612 cFYI(1, "CIFS Tcon rc = %d", rc);
2616 if (volume_info->nodfs) {
2617 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2618 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2620 tcon->seal = volume_info->seal;
2621 /* we can have only one retry value for a connection
2622 to a share so for resources mounted more than once
2623 to the same server share the last value passed in
2624 for the retry flag is used */
2625 tcon->retry = volume_info->retry;
2626 tcon->nocase = volume_info->nocase;
2627 tcon->local_lease = volume_info->local_lease;
2629 spin_lock(&cifs_tcp_ses_lock);
2630 list_add(&tcon->tcon_list, &ses->tcon_list);
2631 spin_unlock(&cifs_tcp_ses_lock);
2633 cifs_fscache_get_super_cookie(tcon);
2643 cifs_put_tlink(struct tcon_link *tlink)
2645 if (!tlink || IS_ERR(tlink))
2648 if (!atomic_dec_and_test(&tlink->tl_count) ||
2649 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2650 tlink->tl_time = jiffies;
2654 if (!IS_ERR(tlink_tcon(tlink)))
2655 cifs_put_tcon(tlink_tcon(tlink));
2660 static inline struct tcon_link *
2661 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2663 return cifs_sb->master_tlink;
2667 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2669 struct cifs_sb_info *old = CIFS_SB(sb);
2670 struct cifs_sb_info *new = mnt_data->cifs_sb;
2672 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2675 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2676 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2680 * We want to share sb only if we don't specify an r/wsize or
2681 * specified r/wsize is greater than or equal to existing one.
2683 if (new->wsize && new->wsize < old->wsize)
2686 if (new->rsize && new->rsize < old->rsize)
2689 if (old->mnt_uid != new->mnt_uid || old->mnt_gid != new->mnt_gid)
2692 if (old->mnt_file_mode != new->mnt_file_mode ||
2693 old->mnt_dir_mode != new->mnt_dir_mode)
2696 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2699 if (old->actimeo != new->actimeo)
2706 cifs_match_super(struct super_block *sb, void *data)
2708 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2709 struct smb_vol *volume_info;
2710 struct cifs_sb_info *cifs_sb;
2711 struct TCP_Server_Info *tcp_srv;
2712 struct cifs_ses *ses;
2713 struct cifs_tcon *tcon;
2714 struct tcon_link *tlink;
2715 struct sockaddr_storage addr;
2718 memset(&addr, 0, sizeof(struct sockaddr_storage));
2720 spin_lock(&cifs_tcp_ses_lock);
2721 cifs_sb = CIFS_SB(sb);
2722 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2723 if (IS_ERR(tlink)) {
2724 spin_unlock(&cifs_tcp_ses_lock);
2727 tcon = tlink_tcon(tlink);
2729 tcp_srv = ses->server;
2731 volume_info = mnt_data->vol;
2733 if (!volume_info->UNCip || !volume_info->UNC)
2736 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
2738 strlen(volume_info->UNCip),
2743 if (!match_server(tcp_srv, (struct sockaddr *)&addr, volume_info) ||
2744 !match_session(ses, volume_info) ||
2745 !match_tcon(tcon, volume_info->UNC)) {
2750 rc = compare_mount_options(sb, mnt_data);
2752 spin_unlock(&cifs_tcp_ses_lock);
2753 cifs_put_tlink(tlink);
2758 get_dfs_path(int xid, struct cifs_ses *pSesInfo, const char *old_path,
2759 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
2760 struct dfs_info3_param **preferrals, int remap)
2765 *pnum_referrals = 0;
2768 if (pSesInfo->ipc_tid == 0) {
2769 temp_unc = kmalloc(2 /* for slashes */ +
2770 strnlen(pSesInfo->serverName,
2771 SERVER_NAME_LEN_WITH_NULL * 2)
2772 + 1 + 4 /* slash IPC$ */ + 2,
2774 if (temp_unc == NULL)
2778 strcpy(temp_unc + 2, pSesInfo->serverName);
2779 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2780 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
2781 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
2785 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
2786 pnum_referrals, nls_codepage, remap);
2787 /* BB map targetUNCs to dfs_info3 structures, here or
2788 in CIFSGetDFSRefer BB */
2793 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2794 static struct lock_class_key cifs_key[2];
2795 static struct lock_class_key cifs_slock_key[2];
2798 cifs_reclassify_socket4(struct socket *sock)
2800 struct sock *sk = sock->sk;
2801 BUG_ON(sock_owned_by_user(sk));
2802 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2803 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2807 cifs_reclassify_socket6(struct socket *sock)
2809 struct sock *sk = sock->sk;
2810 BUG_ON(sock_owned_by_user(sk));
2811 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2812 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2816 cifs_reclassify_socket4(struct socket *sock)
2821 cifs_reclassify_socket6(struct socket *sock)
2826 /* See RFC1001 section 14 on representation of Netbios names */
2827 static void rfc1002mangle(char *target, char *source, unsigned int length)
2831 for (i = 0, j = 0; i < (length); i++) {
2832 /* mask a nibble at a time and encode */
2833 target[j] = 'A' + (0x0F & (source[i] >> 4));
2834 target[j+1] = 'A' + (0x0F & source[i]);
2841 bind_socket(struct TCP_Server_Info *server)
2844 if (server->srcaddr.ss_family != AF_UNSPEC) {
2845 /* Bind to the specified local IP address */
2846 struct socket *socket = server->ssocket;
2847 rc = socket->ops->bind(socket,
2848 (struct sockaddr *) &server->srcaddr,
2849 sizeof(server->srcaddr));
2851 struct sockaddr_in *saddr4;
2852 struct sockaddr_in6 *saddr6;
2853 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2854 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2855 if (saddr6->sin6_family == AF_INET6)
2857 "Failed to bind to: %pI6c, error: %d",
2858 &saddr6->sin6_addr, rc);
2861 "Failed to bind to: %pI4, error: %d",
2862 &saddr4->sin_addr.s_addr, rc);
2869 ip_rfc1001_connect(struct TCP_Server_Info *server)
2873 * some servers require RFC1001 sessinit before sending
2874 * negprot - BB check reconnection in case where second
2875 * sessinit is sent but no second negprot
2877 struct rfc1002_session_packet *ses_init_buf;
2878 struct smb_hdr *smb_buf;
2879 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2882 ses_init_buf->trailer.session_req.called_len = 32;
2884 if (server->server_RFC1001_name &&
2885 server->server_RFC1001_name[0] != 0)
2886 rfc1002mangle(ses_init_buf->trailer.
2887 session_req.called_name,
2888 server->server_RFC1001_name,
2889 RFC1001_NAME_LEN_WITH_NULL);
2891 rfc1002mangle(ses_init_buf->trailer.
2892 session_req.called_name,
2893 DEFAULT_CIFS_CALLED_NAME,
2894 RFC1001_NAME_LEN_WITH_NULL);
2896 ses_init_buf->trailer.session_req.calling_len = 32;
2899 * calling name ends in null (byte 16) from old smb
2902 if (server->workstation_RFC1001_name &&
2903 server->workstation_RFC1001_name[0] != 0)
2904 rfc1002mangle(ses_init_buf->trailer.
2905 session_req.calling_name,
2906 server->workstation_RFC1001_name,
2907 RFC1001_NAME_LEN_WITH_NULL);
2909 rfc1002mangle(ses_init_buf->trailer.
2910 session_req.calling_name,
2912 RFC1001_NAME_LEN_WITH_NULL);
2914 ses_init_buf->trailer.session_req.scope1 = 0;
2915 ses_init_buf->trailer.session_req.scope2 = 0;
2916 smb_buf = (struct smb_hdr *)ses_init_buf;
2918 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2919 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
2920 rc = smb_send(server, smb_buf, 0x44);
2921 kfree(ses_init_buf);
2923 * RFC1001 layer in at least one server
2924 * requires very short break before negprot
2925 * presumably because not expecting negprot
2926 * to follow so fast. This is a simple
2927 * solution that works without
2928 * complicating the code and causes no
2929 * significant slowing down on mount
2932 usleep_range(1000, 2000);
2935 * else the negprot may still work without this
2936 * even though malloc failed
2943 generic_ip_connect(struct TCP_Server_Info *server)
2948 struct socket *socket = server->ssocket;
2949 struct sockaddr *saddr;
2951 saddr = (struct sockaddr *) &server->dstaddr;
2953 if (server->dstaddr.ss_family == AF_INET6) {
2954 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2955 slen = sizeof(struct sockaddr_in6);
2958 sport = ((struct sockaddr_in *) saddr)->sin_port;
2959 slen = sizeof(struct sockaddr_in);
2963 if (socket == NULL) {
2964 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2965 IPPROTO_TCP, &socket, 1);
2967 cERROR(1, "Error %d creating socket", rc);
2968 server->ssocket = NULL;
2972 /* BB other socket options to set KEEPALIVE, NODELAY? */
2973 cFYI(1, "Socket created");
2974 server->ssocket = socket;
2975 socket->sk->sk_allocation = GFP_NOFS;
2976 if (sfamily == AF_INET6)
2977 cifs_reclassify_socket6(socket);
2979 cifs_reclassify_socket4(socket);
2982 rc = bind_socket(server);
2987 * Eventually check for other socket options to change from
2988 * the default. sock_setsockopt not used because it expects
2991 socket->sk->sk_rcvtimeo = 7 * HZ;
2992 socket->sk->sk_sndtimeo = 5 * HZ;
2994 /* make the bufsizes depend on wsize/rsize and max requests */
2995 if (server->noautotune) {
2996 if (socket->sk->sk_sndbuf < (200 * 1024))
2997 socket->sk->sk_sndbuf = 200 * 1024;
2998 if (socket->sk->sk_rcvbuf < (140 * 1024))
2999 socket->sk->sk_rcvbuf = 140 * 1024;
3002 if (server->tcp_nodelay) {
3004 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3005 (char *)&val, sizeof(val));
3007 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
3010 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
3011 socket->sk->sk_sndbuf,
3012 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3014 rc = socket->ops->connect(socket, saddr, slen, 0);
3016 cFYI(1, "Error %d connecting to server", rc);
3017 sock_release(socket);
3018 server->ssocket = NULL;
3022 if (sport == htons(RFC1001_PORT))
3023 rc = ip_rfc1001_connect(server);
3029 ip_connect(struct TCP_Server_Info *server)
3032 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3033 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3035 if (server->dstaddr.ss_family == AF_INET6)
3036 sport = &addr6->sin6_port;
3038 sport = &addr->sin_port;
3043 /* try with 445 port at first */
3044 *sport = htons(CIFS_PORT);
3046 rc = generic_ip_connect(server);
3050 /* if it failed, try with 139 port */
3051 *sport = htons(RFC1001_PORT);
3054 return generic_ip_connect(server);
3057 void reset_cifs_unix_caps(int xid, struct cifs_tcon *tcon,
3058 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3060 /* if we are reconnecting then should we check to see if
3061 * any requested capabilities changed locally e.g. via
3062 * remount but we can not do much about it here
3063 * if they have (even if we could detect it by the following)
3064 * Perhaps we could add a backpointer to array of sb from tcon
3065 * or if we change to make all sb to same share the same
3066 * sb as NFS - then we only have one backpointer to sb.
3067 * What if we wanted to mount the server share twice once with
3068 * and once without posixacls or posix paths? */
3069 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3071 if (vol_info && vol_info->no_linux_ext) {
3072 tcon->fsUnixInfo.Capability = 0;
3073 tcon->unix_ext = 0; /* Unix Extensions disabled */
3074 cFYI(1, "Linux protocol extensions disabled");
3076 } else if (vol_info)
3077 tcon->unix_ext = 1; /* Unix Extensions supported */
3079 if (tcon->unix_ext == 0) {
3080 cFYI(1, "Unix extensions disabled so not set on reconnect");
3084 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3085 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3086 cFYI(1, "unix caps which server supports %lld", cap);
3087 /* check for reconnect case in which we do not
3088 want to change the mount behavior if we can avoid it */
3089 if (vol_info == NULL) {
3090 /* turn off POSIX ACL and PATHNAMES if not set
3091 originally at mount time */
3092 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3093 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3094 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3095 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3096 cERROR(1, "POSIXPATH support change");
3097 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3098 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3099 cERROR(1, "possible reconnect error");
3100 cERROR(1, "server disabled POSIX path support");
3104 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3105 cERROR(1, "per-share encryption not supported yet");
3107 cap &= CIFS_UNIX_CAP_MASK;
3108 if (vol_info && vol_info->no_psx_acl)
3109 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3110 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3111 cFYI(1, "negotiated posix acl support");
3113 cifs_sb->mnt_cifs_flags |=
3114 CIFS_MOUNT_POSIXACL;
3117 if (vol_info && vol_info->posix_paths == 0)
3118 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3119 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3120 cFYI(1, "negotiate posix pathnames");
3122 cifs_sb->mnt_cifs_flags |=
3123 CIFS_MOUNT_POSIX_PATHS;
3126 cFYI(1, "Negotiate caps 0x%x", (int)cap);
3127 #ifdef CONFIG_CIFS_DEBUG2
3128 if (cap & CIFS_UNIX_FCNTL_CAP)
3129 cFYI(1, "FCNTL cap");
3130 if (cap & CIFS_UNIX_EXTATTR_CAP)
3131 cFYI(1, "EXTATTR cap");
3132 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3133 cFYI(1, "POSIX path cap");
3134 if (cap & CIFS_UNIX_XATTR_CAP)
3135 cFYI(1, "XATTR cap");
3136 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3137 cFYI(1, "POSIX ACL cap");
3138 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3139 cFYI(1, "very large read cap");
3140 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3141 cFYI(1, "very large write cap");
3142 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3143 cFYI(1, "transport encryption cap");
3144 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3145 cFYI(1, "mandatory transport encryption cap");
3146 #endif /* CIFS_DEBUG2 */
3147 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3148 if (vol_info == NULL) {
3149 cFYI(1, "resetting capabilities failed");
3151 cERROR(1, "Negotiating Unix capabilities "
3152 "with the server failed. Consider "
3153 "mounting with the Unix Extensions "
3154 "disabled if problems are found "
3155 "by specifying the nounix mount "
3162 void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3163 struct cifs_sb_info *cifs_sb)
3165 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3167 spin_lock_init(&cifs_sb->tlink_tree_lock);
3168 cifs_sb->tlink_tree = RB_ROOT;
3171 * Temporarily set r/wsize for matching superblock. If we end up using
3172 * new sb then client will later negotiate it downward if needed.
3174 cifs_sb->rsize = pvolume_info->rsize;
3175 cifs_sb->wsize = pvolume_info->wsize;
3177 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3178 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3179 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3180 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3181 cFYI(1, "file mode: 0x%hx dir mode: 0x%hx",
3182 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3184 cifs_sb->actimeo = pvolume_info->actimeo;
3185 cifs_sb->local_nls = pvolume_info->local_nls;
3187 if (pvolume_info->noperm)
3188 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3189 if (pvolume_info->setuids)
3190 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3191 if (pvolume_info->server_ino)
3192 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3193 if (pvolume_info->remap)
3194 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3195 if (pvolume_info->no_xattr)
3196 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3197 if (pvolume_info->sfu_emul)
3198 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3199 if (pvolume_info->nobrl)
3200 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3201 if (pvolume_info->nostrictsync)
3202 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3203 if (pvolume_info->mand_lock)
3204 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3205 if (pvolume_info->rwpidforward)
3206 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3207 if (pvolume_info->cifs_acl)
3208 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3209 if (pvolume_info->backupuid_specified) {
3210 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3211 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3213 if (pvolume_info->backupgid_specified) {
3214 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3215 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3217 if (pvolume_info->override_uid)
3218 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3219 if (pvolume_info->override_gid)
3220 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3221 if (pvolume_info->dynperm)
3222 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3223 if (pvolume_info->fsc)
3224 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3225 if (pvolume_info->multiuser)
3226 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3227 CIFS_MOUNT_NO_PERM);
3228 if (pvolume_info->strict_io)
3229 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3230 if (pvolume_info->direct_io) {
3231 cFYI(1, "mounting share using direct i/o");
3232 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3234 if (pvolume_info->mfsymlinks) {
3235 if (pvolume_info->sfu_emul) {
3236 cERROR(1, "mount option mfsymlinks ignored if sfu "
3237 "mount option is used");
3239 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3243 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3244 cERROR(1, "mount option dynperm ignored if cifsacl "
3245 "mount option supported");
3249 * When the server supports very large reads and writes via POSIX extensions,
3250 * we can allow up to 2^24-1, minus the size of a READ/WRITE_AND_X header, not
3251 * including the RFC1001 length.
3253 * Note that this might make for "interesting" allocation problems during
3254 * writeback however as we have to allocate an array of pointers for the
3255 * pages. A 16M write means ~32kb page array with PAGE_CACHE_SIZE == 4096.
3257 * For reads, there is a similar problem as we need to allocate an array
3258 * of kvecs to handle the receive, though that should only need to be done
3261 #define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
3262 #define CIFS_MAX_RSIZE ((1<<24) - sizeof(READ_RSP) + 4)
3265 * When the server doesn't allow large posix writes, only allow a rsize/wsize
3266 * of 2^17-1 minus the size of the call header. That allows for a read or
3267 * write up to the maximum size described by RFC1002.
3269 #define CIFS_MAX_RFC1002_WSIZE ((1<<17) - 1 - sizeof(WRITE_REQ) + 4)
3270 #define CIFS_MAX_RFC1002_RSIZE ((1<<17) - 1 - sizeof(READ_RSP) + 4)
3273 * The default wsize is 1M. find_get_pages seems to return a maximum of 256
3274 * pages in a single call. With PAGE_CACHE_SIZE == 4k, this means we can fill
3275 * a single wsize request with a single call.
3277 #define CIFS_DEFAULT_IOSIZE (1024 * 1024)
3280 * Windows only supports a max of 60kb reads and 65535 byte writes. Default to
3281 * those values when posix extensions aren't in force. In actuality here, we
3282 * use 65536 to allow for a write that is a multiple of 4k. Most servers seem
3283 * to be ok with the extra byte even though Windows doesn't send writes that
3288 * http://blogs.msdn.com/b/openspecification/archive/2009/04/10/smb-maximum-transmit-buffer-size-and-performance-tuning.aspx
3290 #define CIFS_DEFAULT_NON_POSIX_RSIZE (60 * 1024)
3291 #define CIFS_DEFAULT_NON_POSIX_WSIZE (65536)
3294 * On hosts with high memory, we can't currently support wsize/rsize that are
3295 * larger than we can kmap at once. Cap the rsize/wsize at
3296 * LAST_PKMAP * PAGE_SIZE. We'll never be able to fill a read or write request
3297 * larger than that anyway.
3299 #ifdef CONFIG_HIGHMEM
3300 #define CIFS_KMAP_SIZE_LIMIT (LAST_PKMAP * PAGE_CACHE_SIZE)
3301 #else /* CONFIG_HIGHMEM */
3302 #define CIFS_KMAP_SIZE_LIMIT (1<<24)
3303 #endif /* CONFIG_HIGHMEM */
3306 cifs_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
3308 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3309 struct TCP_Server_Info *server = tcon->ses->server;
3312 /* start with specified wsize, or default */
3313 if (pvolume_info->wsize)
3314 wsize = pvolume_info->wsize;
3315 else if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
3316 wsize = CIFS_DEFAULT_IOSIZE;
3318 wsize = CIFS_DEFAULT_NON_POSIX_WSIZE;
3320 /* can server support 24-bit write sizes? (via UNIX extensions) */
3321 if (!tcon->unix_ext || !(unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
3322 wsize = min_t(unsigned int, wsize, CIFS_MAX_RFC1002_WSIZE);
3325 * no CAP_LARGE_WRITE_X or is signing enabled without CAP_UNIX set?
3326 * Limit it to max buffer offered by the server, minus the size of the
3327 * WRITEX header, not including the 4 byte RFC1001 length.
3329 if (!(server->capabilities & CAP_LARGE_WRITE_X) ||
3330 (!(server->capabilities & CAP_UNIX) &&
3331 (server->sec_mode & (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED))))
3332 wsize = min_t(unsigned int, wsize,
3333 server->maxBuf - sizeof(WRITE_REQ) + 4);
3335 /* limit to the amount that we can kmap at once */
3336 wsize = min_t(unsigned int, wsize, CIFS_KMAP_SIZE_LIMIT);
3338 /* hard limit of CIFS_MAX_WSIZE */
3339 wsize = min_t(unsigned int, wsize, CIFS_MAX_WSIZE);
3345 cifs_negotiate_rsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
3347 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3348 struct TCP_Server_Info *server = tcon->ses->server;
3349 unsigned int rsize, defsize;
3352 * Set default value...
3354 * HACK alert! Ancient servers have very small buffers. Even though
3355 * MS-CIFS indicates that servers are only limited by the client's
3356 * bufsize for reads, testing against win98se shows that it throws
3357 * INVALID_PARAMETER errors if you try to request too large a read.
3358 * OS/2 just sends back short reads.
3360 * If the server doesn't advertise CAP_LARGE_READ_X, then assume that
3361 * it can't handle a read request larger than its MaxBufferSize either.
3363 if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_READ_CAP))
3364 defsize = CIFS_DEFAULT_IOSIZE;
3365 else if (server->capabilities & CAP_LARGE_READ_X)
3366 defsize = CIFS_DEFAULT_NON_POSIX_RSIZE;
3368 defsize = server->maxBuf - sizeof(READ_RSP);
3370 rsize = pvolume_info->rsize ? pvolume_info->rsize : defsize;
3373 * no CAP_LARGE_READ_X? Then MS-CIFS states that we must limit this to
3374 * the client's MaxBufferSize.
3376 if (!(server->capabilities & CAP_LARGE_READ_X))
3377 rsize = min_t(unsigned int, CIFSMaxBufSize, rsize);
3379 /* limit to the amount that we can kmap at once */
3380 rsize = min_t(unsigned int, rsize, CIFS_KMAP_SIZE_LIMIT);
3382 /* hard limit of CIFS_MAX_RSIZE */
3383 rsize = min_t(unsigned int, rsize, CIFS_MAX_RSIZE);
3389 is_path_accessible(int xid, struct cifs_tcon *tcon,
3390 struct cifs_sb_info *cifs_sb, const char *full_path)
3393 FILE_ALL_INFO *pfile_info;
3395 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
3396 if (pfile_info == NULL)
3399 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
3400 0 /* not legacy */, cifs_sb->local_nls,
3401 cifs_sb->mnt_cifs_flags &
3402 CIFS_MOUNT_MAP_SPECIAL_CHR);
3404 if (rc == -EOPNOTSUPP || rc == -EINVAL)
3405 rc = SMBQueryInformation(xid, tcon, full_path, pfile_info,
3406 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
3407 CIFS_MOUNT_MAP_SPECIAL_CHR);
3413 cleanup_volume_info_contents(struct smb_vol *volume_info)
3415 kfree(volume_info->username);
3416 kzfree(volume_info->password);
3417 if (volume_info->UNCip != volume_info->UNC + 2)
3418 kfree(volume_info->UNCip);
3419 kfree(volume_info->UNC);
3420 kfree(volume_info->domainname);
3421 kfree(volume_info->iocharset);
3422 kfree(volume_info->prepath);
3426 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3430 cleanup_volume_info_contents(volume_info);
3435 #ifdef CONFIG_CIFS_DFS_UPCALL
3436 /* build_path_to_root returns full path to root when
3437 * we do not have an exiting connection (tcon) */
3439 build_unc_path_to_root(const struct smb_vol *vol,
3440 const struct cifs_sb_info *cifs_sb)
3442 char *full_path, *pos;
3443 unsigned int pplen = vol->prepath ? strlen(vol->prepath) : 0;
3444 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3446 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3447 if (full_path == NULL)
3448 return ERR_PTR(-ENOMEM);
3450 strncpy(full_path, vol->UNC, unc_len);
3451 pos = full_path + unc_len;
3454 strncpy(pos, vol->prepath, pplen);
3458 *pos = '\0'; /* add trailing null */
3459 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3460 cFYI(1, "%s: full_path=%s", __func__, full_path);
3465 * Perform a dfs referral query for a share and (optionally) prefix
3467 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3468 * to a string containing updated options for the submount. Otherwise it
3469 * will be left untouched.
3471 * Returns the rc from get_dfs_path to the caller, which can be used to
3472 * determine whether there were referrals.
3475 expand_dfs_referral(int xid, struct cifs_ses *pSesInfo,
3476 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3480 unsigned int num_referrals = 0;
3481 struct dfs_info3_param *referrals = NULL;
3482 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3484 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3485 if (IS_ERR(full_path))
3486 return PTR_ERR(full_path);
3488 /* For DFS paths, skip the first '\' of the UNC */
3489 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3491 rc = get_dfs_path(xid, pSesInfo , ref_path, cifs_sb->local_nls,
3492 &num_referrals, &referrals,
3493 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
3495 if (!rc && num_referrals > 0) {
3496 char *fake_devname = NULL;
3498 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3499 full_path + 1, referrals,
3502 free_dfs_info_array(referrals, num_referrals);
3504 if (IS_ERR(mdata)) {
3505 rc = PTR_ERR(mdata);
3508 cleanup_volume_info_contents(volume_info);
3509 memset(volume_info, '\0', sizeof(*volume_info));
3510 rc = cifs_setup_volume_info(volume_info, mdata,
3513 kfree(fake_devname);
3514 kfree(cifs_sb->mountdata);
3515 cifs_sb->mountdata = mdata;
3523 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3524 const char *devname)
3528 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3532 if (volume_info->nullauth) {
3533 cFYI(1, "Anonymous login");
3534 kfree(volume_info->username);
3535 volume_info->username = NULL;
3536 } else if (volume_info->username) {
3537 /* BB fixme parse for domain name here */
3538 cFYI(1, "Username: %s", volume_info->username);
3540 cifserror("No username specified");
3541 /* In userspace mount helper we can get user name from alternate
3542 locations such as env variables and files on disk */
3546 /* this is needed for ASCII cp to Unicode converts */
3547 if (volume_info->iocharset == NULL) {
3548 /* load_nls_default cannot return null */
3549 volume_info->local_nls = load_nls_default();
3551 volume_info->local_nls = load_nls(volume_info->iocharset);
3552 if (volume_info->local_nls == NULL) {
3553 cERROR(1, "CIFS mount error: iocharset %s not found",
3554 volume_info->iocharset);
3563 cifs_get_volume_info(char *mount_data, const char *devname)
3566 struct smb_vol *volume_info;
3568 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
3570 return ERR_PTR(-ENOMEM);
3572 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3574 cifs_cleanup_volume_info(volume_info);
3575 volume_info = ERR_PTR(rc);
3582 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3586 struct cifs_ses *pSesInfo;
3587 struct cifs_tcon *tcon;
3588 struct TCP_Server_Info *srvTcp;
3590 struct tcon_link *tlink;
3591 #ifdef CONFIG_CIFS_DFS_UPCALL
3592 int referral_walks_count = 0;
3595 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3599 #ifdef CONFIG_CIFS_DFS_UPCALL
3601 /* cleanup activities if we're chasing a referral */
3602 if (referral_walks_count) {
3604 cifs_put_tcon(tcon);
3606 cifs_put_smb_ses(pSesInfo);
3620 /* get a reference to a tcp session */
3621 srvTcp = cifs_get_tcp_session(volume_info);
3622 if (IS_ERR(srvTcp)) {
3623 rc = PTR_ERR(srvTcp);
3624 bdi_destroy(&cifs_sb->bdi);
3628 /* get a reference to a SMB session */
3629 pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
3630 if (IS_ERR(pSesInfo)) {
3631 rc = PTR_ERR(pSesInfo);
3633 goto mount_fail_check;
3636 /* search for existing tcon to this server share */
3637 tcon = cifs_get_tcon(pSesInfo, volume_info);
3641 goto remote_path_check;
3644 /* tell server which Unix caps we support */
3645 if (tcon->ses->capabilities & CAP_UNIX) {
3646 /* reset of caps checks mount to see if unix extensions
3647 disabled for just this mount */
3648 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3649 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3650 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3651 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3653 goto mount_fail_check;
3656 tcon->unix_ext = 0; /* server does not support them */
3658 /* do not care if following two calls succeed - informational */
3660 CIFSSMBQFSDeviceInfo(xid, tcon);
3661 CIFSSMBQFSAttributeInfo(xid, tcon);
3664 cifs_sb->wsize = cifs_negotiate_wsize(tcon, volume_info);
3665 cifs_sb->rsize = cifs_negotiate_rsize(tcon, volume_info);
3667 /* tune readahead according to rsize */
3668 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
3671 #ifdef CONFIG_CIFS_DFS_UPCALL
3673 * Perform an unconditional check for whether there are DFS
3674 * referrals for this path without prefix, to provide support
3675 * for DFS referrals from w2k8 servers which don't seem to respond
3676 * with PATH_NOT_COVERED to requests that include the prefix.
3677 * Chase the referral if found, otherwise continue normally.
3679 if (referral_walks_count == 0) {
3680 int refrc = expand_dfs_referral(xid, pSesInfo, volume_info,
3683 referral_walks_count++;
3684 goto try_mount_again;
3689 /* check if a whole path is not remote */
3691 /* build_path_to_root works only when we have a valid tcon */
3692 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3693 if (full_path == NULL) {
3695 goto mount_fail_check;
3697 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
3698 if (rc != 0 && rc != -EREMOTE) {
3700 goto mount_fail_check;
3705 /* get referral if needed */
3706 if (rc == -EREMOTE) {
3707 #ifdef CONFIG_CIFS_DFS_UPCALL
3708 if (referral_walks_count > MAX_NESTED_LINKS) {
3710 * BB: when we implement proper loop detection,
3711 * we will remove this check. But now we need it
3712 * to prevent an indefinite loop if 'DFS tree' is
3713 * misconfigured (i.e. has loops).
3716 goto mount_fail_check;
3719 rc = expand_dfs_referral(xid, pSesInfo, volume_info, cifs_sb,
3723 referral_walks_count++;
3724 goto try_mount_again;
3726 goto mount_fail_check;
3727 #else /* No DFS support, return error on mount */
3733 goto mount_fail_check;
3735 /* now, hang the tcon off of the superblock */
3736 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3737 if (tlink == NULL) {
3739 goto mount_fail_check;
3742 tlink->tl_uid = pSesInfo->linux_uid;
3743 tlink->tl_tcon = tcon;
3744 tlink->tl_time = jiffies;
3745 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3746 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3748 cifs_sb->master_tlink = tlink;
3749 spin_lock(&cifs_sb->tlink_tree_lock);
3750 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3751 spin_unlock(&cifs_sb->tlink_tree_lock);
3753 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3757 /* on error free sesinfo and tcon struct if needed */
3759 /* If find_unc succeeded then rc == 0 so we can not end */
3760 /* up accidentally freeing someone elses tcon struct */
3762 cifs_put_tcon(tcon);
3764 cifs_put_smb_ses(pSesInfo);
3766 cifs_put_tcp_session(srvTcp);
3767 bdi_destroy(&cifs_sb->bdi);
3776 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3777 * pointer may be NULL.
3780 CIFSTCon(unsigned int xid, struct cifs_ses *ses,
3781 const char *tree, struct cifs_tcon *tcon,
3782 const struct nls_table *nls_codepage)
3784 struct smb_hdr *smb_buffer;
3785 struct smb_hdr *smb_buffer_response;
3788 unsigned char *bcc_ptr;
3791 __u16 bytes_left, count;
3796 smb_buffer = cifs_buf_get();
3797 if (smb_buffer == NULL)
3800 smb_buffer_response = smb_buffer;
3802 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3803 NULL /*no tid */ , 4 /*wct */ );
3805 smb_buffer->Mid = get_next_mid(ses->server);
3806 smb_buffer->Uid = ses->Suid;
3807 pSMB = (TCONX_REQ *) smb_buffer;
3808 pSMBr = (TCONX_RSP *) smb_buffer_response;
3810 pSMB->AndXCommand = 0xFF;
3811 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3812 bcc_ptr = &pSMB->Password[0];
3813 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3814 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3815 *bcc_ptr = 0; /* password is null byte */
3816 bcc_ptr++; /* skip password */
3817 /* already aligned so no need to do it below */
3819 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3820 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3821 specified as required (when that support is added to
3822 the vfs in the future) as only NTLM or the much
3823 weaker LANMAN (which we do not send by default) is accepted
3824 by Samba (not sure whether other servers allow
3825 NTLMv2 password here) */
3826 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3827 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3828 (ses->server->secType == LANMAN))
3829 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3830 ses->server->sec_mode &
3831 SECMODE_PW_ENCRYPT ? true : false,
3834 #endif /* CIFS_WEAK_PW_HASH */
3835 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3836 bcc_ptr, nls_codepage);
3838 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3839 if (ses->capabilities & CAP_UNICODE) {
3840 /* must align unicode strings */
3841 *bcc_ptr = 0; /* null byte password */
3846 if (ses->server->sec_mode &
3847 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3848 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3850 if (ses->capabilities & CAP_STATUS32) {
3851 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3853 if (ses->capabilities & CAP_DFS) {
3854 smb_buffer->Flags2 |= SMBFLG2_DFS;
3856 if (ses->capabilities & CAP_UNICODE) {
3857 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3859 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3860 6 /* max utf8 char length in bytes */ *
3861 (/* server len*/ + 256 /* share len */), nls_codepage);
3862 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3863 bcc_ptr += 2; /* skip trailing null */
3864 } else { /* ASCII */
3865 strcpy(bcc_ptr, tree);
3866 bcc_ptr += strlen(tree) + 1;
3868 strcpy(bcc_ptr, "?????");
3869 bcc_ptr += strlen("?????");
3871 count = bcc_ptr - &pSMB->Password[0];
3872 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3873 pSMB->hdr.smb_buf_length) + count);
3874 pSMB->ByteCount = cpu_to_le16(count);
3876 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3879 /* above now done in SendReceive */
3880 if ((rc == 0) && (tcon != NULL)) {
3883 tcon->tidStatus = CifsGood;
3884 tcon->need_reconnect = false;
3885 tcon->tid = smb_buffer_response->Tid;
3886 bcc_ptr = pByteArea(smb_buffer_response);
3887 bytes_left = get_bcc(smb_buffer_response);
3888 length = strnlen(bcc_ptr, bytes_left - 2);
3889 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3895 /* skip service field (NB: this field is always ASCII) */
3897 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3898 (bcc_ptr[2] == 'C')) {
3899 cFYI(1, "IPC connection");
3902 } else if (length == 2) {
3903 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3904 /* the most common case */
3905 cFYI(1, "disk share connection");
3908 bcc_ptr += length + 1;
3909 bytes_left -= (length + 1);
3910 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3912 /* mostly informational -- no need to fail on error here */
3913 kfree(tcon->nativeFileSystem);
3914 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
3915 bytes_left, is_unicode,
3918 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
3920 if ((smb_buffer_response->WordCount == 3) ||
3921 (smb_buffer_response->WordCount == 7))
3922 /* field is in same location */
3923 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3926 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
3927 } else if ((rc == 0) && tcon == NULL) {
3928 /* all we need to save for IPC$ connection */
3929 ses->ipc_tid = smb_buffer_response->Tid;
3932 cifs_buf_release(smb_buffer);
3937 cifs_umount(struct cifs_sb_info *cifs_sb)
3939 struct rb_root *root = &cifs_sb->tlink_tree;
3940 struct rb_node *node;
3941 struct tcon_link *tlink;
3943 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3945 spin_lock(&cifs_sb->tlink_tree_lock);
3946 while ((node = rb_first(root))) {
3947 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3948 cifs_get_tlink(tlink);
3949 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3950 rb_erase(node, root);
3952 spin_unlock(&cifs_sb->tlink_tree_lock);
3953 cifs_put_tlink(tlink);
3954 spin_lock(&cifs_sb->tlink_tree_lock);
3956 spin_unlock(&cifs_sb->tlink_tree_lock);
3958 bdi_destroy(&cifs_sb->bdi);
3959 kfree(cifs_sb->mountdata);
3960 unload_nls(cifs_sb->local_nls);
3965 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
3968 struct TCP_Server_Info *server = ses->server;
3970 if (!server->ops->need_neg || !server->ops->negotiate)
3973 /* only send once per connect */
3974 if (!server->ops->need_neg(server))
3977 set_credits(server, 1);
3979 rc = server->ops->negotiate(xid, ses);
3981 spin_lock(&GlobalMid_Lock);
3982 if (server->tcpStatus == CifsNeedNegotiate)
3983 server->tcpStatus = CifsGood;
3986 spin_unlock(&GlobalMid_Lock);
3993 int cifs_setup_session(unsigned int xid, struct cifs_ses *ses,
3994 struct nls_table *nls_info)
3997 struct TCP_Server_Info *server = ses->server;
4000 ses->capabilities = server->capabilities;
4001 if (linuxExtEnabled == 0)
4002 ses->capabilities &= (~CAP_UNIX);
4004 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
4005 server->sec_mode, server->capabilities, server->timeAdj);
4007 rc = CIFS_SessSetup(xid, ses, nls_info);
4009 cERROR(1, "Send error in SessSetup = %d", rc);
4011 mutex_lock(&ses->server->srv_mutex);
4012 if (!server->session_estab) {
4013 server->session_key.response = ses->auth_key.response;
4014 server->session_key.len = ses->auth_key.len;
4015 server->sequence_number = 0x2;
4016 server->session_estab = true;
4017 ses->auth_key.response = NULL;
4019 mutex_unlock(&server->srv_mutex);
4021 cFYI(1, "CIFS Session Established successfully");
4022 spin_lock(&GlobalMid_Lock);
4023 ses->status = CifsGood;
4024 ses->need_reconnect = false;
4025 spin_unlock(&GlobalMid_Lock);
4028 kfree(ses->auth_key.response);
4029 ses->auth_key.response = NULL;
4030 ses->auth_key.len = 0;
4031 kfree(ses->ntlmssp);
4032 ses->ntlmssp = NULL;
4038 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
4040 switch (ses->server->secType) {
4042 vol->secFlg = CIFSSEC_MUST_KRB5;
4045 vol->secFlg = CIFSSEC_MUST_NTLMV2;
4048 vol->secFlg = CIFSSEC_MUST_NTLM;
4051 vol->secFlg = CIFSSEC_MUST_NTLMSSP;
4054 vol->secFlg = CIFSSEC_MUST_LANMAN;
4058 return cifs_set_cifscreds(vol, ses);
4061 static struct cifs_tcon *
4062 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
4065 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4066 struct cifs_ses *ses;
4067 struct cifs_tcon *tcon = NULL;
4068 struct smb_vol *vol_info;
4070 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
4071 if (vol_info == NULL)
4072 return ERR_PTR(-ENOMEM);
4074 vol_info->local_nls = cifs_sb->local_nls;
4075 vol_info->linux_uid = fsuid;
4076 vol_info->cred_uid = fsuid;
4077 vol_info->UNC = master_tcon->treeName;
4078 vol_info->retry = master_tcon->retry;
4079 vol_info->nocase = master_tcon->nocase;
4080 vol_info->local_lease = master_tcon->local_lease;
4081 vol_info->no_linux_ext = !master_tcon->unix_ext;
4083 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4089 /* get a reference for the same TCP session */
4090 spin_lock(&cifs_tcp_ses_lock);
4091 ++master_tcon->ses->server->srv_count;
4092 spin_unlock(&cifs_tcp_ses_lock);
4094 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4096 tcon = (struct cifs_tcon *)ses;
4097 cifs_put_tcp_session(master_tcon->ses->server);
4101 tcon = cifs_get_tcon(ses, vol_info);
4103 cifs_put_smb_ses(ses);
4107 if (ses->capabilities & CAP_UNIX)
4108 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4110 kfree(vol_info->username);
4111 kfree(vol_info->password);
4118 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4120 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4124 cifs_sb_tcon_pending_wait(void *unused)
4127 return signal_pending(current) ? -ERESTARTSYS : 0;
4130 /* find and return a tlink with given uid */
4131 static struct tcon_link *
4132 tlink_rb_search(struct rb_root *root, uid_t uid)
4134 struct rb_node *node = root->rb_node;
4135 struct tcon_link *tlink;
4138 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4140 if (tlink->tl_uid > uid)
4141 node = node->rb_left;
4142 else if (tlink->tl_uid < uid)
4143 node = node->rb_right;
4150 /* insert a tcon_link into the tree */
4152 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4154 struct rb_node **new = &(root->rb_node), *parent = NULL;
4155 struct tcon_link *tlink;
4158 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4161 if (tlink->tl_uid > new_tlink->tl_uid)
4162 new = &((*new)->rb_left);
4164 new = &((*new)->rb_right);
4167 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4168 rb_insert_color(&new_tlink->tl_rbnode, root);
4172 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4175 * If the superblock doesn't refer to a multiuser mount, then just return
4176 * the master tcon for the mount.
4178 * First, search the rbtree for an existing tcon for this fsuid. If one
4179 * exists, then check to see if it's pending construction. If it is then wait
4180 * for construction to complete. Once it's no longer pending, check to see if
4181 * it failed and either return an error or retry construction, depending on
4184 * If one doesn't exist then insert a new tcon_link struct into the tree and
4185 * try to construct a new one.
4188 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4191 uid_t fsuid = current_fsuid();
4192 struct tcon_link *tlink, *newtlink;
4194 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4195 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4197 spin_lock(&cifs_sb->tlink_tree_lock);
4198 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4200 cifs_get_tlink(tlink);
4201 spin_unlock(&cifs_sb->tlink_tree_lock);
4203 if (tlink == NULL) {
4204 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4205 if (newtlink == NULL)
4206 return ERR_PTR(-ENOMEM);
4207 newtlink->tl_uid = fsuid;
4208 newtlink->tl_tcon = ERR_PTR(-EACCES);
4209 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4210 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4211 cifs_get_tlink(newtlink);
4213 spin_lock(&cifs_sb->tlink_tree_lock);
4214 /* was one inserted after previous search? */
4215 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4217 cifs_get_tlink(tlink);
4218 spin_unlock(&cifs_sb->tlink_tree_lock);
4220 goto wait_for_construction;
4223 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4224 spin_unlock(&cifs_sb->tlink_tree_lock);
4226 wait_for_construction:
4227 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4228 cifs_sb_tcon_pending_wait,
4229 TASK_INTERRUPTIBLE);
4231 cifs_put_tlink(tlink);
4232 return ERR_PTR(ret);
4235 /* if it's good, return it */
4236 if (!IS_ERR(tlink->tl_tcon))
4239 /* return error if we tried this already recently */
4240 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4241 cifs_put_tlink(tlink);
4242 return ERR_PTR(-EACCES);
4245 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4246 goto wait_for_construction;
4249 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4250 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4251 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4253 if (IS_ERR(tlink->tl_tcon)) {
4254 cifs_put_tlink(tlink);
4255 return ERR_PTR(-EACCES);
4262 * periodic workqueue job that scans tcon_tree for a superblock and closes
4266 cifs_prune_tlinks(struct work_struct *work)
4268 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4270 struct rb_root *root = &cifs_sb->tlink_tree;
4271 struct rb_node *node = rb_first(root);
4272 struct rb_node *tmp;
4273 struct tcon_link *tlink;
4276 * Because we drop the spinlock in the loop in order to put the tlink
4277 * it's not guarded against removal of links from the tree. The only
4278 * places that remove entries from the tree are this function and
4279 * umounts. Because this function is non-reentrant and is canceled
4280 * before umount can proceed, this is safe.
4282 spin_lock(&cifs_sb->tlink_tree_lock);
4283 node = rb_first(root);
4284 while (node != NULL) {
4286 node = rb_next(tmp);
4287 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4289 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4290 atomic_read(&tlink->tl_count) != 0 ||
4291 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4294 cifs_get_tlink(tlink);
4295 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4296 rb_erase(tmp, root);
4298 spin_unlock(&cifs_sb->tlink_tree_lock);
4299 cifs_put_tlink(tlink);
4300 spin_lock(&cifs_sb->tlink_tree_lock);
4302 spin_unlock(&cifs_sb->tlink_tree_lock);
4304 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,