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