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