blob: d6a972df033800eb0c00f6116b3c4b6bb309bd87 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/connect.c
3 *
Steve Frenchd185cda2009-04-30 17:45:10 +00004 * Copyright (C) International Business Machines Corp., 2002,2009
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
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.
11 *
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.
16 *
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
Steve Frenchfb8c4b12007-07-10 01:16:18 +000019 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Linus Torvalds1da177e2005-04-16 15:20:36 -070020 */
21#include <linux/fs.h>
22#include <linux/net.h>
23#include <linux/string.h>
24#include <linux/list.h>
25#include <linux/wait.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090026#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/pagemap.h>
28#include <linux/ctype.h>
29#include <linux/utsname.h>
30#include <linux/mempool.h>
Steve Frenchb8643e12005-04-28 22:41:07 -070031#include <linux/delay.h>
Steve Frenchf1914012005-08-18 09:37:34 -070032#include <linux/completion.h>
Igor Mammedovaaf737a2007-04-03 19:16:43 +000033#include <linux/kthread.h>
Steve French0ae0efa2005-10-10 10:57:19 -070034#include <linux/pagevec.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080035#include <linux/freezer.h>
Igor Mammedov5c2503a2009-04-21 19:31:05 +040036#include <linux/namei.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <asm/uaccess.h>
38#include <asm/processor.h>
Jeff Layton50b64e32009-06-02 06:55:20 -040039#include <linux/inet.h>
Paul Gortmaker143cb492011-07-01 14:23:34 -040040#include <linux/module.h>
Steve French0e2beda2009-01-30 21:24:41 +000041#include <net/ipv6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include "cifspdu.h"
43#include "cifsglob.h"
44#include "cifsproto.h"
45#include "cifs_unicode.h"
46#include "cifs_debug.h"
47#include "cifs_fs_sb.h"
48#include "ntlmssp.h"
49#include "nterr.h"
50#include "rfc1002pdu.h"
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +053051#include "fscache.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070052
53#define CIFS_PORT 445
54#define RFC1001_PORT 139
55
Jeff Laytonc74093b2011-01-11 07:24:23 -050056/* SMB echo "timeout" -- FIXME: tunable? */
57#define SMB_ECHO_INTERVAL (60 * HZ)
58
Linus Torvalds1da177e2005-04-16 15:20:36 -070059extern mempool_t *cifs_req_poolp;
60
Jeff Layton2de970f2010-10-06 19:51:12 -040061/* FIXME: should these be tunable? */
Jeff Layton9d002df2010-10-06 19:51:11 -040062#define TLINK_ERROR_EXPIRE (1 * HZ)
Jeff Layton2de970f2010-10-06 19:51:12 -040063#define TLINK_IDLE_EXPIRE (600 * HZ)
Jeff Layton9d002df2010-10-06 19:51:11 -040064
Pavel Shilovskya9f1b852010-12-13 19:08:35 +030065static int ip_connect(struct TCP_Server_Info *server);
66static int generic_ip_connect(struct TCP_Server_Info *server);
Jeff Laytonb647c352010-10-28 11:16:44 -040067static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
Jeff Layton2de970f2010-10-06 19:51:12 -040068static void cifs_prune_tlinks(struct work_struct *work);
Jeff Laytonb9bce2e2011-07-06 08:10:39 -040069static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
70 const char *devname);
Linus Torvalds1da177e2005-04-16 15:20:36 -070071
Jeff Laytond5c56052008-12-01 18:42:33 -050072/*
73 * cifs tcp session reconnection
74 *
75 * mark tcp session as reconnecting so temporarily locked
76 * mark all smb sessions as reconnecting for tcp session
77 * reconnect tcp session
78 * wake up waiters on reconnection? - (not needed currently)
79 */
Steve French2cd646a2006-09-28 19:43:08 +000080static int
Linus Torvalds1da177e2005-04-16 15:20:36 -070081cifs_reconnect(struct TCP_Server_Info *server)
82{
83 int rc = 0;
Jeff Laytonf1987b42008-11-15 11:12:47 -050084 struct list_head *tmp, *tmp2;
Steve French96daf2b2011-05-27 04:34:02 +000085 struct cifs_ses *ses;
86 struct cifs_tcon *tcon;
Steve Frenchfb8c4b12007-07-10 01:16:18 +000087 struct mid_q_entry *mid_entry;
Jeff Layton3c1105d2011-05-22 07:09:13 -040088 struct list_head retry_list;
Steve French50c2f752007-07-13 00:33:32 +000089
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 spin_lock(&GlobalMid_Lock);
Jeff Layton469ee612008-10-16 18:46:39 +000091 if (server->tcpStatus == CifsExiting) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +000092 /* the demux thread will exit normally
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 next time through the loop */
94 spin_unlock(&GlobalMid_Lock);
95 return rc;
96 } else
97 server->tcpStatus = CifsNeedReconnect;
98 spin_unlock(&GlobalMid_Lock);
99 server->maxBuf = 0;
100
Joe Perchesb6b38f72010-04-21 03:50:45 +0000101 cFYI(1, "Reconnecting tcp session");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102
103 /* before reconnecting the tcp session, mark the smb session (uid)
104 and the tid bad so they are not used until reconnected */
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500105 cFYI(1, "%s: marking sessions and tcons for reconnect", __func__);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530106 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -0500107 list_for_each(tmp, &server->smb_ses_list) {
Steve French96daf2b2011-05-27 04:34:02 +0000108 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
Jeff Layton14fbf502008-11-14 13:53:46 -0500109 ses->need_reconnect = true;
110 ses->ipc_tid = 0;
Jeff Laytonf1987b42008-11-15 11:12:47 -0500111 list_for_each(tmp2, &ses->tcon_list) {
Steve French96daf2b2011-05-27 04:34:02 +0000112 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
Jeff Laytonf1987b42008-11-15 11:12:47 -0500113 tcon->need_reconnect = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530116 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500117
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 /* do not want to be sending data on a socket we are freeing */
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500119 cFYI(1, "%s: tearing down socket", __func__);
Jeff Layton72ca5452008-12-01 07:09:36 -0500120 mutex_lock(&server->srv_mutex);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000121 if (server->ssocket) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000122 cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
123 server->ssocket->flags);
Trond Myklebust91cf45f2007-11-12 18:10:39 -0800124 kernel_sock_shutdown(server->ssocket, SHUT_WR);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000125 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
Steve French467a8f82007-06-27 22:41:32 +0000126 server->ssocket->state,
Joe Perchesb6b38f72010-04-21 03:50:45 +0000127 server->ssocket->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 sock_release(server->ssocket);
129 server->ssocket = NULL;
130 }
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -0500131 server->sequence_number = 0;
132 server->session_estab = false;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500133 kfree(server->session_key.response);
134 server->session_key.response = NULL;
135 server->session_key.len = 0;
Steve Frenchfda35942011-01-20 18:06:34 +0000136 server->lstrp = jiffies;
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500137 mutex_unlock(&server->srv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500139 /* mark submitted MIDs for retry and issue callback */
Jeff Layton3c1105d2011-05-22 07:09:13 -0400140 INIT_LIST_HEAD(&retry_list);
141 cFYI(1, "%s: moving mids to private list", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 spin_lock(&GlobalMid_Lock);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500143 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
144 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
145 if (mid_entry->midState == MID_REQUEST_SUBMITTED)
Steve Frenchad8b15f2008-08-08 21:10:16 +0000146 mid_entry->midState = MID_RETRY_NEEDED;
Jeff Layton3c1105d2011-05-22 07:09:13 -0400147 list_move(&mid_entry->qhead, &retry_list);
148 }
149 spin_unlock(&GlobalMid_Lock);
150
151 cFYI(1, "%s: issuing mid callbacks", __func__);
152 list_for_each_safe(tmp, tmp2, &retry_list) {
153 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500154 list_del_init(&mid_entry->qhead);
155 mid_entry->callback(mid_entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157
Jeff Layton7fdbaa12011-06-10 16:14:57 -0400158 do {
Steve French6c3d8902006-07-31 22:46:20 +0000159 try_to_freeze();
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300160
161 /* we should try only the port we connected to before */
162 rc = generic_ip_connect(server);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000163 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000164 cFYI(1, "reconnect error %d", rc);
Steve French0cb766a2005-04-28 22:41:11 -0700165 msleep(3000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 } else {
167 atomic_inc(&tcpSesReconnectCount);
168 spin_lock(&GlobalMid_Lock);
Jeff Layton469ee612008-10-16 18:46:39 +0000169 if (server->tcpStatus != CifsExiting)
Steve Frenchfd88ce92011-04-12 01:01:14 +0000170 server->tcpStatus = CifsNeedNegotiate;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000171 spin_unlock(&GlobalMid_Lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 }
Jeff Layton7fdbaa12011-06-10 16:14:57 -0400173 } while (server->tcpStatus == CifsNeedReconnect);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500174
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 return rc;
176}
177
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000178/*
Steve Frenche4eb2952005-04-28 22:41:09 -0700179 return codes:
180 0 not a transact2, or all data present
181 >0 transact2 with that much data missing
182 -EINVAL = invalid transact2
183
184 */
Jeff Laytonc974bef2011-10-11 06:41:32 -0400185static int check2ndT2(struct smb_hdr *pSMB)
Steve Frenche4eb2952005-04-28 22:41:09 -0700186{
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000187 struct smb_t2_rsp *pSMBt;
Steve Frenche4eb2952005-04-28 22:41:09 -0700188 int remaining;
Jeff Layton26ec2542011-01-20 13:36:51 -0500189 __u16 total_data_size, data_in_this_rsp;
Steve Frenche4eb2952005-04-28 22:41:09 -0700190
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000191 if (pSMB->Command != SMB_COM_TRANSACTION2)
Steve Frenche4eb2952005-04-28 22:41:09 -0700192 return 0;
193
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000194 /* check for plausible wct, bcc and t2 data and parm sizes */
195 /* check for parm and data offset going beyond end of smb */
196 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000197 cFYI(1, "invalid transact2 word count");
Steve Frenche4eb2952005-04-28 22:41:09 -0700198 return -EINVAL;
199 }
200
201 pSMBt = (struct smb_t2_rsp *)pSMB;
202
Jeff Layton26ec2542011-01-20 13:36:51 -0500203 total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
204 data_in_this_rsp = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
Steve Frenche4eb2952005-04-28 22:41:09 -0700205
Jeff Laytonc0c7b902011-03-31 17:32:54 -0400206 if (total_data_size == data_in_this_rsp)
Steve Frenche4eb2952005-04-28 22:41:09 -0700207 return 0;
Jeff Laytonc0c7b902011-03-31 17:32:54 -0400208 else if (total_data_size < data_in_this_rsp) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000209 cFYI(1, "total data %d smaller than data in frame %d",
210 total_data_size, data_in_this_rsp);
Steve Frenche4eb2952005-04-28 22:41:09 -0700211 return -EINVAL;
Steve Frenche4eb2952005-04-28 22:41:09 -0700212 }
Jeff Laytonc0c7b902011-03-31 17:32:54 -0400213
214 remaining = total_data_size - data_in_this_rsp;
215
216 cFYI(1, "missing %d bytes from transact2, check next response",
217 remaining);
Jeff Laytonc974bef2011-10-11 06:41:32 -0400218 if (total_data_size > CIFSMaxBufSize) {
Jeff Laytonc0c7b902011-03-31 17:32:54 -0400219 cERROR(1, "TotalDataSize %d is over maximum buffer %d",
Jeff Laytonc974bef2011-10-11 06:41:32 -0400220 total_data_size, CIFSMaxBufSize);
Jeff Laytonc0c7b902011-03-31 17:32:54 -0400221 return -EINVAL;
222 }
223 return remaining;
Steve Frenche4eb2952005-04-28 22:41:09 -0700224}
225
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000226static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
Steve Frenche4eb2952005-04-28 22:41:09 -0700227{
228 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
229 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000230 char *data_area_of_target;
231 char *data_area_of_buf2;
Jeff Layton26ec2542011-01-20 13:36:51 -0500232 int remaining;
Jeff Layton2a2047bc2011-04-27 13:29:49 -0400233 unsigned int byte_count, total_in_buf;
234 __u16 total_data_size, total_in_buf2;
Steve Frenche4eb2952005-04-28 22:41:09 -0700235
Jeff Layton26ec2542011-01-20 13:36:51 -0500236 total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
Steve Frenche4eb2952005-04-28 22:41:09 -0700237
Jeff Layton26ec2542011-01-20 13:36:51 -0500238 if (total_data_size !=
239 get_unaligned_le16(&pSMB2->t2_rsp.TotalDataCount))
Joe Perchesb6b38f72010-04-21 03:50:45 +0000240 cFYI(1, "total data size of primary and secondary t2 differ");
Steve Frenche4eb2952005-04-28 22:41:09 -0700241
Jeff Layton26ec2542011-01-20 13:36:51 -0500242 total_in_buf = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
Steve Frenche4eb2952005-04-28 22:41:09 -0700243
244 remaining = total_data_size - total_in_buf;
Steve French50c2f752007-07-13 00:33:32 +0000245
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000246 if (remaining < 0)
Jeff Layton2a2047bc2011-04-27 13:29:49 -0400247 return -EPROTO;
Steve Frenche4eb2952005-04-28 22:41:09 -0700248
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000249 if (remaining == 0) /* nothing to do, ignore */
Steve Frenche4eb2952005-04-28 22:41:09 -0700250 return 0;
Steve French50c2f752007-07-13 00:33:32 +0000251
Jeff Layton26ec2542011-01-20 13:36:51 -0500252 total_in_buf2 = get_unaligned_le16(&pSMB2->t2_rsp.DataCount);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000253 if (remaining < total_in_buf2) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000254 cFYI(1, "transact2 2nd response contains too much data");
Steve Frenche4eb2952005-04-28 22:41:09 -0700255 }
256
257 /* find end of first SMB data area */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000258 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
Jeff Layton26ec2542011-01-20 13:36:51 -0500259 get_unaligned_le16(&pSMBt->t2_rsp.DataOffset);
Steve Frenche4eb2952005-04-28 22:41:09 -0700260 /* validate target area */
261
Jeff Layton26ec2542011-01-20 13:36:51 -0500262 data_area_of_buf2 = (char *)&pSMB2->hdr.Protocol +
263 get_unaligned_le16(&pSMB2->t2_rsp.DataOffset);
Steve Frenche4eb2952005-04-28 22:41:09 -0700264
265 data_area_of_target += total_in_buf;
266
267 /* copy second buffer into end of first buffer */
Steve Frenche4eb2952005-04-28 22:41:09 -0700268 total_in_buf += total_in_buf2;
Jeff Layton2a2047bc2011-04-27 13:29:49 -0400269 /* is the result too big for the field? */
270 if (total_in_buf > USHRT_MAX)
271 return -EPROTO;
Jeff Layton26ec2542011-01-20 13:36:51 -0500272 put_unaligned_le16(total_in_buf, &pSMBt->t2_rsp.DataCount);
Jeff Layton2a2047bc2011-04-27 13:29:49 -0400273
274 /* fix up the BCC */
Jeff Layton820a8032011-05-04 08:05:26 -0400275 byte_count = get_bcc(pTargetSMB);
Steve Frenche4eb2952005-04-28 22:41:09 -0700276 byte_count += total_in_buf2;
Jeff Layton2a2047bc2011-04-27 13:29:49 -0400277 /* is the result too big for the field? */
278 if (byte_count > USHRT_MAX)
279 return -EPROTO;
Jeff Layton820a8032011-05-04 08:05:26 -0400280 put_bcc(byte_count, pTargetSMB);
Steve Frenche4eb2952005-04-28 22:41:09 -0700281
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000282 byte_count = be32_to_cpu(pTargetSMB->smb_buf_length);
Steve Frenche4eb2952005-04-28 22:41:09 -0700283 byte_count += total_in_buf2;
Jeff Layton2a2047bc2011-04-27 13:29:49 -0400284 /* don't allow buffer to overflow */
285 if (byte_count > CIFSMaxBufSize)
286 return -ENOBUFS;
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000287 pTargetSMB->smb_buf_length = cpu_to_be32(byte_count);
Steve Frenche4eb2952005-04-28 22:41:09 -0700288
Jeff Layton2a2047bc2011-04-27 13:29:49 -0400289 memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
290
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000291 if (remaining == total_in_buf2) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000292 cFYI(1, "found the last secondary response");
Steve Frenche4eb2952005-04-28 22:41:09 -0700293 return 0; /* we are done */
294 } else /* more responses to go */
295 return 1;
Steve Frenche4eb2952005-04-28 22:41:09 -0700296}
297
Jeff Laytonc74093b2011-01-11 07:24:23 -0500298static void
299cifs_echo_request(struct work_struct *work)
300{
301 int rc;
302 struct TCP_Server_Info *server = container_of(work,
303 struct TCP_Server_Info, echo.work);
304
Jeff Layton247ec9b2011-02-04 17:09:50 -0500305 /*
Jeff Layton195291e2011-02-09 12:01:42 -0500306 * We cannot send an echo until the NEGOTIATE_PROTOCOL request is
307 * done, which is indicated by maxBuf != 0. Also, no need to ping if
308 * we got a response recently
Jeff Layton247ec9b2011-02-04 17:09:50 -0500309 */
Jeff Layton195291e2011-02-09 12:01:42 -0500310 if (server->maxBuf == 0 ||
Jeff Layton247ec9b2011-02-04 17:09:50 -0500311 time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
Jeff Laytonc74093b2011-01-11 07:24:23 -0500312 goto requeue_echo;
313
314 rc = CIFSSMBEcho(server);
315 if (rc)
316 cFYI(1, "Unable to send echo request to server: %s",
317 server->hostname);
318
319requeue_echo:
320 queue_delayed_work(system_nrt_wq, &server->echo, SMB_ECHO_INTERVAL);
321}
322
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400323static bool
Jeff Layton2a37ef92011-10-19 15:29:23 -0400324allocate_buffers(struct TCP_Server_Info *server)
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400325{
Jeff Layton2a37ef92011-10-19 15:29:23 -0400326 if (!server->bigbuf) {
327 server->bigbuf = (char *)cifs_buf_get();
328 if (!server->bigbuf) {
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400329 cERROR(1, "No memory for large SMB response");
330 msleep(3000);
331 /* retry will check if exiting */
332 return false;
333 }
Jeff Layton2a37ef92011-10-19 15:29:23 -0400334 } else if (server->large_buf) {
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400335 /* we are reusing a dirty large buf, clear its start */
Jeff Layton2a37ef92011-10-19 15:29:23 -0400336 memset(server->bigbuf, 0, sizeof(struct smb_hdr));
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400337 }
338
Jeff Layton2a37ef92011-10-19 15:29:23 -0400339 if (!server->smallbuf) {
340 server->smallbuf = (char *)cifs_small_buf_get();
341 if (!server->smallbuf) {
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400342 cERROR(1, "No memory for SMB response");
343 msleep(1000);
344 /* retry will check if exiting */
345 return false;
346 }
347 /* beginning of smb buffer is cleared in our buf_get */
348 } else {
349 /* if existing small buf clear beginning */
Jeff Layton2a37ef92011-10-19 15:29:23 -0400350 memset(server->smallbuf, 0, sizeof(struct smb_hdr));
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400351 }
352
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400353 return true;
354}
355
Jeff Laytonba749e62011-10-11 06:41:32 -0400356static bool
357server_unresponsive(struct TCP_Server_Info *server)
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400358{
Jeff Laytonba749e62011-10-11 06:41:32 -0400359 if (echo_retries > 0 && server->tcpStatus == CifsGood &&
360 time_after(jiffies, server->lstrp +
361 (echo_retries * SMB_ECHO_INTERVAL))) {
362 cERROR(1, "Server %s has not responded in %d seconds. "
363 "Reconnecting...", server->hostname,
364 (echo_retries * SMB_ECHO_INTERVAL / HZ));
365 cifs_reconnect(server);
366 wake_up(&server->response_q);
367 return true;
368 }
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400369
Jeff Laytonba749e62011-10-11 06:41:32 -0400370 return false;
371}
372
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400373/*
374 * kvec_array_init - clone a kvec array, and advance into it
375 * @new: pointer to memory for cloned array
376 * @iov: pointer to original array
377 * @nr_segs: number of members in original array
378 * @bytes: number of bytes to advance into the cloned array
379 *
380 * This function will copy the array provided in iov to a section of memory
381 * and advance the specified number of bytes into the new array. It returns
382 * the number of segments in the new array. "new" must be at least as big as
383 * the original iov array.
384 */
385static unsigned int
386kvec_array_init(struct kvec *new, struct kvec *iov, unsigned int nr_segs,
387 size_t bytes)
388{
389 size_t base = 0;
390
391 while (bytes || !iov->iov_len) {
392 int copy = min(bytes, iov->iov_len);
393
394 bytes -= copy;
395 base += copy;
396 if (iov->iov_len == base) {
397 iov++;
398 nr_segs--;
399 base = 0;
400 }
401 }
402 memcpy(new, iov, sizeof(*iov) * nr_segs);
403 new->iov_base += base;
404 new->iov_len -= base;
405 return nr_segs;
406}
407
Jeff Layton1041e3f2011-10-19 15:28:27 -0400408static struct kvec *
409get_server_iovec(struct TCP_Server_Info *server, unsigned int nr_segs)
410{
411 struct kvec *new_iov;
412
413 if (server->iov && nr_segs <= server->nr_iov)
414 return server->iov;
415
416 /* not big enough -- allocate a new one and release the old */
417 new_iov = kmalloc(sizeof(*new_iov) * nr_segs, GFP_NOFS);
418 if (new_iov) {
419 kfree(server->iov);
420 server->iov = new_iov;
421 server->nr_iov = nr_segs;
422 }
423 return new_iov;
424}
425
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400426int
427cifs_readv_from_socket(struct TCP_Server_Info *server, struct kvec *iov_orig,
428 unsigned int nr_segs, unsigned int to_read)
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400429{
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400430 int length = 0;
431 int total_read;
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400432 unsigned int segs;
Jeff Laytone831e6c2011-10-11 06:41:32 -0400433 struct msghdr smb_msg;
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400434 struct kvec *iov;
435
Jeff Layton1041e3f2011-10-19 15:28:27 -0400436 iov = get_server_iovec(server, nr_segs);
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400437 if (!iov)
438 return -ENOMEM;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400439
Jeff Laytone831e6c2011-10-11 06:41:32 -0400440 smb_msg.msg_control = NULL;
441 smb_msg.msg_controllen = 0;
442
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400443 for (total_read = 0; to_read; total_read += length, to_read -= length) {
Jeff Laytonba749e62011-10-11 06:41:32 -0400444 if (server_unresponsive(server)) {
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400445 total_read = -EAGAIN;
Jeff Laytonba749e62011-10-11 06:41:32 -0400446 break;
447 }
448
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400449 segs = kvec_array_init(iov, iov_orig, nr_segs, total_read);
450
451 length = kernel_recvmsg(server->ssocket, &smb_msg,
452 iov, segs, to_read, 0);
453
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400454 if (server->tcpStatus == CifsExiting) {
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400455 total_read = -ESHUTDOWN;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400456 break;
457 } else if (server->tcpStatus == CifsNeedReconnect) {
458 cifs_reconnect(server);
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400459 total_read = -EAGAIN;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400460 break;
461 } else if (length == -ERESTARTSYS ||
462 length == -EAGAIN ||
463 length == -EINTR) {
464 /*
465 * Minimum sleep to prevent looping, allowing socket
466 * to clear and app threads to set tcpStatus
467 * CifsNeedReconnect if server hung.
468 */
469 usleep_range(1000, 2000);
470 length = 0;
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400471 continue;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400472 } else if (length <= 0) {
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400473 cFYI(1, "Received no data or error: expecting %d "
474 "got %d", to_read, length);
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400475 cifs_reconnect(server);
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400476 total_read = -EAGAIN;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400477 break;
478 }
479 }
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400480 return total_read;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400481}
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400482
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400483int
484cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
485 unsigned int to_read)
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400486{
487 struct kvec iov;
488
489 iov.iov_base = buf;
490 iov.iov_len = to_read;
491
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400492 return cifs_readv_from_socket(server, &iov, 1, to_read);
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400493}
494
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400495static bool
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400496is_smb_response(struct TCP_Server_Info *server, unsigned char type)
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400497{
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400498 /*
499 * The first byte big endian of the length field,
500 * is actually not part of the length but the type
501 * with the most common, zero, as regular data.
502 */
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400503 switch (type) {
504 case RFC1002_SESSION_MESSAGE:
505 /* Regular SMB response */
506 return true;
507 case RFC1002_SESSION_KEEP_ALIVE:
508 cFYI(1, "RFC 1002 session keep alive");
509 break;
510 case RFC1002_POSITIVE_SESSION_RESPONSE:
511 cFYI(1, "RFC 1002 positive session response");
512 break;
513 case RFC1002_NEGATIVE_SESSION_RESPONSE:
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400514 /*
515 * We get this from Windows 98 instead of an error on
516 * SMB negprot response.
517 */
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400518 cFYI(1, "RFC 1002 negative session response");
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400519 /* give server a second to clean up */
520 msleep(1000);
521 /*
522 * Always try 445 first on reconnect since we get NACK
523 * on some if we ever connected to port 139 (the NACK
524 * is since we do not begin with RFC1001 session
525 * initialize frame).
526 */
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400527 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400528 cifs_reconnect(server);
529 wake_up(&server->response_q);
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400530 break;
531 default:
532 cERROR(1, "RFC 1002 unknown response type 0x%x", type);
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400533 cifs_reconnect(server);
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400534 }
535
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400536 return false;
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400537}
538
Pavel Shilovskyad69bae2011-08-01 13:19:43 +0400539static struct mid_q_entry *
Jeff Laytonea1f4502011-10-19 15:29:05 -0400540find_mid(struct TCP_Server_Info *server, struct smb_hdr *buf)
Pavel Shilovskyad69bae2011-08-01 13:19:43 +0400541{
Jeff Laytonea1f4502011-10-19 15:29:05 -0400542 struct mid_q_entry *mid;
Pavel Shilovskyad69bae2011-08-01 13:19:43 +0400543
544 spin_lock(&GlobalMid_Lock);
Jeff Laytonea1f4502011-10-19 15:29:05 -0400545 list_for_each_entry(mid, &server->pending_mid_q, qhead) {
546 if (mid->mid == buf->Mid &&
547 mid->midState == MID_REQUEST_SUBMITTED &&
548 mid->command == buf->Command) {
549 spin_unlock(&GlobalMid_Lock);
550 return mid;
Pavel Shilovskyad69bae2011-08-01 13:19:43 +0400551 }
Pavel Shilovskyad69bae2011-08-01 13:19:43 +0400552 }
553 spin_unlock(&GlobalMid_Lock);
Jeff Laytonea1f4502011-10-19 15:29:05 -0400554 return NULL;
555}
Pavel Shilovskyad69bae2011-08-01 13:19:43 +0400556
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400557void
558dequeue_mid(struct mid_q_entry *mid, bool malformed)
Jeff Laytonea1f4502011-10-19 15:29:05 -0400559{
560#ifdef CONFIG_CIFS_STATS2
561 mid->when_received = jiffies;
562#endif
563 spin_lock(&GlobalMid_Lock);
564 if (!malformed)
565 mid->midState = MID_RESPONSE_RECEIVED;
566 else
567 mid->midState = MID_RESPONSE_MALFORMED;
568 list_del_init(&mid->qhead);
569 spin_unlock(&GlobalMid_Lock);
570}
571
Jeff Laytonc8054eb2011-10-19 15:29:31 -0400572static void
573handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
574 struct smb_hdr *buf, int malformed)
Jeff Laytonea1f4502011-10-19 15:29:05 -0400575{
Jeff Laytonffc00e22011-10-19 15:29:13 -0400576 if (malformed == 0 && check2ndT2(buf) > 0) {
577 mid->multiRsp = true;
Jeff Laytonea1f4502011-10-19 15:29:05 -0400578 if (mid->resp_buf) {
579 /* merge response - fix up 1st*/
Jeff Laytonffc00e22011-10-19 15:29:13 -0400580 malformed = coalesce_t2(buf, mid->resp_buf);
581 if (malformed > 0)
Jeff Laytonc8054eb2011-10-19 15:29:31 -0400582 return;
Jeff Laytonffc00e22011-10-19 15:29:13 -0400583
Jeff Laytonea1f4502011-10-19 15:29:05 -0400584 /* All parts received or packet is malformed. */
585 mid->multiEnd = true;
Jeff Laytonc8054eb2011-10-19 15:29:31 -0400586 return dequeue_mid(mid, malformed);
Jeff Laytonea1f4502011-10-19 15:29:05 -0400587 }
Jeff Layton2a37ef92011-10-19 15:29:23 -0400588 if (!server->large_buf) {
Jeff Laytonea1f4502011-10-19 15:29:05 -0400589 /*FIXME: switch to already allocated largebuf?*/
590 cERROR(1, "1st trans2 resp needs bigbuf");
591 } else {
592 /* Have first buffer */
593 mid->resp_buf = buf;
594 mid->largeBuf = true;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400595 server->bigbuf = NULL;
Jeff Laytonea1f4502011-10-19 15:29:05 -0400596 }
Jeff Laytonc8054eb2011-10-19 15:29:31 -0400597 return;
Jeff Laytonea1f4502011-10-19 15:29:05 -0400598 }
599 mid->resp_buf = buf;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400600 mid->largeBuf = server->large_buf;
601 /* Was previous buf put in mpx struct for multi-rsp? */
602 if (!mid->multiRsp) {
603 /* smb buffer will be freed by user thread */
604 if (server->large_buf)
605 server->bigbuf = NULL;
606 else
607 server->smallbuf = NULL;
608 }
Jeff Laytonffc00e22011-10-19 15:29:13 -0400609 dequeue_mid(mid, malformed);
Pavel Shilovskyad69bae2011-08-01 13:19:43 +0400610}
611
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400612static void clean_demultiplex_info(struct TCP_Server_Info *server)
613{
614 int length;
615
616 /* take it off the list, if it's not already */
617 spin_lock(&cifs_tcp_ses_lock);
618 list_del_init(&server->tcp_ses_list);
619 spin_unlock(&cifs_tcp_ses_lock);
620
621 spin_lock(&GlobalMid_Lock);
622 server->tcpStatus = CifsExiting;
623 spin_unlock(&GlobalMid_Lock);
624 wake_up_all(&server->response_q);
625
626 /*
627 * Check if we have blocked requests that need to free. Note that
628 * cifs_max_pending is normally 50, but can be set at module install
629 * time to as little as two.
630 */
631 spin_lock(&GlobalMid_Lock);
632 if (atomic_read(&server->inFlight) >= cifs_max_pending)
633 atomic_set(&server->inFlight, cifs_max_pending - 1);
634 /*
635 * We do not want to set the max_pending too low or we could end up
636 * with the counter going negative.
637 */
638 spin_unlock(&GlobalMid_Lock);
639 /*
640 * Although there should not be any requests blocked on this queue it
641 * can not hurt to be paranoid and try to wake up requests that may
642 * haven been blocked when more than 50 at time were on the wire to the
643 * same server - they now will see the session is in exit state and get
644 * out of SendReceive.
645 */
646 wake_up_all(&server->request_q);
647 /* give those requests time to exit */
648 msleep(125);
649
650 if (server->ssocket) {
651 sock_release(server->ssocket);
652 server->ssocket = NULL;
653 }
654
655 if (!list_empty(&server->pending_mid_q)) {
656 struct list_head dispose_list;
657 struct mid_q_entry *mid_entry;
658 struct list_head *tmp, *tmp2;
659
660 INIT_LIST_HEAD(&dispose_list);
661 spin_lock(&GlobalMid_Lock);
662 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
663 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
664 cFYI(1, "Clearing mid 0x%x", mid_entry->mid);
665 mid_entry->midState = MID_SHUTDOWN;
666 list_move(&mid_entry->qhead, &dispose_list);
667 }
668 spin_unlock(&GlobalMid_Lock);
669
670 /* now walk dispose list and issue callbacks */
671 list_for_each_safe(tmp, tmp2, &dispose_list) {
672 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
673 cFYI(1, "Callback mid 0x%x", mid_entry->mid);
674 list_del_init(&mid_entry->qhead);
675 mid_entry->callback(mid_entry);
676 }
677 /* 1/8th of sec is more than enough time for them to exit */
678 msleep(125);
679 }
680
681 if (!list_empty(&server->pending_mid_q)) {
682 /*
683 * mpx threads have not exited yet give them at least the smb
684 * send timeout time for long ops.
685 *
686 * Due to delays on oplock break requests, we need to wait at
687 * least 45 seconds before giving up on a request getting a
688 * response and going ahead and killing cifsd.
689 */
690 cFYI(1, "Wait for exit from demultiplex thread");
691 msleep(46000);
692 /*
693 * If threads still have not exited they are probably never
694 * coming home not much else we can do but free the memory.
695 */
696 }
697
698 kfree(server->hostname);
Jeff Layton1041e3f2011-10-19 15:28:27 -0400699 kfree(server->iov);
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400700 kfree(server);
701
702 length = atomic_dec_return(&tcpSesAllocCount);
703 if (length > 0)
704 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
705 GFP_KERNEL);
706}
707
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400708static int
Jeff Laytone9097ab2011-10-19 15:29:40 -0400709standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
710{
711 int length;
712 char *buf = server->smallbuf;
713 struct smb_hdr *smb_buffer = (struct smb_hdr *)buf;
714 unsigned int pdu_length = be32_to_cpu(smb_buffer->smb_buf_length);
715
716 /* make sure this will fit in a large buffer */
717 if (pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
718 cERROR(1, "SMB response too long (%u bytes)",
719 pdu_length);
720 cifs_reconnect(server);
721 wake_up(&server->response_q);
722 return -EAGAIN;
723 }
724
725 /* switch to large buffer if too big for a small one */
726 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
727 server->large_buf = true;
728 memcpy(server->bigbuf, server->smallbuf, server->total_read);
729 buf = server->bigbuf;
730 smb_buffer = (struct smb_hdr *)buf;
731 }
732
733 /* now read the rest */
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400734 length = cifs_read_from_socket(server,
Jeff Laytone9097ab2011-10-19 15:29:40 -0400735 buf + sizeof(struct smb_hdr) - 1,
736 pdu_length - sizeof(struct smb_hdr) + 1 + 4);
737 if (length < 0)
738 return length;
739 server->total_read += length;
740
741 dump_smb(smb_buffer, server->total_read);
742
743 /*
744 * We know that we received enough to get to the MID as we
745 * checked the pdu_length earlier. Now check to see
746 * if the rest of the header is OK. We borrow the length
747 * var for the rest of the loop to avoid a new stack var.
748 *
749 * 48 bytes is enough to display the header and a little bit
750 * into the payload for debugging purposes.
751 */
752 length = checkSMB(smb_buffer, smb_buffer->Mid, server->total_read);
753 if (length != 0)
754 cifs_dump_mem("Bad SMB: ", buf,
755 min_t(unsigned int, server->total_read, 48));
756
757 if (mid)
758 handle_mid(mid, server, smb_buffer, length);
759
760 return length;
761}
762
763static int
Al Viro7c97c202011-06-21 08:51:28 -0400764cifs_demultiplex_thread(void *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765{
766 int length;
Al Viro7c97c202011-06-21 08:51:28 -0400767 struct TCP_Server_Info *server = p;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400768 unsigned int pdu_length;
769 char *buf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 struct smb_hdr *smb_buffer = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 struct task_struct *task_to_wake = NULL;
772 struct mid_q_entry *mid_entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 current->flags |= PF_MEMALLOC;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000775 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
Jeff Layton93d0ec82008-08-02 08:00:48 -0400776
777 length = atomic_inc_return(&tcpSesAllocCount);
778 if (length > 1)
Steve French26f57362007-08-30 22:09:15 +0000779 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
780 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781
Rafael J. Wysocki83144182007-07-17 04:03:35 -0700782 set_freezable();
Jeff Layton469ee612008-10-16 18:46:39 +0000783 while (server->tcpStatus != CifsExiting) {
Steve Frenchede13272005-08-30 20:10:14 -0700784 if (try_to_freeze())
785 continue;
Steve Frenchb8643e12005-04-28 22:41:07 -0700786
Jeff Layton2a37ef92011-10-19 15:29:23 -0400787 if (!allocate_buffers(server))
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400788 continue;
Steve Frenchb8643e12005-04-28 22:41:07 -0700789
Jeff Layton2a37ef92011-10-19 15:29:23 -0400790 server->large_buf = false;
791 smb_buffer = (struct smb_hdr *)server->smallbuf;
792 buf = server->smallbuf;
Steve Frenchf01d5e12007-08-30 21:13:31 +0000793 pdu_length = 4; /* enough to get RFC1001 header */
Steve Frenchfda35942011-01-20 18:06:34 +0000794
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400795 length = cifs_read_from_socket(server, buf, pdu_length);
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400796 if (length < 0)
Steve Frenchfda35942011-01-20 18:06:34 +0000797 continue;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400798 server->total_read = length;
Steve French67010fb2005-04-28 22:41:09 -0700799
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400800 /*
801 * The right amount was read from socket - 4 bytes,
802 * so we can now interpret the length field.
803 */
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000804 pdu_length = be32_to_cpu(smb_buffer->smb_buf_length);
Steve French46810cb2005-04-28 22:41:09 -0700805
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400806 cFYI(1, "RFC1002 header 0x%x", pdu_length);
807 if (!is_smb_response(server, buf[0]))
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000808 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -0700809
Jeff Layton89482a52011-10-19 15:28:57 -0400810 /* make sure we have enough to get to the MID */
811 if (pdu_length < sizeof(struct smb_hdr) - 1 - 4) {
812 cERROR(1, "SMB response too short (%u bytes)",
813 pdu_length);
814 cifs_reconnect(server);
815 wake_up(&server->response_q);
816 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -0700817 }
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400818
Jeff Layton89482a52011-10-19 15:28:57 -0400819 /* read down to the MID */
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400820 length = cifs_read_from_socket(server, buf + 4,
821 sizeof(struct smb_hdr) - 1 - 4);
Jeff Layton89482a52011-10-19 15:28:57 -0400822 if (length < 0)
823 continue;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400824 server->total_read += length;
Jeff Layton89482a52011-10-19 15:28:57 -0400825
Jeff Laytonc8054eb2011-10-19 15:29:31 -0400826 mid_entry = find_mid(server, smb_buffer);
827
Jeff Layton44d22d82011-10-19 15:29:49 -0400828 if (!mid_entry || !mid_entry->receive)
829 length = standard_receive3(server, mid_entry);
830 else
831 length = mid_entry->receive(server, mid_entry);
832
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400833 if (length < 0)
Steve Frenche4eb2952005-04-28 22:41:09 -0700834 continue;
835
Jeff Laytone9097ab2011-10-19 15:29:40 -0400836 if (server->large_buf) {
837 buf = server->bigbuf;
838 smb_buffer = (struct smb_hdr *)buf;
839 }
Steve Frenche4eb2952005-04-28 22:41:09 -0700840
Steve Frenchfda35942011-01-20 18:06:34 +0000841 server->lstrp = jiffies;
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500842 if (mid_entry != NULL) {
Jeff Layton2a37ef92011-10-19 15:29:23 -0400843 if (!mid_entry->multiRsp || mid_entry->multiEnd)
844 mid_entry->callback(mid_entry);
Jeff Laytonffc00e22011-10-19 15:29:13 -0400845 } else if (!is_valid_oplock_break(smb_buffer, server)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000846 cERROR(1, "No task to wake, unknown frame received! "
Jeff Layton80975312011-01-11 07:24:02 -0500847 "NumMids %d", atomic_read(&midCount));
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400848 cifs_dump_mem("Received Data is: ", buf,
Steve French70ca7342005-09-22 16:32:06 -0700849 sizeof(struct smb_hdr));
Steve French39798772006-05-31 22:40:51 +0000850#ifdef CONFIG_CIFS_DEBUG2
851 cifs_dump_detail(smb_buffer);
852 cifs_dump_mids(server);
853#endif /* CIFS_DEBUG2 */
Steve French50c2f752007-07-13 00:33:32 +0000854
Steve Frenche4eb2952005-04-28 22:41:09 -0700855 }
856 } /* end while !EXITING */
857
Justin P. Mattockfd62cb72011-02-24 22:15:02 -0800858 /* buffer usually freed in free_mid - need to free it here on exit */
Jeff Layton2a37ef92011-10-19 15:29:23 -0400859 cifs_buf_release(server->bigbuf);
860 if (server->smallbuf) /* no sense logging a debug message if NULL */
861 cifs_small_buf_release(server->smallbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -0400863 task_to_wake = xchg(&server->tsk, NULL);
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400864 clean_demultiplex_info(server);
Steve French50c2f752007-07-13 00:33:32 +0000865
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -0400866 /* if server->tsk was NULL then wait for a signal before exiting */
867 if (!task_to_wake) {
868 set_current_state(TASK_INTERRUPTIBLE);
869 while (!signal_pending(current)) {
870 schedule();
871 set_current_state(TASK_INTERRUPTIBLE);
872 }
873 set_current_state(TASK_RUNNING);
874 }
875
Jeff Layton0468a2c2008-12-01 07:09:35 -0500876 module_put_and_exit(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877}
878
Jeff Laytonc359cf32007-11-16 22:22:06 +0000879/* extract the host portion of the UNC string */
880static char *
881extract_hostname(const char *unc)
882{
883 const char *src;
884 char *dst, *delim;
885 unsigned int len;
886
887 /* skip double chars at beginning of string */
888 /* BB: check validity of these bytes? */
889 src = unc + 2;
890
891 /* delimiter between hostname and sharename is always '\\' now */
892 delim = strchr(src, '\\');
893 if (!delim)
894 return ERR_PTR(-EINVAL);
895
896 len = delim - src;
897 dst = kmalloc((len + 1), GFP_KERNEL);
898 if (dst == NULL)
899 return ERR_PTR(-ENOMEM);
900
901 memcpy(dst, src, len);
902 dst[len] = '\0';
903
904 return dst;
905}
906
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907static int
Sean Finneyb9468452011-04-11 13:19:32 +0000908cifs_parse_mount_options(const char *mountdata, const char *devname,
Steve French50c2f752007-07-13 00:33:32 +0000909 struct smb_vol *vol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910{
Pavel Shilovsky4906e502011-04-14 22:00:56 +0400911 char *value, *data, *end;
Vasily Averin957df452011-06-06 11:33:12 +0400912 char *mountdata_copy = NULL, *options;
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500913 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914 unsigned int temp_len, i, j;
915 char separator[2];
Jeff Layton9b9d6b242009-07-31 06:56:09 -0400916 short int override_uid = -1;
917 short int override_gid = -1;
918 bool uid_specified = false;
919 bool gid_specified = false;
Jeff Layton88463992010-11-22 15:31:03 -0500920 char *nodename = utsname()->nodename;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921
922 separator[0] = ',';
Steve French50c2f752007-07-13 00:33:32 +0000923 separator[1] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924
Jeff Layton88463992010-11-22 15:31:03 -0500925 /*
926 * does not have to be perfect mapping since field is
927 * informational, only used for servers that do not support
928 * port 445 and it can be overridden at mount time
929 */
Jeff Layton1397f2e2011-01-07 11:30:28 -0500930 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
931 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
Jeff Layton88463992010-11-22 15:31:03 -0500932 vol->source_rfc1001_name[i] = toupper(nodename[i]);
933
Jeff Layton1397f2e2011-01-07 11:30:28 -0500934 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
Steve Frencha10faeb22005-08-22 21:38:31 -0700935 /* null target name indicates to use *SMBSERVR default called name
936 if we end up sending RFC1001 session initialize */
937 vol->target_rfc1001_name[0] = 0;
Jeff Layton3e4b3e12010-07-19 18:00:17 -0400938 vol->cred_uid = current_uid();
939 vol->linux_uid = current_uid();
David Howellsa001e5b2008-11-14 10:38:47 +1100940 vol->linux_gid = current_gid();
Jeff Laytonf55ed1a2009-05-26 16:28:11 -0400941
942 /* default to only allowing write access to owner of the mount */
943 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944
945 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
Jeremy Allisonac670552005-06-22 17:26:35 -0700946 /* default is always to request posix paths. */
947 vol->posix_paths = 1;
Jeff Laytona0c92172009-05-27 15:40:47 -0400948 /* default to using server inode numbers where available */
949 vol->server_ino = 1;
Jeremy Allisonac670552005-06-22 17:26:35 -0700950
Suresh Jayaraman6d20e842010-12-01 14:42:28 +0530951 vol->actimeo = CIFS_DEF_ACTIMEO;
952
Sean Finneyb9468452011-04-11 13:19:32 +0000953 if (!mountdata)
954 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955
Sean Finneyb9468452011-04-11 13:19:32 +0000956 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
957 if (!mountdata_copy)
958 goto cifs_parse_mount_err;
959
960 options = mountdata_copy;
Pavel Shilovsky4906e502011-04-14 22:00:56 +0400961 end = options + strlen(options);
Steve French50c2f752007-07-13 00:33:32 +0000962 if (strncmp(options, "sep=", 4) == 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000963 if (options[4] != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 separator[0] = options[4];
965 options += 5;
966 } else {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000967 cFYI(1, "Null separator not allowed");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 }
969 }
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500970 vol->backupuid_specified = false; /* no backup intent for a user */
971 vol->backupgid_specified = false; /* no backup intent for a group */
Steve French50c2f752007-07-13 00:33:32 +0000972
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 while ((data = strsep(&options, separator)) != NULL) {
974 if (!*data)
975 continue;
976 if ((value = strchr(data, '=')) != NULL)
977 *value++ = '\0';
978
Steve French50c2f752007-07-13 00:33:32 +0000979 /* Have to parse this before we parse for "user" */
980 if (strnicmp(data, "user_xattr", 10) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 vol->no_xattr = 0;
Steve French50c2f752007-07-13 00:33:32 +0000982 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 vol->no_xattr = 1;
984 } else if (strnicmp(data, "user", 4) == 0) {
Steve French4b952a92006-10-30 21:46:13 +0000985 if (!value) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 printk(KERN_WARNING
987 "CIFS: invalid or missing username\n");
Sean Finneyb9468452011-04-11 13:19:32 +0000988 goto cifs_parse_mount_err;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000989 } else if (!*value) {
Steve French4b952a92006-10-30 21:46:13 +0000990 /* null user, ie anonymous, authentication */
991 vol->nullauth = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992 }
Steve French8727c8a2011-02-25 01:11:56 -0600993 if (strnlen(value, MAX_USERNAME_SIZE) <
994 MAX_USERNAME_SIZE) {
Sean Finneyb9468452011-04-11 13:19:32 +0000995 vol->username = kstrdup(value, GFP_KERNEL);
996 if (!vol->username) {
997 printk(KERN_WARNING "CIFS: no memory "
998 "for username\n");
999 goto cifs_parse_mount_err;
1000 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 } else {
1002 printk(KERN_WARNING "CIFS: username too long\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001003 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 }
1005 } else if (strnicmp(data, "pass", 4) == 0) {
1006 if (!value) {
1007 vol->password = NULL;
1008 continue;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001009 } else if (value[0] == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 /* check if string begins with double comma
1011 since that would mean the password really
1012 does start with a comma, and would not
1013 indicate an empty string */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001014 if (value[1] != separator[0]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 vol->password = NULL;
1016 continue;
1017 }
1018 }
1019 temp_len = strlen(value);
1020 /* removed password length check, NTLM passwords
1021 can be arbitrarily long */
1022
Steve French50c2f752007-07-13 00:33:32 +00001023 /* if comma in password, the string will be
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 prematurely null terminated. Commas in password are
1025 specified across the cifs mount interface by a double
1026 comma ie ,, and a comma used as in other cases ie ','
1027 as a parameter delimiter/separator is single and due
1028 to the strsep above is temporarily zeroed. */
1029
1030 /* NB: password legally can have multiple commas and
1031 the only illegal character in a password is null */
1032
Steve French50c2f752007-07-13 00:33:32 +00001033 if ((value[temp_len] == 0) &&
Pavel Shilovsky4906e502011-04-14 22:00:56 +04001034 (value + temp_len < end) &&
Steve French09d1db52005-04-28 22:41:08 -07001035 (value[temp_len+1] == separator[0])) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 /* reinsert comma */
1037 value[temp_len] = separator[0];
Steve French50c2f752007-07-13 00:33:32 +00001038 temp_len += 2; /* move after second comma */
1039 while (value[temp_len] != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 if (value[temp_len] == separator[0]) {
Steve French50c2f752007-07-13 00:33:32 +00001041 if (value[temp_len+1] ==
Steve French09d1db52005-04-28 22:41:08 -07001042 separator[0]) {
1043 /* skip second comma */
1044 temp_len++;
Steve French50c2f752007-07-13 00:33:32 +00001045 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 /* single comma indicating start
1047 of next parm */
1048 break;
1049 }
1050 }
1051 temp_len++;
1052 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001053 if (value[temp_len] == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054 options = NULL;
1055 } else {
1056 value[temp_len] = 0;
1057 /* point option to start of next parm */
1058 options = value + temp_len + 1;
1059 }
Steve French50c2f752007-07-13 00:33:32 +00001060 /* go from value to value + temp_len condensing
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 double commas to singles. Note that this ends up
1062 allocating a few bytes too many, which is ok */
Pekka Enberge915fc42005-09-06 15:18:35 -07001063 vol->password = kzalloc(temp_len, GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001064 if (vol->password == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001065 printk(KERN_WARNING "CIFS: no memory "
1066 "for password\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001067 goto cifs_parse_mount_err;
Steve French433dc242005-04-28 22:41:08 -07001068 }
Steve French50c2f752007-07-13 00:33:32 +00001069 for (i = 0, j = 0; i < temp_len; i++, j++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 vol->password[j] = value[i];
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001071 if (value[i] == separator[0]
Steve French09d1db52005-04-28 22:41:08 -07001072 && value[i+1] == separator[0]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 /* skip second comma */
1074 i++;
1075 }
1076 }
1077 vol->password[j] = 0;
1078 } else {
Pekka Enberge915fc42005-09-06 15:18:35 -07001079 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001080 if (vol->password == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001081 printk(KERN_WARNING "CIFS: no memory "
1082 "for password\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001083 goto cifs_parse_mount_err;
Steve French433dc242005-04-28 22:41:08 -07001084 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 strcpy(vol->password, value);
1086 }
Jeff Layton58f7f682009-06-10 09:57:55 -04001087 } else if (!strnicmp(data, "ip", 2) ||
1088 !strnicmp(data, "addr", 4)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 if (!value || !*value) {
1090 vol->UNCip = NULL;
Jeff Layton50b64e32009-06-02 06:55:20 -04001091 } else if (strnlen(value, INET6_ADDRSTRLEN) <
1092 INET6_ADDRSTRLEN) {
Sean Finneyb9468452011-04-11 13:19:32 +00001093 vol->UNCip = kstrdup(value, GFP_KERNEL);
1094 if (!vol->UNCip) {
1095 printk(KERN_WARNING "CIFS: no memory "
1096 "for UNC IP\n");
1097 goto cifs_parse_mount_err;
1098 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099 } else {
Steve French50c2f752007-07-13 00:33:32 +00001100 printk(KERN_WARNING "CIFS: ip address "
1101 "too long\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001102 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 }
Steve French50c2f752007-07-13 00:33:32 +00001104 } else if (strnicmp(data, "sec", 3) == 0) {
1105 if (!value || !*value) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001106 cERROR(1, "no security value specified");
Steve French50c2f752007-07-13 00:33:32 +00001107 continue;
1108 } else if (strnicmp(value, "krb5i", 5) == 0) {
1109 vol->secFlg |= CIFSSEC_MAY_KRB5 |
Steve French189acaa2006-06-23 02:33:48 +00001110 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -08001111 } else if (strnicmp(value, "krb5p", 5) == 0) {
Steve French50c2f752007-07-13 00:33:32 +00001112 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
1113 CIFSSEC_MAY_KRB5; */
Joe Perchesb6b38f72010-04-21 03:50:45 +00001114 cERROR(1, "Krb5 cifs privacy not supported");
Sean Finneyb9468452011-04-11 13:19:32 +00001115 goto cifs_parse_mount_err;
Steve Frenchbf820672005-12-01 22:32:42 -08001116 } else if (strnicmp(value, "krb5", 4) == 0) {
Steve French750d1152006-06-27 06:28:30 +00001117 vol->secFlg |= CIFSSEC_MAY_KRB5;
Steve Frenchac683922009-05-06 04:16:04 +00001118 } else if (strnicmp(value, "ntlmsspi", 8) == 0) {
1119 vol->secFlg |= CIFSSEC_MAY_NTLMSSP |
1120 CIFSSEC_MUST_SIGN;
1121 } else if (strnicmp(value, "ntlmssp", 7) == 0) {
1122 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
Steve Frenchbf820672005-12-01 22:32:42 -08001123 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
Steve French750d1152006-06-27 06:28:30 +00001124 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
Steve French189acaa2006-06-23 02:33:48 +00001125 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -08001126 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
Steve French750d1152006-06-27 06:28:30 +00001127 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
Steve Frenchbf820672005-12-01 22:32:42 -08001128 } else if (strnicmp(value, "ntlmi", 5) == 0) {
Steve French750d1152006-06-27 06:28:30 +00001129 vol->secFlg |= CIFSSEC_MAY_NTLM |
Steve French189acaa2006-06-23 02:33:48 +00001130 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -08001131 } else if (strnicmp(value, "ntlm", 4) == 0) {
1132 /* ntlm is default so can be turned off too */
Steve French750d1152006-06-27 06:28:30 +00001133 vol->secFlg |= CIFSSEC_MAY_NTLM;
Steve Frenchbf820672005-12-01 22:32:42 -08001134 } else if (strnicmp(value, "nontlm", 6) == 0) {
Steve French189acaa2006-06-23 02:33:48 +00001135 /* BB is there a better way to do this? */
Steve French750d1152006-06-27 06:28:30 +00001136 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
Steve French189acaa2006-06-23 02:33:48 +00001137#ifdef CONFIG_CIFS_WEAK_PW_HASH
1138 } else if (strnicmp(value, "lanman", 6) == 0) {
Steve French50c2f752007-07-13 00:33:32 +00001139 vol->secFlg |= CIFSSEC_MAY_LANMAN;
Steve French189acaa2006-06-23 02:33:48 +00001140#endif
Steve Frenchbf820672005-12-01 22:32:42 -08001141 } else if (strnicmp(value, "none", 4) == 0) {
Steve French189acaa2006-06-23 02:33:48 +00001142 vol->nullauth = 1;
Steve French50c2f752007-07-13 00:33:32 +00001143 } else {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001144 cERROR(1, "bad security option: %s", value);
Sean Finneyb9468452011-04-11 13:19:32 +00001145 goto cifs_parse_mount_err;
Steve French50c2f752007-07-13 00:33:32 +00001146 }
Steve French1cb06d02011-02-24 18:07:19 +00001147 } else if (strnicmp(data, "vers", 3) == 0) {
1148 if (!value || !*value) {
1149 cERROR(1, "no protocol version specified"
1150 " after vers= mount option");
1151 } else if ((strnicmp(value, "cifs", 4) == 0) ||
1152 (strnicmp(value, "1", 1) == 0)) {
1153 /* this is the default */
1154 continue;
Steve French1cb06d02011-02-24 18:07:19 +00001155 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 } else if ((strnicmp(data, "unc", 3) == 0)
1157 || (strnicmp(data, "target", 6) == 0)
1158 || (strnicmp(data, "path", 4) == 0)) {
1159 if (!value || !*value) {
Steve French50c2f752007-07-13 00:33:32 +00001160 printk(KERN_WARNING "CIFS: invalid path to "
1161 "network resource\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001162 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 }
1164 if ((temp_len = strnlen(value, 300)) < 300) {
Steve French50c2f752007-07-13 00:33:32 +00001165 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
Steve French4523cc32007-04-30 20:13:06 +00001166 if (vol->UNC == NULL)
Sean Finneyb9468452011-04-11 13:19:32 +00001167 goto cifs_parse_mount_err;
Steve French50c2f752007-07-13 00:33:32 +00001168 strcpy(vol->UNC, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169 if (strncmp(vol->UNC, "//", 2) == 0) {
1170 vol->UNC[0] = '\\';
1171 vol->UNC[1] = '\\';
Steve French50c2f752007-07-13 00:33:32 +00001172 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 printk(KERN_WARNING
Steve French50c2f752007-07-13 00:33:32 +00001174 "CIFS: UNC Path does not begin "
1175 "with // or \\\\ \n");
Sean Finneyb9468452011-04-11 13:19:32 +00001176 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 }
1178 } else {
1179 printk(KERN_WARNING "CIFS: UNC name too long\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001180 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 }
1182 } else if ((strnicmp(data, "domain", 3) == 0)
1183 || (strnicmp(data, "workgroup", 5) == 0)) {
1184 if (!value || !*value) {
1185 printk(KERN_WARNING "CIFS: invalid domain name\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001186 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187 }
1188 /* BB are there cases in which a comma can be valid in
1189 a domain name and need special handling? */
Steve French39798772006-05-31 22:40:51 +00001190 if (strnlen(value, 256) < 256) {
Sean Finneyb9468452011-04-11 13:19:32 +00001191 vol->domainname = kstrdup(value, GFP_KERNEL);
1192 if (!vol->domainname) {
1193 printk(KERN_WARNING "CIFS: no memory "
1194 "for domainname\n");
1195 goto cifs_parse_mount_err;
1196 }
Joe Perchesb6b38f72010-04-21 03:50:45 +00001197 cFYI(1, "Domain name set");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198 } else {
Steve French50c2f752007-07-13 00:33:32 +00001199 printk(KERN_WARNING "CIFS: domain name too "
1200 "long\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001201 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 }
Ben Greear3eb9a882010-09-01 17:06:02 -07001203 } else if (strnicmp(data, "srcaddr", 7) == 0) {
1204 vol->srcaddr.ss_family = AF_UNSPEC;
1205
1206 if (!value || !*value) {
1207 printk(KERN_WARNING "CIFS: srcaddr value"
1208 " not specified.\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001209 goto cifs_parse_mount_err;
Ben Greear3eb9a882010-09-01 17:06:02 -07001210 }
1211 i = cifs_convert_address((struct sockaddr *)&vol->srcaddr,
1212 value, strlen(value));
Dan Carpenterb235f372010-10-25 07:02:56 +02001213 if (i == 0) {
Ben Greear3eb9a882010-09-01 17:06:02 -07001214 printk(KERN_WARNING "CIFS: Could not parse"
1215 " srcaddr: %s\n",
1216 value);
Sean Finneyb9468452011-04-11 13:19:32 +00001217 goto cifs_parse_mount_err;
Ben Greear3eb9a882010-09-01 17:06:02 -07001218 }
Steve French50c2f752007-07-13 00:33:32 +00001219 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1220 if (!value || !*value) {
1221 printk(KERN_WARNING
1222 "CIFS: invalid path prefix\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001223 goto cifs_parse_mount_err;
Steve French50c2f752007-07-13 00:33:32 +00001224 }
1225 if ((temp_len = strnlen(value, 1024)) < 1024) {
Steve French4523cc32007-04-30 20:13:06 +00001226 if (value[0] != '/')
Steve French2fe87f02006-09-21 07:02:52 +00001227 temp_len++; /* missing leading slash */
Steve French50c2f752007-07-13 00:33:32 +00001228 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1229 if (vol->prepath == NULL)
Sean Finneyb9468452011-04-11 13:19:32 +00001230 goto cifs_parse_mount_err;
Steve French4523cc32007-04-30 20:13:06 +00001231 if (value[0] != '/') {
Steve French2fe87f02006-09-21 07:02:52 +00001232 vol->prepath[0] = '/';
Steve French50c2f752007-07-13 00:33:32 +00001233 strcpy(vol->prepath+1, value);
Steve French2fe87f02006-09-21 07:02:52 +00001234 } else
Steve French50c2f752007-07-13 00:33:32 +00001235 strcpy(vol->prepath, value);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001236 cFYI(1, "prefix path %s", vol->prepath);
Steve French50c2f752007-07-13 00:33:32 +00001237 } else {
1238 printk(KERN_WARNING "CIFS: prefix too long\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001239 goto cifs_parse_mount_err;
Steve French50c2f752007-07-13 00:33:32 +00001240 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241 } else if (strnicmp(data, "iocharset", 9) == 0) {
1242 if (!value || !*value) {
Steve French63135e02007-07-17 17:34:02 +00001243 printk(KERN_WARNING "CIFS: invalid iocharset "
1244 "specified\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001245 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246 }
1247 if (strnlen(value, 65) < 65) {
Sean Finneyb9468452011-04-11 13:19:32 +00001248 if (strnicmp(value, "default", 7)) {
1249 vol->iocharset = kstrdup(value,
1250 GFP_KERNEL);
1251
1252 if (!vol->iocharset) {
1253 printk(KERN_WARNING "CIFS: no "
1254 "memory for"
1255 "charset\n");
1256 goto cifs_parse_mount_err;
1257 }
1258 }
Steve French50c2f752007-07-13 00:33:32 +00001259 /* if iocharset not set then load_nls_default
1260 is used by caller */
Joe Perchesb6b38f72010-04-21 03:50:45 +00001261 cFYI(1, "iocharset set to %s", value);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 } else {
Steve French63135e02007-07-17 17:34:02 +00001263 printk(KERN_WARNING "CIFS: iocharset name "
1264 "too long.\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001265 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 }
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001267 } else if (!strnicmp(data, "uid", 3) && value && *value) {
1268 vol->linux_uid = simple_strtoul(value, &value, 0);
1269 uid_specified = true;
Jeff Laytonbd763312011-01-11 10:33:24 -05001270 } else if (!strnicmp(data, "cruid", 5) && value && *value) {
1271 vol->cred_uid = simple_strtoul(value, &value, 0);
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001272 } else if (!strnicmp(data, "forceuid", 8)) {
1273 override_uid = 1;
1274 } else if (!strnicmp(data, "noforceuid", 10)) {
1275 override_uid = 0;
1276 } else if (!strnicmp(data, "gid", 3) && value && *value) {
1277 vol->linux_gid = simple_strtoul(value, &value, 0);
1278 gid_specified = true;
1279 } else if (!strnicmp(data, "forcegid", 8)) {
1280 override_gid = 1;
1281 } else if (!strnicmp(data, "noforcegid", 10)) {
1282 override_gid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283 } else if (strnicmp(data, "file_mode", 4) == 0) {
1284 if (value && *value) {
1285 vol->file_mode =
1286 simple_strtoul(value, &value, 0);
1287 }
1288 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1289 if (value && *value) {
1290 vol->dir_mode =
1291 simple_strtoul(value, &value, 0);
1292 }
1293 } else if (strnicmp(data, "dirmode", 4) == 0) {
1294 if (value && *value) {
1295 vol->dir_mode =
1296 simple_strtoul(value, &value, 0);
1297 }
1298 } else if (strnicmp(data, "port", 4) == 0) {
1299 if (value && *value) {
1300 vol->port =
1301 simple_strtoul(value, &value, 0);
1302 }
1303 } else if (strnicmp(data, "rsize", 5) == 0) {
1304 if (value && *value) {
1305 vol->rsize =
1306 simple_strtoul(value, &value, 0);
1307 }
1308 } else if (strnicmp(data, "wsize", 5) == 0) {
1309 if (value && *value) {
1310 vol->wsize =
1311 simple_strtoul(value, &value, 0);
1312 }
1313 } else if (strnicmp(data, "sockopt", 5) == 0) {
Steve French6a5fa2362010-01-01 01:28:43 +00001314 if (!value || !*value) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001315 cERROR(1, "no socket option specified");
Steve French6a5fa2362010-01-01 01:28:43 +00001316 continue;
1317 } else if (strnicmp(value, "TCP_NODELAY", 11) == 0) {
1318 vol->sockopt_tcp_nodelay = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319 }
1320 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1321 if (!value || !*value || (*value == ' ')) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001322 cFYI(1, "invalid (empty) netbiosname");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323 } else {
Jeff Layton1397f2e2011-01-07 11:30:28 -05001324 memset(vol->source_rfc1001_name, 0x20,
1325 RFC1001_NAME_LEN);
1326 /*
1327 * FIXME: are there cases in which a comma can
1328 * be valid in workstation netbios name (and
1329 * need special handling)?
1330 */
1331 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1332 /* don't ucase netbiosname for user */
Steve French50c2f752007-07-13 00:33:32 +00001333 if (value[i] == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334 break;
Jeff Layton1397f2e2011-01-07 11:30:28 -05001335 vol->source_rfc1001_name[i] = value[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336 }
1337 /* The string has 16th byte zero still from
1338 set at top of the function */
Jeff Layton1397f2e2011-01-07 11:30:28 -05001339 if (i == RFC1001_NAME_LEN && value[i] != 0)
Steve French50c2f752007-07-13 00:33:32 +00001340 printk(KERN_WARNING "CIFS: netbiosname"
1341 " longer than 15 truncated.\n");
Steve Frencha10faeb22005-08-22 21:38:31 -07001342 }
1343 } else if (strnicmp(data, "servern", 7) == 0) {
1344 /* servernetbiosname specified override *SMBSERVER */
1345 if (!value || !*value || (*value == ' ')) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001346 cFYI(1, "empty server netbiosname specified");
Steve Frencha10faeb22005-08-22 21:38:31 -07001347 } else {
1348 /* last byte, type, is 0x20 for servr type */
Jeff Layton1397f2e2011-01-07 11:30:28 -05001349 memset(vol->target_rfc1001_name, 0x20,
1350 RFC1001_NAME_LEN_WITH_NULL);
Steve Frencha10faeb22005-08-22 21:38:31 -07001351
Steve French50c2f752007-07-13 00:33:32 +00001352 for (i = 0; i < 15; i++) {
Steve Frencha10faeb22005-08-22 21:38:31 -07001353 /* BB are there cases in which a comma can be
Steve French50c2f752007-07-13 00:33:32 +00001354 valid in this workstation netbios name
1355 (and need special handling)? */
Steve Frencha10faeb22005-08-22 21:38:31 -07001356
Steve French50c2f752007-07-13 00:33:32 +00001357 /* user or mount helper must uppercase
1358 the netbiosname */
1359 if (value[i] == 0)
Steve Frencha10faeb22005-08-22 21:38:31 -07001360 break;
1361 else
Steve French50c2f752007-07-13 00:33:32 +00001362 vol->target_rfc1001_name[i] =
1363 value[i];
Steve Frencha10faeb22005-08-22 21:38:31 -07001364 }
1365 /* The string has 16th byte zero still from
1366 set at top of the function */
Jeff Layton1397f2e2011-01-07 11:30:28 -05001367 if (i == RFC1001_NAME_LEN && value[i] != 0)
Steve French50c2f752007-07-13 00:33:32 +00001368 printk(KERN_WARNING "CIFS: server net"
1369 "biosname longer than 15 truncated.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 }
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301371 } else if (strnicmp(data, "actimeo", 7) == 0) {
1372 if (value && *value) {
1373 vol->actimeo = HZ * simple_strtoul(value,
1374 &value, 0);
1375 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1376 cERROR(1, "CIFS: attribute cache"
1377 "timeout too large");
Sean Finneyb9468452011-04-11 13:19:32 +00001378 goto cifs_parse_mount_err;
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301379 }
1380 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 } else if (strnicmp(data, "credentials", 4) == 0) {
1382 /* ignore */
1383 } else if (strnicmp(data, "version", 3) == 0) {
1384 /* ignore */
Steve French50c2f752007-07-13 00:33:32 +00001385 } else if (strnicmp(data, "guest", 5) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 /* ignore */
Steve Frenchc9c7fa02011-08-29 18:54:12 +00001387 } else if (strnicmp(data, "rw", 2) == 0 && strlen(data) == 2) {
Steve French71a394f2009-06-26 04:07:18 +00001388 /* ignore */
1389 } else if (strnicmp(data, "ro", 2) == 0) {
1390 /* ignore */
Steve Frenchedf1ae42008-10-29 00:47:57 +00001391 } else if (strnicmp(data, "noblocksend", 11) == 0) {
1392 vol->noblocksnd = 1;
1393 } else if (strnicmp(data, "noautotune", 10) == 0) {
1394 vol->noautotune = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395 } else if ((strnicmp(data, "suid", 4) == 0) ||
1396 (strnicmp(data, "nosuid", 6) == 0) ||
1397 (strnicmp(data, "exec", 4) == 0) ||
1398 (strnicmp(data, "noexec", 6) == 0) ||
1399 (strnicmp(data, "nodev", 5) == 0) ||
1400 (strnicmp(data, "noauto", 6) == 0) ||
1401 (strnicmp(data, "dev", 3) == 0)) {
1402 /* The mount tool or mount.cifs helper (if present)
Steve French50c2f752007-07-13 00:33:32 +00001403 uses these opts to set flags, and the flags are read
1404 by the kernel vfs layer before we get here (ie
1405 before read super) so there is no point trying to
1406 parse these options again and set anything and it
1407 is ok to just ignore them */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409 } else if (strnicmp(data, "hard", 4) == 0) {
1410 vol->retry = 1;
1411 } else if (strnicmp(data, "soft", 4) == 0) {
1412 vol->retry = 0;
1413 } else if (strnicmp(data, "perm", 4) == 0) {
1414 vol->noperm = 0;
1415 } else if (strnicmp(data, "noperm", 6) == 0) {
1416 vol->noperm = 1;
Steve French6a0b4822005-04-28 22:41:05 -07001417 } else if (strnicmp(data, "mapchars", 8) == 0) {
1418 vol->remap = 1;
1419 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1420 vol->remap = 0;
Steve French50c2f752007-07-13 00:33:32 +00001421 } else if (strnicmp(data, "sfu", 3) == 0) {
1422 vol->sfu_emul = 1;
1423 } else if (strnicmp(data, "nosfu", 5) == 0) {
1424 vol->sfu_emul = 0;
Steve French2c1b8612008-10-16 18:35:21 +00001425 } else if (strnicmp(data, "nodfs", 5) == 0) {
1426 vol->nodfs = 1;
Jeremy Allisonac670552005-06-22 17:26:35 -07001427 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1428 vol->posix_paths = 1;
1429 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1430 vol->posix_paths = 0;
Steve Frenchc18c8422007-07-18 23:21:09 +00001431 } else if (strnicmp(data, "nounix", 6) == 0) {
1432 vol->no_linux_ext = 1;
1433 } else if (strnicmp(data, "nolinux", 7) == 0) {
1434 vol->no_linux_ext = 1;
Steve French50c2f752007-07-13 00:33:32 +00001435 } else if ((strnicmp(data, "nocase", 6) == 0) ||
Steve Frencha10faeb22005-08-22 21:38:31 -07001436 (strnicmp(data, "ignorecase", 10) == 0)) {
Steve French50c2f752007-07-13 00:33:32 +00001437 vol->nocase = 1;
Jeff Laytonf636a342010-07-26 10:29:58 -04001438 } else if (strnicmp(data, "mand", 4) == 0) {
1439 /* ignore */
1440 } else if (strnicmp(data, "nomand", 6) == 0) {
1441 /* ignore */
1442 } else if (strnicmp(data, "_netdev", 7) == 0) {
1443 /* ignore */
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001444 } else if (strnicmp(data, "brl", 3) == 0) {
1445 vol->nobrl = 0;
Steve French50c2f752007-07-13 00:33:32 +00001446 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
Steve French1c955182005-08-30 20:58:07 -07001447 (strnicmp(data, "nolock", 6) == 0)) {
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001448 vol->nobrl = 1;
Steve Frenchd3485d32005-08-19 11:04:29 -07001449 /* turn off mandatory locking in mode
1450 if remote locking is turned off since the
1451 local vfs will do advisory */
Steve French50c2f752007-07-13 00:33:32 +00001452 if (vol->file_mode ==
1453 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
Steve Frenchd3485d32005-08-19 11:04:29 -07001454 vol->file_mode = S_IALLUGO;
Steve French13a6e422008-12-02 17:24:33 +00001455 } else if (strnicmp(data, "forcemandatorylock", 9) == 0) {
1456 /* will take the shorter form "forcemand" as well */
1457 /* This mount option will force use of mandatory
1458 (DOS/Windows style) byte range locks, instead of
1459 using posix advisory byte range locks, even if the
1460 Unix extensions are available and posix locks would
1461 be supported otherwise. If Unix extensions are not
1462 negotiated this has no effect since mandatory locks
1463 would be used (mandatory locks is all that those
1464 those servers support) */
1465 vol->mand_lock = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466 } else if (strnicmp(data, "setuids", 7) == 0) {
1467 vol->setuids = 1;
1468 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1469 vol->setuids = 0;
Jeff Laytond0a9c072008-05-12 22:23:49 +00001470 } else if (strnicmp(data, "dynperm", 7) == 0) {
1471 vol->dynperm = true;
1472 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1473 vol->dynperm = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 } else if (strnicmp(data, "nohard", 6) == 0) {
1475 vol->retry = 0;
1476 } else if (strnicmp(data, "nosoft", 6) == 0) {
1477 vol->retry = 1;
1478 } else if (strnicmp(data, "nointr", 6) == 0) {
1479 vol->intr = 0;
1480 } else if (strnicmp(data, "intr", 4) == 0) {
1481 vol->intr = 1;
Steve Frenchbe652442009-02-23 15:21:59 +00001482 } else if (strnicmp(data, "nostrictsync", 12) == 0) {
1483 vol->nostrictsync = 1;
1484 } else if (strnicmp(data, "strictsync", 10) == 0) {
1485 vol->nostrictsync = 0;
Steve French50c2f752007-07-13 00:33:32 +00001486 } else if (strnicmp(data, "serverino", 7) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487 vol->server_ino = 1;
Steve French50c2f752007-07-13 00:33:32 +00001488 } else if (strnicmp(data, "noserverino", 9) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489 vol->server_ino = 0;
Steve Frenchc9c7fa02011-08-29 18:54:12 +00001490 } else if (strnicmp(data, "rwpidforward", 12) == 0) {
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001491 vol->rwpidforward = 1;
Steve French50c2f752007-07-13 00:33:32 +00001492 } else if (strnicmp(data, "cifsacl", 7) == 0) {
Steve French0a4b92c2006-01-12 15:44:21 -08001493 vol->cifs_acl = 1;
1494 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1495 vol->cifs_acl = 0;
Steve French50c2f752007-07-13 00:33:32 +00001496 } else if (strnicmp(data, "acl", 3) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 vol->no_psx_acl = 0;
Steve French50c2f752007-07-13 00:33:32 +00001498 } else if (strnicmp(data, "noacl", 5) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499 vol->no_psx_acl = 1;
Steve French84210e92008-10-23 04:42:37 +00001500 } else if (strnicmp(data, "locallease", 6) == 0) {
1501 vol->local_lease = 1;
Steve French50c2f752007-07-13 00:33:32 +00001502 } else if (strnicmp(data, "sign", 4) == 0) {
Steve French750d1152006-06-27 06:28:30 +00001503 vol->secFlg |= CIFSSEC_MUST_SIGN;
Steve French95b1cb92008-05-15 16:44:38 +00001504 } else if (strnicmp(data, "seal", 4) == 0) {
1505 /* we do not do the following in secFlags because seal
1506 is a per tree connection (mount) not a per socket
1507 or per-smb connection option in the protocol */
1508 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1509 vol->seal = 1;
Steve French50c2f752007-07-13 00:33:32 +00001510 } else if (strnicmp(data, "direct", 6) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511 vol->direct_io = 1;
Steve French50c2f752007-07-13 00:33:32 +00001512 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513 vol->direct_io = 1;
Pavel Shilovskyd39454f2011-01-24 14:16:35 -05001514 } else if (strnicmp(data, "strictcache", 11) == 0) {
1515 vol->strict_io = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 } else if (strnicmp(data, "noac", 4) == 0) {
Steve French50c2f752007-07-13 00:33:32 +00001517 printk(KERN_WARNING "CIFS: Mount option noac not "
1518 "supported. Instead set "
1519 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
Suresh Jayaramanfa1df752010-07-05 18:13:36 +05301520 } else if (strnicmp(data, "fsc", 3) == 0) {
Suresh Jayaraman607a5692010-11-24 17:49:05 +05301521#ifndef CONFIG_CIFS_FSCACHE
Jeff Layton83fb0862011-06-08 07:35:24 -04001522 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE "
Suresh Jayaraman607a5692010-11-24 17:49:05 +05301523 "kernel config option set");
Sean Finneyb9468452011-04-11 13:19:32 +00001524 goto cifs_parse_mount_err;
Suresh Jayaraman607a5692010-11-24 17:49:05 +05301525#endif
Suresh Jayaramanfa1df752010-07-05 18:13:36 +05301526 vol->fsc = true;
Stefan Metzmacher736a3322010-07-30 14:56:00 +02001527 } else if (strnicmp(data, "mfsymlinks", 10) == 0) {
1528 vol->mfsymlinks = true;
Jeff Layton0eb8a132010-10-06 19:51:12 -04001529 } else if (strnicmp(data, "multiuser", 8) == 0) {
1530 vol->multiuser = true;
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05001531 } else if (!strnicmp(data, "backupuid", 9) && value && *value) {
1532 err = kstrtouint(value, 0, &vol->backupuid);
1533 if (err < 0) {
1534 cERROR(1, "%s: Invalid backupuid value",
1535 __func__);
1536 goto cifs_parse_mount_err;
1537 }
1538 vol->backupuid_specified = true;
1539 } else if (!strnicmp(data, "backupgid", 9) && value && *value) {
1540 err = kstrtouint(value, 0, &vol->backupgid);
1541 if (err < 0) {
1542 cERROR(1, "%s: Invalid backupgid value",
1543 __func__);
1544 goto cifs_parse_mount_err;
1545 }
1546 vol->backupgid_specified = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547 } else
Steve French50c2f752007-07-13 00:33:32 +00001548 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1549 data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550 }
1551 if (vol->UNC == NULL) {
Steve French4523cc32007-04-30 20:13:06 +00001552 if (devname == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001553 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1554 "target\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001555 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556 }
1557 if ((temp_len = strnlen(devname, 300)) < 300) {
Steve French50c2f752007-07-13 00:33:32 +00001558 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
Steve French4523cc32007-04-30 20:13:06 +00001559 if (vol->UNC == NULL)
Sean Finneyb9468452011-04-11 13:19:32 +00001560 goto cifs_parse_mount_err;
Steve French50c2f752007-07-13 00:33:32 +00001561 strcpy(vol->UNC, devname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562 if (strncmp(vol->UNC, "//", 2) == 0) {
1563 vol->UNC[0] = '\\';
1564 vol->UNC[1] = '\\';
1565 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
Steve French50c2f752007-07-13 00:33:32 +00001566 printk(KERN_WARNING "CIFS: UNC Path does not "
1567 "begin with // or \\\\ \n");
Sean Finneyb9468452011-04-11 13:19:32 +00001568 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569 }
Igor Mammedov7c5e6282008-05-08 20:48:42 +00001570 value = strpbrk(vol->UNC+2, "/\\");
1571 if (value)
1572 *value = '\\';
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573 } else {
1574 printk(KERN_WARNING "CIFS: UNC name too long\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001575 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576 }
1577 }
Jeff Layton0eb8a132010-10-06 19:51:12 -04001578
1579 if (vol->multiuser && !(vol->secFlg & CIFSSEC_MAY_KRB5)) {
1580 cERROR(1, "Multiuser mounts currently require krb5 "
1581 "authentication!");
Sean Finneyb9468452011-04-11 13:19:32 +00001582 goto cifs_parse_mount_err;
Jeff Layton0eb8a132010-10-06 19:51:12 -04001583 }
1584
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001585 if (vol->UNCip == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586 vol->UNCip = &vol->UNC[2];
1587
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001588 if (uid_specified)
1589 vol->override_uid = override_uid;
1590 else if (override_uid == 1)
1591 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1592 "specified with no uid= option.\n");
1593
1594 if (gid_specified)
1595 vol->override_gid = override_gid;
1596 else if (override_gid == 1)
1597 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1598 "specified with no gid= option.\n");
1599
Sean Finneyb9468452011-04-11 13:19:32 +00001600 kfree(mountdata_copy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601 return 0;
Sean Finneyb9468452011-04-11 13:19:32 +00001602
1603cifs_parse_mount_err:
1604 kfree(mountdata_copy);
1605 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606}
1607
Ben Greear3eb9a882010-09-01 17:06:02 -07001608/** Returns true if srcaddr isn't specified and rhs isn't
1609 * specified, or if srcaddr is specified and
1610 * matches the IP address of the rhs argument.
1611 */
Jeff Layton45151482010-07-06 20:43:02 -04001612static bool
Ben Greear3eb9a882010-09-01 17:06:02 -07001613srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1614{
1615 switch (srcaddr->sa_family) {
1616 case AF_UNSPEC:
1617 return (rhs->sa_family == AF_UNSPEC);
1618 case AF_INET: {
1619 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1620 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1621 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1622 }
1623 case AF_INET6: {
1624 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1625 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1626 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1627 }
1628 default:
1629 WARN_ON(1);
1630 return false; /* don't expect to be here */
1631 }
1632}
1633
Pavel Shilovsky4b886132010-12-13 22:18:07 +03001634/*
1635 * If no port is specified in addr structure, we try to match with 445 port
1636 * and if it fails - with 139 ports. It should be called only if address
1637 * families of server and addr are equal.
1638 */
1639static bool
1640match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1641{
Steve French6da97912011-03-13 18:55:55 +00001642 __be16 port, *sport;
Pavel Shilovsky4b886132010-12-13 22:18:07 +03001643
1644 switch (addr->sa_family) {
1645 case AF_INET:
1646 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1647 port = ((struct sockaddr_in *) addr)->sin_port;
1648 break;
1649 case AF_INET6:
1650 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1651 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1652 break;
1653 default:
1654 WARN_ON(1);
1655 return false;
1656 }
1657
1658 if (!port) {
1659 port = htons(CIFS_PORT);
1660 if (port == *sport)
1661 return true;
1662
1663 port = htons(RFC1001_PORT);
1664 }
1665
1666 return port == *sport;
1667}
Ben Greear3eb9a882010-09-01 17:06:02 -07001668
1669static bool
1670match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1671 struct sockaddr *srcaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672{
Jeff Layton45151482010-07-06 20:43:02 -04001673 switch (addr->sa_family) {
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001674 case AF_INET: {
1675 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1676 struct sockaddr_in *srv_addr4 =
1677 (struct sockaddr_in *)&server->dstaddr;
1678
1679 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
Jeff Layton45151482010-07-06 20:43:02 -04001680 return false;
Jeff Layton45151482010-07-06 20:43:02 -04001681 break;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001682 }
1683 case AF_INET6: {
1684 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1685 struct sockaddr_in6 *srv_addr6 =
1686 (struct sockaddr_in6 *)&server->dstaddr;
1687
Jeff Layton45151482010-07-06 20:43:02 -04001688 if (!ipv6_addr_equal(&addr6->sin6_addr,
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001689 &srv_addr6->sin6_addr))
Jeff Layton45151482010-07-06 20:43:02 -04001690 return false;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001691 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
Jeff Layton45151482010-07-06 20:43:02 -04001692 return false;
Jeff Layton45151482010-07-06 20:43:02 -04001693 break;
1694 }
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001695 default:
1696 WARN_ON(1);
1697 return false; /* don't expect to be here */
1698 }
Jeff Layton45151482010-07-06 20:43:02 -04001699
Ben Greear3eb9a882010-09-01 17:06:02 -07001700 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1701 return false;
1702
Jeff Layton45151482010-07-06 20:43:02 -04001703 return true;
1704}
1705
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001706static bool
1707match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
1708{
1709 unsigned int secFlags;
1710
1711 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
1712 secFlags = vol->secFlg;
1713 else
1714 secFlags = global_secflags | vol->secFlg;
1715
1716 switch (server->secType) {
1717 case LANMAN:
1718 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
1719 return false;
1720 break;
1721 case NTLMv2:
1722 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
1723 return false;
1724 break;
1725 case NTLM:
1726 if (!(secFlags & CIFSSEC_MAY_NTLM))
1727 return false;
1728 break;
1729 case Kerberos:
1730 if (!(secFlags & CIFSSEC_MAY_KRB5))
1731 return false;
1732 break;
1733 case RawNTLMSSP:
1734 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
1735 return false;
1736 break;
1737 default:
1738 /* shouldn't happen */
1739 return false;
1740 }
1741
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001742 /* now check if signing mode is acceptable */
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001743 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
Steve French96daf2b2011-05-27 04:34:02 +00001744 (server->sec_mode & SECMODE_SIGN_REQUIRED))
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001745 return false;
1746 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
Steve French96daf2b2011-05-27 04:34:02 +00001747 (server->sec_mode &
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001748 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
1749 return false;
1750
1751 return true;
1752}
1753
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00001754static int match_server(struct TCP_Server_Info *server, struct sockaddr *addr,
1755 struct smb_vol *vol)
1756{
1757 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
1758 return 0;
1759
1760 if (!match_address(server, addr,
1761 (struct sockaddr *)&vol->srcaddr))
1762 return 0;
1763
1764 if (!match_port(server, addr))
1765 return 0;
1766
1767 if (!match_security(server, vol))
1768 return 0;
1769
1770 return 1;
1771}
1772
Jeff Layton45151482010-07-06 20:43:02 -04001773static struct TCP_Server_Info *
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001774cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
Jeff Layton45151482010-07-06 20:43:02 -04001775{
Jeff Laytone7ddee92008-11-14 13:44:38 -05001776 struct TCP_Server_Info *server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301778 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton45151482010-07-06 20:43:02 -04001779 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00001780 if (!match_server(server, addr, vol))
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001781 continue;
1782
Jeff Laytone7ddee92008-11-14 13:44:38 -05001783 ++server->srv_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301784 spin_unlock(&cifs_tcp_ses_lock);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001785 cFYI(1, "Existing tcp session with server found");
Jeff Laytone7ddee92008-11-14 13:44:38 -05001786 return server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001787 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301788 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789 return NULL;
1790}
1791
Jeff Layton14fbf502008-11-14 13:53:46 -05001792static void
Jeff Laytone7ddee92008-11-14 13:44:38 -05001793cifs_put_tcp_session(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794{
Jeff Laytone7ddee92008-11-14 13:44:38 -05001795 struct task_struct *task;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301797 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05001798 if (--server->srv_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301799 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05001800 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801 }
Steve Frenchdea570e02008-05-06 22:05:51 +00001802
Rob Landleyf1d0c992011-01-22 15:44:05 -06001803 put_net(cifs_net_ns(server));
1804
Jeff Laytone7ddee92008-11-14 13:44:38 -05001805 list_del_init(&server->tcp_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301806 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05001807
Jeff Laytonc74093b2011-01-11 07:24:23 -05001808 cancel_delayed_work_sync(&server->echo);
1809
Jeff Laytone7ddee92008-11-14 13:44:38 -05001810 spin_lock(&GlobalMid_Lock);
1811 server->tcpStatus = CifsExiting;
1812 spin_unlock(&GlobalMid_Lock);
1813
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05001814 cifs_crypto_shash_release(server);
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +05301815 cifs_fscache_release_client_cookie(server);
1816
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05001817 kfree(server->session_key.response);
1818 server->session_key.response = NULL;
1819 server->session_key.len = 0;
1820
Jeff Laytone7ddee92008-11-14 13:44:38 -05001821 task = xchg(&server->tsk, NULL);
1822 if (task)
1823 force_sig(SIGKILL, task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824}
1825
Jeff Layton63c038c2008-12-01 18:41:46 -05001826static struct TCP_Server_Info *
1827cifs_get_tcp_session(struct smb_vol *volume_info)
1828{
1829 struct TCP_Server_Info *tcp_ses = NULL;
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001830 struct sockaddr_storage addr;
Jeff Layton63c038c2008-12-01 18:41:46 -05001831 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
1832 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
1833 int rc;
1834
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001835 memset(&addr, 0, sizeof(struct sockaddr_storage));
Jeff Layton63c038c2008-12-01 18:41:46 -05001836
Joe Perchesb6b38f72010-04-21 03:50:45 +00001837 cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
Jeff Layton1e68b2b2009-06-11 10:27:30 -04001838
Jeff Layton63c038c2008-12-01 18:41:46 -05001839 if (volume_info->UNCip && volume_info->UNC) {
Jeff Layton50d97162010-07-06 20:43:01 -04001840 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
1841 volume_info->UNCip,
David Howells67b76262010-07-22 18:33:01 +01001842 strlen(volume_info->UNCip),
Jeff Layton50d97162010-07-06 20:43:01 -04001843 volume_info->port);
Jeff Layton1e68b2b2009-06-11 10:27:30 -04001844 if (!rc) {
Jeff Layton63c038c2008-12-01 18:41:46 -05001845 /* we failed translating address */
1846 rc = -EINVAL;
1847 goto out_err;
1848 }
Jeff Layton63c038c2008-12-01 18:41:46 -05001849 } else if (volume_info->UNCip) {
1850 /* BB using ip addr as tcp_ses name to connect to the
1851 DFS root below */
Joe Perchesb6b38f72010-04-21 03:50:45 +00001852 cERROR(1, "Connecting to DFS root not implemented yet");
Jeff Layton63c038c2008-12-01 18:41:46 -05001853 rc = -EINVAL;
1854 goto out_err;
1855 } else /* which tcp_sess DFS root would we conect to */ {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001856 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
1857 "unc=//192.168.1.100/public) specified");
Jeff Layton63c038c2008-12-01 18:41:46 -05001858 rc = -EINVAL;
1859 goto out_err;
1860 }
1861
1862 /* see if we already have a matching tcp_ses */
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001863 tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
Jeff Layton63c038c2008-12-01 18:41:46 -05001864 if (tcp_ses)
1865 return tcp_ses;
1866
1867 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1868 if (!tcp_ses) {
1869 rc = -ENOMEM;
1870 goto out_err;
1871 }
1872
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05001873 rc = cifs_crypto_shash_allocate(tcp_ses);
1874 if (rc) {
1875 cERROR(1, "could not setup hash structures rc %d", rc);
1876 goto out_err;
1877 }
1878
Rob Landleyf1d0c992011-01-22 15:44:05 -06001879 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
Jeff Layton63c038c2008-12-01 18:41:46 -05001880 tcp_ses->hostname = extract_hostname(volume_info->UNC);
1881 if (IS_ERR(tcp_ses->hostname)) {
1882 rc = PTR_ERR(tcp_ses->hostname);
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05001883 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05001884 }
1885
1886 tcp_ses->noblocksnd = volume_info->noblocksnd;
1887 tcp_ses->noautotune = volume_info->noautotune;
Steve French6a5fa2362010-01-01 01:28:43 +00001888 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
Jeff Layton63c038c2008-12-01 18:41:46 -05001889 atomic_set(&tcp_ses->inFlight, 0);
1890 init_waitqueue_head(&tcp_ses->response_q);
1891 init_waitqueue_head(&tcp_ses->request_q);
1892 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1893 mutex_init(&tcp_ses->srv_mutex);
1894 memcpy(tcp_ses->workstation_RFC1001_name,
1895 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1896 memcpy(tcp_ses->server_RFC1001_name,
1897 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05001898 tcp_ses->session_estab = false;
Jeff Layton63c038c2008-12-01 18:41:46 -05001899 tcp_ses->sequence_number = 0;
Steve Frenchfda35942011-01-20 18:06:34 +00001900 tcp_ses->lstrp = jiffies;
Jeff Layton63c038c2008-12-01 18:41:46 -05001901 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1902 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
Jeff Laytonc74093b2011-01-11 07:24:23 -05001903 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
Jeff Layton63c038c2008-12-01 18:41:46 -05001904
1905 /*
1906 * at this point we are the only ones with the pointer
1907 * to the struct since the kernel thread not created yet
1908 * no need to spinlock this init of tcpStatus or srv_count
1909 */
1910 tcp_ses->tcpStatus = CifsNew;
Ben Greear3eb9a882010-09-01 17:06:02 -07001911 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
1912 sizeof(tcp_ses->srcaddr));
Jeff Layton63c038c2008-12-01 18:41:46 -05001913 ++tcp_ses->srv_count;
1914
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001915 if (addr.ss_family == AF_INET6) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001916 cFYI(1, "attempting ipv6 connect");
Jeff Layton63c038c2008-12-01 18:41:46 -05001917 /* BB should we allow ipv6 on port 139? */
1918 /* other OS never observed in Wild doing 139 with v6 */
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001919 memcpy(&tcp_ses->dstaddr, sin_server6,
1920 sizeof(struct sockaddr_in6));
1921 } else
1922 memcpy(&tcp_ses->dstaddr, sin_server,
1923 sizeof(struct sockaddr_in));
1924
1925 rc = ip_connect(tcp_ses);
Jeff Layton63c038c2008-12-01 18:41:46 -05001926 if (rc < 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001927 cERROR(1, "Error connecting to socket. Aborting operation");
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05001928 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05001929 }
1930
1931 /*
1932 * since we're in a cifs function already, we know that
1933 * this will succeed. No need for try_module_get().
1934 */
1935 __module_get(THIS_MODULE);
Al Viro7c97c202011-06-21 08:51:28 -04001936 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
Jeff Layton63c038c2008-12-01 18:41:46 -05001937 tcp_ses, "cifsd");
1938 if (IS_ERR(tcp_ses->tsk)) {
1939 rc = PTR_ERR(tcp_ses->tsk);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001940 cERROR(1, "error %d create cifsd thread", rc);
Jeff Layton63c038c2008-12-01 18:41:46 -05001941 module_put(THIS_MODULE);
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05001942 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05001943 }
Steve Frenchfd88ce92011-04-12 01:01:14 +00001944 tcp_ses->tcpStatus = CifsNeedNegotiate;
Jeff Layton63c038c2008-12-01 18:41:46 -05001945
1946 /* thread spawned, put it on the list */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301947 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton63c038c2008-12-01 18:41:46 -05001948 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301949 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton63c038c2008-12-01 18:41:46 -05001950
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +05301951 cifs_fscache_get_client_cookie(tcp_ses);
1952
Jeff Laytonc74093b2011-01-11 07:24:23 -05001953 /* queue echo request delayed work */
1954 queue_delayed_work(system_nrt_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
1955
Jeff Layton63c038c2008-12-01 18:41:46 -05001956 return tcp_ses;
1957
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05001958out_err_crypto_release:
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05001959 cifs_crypto_shash_release(tcp_ses);
1960
Rob Landleyf1d0c992011-01-22 15:44:05 -06001961 put_net(cifs_net_ns(tcp_ses));
1962
Jeff Layton63c038c2008-12-01 18:41:46 -05001963out_err:
1964 if (tcp_ses) {
Steve French8347a5c2009-10-06 18:31:29 +00001965 if (!IS_ERR(tcp_ses->hostname))
1966 kfree(tcp_ses->hostname);
Jeff Layton63c038c2008-12-01 18:41:46 -05001967 if (tcp_ses->ssocket)
1968 sock_release(tcp_ses->ssocket);
1969 kfree(tcp_ses);
1970 }
1971 return ERR_PTR(rc);
1972}
1973
Steve French96daf2b2011-05-27 04:34:02 +00001974static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00001975{
1976 switch (ses->server->secType) {
1977 case Kerberos:
1978 if (vol->cred_uid != ses->cred_uid)
1979 return 0;
1980 break;
1981 default:
1982 /* anything else takes username/password */
1983 if (ses->user_name == NULL)
1984 return 0;
1985 if (strncmp(ses->user_name, vol->username,
1986 MAX_USERNAME_SIZE))
1987 return 0;
1988 if (strlen(vol->username) != 0 &&
1989 ses->password != NULL &&
1990 strncmp(ses->password,
1991 vol->password ? vol->password : "",
1992 MAX_PASSWORD_SIZE))
1993 return 0;
1994 }
1995 return 1;
1996}
1997
Steve French96daf2b2011-05-27 04:34:02 +00001998static struct cifs_ses *
Jeff Layton4ff67b72010-07-06 20:43:02 -04001999cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000{
Steve French96daf2b2011-05-27 04:34:02 +00002001 struct cifs_ses *ses;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302003 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton4ff67b72010-07-06 20:43:02 -04002004 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002005 if (!match_session(ses, vol))
2006 continue;
Jeff Layton14fbf502008-11-14 13:53:46 -05002007 ++ses->ses_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302008 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002009 return ses;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002010 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302011 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002012 return NULL;
2013}
2014
Jeff Layton14fbf502008-11-14 13:53:46 -05002015static void
Steve French96daf2b2011-05-27 04:34:02 +00002016cifs_put_smb_ses(struct cifs_ses *ses)
Jeff Layton14fbf502008-11-14 13:53:46 -05002017{
2018 int xid;
2019 struct TCP_Server_Info *server = ses->server;
2020
Jeff Layton36988c72010-04-24 07:57:43 -04002021 cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302022 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002023 if (--ses->ses_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302024 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002025 return;
2026 }
2027
2028 list_del_init(&ses->smb_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302029 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002030
2031 if (ses->status == CifsGood) {
2032 xid = GetXid();
2033 CIFSSMBLogoff(xid, ses);
2034 _FreeXid(xid);
2035 }
2036 sesInfoFree(ses);
2037 cifs_put_tcp_session(server);
2038}
2039
Steve Frenchd9b94202011-04-12 01:24:57 +00002040static bool warned_on_ntlm; /* globals init to false automatically */
2041
Steve French96daf2b2011-05-27 04:34:02 +00002042static struct cifs_ses *
Jeff Layton36988c72010-04-24 07:57:43 -04002043cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2044{
2045 int rc = -ENOMEM, xid;
Steve French96daf2b2011-05-27 04:34:02 +00002046 struct cifs_ses *ses;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002047 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2048 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
Jeff Layton36988c72010-04-24 07:57:43 -04002049
2050 xid = GetXid();
2051
Jeff Layton4ff67b72010-07-06 20:43:02 -04002052 ses = cifs_find_smb_ses(server, volume_info);
Jeff Layton36988c72010-04-24 07:57:43 -04002053 if (ses) {
2054 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
2055
Jeff Layton36988c72010-04-24 07:57:43 -04002056 mutex_lock(&ses->session_mutex);
Jeff Layton198b5682010-04-24 07:57:48 -04002057 rc = cifs_negotiate_protocol(xid, ses);
2058 if (rc) {
2059 mutex_unlock(&ses->session_mutex);
2060 /* problem -- put our ses reference */
2061 cifs_put_smb_ses(ses);
2062 FreeXid(xid);
2063 return ERR_PTR(rc);
2064 }
Jeff Layton36988c72010-04-24 07:57:43 -04002065 if (ses->need_reconnect) {
2066 cFYI(1, "Session needs reconnect");
2067 rc = cifs_setup_session(xid, ses,
2068 volume_info->local_nls);
2069 if (rc) {
2070 mutex_unlock(&ses->session_mutex);
2071 /* problem -- put our reference */
2072 cifs_put_smb_ses(ses);
2073 FreeXid(xid);
2074 return ERR_PTR(rc);
2075 }
2076 }
2077 mutex_unlock(&ses->session_mutex);
Jeff Layton460cf342010-09-14 11:38:24 -04002078
2079 /* existing SMB ses has a server reference already */
2080 cifs_put_tcp_session(server);
Jeff Layton36988c72010-04-24 07:57:43 -04002081 FreeXid(xid);
2082 return ses;
2083 }
2084
2085 cFYI(1, "Existing smb sess not found");
2086 ses = sesInfoAlloc();
2087 if (ses == NULL)
2088 goto get_ses_fail;
2089
2090 /* new SMB session uses our server ref */
2091 ses->server = server;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002092 if (server->dstaddr.ss_family == AF_INET6)
2093 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
Jeff Layton36988c72010-04-24 07:57:43 -04002094 else
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002095 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
Jeff Layton36988c72010-04-24 07:57:43 -04002096
Steve French8727c8a2011-02-25 01:11:56 -06002097 if (volume_info->username) {
2098 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2099 if (!ses->user_name)
2100 goto get_ses_fail;
2101 }
Jeff Layton36988c72010-04-24 07:57:43 -04002102
2103 /* volume_info->password freed at unmount */
2104 if (volume_info->password) {
2105 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2106 if (!ses->password)
2107 goto get_ses_fail;
2108 }
2109 if (volume_info->domainname) {
Shirish Pargaonkard3686d52010-10-28 09:53:07 -05002110 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2111 if (!ses->domainName)
2112 goto get_ses_fail;
Jeff Layton36988c72010-04-24 07:57:43 -04002113 }
Jeff Layton3e4b3e12010-07-19 18:00:17 -04002114 ses->cred_uid = volume_info->cred_uid;
Jeff Layton36988c72010-04-24 07:57:43 -04002115 ses->linux_uid = volume_info->linux_uid;
Steve Frenchd9b94202011-04-12 01:24:57 +00002116
2117 /* ntlmv2 is much stronger than ntlm security, and has been broadly
2118 supported for many years, time to update default security mechanism */
2119 if ((volume_info->secFlg == 0) && warned_on_ntlm == false) {
2120 warned_on_ntlm = true;
2121 cERROR(1, "default security mechanism requested. The default "
2122 "security mechanism will be upgraded from ntlm to "
Steve French9d1e3972011-10-06 23:14:07 -05002123 "ntlmv2 in kernel release 3.2");
Steve Frenchd9b94202011-04-12 01:24:57 +00002124 }
Jeff Layton36988c72010-04-24 07:57:43 -04002125 ses->overrideSecFlg = volume_info->secFlg;
2126
2127 mutex_lock(&ses->session_mutex);
Jeff Layton198b5682010-04-24 07:57:48 -04002128 rc = cifs_negotiate_protocol(xid, ses);
2129 if (!rc)
2130 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
Jeff Layton36988c72010-04-24 07:57:43 -04002131 mutex_unlock(&ses->session_mutex);
Steve Frenchc8e56f12010-09-08 21:10:58 +00002132 if (rc)
Jeff Layton36988c72010-04-24 07:57:43 -04002133 goto get_ses_fail;
2134
2135 /* success, put it on the list */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302136 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton36988c72010-04-24 07:57:43 -04002137 list_add(&ses->smb_ses_list, &server->smb_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302138 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton36988c72010-04-24 07:57:43 -04002139
2140 FreeXid(xid);
2141 return ses;
2142
2143get_ses_fail:
2144 sesInfoFree(ses);
2145 FreeXid(xid);
2146 return ERR_PTR(rc);
2147}
2148
Steve French96daf2b2011-05-27 04:34:02 +00002149static int match_tcon(struct cifs_tcon *tcon, const char *unc)
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002150{
2151 if (tcon->tidStatus == CifsExiting)
2152 return 0;
2153 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2154 return 0;
2155 return 1;
2156}
2157
Steve French96daf2b2011-05-27 04:34:02 +00002158static struct cifs_tcon *
2159cifs_find_tcon(struct cifs_ses *ses, const char *unc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002160{
2161 struct list_head *tmp;
Steve French96daf2b2011-05-27 04:34:02 +00002162 struct cifs_tcon *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002163
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302164 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002165 list_for_each(tmp, &ses->tcon_list) {
Steve French96daf2b2011-05-27 04:34:02 +00002166 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002167 if (!match_tcon(tcon, unc))
Jeff Laytonf1987b42008-11-15 11:12:47 -05002168 continue;
Jeff Laytonf1987b42008-11-15 11:12:47 -05002169 ++tcon->tc_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302170 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002171 return tcon;
2172 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302173 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174 return NULL;
2175}
2176
Jeff Laytonf1987b42008-11-15 11:12:47 -05002177static void
Steve French96daf2b2011-05-27 04:34:02 +00002178cifs_put_tcon(struct cifs_tcon *tcon)
Jeff Laytonf1987b42008-11-15 11:12:47 -05002179{
2180 int xid;
Steve French96daf2b2011-05-27 04:34:02 +00002181 struct cifs_ses *ses = tcon->ses;
Jeff Laytonf1987b42008-11-15 11:12:47 -05002182
Jeff Laytond00c28d2010-04-24 07:57:44 -04002183 cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302184 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002185 if (--tcon->tc_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302186 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002187 return;
2188 }
2189
2190 list_del_init(&tcon->tcon_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302191 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002192
2193 xid = GetXid();
2194 CIFSSMBTDis(xid, tcon);
2195 _FreeXid(xid);
2196
Suresh Jayaramand03382c2010-07-05 18:12:27 +05302197 cifs_fscache_release_super_cookie(tcon);
Steve French9f841592010-07-23 20:37:53 +00002198 tconInfoFree(tcon);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002199 cifs_put_smb_ses(ses);
2200}
2201
Steve French96daf2b2011-05-27 04:34:02 +00002202static struct cifs_tcon *
2203cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
Jeff Laytond00c28d2010-04-24 07:57:44 -04002204{
2205 int rc, xid;
Steve French96daf2b2011-05-27 04:34:02 +00002206 struct cifs_tcon *tcon;
Jeff Laytond00c28d2010-04-24 07:57:44 -04002207
2208 tcon = cifs_find_tcon(ses, volume_info->UNC);
2209 if (tcon) {
2210 cFYI(1, "Found match on UNC path");
2211 /* existing tcon already has a reference */
2212 cifs_put_smb_ses(ses);
2213 if (tcon->seal != volume_info->seal)
2214 cERROR(1, "transport encryption setting "
2215 "conflicts with existing tid");
2216 return tcon;
2217 }
2218
2219 tcon = tconInfoAlloc();
2220 if (tcon == NULL) {
2221 rc = -ENOMEM;
2222 goto out_fail;
2223 }
2224
2225 tcon->ses = ses;
2226 if (volume_info->password) {
2227 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2228 if (!tcon->password) {
2229 rc = -ENOMEM;
2230 goto out_fail;
2231 }
2232 }
2233
2234 if (strchr(volume_info->UNC + 3, '\\') == NULL
2235 && strchr(volume_info->UNC + 3, '/') == NULL) {
2236 cERROR(1, "Missing share name");
2237 rc = -ENODEV;
2238 goto out_fail;
2239 }
2240
2241 /* BB Do we need to wrap session_mutex around
2242 * this TCon call and Unix SetFS as
2243 * we do on SessSetup and reconnect? */
2244 xid = GetXid();
2245 rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
2246 FreeXid(xid);
2247 cFYI(1, "CIFS Tcon rc = %d", rc);
2248 if (rc)
2249 goto out_fail;
2250
2251 if (volume_info->nodfs) {
2252 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2253 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2254 }
2255 tcon->seal = volume_info->seal;
2256 /* we can have only one retry value for a connection
2257 to a share so for resources mounted more than once
2258 to the same server share the last value passed in
2259 for the retry flag is used */
2260 tcon->retry = volume_info->retry;
2261 tcon->nocase = volume_info->nocase;
2262 tcon->local_lease = volume_info->local_lease;
2263
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302264 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002265 list_add(&tcon->tcon_list, &ses->tcon_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302266 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002267
Suresh Jayaramand03382c2010-07-05 18:12:27 +05302268 cifs_fscache_get_super_cookie(tcon);
2269
Jeff Laytond00c28d2010-04-24 07:57:44 -04002270 return tcon;
2271
2272out_fail:
2273 tconInfoFree(tcon);
2274 return ERR_PTR(rc);
2275}
2276
Jeff Layton9d002df2010-10-06 19:51:11 -04002277void
2278cifs_put_tlink(struct tcon_link *tlink)
2279{
2280 if (!tlink || IS_ERR(tlink))
2281 return;
2282
2283 if (!atomic_dec_and_test(&tlink->tl_count) ||
2284 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2285 tlink->tl_time = jiffies;
2286 return;
2287 }
2288
2289 if (!IS_ERR(tlink_tcon(tlink)))
2290 cifs_put_tcon(tlink_tcon(tlink));
2291 kfree(tlink);
2292 return;
2293}
Jeff Laytond00c28d2010-04-24 07:57:44 -04002294
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002295static inline struct tcon_link *
Pavel Shilovskycd518752011-06-09 12:58:53 +04002296cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2297{
2298 return cifs_sb->master_tlink;
2299}
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002300
2301static int
2302compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2303{
2304 struct cifs_sb_info *old = CIFS_SB(sb);
2305 struct cifs_sb_info *new = mnt_data->cifs_sb;
2306
2307 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2308 return 0;
2309
2310 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2311 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2312 return 0;
2313
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002314 /*
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002315 * We want to share sb only if we don't specify an r/wsize or
2316 * specified r/wsize is greater than or equal to existing one.
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002317 */
2318 if (new->wsize && new->wsize < old->wsize)
2319 return 0;
2320
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002321 if (new->rsize && new->rsize < old->rsize)
2322 return 0;
2323
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002324 if (old->mnt_uid != new->mnt_uid || old->mnt_gid != new->mnt_gid)
2325 return 0;
2326
2327 if (old->mnt_file_mode != new->mnt_file_mode ||
2328 old->mnt_dir_mode != new->mnt_dir_mode)
2329 return 0;
2330
2331 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2332 return 0;
2333
2334 if (old->actimeo != new->actimeo)
2335 return 0;
2336
2337 return 1;
2338}
2339
2340int
2341cifs_match_super(struct super_block *sb, void *data)
2342{
2343 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2344 struct smb_vol *volume_info;
2345 struct cifs_sb_info *cifs_sb;
2346 struct TCP_Server_Info *tcp_srv;
Steve French96daf2b2011-05-27 04:34:02 +00002347 struct cifs_ses *ses;
2348 struct cifs_tcon *tcon;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002349 struct tcon_link *tlink;
2350 struct sockaddr_storage addr;
2351 int rc = 0;
2352
2353 memset(&addr, 0, sizeof(struct sockaddr_storage));
2354
2355 spin_lock(&cifs_tcp_ses_lock);
2356 cifs_sb = CIFS_SB(sb);
2357 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2358 if (IS_ERR(tlink)) {
2359 spin_unlock(&cifs_tcp_ses_lock);
2360 return rc;
2361 }
2362 tcon = tlink_tcon(tlink);
2363 ses = tcon->ses;
2364 tcp_srv = ses->server;
2365
2366 volume_info = mnt_data->vol;
2367
2368 if (!volume_info->UNCip || !volume_info->UNC)
2369 goto out;
2370
2371 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
2372 volume_info->UNCip,
2373 strlen(volume_info->UNCip),
2374 volume_info->port);
2375 if (!rc)
2376 goto out;
2377
2378 if (!match_server(tcp_srv, (struct sockaddr *)&addr, volume_info) ||
2379 !match_session(ses, volume_info) ||
2380 !match_tcon(tcon, volume_info->UNC)) {
2381 rc = 0;
2382 goto out;
2383 }
2384
2385 rc = compare_mount_options(sb, mnt_data);
2386out:
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002387 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf484b5d02011-07-11 10:16:34 -04002388 cifs_put_tlink(tlink);
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002389 return rc;
2390}
2391
Linus Torvalds1da177e2005-04-16 15:20:36 -07002392int
Steve French96daf2b2011-05-27 04:34:02 +00002393get_dfs_path(int xid, struct cifs_ses *pSesInfo, const char *old_path,
Steve French50c2f752007-07-13 00:33:32 +00002394 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
Steve French366781c2008-01-25 10:12:41 +00002395 struct dfs_info3_param **preferrals, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002396{
2397 char *temp_unc;
2398 int rc = 0;
2399
2400 *pnum_referrals = 0;
Steve French366781c2008-01-25 10:12:41 +00002401 *preferrals = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002402
2403 if (pSesInfo->ipc_tid == 0) {
2404 temp_unc = kmalloc(2 /* for slashes */ +
Steve French50c2f752007-07-13 00:33:32 +00002405 strnlen(pSesInfo->serverName,
2406 SERVER_NAME_LEN_WITH_NULL * 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002407 + 1 + 4 /* slash IPC$ */ + 2,
2408 GFP_KERNEL);
2409 if (temp_unc == NULL)
2410 return -ENOMEM;
2411 temp_unc[0] = '\\';
2412 temp_unc[1] = '\\';
2413 strcpy(temp_unc + 2, pSesInfo->serverName);
2414 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2415 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
Joe Perchesb6b38f72010-04-21 03:50:45 +00002416 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002417 kfree(temp_unc);
2418 }
2419 if (rc == 0)
Steve Frenchc2cf07d2008-05-15 06:20:02 +00002420 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
Steve French737b7582005-04-28 22:41:06 -07002421 pnum_referrals, nls_codepage, remap);
Steve French366781c2008-01-25 10:12:41 +00002422 /* BB map targetUNCs to dfs_info3 structures, here or
2423 in CIFSGetDFSRefer BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002424
2425 return rc;
2426}
2427
Jeff Layton09e50d52008-07-23 10:11:19 -04002428#ifdef CONFIG_DEBUG_LOCK_ALLOC
2429static struct lock_class_key cifs_key[2];
2430static struct lock_class_key cifs_slock_key[2];
2431
2432static inline void
2433cifs_reclassify_socket4(struct socket *sock)
2434{
2435 struct sock *sk = sock->sk;
2436 BUG_ON(sock_owned_by_user(sk));
2437 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2438 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2439}
2440
2441static inline void
2442cifs_reclassify_socket6(struct socket *sock)
2443{
2444 struct sock *sk = sock->sk;
2445 BUG_ON(sock_owned_by_user(sk));
2446 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2447 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2448}
2449#else
2450static inline void
2451cifs_reclassify_socket4(struct socket *sock)
2452{
2453}
2454
2455static inline void
2456cifs_reclassify_socket6(struct socket *sock)
2457{
2458}
2459#endif
2460
Linus Torvalds1da177e2005-04-16 15:20:36 -07002461/* See RFC1001 section 14 on representation of Netbios names */
Steve French50c2f752007-07-13 00:33:32 +00002462static void rfc1002mangle(char *target, char *source, unsigned int length)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002463{
Steve French50c2f752007-07-13 00:33:32 +00002464 unsigned int i, j;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002465
Steve French50c2f752007-07-13 00:33:32 +00002466 for (i = 0, j = 0; i < (length); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002467 /* mask a nibble at a time and encode */
2468 target[j] = 'A' + (0x0F & (source[i] >> 4));
2469 target[j+1] = 'A' + (0x0F & source[i]);
Steve French50c2f752007-07-13 00:33:32 +00002470 j += 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002471 }
2472
2473}
2474
Ben Greear3eb9a882010-09-01 17:06:02 -07002475static int
2476bind_socket(struct TCP_Server_Info *server)
2477{
2478 int rc = 0;
2479 if (server->srcaddr.ss_family != AF_UNSPEC) {
2480 /* Bind to the specified local IP address */
2481 struct socket *socket = server->ssocket;
2482 rc = socket->ops->bind(socket,
2483 (struct sockaddr *) &server->srcaddr,
2484 sizeof(server->srcaddr));
2485 if (rc < 0) {
2486 struct sockaddr_in *saddr4;
2487 struct sockaddr_in6 *saddr6;
2488 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2489 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2490 if (saddr6->sin6_family == AF_INET6)
2491 cERROR(1, "cifs: "
2492 "Failed to bind to: %pI6c, error: %d\n",
2493 &saddr6->sin6_addr, rc);
2494 else
2495 cERROR(1, "cifs: "
2496 "Failed to bind to: %pI4, error: %d\n",
2497 &saddr4->sin_addr.s_addr, rc);
2498 }
2499 }
2500 return rc;
2501}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002502
2503static int
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002504ip_rfc1001_connect(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002505{
2506 int rc = 0;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002507 /*
2508 * some servers require RFC1001 sessinit before sending
2509 * negprot - BB check reconnection in case where second
2510 * sessinit is sent but no second negprot
2511 */
2512 struct rfc1002_session_packet *ses_init_buf;
2513 struct smb_hdr *smb_buf;
2514 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2515 GFP_KERNEL);
2516 if (ses_init_buf) {
2517 ses_init_buf->trailer.session_req.called_len = 32;
2518
2519 if (server->server_RFC1001_name &&
2520 server->server_RFC1001_name[0] != 0)
2521 rfc1002mangle(ses_init_buf->trailer.
2522 session_req.called_name,
2523 server->server_RFC1001_name,
2524 RFC1001_NAME_LEN_WITH_NULL);
2525 else
2526 rfc1002mangle(ses_init_buf->trailer.
2527 session_req.called_name,
2528 DEFAULT_CIFS_CALLED_NAME,
2529 RFC1001_NAME_LEN_WITH_NULL);
2530
2531 ses_init_buf->trailer.session_req.calling_len = 32;
2532
2533 /*
2534 * calling name ends in null (byte 16) from old smb
2535 * convention.
2536 */
2537 if (server->workstation_RFC1001_name &&
2538 server->workstation_RFC1001_name[0] != 0)
2539 rfc1002mangle(ses_init_buf->trailer.
2540 session_req.calling_name,
2541 server->workstation_RFC1001_name,
2542 RFC1001_NAME_LEN_WITH_NULL);
2543 else
2544 rfc1002mangle(ses_init_buf->trailer.
2545 session_req.calling_name,
2546 "LINUX_CIFS_CLNT",
2547 RFC1001_NAME_LEN_WITH_NULL);
2548
2549 ses_init_buf->trailer.session_req.scope1 = 0;
2550 ses_init_buf->trailer.session_req.scope2 = 0;
2551 smb_buf = (struct smb_hdr *)ses_init_buf;
2552
2553 /* sizeof RFC1002_SESSION_REQUEST with no scope */
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002554 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002555 rc = smb_send(server, smb_buf, 0x44);
2556 kfree(ses_init_buf);
2557 /*
2558 * RFC1001 layer in at least one server
2559 * requires very short break before negprot
2560 * presumably because not expecting negprot
2561 * to follow so fast. This is a simple
2562 * solution that works without
2563 * complicating the code and causes no
2564 * significant slowing down on mount
2565 * for everyone else
2566 */
2567 usleep_range(1000, 2000);
2568 }
2569 /*
2570 * else the negprot may still work without this
2571 * even though malloc failed
2572 */
2573
2574 return rc;
2575}
2576
2577static int
2578generic_ip_connect(struct TCP_Server_Info *server)
2579{
2580 int rc = 0;
Steve French6da97912011-03-13 18:55:55 +00002581 __be16 sport;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002582 int slen, sfamily;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002583 struct socket *socket = server->ssocket;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002584 struct sockaddr *saddr;
2585
2586 saddr = (struct sockaddr *) &server->dstaddr;
2587
2588 if (server->dstaddr.ss_family == AF_INET6) {
2589 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2590 slen = sizeof(struct sockaddr_in6);
2591 sfamily = AF_INET6;
2592 } else {
2593 sport = ((struct sockaddr_in *) saddr)->sin_port;
2594 slen = sizeof(struct sockaddr_in);
2595 sfamily = AF_INET;
2596 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002597
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002598 if (socket == NULL) {
Rob Landleyf1d0c992011-01-22 15:44:05 -06002599 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2600 IPPROTO_TCP, &socket, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002601 if (rc < 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002602 cERROR(1, "Error %d creating socket", rc);
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002603 server->ssocket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002604 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002605 }
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002606
2607 /* BB other socket options to set KEEPALIVE, NODELAY? */
Joe Perchesb6b38f72010-04-21 03:50:45 +00002608 cFYI(1, "Socket created");
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002609 server->ssocket = socket;
2610 socket->sk->sk_allocation = GFP_NOFS;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002611 if (sfamily == AF_INET6)
2612 cifs_reclassify_socket6(socket);
2613 else
2614 cifs_reclassify_socket4(socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002615 }
2616
Ben Greear3eb9a882010-09-01 17:06:02 -07002617 rc = bind_socket(server);
2618 if (rc < 0)
2619 return rc;
2620
Jeff Laytond5c56052008-12-01 18:42:33 -05002621 /*
2622 * Eventually check for other socket options to change from
2623 * the default. sock_setsockopt not used because it expects
2624 * user space buffer
2625 */
2626 socket->sk->sk_rcvtimeo = 7 * HZ;
Steve Frenchda505c32009-01-19 03:49:35 +00002627 socket->sk->sk_sndtimeo = 5 * HZ;
Steve French6a5fa2362010-01-01 01:28:43 +00002628
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002629 /* make the bufsizes depend on wsize/rsize and max requests */
2630 if (server->noautotune) {
2631 if (socket->sk->sk_sndbuf < (200 * 1024))
2632 socket->sk->sk_sndbuf = 200 * 1024;
2633 if (socket->sk->sk_rcvbuf < (140 * 1024))
2634 socket->sk->sk_rcvbuf = 140 * 1024;
2635 }
2636
Steve French6a5fa2362010-01-01 01:28:43 +00002637 if (server->tcp_nodelay) {
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002638 int val = 1;
Steve French6a5fa2362010-01-01 01:28:43 +00002639 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2640 (char *)&val, sizeof(val));
2641 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002642 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
Steve French6a5fa2362010-01-01 01:28:43 +00002643 }
2644
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002645 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
2646 socket->sk->sk_sndbuf,
2647 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
2648
Jeff Laytonee1b3ea2011-06-21 07:18:26 -04002649 rc = socket->ops->connect(socket, saddr, slen, 0);
2650 if (rc < 0) {
2651 cFYI(1, "Error %d connecting to server", rc);
2652 sock_release(socket);
2653 server->ssocket = NULL;
2654 return rc;
2655 }
2656
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002657 if (sport == htons(RFC1001_PORT))
2658 rc = ip_rfc1001_connect(server);
Steve French50c2f752007-07-13 00:33:32 +00002659
Linus Torvalds1da177e2005-04-16 15:20:36 -07002660 return rc;
2661}
2662
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002663static int
2664ip_connect(struct TCP_Server_Info *server)
2665{
Steve French6da97912011-03-13 18:55:55 +00002666 __be16 *sport;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002667 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2668 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2669
2670 if (server->dstaddr.ss_family == AF_INET6)
2671 sport = &addr6->sin6_port;
2672 else
2673 sport = &addr->sin_port;
2674
2675 if (*sport == 0) {
2676 int rc;
2677
2678 /* try with 445 port at first */
2679 *sport = htons(CIFS_PORT);
2680
2681 rc = generic_ip_connect(server);
2682 if (rc >= 0)
2683 return rc;
2684
2685 /* if it failed, try with 139 port */
2686 *sport = htons(RFC1001_PORT);
2687 }
2688
2689 return generic_ip_connect(server);
2690}
2691
Steve French96daf2b2011-05-27 04:34:02 +00002692void reset_cifs_unix_caps(int xid, struct cifs_tcon *tcon,
Al Viro2c6292a2011-06-17 09:05:48 -04002693 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
Steve French8af18972007-02-14 04:42:51 +00002694{
2695 /* if we are reconnecting then should we check to see if
2696 * any requested capabilities changed locally e.g. via
2697 * remount but we can not do much about it here
2698 * if they have (even if we could detect it by the following)
2699 * Perhaps we could add a backpointer to array of sb from tcon
2700 * or if we change to make all sb to same share the same
2701 * sb as NFS - then we only have one backpointer to sb.
2702 * What if we wanted to mount the server share twice once with
2703 * and once without posixacls or posix paths? */
2704 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French50c2f752007-07-13 00:33:32 +00002705
Steve Frenchc18c8422007-07-18 23:21:09 +00002706 if (vol_info && vol_info->no_linux_ext) {
2707 tcon->fsUnixInfo.Capability = 0;
2708 tcon->unix_ext = 0; /* Unix Extensions disabled */
Joe Perchesb6b38f72010-04-21 03:50:45 +00002709 cFYI(1, "Linux protocol extensions disabled");
Steve Frenchc18c8422007-07-18 23:21:09 +00002710 return;
2711 } else if (vol_info)
2712 tcon->unix_ext = 1; /* Unix Extensions supported */
2713
2714 if (tcon->unix_ext == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002715 cFYI(1, "Unix extensions disabled so not set on reconnect");
Steve Frenchc18c8422007-07-18 23:21:09 +00002716 return;
2717 }
Steve French50c2f752007-07-13 00:33:32 +00002718
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002719 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
Steve French8af18972007-02-14 04:42:51 +00002720 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French6848b732011-05-26 18:38:54 +00002721 cFYI(1, "unix caps which server supports %lld", cap);
Steve French8af18972007-02-14 04:42:51 +00002722 /* check for reconnect case in which we do not
2723 want to change the mount behavior if we can avoid it */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002724 if (vol_info == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00002725 /* turn off POSIX ACL and PATHNAMES if not set
Steve French8af18972007-02-14 04:42:51 +00002726 originally at mount time */
2727 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2728 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00002729 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2730 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002731 cERROR(1, "POSIXPATH support change");
Steve French8af18972007-02-14 04:42:51 +00002732 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00002733 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002734 cERROR(1, "possible reconnect error");
2735 cERROR(1, "server disabled POSIX path support");
Igor Mammedov11b6d642008-02-15 19:06:04 +00002736 }
Steve French8af18972007-02-14 04:42:51 +00002737 }
Steve French50c2f752007-07-13 00:33:32 +00002738
Steve French6848b732011-05-26 18:38:54 +00002739 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
2740 cERROR(1, "per-share encryption not supported yet");
2741
Steve French8af18972007-02-14 04:42:51 +00002742 cap &= CIFS_UNIX_CAP_MASK;
Steve French75865f8c2007-06-24 18:30:48 +00002743 if (vol_info && vol_info->no_psx_acl)
Steve French8af18972007-02-14 04:42:51 +00002744 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00002745 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002746 cFYI(1, "negotiated posix acl support");
Al Viro2c6292a2011-06-17 09:05:48 -04002747 if (cifs_sb)
2748 cifs_sb->mnt_cifs_flags |=
2749 CIFS_MOUNT_POSIXACL;
Steve French8af18972007-02-14 04:42:51 +00002750 }
2751
Steve French75865f8c2007-06-24 18:30:48 +00002752 if (vol_info && vol_info->posix_paths == 0)
Steve French8af18972007-02-14 04:42:51 +00002753 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00002754 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002755 cFYI(1, "negotiate posix pathnames");
Al Viro2c6292a2011-06-17 09:05:48 -04002756 if (cifs_sb)
2757 cifs_sb->mnt_cifs_flags |=
Steve French8af18972007-02-14 04:42:51 +00002758 CIFS_MOUNT_POSIX_PATHS;
2759 }
Steve French50c2f752007-07-13 00:33:32 +00002760
Joe Perchesb6b38f72010-04-21 03:50:45 +00002761 cFYI(1, "Negotiate caps 0x%x", (int)cap);
Steve French8af18972007-02-14 04:42:51 +00002762#ifdef CONFIG_CIFS_DEBUG2
Steve French75865f8c2007-06-24 18:30:48 +00002763 if (cap & CIFS_UNIX_FCNTL_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002764 cFYI(1, "FCNTL cap");
Steve French75865f8c2007-06-24 18:30:48 +00002765 if (cap & CIFS_UNIX_EXTATTR_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002766 cFYI(1, "EXTATTR cap");
Steve French75865f8c2007-06-24 18:30:48 +00002767 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002768 cFYI(1, "POSIX path cap");
Steve French75865f8c2007-06-24 18:30:48 +00002769 if (cap & CIFS_UNIX_XATTR_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002770 cFYI(1, "XATTR cap");
Steve French75865f8c2007-06-24 18:30:48 +00002771 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002772 cFYI(1, "POSIX ACL cap");
Steve French75865f8c2007-06-24 18:30:48 +00002773 if (cap & CIFS_UNIX_LARGE_READ_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002774 cFYI(1, "very large read cap");
Steve French75865f8c2007-06-24 18:30:48 +00002775 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002776 cFYI(1, "very large write cap");
Steve French6848b732011-05-26 18:38:54 +00002777 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
2778 cFYI(1, "transport encryption cap");
2779 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
2780 cFYI(1, "mandatory transport encryption cap");
Steve French8af18972007-02-14 04:42:51 +00002781#endif /* CIFS_DEBUG2 */
2782 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
Steve French442aa312007-09-24 20:25:46 +00002783 if (vol_info == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002784 cFYI(1, "resetting capabilities failed");
Steve French442aa312007-09-24 20:25:46 +00002785 } else
Joe Perchesb6b38f72010-04-21 03:50:45 +00002786 cERROR(1, "Negotiating Unix capabilities "
Steve French5a44b312007-09-20 15:16:24 +00002787 "with the server failed. Consider "
2788 "mounting with the Unix Extensions\n"
2789 "disabled, if problems are found, "
2790 "by specifying the nounix mount "
Joe Perchesb6b38f72010-04-21 03:50:45 +00002791 "option.");
Steve French5a44b312007-09-20 15:16:24 +00002792
Steve French8af18972007-02-14 04:42:51 +00002793 }
2794 }
2795}
2796
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00002797void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
2798 struct cifs_sb_info *cifs_sb)
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04002799{
Jeff Layton2de970f2010-10-06 19:51:12 -04002800 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
2801
Al Viro2ced6f62011-06-17 09:20:04 -04002802 spin_lock_init(&cifs_sb->tlink_tree_lock);
2803 cifs_sb->tlink_tree = RB_ROOT;
2804
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002805 /*
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002806 * Temporarily set r/wsize for matching superblock. If we end up using
2807 * new sb then client will later negotiate it downward if needed.
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002808 */
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002809 cifs_sb->rsize = pvolume_info->rsize;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002810 cifs_sb->wsize = pvolume_info->wsize;
2811
Steve French3b795212008-11-13 19:45:32 +00002812 cifs_sb->mnt_uid = pvolume_info->linux_uid;
2813 cifs_sb->mnt_gid = pvolume_info->linux_gid;
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05002814 if (pvolume_info->backupuid_specified)
2815 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
2816 if (pvolume_info->backupgid_specified)
2817 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
Steve French3b795212008-11-13 19:45:32 +00002818 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2819 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
Joe Perchesb6b38f72010-04-21 03:50:45 +00002820 cFYI(1, "file mode: 0x%x dir mode: 0x%x",
2821 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
Steve French3b795212008-11-13 19:45:32 +00002822
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05302823 cifs_sb->actimeo = pvolume_info->actimeo;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00002824 cifs_sb->local_nls = pvolume_info->local_nls;
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05302825
Steve French3b795212008-11-13 19:45:32 +00002826 if (pvolume_info->noperm)
2827 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2828 if (pvolume_info->setuids)
2829 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2830 if (pvolume_info->server_ino)
2831 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2832 if (pvolume_info->remap)
2833 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2834 if (pvolume_info->no_xattr)
2835 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2836 if (pvolume_info->sfu_emul)
2837 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2838 if (pvolume_info->nobrl)
2839 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
Steve Frenchbe652442009-02-23 15:21:59 +00002840 if (pvolume_info->nostrictsync)
Steve French4717bed2009-02-24 14:44:19 +00002841 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
Steve French13a6e422008-12-02 17:24:33 +00002842 if (pvolume_info->mand_lock)
2843 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002844 if (pvolume_info->rwpidforward)
2845 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
Steve French3b795212008-11-13 19:45:32 +00002846 if (pvolume_info->cifs_acl)
2847 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05002848 if (pvolume_info->backupuid_specified)
2849 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
2850 if (pvolume_info->backupgid_specified)
2851 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
Steve French3b795212008-11-13 19:45:32 +00002852 if (pvolume_info->override_uid)
2853 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2854 if (pvolume_info->override_gid)
2855 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2856 if (pvolume_info->dynperm)
2857 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
Suresh Jayaramanfa1df752010-07-05 18:13:36 +05302858 if (pvolume_info->fsc)
2859 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
Jeff Layton0eb8a132010-10-06 19:51:12 -04002860 if (pvolume_info->multiuser)
2861 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
2862 CIFS_MOUNT_NO_PERM);
Pavel Shilovskyd39454f2011-01-24 14:16:35 -05002863 if (pvolume_info->strict_io)
2864 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
Steve French3b795212008-11-13 19:45:32 +00002865 if (pvolume_info->direct_io) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002866 cFYI(1, "mounting share using direct i/o");
Steve French3b795212008-11-13 19:45:32 +00002867 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2868 }
Stefan Metzmacher736a3322010-07-30 14:56:00 +02002869 if (pvolume_info->mfsymlinks) {
2870 if (pvolume_info->sfu_emul) {
2871 cERROR(1, "mount option mfsymlinks ignored if sfu "
2872 "mount option is used");
2873 } else {
2874 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
2875 }
2876 }
Steve French3b795212008-11-13 19:45:32 +00002877
2878 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
Joe Perchesb6b38f72010-04-21 03:50:45 +00002879 cERROR(1, "mount option dynperm ignored if cifsacl "
2880 "mount option supported");
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04002881}
2882
Jeff Laytonf7910cb2011-05-19 16:22:58 -04002883/*
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002884 * When the server supports very large reads and writes via POSIX extensions,
2885 * we can allow up to 2^24-1, minus the size of a READ/WRITE_AND_X header, not
2886 * including the RFC1001 length.
Jeff Laytonf7910cb2011-05-19 16:22:58 -04002887 *
2888 * Note that this might make for "interesting" allocation problems during
Jeff Layton1190f6a2011-06-22 17:33:57 -04002889 * writeback however as we have to allocate an array of pointers for the
2890 * pages. A 16M write means ~32kb page array with PAGE_CACHE_SIZE == 4096.
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002891 *
2892 * For reads, there is a similar problem as we need to allocate an array
2893 * of kvecs to handle the receive, though that should only need to be done
2894 * once.
Jeff Laytonf7910cb2011-05-19 16:22:58 -04002895 */
Jeff Layton1190f6a2011-06-22 17:33:57 -04002896#define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002897#define CIFS_MAX_RSIZE ((1<<24) - sizeof(READ_RSP) + 4)
Jeff Laytonf7910cb2011-05-19 16:22:58 -04002898
2899/*
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002900 * When the server doesn't allow large posix writes, only allow a rsize/wsize
2901 * of 2^17-1 minus the size of the call header. That allows for a read or
2902 * write up to the maximum size described by RFC1002.
Jeff Laytonf7910cb2011-05-19 16:22:58 -04002903 */
Pavel Shilovsky94443f42011-10-07 18:57:45 +04002904#define CIFS_MAX_RFC1002_WSIZE ((1<<17) - 1 - sizeof(WRITE_REQ) + 4)
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002905#define CIFS_MAX_RFC1002_RSIZE ((1<<17) - 1 - sizeof(READ_RSP) + 4)
Jeff Laytonf7910cb2011-05-19 16:22:58 -04002906
2907/*
2908 * The default wsize is 1M. find_get_pages seems to return a maximum of 256
2909 * pages in a single call. With PAGE_CACHE_SIZE == 4k, this means we can fill
2910 * a single wsize request with a single call.
2911 */
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002912#define CIFS_DEFAULT_IOSIZE (1024 * 1024)
2913
2914/*
2915 * Windows only supports a max of 60k reads. Default to that when posix
2916 * extensions aren't in force.
2917 */
2918#define CIFS_DEFAULT_NON_POSIX_RSIZE (60 * 1024)
Jeff Laytonf7910cb2011-05-19 16:22:58 -04002919
2920static unsigned int
Steve French96daf2b2011-05-27 04:34:02 +00002921cifs_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
Jeff Laytonf7910cb2011-05-19 16:22:58 -04002922{
2923 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2924 struct TCP_Server_Info *server = tcon->ses->server;
2925 unsigned int wsize = pvolume_info->wsize ? pvolume_info->wsize :
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002926 CIFS_DEFAULT_IOSIZE;
Jeff Laytonf7910cb2011-05-19 16:22:58 -04002927
2928 /* can server support 24-bit write sizes? (via UNIX extensions) */
2929 if (!tcon->unix_ext || !(unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
Jeff Layton1190f6a2011-06-22 17:33:57 -04002930 wsize = min_t(unsigned int, wsize, CIFS_MAX_RFC1002_WSIZE);
Jeff Laytonf7910cb2011-05-19 16:22:58 -04002931
Jeff Layton1190f6a2011-06-22 17:33:57 -04002932 /*
2933 * no CAP_LARGE_WRITE_X or is signing enabled without CAP_UNIX set?
2934 * Limit it to max buffer offered by the server, minus the size of the
2935 * WRITEX header, not including the 4 byte RFC1001 length.
2936 */
2937 if (!(server->capabilities & CAP_LARGE_WRITE_X) ||
2938 (!(server->capabilities & CAP_UNIX) &&
2939 (server->sec_mode & (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED))))
2940 wsize = min_t(unsigned int, wsize,
2941 server->maxBuf - sizeof(WRITE_REQ) + 4);
Jeff Laytonf7910cb2011-05-19 16:22:58 -04002942
2943 /* hard limit of CIFS_MAX_WSIZE */
2944 wsize = min_t(unsigned int, wsize, CIFS_MAX_WSIZE);
2945
2946 return wsize;
2947}
2948
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002949static unsigned int
2950cifs_negotiate_rsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
2951{
2952 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2953 struct TCP_Server_Info *server = tcon->ses->server;
2954 unsigned int rsize, defsize;
2955
2956 /*
2957 * Set default value...
2958 *
2959 * HACK alert! Ancient servers have very small buffers. Even though
2960 * MS-CIFS indicates that servers are only limited by the client's
2961 * bufsize for reads, testing against win98se shows that it throws
2962 * INVALID_PARAMETER errors if you try to request too large a read.
2963 *
2964 * If the server advertises a MaxBufferSize of less than one page,
2965 * assume that it also can't satisfy reads larger than that either.
2966 *
2967 * FIXME: Is there a better heuristic for this?
2968 */
2969 if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_READ_CAP))
2970 defsize = CIFS_DEFAULT_IOSIZE;
2971 else if (server->capabilities & CAP_LARGE_READ_X)
2972 defsize = CIFS_DEFAULT_NON_POSIX_RSIZE;
2973 else if (server->maxBuf >= PAGE_CACHE_SIZE)
2974 defsize = CIFSMaxBufSize;
2975 else
2976 defsize = server->maxBuf - sizeof(READ_RSP);
2977
2978 rsize = pvolume_info->rsize ? pvolume_info->rsize : defsize;
2979
2980 /*
2981 * no CAP_LARGE_READ_X? Then MS-CIFS states that we must limit this to
2982 * the client's MaxBufferSize.
2983 */
2984 if (!(server->capabilities & CAP_LARGE_READ_X))
2985 rsize = min_t(unsigned int, CIFSMaxBufSize, rsize);
2986
2987 /* hard limit of CIFS_MAX_RSIZE */
2988 rsize = min_t(unsigned int, rsize, CIFS_MAX_RSIZE);
2989
2990 return rsize;
2991}
2992
Igor Mammedove4cce942009-02-10 14:10:26 +03002993static int
Steve French96daf2b2011-05-27 04:34:02 +00002994is_path_accessible(int xid, struct cifs_tcon *tcon,
Igor Mammedove4cce942009-02-10 14:10:26 +03002995 struct cifs_sb_info *cifs_sb, const char *full_path)
2996{
2997 int rc;
Igor Mammedove4cce942009-02-10 14:10:26 +03002998 FILE_ALL_INFO *pfile_info;
2999
Igor Mammedove4cce942009-02-10 14:10:26 +03003000 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
3001 if (pfile_info == NULL)
3002 return -ENOMEM;
3003
3004 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
3005 0 /* not legacy */, cifs_sb->local_nls,
3006 cifs_sb->mnt_cifs_flags &
3007 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton221d1d72011-05-17 06:40:30 -04003008
3009 if (rc == -EOPNOTSUPP || rc == -EINVAL)
3010 rc = SMBQueryInformation(xid, tcon, full_path, pfile_info,
3011 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
3012 CIFS_MOUNT_MAP_SPECIAL_CHR);
Igor Mammedove4cce942009-02-10 14:10:26 +03003013 kfree(pfile_info);
3014 return rc;
3015}
3016
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003017static void
3018cleanup_volume_info_contents(struct smb_vol *volume_info)
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003019{
Sean Finneyb9468452011-04-11 13:19:32 +00003020 kfree(volume_info->username);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003021 kzfree(volume_info->password);
Steve French13589c42011-08-18 04:41:55 +00003022 if (volume_info->UNCip != volume_info->UNC + 2)
3023 kfree(volume_info->UNCip);
Jesper Juhl95c75452011-08-27 18:58:34 +02003024 kfree(volume_info->UNC);
Sean Finneyb9468452011-04-11 13:19:32 +00003025 kfree(volume_info->domainname);
3026 kfree(volume_info->iocharset);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003027 kfree(volume_info->prepath);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003028}
3029
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003030void
3031cifs_cleanup_volume_info(struct smb_vol *volume_info)
3032{
3033 if (!volume_info)
3034 return;
3035 cleanup_volume_info_contents(volume_info);
3036 kfree(volume_info);
3037}
3038
3039
Steve French2d6d5892009-04-09 00:36:44 +00003040#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003041/* build_path_to_root returns full path to root when
3042 * we do not have an exiting connection (tcon) */
3043static char *
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003044build_unc_path_to_root(const struct smb_vol *vol,
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003045 const struct cifs_sb_info *cifs_sb)
3046{
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003047 char *full_path, *pos;
3048 unsigned int pplen = vol->prepath ? strlen(vol->prepath) : 0;
3049 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003050
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003051 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003052 if (full_path == NULL)
3053 return ERR_PTR(-ENOMEM);
3054
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003055 strncpy(full_path, vol->UNC, unc_len);
3056 pos = full_path + unc_len;
3057
3058 if (pplen) {
3059 strncpy(pos, vol->prepath, pplen);
3060 pos += pplen;
3061 }
3062
3063 *pos = '\0'; /* add trailing null */
Steve Frenchf87d39d2011-05-27 03:50:55 +00003064 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003065 cFYI(1, "%s: full_path=%s", __func__, full_path);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003066 return full_path;
3067}
Sean Finneydd613942011-04-11 13:19:30 +00003068
3069/*
3070 * Perform a dfs referral query for a share and (optionally) prefix
3071 *
Sean Finney046462a2011-04-11 13:19:33 +00003072 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3073 * to a string containing updated options for the submount. Otherwise it
3074 * will be left untouched.
Sean Finneydd613942011-04-11 13:19:30 +00003075 *
3076 * Returns the rc from get_dfs_path to the caller, which can be used to
3077 * determine whether there were referrals.
3078 */
3079static int
Steve French96daf2b2011-05-27 04:34:02 +00003080expand_dfs_referral(int xid, struct cifs_ses *pSesInfo,
Sean Finneydd613942011-04-11 13:19:30 +00003081 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
Sean Finney046462a2011-04-11 13:19:33 +00003082 int check_prefix)
Sean Finneydd613942011-04-11 13:19:30 +00003083{
3084 int rc;
3085 unsigned int num_referrals = 0;
3086 struct dfs_info3_param *referrals = NULL;
3087 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3088
3089 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3090 if (IS_ERR(full_path))
3091 return PTR_ERR(full_path);
3092
3093 /* For DFS paths, skip the first '\' of the UNC */
3094 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3095
3096 rc = get_dfs_path(xid, pSesInfo , ref_path, cifs_sb->local_nls,
3097 &num_referrals, &referrals,
3098 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
3099
3100 if (!rc && num_referrals > 0) {
3101 char *fake_devname = NULL;
3102
3103 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3104 full_path + 1, referrals,
3105 &fake_devname);
3106
3107 free_dfs_info_array(referrals, num_referrals);
Sean Finney046462a2011-04-11 13:19:33 +00003108
Sean Finneydd613942011-04-11 13:19:30 +00003109 if (IS_ERR(mdata)) {
3110 rc = PTR_ERR(mdata);
3111 mdata = NULL;
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003112 } else {
3113 cleanup_volume_info_contents(volume_info);
3114 memset(volume_info, '\0', sizeof(*volume_info));
3115 rc = cifs_setup_volume_info(volume_info, mdata,
3116 fake_devname);
Sean Finneydd613942011-04-11 13:19:30 +00003117 }
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003118 kfree(fake_devname);
3119 kfree(cifs_sb->mountdata);
Sean Finney046462a2011-04-11 13:19:33 +00003120 cifs_sb->mountdata = mdata;
Sean Finneydd613942011-04-11 13:19:30 +00003121 }
3122 kfree(full_path);
3123 return rc;
3124}
Steve French2d6d5892009-04-09 00:36:44 +00003125#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003126
Jeff Layton04db79b2011-07-06 08:10:38 -04003127static int
3128cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3129 const char *devname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003130{
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003131 int rc = 0;
Sean Finneydd613942011-04-11 13:19:30 +00003132
Jeff Layton04db79b2011-07-06 08:10:38 -04003133 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3134 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003135
Jeff Layton7586b762008-12-01 18:41:49 -05003136 if (volume_info->nullauth) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003137 cFYI(1, "null user");
Pavel Shilovsky446b23a2011-06-20 12:33:16 +04003138 volume_info->username = kzalloc(1, GFP_KERNEL);
Jeff Layton04db79b2011-07-06 08:10:38 -04003139 if (volume_info->username == NULL)
3140 return -ENOMEM;
Jeff Layton7586b762008-12-01 18:41:49 -05003141 } else if (volume_info->username) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003142 /* BB fixme parse for domain name here */
Joe Perchesb6b38f72010-04-21 03:50:45 +00003143 cFYI(1, "Username: %s", volume_info->username);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003144 } else {
Steve Frenchbf820672005-12-01 22:32:42 -08003145 cifserror("No username specified");
Steve French50c2f752007-07-13 00:33:32 +00003146 /* In userspace mount helper we can get user name from alternate
3147 locations such as env variables and files on disk */
Jeff Layton04db79b2011-07-06 08:10:38 -04003148 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003149 }
3150
Linus Torvalds1da177e2005-04-16 15:20:36 -07003151 /* this is needed for ASCII cp to Unicode converts */
Jeff Layton7586b762008-12-01 18:41:49 -05003152 if (volume_info->iocharset == NULL) {
Jeff Laytona5fc4ce2010-04-24 07:57:42 -04003153 /* load_nls_default cannot return null */
3154 volume_info->local_nls = load_nls_default();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003155 } else {
Jeff Laytona5fc4ce2010-04-24 07:57:42 -04003156 volume_info->local_nls = load_nls(volume_info->iocharset);
3157 if (volume_info->local_nls == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003158 cERROR(1, "CIFS mount error: iocharset %s not found",
3159 volume_info->iocharset);
Jeff Layton04db79b2011-07-06 08:10:38 -04003160 return -ELIBACC;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003161 }
3162 }
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003163
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003164 return rc;
Jeff Layton04db79b2011-07-06 08:10:38 -04003165}
3166
3167struct smb_vol *
3168cifs_get_volume_info(char *mount_data, const char *devname)
3169{
3170 int rc;
3171 struct smb_vol *volume_info;
3172
3173 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
3174 if (!volume_info)
3175 return ERR_PTR(-ENOMEM);
3176
3177 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3178 if (rc) {
3179 cifs_cleanup_volume_info(volume_info);
3180 volume_info = ERR_PTR(rc);
3181 }
3182
3183 return volume_info;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003184}
3185
Jeff Layton66bfaad2011-10-19 15:30:35 -04003186/* make sure ra_pages is a multiple of rsize */
3187static inline unsigned int
3188cifs_ra_pages(struct cifs_sb_info *cifs_sb)
3189{
3190 unsigned int reads;
3191 unsigned int rsize_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
3192
3193 if (rsize_pages >= default_backing_dev_info.ra_pages)
3194 return default_backing_dev_info.ra_pages;
3195 else if (rsize_pages == 0)
3196 return rsize_pages;
3197
3198 reads = default_backing_dev_info.ra_pages / rsize_pages;
3199 return reads * rsize_pages;
3200}
3201
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003202int
Al Viro2c6292a2011-06-17 09:05:48 -04003203cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003204{
3205 int rc = 0;
3206 int xid;
Steve French96daf2b2011-05-27 04:34:02 +00003207 struct cifs_ses *pSesInfo;
3208 struct cifs_tcon *tcon;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003209 struct TCP_Server_Info *srvTcp;
3210 char *full_path;
3211 struct tcon_link *tlink;
3212#ifdef CONFIG_CIFS_DFS_UPCALL
3213 int referral_walks_count = 0;
Jeff Layton20547492011-07-09 12:21:07 -04003214#endif
Al Virodd854462011-06-17 08:24:42 -04003215
3216 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3217 if (rc)
3218 return rc;
3219
Jeff Layton20547492011-07-09 12:21:07 -04003220#ifdef CONFIG_CIFS_DFS_UPCALL
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003221try_mount_again:
3222 /* cleanup activities if we're chasing a referral */
3223 if (referral_walks_count) {
3224 if (tcon)
3225 cifs_put_tcon(tcon);
3226 else if (pSesInfo)
3227 cifs_put_smb_ses(pSesInfo);
3228
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003229 FreeXid(xid);
3230 }
3231#endif
3232 tcon = NULL;
3233 pSesInfo = NULL;
3234 srvTcp = NULL;
3235 full_path = NULL;
3236 tlink = NULL;
3237
3238 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003239
Jeff Layton63c038c2008-12-01 18:41:46 -05003240 /* get a reference to a tcp session */
Jeff Layton7586b762008-12-01 18:41:49 -05003241 srvTcp = cifs_get_tcp_session(volume_info);
Jeff Layton63c038c2008-12-01 18:41:46 -05003242 if (IS_ERR(srvTcp)) {
3243 rc = PTR_ERR(srvTcp);
Al Virodd854462011-06-17 08:24:42 -04003244 bdi_destroy(&cifs_sb->bdi);
Jeff Layton63c038c2008-12-01 18:41:46 -05003245 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003246 }
3247
Jeff Layton36988c72010-04-24 07:57:43 -04003248 /* get a reference to a SMB session */
3249 pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
3250 if (IS_ERR(pSesInfo)) {
3251 rc = PTR_ERR(pSesInfo);
3252 pSesInfo = NULL;
3253 goto mount_fail_check;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003254 }
Steve French50c2f752007-07-13 00:33:32 +00003255
Jeff Laytond00c28d2010-04-24 07:57:44 -04003256 /* search for existing tcon to this server share */
3257 tcon = cifs_get_tcon(pSesInfo, volume_info);
3258 if (IS_ERR(tcon)) {
3259 rc = PTR_ERR(tcon);
3260 tcon = NULL;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003261 goto remote_path_check;
Jeff Laytond00c28d2010-04-24 07:57:44 -04003262 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003263
Steve French6848b732011-05-26 18:38:54 +00003264 /* tell server which Unix caps we support */
3265 if (tcon->ses->capabilities & CAP_UNIX) {
3266 /* reset of caps checks mount to see if unix extensions
3267 disabled for just this mount */
Al Viro2c6292a2011-06-17 09:05:48 -04003268 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
Steve French6848b732011-05-26 18:38:54 +00003269 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3270 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3271 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3272 rc = -EACCES;
3273 goto mount_fail_check;
3274 }
3275 } else
3276 tcon->unix_ext = 0; /* server does not support them */
3277
Steve Frenchd82c2df2008-11-15 00:07:26 +00003278 /* do not care if following two calls succeed - informational */
3279 if (!tcon->ipc) {
3280 CIFSSMBQFSDeviceInfo(xid, tcon);
3281 CIFSSMBQFSAttributeInfo(xid, tcon);
3282 }
3283
Jeff Laytonf7910cb2011-05-19 16:22:58 -04003284 cifs_sb->wsize = cifs_negotiate_wsize(tcon, volume_info);
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003285 cifs_sb->rsize = cifs_negotiate_rsize(tcon, volume_info);
Jeff Laytonf7910cb2011-05-19 16:22:58 -04003286
Jeff Layton66bfaad2011-10-19 15:30:35 -04003287 /* tune readahead according to rsize */
3288 cifs_sb->bdi.ra_pages = cifs_ra_pages(cifs_sb);
Jeff Layton03ceace2010-12-06 21:07:33 -05003289
Igor Mammedove4cce942009-02-10 14:10:26 +03003290remote_path_check:
3291#ifdef CONFIG_CIFS_DFS_UPCALL
3292 /*
3293 * Perform an unconditional check for whether there are DFS
3294 * referrals for this path without prefix, to provide support
3295 * for DFS referrals from w2k8 servers which don't seem to respond
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003296 * with PATH_NOT_COVERED to requests that include the prefix.
3297 * Chase the referral if found, otherwise continue normally.
Steve Frenchd036f502009-04-03 03:12:08 +00003298 */
Igor Mammedov5c2503a2009-04-21 19:31:05 +04003299 if (referral_walks_count == 0) {
3300 int refrc = expand_dfs_referral(xid, pSesInfo, volume_info,
3301 cifs_sb, false);
3302 if (!refrc) {
3303 referral_walks_count++;
3304 goto try_mount_again;
3305 }
3306 }
3307#endif
3308
Steve Frenchf87d39d2011-05-27 03:50:55 +00003309 /* check if a whole path is not remote */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003310 if (!rc && tcon) {
3311 /* build_path_to_root works only when we have a valid tcon */
Steve Frenchf87d39d2011-05-27 03:50:55 +00003312 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
Steve French7c7b25b2006-06-01 19:20:10 +00003313 if (full_path == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003314 rc = -ENOMEM;
3315 goto mount_fail_check;
3316 }
3317 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
3318 if (rc != 0 && rc != -EREMOTE) {
3319 kfree(full_path);
3320 goto mount_fail_check;
3321 }
3322 kfree(full_path);
3323 }
3324
3325 /* get referral if needed */
3326 if (rc == -EREMOTE) {
3327#ifdef CONFIG_CIFS_DFS_UPCALL
3328 if (referral_walks_count > MAX_NESTED_LINKS) {
3329 /*
Steve Frencheeac8042006-01-13 21:34:58 -08003330 * BB: when we implement proper loop detection,
Steve French4523cc32007-04-30 20:13:06 +00003331 * we will remove this check. But now we need it
Linus Torvalds1da177e2005-04-16 15:20:36 -07003332 * to prevent an indefinite loop if 'DFS tree' is
3333 * misconfigured (i.e. has loops).
3334 */
3335 rc = -ELOOP;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003336 goto mount_fail_check;
3337 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003338
Sean Finneydd613942011-04-11 13:19:30 +00003339 rc = expand_dfs_referral(xid, pSesInfo, volume_info, cifs_sb,
Sean Finney046462a2011-04-11 13:19:33 +00003340 true);
Jeff Layton7b91e262009-07-23 15:22:30 -04003341
Sean Finneydd613942011-04-11 13:19:30 +00003342 if (!rc) {
Igor Mammedov5c2503a2009-04-21 19:31:05 +04003343 referral_walks_count++;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003344 goto try_mount_again;
3345 }
Sean Finneydd613942011-04-11 13:19:30 +00003346 goto mount_fail_check;
Steve Frenchd036f502009-04-03 03:12:08 +00003347#else /* No DFS support, return error on mount */
3348 rc = -EOPNOTSUPP;
3349#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003350 }
3351
Jeff Layton9d002df2010-10-06 19:51:11 -04003352 if (rc)
3353 goto mount_fail_check;
3354
3355 /* now, hang the tcon off of the superblock */
3356 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3357 if (tlink == NULL) {
3358 rc = -ENOMEM;
3359 goto mount_fail_check;
3360 }
3361
Jeff Laytonb647c352010-10-28 11:16:44 -04003362 tlink->tl_uid = pSesInfo->linux_uid;
Jeff Layton9d002df2010-10-06 19:51:11 -04003363 tlink->tl_tcon = tcon;
3364 tlink->tl_time = jiffies;
3365 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3366 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3367
Jeff Layton413e6612010-10-28 13:33:38 -04003368 cifs_sb->master_tlink = tlink;
Jeff Laytonb647c352010-10-28 11:16:44 -04003369 spin_lock(&cifs_sb->tlink_tree_lock);
3370 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3371 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton413e6612010-10-28 13:33:38 -04003372
Jeff Layton2de970f2010-10-06 19:51:12 -04003373 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
3374 TLINK_IDLE_EXPIRE);
3375
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003376mount_fail_check:
3377 /* on error free sesinfo and tcon struct if needed */
3378 if (rc) {
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003379 /* If find_unc succeeded then rc == 0 so we can not end */
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003380 /* up accidentally freeing someone elses tcon struct */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003381 if (tcon)
3382 cifs_put_tcon(tcon);
3383 else if (pSesInfo)
3384 cifs_put_smb_ses(pSesInfo);
3385 else
3386 cifs_put_tcp_session(srvTcp);
Al Virodd854462011-06-17 08:24:42 -04003387 bdi_destroy(&cifs_sb->bdi);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003388 }
3389
Linus Torvalds1da177e2005-04-16 15:20:36 -07003390out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003391 FreeXid(xid);
3392 return rc;
3393}
3394
Jeff Layton8d1bca32011-06-11 21:17:10 -04003395/*
3396 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3397 * pointer may be NULL.
3398 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003399int
Steve French96daf2b2011-05-27 04:34:02 +00003400CIFSTCon(unsigned int xid, struct cifs_ses *ses,
3401 const char *tree, struct cifs_tcon *tcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003402 const struct nls_table *nls_codepage)
3403{
3404 struct smb_hdr *smb_buffer;
3405 struct smb_hdr *smb_buffer_response;
3406 TCONX_REQ *pSMB;
3407 TCONX_RSP *pSMBr;
3408 unsigned char *bcc_ptr;
3409 int rc = 0;
Jeff Layton690c5222011-01-20 13:36:51 -05003410 int length;
3411 __u16 bytes_left, count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003412
3413 if (ses == NULL)
3414 return -EIO;
3415
3416 smb_buffer = cifs_buf_get();
Steve Frenchca43e3b2009-09-01 17:20:50 +00003417 if (smb_buffer == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003418 return -ENOMEM;
Steve Frenchca43e3b2009-09-01 17:20:50 +00003419
Linus Torvalds1da177e2005-04-16 15:20:36 -07003420 smb_buffer_response = smb_buffer;
3421
3422 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3423 NULL /*no tid */ , 4 /*wct */ );
Steve French1982c342005-08-17 12:38:22 -07003424
3425 smb_buffer->Mid = GetNextMid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003426 smb_buffer->Uid = ses->Suid;
3427 pSMB = (TCONX_REQ *) smb_buffer;
3428 pSMBr = (TCONX_RSP *) smb_buffer_response;
3429
3430 pSMB->AndXCommand = 0xFF;
3431 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003432 bcc_ptr = &pSMB->Password[0];
Jeff Layton8d1bca32011-06-11 21:17:10 -04003433 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
Steve Frencheeac8042006-01-13 21:34:58 -08003434 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
Steve French7c7b25b2006-06-01 19:20:10 +00003435 *bcc_ptr = 0; /* password is null byte */
Steve Frencheeac8042006-01-13 21:34:58 -08003436 bcc_ptr++; /* skip password */
Steve French7c7b25b2006-06-01 19:20:10 +00003437 /* already aligned so no need to do it below */
Steve Frencheeac8042006-01-13 21:34:58 -08003438 } else {
Shirish Pargaonkar540b2e32011-01-18 22:33:54 -06003439 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
Steve Frencheeac8042006-01-13 21:34:58 -08003440 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3441 specified as required (when that support is added to
3442 the vfs in the future) as only NTLM or the much
Steve French7c7b25b2006-06-01 19:20:10 +00003443 weaker LANMAN (which we do not send by default) is accepted
Steve Frencheeac8042006-01-13 21:34:58 -08003444 by Samba (not sure whether other servers allow
3445 NTLMv2 password here) */
Steve French7c7b25b2006-06-01 19:20:10 +00003446#ifdef CONFIG_CIFS_WEAK_PW_HASH
Jeff Layton04912d62010-04-24 07:57:45 -04003447 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
Jeff Layton00e485b2008-12-05 20:41:21 -05003448 (ses->server->secType == LANMAN))
Shirish Pargaonkard3ba50b2010-10-27 15:20:36 -05003449 calc_lanman_hash(tcon->password, ses->server->cryptkey,
Steve French96daf2b2011-05-27 04:34:02 +00003450 ses->server->sec_mode &
Jeff Layton4e53a3f2008-12-05 20:41:21 -05003451 SECMODE_PW_ENCRYPT ? true : false,
3452 bcc_ptr);
Steve French7c7b25b2006-06-01 19:20:10 +00003453 else
3454#endif /* CIFS_WEAK_PW_HASH */
Shirish Pargaonkaree2c9252011-01-27 09:58:04 -06003455 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
Shirish Pargaonkar9ef59922011-10-20 13:21:59 -05003456 bcc_ptr, nls_codepage);
Steve Frencheeac8042006-01-13 21:34:58 -08003457
Shirish Pargaonkar540b2e32011-01-18 22:33:54 -06003458 bcc_ptr += CIFS_AUTH_RESP_SIZE;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003459 if (ses->capabilities & CAP_UNICODE) {
Steve French7c7b25b2006-06-01 19:20:10 +00003460 /* must align unicode strings */
3461 *bcc_ptr = 0; /* null byte password */
3462 bcc_ptr++;
3463 }
Steve Frencheeac8042006-01-13 21:34:58 -08003464 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003465
Steve French96daf2b2011-05-27 04:34:02 +00003466 if (ses->server->sec_mode &
Steve Frencha878fb22006-05-30 18:04:19 +00003467 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003468 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3469
3470 if (ses->capabilities & CAP_STATUS32) {
3471 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3472 }
3473 if (ses->capabilities & CAP_DFS) {
3474 smb_buffer->Flags2 |= SMBFLG2_DFS;
3475 }
3476 if (ses->capabilities & CAP_UNICODE) {
3477 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3478 length =
Steve French50c2f752007-07-13 00:33:32 +00003479 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3480 6 /* max utf8 char length in bytes */ *
Steve Frencha878fb22006-05-30 18:04:19 +00003481 (/* server len*/ + 256 /* share len */), nls_codepage);
3482 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003483 bcc_ptr += 2; /* skip trailing null */
3484 } else { /* ASCII */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003485 strcpy(bcc_ptr, tree);
3486 bcc_ptr += strlen(tree) + 1;
3487 }
3488 strcpy(bcc_ptr, "?????");
3489 bcc_ptr += strlen("?????");
3490 bcc_ptr += 1;
3491 count = bcc_ptr - &pSMB->Password[0];
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003492 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3493 pSMB->hdr.smb_buf_length) + count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003494 pSMB->ByteCount = cpu_to_le16(count);
3495
Steve French133672e2007-11-13 22:41:37 +00003496 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
Jeff Layton77499812011-01-11 07:24:23 -05003497 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003498
Linus Torvalds1da177e2005-04-16 15:20:36 -07003499 /* above now done in SendReceive */
3500 if ((rc == 0) && (tcon != NULL)) {
Steve French0e0d2cf2009-05-01 05:27:32 +00003501 bool is_unicode;
3502
Linus Torvalds1da177e2005-04-16 15:20:36 -07003503 tcon->tidStatus = CifsGood;
Steve French3b795212008-11-13 19:45:32 +00003504 tcon->need_reconnect = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003505 tcon->tid = smb_buffer_response->Tid;
3506 bcc_ptr = pByteArea(smb_buffer_response);
Jeff Layton690c5222011-01-20 13:36:51 -05003507 bytes_left = get_bcc(smb_buffer_response);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003508 length = strnlen(bcc_ptr, bytes_left - 2);
Steve French0e0d2cf2009-05-01 05:27:32 +00003509 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3510 is_unicode = true;
3511 else
3512 is_unicode = false;
3513
Jeff Laytoncc20c032009-04-30 07:16:21 -04003514
Steve French50c2f752007-07-13 00:33:32 +00003515 /* skip service field (NB: this field is always ASCII) */
Steve French7f8ed422007-09-28 22:28:55 +00003516 if (length == 3) {
3517 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3518 (bcc_ptr[2] == 'C')) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003519 cFYI(1, "IPC connection");
Steve French7f8ed422007-09-28 22:28:55 +00003520 tcon->ipc = 1;
3521 }
3522 } else if (length == 2) {
3523 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3524 /* the most common case */
Joe Perchesb6b38f72010-04-21 03:50:45 +00003525 cFYI(1, "disk share connection");
Steve French7f8ed422007-09-28 22:28:55 +00003526 }
3527 }
Steve French50c2f752007-07-13 00:33:32 +00003528 bcc_ptr += length + 1;
Jeff Laytoncc20c032009-04-30 07:16:21 -04003529 bytes_left -= (length + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003530 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003531
3532 /* mostly informational -- no need to fail on error here */
Jeff Layton90a98b22009-07-20 13:40:52 -04003533 kfree(tcon->nativeFileSystem);
Steve Frenchd185cda2009-04-30 17:45:10 +00003534 tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
Steve French0e0d2cf2009-05-01 05:27:32 +00003535 bytes_left, is_unicode,
Jeff Laytoncc20c032009-04-30 07:16:21 -04003536 nls_codepage);
3537
Joe Perchesb6b38f72010-04-21 03:50:45 +00003538 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003539
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003540 if ((smb_buffer_response->WordCount == 3) ||
Steve French1a4e15a2006-10-12 21:33:51 +00003541 (smb_buffer_response->WordCount == 7))
3542 /* field is in same location */
Steve French39798772006-05-31 22:40:51 +00003543 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3544 else
3545 tcon->Flags = 0;
Joe Perchesb6b38f72010-04-21 03:50:45 +00003546 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003547 } else if ((rc == 0) && tcon == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00003548 /* all we need to save for IPC$ connection */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003549 ses->ipc_tid = smb_buffer_response->Tid;
3550 }
3551
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00003552 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003553 return rc;
3554}
3555
Al Viro2a9b9952011-06-17 09:27:16 -04003556void
3557cifs_umount(struct cifs_sb_info *cifs_sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003558{
Jeff Laytonb647c352010-10-28 11:16:44 -04003559 struct rb_root *root = &cifs_sb->tlink_tree;
3560 struct rb_node *node;
3561 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003562
Jeff Layton2de970f2010-10-06 19:51:12 -04003563 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3564
Jeff Laytonb647c352010-10-28 11:16:44 -04003565 spin_lock(&cifs_sb->tlink_tree_lock);
3566 while ((node = rb_first(root))) {
3567 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3568 cifs_get_tlink(tlink);
3569 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3570 rb_erase(node, root);
Steve French50c2f752007-07-13 00:33:32 +00003571
Jeff Laytonb647c352010-10-28 11:16:44 -04003572 spin_unlock(&cifs_sb->tlink_tree_lock);
3573 cifs_put_tlink(tlink);
3574 spin_lock(&cifs_sb->tlink_tree_lock);
3575 }
3576 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003577
Al Virodd854462011-06-17 08:24:42 -04003578 bdi_destroy(&cifs_sb->bdi);
Al Virod757d712011-06-17 09:42:43 -04003579 kfree(cifs_sb->mountdata);
3580 unload_nls(cifs_sb->local_nls);
3581 kfree(cifs_sb);
Steve French50c2f752007-07-13 00:33:32 +00003582}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003583
Steve French96daf2b2011-05-27 04:34:02 +00003584int cifs_negotiate_protocol(unsigned int xid, struct cifs_ses *ses)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003585{
3586 int rc = 0;
Jeff Layton198b5682010-04-24 07:57:48 -04003587 struct TCP_Server_Info *server = ses->server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003588
Jeff Layton198b5682010-04-24 07:57:48 -04003589 /* only send once per connect */
3590 if (server->maxBuf != 0)
3591 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003592
Jeff Layton198b5682010-04-24 07:57:48 -04003593 rc = CIFSSMBNegotiate(xid, ses);
3594 if (rc == -EAGAIN) {
3595 /* retry only once on 1st time connection */
3596 rc = CIFSSMBNegotiate(xid, ses);
3597 if (rc == -EAGAIN)
3598 rc = -EHOSTDOWN;
3599 }
3600 if (rc == 0) {
3601 spin_lock(&GlobalMid_Lock);
Jeff Layton7fdbaa12011-06-10 16:14:57 -04003602 if (server->tcpStatus == CifsNeedNegotiate)
Jeff Layton198b5682010-04-24 07:57:48 -04003603 server->tcpStatus = CifsGood;
3604 else
3605 rc = -EHOSTDOWN;
3606 spin_unlock(&GlobalMid_Lock);
3607
Linus Torvalds1da177e2005-04-16 15:20:36 -07003608 }
Steve French26b994f2008-08-06 05:11:33 +00003609
Jeff Layton198b5682010-04-24 07:57:48 -04003610 return rc;
3611}
Steve French26b994f2008-08-06 05:11:33 +00003612
Jeff Layton198b5682010-04-24 07:57:48 -04003613
Steve French96daf2b2011-05-27 04:34:02 +00003614int cifs_setup_session(unsigned int xid, struct cifs_ses *ses,
Jeff Layton198b5682010-04-24 07:57:48 -04003615 struct nls_table *nls_info)
3616{
3617 int rc = 0;
3618 struct TCP_Server_Info *server = ses->server;
3619
3620 ses->flags = 0;
3621 ses->capabilities = server->capabilities;
Steve French26b994f2008-08-06 05:11:33 +00003622 if (linuxExtEnabled == 0)
Jeff Layton198b5682010-04-24 07:57:48 -04003623 ses->capabilities &= (~CAP_UNIX);
Steve French20418ac2009-04-30 16:13:32 +00003624
Joe Perchesb6b38f72010-04-21 03:50:45 +00003625 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
Steve French96daf2b2011-05-27 04:34:02 +00003626 server->sec_mode, server->capabilities, server->timeAdj);
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003627
Jeff Layton198b5682010-04-24 07:57:48 -04003628 rc = CIFS_SessSetup(xid, ses, nls_info);
Steve French26b994f2008-08-06 05:11:33 +00003629 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003630 cERROR(1, "Send error in SessSetup = %d", rc);
Steve French26b994f2008-08-06 05:11:33 +00003631 } else {
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05003632 mutex_lock(&ses->server->srv_mutex);
3633 if (!server->session_estab) {
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003634 server->session_key.response = ses->auth_key.response;
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05003635 server->session_key.len = ses->auth_key.len;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003636 server->sequence_number = 0x2;
3637 server->session_estab = true;
3638 ses->auth_key.response = NULL;
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05003639 }
3640 mutex_unlock(&server->srv_mutex);
3641
Joe Perchesb6b38f72010-04-21 03:50:45 +00003642 cFYI(1, "CIFS Session Established successfully");
Steve French20418ac2009-04-30 16:13:32 +00003643 spin_lock(&GlobalMid_Lock);
Jeff Layton198b5682010-04-24 07:57:48 -04003644 ses->status = CifsGood;
3645 ses->need_reconnect = false;
Steve French20418ac2009-04-30 16:13:32 +00003646 spin_unlock(&GlobalMid_Lock);
Steve French26b994f2008-08-06 05:11:33 +00003647 }
3648
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003649 kfree(ses->auth_key.response);
3650 ses->auth_key.response = NULL;
3651 ses->auth_key.len = 0;
Shirish Pargaonkard3686d52010-10-28 09:53:07 -05003652 kfree(ses->ntlmssp);
3653 ses->ntlmssp = NULL;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003654
Linus Torvalds1da177e2005-04-16 15:20:36 -07003655 return rc;
3656}
3657
Steve French96daf2b2011-05-27 04:34:02 +00003658static struct cifs_tcon *
Jeff Layton9d002df2010-10-06 19:51:11 -04003659cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
3660{
Steve French96daf2b2011-05-27 04:34:02 +00003661 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3662 struct cifs_ses *ses;
3663 struct cifs_tcon *tcon = NULL;
Jeff Layton9d002df2010-10-06 19:51:11 -04003664 struct smb_vol *vol_info;
Steve French34c87902011-03-01 05:02:57 +00003665 char username[28]; /* big enough for "krb50x" + hex of ULONG_MAX 6+16 */
3666 /* We used to have this as MAX_USERNAME which is */
3667 /* way too big now (256 instead of 32) */
Jeff Layton9d002df2010-10-06 19:51:11 -04003668
3669 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3670 if (vol_info == NULL) {
3671 tcon = ERR_PTR(-ENOMEM);
3672 goto out;
3673 }
3674
Steve Frenchea1be1a2011-07-12 18:24:43 +00003675 snprintf(username, sizeof(username), "krb50x%x", fsuid);
Jeff Layton9d002df2010-10-06 19:51:11 -04003676 vol_info->username = username;
3677 vol_info->local_nls = cifs_sb->local_nls;
3678 vol_info->linux_uid = fsuid;
3679 vol_info->cred_uid = fsuid;
3680 vol_info->UNC = master_tcon->treeName;
3681 vol_info->retry = master_tcon->retry;
3682 vol_info->nocase = master_tcon->nocase;
3683 vol_info->local_lease = master_tcon->local_lease;
3684 vol_info->no_linux_ext = !master_tcon->unix_ext;
3685
3686 /* FIXME: allow for other secFlg settings */
3687 vol_info->secFlg = CIFSSEC_MUST_KRB5;
3688
3689 /* get a reference for the same TCP session */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05303690 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003691 ++master_tcon->ses->server->srv_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05303692 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003693
3694 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3695 if (IS_ERR(ses)) {
Steve French96daf2b2011-05-27 04:34:02 +00003696 tcon = (struct cifs_tcon *)ses;
Jeff Layton9d002df2010-10-06 19:51:11 -04003697 cifs_put_tcp_session(master_tcon->ses->server);
3698 goto out;
3699 }
3700
3701 tcon = cifs_get_tcon(ses, vol_info);
3702 if (IS_ERR(tcon)) {
3703 cifs_put_smb_ses(ses);
3704 goto out;
3705 }
3706
3707 if (ses->capabilities & CAP_UNIX)
3708 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3709out:
3710 kfree(vol_info);
3711
3712 return tcon;
3713}
3714
Steve French96daf2b2011-05-27 04:34:02 +00003715struct cifs_tcon *
Jeff Layton9d002df2010-10-06 19:51:11 -04003716cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3717{
3718 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3719}
3720
3721static int
3722cifs_sb_tcon_pending_wait(void *unused)
3723{
3724 schedule();
3725 return signal_pending(current) ? -ERESTARTSYS : 0;
3726}
3727
Jeff Laytonb647c352010-10-28 11:16:44 -04003728/* find and return a tlink with given uid */
3729static struct tcon_link *
3730tlink_rb_search(struct rb_root *root, uid_t uid)
3731{
3732 struct rb_node *node = root->rb_node;
3733 struct tcon_link *tlink;
3734
3735 while (node) {
3736 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3737
3738 if (tlink->tl_uid > uid)
3739 node = node->rb_left;
3740 else if (tlink->tl_uid < uid)
3741 node = node->rb_right;
3742 else
3743 return tlink;
3744 }
3745 return NULL;
3746}
3747
3748/* insert a tcon_link into the tree */
3749static void
3750tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3751{
3752 struct rb_node **new = &(root->rb_node), *parent = NULL;
3753 struct tcon_link *tlink;
3754
3755 while (*new) {
3756 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3757 parent = *new;
3758
3759 if (tlink->tl_uid > new_tlink->tl_uid)
3760 new = &((*new)->rb_left);
3761 else
3762 new = &((*new)->rb_right);
3763 }
3764
3765 rb_link_node(&new_tlink->tl_rbnode, parent, new);
3766 rb_insert_color(&new_tlink->tl_rbnode, root);
3767}
3768
Jeff Layton9d002df2010-10-06 19:51:11 -04003769/*
3770 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3771 * current task.
3772 *
3773 * If the superblock doesn't refer to a multiuser mount, then just return
3774 * the master tcon for the mount.
3775 *
Suresh Jayaraman6ef933a2010-11-03 10:53:49 +05303776 * First, search the rbtree for an existing tcon for this fsuid. If one
Jeff Layton9d002df2010-10-06 19:51:11 -04003777 * exists, then check to see if it's pending construction. If it is then wait
3778 * for construction to complete. Once it's no longer pending, check to see if
3779 * it failed and either return an error or retry construction, depending on
3780 * the timeout.
3781 *
3782 * If one doesn't exist then insert a new tcon_link struct into the tree and
3783 * try to construct a new one.
3784 */
3785struct tcon_link *
3786cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
3787{
3788 int ret;
Jeff Laytonb647c352010-10-28 11:16:44 -04003789 uid_t fsuid = current_fsuid();
Jeff Layton9d002df2010-10-06 19:51:11 -04003790 struct tcon_link *tlink, *newtlink;
3791
3792 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
3793 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3794
3795 spin_lock(&cifs_sb->tlink_tree_lock);
Jeff Laytonb647c352010-10-28 11:16:44 -04003796 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
Jeff Layton9d002df2010-10-06 19:51:11 -04003797 if (tlink)
3798 cifs_get_tlink(tlink);
3799 spin_unlock(&cifs_sb->tlink_tree_lock);
3800
3801 if (tlink == NULL) {
3802 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
3803 if (newtlink == NULL)
3804 return ERR_PTR(-ENOMEM);
Jeff Laytonb647c352010-10-28 11:16:44 -04003805 newtlink->tl_uid = fsuid;
Jeff Layton9d002df2010-10-06 19:51:11 -04003806 newtlink->tl_tcon = ERR_PTR(-EACCES);
3807 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
3808 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
3809 cifs_get_tlink(newtlink);
3810
Jeff Layton9d002df2010-10-06 19:51:11 -04003811 spin_lock(&cifs_sb->tlink_tree_lock);
3812 /* was one inserted after previous search? */
Jeff Laytonb647c352010-10-28 11:16:44 -04003813 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
Jeff Layton9d002df2010-10-06 19:51:11 -04003814 if (tlink) {
3815 cifs_get_tlink(tlink);
3816 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003817 kfree(newtlink);
3818 goto wait_for_construction;
3819 }
Jeff Layton9d002df2010-10-06 19:51:11 -04003820 tlink = newtlink;
Jeff Laytonb647c352010-10-28 11:16:44 -04003821 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3822 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003823 } else {
3824wait_for_construction:
3825 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
3826 cifs_sb_tcon_pending_wait,
3827 TASK_INTERRUPTIBLE);
3828 if (ret) {
3829 cifs_put_tlink(tlink);
3830 return ERR_PTR(ret);
3831 }
3832
3833 /* if it's good, return it */
3834 if (!IS_ERR(tlink->tl_tcon))
3835 return tlink;
3836
3837 /* return error if we tried this already recently */
3838 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
3839 cifs_put_tlink(tlink);
3840 return ERR_PTR(-EACCES);
3841 }
3842
3843 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
3844 goto wait_for_construction;
3845 }
3846
3847 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
3848 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
3849 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
3850
3851 if (IS_ERR(tlink->tl_tcon)) {
3852 cifs_put_tlink(tlink);
3853 return ERR_PTR(-EACCES);
3854 }
3855
3856 return tlink;
3857}
Jeff Layton2de970f2010-10-06 19:51:12 -04003858
3859/*
3860 * periodic workqueue job that scans tcon_tree for a superblock and closes
3861 * out tcons.
3862 */
3863static void
3864cifs_prune_tlinks(struct work_struct *work)
3865{
3866 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
3867 prune_tlinks.work);
Jeff Laytonb647c352010-10-28 11:16:44 -04003868 struct rb_root *root = &cifs_sb->tlink_tree;
3869 struct rb_node *node = rb_first(root);
3870 struct rb_node *tmp;
3871 struct tcon_link *tlink;
Jeff Layton2de970f2010-10-06 19:51:12 -04003872
Jeff Laytonb647c352010-10-28 11:16:44 -04003873 /*
3874 * Because we drop the spinlock in the loop in order to put the tlink
3875 * it's not guarded against removal of links from the tree. The only
3876 * places that remove entries from the tree are this function and
3877 * umounts. Because this function is non-reentrant and is canceled
3878 * before umount can proceed, this is safe.
3879 */
3880 spin_lock(&cifs_sb->tlink_tree_lock);
3881 node = rb_first(root);
3882 while (node != NULL) {
3883 tmp = node;
3884 node = rb_next(tmp);
3885 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
3886
3887 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
3888 atomic_read(&tlink->tl_count) != 0 ||
3889 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
3890 continue;
3891
3892 cifs_get_tlink(tlink);
3893 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3894 rb_erase(tmp, root);
3895
Jeff Layton2de970f2010-10-06 19:51:12 -04003896 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Laytonb647c352010-10-28 11:16:44 -04003897 cifs_put_tlink(tlink);
3898 spin_lock(&cifs_sb->tlink_tree_lock);
3899 }
3900 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton2de970f2010-10-06 19:51:12 -04003901
3902 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
3903 TLINK_IDLE_EXPIRE);
3904}