1 /*
2 * fs/cifs/connect.c
3 *
4 * Copyright (C) International Business Machines Corp., 2002,2011
5 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
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.
11 *
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.
16 *
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
20 */
21 #include <linux/fs.h>
22 #include <linux/net.h>
23 #include <linux/string.h>
24 #include <linux/sched/signal.h>
25 #include <linux/list.h>
26 #include <linux/wait.h>
27 #include <linux/slab.h>
28 #include <linux/pagemap.h>
29 #include <linux/ctype.h>
30 #include <linux/utsname.h>
31 #include <linux/mempool.h>
32 #include <linux/delay.h>
33 #include <linux/completion.h>
34 #include <linux/kthread.h>
35 #include <linux/pagevec.h>
36 #include <linux/freezer.h>
37 #include <linux/namei.h>
38 #include <linux/uuid.h>
39 #include <linux/uaccess.h>
40 #include <asm/processor.h>
41 #include <linux/inet.h>
42 #include <linux/module.h>
43 #include <keys/user-type.h>
44 #include <net/ipv6.h>
45 #include <linux/parser.h>
46 #include <linux/bvec.h>
47 #include "cifspdu.h"
48 #include "cifsglob.h"
49 #include "cifsproto.h"
50 #include "cifs_unicode.h"
51 #include "cifs_debug.h"
52 #include "cifs_fs_sb.h"
53 #include "ntlmssp.h"
54 #include "nterr.h"
55 #include "rfc1002pdu.h"
56 #include "fscache.h"
57 #include "smb2proto.h"
58 #include "smbdirect.h"
60 extern mempool_t *cifs_req_poolp;
61 extern bool disable_legacy_dialects;
63 /* FIXME: should these be tunable? */
64 #define TLINK_ERROR_EXPIRE (1 * HZ)
65 #define TLINK_IDLE_EXPIRE (600 * HZ)
67 enum {
68 /* Mount options that take no arguments */
69 Opt_user_xattr, Opt_nouser_xattr,
70 Opt_forceuid, Opt_noforceuid,
71 Opt_forcegid, Opt_noforcegid,
72 Opt_noblocksend, Opt_noautotune,
73 Opt_hard, Opt_soft, Opt_perm, Opt_noperm,
74 Opt_mapposix, Opt_nomapposix,
75 Opt_mapchars, Opt_nomapchars, Opt_sfu,
76 Opt_nosfu, Opt_nodfs, Opt_posixpaths,
77 Opt_noposixpaths, Opt_nounix, Opt_unix,
78 Opt_nocase,
79 Opt_brl, Opt_nobrl,
80 Opt_handlecache, Opt_nohandlecache,
81 Opt_forcemandatorylock, Opt_setuidfromacl, Opt_setuids,
82 Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
83 Opt_nohard, Opt_nosoft,
84 Opt_nointr, Opt_intr,
85 Opt_nostrictsync, Opt_strictsync,
86 Opt_serverino, Opt_noserverino,
87 Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
88 Opt_acl, Opt_noacl, Opt_locallease,
89 Opt_sign, Opt_seal, Opt_noac,
90 Opt_fsc, Opt_mfsymlinks,
91 Opt_multiuser, Opt_sloppy, Opt_nosharesock,
92 Opt_persistent, Opt_nopersistent,
93 Opt_resilient, Opt_noresilient,
94 Opt_domainauto, Opt_rdma,
96 /* Mount options which take numeric value */
97 Opt_backupuid, Opt_backupgid, Opt_uid,
98 Opt_cruid, Opt_gid, Opt_file_mode,
99 Opt_dirmode, Opt_port,
100 Opt_rsize, Opt_wsize, Opt_actimeo,
101 Opt_echo_interval, Opt_max_credits,
102 Opt_snapshot,
104 /* Mount options which take string value */
105 Opt_user, Opt_pass, Opt_ip,
106 Opt_domain, Opt_srcaddr, Opt_iocharset,
107 Opt_netbiosname, Opt_servern,
108 Opt_ver, Opt_vers, Opt_sec, Opt_cache,
110 /* Mount options to be ignored */
111 Opt_ignore,
113 /* Options which could be blank */
114 Opt_blank_pass,
115 Opt_blank_user,
116 Opt_blank_ip,
118 Opt_err
119 };
121 static const match_table_t cifs_mount_option_tokens = {
123 { Opt_user_xattr, "user_xattr" },
124 { Opt_nouser_xattr, "nouser_xattr" },
125 { Opt_forceuid, "forceuid" },
126 { Opt_noforceuid, "noforceuid" },
127 { Opt_forcegid, "forcegid" },
128 { Opt_noforcegid, "noforcegid" },
129 { Opt_noblocksend, "noblocksend" },
130 { Opt_noautotune, "noautotune" },
131 { Opt_hard, "hard" },
132 { Opt_soft, "soft" },
133 { Opt_perm, "perm" },
134 { Opt_noperm, "noperm" },
135 { Opt_mapchars, "mapchars" }, /* SFU style */
136 { Opt_nomapchars, "nomapchars" },
137 { Opt_mapposix, "mapposix" }, /* SFM style */
138 { Opt_nomapposix, "nomapposix" },
139 { Opt_sfu, "sfu" },
140 { Opt_nosfu, "nosfu" },
141 { Opt_nodfs, "nodfs" },
142 { Opt_posixpaths, "posixpaths" },
143 { Opt_noposixpaths, "noposixpaths" },
144 { Opt_nounix, "nounix" },
145 { Opt_nounix, "nolinux" },
146 { Opt_nounix, "noposix" },
147 { Opt_unix, "unix" },
148 { Opt_unix, "linux" },
149 { Opt_unix, "posix" },
150 { Opt_nocase, "nocase" },
151 { Opt_nocase, "ignorecase" },
152 { Opt_brl, "brl" },
153 { Opt_nobrl, "nobrl" },
154 { Opt_handlecache, "handlecache" },
155 { Opt_nohandlecache, "nohandlecache" },
156 { Opt_nobrl, "nolock" },
157 { Opt_forcemandatorylock, "forcemandatorylock" },
158 { Opt_forcemandatorylock, "forcemand" },
159 { Opt_setuids, "setuids" },
160 { Opt_nosetuids, "nosetuids" },
161 { Opt_setuidfromacl, "idsfromsid" },
162 { Opt_dynperm, "dynperm" },
163 { Opt_nodynperm, "nodynperm" },
164 { Opt_nohard, "nohard" },
165 { Opt_nosoft, "nosoft" },
166 { Opt_nointr, "nointr" },
167 { Opt_intr, "intr" },
168 { Opt_nostrictsync, "nostrictsync" },
169 { Opt_strictsync, "strictsync" },
170 { Opt_serverino, "serverino" },
171 { Opt_noserverino, "noserverino" },
172 { Opt_rwpidforward, "rwpidforward" },
173 { Opt_cifsacl, "cifsacl" },
174 { Opt_nocifsacl, "nocifsacl" },
175 { Opt_acl, "acl" },
176 { Opt_noacl, "noacl" },
177 { Opt_locallease, "locallease" },
178 { Opt_sign, "sign" },
179 { Opt_seal, "seal" },
180 { Opt_noac, "noac" },
181 { Opt_fsc, "fsc" },
182 { Opt_mfsymlinks, "mfsymlinks" },
183 { Opt_multiuser, "multiuser" },
184 { Opt_sloppy, "sloppy" },
185 { Opt_nosharesock, "nosharesock" },
186 { Opt_persistent, "persistenthandles"},
187 { Opt_nopersistent, "nopersistenthandles"},
188 { Opt_resilient, "resilienthandles"},
189 { Opt_noresilient, "noresilienthandles"},
190 { Opt_domainauto, "domainauto"},
191 { Opt_rdma, "rdma"},
193 { Opt_backupuid, "backupuid=%s" },
194 { Opt_backupgid, "backupgid=%s" },
195 { Opt_uid, "uid=%s" },
196 { Opt_cruid, "cruid=%s" },
197 { Opt_gid, "gid=%s" },
198 { Opt_file_mode, "file_mode=%s" },
199 { Opt_dirmode, "dirmode=%s" },
200 { Opt_dirmode, "dir_mode=%s" },
201 { Opt_port, "port=%s" },
202 { Opt_rsize, "rsize=%s" },
203 { Opt_wsize, "wsize=%s" },
204 { Opt_actimeo, "actimeo=%s" },
205 { Opt_echo_interval, "echo_interval=%s" },
206 { Opt_max_credits, "max_credits=%s" },
207 { Opt_snapshot, "snapshot=%s" },
209 { Opt_blank_user, "user=" },
210 { Opt_blank_user, "username=" },
211 { Opt_user, "user=%s" },
212 { Opt_user, "username=%s" },
213 { Opt_blank_pass, "pass=" },
214 { Opt_blank_pass, "password=" },
215 { Opt_pass, "pass=%s" },
216 { Opt_pass, "password=%s" },
217 { Opt_blank_ip, "ip=" },
218 { Opt_blank_ip, "addr=" },
219 { Opt_ip, "ip=%s" },
220 { Opt_ip, "addr=%s" },
221 { Opt_ignore, "unc=%s" },
222 { Opt_ignore, "target=%s" },
223 { Opt_ignore, "path=%s" },
224 { Opt_domain, "dom=%s" },
225 { Opt_domain, "domain=%s" },
226 { Opt_domain, "workgroup=%s" },
227 { Opt_srcaddr, "srcaddr=%s" },
228 { Opt_ignore, "prefixpath=%s" },
229 { Opt_iocharset, "iocharset=%s" },
230 { Opt_netbiosname, "netbiosname=%s" },
231 { Opt_servern, "servern=%s" },
232 { Opt_ver, "ver=%s" },
233 { Opt_vers, "vers=%s" },
234 { Opt_sec, "sec=%s" },
235 { Opt_cache, "cache=%s" },
237 { Opt_ignore, "cred" },
238 { Opt_ignore, "credentials" },
239 { Opt_ignore, "cred=%s" },
240 { Opt_ignore, "credentials=%s" },
241 { Opt_ignore, "guest" },
242 { Opt_ignore, "rw" },
243 { Opt_ignore, "ro" },
244 { Opt_ignore, "suid" },
245 { Opt_ignore, "nosuid" },
246 { Opt_ignore, "exec" },
247 { Opt_ignore, "noexec" },
248 { Opt_ignore, "nodev" },
249 { Opt_ignore, "noauto" },
250 { Opt_ignore, "dev" },
251 { Opt_ignore, "mand" },
252 { Opt_ignore, "nomand" },
253 { Opt_ignore, "_netdev" },
255 { Opt_err, NULL }
256 };
258 enum {
259 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
260 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
261 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
262 Opt_sec_ntlmv2i, Opt_sec_lanman,
263 Opt_sec_none,
265 Opt_sec_err
266 };
268 static const match_table_t cifs_secflavor_tokens = {
269 { Opt_sec_krb5, "krb5" },
270 { Opt_sec_krb5i, "krb5i" },
271 { Opt_sec_krb5p, "krb5p" },
272 { Opt_sec_ntlmsspi, "ntlmsspi" },
273 { Opt_sec_ntlmssp, "ntlmssp" },
274 { Opt_ntlm, "ntlm" },
275 { Opt_sec_ntlmi, "ntlmi" },
276 { Opt_sec_ntlmv2, "nontlm" },
277 { Opt_sec_ntlmv2, "ntlmv2" },
278 { Opt_sec_ntlmv2i, "ntlmv2i" },
279 { Opt_sec_lanman, "lanman" },
280 { Opt_sec_none, "none" },
282 { Opt_sec_err, NULL }
283 };
285 /* cache flavors */
286 enum {
287 Opt_cache_loose,
288 Opt_cache_strict,
289 Opt_cache_none,
290 Opt_cache_err
291 };
293 static const match_table_t cifs_cacheflavor_tokens = {
294 { Opt_cache_loose, "loose" },
295 { Opt_cache_strict, "strict" },
296 { Opt_cache_none, "none" },
297 { Opt_cache_err, NULL }
298 };
300 static const match_table_t cifs_smb_version_tokens = {
301 { Smb_1, SMB1_VERSION_STRING },
302 { Smb_20, SMB20_VERSION_STRING},
303 { Smb_21, SMB21_VERSION_STRING },
304 { Smb_30, SMB30_VERSION_STRING },
305 { Smb_302, SMB302_VERSION_STRING },
306 { Smb_311, SMB311_VERSION_STRING },
307 { Smb_311, ALT_SMB311_VERSION_STRING },
308 { Smb_3any, SMB3ANY_VERSION_STRING },
309 { Smb_default, SMBDEFAULT_VERSION_STRING },
310 { Smb_version_err, NULL }
311 };
313 static int ip_connect(struct TCP_Server_Info *server);
314 static int generic_ip_connect(struct TCP_Server_Info *server);
315 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
316 static void cifs_prune_tlinks(struct work_struct *work);
317 static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
318 const char *devname, bool is_smb3);
320 /*
321 * cifs tcp session reconnection
322 *
323 * mark tcp session as reconnecting so temporarily locked
324 * mark all smb sessions as reconnecting for tcp session
325 * reconnect tcp session
326 * wake up waiters on reconnection? - (not needed currently)
327 */
328 int
329 cifs_reconnect(struct TCP_Server_Info *server)
330 {
331 int rc = 0;
332 struct list_head *tmp, *tmp2;
333 struct cifs_ses *ses;
334 struct cifs_tcon *tcon;
335 struct mid_q_entry *mid_entry;
336 struct list_head retry_list;
338 spin_lock(&GlobalMid_Lock);
339 if (server->tcpStatus == CifsExiting) {
340 /* the demux thread will exit normally
341 next time through the loop */
342 spin_unlock(&GlobalMid_Lock);
343 return rc;
344 } else
345 server->tcpStatus = CifsNeedReconnect;
346 spin_unlock(&GlobalMid_Lock);
347 server->maxBuf = 0;
348 server->max_read = 0;
350 cifs_dbg(FYI, "Reconnecting tcp session\n");
351 trace_smb3_reconnect(server->CurrentMid, server->hostname);
353 /* before reconnecting the tcp session, mark the smb session (uid)
354 and the tid bad so they are not used until reconnected */
355 cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
356 __func__);
357 spin_lock(&cifs_tcp_ses_lock);
358 list_for_each(tmp, &server->smb_ses_list) {
359 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
360 ses->need_reconnect = true;
361 list_for_each(tmp2, &ses->tcon_list) {
362 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
363 tcon->need_reconnect = true;
364 }
365 if (ses->tcon_ipc)
366 ses->tcon_ipc->need_reconnect = true;
367 }
368 spin_unlock(&cifs_tcp_ses_lock);
370 /* do not want to be sending data on a socket we are freeing */
371 cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
372 mutex_lock(&server->srv_mutex);
373 if (server->ssocket) {
374 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
375 server->ssocket->state, server->ssocket->flags);
376 kernel_sock_shutdown(server->ssocket, SHUT_WR);
377 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
378 server->ssocket->state, server->ssocket->flags);
379 sock_release(server->ssocket);
380 server->ssocket = NULL;
381 }
382 server->sequence_number = 0;
383 server->session_estab = false;
384 kfree(server->session_key.response);
385 server->session_key.response = NULL;
386 server->session_key.len = 0;
387 server->lstrp = jiffies;
389 /* mark submitted MIDs for retry and issue callback */
390 INIT_LIST_HEAD(&retry_list);
391 cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
392 spin_lock(&GlobalMid_Lock);
393 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
394 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
395 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
396 mid_entry->mid_state = MID_RETRY_NEEDED;
397 list_move(&mid_entry->qhead, &retry_list);
398 }
399 spin_unlock(&GlobalMid_Lock);
400 mutex_unlock(&server->srv_mutex);
402 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
403 list_for_each_safe(tmp, tmp2, &retry_list) {
404 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
405 list_del_init(&mid_entry->qhead);
406 mid_entry->callback(mid_entry);
407 }
409 do {
410 try_to_freeze();
412 /* we should try only the port we connected to before */
413 mutex_lock(&server->srv_mutex);
414 if (cifs_rdma_enabled(server))
415 rc = smbd_reconnect(server);
416 else
417 rc = generic_ip_connect(server);
418 if (rc) {
419 cifs_dbg(FYI, "reconnect error %d\n", rc);
420 mutex_unlock(&server->srv_mutex);
421 msleep(3000);
422 } else {
423 atomic_inc(&tcpSesReconnectCount);
424 spin_lock(&GlobalMid_Lock);
425 if (server->tcpStatus != CifsExiting)
426 server->tcpStatus = CifsNeedNegotiate;
427 spin_unlock(&GlobalMid_Lock);
428 mutex_unlock(&server->srv_mutex);
429 }
430 } while (server->tcpStatus == CifsNeedReconnect);
432 if (server->tcpStatus == CifsNeedNegotiate)
433 mod_delayed_work(cifsiod_wq, &server->echo, 0);
435 return rc;
436 }
438 static void
439 cifs_echo_request(struct work_struct *work)
440 {
441 int rc;
442 struct TCP_Server_Info *server = container_of(work,
443 struct TCP_Server_Info, echo.work);
444 unsigned long echo_interval;
446 /*
447 * If we need to renegotiate, set echo interval to zero to
448 * immediately call echo service where we can renegotiate.
449 */
450 if (server->tcpStatus == CifsNeedNegotiate)
451 echo_interval = 0;
452 else
453 echo_interval = server->echo_interval;
455 /*
456 * We cannot send an echo if it is disabled.
457 * Also, no need to ping if we got a response recently.
458 */
460 if (server->tcpStatus == CifsNeedReconnect ||
461 server->tcpStatus == CifsExiting ||
462 server->tcpStatus == CifsNew ||
463 (server->ops->can_echo && !server->ops->can_echo(server)) ||
464 time_before(jiffies, server->lstrp + echo_interval - HZ))
465 goto requeue_echo;
467 rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
468 if (rc)
469 cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
470 server->hostname);
472 requeue_echo:
473 queue_delayed_work(cifsiod_wq, &server->echo, server->echo_interval);
474 }
476 static bool
477 allocate_buffers(struct TCP_Server_Info *server)
478 {
479 if (!server->bigbuf) {
480 server->bigbuf = (char *)cifs_buf_get();
481 if (!server->bigbuf) {
482 cifs_dbg(VFS, "No memory for large SMB response\n");
483 msleep(3000);
484 /* retry will check if exiting */
485 return false;
486 }
487 } else if (server->large_buf) {
488 /* we are reusing a dirty large buf, clear its start */
489 memset(server->bigbuf, 0, HEADER_SIZE(server));
490 }
492 if (!server->smallbuf) {
493 server->smallbuf = (char *)cifs_small_buf_get();
494 if (!server->smallbuf) {
495 cifs_dbg(VFS, "No memory for SMB response\n");
496 msleep(1000);
497 /* retry will check if exiting */
498 return false;
499 }
500 /* beginning of smb buffer is cleared in our buf_get */
501 } else {
502 /* if existing small buf clear beginning */
503 memset(server->smallbuf, 0, HEADER_SIZE(server));
504 }
506 return true;
507 }
509 static bool
510 server_unresponsive(struct TCP_Server_Info *server)
511 {
512 /*
513 * We need to wait 2 echo intervals to make sure we handle such
514 * situations right:
515 * 1s client sends a normal SMB request
516 * 2s client gets a response
517 * 30s echo workqueue job pops, and decides we got a response recently
518 * and don't need to send another
519 * ...
520 * 65s kernel_recvmsg times out, and we see that we haven't gotten
521 * a response in >60s.
522 */
523 if ((server->tcpStatus == CifsGood ||
524 server->tcpStatus == CifsNeedNegotiate) &&
525 time_after(jiffies, server->lstrp + 2 * server->echo_interval)) {
526 cifs_dbg(VFS, "Server %s has not responded in %lu seconds. Reconnecting...\n",
527 server->hostname, (2 * server->echo_interval) / HZ);
528 cifs_reconnect(server);
529 wake_up(&server->response_q);
530 return true;
531 }
533 return false;
534 }
536 static int
537 cifs_readv_from_socket(struct TCP_Server_Info *server, struct msghdr *smb_msg)
538 {
539 int length = 0;
540 int total_read;
542 smb_msg->msg_control = NULL;
543 smb_msg->msg_controllen = 0;
545 for (total_read = 0; msg_data_left(smb_msg); total_read += length) {
546 try_to_freeze();
548 if (server_unresponsive(server))
549 return -ECONNABORTED;
550 if (cifs_rdma_enabled(server) && server->smbd_conn)
551 length = smbd_recv(server->smbd_conn, smb_msg);
552 else
553 length = sock_recvmsg(server->ssocket, smb_msg, 0);
555 if (server->tcpStatus == CifsExiting)
556 return -ESHUTDOWN;
558 if (server->tcpStatus == CifsNeedReconnect) {
559 cifs_reconnect(server);
560 return -ECONNABORTED;
561 }
563 if (length == -ERESTARTSYS ||
564 length == -EAGAIN ||
565 length == -EINTR) {
566 /*
567 * Minimum sleep to prevent looping, allowing socket
568 * to clear and app threads to set tcpStatus
569 * CifsNeedReconnect if server hung.
570 */
571 usleep_range(1000, 2000);
572 length = 0;
573 continue;
574 }
576 if (length <= 0) {
577 cifs_dbg(FYI, "Received no data or error: %d\n", length);
578 cifs_reconnect(server);
579 return -ECONNABORTED;
580 }
581 }
582 return total_read;
583 }
585 int
586 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
587 unsigned int to_read)
588 {
589 struct msghdr smb_msg;
590 struct kvec iov = {.iov_base = buf, .iov_len = to_read};
591 iov_iter_kvec(&smb_msg.msg_iter, READ | ITER_KVEC, &iov, 1, to_read);
593 return cifs_readv_from_socket(server, &smb_msg);
594 }
596 int
597 cifs_read_page_from_socket(struct TCP_Server_Info *server, struct page *page,
598 unsigned int page_offset, unsigned int to_read)
599 {
600 struct msghdr smb_msg;
601 struct bio_vec bv = {
602 .bv_page = page, .bv_len = to_read, .bv_offset = page_offset};
603 iov_iter_bvec(&smb_msg.msg_iter, READ | ITER_BVEC, &bv, 1, to_read);
604 return cifs_readv_from_socket(server, &smb_msg);
605 }
607 static bool
608 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
609 {
610 /*
611 * The first byte big endian of the length field,
612 * is actually not part of the length but the type
613 * with the most common, zero, as regular data.
614 */
615 switch (type) {
616 case RFC1002_SESSION_MESSAGE:
617 /* Regular SMB response */
618 return true;
619 case RFC1002_SESSION_KEEP_ALIVE:
620 cifs_dbg(FYI, "RFC 1002 session keep alive\n");
621 break;
622 case RFC1002_POSITIVE_SESSION_RESPONSE:
623 cifs_dbg(FYI, "RFC 1002 positive session response\n");
624 break;
625 case RFC1002_NEGATIVE_SESSION_RESPONSE:
626 /*
627 * We get this from Windows 98 instead of an error on
628 * SMB negprot response.
629 */
630 cifs_dbg(FYI, "RFC 1002 negative session response\n");
631 /* give server a second to clean up */
632 msleep(1000);
633 /*
634 * Always try 445 first on reconnect since we get NACK
635 * on some if we ever connected to port 139 (the NACK
636 * is since we do not begin with RFC1001 session
637 * initialize frame).
638 */
639 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
640 cifs_reconnect(server);
641 wake_up(&server->response_q);
642 break;
643 default:
644 cifs_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
645 cifs_reconnect(server);
646 }
648 return false;
649 }
651 void
652 dequeue_mid(struct mid_q_entry *mid, bool malformed)
653 {
654 #ifdef CONFIG_CIFS_STATS2
655 mid->when_received = jiffies;
656 #endif
657 spin_lock(&GlobalMid_Lock);
658 if (!malformed)
659 mid->mid_state = MID_RESPONSE_RECEIVED;
660 else
661 mid->mid_state = MID_RESPONSE_MALFORMED;
662 /*
663 * Trying to handle/dequeue a mid after the send_recv()
664 * function has finished processing it is a bug.
665 */
666 if (mid->mid_flags & MID_DELETED)
667 printk_once(KERN_WARNING
668 "trying to dequeue a deleted mid\n");
669 else
670 list_del_init(&mid->qhead);
671 spin_unlock(&GlobalMid_Lock);
672 }
674 static void
675 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
676 char *buf, int malformed)
677 {
678 if (server->ops->check_trans2 &&
679 server->ops->check_trans2(mid, server, buf, malformed))
680 return;
681 mid->resp_buf = buf;
682 mid->large_buf = server->large_buf;
683 /* Was previous buf put in mpx struct for multi-rsp? */
684 if (!mid->multiRsp) {
685 /* smb buffer will be freed by user thread */
686 if (server->large_buf)
687 server->bigbuf = NULL;
688 else
689 server->smallbuf = NULL;
690 }
691 dequeue_mid(mid, malformed);
692 }
694 static void clean_demultiplex_info(struct TCP_Server_Info *server)
695 {
696 int length;
698 /* take it off the list, if it's not already */
699 spin_lock(&cifs_tcp_ses_lock);
700 list_del_init(&server->tcp_ses_list);
701 spin_unlock(&cifs_tcp_ses_lock);
703 spin_lock(&GlobalMid_Lock);
704 server->tcpStatus = CifsExiting;
705 spin_unlock(&GlobalMid_Lock);
706 wake_up_all(&server->response_q);
708 /* check if we have blocked requests that need to free */
709 spin_lock(&server->req_lock);
710 if (server->credits <= 0)
711 server->credits = 1;
712 spin_unlock(&server->req_lock);
713 /*
714 * Although there should not be any requests blocked on this queue it
715 * can not hurt to be paranoid and try to wake up requests that may
716 * haven been blocked when more than 50 at time were on the wire to the
717 * same server - they now will see the session is in exit state and get
718 * out of SendReceive.
719 */
720 wake_up_all(&server->request_q);
721 /* give those requests time to exit */
722 msleep(125);
723 if (cifs_rdma_enabled(server) && server->smbd_conn) {
724 smbd_destroy(server->smbd_conn);
725 server->smbd_conn = NULL;
726 }
727 if (server->ssocket) {
728 sock_release(server->ssocket);
729 server->ssocket = NULL;
730 }
732 if (!list_empty(&server->pending_mid_q)) {
733 struct list_head dispose_list;
734 struct mid_q_entry *mid_entry;
735 struct list_head *tmp, *tmp2;
737 INIT_LIST_HEAD(&dispose_list);
738 spin_lock(&GlobalMid_Lock);
739 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
740 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
741 cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid);
742 mid_entry->mid_state = MID_SHUTDOWN;
743 list_move(&mid_entry->qhead, &dispose_list);
744 }
745 spin_unlock(&GlobalMid_Lock);
747 /* now walk dispose list and issue callbacks */
748 list_for_each_safe(tmp, tmp2, &dispose_list) {
749 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
750 cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid);
751 list_del_init(&mid_entry->qhead);
752 mid_entry->callback(mid_entry);
753 }
754 /* 1/8th of sec is more than enough time for them to exit */
755 msleep(125);
756 }
758 if (!list_empty(&server->pending_mid_q)) {
759 /*
760 * mpx threads have not exited yet give them at least the smb
761 * send timeout time for long ops.
762 *
763 * Due to delays on oplock break requests, we need to wait at
764 * least 45 seconds before giving up on a request getting a
765 * response and going ahead and killing cifsd.
766 */
767 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
768 msleep(46000);
769 /*
770 * If threads still have not exited they are probably never
771 * coming home not much else we can do but free the memory.
772 */
773 }
775 kfree(server->hostname);
776 kfree(server);
778 length = atomic_dec_return(&tcpSesAllocCount);
779 if (length > 0)
780 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
781 }
783 static int
784 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
785 {
786 int length;
787 char *buf = server->smallbuf;
788 unsigned int pdu_length = server->pdu_size;
790 /* make sure this will fit in a large buffer */
791 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) -
792 server->vals->header_preamble_size) {
793 cifs_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
794 cifs_reconnect(server);
795 wake_up(&server->response_q);
796 return -ECONNABORTED;
797 }
799 /* switch to large buffer if too big for a small one */
800 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
801 server->large_buf = true;
802 memcpy(server->bigbuf, buf, server->total_read);
803 buf = server->bigbuf;
804 }
806 /* now read the rest */
807 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
808 pdu_length - HEADER_SIZE(server) + 1
809 + server->vals->header_preamble_size);
811 if (length < 0)
812 return length;
813 server->total_read += length;
815 dump_smb(buf, server->total_read);
817 return cifs_handle_standard(server, mid);
818 }
820 int
821 cifs_handle_standard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
822 {
823 char *buf = server->large_buf ? server->bigbuf : server->smallbuf;
824 int length;
826 /*
827 * We know that we received enough to get to the MID as we
828 * checked the pdu_length earlier. Now check to see
829 * if the rest of the header is OK. We borrow the length
830 * var for the rest of the loop to avoid a new stack var.
831 *
832 * 48 bytes is enough to display the header and a little bit
833 * into the payload for debugging purposes.
834 */
835 length = server->ops->check_message(buf, server->total_read, server);
836 if (length != 0)
837 cifs_dump_mem("Bad SMB: ", buf,
838 min_t(unsigned int, server->total_read, 48));
840 if (server->ops->is_session_expired &&
841 server->ops->is_session_expired(buf)) {
842 cifs_reconnect(server);
843 wake_up(&server->response_q);
844 return -1;
845 }
847 if (server->ops->is_status_pending &&
848 server->ops->is_status_pending(buf, server, length))
849 return -1;
851 if (!mid)
852 return length;
854 handle_mid(mid, server, buf, length);
855 return 0;
856 }
858 static int
859 cifs_demultiplex_thread(void *p)
860 {
861 int i, num_mids, length;
862 struct TCP_Server_Info *server = p;
863 unsigned int pdu_length;
864 unsigned int next_offset;
865 char *buf = NULL;
866 struct task_struct *task_to_wake = NULL;
867 struct mid_q_entry *mids[MAX_COMPOUND];
868 char *bufs[MAX_COMPOUND];
870 current->flags |= PF_MEMALLOC;
871 cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
873 length = atomic_inc_return(&tcpSesAllocCount);
874 if (length > 1)
875 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
877 set_freezable();
878 while (server->tcpStatus != CifsExiting) {
879 if (try_to_freeze())
880 continue;
882 if (!allocate_buffers(server))
883 continue;
885 server->large_buf = false;
886 buf = server->smallbuf;
887 pdu_length = 4; /* enough to get RFC1001 header */
889 length = cifs_read_from_socket(server, buf, pdu_length);
890 if (length < 0)
891 continue;
893 if (server->vals->header_preamble_size == 0)
894 server->total_read = 0;
895 else
896 server->total_read = length;
898 /*
899 * The right amount was read from socket - 4 bytes,
900 * so we can now interpret the length field.
901 */
902 pdu_length = get_rfc1002_length(buf);
904 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
905 if (!is_smb_response(server, buf[0]))
906 continue;
907 next_pdu:
908 server->pdu_size = pdu_length;
910 /* make sure we have enough to get to the MID */
911 if (server->pdu_size < HEADER_SIZE(server) - 1 -
912 server->vals->header_preamble_size) {
913 cifs_dbg(VFS, "SMB response too short (%u bytes)\n",
914 server->pdu_size);
915 cifs_reconnect(server);
916 wake_up(&server->response_q);
917 continue;
918 }
920 /* read down to the MID */
921 length = cifs_read_from_socket(server,
922 buf + server->vals->header_preamble_size,
923 HEADER_SIZE(server) - 1
924 - server->vals->header_preamble_size);
925 if (length < 0)
926 continue;
927 server->total_read += length;
929 if (server->ops->next_header) {
930 next_offset = server->ops->next_header(buf);
931 if (next_offset)
932 server->pdu_size = next_offset;
933 }
935 memset(mids, 0, sizeof(mids));
936 memset(bufs, 0, sizeof(bufs));
937 num_mids = 0;
939 if (server->ops->is_transform_hdr &&
940 server->ops->receive_transform &&
941 server->ops->is_transform_hdr(buf)) {
942 length = server->ops->receive_transform(server,
943 mids,
944 bufs,
945 &num_mids);
946 } else {
947 mids[0] = server->ops->find_mid(server, buf);
948 bufs[0] = buf;
949 num_mids = 1;
951 if (!mids[0] || !mids[0]->receive)
952 length = standard_receive3(server, mids[0]);
953 else
954 length = mids[0]->receive(server, mids[0]);
955 }
957 if (length < 0) {
958 for (i = 0; i < num_mids; i++)
959 if (mids[i])
960 cifs_mid_q_entry_release(mids[i]);
961 continue;
962 }
964 if (server->large_buf)
965 buf = server->bigbuf;
968 server->lstrp = jiffies;
970 for (i = 0; i < num_mids; i++) {
971 if (mids[i] != NULL) {
972 mids[i]->resp_buf_size = server->pdu_size;
973 if ((mids[i]->mid_flags & MID_WAIT_CANCELLED) &&
974 mids[i]->mid_state == MID_RESPONSE_RECEIVED &&
975 server->ops->handle_cancelled_mid)
976 server->ops->handle_cancelled_mid(
977 mids[i]->resp_buf,
978 server);
980 if (!mids[i]->multiRsp || mids[i]->multiEnd)
981 mids[i]->callback(mids[i]);
983 cifs_mid_q_entry_release(mids[i]);
984 } else if (server->ops->is_oplock_break &&
985 server->ops->is_oplock_break(bufs[i],
986 server)) {
987 cifs_dbg(FYI, "Received oplock break\n");
988 } else {
989 cifs_dbg(VFS, "No task to wake, unknown frame "
990 "received! NumMids %d\n",
991 atomic_read(&midCount));
992 cifs_dump_mem("Received Data is: ", bufs[i],
993 HEADER_SIZE(server));
994 #ifdef CONFIG_CIFS_DEBUG2
995 if (server->ops->dump_detail)
996 server->ops->dump_detail(bufs[i],
997 server);
998 cifs_dump_mids(server);
999 #endif /* CIFS_DEBUG2 */
1000 }
1001 }
1003 if (pdu_length > server->pdu_size) {
1004 if (!allocate_buffers(server))
1005 continue;
1006 pdu_length -= server->pdu_size;
1007 server->total_read = 0;
1008 server->large_buf = false;
1009 buf = server->smallbuf;
1010 goto next_pdu;
1011 }
1012 } /* end while !EXITING */
1014 /* buffer usually freed in free_mid - need to free it here on exit */
1015 cifs_buf_release(server->bigbuf);
1016 if (server->smallbuf) /* no sense logging a debug message if NULL */
1017 cifs_small_buf_release(server->smallbuf);
1019 task_to_wake = xchg(&server->tsk, NULL);
1020 clean_demultiplex_info(server);
1022 /* if server->tsk was NULL then wait for a signal before exiting */
1023 if (!task_to_wake) {
1024 set_current_state(TASK_INTERRUPTIBLE);
1025 while (!signal_pending(current)) {
1026 schedule();
1027 set_current_state(TASK_INTERRUPTIBLE);
1028 }
1029 set_current_state(TASK_RUNNING);
1030 }
1032 module_put_and_exit(0);
1033 }
1035 /* extract the host portion of the UNC string */
1036 static char *
1037 extract_hostname(const char *unc)
1038 {
1039 const char *src;
1040 char *dst, *delim;
1041 unsigned int len;
1043 /* skip double chars at beginning of string */
1044 /* BB: check validity of these bytes? */
1045 src = unc + 2;
1047 /* delimiter between hostname and sharename is always '\\' now */
1048 delim = strchr(src, '\\');
1049 if (!delim)
1050 return ERR_PTR(-EINVAL);
1052 len = delim - src;
1053 dst = kmalloc((len + 1), GFP_KERNEL);
1054 if (dst == NULL)
1055 return ERR_PTR(-ENOMEM);
1057 memcpy(dst, src, len);
1058 dst[len] = '\0';
1060 return dst;
1061 }
1063 static int get_option_ul(substring_t args[], unsigned long *option)
1064 {
1065 int rc;
1066 char *string;
1068 string = match_strdup(args);
1069 if (string == NULL)
1070 return -ENOMEM;
1071 rc = kstrtoul(string, 0, option);
1072 kfree(string);
1074 return rc;
1075 }
1077 static int get_option_uid(substring_t args[], kuid_t *result)
1078 {
1079 unsigned long value;
1080 kuid_t uid;
1081 int rc;
1083 rc = get_option_ul(args, &value);
1084 if (rc)
1085 return rc;
1087 uid = make_kuid(current_user_ns(), value);
1088 if (!uid_valid(uid))
1089 return -EINVAL;
1091 *result = uid;
1092 return 0;
1093 }
1095 static int get_option_gid(substring_t args[], kgid_t *result)
1096 {
1097 unsigned long value;
1098 kgid_t gid;
1099 int rc;
1101 rc = get_option_ul(args, &value);
1102 if (rc)
1103 return rc;
1105 gid = make_kgid(current_user_ns(), value);
1106 if (!gid_valid(gid))
1107 return -EINVAL;
1109 *result = gid;
1110 return 0;
1111 }
1113 static int cifs_parse_security_flavors(char *value,
1114 struct smb_vol *vol)
1115 {
1117 substring_t args[MAX_OPT_ARGS];
1119 /*
1120 * With mount options, the last one should win. Reset any existing
1121 * settings back to default.
1122 */
1123 vol->sectype = Unspecified;
1124 vol->sign = false;
1126 switch (match_token(value, cifs_secflavor_tokens, args)) {
1127 case Opt_sec_krb5p:
1128 cifs_dbg(VFS, "sec=krb5p is not supported!\n");
1129 return 1;
1130 case Opt_sec_krb5i:
1131 vol->sign = true;
1132 /* Fallthrough */
1133 case Opt_sec_krb5:
1134 vol->sectype = Kerberos;
1135 break;
1136 case Opt_sec_ntlmsspi:
1137 vol->sign = true;
1138 /* Fallthrough */
1139 case Opt_sec_ntlmssp:
1140 vol->sectype = RawNTLMSSP;
1141 break;
1142 case Opt_sec_ntlmi:
1143 vol->sign = true;
1144 /* Fallthrough */
1145 case Opt_ntlm:
1146 vol->sectype = NTLM;
1147 break;
1148 case Opt_sec_ntlmv2i:
1149 vol->sign = true;
1150 /* Fallthrough */
1151 case Opt_sec_ntlmv2:
1152 vol->sectype = NTLMv2;
1153 break;
1154 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1155 case Opt_sec_lanman:
1156 vol->sectype = LANMAN;
1157 break;
1158 #endif
1159 case Opt_sec_none:
1160 vol->nullauth = 1;
1161 break;
1162 default:
1163 cifs_dbg(VFS, "bad security option: %s\n", value);
1164 return 1;
1165 }
1167 return 0;
1168 }
1170 static int
1171 cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1172 {
1173 substring_t args[MAX_OPT_ARGS];
1175 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1176 case Opt_cache_loose:
1177 vol->direct_io = false;
1178 vol->strict_io = false;
1179 break;
1180 case Opt_cache_strict:
1181 vol->direct_io = false;
1182 vol->strict_io = true;
1183 break;
1184 case Opt_cache_none:
1185 vol->direct_io = true;
1186 vol->strict_io = false;
1187 break;
1188 default:
1189 cifs_dbg(VFS, "bad cache= option: %s\n", value);
1190 return 1;
1191 }
1192 return 0;
1193 }
1195 static int
1196 cifs_parse_smb_version(char *value, struct smb_vol *vol, bool is_smb3)
1197 {
1198 substring_t args[MAX_OPT_ARGS];
1200 switch (match_token(value, cifs_smb_version_tokens, args)) {
1201 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1202 case Smb_1:
1203 if (disable_legacy_dialects) {
1204 cifs_dbg(VFS, "mount with legacy dialect disabled\n");
1205 return 1;
1206 }
1207 if (is_smb3) {
1208 cifs_dbg(VFS, "vers=1.0 (cifs) not permitted when mounting with smb3\n");
1209 return 1;
1210 }
1211 vol->ops = &smb1_operations;
1212 vol->vals = &smb1_values;
1213 break;
1214 case Smb_20:
1215 if (disable_legacy_dialects) {
1216 cifs_dbg(VFS, "mount with legacy dialect disabled\n");
1217 return 1;
1218 }
1219 if (is_smb3) {
1220 cifs_dbg(VFS, "vers=2.0 not permitted when mounting with smb3\n");
1221 return 1;
1222 }
1223 vol->ops = &smb20_operations;
1224 vol->vals = &smb20_values;
1225 break;
1226 #else
1227 case Smb_1:
1228 cifs_dbg(VFS, "vers=1.0 (cifs) mount not permitted when legacy dialects disabled\n");
1229 return 1;
1230 case Smb_20:
1231 cifs_dbg(VFS, "vers=2.0 mount not permitted when legacy dialects disabled\n");
1232 return 1;
1233 #endif /* CIFS_ALLOW_INSECURE_LEGACY */
1234 case Smb_21:
1235 vol->ops = &smb21_operations;
1236 vol->vals = &smb21_values;
1237 break;
1238 case Smb_30:
1239 vol->ops = &smb30_operations;
1240 vol->vals = &smb30_values;
1241 break;
1242 case Smb_302:
1243 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1244 vol->vals = &smb302_values;
1245 break;
1246 case Smb_311:
1247 vol->ops = &smb311_operations;
1248 vol->vals = &smb311_values;
1249 break;
1250 case Smb_3any:
1251 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1252 vol->vals = &smb3any_values;
1253 break;
1254 case Smb_default:
1255 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1256 vol->vals = &smbdefault_values;
1257 break;
1258 default:
1259 cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
1260 return 1;
1261 }
1262 return 0;
1263 }
1265 /*
1266 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1267 * fields with the result. Returns 0 on success and an error otherwise.
1268 */
1269 static int
1270 cifs_parse_devname(const char *devname, struct smb_vol *vol)
1271 {
1272 char *pos;
1273 const char *delims = "/\\";
1274 size_t len;
1276 /* make sure we have a valid UNC double delimiter prefix */
1277 len = strspn(devname, delims);
1278 if (len != 2)
1279 return -EINVAL;
1281 /* find delimiter between host and sharename */
1282 pos = strpbrk(devname + 2, delims);
1283 if (!pos)
1284 return -EINVAL;
1286 /* skip past delimiter */
1287 ++pos;
1289 /* now go until next delimiter or end of string */
1290 len = strcspn(pos, delims);
1292 /* move "pos" up to delimiter or NULL */
1293 pos += len;
1294 vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1295 if (!vol->UNC)
1296 return -ENOMEM;
1298 convert_delimiter(vol->UNC, '\\');
1300 /* skip any delimiter */
1301 if (*pos == '/' || *pos == '\\')
1302 pos++;
1304 /* If pos is NULL then no prepath */
1305 if (!*pos)
1306 return 0;
1308 vol->prepath = kstrdup(pos, GFP_KERNEL);
1309 if (!vol->prepath)
1310 return -ENOMEM;
1312 return 0;
1313 }
1315 static int
1316 cifs_parse_mount_options(const char *mountdata, const char *devname,
1317 struct smb_vol *vol, bool is_smb3)
1318 {
1319 char *data, *end;
1320 char *mountdata_copy = NULL, *options;
1321 unsigned int temp_len, i, j;
1322 char separator[2];
1323 short int override_uid = -1;
1324 short int override_gid = -1;
1325 bool uid_specified = false;
1326 bool gid_specified = false;
1327 bool sloppy = false;
1328 char *invalid = NULL;
1329 char *nodename = utsname()->nodename;
1330 char *string = NULL;
1331 char *tmp_end, *value;
1332 char delim;
1333 bool got_ip = false;
1334 bool got_version = false;
1335 unsigned short port = 0;
1336 struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1338 separator[0] = ',';
1339 separator[1] = 0;
1340 delim = separator[0];
1342 /* ensure we always start with zeroed-out smb_vol */
1343 memset(vol, 0, sizeof(*vol));
1345 /*
1346 * does not have to be perfect mapping since field is
1347 * informational, only used for servers that do not support
1348 * port 445 and it can be overridden at mount time
1349 */
1350 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1351 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1352 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1354 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1355 /* null target name indicates to use *SMBSERVR default called name
1356 if we end up sending RFC1001 session initialize */
1357 vol->target_rfc1001_name[0] = 0;
1358 vol->cred_uid = current_uid();
1359 vol->linux_uid = current_uid();
1360 vol->linux_gid = current_gid();
1362 /*
1363 * default to SFM style remapping of seven reserved characters
1364 * unless user overrides it or we negotiate CIFS POSIX where
1365 * it is unnecessary. Can not simultaneously use more than one mapping
1366 * since then readdir could list files that open could not open
1367 */
1368 vol->remap = true;
1370 /* default to only allowing write access to owner of the mount */
1371 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1373 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1374 /* default is always to request posix paths. */
1375 vol->posix_paths = 1;
1376 /* default to using server inode numbers where available */
1377 vol->server_ino = 1;
1379 /* default is to use strict cifs caching semantics */
1380 vol->strict_io = true;
1382 vol->actimeo = CIFS_DEF_ACTIMEO;
1384 /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
1385 vol->ops = &smb30_operations;
1386 vol->vals = &smbdefault_values;
1388 vol->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1390 if (!mountdata)
1391 goto cifs_parse_mount_err;
1393 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1394 if (!mountdata_copy)
1395 goto cifs_parse_mount_err;
1397 options = mountdata_copy;
1398 end = options + strlen(options);
1400 if (strncmp(options, "sep=", 4) == 0) {
1401 if (options[4] != 0) {
1402 separator[0] = options[4];
1403 options += 5;
1404 } else {
1405 cifs_dbg(FYI, "Null separator not allowed\n");
1406 }
1407 }
1408 vol->backupuid_specified = false; /* no backup intent for a user */
1409 vol->backupgid_specified = false; /* no backup intent for a group */
1411 switch (cifs_parse_devname(devname, vol)) {
1412 case 0:
1413 break;
1414 case -ENOMEM:
1415 cifs_dbg(VFS, "Unable to allocate memory for devname.\n");
1416 goto cifs_parse_mount_err;
1417 case -EINVAL:
1418 cifs_dbg(VFS, "Malformed UNC in devname.\n");
1419 goto cifs_parse_mount_err;
1420 default:
1421 cifs_dbg(VFS, "Unknown error parsing devname.\n");
1422 goto cifs_parse_mount_err;
1423 }
1425 while ((data = strsep(&options, separator)) != NULL) {
1426 substring_t args[MAX_OPT_ARGS];
1427 unsigned long option;
1428 int token;
1430 if (!*data)
1431 continue;
1433 token = match_token(data, cifs_mount_option_tokens, args);
1435 switch (token) {
1437 /* Ingnore the following */
1438 case Opt_ignore:
1439 break;
1441 /* Boolean values */
1442 case Opt_user_xattr:
1443 vol->no_xattr = 0;
1444 break;
1445 case Opt_nouser_xattr:
1446 vol->no_xattr = 1;
1447 break;
1448 case Opt_forceuid:
1449 override_uid = 1;
1450 break;
1451 case Opt_noforceuid:
1452 override_uid = 0;
1453 break;
1454 case Opt_forcegid:
1455 override_gid = 1;
1456 break;
1457 case Opt_noforcegid:
1458 override_gid = 0;
1459 break;
1460 case Opt_noblocksend:
1461 vol->noblocksnd = 1;
1462 break;
1463 case Opt_noautotune:
1464 vol->noautotune = 1;
1465 break;
1466 case Opt_hard:
1467 vol->retry = 1;
1468 break;
1469 case Opt_soft:
1470 vol->retry = 0;
1471 break;
1472 case Opt_perm:
1473 vol->noperm = 0;
1474 break;
1475 case Opt_noperm:
1476 vol->noperm = 1;
1477 break;
1478 case Opt_mapchars:
1479 vol->sfu_remap = true;
1480 vol->remap = false; /* disable SFM mapping */
1481 break;
1482 case Opt_nomapchars:
1483 vol->sfu_remap = false;
1484 break;
1485 case Opt_mapposix:
1486 vol->remap = true;
1487 vol->sfu_remap = false; /* disable SFU mapping */
1488 break;
1489 case Opt_nomapposix:
1490 vol->remap = false;
1491 break;
1492 case Opt_sfu:
1493 vol->sfu_emul = 1;
1494 break;
1495 case Opt_nosfu:
1496 vol->sfu_emul = 0;
1497 break;
1498 case Opt_nodfs:
1499 vol->nodfs = 1;
1500 break;
1501 case Opt_posixpaths:
1502 vol->posix_paths = 1;
1503 break;
1504 case Opt_noposixpaths:
1505 vol->posix_paths = 0;
1506 break;
1507 case Opt_nounix:
1508 if (vol->linux_ext)
1509 cifs_dbg(VFS,
1510 "conflicting unix mount options\n");
1511 vol->no_linux_ext = 1;
1512 break;
1513 case Opt_unix:
1514 if (vol->no_linux_ext)
1515 cifs_dbg(VFS,
1516 "conflicting unix mount options\n");
1517 vol->linux_ext = 1;
1518 break;
1519 case Opt_nocase:
1520 vol->nocase = 1;
1521 break;
1522 case Opt_brl:
1523 vol->nobrl = 0;
1524 break;
1525 case Opt_nobrl:
1526 vol->nobrl = 1;
1527 /*
1528 * turn off mandatory locking in mode
1529 * if remote locking is turned off since the
1530 * local vfs will do advisory
1531 */
1532 if (vol->file_mode ==
1533 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1534 vol->file_mode = S_IALLUGO;
1535 break;
1536 case Opt_nohandlecache:
1537 vol->nohandlecache = 1;
1538 break;
1539 case Opt_handlecache:
1540 vol->nohandlecache = 0;
1541 break;
1542 case Opt_forcemandatorylock:
1543 vol->mand_lock = 1;
1544 break;
1545 case Opt_setuids:
1546 vol->setuids = 1;
1547 break;
1548 case Opt_nosetuids:
1549 vol->setuids = 0;
1550 break;
1551 case Opt_setuidfromacl:
1552 vol->setuidfromacl = 1;
1553 break;
1554 case Opt_dynperm:
1555 vol->dynperm = true;
1556 break;
1557 case Opt_nodynperm:
1558 vol->dynperm = false;
1559 break;
1560 case Opt_nohard:
1561 vol->retry = 0;
1562 break;
1563 case Opt_nosoft:
1564 vol->retry = 1;
1565 break;
1566 case Opt_nointr:
1567 vol->intr = 0;
1568 break;
1569 case Opt_intr:
1570 vol->intr = 1;
1571 break;
1572 case Opt_nostrictsync:
1573 vol->nostrictsync = 1;
1574 break;
1575 case Opt_strictsync:
1576 vol->nostrictsync = 0;
1577 break;
1578 case Opt_serverino:
1579 vol->server_ino = 1;
1580 break;
1581 case Opt_noserverino:
1582 vol->server_ino = 0;
1583 break;
1584 case Opt_rwpidforward:
1585 vol->rwpidforward = 1;
1586 break;
1587 case Opt_cifsacl:
1588 vol->cifs_acl = 1;
1589 break;
1590 case Opt_nocifsacl:
1591 vol->cifs_acl = 0;
1592 break;
1593 case Opt_acl:
1594 vol->no_psx_acl = 0;
1595 break;
1596 case Opt_noacl:
1597 vol->no_psx_acl = 1;
1598 break;
1599 case Opt_locallease:
1600 vol->local_lease = 1;
1601 break;
1602 case Opt_sign:
1603 vol->sign = true;
1604 break;
1605 case Opt_seal:
1606 /* we do not do the following in secFlags because seal
1607 * is a per tree connection (mount) not a per socket
1608 * or per-smb connection option in the protocol
1609 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1610 */
1611 vol->seal = 1;
1612 break;
1613 case Opt_noac:
1614 pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1615 break;
1616 case Opt_fsc:
1617 #ifndef CONFIG_CIFS_FSCACHE
1618 cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1619 goto cifs_parse_mount_err;
1620 #endif
1621 vol->fsc = true;
1622 break;
1623 case Opt_mfsymlinks:
1624 vol->mfsymlinks = true;
1625 break;
1626 case Opt_multiuser:
1627 vol->multiuser = true;
1628 break;
1629 case Opt_sloppy:
1630 sloppy = true;
1631 break;
1632 case Opt_nosharesock:
1633 vol->nosharesock = true;
1634 break;
1635 case Opt_nopersistent:
1636 vol->nopersistent = true;
1637 if (vol->persistent) {
1638 cifs_dbg(VFS,
1639 "persistenthandles mount options conflict\n");
1640 goto cifs_parse_mount_err;
1641 }
1642 break;
1643 case Opt_persistent:
1644 vol->persistent = true;
1645 if ((vol->nopersistent) || (vol->resilient)) {
1646 cifs_dbg(VFS,
1647 "persistenthandles mount options conflict\n");
1648 goto cifs_parse_mount_err;
1649 }
1650 break;
1651 case Opt_resilient:
1652 vol->resilient = true;
1653 if (vol->persistent) {
1654 cifs_dbg(VFS,
1655 "persistenthandles mount options conflict\n");
1656 goto cifs_parse_mount_err;
1657 }
1658 break;
1659 case Opt_noresilient:
1660 vol->resilient = false; /* already the default */
1661 break;
1662 case Opt_domainauto:
1663 vol->domainauto = true;
1664 break;
1665 case Opt_rdma:
1666 vol->rdma = true;
1667 break;
1669 /* Numeric Values */
1670 case Opt_backupuid:
1671 if (get_option_uid(args, &vol->backupuid)) {
1672 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
1673 __func__);
1674 goto cifs_parse_mount_err;
1675 }
1676 vol->backupuid_specified = true;
1677 break;
1678 case Opt_backupgid:
1679 if (get_option_gid(args, &vol->backupgid)) {
1680 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
1681 __func__);
1682 goto cifs_parse_mount_err;
1683 }
1684 vol->backupgid_specified = true;
1685 break;
1686 case Opt_uid:
1687 if (get_option_uid(args, &vol->linux_uid)) {
1688 cifs_dbg(VFS, "%s: Invalid uid value\n",
1689 __func__);
1690 goto cifs_parse_mount_err;
1691 }
1692 uid_specified = true;
1693 break;
1694 case Opt_cruid:
1695 if (get_option_uid(args, &vol->cred_uid)) {
1696 cifs_dbg(VFS, "%s: Invalid cruid value\n",
1697 __func__);
1698 goto cifs_parse_mount_err;
1699 }
1700 break;
1701 case Opt_gid:
1702 if (get_option_gid(args, &vol->linux_gid)) {
1703 cifs_dbg(VFS, "%s: Invalid gid value\n",
1704 __func__);
1705 goto cifs_parse_mount_err;
1706 }
1707 gid_specified = true;
1708 break;
1709 case Opt_file_mode:
1710 if (get_option_ul(args, &option)) {
1711 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
1712 __func__);
1713 goto cifs_parse_mount_err;
1714 }
1715 vol->file_mode = option;
1716 break;
1717 case Opt_dirmode:
1718 if (get_option_ul(args, &option)) {
1719 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
1720 __func__);
1721 goto cifs_parse_mount_err;
1722 }
1723 vol->dir_mode = option;
1724 break;
1725 case Opt_port:
1726 if (get_option_ul(args, &option) ||
1727 option > USHRT_MAX) {
1728 cifs_dbg(VFS, "%s: Invalid port value\n",
1729 __func__);
1730 goto cifs_parse_mount_err;
1731 }
1732 port = (unsigned short)option;
1733 break;
1734 case Opt_rsize:
1735 if (get_option_ul(args, &option)) {
1736 cifs_dbg(VFS, "%s: Invalid rsize value\n",
1737 __func__);
1738 goto cifs_parse_mount_err;
1739 }
1740 vol->rsize = option;
1741 break;
1742 case Opt_wsize:
1743 if (get_option_ul(args, &option)) {
1744 cifs_dbg(VFS, "%s: Invalid wsize value\n",
1745 __func__);
1746 goto cifs_parse_mount_err;
1747 }
1748 vol->wsize = option;
1749 break;
1750 case Opt_actimeo:
1751 if (get_option_ul(args, &option)) {
1752 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
1753 __func__);
1754 goto cifs_parse_mount_err;
1755 }
1756 vol->actimeo = HZ * option;
1757 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1758 cifs_dbg(VFS, "attribute cache timeout too large\n");
1759 goto cifs_parse_mount_err;
1760 }
1761 break;
1762 case Opt_echo_interval:
1763 if (get_option_ul(args, &option)) {
1764 cifs_dbg(VFS, "%s: Invalid echo interval value\n",
1765 __func__);
1766 goto cifs_parse_mount_err;
1767 }
1768 vol->echo_interval = option;
1769 break;
1770 case Opt_snapshot:
1771 if (get_option_ul(args, &option)) {
1772 cifs_dbg(VFS, "%s: Invalid snapshot time\n",
1773 __func__);
1774 goto cifs_parse_mount_err;
1775 }
1776 vol->snapshot_time = option;
1777 break;
1778 case Opt_max_credits:
1779 if (get_option_ul(args, &option) || (option < 20) ||
1780 (option > 60000)) {
1781 cifs_dbg(VFS, "%s: Invalid max_credits value\n",
1782 __func__);
1783 goto cifs_parse_mount_err;
1784 }
1785 vol->max_credits = option;
1786 break;
1788 /* String Arguments */
1790 case Opt_blank_user:
1791 /* null user, ie. anonymous authentication */
1792 vol->nullauth = 1;
1793 vol->username = NULL;
1794 break;
1795 case Opt_user:
1796 string = match_strdup(args);
1797 if (string == NULL)
1798 goto out_nomem;
1800 if (strnlen(string, CIFS_MAX_USERNAME_LEN) >
1801 CIFS_MAX_USERNAME_LEN) {
1802 pr_warn("CIFS: username too long\n");
1803 goto cifs_parse_mount_err;
1804 }
1806 kfree(vol->username);
1807 vol->username = kstrdup(string, GFP_KERNEL);
1808 if (!vol->username)
1809 goto cifs_parse_mount_err;
1810 break;
1811 case Opt_blank_pass:
1812 /* passwords have to be handled differently
1813 * to allow the character used for deliminator
1814 * to be passed within them
1815 */
1817 /*
1818 * Check if this is a case where the password
1819 * starts with a delimiter
1820 */
1821 tmp_end = strchr(data, '=');
1822 tmp_end++;
1823 if (!(tmp_end < end && tmp_end[1] == delim)) {
1824 /* No it is not. Set the password to NULL */
1825 kzfree(vol->password);
1826 vol->password = NULL;
1827 break;
1828 }
1829 /* Yes it is. Drop down to Opt_pass below.*/
1830 case Opt_pass:
1831 /* Obtain the value string */
1832 value = strchr(data, '=');
1833 value++;
1835 /* Set tmp_end to end of the string */
1836 tmp_end = (char *) value + strlen(value);
1838 /* Check if following character is the deliminator
1839 * If yes, we have encountered a double deliminator
1840 * reset the NULL character to the deliminator
1841 */
1842 if (tmp_end < end && tmp_end[1] == delim) {
1843 tmp_end[0] = delim;
1845 /* Keep iterating until we get to a single
1846 * deliminator OR the end
1847 */
1848 while ((tmp_end = strchr(tmp_end, delim))
1849 != NULL && (tmp_end[1] == delim)) {
1850 tmp_end = (char *) &tmp_end[2];
1851 }
1853 /* Reset var options to point to next element */
1854 if (tmp_end) {
1855 tmp_end[0] = '\0';
1856 options = (char *) &tmp_end[1];
1857 } else
1858 /* Reached the end of the mount option
1859 * string */
1860 options = end;
1861 }
1863 kzfree(vol->password);
1864 /* Now build new password string */
1865 temp_len = strlen(value);
1866 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1867 if (vol->password == NULL) {
1868 pr_warn("CIFS: no memory for password\n");
1869 goto cifs_parse_mount_err;
1870 }
1872 for (i = 0, j = 0; i < temp_len; i++, j++) {
1873 vol->password[j] = value[i];
1874 if ((value[i] == delim) &&
1875 value[i+1] == delim)
1876 /* skip the second deliminator */
1877 i++;
1878 }
1879 vol->password[j] = '\0';
1880 break;
1881 case Opt_blank_ip:
1882 /* FIXME: should this be an error instead? */
1883 got_ip = false;
1884 break;
1885 case Opt_ip:
1886 string = match_strdup(args);
1887 if (string == NULL)
1888 goto out_nomem;
1890 if (!cifs_convert_address(dstaddr, string,
1891 strlen(string))) {
1892 pr_err("CIFS: bad ip= option (%s).\n", string);
1893 goto cifs_parse_mount_err;
1894 }
1895 got_ip = true;
1896 break;
1897 case Opt_domain:
1898 string = match_strdup(args);
1899 if (string == NULL)
1900 goto out_nomem;
1902 if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
1903 == CIFS_MAX_DOMAINNAME_LEN) {
1904 pr_warn("CIFS: domain name too long\n");
1905 goto cifs_parse_mount_err;
1906 }
1908 kfree(vol->domainname);
1909 vol->domainname = kstrdup(string, GFP_KERNEL);
1910 if (!vol->domainname) {
1911 pr_warn("CIFS: no memory for domainname\n");
1912 goto cifs_parse_mount_err;
1913 }
1914 cifs_dbg(FYI, "Domain name set\n");
1915 break;
1916 case Opt_srcaddr:
1917 string = match_strdup(args);
1918 if (string == NULL)
1919 goto out_nomem;
1921 if (!cifs_convert_address(
1922 (struct sockaddr *)&vol->srcaddr,
1923 string, strlen(string))) {
1924 pr_warn("CIFS: Could not parse srcaddr: %s\n",
1925 string);
1926 goto cifs_parse_mount_err;
1927 }
1928 break;
1929 case Opt_iocharset:
1930 string = match_strdup(args);
1931 if (string == NULL)
1932 goto out_nomem;
1934 if (strnlen(string, 1024) >= 65) {
1935 pr_warn("CIFS: iocharset name too long.\n");
1936 goto cifs_parse_mount_err;
1937 }
1939 if (strncasecmp(string, "default", 7) != 0) {
1940 kfree(vol->iocharset);
1941 vol->iocharset = kstrdup(string,
1942 GFP_KERNEL);
1943 if (!vol->iocharset) {
1944 pr_warn("CIFS: no memory for charset\n");
1945 goto cifs_parse_mount_err;
1946 }
1947 }
1948 /* if iocharset not set then load_nls_default
1949 * is used by caller
1950 */
1951 cifs_dbg(FYI, "iocharset set to %s\n", string);
1952 break;
1953 case Opt_netbiosname:
1954 string = match_strdup(args);
1955 if (string == NULL)
1956 goto out_nomem;
1958 memset(vol->source_rfc1001_name, 0x20,
1959 RFC1001_NAME_LEN);
1960 /*
1961 * FIXME: are there cases in which a comma can
1962 * be valid in workstation netbios name (and
1963 * need special handling)?
1964 */
1965 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1966 /* don't ucase netbiosname for user */
1967 if (string[i] == 0)
1968 break;
1969 vol->source_rfc1001_name[i] = string[i];
1970 }
1971 /* The string has 16th byte zero still from
1972 * set at top of the function
1973 */
1974 if (i == RFC1001_NAME_LEN && string[i] != 0)
1975 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
1976 break;
1977 case Opt_servern:
1978 /* servernetbiosname specified override *SMBSERVER */
1979 string = match_strdup(args);
1980 if (string == NULL)
1981 goto out_nomem;
1983 /* last byte, type, is 0x20 for servr type */
1984 memset(vol->target_rfc1001_name, 0x20,
1985 RFC1001_NAME_LEN_WITH_NULL);
1987 /* BB are there cases in which a comma can be
1988 valid in this workstation netbios name
1989 (and need special handling)? */
1991 /* user or mount helper must uppercase the
1992 netbios name */
1993 for (i = 0; i < 15; i++) {
1994 if (string[i] == 0)
1995 break;
1996 vol->target_rfc1001_name[i] = string[i];
1997 }
1998 /* The string has 16th byte zero still from
1999 set at top of the function */
2000 if (i == RFC1001_NAME_LEN && string[i] != 0)
2001 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
2002 break;
2003 case Opt_ver:
2004 /* version of mount userspace tools, not dialect */
2005 string = match_strdup(args);
2006 if (string == NULL)
2007 goto out_nomem;
2009 /* If interface changes in mount.cifs bump to new ver */
2010 if (strncasecmp(string, "1", 1) == 0) {
2011 if (strlen(string) > 1) {
2012 pr_warn("Bad mount helper ver=%s. Did "
2013 "you want SMB1 (CIFS) dialect "
2014 "and mean to type vers=1.0 "
2015 "instead?\n", string);
2016 goto cifs_parse_mount_err;
2017 }
2018 /* This is the default */
2019 break;
2020 }
2021 /* For all other value, error */
2022 pr_warn("CIFS: Invalid mount helper version specified\n");
2023 goto cifs_parse_mount_err;
2024 case Opt_vers:
2025 /* protocol version (dialect) */
2026 string = match_strdup(args);
2027 if (string == NULL)
2028 goto out_nomem;
2030 if (cifs_parse_smb_version(string, vol, is_smb3) != 0)
2031 goto cifs_parse_mount_err;
2032 got_version = true;
2033 break;
2034 case Opt_sec:
2035 string = match_strdup(args);
2036 if (string == NULL)
2037 goto out_nomem;
2039 if (cifs_parse_security_flavors(string, vol) != 0)
2040 goto cifs_parse_mount_err;
2041 break;
2042 case Opt_cache:
2043 string = match_strdup(args);
2044 if (string == NULL)
2045 goto out_nomem;
2047 if (cifs_parse_cache_flavor(string, vol) != 0)
2048 goto cifs_parse_mount_err;
2049 break;
2050 default:
2051 /*
2052 * An option we don't recognize. Save it off for later
2053 * if we haven't already found one
2054 */
2055 if (!invalid)
2056 invalid = data;
2057 break;
2058 }
2059 /* Free up any allocated string */
2060 kfree(string);
2061 string = NULL;
2062 }
2064 if (!sloppy && invalid) {
2065 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid);
2066 goto cifs_parse_mount_err;
2067 }
2069 if (vol->rdma && vol->vals->protocol_id < SMB30_PROT_ID) {
2070 cifs_dbg(VFS, "SMB Direct requires Version >=3.0\n");
2071 goto cifs_parse_mount_err;
2072 }
2074 #ifndef CONFIG_KEYS
2075 /* Muliuser mounts require CONFIG_KEYS support */
2076 if (vol->multiuser) {
2077 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
2078 goto cifs_parse_mount_err;
2079 }
2080 #endif
2081 if (!vol->UNC) {
2082 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
2083 goto cifs_parse_mount_err;
2084 }
2086 /* make sure UNC has a share name */
2087 if (!strchr(vol->UNC + 3, '\\')) {
2088 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
2089 goto cifs_parse_mount_err;
2090 }
2092 if (!got_ip) {
2093 int len;
2094 const char *slash;
2096 /* No ip= option specified? Try to get it from UNC */
2097 /* Use the address part of the UNC. */
2098 slash = strchr(&vol->UNC[2], '\\');
2099 len = slash - &vol->UNC[2];
2100 if (!cifs_convert_address(dstaddr, &vol->UNC[2], len)) {
2101 pr_err("Unable to determine destination address.\n");
2102 goto cifs_parse_mount_err;
2103 }
2104 }
2106 /* set the port that we got earlier */
2107 cifs_set_port(dstaddr, port);
2109 if (uid_specified)
2110 vol->override_uid = override_uid;
2111 else if (override_uid == 1)
2112 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
2114 if (gid_specified)
2115 vol->override_gid = override_gid;
2116 else if (override_gid == 1)
2117 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
2119 if (got_version == false)
2120 pr_warn("No dialect specified on mount. Default has changed to "
2121 "a more secure dialect, SMB2.1 or later (e.g. SMB3), from CIFS "
2122 "(SMB1). To use the less secure SMB1 dialect to access "
2123 "old servers which do not support SMB3 (or SMB2.1) specify vers=1.0"
2124 " on mount.\n");
2126 kfree(mountdata_copy);
2127 return 0;
2129 out_nomem:
2130 pr_warn("Could not allocate temporary buffer\n");
2131 cifs_parse_mount_err:
2132 kfree(string);
2133 kfree(mountdata_copy);
2134 return 1;
2135 }
2137 /** Returns true if srcaddr isn't specified and rhs isn't
2138 * specified, or if srcaddr is specified and
2139 * matches the IP address of the rhs argument.
2140 */
2141 static bool
2142 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
2143 {
2144 switch (srcaddr->sa_family) {
2145 case AF_UNSPEC:
2146 return (rhs->sa_family == AF_UNSPEC);
2147 case AF_INET: {
2148 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
2149 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
2150 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
2151 }
2152 case AF_INET6: {
2153 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
2154 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
2155 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
2156 }
2157 default:
2158 WARN_ON(1);
2159 return false; /* don't expect to be here */
2160 }
2161 }
2163 /*
2164 * If no port is specified in addr structure, we try to match with 445 port
2165 * and if it fails - with 139 ports. It should be called only if address
2166 * families of server and addr are equal.
2167 */
2168 static bool
2169 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
2170 {
2171 __be16 port, *sport;
2173 switch (addr->sa_family) {
2174 case AF_INET:
2175 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
2176 port = ((struct sockaddr_in *) addr)->sin_port;
2177 break;
2178 case AF_INET6:
2179 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
2180 port = ((struct sockaddr_in6 *) addr)->sin6_port;
2181 break;
2182 default:
2183 WARN_ON(1);
2184 return false;
2185 }
2187 if (!port) {
2188 port = htons(CIFS_PORT);
2189 if (port == *sport)
2190 return true;
2192 port = htons(RFC1001_PORT);
2193 }
2195 return port == *sport;
2196 }
2198 static bool
2199 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
2200 struct sockaddr *srcaddr)
2201 {
2202 switch (addr->sa_family) {
2203 case AF_INET: {
2204 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2205 struct sockaddr_in *srv_addr4 =
2206 (struct sockaddr_in *)&server->dstaddr;
2208 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
2209 return false;
2210 break;
2211 }
2212 case AF_INET6: {
2213 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2214 struct sockaddr_in6 *srv_addr6 =
2215 (struct sockaddr_in6 *)&server->dstaddr;
2217 if (!ipv6_addr_equal(&addr6->sin6_addr,
2218 &srv_addr6->sin6_addr))
2219 return false;
2220 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
2221 return false;
2222 break;
2223 }
2224 default:
2225 WARN_ON(1);
2226 return false; /* don't expect to be here */
2227 }
2229 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2230 return false;
2232 return true;
2233 }
2235 static bool
2236 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2237 {
2238 /*
2239 * The select_sectype function should either return the vol->sectype
2240 * that was specified, or "Unspecified" if that sectype was not
2241 * compatible with the given NEGOTIATE request.
2242 */
2243 if (server->ops->select_sectype(server, vol->sectype)
2244 == Unspecified)
2245 return false;
2247 /*
2248 * Now check if signing mode is acceptable. No need to check
2249 * global_secflags at this point since if MUST_SIGN is set then
2250 * the server->sign had better be too.
2251 */
2252 if (vol->sign && !server->sign)
2253 return false;
2255 return true;
2256 }
2258 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2259 {
2260 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2262 if (vol->nosharesock)
2263 return 0;
2265 /* BB update this for smb3any and default case */
2266 if ((server->vals != vol->vals) || (server->ops != vol->ops))
2267 return 0;
2269 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2270 return 0;
2272 if (!match_address(server, addr,
2273 (struct sockaddr *)&vol->srcaddr))
2274 return 0;
2276 if (!match_port(server, addr))
2277 return 0;
2279 if (!match_security(server, vol))
2280 return 0;
2282 if (server->echo_interval != vol->echo_interval * HZ)
2283 return 0;
2285 if (server->rdma != vol->rdma)
2286 return 0;
2288 return 1;
2289 }
2291 static struct TCP_Server_Info *
2292 cifs_find_tcp_session(struct smb_vol *vol)
2293 {
2294 struct TCP_Server_Info *server;
2296 spin_lock(&cifs_tcp_ses_lock);
2297 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2298 if (!match_server(server, vol))
2299 continue;
2301 ++server->srv_count;
2302 spin_unlock(&cifs_tcp_ses_lock);
2303 cifs_dbg(FYI, "Existing tcp session with server found\n");
2304 return server;
2305 }
2306 spin_unlock(&cifs_tcp_ses_lock);
2307 return NULL;
2308 }
2310 void
2311 cifs_put_tcp_session(struct TCP_Server_Info *server, int from_reconnect)
2312 {
2313 struct task_struct *task;
2315 spin_lock(&cifs_tcp_ses_lock);
2316 if (--server->srv_count > 0) {
2317 spin_unlock(&cifs_tcp_ses_lock);
2318 return;
2319 }
2321 put_net(cifs_net_ns(server));
2323 list_del_init(&server->tcp_ses_list);
2324 spin_unlock(&cifs_tcp_ses_lock);
2326 cancel_delayed_work_sync(&server->echo);
2328 if (from_reconnect)
2329 /*
2330 * Avoid deadlock here: reconnect work calls
2331 * cifs_put_tcp_session() at its end. Need to be sure
2332 * that reconnect work does nothing with server pointer after
2333 * that step.
2334 */
2335 cancel_delayed_work(&server->reconnect);
2336 else
2337 cancel_delayed_work_sync(&server->reconnect);
2339 spin_lock(&GlobalMid_Lock);
2340 server->tcpStatus = CifsExiting;
2341 spin_unlock(&GlobalMid_Lock);
2343 cifs_crypto_secmech_release(server);
2344 cifs_fscache_release_client_cookie(server);
2346 kfree(server->session_key.response);
2347 server->session_key.response = NULL;
2348 server->session_key.len = 0;
2350 task = xchg(&server->tsk, NULL);
2351 if (task)
2352 force_sig(SIGKILL, task);
2353 }
2355 static struct TCP_Server_Info *
2356 cifs_get_tcp_session(struct smb_vol *volume_info)
2357 {
2358 struct TCP_Server_Info *tcp_ses = NULL;
2359 int rc;
2361 cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
2363 /* see if we already have a matching tcp_ses */
2364 tcp_ses = cifs_find_tcp_session(volume_info);
2365 if (tcp_ses)
2366 return tcp_ses;
2368 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2369 if (!tcp_ses) {
2370 rc = -ENOMEM;
2371 goto out_err;
2372 }
2374 tcp_ses->ops = volume_info->ops;
2375 tcp_ses->vals = volume_info->vals;
2376 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2377 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2378 if (IS_ERR(tcp_ses->hostname)) {
2379 rc = PTR_ERR(tcp_ses->hostname);
2380 goto out_err_crypto_release;
2381 }
2383 tcp_ses->noblocksnd = volume_info->noblocksnd;
2384 tcp_ses->noautotune = volume_info->noautotune;
2385 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2386 tcp_ses->rdma = volume_info->rdma;
2387 tcp_ses->in_flight = 0;
2388 tcp_ses->credits = 1;
2389 init_waitqueue_head(&tcp_ses->response_q);
2390 init_waitqueue_head(&tcp_ses->request_q);
2391 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2392 mutex_init(&tcp_ses->srv_mutex);
2393 memcpy(tcp_ses->workstation_RFC1001_name,
2394 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2395 memcpy(tcp_ses->server_RFC1001_name,
2396 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2397 tcp_ses->session_estab = false;
2398 tcp_ses->sequence_number = 0;
2399 tcp_ses->lstrp = jiffies;
2400 spin_lock_init(&tcp_ses->req_lock);
2401 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2402 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2403 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2404 INIT_DELAYED_WORK(&tcp_ses->reconnect, smb2_reconnect_server);
2405 mutex_init(&tcp_ses->reconnect_mutex);
2406 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2407 sizeof(tcp_ses->srcaddr));
2408 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2409 sizeof(tcp_ses->dstaddr));
2410 generate_random_uuid(tcp_ses->client_guid);
2411 /*
2412 * at this point we are the only ones with the pointer
2413 * to the struct since the kernel thread not created yet
2414 * no need to spinlock this init of tcpStatus or srv_count
2415 */
2416 tcp_ses->tcpStatus = CifsNew;
2417 ++tcp_ses->srv_count;
2419 if (volume_info->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
2420 volume_info->echo_interval <= SMB_ECHO_INTERVAL_MAX)
2421 tcp_ses->echo_interval = volume_info->echo_interval * HZ;
2422 else
2423 tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
2424 if (tcp_ses->rdma) {
2425 #ifndef CONFIG_CIFS_SMB_DIRECT
2426 cifs_dbg(VFS, "CONFIG_CIFS_SMB_DIRECT is not enabled\n");
2427 rc = -ENOENT;
2428 goto out_err_crypto_release;
2429 #endif
2430 tcp_ses->smbd_conn = smbd_get_connection(
2431 tcp_ses, (struct sockaddr *)&volume_info->dstaddr);
2432 if (tcp_ses->smbd_conn) {
2433 cifs_dbg(VFS, "RDMA transport established\n");
2434 rc = 0;
2435 goto smbd_connected;
2436 } else {
2437 rc = -ENOENT;
2438 goto out_err_crypto_release;
2439 }
2440 }
2441 rc = ip_connect(tcp_ses);
2442 if (rc < 0) {
2443 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
2444 goto out_err_crypto_release;
2445 }
2446 smbd_connected:
2447 /*
2448 * since we're in a cifs function already, we know that
2449 * this will succeed. No need for try_module_get().
2450 */
2451 __module_get(THIS_MODULE);
2452 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2453 tcp_ses, "cifsd");
2454 if (IS_ERR(tcp_ses->tsk)) {
2455 rc = PTR_ERR(tcp_ses->tsk);
2456 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
2457 module_put(THIS_MODULE);
2458 goto out_err_crypto_release;
2459 }
2460 tcp_ses->tcpStatus = CifsNeedNegotiate;
2462 /* thread spawned, put it on the list */
2463 spin_lock(&cifs_tcp_ses_lock);
2464 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2465 spin_unlock(&cifs_tcp_ses_lock);
2467 cifs_fscache_get_client_cookie(tcp_ses);
2469 /* queue echo request delayed work */
2470 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
2472 return tcp_ses;
2474 out_err_crypto_release:
2475 cifs_crypto_secmech_release(tcp_ses);
2477 put_net(cifs_net_ns(tcp_ses));
2479 out_err:
2480 if (tcp_ses) {
2481 if (!IS_ERR(tcp_ses->hostname))
2482 kfree(tcp_ses->hostname);
2483 if (tcp_ses->ssocket)
2484 sock_release(tcp_ses->ssocket);
2485 kfree(tcp_ses);
2486 }
2487 return ERR_PTR(rc);
2488 }
2490 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2491 {
2492 if (vol->sectype != Unspecified &&
2493 vol->sectype != ses->sectype)
2494 return 0;
2496 switch (ses->sectype) {
2497 case Kerberos:
2498 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2499 return 0;
2500 break;
2501 default:
2502 /* NULL username means anonymous session */
2503 if (ses->user_name == NULL) {
2504 if (!vol->nullauth)
2505 return 0;
2506 break;
2507 }
2509 /* anything else takes username/password */
2510 if (strncmp(ses->user_name,
2511 vol->username ? vol->username : "",
2512 CIFS_MAX_USERNAME_LEN))
2513 return 0;
2514 if ((vol->username && strlen(vol->username) != 0) &&
2515 ses->password != NULL &&
2516 strncmp(ses->password,
2517 vol->password ? vol->password : "",
2518 CIFS_MAX_PASSWORD_LEN))
2519 return 0;
2520 }
2521 return 1;
2522 }
2524 /**
2525 * cifs_setup_ipc - helper to setup the IPC tcon for the session
2526 *
2527 * A new IPC connection is made and stored in the session
2528 * tcon_ipc. The IPC tcon has the same lifetime as the session.
2529 */
2530 static int
2531 cifs_setup_ipc(struct cifs_ses *ses, struct smb_vol *volume_info)
2532 {
2533 int rc = 0, xid;
2534 struct cifs_tcon *tcon;
2535 struct nls_table *nls_codepage;
2536 char unc[SERVER_NAME_LENGTH + sizeof("//x/IPC$")] = {0};
2537 bool seal = false;
2539 /*
2540 * If the mount request that resulted in the creation of the
2541 * session requires encryption, force IPC to be encrypted too.
2542 */
2543 if (volume_info->seal) {
2544 if (ses->server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION)
2545 seal = true;
2546 else {
2547 cifs_dbg(VFS,
2548 "IPC: server doesn't support encryption\n");
2549 return -EOPNOTSUPP;
2550 }
2551 }
2553 tcon = tconInfoAlloc();
2554 if (tcon == NULL)
2555 return -ENOMEM;
2557 snprintf(unc, sizeof(unc), "\\\\%s\\IPC$", ses->server->hostname);
2559 /* cannot fail */
2560 nls_codepage = load_nls_default();
2562 xid = get_xid();
2563 tcon->ses = ses;
2564 tcon->ipc = true;
2565 tcon->seal = seal;
2566 rc = ses->server->ops->tree_connect(xid, ses, unc, tcon, nls_codepage);
2567 free_xid(xid);
2569 if (rc) {
2570 cifs_dbg(VFS, "failed to connect to IPC (rc=%d)\n", rc);
2571 tconInfoFree(tcon);
2572 goto out;
2573 }
2575 cifs_dbg(FYI, "IPC tcon rc = %d ipc tid = %d\n", rc, tcon->tid);
2577 ses->tcon_ipc = tcon;
2578 out:
2579 unload_nls(nls_codepage);
2580 return rc;
2581 }
2583 /**
2584 * cifs_free_ipc - helper to release the session IPC tcon
2585 *
2586 * Needs to be called everytime a session is destroyed
2587 */
2588 static int
2589 cifs_free_ipc(struct cifs_ses *ses)
2590 {
2591 int rc = 0, xid;
2592 struct cifs_tcon *tcon = ses->tcon_ipc;
2594 if (tcon == NULL)
2595 return 0;
2597 if (ses->server->ops->tree_disconnect) {
2598 xid = get_xid();
2599 rc = ses->server->ops->tree_disconnect(xid, tcon);
2600 free_xid(xid);
2601 }
2603 if (rc)
2604 cifs_dbg(FYI, "failed to disconnect IPC tcon (rc=%d)\n", rc);
2606 tconInfoFree(tcon);
2607 ses->tcon_ipc = NULL;
2608 return rc;
2609 }
2611 static struct cifs_ses *
2612 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2613 {
2614 struct cifs_ses *ses;
2616 spin_lock(&cifs_tcp_ses_lock);
2617 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2618 if (ses->status == CifsExiting)
2619 continue;
2620 if (!match_session(ses, vol))
2621 continue;
2622 ++ses->ses_count;
2623 spin_unlock(&cifs_tcp_ses_lock);
2624 return ses;
2625 }
2626 spin_unlock(&cifs_tcp_ses_lock);
2627 return NULL;
2628 }
2630 static void
2631 cifs_put_smb_ses(struct cifs_ses *ses)
2632 {
2633 unsigned int rc, xid;
2634 struct TCP_Server_Info *server = ses->server;
2636 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
2638 spin_lock(&cifs_tcp_ses_lock);
2639 if (ses->status == CifsExiting) {
2640 spin_unlock(&cifs_tcp_ses_lock);
2641 return;
2642 }
2643 if (--ses->ses_count > 0) {
2644 spin_unlock(&cifs_tcp_ses_lock);
2645 return;
2646 }
2647 if (ses->status == CifsGood)
2648 ses->status = CifsExiting;
2649 spin_unlock(&cifs_tcp_ses_lock);
2651 cifs_free_ipc(ses);
2653 if (ses->status == CifsExiting && server->ops->logoff) {
2654 xid = get_xid();
2655 rc = server->ops->logoff(xid, ses);
2656 if (rc)
2657 cifs_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
2658 __func__, rc);
2659 _free_xid(xid);
2660 }
2662 spin_lock(&cifs_tcp_ses_lock);
2663 list_del_init(&ses->smb_ses_list);
2664 spin_unlock(&cifs_tcp_ses_lock);
2666 sesInfoFree(ses);
2667 cifs_put_tcp_session(server, 0);
2668 }
2670 #ifdef CONFIG_KEYS
2672 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2673 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2675 /* Populate username and pw fields from keyring if possible */
2676 static int
2677 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2678 {
2679 int rc = 0;
2680 const char *delim, *payload;
2681 char *desc;
2682 ssize_t len;
2683 struct key *key;
2684 struct TCP_Server_Info *server = ses->server;
2685 struct sockaddr_in *sa;
2686 struct sockaddr_in6 *sa6;
2687 const struct user_key_payload *upayload;
2689 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2690 if (!desc)
2691 return -ENOMEM;
2693 /* try to find an address key first */
2694 switch (server->dstaddr.ss_family) {
2695 case AF_INET:
2696 sa = (struct sockaddr_in *)&server->dstaddr;
2697 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2698 break;
2699 case AF_INET6:
2700 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2701 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2702 break;
2703 default:
2704 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2705 server->dstaddr.ss_family);
2706 rc = -EINVAL;
2707 goto out_err;
2708 }
2710 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2711 key = request_key(&key_type_logon, desc, "");
2712 if (IS_ERR(key)) {
2713 if (!ses->domainName) {
2714 cifs_dbg(FYI, "domainName is NULL\n");
2715 rc = PTR_ERR(key);
2716 goto out_err;
2717 }
2719 /* didn't work, try to find a domain key */
2720 sprintf(desc, "cifs:d:%s", ses->domainName);
2721 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2722 key = request_key(&key_type_logon, desc, "");
2723 if (IS_ERR(key)) {
2724 rc = PTR_ERR(key);
2725 goto out_err;
2726 }
2727 }
2729 down_read(&key->sem);
2730 upayload = user_key_payload_locked(key);
2731 if (IS_ERR_OR_NULL(upayload)) {
2732 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2733 goto out_key_put;
2734 }
2736 /* find first : in payload */
2737 payload = upayload->data;
2738 delim = strnchr(payload, upayload->datalen, ':');
2739 cifs_dbg(FYI, "payload=%s\n", payload);
2740 if (!delim) {
2741 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
2742 upayload->datalen);
2743 rc = -EINVAL;
2744 goto out_key_put;
2745 }
2747 len = delim - payload;
2748 if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
2749 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
2750 len);
2751 rc = -EINVAL;
2752 goto out_key_put;
2753 }
2755 vol->username = kstrndup(payload, len, GFP_KERNEL);
2756 if (!vol->username) {
2757 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
2758 len);
2759 rc = -ENOMEM;
2760 goto out_key_put;
2761 }
2762 cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
2764 len = key->datalen - (len + 1);
2765 if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
2766 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
2767 rc = -EINVAL;
2768 kfree(vol->username);
2769 vol->username = NULL;
2770 goto out_key_put;
2771 }
2773 ++delim;
2774 vol->password = kstrndup(delim, len, GFP_KERNEL);
2775 if (!vol->password) {
2776 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
2777 len);
2778 rc = -ENOMEM;
2779 kfree(vol->username);
2780 vol->username = NULL;
2781 goto out_key_put;
2782 }
2784 out_key_put:
2785 up_read(&key->sem);
2786 key_put(key);
2787 out_err:
2788 kfree(desc);
2789 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
2790 return rc;
2791 }
2792 #else /* ! CONFIG_KEYS */
2793 static inline int
2794 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2795 struct cifs_ses *ses __attribute__((unused)))
2796 {
2797 return -ENOSYS;
2798 }
2799 #endif /* CONFIG_KEYS */
2801 /**
2802 * cifs_get_smb_ses - get a session matching @volume_info data from @server
2803 *
2804 * This function assumes it is being called from cifs_mount() where we
2805 * already got a server reference (server refcount +1). See
2806 * cifs_get_tcon() for refcount explanations.
2807 */
2808 static struct cifs_ses *
2809 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2810 {
2811 int rc = -ENOMEM;
2812 unsigned int xid;
2813 struct cifs_ses *ses;
2814 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2815 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2817 xid = get_xid();
2819 ses = cifs_find_smb_ses(server, volume_info);
2820 if (ses) {
2821 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
2822 ses->status);
2824 mutex_lock(&ses->session_mutex);
2825 rc = cifs_negotiate_protocol(xid, ses);
2826 if (rc) {
2827 mutex_unlock(&ses->session_mutex);
2828 /* problem -- put our ses reference */
2829 cifs_put_smb_ses(ses);
2830 free_xid(xid);
2831 return ERR_PTR(rc);
2832 }
2833 if (ses->need_reconnect) {
2834 cifs_dbg(FYI, "Session needs reconnect\n");
2835 rc = cifs_setup_session(xid, ses,
2836 volume_info->local_nls);
2837 if (rc) {
2838 mutex_unlock(&ses->session_mutex);
2839 /* problem -- put our reference */
2840 cifs_put_smb_ses(ses);
2841 free_xid(xid);
2842 return ERR_PTR(rc);
2843 }
2844 }
2845 mutex_unlock(&ses->session_mutex);
2847 /* existing SMB ses has a server reference already */
2848 cifs_put_tcp_session(server, 0);
2849 free_xid(xid);
2850 return ses;
2851 }
2853 cifs_dbg(FYI, "Existing smb sess not found\n");
2854 ses = sesInfoAlloc();
2855 if (ses == NULL)
2856 goto get_ses_fail;
2858 /* new SMB session uses our server ref */
2859 ses->server = server;
2860 if (server->dstaddr.ss_family == AF_INET6)
2861 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2862 else
2863 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2865 if (volume_info->username) {
2866 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2867 if (!ses->user_name)
2868 goto get_ses_fail;
2869 }
2871 /* volume_info->password freed at unmount */
2872 if (volume_info->password) {
2873 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2874 if (!ses->password)
2875 goto get_ses_fail;
2876 }
2877 if (volume_info->domainname) {
2878 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2879 if (!ses->domainName)
2880 goto get_ses_fail;
2881 }
2882 if (volume_info->domainauto)
2883 ses->domainAuto = volume_info->domainauto;
2884 ses->cred_uid = volume_info->cred_uid;
2885 ses->linux_uid = volume_info->linux_uid;
2887 ses->sectype = volume_info->sectype;
2888 ses->sign = volume_info->sign;
2890 mutex_lock(&ses->session_mutex);
2891 rc = cifs_negotiate_protocol(xid, ses);
2892 if (!rc)
2893 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2894 mutex_unlock(&ses->session_mutex);
2895 if (rc)
2896 goto get_ses_fail;
2898 /* success, put it on the list */
2899 spin_lock(&cifs_tcp_ses_lock);
2900 list_add(&ses->smb_ses_list, &server->smb_ses_list);
2901 spin_unlock(&cifs_tcp_ses_lock);
2903 free_xid(xid);
2905 cifs_setup_ipc(ses, volume_info);
2907 return ses;
2909 get_ses_fail:
2910 sesInfoFree(ses);
2911 free_xid(xid);
2912 return ERR_PTR(rc);
2913 }
2915 static int match_tcon(struct cifs_tcon *tcon, struct smb_vol *volume_info)
2916 {
2917 if (tcon->tidStatus == CifsExiting)
2918 return 0;
2919 if (strncmp(tcon->treeName, volume_info->UNC, MAX_TREE_SIZE))
2920 return 0;
2921 if (tcon->seal != volume_info->seal)
2922 return 0;
2923 if (tcon->snapshot_time != volume_info->snapshot_time)
2924 return 0;
2925 return 1;
2926 }
2928 static struct cifs_tcon *
2929 cifs_find_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2930 {
2931 struct list_head *tmp;
2932 struct cifs_tcon *tcon;
2934 spin_lock(&cifs_tcp_ses_lock);
2935 list_for_each(tmp, &ses->tcon_list) {
2936 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2937 if (!match_tcon(tcon, volume_info))
2938 continue;
2939 ++tcon->tc_count;
2940 spin_unlock(&cifs_tcp_ses_lock);
2941 return tcon;
2942 }
2943 spin_unlock(&cifs_tcp_ses_lock);
2944 return NULL;
2945 }
2947 void
2948 cifs_put_tcon(struct cifs_tcon *tcon)
2949 {
2950 unsigned int xid;
2951 struct cifs_ses *ses;
2953 /*
2954 * IPC tcon share the lifetime of their session and are
2955 * destroyed in the session put function
2956 */
2957 if (tcon == NULL || tcon->ipc)
2958 return;
2960 ses = tcon->ses;
2961 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2962 spin_lock(&cifs_tcp_ses_lock);
2963 if (--tcon->tc_count > 0) {
2964 spin_unlock(&cifs_tcp_ses_lock);
2965 return;
2966 }
2968 list_del_init(&tcon->tcon_list);
2969 spin_unlock(&cifs_tcp_ses_lock);
2971 xid = get_xid();
2972 if (ses->server->ops->tree_disconnect)
2973 ses->server->ops->tree_disconnect(xid, tcon);
2974 _free_xid(xid);
2976 cifs_fscache_release_super_cookie(tcon);
2977 tconInfoFree(tcon);
2978 cifs_put_smb_ses(ses);
2979 }
2981 /**
2982 * cifs_get_tcon - get a tcon matching @volume_info data from @ses
2983 *
2984 * - tcon refcount is the number of mount points using the tcon.
2985 * - ses refcount is the number of tcon using the session.
2986 *
2987 * 1. This function assumes it is being called from cifs_mount() where
2988 * we already got a session reference (ses refcount +1).
2989 *
2990 * 2. Since we're in the context of adding a mount point, the end
2991 * result should be either:
2992 *
2993 * a) a new tcon already allocated with refcount=1 (1 mount point) and
2994 * its session refcount incremented (1 new tcon). This +1 was
2995 * already done in (1).
2996 *
2997 * b) an existing tcon with refcount+1 (add a mount point to it) and
2998 * identical ses refcount (no new tcon). Because of (1) we need to
2999 * decrement the ses refcount.
3000 */
3001 static struct cifs_tcon *
3002 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
3003 {
3004 int rc, xid;
3005 struct cifs_tcon *tcon;
3007 tcon = cifs_find_tcon(ses, volume_info);
3008 if (tcon) {
3009 /*
3010 * tcon has refcount already incremented but we need to
3011 * decrement extra ses reference gotten by caller (case b)
3012 */
3013 cifs_dbg(FYI, "Found match on UNC path\n");
3014 cifs_put_smb_ses(ses);
3015 return tcon;
3016 }
3018 if (!ses->server->ops->tree_connect) {
3019 rc = -ENOSYS;
3020 goto out_fail;
3021 }
3023 tcon = tconInfoAlloc();
3024 if (tcon == NULL) {
3025 rc = -ENOMEM;
3026 goto out_fail;
3027 }
3029 if (volume_info->snapshot_time) {
3030 if (ses->server->vals->protocol_id == 0) {
3031 cifs_dbg(VFS,
3032 "Use SMB2 or later for snapshot mount option\n");
3033 rc = -EOPNOTSUPP;
3034 goto out_fail;
3035 } else
3036 tcon->snapshot_time = volume_info->snapshot_time;
3037 }
3039 tcon->ses = ses;
3040 if (volume_info->password) {
3041 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
3042 if (!tcon->password) {
3043 rc = -ENOMEM;
3044 goto out_fail;
3045 }
3046 }
3048 if (volume_info->seal) {
3049 if (ses->server->vals->protocol_id == 0) {
3050 cifs_dbg(VFS,
3051 "SMB3 or later required for encryption\n");
3052 rc = -EOPNOTSUPP;
3053 goto out_fail;
3054 } else if (tcon->ses->server->capabilities &
3055 SMB2_GLOBAL_CAP_ENCRYPTION)
3056 tcon->seal = true;
3057 else {
3058 cifs_dbg(VFS, "Encryption is not supported on share\n");
3059 rc = -EOPNOTSUPP;
3060 goto out_fail;
3061 }
3062 }
3064 if (volume_info->linux_ext) {
3065 if (ses->server->posix_ext_supported) {
3066 tcon->posix_extensions = true;
3067 printk_once(KERN_WARNING
3068 "SMB3.11 POSIX Extensions are experimental\n");
3069 } else {
3070 cifs_dbg(VFS, "Server does not support mounting with posix SMB3.11 extensions.\n");
3071 rc = -EOPNOTSUPP;
3072 goto out_fail;
3073 }
3074 }
3076 /*
3077 * BB Do we need to wrap session_mutex around this TCon call and Unix
3078 * SetFS as we do on SessSetup and reconnect?
3079 */
3080 xid = get_xid();
3081 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
3082 volume_info->local_nls);
3083 free_xid(xid);
3084 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
3085 if (rc)
3086 goto out_fail;
3088 if (volume_info->nodfs) {
3089 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
3090 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
3091 }
3092 tcon->use_persistent = false;
3093 /* check if SMB2 or later, CIFS does not support persistent handles */
3094 if (volume_info->persistent) {
3095 if (ses->server->vals->protocol_id == 0) {
3096 cifs_dbg(VFS,
3097 "SMB3 or later required for persistent handles\n");
3098 rc = -EOPNOTSUPP;
3099 goto out_fail;
3100 } else if (ses->server->capabilities &
3101 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
3102 tcon->use_persistent = true;
3103 else /* persistent handles requested but not supported */ {
3104 cifs_dbg(VFS,
3105 "Persistent handles not supported on share\n");
3106 rc = -EOPNOTSUPP;
3107 goto out_fail;
3108 }
3109 } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
3110 && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
3111 && (volume_info->nopersistent == false)) {
3112 cifs_dbg(FYI, "enabling persistent handles\n");
3113 tcon->use_persistent = true;
3114 } else if (volume_info->resilient) {
3115 if (ses->server->vals->protocol_id == 0) {
3116 cifs_dbg(VFS,
3117 "SMB2.1 or later required for resilient handles\n");
3118 rc = -EOPNOTSUPP;
3119 goto out_fail;
3120 }
3121 tcon->use_resilient = true;
3122 }
3124 /*
3125 * We can have only one retry value for a connection to a share so for
3126 * resources mounted more than once to the same server share the last
3127 * value passed in for the retry flag is used.
3128 */
3129 tcon->retry = volume_info->retry;
3130 tcon->nocase = volume_info->nocase;
3131 tcon->nohandlecache = volume_info->nohandlecache;
3132 tcon->local_lease = volume_info->local_lease;
3133 INIT_LIST_HEAD(&tcon->pending_opens);
3135 spin_lock(&cifs_tcp_ses_lock);
3136 list_add(&tcon->tcon_list, &ses->tcon_list);
3137 spin_unlock(&cifs_tcp_ses_lock);
3139 cifs_fscache_get_super_cookie(tcon);
3141 return tcon;
3143 out_fail:
3144 tconInfoFree(tcon);
3145 return ERR_PTR(rc);
3146 }
3148 void
3149 cifs_put_tlink(struct tcon_link *tlink)
3150 {
3151 if (!tlink || IS_ERR(tlink))
3152 return;
3154 if (!atomic_dec_and_test(&tlink->tl_count) ||
3155 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
3156 tlink->tl_time = jiffies;
3157 return;
3158 }
3160 if (!IS_ERR(tlink_tcon(tlink)))
3161 cifs_put_tcon(tlink_tcon(tlink));
3162 kfree(tlink);
3163 return;
3164 }
3166 static int
3167 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
3168 {
3169 struct cifs_sb_info *old = CIFS_SB(sb);
3170 struct cifs_sb_info *new = mnt_data->cifs_sb;
3172 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
3173 return 0;
3175 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
3176 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
3177 return 0;
3179 /*
3180 * We want to share sb only if we don't specify an r/wsize or
3181 * specified r/wsize is greater than or equal to existing one.
3182 */
3183 if (new->wsize && new->wsize < old->wsize)
3184 return 0;
3186 if (new->rsize && new->rsize < old->rsize)
3187 return 0;
3189 if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
3190 return 0;
3192 if (old->mnt_file_mode != new->mnt_file_mode ||
3193 old->mnt_dir_mode != new->mnt_dir_mode)
3194 return 0;
3196 if (strcmp(old->local_nls->charset, new->local_nls->charset))
3197 return 0;
3199 if (old->actimeo != new->actimeo)
3200 return 0;
3202 return 1;
3203 }
3205 static int
3206 match_prepath(struct super_block *sb, struct cifs_mnt_data *mnt_data)
3207 {
3208 struct cifs_sb_info *old = CIFS_SB(sb);
3209 struct cifs_sb_info *new = mnt_data->cifs_sb;
3210 bool old_set = old->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH;
3211 bool new_set = new->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH;
3213 if (old_set && new_set && !strcmp(new->prepath, old->prepath))
3214 return 1;
3215 else if (!old_set && !new_set)
3216 return 1;
3218 return 0;
3219 }
3221 int
3222 cifs_match_super(struct super_block *sb, void *data)
3223 {
3224 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
3225 struct smb_vol *volume_info;
3226 struct cifs_sb_info *cifs_sb;
3227 struct TCP_Server_Info *tcp_srv;
3228 struct cifs_ses *ses;
3229 struct cifs_tcon *tcon;
3230 struct tcon_link *tlink;
3231 int rc = 0;
3233 spin_lock(&cifs_tcp_ses_lock);
3234 cifs_sb = CIFS_SB(sb);
3235 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3236 if (IS_ERR(tlink)) {
3237 spin_unlock(&cifs_tcp_ses_lock);
3238 return rc;
3239 }
3240 tcon = tlink_tcon(tlink);
3241 ses = tcon->ses;
3242 tcp_srv = ses->server;
3244 volume_info = mnt_data->vol;
3246 if (!match_server(tcp_srv, volume_info) ||
3247 !match_session(ses, volume_info) ||
3248 !match_tcon(tcon, volume_info) ||
3249 !match_prepath(sb, mnt_data)) {
3250 rc = 0;
3251 goto out;
3252 }
3254 rc = compare_mount_options(sb, mnt_data);
3255 out:
3256 spin_unlock(&cifs_tcp_ses_lock);
3257 cifs_put_tlink(tlink);
3258 return rc;
3259 }
3261 int
3262 get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
3263 const struct nls_table *nls_codepage, unsigned int *num_referrals,
3264 struct dfs_info3_param **referrals, int remap)
3265 {
3266 int rc = 0;
3268 if (!ses->server->ops->get_dfs_refer)
3269 return -ENOSYS;
3271 *num_referrals = 0;
3272 *referrals = NULL;
3274 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
3275 referrals, num_referrals,
3276 nls_codepage, remap);
3277 return rc;
3278 }
3280 #ifdef CONFIG_DEBUG_LOCK_ALLOC
3281 static struct lock_class_key cifs_key[2];
3282 static struct lock_class_key cifs_slock_key[2];
3284 static inline void
3285 cifs_reclassify_socket4(struct socket *sock)
3286 {
3287 struct sock *sk = sock->sk;
3288 BUG_ON(!sock_allow_reclassification(sk));
3289 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
3290 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
3291 }
3293 static inline void
3294 cifs_reclassify_socket6(struct socket *sock)
3295 {
3296 struct sock *sk = sock->sk;
3297 BUG_ON(!sock_allow_reclassification(sk));
3298 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
3299 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
3300 }
3301 #else
3302 static inline void
3303 cifs_reclassify_socket4(struct socket *sock)
3304 {
3305 }
3307 static inline void
3308 cifs_reclassify_socket6(struct socket *sock)
3309 {
3310 }
3311 #endif
3313 /* See RFC1001 section 14 on representation of Netbios names */
3314 static void rfc1002mangle(char *target, char *source, unsigned int length)
3315 {
3316 unsigned int i, j;
3318 for (i = 0, j = 0; i < (length); i++) {
3319 /* mask a nibble at a time and encode */
3320 target[j] = 'A' + (0x0F & (source[i] >> 4));
3321 target[j+1] = 'A' + (0x0F & source[i]);
3322 j += 2;
3323 }
3325 }
3327 static int
3328 bind_socket(struct TCP_Server_Info *server)
3329 {
3330 int rc = 0;
3331 if (server->srcaddr.ss_family != AF_UNSPEC) {
3332 /* Bind to the specified local IP address */
3333 struct socket *socket = server->ssocket;
3334 rc = socket->ops->bind(socket,
3335 (struct sockaddr *) &server->srcaddr,
3336 sizeof(server->srcaddr));
3337 if (rc < 0) {
3338 struct sockaddr_in *saddr4;
3339 struct sockaddr_in6 *saddr6;
3340 saddr4 = (struct sockaddr_in *)&server->srcaddr;
3341 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
3342 if (saddr6->sin6_family == AF_INET6)
3343 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
3344 &saddr6->sin6_addr, rc);
3345 else
3346 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
3347 &saddr4->sin_addr.s_addr, rc);
3348 }
3349 }
3350 return rc;
3351 }
3353 static int
3354 ip_rfc1001_connect(struct TCP_Server_Info *server)
3355 {
3356 int rc = 0;
3357 /*
3358 * some servers require RFC1001 sessinit before sending
3359 * negprot - BB check reconnection in case where second
3360 * sessinit is sent but no second negprot
3361 */
3362 struct rfc1002_session_packet *ses_init_buf;
3363 struct smb_hdr *smb_buf;
3364 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
3365 GFP_KERNEL);
3366 if (ses_init_buf) {
3367 ses_init_buf->trailer.session_req.called_len = 32;
3369 if (server->server_RFC1001_name[0] != 0)
3370 rfc1002mangle(ses_init_buf->trailer.
3371 session_req.called_name,
3372 server->server_RFC1001_name,
3373 RFC1001_NAME_LEN_WITH_NULL);
3374 else
3375 rfc1002mangle(ses_init_buf->trailer.
3376 session_req.called_name,
3377 DEFAULT_CIFS_CALLED_NAME,
3378 RFC1001_NAME_LEN_WITH_NULL);
3380 ses_init_buf->trailer.session_req.calling_len = 32;
3382 /*
3383 * calling name ends in null (byte 16) from old smb
3384 * convention.
3385 */
3386 if (server->workstation_RFC1001_name[0] != 0)
3387 rfc1002mangle(ses_init_buf->trailer.
3388 session_req.calling_name,
3389 server->workstation_RFC1001_name,
3390 RFC1001_NAME_LEN_WITH_NULL);
3391 else
3392 rfc1002mangle(ses_init_buf->trailer.
3393 session_req.calling_name,
3394 "LINUX_CIFS_CLNT",
3395 RFC1001_NAME_LEN_WITH_NULL);
3397 ses_init_buf->trailer.session_req.scope1 = 0;
3398 ses_init_buf->trailer.session_req.scope2 = 0;
3399 smb_buf = (struct smb_hdr *)ses_init_buf;
3401 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3402 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3403 rc = smb_send(server, smb_buf, 0x44);
3404 kfree(ses_init_buf);
3405 /*
3406 * RFC1001 layer in at least one server
3407 * requires very short break before negprot
3408 * presumably because not expecting negprot
3409 * to follow so fast. This is a simple
3410 * solution that works without
3411 * complicating the code and causes no
3412 * significant slowing down on mount
3413 * for everyone else
3414 */
3415 usleep_range(1000, 2000);
3416 }
3417 /*
3418 * else the negprot may still work without this
3419 * even though malloc failed
3420 */
3422 return rc;
3423 }
3425 static int
3426 generic_ip_connect(struct TCP_Server_Info *server)
3427 {
3428 int rc = 0;
3429 __be16 sport;
3430 int slen, sfamily;
3431 struct socket *socket = server->ssocket;
3432 struct sockaddr *saddr;
3434 saddr = (struct sockaddr *) &server->dstaddr;
3436 if (server->dstaddr.ss_family == AF_INET6) {
3437 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3438 slen = sizeof(struct sockaddr_in6);
3439 sfamily = AF_INET6;
3440 } else {
3441 sport = ((struct sockaddr_in *) saddr)->sin_port;
3442 slen = sizeof(struct sockaddr_in);
3443 sfamily = AF_INET;
3444 }
3446 if (socket == NULL) {
3447 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3448 IPPROTO_TCP, &socket, 1);
3449 if (rc < 0) {
3450 cifs_dbg(VFS, "Error %d creating socket\n", rc);
3451 server->ssocket = NULL;
3452 return rc;
3453 }
3455 /* BB other socket options to set KEEPALIVE, NODELAY? */
3456 cifs_dbg(FYI, "Socket created\n");
3457 server->ssocket = socket;
3458 socket->sk->sk_allocation = GFP_NOFS;
3459 if (sfamily == AF_INET6)
3460 cifs_reclassify_socket6(socket);
3461 else
3462 cifs_reclassify_socket4(socket);
3463 }
3465 rc = bind_socket(server);
3466 if (rc < 0)
3467 return rc;
3469 /*
3470 * Eventually check for other socket options to change from
3471 * the default. sock_setsockopt not used because it expects
3472 * user space buffer
3473 */
3474 socket->sk->sk_rcvtimeo = 7 * HZ;
3475 socket->sk->sk_sndtimeo = 5 * HZ;
3477 /* make the bufsizes depend on wsize/rsize and max requests */
3478 if (server->noautotune) {
3479 if (socket->sk->sk_sndbuf < (200 * 1024))
3480 socket->sk->sk_sndbuf = 200 * 1024;
3481 if (socket->sk->sk_rcvbuf < (140 * 1024))
3482 socket->sk->sk_rcvbuf = 140 * 1024;
3483 }
3485 if (server->tcp_nodelay) {
3486 int val = 1;
3487 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3488 (char *)&val, sizeof(val));
3489 if (rc)
3490 cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3491 rc);
3492 }
3494 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3495 socket->sk->sk_sndbuf,
3496 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3498 rc = socket->ops->connect(socket, saddr, slen, 0);
3499 if (rc < 0) {
3500 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3501 sock_release(socket);
3502 server->ssocket = NULL;
3503 return rc;
3504 }
3506 if (sport == htons(RFC1001_PORT))
3507 rc = ip_rfc1001_connect(server);
3509 return rc;
3510 }
3512 static int
3513 ip_connect(struct TCP_Server_Info *server)
3514 {
3515 __be16 *sport;
3516 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3517 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3519 if (server->dstaddr.ss_family == AF_INET6)
3520 sport = &addr6->sin6_port;
3521 else
3522 sport = &addr->sin_port;
3524 if (*sport == 0) {
3525 int rc;
3527 /* try with 445 port at first */
3528 *sport = htons(CIFS_PORT);
3530 rc = generic_ip_connect(server);
3531 if (rc >= 0)
3532 return rc;
3534 /* if it failed, try with 139 port */
3535 *sport = htons(RFC1001_PORT);
3536 }
3538 return generic_ip_connect(server);
3539 }
3541 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3542 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3543 {
3544 /* if we are reconnecting then should we check to see if
3545 * any requested capabilities changed locally e.g. via
3546 * remount but we can not do much about it here
3547 * if they have (even if we could detect it by the following)
3548 * Perhaps we could add a backpointer to array of sb from tcon
3549 * or if we change to make all sb to same share the same
3550 * sb as NFS - then we only have one backpointer to sb.
3551 * What if we wanted to mount the server share twice once with
3552 * and once without posixacls or posix paths? */
3553 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3555 if (vol_info && vol_info->no_linux_ext) {
3556 tcon->fsUnixInfo.Capability = 0;
3557 tcon->unix_ext = 0; /* Unix Extensions disabled */
3558 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
3559 return;
3560 } else if (vol_info)
3561 tcon->unix_ext = 1; /* Unix Extensions supported */
3563 if (tcon->unix_ext == 0) {
3564 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
3565 return;
3566 }
3568 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3569 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3570 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
3571 /* check for reconnect case in which we do not
3572 want to change the mount behavior if we can avoid it */
3573 if (vol_info == NULL) {
3574 /* turn off POSIX ACL and PATHNAMES if not set
3575 originally at mount time */
3576 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3577 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3578 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3579 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3580 cifs_dbg(VFS, "POSIXPATH support change\n");
3581 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3582 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3583 cifs_dbg(VFS, "possible reconnect error\n");
3584 cifs_dbg(VFS, "server disabled POSIX path support\n");
3585 }
3586 }
3588 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3589 cifs_dbg(VFS, "per-share encryption not supported yet\n");
3591 cap &= CIFS_UNIX_CAP_MASK;
3592 if (vol_info && vol_info->no_psx_acl)
3593 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3594 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3595 cifs_dbg(FYI, "negotiated posix acl support\n");
3596 if (cifs_sb)
3597 cifs_sb->mnt_cifs_flags |=
3598 CIFS_MOUNT_POSIXACL;
3599 }
3601 if (vol_info && vol_info->posix_paths == 0)
3602 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3603 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3604 cifs_dbg(FYI, "negotiate posix pathnames\n");
3605 if (cifs_sb)
3606 cifs_sb->mnt_cifs_flags |=
3607 CIFS_MOUNT_POSIX_PATHS;
3608 }
3610 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
3611 #ifdef CONFIG_CIFS_DEBUG2
3612 if (cap & CIFS_UNIX_FCNTL_CAP)
3613 cifs_dbg(FYI, "FCNTL cap\n");
3614 if (cap & CIFS_UNIX_EXTATTR_CAP)
3615 cifs_dbg(FYI, "EXTATTR cap\n");
3616 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3617 cifs_dbg(FYI, "POSIX path cap\n");
3618 if (cap & CIFS_UNIX_XATTR_CAP)
3619 cifs_dbg(FYI, "XATTR cap\n");
3620 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3621 cifs_dbg(FYI, "POSIX ACL cap\n");
3622 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3623 cifs_dbg(FYI, "very large read cap\n");
3624 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3625 cifs_dbg(FYI, "very large write cap\n");
3626 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3627 cifs_dbg(FYI, "transport encryption cap\n");
3628 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3629 cifs_dbg(FYI, "mandatory transport encryption cap\n");
3630 #endif /* CIFS_DEBUG2 */
3631 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3632 if (vol_info == NULL) {
3633 cifs_dbg(FYI, "resetting capabilities failed\n");
3634 } else
3635 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");
3637 }
3638 }
3639 }
3641 int cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3642 struct cifs_sb_info *cifs_sb)
3643 {
3644 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3646 spin_lock_init(&cifs_sb->tlink_tree_lock);
3647 cifs_sb->tlink_tree = RB_ROOT;
3649 /*
3650 * Temporarily set r/wsize for matching superblock. If we end up using
3651 * new sb then client will later negotiate it downward if needed.
3652 */
3653 cifs_sb->rsize = pvolume_info->rsize;
3654 cifs_sb->wsize = pvolume_info->wsize;
3656 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3657 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3658 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3659 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3660 cifs_dbg(FYI, "file mode: 0x%hx dir mode: 0x%hx\n",
3661 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3663 cifs_sb->actimeo = pvolume_info->actimeo;
3664 cifs_sb->local_nls = pvolume_info->local_nls;
3666 if (pvolume_info->noperm)
3667 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3668 if (pvolume_info->setuids)
3669 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3670 if (pvolume_info->setuidfromacl)
3671 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
3672 if (pvolume_info->server_ino)
3673 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3674 if (pvolume_info->remap)
3675 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3676 if (pvolume_info->sfu_remap)
3677 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3678 if (pvolume_info->no_xattr)
3679 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3680 if (pvolume_info->sfu_emul)
3681 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3682 if (pvolume_info->nobrl)
3683 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3684 if (pvolume_info->nohandlecache)
3685 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_HANDLE_CACHE;
3686 if (pvolume_info->nostrictsync)
3687 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3688 if (pvolume_info->mand_lock)
3689 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3690 if (pvolume_info->rwpidforward)
3691 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3692 if (pvolume_info->cifs_acl)
3693 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3694 if (pvolume_info->backupuid_specified) {
3695 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3696 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3697 }
3698 if (pvolume_info->backupgid_specified) {
3699 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3700 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3701 }
3702 if (pvolume_info->override_uid)
3703 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3704 if (pvolume_info->override_gid)
3705 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3706 if (pvolume_info->dynperm)
3707 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3708 if (pvolume_info->fsc)
3709 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3710 if (pvolume_info->multiuser)
3711 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3712 CIFS_MOUNT_NO_PERM);
3713 if (pvolume_info->strict_io)
3714 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3715 if (pvolume_info->direct_io) {
3716 cifs_dbg(FYI, "mounting share using direct i/o\n");
3717 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3718 }
3719 if (pvolume_info->mfsymlinks) {
3720 if (pvolume_info->sfu_emul) {
3721 /*
3722 * Our SFU ("Services for Unix" emulation does not allow
3723 * creating symlinks but does allow reading existing SFU
3724 * symlinks (it does allow both creating and reading SFU
3725 * style mknod and FIFOs though). When "mfsymlinks" and
3726 * "sfu" are both enabled at the same time, it allows
3727 * reading both types of symlinks, but will only create
3728 * them with mfsymlinks format. This allows better
3729 * Apple compatibility (probably better for Samba too)
3730 * while still recognizing old Windows style symlinks.
3731 */
3732 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
3733 }
3734 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3735 }
3737 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3738 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
3740 if (pvolume_info->prepath) {
3741 cifs_sb->prepath = kstrdup(pvolume_info->prepath, GFP_KERNEL);
3742 if (cifs_sb->prepath == NULL)
3743 return -ENOMEM;
3744 }
3746 return 0;
3747 }
3749 static void
3750 cleanup_volume_info_contents(struct smb_vol *volume_info)
3751 {
3752 kfree(volume_info->username);
3753 kzfree(volume_info->password);
3754 kfree(volume_info->UNC);
3755 kfree(volume_info->domainname);
3756 kfree(volume_info->iocharset);
3757 kfree(volume_info->prepath);
3758 }
3760 void
3761 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3762 {
3763 if (!volume_info)
3764 return;
3765 cleanup_volume_info_contents(volume_info);
3766 kfree(volume_info);
3767 }
3770 #ifdef CONFIG_CIFS_DFS_UPCALL
3771 /*
3772 * cifs_build_path_to_root returns full path to root when we do not have an
3773 * exiting connection (tcon)
3774 */
3775 static char *
3776 build_unc_path_to_root(const struct smb_vol *vol,
3777 const struct cifs_sb_info *cifs_sb)
3778 {
3779 char *full_path, *pos;
3780 unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
3781 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3783 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3784 if (full_path == NULL)
3785 return ERR_PTR(-ENOMEM);
3787 strncpy(full_path, vol->UNC, unc_len);
3788 pos = full_path + unc_len;
3790 if (pplen) {
3791 *pos = CIFS_DIR_SEP(cifs_sb);
3792 strncpy(pos + 1, vol->prepath, pplen);
3793 pos += pplen;
3794 }
3796 *pos = '\0'; /* add trailing null */
3797 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3798 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
3799 return full_path;
3800 }
3802 /*
3803 * Perform a dfs referral query for a share and (optionally) prefix
3804 *
3805 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3806 * to a string containing updated options for the submount. Otherwise it
3807 * will be left untouched.
3808 *
3809 * Returns the rc from get_dfs_path to the caller, which can be used to
3810 * determine whether there were referrals.
3811 */
3812 static int
3813 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
3814 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3815 int check_prefix)
3816 {
3817 int rc;
3818 unsigned int num_referrals = 0;
3819 struct dfs_info3_param *referrals = NULL;
3820 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3822 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3823 if (IS_ERR(full_path))
3824 return PTR_ERR(full_path);
3826 /* For DFS paths, skip the first '\' of the UNC */
3827 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3829 rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
3830 &num_referrals, &referrals, cifs_remap(cifs_sb));
3832 if (!rc && num_referrals > 0) {
3833 char *fake_devname = NULL;
3835 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3836 full_path + 1, referrals,
3837 &fake_devname);
3839 free_dfs_info_array(referrals, num_referrals);
3841 if (IS_ERR(mdata)) {
3842 rc = PTR_ERR(mdata);
3843 mdata = NULL;
3844 } else {
3845 cleanup_volume_info_contents(volume_info);
3846 rc = cifs_setup_volume_info(volume_info, mdata,
3847 fake_devname, false);
3848 }
3849 kfree(fake_devname);
3850 kfree(cifs_sb->mountdata);
3851 cifs_sb->mountdata = mdata;
3852 }
3853 kfree(full_path);
3854 return rc;
3855 }
3856 #endif
3858 static int
3859 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3860 const char *devname, bool is_smb3)
3861 {
3862 int rc = 0;
3864 if (cifs_parse_mount_options(mount_data, devname, volume_info, is_smb3))
3865 return -EINVAL;
3867 if (volume_info->nullauth) {
3868 cifs_dbg(FYI, "Anonymous login\n");
3869 kfree(volume_info->username);
3870 volume_info->username = NULL;
3871 } else if (volume_info->username) {
3872 /* BB fixme parse for domain name here */
3873 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
3874 } else {
3875 cifs_dbg(VFS, "No username specified\n");
3876 /* In userspace mount helper we can get user name from alternate
3877 locations such as env variables and files on disk */
3878 return -EINVAL;
3879 }
3881 /* this is needed for ASCII cp to Unicode converts */
3882 if (volume_info->iocharset == NULL) {
3883 /* load_nls_default cannot return null */
3884 volume_info->local_nls = load_nls_default();
3885 } else {
3886 volume_info->local_nls = load_nls(volume_info->iocharset);
3887 if (volume_info->local_nls == NULL) {
3888 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
3889 volume_info->iocharset);
3890 return -ELIBACC;
3891 }
3892 }
3894 return rc;
3895 }
3897 struct smb_vol *
3898 cifs_get_volume_info(char *mount_data, const char *devname, bool is_smb3)
3899 {
3900 int rc;
3901 struct smb_vol *volume_info;
3903 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
3904 if (!volume_info)
3905 return ERR_PTR(-ENOMEM);
3907 rc = cifs_setup_volume_info(volume_info, mount_data, devname, is_smb3);
3908 if (rc) {
3909 cifs_cleanup_volume_info(volume_info);
3910 volume_info = ERR_PTR(rc);
3911 }
3913 return volume_info;
3914 }
3916 static int
3917 cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
3918 unsigned int xid,
3919 struct cifs_tcon *tcon,
3920 struct cifs_sb_info *cifs_sb,
3921 char *full_path)
3922 {
3923 int rc;
3924 char *s;
3925 char sep, tmp;
3927 sep = CIFS_DIR_SEP(cifs_sb);
3928 s = full_path;
3930 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
3931 while (rc == 0) {
3932 /* skip separators */
3933 while (*s == sep)
3934 s++;
3935 if (!*s)
3936 break;
3937 /* next separator */
3938 while (*s && *s != sep)
3939 s++;
3941 /*
3942 * temporarily null-terminate the path at the end of
3943 * the current component
3944 */
3945 tmp = *s;
3946 *s = 0;
3947 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3948 full_path);
3949 *s = tmp;
3950 }
3951 return rc;
3952 }
3954 int
3955 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3956 {
3957 int rc;
3958 unsigned int xid;
3959 struct cifs_ses *ses;
3960 struct cifs_tcon *tcon;
3961 struct TCP_Server_Info *server;
3962 char *full_path;
3963 struct tcon_link *tlink;
3964 #ifdef CONFIG_CIFS_DFS_UPCALL
3965 int referral_walks_count = 0;
3966 #endif
3968 #ifdef CONFIG_CIFS_DFS_UPCALL
3969 try_mount_again:
3970 /* cleanup activities if we're chasing a referral */
3971 if (referral_walks_count) {
3972 if (tcon)
3973 cifs_put_tcon(tcon);
3974 else if (ses)
3975 cifs_put_smb_ses(ses);
3977 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
3979 free_xid(xid);
3980 }
3981 #endif
3982 rc = 0;
3983 tcon = NULL;
3984 ses = NULL;
3985 server = NULL;
3986 full_path = NULL;
3987 tlink = NULL;
3989 xid = get_xid();
3991 /* get a reference to a tcp session */
3992 server = cifs_get_tcp_session(volume_info);
3993 if (IS_ERR(server)) {
3994 rc = PTR_ERR(server);
3995 goto out;
3996 }
3997 if ((volume_info->max_credits < 20) ||
3998 (volume_info->max_credits > 60000))
3999 server->max_credits = SMB2_MAX_CREDITS_AVAILABLE;
4000 else
4001 server->max_credits = volume_info->max_credits;
4002 /* get a reference to a SMB session */
4003 ses = cifs_get_smb_ses(server, volume_info);
4004 if (IS_ERR(ses)) {
4005 rc = PTR_ERR(ses);
4006 ses = NULL;
4007 goto mount_fail_check;
4008 }
4010 if ((volume_info->persistent == true) && ((ses->server->capabilities &
4011 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES) == 0)) {
4012 cifs_dbg(VFS, "persistent handles not supported by server\n");
4013 rc = -EOPNOTSUPP;
4014 goto mount_fail_check;
4015 }
4017 /* search for existing tcon to this server share */
4018 tcon = cifs_get_tcon(ses, volume_info);
4019 if (IS_ERR(tcon)) {
4020 rc = PTR_ERR(tcon);
4021 tcon = NULL;
4022 if (rc == -EACCES)
4023 goto mount_fail_check;
4025 goto remote_path_check;
4026 }
4028 /* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
4029 if (tcon->posix_extensions)
4030 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_POSIX_PATHS;
4032 /* tell server which Unix caps we support */
4033 if (cap_unix(tcon->ses)) {
4034 /* reset of caps checks mount to see if unix extensions
4035 disabled for just this mount */
4036 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
4037 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
4038 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
4039 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
4040 rc = -EACCES;
4041 goto mount_fail_check;
4042 }
4043 } else
4044 tcon->unix_ext = 0; /* server does not support them */
4046 /* do not care if a following call succeed - informational */
4047 if (!tcon->pipe && server->ops->qfs_tcon)
4048 server->ops->qfs_tcon(xid, tcon);
4050 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
4051 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
4053 remote_path_check:
4054 #ifdef CONFIG_CIFS_DFS_UPCALL
4055 /*
4056 * Perform an unconditional check for whether there are DFS
4057 * referrals for this path without prefix, to provide support
4058 * for DFS referrals from w2k8 servers which don't seem to respond
4059 * with PATH_NOT_COVERED to requests that include the prefix.
4060 * Chase the referral if found, otherwise continue normally.
4061 */
4062 if (referral_walks_count == 0) {
4063 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
4064 false);
4065 if (!refrc) {
4066 referral_walks_count++;
4067 goto try_mount_again;
4068 }
4069 }
4070 #endif
4072 /* check if a whole path is not remote */
4073 if (!rc && tcon) {
4074 if (!server->ops->is_path_accessible) {
4075 rc = -ENOSYS;
4076 goto mount_fail_check;
4077 }
4078 /*
4079 * cifs_build_path_to_root works only when we have a valid tcon
4080 */
4081 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon,
4082 tcon->Flags & SMB_SHARE_IS_IN_DFS);
4083 if (full_path == NULL) {
4084 rc = -ENOMEM;
4085 goto mount_fail_check;
4086 }
4087 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
4088 full_path);
4089 if (rc != 0 && rc != -EREMOTE) {
4090 kfree(full_path);
4091 goto mount_fail_check;
4092 }
4094 if (rc != -EREMOTE) {
4095 rc = cifs_are_all_path_components_accessible(server,
4096 xid, tcon, cifs_sb,
4097 full_path);
4098 if (rc != 0) {
4099 cifs_dbg(VFS, "cannot query dirs between root and final path, "
4100 "enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
4101 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
4102 rc = 0;
4103 }
4104 }
4105 kfree(full_path);
4106 }
4108 /* get referral if needed */
4109 if (rc == -EREMOTE) {
4110 #ifdef CONFIG_CIFS_DFS_UPCALL
4111 if (referral_walks_count > MAX_NESTED_LINKS) {
4112 /*
4113 * BB: when we implement proper loop detection,
4114 * we will remove this check. But now we need it
4115 * to prevent an indefinite loop if 'DFS tree' is
4116 * misconfigured (i.e. has loops).
4117 */
4118 rc = -ELOOP;
4119 goto mount_fail_check;
4120 }
4122 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
4124 if (!rc) {
4125 referral_walks_count++;
4126 goto try_mount_again;
4127 }
4128 goto mount_fail_check;
4129 #else /* No DFS support, return error on mount */
4130 rc = -EOPNOTSUPP;
4131 #endif
4132 }
4134 if (rc)
4135 goto mount_fail_check;
4137 /* now, hang the tcon off of the superblock */
4138 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
4139 if (tlink == NULL) {
4140 rc = -ENOMEM;
4141 goto mount_fail_check;
4142 }
4144 tlink->tl_uid = ses->linux_uid;
4145 tlink->tl_tcon = tcon;
4146 tlink->tl_time = jiffies;
4147 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
4148 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4150 cifs_sb->master_tlink = tlink;
4151 spin_lock(&cifs_sb->tlink_tree_lock);
4152 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4153 spin_unlock(&cifs_sb->tlink_tree_lock);
4155 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4156 TLINK_IDLE_EXPIRE);
4158 mount_fail_check:
4159 /* on error free sesinfo and tcon struct if needed */
4160 if (rc) {
4161 /* If find_unc succeeded then rc == 0 so we can not end */
4162 /* up accidentally freeing someone elses tcon struct */
4163 if (tcon)
4164 cifs_put_tcon(tcon);
4165 else if (ses)
4166 cifs_put_smb_ses(ses);
4167 else
4168 cifs_put_tcp_session(server, 0);
4169 }
4171 out:
4172 free_xid(xid);
4173 return rc;
4174 }
4176 /*
4177 * Issue a TREE_CONNECT request.
4178 */
4179 int
4180 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
4181 const char *tree, struct cifs_tcon *tcon,
4182 const struct nls_table *nls_codepage)
4183 {
4184 struct smb_hdr *smb_buffer;
4185 struct smb_hdr *smb_buffer_response;
4186 TCONX_REQ *pSMB;
4187 TCONX_RSP *pSMBr;
4188 unsigned char *bcc_ptr;
4189 int rc = 0;
4190 int length;
4191 __u16 bytes_left, count;
4193 if (ses == NULL)
4194 return -EIO;
4196 smb_buffer = cifs_buf_get();
4197 if (smb_buffer == NULL)
4198 return -ENOMEM;
4200 smb_buffer_response = smb_buffer;
4202 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
4203 NULL /*no tid */ , 4 /*wct */ );
4205 smb_buffer->Mid = get_next_mid(ses->server);
4206 smb_buffer->Uid = ses->Suid;
4207 pSMB = (TCONX_REQ *) smb_buffer;
4208 pSMBr = (TCONX_RSP *) smb_buffer_response;
4210 pSMB->AndXCommand = 0xFF;
4211 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
4212 bcc_ptr = &pSMB->Password[0];
4213 if (tcon->pipe || (ses->server->sec_mode & SECMODE_USER)) {
4214 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
4215 *bcc_ptr = 0; /* password is null byte */
4216 bcc_ptr++; /* skip password */
4217 /* already aligned so no need to do it below */
4218 } else {
4219 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
4220 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
4221 specified as required (when that support is added to
4222 the vfs in the future) as only NTLM or the much
4223 weaker LANMAN (which we do not send by default) is accepted
4224 by Samba (not sure whether other servers allow
4225 NTLMv2 password here) */
4226 #ifdef CONFIG_CIFS_WEAK_PW_HASH
4227 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
4228 (ses->sectype == LANMAN))
4229 calc_lanman_hash(tcon->password, ses->server->cryptkey,
4230 ses->server->sec_mode &
4231 SECMODE_PW_ENCRYPT ? true : false,
4232 bcc_ptr);
4233 else
4234 #endif /* CIFS_WEAK_PW_HASH */
4235 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
4236 bcc_ptr, nls_codepage);
4237 if (rc) {
4238 cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
4239 __func__, rc);
4240 cifs_buf_release(smb_buffer);
4241 return rc;
4242 }
4244 bcc_ptr += CIFS_AUTH_RESP_SIZE;
4245 if (ses->capabilities & CAP_UNICODE) {
4246 /* must align unicode strings */
4247 *bcc_ptr = 0; /* null byte password */
4248 bcc_ptr++;
4249 }
4250 }
4252 if (ses->server->sign)
4253 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
4255 if (ses->capabilities & CAP_STATUS32) {
4256 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
4257 }
4258 if (ses->capabilities & CAP_DFS) {
4259 smb_buffer->Flags2 |= SMBFLG2_DFS;
4260 }
4261 if (ses->capabilities & CAP_UNICODE) {
4262 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
4263 length =
4264 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
4265 6 /* max utf8 char length in bytes */ *
4266 (/* server len*/ + 256 /* share len */), nls_codepage);
4267 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
4268 bcc_ptr += 2; /* skip trailing null */
4269 } else { /* ASCII */
4270 strcpy(bcc_ptr, tree);
4271 bcc_ptr += strlen(tree) + 1;
4272 }
4273 strcpy(bcc_ptr, "?????");
4274 bcc_ptr += strlen("?????");
4275 bcc_ptr += 1;
4276 count = bcc_ptr - &pSMB->Password[0];
4277 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
4278 pSMB->hdr.smb_buf_length) + count);
4279 pSMB->ByteCount = cpu_to_le16(count);
4281 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
4282 0);
4284 /* above now done in SendReceive */
4285 if (rc == 0) {
4286 bool is_unicode;
4288 tcon->tidStatus = CifsGood;
4289 tcon->need_reconnect = false;
4290 tcon->tid = smb_buffer_response->Tid;
4291 bcc_ptr = pByteArea(smb_buffer_response);
4292 bytes_left = get_bcc(smb_buffer_response);
4293 length = strnlen(bcc_ptr, bytes_left - 2);
4294 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
4295 is_unicode = true;
4296 else
4297 is_unicode = false;
4300 /* skip service field (NB: this field is always ASCII) */
4301 if (length == 3) {
4302 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
4303 (bcc_ptr[2] == 'C')) {
4304 cifs_dbg(FYI, "IPC connection\n");
4305 tcon->ipc = true;
4306 tcon->pipe = true;
4307 }
4308 } else if (length == 2) {
4309 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
4310 /* the most common case */
4311 cifs_dbg(FYI, "disk share connection\n");
4312 }
4313 }
4314 bcc_ptr += length + 1;
4315 bytes_left -= (length + 1);
4316 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
4318 /* mostly informational -- no need to fail on error here */
4319 kfree(tcon->nativeFileSystem);
4320 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
4321 bytes_left, is_unicode,
4322 nls_codepage);
4324 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
4326 if ((smb_buffer_response->WordCount == 3) ||
4327 (smb_buffer_response->WordCount == 7))
4328 /* field is in same location */
4329 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
4330 else
4331 tcon->Flags = 0;
4332 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
4333 }
4335 cifs_buf_release(smb_buffer);
4336 return rc;
4337 }
4339 static void delayed_free(struct rcu_head *p)
4340 {
4341 struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
4342 unload_nls(sbi->local_nls);
4343 kfree(sbi);
4344 }
4346 void
4347 cifs_umount(struct cifs_sb_info *cifs_sb)
4348 {
4349 struct rb_root *root = &cifs_sb->tlink_tree;
4350 struct rb_node *node;
4351 struct tcon_link *tlink;
4353 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
4355 spin_lock(&cifs_sb->tlink_tree_lock);
4356 while ((node = rb_first(root))) {
4357 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4358 cifs_get_tlink(tlink);
4359 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4360 rb_erase(node, root);
4362 spin_unlock(&cifs_sb->tlink_tree_lock);
4363 cifs_put_tlink(tlink);
4364 spin_lock(&cifs_sb->tlink_tree_lock);
4365 }
4366 spin_unlock(&cifs_sb->tlink_tree_lock);
4368 kfree(cifs_sb->mountdata);
4369 kfree(cifs_sb->prepath);
4370 call_rcu(&cifs_sb->rcu, delayed_free);
4371 }
4373 int
4374 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
4375 {
4376 int rc = 0;
4377 struct TCP_Server_Info *server = ses->server;
4379 if (!server->ops->need_neg || !server->ops->negotiate)
4380 return -ENOSYS;
4382 /* only send once per connect */
4383 if (!server->ops->need_neg(server))
4384 return 0;
4386 set_credits(server, 1);
4388 rc = server->ops->negotiate(xid, ses);
4389 if (rc == 0) {
4390 spin_lock(&GlobalMid_Lock);
4391 if (server->tcpStatus == CifsNeedNegotiate)
4392 server->tcpStatus = CifsGood;
4393 else
4394 rc = -EHOSTDOWN;
4395 spin_unlock(&GlobalMid_Lock);
4396 }
4398 return rc;
4399 }
4401 int
4402 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
4403 struct nls_table *nls_info)
4404 {
4405 int rc = -ENOSYS;
4406 struct TCP_Server_Info *server = ses->server;
4408 ses->capabilities = server->capabilities;
4409 if (linuxExtEnabled == 0)
4410 ses->capabilities &= (~server->vals->cap_unix);
4412 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
4413 server->sec_mode, server->capabilities, server->timeAdj);
4415 if (ses->auth_key.response) {
4416 cifs_dbg(FYI, "Free previous auth_key.response = %p\n",
4417 ses->auth_key.response);
4418 kfree(ses->auth_key.response);
4419 ses->auth_key.response = NULL;
4420 ses->auth_key.len = 0;
4421 }
4423 if (server->ops->sess_setup)
4424 rc = server->ops->sess_setup(xid, ses, nls_info);
4426 if (rc)
4427 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
4429 return rc;
4430 }
4432 static int
4433 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
4434 {
4435 vol->sectype = ses->sectype;
4437 /* krb5 is special, since we don't need username or pw */
4438 if (vol->sectype == Kerberos)
4439 return 0;
4441 return cifs_set_cifscreds(vol, ses);
4442 }
4444 static struct cifs_tcon *
4445 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
4446 {
4447 int rc;
4448 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4449 struct cifs_ses *ses;
4450 struct cifs_tcon *tcon = NULL;
4451 struct smb_vol *vol_info;
4453 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
4454 if (vol_info == NULL)
4455 return ERR_PTR(-ENOMEM);
4457 vol_info->local_nls = cifs_sb->local_nls;
4458 vol_info->linux_uid = fsuid;
4459 vol_info->cred_uid = fsuid;
4460 vol_info->UNC = master_tcon->treeName;
4461 vol_info->retry = master_tcon->retry;
4462 vol_info->nocase = master_tcon->nocase;
4463 vol_info->nohandlecache = master_tcon->nohandlecache;
4464 vol_info->local_lease = master_tcon->local_lease;
4465 vol_info->no_linux_ext = !master_tcon->unix_ext;
4466 vol_info->sectype = master_tcon->ses->sectype;
4467 vol_info->sign = master_tcon->ses->sign;
4469 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4470 if (rc) {
4471 tcon = ERR_PTR(rc);
4472 goto out;
4473 }
4475 /* get a reference for the same TCP session */
4476 spin_lock(&cifs_tcp_ses_lock);
4477 ++master_tcon->ses->server->srv_count;
4478 spin_unlock(&cifs_tcp_ses_lock);
4480 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4481 if (IS_ERR(ses)) {
4482 tcon = (struct cifs_tcon *)ses;
4483 cifs_put_tcp_session(master_tcon->ses->server, 0);
4484 goto out;
4485 }
4487 tcon = cifs_get_tcon(ses, vol_info);
4488 if (IS_ERR(tcon)) {
4489 cifs_put_smb_ses(ses);
4490 goto out;
4491 }
4493 /* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
4494 if (tcon->posix_extensions)
4495 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_POSIX_PATHS;
4497 if (cap_unix(ses))
4498 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4500 out:
4501 kfree(vol_info->username);
4502 kzfree(vol_info->password);
4503 kfree(vol_info);
4505 return tcon;
4506 }
4508 struct cifs_tcon *
4509 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4510 {
4511 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4512 }
4514 /* find and return a tlink with given uid */
4515 static struct tcon_link *
4516 tlink_rb_search(struct rb_root *root, kuid_t uid)
4517 {
4518 struct rb_node *node = root->rb_node;
4519 struct tcon_link *tlink;
4521 while (node) {
4522 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4524 if (uid_gt(tlink->tl_uid, uid))
4525 node = node->rb_left;
4526 else if (uid_lt(tlink->tl_uid, uid))
4527 node = node->rb_right;
4528 else
4529 return tlink;
4530 }
4531 return NULL;
4532 }
4534 /* insert a tcon_link into the tree */
4535 static void
4536 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4537 {
4538 struct rb_node **new = &(root->rb_node), *parent = NULL;
4539 struct tcon_link *tlink;
4541 while (*new) {
4542 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4543 parent = *new;
4545 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
4546 new = &((*new)->rb_left);
4547 else
4548 new = &((*new)->rb_right);
4549 }
4551 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4552 rb_insert_color(&new_tlink->tl_rbnode, root);
4553 }
4555 /*
4556 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4557 * current task.
4558 *
4559 * If the superblock doesn't refer to a multiuser mount, then just return
4560 * the master tcon for the mount.
4561 *
4562 * First, search the rbtree for an existing tcon for this fsuid. If one
4563 * exists, then check to see if it's pending construction. If it is then wait
4564 * for construction to complete. Once it's no longer pending, check to see if
4565 * it failed and either return an error or retry construction, depending on
4566 * the timeout.
4567 *
4568 * If one doesn't exist then insert a new tcon_link struct into the tree and
4569 * try to construct a new one.
4570 */
4571 struct tcon_link *
4572 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4573 {
4574 int ret;
4575 kuid_t fsuid = current_fsuid();
4576 struct tcon_link *tlink, *newtlink;
4578 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4579 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4581 spin_lock(&cifs_sb->tlink_tree_lock);
4582 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4583 if (tlink)
4584 cifs_get_tlink(tlink);
4585 spin_unlock(&cifs_sb->tlink_tree_lock);
4587 if (tlink == NULL) {
4588 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4589 if (newtlink == NULL)
4590 return ERR_PTR(-ENOMEM);
4591 newtlink->tl_uid = fsuid;
4592 newtlink->tl_tcon = ERR_PTR(-EACCES);
4593 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4594 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4595 cifs_get_tlink(newtlink);
4597 spin_lock(&cifs_sb->tlink_tree_lock);
4598 /* was one inserted after previous search? */
4599 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4600 if (tlink) {
4601 cifs_get_tlink(tlink);
4602 spin_unlock(&cifs_sb->tlink_tree_lock);
4603 kfree(newtlink);
4604 goto wait_for_construction;
4605 }
4606 tlink = newtlink;
4607 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4608 spin_unlock(&cifs_sb->tlink_tree_lock);
4609 } else {
4610 wait_for_construction:
4611 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4612 TASK_INTERRUPTIBLE);
4613 if (ret) {
4614 cifs_put_tlink(tlink);
4615 return ERR_PTR(-ERESTARTSYS);
4616 }
4618 /* if it's good, return it */
4619 if (!IS_ERR(tlink->tl_tcon))
4620 return tlink;
4622 /* return error if we tried this already recently */
4623 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4624 cifs_put_tlink(tlink);
4625 return ERR_PTR(-EACCES);
4626 }
4628 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4629 goto wait_for_construction;
4630 }
4632 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4633 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4634 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4636 if (IS_ERR(tlink->tl_tcon)) {
4637 cifs_put_tlink(tlink);
4638 return ERR_PTR(-EACCES);
4639 }
4641 return tlink;
4642 }
4644 /*
4645 * periodic workqueue job that scans tcon_tree for a superblock and closes
4646 * out tcons.
4647 */
4648 static void
4649 cifs_prune_tlinks(struct work_struct *work)
4650 {
4651 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4652 prune_tlinks.work);
4653 struct rb_root *root = &cifs_sb->tlink_tree;
4654 struct rb_node *node;
4655 struct rb_node *tmp;
4656 struct tcon_link *tlink;
4658 /*
4659 * Because we drop the spinlock in the loop in order to put the tlink
4660 * it's not guarded against removal of links from the tree. The only
4661 * places that remove entries from the tree are this function and
4662 * umounts. Because this function is non-reentrant and is canceled
4663 * before umount can proceed, this is safe.
4664 */
4665 spin_lock(&cifs_sb->tlink_tree_lock);
4666 node = rb_first(root);
4667 while (node != NULL) {
4668 tmp = node;
4669 node = rb_next(tmp);
4670 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4672 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4673 atomic_read(&tlink->tl_count) != 0 ||
4674 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4675 continue;
4677 cifs_get_tlink(tlink);
4678 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4679 rb_erase(tmp, root);
4681 spin_unlock(&cifs_sb->tlink_tree_lock);
4682 cifs_put_tlink(tlink);
4683 spin_lock(&cifs_sb->tlink_tree_lock);
4684 }
4685 spin_unlock(&cifs_sb->tlink_tree_lock);
4687 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4688 TLINK_IDLE_EXPIRE);
4689 }