]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - fs/cifs/connect.c
projects / mirror_ubuntu-jammy-kernel.git / blob
? search:


c38156f324ddb5c1499148c943b205235d07120b
[mirror_ubuntu-jammy-kernel.git] / fs / cifs / connect.c
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/mm.h>
25 #include <linux/sched/signal.h>
26 #include <linux/list.h>
27 #include <linux/wait.h>
28 #include <linux/slab.h>
29 #include <linux/pagemap.h>
30 #include <linux/ctype.h>
31 #include <linux/utsname.h>
32 #include <linux/mempool.h>
33 #include <linux/delay.h>
34 #include <linux/completion.h>
35 #include <linux/kthread.h>
36 #include <linux/pagevec.h>
37 #include <linux/freezer.h>
38 #include <linux/namei.h>
39 #include <linux/uuid.h>
40 #include <linux/uaccess.h>
41 #include <asm/processor.h>
42 #include <linux/inet.h>
43 #include <linux/module.h>
44 #include <keys/user-type.h>
45 #include <net/ipv6.h>
46 #include <linux/parser.h>
47 #include <linux/bvec.h>
48 #include "cifspdu.h"
49 #include "cifsglob.h"
50 #include "cifsproto.h"
51 #include "cifs_unicode.h"
52 #include "cifs_debug.h"
53 #include "cifs_fs_sb.h"
54 #include "ntlmssp.h"
55 #include "nterr.h"
56 #include "rfc1002pdu.h"
57 #include "fscache.h"
58 #include "smb2proto.h"
59 #include "smbdirect.h"
60 #include "dns_resolve.h"
61 #ifdef CONFIG_CIFS_DFS_UPCALL
62 #include "dfs_cache.h"
63 #endif
64 #include "fs_context.h"
65
66 extern mempool_t *cifs_req_poolp;
67 extern bool disable_legacy_dialects;
68
69 /* FIXME: should these be tunable? */
70 #define TLINK_ERROR_EXPIRE (1 * HZ)
71 #define TLINK_IDLE_EXPIRE (600 * HZ)
72
73 /* Drop the connection to not overload the server */
74 #define NUM_STATUS_IO_TIMEOUT 5
75
76 enum {
77 /* Mount options that take no arguments */
78 Opt_user_xattr, Opt_nouser_xattr,
79 Opt_forceuid, Opt_noforceuid,
80 Opt_forcegid, Opt_noforcegid,
81 Opt_noblocksend, Opt_noautotune, Opt_nolease,
82 Opt_hard, Opt_soft, Opt_perm, Opt_noperm, Opt_nodelete,
83 Opt_mapposix, Opt_nomapposix,
84 Opt_mapchars, Opt_nomapchars, Opt_sfu,
85 Opt_nosfu, Opt_nodfs, Opt_posixpaths,
86 Opt_noposixpaths, Opt_nounix, Opt_unix,
87 Opt_nocase,
88 Opt_brl, Opt_nobrl,
89 Opt_handlecache, Opt_nohandlecache,
90 Opt_forcemandatorylock, Opt_setuidfromacl, Opt_setuids,
91 Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
92 Opt_nohard, Opt_nosoft,
93 Opt_nointr, Opt_intr,
94 Opt_nostrictsync, Opt_strictsync,
95 Opt_serverino, Opt_noserverino,
96 Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
97 Opt_acl, Opt_noacl, Opt_locallease,
98 Opt_sign, Opt_ignore_signature, Opt_seal, Opt_noac,
99 Opt_fsc, Opt_mfsymlinks,
100 Opt_multiuser, Opt_sloppy, Opt_nosharesock,
101 Opt_persistent, Opt_nopersistent,
102 Opt_resilient, Opt_noresilient,
103 Opt_domainauto, Opt_rdma, Opt_modesid, Opt_rootfs,
104 Opt_multichannel, Opt_nomultichannel,
105 Opt_compress,
106
107 /* Mount options which take numeric value */
108 Opt_backupuid, Opt_backupgid, Opt_uid,
109 Opt_cruid, Opt_gid, Opt_file_mode,
110 Opt_dirmode, Opt_port,
111 Opt_min_enc_offload,
112 Opt_blocksize, Opt_rsize, Opt_wsize, Opt_actimeo,
113 Opt_echo_interval, Opt_max_credits, Opt_handletimeout,
114 Opt_snapshot, Opt_max_channels,
115
116 /* Mount options which take string value */
117 Opt_user, Opt_pass, Opt_ip,
118 Opt_domain, Opt_srcaddr, Opt_iocharset,
119 Opt_netbiosname, Opt_servern,
120 Opt_ver, Opt_vers, Opt_sec, Opt_cache,
121
122 /* Mount options to be ignored */
123 Opt_ignore,
124
125 /* Options which could be blank */
126 Opt_blank_pass,
127 Opt_blank_user,
128 Opt_blank_ip,
129
130 Opt_err
131 };
132
133 static const match_table_t cifs_mount_option_tokens = {
134
135 { Opt_user_xattr, "user_xattr" },
136 { Opt_nouser_xattr, "nouser_xattr" },
137 { Opt_forceuid, "forceuid" },
138 { Opt_noforceuid, "noforceuid" },
139 { Opt_forcegid, "forcegid" },
140 { Opt_noforcegid, "noforcegid" },
141 { Opt_noblocksend, "noblocksend" },
142 { Opt_noautotune, "noautotune" },
143 { Opt_nolease, "nolease" },
144 { Opt_hard, "hard" },
145 { Opt_soft, "soft" },
146 { Opt_perm, "perm" },
147 { Opt_noperm, "noperm" },
148 { Opt_nodelete, "nodelete" },
149 { Opt_mapchars, "mapchars" }, /* SFU style */
150 { Opt_nomapchars, "nomapchars" },
151 { Opt_mapposix, "mapposix" }, /* SFM style */
152 { Opt_nomapposix, "nomapposix" },
153 { Opt_sfu, "sfu" },
154 { Opt_nosfu, "nosfu" },
155 { Opt_nodfs, "nodfs" },
156 { Opt_posixpaths, "posixpaths" },
157 { Opt_noposixpaths, "noposixpaths" },
158 { Opt_nounix, "nounix" },
159 { Opt_nounix, "nolinux" },
160 { Opt_nounix, "noposix" },
161 { Opt_unix, "unix" },
162 { Opt_unix, "linux" },
163 { Opt_unix, "posix" },
164 { Opt_nocase, "nocase" },
165 { Opt_nocase, "ignorecase" },
166 { Opt_brl, "brl" },
167 { Opt_nobrl, "nobrl" },
168 { Opt_handlecache, "handlecache" },
169 { Opt_nohandlecache, "nohandlecache" },
170 { Opt_nobrl, "nolock" },
171 { Opt_forcemandatorylock, "forcemandatorylock" },
172 { Opt_forcemandatorylock, "forcemand" },
173 { Opt_setuids, "setuids" },
174 { Opt_nosetuids, "nosetuids" },
175 { Opt_setuidfromacl, "idsfromsid" },
176 { Opt_dynperm, "dynperm" },
177 { Opt_nodynperm, "nodynperm" },
178 { Opt_nohard, "nohard" },
179 { Opt_nosoft, "nosoft" },
180 { Opt_nointr, "nointr" },
181 { Opt_intr, "intr" },
182 { Opt_nostrictsync, "nostrictsync" },
183 { Opt_strictsync, "strictsync" },
184 { Opt_serverino, "serverino" },
185 { Opt_noserverino, "noserverino" },
186 { Opt_rwpidforward, "rwpidforward" },
187 { Opt_modesid, "modefromsid" },
188 { Opt_cifsacl, "cifsacl" },
189 { Opt_nocifsacl, "nocifsacl" },
190 { Opt_acl, "acl" },
191 { Opt_noacl, "noacl" },
192 { Opt_locallease, "locallease" },
193 { Opt_sign, "sign" },
194 { Opt_ignore_signature, "signloosely" },
195 { Opt_seal, "seal" },
196 { Opt_noac, "noac" },
197 { Opt_fsc, "fsc" },
198 { Opt_mfsymlinks, "mfsymlinks" },
199 { Opt_multiuser, "multiuser" },
200 { Opt_sloppy, "sloppy" },
201 { Opt_nosharesock, "nosharesock" },
202 { Opt_persistent, "persistenthandles"},
203 { Opt_nopersistent, "nopersistenthandles"},
204 { Opt_resilient, "resilienthandles"},
205 { Opt_noresilient, "noresilienthandles"},
206 { Opt_domainauto, "domainauto"},
207 { Opt_rdma, "rdma"},
208 { Opt_multichannel, "multichannel" },
209 { Opt_nomultichannel, "nomultichannel" },
210
211 { Opt_backupuid, "backupuid=%s" },
212 { Opt_backupgid, "backupgid=%s" },
213 { Opt_uid, "uid=%s" },
214 { Opt_cruid, "cruid=%s" },
215 { Opt_gid, "gid=%s" },
216 { Opt_file_mode, "file_mode=%s" },
217 { Opt_dirmode, "dirmode=%s" },
218 { Opt_dirmode, "dir_mode=%s" },
219 { Opt_port, "port=%s" },
220 { Opt_min_enc_offload, "esize=%s" },
221 { Opt_blocksize, "bsize=%s" },
222 { Opt_rsize, "rsize=%s" },
223 { Opt_wsize, "wsize=%s" },
224 { Opt_actimeo, "actimeo=%s" },
225 { Opt_handletimeout, "handletimeout=%s" },
226 { Opt_echo_interval, "echo_interval=%s" },
227 { Opt_max_credits, "max_credits=%s" },
228 { Opt_snapshot, "snapshot=%s" },
229 { Opt_max_channels, "max_channels=%s" },
230 { Opt_compress, "compress=%s" },
231
232 { Opt_blank_user, "user=" },
233 { Opt_blank_user, "username=" },
234 { Opt_user, "user=%s" },
235 { Opt_user, "username=%s" },
236 { Opt_blank_pass, "pass=" },
237 { Opt_blank_pass, "password=" },
238 { Opt_pass, "pass=%s" },
239 { Opt_pass, "password=%s" },
240 { Opt_blank_ip, "ip=" },
241 { Opt_blank_ip, "addr=" },
242 { Opt_ip, "ip=%s" },
243 { Opt_ip, "addr=%s" },
244 { Opt_ignore, "unc=%s" },
245 { Opt_ignore, "target=%s" },
246 { Opt_ignore, "path=%s" },
247 { Opt_domain, "dom=%s" },
248 { Opt_domain, "domain=%s" },
249 { Opt_domain, "workgroup=%s" },
250 { Opt_srcaddr, "srcaddr=%s" },
251 { Opt_ignore, "prefixpath=%s" },
252 { Opt_iocharset, "iocharset=%s" },
253 { Opt_netbiosname, "netbiosname=%s" },
254 { Opt_servern, "servern=%s" },
255 { Opt_ver, "ver=%s" },
256 { Opt_vers, "vers=%s" },
257 { Opt_sec, "sec=%s" },
258 { Opt_cache, "cache=%s" },
259
260 { Opt_ignore, "cred" },
261 { Opt_ignore, "credentials" },
262 { Opt_ignore, "cred=%s" },
263 { Opt_ignore, "credentials=%s" },
264 { Opt_ignore, "guest" },
265 { Opt_ignore, "rw" },
266 { Opt_ignore, "ro" },
267 { Opt_ignore, "suid" },
268 { Opt_ignore, "nosuid" },
269 { Opt_ignore, "exec" },
270 { Opt_ignore, "noexec" },
271 { Opt_ignore, "nodev" },
272 { Opt_ignore, "noauto" },
273 { Opt_ignore, "dev" },
274 { Opt_ignore, "mand" },
275 { Opt_ignore, "nomand" },
276 { Opt_ignore, "relatime" },
277 { Opt_ignore, "_netdev" },
278 { Opt_rootfs, "rootfs" },
279
280 { Opt_err, NULL }
281 };
282
283 static int ip_connect(struct TCP_Server_Info *server);
284 static int generic_ip_connect(struct TCP_Server_Info *server);
285 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
286 static void cifs_prune_tlinks(struct work_struct *work);
287 static char *extract_hostname(const char *unc);
288
289 /*
290 * Resolve hostname and set ip addr in tcp ses. Useful for hostnames that may
291 * get their ip addresses changed at some point.
292 *
293 * This should be called with server->srv_mutex held.
294 */
295 #ifdef CONFIG_CIFS_DFS_UPCALL
296 static int reconn_set_ipaddr(struct TCP_Server_Info *server)
297 {
298 int rc;
299 int len;
300 char *unc, *ipaddr = NULL;
301
302 if (!server->hostname)
303 return -EINVAL;
304
305 len = strlen(server->hostname) + 3;
306
307 unc = kmalloc(len, GFP_KERNEL);
308 if (!unc) {
309 cifs_dbg(FYI, "%s: failed to create UNC path\n", __func__);
310 return -ENOMEM;
311 }
312 scnprintf(unc, len, "\\\\%s", server->hostname);
313
314 rc = dns_resolve_server_name_to_ip(unc, &ipaddr);
315 kfree(unc);
316
317 if (rc < 0) {
318 cifs_dbg(FYI, "%s: failed to resolve server part of %s to IP: %d\n",
319 __func__, server->hostname, rc);
320 return rc;
321 }
322
323 spin_lock(&cifs_tcp_ses_lock);
324 rc = cifs_convert_address((struct sockaddr *)&server->dstaddr, ipaddr,
325 strlen(ipaddr));
326 spin_unlock(&cifs_tcp_ses_lock);
327 kfree(ipaddr);
328
329 return !rc ? -1 : 0;
330 }
331 #else
332 static inline int reconn_set_ipaddr(struct TCP_Server_Info *server)
333 {
334 return 0;
335 }
336 #endif
337
338 #ifdef CONFIG_CIFS_DFS_UPCALL
339 /* These functions must be called with server->srv_mutex held */
340 static void reconn_set_next_dfs_target(struct TCP_Server_Info *server,
341 struct cifs_sb_info *cifs_sb,
342 struct dfs_cache_tgt_list *tgt_list,
343 struct dfs_cache_tgt_iterator **tgt_it)
344 {
345 const char *name;
346
347 if (!cifs_sb || !cifs_sb->origin_fullpath)
348 return;
349
350 if (!*tgt_it) {
351 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
352 } else {
353 *tgt_it = dfs_cache_get_next_tgt(tgt_list, *tgt_it);
354 if (!*tgt_it)
355 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
356 }
357
358 cifs_dbg(FYI, "%s: UNC: %s\n", __func__, cifs_sb->origin_fullpath);
359
360 name = dfs_cache_get_tgt_name(*tgt_it);
361
362 kfree(server->hostname);
363
364 server->hostname = extract_hostname(name);
365 if (IS_ERR(server->hostname)) {
366 cifs_dbg(FYI,
367 "%s: failed to extract hostname from target: %ld\n",
368 __func__, PTR_ERR(server->hostname));
369 }
370 }
371
372 static inline int reconn_setup_dfs_targets(struct cifs_sb_info *cifs_sb,
373 struct dfs_cache_tgt_list *tl)
374 {
375 if (!cifs_sb->origin_fullpath)
376 return -EOPNOTSUPP;
377 return dfs_cache_noreq_find(cifs_sb->origin_fullpath + 1, NULL, tl);
378 }
379 #endif
380
381 /*
382 * cifs tcp session reconnection
383 *
384 * mark tcp session as reconnecting so temporarily locked
385 * mark all smb sessions as reconnecting for tcp session
386 * reconnect tcp session
387 * wake up waiters on reconnection? - (not needed currently)
388 */
389 int
390 cifs_reconnect(struct TCP_Server_Info *server)
391 {
392 int rc = 0;
393 struct list_head *tmp, *tmp2;
394 struct cifs_ses *ses;
395 struct cifs_tcon *tcon;
396 struct mid_q_entry *mid_entry;
397 struct list_head retry_list;
398 #ifdef CONFIG_CIFS_DFS_UPCALL
399 struct super_block *sb = NULL;
400 struct cifs_sb_info *cifs_sb = NULL;
401 struct dfs_cache_tgt_list tgt_list = {0};
402 struct dfs_cache_tgt_iterator *tgt_it = NULL;
403 #endif
404
405 spin_lock(&GlobalMid_Lock);
406 server->nr_targets = 1;
407 #ifdef CONFIG_CIFS_DFS_UPCALL
408 spin_unlock(&GlobalMid_Lock);
409 sb = cifs_get_tcp_super(server);
410 if (IS_ERR(sb)) {
411 rc = PTR_ERR(sb);
412 cifs_dbg(FYI, "%s: will not do DFS failover: rc = %d\n",
413 __func__, rc);
414 sb = NULL;
415 } else {
416 cifs_sb = CIFS_SB(sb);
417 rc = reconn_setup_dfs_targets(cifs_sb, &tgt_list);
418 if (rc) {
419 cifs_sb = NULL;
420 if (rc != -EOPNOTSUPP) {
421 cifs_server_dbg(VFS, "%s: no target servers for DFS failover\n",
422 __func__);
423 }
424 } else {
425 server->nr_targets = dfs_cache_get_nr_tgts(&tgt_list);
426 }
427 }
428 cifs_dbg(FYI, "%s: will retry %d target(s)\n", __func__,
429 server->nr_targets);
430 spin_lock(&GlobalMid_Lock);
431 #endif
432 if (server->tcpStatus == CifsExiting) {
433 /* the demux thread will exit normally
434 next time through the loop */
435 spin_unlock(&GlobalMid_Lock);
436 #ifdef CONFIG_CIFS_DFS_UPCALL
437 dfs_cache_free_tgts(&tgt_list);
438 cifs_put_tcp_super(sb);
439 #endif
440 wake_up(&server->response_q);
441 return rc;
442 } else
443 server->tcpStatus = CifsNeedReconnect;
444 spin_unlock(&GlobalMid_Lock);
445 server->maxBuf = 0;
446 server->max_read = 0;
447
448 cifs_dbg(FYI, "Mark tcp session as need reconnect\n");
449 trace_smb3_reconnect(server->CurrentMid, server->hostname);
450
451 /* before reconnecting the tcp session, mark the smb session (uid)
452 and the tid bad so they are not used until reconnected */
453 cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
454 __func__);
455 spin_lock(&cifs_tcp_ses_lock);
456 list_for_each(tmp, &server->smb_ses_list) {
457 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
458 ses->need_reconnect = true;
459 list_for_each(tmp2, &ses->tcon_list) {
460 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
461 tcon->need_reconnect = true;
462 }
463 if (ses->tcon_ipc)
464 ses->tcon_ipc->need_reconnect = true;
465 }
466 spin_unlock(&cifs_tcp_ses_lock);
467
468 /* do not want to be sending data on a socket we are freeing */
469 cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
470 mutex_lock(&server->srv_mutex);
471 if (server->ssocket) {
472 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
473 server->ssocket->state, server->ssocket->flags);
474 kernel_sock_shutdown(server->ssocket, SHUT_WR);
475 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
476 server->ssocket->state, server->ssocket->flags);
477 sock_release(server->ssocket);
478 server->ssocket = NULL;
479 }
480 server->sequence_number = 0;
481 server->session_estab = false;
482 kfree(server->session_key.response);
483 server->session_key.response = NULL;
484 server->session_key.len = 0;
485 server->lstrp = jiffies;
486
487 /* mark submitted MIDs for retry and issue callback */
488 INIT_LIST_HEAD(&retry_list);
489 cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
490 spin_lock(&GlobalMid_Lock);
491 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
492 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
493 kref_get(&mid_entry->refcount);
494 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
495 mid_entry->mid_state = MID_RETRY_NEEDED;
496 list_move(&mid_entry->qhead, &retry_list);
497 mid_entry->mid_flags |= MID_DELETED;
498 }
499 spin_unlock(&GlobalMid_Lock);
500 mutex_unlock(&server->srv_mutex);
501
502 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
503 list_for_each_safe(tmp, tmp2, &retry_list) {
504 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
505 list_del_init(&mid_entry->qhead);
506 mid_entry->callback(mid_entry);
507 cifs_mid_q_entry_release(mid_entry);
508 }
509
510 if (cifs_rdma_enabled(server)) {
511 mutex_lock(&server->srv_mutex);
512 smbd_destroy(server);
513 mutex_unlock(&server->srv_mutex);
514 }
515
516 do {
517 try_to_freeze();
518
519 mutex_lock(&server->srv_mutex);
520 #ifdef CONFIG_CIFS_DFS_UPCALL
521 /*
522 * Set up next DFS target server (if any) for reconnect. If DFS
523 * feature is disabled, then we will retry last server we
524 * connected to before.
525 */
526 reconn_set_next_dfs_target(server, cifs_sb, &tgt_list, &tgt_it);
527 #endif
528 rc = reconn_set_ipaddr(server);
529 if (rc) {
530 cifs_dbg(FYI, "%s: failed to resolve hostname: %d\n",
531 __func__, rc);
532 }
533
534 if (cifs_rdma_enabled(server))
535 rc = smbd_reconnect(server);
536 else
537 rc = generic_ip_connect(server);
538 if (rc) {
539 cifs_dbg(FYI, "reconnect error %d\n", rc);
540 mutex_unlock(&server->srv_mutex);
541 msleep(3000);
542 } else {
543 atomic_inc(&tcpSesReconnectCount);
544 set_credits(server, 1);
545 spin_lock(&GlobalMid_Lock);
546 if (server->tcpStatus != CifsExiting)
547 server->tcpStatus = CifsNeedNegotiate;
548 spin_unlock(&GlobalMid_Lock);
549 mutex_unlock(&server->srv_mutex);
550 }
551 } while (server->tcpStatus == CifsNeedReconnect);
552
553 #ifdef CONFIG_CIFS_DFS_UPCALL
554 if (tgt_it) {
555 rc = dfs_cache_noreq_update_tgthint(cifs_sb->origin_fullpath + 1,
556 tgt_it);
557 if (rc) {
558 cifs_server_dbg(VFS, "%s: failed to update DFS target hint: rc = %d\n",
559 __func__, rc);
560 }
561 rc = dfs_cache_update_vol(cifs_sb->origin_fullpath, server);
562 if (rc) {
563 cifs_server_dbg(VFS, "%s: failed to update vol info in DFS cache: rc = %d\n",
564 __func__, rc);
565 }
566 dfs_cache_free_tgts(&tgt_list);
567
568 }
569
570 cifs_put_tcp_super(sb);
571 #endif
572 if (server->tcpStatus == CifsNeedNegotiate)
573 mod_delayed_work(cifsiod_wq, &server->echo, 0);
574
575 wake_up(&server->response_q);
576 return rc;
577 }
578
579 static void
580 cifs_echo_request(struct work_struct *work)
581 {
582 int rc;
583 struct TCP_Server_Info *server = container_of(work,
584 struct TCP_Server_Info, echo.work);
585 unsigned long echo_interval;
586
587 /*
588 * If we need to renegotiate, set echo interval to zero to
589 * immediately call echo service where we can renegotiate.
590 */
591 if (server->tcpStatus == CifsNeedNegotiate)
592 echo_interval = 0;
593 else
594 echo_interval = server->echo_interval;
595
596 /*
597 * We cannot send an echo if it is disabled.
598 * Also, no need to ping if we got a response recently.
599 */
600
601 if (server->tcpStatus == CifsNeedReconnect ||
602 server->tcpStatus == CifsExiting ||
603 server->tcpStatus == CifsNew ||
604 (server->ops->can_echo && !server->ops->can_echo(server)) ||
605 time_before(jiffies, server->lstrp + echo_interval - HZ))
606 goto requeue_echo;
607
608 rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
609 if (rc)
610 cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
611 server->hostname);
612
613 requeue_echo:
614 queue_delayed_work(cifsiod_wq, &server->echo, server->echo_interval);
615 }
616
617 static bool
618 allocate_buffers(struct TCP_Server_Info *server)
619 {
620 if (!server->bigbuf) {
621 server->bigbuf = (char *)cifs_buf_get();
622 if (!server->bigbuf) {
623 cifs_server_dbg(VFS, "No memory for large SMB response\n");
624 msleep(3000);
625 /* retry will check if exiting */
626 return false;
627 }
628 } else if (server->large_buf) {
629 /* we are reusing a dirty large buf, clear its start */
630 memset(server->bigbuf, 0, HEADER_SIZE(server));
631 }
632
633 if (!server->smallbuf) {
634 server->smallbuf = (char *)cifs_small_buf_get();
635 if (!server->smallbuf) {
636 cifs_server_dbg(VFS, "No memory for SMB response\n");
637 msleep(1000);
638 /* retry will check if exiting */
639 return false;
640 }
641 /* beginning of smb buffer is cleared in our buf_get */
642 } else {
643 /* if existing small buf clear beginning */
644 memset(server->smallbuf, 0, HEADER_SIZE(server));
645 }
646
647 return true;
648 }
649
650 static bool
651 server_unresponsive(struct TCP_Server_Info *server)
652 {
653 /*
654 * We need to wait 3 echo intervals to make sure we handle such
655 * situations right:
656 * 1s client sends a normal SMB request
657 * 2s client gets a response
658 * 30s echo workqueue job pops, and decides we got a response recently
659 * and don't need to send another
660 * ...
661 * 65s kernel_recvmsg times out, and we see that we haven't gotten
662 * a response in >60s.
663 */
664 if ((server->tcpStatus == CifsGood ||
665 server->tcpStatus == CifsNeedNegotiate) &&
666 time_after(jiffies, server->lstrp + 3 * server->echo_interval)) {
667 cifs_server_dbg(VFS, "has not responded in %lu seconds. Reconnecting...\n",
668 (3 * server->echo_interval) / HZ);
669 cifs_reconnect(server);
670 return true;
671 }
672
673 return false;
674 }
675
676 static inline bool
677 zero_credits(struct TCP_Server_Info *server)
678 {
679 int val;
680
681 spin_lock(&server->req_lock);
682 val = server->credits + server->echo_credits + server->oplock_credits;
683 if (server->in_flight == 0 && val == 0) {
684 spin_unlock(&server->req_lock);
685 return true;
686 }
687 spin_unlock(&server->req_lock);
688 return false;
689 }
690
691 static int
692 cifs_readv_from_socket(struct TCP_Server_Info *server, struct msghdr *smb_msg)
693 {
694 int length = 0;
695 int total_read;
696
697 smb_msg->msg_control = NULL;
698 smb_msg->msg_controllen = 0;
699
700 for (total_read = 0; msg_data_left(smb_msg); total_read += length) {
701 try_to_freeze();
702
703 /* reconnect if no credits and no requests in flight */
704 if (zero_credits(server)) {
705 cifs_reconnect(server);
706 return -ECONNABORTED;
707 }
708
709 if (server_unresponsive(server))
710 return -ECONNABORTED;
711 if (cifs_rdma_enabled(server) && server->smbd_conn)
712 length = smbd_recv(server->smbd_conn, smb_msg);
713 else
714 length = sock_recvmsg(server->ssocket, smb_msg, 0);
715
716 if (server->tcpStatus == CifsExiting)
717 return -ESHUTDOWN;
718
719 if (server->tcpStatus == CifsNeedReconnect) {
720 cifs_reconnect(server);
721 return -ECONNABORTED;
722 }
723
724 if (length == -ERESTARTSYS ||
725 length == -EAGAIN ||
726 length == -EINTR) {
727 /*
728 * Minimum sleep to prevent looping, allowing socket
729 * to clear and app threads to set tcpStatus
730 * CifsNeedReconnect if server hung.
731 */
732 usleep_range(1000, 2000);
733 length = 0;
734 continue;
735 }
736
737 if (length <= 0) {
738 cifs_dbg(FYI, "Received no data or error: %d\n", length);
739 cifs_reconnect(server);
740 return -ECONNABORTED;
741 }
742 }
743 return total_read;
744 }
745
746 int
747 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
748 unsigned int to_read)
749 {
750 struct msghdr smb_msg;
751 struct kvec iov = {.iov_base = buf, .iov_len = to_read};
752 iov_iter_kvec(&smb_msg.msg_iter, READ, &iov, 1, to_read);
753
754 return cifs_readv_from_socket(server, &smb_msg);
755 }
756
757 int
758 cifs_read_page_from_socket(struct TCP_Server_Info *server, struct page *page,
759 unsigned int page_offset, unsigned int to_read)
760 {
761 struct msghdr smb_msg;
762 struct bio_vec bv = {
763 .bv_page = page, .bv_len = to_read, .bv_offset = page_offset};
764 iov_iter_bvec(&smb_msg.msg_iter, READ, &bv, 1, to_read);
765 return cifs_readv_from_socket(server, &smb_msg);
766 }
767
768 static bool
769 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
770 {
771 /*
772 * The first byte big endian of the length field,
773 * is actually not part of the length but the type
774 * with the most common, zero, as regular data.
775 */
776 switch (type) {
777 case RFC1002_SESSION_MESSAGE:
778 /* Regular SMB response */
779 return true;
780 case RFC1002_SESSION_KEEP_ALIVE:
781 cifs_dbg(FYI, "RFC 1002 session keep alive\n");
782 break;
783 case RFC1002_POSITIVE_SESSION_RESPONSE:
784 cifs_dbg(FYI, "RFC 1002 positive session response\n");
785 break;
786 case RFC1002_NEGATIVE_SESSION_RESPONSE:
787 /*
788 * We get this from Windows 98 instead of an error on
789 * SMB negprot response.
790 */
791 cifs_dbg(FYI, "RFC 1002 negative session response\n");
792 /* give server a second to clean up */
793 msleep(1000);
794 /*
795 * Always try 445 first on reconnect since we get NACK
796 * on some if we ever connected to port 139 (the NACK
797 * is since we do not begin with RFC1001 session
798 * initialize frame).
799 */
800 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
801 cifs_reconnect(server);
802 break;
803 default:
804 cifs_server_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
805 cifs_reconnect(server);
806 }
807
808 return false;
809 }
810
811 void
812 dequeue_mid(struct mid_q_entry *mid, bool malformed)
813 {
814 #ifdef CONFIG_CIFS_STATS2
815 mid->when_received = jiffies;
816 #endif
817 spin_lock(&GlobalMid_Lock);
818 if (!malformed)
819 mid->mid_state = MID_RESPONSE_RECEIVED;
820 else
821 mid->mid_state = MID_RESPONSE_MALFORMED;
822 /*
823 * Trying to handle/dequeue a mid after the send_recv()
824 * function has finished processing it is a bug.
825 */
826 if (mid->mid_flags & MID_DELETED)
827 pr_warn_once("trying to dequeue a deleted mid\n");
828 else {
829 list_del_init(&mid->qhead);
830 mid->mid_flags |= MID_DELETED;
831 }
832 spin_unlock(&GlobalMid_Lock);
833 }
834
835 static unsigned int
836 smb2_get_credits_from_hdr(char *buffer, struct TCP_Server_Info *server)
837 {
838 struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)buffer;
839
840 /*
841 * SMB1 does not use credits.
842 */
843 if (server->vals->header_preamble_size)
844 return 0;
845
846 return le16_to_cpu(shdr->CreditRequest);
847 }
848
849 static void
850 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
851 char *buf, int malformed)
852 {
853 if (server->ops->check_trans2 &&
854 server->ops->check_trans2(mid, server, buf, malformed))
855 return;
856 mid->credits_received = smb2_get_credits_from_hdr(buf, server);
857 mid->resp_buf = buf;
858 mid->large_buf = server->large_buf;
859 /* Was previous buf put in mpx struct for multi-rsp? */
860 if (!mid->multiRsp) {
861 /* smb buffer will be freed by user thread */
862 if (server->large_buf)
863 server->bigbuf = NULL;
864 else
865 server->smallbuf = NULL;
866 }
867 dequeue_mid(mid, malformed);
868 }
869
870 static void clean_demultiplex_info(struct TCP_Server_Info *server)
871 {
872 int length;
873
874 /* take it off the list, if it's not already */
875 spin_lock(&cifs_tcp_ses_lock);
876 list_del_init(&server->tcp_ses_list);
877 spin_unlock(&cifs_tcp_ses_lock);
878
879 spin_lock(&GlobalMid_Lock);
880 server->tcpStatus = CifsExiting;
881 spin_unlock(&GlobalMid_Lock);
882 wake_up_all(&server->response_q);
883
884 /* check if we have blocked requests that need to free */
885 spin_lock(&server->req_lock);
886 if (server->credits <= 0)
887 server->credits = 1;
888 spin_unlock(&server->req_lock);
889 /*
890 * Although there should not be any requests blocked on this queue it
891 * can not hurt to be paranoid and try to wake up requests that may
892 * haven been blocked when more than 50 at time were on the wire to the
893 * same server - they now will see the session is in exit state and get
894 * out of SendReceive.
895 */
896 wake_up_all(&server->request_q);
897 /* give those requests time to exit */
898 msleep(125);
899 if (cifs_rdma_enabled(server))
900 smbd_destroy(server);
901 if (server->ssocket) {
902 sock_release(server->ssocket);
903 server->ssocket = NULL;
904 }
905
906 if (!list_empty(&server->pending_mid_q)) {
907 struct list_head dispose_list;
908 struct mid_q_entry *mid_entry;
909 struct list_head *tmp, *tmp2;
910
911 INIT_LIST_HEAD(&dispose_list);
912 spin_lock(&GlobalMid_Lock);
913 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
914 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
915 cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid);
916 kref_get(&mid_entry->refcount);
917 mid_entry->mid_state = MID_SHUTDOWN;
918 list_move(&mid_entry->qhead, &dispose_list);
919 mid_entry->mid_flags |= MID_DELETED;
920 }
921 spin_unlock(&GlobalMid_Lock);
922
923 /* now walk dispose list and issue callbacks */
924 list_for_each_safe(tmp, tmp2, &dispose_list) {
925 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
926 cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid);
927 list_del_init(&mid_entry->qhead);
928 mid_entry->callback(mid_entry);
929 cifs_mid_q_entry_release(mid_entry);
930 }
931 /* 1/8th of sec is more than enough time for them to exit */
932 msleep(125);
933 }
934
935 if (!list_empty(&server->pending_mid_q)) {
936 /*
937 * mpx threads have not exited yet give them at least the smb
938 * send timeout time for long ops.
939 *
940 * Due to delays on oplock break requests, we need to wait at
941 * least 45 seconds before giving up on a request getting a
942 * response and going ahead and killing cifsd.
943 */
944 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
945 msleep(46000);
946 /*
947 * If threads still have not exited they are probably never
948 * coming home not much else we can do but free the memory.
949 */
950 }
951
952 kfree(server->hostname);
953 kfree(server);
954
955 length = atomic_dec_return(&tcpSesAllocCount);
956 if (length > 0)
957 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
958 }
959
960 static int
961 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
962 {
963 int length;
964 char *buf = server->smallbuf;
965 unsigned int pdu_length = server->pdu_size;
966
967 /* make sure this will fit in a large buffer */
968 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) -
969 server->vals->header_preamble_size) {
970 cifs_server_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
971 cifs_reconnect(server);
972 return -ECONNABORTED;
973 }
974
975 /* switch to large buffer if too big for a small one */
976 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
977 server->large_buf = true;
978 memcpy(server->bigbuf, buf, server->total_read);
979 buf = server->bigbuf;
980 }
981
982 /* now read the rest */
983 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
984 pdu_length - HEADER_SIZE(server) + 1
985 + server->vals->header_preamble_size);
986
987 if (length < 0)
988 return length;
989 server->total_read += length;
990
991 dump_smb(buf, server->total_read);
992
993 return cifs_handle_standard(server, mid);
994 }
995
996 int
997 cifs_handle_standard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
998 {
999 char *buf = server->large_buf ? server->bigbuf : server->smallbuf;
1000 int length;
1001
1002 /*
1003 * We know that we received enough to get to the MID as we
1004 * checked the pdu_length earlier. Now check to see
1005 * if the rest of the header is OK. We borrow the length
1006 * var for the rest of the loop to avoid a new stack var.
1007 *
1008 * 48 bytes is enough to display the header and a little bit
1009 * into the payload for debugging purposes.
1010 */
1011 length = server->ops->check_message(buf, server->total_read, server);
1012 if (length != 0)
1013 cifs_dump_mem("Bad SMB: ", buf,
1014 min_t(unsigned int, server->total_read, 48));
1015
1016 if (server->ops->is_session_expired &&
1017 server->ops->is_session_expired(buf)) {
1018 cifs_reconnect(server);
1019 return -1;
1020 }
1021
1022 if (server->ops->is_status_pending &&
1023 server->ops->is_status_pending(buf, server))
1024 return -1;
1025
1026 if (!mid)
1027 return length;
1028
1029 handle_mid(mid, server, buf, length);
1030 return 0;
1031 }
1032
1033 static void
1034 smb2_add_credits_from_hdr(char *buffer, struct TCP_Server_Info *server)
1035 {
1036 struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)buffer;
1037
1038 /*
1039 * SMB1 does not use credits.
1040 */
1041 if (server->vals->header_preamble_size)
1042 return;
1043
1044 if (shdr->CreditRequest) {
1045 spin_lock(&server->req_lock);
1046 server->credits += le16_to_cpu(shdr->CreditRequest);
1047 spin_unlock(&server->req_lock);
1048 wake_up(&server->request_q);
1049 }
1050 }
1051
1052
1053 static int
1054 cifs_demultiplex_thread(void *p)
1055 {
1056 int i, num_mids, length;
1057 struct TCP_Server_Info *server = p;
1058 unsigned int pdu_length;
1059 unsigned int next_offset;
1060 char *buf = NULL;
1061 struct task_struct *task_to_wake = NULL;
1062 struct mid_q_entry *mids[MAX_COMPOUND];
1063 char *bufs[MAX_COMPOUND];
1064 unsigned int noreclaim_flag, num_io_timeout = 0;
1065
1066 noreclaim_flag = memalloc_noreclaim_save();
1067 cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
1068
1069 length = atomic_inc_return(&tcpSesAllocCount);
1070 if (length > 1)
1071 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
1072
1073 set_freezable();
1074 allow_kernel_signal(SIGKILL);
1075 while (server->tcpStatus != CifsExiting) {
1076 if (try_to_freeze())
1077 continue;
1078
1079 if (!allocate_buffers(server))
1080 continue;
1081
1082 server->large_buf = false;
1083 buf = server->smallbuf;
1084 pdu_length = 4; /* enough to get RFC1001 header */
1085
1086 length = cifs_read_from_socket(server, buf, pdu_length);
1087 if (length < 0)
1088 continue;
1089
1090 if (server->vals->header_preamble_size == 0)
1091 server->total_read = 0;
1092 else
1093 server->total_read = length;
1094
1095 /*
1096 * The right amount was read from socket - 4 bytes,
1097 * so we can now interpret the length field.
1098 */
1099 pdu_length = get_rfc1002_length(buf);
1100
1101 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
1102 if (!is_smb_response(server, buf[0]))
1103 continue;
1104 next_pdu:
1105 server->pdu_size = pdu_length;
1106
1107 /* make sure we have enough to get to the MID */
1108 if (server->pdu_size < HEADER_SIZE(server) - 1 -
1109 server->vals->header_preamble_size) {
1110 cifs_server_dbg(VFS, "SMB response too short (%u bytes)\n",
1111 server->pdu_size);
1112 cifs_reconnect(server);
1113 continue;
1114 }
1115
1116 /* read down to the MID */
1117 length = cifs_read_from_socket(server,
1118 buf + server->vals->header_preamble_size,
1119 HEADER_SIZE(server) - 1
1120 - server->vals->header_preamble_size);
1121 if (length < 0)
1122 continue;
1123 server->total_read += length;
1124
1125 if (server->ops->next_header) {
1126 next_offset = server->ops->next_header(buf);
1127 if (next_offset)
1128 server->pdu_size = next_offset;
1129 }
1130
1131 memset(mids, 0, sizeof(mids));
1132 memset(bufs, 0, sizeof(bufs));
1133 num_mids = 0;
1134
1135 if (server->ops->is_transform_hdr &&
1136 server->ops->receive_transform &&
1137 server->ops->is_transform_hdr(buf)) {
1138 length = server->ops->receive_transform(server,
1139 mids,
1140 bufs,
1141 &num_mids);
1142 } else {
1143 mids[0] = server->ops->find_mid(server, buf);
1144 bufs[0] = buf;
1145 num_mids = 1;
1146
1147 if (!mids[0] || !mids[0]->receive)
1148 length = standard_receive3(server, mids[0]);
1149 else
1150 length = mids[0]->receive(server, mids[0]);
1151 }
1152
1153 if (length < 0) {
1154 for (i = 0; i < num_mids; i++)
1155 if (mids[i])
1156 cifs_mid_q_entry_release(mids[i]);
1157 continue;
1158 }
1159
1160 if (server->ops->is_status_io_timeout &&
1161 server->ops->is_status_io_timeout(buf)) {
1162 num_io_timeout++;
1163 if (num_io_timeout > NUM_STATUS_IO_TIMEOUT) {
1164 cifs_reconnect(server);
1165 num_io_timeout = 0;
1166 continue;
1167 }
1168 }
1169
1170 server->lstrp = jiffies;
1171
1172 for (i = 0; i < num_mids; i++) {
1173 if (mids[i] != NULL) {
1174 mids[i]->resp_buf_size = server->pdu_size;
1175
1176 if (!mids[i]->multiRsp || mids[i]->multiEnd)
1177 mids[i]->callback(mids[i]);
1178
1179 cifs_mid_q_entry_release(mids[i]);
1180 } else if (server->ops->is_oplock_break &&
1181 server->ops->is_oplock_break(bufs[i],
1182 server)) {
1183 smb2_add_credits_from_hdr(bufs[i], server);
1184 cifs_dbg(FYI, "Received oplock break\n");
1185 } else {
1186 cifs_server_dbg(VFS, "No task to wake, unknown frame received! NumMids %d\n",
1187 atomic_read(&midCount));
1188 cifs_dump_mem("Received Data is: ", bufs[i],
1189 HEADER_SIZE(server));
1190 smb2_add_credits_from_hdr(bufs[i], server);
1191 #ifdef CONFIG_CIFS_DEBUG2
1192 if (server->ops->dump_detail)
1193 server->ops->dump_detail(bufs[i],
1194 server);
1195 cifs_dump_mids(server);
1196 #endif /* CIFS_DEBUG2 */
1197 }
1198 }
1199
1200 if (pdu_length > server->pdu_size) {
1201 if (!allocate_buffers(server))
1202 continue;
1203 pdu_length -= server->pdu_size;
1204 server->total_read = 0;
1205 server->large_buf = false;
1206 buf = server->smallbuf;
1207 goto next_pdu;
1208 }
1209 } /* end while !EXITING */
1210
1211 /* buffer usually freed in free_mid - need to free it here on exit */
1212 cifs_buf_release(server->bigbuf);
1213 if (server->smallbuf) /* no sense logging a debug message if NULL */
1214 cifs_small_buf_release(server->smallbuf);
1215
1216 task_to_wake = xchg(&server->tsk, NULL);
1217 clean_demultiplex_info(server);
1218
1219 /* if server->tsk was NULL then wait for a signal before exiting */
1220 if (!task_to_wake) {
1221 set_current_state(TASK_INTERRUPTIBLE);
1222 while (!signal_pending(current)) {
1223 schedule();
1224 set_current_state(TASK_INTERRUPTIBLE);
1225 }
1226 set_current_state(TASK_RUNNING);
1227 }
1228
1229 memalloc_noreclaim_restore(noreclaim_flag);
1230 module_put_and_exit(0);
1231 }
1232
1233 /* extract the host portion of the UNC string */
1234 static char *
1235 extract_hostname(const char *unc)
1236 {
1237 const char *src;
1238 char *dst, *delim;
1239 unsigned int len;
1240
1241 /* skip double chars at beginning of string */
1242 /* BB: check validity of these bytes? */
1243 if (strlen(unc) < 3)
1244 return ERR_PTR(-EINVAL);
1245 for (src = unc; *src && *src == '\\'; src++)
1246 ;
1247 if (!*src)
1248 return ERR_PTR(-EINVAL);
1249
1250 /* delimiter between hostname and sharename is always '\\' now */
1251 delim = strchr(src, '\\');
1252 if (!delim)
1253 return ERR_PTR(-EINVAL);
1254
1255 len = delim - src;
1256 dst = kmalloc((len + 1), GFP_KERNEL);
1257 if (dst == NULL)
1258 return ERR_PTR(-ENOMEM);
1259
1260 memcpy(dst, src, len);
1261 dst[len] = '\0';
1262
1263 return dst;
1264 }
1265
1266 static int get_option_ul(substring_t args[], unsigned long *option)
1267 {
1268 int rc;
1269 char *string;
1270
1271 string = match_strdup(args);
1272 if (string == NULL)
1273 return -ENOMEM;
1274 rc = kstrtoul(string, 0, option);
1275 kfree(string);
1276
1277 return rc;
1278 }
1279
1280 static int get_option_uid(substring_t args[], kuid_t *result)
1281 {
1282 unsigned long value;
1283 kuid_t uid;
1284 int rc;
1285
1286 rc = get_option_ul(args, &value);
1287 if (rc)
1288 return rc;
1289
1290 uid = make_kuid(current_user_ns(), value);
1291 if (!uid_valid(uid))
1292 return -EINVAL;
1293
1294 *result = uid;
1295 return 0;
1296 }
1297
1298 static int get_option_gid(substring_t args[], kgid_t *result)
1299 {
1300 unsigned long value;
1301 kgid_t gid;
1302 int rc;
1303
1304 rc = get_option_ul(args, &value);
1305 if (rc)
1306 return rc;
1307
1308 gid = make_kgid(current_user_ns(), value);
1309 if (!gid_valid(gid))
1310 return -EINVAL;
1311
1312 *result = gid;
1313 return 0;
1314 }
1315
1316 /*
1317 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1318 * fields with the result. Returns 0 on success and an error otherwise.
1319 */
1320 static int
1321 cifs_parse_devname(const char *devname, struct smb_vol *vol)
1322 {
1323 char *pos;
1324 const char *delims = "/\\";
1325 size_t len;
1326
1327 if (unlikely(!devname || !*devname)) {
1328 cifs_dbg(VFS, "Device name not specified\n");
1329 return -EINVAL;
1330 }
1331
1332 /* make sure we have a valid UNC double delimiter prefix */
1333 len = strspn(devname, delims);
1334 if (len != 2)
1335 return -EINVAL;
1336
1337 /* find delimiter between host and sharename */
1338 pos = strpbrk(devname + 2, delims);
1339 if (!pos)
1340 return -EINVAL;
1341
1342 /* skip past delimiter */
1343 ++pos;
1344
1345 /* now go until next delimiter or end of string */
1346 len = strcspn(pos, delims);
1347
1348 /* move "pos" up to delimiter or NULL */
1349 pos += len;
1350 vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1351 if (!vol->UNC)
1352 return -ENOMEM;
1353
1354 convert_delimiter(vol->UNC, '\\');
1355
1356 /* skip any delimiter */
1357 if (*pos == '/' || *pos == '\\')
1358 pos++;
1359
1360 /* If pos is NULL then no prepath */
1361 if (!*pos)
1362 return 0;
1363
1364 vol->prepath = kstrdup(pos, GFP_KERNEL);
1365 if (!vol->prepath)
1366 return -ENOMEM;
1367
1368 return 0;
1369 }
1370
1371 static int
1372 cifs_parse_mount_options(const char *mountdata, const char *devname,
1373 struct smb_vol *vol, bool is_smb3)
1374 {
1375 char *data, *end;
1376 char *mountdata_copy = NULL, *options;
1377 unsigned int temp_len, i, j;
1378 char separator[2];
1379 short int override_uid = -1;
1380 short int override_gid = -1;
1381 bool uid_specified = false;
1382 bool gid_specified = false;
1383 bool sloppy = false;
1384 char *invalid = NULL;
1385 char *nodename = utsname()->nodename;
1386 char *string = NULL;
1387 char *tmp_end, *value;
1388 char delim;
1389 bool got_ip = false;
1390 bool got_version = false;
1391 unsigned short port = 0;
1392 struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1393
1394 separator[0] = ',';
1395 separator[1] = 0;
1396 delim = separator[0];
1397
1398 /* ensure we always start with zeroed-out smb_vol */
1399 memset(vol, 0, sizeof(*vol));
1400
1401 /*
1402 * does not have to be perfect mapping since field is
1403 * informational, only used for servers that do not support
1404 * port 445 and it can be overridden at mount time
1405 */
1406 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1407 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1408 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1409
1410 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1411 /* null target name indicates to use *SMBSERVR default called name
1412 if we end up sending RFC1001 session initialize */
1413 vol->target_rfc1001_name[0] = 0;
1414 vol->cred_uid = current_uid();
1415 vol->linux_uid = current_uid();
1416 vol->linux_gid = current_gid();
1417 vol->bsize = 1024 * 1024; /* can improve cp performance significantly */
1418 /*
1419 * default to SFM style remapping of seven reserved characters
1420 * unless user overrides it or we negotiate CIFS POSIX where
1421 * it is unnecessary. Can not simultaneously use more than one mapping
1422 * since then readdir could list files that open could not open
1423 */
1424 vol->remap = true;
1425
1426 /* default to only allowing write access to owner of the mount */
1427 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1428
1429 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1430 /* default is always to request posix paths. */
1431 vol->posix_paths = 1;
1432 /* default to using server inode numbers where available */
1433 vol->server_ino = 1;
1434
1435 /* default is to use strict cifs caching semantics */
1436 vol->strict_io = true;
1437
1438 vol->actimeo = CIFS_DEF_ACTIMEO;
1439
1440 /* Most clients set timeout to 0, allows server to use its default */
1441 vol->handle_timeout = 0; /* See MS-SMB2 spec section 2.2.14.2.12 */
1442
1443 /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
1444 vol->ops = &smb30_operations;
1445 vol->vals = &smbdefault_values;
1446
1447 vol->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1448
1449 /* default to no multichannel (single server connection) */
1450 vol->multichannel = false;
1451 vol->max_channels = 1;
1452
1453 if (!mountdata)
1454 goto cifs_parse_mount_err;
1455
1456 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1457 if (!mountdata_copy)
1458 goto cifs_parse_mount_err;
1459
1460 options = mountdata_copy;
1461 end = options + strlen(options);
1462
1463 if (strncmp(options, "sep=", 4) == 0) {
1464 if (options[4] != 0) {
1465 separator[0] = options[4];
1466 options += 5;
1467 } else {
1468 cifs_dbg(FYI, "Null separator not allowed\n");
1469 }
1470 }
1471 vol->backupuid_specified = false; /* no backup intent for a user */
1472 vol->backupgid_specified = false; /* no backup intent for a group */
1473
1474 switch (cifs_parse_devname(devname, vol)) {
1475 case 0:
1476 break;
1477 case -ENOMEM:
1478 cifs_dbg(VFS, "Unable to allocate memory for devname\n");
1479 goto cifs_parse_mount_err;
1480 case -EINVAL:
1481 cifs_dbg(VFS, "Malformed UNC in devname\n");
1482 goto cifs_parse_mount_err;
1483 default:
1484 cifs_dbg(VFS, "Unknown error parsing devname\n");
1485 goto cifs_parse_mount_err;
1486 }
1487
1488 while ((data = strsep(&options, separator)) != NULL) {
1489 substring_t args[MAX_OPT_ARGS];
1490 unsigned long option;
1491 int token;
1492
1493 if (!*data)
1494 continue;
1495
1496 token = match_token(data, cifs_mount_option_tokens, args);
1497
1498 switch (token) {
1499
1500 /* Ingnore the following */
1501 case Opt_ignore:
1502 break;
1503
1504 /* Boolean values */
1505 case Opt_user_xattr:
1506 vol->no_xattr = 0;
1507 break;
1508 case Opt_nouser_xattr:
1509 vol->no_xattr = 1;
1510 break;
1511 case Opt_forceuid:
1512 override_uid = 1;
1513 break;
1514 case Opt_noforceuid:
1515 override_uid = 0;
1516 break;
1517 case Opt_forcegid:
1518 override_gid = 1;
1519 break;
1520 case Opt_noforcegid:
1521 override_gid = 0;
1522 break;
1523 case Opt_noblocksend:
1524 vol->noblocksnd = 1;
1525 break;
1526 case Opt_noautotune:
1527 vol->noautotune = 1;
1528 break;
1529 case Opt_nolease:
1530 vol->no_lease = 1;
1531 break;
1532 case Opt_hard:
1533 vol->retry = 1;
1534 break;
1535 case Opt_soft:
1536 vol->retry = 0;
1537 break;
1538 case Opt_perm:
1539 vol->noperm = 0;
1540 break;
1541 case Opt_noperm:
1542 vol->noperm = 1;
1543 break;
1544 case Opt_nodelete:
1545 vol->nodelete = 1;
1546 break;
1547 case Opt_mapchars:
1548 vol->sfu_remap = true;
1549 vol->remap = false; /* disable SFM mapping */
1550 break;
1551 case Opt_nomapchars:
1552 vol->sfu_remap = false;
1553 break;
1554 case Opt_mapposix:
1555 vol->remap = true;
1556 vol->sfu_remap = false; /* disable SFU mapping */
1557 break;
1558 case Opt_nomapposix:
1559 vol->remap = false;
1560 break;
1561 case Opt_sfu:
1562 vol->sfu_emul = 1;
1563 break;
1564 case Opt_nosfu:
1565 vol->sfu_emul = 0;
1566 break;
1567 case Opt_nodfs:
1568 vol->nodfs = 1;
1569 break;
1570 case Opt_rootfs:
1571 #ifdef CONFIG_CIFS_ROOT
1572 vol->rootfs = true;
1573 #endif
1574 break;
1575 case Opt_posixpaths:
1576 vol->posix_paths = 1;
1577 break;
1578 case Opt_noposixpaths:
1579 vol->posix_paths = 0;
1580 break;
1581 case Opt_nounix:
1582 if (vol->linux_ext)
1583 cifs_dbg(VFS,
1584 "conflicting unix mount options\n");
1585 vol->no_linux_ext = 1;
1586 break;
1587 case Opt_unix:
1588 if (vol->no_linux_ext)
1589 cifs_dbg(VFS,
1590 "conflicting unix mount options\n");
1591 vol->linux_ext = 1;
1592 break;
1593 case Opt_nocase:
1594 vol->nocase = 1;
1595 break;
1596 case Opt_brl:
1597 vol->nobrl = 0;
1598 break;
1599 case Opt_nobrl:
1600 vol->nobrl = 1;
1601 /*
1602 * turn off mandatory locking in mode
1603 * if remote locking is turned off since the
1604 * local vfs will do advisory
1605 */
1606 if (vol->file_mode ==
1607 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1608 vol->file_mode = S_IALLUGO;
1609 break;
1610 case Opt_nohandlecache:
1611 vol->nohandlecache = 1;
1612 break;
1613 case Opt_handlecache:
1614 vol->nohandlecache = 0;
1615 break;
1616 case Opt_forcemandatorylock:
1617 vol->mand_lock = 1;
1618 break;
1619 case Opt_setuids:
1620 vol->setuids = 1;
1621 break;
1622 case Opt_nosetuids:
1623 vol->setuids = 0;
1624 break;
1625 case Opt_setuidfromacl:
1626 vol->setuidfromacl = 1;
1627 break;
1628 case Opt_dynperm:
1629 vol->dynperm = true;
1630 break;
1631 case Opt_nodynperm:
1632 vol->dynperm = false;
1633 break;
1634 case Opt_nohard:
1635 vol->retry = 0;
1636 break;
1637 case Opt_nosoft:
1638 vol->retry = 1;
1639 break;
1640 case Opt_nointr:
1641 vol->intr = 0;
1642 break;
1643 case Opt_intr:
1644 vol->intr = 1;
1645 break;
1646 case Opt_nostrictsync:
1647 vol->nostrictsync = 1;
1648 break;
1649 case Opt_strictsync:
1650 vol->nostrictsync = 0;
1651 break;
1652 case Opt_serverino:
1653 vol->server_ino = 1;
1654 break;
1655 case Opt_noserverino:
1656 vol->server_ino = 0;
1657 break;
1658 case Opt_rwpidforward:
1659 vol->rwpidforward = 1;
1660 break;
1661 case Opt_modesid:
1662 vol->mode_ace = 1;
1663 break;
1664 case Opt_cifsacl:
1665 vol->cifs_acl = 1;
1666 break;
1667 case Opt_nocifsacl:
1668 vol->cifs_acl = 0;
1669 break;
1670 case Opt_acl:
1671 vol->no_psx_acl = 0;
1672 break;
1673 case Opt_noacl:
1674 vol->no_psx_acl = 1;
1675 break;
1676 case Opt_locallease:
1677 vol->local_lease = 1;
1678 break;
1679 case Opt_sign:
1680 vol->sign = true;
1681 break;
1682 case Opt_ignore_signature:
1683 vol->sign = true;
1684 vol->ignore_signature = true;
1685 break;
1686 case Opt_seal:
1687 /* we do not do the following in secFlags because seal
1688 * is a per tree connection (mount) not a per socket
1689 * or per-smb connection option in the protocol
1690 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1691 */
1692 vol->seal = 1;
1693 break;
1694 case Opt_noac:
1695 pr_warn("Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1696 break;
1697 case Opt_fsc:
1698 #ifndef CONFIG_CIFS_FSCACHE
1699 cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1700 goto cifs_parse_mount_err;
1701 #endif
1702 vol->fsc = true;
1703 break;
1704 case Opt_mfsymlinks:
1705 vol->mfsymlinks = true;
1706 break;
1707 case Opt_multiuser:
1708 vol->multiuser = true;
1709 break;
1710 case Opt_sloppy:
1711 sloppy = true;
1712 break;
1713 case Opt_nosharesock:
1714 vol->nosharesock = true;
1715 break;
1716 case Opt_nopersistent:
1717 vol->nopersistent = true;
1718 if (vol->persistent) {
1719 cifs_dbg(VFS,
1720 "persistenthandles mount options conflict\n");
1721 goto cifs_parse_mount_err;
1722 }
1723 break;
1724 case Opt_persistent:
1725 vol->persistent = true;
1726 if ((vol->nopersistent) || (vol->resilient)) {
1727 cifs_dbg(VFS,
1728 "persistenthandles mount options conflict\n");
1729 goto cifs_parse_mount_err;
1730 }
1731 break;
1732 case Opt_resilient:
1733 vol->resilient = true;
1734 if (vol->persistent) {
1735 cifs_dbg(VFS,
1736 "persistenthandles mount options conflict\n");
1737 goto cifs_parse_mount_err;
1738 }
1739 break;
1740 case Opt_noresilient:
1741 vol->resilient = false; /* already the default */
1742 break;
1743 case Opt_domainauto:
1744 vol->domainauto = true;
1745 break;
1746 case Opt_rdma:
1747 vol->rdma = true;
1748 break;
1749 case Opt_multichannel:
1750 vol->multichannel = true;
1751 /* if number of channels not specified, default to 2 */
1752 if (vol->max_channels < 2)
1753 vol->max_channels = 2;
1754 break;
1755 case Opt_nomultichannel:
1756 vol->multichannel = false;
1757 vol->max_channels = 1;
1758 break;
1759 case Opt_compress:
1760 vol->compression = UNKNOWN_TYPE;
1761 cifs_dbg(VFS,
1762 "SMB3 compression support is experimental\n");
1763 break;
1764
1765 /* Numeric Values */
1766 case Opt_backupuid:
1767 if (get_option_uid(args, &vol->backupuid)) {
1768 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
1769 __func__);
1770 goto cifs_parse_mount_err;
1771 }
1772 vol->backupuid_specified = true;
1773 break;
1774 case Opt_backupgid:
1775 if (get_option_gid(args, &vol->backupgid)) {
1776 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
1777 __func__);
1778 goto cifs_parse_mount_err;
1779 }
1780 vol->backupgid_specified = true;
1781 break;
1782 case Opt_uid:
1783 if (get_option_uid(args, &vol->linux_uid)) {
1784 cifs_dbg(VFS, "%s: Invalid uid value\n",
1785 __func__);
1786 goto cifs_parse_mount_err;
1787 }
1788 uid_specified = true;
1789 break;
1790 case Opt_cruid:
1791 if (get_option_uid(args, &vol->cred_uid)) {
1792 cifs_dbg(VFS, "%s: Invalid cruid value\n",
1793 __func__);
1794 goto cifs_parse_mount_err;
1795 }
1796 break;
1797 case Opt_gid:
1798 if (get_option_gid(args, &vol->linux_gid)) {
1799 cifs_dbg(VFS, "%s: Invalid gid value\n",
1800 __func__);
1801 goto cifs_parse_mount_err;
1802 }
1803 gid_specified = true;
1804 break;
1805 case Opt_file_mode:
1806 if (get_option_ul(args, &option)) {
1807 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
1808 __func__);
1809 goto cifs_parse_mount_err;
1810 }
1811 vol->file_mode = option;
1812 break;
1813 case Opt_dirmode:
1814 if (get_option_ul(args, &option)) {
1815 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
1816 __func__);
1817 goto cifs_parse_mount_err;
1818 }
1819 vol->dir_mode = option;
1820 break;
1821 case Opt_port:
1822 if (get_option_ul(args, &option) ||
1823 option > USHRT_MAX) {
1824 cifs_dbg(VFS, "%s: Invalid port value\n",
1825 __func__);
1826 goto cifs_parse_mount_err;
1827 }
1828 port = (unsigned short)option;
1829 break;
1830 case Opt_min_enc_offload:
1831 if (get_option_ul(args, &option)) {
1832 cifs_dbg(VFS, "Invalid minimum encrypted read offload size (esize)\n");
1833 goto cifs_parse_mount_err;
1834 }
1835 vol->min_offload = option;
1836 break;
1837 case Opt_blocksize:
1838 if (get_option_ul(args, &option)) {
1839 cifs_dbg(VFS, "%s: Invalid blocksize value\n",
1840 __func__);
1841 goto cifs_parse_mount_err;
1842 }
1843 /*
1844 * inode blocksize realistically should never need to be
1845 * less than 16K or greater than 16M and default is 1MB.
1846 * Note that small inode block sizes (e.g. 64K) can lead
1847 * to very poor performance of common tools like cp and scp
1848 */
1849 if ((option < CIFS_MAX_MSGSIZE) ||
1850 (option > (4 * SMB3_DEFAULT_IOSIZE))) {
1851 cifs_dbg(VFS, "%s: Invalid blocksize\n",
1852 __func__);
1853 goto cifs_parse_mount_err;
1854 }
1855 vol->bsize = option;
1856 break;
1857 case Opt_rsize:
1858 if (get_option_ul(args, &option)) {
1859 cifs_dbg(VFS, "%s: Invalid rsize value\n",
1860 __func__);
1861 goto cifs_parse_mount_err;
1862 }
1863 vol->rsize = option;
1864 break;
1865 case Opt_wsize:
1866 if (get_option_ul(args, &option)) {
1867 cifs_dbg(VFS, "%s: Invalid wsize value\n",
1868 __func__);
1869 goto cifs_parse_mount_err;
1870 }
1871 vol->wsize = option;
1872 break;
1873 case Opt_actimeo:
1874 if (get_option_ul(args, &option)) {
1875 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
1876 __func__);
1877 goto cifs_parse_mount_err;
1878 }
1879 vol->actimeo = HZ * option;
1880 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1881 cifs_dbg(VFS, "attribute cache timeout too large\n");
1882 goto cifs_parse_mount_err;
1883 }
1884 break;
1885 case Opt_handletimeout:
1886 if (get_option_ul(args, &option)) {
1887 cifs_dbg(VFS, "%s: Invalid handletimeout value\n",
1888 __func__);
1889 goto cifs_parse_mount_err;
1890 }
1891 vol->handle_timeout = option;
1892 if (vol->handle_timeout > SMB3_MAX_HANDLE_TIMEOUT) {
1893 cifs_dbg(VFS, "Invalid handle cache timeout, longer than 16 minutes\n");
1894 goto cifs_parse_mount_err;
1895 }
1896 break;
1897 case Opt_echo_interval:
1898 if (get_option_ul(args, &option)) {
1899 cifs_dbg(VFS, "%s: Invalid echo interval value\n",
1900 __func__);
1901 goto cifs_parse_mount_err;
1902 }
1903 vol->echo_interval = option;
1904 break;
1905 case Opt_snapshot:
1906 if (get_option_ul(args, &option)) {
1907 cifs_dbg(VFS, "%s: Invalid snapshot time\n",
1908 __func__);
1909 goto cifs_parse_mount_err;
1910 }
1911 vol->snapshot_time = option;
1912 break;
1913 case Opt_max_credits:
1914 if (get_option_ul(args, &option) || (option < 20) ||
1915 (option > 60000)) {
1916 cifs_dbg(VFS, "%s: Invalid max_credits value\n",
1917 __func__);
1918 goto cifs_parse_mount_err;
1919 }
1920 vol->max_credits = option;
1921 break;
1922 case Opt_max_channels:
1923 if (get_option_ul(args, &option) || option < 1 ||
1924 option > CIFS_MAX_CHANNELS) {
1925 cifs_dbg(VFS, "%s: Invalid max_channels value, needs to be 1-%d\n",
1926 __func__, CIFS_MAX_CHANNELS);
1927 goto cifs_parse_mount_err;
1928 }
1929 vol->max_channels = option;
1930 break;
1931
1932 /* String Arguments */
1933
1934 case Opt_blank_user:
1935 /* null user, ie. anonymous authentication */
1936 vol->nullauth = 1;
1937 vol->username = NULL;
1938 break;
1939 case Opt_user:
1940 string = match_strdup(args);
1941 if (string == NULL)
1942 goto out_nomem;
1943
1944 if (strnlen(string, CIFS_MAX_USERNAME_LEN) >
1945 CIFS_MAX_USERNAME_LEN) {
1946 pr_warn("username too long\n");
1947 goto cifs_parse_mount_err;
1948 }
1949
1950 kfree(vol->username);
1951 vol->username = kstrdup(string, GFP_KERNEL);
1952 if (!vol->username)
1953 goto cifs_parse_mount_err;
1954 break;
1955 case Opt_blank_pass:
1956 /* passwords have to be handled differently
1957 * to allow the character used for deliminator
1958 * to be passed within them
1959 */
1960
1961 /*
1962 * Check if this is a case where the password
1963 * starts with a delimiter
1964 */
1965 tmp_end = strchr(data, '=');
1966 tmp_end++;
1967 if (!(tmp_end < end && tmp_end[1] == delim)) {
1968 /* No it is not. Set the password to NULL */
1969 kfree_sensitive(vol->password);
1970 vol->password = NULL;
1971 break;
1972 }
1973 fallthrough; /* to Opt_pass below */
1974 case Opt_pass:
1975 /* Obtain the value string */
1976 value = strchr(data, '=');
1977 value++;
1978
1979 /* Set tmp_end to end of the string */
1980 tmp_end = (char *) value + strlen(value);
1981
1982 /* Check if following character is the deliminator
1983 * If yes, we have encountered a double deliminator
1984 * reset the NULL character to the deliminator
1985 */
1986 if (tmp_end < end && tmp_end[1] == delim) {
1987 tmp_end[0] = delim;
1988
1989 /* Keep iterating until we get to a single
1990 * deliminator OR the end
1991 */
1992 while ((tmp_end = strchr(tmp_end, delim))
1993 != NULL && (tmp_end[1] == delim)) {
1994 tmp_end = (char *) &tmp_end[2];
1995 }
1996
1997 /* Reset var options to point to next element */
1998 if (tmp_end) {
1999 tmp_end[0] = '\0';
2000 options = (char *) &tmp_end[1];
2001 } else
2002 /* Reached the end of the mount option
2003 * string */
2004 options = end;
2005 }
2006
2007 kfree_sensitive(vol->password);
2008 /* Now build new password string */
2009 temp_len = strlen(value);
2010 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
2011 if (vol->password == NULL) {
2012 pr_warn("no memory for password\n");
2013 goto cifs_parse_mount_err;
2014 }
2015
2016 for (i = 0, j = 0; i < temp_len; i++, j++) {
2017 vol->password[j] = value[i];
2018 if ((value[i] == delim) &&
2019 value[i+1] == delim)
2020 /* skip the second deliminator */
2021 i++;
2022 }
2023 vol->password[j] = '\0';
2024 break;
2025 case Opt_blank_ip:
2026 /* FIXME: should this be an error instead? */
2027 got_ip = false;
2028 break;
2029 case Opt_ip:
2030 string = match_strdup(args);
2031 if (string == NULL)
2032 goto out_nomem;
2033
2034 if (!cifs_convert_address(dstaddr, string,
2035 strlen(string))) {
2036 pr_err("bad ip= option (%s)\n", string);
2037 goto cifs_parse_mount_err;
2038 }
2039 got_ip = true;
2040 break;
2041 case Opt_domain:
2042 string = match_strdup(args);
2043 if (string == NULL)
2044 goto out_nomem;
2045
2046 if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
2047 == CIFS_MAX_DOMAINNAME_LEN) {
2048 pr_warn("domain name too long\n");
2049 goto cifs_parse_mount_err;
2050 }
2051
2052 kfree(vol->domainname);
2053 vol->domainname = kstrdup(string, GFP_KERNEL);
2054 if (!vol->domainname) {
2055 pr_warn("no memory for domainname\n");
2056 goto cifs_parse_mount_err;
2057 }
2058 cifs_dbg(FYI, "Domain name set\n");
2059 break;
2060 case Opt_srcaddr:
2061 string = match_strdup(args);
2062 if (string == NULL)
2063 goto out_nomem;
2064
2065 if (!cifs_convert_address(
2066 (struct sockaddr *)&vol->srcaddr,
2067 string, strlen(string))) {
2068 pr_warn("Could not parse srcaddr: %s\n",
2069 string);
2070 goto cifs_parse_mount_err;
2071 }
2072 break;
2073 case Opt_iocharset:
2074 string = match_strdup(args);
2075 if (string == NULL)
2076 goto out_nomem;
2077
2078 if (strnlen(string, 1024) >= 65) {
2079 pr_warn("iocharset name too long\n");
2080 goto cifs_parse_mount_err;
2081 }
2082
2083 if (strncasecmp(string, "default", 7) != 0) {
2084 kfree(vol->iocharset);
2085 vol->iocharset = kstrdup(string,
2086 GFP_KERNEL);
2087 if (!vol->iocharset) {
2088 pr_warn("no memory for charset\n");
2089 goto cifs_parse_mount_err;
2090 }
2091 }
2092 /* if iocharset not set then load_nls_default
2093 * is used by caller
2094 */
2095 cifs_dbg(FYI, "iocharset set to %s\n", string);
2096 break;
2097 case Opt_netbiosname:
2098 string = match_strdup(args);
2099 if (string == NULL)
2100 goto out_nomem;
2101
2102 memset(vol->source_rfc1001_name, 0x20,
2103 RFC1001_NAME_LEN);
2104 /*
2105 * FIXME: are there cases in which a comma can
2106 * be valid in workstation netbios name (and
2107 * need special handling)?
2108 */
2109 for (i = 0; i < RFC1001_NAME_LEN; i++) {
2110 /* don't ucase netbiosname for user */
2111 if (string[i] == 0)
2112 break;
2113 vol->source_rfc1001_name[i] = string[i];
2114 }
2115 /* The string has 16th byte zero still from
2116 * set at top of the function
2117 */
2118 if (i == RFC1001_NAME_LEN && string[i] != 0)
2119 pr_warn("netbiosname longer than 15 truncated\n");
2120 break;
2121 case Opt_servern:
2122 /* servernetbiosname specified override *SMBSERVER */
2123 string = match_strdup(args);
2124 if (string == NULL)
2125 goto out_nomem;
2126
2127 /* last byte, type, is 0x20 for servr type */
2128 memset(vol->target_rfc1001_name, 0x20,
2129 RFC1001_NAME_LEN_WITH_NULL);
2130
2131 /* BB are there cases in which a comma can be
2132 valid in this workstation netbios name
2133 (and need special handling)? */
2134
2135 /* user or mount helper must uppercase the
2136 netbios name */
2137 for (i = 0; i < 15; i++) {
2138 if (string[i] == 0)
2139 break;
2140 vol->target_rfc1001_name[i] = string[i];
2141 }
2142 /* The string has 16th byte zero still from
2143 set at top of the function */
2144 if (i == RFC1001_NAME_LEN && string[i] != 0)
2145 pr_warn("server netbiosname longer than 15 truncated\n");
2146 break;
2147 case Opt_ver:
2148 /* version of mount userspace tools, not dialect */
2149 string = match_strdup(args);
2150 if (string == NULL)
2151 goto out_nomem;
2152
2153 /* If interface changes in mount.cifs bump to new ver */
2154 if (strncasecmp(string, "1", 1) == 0) {
2155 if (strlen(string) > 1) {
2156 pr_warn("Bad mount helper ver=%s. Did you want SMB1 (CIFS) dialect and mean to type vers=1.0 instead?\n",
2157 string);
2158 goto cifs_parse_mount_err;
2159 }
2160 /* This is the default */
2161 break;
2162 }
2163 /* For all other value, error */
2164 pr_warn("Invalid mount helper version specified\n");
2165 goto cifs_parse_mount_err;
2166 case Opt_vers:
2167 /* protocol version (dialect) */
2168 string = match_strdup(args);
2169 if (string == NULL)
2170 goto out_nomem;
2171
2172 if (cifs_parse_smb_version(string, vol, is_smb3) != 0)
2173 goto cifs_parse_mount_err;
2174 got_version = true;
2175 break;
2176 case Opt_sec:
2177 string = match_strdup(args);
2178 if (string == NULL)
2179 goto out_nomem;
2180
2181 if (cifs_parse_security_flavors(string, vol) != 0)
2182 goto cifs_parse_mount_err;
2183 break;
2184 case Opt_cache:
2185 string = match_strdup(args);
2186 if (string == NULL)
2187 goto out_nomem;
2188
2189 if (cifs_parse_cache_flavor(string, vol) != 0)
2190 goto cifs_parse_mount_err;
2191 break;
2192 default:
2193 /*
2194 * An option we don't recognize. Save it off for later
2195 * if we haven't already found one
2196 */
2197 if (!invalid)
2198 invalid = data;
2199 break;
2200 }
2201 /* Free up any allocated string */
2202 kfree(string);
2203 string = NULL;
2204 }
2205
2206 if (!sloppy && invalid) {
2207 pr_err("Unknown mount option \"%s\"\n", invalid);
2208 goto cifs_parse_mount_err;
2209 }
2210
2211 if (vol->rdma && vol->vals->protocol_id < SMB30_PROT_ID) {
2212 cifs_dbg(VFS, "SMB Direct requires Version >=3.0\n");
2213 goto cifs_parse_mount_err;
2214 }
2215
2216 #ifndef CONFIG_KEYS
2217 /* Muliuser mounts require CONFIG_KEYS support */
2218 if (vol->multiuser) {
2219 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
2220 goto cifs_parse_mount_err;
2221 }
2222 #endif
2223 if (!vol->UNC) {
2224 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
2225 goto cifs_parse_mount_err;
2226 }
2227
2228 /* make sure UNC has a share name */
2229 if (!strchr(vol->UNC + 3, '\\')) {
2230 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
2231 goto cifs_parse_mount_err;
2232 }
2233
2234 if (!got_ip) {
2235 int len;
2236 const char *slash;
2237
2238 /* No ip= option specified? Try to get it from UNC */
2239 /* Use the address part of the UNC. */
2240 slash = strchr(&vol->UNC[2], '\\');
2241 len = slash - &vol->UNC[2];
2242 if (!cifs_convert_address(dstaddr, &vol->UNC[2], len)) {
2243 pr_err("Unable to determine destination address\n");
2244 goto cifs_parse_mount_err;
2245 }
2246 }
2247
2248 /* set the port that we got earlier */
2249 cifs_set_port(dstaddr, port);
2250
2251 if (uid_specified)
2252 vol->override_uid = override_uid;
2253 else if (override_uid == 1)
2254 pr_notice("ignoring forceuid mount option specified with no uid= option\n");
2255
2256 if (gid_specified)
2257 vol->override_gid = override_gid;
2258 else if (override_gid == 1)
2259 pr_notice("ignoring forcegid mount option specified with no gid= option\n");
2260
2261 if (got_version == false)
2262 pr_warn_once("No dialect specified on mount. Default has changed to a more secure dialect, SMB2.1 or later (e.g. SMB3.1.1), from CIFS (SMB1). To use the less secure SMB1 dialect to access old servers which do not support SMB3.1.1 (or even SMB3 or SMB2.1) specify vers=1.0 on mount.\n");
2263
2264 kfree(mountdata_copy);
2265 return 0;
2266
2267 out_nomem:
2268 pr_warn("Could not allocate temporary buffer\n");
2269 cifs_parse_mount_err:
2270 kfree(string);
2271 kfree(mountdata_copy);
2272 return 1;
2273 }
2274
2275 /** Returns true if srcaddr isn't specified and rhs isn't
2276 * specified, or if srcaddr is specified and
2277 * matches the IP address of the rhs argument.
2278 */
2279 bool
2280 cifs_match_ipaddr(struct sockaddr *srcaddr, struct sockaddr *rhs)
2281 {
2282 switch (srcaddr->sa_family) {
2283 case AF_UNSPEC:
2284 return (rhs->sa_family == AF_UNSPEC);
2285 case AF_INET: {
2286 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
2287 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
2288 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
2289 }
2290 case AF_INET6: {
2291 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
2292 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
2293 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
2294 }
2295 default:
2296 WARN_ON(1);
2297 return false; /* don't expect to be here */
2298 }
2299 }
2300
2301 /*
2302 * If no port is specified in addr structure, we try to match with 445 port
2303 * and if it fails - with 139 ports. It should be called only if address
2304 * families of server and addr are equal.
2305 */
2306 static bool
2307 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
2308 {
2309 __be16 port, *sport;
2310
2311 /* SMBDirect manages its own ports, don't match it here */
2312 if (server->rdma)
2313 return true;
2314
2315 switch (addr->sa_family) {
2316 case AF_INET:
2317 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
2318 port = ((struct sockaddr_in *) addr)->sin_port;
2319 break;
2320 case AF_INET6:
2321 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
2322 port = ((struct sockaddr_in6 *) addr)->sin6_port;
2323 break;
2324 default:
2325 WARN_ON(1);
2326 return false;
2327 }
2328
2329 if (!port) {
2330 port = htons(CIFS_PORT);
2331 if (port == *sport)
2332 return true;
2333
2334 port = htons(RFC1001_PORT);
2335 }
2336
2337 return port == *sport;
2338 }
2339
2340 static bool
2341 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
2342 struct sockaddr *srcaddr)
2343 {
2344 switch (addr->sa_family) {
2345 case AF_INET: {
2346 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2347 struct sockaddr_in *srv_addr4 =
2348 (struct sockaddr_in *)&server->dstaddr;
2349
2350 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
2351 return false;
2352 break;
2353 }
2354 case AF_INET6: {
2355 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2356 struct sockaddr_in6 *srv_addr6 =
2357 (struct sockaddr_in6 *)&server->dstaddr;
2358
2359 if (!ipv6_addr_equal(&addr6->sin6_addr,
2360 &srv_addr6->sin6_addr))
2361 return false;
2362 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
2363 return false;
2364 break;
2365 }
2366 default:
2367 WARN_ON(1);
2368 return false; /* don't expect to be here */
2369 }
2370
2371 if (!cifs_match_ipaddr(srcaddr, (struct sockaddr *)&server->srcaddr))
2372 return false;
2373
2374 return true;
2375 }
2376
2377 static bool
2378 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2379 {
2380 /*
2381 * The select_sectype function should either return the vol->sectype
2382 * that was specified, or "Unspecified" if that sectype was not
2383 * compatible with the given NEGOTIATE request.
2384 */
2385 if (server->ops->select_sectype(server, vol->sectype)
2386 == Unspecified)
2387 return false;
2388
2389 /*
2390 * Now check if signing mode is acceptable. No need to check
2391 * global_secflags at this point since if MUST_SIGN is set then
2392 * the server->sign had better be too.
2393 */
2394 if (vol->sign && !server->sign)
2395 return false;
2396
2397 return true;
2398 }
2399
2400 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2401 {
2402 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2403
2404 if (vol->nosharesock)
2405 return 0;
2406
2407 /* If multidialect negotiation see if existing sessions match one */
2408 if (strcmp(vol->vals->version_string, SMB3ANY_VERSION_STRING) == 0) {
2409 if (server->vals->protocol_id < SMB30_PROT_ID)
2410 return 0;
2411 } else if (strcmp(vol->vals->version_string,
2412 SMBDEFAULT_VERSION_STRING) == 0) {
2413 if (server->vals->protocol_id < SMB21_PROT_ID)
2414 return 0;
2415 } else if ((server->vals != vol->vals) || (server->ops != vol->ops))
2416 return 0;
2417
2418 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2419 return 0;
2420
2421 if (!match_address(server, addr,
2422 (struct sockaddr *)&vol->srcaddr))
2423 return 0;
2424
2425 if (!match_port(server, addr))
2426 return 0;
2427
2428 if (!match_security(server, vol))
2429 return 0;
2430
2431 if (server->echo_interval != vol->echo_interval * HZ)
2432 return 0;
2433
2434 if (server->rdma != vol->rdma)
2435 return 0;
2436
2437 if (server->ignore_signature != vol->ignore_signature)
2438 return 0;
2439
2440 if (server->min_offload != vol->min_offload)
2441 return 0;
2442
2443 return 1;
2444 }
2445
2446 struct TCP_Server_Info *
2447 cifs_find_tcp_session(struct smb_vol *vol)
2448 {
2449 struct TCP_Server_Info *server;
2450
2451 spin_lock(&cifs_tcp_ses_lock);
2452 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2453 /*
2454 * Skip ses channels since they're only handled in lower layers
2455 * (e.g. cifs_send_recv).
2456 */
2457 if (server->is_channel || !match_server(server, vol))
2458 continue;
2459
2460 ++server->srv_count;
2461 spin_unlock(&cifs_tcp_ses_lock);
2462 cifs_dbg(FYI, "Existing tcp session with server found\n");
2463 return server;
2464 }
2465 spin_unlock(&cifs_tcp_ses_lock);
2466 return NULL;
2467 }
2468
2469 void
2470 cifs_put_tcp_session(struct TCP_Server_Info *server, int from_reconnect)
2471 {
2472 struct task_struct *task;
2473
2474 spin_lock(&cifs_tcp_ses_lock);
2475 if (--server->srv_count > 0) {
2476 spin_unlock(&cifs_tcp_ses_lock);
2477 return;
2478 }
2479
2480 put_net(cifs_net_ns(server));
2481
2482 list_del_init(&server->tcp_ses_list);
2483 spin_unlock(&cifs_tcp_ses_lock);
2484
2485 cancel_delayed_work_sync(&server->echo);
2486
2487 if (from_reconnect)
2488 /*
2489 * Avoid deadlock here: reconnect work calls
2490 * cifs_put_tcp_session() at its end. Need to be sure
2491 * that reconnect work does nothing with server pointer after
2492 * that step.
2493 */
2494 cancel_delayed_work(&server->reconnect);
2495 else
2496 cancel_delayed_work_sync(&server->reconnect);
2497
2498 spin_lock(&GlobalMid_Lock);
2499 server->tcpStatus = CifsExiting;
2500 spin_unlock(&GlobalMid_Lock);
2501
2502 cifs_crypto_secmech_release(server);
2503 cifs_fscache_release_client_cookie(server);
2504
2505 kfree(server->session_key.response);
2506 server->session_key.response = NULL;
2507 server->session_key.len = 0;
2508
2509 task = xchg(&server->tsk, NULL);
2510 if (task)
2511 send_sig(SIGKILL, task, 1);
2512 }
2513
2514 struct TCP_Server_Info *
2515 cifs_get_tcp_session(struct smb_vol *volume_info)
2516 {
2517 struct TCP_Server_Info *tcp_ses = NULL;
2518 int rc;
2519
2520 cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
2521
2522 /* see if we already have a matching tcp_ses */
2523 tcp_ses = cifs_find_tcp_session(volume_info);
2524 if (tcp_ses)
2525 return tcp_ses;
2526
2527 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2528 if (!tcp_ses) {
2529 rc = -ENOMEM;
2530 goto out_err;
2531 }
2532
2533 tcp_ses->ops = volume_info->ops;
2534 tcp_ses->vals = volume_info->vals;
2535 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2536 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2537 if (IS_ERR(tcp_ses->hostname)) {
2538 rc = PTR_ERR(tcp_ses->hostname);
2539 goto out_err_crypto_release;
2540 }
2541
2542 tcp_ses->noblockcnt = volume_info->rootfs;
2543 tcp_ses->noblocksnd = volume_info->noblocksnd || volume_info->rootfs;
2544 tcp_ses->noautotune = volume_info->noautotune;
2545 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2546 tcp_ses->rdma = volume_info->rdma;
2547 tcp_ses->in_flight = 0;
2548 tcp_ses->max_in_flight = 0;
2549 tcp_ses->credits = 1;
2550 init_waitqueue_head(&tcp_ses->response_q);
2551 init_waitqueue_head(&tcp_ses->request_q);
2552 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2553 mutex_init(&tcp_ses->srv_mutex);
2554 memcpy(tcp_ses->workstation_RFC1001_name,
2555 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2556 memcpy(tcp_ses->server_RFC1001_name,
2557 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2558 tcp_ses->session_estab = false;
2559 tcp_ses->sequence_number = 0;
2560 tcp_ses->reconnect_instance = 1;
2561 tcp_ses->lstrp = jiffies;
2562 tcp_ses->compress_algorithm = cpu_to_le16(volume_info->compression);
2563 spin_lock_init(&tcp_ses->req_lock);
2564 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2565 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2566 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2567 INIT_DELAYED_WORK(&tcp_ses->reconnect, smb2_reconnect_server);
2568 mutex_init(&tcp_ses->reconnect_mutex);
2569 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2570 sizeof(tcp_ses->srcaddr));
2571 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2572 sizeof(tcp_ses->dstaddr));
2573 if (volume_info->use_client_guid)
2574 memcpy(tcp_ses->client_guid, volume_info->client_guid,
2575 SMB2_CLIENT_GUID_SIZE);
2576 else
2577 generate_random_uuid(tcp_ses->client_guid);
2578 /*
2579 * at this point we are the only ones with the pointer
2580 * to the struct since the kernel thread not created yet
2581 * no need to spinlock this init of tcpStatus or srv_count
2582 */
2583 tcp_ses->tcpStatus = CifsNew;
2584 ++tcp_ses->srv_count;
2585
2586 if (volume_info->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
2587 volume_info->echo_interval <= SMB_ECHO_INTERVAL_MAX)
2588 tcp_ses->echo_interval = volume_info->echo_interval * HZ;
2589 else
2590 tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
2591 if (tcp_ses->rdma) {
2592 #ifndef CONFIG_CIFS_SMB_DIRECT
2593 cifs_dbg(VFS, "CONFIG_CIFS_SMB_DIRECT is not enabled\n");
2594 rc = -ENOENT;
2595 goto out_err_crypto_release;
2596 #endif
2597 tcp_ses->smbd_conn = smbd_get_connection(
2598 tcp_ses, (struct sockaddr *)&volume_info->dstaddr);
2599 if (tcp_ses->smbd_conn) {
2600 cifs_dbg(VFS, "RDMA transport established\n");
2601 rc = 0;
2602 goto smbd_connected;
2603 } else {
2604 rc = -ENOENT;
2605 goto out_err_crypto_release;
2606 }
2607 }
2608 rc = ip_connect(tcp_ses);
2609 if (rc < 0) {
2610 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
2611 goto out_err_crypto_release;
2612 }
2613 smbd_connected:
2614 /*
2615 * since we're in a cifs function already, we know that
2616 * this will succeed. No need for try_module_get().
2617 */
2618 __module_get(THIS_MODULE);
2619 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2620 tcp_ses, "cifsd");
2621 if (IS_ERR(tcp_ses->tsk)) {
2622 rc = PTR_ERR(tcp_ses->tsk);
2623 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
2624 module_put(THIS_MODULE);
2625 goto out_err_crypto_release;
2626 }
2627 tcp_ses->min_offload = volume_info->min_offload;
2628 tcp_ses->tcpStatus = CifsNeedNegotiate;
2629
2630 tcp_ses->nr_targets = 1;
2631 tcp_ses->ignore_signature = volume_info->ignore_signature;
2632 /* thread spawned, put it on the list */
2633 spin_lock(&cifs_tcp_ses_lock);
2634 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2635 spin_unlock(&cifs_tcp_ses_lock);
2636
2637 cifs_fscache_get_client_cookie(tcp_ses);
2638
2639 /* queue echo request delayed work */
2640 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
2641
2642 return tcp_ses;
2643
2644 out_err_crypto_release:
2645 cifs_crypto_secmech_release(tcp_ses);
2646
2647 put_net(cifs_net_ns(tcp_ses));
2648
2649 out_err:
2650 if (tcp_ses) {
2651 if (!IS_ERR(tcp_ses->hostname))
2652 kfree(tcp_ses->hostname);
2653 if (tcp_ses->ssocket)
2654 sock_release(tcp_ses->ssocket);
2655 kfree(tcp_ses);
2656 }
2657 return ERR_PTR(rc);
2658 }
2659
2660 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2661 {
2662 if (vol->sectype != Unspecified &&
2663 vol->sectype != ses->sectype)
2664 return 0;
2665
2666 /*
2667 * If an existing session is limited to less channels than
2668 * requested, it should not be reused
2669 */
2670 if (ses->chan_max < vol->max_channels)
2671 return 0;
2672
2673 switch (ses->sectype) {
2674 case Kerberos:
2675 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2676 return 0;
2677 break;
2678 default:
2679 /* NULL username means anonymous session */
2680 if (ses->user_name == NULL) {
2681 if (!vol->nullauth)
2682 return 0;
2683 break;
2684 }
2685
2686 /* anything else takes username/password */
2687 if (strncmp(ses->user_name,
2688 vol->username ? vol->username : "",
2689 CIFS_MAX_USERNAME_LEN))
2690 return 0;
2691 if ((vol->username && strlen(vol->username) != 0) &&
2692 ses->password != NULL &&
2693 strncmp(ses->password,
2694 vol->password ? vol->password : "",
2695 CIFS_MAX_PASSWORD_LEN))
2696 return 0;
2697 }
2698 return 1;
2699 }
2700
2701 /**
2702 * cifs_setup_ipc - helper to setup the IPC tcon for the session
2703 *
2704 * A new IPC connection is made and stored in the session
2705 * tcon_ipc. The IPC tcon has the same lifetime as the session.
2706 */
2707 static int
2708 cifs_setup_ipc(struct cifs_ses *ses, struct smb_vol *volume_info)
2709 {
2710 int rc = 0, xid;
2711 struct cifs_tcon *tcon;
2712 struct nls_table *nls_codepage;
2713 char unc[SERVER_NAME_LENGTH + sizeof("//x/IPC$")] = {0};
2714 bool seal = false;
2715 struct TCP_Server_Info *server = ses->server;
2716
2717 /*
2718 * If the mount request that resulted in the creation of the
2719 * session requires encryption, force IPC to be encrypted too.
2720 */
2721 if (volume_info->seal) {
2722 if (server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION)
2723 seal = true;
2724 else {
2725 cifs_server_dbg(VFS,
2726 "IPC: server doesn't support encryption\n");
2727 return -EOPNOTSUPP;
2728 }
2729 }
2730
2731 tcon = tconInfoAlloc();
2732 if (tcon == NULL)
2733 return -ENOMEM;
2734
2735 scnprintf(unc, sizeof(unc), "\\\\%s\\IPC$", server->hostname);
2736
2737 /* cannot fail */
2738 nls_codepage = load_nls_default();
2739
2740 xid = get_xid();
2741 tcon->ses = ses;
2742 tcon->ipc = true;
2743 tcon->seal = seal;
2744 rc = server->ops->tree_connect(xid, ses, unc, tcon, nls_codepage);
2745 free_xid(xid);
2746
2747 if (rc) {
2748 cifs_server_dbg(VFS, "failed to connect to IPC (rc=%d)\n", rc);
2749 tconInfoFree(tcon);
2750 goto out;
2751 }
2752
2753 cifs_dbg(FYI, "IPC tcon rc = %d ipc tid = %d\n", rc, tcon->tid);
2754
2755 ses->tcon_ipc = tcon;
2756 out:
2757 unload_nls(nls_codepage);
2758 return rc;
2759 }
2760
2761 /**
2762 * cifs_free_ipc - helper to release the session IPC tcon
2763 *
2764 * Needs to be called everytime a session is destroyed
2765 */
2766 static int
2767 cifs_free_ipc(struct cifs_ses *ses)
2768 {
2769 int rc = 0, xid;
2770 struct cifs_tcon *tcon = ses->tcon_ipc;
2771
2772 if (tcon == NULL)
2773 return 0;
2774
2775 if (ses->server->ops->tree_disconnect) {
2776 xid = get_xid();
2777 rc = ses->server->ops->tree_disconnect(xid, tcon);
2778 free_xid(xid);
2779 }
2780
2781 if (rc)
2782 cifs_dbg(FYI, "failed to disconnect IPC tcon (rc=%d)\n", rc);
2783
2784 tconInfoFree(tcon);
2785 ses->tcon_ipc = NULL;
2786 return rc;
2787 }
2788
2789 static struct cifs_ses *
2790 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2791 {
2792 struct cifs_ses *ses;
2793
2794 spin_lock(&cifs_tcp_ses_lock);
2795 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2796 if (ses->status == CifsExiting)
2797 continue;
2798 if (!match_session(ses, vol))
2799 continue;
2800 ++ses->ses_count;
2801 spin_unlock(&cifs_tcp_ses_lock);
2802 return ses;
2803 }
2804 spin_unlock(&cifs_tcp_ses_lock);
2805 return NULL;
2806 }
2807
2808 void cifs_put_smb_ses(struct cifs_ses *ses)
2809 {
2810 unsigned int rc, xid;
2811 struct TCP_Server_Info *server = ses->server;
2812
2813 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
2814
2815 spin_lock(&cifs_tcp_ses_lock);
2816 if (ses->status == CifsExiting) {
2817 spin_unlock(&cifs_tcp_ses_lock);
2818 return;
2819 }
2820 if (--ses->ses_count > 0) {
2821 spin_unlock(&cifs_tcp_ses_lock);
2822 return;
2823 }
2824 if (ses->status == CifsGood)
2825 ses->status = CifsExiting;
2826 spin_unlock(&cifs_tcp_ses_lock);
2827
2828 cifs_free_ipc(ses);
2829
2830 if (ses->status == CifsExiting && server->ops->logoff) {
2831 xid = get_xid();
2832 rc = server->ops->logoff(xid, ses);
2833 if (rc)
2834 cifs_server_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
2835 __func__, rc);
2836 _free_xid(xid);
2837 }
2838
2839 spin_lock(&cifs_tcp_ses_lock);
2840 list_del_init(&ses->smb_ses_list);
2841 spin_unlock(&cifs_tcp_ses_lock);
2842
2843 /* close any extra channels */
2844 if (ses->chan_count > 1) {
2845 int i;
2846
2847 for (i = 1; i < ses->chan_count; i++)
2848 cifs_put_tcp_session(ses->chans[i].server, 0);
2849 }
2850
2851 sesInfoFree(ses);
2852 cifs_put_tcp_session(server, 0);
2853 }
2854
2855 #ifdef CONFIG_KEYS
2856
2857 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2858 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2859
2860 /* Populate username and pw fields from keyring if possible */
2861 static int
2862 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2863 {
2864 int rc = 0;
2865 int is_domain = 0;
2866 const char *delim, *payload;
2867 char *desc;
2868 ssize_t len;
2869 struct key *key;
2870 struct TCP_Server_Info *server = ses->server;
2871 struct sockaddr_in *sa;
2872 struct sockaddr_in6 *sa6;
2873 const struct user_key_payload *upayload;
2874
2875 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2876 if (!desc)
2877 return -ENOMEM;
2878
2879 /* try to find an address key first */
2880 switch (server->dstaddr.ss_family) {
2881 case AF_INET:
2882 sa = (struct sockaddr_in *)&server->dstaddr;
2883 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2884 break;
2885 case AF_INET6:
2886 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2887 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2888 break;
2889 default:
2890 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2891 server->dstaddr.ss_family);
2892 rc = -EINVAL;
2893 goto out_err;
2894 }
2895
2896 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2897 key = request_key(&key_type_logon, desc, "");
2898 if (IS_ERR(key)) {
2899 if (!ses->domainName) {
2900 cifs_dbg(FYI, "domainName is NULL\n");
2901 rc = PTR_ERR(key);
2902 goto out_err;
2903 }
2904
2905 /* didn't work, try to find a domain key */
2906 sprintf(desc, "cifs:d:%s", ses->domainName);
2907 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2908 key = request_key(&key_type_logon, desc, "");
2909 if (IS_ERR(key)) {
2910 rc = PTR_ERR(key);
2911 goto out_err;
2912 }
2913 is_domain = 1;
2914 }
2915
2916 down_read(&key->sem);
2917 upayload = user_key_payload_locked(key);
2918 if (IS_ERR_OR_NULL(upayload)) {
2919 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2920 goto out_key_put;
2921 }
2922
2923 /* find first : in payload */
2924 payload = upayload->data;
2925 delim = strnchr(payload, upayload->datalen, ':');
2926 cifs_dbg(FYI, "payload=%s\n", payload);
2927 if (!delim) {
2928 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
2929 upayload->datalen);
2930 rc = -EINVAL;
2931 goto out_key_put;
2932 }
2933
2934 len = delim - payload;
2935 if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
2936 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
2937 len);
2938 rc = -EINVAL;
2939 goto out_key_put;
2940 }
2941
2942 vol->username = kstrndup(payload, len, GFP_KERNEL);
2943 if (!vol->username) {
2944 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
2945 len);
2946 rc = -ENOMEM;
2947 goto out_key_put;
2948 }
2949 cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
2950
2951 len = key->datalen - (len + 1);
2952 if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
2953 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
2954 rc = -EINVAL;
2955 kfree(vol->username);
2956 vol->username = NULL;
2957 goto out_key_put;
2958 }
2959
2960 ++delim;
2961 vol->password = kstrndup(delim, len, GFP_KERNEL);
2962 if (!vol->password) {
2963 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
2964 len);
2965 rc = -ENOMEM;
2966 kfree(vol->username);
2967 vol->username = NULL;
2968 goto out_key_put;
2969 }
2970
2971 /*
2972 * If we have a domain key then we must set the domainName in the
2973 * for the request.
2974 */
2975 if (is_domain && ses->domainName) {
2976 vol->domainname = kstrndup(ses->domainName,
2977 strlen(ses->domainName),
2978 GFP_KERNEL);
2979 if (!vol->domainname) {
2980 cifs_dbg(FYI, "Unable to allocate %zd bytes for domain\n",
2981 len);
2982 rc = -ENOMEM;
2983 kfree(vol->username);
2984 vol->username = NULL;
2985 kfree_sensitive(vol->password);
2986 vol->password = NULL;
2987 goto out_key_put;
2988 }
2989 }
2990
2991 out_key_put:
2992 up_read(&key->sem);
2993 key_put(key);
2994 out_err:
2995 kfree(desc);
2996 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
2997 return rc;
2998 }
2999 #else /* ! CONFIG_KEYS */
3000 static inline int
3001 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
3002 struct cifs_ses *ses __attribute__((unused)))
3003 {
3004 return -ENOSYS;
3005 }
3006 #endif /* CONFIG_KEYS */
3007
3008 /**
3009 * cifs_get_smb_ses - get a session matching @volume_info data from @server
3010 *
3011 * This function assumes it is being called from cifs_mount() where we
3012 * already got a server reference (server refcount +1). See
3013 * cifs_get_tcon() for refcount explanations.
3014 */
3015 struct cifs_ses *
3016 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
3017 {
3018 int rc = -ENOMEM;
3019 unsigned int xid;
3020 struct cifs_ses *ses;
3021 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3022 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3023
3024 xid = get_xid();
3025
3026 ses = cifs_find_smb_ses(server, volume_info);
3027 if (ses) {
3028 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
3029 ses->status);
3030
3031 mutex_lock(&ses->session_mutex);
3032 rc = cifs_negotiate_protocol(xid, ses);
3033 if (rc) {
3034 mutex_unlock(&ses->session_mutex);
3035 /* problem -- put our ses reference */
3036 cifs_put_smb_ses(ses);
3037 free_xid(xid);
3038 return ERR_PTR(rc);
3039 }
3040 if (ses->need_reconnect) {
3041 cifs_dbg(FYI, "Session needs reconnect\n");
3042 rc = cifs_setup_session(xid, ses,
3043 volume_info->local_nls);
3044 if (rc) {
3045 mutex_unlock(&ses->session_mutex);
3046 /* problem -- put our reference */
3047 cifs_put_smb_ses(ses);
3048 free_xid(xid);
3049 return ERR_PTR(rc);
3050 }
3051 }
3052 mutex_unlock(&ses->session_mutex);
3053
3054 /* existing SMB ses has a server reference already */
3055 cifs_put_tcp_session(server, 0);
3056 free_xid(xid);
3057 return ses;
3058 }
3059
3060 cifs_dbg(FYI, "Existing smb sess not found\n");
3061 ses = sesInfoAlloc();
3062 if (ses == NULL)
3063 goto get_ses_fail;
3064
3065 /* new SMB session uses our server ref */
3066 ses->server = server;
3067 if (server->dstaddr.ss_family == AF_INET6)
3068 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
3069 else
3070 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
3071
3072 if (volume_info->username) {
3073 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
3074 if (!ses->user_name)
3075 goto get_ses_fail;
3076 }
3077
3078 /* volume_info->password freed at unmount */
3079 if (volume_info->password) {
3080 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
3081 if (!ses->password)
3082 goto get_ses_fail;
3083 }
3084 if (volume_info->domainname) {
3085 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
3086 if (!ses->domainName)
3087 goto get_ses_fail;
3088 }
3089 if (volume_info->domainauto)
3090 ses->domainAuto = volume_info->domainauto;
3091 ses->cred_uid = volume_info->cred_uid;
3092 ses->linux_uid = volume_info->linux_uid;
3093
3094 ses->sectype = volume_info->sectype;
3095 ses->sign = volume_info->sign;
3096 mutex_lock(&ses->session_mutex);
3097
3098 /* add server as first channel */
3099 ses->chans[0].server = server;
3100 ses->chan_count = 1;
3101 ses->chan_max = volume_info->multichannel ? volume_info->max_channels:1;
3102
3103 rc = cifs_negotiate_protocol(xid, ses);
3104 if (!rc)
3105 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
3106
3107 /* each channel uses a different signing key */
3108 memcpy(ses->chans[0].signkey, ses->smb3signingkey,
3109 sizeof(ses->smb3signingkey));
3110
3111 mutex_unlock(&ses->session_mutex);
3112 if (rc)
3113 goto get_ses_fail;
3114
3115 /* success, put it on the list and add it as first channel */
3116 spin_lock(&cifs_tcp_ses_lock);
3117 list_add(&ses->smb_ses_list, &server->smb_ses_list);
3118 spin_unlock(&cifs_tcp_ses_lock);
3119
3120 free_xid(xid);
3121
3122 cifs_setup_ipc(ses, volume_info);
3123
3124 return ses;
3125
3126 get_ses_fail:
3127 sesInfoFree(ses);
3128 free_xid(xid);
3129 return ERR_PTR(rc);
3130 }
3131
3132 static int match_tcon(struct cifs_tcon *tcon, struct smb_vol *volume_info)
3133 {
3134 if (tcon->tidStatus == CifsExiting)
3135 return 0;
3136 if (strncmp(tcon->treeName, volume_info->UNC, MAX_TREE_SIZE))
3137 return 0;
3138 if (tcon->seal != volume_info->seal)
3139 return 0;
3140 if (tcon->snapshot_time != volume_info->snapshot_time)
3141 return 0;
3142 if (tcon->handle_timeout != volume_info->handle_timeout)
3143 return 0;
3144 if (tcon->no_lease != volume_info->no_lease)
3145 return 0;
3146 if (tcon->nodelete != volume_info->nodelete)
3147 return 0;
3148 return 1;
3149 }
3150
3151 static struct cifs_tcon *
3152 cifs_find_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
3153 {
3154 struct list_head *tmp;
3155 struct cifs_tcon *tcon;
3156
3157 spin_lock(&cifs_tcp_ses_lock);
3158 list_for_each(tmp, &ses->tcon_list) {
3159 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
3160 #ifdef CONFIG_CIFS_DFS_UPCALL
3161 if (tcon->dfs_path)
3162 continue;
3163 #endif
3164 if (!match_tcon(tcon, volume_info))
3165 continue;
3166 ++tcon->tc_count;
3167 spin_unlock(&cifs_tcp_ses_lock);
3168 return tcon;
3169 }
3170 spin_unlock(&cifs_tcp_ses_lock);
3171 return NULL;
3172 }
3173
3174 void
3175 cifs_put_tcon(struct cifs_tcon *tcon)
3176 {
3177 unsigned int xid;
3178 struct cifs_ses *ses;
3179
3180 /*
3181 * IPC tcon share the lifetime of their session and are
3182 * destroyed in the session put function
3183 */
3184 if (tcon == NULL || tcon->ipc)
3185 return;
3186
3187 ses = tcon->ses;
3188 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
3189 spin_lock(&cifs_tcp_ses_lock);
3190 if (--tcon->tc_count > 0) {
3191 spin_unlock(&cifs_tcp_ses_lock);
3192 return;
3193 }
3194
3195 list_del_init(&tcon->tcon_list);
3196 spin_unlock(&cifs_tcp_ses_lock);
3197
3198 xid = get_xid();
3199 if (ses->server->ops->tree_disconnect)
3200 ses->server->ops->tree_disconnect(xid, tcon);
3201 _free_xid(xid);
3202
3203 cifs_fscache_release_super_cookie(tcon);
3204 tconInfoFree(tcon);
3205 cifs_put_smb_ses(ses);
3206 }
3207
3208 /**
3209 * cifs_get_tcon - get a tcon matching @volume_info data from @ses
3210 *
3211 * - tcon refcount is the number of mount points using the tcon.
3212 * - ses refcount is the number of tcon using the session.
3213 *
3214 * 1. This function assumes it is being called from cifs_mount() where
3215 * we already got a session reference (ses refcount +1).
3216 *
3217 * 2. Since we're in the context of adding a mount point, the end
3218 * result should be either:
3219 *
3220 * a) a new tcon already allocated with refcount=1 (1 mount point) and
3221 * its session refcount incremented (1 new tcon). This +1 was
3222 * already done in (1).
3223 *
3224 * b) an existing tcon with refcount+1 (add a mount point to it) and
3225 * identical ses refcount (no new tcon). Because of (1) we need to
3226 * decrement the ses refcount.
3227 */
3228 static struct cifs_tcon *
3229 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
3230 {
3231 int rc, xid;
3232 struct cifs_tcon *tcon;
3233
3234 tcon = cifs_find_tcon(ses, volume_info);
3235 if (tcon) {
3236 /*
3237 * tcon has refcount already incremented but we need to
3238 * decrement extra ses reference gotten by caller (case b)
3239 */
3240 cifs_dbg(FYI, "Found match on UNC path\n");
3241 cifs_put_smb_ses(ses);
3242 return tcon;
3243 }
3244
3245 if (!ses->server->ops->tree_connect) {
3246 rc = -ENOSYS;
3247 goto out_fail;
3248 }
3249
3250 tcon = tconInfoAlloc();
3251 if (tcon == NULL) {
3252 rc = -ENOMEM;
3253 goto out_fail;
3254 }
3255
3256 if (volume_info->snapshot_time) {
3257 if (ses->server->vals->protocol_id == 0) {
3258 cifs_dbg(VFS,
3259 "Use SMB2 or later for snapshot mount option\n");
3260 rc = -EOPNOTSUPP;
3261 goto out_fail;
3262 } else
3263 tcon->snapshot_time = volume_info->snapshot_time;
3264 }
3265
3266 if (volume_info->handle_timeout) {
3267 if (ses->server->vals->protocol_id == 0) {
3268 cifs_dbg(VFS,
3269 "Use SMB2.1 or later for handle timeout option\n");
3270 rc = -EOPNOTSUPP;
3271 goto out_fail;
3272 } else
3273 tcon->handle_timeout = volume_info->handle_timeout;
3274 }
3275
3276 tcon->ses = ses;
3277 if (volume_info->password) {
3278 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
3279 if (!tcon->password) {
3280 rc = -ENOMEM;
3281 goto out_fail;
3282 }
3283 }
3284
3285 if (volume_info->seal) {
3286 if (ses->server->vals->protocol_id == 0) {
3287 cifs_dbg(VFS,
3288 "SMB3 or later required for encryption\n");
3289 rc = -EOPNOTSUPP;
3290 goto out_fail;
3291 } else if (tcon->ses->server->capabilities &
3292 SMB2_GLOBAL_CAP_ENCRYPTION)
3293 tcon->seal = true;
3294 else {
3295 cifs_dbg(VFS, "Encryption is not supported on share\n");
3296 rc = -EOPNOTSUPP;
3297 goto out_fail;
3298 }
3299 }
3300
3301 if (volume_info->linux_ext) {
3302 if (ses->server->posix_ext_supported) {
3303 tcon->posix_extensions = true;
3304 pr_warn_once("SMB3.11 POSIX Extensions are experimental\n");
3305 } else {
3306 cifs_dbg(VFS, "Server does not support mounting with posix SMB3.11 extensions\n");
3307 rc = -EOPNOTSUPP;
3308 goto out_fail;
3309 }
3310 }
3311
3312 /*
3313 * BB Do we need to wrap session_mutex around this TCon call and Unix
3314 * SetFS as we do on SessSetup and reconnect?
3315 */
3316 xid = get_xid();
3317 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
3318 volume_info->local_nls);
3319 free_xid(xid);
3320 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
3321 if (rc)
3322 goto out_fail;
3323
3324 tcon->use_persistent = false;
3325 /* check if SMB2 or later, CIFS does not support persistent handles */
3326 if (volume_info->persistent) {
3327 if (ses->server->vals->protocol_id == 0) {
3328 cifs_dbg(VFS,
3329 "SMB3 or later required for persistent handles\n");
3330 rc = -EOPNOTSUPP;
3331 goto out_fail;
3332 } else if (ses->server->capabilities &
3333 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
3334 tcon->use_persistent = true;
3335 else /* persistent handles requested but not supported */ {
3336 cifs_dbg(VFS,
3337 "Persistent handles not supported on share\n");
3338 rc = -EOPNOTSUPP;
3339 goto out_fail;
3340 }
3341 } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
3342 && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
3343 && (volume_info->nopersistent == false)) {
3344 cifs_dbg(FYI, "enabling persistent handles\n");
3345 tcon->use_persistent = true;
3346 } else if (volume_info->resilient) {
3347 if (ses->server->vals->protocol_id == 0) {
3348 cifs_dbg(VFS,
3349 "SMB2.1 or later required for resilient handles\n");
3350 rc = -EOPNOTSUPP;
3351 goto out_fail;
3352 }
3353 tcon->use_resilient = true;
3354 }
3355
3356 /* If the user really knows what they are doing they can override */
3357 if (tcon->share_flags & SMB2_SHAREFLAG_NO_CACHING) {
3358 if (volume_info->cache_ro)
3359 cifs_dbg(VFS, "cache=ro requested on mount but NO_CACHING flag set on share\n");
3360 else if (volume_info->cache_rw)
3361 cifs_dbg(VFS, "cache=singleclient requested on mount but NO_CACHING flag set on share\n");
3362 }
3363
3364 if (volume_info->no_lease) {
3365 if (ses->server->vals->protocol_id == 0) {
3366 cifs_dbg(VFS,
3367 "SMB2 or later required for nolease option\n");
3368 rc = -EOPNOTSUPP;
3369 goto out_fail;
3370 } else
3371 tcon->no_lease = volume_info->no_lease;
3372 }
3373
3374 /*
3375 * We can have only one retry value for a connection to a share so for
3376 * resources mounted more than once to the same server share the last
3377 * value passed in for the retry flag is used.
3378 */
3379 tcon->retry = volume_info->retry;
3380 tcon->nocase = volume_info->nocase;
3381 if (ses->server->capabilities & SMB2_GLOBAL_CAP_DIRECTORY_LEASING)
3382 tcon->nohandlecache = volume_info->nohandlecache;
3383 else
3384 tcon->nohandlecache = 1;
3385 tcon->nodelete = volume_info->nodelete;
3386 tcon->local_lease = volume_info->local_lease;
3387 INIT_LIST_HEAD(&tcon->pending_opens);
3388
3389 spin_lock(&cifs_tcp_ses_lock);
3390 list_add(&tcon->tcon_list, &ses->tcon_list);
3391 spin_unlock(&cifs_tcp_ses_lock);
3392
3393 cifs_fscache_get_super_cookie(tcon);
3394
3395 return tcon;
3396
3397 out_fail:
3398 tconInfoFree(tcon);
3399 return ERR_PTR(rc);
3400 }
3401
3402 void
3403 cifs_put_tlink(struct tcon_link *tlink)
3404 {
3405 if (!tlink || IS_ERR(tlink))
3406 return;
3407
3408 if (!atomic_dec_and_test(&tlink->tl_count) ||
3409 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
3410 tlink->tl_time = jiffies;
3411 return;
3412 }
3413
3414 if (!IS_ERR(tlink_tcon(tlink)))
3415 cifs_put_tcon(tlink_tcon(tlink));
3416 kfree(tlink);
3417 return;
3418 }
3419
3420 static int
3421 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
3422 {
3423 struct cifs_sb_info *old = CIFS_SB(sb);
3424 struct cifs_sb_info *new = mnt_data->cifs_sb;
3425 unsigned int oldflags = old->mnt_cifs_flags & CIFS_MOUNT_MASK;
3426 unsigned int newflags = new->mnt_cifs_flags & CIFS_MOUNT_MASK;
3427
3428 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
3429 return 0;
3430
3431 if (old->mnt_cifs_serverino_autodisabled)
3432 newflags &= ~CIFS_MOUNT_SERVER_INUM;
3433
3434 if (oldflags != newflags)
3435 return 0;
3436
3437 /*
3438 * We want to share sb only if we don't specify an r/wsize or
3439 * specified r/wsize is greater than or equal to existing one.
3440 */
3441 if (new->wsize && new->wsize < old->wsize)
3442 return 0;
3443
3444 if (new->rsize && new->rsize < old->rsize)
3445 return 0;
3446
3447 if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
3448 return 0;
3449
3450 if (old->mnt_file_mode != new->mnt_file_mode ||
3451 old->mnt_dir_mode != new->mnt_dir_mode)
3452 return 0;
3453
3454 if (strcmp(old->local_nls->charset, new->local_nls->charset))
3455 return 0;
3456
3457 if (old->actimeo != new->actimeo)
3458 return 0;
3459
3460 return 1;
3461 }
3462
3463 static int
3464 match_prepath(struct super_block *sb, struct cifs_mnt_data *mnt_data)
3465 {
3466 struct cifs_sb_info *old = CIFS_SB(sb);
3467 struct cifs_sb_info *new = mnt_data->cifs_sb;
3468 bool old_set = (old->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) &&
3469 old->prepath;
3470 bool new_set = (new->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) &&
3471 new->prepath;
3472
3473 if (old_set && new_set && !strcmp(new->prepath, old->prepath))
3474 return 1;
3475 else if (!old_set && !new_set)
3476 return 1;
3477
3478 return 0;
3479 }
3480
3481 int
3482 cifs_match_super(struct super_block *sb, void *data)
3483 {
3484 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
3485 struct smb_vol *volume_info;
3486 struct cifs_sb_info *cifs_sb;
3487 struct TCP_Server_Info *tcp_srv;
3488 struct cifs_ses *ses;
3489 struct cifs_tcon *tcon;
3490 struct tcon_link *tlink;
3491 int rc = 0;
3492
3493 spin_lock(&cifs_tcp_ses_lock);
3494 cifs_sb = CIFS_SB(sb);
3495 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3496 if (IS_ERR(tlink)) {
3497 spin_unlock(&cifs_tcp_ses_lock);
3498 return rc;
3499 }
3500 tcon = tlink_tcon(tlink);
3501 ses = tcon->ses;
3502 tcp_srv = ses->server;
3503
3504 volume_info = mnt_data->vol;
3505
3506 if (!match_server(tcp_srv, volume_info) ||
3507 !match_session(ses, volume_info) ||
3508 !match_tcon(tcon, volume_info) ||
3509 !match_prepath(sb, mnt_data)) {
3510 rc = 0;
3511 goto out;
3512 }
3513
3514 rc = compare_mount_options(sb, mnt_data);
3515 out:
3516 spin_unlock(&cifs_tcp_ses_lock);
3517 cifs_put_tlink(tlink);
3518 return rc;
3519 }
3520
3521 #ifdef CONFIG_DEBUG_LOCK_ALLOC
3522 static struct lock_class_key cifs_key[2];
3523 static struct lock_class_key cifs_slock_key[2];
3524
3525 static inline void
3526 cifs_reclassify_socket4(struct socket *sock)
3527 {
3528 struct sock *sk = sock->sk;
3529 BUG_ON(!sock_allow_reclassification(sk));
3530 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
3531 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
3532 }
3533
3534 static inline void
3535 cifs_reclassify_socket6(struct socket *sock)
3536 {
3537 struct sock *sk = sock->sk;
3538 BUG_ON(!sock_allow_reclassification(sk));
3539 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
3540 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
3541 }
3542 #else
3543 static inline void
3544 cifs_reclassify_socket4(struct socket *sock)
3545 {
3546 }
3547
3548 static inline void
3549 cifs_reclassify_socket6(struct socket *sock)
3550 {
3551 }
3552 #endif
3553
3554 /* See RFC1001 section 14 on representation of Netbios names */
3555 static void rfc1002mangle(char *target, char *source, unsigned int length)
3556 {
3557 unsigned int i, j;
3558
3559 for (i = 0, j = 0; i < (length); i++) {
3560 /* mask a nibble at a time and encode */
3561 target[j] = 'A' + (0x0F & (source[i] >> 4));
3562 target[j+1] = 'A' + (0x0F & source[i]);
3563 j += 2;
3564 }
3565
3566 }
3567
3568 static int
3569 bind_socket(struct TCP_Server_Info *server)
3570 {
3571 int rc = 0;
3572 if (server->srcaddr.ss_family != AF_UNSPEC) {
3573 /* Bind to the specified local IP address */
3574 struct socket *socket = server->ssocket;
3575 rc = socket->ops->bind(socket,
3576 (struct sockaddr *) &server->srcaddr,
3577 sizeof(server->srcaddr));
3578 if (rc < 0) {
3579 struct sockaddr_in *saddr4;
3580 struct sockaddr_in6 *saddr6;
3581 saddr4 = (struct sockaddr_in *)&server->srcaddr;
3582 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
3583 if (saddr6->sin6_family == AF_INET6)
3584 cifs_server_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
3585 &saddr6->sin6_addr, rc);
3586 else
3587 cifs_server_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
3588 &saddr4->sin_addr.s_addr, rc);
3589 }
3590 }
3591 return rc;
3592 }
3593
3594 static int
3595 ip_rfc1001_connect(struct TCP_Server_Info *server)
3596 {
3597 int rc = 0;
3598 /*
3599 * some servers require RFC1001 sessinit before sending
3600 * negprot - BB check reconnection in case where second
3601 * sessinit is sent but no second negprot
3602 */
3603 struct rfc1002_session_packet *ses_init_buf;
3604 struct smb_hdr *smb_buf;
3605 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
3606 GFP_KERNEL);
3607 if (ses_init_buf) {
3608 ses_init_buf->trailer.session_req.called_len = 32;
3609
3610 if (server->server_RFC1001_name[0] != 0)
3611 rfc1002mangle(ses_init_buf->trailer.
3612 session_req.called_name,
3613 server->server_RFC1001_name,
3614 RFC1001_NAME_LEN_WITH_NULL);
3615 else
3616 rfc1002mangle(ses_init_buf->trailer.
3617 session_req.called_name,
3618 DEFAULT_CIFS_CALLED_NAME,
3619 RFC1001_NAME_LEN_WITH_NULL);
3620
3621 ses_init_buf->trailer.session_req.calling_len = 32;
3622
3623 /*
3624 * calling name ends in null (byte 16) from old smb
3625 * convention.
3626 */
3627 if (server->workstation_RFC1001_name[0] != 0)
3628 rfc1002mangle(ses_init_buf->trailer.
3629 session_req.calling_name,
3630 server->workstation_RFC1001_name,
3631 RFC1001_NAME_LEN_WITH_NULL);
3632 else
3633 rfc1002mangle(ses_init_buf->trailer.
3634 session_req.calling_name,
3635 "LINUX_CIFS_CLNT",
3636 RFC1001_NAME_LEN_WITH_NULL);
3637
3638 ses_init_buf->trailer.session_req.scope1 = 0;
3639 ses_init_buf->trailer.session_req.scope2 = 0;
3640 smb_buf = (struct smb_hdr *)ses_init_buf;
3641
3642 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3643 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3644 rc = smb_send(server, smb_buf, 0x44);
3645 kfree(ses_init_buf);
3646 /*
3647 * RFC1001 layer in at least one server
3648 * requires very short break before negprot
3649 * presumably because not expecting negprot
3650 * to follow so fast. This is a simple
3651 * solution that works without
3652 * complicating the code and causes no
3653 * significant slowing down on mount
3654 * for everyone else
3655 */
3656 usleep_range(1000, 2000);
3657 }
3658 /*
3659 * else the negprot may still work without this
3660 * even though malloc failed
3661 */
3662
3663 return rc;
3664 }
3665
3666 static int
3667 generic_ip_connect(struct TCP_Server_Info *server)
3668 {
3669 int rc = 0;
3670 __be16 sport;
3671 int slen, sfamily;
3672 struct socket *socket = server->ssocket;
3673 struct sockaddr *saddr;
3674
3675 saddr = (struct sockaddr *) &server->dstaddr;
3676
3677 if (server->dstaddr.ss_family == AF_INET6) {
3678 struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)&server->dstaddr;
3679
3680 sport = ipv6->sin6_port;
3681 slen = sizeof(struct sockaddr_in6);
3682 sfamily = AF_INET6;
3683 cifs_dbg(FYI, "%s: connecting to [%pI6]:%d\n", __func__, &ipv6->sin6_addr,
3684 ntohs(sport));
3685 } else {
3686 struct sockaddr_in *ipv4 = (struct sockaddr_in *)&server->dstaddr;
3687
3688 sport = ipv4->sin_port;
3689 slen = sizeof(struct sockaddr_in);
3690 sfamily = AF_INET;
3691 cifs_dbg(FYI, "%s: connecting to %pI4:%d\n", __func__, &ipv4->sin_addr,
3692 ntohs(sport));
3693 }
3694
3695 if (socket == NULL) {
3696 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3697 IPPROTO_TCP, &socket, 1);
3698 if (rc < 0) {
3699 cifs_server_dbg(VFS, "Error %d creating socket\n", rc);
3700 server->ssocket = NULL;
3701 return rc;
3702 }
3703
3704 /* BB other socket options to set KEEPALIVE, NODELAY? */
3705 cifs_dbg(FYI, "Socket created\n");
3706 server->ssocket = socket;
3707 socket->sk->sk_allocation = GFP_NOFS;
3708 if (sfamily == AF_INET6)
3709 cifs_reclassify_socket6(socket);
3710 else
3711 cifs_reclassify_socket4(socket);
3712 }
3713
3714 rc = bind_socket(server);
3715 if (rc < 0)
3716 return rc;
3717
3718 /*
3719 * Eventually check for other socket options to change from
3720 * the default. sock_setsockopt not used because it expects
3721 * user space buffer
3722 */
3723 socket->sk->sk_rcvtimeo = 7 * HZ;
3724 socket->sk->sk_sndtimeo = 5 * HZ;
3725
3726 /* make the bufsizes depend on wsize/rsize and max requests */
3727 if (server->noautotune) {
3728 if (socket->sk->sk_sndbuf < (200 * 1024))
3729 socket->sk->sk_sndbuf = 200 * 1024;
3730 if (socket->sk->sk_rcvbuf < (140 * 1024))
3731 socket->sk->sk_rcvbuf = 140 * 1024;
3732 }
3733
3734 if (server->tcp_nodelay)
3735 tcp_sock_set_nodelay(socket->sk);
3736
3737 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3738 socket->sk->sk_sndbuf,
3739 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3740
3741 rc = socket->ops->connect(socket, saddr, slen,
3742 server->noblockcnt ? O_NONBLOCK : 0);
3743 /*
3744 * When mounting SMB root file systems, we do not want to block in
3745 * connect. Otherwise bail out and then let cifs_reconnect() perform
3746 * reconnect failover - if possible.
3747 */
3748 if (server->noblockcnt && rc == -EINPROGRESS)
3749 rc = 0;
3750 if (rc < 0) {
3751 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3752 sock_release(socket);
3753 server->ssocket = NULL;
3754 return rc;
3755 }
3756
3757 if (sport == htons(RFC1001_PORT))
3758 rc = ip_rfc1001_connect(server);
3759
3760 return rc;
3761 }
3762
3763 static int
3764 ip_connect(struct TCP_Server_Info *server)
3765 {
3766 __be16 *sport;
3767 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3768 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3769
3770 if (server->dstaddr.ss_family == AF_INET6)
3771 sport = &addr6->sin6_port;
3772 else
3773 sport = &addr->sin_port;
3774
3775 if (*sport == 0) {
3776 int rc;
3777
3778 /* try with 445 port at first */
3779 *sport = htons(CIFS_PORT);
3780
3781 rc = generic_ip_connect(server);
3782 if (rc >= 0)
3783 return rc;
3784
3785 /* if it failed, try with 139 port */
3786 *sport = htons(RFC1001_PORT);
3787 }
3788
3789 return generic_ip_connect(server);
3790 }
3791
3792 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3793 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3794 {
3795 /* if we are reconnecting then should we check to see if
3796 * any requested capabilities changed locally e.g. via
3797 * remount but we can not do much about it here
3798 * if they have (even if we could detect it by the following)
3799 * Perhaps we could add a backpointer to array of sb from tcon
3800 * or if we change to make all sb to same share the same
3801 * sb as NFS - then we only have one backpointer to sb.
3802 * What if we wanted to mount the server share twice once with
3803 * and once without posixacls or posix paths? */
3804 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3805
3806 if (vol_info && vol_info->no_linux_ext) {
3807 tcon->fsUnixInfo.Capability = 0;
3808 tcon->unix_ext = 0; /* Unix Extensions disabled */
3809 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
3810 return;
3811 } else if (vol_info)
3812 tcon->unix_ext = 1; /* Unix Extensions supported */
3813
3814 if (tcon->unix_ext == 0) {
3815 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
3816 return;
3817 }
3818
3819 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3820 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3821 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
3822 /* check for reconnect case in which we do not
3823 want to change the mount behavior if we can avoid it */
3824 if (vol_info == NULL) {
3825 /* turn off POSIX ACL and PATHNAMES if not set
3826 originally at mount time */
3827 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3828 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3829 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3830 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3831 cifs_dbg(VFS, "POSIXPATH support change\n");
3832 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3833 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3834 cifs_dbg(VFS, "possible reconnect error\n");
3835 cifs_dbg(VFS, "server disabled POSIX path support\n");
3836 }
3837 }
3838
3839 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3840 cifs_dbg(VFS, "per-share encryption not supported yet\n");
3841
3842 cap &= CIFS_UNIX_CAP_MASK;
3843 if (vol_info && vol_info->no_psx_acl)
3844 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3845 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3846 cifs_dbg(FYI, "negotiated posix acl support\n");
3847 if (cifs_sb)
3848 cifs_sb->mnt_cifs_flags |=
3849 CIFS_MOUNT_POSIXACL;
3850 }
3851
3852 if (vol_info && vol_info->posix_paths == 0)
3853 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3854 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3855 cifs_dbg(FYI, "negotiate posix pathnames\n");
3856 if (cifs_sb)
3857 cifs_sb->mnt_cifs_flags |=
3858 CIFS_MOUNT_POSIX_PATHS;
3859 }
3860
3861 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
3862 #ifdef CONFIG_CIFS_DEBUG2
3863 if (cap & CIFS_UNIX_FCNTL_CAP)
3864 cifs_dbg(FYI, "FCNTL cap\n");
3865 if (cap & CIFS_UNIX_EXTATTR_CAP)
3866 cifs_dbg(FYI, "EXTATTR cap\n");
3867 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3868 cifs_dbg(FYI, "POSIX path cap\n");
3869 if (cap & CIFS_UNIX_XATTR_CAP)
3870 cifs_dbg(FYI, "XATTR cap\n");
3871 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3872 cifs_dbg(FYI, "POSIX ACL cap\n");
3873 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3874 cifs_dbg(FYI, "very large read cap\n");
3875 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3876 cifs_dbg(FYI, "very large write cap\n");
3877 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3878 cifs_dbg(FYI, "transport encryption cap\n");
3879 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3880 cifs_dbg(FYI, "mandatory transport encryption cap\n");
3881 #endif /* CIFS_DEBUG2 */
3882 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3883 if (vol_info == NULL) {
3884 cifs_dbg(FYI, "resetting capabilities failed\n");
3885 } else
3886 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");
3887
3888 }
3889 }
3890 }
3891
3892 int cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3893 struct cifs_sb_info *cifs_sb)
3894 {
3895 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3896
3897 spin_lock_init(&cifs_sb->tlink_tree_lock);
3898 cifs_sb->tlink_tree = RB_ROOT;
3899
3900 cifs_sb->bsize = pvolume_info->bsize;
3901 /*
3902 * Temporarily set r/wsize for matching superblock. If we end up using
3903 * new sb then client will later negotiate it downward if needed.
3904 */
3905 cifs_sb->rsize = pvolume_info->rsize;
3906 cifs_sb->wsize = pvolume_info->wsize;
3907
3908 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3909 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3910 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3911 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3912 cifs_dbg(FYI, "file mode: %04ho dir mode: %04ho\n",
3913 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3914
3915 cifs_sb->actimeo = pvolume_info->actimeo;
3916 cifs_sb->local_nls = pvolume_info->local_nls;
3917
3918 if (pvolume_info->nodfs)
3919 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_DFS;
3920 if (pvolume_info->noperm)
3921 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3922 if (pvolume_info->setuids)
3923 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3924 if (pvolume_info->setuidfromacl)
3925 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
3926 if (pvolume_info->server_ino)
3927 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3928 if (pvolume_info->remap)
3929 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3930 if (pvolume_info->sfu_remap)
3931 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3932 if (pvolume_info->no_xattr)
3933 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3934 if (pvolume_info->sfu_emul)
3935 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3936 if (pvolume_info->nobrl)
3937 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3938 if (pvolume_info->nohandlecache)
3939 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_HANDLE_CACHE;
3940 if (pvolume_info->nostrictsync)
3941 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3942 if (pvolume_info->mand_lock)
3943 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3944 if (pvolume_info->rwpidforward)
3945 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3946 if (pvolume_info->mode_ace)
3947 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MODE_FROM_SID;
3948 if (pvolume_info->cifs_acl)
3949 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3950 if (pvolume_info->backupuid_specified) {
3951 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3952 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3953 }
3954 if (pvolume_info->backupgid_specified) {
3955 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3956 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3957 }
3958 if (pvolume_info->override_uid)
3959 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3960 if (pvolume_info->override_gid)
3961 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3962 if (pvolume_info->dynperm)
3963 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3964 if (pvolume_info->fsc)
3965 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3966 if (pvolume_info->multiuser)
3967 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3968 CIFS_MOUNT_NO_PERM);
3969 if (pvolume_info->strict_io)
3970 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3971 if (pvolume_info->direct_io) {
3972 cifs_dbg(FYI, "mounting share using direct i/o\n");
3973 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3974 }
3975 if (pvolume_info->cache_ro) {
3976 cifs_dbg(VFS, "mounting share with read only caching. Ensure that the share will not be modified while in use.\n");
3977 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RO_CACHE;
3978 } else if (pvolume_info->cache_rw) {
3979 cifs_dbg(VFS, "mounting share in single client RW caching mode. Ensure that no other systems will be accessing the share.\n");
3980 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_RO_CACHE |
3981 CIFS_MOUNT_RW_CACHE);
3982 }
3983 if (pvolume_info->mfsymlinks) {
3984 if (pvolume_info->sfu_emul) {
3985 /*
3986 * Our SFU ("Services for Unix" emulation does not allow
3987 * creating symlinks but does allow reading existing SFU
3988 * symlinks (it does allow both creating and reading SFU
3989 * style mknod and FIFOs though). When "mfsymlinks" and
3990 * "sfu" are both enabled at the same time, it allows
3991 * reading both types of symlinks, but will only create
3992 * them with mfsymlinks format. This allows better
3993 * Apple compatibility (probably better for Samba too)
3994 * while still recognizing old Windows style symlinks.
3995 */
3996 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
3997 }
3998 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3999 }
4000
4001 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
4002 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
4003
4004 if (pvolume_info->prepath) {
4005 cifs_sb->prepath = kstrdup(pvolume_info->prepath, GFP_KERNEL);
4006 if (cifs_sb->prepath == NULL)
4007 return -ENOMEM;
4008 }
4009
4010 return 0;
4011 }
4012
4013 void
4014 cifs_cleanup_volume_info_contents(struct smb_vol *volume_info)
4015 {
4016 kfree(volume_info->username);
4017 kfree_sensitive(volume_info->password);
4018 kfree(volume_info->UNC);
4019 kfree(volume_info->domainname);
4020 kfree(volume_info->iocharset);
4021 kfree(volume_info->prepath);
4022 }
4023
4024 void
4025 cifs_cleanup_volume_info(struct smb_vol *volume_info)
4026 {
4027 if (!volume_info)
4028 return;
4029 cifs_cleanup_volume_info_contents(volume_info);
4030 kfree(volume_info);
4031 }
4032
4033 /* Release all succeed connections */
4034 static inline void mount_put_conns(struct cifs_sb_info *cifs_sb,
4035 unsigned int xid,
4036 struct TCP_Server_Info *server,
4037 struct cifs_ses *ses, struct cifs_tcon *tcon)
4038 {
4039 int rc = 0;
4040
4041 if (tcon)
4042 cifs_put_tcon(tcon);
4043 else if (ses)
4044 cifs_put_smb_ses(ses);
4045 else if (server)
4046 cifs_put_tcp_session(server, 0);
4047 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
4048 free_xid(xid);
4049 }
4050
4051 /* Get connections for tcp, ses and tcon */
4052 static int mount_get_conns(struct smb_vol *vol, struct cifs_sb_info *cifs_sb,
4053 unsigned int *xid,
4054 struct TCP_Server_Info **nserver,
4055 struct cifs_ses **nses, struct cifs_tcon **ntcon)
4056 {
4057 int rc = 0;
4058 struct TCP_Server_Info *server;
4059 struct cifs_ses *ses;
4060 struct cifs_tcon *tcon;
4061
4062 *nserver = NULL;
4063 *nses = NULL;
4064 *ntcon = NULL;
4065
4066 *xid = get_xid();
4067
4068 /* get a reference to a tcp session */
4069 server = cifs_get_tcp_session(vol);
4070 if (IS_ERR(server)) {
4071 rc = PTR_ERR(server);
4072 return rc;
4073 }
4074
4075 *nserver = server;
4076
4077 if ((vol->max_credits < 20) || (vol->max_credits > 60000))
4078 server->max_credits = SMB2_MAX_CREDITS_AVAILABLE;
4079 else
4080 server->max_credits = vol->max_credits;
4081
4082 /* get a reference to a SMB session */
4083 ses = cifs_get_smb_ses(server, vol);
4084 if (IS_ERR(ses)) {
4085 rc = PTR_ERR(ses);
4086 return rc;
4087 }
4088
4089 *nses = ses;
4090
4091 if ((vol->persistent == true) && (!(ses->server->capabilities &
4092 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES))) {
4093 cifs_server_dbg(VFS, "persistent handles not supported by server\n");
4094 return -EOPNOTSUPP;
4095 }
4096
4097 /* search for existing tcon to this server share */
4098 tcon = cifs_get_tcon(ses, vol);
4099 if (IS_ERR(tcon)) {
4100 rc = PTR_ERR(tcon);
4101 return rc;
4102 }
4103
4104 *ntcon = tcon;
4105
4106 /* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
4107 if (tcon->posix_extensions)
4108 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_POSIX_PATHS;
4109
4110 /* tell server which Unix caps we support */
4111 if (cap_unix(tcon->ses)) {
4112 /*
4113 * reset of caps checks mount to see if unix extensions disabled
4114 * for just this mount.
4115 */
4116 reset_cifs_unix_caps(*xid, tcon, cifs_sb, vol);
4117 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
4118 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
4119 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP))
4120 return -EACCES;
4121 } else
4122 tcon->unix_ext = 0; /* server does not support them */
4123
4124 /* do not care if a following call succeed - informational */
4125 if (!tcon->pipe && server->ops->qfs_tcon) {
4126 server->ops->qfs_tcon(*xid, tcon, cifs_sb);
4127 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE) {
4128 if (tcon->fsDevInfo.DeviceCharacteristics &
4129 cpu_to_le32(FILE_READ_ONLY_DEVICE))
4130 cifs_dbg(VFS, "mounted to read only share\n");
4131 else if ((cifs_sb->mnt_cifs_flags &
4132 CIFS_MOUNT_RW_CACHE) == 0)
4133 cifs_dbg(VFS, "read only mount of RW share\n");
4134 /* no need to log a RW mount of a typical RW share */
4135 }
4136 }
4137
4138 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, vol);
4139 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, vol);
4140
4141 return 0;
4142 }
4143
4144 static int mount_setup_tlink(struct cifs_sb_info *cifs_sb, struct cifs_ses *ses,
4145 struct cifs_tcon *tcon)
4146 {
4147 struct tcon_link *tlink;
4148
4149 /* hang the tcon off of the superblock */
4150 tlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4151 if (tlink == NULL)
4152 return -ENOMEM;
4153
4154 tlink->tl_uid = ses->linux_uid;
4155 tlink->tl_tcon = tcon;
4156 tlink->tl_time = jiffies;
4157 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
4158 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4159
4160 cifs_sb->master_tlink = tlink;
4161 spin_lock(&cifs_sb->tlink_tree_lock);
4162 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4163 spin_unlock(&cifs_sb->tlink_tree_lock);
4164
4165 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4166 TLINK_IDLE_EXPIRE);
4167 return 0;
4168 }
4169
4170 #ifdef CONFIG_CIFS_DFS_UPCALL
4171 /*
4172 * cifs_build_path_to_root returns full path to root when we do not have an
4173 * exiting connection (tcon)
4174 */
4175 static char *
4176 build_unc_path_to_root(const struct smb_vol *vol,
4177 const struct cifs_sb_info *cifs_sb, bool useppath)
4178 {
4179 char *full_path, *pos;
4180 unsigned int pplen = useppath && vol->prepath ?
4181 strlen(vol->prepath) + 1 : 0;
4182 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
4183
4184 if (unc_len > MAX_TREE_SIZE)
4185 return ERR_PTR(-EINVAL);
4186
4187 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
4188 if (full_path == NULL)
4189 return ERR_PTR(-ENOMEM);
4190
4191 memcpy(full_path, vol->UNC, unc_len);
4192 pos = full_path + unc_len;
4193
4194 if (pplen) {
4195 *pos = CIFS_DIR_SEP(cifs_sb);
4196 memcpy(pos + 1, vol->prepath, pplen);
4197 pos += pplen;
4198 }
4199
4200 *pos = '\0'; /* add trailing null */
4201 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
4202 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
4203 return full_path;
4204 }
4205
4206 /**
4207 * expand_dfs_referral - Perform a dfs referral query and update the cifs_sb
4208 *
4209 *
4210 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
4211 * to a string containing updated options for the submount. Otherwise it
4212 * will be left untouched.
4213 *
4214 * Returns the rc from get_dfs_path to the caller, which can be used to
4215 * determine whether there were referrals.
4216 */
4217 static int
4218 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
4219 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
4220 char *ref_path)
4221 {
4222 int rc;
4223 struct dfs_info3_param referral = {0};
4224 char *full_path = NULL, *mdata = NULL;
4225
4226 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
4227 return -EREMOTE;
4228
4229 full_path = build_unc_path_to_root(volume_info, cifs_sb, true);
4230 if (IS_ERR(full_path))
4231 return PTR_ERR(full_path);
4232
4233 rc = dfs_cache_find(xid, ses, cifs_sb->local_nls, cifs_remap(cifs_sb),
4234 ref_path, &referral, NULL);
4235 if (!rc) {
4236 char *fake_devname = NULL;
4237
4238 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
4239 full_path + 1, &referral,
4240 &fake_devname);
4241 free_dfs_info_param(&referral);
4242
4243 if (IS_ERR(mdata)) {
4244 rc = PTR_ERR(mdata);
4245 mdata = NULL;
4246 } else {
4247 cifs_cleanup_volume_info_contents(volume_info);
4248 rc = cifs_setup_volume_info(volume_info, mdata,
4249 fake_devname, false);
4250 }
4251 kfree(fake_devname);
4252 kfree(cifs_sb->mountdata);
4253 cifs_sb->mountdata = mdata;
4254 }
4255 kfree(full_path);
4256 return rc;
4257 }
4258
4259 static inline int get_next_dfs_tgt(const char *path,
4260 struct dfs_cache_tgt_list *tgt_list,
4261 struct dfs_cache_tgt_iterator **tgt_it)
4262 {
4263 if (!*tgt_it)
4264 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
4265 else
4266 *tgt_it = dfs_cache_get_next_tgt(tgt_list, *tgt_it);
4267 return !*tgt_it ? -EHOSTDOWN : 0;
4268 }
4269
4270 static int update_vol_info(const struct dfs_cache_tgt_iterator *tgt_it,
4271 struct smb_vol *fake_vol, struct smb_vol *vol)
4272 {
4273 const char *tgt = dfs_cache_get_tgt_name(tgt_it);
4274 int len = strlen(tgt) + 2;
4275 char *new_unc;
4276
4277 new_unc = kmalloc(len, GFP_KERNEL);
4278 if (!new_unc)
4279 return -ENOMEM;
4280 scnprintf(new_unc, len, "\\%s", tgt);
4281
4282 kfree(vol->UNC);
4283 vol->UNC = new_unc;
4284
4285 if (fake_vol->prepath) {
4286 kfree(vol->prepath);
4287 vol->prepath = fake_vol->prepath;
4288 fake_vol->prepath = NULL;
4289 }
4290 memcpy(&vol->dstaddr, &fake_vol->dstaddr, sizeof(vol->dstaddr));
4291
4292 return 0;
4293 }
4294
4295 static int setup_dfs_tgt_conn(const char *path, const char *full_path,
4296 const struct dfs_cache_tgt_iterator *tgt_it,
4297 struct cifs_sb_info *cifs_sb, struct smb_vol *vol, unsigned int *xid,
4298 struct TCP_Server_Info **server, struct cifs_ses **ses,
4299 struct cifs_tcon **tcon)
4300 {
4301 int rc;
4302 struct dfs_info3_param ref = {0};
4303 char *mdata = NULL, *fake_devname = NULL;
4304 struct smb_vol fake_vol = {NULL};
4305
4306 cifs_dbg(FYI, "%s: dfs path: %s\n", __func__, path);
4307
4308 rc = dfs_cache_get_tgt_referral(path, tgt_it, &ref);
4309 if (rc)
4310 return rc;
4311
4312 mdata = cifs_compose_mount_options(cifs_sb->mountdata, full_path + 1, &ref, &fake_devname);
4313 free_dfs_info_param(&ref);
4314
4315 if (IS_ERR(mdata)) {
4316 rc = PTR_ERR(mdata);
4317 mdata = NULL;
4318 } else {
4319 cifs_dbg(FYI, "%s: fake_devname: %s\n", __func__, fake_devname);
4320 rc = cifs_setup_volume_info(&fake_vol, mdata, fake_devname,
4321 false);
4322 }
4323 kfree(mdata);
4324 kfree(fake_devname);
4325
4326 if (!rc) {
4327 /*
4328 * We use a 'fake_vol' here because we need pass it down to the
4329 * mount_{get,put} functions to test connection against new DFS
4330 * targets.
4331 */
4332 mount_put_conns(cifs_sb, *xid, *server, *ses, *tcon);
4333 rc = mount_get_conns(&fake_vol, cifs_sb, xid, server, ses,
4334 tcon);
4335 if (!rc || (*server && *ses)) {
4336 /*
4337 * We were able to connect to new target server.
4338 * Update current volume info with new target server.
4339 */
4340 rc = update_vol_info(tgt_it, &fake_vol, vol);
4341 }
4342 }
4343 cifs_cleanup_volume_info_contents(&fake_vol);
4344 return rc;
4345 }
4346
4347 static int do_dfs_failover(const char *path, const char *full_path, struct cifs_sb_info *cifs_sb,
4348 struct smb_vol *vol, struct cifs_ses *root_ses, unsigned int *xid,
4349 struct TCP_Server_Info **server, struct cifs_ses **ses,
4350 struct cifs_tcon **tcon)
4351 {
4352 int rc;
4353 struct dfs_cache_tgt_list tgt_list;
4354 struct dfs_cache_tgt_iterator *tgt_it = NULL;
4355
4356 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
4357 return -EOPNOTSUPP;
4358
4359 rc = dfs_cache_noreq_find(path, NULL, &tgt_list);
4360 if (rc)
4361 return rc;
4362
4363 for (;;) {
4364 /* Get next DFS target server - if any */
4365 rc = get_next_dfs_tgt(path, &tgt_list, &tgt_it);
4366 if (rc)
4367 break;
4368 /* Connect to next DFS target */
4369 rc = setup_dfs_tgt_conn(path, full_path, tgt_it, cifs_sb, vol, xid, server, ses,
4370 tcon);
4371 if (!rc || (*server && *ses))
4372 break;
4373 }
4374 if (!rc) {
4375 /*
4376 * Update DFS target hint in DFS referral cache with the target
4377 * server we successfully reconnected to.
4378 */
4379 rc = dfs_cache_update_tgthint(*xid, root_ses ? root_ses : *ses,
4380 cifs_sb->local_nls,
4381 cifs_remap(cifs_sb), path,
4382 tgt_it);
4383 }
4384 dfs_cache_free_tgts(&tgt_list);
4385 return rc;
4386 }
4387 #endif
4388
4389 int
4390 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
4391 const char *devname, bool is_smb3)
4392 {
4393 int rc = 0;
4394
4395 if (cifs_parse_mount_options(mount_data, devname, volume_info, is_smb3))
4396 return -EINVAL;
4397
4398 if (volume_info->nullauth) {
4399 cifs_dbg(FYI, "Anonymous login\n");
4400 kfree(volume_info->username);
4401 volume_info->username = NULL;
4402 } else if (volume_info->username) {
4403 /* BB fixme parse for domain name here */
4404 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
4405 } else {
4406 cifs_dbg(VFS, "No username specified\n");
4407 /* In userspace mount helper we can get user name from alternate
4408 locations such as env variables and files on disk */
4409 return -EINVAL;
4410 }
4411
4412 /* this is needed for ASCII cp to Unicode converts */
4413 if (volume_info->iocharset == NULL) {
4414 /* load_nls_default cannot return null */
4415 volume_info->local_nls = load_nls_default();
4416 } else {
4417 volume_info->local_nls = load_nls(volume_info->iocharset);
4418 if (volume_info->local_nls == NULL) {
4419 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
4420 volume_info->iocharset);
4421 return -ELIBACC;
4422 }
4423 }
4424
4425 return rc;
4426 }
4427
4428 struct smb_vol *
4429 cifs_get_volume_info(char *mount_data, const char *devname, bool is_smb3)
4430 {
4431 int rc;
4432 struct smb_vol *volume_info;
4433
4434 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
4435 if (!volume_info)
4436 return ERR_PTR(-ENOMEM);
4437
4438 rc = cifs_setup_volume_info(volume_info, mount_data, devname, is_smb3);
4439 if (rc) {
4440 cifs_cleanup_volume_info(volume_info);
4441 volume_info = ERR_PTR(rc);
4442 }
4443
4444 return volume_info;
4445 }
4446
4447 static int
4448 cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
4449 unsigned int xid,
4450 struct cifs_tcon *tcon,
4451 struct cifs_sb_info *cifs_sb,
4452 char *full_path,
4453 int added_treename)
4454 {
4455 int rc;
4456 char *s;
4457 char sep, tmp;
4458 int skip = added_treename ? 1 : 0;
4459
4460 sep = CIFS_DIR_SEP(cifs_sb);
4461 s = full_path;
4462
4463 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
4464 while (rc == 0) {
4465 /* skip separators */
4466 while (*s == sep)
4467 s++;
4468 if (!*s)
4469 break;
4470 /* next separator */
4471 while (*s && *s != sep)
4472 s++;
4473 /*
4474 * if the treename is added, we then have to skip the first
4475 * part within the separators
4476 */
4477 if (skip) {
4478 skip = 0;
4479 continue;
4480 }
4481 /*
4482 * temporarily null-terminate the path at the end of
4483 * the current component
4484 */
4485 tmp = *s;
4486 *s = 0;
4487 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
4488 full_path);
4489 *s = tmp;
4490 }
4491 return rc;
4492 }
4493
4494 /*
4495 * Check if path is remote (e.g. a DFS share). Return -EREMOTE if it is,
4496 * otherwise 0.
4497 */
4498 static int is_path_remote(struct cifs_sb_info *cifs_sb, struct smb_vol *vol,
4499 const unsigned int xid,
4500 struct TCP_Server_Info *server,
4501 struct cifs_tcon *tcon)
4502 {
4503 int rc;
4504 char *full_path;
4505
4506 if (!server->ops->is_path_accessible)
4507 return -EOPNOTSUPP;
4508
4509 /*
4510 * cifs_build_path_to_root works only when we have a valid tcon
4511 */
4512 full_path = cifs_build_path_to_root(vol, cifs_sb, tcon,
4513 tcon->Flags & SMB_SHARE_IS_IN_DFS);
4514 if (full_path == NULL)
4515 return -ENOMEM;
4516
4517 cifs_dbg(FYI, "%s: full_path: %s\n", __func__, full_path);
4518
4519 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
4520 full_path);
4521 if (rc != 0 && rc != -EREMOTE) {
4522 kfree(full_path);
4523 return rc;
4524 }
4525
4526 if (rc != -EREMOTE) {
4527 rc = cifs_are_all_path_components_accessible(server, xid, tcon,
4528 cifs_sb, full_path, tcon->Flags & SMB_SHARE_IS_IN_DFS);
4529 if (rc != 0) {
4530 cifs_server_dbg(VFS, "cannot query dirs between root and final path, enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
4531 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
4532 rc = 0;
4533 }
4534 }
4535
4536 kfree(full_path);
4537 return rc;
4538 }
4539
4540 #ifdef CONFIG_CIFS_DFS_UPCALL
4541 static void set_root_ses(struct cifs_sb_info *cifs_sb, struct cifs_ses *ses,
4542 struct cifs_ses **root_ses)
4543 {
4544 if (ses) {
4545 spin_lock(&cifs_tcp_ses_lock);
4546 ses->ses_count++;
4547 ses->tcon_ipc->remap = cifs_remap(cifs_sb);
4548 spin_unlock(&cifs_tcp_ses_lock);
4549 }
4550 *root_ses = ses;
4551 }
4552
4553 static void put_root_ses(struct cifs_ses *ses)
4554 {
4555 if (ses)
4556 cifs_put_smb_ses(ses);
4557 }
4558
4559 /* Check if a path component is remote and then update @dfs_path accordingly */
4560 static int check_dfs_prepath(struct cifs_sb_info *cifs_sb, struct smb_vol *vol,
4561 const unsigned int xid, struct TCP_Server_Info *server,
4562 struct cifs_tcon *tcon, char **dfs_path)
4563 {
4564 char *path, *s;
4565 char sep = CIFS_DIR_SEP(cifs_sb), tmp;
4566 char *npath;
4567 int rc = 0;
4568 int added_treename = tcon->Flags & SMB_SHARE_IS_IN_DFS;
4569 int skip = added_treename;
4570
4571 path = cifs_build_path_to_root(vol, cifs_sb, tcon, added_treename);
4572 if (!path)
4573 return -ENOMEM;
4574
4575 /*
4576 * Walk through the path components in @path and check if they're accessible. In case any of
4577 * the components is -EREMOTE, then update @dfs_path with the next DFS referral request path
4578 * (NOT including the remaining components).
4579 */
4580 s = path;
4581 do {
4582 /* skip separators */
4583 while (*s && *s == sep)
4584 s++;
4585 if (!*s)
4586 break;
4587 /* next separator */
4588 while (*s && *s != sep)
4589 s++;
4590 /*
4591 * if the treename is added, we then have to skip the first
4592 * part within the separators
4593 */
4594 if (skip) {
4595 skip = 0;
4596 continue;
4597 }
4598 tmp = *s;
4599 *s = 0;
4600 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, path);
4601 if (rc && rc == -EREMOTE) {
4602 struct smb_vol v = {NULL};
4603 /* if @path contains a tree name, skip it in the prefix path */
4604 if (added_treename) {
4605 rc = cifs_parse_devname(path, &v);
4606 if (rc)
4607 break;
4608 rc = -EREMOTE;
4609 npath = build_unc_path_to_root(&v, cifs_sb, true);
4610 cifs_cleanup_volume_info_contents(&v);
4611 } else {
4612 v.UNC = vol->UNC;
4613 v.prepath = path + 1;
4614 npath = build_unc_path_to_root(&v, cifs_sb, true);
4615 }
4616 if (IS_ERR(npath)) {
4617 rc = PTR_ERR(npath);
4618 break;
4619 }
4620 kfree(*dfs_path);
4621 *dfs_path = npath;
4622 }
4623 *s = tmp;
4624 } while (rc == 0);
4625
4626 kfree(path);
4627 return rc;
4628 }
4629
4630 int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *vol)
4631 {
4632 int rc = 0;
4633 unsigned int xid;
4634 struct TCP_Server_Info *server = NULL;
4635 struct cifs_ses *ses = NULL, *root_ses = NULL;
4636 struct cifs_tcon *tcon = NULL;
4637 int count = 0;
4638 char *ref_path = NULL, *full_path = NULL;
4639 char *oldmnt = NULL;
4640 char *mntdata = NULL;
4641
4642 rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses, &tcon);
4643 /*
4644 * Unconditionally try to get an DFS referral (even cached) to determine whether it is an
4645 * DFS mount.
4646 *
4647 * Skip prefix path to provide support for DFS referrals from w2k8 servers which don't seem
4648 * to respond with PATH_NOT_COVERED to requests that include the prefix.
4649 */
4650 if (dfs_cache_find(xid, ses, cifs_sb->local_nls, cifs_remap(cifs_sb), vol->UNC + 1, NULL,
4651 NULL)) {
4652 /* No DFS referral was returned. Looks like a regular share. */
4653 if (rc)
4654 goto error;
4655 /* Check if it is fully accessible and then mount it */
4656 rc = is_path_remote(cifs_sb, vol, xid, server, tcon);
4657 if (!rc)
4658 goto out;
4659 if (rc != -EREMOTE)
4660 goto error;
4661 }
4662 /* Save mount options */
4663 mntdata = kstrndup(cifs_sb->mountdata, strlen(cifs_sb->mountdata), GFP_KERNEL);
4664 if (!mntdata) {
4665 rc = -ENOMEM;
4666 goto error;
4667 }
4668 /* Get path of DFS root */
4669 ref_path = build_unc_path_to_root(vol, cifs_sb, false);
4670 if (IS_ERR(ref_path)) {
4671 rc = PTR_ERR(ref_path);
4672 ref_path = NULL;
4673 goto error;
4674 }
4675
4676 set_root_ses(cifs_sb, ses, &root_ses);
4677 do {
4678 /* Save full path of last DFS path we used to resolve final target server */
4679 kfree(full_path);
4680 full_path = build_unc_path_to_root(vol, cifs_sb, !!count);
4681 if (IS_ERR(full_path)) {
4682 rc = PTR_ERR(full_path);
4683 full_path = NULL;
4684 break;
4685 }
4686 /* Chase referral */
4687 oldmnt = cifs_sb->mountdata;
4688 rc = expand_dfs_referral(xid, root_ses, vol, cifs_sb, ref_path + 1);
4689 if (rc)
4690 break;
4691 /* Connect to new DFS target only if we were redirected */
4692 if (oldmnt != cifs_sb->mountdata) {
4693 mount_put_conns(cifs_sb, xid, server, ses, tcon);
4694 rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses, &tcon);
4695 }
4696 if (rc && !server && !ses) {
4697 /* Failed to connect. Try to connect to other targets in the referral. */
4698 rc = do_dfs_failover(ref_path + 1, full_path, cifs_sb, vol, root_ses, &xid,
4699 &server, &ses, &tcon);
4700 }
4701 if (rc == -EACCES || rc == -EOPNOTSUPP || !server || !ses)
4702 break;
4703 if (!tcon)
4704 continue;
4705 /* Make sure that requests go through new root servers */
4706 if (is_tcon_dfs(tcon)) {
4707 put_root_ses(root_ses);
4708 set_root_ses(cifs_sb, ses, &root_ses);
4709 }
4710 /* Check for remaining path components and then continue chasing them (-EREMOTE) */
4711 rc = check_dfs_prepath(cifs_sb, vol, xid, server, tcon, &ref_path);
4712 /* Prevent recursion on broken link referrals */
4713 if (rc == -EREMOTE && ++count > MAX_NESTED_LINKS)
4714 rc = -ELOOP;
4715 } while (rc == -EREMOTE);
4716
4717 if (rc)
4718 goto error;
4719 put_root_ses(root_ses);
4720 root_ses = NULL;
4721 kfree(ref_path);
4722 ref_path = NULL;
4723 /*
4724 * Store DFS full path in both superblock and tree connect structures.
4725 *
4726 * For DFS root mounts, the prefix path (cifs_sb->prepath) is preserved during reconnect so
4727 * only the root path is set in cifs_sb->origin_fullpath and tcon->dfs_path. And for DFS
4728 * links, the prefix path is included in both and may be changed during reconnect. See
4729 * cifs_tree_connect().
4730 */
4731 cifs_sb->origin_fullpath = kstrndup(full_path, strlen(full_path), GFP_KERNEL);
4732 if (!cifs_sb->origin_fullpath) {
4733 rc = -ENOMEM;
4734 goto error;
4735 }
4736 spin_lock(&cifs_tcp_ses_lock);
4737 tcon->dfs_path = full_path;
4738 full_path = NULL;
4739 tcon->remap = cifs_remap(cifs_sb);
4740 spin_unlock(&cifs_tcp_ses_lock);
4741
4742 /* Add original volume information for DFS cache to be used when refreshing referrals */
4743 rc = dfs_cache_add_vol(mntdata, vol, cifs_sb->origin_fullpath);
4744 if (rc)
4745 goto error;
4746 /*
4747 * After reconnecting to a different server, unique ids won't
4748 * match anymore, so we disable serverino. This prevents
4749 * dentry revalidation to think the dentry are stale (ESTALE).
4750 */
4751 cifs_autodisable_serverino(cifs_sb);
4752 /*
4753 * Force the use of prefix path to support failover on DFS paths that
4754 * resolve to targets that have different prefix paths.
4755 */
4756 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
4757 kfree(cifs_sb->prepath);
4758 cifs_sb->prepath = vol->prepath;
4759 vol->prepath = NULL;
4760
4761 out:
4762 free_xid(xid);
4763 cifs_try_adding_channels(ses);
4764 return mount_setup_tlink(cifs_sb, ses, tcon);
4765
4766 error:
4767 kfree(ref_path);
4768 kfree(full_path);
4769 kfree(mntdata);
4770 kfree(cifs_sb->origin_fullpath);
4771 put_root_ses(root_ses);
4772 mount_put_conns(cifs_sb, xid, server, ses, tcon);
4773 return rc;
4774 }
4775 #else
4776 int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *vol)
4777 {
4778 int rc = 0;
4779 unsigned int xid;
4780 struct cifs_ses *ses;
4781 struct cifs_tcon *tcon;
4782 struct TCP_Server_Info *server;
4783
4784 rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses, &tcon);
4785 if (rc)
4786 goto error;
4787
4788 if (tcon) {
4789 rc = is_path_remote(cifs_sb, vol, xid, server, tcon);
4790 if (rc == -EREMOTE)
4791 rc = -EOPNOTSUPP;
4792 if (rc)
4793 goto error;
4794 }
4795
4796 free_xid(xid);
4797
4798 return mount_setup_tlink(cifs_sb, ses, tcon);
4799
4800 error:
4801 mount_put_conns(cifs_sb, xid, server, ses, tcon);
4802 return rc;
4803 }
4804 #endif
4805
4806 /*
4807 * Issue a TREE_CONNECT request.
4808 */
4809 int
4810 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
4811 const char *tree, struct cifs_tcon *tcon,
4812 const struct nls_table *nls_codepage)
4813 {
4814 struct smb_hdr *smb_buffer;
4815 struct smb_hdr *smb_buffer_response;
4816 TCONX_REQ *pSMB;
4817 TCONX_RSP *pSMBr;
4818 unsigned char *bcc_ptr;
4819 int rc = 0;
4820 int length;
4821 __u16 bytes_left, count;
4822
4823 if (ses == NULL)
4824 return -EIO;
4825
4826 smb_buffer = cifs_buf_get();
4827 if (smb_buffer == NULL)
4828 return -ENOMEM;
4829
4830 smb_buffer_response = smb_buffer;
4831
4832 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
4833 NULL /*no tid */ , 4 /*wct */ );
4834
4835 smb_buffer->Mid = get_next_mid(ses->server);
4836 smb_buffer->Uid = ses->Suid;
4837 pSMB = (TCONX_REQ *) smb_buffer;
4838 pSMBr = (TCONX_RSP *) smb_buffer_response;
4839
4840 pSMB->AndXCommand = 0xFF;
4841 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
4842 bcc_ptr = &pSMB->Password[0];
4843 if (tcon->pipe || (ses->server->sec_mode & SECMODE_USER)) {
4844 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
4845 *bcc_ptr = 0; /* password is null byte */
4846 bcc_ptr++; /* skip password */
4847 /* already aligned so no need to do it below */
4848 } else {
4849 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
4850 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
4851 specified as required (when that support is added to
4852 the vfs in the future) as only NTLM or the much
4853 weaker LANMAN (which we do not send by default) is accepted
4854 by Samba (not sure whether other servers allow
4855 NTLMv2 password here) */
4856 #ifdef CONFIG_CIFS_WEAK_PW_HASH
4857 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
4858 (ses->sectype == LANMAN))
4859 calc_lanman_hash(tcon->password, ses->server->cryptkey,
4860 ses->server->sec_mode &
4861 SECMODE_PW_ENCRYPT ? true : false,
4862 bcc_ptr);
4863 else
4864 #endif /* CIFS_WEAK_PW_HASH */
4865 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
4866 bcc_ptr, nls_codepage);
4867 if (rc) {
4868 cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
4869 __func__, rc);
4870 cifs_buf_release(smb_buffer);
4871 return rc;
4872 }
4873
4874 bcc_ptr += CIFS_AUTH_RESP_SIZE;
4875 if (ses->capabilities & CAP_UNICODE) {
4876 /* must align unicode strings */
4877 *bcc_ptr = 0; /* null byte password */
4878 bcc_ptr++;
4879 }
4880 }
4881
4882 if (ses->server->sign)
4883 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
4884
4885 if (ses->capabilities & CAP_STATUS32) {
4886 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
4887 }
4888 if (ses->capabilities & CAP_DFS) {
4889 smb_buffer->Flags2 |= SMBFLG2_DFS;
4890 }
4891 if (ses->capabilities & CAP_UNICODE) {
4892 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
4893 length =
4894 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
4895 6 /* max utf8 char length in bytes */ *
4896 (/* server len*/ + 256 /* share len */), nls_codepage);
4897 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
4898 bcc_ptr += 2; /* skip trailing null */
4899 } else { /* ASCII */
4900 strcpy(bcc_ptr, tree);
4901 bcc_ptr += strlen(tree) + 1;
4902 }
4903 strcpy(bcc_ptr, "?????");
4904 bcc_ptr += strlen("?????");
4905 bcc_ptr += 1;
4906 count = bcc_ptr - &pSMB->Password[0];
4907 be32_add_cpu(&pSMB->hdr.smb_buf_length, count);
4908 pSMB->ByteCount = cpu_to_le16(count);
4909
4910 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
4911 0);
4912
4913 /* above now done in SendReceive */
4914 if (rc == 0) {
4915 bool is_unicode;
4916
4917 tcon->tidStatus = CifsGood;
4918 tcon->need_reconnect = false;
4919 tcon->tid = smb_buffer_response->Tid;
4920 bcc_ptr = pByteArea(smb_buffer_response);
4921 bytes_left = get_bcc(smb_buffer_response);
4922 length = strnlen(bcc_ptr, bytes_left - 2);
4923 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
4924 is_unicode = true;
4925 else
4926 is_unicode = false;
4927
4928
4929 /* skip service field (NB: this field is always ASCII) */
4930 if (length == 3) {
4931 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
4932 (bcc_ptr[2] == 'C')) {
4933 cifs_dbg(FYI, "IPC connection\n");
4934 tcon->ipc = true;
4935 tcon->pipe = true;
4936 }
4937 } else if (length == 2) {
4938 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
4939 /* the most common case */
4940 cifs_dbg(FYI, "disk share connection\n");
4941 }
4942 }
4943 bcc_ptr += length + 1;
4944 bytes_left -= (length + 1);
4945 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
4946
4947 /* mostly informational -- no need to fail on error here */
4948 kfree(tcon->nativeFileSystem);
4949 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
4950 bytes_left, is_unicode,
4951 nls_codepage);
4952
4953 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
4954
4955 if ((smb_buffer_response->WordCount == 3) ||
4956 (smb_buffer_response->WordCount == 7))
4957 /* field is in same location */
4958 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
4959 else
4960 tcon->Flags = 0;
4961 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
4962 }
4963
4964 cifs_buf_release(smb_buffer);
4965 return rc;
4966 }
4967
4968 static void delayed_free(struct rcu_head *p)
4969 {
4970 struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
4971 unload_nls(sbi->local_nls);
4972 kfree(sbi);
4973 }
4974
4975 void
4976 cifs_umount(struct cifs_sb_info *cifs_sb)
4977 {
4978 struct rb_root *root = &cifs_sb->tlink_tree;
4979 struct rb_node *node;
4980 struct tcon_link *tlink;
4981
4982 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
4983
4984 spin_lock(&cifs_sb->tlink_tree_lock);
4985 while ((node = rb_first(root))) {
4986 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4987 cifs_get_tlink(tlink);
4988 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4989 rb_erase(node, root);
4990
4991 spin_unlock(&cifs_sb->tlink_tree_lock);
4992 cifs_put_tlink(tlink);
4993 spin_lock(&cifs_sb->tlink_tree_lock);
4994 }
4995 spin_unlock(&cifs_sb->tlink_tree_lock);
4996
4997 kfree(cifs_sb->mountdata);
4998 kfree(cifs_sb->prepath);
4999 #ifdef CONFIG_CIFS_DFS_UPCALL
5000 dfs_cache_del_vol(cifs_sb->origin_fullpath);
5001 kfree(cifs_sb->origin_fullpath);
5002 #endif
5003 call_rcu(&cifs_sb->rcu, delayed_free);
5004 }
5005
5006 int
5007 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
5008 {
5009 int rc = 0;
5010 struct TCP_Server_Info *server = cifs_ses_server(ses);
5011
5012 if (!server->ops->need_neg || !server->ops->negotiate)
5013 return -ENOSYS;
5014
5015 /* only send once per connect */
5016 if (!server->ops->need_neg(server))
5017 return 0;
5018
5019 rc = server->ops->negotiate(xid, ses);
5020 if (rc == 0) {
5021 spin_lock(&GlobalMid_Lock);
5022 if (server->tcpStatus == CifsNeedNegotiate)
5023 server->tcpStatus = CifsGood;
5024 else
5025 rc = -EHOSTDOWN;
5026 spin_unlock(&GlobalMid_Lock);
5027 }
5028
5029 return rc;
5030 }
5031
5032 int
5033 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
5034 struct nls_table *nls_info)
5035 {
5036 int rc = -ENOSYS;
5037 struct TCP_Server_Info *server = cifs_ses_server(ses);
5038
5039 if (!ses->binding) {
5040 ses->capabilities = server->capabilities;
5041 if (linuxExtEnabled == 0)
5042 ses->capabilities &= (~server->vals->cap_unix);
5043
5044 if (ses->auth_key.response) {
5045 cifs_dbg(FYI, "Free previous auth_key.response = %p\n",
5046 ses->auth_key.response);
5047 kfree(ses->auth_key.response);
5048 ses->auth_key.response = NULL;
5049 ses->auth_key.len = 0;
5050 }
5051 }
5052
5053 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
5054 server->sec_mode, server->capabilities, server->timeAdj);
5055
5056 if (server->ops->sess_setup)
5057 rc = server->ops->sess_setup(xid, ses, nls_info);
5058
5059 if (rc)
5060 cifs_server_dbg(VFS, "Send error in SessSetup = %d\n", rc);
5061
5062 return rc;
5063 }
5064
5065 static int
5066 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
5067 {
5068 vol->sectype = ses->sectype;
5069
5070 /* krb5 is special, since we don't need username or pw */
5071 if (vol->sectype == Kerberos)
5072 return 0;
5073
5074 return cifs_set_cifscreds(vol, ses);
5075 }
5076
5077 static struct cifs_tcon *
5078 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
5079 {
5080 int rc;
5081 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
5082 struct cifs_ses *ses;
5083 struct cifs_tcon *tcon = NULL;
5084 struct smb_vol *vol_info;
5085
5086 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
5087 if (vol_info == NULL)
5088 return ERR_PTR(-ENOMEM);
5089
5090 vol_info->local_nls = cifs_sb->local_nls;
5091 vol_info->linux_uid = fsuid;
5092 vol_info->cred_uid = fsuid;
5093 vol_info->UNC = master_tcon->treeName;
5094 vol_info->retry = master_tcon->retry;
5095 vol_info->nocase = master_tcon->nocase;
5096 vol_info->nohandlecache = master_tcon->nohandlecache;
5097 vol_info->local_lease = master_tcon->local_lease;
5098 vol_info->no_lease = master_tcon->no_lease;
5099 vol_info->resilient = master_tcon->use_resilient;
5100 vol_info->persistent = master_tcon->use_persistent;
5101 vol_info->handle_timeout = master_tcon->handle_timeout;
5102 vol_info->no_linux_ext = !master_tcon->unix_ext;
5103 vol_info->linux_ext = master_tcon->posix_extensions;
5104 vol_info->sectype = master_tcon->ses->sectype;
5105 vol_info->sign = master_tcon->ses->sign;
5106 vol_info->seal = master_tcon->seal;
5107
5108 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
5109 if (rc) {
5110 tcon = ERR_PTR(rc);
5111 goto out;
5112 }
5113
5114 /* get a reference for the same TCP session */
5115 spin_lock(&cifs_tcp_ses_lock);
5116 ++master_tcon->ses->server->srv_count;
5117 spin_unlock(&cifs_tcp_ses_lock);
5118
5119 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
5120 if (IS_ERR(ses)) {
5121 tcon = (struct cifs_tcon *)ses;
5122 cifs_put_tcp_session(master_tcon->ses->server, 0);
5123 goto out;
5124 }
5125
5126 tcon = cifs_get_tcon(ses, vol_info);
5127 if (IS_ERR(tcon)) {
5128 cifs_put_smb_ses(ses);
5129 goto out;
5130 }
5131
5132 if (cap_unix(ses))
5133 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
5134
5135 out:
5136 kfree(vol_info->username);
5137 kfree_sensitive(vol_info->password);
5138 kfree(vol_info);
5139
5140 return tcon;
5141 }
5142
5143 struct cifs_tcon *
5144 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
5145 {
5146 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
5147 }
5148
5149 /* find and return a tlink with given uid */
5150 static struct tcon_link *
5151 tlink_rb_search(struct rb_root *root, kuid_t uid)
5152 {
5153 struct rb_node *node = root->rb_node;
5154 struct tcon_link *tlink;
5155
5156 while (node) {
5157 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
5158
5159 if (uid_gt(tlink->tl_uid, uid))
5160 node = node->rb_left;
5161 else if (uid_lt(tlink->tl_uid, uid))
5162 node = node->rb_right;
5163 else
5164 return tlink;
5165 }
5166 return NULL;
5167 }
5168
5169 /* insert a tcon_link into the tree */
5170 static void
5171 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
5172 {
5173 struct rb_node **new = &(root->rb_node), *parent = NULL;
5174 struct tcon_link *tlink;
5175
5176 while (*new) {
5177 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
5178 parent = *new;
5179
5180 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
5181 new = &((*new)->rb_left);
5182 else
5183 new = &((*new)->rb_right);
5184 }
5185
5186 rb_link_node(&new_tlink->tl_rbnode, parent, new);
5187 rb_insert_color(&new_tlink->tl_rbnode, root);
5188 }
5189
5190 /*
5191 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
5192 * current task.
5193 *
5194 * If the superblock doesn't refer to a multiuser mount, then just return
5195 * the master tcon for the mount.
5196 *
5197 * First, search the rbtree for an existing tcon for this fsuid. If one
5198 * exists, then check to see if it's pending construction. If it is then wait
5199 * for construction to complete. Once it's no longer pending, check to see if
5200 * it failed and either return an error or retry construction, depending on
5201 * the timeout.
5202 *
5203 * If one doesn't exist then insert a new tcon_link struct into the tree and
5204 * try to construct a new one.
5205 */
5206 struct tcon_link *
5207 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
5208 {
5209 int ret;
5210 kuid_t fsuid = current_fsuid();
5211 struct tcon_link *tlink, *newtlink;
5212
5213 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
5214 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
5215
5216 spin_lock(&cifs_sb->tlink_tree_lock);
5217 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
5218 if (tlink)
5219 cifs_get_tlink(tlink);
5220 spin_unlock(&cifs_sb->tlink_tree_lock);
5221
5222 if (tlink == NULL) {
5223 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
5224 if (newtlink == NULL)
5225 return ERR_PTR(-ENOMEM);
5226 newtlink->tl_uid = fsuid;
5227 newtlink->tl_tcon = ERR_PTR(-EACCES);
5228 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
5229 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
5230 cifs_get_tlink(newtlink);
5231
5232 spin_lock(&cifs_sb->tlink_tree_lock);
5233 /* was one inserted after previous search? */
5234 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
5235 if (tlink) {
5236 cifs_get_tlink(tlink);
5237 spin_unlock(&cifs_sb->tlink_tree_lock);
5238 kfree(newtlink);
5239 goto wait_for_construction;
5240 }
5241 tlink = newtlink;
5242 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
5243 spin_unlock(&cifs_sb->tlink_tree_lock);
5244 } else {
5245 wait_for_construction:
5246 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
5247 TASK_INTERRUPTIBLE);
5248 if (ret) {
5249 cifs_put_tlink(tlink);
5250 return ERR_PTR(-ERESTARTSYS);
5251 }
5252
5253 /* if it's good, return it */
5254 if (!IS_ERR(tlink->tl_tcon))
5255 return tlink;
5256
5257 /* return error if we tried this already recently */
5258 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
5259 cifs_put_tlink(tlink);
5260 return ERR_PTR(-EACCES);
5261 }
5262
5263 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
5264 goto wait_for_construction;
5265 }
5266
5267 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
5268 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
5269 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
5270
5271 if (IS_ERR(tlink->tl_tcon)) {
5272 cifs_put_tlink(tlink);
5273 return ERR_PTR(-EACCES);
5274 }
5275
5276 return tlink;
5277 }
5278
5279 /*
5280 * periodic workqueue job that scans tcon_tree for a superblock and closes
5281 * out tcons.
5282 */
5283 static void
5284 cifs_prune_tlinks(struct work_struct *work)
5285 {
5286 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
5287 prune_tlinks.work);
5288 struct rb_root *root = &cifs_sb->tlink_tree;
5289 struct rb_node *node;
5290 struct rb_node *tmp;
5291 struct tcon_link *tlink;
5292
5293 /*
5294 * Because we drop the spinlock in the loop in order to put the tlink
5295 * it's not guarded against removal of links from the tree. The only
5296 * places that remove entries from the tree are this function and
5297 * umounts. Because this function is non-reentrant and is canceled
5298 * before umount can proceed, this is safe.
5299 */
5300 spin_lock(&cifs_sb->tlink_tree_lock);
5301 node = rb_first(root);
5302 while (node != NULL) {
5303 tmp = node;
5304 node = rb_next(tmp);
5305 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
5306
5307 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
5308 atomic_read(&tlink->tl_count) != 0 ||
5309 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
5310 continue;
5311
5312 cifs_get_tlink(tlink);
5313 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
5314 rb_erase(tmp, root);
5315
5316 spin_unlock(&cifs_sb->tlink_tree_lock);
5317 cifs_put_tlink(tlink);
5318 spin_lock(&cifs_sb->tlink_tree_lock);
5319 }
5320 spin_unlock(&cifs_sb->tlink_tree_lock);
5321
5322 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
5323 TLINK_IDLE_EXPIRE);
5324 }
5325
5326 #ifdef CONFIG_CIFS_DFS_UPCALL
5327 int cifs_tree_connect(const unsigned int xid, struct cifs_tcon *tcon, const struct nls_table *nlsc)
5328 {
5329 int rc;
5330 struct TCP_Server_Info *server = tcon->ses->server;
5331 const struct smb_version_operations *ops = server->ops;
5332 struct dfs_cache_tgt_list tl;
5333 struct dfs_cache_tgt_iterator *it = NULL;
5334 char *tree;
5335 const char *tcp_host;
5336 size_t tcp_host_len;
5337 const char *dfs_host;
5338 size_t dfs_host_len;
5339 char *share = NULL, *prefix = NULL;
5340 struct dfs_info3_param ref = {0};
5341 bool isroot;
5342
5343 tree = kzalloc(MAX_TREE_SIZE, GFP_KERNEL);
5344 if (!tree)
5345 return -ENOMEM;
5346
5347 if (!tcon->dfs_path) {
5348 if (tcon->ipc) {
5349 scnprintf(tree, MAX_TREE_SIZE, "\\\\%s\\IPC$", server->hostname);
5350 rc = ops->tree_connect(xid, tcon->ses, tree, tcon, nlsc);
5351 } else {
5352 rc = ops->tree_connect(xid, tcon->ses, tcon->treeName, tcon, nlsc);
5353 }
5354 goto out;
5355 }
5356
5357 rc = dfs_cache_noreq_find(tcon->dfs_path + 1, &ref, &tl);
5358 if (rc)
5359 goto out;
5360 isroot = ref.server_type == DFS_TYPE_ROOT;
5361 free_dfs_info_param(&ref);
5362
5363 extract_unc_hostname(server->hostname, &tcp_host, &tcp_host_len);
5364
5365 for (it = dfs_cache_get_tgt_iterator(&tl); it; it = dfs_cache_get_next_tgt(&tl, it)) {
5366 bool target_match;
5367
5368 kfree(share);
5369 kfree(prefix);
5370 share = NULL;
5371 prefix = NULL;
5372
5373 rc = dfs_cache_get_tgt_share(tcon->dfs_path + 1, it, &share, &prefix);
5374 if (rc) {
5375 cifs_dbg(VFS, "%s: failed to parse target share %d\n",
5376 __func__, rc);
5377 continue;
5378 }
5379
5380 extract_unc_hostname(share, &dfs_host, &dfs_host_len);
5381
5382 if (dfs_host_len != tcp_host_len
5383 || strncasecmp(dfs_host, tcp_host, dfs_host_len) != 0) {
5384 cifs_dbg(FYI, "%s: %.*s doesn't match %.*s\n", __func__, (int)dfs_host_len,
5385 dfs_host, (int)tcp_host_len, tcp_host);
5386
5387 rc = match_target_ip(server, dfs_host, dfs_host_len, &target_match);
5388 if (rc) {
5389 cifs_dbg(VFS, "%s: failed to match target ip: %d\n", __func__, rc);
5390 break;
5391 }
5392
5393 if (!target_match) {
5394 cifs_dbg(FYI, "%s: skipping target\n", __func__);
5395 continue;
5396 }
5397 }
5398
5399 if (tcon->ipc) {
5400 scnprintf(tree, MAX_TREE_SIZE, "\\\\%s\\IPC$", share);
5401 rc = ops->tree_connect(xid, tcon->ses, tree, tcon, nlsc);
5402 } else {
5403 scnprintf(tree, MAX_TREE_SIZE, "\\%s", share);
5404 rc = ops->tree_connect(xid, tcon->ses, tree, tcon, nlsc);
5405 /* Only handle prefix paths of DFS link targets */
5406 if (!rc && !isroot) {
5407 rc = update_super_prepath(tcon, prefix);
5408 break;
5409 }
5410 }
5411 if (rc == -EREMOTE)
5412 break;
5413 }
5414
5415 kfree(share);
5416 kfree(prefix);
5417
5418 if (!rc) {
5419 if (it)
5420 rc = dfs_cache_noreq_update_tgthint(tcon->dfs_path + 1, it);
5421 else
5422 rc = -ENOENT;
5423 }
5424 dfs_cache_free_tgts(&tl);
5425 out:
5426 kfree(tree);
5427 return rc;
5428 }
5429 #else
5430 int cifs_tree_connect(const unsigned int xid, struct cifs_tcon *tcon, const struct nls_table *nlsc)
5431 {
5432 const struct smb_version_operations *ops = tcon->ses->server->ops;
5433
5434 return ops->tree_connect(xid, tcon->ses, tcon->treeName, tcon, nlsc);
5435 }
5436 #endif
Ubuntu Jammy Linux kernel mirror