4 * Copyright (C) International Business Machines Corp., 2002,2009
5 * Author(s): Steve French (sfrench@us.ibm.com)
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.
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.
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
22 #include <linux/net.h>
23 #include <linux/string.h>
24 #include <linux/list.h>
25 #include <linux/wait.h>
26 #include <linux/slab.h>
27 #include <linux/pagemap.h>
28 #include <linux/ctype.h>
29 #include <linux/utsname.h>
30 #include <linux/mempool.h>
31 #include <linux/delay.h>
32 #include <linux/completion.h>
33 #include <linux/kthread.h>
34 #include <linux/pagevec.h>
35 #include <linux/freezer.h>
36 #include <linux/namei.h>
37 #include <asm/uaccess.h>
38 #include <asm/processor.h>
39 #include <linux/inet.h>
43 #include "cifsproto.h"
44 #include "cifs_unicode.h"
45 #include "cifs_debug.h"
46 #include "cifs_fs_sb.h"
49 #include "rfc1002pdu.h"
53 #define RFC1001_PORT 139
55 /* SMB echo "timeout" -- FIXME: tunable? */
56 #define SMB_ECHO_INTERVAL (60 * HZ)
58 extern mempool_t *cifs_req_poolp;
60 /* FIXME: should these be tunable? */
61 #define TLINK_ERROR_EXPIRE (1 * HZ)
62 #define TLINK_IDLE_EXPIRE (600 * HZ)
64 static int ip_connect(struct TCP_Server_Info *server);
65 static int generic_ip_connect(struct TCP_Server_Info *server);
66 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
67 static void cifs_prune_tlinks(struct work_struct *work);
68 static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
72 * cifs tcp session reconnection
74 * mark tcp session as reconnecting so temporarily locked
75 * mark all smb sessions as reconnecting for tcp session
76 * reconnect tcp session
77 * wake up waiters on reconnection? - (not needed currently)
80 cifs_reconnect(struct TCP_Server_Info *server)
83 struct list_head *tmp, *tmp2;
85 struct cifs_tcon *tcon;
86 struct mid_q_entry *mid_entry;
87 struct list_head retry_list;
89 spin_lock(&GlobalMid_Lock);
90 if (server->tcpStatus == CifsExiting) {
91 /* the demux thread will exit normally
92 next time through the loop */
93 spin_unlock(&GlobalMid_Lock);
96 server->tcpStatus = CifsNeedReconnect;
97 spin_unlock(&GlobalMid_Lock);
100 cFYI(1, "Reconnecting tcp session");
102 /* before reconnecting the tcp session, mark the smb session (uid)
103 and the tid bad so they are not used until reconnected */
104 cFYI(1, "%s: marking sessions and tcons for reconnect", __func__);
105 spin_lock(&cifs_tcp_ses_lock);
106 list_for_each(tmp, &server->smb_ses_list) {
107 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
108 ses->need_reconnect = true;
110 list_for_each(tmp2, &ses->tcon_list) {
111 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
112 tcon->need_reconnect = true;
115 spin_unlock(&cifs_tcp_ses_lock);
117 /* do not want to be sending data on a socket we are freeing */
118 cFYI(1, "%s: tearing down socket", __func__);
119 mutex_lock(&server->srv_mutex);
120 if (server->ssocket) {
121 cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
122 server->ssocket->flags);
123 kernel_sock_shutdown(server->ssocket, SHUT_WR);
124 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
125 server->ssocket->state,
126 server->ssocket->flags);
127 sock_release(server->ssocket);
128 server->ssocket = NULL;
130 server->sequence_number = 0;
131 server->session_estab = false;
132 kfree(server->session_key.response);
133 server->session_key.response = NULL;
134 server->session_key.len = 0;
135 server->lstrp = jiffies;
136 mutex_unlock(&server->srv_mutex);
138 /* mark submitted MIDs for retry and issue callback */
139 INIT_LIST_HEAD(&retry_list);
140 cFYI(1, "%s: moving mids to private list", __func__);
141 spin_lock(&GlobalMid_Lock);
142 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
143 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
144 if (mid_entry->midState == MID_REQUEST_SUBMITTED)
145 mid_entry->midState = MID_RETRY_NEEDED;
146 list_move(&mid_entry->qhead, &retry_list);
148 spin_unlock(&GlobalMid_Lock);
150 cFYI(1, "%s: issuing mid callbacks", __func__);
151 list_for_each_safe(tmp, tmp2, &retry_list) {
152 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
153 list_del_init(&mid_entry->qhead);
154 mid_entry->callback(mid_entry);
160 /* we should try only the port we connected to before */
161 rc = generic_ip_connect(server);
163 cFYI(1, "reconnect error %d", rc);
166 atomic_inc(&tcpSesReconnectCount);
167 spin_lock(&GlobalMid_Lock);
168 if (server->tcpStatus != CifsExiting)
169 server->tcpStatus = CifsNeedNegotiate;
170 spin_unlock(&GlobalMid_Lock);
172 } while (server->tcpStatus == CifsNeedReconnect);
179 0 not a transact2, or all data present
180 >0 transact2 with that much data missing
181 -EINVAL = invalid transact2
184 static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
186 struct smb_t2_rsp *pSMBt;
188 __u16 total_data_size, data_in_this_rsp;
190 if (pSMB->Command != SMB_COM_TRANSACTION2)
193 /* check for plausible wct, bcc and t2 data and parm sizes */
194 /* check for parm and data offset going beyond end of smb */
195 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
196 cFYI(1, "invalid transact2 word count");
200 pSMBt = (struct smb_t2_rsp *)pSMB;
202 total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
203 data_in_this_rsp = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
205 if (total_data_size == data_in_this_rsp)
207 else if (total_data_size < data_in_this_rsp) {
208 cFYI(1, "total data %d smaller than data in frame %d",
209 total_data_size, data_in_this_rsp);
213 remaining = total_data_size - data_in_this_rsp;
215 cFYI(1, "missing %d bytes from transact2, check next response",
217 if (total_data_size > maxBufSize) {
218 cERROR(1, "TotalDataSize %d is over maximum buffer %d",
219 total_data_size, maxBufSize);
225 static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
227 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
228 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
229 char *data_area_of_target;
230 char *data_area_of_buf2;
232 unsigned int byte_count, total_in_buf;
233 __u16 total_data_size, total_in_buf2;
235 total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
237 if (total_data_size !=
238 get_unaligned_le16(&pSMB2->t2_rsp.TotalDataCount))
239 cFYI(1, "total data size of primary and secondary t2 differ");
241 total_in_buf = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
243 remaining = total_data_size - total_in_buf;
248 if (remaining == 0) /* nothing to do, ignore */
251 total_in_buf2 = get_unaligned_le16(&pSMB2->t2_rsp.DataCount);
252 if (remaining < total_in_buf2) {
253 cFYI(1, "transact2 2nd response contains too much data");
256 /* find end of first SMB data area */
257 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
258 get_unaligned_le16(&pSMBt->t2_rsp.DataOffset);
259 /* validate target area */
261 data_area_of_buf2 = (char *)&pSMB2->hdr.Protocol +
262 get_unaligned_le16(&pSMB2->t2_rsp.DataOffset);
264 data_area_of_target += total_in_buf;
266 /* copy second buffer into end of first buffer */
267 total_in_buf += total_in_buf2;
268 /* is the result too big for the field? */
269 if (total_in_buf > USHRT_MAX)
271 put_unaligned_le16(total_in_buf, &pSMBt->t2_rsp.DataCount);
274 byte_count = get_bcc(pTargetSMB);
275 byte_count += total_in_buf2;
276 /* is the result too big for the field? */
277 if (byte_count > USHRT_MAX)
279 put_bcc(byte_count, pTargetSMB);
281 byte_count = be32_to_cpu(pTargetSMB->smb_buf_length);
282 byte_count += total_in_buf2;
283 /* don't allow buffer to overflow */
284 if (byte_count > CIFSMaxBufSize)
286 pTargetSMB->smb_buf_length = cpu_to_be32(byte_count);
288 memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
290 if (remaining == total_in_buf2) {
291 cFYI(1, "found the last secondary response");
292 return 0; /* we are done */
293 } else /* more responses to go */
298 cifs_echo_request(struct work_struct *work)
301 struct TCP_Server_Info *server = container_of(work,
302 struct TCP_Server_Info, echo.work);
305 * We cannot send an echo until the NEGOTIATE_PROTOCOL request is
306 * done, which is indicated by maxBuf != 0. Also, no need to ping if
307 * we got a response recently
309 if (server->maxBuf == 0 ||
310 time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
313 rc = CIFSSMBEcho(server);
315 cFYI(1, "Unable to send echo request to server: %s",
319 queue_delayed_work(system_nrt_wq, &server->echo, SMB_ECHO_INTERVAL);
323 cifs_demultiplex_thread(void *p)
326 struct TCP_Server_Info *server = p;
327 unsigned int pdu_length, total_read;
328 struct smb_hdr *smb_buffer = NULL;
329 struct smb_hdr *bigbuf = NULL;
330 struct smb_hdr *smallbuf = NULL;
331 struct msghdr smb_msg;
333 struct socket *csocket = server->ssocket;
334 struct list_head *tmp, *tmp2;
335 struct task_struct *task_to_wake = NULL;
336 struct mid_q_entry *mid_entry;
338 bool isLargeBuf = false;
342 current->flags |= PF_MEMALLOC;
343 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
345 length = atomic_inc_return(&tcpSesAllocCount);
347 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
351 while (server->tcpStatus != CifsExiting) {
354 if (bigbuf == NULL) {
355 bigbuf = cifs_buf_get();
357 cERROR(1, "No memory for large SMB response");
359 /* retry will check if exiting */
362 } else if (isLargeBuf) {
363 /* we are reusing a dirty large buf, clear its start */
364 memset(bigbuf, 0, sizeof(struct smb_hdr));
367 if (smallbuf == NULL) {
368 smallbuf = cifs_small_buf_get();
370 cERROR(1, "No memory for SMB response");
372 /* retry will check if exiting */
375 /* beginning of smb buffer is cleared in our buf_get */
376 } else /* if existing small buf clear beginning */
377 memset(smallbuf, 0, sizeof(struct smb_hdr));
381 smb_buffer = smallbuf;
382 iov.iov_base = smb_buffer;
384 smb_msg.msg_control = NULL;
385 smb_msg.msg_controllen = 0;
386 pdu_length = 4; /* enough to get RFC1001 header */
389 if (echo_retries > 0 && server->tcpStatus == CifsGood &&
390 time_after(jiffies, server->lstrp +
391 (echo_retries * SMB_ECHO_INTERVAL))) {
392 cERROR(1, "Server %s has not responded in %d seconds. "
393 "Reconnecting...", server->hostname,
394 (echo_retries * SMB_ECHO_INTERVAL / HZ));
395 cifs_reconnect(server);
396 csocket = server->ssocket;
397 wake_up(&server->response_q);
402 kernel_recvmsg(csocket, &smb_msg,
403 &iov, 1, pdu_length, 0 /* BB other flags? */);
405 if (server->tcpStatus == CifsExiting) {
407 } else if (server->tcpStatus == CifsNeedReconnect) {
408 cFYI(1, "Reconnect after server stopped responding");
409 cifs_reconnect(server);
410 cFYI(1, "call to reconnect done");
411 csocket = server->ssocket;
413 } else if (length == -ERESTARTSYS ||
416 msleep(1); /* minimum sleep to prevent looping
417 allowing socket to clear and app threads to set
418 tcpStatus CifsNeedReconnect if server hung */
419 if (pdu_length < 4) {
420 iov.iov_base = (4 - pdu_length) +
422 iov.iov_len = pdu_length;
423 smb_msg.msg_control = NULL;
424 smb_msg.msg_controllen = 0;
428 } else if (length <= 0) {
429 cFYI(1, "Reconnect after unexpected peek error %d",
431 cifs_reconnect(server);
432 csocket = server->ssocket;
433 wake_up(&server->response_q);
435 } else if (length < pdu_length) {
436 cFYI(1, "requested %d bytes but only got %d bytes",
438 pdu_length -= length;
443 /* The right amount was read from socket - 4 bytes */
444 /* so we can now interpret the length field */
446 /* the first byte big endian of the length field,
447 is actually not part of the length but the type
448 with the most common, zero, as regular data */
449 temp = *((char *) smb_buffer);
451 /* Note that FC 1001 length is big endian on the wire,
452 but we convert it here so it is always manipulated
453 as host byte order */
454 pdu_length = be32_to_cpu(smb_buffer->smb_buf_length);
456 cFYI(1, "rfc1002 length 0x%x", pdu_length+4);
458 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
460 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
461 cFYI(1, "Good RFC 1002 session rsp");
463 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
464 /* we get this from Windows 98 instead of
465 an error on SMB negprot response */
466 cFYI(1, "Negative RFC1002 Session Response Error 0x%x)",
468 /* give server a second to clean up */
470 /* always try 445 first on reconnect since we get NACK
471 * on some if we ever connected to port 139 (the NACK
472 * is since we do not begin with RFC1001 session
475 cifs_set_port((struct sockaddr *)
476 &server->dstaddr, CIFS_PORT);
477 cifs_reconnect(server);
478 csocket = server->ssocket;
479 wake_up(&server->response_q);
481 } else if (temp != (char) 0) {
482 cERROR(1, "Unknown RFC 1002 frame");
483 cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
485 cifs_reconnect(server);
486 csocket = server->ssocket;
490 /* else we have an SMB response */
491 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
492 (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
493 cERROR(1, "Invalid size SMB length %d pdu_length %d",
494 length, pdu_length+4);
495 cifs_reconnect(server);
496 csocket = server->ssocket;
497 wake_up(&server->response_q);
504 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
506 memcpy(bigbuf, smallbuf, 4);
510 iov.iov_base = 4 + (char *)smb_buffer;
511 iov.iov_len = pdu_length;
512 for (total_read = 0; total_read < pdu_length;
513 total_read += length) {
514 length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
515 pdu_length - total_read, 0);
516 if (server->tcpStatus == CifsExiting) {
520 } else if (server->tcpStatus == CifsNeedReconnect) {
521 cifs_reconnect(server);
522 csocket = server->ssocket;
523 /* Reconnect wakes up rspns q */
524 /* Now we will reread sock */
527 } else if (length == -ERESTARTSYS ||
530 msleep(1); /* minimum sleep to prevent looping,
531 allowing socket to clear and app
532 threads to set tcpStatus
533 CifsNeedReconnect if server hung*/
536 } else if (length <= 0) {
537 cERROR(1, "Received no data, expecting %d",
538 pdu_length - total_read);
539 cifs_reconnect(server);
540 csocket = server->ssocket;
547 else if (reconnect == 1)
550 total_read += 4; /* account for rfc1002 hdr */
552 dump_smb(smb_buffer, total_read);
555 * We know that we received enough to get to the MID as we
556 * checked the pdu_length earlier. Now check to see
557 * if the rest of the header is OK. We borrow the length
558 * var for the rest of the loop to avoid a new stack var.
560 * 48 bytes is enough to display the header and a little bit
561 * into the payload for debugging purposes.
563 length = checkSMB(smb_buffer, smb_buffer->Mid, total_read);
565 cifs_dump_mem("Bad SMB: ", smb_buffer,
566 min_t(unsigned int, total_read, 48));
569 server->lstrp = jiffies;
571 spin_lock(&GlobalMid_Lock);
572 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
573 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
575 if (mid_entry->mid != smb_buffer->Mid ||
576 mid_entry->midState != MID_REQUEST_SUBMITTED ||
577 mid_entry->command != smb_buffer->Command) {
583 check2ndT2(smb_buffer, server->maxBuf) > 0) {
584 /* We have a multipart transact2 resp */
586 if (mid_entry->resp_buf) {
587 /* merge response - fix up 1st*/
588 length = coalesce_t2(smb_buffer,
589 mid_entry->resp_buf);
592 mid_entry->multiRsp = true;
595 /* all parts received or
596 * packet is malformed
598 mid_entry->multiEnd = true;
604 * FIXME: switch to already
605 * allocated largebuf?
607 cERROR(1, "1st trans2 resp "
610 /* Have first buffer */
611 mid_entry->resp_buf =
613 mid_entry->largeBuf = true;
619 mid_entry->resp_buf = smb_buffer;
620 mid_entry->largeBuf = isLargeBuf;
623 mid_entry->midState = MID_RESPONSE_RECEIVED;
625 mid_entry->midState = MID_RESPONSE_MALFORMED;
626 #ifdef CONFIG_CIFS_STATS2
627 mid_entry->when_received = jiffies;
629 list_del_init(&mid_entry->qhead);
632 spin_unlock(&GlobalMid_Lock);
634 if (mid_entry != NULL) {
635 mid_entry->callback(mid_entry);
636 /* Was previous buf put in mpx struct for multi-rsp? */
638 /* smb buffer will be freed by user thread */
644 } else if (length != 0) {
645 /* response sanity checks failed */
647 } else if (!is_valid_oplock_break(smb_buffer, server) &&
649 cERROR(1, "No task to wake, unknown frame received! "
650 "NumMids %d", atomic_read(&midCount));
651 cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
652 sizeof(struct smb_hdr));
653 #ifdef CONFIG_CIFS_DEBUG2
654 cifs_dump_detail(smb_buffer);
655 cifs_dump_mids(server);
656 #endif /* CIFS_DEBUG2 */
659 } /* end while !EXITING */
661 /* take it off the list, if it's not already */
662 spin_lock(&cifs_tcp_ses_lock);
663 list_del_init(&server->tcp_ses_list);
664 spin_unlock(&cifs_tcp_ses_lock);
666 spin_lock(&GlobalMid_Lock);
667 server->tcpStatus = CifsExiting;
668 spin_unlock(&GlobalMid_Lock);
669 wake_up_all(&server->response_q);
671 /* check if we have blocked requests that need to free */
672 /* Note that cifs_max_pending is normally 50, but
673 can be set at module install time to as little as two */
674 spin_lock(&GlobalMid_Lock);
675 if (atomic_read(&server->inFlight) >= cifs_max_pending)
676 atomic_set(&server->inFlight, cifs_max_pending - 1);
677 /* We do not want to set the max_pending too low or we
678 could end up with the counter going negative */
679 spin_unlock(&GlobalMid_Lock);
680 /* Although there should not be any requests blocked on
681 this queue it can not hurt to be paranoid and try to wake up requests
682 that may haven been blocked when more than 50 at time were on the wire
683 to the same server - they now will see the session is in exit state
684 and get out of SendReceive. */
685 wake_up_all(&server->request_q);
686 /* give those requests time to exit */
689 if (server->ssocket) {
690 sock_release(csocket);
691 server->ssocket = NULL;
693 /* buffer usually freed in free_mid - need to free it here on exit */
694 cifs_buf_release(bigbuf);
695 if (smallbuf) /* no sense logging a debug message if NULL */
696 cifs_small_buf_release(smallbuf);
698 if (!list_empty(&server->pending_mid_q)) {
699 struct list_head dispose_list;
701 INIT_LIST_HEAD(&dispose_list);
702 spin_lock(&GlobalMid_Lock);
703 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
704 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
705 cFYI(1, "Clearing mid 0x%x", mid_entry->mid);
706 mid_entry->midState = MID_SHUTDOWN;
707 list_move(&mid_entry->qhead, &dispose_list);
709 spin_unlock(&GlobalMid_Lock);
711 /* now walk dispose list and issue callbacks */
712 list_for_each_safe(tmp, tmp2, &dispose_list) {
713 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
714 cFYI(1, "Callback mid 0x%x", mid_entry->mid);
715 list_del_init(&mid_entry->qhead);
716 mid_entry->callback(mid_entry);
718 /* 1/8th of sec is more than enough time for them to exit */
722 if (!list_empty(&server->pending_mid_q)) {
723 /* mpx threads have not exited yet give them
724 at least the smb send timeout time for long ops */
725 /* due to delays on oplock break requests, we need
726 to wait at least 45 seconds before giving up
727 on a request getting a response and going ahead
729 cFYI(1, "Wait for exit from demultiplex thread");
731 /* if threads still have not exited they are probably never
732 coming home not much else we can do but free the memory */
735 kfree(server->hostname);
736 task_to_wake = xchg(&server->tsk, NULL);
739 length = atomic_dec_return(&tcpSesAllocCount);
741 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
744 /* if server->tsk was NULL then wait for a signal before exiting */
746 set_current_state(TASK_INTERRUPTIBLE);
747 while (!signal_pending(current)) {
749 set_current_state(TASK_INTERRUPTIBLE);
751 set_current_state(TASK_RUNNING);
754 module_put_and_exit(0);
757 /* extract the host portion of the UNC string */
759 extract_hostname(const char *unc)
765 /* skip double chars at beginning of string */
766 /* BB: check validity of these bytes? */
769 /* delimiter between hostname and sharename is always '\\' now */
770 delim = strchr(src, '\\');
772 return ERR_PTR(-EINVAL);
775 dst = kmalloc((len + 1), GFP_KERNEL);
777 return ERR_PTR(-ENOMEM);
779 memcpy(dst, src, len);
786 cifs_parse_mount_options(const char *mountdata, const char *devname,
789 char *value, *data, *end;
790 char *mountdata_copy = NULL, *options;
791 unsigned int temp_len, i, j;
793 short int override_uid = -1;
794 short int override_gid = -1;
795 bool uid_specified = false;
796 bool gid_specified = false;
797 char *nodename = utsname()->nodename;
803 * does not have to be perfect mapping since field is
804 * informational, only used for servers that do not support
805 * port 445 and it can be overridden at mount time
807 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
808 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
809 vol->source_rfc1001_name[i] = toupper(nodename[i]);
811 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
812 /* null target name indicates to use *SMBSERVR default called name
813 if we end up sending RFC1001 session initialize */
814 vol->target_rfc1001_name[0] = 0;
815 vol->cred_uid = current_uid();
816 vol->linux_uid = current_uid();
817 vol->linux_gid = current_gid();
819 /* default to only allowing write access to owner of the mount */
820 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
822 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
823 /* default is always to request posix paths. */
824 vol->posix_paths = 1;
825 /* default to using server inode numbers where available */
828 vol->actimeo = CIFS_DEF_ACTIMEO;
831 goto cifs_parse_mount_err;
833 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
835 goto cifs_parse_mount_err;
837 options = mountdata_copy;
838 end = options + strlen(options);
839 if (strncmp(options, "sep=", 4) == 0) {
840 if (options[4] != 0) {
841 separator[0] = options[4];
844 cFYI(1, "Null separator not allowed");
848 while ((data = strsep(&options, separator)) != NULL) {
851 if ((value = strchr(data, '=')) != NULL)
854 /* Have to parse this before we parse for "user" */
855 if (strnicmp(data, "user_xattr", 10) == 0) {
857 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
859 } else if (strnicmp(data, "user", 4) == 0) {
862 "CIFS: invalid or missing username\n");
863 goto cifs_parse_mount_err;
864 } else if (!*value) {
865 /* null user, ie anonymous, authentication */
868 if (strnlen(value, MAX_USERNAME_SIZE) <
870 vol->username = kstrdup(value, GFP_KERNEL);
871 if (!vol->username) {
872 printk(KERN_WARNING "CIFS: no memory "
874 goto cifs_parse_mount_err;
877 printk(KERN_WARNING "CIFS: username too long\n");
878 goto cifs_parse_mount_err;
880 } else if (strnicmp(data, "pass", 4) == 0) {
882 vol->password = NULL;
884 } else if (value[0] == 0) {
885 /* check if string begins with double comma
886 since that would mean the password really
887 does start with a comma, and would not
888 indicate an empty string */
889 if (value[1] != separator[0]) {
890 vol->password = NULL;
894 temp_len = strlen(value);
895 /* removed password length check, NTLM passwords
896 can be arbitrarily long */
898 /* if comma in password, the string will be
899 prematurely null terminated. Commas in password are
900 specified across the cifs mount interface by a double
901 comma ie ,, and a comma used as in other cases ie ','
902 as a parameter delimiter/separator is single and due
903 to the strsep above is temporarily zeroed. */
905 /* NB: password legally can have multiple commas and
906 the only illegal character in a password is null */
908 if ((value[temp_len] == 0) &&
909 (value + temp_len < end) &&
910 (value[temp_len+1] == separator[0])) {
912 value[temp_len] = separator[0];
913 temp_len += 2; /* move after second comma */
914 while (value[temp_len] != 0) {
915 if (value[temp_len] == separator[0]) {
916 if (value[temp_len+1] ==
918 /* skip second comma */
921 /* single comma indicating start
928 if (value[temp_len] == 0) {
932 /* point option to start of next parm */
933 options = value + temp_len + 1;
935 /* go from value to value + temp_len condensing
936 double commas to singles. Note that this ends up
937 allocating a few bytes too many, which is ok */
938 vol->password = kzalloc(temp_len, GFP_KERNEL);
939 if (vol->password == NULL) {
940 printk(KERN_WARNING "CIFS: no memory "
942 goto cifs_parse_mount_err;
944 for (i = 0, j = 0; i < temp_len; i++, j++) {
945 vol->password[j] = value[i];
946 if (value[i] == separator[0]
947 && value[i+1] == separator[0]) {
948 /* skip second comma */
952 vol->password[j] = 0;
954 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
955 if (vol->password == NULL) {
956 printk(KERN_WARNING "CIFS: no memory "
958 goto cifs_parse_mount_err;
960 strcpy(vol->password, value);
962 } else if (!strnicmp(data, "ip", 2) ||
963 !strnicmp(data, "addr", 4)) {
964 if (!value || !*value) {
966 } else if (strnlen(value, INET6_ADDRSTRLEN) <
968 vol->UNCip = kstrdup(value, GFP_KERNEL);
970 printk(KERN_WARNING "CIFS: no memory "
972 goto cifs_parse_mount_err;
975 printk(KERN_WARNING "CIFS: ip address "
977 goto cifs_parse_mount_err;
979 } else if (strnicmp(data, "sec", 3) == 0) {
980 if (!value || !*value) {
981 cERROR(1, "no security value specified");
983 } else if (strnicmp(value, "krb5i", 5) == 0) {
984 vol->secFlg |= CIFSSEC_MAY_KRB5 |
986 } else if (strnicmp(value, "krb5p", 5) == 0) {
987 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
989 cERROR(1, "Krb5 cifs privacy not supported");
990 goto cifs_parse_mount_err;
991 } else if (strnicmp(value, "krb5", 4) == 0) {
992 vol->secFlg |= CIFSSEC_MAY_KRB5;
993 } else if (strnicmp(value, "ntlmsspi", 8) == 0) {
994 vol->secFlg |= CIFSSEC_MAY_NTLMSSP |
996 } else if (strnicmp(value, "ntlmssp", 7) == 0) {
997 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
998 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
999 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
1001 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
1002 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1003 } else if (strnicmp(value, "ntlmi", 5) == 0) {
1004 vol->secFlg |= CIFSSEC_MAY_NTLM |
1006 } else if (strnicmp(value, "ntlm", 4) == 0) {
1007 /* ntlm is default so can be turned off too */
1008 vol->secFlg |= CIFSSEC_MAY_NTLM;
1009 } else if (strnicmp(value, "nontlm", 6) == 0) {
1010 /* BB is there a better way to do this? */
1011 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1012 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1013 } else if (strnicmp(value, "lanman", 6) == 0) {
1014 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1016 } else if (strnicmp(value, "none", 4) == 0) {
1019 cERROR(1, "bad security option: %s", value);
1020 goto cifs_parse_mount_err;
1022 } else if (strnicmp(data, "vers", 3) == 0) {
1023 if (!value || !*value) {
1024 cERROR(1, "no protocol version specified"
1025 " after vers= mount option");
1026 } else if ((strnicmp(value, "cifs", 4) == 0) ||
1027 (strnicmp(value, "1", 1) == 0)) {
1028 /* this is the default */
1031 } else if ((strnicmp(data, "unc", 3) == 0)
1032 || (strnicmp(data, "target", 6) == 0)
1033 || (strnicmp(data, "path", 4) == 0)) {
1034 if (!value || !*value) {
1035 printk(KERN_WARNING "CIFS: invalid path to "
1036 "network resource\n");
1037 goto cifs_parse_mount_err;
1039 if ((temp_len = strnlen(value, 300)) < 300) {
1040 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1041 if (vol->UNC == NULL)
1042 goto cifs_parse_mount_err;
1043 strcpy(vol->UNC, value);
1044 if (strncmp(vol->UNC, "//", 2) == 0) {
1047 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1049 "CIFS: UNC Path does not begin "
1050 "with // or \\\\ \n");
1051 goto cifs_parse_mount_err;
1054 printk(KERN_WARNING "CIFS: UNC name too long\n");
1055 goto cifs_parse_mount_err;
1057 } else if ((strnicmp(data, "domain", 3) == 0)
1058 || (strnicmp(data, "workgroup", 5) == 0)) {
1059 if (!value || !*value) {
1060 printk(KERN_WARNING "CIFS: invalid domain name\n");
1061 goto cifs_parse_mount_err;
1063 /* BB are there cases in which a comma can be valid in
1064 a domain name and need special handling? */
1065 if (strnlen(value, 256) < 256) {
1066 vol->domainname = kstrdup(value, GFP_KERNEL);
1067 if (!vol->domainname) {
1068 printk(KERN_WARNING "CIFS: no memory "
1069 "for domainname\n");
1070 goto cifs_parse_mount_err;
1072 cFYI(1, "Domain name set");
1074 printk(KERN_WARNING "CIFS: domain name too "
1076 goto cifs_parse_mount_err;
1078 } else if (strnicmp(data, "srcaddr", 7) == 0) {
1079 vol->srcaddr.ss_family = AF_UNSPEC;
1081 if (!value || !*value) {
1082 printk(KERN_WARNING "CIFS: srcaddr value"
1083 " not specified.\n");
1084 goto cifs_parse_mount_err;
1086 i = cifs_convert_address((struct sockaddr *)&vol->srcaddr,
1087 value, strlen(value));
1089 printk(KERN_WARNING "CIFS: Could not parse"
1092 goto cifs_parse_mount_err;
1094 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1095 if (!value || !*value) {
1097 "CIFS: invalid path prefix\n");
1098 goto cifs_parse_mount_err;
1100 if ((temp_len = strnlen(value, 1024)) < 1024) {
1101 if (value[0] != '/')
1102 temp_len++; /* missing leading slash */
1103 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1104 if (vol->prepath == NULL)
1105 goto cifs_parse_mount_err;
1106 if (value[0] != '/') {
1107 vol->prepath[0] = '/';
1108 strcpy(vol->prepath+1, value);
1110 strcpy(vol->prepath, value);
1111 cFYI(1, "prefix path %s", vol->prepath);
1113 printk(KERN_WARNING "CIFS: prefix too long\n");
1114 goto cifs_parse_mount_err;
1116 } else if (strnicmp(data, "iocharset", 9) == 0) {
1117 if (!value || !*value) {
1118 printk(KERN_WARNING "CIFS: invalid iocharset "
1120 goto cifs_parse_mount_err;
1122 if (strnlen(value, 65) < 65) {
1123 if (strnicmp(value, "default", 7)) {
1124 vol->iocharset = kstrdup(value,
1127 if (!vol->iocharset) {
1128 printk(KERN_WARNING "CIFS: no "
1131 goto cifs_parse_mount_err;
1134 /* if iocharset not set then load_nls_default
1135 is used by caller */
1136 cFYI(1, "iocharset set to %s", value);
1138 printk(KERN_WARNING "CIFS: iocharset name "
1140 goto cifs_parse_mount_err;
1142 } else if (!strnicmp(data, "uid", 3) && value && *value) {
1143 vol->linux_uid = simple_strtoul(value, &value, 0);
1144 uid_specified = true;
1145 } else if (!strnicmp(data, "cruid", 5) && value && *value) {
1146 vol->cred_uid = simple_strtoul(value, &value, 0);
1147 } else if (!strnicmp(data, "forceuid", 8)) {
1149 } else if (!strnicmp(data, "noforceuid", 10)) {
1151 } else if (!strnicmp(data, "gid", 3) && value && *value) {
1152 vol->linux_gid = simple_strtoul(value, &value, 0);
1153 gid_specified = true;
1154 } else if (!strnicmp(data, "forcegid", 8)) {
1156 } else if (!strnicmp(data, "noforcegid", 10)) {
1158 } else if (strnicmp(data, "file_mode", 4) == 0) {
1159 if (value && *value) {
1161 simple_strtoul(value, &value, 0);
1163 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1164 if (value && *value) {
1166 simple_strtoul(value, &value, 0);
1168 } else if (strnicmp(data, "dirmode", 4) == 0) {
1169 if (value && *value) {
1171 simple_strtoul(value, &value, 0);
1173 } else if (strnicmp(data, "port", 4) == 0) {
1174 if (value && *value) {
1176 simple_strtoul(value, &value, 0);
1178 } else if (strnicmp(data, "rsize", 5) == 0) {
1179 if (value && *value) {
1181 simple_strtoul(value, &value, 0);
1183 } else if (strnicmp(data, "wsize", 5) == 0) {
1184 if (value && *value) {
1186 simple_strtoul(value, &value, 0);
1188 } else if (strnicmp(data, "sockopt", 5) == 0) {
1189 if (!value || !*value) {
1190 cERROR(1, "no socket option specified");
1192 } else if (strnicmp(value, "TCP_NODELAY", 11) == 0) {
1193 vol->sockopt_tcp_nodelay = 1;
1195 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1196 if (!value || !*value || (*value == ' ')) {
1197 cFYI(1, "invalid (empty) netbiosname");
1199 memset(vol->source_rfc1001_name, 0x20,
1202 * FIXME: are there cases in which a comma can
1203 * be valid in workstation netbios name (and
1204 * need special handling)?
1206 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1207 /* don't ucase netbiosname for user */
1210 vol->source_rfc1001_name[i] = value[i];
1212 /* The string has 16th byte zero still from
1213 set at top of the function */
1214 if (i == RFC1001_NAME_LEN && value[i] != 0)
1215 printk(KERN_WARNING "CIFS: netbiosname"
1216 " longer than 15 truncated.\n");
1218 } else if (strnicmp(data, "servern", 7) == 0) {
1219 /* servernetbiosname specified override *SMBSERVER */
1220 if (!value || !*value || (*value == ' ')) {
1221 cFYI(1, "empty server netbiosname specified");
1223 /* last byte, type, is 0x20 for servr type */
1224 memset(vol->target_rfc1001_name, 0x20,
1225 RFC1001_NAME_LEN_WITH_NULL);
1227 for (i = 0; i < 15; i++) {
1228 /* BB are there cases in which a comma can be
1229 valid in this workstation netbios name
1230 (and need special handling)? */
1232 /* user or mount helper must uppercase
1237 vol->target_rfc1001_name[i] =
1240 /* The string has 16th byte zero still from
1241 set at top of the function */
1242 if (i == RFC1001_NAME_LEN && value[i] != 0)
1243 printk(KERN_WARNING "CIFS: server net"
1244 "biosname longer than 15 truncated.\n");
1246 } else if (strnicmp(data, "actimeo", 7) == 0) {
1247 if (value && *value) {
1248 vol->actimeo = HZ * simple_strtoul(value,
1250 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1251 cERROR(1, "CIFS: attribute cache"
1252 "timeout too large");
1253 goto cifs_parse_mount_err;
1256 } else if (strnicmp(data, "credentials", 4) == 0) {
1258 } else if (strnicmp(data, "version", 3) == 0) {
1260 } else if (strnicmp(data, "guest", 5) == 0) {
1262 } else if (strnicmp(data, "rw", 2) == 0) {
1264 } else if (strnicmp(data, "ro", 2) == 0) {
1266 } else if (strnicmp(data, "noblocksend", 11) == 0) {
1267 vol->noblocksnd = 1;
1268 } else if (strnicmp(data, "noautotune", 10) == 0) {
1269 vol->noautotune = 1;
1270 } else if ((strnicmp(data, "suid", 4) == 0) ||
1271 (strnicmp(data, "nosuid", 6) == 0) ||
1272 (strnicmp(data, "exec", 4) == 0) ||
1273 (strnicmp(data, "noexec", 6) == 0) ||
1274 (strnicmp(data, "nodev", 5) == 0) ||
1275 (strnicmp(data, "noauto", 6) == 0) ||
1276 (strnicmp(data, "dev", 3) == 0)) {
1277 /* The mount tool or mount.cifs helper (if present)
1278 uses these opts to set flags, and the flags are read
1279 by the kernel vfs layer before we get here (ie
1280 before read super) so there is no point trying to
1281 parse these options again and set anything and it
1282 is ok to just ignore them */
1284 } else if (strnicmp(data, "hard", 4) == 0) {
1286 } else if (strnicmp(data, "soft", 4) == 0) {
1288 } else if (strnicmp(data, "perm", 4) == 0) {
1290 } else if (strnicmp(data, "noperm", 6) == 0) {
1292 } else if (strnicmp(data, "mapchars", 8) == 0) {
1294 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1296 } else if (strnicmp(data, "sfu", 3) == 0) {
1298 } else if (strnicmp(data, "nosfu", 5) == 0) {
1300 } else if (strnicmp(data, "nodfs", 5) == 0) {
1302 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1303 vol->posix_paths = 1;
1304 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1305 vol->posix_paths = 0;
1306 } else if (strnicmp(data, "nounix", 6) == 0) {
1307 vol->no_linux_ext = 1;
1308 } else if (strnicmp(data, "nolinux", 7) == 0) {
1309 vol->no_linux_ext = 1;
1310 } else if ((strnicmp(data, "nocase", 6) == 0) ||
1311 (strnicmp(data, "ignorecase", 10) == 0)) {
1313 } else if (strnicmp(data, "mand", 4) == 0) {
1315 } else if (strnicmp(data, "nomand", 6) == 0) {
1317 } else if (strnicmp(data, "_netdev", 7) == 0) {
1319 } else if (strnicmp(data, "brl", 3) == 0) {
1321 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1322 (strnicmp(data, "nolock", 6) == 0)) {
1324 /* turn off mandatory locking in mode
1325 if remote locking is turned off since the
1326 local vfs will do advisory */
1327 if (vol->file_mode ==
1328 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1329 vol->file_mode = S_IALLUGO;
1330 } else if (strnicmp(data, "forcemandatorylock", 9) == 0) {
1331 /* will take the shorter form "forcemand" as well */
1332 /* This mount option will force use of mandatory
1333 (DOS/Windows style) byte range locks, instead of
1334 using posix advisory byte range locks, even if the
1335 Unix extensions are available and posix locks would
1336 be supported otherwise. If Unix extensions are not
1337 negotiated this has no effect since mandatory locks
1338 would be used (mandatory locks is all that those
1339 those servers support) */
1341 } else if (strnicmp(data, "setuids", 7) == 0) {
1343 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1345 } else if (strnicmp(data, "dynperm", 7) == 0) {
1346 vol->dynperm = true;
1347 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1348 vol->dynperm = false;
1349 } else if (strnicmp(data, "nohard", 6) == 0) {
1351 } else if (strnicmp(data, "nosoft", 6) == 0) {
1353 } else if (strnicmp(data, "nointr", 6) == 0) {
1355 } else if (strnicmp(data, "intr", 4) == 0) {
1357 } else if (strnicmp(data, "nostrictsync", 12) == 0) {
1358 vol->nostrictsync = 1;
1359 } else if (strnicmp(data, "strictsync", 10) == 0) {
1360 vol->nostrictsync = 0;
1361 } else if (strnicmp(data, "serverino", 7) == 0) {
1362 vol->server_ino = 1;
1363 } else if (strnicmp(data, "noserverino", 9) == 0) {
1364 vol->server_ino = 0;
1365 } else if (strnicmp(data, "rwpidforward", 4) == 0) {
1366 vol->rwpidforward = 1;
1367 } else if (strnicmp(data, "cifsacl", 7) == 0) {
1369 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1371 } else if (strnicmp(data, "acl", 3) == 0) {
1372 vol->no_psx_acl = 0;
1373 } else if (strnicmp(data, "noacl", 5) == 0) {
1374 vol->no_psx_acl = 1;
1375 } else if (strnicmp(data, "locallease", 6) == 0) {
1376 vol->local_lease = 1;
1377 } else if (strnicmp(data, "sign", 4) == 0) {
1378 vol->secFlg |= CIFSSEC_MUST_SIGN;
1379 } else if (strnicmp(data, "seal", 4) == 0) {
1380 /* we do not do the following in secFlags because seal
1381 is a per tree connection (mount) not a per socket
1382 or per-smb connection option in the protocol */
1383 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1385 } else if (strnicmp(data, "direct", 6) == 0) {
1387 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
1389 } else if (strnicmp(data, "strictcache", 11) == 0) {
1391 } else if (strnicmp(data, "noac", 4) == 0) {
1392 printk(KERN_WARNING "CIFS: Mount option noac not "
1393 "supported. Instead set "
1394 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1395 } else if (strnicmp(data, "fsc", 3) == 0) {
1396 #ifndef CONFIG_CIFS_FSCACHE
1397 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE "
1398 "kernel config option set");
1399 goto cifs_parse_mount_err;
1402 } else if (strnicmp(data, "mfsymlinks", 10) == 0) {
1403 vol->mfsymlinks = true;
1404 } else if (strnicmp(data, "multiuser", 8) == 0) {
1405 vol->multiuser = true;
1407 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1410 if (vol->UNC == NULL) {
1411 if (devname == NULL) {
1412 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1414 goto cifs_parse_mount_err;
1416 if ((temp_len = strnlen(devname, 300)) < 300) {
1417 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1418 if (vol->UNC == NULL)
1419 goto cifs_parse_mount_err;
1420 strcpy(vol->UNC, devname);
1421 if (strncmp(vol->UNC, "//", 2) == 0) {
1424 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1425 printk(KERN_WARNING "CIFS: UNC Path does not "
1426 "begin with // or \\\\ \n");
1427 goto cifs_parse_mount_err;
1429 value = strpbrk(vol->UNC+2, "/\\");
1433 printk(KERN_WARNING "CIFS: UNC name too long\n");
1434 goto cifs_parse_mount_err;
1438 if (vol->multiuser && !(vol->secFlg & CIFSSEC_MAY_KRB5)) {
1439 cERROR(1, "Multiuser mounts currently require krb5 "
1441 goto cifs_parse_mount_err;
1444 if (vol->UNCip == NULL)
1445 vol->UNCip = &vol->UNC[2];
1448 vol->override_uid = override_uid;
1449 else if (override_uid == 1)
1450 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1451 "specified with no uid= option.\n");
1454 vol->override_gid = override_gid;
1455 else if (override_gid == 1)
1456 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1457 "specified with no gid= option.\n");
1459 kfree(mountdata_copy);
1462 cifs_parse_mount_err:
1463 kfree(mountdata_copy);
1467 /** Returns true if srcaddr isn't specified and rhs isn't
1468 * specified, or if srcaddr is specified and
1469 * matches the IP address of the rhs argument.
1472 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1474 switch (srcaddr->sa_family) {
1476 return (rhs->sa_family == AF_UNSPEC);
1478 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1479 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1480 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1483 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1484 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1485 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1489 return false; /* don't expect to be here */
1494 * If no port is specified in addr structure, we try to match with 445 port
1495 * and if it fails - with 139 ports. It should be called only if address
1496 * families of server and addr are equal.
1499 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1501 __be16 port, *sport;
1503 switch (addr->sa_family) {
1505 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1506 port = ((struct sockaddr_in *) addr)->sin_port;
1509 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1510 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1518 port = htons(CIFS_PORT);
1522 port = htons(RFC1001_PORT);
1525 return port == *sport;
1529 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1530 struct sockaddr *srcaddr)
1532 switch (addr->sa_family) {
1534 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1535 struct sockaddr_in *srv_addr4 =
1536 (struct sockaddr_in *)&server->dstaddr;
1538 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1543 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1544 struct sockaddr_in6 *srv_addr6 =
1545 (struct sockaddr_in6 *)&server->dstaddr;
1547 if (!ipv6_addr_equal(&addr6->sin6_addr,
1548 &srv_addr6->sin6_addr))
1550 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
1556 return false; /* don't expect to be here */
1559 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1566 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
1568 unsigned int secFlags;
1570 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
1571 secFlags = vol->secFlg;
1573 secFlags = global_secflags | vol->secFlg;
1575 switch (server->secType) {
1577 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
1581 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
1585 if (!(secFlags & CIFSSEC_MAY_NTLM))
1589 if (!(secFlags & CIFSSEC_MAY_KRB5))
1593 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
1597 /* shouldn't happen */
1601 /* now check if signing mode is acceptable */
1602 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
1603 (server->sec_mode & SECMODE_SIGN_REQUIRED))
1605 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
1607 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
1613 static int match_server(struct TCP_Server_Info *server, struct sockaddr *addr,
1614 struct smb_vol *vol)
1616 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
1619 if (!match_address(server, addr,
1620 (struct sockaddr *)&vol->srcaddr))
1623 if (!match_port(server, addr))
1626 if (!match_security(server, vol))
1632 static struct TCP_Server_Info *
1633 cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
1635 struct TCP_Server_Info *server;
1637 spin_lock(&cifs_tcp_ses_lock);
1638 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
1639 if (!match_server(server, addr, vol))
1642 ++server->srv_count;
1643 spin_unlock(&cifs_tcp_ses_lock);
1644 cFYI(1, "Existing tcp session with server found");
1647 spin_unlock(&cifs_tcp_ses_lock);
1652 cifs_put_tcp_session(struct TCP_Server_Info *server)
1654 struct task_struct *task;
1656 spin_lock(&cifs_tcp_ses_lock);
1657 if (--server->srv_count > 0) {
1658 spin_unlock(&cifs_tcp_ses_lock);
1662 put_net(cifs_net_ns(server));
1664 list_del_init(&server->tcp_ses_list);
1665 spin_unlock(&cifs_tcp_ses_lock);
1667 cancel_delayed_work_sync(&server->echo);
1669 spin_lock(&GlobalMid_Lock);
1670 server->tcpStatus = CifsExiting;
1671 spin_unlock(&GlobalMid_Lock);
1673 cifs_crypto_shash_release(server);
1674 cifs_fscache_release_client_cookie(server);
1676 kfree(server->session_key.response);
1677 server->session_key.response = NULL;
1678 server->session_key.len = 0;
1680 task = xchg(&server->tsk, NULL);
1682 force_sig(SIGKILL, task);
1685 static struct TCP_Server_Info *
1686 cifs_get_tcp_session(struct smb_vol *volume_info)
1688 struct TCP_Server_Info *tcp_ses = NULL;
1689 struct sockaddr_storage addr;
1690 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
1691 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
1694 memset(&addr, 0, sizeof(struct sockaddr_storage));
1696 cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
1698 if (volume_info->UNCip && volume_info->UNC) {
1699 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
1701 strlen(volume_info->UNCip),
1704 /* we failed translating address */
1708 } else if (volume_info->UNCip) {
1709 /* BB using ip addr as tcp_ses name to connect to the
1711 cERROR(1, "Connecting to DFS root not implemented yet");
1714 } else /* which tcp_sess DFS root would we conect to */ {
1715 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
1716 "unc=//192.168.1.100/public) specified");
1721 /* see if we already have a matching tcp_ses */
1722 tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
1726 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1732 rc = cifs_crypto_shash_allocate(tcp_ses);
1734 cERROR(1, "could not setup hash structures rc %d", rc);
1738 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
1739 tcp_ses->hostname = extract_hostname(volume_info->UNC);
1740 if (IS_ERR(tcp_ses->hostname)) {
1741 rc = PTR_ERR(tcp_ses->hostname);
1742 goto out_err_crypto_release;
1745 tcp_ses->noblocksnd = volume_info->noblocksnd;
1746 tcp_ses->noautotune = volume_info->noautotune;
1747 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
1748 atomic_set(&tcp_ses->inFlight, 0);
1749 init_waitqueue_head(&tcp_ses->response_q);
1750 init_waitqueue_head(&tcp_ses->request_q);
1751 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1752 mutex_init(&tcp_ses->srv_mutex);
1753 memcpy(tcp_ses->workstation_RFC1001_name,
1754 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1755 memcpy(tcp_ses->server_RFC1001_name,
1756 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1757 tcp_ses->session_estab = false;
1758 tcp_ses->sequence_number = 0;
1759 tcp_ses->lstrp = jiffies;
1760 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1761 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1762 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
1765 * at this point we are the only ones with the pointer
1766 * to the struct since the kernel thread not created yet
1767 * no need to spinlock this init of tcpStatus or srv_count
1769 tcp_ses->tcpStatus = CifsNew;
1770 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
1771 sizeof(tcp_ses->srcaddr));
1772 ++tcp_ses->srv_count;
1774 if (addr.ss_family == AF_INET6) {
1775 cFYI(1, "attempting ipv6 connect");
1776 /* BB should we allow ipv6 on port 139? */
1777 /* other OS never observed in Wild doing 139 with v6 */
1778 memcpy(&tcp_ses->dstaddr, sin_server6,
1779 sizeof(struct sockaddr_in6));
1781 memcpy(&tcp_ses->dstaddr, sin_server,
1782 sizeof(struct sockaddr_in));
1784 rc = ip_connect(tcp_ses);
1786 cERROR(1, "Error connecting to socket. Aborting operation");
1787 goto out_err_crypto_release;
1791 * since we're in a cifs function already, we know that
1792 * this will succeed. No need for try_module_get().
1794 __module_get(THIS_MODULE);
1795 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
1797 if (IS_ERR(tcp_ses->tsk)) {
1798 rc = PTR_ERR(tcp_ses->tsk);
1799 cERROR(1, "error %d create cifsd thread", rc);
1800 module_put(THIS_MODULE);
1801 goto out_err_crypto_release;
1803 tcp_ses->tcpStatus = CifsNeedNegotiate;
1805 /* thread spawned, put it on the list */
1806 spin_lock(&cifs_tcp_ses_lock);
1807 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
1808 spin_unlock(&cifs_tcp_ses_lock);
1810 cifs_fscache_get_client_cookie(tcp_ses);
1812 /* queue echo request delayed work */
1813 queue_delayed_work(system_nrt_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
1817 out_err_crypto_release:
1818 cifs_crypto_shash_release(tcp_ses);
1820 put_net(cifs_net_ns(tcp_ses));
1824 if (!IS_ERR(tcp_ses->hostname))
1825 kfree(tcp_ses->hostname);
1826 if (tcp_ses->ssocket)
1827 sock_release(tcp_ses->ssocket);
1833 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
1835 switch (ses->server->secType) {
1837 if (vol->cred_uid != ses->cred_uid)
1841 /* anything else takes username/password */
1842 if (ses->user_name == NULL)
1844 if (strncmp(ses->user_name, vol->username,
1847 if (strlen(vol->username) != 0 &&
1848 ses->password != NULL &&
1849 strncmp(ses->password,
1850 vol->password ? vol->password : "",
1857 static struct cifs_ses *
1858 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
1860 struct cifs_ses *ses;
1862 spin_lock(&cifs_tcp_ses_lock);
1863 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
1864 if (!match_session(ses, vol))
1867 spin_unlock(&cifs_tcp_ses_lock);
1870 spin_unlock(&cifs_tcp_ses_lock);
1875 cifs_put_smb_ses(struct cifs_ses *ses)
1878 struct TCP_Server_Info *server = ses->server;
1880 cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
1881 spin_lock(&cifs_tcp_ses_lock);
1882 if (--ses->ses_count > 0) {
1883 spin_unlock(&cifs_tcp_ses_lock);
1887 list_del_init(&ses->smb_ses_list);
1888 spin_unlock(&cifs_tcp_ses_lock);
1890 if (ses->status == CifsGood) {
1892 CIFSSMBLogoff(xid, ses);
1896 cifs_put_tcp_session(server);
1899 static bool warned_on_ntlm; /* globals init to false automatically */
1901 static struct cifs_ses *
1902 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
1904 int rc = -ENOMEM, xid;
1905 struct cifs_ses *ses;
1906 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
1907 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
1911 ses = cifs_find_smb_ses(server, volume_info);
1913 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
1915 mutex_lock(&ses->session_mutex);
1916 rc = cifs_negotiate_protocol(xid, ses);
1918 mutex_unlock(&ses->session_mutex);
1919 /* problem -- put our ses reference */
1920 cifs_put_smb_ses(ses);
1924 if (ses->need_reconnect) {
1925 cFYI(1, "Session needs reconnect");
1926 rc = cifs_setup_session(xid, ses,
1927 volume_info->local_nls);
1929 mutex_unlock(&ses->session_mutex);
1930 /* problem -- put our reference */
1931 cifs_put_smb_ses(ses);
1936 mutex_unlock(&ses->session_mutex);
1938 /* existing SMB ses has a server reference already */
1939 cifs_put_tcp_session(server);
1944 cFYI(1, "Existing smb sess not found");
1945 ses = sesInfoAlloc();
1949 /* new SMB session uses our server ref */
1950 ses->server = server;
1951 if (server->dstaddr.ss_family == AF_INET6)
1952 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
1954 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
1956 if (volume_info->username) {
1957 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
1958 if (!ses->user_name)
1962 /* volume_info->password freed at unmount */
1963 if (volume_info->password) {
1964 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
1968 if (volume_info->domainname) {
1969 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
1970 if (!ses->domainName)
1973 ses->cred_uid = volume_info->cred_uid;
1974 ses->linux_uid = volume_info->linux_uid;
1976 /* ntlmv2 is much stronger than ntlm security, and has been broadly
1977 supported for many years, time to update default security mechanism */
1978 if ((volume_info->secFlg == 0) && warned_on_ntlm == false) {
1979 warned_on_ntlm = true;
1980 cERROR(1, "default security mechanism requested. The default "
1981 "security mechanism will be upgraded from ntlm to "
1982 "ntlmv2 in kernel release 3.1");
1984 ses->overrideSecFlg = volume_info->secFlg;
1986 mutex_lock(&ses->session_mutex);
1987 rc = cifs_negotiate_protocol(xid, ses);
1989 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
1990 mutex_unlock(&ses->session_mutex);
1994 /* success, put it on the list */
1995 spin_lock(&cifs_tcp_ses_lock);
1996 list_add(&ses->smb_ses_list, &server->smb_ses_list);
1997 spin_unlock(&cifs_tcp_ses_lock);
2008 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2010 if (tcon->tidStatus == CifsExiting)
2012 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2017 static struct cifs_tcon *
2018 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2020 struct list_head *tmp;
2021 struct cifs_tcon *tcon;
2023 spin_lock(&cifs_tcp_ses_lock);
2024 list_for_each(tmp, &ses->tcon_list) {
2025 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2026 if (!match_tcon(tcon, unc))
2029 spin_unlock(&cifs_tcp_ses_lock);
2032 spin_unlock(&cifs_tcp_ses_lock);
2037 cifs_put_tcon(struct cifs_tcon *tcon)
2040 struct cifs_ses *ses = tcon->ses;
2042 cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2043 spin_lock(&cifs_tcp_ses_lock);
2044 if (--tcon->tc_count > 0) {
2045 spin_unlock(&cifs_tcp_ses_lock);
2049 list_del_init(&tcon->tcon_list);
2050 spin_unlock(&cifs_tcp_ses_lock);
2053 CIFSSMBTDis(xid, tcon);
2056 cifs_fscache_release_super_cookie(tcon);
2058 cifs_put_smb_ses(ses);
2061 static struct cifs_tcon *
2062 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2065 struct cifs_tcon *tcon;
2067 tcon = cifs_find_tcon(ses, volume_info->UNC);
2069 cFYI(1, "Found match on UNC path");
2070 /* existing tcon already has a reference */
2071 cifs_put_smb_ses(ses);
2072 if (tcon->seal != volume_info->seal)
2073 cERROR(1, "transport encryption setting "
2074 "conflicts with existing tid");
2078 tcon = tconInfoAlloc();
2085 if (volume_info->password) {
2086 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2087 if (!tcon->password) {
2093 if (strchr(volume_info->UNC + 3, '\\') == NULL
2094 && strchr(volume_info->UNC + 3, '/') == NULL) {
2095 cERROR(1, "Missing share name");
2100 /* BB Do we need to wrap session_mutex around
2101 * this TCon call and Unix SetFS as
2102 * we do on SessSetup and reconnect? */
2104 rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
2106 cFYI(1, "CIFS Tcon rc = %d", rc);
2110 if (volume_info->nodfs) {
2111 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2112 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2114 tcon->seal = volume_info->seal;
2115 /* we can have only one retry value for a connection
2116 to a share so for resources mounted more than once
2117 to the same server share the last value passed in
2118 for the retry flag is used */
2119 tcon->retry = volume_info->retry;
2120 tcon->nocase = volume_info->nocase;
2121 tcon->local_lease = volume_info->local_lease;
2123 spin_lock(&cifs_tcp_ses_lock);
2124 list_add(&tcon->tcon_list, &ses->tcon_list);
2125 spin_unlock(&cifs_tcp_ses_lock);
2127 cifs_fscache_get_super_cookie(tcon);
2137 cifs_put_tlink(struct tcon_link *tlink)
2139 if (!tlink || IS_ERR(tlink))
2142 if (!atomic_dec_and_test(&tlink->tl_count) ||
2143 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2144 tlink->tl_time = jiffies;
2148 if (!IS_ERR(tlink_tcon(tlink)))
2149 cifs_put_tcon(tlink_tcon(tlink));
2154 static inline struct tcon_link *
2155 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2157 return cifs_sb->master_tlink;
2161 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2163 struct cifs_sb_info *old = CIFS_SB(sb);
2164 struct cifs_sb_info *new = mnt_data->cifs_sb;
2166 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2169 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2170 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2173 if (old->rsize != new->rsize)
2177 * We want to share sb only if we don't specify wsize or specified wsize
2178 * is greater or equal than existing one.
2180 if (new->wsize && new->wsize < old->wsize)
2183 if (old->mnt_uid != new->mnt_uid || old->mnt_gid != new->mnt_gid)
2186 if (old->mnt_file_mode != new->mnt_file_mode ||
2187 old->mnt_dir_mode != new->mnt_dir_mode)
2190 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2193 if (old->actimeo != new->actimeo)
2200 cifs_match_super(struct super_block *sb, void *data)
2202 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2203 struct smb_vol *volume_info;
2204 struct cifs_sb_info *cifs_sb;
2205 struct TCP_Server_Info *tcp_srv;
2206 struct cifs_ses *ses;
2207 struct cifs_tcon *tcon;
2208 struct tcon_link *tlink;
2209 struct sockaddr_storage addr;
2212 memset(&addr, 0, sizeof(struct sockaddr_storage));
2214 spin_lock(&cifs_tcp_ses_lock);
2215 cifs_sb = CIFS_SB(sb);
2216 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2217 if (IS_ERR(tlink)) {
2218 spin_unlock(&cifs_tcp_ses_lock);
2221 tcon = tlink_tcon(tlink);
2223 tcp_srv = ses->server;
2225 volume_info = mnt_data->vol;
2227 if (!volume_info->UNCip || !volume_info->UNC)
2230 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
2232 strlen(volume_info->UNCip),
2237 if (!match_server(tcp_srv, (struct sockaddr *)&addr, volume_info) ||
2238 !match_session(ses, volume_info) ||
2239 !match_tcon(tcon, volume_info->UNC)) {
2244 rc = compare_mount_options(sb, mnt_data);
2246 spin_unlock(&cifs_tcp_ses_lock);
2247 cifs_put_tlink(tlink);
2252 get_dfs_path(int xid, struct cifs_ses *pSesInfo, const char *old_path,
2253 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
2254 struct dfs_info3_param **preferrals, int remap)
2259 *pnum_referrals = 0;
2262 if (pSesInfo->ipc_tid == 0) {
2263 temp_unc = kmalloc(2 /* for slashes */ +
2264 strnlen(pSesInfo->serverName,
2265 SERVER_NAME_LEN_WITH_NULL * 2)
2266 + 1 + 4 /* slash IPC$ */ + 2,
2268 if (temp_unc == NULL)
2272 strcpy(temp_unc + 2, pSesInfo->serverName);
2273 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2274 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
2275 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
2279 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
2280 pnum_referrals, nls_codepage, remap);
2281 /* BB map targetUNCs to dfs_info3 structures, here or
2282 in CIFSGetDFSRefer BB */
2287 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2288 static struct lock_class_key cifs_key[2];
2289 static struct lock_class_key cifs_slock_key[2];
2292 cifs_reclassify_socket4(struct socket *sock)
2294 struct sock *sk = sock->sk;
2295 BUG_ON(sock_owned_by_user(sk));
2296 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2297 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2301 cifs_reclassify_socket6(struct socket *sock)
2303 struct sock *sk = sock->sk;
2304 BUG_ON(sock_owned_by_user(sk));
2305 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2306 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2310 cifs_reclassify_socket4(struct socket *sock)
2315 cifs_reclassify_socket6(struct socket *sock)
2320 /* See RFC1001 section 14 on representation of Netbios names */
2321 static void rfc1002mangle(char *target, char *source, unsigned int length)
2325 for (i = 0, j = 0; i < (length); i++) {
2326 /* mask a nibble at a time and encode */
2327 target[j] = 'A' + (0x0F & (source[i] >> 4));
2328 target[j+1] = 'A' + (0x0F & source[i]);
2335 bind_socket(struct TCP_Server_Info *server)
2338 if (server->srcaddr.ss_family != AF_UNSPEC) {
2339 /* Bind to the specified local IP address */
2340 struct socket *socket = server->ssocket;
2341 rc = socket->ops->bind(socket,
2342 (struct sockaddr *) &server->srcaddr,
2343 sizeof(server->srcaddr));
2345 struct sockaddr_in *saddr4;
2346 struct sockaddr_in6 *saddr6;
2347 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2348 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2349 if (saddr6->sin6_family == AF_INET6)
2351 "Failed to bind to: %pI6c, error: %d\n",
2352 &saddr6->sin6_addr, rc);
2355 "Failed to bind to: %pI4, error: %d\n",
2356 &saddr4->sin_addr.s_addr, rc);
2363 ip_rfc1001_connect(struct TCP_Server_Info *server)
2367 * some servers require RFC1001 sessinit before sending
2368 * negprot - BB check reconnection in case where second
2369 * sessinit is sent but no second negprot
2371 struct rfc1002_session_packet *ses_init_buf;
2372 struct smb_hdr *smb_buf;
2373 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2376 ses_init_buf->trailer.session_req.called_len = 32;
2378 if (server->server_RFC1001_name &&
2379 server->server_RFC1001_name[0] != 0)
2380 rfc1002mangle(ses_init_buf->trailer.
2381 session_req.called_name,
2382 server->server_RFC1001_name,
2383 RFC1001_NAME_LEN_WITH_NULL);
2385 rfc1002mangle(ses_init_buf->trailer.
2386 session_req.called_name,
2387 DEFAULT_CIFS_CALLED_NAME,
2388 RFC1001_NAME_LEN_WITH_NULL);
2390 ses_init_buf->trailer.session_req.calling_len = 32;
2393 * calling name ends in null (byte 16) from old smb
2396 if (server->workstation_RFC1001_name &&
2397 server->workstation_RFC1001_name[0] != 0)
2398 rfc1002mangle(ses_init_buf->trailer.
2399 session_req.calling_name,
2400 server->workstation_RFC1001_name,
2401 RFC1001_NAME_LEN_WITH_NULL);
2403 rfc1002mangle(ses_init_buf->trailer.
2404 session_req.calling_name,
2406 RFC1001_NAME_LEN_WITH_NULL);
2408 ses_init_buf->trailer.session_req.scope1 = 0;
2409 ses_init_buf->trailer.session_req.scope2 = 0;
2410 smb_buf = (struct smb_hdr *)ses_init_buf;
2412 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2413 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
2414 rc = smb_send(server, smb_buf, 0x44);
2415 kfree(ses_init_buf);
2417 * RFC1001 layer in at least one server
2418 * requires very short break before negprot
2419 * presumably because not expecting negprot
2420 * to follow so fast. This is a simple
2421 * solution that works without
2422 * complicating the code and causes no
2423 * significant slowing down on mount
2426 usleep_range(1000, 2000);
2429 * else the negprot may still work without this
2430 * even though malloc failed
2437 generic_ip_connect(struct TCP_Server_Info *server)
2442 struct socket *socket = server->ssocket;
2443 struct sockaddr *saddr;
2445 saddr = (struct sockaddr *) &server->dstaddr;
2447 if (server->dstaddr.ss_family == AF_INET6) {
2448 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2449 slen = sizeof(struct sockaddr_in6);
2452 sport = ((struct sockaddr_in *) saddr)->sin_port;
2453 slen = sizeof(struct sockaddr_in);
2457 if (socket == NULL) {
2458 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2459 IPPROTO_TCP, &socket, 1);
2461 cERROR(1, "Error %d creating socket", rc);
2462 server->ssocket = NULL;
2466 /* BB other socket options to set KEEPALIVE, NODELAY? */
2467 cFYI(1, "Socket created");
2468 server->ssocket = socket;
2469 socket->sk->sk_allocation = GFP_NOFS;
2470 if (sfamily == AF_INET6)
2471 cifs_reclassify_socket6(socket);
2473 cifs_reclassify_socket4(socket);
2476 rc = bind_socket(server);
2481 * Eventually check for other socket options to change from
2482 * the default. sock_setsockopt not used because it expects
2485 socket->sk->sk_rcvtimeo = 7 * HZ;
2486 socket->sk->sk_sndtimeo = 5 * HZ;
2488 /* make the bufsizes depend on wsize/rsize and max requests */
2489 if (server->noautotune) {
2490 if (socket->sk->sk_sndbuf < (200 * 1024))
2491 socket->sk->sk_sndbuf = 200 * 1024;
2492 if (socket->sk->sk_rcvbuf < (140 * 1024))
2493 socket->sk->sk_rcvbuf = 140 * 1024;
2496 if (server->tcp_nodelay) {
2498 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2499 (char *)&val, sizeof(val));
2501 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
2504 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
2505 socket->sk->sk_sndbuf,
2506 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
2508 rc = socket->ops->connect(socket, saddr, slen, 0);
2510 cFYI(1, "Error %d connecting to server", rc);
2511 sock_release(socket);
2512 server->ssocket = NULL;
2516 if (sport == htons(RFC1001_PORT))
2517 rc = ip_rfc1001_connect(server);
2523 ip_connect(struct TCP_Server_Info *server)
2526 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2527 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2529 if (server->dstaddr.ss_family == AF_INET6)
2530 sport = &addr6->sin6_port;
2532 sport = &addr->sin_port;
2537 /* try with 445 port at first */
2538 *sport = htons(CIFS_PORT);
2540 rc = generic_ip_connect(server);
2544 /* if it failed, try with 139 port */
2545 *sport = htons(RFC1001_PORT);
2548 return generic_ip_connect(server);
2551 void reset_cifs_unix_caps(int xid, struct cifs_tcon *tcon,
2552 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
2554 /* if we are reconnecting then should we check to see if
2555 * any requested capabilities changed locally e.g. via
2556 * remount but we can not do much about it here
2557 * if they have (even if we could detect it by the following)
2558 * Perhaps we could add a backpointer to array of sb from tcon
2559 * or if we change to make all sb to same share the same
2560 * sb as NFS - then we only have one backpointer to sb.
2561 * What if we wanted to mount the server share twice once with
2562 * and once without posixacls or posix paths? */
2563 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2565 if (vol_info && vol_info->no_linux_ext) {
2566 tcon->fsUnixInfo.Capability = 0;
2567 tcon->unix_ext = 0; /* Unix Extensions disabled */
2568 cFYI(1, "Linux protocol extensions disabled");
2570 } else if (vol_info)
2571 tcon->unix_ext = 1; /* Unix Extensions supported */
2573 if (tcon->unix_ext == 0) {
2574 cFYI(1, "Unix extensions disabled so not set on reconnect");
2578 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
2579 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2580 cFYI(1, "unix caps which server supports %lld", cap);
2581 /* check for reconnect case in which we do not
2582 want to change the mount behavior if we can avoid it */
2583 if (vol_info == NULL) {
2584 /* turn off POSIX ACL and PATHNAMES if not set
2585 originally at mount time */
2586 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2587 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2588 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2589 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2590 cERROR(1, "POSIXPATH support change");
2591 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2592 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2593 cERROR(1, "possible reconnect error");
2594 cERROR(1, "server disabled POSIX path support");
2598 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
2599 cERROR(1, "per-share encryption not supported yet");
2601 cap &= CIFS_UNIX_CAP_MASK;
2602 if (vol_info && vol_info->no_psx_acl)
2603 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2604 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
2605 cFYI(1, "negotiated posix acl support");
2607 cifs_sb->mnt_cifs_flags |=
2608 CIFS_MOUNT_POSIXACL;
2611 if (vol_info && vol_info->posix_paths == 0)
2612 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2613 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2614 cFYI(1, "negotiate posix pathnames");
2616 cifs_sb->mnt_cifs_flags |=
2617 CIFS_MOUNT_POSIX_PATHS;
2620 if (cifs_sb && (cifs_sb->rsize > 127 * 1024)) {
2621 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
2622 cifs_sb->rsize = 127 * 1024;
2623 cFYI(DBG2, "larger reads not supported by srv");
2628 cFYI(1, "Negotiate caps 0x%x", (int)cap);
2629 #ifdef CONFIG_CIFS_DEBUG2
2630 if (cap & CIFS_UNIX_FCNTL_CAP)
2631 cFYI(1, "FCNTL cap");
2632 if (cap & CIFS_UNIX_EXTATTR_CAP)
2633 cFYI(1, "EXTATTR cap");
2634 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2635 cFYI(1, "POSIX path cap");
2636 if (cap & CIFS_UNIX_XATTR_CAP)
2637 cFYI(1, "XATTR cap");
2638 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
2639 cFYI(1, "POSIX ACL cap");
2640 if (cap & CIFS_UNIX_LARGE_READ_CAP)
2641 cFYI(1, "very large read cap");
2642 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
2643 cFYI(1, "very large write cap");
2644 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
2645 cFYI(1, "transport encryption cap");
2646 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
2647 cFYI(1, "mandatory transport encryption cap");
2648 #endif /* CIFS_DEBUG2 */
2649 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
2650 if (vol_info == NULL) {
2651 cFYI(1, "resetting capabilities failed");
2653 cERROR(1, "Negotiating Unix capabilities "
2654 "with the server failed. Consider "
2655 "mounting with the Unix Extensions\n"
2656 "disabled, if problems are found, "
2657 "by specifying the nounix mount "
2664 void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
2665 struct cifs_sb_info *cifs_sb)
2667 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
2669 spin_lock_init(&cifs_sb->tlink_tree_lock);
2670 cifs_sb->tlink_tree = RB_ROOT;
2672 if (pvolume_info->rsize > CIFSMaxBufSize) {
2673 cERROR(1, "rsize %d too large, using MaxBufSize",
2674 pvolume_info->rsize);
2675 cifs_sb->rsize = CIFSMaxBufSize;
2676 } else if ((pvolume_info->rsize) &&
2677 (pvolume_info->rsize <= CIFSMaxBufSize))
2678 cifs_sb->rsize = pvolume_info->rsize;
2680 cifs_sb->rsize = CIFSMaxBufSize;
2682 if (cifs_sb->rsize < 2048) {
2683 cifs_sb->rsize = 2048;
2684 /* Windows ME may prefer this */
2685 cFYI(1, "readsize set to minimum: 2048");
2689 * Temporarily set wsize for matching superblock. If we end up using
2690 * new sb then cifs_negotiate_wsize will later negotiate it downward
2693 cifs_sb->wsize = pvolume_info->wsize;
2695 cifs_sb->mnt_uid = pvolume_info->linux_uid;
2696 cifs_sb->mnt_gid = pvolume_info->linux_gid;
2697 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2698 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
2699 cFYI(1, "file mode: 0x%x dir mode: 0x%x",
2700 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
2702 cifs_sb->actimeo = pvolume_info->actimeo;
2703 cifs_sb->local_nls = pvolume_info->local_nls;
2705 if (pvolume_info->noperm)
2706 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2707 if (pvolume_info->setuids)
2708 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2709 if (pvolume_info->server_ino)
2710 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2711 if (pvolume_info->remap)
2712 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2713 if (pvolume_info->no_xattr)
2714 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2715 if (pvolume_info->sfu_emul)
2716 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2717 if (pvolume_info->nobrl)
2718 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2719 if (pvolume_info->nostrictsync)
2720 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
2721 if (pvolume_info->mand_lock)
2722 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
2723 if (pvolume_info->rwpidforward)
2724 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
2725 if (pvolume_info->cifs_acl)
2726 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2727 if (pvolume_info->override_uid)
2728 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2729 if (pvolume_info->override_gid)
2730 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2731 if (pvolume_info->dynperm)
2732 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2733 if (pvolume_info->fsc)
2734 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
2735 if (pvolume_info->multiuser)
2736 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
2737 CIFS_MOUNT_NO_PERM);
2738 if (pvolume_info->strict_io)
2739 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
2740 if (pvolume_info->direct_io) {
2741 cFYI(1, "mounting share using direct i/o");
2742 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2744 if (pvolume_info->mfsymlinks) {
2745 if (pvolume_info->sfu_emul) {
2746 cERROR(1, "mount option mfsymlinks ignored if sfu "
2747 "mount option is used");
2749 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
2753 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
2754 cERROR(1, "mount option dynperm ignored if cifsacl "
2755 "mount option supported");
2759 * When the server supports very large writes via POSIX extensions, we can
2760 * allow up to 2^24-1, minus the size of a WRITE_AND_X header, not including
2761 * the RFC1001 length.
2763 * Note that this might make for "interesting" allocation problems during
2764 * writeback however as we have to allocate an array of pointers for the
2765 * pages. A 16M write means ~32kb page array with PAGE_CACHE_SIZE == 4096.
2767 #define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
2770 * When the server doesn't allow large posix writes, only allow a wsize of
2771 * 128k minus the size of the WRITE_AND_X header. That allows for a write up
2772 * to the maximum size described by RFC1002.
2774 #define CIFS_MAX_RFC1002_WSIZE (128 * 1024 - sizeof(WRITE_REQ) + 4)
2777 * The default wsize is 1M. find_get_pages seems to return a maximum of 256
2778 * pages in a single call. With PAGE_CACHE_SIZE == 4k, this means we can fill
2779 * a single wsize request with a single call.
2781 #define CIFS_DEFAULT_WSIZE (1024 * 1024)
2784 cifs_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
2786 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2787 struct TCP_Server_Info *server = tcon->ses->server;
2788 unsigned int wsize = pvolume_info->wsize ? pvolume_info->wsize :
2791 /* can server support 24-bit write sizes? (via UNIX extensions) */
2792 if (!tcon->unix_ext || !(unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
2793 wsize = min_t(unsigned int, wsize, CIFS_MAX_RFC1002_WSIZE);
2796 * no CAP_LARGE_WRITE_X or is signing enabled without CAP_UNIX set?
2797 * Limit it to max buffer offered by the server, minus the size of the
2798 * WRITEX header, not including the 4 byte RFC1001 length.
2800 if (!(server->capabilities & CAP_LARGE_WRITE_X) ||
2801 (!(server->capabilities & CAP_UNIX) &&
2802 (server->sec_mode & (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED))))
2803 wsize = min_t(unsigned int, wsize,
2804 server->maxBuf - sizeof(WRITE_REQ) + 4);
2806 /* hard limit of CIFS_MAX_WSIZE */
2807 wsize = min_t(unsigned int, wsize, CIFS_MAX_WSIZE);
2813 is_path_accessible(int xid, struct cifs_tcon *tcon,
2814 struct cifs_sb_info *cifs_sb, const char *full_path)
2817 FILE_ALL_INFO *pfile_info;
2819 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
2820 if (pfile_info == NULL)
2823 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
2824 0 /* not legacy */, cifs_sb->local_nls,
2825 cifs_sb->mnt_cifs_flags &
2826 CIFS_MOUNT_MAP_SPECIAL_CHR);
2828 if (rc == -EOPNOTSUPP || rc == -EINVAL)
2829 rc = SMBQueryInformation(xid, tcon, full_path, pfile_info,
2830 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
2831 CIFS_MOUNT_MAP_SPECIAL_CHR);
2837 cleanup_volume_info_contents(struct smb_vol *volume_info)
2839 kfree(volume_info->username);
2840 kzfree(volume_info->password);
2841 kfree(volume_info->UNC);
2842 kfree(volume_info->UNCip);
2843 kfree(volume_info->domainname);
2844 kfree(volume_info->iocharset);
2845 kfree(volume_info->prepath);
2849 cifs_cleanup_volume_info(struct smb_vol *volume_info)
2853 cleanup_volume_info_contents(volume_info);
2858 #ifdef CONFIG_CIFS_DFS_UPCALL
2859 /* build_path_to_root returns full path to root when
2860 * we do not have an exiting connection (tcon) */
2862 build_unc_path_to_root(const struct smb_vol *vol,
2863 const struct cifs_sb_info *cifs_sb)
2865 char *full_path, *pos;
2866 unsigned int pplen = vol->prepath ? strlen(vol->prepath) : 0;
2867 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
2869 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
2870 if (full_path == NULL)
2871 return ERR_PTR(-ENOMEM);
2873 strncpy(full_path, vol->UNC, unc_len);
2874 pos = full_path + unc_len;
2877 strncpy(pos, vol->prepath, pplen);
2881 *pos = '\0'; /* add trailing null */
2882 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
2883 cFYI(1, "%s: full_path=%s", __func__, full_path);
2888 * Perform a dfs referral query for a share and (optionally) prefix
2890 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
2891 * to a string containing updated options for the submount. Otherwise it
2892 * will be left untouched.
2894 * Returns the rc from get_dfs_path to the caller, which can be used to
2895 * determine whether there were referrals.
2898 expand_dfs_referral(int xid, struct cifs_ses *pSesInfo,
2899 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
2903 unsigned int num_referrals = 0;
2904 struct dfs_info3_param *referrals = NULL;
2905 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
2907 full_path = build_unc_path_to_root(volume_info, cifs_sb);
2908 if (IS_ERR(full_path))
2909 return PTR_ERR(full_path);
2911 /* For DFS paths, skip the first '\' of the UNC */
2912 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
2914 rc = get_dfs_path(xid, pSesInfo , ref_path, cifs_sb->local_nls,
2915 &num_referrals, &referrals,
2916 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
2918 if (!rc && num_referrals > 0) {
2919 char *fake_devname = NULL;
2921 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
2922 full_path + 1, referrals,
2925 free_dfs_info_array(referrals, num_referrals);
2927 if (IS_ERR(mdata)) {
2928 rc = PTR_ERR(mdata);
2931 cleanup_volume_info_contents(volume_info);
2932 memset(volume_info, '\0', sizeof(*volume_info));
2933 rc = cifs_setup_volume_info(volume_info, mdata,
2936 kfree(fake_devname);
2937 kfree(cifs_sb->mountdata);
2938 cifs_sb->mountdata = mdata;
2946 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
2947 const char *devname)
2951 if (cifs_parse_mount_options(mount_data, devname, volume_info))
2954 if (volume_info->nullauth) {
2955 cFYI(1, "null user");
2956 volume_info->username = kzalloc(1, GFP_KERNEL);
2957 if (volume_info->username == NULL)
2959 } else if (volume_info->username) {
2960 /* BB fixme parse for domain name here */
2961 cFYI(1, "Username: %s", volume_info->username);
2963 cifserror("No username specified");
2964 /* In userspace mount helper we can get user name from alternate
2965 locations such as env variables and files on disk */
2969 /* this is needed for ASCII cp to Unicode converts */
2970 if (volume_info->iocharset == NULL) {
2971 /* load_nls_default cannot return null */
2972 volume_info->local_nls = load_nls_default();
2974 volume_info->local_nls = load_nls(volume_info->iocharset);
2975 if (volume_info->local_nls == NULL) {
2976 cERROR(1, "CIFS mount error: iocharset %s not found",
2977 volume_info->iocharset);
2986 cifs_get_volume_info(char *mount_data, const char *devname)
2989 struct smb_vol *volume_info;
2991 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
2993 return ERR_PTR(-ENOMEM);
2995 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
2997 cifs_cleanup_volume_info(volume_info);
2998 volume_info = ERR_PTR(rc);
3005 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3009 struct cifs_ses *pSesInfo;
3010 struct cifs_tcon *tcon;
3011 struct TCP_Server_Info *srvTcp;
3013 struct tcon_link *tlink;
3014 #ifdef CONFIG_CIFS_DFS_UPCALL
3015 int referral_walks_count = 0;
3018 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3022 cifs_sb->bdi.ra_pages = default_backing_dev_info.ra_pages;
3024 #ifdef CONFIG_CIFS_DFS_UPCALL
3026 /* cleanup activities if we're chasing a referral */
3027 if (referral_walks_count) {
3029 cifs_put_tcon(tcon);
3031 cifs_put_smb_ses(pSesInfo);
3044 /* get a reference to a tcp session */
3045 srvTcp = cifs_get_tcp_session(volume_info);
3046 if (IS_ERR(srvTcp)) {
3047 rc = PTR_ERR(srvTcp);
3048 bdi_destroy(&cifs_sb->bdi);
3052 /* get a reference to a SMB session */
3053 pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
3054 if (IS_ERR(pSesInfo)) {
3055 rc = PTR_ERR(pSesInfo);
3057 goto mount_fail_check;
3060 /* search for existing tcon to this server share */
3061 tcon = cifs_get_tcon(pSesInfo, volume_info);
3065 goto remote_path_check;
3068 /* tell server which Unix caps we support */
3069 if (tcon->ses->capabilities & CAP_UNIX) {
3070 /* reset of caps checks mount to see if unix extensions
3071 disabled for just this mount */
3072 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3073 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3074 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3075 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3077 goto mount_fail_check;
3080 tcon->unix_ext = 0; /* server does not support them */
3082 /* do not care if following two calls succeed - informational */
3084 CIFSSMBQFSDeviceInfo(xid, tcon);
3085 CIFSSMBQFSAttributeInfo(xid, tcon);
3088 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
3089 cifs_sb->rsize = 1024 * 127;
3090 cFYI(DBG2, "no very large read support, rsize now 127K");
3092 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
3093 cifs_sb->rsize = min(cifs_sb->rsize,
3094 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
3096 cifs_sb->wsize = cifs_negotiate_wsize(tcon, volume_info);
3099 #ifdef CONFIG_CIFS_DFS_UPCALL
3101 * Perform an unconditional check for whether there are DFS
3102 * referrals for this path without prefix, to provide support
3103 * for DFS referrals from w2k8 servers which don't seem to respond
3104 * with PATH_NOT_COVERED to requests that include the prefix.
3105 * Chase the referral if found, otherwise continue normally.
3107 if (referral_walks_count == 0) {
3108 int refrc = expand_dfs_referral(xid, pSesInfo, volume_info,
3111 referral_walks_count++;
3112 goto try_mount_again;
3117 /* check if a whole path is not remote */
3119 /* build_path_to_root works only when we have a valid tcon */
3120 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3121 if (full_path == NULL) {
3123 goto mount_fail_check;
3125 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
3126 if (rc != 0 && rc != -EREMOTE) {
3128 goto mount_fail_check;
3133 /* get referral if needed */
3134 if (rc == -EREMOTE) {
3135 #ifdef CONFIG_CIFS_DFS_UPCALL
3136 if (referral_walks_count > MAX_NESTED_LINKS) {
3138 * BB: when we implement proper loop detection,
3139 * we will remove this check. But now we need it
3140 * to prevent an indefinite loop if 'DFS tree' is
3141 * misconfigured (i.e. has loops).
3144 goto mount_fail_check;
3147 rc = expand_dfs_referral(xid, pSesInfo, volume_info, cifs_sb,
3151 referral_walks_count++;
3152 goto try_mount_again;
3154 goto mount_fail_check;
3155 #else /* No DFS support, return error on mount */
3161 goto mount_fail_check;
3163 /* now, hang the tcon off of the superblock */
3164 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3165 if (tlink == NULL) {
3167 goto mount_fail_check;
3170 tlink->tl_uid = pSesInfo->linux_uid;
3171 tlink->tl_tcon = tcon;
3172 tlink->tl_time = jiffies;
3173 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3174 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3176 cifs_sb->master_tlink = tlink;
3177 spin_lock(&cifs_sb->tlink_tree_lock);
3178 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3179 spin_unlock(&cifs_sb->tlink_tree_lock);
3181 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
3185 /* on error free sesinfo and tcon struct if needed */
3187 /* If find_unc succeeded then rc == 0 so we can not end */
3188 /* up accidentally freeing someone elses tcon struct */
3190 cifs_put_tcon(tcon);
3192 cifs_put_smb_ses(pSesInfo);
3194 cifs_put_tcp_session(srvTcp);
3195 bdi_destroy(&cifs_sb->bdi);
3204 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3205 * pointer may be NULL.
3208 CIFSTCon(unsigned int xid, struct cifs_ses *ses,
3209 const char *tree, struct cifs_tcon *tcon,
3210 const struct nls_table *nls_codepage)
3212 struct smb_hdr *smb_buffer;
3213 struct smb_hdr *smb_buffer_response;
3216 unsigned char *bcc_ptr;
3219 __u16 bytes_left, count;
3224 smb_buffer = cifs_buf_get();
3225 if (smb_buffer == NULL)
3228 smb_buffer_response = smb_buffer;
3230 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3231 NULL /*no tid */ , 4 /*wct */ );
3233 smb_buffer->Mid = GetNextMid(ses->server);
3234 smb_buffer->Uid = ses->Suid;
3235 pSMB = (TCONX_REQ *) smb_buffer;
3236 pSMBr = (TCONX_RSP *) smb_buffer_response;
3238 pSMB->AndXCommand = 0xFF;
3239 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3240 bcc_ptr = &pSMB->Password[0];
3241 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3242 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3243 *bcc_ptr = 0; /* password is null byte */
3244 bcc_ptr++; /* skip password */
3245 /* already aligned so no need to do it below */
3247 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3248 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3249 specified as required (when that support is added to
3250 the vfs in the future) as only NTLM or the much
3251 weaker LANMAN (which we do not send by default) is accepted
3252 by Samba (not sure whether other servers allow
3253 NTLMv2 password here) */
3254 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3255 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3256 (ses->server->secType == LANMAN))
3257 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3258 ses->server->sec_mode &
3259 SECMODE_PW_ENCRYPT ? true : false,
3262 #endif /* CIFS_WEAK_PW_HASH */
3263 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3266 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3267 if (ses->capabilities & CAP_UNICODE) {
3268 /* must align unicode strings */
3269 *bcc_ptr = 0; /* null byte password */
3274 if (ses->server->sec_mode &
3275 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3276 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3278 if (ses->capabilities & CAP_STATUS32) {
3279 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3281 if (ses->capabilities & CAP_DFS) {
3282 smb_buffer->Flags2 |= SMBFLG2_DFS;
3284 if (ses->capabilities & CAP_UNICODE) {
3285 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3287 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3288 6 /* max utf8 char length in bytes */ *
3289 (/* server len*/ + 256 /* share len */), nls_codepage);
3290 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3291 bcc_ptr += 2; /* skip trailing null */
3292 } else { /* ASCII */
3293 strcpy(bcc_ptr, tree);
3294 bcc_ptr += strlen(tree) + 1;
3296 strcpy(bcc_ptr, "?????");
3297 bcc_ptr += strlen("?????");
3299 count = bcc_ptr - &pSMB->Password[0];
3300 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3301 pSMB->hdr.smb_buf_length) + count);
3302 pSMB->ByteCount = cpu_to_le16(count);
3304 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3307 /* above now done in SendReceive */
3308 if ((rc == 0) && (tcon != NULL)) {
3311 tcon->tidStatus = CifsGood;
3312 tcon->need_reconnect = false;
3313 tcon->tid = smb_buffer_response->Tid;
3314 bcc_ptr = pByteArea(smb_buffer_response);
3315 bytes_left = get_bcc(smb_buffer_response);
3316 length = strnlen(bcc_ptr, bytes_left - 2);
3317 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3323 /* skip service field (NB: this field is always ASCII) */
3325 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3326 (bcc_ptr[2] == 'C')) {
3327 cFYI(1, "IPC connection");
3330 } else if (length == 2) {
3331 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3332 /* the most common case */
3333 cFYI(1, "disk share connection");
3336 bcc_ptr += length + 1;
3337 bytes_left -= (length + 1);
3338 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3340 /* mostly informational -- no need to fail on error here */
3341 kfree(tcon->nativeFileSystem);
3342 tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
3343 bytes_left, is_unicode,
3346 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
3348 if ((smb_buffer_response->WordCount == 3) ||
3349 (smb_buffer_response->WordCount == 7))
3350 /* field is in same location */
3351 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3354 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
3355 } else if ((rc == 0) && tcon == NULL) {
3356 /* all we need to save for IPC$ connection */
3357 ses->ipc_tid = smb_buffer_response->Tid;
3360 cifs_buf_release(smb_buffer);
3365 cifs_umount(struct cifs_sb_info *cifs_sb)
3367 struct rb_root *root = &cifs_sb->tlink_tree;
3368 struct rb_node *node;
3369 struct tcon_link *tlink;
3371 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3373 spin_lock(&cifs_sb->tlink_tree_lock);
3374 while ((node = rb_first(root))) {
3375 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3376 cifs_get_tlink(tlink);
3377 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3378 rb_erase(node, root);
3380 spin_unlock(&cifs_sb->tlink_tree_lock);
3381 cifs_put_tlink(tlink);
3382 spin_lock(&cifs_sb->tlink_tree_lock);
3384 spin_unlock(&cifs_sb->tlink_tree_lock);
3386 bdi_destroy(&cifs_sb->bdi);
3387 kfree(cifs_sb->mountdata);
3388 unload_nls(cifs_sb->local_nls);
3392 int cifs_negotiate_protocol(unsigned int xid, struct cifs_ses *ses)
3395 struct TCP_Server_Info *server = ses->server;
3397 /* only send once per connect */
3398 if (server->maxBuf != 0)
3401 rc = CIFSSMBNegotiate(xid, ses);
3402 if (rc == -EAGAIN) {
3403 /* retry only once on 1st time connection */
3404 rc = CIFSSMBNegotiate(xid, ses);
3409 spin_lock(&GlobalMid_Lock);
3410 if (server->tcpStatus == CifsNeedNegotiate)
3411 server->tcpStatus = CifsGood;
3414 spin_unlock(&GlobalMid_Lock);
3422 int cifs_setup_session(unsigned int xid, struct cifs_ses *ses,
3423 struct nls_table *nls_info)
3426 struct TCP_Server_Info *server = ses->server;
3429 ses->capabilities = server->capabilities;
3430 if (linuxExtEnabled == 0)
3431 ses->capabilities &= (~CAP_UNIX);
3433 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3434 server->sec_mode, server->capabilities, server->timeAdj);
3436 rc = CIFS_SessSetup(xid, ses, nls_info);
3438 cERROR(1, "Send error in SessSetup = %d", rc);
3440 mutex_lock(&ses->server->srv_mutex);
3441 if (!server->session_estab) {
3442 server->session_key.response = ses->auth_key.response;
3443 server->session_key.len = ses->auth_key.len;
3444 server->sequence_number = 0x2;
3445 server->session_estab = true;
3446 ses->auth_key.response = NULL;
3448 mutex_unlock(&server->srv_mutex);
3450 cFYI(1, "CIFS Session Established successfully");
3451 spin_lock(&GlobalMid_Lock);
3452 ses->status = CifsGood;
3453 ses->need_reconnect = false;
3454 spin_unlock(&GlobalMid_Lock);
3457 kfree(ses->auth_key.response);
3458 ses->auth_key.response = NULL;
3459 ses->auth_key.len = 0;
3460 kfree(ses->ntlmssp);
3461 ses->ntlmssp = NULL;
3466 static struct cifs_tcon *
3467 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
3469 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3470 struct cifs_ses *ses;
3471 struct cifs_tcon *tcon = NULL;
3472 struct smb_vol *vol_info;
3473 char username[28]; /* big enough for "krb50x" + hex of ULONG_MAX 6+16 */
3474 /* We used to have this as MAX_USERNAME which is */
3475 /* way too big now (256 instead of 32) */
3477 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3478 if (vol_info == NULL) {
3479 tcon = ERR_PTR(-ENOMEM);
3483 snprintf(username, sizeof(username), "krb50x%x", fsuid);
3484 vol_info->username = username;
3485 vol_info->local_nls = cifs_sb->local_nls;
3486 vol_info->linux_uid = fsuid;
3487 vol_info->cred_uid = fsuid;
3488 vol_info->UNC = master_tcon->treeName;
3489 vol_info->retry = master_tcon->retry;
3490 vol_info->nocase = master_tcon->nocase;
3491 vol_info->local_lease = master_tcon->local_lease;
3492 vol_info->no_linux_ext = !master_tcon->unix_ext;
3494 /* FIXME: allow for other secFlg settings */
3495 vol_info->secFlg = CIFSSEC_MUST_KRB5;
3497 /* get a reference for the same TCP session */
3498 spin_lock(&cifs_tcp_ses_lock);
3499 ++master_tcon->ses->server->srv_count;
3500 spin_unlock(&cifs_tcp_ses_lock);
3502 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3504 tcon = (struct cifs_tcon *)ses;
3505 cifs_put_tcp_session(master_tcon->ses->server);
3509 tcon = cifs_get_tcon(ses, vol_info);
3511 cifs_put_smb_ses(ses);
3515 if (ses->capabilities & CAP_UNIX)
3516 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3524 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3526 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3530 cifs_sb_tcon_pending_wait(void *unused)
3533 return signal_pending(current) ? -ERESTARTSYS : 0;
3536 /* find and return a tlink with given uid */
3537 static struct tcon_link *
3538 tlink_rb_search(struct rb_root *root, uid_t uid)
3540 struct rb_node *node = root->rb_node;
3541 struct tcon_link *tlink;
3544 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3546 if (tlink->tl_uid > uid)
3547 node = node->rb_left;
3548 else if (tlink->tl_uid < uid)
3549 node = node->rb_right;
3556 /* insert a tcon_link into the tree */
3558 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3560 struct rb_node **new = &(root->rb_node), *parent = NULL;
3561 struct tcon_link *tlink;
3564 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3567 if (tlink->tl_uid > new_tlink->tl_uid)
3568 new = &((*new)->rb_left);
3570 new = &((*new)->rb_right);
3573 rb_link_node(&new_tlink->tl_rbnode, parent, new);
3574 rb_insert_color(&new_tlink->tl_rbnode, root);
3578 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3581 * If the superblock doesn't refer to a multiuser mount, then just return
3582 * the master tcon for the mount.
3584 * First, search the rbtree for an existing tcon for this fsuid. If one
3585 * exists, then check to see if it's pending construction. If it is then wait
3586 * for construction to complete. Once it's no longer pending, check to see if
3587 * it failed and either return an error or retry construction, depending on
3590 * If one doesn't exist then insert a new tcon_link struct into the tree and
3591 * try to construct a new one.
3594 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
3597 uid_t fsuid = current_fsuid();
3598 struct tcon_link *tlink, *newtlink;
3600 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
3601 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3603 spin_lock(&cifs_sb->tlink_tree_lock);
3604 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3606 cifs_get_tlink(tlink);
3607 spin_unlock(&cifs_sb->tlink_tree_lock);
3609 if (tlink == NULL) {
3610 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
3611 if (newtlink == NULL)
3612 return ERR_PTR(-ENOMEM);
3613 newtlink->tl_uid = fsuid;
3614 newtlink->tl_tcon = ERR_PTR(-EACCES);
3615 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
3616 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
3617 cifs_get_tlink(newtlink);
3619 spin_lock(&cifs_sb->tlink_tree_lock);
3620 /* was one inserted after previous search? */
3621 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3623 cifs_get_tlink(tlink);
3624 spin_unlock(&cifs_sb->tlink_tree_lock);
3626 goto wait_for_construction;
3629 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3630 spin_unlock(&cifs_sb->tlink_tree_lock);
3632 wait_for_construction:
3633 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
3634 cifs_sb_tcon_pending_wait,
3635 TASK_INTERRUPTIBLE);
3637 cifs_put_tlink(tlink);
3638 return ERR_PTR(ret);
3641 /* if it's good, return it */
3642 if (!IS_ERR(tlink->tl_tcon))
3645 /* return error if we tried this already recently */
3646 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
3647 cifs_put_tlink(tlink);
3648 return ERR_PTR(-EACCES);
3651 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
3652 goto wait_for_construction;
3655 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
3656 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
3657 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
3659 if (IS_ERR(tlink->tl_tcon)) {
3660 cifs_put_tlink(tlink);
3661 return ERR_PTR(-EACCES);
3668 * periodic workqueue job that scans tcon_tree for a superblock and closes
3672 cifs_prune_tlinks(struct work_struct *work)
3674 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
3676 struct rb_root *root = &cifs_sb->tlink_tree;
3677 struct rb_node *node = rb_first(root);
3678 struct rb_node *tmp;
3679 struct tcon_link *tlink;
3682 * Because we drop the spinlock in the loop in order to put the tlink
3683 * it's not guarded against removal of links from the tree. The only
3684 * places that remove entries from the tree are this function and
3685 * umounts. Because this function is non-reentrant and is canceled
3686 * before umount can proceed, this is safe.
3688 spin_lock(&cifs_sb->tlink_tree_lock);
3689 node = rb_first(root);
3690 while (node != NULL) {
3692 node = rb_next(tmp);
3693 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
3695 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
3696 atomic_read(&tlink->tl_count) != 0 ||
3697 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
3700 cifs_get_tlink(tlink);
3701 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3702 rb_erase(tmp, root);
3704 spin_unlock(&cifs_sb->tlink_tree_lock);
3705 cifs_put_tlink(tlink);
3706 spin_lock(&cifs_sb->tlink_tree_lock);
3708 spin_unlock(&cifs_sb->tlink_tree_lock);
3710 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,