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 
20 #include <linux/pagemap.h>
21 #include <linux/vfs.h>
22 #include <linux/falloc.h>
23 #include "cifsglob.h"
24 #include "smb2pdu.h"
25 #include "smb2proto.h"
26 #include "cifsproto.h"
27 #include "cifs_debug.h"
28 #include "cifs_unicode.h"
29 #include "smb2status.h"
30 #include "smb2glob.h"
31 
32 static int
change_conf(struct TCP_Server_Info * server)33 change_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;
43 		cifs_dbg(VFS, "disabling echoes and oplocks\n");
44 		break;
45 	case 2:
46 		server->echoes = true;
47 		server->oplocks = false;
48 		server->echo_credits = 1;
49 		cifs_dbg(FYI, "disabling oplocks\n");
50 		break;
51 	default:
52 		server->echoes = true;
53 		if (enable_oplocks) {
54 			server->oplocks = true;
55 			server->oplock_credits = 1;
56 		} else
57 			server->oplocks = false;
58 
59 		server->echo_credits = 1;
60 	}
61 	server->credits -= server->echo_credits + server->oplock_credits;
62 	return 0;
63 }
64 
65 static void
smb2_add_credits(struct TCP_Server_Info * server,const unsigned int add,const int optype)66 smb2_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--;
74 	if (server->in_flight == 0 && (optype & CIFS_OP_MASK) != CIFS_NEG_OP)
75 		rc = change_conf(server);
76 	/*
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 	}
87 	spin_unlock(&server->req_lock);
88 	wake_up(&server->request_q);
89 	if (rc)
90 		cifs_reconnect(server);
91 }
92 
93 static void
smb2_set_credits(struct TCP_Server_Info * server,const int val)94 smb2_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 
101 static int *
smb2_get_credits_field(struct TCP_Server_Info * server,const int optype)102 smb2_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 
114 static unsigned int
smb2_get_credits(struct mid_q_entry * mid)115 smb2_get_credits(struct mid_q_entry *mid)
116 {
117 	return le16_to_cpu(((struct smb2_hdr *)mid->resp_buf)->CreditRequest);
118 }
119 
120 static int
smb2_wait_mtu_credits(struct TCP_Server_Info * server,unsigned int size,unsigned int * num,unsigned int * credits)121 smb2_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 
167 static __u64
smb2_get_next_mid(struct TCP_Server_Info * server)168 smb2_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 }
177 
178 static struct mid_q_entry *
smb2_find_mid(struct TCP_Server_Info * server,char * buf)179 smb2_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;
183 	__u64 wire_mid = le64_to_cpu(hdr->MessageId);
184 
185 	spin_lock(&GlobalMid_Lock);
186 	list_for_each_entry(mid, &server->pending_mid_q, qhead) {
187 		if ((mid->mid == wire_mid) &&
188 		    (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 
198 static void
smb2_dump_detail(void * buf)199 smb2_dump_detail(void *buf)
200 {
201 #ifdef CONFIG_CIFS_DEBUG2
202 	struct smb2_hdr *smb = (struct smb2_hdr *)buf;
203 
204 	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));
208 #endif
209 }
210 
211 static bool
smb2_need_neg(struct TCP_Server_Info * server)212 smb2_need_neg(struct TCP_Server_Info *server)
213 {
214 	return server->max_read == 0;
215 }
216 
217 static int
smb2_negotiate(const unsigned int xid,struct cifs_ses * ses)218 smb2_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 
229 static unsigned int
smb2_negotiate_wsize(struct cifs_tcon * tcon,struct smb_vol * volume_info)230 smb2_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);
238 
239 	if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))
240 		wsize = min_t(unsigned int, wsize, SMB2_MAX_BUFFER_SIZE);
241 
242 	return wsize;
243 }
244 
245 static unsigned int
smb2_negotiate_rsize(struct cifs_tcon * tcon,struct smb_vol * volume_info)246 smb2_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);
254 
255 	if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))
256 		rsize = min_t(unsigned int, rsize, SMB2_MAX_BUFFER_SIZE);
257 
258 	return rsize;
259 }
260 
261 #ifdef CONFIG_CIFS_STATS2
262 static int
SMB3_request_interfaces(const unsigned int xid,struct cifs_tcon * tcon)263 SMB3_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);
273 	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 {
279 		/* 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));
284 	}
285 
286 	return rc;
287 }
288 #endif /* STATS2 */
289 
290 static void
smb3_qfs_tcon(const unsigned int xid,struct cifs_tcon * tcon)291 smb3_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 
310 #ifdef CONFIG_CIFS_STATS2
311 	SMB3_request_interfaces(xid, tcon);
312 #endif /* STATS2 */
313 
314 	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 
324 static void
smb2_qfs_tcon(const unsigned int xid,struct cifs_tcon * tcon)325 smb2_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 
344 	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);
348 	SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
349 	return;
350 }
351 
352 static int
smb2_is_path_accessible(const unsigned int xid,struct cifs_tcon * tcon,struct cifs_sb_info * cifs_sb,const char * full_path)353 smb2_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;
357 	__le16 *utf16_path;
358 	__u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
359 	struct cifs_open_parms oparms;
360 	struct cifs_fid fid;
361 
362 	utf16_path = cifs_convert_path_to_utf16(full_path, cifs_sb);
363 	if (!utf16_path)
364 		return -ENOMEM;
365 
366 	oparms.tcon = tcon;
367 	oparms.desired_access = FILE_READ_ATTRIBUTES;
368 	oparms.disposition = FILE_OPEN;
369 	oparms.create_options = 0;
370 	oparms.fid = &fid;
371 	oparms.reconnect = false;
372 
373 	rc = SMB2_open(xid, &oparms, utf16_path, &oplock, NULL, NULL);
374 	if (rc) {
375 		kfree(utf16_path);
376 		return rc;
377 	}
378 
379 	rc = SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
380 	kfree(utf16_path);
381 	return rc;
382 }
383 
384 static int
smb2_get_srv_inum(const unsigned int xid,struct cifs_tcon * tcon,struct cifs_sb_info * cifs_sb,const char * full_path,u64 * uniqueid,FILE_ALL_INFO * data)385 smb2_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 
393 static int
smb2_query_file_info(const unsigned int xid,struct cifs_tcon * tcon,struct cifs_fid * fid,FILE_ALL_INFO * data)394 smb2_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 
400 	smb2_data = kzalloc(sizeof(struct smb2_file_all_info) + PATH_MAX * 2,
401 			    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 
413 static bool
smb2_can_echo(struct TCP_Server_Info * server)414 smb2_can_echo(struct TCP_Server_Info *server)
415 {
416 	return server->echoes;
417 }
418 
419 static void
smb2_clear_stats(struct cifs_tcon * tcon)420 smb2_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 
431 static void
smb2_dump_share_caps(struct seq_file * m,struct cifs_tcon * tcon)432 smb2_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");
447 	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 
456 	seq_printf(m, "\tShare Flags: 0x%x", tcon->share_flags);
457 	if (tcon->perf_sector_size)
458 		seq_printf(m, "\tOptimal sector size: 0x%x",
459 			   tcon->perf_sector_size);
460 }
461 
462 static void
smb2_print_stats(struct seq_file * m,struct cifs_tcon * tcon)463 smb2_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]));
474 	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 
528 static void
smb2_set_fid(struct cifsFileInfo * cfile,struct cifs_fid * fid,__u32 oplock)529 smb2_set_fid(struct cifsFileInfo *cfile, struct cifs_fid *fid, __u32 oplock)
530 {
531 	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
532 	struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
533 
534 	cfile->fid.persistent_fid = fid->persistent_fid;
535 	cfile->fid.volatile_fid = fid->volatile_fid;
536 	server->ops->set_oplock_level(cinode, oplock, fid->epoch,
537 				      &fid->purge_cache);
538 	cinode->can_cache_brlcks = CIFS_CACHE_WRITE(cinode);
539 }
540 
541 static void
smb2_close_file(const unsigned int xid,struct cifs_tcon * tcon,struct cifs_fid * fid)542 smb2_close_file(const unsigned int xid, struct cifs_tcon *tcon,
543 		struct cifs_fid *fid)
544 {
545 	SMB2_close(xid, tcon, fid->persistent_fid, fid->volatile_fid);
546 }
547 
548 static int
SMB2_request_res_key(const unsigned int xid,struct cifs_tcon * tcon,u64 persistent_fid,u64 volatile_fid,struct copychunk_ioctl * pcchunk)549 SMB2_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 
573 req_res_key_exit:
574 	kfree(res_key);
575 	return rc;
576 }
577 
578 static int
smb2_clone_range(const unsigned int xid,struct cifsFileInfo * srcfile,struct cifsFileInfo * trgtfile,u64 src_off,u64 len,u64 dest_off)579 smb2_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;
587 	struct copychunk_ioctl_rsp *retbuf = NULL;
588 	struct cifs_tcon *tcon;
589 	int chunks_copied = 0;
590 	bool chunk_sizes_updated = false;
591 
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)
605 		goto cchunk_out;
606 
607 	/* For now array only one chunk long, will make more flexible later */
608 	pcchunk->ChunkCount = cpu_to_le32(1);
609 	pcchunk->Reserved = 0;
610 	pcchunk->Reserved2 = 0;
611 
612 	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,
622 			trgtfile->fid.volatile_fid, FSCTL_SRV_COPYCHUNK_WRITE,
623 			true /* is_fsctl */, (char *)pcchunk,
624 			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++;
653 
654 			src_off += le32_to_cpu(retbuf->TotalBytesWritten);
655 			dest_off += le32_to_cpu(retbuf->TotalBytesWritten);
656 			len -= le32_to_cpu(retbuf->TotalBytesWritten);
657 
658 			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;
665 
666 			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;
691 		} else
692 			goto cchunk_out;
693 	}
694 
695 cchunk_out:
696 	kfree(pcchunk);
697 	return rc;
698 }
699 
700 static int
smb2_flush_file(const unsigned int xid,struct cifs_tcon * tcon,struct cifs_fid * fid)701 smb2_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 
707 static unsigned int
smb2_read_data_offset(char * buf)708 smb2_read_data_offset(char *buf)
709 {
710 	struct smb2_read_rsp *rsp = (struct smb2_read_rsp *)buf;
711 	return rsp->DataOffset;
712 }
713 
714 static unsigned int
smb2_read_data_length(char * buf)715 smb2_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 
721 
722 static int
smb2_sync_read(const unsigned int xid,struct cifs_fid * pfid,struct cifs_io_parms * parms,unsigned int * bytes_read,char ** buf,int * buf_type)723 smb2_sync_read(const unsigned int xid, struct cifs_fid *pfid,
724 	       struct cifs_io_parms *parms, unsigned int *bytes_read,
725 	       char **buf, int *buf_type)
726 {
727 	parms->persistent_fid = pfid->persistent_fid;
728 	parms->volatile_fid = pfid->volatile_fid;
729 	return SMB2_read(xid, parms, bytes_read, buf, buf_type);
730 }
731 
732 static int
smb2_sync_write(const unsigned int xid,struct cifs_fid * pfid,struct cifs_io_parms * parms,unsigned int * written,struct kvec * iov,unsigned long nr_segs)733 smb2_sync_write(const unsigned int xid, struct cifs_fid *pfid,
734 		struct cifs_io_parms *parms, unsigned int *written,
735 		struct kvec *iov, unsigned long nr_segs)
736 {
737 
738 	parms->persistent_fid = pfid->persistent_fid;
739 	parms->volatile_fid = pfid->volatile_fid;
740 	return SMB2_write(xid, parms, written, iov, nr_segs);
741 }
742 
743 /* Set or clear the SPARSE_FILE attribute based on value passed in setsparse */
smb2_set_sparse(const unsigned int xid,struct cifs_tcon * tcon,struct cifsFileInfo * cfile,struct inode * inode,__u8 setsparse)744 static 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 
789 static int
smb2_set_file_size(const unsigned int xid,struct cifs_tcon * tcon,struct cifsFileInfo * cfile,__u64 size,bool set_alloc)790 smb2_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);
794 	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 	 */
800 	inode = d_inode(cfile->dentry);
801 
802 	if (!set_alloc && (size > inode->i_size + 8192)) {
803 		__u8 set_sparse = 1;
804 
805 		/* whether set sparse succeeds or not, extend the file */
806 		smb2_set_sparse(xid, tcon, cfile, inode, set_sparse);
807 	}
808 
809 	return SMB2_set_eof(xid, tcon, cfile->fid.persistent_fid,
810 			    cfile->fid.volatile_fid, cfile->pid, &eof, false);
811 }
812 
813 static int
smb2_duplicate_extents(const unsigned int xid,struct cifsFileInfo * srcfile,struct cifsFileInfo * trgtfile,u64 src_off,u64 len,u64 dest_off)814 smb2_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 
853 duplicate_extents_out:
854 	return rc;
855 }
856 
857 static int
smb2_set_compression(const unsigned int xid,struct cifs_tcon * tcon,struct cifsFileInfo * cfile)858 smb2_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 
865 static int
smb3_set_integrity(const unsigned int xid,struct cifs_tcon * tcon,struct cifsFileInfo * cfile)866 smb3_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 
887 static int
smb2_query_dir_first(const unsigned int xid,struct cifs_tcon * tcon,const char * path,struct cifs_sb_info * cifs_sb,struct cifs_fid * fid,__u16 search_flags,struct cifs_search_info * srch_inf)888 smb2_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;
895 	__u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
896 	struct cifs_open_parms oparms;
897 
898 	utf16_path = cifs_convert_path_to_utf16(path, cifs_sb);
899 	if (!utf16_path)
900 		return -ENOMEM;
901 
902 	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;
907 	oparms.reconnect = false;
908 
909 	rc = SMB2_open(xid, &oparms, utf16_path, &oplock, NULL, NULL);
910 	kfree(utf16_path);
911 	if (rc) {
912 		cifs_dbg(VFS, "open dir failed\n");
913 		return rc;
914 	}
915 
916 	srch_inf->entries_in_buffer = 0;
917 	srch_inf->index_of_last_entry = 0;
918 
919 	rc = SMB2_query_directory(xid, tcon, fid->persistent_fid,
920 				  fid->volatile_fid, 0, srch_inf);
921 	if (rc) {
922 		cifs_dbg(VFS, "query directory failed\n");
923 		SMB2_close(xid, tcon, fid->persistent_fid, fid->volatile_fid);
924 	}
925 	return rc;
926 }
927 
928 static int
smb2_query_dir_next(const unsigned int xid,struct cifs_tcon * tcon,struct cifs_fid * fid,__u16 search_flags,struct cifs_search_info * srch_inf)929 smb2_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 
937 static int
smb2_close_dir(const unsigned int xid,struct cifs_tcon * tcon,struct cifs_fid * fid)938 smb2_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 
944 /*
945 * If we negotiate SMB2 protocol and get STATUS_PENDING - update
946 * the number of credits and return true. Otherwise - return false.
947 */
948 static bool
smb2_is_status_pending(char * buf,struct TCP_Server_Info * server,int length)949 smb2_is_status_pending(char *buf, struct TCP_Server_Info *server, int length)
950 {
951 	struct smb2_hdr *hdr = (struct smb2_hdr *)buf;
952 
953 	if (hdr->Status != STATUS_PENDING)
954 		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 
966 static int
smb2_oplock_response(struct cifs_tcon * tcon,struct cifs_fid * fid,struct cifsInodeInfo * cinode)967 smb2_oplock_response(struct cifs_tcon *tcon, struct cifs_fid *fid,
968 		     struct cifsInodeInfo *cinode)
969 {
970 	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 
974 	return SMB2_oplock_break(0, tcon, fid->persistent_fid,
975 				 fid->volatile_fid,
976 				 CIFS_CACHE_READ(cinode) ? 1 : 0);
977 }
978 
979 static int
smb2_queryfs(const unsigned int xid,struct cifs_tcon * tcon,struct kstatfs * buf)980 smb2_queryfs(const unsigned int xid, struct cifs_tcon *tcon,
981 	     struct kstatfs *buf)
982 {
983 	int rc;
984 	__le16 srch_path = 0; /* Null - open root of share */
985 	u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
986 	struct cifs_open_parms oparms;
987 	struct cifs_fid fid;
988 
989 	oparms.tcon = tcon;
990 	oparms.desired_access = FILE_READ_ATTRIBUTES;
991 	oparms.disposition = FILE_OPEN;
992 	oparms.create_options = 0;
993 	oparms.fid = &fid;
994 	oparms.reconnect = false;
995 
996 	rc = SMB2_open(xid, &oparms, &srch_path, &oplock, NULL, NULL);
997 	if (rc)
998 		return rc;
999 	buf->f_type = SMB2_MAGIC_NUMBER;
1000 	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);
1003 	return rc;
1004 }
1005 
1006 static bool
smb2_compare_fids(struct cifsFileInfo * ob1,struct cifsFileInfo * ob2)1007 smb2_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 
1013 static int
smb2_mand_lock(const unsigned int xid,struct cifsFileInfo * cfile,__u64 offset,__u64 length,__u32 type,int lock,int unlock,bool wait)1014 smb2_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 
1024 static void
smb2_get_lease_key(struct inode * inode,struct cifs_fid * fid)1025 smb2_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 
1030 static void
smb2_set_lease_key(struct inode * inode,struct cifs_fid * fid)1031 smb2_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 
1036 static void
smb2_new_lease_key(struct cifs_fid * fid)1037 smb2_new_lease_key(struct cifs_fid *fid)
1038 {
1039 	get_random_bytes(fid->lease_key, SMB2_LEASE_KEY_SIZE);
1040 }
1041 
1042 static int
smb2_query_symlink(const unsigned int xid,struct cifs_tcon * tcon,const char * full_path,char ** target_path,struct cifs_sb_info * cifs_sb)1043 smb2_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 
smb3_zero_range(struct file * file,struct cifs_tcon * tcon,loff_t offset,loff_t len,bool keep_size)1093 static 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 
1105 	inode = d_inode(cfile->dentry);
1106 	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 
1113 	/*
1114 	 * 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 
smb3_punch_hole(struct file * file,struct cifs_tcon * tcon,loff_t offset,loff_t len)1143 static 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 
1156 	inode = d_inode(cfile->dentry);
1157 	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 
smb3_simple_falloc(struct file * file,struct cifs_tcon * tcon,loff_t off,loff_t len,bool keep_size)1177 static 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 
1188 	inode = d_inode(cfile->dentry);
1189 	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 
smb3_fallocate(struct file * file,struct cifs_tcon * tcon,int mode,loff_t off,loff_t len)1235 static 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);
1241 	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);
1245 	} 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);
1249 
1250 	return -EOPNOTSUPP;
1251 }
1252 
1253 static void
smb2_downgrade_oplock(struct TCP_Server_Info * server,struct cifsInodeInfo * cinode,bool set_level2)1254 smb2_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 
1264 static void
smb2_set_oplock_level(struct cifsInodeInfo * cinode,__u32 oplock,unsigned int epoch,bool * purge_cache)1265 smb2_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock,
1266 		      unsigned int epoch, bool *purge_cache)
1267 {
1268 	oplock &= 0xFF;
1269 	if (oplock == SMB2_OPLOCK_LEVEL_NOCHANGE)
1270 		return;
1271 	if (oplock == SMB2_OPLOCK_LEVEL_BATCH) {
1272 		cinode->oplock = CIFS_CACHE_RHW_FLG;
1273 		cifs_dbg(FYI, "Batch Oplock granted on inode %p\n",
1274 			 &cinode->vfs_inode);
1275 	} else if (oplock == SMB2_OPLOCK_LEVEL_EXCLUSIVE) {
1276 		cinode->oplock = CIFS_CACHE_RW_FLG;
1277 		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 
1287 static void
smb21_set_oplock_level(struct cifsInodeInfo * cinode,__u32 oplock,unsigned int epoch,bool * purge_cache)1288 smb21_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock,
1289 		       unsigned int epoch, bool *purge_cache)
1290 {
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 
1316 static void
smb3_set_oplock_level(struct cifsInodeInfo * cinode,__u32 oplock,unsigned int epoch,bool * purge_cache)1317 smb3_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 
1351 static bool
smb2_is_read_op(__u32 oplock)1352 smb2_is_read_op(__u32 oplock)
1353 {
1354 	return oplock == SMB2_OPLOCK_LEVEL_II;
1355 }
1356 
1357 static bool
smb21_is_read_op(__u32 oplock)1358 smb21_is_read_op(__u32 oplock)
1359 {
1360 	return (oplock & SMB2_LEASE_READ_CACHING_HE) &&
1361 	       !(oplock & SMB2_LEASE_WRITE_CACHING_HE);
1362 }
1363 
1364 static __le32
map_oplock_to_lease(u8 oplock)1365 map_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 
1377 static char *
smb2_create_lease_buf(u8 * lease_key,u8 oplock)1378 smb2_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)));
1388 	buf->lcontext.LeaseState = map_oplock_to_lease(oplock);
1389 
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);
1396 	/* SMB2_CREATE_REQUEST_LEASE is "RqLs" */
1397 	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 
1404 static char *
smb3_create_lease_buf(u8 * lease_key,u8 oplock)1405 smb3_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);
1423 	/* SMB2_CREATE_REQUEST_LEASE is "RqLs" */
1424 	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 
1431 static __u8
smb2_parse_lease_buf(void * buf,unsigned int * epoch)1432 smb2_parse_lease_buf(void *buf, unsigned int *epoch)
1433 {
1434 	struct create_lease *lc = (struct create_lease *)buf;
1435 
1436 	*epoch = 0; /* not used */
1437 	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 
1442 static __u8
smb3_parse_lease_buf(void * buf,unsigned int * epoch)1443 smb3_parse_lease_buf(void *buf, unsigned int *epoch)
1444 {
1445 	struct create_lease_v2 *lc = (struct create_lease_v2 *)buf;
1446 
1447 	*epoch = le16_to_cpu(lc->lcontext.Epoch);
1448 	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 
1453 static unsigned int
smb2_wp_retry_size(struct inode * inode)1454 smb2_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 
1460 static bool
smb2_dir_needs_close(struct cifsFileInfo * cfile)1461 smb2_dir_needs_close(struct cifsFileInfo *cfile)
1462 {
1463 	return !cfile->invalidHandle;
1464 }
1465 
1466 struct 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,
1475 	.wait_mtu_credits = cifs_wait_mtu_credits,
1476 	.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,
1486 	.downgrade_oplock = smb2_downgrade_oplock,
1487 	.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,
1495 	.qfs_tcon = smb2_qfs_tcon,
1496 	.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,
1505 	.set_compression = smb2_set_compression,
1506 	.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,
1537 	.create_lease_buf = smb2_create_lease_buf,
1538 	.parse_lease_buf = smb2_parse_lease_buf,
1539 	.clone_range = smb2_clone_range,
1540 	.wp_retry_size = smb2_wp_retry_size,
1541 	.dir_needs_close = smb2_dir_needs_close,
1542 };
1543 
1544 struct smb_version_operations smb21_operations = {
1545 	.compare_fids = smb2_compare_fids,
1546 	.setup_request = smb2_setup_request,
1547 	.setup_async_request = smb2_setup_async_request,
1548 	.check_receive = smb2_check_receive,
1549 	.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,
1553 	.wait_mtu_credits = smb2_wait_mtu_credits,
1554 	.get_next_mid = smb2_get_next_mid,
1555 	.read_data_offset = smb2_read_data_offset,
1556 	.read_data_length = smb2_read_data_length,
1557 	.map_error = map_smb2_to_linux_error,
1558 	.find_mid = smb2_find_mid,
1559 	.check_message = smb2_check_message,
1560 	.dump_detail = smb2_dump_detail,
1561 	.clear_stats = smb2_clear_stats,
1562 	.print_stats = smb2_print_stats,
1563 	.is_oplock_break = smb2_is_valid_oplock_break,
1564 	.downgrade_oplock = smb2_downgrade_oplock,
1565 	.need_neg = smb2_need_neg,
1566 	.negotiate = smb2_negotiate,
1567 	.negotiate_wsize = smb2_negotiate_wsize,
1568 	.negotiate_rsize = smb2_negotiate_rsize,
1569 	.sess_setup = SMB2_sess_setup,
1570 	.logoff = SMB2_logoff,
1571 	.tree_connect = SMB2_tcon,
1572 	.tree_disconnect = SMB2_tdis,
1573 	.qfs_tcon = smb2_qfs_tcon,
1574 	.is_path_accessible = smb2_is_path_accessible,
1575 	.can_echo = smb2_can_echo,
1576 	.echo = SMB2_echo,
1577 	.query_path_info = smb2_query_path_info,
1578 	.get_srv_inum = smb2_get_srv_inum,
1579 	.query_file_info = smb2_query_file_info,
1580 	.set_path_size = smb2_set_path_size,
1581 	.set_file_size = smb2_set_file_size,
1582 	.set_file_info = smb2_set_file_info,
1583 	.set_compression = smb2_set_compression,
1584 	.mkdir = smb2_mkdir,
1585 	.mkdir_setinfo = smb2_mkdir_setinfo,
1586 	.rmdir = smb2_rmdir,
1587 	.unlink = smb2_unlink,
1588 	.rename = smb2_rename_path,
1589 	.create_hardlink = smb2_create_hardlink,
1590 	.query_symlink = smb2_query_symlink,
1591 	.query_mf_symlink = smb3_query_mf_symlink,
1592 	.create_mf_symlink = smb3_create_mf_symlink,
1593 	.open = smb2_open_file,
1594 	.set_fid = smb2_set_fid,
1595 	.close = smb2_close_file,
1596 	.flush = smb2_flush_file,
1597 	.async_readv = smb2_async_readv,
1598 	.async_writev = smb2_async_writev,
1599 	.sync_read = smb2_sync_read,
1600 	.sync_write = smb2_sync_write,
1601 	.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,
1605 	.is_status_pending = smb2_is_status_pending,
1606 	.oplock_response = smb2_oplock_response,
1607 	.queryfs = smb2_queryfs,
1608 	.mand_lock = smb2_mand_lock,
1609 	.mand_unlock_range = smb2_unlock_range,
1610 	.push_mand_locks = smb2_push_mandatory_locks,
1611 	.get_lease_key = smb2_get_lease_key,
1612 	.set_lease_key = smb2_set_lease_key,
1613 	.new_lease_key = smb2_new_lease_key,
1614 	.calc_signature = smb2_calc_signature,
1615 	.is_read_op = smb21_is_read_op,
1616 	.set_oplock_level = smb21_set_oplock_level,
1617 	.create_lease_buf = smb2_create_lease_buf,
1618 	.parse_lease_buf = smb2_parse_lease_buf,
1619 	.clone_range = smb2_clone_range,
1620 	.wp_retry_size = smb2_wp_retry_size,
1621 	.dir_needs_close = smb2_dir_needs_close,
1622 };
1623 
1624 struct 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,
1633 	.wait_mtu_credits = smb2_wait_mtu_credits,
1634 	.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,
1643 	.dump_share_caps = smb2_dump_share_caps,
1644 	.is_oplock_break = smb2_is_valid_oplock_break,
1645 	.downgrade_oplock = smb2_downgrade_oplock,
1646 	.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,
1654 	.qfs_tcon = smb3_qfs_tcon,
1655 	.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,
1664 	.set_compression = smb2_set_compression,
1665 	.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,
1671 	.query_symlink = smb2_query_symlink,
1672 	.query_mf_symlink = smb3_query_mf_symlink,
1673 	.create_mf_symlink = smb3_create_mf_symlink,
1674 	.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,
1695 	.generate_signingkey = generate_smb3signingkey,
1696 	.calc_signature = smb3_calc_signature,
1697 	.set_integrity  = smb3_set_integrity,
1698 	.is_read_op = smb21_is_read_op,
1699 	.set_oplock_level = smb3_set_oplock_level,
1700 	.create_lease_buf = smb3_create_lease_buf,
1701 	.parse_lease_buf = smb3_parse_lease_buf,
1702 	.clone_range = smb2_clone_range,
1703 	.duplicate_extents = smb2_duplicate_extents,
1704 	.validate_negotiate = smb3_validate_negotiate,
1705 	.wp_retry_size = smb2_wp_retry_size,
1706 	.dir_needs_close = smb2_dir_needs_close,
1707 	.fallocate = smb3_fallocate,
1708 };
1709 
1710 #ifdef CONFIG_CIFS_SMB311
1711 struct 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,
1784 	.set_integrity  = smb3_set_integrity,
1785 	.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,
1790 	.duplicate_extents = smb2_duplicate_extents,
1791 /*	.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 
1798 struct 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,
1813 	.signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED,
1814 	.signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED,
1815 	.create_lease_size = sizeof(struct create_lease),
1816 };
1817 
1818 struct smb_version_values smb21_values = {
1819 	.version_string = SMB21_VERSION_STRING,
1820 	.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,
1833 	.signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED,
1834 	.signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED,
1835 	.create_lease_size = sizeof(struct create_lease),
1836 };
1837 
1838 struct smb_version_values smb30_values = {
1839 	.version_string = SMB30_VERSION_STRING,
1840 	.protocol_id = SMB30_PROT_ID,
1841 	.req_capabilities = SMB2_GLOBAL_CAP_DFS | SMB2_GLOBAL_CAP_LEASING | SMB2_GLOBAL_CAP_LARGE_MTU | SMB2_GLOBAL_CAP_PERSISTENT_HANDLES,
1842 	.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,
1846 	.header_size = sizeof(struct smb2_hdr),
1847 	.max_header_size = MAX_SMB2_HDR_SIZE,
1848 	.read_rsp_size = sizeof(struct smb2_read_rsp) - 1,
1849 	.lock_cmd = SMB2_LOCK,
1850 	.cap_unix = 0,
1851 	.cap_nt_find = SMB2_NT_FIND,
1852 	.cap_large_files = SMB2_LARGE_FILES,
1853 	.signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED,
1854 	.signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED,
1855 	.create_lease_size = sizeof(struct create_lease_v2),
1856 };
1857 
1858 struct smb_version_values smb302_values = {
1859 	.version_string = SMB302_VERSION_STRING,
1860 	.protocol_id = SMB302_PROT_ID,
1861 	.req_capabilities = SMB2_GLOBAL_CAP_DFS | SMB2_GLOBAL_CAP_LEASING | SMB2_GLOBAL_CAP_LARGE_MTU | SMB2_GLOBAL_CAP_PERSISTENT_HANDLES,
1862 	.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,
1873 	.signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED,
1874 	.signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED,
1875 	.create_lease_size = sizeof(struct create_lease_v2),
1876 };
1877 
1878 #ifdef CONFIG_CIFS_SMB311
1879 struct smb_version_values smb311_values = {
1880 	.version_string = SMB311_VERSION_STRING,
1881 	.protocol_id = SMB311_PROT_ID,
1882 	.req_capabilities = SMB2_GLOBAL_CAP_DFS | SMB2_GLOBAL_CAP_LEASING | SMB2_GLOBAL_CAP_LARGE_MTU | SMB2_GLOBAL_CAP_PERSISTENT_HANDLES,
1883 	.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 */
1899