4 * Copyright (C) International Business Machines Corp., 2002,2009
5 * Author(s): Steve French (sfrench@us.ibm.com)
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/net.h>
23 #include <linux/string.h>
24 #include <linux/list.h>
25 #include <linux/wait.h>
26 #include <linux/slab.h>
27 #include <linux/pagemap.h>
28 #include <linux/ctype.h>
29 #include <linux/utsname.h>
30 #include <linux/mempool.h>
31 #include <linux/delay.h>
32 #include <linux/completion.h>
33 #include <linux/kthread.h>
34 #include <linux/pagevec.h>
35 #include <linux/freezer.h>
36 #include <linux/namei.h>
37 #include <asm/uaccess.h>
38 #include <asm/processor.h>
39 #include <linux/inet.h>
43 #include "cifsproto.h"
44 #include "cifs_unicode.h"
45 #include "cifs_debug.h"
46 #include "cifs_fs_sb.h"
49 #include "rfc1002pdu.h"
53 #define RFC1001_PORT 139
55 /* SMB echo "timeout" -- FIXME: tunable? */
56 #define SMB_ECHO_INTERVAL (60 * HZ)
58 extern mempool_t *cifs_req_poolp;
60 /* FIXME: should these be tunable? */
61 #define TLINK_ERROR_EXPIRE (1 * HZ)
62 #define TLINK_IDLE_EXPIRE (600 * HZ)
64 static int ip_connect(struct TCP_Server_Info *server);
65 static int generic_ip_connect(struct TCP_Server_Info *server);
66 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
67 static void cifs_prune_tlinks(struct work_struct *work);
68 static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
72 * cifs tcp session reconnection
74 * mark tcp session as reconnecting so temporarily locked
75 * mark all smb sessions as reconnecting for tcp session
76 * reconnect tcp session
77 * wake up waiters on reconnection? - (not needed currently)
80 cifs_reconnect(struct TCP_Server_Info *server)
83 struct list_head *tmp, *tmp2;
85 struct cifs_tcon *tcon;
86 struct mid_q_entry *mid_entry;
87 struct list_head retry_list;
89 spin_lock(&GlobalMid_Lock);
90 if (server->tcpStatus == CifsExiting) {
91 /* the demux thread will exit normally
92 next time through the loop */
93 spin_unlock(&GlobalMid_Lock);
96 server->tcpStatus = CifsNeedReconnect;
97 spin_unlock(&GlobalMid_Lock);
100 cFYI(1, "Reconnecting tcp session");
102 /* before reconnecting the tcp session, mark the smb session (uid)
103 and the tid bad so they are not used until reconnected */
104 cFYI(1, "%s: marking sessions and tcons for reconnect", __func__);
105 spin_lock(&cifs_tcp_ses_lock);
106 list_for_each(tmp, &server->smb_ses_list) {
107 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
108 ses->need_reconnect = true;
110 list_for_each(tmp2, &ses->tcon_list) {
111 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
112 tcon->need_reconnect = true;
115 spin_unlock(&cifs_tcp_ses_lock);
117 /* do not want to be sending data on a socket we are freeing */
118 cFYI(1, "%s: tearing down socket", __func__);
119 mutex_lock(&server->srv_mutex);
120 if (server->ssocket) {
121 cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
122 server->ssocket->flags);
123 kernel_sock_shutdown(server->ssocket, SHUT_WR);
124 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
125 server->ssocket->state,
126 server->ssocket->flags);
127 sock_release(server->ssocket);
128 server->ssocket = NULL;
130 server->sequence_number = 0;
131 server->session_estab = false;
132 kfree(server->session_key.response);
133 server->session_key.response = NULL;
134 server->session_key.len = 0;
135 server->lstrp = jiffies;
136 mutex_unlock(&server->srv_mutex);
138 /* mark submitted MIDs for retry and issue callback */
139 INIT_LIST_HEAD(&retry_list);
140 cFYI(1, "%s: moving mids to private list", __func__);
141 spin_lock(&GlobalMid_Lock);
142 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
143 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
144 if (mid_entry->midState == MID_REQUEST_SUBMITTED)
145 mid_entry->midState = MID_RETRY_NEEDED;
146 list_move(&mid_entry->qhead, &retry_list);
148 spin_unlock(&GlobalMid_Lock);
150 cFYI(1, "%s: issuing mid callbacks", __func__);
151 list_for_each_safe(tmp, tmp2, &retry_list) {
152 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
153 list_del_init(&mid_entry->qhead);
154 mid_entry->callback(mid_entry);
160 /* we should try only the port we connected to before */
161 rc = generic_ip_connect(server);
163 cFYI(1, "reconnect error %d", rc);
166 atomic_inc(&tcpSesReconnectCount);
167 spin_lock(&GlobalMid_Lock);
168 if (server->tcpStatus != CifsExiting)
169 server->tcpStatus = CifsNeedNegotiate;
170 spin_unlock(&GlobalMid_Lock);
172 } while (server->tcpStatus == CifsNeedReconnect);
179 0 not a transact2, or all data present
180 >0 transact2 with that much data missing
181 -EINVAL = invalid transact2
184 static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
186 struct smb_t2_rsp *pSMBt;
188 __u16 total_data_size, data_in_this_rsp;
190 if (pSMB->Command != SMB_COM_TRANSACTION2)
193 /* check for plausible wct, bcc and t2 data and parm sizes */
194 /* check for parm and data offset going beyond end of smb */
195 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
196 cFYI(1, "invalid transact2 word count");
200 pSMBt = (struct smb_t2_rsp *)pSMB;
202 total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
203 data_in_this_rsp = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
205 if (total_data_size == data_in_this_rsp)
207 else if (total_data_size < data_in_this_rsp) {
208 cFYI(1, "total data %d smaller than data in frame %d",
209 total_data_size, data_in_this_rsp);
213 remaining = total_data_size - data_in_this_rsp;
215 cFYI(1, "missing %d bytes from transact2, check next response",
217 if (total_data_size > maxBufSize) {
218 cERROR(1, "TotalDataSize %d is over maximum buffer %d",
219 total_data_size, maxBufSize);
225 static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
227 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
228 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
229 char *data_area_of_target;
230 char *data_area_of_buf2;
232 unsigned int byte_count, total_in_buf;
233 __u16 total_data_size, total_in_buf2;
235 total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
237 if (total_data_size !=
238 get_unaligned_le16(&pSMB2->t2_rsp.TotalDataCount))
239 cFYI(1, "total data size of primary and secondary t2 differ");
241 total_in_buf = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
243 remaining = total_data_size - total_in_buf;
248 if (remaining == 0) /* nothing to do, ignore */
251 total_in_buf2 = get_unaligned_le16(&pSMB2->t2_rsp.DataCount);
252 if (remaining < total_in_buf2) {
253 cFYI(1, "transact2 2nd response contains too much data");
256 /* find end of first SMB data area */
257 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
258 get_unaligned_le16(&pSMBt->t2_rsp.DataOffset);
259 /* validate target area */
261 data_area_of_buf2 = (char *)&pSMB2->hdr.Protocol +
262 get_unaligned_le16(&pSMB2->t2_rsp.DataOffset);
264 data_area_of_target += total_in_buf;
266 /* copy second buffer into end of first buffer */
267 total_in_buf += total_in_buf2;
268 /* is the result too big for the field? */
269 if (total_in_buf > USHRT_MAX)
271 put_unaligned_le16(total_in_buf, &pSMBt->t2_rsp.DataCount);
274 byte_count = get_bcc(pTargetSMB);
275 byte_count += total_in_buf2;
276 /* is the result too big for the field? */
277 if (byte_count > USHRT_MAX)
279 put_bcc(byte_count, pTargetSMB);
281 byte_count = be32_to_cpu(pTargetSMB->smb_buf_length);
282 byte_count += total_in_buf2;
283 /* don't allow buffer to overflow */
284 if (byte_count > CIFSMaxBufSize)
286 pTargetSMB->smb_buf_length = cpu_to_be32(byte_count);
288 memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
290 if (remaining == total_in_buf2) {
291 cFYI(1, "found the last secondary response");
292 return 0; /* we are done */
293 } else /* more responses to go */
298 cifs_echo_request(struct work_struct *work)
301 struct TCP_Server_Info *server = container_of(work,
302 struct TCP_Server_Info, echo.work);
305 * We cannot send an echo until the NEGOTIATE_PROTOCOL request is
306 * done, which is indicated by maxBuf != 0. Also, no need to ping if
307 * we got a response recently
309 if (server->maxBuf == 0 ||
310 time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
313 rc = CIFSSMBEcho(server);
315 cFYI(1, "Unable to send echo request to server: %s",
319 queue_delayed_work(system_nrt_wq, &server->echo, SMB_ECHO_INTERVAL);
323 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 cifs_demultiplex_thread(void *p)
365 struct TCP_Server_Info *server = p;
366 unsigned int pdu_length, total_read;
367 char *buf = NULL, *bigbuf = NULL, *smallbuf = NULL;
368 struct smb_hdr *smb_buffer = NULL;
369 struct msghdr smb_msg;
371 struct socket *csocket = server->ssocket;
372 struct list_head *tmp, *tmp2;
373 struct task_struct *task_to_wake = NULL;
374 struct mid_q_entry *mid_entry;
376 bool isLargeBuf = false;
380 current->flags |= PF_MEMALLOC;
381 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
383 length = atomic_inc_return(&tcpSesAllocCount);
385 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
389 while (server->tcpStatus != CifsExiting) {
393 if (!allocate_buffers(&bigbuf, &smallbuf,
394 sizeof(struct smb_hdr), isLargeBuf))
399 smb_buffer = (struct smb_hdr *)smallbuf;
403 smb_msg.msg_control = NULL;
404 smb_msg.msg_controllen = 0;
405 pdu_length = 4; /* enough to get RFC1001 header */
408 if (echo_retries > 0 && server->tcpStatus == CifsGood &&
409 time_after(jiffies, server->lstrp +
410 (echo_retries * SMB_ECHO_INTERVAL))) {
411 cERROR(1, "Server %s has not responded in %d seconds. "
412 "Reconnecting...", server->hostname,
413 (echo_retries * SMB_ECHO_INTERVAL / HZ));
414 cifs_reconnect(server);
415 csocket = server->ssocket;
416 wake_up(&server->response_q);
421 kernel_recvmsg(csocket, &smb_msg,
422 &iov, 1, pdu_length, 0 /* BB other flags? */);
424 if (server->tcpStatus == CifsExiting) {
426 } else if (server->tcpStatus == CifsNeedReconnect) {
427 cFYI(1, "Reconnect after server stopped responding");
428 cifs_reconnect(server);
429 cFYI(1, "call to reconnect done");
430 csocket = server->ssocket;
432 } else if (length == -ERESTARTSYS ||
435 msleep(1); /* minimum sleep to prevent looping
436 allowing socket to clear and app threads to set
437 tcpStatus CifsNeedReconnect if server hung */
438 if (pdu_length < 4) {
439 iov.iov_base = (4 - pdu_length) + buf;
440 iov.iov_len = pdu_length;
441 smb_msg.msg_control = NULL;
442 smb_msg.msg_controllen = 0;
446 } else if (length <= 0) {
447 cFYI(1, "Reconnect after unexpected peek error %d",
449 cifs_reconnect(server);
450 csocket = server->ssocket;
451 wake_up(&server->response_q);
453 } else if (length < pdu_length) {
454 cFYI(1, "requested %d bytes but only got %d bytes",
456 pdu_length -= length;
461 /* The right amount was read from socket - 4 bytes */
462 /* so we can now interpret the length field */
464 /* the first byte big endian of the length field,
465 is actually not part of the length but the type
466 with the most common, zero, as regular data */
469 /* Note that FC 1001 length is big endian on the wire,
470 but we convert it here so it is always manipulated
471 as host byte order */
472 pdu_length = be32_to_cpu(smb_buffer->smb_buf_length);
474 cFYI(1, "rfc1002 length 0x%x", pdu_length+4);
476 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
478 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
479 cFYI(1, "Good RFC 1002 session rsp");
481 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
482 /* we get this from Windows 98 instead of
483 an error on SMB negprot response */
484 cFYI(1, "Negative RFC1002 Session Response Error 0x%x)",
486 /* give server a second to clean up */
488 /* always try 445 first on reconnect since we get NACK
489 * on some if we ever connected to port 139 (the NACK
490 * is since we do not begin with RFC1001 session
493 cifs_set_port((struct sockaddr *)
494 &server->dstaddr, CIFS_PORT);
495 cifs_reconnect(server);
496 csocket = server->ssocket;
497 wake_up(&server->response_q);
499 } else if (temp != (char) 0) {
500 cERROR(1, "Unknown RFC 1002 frame");
501 cifs_dump_mem(" Received Data: ", buf, length);
502 cifs_reconnect(server);
503 csocket = server->ssocket;
507 /* else we have an SMB response */
508 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
509 (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
510 cERROR(1, "Invalid size SMB length %d pdu_length %d",
511 length, pdu_length+4);
512 cifs_reconnect(server);
513 csocket = server->ssocket;
514 wake_up(&server->response_q);
521 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
523 memcpy(bigbuf, smallbuf, 4);
524 smb_buffer = (struct smb_hdr *)bigbuf;
528 iov.iov_base = 4 + buf;
529 iov.iov_len = pdu_length;
530 for (total_read = 0; total_read < pdu_length;
531 total_read += length) {
532 length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
533 pdu_length - total_read, 0);
534 if (server->tcpStatus == CifsExiting) {
538 } else if (server->tcpStatus == CifsNeedReconnect) {
539 cifs_reconnect(server);
540 csocket = server->ssocket;
541 /* Reconnect wakes up rspns q */
542 /* Now we will reread sock */
545 } else if (length == -ERESTARTSYS ||
548 msleep(1); /* minimum sleep to prevent looping,
549 allowing socket to clear and app
550 threads to set tcpStatus
551 CifsNeedReconnect if server hung*/
554 } else if (length <= 0) {
555 cERROR(1, "Received no data, expecting %d",
556 pdu_length - total_read);
557 cifs_reconnect(server);
558 csocket = server->ssocket;
565 else if (reconnect == 1)
568 total_read += 4; /* account for rfc1002 hdr */
570 dump_smb(smb_buffer, total_read);
573 * We know that we received enough to get to the MID as we
574 * checked the pdu_length earlier. Now check to see
575 * if the rest of the header is OK. We borrow the length
576 * var for the rest of the loop to avoid a new stack var.
578 * 48 bytes is enough to display the header and a little bit
579 * into the payload for debugging purposes.
581 length = checkSMB(smb_buffer, smb_buffer->Mid, total_read);
583 cifs_dump_mem("Bad SMB: ", buf,
584 min_t(unsigned int, total_read, 48));
587 server->lstrp = jiffies;
589 spin_lock(&GlobalMid_Lock);
590 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
591 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
593 if (mid_entry->mid != smb_buffer->Mid ||
594 mid_entry->midState != MID_REQUEST_SUBMITTED ||
595 mid_entry->command != smb_buffer->Command) {
601 check2ndT2(smb_buffer, server->maxBuf) > 0) {
602 /* We have a multipart transact2 resp */
604 if (mid_entry->resp_buf) {
605 /* merge response - fix up 1st*/
606 length = coalesce_t2(smb_buffer,
607 mid_entry->resp_buf);
610 mid_entry->multiRsp = true;
613 /* all parts received or
614 * packet is malformed
616 mid_entry->multiEnd = true;
622 * FIXME: switch to already
623 * allocated largebuf?
625 cERROR(1, "1st trans2 resp "
628 /* Have first buffer */
629 mid_entry->resp_buf =
631 mid_entry->largeBuf = true;
637 mid_entry->resp_buf = smb_buffer;
638 mid_entry->largeBuf = isLargeBuf;
641 mid_entry->midState = MID_RESPONSE_RECEIVED;
643 mid_entry->midState = MID_RESPONSE_MALFORMED;
644 #ifdef CONFIG_CIFS_STATS2
645 mid_entry->when_received = jiffies;
647 list_del_init(&mid_entry->qhead);
650 spin_unlock(&GlobalMid_Lock);
652 if (mid_entry != NULL) {
653 mid_entry->callback(mid_entry);
654 /* Was previous buf put in mpx struct for multi-rsp? */
656 /* smb buffer will be freed by user thread */
662 } else if (length != 0) {
663 /* response sanity checks failed */
665 } else if (!is_valid_oplock_break(smb_buffer, server) &&
667 cERROR(1, "No task to wake, unknown frame received! "
668 "NumMids %d", atomic_read(&midCount));
669 cifs_dump_mem("Received Data is: ", buf,
670 sizeof(struct smb_hdr));
671 #ifdef CONFIG_CIFS_DEBUG2
672 cifs_dump_detail(smb_buffer);
673 cifs_dump_mids(server);
674 #endif /* CIFS_DEBUG2 */
677 } /* end while !EXITING */
679 /* take it off the list, if it's not already */
680 spin_lock(&cifs_tcp_ses_lock);
681 list_del_init(&server->tcp_ses_list);
682 spin_unlock(&cifs_tcp_ses_lock);
684 spin_lock(&GlobalMid_Lock);
685 server->tcpStatus = CifsExiting;
686 spin_unlock(&GlobalMid_Lock);
687 wake_up_all(&server->response_q);
689 /* check if we have blocked requests that need to free */
690 /* Note that cifs_max_pending is normally 50, but
691 can be set at module install time to as little as two */
692 spin_lock(&GlobalMid_Lock);
693 if (atomic_read(&server->inFlight) >= cifs_max_pending)
694 atomic_set(&server->inFlight, cifs_max_pending - 1);
695 /* We do not want to set the max_pending too low or we
696 could end up with the counter going negative */
697 spin_unlock(&GlobalMid_Lock);
698 /* Although there should not be any requests blocked on
699 this queue it can not hurt to be paranoid and try to wake up requests
700 that may haven been blocked when more than 50 at time were on the wire
701 to the same server - they now will see the session is in exit state
702 and get out of SendReceive. */
703 wake_up_all(&server->request_q);
704 /* give those requests time to exit */
707 if (server->ssocket) {
708 sock_release(csocket);
709 server->ssocket = NULL;
711 /* buffer usually freed in free_mid - need to free it here on exit */
712 cifs_buf_release(bigbuf);
713 if (smallbuf) /* no sense logging a debug message if NULL */
714 cifs_small_buf_release(smallbuf);
716 if (!list_empty(&server->pending_mid_q)) {
717 struct list_head dispose_list;
719 INIT_LIST_HEAD(&dispose_list);
720 spin_lock(&GlobalMid_Lock);
721 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
722 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
723 cFYI(1, "Clearing mid 0x%x", mid_entry->mid);
724 mid_entry->midState = MID_SHUTDOWN;
725 list_move(&mid_entry->qhead, &dispose_list);
727 spin_unlock(&GlobalMid_Lock);
729 /* now walk dispose list and issue callbacks */
730 list_for_each_safe(tmp, tmp2, &dispose_list) {
731 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
732 cFYI(1, "Callback mid 0x%x", mid_entry->mid);
733 list_del_init(&mid_entry->qhead);
734 mid_entry->callback(mid_entry);
736 /* 1/8th of sec is more than enough time for them to exit */
740 if (!list_empty(&server->pending_mid_q)) {
741 /* mpx threads have not exited yet give them
742 at least the smb send timeout time for long ops */
743 /* due to delays on oplock break requests, we need
744 to wait at least 45 seconds before giving up
745 on a request getting a response and going ahead
747 cFYI(1, "Wait for exit from demultiplex thread");
749 /* if threads still have not exited they are probably never
750 coming home not much else we can do but free the memory */
753 kfree(server->hostname);
754 task_to_wake = xchg(&server->tsk, NULL);
757 length = atomic_dec_return(&tcpSesAllocCount);
759 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
762 /* if server->tsk was NULL then wait for a signal before exiting */
764 set_current_state(TASK_INTERRUPTIBLE);
765 while (!signal_pending(current)) {
767 set_current_state(TASK_INTERRUPTIBLE);
769 set_current_state(TASK_RUNNING);
772 module_put_and_exit(0);
775 /* extract the host portion of the UNC string */
777 extract_hostname(const char *unc)
783 /* skip double chars at beginning of string */
784 /* BB: check validity of these bytes? */
787 /* delimiter between hostname and sharename is always '\\' now */
788 delim = strchr(src, '\\');
790 return ERR_PTR(-EINVAL);
793 dst = kmalloc((len + 1), GFP_KERNEL);
795 return ERR_PTR(-ENOMEM);
797 memcpy(dst, src, len);
804 cifs_parse_mount_options(const char *mountdata, const char *devname,
807 char *value, *data, *end;
808 char *mountdata_copy = NULL, *options;
809 unsigned int temp_len, i, j;
811 short int override_uid = -1;
812 short int override_gid = -1;
813 bool uid_specified = false;
814 bool gid_specified = false;
815 char *nodename = utsname()->nodename;
821 * does not have to be perfect mapping since field is
822 * informational, only used for servers that do not support
823 * port 445 and it can be overridden at mount time
825 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
826 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
827 vol->source_rfc1001_name[i] = toupper(nodename[i]);
829 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
830 /* null target name indicates to use *SMBSERVR default called name
831 if we end up sending RFC1001 session initialize */
832 vol->target_rfc1001_name[0] = 0;
833 vol->cred_uid = current_uid();
834 vol->linux_uid = current_uid();
835 vol->linux_gid = current_gid();
837 /* default to only allowing write access to owner of the mount */
838 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
840 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
841 /* default is always to request posix paths. */
842 vol->posix_paths = 1;
843 /* default to using server inode numbers where available */
846 vol->actimeo = CIFS_DEF_ACTIMEO;
849 goto cifs_parse_mount_err;
851 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
853 goto cifs_parse_mount_err;
855 options = mountdata_copy;
856 end = options + strlen(options);
857 if (strncmp(options, "sep=", 4) == 0) {
858 if (options[4] != 0) {
859 separator[0] = options[4];
862 cFYI(1, "Null separator not allowed");
866 while ((data = strsep(&options, separator)) != NULL) {
869 if ((value = strchr(data, '=')) != NULL)
872 /* Have to parse this before we parse for "user" */
873 if (strnicmp(data, "user_xattr", 10) == 0) {
875 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
877 } else if (strnicmp(data, "user", 4) == 0) {
880 "CIFS: invalid or missing username\n");
881 goto cifs_parse_mount_err;
882 } else if (!*value) {
883 /* null user, ie anonymous, authentication */
886 if (strnlen(value, MAX_USERNAME_SIZE) <
888 vol->username = kstrdup(value, GFP_KERNEL);
889 if (!vol->username) {
890 printk(KERN_WARNING "CIFS: no memory "
892 goto cifs_parse_mount_err;
895 printk(KERN_WARNING "CIFS: username too long\n");
896 goto cifs_parse_mount_err;
898 } else if (strnicmp(data, "pass", 4) == 0) {
900 vol->password = NULL;
902 } else if (value[0] == 0) {
903 /* check if string begins with double comma
904 since that would mean the password really
905 does start with a comma, and would not
906 indicate an empty string */
907 if (value[1] != separator[0]) {
908 vol->password = NULL;
912 temp_len = strlen(value);
913 /* removed password length check, NTLM passwords
914 can be arbitrarily long */
916 /* if comma in password, the string will be
917 prematurely null terminated. Commas in password are
918 specified across the cifs mount interface by a double
919 comma ie ,, and a comma used as in other cases ie ','
920 as a parameter delimiter/separator is single and due
921 to the strsep above is temporarily zeroed. */
923 /* NB: password legally can have multiple commas and
924 the only illegal character in a password is null */
926 if ((value[temp_len] == 0) &&
927 (value + temp_len < end) &&
928 (value[temp_len+1] == separator[0])) {
930 value[temp_len] = separator[0];
931 temp_len += 2; /* move after second comma */
932 while (value[temp_len] != 0) {
933 if (value[temp_len] == separator[0]) {
934 if (value[temp_len+1] ==
936 /* skip second comma */
939 /* single comma indicating start
946 if (value[temp_len] == 0) {
950 /* point option to start of next parm */
951 options = value + temp_len + 1;
953 /* go from value to value + temp_len condensing
954 double commas to singles. Note that this ends up
955 allocating a few bytes too many, which is ok */
956 vol->password = kzalloc(temp_len, GFP_KERNEL);
957 if (vol->password == NULL) {
958 printk(KERN_WARNING "CIFS: no memory "
960 goto cifs_parse_mount_err;
962 for (i = 0, j = 0; i < temp_len; i++, j++) {
963 vol->password[j] = value[i];
964 if (value[i] == separator[0]
965 && value[i+1] == separator[0]) {
966 /* skip second comma */
970 vol->password[j] = 0;
972 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
973 if (vol->password == NULL) {
974 printk(KERN_WARNING "CIFS: no memory "
976 goto cifs_parse_mount_err;
978 strcpy(vol->password, value);
980 } else if (!strnicmp(data, "ip", 2) ||
981 !strnicmp(data, "addr", 4)) {
982 if (!value || !*value) {
984 } else if (strnlen(value, INET6_ADDRSTRLEN) <
986 vol->UNCip = kstrdup(value, GFP_KERNEL);
988 printk(KERN_WARNING "CIFS: no memory "
990 goto cifs_parse_mount_err;
993 printk(KERN_WARNING "CIFS: ip address "
995 goto cifs_parse_mount_err;
997 } else if (strnicmp(data, "sec", 3) == 0) {
998 if (!value || !*value) {
999 cERROR(1, "no security value specified");
1001 } else if (strnicmp(value, "krb5i", 5) == 0) {
1002 vol->secFlg |= CIFSSEC_MAY_KRB5 |
1004 } else if (strnicmp(value, "krb5p", 5) == 0) {
1005 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
1006 CIFSSEC_MAY_KRB5; */
1007 cERROR(1, "Krb5 cifs privacy not supported");
1008 goto cifs_parse_mount_err;
1009 } else if (strnicmp(value, "krb5", 4) == 0) {
1010 vol->secFlg |= CIFSSEC_MAY_KRB5;
1011 } else if (strnicmp(value, "ntlmsspi", 8) == 0) {
1012 vol->secFlg |= CIFSSEC_MAY_NTLMSSP |
1014 } else if (strnicmp(value, "ntlmssp", 7) == 0) {
1015 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
1016 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
1017 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
1019 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
1020 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1021 } else if (strnicmp(value, "ntlmi", 5) == 0) {
1022 vol->secFlg |= CIFSSEC_MAY_NTLM |
1024 } else if (strnicmp(value, "ntlm", 4) == 0) {
1025 /* ntlm is default so can be turned off too */
1026 vol->secFlg |= CIFSSEC_MAY_NTLM;
1027 } else if (strnicmp(value, "nontlm", 6) == 0) {
1028 /* BB is there a better way to do this? */
1029 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1030 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1031 } else if (strnicmp(value, "lanman", 6) == 0) {
1032 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1034 } else if (strnicmp(value, "none", 4) == 0) {
1037 cERROR(1, "bad security option: %s", value);
1038 goto cifs_parse_mount_err;
1040 } else if (strnicmp(data, "vers", 3) == 0) {
1041 if (!value || !*value) {
1042 cERROR(1, "no protocol version specified"
1043 " after vers= mount option");
1044 } else if ((strnicmp(value, "cifs", 4) == 0) ||
1045 (strnicmp(value, "1", 1) == 0)) {
1046 /* this is the default */
1049 } else if ((strnicmp(data, "unc", 3) == 0)
1050 || (strnicmp(data, "target", 6) == 0)
1051 || (strnicmp(data, "path", 4) == 0)) {
1052 if (!value || !*value) {
1053 printk(KERN_WARNING "CIFS: invalid path to "
1054 "network resource\n");
1055 goto cifs_parse_mount_err;
1057 if ((temp_len = strnlen(value, 300)) < 300) {
1058 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1059 if (vol->UNC == NULL)
1060 goto cifs_parse_mount_err;
1061 strcpy(vol->UNC, value);
1062 if (strncmp(vol->UNC, "//", 2) == 0) {
1065 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1067 "CIFS: UNC Path does not begin "
1068 "with // or \\\\ \n");
1069 goto cifs_parse_mount_err;
1072 printk(KERN_WARNING "CIFS: UNC name too long\n");
1073 goto cifs_parse_mount_err;
1075 } else if ((strnicmp(data, "domain", 3) == 0)
1076 || (strnicmp(data, "workgroup", 5) == 0)) {
1077 if (!value || !*value) {
1078 printk(KERN_WARNING "CIFS: invalid domain name\n");
1079 goto cifs_parse_mount_err;
1081 /* BB are there cases in which a comma can be valid in
1082 a domain name and need special handling? */
1083 if (strnlen(value, 256) < 256) {
1084 vol->domainname = kstrdup(value, GFP_KERNEL);
1085 if (!vol->domainname) {
1086 printk(KERN_WARNING "CIFS: no memory "
1087 "for domainname\n");
1088 goto cifs_parse_mount_err;
1090 cFYI(1, "Domain name set");
1092 printk(KERN_WARNING "CIFS: domain name too "
1094 goto cifs_parse_mount_err;
1096 } else if (strnicmp(data, "srcaddr", 7) == 0) {
1097 vol->srcaddr.ss_family = AF_UNSPEC;
1099 if (!value || !*value) {
1100 printk(KERN_WARNING "CIFS: srcaddr value"
1101 " not specified.\n");
1102 goto cifs_parse_mount_err;
1104 i = cifs_convert_address((struct sockaddr *)&vol->srcaddr,
1105 value, strlen(value));
1107 printk(KERN_WARNING "CIFS: Could not parse"
1110 goto cifs_parse_mount_err;
1112 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1113 if (!value || !*value) {
1115 "CIFS: invalid path prefix\n");
1116 goto cifs_parse_mount_err;
1118 if ((temp_len = strnlen(value, 1024)) < 1024) {
1119 if (value[0] != '/')
1120 temp_len++; /* missing leading slash */
1121 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1122 if (vol->prepath == NULL)
1123 goto cifs_parse_mount_err;
1124 if (value[0] != '/') {
1125 vol->prepath[0] = '/';
1126 strcpy(vol->prepath+1, value);
1128 strcpy(vol->prepath, value);
1129 cFYI(1, "prefix path %s", vol->prepath);
1131 printk(KERN_WARNING "CIFS: prefix too long\n");
1132 goto cifs_parse_mount_err;
1134 } else if (strnicmp(data, "iocharset", 9) == 0) {
1135 if (!value || !*value) {
1136 printk(KERN_WARNING "CIFS: invalid iocharset "
1138 goto cifs_parse_mount_err;
1140 if (strnlen(value, 65) < 65) {
1141 if (strnicmp(value, "default", 7)) {
1142 vol->iocharset = kstrdup(value,
1145 if (!vol->iocharset) {
1146 printk(KERN_WARNING "CIFS: no "
1149 goto cifs_parse_mount_err;
1152 /* if iocharset not set then load_nls_default
1153 is used by caller */
1154 cFYI(1, "iocharset set to %s", value);
1156 printk(KERN_WARNING "CIFS: iocharset name "
1158 goto cifs_parse_mount_err;
1160 } else if (!strnicmp(data, "uid", 3) && value && *value) {
1161 vol->linux_uid = simple_strtoul(value, &value, 0);
1162 uid_specified = true;
1163 } else if (!strnicmp(data, "cruid", 5) && value && *value) {
1164 vol->cred_uid = simple_strtoul(value, &value, 0);
1165 } else if (!strnicmp(data, "forceuid", 8)) {
1167 } else if (!strnicmp(data, "noforceuid", 10)) {
1169 } else if (!strnicmp(data, "gid", 3) && value && *value) {
1170 vol->linux_gid = simple_strtoul(value, &value, 0);
1171 gid_specified = true;
1172 } else if (!strnicmp(data, "forcegid", 8)) {
1174 } else if (!strnicmp(data, "noforcegid", 10)) {
1176 } else if (strnicmp(data, "file_mode", 4) == 0) {
1177 if (value && *value) {
1179 simple_strtoul(value, &value, 0);
1181 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1182 if (value && *value) {
1184 simple_strtoul(value, &value, 0);
1186 } else if (strnicmp(data, "dirmode", 4) == 0) {
1187 if (value && *value) {
1189 simple_strtoul(value, &value, 0);
1191 } else if (strnicmp(data, "port", 4) == 0) {
1192 if (value && *value) {
1194 simple_strtoul(value, &value, 0);
1196 } else if (strnicmp(data, "rsize", 5) == 0) {
1197 if (value && *value) {
1199 simple_strtoul(value, &value, 0);
1201 } else if (strnicmp(data, "wsize", 5) == 0) {
1202 if (value && *value) {
1204 simple_strtoul(value, &value, 0);
1206 } else if (strnicmp(data, "sockopt", 5) == 0) {
1207 if (!value || !*value) {
1208 cERROR(1, "no socket option specified");
1210 } else if (strnicmp(value, "TCP_NODELAY", 11) == 0) {
1211 vol->sockopt_tcp_nodelay = 1;
1213 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1214 if (!value || !*value || (*value == ' ')) {
1215 cFYI(1, "invalid (empty) netbiosname");
1217 memset(vol->source_rfc1001_name, 0x20,
1220 * FIXME: are there cases in which a comma can
1221 * be valid in workstation netbios name (and
1222 * need special handling)?
1224 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1225 /* don't ucase netbiosname for user */
1228 vol->source_rfc1001_name[i] = value[i];
1230 /* The string has 16th byte zero still from
1231 set at top of the function */
1232 if (i == RFC1001_NAME_LEN && value[i] != 0)
1233 printk(KERN_WARNING "CIFS: netbiosname"
1234 " longer than 15 truncated.\n");
1236 } else if (strnicmp(data, "servern", 7) == 0) {
1237 /* servernetbiosname specified override *SMBSERVER */
1238 if (!value || !*value || (*value == ' ')) {
1239 cFYI(1, "empty server netbiosname specified");
1241 /* last byte, type, is 0x20 for servr type */
1242 memset(vol->target_rfc1001_name, 0x20,
1243 RFC1001_NAME_LEN_WITH_NULL);
1245 for (i = 0; i < 15; i++) {
1246 /* BB are there cases in which a comma can be
1247 valid in this workstation netbios name
1248 (and need special handling)? */
1250 /* user or mount helper must uppercase
1255 vol->target_rfc1001_name[i] =
1258 /* The string has 16th byte zero still from
1259 set at top of the function */
1260 if (i == RFC1001_NAME_LEN && value[i] != 0)
1261 printk(KERN_WARNING "CIFS: server net"
1262 "biosname longer than 15 truncated.\n");
1264 } else if (strnicmp(data, "actimeo", 7) == 0) {
1265 if (value && *value) {
1266 vol->actimeo = HZ * simple_strtoul(value,
1268 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1269 cERROR(1, "CIFS: attribute cache"
1270 "timeout too large");
1271 goto cifs_parse_mount_err;
1274 } else if (strnicmp(data, "credentials", 4) == 0) {
1276 } else if (strnicmp(data, "version", 3) == 0) {
1278 } else if (strnicmp(data, "guest", 5) == 0) {
1280 } else if (strnicmp(data, "rw", 2) == 0) {
1282 } else if (strnicmp(data, "ro", 2) == 0) {
1284 } else if (strnicmp(data, "noblocksend", 11) == 0) {
1285 vol->noblocksnd = 1;
1286 } else if (strnicmp(data, "noautotune", 10) == 0) {
1287 vol->noautotune = 1;
1288 } else if ((strnicmp(data, "suid", 4) == 0) ||
1289 (strnicmp(data, "nosuid", 6) == 0) ||
1290 (strnicmp(data, "exec", 4) == 0) ||
1291 (strnicmp(data, "noexec", 6) == 0) ||
1292 (strnicmp(data, "nodev", 5) == 0) ||
1293 (strnicmp(data, "noauto", 6) == 0) ||
1294 (strnicmp(data, "dev", 3) == 0)) {
1295 /* The mount tool or mount.cifs helper (if present)
1296 uses these opts to set flags, and the flags are read
1297 by the kernel vfs layer before we get here (ie
1298 before read super) so there is no point trying to
1299 parse these options again and set anything and it
1300 is ok to just ignore them */
1302 } else if (strnicmp(data, "hard", 4) == 0) {
1304 } else if (strnicmp(data, "soft", 4) == 0) {
1306 } else if (strnicmp(data, "perm", 4) == 0) {
1308 } else if (strnicmp(data, "noperm", 6) == 0) {
1310 } else if (strnicmp(data, "mapchars", 8) == 0) {
1312 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1314 } else if (strnicmp(data, "sfu", 3) == 0) {
1316 } else if (strnicmp(data, "nosfu", 5) == 0) {
1318 } else if (strnicmp(data, "nodfs", 5) == 0) {
1320 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1321 vol->posix_paths = 1;
1322 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1323 vol->posix_paths = 0;
1324 } else if (strnicmp(data, "nounix", 6) == 0) {
1325 vol->no_linux_ext = 1;
1326 } else if (strnicmp(data, "nolinux", 7) == 0) {
1327 vol->no_linux_ext = 1;
1328 } else if ((strnicmp(data, "nocase", 6) == 0) ||
1329 (strnicmp(data, "ignorecase", 10) == 0)) {
1331 } else if (strnicmp(data, "mand", 4) == 0) {
1333 } else if (strnicmp(data, "nomand", 6) == 0) {
1335 } else if (strnicmp(data, "_netdev", 7) == 0) {
1337 } else if (strnicmp(data, "brl", 3) == 0) {
1339 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1340 (strnicmp(data, "nolock", 6) == 0)) {
1342 /* turn off mandatory locking in mode
1343 if remote locking is turned off since the
1344 local vfs will do advisory */
1345 if (vol->file_mode ==
1346 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1347 vol->file_mode = S_IALLUGO;
1348 } else if (strnicmp(data, "forcemandatorylock", 9) == 0) {
1349 /* will take the shorter form "forcemand" as well */
1350 /* This mount option will force use of mandatory
1351 (DOS/Windows style) byte range locks, instead of
1352 using posix advisory byte range locks, even if the
1353 Unix extensions are available and posix locks would
1354 be supported otherwise. If Unix extensions are not
1355 negotiated this has no effect since mandatory locks
1356 would be used (mandatory locks is all that those
1357 those servers support) */
1359 } else if (strnicmp(data, "setuids", 7) == 0) {
1361 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1363 } else if (strnicmp(data, "dynperm", 7) == 0) {
1364 vol->dynperm = true;
1365 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1366 vol->dynperm = false;
1367 } else if (strnicmp(data, "nohard", 6) == 0) {
1369 } else if (strnicmp(data, "nosoft", 6) == 0) {
1371 } else if (strnicmp(data, "nointr", 6) == 0) {
1373 } else if (strnicmp(data, "intr", 4) == 0) {
1375 } else if (strnicmp(data, "nostrictsync", 12) == 0) {
1376 vol->nostrictsync = 1;
1377 } else if (strnicmp(data, "strictsync", 10) == 0) {
1378 vol->nostrictsync = 0;
1379 } else if (strnicmp(data, "serverino", 7) == 0) {
1380 vol->server_ino = 1;
1381 } else if (strnicmp(data, "noserverino", 9) == 0) {
1382 vol->server_ino = 0;
1383 } else if (strnicmp(data, "rwpidforward", 4) == 0) {
1384 vol->rwpidforward = 1;
1385 } else if (strnicmp(data, "cifsacl", 7) == 0) {
1387 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1389 } else if (strnicmp(data, "acl", 3) == 0) {
1390 vol->no_psx_acl = 0;
1391 } else if (strnicmp(data, "noacl", 5) == 0) {
1392 vol->no_psx_acl = 1;
1393 } else if (strnicmp(data, "locallease", 6) == 0) {
1394 vol->local_lease = 1;
1395 } else if (strnicmp(data, "sign", 4) == 0) {
1396 vol->secFlg |= CIFSSEC_MUST_SIGN;
1397 } else if (strnicmp(data, "seal", 4) == 0) {
1398 /* we do not do the following in secFlags because seal
1399 is a per tree connection (mount) not a per socket
1400 or per-smb connection option in the protocol */
1401 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1403 } else if (strnicmp(data, "direct", 6) == 0) {
1405 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
1407 } else if (strnicmp(data, "strictcache", 11) == 0) {
1409 } else if (strnicmp(data, "noac", 4) == 0) {
1410 printk(KERN_WARNING "CIFS: Mount option noac not "
1411 "supported. Instead set "
1412 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1413 } else if (strnicmp(data, "fsc", 3) == 0) {
1414 #ifndef CONFIG_CIFS_FSCACHE
1415 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE "
1416 "kernel config option set");
1417 goto cifs_parse_mount_err;
1420 } else if (strnicmp(data, "mfsymlinks", 10) == 0) {
1421 vol->mfsymlinks = true;
1422 } else if (strnicmp(data, "multiuser", 8) == 0) {
1423 vol->multiuser = true;
1425 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1428 if (vol->UNC == NULL) {
1429 if (devname == NULL) {
1430 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1432 goto cifs_parse_mount_err;
1434 if ((temp_len = strnlen(devname, 300)) < 300) {
1435 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1436 if (vol->UNC == NULL)
1437 goto cifs_parse_mount_err;
1438 strcpy(vol->UNC, devname);
1439 if (strncmp(vol->UNC, "//", 2) == 0) {
1442 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1443 printk(KERN_WARNING "CIFS: UNC Path does not "
1444 "begin with // or \\\\ \n");
1445 goto cifs_parse_mount_err;
1447 value = strpbrk(vol->UNC+2, "/\\");
1451 printk(KERN_WARNING "CIFS: UNC name too long\n");
1452 goto cifs_parse_mount_err;
1456 if (vol->multiuser && !(vol->secFlg & CIFSSEC_MAY_KRB5)) {
1457 cERROR(1, "Multiuser mounts currently require krb5 "
1459 goto cifs_parse_mount_err;
1462 if (vol->UNCip == NULL)
1463 vol->UNCip = &vol->UNC[2];
1466 vol->override_uid = override_uid;
1467 else if (override_uid == 1)
1468 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1469 "specified with no uid= option.\n");
1472 vol->override_gid = override_gid;
1473 else if (override_gid == 1)
1474 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1475 "specified with no gid= option.\n");
1477 kfree(mountdata_copy);
1480 cifs_parse_mount_err:
1481 kfree(mountdata_copy);
1485 /** Returns true if srcaddr isn't specified and rhs isn't
1486 * specified, or if srcaddr is specified and
1487 * matches the IP address of the rhs argument.
1490 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1492 switch (srcaddr->sa_family) {
1494 return (rhs->sa_family == AF_UNSPEC);
1496 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1497 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1498 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1501 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1502 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1503 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1507 return false; /* don't expect to be here */
1512 * If no port is specified in addr structure, we try to match with 445 port
1513 * and if it fails - with 139 ports. It should be called only if address
1514 * families of server and addr are equal.
1517 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1519 __be16 port, *sport;
1521 switch (addr->sa_family) {
1523 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1524 port = ((struct sockaddr_in *) addr)->sin_port;
1527 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1528 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1536 port = htons(CIFS_PORT);
1540 port = htons(RFC1001_PORT);
1543 return port == *sport;
1547 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1548 struct sockaddr *srcaddr)
1550 switch (addr->sa_family) {
1552 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1553 struct sockaddr_in *srv_addr4 =
1554 (struct sockaddr_in *)&server->dstaddr;
1556 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1561 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1562 struct sockaddr_in6 *srv_addr6 =
1563 (struct sockaddr_in6 *)&server->dstaddr;
1565 if (!ipv6_addr_equal(&addr6->sin6_addr,
1566 &srv_addr6->sin6_addr))
1568 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
1574 return false; /* don't expect to be here */
1577 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1584 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
1586 unsigned int secFlags;
1588 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
1589 secFlags = vol->secFlg;
1591 secFlags = global_secflags | vol->secFlg;
1593 switch (server->secType) {
1595 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
1599 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
1603 if (!(secFlags & CIFSSEC_MAY_NTLM))
1607 if (!(secFlags & CIFSSEC_MAY_KRB5))
1611 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
1615 /* shouldn't happen */
1619 /* now check if signing mode is acceptable */
1620 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
1621 (server->sec_mode & SECMODE_SIGN_REQUIRED))
1623 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
1625 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
1631 static int match_server(struct TCP_Server_Info *server, struct sockaddr *addr,
1632 struct smb_vol *vol)
1634 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
1637 if (!match_address(server, addr,
1638 (struct sockaddr *)&vol->srcaddr))
1641 if (!match_port(server, addr))
1644 if (!match_security(server, vol))
1650 static struct TCP_Server_Info *
1651 cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
1653 struct TCP_Server_Info *server;
1655 spin_lock(&cifs_tcp_ses_lock);
1656 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
1657 if (!match_server(server, addr, vol))
1660 ++server->srv_count;
1661 spin_unlock(&cifs_tcp_ses_lock);
1662 cFYI(1, "Existing tcp session with server found");
1665 spin_unlock(&cifs_tcp_ses_lock);
1670 cifs_put_tcp_session(struct TCP_Server_Info *server)
1672 struct task_struct *task;
1674 spin_lock(&cifs_tcp_ses_lock);
1675 if (--server->srv_count > 0) {
1676 spin_unlock(&cifs_tcp_ses_lock);
1680 put_net(cifs_net_ns(server));
1682 list_del_init(&server->tcp_ses_list);
1683 spin_unlock(&cifs_tcp_ses_lock);
1685 cancel_delayed_work_sync(&server->echo);
1687 spin_lock(&GlobalMid_Lock);
1688 server->tcpStatus = CifsExiting;
1689 spin_unlock(&GlobalMid_Lock);
1691 cifs_crypto_shash_release(server);
1692 cifs_fscache_release_client_cookie(server);
1694 kfree(server->session_key.response);
1695 server->session_key.response = NULL;
1696 server->session_key.len = 0;
1698 task = xchg(&server->tsk, NULL);
1700 force_sig(SIGKILL, task);
1703 static struct TCP_Server_Info *
1704 cifs_get_tcp_session(struct smb_vol *volume_info)
1706 struct TCP_Server_Info *tcp_ses = NULL;
1707 struct sockaddr_storage addr;
1708 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
1709 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
1712 memset(&addr, 0, sizeof(struct sockaddr_storage));
1714 cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
1716 if (volume_info->UNCip && volume_info->UNC) {
1717 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
1719 strlen(volume_info->UNCip),
1722 /* we failed translating address */
1726 } else if (volume_info->UNCip) {
1727 /* BB using ip addr as tcp_ses name to connect to the
1729 cERROR(1, "Connecting to DFS root not implemented yet");
1732 } else /* which tcp_sess DFS root would we conect to */ {
1733 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
1734 "unc=//192.168.1.100/public) specified");
1739 /* see if we already have a matching tcp_ses */
1740 tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
1744 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1750 rc = cifs_crypto_shash_allocate(tcp_ses);
1752 cERROR(1, "could not setup hash structures rc %d", rc);
1756 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
1757 tcp_ses->hostname = extract_hostname(volume_info->UNC);
1758 if (IS_ERR(tcp_ses->hostname)) {
1759 rc = PTR_ERR(tcp_ses->hostname);
1760 goto out_err_crypto_release;
1763 tcp_ses->noblocksnd = volume_info->noblocksnd;
1764 tcp_ses->noautotune = volume_info->noautotune;
1765 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
1766 atomic_set(&tcp_ses->inFlight, 0);
1767 init_waitqueue_head(&tcp_ses->response_q);
1768 init_waitqueue_head(&tcp_ses->request_q);
1769 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1770 mutex_init(&tcp_ses->srv_mutex);
1771 memcpy(tcp_ses->workstation_RFC1001_name,
1772 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1773 memcpy(tcp_ses->server_RFC1001_name,
1774 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1775 tcp_ses->session_estab = false;
1776 tcp_ses->sequence_number = 0;
1777 tcp_ses->lstrp = jiffies;
1778 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1779 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1780 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
1783 * at this point we are the only ones with the pointer
1784 * to the struct since the kernel thread not created yet
1785 * no need to spinlock this init of tcpStatus or srv_count
1787 tcp_ses->tcpStatus = CifsNew;
1788 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
1789 sizeof(tcp_ses->srcaddr));
1790 ++tcp_ses->srv_count;
1792 if (addr.ss_family == AF_INET6) {
1793 cFYI(1, "attempting ipv6 connect");
1794 /* BB should we allow ipv6 on port 139? */
1795 /* other OS never observed in Wild doing 139 with v6 */
1796 memcpy(&tcp_ses->dstaddr, sin_server6,
1797 sizeof(struct sockaddr_in6));
1799 memcpy(&tcp_ses->dstaddr, sin_server,
1800 sizeof(struct sockaddr_in));
1802 rc = ip_connect(tcp_ses);
1804 cERROR(1, "Error connecting to socket. Aborting operation");
1805 goto out_err_crypto_release;
1809 * since we're in a cifs function already, we know that
1810 * this will succeed. No need for try_module_get().
1812 __module_get(THIS_MODULE);
1813 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
1815 if (IS_ERR(tcp_ses->tsk)) {
1816 rc = PTR_ERR(tcp_ses->tsk);
1817 cERROR(1, "error %d create cifsd thread", rc);
1818 module_put(THIS_MODULE);
1819 goto out_err_crypto_release;
1821 tcp_ses->tcpStatus = CifsNeedNegotiate;
1823 /* thread spawned, put it on the list */
1824 spin_lock(&cifs_tcp_ses_lock);
1825 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
1826 spin_unlock(&cifs_tcp_ses_lock);
1828 cifs_fscache_get_client_cookie(tcp_ses);
1830 /* queue echo request delayed work */
1831 queue_delayed_work(system_nrt_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
1835 out_err_crypto_release:
1836 cifs_crypto_shash_release(tcp_ses);
1838 put_net(cifs_net_ns(tcp_ses));
1842 if (!IS_ERR(tcp_ses->hostname))
1843 kfree(tcp_ses->hostname);
1844 if (tcp_ses->ssocket)
1845 sock_release(tcp_ses->ssocket);
1851 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
1853 switch (ses->server->secType) {
1855 if (vol->cred_uid != ses->cred_uid)
1859 /* anything else takes username/password */
1860 if (ses->user_name == NULL)
1862 if (strncmp(ses->user_name, vol->username,
1865 if (strlen(vol->username) != 0 &&
1866 ses->password != NULL &&
1867 strncmp(ses->password,
1868 vol->password ? vol->password : "",
1875 static struct cifs_ses *
1876 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
1878 struct cifs_ses *ses;
1880 spin_lock(&cifs_tcp_ses_lock);
1881 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
1882 if (!match_session(ses, vol))
1885 spin_unlock(&cifs_tcp_ses_lock);
1888 spin_unlock(&cifs_tcp_ses_lock);
1893 cifs_put_smb_ses(struct cifs_ses *ses)
1896 struct TCP_Server_Info *server = ses->server;
1898 cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
1899 spin_lock(&cifs_tcp_ses_lock);
1900 if (--ses->ses_count > 0) {
1901 spin_unlock(&cifs_tcp_ses_lock);
1905 list_del_init(&ses->smb_ses_list);
1906 spin_unlock(&cifs_tcp_ses_lock);
1908 if (ses->status == CifsGood) {
1910 CIFSSMBLogoff(xid, ses);
1914 cifs_put_tcp_session(server);
1917 static bool warned_on_ntlm; /* globals init to false automatically */
1919 static struct cifs_ses *
1920 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
1922 int rc = -ENOMEM, xid;
1923 struct cifs_ses *ses;
1924 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
1925 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
1929 ses = cifs_find_smb_ses(server, volume_info);
1931 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
1933 mutex_lock(&ses->session_mutex);
1934 rc = cifs_negotiate_protocol(xid, ses);
1936 mutex_unlock(&ses->session_mutex);
1937 /* problem -- put our ses reference */
1938 cifs_put_smb_ses(ses);
1942 if (ses->need_reconnect) {
1943 cFYI(1, "Session needs reconnect");
1944 rc = cifs_setup_session(xid, ses,
1945 volume_info->local_nls);
1947 mutex_unlock(&ses->session_mutex);
1948 /* problem -- put our reference */
1949 cifs_put_smb_ses(ses);
1954 mutex_unlock(&ses->session_mutex);
1956 /* existing SMB ses has a server reference already */
1957 cifs_put_tcp_session(server);
1962 cFYI(1, "Existing smb sess not found");
1963 ses = sesInfoAlloc();
1967 /* new SMB session uses our server ref */
1968 ses->server = server;
1969 if (server->dstaddr.ss_family == AF_INET6)
1970 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
1972 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
1974 if (volume_info->username) {
1975 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
1976 if (!ses->user_name)
1980 /* volume_info->password freed at unmount */
1981 if (volume_info->password) {
1982 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
1986 if (volume_info->domainname) {
1987 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
1988 if (!ses->domainName)
1991 ses->cred_uid = volume_info->cred_uid;
1992 ses->linux_uid = volume_info->linux_uid;
1994 /* ntlmv2 is much stronger than ntlm security, and has been broadly
1995 supported for many years, time to update default security mechanism */
1996 if ((volume_info->secFlg == 0) && warned_on_ntlm == false) {
1997 warned_on_ntlm = true;
1998 cERROR(1, "default security mechanism requested. The default "
1999 "security mechanism will be upgraded from ntlm to "
2000 "ntlmv2 in kernel release 3.1");
2002 ses->overrideSecFlg = volume_info->secFlg;
2004 mutex_lock(&ses->session_mutex);
2005 rc = cifs_negotiate_protocol(xid, ses);
2007 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2008 mutex_unlock(&ses->session_mutex);
2012 /* success, put it on the list */
2013 spin_lock(&cifs_tcp_ses_lock);
2014 list_add(&ses->smb_ses_list, &server->smb_ses_list);
2015 spin_unlock(&cifs_tcp_ses_lock);
2026 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2028 if (tcon->tidStatus == CifsExiting)
2030 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2035 static struct cifs_tcon *
2036 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2038 struct list_head *tmp;
2039 struct cifs_tcon *tcon;
2041 spin_lock(&cifs_tcp_ses_lock);
2042 list_for_each(tmp, &ses->tcon_list) {
2043 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2044 if (!match_tcon(tcon, unc))
2047 spin_unlock(&cifs_tcp_ses_lock);
2050 spin_unlock(&cifs_tcp_ses_lock);
2055 cifs_put_tcon(struct cifs_tcon *tcon)
2058 struct cifs_ses *ses = tcon->ses;
2060 cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2061 spin_lock(&cifs_tcp_ses_lock);
2062 if (--tcon->tc_count > 0) {
2063 spin_unlock(&cifs_tcp_ses_lock);
2067 list_del_init(&tcon->tcon_list);
2068 spin_unlock(&cifs_tcp_ses_lock);
2071 CIFSSMBTDis(xid, tcon);
2074 cifs_fscache_release_super_cookie(tcon);
2076 cifs_put_smb_ses(ses);
2079 static struct cifs_tcon *
2080 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2083 struct cifs_tcon *tcon;
2085 tcon = cifs_find_tcon(ses, volume_info->UNC);
2087 cFYI(1, "Found match on UNC path");
2088 /* existing tcon already has a reference */
2089 cifs_put_smb_ses(ses);
2090 if (tcon->seal != volume_info->seal)
2091 cERROR(1, "transport encryption setting "
2092 "conflicts with existing tid");
2096 tcon = tconInfoAlloc();
2103 if (volume_info->password) {
2104 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2105 if (!tcon->password) {
2111 if (strchr(volume_info->UNC + 3, '\\') == NULL
2112 && strchr(volume_info->UNC + 3, '/') == NULL) {
2113 cERROR(1, "Missing share name");
2118 /* BB Do we need to wrap session_mutex around
2119 * this TCon call and Unix SetFS as
2120 * we do on SessSetup and reconnect? */
2122 rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
2124 cFYI(1, "CIFS Tcon rc = %d", rc);
2128 if (volume_info->nodfs) {
2129 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2130 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2132 tcon->seal = volume_info->seal;
2133 /* we can have only one retry value for a connection
2134 to a share so for resources mounted more than once
2135 to the same server share the last value passed in
2136 for the retry flag is used */
2137 tcon->retry = volume_info->retry;
2138 tcon->nocase = volume_info->nocase;
2139 tcon->local_lease = volume_info->local_lease;
2141 spin_lock(&cifs_tcp_ses_lock);
2142 list_add(&tcon->tcon_list, &ses->tcon_list);
2143 spin_unlock(&cifs_tcp_ses_lock);
2145 cifs_fscache_get_super_cookie(tcon);
2155 cifs_put_tlink(struct tcon_link *tlink)
2157 if (!tlink || IS_ERR(tlink))
2160 if (!atomic_dec_and_test(&tlink->tl_count) ||
2161 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2162 tlink->tl_time = jiffies;
2166 if (!IS_ERR(tlink_tcon(tlink)))
2167 cifs_put_tcon(tlink_tcon(tlink));
2172 static inline struct tcon_link *
2173 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2175 return cifs_sb->master_tlink;
2179 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2181 struct cifs_sb_info *old = CIFS_SB(sb);
2182 struct cifs_sb_info *new = mnt_data->cifs_sb;
2184 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2187 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2188 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2191 if (old->rsize != new->rsize)
2195 * We want to share sb only if we don't specify wsize or specified wsize
2196 * is greater or equal than existing one.
2198 if (new->wsize && new->wsize < old->wsize)
2201 if (old->mnt_uid != new->mnt_uid || old->mnt_gid != new->mnt_gid)
2204 if (old->mnt_file_mode != new->mnt_file_mode ||
2205 old->mnt_dir_mode != new->mnt_dir_mode)
2208 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2211 if (old->actimeo != new->actimeo)
2218 cifs_match_super(struct super_block *sb, void *data)
2220 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2221 struct smb_vol *volume_info;
2222 struct cifs_sb_info *cifs_sb;
2223 struct TCP_Server_Info *tcp_srv;
2224 struct cifs_ses *ses;
2225 struct cifs_tcon *tcon;
2226 struct tcon_link *tlink;
2227 struct sockaddr_storage addr;
2230 memset(&addr, 0, sizeof(struct sockaddr_storage));
2232 spin_lock(&cifs_tcp_ses_lock);
2233 cifs_sb = CIFS_SB(sb);
2234 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2235 if (IS_ERR(tlink)) {
2236 spin_unlock(&cifs_tcp_ses_lock);
2239 tcon = tlink_tcon(tlink);
2241 tcp_srv = ses->server;
2243 volume_info = mnt_data->vol;
2245 if (!volume_info->UNCip || !volume_info->UNC)
2248 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
2250 strlen(volume_info->UNCip),
2255 if (!match_server(tcp_srv, (struct sockaddr *)&addr, volume_info) ||
2256 !match_session(ses, volume_info) ||
2257 !match_tcon(tcon, volume_info->UNC)) {
2262 rc = compare_mount_options(sb, mnt_data);
2264 spin_unlock(&cifs_tcp_ses_lock);
2265 cifs_put_tlink(tlink);
2270 get_dfs_path(int xid, struct cifs_ses *pSesInfo, const char *old_path,
2271 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
2272 struct dfs_info3_param **preferrals, int remap)
2277 *pnum_referrals = 0;
2280 if (pSesInfo->ipc_tid == 0) {
2281 temp_unc = kmalloc(2 /* for slashes */ +
2282 strnlen(pSesInfo->serverName,
2283 SERVER_NAME_LEN_WITH_NULL * 2)
2284 + 1 + 4 /* slash IPC$ */ + 2,
2286 if (temp_unc == NULL)
2290 strcpy(temp_unc + 2, pSesInfo->serverName);
2291 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2292 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
2293 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
2297 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
2298 pnum_referrals, nls_codepage, remap);
2299 /* BB map targetUNCs to dfs_info3 structures, here or
2300 in CIFSGetDFSRefer BB */
2305 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2306 static struct lock_class_key cifs_key[2];
2307 static struct lock_class_key cifs_slock_key[2];
2310 cifs_reclassify_socket4(struct socket *sock)
2312 struct sock *sk = sock->sk;
2313 BUG_ON(sock_owned_by_user(sk));
2314 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2315 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2319 cifs_reclassify_socket6(struct socket *sock)
2321 struct sock *sk = sock->sk;
2322 BUG_ON(sock_owned_by_user(sk));
2323 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2324 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2328 cifs_reclassify_socket4(struct socket *sock)
2333 cifs_reclassify_socket6(struct socket *sock)
2338 /* See RFC1001 section 14 on representation of Netbios names */
2339 static void rfc1002mangle(char *target, char *source, unsigned int length)
2343 for (i = 0, j = 0; i < (length); i++) {
2344 /* mask a nibble at a time and encode */
2345 target[j] = 'A' + (0x0F & (source[i] >> 4));
2346 target[j+1] = 'A' + (0x0F & source[i]);
2353 bind_socket(struct TCP_Server_Info *server)
2356 if (server->srcaddr.ss_family != AF_UNSPEC) {
2357 /* Bind to the specified local IP address */
2358 struct socket *socket = server->ssocket;
2359 rc = socket->ops->bind(socket,
2360 (struct sockaddr *) &server->srcaddr,
2361 sizeof(server->srcaddr));
2363 struct sockaddr_in *saddr4;
2364 struct sockaddr_in6 *saddr6;
2365 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2366 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2367 if (saddr6->sin6_family == AF_INET6)
2369 "Failed to bind to: %pI6c, error: %d\n",
2370 &saddr6->sin6_addr, rc);
2373 "Failed to bind to: %pI4, error: %d\n",
2374 &saddr4->sin_addr.s_addr, rc);
2381 ip_rfc1001_connect(struct TCP_Server_Info *server)
2385 * some servers require RFC1001 sessinit before sending
2386 * negprot - BB check reconnection in case where second
2387 * sessinit is sent but no second negprot
2389 struct rfc1002_session_packet *ses_init_buf;
2390 struct smb_hdr *smb_buf;
2391 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2394 ses_init_buf->trailer.session_req.called_len = 32;
2396 if (server->server_RFC1001_name &&
2397 server->server_RFC1001_name[0] != 0)
2398 rfc1002mangle(ses_init_buf->trailer.
2399 session_req.called_name,
2400 server->server_RFC1001_name,
2401 RFC1001_NAME_LEN_WITH_NULL);
2403 rfc1002mangle(ses_init_buf->trailer.
2404 session_req.called_name,
2405 DEFAULT_CIFS_CALLED_NAME,
2406 RFC1001_NAME_LEN_WITH_NULL);
2408 ses_init_buf->trailer.session_req.calling_len = 32;
2411 * calling name ends in null (byte 16) from old smb
2414 if (server->workstation_RFC1001_name &&
2415 server->workstation_RFC1001_name[0] != 0)
2416 rfc1002mangle(ses_init_buf->trailer.
2417 session_req.calling_name,
2418 server->workstation_RFC1001_name,
2419 RFC1001_NAME_LEN_WITH_NULL);
2421 rfc1002mangle(ses_init_buf->trailer.
2422 session_req.calling_name,
2424 RFC1001_NAME_LEN_WITH_NULL);
2426 ses_init_buf->trailer.session_req.scope1 = 0;
2427 ses_init_buf->trailer.session_req.scope2 = 0;
2428 smb_buf = (struct smb_hdr *)ses_init_buf;
2430 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2431 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
2432 rc = smb_send(server, smb_buf, 0x44);
2433 kfree(ses_init_buf);
2435 * RFC1001 layer in at least one server
2436 * requires very short break before negprot
2437 * presumably because not expecting negprot
2438 * to follow so fast. This is a simple
2439 * solution that works without
2440 * complicating the code and causes no
2441 * significant slowing down on mount
2444 usleep_range(1000, 2000);
2447 * else the negprot may still work without this
2448 * even though malloc failed
2455 generic_ip_connect(struct TCP_Server_Info *server)
2460 struct socket *socket = server->ssocket;
2461 struct sockaddr *saddr;
2463 saddr = (struct sockaddr *) &server->dstaddr;
2465 if (server->dstaddr.ss_family == AF_INET6) {
2466 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2467 slen = sizeof(struct sockaddr_in6);
2470 sport = ((struct sockaddr_in *) saddr)->sin_port;
2471 slen = sizeof(struct sockaddr_in);
2475 if (socket == NULL) {
2476 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2477 IPPROTO_TCP, &socket, 1);
2479 cERROR(1, "Error %d creating socket", rc);
2480 server->ssocket = NULL;
2484 /* BB other socket options to set KEEPALIVE, NODELAY? */
2485 cFYI(1, "Socket created");
2486 server->ssocket = socket;
2487 socket->sk->sk_allocation = GFP_NOFS;
2488 if (sfamily == AF_INET6)
2489 cifs_reclassify_socket6(socket);
2491 cifs_reclassify_socket4(socket);
2494 rc = bind_socket(server);
2499 * Eventually check for other socket options to change from
2500 * the default. sock_setsockopt not used because it expects
2503 socket->sk->sk_rcvtimeo = 7 * HZ;
2504 socket->sk->sk_sndtimeo = 5 * HZ;
2506 /* make the bufsizes depend on wsize/rsize and max requests */
2507 if (server->noautotune) {
2508 if (socket->sk->sk_sndbuf < (200 * 1024))
2509 socket->sk->sk_sndbuf = 200 * 1024;
2510 if (socket->sk->sk_rcvbuf < (140 * 1024))
2511 socket->sk->sk_rcvbuf = 140 * 1024;
2514 if (server->tcp_nodelay) {
2516 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2517 (char *)&val, sizeof(val));
2519 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
2522 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
2523 socket->sk->sk_sndbuf,
2524 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
2526 rc = socket->ops->connect(socket, saddr, slen, 0);
2528 cFYI(1, "Error %d connecting to server", rc);
2529 sock_release(socket);
2530 server->ssocket = NULL;
2534 if (sport == htons(RFC1001_PORT))
2535 rc = ip_rfc1001_connect(server);
2541 ip_connect(struct TCP_Server_Info *server)
2544 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2545 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2547 if (server->dstaddr.ss_family == AF_INET6)
2548 sport = &addr6->sin6_port;
2550 sport = &addr->sin_port;
2555 /* try with 445 port at first */
2556 *sport = htons(CIFS_PORT);
2558 rc = generic_ip_connect(server);
2562 /* if it failed, try with 139 port */
2563 *sport = htons(RFC1001_PORT);
2566 return generic_ip_connect(server);
2569 void reset_cifs_unix_caps(int xid, struct cifs_tcon *tcon,
2570 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
2572 /* if we are reconnecting then should we check to see if
2573 * any requested capabilities changed locally e.g. via
2574 * remount but we can not do much about it here
2575 * if they have (even if we could detect it by the following)
2576 * Perhaps we could add a backpointer to array of sb from tcon
2577 * or if we change to make all sb to same share the same
2578 * sb as NFS - then we only have one backpointer to sb.
2579 * What if we wanted to mount the server share twice once with
2580 * and once without posixacls or posix paths? */
2581 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2583 if (vol_info && vol_info->no_linux_ext) {
2584 tcon->fsUnixInfo.Capability = 0;
2585 tcon->unix_ext = 0; /* Unix Extensions disabled */
2586 cFYI(1, "Linux protocol extensions disabled");
2588 } else if (vol_info)
2589 tcon->unix_ext = 1; /* Unix Extensions supported */
2591 if (tcon->unix_ext == 0) {
2592 cFYI(1, "Unix extensions disabled so not set on reconnect");
2596 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
2597 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2598 cFYI(1, "unix caps which server supports %lld", cap);
2599 /* check for reconnect case in which we do not
2600 want to change the mount behavior if we can avoid it */
2601 if (vol_info == NULL) {
2602 /* turn off POSIX ACL and PATHNAMES if not set
2603 originally at mount time */
2604 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2605 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2606 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2607 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2608 cERROR(1, "POSIXPATH support change");
2609 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2610 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2611 cERROR(1, "possible reconnect error");
2612 cERROR(1, "server disabled POSIX path support");
2616 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
2617 cERROR(1, "per-share encryption not supported yet");
2619 cap &= CIFS_UNIX_CAP_MASK;
2620 if (vol_info && vol_info->no_psx_acl)
2621 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2622 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
2623 cFYI(1, "negotiated posix acl support");
2625 cifs_sb->mnt_cifs_flags |=
2626 CIFS_MOUNT_POSIXACL;
2629 if (vol_info && vol_info->posix_paths == 0)
2630 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2631 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2632 cFYI(1, "negotiate posix pathnames");
2634 cifs_sb->mnt_cifs_flags |=
2635 CIFS_MOUNT_POSIX_PATHS;
2638 if (cifs_sb && (cifs_sb->rsize > 127 * 1024)) {
2639 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
2640 cifs_sb->rsize = 127 * 1024;
2641 cFYI(DBG2, "larger reads not supported by srv");
2646 cFYI(1, "Negotiate caps 0x%x", (int)cap);
2647 #ifdef CONFIG_CIFS_DEBUG2
2648 if (cap & CIFS_UNIX_FCNTL_CAP)
2649 cFYI(1, "FCNTL cap");
2650 if (cap & CIFS_UNIX_EXTATTR_CAP)
2651 cFYI(1, "EXTATTR cap");
2652 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2653 cFYI(1, "POSIX path cap");
2654 if (cap & CIFS_UNIX_XATTR_CAP)
2655 cFYI(1, "XATTR cap");
2656 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
2657 cFYI(1, "POSIX ACL cap");
2658 if (cap & CIFS_UNIX_LARGE_READ_CAP)
2659 cFYI(1, "very large read cap");
2660 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
2661 cFYI(1, "very large write cap");
2662 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
2663 cFYI(1, "transport encryption cap");
2664 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
2665 cFYI(1, "mandatory transport encryption cap");
2666 #endif /* CIFS_DEBUG2 */
2667 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
2668 if (vol_info == NULL) {
2669 cFYI(1, "resetting capabilities failed");
2671 cERROR(1, "Negotiating Unix capabilities "
2672 "with the server failed. Consider "
2673 "mounting with the Unix Extensions\n"
2674 "disabled, if problems are found, "
2675 "by specifying the nounix mount "
2682 void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
2683 struct cifs_sb_info *cifs_sb)
2685 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
2687 spin_lock_init(&cifs_sb->tlink_tree_lock);
2688 cifs_sb->tlink_tree = RB_ROOT;
2690 if (pvolume_info->rsize > CIFSMaxBufSize) {
2691 cERROR(1, "rsize %d too large, using MaxBufSize",
2692 pvolume_info->rsize);
2693 cifs_sb->rsize = CIFSMaxBufSize;
2694 } else if ((pvolume_info->rsize) &&
2695 (pvolume_info->rsize <= CIFSMaxBufSize))
2696 cifs_sb->rsize = pvolume_info->rsize;
2698 cifs_sb->rsize = CIFSMaxBufSize;
2700 if (cifs_sb->rsize < 2048) {
2701 cifs_sb->rsize = 2048;
2702 /* Windows ME may prefer this */
2703 cFYI(1, "readsize set to minimum: 2048");
2707 * Temporarily set wsize for matching superblock. If we end up using
2708 * new sb then cifs_negotiate_wsize will later negotiate it downward
2711 cifs_sb->wsize = pvolume_info->wsize;
2713 cifs_sb->mnt_uid = pvolume_info->linux_uid;
2714 cifs_sb->mnt_gid = pvolume_info->linux_gid;
2715 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2716 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
2717 cFYI(1, "file mode: 0x%x dir mode: 0x%x",
2718 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
2720 cifs_sb->actimeo = pvolume_info->actimeo;
2721 cifs_sb->local_nls = pvolume_info->local_nls;
2723 if (pvolume_info->noperm)
2724 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2725 if (pvolume_info->setuids)
2726 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2727 if (pvolume_info->server_ino)
2728 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2729 if (pvolume_info->remap)
2730 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2731 if (pvolume_info->no_xattr)
2732 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2733 if (pvolume_info->sfu_emul)
2734 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2735 if (pvolume_info->nobrl)
2736 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2737 if (pvolume_info->nostrictsync)
2738 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
2739 if (pvolume_info->mand_lock)
2740 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
2741 if (pvolume_info->rwpidforward)
2742 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
2743 if (pvolume_info->cifs_acl)
2744 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2745 if (pvolume_info->override_uid)
2746 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2747 if (pvolume_info->override_gid)
2748 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2749 if (pvolume_info->dynperm)
2750 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2751 if (pvolume_info->fsc)
2752 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
2753 if (pvolume_info->multiuser)
2754 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
2755 CIFS_MOUNT_NO_PERM);
2756 if (pvolume_info->strict_io)
2757 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
2758 if (pvolume_info->direct_io) {
2759 cFYI(1, "mounting share using direct i/o");
2760 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2762 if (pvolume_info->mfsymlinks) {
2763 if (pvolume_info->sfu_emul) {
2764 cERROR(1, "mount option mfsymlinks ignored if sfu "
2765 "mount option is used");
2767 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
2771 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
2772 cERROR(1, "mount option dynperm ignored if cifsacl "
2773 "mount option supported");
2777 * When the server supports very large writes via POSIX extensions, we can
2778 * allow up to 2^24-1, minus the size of a WRITE_AND_X header, not including
2779 * the RFC1001 length.
2781 * Note that this might make for "interesting" allocation problems during
2782 * writeback however as we have to allocate an array of pointers for the
2783 * pages. A 16M write means ~32kb page array with PAGE_CACHE_SIZE == 4096.
2785 #define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
2788 * When the server doesn't allow large posix writes, only allow a wsize of
2789 * 128k minus the size of the WRITE_AND_X header. That allows for a write up
2790 * to the maximum size described by RFC1002.
2792 #define CIFS_MAX_RFC1002_WSIZE (128 * 1024 - sizeof(WRITE_REQ) + 4)
2795 * The default wsize is 1M. find_get_pages seems to return a maximum of 256
2796 * pages in a single call. With PAGE_CACHE_SIZE == 4k, this means we can fill
2797 * a single wsize request with a single call.
2799 #define CIFS_DEFAULT_WSIZE (1024 * 1024)
2802 cifs_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
2804 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2805 struct TCP_Server_Info *server = tcon->ses->server;
2806 unsigned int wsize = pvolume_info->wsize ? pvolume_info->wsize :
2809 /* can server support 24-bit write sizes? (via UNIX extensions) */
2810 if (!tcon->unix_ext || !(unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
2811 wsize = min_t(unsigned int, wsize, CIFS_MAX_RFC1002_WSIZE);
2814 * no CAP_LARGE_WRITE_X or is signing enabled without CAP_UNIX set?
2815 * Limit it to max buffer offered by the server, minus the size of the
2816 * WRITEX header, not including the 4 byte RFC1001 length.
2818 if (!(server->capabilities & CAP_LARGE_WRITE_X) ||
2819 (!(server->capabilities & CAP_UNIX) &&
2820 (server->sec_mode & (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED))))
2821 wsize = min_t(unsigned int, wsize,
2822 server->maxBuf - sizeof(WRITE_REQ) + 4);
2824 /* hard limit of CIFS_MAX_WSIZE */
2825 wsize = min_t(unsigned int, wsize, CIFS_MAX_WSIZE);
2831 is_path_accessible(int xid, struct cifs_tcon *tcon,
2832 struct cifs_sb_info *cifs_sb, const char *full_path)
2835 FILE_ALL_INFO *pfile_info;
2837 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
2838 if (pfile_info == NULL)
2841 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
2842 0 /* not legacy */, cifs_sb->local_nls,
2843 cifs_sb->mnt_cifs_flags &
2844 CIFS_MOUNT_MAP_SPECIAL_CHR);
2846 if (rc == -EOPNOTSUPP || rc == -EINVAL)
2847 rc = SMBQueryInformation(xid, tcon, full_path, pfile_info,
2848 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
2849 CIFS_MOUNT_MAP_SPECIAL_CHR);
2855 cleanup_volume_info_contents(struct smb_vol *volume_info)
2857 kfree(volume_info->username);
2858 kzfree(volume_info->password);
2859 kfree(volume_info->UNC);
2860 kfree(volume_info->UNCip);
2861 kfree(volume_info->domainname);
2862 kfree(volume_info->iocharset);
2863 kfree(volume_info->prepath);
2867 cifs_cleanup_volume_info(struct smb_vol *volume_info)
2871 cleanup_volume_info_contents(volume_info);
2876 #ifdef CONFIG_CIFS_DFS_UPCALL
2877 /* build_path_to_root returns full path to root when
2878 * we do not have an exiting connection (tcon) */
2880 build_unc_path_to_root(const struct smb_vol *vol,
2881 const struct cifs_sb_info *cifs_sb)
2883 char *full_path, *pos;
2884 unsigned int pplen = vol->prepath ? strlen(vol->prepath) : 0;
2885 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
2887 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
2888 if (full_path == NULL)
2889 return ERR_PTR(-ENOMEM);
2891 strncpy(full_path, vol->UNC, unc_len);
2892 pos = full_path + unc_len;
2895 strncpy(pos, vol->prepath, pplen);
2899 *pos = '\0'; /* add trailing null */
2900 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
2901 cFYI(1, "%s: full_path=%s", __func__, full_path);
2906 * Perform a dfs referral query for a share and (optionally) prefix
2908 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
2909 * to a string containing updated options for the submount. Otherwise it
2910 * will be left untouched.
2912 * Returns the rc from get_dfs_path to the caller, which can be used to
2913 * determine whether there were referrals.
2916 expand_dfs_referral(int xid, struct cifs_ses *pSesInfo,
2917 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
2921 unsigned int num_referrals = 0;
2922 struct dfs_info3_param *referrals = NULL;
2923 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
2925 full_path = build_unc_path_to_root(volume_info, cifs_sb);
2926 if (IS_ERR(full_path))
2927 return PTR_ERR(full_path);
2929 /* For DFS paths, skip the first '\' of the UNC */
2930 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
2932 rc = get_dfs_path(xid, pSesInfo , ref_path, cifs_sb->local_nls,
2933 &num_referrals, &referrals,
2934 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
2936 if (!rc && num_referrals > 0) {
2937 char *fake_devname = NULL;
2939 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
2940 full_path + 1, referrals,
2943 free_dfs_info_array(referrals, num_referrals);
2945 if (IS_ERR(mdata)) {
2946 rc = PTR_ERR(mdata);
2949 cleanup_volume_info_contents(volume_info);
2950 memset(volume_info, '\0', sizeof(*volume_info));
2951 rc = cifs_setup_volume_info(volume_info, mdata,
2954 kfree(fake_devname);
2955 kfree(cifs_sb->mountdata);
2956 cifs_sb->mountdata = mdata;
2964 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
2965 const char *devname)
2969 if (cifs_parse_mount_options(mount_data, devname, volume_info))
2972 if (volume_info->nullauth) {
2973 cFYI(1, "null user");
2974 volume_info->username = kzalloc(1, GFP_KERNEL);
2975 if (volume_info->username == NULL)
2977 } else if (volume_info->username) {
2978 /* BB fixme parse for domain name here */
2979 cFYI(1, "Username: %s", volume_info->username);
2981 cifserror("No username specified");
2982 /* In userspace mount helper we can get user name from alternate
2983 locations such as env variables and files on disk */
2987 /* this is needed for ASCII cp to Unicode converts */
2988 if (volume_info->iocharset == NULL) {
2989 /* load_nls_default cannot return null */
2990 volume_info->local_nls = load_nls_default();
2992 volume_info->local_nls = load_nls(volume_info->iocharset);
2993 if (volume_info->local_nls == NULL) {
2994 cERROR(1, "CIFS mount error: iocharset %s not found",
2995 volume_info->iocharset);
3004 cifs_get_volume_info(char *mount_data, const char *devname)
3007 struct smb_vol *volume_info;
3009 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
3011 return ERR_PTR(-ENOMEM);
3013 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3015 cifs_cleanup_volume_info(volume_info);
3016 volume_info = ERR_PTR(rc);
3023 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3027 struct cifs_ses *pSesInfo;
3028 struct cifs_tcon *tcon;
3029 struct TCP_Server_Info *srvTcp;
3031 struct tcon_link *tlink;
3032 #ifdef CONFIG_CIFS_DFS_UPCALL
3033 int referral_walks_count = 0;
3036 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3040 cifs_sb->bdi.ra_pages = default_backing_dev_info.ra_pages;
3042 #ifdef CONFIG_CIFS_DFS_UPCALL
3044 /* cleanup activities if we're chasing a referral */
3045 if (referral_walks_count) {
3047 cifs_put_tcon(tcon);
3049 cifs_put_smb_ses(pSesInfo);
3062 /* get a reference to a tcp session */
3063 srvTcp = cifs_get_tcp_session(volume_info);
3064 if (IS_ERR(srvTcp)) {
3065 rc = PTR_ERR(srvTcp);
3066 bdi_destroy(&cifs_sb->bdi);
3070 /* get a reference to a SMB session */
3071 pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
3072 if (IS_ERR(pSesInfo)) {
3073 rc = PTR_ERR(pSesInfo);
3075 goto mount_fail_check;
3078 /* search for existing tcon to this server share */
3079 tcon = cifs_get_tcon(pSesInfo, volume_info);
3083 goto remote_path_check;
3086 /* tell server which Unix caps we support */
3087 if (tcon->ses->capabilities & CAP_UNIX) {
3088 /* reset of caps checks mount to see if unix extensions
3089 disabled for just this mount */
3090 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3091 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3092 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3093 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3095 goto mount_fail_check;
3098 tcon->unix_ext = 0; /* server does not support them */
3100 /* do not care if following two calls succeed - informational */
3102 CIFSSMBQFSDeviceInfo(xid, tcon);
3103 CIFSSMBQFSAttributeInfo(xid, tcon);
3106 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
3107 cifs_sb->rsize = 1024 * 127;
3108 cFYI(DBG2, "no very large read support, rsize now 127K");
3110 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
3111 cifs_sb->rsize = min(cifs_sb->rsize,
3112 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
3114 cifs_sb->wsize = cifs_negotiate_wsize(tcon, volume_info);
3117 #ifdef CONFIG_CIFS_DFS_UPCALL
3119 * Perform an unconditional check for whether there are DFS
3120 * referrals for this path without prefix, to provide support
3121 * for DFS referrals from w2k8 servers which don't seem to respond
3122 * with PATH_NOT_COVERED to requests that include the prefix.
3123 * Chase the referral if found, otherwise continue normally.
3125 if (referral_walks_count == 0) {
3126 int refrc = expand_dfs_referral(xid, pSesInfo, volume_info,
3129 referral_walks_count++;
3130 goto try_mount_again;
3135 /* check if a whole path is not remote */
3137 /* build_path_to_root works only when we have a valid tcon */
3138 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3139 if (full_path == NULL) {
3141 goto mount_fail_check;
3143 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
3144 if (rc != 0 && rc != -EREMOTE) {
3146 goto mount_fail_check;
3151 /* get referral if needed */
3152 if (rc == -EREMOTE) {
3153 #ifdef CONFIG_CIFS_DFS_UPCALL
3154 if (referral_walks_count > MAX_NESTED_LINKS) {
3156 * BB: when we implement proper loop detection,
3157 * we will remove this check. But now we need it
3158 * to prevent an indefinite loop if 'DFS tree' is
3159 * misconfigured (i.e. has loops).
3162 goto mount_fail_check;
3165 rc = expand_dfs_referral(xid, pSesInfo, volume_info, cifs_sb,
3169 referral_walks_count++;
3170 goto try_mount_again;
3172 goto mount_fail_check;
3173 #else /* No DFS support, return error on mount */
3179 goto mount_fail_check;
3181 /* now, hang the tcon off of the superblock */
3182 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3183 if (tlink == NULL) {
3185 goto mount_fail_check;
3188 tlink->tl_uid = pSesInfo->linux_uid;
3189 tlink->tl_tcon = tcon;
3190 tlink->tl_time = jiffies;
3191 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3192 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3194 cifs_sb->master_tlink = tlink;
3195 spin_lock(&cifs_sb->tlink_tree_lock);
3196 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3197 spin_unlock(&cifs_sb->tlink_tree_lock);
3199 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
3203 /* on error free sesinfo and tcon struct if needed */
3205 /* If find_unc succeeded then rc == 0 so we can not end */
3206 /* up accidentally freeing someone elses tcon struct */
3208 cifs_put_tcon(tcon);
3210 cifs_put_smb_ses(pSesInfo);
3212 cifs_put_tcp_session(srvTcp);
3213 bdi_destroy(&cifs_sb->bdi);
3222 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3223 * pointer may be NULL.
3226 CIFSTCon(unsigned int xid, struct cifs_ses *ses,
3227 const char *tree, struct cifs_tcon *tcon,
3228 const struct nls_table *nls_codepage)
3230 struct smb_hdr *smb_buffer;
3231 struct smb_hdr *smb_buffer_response;
3234 unsigned char *bcc_ptr;
3237 __u16 bytes_left, count;
3242 smb_buffer = cifs_buf_get();
3243 if (smb_buffer == NULL)
3246 smb_buffer_response = smb_buffer;
3248 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3249 NULL /*no tid */ , 4 /*wct */ );
3251 smb_buffer->Mid = GetNextMid(ses->server);
3252 smb_buffer->Uid = ses->Suid;
3253 pSMB = (TCONX_REQ *) smb_buffer;
3254 pSMBr = (TCONX_RSP *) smb_buffer_response;
3256 pSMB->AndXCommand = 0xFF;
3257 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3258 bcc_ptr = &pSMB->Password[0];
3259 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3260 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3261 *bcc_ptr = 0; /* password is null byte */
3262 bcc_ptr++; /* skip password */
3263 /* already aligned so no need to do it below */
3265 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3266 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3267 specified as required (when that support is added to
3268 the vfs in the future) as only NTLM or the much
3269 weaker LANMAN (which we do not send by default) is accepted
3270 by Samba (not sure whether other servers allow
3271 NTLMv2 password here) */
3272 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3273 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3274 (ses->server->secType == LANMAN))
3275 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3276 ses->server->sec_mode &
3277 SECMODE_PW_ENCRYPT ? true : false,
3280 #endif /* CIFS_WEAK_PW_HASH */
3281 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3284 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3285 if (ses->capabilities & CAP_UNICODE) {
3286 /* must align unicode strings */
3287 *bcc_ptr = 0; /* null byte password */
3292 if (ses->server->sec_mode &
3293 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3294 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3296 if (ses->capabilities & CAP_STATUS32) {
3297 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3299 if (ses->capabilities & CAP_DFS) {
3300 smb_buffer->Flags2 |= SMBFLG2_DFS;
3302 if (ses->capabilities & CAP_UNICODE) {
3303 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3305 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3306 6 /* max utf8 char length in bytes */ *
3307 (/* server len*/ + 256 /* share len */), nls_codepage);
3308 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3309 bcc_ptr += 2; /* skip trailing null */
3310 } else { /* ASCII */
3311 strcpy(bcc_ptr, tree);
3312 bcc_ptr += strlen(tree) + 1;
3314 strcpy(bcc_ptr, "?????");
3315 bcc_ptr += strlen("?????");
3317 count = bcc_ptr - &pSMB->Password[0];
3318 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3319 pSMB->hdr.smb_buf_length) + count);
3320 pSMB->ByteCount = cpu_to_le16(count);
3322 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3325 /* above now done in SendReceive */
3326 if ((rc == 0) && (tcon != NULL)) {
3329 tcon->tidStatus = CifsGood;
3330 tcon->need_reconnect = false;
3331 tcon->tid = smb_buffer_response->Tid;
3332 bcc_ptr = pByteArea(smb_buffer_response);
3333 bytes_left = get_bcc(smb_buffer_response);
3334 length = strnlen(bcc_ptr, bytes_left - 2);
3335 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3341 /* skip service field (NB: this field is always ASCII) */
3343 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3344 (bcc_ptr[2] == 'C')) {
3345 cFYI(1, "IPC connection");
3348 } else if (length == 2) {
3349 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3350 /* the most common case */
3351 cFYI(1, "disk share connection");
3354 bcc_ptr += length + 1;
3355 bytes_left -= (length + 1);
3356 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3358 /* mostly informational -- no need to fail on error here */
3359 kfree(tcon->nativeFileSystem);
3360 tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
3361 bytes_left, is_unicode,
3364 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
3366 if ((smb_buffer_response->WordCount == 3) ||
3367 (smb_buffer_response->WordCount == 7))
3368 /* field is in same location */
3369 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3372 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
3373 } else if ((rc == 0) && tcon == NULL) {
3374 /* all we need to save for IPC$ connection */
3375 ses->ipc_tid = smb_buffer_response->Tid;
3378 cifs_buf_release(smb_buffer);
3383 cifs_umount(struct cifs_sb_info *cifs_sb)
3385 struct rb_root *root = &cifs_sb->tlink_tree;
3386 struct rb_node *node;
3387 struct tcon_link *tlink;
3389 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3391 spin_lock(&cifs_sb->tlink_tree_lock);
3392 while ((node = rb_first(root))) {
3393 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3394 cifs_get_tlink(tlink);
3395 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3396 rb_erase(node, root);
3398 spin_unlock(&cifs_sb->tlink_tree_lock);
3399 cifs_put_tlink(tlink);
3400 spin_lock(&cifs_sb->tlink_tree_lock);
3402 spin_unlock(&cifs_sb->tlink_tree_lock);
3404 bdi_destroy(&cifs_sb->bdi);
3405 kfree(cifs_sb->mountdata);
3406 unload_nls(cifs_sb->local_nls);
3410 int cifs_negotiate_protocol(unsigned int xid, struct cifs_ses *ses)
3413 struct TCP_Server_Info *server = ses->server;
3415 /* only send once per connect */
3416 if (server->maxBuf != 0)
3419 rc = CIFSSMBNegotiate(xid, ses);
3420 if (rc == -EAGAIN) {
3421 /* retry only once on 1st time connection */
3422 rc = CIFSSMBNegotiate(xid, ses);
3427 spin_lock(&GlobalMid_Lock);
3428 if (server->tcpStatus == CifsNeedNegotiate)
3429 server->tcpStatus = CifsGood;
3432 spin_unlock(&GlobalMid_Lock);
3440 int cifs_setup_session(unsigned int xid, struct cifs_ses *ses,
3441 struct nls_table *nls_info)
3444 struct TCP_Server_Info *server = ses->server;
3447 ses->capabilities = server->capabilities;
3448 if (linuxExtEnabled == 0)
3449 ses->capabilities &= (~CAP_UNIX);
3451 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3452 server->sec_mode, server->capabilities, server->timeAdj);
3454 rc = CIFS_SessSetup(xid, ses, nls_info);
3456 cERROR(1, "Send error in SessSetup = %d", rc);
3458 mutex_lock(&ses->server->srv_mutex);
3459 if (!server->session_estab) {
3460 server->session_key.response = ses->auth_key.response;
3461 server->session_key.len = ses->auth_key.len;
3462 server->sequence_number = 0x2;
3463 server->session_estab = true;
3464 ses->auth_key.response = NULL;
3466 mutex_unlock(&server->srv_mutex);
3468 cFYI(1, "CIFS Session Established successfully");
3469 spin_lock(&GlobalMid_Lock);
3470 ses->status = CifsGood;
3471 ses->need_reconnect = false;
3472 spin_unlock(&GlobalMid_Lock);
3475 kfree(ses->auth_key.response);
3476 ses->auth_key.response = NULL;
3477 ses->auth_key.len = 0;
3478 kfree(ses->ntlmssp);
3479 ses->ntlmssp = NULL;
3484 static struct cifs_tcon *
3485 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
3487 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3488 struct cifs_ses *ses;
3489 struct cifs_tcon *tcon = NULL;
3490 struct smb_vol *vol_info;
3491 char username[28]; /* big enough for "krb50x" + hex of ULONG_MAX 6+16 */
3492 /* We used to have this as MAX_USERNAME which is */
3493 /* way too big now (256 instead of 32) */
3495 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3496 if (vol_info == NULL) {
3497 tcon = ERR_PTR(-ENOMEM);
3501 snprintf(username, sizeof(username), "krb50x%x", fsuid);
3502 vol_info->username = username;
3503 vol_info->local_nls = cifs_sb->local_nls;
3504 vol_info->linux_uid = fsuid;
3505 vol_info->cred_uid = fsuid;
3506 vol_info->UNC = master_tcon->treeName;
3507 vol_info->retry = master_tcon->retry;
3508 vol_info->nocase = master_tcon->nocase;
3509 vol_info->local_lease = master_tcon->local_lease;
3510 vol_info->no_linux_ext = !master_tcon->unix_ext;
3512 /* FIXME: allow for other secFlg settings */
3513 vol_info->secFlg = CIFSSEC_MUST_KRB5;
3515 /* get a reference for the same TCP session */
3516 spin_lock(&cifs_tcp_ses_lock);
3517 ++master_tcon->ses->server->srv_count;
3518 spin_unlock(&cifs_tcp_ses_lock);
3520 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3522 tcon = (struct cifs_tcon *)ses;
3523 cifs_put_tcp_session(master_tcon->ses->server);
3527 tcon = cifs_get_tcon(ses, vol_info);
3529 cifs_put_smb_ses(ses);
3533 if (ses->capabilities & CAP_UNIX)
3534 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3542 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3544 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3548 cifs_sb_tcon_pending_wait(void *unused)
3551 return signal_pending(current) ? -ERESTARTSYS : 0;
3554 /* find and return a tlink with given uid */
3555 static struct tcon_link *
3556 tlink_rb_search(struct rb_root *root, uid_t uid)
3558 struct rb_node *node = root->rb_node;
3559 struct tcon_link *tlink;
3562 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3564 if (tlink->tl_uid > uid)
3565 node = node->rb_left;
3566 else if (tlink->tl_uid < uid)
3567 node = node->rb_right;
3574 /* insert a tcon_link into the tree */
3576 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3578 struct rb_node **new = &(root->rb_node), *parent = NULL;
3579 struct tcon_link *tlink;
3582 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3585 if (tlink->tl_uid > new_tlink->tl_uid)
3586 new = &((*new)->rb_left);
3588 new = &((*new)->rb_right);
3591 rb_link_node(&new_tlink->tl_rbnode, parent, new);
3592 rb_insert_color(&new_tlink->tl_rbnode, root);
3596 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3599 * If the superblock doesn't refer to a multiuser mount, then just return
3600 * the master tcon for the mount.
3602 * First, search the rbtree for an existing tcon for this fsuid. If one
3603 * exists, then check to see if it's pending construction. If it is then wait
3604 * for construction to complete. Once it's no longer pending, check to see if
3605 * it failed and either return an error or retry construction, depending on
3608 * If one doesn't exist then insert a new tcon_link struct into the tree and
3609 * try to construct a new one.
3612 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
3615 uid_t fsuid = current_fsuid();
3616 struct tcon_link *tlink, *newtlink;
3618 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
3619 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3621 spin_lock(&cifs_sb->tlink_tree_lock);
3622 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3624 cifs_get_tlink(tlink);
3625 spin_unlock(&cifs_sb->tlink_tree_lock);
3627 if (tlink == NULL) {
3628 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
3629 if (newtlink == NULL)
3630 return ERR_PTR(-ENOMEM);
3631 newtlink->tl_uid = fsuid;
3632 newtlink->tl_tcon = ERR_PTR(-EACCES);
3633 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
3634 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
3635 cifs_get_tlink(newtlink);
3637 spin_lock(&cifs_sb->tlink_tree_lock);
3638 /* was one inserted after previous search? */
3639 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3641 cifs_get_tlink(tlink);
3642 spin_unlock(&cifs_sb->tlink_tree_lock);
3644 goto wait_for_construction;
3647 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3648 spin_unlock(&cifs_sb->tlink_tree_lock);
3650 wait_for_construction:
3651 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
3652 cifs_sb_tcon_pending_wait,
3653 TASK_INTERRUPTIBLE);
3655 cifs_put_tlink(tlink);
3656 return ERR_PTR(ret);
3659 /* if it's good, return it */
3660 if (!IS_ERR(tlink->tl_tcon))
3663 /* return error if we tried this already recently */
3664 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
3665 cifs_put_tlink(tlink);
3666 return ERR_PTR(-EACCES);
3669 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
3670 goto wait_for_construction;
3673 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
3674 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
3675 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
3677 if (IS_ERR(tlink->tl_tcon)) {
3678 cifs_put_tlink(tlink);
3679 return ERR_PTR(-EACCES);
3686 * periodic workqueue job that scans tcon_tree for a superblock and closes
3690 cifs_prune_tlinks(struct work_struct *work)
3692 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
3694 struct rb_root *root = &cifs_sb->tlink_tree;
3695 struct rb_node *node = rb_first(root);
3696 struct rb_node *tmp;
3697 struct tcon_link *tlink;
3700 * Because we drop the spinlock in the loop in order to put the tlink
3701 * it's not guarded against removal of links from the tree. The only
3702 * places that remove entries from the tree are this function and
3703 * umounts. Because this function is non-reentrant and is canceled
3704 * before umount can proceed, this is safe.
3706 spin_lock(&cifs_sb->tlink_tree_lock);
3707 node = rb_first(root);
3708 while (node != NULL) {
3710 node = rb_next(tmp);
3711 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
3713 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
3714 atomic_read(&tlink->tl_count) != 0 ||
3715 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
3718 cifs_get_tlink(tlink);
3719 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3720 rb_erase(tmp, root);
3722 spin_unlock(&cifs_sb->tlink_tree_lock);
3723 cifs_put_tlink(tlink);
3724 spin_lock(&cifs_sb->tlink_tree_lock);
3726 spin_unlock(&cifs_sb->tlink_tree_lock);
3728 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,