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->maxBuf == 0 ||
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)
2409 int rc = -ENOMEM, xid;
2410 struct cifs_ses *ses;
2411 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2412 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2416 ses = cifs_find_smb_ses(server, volume_info);
2418 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
2420 mutex_lock(&ses->session_mutex);
2421 rc = cifs_negotiate_protocol(xid, ses);
2423 mutex_unlock(&ses->session_mutex);
2424 /* problem -- put our ses reference */
2425 cifs_put_smb_ses(ses);
2429 if (ses->need_reconnect) {
2430 cFYI(1, "Session needs reconnect");
2431 rc = cifs_setup_session(xid, ses,
2432 volume_info->local_nls);
2434 mutex_unlock(&ses->session_mutex);
2435 /* problem -- put our reference */
2436 cifs_put_smb_ses(ses);
2441 mutex_unlock(&ses->session_mutex);
2443 /* existing SMB ses has a server reference already */
2444 cifs_put_tcp_session(server);
2449 cFYI(1, "Existing smb sess not found");
2450 ses = sesInfoAlloc();
2454 /* new SMB session uses our server ref */
2455 ses->server = server;
2456 if (server->dstaddr.ss_family == AF_INET6)
2457 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2459 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2461 if (volume_info->username) {
2462 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2463 if (!ses->user_name)
2467 /* volume_info->password freed at unmount */
2468 if (volume_info->password) {
2469 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2473 if (volume_info->domainname) {
2474 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2475 if (!ses->domainName)
2478 ses->cred_uid = volume_info->cred_uid;
2479 ses->linux_uid = volume_info->linux_uid;
2481 /* ntlmv2 is much stronger than ntlm security, and has been broadly
2482 supported for many years, time to update default security mechanism */
2483 if ((volume_info->secFlg == 0) && warned_on_ntlm == false) {
2484 warned_on_ntlm = true;
2485 cERROR(1, "default security mechanism requested. The default "
2486 "security mechanism will be upgraded from ntlm to "
2487 "ntlmv2 in kernel release 3.3");
2489 ses->overrideSecFlg = volume_info->secFlg;
2491 mutex_lock(&ses->session_mutex);
2492 rc = cifs_negotiate_protocol(xid, ses);
2494 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2495 mutex_unlock(&ses->session_mutex);
2499 /* success, put it on the list */
2500 spin_lock(&cifs_tcp_ses_lock);
2501 list_add(&ses->smb_ses_list, &server->smb_ses_list);
2502 spin_unlock(&cifs_tcp_ses_lock);
2513 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2515 if (tcon->tidStatus == CifsExiting)
2517 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2522 static struct cifs_tcon *
2523 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2525 struct list_head *tmp;
2526 struct cifs_tcon *tcon;
2528 spin_lock(&cifs_tcp_ses_lock);
2529 list_for_each(tmp, &ses->tcon_list) {
2530 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2531 if (!match_tcon(tcon, unc))
2534 spin_unlock(&cifs_tcp_ses_lock);
2537 spin_unlock(&cifs_tcp_ses_lock);
2542 cifs_put_tcon(struct cifs_tcon *tcon)
2545 struct cifs_ses *ses = tcon->ses;
2547 cFYI(1, "%s: tc_count=%d", __func__, tcon->tc_count);
2548 spin_lock(&cifs_tcp_ses_lock);
2549 if (--tcon->tc_count > 0) {
2550 spin_unlock(&cifs_tcp_ses_lock);
2554 list_del_init(&tcon->tcon_list);
2555 spin_unlock(&cifs_tcp_ses_lock);
2558 CIFSSMBTDis(xid, tcon);
2561 cifs_fscache_release_super_cookie(tcon);
2563 cifs_put_smb_ses(ses);
2566 static struct cifs_tcon *
2567 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2570 struct cifs_tcon *tcon;
2572 tcon = cifs_find_tcon(ses, volume_info->UNC);
2574 cFYI(1, "Found match on UNC path");
2575 /* existing tcon already has a reference */
2576 cifs_put_smb_ses(ses);
2577 if (tcon->seal != volume_info->seal)
2578 cERROR(1, "transport encryption setting "
2579 "conflicts with existing tid");
2583 tcon = tconInfoAlloc();
2590 if (volume_info->password) {
2591 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2592 if (!tcon->password) {
2598 if (strchr(volume_info->UNC + 3, '\\') == NULL
2599 && strchr(volume_info->UNC + 3, '/') == NULL) {
2600 cERROR(1, "Missing share name");
2605 /* BB Do we need to wrap session_mutex around
2606 * this TCon call and Unix SetFS as
2607 * we do on SessSetup and reconnect? */
2609 rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
2611 cFYI(1, "CIFS Tcon rc = %d", rc);
2615 if (volume_info->nodfs) {
2616 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2617 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2619 tcon->seal = volume_info->seal;
2620 /* we can have only one retry value for a connection
2621 to a share so for resources mounted more than once
2622 to the same server share the last value passed in
2623 for the retry flag is used */
2624 tcon->retry = volume_info->retry;
2625 tcon->nocase = volume_info->nocase;
2626 tcon->local_lease = volume_info->local_lease;
2628 spin_lock(&cifs_tcp_ses_lock);
2629 list_add(&tcon->tcon_list, &ses->tcon_list);
2630 spin_unlock(&cifs_tcp_ses_lock);
2632 cifs_fscache_get_super_cookie(tcon);
2642 cifs_put_tlink(struct tcon_link *tlink)
2644 if (!tlink || IS_ERR(tlink))
2647 if (!atomic_dec_and_test(&tlink->tl_count) ||
2648 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2649 tlink->tl_time = jiffies;
2653 if (!IS_ERR(tlink_tcon(tlink)))
2654 cifs_put_tcon(tlink_tcon(tlink));
2659 static inline struct tcon_link *
2660 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2662 return cifs_sb->master_tlink;
2666 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2668 struct cifs_sb_info *old = CIFS_SB(sb);
2669 struct cifs_sb_info *new = mnt_data->cifs_sb;
2671 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2674 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2675 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2679 * We want to share sb only if we don't specify an r/wsize or
2680 * specified r/wsize is greater than or equal to existing one.
2682 if (new->wsize && new->wsize < old->wsize)
2685 if (new->rsize && new->rsize < old->rsize)
2688 if (old->mnt_uid != new->mnt_uid || old->mnt_gid != new->mnt_gid)
2691 if (old->mnt_file_mode != new->mnt_file_mode ||
2692 old->mnt_dir_mode != new->mnt_dir_mode)
2695 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2698 if (old->actimeo != new->actimeo)
2705 cifs_match_super(struct super_block *sb, void *data)
2707 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2708 struct smb_vol *volume_info;
2709 struct cifs_sb_info *cifs_sb;
2710 struct TCP_Server_Info *tcp_srv;
2711 struct cifs_ses *ses;
2712 struct cifs_tcon *tcon;
2713 struct tcon_link *tlink;
2714 struct sockaddr_storage addr;
2717 memset(&addr, 0, sizeof(struct sockaddr_storage));
2719 spin_lock(&cifs_tcp_ses_lock);
2720 cifs_sb = CIFS_SB(sb);
2721 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2722 if (IS_ERR(tlink)) {
2723 spin_unlock(&cifs_tcp_ses_lock);
2726 tcon = tlink_tcon(tlink);
2728 tcp_srv = ses->server;
2730 volume_info = mnt_data->vol;
2732 if (!volume_info->UNCip || !volume_info->UNC)
2735 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
2737 strlen(volume_info->UNCip),
2742 if (!match_server(tcp_srv, (struct sockaddr *)&addr, volume_info) ||
2743 !match_session(ses, volume_info) ||
2744 !match_tcon(tcon, volume_info->UNC)) {
2749 rc = compare_mount_options(sb, mnt_data);
2751 spin_unlock(&cifs_tcp_ses_lock);
2752 cifs_put_tlink(tlink);
2757 get_dfs_path(int xid, struct cifs_ses *pSesInfo, const char *old_path,
2758 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
2759 struct dfs_info3_param **preferrals, int remap)
2764 *pnum_referrals = 0;
2767 if (pSesInfo->ipc_tid == 0) {
2768 temp_unc = kmalloc(2 /* for slashes */ +
2769 strnlen(pSesInfo->serverName,
2770 SERVER_NAME_LEN_WITH_NULL * 2)
2771 + 1 + 4 /* slash IPC$ */ + 2,
2773 if (temp_unc == NULL)
2777 strcpy(temp_unc + 2, pSesInfo->serverName);
2778 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2779 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
2780 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
2784 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
2785 pnum_referrals, nls_codepage, remap);
2786 /* BB map targetUNCs to dfs_info3 structures, here or
2787 in CIFSGetDFSRefer BB */
2792 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2793 static struct lock_class_key cifs_key[2];
2794 static struct lock_class_key cifs_slock_key[2];
2797 cifs_reclassify_socket4(struct socket *sock)
2799 struct sock *sk = sock->sk;
2800 BUG_ON(sock_owned_by_user(sk));
2801 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2802 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2806 cifs_reclassify_socket6(struct socket *sock)
2808 struct sock *sk = sock->sk;
2809 BUG_ON(sock_owned_by_user(sk));
2810 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2811 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2815 cifs_reclassify_socket4(struct socket *sock)
2820 cifs_reclassify_socket6(struct socket *sock)
2825 /* See RFC1001 section 14 on representation of Netbios names */
2826 static void rfc1002mangle(char *target, char *source, unsigned int length)
2830 for (i = 0, j = 0; i < (length); i++) {
2831 /* mask a nibble at a time and encode */
2832 target[j] = 'A' + (0x0F & (source[i] >> 4));
2833 target[j+1] = 'A' + (0x0F & source[i]);
2840 bind_socket(struct TCP_Server_Info *server)
2843 if (server->srcaddr.ss_family != AF_UNSPEC) {
2844 /* Bind to the specified local IP address */
2845 struct socket *socket = server->ssocket;
2846 rc = socket->ops->bind(socket,
2847 (struct sockaddr *) &server->srcaddr,
2848 sizeof(server->srcaddr));
2850 struct sockaddr_in *saddr4;
2851 struct sockaddr_in6 *saddr6;
2852 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2853 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2854 if (saddr6->sin6_family == AF_INET6)
2856 "Failed to bind to: %pI6c, error: %d",
2857 &saddr6->sin6_addr, rc);
2860 "Failed to bind to: %pI4, error: %d",
2861 &saddr4->sin_addr.s_addr, rc);
2868 ip_rfc1001_connect(struct TCP_Server_Info *server)
2872 * some servers require RFC1001 sessinit before sending
2873 * negprot - BB check reconnection in case where second
2874 * sessinit is sent but no second negprot
2876 struct rfc1002_session_packet *ses_init_buf;
2877 struct smb_hdr *smb_buf;
2878 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2881 ses_init_buf->trailer.session_req.called_len = 32;
2883 if (server->server_RFC1001_name &&
2884 server->server_RFC1001_name[0] != 0)
2885 rfc1002mangle(ses_init_buf->trailer.
2886 session_req.called_name,
2887 server->server_RFC1001_name,
2888 RFC1001_NAME_LEN_WITH_NULL);
2890 rfc1002mangle(ses_init_buf->trailer.
2891 session_req.called_name,
2892 DEFAULT_CIFS_CALLED_NAME,
2893 RFC1001_NAME_LEN_WITH_NULL);
2895 ses_init_buf->trailer.session_req.calling_len = 32;
2898 * calling name ends in null (byte 16) from old smb
2901 if (server->workstation_RFC1001_name &&
2902 server->workstation_RFC1001_name[0] != 0)
2903 rfc1002mangle(ses_init_buf->trailer.
2904 session_req.calling_name,
2905 server->workstation_RFC1001_name,
2906 RFC1001_NAME_LEN_WITH_NULL);
2908 rfc1002mangle(ses_init_buf->trailer.
2909 session_req.calling_name,
2911 RFC1001_NAME_LEN_WITH_NULL);
2913 ses_init_buf->trailer.session_req.scope1 = 0;
2914 ses_init_buf->trailer.session_req.scope2 = 0;
2915 smb_buf = (struct smb_hdr *)ses_init_buf;
2917 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2918 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
2919 rc = smb_send(server, smb_buf, 0x44);
2920 kfree(ses_init_buf);
2922 * RFC1001 layer in at least one server
2923 * requires very short break before negprot
2924 * presumably because not expecting negprot
2925 * to follow so fast. This is a simple
2926 * solution that works without
2927 * complicating the code and causes no
2928 * significant slowing down on mount
2931 usleep_range(1000, 2000);
2934 * else the negprot may still work without this
2935 * even though malloc failed
2942 generic_ip_connect(struct TCP_Server_Info *server)
2947 struct socket *socket = server->ssocket;
2948 struct sockaddr *saddr;
2950 saddr = (struct sockaddr *) &server->dstaddr;
2952 if (server->dstaddr.ss_family == AF_INET6) {
2953 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2954 slen = sizeof(struct sockaddr_in6);
2957 sport = ((struct sockaddr_in *) saddr)->sin_port;
2958 slen = sizeof(struct sockaddr_in);
2962 if (socket == NULL) {
2963 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2964 IPPROTO_TCP, &socket, 1);
2966 cERROR(1, "Error %d creating socket", rc);
2967 server->ssocket = NULL;
2971 /* BB other socket options to set KEEPALIVE, NODELAY? */
2972 cFYI(1, "Socket created");
2973 server->ssocket = socket;
2974 socket->sk->sk_allocation = GFP_NOFS;
2975 if (sfamily == AF_INET6)
2976 cifs_reclassify_socket6(socket);
2978 cifs_reclassify_socket4(socket);
2981 rc = bind_socket(server);
2986 * Eventually check for other socket options to change from
2987 * the default. sock_setsockopt not used because it expects
2990 socket->sk->sk_rcvtimeo = 7 * HZ;
2991 socket->sk->sk_sndtimeo = 5 * HZ;
2993 /* make the bufsizes depend on wsize/rsize and max requests */
2994 if (server->noautotune) {
2995 if (socket->sk->sk_sndbuf < (200 * 1024))
2996 socket->sk->sk_sndbuf = 200 * 1024;
2997 if (socket->sk->sk_rcvbuf < (140 * 1024))
2998 socket->sk->sk_rcvbuf = 140 * 1024;
3001 if (server->tcp_nodelay) {
3003 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3004 (char *)&val, sizeof(val));
3006 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
3009 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
3010 socket->sk->sk_sndbuf,
3011 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3013 rc = socket->ops->connect(socket, saddr, slen, 0);
3015 cFYI(1, "Error %d connecting to server", rc);
3016 sock_release(socket);
3017 server->ssocket = NULL;
3021 if (sport == htons(RFC1001_PORT))
3022 rc = ip_rfc1001_connect(server);
3028 ip_connect(struct TCP_Server_Info *server)
3031 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3032 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3034 if (server->dstaddr.ss_family == AF_INET6)
3035 sport = &addr6->sin6_port;
3037 sport = &addr->sin_port;
3042 /* try with 445 port at first */
3043 *sport = htons(CIFS_PORT);
3045 rc = generic_ip_connect(server);
3049 /* if it failed, try with 139 port */
3050 *sport = htons(RFC1001_PORT);
3053 return generic_ip_connect(server);
3056 void reset_cifs_unix_caps(int xid, struct cifs_tcon *tcon,
3057 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3059 /* if we are reconnecting then should we check to see if
3060 * any requested capabilities changed locally e.g. via
3061 * remount but we can not do much about it here
3062 * if they have (even if we could detect it by the following)
3063 * Perhaps we could add a backpointer to array of sb from tcon
3064 * or if we change to make all sb to same share the same
3065 * sb as NFS - then we only have one backpointer to sb.
3066 * What if we wanted to mount the server share twice once with
3067 * and once without posixacls or posix paths? */
3068 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3070 if (vol_info && vol_info->no_linux_ext) {
3071 tcon->fsUnixInfo.Capability = 0;
3072 tcon->unix_ext = 0; /* Unix Extensions disabled */
3073 cFYI(1, "Linux protocol extensions disabled");
3075 } else if (vol_info)
3076 tcon->unix_ext = 1; /* Unix Extensions supported */
3078 if (tcon->unix_ext == 0) {
3079 cFYI(1, "Unix extensions disabled so not set on reconnect");
3083 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3084 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3085 cFYI(1, "unix caps which server supports %lld", cap);
3086 /* check for reconnect case in which we do not
3087 want to change the mount behavior if we can avoid it */
3088 if (vol_info == NULL) {
3089 /* turn off POSIX ACL and PATHNAMES if not set
3090 originally at mount time */
3091 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3092 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3093 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3094 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3095 cERROR(1, "POSIXPATH support change");
3096 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3097 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3098 cERROR(1, "possible reconnect error");
3099 cERROR(1, "server disabled POSIX path support");
3103 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3104 cERROR(1, "per-share encryption not supported yet");
3106 cap &= CIFS_UNIX_CAP_MASK;
3107 if (vol_info && vol_info->no_psx_acl)
3108 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3109 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3110 cFYI(1, "negotiated posix acl support");
3112 cifs_sb->mnt_cifs_flags |=
3113 CIFS_MOUNT_POSIXACL;
3116 if (vol_info && vol_info->posix_paths == 0)
3117 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3118 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3119 cFYI(1, "negotiate posix pathnames");
3121 cifs_sb->mnt_cifs_flags |=
3122 CIFS_MOUNT_POSIX_PATHS;
3125 cFYI(1, "Negotiate caps 0x%x", (int)cap);
3126 #ifdef CONFIG_CIFS_DEBUG2
3127 if (cap & CIFS_UNIX_FCNTL_CAP)
3128 cFYI(1, "FCNTL cap");
3129 if (cap & CIFS_UNIX_EXTATTR_CAP)
3130 cFYI(1, "EXTATTR cap");
3131 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3132 cFYI(1, "POSIX path cap");
3133 if (cap & CIFS_UNIX_XATTR_CAP)
3134 cFYI(1, "XATTR cap");
3135 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3136 cFYI(1, "POSIX ACL cap");
3137 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3138 cFYI(1, "very large read cap");
3139 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3140 cFYI(1, "very large write cap");
3141 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3142 cFYI(1, "transport encryption cap");
3143 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3144 cFYI(1, "mandatory transport encryption cap");
3145 #endif /* CIFS_DEBUG2 */
3146 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3147 if (vol_info == NULL) {
3148 cFYI(1, "resetting capabilities failed");
3150 cERROR(1, "Negotiating Unix capabilities "
3151 "with the server failed. Consider "
3152 "mounting with the Unix Extensions "
3153 "disabled if problems are found "
3154 "by specifying the nounix mount "
3161 void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3162 struct cifs_sb_info *cifs_sb)
3164 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3166 spin_lock_init(&cifs_sb->tlink_tree_lock);
3167 cifs_sb->tlink_tree = RB_ROOT;
3170 * Temporarily set r/wsize for matching superblock. If we end up using
3171 * new sb then client will later negotiate it downward if needed.
3173 cifs_sb->rsize = pvolume_info->rsize;
3174 cifs_sb->wsize = pvolume_info->wsize;
3176 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3177 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3178 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3179 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3180 cFYI(1, "file mode: 0x%hx dir mode: 0x%hx",
3181 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3183 cifs_sb->actimeo = pvolume_info->actimeo;
3184 cifs_sb->local_nls = pvolume_info->local_nls;
3186 if (pvolume_info->noperm)
3187 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3188 if (pvolume_info->setuids)
3189 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3190 if (pvolume_info->server_ino)
3191 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3192 if (pvolume_info->remap)
3193 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3194 if (pvolume_info->no_xattr)
3195 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3196 if (pvolume_info->sfu_emul)
3197 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3198 if (pvolume_info->nobrl)
3199 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3200 if (pvolume_info->nostrictsync)
3201 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3202 if (pvolume_info->mand_lock)
3203 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3204 if (pvolume_info->rwpidforward)
3205 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3206 if (pvolume_info->cifs_acl)
3207 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3208 if (pvolume_info->backupuid_specified) {
3209 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3210 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3212 if (pvolume_info->backupgid_specified) {
3213 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3214 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3216 if (pvolume_info->override_uid)
3217 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3218 if (pvolume_info->override_gid)
3219 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3220 if (pvolume_info->dynperm)
3221 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3222 if (pvolume_info->fsc)
3223 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3224 if (pvolume_info->multiuser)
3225 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3226 CIFS_MOUNT_NO_PERM);
3227 if (pvolume_info->strict_io)
3228 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3229 if (pvolume_info->direct_io) {
3230 cFYI(1, "mounting share using direct i/o");
3231 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3233 if (pvolume_info->mfsymlinks) {
3234 if (pvolume_info->sfu_emul) {
3235 cERROR(1, "mount option mfsymlinks ignored if sfu "
3236 "mount option is used");
3238 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3242 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3243 cERROR(1, "mount option dynperm ignored if cifsacl "
3244 "mount option supported");
3248 * When the server supports very large reads and writes via POSIX extensions,
3249 * we can allow up to 2^24-1, minus the size of a READ/WRITE_AND_X header, not
3250 * including the RFC1001 length.
3252 * Note that this might make for "interesting" allocation problems during
3253 * writeback however as we have to allocate an array of pointers for the
3254 * pages. A 16M write means ~32kb page array with PAGE_CACHE_SIZE == 4096.
3256 * For reads, there is a similar problem as we need to allocate an array
3257 * of kvecs to handle the receive, though that should only need to be done
3260 #define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
3261 #define CIFS_MAX_RSIZE ((1<<24) - sizeof(READ_RSP) + 4)
3264 * When the server doesn't allow large posix writes, only allow a rsize/wsize
3265 * of 2^17-1 minus the size of the call header. That allows for a read or
3266 * write up to the maximum size described by RFC1002.
3268 #define CIFS_MAX_RFC1002_WSIZE ((1<<17) - 1 - sizeof(WRITE_REQ) + 4)
3269 #define CIFS_MAX_RFC1002_RSIZE ((1<<17) - 1 - sizeof(READ_RSP) + 4)
3272 * The default wsize is 1M. find_get_pages seems to return a maximum of 256
3273 * pages in a single call. With PAGE_CACHE_SIZE == 4k, this means we can fill
3274 * a single wsize request with a single call.
3276 #define CIFS_DEFAULT_IOSIZE (1024 * 1024)
3279 * Windows only supports a max of 60kb reads and 65535 byte writes. Default to
3280 * those values when posix extensions aren't in force. In actuality here, we
3281 * use 65536 to allow for a write that is a multiple of 4k. Most servers seem
3282 * to be ok with the extra byte even though Windows doesn't send writes that
3287 * http://blogs.msdn.com/b/openspecification/archive/2009/04/10/smb-maximum-transmit-buffer-size-and-performance-tuning.aspx
3289 #define CIFS_DEFAULT_NON_POSIX_RSIZE (60 * 1024)
3290 #define CIFS_DEFAULT_NON_POSIX_WSIZE (65536)
3293 * On hosts with high memory, we can't currently support wsize/rsize that are
3294 * larger than we can kmap at once. Cap the rsize/wsize at
3295 * LAST_PKMAP * PAGE_SIZE. We'll never be able to fill a read or write request
3296 * larger than that anyway.
3298 #ifdef CONFIG_HIGHMEM
3299 #define CIFS_KMAP_SIZE_LIMIT (LAST_PKMAP * PAGE_CACHE_SIZE)
3300 #else /* CONFIG_HIGHMEM */
3301 #define CIFS_KMAP_SIZE_LIMIT (1<<24)
3302 #endif /* CONFIG_HIGHMEM */
3305 cifs_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
3307 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3308 struct TCP_Server_Info *server = tcon->ses->server;
3311 /* start with specified wsize, or default */
3312 if (pvolume_info->wsize)
3313 wsize = pvolume_info->wsize;
3314 else if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
3315 wsize = CIFS_DEFAULT_IOSIZE;
3317 wsize = CIFS_DEFAULT_NON_POSIX_WSIZE;
3319 /* can server support 24-bit write sizes? (via UNIX extensions) */
3320 if (!tcon->unix_ext || !(unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
3321 wsize = min_t(unsigned int, wsize, CIFS_MAX_RFC1002_WSIZE);
3324 * no CAP_LARGE_WRITE_X or is signing enabled without CAP_UNIX set?
3325 * Limit it to max buffer offered by the server, minus the size of the
3326 * WRITEX header, not including the 4 byte RFC1001 length.
3328 if (!(server->capabilities & CAP_LARGE_WRITE_X) ||
3329 (!(server->capabilities & CAP_UNIX) &&
3330 (server->sec_mode & (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED))))
3331 wsize = min_t(unsigned int, wsize,
3332 server->maxBuf - sizeof(WRITE_REQ) + 4);
3334 /* limit to the amount that we can kmap at once */
3335 wsize = min_t(unsigned int, wsize, CIFS_KMAP_SIZE_LIMIT);
3337 /* hard limit of CIFS_MAX_WSIZE */
3338 wsize = min_t(unsigned int, wsize, CIFS_MAX_WSIZE);
3344 cifs_negotiate_rsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
3346 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3347 struct TCP_Server_Info *server = tcon->ses->server;
3348 unsigned int rsize, defsize;
3351 * Set default value...
3353 * HACK alert! Ancient servers have very small buffers. Even though
3354 * MS-CIFS indicates that servers are only limited by the client's
3355 * bufsize for reads, testing against win98se shows that it throws
3356 * INVALID_PARAMETER errors if you try to request too large a read.
3357 * OS/2 just sends back short reads.
3359 * If the server doesn't advertise CAP_LARGE_READ_X, then assume that
3360 * it can't handle a read request larger than its MaxBufferSize either.
3362 if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_READ_CAP))
3363 defsize = CIFS_DEFAULT_IOSIZE;
3364 else if (server->capabilities & CAP_LARGE_READ_X)
3365 defsize = CIFS_DEFAULT_NON_POSIX_RSIZE;
3367 defsize = server->maxBuf - sizeof(READ_RSP);
3369 rsize = pvolume_info->rsize ? pvolume_info->rsize : defsize;
3372 * no CAP_LARGE_READ_X? Then MS-CIFS states that we must limit this to
3373 * the client's MaxBufferSize.
3375 if (!(server->capabilities & CAP_LARGE_READ_X))
3376 rsize = min_t(unsigned int, CIFSMaxBufSize, rsize);
3378 /* limit to the amount that we can kmap at once */
3379 rsize = min_t(unsigned int, rsize, CIFS_KMAP_SIZE_LIMIT);
3381 /* hard limit of CIFS_MAX_RSIZE */
3382 rsize = min_t(unsigned int, rsize, CIFS_MAX_RSIZE);
3388 is_path_accessible(int xid, struct cifs_tcon *tcon,
3389 struct cifs_sb_info *cifs_sb, const char *full_path)
3392 FILE_ALL_INFO *pfile_info;
3394 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
3395 if (pfile_info == NULL)
3398 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
3399 0 /* not legacy */, cifs_sb->local_nls,
3400 cifs_sb->mnt_cifs_flags &
3401 CIFS_MOUNT_MAP_SPECIAL_CHR);
3403 if (rc == -EOPNOTSUPP || rc == -EINVAL)
3404 rc = SMBQueryInformation(xid, tcon, full_path, pfile_info,
3405 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
3406 CIFS_MOUNT_MAP_SPECIAL_CHR);
3412 cleanup_volume_info_contents(struct smb_vol *volume_info)
3414 kfree(volume_info->username);
3415 kzfree(volume_info->password);
3416 if (volume_info->UNCip != volume_info->UNC + 2)
3417 kfree(volume_info->UNCip);
3418 kfree(volume_info->UNC);
3419 kfree(volume_info->domainname);
3420 kfree(volume_info->iocharset);
3421 kfree(volume_info->prepath);
3425 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3429 cleanup_volume_info_contents(volume_info);
3434 #ifdef CONFIG_CIFS_DFS_UPCALL
3435 /* build_path_to_root returns full path to root when
3436 * we do not have an exiting connection (tcon) */
3438 build_unc_path_to_root(const struct smb_vol *vol,
3439 const struct cifs_sb_info *cifs_sb)
3441 char *full_path, *pos;
3442 unsigned int pplen = vol->prepath ? strlen(vol->prepath) : 0;
3443 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3445 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3446 if (full_path == NULL)
3447 return ERR_PTR(-ENOMEM);
3449 strncpy(full_path, vol->UNC, unc_len);
3450 pos = full_path + unc_len;
3453 strncpy(pos, vol->prepath, pplen);
3457 *pos = '\0'; /* add trailing null */
3458 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3459 cFYI(1, "%s: full_path=%s", __func__, full_path);
3464 * Perform a dfs referral query for a share and (optionally) prefix
3466 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3467 * to a string containing updated options for the submount. Otherwise it
3468 * will be left untouched.
3470 * Returns the rc from get_dfs_path to the caller, which can be used to
3471 * determine whether there were referrals.
3474 expand_dfs_referral(int xid, struct cifs_ses *pSesInfo,
3475 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3479 unsigned int num_referrals = 0;
3480 struct dfs_info3_param *referrals = NULL;
3481 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3483 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3484 if (IS_ERR(full_path))
3485 return PTR_ERR(full_path);
3487 /* For DFS paths, skip the first '\' of the UNC */
3488 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3490 rc = get_dfs_path(xid, pSesInfo , ref_path, cifs_sb->local_nls,
3491 &num_referrals, &referrals,
3492 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
3494 if (!rc && num_referrals > 0) {
3495 char *fake_devname = NULL;
3497 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3498 full_path + 1, referrals,
3501 free_dfs_info_array(referrals, num_referrals);
3503 if (IS_ERR(mdata)) {
3504 rc = PTR_ERR(mdata);
3507 cleanup_volume_info_contents(volume_info);
3508 memset(volume_info, '\0', sizeof(*volume_info));
3509 rc = cifs_setup_volume_info(volume_info, mdata,
3512 kfree(fake_devname);
3513 kfree(cifs_sb->mountdata);
3514 cifs_sb->mountdata = mdata;
3522 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3523 const char *devname)
3527 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3531 if (volume_info->nullauth) {
3532 cFYI(1, "Anonymous login");
3533 kfree(volume_info->username);
3534 volume_info->username = NULL;
3535 } else if (volume_info->username) {
3536 /* BB fixme parse for domain name here */
3537 cFYI(1, "Username: %s", volume_info->username);
3539 cifserror("No username specified");
3540 /* In userspace mount helper we can get user name from alternate
3541 locations such as env variables and files on disk */
3545 /* this is needed for ASCII cp to Unicode converts */
3546 if (volume_info->iocharset == NULL) {
3547 /* load_nls_default cannot return null */
3548 volume_info->local_nls = load_nls_default();
3550 volume_info->local_nls = load_nls(volume_info->iocharset);
3551 if (volume_info->local_nls == NULL) {
3552 cERROR(1, "CIFS mount error: iocharset %s not found",
3553 volume_info->iocharset);
3562 cifs_get_volume_info(char *mount_data, const char *devname)
3565 struct smb_vol *volume_info;
3567 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
3569 return ERR_PTR(-ENOMEM);
3571 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3573 cifs_cleanup_volume_info(volume_info);
3574 volume_info = ERR_PTR(rc);
3581 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3585 struct cifs_ses *pSesInfo;
3586 struct cifs_tcon *tcon;
3587 struct TCP_Server_Info *srvTcp;
3589 struct tcon_link *tlink;
3590 #ifdef CONFIG_CIFS_DFS_UPCALL
3591 int referral_walks_count = 0;
3594 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3598 #ifdef CONFIG_CIFS_DFS_UPCALL
3600 /* cleanup activities if we're chasing a referral */
3601 if (referral_walks_count) {
3603 cifs_put_tcon(tcon);
3605 cifs_put_smb_ses(pSesInfo);
3619 /* get a reference to a tcp session */
3620 srvTcp = cifs_get_tcp_session(volume_info);
3621 if (IS_ERR(srvTcp)) {
3622 rc = PTR_ERR(srvTcp);
3623 bdi_destroy(&cifs_sb->bdi);
3627 /* get a reference to a SMB session */
3628 pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
3629 if (IS_ERR(pSesInfo)) {
3630 rc = PTR_ERR(pSesInfo);
3632 goto mount_fail_check;
3635 /* search for existing tcon to this server share */
3636 tcon = cifs_get_tcon(pSesInfo, volume_info);
3640 goto remote_path_check;
3643 /* tell server which Unix caps we support */
3644 if (tcon->ses->capabilities & CAP_UNIX) {
3645 /* reset of caps checks mount to see if unix extensions
3646 disabled for just this mount */
3647 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3648 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3649 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3650 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3652 goto mount_fail_check;
3655 tcon->unix_ext = 0; /* server does not support them */
3657 /* do not care if following two calls succeed - informational */
3659 CIFSSMBQFSDeviceInfo(xid, tcon);
3660 CIFSSMBQFSAttributeInfo(xid, tcon);
3663 cifs_sb->wsize = cifs_negotiate_wsize(tcon, volume_info);
3664 cifs_sb->rsize = cifs_negotiate_rsize(tcon, volume_info);
3666 /* tune readahead according to rsize */
3667 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
3670 #ifdef CONFIG_CIFS_DFS_UPCALL
3672 * Perform an unconditional check for whether there are DFS
3673 * referrals for this path without prefix, to provide support
3674 * for DFS referrals from w2k8 servers which don't seem to respond
3675 * with PATH_NOT_COVERED to requests that include the prefix.
3676 * Chase the referral if found, otherwise continue normally.
3678 if (referral_walks_count == 0) {
3679 int refrc = expand_dfs_referral(xid, pSesInfo, volume_info,
3682 referral_walks_count++;
3683 goto try_mount_again;
3688 /* check if a whole path is not remote */
3690 /* build_path_to_root works only when we have a valid tcon */
3691 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3692 if (full_path == NULL) {
3694 goto mount_fail_check;
3696 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
3697 if (rc != 0 && rc != -EREMOTE) {
3699 goto mount_fail_check;
3704 /* get referral if needed */
3705 if (rc == -EREMOTE) {
3706 #ifdef CONFIG_CIFS_DFS_UPCALL
3707 if (referral_walks_count > MAX_NESTED_LINKS) {
3709 * BB: when we implement proper loop detection,
3710 * we will remove this check. But now we need it
3711 * to prevent an indefinite loop if 'DFS tree' is
3712 * misconfigured (i.e. has loops).
3715 goto mount_fail_check;
3718 rc = expand_dfs_referral(xid, pSesInfo, volume_info, cifs_sb,
3722 referral_walks_count++;
3723 goto try_mount_again;
3725 goto mount_fail_check;
3726 #else /* No DFS support, return error on mount */
3732 goto mount_fail_check;
3734 /* now, hang the tcon off of the superblock */
3735 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3736 if (tlink == NULL) {
3738 goto mount_fail_check;
3741 tlink->tl_uid = pSesInfo->linux_uid;
3742 tlink->tl_tcon = tcon;
3743 tlink->tl_time = jiffies;
3744 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3745 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3747 cifs_sb->master_tlink = tlink;
3748 spin_lock(&cifs_sb->tlink_tree_lock);
3749 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3750 spin_unlock(&cifs_sb->tlink_tree_lock);
3752 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3756 /* on error free sesinfo and tcon struct if needed */
3758 /* If find_unc succeeded then rc == 0 so we can not end */
3759 /* up accidentally freeing someone elses tcon struct */
3761 cifs_put_tcon(tcon);
3763 cifs_put_smb_ses(pSesInfo);
3765 cifs_put_tcp_session(srvTcp);
3766 bdi_destroy(&cifs_sb->bdi);
3775 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3776 * pointer may be NULL.
3779 CIFSTCon(unsigned int xid, struct cifs_ses *ses,
3780 const char *tree, struct cifs_tcon *tcon,
3781 const struct nls_table *nls_codepage)
3783 struct smb_hdr *smb_buffer;
3784 struct smb_hdr *smb_buffer_response;
3787 unsigned char *bcc_ptr;
3790 __u16 bytes_left, count;
3795 smb_buffer = cifs_buf_get();
3796 if (smb_buffer == NULL)
3799 smb_buffer_response = smb_buffer;
3801 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3802 NULL /*no tid */ , 4 /*wct */ );
3804 smb_buffer->Mid = get_next_mid(ses->server);
3805 smb_buffer->Uid = ses->Suid;
3806 pSMB = (TCONX_REQ *) smb_buffer;
3807 pSMBr = (TCONX_RSP *) smb_buffer_response;
3809 pSMB->AndXCommand = 0xFF;
3810 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3811 bcc_ptr = &pSMB->Password[0];
3812 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3813 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3814 *bcc_ptr = 0; /* password is null byte */
3815 bcc_ptr++; /* skip password */
3816 /* already aligned so no need to do it below */
3818 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3819 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3820 specified as required (when that support is added to
3821 the vfs in the future) as only NTLM or the much
3822 weaker LANMAN (which we do not send by default) is accepted
3823 by Samba (not sure whether other servers allow
3824 NTLMv2 password here) */
3825 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3826 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3827 (ses->server->secType == LANMAN))
3828 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3829 ses->server->sec_mode &
3830 SECMODE_PW_ENCRYPT ? true : false,
3833 #endif /* CIFS_WEAK_PW_HASH */
3834 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3835 bcc_ptr, nls_codepage);
3837 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3838 if (ses->capabilities & CAP_UNICODE) {
3839 /* must align unicode strings */
3840 *bcc_ptr = 0; /* null byte password */
3845 if (ses->server->sec_mode &
3846 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3847 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3849 if (ses->capabilities & CAP_STATUS32) {
3850 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3852 if (ses->capabilities & CAP_DFS) {
3853 smb_buffer->Flags2 |= SMBFLG2_DFS;
3855 if (ses->capabilities & CAP_UNICODE) {
3856 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3858 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3859 6 /* max utf8 char length in bytes */ *
3860 (/* server len*/ + 256 /* share len */), nls_codepage);
3861 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3862 bcc_ptr += 2; /* skip trailing null */
3863 } else { /* ASCII */
3864 strcpy(bcc_ptr, tree);
3865 bcc_ptr += strlen(tree) + 1;
3867 strcpy(bcc_ptr, "?????");
3868 bcc_ptr += strlen("?????");
3870 count = bcc_ptr - &pSMB->Password[0];
3871 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3872 pSMB->hdr.smb_buf_length) + count);
3873 pSMB->ByteCount = cpu_to_le16(count);
3875 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3878 /* above now done in SendReceive */
3879 if ((rc == 0) && (tcon != NULL)) {
3882 tcon->tidStatus = CifsGood;
3883 tcon->need_reconnect = false;
3884 tcon->tid = smb_buffer_response->Tid;
3885 bcc_ptr = pByteArea(smb_buffer_response);
3886 bytes_left = get_bcc(smb_buffer_response);
3887 length = strnlen(bcc_ptr, bytes_left - 2);
3888 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3894 /* skip service field (NB: this field is always ASCII) */
3896 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3897 (bcc_ptr[2] == 'C')) {
3898 cFYI(1, "IPC connection");
3901 } else if (length == 2) {
3902 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3903 /* the most common case */
3904 cFYI(1, "disk share connection");
3907 bcc_ptr += length + 1;
3908 bytes_left -= (length + 1);
3909 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3911 /* mostly informational -- no need to fail on error here */
3912 kfree(tcon->nativeFileSystem);
3913 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
3914 bytes_left, is_unicode,
3917 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
3919 if ((smb_buffer_response->WordCount == 3) ||
3920 (smb_buffer_response->WordCount == 7))
3921 /* field is in same location */
3922 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3925 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
3926 } else if ((rc == 0) && tcon == NULL) {
3927 /* all we need to save for IPC$ connection */
3928 ses->ipc_tid = smb_buffer_response->Tid;
3931 cifs_buf_release(smb_buffer);
3936 cifs_umount(struct cifs_sb_info *cifs_sb)
3938 struct rb_root *root = &cifs_sb->tlink_tree;
3939 struct rb_node *node;
3940 struct tcon_link *tlink;
3942 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3944 spin_lock(&cifs_sb->tlink_tree_lock);
3945 while ((node = rb_first(root))) {
3946 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3947 cifs_get_tlink(tlink);
3948 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3949 rb_erase(node, root);
3951 spin_unlock(&cifs_sb->tlink_tree_lock);
3952 cifs_put_tlink(tlink);
3953 spin_lock(&cifs_sb->tlink_tree_lock);
3955 spin_unlock(&cifs_sb->tlink_tree_lock);
3957 bdi_destroy(&cifs_sb->bdi);
3958 kfree(cifs_sb->mountdata);
3959 unload_nls(cifs_sb->local_nls);
3963 int cifs_negotiate_protocol(unsigned int xid, struct cifs_ses *ses)
3966 struct TCP_Server_Info *server = ses->server;
3968 /* only send once per connect */
3969 if (server->maxBuf != 0)
3972 set_credits(server, 1);
3973 rc = CIFSSMBNegotiate(xid, ses);
3974 if (rc == -EAGAIN) {
3975 /* retry only once on 1st time connection */
3976 set_credits(server, 1);
3977 rc = CIFSSMBNegotiate(xid, ses);
3982 spin_lock(&GlobalMid_Lock);
3983 if (server->tcpStatus == CifsNeedNegotiate)
3984 server->tcpStatus = CifsGood;
3987 spin_unlock(&GlobalMid_Lock);
3995 int cifs_setup_session(unsigned int xid, struct cifs_ses *ses,
3996 struct nls_table *nls_info)
3999 struct TCP_Server_Info *server = ses->server;
4002 ses->capabilities = server->capabilities;
4003 if (linuxExtEnabled == 0)
4004 ses->capabilities &= (~CAP_UNIX);
4006 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
4007 server->sec_mode, server->capabilities, server->timeAdj);
4009 rc = CIFS_SessSetup(xid, ses, nls_info);
4011 cERROR(1, "Send error in SessSetup = %d", rc);
4013 mutex_lock(&ses->server->srv_mutex);
4014 if (!server->session_estab) {
4015 server->session_key.response = ses->auth_key.response;
4016 server->session_key.len = ses->auth_key.len;
4017 server->sequence_number = 0x2;
4018 server->session_estab = true;
4019 ses->auth_key.response = NULL;
4021 mutex_unlock(&server->srv_mutex);
4023 cFYI(1, "CIFS Session Established successfully");
4024 spin_lock(&GlobalMid_Lock);
4025 ses->status = CifsGood;
4026 ses->need_reconnect = false;
4027 spin_unlock(&GlobalMid_Lock);
4030 kfree(ses->auth_key.response);
4031 ses->auth_key.response = NULL;
4032 ses->auth_key.len = 0;
4033 kfree(ses->ntlmssp);
4034 ses->ntlmssp = NULL;
4040 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
4042 switch (ses->server->secType) {
4044 vol->secFlg = CIFSSEC_MUST_KRB5;
4047 vol->secFlg = CIFSSEC_MUST_NTLMV2;
4050 vol->secFlg = CIFSSEC_MUST_NTLM;
4053 vol->secFlg = CIFSSEC_MUST_NTLMSSP;
4056 vol->secFlg = CIFSSEC_MUST_LANMAN;
4060 return cifs_set_cifscreds(vol, ses);
4063 static struct cifs_tcon *
4064 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
4067 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4068 struct cifs_ses *ses;
4069 struct cifs_tcon *tcon = NULL;
4070 struct smb_vol *vol_info;
4072 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
4073 if (vol_info == NULL)
4074 return ERR_PTR(-ENOMEM);
4076 vol_info->local_nls = cifs_sb->local_nls;
4077 vol_info->linux_uid = fsuid;
4078 vol_info->cred_uid = fsuid;
4079 vol_info->UNC = master_tcon->treeName;
4080 vol_info->retry = master_tcon->retry;
4081 vol_info->nocase = master_tcon->nocase;
4082 vol_info->local_lease = master_tcon->local_lease;
4083 vol_info->no_linux_ext = !master_tcon->unix_ext;
4085 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4091 /* get a reference for the same TCP session */
4092 spin_lock(&cifs_tcp_ses_lock);
4093 ++master_tcon->ses->server->srv_count;
4094 spin_unlock(&cifs_tcp_ses_lock);
4096 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4098 tcon = (struct cifs_tcon *)ses;
4099 cifs_put_tcp_session(master_tcon->ses->server);
4103 tcon = cifs_get_tcon(ses, vol_info);
4105 cifs_put_smb_ses(ses);
4109 if (ses->capabilities & CAP_UNIX)
4110 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4112 kfree(vol_info->username);
4113 kfree(vol_info->password);
4120 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4122 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4126 cifs_sb_tcon_pending_wait(void *unused)
4129 return signal_pending(current) ? -ERESTARTSYS : 0;
4132 /* find and return a tlink with given uid */
4133 static struct tcon_link *
4134 tlink_rb_search(struct rb_root *root, uid_t uid)
4136 struct rb_node *node = root->rb_node;
4137 struct tcon_link *tlink;
4140 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4142 if (tlink->tl_uid > uid)
4143 node = node->rb_left;
4144 else if (tlink->tl_uid < uid)
4145 node = node->rb_right;
4152 /* insert a tcon_link into the tree */
4154 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4156 struct rb_node **new = &(root->rb_node), *parent = NULL;
4157 struct tcon_link *tlink;
4160 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4163 if (tlink->tl_uid > new_tlink->tl_uid)
4164 new = &((*new)->rb_left);
4166 new = &((*new)->rb_right);
4169 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4170 rb_insert_color(&new_tlink->tl_rbnode, root);
4174 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4177 * If the superblock doesn't refer to a multiuser mount, then just return
4178 * the master tcon for the mount.
4180 * First, search the rbtree for an existing tcon for this fsuid. If one
4181 * exists, then check to see if it's pending construction. If it is then wait
4182 * for construction to complete. Once it's no longer pending, check to see if
4183 * it failed and either return an error or retry construction, depending on
4186 * If one doesn't exist then insert a new tcon_link struct into the tree and
4187 * try to construct a new one.
4190 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4193 uid_t fsuid = current_fsuid();
4194 struct tcon_link *tlink, *newtlink;
4196 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4197 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4199 spin_lock(&cifs_sb->tlink_tree_lock);
4200 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4202 cifs_get_tlink(tlink);
4203 spin_unlock(&cifs_sb->tlink_tree_lock);
4205 if (tlink == NULL) {
4206 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4207 if (newtlink == NULL)
4208 return ERR_PTR(-ENOMEM);
4209 newtlink->tl_uid = fsuid;
4210 newtlink->tl_tcon = ERR_PTR(-EACCES);
4211 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4212 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4213 cifs_get_tlink(newtlink);
4215 spin_lock(&cifs_sb->tlink_tree_lock);
4216 /* was one inserted after previous search? */
4217 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4219 cifs_get_tlink(tlink);
4220 spin_unlock(&cifs_sb->tlink_tree_lock);
4222 goto wait_for_construction;
4225 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4226 spin_unlock(&cifs_sb->tlink_tree_lock);
4228 wait_for_construction:
4229 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4230 cifs_sb_tcon_pending_wait,
4231 TASK_INTERRUPTIBLE);
4233 cifs_put_tlink(tlink);
4234 return ERR_PTR(ret);
4237 /* if it's good, return it */
4238 if (!IS_ERR(tlink->tl_tcon))
4241 /* return error if we tried this already recently */
4242 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4243 cifs_put_tlink(tlink);
4244 return ERR_PTR(-EACCES);
4247 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4248 goto wait_for_construction;
4251 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4252 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4253 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4255 if (IS_ERR(tlink->tl_tcon)) {
4256 cifs_put_tlink(tlink);
4257 return ERR_PTR(-EACCES);
4264 * periodic workqueue job that scans tcon_tree for a superblock and closes
4268 cifs_prune_tlinks(struct work_struct *work)
4270 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4272 struct rb_root *root = &cifs_sb->tlink_tree;
4273 struct rb_node *node = rb_first(root);
4274 struct rb_node *tmp;
4275 struct tcon_link *tlink;
4278 * Because we drop the spinlock in the loop in order to put the tlink
4279 * it's not guarded against removal of links from the tree. The only
4280 * places that remove entries from the tree are this function and
4281 * umounts. Because this function is non-reentrant and is canceled
4282 * before umount can proceed, this is safe.
4284 spin_lock(&cifs_sb->tlink_tree_lock);
4285 node = rb_first(root);
4286 while (node != NULL) {
4288 node = rb_next(tmp);
4289 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4291 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4292 atomic_read(&tlink->tl_count) != 0 ||
4293 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4296 cifs_get_tlink(tlink);
4297 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4298 rb_erase(tmp, root);
4300 spin_unlock(&cifs_sb->tlink_tree_lock);
4301 cifs_put_tlink(tlink);
4302 spin_lock(&cifs_sb->tlink_tree_lock);
4304 spin_unlock(&cifs_sb->tlink_tree_lock);
4306 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,