4 * Copyright (C) International Business Machines Corp., 2002,2011
5 * Author(s): Steve French (sfrench@us.ibm.com)
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/net.h>
23 #include <linux/string.h>
24 #include <linux/list.h>
25 #include <linux/wait.h>
26 #include <linux/slab.h>
27 #include <linux/pagemap.h>
28 #include <linux/ctype.h>
29 #include <linux/utsname.h>
30 #include <linux/mempool.h>
31 #include <linux/delay.h>
32 #include <linux/completion.h>
33 #include <linux/kthread.h>
34 #include <linux/pagevec.h>
35 #include <linux/freezer.h>
36 #include <linux/namei.h>
37 #include <asm/uaccess.h>
38 #include <asm/processor.h>
39 #include <linux/inet.h>
40 #include <linux/module.h>
41 #include <keys/user-type.h>
43 #include <linux/parser.h>
47 #include "cifsproto.h"
48 #include "cifs_unicode.h"
49 #include "cifs_debug.h"
50 #include "cifs_fs_sb.h"
53 #include "rfc1002pdu.h"
57 #define RFC1001_PORT 139
59 extern mempool_t
*cifs_req_poolp
;
61 /* FIXME: should these be tunable? */
62 #define TLINK_ERROR_EXPIRE (1 * HZ)
63 #define TLINK_IDLE_EXPIRE (600 * HZ)
67 /* Mount options that take no arguments */
68 Opt_user_xattr
, Opt_nouser_xattr
,
69 Opt_forceuid
, Opt_noforceuid
,
70 Opt_forcegid
, Opt_noforcegid
,
71 Opt_noblocksend
, Opt_noautotune
,
72 Opt_hard
, Opt_soft
, Opt_perm
, Opt_noperm
,
73 Opt_mapposix
, Opt_nomapposix
,
74 Opt_mapchars
, Opt_nomapchars
, Opt_sfu
,
75 Opt_nosfu
, Opt_nodfs
, Opt_posixpaths
,
76 Opt_noposixpaths
, Opt_nounix
,
79 Opt_forcemandatorylock
, Opt_setuids
,
80 Opt_nosetuids
, Opt_dynperm
, Opt_nodynperm
,
81 Opt_nohard
, Opt_nosoft
,
83 Opt_nostrictsync
, Opt_strictsync
,
84 Opt_serverino
, Opt_noserverino
,
85 Opt_rwpidforward
, Opt_cifsacl
, Opt_nocifsacl
,
86 Opt_acl
, Opt_noacl
, Opt_locallease
,
87 Opt_sign
, Opt_seal
, Opt_noac
,
88 Opt_fsc
, Opt_mfsymlinks
,
89 Opt_multiuser
, Opt_sloppy
, Opt_nosharesock
,
90 Opt_persistent
, Opt_nopersistent
,
91 Opt_resilient
, Opt_noresilient
,
93 /* Mount options which take numeric value */
94 Opt_backupuid
, Opt_backupgid
, Opt_uid
,
95 Opt_cruid
, Opt_gid
, Opt_file_mode
,
96 Opt_dirmode
, Opt_port
,
97 Opt_rsize
, Opt_wsize
, Opt_actimeo
,
100 /* Mount options which take string value */
101 Opt_user
, Opt_pass
, Opt_ip
,
102 Opt_domain
, Opt_srcaddr
, Opt_iocharset
,
103 Opt_netbiosname
, Opt_servern
,
104 Opt_ver
, Opt_vers
, Opt_sec
, Opt_cache
,
106 /* Mount options to be ignored */
109 /* Options which could be blank */
117 static const match_table_t cifs_mount_option_tokens
= {
119 { Opt_user_xattr
, "user_xattr" },
120 { Opt_nouser_xattr
, "nouser_xattr" },
121 { Opt_forceuid
, "forceuid" },
122 { Opt_noforceuid
, "noforceuid" },
123 { Opt_forcegid
, "forcegid" },
124 { Opt_noforcegid
, "noforcegid" },
125 { Opt_noblocksend
, "noblocksend" },
126 { Opt_noautotune
, "noautotune" },
127 { Opt_hard
, "hard" },
128 { Opt_soft
, "soft" },
129 { Opt_perm
, "perm" },
130 { Opt_noperm
, "noperm" },
131 { Opt_mapchars
, "mapchars" }, /* SFU style */
132 { Opt_nomapchars
, "nomapchars" },
133 { Opt_mapposix
, "mapposix" }, /* SFM style */
134 { Opt_nomapposix
, "nomapposix" },
136 { Opt_nosfu
, "nosfu" },
137 { Opt_nodfs
, "nodfs" },
138 { Opt_posixpaths
, "posixpaths" },
139 { Opt_noposixpaths
, "noposixpaths" },
140 { Opt_nounix
, "nounix" },
141 { Opt_nounix
, "nolinux" },
142 { Opt_nocase
, "nocase" },
143 { Opt_nocase
, "ignorecase" },
145 { Opt_nobrl
, "nobrl" },
146 { Opt_nobrl
, "nolock" },
147 { Opt_forcemandatorylock
, "forcemandatorylock" },
148 { Opt_forcemandatorylock
, "forcemand" },
149 { Opt_setuids
, "setuids" },
150 { Opt_nosetuids
, "nosetuids" },
151 { Opt_dynperm
, "dynperm" },
152 { Opt_nodynperm
, "nodynperm" },
153 { Opt_nohard
, "nohard" },
154 { Opt_nosoft
, "nosoft" },
155 { Opt_nointr
, "nointr" },
156 { Opt_intr
, "intr" },
157 { Opt_nostrictsync
, "nostrictsync" },
158 { Opt_strictsync
, "strictsync" },
159 { Opt_serverino
, "serverino" },
160 { Opt_noserverino
, "noserverino" },
161 { Opt_rwpidforward
, "rwpidforward" },
162 { Opt_cifsacl
, "cifsacl" },
163 { Opt_nocifsacl
, "nocifsacl" },
165 { Opt_noacl
, "noacl" },
166 { Opt_locallease
, "locallease" },
167 { Opt_sign
, "sign" },
168 { Opt_seal
, "seal" },
169 { Opt_noac
, "noac" },
171 { Opt_mfsymlinks
, "mfsymlinks" },
172 { Opt_multiuser
, "multiuser" },
173 { Opt_sloppy
, "sloppy" },
174 { Opt_nosharesock
, "nosharesock" },
175 { Opt_persistent
, "persistenthandles"},
176 { Opt_nopersistent
, "nopersistenthandles"},
177 { Opt_resilient
, "resilienthandles"},
178 { Opt_noresilient
, "noresilienthandles"},
180 { Opt_backupuid
, "backupuid=%s" },
181 { Opt_backupgid
, "backupgid=%s" },
182 { Opt_uid
, "uid=%s" },
183 { Opt_cruid
, "cruid=%s" },
184 { Opt_gid
, "gid=%s" },
185 { Opt_file_mode
, "file_mode=%s" },
186 { Opt_dirmode
, "dirmode=%s" },
187 { Opt_dirmode
, "dir_mode=%s" },
188 { Opt_port
, "port=%s" },
189 { Opt_rsize
, "rsize=%s" },
190 { Opt_wsize
, "wsize=%s" },
191 { Opt_actimeo
, "actimeo=%s" },
192 { Opt_echo_interval
, "echo_interval=%s" },
194 { Opt_blank_user
, "user=" },
195 { Opt_blank_user
, "username=" },
196 { Opt_user
, "user=%s" },
197 { Opt_user
, "username=%s" },
198 { Opt_blank_pass
, "pass=" },
199 { Opt_blank_pass
, "password=" },
200 { Opt_pass
, "pass=%s" },
201 { Opt_pass
, "password=%s" },
202 { Opt_blank_ip
, "ip=" },
203 { Opt_blank_ip
, "addr=" },
205 { Opt_ip
, "addr=%s" },
206 { Opt_ignore
, "unc=%s" },
207 { Opt_ignore
, "target=%s" },
208 { Opt_ignore
, "path=%s" },
209 { Opt_domain
, "dom=%s" },
210 { Opt_domain
, "domain=%s" },
211 { Opt_domain
, "workgroup=%s" },
212 { Opt_srcaddr
, "srcaddr=%s" },
213 { Opt_ignore
, "prefixpath=%s" },
214 { Opt_iocharset
, "iocharset=%s" },
215 { Opt_netbiosname
, "netbiosname=%s" },
216 { Opt_servern
, "servern=%s" },
217 { Opt_ver
, "ver=%s" },
218 { Opt_vers
, "vers=%s" },
219 { Opt_sec
, "sec=%s" },
220 { Opt_cache
, "cache=%s" },
222 { Opt_ignore
, "cred" },
223 { Opt_ignore
, "credentials" },
224 { Opt_ignore
, "cred=%s" },
225 { Opt_ignore
, "credentials=%s" },
226 { Opt_ignore
, "guest" },
227 { Opt_ignore
, "rw" },
228 { Opt_ignore
, "ro" },
229 { Opt_ignore
, "suid" },
230 { Opt_ignore
, "nosuid" },
231 { Opt_ignore
, "exec" },
232 { Opt_ignore
, "noexec" },
233 { Opt_ignore
, "nodev" },
234 { Opt_ignore
, "noauto" },
235 { Opt_ignore
, "dev" },
236 { Opt_ignore
, "mand" },
237 { Opt_ignore
, "nomand" },
238 { Opt_ignore
, "_netdev" },
244 Opt_sec_krb5
, Opt_sec_krb5i
, Opt_sec_krb5p
,
245 Opt_sec_ntlmsspi
, Opt_sec_ntlmssp
,
246 Opt_ntlm
, Opt_sec_ntlmi
, Opt_sec_ntlmv2
,
247 Opt_sec_ntlmv2i
, Opt_sec_lanman
,
253 static const match_table_t cifs_secflavor_tokens
= {
254 { Opt_sec_krb5
, "krb5" },
255 { Opt_sec_krb5i
, "krb5i" },
256 { Opt_sec_krb5p
, "krb5p" },
257 { Opt_sec_ntlmsspi
, "ntlmsspi" },
258 { Opt_sec_ntlmssp
, "ntlmssp" },
259 { Opt_ntlm
, "ntlm" },
260 { Opt_sec_ntlmi
, "ntlmi" },
261 { Opt_sec_ntlmv2
, "nontlm" },
262 { Opt_sec_ntlmv2
, "ntlmv2" },
263 { Opt_sec_ntlmv2i
, "ntlmv2i" },
264 { Opt_sec_lanman
, "lanman" },
265 { Opt_sec_none
, "none" },
267 { Opt_sec_err
, NULL
}
278 static const match_table_t cifs_cacheflavor_tokens
= {
279 { Opt_cache_loose
, "loose" },
280 { Opt_cache_strict
, "strict" },
281 { Opt_cache_none
, "none" },
282 { Opt_cache_err
, NULL
}
285 static const match_table_t cifs_smb_version_tokens
= {
286 { Smb_1
, SMB1_VERSION_STRING
},
287 { Smb_20
, SMB20_VERSION_STRING
},
288 { Smb_21
, SMB21_VERSION_STRING
},
289 { Smb_30
, SMB30_VERSION_STRING
},
290 { Smb_302
, SMB302_VERSION_STRING
},
291 #ifdef CONFIG_CIFS_SMB311
292 { Smb_311
, SMB311_VERSION_STRING
},
293 { Smb_311
, ALT_SMB311_VERSION_STRING
},
295 { Smb_version_err
, NULL
}
298 static int ip_connect(struct TCP_Server_Info
*server
);
299 static int generic_ip_connect(struct TCP_Server_Info
*server
);
300 static void tlink_rb_insert(struct rb_root
*root
, struct tcon_link
*new_tlink
);
301 static void cifs_prune_tlinks(struct work_struct
*work
);
302 static int cifs_setup_volume_info(struct smb_vol
*volume_info
, char *mount_data
,
303 const char *devname
);
306 * cifs tcp session reconnection
308 * mark tcp session as reconnecting so temporarily locked
309 * mark all smb sessions as reconnecting for tcp session
310 * reconnect tcp session
311 * wake up waiters on reconnection? - (not needed currently)
314 cifs_reconnect(struct TCP_Server_Info
*server
)
317 struct list_head
*tmp
, *tmp2
;
318 struct cifs_ses
*ses
;
319 struct cifs_tcon
*tcon
;
320 struct mid_q_entry
*mid_entry
;
321 struct list_head retry_list
;
323 spin_lock(&GlobalMid_Lock
);
324 if (server
->tcpStatus
== CifsExiting
) {
325 /* the demux thread will exit normally
326 next time through the loop */
327 spin_unlock(&GlobalMid_Lock
);
330 server
->tcpStatus
= CifsNeedReconnect
;
331 spin_unlock(&GlobalMid_Lock
);
333 #ifdef CONFIG_CIFS_SMB2
334 server
->max_read
= 0;
337 cifs_dbg(FYI
, "Reconnecting tcp session\n");
339 /* before reconnecting the tcp session, mark the smb session (uid)
340 and the tid bad so they are not used until reconnected */
341 cifs_dbg(FYI
, "%s: marking sessions and tcons for reconnect\n",
343 spin_lock(&cifs_tcp_ses_lock
);
344 list_for_each(tmp
, &server
->smb_ses_list
) {
345 ses
= list_entry(tmp
, struct cifs_ses
, smb_ses_list
);
346 ses
->need_reconnect
= true;
348 list_for_each(tmp2
, &ses
->tcon_list
) {
349 tcon
= list_entry(tmp2
, struct cifs_tcon
, tcon_list
);
350 tcon
->need_reconnect
= true;
353 spin_unlock(&cifs_tcp_ses_lock
);
355 /* do not want to be sending data on a socket we are freeing */
356 cifs_dbg(FYI
, "%s: tearing down socket\n", __func__
);
357 mutex_lock(&server
->srv_mutex
);
358 if (server
->ssocket
) {
359 cifs_dbg(FYI
, "State: 0x%x Flags: 0x%lx\n",
360 server
->ssocket
->state
, server
->ssocket
->flags
);
361 kernel_sock_shutdown(server
->ssocket
, SHUT_WR
);
362 cifs_dbg(FYI
, "Post shutdown state: 0x%x Flags: 0x%lx\n",
363 server
->ssocket
->state
, server
->ssocket
->flags
);
364 sock_release(server
->ssocket
);
365 server
->ssocket
= NULL
;
367 server
->sequence_number
= 0;
368 server
->session_estab
= false;
369 kfree(server
->session_key
.response
);
370 server
->session_key
.response
= NULL
;
371 server
->session_key
.len
= 0;
372 server
->lstrp
= jiffies
;
374 /* mark submitted MIDs for retry and issue callback */
375 INIT_LIST_HEAD(&retry_list
);
376 cifs_dbg(FYI
, "%s: moving mids to private list\n", __func__
);
377 spin_lock(&GlobalMid_Lock
);
378 list_for_each_safe(tmp
, tmp2
, &server
->pending_mid_q
) {
379 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
380 if (mid_entry
->mid_state
== MID_REQUEST_SUBMITTED
)
381 mid_entry
->mid_state
= MID_RETRY_NEEDED
;
382 list_move(&mid_entry
->qhead
, &retry_list
);
384 spin_unlock(&GlobalMid_Lock
);
385 mutex_unlock(&server
->srv_mutex
);
387 cifs_dbg(FYI
, "%s: issuing mid callbacks\n", __func__
);
388 list_for_each_safe(tmp
, tmp2
, &retry_list
) {
389 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
390 list_del_init(&mid_entry
->qhead
);
391 mid_entry
->callback(mid_entry
);
397 /* we should try only the port we connected to before */
398 mutex_lock(&server
->srv_mutex
);
399 rc
= generic_ip_connect(server
);
401 cifs_dbg(FYI
, "reconnect error %d\n", rc
);
402 mutex_unlock(&server
->srv_mutex
);
405 atomic_inc(&tcpSesReconnectCount
);
406 spin_lock(&GlobalMid_Lock
);
407 if (server
->tcpStatus
!= CifsExiting
)
408 server
->tcpStatus
= CifsNeedNegotiate
;
409 spin_unlock(&GlobalMid_Lock
);
410 mutex_unlock(&server
->srv_mutex
);
412 } while (server
->tcpStatus
== CifsNeedReconnect
);
418 cifs_echo_request(struct work_struct
*work
)
421 struct TCP_Server_Info
*server
= container_of(work
,
422 struct TCP_Server_Info
, echo
.work
);
423 unsigned long echo_interval
= server
->echo_interval
;
426 * We cannot send an echo if it is disabled or until the
427 * NEGOTIATE_PROTOCOL request is done, which is indicated by
428 * server->ops->need_neg() == true. Also, no need to ping if
429 * we got a response recently.
432 if (server
->tcpStatus
== CifsNeedReconnect
||
433 server
->tcpStatus
== CifsExiting
|| server
->tcpStatus
== CifsNew
||
434 (server
->ops
->can_echo
&& !server
->ops
->can_echo(server
)) ||
435 time_before(jiffies
, server
->lstrp
+ echo_interval
- HZ
))
438 rc
= server
->ops
->echo
? server
->ops
->echo(server
) : -ENOSYS
;
440 cifs_dbg(FYI
, "Unable to send echo request to server: %s\n",
444 queue_delayed_work(cifsiod_wq
, &server
->echo
, echo_interval
);
448 allocate_buffers(struct TCP_Server_Info
*server
)
450 if (!server
->bigbuf
) {
451 server
->bigbuf
= (char *)cifs_buf_get();
452 if (!server
->bigbuf
) {
453 cifs_dbg(VFS
, "No memory for large SMB response\n");
455 /* retry will check if exiting */
458 } else if (server
->large_buf
) {
459 /* we are reusing a dirty large buf, clear its start */
460 memset(server
->bigbuf
, 0, HEADER_SIZE(server
));
463 if (!server
->smallbuf
) {
464 server
->smallbuf
= (char *)cifs_small_buf_get();
465 if (!server
->smallbuf
) {
466 cifs_dbg(VFS
, "No memory for SMB response\n");
468 /* retry will check if exiting */
471 /* beginning of smb buffer is cleared in our buf_get */
473 /* if existing small buf clear beginning */
474 memset(server
->smallbuf
, 0, HEADER_SIZE(server
));
481 server_unresponsive(struct TCP_Server_Info
*server
)
484 * We need to wait 2 echo intervals to make sure we handle such
486 * 1s client sends a normal SMB request
487 * 2s client gets a response
488 * 30s echo workqueue job pops, and decides we got a response recently
489 * and don't need to send another
491 * 65s kernel_recvmsg times out, and we see that we haven't gotten
492 * a response in >60s.
494 if (server
->tcpStatus
== CifsGood
&&
495 time_after(jiffies
, server
->lstrp
+ 2 * server
->echo_interval
)) {
496 cifs_dbg(VFS
, "Server %s has not responded in %lu seconds. Reconnecting...\n",
497 server
->hostname
, (2 * server
->echo_interval
) / HZ
);
498 cifs_reconnect(server
);
499 wake_up(&server
->response_q
);
507 cifs_readv_from_socket(struct TCP_Server_Info
*server
, struct msghdr
*smb_msg
)
512 smb_msg
->msg_control
= NULL
;
513 smb_msg
->msg_controllen
= 0;
515 for (total_read
= 0; msg_data_left(smb_msg
); total_read
+= length
) {
518 if (server_unresponsive(server
))
519 return -ECONNABORTED
;
521 length
= sock_recvmsg(server
->ssocket
, smb_msg
, 0);
523 if (server
->tcpStatus
== CifsExiting
)
526 if (server
->tcpStatus
== CifsNeedReconnect
) {
527 cifs_reconnect(server
);
528 return -ECONNABORTED
;
531 if (length
== -ERESTARTSYS
||
535 * Minimum sleep to prevent looping, allowing socket
536 * to clear and app threads to set tcpStatus
537 * CifsNeedReconnect if server hung.
539 usleep_range(1000, 2000);
545 cifs_dbg(FYI
, "Received no data or error: %d\n", length
);
546 cifs_reconnect(server
);
547 return -ECONNABORTED
;
554 cifs_read_from_socket(struct TCP_Server_Info
*server
, char *buf
,
555 unsigned int to_read
)
557 struct msghdr smb_msg
;
558 struct kvec iov
= {.iov_base
= buf
, .iov_len
= to_read
};
559 iov_iter_kvec(&smb_msg
.msg_iter
, READ
| ITER_KVEC
, &iov
, 1, to_read
);
561 return cifs_readv_from_socket(server
, &smb_msg
);
565 cifs_read_page_from_socket(struct TCP_Server_Info
*server
, struct page
*page
,
566 unsigned int to_read
)
568 struct msghdr smb_msg
;
569 struct bio_vec bv
= {.bv_page
= page
, .bv_len
= to_read
};
570 iov_iter_bvec(&smb_msg
.msg_iter
, READ
| ITER_BVEC
, &bv
, 1, to_read
);
571 return cifs_readv_from_socket(server
, &smb_msg
);
575 is_smb_response(struct TCP_Server_Info
*server
, unsigned char type
)
578 * The first byte big endian of the length field,
579 * is actually not part of the length but the type
580 * with the most common, zero, as regular data.
583 case RFC1002_SESSION_MESSAGE
:
584 /* Regular SMB response */
586 case RFC1002_SESSION_KEEP_ALIVE
:
587 cifs_dbg(FYI
, "RFC 1002 session keep alive\n");
589 case RFC1002_POSITIVE_SESSION_RESPONSE
:
590 cifs_dbg(FYI
, "RFC 1002 positive session response\n");
592 case RFC1002_NEGATIVE_SESSION_RESPONSE
:
594 * We get this from Windows 98 instead of an error on
595 * SMB negprot response.
597 cifs_dbg(FYI
, "RFC 1002 negative session response\n");
598 /* give server a second to clean up */
601 * Always try 445 first on reconnect since we get NACK
602 * on some if we ever connected to port 139 (the NACK
603 * is since we do not begin with RFC1001 session
606 cifs_set_port((struct sockaddr
*)&server
->dstaddr
, CIFS_PORT
);
607 cifs_reconnect(server
);
608 wake_up(&server
->response_q
);
611 cifs_dbg(VFS
, "RFC 1002 unknown response type 0x%x\n", type
);
612 cifs_reconnect(server
);
619 dequeue_mid(struct mid_q_entry
*mid
, bool malformed
)
621 #ifdef CONFIG_CIFS_STATS2
622 mid
->when_received
= jiffies
;
624 spin_lock(&GlobalMid_Lock
);
626 mid
->mid_state
= MID_RESPONSE_RECEIVED
;
628 mid
->mid_state
= MID_RESPONSE_MALFORMED
;
629 list_del_init(&mid
->qhead
);
630 spin_unlock(&GlobalMid_Lock
);
634 handle_mid(struct mid_q_entry
*mid
, struct TCP_Server_Info
*server
,
635 char *buf
, int malformed
)
637 if (server
->ops
->check_trans2
&&
638 server
->ops
->check_trans2(mid
, server
, buf
, malformed
))
641 mid
->large_buf
= server
->large_buf
;
642 /* Was previous buf put in mpx struct for multi-rsp? */
643 if (!mid
->multiRsp
) {
644 /* smb buffer will be freed by user thread */
645 if (server
->large_buf
)
646 server
->bigbuf
= NULL
;
648 server
->smallbuf
= NULL
;
650 dequeue_mid(mid
, malformed
);
653 static void clean_demultiplex_info(struct TCP_Server_Info
*server
)
657 /* take it off the list, if it's not already */
658 spin_lock(&cifs_tcp_ses_lock
);
659 list_del_init(&server
->tcp_ses_list
);
660 spin_unlock(&cifs_tcp_ses_lock
);
662 spin_lock(&GlobalMid_Lock
);
663 server
->tcpStatus
= CifsExiting
;
664 spin_unlock(&GlobalMid_Lock
);
665 wake_up_all(&server
->response_q
);
667 /* check if we have blocked requests that need to free */
668 spin_lock(&server
->req_lock
);
669 if (server
->credits
<= 0)
671 spin_unlock(&server
->req_lock
);
673 * Although there should not be any requests blocked on this queue it
674 * can not hurt to be paranoid and try to wake up requests that may
675 * haven been blocked when more than 50 at time were on the wire to the
676 * same server - they now will see the session is in exit state and get
677 * out of SendReceive.
679 wake_up_all(&server
->request_q
);
680 /* give those requests time to exit */
683 if (server
->ssocket
) {
684 sock_release(server
->ssocket
);
685 server
->ssocket
= NULL
;
688 if (!list_empty(&server
->pending_mid_q
)) {
689 struct list_head dispose_list
;
690 struct mid_q_entry
*mid_entry
;
691 struct list_head
*tmp
, *tmp2
;
693 INIT_LIST_HEAD(&dispose_list
);
694 spin_lock(&GlobalMid_Lock
);
695 list_for_each_safe(tmp
, tmp2
, &server
->pending_mid_q
) {
696 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
697 cifs_dbg(FYI
, "Clearing mid 0x%llx\n", mid_entry
->mid
);
698 mid_entry
->mid_state
= MID_SHUTDOWN
;
699 list_move(&mid_entry
->qhead
, &dispose_list
);
701 spin_unlock(&GlobalMid_Lock
);
703 /* now walk dispose list and issue callbacks */
704 list_for_each_safe(tmp
, tmp2
, &dispose_list
) {
705 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
706 cifs_dbg(FYI
, "Callback mid 0x%llx\n", mid_entry
->mid
);
707 list_del_init(&mid_entry
->qhead
);
708 mid_entry
->callback(mid_entry
);
710 /* 1/8th of sec is more than enough time for them to exit */
714 if (!list_empty(&server
->pending_mid_q
)) {
716 * mpx threads have not exited yet give them at least the smb
717 * send timeout time for long ops.
719 * Due to delays on oplock break requests, we need to wait at
720 * least 45 seconds before giving up on a request getting a
721 * response and going ahead and killing cifsd.
723 cifs_dbg(FYI
, "Wait for exit from demultiplex thread\n");
726 * If threads still have not exited they are probably never
727 * coming home not much else we can do but free the memory.
731 kfree(server
->hostname
);
734 length
= atomic_dec_return(&tcpSesAllocCount
);
736 mempool_resize(cifs_req_poolp
, length
+ cifs_min_rcv
);
740 standard_receive3(struct TCP_Server_Info
*server
, struct mid_q_entry
*mid
)
743 char *buf
= server
->smallbuf
;
744 unsigned int pdu_length
= get_rfc1002_length(buf
);
746 /* make sure this will fit in a large buffer */
747 if (pdu_length
> CIFSMaxBufSize
+ MAX_HEADER_SIZE(server
) - 4) {
748 cifs_dbg(VFS
, "SMB response too long (%u bytes)\n", pdu_length
);
749 cifs_reconnect(server
);
750 wake_up(&server
->response_q
);
751 return -ECONNABORTED
;
754 /* switch to large buffer if too big for a small one */
755 if (pdu_length
> MAX_CIFS_SMALL_BUFFER_SIZE
- 4) {
756 server
->large_buf
= true;
757 memcpy(server
->bigbuf
, buf
, server
->total_read
);
758 buf
= server
->bigbuf
;
761 /* now read the rest */
762 length
= cifs_read_from_socket(server
, buf
+ HEADER_SIZE(server
) - 1,
763 pdu_length
- HEADER_SIZE(server
) + 1 + 4);
766 server
->total_read
+= length
;
768 dump_smb(buf
, server
->total_read
);
771 * We know that we received enough to get to the MID as we
772 * checked the pdu_length earlier. Now check to see
773 * if the rest of the header is OK. We borrow the length
774 * var for the rest of the loop to avoid a new stack var.
776 * 48 bytes is enough to display the header and a little bit
777 * into the payload for debugging purposes.
779 length
= server
->ops
->check_message(buf
, server
->total_read
, server
);
781 cifs_dump_mem("Bad SMB: ", buf
,
782 min_t(unsigned int, server
->total_read
, 48));
784 if (server
->ops
->is_status_pending
&&
785 server
->ops
->is_status_pending(buf
, server
, length
))
791 handle_mid(mid
, server
, buf
, length
);
796 cifs_demultiplex_thread(void *p
)
799 struct TCP_Server_Info
*server
= p
;
800 unsigned int pdu_length
;
802 struct task_struct
*task_to_wake
= NULL
;
803 struct mid_q_entry
*mid_entry
;
805 current
->flags
|= PF_MEMALLOC
;
806 cifs_dbg(FYI
, "Demultiplex PID: %d\n", task_pid_nr(current
));
808 length
= atomic_inc_return(&tcpSesAllocCount
);
810 mempool_resize(cifs_req_poolp
, length
+ cifs_min_rcv
);
813 while (server
->tcpStatus
!= CifsExiting
) {
817 if (!allocate_buffers(server
))
820 server
->large_buf
= false;
821 buf
= server
->smallbuf
;
822 pdu_length
= 4; /* enough to get RFC1001 header */
824 length
= cifs_read_from_socket(server
, buf
, pdu_length
);
827 server
->total_read
= length
;
830 * The right amount was read from socket - 4 bytes,
831 * so we can now interpret the length field.
833 pdu_length
= get_rfc1002_length(buf
);
835 cifs_dbg(FYI
, "RFC1002 header 0x%x\n", pdu_length
);
836 if (!is_smb_response(server
, buf
[0]))
839 /* make sure we have enough to get to the MID */
840 if (pdu_length
< HEADER_SIZE(server
) - 1 - 4) {
841 cifs_dbg(VFS
, "SMB response too short (%u bytes)\n",
843 cifs_reconnect(server
);
844 wake_up(&server
->response_q
);
848 /* read down to the MID */
849 length
= cifs_read_from_socket(server
, buf
+ 4,
850 HEADER_SIZE(server
) - 1 - 4);
853 server
->total_read
+= length
;
855 mid_entry
= server
->ops
->find_mid(server
, buf
);
857 if (!mid_entry
|| !mid_entry
->receive
)
858 length
= standard_receive3(server
, mid_entry
);
860 length
= mid_entry
->receive(server
, mid_entry
);
865 if (server
->large_buf
)
866 buf
= server
->bigbuf
;
868 server
->lstrp
= jiffies
;
869 if (mid_entry
!= NULL
) {
870 if (!mid_entry
->multiRsp
|| mid_entry
->multiEnd
)
871 mid_entry
->callback(mid_entry
);
872 } else if (!server
->ops
->is_oplock_break
||
873 !server
->ops
->is_oplock_break(buf
, server
)) {
874 cifs_dbg(VFS
, "No task to wake, unknown frame received! NumMids %d\n",
875 atomic_read(&midCount
));
876 cifs_dump_mem("Received Data is: ", buf
,
877 HEADER_SIZE(server
));
878 #ifdef CONFIG_CIFS_DEBUG2
879 if (server
->ops
->dump_detail
)
880 server
->ops
->dump_detail(buf
);
881 cifs_dump_mids(server
);
882 #endif /* CIFS_DEBUG2 */
885 } /* end while !EXITING */
887 /* buffer usually freed in free_mid - need to free it here on exit */
888 cifs_buf_release(server
->bigbuf
);
889 if (server
->smallbuf
) /* no sense logging a debug message if NULL */
890 cifs_small_buf_release(server
->smallbuf
);
892 task_to_wake
= xchg(&server
->tsk
, NULL
);
893 clean_demultiplex_info(server
);
895 /* if server->tsk was NULL then wait for a signal before exiting */
897 set_current_state(TASK_INTERRUPTIBLE
);
898 while (!signal_pending(current
)) {
900 set_current_state(TASK_INTERRUPTIBLE
);
902 set_current_state(TASK_RUNNING
);
905 module_put_and_exit(0);
908 /* extract the host portion of the UNC string */
910 extract_hostname(const char *unc
)
916 /* skip double chars at beginning of string */
917 /* BB: check validity of these bytes? */
920 /* delimiter between hostname and sharename is always '\\' now */
921 delim
= strchr(src
, '\\');
923 return ERR_PTR(-EINVAL
);
926 dst
= kmalloc((len
+ 1), GFP_KERNEL
);
928 return ERR_PTR(-ENOMEM
);
930 memcpy(dst
, src
, len
);
936 static int get_option_ul(substring_t args
[], unsigned long *option
)
941 string
= match_strdup(args
);
944 rc
= kstrtoul(string
, 0, option
);
950 static int get_option_uid(substring_t args
[], kuid_t
*result
)
956 rc
= get_option_ul(args
, &value
);
960 uid
= make_kuid(current_user_ns(), value
);
968 static int get_option_gid(substring_t args
[], kgid_t
*result
)
974 rc
= get_option_ul(args
, &value
);
978 gid
= make_kgid(current_user_ns(), value
);
986 static int cifs_parse_security_flavors(char *value
,
990 substring_t args
[MAX_OPT_ARGS
];
993 * With mount options, the last one should win. Reset any existing
994 * settings back to default.
996 vol
->sectype
= Unspecified
;
999 switch (match_token(value
, cifs_secflavor_tokens
, args
)) {
1001 cifs_dbg(VFS
, "sec=krb5p is not supported!\n");
1007 vol
->sectype
= Kerberos
;
1009 case Opt_sec_ntlmsspi
:
1012 case Opt_sec_ntlmssp
:
1013 vol
->sectype
= RawNTLMSSP
;
1019 vol
->sectype
= NTLM
;
1021 case Opt_sec_ntlmv2i
:
1024 case Opt_sec_ntlmv2
:
1025 vol
->sectype
= NTLMv2
;
1027 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1028 case Opt_sec_lanman
:
1029 vol
->sectype
= LANMAN
;
1036 cifs_dbg(VFS
, "bad security option: %s\n", value
);
1044 cifs_parse_cache_flavor(char *value
, struct smb_vol
*vol
)
1046 substring_t args
[MAX_OPT_ARGS
];
1048 switch (match_token(value
, cifs_cacheflavor_tokens
, args
)) {
1049 case Opt_cache_loose
:
1050 vol
->direct_io
= false;
1051 vol
->strict_io
= false;
1053 case Opt_cache_strict
:
1054 vol
->direct_io
= false;
1055 vol
->strict_io
= true;
1057 case Opt_cache_none
:
1058 vol
->direct_io
= true;
1059 vol
->strict_io
= false;
1062 cifs_dbg(VFS
, "bad cache= option: %s\n", value
);
1069 cifs_parse_smb_version(char *value
, struct smb_vol
*vol
)
1071 substring_t args
[MAX_OPT_ARGS
];
1073 switch (match_token(value
, cifs_smb_version_tokens
, args
)) {
1075 vol
->ops
= &smb1_operations
;
1076 vol
->vals
= &smb1_values
;
1078 #ifdef CONFIG_CIFS_SMB2
1080 vol
->ops
= &smb20_operations
;
1081 vol
->vals
= &smb20_values
;
1084 vol
->ops
= &smb21_operations
;
1085 vol
->vals
= &smb21_values
;
1088 vol
->ops
= &smb30_operations
;
1089 vol
->vals
= &smb30_values
;
1092 vol
->ops
= &smb30_operations
; /* currently identical with 3.0 */
1093 vol
->vals
= &smb302_values
;
1095 #ifdef CONFIG_CIFS_SMB311
1097 vol
->ops
= &smb311_operations
;
1098 vol
->vals
= &smb311_values
;
1103 cifs_dbg(VFS
, "Unknown vers= option specified: %s\n", value
);
1110 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1111 * fields with the result. Returns 0 on success and an error otherwise.
1114 cifs_parse_devname(const char *devname
, struct smb_vol
*vol
)
1117 const char *delims
= "/\\";
1120 /* make sure we have a valid UNC double delimiter prefix */
1121 len
= strspn(devname
, delims
);
1125 /* find delimiter between host and sharename */
1126 pos
= strpbrk(devname
+ 2, delims
);
1130 /* skip past delimiter */
1133 /* now go until next delimiter or end of string */
1134 len
= strcspn(pos
, delims
);
1136 /* move "pos" up to delimiter or NULL */
1138 vol
->UNC
= kstrndup(devname
, pos
- devname
, GFP_KERNEL
);
1142 convert_delimiter(vol
->UNC
, '\\');
1144 /* skip any delimiter */
1145 if (*pos
== '/' || *pos
== '\\')
1148 /* If pos is NULL then no prepath */
1152 vol
->prepath
= kstrdup(pos
, GFP_KERNEL
);
1160 cifs_parse_mount_options(const char *mountdata
, const char *devname
,
1161 struct smb_vol
*vol
)
1164 char *mountdata_copy
= NULL
, *options
;
1165 unsigned int temp_len
, i
, j
;
1167 short int override_uid
= -1;
1168 short int override_gid
= -1;
1169 bool uid_specified
= false;
1170 bool gid_specified
= false;
1171 bool sloppy
= false;
1172 char *invalid
= NULL
;
1173 char *nodename
= utsname()->nodename
;
1174 char *string
= NULL
;
1175 char *tmp_end
, *value
;
1177 bool got_ip
= false;
1178 unsigned short port
= 0;
1179 struct sockaddr
*dstaddr
= (struct sockaddr
*)&vol
->dstaddr
;
1183 delim
= separator
[0];
1185 /* ensure we always start with zeroed-out smb_vol */
1186 memset(vol
, 0, sizeof(*vol
));
1189 * does not have to be perfect mapping since field is
1190 * informational, only used for servers that do not support
1191 * port 445 and it can be overridden at mount time
1193 memset(vol
->source_rfc1001_name
, 0x20, RFC1001_NAME_LEN
);
1194 for (i
= 0; i
< strnlen(nodename
, RFC1001_NAME_LEN
); i
++)
1195 vol
->source_rfc1001_name
[i
] = toupper(nodename
[i
]);
1197 vol
->source_rfc1001_name
[RFC1001_NAME_LEN
] = 0;
1198 /* null target name indicates to use *SMBSERVR default called name
1199 if we end up sending RFC1001 session initialize */
1200 vol
->target_rfc1001_name
[0] = 0;
1201 vol
->cred_uid
= current_uid();
1202 vol
->linux_uid
= current_uid();
1203 vol
->linux_gid
= current_gid();
1206 * default to SFM style remapping of seven reserved characters
1207 * unless user overrides it or we negotiate CIFS POSIX where
1208 * it is unnecessary. Can not simultaneously use more than one mapping
1209 * since then readdir could list files that open could not open
1213 /* default to only allowing write access to owner of the mount */
1214 vol
->dir_mode
= vol
->file_mode
= S_IRUGO
| S_IXUGO
| S_IWUSR
;
1216 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1217 /* default is always to request posix paths. */
1218 vol
->posix_paths
= 1;
1219 /* default to using server inode numbers where available */
1220 vol
->server_ino
= 1;
1222 /* default is to use strict cifs caching semantics */
1223 vol
->strict_io
= true;
1225 vol
->actimeo
= CIFS_DEF_ACTIMEO
;
1227 /* FIXME: add autonegotiation -- for now, SMB1 is default */
1228 vol
->ops
= &smb1_operations
;
1229 vol
->vals
= &smb1_values
;
1232 goto cifs_parse_mount_err
;
1234 mountdata_copy
= kstrndup(mountdata
, PAGE_SIZE
, GFP_KERNEL
);
1235 if (!mountdata_copy
)
1236 goto cifs_parse_mount_err
;
1238 options
= mountdata_copy
;
1239 end
= options
+ strlen(options
);
1241 if (strncmp(options
, "sep=", 4) == 0) {
1242 if (options
[4] != 0) {
1243 separator
[0] = options
[4];
1246 cifs_dbg(FYI
, "Null separator not allowed\n");
1249 vol
->backupuid_specified
= false; /* no backup intent for a user */
1250 vol
->backupgid_specified
= false; /* no backup intent for a group */
1252 switch (cifs_parse_devname(devname
, vol
)) {
1256 cifs_dbg(VFS
, "Unable to allocate memory for devname.\n");
1257 goto cifs_parse_mount_err
;
1259 cifs_dbg(VFS
, "Malformed UNC in devname.\n");
1260 goto cifs_parse_mount_err
;
1262 cifs_dbg(VFS
, "Unknown error parsing devname.\n");
1263 goto cifs_parse_mount_err
;
1266 while ((data
= strsep(&options
, separator
)) != NULL
) {
1267 substring_t args
[MAX_OPT_ARGS
];
1268 unsigned long option
;
1274 token
= match_token(data
, cifs_mount_option_tokens
, args
);
1278 /* Ingnore the following */
1282 /* Boolean values */
1283 case Opt_user_xattr
:
1286 case Opt_nouser_xattr
:
1292 case Opt_noforceuid
:
1298 case Opt_noforcegid
:
1301 case Opt_noblocksend
:
1302 vol
->noblocksnd
= 1;
1304 case Opt_noautotune
:
1305 vol
->noautotune
= 1;
1320 vol
->sfu_remap
= true;
1321 vol
->remap
= false; /* disable SFM mapping */
1323 case Opt_nomapchars
:
1324 vol
->sfu_remap
= false;
1328 vol
->sfu_remap
= false; /* disable SFU mapping */
1330 case Opt_nomapposix
:
1342 case Opt_posixpaths
:
1343 vol
->posix_paths
= 1;
1345 case Opt_noposixpaths
:
1346 vol
->posix_paths
= 0;
1349 vol
->no_linux_ext
= 1;
1360 * turn off mandatory locking in mode
1361 * if remote locking is turned off since the
1362 * local vfs will do advisory
1364 if (vol
->file_mode
==
1365 (S_IALLUGO
& ~(S_ISUID
| S_IXGRP
)))
1366 vol
->file_mode
= S_IALLUGO
;
1368 case Opt_forcemandatorylock
:
1378 vol
->dynperm
= true;
1381 vol
->dynperm
= false;
1395 case Opt_nostrictsync
:
1396 vol
->nostrictsync
= 1;
1398 case Opt_strictsync
:
1399 vol
->nostrictsync
= 0;
1402 vol
->server_ino
= 1;
1404 case Opt_noserverino
:
1405 vol
->server_ino
= 0;
1407 case Opt_rwpidforward
:
1408 vol
->rwpidforward
= 1;
1417 vol
->no_psx_acl
= 0;
1420 vol
->no_psx_acl
= 1;
1422 case Opt_locallease
:
1423 vol
->local_lease
= 1;
1429 /* we do not do the following in secFlags because seal
1430 * is a per tree connection (mount) not a per socket
1431 * or per-smb connection option in the protocol
1432 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1437 pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1440 #ifndef CONFIG_CIFS_FSCACHE
1441 cifs_dbg(VFS
, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1442 goto cifs_parse_mount_err
;
1446 case Opt_mfsymlinks
:
1447 vol
->mfsymlinks
= true;
1450 vol
->multiuser
= true;
1455 case Opt_nosharesock
:
1456 vol
->nosharesock
= true;
1458 case Opt_nopersistent
:
1459 vol
->nopersistent
= true;
1460 if (vol
->persistent
) {
1462 "persistenthandles mount options conflict\n");
1463 goto cifs_parse_mount_err
;
1466 case Opt_persistent
:
1467 vol
->persistent
= true;
1468 if ((vol
->nopersistent
) || (vol
->resilient
)) {
1470 "persistenthandles mount options conflict\n");
1471 goto cifs_parse_mount_err
;
1475 vol
->resilient
= true;
1476 if (vol
->persistent
) {
1478 "persistenthandles mount options conflict\n");
1479 goto cifs_parse_mount_err
;
1482 case Opt_noresilient
:
1483 vol
->resilient
= false; /* already the default */
1486 /* Numeric Values */
1488 if (get_option_uid(args
, &vol
->backupuid
)) {
1489 cifs_dbg(VFS
, "%s: Invalid backupuid value\n",
1491 goto cifs_parse_mount_err
;
1493 vol
->backupuid_specified
= true;
1496 if (get_option_gid(args
, &vol
->backupgid
)) {
1497 cifs_dbg(VFS
, "%s: Invalid backupgid value\n",
1499 goto cifs_parse_mount_err
;
1501 vol
->backupgid_specified
= true;
1504 if (get_option_uid(args
, &vol
->linux_uid
)) {
1505 cifs_dbg(VFS
, "%s: Invalid uid value\n",
1507 goto cifs_parse_mount_err
;
1509 uid_specified
= true;
1512 if (get_option_uid(args
, &vol
->cred_uid
)) {
1513 cifs_dbg(VFS
, "%s: Invalid cruid value\n",
1515 goto cifs_parse_mount_err
;
1519 if (get_option_gid(args
, &vol
->linux_gid
)) {
1520 cifs_dbg(VFS
, "%s: Invalid gid value\n",
1522 goto cifs_parse_mount_err
;
1524 gid_specified
= true;
1527 if (get_option_ul(args
, &option
)) {
1528 cifs_dbg(VFS
, "%s: Invalid file_mode value\n",
1530 goto cifs_parse_mount_err
;
1532 vol
->file_mode
= option
;
1535 if (get_option_ul(args
, &option
)) {
1536 cifs_dbg(VFS
, "%s: Invalid dir_mode value\n",
1538 goto cifs_parse_mount_err
;
1540 vol
->dir_mode
= option
;
1543 if (get_option_ul(args
, &option
) ||
1544 option
> USHRT_MAX
) {
1545 cifs_dbg(VFS
, "%s: Invalid port value\n",
1547 goto cifs_parse_mount_err
;
1549 port
= (unsigned short)option
;
1552 if (get_option_ul(args
, &option
)) {
1553 cifs_dbg(VFS
, "%s: Invalid rsize value\n",
1555 goto cifs_parse_mount_err
;
1557 vol
->rsize
= option
;
1560 if (get_option_ul(args
, &option
)) {
1561 cifs_dbg(VFS
, "%s: Invalid wsize value\n",
1563 goto cifs_parse_mount_err
;
1565 vol
->wsize
= option
;
1568 if (get_option_ul(args
, &option
)) {
1569 cifs_dbg(VFS
, "%s: Invalid actimeo value\n",
1571 goto cifs_parse_mount_err
;
1573 vol
->actimeo
= HZ
* option
;
1574 if (vol
->actimeo
> CIFS_MAX_ACTIMEO
) {
1575 cifs_dbg(VFS
, "attribute cache timeout too large\n");
1576 goto cifs_parse_mount_err
;
1579 case Opt_echo_interval
:
1580 if (get_option_ul(args
, &option
)) {
1581 cifs_dbg(VFS
, "%s: Invalid echo interval value\n",
1583 goto cifs_parse_mount_err
;
1585 vol
->echo_interval
= option
;
1588 /* String Arguments */
1590 case Opt_blank_user
:
1591 /* null user, ie. anonymous authentication */
1593 vol
->username
= NULL
;
1596 string
= match_strdup(args
);
1600 if (strnlen(string
, CIFS_MAX_USERNAME_LEN
) >
1601 CIFS_MAX_USERNAME_LEN
) {
1602 pr_warn("CIFS: username too long\n");
1603 goto cifs_parse_mount_err
;
1606 kfree(vol
->username
);
1607 vol
->username
= kstrdup(string
, GFP_KERNEL
);
1609 goto cifs_parse_mount_err
;
1611 case Opt_blank_pass
:
1612 /* passwords have to be handled differently
1613 * to allow the character used for deliminator
1614 * to be passed within them
1618 * Check if this is a case where the password
1619 * starts with a delimiter
1621 tmp_end
= strchr(data
, '=');
1623 if (!(tmp_end
< end
&& tmp_end
[1] == delim
)) {
1624 /* No it is not. Set the password to NULL */
1625 kfree(vol
->password
);
1626 vol
->password
= NULL
;
1629 /* Yes it is. Drop down to Opt_pass below.*/
1631 /* Obtain the value string */
1632 value
= strchr(data
, '=');
1635 /* Set tmp_end to end of the string */
1636 tmp_end
= (char *) value
+ strlen(value
);
1638 /* Check if following character is the deliminator
1639 * If yes, we have encountered a double deliminator
1640 * reset the NULL character to the deliminator
1642 if (tmp_end
< end
&& tmp_end
[1] == delim
) {
1645 /* Keep iterating until we get to a single
1646 * deliminator OR the end
1648 while ((tmp_end
= strchr(tmp_end
, delim
))
1649 != NULL
&& (tmp_end
[1] == delim
)) {
1650 tmp_end
= (char *) &tmp_end
[2];
1653 /* Reset var options to point to next element */
1656 options
= (char *) &tmp_end
[1];
1658 /* Reached the end of the mount option
1663 kfree(vol
->password
);
1664 /* Now build new password string */
1665 temp_len
= strlen(value
);
1666 vol
->password
= kzalloc(temp_len
+1, GFP_KERNEL
);
1667 if (vol
->password
== NULL
) {
1668 pr_warn("CIFS: no memory for password\n");
1669 goto cifs_parse_mount_err
;
1672 for (i
= 0, j
= 0; i
< temp_len
; i
++, j
++) {
1673 vol
->password
[j
] = value
[i
];
1674 if ((value
[i
] == delim
) &&
1675 value
[i
+1] == delim
)
1676 /* skip the second deliminator */
1679 vol
->password
[j
] = '\0';
1682 /* FIXME: should this be an error instead? */
1686 string
= match_strdup(args
);
1690 if (!cifs_convert_address(dstaddr
, string
,
1692 pr_err("CIFS: bad ip= option (%s).\n", string
);
1693 goto cifs_parse_mount_err
;
1698 string
= match_strdup(args
);
1702 if (strnlen(string
, CIFS_MAX_DOMAINNAME_LEN
)
1703 == CIFS_MAX_DOMAINNAME_LEN
) {
1704 pr_warn("CIFS: domain name too long\n");
1705 goto cifs_parse_mount_err
;
1708 kfree(vol
->domainname
);
1709 vol
->domainname
= kstrdup(string
, GFP_KERNEL
);
1710 if (!vol
->domainname
) {
1711 pr_warn("CIFS: no memory for domainname\n");
1712 goto cifs_parse_mount_err
;
1714 cifs_dbg(FYI
, "Domain name set\n");
1717 string
= match_strdup(args
);
1721 if (!cifs_convert_address(
1722 (struct sockaddr
*)&vol
->srcaddr
,
1723 string
, strlen(string
))) {
1724 pr_warn("CIFS: Could not parse srcaddr: %s\n",
1726 goto cifs_parse_mount_err
;
1730 string
= match_strdup(args
);
1734 if (strnlen(string
, 1024) >= 65) {
1735 pr_warn("CIFS: iocharset name too long.\n");
1736 goto cifs_parse_mount_err
;
1739 if (strncasecmp(string
, "default", 7) != 0) {
1740 kfree(vol
->iocharset
);
1741 vol
->iocharset
= kstrdup(string
,
1743 if (!vol
->iocharset
) {
1744 pr_warn("CIFS: no memory for charset\n");
1745 goto cifs_parse_mount_err
;
1748 /* if iocharset not set then load_nls_default
1751 cifs_dbg(FYI
, "iocharset set to %s\n", string
);
1753 case Opt_netbiosname
:
1754 string
= match_strdup(args
);
1758 memset(vol
->source_rfc1001_name
, 0x20,
1761 * FIXME: are there cases in which a comma can
1762 * be valid in workstation netbios name (and
1763 * need special handling)?
1765 for (i
= 0; i
< RFC1001_NAME_LEN
; i
++) {
1766 /* don't ucase netbiosname for user */
1769 vol
->source_rfc1001_name
[i
] = string
[i
];
1771 /* The string has 16th byte zero still from
1772 * set at top of the function
1774 if (i
== RFC1001_NAME_LEN
&& string
[i
] != 0)
1775 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
1778 /* servernetbiosname specified override *SMBSERVER */
1779 string
= match_strdup(args
);
1783 /* last byte, type, is 0x20 for servr type */
1784 memset(vol
->target_rfc1001_name
, 0x20,
1785 RFC1001_NAME_LEN_WITH_NULL
);
1787 /* BB are there cases in which a comma can be
1788 valid in this workstation netbios name
1789 (and need special handling)? */
1791 /* user or mount helper must uppercase the
1793 for (i
= 0; i
< 15; i
++) {
1796 vol
->target_rfc1001_name
[i
] = string
[i
];
1798 /* The string has 16th byte zero still from
1799 set at top of the function */
1800 if (i
== RFC1001_NAME_LEN
&& string
[i
] != 0)
1801 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
1804 string
= match_strdup(args
);
1808 if (strncasecmp(string
, "1", 1) == 0) {
1809 /* This is the default */
1812 /* For all other value, error */
1813 pr_warn("CIFS: Invalid version specified\n");
1814 goto cifs_parse_mount_err
;
1816 string
= match_strdup(args
);
1820 if (cifs_parse_smb_version(string
, vol
) != 0)
1821 goto cifs_parse_mount_err
;
1824 string
= match_strdup(args
);
1828 if (cifs_parse_security_flavors(string
, vol
) != 0)
1829 goto cifs_parse_mount_err
;
1832 string
= match_strdup(args
);
1836 if (cifs_parse_cache_flavor(string
, vol
) != 0)
1837 goto cifs_parse_mount_err
;
1841 * An option we don't recognize. Save it off for later
1842 * if we haven't already found one
1848 /* Free up any allocated string */
1853 if (!sloppy
&& invalid
) {
1854 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid
);
1855 goto cifs_parse_mount_err
;
1859 /* Muliuser mounts require CONFIG_KEYS support */
1860 if (vol
->multiuser
) {
1861 cifs_dbg(VFS
, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
1862 goto cifs_parse_mount_err
;
1866 cifs_dbg(VFS
, "CIFS mount error: No usable UNC path provided in device string!\n");
1867 goto cifs_parse_mount_err
;
1870 /* make sure UNC has a share name */
1871 if (!strchr(vol
->UNC
+ 3, '\\')) {
1872 cifs_dbg(VFS
, "Malformed UNC. Unable to find share name.\n");
1873 goto cifs_parse_mount_err
;
1877 /* No ip= option specified? Try to get it from UNC */
1878 if (!cifs_convert_address(dstaddr
, &vol
->UNC
[2],
1879 strlen(&vol
->UNC
[2]))) {
1880 pr_err("Unable to determine destination address.\n");
1881 goto cifs_parse_mount_err
;
1885 /* set the port that we got earlier */
1886 cifs_set_port(dstaddr
, port
);
1889 vol
->override_uid
= override_uid
;
1890 else if (override_uid
== 1)
1891 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
1894 vol
->override_gid
= override_gid
;
1895 else if (override_gid
== 1)
1896 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
1898 kfree(mountdata_copy
);
1902 pr_warn("Could not allocate temporary buffer\n");
1903 cifs_parse_mount_err
:
1905 kfree(mountdata_copy
);
1909 /** Returns true if srcaddr isn't specified and rhs isn't
1910 * specified, or if srcaddr is specified and
1911 * matches the IP address of the rhs argument.
1914 srcip_matches(struct sockaddr
*srcaddr
, struct sockaddr
*rhs
)
1916 switch (srcaddr
->sa_family
) {
1918 return (rhs
->sa_family
== AF_UNSPEC
);
1920 struct sockaddr_in
*saddr4
= (struct sockaddr_in
*)srcaddr
;
1921 struct sockaddr_in
*vaddr4
= (struct sockaddr_in
*)rhs
;
1922 return (saddr4
->sin_addr
.s_addr
== vaddr4
->sin_addr
.s_addr
);
1925 struct sockaddr_in6
*saddr6
= (struct sockaddr_in6
*)srcaddr
;
1926 struct sockaddr_in6
*vaddr6
= (struct sockaddr_in6
*)rhs
;
1927 return ipv6_addr_equal(&saddr6
->sin6_addr
, &vaddr6
->sin6_addr
);
1931 return false; /* don't expect to be here */
1936 * If no port is specified in addr structure, we try to match with 445 port
1937 * and if it fails - with 139 ports. It should be called only if address
1938 * families of server and addr are equal.
1941 match_port(struct TCP_Server_Info
*server
, struct sockaddr
*addr
)
1943 __be16 port
, *sport
;
1945 switch (addr
->sa_family
) {
1947 sport
= &((struct sockaddr_in
*) &server
->dstaddr
)->sin_port
;
1948 port
= ((struct sockaddr_in
*) addr
)->sin_port
;
1951 sport
= &((struct sockaddr_in6
*) &server
->dstaddr
)->sin6_port
;
1952 port
= ((struct sockaddr_in6
*) addr
)->sin6_port
;
1960 port
= htons(CIFS_PORT
);
1964 port
= htons(RFC1001_PORT
);
1967 return port
== *sport
;
1971 match_address(struct TCP_Server_Info
*server
, struct sockaddr
*addr
,
1972 struct sockaddr
*srcaddr
)
1974 switch (addr
->sa_family
) {
1976 struct sockaddr_in
*addr4
= (struct sockaddr_in
*)addr
;
1977 struct sockaddr_in
*srv_addr4
=
1978 (struct sockaddr_in
*)&server
->dstaddr
;
1980 if (addr4
->sin_addr
.s_addr
!= srv_addr4
->sin_addr
.s_addr
)
1985 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)addr
;
1986 struct sockaddr_in6
*srv_addr6
=
1987 (struct sockaddr_in6
*)&server
->dstaddr
;
1989 if (!ipv6_addr_equal(&addr6
->sin6_addr
,
1990 &srv_addr6
->sin6_addr
))
1992 if (addr6
->sin6_scope_id
!= srv_addr6
->sin6_scope_id
)
1998 return false; /* don't expect to be here */
2001 if (!srcip_matches(srcaddr
, (struct sockaddr
*)&server
->srcaddr
))
2008 match_security(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
2011 * The select_sectype function should either return the vol->sectype
2012 * that was specified, or "Unspecified" if that sectype was not
2013 * compatible with the given NEGOTIATE request.
2015 if (select_sectype(server
, vol
->sectype
) == Unspecified
)
2019 * Now check if signing mode is acceptable. No need to check
2020 * global_secflags at this point since if MUST_SIGN is set then
2021 * the server->sign had better be too.
2023 if (vol
->sign
&& !server
->sign
)
2029 static int match_server(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
2031 struct sockaddr
*addr
= (struct sockaddr
*)&vol
->dstaddr
;
2033 if (vol
->nosharesock
)
2036 if ((server
->vals
!= vol
->vals
) || (server
->ops
!= vol
->ops
))
2039 if (!net_eq(cifs_net_ns(server
), current
->nsproxy
->net_ns
))
2042 if (!match_address(server
, addr
,
2043 (struct sockaddr
*)&vol
->srcaddr
))
2046 if (!match_port(server
, addr
))
2049 if (!match_security(server
, vol
))
2052 if (server
->echo_interval
!= vol
->echo_interval
)
2058 static struct TCP_Server_Info
*
2059 cifs_find_tcp_session(struct smb_vol
*vol
)
2061 struct TCP_Server_Info
*server
;
2063 spin_lock(&cifs_tcp_ses_lock
);
2064 list_for_each_entry(server
, &cifs_tcp_ses_list
, tcp_ses_list
) {
2065 if (!match_server(server
, vol
))
2068 ++server
->srv_count
;
2069 spin_unlock(&cifs_tcp_ses_lock
);
2070 cifs_dbg(FYI
, "Existing tcp session with server found\n");
2073 spin_unlock(&cifs_tcp_ses_lock
);
2078 cifs_put_tcp_session(struct TCP_Server_Info
*server
)
2080 struct task_struct
*task
;
2082 spin_lock(&cifs_tcp_ses_lock
);
2083 if (--server
->srv_count
> 0) {
2084 spin_unlock(&cifs_tcp_ses_lock
);
2088 put_net(cifs_net_ns(server
));
2090 list_del_init(&server
->tcp_ses_list
);
2091 spin_unlock(&cifs_tcp_ses_lock
);
2093 cancel_delayed_work_sync(&server
->echo
);
2095 spin_lock(&GlobalMid_Lock
);
2096 server
->tcpStatus
= CifsExiting
;
2097 spin_unlock(&GlobalMid_Lock
);
2099 cifs_crypto_shash_release(server
);
2100 cifs_fscache_release_client_cookie(server
);
2102 kfree(server
->session_key
.response
);
2103 server
->session_key
.response
= NULL
;
2104 server
->session_key
.len
= 0;
2106 task
= xchg(&server
->tsk
, NULL
);
2108 force_sig(SIGKILL
, task
);
2111 static struct TCP_Server_Info
*
2112 cifs_get_tcp_session(struct smb_vol
*volume_info
)
2114 struct TCP_Server_Info
*tcp_ses
= NULL
;
2117 cifs_dbg(FYI
, "UNC: %s\n", volume_info
->UNC
);
2119 /* see if we already have a matching tcp_ses */
2120 tcp_ses
= cifs_find_tcp_session(volume_info
);
2124 tcp_ses
= kzalloc(sizeof(struct TCP_Server_Info
), GFP_KERNEL
);
2130 tcp_ses
->ops
= volume_info
->ops
;
2131 tcp_ses
->vals
= volume_info
->vals
;
2132 cifs_set_net_ns(tcp_ses
, get_net(current
->nsproxy
->net_ns
));
2133 tcp_ses
->hostname
= extract_hostname(volume_info
->UNC
);
2134 if (IS_ERR(tcp_ses
->hostname
)) {
2135 rc
= PTR_ERR(tcp_ses
->hostname
);
2136 goto out_err_crypto_release
;
2139 tcp_ses
->noblocksnd
= volume_info
->noblocksnd
;
2140 tcp_ses
->noautotune
= volume_info
->noautotune
;
2141 tcp_ses
->tcp_nodelay
= volume_info
->sockopt_tcp_nodelay
;
2142 tcp_ses
->in_flight
= 0;
2143 tcp_ses
->credits
= 1;
2144 init_waitqueue_head(&tcp_ses
->response_q
);
2145 init_waitqueue_head(&tcp_ses
->request_q
);
2146 INIT_LIST_HEAD(&tcp_ses
->pending_mid_q
);
2147 mutex_init(&tcp_ses
->srv_mutex
);
2148 memcpy(tcp_ses
->workstation_RFC1001_name
,
2149 volume_info
->source_rfc1001_name
, RFC1001_NAME_LEN_WITH_NULL
);
2150 memcpy(tcp_ses
->server_RFC1001_name
,
2151 volume_info
->target_rfc1001_name
, RFC1001_NAME_LEN_WITH_NULL
);
2152 tcp_ses
->session_estab
= false;
2153 tcp_ses
->sequence_number
= 0;
2154 tcp_ses
->lstrp
= jiffies
;
2155 spin_lock_init(&tcp_ses
->req_lock
);
2156 INIT_LIST_HEAD(&tcp_ses
->tcp_ses_list
);
2157 INIT_LIST_HEAD(&tcp_ses
->smb_ses_list
);
2158 INIT_DELAYED_WORK(&tcp_ses
->echo
, cifs_echo_request
);
2159 memcpy(&tcp_ses
->srcaddr
, &volume_info
->srcaddr
,
2160 sizeof(tcp_ses
->srcaddr
));
2161 memcpy(&tcp_ses
->dstaddr
, &volume_info
->dstaddr
,
2162 sizeof(tcp_ses
->dstaddr
));
2163 #ifdef CONFIG_CIFS_SMB2
2164 get_random_bytes(tcp_ses
->client_guid
, SMB2_CLIENT_GUID_SIZE
);
2167 * at this point we are the only ones with the pointer
2168 * to the struct since the kernel thread not created yet
2169 * no need to spinlock this init of tcpStatus or srv_count
2171 tcp_ses
->tcpStatus
= CifsNew
;
2172 ++tcp_ses
->srv_count
;
2174 if (volume_info
->echo_interval
>= SMB_ECHO_INTERVAL_MIN
&&
2175 volume_info
->echo_interval
<= SMB_ECHO_INTERVAL_MAX
)
2176 tcp_ses
->echo_interval
= volume_info
->echo_interval
* HZ
;
2178 tcp_ses
->echo_interval
= SMB_ECHO_INTERVAL_DEFAULT
* HZ
;
2180 rc
= ip_connect(tcp_ses
);
2182 cifs_dbg(VFS
, "Error connecting to socket. Aborting operation.\n");
2183 goto out_err_crypto_release
;
2187 * since we're in a cifs function already, we know that
2188 * this will succeed. No need for try_module_get().
2190 __module_get(THIS_MODULE
);
2191 tcp_ses
->tsk
= kthread_run(cifs_demultiplex_thread
,
2193 if (IS_ERR(tcp_ses
->tsk
)) {
2194 rc
= PTR_ERR(tcp_ses
->tsk
);
2195 cifs_dbg(VFS
, "error %d create cifsd thread\n", rc
);
2196 module_put(THIS_MODULE
);
2197 goto out_err_crypto_release
;
2199 tcp_ses
->tcpStatus
= CifsNeedNegotiate
;
2201 /* thread spawned, put it on the list */
2202 spin_lock(&cifs_tcp_ses_lock
);
2203 list_add(&tcp_ses
->tcp_ses_list
, &cifs_tcp_ses_list
);
2204 spin_unlock(&cifs_tcp_ses_lock
);
2206 cifs_fscache_get_client_cookie(tcp_ses
);
2208 /* queue echo request delayed work */
2209 queue_delayed_work(cifsiod_wq
, &tcp_ses
->echo
, tcp_ses
->echo_interval
);
2213 out_err_crypto_release
:
2214 cifs_crypto_shash_release(tcp_ses
);
2216 put_net(cifs_net_ns(tcp_ses
));
2220 if (!IS_ERR(tcp_ses
->hostname
))
2221 kfree(tcp_ses
->hostname
);
2222 if (tcp_ses
->ssocket
)
2223 sock_release(tcp_ses
->ssocket
);
2229 static int match_session(struct cifs_ses
*ses
, struct smb_vol
*vol
)
2231 if (vol
->sectype
!= Unspecified
&&
2232 vol
->sectype
!= ses
->sectype
)
2235 switch (ses
->sectype
) {
2237 if (!uid_eq(vol
->cred_uid
, ses
->cred_uid
))
2241 /* NULL username means anonymous session */
2242 if (ses
->user_name
== NULL
) {
2248 /* anything else takes username/password */
2249 if (strncmp(ses
->user_name
,
2250 vol
->username
? vol
->username
: "",
2251 CIFS_MAX_USERNAME_LEN
))
2253 if ((vol
->username
&& strlen(vol
->username
) != 0) &&
2254 ses
->password
!= NULL
&&
2255 strncmp(ses
->password
,
2256 vol
->password
? vol
->password
: "",
2257 CIFS_MAX_PASSWORD_LEN
))
2263 static struct cifs_ses
*
2264 cifs_find_smb_ses(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
2266 struct cifs_ses
*ses
;
2268 spin_lock(&cifs_tcp_ses_lock
);
2269 list_for_each_entry(ses
, &server
->smb_ses_list
, smb_ses_list
) {
2270 if (ses
->status
== CifsExiting
)
2272 if (!match_session(ses
, vol
))
2275 spin_unlock(&cifs_tcp_ses_lock
);
2278 spin_unlock(&cifs_tcp_ses_lock
);
2283 cifs_put_smb_ses(struct cifs_ses
*ses
)
2285 unsigned int rc
, xid
;
2286 struct TCP_Server_Info
*server
= ses
->server
;
2288 cifs_dbg(FYI
, "%s: ses_count=%d\n", __func__
, ses
->ses_count
);
2290 spin_lock(&cifs_tcp_ses_lock
);
2291 if (ses
->status
== CifsExiting
) {
2292 spin_unlock(&cifs_tcp_ses_lock
);
2295 if (--ses
->ses_count
> 0) {
2296 spin_unlock(&cifs_tcp_ses_lock
);
2299 if (ses
->status
== CifsGood
)
2300 ses
->status
= CifsExiting
;
2301 spin_unlock(&cifs_tcp_ses_lock
);
2303 if (ses
->status
== CifsExiting
&& server
->ops
->logoff
) {
2305 rc
= server
->ops
->logoff(xid
, ses
);
2307 cifs_dbg(VFS
, "%s: Session Logoff failure rc=%d\n",
2312 spin_lock(&cifs_tcp_ses_lock
);
2313 list_del_init(&ses
->smb_ses_list
);
2314 spin_unlock(&cifs_tcp_ses_lock
);
2317 cifs_put_tcp_session(server
);
2322 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2323 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2325 /* Populate username and pw fields from keyring if possible */
2327 cifs_set_cifscreds(struct smb_vol
*vol
, struct cifs_ses
*ses
)
2330 const char *delim
, *payload
;
2334 struct TCP_Server_Info
*server
= ses
->server
;
2335 struct sockaddr_in
*sa
;
2336 struct sockaddr_in6
*sa6
;
2337 const struct user_key_payload
*upayload
;
2339 desc
= kmalloc(CIFSCREDS_DESC_SIZE
, GFP_KERNEL
);
2343 /* try to find an address key first */
2344 switch (server
->dstaddr
.ss_family
) {
2346 sa
= (struct sockaddr_in
*)&server
->dstaddr
;
2347 sprintf(desc
, "cifs:a:%pI4", &sa
->sin_addr
.s_addr
);
2350 sa6
= (struct sockaddr_in6
*)&server
->dstaddr
;
2351 sprintf(desc
, "cifs:a:%pI6c", &sa6
->sin6_addr
.s6_addr
);
2354 cifs_dbg(FYI
, "Bad ss_family (%hu)\n",
2355 server
->dstaddr
.ss_family
);
2360 cifs_dbg(FYI
, "%s: desc=%s\n", __func__
, desc
);
2361 key
= request_key(&key_type_logon
, desc
, "");
2363 if (!ses
->domainName
) {
2364 cifs_dbg(FYI
, "domainName is NULL\n");
2369 /* didn't work, try to find a domain key */
2370 sprintf(desc
, "cifs:d:%s", ses
->domainName
);
2371 cifs_dbg(FYI
, "%s: desc=%s\n", __func__
, desc
);
2372 key
= request_key(&key_type_logon
, desc
, "");
2379 down_read(&key
->sem
);
2380 upayload
= user_key_payload(key
);
2381 if (IS_ERR_OR_NULL(upayload
)) {
2382 rc
= upayload
? PTR_ERR(upayload
) : -EINVAL
;
2386 /* find first : in payload */
2387 payload
= upayload
->data
;
2388 delim
= strnchr(payload
, upayload
->datalen
, ':');
2389 cifs_dbg(FYI
, "payload=%s\n", payload
);
2391 cifs_dbg(FYI
, "Unable to find ':' in payload (datalen=%d)\n",
2397 len
= delim
- payload
;
2398 if (len
> CIFS_MAX_USERNAME_LEN
|| len
<= 0) {
2399 cifs_dbg(FYI
, "Bad value from username search (len=%zd)\n",
2405 vol
->username
= kstrndup(payload
, len
, GFP_KERNEL
);
2406 if (!vol
->username
) {
2407 cifs_dbg(FYI
, "Unable to allocate %zd bytes for username\n",
2412 cifs_dbg(FYI
, "%s: username=%s\n", __func__
, vol
->username
);
2414 len
= key
->datalen
- (len
+ 1);
2415 if (len
> CIFS_MAX_PASSWORD_LEN
|| len
<= 0) {
2416 cifs_dbg(FYI
, "Bad len for password search (len=%zd)\n", len
);
2418 kfree(vol
->username
);
2419 vol
->username
= NULL
;
2424 vol
->password
= kstrndup(delim
, len
, GFP_KERNEL
);
2425 if (!vol
->password
) {
2426 cifs_dbg(FYI
, "Unable to allocate %zd bytes for password\n",
2429 kfree(vol
->username
);
2430 vol
->username
= NULL
;
2439 cifs_dbg(FYI
, "%s: returning %d\n", __func__
, rc
);
2442 #else /* ! CONFIG_KEYS */
2444 cifs_set_cifscreds(struct smb_vol
*vol
__attribute__((unused
)),
2445 struct cifs_ses
*ses
__attribute__((unused
)))
2449 #endif /* CONFIG_KEYS */
2451 static struct cifs_ses
*
2452 cifs_get_smb_ses(struct TCP_Server_Info
*server
, struct smb_vol
*volume_info
)
2456 struct cifs_ses
*ses
;
2457 struct sockaddr_in
*addr
= (struct sockaddr_in
*)&server
->dstaddr
;
2458 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)&server
->dstaddr
;
2462 ses
= cifs_find_smb_ses(server
, volume_info
);
2464 cifs_dbg(FYI
, "Existing smb sess found (status=%d)\n",
2467 mutex_lock(&ses
->session_mutex
);
2468 rc
= cifs_negotiate_protocol(xid
, ses
);
2470 mutex_unlock(&ses
->session_mutex
);
2471 /* problem -- put our ses reference */
2472 cifs_put_smb_ses(ses
);
2476 if (ses
->need_reconnect
) {
2477 cifs_dbg(FYI
, "Session needs reconnect\n");
2478 rc
= cifs_setup_session(xid
, ses
,
2479 volume_info
->local_nls
);
2481 mutex_unlock(&ses
->session_mutex
);
2482 /* problem -- put our reference */
2483 cifs_put_smb_ses(ses
);
2488 mutex_unlock(&ses
->session_mutex
);
2490 /* existing SMB ses has a server reference already */
2491 cifs_put_tcp_session(server
);
2496 cifs_dbg(FYI
, "Existing smb sess not found\n");
2497 ses
= sesInfoAlloc();
2501 /* new SMB session uses our server ref */
2502 ses
->server
= server
;
2503 if (server
->dstaddr
.ss_family
== AF_INET6
)
2504 sprintf(ses
->serverName
, "%pI6", &addr6
->sin6_addr
);
2506 sprintf(ses
->serverName
, "%pI4", &addr
->sin_addr
);
2508 if (volume_info
->username
) {
2509 ses
->user_name
= kstrdup(volume_info
->username
, GFP_KERNEL
);
2510 if (!ses
->user_name
)
2514 /* volume_info->password freed at unmount */
2515 if (volume_info
->password
) {
2516 ses
->password
= kstrdup(volume_info
->password
, GFP_KERNEL
);
2520 if (volume_info
->domainname
) {
2521 ses
->domainName
= kstrdup(volume_info
->domainname
, GFP_KERNEL
);
2522 if (!ses
->domainName
)
2525 ses
->cred_uid
= volume_info
->cred_uid
;
2526 ses
->linux_uid
= volume_info
->linux_uid
;
2528 ses
->sectype
= volume_info
->sectype
;
2529 ses
->sign
= volume_info
->sign
;
2531 mutex_lock(&ses
->session_mutex
);
2532 rc
= cifs_negotiate_protocol(xid
, ses
);
2534 rc
= cifs_setup_session(xid
, ses
, volume_info
->local_nls
);
2535 mutex_unlock(&ses
->session_mutex
);
2539 /* success, put it on the list */
2540 spin_lock(&cifs_tcp_ses_lock
);
2541 list_add(&ses
->smb_ses_list
, &server
->smb_ses_list
);
2542 spin_unlock(&cifs_tcp_ses_lock
);
2553 static int match_tcon(struct cifs_tcon
*tcon
, const char *unc
)
2555 if (tcon
->tidStatus
== CifsExiting
)
2557 if (strncmp(tcon
->treeName
, unc
, MAX_TREE_SIZE
))
2562 static struct cifs_tcon
*
2563 cifs_find_tcon(struct cifs_ses
*ses
, const char *unc
)
2565 struct list_head
*tmp
;
2566 struct cifs_tcon
*tcon
;
2568 spin_lock(&cifs_tcp_ses_lock
);
2569 list_for_each(tmp
, &ses
->tcon_list
) {
2570 tcon
= list_entry(tmp
, struct cifs_tcon
, tcon_list
);
2571 if (!match_tcon(tcon
, unc
))
2574 spin_unlock(&cifs_tcp_ses_lock
);
2577 spin_unlock(&cifs_tcp_ses_lock
);
2582 cifs_put_tcon(struct cifs_tcon
*tcon
)
2585 struct cifs_ses
*ses
= tcon
->ses
;
2587 cifs_dbg(FYI
, "%s: tc_count=%d\n", __func__
, tcon
->tc_count
);
2588 spin_lock(&cifs_tcp_ses_lock
);
2589 if (--tcon
->tc_count
> 0) {
2590 spin_unlock(&cifs_tcp_ses_lock
);
2594 list_del_init(&tcon
->tcon_list
);
2595 spin_unlock(&cifs_tcp_ses_lock
);
2598 if (ses
->server
->ops
->tree_disconnect
)
2599 ses
->server
->ops
->tree_disconnect(xid
, tcon
);
2602 cifs_fscache_release_super_cookie(tcon
);
2604 cifs_put_smb_ses(ses
);
2607 static struct cifs_tcon
*
2608 cifs_get_tcon(struct cifs_ses
*ses
, struct smb_vol
*volume_info
)
2611 struct cifs_tcon
*tcon
;
2613 tcon
= cifs_find_tcon(ses
, volume_info
->UNC
);
2615 cifs_dbg(FYI
, "Found match on UNC path\n");
2616 /* existing tcon already has a reference */
2617 cifs_put_smb_ses(ses
);
2618 if (tcon
->seal
!= volume_info
->seal
)
2619 cifs_dbg(VFS
, "transport encryption setting conflicts with existing tid\n");
2623 if (!ses
->server
->ops
->tree_connect
) {
2628 tcon
= tconInfoAlloc();
2635 if (volume_info
->password
) {
2636 tcon
->password
= kstrdup(volume_info
->password
, GFP_KERNEL
);
2637 if (!tcon
->password
) {
2644 * BB Do we need to wrap session_mutex around this TCon call and Unix
2645 * SetFS as we do on SessSetup and reconnect?
2648 rc
= ses
->server
->ops
->tree_connect(xid
, ses
, volume_info
->UNC
, tcon
,
2649 volume_info
->local_nls
);
2651 cifs_dbg(FYI
, "Tcon rc = %d\n", rc
);
2655 if (volume_info
->nodfs
) {
2656 tcon
->Flags
&= ~SMB_SHARE_IS_IN_DFS
;
2657 cifs_dbg(FYI
, "DFS disabled (%d)\n", tcon
->Flags
);
2659 tcon
->seal
= volume_info
->seal
;
2660 tcon
->use_persistent
= false;
2661 /* check if SMB2 or later, CIFS does not support persistent handles */
2662 if (volume_info
->persistent
) {
2663 if (ses
->server
->vals
->protocol_id
== 0) {
2665 "SMB3 or later required for persistent handles\n");
2668 #ifdef CONFIG_CIFS_SMB2
2669 } else if (ses
->server
->capabilities
&
2670 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES
)
2671 tcon
->use_persistent
= true;
2672 else /* persistent handles requested but not supported */ {
2674 "Persistent handles not supported on share\n");
2677 #endif /* CONFIG_CIFS_SMB2 */
2679 #ifdef CONFIG_CIFS_SMB2
2680 } else if ((tcon
->capabilities
& SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY
)
2681 && (ses
->server
->capabilities
& SMB2_GLOBAL_CAP_PERSISTENT_HANDLES
)
2682 && (volume_info
->nopersistent
== false)) {
2683 cifs_dbg(FYI
, "enabling persistent handles\n");
2684 tcon
->use_persistent
= true;
2685 #endif /* CONFIG_CIFS_SMB2 */
2686 } else if (volume_info
->resilient
) {
2687 if (ses
->server
->vals
->protocol_id
== 0) {
2689 "SMB2.1 or later required for resilient handles\n");
2693 tcon
->use_resilient
= true;
2697 * We can have only one retry value for a connection to a share so for
2698 * resources mounted more than once to the same server share the last
2699 * value passed in for the retry flag is used.
2701 tcon
->retry
= volume_info
->retry
;
2702 tcon
->nocase
= volume_info
->nocase
;
2703 tcon
->local_lease
= volume_info
->local_lease
;
2704 INIT_LIST_HEAD(&tcon
->pending_opens
);
2706 spin_lock(&cifs_tcp_ses_lock
);
2707 list_add(&tcon
->tcon_list
, &ses
->tcon_list
);
2708 spin_unlock(&cifs_tcp_ses_lock
);
2710 cifs_fscache_get_super_cookie(tcon
);
2720 cifs_put_tlink(struct tcon_link
*tlink
)
2722 if (!tlink
|| IS_ERR(tlink
))
2725 if (!atomic_dec_and_test(&tlink
->tl_count
) ||
2726 test_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
)) {
2727 tlink
->tl_time
= jiffies
;
2731 if (!IS_ERR(tlink_tcon(tlink
)))
2732 cifs_put_tcon(tlink_tcon(tlink
));
2737 static inline struct tcon_link
*
2738 cifs_sb_master_tlink(struct cifs_sb_info
*cifs_sb
)
2740 return cifs_sb
->master_tlink
;
2744 compare_mount_options(struct super_block
*sb
, struct cifs_mnt_data
*mnt_data
)
2746 struct cifs_sb_info
*old
= CIFS_SB(sb
);
2747 struct cifs_sb_info
*new = mnt_data
->cifs_sb
;
2749 if ((sb
->s_flags
& CIFS_MS_MASK
) != (mnt_data
->flags
& CIFS_MS_MASK
))
2752 if ((old
->mnt_cifs_flags
& CIFS_MOUNT_MASK
) !=
2753 (new->mnt_cifs_flags
& CIFS_MOUNT_MASK
))
2757 * We want to share sb only if we don't specify an r/wsize or
2758 * specified r/wsize is greater than or equal to existing one.
2760 if (new->wsize
&& new->wsize
< old
->wsize
)
2763 if (new->rsize
&& new->rsize
< old
->rsize
)
2766 if (!uid_eq(old
->mnt_uid
, new->mnt_uid
) || !gid_eq(old
->mnt_gid
, new->mnt_gid
))
2769 if (old
->mnt_file_mode
!= new->mnt_file_mode
||
2770 old
->mnt_dir_mode
!= new->mnt_dir_mode
)
2773 if (strcmp(old
->local_nls
->charset
, new->local_nls
->charset
))
2776 if (old
->actimeo
!= new->actimeo
)
2783 cifs_match_super(struct super_block
*sb
, void *data
)
2785 struct cifs_mnt_data
*mnt_data
= (struct cifs_mnt_data
*)data
;
2786 struct smb_vol
*volume_info
;
2787 struct cifs_sb_info
*cifs_sb
;
2788 struct TCP_Server_Info
*tcp_srv
;
2789 struct cifs_ses
*ses
;
2790 struct cifs_tcon
*tcon
;
2791 struct tcon_link
*tlink
;
2794 spin_lock(&cifs_tcp_ses_lock
);
2795 cifs_sb
= CIFS_SB(sb
);
2796 tlink
= cifs_get_tlink(cifs_sb_master_tlink(cifs_sb
));
2797 if (IS_ERR(tlink
)) {
2798 spin_unlock(&cifs_tcp_ses_lock
);
2801 tcon
= tlink_tcon(tlink
);
2803 tcp_srv
= ses
->server
;
2805 volume_info
= mnt_data
->vol
;
2807 if (!match_server(tcp_srv
, volume_info
) ||
2808 !match_session(ses
, volume_info
) ||
2809 !match_tcon(tcon
, volume_info
->UNC
)) {
2814 rc
= compare_mount_options(sb
, mnt_data
);
2816 spin_unlock(&cifs_tcp_ses_lock
);
2817 cifs_put_tlink(tlink
);
2822 get_dfs_path(const unsigned int xid
, struct cifs_ses
*ses
, const char *old_path
,
2823 const struct nls_table
*nls_codepage
, unsigned int *num_referrals
,
2824 struct dfs_info3_param
**referrals
, int remap
)
2829 if (!ses
->server
->ops
->tree_connect
|| !ses
->server
->ops
->get_dfs_refer
)
2835 if (ses
->ipc_tid
== 0) {
2836 temp_unc
= kmalloc(2 /* for slashes */ +
2837 strnlen(ses
->serverName
, SERVER_NAME_LEN_WITH_NULL
* 2)
2838 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL
);
2839 if (temp_unc
== NULL
)
2843 strcpy(temp_unc
+ 2, ses
->serverName
);
2844 strcpy(temp_unc
+ 2 + strlen(ses
->serverName
), "\\IPC$");
2845 rc
= ses
->server
->ops
->tree_connect(xid
, ses
, temp_unc
, NULL
,
2847 cifs_dbg(FYI
, "Tcon rc = %d ipc_tid = %d\n", rc
, ses
->ipc_tid
);
2851 rc
= ses
->server
->ops
->get_dfs_refer(xid
, ses
, old_path
,
2852 referrals
, num_referrals
,
2853 nls_codepage
, remap
);
2855 * BB - map targetUNCs to dfs_info3 structures, here or in
2856 * ses->server->ops->get_dfs_refer.
2862 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2863 static struct lock_class_key cifs_key
[2];
2864 static struct lock_class_key cifs_slock_key
[2];
2867 cifs_reclassify_socket4(struct socket
*sock
)
2869 struct sock
*sk
= sock
->sk
;
2870 BUG_ON(!sock_allow_reclassification(sk
));
2871 sock_lock_init_class_and_name(sk
, "slock-AF_INET-CIFS",
2872 &cifs_slock_key
[0], "sk_lock-AF_INET-CIFS", &cifs_key
[0]);
2876 cifs_reclassify_socket6(struct socket
*sock
)
2878 struct sock
*sk
= sock
->sk
;
2879 BUG_ON(!sock_allow_reclassification(sk
));
2880 sock_lock_init_class_and_name(sk
, "slock-AF_INET6-CIFS",
2881 &cifs_slock_key
[1], "sk_lock-AF_INET6-CIFS", &cifs_key
[1]);
2885 cifs_reclassify_socket4(struct socket
*sock
)
2890 cifs_reclassify_socket6(struct socket
*sock
)
2895 /* See RFC1001 section 14 on representation of Netbios names */
2896 static void rfc1002mangle(char *target
, char *source
, unsigned int length
)
2900 for (i
= 0, j
= 0; i
< (length
); i
++) {
2901 /* mask a nibble at a time and encode */
2902 target
[j
] = 'A' + (0x0F & (source
[i
] >> 4));
2903 target
[j
+1] = 'A' + (0x0F & source
[i
]);
2910 bind_socket(struct TCP_Server_Info
*server
)
2913 if (server
->srcaddr
.ss_family
!= AF_UNSPEC
) {
2914 /* Bind to the specified local IP address */
2915 struct socket
*socket
= server
->ssocket
;
2916 rc
= socket
->ops
->bind(socket
,
2917 (struct sockaddr
*) &server
->srcaddr
,
2918 sizeof(server
->srcaddr
));
2920 struct sockaddr_in
*saddr4
;
2921 struct sockaddr_in6
*saddr6
;
2922 saddr4
= (struct sockaddr_in
*)&server
->srcaddr
;
2923 saddr6
= (struct sockaddr_in6
*)&server
->srcaddr
;
2924 if (saddr6
->sin6_family
== AF_INET6
)
2925 cifs_dbg(VFS
, "Failed to bind to: %pI6c, error: %d\n",
2926 &saddr6
->sin6_addr
, rc
);
2928 cifs_dbg(VFS
, "Failed to bind to: %pI4, error: %d\n",
2929 &saddr4
->sin_addr
.s_addr
, rc
);
2936 ip_rfc1001_connect(struct TCP_Server_Info
*server
)
2940 * some servers require RFC1001 sessinit before sending
2941 * negprot - BB check reconnection in case where second
2942 * sessinit is sent but no second negprot
2944 struct rfc1002_session_packet
*ses_init_buf
;
2945 struct smb_hdr
*smb_buf
;
2946 ses_init_buf
= kzalloc(sizeof(struct rfc1002_session_packet
),
2949 ses_init_buf
->trailer
.session_req
.called_len
= 32;
2951 if (server
->server_RFC1001_name
[0] != 0)
2952 rfc1002mangle(ses_init_buf
->trailer
.
2953 session_req
.called_name
,
2954 server
->server_RFC1001_name
,
2955 RFC1001_NAME_LEN_WITH_NULL
);
2957 rfc1002mangle(ses_init_buf
->trailer
.
2958 session_req
.called_name
,
2959 DEFAULT_CIFS_CALLED_NAME
,
2960 RFC1001_NAME_LEN_WITH_NULL
);
2962 ses_init_buf
->trailer
.session_req
.calling_len
= 32;
2965 * calling name ends in null (byte 16) from old smb
2968 if (server
->workstation_RFC1001_name
[0] != 0)
2969 rfc1002mangle(ses_init_buf
->trailer
.
2970 session_req
.calling_name
,
2971 server
->workstation_RFC1001_name
,
2972 RFC1001_NAME_LEN_WITH_NULL
);
2974 rfc1002mangle(ses_init_buf
->trailer
.
2975 session_req
.calling_name
,
2977 RFC1001_NAME_LEN_WITH_NULL
);
2979 ses_init_buf
->trailer
.session_req
.scope1
= 0;
2980 ses_init_buf
->trailer
.session_req
.scope2
= 0;
2981 smb_buf
= (struct smb_hdr
*)ses_init_buf
;
2983 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2984 smb_buf
->smb_buf_length
= cpu_to_be32(0x81000044);
2985 rc
= smb_send(server
, smb_buf
, 0x44);
2986 kfree(ses_init_buf
);
2988 * RFC1001 layer in at least one server
2989 * requires very short break before negprot
2990 * presumably because not expecting negprot
2991 * to follow so fast. This is a simple
2992 * solution that works without
2993 * complicating the code and causes no
2994 * significant slowing down on mount
2997 usleep_range(1000, 2000);
3000 * else the negprot may still work without this
3001 * even though malloc failed
3008 generic_ip_connect(struct TCP_Server_Info
*server
)
3013 struct socket
*socket
= server
->ssocket
;
3014 struct sockaddr
*saddr
;
3016 saddr
= (struct sockaddr
*) &server
->dstaddr
;
3018 if (server
->dstaddr
.ss_family
== AF_INET6
) {
3019 sport
= ((struct sockaddr_in6
*) saddr
)->sin6_port
;
3020 slen
= sizeof(struct sockaddr_in6
);
3023 sport
= ((struct sockaddr_in
*) saddr
)->sin_port
;
3024 slen
= sizeof(struct sockaddr_in
);
3028 if (socket
== NULL
) {
3029 rc
= __sock_create(cifs_net_ns(server
), sfamily
, SOCK_STREAM
,
3030 IPPROTO_TCP
, &socket
, 1);
3032 cifs_dbg(VFS
, "Error %d creating socket\n", rc
);
3033 server
->ssocket
= NULL
;
3037 /* BB other socket options to set KEEPALIVE, NODELAY? */
3038 cifs_dbg(FYI
, "Socket created\n");
3039 server
->ssocket
= socket
;
3040 socket
->sk
->sk_allocation
= GFP_NOFS
;
3041 if (sfamily
== AF_INET6
)
3042 cifs_reclassify_socket6(socket
);
3044 cifs_reclassify_socket4(socket
);
3047 rc
= bind_socket(server
);
3052 * Eventually check for other socket options to change from
3053 * the default. sock_setsockopt not used because it expects
3056 socket
->sk
->sk_rcvtimeo
= 7 * HZ
;
3057 socket
->sk
->sk_sndtimeo
= 5 * HZ
;
3059 /* make the bufsizes depend on wsize/rsize and max requests */
3060 if (server
->noautotune
) {
3061 if (socket
->sk
->sk_sndbuf
< (200 * 1024))
3062 socket
->sk
->sk_sndbuf
= 200 * 1024;
3063 if (socket
->sk
->sk_rcvbuf
< (140 * 1024))
3064 socket
->sk
->sk_rcvbuf
= 140 * 1024;
3067 if (server
->tcp_nodelay
) {
3069 rc
= kernel_setsockopt(socket
, SOL_TCP
, TCP_NODELAY
,
3070 (char *)&val
, sizeof(val
));
3072 cifs_dbg(FYI
, "set TCP_NODELAY socket option error %d\n",
3076 cifs_dbg(FYI
, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3077 socket
->sk
->sk_sndbuf
,
3078 socket
->sk
->sk_rcvbuf
, socket
->sk
->sk_rcvtimeo
);
3080 rc
= socket
->ops
->connect(socket
, saddr
, slen
, 0);
3082 cifs_dbg(FYI
, "Error %d connecting to server\n", rc
);
3083 sock_release(socket
);
3084 server
->ssocket
= NULL
;
3088 if (sport
== htons(RFC1001_PORT
))
3089 rc
= ip_rfc1001_connect(server
);
3095 ip_connect(struct TCP_Server_Info
*server
)
3098 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)&server
->dstaddr
;
3099 struct sockaddr_in
*addr
= (struct sockaddr_in
*)&server
->dstaddr
;
3101 if (server
->dstaddr
.ss_family
== AF_INET6
)
3102 sport
= &addr6
->sin6_port
;
3104 sport
= &addr
->sin_port
;
3109 /* try with 445 port at first */
3110 *sport
= htons(CIFS_PORT
);
3112 rc
= generic_ip_connect(server
);
3116 /* if it failed, try with 139 port */
3117 *sport
= htons(RFC1001_PORT
);
3120 return generic_ip_connect(server
);
3123 void reset_cifs_unix_caps(unsigned int xid
, struct cifs_tcon
*tcon
,
3124 struct cifs_sb_info
*cifs_sb
, struct smb_vol
*vol_info
)
3126 /* if we are reconnecting then should we check to see if
3127 * any requested capabilities changed locally e.g. via
3128 * remount but we can not do much about it here
3129 * if they have (even if we could detect it by the following)
3130 * Perhaps we could add a backpointer to array of sb from tcon
3131 * or if we change to make all sb to same share the same
3132 * sb as NFS - then we only have one backpointer to sb.
3133 * What if we wanted to mount the server share twice once with
3134 * and once without posixacls or posix paths? */
3135 __u64 saved_cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
3137 if (vol_info
&& vol_info
->no_linux_ext
) {
3138 tcon
->fsUnixInfo
.Capability
= 0;
3139 tcon
->unix_ext
= 0; /* Unix Extensions disabled */
3140 cifs_dbg(FYI
, "Linux protocol extensions disabled\n");
3142 } else if (vol_info
)
3143 tcon
->unix_ext
= 1; /* Unix Extensions supported */
3145 if (tcon
->unix_ext
== 0) {
3146 cifs_dbg(FYI
, "Unix extensions disabled so not set on reconnect\n");
3150 if (!CIFSSMBQFSUnixInfo(xid
, tcon
)) {
3151 __u64 cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
3152 cifs_dbg(FYI
, "unix caps which server supports %lld\n", cap
);
3153 /* check for reconnect case in which we do not
3154 want to change the mount behavior if we can avoid it */
3155 if (vol_info
== NULL
) {
3156 /* turn off POSIX ACL and PATHNAMES if not set
3157 originally at mount time */
3158 if ((saved_cap
& CIFS_UNIX_POSIX_ACL_CAP
) == 0)
3159 cap
&= ~CIFS_UNIX_POSIX_ACL_CAP
;
3160 if ((saved_cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) == 0) {
3161 if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)
3162 cifs_dbg(VFS
, "POSIXPATH support change\n");
3163 cap
&= ~CIFS_UNIX_POSIX_PATHNAMES_CAP
;
3164 } else if ((cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) == 0) {
3165 cifs_dbg(VFS
, "possible reconnect error\n");
3166 cifs_dbg(VFS
, "server disabled POSIX path support\n");
3170 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)
3171 cifs_dbg(VFS
, "per-share encryption not supported yet\n");
3173 cap
&= CIFS_UNIX_CAP_MASK
;
3174 if (vol_info
&& vol_info
->no_psx_acl
)
3175 cap
&= ~CIFS_UNIX_POSIX_ACL_CAP
;
3176 else if (CIFS_UNIX_POSIX_ACL_CAP
& cap
) {
3177 cifs_dbg(FYI
, "negotiated posix acl support\n");
3179 cifs_sb
->mnt_cifs_flags
|=
3180 CIFS_MOUNT_POSIXACL
;
3183 if (vol_info
&& vol_info
->posix_paths
== 0)
3184 cap
&= ~CIFS_UNIX_POSIX_PATHNAMES_CAP
;
3185 else if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) {
3186 cifs_dbg(FYI
, "negotiate posix pathnames\n");
3188 cifs_sb
->mnt_cifs_flags
|=
3189 CIFS_MOUNT_POSIX_PATHS
;
3192 cifs_dbg(FYI
, "Negotiate caps 0x%x\n", (int)cap
);
3193 #ifdef CONFIG_CIFS_DEBUG2
3194 if (cap
& CIFS_UNIX_FCNTL_CAP
)
3195 cifs_dbg(FYI
, "FCNTL cap\n");
3196 if (cap
& CIFS_UNIX_EXTATTR_CAP
)
3197 cifs_dbg(FYI
, "EXTATTR cap\n");
3198 if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)
3199 cifs_dbg(FYI
, "POSIX path cap\n");
3200 if (cap
& CIFS_UNIX_XATTR_CAP
)
3201 cifs_dbg(FYI
, "XATTR cap\n");
3202 if (cap
& CIFS_UNIX_POSIX_ACL_CAP
)
3203 cifs_dbg(FYI
, "POSIX ACL cap\n");
3204 if (cap
& CIFS_UNIX_LARGE_READ_CAP
)
3205 cifs_dbg(FYI
, "very large read cap\n");
3206 if (cap
& CIFS_UNIX_LARGE_WRITE_CAP
)
3207 cifs_dbg(FYI
, "very large write cap\n");
3208 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP
)
3209 cifs_dbg(FYI
, "transport encryption cap\n");
3210 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)
3211 cifs_dbg(FYI
, "mandatory transport encryption cap\n");
3212 #endif /* CIFS_DEBUG2 */
3213 if (CIFSSMBSetFSUnixInfo(xid
, tcon
, cap
)) {
3214 if (vol_info
== NULL
) {
3215 cifs_dbg(FYI
, "resetting capabilities failed\n");
3217 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");
3223 void cifs_setup_cifs_sb(struct smb_vol
*pvolume_info
,
3224 struct cifs_sb_info
*cifs_sb
)
3226 INIT_DELAYED_WORK(&cifs_sb
->prune_tlinks
, cifs_prune_tlinks
);
3228 spin_lock_init(&cifs_sb
->tlink_tree_lock
);
3229 cifs_sb
->tlink_tree
= RB_ROOT
;
3232 * Temporarily set r/wsize for matching superblock. If we end up using
3233 * new sb then client will later negotiate it downward if needed.
3235 cifs_sb
->rsize
= pvolume_info
->rsize
;
3236 cifs_sb
->wsize
= pvolume_info
->wsize
;
3238 cifs_sb
->mnt_uid
= pvolume_info
->linux_uid
;
3239 cifs_sb
->mnt_gid
= pvolume_info
->linux_gid
;
3240 cifs_sb
->mnt_file_mode
= pvolume_info
->file_mode
;
3241 cifs_sb
->mnt_dir_mode
= pvolume_info
->dir_mode
;
3242 cifs_dbg(FYI
, "file mode: 0x%hx dir mode: 0x%hx\n",
3243 cifs_sb
->mnt_file_mode
, cifs_sb
->mnt_dir_mode
);
3245 cifs_sb
->actimeo
= pvolume_info
->actimeo
;
3246 cifs_sb
->local_nls
= pvolume_info
->local_nls
;
3248 if (pvolume_info
->noperm
)
3249 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_PERM
;
3250 if (pvolume_info
->setuids
)
3251 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_SET_UID
;
3252 if (pvolume_info
->server_ino
)
3253 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_SERVER_INUM
;
3254 if (pvolume_info
->remap
)
3255 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MAP_SFM_CHR
;
3256 if (pvolume_info
->sfu_remap
)
3257 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MAP_SPECIAL_CHR
;
3258 if (pvolume_info
->no_xattr
)
3259 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_XATTR
;
3260 if (pvolume_info
->sfu_emul
)
3261 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_UNX_EMUL
;
3262 if (pvolume_info
->nobrl
)
3263 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_BRL
;
3264 if (pvolume_info
->nostrictsync
)
3265 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NOSSYNC
;
3266 if (pvolume_info
->mand_lock
)
3267 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NOPOSIXBRL
;
3268 if (pvolume_info
->rwpidforward
)
3269 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_RWPIDFORWARD
;
3270 if (pvolume_info
->cifs_acl
)
3271 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_ACL
;
3272 if (pvolume_info
->backupuid_specified
) {
3273 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_BACKUPUID
;
3274 cifs_sb
->mnt_backupuid
= pvolume_info
->backupuid
;
3276 if (pvolume_info
->backupgid_specified
) {
3277 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_BACKUPGID
;
3278 cifs_sb
->mnt_backupgid
= pvolume_info
->backupgid
;
3280 if (pvolume_info
->override_uid
)
3281 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_OVERR_UID
;
3282 if (pvolume_info
->override_gid
)
3283 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_OVERR_GID
;
3284 if (pvolume_info
->dynperm
)
3285 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_DYNPERM
;
3286 if (pvolume_info
->fsc
)
3287 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_FSCACHE
;
3288 if (pvolume_info
->multiuser
)
3289 cifs_sb
->mnt_cifs_flags
|= (CIFS_MOUNT_MULTIUSER
|
3290 CIFS_MOUNT_NO_PERM
);
3291 if (pvolume_info
->strict_io
)
3292 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_STRICT_IO
;
3293 if (pvolume_info
->direct_io
) {
3294 cifs_dbg(FYI
, "mounting share using direct i/o\n");
3295 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_DIRECT_IO
;
3297 if (pvolume_info
->mfsymlinks
) {
3298 if (pvolume_info
->sfu_emul
) {
3300 * Our SFU ("Services for Unix" emulation does not allow
3301 * creating symlinks but does allow reading existing SFU
3302 * symlinks (it does allow both creating and reading SFU
3303 * style mknod and FIFOs though). When "mfsymlinks" and
3304 * "sfu" are both enabled at the same time, it allows
3305 * reading both types of symlinks, but will only create
3306 * them with mfsymlinks format. This allows better
3307 * Apple compatibility (probably better for Samba too)
3308 * while still recognizing old Windows style symlinks.
3310 cifs_dbg(VFS
, "mount options mfsymlinks and sfu both enabled\n");
3312 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MF_SYMLINKS
;
3315 if ((pvolume_info
->cifs_acl
) && (pvolume_info
->dynperm
))
3316 cifs_dbg(VFS
, "mount option dynperm ignored if cifsacl mount option supported\n");
3320 cleanup_volume_info_contents(struct smb_vol
*volume_info
)
3322 kfree(volume_info
->username
);
3323 kzfree(volume_info
->password
);
3324 kfree(volume_info
->UNC
);
3325 kfree(volume_info
->domainname
);
3326 kfree(volume_info
->iocharset
);
3327 kfree(volume_info
->prepath
);
3331 cifs_cleanup_volume_info(struct smb_vol
*volume_info
)
3335 cleanup_volume_info_contents(volume_info
);
3340 #ifdef CONFIG_CIFS_DFS_UPCALL
3342 * cifs_build_path_to_root returns full path to root when we do not have an
3343 * exiting connection (tcon)
3346 build_unc_path_to_root(const struct smb_vol
*vol
,
3347 const struct cifs_sb_info
*cifs_sb
)
3349 char *full_path
, *pos
;
3350 unsigned int pplen
= vol
->prepath
? strlen(vol
->prepath
) + 1 : 0;
3351 unsigned int unc_len
= strnlen(vol
->UNC
, MAX_TREE_SIZE
+ 1);
3353 full_path
= kmalloc(unc_len
+ pplen
+ 1, GFP_KERNEL
);
3354 if (full_path
== NULL
)
3355 return ERR_PTR(-ENOMEM
);
3357 strncpy(full_path
, vol
->UNC
, unc_len
);
3358 pos
= full_path
+ unc_len
;
3361 *pos
= CIFS_DIR_SEP(cifs_sb
);
3362 strncpy(pos
+ 1, vol
->prepath
, pplen
);
3366 *pos
= '\0'; /* add trailing null */
3367 convert_delimiter(full_path
, CIFS_DIR_SEP(cifs_sb
));
3368 cifs_dbg(FYI
, "%s: full_path=%s\n", __func__
, full_path
);
3373 * Perform a dfs referral query for a share and (optionally) prefix
3375 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3376 * to a string containing updated options for the submount. Otherwise it
3377 * will be left untouched.
3379 * Returns the rc from get_dfs_path to the caller, which can be used to
3380 * determine whether there were referrals.
3383 expand_dfs_referral(const unsigned int xid
, struct cifs_ses
*ses
,
3384 struct smb_vol
*volume_info
, struct cifs_sb_info
*cifs_sb
,
3388 unsigned int num_referrals
= 0;
3389 struct dfs_info3_param
*referrals
= NULL
;
3390 char *full_path
= NULL
, *ref_path
= NULL
, *mdata
= NULL
;
3392 full_path
= build_unc_path_to_root(volume_info
, cifs_sb
);
3393 if (IS_ERR(full_path
))
3394 return PTR_ERR(full_path
);
3396 /* For DFS paths, skip the first '\' of the UNC */
3397 ref_path
= check_prefix
? full_path
+ 1 : volume_info
->UNC
+ 1;
3399 rc
= get_dfs_path(xid
, ses
, ref_path
, cifs_sb
->local_nls
,
3400 &num_referrals
, &referrals
, cifs_remap(cifs_sb
));
3402 if (!rc
&& num_referrals
> 0) {
3403 char *fake_devname
= NULL
;
3405 mdata
= cifs_compose_mount_options(cifs_sb
->mountdata
,
3406 full_path
+ 1, referrals
,
3409 free_dfs_info_array(referrals
, num_referrals
);
3411 if (IS_ERR(mdata
)) {
3412 rc
= PTR_ERR(mdata
);
3415 cleanup_volume_info_contents(volume_info
);
3416 rc
= cifs_setup_volume_info(volume_info
, mdata
,
3419 kfree(fake_devname
);
3420 kfree(cifs_sb
->mountdata
);
3421 cifs_sb
->mountdata
= mdata
;
3429 cifs_setup_volume_info(struct smb_vol
*volume_info
, char *mount_data
,
3430 const char *devname
)
3434 if (cifs_parse_mount_options(mount_data
, devname
, volume_info
))
3437 if (volume_info
->nullauth
) {
3438 cifs_dbg(FYI
, "Anonymous login\n");
3439 kfree(volume_info
->username
);
3440 volume_info
->username
= NULL
;
3441 } else if (volume_info
->username
) {
3442 /* BB fixme parse for domain name here */
3443 cifs_dbg(FYI
, "Username: %s\n", volume_info
->username
);
3445 cifs_dbg(VFS
, "No username specified\n");
3446 /* In userspace mount helper we can get user name from alternate
3447 locations such as env variables and files on disk */
3451 /* this is needed for ASCII cp to Unicode converts */
3452 if (volume_info
->iocharset
== NULL
) {
3453 /* load_nls_default cannot return null */
3454 volume_info
->local_nls
= load_nls_default();
3456 volume_info
->local_nls
= load_nls(volume_info
->iocharset
);
3457 if (volume_info
->local_nls
== NULL
) {
3458 cifs_dbg(VFS
, "CIFS mount error: iocharset %s not found\n",
3459 volume_info
->iocharset
);
3468 cifs_get_volume_info(char *mount_data
, const char *devname
)
3471 struct smb_vol
*volume_info
;
3473 volume_info
= kmalloc(sizeof(struct smb_vol
), GFP_KERNEL
);
3475 return ERR_PTR(-ENOMEM
);
3477 rc
= cifs_setup_volume_info(volume_info
, mount_data
, devname
);
3479 cifs_cleanup_volume_info(volume_info
);
3480 volume_info
= ERR_PTR(rc
);
3487 cifs_mount(struct cifs_sb_info
*cifs_sb
, struct smb_vol
*volume_info
)
3491 struct cifs_ses
*ses
;
3492 struct cifs_tcon
*tcon
;
3493 struct TCP_Server_Info
*server
;
3495 struct tcon_link
*tlink
;
3496 #ifdef CONFIG_CIFS_DFS_UPCALL
3497 int referral_walks_count
= 0;
3500 rc
= bdi_setup_and_register(&cifs_sb
->bdi
, "cifs");
3504 #ifdef CONFIG_CIFS_DFS_UPCALL
3506 /* cleanup activities if we're chasing a referral */
3507 if (referral_walks_count
) {
3509 cifs_put_tcon(tcon
);
3511 cifs_put_smb_ses(ses
);
3513 cifs_sb
->mnt_cifs_flags
&= ~CIFS_MOUNT_POSIX_PATHS
;
3527 /* get a reference to a tcp session */
3528 server
= cifs_get_tcp_session(volume_info
);
3529 if (IS_ERR(server
)) {
3530 rc
= PTR_ERR(server
);
3531 bdi_destroy(&cifs_sb
->bdi
);
3535 /* get a reference to a SMB session */
3536 ses
= cifs_get_smb_ses(server
, volume_info
);
3540 goto mount_fail_check
;
3543 #ifdef CONFIG_CIFS_SMB2
3544 if ((volume_info
->persistent
== true) && ((ses
->server
->capabilities
&
3545 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES
) == 0)) {
3546 cifs_dbg(VFS
, "persistent handles not supported by server\n");
3548 goto mount_fail_check
;
3550 #endif /* CONFIG_CIFS_SMB2*/
3552 /* search for existing tcon to this server share */
3553 tcon
= cifs_get_tcon(ses
, volume_info
);
3557 goto remote_path_check
;
3560 /* tell server which Unix caps we support */
3561 if (cap_unix(tcon
->ses
)) {
3562 /* reset of caps checks mount to see if unix extensions
3563 disabled for just this mount */
3564 reset_cifs_unix_caps(xid
, tcon
, cifs_sb
, volume_info
);
3565 if ((tcon
->ses
->server
->tcpStatus
== CifsNeedReconnect
) &&
3566 (le64_to_cpu(tcon
->fsUnixInfo
.Capability
) &
3567 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)) {
3569 goto mount_fail_check
;
3572 tcon
->unix_ext
= 0; /* server does not support them */
3574 /* do not care if a following call succeed - informational */
3575 if (!tcon
->ipc
&& server
->ops
->qfs_tcon
)
3576 server
->ops
->qfs_tcon(xid
, tcon
);
3578 cifs_sb
->wsize
= server
->ops
->negotiate_wsize(tcon
, volume_info
);
3579 cifs_sb
->rsize
= server
->ops
->negotiate_rsize(tcon
, volume_info
);
3581 /* tune readahead according to rsize */
3582 cifs_sb
->bdi
.ra_pages
= cifs_sb
->rsize
/ PAGE_SIZE
;
3585 #ifdef CONFIG_CIFS_DFS_UPCALL
3587 * Perform an unconditional check for whether there are DFS
3588 * referrals for this path without prefix, to provide support
3589 * for DFS referrals from w2k8 servers which don't seem to respond
3590 * with PATH_NOT_COVERED to requests that include the prefix.
3591 * Chase the referral if found, otherwise continue normally.
3593 if (referral_walks_count
== 0) {
3594 int refrc
= expand_dfs_referral(xid
, ses
, volume_info
, cifs_sb
,
3597 referral_walks_count
++;
3598 goto try_mount_again
;
3603 /* check if a whole path is not remote */
3605 if (!server
->ops
->is_path_accessible
) {
3607 goto mount_fail_check
;
3610 * cifs_build_path_to_root works only when we have a valid tcon
3612 full_path
= cifs_build_path_to_root(volume_info
, cifs_sb
, tcon
);
3613 if (full_path
== NULL
) {
3615 goto mount_fail_check
;
3617 rc
= server
->ops
->is_path_accessible(xid
, tcon
, cifs_sb
,
3619 if (rc
!= 0 && rc
!= -EREMOTE
) {
3621 goto mount_fail_check
;
3626 /* get referral if needed */
3627 if (rc
== -EREMOTE
) {
3628 #ifdef CONFIG_CIFS_DFS_UPCALL
3629 if (referral_walks_count
> MAX_NESTED_LINKS
) {
3631 * BB: when we implement proper loop detection,
3632 * we will remove this check. But now we need it
3633 * to prevent an indefinite loop if 'DFS tree' is
3634 * misconfigured (i.e. has loops).
3637 goto mount_fail_check
;
3640 rc
= expand_dfs_referral(xid
, ses
, volume_info
, cifs_sb
, true);
3643 referral_walks_count
++;
3644 goto try_mount_again
;
3646 goto mount_fail_check
;
3647 #else /* No DFS support, return error on mount */
3653 goto mount_fail_check
;
3655 /* now, hang the tcon off of the superblock */
3656 tlink
= kzalloc(sizeof *tlink
, GFP_KERNEL
);
3657 if (tlink
== NULL
) {
3659 goto mount_fail_check
;
3662 tlink
->tl_uid
= ses
->linux_uid
;
3663 tlink
->tl_tcon
= tcon
;
3664 tlink
->tl_time
= jiffies
;
3665 set_bit(TCON_LINK_MASTER
, &tlink
->tl_flags
);
3666 set_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
3668 cifs_sb
->master_tlink
= tlink
;
3669 spin_lock(&cifs_sb
->tlink_tree_lock
);
3670 tlink_rb_insert(&cifs_sb
->tlink_tree
, tlink
);
3671 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3673 queue_delayed_work(cifsiod_wq
, &cifs_sb
->prune_tlinks
,
3677 /* on error free sesinfo and tcon struct if needed */
3679 /* If find_unc succeeded then rc == 0 so we can not end */
3680 /* up accidentally freeing someone elses tcon struct */
3682 cifs_put_tcon(tcon
);
3684 cifs_put_smb_ses(ses
);
3686 cifs_put_tcp_session(server
);
3687 bdi_destroy(&cifs_sb
->bdi
);
3696 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3697 * pointer may be NULL.
3700 CIFSTCon(const unsigned int xid
, struct cifs_ses
*ses
,
3701 const char *tree
, struct cifs_tcon
*tcon
,
3702 const struct nls_table
*nls_codepage
)
3704 struct smb_hdr
*smb_buffer
;
3705 struct smb_hdr
*smb_buffer_response
;
3708 unsigned char *bcc_ptr
;
3711 __u16 bytes_left
, count
;
3716 smb_buffer
= cifs_buf_get();
3717 if (smb_buffer
== NULL
)
3720 smb_buffer_response
= smb_buffer
;
3722 header_assemble(smb_buffer
, SMB_COM_TREE_CONNECT_ANDX
,
3723 NULL
/*no tid */ , 4 /*wct */ );
3725 smb_buffer
->Mid
= get_next_mid(ses
->server
);
3726 smb_buffer
->Uid
= ses
->Suid
;
3727 pSMB
= (TCONX_REQ
*) smb_buffer
;
3728 pSMBr
= (TCONX_RSP
*) smb_buffer_response
;
3730 pSMB
->AndXCommand
= 0xFF;
3731 pSMB
->Flags
= cpu_to_le16(TCON_EXTENDED_SECINFO
);
3732 bcc_ptr
= &pSMB
->Password
[0];
3733 if (!tcon
|| (ses
->server
->sec_mode
& SECMODE_USER
)) {
3734 pSMB
->PasswordLength
= cpu_to_le16(1); /* minimum */
3735 *bcc_ptr
= 0; /* password is null byte */
3736 bcc_ptr
++; /* skip password */
3737 /* already aligned so no need to do it below */
3739 pSMB
->PasswordLength
= cpu_to_le16(CIFS_AUTH_RESP_SIZE
);
3740 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3741 specified as required (when that support is added to
3742 the vfs in the future) as only NTLM or the much
3743 weaker LANMAN (which we do not send by default) is accepted
3744 by Samba (not sure whether other servers allow
3745 NTLMv2 password here) */
3746 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3747 if ((global_secflags
& CIFSSEC_MAY_LANMAN
) &&
3748 (ses
->sectype
== LANMAN
))
3749 calc_lanman_hash(tcon
->password
, ses
->server
->cryptkey
,
3750 ses
->server
->sec_mode
&
3751 SECMODE_PW_ENCRYPT
? true : false,
3754 #endif /* CIFS_WEAK_PW_HASH */
3755 rc
= SMBNTencrypt(tcon
->password
, ses
->server
->cryptkey
,
3756 bcc_ptr
, nls_codepage
);
3758 cifs_dbg(FYI
, "%s Can't generate NTLM rsp. Error: %d\n",
3760 cifs_buf_release(smb_buffer
);
3764 bcc_ptr
+= CIFS_AUTH_RESP_SIZE
;
3765 if (ses
->capabilities
& CAP_UNICODE
) {
3766 /* must align unicode strings */
3767 *bcc_ptr
= 0; /* null byte password */
3772 if (ses
->server
->sign
)
3773 smb_buffer
->Flags2
|= SMBFLG2_SECURITY_SIGNATURE
;
3775 if (ses
->capabilities
& CAP_STATUS32
) {
3776 smb_buffer
->Flags2
|= SMBFLG2_ERR_STATUS
;
3778 if (ses
->capabilities
& CAP_DFS
) {
3779 smb_buffer
->Flags2
|= SMBFLG2_DFS
;
3781 if (ses
->capabilities
& CAP_UNICODE
) {
3782 smb_buffer
->Flags2
|= SMBFLG2_UNICODE
;
3784 cifs_strtoUTF16((__le16
*) bcc_ptr
, tree
,
3785 6 /* max utf8 char length in bytes */ *
3786 (/* server len*/ + 256 /* share len */), nls_codepage
);
3787 bcc_ptr
+= 2 * length
; /* convert num 16 bit words to bytes */
3788 bcc_ptr
+= 2; /* skip trailing null */
3789 } else { /* ASCII */
3790 strcpy(bcc_ptr
, tree
);
3791 bcc_ptr
+= strlen(tree
) + 1;
3793 strcpy(bcc_ptr
, "?????");
3794 bcc_ptr
+= strlen("?????");
3796 count
= bcc_ptr
- &pSMB
->Password
[0];
3797 pSMB
->hdr
.smb_buf_length
= cpu_to_be32(be32_to_cpu(
3798 pSMB
->hdr
.smb_buf_length
) + count
);
3799 pSMB
->ByteCount
= cpu_to_le16(count
);
3801 rc
= SendReceive(xid
, ses
, smb_buffer
, smb_buffer_response
, &length
,
3804 /* above now done in SendReceive */
3805 if ((rc
== 0) && (tcon
!= NULL
)) {
3808 tcon
->tidStatus
= CifsGood
;
3809 tcon
->need_reconnect
= false;
3810 tcon
->tid
= smb_buffer_response
->Tid
;
3811 bcc_ptr
= pByteArea(smb_buffer_response
);
3812 bytes_left
= get_bcc(smb_buffer_response
);
3813 length
= strnlen(bcc_ptr
, bytes_left
- 2);
3814 if (smb_buffer
->Flags2
& SMBFLG2_UNICODE
)
3820 /* skip service field (NB: this field is always ASCII) */
3822 if ((bcc_ptr
[0] == 'I') && (bcc_ptr
[1] == 'P') &&
3823 (bcc_ptr
[2] == 'C')) {
3824 cifs_dbg(FYI
, "IPC connection\n");
3827 } else if (length
== 2) {
3828 if ((bcc_ptr
[0] == 'A') && (bcc_ptr
[1] == ':')) {
3829 /* the most common case */
3830 cifs_dbg(FYI
, "disk share connection\n");
3833 bcc_ptr
+= length
+ 1;
3834 bytes_left
-= (length
+ 1);
3835 strlcpy(tcon
->treeName
, tree
, sizeof(tcon
->treeName
));
3837 /* mostly informational -- no need to fail on error here */
3838 kfree(tcon
->nativeFileSystem
);
3839 tcon
->nativeFileSystem
= cifs_strndup_from_utf16(bcc_ptr
,
3840 bytes_left
, is_unicode
,
3843 cifs_dbg(FYI
, "nativeFileSystem=%s\n", tcon
->nativeFileSystem
);
3845 if ((smb_buffer_response
->WordCount
== 3) ||
3846 (smb_buffer_response
->WordCount
== 7))
3847 /* field is in same location */
3848 tcon
->Flags
= le16_to_cpu(pSMBr
->OptionalSupport
);
3851 cifs_dbg(FYI
, "Tcon flags: 0x%x\n", tcon
->Flags
);
3852 } else if ((rc
== 0) && tcon
== NULL
) {
3853 /* all we need to save for IPC$ connection */
3854 ses
->ipc_tid
= smb_buffer_response
->Tid
;
3857 cifs_buf_release(smb_buffer
);
3861 static void delayed_free(struct rcu_head
*p
)
3863 struct cifs_sb_info
*sbi
= container_of(p
, struct cifs_sb_info
, rcu
);
3864 unload_nls(sbi
->local_nls
);
3869 cifs_umount(struct cifs_sb_info
*cifs_sb
)
3871 struct rb_root
*root
= &cifs_sb
->tlink_tree
;
3872 struct rb_node
*node
;
3873 struct tcon_link
*tlink
;
3875 cancel_delayed_work_sync(&cifs_sb
->prune_tlinks
);
3877 spin_lock(&cifs_sb
->tlink_tree_lock
);
3878 while ((node
= rb_first(root
))) {
3879 tlink
= rb_entry(node
, struct tcon_link
, tl_rbnode
);
3880 cifs_get_tlink(tlink
);
3881 clear_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
3882 rb_erase(node
, root
);
3884 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3885 cifs_put_tlink(tlink
);
3886 spin_lock(&cifs_sb
->tlink_tree_lock
);
3888 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3890 bdi_destroy(&cifs_sb
->bdi
);
3891 kfree(cifs_sb
->mountdata
);
3892 call_rcu(&cifs_sb
->rcu
, delayed_free
);
3896 cifs_negotiate_protocol(const unsigned int xid
, struct cifs_ses
*ses
)
3899 struct TCP_Server_Info
*server
= ses
->server
;
3901 if (!server
->ops
->need_neg
|| !server
->ops
->negotiate
)
3904 /* only send once per connect */
3905 if (!server
->ops
->need_neg(server
))
3908 set_credits(server
, 1);
3910 rc
= server
->ops
->negotiate(xid
, ses
);
3912 spin_lock(&GlobalMid_Lock
);
3913 if (server
->tcpStatus
== CifsNeedNegotiate
)
3914 server
->tcpStatus
= CifsGood
;
3917 spin_unlock(&GlobalMid_Lock
);
3924 cifs_setup_session(const unsigned int xid
, struct cifs_ses
*ses
,
3925 struct nls_table
*nls_info
)
3928 struct TCP_Server_Info
*server
= ses
->server
;
3930 ses
->capabilities
= server
->capabilities
;
3931 if (linuxExtEnabled
== 0)
3932 ses
->capabilities
&= (~server
->vals
->cap_unix
);
3934 cifs_dbg(FYI
, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
3935 server
->sec_mode
, server
->capabilities
, server
->timeAdj
);
3937 if (server
->ops
->sess_setup
)
3938 rc
= server
->ops
->sess_setup(xid
, ses
, nls_info
);
3941 cifs_dbg(VFS
, "Send error in SessSetup = %d\n", rc
);
3947 cifs_set_vol_auth(struct smb_vol
*vol
, struct cifs_ses
*ses
)
3949 vol
->sectype
= ses
->sectype
;
3951 /* krb5 is special, since we don't need username or pw */
3952 if (vol
->sectype
== Kerberos
)
3955 return cifs_set_cifscreds(vol
, ses
);
3958 static struct cifs_tcon
*
3959 cifs_construct_tcon(struct cifs_sb_info
*cifs_sb
, kuid_t fsuid
)
3962 struct cifs_tcon
*master_tcon
= cifs_sb_master_tcon(cifs_sb
);
3963 struct cifs_ses
*ses
;
3964 struct cifs_tcon
*tcon
= NULL
;
3965 struct smb_vol
*vol_info
;
3967 vol_info
= kzalloc(sizeof(*vol_info
), GFP_KERNEL
);
3968 if (vol_info
== NULL
)
3969 return ERR_PTR(-ENOMEM
);
3971 vol_info
->local_nls
= cifs_sb
->local_nls
;
3972 vol_info
->linux_uid
= fsuid
;
3973 vol_info
->cred_uid
= fsuid
;
3974 vol_info
->UNC
= master_tcon
->treeName
;
3975 vol_info
->retry
= master_tcon
->retry
;
3976 vol_info
->nocase
= master_tcon
->nocase
;
3977 vol_info
->local_lease
= master_tcon
->local_lease
;
3978 vol_info
->no_linux_ext
= !master_tcon
->unix_ext
;
3979 vol_info
->sectype
= master_tcon
->ses
->sectype
;
3980 vol_info
->sign
= master_tcon
->ses
->sign
;
3982 rc
= cifs_set_vol_auth(vol_info
, master_tcon
->ses
);
3988 /* get a reference for the same TCP session */
3989 spin_lock(&cifs_tcp_ses_lock
);
3990 ++master_tcon
->ses
->server
->srv_count
;
3991 spin_unlock(&cifs_tcp_ses_lock
);
3993 ses
= cifs_get_smb_ses(master_tcon
->ses
->server
, vol_info
);
3995 tcon
= (struct cifs_tcon
*)ses
;
3996 cifs_put_tcp_session(master_tcon
->ses
->server
);
4000 tcon
= cifs_get_tcon(ses
, vol_info
);
4002 cifs_put_smb_ses(ses
);
4007 reset_cifs_unix_caps(0, tcon
, NULL
, vol_info
);
4009 kfree(vol_info
->username
);
4010 kfree(vol_info
->password
);
4017 cifs_sb_master_tcon(struct cifs_sb_info
*cifs_sb
)
4019 return tlink_tcon(cifs_sb_master_tlink(cifs_sb
));
4022 /* find and return a tlink with given uid */
4023 static struct tcon_link
*
4024 tlink_rb_search(struct rb_root
*root
, kuid_t uid
)
4026 struct rb_node
*node
= root
->rb_node
;
4027 struct tcon_link
*tlink
;
4030 tlink
= rb_entry(node
, struct tcon_link
, tl_rbnode
);
4032 if (uid_gt(tlink
->tl_uid
, uid
))
4033 node
= node
->rb_left
;
4034 else if (uid_lt(tlink
->tl_uid
, uid
))
4035 node
= node
->rb_right
;
4042 /* insert a tcon_link into the tree */
4044 tlink_rb_insert(struct rb_root
*root
, struct tcon_link
*new_tlink
)
4046 struct rb_node
**new = &(root
->rb_node
), *parent
= NULL
;
4047 struct tcon_link
*tlink
;
4050 tlink
= rb_entry(*new, struct tcon_link
, tl_rbnode
);
4053 if (uid_gt(tlink
->tl_uid
, new_tlink
->tl_uid
))
4054 new = &((*new)->rb_left
);
4056 new = &((*new)->rb_right
);
4059 rb_link_node(&new_tlink
->tl_rbnode
, parent
, new);
4060 rb_insert_color(&new_tlink
->tl_rbnode
, root
);
4064 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4067 * If the superblock doesn't refer to a multiuser mount, then just return
4068 * the master tcon for the mount.
4070 * First, search the rbtree for an existing tcon for this fsuid. If one
4071 * exists, then check to see if it's pending construction. If it is then wait
4072 * for construction to complete. Once it's no longer pending, check to see if
4073 * it failed and either return an error or retry construction, depending on
4076 * If one doesn't exist then insert a new tcon_link struct into the tree and
4077 * try to construct a new one.
4080 cifs_sb_tlink(struct cifs_sb_info
*cifs_sb
)
4083 kuid_t fsuid
= current_fsuid();
4084 struct tcon_link
*tlink
, *newtlink
;
4086 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
))
4087 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb
));
4089 spin_lock(&cifs_sb
->tlink_tree_lock
);
4090 tlink
= tlink_rb_search(&cifs_sb
->tlink_tree
, fsuid
);
4092 cifs_get_tlink(tlink
);
4093 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4095 if (tlink
== NULL
) {
4096 newtlink
= kzalloc(sizeof(*tlink
), GFP_KERNEL
);
4097 if (newtlink
== NULL
)
4098 return ERR_PTR(-ENOMEM
);
4099 newtlink
->tl_uid
= fsuid
;
4100 newtlink
->tl_tcon
= ERR_PTR(-EACCES
);
4101 set_bit(TCON_LINK_PENDING
, &newtlink
->tl_flags
);
4102 set_bit(TCON_LINK_IN_TREE
, &newtlink
->tl_flags
);
4103 cifs_get_tlink(newtlink
);
4105 spin_lock(&cifs_sb
->tlink_tree_lock
);
4106 /* was one inserted after previous search? */
4107 tlink
= tlink_rb_search(&cifs_sb
->tlink_tree
, fsuid
);
4109 cifs_get_tlink(tlink
);
4110 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4112 goto wait_for_construction
;
4115 tlink_rb_insert(&cifs_sb
->tlink_tree
, tlink
);
4116 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4118 wait_for_construction
:
4119 ret
= wait_on_bit(&tlink
->tl_flags
, TCON_LINK_PENDING
,
4120 TASK_INTERRUPTIBLE
);
4122 cifs_put_tlink(tlink
);
4123 return ERR_PTR(-ERESTARTSYS
);
4126 /* if it's good, return it */
4127 if (!IS_ERR(tlink
->tl_tcon
))
4130 /* return error if we tried this already recently */
4131 if (time_before(jiffies
, tlink
->tl_time
+ TLINK_ERROR_EXPIRE
)) {
4132 cifs_put_tlink(tlink
);
4133 return ERR_PTR(-EACCES
);
4136 if (test_and_set_bit(TCON_LINK_PENDING
, &tlink
->tl_flags
))
4137 goto wait_for_construction
;
4140 tlink
->tl_tcon
= cifs_construct_tcon(cifs_sb
, fsuid
);
4141 clear_bit(TCON_LINK_PENDING
, &tlink
->tl_flags
);
4142 wake_up_bit(&tlink
->tl_flags
, TCON_LINK_PENDING
);
4144 if (IS_ERR(tlink
->tl_tcon
)) {
4145 cifs_put_tlink(tlink
);
4146 return ERR_PTR(-EACCES
);
4153 * periodic workqueue job that scans tcon_tree for a superblock and closes
4157 cifs_prune_tlinks(struct work_struct
*work
)
4159 struct cifs_sb_info
*cifs_sb
= container_of(work
, struct cifs_sb_info
,
4161 struct rb_root
*root
= &cifs_sb
->tlink_tree
;
4162 struct rb_node
*node
= rb_first(root
);
4163 struct rb_node
*tmp
;
4164 struct tcon_link
*tlink
;
4167 * Because we drop the spinlock in the loop in order to put the tlink
4168 * it's not guarded against removal of links from the tree. The only
4169 * places that remove entries from the tree are this function and
4170 * umounts. Because this function is non-reentrant and is canceled
4171 * before umount can proceed, this is safe.
4173 spin_lock(&cifs_sb
->tlink_tree_lock
);
4174 node
= rb_first(root
);
4175 while (node
!= NULL
) {
4177 node
= rb_next(tmp
);
4178 tlink
= rb_entry(tmp
, struct tcon_link
, tl_rbnode
);
4180 if (test_bit(TCON_LINK_MASTER
, &tlink
->tl_flags
) ||
4181 atomic_read(&tlink
->tl_count
) != 0 ||
4182 time_after(tlink
->tl_time
+ TLINK_IDLE_EXPIRE
, jiffies
))
4185 cifs_get_tlink(tlink
);
4186 clear_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
4187 rb_erase(tmp
, root
);
4189 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4190 cifs_put_tlink(tlink
);
4191 spin_lock(&cifs_sb
->tlink_tree_lock
);
4193 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4195 queue_delayed_work(cifsiod_wq
, &cifs_sb
->prune_tlinks
,