?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'regmap-fix-v5.11-rc2' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux/fpc-iii.git] / fs / cifs / connect.c
blobb9df85506938d55fa86ac2ceaf19ad61ad188b43
1 /*
2 * fs/cifs/connect.c
3 *
4 * Copyright (C) International Business Machines Corp., 2002,2011
5 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21 #include <linux/fs.h>
22 #include <linux/net.h>
23 #include <linux/string.h>
24 #include <linux/sched/mm.h>
25 #include <linux/sched/signal.h>
26 #include <linux/list.h>
27 #include <linux/wait.h>
28 #include <linux/slab.h>
29 #include <linux/pagemap.h>
30 #include <linux/ctype.h>
31 #include <linux/utsname.h>
32 #include <linux/mempool.h>
33 #include <linux/delay.h>
34 #include <linux/completion.h>
35 #include <linux/kthread.h>
36 #include <linux/pagevec.h>
37 #include <linux/freezer.h>
38 #include <linux/namei.h>
39 #include <linux/uuid.h>
40 #include <linux/uaccess.h>
41 #include <asm/processor.h>
42 #include <linux/inet.h>
43 #include <linux/module.h>
44 #include <keys/user-type.h>
45 #include <net/ipv6.h>
46 #include <linux/parser.h>
47 #include <linux/bvec.h>
48 #include "cifspdu.h"
49 #include "cifsglob.h"
50 #include "cifsproto.h"
51 #include "cifs_unicode.h"
52 #include "cifs_debug.h"
53 #include "cifs_fs_sb.h"
54 #include "ntlmssp.h"
55 #include "nterr.h"
56 #include "rfc1002pdu.h"
57 #include "fscache.h"
58 #include "smb2proto.h"
59 #include "smbdirect.h"
60 #include "dns_resolve.h"
61 #ifdef CONFIG_CIFS_DFS_UPCALL
62 #include "dfs_cache.h"
63 #endif
64 #include "fs_context.h"
65 #ifdef CONFIG_CIFS_SWN_UPCALL
66 #include "cifs_swn.h"
67 #endif
68
69 extern mempool_t *cifs_req_poolp;
70 extern bool disable_legacy_dialects;
71
72 /* FIXME: should these be tunable? */
73 #define TLINK_ERROR_EXPIRE (1 * HZ)
74 #define TLINK_IDLE_EXPIRE (600 * HZ)
75
76 /* Drop the connection to not overload the server */
77 #define NUM_STATUS_IO_TIMEOUT 5
78
79 static int ip_connect(struct TCP_Server_Info *server);
80 static int generic_ip_connect(struct TCP_Server_Info *server);
81 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
82 static void cifs_prune_tlinks(struct work_struct *work);
83
84 /*
85 * Resolve hostname and set ip addr in tcp ses. Useful for hostnames that may
86 * get their ip addresses changed at some point.
87 *
88 * This should be called with server->srv_mutex held.
89 */
90 #ifdef CONFIG_CIFS_DFS_UPCALL
91 static int reconn_set_ipaddr_from_hostname(struct TCP_Server_Info *server)
92 {
93 int rc;
94 int len;
95 char *unc, *ipaddr = NULL;
96
97 if (!server->hostname)
98 return -EINVAL;
99
100 len = strlen(server->hostname) + 3;
101
102 unc = kmalloc(len, GFP_KERNEL);
103 if (!unc) {
104 cifs_dbg(FYI, "%s: failed to create UNC path\n", __func__);
105 return -ENOMEM;
106 }
107 scnprintf(unc, len, "\\\\%s", server->hostname);
108
109 rc = dns_resolve_server_name_to_ip(unc, &ipaddr);
110 kfree(unc);
111
112 if (rc < 0) {
113 cifs_dbg(FYI, "%s: failed to resolve server part of %s to IP: %d\n",
114 __func__, server->hostname, rc);
115 return rc;
116 }
117
118 spin_lock(&cifs_tcp_ses_lock);
119 rc = cifs_convert_address((struct sockaddr *)&server->dstaddr, ipaddr,
120 strlen(ipaddr));
121 spin_unlock(&cifs_tcp_ses_lock);
122 kfree(ipaddr);
123
124 return !rc ? -1 : 0;
125 }
126
127 /* These functions must be called with server->srv_mutex held */
128 static void reconn_set_next_dfs_target(struct TCP_Server_Info *server,
129 struct cifs_sb_info *cifs_sb,
130 struct dfs_cache_tgt_list *tgt_list,
131 struct dfs_cache_tgt_iterator **tgt_it)
132 {
133 const char *name;
134 int rc;
135
136 if (!cifs_sb || !cifs_sb->origin_fullpath)
137 return;
138
139 if (!*tgt_it) {
140 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
141 } else {
142 *tgt_it = dfs_cache_get_next_tgt(tgt_list, *tgt_it);
143 if (!*tgt_it)
144 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
145 }
146
147 cifs_dbg(FYI, "%s: UNC: %s\n", __func__, cifs_sb->origin_fullpath);
148
149 name = dfs_cache_get_tgt_name(*tgt_it);
150
151 kfree(server->hostname);
152
153 server->hostname = extract_hostname(name);
154 if (IS_ERR(server->hostname)) {
155 cifs_dbg(FYI,
156 "%s: failed to extract hostname from target: %ld\n",
157 __func__, PTR_ERR(server->hostname));
158 return;
159 }
160
161 rc = reconn_set_ipaddr_from_hostname(server);
162 if (rc) {
163 cifs_dbg(FYI, "%s: failed to resolve hostname: %d\n",
164 __func__, rc);
165 }
166 }
167
168 static inline int reconn_setup_dfs_targets(struct cifs_sb_info *cifs_sb,
169 struct dfs_cache_tgt_list *tl)
170 {
171 if (!cifs_sb->origin_fullpath)
172 return -EOPNOTSUPP;
173 return dfs_cache_noreq_find(cifs_sb->origin_fullpath + 1, NULL, tl);
174 }
175 #endif
176
177 /*
178 * cifs tcp session reconnection
179 *
180 * mark tcp session as reconnecting so temporarily locked
181 * mark all smb sessions as reconnecting for tcp session
182 * reconnect tcp session
183 * wake up waiters on reconnection? - (not needed currently)
184 */
185 int
186 cifs_reconnect(struct TCP_Server_Info *server)
187 {
188 int rc = 0;
189 struct list_head *tmp, *tmp2;
190 struct cifs_ses *ses;
191 struct cifs_tcon *tcon;
192 struct mid_q_entry *mid_entry;
193 struct list_head retry_list;
194 #ifdef CONFIG_CIFS_DFS_UPCALL
195 struct super_block *sb = NULL;
196 struct cifs_sb_info *cifs_sb = NULL;
197 struct dfs_cache_tgt_list tgt_list = {0};
198 struct dfs_cache_tgt_iterator *tgt_it = NULL;
199 #endif
200
201 spin_lock(&GlobalMid_Lock);
202 server->nr_targets = 1;
203 #ifdef CONFIG_CIFS_DFS_UPCALL
204 spin_unlock(&GlobalMid_Lock);
205 sb = cifs_get_tcp_super(server);
206 if (IS_ERR(sb)) {
207 rc = PTR_ERR(sb);
208 cifs_dbg(FYI, "%s: will not do DFS failover: rc = %d\n",
209 __func__, rc);
210 sb = NULL;
211 } else {
212 cifs_sb = CIFS_SB(sb);
213 rc = reconn_setup_dfs_targets(cifs_sb, &tgt_list);
214 if (rc) {
215 cifs_sb = NULL;
216 if (rc != -EOPNOTSUPP) {
217 cifs_server_dbg(VFS, "%s: no target servers for DFS failover\n",
218 __func__);
219 }
220 } else {
221 server->nr_targets = dfs_cache_get_nr_tgts(&tgt_list);
222 }
223 }
224 cifs_dbg(FYI, "%s: will retry %d target(s)\n", __func__,
225 server->nr_targets);
226 spin_lock(&GlobalMid_Lock);
227 #endif
228 if (server->tcpStatus == CifsExiting) {
229 /* the demux thread will exit normally
230 next time through the loop */
231 spin_unlock(&GlobalMid_Lock);
232 #ifdef CONFIG_CIFS_DFS_UPCALL
233 dfs_cache_free_tgts(&tgt_list);
234 cifs_put_tcp_super(sb);
235 #endif
236 wake_up(&server->response_q);
237 return rc;
238 } else
239 server->tcpStatus = CifsNeedReconnect;
240 spin_unlock(&GlobalMid_Lock);
241 server->maxBuf = 0;
242 server->max_read = 0;
243
244 cifs_dbg(FYI, "Mark tcp session as need reconnect\n");
245 trace_smb3_reconnect(server->CurrentMid, server->hostname);
246
247 /* before reconnecting the tcp session, mark the smb session (uid)
248 and the tid bad so they are not used until reconnected */
249 cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
250 __func__);
251 spin_lock(&cifs_tcp_ses_lock);
252 list_for_each(tmp, &server->smb_ses_list) {
253 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
254 ses->need_reconnect = true;
255 list_for_each(tmp2, &ses->tcon_list) {
256 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
257 tcon->need_reconnect = true;
258 }
259 if (ses->tcon_ipc)
260 ses->tcon_ipc->need_reconnect = true;
261 }
262 spin_unlock(&cifs_tcp_ses_lock);
263
264 /* do not want to be sending data on a socket we are freeing */
265 cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
266 mutex_lock(&server->srv_mutex);
267 if (server->ssocket) {
268 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
269 server->ssocket->state, server->ssocket->flags);
270 kernel_sock_shutdown(server->ssocket, SHUT_WR);
271 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
272 server->ssocket->state, server->ssocket->flags);
273 sock_release(server->ssocket);
274 server->ssocket = NULL;
275 }
276 server->sequence_number = 0;
277 server->session_estab = false;
278 kfree(server->session_key.response);
279 server->session_key.response = NULL;
280 server->session_key.len = 0;
281 server->lstrp = jiffies;
282
283 /* mark submitted MIDs for retry and issue callback */
284 INIT_LIST_HEAD(&retry_list);
285 cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
286 spin_lock(&GlobalMid_Lock);
287 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
288 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
289 kref_get(&mid_entry->refcount);
290 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
291 mid_entry->mid_state = MID_RETRY_NEEDED;
292 list_move(&mid_entry->qhead, &retry_list);
293 mid_entry->mid_flags |= MID_DELETED;
294 }
295 spin_unlock(&GlobalMid_Lock);
296 mutex_unlock(&server->srv_mutex);
297
298 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
299 list_for_each_safe(tmp, tmp2, &retry_list) {
300 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
301 list_del_init(&mid_entry->qhead);
302 mid_entry->callback(mid_entry);
303 cifs_mid_q_entry_release(mid_entry);
304 }
305
306 if (cifs_rdma_enabled(server)) {
307 mutex_lock(&server->srv_mutex);
308 smbd_destroy(server);
309 mutex_unlock(&server->srv_mutex);
310 }
311
312 do {
313 try_to_freeze();
314
315 mutex_lock(&server->srv_mutex);
316
317 #ifdef CONFIG_CIFS_SWN_UPCALL
318 if (server->use_swn_dstaddr) {
319 server->dstaddr = server->swn_dstaddr;
320 } else {
321 #endif
322
323 #ifdef CONFIG_CIFS_DFS_UPCALL
324 /*
325 * Set up next DFS target server (if any) for reconnect. If DFS
326 * feature is disabled, then we will retry last server we
327 * connected to before.
328 */
329 reconn_set_next_dfs_target(server, cifs_sb, &tgt_list, &tgt_it);
330 #endif
331
332 #ifdef CONFIG_CIFS_SWN_UPCALL
333 }
334 #endif
335
336 if (cifs_rdma_enabled(server))
337 rc = smbd_reconnect(server);
338 else
339 rc = generic_ip_connect(server);
340 if (rc) {
341 cifs_dbg(FYI, "reconnect error %d\n", rc);
342 mutex_unlock(&server->srv_mutex);
343 msleep(3000);
344 } else {
345 atomic_inc(&tcpSesReconnectCount);
346 set_credits(server, 1);
347 spin_lock(&GlobalMid_Lock);
348 if (server->tcpStatus != CifsExiting)
349 server->tcpStatus = CifsNeedNegotiate;
350 spin_unlock(&GlobalMid_Lock);
351 #ifdef CONFIG_CIFS_SWN_UPCALL
352 server->use_swn_dstaddr = false;
353 #endif
354 mutex_unlock(&server->srv_mutex);
355 }
356 } while (server->tcpStatus == CifsNeedReconnect);
357
358 #ifdef CONFIG_CIFS_DFS_UPCALL
359 if (tgt_it) {
360 rc = dfs_cache_noreq_update_tgthint(cifs_sb->origin_fullpath + 1,
361 tgt_it);
362 if (rc) {
363 cifs_server_dbg(VFS, "%s: failed to update DFS target hint: rc = %d\n",
364 __func__, rc);
365 }
366 rc = dfs_cache_update_vol(cifs_sb->origin_fullpath, server);
367 if (rc) {
368 cifs_server_dbg(VFS, "%s: failed to update vol info in DFS cache: rc = %d\n",
369 __func__, rc);
370 }
371 dfs_cache_free_tgts(&tgt_list);
372
373 }
374
375 cifs_put_tcp_super(sb);
376 #endif
377 if (server->tcpStatus == CifsNeedNegotiate)
378 mod_delayed_work(cifsiod_wq, &server->echo, 0);
379
380 wake_up(&server->response_q);
381 return rc;
382 }
383
384 static void
385 cifs_echo_request(struct work_struct *work)
386 {
387 int rc;
388 struct TCP_Server_Info *server = container_of(work,
389 struct TCP_Server_Info, echo.work);
390 unsigned long echo_interval;
391
392 /*
393 * If we need to renegotiate, set echo interval to zero to
394 * immediately call echo service where we can renegotiate.
395 */
396 if (server->tcpStatus == CifsNeedNegotiate)
397 echo_interval = 0;
398 else
399 echo_interval = server->echo_interval;
400
401 /*
402 * We cannot send an echo if it is disabled.
403 * Also, no need to ping if we got a response recently.
404 */
405
406 if (server->tcpStatus == CifsNeedReconnect ||
407 server->tcpStatus == CifsExiting ||
408 server->tcpStatus == CifsNew ||
409 (server->ops->can_echo && !server->ops->can_echo(server)) ||
410 time_before(jiffies, server->lstrp + echo_interval - HZ))
411 goto requeue_echo;
412
413 rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
414 if (rc)
415 cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
416 server->hostname);
417
418 #ifdef CONFIG_CIFS_SWN_UPCALL
419 /* Check witness registrations */
420 cifs_swn_check();
421 #endif
422
423 requeue_echo:
424 queue_delayed_work(cifsiod_wq, &server->echo, server->echo_interval);
425 }
426
427 static bool
428 allocate_buffers(struct TCP_Server_Info *server)
429 {
430 if (!server->bigbuf) {
431 server->bigbuf = (char *)cifs_buf_get();
432 if (!server->bigbuf) {
433 cifs_server_dbg(VFS, "No memory for large SMB response\n");
434 msleep(3000);
435 /* retry will check if exiting */
436 return false;
437 }
438 } else if (server->large_buf) {
439 /* we are reusing a dirty large buf, clear its start */
440 memset(server->bigbuf, 0, HEADER_SIZE(server));
441 }
442
443 if (!server->smallbuf) {
444 server->smallbuf = (char *)cifs_small_buf_get();
445 if (!server->smallbuf) {
446 cifs_server_dbg(VFS, "No memory for SMB response\n");
447 msleep(1000);
448 /* retry will check if exiting */
449 return false;
450 }
451 /* beginning of smb buffer is cleared in our buf_get */
452 } else {
453 /* if existing small buf clear beginning */
454 memset(server->smallbuf, 0, HEADER_SIZE(server));
455 }
456
457 return true;
458 }
459
460 static bool
461 server_unresponsive(struct TCP_Server_Info *server)
462 {
463 /*
464 * We need to wait 3 echo intervals to make sure we handle such
465 * situations right:
466 * 1s client sends a normal SMB request
467 * 2s client gets a response
468 * 30s echo workqueue job pops, and decides we got a response recently
469 * and don't need to send another
470 * ...
471 * 65s kernel_recvmsg times out, and we see that we haven't gotten
472 * a response in >60s.
473 */
474 if ((server->tcpStatus == CifsGood ||
475 server->tcpStatus == CifsNeedNegotiate) &&
476 time_after(jiffies, server->lstrp + 3 * server->echo_interval)) {
477 cifs_server_dbg(VFS, "has not responded in %lu seconds. Reconnecting...\n",
478 (3 * server->echo_interval) / HZ);
479 cifs_reconnect(server);
480 return true;
481 }
482
483 return false;
484 }
485
486 static inline bool
487 zero_credits(struct TCP_Server_Info *server)
488 {
489 int val;
490
491 spin_lock(&server->req_lock);
492 val = server->credits + server->echo_credits + server->oplock_credits;
493 if (server->in_flight == 0 && val == 0) {
494 spin_unlock(&server->req_lock);
495 return true;
496 }
497 spin_unlock(&server->req_lock);
498 return false;
499 }
500
501 static int
502 cifs_readv_from_socket(struct TCP_Server_Info *server, struct msghdr *smb_msg)
503 {
504 int length = 0;
505 int total_read;
506
507 smb_msg->msg_control = NULL;
508 smb_msg->msg_controllen = 0;
509
510 for (total_read = 0; msg_data_left(smb_msg); total_read += length) {
511 try_to_freeze();
512
513 /* reconnect if no credits and no requests in flight */
514 if (zero_credits(server)) {
515 cifs_reconnect(server);
516 return -ECONNABORTED;
517 }
518
519 if (server_unresponsive(server))
520 return -ECONNABORTED;
521 if (cifs_rdma_enabled(server) && server->smbd_conn)
522 length = smbd_recv(server->smbd_conn, smb_msg);
523 else
524 length = sock_recvmsg(server->ssocket, smb_msg, 0);
525
526 if (server->tcpStatus == CifsExiting)
527 return -ESHUTDOWN;
528
529 if (server->tcpStatus == CifsNeedReconnect) {
530 cifs_reconnect(server);
531 return -ECONNABORTED;
532 }
533
534 if (length == -ERESTARTSYS ||
535 length == -EAGAIN ||
536 length == -EINTR) {
537 /*
538 * Minimum sleep to prevent looping, allowing socket
539 * to clear and app threads to set tcpStatus
540 * CifsNeedReconnect if server hung.
541 */
542 usleep_range(1000, 2000);
543 length = 0;
544 continue;
545 }
546
547 if (length <= 0) {
548 cifs_dbg(FYI, "Received no data or error: %d\n", length);
549 cifs_reconnect(server);
550 return -ECONNABORTED;
551 }
552 }
553 return total_read;
554 }
555
556 int
557 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
558 unsigned int to_read)
559 {
560 struct msghdr smb_msg;
561 struct kvec iov = {.iov_base = buf, .iov_len = to_read};
562 iov_iter_kvec(&smb_msg.msg_iter, READ, &iov, 1, to_read);
563
564 return cifs_readv_from_socket(server, &smb_msg);
565 }
566
567 int
568 cifs_read_page_from_socket(struct TCP_Server_Info *server, struct page *page,
569 unsigned int page_offset, unsigned int to_read)
570 {
571 struct msghdr smb_msg;
572 struct bio_vec bv = {
573 .bv_page = page, .bv_len = to_read, .bv_offset = page_offset};
574 iov_iter_bvec(&smb_msg.msg_iter, READ, &bv, 1, to_read);
575 return cifs_readv_from_socket(server, &smb_msg);
576 }
577
578 static bool
579 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
580 {
581 /*
582 * The first byte big endian of the length field,
583 * is actually not part of the length but the type
584 * with the most common, zero, as regular data.
585 */
586 switch (type) {
587 case RFC1002_SESSION_MESSAGE:
588 /* Regular SMB response */
589 return true;
590 case RFC1002_SESSION_KEEP_ALIVE:
591 cifs_dbg(FYI, "RFC 1002 session keep alive\n");
592 break;
593 case RFC1002_POSITIVE_SESSION_RESPONSE:
594 cifs_dbg(FYI, "RFC 1002 positive session response\n");
595 break;
596 case RFC1002_NEGATIVE_SESSION_RESPONSE:
597 /*
598 * We get this from Windows 98 instead of an error on
599 * SMB negprot response.
600 */
601 cifs_dbg(FYI, "RFC 1002 negative session response\n");
602 /* give server a second to clean up */
603 msleep(1000);
604 /*
605 * Always try 445 first on reconnect since we get NACK
606 * on some if we ever connected to port 139 (the NACK
607 * is since we do not begin with RFC1001 session
608 * initialize frame).
609 */
610 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
611 cifs_reconnect(server);
612 break;
613 default:
614 cifs_server_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
615 cifs_reconnect(server);
616 }
617
618 return false;
619 }
620
621 void
622 dequeue_mid(struct mid_q_entry *mid, bool malformed)
623 {
624 #ifdef CONFIG_CIFS_STATS2
625 mid->when_received = jiffies;
626 #endif
627 spin_lock(&GlobalMid_Lock);
628 if (!malformed)
629 mid->mid_state = MID_RESPONSE_RECEIVED;
630 else
631 mid->mid_state = MID_RESPONSE_MALFORMED;
632 /*
633 * Trying to handle/dequeue a mid after the send_recv()
634 * function has finished processing it is a bug.
635 */
636 if (mid->mid_flags & MID_DELETED)
637 pr_warn_once("trying to dequeue a deleted mid\n");
638 else {
639 list_del_init(&mid->qhead);
640 mid->mid_flags |= MID_DELETED;
641 }
642 spin_unlock(&GlobalMid_Lock);
643 }
644
645 static unsigned int
646 smb2_get_credits_from_hdr(char *buffer, struct TCP_Server_Info *server)
647 {
648 struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)buffer;
649
650 /*
651 * SMB1 does not use credits.
652 */
653 if (server->vals->header_preamble_size)
654 return 0;
655
656 return le16_to_cpu(shdr->CreditRequest);
657 }
658
659 static void
660 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
661 char *buf, int malformed)
662 {
663 if (server->ops->check_trans2 &&
664 server->ops->check_trans2(mid, server, buf, malformed))
665 return;
666 mid->credits_received = smb2_get_credits_from_hdr(buf, server);
667 mid->resp_buf = buf;
668 mid->large_buf = server->large_buf;
669 /* Was previous buf put in mpx struct for multi-rsp? */
670 if (!mid->multiRsp) {
671 /* smb buffer will be freed by user thread */
672 if (server->large_buf)
673 server->bigbuf = NULL;
674 else
675 server->smallbuf = NULL;
676 }
677 dequeue_mid(mid, malformed);
678 }
679
680 static void clean_demultiplex_info(struct TCP_Server_Info *server)
681 {
682 int length;
683
684 /* take it off the list, if it's not already */
685 spin_lock(&cifs_tcp_ses_lock);
686 list_del_init(&server->tcp_ses_list);
687 spin_unlock(&cifs_tcp_ses_lock);
688
689 cancel_delayed_work_sync(&server->echo);
690
691 spin_lock(&GlobalMid_Lock);
692 server->tcpStatus = CifsExiting;
693 spin_unlock(&GlobalMid_Lock);
694 wake_up_all(&server->response_q);
695
696 /* check if we have blocked requests that need to free */
697 spin_lock(&server->req_lock);
698 if (server->credits <= 0)
699 server->credits = 1;
700 spin_unlock(&server->req_lock);
701 /*
702 * Although there should not be any requests blocked on this queue it
703 * can not hurt to be paranoid and try to wake up requests that may
704 * haven been blocked when more than 50 at time were on the wire to the
705 * same server - they now will see the session is in exit state and get
706 * out of SendReceive.
707 */
708 wake_up_all(&server->request_q);
709 /* give those requests time to exit */
710 msleep(125);
711 if (cifs_rdma_enabled(server))
712 smbd_destroy(server);
713 if (server->ssocket) {
714 sock_release(server->ssocket);
715 server->ssocket = NULL;
716 }
717
718 if (!list_empty(&server->pending_mid_q)) {
719 struct list_head dispose_list;
720 struct mid_q_entry *mid_entry;
721 struct list_head *tmp, *tmp2;
722
723 INIT_LIST_HEAD(&dispose_list);
724 spin_lock(&GlobalMid_Lock);
725 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
726 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
727 cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid);
728 kref_get(&mid_entry->refcount);
729 mid_entry->mid_state = MID_SHUTDOWN;
730 list_move(&mid_entry->qhead, &dispose_list);
731 mid_entry->mid_flags |= MID_DELETED;
732 }
733 spin_unlock(&GlobalMid_Lock);
734
735 /* now walk dispose list and issue callbacks */
736 list_for_each_safe(tmp, tmp2, &dispose_list) {
737 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
738 cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid);
739 list_del_init(&mid_entry->qhead);
740 mid_entry->callback(mid_entry);
741 cifs_mid_q_entry_release(mid_entry);
742 }
743 /* 1/8th of sec is more than enough time for them to exit */
744 msleep(125);
745 }
746
747 if (!list_empty(&server->pending_mid_q)) {
748 /*
749 * mpx threads have not exited yet give them at least the smb
750 * send timeout time for long ops.
751 *
752 * Due to delays on oplock break requests, we need to wait at
753 * least 45 seconds before giving up on a request getting a
754 * response and going ahead and killing cifsd.
755 */
756 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
757 msleep(46000);
758 /*
759 * If threads still have not exited they are probably never
760 * coming home not much else we can do but free the memory.
761 */
762 }
763
764 kfree(server->hostname);
765 kfree(server);
766
767 length = atomic_dec_return(&tcpSesAllocCount);
768 if (length > 0)
769 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
770 }
771
772 static int
773 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
774 {
775 int length;
776 char *buf = server->smallbuf;
777 unsigned int pdu_length = server->pdu_size;
778
779 /* make sure this will fit in a large buffer */
780 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) -
781 server->vals->header_preamble_size) {
782 cifs_server_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
783 cifs_reconnect(server);
784 return -ECONNABORTED;
785 }
786
787 /* switch to large buffer if too big for a small one */
788 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
789 server->large_buf = true;
790 memcpy(server->bigbuf, buf, server->total_read);
791 buf = server->bigbuf;
792 }
793
794 /* now read the rest */
795 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
796 pdu_length - HEADER_SIZE(server) + 1
797 + server->vals->header_preamble_size);
798
799 if (length < 0)
800 return length;
801 server->total_read += length;
802
803 dump_smb(buf, server->total_read);
804
805 return cifs_handle_standard(server, mid);
806 }
807
808 int
809 cifs_handle_standard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
810 {
811 char *buf = server->large_buf ? server->bigbuf : server->smallbuf;
812 int length;
813
814 /*
815 * We know that we received enough to get to the MID as we
816 * checked the pdu_length earlier. Now check to see
817 * if the rest of the header is OK. We borrow the length
818 * var for the rest of the loop to avoid a new stack var.
819 *
820 * 48 bytes is enough to display the header and a little bit
821 * into the payload for debugging purposes.
822 */
823 length = server->ops->check_message(buf, server->total_read, server);
824 if (length != 0)
825 cifs_dump_mem("Bad SMB: ", buf,
826 min_t(unsigned int, server->total_read, 48));
827
828 if (server->ops->is_session_expired &&
829 server->ops->is_session_expired(buf)) {
830 cifs_reconnect(server);
831 return -1;
832 }
833
834 if (server->ops->is_status_pending &&
835 server->ops->is_status_pending(buf, server))
836 return -1;
837
838 if (!mid)
839 return length;
840
841 handle_mid(mid, server, buf, length);
842 return 0;
843 }
844
845 static void
846 smb2_add_credits_from_hdr(char *buffer, struct TCP_Server_Info *server)
847 {
848 struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)buffer;
849 int scredits = server->credits;
850
851 /*
852 * SMB1 does not use credits.
853 */
854 if (server->vals->header_preamble_size)
855 return;
856
857 if (shdr->CreditRequest) {
858 spin_lock(&server->req_lock);
859 server->credits += le16_to_cpu(shdr->CreditRequest);
860 spin_unlock(&server->req_lock);
861 wake_up(&server->request_q);
862
863 trace_smb3_add_credits(server->CurrentMid,
864 server->hostname, scredits,
865 le16_to_cpu(shdr->CreditRequest));
866 cifs_server_dbg(FYI, "%s: added %u credits total=%d\n",
867 __func__, le16_to_cpu(shdr->CreditRequest),
868 scredits);
869 }
870 }
871
872
873 static int
874 cifs_demultiplex_thread(void *p)
875 {
876 int i, num_mids, length;
877 struct TCP_Server_Info *server = p;
878 unsigned int pdu_length;
879 unsigned int next_offset;
880 char *buf = NULL;
881 struct task_struct *task_to_wake = NULL;
882 struct mid_q_entry *mids[MAX_COMPOUND];
883 char *bufs[MAX_COMPOUND];
884 unsigned int noreclaim_flag, num_io_timeout = 0;
885
886 noreclaim_flag = memalloc_noreclaim_save();
887 cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
888
889 length = atomic_inc_return(&tcpSesAllocCount);
890 if (length > 1)
891 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
892
893 set_freezable();
894 allow_kernel_signal(SIGKILL);
895 while (server->tcpStatus != CifsExiting) {
896 if (try_to_freeze())
897 continue;
898
899 if (!allocate_buffers(server))
900 continue;
901
902 server->large_buf = false;
903 buf = server->smallbuf;
904 pdu_length = 4; /* enough to get RFC1001 header */
905
906 length = cifs_read_from_socket(server, buf, pdu_length);
907 if (length < 0)
908 continue;
909
910 if (server->vals->header_preamble_size == 0)
911 server->total_read = 0;
912 else
913 server->total_read = length;
914
915 /*
916 * The right amount was read from socket - 4 bytes,
917 * so we can now interpret the length field.
918 */
919 pdu_length = get_rfc1002_length(buf);
920
921 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
922 if (!is_smb_response(server, buf[0]))
923 continue;
924 next_pdu:
925 server->pdu_size = pdu_length;
926
927 /* make sure we have enough to get to the MID */
928 if (server->pdu_size < HEADER_SIZE(server) - 1 -
929 server->vals->header_preamble_size) {
930 cifs_server_dbg(VFS, "SMB response too short (%u bytes)\n",
931 server->pdu_size);
932 cifs_reconnect(server);
933 continue;
934 }
935
936 /* read down to the MID */
937 length = cifs_read_from_socket(server,
938 buf + server->vals->header_preamble_size,
939 HEADER_SIZE(server) - 1
940 - server->vals->header_preamble_size);
941 if (length < 0)
942 continue;
943 server->total_read += length;
944
945 if (server->ops->next_header) {
946 next_offset = server->ops->next_header(buf);
947 if (next_offset)
948 server->pdu_size = next_offset;
949 }
950
951 memset(mids, 0, sizeof(mids));
952 memset(bufs, 0, sizeof(bufs));
953 num_mids = 0;
954
955 if (server->ops->is_transform_hdr &&
956 server->ops->receive_transform &&
957 server->ops->is_transform_hdr(buf)) {
958 length = server->ops->receive_transform(server,
959 mids,
960 bufs,
961 &num_mids);
962 } else {
963 mids[0] = server->ops->find_mid(server, buf);
964 bufs[0] = buf;
965 num_mids = 1;
966
967 if (!mids[0] || !mids[0]->receive)
968 length = standard_receive3(server, mids[0]);
969 else
970 length = mids[0]->receive(server, mids[0]);
971 }
972
973 if (length < 0) {
974 for (i = 0; i < num_mids; i++)
975 if (mids[i])
976 cifs_mid_q_entry_release(mids[i]);
977 continue;
978 }
979
980 if (server->ops->is_status_io_timeout &&
981 server->ops->is_status_io_timeout(buf)) {
982 num_io_timeout++;
983 if (num_io_timeout > NUM_STATUS_IO_TIMEOUT) {
984 cifs_reconnect(server);
985 num_io_timeout = 0;
986 continue;
987 }
988 }
989
990 server->lstrp = jiffies;
991
992 for (i = 0; i < num_mids; i++) {
993 if (mids[i] != NULL) {
994 mids[i]->resp_buf_size = server->pdu_size;
995
996 if (!mids[i]->multiRsp || mids[i]->multiEnd)
997 mids[i]->callback(mids[i]);
998
999 cifs_mid_q_entry_release(mids[i]);
1000 } else if (server->ops->is_oplock_break &&
1001 server->ops->is_oplock_break(bufs[i],
1002 server)) {
1003 smb2_add_credits_from_hdr(bufs[i], server);
1004 cifs_dbg(FYI, "Received oplock break\n");
1005 } else {
1006 cifs_server_dbg(VFS, "No task to wake, unknown frame received! NumMids %d\n",
1007 atomic_read(&midCount));
1008 cifs_dump_mem("Received Data is: ", bufs[i],
1009 HEADER_SIZE(server));
1010 smb2_add_credits_from_hdr(bufs[i], server);
1011 #ifdef CONFIG_CIFS_DEBUG2
1012 if (server->ops->dump_detail)
1013 server->ops->dump_detail(bufs[i],
1014 server);
1015 cifs_dump_mids(server);
1016 #endif /* CIFS_DEBUG2 */
1017 }
1018 }
1019
1020 if (pdu_length > server->pdu_size) {
1021 if (!allocate_buffers(server))
1022 continue;
1023 pdu_length -= server->pdu_size;
1024 server->total_read = 0;
1025 server->large_buf = false;
1026 buf = server->smallbuf;
1027 goto next_pdu;
1028 }
1029 } /* end while !EXITING */
1030
1031 /* buffer usually freed in free_mid - need to free it here on exit */
1032 cifs_buf_release(server->bigbuf);
1033 if (server->smallbuf) /* no sense logging a debug message if NULL */
1034 cifs_small_buf_release(server->smallbuf);
1035
1036 task_to_wake = xchg(&server->tsk, NULL);
1037 clean_demultiplex_info(server);
1038
1039 /* if server->tsk was NULL then wait for a signal before exiting */
1040 if (!task_to_wake) {
1041 set_current_state(TASK_INTERRUPTIBLE);
1042 while (!signal_pending(current)) {
1043 schedule();
1044 set_current_state(TASK_INTERRUPTIBLE);
1045 }
1046 set_current_state(TASK_RUNNING);
1047 }
1048
1049 memalloc_noreclaim_restore(noreclaim_flag);
1050 module_put_and_exit(0);
1051 }
1052
1053 /**
1054 * Returns true if srcaddr isn't specified and rhs isn't specified, or
1055 * if srcaddr is specified and matches the IP address of the rhs argument
1056 */
1057 bool
1058 cifs_match_ipaddr(struct sockaddr *srcaddr, struct sockaddr *rhs)
1059 {
1060 switch (srcaddr->sa_family) {
1061 case AF_UNSPEC:
1062 return (rhs->sa_family == AF_UNSPEC);
1063 case AF_INET: {
1064 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1065 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1066 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1067 }
1068 case AF_INET6: {
1069 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1070 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
1071 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1072 }
1073 default:
1074 WARN_ON(1);
1075 return false; /* don't expect to be here */
1076 }
1077 }
1078
1079 /*
1080 * If no port is specified in addr structure, we try to match with 445 port
1081 * and if it fails - with 139 ports. It should be called only if address
1082 * families of server and addr are equal.
1083 */
1084 static bool
1085 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1086 {
1087 __be16 port, *sport;
1088
1089 /* SMBDirect manages its own ports, don't match it here */
1090 if (server->rdma)
1091 return true;
1092
1093 switch (addr->sa_family) {
1094 case AF_INET:
1095 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1096 port = ((struct sockaddr_in *) addr)->sin_port;
1097 break;
1098 case AF_INET6:
1099 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1100 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1101 break;
1102 default:
1103 WARN_ON(1);
1104 return false;
1105 }
1106
1107 if (!port) {
1108 port = htons(CIFS_PORT);
1109 if (port == *sport)
1110 return true;
1111
1112 port = htons(RFC1001_PORT);
1113 }
1114
1115 return port == *sport;
1116 }
1117
1118 static bool
1119 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1120 struct sockaddr *srcaddr)
1121 {
1122 switch (addr->sa_family) {
1123 case AF_INET: {
1124 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1125 struct sockaddr_in *srv_addr4 =
1126 (struct sockaddr_in *)&server->dstaddr;
1127
1128 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1129 return false;
1130 break;
1131 }
1132 case AF_INET6: {
1133 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1134 struct sockaddr_in6 *srv_addr6 =
1135 (struct sockaddr_in6 *)&server->dstaddr;
1136
1137 if (!ipv6_addr_equal(&addr6->sin6_addr,
1138 &srv_addr6->sin6_addr))
1139 return false;
1140 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
1141 return false;
1142 break;
1143 }
1144 default:
1145 WARN_ON(1);
1146 return false; /* don't expect to be here */
1147 }
1148
1149 if (!cifs_match_ipaddr(srcaddr, (struct sockaddr *)&server->srcaddr))
1150 return false;
1151
1152 return true;
1153 }
1154
1155 static bool
1156 match_security(struct TCP_Server_Info *server, struct smb3_fs_context *ctx)
1157 {
1158 /*
1159 * The select_sectype function should either return the ctx->sectype
1160 * that was specified, or "Unspecified" if that sectype was not
1161 * compatible with the given NEGOTIATE request.
1162 */
1163 if (server->ops->select_sectype(server, ctx->sectype)
1164 == Unspecified)
1165 return false;
1166
1167 /*
1168 * Now check if signing mode is acceptable. No need to check
1169 * global_secflags at this point since if MUST_SIGN is set then
1170 * the server->sign had better be too.
1171 */
1172 if (ctx->sign && !server->sign)
1173 return false;
1174
1175 return true;
1176 }
1177
1178 static int match_server(struct TCP_Server_Info *server, struct smb3_fs_context *ctx)
1179 {
1180 struct sockaddr *addr = (struct sockaddr *)&ctx->dstaddr;
1181
1182 if (ctx->nosharesock)
1183 return 0;
1184
1185 /* If multidialect negotiation see if existing sessions match one */
1186 if (strcmp(ctx->vals->version_string, SMB3ANY_VERSION_STRING) == 0) {
1187 if (server->vals->protocol_id < SMB30_PROT_ID)
1188 return 0;
1189 } else if (strcmp(ctx->vals->version_string,
1190 SMBDEFAULT_VERSION_STRING) == 0) {
1191 if (server->vals->protocol_id < SMB21_PROT_ID)
1192 return 0;
1193 } else if ((server->vals != ctx->vals) || (server->ops != ctx->ops))
1194 return 0;
1195
1196 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
1197 return 0;
1198
1199 if (!match_address(server, addr,
1200 (struct sockaddr *)&ctx->srcaddr))
1201 return 0;
1202
1203 if (!match_port(server, addr))
1204 return 0;
1205
1206 if (!match_security(server, ctx))
1207 return 0;
1208
1209 if (server->echo_interval != ctx->echo_interval * HZ)
1210 return 0;
1211
1212 if (server->rdma != ctx->rdma)
1213 return 0;
1214
1215 if (server->ignore_signature != ctx->ignore_signature)
1216 return 0;
1217
1218 if (server->min_offload != ctx->min_offload)
1219 return 0;
1220
1221 return 1;
1222 }
1223
1224 struct TCP_Server_Info *
1225 cifs_find_tcp_session(struct smb3_fs_context *ctx)
1226 {
1227 struct TCP_Server_Info *server;
1228
1229 spin_lock(&cifs_tcp_ses_lock);
1230 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
1231 /*
1232 * Skip ses channels since they're only handled in lower layers
1233 * (e.g. cifs_send_recv).
1234 */
1235 if (server->is_channel || !match_server(server, ctx))
1236 continue;
1237
1238 ++server->srv_count;
1239 spin_unlock(&cifs_tcp_ses_lock);
1240 cifs_dbg(FYI, "Existing tcp session with server found\n");
1241 return server;
1242 }
1243 spin_unlock(&cifs_tcp_ses_lock);
1244 return NULL;
1245 }
1246
1247 void
1248 cifs_put_tcp_session(struct TCP_Server_Info *server, int from_reconnect)
1249 {
1250 struct task_struct *task;
1251
1252 spin_lock(&cifs_tcp_ses_lock);
1253 if (--server->srv_count > 0) {
1254 spin_unlock(&cifs_tcp_ses_lock);
1255 return;
1256 }
1257
1258 put_net(cifs_net_ns(server));
1259
1260 list_del_init(&server->tcp_ses_list);
1261 spin_unlock(&cifs_tcp_ses_lock);
1262
1263 cancel_delayed_work_sync(&server->echo);
1264
1265 if (from_reconnect)
1266 /*
1267 * Avoid deadlock here: reconnect work calls
1268 * cifs_put_tcp_session() at its end. Need to be sure
1269 * that reconnect work does nothing with server pointer after
1270 * that step.
1271 */
1272 cancel_delayed_work(&server->reconnect);
1273 else
1274 cancel_delayed_work_sync(&server->reconnect);
1275
1276 spin_lock(&GlobalMid_Lock);
1277 server->tcpStatus = CifsExiting;
1278 spin_unlock(&GlobalMid_Lock);
1279
1280 cifs_crypto_secmech_release(server);
1281 cifs_fscache_release_client_cookie(server);
1282
1283 kfree(server->session_key.response);
1284 server->session_key.response = NULL;
1285 server->session_key.len = 0;
1286
1287 task = xchg(&server->tsk, NULL);
1288 if (task)
1289 send_sig(SIGKILL, task, 1);
1290 }
1291
1292 struct TCP_Server_Info *
1293 cifs_get_tcp_session(struct smb3_fs_context *ctx)
1294 {
1295 struct TCP_Server_Info *tcp_ses = NULL;
1296 int rc;
1297
1298 cifs_dbg(FYI, "UNC: %s\n", ctx->UNC);
1299
1300 /* see if we already have a matching tcp_ses */
1301 tcp_ses = cifs_find_tcp_session(ctx);
1302 if (tcp_ses)
1303 return tcp_ses;
1304
1305 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1306 if (!tcp_ses) {
1307 rc = -ENOMEM;
1308 goto out_err;
1309 }
1310
1311 tcp_ses->ops = ctx->ops;
1312 tcp_ses->vals = ctx->vals;
1313 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
1314 tcp_ses->hostname = extract_hostname(ctx->UNC);
1315 if (IS_ERR(tcp_ses->hostname)) {
1316 rc = PTR_ERR(tcp_ses->hostname);
1317 goto out_err_crypto_release;
1318 }
1319
1320 tcp_ses->noblockcnt = ctx->rootfs;
1321 tcp_ses->noblocksnd = ctx->noblocksnd || ctx->rootfs;
1322 tcp_ses->noautotune = ctx->noautotune;
1323 tcp_ses->tcp_nodelay = ctx->sockopt_tcp_nodelay;
1324 tcp_ses->rdma = ctx->rdma;
1325 tcp_ses->in_flight = 0;
1326 tcp_ses->max_in_flight = 0;
1327 tcp_ses->credits = 1;
1328 init_waitqueue_head(&tcp_ses->response_q);
1329 init_waitqueue_head(&tcp_ses->request_q);
1330 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1331 mutex_init(&tcp_ses->srv_mutex);
1332 memcpy(tcp_ses->workstation_RFC1001_name,
1333 ctx->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1334 memcpy(tcp_ses->server_RFC1001_name,
1335 ctx->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1336 tcp_ses->session_estab = false;
1337 tcp_ses->sequence_number = 0;
1338 tcp_ses->reconnect_instance = 1;
1339 tcp_ses->lstrp = jiffies;
1340 tcp_ses->compress_algorithm = cpu_to_le16(ctx->compression);
1341 spin_lock_init(&tcp_ses->req_lock);
1342 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1343 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1344 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
1345 INIT_DELAYED_WORK(&tcp_ses->reconnect, smb2_reconnect_server);
1346 mutex_init(&tcp_ses->reconnect_mutex);
1347 memcpy(&tcp_ses->srcaddr, &ctx->srcaddr,
1348 sizeof(tcp_ses->srcaddr));
1349 memcpy(&tcp_ses->dstaddr, &ctx->dstaddr,
1350 sizeof(tcp_ses->dstaddr));
1351 if (ctx->use_client_guid)
1352 memcpy(tcp_ses->client_guid, ctx->client_guid,
1353 SMB2_CLIENT_GUID_SIZE);
1354 else
1355 generate_random_uuid(tcp_ses->client_guid);
1356 /*
1357 * at this point we are the only ones with the pointer
1358 * to the struct since the kernel thread not created yet
1359 * no need to spinlock this init of tcpStatus or srv_count
1360 */
1361 tcp_ses->tcpStatus = CifsNew;
1362 ++tcp_ses->srv_count;
1363
1364 if (ctx->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
1365 ctx->echo_interval <= SMB_ECHO_INTERVAL_MAX)
1366 tcp_ses->echo_interval = ctx->echo_interval * HZ;
1367 else
1368 tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
1369 if (tcp_ses->rdma) {
1370 #ifndef CONFIG_CIFS_SMB_DIRECT
1371 cifs_dbg(VFS, "CONFIG_CIFS_SMB_DIRECT is not enabled\n");
1372 rc = -ENOENT;
1373 goto out_err_crypto_release;
1374 #endif
1375 tcp_ses->smbd_conn = smbd_get_connection(
1376 tcp_ses, (struct sockaddr *)&ctx->dstaddr);
1377 if (tcp_ses->smbd_conn) {
1378 cifs_dbg(VFS, "RDMA transport established\n");
1379 rc = 0;
1380 goto smbd_connected;
1381 } else {
1382 rc = -ENOENT;
1383 goto out_err_crypto_release;
1384 }
1385 }
1386 rc = ip_connect(tcp_ses);
1387 if (rc < 0) {
1388 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
1389 goto out_err_crypto_release;
1390 }
1391 smbd_connected:
1392 /*
1393 * since we're in a cifs function already, we know that
1394 * this will succeed. No need for try_module_get().
1395 */
1396 __module_get(THIS_MODULE);
1397 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
1398 tcp_ses, "cifsd");
1399 if (IS_ERR(tcp_ses->tsk)) {
1400 rc = PTR_ERR(tcp_ses->tsk);
1401 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
1402 module_put(THIS_MODULE);
1403 goto out_err_crypto_release;
1404 }
1405 tcp_ses->min_offload = ctx->min_offload;
1406 tcp_ses->tcpStatus = CifsNeedNegotiate;
1407
1408 tcp_ses->nr_targets = 1;
1409 tcp_ses->ignore_signature = ctx->ignore_signature;
1410 /* thread spawned, put it on the list */
1411 spin_lock(&cifs_tcp_ses_lock);
1412 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
1413 spin_unlock(&cifs_tcp_ses_lock);
1414
1415 cifs_fscache_get_client_cookie(tcp_ses);
1416
1417 /* queue echo request delayed work */
1418 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
1419
1420 return tcp_ses;
1421
1422 out_err_crypto_release:
1423 cifs_crypto_secmech_release(tcp_ses);
1424
1425 put_net(cifs_net_ns(tcp_ses));
1426
1427 out_err:
1428 if (tcp_ses) {
1429 if (!IS_ERR(tcp_ses->hostname))
1430 kfree(tcp_ses->hostname);
1431 if (tcp_ses->ssocket)
1432 sock_release(tcp_ses->ssocket);
1433 kfree(tcp_ses);
1434 }
1435 return ERR_PTR(rc);
1436 }
1437
1438 static int match_session(struct cifs_ses *ses, struct smb3_fs_context *ctx)
1439 {
1440 if (ctx->sectype != Unspecified &&
1441 ctx->sectype != ses->sectype)
1442 return 0;
1443
1444 /*
1445 * If an existing session is limited to less channels than
1446 * requested, it should not be reused
1447 */
1448 if (ses->chan_max < ctx->max_channels)
1449 return 0;
1450
1451 switch (ses->sectype) {
1452 case Kerberos:
1453 if (!uid_eq(ctx->cred_uid, ses->cred_uid))
1454 return 0;
1455 break;
1456 default:
1457 /* NULL username means anonymous session */
1458 if (ses->user_name == NULL) {
1459 if (!ctx->nullauth)
1460 return 0;
1461 break;
1462 }
1463
1464 /* anything else takes username/password */
1465 if (strncmp(ses->user_name,
1466 ctx->username ? ctx->username : "",
1467 CIFS_MAX_USERNAME_LEN))
1468 return 0;
1469 if ((ctx->username && strlen(ctx->username) != 0) &&
1470 ses->password != NULL &&
1471 strncmp(ses->password,
1472 ctx->password ? ctx->password : "",
1473 CIFS_MAX_PASSWORD_LEN))
1474 return 0;
1475 }
1476 return 1;
1477 }
1478
1479 /**
1480 * cifs_setup_ipc - helper to setup the IPC tcon for the session
1481 *
1482 * A new IPC connection is made and stored in the session
1483 * tcon_ipc. The IPC tcon has the same lifetime as the session.
1484 */
1485 static int
1486 cifs_setup_ipc(struct cifs_ses *ses, struct smb3_fs_context *ctx)
1487 {
1488 int rc = 0, xid;
1489 struct cifs_tcon *tcon;
1490 char unc[SERVER_NAME_LENGTH + sizeof("//x/IPC$")] = {0};
1491 bool seal = false;
1492 struct TCP_Server_Info *server = ses->server;
1493
1494 /*
1495 * If the mount request that resulted in the creation of the
1496 * session requires encryption, force IPC to be encrypted too.
1497 */
1498 if (ctx->seal) {
1499 if (server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION)
1500 seal = true;
1501 else {
1502 cifs_server_dbg(VFS,
1503 "IPC: server doesn't support encryption\n");
1504 return -EOPNOTSUPP;
1505 }
1506 }
1507
1508 tcon = tconInfoAlloc();
1509 if (tcon == NULL)
1510 return -ENOMEM;
1511
1512 scnprintf(unc, sizeof(unc), "\\\\%s\\IPC$", server->hostname);
1513
1514 xid = get_xid();
1515 tcon->ses = ses;
1516 tcon->ipc = true;
1517 tcon->seal = seal;
1518 rc = server->ops->tree_connect(xid, ses, unc, tcon, ctx->local_nls);
1519 free_xid(xid);
1520
1521 if (rc) {
1522 cifs_server_dbg(VFS, "failed to connect to IPC (rc=%d)\n", rc);
1523 tconInfoFree(tcon);
1524 goto out;
1525 }
1526
1527 cifs_dbg(FYI, "IPC tcon rc = %d ipc tid = %d\n", rc, tcon->tid);
1528
1529 ses->tcon_ipc = tcon;
1530 out:
1531 return rc;
1532 }
1533
1534 /**
1535 * cifs_free_ipc - helper to release the session IPC tcon
1536 *
1537 * Needs to be called everytime a session is destroyed
1538 */
1539 static int
1540 cifs_free_ipc(struct cifs_ses *ses)
1541 {
1542 int rc = 0, xid;
1543 struct cifs_tcon *tcon = ses->tcon_ipc;
1544
1545 if (tcon == NULL)
1546 return 0;
1547
1548 if (ses->server->ops->tree_disconnect) {
1549 xid = get_xid();
1550 rc = ses->server->ops->tree_disconnect(xid, tcon);
1551 free_xid(xid);
1552 }
1553
1554 if (rc)
1555 cifs_dbg(FYI, "failed to disconnect IPC tcon (rc=%d)\n", rc);
1556
1557 tconInfoFree(tcon);
1558 ses->tcon_ipc = NULL;
1559 return rc;
1560 }
1561
1562 static struct cifs_ses *
1563 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb3_fs_context *ctx)
1564 {
1565 struct cifs_ses *ses;
1566
1567 spin_lock(&cifs_tcp_ses_lock);
1568 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
1569 if (ses->status == CifsExiting)
1570 continue;
1571 if (!match_session(ses, ctx))
1572 continue;
1573 ++ses->ses_count;
1574 spin_unlock(&cifs_tcp_ses_lock);
1575 return ses;
1576 }
1577 spin_unlock(&cifs_tcp_ses_lock);
1578 return NULL;
1579 }
1580
1581 void cifs_put_smb_ses(struct cifs_ses *ses)
1582 {
1583 unsigned int rc, xid;
1584 struct TCP_Server_Info *server = ses->server;
1585
1586 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
1587
1588 spin_lock(&cifs_tcp_ses_lock);
1589 if (ses->status == CifsExiting) {
1590 spin_unlock(&cifs_tcp_ses_lock);
1591 return;
1592 }
1593 if (--ses->ses_count > 0) {
1594 spin_unlock(&cifs_tcp_ses_lock);
1595 return;
1596 }
1597 if (ses->status == CifsGood)
1598 ses->status = CifsExiting;
1599 spin_unlock(&cifs_tcp_ses_lock);
1600
1601 cifs_free_ipc(ses);
1602
1603 if (ses->status == CifsExiting && server->ops->logoff) {
1604 xid = get_xid();
1605 rc = server->ops->logoff(xid, ses);
1606 if (rc)
1607 cifs_server_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
1608 __func__, rc);
1609 _free_xid(xid);
1610 }
1611
1612 spin_lock(&cifs_tcp_ses_lock);
1613 list_del_init(&ses->smb_ses_list);
1614 spin_unlock(&cifs_tcp_ses_lock);
1615
1616 /* close any extra channels */
1617 if (ses->chan_count > 1) {
1618 int i;
1619
1620 for (i = 1; i < ses->chan_count; i++)
1621 cifs_put_tcp_session(ses->chans[i].server, 0);
1622 }
1623
1624 sesInfoFree(ses);
1625 cifs_put_tcp_session(server, 0);
1626 }
1627
1628 #ifdef CONFIG_KEYS
1629
1630 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
1631 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
1632
1633 /* Populate username and pw fields from keyring if possible */
1634 static int
1635 cifs_set_cifscreds(struct smb3_fs_context *ctx, struct cifs_ses *ses)
1636 {
1637 int rc = 0;
1638 int is_domain = 0;
1639 const char *delim, *payload;
1640 char *desc;
1641 ssize_t len;
1642 struct key *key;
1643 struct TCP_Server_Info *server = ses->server;
1644 struct sockaddr_in *sa;
1645 struct sockaddr_in6 *sa6;
1646 const struct user_key_payload *upayload;
1647
1648 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
1649 if (!desc)
1650 return -ENOMEM;
1651
1652 /* try to find an address key first */
1653 switch (server->dstaddr.ss_family) {
1654 case AF_INET:
1655 sa = (struct sockaddr_in *)&server->dstaddr;
1656 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
1657 break;
1658 case AF_INET6:
1659 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
1660 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
1661 break;
1662 default:
1663 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
1664 server->dstaddr.ss_family);
1665 rc = -EINVAL;
1666 goto out_err;
1667 }
1668
1669 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
1670 key = request_key(&key_type_logon, desc, "");
1671 if (IS_ERR(key)) {
1672 if (!ses->domainName) {
1673 cifs_dbg(FYI, "domainName is NULL\n");
1674 rc = PTR_ERR(key);
1675 goto out_err;
1676 }
1677
1678 /* didn't work, try to find a domain key */
1679 sprintf(desc, "cifs:d:%s", ses->domainName);
1680 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
1681 key = request_key(&key_type_logon, desc, "");
1682 if (IS_ERR(key)) {
1683 rc = PTR_ERR(key);
1684 goto out_err;
1685 }
1686 is_domain = 1;
1687 }
1688
1689 down_read(&key->sem);
1690 upayload = user_key_payload_locked(key);
1691 if (IS_ERR_OR_NULL(upayload)) {
1692 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
1693 goto out_key_put;
1694 }
1695
1696 /* find first : in payload */
1697 payload = upayload->data;
1698 delim = strnchr(payload, upayload->datalen, ':');
1699 cifs_dbg(FYI, "payload=%s\n", payload);
1700 if (!delim) {
1701 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
1702 upayload->datalen);
1703 rc = -EINVAL;
1704 goto out_key_put;
1705 }
1706
1707 len = delim - payload;
1708 if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
1709 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
1710 len);
1711 rc = -EINVAL;
1712 goto out_key_put;
1713 }
1714
1715 ctx->username = kstrndup(payload, len, GFP_KERNEL);
1716 if (!ctx->username) {
1717 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
1718 len);
1719 rc = -ENOMEM;
1720 goto out_key_put;
1721 }
1722 cifs_dbg(FYI, "%s: username=%s\n", __func__, ctx->username);
1723
1724 len = key->datalen - (len + 1);
1725 if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
1726 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
1727 rc = -EINVAL;
1728 kfree(ctx->username);
1729 ctx->username = NULL;
1730 goto out_key_put;
1731 }
1732
1733 ++delim;
1734 ctx->password = kstrndup(delim, len, GFP_KERNEL);
1735 if (!ctx->password) {
1736 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
1737 len);
1738 rc = -ENOMEM;
1739 kfree(ctx->username);
1740 ctx->username = NULL;
1741 goto out_key_put;
1742 }
1743
1744 /*
1745 * If we have a domain key then we must set the domainName in the
1746 * for the request.
1747 */
1748 if (is_domain && ses->domainName) {
1749 ctx->domainname = kstrndup(ses->domainName,
1750 strlen(ses->domainName),
1751 GFP_KERNEL);
1752 if (!ctx->domainname) {
1753 cifs_dbg(FYI, "Unable to allocate %zd bytes for domain\n",
1754 len);
1755 rc = -ENOMEM;
1756 kfree(ctx->username);
1757 ctx->username = NULL;
1758 kfree_sensitive(ctx->password);
1759 ctx->password = NULL;
1760 goto out_key_put;
1761 }
1762 }
1763
1764 out_key_put:
1765 up_read(&key->sem);
1766 key_put(key);
1767 out_err:
1768 kfree(desc);
1769 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
1770 return rc;
1771 }
1772 #else /* ! CONFIG_KEYS */
1773 static inline int
1774 cifs_set_cifscreds(struct smb3_fs_context *ctx __attribute__((unused)),
1775 struct cifs_ses *ses __attribute__((unused)))
1776 {
1777 return -ENOSYS;
1778 }
1779 #endif /* CONFIG_KEYS */
1780
1781 /**
1782 * cifs_get_smb_ses - get a session matching @ctx data from @server
1783 *
1784 * This function assumes it is being called from cifs_mount() where we
1785 * already got a server reference (server refcount +1). See
1786 * cifs_get_tcon() for refcount explanations.
1787 */
1788 struct cifs_ses *
1789 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb3_fs_context *ctx)
1790 {
1791 int rc = -ENOMEM;
1792 unsigned int xid;
1793 struct cifs_ses *ses;
1794 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
1795 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
1796
1797 xid = get_xid();
1798
1799 ses = cifs_find_smb_ses(server, ctx);
1800 if (ses) {
1801 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
1802 ses->status);
1803
1804 mutex_lock(&ses->session_mutex);
1805 rc = cifs_negotiate_protocol(xid, ses);
1806 if (rc) {
1807 mutex_unlock(&ses->session_mutex);
1808 /* problem -- put our ses reference */
1809 cifs_put_smb_ses(ses);
1810 free_xid(xid);
1811 return ERR_PTR(rc);
1812 }
1813 if (ses->need_reconnect) {
1814 cifs_dbg(FYI, "Session needs reconnect\n");
1815 rc = cifs_setup_session(xid, ses,
1816 ctx->local_nls);
1817 if (rc) {
1818 mutex_unlock(&ses->session_mutex);
1819 /* problem -- put our reference */
1820 cifs_put_smb_ses(ses);
1821 free_xid(xid);
1822 return ERR_PTR(rc);
1823 }
1824 }
1825 mutex_unlock(&ses->session_mutex);
1826
1827 /* existing SMB ses has a server reference already */
1828 cifs_put_tcp_session(server, 0);
1829 free_xid(xid);
1830 return ses;
1831 }
1832
1833 cifs_dbg(FYI, "Existing smb sess not found\n");
1834 ses = sesInfoAlloc();
1835 if (ses == NULL)
1836 goto get_ses_fail;
1837
1838 /* new SMB session uses our server ref */
1839 ses->server = server;
1840 if (server->dstaddr.ss_family == AF_INET6)
1841 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
1842 else
1843 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
1844
1845 if (ctx->username) {
1846 ses->user_name = kstrdup(ctx->username, GFP_KERNEL);
1847 if (!ses->user_name)
1848 goto get_ses_fail;
1849 }
1850
1851 /* ctx->password freed at unmount */
1852 if (ctx->password) {
1853 ses->password = kstrdup(ctx->password, GFP_KERNEL);
1854 if (!ses->password)
1855 goto get_ses_fail;
1856 }
1857 if (ctx->domainname) {
1858 ses->domainName = kstrdup(ctx->domainname, GFP_KERNEL);
1859 if (!ses->domainName)
1860 goto get_ses_fail;
1861 }
1862 if (ctx->domainauto)
1863 ses->domainAuto = ctx->domainauto;
1864 ses->cred_uid = ctx->cred_uid;
1865 ses->linux_uid = ctx->linux_uid;
1866
1867 ses->sectype = ctx->sectype;
1868 ses->sign = ctx->sign;
1869 mutex_lock(&ses->session_mutex);
1870
1871 /* add server as first channel */
1872 ses->chans[0].server = server;
1873 ses->chan_count = 1;
1874 ses->chan_max = ctx->multichannel ? ctx->max_channels:1;
1875
1876 rc = cifs_negotiate_protocol(xid, ses);
1877 if (!rc)
1878 rc = cifs_setup_session(xid, ses, ctx->local_nls);
1879
1880 /* each channel uses a different signing key */
1881 memcpy(ses->chans[0].signkey, ses->smb3signingkey,
1882 sizeof(ses->smb3signingkey));
1883
1884 mutex_unlock(&ses->session_mutex);
1885 if (rc)
1886 goto get_ses_fail;
1887
1888 /* success, put it on the list and add it as first channel */
1889 spin_lock(&cifs_tcp_ses_lock);
1890 list_add(&ses->smb_ses_list, &server->smb_ses_list);
1891 spin_unlock(&cifs_tcp_ses_lock);
1892
1893 free_xid(xid);
1894
1895 cifs_setup_ipc(ses, ctx);
1896
1897 return ses;
1898
1899 get_ses_fail:
1900 sesInfoFree(ses);
1901 free_xid(xid);
1902 return ERR_PTR(rc);
1903 }
1904
1905 static int match_tcon(struct cifs_tcon *tcon, struct smb3_fs_context *ctx)
1906 {
1907 if (tcon->tidStatus == CifsExiting)
1908 return 0;
1909 if (strncmp(tcon->treeName, ctx->UNC, MAX_TREE_SIZE))
1910 return 0;
1911 if (tcon->seal != ctx->seal)
1912 return 0;
1913 if (tcon->snapshot_time != ctx->snapshot_time)
1914 return 0;
1915 if (tcon->handle_timeout != ctx->handle_timeout)
1916 return 0;
1917 if (tcon->no_lease != ctx->no_lease)
1918 return 0;
1919 if (tcon->nodelete != ctx->nodelete)
1920 return 0;
1921 return 1;
1922 }
1923
1924 static struct cifs_tcon *
1925 cifs_find_tcon(struct cifs_ses *ses, struct smb3_fs_context *ctx)
1926 {
1927 struct list_head *tmp;
1928 struct cifs_tcon *tcon;
1929
1930 spin_lock(&cifs_tcp_ses_lock);
1931 list_for_each(tmp, &ses->tcon_list) {
1932 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
1933 #ifdef CONFIG_CIFS_DFS_UPCALL
1934 if (tcon->dfs_path)
1935 continue;
1936 #endif
1937 if (!match_tcon(tcon, ctx))
1938 continue;
1939 ++tcon->tc_count;
1940 spin_unlock(&cifs_tcp_ses_lock);
1941 return tcon;
1942 }
1943 spin_unlock(&cifs_tcp_ses_lock);
1944 return NULL;
1945 }
1946
1947 void
1948 cifs_put_tcon(struct cifs_tcon *tcon)
1949 {
1950 unsigned int xid;
1951 struct cifs_ses *ses;
1952
1953 /*
1954 * IPC tcon share the lifetime of their session and are
1955 * destroyed in the session put function
1956 */
1957 if (tcon == NULL || tcon->ipc)
1958 return;
1959
1960 ses = tcon->ses;
1961 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
1962 spin_lock(&cifs_tcp_ses_lock);
1963 if (--tcon->tc_count > 0) {
1964 spin_unlock(&cifs_tcp_ses_lock);
1965 return;
1966 }
1967
1968 #ifdef CONFIG_CIFS_SWN_UPCALL
1969 if (tcon->use_witness) {
1970 int rc;
1971
1972 rc = cifs_swn_unregister(tcon);
1973 if (rc < 0) {
1974 cifs_dbg(VFS, "%s: Failed to unregister for witness notifications: %d\n",
1975 __func__, rc);
1976 }
1977 }
1978 #endif
1979
1980 list_del_init(&tcon->tcon_list);
1981 spin_unlock(&cifs_tcp_ses_lock);
1982
1983 xid = get_xid();
1984 if (ses->server->ops->tree_disconnect)
1985 ses->server->ops->tree_disconnect(xid, tcon);
1986 _free_xid(xid);
1987
1988 cifs_fscache_release_super_cookie(tcon);
1989 tconInfoFree(tcon);
1990 cifs_put_smb_ses(ses);
1991 }
1992
1993 /**
1994 * cifs_get_tcon - get a tcon matching @ctx data from @ses
1995 *
1996 * - tcon refcount is the number of mount points using the tcon.
1997 * - ses refcount is the number of tcon using the session.
1998 *
1999 * 1. This function assumes it is being called from cifs_mount() where
2000 * we already got a session reference (ses refcount +1).
2001 *
2002 * 2. Since we're in the context of adding a mount point, the end
2003 * result should be either:
2004 *
2005 * a) a new tcon already allocated with refcount=1 (1 mount point) and
2006 * its session refcount incremented (1 new tcon). This +1 was
2007 * already done in (1).
2008 *
2009 * b) an existing tcon with refcount+1 (add a mount point to it) and
2010 * identical ses refcount (no new tcon). Because of (1) we need to
2011 * decrement the ses refcount.
2012 */
2013 static struct cifs_tcon *
2014 cifs_get_tcon(struct cifs_ses *ses, struct smb3_fs_context *ctx)
2015 {
2016 int rc, xid;
2017 struct cifs_tcon *tcon;
2018
2019 tcon = cifs_find_tcon(ses, ctx);
2020 if (tcon) {
2021 /*
2022 * tcon has refcount already incremented but we need to
2023 * decrement extra ses reference gotten by caller (case b)
2024 */
2025 cifs_dbg(FYI, "Found match on UNC path\n");
2026 cifs_put_smb_ses(ses);
2027 return tcon;
2028 }
2029
2030 if (!ses->server->ops->tree_connect) {
2031 rc = -ENOSYS;
2032 goto out_fail;
2033 }
2034
2035 tcon = tconInfoAlloc();
2036 if (tcon == NULL) {
2037 rc = -ENOMEM;
2038 goto out_fail;
2039 }
2040
2041 if (ctx->snapshot_time) {
2042 if (ses->server->vals->protocol_id == 0) {
2043 cifs_dbg(VFS,
2044 "Use SMB2 or later for snapshot mount option\n");
2045 rc = -EOPNOTSUPP;
2046 goto out_fail;
2047 } else
2048 tcon->snapshot_time = ctx->snapshot_time;
2049 }
2050
2051 if (ctx->handle_timeout) {
2052 if (ses->server->vals->protocol_id == 0) {
2053 cifs_dbg(VFS,
2054 "Use SMB2.1 or later for handle timeout option\n");
2055 rc = -EOPNOTSUPP;
2056 goto out_fail;
2057 } else
2058 tcon->handle_timeout = ctx->handle_timeout;
2059 }
2060
2061 tcon->ses = ses;
2062 if (ctx->password) {
2063 tcon->password = kstrdup(ctx->password, GFP_KERNEL);
2064 if (!tcon->password) {
2065 rc = -ENOMEM;
2066 goto out_fail;
2067 }
2068 }
2069
2070 if (ctx->seal) {
2071 if (ses->server->vals->protocol_id == 0) {
2072 cifs_dbg(VFS,
2073 "SMB3 or later required for encryption\n");
2074 rc = -EOPNOTSUPP;
2075 goto out_fail;
2076 } else if (tcon->ses->server->capabilities &
2077 SMB2_GLOBAL_CAP_ENCRYPTION)
2078 tcon->seal = true;
2079 else {
2080 cifs_dbg(VFS, "Encryption is not supported on share\n");
2081 rc = -EOPNOTSUPP;
2082 goto out_fail;
2083 }
2084 }
2085
2086 if (ctx->linux_ext) {
2087 if (ses->server->posix_ext_supported) {
2088 tcon->posix_extensions = true;
2089 pr_warn_once("SMB3.11 POSIX Extensions are experimental\n");
2090 } else {
2091 cifs_dbg(VFS, "Server does not support mounting with posix SMB3.11 extensions\n");
2092 rc = -EOPNOTSUPP;
2093 goto out_fail;
2094 }
2095 }
2096
2097 /*
2098 * BB Do we need to wrap session_mutex around this TCon call and Unix
2099 * SetFS as we do on SessSetup and reconnect?
2100 */
2101 xid = get_xid();
2102 rc = ses->server->ops->tree_connect(xid, ses, ctx->UNC, tcon,
2103 ctx->local_nls);
2104 free_xid(xid);
2105 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
2106 if (rc)
2107 goto out_fail;
2108
2109 tcon->use_persistent = false;
2110 /* check if SMB2 or later, CIFS does not support persistent handles */
2111 if (ctx->persistent) {
2112 if (ses->server->vals->protocol_id == 0) {
2113 cifs_dbg(VFS,
2114 "SMB3 or later required for persistent handles\n");
2115 rc = -EOPNOTSUPP;
2116 goto out_fail;
2117 } else if (ses->server->capabilities &
2118 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2119 tcon->use_persistent = true;
2120 else /* persistent handles requested but not supported */ {
2121 cifs_dbg(VFS,
2122 "Persistent handles not supported on share\n");
2123 rc = -EOPNOTSUPP;
2124 goto out_fail;
2125 }
2126 } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
2127 && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2128 && (ctx->nopersistent == false)) {
2129 cifs_dbg(FYI, "enabling persistent handles\n");
2130 tcon->use_persistent = true;
2131 } else if (ctx->resilient) {
2132 if (ses->server->vals->protocol_id == 0) {
2133 cifs_dbg(VFS,
2134 "SMB2.1 or later required for resilient handles\n");
2135 rc = -EOPNOTSUPP;
2136 goto out_fail;
2137 }
2138 tcon->use_resilient = true;
2139 }
2140 #ifdef CONFIG_CIFS_SWN_UPCALL
2141 tcon->use_witness = false;
2142 if (ctx->witness) {
2143 if (ses->server->vals->protocol_id >= SMB30_PROT_ID) {
2144 if (tcon->capabilities & SMB2_SHARE_CAP_CLUSTER) {
2145 /*
2146 * Set witness in use flag in first place
2147 * to retry registration in the echo task
2148 */
2149 tcon->use_witness = true;
2150 /* And try to register immediately */
2151 rc = cifs_swn_register(tcon);
2152 if (rc < 0) {
2153 cifs_dbg(VFS, "Failed to register for witness notifications: %d\n", rc);
2154 goto out_fail;
2155 }
2156 } else {
2157 /* TODO: try to extend for non-cluster uses (eg multichannel) */
2158 cifs_dbg(VFS, "witness requested on mount but no CLUSTER capability on share\n");
2159 rc = -EOPNOTSUPP;
2160 goto out_fail;
2161 }
2162 } else {
2163 cifs_dbg(VFS, "SMB3 or later required for witness option\n");
2164 rc = -EOPNOTSUPP;
2165 goto out_fail;
2166 }
2167 }
2168 #endif
2169
2170 /* If the user really knows what they are doing they can override */
2171 if (tcon->share_flags & SMB2_SHAREFLAG_NO_CACHING) {
2172 if (ctx->cache_ro)
2173 cifs_dbg(VFS, "cache=ro requested on mount but NO_CACHING flag set on share\n");
2174 else if (ctx->cache_rw)
2175 cifs_dbg(VFS, "cache=singleclient requested on mount but NO_CACHING flag set on share\n");
2176 }
2177
2178 if (ctx->no_lease) {
2179 if (ses->server->vals->protocol_id == 0) {
2180 cifs_dbg(VFS,
2181 "SMB2 or later required for nolease option\n");
2182 rc = -EOPNOTSUPP;
2183 goto out_fail;
2184 } else
2185 tcon->no_lease = ctx->no_lease;
2186 }
2187
2188 /*
2189 * We can have only one retry value for a connection to a share so for
2190 * resources mounted more than once to the same server share the last
2191 * value passed in for the retry flag is used.
2192 */
2193 tcon->retry = ctx->retry;
2194 tcon->nocase = ctx->nocase;
2195 if (ses->server->capabilities & SMB2_GLOBAL_CAP_DIRECTORY_LEASING)
2196 tcon->nohandlecache = ctx->nohandlecache;
2197 else
2198 tcon->nohandlecache = 1;
2199 tcon->nodelete = ctx->nodelete;
2200 tcon->local_lease = ctx->local_lease;
2201 INIT_LIST_HEAD(&tcon->pending_opens);
2202
2203 spin_lock(&cifs_tcp_ses_lock);
2204 list_add(&tcon->tcon_list, &ses->tcon_list);
2205 spin_unlock(&cifs_tcp_ses_lock);
2206
2207 cifs_fscache_get_super_cookie(tcon);
2208
2209 return tcon;
2210
2211 out_fail:
2212 tconInfoFree(tcon);
2213 return ERR_PTR(rc);
2214 }
2215
2216 void
2217 cifs_put_tlink(struct tcon_link *tlink)
2218 {
2219 if (!tlink || IS_ERR(tlink))
2220 return;
2221
2222 if (!atomic_dec_and_test(&tlink->tl_count) ||
2223 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2224 tlink->tl_time = jiffies;
2225 return;
2226 }
2227
2228 if (!IS_ERR(tlink_tcon(tlink)))
2229 cifs_put_tcon(tlink_tcon(tlink));
2230 kfree(tlink);
2231 return;
2232 }
2233
2234 static int
2235 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2236 {
2237 struct cifs_sb_info *old = CIFS_SB(sb);
2238 struct cifs_sb_info *new = mnt_data->cifs_sb;
2239 unsigned int oldflags = old->mnt_cifs_flags & CIFS_MOUNT_MASK;
2240 unsigned int newflags = new->mnt_cifs_flags & CIFS_MOUNT_MASK;
2241
2242 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2243 return 0;
2244
2245 if (old->mnt_cifs_serverino_autodisabled)
2246 newflags &= ~CIFS_MOUNT_SERVER_INUM;
2247
2248 if (oldflags != newflags)
2249 return 0;
2250
2251 /*
2252 * We want to share sb only if we don't specify an r/wsize or
2253 * specified r/wsize is greater than or equal to existing one.
2254 */
2255 if (new->ctx->wsize && new->ctx->wsize < old->ctx->wsize)
2256 return 0;
2257
2258 if (new->ctx->rsize && new->ctx->rsize < old->ctx->rsize)
2259 return 0;
2260
2261 if (!uid_eq(old->ctx->linux_uid, new->ctx->linux_uid) ||
2262 !gid_eq(old->ctx->linux_gid, new->ctx->linux_gid))
2263 return 0;
2264
2265 if (old->ctx->file_mode != new->ctx->file_mode ||
2266 old->ctx->dir_mode != new->ctx->dir_mode)
2267 return 0;
2268
2269 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2270 return 0;
2271
2272 if (old->ctx->actimeo != new->ctx->actimeo)
2273 return 0;
2274
2275 return 1;
2276 }
2277
2278 static int
2279 match_prepath(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2280 {
2281 struct cifs_sb_info *old = CIFS_SB(sb);
2282 struct cifs_sb_info *new = mnt_data->cifs_sb;
2283 bool old_set = (old->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) &&
2284 old->prepath;
2285 bool new_set = (new->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) &&
2286 new->prepath;
2287
2288 if (old_set && new_set && !strcmp(new->prepath, old->prepath))
2289 return 1;
2290 else if (!old_set && !new_set)
2291 return 1;
2292
2293 return 0;
2294 }
2295
2296 int
2297 cifs_match_super(struct super_block *sb, void *data)
2298 {
2299 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2300 struct smb3_fs_context *ctx;
2301 struct cifs_sb_info *cifs_sb;
2302 struct TCP_Server_Info *tcp_srv;
2303 struct cifs_ses *ses;
2304 struct cifs_tcon *tcon;
2305 struct tcon_link *tlink;
2306 int rc = 0;
2307
2308 spin_lock(&cifs_tcp_ses_lock);
2309 cifs_sb = CIFS_SB(sb);
2310 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2311 if (IS_ERR(tlink)) {
2312 spin_unlock(&cifs_tcp_ses_lock);
2313 return rc;
2314 }
2315 tcon = tlink_tcon(tlink);
2316 ses = tcon->ses;
2317 tcp_srv = ses->server;
2318
2319 ctx = mnt_data->ctx;
2320
2321 if (!match_server(tcp_srv, ctx) ||
2322 !match_session(ses, ctx) ||
2323 !match_tcon(tcon, ctx) ||
2324 !match_prepath(sb, mnt_data)) {
2325 rc = 0;
2326 goto out;
2327 }
2328
2329 rc = compare_mount_options(sb, mnt_data);
2330 out:
2331 spin_unlock(&cifs_tcp_ses_lock);
2332 cifs_put_tlink(tlink);
2333 return rc;
2334 }
2335
2336 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2337 static struct lock_class_key cifs_key[2];
2338 static struct lock_class_key cifs_slock_key[2];
2339
2340 static inline void
2341 cifs_reclassify_socket4(struct socket *sock)
2342 {
2343 struct sock *sk = sock->sk;
2344 BUG_ON(!sock_allow_reclassification(sk));
2345 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2346 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2347 }
2348
2349 static inline void
2350 cifs_reclassify_socket6(struct socket *sock)
2351 {
2352 struct sock *sk = sock->sk;
2353 BUG_ON(!sock_allow_reclassification(sk));
2354 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2355 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2356 }
2357 #else
2358 static inline void
2359 cifs_reclassify_socket4(struct socket *sock)
2360 {
2361 }
2362
2363 static inline void
2364 cifs_reclassify_socket6(struct socket *sock)
2365 {
2366 }
2367 #endif
2368
2369 /* See RFC1001 section 14 on representation of Netbios names */
2370 static void rfc1002mangle(char *target, char *source, unsigned int length)
2371 {
2372 unsigned int i, j;
2373
2374 for (i = 0, j = 0; i < (length); i++) {
2375 /* mask a nibble at a time and encode */
2376 target[j] = 'A' + (0x0F & (source[i] >> 4));
2377 target[j+1] = 'A' + (0x0F & source[i]);
2378 j += 2;
2379 }
2380
2381 }
2382
2383 static int
2384 bind_socket(struct TCP_Server_Info *server)
2385 {
2386 int rc = 0;
2387 if (server->srcaddr.ss_family != AF_UNSPEC) {
2388 /* Bind to the specified local IP address */
2389 struct socket *socket = server->ssocket;
2390 rc = socket->ops->bind(socket,
2391 (struct sockaddr *) &server->srcaddr,
2392 sizeof(server->srcaddr));
2393 if (rc < 0) {
2394 struct sockaddr_in *saddr4;
2395 struct sockaddr_in6 *saddr6;
2396 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2397 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2398 if (saddr6->sin6_family == AF_INET6)
2399 cifs_server_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
2400 &saddr6->sin6_addr, rc);
2401 else
2402 cifs_server_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
2403 &saddr4->sin_addr.s_addr, rc);
2404 }
2405 }
2406 return rc;
2407 }
2408
2409 static int
2410 ip_rfc1001_connect(struct TCP_Server_Info *server)
2411 {
2412 int rc = 0;
2413 /*
2414 * some servers require RFC1001 sessinit before sending
2415 * negprot - BB check reconnection in case where second
2416 * sessinit is sent but no second negprot
2417 */
2418 struct rfc1002_session_packet *ses_init_buf;
2419 struct smb_hdr *smb_buf;
2420 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2421 GFP_KERNEL);
2422 if (ses_init_buf) {
2423 ses_init_buf->trailer.session_req.called_len = 32;
2424
2425 if (server->server_RFC1001_name[0] != 0)
2426 rfc1002mangle(ses_init_buf->trailer.
2427 session_req.called_name,
2428 server->server_RFC1001_name,
2429 RFC1001_NAME_LEN_WITH_NULL);
2430 else
2431 rfc1002mangle(ses_init_buf->trailer.
2432 session_req.called_name,
2433 DEFAULT_CIFS_CALLED_NAME,
2434 RFC1001_NAME_LEN_WITH_NULL);
2435
2436 ses_init_buf->trailer.session_req.calling_len = 32;
2437
2438 /*
2439 * calling name ends in null (byte 16) from old smb
2440 * convention.
2441 */
2442 if (server->workstation_RFC1001_name[0] != 0)
2443 rfc1002mangle(ses_init_buf->trailer.
2444 session_req.calling_name,
2445 server->workstation_RFC1001_name,
2446 RFC1001_NAME_LEN_WITH_NULL);
2447 else
2448 rfc1002mangle(ses_init_buf->trailer.
2449 session_req.calling_name,
2450 "LINUX_CIFS_CLNT",
2451 RFC1001_NAME_LEN_WITH_NULL);
2452
2453 ses_init_buf->trailer.session_req.scope1 = 0;
2454 ses_init_buf->trailer.session_req.scope2 = 0;
2455 smb_buf = (struct smb_hdr *)ses_init_buf;
2456
2457 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2458 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
2459 rc = smb_send(server, smb_buf, 0x44);
2460 kfree(ses_init_buf);
2461 /*
2462 * RFC1001 layer in at least one server
2463 * requires very short break before negprot
2464 * presumably because not expecting negprot
2465 * to follow so fast. This is a simple
2466 * solution that works without
2467 * complicating the code and causes no
2468 * significant slowing down on mount
2469 * for everyone else
2470 */
2471 usleep_range(1000, 2000);
2472 }
2473 /*
2474 * else the negprot may still work without this
2475 * even though malloc failed
2476 */
2477
2478 return rc;
2479 }
2480
2481 static int
2482 generic_ip_connect(struct TCP_Server_Info *server)
2483 {
2484 int rc = 0;
2485 __be16 sport;
2486 int slen, sfamily;
2487 struct socket *socket = server->ssocket;
2488 struct sockaddr *saddr;
2489
2490 saddr = (struct sockaddr *) &server->dstaddr;
2491
2492 if (server->dstaddr.ss_family == AF_INET6) {
2493 struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)&server->dstaddr;
2494
2495 sport = ipv6->sin6_port;
2496 slen = sizeof(struct sockaddr_in6);
2497 sfamily = AF_INET6;
2498 cifs_dbg(FYI, "%s: connecting to [%pI6]:%d\n", __func__, &ipv6->sin6_addr,
2499 ntohs(sport));
2500 } else {
2501 struct sockaddr_in *ipv4 = (struct sockaddr_in *)&server->dstaddr;
2502
2503 sport = ipv4->sin_port;
2504 slen = sizeof(struct sockaddr_in);
2505 sfamily = AF_INET;
2506 cifs_dbg(FYI, "%s: connecting to %pI4:%d\n", __func__, &ipv4->sin_addr,
2507 ntohs(sport));
2508 }
2509
2510 if (socket == NULL) {
2511 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2512 IPPROTO_TCP, &socket, 1);
2513 if (rc < 0) {
2514 cifs_server_dbg(VFS, "Error %d creating socket\n", rc);
2515 server->ssocket = NULL;
2516 return rc;
2517 }
2518
2519 /* BB other socket options to set KEEPALIVE, NODELAY? */
2520 cifs_dbg(FYI, "Socket created\n");
2521 server->ssocket = socket;
2522 socket->sk->sk_allocation = GFP_NOFS;
2523 if (sfamily == AF_INET6)
2524 cifs_reclassify_socket6(socket);
2525 else
2526 cifs_reclassify_socket4(socket);
2527 }
2528
2529 rc = bind_socket(server);
2530 if (rc < 0)
2531 return rc;
2532
2533 /*
2534 * Eventually check for other socket options to change from
2535 * the default. sock_setsockopt not used because it expects
2536 * user space buffer
2537 */
2538 socket->sk->sk_rcvtimeo = 7 * HZ;
2539 socket->sk->sk_sndtimeo = 5 * HZ;
2540
2541 /* make the bufsizes depend on wsize/rsize and max requests */
2542 if (server->noautotune) {
2543 if (socket->sk->sk_sndbuf < (200 * 1024))
2544 socket->sk->sk_sndbuf = 200 * 1024;
2545 if (socket->sk->sk_rcvbuf < (140 * 1024))
2546 socket->sk->sk_rcvbuf = 140 * 1024;
2547 }
2548
2549 if (server->tcp_nodelay)
2550 tcp_sock_set_nodelay(socket->sk);
2551
2552 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
2553 socket->sk->sk_sndbuf,
2554 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
2555
2556 rc = socket->ops->connect(socket, saddr, slen,
2557 server->noblockcnt ? O_NONBLOCK : 0);
2558 /*
2559 * When mounting SMB root file systems, we do not want to block in
2560 * connect. Otherwise bail out and then let cifs_reconnect() perform
2561 * reconnect failover - if possible.
2562 */
2563 if (server->noblockcnt && rc == -EINPROGRESS)
2564 rc = 0;
2565 if (rc < 0) {
2566 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
2567 sock_release(socket);
2568 server->ssocket = NULL;
2569 return rc;
2570 }
2571
2572 if (sport == htons(RFC1001_PORT))
2573 rc = ip_rfc1001_connect(server);
2574
2575 return rc;
2576 }
2577
2578 static int
2579 ip_connect(struct TCP_Server_Info *server)
2580 {
2581 __be16 *sport;
2582 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2583 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2584
2585 if (server->dstaddr.ss_family == AF_INET6)
2586 sport = &addr6->sin6_port;
2587 else
2588 sport = &addr->sin_port;
2589
2590 if (*sport == 0) {
2591 int rc;
2592
2593 /* try with 445 port at first */
2594 *sport = htons(CIFS_PORT);
2595
2596 rc = generic_ip_connect(server);
2597 if (rc >= 0)
2598 return rc;
2599
2600 /* if it failed, try with 139 port */
2601 *sport = htons(RFC1001_PORT);
2602 }
2603
2604 return generic_ip_connect(server);
2605 }
2606
2607 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
2608 struct cifs_sb_info *cifs_sb, struct smb3_fs_context *ctx)
2609 {
2610 /*
2611 * If we are reconnecting then should we check to see if
2612 * any requested capabilities changed locally e.g. via
2613 * remount but we can not do much about it here
2614 * if they have (even if we could detect it by the following)
2615 * Perhaps we could add a backpointer to array of sb from tcon
2616 * or if we change to make all sb to same share the same
2617 * sb as NFS - then we only have one backpointer to sb.
2618 * What if we wanted to mount the server share twice once with
2619 * and once without posixacls or posix paths?
2620 */
2621 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2622
2623 if (ctx && ctx->no_linux_ext) {
2624 tcon->fsUnixInfo.Capability = 0;
2625 tcon->unix_ext = 0; /* Unix Extensions disabled */
2626 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
2627 return;
2628 } else if (ctx)
2629 tcon->unix_ext = 1; /* Unix Extensions supported */
2630
2631 if (tcon->unix_ext == 0) {
2632 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
2633 return;
2634 }
2635
2636 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
2637 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2638 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
2639 /*
2640 * check for reconnect case in which we do not
2641 * want to change the mount behavior if we can avoid it
2642 */
2643 if (ctx == NULL) {
2644 /*
2645 * turn off POSIX ACL and PATHNAMES if not set
2646 * originally at mount time
2647 */
2648 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2649 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2650 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2651 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2652 cifs_dbg(VFS, "POSIXPATH support change\n");
2653 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2654 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2655 cifs_dbg(VFS, "possible reconnect error\n");
2656 cifs_dbg(VFS, "server disabled POSIX path support\n");
2657 }
2658 }
2659
2660 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
2661 cifs_dbg(VFS, "per-share encryption not supported yet\n");
2662
2663 cap &= CIFS_UNIX_CAP_MASK;
2664 if (ctx && ctx->no_psx_acl)
2665 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2666 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
2667 cifs_dbg(FYI, "negotiated posix acl support\n");
2668 if (cifs_sb)
2669 cifs_sb->mnt_cifs_flags |=
2670 CIFS_MOUNT_POSIXACL;
2671 }
2672
2673 if (ctx && ctx->posix_paths == 0)
2674 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2675 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2676 cifs_dbg(FYI, "negotiate posix pathnames\n");
2677 if (cifs_sb)
2678 cifs_sb->mnt_cifs_flags |=
2679 CIFS_MOUNT_POSIX_PATHS;
2680 }
2681
2682 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
2683 #ifdef CONFIG_CIFS_DEBUG2
2684 if (cap & CIFS_UNIX_FCNTL_CAP)
2685 cifs_dbg(FYI, "FCNTL cap\n");
2686 if (cap & CIFS_UNIX_EXTATTR_CAP)
2687 cifs_dbg(FYI, "EXTATTR cap\n");
2688 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2689 cifs_dbg(FYI, "POSIX path cap\n");
2690 if (cap & CIFS_UNIX_XATTR_CAP)
2691 cifs_dbg(FYI, "XATTR cap\n");
2692 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
2693 cifs_dbg(FYI, "POSIX ACL cap\n");
2694 if (cap & CIFS_UNIX_LARGE_READ_CAP)
2695 cifs_dbg(FYI, "very large read cap\n");
2696 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
2697 cifs_dbg(FYI, "very large write cap\n");
2698 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
2699 cifs_dbg(FYI, "transport encryption cap\n");
2700 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
2701 cifs_dbg(FYI, "mandatory transport encryption cap\n");
2702 #endif /* CIFS_DEBUG2 */
2703 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
2704 if (ctx == NULL)
2705 cifs_dbg(FYI, "resetting capabilities failed\n");
2706 else
2707 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");
2708
2709 }
2710 }
2711 }
2712
2713 int cifs_setup_cifs_sb(struct cifs_sb_info *cifs_sb)
2714 {
2715 struct smb3_fs_context *ctx = cifs_sb->ctx;
2716
2717 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
2718
2719 spin_lock_init(&cifs_sb->tlink_tree_lock);
2720 cifs_sb->tlink_tree = RB_ROOT;
2721
2722 cifs_dbg(FYI, "file mode: %04ho dir mode: %04ho\n",
2723 ctx->file_mode, ctx->dir_mode);
2724
2725 /* this is needed for ASCII cp to Unicode converts */
2726 if (ctx->iocharset == NULL) {
2727 /* load_nls_default cannot return null */
2728 cifs_sb->local_nls = load_nls_default();
2729 } else {
2730 cifs_sb->local_nls = load_nls(ctx->iocharset);
2731 if (cifs_sb->local_nls == NULL) {
2732 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
2733 ctx->iocharset);
2734 return -ELIBACC;
2735 }
2736 }
2737 ctx->local_nls = cifs_sb->local_nls;
2738
2739 smb3_update_mnt_flags(cifs_sb);
2740
2741 if (ctx->direct_io)
2742 cifs_dbg(FYI, "mounting share using direct i/o\n");
2743 if (ctx->cache_ro) {
2744 cifs_dbg(VFS, "mounting share with read only caching. Ensure that the share will not be modified while in use.\n");
2745 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RO_CACHE;
2746 } else if (ctx->cache_rw) {
2747 cifs_dbg(VFS, "mounting share in single client RW caching mode. Ensure that no other systems will be accessing the share.\n");
2748 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_RO_CACHE |
2749 CIFS_MOUNT_RW_CACHE);
2750 }
2751
2752 if ((ctx->cifs_acl) && (ctx->dynperm))
2753 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
2754
2755 if (ctx->prepath) {
2756 cifs_sb->prepath = kstrdup(ctx->prepath, GFP_KERNEL);
2757 if (cifs_sb->prepath == NULL)
2758 return -ENOMEM;
2759 }
2760
2761 return 0;
2762 }
2763
2764 /* Release all succeed connections */
2765 static inline void mount_put_conns(struct cifs_sb_info *cifs_sb,
2766 unsigned int xid,
2767 struct TCP_Server_Info *server,
2768 struct cifs_ses *ses, struct cifs_tcon *tcon)
2769 {
2770 int rc = 0;
2771
2772 if (tcon)
2773 cifs_put_tcon(tcon);
2774 else if (ses)
2775 cifs_put_smb_ses(ses);
2776 else if (server)
2777 cifs_put_tcp_session(server, 0);
2778 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
2779 free_xid(xid);
2780 }
2781
2782 /* Get connections for tcp, ses and tcon */
2783 static int mount_get_conns(struct smb3_fs_context *ctx, struct cifs_sb_info *cifs_sb,
2784 unsigned int *xid,
2785 struct TCP_Server_Info **nserver,
2786 struct cifs_ses **nses, struct cifs_tcon **ntcon)
2787 {
2788 int rc = 0;
2789 struct TCP_Server_Info *server;
2790 struct cifs_ses *ses;
2791 struct cifs_tcon *tcon;
2792
2793 *nserver = NULL;
2794 *nses = NULL;
2795 *ntcon = NULL;
2796
2797 *xid = get_xid();
2798
2799 /* get a reference to a tcp session */
2800 server = cifs_get_tcp_session(ctx);
2801 if (IS_ERR(server)) {
2802 rc = PTR_ERR(server);
2803 return rc;
2804 }
2805
2806 *nserver = server;
2807
2808 if ((ctx->max_credits < 20) || (ctx->max_credits > 60000))
2809 server->max_credits = SMB2_MAX_CREDITS_AVAILABLE;
2810 else
2811 server->max_credits = ctx->max_credits;
2812
2813 /* get a reference to a SMB session */
2814 ses = cifs_get_smb_ses(server, ctx);
2815 if (IS_ERR(ses)) {
2816 rc = PTR_ERR(ses);
2817 return rc;
2818 }
2819
2820 *nses = ses;
2821
2822 if ((ctx->persistent == true) && (!(ses->server->capabilities &
2823 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES))) {
2824 cifs_server_dbg(VFS, "persistent handles not supported by server\n");
2825 return -EOPNOTSUPP;
2826 }
2827
2828 /* search for existing tcon to this server share */
2829 tcon = cifs_get_tcon(ses, ctx);
2830 if (IS_ERR(tcon)) {
2831 rc = PTR_ERR(tcon);
2832 return rc;
2833 }
2834
2835 *ntcon = tcon;
2836
2837 /* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
2838 if (tcon->posix_extensions)
2839 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_POSIX_PATHS;
2840
2841 /* tell server which Unix caps we support */
2842 if (cap_unix(tcon->ses)) {
2843 /*
2844 * reset of caps checks mount to see if unix extensions disabled
2845 * for just this mount.
2846 */
2847 reset_cifs_unix_caps(*xid, tcon, cifs_sb, ctx);
2848 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
2849 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
2850 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP))
2851 return -EACCES;
2852 } else
2853 tcon->unix_ext = 0; /* server does not support them */
2854
2855 /* do not care if a following call succeed - informational */
2856 if (!tcon->pipe && server->ops->qfs_tcon) {
2857 server->ops->qfs_tcon(*xid, tcon, cifs_sb);
2858 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE) {
2859 if (tcon->fsDevInfo.DeviceCharacteristics &
2860 cpu_to_le32(FILE_READ_ONLY_DEVICE))
2861 cifs_dbg(VFS, "mounted to read only share\n");
2862 else if ((cifs_sb->mnt_cifs_flags &
2863 CIFS_MOUNT_RW_CACHE) == 0)
2864 cifs_dbg(VFS, "read only mount of RW share\n");
2865 /* no need to log a RW mount of a typical RW share */
2866 }
2867 }
2868
2869 /*
2870 * Clamp the rsize/wsize mount arguments if they are too big for the server
2871 * and set the rsize/wsize to the negotiated values if not passed in by
2872 * the user on mount
2873 */
2874 if ((cifs_sb->ctx->wsize == 0) ||
2875 (cifs_sb->ctx->wsize > server->ops->negotiate_wsize(tcon, ctx)))
2876 cifs_sb->ctx->wsize = server->ops->negotiate_wsize(tcon, ctx);
2877 if ((cifs_sb->ctx->rsize == 0) ||
2878 (cifs_sb->ctx->rsize > server->ops->negotiate_rsize(tcon, ctx)))
2879 cifs_sb->ctx->rsize = server->ops->negotiate_rsize(tcon, ctx);
2880
2881 return 0;
2882 }
2883
2884 static int mount_setup_tlink(struct cifs_sb_info *cifs_sb, struct cifs_ses *ses,
2885 struct cifs_tcon *tcon)
2886 {
2887 struct tcon_link *tlink;
2888
2889 /* hang the tcon off of the superblock */
2890 tlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
2891 if (tlink == NULL)
2892 return -ENOMEM;
2893
2894 tlink->tl_uid = ses->linux_uid;
2895 tlink->tl_tcon = tcon;
2896 tlink->tl_time = jiffies;
2897 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
2898 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
2899
2900 cifs_sb->master_tlink = tlink;
2901 spin_lock(&cifs_sb->tlink_tree_lock);
2902 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
2903 spin_unlock(&cifs_sb->tlink_tree_lock);
2904
2905 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
2906 TLINK_IDLE_EXPIRE);
2907 return 0;
2908 }
2909
2910 #ifdef CONFIG_CIFS_DFS_UPCALL
2911 /*
2912 * cifs_build_path_to_root returns full path to root when we do not have an
2913 * exiting connection (tcon)
2914 */
2915 static char *
2916 build_unc_path_to_root(const struct smb3_fs_context *ctx,
2917 const struct cifs_sb_info *cifs_sb, bool useppath)
2918 {
2919 char *full_path, *pos;
2920 unsigned int pplen = useppath && ctx->prepath ?
2921 strlen(ctx->prepath) + 1 : 0;
2922 unsigned int unc_len = strnlen(ctx->UNC, MAX_TREE_SIZE + 1);
2923
2924 if (unc_len > MAX_TREE_SIZE)
2925 return ERR_PTR(-EINVAL);
2926
2927 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
2928 if (full_path == NULL)
2929 return ERR_PTR(-ENOMEM);
2930
2931 memcpy(full_path, ctx->UNC, unc_len);
2932 pos = full_path + unc_len;
2933
2934 if (pplen) {
2935 *pos = CIFS_DIR_SEP(cifs_sb);
2936 memcpy(pos + 1, ctx->prepath, pplen);
2937 pos += pplen;
2938 }
2939
2940 *pos = '\0'; /* add trailing null */
2941 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
2942 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
2943 return full_path;
2944 }
2945
2946 /**
2947 * expand_dfs_referral - Perform a dfs referral query and update the cifs_sb
2948 *
2949 * If a referral is found, cifs_sb->ctx->mount_options will be (re-)allocated
2950 * to a string containing updated options for the submount. Otherwise it
2951 * will be left untouched.
2952 *
2953 * Returns the rc from get_dfs_path to the caller, which can be used to
2954 * determine whether there were referrals.
2955 */
2956 static int
2957 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
2958 struct smb3_fs_context *ctx, struct cifs_sb_info *cifs_sb,
2959 char *ref_path)
2960 {
2961 int rc;
2962 struct dfs_info3_param referral = {0};
2963 char *full_path = NULL, *mdata = NULL;
2964
2965 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
2966 return -EREMOTE;
2967
2968 full_path = build_unc_path_to_root(ctx, cifs_sb, true);
2969 if (IS_ERR(full_path))
2970 return PTR_ERR(full_path);
2971
2972 rc = dfs_cache_find(xid, ses, cifs_sb->local_nls, cifs_remap(cifs_sb),
2973 ref_path, &referral, NULL);
2974 if (!rc) {
2975 mdata = cifs_compose_mount_options(cifs_sb->ctx->mount_options,
2976 full_path + 1, &referral);
2977 free_dfs_info_param(&referral);
2978
2979 if (IS_ERR(mdata)) {
2980 rc = PTR_ERR(mdata);
2981 mdata = NULL;
2982 } else {
2983 smb3_cleanup_fs_context_contents(ctx);
2984 rc = cifs_setup_volume_info(ctx);
2985 }
2986 kfree(cifs_sb->ctx->mount_options);
2987 cifs_sb->ctx->mount_options = mdata;
2988 }
2989 kfree(full_path);
2990 return rc;
2991 }
2992
2993 static inline int get_next_dfs_tgt(const char *path,
2994 struct dfs_cache_tgt_list *tgt_list,
2995 struct dfs_cache_tgt_iterator **tgt_it)
2996 {
2997 if (!*tgt_it)
2998 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
2999 else
3000 *tgt_it = dfs_cache_get_next_tgt(tgt_list, *tgt_it);
3001 return !*tgt_it ? -EHOSTDOWN : 0;
3002 }
3003
3004 static int update_vol_info(const struct dfs_cache_tgt_iterator *tgt_it,
3005 struct smb3_fs_context *fake_ctx, struct smb3_fs_context *ctx)
3006 {
3007 const char *tgt = dfs_cache_get_tgt_name(tgt_it);
3008 int len = strlen(tgt) + 2;
3009 char *new_unc;
3010
3011 new_unc = kmalloc(len, GFP_KERNEL);
3012 if (!new_unc)
3013 return -ENOMEM;
3014 scnprintf(new_unc, len, "\\%s", tgt);
3015
3016 kfree(ctx->UNC);
3017 ctx->UNC = new_unc;
3018
3019 if (fake_ctx->prepath) {
3020 kfree(ctx->prepath);
3021 ctx->prepath = fake_ctx->prepath;
3022 fake_ctx->prepath = NULL;
3023 }
3024 memcpy(&ctx->dstaddr, &fake_ctx->dstaddr, sizeof(ctx->dstaddr));
3025
3026 return 0;
3027 }
3028
3029 static int setup_dfs_tgt_conn(const char *path, const char *full_path,
3030 const struct dfs_cache_tgt_iterator *tgt_it,
3031 struct cifs_sb_info *cifs_sb, struct smb3_fs_context *ctx,
3032 unsigned int *xid, struct TCP_Server_Info **server,
3033 struct cifs_ses **ses, struct cifs_tcon **tcon)
3034 {
3035 int rc;
3036 struct dfs_info3_param ref = {0};
3037 char *mdata = NULL;
3038 struct smb3_fs_context fake_ctx = {NULL};
3039
3040 cifs_dbg(FYI, "%s: dfs path: %s\n", __func__, path);
3041
3042 rc = dfs_cache_get_tgt_referral(path, tgt_it, &ref);
3043 if (rc)
3044 return rc;
3045
3046 mdata = cifs_compose_mount_options(cifs_sb->ctx->mount_options,
3047 full_path + 1, &ref);
3048 free_dfs_info_param(&ref);
3049
3050 if (IS_ERR(mdata)) {
3051 rc = PTR_ERR(mdata);
3052 mdata = NULL;
3053 } else
3054 rc = cifs_setup_volume_info(&fake_ctx);
3055
3056 kfree(mdata);
3057
3058 if (!rc) {
3059 /*
3060 * We use a 'fake_ctx' here because we need pass it down to the
3061 * mount_{get,put} functions to test connection against new DFS
3062 * targets.
3063 */
3064 mount_put_conns(cifs_sb, *xid, *server, *ses, *tcon);
3065 rc = mount_get_conns(&fake_ctx, cifs_sb, xid, server, ses,
3066 tcon);
3067 if (!rc || (*server && *ses)) {
3068 /*
3069 * We were able to connect to new target server.
3070 * Update current context with new target server.
3071 */
3072 rc = update_vol_info(tgt_it, &fake_ctx, ctx);
3073 }
3074 }
3075 smb3_cleanup_fs_context_contents(&fake_ctx);
3076 return rc;
3077 }
3078
3079 static int do_dfs_failover(const char *path, const char *full_path, struct cifs_sb_info *cifs_sb,
3080 struct smb3_fs_context *ctx, struct cifs_ses *root_ses,
3081 unsigned int *xid, struct TCP_Server_Info **server,
3082 struct cifs_ses **ses, struct cifs_tcon **tcon)
3083 {
3084 int rc;
3085 struct dfs_cache_tgt_list tgt_list;
3086 struct dfs_cache_tgt_iterator *tgt_it = NULL;
3087
3088 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
3089 return -EOPNOTSUPP;
3090
3091 rc = dfs_cache_noreq_find(path, NULL, &tgt_list);
3092 if (rc)
3093 return rc;
3094
3095 for (;;) {
3096 /* Get next DFS target server - if any */
3097 rc = get_next_dfs_tgt(path, &tgt_list, &tgt_it);
3098 if (rc)
3099 break;
3100 /* Connect to next DFS target */
3101 rc = setup_dfs_tgt_conn(path, full_path, tgt_it, cifs_sb, ctx, xid, server, ses,
3102 tcon);
3103 if (!rc || (*server && *ses))
3104 break;
3105 }
3106 if (!rc) {
3107 /*
3108 * Update DFS target hint in DFS referral cache with the target
3109 * server we successfully reconnected to.
3110 */
3111 rc = dfs_cache_update_tgthint(*xid, root_ses ? root_ses : *ses,
3112 cifs_sb->local_nls,
3113 cifs_remap(cifs_sb), path,
3114 tgt_it);
3115 }
3116 dfs_cache_free_tgts(&tgt_list);
3117 return rc;
3118 }
3119 #endif
3120
3121 /* TODO: all callers to this are broken. We are not parsing mount_options here
3122 * we should pass a clone of the original context?
3123 */
3124 int
3125 cifs_setup_volume_info(struct smb3_fs_context *ctx)
3126 {
3127 int rc = 0;
3128
3129 if (ctx->nullauth) {
3130 cifs_dbg(FYI, "Anonymous login\n");
3131 kfree(ctx->username);
3132 ctx->username = NULL;
3133 } else if (ctx->username) {
3134 /* BB fixme parse for domain name here */
3135 cifs_dbg(FYI, "Username: %s\n", ctx->username);
3136 } else {
3137 cifs_dbg(VFS, "No username specified\n");
3138 /* In userspace mount helper we can get user name from alternate
3139 locations such as env variables and files on disk */
3140 return -EINVAL;
3141 }
3142
3143 return rc;
3144 }
3145
3146 static int
3147 cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
3148 unsigned int xid,
3149 struct cifs_tcon *tcon,
3150 struct cifs_sb_info *cifs_sb,
3151 char *full_path,
3152 int added_treename)
3153 {
3154 int rc;
3155 char *s;
3156 char sep, tmp;
3157 int skip = added_treename ? 1 : 0;
3158
3159 sep = CIFS_DIR_SEP(cifs_sb);
3160 s = full_path;
3161
3162 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
3163 while (rc == 0) {
3164 /* skip separators */
3165 while (*s == sep)
3166 s++;
3167 if (!*s)
3168 break;
3169 /* next separator */
3170 while (*s && *s != sep)
3171 s++;
3172 /*
3173 * if the treename is added, we then have to skip the first
3174 * part within the separators
3175 */
3176 if (skip) {
3177 skip = 0;
3178 continue;
3179 }
3180 /*
3181 * temporarily null-terminate the path at the end of
3182 * the current component
3183 */
3184 tmp = *s;
3185 *s = 0;
3186 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3187 full_path);
3188 *s = tmp;
3189 }
3190 return rc;
3191 }
3192
3193 /*
3194 * Check if path is remote (e.g. a DFS share). Return -EREMOTE if it is,
3195 * otherwise 0.
3196 */
3197 static int is_path_remote(struct cifs_sb_info *cifs_sb, struct smb3_fs_context *ctx,
3198 const unsigned int xid,
3199 struct TCP_Server_Info *server,
3200 struct cifs_tcon *tcon)
3201 {
3202 int rc;
3203 char *full_path;
3204
3205 if (!server->ops->is_path_accessible)
3206 return -EOPNOTSUPP;
3207
3208 /*
3209 * cifs_build_path_to_root works only when we have a valid tcon
3210 */
3211 full_path = cifs_build_path_to_root(ctx, cifs_sb, tcon,
3212 tcon->Flags & SMB_SHARE_IS_IN_DFS);
3213 if (full_path == NULL)
3214 return -ENOMEM;
3215
3216 cifs_dbg(FYI, "%s: full_path: %s\n", __func__, full_path);
3217
3218 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3219 full_path);
3220 if (rc != 0 && rc != -EREMOTE) {
3221 kfree(full_path);
3222 return rc;
3223 }
3224
3225 if (rc != -EREMOTE) {
3226 rc = cifs_are_all_path_components_accessible(server, xid, tcon,
3227 cifs_sb, full_path, tcon->Flags & SMB_SHARE_IS_IN_DFS);
3228 if (rc != 0) {
3229 cifs_server_dbg(VFS, "cannot query dirs between root and final path, enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
3230 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
3231 rc = 0;
3232 }
3233 }
3234
3235 kfree(full_path);
3236 return rc;
3237 }
3238
3239 #ifdef CONFIG_CIFS_DFS_UPCALL
3240 static void set_root_ses(struct cifs_sb_info *cifs_sb, struct cifs_ses *ses,
3241 struct cifs_ses **root_ses)
3242 {
3243 if (ses) {
3244 spin_lock(&cifs_tcp_ses_lock);
3245 ses->ses_count++;
3246 if (ses->tcon_ipc)
3247 ses->tcon_ipc->remap = cifs_remap(cifs_sb);
3248 spin_unlock(&cifs_tcp_ses_lock);
3249 }
3250 *root_ses = ses;
3251 }
3252
3253 static void put_root_ses(struct cifs_ses *ses)
3254 {
3255 if (ses)
3256 cifs_put_smb_ses(ses);
3257 }
3258
3259 /* Check if a path component is remote and then update @dfs_path accordingly */
3260 static int check_dfs_prepath(struct cifs_sb_info *cifs_sb, struct smb3_fs_context *ctx,
3261 const unsigned int xid, struct TCP_Server_Info *server,
3262 struct cifs_tcon *tcon, char **dfs_path)
3263 {
3264 char *path, *s;
3265 char sep = CIFS_DIR_SEP(cifs_sb), tmp;
3266 char *npath;
3267 int rc = 0;
3268 int added_treename = tcon->Flags & SMB_SHARE_IS_IN_DFS;
3269 int skip = added_treename;
3270
3271 path = cifs_build_path_to_root(ctx, cifs_sb, tcon, added_treename);
3272 if (!path)
3273 return -ENOMEM;
3274
3275 /*
3276 * Walk through the path components in @path and check if they're accessible. In case any of
3277 * the components is -EREMOTE, then update @dfs_path with the next DFS referral request path
3278 * (NOT including the remaining components).
3279 */
3280 s = path;
3281 do {
3282 /* skip separators */
3283 while (*s && *s == sep)
3284 s++;
3285 if (!*s)
3286 break;
3287 /* next separator */
3288 while (*s && *s != sep)
3289 s++;
3290 /*
3291 * if the treename is added, we then have to skip the first
3292 * part within the separators
3293 */
3294 if (skip) {
3295 skip = 0;
3296 continue;
3297 }
3298 tmp = *s;
3299 *s = 0;
3300 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, path);
3301 if (rc && rc == -EREMOTE) {
3302 struct smb3_fs_context v = {NULL};
3303 /* if @path contains a tree name, skip it in the prefix path */
3304 if (added_treename) {
3305 rc = smb3_parse_devname(path, &v);
3306 if (rc)
3307 break;
3308 rc = -EREMOTE;
3309 npath = build_unc_path_to_root(&v, cifs_sb, true);
3310 smb3_cleanup_fs_context_contents(&v);
3311 } else {
3312 v.UNC = ctx->UNC;
3313 v.prepath = path + 1;
3314 npath = build_unc_path_to_root(&v, cifs_sb, true);
3315 }
3316 if (IS_ERR(npath)) {
3317 rc = PTR_ERR(npath);
3318 break;
3319 }
3320 kfree(*dfs_path);
3321 *dfs_path = npath;
3322 }
3323 *s = tmp;
3324 } while (rc == 0);
3325
3326 kfree(path);
3327 return rc;
3328 }
3329
3330 int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb3_fs_context *ctx)
3331 {
3332 int rc = 0;
3333 unsigned int xid;
3334 struct TCP_Server_Info *server = NULL;
3335 struct cifs_ses *ses = NULL, *root_ses = NULL;
3336 struct cifs_tcon *tcon = NULL;
3337 int count = 0;
3338 char *ref_path = NULL, *full_path = NULL;
3339 char *oldmnt = NULL;
3340 char *mntdata = NULL;
3341
3342 rc = mount_get_conns(ctx, cifs_sb, &xid, &server, &ses, &tcon);
3343 /*
3344 * Unconditionally try to get an DFS referral (even cached) to determine whether it is an
3345 * DFS mount.
3346 *
3347 * Skip prefix path to provide support for DFS referrals from w2k8 servers which don't seem
3348 * to respond with PATH_NOT_COVERED to requests that include the prefix.
3349 */
3350 if (dfs_cache_find(xid, ses, cifs_sb->local_nls, cifs_remap(cifs_sb), ctx->UNC + 1, NULL,
3351 NULL)) {
3352 /* No DFS referral was returned. Looks like a regular share. */
3353 if (rc)
3354 goto error;
3355 /* Check if it is fully accessible and then mount it */
3356 rc = is_path_remote(cifs_sb, ctx, xid, server, tcon);
3357 if (!rc)
3358 goto out;
3359 if (rc != -EREMOTE)
3360 goto error;
3361 }
3362 /* Save mount options */
3363 mntdata = kstrndup(cifs_sb->ctx->mount_options,
3364 strlen(cifs_sb->ctx->mount_options), GFP_KERNEL);
3365 if (!mntdata) {
3366 rc = -ENOMEM;
3367 goto error;
3368 }
3369 /* Get path of DFS root */
3370 ref_path = build_unc_path_to_root(ctx, cifs_sb, false);
3371 if (IS_ERR(ref_path)) {
3372 rc = PTR_ERR(ref_path);
3373 ref_path = NULL;
3374 goto error;
3375 }
3376
3377 set_root_ses(cifs_sb, ses, &root_ses);
3378 do {
3379 /* Save full path of last DFS path we used to resolve final target server */
3380 kfree(full_path);
3381 full_path = build_unc_path_to_root(ctx, cifs_sb, !!count);
3382 if (IS_ERR(full_path)) {
3383 rc = PTR_ERR(full_path);
3384 full_path = NULL;
3385 break;
3386 }
3387 /* Chase referral */
3388 oldmnt = cifs_sb->ctx->mount_options;
3389 rc = expand_dfs_referral(xid, root_ses, ctx, cifs_sb, ref_path + 1);
3390 if (rc)
3391 break;
3392 /* Connect to new DFS target only if we were redirected */
3393 if (oldmnt != cifs_sb->ctx->mount_options) {
3394 mount_put_conns(cifs_sb, xid, server, ses, tcon);
3395 rc = mount_get_conns(ctx, cifs_sb, &xid, &server, &ses, &tcon);
3396 }
3397 if (rc && !server && !ses) {
3398 /* Failed to connect. Try to connect to other targets in the referral. */
3399 rc = do_dfs_failover(ref_path + 1, full_path, cifs_sb, ctx, root_ses, &xid,
3400 &server, &ses, &tcon);
3401 }
3402 if (rc == -EACCES || rc == -EOPNOTSUPP || !server || !ses)
3403 break;
3404 if (!tcon)
3405 continue;
3406 /* Make sure that requests go through new root servers */
3407 if (is_tcon_dfs(tcon)) {
3408 put_root_ses(root_ses);
3409 set_root_ses(cifs_sb, ses, &root_ses);
3410 }
3411 /* Check for remaining path components and then continue chasing them (-EREMOTE) */
3412 rc = check_dfs_prepath(cifs_sb, ctx, xid, server, tcon, &ref_path);
3413 /* Prevent recursion on broken link referrals */
3414 if (rc == -EREMOTE && ++count > MAX_NESTED_LINKS)
3415 rc = -ELOOP;
3416 } while (rc == -EREMOTE);
3417
3418 if (rc)
3419 goto error;
3420 put_root_ses(root_ses);
3421 root_ses = NULL;
3422 kfree(ref_path);
3423 ref_path = NULL;
3424 /*
3425 * Store DFS full path in both superblock and tree connect structures.
3426 *
3427 * For DFS root mounts, the prefix path (cifs_sb->prepath) is preserved during reconnect so
3428 * only the root path is set in cifs_sb->origin_fullpath and tcon->dfs_path. And for DFS
3429 * links, the prefix path is included in both and may be changed during reconnect. See
3430 * cifs_tree_connect().
3431 */
3432 cifs_sb->origin_fullpath = kstrndup(full_path, strlen(full_path), GFP_KERNEL);
3433 if (!cifs_sb->origin_fullpath) {
3434 rc = -ENOMEM;
3435 goto error;
3436 }
3437 spin_lock(&cifs_tcp_ses_lock);
3438 tcon->dfs_path = full_path;
3439 full_path = NULL;
3440 tcon->remap = cifs_remap(cifs_sb);
3441 spin_unlock(&cifs_tcp_ses_lock);
3442
3443 /* Add original context for DFS cache to be used when refreshing referrals */
3444 rc = dfs_cache_add_vol(mntdata, ctx, cifs_sb->origin_fullpath);
3445 if (rc)
3446 goto error;
3447 /*
3448 * After reconnecting to a different server, unique ids won't
3449 * match anymore, so we disable serverino. This prevents
3450 * dentry revalidation to think the dentry are stale (ESTALE).
3451 */
3452 cifs_autodisable_serverino(cifs_sb);
3453 /*
3454 * Force the use of prefix path to support failover on DFS paths that
3455 * resolve to targets that have different prefix paths.
3456 */
3457 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
3458 kfree(cifs_sb->prepath);
3459 cifs_sb->prepath = ctx->prepath;
3460 ctx->prepath = NULL;
3461
3462 out:
3463 free_xid(xid);
3464 cifs_try_adding_channels(cifs_sb, ses);
3465 return mount_setup_tlink(cifs_sb, ses, tcon);
3466
3467 error:
3468 kfree(ref_path);
3469 kfree(full_path);
3470 kfree(mntdata);
3471 kfree(cifs_sb->origin_fullpath);
3472 put_root_ses(root_ses);
3473 mount_put_conns(cifs_sb, xid, server, ses, tcon);
3474 return rc;
3475 }
3476 #else
3477 int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb3_fs_context *ctx)
3478 {
3479 int rc = 0;
3480 unsigned int xid;
3481 struct cifs_ses *ses;
3482 struct cifs_tcon *tcon;
3483 struct TCP_Server_Info *server;
3484
3485 rc = mount_get_conns(ctx, cifs_sb, &xid, &server, &ses, &tcon);
3486 if (rc)
3487 goto error;
3488
3489 if (tcon) {
3490 rc = is_path_remote(cifs_sb, ctx, xid, server, tcon);
3491 if (rc == -EREMOTE)
3492 rc = -EOPNOTSUPP;
3493 if (rc)
3494 goto error;
3495 }
3496
3497 free_xid(xid);
3498
3499 return mount_setup_tlink(cifs_sb, ses, tcon);
3500
3501 error:
3502 mount_put_conns(cifs_sb, xid, server, ses, tcon);
3503 return rc;
3504 }
3505 #endif
3506
3507 /*
3508 * Issue a TREE_CONNECT request.
3509 */
3510 int
3511 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
3512 const char *tree, struct cifs_tcon *tcon,
3513 const struct nls_table *nls_codepage)
3514 {
3515 struct smb_hdr *smb_buffer;
3516 struct smb_hdr *smb_buffer_response;
3517 TCONX_REQ *pSMB;
3518 TCONX_RSP *pSMBr;
3519 unsigned char *bcc_ptr;
3520 int rc = 0;
3521 int length;
3522 __u16 bytes_left, count;
3523
3524 if (ses == NULL)
3525 return -EIO;
3526
3527 smb_buffer = cifs_buf_get();
3528 if (smb_buffer == NULL)
3529 return -ENOMEM;
3530
3531 smb_buffer_response = smb_buffer;
3532
3533 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3534 NULL /*no tid */ , 4 /*wct */ );
3535
3536 smb_buffer->Mid = get_next_mid(ses->server);
3537 smb_buffer->Uid = ses->Suid;
3538 pSMB = (TCONX_REQ *) smb_buffer;
3539 pSMBr = (TCONX_RSP *) smb_buffer_response;
3540
3541 pSMB->AndXCommand = 0xFF;
3542 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3543 bcc_ptr = &pSMB->Password[0];
3544 if (tcon->pipe || (ses->server->sec_mode & SECMODE_USER)) {
3545 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3546 *bcc_ptr = 0; /* password is null byte */
3547 bcc_ptr++; /* skip password */
3548 /* already aligned so no need to do it below */
3549 } else {
3550 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3551 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3552 specified as required (when that support is added to
3553 the vfs in the future) as only NTLM or the much
3554 weaker LANMAN (which we do not send by default) is accepted
3555 by Samba (not sure whether other servers allow
3556 NTLMv2 password here) */
3557 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3558 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3559 (ses->sectype == LANMAN))
3560 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3561 ses->server->sec_mode &
3562 SECMODE_PW_ENCRYPT ? true : false,
3563 bcc_ptr);
3564 else
3565 #endif /* CIFS_WEAK_PW_HASH */
3566 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3567 bcc_ptr, nls_codepage);
3568 if (rc) {
3569 cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
3570 __func__, rc);
3571 cifs_buf_release(smb_buffer);
3572 return rc;
3573 }
3574
3575 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3576 if (ses->capabilities & CAP_UNICODE) {
3577 /* must align unicode strings */
3578 *bcc_ptr = 0; /* null byte password */
3579 bcc_ptr++;
3580 }
3581 }
3582
3583 if (ses->server->sign)
3584 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3585
3586 if (ses->capabilities & CAP_STATUS32) {
3587 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3588 }
3589 if (ses->capabilities & CAP_DFS) {
3590 smb_buffer->Flags2 |= SMBFLG2_DFS;
3591 }
3592 if (ses->capabilities & CAP_UNICODE) {
3593 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3594 length =
3595 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3596 6 /* max utf8 char length in bytes */ *
3597 (/* server len*/ + 256 /* share len */), nls_codepage);
3598 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3599 bcc_ptr += 2; /* skip trailing null */
3600 } else { /* ASCII */
3601 strcpy(bcc_ptr, tree);
3602 bcc_ptr += strlen(tree) + 1;
3603 }
3604 strcpy(bcc_ptr, "?????");
3605 bcc_ptr += strlen("?????");
3606 bcc_ptr += 1;
3607 count = bcc_ptr - &pSMB->Password[0];
3608 be32_add_cpu(&pSMB->hdr.smb_buf_length, count);
3609 pSMB->ByteCount = cpu_to_le16(count);
3610
3611 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3612 0);
3613
3614 /* above now done in SendReceive */
3615 if (rc == 0) {
3616 bool is_unicode;
3617
3618 tcon->tidStatus = CifsGood;
3619 tcon->need_reconnect = false;
3620 tcon->tid = smb_buffer_response->Tid;
3621 bcc_ptr = pByteArea(smb_buffer_response);
3622 bytes_left = get_bcc(smb_buffer_response);
3623 length = strnlen(bcc_ptr, bytes_left - 2);
3624 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3625 is_unicode = true;
3626 else
3627 is_unicode = false;
3628
3629
3630 /* skip service field (NB: this field is always ASCII) */
3631 if (length == 3) {
3632 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3633 (bcc_ptr[2] == 'C')) {
3634 cifs_dbg(FYI, "IPC connection\n");
3635 tcon->ipc = true;
3636 tcon->pipe = true;
3637 }
3638 } else if (length == 2) {
3639 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3640 /* the most common case */
3641 cifs_dbg(FYI, "disk share connection\n");
3642 }
3643 }
3644 bcc_ptr += length + 1;
3645 bytes_left -= (length + 1);
3646 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
3647
3648 /* mostly informational -- no need to fail on error here */
3649 kfree(tcon->nativeFileSystem);
3650 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
3651 bytes_left, is_unicode,
3652 nls_codepage);
3653
3654 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
3655
3656 if ((smb_buffer_response->WordCount == 3) ||
3657 (smb_buffer_response->WordCount == 7))
3658 /* field is in same location */
3659 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3660 else
3661 tcon->Flags = 0;
3662 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
3663 }
3664
3665 cifs_buf_release(smb_buffer);
3666 return rc;
3667 }
3668
3669 static void delayed_free(struct rcu_head *p)
3670 {
3671 struct cifs_sb_info *cifs_sb = container_of(p, struct cifs_sb_info, rcu);
3672
3673 unload_nls(cifs_sb->local_nls);
3674 smb3_cleanup_fs_context(cifs_sb->ctx);
3675 kfree(cifs_sb);
3676 }
3677
3678 void
3679 cifs_umount(struct cifs_sb_info *cifs_sb)
3680 {
3681 struct rb_root *root = &cifs_sb->tlink_tree;
3682 struct rb_node *node;
3683 struct tcon_link *tlink;
3684
3685 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3686
3687 spin_lock(&cifs_sb->tlink_tree_lock);
3688 while ((node = rb_first(root))) {
3689 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3690 cifs_get_tlink(tlink);
3691 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3692 rb_erase(node, root);
3693
3694 spin_unlock(&cifs_sb->tlink_tree_lock);
3695 cifs_put_tlink(tlink);
3696 spin_lock(&cifs_sb->tlink_tree_lock);
3697 }
3698 spin_unlock(&cifs_sb->tlink_tree_lock);
3699
3700 kfree(cifs_sb->prepath);
3701 #ifdef CONFIG_CIFS_DFS_UPCALL
3702 dfs_cache_del_vol(cifs_sb->origin_fullpath);
3703 kfree(cifs_sb->origin_fullpath);
3704 #endif
3705 call_rcu(&cifs_sb->rcu, delayed_free);
3706 }
3707
3708 int
3709 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
3710 {
3711 int rc = 0;
3712 struct TCP_Server_Info *server = cifs_ses_server(ses);
3713
3714 if (!server->ops->need_neg || !server->ops->negotiate)
3715 return -ENOSYS;
3716
3717 /* only send once per connect */
3718 if (!server->ops->need_neg(server))
3719 return 0;
3720
3721 rc = server->ops->negotiate(xid, ses);
3722 if (rc == 0) {
3723 spin_lock(&GlobalMid_Lock);
3724 if (server->tcpStatus == CifsNeedNegotiate)
3725 server->tcpStatus = CifsGood;
3726 else
3727 rc = -EHOSTDOWN;
3728 spin_unlock(&GlobalMid_Lock);
3729 }
3730
3731 return rc;
3732 }
3733
3734 int
3735 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
3736 struct nls_table *nls_info)
3737 {
3738 int rc = -ENOSYS;
3739 struct TCP_Server_Info *server = cifs_ses_server(ses);
3740
3741 if (!ses->binding) {
3742 ses->capabilities = server->capabilities;
3743 if (linuxExtEnabled == 0)
3744 ses->capabilities &= (~server->vals->cap_unix);
3745
3746 if (ses->auth_key.response) {
3747 cifs_dbg(FYI, "Free previous auth_key.response = %p\n",
3748 ses->auth_key.response);
3749 kfree(ses->auth_key.response);
3750 ses->auth_key.response = NULL;
3751 ses->auth_key.len = 0;
3752 }
3753 }
3754
3755 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
3756 server->sec_mode, server->capabilities, server->timeAdj);
3757
3758 if (server->ops->sess_setup)
3759 rc = server->ops->sess_setup(xid, ses, nls_info);
3760
3761 if (rc)
3762 cifs_server_dbg(VFS, "Send error in SessSetup = %d\n", rc);
3763
3764 return rc;
3765 }
3766
3767 static int
3768 cifs_set_vol_auth(struct smb3_fs_context *ctx, struct cifs_ses *ses)
3769 {
3770 ctx->sectype = ses->sectype;
3771
3772 /* krb5 is special, since we don't need username or pw */
3773 if (ctx->sectype == Kerberos)
3774 return 0;
3775
3776 return cifs_set_cifscreds(ctx, ses);
3777 }
3778
3779 static struct cifs_tcon *
3780 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
3781 {
3782 int rc;
3783 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3784 struct cifs_ses *ses;
3785 struct cifs_tcon *tcon = NULL;
3786 struct smb3_fs_context *ctx;
3787
3788 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
3789 if (ctx == NULL)
3790 return ERR_PTR(-ENOMEM);
3791
3792 ctx->local_nls = cifs_sb->local_nls;
3793 ctx->linux_uid = fsuid;
3794 ctx->cred_uid = fsuid;
3795 ctx->UNC = master_tcon->treeName;
3796 ctx->retry = master_tcon->retry;
3797 ctx->nocase = master_tcon->nocase;
3798 ctx->nohandlecache = master_tcon->nohandlecache;
3799 ctx->local_lease = master_tcon->local_lease;
3800 ctx->no_lease = master_tcon->no_lease;
3801 ctx->resilient = master_tcon->use_resilient;
3802 ctx->persistent = master_tcon->use_persistent;
3803 ctx->handle_timeout = master_tcon->handle_timeout;
3804 ctx->no_linux_ext = !master_tcon->unix_ext;
3805 ctx->linux_ext = master_tcon->posix_extensions;
3806 ctx->sectype = master_tcon->ses->sectype;
3807 ctx->sign = master_tcon->ses->sign;
3808 ctx->seal = master_tcon->seal;
3809 #ifdef CONFIG_CIFS_SWN_UPCALL
3810 ctx->witness = master_tcon->use_witness;
3811 #endif
3812
3813 rc = cifs_set_vol_auth(ctx, master_tcon->ses);
3814 if (rc) {
3815 tcon = ERR_PTR(rc);
3816 goto out;
3817 }
3818
3819 /* get a reference for the same TCP session */
3820 spin_lock(&cifs_tcp_ses_lock);
3821 ++master_tcon->ses->server->srv_count;
3822 spin_unlock(&cifs_tcp_ses_lock);
3823
3824 ses = cifs_get_smb_ses(master_tcon->ses->server, ctx);
3825 if (IS_ERR(ses)) {
3826 tcon = (struct cifs_tcon *)ses;
3827 cifs_put_tcp_session(master_tcon->ses->server, 0);
3828 goto out;
3829 }
3830
3831 tcon = cifs_get_tcon(ses, ctx);
3832 if (IS_ERR(tcon)) {
3833 cifs_put_smb_ses(ses);
3834 goto out;
3835 }
3836
3837 if (cap_unix(ses))
3838 reset_cifs_unix_caps(0, tcon, NULL, ctx);
3839
3840 out:
3841 kfree(ctx->username);
3842 kfree_sensitive(ctx->password);
3843 kfree(ctx);
3844
3845 return tcon;
3846 }
3847
3848 struct cifs_tcon *
3849 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3850 {
3851 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3852 }
3853
3854 /* find and return a tlink with given uid */
3855 static struct tcon_link *
3856 tlink_rb_search(struct rb_root *root, kuid_t uid)
3857 {
3858 struct rb_node *node = root->rb_node;
3859 struct tcon_link *tlink;
3860
3861 while (node) {
3862 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3863
3864 if (uid_gt(tlink->tl_uid, uid))
3865 node = node->rb_left;
3866 else if (uid_lt(tlink->tl_uid, uid))
3867 node = node->rb_right;
3868 else
3869 return tlink;
3870 }
3871 return NULL;
3872 }
3873
3874 /* insert a tcon_link into the tree */
3875 static void
3876 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3877 {
3878 struct rb_node **new = &(root->rb_node), *parent = NULL;
3879 struct tcon_link *tlink;
3880
3881 while (*new) {
3882 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3883 parent = *new;
3884
3885 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
3886 new = &((*new)->rb_left);
3887 else
3888 new = &((*new)->rb_right);
3889 }
3890
3891 rb_link_node(&new_tlink->tl_rbnode, parent, new);
3892 rb_insert_color(&new_tlink->tl_rbnode, root);
3893 }
3894
3895 /*
3896 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3897 * current task.
3898 *
3899 * If the superblock doesn't refer to a multiuser mount, then just return
3900 * the master tcon for the mount.
3901 *
3902 * First, search the rbtree for an existing tcon for this fsuid. If one
3903 * exists, then check to see if it's pending construction. If it is then wait
3904 * for construction to complete. Once it's no longer pending, check to see if
3905 * it failed and either return an error or retry construction, depending on
3906 * the timeout.
3907 *
3908 * If one doesn't exist then insert a new tcon_link struct into the tree and
3909 * try to construct a new one.
3910 */
3911 struct tcon_link *
3912 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
3913 {
3914 int ret;
3915 kuid_t fsuid = current_fsuid();
3916 struct tcon_link *tlink, *newtlink;
3917
3918 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
3919 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3920
3921 spin_lock(&cifs_sb->tlink_tree_lock);
3922 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3923 if (tlink)
3924 cifs_get_tlink(tlink);
3925 spin_unlock(&cifs_sb->tlink_tree_lock);
3926
3927 if (tlink == NULL) {
3928 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
3929 if (newtlink == NULL)
3930 return ERR_PTR(-ENOMEM);
3931 newtlink->tl_uid = fsuid;
3932 newtlink->tl_tcon = ERR_PTR(-EACCES);
3933 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
3934 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
3935 cifs_get_tlink(newtlink);
3936
3937 spin_lock(&cifs_sb->tlink_tree_lock);
3938 /* was one inserted after previous search? */
3939 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3940 if (tlink) {
3941 cifs_get_tlink(tlink);
3942 spin_unlock(&cifs_sb->tlink_tree_lock);
3943 kfree(newtlink);
3944 goto wait_for_construction;
3945 }
3946 tlink = newtlink;
3947 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3948 spin_unlock(&cifs_sb->tlink_tree_lock);
3949 } else {
3950 wait_for_construction:
3951 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
3952 TASK_INTERRUPTIBLE);
3953 if (ret) {
3954 cifs_put_tlink(tlink);
3955 return ERR_PTR(-ERESTARTSYS);
3956 }
3957
3958 /* if it's good, return it */
3959 if (!IS_ERR(tlink->tl_tcon))
3960 return tlink;
3961
3962 /* return error if we tried this already recently */
3963 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
3964 cifs_put_tlink(tlink);
3965 return ERR_PTR(-EACCES);
3966 }
3967
3968 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
3969 goto wait_for_construction;
3970 }
3971
3972 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
3973 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
3974 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
3975
3976 if (IS_ERR(tlink->tl_tcon)) {
3977 cifs_put_tlink(tlink);
3978 return ERR_PTR(-EACCES);
3979 }
3980
3981 return tlink;
3982 }
3983
3984 /*
3985 * periodic workqueue job that scans tcon_tree for a superblock and closes
3986 * out tcons.
3987 */
3988 static void
3989 cifs_prune_tlinks(struct work_struct *work)
3990 {
3991 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
3992 prune_tlinks.work);
3993 struct rb_root *root = &cifs_sb->tlink_tree;
3994 struct rb_node *node;
3995 struct rb_node *tmp;
3996 struct tcon_link *tlink;
3997
3998 /*
3999 * Because we drop the spinlock in the loop in order to put the tlink
4000 * it's not guarded against removal of links from the tree. The only
4001 * places that remove entries from the tree are this function and
4002 * umounts. Because this function is non-reentrant and is canceled
4003 * before umount can proceed, this is safe.
4004 */
4005 spin_lock(&cifs_sb->tlink_tree_lock);
4006 node = rb_first(root);
4007 while (node != NULL) {
4008 tmp = node;
4009 node = rb_next(tmp);
4010 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4011
4012 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4013 atomic_read(&tlink->tl_count) != 0 ||
4014 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4015 continue;
4016
4017 cifs_get_tlink(tlink);
4018 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4019 rb_erase(tmp, root);
4020
4021 spin_unlock(&cifs_sb->tlink_tree_lock);
4022 cifs_put_tlink(tlink);
4023 spin_lock(&cifs_sb->tlink_tree_lock);
4024 }
4025 spin_unlock(&cifs_sb->tlink_tree_lock);
4026
4027 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4028 TLINK_IDLE_EXPIRE);
4029 }
4030
4031 #ifdef CONFIG_CIFS_DFS_UPCALL
4032 int cifs_tree_connect(const unsigned int xid, struct cifs_tcon *tcon, const struct nls_table *nlsc)
4033 {
4034 int rc;
4035 struct TCP_Server_Info *server = tcon->ses->server;
4036 const struct smb_version_operations *ops = server->ops;
4037 struct dfs_cache_tgt_list tl;
4038 struct dfs_cache_tgt_iterator *it = NULL;
4039 char *tree;
4040 const char *tcp_host;
4041 size_t tcp_host_len;
4042 const char *dfs_host;
4043 size_t dfs_host_len;
4044 char *share = NULL, *prefix = NULL;
4045 struct dfs_info3_param ref = {0};
4046 bool isroot;
4047
4048 tree = kzalloc(MAX_TREE_SIZE, GFP_KERNEL);
4049 if (!tree)
4050 return -ENOMEM;
4051
4052 if (!tcon->dfs_path) {
4053 if (tcon->ipc) {
4054 scnprintf(tree, MAX_TREE_SIZE, "\\\\%s\\IPC$", server->hostname);
4055 rc = ops->tree_connect(xid, tcon->ses, tree, tcon, nlsc);
4056 } else {
4057 rc = ops->tree_connect(xid, tcon->ses, tcon->treeName, tcon, nlsc);
4058 }
4059 goto out;
4060 }
4061
4062 rc = dfs_cache_noreq_find(tcon->dfs_path + 1, &ref, &tl);
4063 if (rc)
4064 goto out;
4065 isroot = ref.server_type == DFS_TYPE_ROOT;
4066 free_dfs_info_param(&ref);
4067
4068 extract_unc_hostname(server->hostname, &tcp_host, &tcp_host_len);
4069
4070 for (it = dfs_cache_get_tgt_iterator(&tl); it; it = dfs_cache_get_next_tgt(&tl, it)) {
4071 bool target_match;
4072
4073 kfree(share);
4074 kfree(prefix);
4075 share = NULL;
4076 prefix = NULL;
4077
4078 rc = dfs_cache_get_tgt_share(tcon->dfs_path + 1, it, &share, &prefix);
4079 if (rc) {
4080 cifs_dbg(VFS, "%s: failed to parse target share %d\n",
4081 __func__, rc);
4082 continue;
4083 }
4084
4085 extract_unc_hostname(share, &dfs_host, &dfs_host_len);
4086
4087 if (dfs_host_len != tcp_host_len
4088 || strncasecmp(dfs_host, tcp_host, dfs_host_len) != 0) {
4089 cifs_dbg(FYI, "%s: %.*s doesn't match %.*s\n", __func__, (int)dfs_host_len,
4090 dfs_host, (int)tcp_host_len, tcp_host);
4091
4092 rc = match_target_ip(server, dfs_host, dfs_host_len, &target_match);
4093 if (rc) {
4094 cifs_dbg(VFS, "%s: failed to match target ip: %d\n", __func__, rc);
4095 break;
4096 }
4097
4098 if (!target_match) {
4099 cifs_dbg(FYI, "%s: skipping target\n", __func__);
4100 continue;
4101 }
4102 }
4103
4104 if (tcon->ipc) {
4105 scnprintf(tree, MAX_TREE_SIZE, "\\\\%s\\IPC$", share);
4106 rc = ops->tree_connect(xid, tcon->ses, tree, tcon, nlsc);
4107 } else {
4108 scnprintf(tree, MAX_TREE_SIZE, "\\%s", share);
4109 rc = ops->tree_connect(xid, tcon->ses, tree, tcon, nlsc);
4110 /* Only handle prefix paths of DFS link targets */
4111 if (!rc && !isroot) {
4112 rc = update_super_prepath(tcon, prefix);
4113 break;
4114 }
4115 }
4116 if (rc == -EREMOTE)
4117 break;
4118 }
4119
4120 kfree(share);
4121 kfree(prefix);
4122
4123 if (!rc) {
4124 if (it)
4125 rc = dfs_cache_noreq_update_tgthint(tcon->dfs_path + 1, it);
4126 else
4127 rc = -ENOENT;
4128 }
4129 dfs_cache_free_tgts(&tl);
4130 out:
4131 kfree(tree);
4132 return rc;
4133 }
4134 #else
4135 int cifs_tree_connect(const unsigned int xid, struct cifs_tcon *tcon, const struct nls_table *nlsc)
4136 {
4137 const struct smb_version_operations *ops = tcon->ses->server->ops;
4138
4139 return ops->tree_connect(xid, tcon->ses, tcon->treeName, tcon, nlsc);
4140 }
4141 #endif
Linux with added FPC-III support