]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - fs/cifs/connect.c
projects / mirror_ubuntu-jammy-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
cifs: add resp_buf_size to the mid_q_entry structure
[mirror_ubuntu-jammy-kernel.git] / fs / cifs / connect.c
1 /*
2 * fs/cifs/connect.c
3 *
4 * Copyright (C) International Business Machines Corp., 2002,2011
5 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21 #include <linux/fs.h>
22 #include <linux/net.h>
23 #include <linux/string.h>
24 #include <linux/sched/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
63 extern mempool_t *cifs_req_poolp;
64
65 /* FIXME: should these be tunable? */
66 #define TLINK_ERROR_EXPIRE (1 * HZ)
67 #define TLINK_IDLE_EXPIRE (600 * HZ)
68
69 enum {
70 /* Mount options that take no arguments */
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 /* Mount options which take numeric value */
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 /* Mount options which take string value */
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 /* Mount options to be ignored */
112 Opt_ignore,
113
114 /* Options which could be blank */
115 Opt_blank_pass,
116 Opt_blank_user,
117 Opt_blank_ip,
118
119 Opt_err
120 };
121
122 static 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" }, /* SFU style */
137 { Opt_nomapchars, "nomapchars" },
138 { Opt_mapposix, "mapposix" }, /* SFM style */
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
253 enum {
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
263 static 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 /* cache flavors */
281 enum {
282 Opt_cache_loose,
283 Opt_cache_strict,
284 Opt_cache_none,
285 Opt_cache_err
286 };
287
288 static 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
295 static 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 /* SMB311 */
305 { Smb_3any, SMB3ANY_VERSION_STRING },
306 { Smb_default, SMBDEFAULT_VERSION_STRING },
307 { Smb_version_err, NULL }
308 };
309
310 static int ip_connect(struct TCP_Server_Info *server);
311 static int generic_ip_connect(struct TCP_Server_Info *server);
312 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
313 static void cifs_prune_tlinks(struct work_struct *work);
314 static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
315 const char *devname);
316
317 /*
318 * cifs tcp session reconnection
319 *
320 * mark tcp session as reconnecting so temporarily locked
321 * mark all smb sessions as reconnecting for tcp session
322 * reconnect tcp session
323 * wake up waiters on reconnection? - (not needed currently)
324 */
325 int
326 cifs_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 /* the demux thread will exit normally
338 next time through the loop */
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 /* before reconnecting the tcp session, mark the smb session (uid)
350 and the tid bad so they are not used until reconnected */
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 /* do not want to be sending data on a socket we are freeing */
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 /* mark submitted MIDs for retry and issue callback */
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 /* we should try only the port we connected to before */
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
434 static void
435 cifs_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 * If we need to renegotiate, set echo interval to zero to
444 * immediately call echo service where we can renegotiate.
445 */
446 if (server->tcpStatus == CifsNeedNegotiate)
447 echo_interval = 0;
448 else
449 echo_interval = server->echo_interval;
450
451 /*
452 * We cannot send an echo if it is disabled.
453 * Also, no need to ping if we got a response recently.
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
468 requeue_echo:
469 queue_delayed_work(cifsiod_wq, &server->echo, server->echo_interval);
470 }
471
472 static bool
473 allocate_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 /* retry will check if exiting */
481 return false;
482 }
483 } else if (server->large_buf) {
484 /* we are reusing a dirty large buf, clear its start */
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 /* retry will check if exiting */
494 return false;
495 }
496 /* beginning of smb buffer is cleared in our buf_get */
497 } else {
498 /* if existing small buf clear beginning */
499 memset(server->smallbuf, 0, HEADER_SIZE(server));
500 }
501
502 return true;
503 }
504
505 static bool
506 server_unresponsive(struct TCP_Server_Info *server)
507 {
508 /*
509 * We need to wait 2 echo intervals to make sure we handle such
510 * situations right:
511 * 1s client sends a normal SMB request
512 * 2s client gets a response
513 * 30s echo workqueue job pops, and decides we got a response recently
514 * and don't need to send another
515 * ...
516 * 65s kernel_recvmsg times out, and we see that we haven't gotten
517 * a response in >60s.
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
532 static int
533 cifs_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 * Minimum sleep to prevent looping, allowing socket
564 * to clear and app threads to set tcpStatus
565 * CifsNeedReconnect if server hung.
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
581 int
582 cifs_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
592 int
593 cifs_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
602 static bool
603 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
604 {
605 /*
606 * The first byte big endian of the length field,
607 * is actually not part of the length but the type
608 * with the most common, zero, as regular data.
609 */
610 switch (type) {
611 case RFC1002_SESSION_MESSAGE:
612 /* Regular SMB response */
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 * We get this from Windows 98 instead of an error on
623 * SMB negprot response.
624 */
625 cifs_dbg(FYI, "RFC 1002 negative session response\n");
626 /* give server a second to clean up */
627 msleep(1000);
628 /*
629 * Always try 445 first on reconnect since we get NACK
630 * on some if we ever connected to port 139 (the NACK
631 * is since we do not begin with RFC1001 session
632 * initialize frame).
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
646 void
647 dequeue_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
661 static void
662 handle_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 /* Was previous buf put in mpx struct for multi-rsp? */
671 if (!mid->multiRsp) {
672 /* smb buffer will be freed by user thread */
673 if (server->large_buf)
674 server->bigbuf = NULL;
675 else
676 server->smallbuf = NULL;
677 }
678 dequeue_mid(mid, malformed);
679 }
680
681 static void clean_demultiplex_info(struct TCP_Server_Info *server)
682 {
683 int length;
684
685 /* take it off the list, if it's not already */
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 /* check if we have blocked requests that need to free */
696 spin_lock(&server->req_lock);
697 if (server->credits <= 0)
698 server->credits = 1;
699 spin_unlock(&server->req_lock);
700 /*
701 * Although there should not be any requests blocked on this queue it
702 * can not hurt to be paranoid and try to wake up requests that may
703 * haven been blocked when more than 50 at time were on the wire to the
704 * same server - they now will see the session is in exit state and get
705 * out of SendReceive.
706 */
707 wake_up_all(&server->request_q);
708 /* give those requests time to exit */
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 /* now walk dispose list and issue callbacks */
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 /* 1/8th of sec is more than enough time for them to exit */
742 msleep(125);
743 }
744
745 if (!list_empty(&server->pending_mid_q)) {
746 /*
747 * mpx threads have not exited yet give them at least the smb
748 * send timeout time for long ops.
749 *
750 * Due to delays on oplock break requests, we need to wait at
751 * least 45 seconds before giving up on a request getting a
752 * response and going ahead and killing cifsd.
753 */
754 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
755 msleep(46000);
756 /*
757 * If threads still have not exited they are probably never
758 * coming home not much else we can do but free the memory.
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
770 static int
771 standard_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 /* make sure this will fit in a large buffer */
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 /* switch to large buffer if too big for a small one */
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 /* now read the rest */
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
807 int
808 cifs_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 * We know that we received enough to get to the MID as we
815 * checked the pdu_length earlier. Now check to see
816 * if the rest of the header is OK. We borrow the length
817 * var for the rest of the loop to avoid a new stack var.
818 *
819 * 48 bytes is enough to display the header and a little bit
820 * into the payload for debugging purposes.
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
845 static int
846 cifs_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; /* enough to get RFC1001 header */
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 * The right amount was read from socket - 4 bytes,
881 * so we can now interpret the length field.
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 /* make sure we have enough to get to the MID */
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 /* read down to the MID */
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 /* CIFS_DEBUG2 */
954
955 }
956 } /* end while !EXITING */
957
958 /* buffer usually freed in free_mid - need to free it here on exit */
959 cifs_buf_release(server->bigbuf);
960 if (server->smallbuf) /* no sense logging a debug message if NULL */
961 cifs_small_buf_release(server->smallbuf);
962
963 task_to_wake = xchg(&server->tsk, NULL);
964 clean_demultiplex_info(server);
965
966 /* if server->tsk was NULL then wait for a signal before exiting */
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 /* extract the host portion of the UNC string */
980 static char *
981 extract_hostname(const char *unc)
982 {
983 const char *src;
984 char *dst, *delim;
985 unsigned int len;
986
987 /* skip double chars at beginning of string */
988 /* BB: check validity of these bytes? */
989 src = unc + 2;
990
991 /* delimiter between hostname and sharename is always '\\' now */
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
1007 static 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
1021 static 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
1039 static 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
1057 static int cifs_parse_security_flavors(char *value,
1058 struct smb_vol *vol)
1059 {
1060
1061 substring_t args[MAX_OPT_ARGS];
1062
1063 /*
1064 * With mount options, the last one should win. Reset any existing
1065 * settings back to default.
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 /* Fallthrough */
1077 case Opt_sec_krb5:
1078 vol->sectype = Kerberos;
1079 break;
1080 case Opt_sec_ntlmsspi:
1081 vol->sign = true;
1082 /* Fallthrough */
1083 case Opt_sec_ntlmssp:
1084 vol->sectype = RawNTLMSSP;
1085 break;
1086 case Opt_sec_ntlmi:
1087 vol->sign = true;
1088 /* Fallthrough */
1089 case Opt_ntlm:
1090 vol->sectype = NTLM;
1091 break;
1092 case Opt_sec_ntlmv2i:
1093 vol->sign = true;
1094 /* Fallthrough */
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
1114 static int
1115 cifs_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
1139 static int
1140 cifs_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; /* currently identical with 3.0 */
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 /* SMB311 */
1171 case Smb_3any:
1172 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1173 vol->vals = &smb3any_values;
1174 break;
1175 case Smb_default:
1176 vol->ops = &smb30_operations; /* currently identical with 3.0 */
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 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1188 * fields with the result. Returns 0 on success and an error otherwise.
1189 */
1190 static int
1191 cifs_parse_devname(const char *devname, struct smb_vol *vol)
1192 {
1193 char *pos;
1194 const char *delims = "/\\";
1195 size_t len;
1196
1197 /* make sure we have a valid UNC double delimiter prefix */
1198 len = strspn(devname, delims);
1199 if (len != 2)
1200 return -EINVAL;
1201
1202 /* find delimiter between host and sharename */
1203 pos = strpbrk(devname + 2, delims);
1204 if (!pos)
1205 return -EINVAL;
1206
1207 /* skip past delimiter */
1208 ++pos;
1209
1210 /* now go until next delimiter or end of string */
1211 len = strcspn(pos, delims);
1212
1213 /* move "pos" up to delimiter or NULL */
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 /* skip any delimiter */
1222 if (*pos == '/' || *pos == '\\')
1223 pos++;
1224
1225 /* If pos is NULL then no prepath */
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
1236 static int
1237 cifs_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 /* ensure we always start with zeroed-out smb_vol */
1264 memset(vol, 0, sizeof(*vol));
1265
1266 /*
1267 * does not have to be perfect mapping since field is
1268 * informational, only used for servers that do not support
1269 * port 445 and it can be overridden at mount time
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 /* null target name indicates to use *SMBSERVR default called name
1277 if we end up sending RFC1001 session initialize */
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 * default to SFM style remapping of seven reserved characters
1285 * unless user overrides it or we negotiate CIFS POSIX where
1286 * it is unnecessary. Can not simultaneously use more than one mapping
1287 * since then readdir could list files that open could not open
1288 */
1289 vol->remap = true;
1290
1291 /* default to only allowing write access to owner of the mount */
1292 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1293
1294 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1295 /* default is always to request posix paths. */
1296 vol->posix_paths = 1;
1297 /* default to using server inode numbers where available */
1298 vol->server_ino = 1;
1299
1300 /* default is to use strict cifs caching semantics */
1301 vol->strict_io = true;
1302
1303 vol->actimeo = CIFS_DEF_ACTIMEO;
1304
1305 /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
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; /* no backup intent for a user */
1330 vol->backupgid_specified = false; /* no backup intent for a group */
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 /* Ingnore the following */
1359 case Opt_ignore:
1360 break;
1361
1362 /* Boolean values */
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; /* disable SFM mapping */
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; /* disable SFU mapping */
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 * turn off mandatory locking in mode
1441 * if remote locking is turned off since the
1442 * local vfs will do advisory
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 /* we do not do the following in secFlags because seal
1513 * is a per tree connection (mount) not a per socket
1514 * or per-smb connection option in the protocol
1515 * vol->secFlg |= CIFSSEC_MUST_SEAL;
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; /* already the default */
1567 break;
1568 case Opt_domainauto:
1569 vol->domainauto = true;
1570 break;
1571 case Opt_rdma:
1572 vol->rdma = true;
1573 break;
1574
1575 /* Numeric Values */
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 /* String Arguments */
1695
1696 case Opt_blank_user:
1697 /* null user, ie. anonymous authentication */
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 /* passwords have to be handled differently
1719 * to allow the character used for deliminator
1720 * to be passed within them
1721 */
1722
1723 /*
1724 * Check if this is a case where the password
1725 * starts with a delimiter
1726 */
1727 tmp_end = strchr(data, '=');
1728 tmp_end++;
1729 if (!(tmp_end < end && tmp_end[1] == delim)) {
1730 /* No it is not. Set the password to NULL */
1731 kzfree(vol->password);
1732 vol->password = NULL;
1733 break;
1734 }
1735 /* Yes it is. Drop down to Opt_pass below.*/
1736 case Opt_pass:
1737 /* Obtain the value string */
1738 value = strchr(data, '=');
1739 value++;
1740
1741 /* Set tmp_end to end of the string */
1742 tmp_end = (char *) value + strlen(value);
1743
1744 /* Check if following character is the deliminator
1745 * If yes, we have encountered a double deliminator
1746 * reset the NULL character to the deliminator
1747 */
1748 if (tmp_end < end && tmp_end[1] == delim) {
1749 tmp_end[0] = delim;
1750
1751 /* Keep iterating until we get to a single
1752 * deliminator OR the end
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 /* Reset var options to point to next element */
1760 if (tmp_end) {
1761 tmp_end[0] = '\0';
1762 options = (char *) &tmp_end[1];
1763 } else
1764 /* Reached the end of the mount option
1765 * string */
1766 options = end;
1767 }
1768
1769 kzfree(vol->password);
1770 /* Now build new password string */
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 /* skip the second deliminator */
1783 i++;
1784 }
1785 vol->password[j] = '\0';
1786 break;
1787 case Opt_blank_ip:
1788 /* FIXME: should this be an error instead? */
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 /* if iocharset not set then load_nls_default
1855 * is used by caller
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 * FIXME: are there cases in which a comma can
1868 * be valid in workstation netbios name (and
1869 * need special handling)?
1870 */
1871 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1872 /* don't ucase netbiosname for user */
1873 if (string[i] == 0)
1874 break;
1875 vol->source_rfc1001_name[i] = string[i];
1876 }
1877 /* The string has 16th byte zero still from
1878 * set at top of the function
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 /* servernetbiosname specified override *SMBSERVER */
1885 string = match_strdup(args);
1886 if (string == NULL)
1887 goto out_nomem;
1888
1889 /* last byte, type, is 0x20 for servr type */
1890 memset(vol->target_rfc1001_name, 0x20,
1891 RFC1001_NAME_LEN_WITH_NULL);
1892
1893 /* BB are there cases in which a comma can be
1894 valid in this workstation netbios name
1895 (and need special handling)? */
1896
1897 /* user or mount helper must uppercase the
1898 netbios name */
1899 for (i = 0; i < 15; i++) {
1900 if (string[i] == 0)
1901 break;
1902 vol->target_rfc1001_name[i] = string[i];
1903 }
1904 /* The string has 16th byte zero still from
1905 set at top of the function */
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 /* version of mount userspace tools, not dialect */
1911 string = match_strdup(args);
1912 if (string == NULL)
1913 goto out_nomem;
1914
1915 /* If interface changes in mount.cifs bump to new ver */
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 /* This is the default */
1925 break;
1926 }
1927 /* For all other value, error */
1928 pr_warn("CIFS: Invalid mount helper version specified\n");
1929 goto cifs_parse_mount_err;
1930 case Opt_vers:
1931 /* protocol version (dialect) */
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 * An option we don't recognize. Save it off for later
1959 * if we haven't already found one
1960 */
1961 if (!invalid)
1962 invalid = data;
1963 break;
1964 }
1965 /* Free up any allocated string */
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 #ifdef CONFIG_CIFS_SMB_DIRECT
1981 if (vol->rdma && vol->sign) {
1982 cifs_dbg(VFS, "Currently SMB direct doesn't support signing."
1983 " This is being fixed\n");
1984 goto cifs_parse_mount_err;
1985 }
1986 #endif
1987
1988 #ifndef CONFIG_KEYS
1989 /* Muliuser mounts require CONFIG_KEYS support */
1990 if (vol->multiuser) {
1991 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
1992 goto cifs_parse_mount_err;
1993 }
1994 #endif
1995 if (!vol->UNC) {
1996 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
1997 goto cifs_parse_mount_err;
1998 }
1999
2000 /* make sure UNC has a share name */
2001 if (!strchr(vol->UNC + 3, '\\')) {
2002 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
2003 goto cifs_parse_mount_err;
2004 }
2005
2006 if (!got_ip) {
2007 int len;
2008 const char *slash;
2009
2010 /* No ip= option specified? Try to get it from UNC */
2011 /* Use the address part of the UNC. */
2012 slash = strchr(&vol->UNC[2], '\\');
2013 len = slash - &vol->UNC[2];
2014 if (!cifs_convert_address(dstaddr, &vol->UNC[2], len)) {
2015 pr_err("Unable to determine destination address.\n");
2016 goto cifs_parse_mount_err;
2017 }
2018 }
2019
2020 /* set the port that we got earlier */
2021 cifs_set_port(dstaddr, port);
2022
2023 if (uid_specified)
2024 vol->override_uid = override_uid;
2025 else if (override_uid == 1)
2026 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
2027
2028 if (gid_specified)
2029 vol->override_gid = override_gid;
2030 else if (override_gid == 1)
2031 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
2032
2033 if (got_version == false)
2034 pr_warn("No dialect specified on mount. Default has changed to "
2035 "a more secure dialect, SMB2.1 or later (e.g. SMB3), from CIFS "
2036 "(SMB1). To use the less secure SMB1 dialect to access "
2037 "old servers which do not support SMB3 (or SMB2.1) specify vers=1.0"
2038 " on mount.\n");
2039
2040 kfree(mountdata_copy);
2041 return 0;
2042
2043 out_nomem:
2044 pr_warn("Could not allocate temporary buffer\n");
2045 cifs_parse_mount_err:
2046 kfree(string);
2047 kfree(mountdata_copy);
2048 return 1;
2049 }
2050
2051 /** Returns true if srcaddr isn't specified and rhs isn't
2052 * specified, or if srcaddr is specified and
2053 * matches the IP address of the rhs argument.
2054 */
2055 static bool
2056 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
2057 {
2058 switch (srcaddr->sa_family) {
2059 case AF_UNSPEC:
2060 return (rhs->sa_family == AF_UNSPEC);
2061 case AF_INET: {
2062 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
2063 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
2064 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
2065 }
2066 case AF_INET6: {
2067 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
2068 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
2069 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
2070 }
2071 default:
2072 WARN_ON(1);
2073 return false; /* don't expect to be here */
2074 }
2075 }
2076
2077 /*
2078 * If no port is specified in addr structure, we try to match with 445 port
2079 * and if it fails - with 139 ports. It should be called only if address
2080 * families of server and addr are equal.
2081 */
2082 static bool
2083 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
2084 {
2085 __be16 port, *sport;
2086
2087 switch (addr->sa_family) {
2088 case AF_INET:
2089 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
2090 port = ((struct sockaddr_in *) addr)->sin_port;
2091 break;
2092 case AF_INET6:
2093 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
2094 port = ((struct sockaddr_in6 *) addr)->sin6_port;
2095 break;
2096 default:
2097 WARN_ON(1);
2098 return false;
2099 }
2100
2101 if (!port) {
2102 port = htons(CIFS_PORT);
2103 if (port == *sport)
2104 return true;
2105
2106 port = htons(RFC1001_PORT);
2107 }
2108
2109 return port == *sport;
2110 }
2111
2112 static bool
2113 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
2114 struct sockaddr *srcaddr)
2115 {
2116 switch (addr->sa_family) {
2117 case AF_INET: {
2118 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2119 struct sockaddr_in *srv_addr4 =
2120 (struct sockaddr_in *)&server->dstaddr;
2121
2122 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
2123 return false;
2124 break;
2125 }
2126 case AF_INET6: {
2127 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2128 struct sockaddr_in6 *srv_addr6 =
2129 (struct sockaddr_in6 *)&server->dstaddr;
2130
2131 if (!ipv6_addr_equal(&addr6->sin6_addr,
2132 &srv_addr6->sin6_addr))
2133 return false;
2134 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
2135 return false;
2136 break;
2137 }
2138 default:
2139 WARN_ON(1);
2140 return false; /* don't expect to be here */
2141 }
2142
2143 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2144 return false;
2145
2146 return true;
2147 }
2148
2149 static bool
2150 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2151 {
2152 /*
2153 * The select_sectype function should either return the vol->sectype
2154 * that was specified, or "Unspecified" if that sectype was not
2155 * compatible with the given NEGOTIATE request.
2156 */
2157 if (server->ops->select_sectype(server, vol->sectype)
2158 == Unspecified)
2159 return false;
2160
2161 /*
2162 * Now check if signing mode is acceptable. No need to check
2163 * global_secflags at this point since if MUST_SIGN is set then
2164 * the server->sign had better be too.
2165 */
2166 if (vol->sign && !server->sign)
2167 return false;
2168
2169 return true;
2170 }
2171
2172 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2173 {
2174 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2175
2176 if (vol->nosharesock)
2177 return 0;
2178
2179 /* BB update this for smb3any and default case */
2180 if ((server->vals != vol->vals) || (server->ops != vol->ops))
2181 return 0;
2182
2183 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2184 return 0;
2185
2186 if (!match_address(server, addr,
2187 (struct sockaddr *)&vol->srcaddr))
2188 return 0;
2189
2190 if (!match_port(server, addr))
2191 return 0;
2192
2193 if (!match_security(server, vol))
2194 return 0;
2195
2196 if (server->echo_interval != vol->echo_interval * HZ)
2197 return 0;
2198
2199 if (server->rdma != vol->rdma)
2200 return 0;
2201
2202 return 1;
2203 }
2204
2205 static struct TCP_Server_Info *
2206 cifs_find_tcp_session(struct smb_vol *vol)
2207 {
2208 struct TCP_Server_Info *server;
2209
2210 spin_lock(&cifs_tcp_ses_lock);
2211 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2212 if (!match_server(server, vol))
2213 continue;
2214
2215 ++server->srv_count;
2216 spin_unlock(&cifs_tcp_ses_lock);
2217 cifs_dbg(FYI, "Existing tcp session with server found\n");
2218 return server;
2219 }
2220 spin_unlock(&cifs_tcp_ses_lock);
2221 return NULL;
2222 }
2223
2224 void
2225 cifs_put_tcp_session(struct TCP_Server_Info *server, int from_reconnect)
2226 {
2227 struct task_struct *task;
2228
2229 spin_lock(&cifs_tcp_ses_lock);
2230 if (--server->srv_count > 0) {
2231 spin_unlock(&cifs_tcp_ses_lock);
2232 return;
2233 }
2234
2235 put_net(cifs_net_ns(server));
2236
2237 list_del_init(&server->tcp_ses_list);
2238 spin_unlock(&cifs_tcp_ses_lock);
2239
2240 cancel_delayed_work_sync(&server->echo);
2241
2242 if (from_reconnect)
2243 /*
2244 * Avoid deadlock here: reconnect work calls
2245 * cifs_put_tcp_session() at its end. Need to be sure
2246 * that reconnect work does nothing with server pointer after
2247 * that step.
2248 */
2249 cancel_delayed_work(&server->reconnect);
2250 else
2251 cancel_delayed_work_sync(&server->reconnect);
2252
2253 spin_lock(&GlobalMid_Lock);
2254 server->tcpStatus = CifsExiting;
2255 spin_unlock(&GlobalMid_Lock);
2256
2257 cifs_crypto_secmech_release(server);
2258 cifs_fscache_release_client_cookie(server);
2259
2260 kfree(server->session_key.response);
2261 server->session_key.response = NULL;
2262 server->session_key.len = 0;
2263
2264 task = xchg(&server->tsk, NULL);
2265 if (task)
2266 force_sig(SIGKILL, task);
2267 }
2268
2269 static struct TCP_Server_Info *
2270 cifs_get_tcp_session(struct smb_vol *volume_info)
2271 {
2272 struct TCP_Server_Info *tcp_ses = NULL;
2273 int rc;
2274
2275 cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
2276
2277 /* see if we already have a matching tcp_ses */
2278 tcp_ses = cifs_find_tcp_session(volume_info);
2279 if (tcp_ses)
2280 return tcp_ses;
2281
2282 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2283 if (!tcp_ses) {
2284 rc = -ENOMEM;
2285 goto out_err;
2286 }
2287
2288 tcp_ses->ops = volume_info->ops;
2289 tcp_ses->vals = volume_info->vals;
2290 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2291 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2292 if (IS_ERR(tcp_ses->hostname)) {
2293 rc = PTR_ERR(tcp_ses->hostname);
2294 goto out_err_crypto_release;
2295 }
2296
2297 tcp_ses->noblocksnd = volume_info->noblocksnd;
2298 tcp_ses->noautotune = volume_info->noautotune;
2299 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2300 tcp_ses->rdma = volume_info->rdma;
2301 tcp_ses->in_flight = 0;
2302 tcp_ses->credits = 1;
2303 init_waitqueue_head(&tcp_ses->response_q);
2304 init_waitqueue_head(&tcp_ses->request_q);
2305 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2306 mutex_init(&tcp_ses->srv_mutex);
2307 memcpy(tcp_ses->workstation_RFC1001_name,
2308 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2309 memcpy(tcp_ses->server_RFC1001_name,
2310 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2311 tcp_ses->session_estab = false;
2312 tcp_ses->sequence_number = 0;
2313 tcp_ses->lstrp = jiffies;
2314 spin_lock_init(&tcp_ses->req_lock);
2315 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2316 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2317 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2318 INIT_DELAYED_WORK(&tcp_ses->reconnect, smb2_reconnect_server);
2319 mutex_init(&tcp_ses->reconnect_mutex);
2320 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2321 sizeof(tcp_ses->srcaddr));
2322 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2323 sizeof(tcp_ses->dstaddr));
2324 generate_random_uuid(tcp_ses->client_guid);
2325 /*
2326 * at this point we are the only ones with the pointer
2327 * to the struct since the kernel thread not created yet
2328 * no need to spinlock this init of tcpStatus or srv_count
2329 */
2330 tcp_ses->tcpStatus = CifsNew;
2331 ++tcp_ses->srv_count;
2332
2333 if (volume_info->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
2334 volume_info->echo_interval <= SMB_ECHO_INTERVAL_MAX)
2335 tcp_ses->echo_interval = volume_info->echo_interval * HZ;
2336 else
2337 tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
2338 if (tcp_ses->rdma) {
2339 #ifndef CONFIG_CIFS_SMB_DIRECT
2340 cifs_dbg(VFS, "CONFIG_CIFS_SMB_DIRECT is not enabled\n");
2341 rc = -ENOENT;
2342 goto out_err_crypto_release;
2343 #endif
2344 tcp_ses->smbd_conn = smbd_get_connection(
2345 tcp_ses, (struct sockaddr *)&volume_info->dstaddr);
2346 if (tcp_ses->smbd_conn) {
2347 cifs_dbg(VFS, "RDMA transport established\n");
2348 rc = 0;
2349 goto smbd_connected;
2350 } else {
2351 rc = -ENOENT;
2352 goto out_err_crypto_release;
2353 }
2354 }
2355 rc = ip_connect(tcp_ses);
2356 if (rc < 0) {
2357 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
2358 goto out_err_crypto_release;
2359 }
2360 smbd_connected:
2361 /*
2362 * since we're in a cifs function already, we know that
2363 * this will succeed. No need for try_module_get().
2364 */
2365 __module_get(THIS_MODULE);
2366 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2367 tcp_ses, "cifsd");
2368 if (IS_ERR(tcp_ses->tsk)) {
2369 rc = PTR_ERR(tcp_ses->tsk);
2370 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
2371 module_put(THIS_MODULE);
2372 goto out_err_crypto_release;
2373 }
2374 tcp_ses->tcpStatus = CifsNeedNegotiate;
2375
2376 /* thread spawned, put it on the list */
2377 spin_lock(&cifs_tcp_ses_lock);
2378 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2379 spin_unlock(&cifs_tcp_ses_lock);
2380
2381 cifs_fscache_get_client_cookie(tcp_ses);
2382
2383 /* queue echo request delayed work */
2384 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
2385
2386 return tcp_ses;
2387
2388 out_err_crypto_release:
2389 cifs_crypto_secmech_release(tcp_ses);
2390
2391 put_net(cifs_net_ns(tcp_ses));
2392
2393 out_err:
2394 if (tcp_ses) {
2395 if (!IS_ERR(tcp_ses->hostname))
2396 kfree(tcp_ses->hostname);
2397 if (tcp_ses->ssocket)
2398 sock_release(tcp_ses->ssocket);
2399 kfree(tcp_ses);
2400 }
2401 return ERR_PTR(rc);
2402 }
2403
2404 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2405 {
2406 if (vol->sectype != Unspecified &&
2407 vol->sectype != ses->sectype)
2408 return 0;
2409
2410 switch (ses->sectype) {
2411 case Kerberos:
2412 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2413 return 0;
2414 break;
2415 default:
2416 /* NULL username means anonymous session */
2417 if (ses->user_name == NULL) {
2418 if (!vol->nullauth)
2419 return 0;
2420 break;
2421 }
2422
2423 /* anything else takes username/password */
2424 if (strncmp(ses->user_name,
2425 vol->username ? vol->username : "",
2426 CIFS_MAX_USERNAME_LEN))
2427 return 0;
2428 if ((vol->username && strlen(vol->username) != 0) &&
2429 ses->password != NULL &&
2430 strncmp(ses->password,
2431 vol->password ? vol->password : "",
2432 CIFS_MAX_PASSWORD_LEN))
2433 return 0;
2434 }
2435 return 1;
2436 }
2437
2438 /**
2439 * cifs_setup_ipc - helper to setup the IPC tcon for the session
2440 *
2441 * A new IPC connection is made and stored in the session
2442 * tcon_ipc. The IPC tcon has the same lifetime as the session.
2443 */
2444 static int
2445 cifs_setup_ipc(struct cifs_ses *ses, struct smb_vol *volume_info)
2446 {
2447 int rc = 0, xid;
2448 struct cifs_tcon *tcon;
2449 struct nls_table *nls_codepage;
2450 char unc[SERVER_NAME_LENGTH + sizeof("//x/IPC$")] = {0};
2451 bool seal = false;
2452
2453 /*
2454 * If the mount request that resulted in the creation of the
2455 * session requires encryption, force IPC to be encrypted too.
2456 */
2457 if (volume_info->seal) {
2458 if (ses->server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION)
2459 seal = true;
2460 else {
2461 cifs_dbg(VFS,
2462 "IPC: server doesn't support encryption\n");
2463 return -EOPNOTSUPP;
2464 }
2465 }
2466
2467 tcon = tconInfoAlloc();
2468 if (tcon == NULL)
2469 return -ENOMEM;
2470
2471 snprintf(unc, sizeof(unc), "\\\\%s\\IPC$", ses->serverName);
2472
2473 /* cannot fail */
2474 nls_codepage = load_nls_default();
2475
2476 xid = get_xid();
2477 tcon->ses = ses;
2478 tcon->ipc = true;
2479 tcon->seal = seal;
2480 rc = ses->server->ops->tree_connect(xid, ses, unc, tcon, nls_codepage);
2481 free_xid(xid);
2482
2483 if (rc) {
2484 cifs_dbg(VFS, "failed to connect to IPC (rc=%d)\n", rc);
2485 tconInfoFree(tcon);
2486 goto out;
2487 }
2488
2489 cifs_dbg(FYI, "IPC tcon rc = %d ipc tid = %d\n", rc, tcon->tid);
2490
2491 ses->tcon_ipc = tcon;
2492 out:
2493 unload_nls(nls_codepage);
2494 return rc;
2495 }
2496
2497 /**
2498 * cifs_free_ipc - helper to release the session IPC tcon
2499 *
2500 * Needs to be called everytime a session is destroyed
2501 */
2502 static int
2503 cifs_free_ipc(struct cifs_ses *ses)
2504 {
2505 int rc = 0, xid;
2506 struct cifs_tcon *tcon = ses->tcon_ipc;
2507
2508 if (tcon == NULL)
2509 return 0;
2510
2511 if (ses->server->ops->tree_disconnect) {
2512 xid = get_xid();
2513 rc = ses->server->ops->tree_disconnect(xid, tcon);
2514 free_xid(xid);
2515 }
2516
2517 if (rc)
2518 cifs_dbg(FYI, "failed to disconnect IPC tcon (rc=%d)\n", rc);
2519
2520 tconInfoFree(tcon);
2521 ses->tcon_ipc = NULL;
2522 return rc;
2523 }
2524
2525 static struct cifs_ses *
2526 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2527 {
2528 struct cifs_ses *ses;
2529
2530 spin_lock(&cifs_tcp_ses_lock);
2531 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2532 if (ses->status == CifsExiting)
2533 continue;
2534 if (!match_session(ses, vol))
2535 continue;
2536 ++ses->ses_count;
2537 spin_unlock(&cifs_tcp_ses_lock);
2538 return ses;
2539 }
2540 spin_unlock(&cifs_tcp_ses_lock);
2541 return NULL;
2542 }
2543
2544 static void
2545 cifs_put_smb_ses(struct cifs_ses *ses)
2546 {
2547 unsigned int rc, xid;
2548 struct TCP_Server_Info *server = ses->server;
2549
2550 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
2551
2552 spin_lock(&cifs_tcp_ses_lock);
2553 if (ses->status == CifsExiting) {
2554 spin_unlock(&cifs_tcp_ses_lock);
2555 return;
2556 }
2557 if (--ses->ses_count > 0) {
2558 spin_unlock(&cifs_tcp_ses_lock);
2559 return;
2560 }
2561 if (ses->status == CifsGood)
2562 ses->status = CifsExiting;
2563 spin_unlock(&cifs_tcp_ses_lock);
2564
2565 cifs_free_ipc(ses);
2566
2567 if (ses->status == CifsExiting && server->ops->logoff) {
2568 xid = get_xid();
2569 rc = server->ops->logoff(xid, ses);
2570 if (rc)
2571 cifs_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
2572 __func__, rc);
2573 _free_xid(xid);
2574 }
2575
2576 spin_lock(&cifs_tcp_ses_lock);
2577 list_del_init(&ses->smb_ses_list);
2578 spin_unlock(&cifs_tcp_ses_lock);
2579
2580 sesInfoFree(ses);
2581 cifs_put_tcp_session(server, 0);
2582 }
2583
2584 #ifdef CONFIG_KEYS
2585
2586 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2587 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2588
2589 /* Populate username and pw fields from keyring if possible */
2590 static int
2591 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2592 {
2593 int rc = 0;
2594 const char *delim, *payload;
2595 char *desc;
2596 ssize_t len;
2597 struct key *key;
2598 struct TCP_Server_Info *server = ses->server;
2599 struct sockaddr_in *sa;
2600 struct sockaddr_in6 *sa6;
2601 const struct user_key_payload *upayload;
2602
2603 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2604 if (!desc)
2605 return -ENOMEM;
2606
2607 /* try to find an address key first */
2608 switch (server->dstaddr.ss_family) {
2609 case AF_INET:
2610 sa = (struct sockaddr_in *)&server->dstaddr;
2611 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2612 break;
2613 case AF_INET6:
2614 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2615 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2616 break;
2617 default:
2618 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2619 server->dstaddr.ss_family);
2620 rc = -EINVAL;
2621 goto out_err;
2622 }
2623
2624 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2625 key = request_key(&key_type_logon, desc, "");
2626 if (IS_ERR(key)) {
2627 if (!ses->domainName) {
2628 cifs_dbg(FYI, "domainName is NULL\n");
2629 rc = PTR_ERR(key);
2630 goto out_err;
2631 }
2632
2633 /* didn't work, try to find a domain key */
2634 sprintf(desc, "cifs:d:%s", ses->domainName);
2635 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2636 key = request_key(&key_type_logon, desc, "");
2637 if (IS_ERR(key)) {
2638 rc = PTR_ERR(key);
2639 goto out_err;
2640 }
2641 }
2642
2643 down_read(&key->sem);
2644 upayload = user_key_payload_locked(key);
2645 if (IS_ERR_OR_NULL(upayload)) {
2646 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2647 goto out_key_put;
2648 }
2649
2650 /* find first : in payload */
2651 payload = upayload->data;
2652 delim = strnchr(payload, upayload->datalen, ':');
2653 cifs_dbg(FYI, "payload=%s\n", payload);
2654 if (!delim) {
2655 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
2656 upayload->datalen);
2657 rc = -EINVAL;
2658 goto out_key_put;
2659 }
2660
2661 len = delim - payload;
2662 if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
2663 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
2664 len);
2665 rc = -EINVAL;
2666 goto out_key_put;
2667 }
2668
2669 vol->username = kstrndup(payload, len, GFP_KERNEL);
2670 if (!vol->username) {
2671 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
2672 len);
2673 rc = -ENOMEM;
2674 goto out_key_put;
2675 }
2676 cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
2677
2678 len = key->datalen - (len + 1);
2679 if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
2680 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
2681 rc = -EINVAL;
2682 kfree(vol->username);
2683 vol->username = NULL;
2684 goto out_key_put;
2685 }
2686
2687 ++delim;
2688 vol->password = kstrndup(delim, len, GFP_KERNEL);
2689 if (!vol->password) {
2690 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
2691 len);
2692 rc = -ENOMEM;
2693 kfree(vol->username);
2694 vol->username = NULL;
2695 goto out_key_put;
2696 }
2697
2698 out_key_put:
2699 up_read(&key->sem);
2700 key_put(key);
2701 out_err:
2702 kfree(desc);
2703 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
2704 return rc;
2705 }
2706 #else /* ! CONFIG_KEYS */
2707 static inline int
2708 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2709 struct cifs_ses *ses __attribute__((unused)))
2710 {
2711 return -ENOSYS;
2712 }
2713 #endif /* CONFIG_KEYS */
2714
2715 /**
2716 * cifs_get_smb_ses - get a session matching @volume_info data from @server
2717 *
2718 * This function assumes it is being called from cifs_mount() where we
2719 * already got a server reference (server refcount +1). See
2720 * cifs_get_tcon() for refcount explanations.
2721 */
2722 static struct cifs_ses *
2723 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2724 {
2725 int rc = -ENOMEM;
2726 unsigned int xid;
2727 struct cifs_ses *ses;
2728 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2729 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2730
2731 xid = get_xid();
2732
2733 ses = cifs_find_smb_ses(server, volume_info);
2734 if (ses) {
2735 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
2736 ses->status);
2737
2738 mutex_lock(&ses->session_mutex);
2739 rc = cifs_negotiate_protocol(xid, ses);
2740 if (rc) {
2741 mutex_unlock(&ses->session_mutex);
2742 /* problem -- put our ses reference */
2743 cifs_put_smb_ses(ses);
2744 free_xid(xid);
2745 return ERR_PTR(rc);
2746 }
2747 if (ses->need_reconnect) {
2748 cifs_dbg(FYI, "Session needs reconnect\n");
2749 rc = cifs_setup_session(xid, ses,
2750 volume_info->local_nls);
2751 if (rc) {
2752 mutex_unlock(&ses->session_mutex);
2753 /* problem -- put our reference */
2754 cifs_put_smb_ses(ses);
2755 free_xid(xid);
2756 return ERR_PTR(rc);
2757 }
2758 }
2759 mutex_unlock(&ses->session_mutex);
2760
2761 /* existing SMB ses has a server reference already */
2762 cifs_put_tcp_session(server, 0);
2763 free_xid(xid);
2764 return ses;
2765 }
2766
2767 cifs_dbg(FYI, "Existing smb sess not found\n");
2768 ses = sesInfoAlloc();
2769 if (ses == NULL)
2770 goto get_ses_fail;
2771
2772 /* new SMB session uses our server ref */
2773 ses->server = server;
2774 if (server->dstaddr.ss_family == AF_INET6)
2775 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2776 else
2777 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2778
2779 if (volume_info->username) {
2780 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2781 if (!ses->user_name)
2782 goto get_ses_fail;
2783 }
2784
2785 /* volume_info->password freed at unmount */
2786 if (volume_info->password) {
2787 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2788 if (!ses->password)
2789 goto get_ses_fail;
2790 }
2791 if (volume_info->domainname) {
2792 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2793 if (!ses->domainName)
2794 goto get_ses_fail;
2795 }
2796 if (volume_info->domainauto)
2797 ses->domainAuto = volume_info->domainauto;
2798 ses->cred_uid = volume_info->cred_uid;
2799 ses->linux_uid = volume_info->linux_uid;
2800
2801 ses->sectype = volume_info->sectype;
2802 ses->sign = volume_info->sign;
2803
2804 mutex_lock(&ses->session_mutex);
2805 rc = cifs_negotiate_protocol(xid, ses);
2806 if (!rc)
2807 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2808 mutex_unlock(&ses->session_mutex);
2809 if (rc)
2810 goto get_ses_fail;
2811
2812 /* success, put it on the list */
2813 spin_lock(&cifs_tcp_ses_lock);
2814 list_add(&ses->smb_ses_list, &server->smb_ses_list);
2815 spin_unlock(&cifs_tcp_ses_lock);
2816
2817 free_xid(xid);
2818
2819 cifs_setup_ipc(ses, volume_info);
2820
2821 return ses;
2822
2823 get_ses_fail:
2824 sesInfoFree(ses);
2825 free_xid(xid);
2826 return ERR_PTR(rc);
2827 }
2828
2829 static int match_tcon(struct cifs_tcon *tcon, struct smb_vol *volume_info)
2830 {
2831 if (tcon->tidStatus == CifsExiting)
2832 return 0;
2833 if (strncmp(tcon->treeName, volume_info->UNC, MAX_TREE_SIZE))
2834 return 0;
2835 if (tcon->seal != volume_info->seal)
2836 return 0;
2837 if (tcon->snapshot_time != volume_info->snapshot_time)
2838 return 0;
2839 return 1;
2840 }
2841
2842 static struct cifs_tcon *
2843 cifs_find_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2844 {
2845 struct list_head *tmp;
2846 struct cifs_tcon *tcon;
2847
2848 spin_lock(&cifs_tcp_ses_lock);
2849 list_for_each(tmp, &ses->tcon_list) {
2850 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2851 if (!match_tcon(tcon, volume_info))
2852 continue;
2853 ++tcon->tc_count;
2854 spin_unlock(&cifs_tcp_ses_lock);
2855 return tcon;
2856 }
2857 spin_unlock(&cifs_tcp_ses_lock);
2858 return NULL;
2859 }
2860
2861 void
2862 cifs_put_tcon(struct cifs_tcon *tcon)
2863 {
2864 unsigned int xid;
2865 struct cifs_ses *ses;
2866
2867 /*
2868 * IPC tcon share the lifetime of their session and are
2869 * destroyed in the session put function
2870 */
2871 if (tcon == NULL || tcon->ipc)
2872 return;
2873
2874 ses = tcon->ses;
2875 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2876 spin_lock(&cifs_tcp_ses_lock);
2877 if (--tcon->tc_count > 0) {
2878 spin_unlock(&cifs_tcp_ses_lock);
2879 return;
2880 }
2881
2882 list_del_init(&tcon->tcon_list);
2883 spin_unlock(&cifs_tcp_ses_lock);
2884
2885 xid = get_xid();
2886 if (ses->server->ops->tree_disconnect)
2887 ses->server->ops->tree_disconnect(xid, tcon);
2888 _free_xid(xid);
2889
2890 cifs_fscache_release_super_cookie(tcon);
2891 tconInfoFree(tcon);
2892 cifs_put_smb_ses(ses);
2893 }
2894
2895 /**
2896 * cifs_get_tcon - get a tcon matching @volume_info data from @ses
2897 *
2898 * - tcon refcount is the number of mount points using the tcon.
2899 * - ses refcount is the number of tcon using the session.
2900 *
2901 * 1. This function assumes it is being called from cifs_mount() where
2902 * we already got a session reference (ses refcount +1).
2903 *
2904 * 2. Since we're in the context of adding a mount point, the end
2905 * result should be either:
2906 *
2907 * a) a new tcon already allocated with refcount=1 (1 mount point) and
2908 * its session refcount incremented (1 new tcon). This +1 was
2909 * already done in (1).
2910 *
2911 * b) an existing tcon with refcount+1 (add a mount point to it) and
2912 * identical ses refcount (no new tcon). Because of (1) we need to
2913 * decrement the ses refcount.
2914 */
2915 static struct cifs_tcon *
2916 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2917 {
2918 int rc, xid;
2919 struct cifs_tcon *tcon;
2920
2921 tcon = cifs_find_tcon(ses, volume_info);
2922 if (tcon) {
2923 /*
2924 * tcon has refcount already incremented but we need to
2925 * decrement extra ses reference gotten by caller (case b)
2926 */
2927 cifs_dbg(FYI, "Found match on UNC path\n");
2928 cifs_put_smb_ses(ses);
2929 return tcon;
2930 }
2931
2932 if (!ses->server->ops->tree_connect) {
2933 rc = -ENOSYS;
2934 goto out_fail;
2935 }
2936
2937 tcon = tconInfoAlloc();
2938 if (tcon == NULL) {
2939 rc = -ENOMEM;
2940 goto out_fail;
2941 }
2942
2943 if (volume_info->snapshot_time) {
2944 if (ses->server->vals->protocol_id == 0) {
2945 cifs_dbg(VFS,
2946 "Use SMB2 or later for snapshot mount option\n");
2947 rc = -EOPNOTSUPP;
2948 goto out_fail;
2949 } else
2950 tcon->snapshot_time = volume_info->snapshot_time;
2951 }
2952
2953 tcon->ses = ses;
2954 if (volume_info->password) {
2955 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2956 if (!tcon->password) {
2957 rc = -ENOMEM;
2958 goto out_fail;
2959 }
2960 }
2961
2962 /*
2963 * BB Do we need to wrap session_mutex around this TCon call and Unix
2964 * SetFS as we do on SessSetup and reconnect?
2965 */
2966 xid = get_xid();
2967 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2968 volume_info->local_nls);
2969 free_xid(xid);
2970 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
2971 if (rc)
2972 goto out_fail;
2973
2974 if (volume_info->nodfs) {
2975 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2976 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
2977 }
2978 tcon->use_persistent = false;
2979 /* check if SMB2 or later, CIFS does not support persistent handles */
2980 if (volume_info->persistent) {
2981 if (ses->server->vals->protocol_id == 0) {
2982 cifs_dbg(VFS,
2983 "SMB3 or later required for persistent handles\n");
2984 rc = -EOPNOTSUPP;
2985 goto out_fail;
2986 } else if (ses->server->capabilities &
2987 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2988 tcon->use_persistent = true;
2989 else /* persistent handles requested but not supported */ {
2990 cifs_dbg(VFS,
2991 "Persistent handles not supported on share\n");
2992 rc = -EOPNOTSUPP;
2993 goto out_fail;
2994 }
2995 } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
2996 && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2997 && (volume_info->nopersistent == false)) {
2998 cifs_dbg(FYI, "enabling persistent handles\n");
2999 tcon->use_persistent = true;
3000 } else if (volume_info->resilient) {
3001 if (ses->server->vals->protocol_id == 0) {
3002 cifs_dbg(VFS,
3003 "SMB2.1 or later required for resilient handles\n");
3004 rc = -EOPNOTSUPP;
3005 goto out_fail;
3006 }
3007 tcon->use_resilient = true;
3008 }
3009
3010 if (volume_info->seal) {
3011 if (ses->server->vals->protocol_id == 0) {
3012 cifs_dbg(VFS,
3013 "SMB3 or later required for encryption\n");
3014 rc = -EOPNOTSUPP;
3015 goto out_fail;
3016 } else if (tcon->ses->server->capabilities &
3017 SMB2_GLOBAL_CAP_ENCRYPTION)
3018 tcon->seal = true;
3019 else {
3020 cifs_dbg(VFS, "Encryption is not supported on share\n");
3021 rc = -EOPNOTSUPP;
3022 goto out_fail;
3023 }
3024 }
3025
3026 /*
3027 * We can have only one retry value for a connection to a share so for
3028 * resources mounted more than once to the same server share the last
3029 * value passed in for the retry flag is used.
3030 */
3031 tcon->retry = volume_info->retry;
3032 tcon->nocase = volume_info->nocase;
3033 tcon->local_lease = volume_info->local_lease;
3034 INIT_LIST_HEAD(&tcon->pending_opens);
3035
3036 spin_lock(&cifs_tcp_ses_lock);
3037 list_add(&tcon->tcon_list, &ses->tcon_list);
3038 spin_unlock(&cifs_tcp_ses_lock);
3039
3040 cifs_fscache_get_super_cookie(tcon);
3041
3042 return tcon;
3043
3044 out_fail:
3045 tconInfoFree(tcon);
3046 return ERR_PTR(rc);
3047 }
3048
3049 void
3050 cifs_put_tlink(struct tcon_link *tlink)
3051 {
3052 if (!tlink || IS_ERR(tlink))
3053 return;
3054
3055 if (!atomic_dec_and_test(&tlink->tl_count) ||
3056 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
3057 tlink->tl_time = jiffies;
3058 return;
3059 }
3060
3061 if (!IS_ERR(tlink_tcon(tlink)))
3062 cifs_put_tcon(tlink_tcon(tlink));
3063 kfree(tlink);
3064 return;
3065 }
3066
3067 static inline struct tcon_link *
3068 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
3069 {
3070 return cifs_sb->master_tlink;
3071 }
3072
3073 static int
3074 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
3075 {
3076 struct cifs_sb_info *old = CIFS_SB(sb);
3077 struct cifs_sb_info *new = mnt_data->cifs_sb;
3078
3079 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
3080 return 0;
3081
3082 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
3083 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
3084 return 0;
3085
3086 /*
3087 * We want to share sb only if we don't specify an r/wsize or
3088 * specified r/wsize is greater than or equal to existing one.
3089 */
3090 if (new->wsize && new->wsize < old->wsize)
3091 return 0;
3092
3093 if (new->rsize && new->rsize < old->rsize)
3094 return 0;
3095
3096 if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
3097 return 0;
3098
3099 if (old->mnt_file_mode != new->mnt_file_mode ||
3100 old->mnt_dir_mode != new->mnt_dir_mode)
3101 return 0;
3102
3103 if (strcmp(old->local_nls->charset, new->local_nls->charset))
3104 return 0;
3105
3106 if (old->actimeo != new->actimeo)
3107 return 0;
3108
3109 return 1;
3110 }
3111
3112 static int
3113 match_prepath(struct super_block *sb, struct cifs_mnt_data *mnt_data)
3114 {
3115 struct cifs_sb_info *old = CIFS_SB(sb);
3116 struct cifs_sb_info *new = mnt_data->cifs_sb;
3117 bool old_set = old->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH;
3118 bool new_set = new->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH;
3119
3120 if (old_set && new_set && !strcmp(new->prepath, old->prepath))
3121 return 1;
3122 else if (!old_set && !new_set)
3123 return 1;
3124
3125 return 0;
3126 }
3127
3128 int
3129 cifs_match_super(struct super_block *sb, void *data)
3130 {
3131 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
3132 struct smb_vol *volume_info;
3133 struct cifs_sb_info *cifs_sb;
3134 struct TCP_Server_Info *tcp_srv;
3135 struct cifs_ses *ses;
3136 struct cifs_tcon *tcon;
3137 struct tcon_link *tlink;
3138 int rc = 0;
3139
3140 spin_lock(&cifs_tcp_ses_lock);
3141 cifs_sb = CIFS_SB(sb);
3142 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3143 if (IS_ERR(tlink)) {
3144 spin_unlock(&cifs_tcp_ses_lock);
3145 return rc;
3146 }
3147 tcon = tlink_tcon(tlink);
3148 ses = tcon->ses;
3149 tcp_srv = ses->server;
3150
3151 volume_info = mnt_data->vol;
3152
3153 if (!match_server(tcp_srv, volume_info) ||
3154 !match_session(ses, volume_info) ||
3155 !match_tcon(tcon, volume_info) ||
3156 !match_prepath(sb, mnt_data)) {
3157 rc = 0;
3158 goto out;
3159 }
3160
3161 rc = compare_mount_options(sb, mnt_data);
3162 out:
3163 spin_unlock(&cifs_tcp_ses_lock);
3164 cifs_put_tlink(tlink);
3165 return rc;
3166 }
3167
3168 int
3169 get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
3170 const struct nls_table *nls_codepage, unsigned int *num_referrals,
3171 struct dfs_info3_param **referrals, int remap)
3172 {
3173 int rc = 0;
3174
3175 if (!ses->server->ops->get_dfs_refer)
3176 return -ENOSYS;
3177
3178 *num_referrals = 0;
3179 *referrals = NULL;
3180
3181 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
3182 referrals, num_referrals,
3183 nls_codepage, remap);
3184 return rc;
3185 }
3186
3187 #ifdef CONFIG_DEBUG_LOCK_ALLOC
3188 static struct lock_class_key cifs_key[2];
3189 static struct lock_class_key cifs_slock_key[2];
3190
3191 static inline void
3192 cifs_reclassify_socket4(struct socket *sock)
3193 {
3194 struct sock *sk = sock->sk;
3195 BUG_ON(!sock_allow_reclassification(sk));
3196 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
3197 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
3198 }
3199
3200 static inline void
3201 cifs_reclassify_socket6(struct socket *sock)
3202 {
3203 struct sock *sk = sock->sk;
3204 BUG_ON(!sock_allow_reclassification(sk));
3205 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
3206 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
3207 }
3208 #else
3209 static inline void
3210 cifs_reclassify_socket4(struct socket *sock)
3211 {
3212 }
3213
3214 static inline void
3215 cifs_reclassify_socket6(struct socket *sock)
3216 {
3217 }
3218 #endif
3219
3220 /* See RFC1001 section 14 on representation of Netbios names */
3221 static void rfc1002mangle(char *target, char *source, unsigned int length)
3222 {
3223 unsigned int i, j;
3224
3225 for (i = 0, j = 0; i < (length); i++) {
3226 /* mask a nibble at a time and encode */
3227 target[j] = 'A' + (0x0F & (source[i] >> 4));
3228 target[j+1] = 'A' + (0x0F & source[i]);
3229 j += 2;
3230 }
3231
3232 }
3233
3234 static int
3235 bind_socket(struct TCP_Server_Info *server)
3236 {
3237 int rc = 0;
3238 if (server->srcaddr.ss_family != AF_UNSPEC) {
3239 /* Bind to the specified local IP address */
3240 struct socket *socket = server->ssocket;
3241 rc = socket->ops->bind(socket,
3242 (struct sockaddr *) &server->srcaddr,
3243 sizeof(server->srcaddr));
3244 if (rc < 0) {
3245 struct sockaddr_in *saddr4;
3246 struct sockaddr_in6 *saddr6;
3247 saddr4 = (struct sockaddr_in *)&server->srcaddr;
3248 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
3249 if (saddr6->sin6_family == AF_INET6)
3250 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
3251 &saddr6->sin6_addr, rc);
3252 else
3253 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
3254 &saddr4->sin_addr.s_addr, rc);
3255 }
3256 }
3257 return rc;
3258 }
3259
3260 static int
3261 ip_rfc1001_connect(struct TCP_Server_Info *server)
3262 {
3263 int rc = 0;
3264 /*
3265 * some servers require RFC1001 sessinit before sending
3266 * negprot - BB check reconnection in case where second
3267 * sessinit is sent but no second negprot
3268 */
3269 struct rfc1002_session_packet *ses_init_buf;
3270 struct smb_hdr *smb_buf;
3271 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
3272 GFP_KERNEL);
3273 if (ses_init_buf) {
3274 ses_init_buf->trailer.session_req.called_len = 32;
3275
3276 if (server->server_RFC1001_name[0] != 0)
3277 rfc1002mangle(ses_init_buf->trailer.
3278 session_req.called_name,
3279 server->server_RFC1001_name,
3280 RFC1001_NAME_LEN_WITH_NULL);
3281 else
3282 rfc1002mangle(ses_init_buf->trailer.
3283 session_req.called_name,
3284 DEFAULT_CIFS_CALLED_NAME,
3285 RFC1001_NAME_LEN_WITH_NULL);
3286
3287 ses_init_buf->trailer.session_req.calling_len = 32;
3288
3289 /*
3290 * calling name ends in null (byte 16) from old smb
3291 * convention.
3292 */
3293 if (server->workstation_RFC1001_name[0] != 0)
3294 rfc1002mangle(ses_init_buf->trailer.
3295 session_req.calling_name,
3296 server->workstation_RFC1001_name,
3297 RFC1001_NAME_LEN_WITH_NULL);
3298 else
3299 rfc1002mangle(ses_init_buf->trailer.
3300 session_req.calling_name,
3301 "LINUX_CIFS_CLNT",
3302 RFC1001_NAME_LEN_WITH_NULL);
3303
3304 ses_init_buf->trailer.session_req.scope1 = 0;
3305 ses_init_buf->trailer.session_req.scope2 = 0;
3306 smb_buf = (struct smb_hdr *)ses_init_buf;
3307
3308 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3309 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3310 rc = smb_send(server, smb_buf, 0x44);
3311 kfree(ses_init_buf);
3312 /*
3313 * RFC1001 layer in at least one server
3314 * requires very short break before negprot
3315 * presumably because not expecting negprot
3316 * to follow so fast. This is a simple
3317 * solution that works without
3318 * complicating the code and causes no
3319 * significant slowing down on mount
3320 * for everyone else
3321 */
3322 usleep_range(1000, 2000);
3323 }
3324 /*
3325 * else the negprot may still work without this
3326 * even though malloc failed
3327 */
3328
3329 return rc;
3330 }
3331
3332 static int
3333 generic_ip_connect(struct TCP_Server_Info *server)
3334 {
3335 int rc = 0;
3336 __be16 sport;
3337 int slen, sfamily;
3338 struct socket *socket = server->ssocket;
3339 struct sockaddr *saddr;
3340
3341 saddr = (struct sockaddr *) &server->dstaddr;
3342
3343 if (server->dstaddr.ss_family == AF_INET6) {
3344 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3345 slen = sizeof(struct sockaddr_in6);
3346 sfamily = AF_INET6;
3347 } else {
3348 sport = ((struct sockaddr_in *) saddr)->sin_port;
3349 slen = sizeof(struct sockaddr_in);
3350 sfamily = AF_INET;
3351 }
3352
3353 if (socket == NULL) {
3354 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3355 IPPROTO_TCP, &socket, 1);
3356 if (rc < 0) {
3357 cifs_dbg(VFS, "Error %d creating socket\n", rc);
3358 server->ssocket = NULL;
3359 return rc;
3360 }
3361
3362 /* BB other socket options to set KEEPALIVE, NODELAY? */
3363 cifs_dbg(FYI, "Socket created\n");
3364 server->ssocket = socket;
3365 socket->sk->sk_allocation = GFP_NOFS;
3366 if (sfamily == AF_INET6)
3367 cifs_reclassify_socket6(socket);
3368 else
3369 cifs_reclassify_socket4(socket);
3370 }
3371
3372 rc = bind_socket(server);
3373 if (rc < 0)
3374 return rc;
3375
3376 /*
3377 * Eventually check for other socket options to change from
3378 * the default. sock_setsockopt not used because it expects
3379 * user space buffer
3380 */
3381 socket->sk->sk_rcvtimeo = 7 * HZ;
3382 socket->sk->sk_sndtimeo = 5 * HZ;
3383
3384 /* make the bufsizes depend on wsize/rsize and max requests */
3385 if (server->noautotune) {
3386 if (socket->sk->sk_sndbuf < (200 * 1024))
3387 socket->sk->sk_sndbuf = 200 * 1024;
3388 if (socket->sk->sk_rcvbuf < (140 * 1024))
3389 socket->sk->sk_rcvbuf = 140 * 1024;
3390 }
3391
3392 if (server->tcp_nodelay) {
3393 int val = 1;
3394 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3395 (char *)&val, sizeof(val));
3396 if (rc)
3397 cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3398 rc);
3399 }
3400
3401 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3402 socket->sk->sk_sndbuf,
3403 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3404
3405 rc = socket->ops->connect(socket, saddr, slen, 0);
3406 if (rc < 0) {
3407 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3408 sock_release(socket);
3409 server->ssocket = NULL;
3410 return rc;
3411 }
3412
3413 if (sport == htons(RFC1001_PORT))
3414 rc = ip_rfc1001_connect(server);
3415
3416 return rc;
3417 }
3418
3419 static int
3420 ip_connect(struct TCP_Server_Info *server)
3421 {
3422 __be16 *sport;
3423 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3424 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3425
3426 if (server->dstaddr.ss_family == AF_INET6)
3427 sport = &addr6->sin6_port;
3428 else
3429 sport = &addr->sin_port;
3430
3431 if (*sport == 0) {
3432 int rc;
3433
3434 /* try with 445 port at first */
3435 *sport = htons(CIFS_PORT);
3436
3437 rc = generic_ip_connect(server);
3438 if (rc >= 0)
3439 return rc;
3440
3441 /* if it failed, try with 139 port */
3442 *sport = htons(RFC1001_PORT);
3443 }
3444
3445 return generic_ip_connect(server);
3446 }
3447
3448 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3449 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3450 {
3451 /* if we are reconnecting then should we check to see if
3452 * any requested capabilities changed locally e.g. via
3453 * remount but we can not do much about it here
3454 * if they have (even if we could detect it by the following)
3455 * Perhaps we could add a backpointer to array of sb from tcon
3456 * or if we change to make all sb to same share the same
3457 * sb as NFS - then we only have one backpointer to sb.
3458 * What if we wanted to mount the server share twice once with
3459 * and once without posixacls or posix paths? */
3460 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3461
3462 if (vol_info && vol_info->no_linux_ext) {
3463 tcon->fsUnixInfo.Capability = 0;
3464 tcon->unix_ext = 0; /* Unix Extensions disabled */
3465 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
3466 return;
3467 } else if (vol_info)
3468 tcon->unix_ext = 1; /* Unix Extensions supported */
3469
3470 if (tcon->unix_ext == 0) {
3471 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
3472 return;
3473 }
3474
3475 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3476 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3477 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
3478 /* check for reconnect case in which we do not
3479 want to change the mount behavior if we can avoid it */
3480 if (vol_info == NULL) {
3481 /* turn off POSIX ACL and PATHNAMES if not set
3482 originally at mount time */
3483 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3484 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3485 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3486 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3487 cifs_dbg(VFS, "POSIXPATH support change\n");
3488 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3489 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3490 cifs_dbg(VFS, "possible reconnect error\n");
3491 cifs_dbg(VFS, "server disabled POSIX path support\n");
3492 }
3493 }
3494
3495 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3496 cifs_dbg(VFS, "per-share encryption not supported yet\n");
3497
3498 cap &= CIFS_UNIX_CAP_MASK;
3499 if (vol_info && vol_info->no_psx_acl)
3500 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3501 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3502 cifs_dbg(FYI, "negotiated posix acl support\n");
3503 if (cifs_sb)
3504 cifs_sb->mnt_cifs_flags |=
3505 CIFS_MOUNT_POSIXACL;
3506 }
3507
3508 if (vol_info && vol_info->posix_paths == 0)
3509 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3510 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3511 cifs_dbg(FYI, "negotiate posix pathnames\n");
3512 if (cifs_sb)
3513 cifs_sb->mnt_cifs_flags |=
3514 CIFS_MOUNT_POSIX_PATHS;
3515 }
3516
3517 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
3518 #ifdef CONFIG_CIFS_DEBUG2
3519 if (cap & CIFS_UNIX_FCNTL_CAP)
3520 cifs_dbg(FYI, "FCNTL cap\n");
3521 if (cap & CIFS_UNIX_EXTATTR_CAP)
3522 cifs_dbg(FYI, "EXTATTR cap\n");
3523 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3524 cifs_dbg(FYI, "POSIX path cap\n");
3525 if (cap & CIFS_UNIX_XATTR_CAP)
3526 cifs_dbg(FYI, "XATTR cap\n");
3527 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3528 cifs_dbg(FYI, "POSIX ACL cap\n");
3529 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3530 cifs_dbg(FYI, "very large read cap\n");
3531 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3532 cifs_dbg(FYI, "very large write cap\n");
3533 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3534 cifs_dbg(FYI, "transport encryption cap\n");
3535 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3536 cifs_dbg(FYI, "mandatory transport encryption cap\n");
3537 #endif /* CIFS_DEBUG2 */
3538 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3539 if (vol_info == NULL) {
3540 cifs_dbg(FYI, "resetting capabilities failed\n");
3541 } else
3542 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");
3543
3544 }
3545 }
3546 }
3547
3548 int cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3549 struct cifs_sb_info *cifs_sb)
3550 {
3551 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3552
3553 spin_lock_init(&cifs_sb->tlink_tree_lock);
3554 cifs_sb->tlink_tree = RB_ROOT;
3555
3556 /*
3557 * Temporarily set r/wsize for matching superblock. If we end up using
3558 * new sb then client will later negotiate it downward if needed.
3559 */
3560 cifs_sb->rsize = pvolume_info->rsize;
3561 cifs_sb->wsize = pvolume_info->wsize;
3562
3563 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3564 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3565 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3566 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3567 cifs_dbg(FYI, "file mode: 0x%hx dir mode: 0x%hx\n",
3568 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3569
3570 cifs_sb->actimeo = pvolume_info->actimeo;
3571 cifs_sb->local_nls = pvolume_info->local_nls;
3572
3573 if (pvolume_info->noperm)
3574 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3575 if (pvolume_info->setuids)
3576 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3577 if (pvolume_info->setuidfromacl)
3578 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
3579 if (pvolume_info->server_ino)
3580 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3581 if (pvolume_info->remap)
3582 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3583 if (pvolume_info->sfu_remap)
3584 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3585 if (pvolume_info->no_xattr)
3586 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3587 if (pvolume_info->sfu_emul)
3588 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3589 if (pvolume_info->nobrl)
3590 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3591 if (pvolume_info->nostrictsync)
3592 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3593 if (pvolume_info->mand_lock)
3594 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3595 if (pvolume_info->rwpidforward)
3596 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3597 if (pvolume_info->cifs_acl)
3598 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3599 if (pvolume_info->backupuid_specified) {
3600 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3601 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3602 }
3603 if (pvolume_info->backupgid_specified) {
3604 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3605 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3606 }
3607 if (pvolume_info->override_uid)
3608 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3609 if (pvolume_info->override_gid)
3610 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3611 if (pvolume_info->dynperm)
3612 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3613 if (pvolume_info->fsc)
3614 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3615 if (pvolume_info->multiuser)
3616 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3617 CIFS_MOUNT_NO_PERM);
3618 if (pvolume_info->strict_io)
3619 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3620 if (pvolume_info->direct_io) {
3621 cifs_dbg(FYI, "mounting share using direct i/o\n");
3622 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3623 }
3624 if (pvolume_info->mfsymlinks) {
3625 if (pvolume_info->sfu_emul) {
3626 /*
3627 * Our SFU ("Services for Unix" emulation does not allow
3628 * creating symlinks but does allow reading existing SFU
3629 * symlinks (it does allow both creating and reading SFU
3630 * style mknod and FIFOs though). When "mfsymlinks" and
3631 * "sfu" are both enabled at the same time, it allows
3632 * reading both types of symlinks, but will only create
3633 * them with mfsymlinks format. This allows better
3634 * Apple compatibility (probably better for Samba too)
3635 * while still recognizing old Windows style symlinks.
3636 */
3637 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
3638 }
3639 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3640 }
3641
3642 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3643 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
3644
3645 if (pvolume_info->prepath) {
3646 cifs_sb->prepath = kstrdup(pvolume_info->prepath, GFP_KERNEL);
3647 if (cifs_sb->prepath == NULL)
3648 return -ENOMEM;
3649 }
3650
3651 return 0;
3652 }
3653
3654 static void
3655 cleanup_volume_info_contents(struct smb_vol *volume_info)
3656 {
3657 kfree(volume_info->username);
3658 kzfree(volume_info->password);
3659 kfree(volume_info->UNC);
3660 kfree(volume_info->domainname);
3661 kfree(volume_info->iocharset);
3662 kfree(volume_info->prepath);
3663 }
3664
3665 void
3666 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3667 {
3668 if (!volume_info)
3669 return;
3670 cleanup_volume_info_contents(volume_info);
3671 kfree(volume_info);
3672 }
3673
3674
3675 #ifdef CONFIG_CIFS_DFS_UPCALL
3676 /*
3677 * cifs_build_path_to_root returns full path to root when we do not have an
3678 * exiting connection (tcon)
3679 */
3680 static char *
3681 build_unc_path_to_root(const struct smb_vol *vol,
3682 const struct cifs_sb_info *cifs_sb)
3683 {
3684 char *full_path, *pos;
3685 unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
3686 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3687
3688 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3689 if (full_path == NULL)
3690 return ERR_PTR(-ENOMEM);
3691
3692 strncpy(full_path, vol->UNC, unc_len);
3693 pos = full_path + unc_len;
3694
3695 if (pplen) {
3696 *pos = CIFS_DIR_SEP(cifs_sb);
3697 strncpy(pos + 1, vol->prepath, pplen);
3698 pos += pplen;
3699 }
3700
3701 *pos = '\0'; /* add trailing null */
3702 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3703 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
3704 return full_path;
3705 }
3706
3707 /*
3708 * Perform a dfs referral query for a share and (optionally) prefix
3709 *
3710 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3711 * to a string containing updated options for the submount. Otherwise it
3712 * will be left untouched.
3713 *
3714 * Returns the rc from get_dfs_path to the caller, which can be used to
3715 * determine whether there were referrals.
3716 */
3717 static int
3718 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
3719 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3720 int check_prefix)
3721 {
3722 int rc;
3723 unsigned int num_referrals = 0;
3724 struct dfs_info3_param *referrals = NULL;
3725 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3726
3727 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3728 if (IS_ERR(full_path))
3729 return PTR_ERR(full_path);
3730
3731 /* For DFS paths, skip the first '\' of the UNC */
3732 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3733
3734 rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
3735 &num_referrals, &referrals, cifs_remap(cifs_sb));
3736
3737 if (!rc && num_referrals > 0) {
3738 char *fake_devname = NULL;
3739
3740 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3741 full_path + 1, referrals,
3742 &fake_devname);
3743
3744 free_dfs_info_array(referrals, num_referrals);
3745
3746 if (IS_ERR(mdata)) {
3747 rc = PTR_ERR(mdata);
3748 mdata = NULL;
3749 } else {
3750 cleanup_volume_info_contents(volume_info);
3751 rc = cifs_setup_volume_info(volume_info, mdata,
3752 fake_devname);
3753 }
3754 kfree(fake_devname);
3755 kfree(cifs_sb->mountdata);
3756 cifs_sb->mountdata = mdata;
3757 }
3758 kfree(full_path);
3759 return rc;
3760 }
3761 #endif
3762
3763 static int
3764 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3765 const char *devname)
3766 {
3767 int rc = 0;
3768
3769 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3770 return -EINVAL;
3771
3772 if (volume_info->nullauth) {
3773 cifs_dbg(FYI, "Anonymous login\n");
3774 kfree(volume_info->username);
3775 volume_info->username = NULL;
3776 } else if (volume_info->username) {
3777 /* BB fixme parse for domain name here */
3778 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
3779 } else {
3780 cifs_dbg(VFS, "No username specified\n");
3781 /* In userspace mount helper we can get user name from alternate
3782 locations such as env variables and files on disk */
3783 return -EINVAL;
3784 }
3785
3786 /* this is needed for ASCII cp to Unicode converts */
3787 if (volume_info->iocharset == NULL) {
3788 /* load_nls_default cannot return null */
3789 volume_info->local_nls = load_nls_default();
3790 } else {
3791 volume_info->local_nls = load_nls(volume_info->iocharset);
3792 if (volume_info->local_nls == NULL) {
3793 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
3794 volume_info->iocharset);
3795 return -ELIBACC;
3796 }
3797 }
3798
3799 return rc;
3800 }
3801
3802 struct smb_vol *
3803 cifs_get_volume_info(char *mount_data, const char *devname)
3804 {
3805 int rc;
3806 struct smb_vol *volume_info;
3807
3808 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
3809 if (!volume_info)
3810 return ERR_PTR(-ENOMEM);
3811
3812 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3813 if (rc) {
3814 cifs_cleanup_volume_info(volume_info);
3815 volume_info = ERR_PTR(rc);
3816 }
3817
3818 return volume_info;
3819 }
3820
3821 static int
3822 cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
3823 unsigned int xid,
3824 struct cifs_tcon *tcon,
3825 struct cifs_sb_info *cifs_sb,
3826 char *full_path)
3827 {
3828 int rc;
3829 char *s;
3830 char sep, tmp;
3831
3832 sep = CIFS_DIR_SEP(cifs_sb);
3833 s = full_path;
3834
3835 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
3836 while (rc == 0) {
3837 /* skip separators */
3838 while (*s == sep)
3839 s++;
3840 if (!*s)
3841 break;
3842 /* next separator */
3843 while (*s && *s != sep)
3844 s++;
3845
3846 /*
3847 * temporarily null-terminate the path at the end of
3848 * the current component
3849 */
3850 tmp = *s;
3851 *s = 0;
3852 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3853 full_path);
3854 *s = tmp;
3855 }
3856 return rc;
3857 }
3858
3859 int
3860 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3861 {
3862 int rc;
3863 unsigned int xid;
3864 struct cifs_ses *ses;
3865 struct cifs_tcon *tcon;
3866 struct TCP_Server_Info *server;
3867 char *full_path;
3868 struct tcon_link *tlink;
3869 #ifdef CONFIG_CIFS_DFS_UPCALL
3870 int referral_walks_count = 0;
3871 #endif
3872
3873 #ifdef CONFIG_CIFS_DFS_UPCALL
3874 try_mount_again:
3875 /* cleanup activities if we're chasing a referral */
3876 if (referral_walks_count) {
3877 if (tcon)
3878 cifs_put_tcon(tcon);
3879 else if (ses)
3880 cifs_put_smb_ses(ses);
3881
3882 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
3883
3884 free_xid(xid);
3885 }
3886 #endif
3887 rc = 0;
3888 tcon = NULL;
3889 ses = NULL;
3890 server = NULL;
3891 full_path = NULL;
3892 tlink = NULL;
3893
3894 xid = get_xid();
3895
3896 /* get a reference to a tcp session */
3897 server = cifs_get_tcp_session(volume_info);
3898 if (IS_ERR(server)) {
3899 rc = PTR_ERR(server);
3900 goto out;
3901 }
3902 if ((volume_info->max_credits < 20) ||
3903 (volume_info->max_credits > 60000))
3904 server->max_credits = SMB2_MAX_CREDITS_AVAILABLE;
3905 else
3906 server->max_credits = volume_info->max_credits;
3907 /* get a reference to a SMB session */
3908 ses = cifs_get_smb_ses(server, volume_info);
3909 if (IS_ERR(ses)) {
3910 rc = PTR_ERR(ses);
3911 ses = NULL;
3912 goto mount_fail_check;
3913 }
3914
3915 if ((volume_info->persistent == true) && ((ses->server->capabilities &
3916 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES) == 0)) {
3917 cifs_dbg(VFS, "persistent handles not supported by server\n");
3918 rc = -EOPNOTSUPP;
3919 goto mount_fail_check;
3920 }
3921
3922 /* search for existing tcon to this server share */
3923 tcon = cifs_get_tcon(ses, volume_info);
3924 if (IS_ERR(tcon)) {
3925 rc = PTR_ERR(tcon);
3926 tcon = NULL;
3927 if (rc == -EACCES)
3928 goto mount_fail_check;
3929
3930 goto remote_path_check;
3931 }
3932
3933 /* tell server which Unix caps we support */
3934 if (cap_unix(tcon->ses)) {
3935 /* reset of caps checks mount to see if unix extensions
3936 disabled for just this mount */
3937 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3938 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3939 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3940 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3941 rc = -EACCES;
3942 goto mount_fail_check;
3943 }
3944 } else
3945 tcon->unix_ext = 0; /* server does not support them */
3946
3947 /* do not care if a following call succeed - informational */
3948 if (!tcon->pipe && server->ops->qfs_tcon)
3949 server->ops->qfs_tcon(xid, tcon);
3950
3951 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3952 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
3953
3954 remote_path_check:
3955 #ifdef CONFIG_CIFS_DFS_UPCALL
3956 /*
3957 * Perform an unconditional check for whether there are DFS
3958 * referrals for this path without prefix, to provide support
3959 * for DFS referrals from w2k8 servers which don't seem to respond
3960 * with PATH_NOT_COVERED to requests that include the prefix.
3961 * Chase the referral if found, otherwise continue normally.
3962 */
3963 if (referral_walks_count == 0) {
3964 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3965 false);
3966 if (!refrc) {
3967 referral_walks_count++;
3968 goto try_mount_again;
3969 }
3970 }
3971 #endif
3972
3973 /* check if a whole path is not remote */
3974 if (!rc && tcon) {
3975 if (!server->ops->is_path_accessible) {
3976 rc = -ENOSYS;
3977 goto mount_fail_check;
3978 }
3979 /*
3980 * cifs_build_path_to_root works only when we have a valid tcon
3981 */
3982 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon,
3983 tcon->Flags & SMB_SHARE_IS_IN_DFS);
3984 if (full_path == NULL) {
3985 rc = -ENOMEM;
3986 goto mount_fail_check;
3987 }
3988 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3989 full_path);
3990 if (rc != 0 && rc != -EREMOTE) {
3991 kfree(full_path);
3992 goto mount_fail_check;
3993 }
3994
3995 if (rc != -EREMOTE) {
3996 rc = cifs_are_all_path_components_accessible(server,
3997 xid, tcon, cifs_sb,
3998 full_path);
3999 if (rc != 0) {
4000 cifs_dbg(VFS, "cannot query dirs between root and final path, "
4001 "enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
4002 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
4003 rc = 0;
4004 }
4005 }
4006 kfree(full_path);
4007 }
4008
4009 /* get referral if needed */
4010 if (rc == -EREMOTE) {
4011 #ifdef CONFIG_CIFS_DFS_UPCALL
4012 if (referral_walks_count > MAX_NESTED_LINKS) {
4013 /*
4014 * BB: when we implement proper loop detection,
4015 * we will remove this check. But now we need it
4016 * to prevent an indefinite loop if 'DFS tree' is
4017 * misconfigured (i.e. has loops).
4018 */
4019 rc = -ELOOP;
4020 goto mount_fail_check;
4021 }
4022
4023 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
4024
4025 if (!rc) {
4026 referral_walks_count++;
4027 goto try_mount_again;
4028 }
4029 goto mount_fail_check;
4030 #else /* No DFS support, return error on mount */
4031 rc = -EOPNOTSUPP;
4032 #endif
4033 }
4034
4035 if (rc)
4036 goto mount_fail_check;
4037
4038 /* now, hang the tcon off of the superblock */
4039 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
4040 if (tlink == NULL) {
4041 rc = -ENOMEM;
4042 goto mount_fail_check;
4043 }
4044
4045 tlink->tl_uid = ses->linux_uid;
4046 tlink->tl_tcon = tcon;
4047 tlink->tl_time = jiffies;
4048 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
4049 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4050
4051 cifs_sb->master_tlink = tlink;
4052 spin_lock(&cifs_sb->tlink_tree_lock);
4053 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4054 spin_unlock(&cifs_sb->tlink_tree_lock);
4055
4056 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4057 TLINK_IDLE_EXPIRE);
4058
4059 mount_fail_check:
4060 /* on error free sesinfo and tcon struct if needed */
4061 if (rc) {
4062 /* If find_unc succeeded then rc == 0 so we can not end */
4063 /* up accidentally freeing someone elses tcon struct */
4064 if (tcon)
4065 cifs_put_tcon(tcon);
4066 else if (ses)
4067 cifs_put_smb_ses(ses);
4068 else
4069 cifs_put_tcp_session(server, 0);
4070 }
4071
4072 out:
4073 free_xid(xid);
4074 return rc;
4075 }
4076
4077 /*
4078 * Issue a TREE_CONNECT request.
4079 */
4080 int
4081 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
4082 const char *tree, struct cifs_tcon *tcon,
4083 const struct nls_table *nls_codepage)
4084 {
4085 struct smb_hdr *smb_buffer;
4086 struct smb_hdr *smb_buffer_response;
4087 TCONX_REQ *pSMB;
4088 TCONX_RSP *pSMBr;
4089 unsigned char *bcc_ptr;
4090 int rc = 0;
4091 int length;
4092 __u16 bytes_left, count;
4093
4094 if (ses == NULL)
4095 return -EIO;
4096
4097 smb_buffer = cifs_buf_get();
4098 if (smb_buffer == NULL)
4099 return -ENOMEM;
4100
4101 smb_buffer_response = smb_buffer;
4102
4103 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
4104 NULL /*no tid */ , 4 /*wct */ );
4105
4106 smb_buffer->Mid = get_next_mid(ses->server);
4107 smb_buffer->Uid = ses->Suid;
4108 pSMB = (TCONX_REQ *) smb_buffer;
4109 pSMBr = (TCONX_RSP *) smb_buffer_response;
4110
4111 pSMB->AndXCommand = 0xFF;
4112 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
4113 bcc_ptr = &pSMB->Password[0];
4114 if (tcon->pipe || (ses->server->sec_mode & SECMODE_USER)) {
4115 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
4116 *bcc_ptr = 0; /* password is null byte */
4117 bcc_ptr++; /* skip password */
4118 /* already aligned so no need to do it below */
4119 } else {
4120 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
4121 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
4122 specified as required (when that support is added to
4123 the vfs in the future) as only NTLM or the much
4124 weaker LANMAN (which we do not send by default) is accepted
4125 by Samba (not sure whether other servers allow
4126 NTLMv2 password here) */
4127 #ifdef CONFIG_CIFS_WEAK_PW_HASH
4128 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
4129 (ses->sectype == LANMAN))
4130 calc_lanman_hash(tcon->password, ses->server->cryptkey,
4131 ses->server->sec_mode &
4132 SECMODE_PW_ENCRYPT ? true : false,
4133 bcc_ptr);
4134 else
4135 #endif /* CIFS_WEAK_PW_HASH */
4136 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
4137 bcc_ptr, nls_codepage);
4138 if (rc) {
4139 cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
4140 __func__, rc);
4141 cifs_buf_release(smb_buffer);
4142 return rc;
4143 }
4144
4145 bcc_ptr += CIFS_AUTH_RESP_SIZE;
4146 if (ses->capabilities & CAP_UNICODE) {
4147 /* must align unicode strings */
4148 *bcc_ptr = 0; /* null byte password */
4149 bcc_ptr++;
4150 }
4151 }
4152
4153 if (ses->server->sign)
4154 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
4155
4156 if (ses->capabilities & CAP_STATUS32) {
4157 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
4158 }
4159 if (ses->capabilities & CAP_DFS) {
4160 smb_buffer->Flags2 |= SMBFLG2_DFS;
4161 }
4162 if (ses->capabilities & CAP_UNICODE) {
4163 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
4164 length =
4165 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
4166 6 /* max utf8 char length in bytes */ *
4167 (/* server len*/ + 256 /* share len */), nls_codepage);
4168 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
4169 bcc_ptr += 2; /* skip trailing null */
4170 } else { /* ASCII */
4171 strcpy(bcc_ptr, tree);
4172 bcc_ptr += strlen(tree) + 1;
4173 }
4174 strcpy(bcc_ptr, "?????");
4175 bcc_ptr += strlen("?????");
4176 bcc_ptr += 1;
4177 count = bcc_ptr - &pSMB->Password[0];
4178 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
4179 pSMB->hdr.smb_buf_length) + count);
4180 pSMB->ByteCount = cpu_to_le16(count);
4181
4182 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
4183 0);
4184
4185 /* above now done in SendReceive */
4186 if (rc == 0) {
4187 bool is_unicode;
4188
4189 tcon->tidStatus = CifsGood;
4190 tcon->need_reconnect = false;
4191 tcon->tid = smb_buffer_response->Tid;
4192 bcc_ptr = pByteArea(smb_buffer_response);
4193 bytes_left = get_bcc(smb_buffer_response);
4194 length = strnlen(bcc_ptr, bytes_left - 2);
4195 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
4196 is_unicode = true;
4197 else
4198 is_unicode = false;
4199
4200
4201 /* skip service field (NB: this field is always ASCII) */
4202 if (length == 3) {
4203 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
4204 (bcc_ptr[2] == 'C')) {
4205 cifs_dbg(FYI, "IPC connection\n");
4206 tcon->ipc = true;
4207 tcon->pipe = true;
4208 }
4209 } else if (length == 2) {
4210 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
4211 /* the most common case */
4212 cifs_dbg(FYI, "disk share connection\n");
4213 }
4214 }
4215 bcc_ptr += length + 1;
4216 bytes_left -= (length + 1);
4217 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
4218
4219 /* mostly informational -- no need to fail on error here */
4220 kfree(tcon->nativeFileSystem);
4221 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
4222 bytes_left, is_unicode,
4223 nls_codepage);
4224
4225 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
4226
4227 if ((smb_buffer_response->WordCount == 3) ||
4228 (smb_buffer_response->WordCount == 7))
4229 /* field is in same location */
4230 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
4231 else
4232 tcon->Flags = 0;
4233 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
4234 }
4235
4236 cifs_buf_release(smb_buffer);
4237 return rc;
4238 }
4239
4240 static void delayed_free(struct rcu_head *p)
4241 {
4242 struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
4243 unload_nls(sbi->local_nls);
4244 kfree(sbi);
4245 }
4246
4247 void
4248 cifs_umount(struct cifs_sb_info *cifs_sb)
4249 {
4250 struct rb_root *root = &cifs_sb->tlink_tree;
4251 struct rb_node *node;
4252 struct tcon_link *tlink;
4253
4254 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
4255
4256 spin_lock(&cifs_sb->tlink_tree_lock);
4257 while ((node = rb_first(root))) {
4258 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4259 cifs_get_tlink(tlink);
4260 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4261 rb_erase(node, root);
4262
4263 spin_unlock(&cifs_sb->tlink_tree_lock);
4264 cifs_put_tlink(tlink);
4265 spin_lock(&cifs_sb->tlink_tree_lock);
4266 }
4267 spin_unlock(&cifs_sb->tlink_tree_lock);
4268
4269 kfree(cifs_sb->mountdata);
4270 kfree(cifs_sb->prepath);
4271 call_rcu(&cifs_sb->rcu, delayed_free);
4272 }
4273
4274 int
4275 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
4276 {
4277 int rc = 0;
4278 struct TCP_Server_Info *server = ses->server;
4279
4280 if (!server->ops->need_neg || !server->ops->negotiate)
4281 return -ENOSYS;
4282
4283 /* only send once per connect */
4284 if (!server->ops->need_neg(server))
4285 return 0;
4286
4287 set_credits(server, 1);
4288
4289 rc = server->ops->negotiate(xid, ses);
4290 if (rc == 0) {
4291 spin_lock(&GlobalMid_Lock);
4292 if (server->tcpStatus == CifsNeedNegotiate)
4293 server->tcpStatus = CifsGood;
4294 else
4295 rc = -EHOSTDOWN;
4296 spin_unlock(&GlobalMid_Lock);
4297 }
4298
4299 return rc;
4300 }
4301
4302 int
4303 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
4304 struct nls_table *nls_info)
4305 {
4306 int rc = -ENOSYS;
4307 struct TCP_Server_Info *server = ses->server;
4308
4309 ses->capabilities = server->capabilities;
4310 if (linuxExtEnabled == 0)
4311 ses->capabilities &= (~server->vals->cap_unix);
4312
4313 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
4314 server->sec_mode, server->capabilities, server->timeAdj);
4315
4316 if (ses->auth_key.response) {
4317 cifs_dbg(FYI, "Free previous auth_key.response = %p\n",
4318 ses->auth_key.response);
4319 kfree(ses->auth_key.response);
4320 ses->auth_key.response = NULL;
4321 ses->auth_key.len = 0;
4322 }
4323
4324 if (server->ops->sess_setup)
4325 rc = server->ops->sess_setup(xid, ses, nls_info);
4326
4327 if (rc)
4328 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
4329
4330 return rc;
4331 }
4332
4333 static int
4334 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
4335 {
4336 vol->sectype = ses->sectype;
4337
4338 /* krb5 is special, since we don't need username or pw */
4339 if (vol->sectype == Kerberos)
4340 return 0;
4341
4342 return cifs_set_cifscreds(vol, ses);
4343 }
4344
4345 static struct cifs_tcon *
4346 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
4347 {
4348 int rc;
4349 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4350 struct cifs_ses *ses;
4351 struct cifs_tcon *tcon = NULL;
4352 struct smb_vol *vol_info;
4353
4354 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
4355 if (vol_info == NULL)
4356 return ERR_PTR(-ENOMEM);
4357
4358 vol_info->local_nls = cifs_sb->local_nls;
4359 vol_info->linux_uid = fsuid;
4360 vol_info->cred_uid = fsuid;
4361 vol_info->UNC = master_tcon->treeName;
4362 vol_info->retry = master_tcon->retry;
4363 vol_info->nocase = master_tcon->nocase;
4364 vol_info->local_lease = master_tcon->local_lease;
4365 vol_info->no_linux_ext = !master_tcon->unix_ext;
4366 vol_info->sectype = master_tcon->ses->sectype;
4367 vol_info->sign = master_tcon->ses->sign;
4368
4369 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4370 if (rc) {
4371 tcon = ERR_PTR(rc);
4372 goto out;
4373 }
4374
4375 /* get a reference for the same TCP session */
4376 spin_lock(&cifs_tcp_ses_lock);
4377 ++master_tcon->ses->server->srv_count;
4378 spin_unlock(&cifs_tcp_ses_lock);
4379
4380 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4381 if (IS_ERR(ses)) {
4382 tcon = (struct cifs_tcon *)ses;
4383 cifs_put_tcp_session(master_tcon->ses->server, 0);
4384 goto out;
4385 }
4386
4387 tcon = cifs_get_tcon(ses, vol_info);
4388 if (IS_ERR(tcon)) {
4389 cifs_put_smb_ses(ses);
4390 goto out;
4391 }
4392
4393 if (cap_unix(ses))
4394 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4395 out:
4396 kfree(vol_info->username);
4397 kzfree(vol_info->password);
4398 kfree(vol_info);
4399
4400 return tcon;
4401 }
4402
4403 struct cifs_tcon *
4404 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4405 {
4406 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4407 }
4408
4409 /* find and return a tlink with given uid */
4410 static struct tcon_link *
4411 tlink_rb_search(struct rb_root *root, kuid_t uid)
4412 {
4413 struct rb_node *node = root->rb_node;
4414 struct tcon_link *tlink;
4415
4416 while (node) {
4417 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4418
4419 if (uid_gt(tlink->tl_uid, uid))
4420 node = node->rb_left;
4421 else if (uid_lt(tlink->tl_uid, uid))
4422 node = node->rb_right;
4423 else
4424 return tlink;
4425 }
4426 return NULL;
4427 }
4428
4429 /* insert a tcon_link into the tree */
4430 static void
4431 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4432 {
4433 struct rb_node **new = &(root->rb_node), *parent = NULL;
4434 struct tcon_link *tlink;
4435
4436 while (*new) {
4437 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4438 parent = *new;
4439
4440 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
4441 new = &((*new)->rb_left);
4442 else
4443 new = &((*new)->rb_right);
4444 }
4445
4446 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4447 rb_insert_color(&new_tlink->tl_rbnode, root);
4448 }
4449
4450 /*
4451 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4452 * current task.
4453 *
4454 * If the superblock doesn't refer to a multiuser mount, then just return
4455 * the master tcon for the mount.
4456 *
4457 * First, search the rbtree for an existing tcon for this fsuid. If one
4458 * exists, then check to see if it's pending construction. If it is then wait
4459 * for construction to complete. Once it's no longer pending, check to see if
4460 * it failed and either return an error or retry construction, depending on
4461 * the timeout.
4462 *
4463 * If one doesn't exist then insert a new tcon_link struct into the tree and
4464 * try to construct a new one.
4465 */
4466 struct tcon_link *
4467 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4468 {
4469 int ret;
4470 kuid_t fsuid = current_fsuid();
4471 struct tcon_link *tlink, *newtlink;
4472
4473 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4474 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4475
4476 spin_lock(&cifs_sb->tlink_tree_lock);
4477 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4478 if (tlink)
4479 cifs_get_tlink(tlink);
4480 spin_unlock(&cifs_sb->tlink_tree_lock);
4481
4482 if (tlink == NULL) {
4483 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4484 if (newtlink == NULL)
4485 return ERR_PTR(-ENOMEM);
4486 newtlink->tl_uid = fsuid;
4487 newtlink->tl_tcon = ERR_PTR(-EACCES);
4488 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4489 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4490 cifs_get_tlink(newtlink);
4491
4492 spin_lock(&cifs_sb->tlink_tree_lock);
4493 /* was one inserted after previous search? */
4494 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4495 if (tlink) {
4496 cifs_get_tlink(tlink);
4497 spin_unlock(&cifs_sb->tlink_tree_lock);
4498 kfree(newtlink);
4499 goto wait_for_construction;
4500 }
4501 tlink = newtlink;
4502 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4503 spin_unlock(&cifs_sb->tlink_tree_lock);
4504 } else {
4505 wait_for_construction:
4506 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4507 TASK_INTERRUPTIBLE);
4508 if (ret) {
4509 cifs_put_tlink(tlink);
4510 return ERR_PTR(-ERESTARTSYS);
4511 }
4512
4513 /* if it's good, return it */
4514 if (!IS_ERR(tlink->tl_tcon))
4515 return tlink;
4516
4517 /* return error if we tried this already recently */
4518 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4519 cifs_put_tlink(tlink);
4520 return ERR_PTR(-EACCES);
4521 }
4522
4523 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4524 goto wait_for_construction;
4525 }
4526
4527 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4528 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4529 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4530
4531 if (IS_ERR(tlink->tl_tcon)) {
4532 cifs_put_tlink(tlink);
4533 return ERR_PTR(-EACCES);
4534 }
4535
4536 return tlink;
4537 }
4538
4539 /*
4540 * periodic workqueue job that scans tcon_tree for a superblock and closes
4541 * out tcons.
4542 */
4543 static void
4544 cifs_prune_tlinks(struct work_struct *work)
4545 {
4546 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4547 prune_tlinks.work);
4548 struct rb_root *root = &cifs_sb->tlink_tree;
4549 struct rb_node *node;
4550 struct rb_node *tmp;
4551 struct tcon_link *tlink;
4552
4553 /*
4554 * Because we drop the spinlock in the loop in order to put the tlink
4555 * it's not guarded against removal of links from the tree. The only
4556 * places that remove entries from the tree are this function and
4557 * umounts. Because this function is non-reentrant and is canceled
4558 * before umount can proceed, this is safe.
4559 */
4560 spin_lock(&cifs_sb->tlink_tree_lock);
4561 node = rb_first(root);
4562 while (node != NULL) {
4563 tmp = node;
4564 node = rb_next(tmp);
4565 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4566
4567 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4568 atomic_read(&tlink->tl_count) != 0 ||
4569 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4570 continue;
4571
4572 cifs_get_tlink(tlink);
4573 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4574 rb_erase(tmp, root);
4575
4576 spin_unlock(&cifs_sb->tlink_tree_lock);
4577 cifs_put_tlink(tlink);
4578 spin_lock(&cifs_sb->tlink_tree_lock);
4579 }
4580 spin_unlock(&cifs_sb->tlink_tree_lock);
4581
4582 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4583 TLINK_IDLE_EXPIRE);
4584 }
Ubuntu Jammy Linux kernel mirror