4 * Copyright (C) International Business Machines Corp., 2002,2009
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,
107 /* Mount options to be ignored */
110 /* Options which could be blank */
116 static const match_table_t cifs_mount_option_tokens = {
118 { Opt_user_xattr, "user_xattr" },
119 { Opt_nouser_xattr, "nouser_xattr" },
120 { Opt_forceuid, "forceuid" },
121 { Opt_noforceuid, "noforceuid" },
122 { Opt_noblocksend, "noblocksend" },
123 { Opt_noautotune, "noautotune" },
124 { Opt_hard, "hard" },
125 { Opt_soft, "soft" },
126 { Opt_perm, "perm" },
127 { Opt_noperm, "noperm" },
128 { Opt_mapchars, "mapchars" },
129 { Opt_nomapchars, "nomapchars" },
131 { Opt_nosfu, "nosfu" },
132 { Opt_nodfs, "nodfs" },
133 { Opt_posixpaths, "posixpaths" },
134 { Opt_noposixpaths, "noposixpaths" },
135 { Opt_nounix, "nounix" },
136 { Opt_nounix, "nolinux" },
137 { Opt_nocase, "nocase" },
138 { Opt_nocase, "ignorecase" },
140 { Opt_nobrl, "nobrl" },
141 { Opt_nobrl, "nolock" },
142 { Opt_forcemandatorylock, "forcemandatorylock" },
143 { Opt_forcemandatorylock, "forcemand" },
144 { Opt_setuids, "setuids" },
145 { Opt_nosetuids, "nosetuids" },
146 { Opt_dynperm, "dynperm" },
147 { Opt_nodynperm, "nodynperm" },
148 { Opt_nohard, "nohard" },
149 { Opt_nosoft, "nosoft" },
150 { Opt_nointr, "nointr" },
151 { Opt_intr, "intr" },
152 { Opt_nostrictsync, "nostrictsync" },
153 { Opt_strictsync, "strictsync" },
154 { Opt_serverino, "serverino" },
155 { Opt_noserverino, "noserverino" },
156 { Opt_rwpidforward, "rwpidforward" },
157 { Opt_cifsacl, "cifsacl" },
158 { Opt_nocifsacl, "nocifsacl" },
160 { Opt_noacl, "noacl" },
161 { Opt_locallease, "locallease" },
162 { Opt_sign, "sign" },
163 { Opt_seal, "seal" },
164 { Opt_direct, "direct" },
165 { Opt_direct, "forceddirectio" },
166 { Opt_strictcache, "strictcache" },
167 { Opt_noac, "noac" },
169 { Opt_mfsymlinks, "mfsymlinks" },
170 { Opt_multiuser, "multiuser" },
171 { Opt_sloppy, "sloppy" },
173 { Opt_backupuid, "backupuid=%s" },
174 { Opt_backupgid, "backupgid=%s" },
175 { Opt_uid, "uid=%s" },
176 { Opt_cruid, "cruid=%s" },
177 { Opt_gid, "gid=%s" },
178 { Opt_file_mode, "file_mode=%s" },
179 { Opt_dirmode, "dirmode=%s" },
180 { Opt_dirmode, "dir_mode=%s" },
181 { Opt_port, "port=%s" },
182 { Opt_rsize, "rsize=%s" },
183 { Opt_wsize, "wsize=%s" },
184 { Opt_actimeo, "actimeo=%s" },
186 { Opt_user, "user=%s" },
187 { Opt_user, "username=%s" },
188 { Opt_blank_pass, "pass=" },
189 { Opt_pass, "pass=%s" },
190 { Opt_pass, "password=%s" },
192 { Opt_ip, "addr=%s" },
193 { Opt_unc, "unc=%s" },
194 { Opt_unc, "target=%s" },
195 { Opt_unc, "path=%s" },
196 { Opt_domain, "dom=%s" },
197 { Opt_domain, "domain=%s" },
198 { Opt_domain, "workgroup=%s" },
199 { Opt_srcaddr, "srcaddr=%s" },
200 { Opt_prefixpath, "prefixpath=%s" },
201 { Opt_iocharset, "iocharset=%s" },
202 { Opt_sockopt, "sockopt=%s" },
203 { Opt_netbiosname, "netbiosname=%s" },
204 { Opt_servern, "servern=%s" },
205 { Opt_ver, "ver=%s" },
206 { Opt_ver, "vers=%s" },
207 { Opt_ver, "version=%s" },
208 { Opt_sec, "sec=%s" },
210 { Opt_ignore, "cred" },
211 { Opt_ignore, "credentials" },
212 { Opt_ignore, "guest" },
213 { Opt_ignore, "rw" },
214 { Opt_ignore, "ro" },
215 { Opt_ignore, "suid" },
216 { Opt_ignore, "nosuid" },
217 { Opt_ignore, "exec" },
218 { Opt_ignore, "noexec" },
219 { Opt_ignore, "nodev" },
220 { Opt_ignore, "noauto" },
221 { Opt_ignore, "dev" },
222 { Opt_ignore, "mand" },
223 { Opt_ignore, "nomand" },
224 { Opt_ignore, "_netdev" },
230 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
231 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
232 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2i,
233 Opt_sec_nontlm, Opt_sec_lanman,
239 static const match_table_t cifs_secflavor_tokens = {
240 { Opt_sec_krb5, "krb5" },
241 { Opt_sec_krb5i, "krb5i" },
242 { Opt_sec_krb5p, "krb5p" },
243 { Opt_sec_ntlmsspi, "ntlmsspi" },
244 { Opt_sec_ntlmssp, "ntlmssp" },
245 { Opt_ntlm, "ntlm" },
246 { Opt_sec_ntlmi, "ntlmi" },
247 { Opt_sec_ntlmv2i, "ntlmv2i" },
248 { Opt_sec_nontlm, "nontlm" },
249 { Opt_sec_lanman, "lanman" },
250 { Opt_sec_none, "none" },
252 { Opt_sec_err, NULL }
255 static int ip_connect(struct TCP_Server_Info *server);
256 static int generic_ip_connect(struct TCP_Server_Info *server);
257 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
258 static void cifs_prune_tlinks(struct work_struct *work);
259 static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
260 const char *devname);
263 * cifs tcp session reconnection
265 * mark tcp session as reconnecting so temporarily locked
266 * mark all smb sessions as reconnecting for tcp session
267 * reconnect tcp session
268 * wake up waiters on reconnection? - (not needed currently)
271 cifs_reconnect(struct TCP_Server_Info *server)
274 struct list_head *tmp, *tmp2;
275 struct cifs_ses *ses;
276 struct cifs_tcon *tcon;
277 struct mid_q_entry *mid_entry;
278 struct list_head retry_list;
280 spin_lock(&GlobalMid_Lock);
281 if (server->tcpStatus == CifsExiting) {
282 /* the demux thread will exit normally
283 next time through the loop */
284 spin_unlock(&GlobalMid_Lock);
287 server->tcpStatus = CifsNeedReconnect;
288 spin_unlock(&GlobalMid_Lock);
291 cFYI(1, "Reconnecting tcp session");
293 /* before reconnecting the tcp session, mark the smb session (uid)
294 and the tid bad so they are not used until reconnected */
295 cFYI(1, "%s: marking sessions and tcons for reconnect", __func__);
296 spin_lock(&cifs_tcp_ses_lock);
297 list_for_each(tmp, &server->smb_ses_list) {
298 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
299 ses->need_reconnect = true;
301 list_for_each(tmp2, &ses->tcon_list) {
302 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
303 tcon->need_reconnect = true;
306 spin_unlock(&cifs_tcp_ses_lock);
308 /* do not want to be sending data on a socket we are freeing */
309 cFYI(1, "%s: tearing down socket", __func__);
310 mutex_lock(&server->srv_mutex);
311 if (server->ssocket) {
312 cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
313 server->ssocket->flags);
314 kernel_sock_shutdown(server->ssocket, SHUT_WR);
315 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
316 server->ssocket->state,
317 server->ssocket->flags);
318 sock_release(server->ssocket);
319 server->ssocket = NULL;
321 server->sequence_number = 0;
322 server->session_estab = false;
323 kfree(server->session_key.response);
324 server->session_key.response = NULL;
325 server->session_key.len = 0;
326 server->lstrp = jiffies;
327 mutex_unlock(&server->srv_mutex);
329 /* mark submitted MIDs for retry and issue callback */
330 INIT_LIST_HEAD(&retry_list);
331 cFYI(1, "%s: moving mids to private list", __func__);
332 spin_lock(&GlobalMid_Lock);
333 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
334 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
335 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
336 mid_entry->mid_state = MID_RETRY_NEEDED;
337 list_move(&mid_entry->qhead, &retry_list);
339 spin_unlock(&GlobalMid_Lock);
341 cFYI(1, "%s: issuing mid callbacks", __func__);
342 list_for_each_safe(tmp, tmp2, &retry_list) {
343 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
344 list_del_init(&mid_entry->qhead);
345 mid_entry->callback(mid_entry);
351 /* we should try only the port we connected to before */
352 rc = generic_ip_connect(server);
354 cFYI(1, "reconnect error %d", rc);
357 atomic_inc(&tcpSesReconnectCount);
358 spin_lock(&GlobalMid_Lock);
359 if (server->tcpStatus != CifsExiting)
360 server->tcpStatus = CifsNeedNegotiate;
361 spin_unlock(&GlobalMid_Lock);
363 } while (server->tcpStatus == CifsNeedReconnect);
370 0 not a transact2, or all data present
371 >0 transact2 with that much data missing
372 -EINVAL = invalid transact2
375 static int check2ndT2(char *buf)
377 struct smb_hdr *pSMB = (struct smb_hdr *)buf;
378 struct smb_t2_rsp *pSMBt;
380 __u16 total_data_size, data_in_this_rsp;
382 if (pSMB->Command != SMB_COM_TRANSACTION2)
385 /* check for plausible wct, bcc and t2 data and parm sizes */
386 /* check for parm and data offset going beyond end of smb */
387 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
388 cFYI(1, "invalid transact2 word count");
392 pSMBt = (struct smb_t2_rsp *)pSMB;
394 total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
395 data_in_this_rsp = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
397 if (total_data_size == data_in_this_rsp)
399 else if (total_data_size < data_in_this_rsp) {
400 cFYI(1, "total data %d smaller than data in frame %d",
401 total_data_size, data_in_this_rsp);
405 remaining = total_data_size - data_in_this_rsp;
407 cFYI(1, "missing %d bytes from transact2, check next response",
409 if (total_data_size > CIFSMaxBufSize) {
410 cERROR(1, "TotalDataSize %d is over maximum buffer %d",
411 total_data_size, CIFSMaxBufSize);
417 static int coalesce_t2(char *second_buf, struct smb_hdr *target_hdr)
419 struct smb_t2_rsp *pSMBs = (struct smb_t2_rsp *)second_buf;
420 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)target_hdr;
421 char *data_area_of_tgt;
422 char *data_area_of_src;
424 unsigned int byte_count, total_in_tgt;
425 __u16 tgt_total_cnt, src_total_cnt, total_in_src;
427 src_total_cnt = get_unaligned_le16(&pSMBs->t2_rsp.TotalDataCount);
428 tgt_total_cnt = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
430 if (tgt_total_cnt != src_total_cnt)
431 cFYI(1, "total data count of primary and secondary t2 differ "
432 "source=%hu target=%hu", src_total_cnt, tgt_total_cnt);
434 total_in_tgt = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
436 remaining = tgt_total_cnt - total_in_tgt;
439 cFYI(1, "Server sent too much data. tgt_total_cnt=%hu "
440 "total_in_tgt=%hu", tgt_total_cnt, total_in_tgt);
444 if (remaining == 0) {
445 /* nothing to do, ignore */
446 cFYI(1, "no more data remains");
450 total_in_src = get_unaligned_le16(&pSMBs->t2_rsp.DataCount);
451 if (remaining < total_in_src)
452 cFYI(1, "transact2 2nd response contains too much data");
454 /* find end of first SMB data area */
455 data_area_of_tgt = (char *)&pSMBt->hdr.Protocol +
456 get_unaligned_le16(&pSMBt->t2_rsp.DataOffset);
458 /* validate target area */
459 data_area_of_src = (char *)&pSMBs->hdr.Protocol +
460 get_unaligned_le16(&pSMBs->t2_rsp.DataOffset);
462 data_area_of_tgt += total_in_tgt;
464 total_in_tgt += total_in_src;
465 /* is the result too big for the field? */
466 if (total_in_tgt > USHRT_MAX) {
467 cFYI(1, "coalesced DataCount too large (%u)", total_in_tgt);
470 put_unaligned_le16(total_in_tgt, &pSMBt->t2_rsp.DataCount);
473 byte_count = get_bcc(target_hdr);
474 byte_count += total_in_src;
475 /* is the result too big for the field? */
476 if (byte_count > USHRT_MAX) {
477 cFYI(1, "coalesced BCC too large (%u)", byte_count);
480 put_bcc(byte_count, target_hdr);
482 byte_count = be32_to_cpu(target_hdr->smb_buf_length);
483 byte_count += total_in_src;
484 /* don't allow buffer to overflow */
485 if (byte_count > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
486 cFYI(1, "coalesced BCC exceeds buffer size (%u)", byte_count);
489 target_hdr->smb_buf_length = cpu_to_be32(byte_count);
491 /* copy second buffer into end of first buffer */
492 memcpy(data_area_of_tgt, data_area_of_src, total_in_src);
494 if (remaining != total_in_src) {
495 /* more responses to go */
496 cFYI(1, "waiting for more secondary responses");
501 cFYI(1, "found the last secondary response");
506 cifs_echo_request(struct work_struct *work)
509 struct TCP_Server_Info *server = container_of(work,
510 struct TCP_Server_Info, echo.work);
513 * We cannot send an echo until the NEGOTIATE_PROTOCOL request is
514 * done, which is indicated by maxBuf != 0. Also, no need to ping if
515 * we got a response recently
517 if (server->maxBuf == 0 ||
518 time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
521 rc = CIFSSMBEcho(server);
523 cFYI(1, "Unable to send echo request to server: %s",
527 queue_delayed_work(cifsiod_wq, &server->echo, SMB_ECHO_INTERVAL);
531 allocate_buffers(struct TCP_Server_Info *server)
533 if (!server->bigbuf) {
534 server->bigbuf = (char *)cifs_buf_get();
535 if (!server->bigbuf) {
536 cERROR(1, "No memory for large SMB response");
538 /* retry will check if exiting */
541 } else if (server->large_buf) {
542 /* we are reusing a dirty large buf, clear its start */
543 memset(server->bigbuf, 0, header_size());
546 if (!server->smallbuf) {
547 server->smallbuf = (char *)cifs_small_buf_get();
548 if (!server->smallbuf) {
549 cERROR(1, "No memory for SMB response");
551 /* retry will check if exiting */
554 /* beginning of smb buffer is cleared in our buf_get */
556 /* if existing small buf clear beginning */
557 memset(server->smallbuf, 0, header_size());
564 server_unresponsive(struct TCP_Server_Info *server)
567 * We need to wait 2 echo intervals to make sure we handle such
569 * 1s client sends a normal SMB request
570 * 2s client gets a response
571 * 30s echo workqueue job pops, and decides we got a response recently
572 * and don't need to send another
574 * 65s kernel_recvmsg times out, and we see that we haven't gotten
575 * a response in >60s.
577 if (server->tcpStatus == CifsGood &&
578 time_after(jiffies, server->lstrp + 2 * SMB_ECHO_INTERVAL)) {
579 cERROR(1, "Server %s has not responded in %d seconds. "
580 "Reconnecting...", server->hostname,
581 (2 * SMB_ECHO_INTERVAL) / HZ);
582 cifs_reconnect(server);
583 wake_up(&server->response_q);
591 * kvec_array_init - clone a kvec array, and advance into it
592 * @new: pointer to memory for cloned array
593 * @iov: pointer to original array
594 * @nr_segs: number of members in original array
595 * @bytes: number of bytes to advance into the cloned array
597 * This function will copy the array provided in iov to a section of memory
598 * and advance the specified number of bytes into the new array. It returns
599 * the number of segments in the new array. "new" must be at least as big as
600 * the original iov array.
603 kvec_array_init(struct kvec *new, struct kvec *iov, unsigned int nr_segs,
608 while (bytes || !iov->iov_len) {
609 int copy = min(bytes, iov->iov_len);
613 if (iov->iov_len == base) {
619 memcpy(new, iov, sizeof(*iov) * nr_segs);
620 new->iov_base += base;
621 new->iov_len -= base;
626 get_server_iovec(struct TCP_Server_Info *server, unsigned int nr_segs)
628 struct kvec *new_iov;
630 if (server->iov && nr_segs <= server->nr_iov)
633 /* not big enough -- allocate a new one and release the old */
634 new_iov = kmalloc(sizeof(*new_iov) * nr_segs, GFP_NOFS);
637 server->iov = new_iov;
638 server->nr_iov = nr_segs;
644 cifs_readv_from_socket(struct TCP_Server_Info *server, struct kvec *iov_orig,
645 unsigned int nr_segs, unsigned int to_read)
650 struct msghdr smb_msg;
653 iov = get_server_iovec(server, nr_segs);
657 smb_msg.msg_control = NULL;
658 smb_msg.msg_controllen = 0;
660 for (total_read = 0; to_read; total_read += length, to_read -= length) {
663 if (server_unresponsive(server)) {
664 total_read = -EAGAIN;
668 segs = kvec_array_init(iov, iov_orig, nr_segs, total_read);
670 length = kernel_recvmsg(server->ssocket, &smb_msg,
671 iov, segs, to_read, 0);
673 if (server->tcpStatus == CifsExiting) {
674 total_read = -ESHUTDOWN;
676 } else if (server->tcpStatus == CifsNeedReconnect) {
677 cifs_reconnect(server);
678 total_read = -EAGAIN;
680 } else if (length == -ERESTARTSYS ||
684 * Minimum sleep to prevent looping, allowing socket
685 * to clear and app threads to set tcpStatus
686 * CifsNeedReconnect if server hung.
688 usleep_range(1000, 2000);
691 } else if (length <= 0) {
692 cFYI(1, "Received no data or error: expecting %d "
693 "got %d", to_read, length);
694 cifs_reconnect(server);
695 total_read = -EAGAIN;
703 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
704 unsigned int to_read)
709 iov.iov_len = to_read;
711 return cifs_readv_from_socket(server, &iov, 1, to_read);
715 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
718 * The first byte big endian of the length field,
719 * is actually not part of the length but the type
720 * with the most common, zero, as regular data.
723 case RFC1002_SESSION_MESSAGE:
724 /* Regular SMB response */
726 case RFC1002_SESSION_KEEP_ALIVE:
727 cFYI(1, "RFC 1002 session keep alive");
729 case RFC1002_POSITIVE_SESSION_RESPONSE:
730 cFYI(1, "RFC 1002 positive session response");
732 case RFC1002_NEGATIVE_SESSION_RESPONSE:
734 * We get this from Windows 98 instead of an error on
735 * SMB negprot response.
737 cFYI(1, "RFC 1002 negative session response");
738 /* give server a second to clean up */
741 * Always try 445 first on reconnect since we get NACK
742 * on some if we ever connected to port 139 (the NACK
743 * is since we do not begin with RFC1001 session
746 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
747 cifs_reconnect(server);
748 wake_up(&server->response_q);
751 cERROR(1, "RFC 1002 unknown response type 0x%x", type);
752 cifs_reconnect(server);
758 static struct mid_q_entry *
759 find_mid(struct TCP_Server_Info *server, char *buffer)
761 struct smb_hdr *buf = (struct smb_hdr *)buffer;
762 struct mid_q_entry *mid;
764 spin_lock(&GlobalMid_Lock);
765 list_for_each_entry(mid, &server->pending_mid_q, qhead) {
766 if (mid->mid == buf->Mid &&
767 mid->mid_state == MID_REQUEST_SUBMITTED &&
768 le16_to_cpu(mid->command) == buf->Command) {
769 spin_unlock(&GlobalMid_Lock);
773 spin_unlock(&GlobalMid_Lock);
778 dequeue_mid(struct mid_q_entry *mid, bool malformed)
780 #ifdef CONFIG_CIFS_STATS2
781 mid->when_received = jiffies;
783 spin_lock(&GlobalMid_Lock);
785 mid->mid_state = MID_RESPONSE_RECEIVED;
787 mid->mid_state = MID_RESPONSE_MALFORMED;
788 list_del_init(&mid->qhead);
789 spin_unlock(&GlobalMid_Lock);
793 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
794 char *buf, int malformed)
796 if (malformed == 0 && check2ndT2(buf) > 0) {
797 mid->multiRsp = true;
799 /* merge response - fix up 1st*/
800 malformed = coalesce_t2(buf, mid->resp_buf);
804 /* All parts received or packet is malformed. */
805 mid->multiEnd = true;
806 return dequeue_mid(mid, malformed);
808 if (!server->large_buf) {
809 /*FIXME: switch to already allocated largebuf?*/
810 cERROR(1, "1st trans2 resp needs bigbuf");
812 /* Have first buffer */
814 mid->large_buf = true;
815 server->bigbuf = NULL;
820 mid->large_buf = server->large_buf;
821 /* Was previous buf put in mpx struct for multi-rsp? */
822 if (!mid->multiRsp) {
823 /* smb buffer will be freed by user thread */
824 if (server->large_buf)
825 server->bigbuf = NULL;
827 server->smallbuf = NULL;
829 dequeue_mid(mid, malformed);
832 static void clean_demultiplex_info(struct TCP_Server_Info *server)
836 /* take it off the list, if it's not already */
837 spin_lock(&cifs_tcp_ses_lock);
838 list_del_init(&server->tcp_ses_list);
839 spin_unlock(&cifs_tcp_ses_lock);
841 spin_lock(&GlobalMid_Lock);
842 server->tcpStatus = CifsExiting;
843 spin_unlock(&GlobalMid_Lock);
844 wake_up_all(&server->response_q);
846 /* check if we have blocked requests that need to free */
847 spin_lock(&server->req_lock);
848 if (server->credits <= 0)
850 spin_unlock(&server->req_lock);
852 * Although there should not be any requests blocked on this queue it
853 * can not hurt to be paranoid and try to wake up requests that may
854 * haven been blocked when more than 50 at time were on the wire to the
855 * same server - they now will see the session is in exit state and get
856 * out of SendReceive.
858 wake_up_all(&server->request_q);
859 /* give those requests time to exit */
862 if (server->ssocket) {
863 sock_release(server->ssocket);
864 server->ssocket = NULL;
867 if (!list_empty(&server->pending_mid_q)) {
868 struct list_head dispose_list;
869 struct mid_q_entry *mid_entry;
870 struct list_head *tmp, *tmp2;
872 INIT_LIST_HEAD(&dispose_list);
873 spin_lock(&GlobalMid_Lock);
874 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
875 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
876 cFYI(1, "Clearing mid 0x%llx", mid_entry->mid);
877 mid_entry->mid_state = MID_SHUTDOWN;
878 list_move(&mid_entry->qhead, &dispose_list);
880 spin_unlock(&GlobalMid_Lock);
882 /* now walk dispose list and issue callbacks */
883 list_for_each_safe(tmp, tmp2, &dispose_list) {
884 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
885 cFYI(1, "Callback mid 0x%llx", mid_entry->mid);
886 list_del_init(&mid_entry->qhead);
887 mid_entry->callback(mid_entry);
889 /* 1/8th of sec is more than enough time for them to exit */
893 if (!list_empty(&server->pending_mid_q)) {
895 * mpx threads have not exited yet give them at least the smb
896 * send timeout time for long ops.
898 * Due to delays on oplock break requests, we need to wait at
899 * least 45 seconds before giving up on a request getting a
900 * response and going ahead and killing cifsd.
902 cFYI(1, "Wait for exit from demultiplex thread");
905 * If threads still have not exited they are probably never
906 * coming home not much else we can do but free the memory.
910 kfree(server->hostname);
914 length = atomic_dec_return(&tcpSesAllocCount);
916 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
921 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
924 char *buf = server->smallbuf;
925 unsigned int pdu_length = get_rfc1002_length(buf);
927 /* make sure this will fit in a large buffer */
928 if (pdu_length > CIFSMaxBufSize + max_header_size() - 4) {
929 cERROR(1, "SMB response too long (%u bytes)",
931 cifs_reconnect(server);
932 wake_up(&server->response_q);
936 /* switch to large buffer if too big for a small one */
937 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
938 server->large_buf = true;
939 memcpy(server->bigbuf, buf, server->total_read);
940 buf = server->bigbuf;
943 /* now read the rest */
944 length = cifs_read_from_socket(server, buf + header_size() - 1,
945 pdu_length - header_size() + 1 + 4);
948 server->total_read += length;
950 dump_smb(buf, server->total_read);
953 * We know that we received enough to get to the MID as we
954 * checked the pdu_length earlier. Now check to see
955 * if the rest of the header is OK. We borrow the length
956 * var for the rest of the loop to avoid a new stack var.
958 * 48 bytes is enough to display the header and a little bit
959 * into the payload for debugging purposes.
961 length = checkSMB(buf, server->total_read);
963 cifs_dump_mem("Bad SMB: ", buf,
964 min_t(unsigned int, server->total_read, 48));
969 handle_mid(mid, server, buf, length);
974 cifs_demultiplex_thread(void *p)
977 struct TCP_Server_Info *server = p;
978 unsigned int pdu_length;
980 struct task_struct *task_to_wake = NULL;
981 struct mid_q_entry *mid_entry;
983 current->flags |= PF_MEMALLOC;
984 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
986 length = atomic_inc_return(&tcpSesAllocCount);
988 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
992 while (server->tcpStatus != CifsExiting) {
996 if (!allocate_buffers(server))
999 server->large_buf = false;
1000 buf = server->smallbuf;
1001 pdu_length = 4; /* enough to get RFC1001 header */
1003 length = cifs_read_from_socket(server, buf, pdu_length);
1006 server->total_read = length;
1009 * The right amount was read from socket - 4 bytes,
1010 * so we can now interpret the length field.
1012 pdu_length = get_rfc1002_length(buf);
1014 cFYI(1, "RFC1002 header 0x%x", pdu_length);
1015 if (!is_smb_response(server, buf[0]))
1018 /* make sure we have enough to get to the MID */
1019 if (pdu_length < header_size() - 1 - 4) {
1020 cERROR(1, "SMB response too short (%u bytes)",
1022 cifs_reconnect(server);
1023 wake_up(&server->response_q);
1027 /* read down to the MID */
1028 length = cifs_read_from_socket(server, buf + 4,
1029 header_size() - 1 - 4);
1032 server->total_read += length;
1034 mid_entry = find_mid(server, buf);
1036 if (!mid_entry || !mid_entry->receive)
1037 length = standard_receive3(server, mid_entry);
1039 length = mid_entry->receive(server, mid_entry);
1044 if (server->large_buf)
1045 buf = server->bigbuf;
1047 server->lstrp = jiffies;
1048 if (mid_entry != NULL) {
1049 if (!mid_entry->multiRsp || mid_entry->multiEnd)
1050 mid_entry->callback(mid_entry);
1051 } else if (!is_valid_oplock_break(buf, server)) {
1052 cERROR(1, "No task to wake, unknown frame received! "
1053 "NumMids %d", atomic_read(&midCount));
1054 cifs_dump_mem("Received Data is: ", buf, header_size());
1055 #ifdef CONFIG_CIFS_DEBUG2
1056 cifs_dump_detail(buf);
1057 cifs_dump_mids(server);
1058 #endif /* CIFS_DEBUG2 */
1061 } /* end while !EXITING */
1063 /* buffer usually freed in free_mid - need to free it here on exit */
1064 cifs_buf_release(server->bigbuf);
1065 if (server->smallbuf) /* no sense logging a debug message if NULL */
1066 cifs_small_buf_release(server->smallbuf);
1068 task_to_wake = xchg(&server->tsk, NULL);
1069 clean_demultiplex_info(server);
1071 /* if server->tsk was NULL then wait for a signal before exiting */
1072 if (!task_to_wake) {
1073 set_current_state(TASK_INTERRUPTIBLE);
1074 while (!signal_pending(current)) {
1076 set_current_state(TASK_INTERRUPTIBLE);
1078 set_current_state(TASK_RUNNING);
1081 module_put_and_exit(0);
1084 /* extract the host portion of the UNC string */
1086 extract_hostname(const char *unc)
1092 /* skip double chars at beginning of string */
1093 /* BB: check validity of these bytes? */
1096 /* delimiter between hostname and sharename is always '\\' now */
1097 delim = strchr(src, '\\');
1099 return ERR_PTR(-EINVAL);
1102 dst = kmalloc((len + 1), GFP_KERNEL);
1104 return ERR_PTR(-ENOMEM);
1106 memcpy(dst, src, len);
1112 static int get_option_ul(substring_t args[], unsigned long *option)
1117 string = match_strdup(args);
1120 rc = kstrtoul(string, 10, option);
1127 static int cifs_parse_security_flavors(char *value,
1128 struct smb_vol *vol)
1131 substring_t args[MAX_OPT_ARGS];
1133 switch (match_token(value, cifs_secflavor_tokens, args)) {
1135 vol->secFlg |= CIFSSEC_MAY_KRB5;
1138 vol->secFlg |= CIFSSEC_MAY_KRB5 | CIFSSEC_MUST_SIGN;
1141 /* vol->secFlg |= CIFSSEC_MUST_SEAL | CIFSSEC_MAY_KRB5; */
1142 cERROR(1, "Krb5 cifs privacy not supported");
1144 case Opt_sec_ntlmssp:
1145 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
1147 case Opt_sec_ntlmsspi:
1148 vol->secFlg |= CIFSSEC_MAY_NTLMSSP | CIFSSEC_MUST_SIGN;
1151 /* ntlm is default so can be turned off too */
1152 vol->secFlg |= CIFSSEC_MAY_NTLM;
1155 vol->secFlg |= CIFSSEC_MAY_NTLM | CIFSSEC_MUST_SIGN;
1157 case Opt_sec_nontlm:
1158 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1160 case Opt_sec_ntlmv2i:
1161 vol->secFlg |= CIFSSEC_MAY_NTLMV2 | CIFSSEC_MUST_SIGN;
1163 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1164 case Opt_sec_lanman:
1165 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1172 cERROR(1, "bad security option: %s", value);
1180 cifs_parse_mount_options(const char *mountdata, const char *devname,
1181 struct smb_vol *vol)
1184 char *mountdata_copy = NULL, *options;
1185 unsigned int temp_len, i, j;
1187 short int override_uid = -1;
1188 short int override_gid = -1;
1189 bool uid_specified = false;
1190 bool gid_specified = false;
1191 bool sloppy = false;
1192 char *invalid = NULL;
1193 char *nodename = utsname()->nodename;
1194 char *string = NULL;
1195 char *tmp_end, *value;
1200 delim = separator[0];
1203 * does not have to be perfect mapping since field is
1204 * informational, only used for servers that do not support
1205 * port 445 and it can be overridden at mount time
1207 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1208 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1209 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1211 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1212 /* null target name indicates to use *SMBSERVR default called name
1213 if we end up sending RFC1001 session initialize */
1214 vol->target_rfc1001_name[0] = 0;
1215 vol->cred_uid = current_uid();
1216 vol->linux_uid = current_uid();
1217 vol->linux_gid = current_gid();
1219 /* default to only allowing write access to owner of the mount */
1220 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1222 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1223 /* default is always to request posix paths. */
1224 vol->posix_paths = 1;
1225 /* default to using server inode numbers where available */
1226 vol->server_ino = 1;
1228 vol->actimeo = CIFS_DEF_ACTIMEO;
1231 goto cifs_parse_mount_err;
1233 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1234 if (!mountdata_copy)
1235 goto cifs_parse_mount_err;
1237 options = mountdata_copy;
1238 end = options + strlen(options);
1240 if (strncmp(options, "sep=", 4) == 0) {
1241 if (options[4] != 0) {
1242 separator[0] = options[4];
1245 cFYI(1, "Null separator not allowed");
1248 vol->backupuid_specified = false; /* no backup intent for a user */
1249 vol->backupgid_specified = false; /* no backup intent for a group */
1251 while ((data = strsep(&options, separator)) != NULL) {
1252 substring_t args[MAX_OPT_ARGS];
1253 unsigned long option;
1259 token = match_token(data, cifs_mount_option_tokens, args);
1263 /* Ingnore the following */
1267 /* Boolean values */
1268 case Opt_user_xattr:
1271 case Opt_nouser_xattr:
1277 case Opt_noforceuid:
1280 case Opt_noblocksend:
1281 vol->noblocksnd = 1;
1283 case Opt_noautotune:
1284 vol->noautotune = 1;
1301 case Opt_nomapchars:
1313 case Opt_posixpaths:
1314 vol->posix_paths = 1;
1316 case Opt_noposixpaths:
1317 vol->posix_paths = 0;
1320 vol->no_linux_ext = 1;
1331 * turn off mandatory locking in mode
1332 * if remote locking is turned off since the
1333 * local vfs will do advisory
1335 if (vol->file_mode ==
1336 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1337 vol->file_mode = S_IALLUGO;
1339 case Opt_forcemandatorylock:
1349 vol->dynperm = true;
1352 vol->dynperm = false;
1366 case Opt_nostrictsync:
1367 vol->nostrictsync = 1;
1369 case Opt_strictsync:
1370 vol->nostrictsync = 0;
1373 vol->server_ino = 1;
1375 case Opt_noserverino:
1376 vol->server_ino = 0;
1378 case Opt_rwpidforward:
1379 vol->rwpidforward = 1;
1388 vol->no_psx_acl = 0;
1391 vol->no_psx_acl = 1;
1393 case Opt_locallease:
1394 vol->local_lease = 1;
1397 vol->secFlg |= CIFSSEC_MUST_SIGN;
1400 /* we do not do the following in secFlags because seal
1401 * is a per tree connection (mount) not a per socket
1402 * or per-smb connection option in the protocol
1403 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1410 case Opt_strictcache:
1414 printk(KERN_WARNING "CIFS: Mount option noac not "
1415 "supported. Instead set "
1416 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1419 #ifndef CONFIG_CIFS_FSCACHE
1420 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE "
1421 "kernel config option set");
1422 goto cifs_parse_mount_err;
1426 case Opt_mfsymlinks:
1427 vol->mfsymlinks = true;
1430 vol->multiuser = true;
1436 /* Numeric Values */
1438 if (get_option_ul(args, &option)) {
1439 cERROR(1, "%s: Invalid backupuid value",
1441 goto cifs_parse_mount_err;
1443 vol->backupuid = option;
1444 vol->backupuid_specified = true;
1447 if (get_option_ul(args, &option)) {
1448 cERROR(1, "%s: Invalid backupgid value",
1450 goto cifs_parse_mount_err;
1452 vol->backupgid = option;
1453 vol->backupgid_specified = true;
1456 if (get_option_ul(args, &option)) {
1457 cERROR(1, "%s: Invalid uid value",
1459 goto cifs_parse_mount_err;
1461 vol->linux_uid = option;
1462 uid_specified = true;
1465 if (get_option_ul(args, &option)) {
1466 cERROR(1, "%s: Invalid cruid value",
1468 goto cifs_parse_mount_err;
1470 vol->cred_uid = option;
1473 if (get_option_ul(args, &option)) {
1474 cERROR(1, "%s: Invalid gid value",
1476 goto cifs_parse_mount_err;
1478 vol->linux_gid = option;
1479 gid_specified = true;
1482 if (get_option_ul(args, &option)) {
1483 cERROR(1, "%s: Invalid file_mode value",
1485 goto cifs_parse_mount_err;
1487 vol->file_mode = option;
1490 if (get_option_ul(args, &option)) {
1491 cERROR(1, "%s: Invalid dir_mode value",
1493 goto cifs_parse_mount_err;
1495 vol->dir_mode = option;
1498 if (get_option_ul(args, &option)) {
1499 cERROR(1, "%s: Invalid port value",
1501 goto cifs_parse_mount_err;
1506 if (get_option_ul(args, &option)) {
1507 cERROR(1, "%s: Invalid rsize value",
1509 goto cifs_parse_mount_err;
1511 vol->rsize = option;
1514 if (get_option_ul(args, &option)) {
1515 cERROR(1, "%s: Invalid wsize value",
1517 goto cifs_parse_mount_err;
1519 vol->wsize = option;
1522 if (get_option_ul(args, &option)) {
1523 cERROR(1, "%s: Invalid actimeo value",
1525 goto cifs_parse_mount_err;
1527 vol->actimeo = HZ * option;
1528 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1529 cERROR(1, "CIFS: attribute cache"
1530 "timeout too large");
1531 goto cifs_parse_mount_err;
1535 /* String Arguments */
1538 string = match_strdup(args);
1543 /* null user, ie. anonymous authentication */
1545 } else if (strnlen(string, MAX_USERNAME_SIZE) >
1546 MAX_USERNAME_SIZE) {
1547 printk(KERN_WARNING "CIFS: username too long\n");
1548 goto cifs_parse_mount_err;
1550 vol->username = kstrdup(string, GFP_KERNEL);
1551 if (!vol->username) {
1552 printk(KERN_WARNING "CIFS: no memory "
1554 goto cifs_parse_mount_err;
1557 case Opt_blank_pass:
1558 vol->password = NULL;
1561 /* passwords have to be handled differently
1562 * to allow the character used for deliminator
1563 * to be passed within them
1566 /* Obtain the value string */
1567 value = strchr(data, '=');
1571 /* Set tmp_end to end of the string */
1572 tmp_end = (char *) value + strlen(value);
1574 /* Check if following character is the deliminator
1575 * If yes, we have encountered a double deliminator
1576 * reset the NULL character to the deliminator
1578 if (tmp_end < end && tmp_end[1] == delim)
1581 /* Keep iterating until we get to a single deliminator
1584 while ((tmp_end = strchr(tmp_end, delim)) != NULL &&
1585 (tmp_end[1] == delim)) {
1586 tmp_end = (char *) &tmp_end[2];
1589 /* Reset var options to point to next element */
1592 options = (char *) &tmp_end[1];
1594 /* Reached the end of the mount option string */
1597 /* Now build new password string */
1598 temp_len = strlen(value);
1599 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1600 if (vol->password == NULL) {
1601 printk(KERN_WARNING "CIFS: no memory "
1603 goto cifs_parse_mount_err;
1606 for (i = 0, j = 0; i < temp_len; i++, j++) {
1607 vol->password[j] = value[i];
1608 if ((value[i] == delim) &&
1609 value[i+1] == delim)
1610 /* skip the second deliminator */
1613 vol->password[j] = '\0';
1616 string = match_strdup(args);
1622 } else if (strnlen(string, INET6_ADDRSTRLEN) >
1624 printk(KERN_WARNING "CIFS: ip address "
1626 goto cifs_parse_mount_err;
1628 vol->UNCip = kstrdup(string, GFP_KERNEL);
1630 printk(KERN_WARNING "CIFS: no memory "
1632 goto cifs_parse_mount_err;
1636 string = match_strdup(args);
1641 printk(KERN_WARNING "CIFS: invalid path to "
1642 "network resource\n");
1643 goto cifs_parse_mount_err;
1646 temp_len = strnlen(string, 300);
1647 if (temp_len == 300) {
1648 printk(KERN_WARNING "CIFS: UNC name too long\n");
1649 goto cifs_parse_mount_err;
1652 if (strncmp(string, "//", 2) == 0) {
1655 } else if (strncmp(string, "\\\\", 2) != 0) {
1656 printk(KERN_WARNING "CIFS: UNC Path does not "
1657 "begin with // or \\\\\n");
1658 goto cifs_parse_mount_err;
1661 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1662 if (vol->UNC == NULL) {
1663 printk(KERN_WARNING "CIFS: no memory "
1665 goto cifs_parse_mount_err;
1667 strcpy(vol->UNC, string);
1670 string = match_strdup(args);
1675 printk(KERN_WARNING "CIFS: invalid domain"
1677 goto cifs_parse_mount_err;
1678 } else if (strnlen(string, 256) == 256) {
1679 printk(KERN_WARNING "CIFS: domain name too"
1681 goto cifs_parse_mount_err;
1684 vol->domainname = kstrdup(string, GFP_KERNEL);
1685 if (!vol->domainname) {
1686 printk(KERN_WARNING "CIFS: no memory "
1687 "for domainname\n");
1688 goto cifs_parse_mount_err;
1690 cFYI(1, "Domain name set");
1693 string = match_strdup(args);
1698 printk(KERN_WARNING "CIFS: srcaddr value not"
1700 goto cifs_parse_mount_err;
1701 } else if (!cifs_convert_address(
1702 (struct sockaddr *)&vol->srcaddr,
1703 string, strlen(string))) {
1704 printk(KERN_WARNING "CIFS: Could not parse"
1705 " srcaddr: %s\n", string);
1706 goto cifs_parse_mount_err;
1709 case Opt_prefixpath:
1710 string = match_strdup(args);
1715 printk(KERN_WARNING "CIFS: Invalid path"
1717 goto cifs_parse_mount_err;
1719 temp_len = strnlen(string, 1024);
1720 if (string[0] != '/')
1721 temp_len++; /* missing leading slash */
1722 if (temp_len > 1024) {
1723 printk(KERN_WARNING "CIFS: prefix too long\n");
1724 goto cifs_parse_mount_err;
1727 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1728 if (vol->prepath == NULL) {
1729 printk(KERN_WARNING "CIFS: no memory "
1730 "for path prefix\n");
1731 goto cifs_parse_mount_err;
1734 if (string[0] != '/') {
1735 vol->prepath[0] = '/';
1736 strcpy(vol->prepath+1, string);
1738 strcpy(vol->prepath, string);
1742 string = match_strdup(args);
1747 printk(KERN_WARNING "CIFS: Invalid iocharset"
1749 goto cifs_parse_mount_err;
1750 } else if (strnlen(string, 1024) >= 65) {
1751 printk(KERN_WARNING "CIFS: iocharset name "
1753 goto cifs_parse_mount_err;
1756 if (strnicmp(string, "default", 7) != 0) {
1757 vol->iocharset = kstrdup(string,
1759 if (!vol->iocharset) {
1760 printk(KERN_WARNING "CIFS: no memory"
1762 goto cifs_parse_mount_err;
1765 /* if iocharset not set then load_nls_default
1768 cFYI(1, "iocharset set to %s", string);
1771 string = match_strdup(args);
1776 printk(KERN_WARNING "CIFS: No socket option"
1778 goto cifs_parse_mount_err;
1780 if (strnicmp(string, "TCP_NODELAY", 11) == 0)
1781 vol->sockopt_tcp_nodelay = 1;
1783 case Opt_netbiosname:
1784 string = match_strdup(args);
1789 printk(KERN_WARNING "CIFS: Invalid (empty)"
1794 memset(vol->source_rfc1001_name, 0x20,
1797 * FIXME: are there cases in which a comma can
1798 * be valid in workstation netbios name (and
1799 * need special handling)?
1801 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1802 /* don't ucase netbiosname for user */
1805 vol->source_rfc1001_name[i] = string[i];
1807 /* The string has 16th byte zero still from
1808 * set at top of the function
1810 if (i == RFC1001_NAME_LEN && string[i] != 0)
1811 printk(KERN_WARNING "CIFS: netbiosname"
1812 " longer than 15 truncated.\n");
1816 /* servernetbiosname specified override *SMBSERVER */
1817 string = match_strdup(args);
1822 printk(KERN_WARNING "CIFS: Empty server"
1823 " netbiosname specified\n");
1826 /* last byte, type, is 0x20 for servr type */
1827 memset(vol->target_rfc1001_name, 0x20,
1828 RFC1001_NAME_LEN_WITH_NULL);
1830 /* BB are there cases in which a comma can be
1831 valid in this workstation netbios name
1832 (and need special handling)? */
1834 /* user or mount helper must uppercase the
1836 for (i = 0; i < 15; i++) {
1839 vol->target_rfc1001_name[i] = string[i];
1841 /* The string has 16th byte zero still from
1842 set at top of the function */
1843 if (i == RFC1001_NAME_LEN && string[i] != 0)
1844 printk(KERN_WARNING "CIFS: server net"
1845 "biosname longer than 15 truncated.\n");
1848 string = match_strdup(args);
1853 cERROR(1, "no protocol version specified"
1854 " after vers= mount option");
1855 goto cifs_parse_mount_err;
1858 if (strnicmp(string, "cifs", 4) == 0 ||
1859 strnicmp(string, "1", 1) == 0) {
1860 /* This is the default */
1863 /* For all other value, error */
1864 printk(KERN_WARNING "CIFS: Invalid version"
1866 goto cifs_parse_mount_err;
1868 string = match_strdup(args);
1873 printk(KERN_WARNING "CIFS: no security flavor"
1878 if (cifs_parse_security_flavors(string, vol) != 0)
1879 goto cifs_parse_mount_err;
1883 * An option we don't recognize. Save it off for later
1884 * if we haven't already found one
1890 /* Free up any allocated string */
1895 if (!sloppy && invalid) {
1896 printk(KERN_ERR "CIFS: Unknown mount option \"%s\"\n", invalid);
1897 goto cifs_parse_mount_err;
1901 /* Muliuser mounts require CONFIG_KEYS support */
1902 if (vol->multiuser) {
1903 cERROR(1, "Multiuser mounts require kernels with "
1904 "CONFIG_KEYS enabled.");
1905 goto cifs_parse_mount_err;
1909 if (vol->UNCip == NULL)
1910 vol->UNCip = &vol->UNC[2];
1913 vol->override_uid = override_uid;
1914 else if (override_uid == 1)
1915 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1916 "specified with no uid= option.\n");
1919 vol->override_gid = override_gid;
1920 else if (override_gid == 1)
1921 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1922 "specified with no gid= option.\n");
1924 kfree(mountdata_copy);
1928 printk(KERN_WARNING "Could not allocate temporary buffer\n");
1929 cifs_parse_mount_err:
1931 kfree(mountdata_copy);
1935 /** Returns true if srcaddr isn't specified and rhs isn't
1936 * specified, or if srcaddr is specified and
1937 * matches the IP address of the rhs argument.
1940 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1942 switch (srcaddr->sa_family) {
1944 return (rhs->sa_family == AF_UNSPEC);
1946 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1947 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1948 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1951 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1952 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1953 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1957 return false; /* don't expect to be here */
1962 * If no port is specified in addr structure, we try to match with 445 port
1963 * and if it fails - with 139 ports. It should be called only if address
1964 * families of server and addr are equal.
1967 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1969 __be16 port, *sport;
1971 switch (addr->sa_family) {
1973 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1974 port = ((struct sockaddr_in *) addr)->sin_port;
1977 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1978 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1986 port = htons(CIFS_PORT);
1990 port = htons(RFC1001_PORT);
1993 return port == *sport;
1997 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1998 struct sockaddr *srcaddr)
2000 switch (addr->sa_family) {
2002 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2003 struct sockaddr_in *srv_addr4 =
2004 (struct sockaddr_in *)&server->dstaddr;
2006 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
2011 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2012 struct sockaddr_in6 *srv_addr6 =
2013 (struct sockaddr_in6 *)&server->dstaddr;
2015 if (!ipv6_addr_equal(&addr6->sin6_addr,
2016 &srv_addr6->sin6_addr))
2018 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
2024 return false; /* don't expect to be here */
2027 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2034 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2036 unsigned int secFlags;
2038 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
2039 secFlags = vol->secFlg;
2041 secFlags = global_secflags | vol->secFlg;
2043 switch (server->secType) {
2045 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
2049 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
2053 if (!(secFlags & CIFSSEC_MAY_NTLM))
2057 if (!(secFlags & CIFSSEC_MAY_KRB5))
2061 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
2065 /* shouldn't happen */
2069 /* now check if signing mode is acceptable */
2070 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
2071 (server->sec_mode & SECMODE_SIGN_REQUIRED))
2073 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
2075 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
2081 static int match_server(struct TCP_Server_Info *server, struct sockaddr *addr,
2082 struct smb_vol *vol)
2084 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2087 if (!match_address(server, addr,
2088 (struct sockaddr *)&vol->srcaddr))
2091 if (!match_port(server, addr))
2094 if (!match_security(server, vol))
2100 static struct TCP_Server_Info *
2101 cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
2103 struct TCP_Server_Info *server;
2105 spin_lock(&cifs_tcp_ses_lock);
2106 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2107 if (!match_server(server, addr, vol))
2110 ++server->srv_count;
2111 spin_unlock(&cifs_tcp_ses_lock);
2112 cFYI(1, "Existing tcp session with server found");
2115 spin_unlock(&cifs_tcp_ses_lock);
2120 cifs_put_tcp_session(struct TCP_Server_Info *server)
2122 struct task_struct *task;
2124 spin_lock(&cifs_tcp_ses_lock);
2125 if (--server->srv_count > 0) {
2126 spin_unlock(&cifs_tcp_ses_lock);
2130 put_net(cifs_net_ns(server));
2132 list_del_init(&server->tcp_ses_list);
2133 spin_unlock(&cifs_tcp_ses_lock);
2135 cancel_delayed_work_sync(&server->echo);
2137 spin_lock(&GlobalMid_Lock);
2138 server->tcpStatus = CifsExiting;
2139 spin_unlock(&GlobalMid_Lock);
2141 cifs_crypto_shash_release(server);
2142 cifs_fscache_release_client_cookie(server);
2144 kfree(server->session_key.response);
2145 server->session_key.response = NULL;
2146 server->session_key.len = 0;
2148 task = xchg(&server->tsk, NULL);
2150 force_sig(SIGKILL, task);
2153 static struct TCP_Server_Info *
2154 cifs_get_tcp_session(struct smb_vol *volume_info)
2156 struct TCP_Server_Info *tcp_ses = NULL;
2157 struct sockaddr_storage addr;
2158 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
2159 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
2162 memset(&addr, 0, sizeof(struct sockaddr_storage));
2164 cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
2166 if (volume_info->UNCip && volume_info->UNC) {
2167 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
2169 strlen(volume_info->UNCip),
2172 /* we failed translating address */
2176 } else if (volume_info->UNCip) {
2177 /* BB using ip addr as tcp_ses name to connect to the
2179 cERROR(1, "Connecting to DFS root not implemented yet");
2182 } else /* which tcp_sess DFS root would we conect to */ {
2183 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
2184 "unc=//192.168.1.100/public) specified");
2189 /* see if we already have a matching tcp_ses */
2190 tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
2194 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2200 rc = cifs_crypto_shash_allocate(tcp_ses);
2202 cERROR(1, "could not setup hash structures rc %d", rc);
2206 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2207 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2208 if (IS_ERR(tcp_ses->hostname)) {
2209 rc = PTR_ERR(tcp_ses->hostname);
2210 goto out_err_crypto_release;
2213 tcp_ses->noblocksnd = volume_info->noblocksnd;
2214 tcp_ses->noautotune = volume_info->noautotune;
2215 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2216 tcp_ses->in_flight = 0;
2217 tcp_ses->credits = 1;
2218 init_waitqueue_head(&tcp_ses->response_q);
2219 init_waitqueue_head(&tcp_ses->request_q);
2220 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2221 mutex_init(&tcp_ses->srv_mutex);
2222 memcpy(tcp_ses->workstation_RFC1001_name,
2223 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2224 memcpy(tcp_ses->server_RFC1001_name,
2225 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2226 tcp_ses->session_estab = false;
2227 tcp_ses->sequence_number = 0;
2228 tcp_ses->lstrp = jiffies;
2229 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2230 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2231 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2234 * at this point we are the only ones with the pointer
2235 * to the struct since the kernel thread not created yet
2236 * no need to spinlock this init of tcpStatus or srv_count
2238 tcp_ses->tcpStatus = CifsNew;
2239 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2240 sizeof(tcp_ses->srcaddr));
2241 ++tcp_ses->srv_count;
2243 if (addr.ss_family == AF_INET6) {
2244 cFYI(1, "attempting ipv6 connect");
2245 /* BB should we allow ipv6 on port 139? */
2246 /* other OS never observed in Wild doing 139 with v6 */
2247 memcpy(&tcp_ses->dstaddr, sin_server6,
2248 sizeof(struct sockaddr_in6));
2250 memcpy(&tcp_ses->dstaddr, sin_server,
2251 sizeof(struct sockaddr_in));
2253 rc = ip_connect(tcp_ses);
2255 cERROR(1, "Error connecting to socket. Aborting operation");
2256 goto out_err_crypto_release;
2260 * since we're in a cifs function already, we know that
2261 * this will succeed. No need for try_module_get().
2263 __module_get(THIS_MODULE);
2264 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2266 if (IS_ERR(tcp_ses->tsk)) {
2267 rc = PTR_ERR(tcp_ses->tsk);
2268 cERROR(1, "error %d create cifsd thread", rc);
2269 module_put(THIS_MODULE);
2270 goto out_err_crypto_release;
2272 tcp_ses->tcpStatus = CifsNeedNegotiate;
2274 /* thread spawned, put it on the list */
2275 spin_lock(&cifs_tcp_ses_lock);
2276 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2277 spin_unlock(&cifs_tcp_ses_lock);
2279 cifs_fscache_get_client_cookie(tcp_ses);
2281 /* queue echo request delayed work */
2282 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
2286 out_err_crypto_release:
2287 cifs_crypto_shash_release(tcp_ses);
2289 put_net(cifs_net_ns(tcp_ses));
2293 if (!IS_ERR(tcp_ses->hostname))
2294 kfree(tcp_ses->hostname);
2295 if (tcp_ses->ssocket)
2296 sock_release(tcp_ses->ssocket);
2302 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2304 switch (ses->server->secType) {
2306 if (vol->cred_uid != ses->cred_uid)
2310 /* NULL username means anonymous session */
2311 if (ses->user_name == NULL) {
2317 /* anything else takes username/password */
2318 if (strncmp(ses->user_name,
2319 vol->username ? vol->username : "",
2322 if (strlen(vol->username) != 0 &&
2323 ses->password != NULL &&
2324 strncmp(ses->password,
2325 vol->password ? vol->password : "",
2332 static struct cifs_ses *
2333 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2335 struct cifs_ses *ses;
2337 spin_lock(&cifs_tcp_ses_lock);
2338 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2339 if (!match_session(ses, vol))
2342 spin_unlock(&cifs_tcp_ses_lock);
2345 spin_unlock(&cifs_tcp_ses_lock);
2350 cifs_put_smb_ses(struct cifs_ses *ses)
2353 struct TCP_Server_Info *server = ses->server;
2355 cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
2356 spin_lock(&cifs_tcp_ses_lock);
2357 if (--ses->ses_count > 0) {
2358 spin_unlock(&cifs_tcp_ses_lock);
2362 list_del_init(&ses->smb_ses_list);
2363 spin_unlock(&cifs_tcp_ses_lock);
2365 if (ses->status == CifsGood) {
2367 CIFSSMBLogoff(xid, ses);
2371 cifs_put_tcp_session(server);
2376 /* strlen("cifs:a:") + INET6_ADDRSTRLEN + 1 */
2377 #define CIFSCREDS_DESC_SIZE (7 + INET6_ADDRSTRLEN + 1)
2379 /* Populate username and pw fields from keyring if possible */
2381 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2384 char *desc, *delim, *payload;
2387 struct TCP_Server_Info *server = ses->server;
2388 struct sockaddr_in *sa;
2389 struct sockaddr_in6 *sa6;
2390 struct user_key_payload *upayload;
2392 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2396 /* try to find an address key first */
2397 switch (server->dstaddr.ss_family) {
2399 sa = (struct sockaddr_in *)&server->dstaddr;
2400 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2403 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2404 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2407 cFYI(1, "Bad ss_family (%hu)", server->dstaddr.ss_family);
2412 cFYI(1, "%s: desc=%s", __func__, desc);
2413 key = request_key(&key_type_logon, desc, "");
2415 if (!ses->domainName) {
2416 cFYI(1, "domainName is NULL");
2421 /* didn't work, try to find a domain key */
2422 sprintf(desc, "cifs:d:%s", ses->domainName);
2423 cFYI(1, "%s: desc=%s", __func__, desc);
2424 key = request_key(&key_type_logon, desc, "");
2431 down_read(&key->sem);
2432 upayload = key->payload.data;
2433 if (IS_ERR_OR_NULL(upayload)) {
2434 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2438 /* find first : in payload */
2439 payload = (char *)upayload->data;
2440 delim = strnchr(payload, upayload->datalen, ':');
2441 cFYI(1, "payload=%s", payload);
2443 cFYI(1, "Unable to find ':' in payload (datalen=%d)",
2449 len = delim - payload;
2450 if (len > MAX_USERNAME_SIZE || len <= 0) {
2451 cFYI(1, "Bad value from username search (len=%zd)", len);
2456 vol->username = kstrndup(payload, len, GFP_KERNEL);
2457 if (!vol->username) {
2458 cFYI(1, "Unable to allocate %zd bytes for username", len);
2462 cFYI(1, "%s: username=%s", __func__, vol->username);
2464 len = key->datalen - (len + 1);
2465 if (len > MAX_PASSWORD_SIZE || len <= 0) {
2466 cFYI(1, "Bad len for password search (len=%zd)", len);
2468 kfree(vol->username);
2469 vol->username = NULL;
2474 vol->password = kstrndup(delim, len, GFP_KERNEL);
2475 if (!vol->password) {
2476 cFYI(1, "Unable to allocate %zd bytes for password", len);
2478 kfree(vol->username);
2479 vol->username = NULL;
2488 cFYI(1, "%s: returning %d", __func__, rc);
2491 #else /* ! CONFIG_KEYS */
2493 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2494 struct cifs_ses *ses __attribute__((unused)))
2498 #endif /* CONFIG_KEYS */
2500 static bool warned_on_ntlm; /* globals init to false automatically */
2502 static struct cifs_ses *
2503 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2505 int rc = -ENOMEM, xid;
2506 struct cifs_ses *ses;
2507 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2508 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2512 ses = cifs_find_smb_ses(server, volume_info);
2514 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
2516 mutex_lock(&ses->session_mutex);
2517 rc = cifs_negotiate_protocol(xid, ses);
2519 mutex_unlock(&ses->session_mutex);
2520 /* problem -- put our ses reference */
2521 cifs_put_smb_ses(ses);
2525 if (ses->need_reconnect) {
2526 cFYI(1, "Session needs reconnect");
2527 rc = cifs_setup_session(xid, ses,
2528 volume_info->local_nls);
2530 mutex_unlock(&ses->session_mutex);
2531 /* problem -- put our reference */
2532 cifs_put_smb_ses(ses);
2537 mutex_unlock(&ses->session_mutex);
2539 /* existing SMB ses has a server reference already */
2540 cifs_put_tcp_session(server);
2545 cFYI(1, "Existing smb sess not found");
2546 ses = sesInfoAlloc();
2550 /* new SMB session uses our server ref */
2551 ses->server = server;
2552 if (server->dstaddr.ss_family == AF_INET6)
2553 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2555 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2557 if (volume_info->username) {
2558 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2559 if (!ses->user_name)
2563 /* volume_info->password freed at unmount */
2564 if (volume_info->password) {
2565 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2569 if (volume_info->domainname) {
2570 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2571 if (!ses->domainName)
2574 ses->cred_uid = volume_info->cred_uid;
2575 ses->linux_uid = volume_info->linux_uid;
2577 /* ntlmv2 is much stronger than ntlm security, and has been broadly
2578 supported for many years, time to update default security mechanism */
2579 if ((volume_info->secFlg == 0) && warned_on_ntlm == false) {
2580 warned_on_ntlm = true;
2581 cERROR(1, "default security mechanism requested. The default "
2582 "security mechanism will be upgraded from ntlm to "
2583 "ntlmv2 in kernel release 3.3");
2585 ses->overrideSecFlg = volume_info->secFlg;
2587 mutex_lock(&ses->session_mutex);
2588 rc = cifs_negotiate_protocol(xid, ses);
2590 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2591 mutex_unlock(&ses->session_mutex);
2595 /* success, put it on the list */
2596 spin_lock(&cifs_tcp_ses_lock);
2597 list_add(&ses->smb_ses_list, &server->smb_ses_list);
2598 spin_unlock(&cifs_tcp_ses_lock);
2609 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2611 if (tcon->tidStatus == CifsExiting)
2613 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2618 static struct cifs_tcon *
2619 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2621 struct list_head *tmp;
2622 struct cifs_tcon *tcon;
2624 spin_lock(&cifs_tcp_ses_lock);
2625 list_for_each(tmp, &ses->tcon_list) {
2626 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2627 if (!match_tcon(tcon, unc))
2630 spin_unlock(&cifs_tcp_ses_lock);
2633 spin_unlock(&cifs_tcp_ses_lock);
2638 cifs_put_tcon(struct cifs_tcon *tcon)
2641 struct cifs_ses *ses = tcon->ses;
2643 cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2644 spin_lock(&cifs_tcp_ses_lock);
2645 if (--tcon->tc_count > 0) {
2646 spin_unlock(&cifs_tcp_ses_lock);
2650 list_del_init(&tcon->tcon_list);
2651 spin_unlock(&cifs_tcp_ses_lock);
2654 CIFSSMBTDis(xid, tcon);
2657 cifs_fscache_release_super_cookie(tcon);
2659 cifs_put_smb_ses(ses);
2662 static struct cifs_tcon *
2663 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2666 struct cifs_tcon *tcon;
2668 tcon = cifs_find_tcon(ses, volume_info->UNC);
2670 cFYI(1, "Found match on UNC path");
2671 /* existing tcon already has a reference */
2672 cifs_put_smb_ses(ses);
2673 if (tcon->seal != volume_info->seal)
2674 cERROR(1, "transport encryption setting "
2675 "conflicts with existing tid");
2679 tcon = tconInfoAlloc();
2686 if (volume_info->password) {
2687 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2688 if (!tcon->password) {
2694 if (strchr(volume_info->UNC + 3, '\\') == NULL
2695 && strchr(volume_info->UNC + 3, '/') == NULL) {
2696 cERROR(1, "Missing share name");
2701 /* BB Do we need to wrap session_mutex around
2702 * this TCon call and Unix SetFS as
2703 * we do on SessSetup and reconnect? */
2705 rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
2707 cFYI(1, "CIFS Tcon rc = %d", rc);
2711 if (volume_info->nodfs) {
2712 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2713 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2715 tcon->seal = volume_info->seal;
2716 /* we can have only one retry value for a connection
2717 to a share so for resources mounted more than once
2718 to the same server share the last value passed in
2719 for the retry flag is used */
2720 tcon->retry = volume_info->retry;
2721 tcon->nocase = volume_info->nocase;
2722 tcon->local_lease = volume_info->local_lease;
2724 spin_lock(&cifs_tcp_ses_lock);
2725 list_add(&tcon->tcon_list, &ses->tcon_list);
2726 spin_unlock(&cifs_tcp_ses_lock);
2728 cifs_fscache_get_super_cookie(tcon);
2738 cifs_put_tlink(struct tcon_link *tlink)
2740 if (!tlink || IS_ERR(tlink))
2743 if (!atomic_dec_and_test(&tlink->tl_count) ||
2744 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2745 tlink->tl_time = jiffies;
2749 if (!IS_ERR(tlink_tcon(tlink)))
2750 cifs_put_tcon(tlink_tcon(tlink));
2755 static inline struct tcon_link *
2756 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2758 return cifs_sb->master_tlink;
2762 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2764 struct cifs_sb_info *old = CIFS_SB(sb);
2765 struct cifs_sb_info *new = mnt_data->cifs_sb;
2767 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2770 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2771 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2775 * We want to share sb only if we don't specify an r/wsize or
2776 * specified r/wsize is greater than or equal to existing one.
2778 if (new->wsize && new->wsize < old->wsize)
2781 if (new->rsize && new->rsize < old->rsize)
2784 if (old->mnt_uid != new->mnt_uid || old->mnt_gid != new->mnt_gid)
2787 if (old->mnt_file_mode != new->mnt_file_mode ||
2788 old->mnt_dir_mode != new->mnt_dir_mode)
2791 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2794 if (old->actimeo != new->actimeo)
2801 cifs_match_super(struct super_block *sb, void *data)
2803 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2804 struct smb_vol *volume_info;
2805 struct cifs_sb_info *cifs_sb;
2806 struct TCP_Server_Info *tcp_srv;
2807 struct cifs_ses *ses;
2808 struct cifs_tcon *tcon;
2809 struct tcon_link *tlink;
2810 struct sockaddr_storage addr;
2813 memset(&addr, 0, sizeof(struct sockaddr_storage));
2815 spin_lock(&cifs_tcp_ses_lock);
2816 cifs_sb = CIFS_SB(sb);
2817 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2818 if (IS_ERR(tlink)) {
2819 spin_unlock(&cifs_tcp_ses_lock);
2822 tcon = tlink_tcon(tlink);
2824 tcp_srv = ses->server;
2826 volume_info = mnt_data->vol;
2828 if (!volume_info->UNCip || !volume_info->UNC)
2831 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
2833 strlen(volume_info->UNCip),
2838 if (!match_server(tcp_srv, (struct sockaddr *)&addr, volume_info) ||
2839 !match_session(ses, volume_info) ||
2840 !match_tcon(tcon, volume_info->UNC)) {
2845 rc = compare_mount_options(sb, mnt_data);
2847 spin_unlock(&cifs_tcp_ses_lock);
2848 cifs_put_tlink(tlink);
2853 get_dfs_path(int xid, struct cifs_ses *pSesInfo, const char *old_path,
2854 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
2855 struct dfs_info3_param **preferrals, int remap)
2860 *pnum_referrals = 0;
2863 if (pSesInfo->ipc_tid == 0) {
2864 temp_unc = kmalloc(2 /* for slashes */ +
2865 strnlen(pSesInfo->serverName,
2866 SERVER_NAME_LEN_WITH_NULL * 2)
2867 + 1 + 4 /* slash IPC$ */ + 2,
2869 if (temp_unc == NULL)
2873 strcpy(temp_unc + 2, pSesInfo->serverName);
2874 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2875 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
2876 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
2880 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
2881 pnum_referrals, nls_codepage, remap);
2882 /* BB map targetUNCs to dfs_info3 structures, here or
2883 in CIFSGetDFSRefer BB */
2888 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2889 static struct lock_class_key cifs_key[2];
2890 static struct lock_class_key cifs_slock_key[2];
2893 cifs_reclassify_socket4(struct socket *sock)
2895 struct sock *sk = sock->sk;
2896 BUG_ON(sock_owned_by_user(sk));
2897 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2898 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2902 cifs_reclassify_socket6(struct socket *sock)
2904 struct sock *sk = sock->sk;
2905 BUG_ON(sock_owned_by_user(sk));
2906 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2907 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2911 cifs_reclassify_socket4(struct socket *sock)
2916 cifs_reclassify_socket6(struct socket *sock)
2921 /* See RFC1001 section 14 on representation of Netbios names */
2922 static void rfc1002mangle(char *target, char *source, unsigned int length)
2926 for (i = 0, j = 0; i < (length); i++) {
2927 /* mask a nibble at a time and encode */
2928 target[j] = 'A' + (0x0F & (source[i] >> 4));
2929 target[j+1] = 'A' + (0x0F & source[i]);
2936 bind_socket(struct TCP_Server_Info *server)
2939 if (server->srcaddr.ss_family != AF_UNSPEC) {
2940 /* Bind to the specified local IP address */
2941 struct socket *socket = server->ssocket;
2942 rc = socket->ops->bind(socket,
2943 (struct sockaddr *) &server->srcaddr,
2944 sizeof(server->srcaddr));
2946 struct sockaddr_in *saddr4;
2947 struct sockaddr_in6 *saddr6;
2948 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2949 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2950 if (saddr6->sin6_family == AF_INET6)
2952 "Failed to bind to: %pI6c, error: %d\n",
2953 &saddr6->sin6_addr, rc);
2956 "Failed to bind to: %pI4, error: %d\n",
2957 &saddr4->sin_addr.s_addr, rc);
2964 ip_rfc1001_connect(struct TCP_Server_Info *server)
2968 * some servers require RFC1001 sessinit before sending
2969 * negprot - BB check reconnection in case where second
2970 * sessinit is sent but no second negprot
2972 struct rfc1002_session_packet *ses_init_buf;
2973 struct smb_hdr *smb_buf;
2974 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2977 ses_init_buf->trailer.session_req.called_len = 32;
2979 if (server->server_RFC1001_name &&
2980 server->server_RFC1001_name[0] != 0)
2981 rfc1002mangle(ses_init_buf->trailer.
2982 session_req.called_name,
2983 server->server_RFC1001_name,
2984 RFC1001_NAME_LEN_WITH_NULL);
2986 rfc1002mangle(ses_init_buf->trailer.
2987 session_req.called_name,
2988 DEFAULT_CIFS_CALLED_NAME,
2989 RFC1001_NAME_LEN_WITH_NULL);
2991 ses_init_buf->trailer.session_req.calling_len = 32;
2994 * calling name ends in null (byte 16) from old smb
2997 if (server->workstation_RFC1001_name &&
2998 server->workstation_RFC1001_name[0] != 0)
2999 rfc1002mangle(ses_init_buf->trailer.
3000 session_req.calling_name,
3001 server->workstation_RFC1001_name,
3002 RFC1001_NAME_LEN_WITH_NULL);
3004 rfc1002mangle(ses_init_buf->trailer.
3005 session_req.calling_name,
3007 RFC1001_NAME_LEN_WITH_NULL);
3009 ses_init_buf->trailer.session_req.scope1 = 0;
3010 ses_init_buf->trailer.session_req.scope2 = 0;
3011 smb_buf = (struct smb_hdr *)ses_init_buf;
3013 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3014 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3015 rc = smb_send(server, smb_buf, 0x44);
3016 kfree(ses_init_buf);
3018 * RFC1001 layer in at least one server
3019 * requires very short break before negprot
3020 * presumably because not expecting negprot
3021 * to follow so fast. This is a simple
3022 * solution that works without
3023 * complicating the code and causes no
3024 * significant slowing down on mount
3027 usleep_range(1000, 2000);
3030 * else the negprot may still work without this
3031 * even though malloc failed
3038 generic_ip_connect(struct TCP_Server_Info *server)
3043 struct socket *socket = server->ssocket;
3044 struct sockaddr *saddr;
3046 saddr = (struct sockaddr *) &server->dstaddr;
3048 if (server->dstaddr.ss_family == AF_INET6) {
3049 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3050 slen = sizeof(struct sockaddr_in6);
3053 sport = ((struct sockaddr_in *) saddr)->sin_port;
3054 slen = sizeof(struct sockaddr_in);
3058 if (socket == NULL) {
3059 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3060 IPPROTO_TCP, &socket, 1);
3062 cERROR(1, "Error %d creating socket", rc);
3063 server->ssocket = NULL;
3067 /* BB other socket options to set KEEPALIVE, NODELAY? */
3068 cFYI(1, "Socket created");
3069 server->ssocket = socket;
3070 socket->sk->sk_allocation = GFP_NOFS;
3071 if (sfamily == AF_INET6)
3072 cifs_reclassify_socket6(socket);
3074 cifs_reclassify_socket4(socket);
3077 rc = bind_socket(server);
3082 * Eventually check for other socket options to change from
3083 * the default. sock_setsockopt not used because it expects
3086 socket->sk->sk_rcvtimeo = 7 * HZ;
3087 socket->sk->sk_sndtimeo = 5 * HZ;
3089 /* make the bufsizes depend on wsize/rsize and max requests */
3090 if (server->noautotune) {
3091 if (socket->sk->sk_sndbuf < (200 * 1024))
3092 socket->sk->sk_sndbuf = 200 * 1024;
3093 if (socket->sk->sk_rcvbuf < (140 * 1024))
3094 socket->sk->sk_rcvbuf = 140 * 1024;
3097 if (server->tcp_nodelay) {
3099 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3100 (char *)&val, sizeof(val));
3102 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
3105 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
3106 socket->sk->sk_sndbuf,
3107 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3109 rc = socket->ops->connect(socket, saddr, slen, 0);
3111 cFYI(1, "Error %d connecting to server", rc);
3112 sock_release(socket);
3113 server->ssocket = NULL;
3117 if (sport == htons(RFC1001_PORT))
3118 rc = ip_rfc1001_connect(server);
3124 ip_connect(struct TCP_Server_Info *server)
3127 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3128 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3130 if (server->dstaddr.ss_family == AF_INET6)
3131 sport = &addr6->sin6_port;
3133 sport = &addr->sin_port;
3138 /* try with 445 port at first */
3139 *sport = htons(CIFS_PORT);
3141 rc = generic_ip_connect(server);
3145 /* if it failed, try with 139 port */
3146 *sport = htons(RFC1001_PORT);
3149 return generic_ip_connect(server);
3152 void reset_cifs_unix_caps(int xid, struct cifs_tcon *tcon,
3153 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3155 /* if we are reconnecting then should we check to see if
3156 * any requested capabilities changed locally e.g. via
3157 * remount but we can not do much about it here
3158 * if they have (even if we could detect it by the following)
3159 * Perhaps we could add a backpointer to array of sb from tcon
3160 * or if we change to make all sb to same share the same
3161 * sb as NFS - then we only have one backpointer to sb.
3162 * What if we wanted to mount the server share twice once with
3163 * and once without posixacls or posix paths? */
3164 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3166 if (vol_info && vol_info->no_linux_ext) {
3167 tcon->fsUnixInfo.Capability = 0;
3168 tcon->unix_ext = 0; /* Unix Extensions disabled */
3169 cFYI(1, "Linux protocol extensions disabled");
3171 } else if (vol_info)
3172 tcon->unix_ext = 1; /* Unix Extensions supported */
3174 if (tcon->unix_ext == 0) {
3175 cFYI(1, "Unix extensions disabled so not set on reconnect");
3179 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3180 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3181 cFYI(1, "unix caps which server supports %lld", cap);
3182 /* check for reconnect case in which we do not
3183 want to change the mount behavior if we can avoid it */
3184 if (vol_info == NULL) {
3185 /* turn off POSIX ACL and PATHNAMES if not set
3186 originally at mount time */
3187 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3188 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3189 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3190 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3191 cERROR(1, "POSIXPATH support change");
3192 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3193 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3194 cERROR(1, "possible reconnect error");
3195 cERROR(1, "server disabled POSIX path support");
3199 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3200 cERROR(1, "per-share encryption not supported yet");
3202 cap &= CIFS_UNIX_CAP_MASK;
3203 if (vol_info && vol_info->no_psx_acl)
3204 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3205 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3206 cFYI(1, "negotiated posix acl support");
3208 cifs_sb->mnt_cifs_flags |=
3209 CIFS_MOUNT_POSIXACL;
3212 if (vol_info && vol_info->posix_paths == 0)
3213 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3214 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3215 cFYI(1, "negotiate posix pathnames");
3217 cifs_sb->mnt_cifs_flags |=
3218 CIFS_MOUNT_POSIX_PATHS;
3221 cFYI(1, "Negotiate caps 0x%x", (int)cap);
3222 #ifdef CONFIG_CIFS_DEBUG2
3223 if (cap & CIFS_UNIX_FCNTL_CAP)
3224 cFYI(1, "FCNTL cap");
3225 if (cap & CIFS_UNIX_EXTATTR_CAP)
3226 cFYI(1, "EXTATTR cap");
3227 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3228 cFYI(1, "POSIX path cap");
3229 if (cap & CIFS_UNIX_XATTR_CAP)
3230 cFYI(1, "XATTR cap");
3231 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3232 cFYI(1, "POSIX ACL cap");
3233 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3234 cFYI(1, "very large read cap");
3235 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3236 cFYI(1, "very large write cap");
3237 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3238 cFYI(1, "transport encryption cap");
3239 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3240 cFYI(1, "mandatory transport encryption cap");
3241 #endif /* CIFS_DEBUG2 */
3242 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3243 if (vol_info == NULL) {
3244 cFYI(1, "resetting capabilities failed");
3246 cERROR(1, "Negotiating Unix capabilities "
3247 "with the server failed. Consider "
3248 "mounting with the Unix Extensions\n"
3249 "disabled, if problems are found, "
3250 "by specifying the nounix mount "
3257 void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3258 struct cifs_sb_info *cifs_sb)
3260 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3262 spin_lock_init(&cifs_sb->tlink_tree_lock);
3263 cifs_sb->tlink_tree = RB_ROOT;
3266 * Temporarily set r/wsize for matching superblock. If we end up using
3267 * new sb then client will later negotiate it downward if needed.
3269 cifs_sb->rsize = pvolume_info->rsize;
3270 cifs_sb->wsize = pvolume_info->wsize;
3272 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3273 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3274 if (pvolume_info->backupuid_specified)
3275 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3276 if (pvolume_info->backupgid_specified)
3277 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3278 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3279 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3280 cFYI(1, "file mode: 0x%hx dir mode: 0x%hx",
3281 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3283 cifs_sb->actimeo = pvolume_info->actimeo;
3284 cifs_sb->local_nls = pvolume_info->local_nls;
3286 if (pvolume_info->noperm)
3287 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3288 if (pvolume_info->setuids)
3289 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3290 if (pvolume_info->server_ino)
3291 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3292 if (pvolume_info->remap)
3293 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3294 if (pvolume_info->no_xattr)
3295 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3296 if (pvolume_info->sfu_emul)
3297 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3298 if (pvolume_info->nobrl)
3299 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3300 if (pvolume_info->nostrictsync)
3301 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3302 if (pvolume_info->mand_lock)
3303 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3304 if (pvolume_info->rwpidforward)
3305 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3306 if (pvolume_info->cifs_acl)
3307 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3308 if (pvolume_info->backupuid_specified)
3309 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3310 if (pvolume_info->backupgid_specified)
3311 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3312 if (pvolume_info->override_uid)
3313 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3314 if (pvolume_info->override_gid)
3315 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3316 if (pvolume_info->dynperm)
3317 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3318 if (pvolume_info->fsc)
3319 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3320 if (pvolume_info->multiuser)
3321 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3322 CIFS_MOUNT_NO_PERM);
3323 if (pvolume_info->strict_io)
3324 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3325 if (pvolume_info->direct_io) {
3326 cFYI(1, "mounting share using direct i/o");
3327 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3329 if (pvolume_info->mfsymlinks) {
3330 if (pvolume_info->sfu_emul) {
3331 cERROR(1, "mount option mfsymlinks ignored if sfu "
3332 "mount option is used");
3334 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3338 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3339 cERROR(1, "mount option dynperm ignored if cifsacl "
3340 "mount option supported");
3344 * When the server supports very large reads and writes via POSIX extensions,
3345 * we can allow up to 2^24-1, minus the size of a READ/WRITE_AND_X header, not
3346 * including the RFC1001 length.
3348 * Note that this might make for "interesting" allocation problems during
3349 * writeback however as we have to allocate an array of pointers for the
3350 * pages. A 16M write means ~32kb page array with PAGE_CACHE_SIZE == 4096.
3352 * For reads, there is a similar problem as we need to allocate an array
3353 * of kvecs to handle the receive, though that should only need to be done
3356 #define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
3357 #define CIFS_MAX_RSIZE ((1<<24) - sizeof(READ_RSP) + 4)
3360 * When the server doesn't allow large posix writes, only allow a rsize/wsize
3361 * of 2^17-1 minus the size of the call header. That allows for a read or
3362 * write up to the maximum size described by RFC1002.
3364 #define CIFS_MAX_RFC1002_WSIZE ((1<<17) - 1 - sizeof(WRITE_REQ) + 4)
3365 #define CIFS_MAX_RFC1002_RSIZE ((1<<17) - 1 - sizeof(READ_RSP) + 4)
3368 * The default wsize is 1M. find_get_pages seems to return a maximum of 256
3369 * pages in a single call. With PAGE_CACHE_SIZE == 4k, this means we can fill
3370 * a single wsize request with a single call.
3372 #define CIFS_DEFAULT_IOSIZE (1024 * 1024)
3375 * Windows only supports a max of 60kb reads and 65535 byte writes. Default to
3376 * those values when posix extensions aren't in force. In actuality here, we
3377 * use 65536 to allow for a write that is a multiple of 4k. Most servers seem
3378 * to be ok with the extra byte even though Windows doesn't send writes that
3383 * http://blogs.msdn.com/b/openspecification/archive/2009/04/10/smb-maximum-transmit-buffer-size-and-performance-tuning.aspx
3385 #define CIFS_DEFAULT_NON_POSIX_RSIZE (60 * 1024)
3386 #define CIFS_DEFAULT_NON_POSIX_WSIZE (65536)
3389 cifs_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
3391 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3392 struct TCP_Server_Info *server = tcon->ses->server;
3395 /* start with specified wsize, or default */
3396 if (pvolume_info->wsize)
3397 wsize = pvolume_info->wsize;
3398 else if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
3399 wsize = CIFS_DEFAULT_IOSIZE;
3401 wsize = CIFS_DEFAULT_NON_POSIX_WSIZE;
3403 /* can server support 24-bit write sizes? (via UNIX extensions) */
3404 if (!tcon->unix_ext || !(unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
3405 wsize = min_t(unsigned int, wsize, CIFS_MAX_RFC1002_WSIZE);
3408 * no CAP_LARGE_WRITE_X or is signing enabled without CAP_UNIX set?
3409 * Limit it to max buffer offered by the server, minus the size of the
3410 * WRITEX header, not including the 4 byte RFC1001 length.
3412 if (!(server->capabilities & CAP_LARGE_WRITE_X) ||
3413 (!(server->capabilities & CAP_UNIX) &&
3414 (server->sec_mode & (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED))))
3415 wsize = min_t(unsigned int, wsize,
3416 server->maxBuf - sizeof(WRITE_REQ) + 4);
3418 /* hard limit of CIFS_MAX_WSIZE */
3419 wsize = min_t(unsigned int, wsize, CIFS_MAX_WSIZE);
3425 cifs_negotiate_rsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
3427 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3428 struct TCP_Server_Info *server = tcon->ses->server;
3429 unsigned int rsize, defsize;
3432 * Set default value...
3434 * HACK alert! Ancient servers have very small buffers. Even though
3435 * MS-CIFS indicates that servers are only limited by the client's
3436 * bufsize for reads, testing against win98se shows that it throws
3437 * INVALID_PARAMETER errors if you try to request too large a read.
3439 * If the server advertises a MaxBufferSize of less than one page,
3440 * assume that it also can't satisfy reads larger than that either.
3442 * FIXME: Is there a better heuristic for this?
3444 if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_READ_CAP))
3445 defsize = CIFS_DEFAULT_IOSIZE;
3446 else if (server->capabilities & CAP_LARGE_READ_X)
3447 defsize = CIFS_DEFAULT_NON_POSIX_RSIZE;
3448 else if (server->maxBuf >= PAGE_CACHE_SIZE)
3449 defsize = CIFSMaxBufSize;
3451 defsize = server->maxBuf - sizeof(READ_RSP);
3453 rsize = pvolume_info->rsize ? pvolume_info->rsize : defsize;
3456 * no CAP_LARGE_READ_X? Then MS-CIFS states that we must limit this to
3457 * the client's MaxBufferSize.
3459 if (!(server->capabilities & CAP_LARGE_READ_X))
3460 rsize = min_t(unsigned int, CIFSMaxBufSize, rsize);
3462 /* hard limit of CIFS_MAX_RSIZE */
3463 rsize = min_t(unsigned int, rsize, CIFS_MAX_RSIZE);
3469 is_path_accessible(int xid, struct cifs_tcon *tcon,
3470 struct cifs_sb_info *cifs_sb, const char *full_path)
3473 FILE_ALL_INFO *pfile_info;
3475 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
3476 if (pfile_info == NULL)
3479 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
3480 0 /* not legacy */, cifs_sb->local_nls,
3481 cifs_sb->mnt_cifs_flags &
3482 CIFS_MOUNT_MAP_SPECIAL_CHR);
3484 if (rc == -EOPNOTSUPP || rc == -EINVAL)
3485 rc = SMBQueryInformation(xid, tcon, full_path, pfile_info,
3486 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
3487 CIFS_MOUNT_MAP_SPECIAL_CHR);
3493 cleanup_volume_info_contents(struct smb_vol *volume_info)
3495 kfree(volume_info->username);
3496 kzfree(volume_info->password);
3497 if (volume_info->UNCip != volume_info->UNC + 2)
3498 kfree(volume_info->UNCip);
3499 kfree(volume_info->UNC);
3500 kfree(volume_info->domainname);
3501 kfree(volume_info->iocharset);
3502 kfree(volume_info->prepath);
3506 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3510 cleanup_volume_info_contents(volume_info);
3515 #ifdef CONFIG_CIFS_DFS_UPCALL
3516 /* build_path_to_root returns full path to root when
3517 * we do not have an exiting connection (tcon) */
3519 build_unc_path_to_root(const struct smb_vol *vol,
3520 const struct cifs_sb_info *cifs_sb)
3522 char *full_path, *pos;
3523 unsigned int pplen = vol->prepath ? strlen(vol->prepath) : 0;
3524 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3526 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3527 if (full_path == NULL)
3528 return ERR_PTR(-ENOMEM);
3530 strncpy(full_path, vol->UNC, unc_len);
3531 pos = full_path + unc_len;
3534 strncpy(pos, vol->prepath, pplen);
3538 *pos = '\0'; /* add trailing null */
3539 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3540 cFYI(1, "%s: full_path=%s", __func__, full_path);
3545 * Perform a dfs referral query for a share and (optionally) prefix
3547 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3548 * to a string containing updated options for the submount. Otherwise it
3549 * will be left untouched.
3551 * Returns the rc from get_dfs_path to the caller, which can be used to
3552 * determine whether there were referrals.
3555 expand_dfs_referral(int xid, struct cifs_ses *pSesInfo,
3556 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3560 unsigned int num_referrals = 0;
3561 struct dfs_info3_param *referrals = NULL;
3562 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3564 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3565 if (IS_ERR(full_path))
3566 return PTR_ERR(full_path);
3568 /* For DFS paths, skip the first '\' of the UNC */
3569 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3571 rc = get_dfs_path(xid, pSesInfo , ref_path, cifs_sb->local_nls,
3572 &num_referrals, &referrals,
3573 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
3575 if (!rc && num_referrals > 0) {
3576 char *fake_devname = NULL;
3578 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3579 full_path + 1, referrals,
3582 free_dfs_info_array(referrals, num_referrals);
3584 if (IS_ERR(mdata)) {
3585 rc = PTR_ERR(mdata);
3588 cleanup_volume_info_contents(volume_info);
3589 memset(volume_info, '\0', sizeof(*volume_info));
3590 rc = cifs_setup_volume_info(volume_info, mdata,
3593 kfree(fake_devname);
3594 kfree(cifs_sb->mountdata);
3595 cifs_sb->mountdata = mdata;
3603 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3604 const char *devname)
3608 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3611 if (volume_info->nullauth) {
3612 cFYI(1, "Anonymous login");
3613 kfree(volume_info->username);
3614 volume_info->username = NULL;
3615 } else if (volume_info->username) {
3616 /* BB fixme parse for domain name here */
3617 cFYI(1, "Username: %s", volume_info->username);
3619 cifserror("No username specified");
3620 /* In userspace mount helper we can get user name from alternate
3621 locations such as env variables and files on disk */
3625 /* this is needed for ASCII cp to Unicode converts */
3626 if (volume_info->iocharset == NULL) {
3627 /* load_nls_default cannot return null */
3628 volume_info->local_nls = load_nls_default();
3630 volume_info->local_nls = load_nls(volume_info->iocharset);
3631 if (volume_info->local_nls == NULL) {
3632 cERROR(1, "CIFS mount error: iocharset %s not found",
3633 volume_info->iocharset);
3642 cifs_get_volume_info(char *mount_data, const char *devname)
3645 struct smb_vol *volume_info;
3647 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
3649 return ERR_PTR(-ENOMEM);
3651 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3653 cifs_cleanup_volume_info(volume_info);
3654 volume_info = ERR_PTR(rc);
3660 /* make sure ra_pages is a multiple of rsize */
3661 static inline unsigned int
3662 cifs_ra_pages(struct cifs_sb_info *cifs_sb)
3665 unsigned int rsize_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
3667 if (rsize_pages >= default_backing_dev_info.ra_pages)
3668 return default_backing_dev_info.ra_pages;
3669 else if (rsize_pages == 0)
3672 reads = default_backing_dev_info.ra_pages / rsize_pages;
3673 return reads * rsize_pages;
3677 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3681 struct cifs_ses *pSesInfo;
3682 struct cifs_tcon *tcon;
3683 struct TCP_Server_Info *srvTcp;
3685 struct tcon_link *tlink;
3686 #ifdef CONFIG_CIFS_DFS_UPCALL
3687 int referral_walks_count = 0;
3690 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3694 #ifdef CONFIG_CIFS_DFS_UPCALL
3696 /* cleanup activities if we're chasing a referral */
3697 if (referral_walks_count) {
3699 cifs_put_tcon(tcon);
3701 cifs_put_smb_ses(pSesInfo);
3715 /* get a reference to a tcp session */
3716 srvTcp = cifs_get_tcp_session(volume_info);
3717 if (IS_ERR(srvTcp)) {
3718 rc = PTR_ERR(srvTcp);
3719 bdi_destroy(&cifs_sb->bdi);
3723 /* get a reference to a SMB session */
3724 pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
3725 if (IS_ERR(pSesInfo)) {
3726 rc = PTR_ERR(pSesInfo);
3728 goto mount_fail_check;
3731 /* search for existing tcon to this server share */
3732 tcon = cifs_get_tcon(pSesInfo, volume_info);
3736 goto remote_path_check;
3739 /* tell server which Unix caps we support */
3740 if (tcon->ses->capabilities & CAP_UNIX) {
3741 /* reset of caps checks mount to see if unix extensions
3742 disabled for just this mount */
3743 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3744 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3745 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3746 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3748 goto mount_fail_check;
3751 tcon->unix_ext = 0; /* server does not support them */
3753 /* do not care if following two calls succeed - informational */
3755 CIFSSMBQFSDeviceInfo(xid, tcon);
3756 CIFSSMBQFSAttributeInfo(xid, tcon);
3759 cifs_sb->wsize = cifs_negotiate_wsize(tcon, volume_info);
3760 cifs_sb->rsize = cifs_negotiate_rsize(tcon, volume_info);
3762 /* tune readahead according to rsize */
3763 cifs_sb->bdi.ra_pages = cifs_ra_pages(cifs_sb);
3766 #ifdef CONFIG_CIFS_DFS_UPCALL
3768 * Perform an unconditional check for whether there are DFS
3769 * referrals for this path without prefix, to provide support
3770 * for DFS referrals from w2k8 servers which don't seem to respond
3771 * with PATH_NOT_COVERED to requests that include the prefix.
3772 * Chase the referral if found, otherwise continue normally.
3774 if (referral_walks_count == 0) {
3775 int refrc = expand_dfs_referral(xid, pSesInfo, volume_info,
3778 referral_walks_count++;
3779 goto try_mount_again;
3784 /* check if a whole path is not remote */
3786 /* build_path_to_root works only when we have a valid tcon */
3787 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3788 if (full_path == NULL) {
3790 goto mount_fail_check;
3792 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
3793 if (rc != 0 && rc != -EREMOTE) {
3795 goto mount_fail_check;
3800 /* get referral if needed */
3801 if (rc == -EREMOTE) {
3802 #ifdef CONFIG_CIFS_DFS_UPCALL
3803 if (referral_walks_count > MAX_NESTED_LINKS) {
3805 * BB: when we implement proper loop detection,
3806 * we will remove this check. But now we need it
3807 * to prevent an indefinite loop if 'DFS tree' is
3808 * misconfigured (i.e. has loops).
3811 goto mount_fail_check;
3814 rc = expand_dfs_referral(xid, pSesInfo, volume_info, cifs_sb,
3818 referral_walks_count++;
3819 goto try_mount_again;
3821 goto mount_fail_check;
3822 #else /* No DFS support, return error on mount */
3828 goto mount_fail_check;
3830 /* now, hang the tcon off of the superblock */
3831 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3832 if (tlink == NULL) {
3834 goto mount_fail_check;
3837 tlink->tl_uid = pSesInfo->linux_uid;
3838 tlink->tl_tcon = tcon;
3839 tlink->tl_time = jiffies;
3840 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3841 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3843 cifs_sb->master_tlink = tlink;
3844 spin_lock(&cifs_sb->tlink_tree_lock);
3845 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3846 spin_unlock(&cifs_sb->tlink_tree_lock);
3848 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3852 /* on error free sesinfo and tcon struct if needed */
3854 /* If find_unc succeeded then rc == 0 so we can not end */
3855 /* up accidentally freeing someone elses tcon struct */
3857 cifs_put_tcon(tcon);
3859 cifs_put_smb_ses(pSesInfo);
3861 cifs_put_tcp_session(srvTcp);
3862 bdi_destroy(&cifs_sb->bdi);
3871 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3872 * pointer may be NULL.
3875 CIFSTCon(unsigned int xid, struct cifs_ses *ses,
3876 const char *tree, struct cifs_tcon *tcon,
3877 const struct nls_table *nls_codepage)
3879 struct smb_hdr *smb_buffer;
3880 struct smb_hdr *smb_buffer_response;
3883 unsigned char *bcc_ptr;
3886 __u16 bytes_left, count;
3891 smb_buffer = cifs_buf_get();
3892 if (smb_buffer == NULL)
3895 smb_buffer_response = smb_buffer;
3897 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3898 NULL /*no tid */ , 4 /*wct */ );
3900 smb_buffer->Mid = GetNextMid(ses->server);
3901 smb_buffer->Uid = ses->Suid;
3902 pSMB = (TCONX_REQ *) smb_buffer;
3903 pSMBr = (TCONX_RSP *) smb_buffer_response;
3905 pSMB->AndXCommand = 0xFF;
3906 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3907 bcc_ptr = &pSMB->Password[0];
3908 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3909 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3910 *bcc_ptr = 0; /* password is null byte */
3911 bcc_ptr++; /* skip password */
3912 /* already aligned so no need to do it below */
3914 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3915 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3916 specified as required (when that support is added to
3917 the vfs in the future) as only NTLM or the much
3918 weaker LANMAN (which we do not send by default) is accepted
3919 by Samba (not sure whether other servers allow
3920 NTLMv2 password here) */
3921 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3922 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3923 (ses->server->secType == LANMAN))
3924 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3925 ses->server->sec_mode &
3926 SECMODE_PW_ENCRYPT ? true : false,
3929 #endif /* CIFS_WEAK_PW_HASH */
3930 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3931 bcc_ptr, nls_codepage);
3933 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3934 if (ses->capabilities & CAP_UNICODE) {
3935 /* must align unicode strings */
3936 *bcc_ptr = 0; /* null byte password */
3941 if (ses->server->sec_mode &
3942 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3943 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3945 if (ses->capabilities & CAP_STATUS32) {
3946 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3948 if (ses->capabilities & CAP_DFS) {
3949 smb_buffer->Flags2 |= SMBFLG2_DFS;
3951 if (ses->capabilities & CAP_UNICODE) {
3952 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3954 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3955 6 /* max utf8 char length in bytes */ *
3956 (/* server len*/ + 256 /* share len */), nls_codepage);
3957 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3958 bcc_ptr += 2; /* skip trailing null */
3959 } else { /* ASCII */
3960 strcpy(bcc_ptr, tree);
3961 bcc_ptr += strlen(tree) + 1;
3963 strcpy(bcc_ptr, "?????");
3964 bcc_ptr += strlen("?????");
3966 count = bcc_ptr - &pSMB->Password[0];
3967 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3968 pSMB->hdr.smb_buf_length) + count);
3969 pSMB->ByteCount = cpu_to_le16(count);
3971 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3974 /* above now done in SendReceive */
3975 if ((rc == 0) && (tcon != NULL)) {
3978 tcon->tidStatus = CifsGood;
3979 tcon->need_reconnect = false;
3980 tcon->tid = smb_buffer_response->Tid;
3981 bcc_ptr = pByteArea(smb_buffer_response);
3982 bytes_left = get_bcc(smb_buffer_response);
3983 length = strnlen(bcc_ptr, bytes_left - 2);
3984 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3990 /* skip service field (NB: this field is always ASCII) */
3992 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3993 (bcc_ptr[2] == 'C')) {
3994 cFYI(1, "IPC connection");
3997 } else if (length == 2) {
3998 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3999 /* the most common case */
4000 cFYI(1, "disk share connection");
4003 bcc_ptr += length + 1;
4004 bytes_left -= (length + 1);
4005 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
4007 /* mostly informational -- no need to fail on error here */
4008 kfree(tcon->nativeFileSystem);
4009 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
4010 bytes_left, is_unicode,
4013 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
4015 if ((smb_buffer_response->WordCount == 3) ||
4016 (smb_buffer_response->WordCount == 7))
4017 /* field is in same location */
4018 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
4021 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
4022 } else if ((rc == 0) && tcon == NULL) {
4023 /* all we need to save for IPC$ connection */
4024 ses->ipc_tid = smb_buffer_response->Tid;
4027 cifs_buf_release(smb_buffer);
4032 cifs_umount(struct cifs_sb_info *cifs_sb)
4034 struct rb_root *root = &cifs_sb->tlink_tree;
4035 struct rb_node *node;
4036 struct tcon_link *tlink;
4038 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
4040 spin_lock(&cifs_sb->tlink_tree_lock);
4041 while ((node = rb_first(root))) {
4042 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4043 cifs_get_tlink(tlink);
4044 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4045 rb_erase(node, root);
4047 spin_unlock(&cifs_sb->tlink_tree_lock);
4048 cifs_put_tlink(tlink);
4049 spin_lock(&cifs_sb->tlink_tree_lock);
4051 spin_unlock(&cifs_sb->tlink_tree_lock);
4053 bdi_destroy(&cifs_sb->bdi);
4054 kfree(cifs_sb->mountdata);
4055 unload_nls(cifs_sb->local_nls);
4059 int cifs_negotiate_protocol(unsigned int xid, struct cifs_ses *ses)
4062 struct TCP_Server_Info *server = ses->server;
4064 /* only send once per connect */
4065 if (server->maxBuf != 0)
4068 cifs_set_credits(server, 1);
4069 rc = CIFSSMBNegotiate(xid, ses);
4070 if (rc == -EAGAIN) {
4071 /* retry only once on 1st time connection */
4072 cifs_set_credits(server, 1);
4073 rc = CIFSSMBNegotiate(xid, ses);
4078 spin_lock(&GlobalMid_Lock);
4079 if (server->tcpStatus == CifsNeedNegotiate)
4080 server->tcpStatus = CifsGood;
4083 spin_unlock(&GlobalMid_Lock);
4091 int cifs_setup_session(unsigned int xid, struct cifs_ses *ses,
4092 struct nls_table *nls_info)
4095 struct TCP_Server_Info *server = ses->server;
4098 ses->capabilities = server->capabilities;
4099 if (linuxExtEnabled == 0)
4100 ses->capabilities &= (~CAP_UNIX);
4102 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
4103 server->sec_mode, server->capabilities, server->timeAdj);
4105 rc = CIFS_SessSetup(xid, ses, nls_info);
4107 cERROR(1, "Send error in SessSetup = %d", rc);
4109 mutex_lock(&ses->server->srv_mutex);
4110 if (!server->session_estab) {
4111 server->session_key.response = ses->auth_key.response;
4112 server->session_key.len = ses->auth_key.len;
4113 server->sequence_number = 0x2;
4114 server->session_estab = true;
4115 ses->auth_key.response = NULL;
4117 mutex_unlock(&server->srv_mutex);
4119 cFYI(1, "CIFS Session Established successfully");
4120 spin_lock(&GlobalMid_Lock);
4121 ses->status = CifsGood;
4122 ses->need_reconnect = false;
4123 spin_unlock(&GlobalMid_Lock);
4126 kfree(ses->auth_key.response);
4127 ses->auth_key.response = NULL;
4128 ses->auth_key.len = 0;
4129 kfree(ses->ntlmssp);
4130 ses->ntlmssp = NULL;
4136 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
4138 switch (ses->server->secType) {
4140 vol->secFlg = CIFSSEC_MUST_KRB5;
4143 vol->secFlg = CIFSSEC_MUST_NTLMV2;
4146 vol->secFlg = CIFSSEC_MUST_NTLM;
4149 vol->secFlg = CIFSSEC_MUST_NTLMSSP;
4152 vol->secFlg = CIFSSEC_MUST_LANMAN;
4156 return cifs_set_cifscreds(vol, ses);
4159 static struct cifs_tcon *
4160 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
4163 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4164 struct cifs_ses *ses;
4165 struct cifs_tcon *tcon = NULL;
4166 struct smb_vol *vol_info;
4168 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
4169 if (vol_info == NULL)
4170 return ERR_PTR(-ENOMEM);
4172 vol_info->local_nls = cifs_sb->local_nls;
4173 vol_info->linux_uid = fsuid;
4174 vol_info->cred_uid = fsuid;
4175 vol_info->UNC = master_tcon->treeName;
4176 vol_info->retry = master_tcon->retry;
4177 vol_info->nocase = master_tcon->nocase;
4178 vol_info->local_lease = master_tcon->local_lease;
4179 vol_info->no_linux_ext = !master_tcon->unix_ext;
4181 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4187 /* get a reference for the same TCP session */
4188 spin_lock(&cifs_tcp_ses_lock);
4189 ++master_tcon->ses->server->srv_count;
4190 spin_unlock(&cifs_tcp_ses_lock);
4192 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4194 tcon = (struct cifs_tcon *)ses;
4195 cifs_put_tcp_session(master_tcon->ses->server);
4199 tcon = cifs_get_tcon(ses, vol_info);
4201 cifs_put_smb_ses(ses);
4205 if (ses->capabilities & CAP_UNIX)
4206 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4208 kfree(vol_info->username);
4209 kfree(vol_info->password);
4216 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4218 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4222 cifs_sb_tcon_pending_wait(void *unused)
4225 return signal_pending(current) ? -ERESTARTSYS : 0;
4228 /* find and return a tlink with given uid */
4229 static struct tcon_link *
4230 tlink_rb_search(struct rb_root *root, uid_t uid)
4232 struct rb_node *node = root->rb_node;
4233 struct tcon_link *tlink;
4236 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4238 if (tlink->tl_uid > uid)
4239 node = node->rb_left;
4240 else if (tlink->tl_uid < uid)
4241 node = node->rb_right;
4248 /* insert a tcon_link into the tree */
4250 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4252 struct rb_node **new = &(root->rb_node), *parent = NULL;
4253 struct tcon_link *tlink;
4256 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4259 if (tlink->tl_uid > new_tlink->tl_uid)
4260 new = &((*new)->rb_left);
4262 new = &((*new)->rb_right);
4265 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4266 rb_insert_color(&new_tlink->tl_rbnode, root);
4270 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4273 * If the superblock doesn't refer to a multiuser mount, then just return
4274 * the master tcon for the mount.
4276 * First, search the rbtree for an existing tcon for this fsuid. If one
4277 * exists, then check to see if it's pending construction. If it is then wait
4278 * for construction to complete. Once it's no longer pending, check to see if
4279 * it failed and either return an error or retry construction, depending on
4282 * If one doesn't exist then insert a new tcon_link struct into the tree and
4283 * try to construct a new one.
4286 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4289 uid_t fsuid = current_fsuid();
4290 struct tcon_link *tlink, *newtlink;
4292 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4293 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4295 spin_lock(&cifs_sb->tlink_tree_lock);
4296 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4298 cifs_get_tlink(tlink);
4299 spin_unlock(&cifs_sb->tlink_tree_lock);
4301 if (tlink == NULL) {
4302 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4303 if (newtlink == NULL)
4304 return ERR_PTR(-ENOMEM);
4305 newtlink->tl_uid = fsuid;
4306 newtlink->tl_tcon = ERR_PTR(-EACCES);
4307 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4308 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4309 cifs_get_tlink(newtlink);
4311 spin_lock(&cifs_sb->tlink_tree_lock);
4312 /* was one inserted after previous search? */
4313 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4315 cifs_get_tlink(tlink);
4316 spin_unlock(&cifs_sb->tlink_tree_lock);
4318 goto wait_for_construction;
4321 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4322 spin_unlock(&cifs_sb->tlink_tree_lock);
4324 wait_for_construction:
4325 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4326 cifs_sb_tcon_pending_wait,
4327 TASK_INTERRUPTIBLE);
4329 cifs_put_tlink(tlink);
4330 return ERR_PTR(ret);
4333 /* if it's good, return it */
4334 if (!IS_ERR(tlink->tl_tcon))
4337 /* return error if we tried this already recently */
4338 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4339 cifs_put_tlink(tlink);
4340 return ERR_PTR(-EACCES);
4343 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4344 goto wait_for_construction;
4347 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4348 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4349 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4351 if (IS_ERR(tlink->tl_tcon)) {
4352 cifs_put_tlink(tlink);
4353 return ERR_PTR(-EACCES);
4360 * periodic workqueue job that scans tcon_tree for a superblock and closes
4364 cifs_prune_tlinks(struct work_struct *work)
4366 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4368 struct rb_root *root = &cifs_sb->tlink_tree;
4369 struct rb_node *node = rb_first(root);
4370 struct rb_node *tmp;
4371 struct tcon_link *tlink;
4374 * Because we drop the spinlock in the loop in order to put the tlink
4375 * it's not guarded against removal of links from the tree. The only
4376 * places that remove entries from the tree are this function and
4377 * umounts. Because this function is non-reentrant and is canceled
4378 * before umount can proceed, this is safe.
4380 spin_lock(&cifs_sb->tlink_tree_lock);
4381 node = rb_first(root);
4382 while (node != NULL) {
4384 node = rb_next(tmp);
4385 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4387 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4388 atomic_read(&tlink->tl_count) != 0 ||
4389 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4392 cifs_get_tlink(tlink);
4393 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4394 rb_erase(tmp, root);
4396 spin_unlock(&cifs_sb->tlink_tree_lock);
4397 cifs_put_tlink(tlink);
4398 spin_lock(&cifs_sb->tlink_tree_lock);
4400 spin_unlock(&cifs_sb->tlink_tree_lock);
4402 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,