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_version_err
, NULL
}
307 static int ip_connect(struct TCP_Server_Info
*server
);
308 static int generic_ip_connect(struct TCP_Server_Info
*server
);
309 static void tlink_rb_insert(struct rb_root
*root
, struct tcon_link
*new_tlink
);
310 static void cifs_prune_tlinks(struct work_struct
*work
);
311 static int cifs_setup_volume_info(struct smb_vol
*volume_info
, char *mount_data
,
312 const char *devname
);
315 * cifs tcp session reconnection
317 * mark tcp session as reconnecting so temporarily locked
318 * mark all smb sessions as reconnecting for tcp session
319 * reconnect tcp session
320 * wake up waiters on reconnection? - (not needed currently)
323 cifs_reconnect(struct TCP_Server_Info
*server
)
326 struct list_head
*tmp
, *tmp2
;
327 struct cifs_ses
*ses
;
328 struct cifs_tcon
*tcon
;
329 struct mid_q_entry
*mid_entry
;
330 struct list_head retry_list
;
332 spin_lock(&GlobalMid_Lock
);
333 if (server
->tcpStatus
== CifsExiting
) {
334 /* the demux thread will exit normally
335 next time through the loop */
336 spin_unlock(&GlobalMid_Lock
);
339 server
->tcpStatus
= CifsNeedReconnect
;
340 spin_unlock(&GlobalMid_Lock
);
342 server
->max_read
= 0;
344 cifs_dbg(FYI
, "Reconnecting tcp session\n");
346 /* before reconnecting the tcp session, mark the smb session (uid)
347 and the tid bad so they are not used until reconnected */
348 cifs_dbg(FYI
, "%s: marking sessions and tcons for reconnect\n",
350 spin_lock(&cifs_tcp_ses_lock
);
351 list_for_each(tmp
, &server
->smb_ses_list
) {
352 ses
= list_entry(tmp
, struct cifs_ses
, smb_ses_list
);
353 ses
->need_reconnect
= true;
355 list_for_each(tmp2
, &ses
->tcon_list
) {
356 tcon
= list_entry(tmp2
, struct cifs_tcon
, tcon_list
);
357 tcon
->need_reconnect
= true;
360 spin_unlock(&cifs_tcp_ses_lock
);
362 /* do not want to be sending data on a socket we are freeing */
363 cifs_dbg(FYI
, "%s: tearing down socket\n", __func__
);
364 mutex_lock(&server
->srv_mutex
);
365 if (server
->ssocket
) {
366 cifs_dbg(FYI
, "State: 0x%x Flags: 0x%lx\n",
367 server
->ssocket
->state
, server
->ssocket
->flags
);
368 kernel_sock_shutdown(server
->ssocket
, SHUT_WR
);
369 cifs_dbg(FYI
, "Post shutdown state: 0x%x Flags: 0x%lx\n",
370 server
->ssocket
->state
, server
->ssocket
->flags
);
371 sock_release(server
->ssocket
);
372 server
->ssocket
= NULL
;
374 server
->sequence_number
= 0;
375 server
->session_estab
= false;
376 kfree(server
->session_key
.response
);
377 server
->session_key
.response
= NULL
;
378 server
->session_key
.len
= 0;
379 server
->lstrp
= jiffies
;
381 /* mark submitted MIDs for retry and issue callback */
382 INIT_LIST_HEAD(&retry_list
);
383 cifs_dbg(FYI
, "%s: moving mids to private list\n", __func__
);
384 spin_lock(&GlobalMid_Lock
);
385 list_for_each_safe(tmp
, tmp2
, &server
->pending_mid_q
) {
386 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
387 if (mid_entry
->mid_state
== MID_REQUEST_SUBMITTED
)
388 mid_entry
->mid_state
= MID_RETRY_NEEDED
;
389 list_move(&mid_entry
->qhead
, &retry_list
);
391 spin_unlock(&GlobalMid_Lock
);
392 mutex_unlock(&server
->srv_mutex
);
394 cifs_dbg(FYI
, "%s: issuing mid callbacks\n", __func__
);
395 list_for_each_safe(tmp
, tmp2
, &retry_list
) {
396 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
397 list_del_init(&mid_entry
->qhead
);
398 mid_entry
->callback(mid_entry
);
404 /* we should try only the port we connected to before */
405 mutex_lock(&server
->srv_mutex
);
406 rc
= generic_ip_connect(server
);
408 cifs_dbg(FYI
, "reconnect error %d\n", rc
);
409 mutex_unlock(&server
->srv_mutex
);
412 atomic_inc(&tcpSesReconnectCount
);
413 spin_lock(&GlobalMid_Lock
);
414 if (server
->tcpStatus
!= CifsExiting
)
415 server
->tcpStatus
= CifsNeedNegotiate
;
416 spin_unlock(&GlobalMid_Lock
);
417 mutex_unlock(&server
->srv_mutex
);
419 } while (server
->tcpStatus
== CifsNeedReconnect
);
421 if (server
->tcpStatus
== CifsNeedNegotiate
)
422 mod_delayed_work(cifsiod_wq
, &server
->echo
, 0);
428 cifs_echo_request(struct work_struct
*work
)
431 struct TCP_Server_Info
*server
= container_of(work
,
432 struct TCP_Server_Info
, echo
.work
);
433 unsigned long echo_interval
;
436 * If we need to renegotiate, set echo interval to zero to
437 * immediately call echo service where we can renegotiate.
439 if (server
->tcpStatus
== CifsNeedNegotiate
)
442 echo_interval
= server
->echo_interval
;
445 * We cannot send an echo if it is disabled.
446 * Also, no need to ping if we got a response recently.
449 if (server
->tcpStatus
== CifsNeedReconnect
||
450 server
->tcpStatus
== CifsExiting
||
451 server
->tcpStatus
== CifsNew
||
452 (server
->ops
->can_echo
&& !server
->ops
->can_echo(server
)) ||
453 time_before(jiffies
, server
->lstrp
+ echo_interval
- HZ
))
456 rc
= server
->ops
->echo
? server
->ops
->echo(server
) : -ENOSYS
;
458 cifs_dbg(FYI
, "Unable to send echo request to server: %s\n",
462 queue_delayed_work(cifsiod_wq
, &server
->echo
, server
->echo_interval
);
466 allocate_buffers(struct TCP_Server_Info
*server
)
468 if (!server
->bigbuf
) {
469 server
->bigbuf
= (char *)cifs_buf_get();
470 if (!server
->bigbuf
) {
471 cifs_dbg(VFS
, "No memory for large SMB response\n");
473 /* retry will check if exiting */
476 } else if (server
->large_buf
) {
477 /* we are reusing a dirty large buf, clear its start */
478 memset(server
->bigbuf
, 0, HEADER_SIZE(server
));
481 if (!server
->smallbuf
) {
482 server
->smallbuf
= (char *)cifs_small_buf_get();
483 if (!server
->smallbuf
) {
484 cifs_dbg(VFS
, "No memory for SMB response\n");
486 /* retry will check if exiting */
489 /* beginning of smb buffer is cleared in our buf_get */
491 /* if existing small buf clear beginning */
492 memset(server
->smallbuf
, 0, HEADER_SIZE(server
));
499 server_unresponsive(struct TCP_Server_Info
*server
)
502 * We need to wait 2 echo intervals to make sure we handle such
504 * 1s client sends a normal SMB request
505 * 2s client gets a response
506 * 30s echo workqueue job pops, and decides we got a response recently
507 * and don't need to send another
509 * 65s kernel_recvmsg times out, and we see that we haven't gotten
510 * a response in >60s.
512 if (server
->tcpStatus
== CifsGood
&&
513 time_after(jiffies
, server
->lstrp
+ 2 * server
->echo_interval
)) {
514 cifs_dbg(VFS
, "Server %s has not responded in %lu seconds. Reconnecting...\n",
515 server
->hostname
, (2 * server
->echo_interval
) / HZ
);
516 cifs_reconnect(server
);
517 wake_up(&server
->response_q
);
525 cifs_readv_from_socket(struct TCP_Server_Info
*server
, struct msghdr
*smb_msg
)
530 smb_msg
->msg_control
= NULL
;
531 smb_msg
->msg_controllen
= 0;
533 for (total_read
= 0; msg_data_left(smb_msg
); total_read
+= length
) {
536 if (server_unresponsive(server
))
537 return -ECONNABORTED
;
539 length
= sock_recvmsg(server
->ssocket
, smb_msg
, 0);
541 if (server
->tcpStatus
== CifsExiting
)
544 if (server
->tcpStatus
== CifsNeedReconnect
) {
545 cifs_reconnect(server
);
546 return -ECONNABORTED
;
549 if (length
== -ERESTARTSYS
||
553 * Minimum sleep to prevent looping, allowing socket
554 * to clear and app threads to set tcpStatus
555 * CifsNeedReconnect if server hung.
557 usleep_range(1000, 2000);
563 cifs_dbg(FYI
, "Received no data or error: %d\n", length
);
564 cifs_reconnect(server
);
565 return -ECONNABORTED
;
572 cifs_read_from_socket(struct TCP_Server_Info
*server
, char *buf
,
573 unsigned int to_read
)
575 struct msghdr smb_msg
;
576 struct kvec iov
= {.iov_base
= buf
, .iov_len
= to_read
};
577 iov_iter_kvec(&smb_msg
.msg_iter
, READ
| ITER_KVEC
, &iov
, 1, to_read
);
579 return cifs_readv_from_socket(server
, &smb_msg
);
583 cifs_read_page_from_socket(struct TCP_Server_Info
*server
, struct page
*page
,
584 unsigned int to_read
)
586 struct msghdr smb_msg
;
587 struct bio_vec bv
= {.bv_page
= page
, .bv_len
= to_read
};
588 iov_iter_bvec(&smb_msg
.msg_iter
, READ
| ITER_BVEC
, &bv
, 1, to_read
);
589 return cifs_readv_from_socket(server
, &smb_msg
);
593 is_smb_response(struct TCP_Server_Info
*server
, unsigned char type
)
596 * The first byte big endian of the length field,
597 * is actually not part of the length but the type
598 * with the most common, zero, as regular data.
601 case RFC1002_SESSION_MESSAGE
:
602 /* Regular SMB response */
604 case RFC1002_SESSION_KEEP_ALIVE
:
605 cifs_dbg(FYI
, "RFC 1002 session keep alive\n");
607 case RFC1002_POSITIVE_SESSION_RESPONSE
:
608 cifs_dbg(FYI
, "RFC 1002 positive session response\n");
610 case RFC1002_NEGATIVE_SESSION_RESPONSE
:
612 * We get this from Windows 98 instead of an error on
613 * SMB negprot response.
615 cifs_dbg(FYI
, "RFC 1002 negative session response\n");
616 /* give server a second to clean up */
619 * Always try 445 first on reconnect since we get NACK
620 * on some if we ever connected to port 139 (the NACK
621 * is since we do not begin with RFC1001 session
624 cifs_set_port((struct sockaddr
*)&server
->dstaddr
, CIFS_PORT
);
625 cifs_reconnect(server
);
626 wake_up(&server
->response_q
);
629 cifs_dbg(VFS
, "RFC 1002 unknown response type 0x%x\n", type
);
630 cifs_reconnect(server
);
637 dequeue_mid(struct mid_q_entry
*mid
, bool malformed
)
639 #ifdef CONFIG_CIFS_STATS2
640 mid
->when_received
= jiffies
;
642 spin_lock(&GlobalMid_Lock
);
644 mid
->mid_state
= MID_RESPONSE_RECEIVED
;
646 mid
->mid_state
= MID_RESPONSE_MALFORMED
;
647 list_del_init(&mid
->qhead
);
648 spin_unlock(&GlobalMid_Lock
);
652 handle_mid(struct mid_q_entry
*mid
, struct TCP_Server_Info
*server
,
653 char *buf
, int malformed
)
655 if (server
->ops
->check_trans2
&&
656 server
->ops
->check_trans2(mid
, server
, buf
, malformed
))
659 mid
->large_buf
= server
->large_buf
;
660 /* Was previous buf put in mpx struct for multi-rsp? */
661 if (!mid
->multiRsp
) {
662 /* smb buffer will be freed by user thread */
663 if (server
->large_buf
)
664 server
->bigbuf
= NULL
;
666 server
->smallbuf
= NULL
;
668 dequeue_mid(mid
, malformed
);
671 static void clean_demultiplex_info(struct TCP_Server_Info
*server
)
675 /* take it off the list, if it's not already */
676 spin_lock(&cifs_tcp_ses_lock
);
677 list_del_init(&server
->tcp_ses_list
);
678 spin_unlock(&cifs_tcp_ses_lock
);
680 spin_lock(&GlobalMid_Lock
);
681 server
->tcpStatus
= CifsExiting
;
682 spin_unlock(&GlobalMid_Lock
);
683 wake_up_all(&server
->response_q
);
685 /* check if we have blocked requests that need to free */
686 spin_lock(&server
->req_lock
);
687 if (server
->credits
<= 0)
689 spin_unlock(&server
->req_lock
);
691 * Although there should not be any requests blocked on this queue it
692 * can not hurt to be paranoid and try to wake up requests that may
693 * haven been blocked when more than 50 at time were on the wire to the
694 * same server - they now will see the session is in exit state and get
695 * out of SendReceive.
697 wake_up_all(&server
->request_q
);
698 /* give those requests time to exit */
701 if (server
->ssocket
) {
702 sock_release(server
->ssocket
);
703 server
->ssocket
= NULL
;
706 if (!list_empty(&server
->pending_mid_q
)) {
707 struct list_head dispose_list
;
708 struct mid_q_entry
*mid_entry
;
709 struct list_head
*tmp
, *tmp2
;
711 INIT_LIST_HEAD(&dispose_list
);
712 spin_lock(&GlobalMid_Lock
);
713 list_for_each_safe(tmp
, tmp2
, &server
->pending_mid_q
) {
714 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
715 cifs_dbg(FYI
, "Clearing mid 0x%llx\n", mid_entry
->mid
);
716 mid_entry
->mid_state
= MID_SHUTDOWN
;
717 list_move(&mid_entry
->qhead
, &dispose_list
);
719 spin_unlock(&GlobalMid_Lock
);
721 /* now walk dispose list and issue callbacks */
722 list_for_each_safe(tmp
, tmp2
, &dispose_list
) {
723 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
724 cifs_dbg(FYI
, "Callback mid 0x%llx\n", mid_entry
->mid
);
725 list_del_init(&mid_entry
->qhead
);
726 mid_entry
->callback(mid_entry
);
728 /* 1/8th of sec is more than enough time for them to exit */
732 if (!list_empty(&server
->pending_mid_q
)) {
734 * mpx threads have not exited yet give them at least the smb
735 * send timeout time for long ops.
737 * Due to delays on oplock break requests, we need to wait at
738 * least 45 seconds before giving up on a request getting a
739 * response and going ahead and killing cifsd.
741 cifs_dbg(FYI
, "Wait for exit from demultiplex thread\n");
744 * If threads still have not exited they are probably never
745 * coming home not much else we can do but free the memory.
749 kfree(server
->hostname
);
752 length
= atomic_dec_return(&tcpSesAllocCount
);
754 mempool_resize(cifs_req_poolp
, length
+ cifs_min_rcv
);
758 standard_receive3(struct TCP_Server_Info
*server
, struct mid_q_entry
*mid
)
761 char *buf
= server
->smallbuf
;
762 unsigned int pdu_length
= get_rfc1002_length(buf
);
764 /* make sure this will fit in a large buffer */
765 if (pdu_length
> CIFSMaxBufSize
+ MAX_HEADER_SIZE(server
) - 4) {
766 cifs_dbg(VFS
, "SMB response too long (%u bytes)\n", pdu_length
);
767 cifs_reconnect(server
);
768 wake_up(&server
->response_q
);
769 return -ECONNABORTED
;
772 /* switch to large buffer if too big for a small one */
773 if (pdu_length
> MAX_CIFS_SMALL_BUFFER_SIZE
- 4) {
774 server
->large_buf
= true;
775 memcpy(server
->bigbuf
, buf
, server
->total_read
);
776 buf
= server
->bigbuf
;
779 /* now read the rest */
780 length
= cifs_read_from_socket(server
, buf
+ HEADER_SIZE(server
) - 1,
781 pdu_length
- HEADER_SIZE(server
) + 1 + 4);
784 server
->total_read
+= length
;
786 dump_smb(buf
, server
->total_read
);
788 return cifs_handle_standard(server
, mid
);
792 cifs_handle_standard(struct TCP_Server_Info
*server
, struct mid_q_entry
*mid
)
794 char *buf
= server
->large_buf
? server
->bigbuf
: server
->smallbuf
;
798 * We know that we received enough to get to the MID as we
799 * checked the pdu_length earlier. Now check to see
800 * if the rest of the header is OK. We borrow the length
801 * var for the rest of the loop to avoid a new stack var.
803 * 48 bytes is enough to display the header and a little bit
804 * into the payload for debugging purposes.
806 length
= server
->ops
->check_message(buf
, server
->total_read
, server
);
808 cifs_dump_mem("Bad SMB: ", buf
,
809 min_t(unsigned int, server
->total_read
, 48));
811 if (server
->ops
->is_session_expired
&&
812 server
->ops
->is_session_expired(buf
)) {
813 cifs_reconnect(server
);
814 wake_up(&server
->response_q
);
818 if (server
->ops
->is_status_pending
&&
819 server
->ops
->is_status_pending(buf
, server
, length
))
825 handle_mid(mid
, server
, buf
, length
);
830 cifs_demultiplex_thread(void *p
)
833 struct TCP_Server_Info
*server
= p
;
834 unsigned int pdu_length
;
836 struct task_struct
*task_to_wake
= NULL
;
837 struct mid_q_entry
*mid_entry
;
839 current
->flags
|= PF_MEMALLOC
;
840 cifs_dbg(FYI
, "Demultiplex PID: %d\n", task_pid_nr(current
));
842 length
= atomic_inc_return(&tcpSesAllocCount
);
844 mempool_resize(cifs_req_poolp
, length
+ cifs_min_rcv
);
847 while (server
->tcpStatus
!= CifsExiting
) {
851 if (!allocate_buffers(server
))
854 server
->large_buf
= false;
855 buf
= server
->smallbuf
;
856 pdu_length
= 4; /* enough to get RFC1001 header */
858 length
= cifs_read_from_socket(server
, buf
, pdu_length
);
861 server
->total_read
= length
;
864 * The right amount was read from socket - 4 bytes,
865 * so we can now interpret the length field.
867 pdu_length
= get_rfc1002_length(buf
);
869 cifs_dbg(FYI
, "RFC1002 header 0x%x\n", pdu_length
);
870 if (!is_smb_response(server
, buf
[0]))
873 /* make sure we have enough to get to the MID */
874 if (pdu_length
< HEADER_SIZE(server
) - 1 - 4) {
875 cifs_dbg(VFS
, "SMB response too short (%u bytes)\n",
877 cifs_reconnect(server
);
878 wake_up(&server
->response_q
);
882 /* read down to the MID */
883 length
= cifs_read_from_socket(server
, buf
+ 4,
884 HEADER_SIZE(server
) - 1 - 4);
887 server
->total_read
+= length
;
889 if (server
->ops
->is_transform_hdr
&&
890 server
->ops
->receive_transform
&&
891 server
->ops
->is_transform_hdr(buf
)) {
892 length
= server
->ops
->receive_transform(server
,
895 mid_entry
= server
->ops
->find_mid(server
, buf
);
897 if (!mid_entry
|| !mid_entry
->receive
)
898 length
= standard_receive3(server
, mid_entry
);
900 length
= mid_entry
->receive(server
, mid_entry
);
906 if (server
->large_buf
)
907 buf
= server
->bigbuf
;
909 server
->lstrp
= jiffies
;
910 if (mid_entry
!= NULL
) {
911 if ((mid_entry
->mid_flags
& MID_WAIT_CANCELLED
) &&
912 mid_entry
->mid_state
== MID_RESPONSE_RECEIVED
&&
913 server
->ops
->handle_cancelled_mid
)
914 server
->ops
->handle_cancelled_mid(
918 if (!mid_entry
->multiRsp
|| mid_entry
->multiEnd
)
919 mid_entry
->callback(mid_entry
);
920 } else if (server
->ops
->is_oplock_break
&&
921 server
->ops
->is_oplock_break(buf
, server
)) {
922 cifs_dbg(FYI
, "Received oplock break\n");
924 cifs_dbg(VFS
, "No task to wake, unknown frame received! NumMids %d\n",
925 atomic_read(&midCount
));
926 cifs_dump_mem("Received Data is: ", buf
,
927 HEADER_SIZE(server
));
928 #ifdef CONFIG_CIFS_DEBUG2
929 if (server
->ops
->dump_detail
)
930 server
->ops
->dump_detail(buf
);
931 cifs_dump_mids(server
);
932 #endif /* CIFS_DEBUG2 */
935 } /* end while !EXITING */
937 /* buffer usually freed in free_mid - need to free it here on exit */
938 cifs_buf_release(server
->bigbuf
);
939 if (server
->smallbuf
) /* no sense logging a debug message if NULL */
940 cifs_small_buf_release(server
->smallbuf
);
942 task_to_wake
= xchg(&server
->tsk
, NULL
);
943 clean_demultiplex_info(server
);
945 /* if server->tsk was NULL then wait for a signal before exiting */
947 set_current_state(TASK_INTERRUPTIBLE
);
948 while (!signal_pending(current
)) {
950 set_current_state(TASK_INTERRUPTIBLE
);
952 set_current_state(TASK_RUNNING
);
955 module_put_and_exit(0);
958 /* extract the host portion of the UNC string */
960 extract_hostname(const char *unc
)
966 /* skip double chars at beginning of string */
967 /* BB: check validity of these bytes? */
970 /* delimiter between hostname and sharename is always '\\' now */
971 delim
= strchr(src
, '\\');
973 return ERR_PTR(-EINVAL
);
976 dst
= kmalloc((len
+ 1), GFP_KERNEL
);
978 return ERR_PTR(-ENOMEM
);
980 memcpy(dst
, src
, len
);
986 static int get_option_ul(substring_t args
[], unsigned long *option
)
991 string
= match_strdup(args
);
994 rc
= kstrtoul(string
, 0, option
);
1000 static int get_option_uid(substring_t args
[], kuid_t
*result
)
1002 unsigned long value
;
1006 rc
= get_option_ul(args
, &value
);
1010 uid
= make_kuid(current_user_ns(), value
);
1011 if (!uid_valid(uid
))
1018 static int get_option_gid(substring_t args
[], kgid_t
*result
)
1020 unsigned long value
;
1024 rc
= get_option_ul(args
, &value
);
1028 gid
= make_kgid(current_user_ns(), value
);
1029 if (!gid_valid(gid
))
1036 static int cifs_parse_security_flavors(char *value
,
1037 struct smb_vol
*vol
)
1040 substring_t args
[MAX_OPT_ARGS
];
1043 * With mount options, the last one should win. Reset any existing
1044 * settings back to default.
1046 vol
->sectype
= Unspecified
;
1049 switch (match_token(value
, cifs_secflavor_tokens
, args
)) {
1051 cifs_dbg(VFS
, "sec=krb5p is not supported!\n");
1057 vol
->sectype
= Kerberos
;
1059 case Opt_sec_ntlmsspi
:
1062 case Opt_sec_ntlmssp
:
1063 vol
->sectype
= RawNTLMSSP
;
1069 vol
->sectype
= NTLM
;
1071 case Opt_sec_ntlmv2i
:
1074 case Opt_sec_ntlmv2
:
1075 vol
->sectype
= NTLMv2
;
1077 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1078 case Opt_sec_lanman
:
1079 vol
->sectype
= LANMAN
;
1086 cifs_dbg(VFS
, "bad security option: %s\n", value
);
1094 cifs_parse_cache_flavor(char *value
, struct smb_vol
*vol
)
1096 substring_t args
[MAX_OPT_ARGS
];
1098 switch (match_token(value
, cifs_cacheflavor_tokens
, args
)) {
1099 case Opt_cache_loose
:
1100 vol
->direct_io
= false;
1101 vol
->strict_io
= false;
1103 case Opt_cache_strict
:
1104 vol
->direct_io
= false;
1105 vol
->strict_io
= true;
1107 case Opt_cache_none
:
1108 vol
->direct_io
= true;
1109 vol
->strict_io
= false;
1112 cifs_dbg(VFS
, "bad cache= option: %s\n", value
);
1119 cifs_parse_smb_version(char *value
, struct smb_vol
*vol
)
1121 substring_t args
[MAX_OPT_ARGS
];
1123 switch (match_token(value
, cifs_smb_version_tokens
, args
)) {
1125 vol
->ops
= &smb1_operations
;
1126 vol
->vals
= &smb1_values
;
1129 vol
->ops
= &smb20_operations
;
1130 vol
->vals
= &smb20_values
;
1133 vol
->ops
= &smb21_operations
;
1134 vol
->vals
= &smb21_values
;
1137 vol
->ops
= &smb30_operations
;
1138 vol
->vals
= &smb30_values
;
1141 vol
->ops
= &smb30_operations
; /* currently identical with 3.0 */
1142 vol
->vals
= &smb302_values
;
1144 #ifdef CONFIG_CIFS_SMB311
1146 vol
->ops
= &smb311_operations
;
1147 vol
->vals
= &smb311_values
;
1151 cifs_dbg(VFS
, "Unknown vers= option specified: %s\n", value
);
1158 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1159 * fields with the result. Returns 0 on success and an error otherwise.
1162 cifs_parse_devname(const char *devname
, struct smb_vol
*vol
)
1165 const char *delims
= "/\\";
1168 /* make sure we have a valid UNC double delimiter prefix */
1169 len
= strspn(devname
, delims
);
1173 /* find delimiter between host and sharename */
1174 pos
= strpbrk(devname
+ 2, delims
);
1178 /* skip past delimiter */
1181 /* now go until next delimiter or end of string */
1182 len
= strcspn(pos
, delims
);
1184 /* move "pos" up to delimiter or NULL */
1186 vol
->UNC
= kstrndup(devname
, pos
- devname
, GFP_KERNEL
);
1190 convert_delimiter(vol
->UNC
, '\\');
1192 /* skip any delimiter */
1193 if (*pos
== '/' || *pos
== '\\')
1196 /* If pos is NULL then no prepath */
1200 vol
->prepath
= kstrdup(pos
, GFP_KERNEL
);
1208 cifs_parse_mount_options(const char *mountdata
, const char *devname
,
1209 struct smb_vol
*vol
)
1212 char *mountdata_copy
= NULL
, *options
;
1213 unsigned int temp_len
, i
, j
;
1215 short int override_uid
= -1;
1216 short int override_gid
= -1;
1217 bool uid_specified
= false;
1218 bool gid_specified
= false;
1219 bool sloppy
= false;
1220 char *invalid
= NULL
;
1221 char *nodename
= utsname()->nodename
;
1222 char *string
= NULL
;
1223 char *tmp_end
, *value
;
1225 bool got_ip
= false;
1226 bool got_version
= false;
1227 unsigned short port
= 0;
1228 struct sockaddr
*dstaddr
= (struct sockaddr
*)&vol
->dstaddr
;
1232 delim
= separator
[0];
1234 /* ensure we always start with zeroed-out smb_vol */
1235 memset(vol
, 0, sizeof(*vol
));
1238 * does not have to be perfect mapping since field is
1239 * informational, only used for servers that do not support
1240 * port 445 and it can be overridden at mount time
1242 memset(vol
->source_rfc1001_name
, 0x20, RFC1001_NAME_LEN
);
1243 for (i
= 0; i
< strnlen(nodename
, RFC1001_NAME_LEN
); i
++)
1244 vol
->source_rfc1001_name
[i
] = toupper(nodename
[i
]);
1246 vol
->source_rfc1001_name
[RFC1001_NAME_LEN
] = 0;
1247 /* null target name indicates to use *SMBSERVR default called name
1248 if we end up sending RFC1001 session initialize */
1249 vol
->target_rfc1001_name
[0] = 0;
1250 vol
->cred_uid
= current_uid();
1251 vol
->linux_uid
= current_uid();
1252 vol
->linux_gid
= current_gid();
1255 * default to SFM style remapping of seven reserved characters
1256 * unless user overrides it or we negotiate CIFS POSIX where
1257 * it is unnecessary. Can not simultaneously use more than one mapping
1258 * since then readdir could list files that open could not open
1262 /* default to only allowing write access to owner of the mount */
1263 vol
->dir_mode
= vol
->file_mode
= S_IRUGO
| S_IXUGO
| S_IWUSR
;
1265 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1266 /* default is always to request posix paths. */
1267 vol
->posix_paths
= 1;
1268 /* default to using server inode numbers where available */
1269 vol
->server_ino
= 1;
1271 /* default is to use strict cifs caching semantics */
1272 vol
->strict_io
= true;
1274 vol
->actimeo
= CIFS_DEF_ACTIMEO
;
1276 /* FIXME: add autonegotiation for SMB3 or later rather than just SMB3 */
1277 vol
->ops
= &smb30_operations
; /* both secure and accepted widely */
1278 vol
->vals
= &smb30_values
;
1280 vol
->echo_interval
= SMB_ECHO_INTERVAL_DEFAULT
;
1283 goto cifs_parse_mount_err
;
1285 mountdata_copy
= kstrndup(mountdata
, PAGE_SIZE
, GFP_KERNEL
);
1286 if (!mountdata_copy
)
1287 goto cifs_parse_mount_err
;
1289 options
= mountdata_copy
;
1290 end
= options
+ strlen(options
);
1292 if (strncmp(options
, "sep=", 4) == 0) {
1293 if (options
[4] != 0) {
1294 separator
[0] = options
[4];
1297 cifs_dbg(FYI
, "Null separator not allowed\n");
1300 vol
->backupuid_specified
= false; /* no backup intent for a user */
1301 vol
->backupgid_specified
= false; /* no backup intent for a group */
1303 switch (cifs_parse_devname(devname
, vol
)) {
1307 cifs_dbg(VFS
, "Unable to allocate memory for devname.\n");
1308 goto cifs_parse_mount_err
;
1310 cifs_dbg(VFS
, "Malformed UNC in devname.\n");
1311 goto cifs_parse_mount_err
;
1313 cifs_dbg(VFS
, "Unknown error parsing devname.\n");
1314 goto cifs_parse_mount_err
;
1317 while ((data
= strsep(&options
, separator
)) != NULL
) {
1318 substring_t args
[MAX_OPT_ARGS
];
1319 unsigned long option
;
1325 token
= match_token(data
, cifs_mount_option_tokens
, args
);
1329 /* Ingnore the following */
1333 /* Boolean values */
1334 case Opt_user_xattr
:
1337 case Opt_nouser_xattr
:
1343 case Opt_noforceuid
:
1349 case Opt_noforcegid
:
1352 case Opt_noblocksend
:
1353 vol
->noblocksnd
= 1;
1355 case Opt_noautotune
:
1356 vol
->noautotune
= 1;
1371 vol
->sfu_remap
= true;
1372 vol
->remap
= false; /* disable SFM mapping */
1374 case Opt_nomapchars
:
1375 vol
->sfu_remap
= false;
1379 vol
->sfu_remap
= false; /* disable SFU mapping */
1381 case Opt_nomapposix
:
1393 case Opt_posixpaths
:
1394 vol
->posix_paths
= 1;
1396 case Opt_noposixpaths
:
1397 vol
->posix_paths
= 0;
1400 vol
->no_linux_ext
= 1;
1411 * turn off mandatory locking in mode
1412 * if remote locking is turned off since the
1413 * local vfs will do advisory
1415 if (vol
->file_mode
==
1416 (S_IALLUGO
& ~(S_ISUID
| S_IXGRP
)))
1417 vol
->file_mode
= S_IALLUGO
;
1419 case Opt_forcemandatorylock
:
1428 case Opt_setuidfromacl
:
1429 vol
->setuidfromacl
= 1;
1432 vol
->dynperm
= true;
1435 vol
->dynperm
= false;
1449 case Opt_nostrictsync
:
1450 vol
->nostrictsync
= 1;
1452 case Opt_strictsync
:
1453 vol
->nostrictsync
= 0;
1456 vol
->server_ino
= 1;
1458 case Opt_noserverino
:
1459 vol
->server_ino
= 0;
1461 case Opt_rwpidforward
:
1462 vol
->rwpidforward
= 1;
1471 vol
->no_psx_acl
= 0;
1474 vol
->no_psx_acl
= 1;
1476 case Opt_locallease
:
1477 vol
->local_lease
= 1;
1483 /* we do not do the following in secFlags because seal
1484 * is a per tree connection (mount) not a per socket
1485 * or per-smb connection option in the protocol
1486 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1491 pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1494 #ifndef CONFIG_CIFS_FSCACHE
1495 cifs_dbg(VFS
, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1496 goto cifs_parse_mount_err
;
1500 case Opt_mfsymlinks
:
1501 vol
->mfsymlinks
= true;
1504 vol
->multiuser
= true;
1509 case Opt_nosharesock
:
1510 vol
->nosharesock
= true;
1512 case Opt_nopersistent
:
1513 vol
->nopersistent
= true;
1514 if (vol
->persistent
) {
1516 "persistenthandles mount options conflict\n");
1517 goto cifs_parse_mount_err
;
1520 case Opt_persistent
:
1521 vol
->persistent
= true;
1522 if ((vol
->nopersistent
) || (vol
->resilient
)) {
1524 "persistenthandles mount options conflict\n");
1525 goto cifs_parse_mount_err
;
1529 vol
->resilient
= true;
1530 if (vol
->persistent
) {
1532 "persistenthandles mount options conflict\n");
1533 goto cifs_parse_mount_err
;
1536 case Opt_noresilient
:
1537 vol
->resilient
= false; /* already the default */
1539 case Opt_domainauto
:
1540 vol
->domainauto
= true;
1543 /* Numeric Values */
1545 if (get_option_uid(args
, &vol
->backupuid
)) {
1546 cifs_dbg(VFS
, "%s: Invalid backupuid value\n",
1548 goto cifs_parse_mount_err
;
1550 vol
->backupuid_specified
= true;
1553 if (get_option_gid(args
, &vol
->backupgid
)) {
1554 cifs_dbg(VFS
, "%s: Invalid backupgid value\n",
1556 goto cifs_parse_mount_err
;
1558 vol
->backupgid_specified
= true;
1561 if (get_option_uid(args
, &vol
->linux_uid
)) {
1562 cifs_dbg(VFS
, "%s: Invalid uid value\n",
1564 goto cifs_parse_mount_err
;
1566 uid_specified
= true;
1569 if (get_option_uid(args
, &vol
->cred_uid
)) {
1570 cifs_dbg(VFS
, "%s: Invalid cruid value\n",
1572 goto cifs_parse_mount_err
;
1576 if (get_option_gid(args
, &vol
->linux_gid
)) {
1577 cifs_dbg(VFS
, "%s: Invalid gid value\n",
1579 goto cifs_parse_mount_err
;
1581 gid_specified
= true;
1584 if (get_option_ul(args
, &option
)) {
1585 cifs_dbg(VFS
, "%s: Invalid file_mode value\n",
1587 goto cifs_parse_mount_err
;
1589 vol
->file_mode
= option
;
1592 if (get_option_ul(args
, &option
)) {
1593 cifs_dbg(VFS
, "%s: Invalid dir_mode value\n",
1595 goto cifs_parse_mount_err
;
1597 vol
->dir_mode
= option
;
1600 if (get_option_ul(args
, &option
) ||
1601 option
> USHRT_MAX
) {
1602 cifs_dbg(VFS
, "%s: Invalid port value\n",
1604 goto cifs_parse_mount_err
;
1606 port
= (unsigned short)option
;
1609 if (get_option_ul(args
, &option
)) {
1610 cifs_dbg(VFS
, "%s: Invalid rsize value\n",
1612 goto cifs_parse_mount_err
;
1614 vol
->rsize
= option
;
1617 if (get_option_ul(args
, &option
)) {
1618 cifs_dbg(VFS
, "%s: Invalid wsize value\n",
1620 goto cifs_parse_mount_err
;
1622 vol
->wsize
= option
;
1625 if (get_option_ul(args
, &option
)) {
1626 cifs_dbg(VFS
, "%s: Invalid actimeo value\n",
1628 goto cifs_parse_mount_err
;
1630 vol
->actimeo
= HZ
* option
;
1631 if (vol
->actimeo
> CIFS_MAX_ACTIMEO
) {
1632 cifs_dbg(VFS
, "attribute cache timeout too large\n");
1633 goto cifs_parse_mount_err
;
1636 case Opt_echo_interval
:
1637 if (get_option_ul(args
, &option
)) {
1638 cifs_dbg(VFS
, "%s: Invalid echo interval value\n",
1640 goto cifs_parse_mount_err
;
1642 vol
->echo_interval
= option
;
1645 if (get_option_ul(args
, &option
)) {
1646 cifs_dbg(VFS
, "%s: Invalid snapshot time\n",
1648 goto cifs_parse_mount_err
;
1650 vol
->snapshot_time
= option
;
1652 case Opt_max_credits
:
1653 if (get_option_ul(args
, &option
) || (option
< 20) ||
1655 cifs_dbg(VFS
, "%s: Invalid max_credits value\n",
1657 goto cifs_parse_mount_err
;
1659 vol
->max_credits
= option
;
1662 /* String Arguments */
1664 case Opt_blank_user
:
1665 /* null user, ie. anonymous authentication */
1667 vol
->username
= NULL
;
1670 string
= match_strdup(args
);
1674 if (strnlen(string
, CIFS_MAX_USERNAME_LEN
) >
1675 CIFS_MAX_USERNAME_LEN
) {
1676 pr_warn("CIFS: username too long\n");
1677 goto cifs_parse_mount_err
;
1680 kfree(vol
->username
);
1681 vol
->username
= kstrdup(string
, GFP_KERNEL
);
1683 goto cifs_parse_mount_err
;
1685 case Opt_blank_pass
:
1686 /* passwords have to be handled differently
1687 * to allow the character used for deliminator
1688 * to be passed within them
1692 * Check if this is a case where the password
1693 * starts with a delimiter
1695 tmp_end
= strchr(data
, '=');
1697 if (!(tmp_end
< end
&& tmp_end
[1] == delim
)) {
1698 /* No it is not. Set the password to NULL */
1699 kfree(vol
->password
);
1700 vol
->password
= NULL
;
1703 /* Yes it is. Drop down to Opt_pass below.*/
1705 /* Obtain the value string */
1706 value
= strchr(data
, '=');
1709 /* Set tmp_end to end of the string */
1710 tmp_end
= (char *) value
+ strlen(value
);
1712 /* Check if following character is the deliminator
1713 * If yes, we have encountered a double deliminator
1714 * reset the NULL character to the deliminator
1716 if (tmp_end
< end
&& tmp_end
[1] == delim
) {
1719 /* Keep iterating until we get to a single
1720 * deliminator OR the end
1722 while ((tmp_end
= strchr(tmp_end
, delim
))
1723 != NULL
&& (tmp_end
[1] == delim
)) {
1724 tmp_end
= (char *) &tmp_end
[2];
1727 /* Reset var options to point to next element */
1730 options
= (char *) &tmp_end
[1];
1732 /* Reached the end of the mount option
1737 kfree(vol
->password
);
1738 /* Now build new password string */
1739 temp_len
= strlen(value
);
1740 vol
->password
= kzalloc(temp_len
+1, GFP_KERNEL
);
1741 if (vol
->password
== NULL
) {
1742 pr_warn("CIFS: no memory for password\n");
1743 goto cifs_parse_mount_err
;
1746 for (i
= 0, j
= 0; i
< temp_len
; i
++, j
++) {
1747 vol
->password
[j
] = value
[i
];
1748 if ((value
[i
] == delim
) &&
1749 value
[i
+1] == delim
)
1750 /* skip the second deliminator */
1753 vol
->password
[j
] = '\0';
1756 /* FIXME: should this be an error instead? */
1760 string
= match_strdup(args
);
1764 if (!cifs_convert_address(dstaddr
, string
,
1766 pr_err("CIFS: bad ip= option (%s).\n", string
);
1767 goto cifs_parse_mount_err
;
1772 string
= match_strdup(args
);
1776 if (strnlen(string
, CIFS_MAX_DOMAINNAME_LEN
)
1777 == CIFS_MAX_DOMAINNAME_LEN
) {
1778 pr_warn("CIFS: domain name too long\n");
1779 goto cifs_parse_mount_err
;
1782 kfree(vol
->domainname
);
1783 vol
->domainname
= kstrdup(string
, GFP_KERNEL
);
1784 if (!vol
->domainname
) {
1785 pr_warn("CIFS: no memory for domainname\n");
1786 goto cifs_parse_mount_err
;
1788 cifs_dbg(FYI
, "Domain name set\n");
1791 string
= match_strdup(args
);
1795 if (!cifs_convert_address(
1796 (struct sockaddr
*)&vol
->srcaddr
,
1797 string
, strlen(string
))) {
1798 pr_warn("CIFS: Could not parse srcaddr: %s\n",
1800 goto cifs_parse_mount_err
;
1804 string
= match_strdup(args
);
1808 if (strnlen(string
, 1024) >= 65) {
1809 pr_warn("CIFS: iocharset name too long.\n");
1810 goto cifs_parse_mount_err
;
1813 if (strncasecmp(string
, "default", 7) != 0) {
1814 kfree(vol
->iocharset
);
1815 vol
->iocharset
= kstrdup(string
,
1817 if (!vol
->iocharset
) {
1818 pr_warn("CIFS: no memory for charset\n");
1819 goto cifs_parse_mount_err
;
1822 /* if iocharset not set then load_nls_default
1825 cifs_dbg(FYI
, "iocharset set to %s\n", string
);
1827 case Opt_netbiosname
:
1828 string
= match_strdup(args
);
1832 memset(vol
->source_rfc1001_name
, 0x20,
1835 * FIXME: are there cases in which a comma can
1836 * be valid in workstation netbios name (and
1837 * need special handling)?
1839 for (i
= 0; i
< RFC1001_NAME_LEN
; i
++) {
1840 /* don't ucase netbiosname for user */
1843 vol
->source_rfc1001_name
[i
] = string
[i
];
1845 /* The string has 16th byte zero still from
1846 * set at top of the function
1848 if (i
== RFC1001_NAME_LEN
&& string
[i
] != 0)
1849 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
1852 /* servernetbiosname specified override *SMBSERVER */
1853 string
= match_strdup(args
);
1857 /* last byte, type, is 0x20 for servr type */
1858 memset(vol
->target_rfc1001_name
, 0x20,
1859 RFC1001_NAME_LEN_WITH_NULL
);
1861 /* BB are there cases in which a comma can be
1862 valid in this workstation netbios name
1863 (and need special handling)? */
1865 /* user or mount helper must uppercase the
1867 for (i
= 0; i
< 15; i
++) {
1870 vol
->target_rfc1001_name
[i
] = string
[i
];
1872 /* The string has 16th byte zero still from
1873 set at top of the function */
1874 if (i
== RFC1001_NAME_LEN
&& string
[i
] != 0)
1875 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
1878 /* version of mount userspace tools, not dialect */
1879 string
= match_strdup(args
);
1883 /* If interface changes in mount.cifs bump to new ver */
1884 if (strncasecmp(string
, "1", 1) == 0) {
1885 if (strlen(string
) > 1) {
1886 pr_warn("Bad mount helper ver=%s. Did "
1887 "you want SMB1 (CIFS) dialect "
1888 "and mean to type vers=1.0 "
1889 "instead?\n", string
);
1890 goto cifs_parse_mount_err
;
1892 /* This is the default */
1895 /* For all other value, error */
1896 pr_warn("CIFS: Invalid mount helper version specified\n");
1897 goto cifs_parse_mount_err
;
1899 /* protocol version (dialect) */
1900 string
= match_strdup(args
);
1904 if (cifs_parse_smb_version(string
, vol
) != 0)
1905 goto cifs_parse_mount_err
;
1909 string
= match_strdup(args
);
1913 if (cifs_parse_security_flavors(string
, vol
) != 0)
1914 goto cifs_parse_mount_err
;
1917 string
= match_strdup(args
);
1921 if (cifs_parse_cache_flavor(string
, vol
) != 0)
1922 goto cifs_parse_mount_err
;
1926 * An option we don't recognize. Save it off for later
1927 * if we haven't already found one
1933 /* Free up any allocated string */
1938 if (!sloppy
&& invalid
) {
1939 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid
);
1940 goto cifs_parse_mount_err
;
1944 /* Muliuser mounts require CONFIG_KEYS support */
1945 if (vol
->multiuser
) {
1946 cifs_dbg(VFS
, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
1947 goto cifs_parse_mount_err
;
1951 cifs_dbg(VFS
, "CIFS mount error: No usable UNC path provided in device string!\n");
1952 goto cifs_parse_mount_err
;
1955 /* make sure UNC has a share name */
1956 if (!strchr(vol
->UNC
+ 3, '\\')) {
1957 cifs_dbg(VFS
, "Malformed UNC. Unable to find share name.\n");
1958 goto cifs_parse_mount_err
;
1965 /* No ip= option specified? Try to get it from UNC */
1966 /* Use the address part of the UNC. */
1967 slash
= strchr(&vol
->UNC
[2], '\\');
1968 len
= slash
- &vol
->UNC
[2];
1969 if (!cifs_convert_address(dstaddr
, &vol
->UNC
[2], len
)) {
1970 pr_err("Unable to determine destination address.\n");
1971 goto cifs_parse_mount_err
;
1975 /* set the port that we got earlier */
1976 cifs_set_port(dstaddr
, port
);
1979 vol
->override_uid
= override_uid
;
1980 else if (override_uid
== 1)
1981 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
1984 vol
->override_gid
= override_gid
;
1985 else if (override_gid
== 1)
1986 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
1988 if (got_version
== false)
1989 pr_warn("No dialect specified on mount. Default has changed to "
1990 "a more secure dialect, SMB3 (vers=3.0), from CIFS "
1991 "(SMB1). To use the less secure SMB1 dialect to access "
1992 "old servers which do not support SMB3 specify vers=1.0"
1993 " on mount. For somewhat newer servers such as Windows "
1994 "7 try vers=2.1.\n");
1996 kfree(mountdata_copy
);
2000 pr_warn("Could not allocate temporary buffer\n");
2001 cifs_parse_mount_err
:
2003 kfree(mountdata_copy
);
2007 /** Returns true if srcaddr isn't specified and rhs isn't
2008 * specified, or if srcaddr is specified and
2009 * matches the IP address of the rhs argument.
2012 srcip_matches(struct sockaddr
*srcaddr
, struct sockaddr
*rhs
)
2014 switch (srcaddr
->sa_family
) {
2016 return (rhs
->sa_family
== AF_UNSPEC
);
2018 struct sockaddr_in
*saddr4
= (struct sockaddr_in
*)srcaddr
;
2019 struct sockaddr_in
*vaddr4
= (struct sockaddr_in
*)rhs
;
2020 return (saddr4
->sin_addr
.s_addr
== vaddr4
->sin_addr
.s_addr
);
2023 struct sockaddr_in6
*saddr6
= (struct sockaddr_in6
*)srcaddr
;
2024 struct sockaddr_in6
*vaddr6
= (struct sockaddr_in6
*)rhs
;
2025 return ipv6_addr_equal(&saddr6
->sin6_addr
, &vaddr6
->sin6_addr
);
2029 return false; /* don't expect to be here */
2034 * If no port is specified in addr structure, we try to match with 445 port
2035 * and if it fails - with 139 ports. It should be called only if address
2036 * families of server and addr are equal.
2039 match_port(struct TCP_Server_Info
*server
, struct sockaddr
*addr
)
2041 __be16 port
, *sport
;
2043 switch (addr
->sa_family
) {
2045 sport
= &((struct sockaddr_in
*) &server
->dstaddr
)->sin_port
;
2046 port
= ((struct sockaddr_in
*) addr
)->sin_port
;
2049 sport
= &((struct sockaddr_in6
*) &server
->dstaddr
)->sin6_port
;
2050 port
= ((struct sockaddr_in6
*) addr
)->sin6_port
;
2058 port
= htons(CIFS_PORT
);
2062 port
= htons(RFC1001_PORT
);
2065 return port
== *sport
;
2069 match_address(struct TCP_Server_Info
*server
, struct sockaddr
*addr
,
2070 struct sockaddr
*srcaddr
)
2072 switch (addr
->sa_family
) {
2074 struct sockaddr_in
*addr4
= (struct sockaddr_in
*)addr
;
2075 struct sockaddr_in
*srv_addr4
=
2076 (struct sockaddr_in
*)&server
->dstaddr
;
2078 if (addr4
->sin_addr
.s_addr
!= srv_addr4
->sin_addr
.s_addr
)
2083 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)addr
;
2084 struct sockaddr_in6
*srv_addr6
=
2085 (struct sockaddr_in6
*)&server
->dstaddr
;
2087 if (!ipv6_addr_equal(&addr6
->sin6_addr
,
2088 &srv_addr6
->sin6_addr
))
2090 if (addr6
->sin6_scope_id
!= srv_addr6
->sin6_scope_id
)
2096 return false; /* don't expect to be here */
2099 if (!srcip_matches(srcaddr
, (struct sockaddr
*)&server
->srcaddr
))
2106 match_security(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
2109 * The select_sectype function should either return the vol->sectype
2110 * that was specified, or "Unspecified" if that sectype was not
2111 * compatible with the given NEGOTIATE request.
2113 if (server
->ops
->select_sectype(server
, vol
->sectype
)
2118 * Now check if signing mode is acceptable. No need to check
2119 * global_secflags at this point since if MUST_SIGN is set then
2120 * the server->sign had better be too.
2122 if (vol
->sign
&& !server
->sign
)
2128 static int match_server(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
2130 struct sockaddr
*addr
= (struct sockaddr
*)&vol
->dstaddr
;
2132 if (vol
->nosharesock
)
2135 if ((server
->vals
!= vol
->vals
) || (server
->ops
!= vol
->ops
))
2138 if (!net_eq(cifs_net_ns(server
), current
->nsproxy
->net_ns
))
2141 if (!match_address(server
, addr
,
2142 (struct sockaddr
*)&vol
->srcaddr
))
2145 if (!match_port(server
, addr
))
2148 if (!match_security(server
, vol
))
2151 if (server
->echo_interval
!= vol
->echo_interval
* HZ
)
2157 static struct TCP_Server_Info
*
2158 cifs_find_tcp_session(struct smb_vol
*vol
)
2160 struct TCP_Server_Info
*server
;
2162 spin_lock(&cifs_tcp_ses_lock
);
2163 list_for_each_entry(server
, &cifs_tcp_ses_list
, tcp_ses_list
) {
2164 if (!match_server(server
, vol
))
2167 ++server
->srv_count
;
2168 spin_unlock(&cifs_tcp_ses_lock
);
2169 cifs_dbg(FYI
, "Existing tcp session with server found\n");
2172 spin_unlock(&cifs_tcp_ses_lock
);
2177 cifs_put_tcp_session(struct TCP_Server_Info
*server
, int from_reconnect
)
2179 struct task_struct
*task
;
2181 spin_lock(&cifs_tcp_ses_lock
);
2182 if (--server
->srv_count
> 0) {
2183 spin_unlock(&cifs_tcp_ses_lock
);
2187 put_net(cifs_net_ns(server
));
2189 list_del_init(&server
->tcp_ses_list
);
2190 spin_unlock(&cifs_tcp_ses_lock
);
2192 cancel_delayed_work_sync(&server
->echo
);
2196 * Avoid deadlock here: reconnect work calls
2197 * cifs_put_tcp_session() at its end. Need to be sure
2198 * that reconnect work does nothing with server pointer after
2201 cancel_delayed_work(&server
->reconnect
);
2203 cancel_delayed_work_sync(&server
->reconnect
);
2205 spin_lock(&GlobalMid_Lock
);
2206 server
->tcpStatus
= CifsExiting
;
2207 spin_unlock(&GlobalMid_Lock
);
2209 cifs_crypto_secmech_release(server
);
2210 cifs_fscache_release_client_cookie(server
);
2212 kfree(server
->session_key
.response
);
2213 server
->session_key
.response
= NULL
;
2214 server
->session_key
.len
= 0;
2216 task
= xchg(&server
->tsk
, NULL
);
2218 force_sig(SIGKILL
, task
);
2221 static struct TCP_Server_Info
*
2222 cifs_get_tcp_session(struct smb_vol
*volume_info
)
2224 struct TCP_Server_Info
*tcp_ses
= NULL
;
2227 cifs_dbg(FYI
, "UNC: %s\n", volume_info
->UNC
);
2229 /* see if we already have a matching tcp_ses */
2230 tcp_ses
= cifs_find_tcp_session(volume_info
);
2234 tcp_ses
= kzalloc(sizeof(struct TCP_Server_Info
), GFP_KERNEL
);
2240 tcp_ses
->ops
= volume_info
->ops
;
2241 tcp_ses
->vals
= volume_info
->vals
;
2242 cifs_set_net_ns(tcp_ses
, get_net(current
->nsproxy
->net_ns
));
2243 tcp_ses
->hostname
= extract_hostname(volume_info
->UNC
);
2244 if (IS_ERR(tcp_ses
->hostname
)) {
2245 rc
= PTR_ERR(tcp_ses
->hostname
);
2246 goto out_err_crypto_release
;
2249 tcp_ses
->noblocksnd
= volume_info
->noblocksnd
;
2250 tcp_ses
->noautotune
= volume_info
->noautotune
;
2251 tcp_ses
->tcp_nodelay
= volume_info
->sockopt_tcp_nodelay
;
2252 tcp_ses
->in_flight
= 0;
2253 tcp_ses
->credits
= 1;
2254 init_waitqueue_head(&tcp_ses
->response_q
);
2255 init_waitqueue_head(&tcp_ses
->request_q
);
2256 INIT_LIST_HEAD(&tcp_ses
->pending_mid_q
);
2257 mutex_init(&tcp_ses
->srv_mutex
);
2258 memcpy(tcp_ses
->workstation_RFC1001_name
,
2259 volume_info
->source_rfc1001_name
, RFC1001_NAME_LEN_WITH_NULL
);
2260 memcpy(tcp_ses
->server_RFC1001_name
,
2261 volume_info
->target_rfc1001_name
, RFC1001_NAME_LEN_WITH_NULL
);
2262 tcp_ses
->session_estab
= false;
2263 tcp_ses
->sequence_number
= 0;
2264 tcp_ses
->lstrp
= jiffies
;
2265 spin_lock_init(&tcp_ses
->req_lock
);
2266 INIT_LIST_HEAD(&tcp_ses
->tcp_ses_list
);
2267 INIT_LIST_HEAD(&tcp_ses
->smb_ses_list
);
2268 INIT_DELAYED_WORK(&tcp_ses
->echo
, cifs_echo_request
);
2269 INIT_DELAYED_WORK(&tcp_ses
->reconnect
, smb2_reconnect_server
);
2270 mutex_init(&tcp_ses
->reconnect_mutex
);
2271 memcpy(&tcp_ses
->srcaddr
, &volume_info
->srcaddr
,
2272 sizeof(tcp_ses
->srcaddr
));
2273 memcpy(&tcp_ses
->dstaddr
, &volume_info
->dstaddr
,
2274 sizeof(tcp_ses
->dstaddr
));
2275 generate_random_uuid(tcp_ses
->client_guid
);
2277 * at this point we are the only ones with the pointer
2278 * to the struct since the kernel thread not created yet
2279 * no need to spinlock this init of tcpStatus or srv_count
2281 tcp_ses
->tcpStatus
= CifsNew
;
2282 ++tcp_ses
->srv_count
;
2284 if (volume_info
->echo_interval
>= SMB_ECHO_INTERVAL_MIN
&&
2285 volume_info
->echo_interval
<= SMB_ECHO_INTERVAL_MAX
)
2286 tcp_ses
->echo_interval
= volume_info
->echo_interval
* HZ
;
2288 tcp_ses
->echo_interval
= SMB_ECHO_INTERVAL_DEFAULT
* HZ
;
2290 rc
= ip_connect(tcp_ses
);
2292 cifs_dbg(VFS
, "Error connecting to socket. Aborting operation.\n");
2293 goto out_err_crypto_release
;
2297 * since we're in a cifs function already, we know that
2298 * this will succeed. No need for try_module_get().
2300 __module_get(THIS_MODULE
);
2301 tcp_ses
->tsk
= kthread_run(cifs_demultiplex_thread
,
2303 if (IS_ERR(tcp_ses
->tsk
)) {
2304 rc
= PTR_ERR(tcp_ses
->tsk
);
2305 cifs_dbg(VFS
, "error %d create cifsd thread\n", rc
);
2306 module_put(THIS_MODULE
);
2307 goto out_err_crypto_release
;
2309 tcp_ses
->tcpStatus
= CifsNeedNegotiate
;
2311 /* thread spawned, put it on the list */
2312 spin_lock(&cifs_tcp_ses_lock
);
2313 list_add(&tcp_ses
->tcp_ses_list
, &cifs_tcp_ses_list
);
2314 spin_unlock(&cifs_tcp_ses_lock
);
2316 cifs_fscache_get_client_cookie(tcp_ses
);
2318 /* queue echo request delayed work */
2319 queue_delayed_work(cifsiod_wq
, &tcp_ses
->echo
, tcp_ses
->echo_interval
);
2323 out_err_crypto_release
:
2324 cifs_crypto_secmech_release(tcp_ses
);
2326 put_net(cifs_net_ns(tcp_ses
));
2330 if (!IS_ERR(tcp_ses
->hostname
))
2331 kfree(tcp_ses
->hostname
);
2332 if (tcp_ses
->ssocket
)
2333 sock_release(tcp_ses
->ssocket
);
2339 static int match_session(struct cifs_ses
*ses
, struct smb_vol
*vol
)
2341 if (vol
->sectype
!= Unspecified
&&
2342 vol
->sectype
!= ses
->sectype
)
2345 switch (ses
->sectype
) {
2347 if (!uid_eq(vol
->cred_uid
, ses
->cred_uid
))
2351 /* NULL username means anonymous session */
2352 if (ses
->user_name
== NULL
) {
2358 /* anything else takes username/password */
2359 if (strncmp(ses
->user_name
,
2360 vol
->username
? vol
->username
: "",
2361 CIFS_MAX_USERNAME_LEN
))
2363 if ((vol
->username
&& strlen(vol
->username
) != 0) &&
2364 ses
->password
!= NULL
&&
2365 strncmp(ses
->password
,
2366 vol
->password
? vol
->password
: "",
2367 CIFS_MAX_PASSWORD_LEN
))
2373 static struct cifs_ses
*
2374 cifs_find_smb_ses(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
2376 struct cifs_ses
*ses
;
2378 spin_lock(&cifs_tcp_ses_lock
);
2379 list_for_each_entry(ses
, &server
->smb_ses_list
, smb_ses_list
) {
2380 if (ses
->status
== CifsExiting
)
2382 if (!match_session(ses
, vol
))
2385 spin_unlock(&cifs_tcp_ses_lock
);
2388 spin_unlock(&cifs_tcp_ses_lock
);
2393 cifs_put_smb_ses(struct cifs_ses
*ses
)
2395 unsigned int rc
, xid
;
2396 struct TCP_Server_Info
*server
= ses
->server
;
2398 cifs_dbg(FYI
, "%s: ses_count=%d\n", __func__
, ses
->ses_count
);
2400 spin_lock(&cifs_tcp_ses_lock
);
2401 if (ses
->status
== CifsExiting
) {
2402 spin_unlock(&cifs_tcp_ses_lock
);
2405 if (--ses
->ses_count
> 0) {
2406 spin_unlock(&cifs_tcp_ses_lock
);
2409 if (ses
->status
== CifsGood
)
2410 ses
->status
= CifsExiting
;
2411 spin_unlock(&cifs_tcp_ses_lock
);
2413 if (ses
->status
== CifsExiting
&& server
->ops
->logoff
) {
2415 rc
= server
->ops
->logoff(xid
, ses
);
2417 cifs_dbg(VFS
, "%s: Session Logoff failure rc=%d\n",
2422 spin_lock(&cifs_tcp_ses_lock
);
2423 list_del_init(&ses
->smb_ses_list
);
2424 spin_unlock(&cifs_tcp_ses_lock
);
2427 cifs_put_tcp_session(server
, 0);
2432 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2433 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2435 /* Populate username and pw fields from keyring if possible */
2437 cifs_set_cifscreds(struct smb_vol
*vol
, struct cifs_ses
*ses
)
2440 const char *delim
, *payload
;
2444 struct TCP_Server_Info
*server
= ses
->server
;
2445 struct sockaddr_in
*sa
;
2446 struct sockaddr_in6
*sa6
;
2447 const struct user_key_payload
*upayload
;
2449 desc
= kmalloc(CIFSCREDS_DESC_SIZE
, GFP_KERNEL
);
2453 /* try to find an address key first */
2454 switch (server
->dstaddr
.ss_family
) {
2456 sa
= (struct sockaddr_in
*)&server
->dstaddr
;
2457 sprintf(desc
, "cifs:a:%pI4", &sa
->sin_addr
.s_addr
);
2460 sa6
= (struct sockaddr_in6
*)&server
->dstaddr
;
2461 sprintf(desc
, "cifs:a:%pI6c", &sa6
->sin6_addr
.s6_addr
);
2464 cifs_dbg(FYI
, "Bad ss_family (%hu)\n",
2465 server
->dstaddr
.ss_family
);
2470 cifs_dbg(FYI
, "%s: desc=%s\n", __func__
, desc
);
2471 key
= request_key(&key_type_logon
, desc
, "");
2473 if (!ses
->domainName
) {
2474 cifs_dbg(FYI
, "domainName is NULL\n");
2479 /* didn't work, try to find a domain key */
2480 sprintf(desc
, "cifs:d:%s", ses
->domainName
);
2481 cifs_dbg(FYI
, "%s: desc=%s\n", __func__
, desc
);
2482 key
= request_key(&key_type_logon
, desc
, "");
2489 down_read(&key
->sem
);
2490 upayload
= user_key_payload_locked(key
);
2491 if (IS_ERR_OR_NULL(upayload
)) {
2492 rc
= upayload
? PTR_ERR(upayload
) : -EINVAL
;
2496 /* find first : in payload */
2497 payload
= upayload
->data
;
2498 delim
= strnchr(payload
, upayload
->datalen
, ':');
2499 cifs_dbg(FYI
, "payload=%s\n", payload
);
2501 cifs_dbg(FYI
, "Unable to find ':' in payload (datalen=%d)\n",
2507 len
= delim
- payload
;
2508 if (len
> CIFS_MAX_USERNAME_LEN
|| len
<= 0) {
2509 cifs_dbg(FYI
, "Bad value from username search (len=%zd)\n",
2515 vol
->username
= kstrndup(payload
, len
, GFP_KERNEL
);
2516 if (!vol
->username
) {
2517 cifs_dbg(FYI
, "Unable to allocate %zd bytes for username\n",
2522 cifs_dbg(FYI
, "%s: username=%s\n", __func__
, vol
->username
);
2524 len
= key
->datalen
- (len
+ 1);
2525 if (len
> CIFS_MAX_PASSWORD_LEN
|| len
<= 0) {
2526 cifs_dbg(FYI
, "Bad len for password search (len=%zd)\n", len
);
2528 kfree(vol
->username
);
2529 vol
->username
= NULL
;
2534 vol
->password
= kstrndup(delim
, len
, GFP_KERNEL
);
2535 if (!vol
->password
) {
2536 cifs_dbg(FYI
, "Unable to allocate %zd bytes for password\n",
2539 kfree(vol
->username
);
2540 vol
->username
= NULL
;
2549 cifs_dbg(FYI
, "%s: returning %d\n", __func__
, rc
);
2552 #else /* ! CONFIG_KEYS */
2554 cifs_set_cifscreds(struct smb_vol
*vol
__attribute__((unused
)),
2555 struct cifs_ses
*ses
__attribute__((unused
)))
2559 #endif /* CONFIG_KEYS */
2561 static struct cifs_ses
*
2562 cifs_get_smb_ses(struct TCP_Server_Info
*server
, struct smb_vol
*volume_info
)
2566 struct cifs_ses
*ses
;
2567 struct sockaddr_in
*addr
= (struct sockaddr_in
*)&server
->dstaddr
;
2568 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)&server
->dstaddr
;
2572 ses
= cifs_find_smb_ses(server
, volume_info
);
2574 cifs_dbg(FYI
, "Existing smb sess found (status=%d)\n",
2577 mutex_lock(&ses
->session_mutex
);
2578 rc
= cifs_negotiate_protocol(xid
, ses
);
2580 mutex_unlock(&ses
->session_mutex
);
2581 /* problem -- put our ses reference */
2582 cifs_put_smb_ses(ses
);
2586 if (ses
->need_reconnect
) {
2587 cifs_dbg(FYI
, "Session needs reconnect\n");
2588 rc
= cifs_setup_session(xid
, ses
,
2589 volume_info
->local_nls
);
2591 mutex_unlock(&ses
->session_mutex
);
2592 /* problem -- put our reference */
2593 cifs_put_smb_ses(ses
);
2598 mutex_unlock(&ses
->session_mutex
);
2600 /* existing SMB ses has a server reference already */
2601 cifs_put_tcp_session(server
, 0);
2606 cifs_dbg(FYI
, "Existing smb sess not found\n");
2607 ses
= sesInfoAlloc();
2611 /* new SMB session uses our server ref */
2612 ses
->server
= server
;
2613 if (server
->dstaddr
.ss_family
== AF_INET6
)
2614 sprintf(ses
->serverName
, "%pI6", &addr6
->sin6_addr
);
2616 sprintf(ses
->serverName
, "%pI4", &addr
->sin_addr
);
2618 if (volume_info
->username
) {
2619 ses
->user_name
= kstrdup(volume_info
->username
, GFP_KERNEL
);
2620 if (!ses
->user_name
)
2624 /* volume_info->password freed at unmount */
2625 if (volume_info
->password
) {
2626 ses
->password
= kstrdup(volume_info
->password
, GFP_KERNEL
);
2630 if (volume_info
->domainname
) {
2631 ses
->domainName
= kstrdup(volume_info
->domainname
, GFP_KERNEL
);
2632 if (!ses
->domainName
)
2635 if (volume_info
->domainauto
)
2636 ses
->domainAuto
= volume_info
->domainauto
;
2637 ses
->cred_uid
= volume_info
->cred_uid
;
2638 ses
->linux_uid
= volume_info
->linux_uid
;
2640 ses
->sectype
= volume_info
->sectype
;
2641 ses
->sign
= volume_info
->sign
;
2643 mutex_lock(&ses
->session_mutex
);
2644 rc
= cifs_negotiate_protocol(xid
, ses
);
2646 rc
= cifs_setup_session(xid
, ses
, volume_info
->local_nls
);
2647 mutex_unlock(&ses
->session_mutex
);
2651 /* success, put it on the list */
2652 spin_lock(&cifs_tcp_ses_lock
);
2653 list_add(&ses
->smb_ses_list
, &server
->smb_ses_list
);
2654 spin_unlock(&cifs_tcp_ses_lock
);
2665 static int match_tcon(struct cifs_tcon
*tcon
, struct smb_vol
*volume_info
)
2667 if (tcon
->tidStatus
== CifsExiting
)
2669 if (strncmp(tcon
->treeName
, volume_info
->UNC
, MAX_TREE_SIZE
))
2671 if (tcon
->seal
!= volume_info
->seal
)
2673 if (tcon
->snapshot_time
!= volume_info
->snapshot_time
)
2678 static struct cifs_tcon
*
2679 cifs_find_tcon(struct cifs_ses
*ses
, struct smb_vol
*volume_info
)
2681 struct list_head
*tmp
;
2682 struct cifs_tcon
*tcon
;
2684 spin_lock(&cifs_tcp_ses_lock
);
2685 list_for_each(tmp
, &ses
->tcon_list
) {
2686 tcon
= list_entry(tmp
, struct cifs_tcon
, tcon_list
);
2687 if (!match_tcon(tcon
, volume_info
))
2690 spin_unlock(&cifs_tcp_ses_lock
);
2693 spin_unlock(&cifs_tcp_ses_lock
);
2698 cifs_put_tcon(struct cifs_tcon
*tcon
)
2701 struct cifs_ses
*ses
= tcon
->ses
;
2703 cifs_dbg(FYI
, "%s: tc_count=%d\n", __func__
, tcon
->tc_count
);
2704 spin_lock(&cifs_tcp_ses_lock
);
2705 if (--tcon
->tc_count
> 0) {
2706 spin_unlock(&cifs_tcp_ses_lock
);
2710 list_del_init(&tcon
->tcon_list
);
2711 spin_unlock(&cifs_tcp_ses_lock
);
2714 if (ses
->server
->ops
->tree_disconnect
)
2715 ses
->server
->ops
->tree_disconnect(xid
, tcon
);
2718 cifs_fscache_release_super_cookie(tcon
);
2720 cifs_put_smb_ses(ses
);
2723 static struct cifs_tcon
*
2724 cifs_get_tcon(struct cifs_ses
*ses
, struct smb_vol
*volume_info
)
2727 struct cifs_tcon
*tcon
;
2729 tcon
= cifs_find_tcon(ses
, volume_info
);
2731 cifs_dbg(FYI
, "Found match on UNC path\n");
2732 /* existing tcon already has a reference */
2733 cifs_put_smb_ses(ses
);
2737 if (!ses
->server
->ops
->tree_connect
) {
2742 tcon
= tconInfoAlloc();
2748 if (volume_info
->snapshot_time
) {
2749 if (ses
->server
->vals
->protocol_id
== 0) {
2751 "Use SMB2 or later for snapshot mount option\n");
2755 tcon
->snapshot_time
= volume_info
->snapshot_time
;
2759 if (volume_info
->password
) {
2760 tcon
->password
= kstrdup(volume_info
->password
, GFP_KERNEL
);
2761 if (!tcon
->password
) {
2768 * BB Do we need to wrap session_mutex around this TCon call and Unix
2769 * SetFS as we do on SessSetup and reconnect?
2772 rc
= ses
->server
->ops
->tree_connect(xid
, ses
, volume_info
->UNC
, tcon
,
2773 volume_info
->local_nls
);
2775 cifs_dbg(FYI
, "Tcon rc = %d\n", rc
);
2779 if (volume_info
->nodfs
) {
2780 tcon
->Flags
&= ~SMB_SHARE_IS_IN_DFS
;
2781 cifs_dbg(FYI
, "DFS disabled (%d)\n", tcon
->Flags
);
2783 tcon
->use_persistent
= false;
2784 /* check if SMB2 or later, CIFS does not support persistent handles */
2785 if (volume_info
->persistent
) {
2786 if (ses
->server
->vals
->protocol_id
== 0) {
2788 "SMB3 or later required for persistent handles\n");
2791 } else if (ses
->server
->capabilities
&
2792 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES
)
2793 tcon
->use_persistent
= true;
2794 else /* persistent handles requested but not supported */ {
2796 "Persistent handles not supported on share\n");
2800 } else if ((tcon
->capabilities
& SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY
)
2801 && (ses
->server
->capabilities
& SMB2_GLOBAL_CAP_PERSISTENT_HANDLES
)
2802 && (volume_info
->nopersistent
== false)) {
2803 cifs_dbg(FYI
, "enabling persistent handles\n");
2804 tcon
->use_persistent
= true;
2805 } else if (volume_info
->resilient
) {
2806 if (ses
->server
->vals
->protocol_id
== 0) {
2808 "SMB2.1 or later required for resilient handles\n");
2812 tcon
->use_resilient
= true;
2815 if (volume_info
->seal
) {
2816 if (ses
->server
->vals
->protocol_id
== 0) {
2818 "SMB3 or later required for encryption\n");
2821 } else if (tcon
->ses
->server
->capabilities
&
2822 SMB2_GLOBAL_CAP_ENCRYPTION
)
2825 cifs_dbg(VFS
, "Encryption is not supported on share\n");
2832 * We can have only one retry value for a connection to a share so for
2833 * resources mounted more than once to the same server share the last
2834 * value passed in for the retry flag is used.
2836 tcon
->retry
= volume_info
->retry
;
2837 tcon
->nocase
= volume_info
->nocase
;
2838 tcon
->local_lease
= volume_info
->local_lease
;
2839 INIT_LIST_HEAD(&tcon
->pending_opens
);
2841 spin_lock(&cifs_tcp_ses_lock
);
2842 list_add(&tcon
->tcon_list
, &ses
->tcon_list
);
2843 spin_unlock(&cifs_tcp_ses_lock
);
2845 cifs_fscache_get_super_cookie(tcon
);
2855 cifs_put_tlink(struct tcon_link
*tlink
)
2857 if (!tlink
|| IS_ERR(tlink
))
2860 if (!atomic_dec_and_test(&tlink
->tl_count
) ||
2861 test_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
)) {
2862 tlink
->tl_time
= jiffies
;
2866 if (!IS_ERR(tlink_tcon(tlink
)))
2867 cifs_put_tcon(tlink_tcon(tlink
));
2872 static inline struct tcon_link
*
2873 cifs_sb_master_tlink(struct cifs_sb_info
*cifs_sb
)
2875 return cifs_sb
->master_tlink
;
2879 compare_mount_options(struct super_block
*sb
, struct cifs_mnt_data
*mnt_data
)
2881 struct cifs_sb_info
*old
= CIFS_SB(sb
);
2882 struct cifs_sb_info
*new = mnt_data
->cifs_sb
;
2884 if ((sb
->s_flags
& CIFS_MS_MASK
) != (mnt_data
->flags
& CIFS_MS_MASK
))
2887 if ((old
->mnt_cifs_flags
& CIFS_MOUNT_MASK
) !=
2888 (new->mnt_cifs_flags
& CIFS_MOUNT_MASK
))
2892 * We want to share sb only if we don't specify an r/wsize or
2893 * specified r/wsize is greater than or equal to existing one.
2895 if (new->wsize
&& new->wsize
< old
->wsize
)
2898 if (new->rsize
&& new->rsize
< old
->rsize
)
2901 if (!uid_eq(old
->mnt_uid
, new->mnt_uid
) || !gid_eq(old
->mnt_gid
, new->mnt_gid
))
2904 if (old
->mnt_file_mode
!= new->mnt_file_mode
||
2905 old
->mnt_dir_mode
!= new->mnt_dir_mode
)
2908 if (strcmp(old
->local_nls
->charset
, new->local_nls
->charset
))
2911 if (old
->actimeo
!= new->actimeo
)
2918 match_prepath(struct super_block
*sb
, struct cifs_mnt_data
*mnt_data
)
2920 struct cifs_sb_info
*old
= CIFS_SB(sb
);
2921 struct cifs_sb_info
*new = mnt_data
->cifs_sb
;
2922 bool old_set
= old
->mnt_cifs_flags
& CIFS_MOUNT_USE_PREFIX_PATH
;
2923 bool new_set
= new->mnt_cifs_flags
& CIFS_MOUNT_USE_PREFIX_PATH
;
2925 if (old_set
&& new_set
&& !strcmp(new->prepath
, old
->prepath
))
2927 else if (!old_set
&& !new_set
)
2934 cifs_match_super(struct super_block
*sb
, void *data
)
2936 struct cifs_mnt_data
*mnt_data
= (struct cifs_mnt_data
*)data
;
2937 struct smb_vol
*volume_info
;
2938 struct cifs_sb_info
*cifs_sb
;
2939 struct TCP_Server_Info
*tcp_srv
;
2940 struct cifs_ses
*ses
;
2941 struct cifs_tcon
*tcon
;
2942 struct tcon_link
*tlink
;
2945 spin_lock(&cifs_tcp_ses_lock
);
2946 cifs_sb
= CIFS_SB(sb
);
2947 tlink
= cifs_get_tlink(cifs_sb_master_tlink(cifs_sb
));
2948 if (IS_ERR(tlink
)) {
2949 spin_unlock(&cifs_tcp_ses_lock
);
2952 tcon
= tlink_tcon(tlink
);
2954 tcp_srv
= ses
->server
;
2956 volume_info
= mnt_data
->vol
;
2958 if (!match_server(tcp_srv
, volume_info
) ||
2959 !match_session(ses
, volume_info
) ||
2960 !match_tcon(tcon
, volume_info
) ||
2961 !match_prepath(sb
, mnt_data
)) {
2966 rc
= compare_mount_options(sb
, mnt_data
);
2968 spin_unlock(&cifs_tcp_ses_lock
);
2969 cifs_put_tlink(tlink
);
2974 get_dfs_path(const unsigned int xid
, struct cifs_ses
*ses
, const char *old_path
,
2975 const struct nls_table
*nls_codepage
, unsigned int *num_referrals
,
2976 struct dfs_info3_param
**referrals
, int remap
)
2981 if (!ses
->server
->ops
->tree_connect
|| !ses
->server
->ops
->get_dfs_refer
)
2987 if (ses
->ipc_tid
== 0) {
2988 temp_unc
= kmalloc(2 /* for slashes */ +
2989 strnlen(ses
->serverName
, SERVER_NAME_LEN_WITH_NULL
* 2)
2990 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL
);
2991 if (temp_unc
== NULL
)
2995 strcpy(temp_unc
+ 2, ses
->serverName
);
2996 strcpy(temp_unc
+ 2 + strlen(ses
->serverName
), "\\IPC$");
2997 rc
= ses
->server
->ops
->tree_connect(xid
, ses
, temp_unc
, NULL
,
2999 cifs_dbg(FYI
, "Tcon rc = %d ipc_tid = %d\n", rc
, ses
->ipc_tid
);
3003 rc
= ses
->server
->ops
->get_dfs_refer(xid
, ses
, old_path
,
3004 referrals
, num_referrals
,
3005 nls_codepage
, remap
);
3007 * BB - map targetUNCs to dfs_info3 structures, here or in
3008 * ses->server->ops->get_dfs_refer.
3014 #ifdef CONFIG_DEBUG_LOCK_ALLOC
3015 static struct lock_class_key cifs_key
[2];
3016 static struct lock_class_key cifs_slock_key
[2];
3019 cifs_reclassify_socket4(struct socket
*sock
)
3021 struct sock
*sk
= sock
->sk
;
3022 BUG_ON(!sock_allow_reclassification(sk
));
3023 sock_lock_init_class_and_name(sk
, "slock-AF_INET-CIFS",
3024 &cifs_slock_key
[0], "sk_lock-AF_INET-CIFS", &cifs_key
[0]);
3028 cifs_reclassify_socket6(struct socket
*sock
)
3030 struct sock
*sk
= sock
->sk
;
3031 BUG_ON(!sock_allow_reclassification(sk
));
3032 sock_lock_init_class_and_name(sk
, "slock-AF_INET6-CIFS",
3033 &cifs_slock_key
[1], "sk_lock-AF_INET6-CIFS", &cifs_key
[1]);
3037 cifs_reclassify_socket4(struct socket
*sock
)
3042 cifs_reclassify_socket6(struct socket
*sock
)
3047 /* See RFC1001 section 14 on representation of Netbios names */
3048 static void rfc1002mangle(char *target
, char *source
, unsigned int length
)
3052 for (i
= 0, j
= 0; i
< (length
); i
++) {
3053 /* mask a nibble at a time and encode */
3054 target
[j
] = 'A' + (0x0F & (source
[i
] >> 4));
3055 target
[j
+1] = 'A' + (0x0F & source
[i
]);
3062 bind_socket(struct TCP_Server_Info
*server
)
3065 if (server
->srcaddr
.ss_family
!= AF_UNSPEC
) {
3066 /* Bind to the specified local IP address */
3067 struct socket
*socket
= server
->ssocket
;
3068 rc
= socket
->ops
->bind(socket
,
3069 (struct sockaddr
*) &server
->srcaddr
,
3070 sizeof(server
->srcaddr
));
3072 struct sockaddr_in
*saddr4
;
3073 struct sockaddr_in6
*saddr6
;
3074 saddr4
= (struct sockaddr_in
*)&server
->srcaddr
;
3075 saddr6
= (struct sockaddr_in6
*)&server
->srcaddr
;
3076 if (saddr6
->sin6_family
== AF_INET6
)
3077 cifs_dbg(VFS
, "Failed to bind to: %pI6c, error: %d\n",
3078 &saddr6
->sin6_addr
, rc
);
3080 cifs_dbg(VFS
, "Failed to bind to: %pI4, error: %d\n",
3081 &saddr4
->sin_addr
.s_addr
, rc
);
3088 ip_rfc1001_connect(struct TCP_Server_Info
*server
)
3092 * some servers require RFC1001 sessinit before sending
3093 * negprot - BB check reconnection in case where second
3094 * sessinit is sent but no second negprot
3096 struct rfc1002_session_packet
*ses_init_buf
;
3097 struct smb_hdr
*smb_buf
;
3098 ses_init_buf
= kzalloc(sizeof(struct rfc1002_session_packet
),
3101 ses_init_buf
->trailer
.session_req
.called_len
= 32;
3103 if (server
->server_RFC1001_name
[0] != 0)
3104 rfc1002mangle(ses_init_buf
->trailer
.
3105 session_req
.called_name
,
3106 server
->server_RFC1001_name
,
3107 RFC1001_NAME_LEN_WITH_NULL
);
3109 rfc1002mangle(ses_init_buf
->trailer
.
3110 session_req
.called_name
,
3111 DEFAULT_CIFS_CALLED_NAME
,
3112 RFC1001_NAME_LEN_WITH_NULL
);
3114 ses_init_buf
->trailer
.session_req
.calling_len
= 32;
3117 * calling name ends in null (byte 16) from old smb
3120 if (server
->workstation_RFC1001_name
[0] != 0)
3121 rfc1002mangle(ses_init_buf
->trailer
.
3122 session_req
.calling_name
,
3123 server
->workstation_RFC1001_name
,
3124 RFC1001_NAME_LEN_WITH_NULL
);
3126 rfc1002mangle(ses_init_buf
->trailer
.
3127 session_req
.calling_name
,
3129 RFC1001_NAME_LEN_WITH_NULL
);
3131 ses_init_buf
->trailer
.session_req
.scope1
= 0;
3132 ses_init_buf
->trailer
.session_req
.scope2
= 0;
3133 smb_buf
= (struct smb_hdr
*)ses_init_buf
;
3135 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3136 smb_buf
->smb_buf_length
= cpu_to_be32(0x81000044);
3137 rc
= smb_send(server
, smb_buf
, 0x44);
3138 kfree(ses_init_buf
);
3140 * RFC1001 layer in at least one server
3141 * requires very short break before negprot
3142 * presumably because not expecting negprot
3143 * to follow so fast. This is a simple
3144 * solution that works without
3145 * complicating the code and causes no
3146 * significant slowing down on mount
3149 usleep_range(1000, 2000);
3152 * else the negprot may still work without this
3153 * even though malloc failed
3160 generic_ip_connect(struct TCP_Server_Info
*server
)
3165 struct socket
*socket
= server
->ssocket
;
3166 struct sockaddr
*saddr
;
3168 saddr
= (struct sockaddr
*) &server
->dstaddr
;
3170 if (server
->dstaddr
.ss_family
== AF_INET6
) {
3171 sport
= ((struct sockaddr_in6
*) saddr
)->sin6_port
;
3172 slen
= sizeof(struct sockaddr_in6
);
3175 sport
= ((struct sockaddr_in
*) saddr
)->sin_port
;
3176 slen
= sizeof(struct sockaddr_in
);
3180 if (socket
== NULL
) {
3181 rc
= __sock_create(cifs_net_ns(server
), sfamily
, SOCK_STREAM
,
3182 IPPROTO_TCP
, &socket
, 1);
3184 cifs_dbg(VFS
, "Error %d creating socket\n", rc
);
3185 server
->ssocket
= NULL
;
3189 /* BB other socket options to set KEEPALIVE, NODELAY? */
3190 cifs_dbg(FYI
, "Socket created\n");
3191 server
->ssocket
= socket
;
3192 socket
->sk
->sk_allocation
= GFP_NOFS
;
3193 if (sfamily
== AF_INET6
)
3194 cifs_reclassify_socket6(socket
);
3196 cifs_reclassify_socket4(socket
);
3199 rc
= bind_socket(server
);
3204 * Eventually check for other socket options to change from
3205 * the default. sock_setsockopt not used because it expects
3208 socket
->sk
->sk_rcvtimeo
= 7 * HZ
;
3209 socket
->sk
->sk_sndtimeo
= 5 * HZ
;
3211 /* make the bufsizes depend on wsize/rsize and max requests */
3212 if (server
->noautotune
) {
3213 if (socket
->sk
->sk_sndbuf
< (200 * 1024))
3214 socket
->sk
->sk_sndbuf
= 200 * 1024;
3215 if (socket
->sk
->sk_rcvbuf
< (140 * 1024))
3216 socket
->sk
->sk_rcvbuf
= 140 * 1024;
3219 if (server
->tcp_nodelay
) {
3221 rc
= kernel_setsockopt(socket
, SOL_TCP
, TCP_NODELAY
,
3222 (char *)&val
, sizeof(val
));
3224 cifs_dbg(FYI
, "set TCP_NODELAY socket option error %d\n",
3228 cifs_dbg(FYI
, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3229 socket
->sk
->sk_sndbuf
,
3230 socket
->sk
->sk_rcvbuf
, socket
->sk
->sk_rcvtimeo
);
3232 rc
= socket
->ops
->connect(socket
, saddr
, slen
, 0);
3234 cifs_dbg(FYI
, "Error %d connecting to server\n", rc
);
3235 sock_release(socket
);
3236 server
->ssocket
= NULL
;
3240 if (sport
== htons(RFC1001_PORT
))
3241 rc
= ip_rfc1001_connect(server
);
3247 ip_connect(struct TCP_Server_Info
*server
)
3250 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)&server
->dstaddr
;
3251 struct sockaddr_in
*addr
= (struct sockaddr_in
*)&server
->dstaddr
;
3253 if (server
->dstaddr
.ss_family
== AF_INET6
)
3254 sport
= &addr6
->sin6_port
;
3256 sport
= &addr
->sin_port
;
3261 /* try with 445 port at first */
3262 *sport
= htons(CIFS_PORT
);
3264 rc
= generic_ip_connect(server
);
3268 /* if it failed, try with 139 port */
3269 *sport
= htons(RFC1001_PORT
);
3272 return generic_ip_connect(server
);
3275 void reset_cifs_unix_caps(unsigned int xid
, struct cifs_tcon
*tcon
,
3276 struct cifs_sb_info
*cifs_sb
, struct smb_vol
*vol_info
)
3278 /* if we are reconnecting then should we check to see if
3279 * any requested capabilities changed locally e.g. via
3280 * remount but we can not do much about it here
3281 * if they have (even if we could detect it by the following)
3282 * Perhaps we could add a backpointer to array of sb from tcon
3283 * or if we change to make all sb to same share the same
3284 * sb as NFS - then we only have one backpointer to sb.
3285 * What if we wanted to mount the server share twice once with
3286 * and once without posixacls or posix paths? */
3287 __u64 saved_cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
3289 if (vol_info
&& vol_info
->no_linux_ext
) {
3290 tcon
->fsUnixInfo
.Capability
= 0;
3291 tcon
->unix_ext
= 0; /* Unix Extensions disabled */
3292 cifs_dbg(FYI
, "Linux protocol extensions disabled\n");
3294 } else if (vol_info
)
3295 tcon
->unix_ext
= 1; /* Unix Extensions supported */
3297 if (tcon
->unix_ext
== 0) {
3298 cifs_dbg(FYI
, "Unix extensions disabled so not set on reconnect\n");
3302 if (!CIFSSMBQFSUnixInfo(xid
, tcon
)) {
3303 __u64 cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
3304 cifs_dbg(FYI
, "unix caps which server supports %lld\n", cap
);
3305 /* check for reconnect case in which we do not
3306 want to change the mount behavior if we can avoid it */
3307 if (vol_info
== NULL
) {
3308 /* turn off POSIX ACL and PATHNAMES if not set
3309 originally at mount time */
3310 if ((saved_cap
& CIFS_UNIX_POSIX_ACL_CAP
) == 0)
3311 cap
&= ~CIFS_UNIX_POSIX_ACL_CAP
;
3312 if ((saved_cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) == 0) {
3313 if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)
3314 cifs_dbg(VFS
, "POSIXPATH support change\n");
3315 cap
&= ~CIFS_UNIX_POSIX_PATHNAMES_CAP
;
3316 } else if ((cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) == 0) {
3317 cifs_dbg(VFS
, "possible reconnect error\n");
3318 cifs_dbg(VFS
, "server disabled POSIX path support\n");
3322 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)
3323 cifs_dbg(VFS
, "per-share encryption not supported yet\n");
3325 cap
&= CIFS_UNIX_CAP_MASK
;
3326 if (vol_info
&& vol_info
->no_psx_acl
)
3327 cap
&= ~CIFS_UNIX_POSIX_ACL_CAP
;
3328 else if (CIFS_UNIX_POSIX_ACL_CAP
& cap
) {
3329 cifs_dbg(FYI
, "negotiated posix acl support\n");
3331 cifs_sb
->mnt_cifs_flags
|=
3332 CIFS_MOUNT_POSIXACL
;
3335 if (vol_info
&& vol_info
->posix_paths
== 0)
3336 cap
&= ~CIFS_UNIX_POSIX_PATHNAMES_CAP
;
3337 else if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) {
3338 cifs_dbg(FYI
, "negotiate posix pathnames\n");
3340 cifs_sb
->mnt_cifs_flags
|=
3341 CIFS_MOUNT_POSIX_PATHS
;
3344 cifs_dbg(FYI
, "Negotiate caps 0x%x\n", (int)cap
);
3345 #ifdef CONFIG_CIFS_DEBUG2
3346 if (cap
& CIFS_UNIX_FCNTL_CAP
)
3347 cifs_dbg(FYI
, "FCNTL cap\n");
3348 if (cap
& CIFS_UNIX_EXTATTR_CAP
)
3349 cifs_dbg(FYI
, "EXTATTR cap\n");
3350 if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)
3351 cifs_dbg(FYI
, "POSIX path cap\n");
3352 if (cap
& CIFS_UNIX_XATTR_CAP
)
3353 cifs_dbg(FYI
, "XATTR cap\n");
3354 if (cap
& CIFS_UNIX_POSIX_ACL_CAP
)
3355 cifs_dbg(FYI
, "POSIX ACL cap\n");
3356 if (cap
& CIFS_UNIX_LARGE_READ_CAP
)
3357 cifs_dbg(FYI
, "very large read cap\n");
3358 if (cap
& CIFS_UNIX_LARGE_WRITE_CAP
)
3359 cifs_dbg(FYI
, "very large write cap\n");
3360 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP
)
3361 cifs_dbg(FYI
, "transport encryption cap\n");
3362 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)
3363 cifs_dbg(FYI
, "mandatory transport encryption cap\n");
3364 #endif /* CIFS_DEBUG2 */
3365 if (CIFSSMBSetFSUnixInfo(xid
, tcon
, cap
)) {
3366 if (vol_info
== NULL
) {
3367 cifs_dbg(FYI
, "resetting capabilities failed\n");
3369 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");
3375 int cifs_setup_cifs_sb(struct smb_vol
*pvolume_info
,
3376 struct cifs_sb_info
*cifs_sb
)
3378 INIT_DELAYED_WORK(&cifs_sb
->prune_tlinks
, cifs_prune_tlinks
);
3380 spin_lock_init(&cifs_sb
->tlink_tree_lock
);
3381 cifs_sb
->tlink_tree
= RB_ROOT
;
3384 * Temporarily set r/wsize for matching superblock. If we end up using
3385 * new sb then client will later negotiate it downward if needed.
3387 cifs_sb
->rsize
= pvolume_info
->rsize
;
3388 cifs_sb
->wsize
= pvolume_info
->wsize
;
3390 cifs_sb
->mnt_uid
= pvolume_info
->linux_uid
;
3391 cifs_sb
->mnt_gid
= pvolume_info
->linux_gid
;
3392 cifs_sb
->mnt_file_mode
= pvolume_info
->file_mode
;
3393 cifs_sb
->mnt_dir_mode
= pvolume_info
->dir_mode
;
3394 cifs_dbg(FYI
, "file mode: 0x%hx dir mode: 0x%hx\n",
3395 cifs_sb
->mnt_file_mode
, cifs_sb
->mnt_dir_mode
);
3397 cifs_sb
->actimeo
= pvolume_info
->actimeo
;
3398 cifs_sb
->local_nls
= pvolume_info
->local_nls
;
3400 if (pvolume_info
->noperm
)
3401 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_PERM
;
3402 if (pvolume_info
->setuids
)
3403 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_SET_UID
;
3404 if (pvolume_info
->setuidfromacl
)
3405 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_UID_FROM_ACL
;
3406 if (pvolume_info
->server_ino
)
3407 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_SERVER_INUM
;
3408 if (pvolume_info
->remap
)
3409 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MAP_SFM_CHR
;
3410 if (pvolume_info
->sfu_remap
)
3411 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MAP_SPECIAL_CHR
;
3412 if (pvolume_info
->no_xattr
)
3413 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_XATTR
;
3414 if (pvolume_info
->sfu_emul
)
3415 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_UNX_EMUL
;
3416 if (pvolume_info
->nobrl
)
3417 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_BRL
;
3418 if (pvolume_info
->nostrictsync
)
3419 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NOSSYNC
;
3420 if (pvolume_info
->mand_lock
)
3421 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NOPOSIXBRL
;
3422 if (pvolume_info
->rwpidforward
)
3423 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_RWPIDFORWARD
;
3424 if (pvolume_info
->cifs_acl
)
3425 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_ACL
;
3426 if (pvolume_info
->backupuid_specified
) {
3427 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_BACKUPUID
;
3428 cifs_sb
->mnt_backupuid
= pvolume_info
->backupuid
;
3430 if (pvolume_info
->backupgid_specified
) {
3431 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_BACKUPGID
;
3432 cifs_sb
->mnt_backupgid
= pvolume_info
->backupgid
;
3434 if (pvolume_info
->override_uid
)
3435 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_OVERR_UID
;
3436 if (pvolume_info
->override_gid
)
3437 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_OVERR_GID
;
3438 if (pvolume_info
->dynperm
)
3439 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_DYNPERM
;
3440 if (pvolume_info
->fsc
)
3441 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_FSCACHE
;
3442 if (pvolume_info
->multiuser
)
3443 cifs_sb
->mnt_cifs_flags
|= (CIFS_MOUNT_MULTIUSER
|
3444 CIFS_MOUNT_NO_PERM
);
3445 if (pvolume_info
->strict_io
)
3446 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_STRICT_IO
;
3447 if (pvolume_info
->direct_io
) {
3448 cifs_dbg(FYI
, "mounting share using direct i/o\n");
3449 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_DIRECT_IO
;
3451 if (pvolume_info
->mfsymlinks
) {
3452 if (pvolume_info
->sfu_emul
) {
3454 * Our SFU ("Services for Unix" emulation does not allow
3455 * creating symlinks but does allow reading existing SFU
3456 * symlinks (it does allow both creating and reading SFU
3457 * style mknod and FIFOs though). When "mfsymlinks" and
3458 * "sfu" are both enabled at the same time, it allows
3459 * reading both types of symlinks, but will only create
3460 * them with mfsymlinks format. This allows better
3461 * Apple compatibility (probably better for Samba too)
3462 * while still recognizing old Windows style symlinks.
3464 cifs_dbg(VFS
, "mount options mfsymlinks and sfu both enabled\n");
3466 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MF_SYMLINKS
;
3469 if ((pvolume_info
->cifs_acl
) && (pvolume_info
->dynperm
))
3470 cifs_dbg(VFS
, "mount option dynperm ignored if cifsacl mount option supported\n");
3472 if (pvolume_info
->prepath
) {
3473 cifs_sb
->prepath
= kstrdup(pvolume_info
->prepath
, GFP_KERNEL
);
3474 if (cifs_sb
->prepath
== NULL
)
3482 cleanup_volume_info_contents(struct smb_vol
*volume_info
)
3484 kfree(volume_info
->username
);
3485 kzfree(volume_info
->password
);
3486 kfree(volume_info
->UNC
);
3487 kfree(volume_info
->domainname
);
3488 kfree(volume_info
->iocharset
);
3489 kfree(volume_info
->prepath
);
3493 cifs_cleanup_volume_info(struct smb_vol
*volume_info
)
3497 cleanup_volume_info_contents(volume_info
);
3502 #ifdef CONFIG_CIFS_DFS_UPCALL
3504 * cifs_build_path_to_root returns full path to root when we do not have an
3505 * exiting connection (tcon)
3508 build_unc_path_to_root(const struct smb_vol
*vol
,
3509 const struct cifs_sb_info
*cifs_sb
)
3511 char *full_path
, *pos
;
3512 unsigned int pplen
= vol
->prepath
? strlen(vol
->prepath
) + 1 : 0;
3513 unsigned int unc_len
= strnlen(vol
->UNC
, MAX_TREE_SIZE
+ 1);
3515 full_path
= kmalloc(unc_len
+ pplen
+ 1, GFP_KERNEL
);
3516 if (full_path
== NULL
)
3517 return ERR_PTR(-ENOMEM
);
3519 strncpy(full_path
, vol
->UNC
, unc_len
);
3520 pos
= full_path
+ unc_len
;
3523 *pos
= CIFS_DIR_SEP(cifs_sb
);
3524 strncpy(pos
+ 1, vol
->prepath
, pplen
);
3528 *pos
= '\0'; /* add trailing null */
3529 convert_delimiter(full_path
, CIFS_DIR_SEP(cifs_sb
));
3530 cifs_dbg(FYI
, "%s: full_path=%s\n", __func__
, full_path
);
3535 * Perform a dfs referral query for a share and (optionally) prefix
3537 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3538 * to a string containing updated options for the submount. Otherwise it
3539 * will be left untouched.
3541 * Returns the rc from get_dfs_path to the caller, which can be used to
3542 * determine whether there were referrals.
3545 expand_dfs_referral(const unsigned int xid
, struct cifs_ses
*ses
,
3546 struct smb_vol
*volume_info
, struct cifs_sb_info
*cifs_sb
,
3550 unsigned int num_referrals
= 0;
3551 struct dfs_info3_param
*referrals
= NULL
;
3552 char *full_path
= NULL
, *ref_path
= NULL
, *mdata
= NULL
;
3554 full_path
= build_unc_path_to_root(volume_info
, cifs_sb
);
3555 if (IS_ERR(full_path
))
3556 return PTR_ERR(full_path
);
3558 /* For DFS paths, skip the first '\' of the UNC */
3559 ref_path
= check_prefix
? full_path
+ 1 : volume_info
->UNC
+ 1;
3561 rc
= get_dfs_path(xid
, ses
, ref_path
, cifs_sb
->local_nls
,
3562 &num_referrals
, &referrals
, cifs_remap(cifs_sb
));
3564 if (!rc
&& num_referrals
> 0) {
3565 char *fake_devname
= NULL
;
3567 mdata
= cifs_compose_mount_options(cifs_sb
->mountdata
,
3568 full_path
+ 1, referrals
,
3571 free_dfs_info_array(referrals
, num_referrals
);
3573 if (IS_ERR(mdata
)) {
3574 rc
= PTR_ERR(mdata
);
3577 cleanup_volume_info_contents(volume_info
);
3578 rc
= cifs_setup_volume_info(volume_info
, mdata
,
3581 kfree(fake_devname
);
3582 kfree(cifs_sb
->mountdata
);
3583 cifs_sb
->mountdata
= mdata
;
3591 cifs_setup_volume_info(struct smb_vol
*volume_info
, char *mount_data
,
3592 const char *devname
)
3596 if (cifs_parse_mount_options(mount_data
, devname
, volume_info
))
3599 if (volume_info
->nullauth
) {
3600 cifs_dbg(FYI
, "Anonymous login\n");
3601 kfree(volume_info
->username
);
3602 volume_info
->username
= NULL
;
3603 } else if (volume_info
->username
) {
3604 /* BB fixme parse for domain name here */
3605 cifs_dbg(FYI
, "Username: %s\n", volume_info
->username
);
3607 cifs_dbg(VFS
, "No username specified\n");
3608 /* In userspace mount helper we can get user name from alternate
3609 locations such as env variables and files on disk */
3613 /* this is needed for ASCII cp to Unicode converts */
3614 if (volume_info
->iocharset
== NULL
) {
3615 /* load_nls_default cannot return null */
3616 volume_info
->local_nls
= load_nls_default();
3618 volume_info
->local_nls
= load_nls(volume_info
->iocharset
);
3619 if (volume_info
->local_nls
== NULL
) {
3620 cifs_dbg(VFS
, "CIFS mount error: iocharset %s not found\n",
3621 volume_info
->iocharset
);
3630 cifs_get_volume_info(char *mount_data
, const char *devname
)
3633 struct smb_vol
*volume_info
;
3635 volume_info
= kmalloc(sizeof(struct smb_vol
), GFP_KERNEL
);
3637 return ERR_PTR(-ENOMEM
);
3639 rc
= cifs_setup_volume_info(volume_info
, mount_data
, devname
);
3641 cifs_cleanup_volume_info(volume_info
);
3642 volume_info
= ERR_PTR(rc
);
3649 cifs_are_all_path_components_accessible(struct TCP_Server_Info
*server
,
3651 struct cifs_tcon
*tcon
,
3652 struct cifs_sb_info
*cifs_sb
,
3659 sep
= CIFS_DIR_SEP(cifs_sb
);
3662 rc
= server
->ops
->is_path_accessible(xid
, tcon
, cifs_sb
, "");
3664 /* skip separators */
3669 /* next separator */
3670 while (*s
&& *s
!= sep
)
3674 * temporarily null-terminate the path at the end of
3675 * the current component
3679 rc
= server
->ops
->is_path_accessible(xid
, tcon
, cifs_sb
,
3687 cifs_mount(struct cifs_sb_info
*cifs_sb
, struct smb_vol
*volume_info
)
3691 struct cifs_ses
*ses
;
3692 struct cifs_tcon
*tcon
;
3693 struct TCP_Server_Info
*server
;
3695 struct tcon_link
*tlink
;
3696 #ifdef CONFIG_CIFS_DFS_UPCALL
3697 int referral_walks_count
= 0;
3700 #ifdef CONFIG_CIFS_DFS_UPCALL
3702 /* cleanup activities if we're chasing a referral */
3703 if (referral_walks_count
) {
3705 cifs_put_tcon(tcon
);
3707 cifs_put_smb_ses(ses
);
3709 cifs_sb
->mnt_cifs_flags
&= ~CIFS_MOUNT_POSIX_PATHS
;
3723 /* get a reference to a tcp session */
3724 server
= cifs_get_tcp_session(volume_info
);
3725 if (IS_ERR(server
)) {
3726 rc
= PTR_ERR(server
);
3729 if ((volume_info
->max_credits
< 20) ||
3730 (volume_info
->max_credits
> 60000))
3731 server
->max_credits
= SMB2_MAX_CREDITS_AVAILABLE
;
3733 server
->max_credits
= volume_info
->max_credits
;
3734 /* get a reference to a SMB session */
3735 ses
= cifs_get_smb_ses(server
, volume_info
);
3739 goto mount_fail_check
;
3742 if ((volume_info
->persistent
== true) && ((ses
->server
->capabilities
&
3743 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES
) == 0)) {
3744 cifs_dbg(VFS
, "persistent handles not supported by server\n");
3746 goto mount_fail_check
;
3749 /* search for existing tcon to this server share */
3750 tcon
= cifs_get_tcon(ses
, volume_info
);
3755 goto mount_fail_check
;
3757 goto remote_path_check
;
3760 /* tell server which Unix caps we support */
3761 if (cap_unix(tcon
->ses
)) {
3762 /* reset of caps checks mount to see if unix extensions
3763 disabled for just this mount */
3764 reset_cifs_unix_caps(xid
, tcon
, cifs_sb
, volume_info
);
3765 if ((tcon
->ses
->server
->tcpStatus
== CifsNeedReconnect
) &&
3766 (le64_to_cpu(tcon
->fsUnixInfo
.Capability
) &
3767 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)) {
3769 goto mount_fail_check
;
3772 tcon
->unix_ext
= 0; /* server does not support them */
3774 /* do not care if a following call succeed - informational */
3775 if (!tcon
->ipc
&& server
->ops
->qfs_tcon
)
3776 server
->ops
->qfs_tcon(xid
, tcon
);
3778 cifs_sb
->wsize
= server
->ops
->negotiate_wsize(tcon
, volume_info
);
3779 cifs_sb
->rsize
= server
->ops
->negotiate_rsize(tcon
, volume_info
);
3782 #ifdef CONFIG_CIFS_DFS_UPCALL
3784 * Perform an unconditional check for whether there are DFS
3785 * referrals for this path without prefix, to provide support
3786 * for DFS referrals from w2k8 servers which don't seem to respond
3787 * with PATH_NOT_COVERED to requests that include the prefix.
3788 * Chase the referral if found, otherwise continue normally.
3790 if (referral_walks_count
== 0) {
3791 int refrc
= expand_dfs_referral(xid
, ses
, volume_info
, cifs_sb
,
3794 referral_walks_count
++;
3795 goto try_mount_again
;
3800 /* check if a whole path is not remote */
3802 if (!server
->ops
->is_path_accessible
) {
3804 goto mount_fail_check
;
3807 * cifs_build_path_to_root works only when we have a valid tcon
3809 full_path
= cifs_build_path_to_root(volume_info
, cifs_sb
, tcon
,
3810 tcon
->Flags
& SMB_SHARE_IS_IN_DFS
);
3811 if (full_path
== NULL
) {
3813 goto mount_fail_check
;
3815 rc
= server
->ops
->is_path_accessible(xid
, tcon
, cifs_sb
,
3817 if (rc
!= 0 && rc
!= -EREMOTE
) {
3819 goto mount_fail_check
;
3822 if (rc
!= -EREMOTE
) {
3823 rc
= cifs_are_all_path_components_accessible(server
,
3827 cifs_dbg(VFS
, "cannot query dirs between root and final path, "
3828 "enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
3829 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_USE_PREFIX_PATH
;
3836 /* get referral if needed */
3837 if (rc
== -EREMOTE
) {
3838 #ifdef CONFIG_CIFS_DFS_UPCALL
3839 if (referral_walks_count
> MAX_NESTED_LINKS
) {
3841 * BB: when we implement proper loop detection,
3842 * we will remove this check. But now we need it
3843 * to prevent an indefinite loop if 'DFS tree' is
3844 * misconfigured (i.e. has loops).
3847 goto mount_fail_check
;
3850 rc
= expand_dfs_referral(xid
, ses
, volume_info
, cifs_sb
, true);
3853 referral_walks_count
++;
3854 goto try_mount_again
;
3856 goto mount_fail_check
;
3857 #else /* No DFS support, return error on mount */
3863 goto mount_fail_check
;
3865 /* now, hang the tcon off of the superblock */
3866 tlink
= kzalloc(sizeof *tlink
, GFP_KERNEL
);
3867 if (tlink
== NULL
) {
3869 goto mount_fail_check
;
3872 tlink
->tl_uid
= ses
->linux_uid
;
3873 tlink
->tl_tcon
= tcon
;
3874 tlink
->tl_time
= jiffies
;
3875 set_bit(TCON_LINK_MASTER
, &tlink
->tl_flags
);
3876 set_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
3878 cifs_sb
->master_tlink
= tlink
;
3879 spin_lock(&cifs_sb
->tlink_tree_lock
);
3880 tlink_rb_insert(&cifs_sb
->tlink_tree
, tlink
);
3881 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3883 queue_delayed_work(cifsiod_wq
, &cifs_sb
->prune_tlinks
,
3887 /* on error free sesinfo and tcon struct if needed */
3889 /* If find_unc succeeded then rc == 0 so we can not end */
3890 /* up accidentally freeing someone elses tcon struct */
3892 cifs_put_tcon(tcon
);
3894 cifs_put_smb_ses(ses
);
3896 cifs_put_tcp_session(server
, 0);
3905 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3906 * pointer may be NULL.
3909 CIFSTCon(const unsigned int xid
, struct cifs_ses
*ses
,
3910 const char *tree
, struct cifs_tcon
*tcon
,
3911 const struct nls_table
*nls_codepage
)
3913 struct smb_hdr
*smb_buffer
;
3914 struct smb_hdr
*smb_buffer_response
;
3917 unsigned char *bcc_ptr
;
3920 __u16 bytes_left
, count
;
3925 smb_buffer
= cifs_buf_get();
3926 if (smb_buffer
== NULL
)
3929 smb_buffer_response
= smb_buffer
;
3931 header_assemble(smb_buffer
, SMB_COM_TREE_CONNECT_ANDX
,
3932 NULL
/*no tid */ , 4 /*wct */ );
3934 smb_buffer
->Mid
= get_next_mid(ses
->server
);
3935 smb_buffer
->Uid
= ses
->Suid
;
3936 pSMB
= (TCONX_REQ
*) smb_buffer
;
3937 pSMBr
= (TCONX_RSP
*) smb_buffer_response
;
3939 pSMB
->AndXCommand
= 0xFF;
3940 pSMB
->Flags
= cpu_to_le16(TCON_EXTENDED_SECINFO
);
3941 bcc_ptr
= &pSMB
->Password
[0];
3942 if (!tcon
|| (ses
->server
->sec_mode
& SECMODE_USER
)) {
3943 pSMB
->PasswordLength
= cpu_to_le16(1); /* minimum */
3944 *bcc_ptr
= 0; /* password is null byte */
3945 bcc_ptr
++; /* skip password */
3946 /* already aligned so no need to do it below */
3948 pSMB
->PasswordLength
= cpu_to_le16(CIFS_AUTH_RESP_SIZE
);
3949 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3950 specified as required (when that support is added to
3951 the vfs in the future) as only NTLM or the much
3952 weaker LANMAN (which we do not send by default) is accepted
3953 by Samba (not sure whether other servers allow
3954 NTLMv2 password here) */
3955 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3956 if ((global_secflags
& CIFSSEC_MAY_LANMAN
) &&
3957 (ses
->sectype
== LANMAN
))
3958 calc_lanman_hash(tcon
->password
, ses
->server
->cryptkey
,
3959 ses
->server
->sec_mode
&
3960 SECMODE_PW_ENCRYPT
? true : false,
3963 #endif /* CIFS_WEAK_PW_HASH */
3964 rc
= SMBNTencrypt(tcon
->password
, ses
->server
->cryptkey
,
3965 bcc_ptr
, nls_codepage
);
3967 cifs_dbg(FYI
, "%s Can't generate NTLM rsp. Error: %d\n",
3969 cifs_buf_release(smb_buffer
);
3973 bcc_ptr
+= CIFS_AUTH_RESP_SIZE
;
3974 if (ses
->capabilities
& CAP_UNICODE
) {
3975 /* must align unicode strings */
3976 *bcc_ptr
= 0; /* null byte password */
3981 if (ses
->server
->sign
)
3982 smb_buffer
->Flags2
|= SMBFLG2_SECURITY_SIGNATURE
;
3984 if (ses
->capabilities
& CAP_STATUS32
) {
3985 smb_buffer
->Flags2
|= SMBFLG2_ERR_STATUS
;
3987 if (ses
->capabilities
& CAP_DFS
) {
3988 smb_buffer
->Flags2
|= SMBFLG2_DFS
;
3990 if (ses
->capabilities
& CAP_UNICODE
) {
3991 smb_buffer
->Flags2
|= SMBFLG2_UNICODE
;
3993 cifs_strtoUTF16((__le16
*) bcc_ptr
, tree
,
3994 6 /* max utf8 char length in bytes */ *
3995 (/* server len*/ + 256 /* share len */), nls_codepage
);
3996 bcc_ptr
+= 2 * length
; /* convert num 16 bit words to bytes */
3997 bcc_ptr
+= 2; /* skip trailing null */
3998 } else { /* ASCII */
3999 strcpy(bcc_ptr
, tree
);
4000 bcc_ptr
+= strlen(tree
) + 1;
4002 strcpy(bcc_ptr
, "?????");
4003 bcc_ptr
+= strlen("?????");
4005 count
= bcc_ptr
- &pSMB
->Password
[0];
4006 pSMB
->hdr
.smb_buf_length
= cpu_to_be32(be32_to_cpu(
4007 pSMB
->hdr
.smb_buf_length
) + count
);
4008 pSMB
->ByteCount
= cpu_to_le16(count
);
4010 rc
= SendReceive(xid
, ses
, smb_buffer
, smb_buffer_response
, &length
,
4013 /* above now done in SendReceive */
4014 if ((rc
== 0) && (tcon
!= NULL
)) {
4017 tcon
->tidStatus
= CifsGood
;
4018 tcon
->need_reconnect
= false;
4019 tcon
->tid
= smb_buffer_response
->Tid
;
4020 bcc_ptr
= pByteArea(smb_buffer_response
);
4021 bytes_left
= get_bcc(smb_buffer_response
);
4022 length
= strnlen(bcc_ptr
, bytes_left
- 2);
4023 if (smb_buffer
->Flags2
& SMBFLG2_UNICODE
)
4029 /* skip service field (NB: this field is always ASCII) */
4031 if ((bcc_ptr
[0] == 'I') && (bcc_ptr
[1] == 'P') &&
4032 (bcc_ptr
[2] == 'C')) {
4033 cifs_dbg(FYI
, "IPC connection\n");
4036 } else if (length
== 2) {
4037 if ((bcc_ptr
[0] == 'A') && (bcc_ptr
[1] == ':')) {
4038 /* the most common case */
4039 cifs_dbg(FYI
, "disk share connection\n");
4042 bcc_ptr
+= length
+ 1;
4043 bytes_left
-= (length
+ 1);
4044 strlcpy(tcon
->treeName
, tree
, sizeof(tcon
->treeName
));
4046 /* mostly informational -- no need to fail on error here */
4047 kfree(tcon
->nativeFileSystem
);
4048 tcon
->nativeFileSystem
= cifs_strndup_from_utf16(bcc_ptr
,
4049 bytes_left
, is_unicode
,
4052 cifs_dbg(FYI
, "nativeFileSystem=%s\n", tcon
->nativeFileSystem
);
4054 if ((smb_buffer_response
->WordCount
== 3) ||
4055 (smb_buffer_response
->WordCount
== 7))
4056 /* field is in same location */
4057 tcon
->Flags
= le16_to_cpu(pSMBr
->OptionalSupport
);
4060 cifs_dbg(FYI
, "Tcon flags: 0x%x\n", tcon
->Flags
);
4061 } else if ((rc
== 0) && tcon
== NULL
) {
4062 /* all we need to save for IPC$ connection */
4063 ses
->ipc_tid
= smb_buffer_response
->Tid
;
4066 cifs_buf_release(smb_buffer
);
4070 static void delayed_free(struct rcu_head
*p
)
4072 struct cifs_sb_info
*sbi
= container_of(p
, struct cifs_sb_info
, rcu
);
4073 unload_nls(sbi
->local_nls
);
4078 cifs_umount(struct cifs_sb_info
*cifs_sb
)
4080 struct rb_root
*root
= &cifs_sb
->tlink_tree
;
4081 struct rb_node
*node
;
4082 struct tcon_link
*tlink
;
4084 cancel_delayed_work_sync(&cifs_sb
->prune_tlinks
);
4086 spin_lock(&cifs_sb
->tlink_tree_lock
);
4087 while ((node
= rb_first(root
))) {
4088 tlink
= rb_entry(node
, struct tcon_link
, tl_rbnode
);
4089 cifs_get_tlink(tlink
);
4090 clear_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
4091 rb_erase(node
, root
);
4093 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4094 cifs_put_tlink(tlink
);
4095 spin_lock(&cifs_sb
->tlink_tree_lock
);
4097 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4099 kfree(cifs_sb
->mountdata
);
4100 kfree(cifs_sb
->prepath
);
4101 call_rcu(&cifs_sb
->rcu
, delayed_free
);
4105 cifs_negotiate_protocol(const unsigned int xid
, struct cifs_ses
*ses
)
4108 struct TCP_Server_Info
*server
= ses
->server
;
4110 if (!server
->ops
->need_neg
|| !server
->ops
->negotiate
)
4113 /* only send once per connect */
4114 if (!server
->ops
->need_neg(server
))
4117 set_credits(server
, 1);
4119 rc
= server
->ops
->negotiate(xid
, ses
);
4121 spin_lock(&GlobalMid_Lock
);
4122 if (server
->tcpStatus
== CifsNeedNegotiate
)
4123 server
->tcpStatus
= CifsGood
;
4126 spin_unlock(&GlobalMid_Lock
);
4133 cifs_setup_session(const unsigned int xid
, struct cifs_ses
*ses
,
4134 struct nls_table
*nls_info
)
4137 struct TCP_Server_Info
*server
= ses
->server
;
4139 ses
->capabilities
= server
->capabilities
;
4140 if (linuxExtEnabled
== 0)
4141 ses
->capabilities
&= (~server
->vals
->cap_unix
);
4143 cifs_dbg(FYI
, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
4144 server
->sec_mode
, server
->capabilities
, server
->timeAdj
);
4146 if (server
->ops
->sess_setup
)
4147 rc
= server
->ops
->sess_setup(xid
, ses
, nls_info
);
4150 cifs_dbg(VFS
, "Send error in SessSetup = %d\n", rc
);
4156 cifs_set_vol_auth(struct smb_vol
*vol
, struct cifs_ses
*ses
)
4158 vol
->sectype
= ses
->sectype
;
4160 /* krb5 is special, since we don't need username or pw */
4161 if (vol
->sectype
== Kerberos
)
4164 return cifs_set_cifscreds(vol
, ses
);
4167 static struct cifs_tcon
*
4168 cifs_construct_tcon(struct cifs_sb_info
*cifs_sb
, kuid_t fsuid
)
4171 struct cifs_tcon
*master_tcon
= cifs_sb_master_tcon(cifs_sb
);
4172 struct cifs_ses
*ses
;
4173 struct cifs_tcon
*tcon
= NULL
;
4174 struct smb_vol
*vol_info
;
4176 vol_info
= kzalloc(sizeof(*vol_info
), GFP_KERNEL
);
4177 if (vol_info
== NULL
)
4178 return ERR_PTR(-ENOMEM
);
4180 vol_info
->local_nls
= cifs_sb
->local_nls
;
4181 vol_info
->linux_uid
= fsuid
;
4182 vol_info
->cred_uid
= fsuid
;
4183 vol_info
->UNC
= master_tcon
->treeName
;
4184 vol_info
->retry
= master_tcon
->retry
;
4185 vol_info
->nocase
= master_tcon
->nocase
;
4186 vol_info
->local_lease
= master_tcon
->local_lease
;
4187 vol_info
->no_linux_ext
= !master_tcon
->unix_ext
;
4188 vol_info
->sectype
= master_tcon
->ses
->sectype
;
4189 vol_info
->sign
= master_tcon
->ses
->sign
;
4191 rc
= cifs_set_vol_auth(vol_info
, master_tcon
->ses
);
4197 /* get a reference for the same TCP session */
4198 spin_lock(&cifs_tcp_ses_lock
);
4199 ++master_tcon
->ses
->server
->srv_count
;
4200 spin_unlock(&cifs_tcp_ses_lock
);
4202 ses
= cifs_get_smb_ses(master_tcon
->ses
->server
, vol_info
);
4204 tcon
= (struct cifs_tcon
*)ses
;
4205 cifs_put_tcp_session(master_tcon
->ses
->server
, 0);
4209 tcon
= cifs_get_tcon(ses
, vol_info
);
4211 cifs_put_smb_ses(ses
);
4216 reset_cifs_unix_caps(0, tcon
, NULL
, vol_info
);
4218 kfree(vol_info
->username
);
4219 kfree(vol_info
->password
);
4226 cifs_sb_master_tcon(struct cifs_sb_info
*cifs_sb
)
4228 return tlink_tcon(cifs_sb_master_tlink(cifs_sb
));
4231 /* find and return a tlink with given uid */
4232 static struct tcon_link
*
4233 tlink_rb_search(struct rb_root
*root
, kuid_t uid
)
4235 struct rb_node
*node
= root
->rb_node
;
4236 struct tcon_link
*tlink
;
4239 tlink
= rb_entry(node
, struct tcon_link
, tl_rbnode
);
4241 if (uid_gt(tlink
->tl_uid
, uid
))
4242 node
= node
->rb_left
;
4243 else if (uid_lt(tlink
->tl_uid
, uid
))
4244 node
= node
->rb_right
;
4251 /* insert a tcon_link into the tree */
4253 tlink_rb_insert(struct rb_root
*root
, struct tcon_link
*new_tlink
)
4255 struct rb_node
**new = &(root
->rb_node
), *parent
= NULL
;
4256 struct tcon_link
*tlink
;
4259 tlink
= rb_entry(*new, struct tcon_link
, tl_rbnode
);
4262 if (uid_gt(tlink
->tl_uid
, new_tlink
->tl_uid
))
4263 new = &((*new)->rb_left
);
4265 new = &((*new)->rb_right
);
4268 rb_link_node(&new_tlink
->tl_rbnode
, parent
, new);
4269 rb_insert_color(&new_tlink
->tl_rbnode
, root
);
4273 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4276 * If the superblock doesn't refer to a multiuser mount, then just return
4277 * the master tcon for the mount.
4279 * First, search the rbtree for an existing tcon for this fsuid. If one
4280 * exists, then check to see if it's pending construction. If it is then wait
4281 * for construction to complete. Once it's no longer pending, check to see if
4282 * it failed and either return an error or retry construction, depending on
4285 * If one doesn't exist then insert a new tcon_link struct into the tree and
4286 * try to construct a new one.
4289 cifs_sb_tlink(struct cifs_sb_info
*cifs_sb
)
4292 kuid_t fsuid
= current_fsuid();
4293 struct tcon_link
*tlink
, *newtlink
;
4295 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
))
4296 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb
));
4298 spin_lock(&cifs_sb
->tlink_tree_lock
);
4299 tlink
= tlink_rb_search(&cifs_sb
->tlink_tree
, fsuid
);
4301 cifs_get_tlink(tlink
);
4302 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4304 if (tlink
== NULL
) {
4305 newtlink
= kzalloc(sizeof(*tlink
), GFP_KERNEL
);
4306 if (newtlink
== NULL
)
4307 return ERR_PTR(-ENOMEM
);
4308 newtlink
->tl_uid
= fsuid
;
4309 newtlink
->tl_tcon
= ERR_PTR(-EACCES
);
4310 set_bit(TCON_LINK_PENDING
, &newtlink
->tl_flags
);
4311 set_bit(TCON_LINK_IN_TREE
, &newtlink
->tl_flags
);
4312 cifs_get_tlink(newtlink
);
4314 spin_lock(&cifs_sb
->tlink_tree_lock
);
4315 /* was one inserted after previous search? */
4316 tlink
= tlink_rb_search(&cifs_sb
->tlink_tree
, fsuid
);
4318 cifs_get_tlink(tlink
);
4319 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4321 goto wait_for_construction
;
4324 tlink_rb_insert(&cifs_sb
->tlink_tree
, tlink
);
4325 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4327 wait_for_construction
:
4328 ret
= wait_on_bit(&tlink
->tl_flags
, TCON_LINK_PENDING
,
4329 TASK_INTERRUPTIBLE
);
4331 cifs_put_tlink(tlink
);
4332 return ERR_PTR(-ERESTARTSYS
);
4335 /* if it's good, return it */
4336 if (!IS_ERR(tlink
->tl_tcon
))
4339 /* return error if we tried this already recently */
4340 if (time_before(jiffies
, tlink
->tl_time
+ TLINK_ERROR_EXPIRE
)) {
4341 cifs_put_tlink(tlink
);
4342 return ERR_PTR(-EACCES
);
4345 if (test_and_set_bit(TCON_LINK_PENDING
, &tlink
->tl_flags
))
4346 goto wait_for_construction
;
4349 tlink
->tl_tcon
= cifs_construct_tcon(cifs_sb
, fsuid
);
4350 clear_bit(TCON_LINK_PENDING
, &tlink
->tl_flags
);
4351 wake_up_bit(&tlink
->tl_flags
, TCON_LINK_PENDING
);
4353 if (IS_ERR(tlink
->tl_tcon
)) {
4354 cifs_put_tlink(tlink
);
4355 return ERR_PTR(-EACCES
);
4362 * periodic workqueue job that scans tcon_tree for a superblock and closes
4366 cifs_prune_tlinks(struct work_struct
*work
)
4368 struct cifs_sb_info
*cifs_sb
= container_of(work
, struct cifs_sb_info
,
4370 struct rb_root
*root
= &cifs_sb
->tlink_tree
;
4371 struct rb_node
*node
= rb_first(root
);
4372 struct rb_node
*tmp
;
4373 struct tcon_link
*tlink
;
4376 * Because we drop the spinlock in the loop in order to put the tlink
4377 * it's not guarded against removal of links from the tree. The only
4378 * places that remove entries from the tree are this function and
4379 * umounts. Because this function is non-reentrant and is canceled
4380 * before umount can proceed, this is safe.
4382 spin_lock(&cifs_sb
->tlink_tree_lock
);
4383 node
= rb_first(root
);
4384 while (node
!= NULL
) {
4386 node
= rb_next(tmp
);
4387 tlink
= rb_entry(tmp
, struct tcon_link
, tl_rbnode
);
4389 if (test_bit(TCON_LINK_MASTER
, &tlink
->tl_flags
) ||
4390 atomic_read(&tlink
->tl_count
) != 0 ||
4391 time_after(tlink
->tl_time
+ TLINK_IDLE_EXPIRE
, jiffies
))
4394 cifs_get_tlink(tlink
);
4395 clear_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
4396 rb_erase(tmp
, root
);
4398 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4399 cifs_put_tlink(tlink
);
4400 spin_lock(&cifs_sb
->tlink_tree_lock
);
4402 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4404 queue_delayed_work(cifsiod_wq
, &cifs_sb
->prune_tlinks
,