blob: 53ccdde6ff187c16084e10dd07372d6516d25139 [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 Frenchf29ebb42014-07-19 21:44:58 -050022#include <linux/falloc.h>
Steve French1080ef72011-02-24 18:07:19 +000023#include "cifsglob.h"
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +040024#include "smb2pdu.h"
25#include "smb2proto.h"
Pavel Shilovsky28ea5292012-05-23 16:18:00 +040026#include "cifsproto.h"
27#include "cifs_debug.h"
Pavel Shilovskyb42bf882013-08-14 19:25:21 +040028#include "cifs_unicode.h"
Pavel Shilovsky2e44b282012-09-18 16:20:33 -070029#include "smb2status.h"
Pavel Shilovsky6fc05c22012-09-18 16:20:34 -070030#include "smb2glob.h"
Pavel Shilovsky28ea5292012-05-23 16:18:00 +040031
32static int
33change_conf(struct TCP_Server_Info *server)
34{
35 server->credits += server->echo_credits + server->oplock_credits;
36 server->oplock_credits = server->echo_credits = 0;
37 switch (server->credits) {
38 case 0:
39 return -1;
40 case 1:
41 server->echoes = false;
42 server->oplocks = false;
Joe Perchesf96637b2013-05-04 22:12:25 -050043 cifs_dbg(VFS, "disabling echoes and oplocks\n");
Pavel Shilovsky28ea5292012-05-23 16:18:00 +040044 break;
45 case 2:
46 server->echoes = true;
47 server->oplocks = false;
48 server->echo_credits = 1;
Joe Perchesf96637b2013-05-04 22:12:25 -050049 cifs_dbg(FYI, "disabling oplocks\n");
Pavel Shilovsky28ea5292012-05-23 16:18:00 +040050 break;
51 default:
52 server->echoes = true;
Steve Frenche0ddde92015-09-22 09:29:38 -050053 if (enable_oplocks) {
54 server->oplocks = true;
55 server->oplock_credits = 1;
56 } else
57 server->oplocks = false;
58
Pavel Shilovsky28ea5292012-05-23 16:18:00 +040059 server->echo_credits = 1;
Pavel Shilovsky28ea5292012-05-23 16:18:00 +040060 }
61 server->credits -= server->echo_credits + server->oplock_credits;
62 return 0;
63}
64
65static void
66smb2_add_credits(struct TCP_Server_Info *server, const unsigned int add,
67 const int optype)
68{
69 int *val, rc = 0;
70 spin_lock(&server->req_lock);
71 val = server->ops->get_credits_field(server, optype);
72 *val += add;
73 server->in_flight--;
Pavel Shilovskyec2e4522011-12-27 16:12:43 +040074 if (server->in_flight == 0 && (optype & CIFS_OP_MASK) != CIFS_NEG_OP)
Pavel Shilovsky28ea5292012-05-23 16:18:00 +040075 rc = change_conf(server);
Pavel Shilovsky983c88a2012-09-18 16:20:33 -070076 /*
77 * Sometimes server returns 0 credits on oplock break ack - we need to
78 * rebalance credits in this case.
79 */
80 else if (server->in_flight > 0 && server->oplock_credits == 0 &&
81 server->oplocks) {
82 if (server->credits > 1) {
83 server->credits--;
84 server->oplock_credits++;
85 }
86 }
Pavel Shilovsky28ea5292012-05-23 16:18:00 +040087 spin_unlock(&server->req_lock);
88 wake_up(&server->request_q);
89 if (rc)
90 cifs_reconnect(server);
91}
92
93static void
94smb2_set_credits(struct TCP_Server_Info *server, const int val)
95{
96 spin_lock(&server->req_lock);
97 server->credits = val;
98 spin_unlock(&server->req_lock);
99}
100
101static int *
102smb2_get_credits_field(struct TCP_Server_Info *server, const int optype)
103{
104 switch (optype) {
105 case CIFS_ECHO_OP:
106 return &server->echo_credits;
107 case CIFS_OBREAK_OP:
108 return &server->oplock_credits;
109 default:
110 return &server->credits;
111 }
112}
113
114static unsigned int
115smb2_get_credits(struct mid_q_entry *mid)
116{
117 return le16_to_cpu(((struct smb2_hdr *)mid->resp_buf)->CreditRequest);
118}
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +0400119
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +0400120static int
121smb2_wait_mtu_credits(struct TCP_Server_Info *server, unsigned int size,
122 unsigned int *num, unsigned int *credits)
123{
124 int rc = 0;
125 unsigned int scredits;
126
127 spin_lock(&server->req_lock);
128 while (1) {
129 if (server->credits <= 0) {
130 spin_unlock(&server->req_lock);
131 cifs_num_waiters_inc(server);
132 rc = wait_event_killable(server->request_q,
133 has_credits(server, &server->credits));
134 cifs_num_waiters_dec(server);
135 if (rc)
136 return rc;
137 spin_lock(&server->req_lock);
138 } else {
139 if (server->tcpStatus == CifsExiting) {
140 spin_unlock(&server->req_lock);
141 return -ENOENT;
142 }
143
144 scredits = server->credits;
145 /* can deadlock with reopen */
146 if (scredits == 1) {
147 *num = SMB2_MAX_BUFFER_SIZE;
148 *credits = 0;
149 break;
150 }
151
152 /* leave one credit for a possible reopen */
153 scredits--;
154 *num = min_t(unsigned int, size,
155 scredits * SMB2_MAX_BUFFER_SIZE);
156
157 *credits = DIV_ROUND_UP(*num, SMB2_MAX_BUFFER_SIZE);
158 server->credits -= *credits;
159 server->in_flight++;
160 break;
161 }
162 }
163 spin_unlock(&server->req_lock);
164 return rc;
165}
166
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +0400167static __u64
168smb2_get_next_mid(struct TCP_Server_Info *server)
169{
170 __u64 mid;
171 /* for SMB2 we need the current value */
172 spin_lock(&GlobalMid_Lock);
173 mid = server->CurrentMid++;
174 spin_unlock(&GlobalMid_Lock);
175 return mid;
176}
Steve French1080ef72011-02-24 18:07:19 +0000177
Pavel Shilovsky093b2bd2011-06-08 15:51:07 +0400178static struct mid_q_entry *
179smb2_find_mid(struct TCP_Server_Info *server, char *buf)
180{
181 struct mid_q_entry *mid;
182 struct smb2_hdr *hdr = (struct smb2_hdr *)buf;
Sachin Prabhu9235d092014-12-09 17:37:00 +0000183 __u64 wire_mid = le64_to_cpu(hdr->MessageId);
Pavel Shilovsky093b2bd2011-06-08 15:51:07 +0400184
185 spin_lock(&GlobalMid_Lock);
186 list_for_each_entry(mid, &server->pending_mid_q, qhead) {
Sachin Prabhu9235d092014-12-09 17:37:00 +0000187 if ((mid->mid == wire_mid) &&
Pavel Shilovsky093b2bd2011-06-08 15:51:07 +0400188 (mid->mid_state == MID_REQUEST_SUBMITTED) &&
189 (mid->command == hdr->Command)) {
190 spin_unlock(&GlobalMid_Lock);
191 return mid;
192 }
193 }
194 spin_unlock(&GlobalMid_Lock);
195 return NULL;
196}
197
198static void
199smb2_dump_detail(void *buf)
200{
201#ifdef CONFIG_CIFS_DEBUG2
202 struct smb2_hdr *smb = (struct smb2_hdr *)buf;
203
Joe Perchesf96637b2013-05-04 22:12:25 -0500204 cifs_dbg(VFS, "Cmd: %d Err: 0x%x Flags: 0x%x Mid: %llu Pid: %d\n",
205 smb->Command, smb->Status, smb->Flags, smb->MessageId,
206 smb->ProcessId);
207 cifs_dbg(VFS, "smb buf %p len %u\n", smb, smb2_calc_size(smb));
Pavel Shilovsky093b2bd2011-06-08 15:51:07 +0400208#endif
209}
210
Pavel Shilovskyec2e4522011-12-27 16:12:43 +0400211static bool
212smb2_need_neg(struct TCP_Server_Info *server)
213{
214 return server->max_read == 0;
215}
216
217static int
218smb2_negotiate(const unsigned int xid, struct cifs_ses *ses)
219{
220 int rc;
221 ses->server->CurrentMid = 0;
222 rc = SMB2_negotiate(xid, ses);
223 /* BB we probably don't need to retry with modern servers */
224 if (rc == -EAGAIN)
225 rc = -EHOSTDOWN;
226 return rc;
227}
228
Pavel Shilovsky3a3bab52012-09-18 16:20:28 -0700229static unsigned int
230smb2_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *volume_info)
231{
232 struct TCP_Server_Info *server = tcon->ses->server;
233 unsigned int wsize;
234
235 /* start with specified wsize, or default */
236 wsize = volume_info->wsize ? volume_info->wsize : CIFS_DEFAULT_IOSIZE;
237 wsize = min_t(unsigned int, wsize, server->max_write);
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +0400238
239 if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))
240 wsize = min_t(unsigned int, wsize, SMB2_MAX_BUFFER_SIZE);
Pavel Shilovsky3a3bab52012-09-18 16:20:28 -0700241
Pavel Shilovsky3a3bab52012-09-18 16:20:28 -0700242 return wsize;
243}
244
245static unsigned int
246smb2_negotiate_rsize(struct cifs_tcon *tcon, struct smb_vol *volume_info)
247{
248 struct TCP_Server_Info *server = tcon->ses->server;
249 unsigned int rsize;
250
251 /* start with specified rsize, or default */
252 rsize = volume_info->rsize ? volume_info->rsize : CIFS_DEFAULT_IOSIZE;
253 rsize = min_t(unsigned int, rsize, server->max_read);
Pavel Shilovskybed9da02014-06-25 11:28:57 +0400254
255 if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))
256 rsize = min_t(unsigned int, rsize, SMB2_MAX_BUFFER_SIZE);
Pavel Shilovsky3a3bab52012-09-18 16:20:28 -0700257
Pavel Shilovsky3a3bab52012-09-18 16:20:28 -0700258 return rsize;
259}
260
Steve Frenchc481e9f2013-10-14 01:21:53 -0500261#ifdef CONFIG_CIFS_STATS2
262static int
263SMB3_request_interfaces(const unsigned int xid, struct cifs_tcon *tcon)
264{
265 int rc;
266 unsigned int ret_data_len = 0;
267 struct network_interface_info_ioctl_rsp *out_buf;
268
269 rc = SMB2_ioctl(xid, tcon, NO_FILE_ID, NO_FILE_ID,
270 FSCTL_QUERY_NETWORK_INTERFACE_INFO, true /* is_fsctl */,
271 NULL /* no data input */, 0 /* no data input */,
272 (char **)&out_buf, &ret_data_len);
Steve French9ffc5412014-10-16 15:13:14 -0500273 if (rc != 0)
274 cifs_dbg(VFS, "error %d on ioctl to get interface list\n", rc);
275 else if (ret_data_len < sizeof(struct network_interface_info_ioctl_rsp)) {
276 cifs_dbg(VFS, "server returned bad net interface info buf\n");
277 rc = -EINVAL;
278 } else {
Steve Frenchc481e9f2013-10-14 01:21:53 -0500279 /* Dump info on first interface */
280 cifs_dbg(FYI, "Adapter Capability 0x%x\t",
281 le32_to_cpu(out_buf->Capability));
282 cifs_dbg(FYI, "Link Speed %lld\n",
283 le64_to_cpu(out_buf->LinkSpeed));
Steve French9ffc5412014-10-16 15:13:14 -0500284 }
Steve Frenchc481e9f2013-10-14 01:21:53 -0500285
286 return rc;
287}
288#endif /* STATS2 */
289
Steve French34f62642013-10-09 02:07:00 -0500290static void
Steven Frenchaf6a12e2013-10-09 20:55:53 -0500291smb3_qfs_tcon(const unsigned int xid, struct cifs_tcon *tcon)
292{
293 int rc;
294 __le16 srch_path = 0; /* Null - open root of share */
295 u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
296 struct cifs_open_parms oparms;
297 struct cifs_fid fid;
298
299 oparms.tcon = tcon;
300 oparms.desired_access = FILE_READ_ATTRIBUTES;
301 oparms.disposition = FILE_OPEN;
302 oparms.create_options = 0;
303 oparms.fid = &fid;
304 oparms.reconnect = false;
305
306 rc = SMB2_open(xid, &oparms, &srch_path, &oplock, NULL, NULL);
307 if (rc)
308 return;
309
Steve Frenchc481e9f2013-10-14 01:21:53 -0500310#ifdef CONFIG_CIFS_STATS2
311 SMB3_request_interfaces(xid, tcon);
312#endif /* STATS2 */
313
Steven Frenchaf6a12e2013-10-09 20:55:53 -0500314 SMB2_QFS_attr(xid, tcon, fid.persistent_fid, fid.volatile_fid,
315 FS_ATTRIBUTE_INFORMATION);
316 SMB2_QFS_attr(xid, tcon, fid.persistent_fid, fid.volatile_fid,
317 FS_DEVICE_INFORMATION);
318 SMB2_QFS_attr(xid, tcon, fid.persistent_fid, fid.volatile_fid,
319 FS_SECTOR_SIZE_INFORMATION); /* SMB3 specific */
320 SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
321 return;
322}
323
324static void
Steve French34f62642013-10-09 02:07:00 -0500325smb2_qfs_tcon(const unsigned int xid, struct cifs_tcon *tcon)
326{
327 int rc;
328 __le16 srch_path = 0; /* Null - open root of share */
329 u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
330 struct cifs_open_parms oparms;
331 struct cifs_fid fid;
332
333 oparms.tcon = tcon;
334 oparms.desired_access = FILE_READ_ATTRIBUTES;
335 oparms.disposition = FILE_OPEN;
336 oparms.create_options = 0;
337 oparms.fid = &fid;
338 oparms.reconnect = false;
339
340 rc = SMB2_open(xid, &oparms, &srch_path, &oplock, NULL, NULL);
341 if (rc)
342 return;
343
Steven French21671142013-10-09 13:36:35 -0500344 SMB2_QFS_attr(xid, tcon, fid.persistent_fid, fid.volatile_fid,
345 FS_ATTRIBUTE_INFORMATION);
346 SMB2_QFS_attr(xid, tcon, fid.persistent_fid, fid.volatile_fid,
347 FS_DEVICE_INFORMATION);
Steve French34f62642013-10-09 02:07:00 -0500348 SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
349 return;
350}
351
Pavel Shilovsky2503a0d2011-12-26 22:58:46 +0400352static int
353smb2_is_path_accessible(const unsigned int xid, struct cifs_tcon *tcon,
354 struct cifs_sb_info *cifs_sb, const char *full_path)
355{
356 int rc;
Pavel Shilovsky2503a0d2011-12-26 22:58:46 +0400357 __le16 *utf16_path;
Pavel Shilovsky2e44b282012-09-18 16:20:33 -0700358 __u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
Pavel Shilovsky064f6042013-07-09 18:20:30 +0400359 struct cifs_open_parms oparms;
360 struct cifs_fid fid;
Pavel Shilovsky2503a0d2011-12-26 22:58:46 +0400361
362 utf16_path = cifs_convert_path_to_utf16(full_path, cifs_sb);
363 if (!utf16_path)
364 return -ENOMEM;
365
Pavel Shilovsky064f6042013-07-09 18:20:30 +0400366 oparms.tcon = tcon;
367 oparms.desired_access = FILE_READ_ATTRIBUTES;
368 oparms.disposition = FILE_OPEN;
369 oparms.create_options = 0;
370 oparms.fid = &fid;
Pavel Shilovsky9cbc0b72013-07-09 18:40:58 +0400371 oparms.reconnect = false;
Pavel Shilovsky064f6042013-07-09 18:20:30 +0400372
Pavel Shilovskyb42bf882013-08-14 19:25:21 +0400373 rc = SMB2_open(xid, &oparms, utf16_path, &oplock, NULL, NULL);
Pavel Shilovsky2503a0d2011-12-26 22:58:46 +0400374 if (rc) {
375 kfree(utf16_path);
376 return rc;
377 }
378
Pavel Shilovsky064f6042013-07-09 18:20:30 +0400379 rc = SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
Pavel Shilovsky2503a0d2011-12-26 22:58:46 +0400380 kfree(utf16_path);
381 return rc;
382}
383
Pavel Shilovskybe4cb9e2011-12-29 17:06:33 +0400384static int
385smb2_get_srv_inum(const unsigned int xid, struct cifs_tcon *tcon,
386 struct cifs_sb_info *cifs_sb, const char *full_path,
387 u64 *uniqueid, FILE_ALL_INFO *data)
388{
389 *uniqueid = le64_to_cpu(data->IndexNumber);
390 return 0;
391}
392
Pavel Shilovskyb7546bc2012-09-18 16:20:27 -0700393static int
394smb2_query_file_info(const unsigned int xid, struct cifs_tcon *tcon,
395 struct cifs_fid *fid, FILE_ALL_INFO *data)
396{
397 int rc;
398 struct smb2_file_all_info *smb2_data;
399
Pavel Shilovsky1bbe4992014-08-22 13:32:11 +0400400 smb2_data = kzalloc(sizeof(struct smb2_file_all_info) + PATH_MAX * 2,
Pavel Shilovskyb7546bc2012-09-18 16:20:27 -0700401 GFP_KERNEL);
402 if (smb2_data == NULL)
403 return -ENOMEM;
404
405 rc = SMB2_query_info(xid, tcon, fid->persistent_fid, fid->volatile_fid,
406 smb2_data);
407 if (!rc)
408 move_smb2_info_to_cifs(data, smb2_data);
409 kfree(smb2_data);
410 return rc;
411}
412
Pavel Shilovsky9094fad2012-07-12 18:30:44 +0400413static bool
414smb2_can_echo(struct TCP_Server_Info *server)
415{
416 return server->echoes;
417}
418
Pavel Shilovskyd60622e2012-05-28 15:19:39 +0400419static void
420smb2_clear_stats(struct cifs_tcon *tcon)
421{
422#ifdef CONFIG_CIFS_STATS
423 int i;
424 for (i = 0; i < NUMBER_OF_SMB2_COMMANDS; i++) {
425 atomic_set(&tcon->stats.smb2_stats.smb2_com_sent[i], 0);
426 atomic_set(&tcon->stats.smb2_stats.smb2_com_failed[i], 0);
427 }
428#endif
429}
430
431static void
Steve French769ee6a2013-06-19 14:15:30 -0500432smb2_dump_share_caps(struct seq_file *m, struct cifs_tcon *tcon)
433{
434 seq_puts(m, "\n\tShare Capabilities:");
435 if (tcon->capabilities & SMB2_SHARE_CAP_DFS)
436 seq_puts(m, " DFS,");
437 if (tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
438 seq_puts(m, " CONTINUOUS AVAILABILITY,");
439 if (tcon->capabilities & SMB2_SHARE_CAP_SCALEOUT)
440 seq_puts(m, " SCALEOUT,");
441 if (tcon->capabilities & SMB2_SHARE_CAP_CLUSTER)
442 seq_puts(m, " CLUSTER,");
443 if (tcon->capabilities & SMB2_SHARE_CAP_ASYMMETRIC)
444 seq_puts(m, " ASYMMETRIC,");
445 if (tcon->capabilities == 0)
446 seq_puts(m, " None");
Steven Frenchaf6a12e2013-10-09 20:55:53 -0500447 if (tcon->ss_flags & SSINFO_FLAGS_ALIGNED_DEVICE)
448 seq_puts(m, " Aligned,");
449 if (tcon->ss_flags & SSINFO_FLAGS_PARTITION_ALIGNED_ON_DEVICE)
450 seq_puts(m, " Partition Aligned,");
451 if (tcon->ss_flags & SSINFO_FLAGS_NO_SEEK_PENALTY)
452 seq_puts(m, " SSD,");
453 if (tcon->ss_flags & SSINFO_FLAGS_TRIM_ENABLED)
454 seq_puts(m, " TRIM-support,");
455
Steve French769ee6a2013-06-19 14:15:30 -0500456 seq_printf(m, "\tShare Flags: 0x%x", tcon->share_flags);
Steven Frenchaf6a12e2013-10-09 20:55:53 -0500457 if (tcon->perf_sector_size)
458 seq_printf(m, "\tOptimal sector size: 0x%x",
459 tcon->perf_sector_size);
Steve French769ee6a2013-06-19 14:15:30 -0500460}
461
462static void
Pavel Shilovskyd60622e2012-05-28 15:19:39 +0400463smb2_print_stats(struct seq_file *m, struct cifs_tcon *tcon)
464{
465#ifdef CONFIG_CIFS_STATS
466 atomic_t *sent = tcon->stats.smb2_stats.smb2_com_sent;
467 atomic_t *failed = tcon->stats.smb2_stats.smb2_com_failed;
468 seq_printf(m, "\nNegotiates: %d sent %d failed",
469 atomic_read(&sent[SMB2_NEGOTIATE_HE]),
470 atomic_read(&failed[SMB2_NEGOTIATE_HE]));
471 seq_printf(m, "\nSessionSetups: %d sent %d failed",
472 atomic_read(&sent[SMB2_SESSION_SETUP_HE]),
473 atomic_read(&failed[SMB2_SESSION_SETUP_HE]));
Pavel Shilovskyd60622e2012-05-28 15:19:39 +0400474 seq_printf(m, "\nLogoffs: %d sent %d failed",
475 atomic_read(&sent[SMB2_LOGOFF_HE]),
476 atomic_read(&failed[SMB2_LOGOFF_HE]));
477 seq_printf(m, "\nTreeConnects: %d sent %d failed",
478 atomic_read(&sent[SMB2_TREE_CONNECT_HE]),
479 atomic_read(&failed[SMB2_TREE_CONNECT_HE]));
480 seq_printf(m, "\nTreeDisconnects: %d sent %d failed",
481 atomic_read(&sent[SMB2_TREE_DISCONNECT_HE]),
482 atomic_read(&failed[SMB2_TREE_DISCONNECT_HE]));
483 seq_printf(m, "\nCreates: %d sent %d failed",
484 atomic_read(&sent[SMB2_CREATE_HE]),
485 atomic_read(&failed[SMB2_CREATE_HE]));
486 seq_printf(m, "\nCloses: %d sent %d failed",
487 atomic_read(&sent[SMB2_CLOSE_HE]),
488 atomic_read(&failed[SMB2_CLOSE_HE]));
489 seq_printf(m, "\nFlushes: %d sent %d failed",
490 atomic_read(&sent[SMB2_FLUSH_HE]),
491 atomic_read(&failed[SMB2_FLUSH_HE]));
492 seq_printf(m, "\nReads: %d sent %d failed",
493 atomic_read(&sent[SMB2_READ_HE]),
494 atomic_read(&failed[SMB2_READ_HE]));
495 seq_printf(m, "\nWrites: %d sent %d failed",
496 atomic_read(&sent[SMB2_WRITE_HE]),
497 atomic_read(&failed[SMB2_WRITE_HE]));
498 seq_printf(m, "\nLocks: %d sent %d failed",
499 atomic_read(&sent[SMB2_LOCK_HE]),
500 atomic_read(&failed[SMB2_LOCK_HE]));
501 seq_printf(m, "\nIOCTLs: %d sent %d failed",
502 atomic_read(&sent[SMB2_IOCTL_HE]),
503 atomic_read(&failed[SMB2_IOCTL_HE]));
504 seq_printf(m, "\nCancels: %d sent %d failed",
505 atomic_read(&sent[SMB2_CANCEL_HE]),
506 atomic_read(&failed[SMB2_CANCEL_HE]));
507 seq_printf(m, "\nEchos: %d sent %d failed",
508 atomic_read(&sent[SMB2_ECHO_HE]),
509 atomic_read(&failed[SMB2_ECHO_HE]));
510 seq_printf(m, "\nQueryDirectories: %d sent %d failed",
511 atomic_read(&sent[SMB2_QUERY_DIRECTORY_HE]),
512 atomic_read(&failed[SMB2_QUERY_DIRECTORY_HE]));
513 seq_printf(m, "\nChangeNotifies: %d sent %d failed",
514 atomic_read(&sent[SMB2_CHANGE_NOTIFY_HE]),
515 atomic_read(&failed[SMB2_CHANGE_NOTIFY_HE]));
516 seq_printf(m, "\nQueryInfos: %d sent %d failed",
517 atomic_read(&sent[SMB2_QUERY_INFO_HE]),
518 atomic_read(&failed[SMB2_QUERY_INFO_HE]));
519 seq_printf(m, "\nSetInfos: %d sent %d failed",
520 atomic_read(&sent[SMB2_SET_INFO_HE]),
521 atomic_read(&failed[SMB2_SET_INFO_HE]));
522 seq_printf(m, "\nOplockBreaks: %d sent %d failed",
523 atomic_read(&sent[SMB2_OPLOCK_BREAK_HE]),
524 atomic_read(&failed[SMB2_OPLOCK_BREAK_HE]));
525#endif
526}
527
Pavel Shilovskyf0df7372012-09-18 16:20:26 -0700528static void
529smb2_set_fid(struct cifsFileInfo *cfile, struct cifs_fid *fid, __u32 oplock)
530{
David Howells2b0143b2015-03-17 22:25:59 +0000531 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
Pavel Shilovsky53ef1012013-09-05 16:11:28 +0400532 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
533
Pavel Shilovskyf0df7372012-09-18 16:20:26 -0700534 cfile->fid.persistent_fid = fid->persistent_fid;
535 cfile->fid.volatile_fid = fid->volatile_fid;
Pavel Shilovsky42873b02013-09-05 21:30:16 +0400536 server->ops->set_oplock_level(cinode, oplock, fid->epoch,
537 &fid->purge_cache);
Pavel Shilovsky18cceb62013-09-05 13:01:06 +0400538 cinode->can_cache_brlcks = CIFS_CACHE_WRITE(cinode);
Pavel Shilovskyf0df7372012-09-18 16:20:26 -0700539}
540
Pavel Shilovsky760ad0c2012-09-25 11:00:07 +0400541static void
Pavel Shilovskyf0df7372012-09-18 16:20:26 -0700542smb2_close_file(const unsigned int xid, struct cifs_tcon *tcon,
543 struct cifs_fid *fid)
544{
Pavel Shilovsky760ad0c2012-09-25 11:00:07 +0400545 SMB2_close(xid, tcon, fid->persistent_fid, fid->volatile_fid);
Pavel Shilovskyf0df7372012-09-18 16:20:26 -0700546}
547
Pavel Shilovsky7a5cfb12012-09-18 16:20:28 -0700548static int
Steve French41c13582013-11-14 00:05:36 -0600549SMB2_request_res_key(const unsigned int xid, struct cifs_tcon *tcon,
550 u64 persistent_fid, u64 volatile_fid,
551 struct copychunk_ioctl *pcchunk)
552{
553 int rc;
554 unsigned int ret_data_len;
555 struct resume_key_req *res_key;
556
557 rc = SMB2_ioctl(xid, tcon, persistent_fid, volatile_fid,
558 FSCTL_SRV_REQUEST_RESUME_KEY, true /* is_fsctl */,
559 NULL, 0 /* no input */,
560 (char **)&res_key, &ret_data_len);
561
562 if (rc) {
563 cifs_dbg(VFS, "refcpy ioctl error %d getting resume key\n", rc);
564 goto req_res_key_exit;
565 }
566 if (ret_data_len < sizeof(struct resume_key_req)) {
567 cifs_dbg(VFS, "Invalid refcopy resume key length\n");
568 rc = -EINVAL;
569 goto req_res_key_exit;
570 }
571 memcpy(pcchunk->SourceKey, res_key->ResumeKey, COPY_CHUNK_RES_KEY_SIZE);
572
573req_res_key_exit:
574 kfree(res_key);
575 return rc;
576}
577
578static int
579smb2_clone_range(const unsigned int xid,
580 struct cifsFileInfo *srcfile,
581 struct cifsFileInfo *trgtfile, u64 src_off,
582 u64 len, u64 dest_off)
583{
584 int rc;
585 unsigned int ret_data_len;
586 struct copychunk_ioctl *pcchunk;
Steve French9bf0c9c2013-11-16 18:05:28 -0600587 struct copychunk_ioctl_rsp *retbuf = NULL;
588 struct cifs_tcon *tcon;
589 int chunks_copied = 0;
590 bool chunk_sizes_updated = false;
Steve French41c13582013-11-14 00:05:36 -0600591
592 pcchunk = kmalloc(sizeof(struct copychunk_ioctl), GFP_KERNEL);
593
594 if (pcchunk == NULL)
595 return -ENOMEM;
596
597 cifs_dbg(FYI, "in smb2_clone_range - about to call request res key\n");
598 /* Request a key from the server to identify the source of the copy */
599 rc = SMB2_request_res_key(xid, tlink_tcon(srcfile->tlink),
600 srcfile->fid.persistent_fid,
601 srcfile->fid.volatile_fid, pcchunk);
602
603 /* Note: request_res_key sets res_key null only if rc !=0 */
604 if (rc)
Steve French9bf0c9c2013-11-16 18:05:28 -0600605 goto cchunk_out;
Steve French41c13582013-11-14 00:05:36 -0600606
607 /* For now array only one chunk long, will make more flexible later */
Fabian Frederickbc09d142014-12-10 15:41:15 -0800608 pcchunk->ChunkCount = cpu_to_le32(1);
Steve French41c13582013-11-14 00:05:36 -0600609 pcchunk->Reserved = 0;
Steve French41c13582013-11-14 00:05:36 -0600610 pcchunk->Reserved2 = 0;
611
Steve French9bf0c9c2013-11-16 18:05:28 -0600612 tcon = tlink_tcon(trgtfile->tlink);
613
614 while (len > 0) {
615 pcchunk->SourceOffset = cpu_to_le64(src_off);
616 pcchunk->TargetOffset = cpu_to_le64(dest_off);
617 pcchunk->Length =
618 cpu_to_le32(min_t(u32, len, tcon->max_bytes_chunk));
619
620 /* Request server copy to target from src identified by key */
621 rc = SMB2_ioctl(xid, tcon, trgtfile->fid.persistent_fid,
Steve French41c13582013-11-14 00:05:36 -0600622 trgtfile->fid.volatile_fid, FSCTL_SRV_COPYCHUNK_WRITE,
623 true /* is_fsctl */, (char *)pcchunk,
Steve French9bf0c9c2013-11-16 18:05:28 -0600624 sizeof(struct copychunk_ioctl), (char **)&retbuf,
625 &ret_data_len);
626 if (rc == 0) {
627 if (ret_data_len !=
628 sizeof(struct copychunk_ioctl_rsp)) {
629 cifs_dbg(VFS, "invalid cchunk response size\n");
630 rc = -EIO;
631 goto cchunk_out;
632 }
633 if (retbuf->TotalBytesWritten == 0) {
634 cifs_dbg(FYI, "no bytes copied\n");
635 rc = -EIO;
636 goto cchunk_out;
637 }
638 /*
639 * Check if server claimed to write more than we asked
640 */
641 if (le32_to_cpu(retbuf->TotalBytesWritten) >
642 le32_to_cpu(pcchunk->Length)) {
643 cifs_dbg(VFS, "invalid copy chunk response\n");
644 rc = -EIO;
645 goto cchunk_out;
646 }
647 if (le32_to_cpu(retbuf->ChunksWritten) != 1) {
648 cifs_dbg(VFS, "invalid num chunks written\n");
649 rc = -EIO;
650 goto cchunk_out;
651 }
652 chunks_copied++;
Steve French41c13582013-11-14 00:05:36 -0600653
Steve French9bf0c9c2013-11-16 18:05:28 -0600654 src_off += le32_to_cpu(retbuf->TotalBytesWritten);
655 dest_off += le32_to_cpu(retbuf->TotalBytesWritten);
656 len -= le32_to_cpu(retbuf->TotalBytesWritten);
Steve French41c13582013-11-14 00:05:36 -0600657
Steve French9bf0c9c2013-11-16 18:05:28 -0600658 cifs_dbg(FYI, "Chunks %d PartialChunk %d Total %d\n",
659 le32_to_cpu(retbuf->ChunksWritten),
660 le32_to_cpu(retbuf->ChunkBytesWritten),
661 le32_to_cpu(retbuf->TotalBytesWritten));
662 } else if (rc == -EINVAL) {
663 if (ret_data_len != sizeof(struct copychunk_ioctl_rsp))
664 goto cchunk_out;
Steve French41c13582013-11-14 00:05:36 -0600665
Steve French9bf0c9c2013-11-16 18:05:28 -0600666 cifs_dbg(FYI, "MaxChunks %d BytesChunk %d MaxCopy %d\n",
667 le32_to_cpu(retbuf->ChunksWritten),
668 le32_to_cpu(retbuf->ChunkBytesWritten),
669 le32_to_cpu(retbuf->TotalBytesWritten));
670
671 /*
672 * Check if this is the first request using these sizes,
673 * (ie check if copy succeed once with original sizes
674 * and check if the server gave us different sizes after
675 * we already updated max sizes on previous request).
676 * if not then why is the server returning an error now
677 */
678 if ((chunks_copied != 0) || chunk_sizes_updated)
679 goto cchunk_out;
680
681 /* Check that server is not asking us to grow size */
682 if (le32_to_cpu(retbuf->ChunkBytesWritten) <
683 tcon->max_bytes_chunk)
684 tcon->max_bytes_chunk =
685 le32_to_cpu(retbuf->ChunkBytesWritten);
686 else
687 goto cchunk_out; /* server gave us bogus size */
688
689 /* No need to change MaxChunks since already set to 1 */
690 chunk_sizes_updated = true;
Sachin Prabhu2477bc52015-02-04 13:10:26 +0000691 } else
692 goto cchunk_out;
Steve French9bf0c9c2013-11-16 18:05:28 -0600693 }
694
695cchunk_out:
Steve French41c13582013-11-14 00:05:36 -0600696 kfree(pcchunk);
697 return rc;
698}
699
700static int
Pavel Shilovsky7a5cfb12012-09-18 16:20:28 -0700701smb2_flush_file(const unsigned int xid, struct cifs_tcon *tcon,
702 struct cifs_fid *fid)
703{
704 return SMB2_flush(xid, tcon, fid->persistent_fid, fid->volatile_fid);
705}
706
Pavel Shilovsky09a47072012-09-18 16:20:29 -0700707static unsigned int
708smb2_read_data_offset(char *buf)
709{
710 struct smb2_read_rsp *rsp = (struct smb2_read_rsp *)buf;
711 return rsp->DataOffset;
712}
713
714static unsigned int
715smb2_read_data_length(char *buf)
716{
717 struct smb2_read_rsp *rsp = (struct smb2_read_rsp *)buf;
718 return le32_to_cpu(rsp->DataLength);
719}
720
Pavel Shilovskyd8e05032012-09-18 16:20:30 -0700721
722static int
Steve Frenchdb8b6312014-09-22 05:13:55 -0500723smb2_sync_read(const unsigned int xid, struct cifs_fid *pfid,
Pavel Shilovskyd8e05032012-09-18 16:20:30 -0700724 struct cifs_io_parms *parms, unsigned int *bytes_read,
725 char **buf, int *buf_type)
726{
Steve Frenchdb8b6312014-09-22 05:13:55 -0500727 parms->persistent_fid = pfid->persistent_fid;
728 parms->volatile_fid = pfid->volatile_fid;
Pavel Shilovskyd8e05032012-09-18 16:20:30 -0700729 return SMB2_read(xid, parms, bytes_read, buf, buf_type);
730}
731
Pavel Shilovsky009d3442012-09-18 16:20:30 -0700732static int
Steve Frenchdb8b6312014-09-22 05:13:55 -0500733smb2_sync_write(const unsigned int xid, struct cifs_fid *pfid,
Pavel Shilovsky009d3442012-09-18 16:20:30 -0700734 struct cifs_io_parms *parms, unsigned int *written,
735 struct kvec *iov, unsigned long nr_segs)
736{
737
Steve Frenchdb8b6312014-09-22 05:13:55 -0500738 parms->persistent_fid = pfid->persistent_fid;
739 parms->volatile_fid = pfid->volatile_fid;
Pavel Shilovsky009d3442012-09-18 16:20:30 -0700740 return SMB2_write(xid, parms, written, iov, nr_segs);
741}
742
Steve Frenchd43cc792014-08-13 17:16:29 -0500743/* Set or clear the SPARSE_FILE attribute based on value passed in setsparse */
744static bool smb2_set_sparse(const unsigned int xid, struct cifs_tcon *tcon,
745 struct cifsFileInfo *cfile, struct inode *inode, __u8 setsparse)
746{
747 struct cifsInodeInfo *cifsi;
748 int rc;
749
750 cifsi = CIFS_I(inode);
751
752 /* if file already sparse don't bother setting sparse again */
753 if ((cifsi->cifsAttrs & FILE_ATTRIBUTE_SPARSE_FILE) && setsparse)
754 return true; /* already sparse */
755
756 if (!(cifsi->cifsAttrs & FILE_ATTRIBUTE_SPARSE_FILE) && !setsparse)
757 return true; /* already not sparse */
758
759 /*
760 * Can't check for sparse support on share the usual way via the
761 * FS attribute info (FILE_SUPPORTS_SPARSE_FILES) on the share
762 * since Samba server doesn't set the flag on the share, yet
763 * supports the set sparse FSCTL and returns sparse correctly
764 * in the file attributes. If we fail setting sparse though we
765 * mark that server does not support sparse files for this share
766 * to avoid repeatedly sending the unsupported fsctl to server
767 * if the file is repeatedly extended.
768 */
769 if (tcon->broken_sparse_sup)
770 return false;
771
772 rc = SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid,
773 cfile->fid.volatile_fid, FSCTL_SET_SPARSE,
774 true /* is_fctl */, &setsparse, 1, NULL, NULL);
775 if (rc) {
776 tcon->broken_sparse_sup = true;
777 cifs_dbg(FYI, "set sparse rc = %d\n", rc);
778 return false;
779 }
780
781 if (setsparse)
782 cifsi->cifsAttrs |= FILE_ATTRIBUTE_SPARSE_FILE;
783 else
784 cifsi->cifsAttrs &= (~FILE_ATTRIBUTE_SPARSE_FILE);
785
786 return true;
787}
788
Pavel Shilovskyc839ff22012-09-18 16:20:32 -0700789static int
790smb2_set_file_size(const unsigned int xid, struct cifs_tcon *tcon,
791 struct cifsFileInfo *cfile, __u64 size, bool set_alloc)
792{
793 __le64 eof = cpu_to_le64(size);
Steve French3d1a3742014-08-11 21:05:25 -0500794 struct inode *inode;
795
796 /*
797 * If extending file more than one page make sparse. Many Linux fs
798 * make files sparse by default when extending via ftruncate
799 */
David Howells2b0143b2015-03-17 22:25:59 +0000800 inode = d_inode(cfile->dentry);
Steve French3d1a3742014-08-11 21:05:25 -0500801
802 if (!set_alloc && (size > inode->i_size + 8192)) {
Steve French3d1a3742014-08-11 21:05:25 -0500803 __u8 set_sparse = 1;
Steve French3d1a3742014-08-11 21:05:25 -0500804
Steve Frenchd43cc792014-08-13 17:16:29 -0500805 /* whether set sparse succeeds or not, extend the file */
806 smb2_set_sparse(xid, tcon, cfile, inode, set_sparse);
Steve French3d1a3742014-08-11 21:05:25 -0500807 }
808
Pavel Shilovskyc839ff22012-09-18 16:20:32 -0700809 return SMB2_set_eof(xid, tcon, cfile->fid.persistent_fid,
Steve Frenchf29ebb42014-07-19 21:44:58 -0500810 cfile->fid.volatile_fid, cfile->pid, &eof, false);
Pavel Shilovskyc839ff22012-09-18 16:20:32 -0700811}
812
Steve French02b16662015-06-27 21:18:36 -0700813static int
814smb2_duplicate_extents(const unsigned int xid,
815 struct cifsFileInfo *srcfile,
816 struct cifsFileInfo *trgtfile, u64 src_off,
817 u64 len, u64 dest_off)
818{
819 int rc;
820 unsigned int ret_data_len;
821 char *retbuf = NULL;
822 struct duplicate_extents_to_file dup_ext_buf;
823 struct cifs_tcon *tcon = tlink_tcon(trgtfile->tlink);
824
825 /* server fileays advertise duplicate extent support with this flag */
826 if ((le32_to_cpu(tcon->fsAttrInfo.Attributes) &
827 FILE_SUPPORTS_BLOCK_REFCOUNTING) == 0)
828 return -EOPNOTSUPP;
829
830 dup_ext_buf.VolatileFileHandle = srcfile->fid.volatile_fid;
831 dup_ext_buf.PersistentFileHandle = srcfile->fid.persistent_fid;
832 dup_ext_buf.SourceFileOffset = cpu_to_le64(src_off);
833 dup_ext_buf.TargetFileOffset = cpu_to_le64(dest_off);
834 dup_ext_buf.ByteCount = cpu_to_le64(len);
835 cifs_dbg(FYI, "duplicate extents: src off %lld dst off %lld len %lld",
836 src_off, dest_off, len);
837
838 rc = smb2_set_file_size(xid, tcon, trgtfile, dest_off + len, false);
839 if (rc)
840 goto duplicate_extents_out;
841
842 rc = SMB2_ioctl(xid, tcon, trgtfile->fid.persistent_fid,
843 trgtfile->fid.volatile_fid,
844 FSCTL_DUPLICATE_EXTENTS_TO_FILE,
845 true /* is_fsctl */, (char *)&dup_ext_buf,
846 sizeof(struct duplicate_extents_to_file),
847 (char **)&retbuf,
848 &ret_data_len);
849
850 if (ret_data_len > 0)
851 cifs_dbg(FYI, "non-zero response length in duplicate extents");
852
853duplicate_extents_out:
854 return rc;
855}
Steve French02b16662015-06-27 21:18:36 -0700856
Pavel Shilovskyd324f08d2012-09-18 16:20:33 -0700857static int
Steve French64a5cfa2013-10-14 15:31:32 -0500858smb2_set_compression(const unsigned int xid, struct cifs_tcon *tcon,
859 struct cifsFileInfo *cfile)
860{
861 return SMB2_set_compression(xid, tcon, cfile->fid.persistent_fid,
862 cfile->fid.volatile_fid);
863}
864
865static int
Steve Frenchb3152e22015-06-24 03:17:02 -0500866smb3_set_integrity(const unsigned int xid, struct cifs_tcon *tcon,
867 struct cifsFileInfo *cfile)
868{
869 struct fsctl_set_integrity_information_req integr_info;
870 char *retbuf = NULL;
871 unsigned int ret_data_len;
872
873 integr_info.ChecksumAlgorithm = cpu_to_le16(CHECKSUM_TYPE_UNCHANGED);
874 integr_info.Flags = 0;
875 integr_info.Reserved = 0;
876
877 return SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid,
878 cfile->fid.volatile_fid,
879 FSCTL_SET_INTEGRITY_INFORMATION,
880 true /* is_fsctl */, (char *)&integr_info,
881 sizeof(struct fsctl_set_integrity_information_req),
882 (char **)&retbuf,
883 &ret_data_len);
884
885}
886
887static int
Pavel Shilovskyd324f08d2012-09-18 16:20:33 -0700888smb2_query_dir_first(const unsigned int xid, struct cifs_tcon *tcon,
889 const char *path, struct cifs_sb_info *cifs_sb,
890 struct cifs_fid *fid, __u16 search_flags,
891 struct cifs_search_info *srch_inf)
892{
893 __le16 *utf16_path;
894 int rc;
Pavel Shilovsky2e44b282012-09-18 16:20:33 -0700895 __u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
Pavel Shilovsky064f6042013-07-09 18:20:30 +0400896 struct cifs_open_parms oparms;
Pavel Shilovskyd324f08d2012-09-18 16:20:33 -0700897
898 utf16_path = cifs_convert_path_to_utf16(path, cifs_sb);
899 if (!utf16_path)
900 return -ENOMEM;
901
Pavel Shilovsky064f6042013-07-09 18:20:30 +0400902 oparms.tcon = tcon;
903 oparms.desired_access = FILE_READ_ATTRIBUTES | FILE_READ_DATA;
904 oparms.disposition = FILE_OPEN;
905 oparms.create_options = 0;
906 oparms.fid = fid;
Pavel Shilovsky9cbc0b72013-07-09 18:40:58 +0400907 oparms.reconnect = false;
Pavel Shilovsky064f6042013-07-09 18:20:30 +0400908
Pavel Shilovskyb42bf882013-08-14 19:25:21 +0400909 rc = SMB2_open(xid, &oparms, utf16_path, &oplock, NULL, NULL);
Pavel Shilovskyd324f08d2012-09-18 16:20:33 -0700910 kfree(utf16_path);
911 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500912 cifs_dbg(VFS, "open dir failed\n");
Pavel Shilovskyd324f08d2012-09-18 16:20:33 -0700913 return rc;
914 }
915
916 srch_inf->entries_in_buffer = 0;
917 srch_inf->index_of_last_entry = 0;
Pavel Shilovskyd324f08d2012-09-18 16:20:33 -0700918
Pavel Shilovsky064f6042013-07-09 18:20:30 +0400919 rc = SMB2_query_directory(xid, tcon, fid->persistent_fid,
920 fid->volatile_fid, 0, srch_inf);
Pavel Shilovskyd324f08d2012-09-18 16:20:33 -0700921 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500922 cifs_dbg(VFS, "query directory failed\n");
Pavel Shilovsky064f6042013-07-09 18:20:30 +0400923 SMB2_close(xid, tcon, fid->persistent_fid, fid->volatile_fid);
Pavel Shilovskyd324f08d2012-09-18 16:20:33 -0700924 }
925 return rc;
926}
927
928static int
929smb2_query_dir_next(const unsigned int xid, struct cifs_tcon *tcon,
930 struct cifs_fid *fid, __u16 search_flags,
931 struct cifs_search_info *srch_inf)
932{
933 return SMB2_query_directory(xid, tcon, fid->persistent_fid,
934 fid->volatile_fid, 0, srch_inf);
935}
936
937static int
938smb2_close_dir(const unsigned int xid, struct cifs_tcon *tcon,
939 struct cifs_fid *fid)
940{
941 return SMB2_close(xid, tcon, fid->persistent_fid, fid->volatile_fid);
942}
943
Pavel Shilovsky2e44b282012-09-18 16:20:33 -0700944/*
945* If we negotiate SMB2 protocol and get STATUS_PENDING - update
946* the number of credits and return true. Otherwise - return false.
947*/
948static bool
949smb2_is_status_pending(char *buf, struct TCP_Server_Info *server, int length)
950{
951 struct smb2_hdr *hdr = (struct smb2_hdr *)buf;
952
Steve French12e8a202012-09-19 09:19:39 -0700953 if (hdr->Status != STATUS_PENDING)
Pavel Shilovsky2e44b282012-09-18 16:20:33 -0700954 return false;
955
956 if (!length) {
957 spin_lock(&server->req_lock);
958 server->credits += le16_to_cpu(hdr->CreditRequest);
959 spin_unlock(&server->req_lock);
960 wake_up(&server->request_q);
961 }
962
963 return true;
964}
965
Pavel Shilovsky983c88a2012-09-18 16:20:33 -0700966static int
967smb2_oplock_response(struct cifs_tcon *tcon, struct cifs_fid *fid,
968 struct cifsInodeInfo *cinode)
969{
Pavel Shilovsky0822f512012-09-19 06:22:45 -0700970 if (tcon->ses->server->capabilities & SMB2_GLOBAL_CAP_LEASING)
971 return SMB2_lease_break(0, tcon, cinode->lease_key,
972 smb2_get_lease_state(cinode));
973
Pavel Shilovsky983c88a2012-09-18 16:20:33 -0700974 return SMB2_oplock_break(0, tcon, fid->persistent_fid,
975 fid->volatile_fid,
Pavel Shilovsky18cceb62013-09-05 13:01:06 +0400976 CIFS_CACHE_READ(cinode) ? 1 : 0);
Pavel Shilovsky983c88a2012-09-18 16:20:33 -0700977}
978
Pavel Shilovsky6fc05c22012-09-18 16:20:34 -0700979static int
980smb2_queryfs(const unsigned int xid, struct cifs_tcon *tcon,
981 struct kstatfs *buf)
982{
983 int rc;
Pavel Shilovsky6fc05c22012-09-18 16:20:34 -0700984 __le16 srch_path = 0; /* Null - open root of share */
985 u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
Pavel Shilovsky064f6042013-07-09 18:20:30 +0400986 struct cifs_open_parms oparms;
987 struct cifs_fid fid;
Pavel Shilovsky6fc05c22012-09-18 16:20:34 -0700988
Pavel Shilovsky064f6042013-07-09 18:20:30 +0400989 oparms.tcon = tcon;
990 oparms.desired_access = FILE_READ_ATTRIBUTES;
991 oparms.disposition = FILE_OPEN;
992 oparms.create_options = 0;
993 oparms.fid = &fid;
Pavel Shilovsky9cbc0b72013-07-09 18:40:58 +0400994 oparms.reconnect = false;
Pavel Shilovsky064f6042013-07-09 18:20:30 +0400995
Pavel Shilovskyb42bf882013-08-14 19:25:21 +0400996 rc = SMB2_open(xid, &oparms, &srch_path, &oplock, NULL, NULL);
Pavel Shilovsky6fc05c22012-09-18 16:20:34 -0700997 if (rc)
998 return rc;
999 buf->f_type = SMB2_MAGIC_NUMBER;
Pavel Shilovsky064f6042013-07-09 18:20:30 +04001000 rc = SMB2_QFS_info(xid, tcon, fid.persistent_fid, fid.volatile_fid,
1001 buf);
1002 SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
Pavel Shilovsky6fc05c22012-09-18 16:20:34 -07001003 return rc;
1004}
1005
Pavel Shilovsky027e8ee2012-09-19 06:22:43 -07001006static bool
1007smb2_compare_fids(struct cifsFileInfo *ob1, struct cifsFileInfo *ob2)
1008{
1009 return ob1->fid.persistent_fid == ob2->fid.persistent_fid &&
1010 ob1->fid.volatile_fid == ob2->fid.volatile_fid;
1011}
1012
Pavel Shilovskyf7ba7fe2012-09-19 06:22:43 -07001013static int
1014smb2_mand_lock(const unsigned int xid, struct cifsFileInfo *cfile, __u64 offset,
1015 __u64 length, __u32 type, int lock, int unlock, bool wait)
1016{
1017 if (unlock && !lock)
1018 type = SMB2_LOCKFLAG_UNLOCK;
1019 return SMB2_lock(xid, tlink_tcon(cfile->tlink),
1020 cfile->fid.persistent_fid, cfile->fid.volatile_fid,
1021 current->tgid, length, offset, type, wait);
1022}
1023
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -07001024static void
1025smb2_get_lease_key(struct inode *inode, struct cifs_fid *fid)
1026{
1027 memcpy(fid->lease_key, CIFS_I(inode)->lease_key, SMB2_LEASE_KEY_SIZE);
1028}
1029
1030static void
1031smb2_set_lease_key(struct inode *inode, struct cifs_fid *fid)
1032{
1033 memcpy(CIFS_I(inode)->lease_key, fid->lease_key, SMB2_LEASE_KEY_SIZE);
1034}
1035
1036static void
1037smb2_new_lease_key(struct cifs_fid *fid)
1038{
1039 get_random_bytes(fid->lease_key, SMB2_LEASE_KEY_SIZE);
1040}
1041
Pavel Shilovskyb42bf882013-08-14 19:25:21 +04001042static int
1043smb2_query_symlink(const unsigned int xid, struct cifs_tcon *tcon,
1044 const char *full_path, char **target_path,
1045 struct cifs_sb_info *cifs_sb)
1046{
1047 int rc;
1048 __le16 *utf16_path;
1049 __u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
1050 struct cifs_open_parms oparms;
1051 struct cifs_fid fid;
1052 struct smb2_err_rsp *err_buf = NULL;
1053 struct smb2_symlink_err_rsp *symlink;
1054 unsigned int sub_len, sub_offset;
1055
1056 cifs_dbg(FYI, "%s: path: %s\n", __func__, full_path);
1057
1058 utf16_path = cifs_convert_path_to_utf16(full_path, cifs_sb);
1059 if (!utf16_path)
1060 return -ENOMEM;
1061
1062 oparms.tcon = tcon;
1063 oparms.desired_access = FILE_READ_ATTRIBUTES;
1064 oparms.disposition = FILE_OPEN;
1065 oparms.create_options = 0;
1066 oparms.fid = &fid;
1067 oparms.reconnect = false;
1068
1069 rc = SMB2_open(xid, &oparms, utf16_path, &oplock, NULL, &err_buf);
1070
1071 if (!rc || !err_buf) {
1072 kfree(utf16_path);
1073 return -ENOENT;
1074 }
1075 /* open must fail on symlink - reset rc */
1076 rc = 0;
1077 symlink = (struct smb2_symlink_err_rsp *)err_buf->ErrorData;
1078 sub_len = le16_to_cpu(symlink->SubstituteNameLength);
1079 sub_offset = le16_to_cpu(symlink->SubstituteNameOffset);
1080 *target_path = cifs_strndup_from_utf16(
1081 (char *)symlink->PathBuffer + sub_offset,
1082 sub_len, true, cifs_sb->local_nls);
1083 if (!(*target_path)) {
1084 kfree(utf16_path);
1085 return -ENOMEM;
1086 }
1087 convert_delimiter(*target_path, '/');
1088 cifs_dbg(FYI, "%s: target path: %s\n", __func__, *target_path);
1089 kfree(utf16_path);
1090 return rc;
1091}
1092
Steve French30175622014-08-17 18:16:40 -05001093static long smb3_zero_range(struct file *file, struct cifs_tcon *tcon,
1094 loff_t offset, loff_t len, bool keep_size)
1095{
1096 struct inode *inode;
1097 struct cifsInodeInfo *cifsi;
1098 struct cifsFileInfo *cfile = file->private_data;
1099 struct file_zero_data_information fsctl_buf;
1100 long rc;
1101 unsigned int xid;
1102
1103 xid = get_xid();
1104
David Howells2b0143b2015-03-17 22:25:59 +00001105 inode = d_inode(cfile->dentry);
Steve French30175622014-08-17 18:16:40 -05001106 cifsi = CIFS_I(inode);
1107
1108 /* if file not oplocked can't be sure whether asking to extend size */
1109 if (!CIFS_CACHE_READ(cifsi))
1110 if (keep_size == false)
1111 return -EOPNOTSUPP;
1112
Steve French2bb93d22014-08-20 18:56:29 -05001113 /*
Steve French30175622014-08-17 18:16:40 -05001114 * Must check if file sparse since fallocate -z (zero range) assumes
1115 * non-sparse allocation
1116 */
1117 if (!(cifsi->cifsAttrs & FILE_ATTRIBUTE_SPARSE_FILE))
1118 return -EOPNOTSUPP;
1119
1120 /*
1121 * need to make sure we are not asked to extend the file since the SMB3
1122 * fsctl does not change the file size. In the future we could change
1123 * this to zero the first part of the range then set the file size
1124 * which for a non sparse file would zero the newly extended range
1125 */
1126 if (keep_size == false)
1127 if (i_size_read(inode) < offset + len)
1128 return -EOPNOTSUPP;
1129
1130 cifs_dbg(FYI, "offset %lld len %lld", offset, len);
1131
1132 fsctl_buf.FileOffset = cpu_to_le64(offset);
1133 fsctl_buf.BeyondFinalZero = cpu_to_le64(offset + len);
1134
1135 rc = SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid,
1136 cfile->fid.volatile_fid, FSCTL_SET_ZERO_DATA,
1137 true /* is_fctl */, (char *)&fsctl_buf,
1138 sizeof(struct file_zero_data_information), NULL, NULL);
1139 free_xid(xid);
1140 return rc;
1141}
1142
Steve French31742c52014-08-17 08:38:47 -05001143static long smb3_punch_hole(struct file *file, struct cifs_tcon *tcon,
1144 loff_t offset, loff_t len)
1145{
1146 struct inode *inode;
1147 struct cifsInodeInfo *cifsi;
1148 struct cifsFileInfo *cfile = file->private_data;
1149 struct file_zero_data_information fsctl_buf;
1150 long rc;
1151 unsigned int xid;
1152 __u8 set_sparse = 1;
1153
1154 xid = get_xid();
1155
David Howells2b0143b2015-03-17 22:25:59 +00001156 inode = d_inode(cfile->dentry);
Steve French31742c52014-08-17 08:38:47 -05001157 cifsi = CIFS_I(inode);
1158
1159 /* Need to make file sparse, if not already, before freeing range. */
1160 /* Consider adding equivalent for compressed since it could also work */
1161 if (!smb2_set_sparse(xid, tcon, cfile, inode, set_sparse))
1162 return -EOPNOTSUPP;
1163
1164 cifs_dbg(FYI, "offset %lld len %lld", offset, len);
1165
1166 fsctl_buf.FileOffset = cpu_to_le64(offset);
1167 fsctl_buf.BeyondFinalZero = cpu_to_le64(offset + len);
1168
1169 rc = SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid,
1170 cfile->fid.volatile_fid, FSCTL_SET_ZERO_DATA,
1171 true /* is_fctl */, (char *)&fsctl_buf,
1172 sizeof(struct file_zero_data_information), NULL, NULL);
1173 free_xid(xid);
1174 return rc;
1175}
1176
Steve French9ccf3212014-10-18 17:01:15 -05001177static long smb3_simple_falloc(struct file *file, struct cifs_tcon *tcon,
1178 loff_t off, loff_t len, bool keep_size)
1179{
1180 struct inode *inode;
1181 struct cifsInodeInfo *cifsi;
1182 struct cifsFileInfo *cfile = file->private_data;
1183 long rc = -EOPNOTSUPP;
1184 unsigned int xid;
1185
1186 xid = get_xid();
1187
David Howells2b0143b2015-03-17 22:25:59 +00001188 inode = d_inode(cfile->dentry);
Steve French9ccf3212014-10-18 17:01:15 -05001189 cifsi = CIFS_I(inode);
1190
1191 /* if file not oplocked can't be sure whether asking to extend size */
1192 if (!CIFS_CACHE_READ(cifsi))
1193 if (keep_size == false)
1194 return -EOPNOTSUPP;
1195
1196 /*
1197 * Files are non-sparse by default so falloc may be a no-op
1198 * Must check if file sparse. If not sparse, and not extending
1199 * then no need to do anything since file already allocated
1200 */
1201 if ((cifsi->cifsAttrs & FILE_ATTRIBUTE_SPARSE_FILE) == 0) {
1202 if (keep_size == true)
1203 return 0;
1204 /* check if extending file */
1205 else if (i_size_read(inode) >= off + len)
1206 /* not extending file and already not sparse */
1207 return 0;
1208 /* BB: in future add else clause to extend file */
1209 else
1210 return -EOPNOTSUPP;
1211 }
1212
1213 if ((keep_size == true) || (i_size_read(inode) >= off + len)) {
1214 /*
1215 * Check if falloc starts within first few pages of file
1216 * and ends within a few pages of the end of file to
1217 * ensure that most of file is being forced to be
1218 * fallocated now. If so then setting whole file sparse
1219 * ie potentially making a few extra pages at the beginning
1220 * or end of the file non-sparse via set_sparse is harmless.
1221 */
1222 if ((off > 8192) || (off + len + 8192 < i_size_read(inode)))
1223 return -EOPNOTSUPP;
1224
1225 rc = smb2_set_sparse(xid, tcon, cfile, inode, false);
1226 }
1227 /* BB: else ... in future add code to extend file and set sparse */
1228
1229
1230 free_xid(xid);
1231 return rc;
1232}
1233
1234
Steve French31742c52014-08-17 08:38:47 -05001235static long smb3_fallocate(struct file *file, struct cifs_tcon *tcon, int mode,
1236 loff_t off, loff_t len)
1237{
1238 /* KEEP_SIZE already checked for by do_fallocate */
1239 if (mode & FALLOC_FL_PUNCH_HOLE)
1240 return smb3_punch_hole(file, tcon, off, len);
Steve French30175622014-08-17 18:16:40 -05001241 else if (mode & FALLOC_FL_ZERO_RANGE) {
1242 if (mode & FALLOC_FL_KEEP_SIZE)
1243 return smb3_zero_range(file, tcon, off, len, true);
1244 return smb3_zero_range(file, tcon, off, len, false);
Steve French9ccf3212014-10-18 17:01:15 -05001245 } else if (mode == FALLOC_FL_KEEP_SIZE)
1246 return smb3_simple_falloc(file, tcon, off, len, true);
1247 else if (mode == 0)
1248 return smb3_simple_falloc(file, tcon, off, len, false);
Steve French31742c52014-08-17 08:38:47 -05001249
1250 return -EOPNOTSUPP;
1251}
1252
Pavel Shilovsky53ef1012013-09-05 16:11:28 +04001253static void
Sachin Prabhuc11f1df2014-03-11 16:11:47 +00001254smb2_downgrade_oplock(struct TCP_Server_Info *server,
1255 struct cifsInodeInfo *cinode, bool set_level2)
1256{
1257 if (set_level2)
1258 server->ops->set_oplock_level(cinode, SMB2_OPLOCK_LEVEL_II,
1259 0, NULL);
1260 else
1261 server->ops->set_oplock_level(cinode, 0, 0, NULL);
1262}
1263
1264static void
Pavel Shilovsky42873b02013-09-05 21:30:16 +04001265smb2_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock,
1266 unsigned int epoch, bool *purge_cache)
Pavel Shilovsky53ef1012013-09-05 16:11:28 +04001267{
1268 oplock &= 0xFF;
1269 if (oplock == SMB2_OPLOCK_LEVEL_NOCHANGE)
1270 return;
1271 if (oplock == SMB2_OPLOCK_LEVEL_BATCH) {
Pavel Shilovsky42873b02013-09-05 21:30:16 +04001272 cinode->oplock = CIFS_CACHE_RHW_FLG;
Pavel Shilovsky53ef1012013-09-05 16:11:28 +04001273 cifs_dbg(FYI, "Batch Oplock granted on inode %p\n",
1274 &cinode->vfs_inode);
1275 } else if (oplock == SMB2_OPLOCK_LEVEL_EXCLUSIVE) {
Pavel Shilovsky42873b02013-09-05 21:30:16 +04001276 cinode->oplock = CIFS_CACHE_RW_FLG;
Pavel Shilovsky53ef1012013-09-05 16:11:28 +04001277 cifs_dbg(FYI, "Exclusive Oplock granted on inode %p\n",
1278 &cinode->vfs_inode);
1279 } else if (oplock == SMB2_OPLOCK_LEVEL_II) {
1280 cinode->oplock = CIFS_CACHE_READ_FLG;
1281 cifs_dbg(FYI, "Level II Oplock granted on inode %p\n",
1282 &cinode->vfs_inode);
1283 } else
1284 cinode->oplock = 0;
1285}
1286
1287static void
Pavel Shilovsky42873b02013-09-05 21:30:16 +04001288smb21_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock,
1289 unsigned int epoch, bool *purge_cache)
Pavel Shilovsky53ef1012013-09-05 16:11:28 +04001290{
1291 char message[5] = {0};
1292
1293 oplock &= 0xFF;
1294 if (oplock == SMB2_OPLOCK_LEVEL_NOCHANGE)
1295 return;
1296
1297 cinode->oplock = 0;
1298 if (oplock & SMB2_LEASE_READ_CACHING_HE) {
1299 cinode->oplock |= CIFS_CACHE_READ_FLG;
1300 strcat(message, "R");
1301 }
1302 if (oplock & SMB2_LEASE_HANDLE_CACHING_HE) {
1303 cinode->oplock |= CIFS_CACHE_HANDLE_FLG;
1304 strcat(message, "H");
1305 }
1306 if (oplock & SMB2_LEASE_WRITE_CACHING_HE) {
1307 cinode->oplock |= CIFS_CACHE_WRITE_FLG;
1308 strcat(message, "W");
1309 }
1310 if (!cinode->oplock)
1311 strcat(message, "None");
1312 cifs_dbg(FYI, "%s Lease granted on inode %p\n", message,
1313 &cinode->vfs_inode);
1314}
1315
Pavel Shilovsky42873b02013-09-05 21:30:16 +04001316static void
1317smb3_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock,
1318 unsigned int epoch, bool *purge_cache)
1319{
1320 unsigned int old_oplock = cinode->oplock;
1321
1322 smb21_set_oplock_level(cinode, oplock, epoch, purge_cache);
1323
1324 if (purge_cache) {
1325 *purge_cache = false;
1326 if (old_oplock == CIFS_CACHE_READ_FLG) {
1327 if (cinode->oplock == CIFS_CACHE_READ_FLG &&
1328 (epoch - cinode->epoch > 0))
1329 *purge_cache = true;
1330 else if (cinode->oplock == CIFS_CACHE_RH_FLG &&
1331 (epoch - cinode->epoch > 1))
1332 *purge_cache = true;
1333 else if (cinode->oplock == CIFS_CACHE_RHW_FLG &&
1334 (epoch - cinode->epoch > 1))
1335 *purge_cache = true;
1336 else if (cinode->oplock == 0 &&
1337 (epoch - cinode->epoch > 0))
1338 *purge_cache = true;
1339 } else if (old_oplock == CIFS_CACHE_RH_FLG) {
1340 if (cinode->oplock == CIFS_CACHE_RH_FLG &&
1341 (epoch - cinode->epoch > 0))
1342 *purge_cache = true;
1343 else if (cinode->oplock == CIFS_CACHE_RHW_FLG &&
1344 (epoch - cinode->epoch > 1))
1345 *purge_cache = true;
1346 }
1347 cinode->epoch = epoch;
1348 }
1349}
1350
Pavel Shilovsky53ef1012013-09-05 16:11:28 +04001351static bool
1352smb2_is_read_op(__u32 oplock)
1353{
1354 return oplock == SMB2_OPLOCK_LEVEL_II;
1355}
1356
1357static bool
1358smb21_is_read_op(__u32 oplock)
1359{
1360 return (oplock & SMB2_LEASE_READ_CACHING_HE) &&
1361 !(oplock & SMB2_LEASE_WRITE_CACHING_HE);
1362}
1363
Pavel Shilovskyf0473902013-09-04 13:44:05 +04001364static __le32
1365map_oplock_to_lease(u8 oplock)
1366{
1367 if (oplock == SMB2_OPLOCK_LEVEL_EXCLUSIVE)
1368 return SMB2_LEASE_WRITE_CACHING | SMB2_LEASE_READ_CACHING;
1369 else if (oplock == SMB2_OPLOCK_LEVEL_II)
1370 return SMB2_LEASE_READ_CACHING;
1371 else if (oplock == SMB2_OPLOCK_LEVEL_BATCH)
1372 return SMB2_LEASE_HANDLE_CACHING | SMB2_LEASE_READ_CACHING |
1373 SMB2_LEASE_WRITE_CACHING;
1374 return 0;
1375}
1376
Pavel Shilovskya41a28b2013-09-04 13:07:41 +04001377static char *
1378smb2_create_lease_buf(u8 *lease_key, u8 oplock)
1379{
1380 struct create_lease *buf;
1381
1382 buf = kzalloc(sizeof(struct create_lease), GFP_KERNEL);
1383 if (!buf)
1384 return NULL;
1385
1386 buf->lcontext.LeaseKeyLow = cpu_to_le64(*((u64 *)lease_key));
1387 buf->lcontext.LeaseKeyHigh = cpu_to_le64(*((u64 *)(lease_key + 8)));
Pavel Shilovskyf0473902013-09-04 13:44:05 +04001388 buf->lcontext.LeaseState = map_oplock_to_lease(oplock);
Pavel Shilovskya41a28b2013-09-04 13:07:41 +04001389
1390 buf->ccontext.DataOffset = cpu_to_le16(offsetof
1391 (struct create_lease, lcontext));
1392 buf->ccontext.DataLength = cpu_to_le32(sizeof(struct lease_context));
1393 buf->ccontext.NameOffset = cpu_to_le16(offsetof
1394 (struct create_lease, Name));
1395 buf->ccontext.NameLength = cpu_to_le16(4);
Steve French12197a72014-05-14 05:29:40 -07001396 /* SMB2_CREATE_REQUEST_LEASE is "RqLs" */
Pavel Shilovskya41a28b2013-09-04 13:07:41 +04001397 buf->Name[0] = 'R';
1398 buf->Name[1] = 'q';
1399 buf->Name[2] = 'L';
1400 buf->Name[3] = 's';
1401 return (char *)buf;
1402}
1403
Pavel Shilovskyf0473902013-09-04 13:44:05 +04001404static char *
1405smb3_create_lease_buf(u8 *lease_key, u8 oplock)
1406{
1407 struct create_lease_v2 *buf;
1408
1409 buf = kzalloc(sizeof(struct create_lease_v2), GFP_KERNEL);
1410 if (!buf)
1411 return NULL;
1412
1413 buf->lcontext.LeaseKeyLow = cpu_to_le64(*((u64 *)lease_key));
1414 buf->lcontext.LeaseKeyHigh = cpu_to_le64(*((u64 *)(lease_key + 8)));
1415 buf->lcontext.LeaseState = map_oplock_to_lease(oplock);
1416
1417 buf->ccontext.DataOffset = cpu_to_le16(offsetof
1418 (struct create_lease_v2, lcontext));
1419 buf->ccontext.DataLength = cpu_to_le32(sizeof(struct lease_context_v2));
1420 buf->ccontext.NameOffset = cpu_to_le16(offsetof
1421 (struct create_lease_v2, Name));
1422 buf->ccontext.NameLength = cpu_to_le16(4);
Steve French12197a72014-05-14 05:29:40 -07001423 /* SMB2_CREATE_REQUEST_LEASE is "RqLs" */
Pavel Shilovskyf0473902013-09-04 13:44:05 +04001424 buf->Name[0] = 'R';
1425 buf->Name[1] = 'q';
1426 buf->Name[2] = 'L';
1427 buf->Name[3] = 's';
1428 return (char *)buf;
1429}
1430
Pavel Shilovskyb5c7cde2013-09-05 20:16:45 +04001431static __u8
Pavel Shilovsky42873b02013-09-05 21:30:16 +04001432smb2_parse_lease_buf(void *buf, unsigned int *epoch)
Pavel Shilovskyb5c7cde2013-09-05 20:16:45 +04001433{
1434 struct create_lease *lc = (struct create_lease *)buf;
1435
Pavel Shilovsky42873b02013-09-05 21:30:16 +04001436 *epoch = 0; /* not used */
Pavel Shilovskyb5c7cde2013-09-05 20:16:45 +04001437 if (lc->lcontext.LeaseFlags & SMB2_LEASE_FLAG_BREAK_IN_PROGRESS)
1438 return SMB2_OPLOCK_LEVEL_NOCHANGE;
1439 return le32_to_cpu(lc->lcontext.LeaseState);
1440}
1441
Pavel Shilovskyf0473902013-09-04 13:44:05 +04001442static __u8
Pavel Shilovsky42873b02013-09-05 21:30:16 +04001443smb3_parse_lease_buf(void *buf, unsigned int *epoch)
Pavel Shilovskyf0473902013-09-04 13:44:05 +04001444{
1445 struct create_lease_v2 *lc = (struct create_lease_v2 *)buf;
1446
Pavel Shilovsky42873b02013-09-05 21:30:16 +04001447 *epoch = le16_to_cpu(lc->lcontext.Epoch);
Pavel Shilovskyf0473902013-09-04 13:44:05 +04001448 if (lc->lcontext.LeaseFlags & SMB2_LEASE_FLAG_BREAK_IN_PROGRESS)
1449 return SMB2_OPLOCK_LEVEL_NOCHANGE;
1450 return le32_to_cpu(lc->lcontext.LeaseState);
1451}
1452
Pavel Shilovsky7f6c5002014-06-22 11:03:22 +04001453static unsigned int
1454smb2_wp_retry_size(struct inode *inode)
1455{
1456 return min_t(unsigned int, CIFS_SB(inode->i_sb)->wsize,
1457 SMB2_MAX_BUFFER_SIZE);
1458}
1459
Pavel Shilovsky52755802014-08-18 20:49:57 +04001460static bool
1461smb2_dir_needs_close(struct cifsFileInfo *cfile)
1462{
1463 return !cfile->invalidHandle;
1464}
1465
Pavel Shilovsky53ef1012013-09-05 16:11:28 +04001466struct smb_version_operations smb20_operations = {
1467 .compare_fids = smb2_compare_fids,
1468 .setup_request = smb2_setup_request,
1469 .setup_async_request = smb2_setup_async_request,
1470 .check_receive = smb2_check_receive,
1471 .add_credits = smb2_add_credits,
1472 .set_credits = smb2_set_credits,
1473 .get_credits_field = smb2_get_credits_field,
1474 .get_credits = smb2_get_credits,
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04001475 .wait_mtu_credits = cifs_wait_mtu_credits,
Pavel Shilovsky53ef1012013-09-05 16:11:28 +04001476 .get_next_mid = smb2_get_next_mid,
1477 .read_data_offset = smb2_read_data_offset,
1478 .read_data_length = smb2_read_data_length,
1479 .map_error = map_smb2_to_linux_error,
1480 .find_mid = smb2_find_mid,
1481 .check_message = smb2_check_message,
1482 .dump_detail = smb2_dump_detail,
1483 .clear_stats = smb2_clear_stats,
1484 .print_stats = smb2_print_stats,
1485 .is_oplock_break = smb2_is_valid_oplock_break,
Sachin Prabhuc11f1df2014-03-11 16:11:47 +00001486 .downgrade_oplock = smb2_downgrade_oplock,
Pavel Shilovsky53ef1012013-09-05 16:11:28 +04001487 .need_neg = smb2_need_neg,
1488 .negotiate = smb2_negotiate,
1489 .negotiate_wsize = smb2_negotiate_wsize,
1490 .negotiate_rsize = smb2_negotiate_rsize,
1491 .sess_setup = SMB2_sess_setup,
1492 .logoff = SMB2_logoff,
1493 .tree_connect = SMB2_tcon,
1494 .tree_disconnect = SMB2_tdis,
Steve French34f62642013-10-09 02:07:00 -05001495 .qfs_tcon = smb2_qfs_tcon,
Pavel Shilovsky53ef1012013-09-05 16:11:28 +04001496 .is_path_accessible = smb2_is_path_accessible,
1497 .can_echo = smb2_can_echo,
1498 .echo = SMB2_echo,
1499 .query_path_info = smb2_query_path_info,
1500 .get_srv_inum = smb2_get_srv_inum,
1501 .query_file_info = smb2_query_file_info,
1502 .set_path_size = smb2_set_path_size,
1503 .set_file_size = smb2_set_file_size,
1504 .set_file_info = smb2_set_file_info,
Steve French64a5cfa2013-10-14 15:31:32 -05001505 .set_compression = smb2_set_compression,
Pavel Shilovsky53ef1012013-09-05 16:11:28 +04001506 .mkdir = smb2_mkdir,
1507 .mkdir_setinfo = smb2_mkdir_setinfo,
1508 .rmdir = smb2_rmdir,
1509 .unlink = smb2_unlink,
1510 .rename = smb2_rename_path,
1511 .create_hardlink = smb2_create_hardlink,
1512 .query_symlink = smb2_query_symlink,
1513 .open = smb2_open_file,
1514 .set_fid = smb2_set_fid,
1515 .close = smb2_close_file,
1516 .flush = smb2_flush_file,
1517 .async_readv = smb2_async_readv,
1518 .async_writev = smb2_async_writev,
1519 .sync_read = smb2_sync_read,
1520 .sync_write = smb2_sync_write,
1521 .query_dir_first = smb2_query_dir_first,
1522 .query_dir_next = smb2_query_dir_next,
1523 .close_dir = smb2_close_dir,
1524 .calc_smb_size = smb2_calc_size,
1525 .is_status_pending = smb2_is_status_pending,
1526 .oplock_response = smb2_oplock_response,
1527 .queryfs = smb2_queryfs,
1528 .mand_lock = smb2_mand_lock,
1529 .mand_unlock_range = smb2_unlock_range,
1530 .push_mand_locks = smb2_push_mandatory_locks,
1531 .get_lease_key = smb2_get_lease_key,
1532 .set_lease_key = smb2_set_lease_key,
1533 .new_lease_key = smb2_new_lease_key,
1534 .calc_signature = smb2_calc_signature,
1535 .is_read_op = smb2_is_read_op,
1536 .set_oplock_level = smb2_set_oplock_level,
Pavel Shilovskya41a28b2013-09-04 13:07:41 +04001537 .create_lease_buf = smb2_create_lease_buf,
Pavel Shilovskyb5c7cde2013-09-05 20:16:45 +04001538 .parse_lease_buf = smb2_parse_lease_buf,
Steve French41c13582013-11-14 00:05:36 -06001539 .clone_range = smb2_clone_range,
Pavel Shilovsky7f6c5002014-06-22 11:03:22 +04001540 .wp_retry_size = smb2_wp_retry_size,
Pavel Shilovsky52755802014-08-18 20:49:57 +04001541 .dir_needs_close = smb2_dir_needs_close,
Pavel Shilovsky53ef1012013-09-05 16:11:28 +04001542};
1543
Steve French1080ef72011-02-24 18:07:19 +00001544struct smb_version_operations smb21_operations = {
Pavel Shilovsky027e8ee2012-09-19 06:22:43 -07001545 .compare_fids = smb2_compare_fids,
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +04001546 .setup_request = smb2_setup_request,
Pavel Shilovskyc95b8ee2012-07-11 14:45:28 +04001547 .setup_async_request = smb2_setup_async_request,
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +04001548 .check_receive = smb2_check_receive,
Pavel Shilovsky28ea5292012-05-23 16:18:00 +04001549 .add_credits = smb2_add_credits,
1550 .set_credits = smb2_set_credits,
1551 .get_credits_field = smb2_get_credits_field,
1552 .get_credits = smb2_get_credits,
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04001553 .wait_mtu_credits = smb2_wait_mtu_credits,
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +04001554 .get_next_mid = smb2_get_next_mid,
Pavel Shilovsky09a47072012-09-18 16:20:29 -07001555 .read_data_offset = smb2_read_data_offset,
1556 .read_data_length = smb2_read_data_length,
1557 .map_error = map_smb2_to_linux_error,
Pavel Shilovsky093b2bd2011-06-08 15:51:07 +04001558 .find_mid = smb2_find_mid,
1559 .check_message = smb2_check_message,
1560 .dump_detail = smb2_dump_detail,
Pavel Shilovskyd60622e2012-05-28 15:19:39 +04001561 .clear_stats = smb2_clear_stats,
1562 .print_stats = smb2_print_stats,
Pavel Shilovsky983c88a2012-09-18 16:20:33 -07001563 .is_oplock_break = smb2_is_valid_oplock_break,
Sachin Prabhuc11f1df2014-03-11 16:11:47 +00001564 .downgrade_oplock = smb2_downgrade_oplock,
Pavel Shilovskyec2e4522011-12-27 16:12:43 +04001565 .need_neg = smb2_need_neg,
1566 .negotiate = smb2_negotiate,
Pavel Shilovsky3a3bab52012-09-18 16:20:28 -07001567 .negotiate_wsize = smb2_negotiate_wsize,
1568 .negotiate_rsize = smb2_negotiate_rsize,
Pavel Shilovsky5478f9b2011-12-27 16:22:00 +04001569 .sess_setup = SMB2_sess_setup,
1570 .logoff = SMB2_logoff,
Pavel Shilovskyfaaf9462011-12-27 16:04:00 +04001571 .tree_connect = SMB2_tcon,
1572 .tree_disconnect = SMB2_tdis,
Steve French34f62642013-10-09 02:07:00 -05001573 .qfs_tcon = smb2_qfs_tcon,
Pavel Shilovsky2503a0d2011-12-26 22:58:46 +04001574 .is_path_accessible = smb2_is_path_accessible,
Pavel Shilovsky9094fad2012-07-12 18:30:44 +04001575 .can_echo = smb2_can_echo,
1576 .echo = SMB2_echo,
Pavel Shilovskybe4cb9e2011-12-29 17:06:33 +04001577 .query_path_info = smb2_query_path_info,
1578 .get_srv_inum = smb2_get_srv_inum,
Pavel Shilovskyb7546bc2012-09-18 16:20:27 -07001579 .query_file_info = smb2_query_file_info,
Pavel Shilovskyc839ff22012-09-18 16:20:32 -07001580 .set_path_size = smb2_set_path_size,
1581 .set_file_size = smb2_set_file_size,
Pavel Shilovsky1feeaac2012-09-18 16:20:32 -07001582 .set_file_info = smb2_set_file_info,
Steve French64a5cfa2013-10-14 15:31:32 -05001583 .set_compression = smb2_set_compression,
Pavel Shilovskya0e73182011-07-19 12:56:37 +04001584 .mkdir = smb2_mkdir,
1585 .mkdir_setinfo = smb2_mkdir_setinfo,
Pavel Shilovsky1a500f02012-07-10 16:14:38 +04001586 .rmdir = smb2_rmdir,
Pavel Shilovskycbe6f432012-09-18 16:20:25 -07001587 .unlink = smb2_unlink,
Pavel Shilovsky35143eb2012-09-18 16:20:31 -07001588 .rename = smb2_rename_path,
Pavel Shilovsky568798c2012-09-18 16:20:31 -07001589 .create_hardlink = smb2_create_hardlink,
Pavel Shilovskyb42bf882013-08-14 19:25:21 +04001590 .query_symlink = smb2_query_symlink,
Steve Frenchc22870e2014-09-16 07:18:19 -05001591 .query_mf_symlink = smb3_query_mf_symlink,
Steve French5ab97572014-09-15 04:49:28 -05001592 .create_mf_symlink = smb3_create_mf_symlink,
Pavel Shilovskyf0df7372012-09-18 16:20:26 -07001593 .open = smb2_open_file,
1594 .set_fid = smb2_set_fid,
1595 .close = smb2_close_file,
Pavel Shilovsky7a5cfb12012-09-18 16:20:28 -07001596 .flush = smb2_flush_file,
Pavel Shilovsky09a47072012-09-18 16:20:29 -07001597 .async_readv = smb2_async_readv,
Pavel Shilovsky33319142012-09-18 16:20:29 -07001598 .async_writev = smb2_async_writev,
Pavel Shilovskyd8e05032012-09-18 16:20:30 -07001599 .sync_read = smb2_sync_read,
Pavel Shilovsky009d3442012-09-18 16:20:30 -07001600 .sync_write = smb2_sync_write,
Pavel Shilovskyd324f08d2012-09-18 16:20:33 -07001601 .query_dir_first = smb2_query_dir_first,
1602 .query_dir_next = smb2_query_dir_next,
1603 .close_dir = smb2_close_dir,
1604 .calc_smb_size = smb2_calc_size,
Pavel Shilovsky2e44b282012-09-18 16:20:33 -07001605 .is_status_pending = smb2_is_status_pending,
Pavel Shilovsky983c88a2012-09-18 16:20:33 -07001606 .oplock_response = smb2_oplock_response,
Pavel Shilovsky6fc05c22012-09-18 16:20:34 -07001607 .queryfs = smb2_queryfs,
Pavel Shilovskyf7ba7fe2012-09-19 06:22:43 -07001608 .mand_lock = smb2_mand_lock,
1609 .mand_unlock_range = smb2_unlock_range,
Pavel Shilovskyb1407992012-09-19 06:22:44 -07001610 .push_mand_locks = smb2_push_mandatory_locks,
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -07001611 .get_lease_key = smb2_get_lease_key,
1612 .set_lease_key = smb2_set_lease_key,
1613 .new_lease_key = smb2_new_lease_key,
Steve French38107d42012-12-08 22:08:06 -06001614 .calc_signature = smb2_calc_signature,
Pavel Shilovsky53ef1012013-09-05 16:11:28 +04001615 .is_read_op = smb21_is_read_op,
1616 .set_oplock_level = smb21_set_oplock_level,
Pavel Shilovskya41a28b2013-09-04 13:07:41 +04001617 .create_lease_buf = smb2_create_lease_buf,
Pavel Shilovskyb5c7cde2013-09-05 20:16:45 +04001618 .parse_lease_buf = smb2_parse_lease_buf,
Steve French41c13582013-11-14 00:05:36 -06001619 .clone_range = smb2_clone_range,
Pavel Shilovsky7f6c5002014-06-22 11:03:22 +04001620 .wp_retry_size = smb2_wp_retry_size,
Pavel Shilovsky52755802014-08-18 20:49:57 +04001621 .dir_needs_close = smb2_dir_needs_close,
Steve French38107d42012-12-08 22:08:06 -06001622};
1623
Steve French38107d42012-12-08 22:08:06 -06001624struct smb_version_operations smb30_operations = {
1625 .compare_fids = smb2_compare_fids,
1626 .setup_request = smb2_setup_request,
1627 .setup_async_request = smb2_setup_async_request,
1628 .check_receive = smb2_check_receive,
1629 .add_credits = smb2_add_credits,
1630 .set_credits = smb2_set_credits,
1631 .get_credits_field = smb2_get_credits_field,
1632 .get_credits = smb2_get_credits,
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04001633 .wait_mtu_credits = smb2_wait_mtu_credits,
Steve French38107d42012-12-08 22:08:06 -06001634 .get_next_mid = smb2_get_next_mid,
1635 .read_data_offset = smb2_read_data_offset,
1636 .read_data_length = smb2_read_data_length,
1637 .map_error = map_smb2_to_linux_error,
1638 .find_mid = smb2_find_mid,
1639 .check_message = smb2_check_message,
1640 .dump_detail = smb2_dump_detail,
1641 .clear_stats = smb2_clear_stats,
1642 .print_stats = smb2_print_stats,
Steve French769ee6a2013-06-19 14:15:30 -05001643 .dump_share_caps = smb2_dump_share_caps,
Steve French38107d42012-12-08 22:08:06 -06001644 .is_oplock_break = smb2_is_valid_oplock_break,
Sachin Prabhuc11f1df2014-03-11 16:11:47 +00001645 .downgrade_oplock = smb2_downgrade_oplock,
Steve French38107d42012-12-08 22:08:06 -06001646 .need_neg = smb2_need_neg,
1647 .negotiate = smb2_negotiate,
1648 .negotiate_wsize = smb2_negotiate_wsize,
1649 .negotiate_rsize = smb2_negotiate_rsize,
1650 .sess_setup = SMB2_sess_setup,
1651 .logoff = SMB2_logoff,
1652 .tree_connect = SMB2_tcon,
1653 .tree_disconnect = SMB2_tdis,
Steven Frenchaf6a12e2013-10-09 20:55:53 -05001654 .qfs_tcon = smb3_qfs_tcon,
Steve French38107d42012-12-08 22:08:06 -06001655 .is_path_accessible = smb2_is_path_accessible,
1656 .can_echo = smb2_can_echo,
1657 .echo = SMB2_echo,
1658 .query_path_info = smb2_query_path_info,
1659 .get_srv_inum = smb2_get_srv_inum,
1660 .query_file_info = smb2_query_file_info,
1661 .set_path_size = smb2_set_path_size,
1662 .set_file_size = smb2_set_file_size,
1663 .set_file_info = smb2_set_file_info,
Steve French64a5cfa2013-10-14 15:31:32 -05001664 .set_compression = smb2_set_compression,
Steve French38107d42012-12-08 22:08:06 -06001665 .mkdir = smb2_mkdir,
1666 .mkdir_setinfo = smb2_mkdir_setinfo,
1667 .rmdir = smb2_rmdir,
1668 .unlink = smb2_unlink,
1669 .rename = smb2_rename_path,
1670 .create_hardlink = smb2_create_hardlink,
Pavel Shilovskyb42bf882013-08-14 19:25:21 +04001671 .query_symlink = smb2_query_symlink,
Steve Frenchc22870e2014-09-16 07:18:19 -05001672 .query_mf_symlink = smb3_query_mf_symlink,
Steve French5ab97572014-09-15 04:49:28 -05001673 .create_mf_symlink = smb3_create_mf_symlink,
Steve French38107d42012-12-08 22:08:06 -06001674 .open = smb2_open_file,
1675 .set_fid = smb2_set_fid,
1676 .close = smb2_close_file,
1677 .flush = smb2_flush_file,
1678 .async_readv = smb2_async_readv,
1679 .async_writev = smb2_async_writev,
1680 .sync_read = smb2_sync_read,
1681 .sync_write = smb2_sync_write,
1682 .query_dir_first = smb2_query_dir_first,
1683 .query_dir_next = smb2_query_dir_next,
1684 .close_dir = smb2_close_dir,
1685 .calc_smb_size = smb2_calc_size,
1686 .is_status_pending = smb2_is_status_pending,
1687 .oplock_response = smb2_oplock_response,
1688 .queryfs = smb2_queryfs,
1689 .mand_lock = smb2_mand_lock,
1690 .mand_unlock_range = smb2_unlock_range,
1691 .push_mand_locks = smb2_push_mandatory_locks,
1692 .get_lease_key = smb2_get_lease_key,
1693 .set_lease_key = smb2_set_lease_key,
1694 .new_lease_key = smb2_new_lease_key,
Steve Frenche65a5cb2013-06-27 01:06:50 -05001695 .generate_signingkey = generate_smb3signingkey,
Steve French38107d42012-12-08 22:08:06 -06001696 .calc_signature = smb3_calc_signature,
Steve Frenchb3152e22015-06-24 03:17:02 -05001697 .set_integrity = smb3_set_integrity,
Pavel Shilovsky53ef1012013-09-05 16:11:28 +04001698 .is_read_op = smb21_is_read_op,
Pavel Shilovsky42873b02013-09-05 21:30:16 +04001699 .set_oplock_level = smb3_set_oplock_level,
Pavel Shilovskyf0473902013-09-04 13:44:05 +04001700 .create_lease_buf = smb3_create_lease_buf,
1701 .parse_lease_buf = smb3_parse_lease_buf,
Steve French41c13582013-11-14 00:05:36 -06001702 .clone_range = smb2_clone_range,
Steve Frenchca9e7a12015-10-01 21:40:10 -05001703 .duplicate_extents = smb2_duplicate_extents,
Steve Frenchff1c0382013-11-19 23:44:46 -06001704 .validate_negotiate = smb3_validate_negotiate,
Pavel Shilovsky7f6c5002014-06-22 11:03:22 +04001705 .wp_retry_size = smb2_wp_retry_size,
Pavel Shilovsky52755802014-08-18 20:49:57 +04001706 .dir_needs_close = smb2_dir_needs_close,
Steve French31742c52014-08-17 08:38:47 -05001707 .fallocate = smb3_fallocate,
Steve French1080ef72011-02-24 18:07:19 +00001708};
1709
Steve Frenchaab18932015-06-23 23:37:11 -05001710#ifdef CONFIG_CIFS_SMB311
1711struct smb_version_operations smb311_operations = {
1712 .compare_fids = smb2_compare_fids,
1713 .setup_request = smb2_setup_request,
1714 .setup_async_request = smb2_setup_async_request,
1715 .check_receive = smb2_check_receive,
1716 .add_credits = smb2_add_credits,
1717 .set_credits = smb2_set_credits,
1718 .get_credits_field = smb2_get_credits_field,
1719 .get_credits = smb2_get_credits,
1720 .wait_mtu_credits = smb2_wait_mtu_credits,
1721 .get_next_mid = smb2_get_next_mid,
1722 .read_data_offset = smb2_read_data_offset,
1723 .read_data_length = smb2_read_data_length,
1724 .map_error = map_smb2_to_linux_error,
1725 .find_mid = smb2_find_mid,
1726 .check_message = smb2_check_message,
1727 .dump_detail = smb2_dump_detail,
1728 .clear_stats = smb2_clear_stats,
1729 .print_stats = smb2_print_stats,
1730 .dump_share_caps = smb2_dump_share_caps,
1731 .is_oplock_break = smb2_is_valid_oplock_break,
1732 .downgrade_oplock = smb2_downgrade_oplock,
1733 .need_neg = smb2_need_neg,
1734 .negotiate = smb2_negotiate,
1735 .negotiate_wsize = smb2_negotiate_wsize,
1736 .negotiate_rsize = smb2_negotiate_rsize,
1737 .sess_setup = SMB2_sess_setup,
1738 .logoff = SMB2_logoff,
1739 .tree_connect = SMB2_tcon,
1740 .tree_disconnect = SMB2_tdis,
1741 .qfs_tcon = smb3_qfs_tcon,
1742 .is_path_accessible = smb2_is_path_accessible,
1743 .can_echo = smb2_can_echo,
1744 .echo = SMB2_echo,
1745 .query_path_info = smb2_query_path_info,
1746 .get_srv_inum = smb2_get_srv_inum,
1747 .query_file_info = smb2_query_file_info,
1748 .set_path_size = smb2_set_path_size,
1749 .set_file_size = smb2_set_file_size,
1750 .set_file_info = smb2_set_file_info,
1751 .set_compression = smb2_set_compression,
1752 .mkdir = smb2_mkdir,
1753 .mkdir_setinfo = smb2_mkdir_setinfo,
1754 .rmdir = smb2_rmdir,
1755 .unlink = smb2_unlink,
1756 .rename = smb2_rename_path,
1757 .create_hardlink = smb2_create_hardlink,
1758 .query_symlink = smb2_query_symlink,
1759 .query_mf_symlink = smb3_query_mf_symlink,
1760 .create_mf_symlink = smb3_create_mf_symlink,
1761 .open = smb2_open_file,
1762 .set_fid = smb2_set_fid,
1763 .close = smb2_close_file,
1764 .flush = smb2_flush_file,
1765 .async_readv = smb2_async_readv,
1766 .async_writev = smb2_async_writev,
1767 .sync_read = smb2_sync_read,
1768 .sync_write = smb2_sync_write,
1769 .query_dir_first = smb2_query_dir_first,
1770 .query_dir_next = smb2_query_dir_next,
1771 .close_dir = smb2_close_dir,
1772 .calc_smb_size = smb2_calc_size,
1773 .is_status_pending = smb2_is_status_pending,
1774 .oplock_response = smb2_oplock_response,
1775 .queryfs = smb2_queryfs,
1776 .mand_lock = smb2_mand_lock,
1777 .mand_unlock_range = smb2_unlock_range,
1778 .push_mand_locks = smb2_push_mandatory_locks,
1779 .get_lease_key = smb2_get_lease_key,
1780 .set_lease_key = smb2_set_lease_key,
1781 .new_lease_key = smb2_new_lease_key,
1782 .generate_signingkey = generate_smb3signingkey,
1783 .calc_signature = smb3_calc_signature,
Steve Frenchb3152e22015-06-24 03:17:02 -05001784 .set_integrity = smb3_set_integrity,
Steve Frenchaab18932015-06-23 23:37:11 -05001785 .is_read_op = smb21_is_read_op,
1786 .set_oplock_level = smb3_set_oplock_level,
1787 .create_lease_buf = smb3_create_lease_buf,
1788 .parse_lease_buf = smb3_parse_lease_buf,
1789 .clone_range = smb2_clone_range,
Steve French02b16662015-06-27 21:18:36 -07001790 .duplicate_extents = smb2_duplicate_extents,
Steve Frenchaab18932015-06-23 23:37:11 -05001791/* .validate_negotiate = smb3_validate_negotiate, */ /* not used in 3.11 */
1792 .wp_retry_size = smb2_wp_retry_size,
1793 .dir_needs_close = smb2_dir_needs_close,
1794 .fallocate = smb3_fallocate,
1795};
1796#endif /* CIFS_SMB311 */
1797
Steve Frenchdd446b12012-11-28 23:21:06 -06001798struct smb_version_values smb20_values = {
1799 .version_string = SMB20_VERSION_STRING,
1800 .protocol_id = SMB20_PROT_ID,
1801 .req_capabilities = 0, /* MBZ */
1802 .large_lock_type = 0,
1803 .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK,
1804 .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK,
1805 .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK,
1806 .header_size = sizeof(struct smb2_hdr),
1807 .max_header_size = MAX_SMB2_HDR_SIZE,
1808 .read_rsp_size = sizeof(struct smb2_read_rsp) - 1,
1809 .lock_cmd = SMB2_LOCK,
1810 .cap_unix = 0,
1811 .cap_nt_find = SMB2_NT_FIND,
1812 .cap_large_files = SMB2_LARGE_FILES,
Jeff Layton50285882013-06-27 12:45:00 -04001813 .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED,
1814 .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED,
Pavel Shilovskya41a28b2013-09-04 13:07:41 +04001815 .create_lease_size = sizeof(struct create_lease),
Steve Frenchdd446b12012-11-28 23:21:06 -06001816};
1817
Steve French1080ef72011-02-24 18:07:19 +00001818struct smb_version_values smb21_values = {
1819 .version_string = SMB21_VERSION_STRING,
Steve Frenche4aa25e2012-10-01 12:26:22 -05001820 .protocol_id = SMB21_PROT_ID,
1821 .req_capabilities = 0, /* MBZ on negotiate req until SMB3 dialect */
1822 .large_lock_type = 0,
1823 .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK,
1824 .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK,
1825 .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK,
1826 .header_size = sizeof(struct smb2_hdr),
1827 .max_header_size = MAX_SMB2_HDR_SIZE,
1828 .read_rsp_size = sizeof(struct smb2_read_rsp) - 1,
1829 .lock_cmd = SMB2_LOCK,
1830 .cap_unix = 0,
1831 .cap_nt_find = SMB2_NT_FIND,
1832 .cap_large_files = SMB2_LARGE_FILES,
Jeff Layton50285882013-06-27 12:45:00 -04001833 .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED,
1834 .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED,
Pavel Shilovskya41a28b2013-09-04 13:07:41 +04001835 .create_lease_size = sizeof(struct create_lease),
Steve Frenche4aa25e2012-10-01 12:26:22 -05001836};
1837
1838struct smb_version_values smb30_values = {
1839 .version_string = SMB30_VERSION_STRING,
1840 .protocol_id = SMB30_PROT_ID,
Steve Frenchb618f002015-11-03 09:15:03 -06001841 .req_capabilities = SMB2_GLOBAL_CAP_DFS | SMB2_GLOBAL_CAP_LEASING | SMB2_GLOBAL_CAP_LARGE_MTU | SMB2_GLOBAL_CAP_PERSISTENT_HANDLES,
Pavel Shilovsky027e8ee2012-09-19 06:22:43 -07001842 .large_lock_type = 0,
1843 .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK,
1844 .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK,
1845 .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK,
Pavel Shilovsky093b2bd2011-06-08 15:51:07 +04001846 .header_size = sizeof(struct smb2_hdr),
1847 .max_header_size = MAX_SMB2_HDR_SIZE,
Pavel Shilovsky09a47072012-09-18 16:20:29 -07001848 .read_rsp_size = sizeof(struct smb2_read_rsp) - 1,
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +04001849 .lock_cmd = SMB2_LOCK,
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001850 .cap_unix = 0,
1851 .cap_nt_find = SMB2_NT_FIND,
1852 .cap_large_files = SMB2_LARGE_FILES,
Jeff Layton50285882013-06-27 12:45:00 -04001853 .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED,
1854 .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED,
Pavel Shilovskyf0473902013-09-04 13:44:05 +04001855 .create_lease_size = sizeof(struct create_lease_v2),
Steve French1080ef72011-02-24 18:07:19 +00001856};
Steve French20b6d8b2013-06-12 22:48:41 -05001857
1858struct smb_version_values smb302_values = {
1859 .version_string = SMB302_VERSION_STRING,
1860 .protocol_id = SMB302_PROT_ID,
Steve Frenchb618f002015-11-03 09:15:03 -06001861 .req_capabilities = SMB2_GLOBAL_CAP_DFS | SMB2_GLOBAL_CAP_LEASING | SMB2_GLOBAL_CAP_LARGE_MTU | SMB2_GLOBAL_CAP_PERSISTENT_HANDLES,
Steve French20b6d8b2013-06-12 22:48:41 -05001862 .large_lock_type = 0,
1863 .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK,
1864 .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK,
1865 .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK,
1866 .header_size = sizeof(struct smb2_hdr),
1867 .max_header_size = MAX_SMB2_HDR_SIZE,
1868 .read_rsp_size = sizeof(struct smb2_read_rsp) - 1,
1869 .lock_cmd = SMB2_LOCK,
1870 .cap_unix = 0,
1871 .cap_nt_find = SMB2_NT_FIND,
1872 .cap_large_files = SMB2_LARGE_FILES,
Jeff Layton50285882013-06-27 12:45:00 -04001873 .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED,
1874 .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED,
Pavel Shilovskyf0473902013-09-04 13:44:05 +04001875 .create_lease_size = sizeof(struct create_lease_v2),
Steve French20b6d8b2013-06-12 22:48:41 -05001876};
Steve French5f7fbf72014-12-17 22:52:58 -06001877
1878#ifdef CONFIG_CIFS_SMB311
1879struct smb_version_values smb311_values = {
1880 .version_string = SMB311_VERSION_STRING,
1881 .protocol_id = SMB311_PROT_ID,
Steve Frenchb618f002015-11-03 09:15:03 -06001882 .req_capabilities = SMB2_GLOBAL_CAP_DFS | SMB2_GLOBAL_CAP_LEASING | SMB2_GLOBAL_CAP_LARGE_MTU | SMB2_GLOBAL_CAP_PERSISTENT_HANDLES,
Steve French5f7fbf72014-12-17 22:52:58 -06001883 .large_lock_type = 0,
1884 .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK,
1885 .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK,
1886 .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK,
1887 .header_size = sizeof(struct smb2_hdr),
1888 .max_header_size = MAX_SMB2_HDR_SIZE,
1889 .read_rsp_size = sizeof(struct smb2_read_rsp) - 1,
1890 .lock_cmd = SMB2_LOCK,
1891 .cap_unix = 0,
1892 .cap_nt_find = SMB2_NT_FIND,
1893 .cap_large_files = SMB2_LARGE_FILES,
1894 .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED,
1895 .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED,
1896 .create_lease_size = sizeof(struct create_lease_v2),
1897};
1898#endif /* SMB311 */