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 * kvec_array_init - clone a kvec array, and advance into it
380 * @new: pointer to memory for cloned array
381 * @iov: pointer to original array
382 * @nr_segs: number of members in original array
383 * @bytes: number of bytes to advance into the cloned array
385 * This function will copy the array provided in iov to a section of memory
386 * and advance the specified number of bytes into the new array. It returns
387 * the number of segments in the new array. "new" must be at least as big as
388 * the original iov array.
391 kvec_array_init(struct kvec *new, struct kvec *iov, unsigned int nr_segs,
396 while (bytes || !iov->iov_len) {
397 int copy = min(bytes, iov->iov_len);
401 if (iov->iov_len == base) {
407 memcpy(new, iov, sizeof(*iov) * nr_segs);
408 new->iov_base += base;
409 new->iov_len -= base;
414 get_server_iovec(struct TCP_Server_Info *server, unsigned int nr_segs)
416 struct kvec *new_iov;
418 if (server->iov && nr_segs <= server->nr_iov)
421 /* not big enough -- allocate a new one and release the old */
422 new_iov = kmalloc(sizeof(*new_iov) * nr_segs, GFP_NOFS);
425 server->iov = new_iov;
426 server->nr_iov = nr_segs;
432 readv_from_socket(struct TCP_Server_Info *server, struct kvec *iov_orig,
433 unsigned int nr_segs, unsigned int to_read)
438 struct msghdr smb_msg;
441 iov = get_server_iovec(server, nr_segs);
445 smb_msg.msg_control = NULL;
446 smb_msg.msg_controllen = 0;
448 for (total_read = 0; to_read; total_read += length, to_read -= length) {
449 if (server_unresponsive(server)) {
450 total_read = -EAGAIN;
454 segs = kvec_array_init(iov, iov_orig, nr_segs, total_read);
456 length = kernel_recvmsg(server->ssocket, &smb_msg,
457 iov, segs, to_read, 0);
459 if (server->tcpStatus == CifsExiting) {
460 total_read = -ESHUTDOWN;
462 } else if (server->tcpStatus == CifsNeedReconnect) {
463 cifs_reconnect(server);
464 total_read = -EAGAIN;
466 } else if (length == -ERESTARTSYS ||
470 * Minimum sleep to prevent looping, allowing socket
471 * to clear and app threads to set tcpStatus
472 * CifsNeedReconnect if server hung.
474 usleep_range(1000, 2000);
477 } else if (length <= 0) {
478 cFYI(1, "Received no data or error: expecting %d "
479 "got %d", to_read, length);
480 cifs_reconnect(server);
481 total_read = -EAGAIN;
489 read_from_socket(struct TCP_Server_Info *server, char *buf,
490 unsigned int to_read)
495 iov.iov_len = to_read;
497 return readv_from_socket(server, &iov, 1, to_read);
501 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
504 * The first byte big endian of the length field,
505 * is actually not part of the length but the type
506 * with the most common, zero, as regular data.
509 case RFC1002_SESSION_MESSAGE:
510 /* Regular SMB response */
512 case RFC1002_SESSION_KEEP_ALIVE:
513 cFYI(1, "RFC 1002 session keep alive");
515 case RFC1002_POSITIVE_SESSION_RESPONSE:
516 cFYI(1, "RFC 1002 positive session response");
518 case RFC1002_NEGATIVE_SESSION_RESPONSE:
520 * We get this from Windows 98 instead of an error on
521 * SMB negprot response.
523 cFYI(1, "RFC 1002 negative session response");
524 /* give server a second to clean up */
527 * Always try 445 first on reconnect since we get NACK
528 * on some if we ever connected to port 139 (the NACK
529 * is since we do not begin with RFC1001 session
532 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
533 cifs_reconnect(server);
534 wake_up(&server->response_q);
537 cERROR(1, "RFC 1002 unknown response type 0x%x", type);
538 cifs_reconnect(server);
544 static struct mid_q_entry *
545 find_mid(struct TCP_Server_Info *server, struct smb_hdr *buf)
547 struct mid_q_entry *mid;
549 spin_lock(&GlobalMid_Lock);
550 list_for_each_entry(mid, &server->pending_mid_q, qhead) {
551 if (mid->mid == buf->Mid &&
552 mid->midState == MID_REQUEST_SUBMITTED &&
553 mid->command == buf->Command) {
554 spin_unlock(&GlobalMid_Lock);
558 spin_unlock(&GlobalMid_Lock);
563 dequeue_mid(struct mid_q_entry *mid, int malformed)
565 #ifdef CONFIG_CIFS_STATS2
566 mid->when_received = jiffies;
568 spin_lock(&GlobalMid_Lock);
570 mid->midState = MID_RESPONSE_RECEIVED;
572 mid->midState = MID_RESPONSE_MALFORMED;
573 list_del_init(&mid->qhead);
574 spin_unlock(&GlobalMid_Lock);
577 static struct mid_q_entry *
578 find_cifs_mid(struct TCP_Server_Info *server, struct smb_hdr *buf,
579 int *malformed, bool is_large_buf, bool *is_multi_rsp,
582 struct mid_q_entry *mid = NULL;
584 mid = find_mid(server, buf);
588 if (*malformed == 0 && check2ndT2(buf) > 0) {
589 /* We have a multipart transact2 resp */
590 *is_multi_rsp = true;
592 /* merge response - fix up 1st*/
593 *malformed = coalesce_t2(buf, mid->resp_buf);
594 if (*malformed > 0) {
596 mid->multiRsp = true;
599 /* All parts received or packet is malformed. */
600 mid->multiEnd = true;
604 /*FIXME: switch to already allocated largebuf?*/
605 cERROR(1, "1st trans2 resp needs bigbuf");
607 /* Have first buffer */
609 mid->largeBuf = true;
615 mid->largeBuf = is_large_buf;
617 dequeue_mid(mid, *malformed);
621 static void clean_demultiplex_info(struct TCP_Server_Info *server)
625 /* take it off the list, if it's not already */
626 spin_lock(&cifs_tcp_ses_lock);
627 list_del_init(&server->tcp_ses_list);
628 spin_unlock(&cifs_tcp_ses_lock);
630 spin_lock(&GlobalMid_Lock);
631 server->tcpStatus = CifsExiting;
632 spin_unlock(&GlobalMid_Lock);
633 wake_up_all(&server->response_q);
636 * Check if we have blocked requests that need to free. Note that
637 * cifs_max_pending is normally 50, but can be set at module install
638 * time to as little as two.
640 spin_lock(&GlobalMid_Lock);
641 if (atomic_read(&server->inFlight) >= cifs_max_pending)
642 atomic_set(&server->inFlight, cifs_max_pending - 1);
644 * We do not want to set the max_pending too low or we could end up
645 * with the counter going negative.
647 spin_unlock(&GlobalMid_Lock);
649 * Although there should not be any requests blocked on this queue it
650 * can not hurt to be paranoid and try to wake up requests that may
651 * haven been blocked when more than 50 at time were on the wire to the
652 * same server - they now will see the session is in exit state and get
653 * out of SendReceive.
655 wake_up_all(&server->request_q);
656 /* give those requests time to exit */
659 if (server->ssocket) {
660 sock_release(server->ssocket);
661 server->ssocket = NULL;
664 if (!list_empty(&server->pending_mid_q)) {
665 struct list_head dispose_list;
666 struct mid_q_entry *mid_entry;
667 struct list_head *tmp, *tmp2;
669 INIT_LIST_HEAD(&dispose_list);
670 spin_lock(&GlobalMid_Lock);
671 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
672 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
673 cFYI(1, "Clearing mid 0x%x", mid_entry->mid);
674 mid_entry->midState = MID_SHUTDOWN;
675 list_move(&mid_entry->qhead, &dispose_list);
677 spin_unlock(&GlobalMid_Lock);
679 /* now walk dispose list and issue callbacks */
680 list_for_each_safe(tmp, tmp2, &dispose_list) {
681 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
682 cFYI(1, "Callback mid 0x%x", mid_entry->mid);
683 list_del_init(&mid_entry->qhead);
684 mid_entry->callback(mid_entry);
686 /* 1/8th of sec is more than enough time for them to exit */
690 if (!list_empty(&server->pending_mid_q)) {
692 * mpx threads have not exited yet give them at least the smb
693 * send timeout time for long ops.
695 * Due to delays on oplock break requests, we need to wait at
696 * least 45 seconds before giving up on a request getting a
697 * response and going ahead and killing cifsd.
699 cFYI(1, "Wait for exit from demultiplex thread");
702 * If threads still have not exited they are probably never
703 * coming home not much else we can do but free the memory.
707 kfree(server->hostname);
711 length = atomic_dec_return(&tcpSesAllocCount);
713 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
718 cifs_demultiplex_thread(void *p)
721 struct TCP_Server_Info *server = p;
722 unsigned int pdu_length, total_read;
723 char *buf = NULL, *bigbuf = NULL, *smallbuf = NULL;
724 struct smb_hdr *smb_buffer = NULL;
725 struct task_struct *task_to_wake = NULL;
726 struct mid_q_entry *mid_entry;
727 bool isLargeBuf = false;
728 bool isMultiRsp = false;
730 current->flags |= PF_MEMALLOC;
731 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
733 length = atomic_inc_return(&tcpSesAllocCount);
735 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
739 while (server->tcpStatus != CifsExiting) {
743 if (!allocate_buffers(&bigbuf, &smallbuf,
744 sizeof(struct smb_hdr), isLargeBuf))
749 smb_buffer = (struct smb_hdr *)smallbuf;
751 pdu_length = 4; /* enough to get RFC1001 header */
753 length = read_from_socket(server, buf, pdu_length);
759 * The right amount was read from socket - 4 bytes,
760 * so we can now interpret the length field.
762 pdu_length = be32_to_cpu(smb_buffer->smb_buf_length);
764 cFYI(1, "RFC1002 header 0x%x", pdu_length);
765 if (!is_smb_response(server, buf[0]))
768 /* make sure we have enough to get to the MID */
769 if (pdu_length < sizeof(struct smb_hdr) - 1 - 4) {
770 cERROR(1, "SMB response too short (%u bytes)",
772 cifs_reconnect(server);
773 wake_up(&server->response_q);
777 /* read down to the MID */
778 length = read_from_socket(server, buf + 4,
779 sizeof(struct smb_hdr) - 1 - 4);
782 total_read += length;
784 if (pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
785 cERROR(1, "SMB response too long (%u bytes)",
787 cifs_reconnect(server);
788 wake_up(&server->response_q);
793 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
795 memcpy(bigbuf, smallbuf, total_read);
796 smb_buffer = (struct smb_hdr *)bigbuf;
800 /* now read the rest */
801 length = read_from_socket(server,
802 buf + sizeof(struct smb_hdr) - 1,
803 pdu_length - sizeof(struct smb_hdr) + 1 + 4);
806 total_read += length;
808 dump_smb(smb_buffer, total_read);
811 * We know that we received enough to get to the MID as we
812 * checked the pdu_length earlier. Now check to see
813 * if the rest of the header is OK. We borrow the length
814 * var for the rest of the loop to avoid a new stack var.
816 * 48 bytes is enough to display the header and a little bit
817 * into the payload for debugging purposes.
819 length = checkSMB(smb_buffer, smb_buffer->Mid, total_read);
821 cifs_dump_mem("Bad SMB: ", buf,
822 min_t(unsigned int, total_read, 48));
824 server->lstrp = jiffies;
826 mid_entry = find_cifs_mid(server, smb_buffer, &length,
827 isLargeBuf, &isMultiRsp, &bigbuf);
828 if (mid_entry != NULL) {
829 mid_entry->callback(mid_entry);
830 /* Was previous buf put in mpx struct for multi-rsp? */
832 /* smb buffer will be freed by user thread */
838 } else if (length != 0) {
839 /* response sanity checks failed */
841 } else if (!is_valid_oplock_break(smb_buffer, server) &&
843 cERROR(1, "No task to wake, unknown frame received! "
844 "NumMids %d", atomic_read(&midCount));
845 cifs_dump_mem("Received Data is: ", buf,
846 sizeof(struct smb_hdr));
847 #ifdef CONFIG_CIFS_DEBUG2
848 cifs_dump_detail(smb_buffer);
849 cifs_dump_mids(server);
850 #endif /* CIFS_DEBUG2 */
853 } /* end while !EXITING */
855 /* buffer usually freed in free_mid - need to free it here on exit */
856 cifs_buf_release(bigbuf);
857 if (smallbuf) /* no sense logging a debug message if NULL */
858 cifs_small_buf_release(smallbuf);
860 task_to_wake = xchg(&server->tsk, NULL);
861 clean_demultiplex_info(server);
863 /* if server->tsk was NULL then wait for a signal before exiting */
865 set_current_state(TASK_INTERRUPTIBLE);
866 while (!signal_pending(current)) {
868 set_current_state(TASK_INTERRUPTIBLE);
870 set_current_state(TASK_RUNNING);
873 module_put_and_exit(0);
876 /* extract the host portion of the UNC string */
878 extract_hostname(const char *unc)
884 /* skip double chars at beginning of string */
885 /* BB: check validity of these bytes? */
888 /* delimiter between hostname and sharename is always '\\' now */
889 delim = strchr(src, '\\');
891 return ERR_PTR(-EINVAL);
894 dst = kmalloc((len + 1), GFP_KERNEL);
896 return ERR_PTR(-ENOMEM);
898 memcpy(dst, src, len);
905 cifs_parse_mount_options(const char *mountdata, const char *devname,
908 char *value, *data, *end;
909 char *mountdata_copy = NULL, *options;
911 unsigned int temp_len, i, j;
913 short int override_uid = -1;
914 short int override_gid = -1;
915 bool uid_specified = false;
916 bool gid_specified = false;
917 char *nodename = utsname()->nodename;
923 * does not have to be perfect mapping since field is
924 * informational, only used for servers that do not support
925 * port 445 and it can be overridden at mount time
927 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
928 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
929 vol->source_rfc1001_name[i] = toupper(nodename[i]);
931 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
932 /* null target name indicates to use *SMBSERVR default called name
933 if we end up sending RFC1001 session initialize */
934 vol->target_rfc1001_name[0] = 0;
935 vol->cred_uid = current_uid();
936 vol->linux_uid = current_uid();
937 vol->linux_gid = current_gid();
939 /* default to only allowing write access to owner of the mount */
940 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
942 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
943 /* default is always to request posix paths. */
944 vol->posix_paths = 1;
945 /* default to using server inode numbers where available */
948 vol->actimeo = CIFS_DEF_ACTIMEO;
951 goto cifs_parse_mount_err;
953 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
955 goto cifs_parse_mount_err;
957 options = mountdata_copy;
958 end = options + strlen(options);
959 if (strncmp(options, "sep=", 4) == 0) {
960 if (options[4] != 0) {
961 separator[0] = options[4];
964 cFYI(1, "Null separator not allowed");
967 vol->backupuid_specified = false; /* no backup intent for a user */
968 vol->backupgid_specified = false; /* no backup intent for a group */
970 while ((data = strsep(&options, separator)) != NULL) {
973 if ((value = strchr(data, '=')) != NULL)
976 /* Have to parse this before we parse for "user" */
977 if (strnicmp(data, "user_xattr", 10) == 0) {
979 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
981 } else if (strnicmp(data, "user", 4) == 0) {
984 "CIFS: invalid or missing username\n");
985 goto cifs_parse_mount_err;
986 } else if (!*value) {
987 /* null user, ie anonymous, authentication */
990 if (strnlen(value, MAX_USERNAME_SIZE) <
992 vol->username = kstrdup(value, GFP_KERNEL);
993 if (!vol->username) {
994 printk(KERN_WARNING "CIFS: no memory "
996 goto cifs_parse_mount_err;
999 printk(KERN_WARNING "CIFS: username too long\n");
1000 goto cifs_parse_mount_err;
1002 } else if (strnicmp(data, "pass", 4) == 0) {
1004 vol->password = NULL;
1006 } else if (value[0] == 0) {
1007 /* check if string begins with double comma
1008 since that would mean the password really
1009 does start with a comma, and would not
1010 indicate an empty string */
1011 if (value[1] != separator[0]) {
1012 vol->password = NULL;
1016 temp_len = strlen(value);
1017 /* removed password length check, NTLM passwords
1018 can be arbitrarily long */
1020 /* if comma in password, the string will be
1021 prematurely null terminated. Commas in password are
1022 specified across the cifs mount interface by a double
1023 comma ie ,, and a comma used as in other cases ie ','
1024 as a parameter delimiter/separator is single and due
1025 to the strsep above is temporarily zeroed. */
1027 /* NB: password legally can have multiple commas and
1028 the only illegal character in a password is null */
1030 if ((value[temp_len] == 0) &&
1031 (value + temp_len < end) &&
1032 (value[temp_len+1] == separator[0])) {
1033 /* reinsert comma */
1034 value[temp_len] = separator[0];
1035 temp_len += 2; /* move after second comma */
1036 while (value[temp_len] != 0) {
1037 if (value[temp_len] == separator[0]) {
1038 if (value[temp_len+1] ==
1040 /* skip second comma */
1043 /* single comma indicating start
1050 if (value[temp_len] == 0) {
1053 value[temp_len] = 0;
1054 /* point option to start of next parm */
1055 options = value + temp_len + 1;
1057 /* go from value to value + temp_len condensing
1058 double commas to singles. Note that this ends up
1059 allocating a few bytes too many, which is ok */
1060 vol->password = kzalloc(temp_len, GFP_KERNEL);
1061 if (vol->password == NULL) {
1062 printk(KERN_WARNING "CIFS: no memory "
1064 goto cifs_parse_mount_err;
1066 for (i = 0, j = 0; i < temp_len; i++, j++) {
1067 vol->password[j] = value[i];
1068 if (value[i] == separator[0]
1069 && value[i+1] == separator[0]) {
1070 /* skip second comma */
1074 vol->password[j] = 0;
1076 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1077 if (vol->password == NULL) {
1078 printk(KERN_WARNING "CIFS: no memory "
1080 goto cifs_parse_mount_err;
1082 strcpy(vol->password, value);
1084 } else if (!strnicmp(data, "ip", 2) ||
1085 !strnicmp(data, "addr", 4)) {
1086 if (!value || !*value) {
1088 } else if (strnlen(value, INET6_ADDRSTRLEN) <
1090 vol->UNCip = kstrdup(value, GFP_KERNEL);
1092 printk(KERN_WARNING "CIFS: no memory "
1094 goto cifs_parse_mount_err;
1097 printk(KERN_WARNING "CIFS: ip address "
1099 goto cifs_parse_mount_err;
1101 } else if (strnicmp(data, "sec", 3) == 0) {
1102 if (!value || !*value) {
1103 cERROR(1, "no security value specified");
1105 } else if (strnicmp(value, "krb5i", 5) == 0) {
1106 vol->secFlg |= CIFSSEC_MAY_KRB5 |
1108 } else if (strnicmp(value, "krb5p", 5) == 0) {
1109 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
1110 CIFSSEC_MAY_KRB5; */
1111 cERROR(1, "Krb5 cifs privacy not supported");
1112 goto cifs_parse_mount_err;
1113 } else if (strnicmp(value, "krb5", 4) == 0) {
1114 vol->secFlg |= CIFSSEC_MAY_KRB5;
1115 } else if (strnicmp(value, "ntlmsspi", 8) == 0) {
1116 vol->secFlg |= CIFSSEC_MAY_NTLMSSP |
1118 } else if (strnicmp(value, "ntlmssp", 7) == 0) {
1119 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
1120 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
1121 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
1123 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
1124 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1125 } else if (strnicmp(value, "ntlmi", 5) == 0) {
1126 vol->secFlg |= CIFSSEC_MAY_NTLM |
1128 } else if (strnicmp(value, "ntlm", 4) == 0) {
1129 /* ntlm is default so can be turned off too */
1130 vol->secFlg |= CIFSSEC_MAY_NTLM;
1131 } else if (strnicmp(value, "nontlm", 6) == 0) {
1132 /* BB is there a better way to do this? */
1133 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1134 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1135 } else if (strnicmp(value, "lanman", 6) == 0) {
1136 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1138 } else if (strnicmp(value, "none", 4) == 0) {
1141 cERROR(1, "bad security option: %s", value);
1142 goto cifs_parse_mount_err;
1144 } else if (strnicmp(data, "vers", 3) == 0) {
1145 if (!value || !*value) {
1146 cERROR(1, "no protocol version specified"
1147 " after vers= mount option");
1148 } else if ((strnicmp(value, "cifs", 4) == 0) ||
1149 (strnicmp(value, "1", 1) == 0)) {
1150 /* this is the default */
1153 } else if ((strnicmp(data, "unc", 3) == 0)
1154 || (strnicmp(data, "target", 6) == 0)
1155 || (strnicmp(data, "path", 4) == 0)) {
1156 if (!value || !*value) {
1157 printk(KERN_WARNING "CIFS: invalid path to "
1158 "network resource\n");
1159 goto cifs_parse_mount_err;
1161 if ((temp_len = strnlen(value, 300)) < 300) {
1162 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1163 if (vol->UNC == NULL)
1164 goto cifs_parse_mount_err;
1165 strcpy(vol->UNC, value);
1166 if (strncmp(vol->UNC, "//", 2) == 0) {
1169 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1171 "CIFS: UNC Path does not begin "
1172 "with // or \\\\ \n");
1173 goto cifs_parse_mount_err;
1176 printk(KERN_WARNING "CIFS: UNC name too long\n");
1177 goto cifs_parse_mount_err;
1179 } else if ((strnicmp(data, "domain", 3) == 0)
1180 || (strnicmp(data, "workgroup", 5) == 0)) {
1181 if (!value || !*value) {
1182 printk(KERN_WARNING "CIFS: invalid domain name\n");
1183 goto cifs_parse_mount_err;
1185 /* BB are there cases in which a comma can be valid in
1186 a domain name and need special handling? */
1187 if (strnlen(value, 256) < 256) {
1188 vol->domainname = kstrdup(value, GFP_KERNEL);
1189 if (!vol->domainname) {
1190 printk(KERN_WARNING "CIFS: no memory "
1191 "for domainname\n");
1192 goto cifs_parse_mount_err;
1194 cFYI(1, "Domain name set");
1196 printk(KERN_WARNING "CIFS: domain name too "
1198 goto cifs_parse_mount_err;
1200 } else if (strnicmp(data, "srcaddr", 7) == 0) {
1201 vol->srcaddr.ss_family = AF_UNSPEC;
1203 if (!value || !*value) {
1204 printk(KERN_WARNING "CIFS: srcaddr value"
1205 " not specified.\n");
1206 goto cifs_parse_mount_err;
1208 i = cifs_convert_address((struct sockaddr *)&vol->srcaddr,
1209 value, strlen(value));
1211 printk(KERN_WARNING "CIFS: Could not parse"
1214 goto cifs_parse_mount_err;
1216 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1217 if (!value || !*value) {
1219 "CIFS: invalid path prefix\n");
1220 goto cifs_parse_mount_err;
1222 if ((temp_len = strnlen(value, 1024)) < 1024) {
1223 if (value[0] != '/')
1224 temp_len++; /* missing leading slash */
1225 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1226 if (vol->prepath == NULL)
1227 goto cifs_parse_mount_err;
1228 if (value[0] != '/') {
1229 vol->prepath[0] = '/';
1230 strcpy(vol->prepath+1, value);
1232 strcpy(vol->prepath, value);
1233 cFYI(1, "prefix path %s", vol->prepath);
1235 printk(KERN_WARNING "CIFS: prefix too long\n");
1236 goto cifs_parse_mount_err;
1238 } else if (strnicmp(data, "iocharset", 9) == 0) {
1239 if (!value || !*value) {
1240 printk(KERN_WARNING "CIFS: invalid iocharset "
1242 goto cifs_parse_mount_err;
1244 if (strnlen(value, 65) < 65) {
1245 if (strnicmp(value, "default", 7)) {
1246 vol->iocharset = kstrdup(value,
1249 if (!vol->iocharset) {
1250 printk(KERN_WARNING "CIFS: no "
1253 goto cifs_parse_mount_err;
1256 /* if iocharset not set then load_nls_default
1257 is used by caller */
1258 cFYI(1, "iocharset set to %s", value);
1260 printk(KERN_WARNING "CIFS: iocharset name "
1262 goto cifs_parse_mount_err;
1264 } else if (!strnicmp(data, "uid", 3) && value && *value) {
1265 vol->linux_uid = simple_strtoul(value, &value, 0);
1266 uid_specified = true;
1267 } else if (!strnicmp(data, "cruid", 5) && value && *value) {
1268 vol->cred_uid = simple_strtoul(value, &value, 0);
1269 } else if (!strnicmp(data, "forceuid", 8)) {
1271 } else if (!strnicmp(data, "noforceuid", 10)) {
1273 } else if (!strnicmp(data, "gid", 3) && value && *value) {
1274 vol->linux_gid = simple_strtoul(value, &value, 0);
1275 gid_specified = true;
1276 } else if (!strnicmp(data, "forcegid", 8)) {
1278 } else if (!strnicmp(data, "noforcegid", 10)) {
1280 } else if (strnicmp(data, "file_mode", 4) == 0) {
1281 if (value && *value) {
1283 simple_strtoul(value, &value, 0);
1285 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1286 if (value && *value) {
1288 simple_strtoul(value, &value, 0);
1290 } else if (strnicmp(data, "dirmode", 4) == 0) {
1291 if (value && *value) {
1293 simple_strtoul(value, &value, 0);
1295 } else if (strnicmp(data, "port", 4) == 0) {
1296 if (value && *value) {
1298 simple_strtoul(value, &value, 0);
1300 } else if (strnicmp(data, "rsize", 5) == 0) {
1301 if (value && *value) {
1303 simple_strtoul(value, &value, 0);
1305 } else if (strnicmp(data, "wsize", 5) == 0) {
1306 if (value && *value) {
1308 simple_strtoul(value, &value, 0);
1310 } else if (strnicmp(data, "sockopt", 5) == 0) {
1311 if (!value || !*value) {
1312 cERROR(1, "no socket option specified");
1314 } else if (strnicmp(value, "TCP_NODELAY", 11) == 0) {
1315 vol->sockopt_tcp_nodelay = 1;
1317 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1318 if (!value || !*value || (*value == ' ')) {
1319 cFYI(1, "invalid (empty) netbiosname");
1321 memset(vol->source_rfc1001_name, 0x20,
1324 * FIXME: are there cases in which a comma can
1325 * be valid in workstation netbios name (and
1326 * need special handling)?
1328 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1329 /* don't ucase netbiosname for user */
1332 vol->source_rfc1001_name[i] = value[i];
1334 /* The string has 16th byte zero still from
1335 set at top of the function */
1336 if (i == RFC1001_NAME_LEN && value[i] != 0)
1337 printk(KERN_WARNING "CIFS: netbiosname"
1338 " longer than 15 truncated.\n");
1340 } else if (strnicmp(data, "servern", 7) == 0) {
1341 /* servernetbiosname specified override *SMBSERVER */
1342 if (!value || !*value || (*value == ' ')) {
1343 cFYI(1, "empty server netbiosname specified");
1345 /* last byte, type, is 0x20 for servr type */
1346 memset(vol->target_rfc1001_name, 0x20,
1347 RFC1001_NAME_LEN_WITH_NULL);
1349 for (i = 0; i < 15; i++) {
1350 /* BB are there cases in which a comma can be
1351 valid in this workstation netbios name
1352 (and need special handling)? */
1354 /* user or mount helper must uppercase
1359 vol->target_rfc1001_name[i] =
1362 /* The string has 16th byte zero still from
1363 set at top of the function */
1364 if (i == RFC1001_NAME_LEN && value[i] != 0)
1365 printk(KERN_WARNING "CIFS: server net"
1366 "biosname longer than 15 truncated.\n");
1368 } else if (strnicmp(data, "actimeo", 7) == 0) {
1369 if (value && *value) {
1370 vol->actimeo = HZ * simple_strtoul(value,
1372 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1373 cERROR(1, "CIFS: attribute cache"
1374 "timeout too large");
1375 goto cifs_parse_mount_err;
1378 } else if (strnicmp(data, "credentials", 4) == 0) {
1380 } else if (strnicmp(data, "version", 3) == 0) {
1382 } else if (strnicmp(data, "guest", 5) == 0) {
1384 } else if (strnicmp(data, "rw", 2) == 0 && strlen(data) == 2) {
1386 } else if (strnicmp(data, "ro", 2) == 0) {
1388 } else if (strnicmp(data, "noblocksend", 11) == 0) {
1389 vol->noblocksnd = 1;
1390 } else if (strnicmp(data, "noautotune", 10) == 0) {
1391 vol->noautotune = 1;
1392 } else if ((strnicmp(data, "suid", 4) == 0) ||
1393 (strnicmp(data, "nosuid", 6) == 0) ||
1394 (strnicmp(data, "exec", 4) == 0) ||
1395 (strnicmp(data, "noexec", 6) == 0) ||
1396 (strnicmp(data, "nodev", 5) == 0) ||
1397 (strnicmp(data, "noauto", 6) == 0) ||
1398 (strnicmp(data, "dev", 3) == 0)) {
1399 /* The mount tool or mount.cifs helper (if present)
1400 uses these opts to set flags, and the flags are read
1401 by the kernel vfs layer before we get here (ie
1402 before read super) so there is no point trying to
1403 parse these options again and set anything and it
1404 is ok to just ignore them */
1406 } else if (strnicmp(data, "hard", 4) == 0) {
1408 } else if (strnicmp(data, "soft", 4) == 0) {
1410 } else if (strnicmp(data, "perm", 4) == 0) {
1412 } else if (strnicmp(data, "noperm", 6) == 0) {
1414 } else if (strnicmp(data, "mapchars", 8) == 0) {
1416 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1418 } else if (strnicmp(data, "sfu", 3) == 0) {
1420 } else if (strnicmp(data, "nosfu", 5) == 0) {
1422 } else if (strnicmp(data, "nodfs", 5) == 0) {
1424 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1425 vol->posix_paths = 1;
1426 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1427 vol->posix_paths = 0;
1428 } else if (strnicmp(data, "nounix", 6) == 0) {
1429 vol->no_linux_ext = 1;
1430 } else if (strnicmp(data, "nolinux", 7) == 0) {
1431 vol->no_linux_ext = 1;
1432 } else if ((strnicmp(data, "nocase", 6) == 0) ||
1433 (strnicmp(data, "ignorecase", 10) == 0)) {
1435 } else if (strnicmp(data, "mand", 4) == 0) {
1437 } else if (strnicmp(data, "nomand", 6) == 0) {
1439 } else if (strnicmp(data, "_netdev", 7) == 0) {
1441 } else if (strnicmp(data, "brl", 3) == 0) {
1443 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1444 (strnicmp(data, "nolock", 6) == 0)) {
1446 /* turn off mandatory locking in mode
1447 if remote locking is turned off since the
1448 local vfs will do advisory */
1449 if (vol->file_mode ==
1450 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1451 vol->file_mode = S_IALLUGO;
1452 } else if (strnicmp(data, "forcemandatorylock", 9) == 0) {
1453 /* will take the shorter form "forcemand" as well */
1454 /* This mount option will force use of mandatory
1455 (DOS/Windows style) byte range locks, instead of
1456 using posix advisory byte range locks, even if the
1457 Unix extensions are available and posix locks would
1458 be supported otherwise. If Unix extensions are not
1459 negotiated this has no effect since mandatory locks
1460 would be used (mandatory locks is all that those
1461 those servers support) */
1463 } else if (strnicmp(data, "setuids", 7) == 0) {
1465 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1467 } else if (strnicmp(data, "dynperm", 7) == 0) {
1468 vol->dynperm = true;
1469 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1470 vol->dynperm = false;
1471 } else if (strnicmp(data, "nohard", 6) == 0) {
1473 } else if (strnicmp(data, "nosoft", 6) == 0) {
1475 } else if (strnicmp(data, "nointr", 6) == 0) {
1477 } else if (strnicmp(data, "intr", 4) == 0) {
1479 } else if (strnicmp(data, "nostrictsync", 12) == 0) {
1480 vol->nostrictsync = 1;
1481 } else if (strnicmp(data, "strictsync", 10) == 0) {
1482 vol->nostrictsync = 0;
1483 } else if (strnicmp(data, "serverino", 7) == 0) {
1484 vol->server_ino = 1;
1485 } else if (strnicmp(data, "noserverino", 9) == 0) {
1486 vol->server_ino = 0;
1487 } else if (strnicmp(data, "rwpidforward", 12) == 0) {
1488 vol->rwpidforward = 1;
1489 } else if (strnicmp(data, "cifsacl", 7) == 0) {
1491 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1493 } else if (strnicmp(data, "acl", 3) == 0) {
1494 vol->no_psx_acl = 0;
1495 } else if (strnicmp(data, "noacl", 5) == 0) {
1496 vol->no_psx_acl = 1;
1497 } else if (strnicmp(data, "locallease", 6) == 0) {
1498 vol->local_lease = 1;
1499 } else if (strnicmp(data, "sign", 4) == 0) {
1500 vol->secFlg |= CIFSSEC_MUST_SIGN;
1501 } else if (strnicmp(data, "seal", 4) == 0) {
1502 /* we do not do the following in secFlags because seal
1503 is a per tree connection (mount) not a per socket
1504 or per-smb connection option in the protocol */
1505 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1507 } else if (strnicmp(data, "direct", 6) == 0) {
1509 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
1511 } else if (strnicmp(data, "strictcache", 11) == 0) {
1513 } else if (strnicmp(data, "noac", 4) == 0) {
1514 printk(KERN_WARNING "CIFS: Mount option noac not "
1515 "supported. Instead set "
1516 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1517 } else if (strnicmp(data, "fsc", 3) == 0) {
1518 #ifndef CONFIG_CIFS_FSCACHE
1519 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE "
1520 "kernel config option set");
1521 goto cifs_parse_mount_err;
1524 } else if (strnicmp(data, "mfsymlinks", 10) == 0) {
1525 vol->mfsymlinks = true;
1526 } else if (strnicmp(data, "multiuser", 8) == 0) {
1527 vol->multiuser = true;
1528 } else if (!strnicmp(data, "backupuid", 9) && value && *value) {
1529 err = kstrtouint(value, 0, &vol->backupuid);
1531 cERROR(1, "%s: Invalid backupuid value",
1533 goto cifs_parse_mount_err;
1535 vol->backupuid_specified = true;
1536 } else if (!strnicmp(data, "backupgid", 9) && value && *value) {
1537 err = kstrtouint(value, 0, &vol->backupgid);
1539 cERROR(1, "%s: Invalid backupgid value",
1541 goto cifs_parse_mount_err;
1543 vol->backupgid_specified = true;
1545 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1548 if (vol->UNC == NULL) {
1549 if (devname == NULL) {
1550 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1552 goto cifs_parse_mount_err;
1554 if ((temp_len = strnlen(devname, 300)) < 300) {
1555 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1556 if (vol->UNC == NULL)
1557 goto cifs_parse_mount_err;
1558 strcpy(vol->UNC, devname);
1559 if (strncmp(vol->UNC, "//", 2) == 0) {
1562 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1563 printk(KERN_WARNING "CIFS: UNC Path does not "
1564 "begin with // or \\\\ \n");
1565 goto cifs_parse_mount_err;
1567 value = strpbrk(vol->UNC+2, "/\\");
1571 printk(KERN_WARNING "CIFS: UNC name too long\n");
1572 goto cifs_parse_mount_err;
1576 if (vol->multiuser && !(vol->secFlg & CIFSSEC_MAY_KRB5)) {
1577 cERROR(1, "Multiuser mounts currently require krb5 "
1579 goto cifs_parse_mount_err;
1582 if (vol->UNCip == NULL)
1583 vol->UNCip = &vol->UNC[2];
1586 vol->override_uid = override_uid;
1587 else if (override_uid == 1)
1588 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1589 "specified with no uid= option.\n");
1592 vol->override_gid = override_gid;
1593 else if (override_gid == 1)
1594 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1595 "specified with no gid= option.\n");
1597 kfree(mountdata_copy);
1600 cifs_parse_mount_err:
1601 kfree(mountdata_copy);
1605 /** Returns true if srcaddr isn't specified and rhs isn't
1606 * specified, or if srcaddr is specified and
1607 * matches the IP address of the rhs argument.
1610 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1612 switch (srcaddr->sa_family) {
1614 return (rhs->sa_family == AF_UNSPEC);
1616 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1617 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1618 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1621 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1622 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1623 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1627 return false; /* don't expect to be here */
1632 * If no port is specified in addr structure, we try to match with 445 port
1633 * and if it fails - with 139 ports. It should be called only if address
1634 * families of server and addr are equal.
1637 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1639 __be16 port, *sport;
1641 switch (addr->sa_family) {
1643 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1644 port = ((struct sockaddr_in *) addr)->sin_port;
1647 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1648 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1656 port = htons(CIFS_PORT);
1660 port = htons(RFC1001_PORT);
1663 return port == *sport;
1667 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1668 struct sockaddr *srcaddr)
1670 switch (addr->sa_family) {
1672 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1673 struct sockaddr_in *srv_addr4 =
1674 (struct sockaddr_in *)&server->dstaddr;
1676 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1681 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1682 struct sockaddr_in6 *srv_addr6 =
1683 (struct sockaddr_in6 *)&server->dstaddr;
1685 if (!ipv6_addr_equal(&addr6->sin6_addr,
1686 &srv_addr6->sin6_addr))
1688 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
1694 return false; /* don't expect to be here */
1697 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1704 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
1706 unsigned int secFlags;
1708 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
1709 secFlags = vol->secFlg;
1711 secFlags = global_secflags | vol->secFlg;
1713 switch (server->secType) {
1715 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
1719 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
1723 if (!(secFlags & CIFSSEC_MAY_NTLM))
1727 if (!(secFlags & CIFSSEC_MAY_KRB5))
1731 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
1735 /* shouldn't happen */
1739 /* now check if signing mode is acceptable */
1740 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
1741 (server->sec_mode & SECMODE_SIGN_REQUIRED))
1743 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
1745 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
1751 static int match_server(struct TCP_Server_Info *server, struct sockaddr *addr,
1752 struct smb_vol *vol)
1754 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
1757 if (!match_address(server, addr,
1758 (struct sockaddr *)&vol->srcaddr))
1761 if (!match_port(server, addr))
1764 if (!match_security(server, vol))
1770 static struct TCP_Server_Info *
1771 cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
1773 struct TCP_Server_Info *server;
1775 spin_lock(&cifs_tcp_ses_lock);
1776 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
1777 if (!match_server(server, addr, vol))
1780 ++server->srv_count;
1781 spin_unlock(&cifs_tcp_ses_lock);
1782 cFYI(1, "Existing tcp session with server found");
1785 spin_unlock(&cifs_tcp_ses_lock);
1790 cifs_put_tcp_session(struct TCP_Server_Info *server)
1792 struct task_struct *task;
1794 spin_lock(&cifs_tcp_ses_lock);
1795 if (--server->srv_count > 0) {
1796 spin_unlock(&cifs_tcp_ses_lock);
1800 put_net(cifs_net_ns(server));
1802 list_del_init(&server->tcp_ses_list);
1803 spin_unlock(&cifs_tcp_ses_lock);
1805 cancel_delayed_work_sync(&server->echo);
1807 spin_lock(&GlobalMid_Lock);
1808 server->tcpStatus = CifsExiting;
1809 spin_unlock(&GlobalMid_Lock);
1811 cifs_crypto_shash_release(server);
1812 cifs_fscache_release_client_cookie(server);
1814 kfree(server->session_key.response);
1815 server->session_key.response = NULL;
1816 server->session_key.len = 0;
1818 task = xchg(&server->tsk, NULL);
1820 force_sig(SIGKILL, task);
1823 static struct TCP_Server_Info *
1824 cifs_get_tcp_session(struct smb_vol *volume_info)
1826 struct TCP_Server_Info *tcp_ses = NULL;
1827 struct sockaddr_storage addr;
1828 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
1829 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
1832 memset(&addr, 0, sizeof(struct sockaddr_storage));
1834 cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
1836 if (volume_info->UNCip && volume_info->UNC) {
1837 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
1839 strlen(volume_info->UNCip),
1842 /* we failed translating address */
1846 } else if (volume_info->UNCip) {
1847 /* BB using ip addr as tcp_ses name to connect to the
1849 cERROR(1, "Connecting to DFS root not implemented yet");
1852 } else /* which tcp_sess DFS root would we conect to */ {
1853 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
1854 "unc=//192.168.1.100/public) specified");
1859 /* see if we already have a matching tcp_ses */
1860 tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
1864 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1870 rc = cifs_crypto_shash_allocate(tcp_ses);
1872 cERROR(1, "could not setup hash structures rc %d", rc);
1876 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
1877 tcp_ses->hostname = extract_hostname(volume_info->UNC);
1878 if (IS_ERR(tcp_ses->hostname)) {
1879 rc = PTR_ERR(tcp_ses->hostname);
1880 goto out_err_crypto_release;
1883 tcp_ses->noblocksnd = volume_info->noblocksnd;
1884 tcp_ses->noautotune = volume_info->noautotune;
1885 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
1886 atomic_set(&tcp_ses->inFlight, 0);
1887 init_waitqueue_head(&tcp_ses->response_q);
1888 init_waitqueue_head(&tcp_ses->request_q);
1889 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1890 mutex_init(&tcp_ses->srv_mutex);
1891 memcpy(tcp_ses->workstation_RFC1001_name,
1892 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1893 memcpy(tcp_ses->server_RFC1001_name,
1894 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1895 tcp_ses->session_estab = false;
1896 tcp_ses->sequence_number = 0;
1897 tcp_ses->lstrp = jiffies;
1898 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1899 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1900 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
1903 * at this point we are the only ones with the pointer
1904 * to the struct since the kernel thread not created yet
1905 * no need to spinlock this init of tcpStatus or srv_count
1907 tcp_ses->tcpStatus = CifsNew;
1908 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
1909 sizeof(tcp_ses->srcaddr));
1910 ++tcp_ses->srv_count;
1912 if (addr.ss_family == AF_INET6) {
1913 cFYI(1, "attempting ipv6 connect");
1914 /* BB should we allow ipv6 on port 139? */
1915 /* other OS never observed in Wild doing 139 with v6 */
1916 memcpy(&tcp_ses->dstaddr, sin_server6,
1917 sizeof(struct sockaddr_in6));
1919 memcpy(&tcp_ses->dstaddr, sin_server,
1920 sizeof(struct sockaddr_in));
1922 rc = ip_connect(tcp_ses);
1924 cERROR(1, "Error connecting to socket. Aborting operation");
1925 goto out_err_crypto_release;
1929 * since we're in a cifs function already, we know that
1930 * this will succeed. No need for try_module_get().
1932 __module_get(THIS_MODULE);
1933 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
1935 if (IS_ERR(tcp_ses->tsk)) {
1936 rc = PTR_ERR(tcp_ses->tsk);
1937 cERROR(1, "error %d create cifsd thread", rc);
1938 module_put(THIS_MODULE);
1939 goto out_err_crypto_release;
1941 tcp_ses->tcpStatus = CifsNeedNegotiate;
1943 /* thread spawned, put it on the list */
1944 spin_lock(&cifs_tcp_ses_lock);
1945 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
1946 spin_unlock(&cifs_tcp_ses_lock);
1948 cifs_fscache_get_client_cookie(tcp_ses);
1950 /* queue echo request delayed work */
1951 queue_delayed_work(system_nrt_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
1955 out_err_crypto_release:
1956 cifs_crypto_shash_release(tcp_ses);
1958 put_net(cifs_net_ns(tcp_ses));
1962 if (!IS_ERR(tcp_ses->hostname))
1963 kfree(tcp_ses->hostname);
1964 if (tcp_ses->ssocket)
1965 sock_release(tcp_ses->ssocket);
1971 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
1973 switch (ses->server->secType) {
1975 if (vol->cred_uid != ses->cred_uid)
1979 /* anything else takes username/password */
1980 if (ses->user_name == NULL)
1982 if (strncmp(ses->user_name, vol->username,
1985 if (strlen(vol->username) != 0 &&
1986 ses->password != NULL &&
1987 strncmp(ses->password,
1988 vol->password ? vol->password : "",
1995 static struct cifs_ses *
1996 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
1998 struct cifs_ses *ses;
2000 spin_lock(&cifs_tcp_ses_lock);
2001 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2002 if (!match_session(ses, vol))
2005 spin_unlock(&cifs_tcp_ses_lock);
2008 spin_unlock(&cifs_tcp_ses_lock);
2013 cifs_put_smb_ses(struct cifs_ses *ses)
2016 struct TCP_Server_Info *server = ses->server;
2018 cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
2019 spin_lock(&cifs_tcp_ses_lock);
2020 if (--ses->ses_count > 0) {
2021 spin_unlock(&cifs_tcp_ses_lock);
2025 list_del_init(&ses->smb_ses_list);
2026 spin_unlock(&cifs_tcp_ses_lock);
2028 if (ses->status == CifsGood) {
2030 CIFSSMBLogoff(xid, ses);
2034 cifs_put_tcp_session(server);
2037 static bool warned_on_ntlm; /* globals init to false automatically */
2039 static struct cifs_ses *
2040 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2042 int rc = -ENOMEM, xid;
2043 struct cifs_ses *ses;
2044 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2045 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2049 ses = cifs_find_smb_ses(server, volume_info);
2051 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
2053 mutex_lock(&ses->session_mutex);
2054 rc = cifs_negotiate_protocol(xid, ses);
2056 mutex_unlock(&ses->session_mutex);
2057 /* problem -- put our ses reference */
2058 cifs_put_smb_ses(ses);
2062 if (ses->need_reconnect) {
2063 cFYI(1, "Session needs reconnect");
2064 rc = cifs_setup_session(xid, ses,
2065 volume_info->local_nls);
2067 mutex_unlock(&ses->session_mutex);
2068 /* problem -- put our reference */
2069 cifs_put_smb_ses(ses);
2074 mutex_unlock(&ses->session_mutex);
2076 /* existing SMB ses has a server reference already */
2077 cifs_put_tcp_session(server);
2082 cFYI(1, "Existing smb sess not found");
2083 ses = sesInfoAlloc();
2087 /* new SMB session uses our server ref */
2088 ses->server = server;
2089 if (server->dstaddr.ss_family == AF_INET6)
2090 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2092 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2094 if (volume_info->username) {
2095 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2096 if (!ses->user_name)
2100 /* volume_info->password freed at unmount */
2101 if (volume_info->password) {
2102 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2106 if (volume_info->domainname) {
2107 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2108 if (!ses->domainName)
2111 ses->cred_uid = volume_info->cred_uid;
2112 ses->linux_uid = volume_info->linux_uid;
2114 /* ntlmv2 is much stronger than ntlm security, and has been broadly
2115 supported for many years, time to update default security mechanism */
2116 if ((volume_info->secFlg == 0) && warned_on_ntlm == false) {
2117 warned_on_ntlm = true;
2118 cERROR(1, "default security mechanism requested. The default "
2119 "security mechanism will be upgraded from ntlm to "
2120 "ntlmv2 in kernel release 3.2");
2122 ses->overrideSecFlg = volume_info->secFlg;
2124 mutex_lock(&ses->session_mutex);
2125 rc = cifs_negotiate_protocol(xid, ses);
2127 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2128 mutex_unlock(&ses->session_mutex);
2132 /* success, put it on the list */
2133 spin_lock(&cifs_tcp_ses_lock);
2134 list_add(&ses->smb_ses_list, &server->smb_ses_list);
2135 spin_unlock(&cifs_tcp_ses_lock);
2146 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2148 if (tcon->tidStatus == CifsExiting)
2150 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2155 static struct cifs_tcon *
2156 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2158 struct list_head *tmp;
2159 struct cifs_tcon *tcon;
2161 spin_lock(&cifs_tcp_ses_lock);
2162 list_for_each(tmp, &ses->tcon_list) {
2163 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2164 if (!match_tcon(tcon, unc))
2167 spin_unlock(&cifs_tcp_ses_lock);
2170 spin_unlock(&cifs_tcp_ses_lock);
2175 cifs_put_tcon(struct cifs_tcon *tcon)
2178 struct cifs_ses *ses = tcon->ses;
2180 cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2181 spin_lock(&cifs_tcp_ses_lock);
2182 if (--tcon->tc_count > 0) {
2183 spin_unlock(&cifs_tcp_ses_lock);
2187 list_del_init(&tcon->tcon_list);
2188 spin_unlock(&cifs_tcp_ses_lock);
2191 CIFSSMBTDis(xid, tcon);
2194 cifs_fscache_release_super_cookie(tcon);
2196 cifs_put_smb_ses(ses);
2199 static struct cifs_tcon *
2200 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2203 struct cifs_tcon *tcon;
2205 tcon = cifs_find_tcon(ses, volume_info->UNC);
2207 cFYI(1, "Found match on UNC path");
2208 /* existing tcon already has a reference */
2209 cifs_put_smb_ses(ses);
2210 if (tcon->seal != volume_info->seal)
2211 cERROR(1, "transport encryption setting "
2212 "conflicts with existing tid");
2216 tcon = tconInfoAlloc();
2223 if (volume_info->password) {
2224 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2225 if (!tcon->password) {
2231 if (strchr(volume_info->UNC + 3, '\\') == NULL
2232 && strchr(volume_info->UNC + 3, '/') == NULL) {
2233 cERROR(1, "Missing share name");
2238 /* BB Do we need to wrap session_mutex around
2239 * this TCon call and Unix SetFS as
2240 * we do on SessSetup and reconnect? */
2242 rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
2244 cFYI(1, "CIFS Tcon rc = %d", rc);
2248 if (volume_info->nodfs) {
2249 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2250 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2252 tcon->seal = volume_info->seal;
2253 /* we can have only one retry value for a connection
2254 to a share so for resources mounted more than once
2255 to the same server share the last value passed in
2256 for the retry flag is used */
2257 tcon->retry = volume_info->retry;
2258 tcon->nocase = volume_info->nocase;
2259 tcon->local_lease = volume_info->local_lease;
2261 spin_lock(&cifs_tcp_ses_lock);
2262 list_add(&tcon->tcon_list, &ses->tcon_list);
2263 spin_unlock(&cifs_tcp_ses_lock);
2265 cifs_fscache_get_super_cookie(tcon);
2275 cifs_put_tlink(struct tcon_link *tlink)
2277 if (!tlink || IS_ERR(tlink))
2280 if (!atomic_dec_and_test(&tlink->tl_count) ||
2281 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2282 tlink->tl_time = jiffies;
2286 if (!IS_ERR(tlink_tcon(tlink)))
2287 cifs_put_tcon(tlink_tcon(tlink));
2292 static inline struct tcon_link *
2293 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2295 return cifs_sb->master_tlink;
2299 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2301 struct cifs_sb_info *old = CIFS_SB(sb);
2302 struct cifs_sb_info *new = mnt_data->cifs_sb;
2304 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2307 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2308 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2311 if (old->rsize != new->rsize)
2315 * We want to share sb only if we don't specify wsize or specified wsize
2316 * is greater or equal than existing one.
2318 if (new->wsize && new->wsize < old->wsize)
2321 if (old->mnt_uid != new->mnt_uid || old->mnt_gid != new->mnt_gid)
2324 if (old->mnt_file_mode != new->mnt_file_mode ||
2325 old->mnt_dir_mode != new->mnt_dir_mode)
2328 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2331 if (old->actimeo != new->actimeo)
2338 cifs_match_super(struct super_block *sb, void *data)
2340 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2341 struct smb_vol *volume_info;
2342 struct cifs_sb_info *cifs_sb;
2343 struct TCP_Server_Info *tcp_srv;
2344 struct cifs_ses *ses;
2345 struct cifs_tcon *tcon;
2346 struct tcon_link *tlink;
2347 struct sockaddr_storage addr;
2350 memset(&addr, 0, sizeof(struct sockaddr_storage));
2352 spin_lock(&cifs_tcp_ses_lock);
2353 cifs_sb = CIFS_SB(sb);
2354 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2355 if (IS_ERR(tlink)) {
2356 spin_unlock(&cifs_tcp_ses_lock);
2359 tcon = tlink_tcon(tlink);
2361 tcp_srv = ses->server;
2363 volume_info = mnt_data->vol;
2365 if (!volume_info->UNCip || !volume_info->UNC)
2368 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
2370 strlen(volume_info->UNCip),
2375 if (!match_server(tcp_srv, (struct sockaddr *)&addr, volume_info) ||
2376 !match_session(ses, volume_info) ||
2377 !match_tcon(tcon, volume_info->UNC)) {
2382 rc = compare_mount_options(sb, mnt_data);
2384 spin_unlock(&cifs_tcp_ses_lock);
2385 cifs_put_tlink(tlink);
2390 get_dfs_path(int xid, struct cifs_ses *pSesInfo, const char *old_path,
2391 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
2392 struct dfs_info3_param **preferrals, int remap)
2397 *pnum_referrals = 0;
2400 if (pSesInfo->ipc_tid == 0) {
2401 temp_unc = kmalloc(2 /* for slashes */ +
2402 strnlen(pSesInfo->serverName,
2403 SERVER_NAME_LEN_WITH_NULL * 2)
2404 + 1 + 4 /* slash IPC$ */ + 2,
2406 if (temp_unc == NULL)
2410 strcpy(temp_unc + 2, pSesInfo->serverName);
2411 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2412 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
2413 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
2417 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
2418 pnum_referrals, nls_codepage, remap);
2419 /* BB map targetUNCs to dfs_info3 structures, here or
2420 in CIFSGetDFSRefer BB */
2425 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2426 static struct lock_class_key cifs_key[2];
2427 static struct lock_class_key cifs_slock_key[2];
2430 cifs_reclassify_socket4(struct socket *sock)
2432 struct sock *sk = sock->sk;
2433 BUG_ON(sock_owned_by_user(sk));
2434 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2435 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2439 cifs_reclassify_socket6(struct socket *sock)
2441 struct sock *sk = sock->sk;
2442 BUG_ON(sock_owned_by_user(sk));
2443 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2444 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2448 cifs_reclassify_socket4(struct socket *sock)
2453 cifs_reclassify_socket6(struct socket *sock)
2458 /* See RFC1001 section 14 on representation of Netbios names */
2459 static void rfc1002mangle(char *target, char *source, unsigned int length)
2463 for (i = 0, j = 0; i < (length); i++) {
2464 /* mask a nibble at a time and encode */
2465 target[j] = 'A' + (0x0F & (source[i] >> 4));
2466 target[j+1] = 'A' + (0x0F & source[i]);
2473 bind_socket(struct TCP_Server_Info *server)
2476 if (server->srcaddr.ss_family != AF_UNSPEC) {
2477 /* Bind to the specified local IP address */
2478 struct socket *socket = server->ssocket;
2479 rc = socket->ops->bind(socket,
2480 (struct sockaddr *) &server->srcaddr,
2481 sizeof(server->srcaddr));
2483 struct sockaddr_in *saddr4;
2484 struct sockaddr_in6 *saddr6;
2485 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2486 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2487 if (saddr6->sin6_family == AF_INET6)
2489 "Failed to bind to: %pI6c, error: %d\n",
2490 &saddr6->sin6_addr, rc);
2493 "Failed to bind to: %pI4, error: %d\n",
2494 &saddr4->sin_addr.s_addr, rc);
2501 ip_rfc1001_connect(struct TCP_Server_Info *server)
2505 * some servers require RFC1001 sessinit before sending
2506 * negprot - BB check reconnection in case where second
2507 * sessinit is sent but no second negprot
2509 struct rfc1002_session_packet *ses_init_buf;
2510 struct smb_hdr *smb_buf;
2511 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2514 ses_init_buf->trailer.session_req.called_len = 32;
2516 if (server->server_RFC1001_name &&
2517 server->server_RFC1001_name[0] != 0)
2518 rfc1002mangle(ses_init_buf->trailer.
2519 session_req.called_name,
2520 server->server_RFC1001_name,
2521 RFC1001_NAME_LEN_WITH_NULL);
2523 rfc1002mangle(ses_init_buf->trailer.
2524 session_req.called_name,
2525 DEFAULT_CIFS_CALLED_NAME,
2526 RFC1001_NAME_LEN_WITH_NULL);
2528 ses_init_buf->trailer.session_req.calling_len = 32;
2531 * calling name ends in null (byte 16) from old smb
2534 if (server->workstation_RFC1001_name &&
2535 server->workstation_RFC1001_name[0] != 0)
2536 rfc1002mangle(ses_init_buf->trailer.
2537 session_req.calling_name,
2538 server->workstation_RFC1001_name,
2539 RFC1001_NAME_LEN_WITH_NULL);
2541 rfc1002mangle(ses_init_buf->trailer.
2542 session_req.calling_name,
2544 RFC1001_NAME_LEN_WITH_NULL);
2546 ses_init_buf->trailer.session_req.scope1 = 0;
2547 ses_init_buf->trailer.session_req.scope2 = 0;
2548 smb_buf = (struct smb_hdr *)ses_init_buf;
2550 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2551 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
2552 rc = smb_send(server, smb_buf, 0x44);
2553 kfree(ses_init_buf);
2555 * RFC1001 layer in at least one server
2556 * requires very short break before negprot
2557 * presumably because not expecting negprot
2558 * to follow so fast. This is a simple
2559 * solution that works without
2560 * complicating the code and causes no
2561 * significant slowing down on mount
2564 usleep_range(1000, 2000);
2567 * else the negprot may still work without this
2568 * even though malloc failed
2575 generic_ip_connect(struct TCP_Server_Info *server)
2580 struct socket *socket = server->ssocket;
2581 struct sockaddr *saddr;
2583 saddr = (struct sockaddr *) &server->dstaddr;
2585 if (server->dstaddr.ss_family == AF_INET6) {
2586 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2587 slen = sizeof(struct sockaddr_in6);
2590 sport = ((struct sockaddr_in *) saddr)->sin_port;
2591 slen = sizeof(struct sockaddr_in);
2595 if (socket == NULL) {
2596 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2597 IPPROTO_TCP, &socket, 1);
2599 cERROR(1, "Error %d creating socket", rc);
2600 server->ssocket = NULL;
2604 /* BB other socket options to set KEEPALIVE, NODELAY? */
2605 cFYI(1, "Socket created");
2606 server->ssocket = socket;
2607 socket->sk->sk_allocation = GFP_NOFS;
2608 if (sfamily == AF_INET6)
2609 cifs_reclassify_socket6(socket);
2611 cifs_reclassify_socket4(socket);
2614 rc = bind_socket(server);
2619 * Eventually check for other socket options to change from
2620 * the default. sock_setsockopt not used because it expects
2623 socket->sk->sk_rcvtimeo = 7 * HZ;
2624 socket->sk->sk_sndtimeo = 5 * HZ;
2626 /* make the bufsizes depend on wsize/rsize and max requests */
2627 if (server->noautotune) {
2628 if (socket->sk->sk_sndbuf < (200 * 1024))
2629 socket->sk->sk_sndbuf = 200 * 1024;
2630 if (socket->sk->sk_rcvbuf < (140 * 1024))
2631 socket->sk->sk_rcvbuf = 140 * 1024;
2634 if (server->tcp_nodelay) {
2636 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2637 (char *)&val, sizeof(val));
2639 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
2642 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
2643 socket->sk->sk_sndbuf,
2644 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
2646 rc = socket->ops->connect(socket, saddr, slen, 0);
2648 cFYI(1, "Error %d connecting to server", rc);
2649 sock_release(socket);
2650 server->ssocket = NULL;
2654 if (sport == htons(RFC1001_PORT))
2655 rc = ip_rfc1001_connect(server);
2661 ip_connect(struct TCP_Server_Info *server)
2664 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2665 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2667 if (server->dstaddr.ss_family == AF_INET6)
2668 sport = &addr6->sin6_port;
2670 sport = &addr->sin_port;
2675 /* try with 445 port at first */
2676 *sport = htons(CIFS_PORT);
2678 rc = generic_ip_connect(server);
2682 /* if it failed, try with 139 port */
2683 *sport = htons(RFC1001_PORT);
2686 return generic_ip_connect(server);
2689 void reset_cifs_unix_caps(int xid, struct cifs_tcon *tcon,
2690 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
2692 /* if we are reconnecting then should we check to see if
2693 * any requested capabilities changed locally e.g. via
2694 * remount but we can not do much about it here
2695 * if they have (even if we could detect it by the following)
2696 * Perhaps we could add a backpointer to array of sb from tcon
2697 * or if we change to make all sb to same share the same
2698 * sb as NFS - then we only have one backpointer to sb.
2699 * What if we wanted to mount the server share twice once with
2700 * and once without posixacls or posix paths? */
2701 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2703 if (vol_info && vol_info->no_linux_ext) {
2704 tcon->fsUnixInfo.Capability = 0;
2705 tcon->unix_ext = 0; /* Unix Extensions disabled */
2706 cFYI(1, "Linux protocol extensions disabled");
2708 } else if (vol_info)
2709 tcon->unix_ext = 1; /* Unix Extensions supported */
2711 if (tcon->unix_ext == 0) {
2712 cFYI(1, "Unix extensions disabled so not set on reconnect");
2716 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
2717 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2718 cFYI(1, "unix caps which server supports %lld", cap);
2719 /* check for reconnect case in which we do not
2720 want to change the mount behavior if we can avoid it */
2721 if (vol_info == NULL) {
2722 /* turn off POSIX ACL and PATHNAMES if not set
2723 originally at mount time */
2724 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2725 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2726 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2727 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2728 cERROR(1, "POSIXPATH support change");
2729 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2730 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2731 cERROR(1, "possible reconnect error");
2732 cERROR(1, "server disabled POSIX path support");
2736 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
2737 cERROR(1, "per-share encryption not supported yet");
2739 cap &= CIFS_UNIX_CAP_MASK;
2740 if (vol_info && vol_info->no_psx_acl)
2741 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2742 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
2743 cFYI(1, "negotiated posix acl support");
2745 cifs_sb->mnt_cifs_flags |=
2746 CIFS_MOUNT_POSIXACL;
2749 if (vol_info && vol_info->posix_paths == 0)
2750 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2751 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2752 cFYI(1, "negotiate posix pathnames");
2754 cifs_sb->mnt_cifs_flags |=
2755 CIFS_MOUNT_POSIX_PATHS;
2758 if (cifs_sb && (cifs_sb->rsize > 127 * 1024)) {
2759 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
2760 cifs_sb->rsize = 127 * 1024;
2761 cFYI(DBG2, "larger reads not supported by srv");
2766 cFYI(1, "Negotiate caps 0x%x", (int)cap);
2767 #ifdef CONFIG_CIFS_DEBUG2
2768 if (cap & CIFS_UNIX_FCNTL_CAP)
2769 cFYI(1, "FCNTL cap");
2770 if (cap & CIFS_UNIX_EXTATTR_CAP)
2771 cFYI(1, "EXTATTR cap");
2772 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2773 cFYI(1, "POSIX path cap");
2774 if (cap & CIFS_UNIX_XATTR_CAP)
2775 cFYI(1, "XATTR cap");
2776 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
2777 cFYI(1, "POSIX ACL cap");
2778 if (cap & CIFS_UNIX_LARGE_READ_CAP)
2779 cFYI(1, "very large read cap");
2780 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
2781 cFYI(1, "very large write cap");
2782 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
2783 cFYI(1, "transport encryption cap");
2784 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
2785 cFYI(1, "mandatory transport encryption cap");
2786 #endif /* CIFS_DEBUG2 */
2787 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
2788 if (vol_info == NULL) {
2789 cFYI(1, "resetting capabilities failed");
2791 cERROR(1, "Negotiating Unix capabilities "
2792 "with the server failed. Consider "
2793 "mounting with the Unix Extensions\n"
2794 "disabled, if problems are found, "
2795 "by specifying the nounix mount "
2802 void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
2803 struct cifs_sb_info *cifs_sb)
2805 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
2807 spin_lock_init(&cifs_sb->tlink_tree_lock);
2808 cifs_sb->tlink_tree = RB_ROOT;
2810 if (pvolume_info->rsize > CIFSMaxBufSize) {
2811 cERROR(1, "rsize %d too large, using MaxBufSize",
2812 pvolume_info->rsize);
2813 cifs_sb->rsize = CIFSMaxBufSize;
2814 } else if ((pvolume_info->rsize) &&
2815 (pvolume_info->rsize <= CIFSMaxBufSize))
2816 cifs_sb->rsize = pvolume_info->rsize;
2818 cifs_sb->rsize = CIFSMaxBufSize;
2820 if (cifs_sb->rsize < 2048) {
2821 cifs_sb->rsize = 2048;
2822 /* Windows ME may prefer this */
2823 cFYI(1, "readsize set to minimum: 2048");
2827 * Temporarily set wsize for matching superblock. If we end up using
2828 * new sb then cifs_negotiate_wsize will later negotiate it downward
2831 cifs_sb->wsize = pvolume_info->wsize;
2833 cifs_sb->mnt_uid = pvolume_info->linux_uid;
2834 cifs_sb->mnt_gid = pvolume_info->linux_gid;
2835 if (pvolume_info->backupuid_specified)
2836 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
2837 if (pvolume_info->backupgid_specified)
2838 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
2839 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2840 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
2841 cFYI(1, "file mode: 0x%x dir mode: 0x%x",
2842 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
2844 cifs_sb->actimeo = pvolume_info->actimeo;
2845 cifs_sb->local_nls = pvolume_info->local_nls;
2847 if (pvolume_info->noperm)
2848 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2849 if (pvolume_info->setuids)
2850 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2851 if (pvolume_info->server_ino)
2852 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2853 if (pvolume_info->remap)
2854 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2855 if (pvolume_info->no_xattr)
2856 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2857 if (pvolume_info->sfu_emul)
2858 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2859 if (pvolume_info->nobrl)
2860 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2861 if (pvolume_info->nostrictsync)
2862 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
2863 if (pvolume_info->mand_lock)
2864 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
2865 if (pvolume_info->rwpidforward)
2866 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
2867 if (pvolume_info->cifs_acl)
2868 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2869 if (pvolume_info->backupuid_specified)
2870 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
2871 if (pvolume_info->backupgid_specified)
2872 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
2873 if (pvolume_info->override_uid)
2874 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2875 if (pvolume_info->override_gid)
2876 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2877 if (pvolume_info->dynperm)
2878 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2879 if (pvolume_info->fsc)
2880 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
2881 if (pvolume_info->multiuser)
2882 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
2883 CIFS_MOUNT_NO_PERM);
2884 if (pvolume_info->strict_io)
2885 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
2886 if (pvolume_info->direct_io) {
2887 cFYI(1, "mounting share using direct i/o");
2888 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2890 if (pvolume_info->mfsymlinks) {
2891 if (pvolume_info->sfu_emul) {
2892 cERROR(1, "mount option mfsymlinks ignored if sfu "
2893 "mount option is used");
2895 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
2899 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
2900 cERROR(1, "mount option dynperm ignored if cifsacl "
2901 "mount option supported");
2905 * When the server supports very large writes via POSIX extensions, we can
2906 * allow up to 2^24-1, minus the size of a WRITE_AND_X header, not including
2907 * the RFC1001 length.
2909 * Note that this might make for "interesting" allocation problems during
2910 * writeback however as we have to allocate an array of pointers for the
2911 * pages. A 16M write means ~32kb page array with PAGE_CACHE_SIZE == 4096.
2913 #define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
2916 * When the server doesn't allow large posix writes, only allow a wsize of
2917 * 2^17-1 minus the size of the WRITE_AND_X header. That allows for a write up
2918 * to the maximum size described by RFC1002.
2920 #define CIFS_MAX_RFC1002_WSIZE ((1<<17) - 1 - sizeof(WRITE_REQ) + 4)
2923 * The default wsize is 1M. find_get_pages seems to return a maximum of 256
2924 * pages in a single call. With PAGE_CACHE_SIZE == 4k, this means we can fill
2925 * a single wsize request with a single call.
2927 #define CIFS_DEFAULT_WSIZE (1024 * 1024)
2930 cifs_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
2932 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2933 struct TCP_Server_Info *server = tcon->ses->server;
2934 unsigned int wsize = pvolume_info->wsize ? pvolume_info->wsize :
2937 /* can server support 24-bit write sizes? (via UNIX extensions) */
2938 if (!tcon->unix_ext || !(unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
2939 wsize = min_t(unsigned int, wsize, CIFS_MAX_RFC1002_WSIZE);
2942 * no CAP_LARGE_WRITE_X or is signing enabled without CAP_UNIX set?
2943 * Limit it to max buffer offered by the server, minus the size of the
2944 * WRITEX header, not including the 4 byte RFC1001 length.
2946 if (!(server->capabilities & CAP_LARGE_WRITE_X) ||
2947 (!(server->capabilities & CAP_UNIX) &&
2948 (server->sec_mode & (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED))))
2949 wsize = min_t(unsigned int, wsize,
2950 server->maxBuf - sizeof(WRITE_REQ) + 4);
2952 /* hard limit of CIFS_MAX_WSIZE */
2953 wsize = min_t(unsigned int, wsize, CIFS_MAX_WSIZE);
2959 is_path_accessible(int xid, struct cifs_tcon *tcon,
2960 struct cifs_sb_info *cifs_sb, const char *full_path)
2963 FILE_ALL_INFO *pfile_info;
2965 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
2966 if (pfile_info == NULL)
2969 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
2970 0 /* not legacy */, cifs_sb->local_nls,
2971 cifs_sb->mnt_cifs_flags &
2972 CIFS_MOUNT_MAP_SPECIAL_CHR);
2974 if (rc == -EOPNOTSUPP || rc == -EINVAL)
2975 rc = SMBQueryInformation(xid, tcon, full_path, pfile_info,
2976 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
2977 CIFS_MOUNT_MAP_SPECIAL_CHR);
2983 cleanup_volume_info_contents(struct smb_vol *volume_info)
2985 kfree(volume_info->username);
2986 kzfree(volume_info->password);
2987 kfree(volume_info->UNC);
2988 if (volume_info->UNCip != volume_info->UNC + 2)
2989 kfree(volume_info->UNCip);
2990 kfree(volume_info->domainname);
2991 kfree(volume_info->iocharset);
2992 kfree(volume_info->prepath);
2996 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3000 cleanup_volume_info_contents(volume_info);
3005 #ifdef CONFIG_CIFS_DFS_UPCALL
3006 /* build_path_to_root returns full path to root when
3007 * we do not have an exiting connection (tcon) */
3009 build_unc_path_to_root(const struct smb_vol *vol,
3010 const struct cifs_sb_info *cifs_sb)
3012 char *full_path, *pos;
3013 unsigned int pplen = vol->prepath ? strlen(vol->prepath) : 0;
3014 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3016 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3017 if (full_path == NULL)
3018 return ERR_PTR(-ENOMEM);
3020 strncpy(full_path, vol->UNC, unc_len);
3021 pos = full_path + unc_len;
3024 strncpy(pos, vol->prepath, pplen);
3028 *pos = '\0'; /* add trailing null */
3029 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3030 cFYI(1, "%s: full_path=%s", __func__, full_path);
3035 * Perform a dfs referral query for a share and (optionally) prefix
3037 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3038 * to a string containing updated options for the submount. Otherwise it
3039 * will be left untouched.
3041 * Returns the rc from get_dfs_path to the caller, which can be used to
3042 * determine whether there were referrals.
3045 expand_dfs_referral(int xid, struct cifs_ses *pSesInfo,
3046 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3050 unsigned int num_referrals = 0;
3051 struct dfs_info3_param *referrals = NULL;
3052 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3054 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3055 if (IS_ERR(full_path))
3056 return PTR_ERR(full_path);
3058 /* For DFS paths, skip the first '\' of the UNC */
3059 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3061 rc = get_dfs_path(xid, pSesInfo , ref_path, cifs_sb->local_nls,
3062 &num_referrals, &referrals,
3063 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
3065 if (!rc && num_referrals > 0) {
3066 char *fake_devname = NULL;
3068 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3069 full_path + 1, referrals,
3072 free_dfs_info_array(referrals, num_referrals);
3074 if (IS_ERR(mdata)) {
3075 rc = PTR_ERR(mdata);
3078 cleanup_volume_info_contents(volume_info);
3079 memset(volume_info, '\0', sizeof(*volume_info));
3080 rc = cifs_setup_volume_info(volume_info, mdata,
3083 kfree(fake_devname);
3084 kfree(cifs_sb->mountdata);
3085 cifs_sb->mountdata = mdata;
3093 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3094 const char *devname)
3098 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3101 if (volume_info->nullauth) {
3102 cFYI(1, "null user");
3103 volume_info->username = kzalloc(1, GFP_KERNEL);
3104 if (volume_info->username == NULL)
3106 } else if (volume_info->username) {
3107 /* BB fixme parse for domain name here */
3108 cFYI(1, "Username: %s", volume_info->username);
3110 cifserror("No username specified");
3111 /* In userspace mount helper we can get user name from alternate
3112 locations such as env variables and files on disk */
3116 /* this is needed for ASCII cp to Unicode converts */
3117 if (volume_info->iocharset == NULL) {
3118 /* load_nls_default cannot return null */
3119 volume_info->local_nls = load_nls_default();
3121 volume_info->local_nls = load_nls(volume_info->iocharset);
3122 if (volume_info->local_nls == NULL) {
3123 cERROR(1, "CIFS mount error: iocharset %s not found",
3124 volume_info->iocharset);
3133 cifs_get_volume_info(char *mount_data, const char *devname)
3136 struct smb_vol *volume_info;
3138 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
3140 return ERR_PTR(-ENOMEM);
3142 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3144 cifs_cleanup_volume_info(volume_info);
3145 volume_info = ERR_PTR(rc);
3152 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3156 struct cifs_ses *pSesInfo;
3157 struct cifs_tcon *tcon;
3158 struct TCP_Server_Info *srvTcp;
3160 struct tcon_link *tlink;
3161 #ifdef CONFIG_CIFS_DFS_UPCALL
3162 int referral_walks_count = 0;
3165 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3169 cifs_sb->bdi.ra_pages = default_backing_dev_info.ra_pages;
3171 #ifdef CONFIG_CIFS_DFS_UPCALL
3173 /* cleanup activities if we're chasing a referral */
3174 if (referral_walks_count) {
3176 cifs_put_tcon(tcon);
3178 cifs_put_smb_ses(pSesInfo);
3191 /* get a reference to a tcp session */
3192 srvTcp = cifs_get_tcp_session(volume_info);
3193 if (IS_ERR(srvTcp)) {
3194 rc = PTR_ERR(srvTcp);
3195 bdi_destroy(&cifs_sb->bdi);
3199 /* get a reference to a SMB session */
3200 pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
3201 if (IS_ERR(pSesInfo)) {
3202 rc = PTR_ERR(pSesInfo);
3204 goto mount_fail_check;
3207 /* search for existing tcon to this server share */
3208 tcon = cifs_get_tcon(pSesInfo, volume_info);
3212 goto remote_path_check;
3215 /* tell server which Unix caps we support */
3216 if (tcon->ses->capabilities & CAP_UNIX) {
3217 /* reset of caps checks mount to see if unix extensions
3218 disabled for just this mount */
3219 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3220 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3221 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3222 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3224 goto mount_fail_check;
3227 tcon->unix_ext = 0; /* server does not support them */
3229 /* do not care if following two calls succeed - informational */
3231 CIFSSMBQFSDeviceInfo(xid, tcon);
3232 CIFSSMBQFSAttributeInfo(xid, tcon);
3235 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
3236 cifs_sb->rsize = 1024 * 127;
3237 cFYI(DBG2, "no very large read support, rsize now 127K");
3239 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
3240 cifs_sb->rsize = min(cifs_sb->rsize, CIFSMaxBufSize);
3242 cifs_sb->wsize = cifs_negotiate_wsize(tcon, volume_info);
3245 #ifdef CONFIG_CIFS_DFS_UPCALL
3247 * Perform an unconditional check for whether there are DFS
3248 * referrals for this path without prefix, to provide support
3249 * for DFS referrals from w2k8 servers which don't seem to respond
3250 * with PATH_NOT_COVERED to requests that include the prefix.
3251 * Chase the referral if found, otherwise continue normally.
3253 if (referral_walks_count == 0) {
3254 int refrc = expand_dfs_referral(xid, pSesInfo, volume_info,
3257 referral_walks_count++;
3258 goto try_mount_again;
3263 /* check if a whole path is not remote */
3265 /* build_path_to_root works only when we have a valid tcon */
3266 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3267 if (full_path == NULL) {
3269 goto mount_fail_check;
3271 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
3272 if (rc != 0 && rc != -EREMOTE) {
3274 goto mount_fail_check;
3279 /* get referral if needed */
3280 if (rc == -EREMOTE) {
3281 #ifdef CONFIG_CIFS_DFS_UPCALL
3282 if (referral_walks_count > MAX_NESTED_LINKS) {
3284 * BB: when we implement proper loop detection,
3285 * we will remove this check. But now we need it
3286 * to prevent an indefinite loop if 'DFS tree' is
3287 * misconfigured (i.e. has loops).
3290 goto mount_fail_check;
3293 rc = expand_dfs_referral(xid, pSesInfo, volume_info, cifs_sb,
3297 referral_walks_count++;
3298 goto try_mount_again;
3300 goto mount_fail_check;
3301 #else /* No DFS support, return error on mount */
3307 goto mount_fail_check;
3309 /* now, hang the tcon off of the superblock */
3310 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3311 if (tlink == NULL) {
3313 goto mount_fail_check;
3316 tlink->tl_uid = pSesInfo->linux_uid;
3317 tlink->tl_tcon = tcon;
3318 tlink->tl_time = jiffies;
3319 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3320 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3322 cifs_sb->master_tlink = tlink;
3323 spin_lock(&cifs_sb->tlink_tree_lock);
3324 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3325 spin_unlock(&cifs_sb->tlink_tree_lock);
3327 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
3331 /* on error free sesinfo and tcon struct if needed */
3333 /* If find_unc succeeded then rc == 0 so we can not end */
3334 /* up accidentally freeing someone elses tcon struct */
3336 cifs_put_tcon(tcon);
3338 cifs_put_smb_ses(pSesInfo);
3340 cifs_put_tcp_session(srvTcp);
3341 bdi_destroy(&cifs_sb->bdi);
3350 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3351 * pointer may be NULL.
3354 CIFSTCon(unsigned int xid, struct cifs_ses *ses,
3355 const char *tree, struct cifs_tcon *tcon,
3356 const struct nls_table *nls_codepage)
3358 struct smb_hdr *smb_buffer;
3359 struct smb_hdr *smb_buffer_response;
3362 unsigned char *bcc_ptr;
3365 __u16 bytes_left, count;
3370 smb_buffer = cifs_buf_get();
3371 if (smb_buffer == NULL)
3374 smb_buffer_response = smb_buffer;
3376 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3377 NULL /*no tid */ , 4 /*wct */ );
3379 smb_buffer->Mid = GetNextMid(ses->server);
3380 smb_buffer->Uid = ses->Suid;
3381 pSMB = (TCONX_REQ *) smb_buffer;
3382 pSMBr = (TCONX_RSP *) smb_buffer_response;
3384 pSMB->AndXCommand = 0xFF;
3385 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3386 bcc_ptr = &pSMB->Password[0];
3387 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3388 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3389 *bcc_ptr = 0; /* password is null byte */
3390 bcc_ptr++; /* skip password */
3391 /* already aligned so no need to do it below */
3393 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3394 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3395 specified as required (when that support is added to
3396 the vfs in the future) as only NTLM or the much
3397 weaker LANMAN (which we do not send by default) is accepted
3398 by Samba (not sure whether other servers allow
3399 NTLMv2 password here) */
3400 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3401 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3402 (ses->server->secType == LANMAN))
3403 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3404 ses->server->sec_mode &
3405 SECMODE_PW_ENCRYPT ? true : false,
3408 #endif /* CIFS_WEAK_PW_HASH */
3409 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3412 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3413 if (ses->capabilities & CAP_UNICODE) {
3414 /* must align unicode strings */
3415 *bcc_ptr = 0; /* null byte password */
3420 if (ses->server->sec_mode &
3421 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3422 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3424 if (ses->capabilities & CAP_STATUS32) {
3425 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3427 if (ses->capabilities & CAP_DFS) {
3428 smb_buffer->Flags2 |= SMBFLG2_DFS;
3430 if (ses->capabilities & CAP_UNICODE) {
3431 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3433 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3434 6 /* max utf8 char length in bytes */ *
3435 (/* server len*/ + 256 /* share len */), nls_codepage);
3436 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3437 bcc_ptr += 2; /* skip trailing null */
3438 } else { /* ASCII */
3439 strcpy(bcc_ptr, tree);
3440 bcc_ptr += strlen(tree) + 1;
3442 strcpy(bcc_ptr, "?????");
3443 bcc_ptr += strlen("?????");
3445 count = bcc_ptr - &pSMB->Password[0];
3446 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3447 pSMB->hdr.smb_buf_length) + count);
3448 pSMB->ByteCount = cpu_to_le16(count);
3450 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3453 /* above now done in SendReceive */
3454 if ((rc == 0) && (tcon != NULL)) {
3457 tcon->tidStatus = CifsGood;
3458 tcon->need_reconnect = false;
3459 tcon->tid = smb_buffer_response->Tid;
3460 bcc_ptr = pByteArea(smb_buffer_response);
3461 bytes_left = get_bcc(smb_buffer_response);
3462 length = strnlen(bcc_ptr, bytes_left - 2);
3463 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3469 /* skip service field (NB: this field is always ASCII) */
3471 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3472 (bcc_ptr[2] == 'C')) {
3473 cFYI(1, "IPC connection");
3476 } else if (length == 2) {
3477 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3478 /* the most common case */
3479 cFYI(1, "disk share connection");
3482 bcc_ptr += length + 1;
3483 bytes_left -= (length + 1);
3484 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3486 /* mostly informational -- no need to fail on error here */
3487 kfree(tcon->nativeFileSystem);
3488 tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
3489 bytes_left, is_unicode,
3492 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
3494 if ((smb_buffer_response->WordCount == 3) ||
3495 (smb_buffer_response->WordCount == 7))
3496 /* field is in same location */
3497 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3500 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
3501 } else if ((rc == 0) && tcon == NULL) {
3502 /* all we need to save for IPC$ connection */
3503 ses->ipc_tid = smb_buffer_response->Tid;
3506 cifs_buf_release(smb_buffer);
3511 cifs_umount(struct cifs_sb_info *cifs_sb)
3513 struct rb_root *root = &cifs_sb->tlink_tree;
3514 struct rb_node *node;
3515 struct tcon_link *tlink;
3517 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3519 spin_lock(&cifs_sb->tlink_tree_lock);
3520 while ((node = rb_first(root))) {
3521 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3522 cifs_get_tlink(tlink);
3523 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3524 rb_erase(node, root);
3526 spin_unlock(&cifs_sb->tlink_tree_lock);
3527 cifs_put_tlink(tlink);
3528 spin_lock(&cifs_sb->tlink_tree_lock);
3530 spin_unlock(&cifs_sb->tlink_tree_lock);
3532 bdi_destroy(&cifs_sb->bdi);
3533 kfree(cifs_sb->mountdata);
3534 unload_nls(cifs_sb->local_nls);
3538 int cifs_negotiate_protocol(unsigned int xid, struct cifs_ses *ses)
3541 struct TCP_Server_Info *server = ses->server;
3543 /* only send once per connect */
3544 if (server->maxBuf != 0)
3547 rc = CIFSSMBNegotiate(xid, ses);
3548 if (rc == -EAGAIN) {
3549 /* retry only once on 1st time connection */
3550 rc = CIFSSMBNegotiate(xid, ses);
3555 spin_lock(&GlobalMid_Lock);
3556 if (server->tcpStatus == CifsNeedNegotiate)
3557 server->tcpStatus = CifsGood;
3560 spin_unlock(&GlobalMid_Lock);
3568 int cifs_setup_session(unsigned int xid, struct cifs_ses *ses,
3569 struct nls_table *nls_info)
3572 struct TCP_Server_Info *server = ses->server;
3575 ses->capabilities = server->capabilities;
3576 if (linuxExtEnabled == 0)
3577 ses->capabilities &= (~CAP_UNIX);
3579 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3580 server->sec_mode, server->capabilities, server->timeAdj);
3582 rc = CIFS_SessSetup(xid, ses, nls_info);
3584 cERROR(1, "Send error in SessSetup = %d", rc);
3586 mutex_lock(&ses->server->srv_mutex);
3587 if (!server->session_estab) {
3588 server->session_key.response = ses->auth_key.response;
3589 server->session_key.len = ses->auth_key.len;
3590 server->sequence_number = 0x2;
3591 server->session_estab = true;
3592 ses->auth_key.response = NULL;
3594 mutex_unlock(&server->srv_mutex);
3596 cFYI(1, "CIFS Session Established successfully");
3597 spin_lock(&GlobalMid_Lock);
3598 ses->status = CifsGood;
3599 ses->need_reconnect = false;
3600 spin_unlock(&GlobalMid_Lock);
3603 kfree(ses->auth_key.response);
3604 ses->auth_key.response = NULL;
3605 ses->auth_key.len = 0;
3606 kfree(ses->ntlmssp);
3607 ses->ntlmssp = NULL;
3612 static struct cifs_tcon *
3613 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
3615 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3616 struct cifs_ses *ses;
3617 struct cifs_tcon *tcon = NULL;
3618 struct smb_vol *vol_info;
3619 char username[28]; /* big enough for "krb50x" + hex of ULONG_MAX 6+16 */
3620 /* We used to have this as MAX_USERNAME which is */
3621 /* way too big now (256 instead of 32) */
3623 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3624 if (vol_info == NULL) {
3625 tcon = ERR_PTR(-ENOMEM);
3629 snprintf(username, sizeof(username), "krb50x%x", fsuid);
3630 vol_info->username = username;
3631 vol_info->local_nls = cifs_sb->local_nls;
3632 vol_info->linux_uid = fsuid;
3633 vol_info->cred_uid = fsuid;
3634 vol_info->UNC = master_tcon->treeName;
3635 vol_info->retry = master_tcon->retry;
3636 vol_info->nocase = master_tcon->nocase;
3637 vol_info->local_lease = master_tcon->local_lease;
3638 vol_info->no_linux_ext = !master_tcon->unix_ext;
3640 /* FIXME: allow for other secFlg settings */
3641 vol_info->secFlg = CIFSSEC_MUST_KRB5;
3643 /* get a reference for the same TCP session */
3644 spin_lock(&cifs_tcp_ses_lock);
3645 ++master_tcon->ses->server->srv_count;
3646 spin_unlock(&cifs_tcp_ses_lock);
3648 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3650 tcon = (struct cifs_tcon *)ses;
3651 cifs_put_tcp_session(master_tcon->ses->server);
3655 tcon = cifs_get_tcon(ses, vol_info);
3657 cifs_put_smb_ses(ses);
3661 if (ses->capabilities & CAP_UNIX)
3662 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3670 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3672 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3676 cifs_sb_tcon_pending_wait(void *unused)
3679 return signal_pending(current) ? -ERESTARTSYS : 0;
3682 /* find and return a tlink with given uid */
3683 static struct tcon_link *
3684 tlink_rb_search(struct rb_root *root, uid_t uid)
3686 struct rb_node *node = root->rb_node;
3687 struct tcon_link *tlink;
3690 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3692 if (tlink->tl_uid > uid)
3693 node = node->rb_left;
3694 else if (tlink->tl_uid < uid)
3695 node = node->rb_right;
3702 /* insert a tcon_link into the tree */
3704 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3706 struct rb_node **new = &(root->rb_node), *parent = NULL;
3707 struct tcon_link *tlink;
3710 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3713 if (tlink->tl_uid > new_tlink->tl_uid)
3714 new = &((*new)->rb_left);
3716 new = &((*new)->rb_right);
3719 rb_link_node(&new_tlink->tl_rbnode, parent, new);
3720 rb_insert_color(&new_tlink->tl_rbnode, root);
3724 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3727 * If the superblock doesn't refer to a multiuser mount, then just return
3728 * the master tcon for the mount.
3730 * First, search the rbtree for an existing tcon for this fsuid. If one
3731 * exists, then check to see if it's pending construction. If it is then wait
3732 * for construction to complete. Once it's no longer pending, check to see if
3733 * it failed and either return an error or retry construction, depending on
3736 * If one doesn't exist then insert a new tcon_link struct into the tree and
3737 * try to construct a new one.
3740 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
3743 uid_t fsuid = current_fsuid();
3744 struct tcon_link *tlink, *newtlink;
3746 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
3747 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3749 spin_lock(&cifs_sb->tlink_tree_lock);
3750 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3752 cifs_get_tlink(tlink);
3753 spin_unlock(&cifs_sb->tlink_tree_lock);
3755 if (tlink == NULL) {
3756 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
3757 if (newtlink == NULL)
3758 return ERR_PTR(-ENOMEM);
3759 newtlink->tl_uid = fsuid;
3760 newtlink->tl_tcon = ERR_PTR(-EACCES);
3761 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
3762 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
3763 cifs_get_tlink(newtlink);
3765 spin_lock(&cifs_sb->tlink_tree_lock);
3766 /* was one inserted after previous search? */
3767 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3769 cifs_get_tlink(tlink);
3770 spin_unlock(&cifs_sb->tlink_tree_lock);
3772 goto wait_for_construction;
3775 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3776 spin_unlock(&cifs_sb->tlink_tree_lock);
3778 wait_for_construction:
3779 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
3780 cifs_sb_tcon_pending_wait,
3781 TASK_INTERRUPTIBLE);
3783 cifs_put_tlink(tlink);
3784 return ERR_PTR(ret);
3787 /* if it's good, return it */
3788 if (!IS_ERR(tlink->tl_tcon))
3791 /* return error if we tried this already recently */
3792 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
3793 cifs_put_tlink(tlink);
3794 return ERR_PTR(-EACCES);
3797 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
3798 goto wait_for_construction;
3801 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
3802 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
3803 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
3805 if (IS_ERR(tlink->tl_tcon)) {
3806 cifs_put_tlink(tlink);
3807 return ERR_PTR(-EACCES);
3814 * periodic workqueue job that scans tcon_tree for a superblock and closes
3818 cifs_prune_tlinks(struct work_struct *work)
3820 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
3822 struct rb_root *root = &cifs_sb->tlink_tree;
3823 struct rb_node *node = rb_first(root);
3824 struct rb_node *tmp;
3825 struct tcon_link *tlink;
3828 * Because we drop the spinlock in the loop in order to put the tlink
3829 * it's not guarded against removal of links from the tree. The only
3830 * places that remove entries from the tree are this function and
3831 * umounts. Because this function is non-reentrant and is canceled
3832 * before umount can proceed, this is safe.
3834 spin_lock(&cifs_sb->tlink_tree_lock);
3835 node = rb_first(root);
3836 while (node != NULL) {
3838 node = rb_next(tmp);
3839 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
3841 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
3842 atomic_read(&tlink->tl_count) != 0 ||
3843 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
3846 cifs_get_tlink(tlink);
3847 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3848 rb_erase(tmp, root);
3850 spin_unlock(&cifs_sb->tlink_tree_lock);
3851 cifs_put_tlink(tlink);
3852 spin_lock(&cifs_sb->tlink_tree_lock);
3854 spin_unlock(&cifs_sb->tlink_tree_lock);
3856 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,