~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/cifs/connect.c

Version: ~ [ linux-5.18-rc6 ] ~ [ linux-5.17.6 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.38 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.114 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.192 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.241 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.277 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.312 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp