4 * Copyright (C) International Business Machines Corp., 2002,2011
5 * Author(s): Steve French (sfrench@us.ibm.com)
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/net.h>
23 #include <linux/string.h>
24 #include <linux/sched/signal.h>
25 #include <linux/list.h>
26 #include <linux/wait.h>
27 #include <linux/slab.h>
28 #include <linux/pagemap.h>
29 #include <linux/ctype.h>
30 #include <linux/utsname.h>
31 #include <linux/mempool.h>
32 #include <linux/delay.h>
33 #include <linux/completion.h>
34 #include <linux/kthread.h>
35 #include <linux/pagevec.h>
36 #include <linux/freezer.h>
37 #include <linux/namei.h>
38 #include <linux/uuid.h>
39 #include <linux/uaccess.h>
40 #include <asm/processor.h>
41 #include <linux/inet.h>
42 #include <linux/module.h>
43 #include <keys/user-type.h>
45 #include <linux/parser.h>
46 #include <linux/bvec.h>
50 #include "cifsproto.h"
51 #include "cifs_unicode.h"
52 #include "cifs_debug.h"
53 #include "cifs_fs_sb.h"
56 #include "rfc1002pdu.h"
58 #include "smb2proto.h"
61 #define RFC1001_PORT 139
63 extern mempool_t
*cifs_req_poolp
;
65 /* FIXME: should these be tunable? */
66 #define TLINK_ERROR_EXPIRE (1 * HZ)
67 #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_forcegid
, Opt_noforcegid
,
74 Opt_noblocksend
, Opt_noautotune
,
75 Opt_hard
, Opt_soft
, Opt_perm
, Opt_noperm
,
76 Opt_mapposix
, Opt_nomapposix
,
77 Opt_mapchars
, Opt_nomapchars
, Opt_sfu
,
78 Opt_nosfu
, Opt_nodfs
, Opt_posixpaths
,
79 Opt_noposixpaths
, Opt_nounix
,
82 Opt_forcemandatorylock
, Opt_setuidfromacl
, Opt_setuids
,
83 Opt_nosetuids
, Opt_dynperm
, Opt_nodynperm
,
84 Opt_nohard
, Opt_nosoft
,
86 Opt_nostrictsync
, Opt_strictsync
,
87 Opt_serverino
, Opt_noserverino
,
88 Opt_rwpidforward
, Opt_cifsacl
, Opt_nocifsacl
,
89 Opt_acl
, Opt_noacl
, Opt_locallease
,
90 Opt_sign
, Opt_seal
, Opt_noac
,
91 Opt_fsc
, Opt_mfsymlinks
,
92 Opt_multiuser
, Opt_sloppy
, Opt_nosharesock
,
93 Opt_persistent
, Opt_nopersistent
,
94 Opt_resilient
, Opt_noresilient
,
97 /* Mount options which take numeric value */
98 Opt_backupuid
, Opt_backupgid
, Opt_uid
,
99 Opt_cruid
, Opt_gid
, Opt_file_mode
,
100 Opt_dirmode
, Opt_port
,
101 Opt_rsize
, Opt_wsize
, Opt_actimeo
,
102 Opt_echo_interval
, Opt_max_credits
,
105 /* Mount options which take string value */
106 Opt_user
, Opt_pass
, Opt_ip
,
107 Opt_domain
, Opt_srcaddr
, Opt_iocharset
,
108 Opt_netbiosname
, Opt_servern
,
109 Opt_ver
, Opt_vers
, Opt_sec
, Opt_cache
,
111 /* Mount options to be ignored */
114 /* Options which could be blank */
122 static const match_table_t cifs_mount_option_tokens
= {
124 { Opt_user_xattr
, "user_xattr" },
125 { Opt_nouser_xattr
, "nouser_xattr" },
126 { Opt_forceuid
, "forceuid" },
127 { Opt_noforceuid
, "noforceuid" },
128 { Opt_forcegid
, "forcegid" },
129 { Opt_noforcegid
, "noforcegid" },
130 { Opt_noblocksend
, "noblocksend" },
131 { Opt_noautotune
, "noautotune" },
132 { Opt_hard
, "hard" },
133 { Opt_soft
, "soft" },
134 { Opt_perm
, "perm" },
135 { Opt_noperm
, "noperm" },
136 { Opt_mapchars
, "mapchars" }, /* SFU style */
137 { Opt_nomapchars
, "nomapchars" },
138 { Opt_mapposix
, "mapposix" }, /* SFM style */
139 { Opt_nomapposix
, "nomapposix" },
141 { Opt_nosfu
, "nosfu" },
142 { Opt_nodfs
, "nodfs" },
143 { Opt_posixpaths
, "posixpaths" },
144 { Opt_noposixpaths
, "noposixpaths" },
145 { Opt_nounix
, "nounix" },
146 { Opt_nounix
, "nolinux" },
147 { Opt_nocase
, "nocase" },
148 { Opt_nocase
, "ignorecase" },
150 { Opt_nobrl
, "nobrl" },
151 { Opt_nobrl
, "nolock" },
152 { Opt_forcemandatorylock
, "forcemandatorylock" },
153 { Opt_forcemandatorylock
, "forcemand" },
154 { Opt_setuids
, "setuids" },
155 { Opt_nosetuids
, "nosetuids" },
156 { Opt_setuidfromacl
, "idsfromsid" },
157 { Opt_dynperm
, "dynperm" },
158 { Opt_nodynperm
, "nodynperm" },
159 { Opt_nohard
, "nohard" },
160 { Opt_nosoft
, "nosoft" },
161 { Opt_nointr
, "nointr" },
162 { Opt_intr
, "intr" },
163 { Opt_nostrictsync
, "nostrictsync" },
164 { Opt_strictsync
, "strictsync" },
165 { Opt_serverino
, "serverino" },
166 { Opt_noserverino
, "noserverino" },
167 { Opt_rwpidforward
, "rwpidforward" },
168 { Opt_cifsacl
, "cifsacl" },
169 { Opt_nocifsacl
, "nocifsacl" },
171 { Opt_noacl
, "noacl" },
172 { Opt_locallease
, "locallease" },
173 { Opt_sign
, "sign" },
174 { Opt_seal
, "seal" },
175 { Opt_noac
, "noac" },
177 { Opt_mfsymlinks
, "mfsymlinks" },
178 { Opt_multiuser
, "multiuser" },
179 { Opt_sloppy
, "sloppy" },
180 { Opt_nosharesock
, "nosharesock" },
181 { Opt_persistent
, "persistenthandles"},
182 { Opt_nopersistent
, "nopersistenthandles"},
183 { Opt_resilient
, "resilienthandles"},
184 { Opt_noresilient
, "noresilienthandles"},
185 { Opt_domainauto
, "domainauto"},
187 { Opt_backupuid
, "backupuid=%s" },
188 { Opt_backupgid
, "backupgid=%s" },
189 { Opt_uid
, "uid=%s" },
190 { Opt_cruid
, "cruid=%s" },
191 { Opt_gid
, "gid=%s" },
192 { Opt_file_mode
, "file_mode=%s" },
193 { Opt_dirmode
, "dirmode=%s" },
194 { Opt_dirmode
, "dir_mode=%s" },
195 { Opt_port
, "port=%s" },
196 { Opt_rsize
, "rsize=%s" },
197 { Opt_wsize
, "wsize=%s" },
198 { Opt_actimeo
, "actimeo=%s" },
199 { Opt_echo_interval
, "echo_interval=%s" },
200 { Opt_max_credits
, "max_credits=%s" },
201 { Opt_snapshot
, "snapshot=%s" },
203 { Opt_blank_user
, "user=" },
204 { Opt_blank_user
, "username=" },
205 { Opt_user
, "user=%s" },
206 { Opt_user
, "username=%s" },
207 { Opt_blank_pass
, "pass=" },
208 { Opt_blank_pass
, "password=" },
209 { Opt_pass
, "pass=%s" },
210 { Opt_pass
, "password=%s" },
211 { Opt_blank_ip
, "ip=" },
212 { Opt_blank_ip
, "addr=" },
214 { Opt_ip
, "addr=%s" },
215 { Opt_ignore
, "unc=%s" },
216 { Opt_ignore
, "target=%s" },
217 { Opt_ignore
, "path=%s" },
218 { Opt_domain
, "dom=%s" },
219 { Opt_domain
, "domain=%s" },
220 { Opt_domain
, "workgroup=%s" },
221 { Opt_srcaddr
, "srcaddr=%s" },
222 { Opt_ignore
, "prefixpath=%s" },
223 { Opt_iocharset
, "iocharset=%s" },
224 { Opt_netbiosname
, "netbiosname=%s" },
225 { Opt_servern
, "servern=%s" },
226 { Opt_ver
, "ver=%s" },
227 { Opt_vers
, "vers=%s" },
228 { Opt_sec
, "sec=%s" },
229 { Opt_cache
, "cache=%s" },
231 { Opt_ignore
, "cred" },
232 { Opt_ignore
, "credentials" },
233 { Opt_ignore
, "cred=%s" },
234 { Opt_ignore
, "credentials=%s" },
235 { Opt_ignore
, "guest" },
236 { Opt_ignore
, "rw" },
237 { Opt_ignore
, "ro" },
238 { Opt_ignore
, "suid" },
239 { Opt_ignore
, "nosuid" },
240 { Opt_ignore
, "exec" },
241 { Opt_ignore
, "noexec" },
242 { Opt_ignore
, "nodev" },
243 { Opt_ignore
, "noauto" },
244 { Opt_ignore
, "dev" },
245 { Opt_ignore
, "mand" },
246 { Opt_ignore
, "nomand" },
247 { Opt_ignore
, "_netdev" },
253 Opt_sec_krb5
, Opt_sec_krb5i
, Opt_sec_krb5p
,
254 Opt_sec_ntlmsspi
, Opt_sec_ntlmssp
,
255 Opt_ntlm
, Opt_sec_ntlmi
, Opt_sec_ntlmv2
,
256 Opt_sec_ntlmv2i
, Opt_sec_lanman
,
262 static const match_table_t cifs_secflavor_tokens
= {
263 { Opt_sec_krb5
, "krb5" },
264 { Opt_sec_krb5i
, "krb5i" },
265 { Opt_sec_krb5p
, "krb5p" },
266 { Opt_sec_ntlmsspi
, "ntlmsspi" },
267 { Opt_sec_ntlmssp
, "ntlmssp" },
268 { Opt_ntlm
, "ntlm" },
269 { Opt_sec_ntlmi
, "ntlmi" },
270 { Opt_sec_ntlmv2
, "nontlm" },
271 { Opt_sec_ntlmv2
, "ntlmv2" },
272 { Opt_sec_ntlmv2i
, "ntlmv2i" },
273 { Opt_sec_lanman
, "lanman" },
274 { Opt_sec_none
, "none" },
276 { Opt_sec_err
, NULL
}
287 static const match_table_t cifs_cacheflavor_tokens
= {
288 { Opt_cache_loose
, "loose" },
289 { Opt_cache_strict
, "strict" },
290 { Opt_cache_none
, "none" },
291 { Opt_cache_err
, NULL
}
294 static const match_table_t cifs_smb_version_tokens
= {
295 { Smb_1
, SMB1_VERSION_STRING
},
296 { Smb_20
, SMB20_VERSION_STRING
},
297 { Smb_21
, SMB21_VERSION_STRING
},
298 { Smb_30
, SMB30_VERSION_STRING
},
299 { Smb_302
, SMB302_VERSION_STRING
},
300 #ifdef CONFIG_CIFS_SMB311
301 { Smb_311
, SMB311_VERSION_STRING
},
302 { Smb_311
, ALT_SMB311_VERSION_STRING
},
304 { Smb_3any
, SMB3ANY_VERSION_STRING
},
305 { Smb_default
, SMBDEFAULT_VERSION_STRING
},
306 { Smb_version_err
, NULL
}
309 static int ip_connect(struct TCP_Server_Info
*server
);
310 static int generic_ip_connect(struct TCP_Server_Info
*server
);
311 static void tlink_rb_insert(struct rb_root
*root
, struct tcon_link
*new_tlink
);
312 static void cifs_prune_tlinks(struct work_struct
*work
);
313 static int cifs_setup_volume_info(struct smb_vol
*volume_info
, char *mount_data
,
314 const char *devname
);
317 * cifs tcp session reconnection
319 * mark tcp session as reconnecting so temporarily locked
320 * mark all smb sessions as reconnecting for tcp session
321 * reconnect tcp session
322 * wake up waiters on reconnection? - (not needed currently)
325 cifs_reconnect(struct TCP_Server_Info
*server
)
328 struct list_head
*tmp
, *tmp2
;
329 struct cifs_ses
*ses
;
330 struct cifs_tcon
*tcon
;
331 struct mid_q_entry
*mid_entry
;
332 struct list_head retry_list
;
334 spin_lock(&GlobalMid_Lock
);
335 if (server
->tcpStatus
== CifsExiting
) {
336 /* the demux thread will exit normally
337 next time through the loop */
338 spin_unlock(&GlobalMid_Lock
);
341 server
->tcpStatus
= CifsNeedReconnect
;
342 spin_unlock(&GlobalMid_Lock
);
344 server
->max_read
= 0;
346 cifs_dbg(FYI
, "Reconnecting tcp session\n");
348 /* before reconnecting the tcp session, mark the smb session (uid)
349 and the tid bad so they are not used until reconnected */
350 cifs_dbg(FYI
, "%s: marking sessions and tcons for reconnect\n",
352 spin_lock(&cifs_tcp_ses_lock
);
353 list_for_each(tmp
, &server
->smb_ses_list
) {
354 ses
= list_entry(tmp
, struct cifs_ses
, smb_ses_list
);
355 ses
->need_reconnect
= true;
357 list_for_each(tmp2
, &ses
->tcon_list
) {
358 tcon
= list_entry(tmp2
, struct cifs_tcon
, tcon_list
);
359 tcon
->need_reconnect
= true;
362 spin_unlock(&cifs_tcp_ses_lock
);
364 /* do not want to be sending data on a socket we are freeing */
365 cifs_dbg(FYI
, "%s: tearing down socket\n", __func__
);
366 mutex_lock(&server
->srv_mutex
);
367 if (server
->ssocket
) {
368 cifs_dbg(FYI
, "State: 0x%x Flags: 0x%lx\n",
369 server
->ssocket
->state
, server
->ssocket
->flags
);
370 kernel_sock_shutdown(server
->ssocket
, SHUT_WR
);
371 cifs_dbg(FYI
, "Post shutdown state: 0x%x Flags: 0x%lx\n",
372 server
->ssocket
->state
, server
->ssocket
->flags
);
373 sock_release(server
->ssocket
);
374 server
->ssocket
= NULL
;
376 server
->sequence_number
= 0;
377 server
->session_estab
= false;
378 kfree(server
->session_key
.response
);
379 server
->session_key
.response
= NULL
;
380 server
->session_key
.len
= 0;
381 server
->lstrp
= jiffies
;
383 /* mark submitted MIDs for retry and issue callback */
384 INIT_LIST_HEAD(&retry_list
);
385 cifs_dbg(FYI
, "%s: moving mids to private list\n", __func__
);
386 spin_lock(&GlobalMid_Lock
);
387 list_for_each_safe(tmp
, tmp2
, &server
->pending_mid_q
) {
388 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
389 if (mid_entry
->mid_state
== MID_REQUEST_SUBMITTED
)
390 mid_entry
->mid_state
= MID_RETRY_NEEDED
;
391 list_move(&mid_entry
->qhead
, &retry_list
);
393 spin_unlock(&GlobalMid_Lock
);
394 mutex_unlock(&server
->srv_mutex
);
396 cifs_dbg(FYI
, "%s: issuing mid callbacks\n", __func__
);
397 list_for_each_safe(tmp
, tmp2
, &retry_list
) {
398 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
399 list_del_init(&mid_entry
->qhead
);
400 mid_entry
->callback(mid_entry
);
406 /* we should try only the port we connected to before */
407 mutex_lock(&server
->srv_mutex
);
408 rc
= generic_ip_connect(server
);
410 cifs_dbg(FYI
, "reconnect error %d\n", rc
);
411 mutex_unlock(&server
->srv_mutex
);
414 atomic_inc(&tcpSesReconnectCount
);
415 spin_lock(&GlobalMid_Lock
);
416 if (server
->tcpStatus
!= CifsExiting
)
417 server
->tcpStatus
= CifsNeedNegotiate
;
418 spin_unlock(&GlobalMid_Lock
);
419 mutex_unlock(&server
->srv_mutex
);
421 } while (server
->tcpStatus
== CifsNeedReconnect
);
423 if (server
->tcpStatus
== CifsNeedNegotiate
)
424 mod_delayed_work(cifsiod_wq
, &server
->echo
, 0);
430 cifs_echo_request(struct work_struct
*work
)
433 struct TCP_Server_Info
*server
= container_of(work
,
434 struct TCP_Server_Info
, echo
.work
);
435 unsigned long echo_interval
;
438 * If we need to renegotiate, set echo interval to zero to
439 * immediately call echo service where we can renegotiate.
441 if (server
->tcpStatus
== CifsNeedNegotiate
)
444 echo_interval
= server
->echo_interval
;
447 * We cannot send an echo if it is disabled.
448 * Also, no need to ping if we got a response recently.
451 if (server
->tcpStatus
== CifsNeedReconnect
||
452 server
->tcpStatus
== CifsExiting
||
453 server
->tcpStatus
== CifsNew
||
454 (server
->ops
->can_echo
&& !server
->ops
->can_echo(server
)) ||
455 time_before(jiffies
, server
->lstrp
+ echo_interval
- HZ
))
458 rc
= server
->ops
->echo
? server
->ops
->echo(server
) : -ENOSYS
;
460 cifs_dbg(FYI
, "Unable to send echo request to server: %s\n",
464 queue_delayed_work(cifsiod_wq
, &server
->echo
, server
->echo_interval
);
468 allocate_buffers(struct TCP_Server_Info
*server
)
470 if (!server
->bigbuf
) {
471 server
->bigbuf
= (char *)cifs_buf_get();
472 if (!server
->bigbuf
) {
473 cifs_dbg(VFS
, "No memory for large SMB response\n");
475 /* retry will check if exiting */
478 } else if (server
->large_buf
) {
479 /* we are reusing a dirty large buf, clear its start */
480 memset(server
->bigbuf
, 0, HEADER_SIZE(server
));
483 if (!server
->smallbuf
) {
484 server
->smallbuf
= (char *)cifs_small_buf_get();
485 if (!server
->smallbuf
) {
486 cifs_dbg(VFS
, "No memory for SMB response\n");
488 /* retry will check if exiting */
491 /* beginning of smb buffer is cleared in our buf_get */
493 /* if existing small buf clear beginning */
494 memset(server
->smallbuf
, 0, HEADER_SIZE(server
));
501 server_unresponsive(struct TCP_Server_Info
*server
)
504 * We need to wait 2 echo intervals to make sure we handle such
506 * 1s client sends a normal SMB request
507 * 2s client gets a response
508 * 30s echo workqueue job pops, and decides we got a response recently
509 * and don't need to send another
511 * 65s kernel_recvmsg times out, and we see that we haven't gotten
512 * a response in >60s.
514 if (server
->tcpStatus
== CifsGood
&&
515 time_after(jiffies
, server
->lstrp
+ 2 * server
->echo_interval
)) {
516 cifs_dbg(VFS
, "Server %s has not responded in %lu seconds. Reconnecting...\n",
517 server
->hostname
, (2 * server
->echo_interval
) / HZ
);
518 cifs_reconnect(server
);
519 wake_up(&server
->response_q
);
527 cifs_readv_from_socket(struct TCP_Server_Info
*server
, struct msghdr
*smb_msg
)
532 smb_msg
->msg_control
= NULL
;
533 smb_msg
->msg_controllen
= 0;
535 for (total_read
= 0; msg_data_left(smb_msg
); total_read
+= length
) {
538 if (server_unresponsive(server
))
539 return -ECONNABORTED
;
541 length
= sock_recvmsg(server
->ssocket
, smb_msg
, 0);
543 if (server
->tcpStatus
== CifsExiting
)
546 if (server
->tcpStatus
== CifsNeedReconnect
) {
547 cifs_reconnect(server
);
548 return -ECONNABORTED
;
551 if (length
== -ERESTARTSYS
||
555 * Minimum sleep to prevent looping, allowing socket
556 * to clear and app threads to set tcpStatus
557 * CifsNeedReconnect if server hung.
559 usleep_range(1000, 2000);
565 cifs_dbg(FYI
, "Received no data or error: %d\n", length
);
566 cifs_reconnect(server
);
567 return -ECONNABORTED
;
574 cifs_read_from_socket(struct TCP_Server_Info
*server
, char *buf
,
575 unsigned int to_read
)
577 struct msghdr smb_msg
;
578 struct kvec iov
= {.iov_base
= buf
, .iov_len
= to_read
};
579 iov_iter_kvec(&smb_msg
.msg_iter
, READ
| ITER_KVEC
, &iov
, 1, to_read
);
581 return cifs_readv_from_socket(server
, &smb_msg
);
585 cifs_read_page_from_socket(struct TCP_Server_Info
*server
, struct page
*page
,
586 unsigned int to_read
)
588 struct msghdr smb_msg
;
589 struct bio_vec bv
= {.bv_page
= page
, .bv_len
= to_read
};
590 iov_iter_bvec(&smb_msg
.msg_iter
, READ
| ITER_BVEC
, &bv
, 1, to_read
);
591 return cifs_readv_from_socket(server
, &smb_msg
);
595 is_smb_response(struct TCP_Server_Info
*server
, unsigned char type
)
598 * The first byte big endian of the length field,
599 * is actually not part of the length but the type
600 * with the most common, zero, as regular data.
603 case RFC1002_SESSION_MESSAGE
:
604 /* Regular SMB response */
606 case RFC1002_SESSION_KEEP_ALIVE
:
607 cifs_dbg(FYI
, "RFC 1002 session keep alive\n");
609 case RFC1002_POSITIVE_SESSION_RESPONSE
:
610 cifs_dbg(FYI
, "RFC 1002 positive session response\n");
612 case RFC1002_NEGATIVE_SESSION_RESPONSE
:
614 * We get this from Windows 98 instead of an error on
615 * SMB negprot response.
617 cifs_dbg(FYI
, "RFC 1002 negative session response\n");
618 /* give server a second to clean up */
621 * Always try 445 first on reconnect since we get NACK
622 * on some if we ever connected to port 139 (the NACK
623 * is since we do not begin with RFC1001 session
626 cifs_set_port((struct sockaddr
*)&server
->dstaddr
, CIFS_PORT
);
627 cifs_reconnect(server
);
628 wake_up(&server
->response_q
);
631 cifs_dbg(VFS
, "RFC 1002 unknown response type 0x%x\n", type
);
632 cifs_reconnect(server
);
639 dequeue_mid(struct mid_q_entry
*mid
, bool malformed
)
641 #ifdef CONFIG_CIFS_STATS2
642 mid
->when_received
= jiffies
;
644 spin_lock(&GlobalMid_Lock
);
646 mid
->mid_state
= MID_RESPONSE_RECEIVED
;
648 mid
->mid_state
= MID_RESPONSE_MALFORMED
;
649 list_del_init(&mid
->qhead
);
650 spin_unlock(&GlobalMid_Lock
);
654 handle_mid(struct mid_q_entry
*mid
, struct TCP_Server_Info
*server
,
655 char *buf
, int malformed
)
657 if (server
->ops
->check_trans2
&&
658 server
->ops
->check_trans2(mid
, server
, buf
, malformed
))
661 mid
->large_buf
= server
->large_buf
;
662 /* Was previous buf put in mpx struct for multi-rsp? */
663 if (!mid
->multiRsp
) {
664 /* smb buffer will be freed by user thread */
665 if (server
->large_buf
)
666 server
->bigbuf
= NULL
;
668 server
->smallbuf
= NULL
;
670 dequeue_mid(mid
, malformed
);
673 static void clean_demultiplex_info(struct TCP_Server_Info
*server
)
677 /* take it off the list, if it's not already */
678 spin_lock(&cifs_tcp_ses_lock
);
679 list_del_init(&server
->tcp_ses_list
);
680 spin_unlock(&cifs_tcp_ses_lock
);
682 spin_lock(&GlobalMid_Lock
);
683 server
->tcpStatus
= CifsExiting
;
684 spin_unlock(&GlobalMid_Lock
);
685 wake_up_all(&server
->response_q
);
687 /* check if we have blocked requests that need to free */
688 spin_lock(&server
->req_lock
);
689 if (server
->credits
<= 0)
691 spin_unlock(&server
->req_lock
);
693 * Although there should not be any requests blocked on this queue it
694 * can not hurt to be paranoid and try to wake up requests that may
695 * haven been blocked when more than 50 at time were on the wire to the
696 * same server - they now will see the session is in exit state and get
697 * out of SendReceive.
699 wake_up_all(&server
->request_q
);
700 /* give those requests time to exit */
703 if (server
->ssocket
) {
704 sock_release(server
->ssocket
);
705 server
->ssocket
= NULL
;
708 if (!list_empty(&server
->pending_mid_q
)) {
709 struct list_head dispose_list
;
710 struct mid_q_entry
*mid_entry
;
711 struct list_head
*tmp
, *tmp2
;
713 INIT_LIST_HEAD(&dispose_list
);
714 spin_lock(&GlobalMid_Lock
);
715 list_for_each_safe(tmp
, tmp2
, &server
->pending_mid_q
) {
716 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
717 cifs_dbg(FYI
, "Clearing mid 0x%llx\n", mid_entry
->mid
);
718 mid_entry
->mid_state
= MID_SHUTDOWN
;
719 list_move(&mid_entry
->qhead
, &dispose_list
);
721 spin_unlock(&GlobalMid_Lock
);
723 /* now walk dispose list and issue callbacks */
724 list_for_each_safe(tmp
, tmp2
, &dispose_list
) {
725 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
726 cifs_dbg(FYI
, "Callback mid 0x%llx\n", mid_entry
->mid
);
727 list_del_init(&mid_entry
->qhead
);
728 mid_entry
->callback(mid_entry
);
730 /* 1/8th of sec is more than enough time for them to exit */
734 if (!list_empty(&server
->pending_mid_q
)) {
736 * mpx threads have not exited yet give them at least the smb
737 * send timeout time for long ops.
739 * Due to delays on oplock break requests, we need to wait at
740 * least 45 seconds before giving up on a request getting a
741 * response and going ahead and killing cifsd.
743 cifs_dbg(FYI
, "Wait for exit from demultiplex thread\n");
746 * If threads still have not exited they are probably never
747 * coming home not much else we can do but free the memory.
751 kfree(server
->hostname
);
754 length
= atomic_dec_return(&tcpSesAllocCount
);
756 mempool_resize(cifs_req_poolp
, length
+ cifs_min_rcv
);
760 standard_receive3(struct TCP_Server_Info
*server
, struct mid_q_entry
*mid
)
763 char *buf
= server
->smallbuf
;
764 unsigned int pdu_length
= get_rfc1002_length(buf
);
766 /* make sure this will fit in a large buffer */
767 if (pdu_length
> CIFSMaxBufSize
+ MAX_HEADER_SIZE(server
) - 4) {
768 cifs_dbg(VFS
, "SMB response too long (%u bytes)\n", pdu_length
);
769 cifs_reconnect(server
);
770 wake_up(&server
->response_q
);
771 return -ECONNABORTED
;
774 /* switch to large buffer if too big for a small one */
775 if (pdu_length
> MAX_CIFS_SMALL_BUFFER_SIZE
- 4) {
776 server
->large_buf
= true;
777 memcpy(server
->bigbuf
, buf
, server
->total_read
);
778 buf
= server
->bigbuf
;
781 /* now read the rest */
782 length
= cifs_read_from_socket(server
, buf
+ HEADER_SIZE(server
) - 1,
783 pdu_length
- HEADER_SIZE(server
) + 1 + 4);
786 server
->total_read
+= length
;
788 dump_smb(buf
, server
->total_read
);
790 return cifs_handle_standard(server
, mid
);
794 cifs_handle_standard(struct TCP_Server_Info
*server
, struct mid_q_entry
*mid
)
796 char *buf
= server
->large_buf
? server
->bigbuf
: server
->smallbuf
;
800 * We know that we received enough to get to the MID as we
801 * checked the pdu_length earlier. Now check to see
802 * if the rest of the header is OK. We borrow the length
803 * var for the rest of the loop to avoid a new stack var.
805 * 48 bytes is enough to display the header and a little bit
806 * into the payload for debugging purposes.
808 length
= server
->ops
->check_message(buf
, server
->total_read
, server
);
810 cifs_dump_mem("Bad SMB: ", buf
,
811 min_t(unsigned int, server
->total_read
, 48));
813 if (server
->ops
->is_session_expired
&&
814 server
->ops
->is_session_expired(buf
)) {
815 cifs_reconnect(server
);
816 wake_up(&server
->response_q
);
820 if (server
->ops
->is_status_pending
&&
821 server
->ops
->is_status_pending(buf
, server
, length
))
827 handle_mid(mid
, server
, buf
, length
);
832 cifs_demultiplex_thread(void *p
)
835 struct TCP_Server_Info
*server
= p
;
836 unsigned int pdu_length
;
838 struct task_struct
*task_to_wake
= NULL
;
839 struct mid_q_entry
*mid_entry
;
841 current
->flags
|= PF_MEMALLOC
;
842 cifs_dbg(FYI
, "Demultiplex PID: %d\n", task_pid_nr(current
));
844 length
= atomic_inc_return(&tcpSesAllocCount
);
846 mempool_resize(cifs_req_poolp
, length
+ cifs_min_rcv
);
849 while (server
->tcpStatus
!= CifsExiting
) {
853 if (!allocate_buffers(server
))
856 server
->large_buf
= false;
857 buf
= server
->smallbuf
;
858 pdu_length
= 4; /* enough to get RFC1001 header */
860 length
= cifs_read_from_socket(server
, buf
, pdu_length
);
863 server
->total_read
= length
;
866 * The right amount was read from socket - 4 bytes,
867 * so we can now interpret the length field.
869 pdu_length
= get_rfc1002_length(buf
);
871 cifs_dbg(FYI
, "RFC1002 header 0x%x\n", pdu_length
);
872 if (!is_smb_response(server
, buf
[0]))
875 /* make sure we have enough to get to the MID */
876 if (pdu_length
< HEADER_SIZE(server
) - 1 - 4) {
877 cifs_dbg(VFS
, "SMB response too short (%u bytes)\n",
879 cifs_reconnect(server
);
880 wake_up(&server
->response_q
);
884 /* read down to the MID */
885 length
= cifs_read_from_socket(server
, buf
+ 4,
886 HEADER_SIZE(server
) - 1 - 4);
889 server
->total_read
+= length
;
891 if (server
->ops
->is_transform_hdr
&&
892 server
->ops
->receive_transform
&&
893 server
->ops
->is_transform_hdr(buf
)) {
894 length
= server
->ops
->receive_transform(server
,
897 mid_entry
= server
->ops
->find_mid(server
, buf
);
899 if (!mid_entry
|| !mid_entry
->receive
)
900 length
= standard_receive3(server
, mid_entry
);
902 length
= mid_entry
->receive(server
, mid_entry
);
908 if (server
->large_buf
)
909 buf
= server
->bigbuf
;
911 server
->lstrp
= jiffies
;
912 if (mid_entry
!= NULL
) {
913 if ((mid_entry
->mid_flags
& MID_WAIT_CANCELLED
) &&
914 mid_entry
->mid_state
== MID_RESPONSE_RECEIVED
&&
915 server
->ops
->handle_cancelled_mid
)
916 server
->ops
->handle_cancelled_mid(
920 if (!mid_entry
->multiRsp
|| mid_entry
->multiEnd
)
921 mid_entry
->callback(mid_entry
);
922 } else if (server
->ops
->is_oplock_break
&&
923 server
->ops
->is_oplock_break(buf
, server
)) {
924 cifs_dbg(FYI
, "Received oplock break\n");
926 cifs_dbg(VFS
, "No task to wake, unknown frame received! NumMids %d\n",
927 atomic_read(&midCount
));
928 cifs_dump_mem("Received Data is: ", buf
,
929 HEADER_SIZE(server
));
930 #ifdef CONFIG_CIFS_DEBUG2
931 if (server
->ops
->dump_detail
)
932 server
->ops
->dump_detail(buf
);
933 cifs_dump_mids(server
);
934 #endif /* CIFS_DEBUG2 */
937 } /* end while !EXITING */
939 /* buffer usually freed in free_mid - need to free it here on exit */
940 cifs_buf_release(server
->bigbuf
);
941 if (server
->smallbuf
) /* no sense logging a debug message if NULL */
942 cifs_small_buf_release(server
->smallbuf
);
944 task_to_wake
= xchg(&server
->tsk
, NULL
);
945 clean_demultiplex_info(server
);
947 /* if server->tsk was NULL then wait for a signal before exiting */
949 set_current_state(TASK_INTERRUPTIBLE
);
950 while (!signal_pending(current
)) {
952 set_current_state(TASK_INTERRUPTIBLE
);
954 set_current_state(TASK_RUNNING
);
957 module_put_and_exit(0);
960 /* extract the host portion of the UNC string */
962 extract_hostname(const char *unc
)
968 /* skip double chars at beginning of string */
969 /* BB: check validity of these bytes? */
972 /* delimiter between hostname and sharename is always '\\' now */
973 delim
= strchr(src
, '\\');
975 return ERR_PTR(-EINVAL
);
978 dst
= kmalloc((len
+ 1), GFP_KERNEL
);
980 return ERR_PTR(-ENOMEM
);
982 memcpy(dst
, src
, len
);
988 static int get_option_ul(substring_t args
[], unsigned long *option
)
993 string
= match_strdup(args
);
996 rc
= kstrtoul(string
, 0, option
);
1002 static int get_option_uid(substring_t args
[], kuid_t
*result
)
1004 unsigned long value
;
1008 rc
= get_option_ul(args
, &value
);
1012 uid
= make_kuid(current_user_ns(), value
);
1013 if (!uid_valid(uid
))
1020 static int get_option_gid(substring_t args
[], kgid_t
*result
)
1022 unsigned long value
;
1026 rc
= get_option_ul(args
, &value
);
1030 gid
= make_kgid(current_user_ns(), value
);
1031 if (!gid_valid(gid
))
1038 static int cifs_parse_security_flavors(char *value
,
1039 struct smb_vol
*vol
)
1042 substring_t args
[MAX_OPT_ARGS
];
1045 * With mount options, the last one should win. Reset any existing
1046 * settings back to default.
1048 vol
->sectype
= Unspecified
;
1051 switch (match_token(value
, cifs_secflavor_tokens
, args
)) {
1053 cifs_dbg(VFS
, "sec=krb5p is not supported!\n");
1059 vol
->sectype
= Kerberos
;
1061 case Opt_sec_ntlmsspi
:
1064 case Opt_sec_ntlmssp
:
1065 vol
->sectype
= RawNTLMSSP
;
1071 vol
->sectype
= NTLM
;
1073 case Opt_sec_ntlmv2i
:
1076 case Opt_sec_ntlmv2
:
1077 vol
->sectype
= NTLMv2
;
1079 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1080 case Opt_sec_lanman
:
1081 vol
->sectype
= LANMAN
;
1088 cifs_dbg(VFS
, "bad security option: %s\n", value
);
1096 cifs_parse_cache_flavor(char *value
, struct smb_vol
*vol
)
1098 substring_t args
[MAX_OPT_ARGS
];
1100 switch (match_token(value
, cifs_cacheflavor_tokens
, args
)) {
1101 case Opt_cache_loose
:
1102 vol
->direct_io
= false;
1103 vol
->strict_io
= false;
1105 case Opt_cache_strict
:
1106 vol
->direct_io
= false;
1107 vol
->strict_io
= true;
1109 case Opt_cache_none
:
1110 vol
->direct_io
= true;
1111 vol
->strict_io
= false;
1114 cifs_dbg(VFS
, "bad cache= option: %s\n", value
);
1121 cifs_parse_smb_version(char *value
, struct smb_vol
*vol
)
1123 substring_t args
[MAX_OPT_ARGS
];
1125 switch (match_token(value
, cifs_smb_version_tokens
, args
)) {
1127 vol
->ops
= &smb1_operations
;
1128 vol
->vals
= &smb1_values
;
1131 vol
->ops
= &smb20_operations
;
1132 vol
->vals
= &smb20_values
;
1135 vol
->ops
= &smb21_operations
;
1136 vol
->vals
= &smb21_values
;
1139 vol
->ops
= &smb30_operations
;
1140 vol
->vals
= &smb30_values
;
1143 vol
->ops
= &smb30_operations
; /* currently identical with 3.0 */
1144 vol
->vals
= &smb302_values
;
1146 #ifdef CONFIG_CIFS_SMB311
1148 vol
->ops
= &smb311_operations
;
1149 vol
->vals
= &smb311_values
;
1153 vol
->ops
= &smb30_operations
; /* currently identical with 3.0 */
1154 vol
->vals
= &smb3any_values
;
1157 vol
->ops
= &smb30_operations
; /* currently identical with 3.0 */
1158 vol
->vals
= &smbdefault_values
;
1161 cifs_dbg(VFS
, "Unknown vers= option specified: %s\n", value
);
1168 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1169 * fields with the result. Returns 0 on success and an error otherwise.
1172 cifs_parse_devname(const char *devname
, struct smb_vol
*vol
)
1175 const char *delims
= "/\\";
1178 /* make sure we have a valid UNC double delimiter prefix */
1179 len
= strspn(devname
, delims
);
1183 /* find delimiter between host and sharename */
1184 pos
= strpbrk(devname
+ 2, delims
);
1188 /* skip past delimiter */
1191 /* now go until next delimiter or end of string */
1192 len
= strcspn(pos
, delims
);
1194 /* move "pos" up to delimiter or NULL */
1196 vol
->UNC
= kstrndup(devname
, pos
- devname
, GFP_KERNEL
);
1200 convert_delimiter(vol
->UNC
, '\\');
1202 /* skip any delimiter */
1203 if (*pos
== '/' || *pos
== '\\')
1206 /* If pos is NULL then no prepath */
1210 vol
->prepath
= kstrdup(pos
, GFP_KERNEL
);
1218 cifs_parse_mount_options(const char *mountdata
, const char *devname
,
1219 struct smb_vol
*vol
)
1222 char *mountdata_copy
= NULL
, *options
;
1223 unsigned int temp_len
, i
, j
;
1225 short int override_uid
= -1;
1226 short int override_gid
= -1;
1227 bool uid_specified
= false;
1228 bool gid_specified
= false;
1229 bool sloppy
= false;
1230 char *invalid
= NULL
;
1231 char *nodename
= utsname()->nodename
;
1232 char *string
= NULL
;
1233 char *tmp_end
, *value
;
1235 bool got_ip
= false;
1236 bool got_version
= false;
1237 unsigned short port
= 0;
1238 struct sockaddr
*dstaddr
= (struct sockaddr
*)&vol
->dstaddr
;
1242 delim
= separator
[0];
1244 /* ensure we always start with zeroed-out smb_vol */
1245 memset(vol
, 0, sizeof(*vol
));
1248 * does not have to be perfect mapping since field is
1249 * informational, only used for servers that do not support
1250 * port 445 and it can be overridden at mount time
1252 memset(vol
->source_rfc1001_name
, 0x20, RFC1001_NAME_LEN
);
1253 for (i
= 0; i
< strnlen(nodename
, RFC1001_NAME_LEN
); i
++)
1254 vol
->source_rfc1001_name
[i
] = toupper(nodename
[i
]);
1256 vol
->source_rfc1001_name
[RFC1001_NAME_LEN
] = 0;
1257 /* null target name indicates to use *SMBSERVR default called name
1258 if we end up sending RFC1001 session initialize */
1259 vol
->target_rfc1001_name
[0] = 0;
1260 vol
->cred_uid
= current_uid();
1261 vol
->linux_uid
= current_uid();
1262 vol
->linux_gid
= current_gid();
1265 * default to SFM style remapping of seven reserved characters
1266 * unless user overrides it or we negotiate CIFS POSIX where
1267 * it is unnecessary. Can not simultaneously use more than one mapping
1268 * since then readdir could list files that open could not open
1272 /* default to only allowing write access to owner of the mount */
1273 vol
->dir_mode
= vol
->file_mode
= S_IRUGO
| S_IXUGO
| S_IWUSR
;
1275 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1276 /* default is always to request posix paths. */
1277 vol
->posix_paths
= 1;
1278 /* default to using server inode numbers where available */
1279 vol
->server_ino
= 1;
1281 /* default is to use strict cifs caching semantics */
1282 vol
->strict_io
= true;
1284 vol
->actimeo
= CIFS_DEF_ACTIMEO
;
1286 /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
1287 vol
->ops
= &smb30_operations
;
1288 vol
->vals
= &smbdefault_values
;
1290 vol
->echo_interval
= SMB_ECHO_INTERVAL_DEFAULT
;
1293 goto cifs_parse_mount_err
;
1295 mountdata_copy
= kstrndup(mountdata
, PAGE_SIZE
, GFP_KERNEL
);
1296 if (!mountdata_copy
)
1297 goto cifs_parse_mount_err
;
1299 options
= mountdata_copy
;
1300 end
= options
+ strlen(options
);
1302 if (strncmp(options
, "sep=", 4) == 0) {
1303 if (options
[4] != 0) {
1304 separator
[0] = options
[4];
1307 cifs_dbg(FYI
, "Null separator not allowed\n");
1310 vol
->backupuid_specified
= false; /* no backup intent for a user */
1311 vol
->backupgid_specified
= false; /* no backup intent for a group */
1313 switch (cifs_parse_devname(devname
, vol
)) {
1317 cifs_dbg(VFS
, "Unable to allocate memory for devname.\n");
1318 goto cifs_parse_mount_err
;
1320 cifs_dbg(VFS
, "Malformed UNC in devname.\n");
1321 goto cifs_parse_mount_err
;
1323 cifs_dbg(VFS
, "Unknown error parsing devname.\n");
1324 goto cifs_parse_mount_err
;
1327 while ((data
= strsep(&options
, separator
)) != NULL
) {
1328 substring_t args
[MAX_OPT_ARGS
];
1329 unsigned long option
;
1335 token
= match_token(data
, cifs_mount_option_tokens
, args
);
1339 /* Ingnore the following */
1343 /* Boolean values */
1344 case Opt_user_xattr
:
1347 case Opt_nouser_xattr
:
1353 case Opt_noforceuid
:
1359 case Opt_noforcegid
:
1362 case Opt_noblocksend
:
1363 vol
->noblocksnd
= 1;
1365 case Opt_noautotune
:
1366 vol
->noautotune
= 1;
1381 vol
->sfu_remap
= true;
1382 vol
->remap
= false; /* disable SFM mapping */
1384 case Opt_nomapchars
:
1385 vol
->sfu_remap
= false;
1389 vol
->sfu_remap
= false; /* disable SFU mapping */
1391 case Opt_nomapposix
:
1403 case Opt_posixpaths
:
1404 vol
->posix_paths
= 1;
1406 case Opt_noposixpaths
:
1407 vol
->posix_paths
= 0;
1410 vol
->no_linux_ext
= 1;
1421 * turn off mandatory locking in mode
1422 * if remote locking is turned off since the
1423 * local vfs will do advisory
1425 if (vol
->file_mode
==
1426 (S_IALLUGO
& ~(S_ISUID
| S_IXGRP
)))
1427 vol
->file_mode
= S_IALLUGO
;
1429 case Opt_forcemandatorylock
:
1438 case Opt_setuidfromacl
:
1439 vol
->setuidfromacl
= 1;
1442 vol
->dynperm
= true;
1445 vol
->dynperm
= false;
1459 case Opt_nostrictsync
:
1460 vol
->nostrictsync
= 1;
1462 case Opt_strictsync
:
1463 vol
->nostrictsync
= 0;
1466 vol
->server_ino
= 1;
1468 case Opt_noserverino
:
1469 vol
->server_ino
= 0;
1471 case Opt_rwpidforward
:
1472 vol
->rwpidforward
= 1;
1481 vol
->no_psx_acl
= 0;
1484 vol
->no_psx_acl
= 1;
1486 case Opt_locallease
:
1487 vol
->local_lease
= 1;
1493 /* we do not do the following in secFlags because seal
1494 * is a per tree connection (mount) not a per socket
1495 * or per-smb connection option in the protocol
1496 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1501 pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1504 #ifndef CONFIG_CIFS_FSCACHE
1505 cifs_dbg(VFS
, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1506 goto cifs_parse_mount_err
;
1510 case Opt_mfsymlinks
:
1511 vol
->mfsymlinks
= true;
1514 vol
->multiuser
= true;
1519 case Opt_nosharesock
:
1520 vol
->nosharesock
= true;
1522 case Opt_nopersistent
:
1523 vol
->nopersistent
= true;
1524 if (vol
->persistent
) {
1526 "persistenthandles mount options conflict\n");
1527 goto cifs_parse_mount_err
;
1530 case Opt_persistent
:
1531 vol
->persistent
= true;
1532 if ((vol
->nopersistent
) || (vol
->resilient
)) {
1534 "persistenthandles mount options conflict\n");
1535 goto cifs_parse_mount_err
;
1539 vol
->resilient
= true;
1540 if (vol
->persistent
) {
1542 "persistenthandles mount options conflict\n");
1543 goto cifs_parse_mount_err
;
1546 case Opt_noresilient
:
1547 vol
->resilient
= false; /* already the default */
1549 case Opt_domainauto
:
1550 vol
->domainauto
= true;
1553 /* Numeric Values */
1555 if (get_option_uid(args
, &vol
->backupuid
)) {
1556 cifs_dbg(VFS
, "%s: Invalid backupuid value\n",
1558 goto cifs_parse_mount_err
;
1560 vol
->backupuid_specified
= true;
1563 if (get_option_gid(args
, &vol
->backupgid
)) {
1564 cifs_dbg(VFS
, "%s: Invalid backupgid value\n",
1566 goto cifs_parse_mount_err
;
1568 vol
->backupgid_specified
= true;
1571 if (get_option_uid(args
, &vol
->linux_uid
)) {
1572 cifs_dbg(VFS
, "%s: Invalid uid value\n",
1574 goto cifs_parse_mount_err
;
1576 uid_specified
= true;
1579 if (get_option_uid(args
, &vol
->cred_uid
)) {
1580 cifs_dbg(VFS
, "%s: Invalid cruid value\n",
1582 goto cifs_parse_mount_err
;
1586 if (get_option_gid(args
, &vol
->linux_gid
)) {
1587 cifs_dbg(VFS
, "%s: Invalid gid value\n",
1589 goto cifs_parse_mount_err
;
1591 gid_specified
= true;
1594 if (get_option_ul(args
, &option
)) {
1595 cifs_dbg(VFS
, "%s: Invalid file_mode value\n",
1597 goto cifs_parse_mount_err
;
1599 vol
->file_mode
= option
;
1602 if (get_option_ul(args
, &option
)) {
1603 cifs_dbg(VFS
, "%s: Invalid dir_mode value\n",
1605 goto cifs_parse_mount_err
;
1607 vol
->dir_mode
= option
;
1610 if (get_option_ul(args
, &option
) ||
1611 option
> USHRT_MAX
) {
1612 cifs_dbg(VFS
, "%s: Invalid port value\n",
1614 goto cifs_parse_mount_err
;
1616 port
= (unsigned short)option
;
1619 if (get_option_ul(args
, &option
)) {
1620 cifs_dbg(VFS
, "%s: Invalid rsize value\n",
1622 goto cifs_parse_mount_err
;
1624 vol
->rsize
= option
;
1627 if (get_option_ul(args
, &option
)) {
1628 cifs_dbg(VFS
, "%s: Invalid wsize value\n",
1630 goto cifs_parse_mount_err
;
1632 vol
->wsize
= option
;
1635 if (get_option_ul(args
, &option
)) {
1636 cifs_dbg(VFS
, "%s: Invalid actimeo value\n",
1638 goto cifs_parse_mount_err
;
1640 vol
->actimeo
= HZ
* option
;
1641 if (vol
->actimeo
> CIFS_MAX_ACTIMEO
) {
1642 cifs_dbg(VFS
, "attribute cache timeout too large\n");
1643 goto cifs_parse_mount_err
;
1646 case Opt_echo_interval
:
1647 if (get_option_ul(args
, &option
)) {
1648 cifs_dbg(VFS
, "%s: Invalid echo interval value\n",
1650 goto cifs_parse_mount_err
;
1652 vol
->echo_interval
= option
;
1655 if (get_option_ul(args
, &option
)) {
1656 cifs_dbg(VFS
, "%s: Invalid snapshot time\n",
1658 goto cifs_parse_mount_err
;
1660 vol
->snapshot_time
= option
;
1662 case Opt_max_credits
:
1663 if (get_option_ul(args
, &option
) || (option
< 20) ||
1665 cifs_dbg(VFS
, "%s: Invalid max_credits value\n",
1667 goto cifs_parse_mount_err
;
1669 vol
->max_credits
= option
;
1672 /* String Arguments */
1674 case Opt_blank_user
:
1675 /* null user, ie. anonymous authentication */
1677 vol
->username
= NULL
;
1680 string
= match_strdup(args
);
1684 if (strnlen(string
, CIFS_MAX_USERNAME_LEN
) >
1685 CIFS_MAX_USERNAME_LEN
) {
1686 pr_warn("CIFS: username too long\n");
1687 goto cifs_parse_mount_err
;
1690 kfree(vol
->username
);
1691 vol
->username
= kstrdup(string
, GFP_KERNEL
);
1693 goto cifs_parse_mount_err
;
1695 case Opt_blank_pass
:
1696 /* passwords have to be handled differently
1697 * to allow the character used for deliminator
1698 * to be passed within them
1702 * Check if this is a case where the password
1703 * starts with a delimiter
1705 tmp_end
= strchr(data
, '=');
1707 if (!(tmp_end
< end
&& tmp_end
[1] == delim
)) {
1708 /* No it is not. Set the password to NULL */
1709 kfree(vol
->password
);
1710 vol
->password
= NULL
;
1713 /* Yes it is. Drop down to Opt_pass below.*/
1715 /* Obtain the value string */
1716 value
= strchr(data
, '=');
1719 /* Set tmp_end to end of the string */
1720 tmp_end
= (char *) value
+ strlen(value
);
1722 /* Check if following character is the deliminator
1723 * If yes, we have encountered a double deliminator
1724 * reset the NULL character to the deliminator
1726 if (tmp_end
< end
&& tmp_end
[1] == delim
) {
1729 /* Keep iterating until we get to a single
1730 * deliminator OR the end
1732 while ((tmp_end
= strchr(tmp_end
, delim
))
1733 != NULL
&& (tmp_end
[1] == delim
)) {
1734 tmp_end
= (char *) &tmp_end
[2];
1737 /* Reset var options to point to next element */
1740 options
= (char *) &tmp_end
[1];
1742 /* Reached the end of the mount option
1747 kfree(vol
->password
);
1748 /* Now build new password string */
1749 temp_len
= strlen(value
);
1750 vol
->password
= kzalloc(temp_len
+1, GFP_KERNEL
);
1751 if (vol
->password
== NULL
) {
1752 pr_warn("CIFS: no memory for password\n");
1753 goto cifs_parse_mount_err
;
1756 for (i
= 0, j
= 0; i
< temp_len
; i
++, j
++) {
1757 vol
->password
[j
] = value
[i
];
1758 if ((value
[i
] == delim
) &&
1759 value
[i
+1] == delim
)
1760 /* skip the second deliminator */
1763 vol
->password
[j
] = '\0';
1766 /* FIXME: should this be an error instead? */
1770 string
= match_strdup(args
);
1774 if (!cifs_convert_address(dstaddr
, string
,
1776 pr_err("CIFS: bad ip= option (%s).\n", string
);
1777 goto cifs_parse_mount_err
;
1782 string
= match_strdup(args
);
1786 if (strnlen(string
, CIFS_MAX_DOMAINNAME_LEN
)
1787 == CIFS_MAX_DOMAINNAME_LEN
) {
1788 pr_warn("CIFS: domain name too long\n");
1789 goto cifs_parse_mount_err
;
1792 kfree(vol
->domainname
);
1793 vol
->domainname
= kstrdup(string
, GFP_KERNEL
);
1794 if (!vol
->domainname
) {
1795 pr_warn("CIFS: no memory for domainname\n");
1796 goto cifs_parse_mount_err
;
1798 cifs_dbg(FYI
, "Domain name set\n");
1801 string
= match_strdup(args
);
1805 if (!cifs_convert_address(
1806 (struct sockaddr
*)&vol
->srcaddr
,
1807 string
, strlen(string
))) {
1808 pr_warn("CIFS: Could not parse srcaddr: %s\n",
1810 goto cifs_parse_mount_err
;
1814 string
= match_strdup(args
);
1818 if (strnlen(string
, 1024) >= 65) {
1819 pr_warn("CIFS: iocharset name too long.\n");
1820 goto cifs_parse_mount_err
;
1823 if (strncasecmp(string
, "default", 7) != 0) {
1824 kfree(vol
->iocharset
);
1825 vol
->iocharset
= kstrdup(string
,
1827 if (!vol
->iocharset
) {
1828 pr_warn("CIFS: no memory for charset\n");
1829 goto cifs_parse_mount_err
;
1832 /* if iocharset not set then load_nls_default
1835 cifs_dbg(FYI
, "iocharset set to %s\n", string
);
1837 case Opt_netbiosname
:
1838 string
= match_strdup(args
);
1842 memset(vol
->source_rfc1001_name
, 0x20,
1845 * FIXME: are there cases in which a comma can
1846 * be valid in workstation netbios name (and
1847 * need special handling)?
1849 for (i
= 0; i
< RFC1001_NAME_LEN
; i
++) {
1850 /* don't ucase netbiosname for user */
1853 vol
->source_rfc1001_name
[i
] = string
[i
];
1855 /* The string has 16th byte zero still from
1856 * set at top of the function
1858 if (i
== RFC1001_NAME_LEN
&& string
[i
] != 0)
1859 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
1862 /* servernetbiosname specified override *SMBSERVER */
1863 string
= match_strdup(args
);
1867 /* last byte, type, is 0x20 for servr type */
1868 memset(vol
->target_rfc1001_name
, 0x20,
1869 RFC1001_NAME_LEN_WITH_NULL
);
1871 /* BB are there cases in which a comma can be
1872 valid in this workstation netbios name
1873 (and need special handling)? */
1875 /* user or mount helper must uppercase the
1877 for (i
= 0; i
< 15; i
++) {
1880 vol
->target_rfc1001_name
[i
] = string
[i
];
1882 /* The string has 16th byte zero still from
1883 set at top of the function */
1884 if (i
== RFC1001_NAME_LEN
&& string
[i
] != 0)
1885 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
1888 /* version of mount userspace tools, not dialect */
1889 string
= match_strdup(args
);
1893 /* If interface changes in mount.cifs bump to new ver */
1894 if (strncasecmp(string
, "1", 1) == 0) {
1895 if (strlen(string
) > 1) {
1896 pr_warn("Bad mount helper ver=%s. Did "
1897 "you want SMB1 (CIFS) dialect "
1898 "and mean to type vers=1.0 "
1899 "instead?\n", string
);
1900 goto cifs_parse_mount_err
;
1902 /* This is the default */
1905 /* For all other value, error */
1906 pr_warn("CIFS: Invalid mount helper version specified\n");
1907 goto cifs_parse_mount_err
;
1909 /* protocol version (dialect) */
1910 string
= match_strdup(args
);
1914 if (cifs_parse_smb_version(string
, vol
) != 0)
1915 goto cifs_parse_mount_err
;
1919 string
= match_strdup(args
);
1923 if (cifs_parse_security_flavors(string
, vol
) != 0)
1924 goto cifs_parse_mount_err
;
1927 string
= match_strdup(args
);
1931 if (cifs_parse_cache_flavor(string
, vol
) != 0)
1932 goto cifs_parse_mount_err
;
1936 * An option we don't recognize. Save it off for later
1937 * if we haven't already found one
1943 /* Free up any allocated string */
1948 if (!sloppy
&& invalid
) {
1949 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid
);
1950 goto cifs_parse_mount_err
;
1954 /* Muliuser mounts require CONFIG_KEYS support */
1955 if (vol
->multiuser
) {
1956 cifs_dbg(VFS
, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
1957 goto cifs_parse_mount_err
;
1961 cifs_dbg(VFS
, "CIFS mount error: No usable UNC path provided in device string!\n");
1962 goto cifs_parse_mount_err
;
1965 /* make sure UNC has a share name */
1966 if (!strchr(vol
->UNC
+ 3, '\\')) {
1967 cifs_dbg(VFS
, "Malformed UNC. Unable to find share name.\n");
1968 goto cifs_parse_mount_err
;
1975 /* No ip= option specified? Try to get it from UNC */
1976 /* Use the address part of the UNC. */
1977 slash
= strchr(&vol
->UNC
[2], '\\');
1978 len
= slash
- &vol
->UNC
[2];
1979 if (!cifs_convert_address(dstaddr
, &vol
->UNC
[2], len
)) {
1980 pr_err("Unable to determine destination address.\n");
1981 goto cifs_parse_mount_err
;
1985 /* set the port that we got earlier */
1986 cifs_set_port(dstaddr
, port
);
1989 vol
->override_uid
= override_uid
;
1990 else if (override_uid
== 1)
1991 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
1994 vol
->override_gid
= override_gid
;
1995 else if (override_gid
== 1)
1996 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
1998 if (got_version
== false)
1999 pr_warn("No dialect specified on mount. Default has changed to "
2000 "a more secure dialect, SMB2.1 or later (e.g. SMB3), from CIFS "
2001 "(SMB1). To use the less secure SMB1 dialect to access "
2002 "old servers which do not support SMB3 (or SMB2.1) specify vers=1.0"
2005 kfree(mountdata_copy
);
2009 pr_warn("Could not allocate temporary buffer\n");
2010 cifs_parse_mount_err
:
2012 kfree(mountdata_copy
);
2016 /** Returns true if srcaddr isn't specified and rhs isn't
2017 * specified, or if srcaddr is specified and
2018 * matches the IP address of the rhs argument.
2021 srcip_matches(struct sockaddr
*srcaddr
, struct sockaddr
*rhs
)
2023 switch (srcaddr
->sa_family
) {
2025 return (rhs
->sa_family
== AF_UNSPEC
);
2027 struct sockaddr_in
*saddr4
= (struct sockaddr_in
*)srcaddr
;
2028 struct sockaddr_in
*vaddr4
= (struct sockaddr_in
*)rhs
;
2029 return (saddr4
->sin_addr
.s_addr
== vaddr4
->sin_addr
.s_addr
);
2032 struct sockaddr_in6
*saddr6
= (struct sockaddr_in6
*)srcaddr
;
2033 struct sockaddr_in6
*vaddr6
= (struct sockaddr_in6
*)rhs
;
2034 return ipv6_addr_equal(&saddr6
->sin6_addr
, &vaddr6
->sin6_addr
);
2038 return false; /* don't expect to be here */
2043 * If no port is specified in addr structure, we try to match with 445 port
2044 * and if it fails - with 139 ports. It should be called only if address
2045 * families of server and addr are equal.
2048 match_port(struct TCP_Server_Info
*server
, struct sockaddr
*addr
)
2050 __be16 port
, *sport
;
2052 switch (addr
->sa_family
) {
2054 sport
= &((struct sockaddr_in
*) &server
->dstaddr
)->sin_port
;
2055 port
= ((struct sockaddr_in
*) addr
)->sin_port
;
2058 sport
= &((struct sockaddr_in6
*) &server
->dstaddr
)->sin6_port
;
2059 port
= ((struct sockaddr_in6
*) addr
)->sin6_port
;
2067 port
= htons(CIFS_PORT
);
2071 port
= htons(RFC1001_PORT
);
2074 return port
== *sport
;
2078 match_address(struct TCP_Server_Info
*server
, struct sockaddr
*addr
,
2079 struct sockaddr
*srcaddr
)
2081 switch (addr
->sa_family
) {
2083 struct sockaddr_in
*addr4
= (struct sockaddr_in
*)addr
;
2084 struct sockaddr_in
*srv_addr4
=
2085 (struct sockaddr_in
*)&server
->dstaddr
;
2087 if (addr4
->sin_addr
.s_addr
!= srv_addr4
->sin_addr
.s_addr
)
2092 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)addr
;
2093 struct sockaddr_in6
*srv_addr6
=
2094 (struct sockaddr_in6
*)&server
->dstaddr
;
2096 if (!ipv6_addr_equal(&addr6
->sin6_addr
,
2097 &srv_addr6
->sin6_addr
))
2099 if (addr6
->sin6_scope_id
!= srv_addr6
->sin6_scope_id
)
2105 return false; /* don't expect to be here */
2108 if (!srcip_matches(srcaddr
, (struct sockaddr
*)&server
->srcaddr
))
2115 match_security(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
2118 * The select_sectype function should either return the vol->sectype
2119 * that was specified, or "Unspecified" if that sectype was not
2120 * compatible with the given NEGOTIATE request.
2122 if (server
->ops
->select_sectype(server
, vol
->sectype
)
2127 * Now check if signing mode is acceptable. No need to check
2128 * global_secflags at this point since if MUST_SIGN is set then
2129 * the server->sign had better be too.
2131 if (vol
->sign
&& !server
->sign
)
2137 static int match_server(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
2139 struct sockaddr
*addr
= (struct sockaddr
*)&vol
->dstaddr
;
2141 if (vol
->nosharesock
)
2144 /* BB update this for smb3any and default case */
2145 if ((server
->vals
!= vol
->vals
) || (server
->ops
!= vol
->ops
))
2148 if (!net_eq(cifs_net_ns(server
), current
->nsproxy
->net_ns
))
2151 if (!match_address(server
, addr
,
2152 (struct sockaddr
*)&vol
->srcaddr
))
2155 if (!match_port(server
, addr
))
2158 if (!match_security(server
, vol
))
2161 if (server
->echo_interval
!= vol
->echo_interval
* HZ
)
2167 static struct TCP_Server_Info
*
2168 cifs_find_tcp_session(struct smb_vol
*vol
)
2170 struct TCP_Server_Info
*server
;
2172 spin_lock(&cifs_tcp_ses_lock
);
2173 list_for_each_entry(server
, &cifs_tcp_ses_list
, tcp_ses_list
) {
2174 if (!match_server(server
, vol
))
2177 ++server
->srv_count
;
2178 spin_unlock(&cifs_tcp_ses_lock
);
2179 cifs_dbg(FYI
, "Existing tcp session with server found\n");
2182 spin_unlock(&cifs_tcp_ses_lock
);
2187 cifs_put_tcp_session(struct TCP_Server_Info
*server
, int from_reconnect
)
2189 struct task_struct
*task
;
2191 spin_lock(&cifs_tcp_ses_lock
);
2192 if (--server
->srv_count
> 0) {
2193 spin_unlock(&cifs_tcp_ses_lock
);
2197 put_net(cifs_net_ns(server
));
2199 list_del_init(&server
->tcp_ses_list
);
2200 spin_unlock(&cifs_tcp_ses_lock
);
2202 cancel_delayed_work_sync(&server
->echo
);
2206 * Avoid deadlock here: reconnect work calls
2207 * cifs_put_tcp_session() at its end. Need to be sure
2208 * that reconnect work does nothing with server pointer after
2211 cancel_delayed_work(&server
->reconnect
);
2213 cancel_delayed_work_sync(&server
->reconnect
);
2215 spin_lock(&GlobalMid_Lock
);
2216 server
->tcpStatus
= CifsExiting
;
2217 spin_unlock(&GlobalMid_Lock
);
2219 cifs_crypto_secmech_release(server
);
2220 cifs_fscache_release_client_cookie(server
);
2222 kfree(server
->session_key
.response
);
2223 server
->session_key
.response
= NULL
;
2224 server
->session_key
.len
= 0;
2226 task
= xchg(&server
->tsk
, NULL
);
2228 force_sig(SIGKILL
, task
);
2231 static struct TCP_Server_Info
*
2232 cifs_get_tcp_session(struct smb_vol
*volume_info
)
2234 struct TCP_Server_Info
*tcp_ses
= NULL
;
2237 cifs_dbg(FYI
, "UNC: %s\n", volume_info
->UNC
);
2239 /* see if we already have a matching tcp_ses */
2240 tcp_ses
= cifs_find_tcp_session(volume_info
);
2244 tcp_ses
= kzalloc(sizeof(struct TCP_Server_Info
), GFP_KERNEL
);
2250 tcp_ses
->ops
= volume_info
->ops
;
2251 tcp_ses
->vals
= volume_info
->vals
;
2252 cifs_set_net_ns(tcp_ses
, get_net(current
->nsproxy
->net_ns
));
2253 tcp_ses
->hostname
= extract_hostname(volume_info
->UNC
);
2254 if (IS_ERR(tcp_ses
->hostname
)) {
2255 rc
= PTR_ERR(tcp_ses
->hostname
);
2256 goto out_err_crypto_release
;
2259 tcp_ses
->noblocksnd
= volume_info
->noblocksnd
;
2260 tcp_ses
->noautotune
= volume_info
->noautotune
;
2261 tcp_ses
->tcp_nodelay
= volume_info
->sockopt_tcp_nodelay
;
2262 tcp_ses
->in_flight
= 0;
2263 tcp_ses
->credits
= 1;
2264 init_waitqueue_head(&tcp_ses
->response_q
);
2265 init_waitqueue_head(&tcp_ses
->request_q
);
2266 INIT_LIST_HEAD(&tcp_ses
->pending_mid_q
);
2267 mutex_init(&tcp_ses
->srv_mutex
);
2268 memcpy(tcp_ses
->workstation_RFC1001_name
,
2269 volume_info
->source_rfc1001_name
, RFC1001_NAME_LEN_WITH_NULL
);
2270 memcpy(tcp_ses
->server_RFC1001_name
,
2271 volume_info
->target_rfc1001_name
, RFC1001_NAME_LEN_WITH_NULL
);
2272 tcp_ses
->session_estab
= false;
2273 tcp_ses
->sequence_number
= 0;
2274 tcp_ses
->lstrp
= jiffies
;
2275 spin_lock_init(&tcp_ses
->req_lock
);
2276 INIT_LIST_HEAD(&tcp_ses
->tcp_ses_list
);
2277 INIT_LIST_HEAD(&tcp_ses
->smb_ses_list
);
2278 INIT_DELAYED_WORK(&tcp_ses
->echo
, cifs_echo_request
);
2279 INIT_DELAYED_WORK(&tcp_ses
->reconnect
, smb2_reconnect_server
);
2280 mutex_init(&tcp_ses
->reconnect_mutex
);
2281 memcpy(&tcp_ses
->srcaddr
, &volume_info
->srcaddr
,
2282 sizeof(tcp_ses
->srcaddr
));
2283 memcpy(&tcp_ses
->dstaddr
, &volume_info
->dstaddr
,
2284 sizeof(tcp_ses
->dstaddr
));
2285 generate_random_uuid(tcp_ses
->client_guid
);
2287 * at this point we are the only ones with the pointer
2288 * to the struct since the kernel thread not created yet
2289 * no need to spinlock this init of tcpStatus or srv_count
2291 tcp_ses
->tcpStatus
= CifsNew
;
2292 ++tcp_ses
->srv_count
;
2294 if (volume_info
->echo_interval
>= SMB_ECHO_INTERVAL_MIN
&&
2295 volume_info
->echo_interval
<= SMB_ECHO_INTERVAL_MAX
)
2296 tcp_ses
->echo_interval
= volume_info
->echo_interval
* HZ
;
2298 tcp_ses
->echo_interval
= SMB_ECHO_INTERVAL_DEFAULT
* HZ
;
2300 rc
= ip_connect(tcp_ses
);
2302 cifs_dbg(VFS
, "Error connecting to socket. Aborting operation.\n");
2303 goto out_err_crypto_release
;
2307 * since we're in a cifs function already, we know that
2308 * this will succeed. No need for try_module_get().
2310 __module_get(THIS_MODULE
);
2311 tcp_ses
->tsk
= kthread_run(cifs_demultiplex_thread
,
2313 if (IS_ERR(tcp_ses
->tsk
)) {
2314 rc
= PTR_ERR(tcp_ses
->tsk
);
2315 cifs_dbg(VFS
, "error %d create cifsd thread\n", rc
);
2316 module_put(THIS_MODULE
);
2317 goto out_err_crypto_release
;
2319 tcp_ses
->tcpStatus
= CifsNeedNegotiate
;
2321 /* thread spawned, put it on the list */
2322 spin_lock(&cifs_tcp_ses_lock
);
2323 list_add(&tcp_ses
->tcp_ses_list
, &cifs_tcp_ses_list
);
2324 spin_unlock(&cifs_tcp_ses_lock
);
2326 cifs_fscache_get_client_cookie(tcp_ses
);
2328 /* queue echo request delayed work */
2329 queue_delayed_work(cifsiod_wq
, &tcp_ses
->echo
, tcp_ses
->echo_interval
);
2333 out_err_crypto_release
:
2334 cifs_crypto_secmech_release(tcp_ses
);
2336 put_net(cifs_net_ns(tcp_ses
));
2340 if (!IS_ERR(tcp_ses
->hostname
))
2341 kfree(tcp_ses
->hostname
);
2342 if (tcp_ses
->ssocket
)
2343 sock_release(tcp_ses
->ssocket
);
2349 static int match_session(struct cifs_ses
*ses
, struct smb_vol
*vol
)
2351 if (vol
->sectype
!= Unspecified
&&
2352 vol
->sectype
!= ses
->sectype
)
2355 switch (ses
->sectype
) {
2357 if (!uid_eq(vol
->cred_uid
, ses
->cred_uid
))
2361 /* NULL username means anonymous session */
2362 if (ses
->user_name
== NULL
) {
2368 /* anything else takes username/password */
2369 if (strncmp(ses
->user_name
,
2370 vol
->username
? vol
->username
: "",
2371 CIFS_MAX_USERNAME_LEN
))
2373 if ((vol
->username
&& strlen(vol
->username
) != 0) &&
2374 ses
->password
!= NULL
&&
2375 strncmp(ses
->password
,
2376 vol
->password
? vol
->password
: "",
2377 CIFS_MAX_PASSWORD_LEN
))
2383 static struct cifs_ses
*
2384 cifs_find_smb_ses(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
2386 struct cifs_ses
*ses
;
2388 spin_lock(&cifs_tcp_ses_lock
);
2389 list_for_each_entry(ses
, &server
->smb_ses_list
, smb_ses_list
) {
2390 if (ses
->status
== CifsExiting
)
2392 if (!match_session(ses
, vol
))
2395 spin_unlock(&cifs_tcp_ses_lock
);
2398 spin_unlock(&cifs_tcp_ses_lock
);
2403 cifs_put_smb_ses(struct cifs_ses
*ses
)
2405 unsigned int rc
, xid
;
2406 struct TCP_Server_Info
*server
= ses
->server
;
2408 cifs_dbg(FYI
, "%s: ses_count=%d\n", __func__
, ses
->ses_count
);
2410 spin_lock(&cifs_tcp_ses_lock
);
2411 if (ses
->status
== CifsExiting
) {
2412 spin_unlock(&cifs_tcp_ses_lock
);
2415 if (--ses
->ses_count
> 0) {
2416 spin_unlock(&cifs_tcp_ses_lock
);
2419 if (ses
->status
== CifsGood
)
2420 ses
->status
= CifsExiting
;
2421 spin_unlock(&cifs_tcp_ses_lock
);
2423 if (ses
->status
== CifsExiting
&& server
->ops
->logoff
) {
2425 rc
= server
->ops
->logoff(xid
, ses
);
2427 cifs_dbg(VFS
, "%s: Session Logoff failure rc=%d\n",
2432 spin_lock(&cifs_tcp_ses_lock
);
2433 list_del_init(&ses
->smb_ses_list
);
2434 spin_unlock(&cifs_tcp_ses_lock
);
2437 cifs_put_tcp_session(server
, 0);
2442 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2443 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2445 /* Populate username and pw fields from keyring if possible */
2447 cifs_set_cifscreds(struct smb_vol
*vol
, struct cifs_ses
*ses
)
2450 const char *delim
, *payload
;
2454 struct TCP_Server_Info
*server
= ses
->server
;
2455 struct sockaddr_in
*sa
;
2456 struct sockaddr_in6
*sa6
;
2457 const struct user_key_payload
*upayload
;
2459 desc
= kmalloc(CIFSCREDS_DESC_SIZE
, GFP_KERNEL
);
2463 /* try to find an address key first */
2464 switch (server
->dstaddr
.ss_family
) {
2466 sa
= (struct sockaddr_in
*)&server
->dstaddr
;
2467 sprintf(desc
, "cifs:a:%pI4", &sa
->sin_addr
.s_addr
);
2470 sa6
= (struct sockaddr_in6
*)&server
->dstaddr
;
2471 sprintf(desc
, "cifs:a:%pI6c", &sa6
->sin6_addr
.s6_addr
);
2474 cifs_dbg(FYI
, "Bad ss_family (%hu)\n",
2475 server
->dstaddr
.ss_family
);
2480 cifs_dbg(FYI
, "%s: desc=%s\n", __func__
, desc
);
2481 key
= request_key(&key_type_logon
, desc
, "");
2483 if (!ses
->domainName
) {
2484 cifs_dbg(FYI
, "domainName is NULL\n");
2489 /* didn't work, try to find a domain key */
2490 sprintf(desc
, "cifs:d:%s", ses
->domainName
);
2491 cifs_dbg(FYI
, "%s: desc=%s\n", __func__
, desc
);
2492 key
= request_key(&key_type_logon
, desc
, "");
2499 down_read(&key
->sem
);
2500 upayload
= user_key_payload_locked(key
);
2501 if (IS_ERR_OR_NULL(upayload
)) {
2502 rc
= upayload
? PTR_ERR(upayload
) : -EINVAL
;
2506 /* find first : in payload */
2507 payload
= upayload
->data
;
2508 delim
= strnchr(payload
, upayload
->datalen
, ':');
2509 cifs_dbg(FYI
, "payload=%s\n", payload
);
2511 cifs_dbg(FYI
, "Unable to find ':' in payload (datalen=%d)\n",
2517 len
= delim
- payload
;
2518 if (len
> CIFS_MAX_USERNAME_LEN
|| len
<= 0) {
2519 cifs_dbg(FYI
, "Bad value from username search (len=%zd)\n",
2525 vol
->username
= kstrndup(payload
, len
, GFP_KERNEL
);
2526 if (!vol
->username
) {
2527 cifs_dbg(FYI
, "Unable to allocate %zd bytes for username\n",
2532 cifs_dbg(FYI
, "%s: username=%s\n", __func__
, vol
->username
);
2534 len
= key
->datalen
- (len
+ 1);
2535 if (len
> CIFS_MAX_PASSWORD_LEN
|| len
<= 0) {
2536 cifs_dbg(FYI
, "Bad len for password search (len=%zd)\n", len
);
2538 kfree(vol
->username
);
2539 vol
->username
= NULL
;
2544 vol
->password
= kstrndup(delim
, len
, GFP_KERNEL
);
2545 if (!vol
->password
) {
2546 cifs_dbg(FYI
, "Unable to allocate %zd bytes for password\n",
2549 kfree(vol
->username
);
2550 vol
->username
= NULL
;
2559 cifs_dbg(FYI
, "%s: returning %d\n", __func__
, rc
);
2562 #else /* ! CONFIG_KEYS */
2564 cifs_set_cifscreds(struct smb_vol
*vol
__attribute__((unused
)),
2565 struct cifs_ses
*ses
__attribute__((unused
)))
2569 #endif /* CONFIG_KEYS */
2571 static struct cifs_ses
*
2572 cifs_get_smb_ses(struct TCP_Server_Info
*server
, struct smb_vol
*volume_info
)
2576 struct cifs_ses
*ses
;
2577 struct sockaddr_in
*addr
= (struct sockaddr_in
*)&server
->dstaddr
;
2578 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)&server
->dstaddr
;
2582 ses
= cifs_find_smb_ses(server
, volume_info
);
2584 cifs_dbg(FYI
, "Existing smb sess found (status=%d)\n",
2587 mutex_lock(&ses
->session_mutex
);
2588 rc
= cifs_negotiate_protocol(xid
, ses
);
2590 mutex_unlock(&ses
->session_mutex
);
2591 /* problem -- put our ses reference */
2592 cifs_put_smb_ses(ses
);
2596 if (ses
->need_reconnect
) {
2597 cifs_dbg(FYI
, "Session needs reconnect\n");
2598 rc
= cifs_setup_session(xid
, ses
,
2599 volume_info
->local_nls
);
2601 mutex_unlock(&ses
->session_mutex
);
2602 /* problem -- put our reference */
2603 cifs_put_smb_ses(ses
);
2608 mutex_unlock(&ses
->session_mutex
);
2610 /* existing SMB ses has a server reference already */
2611 cifs_put_tcp_session(server
, 0);
2616 cifs_dbg(FYI
, "Existing smb sess not found\n");
2617 ses
= sesInfoAlloc();
2621 /* new SMB session uses our server ref */
2622 ses
->server
= server
;
2623 if (server
->dstaddr
.ss_family
== AF_INET6
)
2624 sprintf(ses
->serverName
, "%pI6", &addr6
->sin6_addr
);
2626 sprintf(ses
->serverName
, "%pI4", &addr
->sin_addr
);
2628 if (volume_info
->username
) {
2629 ses
->user_name
= kstrdup(volume_info
->username
, GFP_KERNEL
);
2630 if (!ses
->user_name
)
2634 /* volume_info->password freed at unmount */
2635 if (volume_info
->password
) {
2636 ses
->password
= kstrdup(volume_info
->password
, GFP_KERNEL
);
2640 if (volume_info
->domainname
) {
2641 ses
->domainName
= kstrdup(volume_info
->domainname
, GFP_KERNEL
);
2642 if (!ses
->domainName
)
2645 if (volume_info
->domainauto
)
2646 ses
->domainAuto
= volume_info
->domainauto
;
2647 ses
->cred_uid
= volume_info
->cred_uid
;
2648 ses
->linux_uid
= volume_info
->linux_uid
;
2650 ses
->sectype
= volume_info
->sectype
;
2651 ses
->sign
= volume_info
->sign
;
2653 mutex_lock(&ses
->session_mutex
);
2654 rc
= cifs_negotiate_protocol(xid
, ses
);
2656 rc
= cifs_setup_session(xid
, ses
, volume_info
->local_nls
);
2657 mutex_unlock(&ses
->session_mutex
);
2661 /* success, put it on the list */
2662 spin_lock(&cifs_tcp_ses_lock
);
2663 list_add(&ses
->smb_ses_list
, &server
->smb_ses_list
);
2664 spin_unlock(&cifs_tcp_ses_lock
);
2675 static int match_tcon(struct cifs_tcon
*tcon
, struct smb_vol
*volume_info
)
2677 if (tcon
->tidStatus
== CifsExiting
)
2679 if (strncmp(tcon
->treeName
, volume_info
->UNC
, MAX_TREE_SIZE
))
2681 if (tcon
->seal
!= volume_info
->seal
)
2683 if (tcon
->snapshot_time
!= volume_info
->snapshot_time
)
2688 static struct cifs_tcon
*
2689 cifs_find_tcon(struct cifs_ses
*ses
, struct smb_vol
*volume_info
)
2691 struct list_head
*tmp
;
2692 struct cifs_tcon
*tcon
;
2694 spin_lock(&cifs_tcp_ses_lock
);
2695 list_for_each(tmp
, &ses
->tcon_list
) {
2696 tcon
= list_entry(tmp
, struct cifs_tcon
, tcon_list
);
2697 if (!match_tcon(tcon
, volume_info
))
2700 spin_unlock(&cifs_tcp_ses_lock
);
2703 spin_unlock(&cifs_tcp_ses_lock
);
2708 cifs_put_tcon(struct cifs_tcon
*tcon
)
2711 struct cifs_ses
*ses
= tcon
->ses
;
2713 cifs_dbg(FYI
, "%s: tc_count=%d\n", __func__
, tcon
->tc_count
);
2714 spin_lock(&cifs_tcp_ses_lock
);
2715 if (--tcon
->tc_count
> 0) {
2716 spin_unlock(&cifs_tcp_ses_lock
);
2720 list_del_init(&tcon
->tcon_list
);
2721 spin_unlock(&cifs_tcp_ses_lock
);
2724 if (ses
->server
->ops
->tree_disconnect
)
2725 ses
->server
->ops
->tree_disconnect(xid
, tcon
);
2728 cifs_fscache_release_super_cookie(tcon
);
2730 cifs_put_smb_ses(ses
);
2733 static struct cifs_tcon
*
2734 cifs_get_tcon(struct cifs_ses
*ses
, struct smb_vol
*volume_info
)
2737 struct cifs_tcon
*tcon
;
2739 tcon
= cifs_find_tcon(ses
, volume_info
);
2741 cifs_dbg(FYI
, "Found match on UNC path\n");
2742 /* existing tcon already has a reference */
2743 cifs_put_smb_ses(ses
);
2747 if (!ses
->server
->ops
->tree_connect
) {
2752 tcon
= tconInfoAlloc();
2758 if (volume_info
->snapshot_time
) {
2759 if (ses
->server
->vals
->protocol_id
== 0) {
2761 "Use SMB2 or later for snapshot mount option\n");
2765 tcon
->snapshot_time
= volume_info
->snapshot_time
;
2769 if (volume_info
->password
) {
2770 tcon
->password
= kstrdup(volume_info
->password
, GFP_KERNEL
);
2771 if (!tcon
->password
) {
2778 * BB Do we need to wrap session_mutex around this TCon call and Unix
2779 * SetFS as we do on SessSetup and reconnect?
2782 rc
= ses
->server
->ops
->tree_connect(xid
, ses
, volume_info
->UNC
, tcon
,
2783 volume_info
->local_nls
);
2785 cifs_dbg(FYI
, "Tcon rc = %d\n", rc
);
2789 if (volume_info
->nodfs
) {
2790 tcon
->Flags
&= ~SMB_SHARE_IS_IN_DFS
;
2791 cifs_dbg(FYI
, "DFS disabled (%d)\n", tcon
->Flags
);
2793 tcon
->use_persistent
= false;
2794 /* check if SMB2 or later, CIFS does not support persistent handles */
2795 if (volume_info
->persistent
) {
2796 if (ses
->server
->vals
->protocol_id
== 0) {
2798 "SMB3 or later required for persistent handles\n");
2801 } else if (ses
->server
->capabilities
&
2802 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES
)
2803 tcon
->use_persistent
= true;
2804 else /* persistent handles requested but not supported */ {
2806 "Persistent handles not supported on share\n");
2810 } else if ((tcon
->capabilities
& SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY
)
2811 && (ses
->server
->capabilities
& SMB2_GLOBAL_CAP_PERSISTENT_HANDLES
)
2812 && (volume_info
->nopersistent
== false)) {
2813 cifs_dbg(FYI
, "enabling persistent handles\n");
2814 tcon
->use_persistent
= true;
2815 } else if (volume_info
->resilient
) {
2816 if (ses
->server
->vals
->protocol_id
== 0) {
2818 "SMB2.1 or later required for resilient handles\n");
2822 tcon
->use_resilient
= true;
2825 if (volume_info
->seal
) {
2826 if (ses
->server
->vals
->protocol_id
== 0) {
2828 "SMB3 or later required for encryption\n");
2831 } else if (tcon
->ses
->server
->capabilities
&
2832 SMB2_GLOBAL_CAP_ENCRYPTION
)
2835 cifs_dbg(VFS
, "Encryption is not supported on share\n");
2842 * We can have only one retry value for a connection to a share so for
2843 * resources mounted more than once to the same server share the last
2844 * value passed in for the retry flag is used.
2846 tcon
->retry
= volume_info
->retry
;
2847 tcon
->nocase
= volume_info
->nocase
;
2848 tcon
->local_lease
= volume_info
->local_lease
;
2849 INIT_LIST_HEAD(&tcon
->pending_opens
);
2851 spin_lock(&cifs_tcp_ses_lock
);
2852 list_add(&tcon
->tcon_list
, &ses
->tcon_list
);
2853 spin_unlock(&cifs_tcp_ses_lock
);
2855 cifs_fscache_get_super_cookie(tcon
);
2865 cifs_put_tlink(struct tcon_link
*tlink
)
2867 if (!tlink
|| IS_ERR(tlink
))
2870 if (!atomic_dec_and_test(&tlink
->tl_count
) ||
2871 test_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
)) {
2872 tlink
->tl_time
= jiffies
;
2876 if (!IS_ERR(tlink_tcon(tlink
)))
2877 cifs_put_tcon(tlink_tcon(tlink
));
2882 static inline struct tcon_link
*
2883 cifs_sb_master_tlink(struct cifs_sb_info
*cifs_sb
)
2885 return cifs_sb
->master_tlink
;
2889 compare_mount_options(struct super_block
*sb
, struct cifs_mnt_data
*mnt_data
)
2891 struct cifs_sb_info
*old
= CIFS_SB(sb
);
2892 struct cifs_sb_info
*new = mnt_data
->cifs_sb
;
2894 if ((sb
->s_flags
& CIFS_MS_MASK
) != (mnt_data
->flags
& CIFS_MS_MASK
))
2897 if ((old
->mnt_cifs_flags
& CIFS_MOUNT_MASK
) !=
2898 (new->mnt_cifs_flags
& CIFS_MOUNT_MASK
))
2902 * We want to share sb only if we don't specify an r/wsize or
2903 * specified r/wsize is greater than or equal to existing one.
2905 if (new->wsize
&& new->wsize
< old
->wsize
)
2908 if (new->rsize
&& new->rsize
< old
->rsize
)
2911 if (!uid_eq(old
->mnt_uid
, new->mnt_uid
) || !gid_eq(old
->mnt_gid
, new->mnt_gid
))
2914 if (old
->mnt_file_mode
!= new->mnt_file_mode
||
2915 old
->mnt_dir_mode
!= new->mnt_dir_mode
)
2918 if (strcmp(old
->local_nls
->charset
, new->local_nls
->charset
))
2921 if (old
->actimeo
!= new->actimeo
)
2928 match_prepath(struct super_block
*sb
, struct cifs_mnt_data
*mnt_data
)
2930 struct cifs_sb_info
*old
= CIFS_SB(sb
);
2931 struct cifs_sb_info
*new = mnt_data
->cifs_sb
;
2932 bool old_set
= old
->mnt_cifs_flags
& CIFS_MOUNT_USE_PREFIX_PATH
;
2933 bool new_set
= new->mnt_cifs_flags
& CIFS_MOUNT_USE_PREFIX_PATH
;
2935 if (old_set
&& new_set
&& !strcmp(new->prepath
, old
->prepath
))
2937 else if (!old_set
&& !new_set
)
2944 cifs_match_super(struct super_block
*sb
, void *data
)
2946 struct cifs_mnt_data
*mnt_data
= (struct cifs_mnt_data
*)data
;
2947 struct smb_vol
*volume_info
;
2948 struct cifs_sb_info
*cifs_sb
;
2949 struct TCP_Server_Info
*tcp_srv
;
2950 struct cifs_ses
*ses
;
2951 struct cifs_tcon
*tcon
;
2952 struct tcon_link
*tlink
;
2955 spin_lock(&cifs_tcp_ses_lock
);
2956 cifs_sb
= CIFS_SB(sb
);
2957 tlink
= cifs_get_tlink(cifs_sb_master_tlink(cifs_sb
));
2958 if (IS_ERR(tlink
)) {
2959 spin_unlock(&cifs_tcp_ses_lock
);
2962 tcon
= tlink_tcon(tlink
);
2964 tcp_srv
= ses
->server
;
2966 volume_info
= mnt_data
->vol
;
2968 if (!match_server(tcp_srv
, volume_info
) ||
2969 !match_session(ses
, volume_info
) ||
2970 !match_tcon(tcon
, volume_info
) ||
2971 !match_prepath(sb
, mnt_data
)) {
2976 rc
= compare_mount_options(sb
, mnt_data
);
2978 spin_unlock(&cifs_tcp_ses_lock
);
2979 cifs_put_tlink(tlink
);
2984 get_dfs_path(const unsigned int xid
, struct cifs_ses
*ses
, const char *old_path
,
2985 const struct nls_table
*nls_codepage
, unsigned int *num_referrals
,
2986 struct dfs_info3_param
**referrals
, int remap
)
2991 if (!ses
->server
->ops
->tree_connect
|| !ses
->server
->ops
->get_dfs_refer
)
2997 if (ses
->ipc_tid
== 0) {
2998 temp_unc
= kmalloc(2 /* for slashes */ +
2999 strnlen(ses
->serverName
, SERVER_NAME_LEN_WITH_NULL
* 2)
3000 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL
);
3001 if (temp_unc
== NULL
)
3005 strcpy(temp_unc
+ 2, ses
->serverName
);
3006 strcpy(temp_unc
+ 2 + strlen(ses
->serverName
), "\\IPC$");
3007 rc
= ses
->server
->ops
->tree_connect(xid
, ses
, temp_unc
, NULL
,
3009 cifs_dbg(FYI
, "Tcon rc = %d ipc_tid = %d\n", rc
, ses
->ipc_tid
);
3013 rc
= ses
->server
->ops
->get_dfs_refer(xid
, ses
, old_path
,
3014 referrals
, num_referrals
,
3015 nls_codepage
, remap
);
3017 * BB - map targetUNCs to dfs_info3 structures, here or in
3018 * ses->server->ops->get_dfs_refer.
3024 #ifdef CONFIG_DEBUG_LOCK_ALLOC
3025 static struct lock_class_key cifs_key
[2];
3026 static struct lock_class_key cifs_slock_key
[2];
3029 cifs_reclassify_socket4(struct socket
*sock
)
3031 struct sock
*sk
= sock
->sk
;
3032 BUG_ON(!sock_allow_reclassification(sk
));
3033 sock_lock_init_class_and_name(sk
, "slock-AF_INET-CIFS",
3034 &cifs_slock_key
[0], "sk_lock-AF_INET-CIFS", &cifs_key
[0]);
3038 cifs_reclassify_socket6(struct socket
*sock
)
3040 struct sock
*sk
= sock
->sk
;
3041 BUG_ON(!sock_allow_reclassification(sk
));
3042 sock_lock_init_class_and_name(sk
, "slock-AF_INET6-CIFS",
3043 &cifs_slock_key
[1], "sk_lock-AF_INET6-CIFS", &cifs_key
[1]);
3047 cifs_reclassify_socket4(struct socket
*sock
)
3052 cifs_reclassify_socket6(struct socket
*sock
)
3057 /* See RFC1001 section 14 on representation of Netbios names */
3058 static void rfc1002mangle(char *target
, char *source
, unsigned int length
)
3062 for (i
= 0, j
= 0; i
< (length
); i
++) {
3063 /* mask a nibble at a time and encode */
3064 target
[j
] = 'A' + (0x0F & (source
[i
] >> 4));
3065 target
[j
+1] = 'A' + (0x0F & source
[i
]);
3072 bind_socket(struct TCP_Server_Info
*server
)
3075 if (server
->srcaddr
.ss_family
!= AF_UNSPEC
) {
3076 /* Bind to the specified local IP address */
3077 struct socket
*socket
= server
->ssocket
;
3078 rc
= socket
->ops
->bind(socket
,
3079 (struct sockaddr
*) &server
->srcaddr
,
3080 sizeof(server
->srcaddr
));
3082 struct sockaddr_in
*saddr4
;
3083 struct sockaddr_in6
*saddr6
;
3084 saddr4
= (struct sockaddr_in
*)&server
->srcaddr
;
3085 saddr6
= (struct sockaddr_in6
*)&server
->srcaddr
;
3086 if (saddr6
->sin6_family
== AF_INET6
)
3087 cifs_dbg(VFS
, "Failed to bind to: %pI6c, error: %d\n",
3088 &saddr6
->sin6_addr
, rc
);
3090 cifs_dbg(VFS
, "Failed to bind to: %pI4, error: %d\n",
3091 &saddr4
->sin_addr
.s_addr
, rc
);
3098 ip_rfc1001_connect(struct TCP_Server_Info
*server
)
3102 * some servers require RFC1001 sessinit before sending
3103 * negprot - BB check reconnection in case where second
3104 * sessinit is sent but no second negprot
3106 struct rfc1002_session_packet
*ses_init_buf
;
3107 struct smb_hdr
*smb_buf
;
3108 ses_init_buf
= kzalloc(sizeof(struct rfc1002_session_packet
),
3111 ses_init_buf
->trailer
.session_req
.called_len
= 32;
3113 if (server
->server_RFC1001_name
[0] != 0)
3114 rfc1002mangle(ses_init_buf
->trailer
.
3115 session_req
.called_name
,
3116 server
->server_RFC1001_name
,
3117 RFC1001_NAME_LEN_WITH_NULL
);
3119 rfc1002mangle(ses_init_buf
->trailer
.
3120 session_req
.called_name
,
3121 DEFAULT_CIFS_CALLED_NAME
,
3122 RFC1001_NAME_LEN_WITH_NULL
);
3124 ses_init_buf
->trailer
.session_req
.calling_len
= 32;
3127 * calling name ends in null (byte 16) from old smb
3130 if (server
->workstation_RFC1001_name
[0] != 0)
3131 rfc1002mangle(ses_init_buf
->trailer
.
3132 session_req
.calling_name
,
3133 server
->workstation_RFC1001_name
,
3134 RFC1001_NAME_LEN_WITH_NULL
);
3136 rfc1002mangle(ses_init_buf
->trailer
.
3137 session_req
.calling_name
,
3139 RFC1001_NAME_LEN_WITH_NULL
);
3141 ses_init_buf
->trailer
.session_req
.scope1
= 0;
3142 ses_init_buf
->trailer
.session_req
.scope2
= 0;
3143 smb_buf
= (struct smb_hdr
*)ses_init_buf
;
3145 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3146 smb_buf
->smb_buf_length
= cpu_to_be32(0x81000044);
3147 rc
= smb_send(server
, smb_buf
, 0x44);
3148 kfree(ses_init_buf
);
3150 * RFC1001 layer in at least one server
3151 * requires very short break before negprot
3152 * presumably because not expecting negprot
3153 * to follow so fast. This is a simple
3154 * solution that works without
3155 * complicating the code and causes no
3156 * significant slowing down on mount
3159 usleep_range(1000, 2000);
3162 * else the negprot may still work without this
3163 * even though malloc failed
3170 generic_ip_connect(struct TCP_Server_Info
*server
)
3175 struct socket
*socket
= server
->ssocket
;
3176 struct sockaddr
*saddr
;
3178 saddr
= (struct sockaddr
*) &server
->dstaddr
;
3180 if (server
->dstaddr
.ss_family
== AF_INET6
) {
3181 sport
= ((struct sockaddr_in6
*) saddr
)->sin6_port
;
3182 slen
= sizeof(struct sockaddr_in6
);
3185 sport
= ((struct sockaddr_in
*) saddr
)->sin_port
;
3186 slen
= sizeof(struct sockaddr_in
);
3190 if (socket
== NULL
) {
3191 rc
= __sock_create(cifs_net_ns(server
), sfamily
, SOCK_STREAM
,
3192 IPPROTO_TCP
, &socket
, 1);
3194 cifs_dbg(VFS
, "Error %d creating socket\n", rc
);
3195 server
->ssocket
= NULL
;
3199 /* BB other socket options to set KEEPALIVE, NODELAY? */
3200 cifs_dbg(FYI
, "Socket created\n");
3201 server
->ssocket
= socket
;
3202 socket
->sk
->sk_allocation
= GFP_NOFS
;
3203 if (sfamily
== AF_INET6
)
3204 cifs_reclassify_socket6(socket
);
3206 cifs_reclassify_socket4(socket
);
3209 rc
= bind_socket(server
);
3214 * Eventually check for other socket options to change from
3215 * the default. sock_setsockopt not used because it expects
3218 socket
->sk
->sk_rcvtimeo
= 7 * HZ
;
3219 socket
->sk
->sk_sndtimeo
= 5 * HZ
;
3221 /* make the bufsizes depend on wsize/rsize and max requests */
3222 if (server
->noautotune
) {
3223 if (socket
->sk
->sk_sndbuf
< (200 * 1024))
3224 socket
->sk
->sk_sndbuf
= 200 * 1024;
3225 if (socket
->sk
->sk_rcvbuf
< (140 * 1024))
3226 socket
->sk
->sk_rcvbuf
= 140 * 1024;
3229 if (server
->tcp_nodelay
) {
3231 rc
= kernel_setsockopt(socket
, SOL_TCP
, TCP_NODELAY
,
3232 (char *)&val
, sizeof(val
));
3234 cifs_dbg(FYI
, "set TCP_NODELAY socket option error %d\n",
3238 cifs_dbg(FYI
, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3239 socket
->sk
->sk_sndbuf
,
3240 socket
->sk
->sk_rcvbuf
, socket
->sk
->sk_rcvtimeo
);
3242 rc
= socket
->ops
->connect(socket
, saddr
, slen
, 0);
3244 cifs_dbg(FYI
, "Error %d connecting to server\n", rc
);
3245 sock_release(socket
);
3246 server
->ssocket
= NULL
;
3250 if (sport
== htons(RFC1001_PORT
))
3251 rc
= ip_rfc1001_connect(server
);
3257 ip_connect(struct TCP_Server_Info
*server
)
3260 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)&server
->dstaddr
;
3261 struct sockaddr_in
*addr
= (struct sockaddr_in
*)&server
->dstaddr
;
3263 if (server
->dstaddr
.ss_family
== AF_INET6
)
3264 sport
= &addr6
->sin6_port
;
3266 sport
= &addr
->sin_port
;
3271 /* try with 445 port at first */
3272 *sport
= htons(CIFS_PORT
);
3274 rc
= generic_ip_connect(server
);
3278 /* if it failed, try with 139 port */
3279 *sport
= htons(RFC1001_PORT
);
3282 return generic_ip_connect(server
);
3285 void reset_cifs_unix_caps(unsigned int xid
, struct cifs_tcon
*tcon
,
3286 struct cifs_sb_info
*cifs_sb
, struct smb_vol
*vol_info
)
3288 /* if we are reconnecting then should we check to see if
3289 * any requested capabilities changed locally e.g. via
3290 * remount but we can not do much about it here
3291 * if they have (even if we could detect it by the following)
3292 * Perhaps we could add a backpointer to array of sb from tcon
3293 * or if we change to make all sb to same share the same
3294 * sb as NFS - then we only have one backpointer to sb.
3295 * What if we wanted to mount the server share twice once with
3296 * and once without posixacls or posix paths? */
3297 __u64 saved_cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
3299 if (vol_info
&& vol_info
->no_linux_ext
) {
3300 tcon
->fsUnixInfo
.Capability
= 0;
3301 tcon
->unix_ext
= 0; /* Unix Extensions disabled */
3302 cifs_dbg(FYI
, "Linux protocol extensions disabled\n");
3304 } else if (vol_info
)
3305 tcon
->unix_ext
= 1; /* Unix Extensions supported */
3307 if (tcon
->unix_ext
== 0) {
3308 cifs_dbg(FYI
, "Unix extensions disabled so not set on reconnect\n");
3312 if (!CIFSSMBQFSUnixInfo(xid
, tcon
)) {
3313 __u64 cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
3314 cifs_dbg(FYI
, "unix caps which server supports %lld\n", cap
);
3315 /* check for reconnect case in which we do not
3316 want to change the mount behavior if we can avoid it */
3317 if (vol_info
== NULL
) {
3318 /* turn off POSIX ACL and PATHNAMES if not set
3319 originally at mount time */
3320 if ((saved_cap
& CIFS_UNIX_POSIX_ACL_CAP
) == 0)
3321 cap
&= ~CIFS_UNIX_POSIX_ACL_CAP
;
3322 if ((saved_cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) == 0) {
3323 if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)
3324 cifs_dbg(VFS
, "POSIXPATH support change\n");
3325 cap
&= ~CIFS_UNIX_POSIX_PATHNAMES_CAP
;
3326 } else if ((cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) == 0) {
3327 cifs_dbg(VFS
, "possible reconnect error\n");
3328 cifs_dbg(VFS
, "server disabled POSIX path support\n");
3332 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)
3333 cifs_dbg(VFS
, "per-share encryption not supported yet\n");
3335 cap
&= CIFS_UNIX_CAP_MASK
;
3336 if (vol_info
&& vol_info
->no_psx_acl
)
3337 cap
&= ~CIFS_UNIX_POSIX_ACL_CAP
;
3338 else if (CIFS_UNIX_POSIX_ACL_CAP
& cap
) {
3339 cifs_dbg(FYI
, "negotiated posix acl support\n");
3341 cifs_sb
->mnt_cifs_flags
|=
3342 CIFS_MOUNT_POSIXACL
;
3345 if (vol_info
&& vol_info
->posix_paths
== 0)
3346 cap
&= ~CIFS_UNIX_POSIX_PATHNAMES_CAP
;
3347 else if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) {
3348 cifs_dbg(FYI
, "negotiate posix pathnames\n");
3350 cifs_sb
->mnt_cifs_flags
|=
3351 CIFS_MOUNT_POSIX_PATHS
;
3354 cifs_dbg(FYI
, "Negotiate caps 0x%x\n", (int)cap
);
3355 #ifdef CONFIG_CIFS_DEBUG2
3356 if (cap
& CIFS_UNIX_FCNTL_CAP
)
3357 cifs_dbg(FYI
, "FCNTL cap\n");
3358 if (cap
& CIFS_UNIX_EXTATTR_CAP
)
3359 cifs_dbg(FYI
, "EXTATTR cap\n");
3360 if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)
3361 cifs_dbg(FYI
, "POSIX path cap\n");
3362 if (cap
& CIFS_UNIX_XATTR_CAP
)
3363 cifs_dbg(FYI
, "XATTR cap\n");
3364 if (cap
& CIFS_UNIX_POSIX_ACL_CAP
)
3365 cifs_dbg(FYI
, "POSIX ACL cap\n");
3366 if (cap
& CIFS_UNIX_LARGE_READ_CAP
)
3367 cifs_dbg(FYI
, "very large read cap\n");
3368 if (cap
& CIFS_UNIX_LARGE_WRITE_CAP
)
3369 cifs_dbg(FYI
, "very large write cap\n");
3370 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP
)
3371 cifs_dbg(FYI
, "transport encryption cap\n");
3372 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)
3373 cifs_dbg(FYI
, "mandatory transport encryption cap\n");
3374 #endif /* CIFS_DEBUG2 */
3375 if (CIFSSMBSetFSUnixInfo(xid
, tcon
, cap
)) {
3376 if (vol_info
== NULL
) {
3377 cifs_dbg(FYI
, "resetting capabilities failed\n");
3379 cifs_dbg(VFS
, "Negotiating Unix capabilities with the server failed. Consider mounting with the Unix Extensions disabled if problems are found by specifying the nounix mount option.\n");
3385 int cifs_setup_cifs_sb(struct smb_vol
*pvolume_info
,
3386 struct cifs_sb_info
*cifs_sb
)
3388 INIT_DELAYED_WORK(&cifs_sb
->prune_tlinks
, cifs_prune_tlinks
);
3390 spin_lock_init(&cifs_sb
->tlink_tree_lock
);
3391 cifs_sb
->tlink_tree
= RB_ROOT
;
3394 * Temporarily set r/wsize for matching superblock. If we end up using
3395 * new sb then client will later negotiate it downward if needed.
3397 cifs_sb
->rsize
= pvolume_info
->rsize
;
3398 cifs_sb
->wsize
= pvolume_info
->wsize
;
3400 cifs_sb
->mnt_uid
= pvolume_info
->linux_uid
;
3401 cifs_sb
->mnt_gid
= pvolume_info
->linux_gid
;
3402 cifs_sb
->mnt_file_mode
= pvolume_info
->file_mode
;
3403 cifs_sb
->mnt_dir_mode
= pvolume_info
->dir_mode
;
3404 cifs_dbg(FYI
, "file mode: 0x%hx dir mode: 0x%hx\n",
3405 cifs_sb
->mnt_file_mode
, cifs_sb
->mnt_dir_mode
);
3407 cifs_sb
->actimeo
= pvolume_info
->actimeo
;
3408 cifs_sb
->local_nls
= pvolume_info
->local_nls
;
3410 if (pvolume_info
->noperm
)
3411 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_PERM
;
3412 if (pvolume_info
->setuids
)
3413 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_SET_UID
;
3414 if (pvolume_info
->setuidfromacl
)
3415 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_UID_FROM_ACL
;
3416 if (pvolume_info
->server_ino
)
3417 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_SERVER_INUM
;
3418 if (pvolume_info
->remap
)
3419 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MAP_SFM_CHR
;
3420 if (pvolume_info
->sfu_remap
)
3421 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MAP_SPECIAL_CHR
;
3422 if (pvolume_info
->no_xattr
)
3423 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_XATTR
;
3424 if (pvolume_info
->sfu_emul
)
3425 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_UNX_EMUL
;
3426 if (pvolume_info
->nobrl
)
3427 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_BRL
;
3428 if (pvolume_info
->nostrictsync
)
3429 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NOSSYNC
;
3430 if (pvolume_info
->mand_lock
)
3431 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NOPOSIXBRL
;
3432 if (pvolume_info
->rwpidforward
)
3433 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_RWPIDFORWARD
;
3434 if (pvolume_info
->cifs_acl
)
3435 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_ACL
;
3436 if (pvolume_info
->backupuid_specified
) {
3437 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_BACKUPUID
;
3438 cifs_sb
->mnt_backupuid
= pvolume_info
->backupuid
;
3440 if (pvolume_info
->backupgid_specified
) {
3441 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_BACKUPGID
;
3442 cifs_sb
->mnt_backupgid
= pvolume_info
->backupgid
;
3444 if (pvolume_info
->override_uid
)
3445 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_OVERR_UID
;
3446 if (pvolume_info
->override_gid
)
3447 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_OVERR_GID
;
3448 if (pvolume_info
->dynperm
)
3449 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_DYNPERM
;
3450 if (pvolume_info
->fsc
)
3451 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_FSCACHE
;
3452 if (pvolume_info
->multiuser
)
3453 cifs_sb
->mnt_cifs_flags
|= (CIFS_MOUNT_MULTIUSER
|
3454 CIFS_MOUNT_NO_PERM
);
3455 if (pvolume_info
->strict_io
)
3456 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_STRICT_IO
;
3457 if (pvolume_info
->direct_io
) {
3458 cifs_dbg(FYI
, "mounting share using direct i/o\n");
3459 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_DIRECT_IO
;
3461 if (pvolume_info
->mfsymlinks
) {
3462 if (pvolume_info
->sfu_emul
) {
3464 * Our SFU ("Services for Unix" emulation does not allow
3465 * creating symlinks but does allow reading existing SFU
3466 * symlinks (it does allow both creating and reading SFU
3467 * style mknod and FIFOs though). When "mfsymlinks" and
3468 * "sfu" are both enabled at the same time, it allows
3469 * reading both types of symlinks, but will only create
3470 * them with mfsymlinks format. This allows better
3471 * Apple compatibility (probably better for Samba too)
3472 * while still recognizing old Windows style symlinks.
3474 cifs_dbg(VFS
, "mount options mfsymlinks and sfu both enabled\n");
3476 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MF_SYMLINKS
;
3479 if ((pvolume_info
->cifs_acl
) && (pvolume_info
->dynperm
))
3480 cifs_dbg(VFS
, "mount option dynperm ignored if cifsacl mount option supported\n");
3482 if (pvolume_info
->prepath
) {
3483 cifs_sb
->prepath
= kstrdup(pvolume_info
->prepath
, GFP_KERNEL
);
3484 if (cifs_sb
->prepath
== NULL
)
3492 cleanup_volume_info_contents(struct smb_vol
*volume_info
)
3494 kfree(volume_info
->username
);
3495 kzfree(volume_info
->password
);
3496 kfree(volume_info
->UNC
);
3497 kfree(volume_info
->domainname
);
3498 kfree(volume_info
->iocharset
);
3499 kfree(volume_info
->prepath
);
3503 cifs_cleanup_volume_info(struct smb_vol
*volume_info
)
3507 cleanup_volume_info_contents(volume_info
);
3512 #ifdef CONFIG_CIFS_DFS_UPCALL
3514 * cifs_build_path_to_root returns full path to root when we do not have an
3515 * exiting connection (tcon)
3518 build_unc_path_to_root(const struct smb_vol
*vol
,
3519 const struct cifs_sb_info
*cifs_sb
)
3521 char *full_path
, *pos
;
3522 unsigned int pplen
= vol
->prepath
? strlen(vol
->prepath
) + 1 : 0;
3523 unsigned int unc_len
= strnlen(vol
->UNC
, MAX_TREE_SIZE
+ 1);
3525 full_path
= kmalloc(unc_len
+ pplen
+ 1, GFP_KERNEL
);
3526 if (full_path
== NULL
)
3527 return ERR_PTR(-ENOMEM
);
3529 strncpy(full_path
, vol
->UNC
, unc_len
);
3530 pos
= full_path
+ unc_len
;
3533 *pos
= CIFS_DIR_SEP(cifs_sb
);
3534 strncpy(pos
+ 1, vol
->prepath
, pplen
);
3538 *pos
= '\0'; /* add trailing null */
3539 convert_delimiter(full_path
, CIFS_DIR_SEP(cifs_sb
));
3540 cifs_dbg(FYI
, "%s: full_path=%s\n", __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(const unsigned int xid
, struct cifs_ses
*ses
,
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
, ses
, ref_path
, cifs_sb
->local_nls
,
3572 &num_referrals
, &referrals
, cifs_remap(cifs_sb
));
3574 if (!rc
&& num_referrals
> 0) {
3575 char *fake_devname
= NULL
;
3577 mdata
= cifs_compose_mount_options(cifs_sb
->mountdata
,
3578 full_path
+ 1, referrals
,
3581 free_dfs_info_array(referrals
, num_referrals
);
3583 if (IS_ERR(mdata
)) {
3584 rc
= PTR_ERR(mdata
);
3587 cleanup_volume_info_contents(volume_info
);
3588 rc
= cifs_setup_volume_info(volume_info
, mdata
,
3591 kfree(fake_devname
);
3592 kfree(cifs_sb
->mountdata
);
3593 cifs_sb
->mountdata
= mdata
;
3601 cifs_setup_volume_info(struct smb_vol
*volume_info
, char *mount_data
,
3602 const char *devname
)
3606 if (cifs_parse_mount_options(mount_data
, devname
, volume_info
))
3609 if (volume_info
->nullauth
) {
3610 cifs_dbg(FYI
, "Anonymous login\n");
3611 kfree(volume_info
->username
);
3612 volume_info
->username
= NULL
;
3613 } else if (volume_info
->username
) {
3614 /* BB fixme parse for domain name here */
3615 cifs_dbg(FYI
, "Username: %s\n", volume_info
->username
);
3617 cifs_dbg(VFS
, "No username specified\n");
3618 /* In userspace mount helper we can get user name from alternate
3619 locations such as env variables and files on disk */
3623 /* this is needed for ASCII cp to Unicode converts */
3624 if (volume_info
->iocharset
== NULL
) {
3625 /* load_nls_default cannot return null */
3626 volume_info
->local_nls
= load_nls_default();
3628 volume_info
->local_nls
= load_nls(volume_info
->iocharset
);
3629 if (volume_info
->local_nls
== NULL
) {
3630 cifs_dbg(VFS
, "CIFS mount error: iocharset %s not found\n",
3631 volume_info
->iocharset
);
3640 cifs_get_volume_info(char *mount_data
, const char *devname
)
3643 struct smb_vol
*volume_info
;
3645 volume_info
= kmalloc(sizeof(struct smb_vol
), GFP_KERNEL
);
3647 return ERR_PTR(-ENOMEM
);
3649 rc
= cifs_setup_volume_info(volume_info
, mount_data
, devname
);
3651 cifs_cleanup_volume_info(volume_info
);
3652 volume_info
= ERR_PTR(rc
);
3659 cifs_are_all_path_components_accessible(struct TCP_Server_Info
*server
,
3661 struct cifs_tcon
*tcon
,
3662 struct cifs_sb_info
*cifs_sb
,
3669 sep
= CIFS_DIR_SEP(cifs_sb
);
3672 rc
= server
->ops
->is_path_accessible(xid
, tcon
, cifs_sb
, "");
3674 /* skip separators */
3679 /* next separator */
3680 while (*s
&& *s
!= sep
)
3684 * temporarily null-terminate the path at the end of
3685 * the current component
3689 rc
= server
->ops
->is_path_accessible(xid
, tcon
, cifs_sb
,
3697 cifs_mount(struct cifs_sb_info
*cifs_sb
, struct smb_vol
*volume_info
)
3701 struct cifs_ses
*ses
;
3702 struct cifs_tcon
*tcon
;
3703 struct TCP_Server_Info
*server
;
3705 struct tcon_link
*tlink
;
3706 #ifdef CONFIG_CIFS_DFS_UPCALL
3707 int referral_walks_count
= 0;
3710 #ifdef CONFIG_CIFS_DFS_UPCALL
3712 /* cleanup activities if we're chasing a referral */
3713 if (referral_walks_count
) {
3715 cifs_put_tcon(tcon
);
3717 cifs_put_smb_ses(ses
);
3719 cifs_sb
->mnt_cifs_flags
&= ~CIFS_MOUNT_POSIX_PATHS
;
3733 /* get a reference to a tcp session */
3734 server
= cifs_get_tcp_session(volume_info
);
3735 if (IS_ERR(server
)) {
3736 rc
= PTR_ERR(server
);
3739 if ((volume_info
->max_credits
< 20) ||
3740 (volume_info
->max_credits
> 60000))
3741 server
->max_credits
= SMB2_MAX_CREDITS_AVAILABLE
;
3743 server
->max_credits
= volume_info
->max_credits
;
3744 /* get a reference to a SMB session */
3745 ses
= cifs_get_smb_ses(server
, volume_info
);
3749 goto mount_fail_check
;
3752 if ((volume_info
->persistent
== true) && ((ses
->server
->capabilities
&
3753 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES
) == 0)) {
3754 cifs_dbg(VFS
, "persistent handles not supported by server\n");
3756 goto mount_fail_check
;
3759 /* search for existing tcon to this server share */
3760 tcon
= cifs_get_tcon(ses
, volume_info
);
3765 goto mount_fail_check
;
3767 goto remote_path_check
;
3770 /* tell server which Unix caps we support */
3771 if (cap_unix(tcon
->ses
)) {
3772 /* reset of caps checks mount to see if unix extensions
3773 disabled for just this mount */
3774 reset_cifs_unix_caps(xid
, tcon
, cifs_sb
, volume_info
);
3775 if ((tcon
->ses
->server
->tcpStatus
== CifsNeedReconnect
) &&
3776 (le64_to_cpu(tcon
->fsUnixInfo
.Capability
) &
3777 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)) {
3779 goto mount_fail_check
;
3782 tcon
->unix_ext
= 0; /* server does not support them */
3784 /* do not care if a following call succeed - informational */
3785 if (!tcon
->ipc
&& server
->ops
->qfs_tcon
)
3786 server
->ops
->qfs_tcon(xid
, tcon
);
3788 cifs_sb
->wsize
= server
->ops
->negotiate_wsize(tcon
, volume_info
);
3789 cifs_sb
->rsize
= server
->ops
->negotiate_rsize(tcon
, volume_info
);
3792 #ifdef CONFIG_CIFS_DFS_UPCALL
3794 * Perform an unconditional check for whether there are DFS
3795 * referrals for this path without prefix, to provide support
3796 * for DFS referrals from w2k8 servers which don't seem to respond
3797 * with PATH_NOT_COVERED to requests that include the prefix.
3798 * Chase the referral if found, otherwise continue normally.
3800 if (referral_walks_count
== 0) {
3801 int refrc
= expand_dfs_referral(xid
, ses
, volume_info
, cifs_sb
,
3804 referral_walks_count
++;
3805 goto try_mount_again
;
3810 /* check if a whole path is not remote */
3812 if (!server
->ops
->is_path_accessible
) {
3814 goto mount_fail_check
;
3817 * cifs_build_path_to_root works only when we have a valid tcon
3819 full_path
= cifs_build_path_to_root(volume_info
, cifs_sb
, tcon
,
3820 tcon
->Flags
& SMB_SHARE_IS_IN_DFS
);
3821 if (full_path
== NULL
) {
3823 goto mount_fail_check
;
3825 rc
= server
->ops
->is_path_accessible(xid
, tcon
, cifs_sb
,
3827 if (rc
!= 0 && rc
!= -EREMOTE
) {
3829 goto mount_fail_check
;
3832 if (rc
!= -EREMOTE
) {
3833 rc
= cifs_are_all_path_components_accessible(server
,
3837 cifs_dbg(VFS
, "cannot query dirs between root and final path, "
3838 "enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
3839 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_USE_PREFIX_PATH
;
3846 /* get referral if needed */
3847 if (rc
== -EREMOTE
) {
3848 #ifdef CONFIG_CIFS_DFS_UPCALL
3849 if (referral_walks_count
> MAX_NESTED_LINKS
) {
3851 * BB: when we implement proper loop detection,
3852 * we will remove this check. But now we need it
3853 * to prevent an indefinite loop if 'DFS tree' is
3854 * misconfigured (i.e. has loops).
3857 goto mount_fail_check
;
3860 rc
= expand_dfs_referral(xid
, ses
, volume_info
, cifs_sb
, true);
3863 referral_walks_count
++;
3864 goto try_mount_again
;
3866 goto mount_fail_check
;
3867 #else /* No DFS support, return error on mount */
3873 goto mount_fail_check
;
3875 /* now, hang the tcon off of the superblock */
3876 tlink
= kzalloc(sizeof *tlink
, GFP_KERNEL
);
3877 if (tlink
== NULL
) {
3879 goto mount_fail_check
;
3882 tlink
->tl_uid
= ses
->linux_uid
;
3883 tlink
->tl_tcon
= tcon
;
3884 tlink
->tl_time
= jiffies
;
3885 set_bit(TCON_LINK_MASTER
, &tlink
->tl_flags
);
3886 set_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
3888 cifs_sb
->master_tlink
= tlink
;
3889 spin_lock(&cifs_sb
->tlink_tree_lock
);
3890 tlink_rb_insert(&cifs_sb
->tlink_tree
, tlink
);
3891 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3893 queue_delayed_work(cifsiod_wq
, &cifs_sb
->prune_tlinks
,
3897 /* on error free sesinfo and tcon struct if needed */
3899 /* If find_unc succeeded then rc == 0 so we can not end */
3900 /* up accidentally freeing someone elses tcon struct */
3902 cifs_put_tcon(tcon
);
3904 cifs_put_smb_ses(ses
);
3906 cifs_put_tcp_session(server
, 0);
3915 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3916 * pointer may be NULL.
3919 CIFSTCon(const unsigned int xid
, struct cifs_ses
*ses
,
3920 const char *tree
, struct cifs_tcon
*tcon
,
3921 const struct nls_table
*nls_codepage
)
3923 struct smb_hdr
*smb_buffer
;
3924 struct smb_hdr
*smb_buffer_response
;
3927 unsigned char *bcc_ptr
;
3930 __u16 bytes_left
, count
;
3935 smb_buffer
= cifs_buf_get();
3936 if (smb_buffer
== NULL
)
3939 smb_buffer_response
= smb_buffer
;
3941 header_assemble(smb_buffer
, SMB_COM_TREE_CONNECT_ANDX
,
3942 NULL
/*no tid */ , 4 /*wct */ );
3944 smb_buffer
->Mid
= get_next_mid(ses
->server
);
3945 smb_buffer
->Uid
= ses
->Suid
;
3946 pSMB
= (TCONX_REQ
*) smb_buffer
;
3947 pSMBr
= (TCONX_RSP
*) smb_buffer_response
;
3949 pSMB
->AndXCommand
= 0xFF;
3950 pSMB
->Flags
= cpu_to_le16(TCON_EXTENDED_SECINFO
);
3951 bcc_ptr
= &pSMB
->Password
[0];
3952 if (!tcon
|| (ses
->server
->sec_mode
& SECMODE_USER
)) {
3953 pSMB
->PasswordLength
= cpu_to_le16(1); /* minimum */
3954 *bcc_ptr
= 0; /* password is null byte */
3955 bcc_ptr
++; /* skip password */
3956 /* already aligned so no need to do it below */
3958 pSMB
->PasswordLength
= cpu_to_le16(CIFS_AUTH_RESP_SIZE
);
3959 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3960 specified as required (when that support is added to
3961 the vfs in the future) as only NTLM or the much
3962 weaker LANMAN (which we do not send by default) is accepted
3963 by Samba (not sure whether other servers allow
3964 NTLMv2 password here) */
3965 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3966 if ((global_secflags
& CIFSSEC_MAY_LANMAN
) &&
3967 (ses
->sectype
== LANMAN
))
3968 calc_lanman_hash(tcon
->password
, ses
->server
->cryptkey
,
3969 ses
->server
->sec_mode
&
3970 SECMODE_PW_ENCRYPT
? true : false,
3973 #endif /* CIFS_WEAK_PW_HASH */
3974 rc
= SMBNTencrypt(tcon
->password
, ses
->server
->cryptkey
,
3975 bcc_ptr
, nls_codepage
);
3977 cifs_dbg(FYI
, "%s Can't generate NTLM rsp. Error: %d\n",
3979 cifs_buf_release(smb_buffer
);
3983 bcc_ptr
+= CIFS_AUTH_RESP_SIZE
;
3984 if (ses
->capabilities
& CAP_UNICODE
) {
3985 /* must align unicode strings */
3986 *bcc_ptr
= 0; /* null byte password */
3991 if (ses
->server
->sign
)
3992 smb_buffer
->Flags2
|= SMBFLG2_SECURITY_SIGNATURE
;
3994 if (ses
->capabilities
& CAP_STATUS32
) {
3995 smb_buffer
->Flags2
|= SMBFLG2_ERR_STATUS
;
3997 if (ses
->capabilities
& CAP_DFS
) {
3998 smb_buffer
->Flags2
|= SMBFLG2_DFS
;
4000 if (ses
->capabilities
& CAP_UNICODE
) {
4001 smb_buffer
->Flags2
|= SMBFLG2_UNICODE
;
4003 cifs_strtoUTF16((__le16
*) bcc_ptr
, tree
,
4004 6 /* max utf8 char length in bytes */ *
4005 (/* server len*/ + 256 /* share len */), nls_codepage
);
4006 bcc_ptr
+= 2 * length
; /* convert num 16 bit words to bytes */
4007 bcc_ptr
+= 2; /* skip trailing null */
4008 } else { /* ASCII */
4009 strcpy(bcc_ptr
, tree
);
4010 bcc_ptr
+= strlen(tree
) + 1;
4012 strcpy(bcc_ptr
, "?????");
4013 bcc_ptr
+= strlen("?????");
4015 count
= bcc_ptr
- &pSMB
->Password
[0];
4016 pSMB
->hdr
.smb_buf_length
= cpu_to_be32(be32_to_cpu(
4017 pSMB
->hdr
.smb_buf_length
) + count
);
4018 pSMB
->ByteCount
= cpu_to_le16(count
);
4020 rc
= SendReceive(xid
, ses
, smb_buffer
, smb_buffer_response
, &length
,
4023 /* above now done in SendReceive */
4024 if ((rc
== 0) && (tcon
!= NULL
)) {
4027 tcon
->tidStatus
= CifsGood
;
4028 tcon
->need_reconnect
= false;
4029 tcon
->tid
= smb_buffer_response
->Tid
;
4030 bcc_ptr
= pByteArea(smb_buffer_response
);
4031 bytes_left
= get_bcc(smb_buffer_response
);
4032 length
= strnlen(bcc_ptr
, bytes_left
- 2);
4033 if (smb_buffer
->Flags2
& SMBFLG2_UNICODE
)
4039 /* skip service field (NB: this field is always ASCII) */
4041 if ((bcc_ptr
[0] == 'I') && (bcc_ptr
[1] == 'P') &&
4042 (bcc_ptr
[2] == 'C')) {
4043 cifs_dbg(FYI
, "IPC connection\n");
4046 } else if (length
== 2) {
4047 if ((bcc_ptr
[0] == 'A') && (bcc_ptr
[1] == ':')) {
4048 /* the most common case */
4049 cifs_dbg(FYI
, "disk share connection\n");
4052 bcc_ptr
+= length
+ 1;
4053 bytes_left
-= (length
+ 1);
4054 strlcpy(tcon
->treeName
, tree
, sizeof(tcon
->treeName
));
4056 /* mostly informational -- no need to fail on error here */
4057 kfree(tcon
->nativeFileSystem
);
4058 tcon
->nativeFileSystem
= cifs_strndup_from_utf16(bcc_ptr
,
4059 bytes_left
, is_unicode
,
4062 cifs_dbg(FYI
, "nativeFileSystem=%s\n", tcon
->nativeFileSystem
);
4064 if ((smb_buffer_response
->WordCount
== 3) ||
4065 (smb_buffer_response
->WordCount
== 7))
4066 /* field is in same location */
4067 tcon
->Flags
= le16_to_cpu(pSMBr
->OptionalSupport
);
4070 cifs_dbg(FYI
, "Tcon flags: 0x%x\n", tcon
->Flags
);
4071 } else if ((rc
== 0) && tcon
== NULL
) {
4072 /* all we need to save for IPC$ connection */
4073 ses
->ipc_tid
= smb_buffer_response
->Tid
;
4076 cifs_buf_release(smb_buffer
);
4080 static void delayed_free(struct rcu_head
*p
)
4082 struct cifs_sb_info
*sbi
= container_of(p
, struct cifs_sb_info
, rcu
);
4083 unload_nls(sbi
->local_nls
);
4088 cifs_umount(struct cifs_sb_info
*cifs_sb
)
4090 struct rb_root
*root
= &cifs_sb
->tlink_tree
;
4091 struct rb_node
*node
;
4092 struct tcon_link
*tlink
;
4094 cancel_delayed_work_sync(&cifs_sb
->prune_tlinks
);
4096 spin_lock(&cifs_sb
->tlink_tree_lock
);
4097 while ((node
= rb_first(root
))) {
4098 tlink
= rb_entry(node
, struct tcon_link
, tl_rbnode
);
4099 cifs_get_tlink(tlink
);
4100 clear_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
4101 rb_erase(node
, root
);
4103 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4104 cifs_put_tlink(tlink
);
4105 spin_lock(&cifs_sb
->tlink_tree_lock
);
4107 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4109 kfree(cifs_sb
->mountdata
);
4110 kfree(cifs_sb
->prepath
);
4111 call_rcu(&cifs_sb
->rcu
, delayed_free
);
4115 cifs_negotiate_protocol(const unsigned int xid
, struct cifs_ses
*ses
)
4118 struct TCP_Server_Info
*server
= ses
->server
;
4120 if (!server
->ops
->need_neg
|| !server
->ops
->negotiate
)
4123 /* only send once per connect */
4124 if (!server
->ops
->need_neg(server
))
4127 set_credits(server
, 1);
4129 rc
= server
->ops
->negotiate(xid
, ses
);
4131 spin_lock(&GlobalMid_Lock
);
4132 if (server
->tcpStatus
== CifsNeedNegotiate
)
4133 server
->tcpStatus
= CifsGood
;
4136 spin_unlock(&GlobalMid_Lock
);
4143 cifs_setup_session(const unsigned int xid
, struct cifs_ses
*ses
,
4144 struct nls_table
*nls_info
)
4147 struct TCP_Server_Info
*server
= ses
->server
;
4149 ses
->capabilities
= server
->capabilities
;
4150 if (linuxExtEnabled
== 0)
4151 ses
->capabilities
&= (~server
->vals
->cap_unix
);
4153 cifs_dbg(FYI
, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
4154 server
->sec_mode
, server
->capabilities
, server
->timeAdj
);
4156 if (ses
->auth_key
.response
) {
4157 cifs_dbg(VFS
, "Free previous auth_key.response = %p\n",
4158 ses
->auth_key
.response
);
4159 kfree(ses
->auth_key
.response
);
4160 ses
->auth_key
.response
= NULL
;
4161 ses
->auth_key
.len
= 0;
4164 if (server
->ops
->sess_setup
)
4165 rc
= server
->ops
->sess_setup(xid
, ses
, nls_info
);
4168 cifs_dbg(VFS
, "Send error in SessSetup = %d\n", rc
);
4174 cifs_set_vol_auth(struct smb_vol
*vol
, struct cifs_ses
*ses
)
4176 vol
->sectype
= ses
->sectype
;
4178 /* krb5 is special, since we don't need username or pw */
4179 if (vol
->sectype
== Kerberos
)
4182 return cifs_set_cifscreds(vol
, ses
);
4185 static struct cifs_tcon
*
4186 cifs_construct_tcon(struct cifs_sb_info
*cifs_sb
, kuid_t fsuid
)
4189 struct cifs_tcon
*master_tcon
= cifs_sb_master_tcon(cifs_sb
);
4190 struct cifs_ses
*ses
;
4191 struct cifs_tcon
*tcon
= NULL
;
4192 struct smb_vol
*vol_info
;
4194 vol_info
= kzalloc(sizeof(*vol_info
), GFP_KERNEL
);
4195 if (vol_info
== NULL
)
4196 return ERR_PTR(-ENOMEM
);
4198 vol_info
->local_nls
= cifs_sb
->local_nls
;
4199 vol_info
->linux_uid
= fsuid
;
4200 vol_info
->cred_uid
= fsuid
;
4201 vol_info
->UNC
= master_tcon
->treeName
;
4202 vol_info
->retry
= master_tcon
->retry
;
4203 vol_info
->nocase
= master_tcon
->nocase
;
4204 vol_info
->local_lease
= master_tcon
->local_lease
;
4205 vol_info
->no_linux_ext
= !master_tcon
->unix_ext
;
4206 vol_info
->sectype
= master_tcon
->ses
->sectype
;
4207 vol_info
->sign
= master_tcon
->ses
->sign
;
4209 rc
= cifs_set_vol_auth(vol_info
, master_tcon
->ses
);
4215 /* get a reference for the same TCP session */
4216 spin_lock(&cifs_tcp_ses_lock
);
4217 ++master_tcon
->ses
->server
->srv_count
;
4218 spin_unlock(&cifs_tcp_ses_lock
);
4220 ses
= cifs_get_smb_ses(master_tcon
->ses
->server
, vol_info
);
4222 tcon
= (struct cifs_tcon
*)ses
;
4223 cifs_put_tcp_session(master_tcon
->ses
->server
, 0);
4227 tcon
= cifs_get_tcon(ses
, vol_info
);
4229 cifs_put_smb_ses(ses
);
4234 reset_cifs_unix_caps(0, tcon
, NULL
, vol_info
);
4236 kfree(vol_info
->username
);
4237 kfree(vol_info
->password
);
4244 cifs_sb_master_tcon(struct cifs_sb_info
*cifs_sb
)
4246 return tlink_tcon(cifs_sb_master_tlink(cifs_sb
));
4249 /* find and return a tlink with given uid */
4250 static struct tcon_link
*
4251 tlink_rb_search(struct rb_root
*root
, kuid_t uid
)
4253 struct rb_node
*node
= root
->rb_node
;
4254 struct tcon_link
*tlink
;
4257 tlink
= rb_entry(node
, struct tcon_link
, tl_rbnode
);
4259 if (uid_gt(tlink
->tl_uid
, uid
))
4260 node
= node
->rb_left
;
4261 else if (uid_lt(tlink
->tl_uid
, uid
))
4262 node
= node
->rb_right
;
4269 /* insert a tcon_link into the tree */
4271 tlink_rb_insert(struct rb_root
*root
, struct tcon_link
*new_tlink
)
4273 struct rb_node
**new = &(root
->rb_node
), *parent
= NULL
;
4274 struct tcon_link
*tlink
;
4277 tlink
= rb_entry(*new, struct tcon_link
, tl_rbnode
);
4280 if (uid_gt(tlink
->tl_uid
, new_tlink
->tl_uid
))
4281 new = &((*new)->rb_left
);
4283 new = &((*new)->rb_right
);
4286 rb_link_node(&new_tlink
->tl_rbnode
, parent
, new);
4287 rb_insert_color(&new_tlink
->tl_rbnode
, root
);
4291 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4294 * If the superblock doesn't refer to a multiuser mount, then just return
4295 * the master tcon for the mount.
4297 * First, search the rbtree for an existing tcon for this fsuid. If one
4298 * exists, then check to see if it's pending construction. If it is then wait
4299 * for construction to complete. Once it's no longer pending, check to see if
4300 * it failed and either return an error or retry construction, depending on
4303 * If one doesn't exist then insert a new tcon_link struct into the tree and
4304 * try to construct a new one.
4307 cifs_sb_tlink(struct cifs_sb_info
*cifs_sb
)
4310 kuid_t fsuid
= current_fsuid();
4311 struct tcon_link
*tlink
, *newtlink
;
4313 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
))
4314 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb
));
4316 spin_lock(&cifs_sb
->tlink_tree_lock
);
4317 tlink
= tlink_rb_search(&cifs_sb
->tlink_tree
, fsuid
);
4319 cifs_get_tlink(tlink
);
4320 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4322 if (tlink
== NULL
) {
4323 newtlink
= kzalloc(sizeof(*tlink
), GFP_KERNEL
);
4324 if (newtlink
== NULL
)
4325 return ERR_PTR(-ENOMEM
);
4326 newtlink
->tl_uid
= fsuid
;
4327 newtlink
->tl_tcon
= ERR_PTR(-EACCES
);
4328 set_bit(TCON_LINK_PENDING
, &newtlink
->tl_flags
);
4329 set_bit(TCON_LINK_IN_TREE
, &newtlink
->tl_flags
);
4330 cifs_get_tlink(newtlink
);
4332 spin_lock(&cifs_sb
->tlink_tree_lock
);
4333 /* was one inserted after previous search? */
4334 tlink
= tlink_rb_search(&cifs_sb
->tlink_tree
, fsuid
);
4336 cifs_get_tlink(tlink
);
4337 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4339 goto wait_for_construction
;
4342 tlink_rb_insert(&cifs_sb
->tlink_tree
, tlink
);
4343 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4345 wait_for_construction
:
4346 ret
= wait_on_bit(&tlink
->tl_flags
, TCON_LINK_PENDING
,
4347 TASK_INTERRUPTIBLE
);
4349 cifs_put_tlink(tlink
);
4350 return ERR_PTR(-ERESTARTSYS
);
4353 /* if it's good, return it */
4354 if (!IS_ERR(tlink
->tl_tcon
))
4357 /* return error if we tried this already recently */
4358 if (time_before(jiffies
, tlink
->tl_time
+ TLINK_ERROR_EXPIRE
)) {
4359 cifs_put_tlink(tlink
);
4360 return ERR_PTR(-EACCES
);
4363 if (test_and_set_bit(TCON_LINK_PENDING
, &tlink
->tl_flags
))
4364 goto wait_for_construction
;
4367 tlink
->tl_tcon
= cifs_construct_tcon(cifs_sb
, fsuid
);
4368 clear_bit(TCON_LINK_PENDING
, &tlink
->tl_flags
);
4369 wake_up_bit(&tlink
->tl_flags
, TCON_LINK_PENDING
);
4371 if (IS_ERR(tlink
->tl_tcon
)) {
4372 cifs_put_tlink(tlink
);
4373 return ERR_PTR(-EACCES
);
4380 * periodic workqueue job that scans tcon_tree for a superblock and closes
4384 cifs_prune_tlinks(struct work_struct
*work
)
4386 struct cifs_sb_info
*cifs_sb
= container_of(work
, struct cifs_sb_info
,
4388 struct rb_root
*root
= &cifs_sb
->tlink_tree
;
4389 struct rb_node
*node
= rb_first(root
);
4390 struct rb_node
*tmp
;
4391 struct tcon_link
*tlink
;
4394 * Because we drop the spinlock in the loop in order to put the tlink
4395 * it's not guarded against removal of links from the tree. The only
4396 * places that remove entries from the tree are this function and
4397 * umounts. Because this function is non-reentrant and is canceled
4398 * before umount can proceed, this is safe.
4400 spin_lock(&cifs_sb
->tlink_tree_lock
);
4401 node
= rb_first(root
);
4402 while (node
!= NULL
) {
4404 node
= rb_next(tmp
);
4405 tlink
= rb_entry(tmp
, struct tcon_link
, tl_rbnode
);
4407 if (test_bit(TCON_LINK_MASTER
, &tlink
->tl_flags
) ||
4408 atomic_read(&tlink
->tl_count
) != 0 ||
4409 time_after(tlink
->tl_time
+ TLINK_IDLE_EXPIRE
, jiffies
))
4412 cifs_get_tlink(tlink
);
4413 clear_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
4414 rb_erase(tmp
, root
);
4416 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4417 cifs_put_tlink(tlink
);
4418 spin_lock(&cifs_sb
->tlink_tree_lock
);
4420 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4422 queue_delayed_work(cifsiod_wq
, &cifs_sb
->prune_tlinks
,