4 * Copyright (C) International Business Machines Corp., 2002,2009
5 * Author(s): Steve French (sfrench@us.ibm.com)
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/net.h>
23 #include <linux/string.h>
24 #include <linux/list.h>
25 #include <linux/wait.h>
26 #include <linux/slab.h>
27 #include <linux/pagemap.h>
28 #include <linux/ctype.h>
29 #include <linux/utsname.h>
30 #include <linux/mempool.h>
31 #include <linux/delay.h>
32 #include <linux/completion.h>
33 #include <linux/kthread.h>
34 #include <linux/pagevec.h>
35 #include <linux/freezer.h>
36 #include <linux/namei.h>
37 #include <asm/uaccess.h>
38 #include <asm/processor.h>
39 #include <linux/inet.h>
43 #include "cifsproto.h"
44 #include "cifs_unicode.h"
45 #include "cifs_debug.h"
46 #include "cifs_fs_sb.h"
49 #include "rfc1002pdu.h"
53 #define RFC1001_PORT 139
55 /* SMB echo "timeout" -- FIXME: tunable? */
56 #define SMB_ECHO_INTERVAL (60 * HZ)
58 extern mempool_t *cifs_req_poolp;
60 /* FIXME: should these be tunable? */
61 #define TLINK_ERROR_EXPIRE (1 * HZ)
62 #define TLINK_IDLE_EXPIRE (600 * HZ)
64 static int ip_connect(struct TCP_Server_Info *server);
65 static int generic_ip_connect(struct TCP_Server_Info *server);
66 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
67 static void cifs_prune_tlinks(struct work_struct *work);
68 static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
72 * cifs tcp session reconnection
74 * mark tcp session as reconnecting so temporarily locked
75 * mark all smb sessions as reconnecting for tcp session
76 * reconnect tcp session
77 * wake up waiters on reconnection? - (not needed currently)
80 cifs_reconnect(struct TCP_Server_Info *server)
83 struct list_head *tmp, *tmp2;
85 struct cifs_tcon *tcon;
86 struct mid_q_entry *mid_entry;
87 struct list_head retry_list;
89 spin_lock(&GlobalMid_Lock);
90 if (server->tcpStatus == CifsExiting) {
91 /* the demux thread will exit normally
92 next time through the loop */
93 spin_unlock(&GlobalMid_Lock);
96 server->tcpStatus = CifsNeedReconnect;
97 spin_unlock(&GlobalMid_Lock);
100 cFYI(1, "Reconnecting tcp session");
102 /* before reconnecting the tcp session, mark the smb session (uid)
103 and the tid bad so they are not used until reconnected */
104 cFYI(1, "%s: marking sessions and tcons for reconnect", __func__);
105 spin_lock(&cifs_tcp_ses_lock);
106 list_for_each(tmp, &server->smb_ses_list) {
107 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
108 ses->need_reconnect = true;
110 list_for_each(tmp2, &ses->tcon_list) {
111 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
112 tcon->need_reconnect = true;
115 spin_unlock(&cifs_tcp_ses_lock);
117 /* do not want to be sending data on a socket we are freeing */
118 cFYI(1, "%s: tearing down socket", __func__);
119 mutex_lock(&server->srv_mutex);
120 if (server->ssocket) {
121 cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
122 server->ssocket->flags);
123 kernel_sock_shutdown(server->ssocket, SHUT_WR);
124 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
125 server->ssocket->state,
126 server->ssocket->flags);
127 sock_release(server->ssocket);
128 server->ssocket = NULL;
130 server->sequence_number = 0;
131 server->session_estab = false;
132 kfree(server->session_key.response);
133 server->session_key.response = NULL;
134 server->session_key.len = 0;
135 server->lstrp = jiffies;
136 mutex_unlock(&server->srv_mutex);
138 /* mark submitted MIDs for retry and issue callback */
139 INIT_LIST_HEAD(&retry_list);
140 cFYI(1, "%s: moving mids to private list", __func__);
141 spin_lock(&GlobalMid_Lock);
142 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
143 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
144 if (mid_entry->midState == MID_REQUEST_SUBMITTED)
145 mid_entry->midState = MID_RETRY_NEEDED;
146 list_move(&mid_entry->qhead, &retry_list);
148 spin_unlock(&GlobalMid_Lock);
150 cFYI(1, "%s: issuing mid callbacks", __func__);
151 list_for_each_safe(tmp, tmp2, &retry_list) {
152 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
153 list_del_init(&mid_entry->qhead);
154 mid_entry->callback(mid_entry);
160 /* we should try only the port we connected to before */
161 rc = generic_ip_connect(server);
163 cFYI(1, "reconnect error %d", rc);
166 atomic_inc(&tcpSesReconnectCount);
167 spin_lock(&GlobalMid_Lock);
168 if (server->tcpStatus != CifsExiting)
169 server->tcpStatus = CifsNeedNegotiate;
170 spin_unlock(&GlobalMid_Lock);
172 } while (server->tcpStatus == CifsNeedReconnect);
179 0 not a transact2, or all data present
180 >0 transact2 with that much data missing
181 -EINVAL = invalid transact2
184 static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
186 struct smb_t2_rsp *pSMBt;
188 __u16 total_data_size, data_in_this_rsp;
190 if (pSMB->Command != SMB_COM_TRANSACTION2)
193 /* check for plausible wct, bcc and t2 data and parm sizes */
194 /* check for parm and data offset going beyond end of smb */
195 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
196 cFYI(1, "invalid transact2 word count");
200 pSMBt = (struct smb_t2_rsp *)pSMB;
202 total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
203 data_in_this_rsp = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
205 if (total_data_size == data_in_this_rsp)
207 else if (total_data_size < data_in_this_rsp) {
208 cFYI(1, "total data %d smaller than data in frame %d",
209 total_data_size, data_in_this_rsp);
213 remaining = total_data_size - data_in_this_rsp;
215 cFYI(1, "missing %d bytes from transact2, check next response",
217 if (total_data_size > maxBufSize) {
218 cERROR(1, "TotalDataSize %d is over maximum buffer %d",
219 total_data_size, maxBufSize);
225 static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
227 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
228 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
229 char *data_area_of_target;
230 char *data_area_of_buf2;
232 unsigned int byte_count, total_in_buf;
233 __u16 total_data_size, total_in_buf2;
235 total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
237 if (total_data_size !=
238 get_unaligned_le16(&pSMB2->t2_rsp.TotalDataCount))
239 cFYI(1, "total data size of primary and secondary t2 differ");
241 total_in_buf = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
243 remaining = total_data_size - total_in_buf;
248 if (remaining == 0) /* nothing to do, ignore */
251 total_in_buf2 = get_unaligned_le16(&pSMB2->t2_rsp.DataCount);
252 if (remaining < total_in_buf2) {
253 cFYI(1, "transact2 2nd response contains too much data");
256 /* find end of first SMB data area */
257 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
258 get_unaligned_le16(&pSMBt->t2_rsp.DataOffset);
259 /* validate target area */
261 data_area_of_buf2 = (char *)&pSMB2->hdr.Protocol +
262 get_unaligned_le16(&pSMB2->t2_rsp.DataOffset);
264 data_area_of_target += total_in_buf;
266 /* copy second buffer into end of first buffer */
267 total_in_buf += total_in_buf2;
268 /* is the result too big for the field? */
269 if (total_in_buf > USHRT_MAX)
271 put_unaligned_le16(total_in_buf, &pSMBt->t2_rsp.DataCount);
274 byte_count = get_bcc(pTargetSMB);
275 byte_count += total_in_buf2;
276 /* is the result too big for the field? */
277 if (byte_count > USHRT_MAX)
279 put_bcc(byte_count, pTargetSMB);
281 byte_count = be32_to_cpu(pTargetSMB->smb_buf_length);
282 byte_count += total_in_buf2;
283 /* don't allow buffer to overflow */
284 if (byte_count > CIFSMaxBufSize)
286 pTargetSMB->smb_buf_length = cpu_to_be32(byte_count);
288 memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
290 if (remaining == total_in_buf2) {
291 cFYI(1, "found the last secondary response");
292 return 0; /* we are done */
293 } else /* more responses to go */
298 cifs_echo_request(struct work_struct *work)
301 struct TCP_Server_Info *server = container_of(work,
302 struct TCP_Server_Info, echo.work);
305 * We cannot send an echo until the NEGOTIATE_PROTOCOL request is
306 * done, which is indicated by maxBuf != 0. Also, no need to ping if
307 * we got a response recently
309 if (server->maxBuf == 0 ||
310 time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
313 rc = CIFSSMBEcho(server);
315 cFYI(1, "Unable to send echo request to server: %s",
319 queue_delayed_work(system_nrt_wq, &server->echo, SMB_ECHO_INTERVAL);
323 allocate_buffers(char **bigbuf, char **smallbuf, unsigned int size,
326 char *bbuf = *bigbuf, *sbuf = *smallbuf;
329 bbuf = (char *)cifs_buf_get();
331 cERROR(1, "No memory for large SMB response");
333 /* retry will check if exiting */
336 } else if (is_large_buf) {
337 /* we are reusing a dirty large buf, clear its start */
338 memset(bbuf, 0, size);
342 sbuf = (char *)cifs_small_buf_get();
344 cERROR(1, "No memory for SMB response");
346 /* retry will check if exiting */
349 /* beginning of smb buffer is cleared in our buf_get */
351 /* if existing small buf clear beginning */
352 memset(sbuf, 0, size);
362 read_from_socket(struct TCP_Server_Info *server, struct msghdr *smb_msg,
363 struct kvec *iov, unsigned int to_read,
364 unsigned int *ptotal_read, bool is_header_read)
367 unsigned int total_read;
368 char *buf = iov->iov_base;
370 for (total_read = 0; total_read < to_read; total_read += length) {
371 length = kernel_recvmsg(server->ssocket, smb_msg, iov, 1,
372 to_read - total_read, 0);
373 if (server->tcpStatus == CifsExiting) {
377 } else if (server->tcpStatus == CifsNeedReconnect) {
378 cifs_reconnect(server);
379 /* Reconnect wakes up rspns q */
380 /* Now we will reread sock */
383 } else if (length == -ERESTARTSYS ||
387 * Minimum sleep to prevent looping, allowing socket
388 * to clear and app threads to set tcpStatus
389 * CifsNeedReconnect if server hung.
391 usleep_range(1000, 2000);
395 /* Special handling for header read */
397 iov->iov_base = (to_read - total_read) +
399 iov->iov_len = to_read - total_read;
400 smb_msg->msg_control = NULL;
401 smb_msg->msg_controllen = 0;
406 } else if (length <= 0) {
407 cERROR(1, "Received no data, expecting %d",
408 to_read - total_read);
409 cifs_reconnect(server);
415 *ptotal_read = total_read;
420 cifs_demultiplex_thread(void *p)
423 struct TCP_Server_Info *server = p;
424 unsigned int pdu_length, total_read;
425 char *buf = NULL, *bigbuf = NULL, *smallbuf = NULL;
426 struct smb_hdr *smb_buffer = NULL;
427 struct msghdr smb_msg;
429 struct list_head *tmp, *tmp2;
430 struct task_struct *task_to_wake = NULL;
431 struct mid_q_entry *mid_entry;
433 bool isLargeBuf = false;
437 current->flags |= PF_MEMALLOC;
438 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
440 length = atomic_inc_return(&tcpSesAllocCount);
442 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
446 while (server->tcpStatus != CifsExiting) {
450 if (!allocate_buffers(&bigbuf, &smallbuf,
451 sizeof(struct smb_hdr), isLargeBuf))
456 smb_buffer = (struct smb_hdr *)smallbuf;
460 smb_msg.msg_control = NULL;
461 smb_msg.msg_controllen = 0;
462 pdu_length = 4; /* enough to get RFC1001 header */
465 if (echo_retries > 0 && server->tcpStatus == CifsGood &&
466 time_after(jiffies, server->lstrp +
467 (echo_retries * SMB_ECHO_INTERVAL))) {
468 cERROR(1, "Server %s has not responded in %d seconds. "
469 "Reconnecting...", server->hostname,
470 (echo_retries * SMB_ECHO_INTERVAL / HZ));
471 cifs_reconnect(server);
472 wake_up(&server->response_q);
476 rc = read_from_socket(server, &smb_msg, &iov, pdu_length,
477 &total_read, true /* header read */);
485 /* The right amount was read from socket - 4 bytes */
486 /* so we can now interpret the length field */
488 /* the first byte big endian of the length field,
489 is actually not part of the length but the type
490 with the most common, zero, as regular data */
493 /* Note that FC 1001 length is big endian on the wire,
494 but we convert it here so it is always manipulated
495 as host byte order */
496 pdu_length = be32_to_cpu(smb_buffer->smb_buf_length);
498 cFYI(1, "rfc1002 length 0x%x", pdu_length+4);
500 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
502 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
503 cFYI(1, "Good RFC 1002 session rsp");
505 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
506 /* we get this from Windows 98 instead of
507 an error on SMB negprot response */
508 cFYI(1, "Negative RFC1002 Session Response Error 0x%x)",
510 /* give server a second to clean up */
512 /* always try 445 first on reconnect since we get NACK
513 * on some if we ever connected to port 139 (the NACK
514 * is since we do not begin with RFC1001 session
517 cifs_set_port((struct sockaddr *)
518 &server->dstaddr, CIFS_PORT);
519 cifs_reconnect(server);
520 wake_up(&server->response_q);
522 } else if (temp != (char) 0) {
523 cERROR(1, "Unknown RFC 1002 frame");
524 cifs_dump_mem(" Received Data: ", buf, length);
525 cifs_reconnect(server);
529 /* else we have an SMB response */
530 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
531 (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
532 cERROR(1, "Invalid size SMB length %d pdu_length %d",
533 length, pdu_length+4);
534 cifs_reconnect(server);
535 wake_up(&server->response_q);
540 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
542 memcpy(bigbuf, smallbuf, 4);
543 smb_buffer = (struct smb_hdr *)bigbuf;
547 iov.iov_base = 4 + buf;
548 iov.iov_len = pdu_length;
549 rc = read_from_socket(server, &smb_msg, &iov, pdu_length,
556 total_read += 4; /* account for rfc1002 hdr */
558 dump_smb(smb_buffer, total_read);
561 * We know that we received enough to get to the MID as we
562 * checked the pdu_length earlier. Now check to see
563 * if the rest of the header is OK. We borrow the length
564 * var for the rest of the loop to avoid a new stack var.
566 * 48 bytes is enough to display the header and a little bit
567 * into the payload for debugging purposes.
569 length = checkSMB(smb_buffer, smb_buffer->Mid, total_read);
571 cifs_dump_mem("Bad SMB: ", buf,
572 min_t(unsigned int, total_read, 48));
575 server->lstrp = jiffies;
577 spin_lock(&GlobalMid_Lock);
578 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
579 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
581 if (mid_entry->mid != smb_buffer->Mid ||
582 mid_entry->midState != MID_REQUEST_SUBMITTED ||
583 mid_entry->command != smb_buffer->Command) {
589 check2ndT2(smb_buffer, server->maxBuf) > 0) {
590 /* We have a multipart transact2 resp */
592 if (mid_entry->resp_buf) {
593 /* merge response - fix up 1st*/
594 length = coalesce_t2(smb_buffer,
595 mid_entry->resp_buf);
598 mid_entry->multiRsp = true;
601 /* all parts received or
602 * packet is malformed
604 mid_entry->multiEnd = true;
610 * FIXME: switch to already
611 * allocated largebuf?
613 cERROR(1, "1st trans2 resp "
616 /* Have first buffer */
617 mid_entry->resp_buf =
619 mid_entry->largeBuf = true;
625 mid_entry->resp_buf = smb_buffer;
626 mid_entry->largeBuf = isLargeBuf;
629 mid_entry->midState = MID_RESPONSE_RECEIVED;
631 mid_entry->midState = MID_RESPONSE_MALFORMED;
632 #ifdef CONFIG_CIFS_STATS2
633 mid_entry->when_received = jiffies;
635 list_del_init(&mid_entry->qhead);
638 spin_unlock(&GlobalMid_Lock);
640 if (mid_entry != NULL) {
641 mid_entry->callback(mid_entry);
642 /* Was previous buf put in mpx struct for multi-rsp? */
644 /* smb buffer will be freed by user thread */
650 } else if (length != 0) {
651 /* response sanity checks failed */
653 } else if (!is_valid_oplock_break(smb_buffer, server) &&
655 cERROR(1, "No task to wake, unknown frame received! "
656 "NumMids %d", atomic_read(&midCount));
657 cifs_dump_mem("Received Data is: ", buf,
658 sizeof(struct smb_hdr));
659 #ifdef CONFIG_CIFS_DEBUG2
660 cifs_dump_detail(smb_buffer);
661 cifs_dump_mids(server);
662 #endif /* CIFS_DEBUG2 */
665 } /* end while !EXITING */
667 /* take it off the list, if it's not already */
668 spin_lock(&cifs_tcp_ses_lock);
669 list_del_init(&server->tcp_ses_list);
670 spin_unlock(&cifs_tcp_ses_lock);
672 spin_lock(&GlobalMid_Lock);
673 server->tcpStatus = CifsExiting;
674 spin_unlock(&GlobalMid_Lock);
675 wake_up_all(&server->response_q);
677 /* check if we have blocked requests that need to free */
678 /* Note that cifs_max_pending is normally 50, but
679 can be set at module install time to as little as two */
680 spin_lock(&GlobalMid_Lock);
681 if (atomic_read(&server->inFlight) >= cifs_max_pending)
682 atomic_set(&server->inFlight, cifs_max_pending - 1);
683 /* We do not want to set the max_pending too low or we
684 could end up with the counter going negative */
685 spin_unlock(&GlobalMid_Lock);
686 /* Although there should not be any requests blocked on
687 this queue it can not hurt to be paranoid and try to wake up requests
688 that may haven been blocked when more than 50 at time were on the wire
689 to the same server - they now will see the session is in exit state
690 and get out of SendReceive. */
691 wake_up_all(&server->request_q);
692 /* give those requests time to exit */
695 if (server->ssocket) {
696 sock_release(server->ssocket);
697 server->ssocket = NULL;
699 /* buffer usually freed in free_mid - need to free it here on exit */
700 cifs_buf_release(bigbuf);
701 if (smallbuf) /* no sense logging a debug message if NULL */
702 cifs_small_buf_release(smallbuf);
704 if (!list_empty(&server->pending_mid_q)) {
705 struct list_head dispose_list;
707 INIT_LIST_HEAD(&dispose_list);
708 spin_lock(&GlobalMid_Lock);
709 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
710 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
711 cFYI(1, "Clearing mid 0x%x", mid_entry->mid);
712 mid_entry->midState = MID_SHUTDOWN;
713 list_move(&mid_entry->qhead, &dispose_list);
715 spin_unlock(&GlobalMid_Lock);
717 /* now walk dispose list and issue callbacks */
718 list_for_each_safe(tmp, tmp2, &dispose_list) {
719 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
720 cFYI(1, "Callback mid 0x%x", mid_entry->mid);
721 list_del_init(&mid_entry->qhead);
722 mid_entry->callback(mid_entry);
724 /* 1/8th of sec is more than enough time for them to exit */
728 if (!list_empty(&server->pending_mid_q)) {
729 /* mpx threads have not exited yet give them
730 at least the smb send timeout time for long ops */
731 /* due to delays on oplock break requests, we need
732 to wait at least 45 seconds before giving up
733 on a request getting a response and going ahead
735 cFYI(1, "Wait for exit from demultiplex thread");
737 /* if threads still have not exited they are probably never
738 coming home not much else we can do but free the memory */
741 kfree(server->hostname);
742 task_to_wake = xchg(&server->tsk, NULL);
745 length = atomic_dec_return(&tcpSesAllocCount);
747 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
750 /* if server->tsk was NULL then wait for a signal before exiting */
752 set_current_state(TASK_INTERRUPTIBLE);
753 while (!signal_pending(current)) {
755 set_current_state(TASK_INTERRUPTIBLE);
757 set_current_state(TASK_RUNNING);
760 module_put_and_exit(0);
763 /* extract the host portion of the UNC string */
765 extract_hostname(const char *unc)
771 /* skip double chars at beginning of string */
772 /* BB: check validity of these bytes? */
775 /* delimiter between hostname and sharename is always '\\' now */
776 delim = strchr(src, '\\');
778 return ERR_PTR(-EINVAL);
781 dst = kmalloc((len + 1), GFP_KERNEL);
783 return ERR_PTR(-ENOMEM);
785 memcpy(dst, src, len);
792 cifs_parse_mount_options(const char *mountdata, const char *devname,
795 char *value, *data, *end;
796 char *mountdata_copy = NULL, *options;
797 unsigned int temp_len, i, j;
799 short int override_uid = -1;
800 short int override_gid = -1;
801 bool uid_specified = false;
802 bool gid_specified = false;
803 char *nodename = utsname()->nodename;
809 * does not have to be perfect mapping since field is
810 * informational, only used for servers that do not support
811 * port 445 and it can be overridden at mount time
813 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
814 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
815 vol->source_rfc1001_name[i] = toupper(nodename[i]);
817 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
818 /* null target name indicates to use *SMBSERVR default called name
819 if we end up sending RFC1001 session initialize */
820 vol->target_rfc1001_name[0] = 0;
821 vol->cred_uid = current_uid();
822 vol->linux_uid = current_uid();
823 vol->linux_gid = current_gid();
825 /* default to only allowing write access to owner of the mount */
826 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
828 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
829 /* default is always to request posix paths. */
830 vol->posix_paths = 1;
831 /* default to using server inode numbers where available */
834 vol->actimeo = CIFS_DEF_ACTIMEO;
837 goto cifs_parse_mount_err;
839 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
841 goto cifs_parse_mount_err;
843 options = mountdata_copy;
844 end = options + strlen(options);
845 if (strncmp(options, "sep=", 4) == 0) {
846 if (options[4] != 0) {
847 separator[0] = options[4];
850 cFYI(1, "Null separator not allowed");
854 while ((data = strsep(&options, separator)) != NULL) {
857 if ((value = strchr(data, '=')) != NULL)
860 /* Have to parse this before we parse for "user" */
861 if (strnicmp(data, "user_xattr", 10) == 0) {
863 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
865 } else if (strnicmp(data, "user", 4) == 0) {
868 "CIFS: invalid or missing username\n");
869 goto cifs_parse_mount_err;
870 } else if (!*value) {
871 /* null user, ie anonymous, authentication */
874 if (strnlen(value, MAX_USERNAME_SIZE) <
876 vol->username = kstrdup(value, GFP_KERNEL);
877 if (!vol->username) {
878 printk(KERN_WARNING "CIFS: no memory "
880 goto cifs_parse_mount_err;
883 printk(KERN_WARNING "CIFS: username too long\n");
884 goto cifs_parse_mount_err;
886 } else if (strnicmp(data, "pass", 4) == 0) {
888 vol->password = NULL;
890 } else if (value[0] == 0) {
891 /* check if string begins with double comma
892 since that would mean the password really
893 does start with a comma, and would not
894 indicate an empty string */
895 if (value[1] != separator[0]) {
896 vol->password = NULL;
900 temp_len = strlen(value);
901 /* removed password length check, NTLM passwords
902 can be arbitrarily long */
904 /* if comma in password, the string will be
905 prematurely null terminated. Commas in password are
906 specified across the cifs mount interface by a double
907 comma ie ,, and a comma used as in other cases ie ','
908 as a parameter delimiter/separator is single and due
909 to the strsep above is temporarily zeroed. */
911 /* NB: password legally can have multiple commas and
912 the only illegal character in a password is null */
914 if ((value[temp_len] == 0) &&
915 (value + temp_len < end) &&
916 (value[temp_len+1] == separator[0])) {
918 value[temp_len] = separator[0];
919 temp_len += 2; /* move after second comma */
920 while (value[temp_len] != 0) {
921 if (value[temp_len] == separator[0]) {
922 if (value[temp_len+1] ==
924 /* skip second comma */
927 /* single comma indicating start
934 if (value[temp_len] == 0) {
938 /* point option to start of next parm */
939 options = value + temp_len + 1;
941 /* go from value to value + temp_len condensing
942 double commas to singles. Note that this ends up
943 allocating a few bytes too many, which is ok */
944 vol->password = kzalloc(temp_len, GFP_KERNEL);
945 if (vol->password == NULL) {
946 printk(KERN_WARNING "CIFS: no memory "
948 goto cifs_parse_mount_err;
950 for (i = 0, j = 0; i < temp_len; i++, j++) {
951 vol->password[j] = value[i];
952 if (value[i] == separator[0]
953 && value[i+1] == separator[0]) {
954 /* skip second comma */
958 vol->password[j] = 0;
960 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
961 if (vol->password == NULL) {
962 printk(KERN_WARNING "CIFS: no memory "
964 goto cifs_parse_mount_err;
966 strcpy(vol->password, value);
968 } else if (!strnicmp(data, "ip", 2) ||
969 !strnicmp(data, "addr", 4)) {
970 if (!value || !*value) {
972 } else if (strnlen(value, INET6_ADDRSTRLEN) <
974 vol->UNCip = kstrdup(value, GFP_KERNEL);
976 printk(KERN_WARNING "CIFS: no memory "
978 goto cifs_parse_mount_err;
981 printk(KERN_WARNING "CIFS: ip address "
983 goto cifs_parse_mount_err;
985 } else if (strnicmp(data, "sec", 3) == 0) {
986 if (!value || !*value) {
987 cERROR(1, "no security value specified");
989 } else if (strnicmp(value, "krb5i", 5) == 0) {
990 vol->secFlg |= CIFSSEC_MAY_KRB5 |
992 } else if (strnicmp(value, "krb5p", 5) == 0) {
993 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
995 cERROR(1, "Krb5 cifs privacy not supported");
996 goto cifs_parse_mount_err;
997 } else if (strnicmp(value, "krb5", 4) == 0) {
998 vol->secFlg |= CIFSSEC_MAY_KRB5;
999 } else if (strnicmp(value, "ntlmsspi", 8) == 0) {
1000 vol->secFlg |= CIFSSEC_MAY_NTLMSSP |
1002 } else if (strnicmp(value, "ntlmssp", 7) == 0) {
1003 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
1004 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
1005 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
1007 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
1008 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1009 } else if (strnicmp(value, "ntlmi", 5) == 0) {
1010 vol->secFlg |= CIFSSEC_MAY_NTLM |
1012 } else if (strnicmp(value, "ntlm", 4) == 0) {
1013 /* ntlm is default so can be turned off too */
1014 vol->secFlg |= CIFSSEC_MAY_NTLM;
1015 } else if (strnicmp(value, "nontlm", 6) == 0) {
1016 /* BB is there a better way to do this? */
1017 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1018 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1019 } else if (strnicmp(value, "lanman", 6) == 0) {
1020 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1022 } else if (strnicmp(value, "none", 4) == 0) {
1025 cERROR(1, "bad security option: %s", value);
1026 goto cifs_parse_mount_err;
1028 } else if (strnicmp(data, "vers", 3) == 0) {
1029 if (!value || !*value) {
1030 cERROR(1, "no protocol version specified"
1031 " after vers= mount option");
1032 } else if ((strnicmp(value, "cifs", 4) == 0) ||
1033 (strnicmp(value, "1", 1) == 0)) {
1034 /* this is the default */
1037 } else if ((strnicmp(data, "unc", 3) == 0)
1038 || (strnicmp(data, "target", 6) == 0)
1039 || (strnicmp(data, "path", 4) == 0)) {
1040 if (!value || !*value) {
1041 printk(KERN_WARNING "CIFS: invalid path to "
1042 "network resource\n");
1043 goto cifs_parse_mount_err;
1045 if ((temp_len = strnlen(value, 300)) < 300) {
1046 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1047 if (vol->UNC == NULL)
1048 goto cifs_parse_mount_err;
1049 strcpy(vol->UNC, value);
1050 if (strncmp(vol->UNC, "//", 2) == 0) {
1053 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1055 "CIFS: UNC Path does not begin "
1056 "with // or \\\\ \n");
1057 goto cifs_parse_mount_err;
1060 printk(KERN_WARNING "CIFS: UNC name too long\n");
1061 goto cifs_parse_mount_err;
1063 } else if ((strnicmp(data, "domain", 3) == 0)
1064 || (strnicmp(data, "workgroup", 5) == 0)) {
1065 if (!value || !*value) {
1066 printk(KERN_WARNING "CIFS: invalid domain name\n");
1067 goto cifs_parse_mount_err;
1069 /* BB are there cases in which a comma can be valid in
1070 a domain name and need special handling? */
1071 if (strnlen(value, 256) < 256) {
1072 vol->domainname = kstrdup(value, GFP_KERNEL);
1073 if (!vol->domainname) {
1074 printk(KERN_WARNING "CIFS: no memory "
1075 "for domainname\n");
1076 goto cifs_parse_mount_err;
1078 cFYI(1, "Domain name set");
1080 printk(KERN_WARNING "CIFS: domain name too "
1082 goto cifs_parse_mount_err;
1084 } else if (strnicmp(data, "srcaddr", 7) == 0) {
1085 vol->srcaddr.ss_family = AF_UNSPEC;
1087 if (!value || !*value) {
1088 printk(KERN_WARNING "CIFS: srcaddr value"
1089 " not specified.\n");
1090 goto cifs_parse_mount_err;
1092 i = cifs_convert_address((struct sockaddr *)&vol->srcaddr,
1093 value, strlen(value));
1095 printk(KERN_WARNING "CIFS: Could not parse"
1098 goto cifs_parse_mount_err;
1100 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1101 if (!value || !*value) {
1103 "CIFS: invalid path prefix\n");
1104 goto cifs_parse_mount_err;
1106 if ((temp_len = strnlen(value, 1024)) < 1024) {
1107 if (value[0] != '/')
1108 temp_len++; /* missing leading slash */
1109 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1110 if (vol->prepath == NULL)
1111 goto cifs_parse_mount_err;
1112 if (value[0] != '/') {
1113 vol->prepath[0] = '/';
1114 strcpy(vol->prepath+1, value);
1116 strcpy(vol->prepath, value);
1117 cFYI(1, "prefix path %s", vol->prepath);
1119 printk(KERN_WARNING "CIFS: prefix too long\n");
1120 goto cifs_parse_mount_err;
1122 } else if (strnicmp(data, "iocharset", 9) == 0) {
1123 if (!value || !*value) {
1124 printk(KERN_WARNING "CIFS: invalid iocharset "
1126 goto cifs_parse_mount_err;
1128 if (strnlen(value, 65) < 65) {
1129 if (strnicmp(value, "default", 7)) {
1130 vol->iocharset = kstrdup(value,
1133 if (!vol->iocharset) {
1134 printk(KERN_WARNING "CIFS: no "
1137 goto cifs_parse_mount_err;
1140 /* if iocharset not set then load_nls_default
1141 is used by caller */
1142 cFYI(1, "iocharset set to %s", value);
1144 printk(KERN_WARNING "CIFS: iocharset name "
1146 goto cifs_parse_mount_err;
1148 } else if (!strnicmp(data, "uid", 3) && value && *value) {
1149 vol->linux_uid = simple_strtoul(value, &value, 0);
1150 uid_specified = true;
1151 } else if (!strnicmp(data, "cruid", 5) && value && *value) {
1152 vol->cred_uid = simple_strtoul(value, &value, 0);
1153 } else if (!strnicmp(data, "forceuid", 8)) {
1155 } else if (!strnicmp(data, "noforceuid", 10)) {
1157 } else if (!strnicmp(data, "gid", 3) && value && *value) {
1158 vol->linux_gid = simple_strtoul(value, &value, 0);
1159 gid_specified = true;
1160 } else if (!strnicmp(data, "forcegid", 8)) {
1162 } else if (!strnicmp(data, "noforcegid", 10)) {
1164 } else if (strnicmp(data, "file_mode", 4) == 0) {
1165 if (value && *value) {
1167 simple_strtoul(value, &value, 0);
1169 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1170 if (value && *value) {
1172 simple_strtoul(value, &value, 0);
1174 } else if (strnicmp(data, "dirmode", 4) == 0) {
1175 if (value && *value) {
1177 simple_strtoul(value, &value, 0);
1179 } else if (strnicmp(data, "port", 4) == 0) {
1180 if (value && *value) {
1182 simple_strtoul(value, &value, 0);
1184 } else if (strnicmp(data, "rsize", 5) == 0) {
1185 if (value && *value) {
1187 simple_strtoul(value, &value, 0);
1189 } else if (strnicmp(data, "wsize", 5) == 0) {
1190 if (value && *value) {
1192 simple_strtoul(value, &value, 0);
1194 } else if (strnicmp(data, "sockopt", 5) == 0) {
1195 if (!value || !*value) {
1196 cERROR(1, "no socket option specified");
1198 } else if (strnicmp(value, "TCP_NODELAY", 11) == 0) {
1199 vol->sockopt_tcp_nodelay = 1;
1201 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1202 if (!value || !*value || (*value == ' ')) {
1203 cFYI(1, "invalid (empty) netbiosname");
1205 memset(vol->source_rfc1001_name, 0x20,
1208 * FIXME: are there cases in which a comma can
1209 * be valid in workstation netbios name (and
1210 * need special handling)?
1212 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1213 /* don't ucase netbiosname for user */
1216 vol->source_rfc1001_name[i] = value[i];
1218 /* The string has 16th byte zero still from
1219 set at top of the function */
1220 if (i == RFC1001_NAME_LEN && value[i] != 0)
1221 printk(KERN_WARNING "CIFS: netbiosname"
1222 " longer than 15 truncated.\n");
1224 } else if (strnicmp(data, "servern", 7) == 0) {
1225 /* servernetbiosname specified override *SMBSERVER */
1226 if (!value || !*value || (*value == ' ')) {
1227 cFYI(1, "empty server netbiosname specified");
1229 /* last byte, type, is 0x20 for servr type */
1230 memset(vol->target_rfc1001_name, 0x20,
1231 RFC1001_NAME_LEN_WITH_NULL);
1233 for (i = 0; i < 15; i++) {
1234 /* BB are there cases in which a comma can be
1235 valid in this workstation netbios name
1236 (and need special handling)? */
1238 /* user or mount helper must uppercase
1243 vol->target_rfc1001_name[i] =
1246 /* The string has 16th byte zero still from
1247 set at top of the function */
1248 if (i == RFC1001_NAME_LEN && value[i] != 0)
1249 printk(KERN_WARNING "CIFS: server net"
1250 "biosname longer than 15 truncated.\n");
1252 } else if (strnicmp(data, "actimeo", 7) == 0) {
1253 if (value && *value) {
1254 vol->actimeo = HZ * simple_strtoul(value,
1256 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1257 cERROR(1, "CIFS: attribute cache"
1258 "timeout too large");
1259 goto cifs_parse_mount_err;
1262 } else if (strnicmp(data, "credentials", 4) == 0) {
1264 } else if (strnicmp(data, "version", 3) == 0) {
1266 } else if (strnicmp(data, "guest", 5) == 0) {
1268 } else if (strnicmp(data, "rw", 2) == 0) {
1270 } else if (strnicmp(data, "ro", 2) == 0) {
1272 } else if (strnicmp(data, "noblocksend", 11) == 0) {
1273 vol->noblocksnd = 1;
1274 } else if (strnicmp(data, "noautotune", 10) == 0) {
1275 vol->noautotune = 1;
1276 } else if ((strnicmp(data, "suid", 4) == 0) ||
1277 (strnicmp(data, "nosuid", 6) == 0) ||
1278 (strnicmp(data, "exec", 4) == 0) ||
1279 (strnicmp(data, "noexec", 6) == 0) ||
1280 (strnicmp(data, "nodev", 5) == 0) ||
1281 (strnicmp(data, "noauto", 6) == 0) ||
1282 (strnicmp(data, "dev", 3) == 0)) {
1283 /* The mount tool or mount.cifs helper (if present)
1284 uses these opts to set flags, and the flags are read
1285 by the kernel vfs layer before we get here (ie
1286 before read super) so there is no point trying to
1287 parse these options again and set anything and it
1288 is ok to just ignore them */
1290 } else if (strnicmp(data, "hard", 4) == 0) {
1292 } else if (strnicmp(data, "soft", 4) == 0) {
1294 } else if (strnicmp(data, "perm", 4) == 0) {
1296 } else if (strnicmp(data, "noperm", 6) == 0) {
1298 } else if (strnicmp(data, "mapchars", 8) == 0) {
1300 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1302 } else if (strnicmp(data, "sfu", 3) == 0) {
1304 } else if (strnicmp(data, "nosfu", 5) == 0) {
1306 } else if (strnicmp(data, "nodfs", 5) == 0) {
1308 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1309 vol->posix_paths = 1;
1310 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1311 vol->posix_paths = 0;
1312 } else if (strnicmp(data, "nounix", 6) == 0) {
1313 vol->no_linux_ext = 1;
1314 } else if (strnicmp(data, "nolinux", 7) == 0) {
1315 vol->no_linux_ext = 1;
1316 } else if ((strnicmp(data, "nocase", 6) == 0) ||
1317 (strnicmp(data, "ignorecase", 10) == 0)) {
1319 } else if (strnicmp(data, "mand", 4) == 0) {
1321 } else if (strnicmp(data, "nomand", 6) == 0) {
1323 } else if (strnicmp(data, "_netdev", 7) == 0) {
1325 } else if (strnicmp(data, "brl", 3) == 0) {
1327 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1328 (strnicmp(data, "nolock", 6) == 0)) {
1330 /* turn off mandatory locking in mode
1331 if remote locking is turned off since the
1332 local vfs will do advisory */
1333 if (vol->file_mode ==
1334 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1335 vol->file_mode = S_IALLUGO;
1336 } else if (strnicmp(data, "forcemandatorylock", 9) == 0) {
1337 /* will take the shorter form "forcemand" as well */
1338 /* This mount option will force use of mandatory
1339 (DOS/Windows style) byte range locks, instead of
1340 using posix advisory byte range locks, even if the
1341 Unix extensions are available and posix locks would
1342 be supported otherwise. If Unix extensions are not
1343 negotiated this has no effect since mandatory locks
1344 would be used (mandatory locks is all that those
1345 those servers support) */
1347 } else if (strnicmp(data, "setuids", 7) == 0) {
1349 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1351 } else if (strnicmp(data, "dynperm", 7) == 0) {
1352 vol->dynperm = true;
1353 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1354 vol->dynperm = false;
1355 } else if (strnicmp(data, "nohard", 6) == 0) {
1357 } else if (strnicmp(data, "nosoft", 6) == 0) {
1359 } else if (strnicmp(data, "nointr", 6) == 0) {
1361 } else if (strnicmp(data, "intr", 4) == 0) {
1363 } else if (strnicmp(data, "nostrictsync", 12) == 0) {
1364 vol->nostrictsync = 1;
1365 } else if (strnicmp(data, "strictsync", 10) == 0) {
1366 vol->nostrictsync = 0;
1367 } else if (strnicmp(data, "serverino", 7) == 0) {
1368 vol->server_ino = 1;
1369 } else if (strnicmp(data, "noserverino", 9) == 0) {
1370 vol->server_ino = 0;
1371 } else if (strnicmp(data, "rwpidforward", 4) == 0) {
1372 vol->rwpidforward = 1;
1373 } else if (strnicmp(data, "cifsacl", 7) == 0) {
1375 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1377 } else if (strnicmp(data, "acl", 3) == 0) {
1378 vol->no_psx_acl = 0;
1379 } else if (strnicmp(data, "noacl", 5) == 0) {
1380 vol->no_psx_acl = 1;
1381 } else if (strnicmp(data, "locallease", 6) == 0) {
1382 vol->local_lease = 1;
1383 } else if (strnicmp(data, "sign", 4) == 0) {
1384 vol->secFlg |= CIFSSEC_MUST_SIGN;
1385 } else if (strnicmp(data, "seal", 4) == 0) {
1386 /* we do not do the following in secFlags because seal
1387 is a per tree connection (mount) not a per socket
1388 or per-smb connection option in the protocol */
1389 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1391 } else if (strnicmp(data, "direct", 6) == 0) {
1393 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
1395 } else if (strnicmp(data, "strictcache", 11) == 0) {
1397 } else if (strnicmp(data, "noac", 4) == 0) {
1398 printk(KERN_WARNING "CIFS: Mount option noac not "
1399 "supported. Instead set "
1400 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1401 } else if (strnicmp(data, "fsc", 3) == 0) {
1402 #ifndef CONFIG_CIFS_FSCACHE
1403 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE "
1404 "kernel config option set");
1405 goto cifs_parse_mount_err;
1408 } else if (strnicmp(data, "mfsymlinks", 10) == 0) {
1409 vol->mfsymlinks = true;
1410 } else if (strnicmp(data, "multiuser", 8) == 0) {
1411 vol->multiuser = true;
1413 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1416 if (vol->UNC == NULL) {
1417 if (devname == NULL) {
1418 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1420 goto cifs_parse_mount_err;
1422 if ((temp_len = strnlen(devname, 300)) < 300) {
1423 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1424 if (vol->UNC == NULL)
1425 goto cifs_parse_mount_err;
1426 strcpy(vol->UNC, devname);
1427 if (strncmp(vol->UNC, "//", 2) == 0) {
1430 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1431 printk(KERN_WARNING "CIFS: UNC Path does not "
1432 "begin with // or \\\\ \n");
1433 goto cifs_parse_mount_err;
1435 value = strpbrk(vol->UNC+2, "/\\");
1439 printk(KERN_WARNING "CIFS: UNC name too long\n");
1440 goto cifs_parse_mount_err;
1444 if (vol->multiuser && !(vol->secFlg & CIFSSEC_MAY_KRB5)) {
1445 cERROR(1, "Multiuser mounts currently require krb5 "
1447 goto cifs_parse_mount_err;
1450 if (vol->UNCip == NULL)
1451 vol->UNCip = &vol->UNC[2];
1454 vol->override_uid = override_uid;
1455 else if (override_uid == 1)
1456 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1457 "specified with no uid= option.\n");
1460 vol->override_gid = override_gid;
1461 else if (override_gid == 1)
1462 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1463 "specified with no gid= option.\n");
1465 kfree(mountdata_copy);
1468 cifs_parse_mount_err:
1469 kfree(mountdata_copy);
1473 /** Returns true if srcaddr isn't specified and rhs isn't
1474 * specified, or if srcaddr is specified and
1475 * matches the IP address of the rhs argument.
1478 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1480 switch (srcaddr->sa_family) {
1482 return (rhs->sa_family == AF_UNSPEC);
1484 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1485 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1486 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1489 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1490 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1491 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1495 return false; /* don't expect to be here */
1500 * If no port is specified in addr structure, we try to match with 445 port
1501 * and if it fails - with 139 ports. It should be called only if address
1502 * families of server and addr are equal.
1505 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1507 __be16 port, *sport;
1509 switch (addr->sa_family) {
1511 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1512 port = ((struct sockaddr_in *) addr)->sin_port;
1515 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1516 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1524 port = htons(CIFS_PORT);
1528 port = htons(RFC1001_PORT);
1531 return port == *sport;
1535 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1536 struct sockaddr *srcaddr)
1538 switch (addr->sa_family) {
1540 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1541 struct sockaddr_in *srv_addr4 =
1542 (struct sockaddr_in *)&server->dstaddr;
1544 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1549 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1550 struct sockaddr_in6 *srv_addr6 =
1551 (struct sockaddr_in6 *)&server->dstaddr;
1553 if (!ipv6_addr_equal(&addr6->sin6_addr,
1554 &srv_addr6->sin6_addr))
1556 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
1562 return false; /* don't expect to be here */
1565 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1572 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
1574 unsigned int secFlags;
1576 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
1577 secFlags = vol->secFlg;
1579 secFlags = global_secflags | vol->secFlg;
1581 switch (server->secType) {
1583 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
1587 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
1591 if (!(secFlags & CIFSSEC_MAY_NTLM))
1595 if (!(secFlags & CIFSSEC_MAY_KRB5))
1599 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
1603 /* shouldn't happen */
1607 /* now check if signing mode is acceptable */
1608 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
1609 (server->sec_mode & SECMODE_SIGN_REQUIRED))
1611 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
1613 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
1619 static int match_server(struct TCP_Server_Info *server, struct sockaddr *addr,
1620 struct smb_vol *vol)
1622 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
1625 if (!match_address(server, addr,
1626 (struct sockaddr *)&vol->srcaddr))
1629 if (!match_port(server, addr))
1632 if (!match_security(server, vol))
1638 static struct TCP_Server_Info *
1639 cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
1641 struct TCP_Server_Info *server;
1643 spin_lock(&cifs_tcp_ses_lock);
1644 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
1645 if (!match_server(server, addr, vol))
1648 ++server->srv_count;
1649 spin_unlock(&cifs_tcp_ses_lock);
1650 cFYI(1, "Existing tcp session with server found");
1653 spin_unlock(&cifs_tcp_ses_lock);
1658 cifs_put_tcp_session(struct TCP_Server_Info *server)
1660 struct task_struct *task;
1662 spin_lock(&cifs_tcp_ses_lock);
1663 if (--server->srv_count > 0) {
1664 spin_unlock(&cifs_tcp_ses_lock);
1668 put_net(cifs_net_ns(server));
1670 list_del_init(&server->tcp_ses_list);
1671 spin_unlock(&cifs_tcp_ses_lock);
1673 cancel_delayed_work_sync(&server->echo);
1675 spin_lock(&GlobalMid_Lock);
1676 server->tcpStatus = CifsExiting;
1677 spin_unlock(&GlobalMid_Lock);
1679 cifs_crypto_shash_release(server);
1680 cifs_fscache_release_client_cookie(server);
1682 kfree(server->session_key.response);
1683 server->session_key.response = NULL;
1684 server->session_key.len = 0;
1686 task = xchg(&server->tsk, NULL);
1688 force_sig(SIGKILL, task);
1691 static struct TCP_Server_Info *
1692 cifs_get_tcp_session(struct smb_vol *volume_info)
1694 struct TCP_Server_Info *tcp_ses = NULL;
1695 struct sockaddr_storage addr;
1696 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
1697 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
1700 memset(&addr, 0, sizeof(struct sockaddr_storage));
1702 cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
1704 if (volume_info->UNCip && volume_info->UNC) {
1705 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
1707 strlen(volume_info->UNCip),
1710 /* we failed translating address */
1714 } else if (volume_info->UNCip) {
1715 /* BB using ip addr as tcp_ses name to connect to the
1717 cERROR(1, "Connecting to DFS root not implemented yet");
1720 } else /* which tcp_sess DFS root would we conect to */ {
1721 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
1722 "unc=//192.168.1.100/public) specified");
1727 /* see if we already have a matching tcp_ses */
1728 tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
1732 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1738 rc = cifs_crypto_shash_allocate(tcp_ses);
1740 cERROR(1, "could not setup hash structures rc %d", rc);
1744 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
1745 tcp_ses->hostname = extract_hostname(volume_info->UNC);
1746 if (IS_ERR(tcp_ses->hostname)) {
1747 rc = PTR_ERR(tcp_ses->hostname);
1748 goto out_err_crypto_release;
1751 tcp_ses->noblocksnd = volume_info->noblocksnd;
1752 tcp_ses->noautotune = volume_info->noautotune;
1753 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
1754 atomic_set(&tcp_ses->inFlight, 0);
1755 init_waitqueue_head(&tcp_ses->response_q);
1756 init_waitqueue_head(&tcp_ses->request_q);
1757 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1758 mutex_init(&tcp_ses->srv_mutex);
1759 memcpy(tcp_ses->workstation_RFC1001_name,
1760 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1761 memcpy(tcp_ses->server_RFC1001_name,
1762 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1763 tcp_ses->session_estab = false;
1764 tcp_ses->sequence_number = 0;
1765 tcp_ses->lstrp = jiffies;
1766 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1767 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1768 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
1771 * at this point we are the only ones with the pointer
1772 * to the struct since the kernel thread not created yet
1773 * no need to spinlock this init of tcpStatus or srv_count
1775 tcp_ses->tcpStatus = CifsNew;
1776 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
1777 sizeof(tcp_ses->srcaddr));
1778 ++tcp_ses->srv_count;
1780 if (addr.ss_family == AF_INET6) {
1781 cFYI(1, "attempting ipv6 connect");
1782 /* BB should we allow ipv6 on port 139? */
1783 /* other OS never observed in Wild doing 139 with v6 */
1784 memcpy(&tcp_ses->dstaddr, sin_server6,
1785 sizeof(struct sockaddr_in6));
1787 memcpy(&tcp_ses->dstaddr, sin_server,
1788 sizeof(struct sockaddr_in));
1790 rc = ip_connect(tcp_ses);
1792 cERROR(1, "Error connecting to socket. Aborting operation");
1793 goto out_err_crypto_release;
1797 * since we're in a cifs function already, we know that
1798 * this will succeed. No need for try_module_get().
1800 __module_get(THIS_MODULE);
1801 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
1803 if (IS_ERR(tcp_ses->tsk)) {
1804 rc = PTR_ERR(tcp_ses->tsk);
1805 cERROR(1, "error %d create cifsd thread", rc);
1806 module_put(THIS_MODULE);
1807 goto out_err_crypto_release;
1809 tcp_ses->tcpStatus = CifsNeedNegotiate;
1811 /* thread spawned, put it on the list */
1812 spin_lock(&cifs_tcp_ses_lock);
1813 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
1814 spin_unlock(&cifs_tcp_ses_lock);
1816 cifs_fscache_get_client_cookie(tcp_ses);
1818 /* queue echo request delayed work */
1819 queue_delayed_work(system_nrt_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
1823 out_err_crypto_release:
1824 cifs_crypto_shash_release(tcp_ses);
1826 put_net(cifs_net_ns(tcp_ses));
1830 if (!IS_ERR(tcp_ses->hostname))
1831 kfree(tcp_ses->hostname);
1832 if (tcp_ses->ssocket)
1833 sock_release(tcp_ses->ssocket);
1839 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
1841 switch (ses->server->secType) {
1843 if (vol->cred_uid != ses->cred_uid)
1847 /* anything else takes username/password */
1848 if (ses->user_name == NULL)
1850 if (strncmp(ses->user_name, vol->username,
1853 if (strlen(vol->username) != 0 &&
1854 ses->password != NULL &&
1855 strncmp(ses->password,
1856 vol->password ? vol->password : "",
1863 static struct cifs_ses *
1864 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
1866 struct cifs_ses *ses;
1868 spin_lock(&cifs_tcp_ses_lock);
1869 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
1870 if (!match_session(ses, vol))
1873 spin_unlock(&cifs_tcp_ses_lock);
1876 spin_unlock(&cifs_tcp_ses_lock);
1881 cifs_put_smb_ses(struct cifs_ses *ses)
1884 struct TCP_Server_Info *server = ses->server;
1886 cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
1887 spin_lock(&cifs_tcp_ses_lock);
1888 if (--ses->ses_count > 0) {
1889 spin_unlock(&cifs_tcp_ses_lock);
1893 list_del_init(&ses->smb_ses_list);
1894 spin_unlock(&cifs_tcp_ses_lock);
1896 if (ses->status == CifsGood) {
1898 CIFSSMBLogoff(xid, ses);
1902 cifs_put_tcp_session(server);
1905 static bool warned_on_ntlm; /* globals init to false automatically */
1907 static struct cifs_ses *
1908 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
1910 int rc = -ENOMEM, xid;
1911 struct cifs_ses *ses;
1912 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
1913 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
1917 ses = cifs_find_smb_ses(server, volume_info);
1919 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
1921 mutex_lock(&ses->session_mutex);
1922 rc = cifs_negotiate_protocol(xid, ses);
1924 mutex_unlock(&ses->session_mutex);
1925 /* problem -- put our ses reference */
1926 cifs_put_smb_ses(ses);
1930 if (ses->need_reconnect) {
1931 cFYI(1, "Session needs reconnect");
1932 rc = cifs_setup_session(xid, ses,
1933 volume_info->local_nls);
1935 mutex_unlock(&ses->session_mutex);
1936 /* problem -- put our reference */
1937 cifs_put_smb_ses(ses);
1942 mutex_unlock(&ses->session_mutex);
1944 /* existing SMB ses has a server reference already */
1945 cifs_put_tcp_session(server);
1950 cFYI(1, "Existing smb sess not found");
1951 ses = sesInfoAlloc();
1955 /* new SMB session uses our server ref */
1956 ses->server = server;
1957 if (server->dstaddr.ss_family == AF_INET6)
1958 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
1960 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
1962 if (volume_info->username) {
1963 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
1964 if (!ses->user_name)
1968 /* volume_info->password freed at unmount */
1969 if (volume_info->password) {
1970 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
1974 if (volume_info->domainname) {
1975 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
1976 if (!ses->domainName)
1979 ses->cred_uid = volume_info->cred_uid;
1980 ses->linux_uid = volume_info->linux_uid;
1982 /* ntlmv2 is much stronger than ntlm security, and has been broadly
1983 supported for many years, time to update default security mechanism */
1984 if ((volume_info->secFlg == 0) && warned_on_ntlm == false) {
1985 warned_on_ntlm = true;
1986 cERROR(1, "default security mechanism requested. The default "
1987 "security mechanism will be upgraded from ntlm to "
1988 "ntlmv2 in kernel release 3.1");
1990 ses->overrideSecFlg = volume_info->secFlg;
1992 mutex_lock(&ses->session_mutex);
1993 rc = cifs_negotiate_protocol(xid, ses);
1995 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
1996 mutex_unlock(&ses->session_mutex);
2000 /* success, put it on the list */
2001 spin_lock(&cifs_tcp_ses_lock);
2002 list_add(&ses->smb_ses_list, &server->smb_ses_list);
2003 spin_unlock(&cifs_tcp_ses_lock);
2014 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2016 if (tcon->tidStatus == CifsExiting)
2018 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2023 static struct cifs_tcon *
2024 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2026 struct list_head *tmp;
2027 struct cifs_tcon *tcon;
2029 spin_lock(&cifs_tcp_ses_lock);
2030 list_for_each(tmp, &ses->tcon_list) {
2031 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2032 if (!match_tcon(tcon, unc))
2035 spin_unlock(&cifs_tcp_ses_lock);
2038 spin_unlock(&cifs_tcp_ses_lock);
2043 cifs_put_tcon(struct cifs_tcon *tcon)
2046 struct cifs_ses *ses = tcon->ses;
2048 cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2049 spin_lock(&cifs_tcp_ses_lock);
2050 if (--tcon->tc_count > 0) {
2051 spin_unlock(&cifs_tcp_ses_lock);
2055 list_del_init(&tcon->tcon_list);
2056 spin_unlock(&cifs_tcp_ses_lock);
2059 CIFSSMBTDis(xid, tcon);
2062 cifs_fscache_release_super_cookie(tcon);
2064 cifs_put_smb_ses(ses);
2067 static struct cifs_tcon *
2068 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2071 struct cifs_tcon *tcon;
2073 tcon = cifs_find_tcon(ses, volume_info->UNC);
2075 cFYI(1, "Found match on UNC path");
2076 /* existing tcon already has a reference */
2077 cifs_put_smb_ses(ses);
2078 if (tcon->seal != volume_info->seal)
2079 cERROR(1, "transport encryption setting "
2080 "conflicts with existing tid");
2084 tcon = tconInfoAlloc();
2091 if (volume_info->password) {
2092 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2093 if (!tcon->password) {
2099 if (strchr(volume_info->UNC + 3, '\\') == NULL
2100 && strchr(volume_info->UNC + 3, '/') == NULL) {
2101 cERROR(1, "Missing share name");
2106 /* BB Do we need to wrap session_mutex around
2107 * this TCon call and Unix SetFS as
2108 * we do on SessSetup and reconnect? */
2110 rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
2112 cFYI(1, "CIFS Tcon rc = %d", rc);
2116 if (volume_info->nodfs) {
2117 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2118 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2120 tcon->seal = volume_info->seal;
2121 /* we can have only one retry value for a connection
2122 to a share so for resources mounted more than once
2123 to the same server share the last value passed in
2124 for the retry flag is used */
2125 tcon->retry = volume_info->retry;
2126 tcon->nocase = volume_info->nocase;
2127 tcon->local_lease = volume_info->local_lease;
2129 spin_lock(&cifs_tcp_ses_lock);
2130 list_add(&tcon->tcon_list, &ses->tcon_list);
2131 spin_unlock(&cifs_tcp_ses_lock);
2133 cifs_fscache_get_super_cookie(tcon);
2143 cifs_put_tlink(struct tcon_link *tlink)
2145 if (!tlink || IS_ERR(tlink))
2148 if (!atomic_dec_and_test(&tlink->tl_count) ||
2149 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2150 tlink->tl_time = jiffies;
2154 if (!IS_ERR(tlink_tcon(tlink)))
2155 cifs_put_tcon(tlink_tcon(tlink));
2160 static inline struct tcon_link *
2161 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2163 return cifs_sb->master_tlink;
2167 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2169 struct cifs_sb_info *old = CIFS_SB(sb);
2170 struct cifs_sb_info *new = mnt_data->cifs_sb;
2172 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2175 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2176 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2179 if (old->rsize != new->rsize)
2183 * We want to share sb only if we don't specify wsize or specified wsize
2184 * is greater or equal than existing one.
2186 if (new->wsize && new->wsize < old->wsize)
2189 if (old->mnt_uid != new->mnt_uid || old->mnt_gid != new->mnt_gid)
2192 if (old->mnt_file_mode != new->mnt_file_mode ||
2193 old->mnt_dir_mode != new->mnt_dir_mode)
2196 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2199 if (old->actimeo != new->actimeo)
2206 cifs_match_super(struct super_block *sb, void *data)
2208 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2209 struct smb_vol *volume_info;
2210 struct cifs_sb_info *cifs_sb;
2211 struct TCP_Server_Info *tcp_srv;
2212 struct cifs_ses *ses;
2213 struct cifs_tcon *tcon;
2214 struct tcon_link *tlink;
2215 struct sockaddr_storage addr;
2218 memset(&addr, 0, sizeof(struct sockaddr_storage));
2220 spin_lock(&cifs_tcp_ses_lock);
2221 cifs_sb = CIFS_SB(sb);
2222 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2223 if (IS_ERR(tlink)) {
2224 spin_unlock(&cifs_tcp_ses_lock);
2227 tcon = tlink_tcon(tlink);
2229 tcp_srv = ses->server;
2231 volume_info = mnt_data->vol;
2233 if (!volume_info->UNCip || !volume_info->UNC)
2236 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
2238 strlen(volume_info->UNCip),
2243 if (!match_server(tcp_srv, (struct sockaddr *)&addr, volume_info) ||
2244 !match_session(ses, volume_info) ||
2245 !match_tcon(tcon, volume_info->UNC)) {
2250 rc = compare_mount_options(sb, mnt_data);
2252 spin_unlock(&cifs_tcp_ses_lock);
2253 cifs_put_tlink(tlink);
2258 get_dfs_path(int xid, struct cifs_ses *pSesInfo, const char *old_path,
2259 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
2260 struct dfs_info3_param **preferrals, int remap)
2265 *pnum_referrals = 0;
2268 if (pSesInfo->ipc_tid == 0) {
2269 temp_unc = kmalloc(2 /* for slashes */ +
2270 strnlen(pSesInfo->serverName,
2271 SERVER_NAME_LEN_WITH_NULL * 2)
2272 + 1 + 4 /* slash IPC$ */ + 2,
2274 if (temp_unc == NULL)
2278 strcpy(temp_unc + 2, pSesInfo->serverName);
2279 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2280 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
2281 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
2285 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
2286 pnum_referrals, nls_codepage, remap);
2287 /* BB map targetUNCs to dfs_info3 structures, here or
2288 in CIFSGetDFSRefer BB */
2293 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2294 static struct lock_class_key cifs_key[2];
2295 static struct lock_class_key cifs_slock_key[2];
2298 cifs_reclassify_socket4(struct socket *sock)
2300 struct sock *sk = sock->sk;
2301 BUG_ON(sock_owned_by_user(sk));
2302 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2303 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2307 cifs_reclassify_socket6(struct socket *sock)
2309 struct sock *sk = sock->sk;
2310 BUG_ON(sock_owned_by_user(sk));
2311 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2312 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2316 cifs_reclassify_socket4(struct socket *sock)
2321 cifs_reclassify_socket6(struct socket *sock)
2326 /* See RFC1001 section 14 on representation of Netbios names */
2327 static void rfc1002mangle(char *target, char *source, unsigned int length)
2331 for (i = 0, j = 0; i < (length); i++) {
2332 /* mask a nibble at a time and encode */
2333 target[j] = 'A' + (0x0F & (source[i] >> 4));
2334 target[j+1] = 'A' + (0x0F & source[i]);
2341 bind_socket(struct TCP_Server_Info *server)
2344 if (server->srcaddr.ss_family != AF_UNSPEC) {
2345 /* Bind to the specified local IP address */
2346 struct socket *socket = server->ssocket;
2347 rc = socket->ops->bind(socket,
2348 (struct sockaddr *) &server->srcaddr,
2349 sizeof(server->srcaddr));
2351 struct sockaddr_in *saddr4;
2352 struct sockaddr_in6 *saddr6;
2353 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2354 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2355 if (saddr6->sin6_family == AF_INET6)
2357 "Failed to bind to: %pI6c, error: %d\n",
2358 &saddr6->sin6_addr, rc);
2361 "Failed to bind to: %pI4, error: %d\n",
2362 &saddr4->sin_addr.s_addr, rc);
2369 ip_rfc1001_connect(struct TCP_Server_Info *server)
2373 * some servers require RFC1001 sessinit before sending
2374 * negprot - BB check reconnection in case where second
2375 * sessinit is sent but no second negprot
2377 struct rfc1002_session_packet *ses_init_buf;
2378 struct smb_hdr *smb_buf;
2379 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2382 ses_init_buf->trailer.session_req.called_len = 32;
2384 if (server->server_RFC1001_name &&
2385 server->server_RFC1001_name[0] != 0)
2386 rfc1002mangle(ses_init_buf->trailer.
2387 session_req.called_name,
2388 server->server_RFC1001_name,
2389 RFC1001_NAME_LEN_WITH_NULL);
2391 rfc1002mangle(ses_init_buf->trailer.
2392 session_req.called_name,
2393 DEFAULT_CIFS_CALLED_NAME,
2394 RFC1001_NAME_LEN_WITH_NULL);
2396 ses_init_buf->trailer.session_req.calling_len = 32;
2399 * calling name ends in null (byte 16) from old smb
2402 if (server->workstation_RFC1001_name &&
2403 server->workstation_RFC1001_name[0] != 0)
2404 rfc1002mangle(ses_init_buf->trailer.
2405 session_req.calling_name,
2406 server->workstation_RFC1001_name,
2407 RFC1001_NAME_LEN_WITH_NULL);
2409 rfc1002mangle(ses_init_buf->trailer.
2410 session_req.calling_name,
2412 RFC1001_NAME_LEN_WITH_NULL);
2414 ses_init_buf->trailer.session_req.scope1 = 0;
2415 ses_init_buf->trailer.session_req.scope2 = 0;
2416 smb_buf = (struct smb_hdr *)ses_init_buf;
2418 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2419 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
2420 rc = smb_send(server, smb_buf, 0x44);
2421 kfree(ses_init_buf);
2423 * RFC1001 layer in at least one server
2424 * requires very short break before negprot
2425 * presumably because not expecting negprot
2426 * to follow so fast. This is a simple
2427 * solution that works without
2428 * complicating the code and causes no
2429 * significant slowing down on mount
2432 usleep_range(1000, 2000);
2435 * else the negprot may still work without this
2436 * even though malloc failed
2443 generic_ip_connect(struct TCP_Server_Info *server)
2448 struct socket *socket = server->ssocket;
2449 struct sockaddr *saddr;
2451 saddr = (struct sockaddr *) &server->dstaddr;
2453 if (server->dstaddr.ss_family == AF_INET6) {
2454 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2455 slen = sizeof(struct sockaddr_in6);
2458 sport = ((struct sockaddr_in *) saddr)->sin_port;
2459 slen = sizeof(struct sockaddr_in);
2463 if (socket == NULL) {
2464 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2465 IPPROTO_TCP, &socket, 1);
2467 cERROR(1, "Error %d creating socket", rc);
2468 server->ssocket = NULL;
2472 /* BB other socket options to set KEEPALIVE, NODELAY? */
2473 cFYI(1, "Socket created");
2474 server->ssocket = socket;
2475 socket->sk->sk_allocation = GFP_NOFS;
2476 if (sfamily == AF_INET6)
2477 cifs_reclassify_socket6(socket);
2479 cifs_reclassify_socket4(socket);
2482 rc = bind_socket(server);
2487 * Eventually check for other socket options to change from
2488 * the default. sock_setsockopt not used because it expects
2491 socket->sk->sk_rcvtimeo = 7 * HZ;
2492 socket->sk->sk_sndtimeo = 5 * HZ;
2494 /* make the bufsizes depend on wsize/rsize and max requests */
2495 if (server->noautotune) {
2496 if (socket->sk->sk_sndbuf < (200 * 1024))
2497 socket->sk->sk_sndbuf = 200 * 1024;
2498 if (socket->sk->sk_rcvbuf < (140 * 1024))
2499 socket->sk->sk_rcvbuf = 140 * 1024;
2502 if (server->tcp_nodelay) {
2504 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2505 (char *)&val, sizeof(val));
2507 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
2510 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
2511 socket->sk->sk_sndbuf,
2512 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
2514 rc = socket->ops->connect(socket, saddr, slen, 0);
2516 cFYI(1, "Error %d connecting to server", rc);
2517 sock_release(socket);
2518 server->ssocket = NULL;
2522 if (sport == htons(RFC1001_PORT))
2523 rc = ip_rfc1001_connect(server);
2529 ip_connect(struct TCP_Server_Info *server)
2532 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2533 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2535 if (server->dstaddr.ss_family == AF_INET6)
2536 sport = &addr6->sin6_port;
2538 sport = &addr->sin_port;
2543 /* try with 445 port at first */
2544 *sport = htons(CIFS_PORT);
2546 rc = generic_ip_connect(server);
2550 /* if it failed, try with 139 port */
2551 *sport = htons(RFC1001_PORT);
2554 return generic_ip_connect(server);
2557 void reset_cifs_unix_caps(int xid, struct cifs_tcon *tcon,
2558 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
2560 /* if we are reconnecting then should we check to see if
2561 * any requested capabilities changed locally e.g. via
2562 * remount but we can not do much about it here
2563 * if they have (even if we could detect it by the following)
2564 * Perhaps we could add a backpointer to array of sb from tcon
2565 * or if we change to make all sb to same share the same
2566 * sb as NFS - then we only have one backpointer to sb.
2567 * What if we wanted to mount the server share twice once with
2568 * and once without posixacls or posix paths? */
2569 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2571 if (vol_info && vol_info->no_linux_ext) {
2572 tcon->fsUnixInfo.Capability = 0;
2573 tcon->unix_ext = 0; /* Unix Extensions disabled */
2574 cFYI(1, "Linux protocol extensions disabled");
2576 } else if (vol_info)
2577 tcon->unix_ext = 1; /* Unix Extensions supported */
2579 if (tcon->unix_ext == 0) {
2580 cFYI(1, "Unix extensions disabled so not set on reconnect");
2584 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
2585 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2586 cFYI(1, "unix caps which server supports %lld", cap);
2587 /* check for reconnect case in which we do not
2588 want to change the mount behavior if we can avoid it */
2589 if (vol_info == NULL) {
2590 /* turn off POSIX ACL and PATHNAMES if not set
2591 originally at mount time */
2592 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2593 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2594 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2595 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2596 cERROR(1, "POSIXPATH support change");
2597 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2598 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2599 cERROR(1, "possible reconnect error");
2600 cERROR(1, "server disabled POSIX path support");
2604 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
2605 cERROR(1, "per-share encryption not supported yet");
2607 cap &= CIFS_UNIX_CAP_MASK;
2608 if (vol_info && vol_info->no_psx_acl)
2609 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2610 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
2611 cFYI(1, "negotiated posix acl support");
2613 cifs_sb->mnt_cifs_flags |=
2614 CIFS_MOUNT_POSIXACL;
2617 if (vol_info && vol_info->posix_paths == 0)
2618 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2619 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2620 cFYI(1, "negotiate posix pathnames");
2622 cifs_sb->mnt_cifs_flags |=
2623 CIFS_MOUNT_POSIX_PATHS;
2626 if (cifs_sb && (cifs_sb->rsize > 127 * 1024)) {
2627 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
2628 cifs_sb->rsize = 127 * 1024;
2629 cFYI(DBG2, "larger reads not supported by srv");
2634 cFYI(1, "Negotiate caps 0x%x", (int)cap);
2635 #ifdef CONFIG_CIFS_DEBUG2
2636 if (cap & CIFS_UNIX_FCNTL_CAP)
2637 cFYI(1, "FCNTL cap");
2638 if (cap & CIFS_UNIX_EXTATTR_CAP)
2639 cFYI(1, "EXTATTR cap");
2640 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2641 cFYI(1, "POSIX path cap");
2642 if (cap & CIFS_UNIX_XATTR_CAP)
2643 cFYI(1, "XATTR cap");
2644 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
2645 cFYI(1, "POSIX ACL cap");
2646 if (cap & CIFS_UNIX_LARGE_READ_CAP)
2647 cFYI(1, "very large read cap");
2648 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
2649 cFYI(1, "very large write cap");
2650 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
2651 cFYI(1, "transport encryption cap");
2652 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
2653 cFYI(1, "mandatory transport encryption cap");
2654 #endif /* CIFS_DEBUG2 */
2655 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
2656 if (vol_info == NULL) {
2657 cFYI(1, "resetting capabilities failed");
2659 cERROR(1, "Negotiating Unix capabilities "
2660 "with the server failed. Consider "
2661 "mounting with the Unix Extensions\n"
2662 "disabled, if problems are found, "
2663 "by specifying the nounix mount "
2670 void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
2671 struct cifs_sb_info *cifs_sb)
2673 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
2675 spin_lock_init(&cifs_sb->tlink_tree_lock);
2676 cifs_sb->tlink_tree = RB_ROOT;
2678 if (pvolume_info->rsize > CIFSMaxBufSize) {
2679 cERROR(1, "rsize %d too large, using MaxBufSize",
2680 pvolume_info->rsize);
2681 cifs_sb->rsize = CIFSMaxBufSize;
2682 } else if ((pvolume_info->rsize) &&
2683 (pvolume_info->rsize <= CIFSMaxBufSize))
2684 cifs_sb->rsize = pvolume_info->rsize;
2686 cifs_sb->rsize = CIFSMaxBufSize;
2688 if (cifs_sb->rsize < 2048) {
2689 cifs_sb->rsize = 2048;
2690 /* Windows ME may prefer this */
2691 cFYI(1, "readsize set to minimum: 2048");
2695 * Temporarily set wsize for matching superblock. If we end up using
2696 * new sb then cifs_negotiate_wsize will later negotiate it downward
2699 cifs_sb->wsize = pvolume_info->wsize;
2701 cifs_sb->mnt_uid = pvolume_info->linux_uid;
2702 cifs_sb->mnt_gid = pvolume_info->linux_gid;
2703 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2704 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
2705 cFYI(1, "file mode: 0x%x dir mode: 0x%x",
2706 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
2708 cifs_sb->actimeo = pvolume_info->actimeo;
2709 cifs_sb->local_nls = pvolume_info->local_nls;
2711 if (pvolume_info->noperm)
2712 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2713 if (pvolume_info->setuids)
2714 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2715 if (pvolume_info->server_ino)
2716 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2717 if (pvolume_info->remap)
2718 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2719 if (pvolume_info->no_xattr)
2720 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2721 if (pvolume_info->sfu_emul)
2722 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2723 if (pvolume_info->nobrl)
2724 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2725 if (pvolume_info->nostrictsync)
2726 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
2727 if (pvolume_info->mand_lock)
2728 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
2729 if (pvolume_info->rwpidforward)
2730 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
2731 if (pvolume_info->cifs_acl)
2732 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2733 if (pvolume_info->override_uid)
2734 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2735 if (pvolume_info->override_gid)
2736 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2737 if (pvolume_info->dynperm)
2738 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2739 if (pvolume_info->fsc)
2740 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
2741 if (pvolume_info->multiuser)
2742 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
2743 CIFS_MOUNT_NO_PERM);
2744 if (pvolume_info->strict_io)
2745 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
2746 if (pvolume_info->direct_io) {
2747 cFYI(1, "mounting share using direct i/o");
2748 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2750 if (pvolume_info->mfsymlinks) {
2751 if (pvolume_info->sfu_emul) {
2752 cERROR(1, "mount option mfsymlinks ignored if sfu "
2753 "mount option is used");
2755 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
2759 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
2760 cERROR(1, "mount option dynperm ignored if cifsacl "
2761 "mount option supported");
2765 * When the server supports very large writes via POSIX extensions, we can
2766 * allow up to 2^24-1, minus the size of a WRITE_AND_X header, not including
2767 * the RFC1001 length.
2769 * Note that this might make for "interesting" allocation problems during
2770 * writeback however as we have to allocate an array of pointers for the
2771 * pages. A 16M write means ~32kb page array with PAGE_CACHE_SIZE == 4096.
2773 #define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
2776 * When the server doesn't allow large posix writes, only allow a wsize of
2777 * 128k minus the size of the WRITE_AND_X header. That allows for a write up
2778 * to the maximum size described by RFC1002.
2780 #define CIFS_MAX_RFC1002_WSIZE (128 * 1024 - sizeof(WRITE_REQ) + 4)
2783 * The default wsize is 1M. find_get_pages seems to return a maximum of 256
2784 * pages in a single call. With PAGE_CACHE_SIZE == 4k, this means we can fill
2785 * a single wsize request with a single call.
2787 #define CIFS_DEFAULT_WSIZE (1024 * 1024)
2790 cifs_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
2792 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2793 struct TCP_Server_Info *server = tcon->ses->server;
2794 unsigned int wsize = pvolume_info->wsize ? pvolume_info->wsize :
2797 /* can server support 24-bit write sizes? (via UNIX extensions) */
2798 if (!tcon->unix_ext || !(unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
2799 wsize = min_t(unsigned int, wsize, CIFS_MAX_RFC1002_WSIZE);
2802 * no CAP_LARGE_WRITE_X or is signing enabled without CAP_UNIX set?
2803 * Limit it to max buffer offered by the server, minus the size of the
2804 * WRITEX header, not including the 4 byte RFC1001 length.
2806 if (!(server->capabilities & CAP_LARGE_WRITE_X) ||
2807 (!(server->capabilities & CAP_UNIX) &&
2808 (server->sec_mode & (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED))))
2809 wsize = min_t(unsigned int, wsize,
2810 server->maxBuf - sizeof(WRITE_REQ) + 4);
2812 /* hard limit of CIFS_MAX_WSIZE */
2813 wsize = min_t(unsigned int, wsize, CIFS_MAX_WSIZE);
2819 is_path_accessible(int xid, struct cifs_tcon *tcon,
2820 struct cifs_sb_info *cifs_sb, const char *full_path)
2823 FILE_ALL_INFO *pfile_info;
2825 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
2826 if (pfile_info == NULL)
2829 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
2830 0 /* not legacy */, cifs_sb->local_nls,
2831 cifs_sb->mnt_cifs_flags &
2832 CIFS_MOUNT_MAP_SPECIAL_CHR);
2834 if (rc == -EOPNOTSUPP || rc == -EINVAL)
2835 rc = SMBQueryInformation(xid, tcon, full_path, pfile_info,
2836 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
2837 CIFS_MOUNT_MAP_SPECIAL_CHR);
2843 cleanup_volume_info_contents(struct smb_vol *volume_info)
2845 kfree(volume_info->username);
2846 kzfree(volume_info->password);
2847 kfree(volume_info->UNC);
2848 kfree(volume_info->UNCip);
2849 kfree(volume_info->domainname);
2850 kfree(volume_info->iocharset);
2851 kfree(volume_info->prepath);
2855 cifs_cleanup_volume_info(struct smb_vol *volume_info)
2859 cleanup_volume_info_contents(volume_info);
2864 #ifdef CONFIG_CIFS_DFS_UPCALL
2865 /* build_path_to_root returns full path to root when
2866 * we do not have an exiting connection (tcon) */
2868 build_unc_path_to_root(const struct smb_vol *vol,
2869 const struct cifs_sb_info *cifs_sb)
2871 char *full_path, *pos;
2872 unsigned int pplen = vol->prepath ? strlen(vol->prepath) : 0;
2873 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
2875 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
2876 if (full_path == NULL)
2877 return ERR_PTR(-ENOMEM);
2879 strncpy(full_path, vol->UNC, unc_len);
2880 pos = full_path + unc_len;
2883 strncpy(pos, vol->prepath, pplen);
2887 *pos = '\0'; /* add trailing null */
2888 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
2889 cFYI(1, "%s: full_path=%s", __func__, full_path);
2894 * Perform a dfs referral query for a share and (optionally) prefix
2896 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
2897 * to a string containing updated options for the submount. Otherwise it
2898 * will be left untouched.
2900 * Returns the rc from get_dfs_path to the caller, which can be used to
2901 * determine whether there were referrals.
2904 expand_dfs_referral(int xid, struct cifs_ses *pSesInfo,
2905 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
2909 unsigned int num_referrals = 0;
2910 struct dfs_info3_param *referrals = NULL;
2911 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
2913 full_path = build_unc_path_to_root(volume_info, cifs_sb);
2914 if (IS_ERR(full_path))
2915 return PTR_ERR(full_path);
2917 /* For DFS paths, skip the first '\' of the UNC */
2918 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
2920 rc = get_dfs_path(xid, pSesInfo , ref_path, cifs_sb->local_nls,
2921 &num_referrals, &referrals,
2922 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
2924 if (!rc && num_referrals > 0) {
2925 char *fake_devname = NULL;
2927 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
2928 full_path + 1, referrals,
2931 free_dfs_info_array(referrals, num_referrals);
2933 if (IS_ERR(mdata)) {
2934 rc = PTR_ERR(mdata);
2937 cleanup_volume_info_contents(volume_info);
2938 memset(volume_info, '\0', sizeof(*volume_info));
2939 rc = cifs_setup_volume_info(volume_info, mdata,
2942 kfree(fake_devname);
2943 kfree(cifs_sb->mountdata);
2944 cifs_sb->mountdata = mdata;
2952 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
2953 const char *devname)
2957 if (cifs_parse_mount_options(mount_data, devname, volume_info))
2960 if (volume_info->nullauth) {
2961 cFYI(1, "null user");
2962 volume_info->username = kzalloc(1, GFP_KERNEL);
2963 if (volume_info->username == NULL)
2965 } else if (volume_info->username) {
2966 /* BB fixme parse for domain name here */
2967 cFYI(1, "Username: %s", volume_info->username);
2969 cifserror("No username specified");
2970 /* In userspace mount helper we can get user name from alternate
2971 locations such as env variables and files on disk */
2975 /* this is needed for ASCII cp to Unicode converts */
2976 if (volume_info->iocharset == NULL) {
2977 /* load_nls_default cannot return null */
2978 volume_info->local_nls = load_nls_default();
2980 volume_info->local_nls = load_nls(volume_info->iocharset);
2981 if (volume_info->local_nls == NULL) {
2982 cERROR(1, "CIFS mount error: iocharset %s not found",
2983 volume_info->iocharset);
2992 cifs_get_volume_info(char *mount_data, const char *devname)
2995 struct smb_vol *volume_info;
2997 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
2999 return ERR_PTR(-ENOMEM);
3001 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3003 cifs_cleanup_volume_info(volume_info);
3004 volume_info = ERR_PTR(rc);
3011 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3015 struct cifs_ses *pSesInfo;
3016 struct cifs_tcon *tcon;
3017 struct TCP_Server_Info *srvTcp;
3019 struct tcon_link *tlink;
3020 #ifdef CONFIG_CIFS_DFS_UPCALL
3021 int referral_walks_count = 0;
3024 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3028 cifs_sb->bdi.ra_pages = default_backing_dev_info.ra_pages;
3030 #ifdef CONFIG_CIFS_DFS_UPCALL
3032 /* cleanup activities if we're chasing a referral */
3033 if (referral_walks_count) {
3035 cifs_put_tcon(tcon);
3037 cifs_put_smb_ses(pSesInfo);
3050 /* get a reference to a tcp session */
3051 srvTcp = cifs_get_tcp_session(volume_info);
3052 if (IS_ERR(srvTcp)) {
3053 rc = PTR_ERR(srvTcp);
3054 bdi_destroy(&cifs_sb->bdi);
3058 /* get a reference to a SMB session */
3059 pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
3060 if (IS_ERR(pSesInfo)) {
3061 rc = PTR_ERR(pSesInfo);
3063 goto mount_fail_check;
3066 /* search for existing tcon to this server share */
3067 tcon = cifs_get_tcon(pSesInfo, volume_info);
3071 goto remote_path_check;
3074 /* tell server which Unix caps we support */
3075 if (tcon->ses->capabilities & CAP_UNIX) {
3076 /* reset of caps checks mount to see if unix extensions
3077 disabled for just this mount */
3078 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3079 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3080 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3081 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3083 goto mount_fail_check;
3086 tcon->unix_ext = 0; /* server does not support them */
3088 /* do not care if following two calls succeed - informational */
3090 CIFSSMBQFSDeviceInfo(xid, tcon);
3091 CIFSSMBQFSAttributeInfo(xid, tcon);
3094 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
3095 cifs_sb->rsize = 1024 * 127;
3096 cFYI(DBG2, "no very large read support, rsize now 127K");
3098 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
3099 cifs_sb->rsize = min(cifs_sb->rsize,
3100 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
3102 cifs_sb->wsize = cifs_negotiate_wsize(tcon, volume_info);
3105 #ifdef CONFIG_CIFS_DFS_UPCALL
3107 * Perform an unconditional check for whether there are DFS
3108 * referrals for this path without prefix, to provide support
3109 * for DFS referrals from w2k8 servers which don't seem to respond
3110 * with PATH_NOT_COVERED to requests that include the prefix.
3111 * Chase the referral if found, otherwise continue normally.
3113 if (referral_walks_count == 0) {
3114 int refrc = expand_dfs_referral(xid, pSesInfo, volume_info,
3117 referral_walks_count++;
3118 goto try_mount_again;
3123 /* check if a whole path is not remote */
3125 /* build_path_to_root works only when we have a valid tcon */
3126 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3127 if (full_path == NULL) {
3129 goto mount_fail_check;
3131 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
3132 if (rc != 0 && rc != -EREMOTE) {
3134 goto mount_fail_check;
3139 /* get referral if needed */
3140 if (rc == -EREMOTE) {
3141 #ifdef CONFIG_CIFS_DFS_UPCALL
3142 if (referral_walks_count > MAX_NESTED_LINKS) {
3144 * BB: when we implement proper loop detection,
3145 * we will remove this check. But now we need it
3146 * to prevent an indefinite loop if 'DFS tree' is
3147 * misconfigured (i.e. has loops).
3150 goto mount_fail_check;
3153 rc = expand_dfs_referral(xid, pSesInfo, volume_info, cifs_sb,
3157 referral_walks_count++;
3158 goto try_mount_again;
3160 goto mount_fail_check;
3161 #else /* No DFS support, return error on mount */
3167 goto mount_fail_check;
3169 /* now, hang the tcon off of the superblock */
3170 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3171 if (tlink == NULL) {
3173 goto mount_fail_check;
3176 tlink->tl_uid = pSesInfo->linux_uid;
3177 tlink->tl_tcon = tcon;
3178 tlink->tl_time = jiffies;
3179 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3180 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3182 cifs_sb->master_tlink = tlink;
3183 spin_lock(&cifs_sb->tlink_tree_lock);
3184 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3185 spin_unlock(&cifs_sb->tlink_tree_lock);
3187 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
3191 /* on error free sesinfo and tcon struct if needed */
3193 /* If find_unc succeeded then rc == 0 so we can not end */
3194 /* up accidentally freeing someone elses tcon struct */
3196 cifs_put_tcon(tcon);
3198 cifs_put_smb_ses(pSesInfo);
3200 cifs_put_tcp_session(srvTcp);
3201 bdi_destroy(&cifs_sb->bdi);
3210 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3211 * pointer may be NULL.
3214 CIFSTCon(unsigned int xid, struct cifs_ses *ses,
3215 const char *tree, struct cifs_tcon *tcon,
3216 const struct nls_table *nls_codepage)
3218 struct smb_hdr *smb_buffer;
3219 struct smb_hdr *smb_buffer_response;
3222 unsigned char *bcc_ptr;
3225 __u16 bytes_left, count;
3230 smb_buffer = cifs_buf_get();
3231 if (smb_buffer == NULL)
3234 smb_buffer_response = smb_buffer;
3236 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3237 NULL /*no tid */ , 4 /*wct */ );
3239 smb_buffer->Mid = GetNextMid(ses->server);
3240 smb_buffer->Uid = ses->Suid;
3241 pSMB = (TCONX_REQ *) smb_buffer;
3242 pSMBr = (TCONX_RSP *) smb_buffer_response;
3244 pSMB->AndXCommand = 0xFF;
3245 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3246 bcc_ptr = &pSMB->Password[0];
3247 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3248 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3249 *bcc_ptr = 0; /* password is null byte */
3250 bcc_ptr++; /* skip password */
3251 /* already aligned so no need to do it below */
3253 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3254 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3255 specified as required (when that support is added to
3256 the vfs in the future) as only NTLM or the much
3257 weaker LANMAN (which we do not send by default) is accepted
3258 by Samba (not sure whether other servers allow
3259 NTLMv2 password here) */
3260 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3261 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3262 (ses->server->secType == LANMAN))
3263 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3264 ses->server->sec_mode &
3265 SECMODE_PW_ENCRYPT ? true : false,
3268 #endif /* CIFS_WEAK_PW_HASH */
3269 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3272 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3273 if (ses->capabilities & CAP_UNICODE) {
3274 /* must align unicode strings */
3275 *bcc_ptr = 0; /* null byte password */
3280 if (ses->server->sec_mode &
3281 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3282 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3284 if (ses->capabilities & CAP_STATUS32) {
3285 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3287 if (ses->capabilities & CAP_DFS) {
3288 smb_buffer->Flags2 |= SMBFLG2_DFS;
3290 if (ses->capabilities & CAP_UNICODE) {
3291 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3293 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3294 6 /* max utf8 char length in bytes */ *
3295 (/* server len*/ + 256 /* share len */), nls_codepage);
3296 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3297 bcc_ptr += 2; /* skip trailing null */
3298 } else { /* ASCII */
3299 strcpy(bcc_ptr, tree);
3300 bcc_ptr += strlen(tree) + 1;
3302 strcpy(bcc_ptr, "?????");
3303 bcc_ptr += strlen("?????");
3305 count = bcc_ptr - &pSMB->Password[0];
3306 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3307 pSMB->hdr.smb_buf_length) + count);
3308 pSMB->ByteCount = cpu_to_le16(count);
3310 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3313 /* above now done in SendReceive */
3314 if ((rc == 0) && (tcon != NULL)) {
3317 tcon->tidStatus = CifsGood;
3318 tcon->need_reconnect = false;
3319 tcon->tid = smb_buffer_response->Tid;
3320 bcc_ptr = pByteArea(smb_buffer_response);
3321 bytes_left = get_bcc(smb_buffer_response);
3322 length = strnlen(bcc_ptr, bytes_left - 2);
3323 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3329 /* skip service field (NB: this field is always ASCII) */
3331 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3332 (bcc_ptr[2] == 'C')) {
3333 cFYI(1, "IPC connection");
3336 } else if (length == 2) {
3337 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3338 /* the most common case */
3339 cFYI(1, "disk share connection");
3342 bcc_ptr += length + 1;
3343 bytes_left -= (length + 1);
3344 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3346 /* mostly informational -- no need to fail on error here */
3347 kfree(tcon->nativeFileSystem);
3348 tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
3349 bytes_left, is_unicode,
3352 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
3354 if ((smb_buffer_response->WordCount == 3) ||
3355 (smb_buffer_response->WordCount == 7))
3356 /* field is in same location */
3357 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3360 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
3361 } else if ((rc == 0) && tcon == NULL) {
3362 /* all we need to save for IPC$ connection */
3363 ses->ipc_tid = smb_buffer_response->Tid;
3366 cifs_buf_release(smb_buffer);
3371 cifs_umount(struct cifs_sb_info *cifs_sb)
3373 struct rb_root *root = &cifs_sb->tlink_tree;
3374 struct rb_node *node;
3375 struct tcon_link *tlink;
3377 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3379 spin_lock(&cifs_sb->tlink_tree_lock);
3380 while ((node = rb_first(root))) {
3381 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3382 cifs_get_tlink(tlink);
3383 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3384 rb_erase(node, root);
3386 spin_unlock(&cifs_sb->tlink_tree_lock);
3387 cifs_put_tlink(tlink);
3388 spin_lock(&cifs_sb->tlink_tree_lock);
3390 spin_unlock(&cifs_sb->tlink_tree_lock);
3392 bdi_destroy(&cifs_sb->bdi);
3393 kfree(cifs_sb->mountdata);
3394 unload_nls(cifs_sb->local_nls);
3398 int cifs_negotiate_protocol(unsigned int xid, struct cifs_ses *ses)
3401 struct TCP_Server_Info *server = ses->server;
3403 /* only send once per connect */
3404 if (server->maxBuf != 0)
3407 rc = CIFSSMBNegotiate(xid, ses);
3408 if (rc == -EAGAIN) {
3409 /* retry only once on 1st time connection */
3410 rc = CIFSSMBNegotiate(xid, ses);
3415 spin_lock(&GlobalMid_Lock);
3416 if (server->tcpStatus == CifsNeedNegotiate)
3417 server->tcpStatus = CifsGood;
3420 spin_unlock(&GlobalMid_Lock);
3428 int cifs_setup_session(unsigned int xid, struct cifs_ses *ses,
3429 struct nls_table *nls_info)
3432 struct TCP_Server_Info *server = ses->server;
3435 ses->capabilities = server->capabilities;
3436 if (linuxExtEnabled == 0)
3437 ses->capabilities &= (~CAP_UNIX);
3439 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3440 server->sec_mode, server->capabilities, server->timeAdj);
3442 rc = CIFS_SessSetup(xid, ses, nls_info);
3444 cERROR(1, "Send error in SessSetup = %d", rc);
3446 mutex_lock(&ses->server->srv_mutex);
3447 if (!server->session_estab) {
3448 server->session_key.response = ses->auth_key.response;
3449 server->session_key.len = ses->auth_key.len;
3450 server->sequence_number = 0x2;
3451 server->session_estab = true;
3452 ses->auth_key.response = NULL;
3454 mutex_unlock(&server->srv_mutex);
3456 cFYI(1, "CIFS Session Established successfully");
3457 spin_lock(&GlobalMid_Lock);
3458 ses->status = CifsGood;
3459 ses->need_reconnect = false;
3460 spin_unlock(&GlobalMid_Lock);
3463 kfree(ses->auth_key.response);
3464 ses->auth_key.response = NULL;
3465 ses->auth_key.len = 0;
3466 kfree(ses->ntlmssp);
3467 ses->ntlmssp = NULL;
3472 static struct cifs_tcon *
3473 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
3475 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3476 struct cifs_ses *ses;
3477 struct cifs_tcon *tcon = NULL;
3478 struct smb_vol *vol_info;
3479 char username[28]; /* big enough for "krb50x" + hex of ULONG_MAX 6+16 */
3480 /* We used to have this as MAX_USERNAME which is */
3481 /* way too big now (256 instead of 32) */
3483 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3484 if (vol_info == NULL) {
3485 tcon = ERR_PTR(-ENOMEM);
3489 snprintf(username, sizeof(username), "krb50x%x", fsuid);
3490 vol_info->username = username;
3491 vol_info->local_nls = cifs_sb->local_nls;
3492 vol_info->linux_uid = fsuid;
3493 vol_info->cred_uid = fsuid;
3494 vol_info->UNC = master_tcon->treeName;
3495 vol_info->retry = master_tcon->retry;
3496 vol_info->nocase = master_tcon->nocase;
3497 vol_info->local_lease = master_tcon->local_lease;
3498 vol_info->no_linux_ext = !master_tcon->unix_ext;
3500 /* FIXME: allow for other secFlg settings */
3501 vol_info->secFlg = CIFSSEC_MUST_KRB5;
3503 /* get a reference for the same TCP session */
3504 spin_lock(&cifs_tcp_ses_lock);
3505 ++master_tcon->ses->server->srv_count;
3506 spin_unlock(&cifs_tcp_ses_lock);
3508 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3510 tcon = (struct cifs_tcon *)ses;
3511 cifs_put_tcp_session(master_tcon->ses->server);
3515 tcon = cifs_get_tcon(ses, vol_info);
3517 cifs_put_smb_ses(ses);
3521 if (ses->capabilities & CAP_UNIX)
3522 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3530 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3532 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3536 cifs_sb_tcon_pending_wait(void *unused)
3539 return signal_pending(current) ? -ERESTARTSYS : 0;
3542 /* find and return a tlink with given uid */
3543 static struct tcon_link *
3544 tlink_rb_search(struct rb_root *root, uid_t uid)
3546 struct rb_node *node = root->rb_node;
3547 struct tcon_link *tlink;
3550 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3552 if (tlink->tl_uid > uid)
3553 node = node->rb_left;
3554 else if (tlink->tl_uid < uid)
3555 node = node->rb_right;
3562 /* insert a tcon_link into the tree */
3564 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3566 struct rb_node **new = &(root->rb_node), *parent = NULL;
3567 struct tcon_link *tlink;
3570 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3573 if (tlink->tl_uid > new_tlink->tl_uid)
3574 new = &((*new)->rb_left);
3576 new = &((*new)->rb_right);
3579 rb_link_node(&new_tlink->tl_rbnode, parent, new);
3580 rb_insert_color(&new_tlink->tl_rbnode, root);
3584 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3587 * If the superblock doesn't refer to a multiuser mount, then just return
3588 * the master tcon for the mount.
3590 * First, search the rbtree for an existing tcon for this fsuid. If one
3591 * exists, then check to see if it's pending construction. If it is then wait
3592 * for construction to complete. Once it's no longer pending, check to see if
3593 * it failed and either return an error or retry construction, depending on
3596 * If one doesn't exist then insert a new tcon_link struct into the tree and
3597 * try to construct a new one.
3600 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
3603 uid_t fsuid = current_fsuid();
3604 struct tcon_link *tlink, *newtlink;
3606 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
3607 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3609 spin_lock(&cifs_sb->tlink_tree_lock);
3610 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3612 cifs_get_tlink(tlink);
3613 spin_unlock(&cifs_sb->tlink_tree_lock);
3615 if (tlink == NULL) {
3616 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
3617 if (newtlink == NULL)
3618 return ERR_PTR(-ENOMEM);
3619 newtlink->tl_uid = fsuid;
3620 newtlink->tl_tcon = ERR_PTR(-EACCES);
3621 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
3622 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
3623 cifs_get_tlink(newtlink);
3625 spin_lock(&cifs_sb->tlink_tree_lock);
3626 /* was one inserted after previous search? */
3627 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3629 cifs_get_tlink(tlink);
3630 spin_unlock(&cifs_sb->tlink_tree_lock);
3632 goto wait_for_construction;
3635 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3636 spin_unlock(&cifs_sb->tlink_tree_lock);
3638 wait_for_construction:
3639 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
3640 cifs_sb_tcon_pending_wait,
3641 TASK_INTERRUPTIBLE);
3643 cifs_put_tlink(tlink);
3644 return ERR_PTR(ret);
3647 /* if it's good, return it */
3648 if (!IS_ERR(tlink->tl_tcon))
3651 /* return error if we tried this already recently */
3652 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
3653 cifs_put_tlink(tlink);
3654 return ERR_PTR(-EACCES);
3657 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
3658 goto wait_for_construction;
3661 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
3662 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
3663 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
3665 if (IS_ERR(tlink->tl_tcon)) {
3666 cifs_put_tlink(tlink);
3667 return ERR_PTR(-EACCES);
3674 * periodic workqueue job that scans tcon_tree for a superblock and closes
3678 cifs_prune_tlinks(struct work_struct *work)
3680 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
3682 struct rb_root *root = &cifs_sb->tlink_tree;
3683 struct rb_node *node = rb_first(root);
3684 struct rb_node *tmp;
3685 struct tcon_link *tlink;
3688 * Because we drop the spinlock in the loop in order to put the tlink
3689 * it's not guarded against removal of links from the tree. The only
3690 * places that remove entries from the tree are this function and
3691 * umounts. Because this function is non-reentrant and is canceled
3692 * before umount can proceed, this is safe.
3694 spin_lock(&cifs_sb->tlink_tree_lock);
3695 node = rb_first(root);
3696 while (node != NULL) {
3698 node = rb_next(tmp);
3699 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
3701 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
3702 atomic_read(&tlink->tl_count) != 0 ||
3703 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
3706 cifs_get_tlink(tlink);
3707 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3708 rb_erase(tmp, root);
3710 spin_unlock(&cifs_sb->tlink_tree_lock);
3711 cifs_put_tlink(tlink);
3712 spin_lock(&cifs_sb->tlink_tree_lock);
3714 spin_unlock(&cifs_sb->tlink_tree_lock);
3716 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,