4 * Copyright (C) International Business Machines Corp., 2002,2009
5 * Author(s): Steve French (sfrench@us.ibm.com)
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/net.h>
23 #include <linux/string.h>
24 #include <linux/list.h>
25 #include <linux/wait.h>
26 #include <linux/slab.h>
27 #include <linux/pagemap.h>
28 #include <linux/ctype.h>
29 #include <linux/utsname.h>
30 #include <linux/mempool.h>
31 #include <linux/delay.h>
32 #include <linux/completion.h>
33 #include <linux/kthread.h>
34 #include <linux/pagevec.h>
35 #include <linux/freezer.h>
36 #include <linux/namei.h>
37 #include <asm/uaccess.h>
38 #include <asm/processor.h>
39 #include <linux/inet.h>
43 #include "cifsproto.h"
44 #include "cifs_unicode.h"
45 #include "cifs_debug.h"
46 #include "cifs_fs_sb.h"
49 #include "rfc1002pdu.h"
53 #define RFC1001_PORT 139
55 /* SMB echo "timeout" -- FIXME: tunable? */
56 #define SMB_ECHO_INTERVAL (60 * HZ)
58 extern mempool_t *cifs_req_poolp;
60 /* FIXME: should these be tunable? */
61 #define TLINK_ERROR_EXPIRE (1 * HZ)
62 #define TLINK_IDLE_EXPIRE (600 * HZ)
64 static int ip_connect(struct TCP_Server_Info *server);
65 static int generic_ip_connect(struct TCP_Server_Info *server);
66 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
67 static void cifs_prune_tlinks(struct work_struct *work);
68 static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
72 * cifs tcp session reconnection
74 * mark tcp session as reconnecting so temporarily locked
75 * mark all smb sessions as reconnecting for tcp session
76 * reconnect tcp session
77 * wake up waiters on reconnection? - (not needed currently)
80 cifs_reconnect(struct TCP_Server_Info *server)
83 struct list_head *tmp, *tmp2;
85 struct cifs_tcon *tcon;
86 struct mid_q_entry *mid_entry;
87 struct list_head retry_list;
89 spin_lock(&GlobalMid_Lock);
90 if (server->tcpStatus == CifsExiting) {
91 /* the demux thread will exit normally
92 next time through the loop */
93 spin_unlock(&GlobalMid_Lock);
96 server->tcpStatus = CifsNeedReconnect;
97 spin_unlock(&GlobalMid_Lock);
100 cFYI(1, "Reconnecting tcp session");
102 /* before reconnecting the tcp session, mark the smb session (uid)
103 and the tid bad so they are not used until reconnected */
104 cFYI(1, "%s: marking sessions and tcons for reconnect", __func__);
105 spin_lock(&cifs_tcp_ses_lock);
106 list_for_each(tmp, &server->smb_ses_list) {
107 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
108 ses->need_reconnect = true;
110 list_for_each(tmp2, &ses->tcon_list) {
111 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
112 tcon->need_reconnect = true;
115 spin_unlock(&cifs_tcp_ses_lock);
117 /* do not want to be sending data on a socket we are freeing */
118 cFYI(1, "%s: tearing down socket", __func__);
119 mutex_lock(&server->srv_mutex);
120 if (server->ssocket) {
121 cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
122 server->ssocket->flags);
123 kernel_sock_shutdown(server->ssocket, SHUT_WR);
124 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
125 server->ssocket->state,
126 server->ssocket->flags);
127 sock_release(server->ssocket);
128 server->ssocket = NULL;
130 server->sequence_number = 0;
131 server->session_estab = false;
132 kfree(server->session_key.response);
133 server->session_key.response = NULL;
134 server->session_key.len = 0;
135 server->lstrp = jiffies;
136 mutex_unlock(&server->srv_mutex);
138 /* mark submitted MIDs for retry and issue callback */
139 INIT_LIST_HEAD(&retry_list);
140 cFYI(1, "%s: moving mids to private list", __func__);
141 spin_lock(&GlobalMid_Lock);
142 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
143 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
144 if (mid_entry->midState == MID_REQUEST_SUBMITTED)
145 mid_entry->midState = MID_RETRY_NEEDED;
146 list_move(&mid_entry->qhead, &retry_list);
148 spin_unlock(&GlobalMid_Lock);
150 cFYI(1, "%s: issuing mid callbacks", __func__);
151 list_for_each_safe(tmp, tmp2, &retry_list) {
152 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
153 list_del_init(&mid_entry->qhead);
154 mid_entry->callback(mid_entry);
160 /* we should try only the port we connected to before */
161 rc = generic_ip_connect(server);
163 cFYI(1, "reconnect error %d", rc);
166 atomic_inc(&tcpSesReconnectCount);
167 spin_lock(&GlobalMid_Lock);
168 if (server->tcpStatus != CifsExiting)
169 server->tcpStatus = CifsNeedNegotiate;
170 spin_unlock(&GlobalMid_Lock);
172 } while (server->tcpStatus == CifsNeedReconnect);
179 0 not a transact2, or all data present
180 >0 transact2 with that much data missing
181 -EINVAL = invalid transact2
184 static int check2ndT2(struct smb_hdr *pSMB)
186 struct smb_t2_rsp *pSMBt;
188 __u16 total_data_size, data_in_this_rsp;
190 if (pSMB->Command != SMB_COM_TRANSACTION2)
193 /* check for plausible wct, bcc and t2 data and parm sizes */
194 /* check for parm and data offset going beyond end of smb */
195 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
196 cFYI(1, "invalid transact2 word count");
200 pSMBt = (struct smb_t2_rsp *)pSMB;
202 total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
203 data_in_this_rsp = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
205 if (total_data_size == data_in_this_rsp)
207 else if (total_data_size < data_in_this_rsp) {
208 cFYI(1, "total data %d smaller than data in frame %d",
209 total_data_size, data_in_this_rsp);
213 remaining = total_data_size - data_in_this_rsp;
215 cFYI(1, "missing %d bytes from transact2, check next response",
217 if (total_data_size > CIFSMaxBufSize) {
218 cERROR(1, "TotalDataSize %d is over maximum buffer %d",
219 total_data_size, CIFSMaxBufSize);
225 static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
227 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
228 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
229 char *data_area_of_target;
230 char *data_area_of_buf2;
232 unsigned int byte_count, total_in_buf;
233 __u16 total_data_size, total_in_buf2;
235 total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
237 if (total_data_size !=
238 get_unaligned_le16(&pSMB2->t2_rsp.TotalDataCount))
239 cFYI(1, "total data size of primary and secondary t2 differ");
241 total_in_buf = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
243 remaining = total_data_size - total_in_buf;
248 if (remaining == 0) /* nothing to do, ignore */
251 total_in_buf2 = get_unaligned_le16(&pSMB2->t2_rsp.DataCount);
252 if (remaining < total_in_buf2) {
253 cFYI(1, "transact2 2nd response contains too much data");
256 /* find end of first SMB data area */
257 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
258 get_unaligned_le16(&pSMBt->t2_rsp.DataOffset);
259 /* validate target area */
261 data_area_of_buf2 = (char *)&pSMB2->hdr.Protocol +
262 get_unaligned_le16(&pSMB2->t2_rsp.DataOffset);
264 data_area_of_target += total_in_buf;
266 /* copy second buffer into end of first buffer */
267 total_in_buf += total_in_buf2;
268 /* is the result too big for the field? */
269 if (total_in_buf > USHRT_MAX)
271 put_unaligned_le16(total_in_buf, &pSMBt->t2_rsp.DataCount);
274 byte_count = get_bcc(pTargetSMB);
275 byte_count += total_in_buf2;
276 /* is the result too big for the field? */
277 if (byte_count > USHRT_MAX)
279 put_bcc(byte_count, pTargetSMB);
281 byte_count = be32_to_cpu(pTargetSMB->smb_buf_length);
282 byte_count += total_in_buf2;
283 /* don't allow buffer to overflow */
284 if (byte_count > CIFSMaxBufSize)
286 pTargetSMB->smb_buf_length = cpu_to_be32(byte_count);
288 memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
290 if (remaining == total_in_buf2) {
291 cFYI(1, "found the last secondary response");
292 return 0; /* we are done */
293 } else /* more responses to go */
298 cifs_echo_request(struct work_struct *work)
301 struct TCP_Server_Info *server = container_of(work,
302 struct TCP_Server_Info, echo.work);
305 * We cannot send an echo until the NEGOTIATE_PROTOCOL request is
306 * done, which is indicated by maxBuf != 0. Also, no need to ping if
307 * we got a response recently
309 if (server->maxBuf == 0 ||
310 time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
313 rc = CIFSSMBEcho(server);
315 cFYI(1, "Unable to send echo request to server: %s",
319 queue_delayed_work(system_nrt_wq, &server->echo, SMB_ECHO_INTERVAL);
323 allocate_buffers(char **bigbuf, char **smallbuf, unsigned int size,
326 char *bbuf = *bigbuf, *sbuf = *smallbuf;
329 bbuf = (char *)cifs_buf_get();
331 cERROR(1, "No memory for large SMB response");
333 /* retry will check if exiting */
336 } else if (is_large_buf) {
337 /* we are reusing a dirty large buf, clear its start */
338 memset(bbuf, 0, size);
342 sbuf = (char *)cifs_small_buf_get();
344 cERROR(1, "No memory for SMB response");
346 /* retry will check if exiting */
349 /* beginning of smb buffer is cleared in our buf_get */
351 /* if existing small buf clear beginning */
352 memset(sbuf, 0, size);
362 server_unresponsive(struct TCP_Server_Info *server)
364 if (echo_retries > 0 && server->tcpStatus == CifsGood &&
365 time_after(jiffies, server->lstrp +
366 (echo_retries * SMB_ECHO_INTERVAL))) {
367 cERROR(1, "Server %s has not responded in %d seconds. "
368 "Reconnecting...", server->hostname,
369 (echo_retries * SMB_ECHO_INTERVAL / HZ));
370 cifs_reconnect(server);
371 wake_up(&server->response_q);
379 read_from_socket(struct TCP_Server_Info *server, char *buf,
380 unsigned int to_read)
384 struct msghdr smb_msg;
387 smb_msg.msg_control = NULL;
388 smb_msg.msg_controllen = 0;
390 for (total_read = 0; to_read; total_read += length, to_read -= length) {
391 if (server_unresponsive(server)) {
392 total_read = -EAGAIN;
396 iov.iov_base = buf + total_read;
397 iov.iov_len = to_read;
398 length = kernel_recvmsg(server->ssocket, &smb_msg, &iov, 1,
400 if (server->tcpStatus == CifsExiting) {
401 total_read = -ESHUTDOWN;
403 } else if (server->tcpStatus == CifsNeedReconnect) {
404 cifs_reconnect(server);
405 total_read = -EAGAIN;
407 } else if (length == -ERESTARTSYS ||
411 * Minimum sleep to prevent looping, allowing socket
412 * to clear and app threads to set tcpStatus
413 * CifsNeedReconnect if server hung.
415 usleep_range(1000, 2000);
418 } else if (length <= 0) {
419 cFYI(1, "Received no data or error: expecting %d "
420 "got %d", to_read, length);
421 cifs_reconnect(server);
422 total_read = -EAGAIN;
430 check_rfc1002_header(struct TCP_Server_Info *server, char *buf)
433 unsigned int pdu_length = be32_to_cpu(
434 ((struct smb_hdr *)buf)->smb_buf_length);
437 * The first byte big endian of the length field,
438 * is actually not part of the length but the type
439 * with the most common, zero, as regular data.
441 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
443 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
444 cFYI(1, "Good RFC 1002 session rsp");
446 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
448 * We get this from Windows 98 instead of an error on
449 * SMB negprot response.
451 cFYI(1, "Negative RFC1002 Session Response Error 0x%x)",
453 /* give server a second to clean up */
456 * Always try 445 first on reconnect since we get NACK
457 * on some if we ever connected to port 139 (the NACK
458 * is since we do not begin with RFC1001 session
461 cifs_set_port((struct sockaddr *)
462 &server->dstaddr, CIFS_PORT);
463 cifs_reconnect(server);
464 wake_up(&server->response_q);
466 } else if (temp != (char) 0) {
467 cERROR(1, "Unknown RFC 1002 frame");
468 cifs_dump_mem(" Received Data: ", buf, 4);
469 cifs_reconnect(server);
473 /* else we have an SMB response */
474 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
475 (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
476 cERROR(1, "Invalid size SMB length %d pdu_length %d",
478 cifs_reconnect(server);
479 wake_up(&server->response_q);
486 static struct mid_q_entry *
487 find_cifs_mid(struct TCP_Server_Info *server, struct smb_hdr *buf,
488 int *length, bool is_large_buf, bool *is_multi_rsp, char **bigbuf)
490 struct mid_q_entry *mid = NULL, *tmp_mid, *ret = NULL;
492 spin_lock(&GlobalMid_Lock);
493 list_for_each_entry_safe(mid, tmp_mid, &server->pending_mid_q, qhead) {
494 if (mid->mid != buf->Mid ||
495 mid->midState != MID_REQUEST_SUBMITTED ||
496 mid->command != buf->Command)
499 if (*length == 0 && check2ndT2(buf) > 0) {
500 /* We have a multipart transact2 resp */
501 *is_multi_rsp = true;
503 /* merge response - fix up 1st*/
504 *length = coalesce_t2(buf, mid->resp_buf);
507 mid->multiRsp = true;
510 /* All parts received or packet is malformed. */
511 mid->multiEnd = true;
515 /*FIXME: switch to already allocated largebuf?*/
516 cERROR(1, "1st trans2 resp needs bigbuf");
518 /* Have first buffer */
520 mid->largeBuf = true;
526 mid->largeBuf = is_large_buf;
529 mid->midState = MID_RESPONSE_RECEIVED;
531 mid->midState = MID_RESPONSE_MALFORMED;
532 #ifdef CONFIG_CIFS_STATS2
533 mid->when_received = jiffies;
535 list_del_init(&mid->qhead);
539 spin_unlock(&GlobalMid_Lock);
544 static void clean_demultiplex_info(struct TCP_Server_Info *server)
548 /* take it off the list, if it's not already */
549 spin_lock(&cifs_tcp_ses_lock);
550 list_del_init(&server->tcp_ses_list);
551 spin_unlock(&cifs_tcp_ses_lock);
553 spin_lock(&GlobalMid_Lock);
554 server->tcpStatus = CifsExiting;
555 spin_unlock(&GlobalMid_Lock);
556 wake_up_all(&server->response_q);
559 * Check if we have blocked requests that need to free. Note that
560 * cifs_max_pending is normally 50, but can be set at module install
561 * time to as little as two.
563 spin_lock(&GlobalMid_Lock);
564 if (atomic_read(&server->inFlight) >= cifs_max_pending)
565 atomic_set(&server->inFlight, cifs_max_pending - 1);
567 * We do not want to set the max_pending too low or we could end up
568 * with the counter going negative.
570 spin_unlock(&GlobalMid_Lock);
572 * Although there should not be any requests blocked on this queue it
573 * can not hurt to be paranoid and try to wake up requests that may
574 * haven been blocked when more than 50 at time were on the wire to the
575 * same server - they now will see the session is in exit state and get
576 * out of SendReceive.
578 wake_up_all(&server->request_q);
579 /* give those requests time to exit */
582 if (server->ssocket) {
583 sock_release(server->ssocket);
584 server->ssocket = NULL;
587 if (!list_empty(&server->pending_mid_q)) {
588 struct list_head dispose_list;
589 struct mid_q_entry *mid_entry;
590 struct list_head *tmp, *tmp2;
592 INIT_LIST_HEAD(&dispose_list);
593 spin_lock(&GlobalMid_Lock);
594 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
595 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
596 cFYI(1, "Clearing mid 0x%x", mid_entry->mid);
597 mid_entry->midState = MID_SHUTDOWN;
598 list_move(&mid_entry->qhead, &dispose_list);
600 spin_unlock(&GlobalMid_Lock);
602 /* now walk dispose list and issue callbacks */
603 list_for_each_safe(tmp, tmp2, &dispose_list) {
604 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
605 cFYI(1, "Callback mid 0x%x", mid_entry->mid);
606 list_del_init(&mid_entry->qhead);
607 mid_entry->callback(mid_entry);
609 /* 1/8th of sec is more than enough time for them to exit */
613 if (!list_empty(&server->pending_mid_q)) {
615 * mpx threads have not exited yet give them at least the smb
616 * send timeout time for long ops.
618 * Due to delays on oplock break requests, we need to wait at
619 * least 45 seconds before giving up on a request getting a
620 * response and going ahead and killing cifsd.
622 cFYI(1, "Wait for exit from demultiplex thread");
625 * If threads still have not exited they are probably never
626 * coming home not much else we can do but free the memory.
630 kfree(server->hostname);
633 length = atomic_dec_return(&tcpSesAllocCount);
635 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
640 cifs_demultiplex_thread(void *p)
643 struct TCP_Server_Info *server = p;
644 unsigned int pdu_length, total_read;
645 char *buf = NULL, *bigbuf = NULL, *smallbuf = NULL;
646 struct smb_hdr *smb_buffer = NULL;
647 struct task_struct *task_to_wake = NULL;
648 struct mid_q_entry *mid_entry;
649 bool isLargeBuf = false;
650 bool isMultiRsp = false;
652 current->flags |= PF_MEMALLOC;
653 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
655 length = atomic_inc_return(&tcpSesAllocCount);
657 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
661 while (server->tcpStatus != CifsExiting) {
665 if (!allocate_buffers(&bigbuf, &smallbuf,
666 sizeof(struct smb_hdr), isLargeBuf))
671 smb_buffer = (struct smb_hdr *)smallbuf;
673 pdu_length = 4; /* enough to get RFC1001 header */
675 length = read_from_socket(server, buf, pdu_length);
681 * The right amount was read from socket - 4 bytes,
682 * so we can now interpret the length field.
684 pdu_length = be32_to_cpu(smb_buffer->smb_buf_length);
686 cFYI(1, "rfc1002 length 0x%x", pdu_length+4);
687 if (!check_rfc1002_header(server, buf))
691 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
693 memcpy(bigbuf, smallbuf, 4);
694 smb_buffer = (struct smb_hdr *)bigbuf;
698 length = read_from_socket(server, buf + 4, pdu_length);
701 total_read += length;
703 dump_smb(smb_buffer, total_read);
706 * We know that we received enough to get to the MID as we
707 * checked the pdu_length earlier. Now check to see
708 * if the rest of the header is OK. We borrow the length
709 * var for the rest of the loop to avoid a new stack var.
711 * 48 bytes is enough to display the header and a little bit
712 * into the payload for debugging purposes.
714 length = checkSMB(smb_buffer, smb_buffer->Mid, total_read);
716 cifs_dump_mem("Bad SMB: ", buf,
717 min_t(unsigned int, total_read, 48));
719 server->lstrp = jiffies;
721 mid_entry = find_cifs_mid(server, smb_buffer, &length,
722 isLargeBuf, &isMultiRsp, &bigbuf);
723 if (mid_entry != NULL) {
724 mid_entry->callback(mid_entry);
725 /* Was previous buf put in mpx struct for multi-rsp? */
727 /* smb buffer will be freed by user thread */
733 } else if (length != 0) {
734 /* response sanity checks failed */
736 } else if (!is_valid_oplock_break(smb_buffer, server) &&
738 cERROR(1, "No task to wake, unknown frame received! "
739 "NumMids %d", atomic_read(&midCount));
740 cifs_dump_mem("Received Data is: ", buf,
741 sizeof(struct smb_hdr));
742 #ifdef CONFIG_CIFS_DEBUG2
743 cifs_dump_detail(smb_buffer);
744 cifs_dump_mids(server);
745 #endif /* CIFS_DEBUG2 */
748 } /* end while !EXITING */
750 /* buffer usually freed in free_mid - need to free it here on exit */
751 cifs_buf_release(bigbuf);
752 if (smallbuf) /* no sense logging a debug message if NULL */
753 cifs_small_buf_release(smallbuf);
755 task_to_wake = xchg(&server->tsk, NULL);
756 clean_demultiplex_info(server);
758 /* if server->tsk was NULL then wait for a signal before exiting */
760 set_current_state(TASK_INTERRUPTIBLE);
761 while (!signal_pending(current)) {
763 set_current_state(TASK_INTERRUPTIBLE);
765 set_current_state(TASK_RUNNING);
768 module_put_and_exit(0);
771 /* extract the host portion of the UNC string */
773 extract_hostname(const char *unc)
779 /* skip double chars at beginning of string */
780 /* BB: check validity of these bytes? */
783 /* delimiter between hostname and sharename is always '\\' now */
784 delim = strchr(src, '\\');
786 return ERR_PTR(-EINVAL);
789 dst = kmalloc((len + 1), GFP_KERNEL);
791 return ERR_PTR(-ENOMEM);
793 memcpy(dst, src, len);
800 cifs_parse_mount_options(const char *mountdata, const char *devname,
803 char *value, *data, *end;
804 char *mountdata_copy = NULL, *options;
806 unsigned int temp_len, i, j;
808 short int override_uid = -1;
809 short int override_gid = -1;
810 bool uid_specified = false;
811 bool gid_specified = false;
812 char *nodename = utsname()->nodename;
818 * does not have to be perfect mapping since field is
819 * informational, only used for servers that do not support
820 * port 445 and it can be overridden at mount time
822 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
823 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
824 vol->source_rfc1001_name[i] = toupper(nodename[i]);
826 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
827 /* null target name indicates to use *SMBSERVR default called name
828 if we end up sending RFC1001 session initialize */
829 vol->target_rfc1001_name[0] = 0;
830 vol->cred_uid = current_uid();
831 vol->linux_uid = current_uid();
832 vol->linux_gid = current_gid();
834 /* default to only allowing write access to owner of the mount */
835 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
837 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
838 /* default is always to request posix paths. */
839 vol->posix_paths = 1;
840 /* default to using server inode numbers where available */
843 vol->actimeo = CIFS_DEF_ACTIMEO;
846 goto cifs_parse_mount_err;
848 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
850 goto cifs_parse_mount_err;
852 options = mountdata_copy;
853 end = options + strlen(options);
854 if (strncmp(options, "sep=", 4) == 0) {
855 if (options[4] != 0) {
856 separator[0] = options[4];
859 cFYI(1, "Null separator not allowed");
862 vol->backupuid_specified = false; /* no backup intent for a user */
863 vol->backupgid_specified = false; /* no backup intent for a group */
865 while ((data = strsep(&options, separator)) != NULL) {
868 if ((value = strchr(data, '=')) != NULL)
871 /* Have to parse this before we parse for "user" */
872 if (strnicmp(data, "user_xattr", 10) == 0) {
874 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
876 } else if (strnicmp(data, "user", 4) == 0) {
879 "CIFS: invalid or missing username\n");
880 goto cifs_parse_mount_err;
881 } else if (!*value) {
882 /* null user, ie anonymous, authentication */
885 if (strnlen(value, MAX_USERNAME_SIZE) <
887 vol->username = kstrdup(value, GFP_KERNEL);
888 if (!vol->username) {
889 printk(KERN_WARNING "CIFS: no memory "
891 goto cifs_parse_mount_err;
894 printk(KERN_WARNING "CIFS: username too long\n");
895 goto cifs_parse_mount_err;
897 } else if (strnicmp(data, "pass", 4) == 0) {
899 vol->password = NULL;
901 } else if (value[0] == 0) {
902 /* check if string begins with double comma
903 since that would mean the password really
904 does start with a comma, and would not
905 indicate an empty string */
906 if (value[1] != separator[0]) {
907 vol->password = NULL;
911 temp_len = strlen(value);
912 /* removed password length check, NTLM passwords
913 can be arbitrarily long */
915 /* if comma in password, the string will be
916 prematurely null terminated. Commas in password are
917 specified across the cifs mount interface by a double
918 comma ie ,, and a comma used as in other cases ie ','
919 as a parameter delimiter/separator is single and due
920 to the strsep above is temporarily zeroed. */
922 /* NB: password legally can have multiple commas and
923 the only illegal character in a password is null */
925 if ((value[temp_len] == 0) &&
926 (value + temp_len < end) &&
927 (value[temp_len+1] == separator[0])) {
929 value[temp_len] = separator[0];
930 temp_len += 2; /* move after second comma */
931 while (value[temp_len] != 0) {
932 if (value[temp_len] == separator[0]) {
933 if (value[temp_len+1] ==
935 /* skip second comma */
938 /* single comma indicating start
945 if (value[temp_len] == 0) {
949 /* point option to start of next parm */
950 options = value + temp_len + 1;
952 /* go from value to value + temp_len condensing
953 double commas to singles. Note that this ends up
954 allocating a few bytes too many, which is ok */
955 vol->password = kzalloc(temp_len, GFP_KERNEL);
956 if (vol->password == NULL) {
957 printk(KERN_WARNING "CIFS: no memory "
959 goto cifs_parse_mount_err;
961 for (i = 0, j = 0; i < temp_len; i++, j++) {
962 vol->password[j] = value[i];
963 if (value[i] == separator[0]
964 && value[i+1] == separator[0]) {
965 /* skip second comma */
969 vol->password[j] = 0;
971 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
972 if (vol->password == NULL) {
973 printk(KERN_WARNING "CIFS: no memory "
975 goto cifs_parse_mount_err;
977 strcpy(vol->password, value);
979 } else if (!strnicmp(data, "ip", 2) ||
980 !strnicmp(data, "addr", 4)) {
981 if (!value || !*value) {
983 } else if (strnlen(value, INET6_ADDRSTRLEN) <
985 vol->UNCip = kstrdup(value, GFP_KERNEL);
987 printk(KERN_WARNING "CIFS: no memory "
989 goto cifs_parse_mount_err;
992 printk(KERN_WARNING "CIFS: ip address "
994 goto cifs_parse_mount_err;
996 } else if (strnicmp(data, "sec", 3) == 0) {
997 if (!value || !*value) {
998 cERROR(1, "no security value specified");
1000 } else if (strnicmp(value, "krb5i", 5) == 0) {
1001 vol->secFlg |= CIFSSEC_MAY_KRB5 |
1003 } else if (strnicmp(value, "krb5p", 5) == 0) {
1004 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
1005 CIFSSEC_MAY_KRB5; */
1006 cERROR(1, "Krb5 cifs privacy not supported");
1007 goto cifs_parse_mount_err;
1008 } else if (strnicmp(value, "krb5", 4) == 0) {
1009 vol->secFlg |= CIFSSEC_MAY_KRB5;
1010 } else if (strnicmp(value, "ntlmsspi", 8) == 0) {
1011 vol->secFlg |= CIFSSEC_MAY_NTLMSSP |
1013 } else if (strnicmp(value, "ntlmssp", 7) == 0) {
1014 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
1015 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
1016 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
1018 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
1019 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1020 } else if (strnicmp(value, "ntlmi", 5) == 0) {
1021 vol->secFlg |= CIFSSEC_MAY_NTLM |
1023 } else if (strnicmp(value, "ntlm", 4) == 0) {
1024 /* ntlm is default so can be turned off too */
1025 vol->secFlg |= CIFSSEC_MAY_NTLM;
1026 } else if (strnicmp(value, "nontlm", 6) == 0) {
1027 /* BB is there a better way to do this? */
1028 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1029 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1030 } else if (strnicmp(value, "lanman", 6) == 0) {
1031 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1033 } else if (strnicmp(value, "none", 4) == 0) {
1036 cERROR(1, "bad security option: %s", value);
1037 goto cifs_parse_mount_err;
1039 } else if (strnicmp(data, "vers", 3) == 0) {
1040 if (!value || !*value) {
1041 cERROR(1, "no protocol version specified"
1042 " after vers= mount option");
1043 } else if ((strnicmp(value, "cifs", 4) == 0) ||
1044 (strnicmp(value, "1", 1) == 0)) {
1045 /* this is the default */
1048 } else if ((strnicmp(data, "unc", 3) == 0)
1049 || (strnicmp(data, "target", 6) == 0)
1050 || (strnicmp(data, "path", 4) == 0)) {
1051 if (!value || !*value) {
1052 printk(KERN_WARNING "CIFS: invalid path to "
1053 "network resource\n");
1054 goto cifs_parse_mount_err;
1056 if ((temp_len = strnlen(value, 300)) < 300) {
1057 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1058 if (vol->UNC == NULL)
1059 goto cifs_parse_mount_err;
1060 strcpy(vol->UNC, value);
1061 if (strncmp(vol->UNC, "//", 2) == 0) {
1064 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1066 "CIFS: UNC Path does not begin "
1067 "with // or \\\\ \n");
1068 goto cifs_parse_mount_err;
1071 printk(KERN_WARNING "CIFS: UNC name too long\n");
1072 goto cifs_parse_mount_err;
1074 } else if ((strnicmp(data, "domain", 3) == 0)
1075 || (strnicmp(data, "workgroup", 5) == 0)) {
1076 if (!value || !*value) {
1077 printk(KERN_WARNING "CIFS: invalid domain name\n");
1078 goto cifs_parse_mount_err;
1080 /* BB are there cases in which a comma can be valid in
1081 a domain name and need special handling? */
1082 if (strnlen(value, 256) < 256) {
1083 vol->domainname = kstrdup(value, GFP_KERNEL);
1084 if (!vol->domainname) {
1085 printk(KERN_WARNING "CIFS: no memory "
1086 "for domainname\n");
1087 goto cifs_parse_mount_err;
1089 cFYI(1, "Domain name set");
1091 printk(KERN_WARNING "CIFS: domain name too "
1093 goto cifs_parse_mount_err;
1095 } else if (strnicmp(data, "srcaddr", 7) == 0) {
1096 vol->srcaddr.ss_family = AF_UNSPEC;
1098 if (!value || !*value) {
1099 printk(KERN_WARNING "CIFS: srcaddr value"
1100 " not specified.\n");
1101 goto cifs_parse_mount_err;
1103 i = cifs_convert_address((struct sockaddr *)&vol->srcaddr,
1104 value, strlen(value));
1106 printk(KERN_WARNING "CIFS: Could not parse"
1109 goto cifs_parse_mount_err;
1111 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1112 if (!value || !*value) {
1114 "CIFS: invalid path prefix\n");
1115 goto cifs_parse_mount_err;
1117 if ((temp_len = strnlen(value, 1024)) < 1024) {
1118 if (value[0] != '/')
1119 temp_len++; /* missing leading slash */
1120 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1121 if (vol->prepath == NULL)
1122 goto cifs_parse_mount_err;
1123 if (value[0] != '/') {
1124 vol->prepath[0] = '/';
1125 strcpy(vol->prepath+1, value);
1127 strcpy(vol->prepath, value);
1128 cFYI(1, "prefix path %s", vol->prepath);
1130 printk(KERN_WARNING "CIFS: prefix too long\n");
1131 goto cifs_parse_mount_err;
1133 } else if (strnicmp(data, "iocharset", 9) == 0) {
1134 if (!value || !*value) {
1135 printk(KERN_WARNING "CIFS: invalid iocharset "
1137 goto cifs_parse_mount_err;
1139 if (strnlen(value, 65) < 65) {
1140 if (strnicmp(value, "default", 7)) {
1141 vol->iocharset = kstrdup(value,
1144 if (!vol->iocharset) {
1145 printk(KERN_WARNING "CIFS: no "
1148 goto cifs_parse_mount_err;
1151 /* if iocharset not set then load_nls_default
1152 is used by caller */
1153 cFYI(1, "iocharset set to %s", value);
1155 printk(KERN_WARNING "CIFS: iocharset name "
1157 goto cifs_parse_mount_err;
1159 } else if (!strnicmp(data, "uid", 3) && value && *value) {
1160 vol->linux_uid = simple_strtoul(value, &value, 0);
1161 uid_specified = true;
1162 } else if (!strnicmp(data, "cruid", 5) && value && *value) {
1163 vol->cred_uid = simple_strtoul(value, &value, 0);
1164 } else if (!strnicmp(data, "forceuid", 8)) {
1166 } else if (!strnicmp(data, "noforceuid", 10)) {
1168 } else if (!strnicmp(data, "gid", 3) && value && *value) {
1169 vol->linux_gid = simple_strtoul(value, &value, 0);
1170 gid_specified = true;
1171 } else if (!strnicmp(data, "forcegid", 8)) {
1173 } else if (!strnicmp(data, "noforcegid", 10)) {
1175 } else if (strnicmp(data, "file_mode", 4) == 0) {
1176 if (value && *value) {
1178 simple_strtoul(value, &value, 0);
1180 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1181 if (value && *value) {
1183 simple_strtoul(value, &value, 0);
1185 } else if (strnicmp(data, "dirmode", 4) == 0) {
1186 if (value && *value) {
1188 simple_strtoul(value, &value, 0);
1190 } else if (strnicmp(data, "port", 4) == 0) {
1191 if (value && *value) {
1193 simple_strtoul(value, &value, 0);
1195 } else if (strnicmp(data, "rsize", 5) == 0) {
1196 if (value && *value) {
1198 simple_strtoul(value, &value, 0);
1200 } else if (strnicmp(data, "wsize", 5) == 0) {
1201 if (value && *value) {
1203 simple_strtoul(value, &value, 0);
1205 } else if (strnicmp(data, "sockopt", 5) == 0) {
1206 if (!value || !*value) {
1207 cERROR(1, "no socket option specified");
1209 } else if (strnicmp(value, "TCP_NODELAY", 11) == 0) {
1210 vol->sockopt_tcp_nodelay = 1;
1212 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1213 if (!value || !*value || (*value == ' ')) {
1214 cFYI(1, "invalid (empty) netbiosname");
1216 memset(vol->source_rfc1001_name, 0x20,
1219 * FIXME: are there cases in which a comma can
1220 * be valid in workstation netbios name (and
1221 * need special handling)?
1223 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1224 /* don't ucase netbiosname for user */
1227 vol->source_rfc1001_name[i] = value[i];
1229 /* The string has 16th byte zero still from
1230 set at top of the function */
1231 if (i == RFC1001_NAME_LEN && value[i] != 0)
1232 printk(KERN_WARNING "CIFS: netbiosname"
1233 " longer than 15 truncated.\n");
1235 } else if (strnicmp(data, "servern", 7) == 0) {
1236 /* servernetbiosname specified override *SMBSERVER */
1237 if (!value || !*value || (*value == ' ')) {
1238 cFYI(1, "empty server netbiosname specified");
1240 /* last byte, type, is 0x20 for servr type */
1241 memset(vol->target_rfc1001_name, 0x20,
1242 RFC1001_NAME_LEN_WITH_NULL);
1244 for (i = 0; i < 15; i++) {
1245 /* BB are there cases in which a comma can be
1246 valid in this workstation netbios name
1247 (and need special handling)? */
1249 /* user or mount helper must uppercase
1254 vol->target_rfc1001_name[i] =
1257 /* The string has 16th byte zero still from
1258 set at top of the function */
1259 if (i == RFC1001_NAME_LEN && value[i] != 0)
1260 printk(KERN_WARNING "CIFS: server net"
1261 "biosname longer than 15 truncated.\n");
1263 } else if (strnicmp(data, "actimeo", 7) == 0) {
1264 if (value && *value) {
1265 vol->actimeo = HZ * simple_strtoul(value,
1267 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1268 cERROR(1, "CIFS: attribute cache"
1269 "timeout too large");
1270 goto cifs_parse_mount_err;
1273 } else if (strnicmp(data, "credentials", 4) == 0) {
1275 } else if (strnicmp(data, "version", 3) == 0) {
1277 } else if (strnicmp(data, "guest", 5) == 0) {
1279 } else if (strnicmp(data, "rw", 2) == 0 && strlen(data) == 2) {
1281 } else if (strnicmp(data, "ro", 2) == 0) {
1283 } else if (strnicmp(data, "noblocksend", 11) == 0) {
1284 vol->noblocksnd = 1;
1285 } else if (strnicmp(data, "noautotune", 10) == 0) {
1286 vol->noautotune = 1;
1287 } else if ((strnicmp(data, "suid", 4) == 0) ||
1288 (strnicmp(data, "nosuid", 6) == 0) ||
1289 (strnicmp(data, "exec", 4) == 0) ||
1290 (strnicmp(data, "noexec", 6) == 0) ||
1291 (strnicmp(data, "nodev", 5) == 0) ||
1292 (strnicmp(data, "noauto", 6) == 0) ||
1293 (strnicmp(data, "dev", 3) == 0)) {
1294 /* The mount tool or mount.cifs helper (if present)
1295 uses these opts to set flags, and the flags are read
1296 by the kernel vfs layer before we get here (ie
1297 before read super) so there is no point trying to
1298 parse these options again and set anything and it
1299 is ok to just ignore them */
1301 } else if (strnicmp(data, "hard", 4) == 0) {
1303 } else if (strnicmp(data, "soft", 4) == 0) {
1305 } else if (strnicmp(data, "perm", 4) == 0) {
1307 } else if (strnicmp(data, "noperm", 6) == 0) {
1309 } else if (strnicmp(data, "mapchars", 8) == 0) {
1311 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1313 } else if (strnicmp(data, "sfu", 3) == 0) {
1315 } else if (strnicmp(data, "nosfu", 5) == 0) {
1317 } else if (strnicmp(data, "nodfs", 5) == 0) {
1319 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1320 vol->posix_paths = 1;
1321 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1322 vol->posix_paths = 0;
1323 } else if (strnicmp(data, "nounix", 6) == 0) {
1324 vol->no_linux_ext = 1;
1325 } else if (strnicmp(data, "nolinux", 7) == 0) {
1326 vol->no_linux_ext = 1;
1327 } else if ((strnicmp(data, "nocase", 6) == 0) ||
1328 (strnicmp(data, "ignorecase", 10) == 0)) {
1330 } else if (strnicmp(data, "mand", 4) == 0) {
1332 } else if (strnicmp(data, "nomand", 6) == 0) {
1334 } else if (strnicmp(data, "_netdev", 7) == 0) {
1336 } else if (strnicmp(data, "brl", 3) == 0) {
1338 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1339 (strnicmp(data, "nolock", 6) == 0)) {
1341 /* turn off mandatory locking in mode
1342 if remote locking is turned off since the
1343 local vfs will do advisory */
1344 if (vol->file_mode ==
1345 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1346 vol->file_mode = S_IALLUGO;
1347 } else if (strnicmp(data, "forcemandatorylock", 9) == 0) {
1348 /* will take the shorter form "forcemand" as well */
1349 /* This mount option will force use of mandatory
1350 (DOS/Windows style) byte range locks, instead of
1351 using posix advisory byte range locks, even if the
1352 Unix extensions are available and posix locks would
1353 be supported otherwise. If Unix extensions are not
1354 negotiated this has no effect since mandatory locks
1355 would be used (mandatory locks is all that those
1356 those servers support) */
1358 } else if (strnicmp(data, "setuids", 7) == 0) {
1360 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1362 } else if (strnicmp(data, "dynperm", 7) == 0) {
1363 vol->dynperm = true;
1364 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1365 vol->dynperm = false;
1366 } else if (strnicmp(data, "nohard", 6) == 0) {
1368 } else if (strnicmp(data, "nosoft", 6) == 0) {
1370 } else if (strnicmp(data, "nointr", 6) == 0) {
1372 } else if (strnicmp(data, "intr", 4) == 0) {
1374 } else if (strnicmp(data, "nostrictsync", 12) == 0) {
1375 vol->nostrictsync = 1;
1376 } else if (strnicmp(data, "strictsync", 10) == 0) {
1377 vol->nostrictsync = 0;
1378 } else if (strnicmp(data, "serverino", 7) == 0) {
1379 vol->server_ino = 1;
1380 } else if (strnicmp(data, "noserverino", 9) == 0) {
1381 vol->server_ino = 0;
1382 } else if (strnicmp(data, "rwpidforward", 12) == 0) {
1383 vol->rwpidforward = 1;
1384 } else if (strnicmp(data, "cifsacl", 7) == 0) {
1386 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1388 } else if (strnicmp(data, "acl", 3) == 0) {
1389 vol->no_psx_acl = 0;
1390 } else if (strnicmp(data, "noacl", 5) == 0) {
1391 vol->no_psx_acl = 1;
1392 } else if (strnicmp(data, "locallease", 6) == 0) {
1393 vol->local_lease = 1;
1394 } else if (strnicmp(data, "sign", 4) == 0) {
1395 vol->secFlg |= CIFSSEC_MUST_SIGN;
1396 } else if (strnicmp(data, "seal", 4) == 0) {
1397 /* we do not do the following in secFlags because seal
1398 is a per tree connection (mount) not a per socket
1399 or per-smb connection option in the protocol */
1400 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1402 } else if (strnicmp(data, "direct", 6) == 0) {
1404 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
1406 } else if (strnicmp(data, "strictcache", 11) == 0) {
1408 } else if (strnicmp(data, "noac", 4) == 0) {
1409 printk(KERN_WARNING "CIFS: Mount option noac not "
1410 "supported. Instead set "
1411 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1412 } else if (strnicmp(data, "fsc", 3) == 0) {
1413 #ifndef CONFIG_CIFS_FSCACHE
1414 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE "
1415 "kernel config option set");
1416 goto cifs_parse_mount_err;
1419 } else if (strnicmp(data, "mfsymlinks", 10) == 0) {
1420 vol->mfsymlinks = true;
1421 } else if (strnicmp(data, "multiuser", 8) == 0) {
1422 vol->multiuser = true;
1423 } else if (!strnicmp(data, "backupuid", 9) && value && *value) {
1424 err = kstrtouint(value, 0, &vol->backupuid);
1426 cERROR(1, "%s: Invalid backupuid value",
1428 goto cifs_parse_mount_err;
1430 vol->backupuid_specified = true;
1431 } else if (!strnicmp(data, "backupgid", 9) && value && *value) {
1432 err = kstrtouint(value, 0, &vol->backupgid);
1434 cERROR(1, "%s: Invalid backupgid value",
1436 goto cifs_parse_mount_err;
1438 vol->backupgid_specified = true;
1440 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1443 if (vol->UNC == NULL) {
1444 if (devname == NULL) {
1445 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1447 goto cifs_parse_mount_err;
1449 if ((temp_len = strnlen(devname, 300)) < 300) {
1450 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1451 if (vol->UNC == NULL)
1452 goto cifs_parse_mount_err;
1453 strcpy(vol->UNC, devname);
1454 if (strncmp(vol->UNC, "//", 2) == 0) {
1457 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1458 printk(KERN_WARNING "CIFS: UNC Path does not "
1459 "begin with // or \\\\ \n");
1460 goto cifs_parse_mount_err;
1462 value = strpbrk(vol->UNC+2, "/\\");
1466 printk(KERN_WARNING "CIFS: UNC name too long\n");
1467 goto cifs_parse_mount_err;
1471 if (vol->multiuser && !(vol->secFlg & CIFSSEC_MAY_KRB5)) {
1472 cERROR(1, "Multiuser mounts currently require krb5 "
1474 goto cifs_parse_mount_err;
1477 if (vol->UNCip == NULL)
1478 vol->UNCip = &vol->UNC[2];
1481 vol->override_uid = override_uid;
1482 else if (override_uid == 1)
1483 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1484 "specified with no uid= option.\n");
1487 vol->override_gid = override_gid;
1488 else if (override_gid == 1)
1489 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1490 "specified with no gid= option.\n");
1492 kfree(mountdata_copy);
1495 cifs_parse_mount_err:
1496 kfree(mountdata_copy);
1500 /** Returns true if srcaddr isn't specified and rhs isn't
1501 * specified, or if srcaddr is specified and
1502 * matches the IP address of the rhs argument.
1505 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1507 switch (srcaddr->sa_family) {
1509 return (rhs->sa_family == AF_UNSPEC);
1511 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1512 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1513 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1516 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1517 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1518 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1522 return false; /* don't expect to be here */
1527 * If no port is specified in addr structure, we try to match with 445 port
1528 * and if it fails - with 139 ports. It should be called only if address
1529 * families of server and addr are equal.
1532 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1534 __be16 port, *sport;
1536 switch (addr->sa_family) {
1538 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1539 port = ((struct sockaddr_in *) addr)->sin_port;
1542 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1543 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1551 port = htons(CIFS_PORT);
1555 port = htons(RFC1001_PORT);
1558 return port == *sport;
1562 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1563 struct sockaddr *srcaddr)
1565 switch (addr->sa_family) {
1567 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1568 struct sockaddr_in *srv_addr4 =
1569 (struct sockaddr_in *)&server->dstaddr;
1571 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1576 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1577 struct sockaddr_in6 *srv_addr6 =
1578 (struct sockaddr_in6 *)&server->dstaddr;
1580 if (!ipv6_addr_equal(&addr6->sin6_addr,
1581 &srv_addr6->sin6_addr))
1583 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
1589 return false; /* don't expect to be here */
1592 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1599 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
1601 unsigned int secFlags;
1603 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
1604 secFlags = vol->secFlg;
1606 secFlags = global_secflags | vol->secFlg;
1608 switch (server->secType) {
1610 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
1614 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
1618 if (!(secFlags & CIFSSEC_MAY_NTLM))
1622 if (!(secFlags & CIFSSEC_MAY_KRB5))
1626 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
1630 /* shouldn't happen */
1634 /* now check if signing mode is acceptable */
1635 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
1636 (server->sec_mode & SECMODE_SIGN_REQUIRED))
1638 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
1640 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
1646 static int match_server(struct TCP_Server_Info *server, struct sockaddr *addr,
1647 struct smb_vol *vol)
1649 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
1652 if (!match_address(server, addr,
1653 (struct sockaddr *)&vol->srcaddr))
1656 if (!match_port(server, addr))
1659 if (!match_security(server, vol))
1665 static struct TCP_Server_Info *
1666 cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
1668 struct TCP_Server_Info *server;
1670 spin_lock(&cifs_tcp_ses_lock);
1671 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
1672 if (!match_server(server, addr, vol))
1675 ++server->srv_count;
1676 spin_unlock(&cifs_tcp_ses_lock);
1677 cFYI(1, "Existing tcp session with server found");
1680 spin_unlock(&cifs_tcp_ses_lock);
1685 cifs_put_tcp_session(struct TCP_Server_Info *server)
1687 struct task_struct *task;
1689 spin_lock(&cifs_tcp_ses_lock);
1690 if (--server->srv_count > 0) {
1691 spin_unlock(&cifs_tcp_ses_lock);
1695 put_net(cifs_net_ns(server));
1697 list_del_init(&server->tcp_ses_list);
1698 spin_unlock(&cifs_tcp_ses_lock);
1700 cancel_delayed_work_sync(&server->echo);
1702 spin_lock(&GlobalMid_Lock);
1703 server->tcpStatus = CifsExiting;
1704 spin_unlock(&GlobalMid_Lock);
1706 cifs_crypto_shash_release(server);
1707 cifs_fscache_release_client_cookie(server);
1709 kfree(server->session_key.response);
1710 server->session_key.response = NULL;
1711 server->session_key.len = 0;
1713 task = xchg(&server->tsk, NULL);
1715 force_sig(SIGKILL, task);
1718 static struct TCP_Server_Info *
1719 cifs_get_tcp_session(struct smb_vol *volume_info)
1721 struct TCP_Server_Info *tcp_ses = NULL;
1722 struct sockaddr_storage addr;
1723 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
1724 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
1727 memset(&addr, 0, sizeof(struct sockaddr_storage));
1729 cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
1731 if (volume_info->UNCip && volume_info->UNC) {
1732 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
1734 strlen(volume_info->UNCip),
1737 /* we failed translating address */
1741 } else if (volume_info->UNCip) {
1742 /* BB using ip addr as tcp_ses name to connect to the
1744 cERROR(1, "Connecting to DFS root not implemented yet");
1747 } else /* which tcp_sess DFS root would we conect to */ {
1748 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
1749 "unc=//192.168.1.100/public) specified");
1754 /* see if we already have a matching tcp_ses */
1755 tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
1759 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1765 rc = cifs_crypto_shash_allocate(tcp_ses);
1767 cERROR(1, "could not setup hash structures rc %d", rc);
1771 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
1772 tcp_ses->hostname = extract_hostname(volume_info->UNC);
1773 if (IS_ERR(tcp_ses->hostname)) {
1774 rc = PTR_ERR(tcp_ses->hostname);
1775 goto out_err_crypto_release;
1778 tcp_ses->noblocksnd = volume_info->noblocksnd;
1779 tcp_ses->noautotune = volume_info->noautotune;
1780 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
1781 atomic_set(&tcp_ses->inFlight, 0);
1782 init_waitqueue_head(&tcp_ses->response_q);
1783 init_waitqueue_head(&tcp_ses->request_q);
1784 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1785 mutex_init(&tcp_ses->srv_mutex);
1786 memcpy(tcp_ses->workstation_RFC1001_name,
1787 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1788 memcpy(tcp_ses->server_RFC1001_name,
1789 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1790 tcp_ses->session_estab = false;
1791 tcp_ses->sequence_number = 0;
1792 tcp_ses->lstrp = jiffies;
1793 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1794 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1795 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
1798 * at this point we are the only ones with the pointer
1799 * to the struct since the kernel thread not created yet
1800 * no need to spinlock this init of tcpStatus or srv_count
1802 tcp_ses->tcpStatus = CifsNew;
1803 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
1804 sizeof(tcp_ses->srcaddr));
1805 ++tcp_ses->srv_count;
1807 if (addr.ss_family == AF_INET6) {
1808 cFYI(1, "attempting ipv6 connect");
1809 /* BB should we allow ipv6 on port 139? */
1810 /* other OS never observed in Wild doing 139 with v6 */
1811 memcpy(&tcp_ses->dstaddr, sin_server6,
1812 sizeof(struct sockaddr_in6));
1814 memcpy(&tcp_ses->dstaddr, sin_server,
1815 sizeof(struct sockaddr_in));
1817 rc = ip_connect(tcp_ses);
1819 cERROR(1, "Error connecting to socket. Aborting operation");
1820 goto out_err_crypto_release;
1824 * since we're in a cifs function already, we know that
1825 * this will succeed. No need for try_module_get().
1827 __module_get(THIS_MODULE);
1828 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
1830 if (IS_ERR(tcp_ses->tsk)) {
1831 rc = PTR_ERR(tcp_ses->tsk);
1832 cERROR(1, "error %d create cifsd thread", rc);
1833 module_put(THIS_MODULE);
1834 goto out_err_crypto_release;
1836 tcp_ses->tcpStatus = CifsNeedNegotiate;
1838 /* thread spawned, put it on the list */
1839 spin_lock(&cifs_tcp_ses_lock);
1840 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
1841 spin_unlock(&cifs_tcp_ses_lock);
1843 cifs_fscache_get_client_cookie(tcp_ses);
1845 /* queue echo request delayed work */
1846 queue_delayed_work(system_nrt_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
1850 out_err_crypto_release:
1851 cifs_crypto_shash_release(tcp_ses);
1853 put_net(cifs_net_ns(tcp_ses));
1857 if (!IS_ERR(tcp_ses->hostname))
1858 kfree(tcp_ses->hostname);
1859 if (tcp_ses->ssocket)
1860 sock_release(tcp_ses->ssocket);
1866 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
1868 switch (ses->server->secType) {
1870 if (vol->cred_uid != ses->cred_uid)
1874 /* anything else takes username/password */
1875 if (ses->user_name == NULL)
1877 if (strncmp(ses->user_name, vol->username,
1880 if (strlen(vol->username) != 0 &&
1881 ses->password != NULL &&
1882 strncmp(ses->password,
1883 vol->password ? vol->password : "",
1890 static struct cifs_ses *
1891 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
1893 struct cifs_ses *ses;
1895 spin_lock(&cifs_tcp_ses_lock);
1896 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
1897 if (!match_session(ses, vol))
1900 spin_unlock(&cifs_tcp_ses_lock);
1903 spin_unlock(&cifs_tcp_ses_lock);
1908 cifs_put_smb_ses(struct cifs_ses *ses)
1911 struct TCP_Server_Info *server = ses->server;
1913 cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
1914 spin_lock(&cifs_tcp_ses_lock);
1915 if (--ses->ses_count > 0) {
1916 spin_unlock(&cifs_tcp_ses_lock);
1920 list_del_init(&ses->smb_ses_list);
1921 spin_unlock(&cifs_tcp_ses_lock);
1923 if (ses->status == CifsGood) {
1925 CIFSSMBLogoff(xid, ses);
1929 cifs_put_tcp_session(server);
1932 static bool warned_on_ntlm; /* globals init to false automatically */
1934 static struct cifs_ses *
1935 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
1937 int rc = -ENOMEM, xid;
1938 struct cifs_ses *ses;
1939 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
1940 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
1944 ses = cifs_find_smb_ses(server, volume_info);
1946 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
1948 mutex_lock(&ses->session_mutex);
1949 rc = cifs_negotiate_protocol(xid, ses);
1951 mutex_unlock(&ses->session_mutex);
1952 /* problem -- put our ses reference */
1953 cifs_put_smb_ses(ses);
1957 if (ses->need_reconnect) {
1958 cFYI(1, "Session needs reconnect");
1959 rc = cifs_setup_session(xid, ses,
1960 volume_info->local_nls);
1962 mutex_unlock(&ses->session_mutex);
1963 /* problem -- put our reference */
1964 cifs_put_smb_ses(ses);
1969 mutex_unlock(&ses->session_mutex);
1971 /* existing SMB ses has a server reference already */
1972 cifs_put_tcp_session(server);
1977 cFYI(1, "Existing smb sess not found");
1978 ses = sesInfoAlloc();
1982 /* new SMB session uses our server ref */
1983 ses->server = server;
1984 if (server->dstaddr.ss_family == AF_INET6)
1985 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
1987 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
1989 if (volume_info->username) {
1990 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
1991 if (!ses->user_name)
1995 /* volume_info->password freed at unmount */
1996 if (volume_info->password) {
1997 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2001 if (volume_info->domainname) {
2002 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2003 if (!ses->domainName)
2006 ses->cred_uid = volume_info->cred_uid;
2007 ses->linux_uid = volume_info->linux_uid;
2009 /* ntlmv2 is much stronger than ntlm security, and has been broadly
2010 supported for many years, time to update default security mechanism */
2011 if ((volume_info->secFlg == 0) && warned_on_ntlm == false) {
2012 warned_on_ntlm = true;
2013 cERROR(1, "default security mechanism requested. The default "
2014 "security mechanism will be upgraded from ntlm to "
2015 "ntlmv2 in kernel release 3.2");
2017 ses->overrideSecFlg = volume_info->secFlg;
2019 mutex_lock(&ses->session_mutex);
2020 rc = cifs_negotiate_protocol(xid, ses);
2022 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2023 mutex_unlock(&ses->session_mutex);
2027 /* success, put it on the list */
2028 spin_lock(&cifs_tcp_ses_lock);
2029 list_add(&ses->smb_ses_list, &server->smb_ses_list);
2030 spin_unlock(&cifs_tcp_ses_lock);
2041 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2043 if (tcon->tidStatus == CifsExiting)
2045 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2050 static struct cifs_tcon *
2051 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2053 struct list_head *tmp;
2054 struct cifs_tcon *tcon;
2056 spin_lock(&cifs_tcp_ses_lock);
2057 list_for_each(tmp, &ses->tcon_list) {
2058 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2059 if (!match_tcon(tcon, unc))
2062 spin_unlock(&cifs_tcp_ses_lock);
2065 spin_unlock(&cifs_tcp_ses_lock);
2070 cifs_put_tcon(struct cifs_tcon *tcon)
2073 struct cifs_ses *ses = tcon->ses;
2075 cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2076 spin_lock(&cifs_tcp_ses_lock);
2077 if (--tcon->tc_count > 0) {
2078 spin_unlock(&cifs_tcp_ses_lock);
2082 list_del_init(&tcon->tcon_list);
2083 spin_unlock(&cifs_tcp_ses_lock);
2086 CIFSSMBTDis(xid, tcon);
2089 cifs_fscache_release_super_cookie(tcon);
2091 cifs_put_smb_ses(ses);
2094 static struct cifs_tcon *
2095 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2098 struct cifs_tcon *tcon;
2100 tcon = cifs_find_tcon(ses, volume_info->UNC);
2102 cFYI(1, "Found match on UNC path");
2103 /* existing tcon already has a reference */
2104 cifs_put_smb_ses(ses);
2105 if (tcon->seal != volume_info->seal)
2106 cERROR(1, "transport encryption setting "
2107 "conflicts with existing tid");
2111 tcon = tconInfoAlloc();
2118 if (volume_info->password) {
2119 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2120 if (!tcon->password) {
2126 if (strchr(volume_info->UNC + 3, '\\') == NULL
2127 && strchr(volume_info->UNC + 3, '/') == NULL) {
2128 cERROR(1, "Missing share name");
2133 /* BB Do we need to wrap session_mutex around
2134 * this TCon call and Unix SetFS as
2135 * we do on SessSetup and reconnect? */
2137 rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
2139 cFYI(1, "CIFS Tcon rc = %d", rc);
2143 if (volume_info->nodfs) {
2144 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2145 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2147 tcon->seal = volume_info->seal;
2148 /* we can have only one retry value for a connection
2149 to a share so for resources mounted more than once
2150 to the same server share the last value passed in
2151 for the retry flag is used */
2152 tcon->retry = volume_info->retry;
2153 tcon->nocase = volume_info->nocase;
2154 tcon->local_lease = volume_info->local_lease;
2156 spin_lock(&cifs_tcp_ses_lock);
2157 list_add(&tcon->tcon_list, &ses->tcon_list);
2158 spin_unlock(&cifs_tcp_ses_lock);
2160 cifs_fscache_get_super_cookie(tcon);
2170 cifs_put_tlink(struct tcon_link *tlink)
2172 if (!tlink || IS_ERR(tlink))
2175 if (!atomic_dec_and_test(&tlink->tl_count) ||
2176 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2177 tlink->tl_time = jiffies;
2181 if (!IS_ERR(tlink_tcon(tlink)))
2182 cifs_put_tcon(tlink_tcon(tlink));
2187 static inline struct tcon_link *
2188 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2190 return cifs_sb->master_tlink;
2194 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2196 struct cifs_sb_info *old = CIFS_SB(sb);
2197 struct cifs_sb_info *new = mnt_data->cifs_sb;
2199 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2202 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2203 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2206 if (old->rsize != new->rsize)
2210 * We want to share sb only if we don't specify wsize or specified wsize
2211 * is greater or equal than existing one.
2213 if (new->wsize && new->wsize < old->wsize)
2216 if (old->mnt_uid != new->mnt_uid || old->mnt_gid != new->mnt_gid)
2219 if (old->mnt_file_mode != new->mnt_file_mode ||
2220 old->mnt_dir_mode != new->mnt_dir_mode)
2223 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2226 if (old->actimeo != new->actimeo)
2233 cifs_match_super(struct super_block *sb, void *data)
2235 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2236 struct smb_vol *volume_info;
2237 struct cifs_sb_info *cifs_sb;
2238 struct TCP_Server_Info *tcp_srv;
2239 struct cifs_ses *ses;
2240 struct cifs_tcon *tcon;
2241 struct tcon_link *tlink;
2242 struct sockaddr_storage addr;
2245 memset(&addr, 0, sizeof(struct sockaddr_storage));
2247 spin_lock(&cifs_tcp_ses_lock);
2248 cifs_sb = CIFS_SB(sb);
2249 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2250 if (IS_ERR(tlink)) {
2251 spin_unlock(&cifs_tcp_ses_lock);
2254 tcon = tlink_tcon(tlink);
2256 tcp_srv = ses->server;
2258 volume_info = mnt_data->vol;
2260 if (!volume_info->UNCip || !volume_info->UNC)
2263 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
2265 strlen(volume_info->UNCip),
2270 if (!match_server(tcp_srv, (struct sockaddr *)&addr, volume_info) ||
2271 !match_session(ses, volume_info) ||
2272 !match_tcon(tcon, volume_info->UNC)) {
2277 rc = compare_mount_options(sb, mnt_data);
2279 spin_unlock(&cifs_tcp_ses_lock);
2280 cifs_put_tlink(tlink);
2285 get_dfs_path(int xid, struct cifs_ses *pSesInfo, const char *old_path,
2286 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
2287 struct dfs_info3_param **preferrals, int remap)
2292 *pnum_referrals = 0;
2295 if (pSesInfo->ipc_tid == 0) {
2296 temp_unc = kmalloc(2 /* for slashes */ +
2297 strnlen(pSesInfo->serverName,
2298 SERVER_NAME_LEN_WITH_NULL * 2)
2299 + 1 + 4 /* slash IPC$ */ + 2,
2301 if (temp_unc == NULL)
2305 strcpy(temp_unc + 2, pSesInfo->serverName);
2306 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2307 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
2308 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
2312 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
2313 pnum_referrals, nls_codepage, remap);
2314 /* BB map targetUNCs to dfs_info3 structures, here or
2315 in CIFSGetDFSRefer BB */
2320 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2321 static struct lock_class_key cifs_key[2];
2322 static struct lock_class_key cifs_slock_key[2];
2325 cifs_reclassify_socket4(struct socket *sock)
2327 struct sock *sk = sock->sk;
2328 BUG_ON(sock_owned_by_user(sk));
2329 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2330 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2334 cifs_reclassify_socket6(struct socket *sock)
2336 struct sock *sk = sock->sk;
2337 BUG_ON(sock_owned_by_user(sk));
2338 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2339 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2343 cifs_reclassify_socket4(struct socket *sock)
2348 cifs_reclassify_socket6(struct socket *sock)
2353 /* See RFC1001 section 14 on representation of Netbios names */
2354 static void rfc1002mangle(char *target, char *source, unsigned int length)
2358 for (i = 0, j = 0; i < (length); i++) {
2359 /* mask a nibble at a time and encode */
2360 target[j] = 'A' + (0x0F & (source[i] >> 4));
2361 target[j+1] = 'A' + (0x0F & source[i]);
2368 bind_socket(struct TCP_Server_Info *server)
2371 if (server->srcaddr.ss_family != AF_UNSPEC) {
2372 /* Bind to the specified local IP address */
2373 struct socket *socket = server->ssocket;
2374 rc = socket->ops->bind(socket,
2375 (struct sockaddr *) &server->srcaddr,
2376 sizeof(server->srcaddr));
2378 struct sockaddr_in *saddr4;
2379 struct sockaddr_in6 *saddr6;
2380 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2381 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2382 if (saddr6->sin6_family == AF_INET6)
2384 "Failed to bind to: %pI6c, error: %d\n",
2385 &saddr6->sin6_addr, rc);
2388 "Failed to bind to: %pI4, error: %d\n",
2389 &saddr4->sin_addr.s_addr, rc);
2396 ip_rfc1001_connect(struct TCP_Server_Info *server)
2400 * some servers require RFC1001 sessinit before sending
2401 * negprot - BB check reconnection in case where second
2402 * sessinit is sent but no second negprot
2404 struct rfc1002_session_packet *ses_init_buf;
2405 struct smb_hdr *smb_buf;
2406 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2409 ses_init_buf->trailer.session_req.called_len = 32;
2411 if (server->server_RFC1001_name &&
2412 server->server_RFC1001_name[0] != 0)
2413 rfc1002mangle(ses_init_buf->trailer.
2414 session_req.called_name,
2415 server->server_RFC1001_name,
2416 RFC1001_NAME_LEN_WITH_NULL);
2418 rfc1002mangle(ses_init_buf->trailer.
2419 session_req.called_name,
2420 DEFAULT_CIFS_CALLED_NAME,
2421 RFC1001_NAME_LEN_WITH_NULL);
2423 ses_init_buf->trailer.session_req.calling_len = 32;
2426 * calling name ends in null (byte 16) from old smb
2429 if (server->workstation_RFC1001_name &&
2430 server->workstation_RFC1001_name[0] != 0)
2431 rfc1002mangle(ses_init_buf->trailer.
2432 session_req.calling_name,
2433 server->workstation_RFC1001_name,
2434 RFC1001_NAME_LEN_WITH_NULL);
2436 rfc1002mangle(ses_init_buf->trailer.
2437 session_req.calling_name,
2439 RFC1001_NAME_LEN_WITH_NULL);
2441 ses_init_buf->trailer.session_req.scope1 = 0;
2442 ses_init_buf->trailer.session_req.scope2 = 0;
2443 smb_buf = (struct smb_hdr *)ses_init_buf;
2445 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2446 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
2447 rc = smb_send(server, smb_buf, 0x44);
2448 kfree(ses_init_buf);
2450 * RFC1001 layer in at least one server
2451 * requires very short break before negprot
2452 * presumably because not expecting negprot
2453 * to follow so fast. This is a simple
2454 * solution that works without
2455 * complicating the code and causes no
2456 * significant slowing down on mount
2459 usleep_range(1000, 2000);
2462 * else the negprot may still work without this
2463 * even though malloc failed
2470 generic_ip_connect(struct TCP_Server_Info *server)
2475 struct socket *socket = server->ssocket;
2476 struct sockaddr *saddr;
2478 saddr = (struct sockaddr *) &server->dstaddr;
2480 if (server->dstaddr.ss_family == AF_INET6) {
2481 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2482 slen = sizeof(struct sockaddr_in6);
2485 sport = ((struct sockaddr_in *) saddr)->sin_port;
2486 slen = sizeof(struct sockaddr_in);
2490 if (socket == NULL) {
2491 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2492 IPPROTO_TCP, &socket, 1);
2494 cERROR(1, "Error %d creating socket", rc);
2495 server->ssocket = NULL;
2499 /* BB other socket options to set KEEPALIVE, NODELAY? */
2500 cFYI(1, "Socket created");
2501 server->ssocket = socket;
2502 socket->sk->sk_allocation = GFP_NOFS;
2503 if (sfamily == AF_INET6)
2504 cifs_reclassify_socket6(socket);
2506 cifs_reclassify_socket4(socket);
2509 rc = bind_socket(server);
2514 * Eventually check for other socket options to change from
2515 * the default. sock_setsockopt not used because it expects
2518 socket->sk->sk_rcvtimeo = 7 * HZ;
2519 socket->sk->sk_sndtimeo = 5 * HZ;
2521 /* make the bufsizes depend on wsize/rsize and max requests */
2522 if (server->noautotune) {
2523 if (socket->sk->sk_sndbuf < (200 * 1024))
2524 socket->sk->sk_sndbuf = 200 * 1024;
2525 if (socket->sk->sk_rcvbuf < (140 * 1024))
2526 socket->sk->sk_rcvbuf = 140 * 1024;
2529 if (server->tcp_nodelay) {
2531 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2532 (char *)&val, sizeof(val));
2534 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
2537 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
2538 socket->sk->sk_sndbuf,
2539 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
2541 rc = socket->ops->connect(socket, saddr, slen, 0);
2543 cFYI(1, "Error %d connecting to server", rc);
2544 sock_release(socket);
2545 server->ssocket = NULL;
2549 if (sport == htons(RFC1001_PORT))
2550 rc = ip_rfc1001_connect(server);
2556 ip_connect(struct TCP_Server_Info *server)
2559 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2560 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2562 if (server->dstaddr.ss_family == AF_INET6)
2563 sport = &addr6->sin6_port;
2565 sport = &addr->sin_port;
2570 /* try with 445 port at first */
2571 *sport = htons(CIFS_PORT);
2573 rc = generic_ip_connect(server);
2577 /* if it failed, try with 139 port */
2578 *sport = htons(RFC1001_PORT);
2581 return generic_ip_connect(server);
2584 void reset_cifs_unix_caps(int xid, struct cifs_tcon *tcon,
2585 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
2587 /* if we are reconnecting then should we check to see if
2588 * any requested capabilities changed locally e.g. via
2589 * remount but we can not do much about it here
2590 * if they have (even if we could detect it by the following)
2591 * Perhaps we could add a backpointer to array of sb from tcon
2592 * or if we change to make all sb to same share the same
2593 * sb as NFS - then we only have one backpointer to sb.
2594 * What if we wanted to mount the server share twice once with
2595 * and once without posixacls or posix paths? */
2596 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2598 if (vol_info && vol_info->no_linux_ext) {
2599 tcon->fsUnixInfo.Capability = 0;
2600 tcon->unix_ext = 0; /* Unix Extensions disabled */
2601 cFYI(1, "Linux protocol extensions disabled");
2603 } else if (vol_info)
2604 tcon->unix_ext = 1; /* Unix Extensions supported */
2606 if (tcon->unix_ext == 0) {
2607 cFYI(1, "Unix extensions disabled so not set on reconnect");
2611 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
2612 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2613 cFYI(1, "unix caps which server supports %lld", cap);
2614 /* check for reconnect case in which we do not
2615 want to change the mount behavior if we can avoid it */
2616 if (vol_info == NULL) {
2617 /* turn off POSIX ACL and PATHNAMES if not set
2618 originally at mount time */
2619 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2620 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2621 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2622 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2623 cERROR(1, "POSIXPATH support change");
2624 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2625 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2626 cERROR(1, "possible reconnect error");
2627 cERROR(1, "server disabled POSIX path support");
2631 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
2632 cERROR(1, "per-share encryption not supported yet");
2634 cap &= CIFS_UNIX_CAP_MASK;
2635 if (vol_info && vol_info->no_psx_acl)
2636 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2637 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
2638 cFYI(1, "negotiated posix acl support");
2640 cifs_sb->mnt_cifs_flags |=
2641 CIFS_MOUNT_POSIXACL;
2644 if (vol_info && vol_info->posix_paths == 0)
2645 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2646 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2647 cFYI(1, "negotiate posix pathnames");
2649 cifs_sb->mnt_cifs_flags |=
2650 CIFS_MOUNT_POSIX_PATHS;
2653 if (cifs_sb && (cifs_sb->rsize > 127 * 1024)) {
2654 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
2655 cifs_sb->rsize = 127 * 1024;
2656 cFYI(DBG2, "larger reads not supported by srv");
2661 cFYI(1, "Negotiate caps 0x%x", (int)cap);
2662 #ifdef CONFIG_CIFS_DEBUG2
2663 if (cap & CIFS_UNIX_FCNTL_CAP)
2664 cFYI(1, "FCNTL cap");
2665 if (cap & CIFS_UNIX_EXTATTR_CAP)
2666 cFYI(1, "EXTATTR cap");
2667 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2668 cFYI(1, "POSIX path cap");
2669 if (cap & CIFS_UNIX_XATTR_CAP)
2670 cFYI(1, "XATTR cap");
2671 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
2672 cFYI(1, "POSIX ACL cap");
2673 if (cap & CIFS_UNIX_LARGE_READ_CAP)
2674 cFYI(1, "very large read cap");
2675 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
2676 cFYI(1, "very large write cap");
2677 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
2678 cFYI(1, "transport encryption cap");
2679 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
2680 cFYI(1, "mandatory transport encryption cap");
2681 #endif /* CIFS_DEBUG2 */
2682 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
2683 if (vol_info == NULL) {
2684 cFYI(1, "resetting capabilities failed");
2686 cERROR(1, "Negotiating Unix capabilities "
2687 "with the server failed. Consider "
2688 "mounting with the Unix Extensions\n"
2689 "disabled, if problems are found, "
2690 "by specifying the nounix mount "
2697 void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
2698 struct cifs_sb_info *cifs_sb)
2700 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
2702 spin_lock_init(&cifs_sb->tlink_tree_lock);
2703 cifs_sb->tlink_tree = RB_ROOT;
2705 if (pvolume_info->rsize > CIFSMaxBufSize) {
2706 cERROR(1, "rsize %d too large, using MaxBufSize",
2707 pvolume_info->rsize);
2708 cifs_sb->rsize = CIFSMaxBufSize;
2709 } else if ((pvolume_info->rsize) &&
2710 (pvolume_info->rsize <= CIFSMaxBufSize))
2711 cifs_sb->rsize = pvolume_info->rsize;
2713 cifs_sb->rsize = CIFSMaxBufSize;
2715 if (cifs_sb->rsize < 2048) {
2716 cifs_sb->rsize = 2048;
2717 /* Windows ME may prefer this */
2718 cFYI(1, "readsize set to minimum: 2048");
2722 * Temporarily set wsize for matching superblock. If we end up using
2723 * new sb then cifs_negotiate_wsize will later negotiate it downward
2726 cifs_sb->wsize = pvolume_info->wsize;
2728 cifs_sb->mnt_uid = pvolume_info->linux_uid;
2729 cifs_sb->mnt_gid = pvolume_info->linux_gid;
2730 if (pvolume_info->backupuid_specified)
2731 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
2732 if (pvolume_info->backupgid_specified)
2733 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
2734 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2735 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
2736 cFYI(1, "file mode: 0x%x dir mode: 0x%x",
2737 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
2739 cifs_sb->actimeo = pvolume_info->actimeo;
2740 cifs_sb->local_nls = pvolume_info->local_nls;
2742 if (pvolume_info->noperm)
2743 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2744 if (pvolume_info->setuids)
2745 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2746 if (pvolume_info->server_ino)
2747 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2748 if (pvolume_info->remap)
2749 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2750 if (pvolume_info->no_xattr)
2751 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2752 if (pvolume_info->sfu_emul)
2753 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2754 if (pvolume_info->nobrl)
2755 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2756 if (pvolume_info->nostrictsync)
2757 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
2758 if (pvolume_info->mand_lock)
2759 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
2760 if (pvolume_info->rwpidforward)
2761 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
2762 if (pvolume_info->cifs_acl)
2763 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2764 if (pvolume_info->backupuid_specified)
2765 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
2766 if (pvolume_info->backupgid_specified)
2767 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
2768 if (pvolume_info->override_uid)
2769 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2770 if (pvolume_info->override_gid)
2771 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2772 if (pvolume_info->dynperm)
2773 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2774 if (pvolume_info->fsc)
2775 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
2776 if (pvolume_info->multiuser)
2777 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
2778 CIFS_MOUNT_NO_PERM);
2779 if (pvolume_info->strict_io)
2780 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
2781 if (pvolume_info->direct_io) {
2782 cFYI(1, "mounting share using direct i/o");
2783 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2785 if (pvolume_info->mfsymlinks) {
2786 if (pvolume_info->sfu_emul) {
2787 cERROR(1, "mount option mfsymlinks ignored if sfu "
2788 "mount option is used");
2790 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
2794 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
2795 cERROR(1, "mount option dynperm ignored if cifsacl "
2796 "mount option supported");
2800 * When the server supports very large writes via POSIX extensions, we can
2801 * allow up to 2^24-1, minus the size of a WRITE_AND_X header, not including
2802 * the RFC1001 length.
2804 * Note that this might make for "interesting" allocation problems during
2805 * writeback however as we have to allocate an array of pointers for the
2806 * pages. A 16M write means ~32kb page array with PAGE_CACHE_SIZE == 4096.
2808 #define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
2811 * When the server doesn't allow large posix writes, only allow a wsize of
2812 * 2^17-1 minus the size of the WRITE_AND_X header. That allows for a write up
2813 * to the maximum size described by RFC1002.
2815 #define CIFS_MAX_RFC1002_WSIZE ((1<<17) - 1 - sizeof(WRITE_REQ) + 4)
2818 * The default wsize is 1M. find_get_pages seems to return a maximum of 256
2819 * pages in a single call. With PAGE_CACHE_SIZE == 4k, this means we can fill
2820 * a single wsize request with a single call.
2822 #define CIFS_DEFAULT_WSIZE (1024 * 1024)
2825 cifs_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
2827 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2828 struct TCP_Server_Info *server = tcon->ses->server;
2829 unsigned int wsize = pvolume_info->wsize ? pvolume_info->wsize :
2832 /* can server support 24-bit write sizes? (via UNIX extensions) */
2833 if (!tcon->unix_ext || !(unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
2834 wsize = min_t(unsigned int, wsize, CIFS_MAX_RFC1002_WSIZE);
2837 * no CAP_LARGE_WRITE_X or is signing enabled without CAP_UNIX set?
2838 * Limit it to max buffer offered by the server, minus the size of the
2839 * WRITEX header, not including the 4 byte RFC1001 length.
2841 if (!(server->capabilities & CAP_LARGE_WRITE_X) ||
2842 (!(server->capabilities & CAP_UNIX) &&
2843 (server->sec_mode & (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED))))
2844 wsize = min_t(unsigned int, wsize,
2845 server->maxBuf - sizeof(WRITE_REQ) + 4);
2847 /* hard limit of CIFS_MAX_WSIZE */
2848 wsize = min_t(unsigned int, wsize, CIFS_MAX_WSIZE);
2854 is_path_accessible(int xid, struct cifs_tcon *tcon,
2855 struct cifs_sb_info *cifs_sb, const char *full_path)
2858 FILE_ALL_INFO *pfile_info;
2860 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
2861 if (pfile_info == NULL)
2864 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
2865 0 /* not legacy */, cifs_sb->local_nls,
2866 cifs_sb->mnt_cifs_flags &
2867 CIFS_MOUNT_MAP_SPECIAL_CHR);
2869 if (rc == -EOPNOTSUPP || rc == -EINVAL)
2870 rc = SMBQueryInformation(xid, tcon, full_path, pfile_info,
2871 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
2872 CIFS_MOUNT_MAP_SPECIAL_CHR);
2878 cleanup_volume_info_contents(struct smb_vol *volume_info)
2880 kfree(volume_info->username);
2881 kzfree(volume_info->password);
2882 kfree(volume_info->UNC);
2883 if (volume_info->UNCip != volume_info->UNC + 2)
2884 kfree(volume_info->UNCip);
2885 kfree(volume_info->domainname);
2886 kfree(volume_info->iocharset);
2887 kfree(volume_info->prepath);
2891 cifs_cleanup_volume_info(struct smb_vol *volume_info)
2895 cleanup_volume_info_contents(volume_info);
2900 #ifdef CONFIG_CIFS_DFS_UPCALL
2901 /* build_path_to_root returns full path to root when
2902 * we do not have an exiting connection (tcon) */
2904 build_unc_path_to_root(const struct smb_vol *vol,
2905 const struct cifs_sb_info *cifs_sb)
2907 char *full_path, *pos;
2908 unsigned int pplen = vol->prepath ? strlen(vol->prepath) : 0;
2909 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
2911 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
2912 if (full_path == NULL)
2913 return ERR_PTR(-ENOMEM);
2915 strncpy(full_path, vol->UNC, unc_len);
2916 pos = full_path + unc_len;
2919 strncpy(pos, vol->prepath, pplen);
2923 *pos = '\0'; /* add trailing null */
2924 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
2925 cFYI(1, "%s: full_path=%s", __func__, full_path);
2930 * Perform a dfs referral query for a share and (optionally) prefix
2932 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
2933 * to a string containing updated options for the submount. Otherwise it
2934 * will be left untouched.
2936 * Returns the rc from get_dfs_path to the caller, which can be used to
2937 * determine whether there were referrals.
2940 expand_dfs_referral(int xid, struct cifs_ses *pSesInfo,
2941 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
2945 unsigned int num_referrals = 0;
2946 struct dfs_info3_param *referrals = NULL;
2947 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
2949 full_path = build_unc_path_to_root(volume_info, cifs_sb);
2950 if (IS_ERR(full_path))
2951 return PTR_ERR(full_path);
2953 /* For DFS paths, skip the first '\' of the UNC */
2954 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
2956 rc = get_dfs_path(xid, pSesInfo , ref_path, cifs_sb->local_nls,
2957 &num_referrals, &referrals,
2958 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
2960 if (!rc && num_referrals > 0) {
2961 char *fake_devname = NULL;
2963 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
2964 full_path + 1, referrals,
2967 free_dfs_info_array(referrals, num_referrals);
2969 if (IS_ERR(mdata)) {
2970 rc = PTR_ERR(mdata);
2973 cleanup_volume_info_contents(volume_info);
2974 memset(volume_info, '\0', sizeof(*volume_info));
2975 rc = cifs_setup_volume_info(volume_info, mdata,
2978 kfree(fake_devname);
2979 kfree(cifs_sb->mountdata);
2980 cifs_sb->mountdata = mdata;
2988 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
2989 const char *devname)
2993 if (cifs_parse_mount_options(mount_data, devname, volume_info))
2996 if (volume_info->nullauth) {
2997 cFYI(1, "null user");
2998 volume_info->username = kzalloc(1, GFP_KERNEL);
2999 if (volume_info->username == NULL)
3001 } else if (volume_info->username) {
3002 /* BB fixme parse for domain name here */
3003 cFYI(1, "Username: %s", volume_info->username);
3005 cifserror("No username specified");
3006 /* In userspace mount helper we can get user name from alternate
3007 locations such as env variables and files on disk */
3011 /* this is needed for ASCII cp to Unicode converts */
3012 if (volume_info->iocharset == NULL) {
3013 /* load_nls_default cannot return null */
3014 volume_info->local_nls = load_nls_default();
3016 volume_info->local_nls = load_nls(volume_info->iocharset);
3017 if (volume_info->local_nls == NULL) {
3018 cERROR(1, "CIFS mount error: iocharset %s not found",
3019 volume_info->iocharset);
3028 cifs_get_volume_info(char *mount_data, const char *devname)
3031 struct smb_vol *volume_info;
3033 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
3035 return ERR_PTR(-ENOMEM);
3037 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3039 cifs_cleanup_volume_info(volume_info);
3040 volume_info = ERR_PTR(rc);
3047 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3051 struct cifs_ses *pSesInfo;
3052 struct cifs_tcon *tcon;
3053 struct TCP_Server_Info *srvTcp;
3055 struct tcon_link *tlink;
3056 #ifdef CONFIG_CIFS_DFS_UPCALL
3057 int referral_walks_count = 0;
3060 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3064 cifs_sb->bdi.ra_pages = default_backing_dev_info.ra_pages;
3066 #ifdef CONFIG_CIFS_DFS_UPCALL
3068 /* cleanup activities if we're chasing a referral */
3069 if (referral_walks_count) {
3071 cifs_put_tcon(tcon);
3073 cifs_put_smb_ses(pSesInfo);
3086 /* get a reference to a tcp session */
3087 srvTcp = cifs_get_tcp_session(volume_info);
3088 if (IS_ERR(srvTcp)) {
3089 rc = PTR_ERR(srvTcp);
3090 bdi_destroy(&cifs_sb->bdi);
3094 /* get a reference to a SMB session */
3095 pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
3096 if (IS_ERR(pSesInfo)) {
3097 rc = PTR_ERR(pSesInfo);
3099 goto mount_fail_check;
3102 /* search for existing tcon to this server share */
3103 tcon = cifs_get_tcon(pSesInfo, volume_info);
3107 goto remote_path_check;
3110 /* tell server which Unix caps we support */
3111 if (tcon->ses->capabilities & CAP_UNIX) {
3112 /* reset of caps checks mount to see if unix extensions
3113 disabled for just this mount */
3114 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3115 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3116 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3117 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3119 goto mount_fail_check;
3122 tcon->unix_ext = 0; /* server does not support them */
3124 /* do not care if following two calls succeed - informational */
3126 CIFSSMBQFSDeviceInfo(xid, tcon);
3127 CIFSSMBQFSAttributeInfo(xid, tcon);
3130 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
3131 cifs_sb->rsize = 1024 * 127;
3132 cFYI(DBG2, "no very large read support, rsize now 127K");
3134 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
3135 cifs_sb->rsize = min(cifs_sb->rsize, CIFSMaxBufSize);
3137 cifs_sb->wsize = cifs_negotiate_wsize(tcon, volume_info);
3140 #ifdef CONFIG_CIFS_DFS_UPCALL
3142 * Perform an unconditional check for whether there are DFS
3143 * referrals for this path without prefix, to provide support
3144 * for DFS referrals from w2k8 servers which don't seem to respond
3145 * with PATH_NOT_COVERED to requests that include the prefix.
3146 * Chase the referral if found, otherwise continue normally.
3148 if (referral_walks_count == 0) {
3149 int refrc = expand_dfs_referral(xid, pSesInfo, volume_info,
3152 referral_walks_count++;
3153 goto try_mount_again;
3158 /* check if a whole path is not remote */
3160 /* build_path_to_root works only when we have a valid tcon */
3161 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3162 if (full_path == NULL) {
3164 goto mount_fail_check;
3166 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
3167 if (rc != 0 && rc != -EREMOTE) {
3169 goto mount_fail_check;
3174 /* get referral if needed */
3175 if (rc == -EREMOTE) {
3176 #ifdef CONFIG_CIFS_DFS_UPCALL
3177 if (referral_walks_count > MAX_NESTED_LINKS) {
3179 * BB: when we implement proper loop detection,
3180 * we will remove this check. But now we need it
3181 * to prevent an indefinite loop if 'DFS tree' is
3182 * misconfigured (i.e. has loops).
3185 goto mount_fail_check;
3188 rc = expand_dfs_referral(xid, pSesInfo, volume_info, cifs_sb,
3192 referral_walks_count++;
3193 goto try_mount_again;
3195 goto mount_fail_check;
3196 #else /* No DFS support, return error on mount */
3202 goto mount_fail_check;
3204 /* now, hang the tcon off of the superblock */
3205 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3206 if (tlink == NULL) {
3208 goto mount_fail_check;
3211 tlink->tl_uid = pSesInfo->linux_uid;
3212 tlink->tl_tcon = tcon;
3213 tlink->tl_time = jiffies;
3214 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3215 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3217 cifs_sb->master_tlink = tlink;
3218 spin_lock(&cifs_sb->tlink_tree_lock);
3219 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3220 spin_unlock(&cifs_sb->tlink_tree_lock);
3222 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
3226 /* on error free sesinfo and tcon struct if needed */
3228 /* If find_unc succeeded then rc == 0 so we can not end */
3229 /* up accidentally freeing someone elses tcon struct */
3231 cifs_put_tcon(tcon);
3233 cifs_put_smb_ses(pSesInfo);
3235 cifs_put_tcp_session(srvTcp);
3236 bdi_destroy(&cifs_sb->bdi);
3245 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3246 * pointer may be NULL.
3249 CIFSTCon(unsigned int xid, struct cifs_ses *ses,
3250 const char *tree, struct cifs_tcon *tcon,
3251 const struct nls_table *nls_codepage)
3253 struct smb_hdr *smb_buffer;
3254 struct smb_hdr *smb_buffer_response;
3257 unsigned char *bcc_ptr;
3260 __u16 bytes_left, count;
3265 smb_buffer = cifs_buf_get();
3266 if (smb_buffer == NULL)
3269 smb_buffer_response = smb_buffer;
3271 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3272 NULL /*no tid */ , 4 /*wct */ );
3274 smb_buffer->Mid = GetNextMid(ses->server);
3275 smb_buffer->Uid = ses->Suid;
3276 pSMB = (TCONX_REQ *) smb_buffer;
3277 pSMBr = (TCONX_RSP *) smb_buffer_response;
3279 pSMB->AndXCommand = 0xFF;
3280 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3281 bcc_ptr = &pSMB->Password[0];
3282 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3283 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3284 *bcc_ptr = 0; /* password is null byte */
3285 bcc_ptr++; /* skip password */
3286 /* already aligned so no need to do it below */
3288 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3289 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3290 specified as required (when that support is added to
3291 the vfs in the future) as only NTLM or the much
3292 weaker LANMAN (which we do not send by default) is accepted
3293 by Samba (not sure whether other servers allow
3294 NTLMv2 password here) */
3295 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3296 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3297 (ses->server->secType == LANMAN))
3298 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3299 ses->server->sec_mode &
3300 SECMODE_PW_ENCRYPT ? true : false,
3303 #endif /* CIFS_WEAK_PW_HASH */
3304 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3307 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3308 if (ses->capabilities & CAP_UNICODE) {
3309 /* must align unicode strings */
3310 *bcc_ptr = 0; /* null byte password */
3315 if (ses->server->sec_mode &
3316 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3317 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3319 if (ses->capabilities & CAP_STATUS32) {
3320 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3322 if (ses->capabilities & CAP_DFS) {
3323 smb_buffer->Flags2 |= SMBFLG2_DFS;
3325 if (ses->capabilities & CAP_UNICODE) {
3326 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3328 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3329 6 /* max utf8 char length in bytes */ *
3330 (/* server len*/ + 256 /* share len */), nls_codepage);
3331 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3332 bcc_ptr += 2; /* skip trailing null */
3333 } else { /* ASCII */
3334 strcpy(bcc_ptr, tree);
3335 bcc_ptr += strlen(tree) + 1;
3337 strcpy(bcc_ptr, "?????");
3338 bcc_ptr += strlen("?????");
3340 count = bcc_ptr - &pSMB->Password[0];
3341 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3342 pSMB->hdr.smb_buf_length) + count);
3343 pSMB->ByteCount = cpu_to_le16(count);
3345 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3348 /* above now done in SendReceive */
3349 if ((rc == 0) && (tcon != NULL)) {
3352 tcon->tidStatus = CifsGood;
3353 tcon->need_reconnect = false;
3354 tcon->tid = smb_buffer_response->Tid;
3355 bcc_ptr = pByteArea(smb_buffer_response);
3356 bytes_left = get_bcc(smb_buffer_response);
3357 length = strnlen(bcc_ptr, bytes_left - 2);
3358 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3364 /* skip service field (NB: this field is always ASCII) */
3366 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3367 (bcc_ptr[2] == 'C')) {
3368 cFYI(1, "IPC connection");
3371 } else if (length == 2) {
3372 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3373 /* the most common case */
3374 cFYI(1, "disk share connection");
3377 bcc_ptr += length + 1;
3378 bytes_left -= (length + 1);
3379 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3381 /* mostly informational -- no need to fail on error here */
3382 kfree(tcon->nativeFileSystem);
3383 tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
3384 bytes_left, is_unicode,
3387 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
3389 if ((smb_buffer_response->WordCount == 3) ||
3390 (smb_buffer_response->WordCount == 7))
3391 /* field is in same location */
3392 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3395 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
3396 } else if ((rc == 0) && tcon == NULL) {
3397 /* all we need to save for IPC$ connection */
3398 ses->ipc_tid = smb_buffer_response->Tid;
3401 cifs_buf_release(smb_buffer);
3406 cifs_umount(struct cifs_sb_info *cifs_sb)
3408 struct rb_root *root = &cifs_sb->tlink_tree;
3409 struct rb_node *node;
3410 struct tcon_link *tlink;
3412 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3414 spin_lock(&cifs_sb->tlink_tree_lock);
3415 while ((node = rb_first(root))) {
3416 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3417 cifs_get_tlink(tlink);
3418 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3419 rb_erase(node, root);
3421 spin_unlock(&cifs_sb->tlink_tree_lock);
3422 cifs_put_tlink(tlink);
3423 spin_lock(&cifs_sb->tlink_tree_lock);
3425 spin_unlock(&cifs_sb->tlink_tree_lock);
3427 bdi_destroy(&cifs_sb->bdi);
3428 kfree(cifs_sb->mountdata);
3429 unload_nls(cifs_sb->local_nls);
3433 int cifs_negotiate_protocol(unsigned int xid, struct cifs_ses *ses)
3436 struct TCP_Server_Info *server = ses->server;
3438 /* only send once per connect */
3439 if (server->maxBuf != 0)
3442 rc = CIFSSMBNegotiate(xid, ses);
3443 if (rc == -EAGAIN) {
3444 /* retry only once on 1st time connection */
3445 rc = CIFSSMBNegotiate(xid, ses);
3450 spin_lock(&GlobalMid_Lock);
3451 if (server->tcpStatus == CifsNeedNegotiate)
3452 server->tcpStatus = CifsGood;
3455 spin_unlock(&GlobalMid_Lock);
3463 int cifs_setup_session(unsigned int xid, struct cifs_ses *ses,
3464 struct nls_table *nls_info)
3467 struct TCP_Server_Info *server = ses->server;
3470 ses->capabilities = server->capabilities;
3471 if (linuxExtEnabled == 0)
3472 ses->capabilities &= (~CAP_UNIX);
3474 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3475 server->sec_mode, server->capabilities, server->timeAdj);
3477 rc = CIFS_SessSetup(xid, ses, nls_info);
3479 cERROR(1, "Send error in SessSetup = %d", rc);
3481 mutex_lock(&ses->server->srv_mutex);
3482 if (!server->session_estab) {
3483 server->session_key.response = ses->auth_key.response;
3484 server->session_key.len = ses->auth_key.len;
3485 server->sequence_number = 0x2;
3486 server->session_estab = true;
3487 ses->auth_key.response = NULL;
3489 mutex_unlock(&server->srv_mutex);
3491 cFYI(1, "CIFS Session Established successfully");
3492 spin_lock(&GlobalMid_Lock);
3493 ses->status = CifsGood;
3494 ses->need_reconnect = false;
3495 spin_unlock(&GlobalMid_Lock);
3498 kfree(ses->auth_key.response);
3499 ses->auth_key.response = NULL;
3500 ses->auth_key.len = 0;
3501 kfree(ses->ntlmssp);
3502 ses->ntlmssp = NULL;
3507 static struct cifs_tcon *
3508 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
3510 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3511 struct cifs_ses *ses;
3512 struct cifs_tcon *tcon = NULL;
3513 struct smb_vol *vol_info;
3514 char username[28]; /* big enough for "krb50x" + hex of ULONG_MAX 6+16 */
3515 /* We used to have this as MAX_USERNAME which is */
3516 /* way too big now (256 instead of 32) */
3518 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3519 if (vol_info == NULL) {
3520 tcon = ERR_PTR(-ENOMEM);
3524 snprintf(username, sizeof(username), "krb50x%x", fsuid);
3525 vol_info->username = username;
3526 vol_info->local_nls = cifs_sb->local_nls;
3527 vol_info->linux_uid = fsuid;
3528 vol_info->cred_uid = fsuid;
3529 vol_info->UNC = master_tcon->treeName;
3530 vol_info->retry = master_tcon->retry;
3531 vol_info->nocase = master_tcon->nocase;
3532 vol_info->local_lease = master_tcon->local_lease;
3533 vol_info->no_linux_ext = !master_tcon->unix_ext;
3535 /* FIXME: allow for other secFlg settings */
3536 vol_info->secFlg = CIFSSEC_MUST_KRB5;
3538 /* get a reference for the same TCP session */
3539 spin_lock(&cifs_tcp_ses_lock);
3540 ++master_tcon->ses->server->srv_count;
3541 spin_unlock(&cifs_tcp_ses_lock);
3543 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3545 tcon = (struct cifs_tcon *)ses;
3546 cifs_put_tcp_session(master_tcon->ses->server);
3550 tcon = cifs_get_tcon(ses, vol_info);
3552 cifs_put_smb_ses(ses);
3556 if (ses->capabilities & CAP_UNIX)
3557 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3565 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3567 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3571 cifs_sb_tcon_pending_wait(void *unused)
3574 return signal_pending(current) ? -ERESTARTSYS : 0;
3577 /* find and return a tlink with given uid */
3578 static struct tcon_link *
3579 tlink_rb_search(struct rb_root *root, uid_t uid)
3581 struct rb_node *node = root->rb_node;
3582 struct tcon_link *tlink;
3585 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3587 if (tlink->tl_uid > uid)
3588 node = node->rb_left;
3589 else if (tlink->tl_uid < uid)
3590 node = node->rb_right;
3597 /* insert a tcon_link into the tree */
3599 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3601 struct rb_node **new = &(root->rb_node), *parent = NULL;
3602 struct tcon_link *tlink;
3605 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3608 if (tlink->tl_uid > new_tlink->tl_uid)
3609 new = &((*new)->rb_left);
3611 new = &((*new)->rb_right);
3614 rb_link_node(&new_tlink->tl_rbnode, parent, new);
3615 rb_insert_color(&new_tlink->tl_rbnode, root);
3619 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3622 * If the superblock doesn't refer to a multiuser mount, then just return
3623 * the master tcon for the mount.
3625 * First, search the rbtree for an existing tcon for this fsuid. If one
3626 * exists, then check to see if it's pending construction. If it is then wait
3627 * for construction to complete. Once it's no longer pending, check to see if
3628 * it failed and either return an error or retry construction, depending on
3631 * If one doesn't exist then insert a new tcon_link struct into the tree and
3632 * try to construct a new one.
3635 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
3638 uid_t fsuid = current_fsuid();
3639 struct tcon_link *tlink, *newtlink;
3641 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
3642 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3644 spin_lock(&cifs_sb->tlink_tree_lock);
3645 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3647 cifs_get_tlink(tlink);
3648 spin_unlock(&cifs_sb->tlink_tree_lock);
3650 if (tlink == NULL) {
3651 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
3652 if (newtlink == NULL)
3653 return ERR_PTR(-ENOMEM);
3654 newtlink->tl_uid = fsuid;
3655 newtlink->tl_tcon = ERR_PTR(-EACCES);
3656 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
3657 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
3658 cifs_get_tlink(newtlink);
3660 spin_lock(&cifs_sb->tlink_tree_lock);
3661 /* was one inserted after previous search? */
3662 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3664 cifs_get_tlink(tlink);
3665 spin_unlock(&cifs_sb->tlink_tree_lock);
3667 goto wait_for_construction;
3670 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3671 spin_unlock(&cifs_sb->tlink_tree_lock);
3673 wait_for_construction:
3674 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
3675 cifs_sb_tcon_pending_wait,
3676 TASK_INTERRUPTIBLE);
3678 cifs_put_tlink(tlink);
3679 return ERR_PTR(ret);
3682 /* if it's good, return it */
3683 if (!IS_ERR(tlink->tl_tcon))
3686 /* return error if we tried this already recently */
3687 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
3688 cifs_put_tlink(tlink);
3689 return ERR_PTR(-EACCES);
3692 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
3693 goto wait_for_construction;
3696 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
3697 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
3698 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
3700 if (IS_ERR(tlink->tl_tcon)) {
3701 cifs_put_tlink(tlink);
3702 return ERR_PTR(-EACCES);
3709 * periodic workqueue job that scans tcon_tree for a superblock and closes
3713 cifs_prune_tlinks(struct work_struct *work)
3715 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
3717 struct rb_root *root = &cifs_sb->tlink_tree;
3718 struct rb_node *node = rb_first(root);
3719 struct rb_node *tmp;
3720 struct tcon_link *tlink;
3723 * Because we drop the spinlock in the loop in order to put the tlink
3724 * it's not guarded against removal of links from the tree. The only
3725 * places that remove entries from the tree are this function and
3726 * umounts. Because this function is non-reentrant and is canceled
3727 * before umount can proceed, this is safe.
3729 spin_lock(&cifs_sb->tlink_tree_lock);
3730 node = rb_first(root);
3731 while (node != NULL) {
3733 node = rb_next(tmp);
3734 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
3736 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
3737 atomic_read(&tlink->tl_count) != 0 ||
3738 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
3741 cifs_get_tlink(tlink);
3742 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3743 rb_erase(tmp, root);
3745 spin_unlock(&cifs_sb->tlink_tree_lock);
3746 cifs_put_tlink(tlink);
3747 spin_lock(&cifs_sb->tlink_tree_lock);
3749 spin_unlock(&cifs_sb->tlink_tree_lock);
3751 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,