blob: 192f51a12cf1c63fb6eee3359b2350747343a76c [file] [log] [blame]
Steve French1080ef72011-02-24 18:07:19 +00001/*
2 * SMB2 version specific operations
3 *
4 * Copyright (c) 2012, Jeff Layton <jlayton@redhat.com>
5 *
6 * This library is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License v2 as published
8 * by the Free Software Foundation.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
13 * the GNU Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public License
16 * along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 */
19
Pavel Shilovsky3a3bab52012-09-18 16:20:28 -070020#include <linux/pagemap.h>
Pavel Shilovsky6fc05c22012-09-18 16:20:34 -070021#include <linux/vfs.h>
Steve French1080ef72011-02-24 18:07:19 +000022#include "cifsglob.h"
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +040023#include "smb2pdu.h"
24#include "smb2proto.h"
Pavel Shilovsky28ea5292012-05-23 16:18:00 +040025#include "cifsproto.h"
26#include "cifs_debug.h"
Pavel Shilovskyb42bf882013-08-14 19:25:21 +040027#include "cifs_unicode.h"
Pavel Shilovsky2e44b282012-09-18 16:20:33 -070028#include "smb2status.h"
Pavel Shilovsky6fc05c22012-09-18 16:20:34 -070029#include "smb2glob.h"
Pavel Shilovsky28ea5292012-05-23 16:18:00 +040030
31static int
32change_conf(struct TCP_Server_Info *server)
33{
34 server->credits += server->echo_credits + server->oplock_credits;
35 server->oplock_credits = server->echo_credits = 0;
36 switch (server->credits) {
37 case 0:
38 return -1;
39 case 1:
40 server->echoes = false;
41 server->oplocks = false;
Joe Perchesf96637b2013-05-04 22:12:25 -050042 cifs_dbg(VFS, "disabling echoes and oplocks\n");
Pavel Shilovsky28ea5292012-05-23 16:18:00 +040043 break;
44 case 2:
45 server->echoes = true;
46 server->oplocks = false;
47 server->echo_credits = 1;
Joe Perchesf96637b2013-05-04 22:12:25 -050048 cifs_dbg(FYI, "disabling oplocks\n");
Pavel Shilovsky28ea5292012-05-23 16:18:00 +040049 break;
50 default:
51 server->echoes = true;
52 server->oplocks = true;
53 server->echo_credits = 1;
54 server->oplock_credits = 1;
55 }
56 server->credits -= server->echo_credits + server->oplock_credits;
57 return 0;
58}
59
60static void
61smb2_add_credits(struct TCP_Server_Info *server, const unsigned int add,
62 const int optype)
63{
64 int *val, rc = 0;
65 spin_lock(&server->req_lock);
66 val = server->ops->get_credits_field(server, optype);
67 *val += add;
68 server->in_flight--;
Pavel Shilovskyec2e4522011-12-27 16:12:43 +040069 if (server->in_flight == 0 && (optype & CIFS_OP_MASK) != CIFS_NEG_OP)
Pavel Shilovsky28ea5292012-05-23 16:18:00 +040070 rc = change_conf(server);
Pavel Shilovsky983c88a2012-09-18 16:20:33 -070071 /*
72 * Sometimes server returns 0 credits on oplock break ack - we need to
73 * rebalance credits in this case.
74 */
75 else if (server->in_flight > 0 && server->oplock_credits == 0 &&
76 server->oplocks) {
77 if (server->credits > 1) {
78 server->credits--;
79 server->oplock_credits++;
80 }
81 }
Pavel Shilovsky28ea5292012-05-23 16:18:00 +040082 spin_unlock(&server->req_lock);
83 wake_up(&server->request_q);
84 if (rc)
85 cifs_reconnect(server);
86}
87
88static void
89smb2_set_credits(struct TCP_Server_Info *server, const int val)
90{
91 spin_lock(&server->req_lock);
92 server->credits = val;
93 spin_unlock(&server->req_lock);
94}
95
96static int *
97smb2_get_credits_field(struct TCP_Server_Info *server, const int optype)
98{
99 switch (optype) {
100 case CIFS_ECHO_OP:
101 return &server->echo_credits;
102 case CIFS_OBREAK_OP:
103 return &server->oplock_credits;
104 default:
105 return &server->credits;
106 }
107}
108
109static unsigned int
110smb2_get_credits(struct mid_q_entry *mid)
111{
112 return le16_to_cpu(((struct smb2_hdr *)mid->resp_buf)->CreditRequest);
113}
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +0400114
115static __u64
116smb2_get_next_mid(struct TCP_Server_Info *server)
117{
118 __u64 mid;
119 /* for SMB2 we need the current value */
120 spin_lock(&GlobalMid_Lock);
121 mid = server->CurrentMid++;
122 spin_unlock(&GlobalMid_Lock);
123 return mid;
124}
Steve French1080ef72011-02-24 18:07:19 +0000125
Pavel Shilovsky093b2bd2011-06-08 15:51:07 +0400126static struct mid_q_entry *
127smb2_find_mid(struct TCP_Server_Info *server, char *buf)
128{
129 struct mid_q_entry *mid;
130 struct smb2_hdr *hdr = (struct smb2_hdr *)buf;
131
132 spin_lock(&GlobalMid_Lock);
133 list_for_each_entry(mid, &server->pending_mid_q, qhead) {
134 if ((mid->mid == hdr->MessageId) &&
135 (mid->mid_state == MID_REQUEST_SUBMITTED) &&
136 (mid->command == hdr->Command)) {
137 spin_unlock(&GlobalMid_Lock);
138 return mid;
139 }
140 }
141 spin_unlock(&GlobalMid_Lock);
142 return NULL;
143}
144
145static void
146smb2_dump_detail(void *buf)
147{
148#ifdef CONFIG_CIFS_DEBUG2
149 struct smb2_hdr *smb = (struct smb2_hdr *)buf;
150
Joe Perchesf96637b2013-05-04 22:12:25 -0500151 cifs_dbg(VFS, "Cmd: %d Err: 0x%x Flags: 0x%x Mid: %llu Pid: %d\n",
152 smb->Command, smb->Status, smb->Flags, smb->MessageId,
153 smb->ProcessId);
154 cifs_dbg(VFS, "smb buf %p len %u\n", smb, smb2_calc_size(smb));
Pavel Shilovsky093b2bd2011-06-08 15:51:07 +0400155#endif
156}
157
Pavel Shilovskyec2e4522011-12-27 16:12:43 +0400158static bool
159smb2_need_neg(struct TCP_Server_Info *server)
160{
161 return server->max_read == 0;
162}
163
164static int
165smb2_negotiate(const unsigned int xid, struct cifs_ses *ses)
166{
167 int rc;
168 ses->server->CurrentMid = 0;
169 rc = SMB2_negotiate(xid, ses);
170 /* BB we probably don't need to retry with modern servers */
171 if (rc == -EAGAIN)
172 rc = -EHOSTDOWN;
173 return rc;
174}
175
Pavel Shilovsky3a3bab52012-09-18 16:20:28 -0700176static unsigned int
177smb2_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *volume_info)
178{
179 struct TCP_Server_Info *server = tcon->ses->server;
180 unsigned int wsize;
181
182 /* start with specified wsize, or default */
183 wsize = volume_info->wsize ? volume_info->wsize : CIFS_DEFAULT_IOSIZE;
184 wsize = min_t(unsigned int, wsize, server->max_write);
Pavel Shilovsky2365c4e2014-02-14 13:31:02 +0400185 /* set it to the maximum buffer size value we can send with 1 credit */
186 wsize = min_t(unsigned int, wsize, SMB2_MAX_BUFFER_SIZE);
Pavel Shilovsky3a3bab52012-09-18 16:20:28 -0700187
Pavel Shilovsky3a3bab52012-09-18 16:20:28 -0700188 return wsize;
189}
190
191static unsigned int
192smb2_negotiate_rsize(struct cifs_tcon *tcon, struct smb_vol *volume_info)
193{
194 struct TCP_Server_Info *server = tcon->ses->server;
195 unsigned int rsize;
196
197 /* start with specified rsize, or default */
198 rsize = volume_info->rsize ? volume_info->rsize : CIFS_DEFAULT_IOSIZE;
199 rsize = min_t(unsigned int, rsize, server->max_read);
Pavel Shilovsky2365c4e2014-02-14 13:31:02 +0400200 /* set it to the maximum buffer size value we can send with 1 credit */
201 rsize = min_t(unsigned int, rsize, SMB2_MAX_BUFFER_SIZE);
Pavel Shilovsky3a3bab52012-09-18 16:20:28 -0700202
Pavel Shilovsky3a3bab52012-09-18 16:20:28 -0700203 return rsize;
204}
205
Steve Frenchc481e9f2013-10-14 01:21:53 -0500206#ifdef CONFIG_CIFS_STATS2
207static int
208SMB3_request_interfaces(const unsigned int xid, struct cifs_tcon *tcon)
209{
210 int rc;
211 unsigned int ret_data_len = 0;
212 struct network_interface_info_ioctl_rsp *out_buf;
213
214 rc = SMB2_ioctl(xid, tcon, NO_FILE_ID, NO_FILE_ID,
215 FSCTL_QUERY_NETWORK_INTERFACE_INFO, true /* is_fsctl */,
216 NULL /* no data input */, 0 /* no data input */,
217 (char **)&out_buf, &ret_data_len);
218
219 if ((rc == 0) && (ret_data_len > 0)) {
220 /* Dump info on first interface */
221 cifs_dbg(FYI, "Adapter Capability 0x%x\t",
222 le32_to_cpu(out_buf->Capability));
223 cifs_dbg(FYI, "Link Speed %lld\n",
224 le64_to_cpu(out_buf->LinkSpeed));
225 } else
226 cifs_dbg(VFS, "error %d on ioctl to get interface list\n", rc);
227
228 return rc;
229}
230#endif /* STATS2 */
231
Steve French34f62642013-10-09 02:07:00 -0500232static void
Steven Frenchaf6a12e2013-10-09 20:55:53 -0500233smb3_qfs_tcon(const unsigned int xid, struct cifs_tcon *tcon)
234{
235 int rc;
236 __le16 srch_path = 0; /* Null - open root of share */
237 u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
238 struct cifs_open_parms oparms;
239 struct cifs_fid fid;
240
241 oparms.tcon = tcon;
242 oparms.desired_access = FILE_READ_ATTRIBUTES;
243 oparms.disposition = FILE_OPEN;
244 oparms.create_options = 0;
245 oparms.fid = &fid;
246 oparms.reconnect = false;
247
248 rc = SMB2_open(xid, &oparms, &srch_path, &oplock, NULL, NULL);
249 if (rc)
250 return;
251
Steve Frenchc481e9f2013-10-14 01:21:53 -0500252#ifdef CONFIG_CIFS_STATS2
253 SMB3_request_interfaces(xid, tcon);
254#endif /* STATS2 */
255
Steven Frenchaf6a12e2013-10-09 20:55:53 -0500256 SMB2_QFS_attr(xid, tcon, fid.persistent_fid, fid.volatile_fid,
257 FS_ATTRIBUTE_INFORMATION);
258 SMB2_QFS_attr(xid, tcon, fid.persistent_fid, fid.volatile_fid,
259 FS_DEVICE_INFORMATION);
260 SMB2_QFS_attr(xid, tcon, fid.persistent_fid, fid.volatile_fid,
261 FS_SECTOR_SIZE_INFORMATION); /* SMB3 specific */
262 SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
263 return;
264}
265
266static void
Steve French34f62642013-10-09 02:07:00 -0500267smb2_qfs_tcon(const unsigned int xid, struct cifs_tcon *tcon)
268{
269 int rc;
270 __le16 srch_path = 0; /* Null - open root of share */
271 u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
272 struct cifs_open_parms oparms;
273 struct cifs_fid fid;
274
275 oparms.tcon = tcon;
276 oparms.desired_access = FILE_READ_ATTRIBUTES;
277 oparms.disposition = FILE_OPEN;
278 oparms.create_options = 0;
279 oparms.fid = &fid;
280 oparms.reconnect = false;
281
282 rc = SMB2_open(xid, &oparms, &srch_path, &oplock, NULL, NULL);
283 if (rc)
284 return;
285
Steven French21671142013-10-09 13:36:35 -0500286 SMB2_QFS_attr(xid, tcon, fid.persistent_fid, fid.volatile_fid,
287 FS_ATTRIBUTE_INFORMATION);
288 SMB2_QFS_attr(xid, tcon, fid.persistent_fid, fid.volatile_fid,
289 FS_DEVICE_INFORMATION);
Steve French34f62642013-10-09 02:07:00 -0500290 SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
291 return;
292}
293
Pavel Shilovsky2503a0d2011-12-26 22:58:46 +0400294static int
295smb2_is_path_accessible(const unsigned int xid, struct cifs_tcon *tcon,
296 struct cifs_sb_info *cifs_sb, const char *full_path)
297{
298 int rc;
Pavel Shilovsky2503a0d2011-12-26 22:58:46 +0400299 __le16 *utf16_path;
Pavel Shilovsky2e44b282012-09-18 16:20:33 -0700300 __u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
Pavel Shilovsky064f6042013-07-09 18:20:30 +0400301 struct cifs_open_parms oparms;
302 struct cifs_fid fid;
Pavel Shilovsky2503a0d2011-12-26 22:58:46 +0400303
304 utf16_path = cifs_convert_path_to_utf16(full_path, cifs_sb);
305 if (!utf16_path)
306 return -ENOMEM;
307
Pavel Shilovsky064f6042013-07-09 18:20:30 +0400308 oparms.tcon = tcon;
309 oparms.desired_access = FILE_READ_ATTRIBUTES;
310 oparms.disposition = FILE_OPEN;
311 oparms.create_options = 0;
312 oparms.fid = &fid;
Pavel Shilovsky9cbc0b72013-07-09 18:40:58 +0400313 oparms.reconnect = false;
Pavel Shilovsky064f6042013-07-09 18:20:30 +0400314
Pavel Shilovskyb42bf882013-08-14 19:25:21 +0400315 rc = SMB2_open(xid, &oparms, utf16_path, &oplock, NULL, NULL);
Pavel Shilovsky2503a0d2011-12-26 22:58:46 +0400316 if (rc) {
317 kfree(utf16_path);
318 return rc;
319 }
320
Pavel Shilovsky064f6042013-07-09 18:20:30 +0400321 rc = SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
Pavel Shilovsky2503a0d2011-12-26 22:58:46 +0400322 kfree(utf16_path);
323 return rc;
324}
325
Pavel Shilovskybe4cb9e2011-12-29 17:06:33 +0400326static int
327smb2_get_srv_inum(const unsigned int xid, struct cifs_tcon *tcon,
328 struct cifs_sb_info *cifs_sb, const char *full_path,
329 u64 *uniqueid, FILE_ALL_INFO *data)
330{
331 *uniqueid = le64_to_cpu(data->IndexNumber);
332 return 0;
333}
334
Pavel Shilovskyb7546bc2012-09-18 16:20:27 -0700335static int
336smb2_query_file_info(const unsigned int xid, struct cifs_tcon *tcon,
337 struct cifs_fid *fid, FILE_ALL_INFO *data)
338{
339 int rc;
340 struct smb2_file_all_info *smb2_data;
341
342 smb2_data = kzalloc(sizeof(struct smb2_file_all_info) + MAX_NAME * 2,
343 GFP_KERNEL);
344 if (smb2_data == NULL)
345 return -ENOMEM;
346
347 rc = SMB2_query_info(xid, tcon, fid->persistent_fid, fid->volatile_fid,
348 smb2_data);
349 if (!rc)
350 move_smb2_info_to_cifs(data, smb2_data);
351 kfree(smb2_data);
352 return rc;
353}
354
Pavel Shilovsky9094fad2012-07-12 18:30:44 +0400355static bool
356smb2_can_echo(struct TCP_Server_Info *server)
357{
358 return server->echoes;
359}
360
Pavel Shilovskyd60622e2012-05-28 15:19:39 +0400361static void
362smb2_clear_stats(struct cifs_tcon *tcon)
363{
364#ifdef CONFIG_CIFS_STATS
365 int i;
366 for (i = 0; i < NUMBER_OF_SMB2_COMMANDS; i++) {
367 atomic_set(&tcon->stats.smb2_stats.smb2_com_sent[i], 0);
368 atomic_set(&tcon->stats.smb2_stats.smb2_com_failed[i], 0);
369 }
370#endif
371}
372
373static void
Steve French769ee6a2013-06-19 14:15:30 -0500374smb2_dump_share_caps(struct seq_file *m, struct cifs_tcon *tcon)
375{
376 seq_puts(m, "\n\tShare Capabilities:");
377 if (tcon->capabilities & SMB2_SHARE_CAP_DFS)
378 seq_puts(m, " DFS,");
379 if (tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
380 seq_puts(m, " CONTINUOUS AVAILABILITY,");
381 if (tcon->capabilities & SMB2_SHARE_CAP_SCALEOUT)
382 seq_puts(m, " SCALEOUT,");
383 if (tcon->capabilities & SMB2_SHARE_CAP_CLUSTER)
384 seq_puts(m, " CLUSTER,");
385 if (tcon->capabilities & SMB2_SHARE_CAP_ASYMMETRIC)
386 seq_puts(m, " ASYMMETRIC,");
387 if (tcon->capabilities == 0)
388 seq_puts(m, " None");
Steven Frenchaf6a12e2013-10-09 20:55:53 -0500389 if (tcon->ss_flags & SSINFO_FLAGS_ALIGNED_DEVICE)
390 seq_puts(m, " Aligned,");
391 if (tcon->ss_flags & SSINFO_FLAGS_PARTITION_ALIGNED_ON_DEVICE)
392 seq_puts(m, " Partition Aligned,");
393 if (tcon->ss_flags & SSINFO_FLAGS_NO_SEEK_PENALTY)
394 seq_puts(m, " SSD,");
395 if (tcon->ss_flags & SSINFO_FLAGS_TRIM_ENABLED)
396 seq_puts(m, " TRIM-support,");
397
Steve French769ee6a2013-06-19 14:15:30 -0500398 seq_printf(m, "\tShare Flags: 0x%x", tcon->share_flags);
Steven Frenchaf6a12e2013-10-09 20:55:53 -0500399 if (tcon->perf_sector_size)
400 seq_printf(m, "\tOptimal sector size: 0x%x",
401 tcon->perf_sector_size);
Steve French769ee6a2013-06-19 14:15:30 -0500402}
403
404static void
Pavel Shilovskyd60622e2012-05-28 15:19:39 +0400405smb2_print_stats(struct seq_file *m, struct cifs_tcon *tcon)
406{
407#ifdef CONFIG_CIFS_STATS
408 atomic_t *sent = tcon->stats.smb2_stats.smb2_com_sent;
409 atomic_t *failed = tcon->stats.smb2_stats.smb2_com_failed;
410 seq_printf(m, "\nNegotiates: %d sent %d failed",
411 atomic_read(&sent[SMB2_NEGOTIATE_HE]),
412 atomic_read(&failed[SMB2_NEGOTIATE_HE]));
413 seq_printf(m, "\nSessionSetups: %d sent %d failed",
414 atomic_read(&sent[SMB2_SESSION_SETUP_HE]),
415 atomic_read(&failed[SMB2_SESSION_SETUP_HE]));
Pavel Shilovskyd60622e2012-05-28 15:19:39 +0400416 seq_printf(m, "\nLogoffs: %d sent %d failed",
417 atomic_read(&sent[SMB2_LOGOFF_HE]),
418 atomic_read(&failed[SMB2_LOGOFF_HE]));
419 seq_printf(m, "\nTreeConnects: %d sent %d failed",
420 atomic_read(&sent[SMB2_TREE_CONNECT_HE]),
421 atomic_read(&failed[SMB2_TREE_CONNECT_HE]));
422 seq_printf(m, "\nTreeDisconnects: %d sent %d failed",
423 atomic_read(&sent[SMB2_TREE_DISCONNECT_HE]),
424 atomic_read(&failed[SMB2_TREE_DISCONNECT_HE]));
425 seq_printf(m, "\nCreates: %d sent %d failed",
426 atomic_read(&sent[SMB2_CREATE_HE]),
427 atomic_read(&failed[SMB2_CREATE_HE]));
428 seq_printf(m, "\nCloses: %d sent %d failed",
429 atomic_read(&sent[SMB2_CLOSE_HE]),
430 atomic_read(&failed[SMB2_CLOSE_HE]));
431 seq_printf(m, "\nFlushes: %d sent %d failed",
432 atomic_read(&sent[SMB2_FLUSH_HE]),
433 atomic_read(&failed[SMB2_FLUSH_HE]));
434 seq_printf(m, "\nReads: %d sent %d failed",
435 atomic_read(&sent[SMB2_READ_HE]),
436 atomic_read(&failed[SMB2_READ_HE]));
437 seq_printf(m, "\nWrites: %d sent %d failed",
438 atomic_read(&sent[SMB2_WRITE_HE]),
439 atomic_read(&failed[SMB2_WRITE_HE]));
440 seq_printf(m, "\nLocks: %d sent %d failed",
441 atomic_read(&sent[SMB2_LOCK_HE]),
442 atomic_read(&failed[SMB2_LOCK_HE]));
443 seq_printf(m, "\nIOCTLs: %d sent %d failed",
444 atomic_read(&sent[SMB2_IOCTL_HE]),
445 atomic_read(&failed[SMB2_IOCTL_HE]));
446 seq_printf(m, "\nCancels: %d sent %d failed",
447 atomic_read(&sent[SMB2_CANCEL_HE]),
448 atomic_read(&failed[SMB2_CANCEL_HE]));
449 seq_printf(m, "\nEchos: %d sent %d failed",
450 atomic_read(&sent[SMB2_ECHO_HE]),
451 atomic_read(&failed[SMB2_ECHO_HE]));
452 seq_printf(m, "\nQueryDirectories: %d sent %d failed",
453 atomic_read(&sent[SMB2_QUERY_DIRECTORY_HE]),
454 atomic_read(&failed[SMB2_QUERY_DIRECTORY_HE]));
455 seq_printf(m, "\nChangeNotifies: %d sent %d failed",
456 atomic_read(&sent[SMB2_CHANGE_NOTIFY_HE]),
457 atomic_read(&failed[SMB2_CHANGE_NOTIFY_HE]));
458 seq_printf(m, "\nQueryInfos: %d sent %d failed",
459 atomic_read(&sent[SMB2_QUERY_INFO_HE]),
460 atomic_read(&failed[SMB2_QUERY_INFO_HE]));
461 seq_printf(m, "\nSetInfos: %d sent %d failed",
462 atomic_read(&sent[SMB2_SET_INFO_HE]),
463 atomic_read(&failed[SMB2_SET_INFO_HE]));
464 seq_printf(m, "\nOplockBreaks: %d sent %d failed",
465 atomic_read(&sent[SMB2_OPLOCK_BREAK_HE]),
466 atomic_read(&failed[SMB2_OPLOCK_BREAK_HE]));
467#endif
468}
469
Pavel Shilovskyf0df7372012-09-18 16:20:26 -0700470static void
471smb2_set_fid(struct cifsFileInfo *cfile, struct cifs_fid *fid, __u32 oplock)
472{
Pavel Shilovsky2e44b282012-09-18 16:20:33 -0700473 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
Pavel Shilovsky53ef1012013-09-05 16:11:28 +0400474 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
475
Pavel Shilovskyf0df7372012-09-18 16:20:26 -0700476 cfile->fid.persistent_fid = fid->persistent_fid;
477 cfile->fid.volatile_fid = fid->volatile_fid;
Pavel Shilovsky42873b02013-09-05 21:30:16 +0400478 server->ops->set_oplock_level(cinode, oplock, fid->epoch,
479 &fid->purge_cache);
Pavel Shilovsky18cceb62013-09-05 13:01:06 +0400480 cinode->can_cache_brlcks = CIFS_CACHE_WRITE(cinode);
Pavel Shilovskyf0df7372012-09-18 16:20:26 -0700481}
482
Pavel Shilovsky760ad0c2012-09-25 11:00:07 +0400483static void
Pavel Shilovskyf0df7372012-09-18 16:20:26 -0700484smb2_close_file(const unsigned int xid, struct cifs_tcon *tcon,
485 struct cifs_fid *fid)
486{
Pavel Shilovsky760ad0c2012-09-25 11:00:07 +0400487 SMB2_close(xid, tcon, fid->persistent_fid, fid->volatile_fid);
Pavel Shilovskyf0df7372012-09-18 16:20:26 -0700488}
489
Pavel Shilovsky7a5cfb12012-09-18 16:20:28 -0700490static int
Steve French41c13582013-11-14 00:05:36 -0600491SMB2_request_res_key(const unsigned int xid, struct cifs_tcon *tcon,
492 u64 persistent_fid, u64 volatile_fid,
493 struct copychunk_ioctl *pcchunk)
494{
495 int rc;
496 unsigned int ret_data_len;
497 struct resume_key_req *res_key;
498
499 rc = SMB2_ioctl(xid, tcon, persistent_fid, volatile_fid,
500 FSCTL_SRV_REQUEST_RESUME_KEY, true /* is_fsctl */,
501 NULL, 0 /* no input */,
502 (char **)&res_key, &ret_data_len);
503
504 if (rc) {
505 cifs_dbg(VFS, "refcpy ioctl error %d getting resume key\n", rc);
506 goto req_res_key_exit;
507 }
508 if (ret_data_len < sizeof(struct resume_key_req)) {
509 cifs_dbg(VFS, "Invalid refcopy resume key length\n");
510 rc = -EINVAL;
511 goto req_res_key_exit;
512 }
513 memcpy(pcchunk->SourceKey, res_key->ResumeKey, COPY_CHUNK_RES_KEY_SIZE);
514
515req_res_key_exit:
516 kfree(res_key);
517 return rc;
518}
519
520static int
521smb2_clone_range(const unsigned int xid,
522 struct cifsFileInfo *srcfile,
523 struct cifsFileInfo *trgtfile, u64 src_off,
524 u64 len, u64 dest_off)
525{
526 int rc;
527 unsigned int ret_data_len;
528 struct copychunk_ioctl *pcchunk;
Steve French9bf0c9c2013-11-16 18:05:28 -0600529 struct copychunk_ioctl_rsp *retbuf = NULL;
530 struct cifs_tcon *tcon;
531 int chunks_copied = 0;
532 bool chunk_sizes_updated = false;
Steve French41c13582013-11-14 00:05:36 -0600533
534 pcchunk = kmalloc(sizeof(struct copychunk_ioctl), GFP_KERNEL);
535
536 if (pcchunk == NULL)
537 return -ENOMEM;
538
539 cifs_dbg(FYI, "in smb2_clone_range - about to call request res key\n");
540 /* Request a key from the server to identify the source of the copy */
541 rc = SMB2_request_res_key(xid, tlink_tcon(srcfile->tlink),
542 srcfile->fid.persistent_fid,
543 srcfile->fid.volatile_fid, pcchunk);
544
545 /* Note: request_res_key sets res_key null only if rc !=0 */
546 if (rc)
Steve French9bf0c9c2013-11-16 18:05:28 -0600547 goto cchunk_out;
Steve French41c13582013-11-14 00:05:36 -0600548
549 /* For now array only one chunk long, will make more flexible later */
550 pcchunk->ChunkCount = __constant_cpu_to_le32(1);
551 pcchunk->Reserved = 0;
Steve French41c13582013-11-14 00:05:36 -0600552 pcchunk->Reserved2 = 0;
553
Steve French9bf0c9c2013-11-16 18:05:28 -0600554 tcon = tlink_tcon(trgtfile->tlink);
555
556 while (len > 0) {
557 pcchunk->SourceOffset = cpu_to_le64(src_off);
558 pcchunk->TargetOffset = cpu_to_le64(dest_off);
559 pcchunk->Length =
560 cpu_to_le32(min_t(u32, len, tcon->max_bytes_chunk));
561
562 /* Request server copy to target from src identified by key */
563 rc = SMB2_ioctl(xid, tcon, trgtfile->fid.persistent_fid,
Steve French41c13582013-11-14 00:05:36 -0600564 trgtfile->fid.volatile_fid, FSCTL_SRV_COPYCHUNK_WRITE,
565 true /* is_fsctl */, (char *)pcchunk,
Steve French9bf0c9c2013-11-16 18:05:28 -0600566 sizeof(struct copychunk_ioctl), (char **)&retbuf,
567 &ret_data_len);
568 if (rc == 0) {
569 if (ret_data_len !=
570 sizeof(struct copychunk_ioctl_rsp)) {
571 cifs_dbg(VFS, "invalid cchunk response size\n");
572 rc = -EIO;
573 goto cchunk_out;
574 }
575 if (retbuf->TotalBytesWritten == 0) {
576 cifs_dbg(FYI, "no bytes copied\n");
577 rc = -EIO;
578 goto cchunk_out;
579 }
580 /*
581 * Check if server claimed to write more than we asked
582 */
583 if (le32_to_cpu(retbuf->TotalBytesWritten) >
584 le32_to_cpu(pcchunk->Length)) {
585 cifs_dbg(VFS, "invalid copy chunk response\n");
586 rc = -EIO;
587 goto cchunk_out;
588 }
589 if (le32_to_cpu(retbuf->ChunksWritten) != 1) {
590 cifs_dbg(VFS, "invalid num chunks written\n");
591 rc = -EIO;
592 goto cchunk_out;
593 }
594 chunks_copied++;
Steve French41c13582013-11-14 00:05:36 -0600595
Steve French9bf0c9c2013-11-16 18:05:28 -0600596 src_off += le32_to_cpu(retbuf->TotalBytesWritten);
597 dest_off += le32_to_cpu(retbuf->TotalBytesWritten);
598 len -= le32_to_cpu(retbuf->TotalBytesWritten);
Steve French41c13582013-11-14 00:05:36 -0600599
Steve French9bf0c9c2013-11-16 18:05:28 -0600600 cifs_dbg(FYI, "Chunks %d PartialChunk %d Total %d\n",
601 le32_to_cpu(retbuf->ChunksWritten),
602 le32_to_cpu(retbuf->ChunkBytesWritten),
603 le32_to_cpu(retbuf->TotalBytesWritten));
604 } else if (rc == -EINVAL) {
605 if (ret_data_len != sizeof(struct copychunk_ioctl_rsp))
606 goto cchunk_out;
Steve French41c13582013-11-14 00:05:36 -0600607
Steve French9bf0c9c2013-11-16 18:05:28 -0600608 cifs_dbg(FYI, "MaxChunks %d BytesChunk %d MaxCopy %d\n",
609 le32_to_cpu(retbuf->ChunksWritten),
610 le32_to_cpu(retbuf->ChunkBytesWritten),
611 le32_to_cpu(retbuf->TotalBytesWritten));
612
613 /*
614 * Check if this is the first request using these sizes,
615 * (ie check if copy succeed once with original sizes
616 * and check if the server gave us different sizes after
617 * we already updated max sizes on previous request).
618 * if not then why is the server returning an error now
619 */
620 if ((chunks_copied != 0) || chunk_sizes_updated)
621 goto cchunk_out;
622
623 /* Check that server is not asking us to grow size */
624 if (le32_to_cpu(retbuf->ChunkBytesWritten) <
625 tcon->max_bytes_chunk)
626 tcon->max_bytes_chunk =
627 le32_to_cpu(retbuf->ChunkBytesWritten);
628 else
629 goto cchunk_out; /* server gave us bogus size */
630
631 /* No need to change MaxChunks since already set to 1 */
632 chunk_sizes_updated = true;
633 }
634 }
635
636cchunk_out:
Steve French41c13582013-11-14 00:05:36 -0600637 kfree(pcchunk);
638 return rc;
639}
640
641static int
Pavel Shilovsky7a5cfb12012-09-18 16:20:28 -0700642smb2_flush_file(const unsigned int xid, struct cifs_tcon *tcon,
643 struct cifs_fid *fid)
644{
645 return SMB2_flush(xid, tcon, fid->persistent_fid, fid->volatile_fid);
646}
647
Pavel Shilovsky09a47072012-09-18 16:20:29 -0700648static unsigned int
649smb2_read_data_offset(char *buf)
650{
651 struct smb2_read_rsp *rsp = (struct smb2_read_rsp *)buf;
652 return rsp->DataOffset;
653}
654
655static unsigned int
656smb2_read_data_length(char *buf)
657{
658 struct smb2_read_rsp *rsp = (struct smb2_read_rsp *)buf;
659 return le32_to_cpu(rsp->DataLength);
660}
661
Pavel Shilovskyd8e05032012-09-18 16:20:30 -0700662
663static int
664smb2_sync_read(const unsigned int xid, struct cifsFileInfo *cfile,
665 struct cifs_io_parms *parms, unsigned int *bytes_read,
666 char **buf, int *buf_type)
667{
668 parms->persistent_fid = cfile->fid.persistent_fid;
669 parms->volatile_fid = cfile->fid.volatile_fid;
670 return SMB2_read(xid, parms, bytes_read, buf, buf_type);
671}
672
Pavel Shilovsky009d3442012-09-18 16:20:30 -0700673static int
674smb2_sync_write(const unsigned int xid, struct cifsFileInfo *cfile,
675 struct cifs_io_parms *parms, unsigned int *written,
676 struct kvec *iov, unsigned long nr_segs)
677{
678
679 parms->persistent_fid = cfile->fid.persistent_fid;
680 parms->volatile_fid = cfile->fid.volatile_fid;
681 return SMB2_write(xid, parms, written, iov, nr_segs);
682}
683
Pavel Shilovskyc839ff22012-09-18 16:20:32 -0700684static int
685smb2_set_file_size(const unsigned int xid, struct cifs_tcon *tcon,
686 struct cifsFileInfo *cfile, __u64 size, bool set_alloc)
687{
688 __le64 eof = cpu_to_le64(size);
689 return SMB2_set_eof(xid, tcon, cfile->fid.persistent_fid,
690 cfile->fid.volatile_fid, cfile->pid, &eof);
691}
692
Pavel Shilovskyd324f08d2012-09-18 16:20:33 -0700693static int
Steve French64a5cfa2013-10-14 15:31:32 -0500694smb2_set_compression(const unsigned int xid, struct cifs_tcon *tcon,
695 struct cifsFileInfo *cfile)
696{
697 return SMB2_set_compression(xid, tcon, cfile->fid.persistent_fid,
698 cfile->fid.volatile_fid);
699}
700
701static int
Pavel Shilovskyd324f08d2012-09-18 16:20:33 -0700702smb2_query_dir_first(const unsigned int xid, struct cifs_tcon *tcon,
703 const char *path, struct cifs_sb_info *cifs_sb,
704 struct cifs_fid *fid, __u16 search_flags,
705 struct cifs_search_info *srch_inf)
706{
707 __le16 *utf16_path;
708 int rc;
Pavel Shilovsky2e44b282012-09-18 16:20:33 -0700709 __u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
Pavel Shilovsky064f6042013-07-09 18:20:30 +0400710 struct cifs_open_parms oparms;
Pavel Shilovskyd324f08d2012-09-18 16:20:33 -0700711
712 utf16_path = cifs_convert_path_to_utf16(path, cifs_sb);
713 if (!utf16_path)
714 return -ENOMEM;
715
Pavel Shilovsky064f6042013-07-09 18:20:30 +0400716 oparms.tcon = tcon;
717 oparms.desired_access = FILE_READ_ATTRIBUTES | FILE_READ_DATA;
718 oparms.disposition = FILE_OPEN;
719 oparms.create_options = 0;
720 oparms.fid = fid;
Pavel Shilovsky9cbc0b72013-07-09 18:40:58 +0400721 oparms.reconnect = false;
Pavel Shilovsky064f6042013-07-09 18:20:30 +0400722
Pavel Shilovskyb42bf882013-08-14 19:25:21 +0400723 rc = SMB2_open(xid, &oparms, utf16_path, &oplock, NULL, NULL);
Pavel Shilovskyd324f08d2012-09-18 16:20:33 -0700724 kfree(utf16_path);
725 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500726 cifs_dbg(VFS, "open dir failed\n");
Pavel Shilovskyd324f08d2012-09-18 16:20:33 -0700727 return rc;
728 }
729
730 srch_inf->entries_in_buffer = 0;
731 srch_inf->index_of_last_entry = 0;
Pavel Shilovskyd324f08d2012-09-18 16:20:33 -0700732
Pavel Shilovsky064f6042013-07-09 18:20:30 +0400733 rc = SMB2_query_directory(xid, tcon, fid->persistent_fid,
734 fid->volatile_fid, 0, srch_inf);
Pavel Shilovskyd324f08d2012-09-18 16:20:33 -0700735 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500736 cifs_dbg(VFS, "query directory failed\n");
Pavel Shilovsky064f6042013-07-09 18:20:30 +0400737 SMB2_close(xid, tcon, fid->persistent_fid, fid->volatile_fid);
Pavel Shilovskyd324f08d2012-09-18 16:20:33 -0700738 }
739 return rc;
740}
741
742static int
743smb2_query_dir_next(const unsigned int xid, struct cifs_tcon *tcon,
744 struct cifs_fid *fid, __u16 search_flags,
745 struct cifs_search_info *srch_inf)
746{
747 return SMB2_query_directory(xid, tcon, fid->persistent_fid,
748 fid->volatile_fid, 0, srch_inf);
749}
750
751static int
752smb2_close_dir(const unsigned int xid, struct cifs_tcon *tcon,
753 struct cifs_fid *fid)
754{
755 return SMB2_close(xid, tcon, fid->persistent_fid, fid->volatile_fid);
756}
757
Pavel Shilovsky2e44b282012-09-18 16:20:33 -0700758/*
759* If we negotiate SMB2 protocol and get STATUS_PENDING - update
760* the number of credits and return true. Otherwise - return false.
761*/
762static bool
763smb2_is_status_pending(char *buf, struct TCP_Server_Info *server, int length)
764{
765 struct smb2_hdr *hdr = (struct smb2_hdr *)buf;
766
Steve French12e8a202012-09-19 09:19:39 -0700767 if (hdr->Status != STATUS_PENDING)
Pavel Shilovsky2e44b282012-09-18 16:20:33 -0700768 return false;
769
770 if (!length) {
771 spin_lock(&server->req_lock);
772 server->credits += le16_to_cpu(hdr->CreditRequest);
773 spin_unlock(&server->req_lock);
774 wake_up(&server->request_q);
775 }
776
777 return true;
778}
779
Pavel Shilovsky983c88a2012-09-18 16:20:33 -0700780static int
781smb2_oplock_response(struct cifs_tcon *tcon, struct cifs_fid *fid,
782 struct cifsInodeInfo *cinode)
783{
Pavel Shilovsky0822f512012-09-19 06:22:45 -0700784 if (tcon->ses->server->capabilities & SMB2_GLOBAL_CAP_LEASING)
785 return SMB2_lease_break(0, tcon, cinode->lease_key,
786 smb2_get_lease_state(cinode));
787
Pavel Shilovsky983c88a2012-09-18 16:20:33 -0700788 return SMB2_oplock_break(0, tcon, fid->persistent_fid,
789 fid->volatile_fid,
Pavel Shilovsky18cceb62013-09-05 13:01:06 +0400790 CIFS_CACHE_READ(cinode) ? 1 : 0);
Pavel Shilovsky983c88a2012-09-18 16:20:33 -0700791}
792
Pavel Shilovsky6fc05c22012-09-18 16:20:34 -0700793static int
794smb2_queryfs(const unsigned int xid, struct cifs_tcon *tcon,
795 struct kstatfs *buf)
796{
797 int rc;
Pavel Shilovsky6fc05c22012-09-18 16:20:34 -0700798 __le16 srch_path = 0; /* Null - open root of share */
799 u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
Pavel Shilovsky064f6042013-07-09 18:20:30 +0400800 struct cifs_open_parms oparms;
801 struct cifs_fid fid;
Pavel Shilovsky6fc05c22012-09-18 16:20:34 -0700802
Pavel Shilovsky064f6042013-07-09 18:20:30 +0400803 oparms.tcon = tcon;
804 oparms.desired_access = FILE_READ_ATTRIBUTES;
805 oparms.disposition = FILE_OPEN;
806 oparms.create_options = 0;
807 oparms.fid = &fid;
Pavel Shilovsky9cbc0b72013-07-09 18:40:58 +0400808 oparms.reconnect = false;
Pavel Shilovsky064f6042013-07-09 18:20:30 +0400809
Pavel Shilovskyb42bf882013-08-14 19:25:21 +0400810 rc = SMB2_open(xid, &oparms, &srch_path, &oplock, NULL, NULL);
Pavel Shilovsky6fc05c22012-09-18 16:20:34 -0700811 if (rc)
812 return rc;
813 buf->f_type = SMB2_MAGIC_NUMBER;
Pavel Shilovsky064f6042013-07-09 18:20:30 +0400814 rc = SMB2_QFS_info(xid, tcon, fid.persistent_fid, fid.volatile_fid,
815 buf);
816 SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
Pavel Shilovsky6fc05c22012-09-18 16:20:34 -0700817 return rc;
818}
819
Pavel Shilovsky027e8ee2012-09-19 06:22:43 -0700820static bool
821smb2_compare_fids(struct cifsFileInfo *ob1, struct cifsFileInfo *ob2)
822{
823 return ob1->fid.persistent_fid == ob2->fid.persistent_fid &&
824 ob1->fid.volatile_fid == ob2->fid.volatile_fid;
825}
826
Pavel Shilovskyf7ba7fe2012-09-19 06:22:43 -0700827static int
828smb2_mand_lock(const unsigned int xid, struct cifsFileInfo *cfile, __u64 offset,
829 __u64 length, __u32 type, int lock, int unlock, bool wait)
830{
831 if (unlock && !lock)
832 type = SMB2_LOCKFLAG_UNLOCK;
833 return SMB2_lock(xid, tlink_tcon(cfile->tlink),
834 cfile->fid.persistent_fid, cfile->fid.volatile_fid,
835 current->tgid, length, offset, type, wait);
836}
837
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700838static void
839smb2_get_lease_key(struct inode *inode, struct cifs_fid *fid)
840{
841 memcpy(fid->lease_key, CIFS_I(inode)->lease_key, SMB2_LEASE_KEY_SIZE);
842}
843
844static void
845smb2_set_lease_key(struct inode *inode, struct cifs_fid *fid)
846{
847 memcpy(CIFS_I(inode)->lease_key, fid->lease_key, SMB2_LEASE_KEY_SIZE);
848}
849
850static void
851smb2_new_lease_key(struct cifs_fid *fid)
852{
853 get_random_bytes(fid->lease_key, SMB2_LEASE_KEY_SIZE);
854}
855
Pavel Shilovskyb42bf882013-08-14 19:25:21 +0400856static int
857smb2_query_symlink(const unsigned int xid, struct cifs_tcon *tcon,
858 const char *full_path, char **target_path,
859 struct cifs_sb_info *cifs_sb)
860{
861 int rc;
862 __le16 *utf16_path;
863 __u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
864 struct cifs_open_parms oparms;
865 struct cifs_fid fid;
866 struct smb2_err_rsp *err_buf = NULL;
867 struct smb2_symlink_err_rsp *symlink;
868 unsigned int sub_len, sub_offset;
869
870 cifs_dbg(FYI, "%s: path: %s\n", __func__, full_path);
871
872 utf16_path = cifs_convert_path_to_utf16(full_path, cifs_sb);
873 if (!utf16_path)
874 return -ENOMEM;
875
876 oparms.tcon = tcon;
877 oparms.desired_access = FILE_READ_ATTRIBUTES;
878 oparms.disposition = FILE_OPEN;
879 oparms.create_options = 0;
880 oparms.fid = &fid;
881 oparms.reconnect = false;
882
883 rc = SMB2_open(xid, &oparms, utf16_path, &oplock, NULL, &err_buf);
884
885 if (!rc || !err_buf) {
886 kfree(utf16_path);
887 return -ENOENT;
888 }
889 /* open must fail on symlink - reset rc */
890 rc = 0;
891 symlink = (struct smb2_symlink_err_rsp *)err_buf->ErrorData;
892 sub_len = le16_to_cpu(symlink->SubstituteNameLength);
893 sub_offset = le16_to_cpu(symlink->SubstituteNameOffset);
894 *target_path = cifs_strndup_from_utf16(
895 (char *)symlink->PathBuffer + sub_offset,
896 sub_len, true, cifs_sb->local_nls);
897 if (!(*target_path)) {
898 kfree(utf16_path);
899 return -ENOMEM;
900 }
901 convert_delimiter(*target_path, '/');
902 cifs_dbg(FYI, "%s: target path: %s\n", __func__, *target_path);
903 kfree(utf16_path);
904 return rc;
905}
906
Pavel Shilovsky53ef1012013-09-05 16:11:28 +0400907static void
Pavel Shilovsky42873b02013-09-05 21:30:16 +0400908smb2_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock,
909 unsigned int epoch, bool *purge_cache)
Pavel Shilovsky53ef1012013-09-05 16:11:28 +0400910{
911 oplock &= 0xFF;
912 if (oplock == SMB2_OPLOCK_LEVEL_NOCHANGE)
913 return;
914 if (oplock == SMB2_OPLOCK_LEVEL_BATCH) {
Pavel Shilovsky42873b02013-09-05 21:30:16 +0400915 cinode->oplock = CIFS_CACHE_RHW_FLG;
Pavel Shilovsky53ef1012013-09-05 16:11:28 +0400916 cifs_dbg(FYI, "Batch Oplock granted on inode %p\n",
917 &cinode->vfs_inode);
918 } else if (oplock == SMB2_OPLOCK_LEVEL_EXCLUSIVE) {
Pavel Shilovsky42873b02013-09-05 21:30:16 +0400919 cinode->oplock = CIFS_CACHE_RW_FLG;
Pavel Shilovsky53ef1012013-09-05 16:11:28 +0400920 cifs_dbg(FYI, "Exclusive Oplock granted on inode %p\n",
921 &cinode->vfs_inode);
922 } else if (oplock == SMB2_OPLOCK_LEVEL_II) {
923 cinode->oplock = CIFS_CACHE_READ_FLG;
924 cifs_dbg(FYI, "Level II Oplock granted on inode %p\n",
925 &cinode->vfs_inode);
926 } else
927 cinode->oplock = 0;
928}
929
930static void
Pavel Shilovsky42873b02013-09-05 21:30:16 +0400931smb21_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock,
932 unsigned int epoch, bool *purge_cache)
Pavel Shilovsky53ef1012013-09-05 16:11:28 +0400933{
934 char message[5] = {0};
935
936 oplock &= 0xFF;
937 if (oplock == SMB2_OPLOCK_LEVEL_NOCHANGE)
938 return;
939
940 cinode->oplock = 0;
941 if (oplock & SMB2_LEASE_READ_CACHING_HE) {
942 cinode->oplock |= CIFS_CACHE_READ_FLG;
943 strcat(message, "R");
944 }
945 if (oplock & SMB2_LEASE_HANDLE_CACHING_HE) {
946 cinode->oplock |= CIFS_CACHE_HANDLE_FLG;
947 strcat(message, "H");
948 }
949 if (oplock & SMB2_LEASE_WRITE_CACHING_HE) {
950 cinode->oplock |= CIFS_CACHE_WRITE_FLG;
951 strcat(message, "W");
952 }
953 if (!cinode->oplock)
954 strcat(message, "None");
955 cifs_dbg(FYI, "%s Lease granted on inode %p\n", message,
956 &cinode->vfs_inode);
957}
958
Pavel Shilovsky42873b02013-09-05 21:30:16 +0400959static void
960smb3_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock,
961 unsigned int epoch, bool *purge_cache)
962{
963 unsigned int old_oplock = cinode->oplock;
964
965 smb21_set_oplock_level(cinode, oplock, epoch, purge_cache);
966
967 if (purge_cache) {
968 *purge_cache = false;
969 if (old_oplock == CIFS_CACHE_READ_FLG) {
970 if (cinode->oplock == CIFS_CACHE_READ_FLG &&
971 (epoch - cinode->epoch > 0))
972 *purge_cache = true;
973 else if (cinode->oplock == CIFS_CACHE_RH_FLG &&
974 (epoch - cinode->epoch > 1))
975 *purge_cache = true;
976 else if (cinode->oplock == CIFS_CACHE_RHW_FLG &&
977 (epoch - cinode->epoch > 1))
978 *purge_cache = true;
979 else if (cinode->oplock == 0 &&
980 (epoch - cinode->epoch > 0))
981 *purge_cache = true;
982 } else if (old_oplock == CIFS_CACHE_RH_FLG) {
983 if (cinode->oplock == CIFS_CACHE_RH_FLG &&
984 (epoch - cinode->epoch > 0))
985 *purge_cache = true;
986 else if (cinode->oplock == CIFS_CACHE_RHW_FLG &&
987 (epoch - cinode->epoch > 1))
988 *purge_cache = true;
989 }
990 cinode->epoch = epoch;
991 }
992}
993
Pavel Shilovsky53ef1012013-09-05 16:11:28 +0400994static bool
995smb2_is_read_op(__u32 oplock)
996{
997 return oplock == SMB2_OPLOCK_LEVEL_II;
998}
999
1000static bool
1001smb21_is_read_op(__u32 oplock)
1002{
1003 return (oplock & SMB2_LEASE_READ_CACHING_HE) &&
1004 !(oplock & SMB2_LEASE_WRITE_CACHING_HE);
1005}
1006
Pavel Shilovskyf0473902013-09-04 13:44:05 +04001007static __le32
1008map_oplock_to_lease(u8 oplock)
1009{
1010 if (oplock == SMB2_OPLOCK_LEVEL_EXCLUSIVE)
1011 return SMB2_LEASE_WRITE_CACHING | SMB2_LEASE_READ_CACHING;
1012 else if (oplock == SMB2_OPLOCK_LEVEL_II)
1013 return SMB2_LEASE_READ_CACHING;
1014 else if (oplock == SMB2_OPLOCK_LEVEL_BATCH)
1015 return SMB2_LEASE_HANDLE_CACHING | SMB2_LEASE_READ_CACHING |
1016 SMB2_LEASE_WRITE_CACHING;
1017 return 0;
1018}
1019
Pavel Shilovskya41a28b2013-09-04 13:07:41 +04001020static char *
1021smb2_create_lease_buf(u8 *lease_key, u8 oplock)
1022{
1023 struct create_lease *buf;
1024
1025 buf = kzalloc(sizeof(struct create_lease), GFP_KERNEL);
1026 if (!buf)
1027 return NULL;
1028
1029 buf->lcontext.LeaseKeyLow = cpu_to_le64(*((u64 *)lease_key));
1030 buf->lcontext.LeaseKeyHigh = cpu_to_le64(*((u64 *)(lease_key + 8)));
Pavel Shilovskyf0473902013-09-04 13:44:05 +04001031 buf->lcontext.LeaseState = map_oplock_to_lease(oplock);
Pavel Shilovskya41a28b2013-09-04 13:07:41 +04001032
1033 buf->ccontext.DataOffset = cpu_to_le16(offsetof
1034 (struct create_lease, lcontext));
1035 buf->ccontext.DataLength = cpu_to_le32(sizeof(struct lease_context));
1036 buf->ccontext.NameOffset = cpu_to_le16(offsetof
1037 (struct create_lease, Name));
1038 buf->ccontext.NameLength = cpu_to_le16(4);
1039 buf->Name[0] = 'R';
1040 buf->Name[1] = 'q';
1041 buf->Name[2] = 'L';
1042 buf->Name[3] = 's';
1043 return (char *)buf;
1044}
1045
Pavel Shilovskyf0473902013-09-04 13:44:05 +04001046static char *
1047smb3_create_lease_buf(u8 *lease_key, u8 oplock)
1048{
1049 struct create_lease_v2 *buf;
1050
1051 buf = kzalloc(sizeof(struct create_lease_v2), GFP_KERNEL);
1052 if (!buf)
1053 return NULL;
1054
1055 buf->lcontext.LeaseKeyLow = cpu_to_le64(*((u64 *)lease_key));
1056 buf->lcontext.LeaseKeyHigh = cpu_to_le64(*((u64 *)(lease_key + 8)));
1057 buf->lcontext.LeaseState = map_oplock_to_lease(oplock);
1058
1059 buf->ccontext.DataOffset = cpu_to_le16(offsetof
1060 (struct create_lease_v2, lcontext));
1061 buf->ccontext.DataLength = cpu_to_le32(sizeof(struct lease_context_v2));
1062 buf->ccontext.NameOffset = cpu_to_le16(offsetof
1063 (struct create_lease_v2, Name));
1064 buf->ccontext.NameLength = cpu_to_le16(4);
1065 buf->Name[0] = 'R';
1066 buf->Name[1] = 'q';
1067 buf->Name[2] = 'L';
1068 buf->Name[3] = 's';
1069 return (char *)buf;
1070}
1071
Pavel Shilovskyb5c7cde2013-09-05 20:16:45 +04001072static __u8
Pavel Shilovsky42873b02013-09-05 21:30:16 +04001073smb2_parse_lease_buf(void *buf, unsigned int *epoch)
Pavel Shilovskyb5c7cde2013-09-05 20:16:45 +04001074{
1075 struct create_lease *lc = (struct create_lease *)buf;
1076
Pavel Shilovsky42873b02013-09-05 21:30:16 +04001077 *epoch = 0; /* not used */
Pavel Shilovskyb5c7cde2013-09-05 20:16:45 +04001078 if (lc->lcontext.LeaseFlags & SMB2_LEASE_FLAG_BREAK_IN_PROGRESS)
1079 return SMB2_OPLOCK_LEVEL_NOCHANGE;
1080 return le32_to_cpu(lc->lcontext.LeaseState);
1081}
1082
Pavel Shilovskyf0473902013-09-04 13:44:05 +04001083static __u8
Pavel Shilovsky42873b02013-09-05 21:30:16 +04001084smb3_parse_lease_buf(void *buf, unsigned int *epoch)
Pavel Shilovskyf0473902013-09-04 13:44:05 +04001085{
1086 struct create_lease_v2 *lc = (struct create_lease_v2 *)buf;
1087
Pavel Shilovsky42873b02013-09-05 21:30:16 +04001088 *epoch = le16_to_cpu(lc->lcontext.Epoch);
Pavel Shilovskyf0473902013-09-04 13:44:05 +04001089 if (lc->lcontext.LeaseFlags & SMB2_LEASE_FLAG_BREAK_IN_PROGRESS)
1090 return SMB2_OPLOCK_LEVEL_NOCHANGE;
1091 return le32_to_cpu(lc->lcontext.LeaseState);
1092}
1093
Pavel Shilovsky53ef1012013-09-05 16:11:28 +04001094struct smb_version_operations smb20_operations = {
1095 .compare_fids = smb2_compare_fids,
1096 .setup_request = smb2_setup_request,
1097 .setup_async_request = smb2_setup_async_request,
1098 .check_receive = smb2_check_receive,
1099 .add_credits = smb2_add_credits,
1100 .set_credits = smb2_set_credits,
1101 .get_credits_field = smb2_get_credits_field,
1102 .get_credits = smb2_get_credits,
1103 .get_next_mid = smb2_get_next_mid,
1104 .read_data_offset = smb2_read_data_offset,
1105 .read_data_length = smb2_read_data_length,
1106 .map_error = map_smb2_to_linux_error,
1107 .find_mid = smb2_find_mid,
1108 .check_message = smb2_check_message,
1109 .dump_detail = smb2_dump_detail,
1110 .clear_stats = smb2_clear_stats,
1111 .print_stats = smb2_print_stats,
1112 .is_oplock_break = smb2_is_valid_oplock_break,
1113 .need_neg = smb2_need_neg,
1114 .negotiate = smb2_negotiate,
1115 .negotiate_wsize = smb2_negotiate_wsize,
1116 .negotiate_rsize = smb2_negotiate_rsize,
1117 .sess_setup = SMB2_sess_setup,
1118 .logoff = SMB2_logoff,
1119 .tree_connect = SMB2_tcon,
1120 .tree_disconnect = SMB2_tdis,
Steve French34f62642013-10-09 02:07:00 -05001121 .qfs_tcon = smb2_qfs_tcon,
Pavel Shilovsky53ef1012013-09-05 16:11:28 +04001122 .is_path_accessible = smb2_is_path_accessible,
1123 .can_echo = smb2_can_echo,
1124 .echo = SMB2_echo,
1125 .query_path_info = smb2_query_path_info,
1126 .get_srv_inum = smb2_get_srv_inum,
1127 .query_file_info = smb2_query_file_info,
1128 .set_path_size = smb2_set_path_size,
1129 .set_file_size = smb2_set_file_size,
1130 .set_file_info = smb2_set_file_info,
Steve French64a5cfa2013-10-14 15:31:32 -05001131 .set_compression = smb2_set_compression,
Pavel Shilovsky53ef1012013-09-05 16:11:28 +04001132 .mkdir = smb2_mkdir,
1133 .mkdir_setinfo = smb2_mkdir_setinfo,
1134 .rmdir = smb2_rmdir,
1135 .unlink = smb2_unlink,
1136 .rename = smb2_rename_path,
1137 .create_hardlink = smb2_create_hardlink,
1138 .query_symlink = smb2_query_symlink,
1139 .open = smb2_open_file,
1140 .set_fid = smb2_set_fid,
1141 .close = smb2_close_file,
1142 .flush = smb2_flush_file,
1143 .async_readv = smb2_async_readv,
1144 .async_writev = smb2_async_writev,
1145 .sync_read = smb2_sync_read,
1146 .sync_write = smb2_sync_write,
1147 .query_dir_first = smb2_query_dir_first,
1148 .query_dir_next = smb2_query_dir_next,
1149 .close_dir = smb2_close_dir,
1150 .calc_smb_size = smb2_calc_size,
1151 .is_status_pending = smb2_is_status_pending,
1152 .oplock_response = smb2_oplock_response,
1153 .queryfs = smb2_queryfs,
1154 .mand_lock = smb2_mand_lock,
1155 .mand_unlock_range = smb2_unlock_range,
1156 .push_mand_locks = smb2_push_mandatory_locks,
1157 .get_lease_key = smb2_get_lease_key,
1158 .set_lease_key = smb2_set_lease_key,
1159 .new_lease_key = smb2_new_lease_key,
1160 .calc_signature = smb2_calc_signature,
1161 .is_read_op = smb2_is_read_op,
1162 .set_oplock_level = smb2_set_oplock_level,
Pavel Shilovskya41a28b2013-09-04 13:07:41 +04001163 .create_lease_buf = smb2_create_lease_buf,
Pavel Shilovskyb5c7cde2013-09-05 20:16:45 +04001164 .parse_lease_buf = smb2_parse_lease_buf,
Steve French41c13582013-11-14 00:05:36 -06001165 .clone_range = smb2_clone_range,
Pavel Shilovsky53ef1012013-09-05 16:11:28 +04001166};
1167
Steve French1080ef72011-02-24 18:07:19 +00001168struct smb_version_operations smb21_operations = {
Pavel Shilovsky027e8ee2012-09-19 06:22:43 -07001169 .compare_fids = smb2_compare_fids,
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +04001170 .setup_request = smb2_setup_request,
Pavel Shilovskyc95b8ee2012-07-11 14:45:28 +04001171 .setup_async_request = smb2_setup_async_request,
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +04001172 .check_receive = smb2_check_receive,
Pavel Shilovsky28ea5292012-05-23 16:18:00 +04001173 .add_credits = smb2_add_credits,
1174 .set_credits = smb2_set_credits,
1175 .get_credits_field = smb2_get_credits_field,
1176 .get_credits = smb2_get_credits,
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +04001177 .get_next_mid = smb2_get_next_mid,
Pavel Shilovsky09a47072012-09-18 16:20:29 -07001178 .read_data_offset = smb2_read_data_offset,
1179 .read_data_length = smb2_read_data_length,
1180 .map_error = map_smb2_to_linux_error,
Pavel Shilovsky093b2bd2011-06-08 15:51:07 +04001181 .find_mid = smb2_find_mid,
1182 .check_message = smb2_check_message,
1183 .dump_detail = smb2_dump_detail,
Pavel Shilovskyd60622e2012-05-28 15:19:39 +04001184 .clear_stats = smb2_clear_stats,
1185 .print_stats = smb2_print_stats,
Pavel Shilovsky983c88a2012-09-18 16:20:33 -07001186 .is_oplock_break = smb2_is_valid_oplock_break,
Pavel Shilovskyec2e4522011-12-27 16:12:43 +04001187 .need_neg = smb2_need_neg,
1188 .negotiate = smb2_negotiate,
Pavel Shilovsky3a3bab52012-09-18 16:20:28 -07001189 .negotiate_wsize = smb2_negotiate_wsize,
1190 .negotiate_rsize = smb2_negotiate_rsize,
Pavel Shilovsky5478f9b2011-12-27 16:22:00 +04001191 .sess_setup = SMB2_sess_setup,
1192 .logoff = SMB2_logoff,
Pavel Shilovskyfaaf9462011-12-27 16:04:00 +04001193 .tree_connect = SMB2_tcon,
1194 .tree_disconnect = SMB2_tdis,
Steve French34f62642013-10-09 02:07:00 -05001195 .qfs_tcon = smb2_qfs_tcon,
Pavel Shilovsky2503a0d2011-12-26 22:58:46 +04001196 .is_path_accessible = smb2_is_path_accessible,
Pavel Shilovsky9094fad2012-07-12 18:30:44 +04001197 .can_echo = smb2_can_echo,
1198 .echo = SMB2_echo,
Pavel Shilovskybe4cb9e2011-12-29 17:06:33 +04001199 .query_path_info = smb2_query_path_info,
1200 .get_srv_inum = smb2_get_srv_inum,
Pavel Shilovskyb7546bc2012-09-18 16:20:27 -07001201 .query_file_info = smb2_query_file_info,
Pavel Shilovskyc839ff22012-09-18 16:20:32 -07001202 .set_path_size = smb2_set_path_size,
1203 .set_file_size = smb2_set_file_size,
Pavel Shilovsky1feeaac2012-09-18 16:20:32 -07001204 .set_file_info = smb2_set_file_info,
Steve French64a5cfa2013-10-14 15:31:32 -05001205 .set_compression = smb2_set_compression,
Pavel Shilovskya0e73182011-07-19 12:56:37 +04001206 .mkdir = smb2_mkdir,
1207 .mkdir_setinfo = smb2_mkdir_setinfo,
Pavel Shilovsky1a500f02012-07-10 16:14:38 +04001208 .rmdir = smb2_rmdir,
Pavel Shilovskycbe6f432012-09-18 16:20:25 -07001209 .unlink = smb2_unlink,
Pavel Shilovsky35143eb2012-09-18 16:20:31 -07001210 .rename = smb2_rename_path,
Pavel Shilovsky568798c2012-09-18 16:20:31 -07001211 .create_hardlink = smb2_create_hardlink,
Pavel Shilovskyb42bf882013-08-14 19:25:21 +04001212 .query_symlink = smb2_query_symlink,
Pavel Shilovskyf0df7372012-09-18 16:20:26 -07001213 .open = smb2_open_file,
1214 .set_fid = smb2_set_fid,
1215 .close = smb2_close_file,
Pavel Shilovsky7a5cfb12012-09-18 16:20:28 -07001216 .flush = smb2_flush_file,
Pavel Shilovsky09a47072012-09-18 16:20:29 -07001217 .async_readv = smb2_async_readv,
Pavel Shilovsky33319142012-09-18 16:20:29 -07001218 .async_writev = smb2_async_writev,
Pavel Shilovskyd8e05032012-09-18 16:20:30 -07001219 .sync_read = smb2_sync_read,
Pavel Shilovsky009d3442012-09-18 16:20:30 -07001220 .sync_write = smb2_sync_write,
Pavel Shilovskyd324f08d2012-09-18 16:20:33 -07001221 .query_dir_first = smb2_query_dir_first,
1222 .query_dir_next = smb2_query_dir_next,
1223 .close_dir = smb2_close_dir,
1224 .calc_smb_size = smb2_calc_size,
Pavel Shilovsky2e44b282012-09-18 16:20:33 -07001225 .is_status_pending = smb2_is_status_pending,
Pavel Shilovsky983c88a2012-09-18 16:20:33 -07001226 .oplock_response = smb2_oplock_response,
Pavel Shilovsky6fc05c22012-09-18 16:20:34 -07001227 .queryfs = smb2_queryfs,
Pavel Shilovskyf7ba7fe2012-09-19 06:22:43 -07001228 .mand_lock = smb2_mand_lock,
1229 .mand_unlock_range = smb2_unlock_range,
Pavel Shilovskyb1407992012-09-19 06:22:44 -07001230 .push_mand_locks = smb2_push_mandatory_locks,
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -07001231 .get_lease_key = smb2_get_lease_key,
1232 .set_lease_key = smb2_set_lease_key,
1233 .new_lease_key = smb2_new_lease_key,
Steve French38107d42012-12-08 22:08:06 -06001234 .calc_signature = smb2_calc_signature,
Pavel Shilovsky53ef1012013-09-05 16:11:28 +04001235 .is_read_op = smb21_is_read_op,
1236 .set_oplock_level = smb21_set_oplock_level,
Pavel Shilovskya41a28b2013-09-04 13:07:41 +04001237 .create_lease_buf = smb2_create_lease_buf,
Pavel Shilovskyb5c7cde2013-09-05 20:16:45 +04001238 .parse_lease_buf = smb2_parse_lease_buf,
Steve French41c13582013-11-14 00:05:36 -06001239 .clone_range = smb2_clone_range,
Steve French38107d42012-12-08 22:08:06 -06001240};
1241
Steve French38107d42012-12-08 22:08:06 -06001242struct smb_version_operations smb30_operations = {
1243 .compare_fids = smb2_compare_fids,
1244 .setup_request = smb2_setup_request,
1245 .setup_async_request = smb2_setup_async_request,
1246 .check_receive = smb2_check_receive,
1247 .add_credits = smb2_add_credits,
1248 .set_credits = smb2_set_credits,
1249 .get_credits_field = smb2_get_credits_field,
1250 .get_credits = smb2_get_credits,
1251 .get_next_mid = smb2_get_next_mid,
1252 .read_data_offset = smb2_read_data_offset,
1253 .read_data_length = smb2_read_data_length,
1254 .map_error = map_smb2_to_linux_error,
1255 .find_mid = smb2_find_mid,
1256 .check_message = smb2_check_message,
1257 .dump_detail = smb2_dump_detail,
1258 .clear_stats = smb2_clear_stats,
1259 .print_stats = smb2_print_stats,
Steve French769ee6a2013-06-19 14:15:30 -05001260 .dump_share_caps = smb2_dump_share_caps,
Steve French38107d42012-12-08 22:08:06 -06001261 .is_oplock_break = smb2_is_valid_oplock_break,
1262 .need_neg = smb2_need_neg,
1263 .negotiate = smb2_negotiate,
1264 .negotiate_wsize = smb2_negotiate_wsize,
1265 .negotiate_rsize = smb2_negotiate_rsize,
1266 .sess_setup = SMB2_sess_setup,
1267 .logoff = SMB2_logoff,
1268 .tree_connect = SMB2_tcon,
1269 .tree_disconnect = SMB2_tdis,
Steven Frenchaf6a12e2013-10-09 20:55:53 -05001270 .qfs_tcon = smb3_qfs_tcon,
Steve French38107d42012-12-08 22:08:06 -06001271 .is_path_accessible = smb2_is_path_accessible,
1272 .can_echo = smb2_can_echo,
1273 .echo = SMB2_echo,
1274 .query_path_info = smb2_query_path_info,
1275 .get_srv_inum = smb2_get_srv_inum,
1276 .query_file_info = smb2_query_file_info,
1277 .set_path_size = smb2_set_path_size,
1278 .set_file_size = smb2_set_file_size,
1279 .set_file_info = smb2_set_file_info,
Steve French64a5cfa2013-10-14 15:31:32 -05001280 .set_compression = smb2_set_compression,
Steve French38107d42012-12-08 22:08:06 -06001281 .mkdir = smb2_mkdir,
1282 .mkdir_setinfo = smb2_mkdir_setinfo,
1283 .rmdir = smb2_rmdir,
1284 .unlink = smb2_unlink,
1285 .rename = smb2_rename_path,
1286 .create_hardlink = smb2_create_hardlink,
Pavel Shilovskyb42bf882013-08-14 19:25:21 +04001287 .query_symlink = smb2_query_symlink,
Steve French38107d42012-12-08 22:08:06 -06001288 .open = smb2_open_file,
1289 .set_fid = smb2_set_fid,
1290 .close = smb2_close_file,
1291 .flush = smb2_flush_file,
1292 .async_readv = smb2_async_readv,
1293 .async_writev = smb2_async_writev,
1294 .sync_read = smb2_sync_read,
1295 .sync_write = smb2_sync_write,
1296 .query_dir_first = smb2_query_dir_first,
1297 .query_dir_next = smb2_query_dir_next,
1298 .close_dir = smb2_close_dir,
1299 .calc_smb_size = smb2_calc_size,
1300 .is_status_pending = smb2_is_status_pending,
1301 .oplock_response = smb2_oplock_response,
1302 .queryfs = smb2_queryfs,
1303 .mand_lock = smb2_mand_lock,
1304 .mand_unlock_range = smb2_unlock_range,
1305 .push_mand_locks = smb2_push_mandatory_locks,
1306 .get_lease_key = smb2_get_lease_key,
1307 .set_lease_key = smb2_set_lease_key,
1308 .new_lease_key = smb2_new_lease_key,
Steve Frenche65a5cb2013-06-27 01:06:50 -05001309 .generate_signingkey = generate_smb3signingkey,
Steve French38107d42012-12-08 22:08:06 -06001310 .calc_signature = smb3_calc_signature,
Pavel Shilovsky53ef1012013-09-05 16:11:28 +04001311 .is_read_op = smb21_is_read_op,
Pavel Shilovsky42873b02013-09-05 21:30:16 +04001312 .set_oplock_level = smb3_set_oplock_level,
Pavel Shilovskyf0473902013-09-04 13:44:05 +04001313 .create_lease_buf = smb3_create_lease_buf,
1314 .parse_lease_buf = smb3_parse_lease_buf,
Steve French41c13582013-11-14 00:05:36 -06001315 .clone_range = smb2_clone_range,
Steve Frenchff1c0382013-11-19 23:44:46 -06001316 .validate_negotiate = smb3_validate_negotiate,
Steve French1080ef72011-02-24 18:07:19 +00001317};
1318
Steve Frenchdd446b12012-11-28 23:21:06 -06001319struct smb_version_values smb20_values = {
1320 .version_string = SMB20_VERSION_STRING,
1321 .protocol_id = SMB20_PROT_ID,
1322 .req_capabilities = 0, /* MBZ */
1323 .large_lock_type = 0,
1324 .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK,
1325 .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK,
1326 .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK,
1327 .header_size = sizeof(struct smb2_hdr),
1328 .max_header_size = MAX_SMB2_HDR_SIZE,
1329 .read_rsp_size = sizeof(struct smb2_read_rsp) - 1,
1330 .lock_cmd = SMB2_LOCK,
1331 .cap_unix = 0,
1332 .cap_nt_find = SMB2_NT_FIND,
1333 .cap_large_files = SMB2_LARGE_FILES,
Jeff Layton50285882013-06-27 12:45:00 -04001334 .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED,
1335 .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED,
Pavel Shilovskya41a28b2013-09-04 13:07:41 +04001336 .create_lease_size = sizeof(struct create_lease),
Steve Frenchdd446b12012-11-28 23:21:06 -06001337};
1338
Steve French1080ef72011-02-24 18:07:19 +00001339struct smb_version_values smb21_values = {
1340 .version_string = SMB21_VERSION_STRING,
Steve Frenche4aa25e2012-10-01 12:26:22 -05001341 .protocol_id = SMB21_PROT_ID,
1342 .req_capabilities = 0, /* MBZ on negotiate req until SMB3 dialect */
1343 .large_lock_type = 0,
1344 .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK,
1345 .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK,
1346 .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK,
1347 .header_size = sizeof(struct smb2_hdr),
1348 .max_header_size = MAX_SMB2_HDR_SIZE,
1349 .read_rsp_size = sizeof(struct smb2_read_rsp) - 1,
1350 .lock_cmd = SMB2_LOCK,
1351 .cap_unix = 0,
1352 .cap_nt_find = SMB2_NT_FIND,
1353 .cap_large_files = SMB2_LARGE_FILES,
Jeff Layton50285882013-06-27 12:45:00 -04001354 .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED,
1355 .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED,
Pavel Shilovskya41a28b2013-09-04 13:07:41 +04001356 .create_lease_size = sizeof(struct create_lease),
Steve Frenche4aa25e2012-10-01 12:26:22 -05001357};
1358
1359struct smb_version_values smb30_values = {
1360 .version_string = SMB30_VERSION_STRING,
1361 .protocol_id = SMB30_PROT_ID,
1362 .req_capabilities = SMB2_GLOBAL_CAP_DFS | SMB2_GLOBAL_CAP_LEASING | SMB2_GLOBAL_CAP_LARGE_MTU,
Pavel Shilovsky027e8ee2012-09-19 06:22:43 -07001363 .large_lock_type = 0,
1364 .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK,
1365 .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK,
1366 .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK,
Pavel Shilovsky093b2bd2011-06-08 15:51:07 +04001367 .header_size = sizeof(struct smb2_hdr),
1368 .max_header_size = MAX_SMB2_HDR_SIZE,
Pavel Shilovsky09a47072012-09-18 16:20:29 -07001369 .read_rsp_size = sizeof(struct smb2_read_rsp) - 1,
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +04001370 .lock_cmd = SMB2_LOCK,
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001371 .cap_unix = 0,
1372 .cap_nt_find = SMB2_NT_FIND,
1373 .cap_large_files = SMB2_LARGE_FILES,
Jeff Layton50285882013-06-27 12:45:00 -04001374 .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED,
1375 .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED,
Pavel Shilovskyf0473902013-09-04 13:44:05 +04001376 .create_lease_size = sizeof(struct create_lease_v2),
Steve French1080ef72011-02-24 18:07:19 +00001377};
Steve French20b6d8b2013-06-12 22:48:41 -05001378
1379struct smb_version_values smb302_values = {
1380 .version_string = SMB302_VERSION_STRING,
1381 .protocol_id = SMB302_PROT_ID,
1382 .req_capabilities = SMB2_GLOBAL_CAP_DFS | SMB2_GLOBAL_CAP_LEASING | SMB2_GLOBAL_CAP_LARGE_MTU,
1383 .large_lock_type = 0,
1384 .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK,
1385 .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK,
1386 .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK,
1387 .header_size = sizeof(struct smb2_hdr),
1388 .max_header_size = MAX_SMB2_HDR_SIZE,
1389 .read_rsp_size = sizeof(struct smb2_read_rsp) - 1,
1390 .lock_cmd = SMB2_LOCK,
1391 .cap_unix = 0,
1392 .cap_nt_find = SMB2_NT_FIND,
1393 .cap_large_files = SMB2_LARGE_FILES,
Jeff Layton50285882013-06-27 12:45:00 -04001394 .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED,
1395 .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED,
Pavel Shilovskyf0473902013-09-04 13:44:05 +04001396 .create_lease_size = sizeof(struct create_lease_v2),
Steve French20b6d8b2013-06-12 22:48:41 -05001397};