]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - fs/cifs/smb2ops.c
projects / mirror_ubuntu-bionic-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'for-3.14-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/tj...
[mirror_ubuntu-bionic-kernel.git] / fs / cifs / smb2ops.c
CommitLineData
1080ef75
SF		 1/*
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
3a3bab50 20#include <linux/pagemap.h>
6fc05c25 21#include <linux/vfs.h>
1080ef75 22#include "cifsglob.h"
2dc7e1c0
PS		 23#include "smb2pdu.h"
24#include "smb2proto.h"
28ea5290
PS		 25#include "cifsproto.h"
26#include "cifs_debug.h"
b42bf888 27#include "cifs_unicode.h"
2e44b288 28#include "smb2status.h"
6fc05c25 29#include "smb2glob.h"
28ea5290
PS		 30
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;
f96637be 42 cifs_dbg(VFS, "disabling echoes and oplocks\n");
28ea5290
PS		 43 break;
44 case 2:
45 server->echoes = true;
46 server->oplocks = false;
47 server->echo_credits = 1;
f96637be 48 cifs_dbg(FYI, "disabling oplocks\n");
28ea5290
PS		 49 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--;
ec2e4523 69 if (server->in_flight == 0 && (optype & CIFS_OP_MASK) != CIFS_NEG_OP)
28ea5290 70 rc = change_conf(server);
983c88a4
PS		 71 /*
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 }
28ea5290
PS		 82 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}
2dc7e1c0
PS		 114
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}
1080ef75 125
093b2bda
PS		 126static 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
f96637be
JP		 151 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));
093b2bda
PS		 155#endif
156}
157
ec2e4523
PS		 158static 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
3a3bab50
PS		 176static 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);
2365c4ea
PS		 185 /* 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);
3a3bab50 187
3a3bab50
PS		 188 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);
2365c4ea
PS		 200 /* 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);
3a3bab50 202
3a3bab50
PS		 203 return rsize;
204}
205
c481e9fe
SF		 206#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
af6a12ea
SF		 232static void
233smb3_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
c481e9fe
SF		 252#ifdef CONFIG_CIFS_STATS2
253 SMB3_request_interfaces(xid, tcon);
254#endif /* STATS2 */
255
af6a12ea
SF		 256 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
34f62640
SF		 266static void
267smb2_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
2167114c
SF		 286 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);
34f62640
SF		 290 SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
291 return;
292}
293
2503a0db
PS		 294static 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;
2503a0db 299 __le16 *utf16_path;
2e44b288 300 __u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
064f6047
PS		 301 struct cifs_open_parms oparms;
302 struct cifs_fid fid;
2503a0db
PS		 303
304 utf16_path = cifs_convert_path_to_utf16(full_path, cifs_sb);
305 if (!utf16_path)
306 return -ENOMEM;
307
064f6047
PS		 308 oparms.tcon = tcon;
309 oparms.desired_access = FILE_READ_ATTRIBUTES;
310 oparms.disposition = FILE_OPEN;
311 oparms.create_options = 0;
312 oparms.fid = &fid;
9cbc0b73 313 oparms.reconnect = false;
064f6047 314
b42bf888 315 rc = SMB2_open(xid, &oparms, utf16_path, &oplock, NULL, NULL);
2503a0db
PS		 316 if (rc) {
317 kfree(utf16_path);
318 return rc;
319 }
320
064f6047 321 rc = SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
2503a0db
PS		 322 kfree(utf16_path);
323 return rc;
324}
325
be4cb9e3
PS		 326static 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
b7546bc5
PS		 335static 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
9094fad1
PS		 355static bool
356smb2_can_echo(struct TCP_Server_Info *server)
357{
358 return server->echoes;
359}
360
d60622eb
PS		 361static 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
769ee6a4
SF		 373static void
374smb2_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");
af6a12ea
SF		 389 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
769ee6a4 398 seq_printf(m, "\tShare Flags: 0x%x", tcon->share_flags);
af6a12ea
SF		 399 if (tcon->perf_sector_size)
400 seq_printf(m, "\tOptimal sector size: 0x%x",
401 tcon->perf_sector_size);
769ee6a4
SF		 402}
403
d60622eb
PS		 404static void
405smb2_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]));
d60622eb
PS		 416 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
f0df737e
PS		 470static void
471smb2_set_fid(struct cifsFileInfo *cfile, struct cifs_fid *fid, __u32 oplock)
472{
2e44b288 473 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
53ef1016
PS		 474 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
475
f0df737e
PS		 476 cfile->fid.persistent_fid = fid->persistent_fid;
477 cfile->fid.volatile_fid = fid->volatile_fid;
42873b0a
PS		 478 server->ops->set_oplock_level(cinode, oplock, fid->epoch,
479 &fid->purge_cache);
18cceb6a 480 cinode->can_cache_brlcks = CIFS_CACHE_WRITE(cinode);
f0df737e
PS		 481}
482
760ad0ca 483static void
f0df737e
PS		 484smb2_close_file(const unsigned int xid, struct cifs_tcon *tcon,
485 struct cifs_fid *fid)
486{
760ad0ca 487 SMB2_close(xid, tcon, fid->persistent_fid, fid->volatile_fid);
f0df737e
PS		 488}
489
41c1358e
SF		 490static int
491SMB2_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;
9bf0c9cd
SF		 529 struct copychunk_ioctl_rsp *retbuf = NULL;
530 struct cifs_tcon *tcon;
531 int chunks_copied = 0;
532 bool chunk_sizes_updated = false;
41c1358e
SF		 533
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)
9bf0c9cd 547 goto cchunk_out;
41c1358e
SF		 548
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;
41c1358e
SF		 552 pcchunk->Reserved2 = 0;
553
9bf0c9cd 554 tcon = tlink_tcon(trgtfile->tlink);
41c1358e 555
9bf0c9cd
SF		 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));
41c1358e 561
9bf0c9cd
SF		 562 /* Request server copy to target from src identified by key */
563 rc = SMB2_ioctl(xid, tcon, trgtfile->fid.persistent_fid,
564 trgtfile->fid.volatile_fid, FSCTL_SRV_COPYCHUNK_WRITE,
565 true /* is_fsctl */, (char *)pcchunk,
566 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++;
595
596 src_off += le32_to_cpu(retbuf->TotalBytesWritten);
597 dest_off += le32_to_cpu(retbuf->TotalBytesWritten);
598 len -= le32_to_cpu(retbuf->TotalBytesWritten);
599
600 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;
607
608 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 }
41c1358e 635
9bf0c9cd 636cchunk_out:
41c1358e
SF		 637 kfree(pcchunk);
638 return rc;
639}
640
7a5cfb19
PS		 641static int
642smb2_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
09a4707e
PS		 648static 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
d8e05039
PS		 662
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
009d3443
PS		 673static 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
c839ff24
PS		 684static 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
64a5cfa6
SF		 693static int
694smb2_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
d324f08d
PS		 701static int
702smb2_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;
2e44b288 709 __u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
064f6047 710 struct cifs_open_parms oparms;
d324f08d
PS		 711
712 utf16_path = cifs_convert_path_to_utf16(path, cifs_sb);
713 if (!utf16_path)
714 return -ENOMEM;
715
064f6047
PS		 716 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;
9cbc0b73 721 oparms.reconnect = false;
064f6047 722
b42bf888 723 rc = SMB2_open(xid, &oparms, utf16_path, &oplock, NULL, NULL);
d324f08d
PS		 724 kfree(utf16_path);
725 if (rc) {
f96637be 726 cifs_dbg(VFS, "open dir failed\n");
d324f08d
PS		 727 return rc;
728 }
729
730 srch_inf->entries_in_buffer = 0;
731 srch_inf->index_of_last_entry = 0;
d324f08d 732
064f6047
PS		 733 rc = SMB2_query_directory(xid, tcon, fid->persistent_fid,
734 fid->volatile_fid, 0, srch_inf);
d324f08d 735 if (rc) {
f96637be 736 cifs_dbg(VFS, "query directory failed\n");
064f6047 737 SMB2_close(xid, tcon, fid->persistent_fid, fid->volatile_fid);
d324f08d
PS		 738 }
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
2e44b288
PS		 758/*
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
12e8a208 767 if (hdr->Status != STATUS_PENDING)
2e44b288
PS		 768 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
983c88a4
PS		 780static int
781smb2_oplock_response(struct cifs_tcon *tcon, struct cifs_fid *fid,
782 struct cifsInodeInfo *cinode)
783{
0822f514
PS		 784 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
983c88a4
PS		 788 return SMB2_oplock_break(0, tcon, fid->persistent_fid,
789 fid->volatile_fid,
18cceb6a 790 CIFS_CACHE_READ(cinode) ? 1 : 0);
983c88a4
PS		 791}
792
6fc05c25
PS		 793static int
794smb2_queryfs(const unsigned int xid, struct cifs_tcon *tcon,
795 struct kstatfs *buf)
796{
797 int rc;
6fc05c25
PS		 798 __le16 srch_path = 0; /* Null - open root of share */
799 u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
064f6047
PS		 800 struct cifs_open_parms oparms;
801 struct cifs_fid fid;
802
803 oparms.tcon = tcon;
804 oparms.desired_access = FILE_READ_ATTRIBUTES;
805 oparms.disposition = FILE_OPEN;
806 oparms.create_options = 0;
807 oparms.fid = &fid;
9cbc0b73 808 oparms.reconnect = false;
6fc05c25 809
b42bf888 810 rc = SMB2_open(xid, &oparms, &srch_path, &oplock, NULL, NULL);
6fc05c25
PS		 811 if (rc)
812 return rc;
813 buf->f_type = SMB2_MAGIC_NUMBER;
064f6047
PS		 814 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);
6fc05c25
PS		 817 return rc;
818}
819
027e8eec
PS		 820static 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
f7ba7fe6
PS		 827static 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
b8c32dbb
PS		 838static 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
b42bf888
PS		 856static 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
53ef1016 907static void
42873b0a
PS		 908smb2_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock,
909 unsigned int epoch, bool *purge_cache)
53ef1016
PS		 910{
911 oplock &= 0xFF;
912 if (oplock == SMB2_OPLOCK_LEVEL_NOCHANGE)
913 return;
914 if (oplock == SMB2_OPLOCK_LEVEL_BATCH) {
42873b0a 915 cinode->oplock = CIFS_CACHE_RHW_FLG;
53ef1016
PS		 916 cifs_dbg(FYI, "Batch Oplock granted on inode %p\n",
917 &cinode->vfs_inode);
918 } else if (oplock == SMB2_OPLOCK_LEVEL_EXCLUSIVE) {
42873b0a 919 cinode->oplock = CIFS_CACHE_RW_FLG;
53ef1016
PS		 920 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
42873b0a
PS		 931smb21_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock,
932 unsigned int epoch, bool *purge_cache)
53ef1016
PS		 933{
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
42873b0a
PS		 959static 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
53ef1016
PS		 994static 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
f047390a
PS		 1007static __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
a41a28bd
PS		 1020static 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)));
f047390a 1031 buf->lcontext.LeaseState = map_oplock_to_lease(oplock);
a41a28bd
PS		 1032
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
f047390a
PS		 1046static 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
b5c7cde3 1072static __u8
42873b0a 1073smb2_parse_lease_buf(void *buf, unsigned int *epoch)
b5c7cde3
PS		 1074{
1075 struct create_lease *lc = (struct create_lease *)buf;
1076
42873b0a 1077 *epoch = 0; /* not used */
b5c7cde3
PS		 1078 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
f047390a 1083static __u8
42873b0a 1084smb3_parse_lease_buf(void *buf, unsigned int *epoch)
f047390a
PS		 1085{
1086 struct create_lease_v2 *lc = (struct create_lease_v2 *)buf;
1087
42873b0a 1088 *epoch = le16_to_cpu(lc->lcontext.Epoch);
f047390a
PS		 1089 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
53ef1016 1094struct smb_version_operations smb20_operations = {
027e8eec 1095 .compare_fids = smb2_compare_fids,
2dc7e1c0 1096 .setup_request = smb2_setup_request,
c95b8eed 1097 .setup_async_request = smb2_setup_async_request,
2dc7e1c0 1098 .check_receive = smb2_check_receive,
28ea5290
PS		 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,
2dc7e1c0 1103 .get_next_mid = smb2_get_next_mid,
09a4707e
PS		 1104 .read_data_offset = smb2_read_data_offset,
1105 .read_data_length = smb2_read_data_length,
1106 .map_error = map_smb2_to_linux_error,
093b2bda
PS		 1107 .find_mid = smb2_find_mid,
1108 .check_message = smb2_check_message,
1109 .dump_detail = smb2_dump_detail,
d60622eb
PS		 1110 .clear_stats = smb2_clear_stats,
1111 .print_stats = smb2_print_stats,
983c88a4 1112 .is_oplock_break = smb2_is_valid_oplock_break,
ec2e4523
PS		 1113 .need_neg = smb2_need_neg,
1114 .negotiate = smb2_negotiate,
3a3bab50
PS		 1115 .negotiate_wsize = smb2_negotiate_wsize,
1116 .negotiate_rsize = smb2_negotiate_rsize,
5478f9ba
PS		 1117 .sess_setup = SMB2_sess_setup,
1118 .logoff = SMB2_logoff,
faaf946a
PS		 1119 .tree_connect = SMB2_tcon,
1120 .tree_disconnect = SMB2_tdis,
34f62640 1121 .qfs_tcon = smb2_qfs_tcon,
2503a0db 1122 .is_path_accessible = smb2_is_path_accessible,
9094fad1
PS		 1123 .can_echo = smb2_can_echo,
1124 .echo = SMB2_echo,
be4cb9e3
PS		 1125 .query_path_info = smb2_query_path_info,
1126 .get_srv_inum = smb2_get_srv_inum,
b7546bc5 1127 .query_file_info = smb2_query_file_info,
c839ff24
PS		 1128 .set_path_size = smb2_set_path_size,
1129 .set_file_size = smb2_set_file_size,
1feeaac7 1130 .set_file_info = smb2_set_file_info,
64a5cfa6 1131 .set_compression = smb2_set_compression,
a0e73183
PS		 1132 .mkdir = smb2_mkdir,
1133 .mkdir_setinfo = smb2_mkdir_setinfo,
1a500f01 1134 .rmdir = smb2_rmdir,
cbe6f439 1135 .unlink = smb2_unlink,
35143eb5 1136 .rename = smb2_rename_path,
568798cc 1137 .create_hardlink = smb2_create_hardlink,
b42bf888 1138 .query_symlink = smb2_query_symlink,
f0df737e
PS		 1139 .open = smb2_open_file,
1140 .set_fid = smb2_set_fid,
1141 .close = smb2_close_file,
7a5cfb19 1142 .flush = smb2_flush_file,
09a4707e 1143 .async_readv = smb2_async_readv,
33319141 1144 .async_writev = smb2_async_writev,
d8e05039 1145 .sync_read = smb2_sync_read,
009d3443 1146 .sync_write = smb2_sync_write,
d324f08d
PS		 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,
2e44b288 1151 .is_status_pending = smb2_is_status_pending,
983c88a4 1152 .oplock_response = smb2_oplock_response,
6fc05c25 1153 .queryfs = smb2_queryfs,
f7ba7fe6
PS		 1154 .mand_lock = smb2_mand_lock,
1155 .mand_unlock_range = smb2_unlock_range,
b140799a 1156 .push_mand_locks = smb2_push_mandatory_locks,
b8c32dbb
PS		 1157 .get_lease_key = smb2_get_lease_key,
1158 .set_lease_key = smb2_set_lease_key,
1159 .new_lease_key = smb2_new_lease_key,
38107d45 1160 .calc_signature = smb2_calc_signature,
53ef1016
PS		 1161 .is_read_op = smb2_is_read_op,
1162 .set_oplock_level = smb2_set_oplock_level,
a41a28bd 1163 .create_lease_buf = smb2_create_lease_buf,
b5c7cde3 1164 .parse_lease_buf = smb2_parse_lease_buf,
41c1358e 1165 .clone_range = smb2_clone_range,
38107d45
SF		 1166};
1167
53ef1016
PS		 1168struct smb_version_operations smb21_operations = {
1169 .compare_fids = smb2_compare_fids,
1170 .setup_request = smb2_setup_request,
1171 .setup_async_request = smb2_setup_async_request,
1172 .check_receive = smb2_check_receive,
1173 .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,
1177 .get_next_mid = smb2_get_next_mid,
1178 .read_data_offset = smb2_read_data_offset,
1179 .read_data_length = smb2_read_data_length,
1180 .map_error = map_smb2_to_linux_error,
1181 .find_mid = smb2_find_mid,
1182 .check_message = smb2_check_message,
1183 .dump_detail = smb2_dump_detail,
1184 .clear_stats = smb2_clear_stats,
1185 .print_stats = smb2_print_stats,
1186 .is_oplock_break = smb2_is_valid_oplock_break,
1187 .need_neg = smb2_need_neg,
1188 .negotiate = smb2_negotiate,
1189 .negotiate_wsize = smb2_negotiate_wsize,
1190 .negotiate_rsize = smb2_negotiate_rsize,
1191 .sess_setup = SMB2_sess_setup,
1192 .logoff = SMB2_logoff,
1193 .tree_connect = SMB2_tcon,
1194 .tree_disconnect = SMB2_tdis,
34f62640 1195 .qfs_tcon = smb2_qfs_tcon,
53ef1016
PS		 1196 .is_path_accessible = smb2_is_path_accessible,
1197 .can_echo = smb2_can_echo,
1198 .echo = SMB2_echo,
1199 .query_path_info = smb2_query_path_info,
1200 .get_srv_inum = smb2_get_srv_inum,
1201 .query_file_info = smb2_query_file_info,
1202 .set_path_size = smb2_set_path_size,
1203 .set_file_size = smb2_set_file_size,
1204 .set_file_info = smb2_set_file_info,
64a5cfa6 1205 .set_compression = smb2_set_compression,
53ef1016
PS		 1206 .mkdir = smb2_mkdir,
1207 .mkdir_setinfo = smb2_mkdir_setinfo,
1208 .rmdir = smb2_rmdir,
1209 .unlink = smb2_unlink,
1210 .rename = smb2_rename_path,
1211 .create_hardlink = smb2_create_hardlink,
1212 .query_symlink = smb2_query_symlink,
1213 .open = smb2_open_file,
1214 .set_fid = smb2_set_fid,
1215 .close = smb2_close_file,
1216 .flush = smb2_flush_file,
1217 .async_readv = smb2_async_readv,
1218 .async_writev = smb2_async_writev,
1219 .sync_read = smb2_sync_read,
1220 .sync_write = smb2_sync_write,
1221 .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,
1225 .is_status_pending = smb2_is_status_pending,
1226 .oplock_response = smb2_oplock_response,
1227 .queryfs = smb2_queryfs,
1228 .mand_lock = smb2_mand_lock,
1229 .mand_unlock_range = smb2_unlock_range,
1230 .push_mand_locks = smb2_push_mandatory_locks,
1231 .get_lease_key = smb2_get_lease_key,
1232 .set_lease_key = smb2_set_lease_key,
1233 .new_lease_key = smb2_new_lease_key,
1234 .calc_signature = smb2_calc_signature,
1235 .is_read_op = smb21_is_read_op,
1236 .set_oplock_level = smb21_set_oplock_level,
a41a28bd 1237 .create_lease_buf = smb2_create_lease_buf,
b5c7cde3 1238 .parse_lease_buf = smb2_parse_lease_buf,
41c1358e 1239 .clone_range = smb2_clone_range,
53ef1016 1240};
38107d45
SF		 1241
1242struct 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,
769ee6a4 1260 .dump_share_caps = smb2_dump_share_caps,
38107d45
SF		 1261 .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,
af6a12ea 1270 .qfs_tcon = smb3_qfs_tcon,
38107d45
SF		 1271 .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,
64a5cfa6 1280 .set_compression = smb2_set_compression,
38107d45
SF		 1281 .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,
b42bf888 1287 .query_symlink = smb2_query_symlink,
38107d45
SF		 1288 .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,
e65a5cb4 1309 .generate_signingkey = generate_smb3signingkey,
38107d45 1310 .calc_signature = smb3_calc_signature,
53ef1016 1311 .is_read_op = smb21_is_read_op,
42873b0a 1312 .set_oplock_level = smb3_set_oplock_level,
f047390a
PS		 1313 .create_lease_buf = smb3_create_lease_buf,
1314 .parse_lease_buf = smb3_parse_lease_buf,
41c1358e 1315 .clone_range = smb2_clone_range,
ff1c038a 1316 .validate_negotiate = smb3_validate_negotiate,
1080ef75
SF		 1317};
1318
dd446b16
SF		 1319struct 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,
50285882
JL		 1334 .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED,
1335 .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED,
a41a28bd 1336 .create_lease_size = sizeof(struct create_lease),
dd446b16
SF		 1337};
1338
1080ef75
SF		 1339struct smb_version_values smb21_values = {
1340 .version_string = SMB21_VERSION_STRING,
e4aa25e7
SF		 1341 .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,
50285882
JL		 1354 .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED,
1355 .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED,
a41a28bd 1356 .create_lease_size = sizeof(struct create_lease),
e4aa25e7
SF		 1357};
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,
027e8eec
PS		 1363 .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,
093b2bda
PS		 1367 .header_size = sizeof(struct smb2_hdr),
1368 .max_header_size = MAX_SMB2_HDR_SIZE,
09a4707e 1369 .read_rsp_size = sizeof(struct smb2_read_rsp) - 1,
2dc7e1c0 1370 .lock_cmd = SMB2_LOCK,
29e20f9c
PS		 1371 .cap_unix = 0,
1372 .cap_nt_find = SMB2_NT_FIND,
1373 .cap_large_files = SMB2_LARGE_FILES,
50285882
JL		 1374 .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED,
1375 .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED,
f047390a 1376 .create_lease_size = sizeof(struct create_lease_v2),
1080ef75 1377};
20b6d8b4
SF		 1378
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,
50285882
JL		 1394 .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED,
1395 .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED,
f047390a 1396 .create_lease_size = sizeof(struct create_lease_v2),
20b6d8b4 1397};
ubuntu-bionic-kernel mirror