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