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