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)
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 > CIFSMaxBufSize) {
218 cERROR(1, "TotalDataSize %d is over maximum buffer %d",
219 total_data_size, CIFSMaxBufSize);
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 allocate_buffers(char **bigbuf, char **smallbuf, unsigned int size,
326 char *bbuf = *bigbuf, *sbuf = *smallbuf;
329 bbuf = (char *)cifs_buf_get();
331 cERROR(1, "No memory for large SMB response");
333 /* retry will check if exiting */
336 } else if (is_large_buf) {
337 /* we are reusing a dirty large buf, clear its start */
338 memset(bbuf, 0, size);
342 sbuf = (char *)cifs_small_buf_get();
344 cERROR(1, "No memory for SMB response");
346 /* retry will check if exiting */
349 /* beginning of smb buffer is cleared in our buf_get */
351 /* if existing small buf clear beginning */
352 memset(sbuf, 0, size);
362 read_from_socket(struct TCP_Server_Info *server, struct msghdr *smb_msg,
363 struct kvec *iov, unsigned int to_read,
364 unsigned int *ptotal_read, bool is_header_read)
367 unsigned int total_read;
368 char *buf = iov->iov_base;
370 for (total_read = 0; total_read < to_read; total_read += length) {
371 length = kernel_recvmsg(server->ssocket, smb_msg, iov, 1,
372 to_read - total_read, 0);
373 if (server->tcpStatus == CifsExiting) {
377 } else if (server->tcpStatus == CifsNeedReconnect) {
378 cifs_reconnect(server);
379 /* Reconnect wakes up rspns q */
380 /* Now we will reread sock */
383 } else if (length == -ERESTARTSYS ||
387 * Minimum sleep to prevent looping, allowing socket
388 * to clear and app threads to set tcpStatus
389 * CifsNeedReconnect if server hung.
391 usleep_range(1000, 2000);
395 /* Special handling for header read */
397 iov->iov_base = (to_read - total_read) +
399 iov->iov_len = to_read - total_read;
400 smb_msg->msg_control = NULL;
401 smb_msg->msg_controllen = 0;
406 } else if (length <= 0) {
407 cERROR(1, "Received no data, expecting %d",
408 to_read - total_read);
409 cifs_reconnect(server);
415 *ptotal_read = total_read;
420 check_rfc1002_header(struct TCP_Server_Info *server, char *buf)
423 unsigned int pdu_length = be32_to_cpu(
424 ((struct smb_hdr *)buf)->smb_buf_length);
427 * The first byte big endian of the length field,
428 * is actually not part of the length but the type
429 * with the most common, zero, as regular data.
431 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
433 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
434 cFYI(1, "Good RFC 1002 session rsp");
436 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
438 * We get this from Windows 98 instead of an error on
439 * SMB negprot response.
441 cFYI(1, "Negative RFC1002 Session Response Error 0x%x)",
443 /* give server a second to clean up */
446 * Always try 445 first on reconnect since we get NACK
447 * on some if we ever connected to port 139 (the NACK
448 * is since we do not begin with RFC1001 session
451 cifs_set_port((struct sockaddr *)
452 &server->dstaddr, CIFS_PORT);
453 cifs_reconnect(server);
454 wake_up(&server->response_q);
456 } else if (temp != (char) 0) {
457 cERROR(1, "Unknown RFC 1002 frame");
458 cifs_dump_mem(" Received Data: ", buf, 4);
459 cifs_reconnect(server);
463 /* else we have an SMB response */
464 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
465 (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
466 cERROR(1, "Invalid size SMB length %d pdu_length %d",
468 cifs_reconnect(server);
469 wake_up(&server->response_q);
476 static struct mid_q_entry *
477 find_cifs_mid(struct TCP_Server_Info *server, struct smb_hdr *buf,
478 int *length, bool is_large_buf, bool *is_multi_rsp, char **bigbuf)
480 struct mid_q_entry *mid = NULL, *tmp_mid, *ret = NULL;
482 spin_lock(&GlobalMid_Lock);
483 list_for_each_entry_safe(mid, tmp_mid, &server->pending_mid_q, qhead) {
484 if (mid->mid != buf->Mid ||
485 mid->midState != MID_REQUEST_SUBMITTED ||
486 mid->command != buf->Command)
489 if (*length == 0 && check2ndT2(buf) > 0) {
490 /* We have a multipart transact2 resp */
491 *is_multi_rsp = true;
493 /* merge response - fix up 1st*/
494 *length = coalesce_t2(buf, mid->resp_buf);
497 mid->multiRsp = true;
500 /* All parts received or packet is malformed. */
501 mid->multiEnd = true;
505 /*FIXME: switch to already allocated largebuf?*/
506 cERROR(1, "1st trans2 resp needs bigbuf");
508 /* Have first buffer */
510 mid->largeBuf = true;
516 mid->largeBuf = is_large_buf;
519 mid->midState = MID_RESPONSE_RECEIVED;
521 mid->midState = MID_RESPONSE_MALFORMED;
522 #ifdef CONFIG_CIFS_STATS2
523 mid->when_received = jiffies;
525 list_del_init(&mid->qhead);
529 spin_unlock(&GlobalMid_Lock);
534 static void clean_demultiplex_info(struct TCP_Server_Info *server)
538 /* take it off the list, if it's not already */
539 spin_lock(&cifs_tcp_ses_lock);
540 list_del_init(&server->tcp_ses_list);
541 spin_unlock(&cifs_tcp_ses_lock);
543 spin_lock(&GlobalMid_Lock);
544 server->tcpStatus = CifsExiting;
545 spin_unlock(&GlobalMid_Lock);
546 wake_up_all(&server->response_q);
549 * Check if we have blocked requests that need to free. Note that
550 * cifs_max_pending is normally 50, but can be set at module install
551 * time to as little as two.
553 spin_lock(&GlobalMid_Lock);
554 if (atomic_read(&server->inFlight) >= cifs_max_pending)
555 atomic_set(&server->inFlight, cifs_max_pending - 1);
557 * We do not want to set the max_pending too low or we could end up
558 * with the counter going negative.
560 spin_unlock(&GlobalMid_Lock);
562 * Although there should not be any requests blocked on this queue it
563 * can not hurt to be paranoid and try to wake up requests that may
564 * haven been blocked when more than 50 at time were on the wire to the
565 * same server - they now will see the session is in exit state and get
566 * out of SendReceive.
568 wake_up_all(&server->request_q);
569 /* give those requests time to exit */
572 if (server->ssocket) {
573 sock_release(server->ssocket);
574 server->ssocket = NULL;
577 if (!list_empty(&server->pending_mid_q)) {
578 struct list_head dispose_list;
579 struct mid_q_entry *mid_entry;
580 struct list_head *tmp, *tmp2;
582 INIT_LIST_HEAD(&dispose_list);
583 spin_lock(&GlobalMid_Lock);
584 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
585 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
586 cFYI(1, "Clearing mid 0x%x", mid_entry->mid);
587 mid_entry->midState = MID_SHUTDOWN;
588 list_move(&mid_entry->qhead, &dispose_list);
590 spin_unlock(&GlobalMid_Lock);
592 /* now walk dispose list and issue callbacks */
593 list_for_each_safe(tmp, tmp2, &dispose_list) {
594 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
595 cFYI(1, "Callback mid 0x%x", mid_entry->mid);
596 list_del_init(&mid_entry->qhead);
597 mid_entry->callback(mid_entry);
599 /* 1/8th of sec is more than enough time for them to exit */
603 if (!list_empty(&server->pending_mid_q)) {
605 * mpx threads have not exited yet give them at least the smb
606 * send timeout time for long ops.
608 * Due to delays on oplock break requests, we need to wait at
609 * least 45 seconds before giving up on a request getting a
610 * response and going ahead and killing cifsd.
612 cFYI(1, "Wait for exit from demultiplex thread");
615 * If threads still have not exited they are probably never
616 * coming home not much else we can do but free the memory.
620 kfree(server->hostname);
623 length = atomic_dec_return(&tcpSesAllocCount);
625 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
630 cifs_demultiplex_thread(void *p)
633 struct TCP_Server_Info *server = p;
634 unsigned int pdu_length, total_read;
635 char *buf = NULL, *bigbuf = NULL, *smallbuf = NULL;
636 struct smb_hdr *smb_buffer = NULL;
637 struct msghdr smb_msg;
639 struct task_struct *task_to_wake = NULL;
640 struct mid_q_entry *mid_entry;
641 bool isLargeBuf = false;
642 bool isMultiRsp = false;
645 current->flags |= PF_MEMALLOC;
646 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
648 length = atomic_inc_return(&tcpSesAllocCount);
650 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
654 while (server->tcpStatus != CifsExiting) {
658 if (!allocate_buffers(&bigbuf, &smallbuf,
659 sizeof(struct smb_hdr), isLargeBuf))
664 smb_buffer = (struct smb_hdr *)smallbuf;
668 smb_msg.msg_control = NULL;
669 smb_msg.msg_controllen = 0;
670 pdu_length = 4; /* enough to get RFC1001 header */
673 if (echo_retries > 0 && server->tcpStatus == CifsGood &&
674 time_after(jiffies, server->lstrp +
675 (echo_retries * SMB_ECHO_INTERVAL))) {
676 cERROR(1, "Server %s has not responded in %d seconds. "
677 "Reconnecting...", server->hostname,
678 (echo_retries * SMB_ECHO_INTERVAL / HZ));
679 cifs_reconnect(server);
680 wake_up(&server->response_q);
684 rc = read_from_socket(server, &smb_msg, &iov, pdu_length,
685 &total_read, true /* header read */);
694 * The right amount was read from socket - 4 bytes,
695 * so we can now interpret the length field.
697 pdu_length = be32_to_cpu(smb_buffer->smb_buf_length);
699 cFYI(1, "rfc1002 length 0x%x", pdu_length+4);
700 if (!check_rfc1002_header(server, buf))
704 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
706 memcpy(bigbuf, smallbuf, 4);
707 smb_buffer = (struct smb_hdr *)bigbuf;
711 iov.iov_base = 4 + buf;
712 iov.iov_len = pdu_length;
713 rc = read_from_socket(server, &smb_msg, &iov, pdu_length,
720 total_read += 4; /* account for rfc1002 hdr */
722 dump_smb(smb_buffer, total_read);
725 * We know that we received enough to get to the MID as we
726 * checked the pdu_length earlier. Now check to see
727 * if the rest of the header is OK. We borrow the length
728 * var for the rest of the loop to avoid a new stack var.
730 * 48 bytes is enough to display the header and a little bit
731 * into the payload for debugging purposes.
733 length = checkSMB(smb_buffer, smb_buffer->Mid, total_read);
735 cifs_dump_mem("Bad SMB: ", buf,
736 min_t(unsigned int, total_read, 48));
738 server->lstrp = jiffies;
740 mid_entry = find_cifs_mid(server, smb_buffer, &length,
741 isLargeBuf, &isMultiRsp, &bigbuf);
742 if (mid_entry != NULL) {
743 mid_entry->callback(mid_entry);
744 /* Was previous buf put in mpx struct for multi-rsp? */
746 /* smb buffer will be freed by user thread */
752 } else if (length != 0) {
753 /* response sanity checks failed */
755 } else if (!is_valid_oplock_break(smb_buffer, server) &&
757 cERROR(1, "No task to wake, unknown frame received! "
758 "NumMids %d", atomic_read(&midCount));
759 cifs_dump_mem("Received Data is: ", buf,
760 sizeof(struct smb_hdr));
761 #ifdef CONFIG_CIFS_DEBUG2
762 cifs_dump_detail(smb_buffer);
763 cifs_dump_mids(server);
764 #endif /* CIFS_DEBUG2 */
767 } /* end while !EXITING */
769 /* buffer usually freed in free_mid - need to free it here on exit */
770 cifs_buf_release(bigbuf);
771 if (smallbuf) /* no sense logging a debug message if NULL */
772 cifs_small_buf_release(smallbuf);
774 task_to_wake = xchg(&server->tsk, NULL);
775 clean_demultiplex_info(server);
777 /* if server->tsk was NULL then wait for a signal before exiting */
779 set_current_state(TASK_INTERRUPTIBLE);
780 while (!signal_pending(current)) {
782 set_current_state(TASK_INTERRUPTIBLE);
784 set_current_state(TASK_RUNNING);
787 module_put_and_exit(0);
790 /* extract the host portion of the UNC string */
792 extract_hostname(const char *unc)
798 /* skip double chars at beginning of string */
799 /* BB: check validity of these bytes? */
802 /* delimiter between hostname and sharename is always '\\' now */
803 delim = strchr(src, '\\');
805 return ERR_PTR(-EINVAL);
808 dst = kmalloc((len + 1), GFP_KERNEL);
810 return ERR_PTR(-ENOMEM);
812 memcpy(dst, src, len);
819 cifs_parse_mount_options(const char *mountdata, const char *devname,
822 char *value, *data, *end;
823 char *mountdata_copy = NULL, *options;
824 unsigned int temp_len, i, j;
826 short int override_uid = -1;
827 short int override_gid = -1;
828 bool uid_specified = false;
829 bool gid_specified = false;
830 char *nodename = utsname()->nodename;
836 * does not have to be perfect mapping since field is
837 * informational, only used for servers that do not support
838 * port 445 and it can be overridden at mount time
840 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
841 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
842 vol->source_rfc1001_name[i] = toupper(nodename[i]);
844 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
845 /* null target name indicates to use *SMBSERVR default called name
846 if we end up sending RFC1001 session initialize */
847 vol->target_rfc1001_name[0] = 0;
848 vol->cred_uid = current_uid();
849 vol->linux_uid = current_uid();
850 vol->linux_gid = current_gid();
852 /* default to only allowing write access to owner of the mount */
853 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
855 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
856 /* default is always to request posix paths. */
857 vol->posix_paths = 1;
858 /* default to using server inode numbers where available */
861 vol->actimeo = CIFS_DEF_ACTIMEO;
864 goto cifs_parse_mount_err;
866 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
868 goto cifs_parse_mount_err;
870 options = mountdata_copy;
871 end = options + strlen(options);
872 if (strncmp(options, "sep=", 4) == 0) {
873 if (options[4] != 0) {
874 separator[0] = options[4];
877 cFYI(1, "Null separator not allowed");
881 while ((data = strsep(&options, separator)) != NULL) {
884 if ((value = strchr(data, '=')) != NULL)
887 /* Have to parse this before we parse for "user" */
888 if (strnicmp(data, "user_xattr", 10) == 0) {
890 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
892 } else if (strnicmp(data, "user", 4) == 0) {
895 "CIFS: invalid or missing username\n");
896 goto cifs_parse_mount_err;
897 } else if (!*value) {
898 /* null user, ie anonymous, authentication */
901 if (strnlen(value, MAX_USERNAME_SIZE) <
903 vol->username = kstrdup(value, GFP_KERNEL);
904 if (!vol->username) {
905 printk(KERN_WARNING "CIFS: no memory "
907 goto cifs_parse_mount_err;
910 printk(KERN_WARNING "CIFS: username too long\n");
911 goto cifs_parse_mount_err;
913 } else if (strnicmp(data, "pass", 4) == 0) {
915 vol->password = NULL;
917 } else if (value[0] == 0) {
918 /* check if string begins with double comma
919 since that would mean the password really
920 does start with a comma, and would not
921 indicate an empty string */
922 if (value[1] != separator[0]) {
923 vol->password = NULL;
927 temp_len = strlen(value);
928 /* removed password length check, NTLM passwords
929 can be arbitrarily long */
931 /* if comma in password, the string will be
932 prematurely null terminated. Commas in password are
933 specified across the cifs mount interface by a double
934 comma ie ,, and a comma used as in other cases ie ','
935 as a parameter delimiter/separator is single and due
936 to the strsep above is temporarily zeroed. */
938 /* NB: password legally can have multiple commas and
939 the only illegal character in a password is null */
941 if ((value[temp_len] == 0) &&
942 (value + temp_len < end) &&
943 (value[temp_len+1] == separator[0])) {
945 value[temp_len] = separator[0];
946 temp_len += 2; /* move after second comma */
947 while (value[temp_len] != 0) {
948 if (value[temp_len] == separator[0]) {
949 if (value[temp_len+1] ==
951 /* skip second comma */
954 /* single comma indicating start
961 if (value[temp_len] == 0) {
965 /* point option to start of next parm */
966 options = value + temp_len + 1;
968 /* go from value to value + temp_len condensing
969 double commas to singles. Note that this ends up
970 allocating a few bytes too many, which is ok */
971 vol->password = kzalloc(temp_len, GFP_KERNEL);
972 if (vol->password == NULL) {
973 printk(KERN_WARNING "CIFS: no memory "
975 goto cifs_parse_mount_err;
977 for (i = 0, j = 0; i < temp_len; i++, j++) {
978 vol->password[j] = value[i];
979 if (value[i] == separator[0]
980 && value[i+1] == separator[0]) {
981 /* skip second comma */
985 vol->password[j] = 0;
987 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
988 if (vol->password == NULL) {
989 printk(KERN_WARNING "CIFS: no memory "
991 goto cifs_parse_mount_err;
993 strcpy(vol->password, value);
995 } else if (!strnicmp(data, "ip", 2) ||
996 !strnicmp(data, "addr", 4)) {
997 if (!value || !*value) {
999 } else if (strnlen(value, INET6_ADDRSTRLEN) <
1001 vol->UNCip = kstrdup(value, GFP_KERNEL);
1003 printk(KERN_WARNING "CIFS: no memory "
1005 goto cifs_parse_mount_err;
1008 printk(KERN_WARNING "CIFS: ip address "
1010 goto cifs_parse_mount_err;
1012 } else if (strnicmp(data, "sec", 3) == 0) {
1013 if (!value || !*value) {
1014 cERROR(1, "no security value specified");
1016 } else if (strnicmp(value, "krb5i", 5) == 0) {
1017 vol->secFlg |= CIFSSEC_MAY_KRB5 |
1019 } else if (strnicmp(value, "krb5p", 5) == 0) {
1020 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
1021 CIFSSEC_MAY_KRB5; */
1022 cERROR(1, "Krb5 cifs privacy not supported");
1023 goto cifs_parse_mount_err;
1024 } else if (strnicmp(value, "krb5", 4) == 0) {
1025 vol->secFlg |= CIFSSEC_MAY_KRB5;
1026 } else if (strnicmp(value, "ntlmsspi", 8) == 0) {
1027 vol->secFlg |= CIFSSEC_MAY_NTLMSSP |
1029 } else if (strnicmp(value, "ntlmssp", 7) == 0) {
1030 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
1031 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
1032 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
1034 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
1035 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1036 } else if (strnicmp(value, "ntlmi", 5) == 0) {
1037 vol->secFlg |= CIFSSEC_MAY_NTLM |
1039 } else if (strnicmp(value, "ntlm", 4) == 0) {
1040 /* ntlm is default so can be turned off too */
1041 vol->secFlg |= CIFSSEC_MAY_NTLM;
1042 } else if (strnicmp(value, "nontlm", 6) == 0) {
1043 /* BB is there a better way to do this? */
1044 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1045 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1046 } else if (strnicmp(value, "lanman", 6) == 0) {
1047 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1049 } else if (strnicmp(value, "none", 4) == 0) {
1052 cERROR(1, "bad security option: %s", value);
1053 goto cifs_parse_mount_err;
1055 } else if (strnicmp(data, "vers", 3) == 0) {
1056 if (!value || !*value) {
1057 cERROR(1, "no protocol version specified"
1058 " after vers= mount option");
1059 } else if ((strnicmp(value, "cifs", 4) == 0) ||
1060 (strnicmp(value, "1", 1) == 0)) {
1061 /* this is the default */
1064 } else if ((strnicmp(data, "unc", 3) == 0)
1065 || (strnicmp(data, "target", 6) == 0)
1066 || (strnicmp(data, "path", 4) == 0)) {
1067 if (!value || !*value) {
1068 printk(KERN_WARNING "CIFS: invalid path to "
1069 "network resource\n");
1070 goto cifs_parse_mount_err;
1072 if ((temp_len = strnlen(value, 300)) < 300) {
1073 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1074 if (vol->UNC == NULL)
1075 goto cifs_parse_mount_err;
1076 strcpy(vol->UNC, value);
1077 if (strncmp(vol->UNC, "//", 2) == 0) {
1080 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1082 "CIFS: UNC Path does not begin "
1083 "with // or \\\\ \n");
1084 goto cifs_parse_mount_err;
1087 printk(KERN_WARNING "CIFS: UNC name too long\n");
1088 goto cifs_parse_mount_err;
1090 } else if ((strnicmp(data, "domain", 3) == 0)
1091 || (strnicmp(data, "workgroup", 5) == 0)) {
1092 if (!value || !*value) {
1093 printk(KERN_WARNING "CIFS: invalid domain name\n");
1094 goto cifs_parse_mount_err;
1096 /* BB are there cases in which a comma can be valid in
1097 a domain name and need special handling? */
1098 if (strnlen(value, 256) < 256) {
1099 vol->domainname = kstrdup(value, GFP_KERNEL);
1100 if (!vol->domainname) {
1101 printk(KERN_WARNING "CIFS: no memory "
1102 "for domainname\n");
1103 goto cifs_parse_mount_err;
1105 cFYI(1, "Domain name set");
1107 printk(KERN_WARNING "CIFS: domain name too "
1109 goto cifs_parse_mount_err;
1111 } else if (strnicmp(data, "srcaddr", 7) == 0) {
1112 vol->srcaddr.ss_family = AF_UNSPEC;
1114 if (!value || !*value) {
1115 printk(KERN_WARNING "CIFS: srcaddr value"
1116 " not specified.\n");
1117 goto cifs_parse_mount_err;
1119 i = cifs_convert_address((struct sockaddr *)&vol->srcaddr,
1120 value, strlen(value));
1122 printk(KERN_WARNING "CIFS: Could not parse"
1125 goto cifs_parse_mount_err;
1127 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1128 if (!value || !*value) {
1130 "CIFS: invalid path prefix\n");
1131 goto cifs_parse_mount_err;
1133 if ((temp_len = strnlen(value, 1024)) < 1024) {
1134 if (value[0] != '/')
1135 temp_len++; /* missing leading slash */
1136 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1137 if (vol->prepath == NULL)
1138 goto cifs_parse_mount_err;
1139 if (value[0] != '/') {
1140 vol->prepath[0] = '/';
1141 strcpy(vol->prepath+1, value);
1143 strcpy(vol->prepath, value);
1144 cFYI(1, "prefix path %s", vol->prepath);
1146 printk(KERN_WARNING "CIFS: prefix too long\n");
1147 goto cifs_parse_mount_err;
1149 } else if (strnicmp(data, "iocharset", 9) == 0) {
1150 if (!value || !*value) {
1151 printk(KERN_WARNING "CIFS: invalid iocharset "
1153 goto cifs_parse_mount_err;
1155 if (strnlen(value, 65) < 65) {
1156 if (strnicmp(value, "default", 7)) {
1157 vol->iocharset = kstrdup(value,
1160 if (!vol->iocharset) {
1161 printk(KERN_WARNING "CIFS: no "
1164 goto cifs_parse_mount_err;
1167 /* if iocharset not set then load_nls_default
1168 is used by caller */
1169 cFYI(1, "iocharset set to %s", value);
1171 printk(KERN_WARNING "CIFS: iocharset name "
1173 goto cifs_parse_mount_err;
1175 } else if (!strnicmp(data, "uid", 3) && value && *value) {
1176 vol->linux_uid = simple_strtoul(value, &value, 0);
1177 uid_specified = true;
1178 } else if (!strnicmp(data, "cruid", 5) && value && *value) {
1179 vol->cred_uid = simple_strtoul(value, &value, 0);
1180 } else if (!strnicmp(data, "forceuid", 8)) {
1182 } else if (!strnicmp(data, "noforceuid", 10)) {
1184 } else if (!strnicmp(data, "gid", 3) && value && *value) {
1185 vol->linux_gid = simple_strtoul(value, &value, 0);
1186 gid_specified = true;
1187 } else if (!strnicmp(data, "forcegid", 8)) {
1189 } else if (!strnicmp(data, "noforcegid", 10)) {
1191 } else if (strnicmp(data, "file_mode", 4) == 0) {
1192 if (value && *value) {
1194 simple_strtoul(value, &value, 0);
1196 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1197 if (value && *value) {
1199 simple_strtoul(value, &value, 0);
1201 } else if (strnicmp(data, "dirmode", 4) == 0) {
1202 if (value && *value) {
1204 simple_strtoul(value, &value, 0);
1206 } else if (strnicmp(data, "port", 4) == 0) {
1207 if (value && *value) {
1209 simple_strtoul(value, &value, 0);
1211 } else if (strnicmp(data, "rsize", 5) == 0) {
1212 if (value && *value) {
1214 simple_strtoul(value, &value, 0);
1216 } else if (strnicmp(data, "wsize", 5) == 0) {
1217 if (value && *value) {
1219 simple_strtoul(value, &value, 0);
1221 } else if (strnicmp(data, "sockopt", 5) == 0) {
1222 if (!value || !*value) {
1223 cERROR(1, "no socket option specified");
1225 } else if (strnicmp(value, "TCP_NODELAY", 11) == 0) {
1226 vol->sockopt_tcp_nodelay = 1;
1228 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1229 if (!value || !*value || (*value == ' ')) {
1230 cFYI(1, "invalid (empty) netbiosname");
1232 memset(vol->source_rfc1001_name, 0x20,
1235 * FIXME: are there cases in which a comma can
1236 * be valid in workstation netbios name (and
1237 * need special handling)?
1239 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1240 /* don't ucase netbiosname for user */
1243 vol->source_rfc1001_name[i] = value[i];
1245 /* The string has 16th byte zero still from
1246 set at top of the function */
1247 if (i == RFC1001_NAME_LEN && value[i] != 0)
1248 printk(KERN_WARNING "CIFS: netbiosname"
1249 " longer than 15 truncated.\n");
1251 } else if (strnicmp(data, "servern", 7) == 0) {
1252 /* servernetbiosname specified override *SMBSERVER */
1253 if (!value || !*value || (*value == ' ')) {
1254 cFYI(1, "empty server netbiosname specified");
1256 /* last byte, type, is 0x20 for servr type */
1257 memset(vol->target_rfc1001_name, 0x20,
1258 RFC1001_NAME_LEN_WITH_NULL);
1260 for (i = 0; i < 15; i++) {
1261 /* BB are there cases in which a comma can be
1262 valid in this workstation netbios name
1263 (and need special handling)? */
1265 /* user or mount helper must uppercase
1270 vol->target_rfc1001_name[i] =
1273 /* The string has 16th byte zero still from
1274 set at top of the function */
1275 if (i == RFC1001_NAME_LEN && value[i] != 0)
1276 printk(KERN_WARNING "CIFS: server net"
1277 "biosname longer than 15 truncated.\n");
1279 } else if (strnicmp(data, "actimeo", 7) == 0) {
1280 if (value && *value) {
1281 vol->actimeo = HZ * simple_strtoul(value,
1283 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1284 cERROR(1, "CIFS: attribute cache"
1285 "timeout too large");
1286 goto cifs_parse_mount_err;
1289 } else if (strnicmp(data, "credentials", 4) == 0) {
1291 } else if (strnicmp(data, "version", 3) == 0) {
1293 } else if (strnicmp(data, "guest", 5) == 0) {
1295 } else if (strnicmp(data, "rw", 2) == 0 && strlen(data) == 2) {
1297 } else if (strnicmp(data, "ro", 2) == 0) {
1299 } else if (strnicmp(data, "noblocksend", 11) == 0) {
1300 vol->noblocksnd = 1;
1301 } else if (strnicmp(data, "noautotune", 10) == 0) {
1302 vol->noautotune = 1;
1303 } else if ((strnicmp(data, "suid", 4) == 0) ||
1304 (strnicmp(data, "nosuid", 6) == 0) ||
1305 (strnicmp(data, "exec", 4) == 0) ||
1306 (strnicmp(data, "noexec", 6) == 0) ||
1307 (strnicmp(data, "nodev", 5) == 0) ||
1308 (strnicmp(data, "noauto", 6) == 0) ||
1309 (strnicmp(data, "dev", 3) == 0)) {
1310 /* The mount tool or mount.cifs helper (if present)
1311 uses these opts to set flags, and the flags are read
1312 by the kernel vfs layer before we get here (ie
1313 before read super) so there is no point trying to
1314 parse these options again and set anything and it
1315 is ok to just ignore them */
1317 } else if (strnicmp(data, "hard", 4) == 0) {
1319 } else if (strnicmp(data, "soft", 4) == 0) {
1321 } else if (strnicmp(data, "perm", 4) == 0) {
1323 } else if (strnicmp(data, "noperm", 6) == 0) {
1325 } else if (strnicmp(data, "mapchars", 8) == 0) {
1327 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1329 } else if (strnicmp(data, "sfu", 3) == 0) {
1331 } else if (strnicmp(data, "nosfu", 5) == 0) {
1333 } else if (strnicmp(data, "nodfs", 5) == 0) {
1335 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1336 vol->posix_paths = 1;
1337 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1338 vol->posix_paths = 0;
1339 } else if (strnicmp(data, "nounix", 6) == 0) {
1340 vol->no_linux_ext = 1;
1341 } else if (strnicmp(data, "nolinux", 7) == 0) {
1342 vol->no_linux_ext = 1;
1343 } else if ((strnicmp(data, "nocase", 6) == 0) ||
1344 (strnicmp(data, "ignorecase", 10) == 0)) {
1346 } else if (strnicmp(data, "mand", 4) == 0) {
1348 } else if (strnicmp(data, "nomand", 6) == 0) {
1350 } else if (strnicmp(data, "_netdev", 7) == 0) {
1352 } else if (strnicmp(data, "brl", 3) == 0) {
1354 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1355 (strnicmp(data, "nolock", 6) == 0)) {
1357 /* turn off mandatory locking in mode
1358 if remote locking is turned off since the
1359 local vfs will do advisory */
1360 if (vol->file_mode ==
1361 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1362 vol->file_mode = S_IALLUGO;
1363 } else if (strnicmp(data, "forcemandatorylock", 9) == 0) {
1364 /* will take the shorter form "forcemand" as well */
1365 /* This mount option will force use of mandatory
1366 (DOS/Windows style) byte range locks, instead of
1367 using posix advisory byte range locks, even if the
1368 Unix extensions are available and posix locks would
1369 be supported otherwise. If Unix extensions are not
1370 negotiated this has no effect since mandatory locks
1371 would be used (mandatory locks is all that those
1372 those servers support) */
1374 } else if (strnicmp(data, "setuids", 7) == 0) {
1376 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1378 } else if (strnicmp(data, "dynperm", 7) == 0) {
1379 vol->dynperm = true;
1380 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1381 vol->dynperm = false;
1382 } else if (strnicmp(data, "nohard", 6) == 0) {
1384 } else if (strnicmp(data, "nosoft", 6) == 0) {
1386 } else if (strnicmp(data, "nointr", 6) == 0) {
1388 } else if (strnicmp(data, "intr", 4) == 0) {
1390 } else if (strnicmp(data, "nostrictsync", 12) == 0) {
1391 vol->nostrictsync = 1;
1392 } else if (strnicmp(data, "strictsync", 10) == 0) {
1393 vol->nostrictsync = 0;
1394 } else if (strnicmp(data, "serverino", 7) == 0) {
1395 vol->server_ino = 1;
1396 } else if (strnicmp(data, "noserverino", 9) == 0) {
1397 vol->server_ino = 0;
1398 } else if (strnicmp(data, "rwpidforward", 12) == 0) {
1399 vol->rwpidforward = 1;
1400 } else if (strnicmp(data, "cifsacl", 7) == 0) {
1402 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1404 } else if (strnicmp(data, "acl", 3) == 0) {
1405 vol->no_psx_acl = 0;
1406 } else if (strnicmp(data, "noacl", 5) == 0) {
1407 vol->no_psx_acl = 1;
1408 } else if (strnicmp(data, "locallease", 6) == 0) {
1409 vol->local_lease = 1;
1410 } else if (strnicmp(data, "sign", 4) == 0) {
1411 vol->secFlg |= CIFSSEC_MUST_SIGN;
1412 } else if (strnicmp(data, "seal", 4) == 0) {
1413 /* we do not do the following in secFlags because seal
1414 is a per tree connection (mount) not a per socket
1415 or per-smb connection option in the protocol */
1416 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1418 } else if (strnicmp(data, "direct", 6) == 0) {
1420 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
1422 } else if (strnicmp(data, "strictcache", 11) == 0) {
1424 } else if (strnicmp(data, "noac", 4) == 0) {
1425 printk(KERN_WARNING "CIFS: Mount option noac not "
1426 "supported. Instead set "
1427 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1428 } else if (strnicmp(data, "fsc", 3) == 0) {
1429 #ifndef CONFIG_CIFS_FSCACHE
1430 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE "
1431 "kernel config option set");
1432 goto cifs_parse_mount_err;
1435 } else if (strnicmp(data, "mfsymlinks", 10) == 0) {
1436 vol->mfsymlinks = true;
1437 } else if (strnicmp(data, "multiuser", 8) == 0) {
1438 vol->multiuser = true;
1440 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1443 if (vol->UNC == NULL) {
1444 if (devname == NULL) {
1445 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1447 goto cifs_parse_mount_err;
1449 if ((temp_len = strnlen(devname, 300)) < 300) {
1450 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1451 if (vol->UNC == NULL)
1452 goto cifs_parse_mount_err;
1453 strcpy(vol->UNC, devname);
1454 if (strncmp(vol->UNC, "//", 2) == 0) {
1457 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1458 printk(KERN_WARNING "CIFS: UNC Path does not "
1459 "begin with // or \\\\ \n");
1460 goto cifs_parse_mount_err;
1462 value = strpbrk(vol->UNC+2, "/\\");
1466 printk(KERN_WARNING "CIFS: UNC name too long\n");
1467 goto cifs_parse_mount_err;
1471 if (vol->multiuser && !(vol->secFlg & CIFSSEC_MAY_KRB5)) {
1472 cERROR(1, "Multiuser mounts currently require krb5 "
1474 goto cifs_parse_mount_err;
1477 if (vol->UNCip == NULL)
1478 vol->UNCip = &vol->UNC[2];
1481 vol->override_uid = override_uid;
1482 else if (override_uid == 1)
1483 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1484 "specified with no uid= option.\n");
1487 vol->override_gid = override_gid;
1488 else if (override_gid == 1)
1489 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1490 "specified with no gid= option.\n");
1492 kfree(mountdata_copy);
1495 cifs_parse_mount_err:
1496 kfree(mountdata_copy);
1500 /** Returns true if srcaddr isn't specified and rhs isn't
1501 * specified, or if srcaddr is specified and
1502 * matches the IP address of the rhs argument.
1505 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1507 switch (srcaddr->sa_family) {
1509 return (rhs->sa_family == AF_UNSPEC);
1511 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1512 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1513 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1516 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1517 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1518 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1522 return false; /* don't expect to be here */
1527 * If no port is specified in addr structure, we try to match with 445 port
1528 * and if it fails - with 139 ports. It should be called only if address
1529 * families of server and addr are equal.
1532 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1534 __be16 port, *sport;
1536 switch (addr->sa_family) {
1538 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1539 port = ((struct sockaddr_in *) addr)->sin_port;
1542 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1543 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1551 port = htons(CIFS_PORT);
1555 port = htons(RFC1001_PORT);
1558 return port == *sport;
1562 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1563 struct sockaddr *srcaddr)
1565 switch (addr->sa_family) {
1567 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1568 struct sockaddr_in *srv_addr4 =
1569 (struct sockaddr_in *)&server->dstaddr;
1571 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1576 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1577 struct sockaddr_in6 *srv_addr6 =
1578 (struct sockaddr_in6 *)&server->dstaddr;
1580 if (!ipv6_addr_equal(&addr6->sin6_addr,
1581 &srv_addr6->sin6_addr))
1583 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
1589 return false; /* don't expect to be here */
1592 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1599 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
1601 unsigned int secFlags;
1603 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
1604 secFlags = vol->secFlg;
1606 secFlags = global_secflags | vol->secFlg;
1608 switch (server->secType) {
1610 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
1614 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
1618 if (!(secFlags & CIFSSEC_MAY_NTLM))
1622 if (!(secFlags & CIFSSEC_MAY_KRB5))
1626 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
1630 /* shouldn't happen */
1634 /* now check if signing mode is acceptable */
1635 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
1636 (server->sec_mode & SECMODE_SIGN_REQUIRED))
1638 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
1640 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
1646 static int match_server(struct TCP_Server_Info *server, struct sockaddr *addr,
1647 struct smb_vol *vol)
1649 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
1652 if (!match_address(server, addr,
1653 (struct sockaddr *)&vol->srcaddr))
1656 if (!match_port(server, addr))
1659 if (!match_security(server, vol))
1665 static struct TCP_Server_Info *
1666 cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
1668 struct TCP_Server_Info *server;
1670 spin_lock(&cifs_tcp_ses_lock);
1671 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
1672 if (!match_server(server, addr, vol))
1675 ++server->srv_count;
1676 spin_unlock(&cifs_tcp_ses_lock);
1677 cFYI(1, "Existing tcp session with server found");
1680 spin_unlock(&cifs_tcp_ses_lock);
1685 cifs_put_tcp_session(struct TCP_Server_Info *server)
1687 struct task_struct *task;
1689 spin_lock(&cifs_tcp_ses_lock);
1690 if (--server->srv_count > 0) {
1691 spin_unlock(&cifs_tcp_ses_lock);
1695 put_net(cifs_net_ns(server));
1697 list_del_init(&server->tcp_ses_list);
1698 spin_unlock(&cifs_tcp_ses_lock);
1700 cancel_delayed_work_sync(&server->echo);
1702 spin_lock(&GlobalMid_Lock);
1703 server->tcpStatus = CifsExiting;
1704 spin_unlock(&GlobalMid_Lock);
1706 cifs_crypto_shash_release(server);
1707 cifs_fscache_release_client_cookie(server);
1709 kfree(server->session_key.response);
1710 server->session_key.response = NULL;
1711 server->session_key.len = 0;
1713 task = xchg(&server->tsk, NULL);
1715 force_sig(SIGKILL, task);
1718 static struct TCP_Server_Info *
1719 cifs_get_tcp_session(struct smb_vol *volume_info)
1721 struct TCP_Server_Info *tcp_ses = NULL;
1722 struct sockaddr_storage addr;
1723 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
1724 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
1727 memset(&addr, 0, sizeof(struct sockaddr_storage));
1729 cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
1731 if (volume_info->UNCip && volume_info->UNC) {
1732 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
1734 strlen(volume_info->UNCip),
1737 /* we failed translating address */
1741 } else if (volume_info->UNCip) {
1742 /* BB using ip addr as tcp_ses name to connect to the
1744 cERROR(1, "Connecting to DFS root not implemented yet");
1747 } else /* which tcp_sess DFS root would we conect to */ {
1748 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
1749 "unc=//192.168.1.100/public) specified");
1754 /* see if we already have a matching tcp_ses */
1755 tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
1759 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1765 rc = cifs_crypto_shash_allocate(tcp_ses);
1767 cERROR(1, "could not setup hash structures rc %d", rc);
1771 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
1772 tcp_ses->hostname = extract_hostname(volume_info->UNC);
1773 if (IS_ERR(tcp_ses->hostname)) {
1774 rc = PTR_ERR(tcp_ses->hostname);
1775 goto out_err_crypto_release;
1778 tcp_ses->noblocksnd = volume_info->noblocksnd;
1779 tcp_ses->noautotune = volume_info->noautotune;
1780 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
1781 atomic_set(&tcp_ses->inFlight, 0);
1782 init_waitqueue_head(&tcp_ses->response_q);
1783 init_waitqueue_head(&tcp_ses->request_q);
1784 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1785 mutex_init(&tcp_ses->srv_mutex);
1786 memcpy(tcp_ses->workstation_RFC1001_name,
1787 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1788 memcpy(tcp_ses->server_RFC1001_name,
1789 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1790 tcp_ses->session_estab = false;
1791 tcp_ses->sequence_number = 0;
1792 tcp_ses->lstrp = jiffies;
1793 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1794 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1795 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
1798 * at this point we are the only ones with the pointer
1799 * to the struct since the kernel thread not created yet
1800 * no need to spinlock this init of tcpStatus or srv_count
1802 tcp_ses->tcpStatus = CifsNew;
1803 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
1804 sizeof(tcp_ses->srcaddr));
1805 ++tcp_ses->srv_count;
1807 if (addr.ss_family == AF_INET6) {
1808 cFYI(1, "attempting ipv6 connect");
1809 /* BB should we allow ipv6 on port 139? */
1810 /* other OS never observed in Wild doing 139 with v6 */
1811 memcpy(&tcp_ses->dstaddr, sin_server6,
1812 sizeof(struct sockaddr_in6));
1814 memcpy(&tcp_ses->dstaddr, sin_server,
1815 sizeof(struct sockaddr_in));
1817 rc = ip_connect(tcp_ses);
1819 cERROR(1, "Error connecting to socket. Aborting operation");
1820 goto out_err_crypto_release;
1824 * since we're in a cifs function already, we know that
1825 * this will succeed. No need for try_module_get().
1827 __module_get(THIS_MODULE);
1828 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
1830 if (IS_ERR(tcp_ses->tsk)) {
1831 rc = PTR_ERR(tcp_ses->tsk);
1832 cERROR(1, "error %d create cifsd thread", rc);
1833 module_put(THIS_MODULE);
1834 goto out_err_crypto_release;
1836 tcp_ses->tcpStatus = CifsNeedNegotiate;
1838 /* thread spawned, put it on the list */
1839 spin_lock(&cifs_tcp_ses_lock);
1840 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
1841 spin_unlock(&cifs_tcp_ses_lock);
1843 cifs_fscache_get_client_cookie(tcp_ses);
1845 /* queue echo request delayed work */
1846 queue_delayed_work(system_nrt_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
1850 out_err_crypto_release:
1851 cifs_crypto_shash_release(tcp_ses);
1853 put_net(cifs_net_ns(tcp_ses));
1857 if (!IS_ERR(tcp_ses->hostname))
1858 kfree(tcp_ses->hostname);
1859 if (tcp_ses->ssocket)
1860 sock_release(tcp_ses->ssocket);
1866 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
1868 switch (ses->server->secType) {
1870 if (vol->cred_uid != ses->cred_uid)
1874 /* anything else takes username/password */
1875 if (ses->user_name == NULL)
1877 if (strncmp(ses->user_name, vol->username,
1880 if (strlen(vol->username) != 0 &&
1881 ses->password != NULL &&
1882 strncmp(ses->password,
1883 vol->password ? vol->password : "",
1890 static struct cifs_ses *
1891 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
1893 struct cifs_ses *ses;
1895 spin_lock(&cifs_tcp_ses_lock);
1896 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
1897 if (!match_session(ses, vol))
1900 spin_unlock(&cifs_tcp_ses_lock);
1903 spin_unlock(&cifs_tcp_ses_lock);
1908 cifs_put_smb_ses(struct cifs_ses *ses)
1911 struct TCP_Server_Info *server = ses->server;
1913 cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
1914 spin_lock(&cifs_tcp_ses_lock);
1915 if (--ses->ses_count > 0) {
1916 spin_unlock(&cifs_tcp_ses_lock);
1920 list_del_init(&ses->smb_ses_list);
1921 spin_unlock(&cifs_tcp_ses_lock);
1923 if (ses->status == CifsGood) {
1925 CIFSSMBLogoff(xid, ses);
1929 cifs_put_tcp_session(server);
1932 static bool warned_on_ntlm; /* globals init to false automatically */
1934 static struct cifs_ses *
1935 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
1937 int rc = -ENOMEM, xid;
1938 struct cifs_ses *ses;
1939 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
1940 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
1944 ses = cifs_find_smb_ses(server, volume_info);
1946 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
1948 mutex_lock(&ses->session_mutex);
1949 rc = cifs_negotiate_protocol(xid, ses);
1951 mutex_unlock(&ses->session_mutex);
1952 /* problem -- put our ses reference */
1953 cifs_put_smb_ses(ses);
1957 if (ses->need_reconnect) {
1958 cFYI(1, "Session needs reconnect");
1959 rc = cifs_setup_session(xid, ses,
1960 volume_info->local_nls);
1962 mutex_unlock(&ses->session_mutex);
1963 /* problem -- put our reference */
1964 cifs_put_smb_ses(ses);
1969 mutex_unlock(&ses->session_mutex);
1971 /* existing SMB ses has a server reference already */
1972 cifs_put_tcp_session(server);
1977 cFYI(1, "Existing smb sess not found");
1978 ses = sesInfoAlloc();
1982 /* new SMB session uses our server ref */
1983 ses->server = server;
1984 if (server->dstaddr.ss_family == AF_INET6)
1985 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
1987 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
1989 if (volume_info->username) {
1990 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
1991 if (!ses->user_name)
1995 /* volume_info->password freed at unmount */
1996 if (volume_info->password) {
1997 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2001 if (volume_info->domainname) {
2002 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2003 if (!ses->domainName)
2006 ses->cred_uid = volume_info->cred_uid;
2007 ses->linux_uid = volume_info->linux_uid;
2009 /* ntlmv2 is much stronger than ntlm security, and has been broadly
2010 supported for many years, time to update default security mechanism */
2011 if ((volume_info->secFlg == 0) && warned_on_ntlm == false) {
2012 warned_on_ntlm = true;
2013 cERROR(1, "default security mechanism requested. The default "
2014 "security mechanism will be upgraded from ntlm to "
2015 "ntlmv2 in kernel release 3.2");
2017 ses->overrideSecFlg = volume_info->secFlg;
2019 mutex_lock(&ses->session_mutex);
2020 rc = cifs_negotiate_protocol(xid, ses);
2022 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2023 mutex_unlock(&ses->session_mutex);
2027 /* success, put it on the list */
2028 spin_lock(&cifs_tcp_ses_lock);
2029 list_add(&ses->smb_ses_list, &server->smb_ses_list);
2030 spin_unlock(&cifs_tcp_ses_lock);
2041 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2043 if (tcon->tidStatus == CifsExiting)
2045 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2050 static struct cifs_tcon *
2051 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2053 struct list_head *tmp;
2054 struct cifs_tcon *tcon;
2056 spin_lock(&cifs_tcp_ses_lock);
2057 list_for_each(tmp, &ses->tcon_list) {
2058 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2059 if (!match_tcon(tcon, unc))
2062 spin_unlock(&cifs_tcp_ses_lock);
2065 spin_unlock(&cifs_tcp_ses_lock);
2070 cifs_put_tcon(struct cifs_tcon *tcon)
2073 struct cifs_ses *ses = tcon->ses;
2075 cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2076 spin_lock(&cifs_tcp_ses_lock);
2077 if (--tcon->tc_count > 0) {
2078 spin_unlock(&cifs_tcp_ses_lock);
2082 list_del_init(&tcon->tcon_list);
2083 spin_unlock(&cifs_tcp_ses_lock);
2086 CIFSSMBTDis(xid, tcon);
2089 cifs_fscache_release_super_cookie(tcon);
2091 cifs_put_smb_ses(ses);
2094 static struct cifs_tcon *
2095 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2098 struct cifs_tcon *tcon;
2100 tcon = cifs_find_tcon(ses, volume_info->UNC);
2102 cFYI(1, "Found match on UNC path");
2103 /* existing tcon already has a reference */
2104 cifs_put_smb_ses(ses);
2105 if (tcon->seal != volume_info->seal)
2106 cERROR(1, "transport encryption setting "
2107 "conflicts with existing tid");
2111 tcon = tconInfoAlloc();
2118 if (volume_info->password) {
2119 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2120 if (!tcon->password) {
2126 if (strchr(volume_info->UNC + 3, '\\') == NULL
2127 && strchr(volume_info->UNC + 3, '/') == NULL) {
2128 cERROR(1, "Missing share name");
2133 /* BB Do we need to wrap session_mutex around
2134 * this TCon call and Unix SetFS as
2135 * we do on SessSetup and reconnect? */
2137 rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
2139 cFYI(1, "CIFS Tcon rc = %d", rc);
2143 if (volume_info->nodfs) {
2144 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2145 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2147 tcon->seal = volume_info->seal;
2148 /* we can have only one retry value for a connection
2149 to a share so for resources mounted more than once
2150 to the same server share the last value passed in
2151 for the retry flag is used */
2152 tcon->retry = volume_info->retry;
2153 tcon->nocase = volume_info->nocase;
2154 tcon->local_lease = volume_info->local_lease;
2156 spin_lock(&cifs_tcp_ses_lock);
2157 list_add(&tcon->tcon_list, &ses->tcon_list);
2158 spin_unlock(&cifs_tcp_ses_lock);
2160 cifs_fscache_get_super_cookie(tcon);
2170 cifs_put_tlink(struct tcon_link *tlink)
2172 if (!tlink || IS_ERR(tlink))
2175 if (!atomic_dec_and_test(&tlink->tl_count) ||
2176 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2177 tlink->tl_time = jiffies;
2181 if (!IS_ERR(tlink_tcon(tlink)))
2182 cifs_put_tcon(tlink_tcon(tlink));
2187 static inline struct tcon_link *
2188 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2190 return cifs_sb->master_tlink;
2194 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2196 struct cifs_sb_info *old = CIFS_SB(sb);
2197 struct cifs_sb_info *new = mnt_data->cifs_sb;
2199 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2202 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2203 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2206 if (old->rsize != new->rsize)
2210 * We want to share sb only if we don't specify wsize or specified wsize
2211 * is greater or equal than existing one.
2213 if (new->wsize && new->wsize < old->wsize)
2216 if (old->mnt_uid != new->mnt_uid || old->mnt_gid != new->mnt_gid)
2219 if (old->mnt_file_mode != new->mnt_file_mode ||
2220 old->mnt_dir_mode != new->mnt_dir_mode)
2223 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2226 if (old->actimeo != new->actimeo)
2233 cifs_match_super(struct super_block *sb, void *data)
2235 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2236 struct smb_vol *volume_info;
2237 struct cifs_sb_info *cifs_sb;
2238 struct TCP_Server_Info *tcp_srv;
2239 struct cifs_ses *ses;
2240 struct cifs_tcon *tcon;
2241 struct tcon_link *tlink;
2242 struct sockaddr_storage addr;
2245 memset(&addr, 0, sizeof(struct sockaddr_storage));
2247 spin_lock(&cifs_tcp_ses_lock);
2248 cifs_sb = CIFS_SB(sb);
2249 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2250 if (IS_ERR(tlink)) {
2251 spin_unlock(&cifs_tcp_ses_lock);
2254 tcon = tlink_tcon(tlink);
2256 tcp_srv = ses->server;
2258 volume_info = mnt_data->vol;
2260 if (!volume_info->UNCip || !volume_info->UNC)
2263 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
2265 strlen(volume_info->UNCip),
2270 if (!match_server(tcp_srv, (struct sockaddr *)&addr, volume_info) ||
2271 !match_session(ses, volume_info) ||
2272 !match_tcon(tcon, volume_info->UNC)) {
2277 rc = compare_mount_options(sb, mnt_data);
2279 spin_unlock(&cifs_tcp_ses_lock);
2280 cifs_put_tlink(tlink);
2285 get_dfs_path(int xid, struct cifs_ses *pSesInfo, const char *old_path,
2286 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
2287 struct dfs_info3_param **preferrals, int remap)
2292 *pnum_referrals = 0;
2295 if (pSesInfo->ipc_tid == 0) {
2296 temp_unc = kmalloc(2 /* for slashes */ +
2297 strnlen(pSesInfo->serverName,
2298 SERVER_NAME_LEN_WITH_NULL * 2)
2299 + 1 + 4 /* slash IPC$ */ + 2,
2301 if (temp_unc == NULL)
2305 strcpy(temp_unc + 2, pSesInfo->serverName);
2306 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2307 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
2308 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
2312 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
2313 pnum_referrals, nls_codepage, remap);
2314 /* BB map targetUNCs to dfs_info3 structures, here or
2315 in CIFSGetDFSRefer BB */
2320 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2321 static struct lock_class_key cifs_key[2];
2322 static struct lock_class_key cifs_slock_key[2];
2325 cifs_reclassify_socket4(struct socket *sock)
2327 struct sock *sk = sock->sk;
2328 BUG_ON(sock_owned_by_user(sk));
2329 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2330 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2334 cifs_reclassify_socket6(struct socket *sock)
2336 struct sock *sk = sock->sk;
2337 BUG_ON(sock_owned_by_user(sk));
2338 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2339 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2343 cifs_reclassify_socket4(struct socket *sock)
2348 cifs_reclassify_socket6(struct socket *sock)
2353 /* See RFC1001 section 14 on representation of Netbios names */
2354 static void rfc1002mangle(char *target, char *source, unsigned int length)
2358 for (i = 0, j = 0; i < (length); i++) {
2359 /* mask a nibble at a time and encode */
2360 target[j] = 'A' + (0x0F & (source[i] >> 4));
2361 target[j+1] = 'A' + (0x0F & source[i]);
2368 bind_socket(struct TCP_Server_Info *server)
2371 if (server->srcaddr.ss_family != AF_UNSPEC) {
2372 /* Bind to the specified local IP address */
2373 struct socket *socket = server->ssocket;
2374 rc = socket->ops->bind(socket,
2375 (struct sockaddr *) &server->srcaddr,
2376 sizeof(server->srcaddr));
2378 struct sockaddr_in *saddr4;
2379 struct sockaddr_in6 *saddr6;
2380 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2381 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2382 if (saddr6->sin6_family == AF_INET6)
2384 "Failed to bind to: %pI6c, error: %d\n",
2385 &saddr6->sin6_addr, rc);
2388 "Failed to bind to: %pI4, error: %d\n",
2389 &saddr4->sin_addr.s_addr, rc);
2396 ip_rfc1001_connect(struct TCP_Server_Info *server)
2400 * some servers require RFC1001 sessinit before sending
2401 * negprot - BB check reconnection in case where second
2402 * sessinit is sent but no second negprot
2404 struct rfc1002_session_packet *ses_init_buf;
2405 struct smb_hdr *smb_buf;
2406 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2409 ses_init_buf->trailer.session_req.called_len = 32;
2411 if (server->server_RFC1001_name &&
2412 server->server_RFC1001_name[0] != 0)
2413 rfc1002mangle(ses_init_buf->trailer.
2414 session_req.called_name,
2415 server->server_RFC1001_name,
2416 RFC1001_NAME_LEN_WITH_NULL);
2418 rfc1002mangle(ses_init_buf->trailer.
2419 session_req.called_name,
2420 DEFAULT_CIFS_CALLED_NAME,
2421 RFC1001_NAME_LEN_WITH_NULL);
2423 ses_init_buf->trailer.session_req.calling_len = 32;
2426 * calling name ends in null (byte 16) from old smb
2429 if (server->workstation_RFC1001_name &&
2430 server->workstation_RFC1001_name[0] != 0)
2431 rfc1002mangle(ses_init_buf->trailer.
2432 session_req.calling_name,
2433 server->workstation_RFC1001_name,
2434 RFC1001_NAME_LEN_WITH_NULL);
2436 rfc1002mangle(ses_init_buf->trailer.
2437 session_req.calling_name,
2439 RFC1001_NAME_LEN_WITH_NULL);
2441 ses_init_buf->trailer.session_req.scope1 = 0;
2442 ses_init_buf->trailer.session_req.scope2 = 0;
2443 smb_buf = (struct smb_hdr *)ses_init_buf;
2445 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2446 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
2447 rc = smb_send(server, smb_buf, 0x44);
2448 kfree(ses_init_buf);
2450 * RFC1001 layer in at least one server
2451 * requires very short break before negprot
2452 * presumably because not expecting negprot
2453 * to follow so fast. This is a simple
2454 * solution that works without
2455 * complicating the code and causes no
2456 * significant slowing down on mount
2459 usleep_range(1000, 2000);
2462 * else the negprot may still work without this
2463 * even though malloc failed
2470 generic_ip_connect(struct TCP_Server_Info *server)
2475 struct socket *socket = server->ssocket;
2476 struct sockaddr *saddr;
2478 saddr = (struct sockaddr *) &server->dstaddr;
2480 if (server->dstaddr.ss_family == AF_INET6) {
2481 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2482 slen = sizeof(struct sockaddr_in6);
2485 sport = ((struct sockaddr_in *) saddr)->sin_port;
2486 slen = sizeof(struct sockaddr_in);
2490 if (socket == NULL) {
2491 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2492 IPPROTO_TCP, &socket, 1);
2494 cERROR(1, "Error %d creating socket", rc);
2495 server->ssocket = NULL;
2499 /* BB other socket options to set KEEPALIVE, NODELAY? */
2500 cFYI(1, "Socket created");
2501 server->ssocket = socket;
2502 socket->sk->sk_allocation = GFP_NOFS;
2503 if (sfamily == AF_INET6)
2504 cifs_reclassify_socket6(socket);
2506 cifs_reclassify_socket4(socket);
2509 rc = bind_socket(server);
2514 * Eventually check for other socket options to change from
2515 * the default. sock_setsockopt not used because it expects
2518 socket->sk->sk_rcvtimeo = 7 * HZ;
2519 socket->sk->sk_sndtimeo = 5 * HZ;
2521 /* make the bufsizes depend on wsize/rsize and max requests */
2522 if (server->noautotune) {
2523 if (socket->sk->sk_sndbuf < (200 * 1024))
2524 socket->sk->sk_sndbuf = 200 * 1024;
2525 if (socket->sk->sk_rcvbuf < (140 * 1024))
2526 socket->sk->sk_rcvbuf = 140 * 1024;
2529 if (server->tcp_nodelay) {
2531 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2532 (char *)&val, sizeof(val));
2534 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
2537 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
2538 socket->sk->sk_sndbuf,
2539 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
2541 rc = socket->ops->connect(socket, saddr, slen, 0);
2543 cFYI(1, "Error %d connecting to server", rc);
2544 sock_release(socket);
2545 server->ssocket = NULL;
2549 if (sport == htons(RFC1001_PORT))
2550 rc = ip_rfc1001_connect(server);
2556 ip_connect(struct TCP_Server_Info *server)
2559 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2560 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2562 if (server->dstaddr.ss_family == AF_INET6)
2563 sport = &addr6->sin6_port;
2565 sport = &addr->sin_port;
2570 /* try with 445 port at first */
2571 *sport = htons(CIFS_PORT);
2573 rc = generic_ip_connect(server);
2577 /* if it failed, try with 139 port */
2578 *sport = htons(RFC1001_PORT);
2581 return generic_ip_connect(server);
2584 void reset_cifs_unix_caps(int xid, struct cifs_tcon *tcon,
2585 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
2587 /* if we are reconnecting then should we check to see if
2588 * any requested capabilities changed locally e.g. via
2589 * remount but we can not do much about it here
2590 * if they have (even if we could detect it by the following)
2591 * Perhaps we could add a backpointer to array of sb from tcon
2592 * or if we change to make all sb to same share the same
2593 * sb as NFS - then we only have one backpointer to sb.
2594 * What if we wanted to mount the server share twice once with
2595 * and once without posixacls or posix paths? */
2596 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2598 if (vol_info && vol_info->no_linux_ext) {
2599 tcon->fsUnixInfo.Capability = 0;
2600 tcon->unix_ext = 0; /* Unix Extensions disabled */
2601 cFYI(1, "Linux protocol extensions disabled");
2603 } else if (vol_info)
2604 tcon->unix_ext = 1; /* Unix Extensions supported */
2606 if (tcon->unix_ext == 0) {
2607 cFYI(1, "Unix extensions disabled so not set on reconnect");
2611 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
2612 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2613 cFYI(1, "unix caps which server supports %lld", cap);
2614 /* check for reconnect case in which we do not
2615 want to change the mount behavior if we can avoid it */
2616 if (vol_info == NULL) {
2617 /* turn off POSIX ACL and PATHNAMES if not set
2618 originally at mount time */
2619 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2620 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2621 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2622 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2623 cERROR(1, "POSIXPATH support change");
2624 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2625 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2626 cERROR(1, "possible reconnect error");
2627 cERROR(1, "server disabled POSIX path support");
2631 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
2632 cERROR(1, "per-share encryption not supported yet");
2634 cap &= CIFS_UNIX_CAP_MASK;
2635 if (vol_info && vol_info->no_psx_acl)
2636 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2637 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
2638 cFYI(1, "negotiated posix acl support");
2640 cifs_sb->mnt_cifs_flags |=
2641 CIFS_MOUNT_POSIXACL;
2644 if (vol_info && vol_info->posix_paths == 0)
2645 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2646 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2647 cFYI(1, "negotiate posix pathnames");
2649 cifs_sb->mnt_cifs_flags |=
2650 CIFS_MOUNT_POSIX_PATHS;
2653 if (cifs_sb && (cifs_sb->rsize > 127 * 1024)) {
2654 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
2655 cifs_sb->rsize = 127 * 1024;
2656 cFYI(DBG2, "larger reads not supported by srv");
2661 cFYI(1, "Negotiate caps 0x%x", (int)cap);
2662 #ifdef CONFIG_CIFS_DEBUG2
2663 if (cap & CIFS_UNIX_FCNTL_CAP)
2664 cFYI(1, "FCNTL cap");
2665 if (cap & CIFS_UNIX_EXTATTR_CAP)
2666 cFYI(1, "EXTATTR cap");
2667 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2668 cFYI(1, "POSIX path cap");
2669 if (cap & CIFS_UNIX_XATTR_CAP)
2670 cFYI(1, "XATTR cap");
2671 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
2672 cFYI(1, "POSIX ACL cap");
2673 if (cap & CIFS_UNIX_LARGE_READ_CAP)
2674 cFYI(1, "very large read cap");
2675 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
2676 cFYI(1, "very large write cap");
2677 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
2678 cFYI(1, "transport encryption cap");
2679 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
2680 cFYI(1, "mandatory transport encryption cap");
2681 #endif /* CIFS_DEBUG2 */
2682 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
2683 if (vol_info == NULL) {
2684 cFYI(1, "resetting capabilities failed");
2686 cERROR(1, "Negotiating Unix capabilities "
2687 "with the server failed. Consider "
2688 "mounting with the Unix Extensions\n"
2689 "disabled, if problems are found, "
2690 "by specifying the nounix mount "
2697 void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
2698 struct cifs_sb_info *cifs_sb)
2700 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
2702 spin_lock_init(&cifs_sb->tlink_tree_lock);
2703 cifs_sb->tlink_tree = RB_ROOT;
2705 if (pvolume_info->rsize > CIFSMaxBufSize) {
2706 cERROR(1, "rsize %d too large, using MaxBufSize",
2707 pvolume_info->rsize);
2708 cifs_sb->rsize = CIFSMaxBufSize;
2709 } else if ((pvolume_info->rsize) &&
2710 (pvolume_info->rsize <= CIFSMaxBufSize))
2711 cifs_sb->rsize = pvolume_info->rsize;
2713 cifs_sb->rsize = CIFSMaxBufSize;
2715 if (cifs_sb->rsize < 2048) {
2716 cifs_sb->rsize = 2048;
2717 /* Windows ME may prefer this */
2718 cFYI(1, "readsize set to minimum: 2048");
2722 * Temporarily set wsize for matching superblock. If we end up using
2723 * new sb then cifs_negotiate_wsize will later negotiate it downward
2726 cifs_sb->wsize = pvolume_info->wsize;
2728 cifs_sb->mnt_uid = pvolume_info->linux_uid;
2729 cifs_sb->mnt_gid = pvolume_info->linux_gid;
2730 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2731 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
2732 cFYI(1, "file mode: 0x%x dir mode: 0x%x",
2733 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
2735 cifs_sb->actimeo = pvolume_info->actimeo;
2736 cifs_sb->local_nls = pvolume_info->local_nls;
2738 if (pvolume_info->noperm)
2739 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2740 if (pvolume_info->setuids)
2741 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2742 if (pvolume_info->server_ino)
2743 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2744 if (pvolume_info->remap)
2745 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2746 if (pvolume_info->no_xattr)
2747 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2748 if (pvolume_info->sfu_emul)
2749 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2750 if (pvolume_info->nobrl)
2751 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2752 if (pvolume_info->nostrictsync)
2753 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
2754 if (pvolume_info->mand_lock)
2755 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
2756 if (pvolume_info->rwpidforward)
2757 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
2758 if (pvolume_info->cifs_acl)
2759 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2760 if (pvolume_info->override_uid)
2761 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2762 if (pvolume_info->override_gid)
2763 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2764 if (pvolume_info->dynperm)
2765 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2766 if (pvolume_info->fsc)
2767 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
2768 if (pvolume_info->multiuser)
2769 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
2770 CIFS_MOUNT_NO_PERM);
2771 if (pvolume_info->strict_io)
2772 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
2773 if (pvolume_info->direct_io) {
2774 cFYI(1, "mounting share using direct i/o");
2775 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2777 if (pvolume_info->mfsymlinks) {
2778 if (pvolume_info->sfu_emul) {
2779 cERROR(1, "mount option mfsymlinks ignored if sfu "
2780 "mount option is used");
2782 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
2786 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
2787 cERROR(1, "mount option dynperm ignored if cifsacl "
2788 "mount option supported");
2792 * When the server supports very large writes via POSIX extensions, we can
2793 * allow up to 2^24-1, minus the size of a WRITE_AND_X header, not including
2794 * the RFC1001 length.
2796 * Note that this might make for "interesting" allocation problems during
2797 * writeback however as we have to allocate an array of pointers for the
2798 * pages. A 16M write means ~32kb page array with PAGE_CACHE_SIZE == 4096.
2800 #define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
2803 * When the server doesn't allow large posix writes, only allow a wsize of
2804 * 128k minus the size of the WRITE_AND_X header. That allows for a write up
2805 * to the maximum size described by RFC1002.
2807 #define CIFS_MAX_RFC1002_WSIZE (128 * 1024 - sizeof(WRITE_REQ) + 4)
2810 * The default wsize is 1M. find_get_pages seems to return a maximum of 256
2811 * pages in a single call. With PAGE_CACHE_SIZE == 4k, this means we can fill
2812 * a single wsize request with a single call.
2814 #define CIFS_DEFAULT_WSIZE (1024 * 1024)
2817 cifs_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
2819 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2820 struct TCP_Server_Info *server = tcon->ses->server;
2821 unsigned int wsize = pvolume_info->wsize ? pvolume_info->wsize :
2824 /* can server support 24-bit write sizes? (via UNIX extensions) */
2825 if (!tcon->unix_ext || !(unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
2826 wsize = min_t(unsigned int, wsize, CIFS_MAX_RFC1002_WSIZE);
2829 * no CAP_LARGE_WRITE_X or is signing enabled without CAP_UNIX set?
2830 * Limit it to max buffer offered by the server, minus the size of the
2831 * WRITEX header, not including the 4 byte RFC1001 length.
2833 if (!(server->capabilities & CAP_LARGE_WRITE_X) ||
2834 (!(server->capabilities & CAP_UNIX) &&
2835 (server->sec_mode & (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED))))
2836 wsize = min_t(unsigned int, wsize,
2837 server->maxBuf - sizeof(WRITE_REQ) + 4);
2839 /* hard limit of CIFS_MAX_WSIZE */
2840 wsize = min_t(unsigned int, wsize, CIFS_MAX_WSIZE);
2846 is_path_accessible(int xid, struct cifs_tcon *tcon,
2847 struct cifs_sb_info *cifs_sb, const char *full_path)
2850 FILE_ALL_INFO *pfile_info;
2852 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
2853 if (pfile_info == NULL)
2856 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
2857 0 /* not legacy */, cifs_sb->local_nls,
2858 cifs_sb->mnt_cifs_flags &
2859 CIFS_MOUNT_MAP_SPECIAL_CHR);
2861 if (rc == -EOPNOTSUPP || rc == -EINVAL)
2862 rc = SMBQueryInformation(xid, tcon, full_path, pfile_info,
2863 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
2864 CIFS_MOUNT_MAP_SPECIAL_CHR);
2870 cleanup_volume_info_contents(struct smb_vol *volume_info)
2872 kfree(volume_info->username);
2873 kzfree(volume_info->password);
2874 kfree(volume_info->UNC);
2875 if (volume_info->UNCip != volume_info->UNC + 2)
2876 kfree(volume_info->UNCip);
2877 kfree(volume_info->domainname);
2878 kfree(volume_info->iocharset);
2879 kfree(volume_info->prepath);
2883 cifs_cleanup_volume_info(struct smb_vol *volume_info)
2887 cleanup_volume_info_contents(volume_info);
2892 #ifdef CONFIG_CIFS_DFS_UPCALL
2893 /* build_path_to_root returns full path to root when
2894 * we do not have an exiting connection (tcon) */
2896 build_unc_path_to_root(const struct smb_vol *vol,
2897 const struct cifs_sb_info *cifs_sb)
2899 char *full_path, *pos;
2900 unsigned int pplen = vol->prepath ? strlen(vol->prepath) : 0;
2901 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
2903 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
2904 if (full_path == NULL)
2905 return ERR_PTR(-ENOMEM);
2907 strncpy(full_path, vol->UNC, unc_len);
2908 pos = full_path + unc_len;
2911 strncpy(pos, vol->prepath, pplen);
2915 *pos = '\0'; /* add trailing null */
2916 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
2917 cFYI(1, "%s: full_path=%s", __func__, full_path);
2922 * Perform a dfs referral query for a share and (optionally) prefix
2924 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
2925 * to a string containing updated options for the submount. Otherwise it
2926 * will be left untouched.
2928 * Returns the rc from get_dfs_path to the caller, which can be used to
2929 * determine whether there were referrals.
2932 expand_dfs_referral(int xid, struct cifs_ses *pSesInfo,
2933 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
2937 unsigned int num_referrals = 0;
2938 struct dfs_info3_param *referrals = NULL;
2939 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
2941 full_path = build_unc_path_to_root(volume_info, cifs_sb);
2942 if (IS_ERR(full_path))
2943 return PTR_ERR(full_path);
2945 /* For DFS paths, skip the first '\' of the UNC */
2946 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
2948 rc = get_dfs_path(xid, pSesInfo , ref_path, cifs_sb->local_nls,
2949 &num_referrals, &referrals,
2950 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
2952 if (!rc && num_referrals > 0) {
2953 char *fake_devname = NULL;
2955 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
2956 full_path + 1, referrals,
2959 free_dfs_info_array(referrals, num_referrals);
2961 if (IS_ERR(mdata)) {
2962 rc = PTR_ERR(mdata);
2965 cleanup_volume_info_contents(volume_info);
2966 memset(volume_info, '\0', sizeof(*volume_info));
2967 rc = cifs_setup_volume_info(volume_info, mdata,
2970 kfree(fake_devname);
2971 kfree(cifs_sb->mountdata);
2972 cifs_sb->mountdata = mdata;
2980 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
2981 const char *devname)
2985 if (cifs_parse_mount_options(mount_data, devname, volume_info))
2988 if (volume_info->nullauth) {
2989 cFYI(1, "null user");
2990 volume_info->username = kzalloc(1, GFP_KERNEL);
2991 if (volume_info->username == NULL)
2993 } else if (volume_info->username) {
2994 /* BB fixme parse for domain name here */
2995 cFYI(1, "Username: %s", volume_info->username);
2997 cifserror("No username specified");
2998 /* In userspace mount helper we can get user name from alternate
2999 locations such as env variables and files on disk */
3003 /* this is needed for ASCII cp to Unicode converts */
3004 if (volume_info->iocharset == NULL) {
3005 /* load_nls_default cannot return null */
3006 volume_info->local_nls = load_nls_default();
3008 volume_info->local_nls = load_nls(volume_info->iocharset);
3009 if (volume_info->local_nls == NULL) {
3010 cERROR(1, "CIFS mount error: iocharset %s not found",
3011 volume_info->iocharset);
3020 cifs_get_volume_info(char *mount_data, const char *devname)
3023 struct smb_vol *volume_info;
3025 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
3027 return ERR_PTR(-ENOMEM);
3029 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3031 cifs_cleanup_volume_info(volume_info);
3032 volume_info = ERR_PTR(rc);
3039 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3043 struct cifs_ses *pSesInfo;
3044 struct cifs_tcon *tcon;
3045 struct TCP_Server_Info *srvTcp;
3047 struct tcon_link *tlink;
3048 #ifdef CONFIG_CIFS_DFS_UPCALL
3049 int referral_walks_count = 0;
3052 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3056 cifs_sb->bdi.ra_pages = default_backing_dev_info.ra_pages;
3058 #ifdef CONFIG_CIFS_DFS_UPCALL
3060 /* cleanup activities if we're chasing a referral */
3061 if (referral_walks_count) {
3063 cifs_put_tcon(tcon);
3065 cifs_put_smb_ses(pSesInfo);
3078 /* get a reference to a tcp session */
3079 srvTcp = cifs_get_tcp_session(volume_info);
3080 if (IS_ERR(srvTcp)) {
3081 rc = PTR_ERR(srvTcp);
3082 bdi_destroy(&cifs_sb->bdi);
3086 /* get a reference to a SMB session */
3087 pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
3088 if (IS_ERR(pSesInfo)) {
3089 rc = PTR_ERR(pSesInfo);
3091 goto mount_fail_check;
3094 /* search for existing tcon to this server share */
3095 tcon = cifs_get_tcon(pSesInfo, volume_info);
3099 goto remote_path_check;
3102 /* tell server which Unix caps we support */
3103 if (tcon->ses->capabilities & CAP_UNIX) {
3104 /* reset of caps checks mount to see if unix extensions
3105 disabled for just this mount */
3106 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3107 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3108 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3109 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3111 goto mount_fail_check;
3114 tcon->unix_ext = 0; /* server does not support them */
3116 /* do not care if following two calls succeed - informational */
3118 CIFSSMBQFSDeviceInfo(xid, tcon);
3119 CIFSSMBQFSAttributeInfo(xid, tcon);
3122 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
3123 cifs_sb->rsize = 1024 * 127;
3124 cFYI(DBG2, "no very large read support, rsize now 127K");
3126 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
3127 cifs_sb->rsize = min(cifs_sb->rsize, CIFSMaxBufSize);
3129 cifs_sb->wsize = cifs_negotiate_wsize(tcon, volume_info);
3132 #ifdef CONFIG_CIFS_DFS_UPCALL
3134 * Perform an unconditional check for whether there are DFS
3135 * referrals for this path without prefix, to provide support
3136 * for DFS referrals from w2k8 servers which don't seem to respond
3137 * with PATH_NOT_COVERED to requests that include the prefix.
3138 * Chase the referral if found, otherwise continue normally.
3140 if (referral_walks_count == 0) {
3141 int refrc = expand_dfs_referral(xid, pSesInfo, volume_info,
3144 referral_walks_count++;
3145 goto try_mount_again;
3150 /* check if a whole path is not remote */
3152 /* build_path_to_root works only when we have a valid tcon */
3153 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3154 if (full_path == NULL) {
3156 goto mount_fail_check;
3158 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
3159 if (rc != 0 && rc != -EREMOTE) {
3161 goto mount_fail_check;
3166 /* get referral if needed */
3167 if (rc == -EREMOTE) {
3168 #ifdef CONFIG_CIFS_DFS_UPCALL
3169 if (referral_walks_count > MAX_NESTED_LINKS) {
3171 * BB: when we implement proper loop detection,
3172 * we will remove this check. But now we need it
3173 * to prevent an indefinite loop if 'DFS tree' is
3174 * misconfigured (i.e. has loops).
3177 goto mount_fail_check;
3180 rc = expand_dfs_referral(xid, pSesInfo, volume_info, cifs_sb,
3184 referral_walks_count++;
3185 goto try_mount_again;
3187 goto mount_fail_check;
3188 #else /* No DFS support, return error on mount */
3194 goto mount_fail_check;
3196 /* now, hang the tcon off of the superblock */
3197 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3198 if (tlink == NULL) {
3200 goto mount_fail_check;
3203 tlink->tl_uid = pSesInfo->linux_uid;
3204 tlink->tl_tcon = tcon;
3205 tlink->tl_time = jiffies;
3206 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3207 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3209 cifs_sb->master_tlink = tlink;
3210 spin_lock(&cifs_sb->tlink_tree_lock);
3211 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3212 spin_unlock(&cifs_sb->tlink_tree_lock);
3214 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
3218 /* on error free sesinfo and tcon struct if needed */
3220 /* If find_unc succeeded then rc == 0 so we can not end */
3221 /* up accidentally freeing someone elses tcon struct */
3223 cifs_put_tcon(tcon);
3225 cifs_put_smb_ses(pSesInfo);
3227 cifs_put_tcp_session(srvTcp);
3228 bdi_destroy(&cifs_sb->bdi);
3237 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3238 * pointer may be NULL.
3241 CIFSTCon(unsigned int xid, struct cifs_ses *ses,
3242 const char *tree, struct cifs_tcon *tcon,
3243 const struct nls_table *nls_codepage)
3245 struct smb_hdr *smb_buffer;
3246 struct smb_hdr *smb_buffer_response;
3249 unsigned char *bcc_ptr;
3252 __u16 bytes_left, count;
3257 smb_buffer = cifs_buf_get();
3258 if (smb_buffer == NULL)
3261 smb_buffer_response = smb_buffer;
3263 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3264 NULL /*no tid */ , 4 /*wct */ );
3266 smb_buffer->Mid = GetNextMid(ses->server);
3267 smb_buffer->Uid = ses->Suid;
3268 pSMB = (TCONX_REQ *) smb_buffer;
3269 pSMBr = (TCONX_RSP *) smb_buffer_response;
3271 pSMB->AndXCommand = 0xFF;
3272 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3273 bcc_ptr = &pSMB->Password[0];
3274 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3275 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3276 *bcc_ptr = 0; /* password is null byte */
3277 bcc_ptr++; /* skip password */
3278 /* already aligned so no need to do it below */
3280 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3281 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3282 specified as required (when that support is added to
3283 the vfs in the future) as only NTLM or the much
3284 weaker LANMAN (which we do not send by default) is accepted
3285 by Samba (not sure whether other servers allow
3286 NTLMv2 password here) */
3287 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3288 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3289 (ses->server->secType == LANMAN))
3290 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3291 ses->server->sec_mode &
3292 SECMODE_PW_ENCRYPT ? true : false,
3295 #endif /* CIFS_WEAK_PW_HASH */
3296 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3299 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3300 if (ses->capabilities & CAP_UNICODE) {
3301 /* must align unicode strings */
3302 *bcc_ptr = 0; /* null byte password */
3307 if (ses->server->sec_mode &
3308 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3309 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3311 if (ses->capabilities & CAP_STATUS32) {
3312 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3314 if (ses->capabilities & CAP_DFS) {
3315 smb_buffer->Flags2 |= SMBFLG2_DFS;
3317 if (ses->capabilities & CAP_UNICODE) {
3318 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3320 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3321 6 /* max utf8 char length in bytes */ *
3322 (/* server len*/ + 256 /* share len */), nls_codepage);
3323 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3324 bcc_ptr += 2; /* skip trailing null */
3325 } else { /* ASCII */
3326 strcpy(bcc_ptr, tree);
3327 bcc_ptr += strlen(tree) + 1;
3329 strcpy(bcc_ptr, "?????");
3330 bcc_ptr += strlen("?????");
3332 count = bcc_ptr - &pSMB->Password[0];
3333 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3334 pSMB->hdr.smb_buf_length) + count);
3335 pSMB->ByteCount = cpu_to_le16(count);
3337 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3340 /* above now done in SendReceive */
3341 if ((rc == 0) && (tcon != NULL)) {
3344 tcon->tidStatus = CifsGood;
3345 tcon->need_reconnect = false;
3346 tcon->tid = smb_buffer_response->Tid;
3347 bcc_ptr = pByteArea(smb_buffer_response);
3348 bytes_left = get_bcc(smb_buffer_response);
3349 length = strnlen(bcc_ptr, bytes_left - 2);
3350 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3356 /* skip service field (NB: this field is always ASCII) */
3358 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3359 (bcc_ptr[2] == 'C')) {
3360 cFYI(1, "IPC connection");
3363 } else if (length == 2) {
3364 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3365 /* the most common case */
3366 cFYI(1, "disk share connection");
3369 bcc_ptr += length + 1;
3370 bytes_left -= (length + 1);
3371 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3373 /* mostly informational -- no need to fail on error here */
3374 kfree(tcon->nativeFileSystem);
3375 tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
3376 bytes_left, is_unicode,
3379 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
3381 if ((smb_buffer_response->WordCount == 3) ||
3382 (smb_buffer_response->WordCount == 7))
3383 /* field is in same location */
3384 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3387 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
3388 } else if ((rc == 0) && tcon == NULL) {
3389 /* all we need to save for IPC$ connection */
3390 ses->ipc_tid = smb_buffer_response->Tid;
3393 cifs_buf_release(smb_buffer);
3398 cifs_umount(struct cifs_sb_info *cifs_sb)
3400 struct rb_root *root = &cifs_sb->tlink_tree;
3401 struct rb_node *node;
3402 struct tcon_link *tlink;
3404 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3406 spin_lock(&cifs_sb->tlink_tree_lock);
3407 while ((node = rb_first(root))) {
3408 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3409 cifs_get_tlink(tlink);
3410 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3411 rb_erase(node, root);
3413 spin_unlock(&cifs_sb->tlink_tree_lock);
3414 cifs_put_tlink(tlink);
3415 spin_lock(&cifs_sb->tlink_tree_lock);
3417 spin_unlock(&cifs_sb->tlink_tree_lock);
3419 bdi_destroy(&cifs_sb->bdi);
3420 kfree(cifs_sb->mountdata);
3421 unload_nls(cifs_sb->local_nls);
3425 int cifs_negotiate_protocol(unsigned int xid, struct cifs_ses *ses)
3428 struct TCP_Server_Info *server = ses->server;
3430 /* only send once per connect */
3431 if (server->maxBuf != 0)
3434 rc = CIFSSMBNegotiate(xid, ses);
3435 if (rc == -EAGAIN) {
3436 /* retry only once on 1st time connection */
3437 rc = CIFSSMBNegotiate(xid, ses);
3442 spin_lock(&GlobalMid_Lock);
3443 if (server->tcpStatus == CifsNeedNegotiate)
3444 server->tcpStatus = CifsGood;
3447 spin_unlock(&GlobalMid_Lock);
3455 int cifs_setup_session(unsigned int xid, struct cifs_ses *ses,
3456 struct nls_table *nls_info)
3459 struct TCP_Server_Info *server = ses->server;
3462 ses->capabilities = server->capabilities;
3463 if (linuxExtEnabled == 0)
3464 ses->capabilities &= (~CAP_UNIX);
3466 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3467 server->sec_mode, server->capabilities, server->timeAdj);
3469 rc = CIFS_SessSetup(xid, ses, nls_info);
3471 cERROR(1, "Send error in SessSetup = %d", rc);
3473 mutex_lock(&ses->server->srv_mutex);
3474 if (!server->session_estab) {
3475 server->session_key.response = ses->auth_key.response;
3476 server->session_key.len = ses->auth_key.len;
3477 server->sequence_number = 0x2;
3478 server->session_estab = true;
3479 ses->auth_key.response = NULL;
3481 mutex_unlock(&server->srv_mutex);
3483 cFYI(1, "CIFS Session Established successfully");
3484 spin_lock(&GlobalMid_Lock);
3485 ses->status = CifsGood;
3486 ses->need_reconnect = false;
3487 spin_unlock(&GlobalMid_Lock);
3490 kfree(ses->auth_key.response);
3491 ses->auth_key.response = NULL;
3492 ses->auth_key.len = 0;
3493 kfree(ses->ntlmssp);
3494 ses->ntlmssp = NULL;
3499 static struct cifs_tcon *
3500 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
3502 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3503 struct cifs_ses *ses;
3504 struct cifs_tcon *tcon = NULL;
3505 struct smb_vol *vol_info;
3506 char username[28]; /* big enough for "krb50x" + hex of ULONG_MAX 6+16 */
3507 /* We used to have this as MAX_USERNAME which is */
3508 /* way too big now (256 instead of 32) */
3510 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3511 if (vol_info == NULL) {
3512 tcon = ERR_PTR(-ENOMEM);
3516 snprintf(username, sizeof(username), "krb50x%x", fsuid);
3517 vol_info->username = username;
3518 vol_info->local_nls = cifs_sb->local_nls;
3519 vol_info->linux_uid = fsuid;
3520 vol_info->cred_uid = fsuid;
3521 vol_info->UNC = master_tcon->treeName;
3522 vol_info->retry = master_tcon->retry;
3523 vol_info->nocase = master_tcon->nocase;
3524 vol_info->local_lease = master_tcon->local_lease;
3525 vol_info->no_linux_ext = !master_tcon->unix_ext;
3527 /* FIXME: allow for other secFlg settings */
3528 vol_info->secFlg = CIFSSEC_MUST_KRB5;
3530 /* get a reference for the same TCP session */
3531 spin_lock(&cifs_tcp_ses_lock);
3532 ++master_tcon->ses->server->srv_count;
3533 spin_unlock(&cifs_tcp_ses_lock);
3535 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3537 tcon = (struct cifs_tcon *)ses;
3538 cifs_put_tcp_session(master_tcon->ses->server);
3542 tcon = cifs_get_tcon(ses, vol_info);
3544 cifs_put_smb_ses(ses);
3548 if (ses->capabilities & CAP_UNIX)
3549 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3557 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3559 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3563 cifs_sb_tcon_pending_wait(void *unused)
3566 return signal_pending(current) ? -ERESTARTSYS : 0;
3569 /* find and return a tlink with given uid */
3570 static struct tcon_link *
3571 tlink_rb_search(struct rb_root *root, uid_t uid)
3573 struct rb_node *node = root->rb_node;
3574 struct tcon_link *tlink;
3577 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3579 if (tlink->tl_uid > uid)
3580 node = node->rb_left;
3581 else if (tlink->tl_uid < uid)
3582 node = node->rb_right;
3589 /* insert a tcon_link into the tree */
3591 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3593 struct rb_node **new = &(root->rb_node), *parent = NULL;
3594 struct tcon_link *tlink;
3597 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3600 if (tlink->tl_uid > new_tlink->tl_uid)
3601 new = &((*new)->rb_left);
3603 new = &((*new)->rb_right);
3606 rb_link_node(&new_tlink->tl_rbnode, parent, new);
3607 rb_insert_color(&new_tlink->tl_rbnode, root);
3611 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3614 * If the superblock doesn't refer to a multiuser mount, then just return
3615 * the master tcon for the mount.
3617 * First, search the rbtree for an existing tcon for this fsuid. If one
3618 * exists, then check to see if it's pending construction. If it is then wait
3619 * for construction to complete. Once it's no longer pending, check to see if
3620 * it failed and either return an error or retry construction, depending on
3623 * If one doesn't exist then insert a new tcon_link struct into the tree and
3624 * try to construct a new one.
3627 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
3630 uid_t fsuid = current_fsuid();
3631 struct tcon_link *tlink, *newtlink;
3633 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
3634 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3636 spin_lock(&cifs_sb->tlink_tree_lock);
3637 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3639 cifs_get_tlink(tlink);
3640 spin_unlock(&cifs_sb->tlink_tree_lock);
3642 if (tlink == NULL) {
3643 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
3644 if (newtlink == NULL)
3645 return ERR_PTR(-ENOMEM);
3646 newtlink->tl_uid = fsuid;
3647 newtlink->tl_tcon = ERR_PTR(-EACCES);
3648 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
3649 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
3650 cifs_get_tlink(newtlink);
3652 spin_lock(&cifs_sb->tlink_tree_lock);
3653 /* was one inserted after previous search? */
3654 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3656 cifs_get_tlink(tlink);
3657 spin_unlock(&cifs_sb->tlink_tree_lock);
3659 goto wait_for_construction;
3662 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3663 spin_unlock(&cifs_sb->tlink_tree_lock);
3665 wait_for_construction:
3666 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
3667 cifs_sb_tcon_pending_wait,
3668 TASK_INTERRUPTIBLE);
3670 cifs_put_tlink(tlink);
3671 return ERR_PTR(ret);
3674 /* if it's good, return it */
3675 if (!IS_ERR(tlink->tl_tcon))
3678 /* return error if we tried this already recently */
3679 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
3680 cifs_put_tlink(tlink);
3681 return ERR_PTR(-EACCES);
3684 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
3685 goto wait_for_construction;
3688 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
3689 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
3690 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
3692 if (IS_ERR(tlink->tl_tcon)) {
3693 cifs_put_tlink(tlink);
3694 return ERR_PTR(-EACCES);
3701 * periodic workqueue job that scans tcon_tree for a superblock and closes
3705 cifs_prune_tlinks(struct work_struct *work)
3707 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
3709 struct rb_root *root = &cifs_sb->tlink_tree;
3710 struct rb_node *node = rb_first(root);
3711 struct rb_node *tmp;
3712 struct tcon_link *tlink;
3715 * Because we drop the spinlock in the loop in order to put the tlink
3716 * it's not guarded against removal of links from the tree. The only
3717 * places that remove entries from the tree are this function and
3718 * umounts. Because this function is non-reentrant and is canceled
3719 * before umount can proceed, this is safe.
3721 spin_lock(&cifs_sb->tlink_tree_lock);
3722 node = rb_first(root);
3723 while (node != NULL) {
3725 node = rb_next(tmp);
3726 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
3728 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
3729 atomic_read(&tlink->tl_count) != 0 ||
3730 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
3733 cifs_get_tlink(tlink);
3734 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3735 rb_erase(tmp, root);
3737 spin_unlock(&cifs_sb->tlink_tree_lock);
3738 cifs_put_tlink(tlink);
3739 spin_lock(&cifs_sb->tlink_tree_lock);
3741 spin_unlock(&cifs_sb->tlink_tree_lock);
3743 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,