1
2
3
4
5
6
7
8#include <linux/pagemap.h>
9#include <linux/vfs.h>
10#include <linux/falloc.h>
11#include <linux/scatterlist.h>
12#include <linux/uuid.h>
13#include <linux/sort.h>
14#include <crypto/aead.h>
15#include <linux/fiemap.h>
16#include "cifsfs.h"
17#include "cifsglob.h"
18#include "smb2pdu.h"
19#include "smb2proto.h"
20#include "cifsproto.h"
21#include "cifs_debug.h"
22#include "cifs_unicode.h"
23#include "smb2status.h"
24#include "smb2glob.h"
25#include "cifs_ioctl.h"
26#include "smbdirect.h"
27#include "fs_context.h"
28
29
30static int
31change_conf(struct TCP_Server_Info *server)
32{
33 server->credits += server->echo_credits + server->oplock_credits;
34 server->oplock_credits = server->echo_credits = 0;
35 switch (server->credits) {
36 case 0:
37 return 0;
38 case 1:
39 server->echoes = false;
40 server->oplocks = false;
41 break;
42 case 2:
43 server->echoes = true;
44 server->oplocks = false;
45 server->echo_credits = 1;
46 break;
47 default:
48 server->echoes = true;
49 if (enable_oplocks) {
50 server->oplocks = true;
51 server->oplock_credits = 1;
52 } else
53 server->oplocks = false;
54
55 server->echo_credits = 1;
56 }
57 server->credits -= server->echo_credits + server->oplock_credits;
58 return server->credits + server->echo_credits + server->oplock_credits;
59}
60
61static void
62smb2_add_credits(struct TCP_Server_Info *server,
63 const struct cifs_credits *credits, const int optype)
64{
65 int *val, rc = -1;
66 int scredits, in_flight;
67 unsigned int add = credits->value;
68 unsigned int instance = credits->instance;
69 bool reconnect_detected = false;
70 bool reconnect_with_invalid_credits = false;
71
72 spin_lock(&server->req_lock);
73 val = server->ops->get_credits_field(server, optype);
74
75
76 if (((optype & CIFS_OP_MASK) == CIFS_NEG_OP) && (*val != 0))
77 reconnect_with_invalid_credits = true;
78
79 if ((instance == 0) || (instance == server->reconnect_instance))
80 *val += add;
81 else
82 reconnect_detected = true;
83
84 if (*val > 65000) {
85 *val = 65000;
86 pr_warn_once("server overflowed SMB3 credits\n");
87 }
88 server->in_flight--;
89 if (server->in_flight == 0 &&
90 ((optype & CIFS_OP_MASK) != CIFS_NEG_OP) &&
91 ((optype & CIFS_OP_MASK) != CIFS_SESS_OP))
92 rc = change_conf(server);
93
94
95
96
97 else if (server->in_flight > 0 && server->oplock_credits == 0 &&
98 server->oplocks) {
99 if (server->credits > 1) {
100 server->credits--;
101 server->oplock_credits++;
102 }
103 }
104 scredits = *val;
105 in_flight = server->in_flight;
106 spin_unlock(&server->req_lock);
107 wake_up(&server->request_q);
108
109 if (reconnect_detected) {
110 trace_smb3_reconnect_detected(server->CurrentMid,
111 server->conn_id, server->hostname, scredits, add, in_flight);
112
113 cifs_dbg(FYI, "trying to put %d credits from the old server instance %d\n",
114 add, instance);
115 }
116
117 if (reconnect_with_invalid_credits) {
118 trace_smb3_reconnect_with_invalid_credits(server->CurrentMid,
119 server->conn_id, server->hostname, scredits, add, in_flight);
120 cifs_dbg(FYI, "Negotiate operation when server credits is non-zero. Optype: %d, server credits: %d, credits added: %d\n",
121 optype, scredits, add);
122 }
123
124 if (server->tcpStatus == CifsNeedReconnect
125 || server->tcpStatus == CifsExiting)
126 return;
127
128 switch (rc) {
129 case -1:
130
131 break;
132 case 0:
133 cifs_server_dbg(VFS, "Possible client or server bug - zero credits\n");
134 break;
135 case 1:
136 cifs_server_dbg(VFS, "disabling echoes and oplocks\n");
137 break;
138 case 2:
139 cifs_dbg(FYI, "disabling oplocks\n");
140 break;
141 default:
142
143 break;
144 }
145
146 trace_smb3_add_credits(server->CurrentMid,
147 server->conn_id, server->hostname, scredits, add, in_flight);
148 cifs_dbg(FYI, "%s: added %u credits total=%d\n", __func__, add, scredits);
149}
150
151static void
152smb2_set_credits(struct TCP_Server_Info *server, const int val)
153{
154 int scredits, in_flight;
155
156 spin_lock(&server->req_lock);
157 server->credits = val;
158 if (val == 1)
159 server->reconnect_instance++;
160 scredits = server->credits;
161 in_flight = server->in_flight;
162 spin_unlock(&server->req_lock);
163
164 trace_smb3_set_credits(server->CurrentMid,
165 server->conn_id, server->hostname, scredits, val, in_flight);
166 cifs_dbg(FYI, "%s: set %u credits\n", __func__, val);
167
168
169 if (val == 1)
170 cifs_dbg(FYI, "set credits to 1 due to smb2 reconnect\n");
171}
172
173static int *
174smb2_get_credits_field(struct TCP_Server_Info *server, const int optype)
175{
176 switch (optype) {
177 case CIFS_ECHO_OP:
178 return &server->echo_credits;
179 case CIFS_OBREAK_OP:
180 return &server->oplock_credits;
181 default:
182 return &server->credits;
183 }
184}
185
186static unsigned int
187smb2_get_credits(struct mid_q_entry *mid)
188{
189 return mid->credits_received;
190}
191
192static int
193smb2_wait_mtu_credits(struct TCP_Server_Info *server, unsigned int size,
194 unsigned int *num, struct cifs_credits *credits)
195{
196 int rc = 0;
197 unsigned int scredits, in_flight;
198
199 spin_lock(&server->req_lock);
200 while (1) {
201 if (server->credits <= 0) {
202 spin_unlock(&server->req_lock);
203 cifs_num_waiters_inc(server);
204 rc = wait_event_killable(server->request_q,
205 has_credits(server, &server->credits, 1));
206 cifs_num_waiters_dec(server);
207 if (rc)
208 return rc;
209 spin_lock(&server->req_lock);
210 } else {
211 if (server->tcpStatus == CifsExiting) {
212 spin_unlock(&server->req_lock);
213 return -ENOENT;
214 }
215
216 scredits = server->credits;
217
218 if (scredits <= 8) {
219 *num = SMB2_MAX_BUFFER_SIZE;
220 credits->value = 0;
221 credits->instance = 0;
222 break;
223 }
224
225
226 scredits -= 8;
227 *num = min_t(unsigned int, size,
228 scredits * SMB2_MAX_BUFFER_SIZE);
229
230 credits->value =
231 DIV_ROUND_UP(*num, SMB2_MAX_BUFFER_SIZE);
232 credits->instance = server->reconnect_instance;
233 server->credits -= credits->value;
234 server->in_flight++;
235 if (server->in_flight > server->max_in_flight)
236 server->max_in_flight = server->in_flight;
237 break;
238 }
239 }
240 scredits = server->credits;
241 in_flight = server->in_flight;
242 spin_unlock(&server->req_lock);
243
244 trace_smb3_add_credits(server->CurrentMid,
245 server->conn_id, server->hostname, scredits, -(credits->value), in_flight);
246 cifs_dbg(FYI, "%s: removed %u credits total=%d\n",
247 __func__, credits->value, scredits);
248
249 return rc;
250}
251
252static int
253smb2_adjust_credits(struct TCP_Server_Info *server,
254 struct cifs_credits *credits,
255 const unsigned int payload_size)
256{
257 int new_val = DIV_ROUND_UP(payload_size, SMB2_MAX_BUFFER_SIZE);
258 int scredits, in_flight;
259
260 if (!credits->value || credits->value == new_val)
261 return 0;
262
263 if (credits->value < new_val) {
264 trace_smb3_too_many_credits(server->CurrentMid,
265 server->conn_id, server->hostname, 0, credits->value - new_val, 0);
266 cifs_server_dbg(VFS, "request has less credits (%d) than required (%d)",
267 credits->value, new_val);
268
269 return -ENOTSUPP;
270 }
271
272 spin_lock(&server->req_lock);
273
274 if (server->reconnect_instance != credits->instance) {
275 scredits = server->credits;
276 in_flight = server->in_flight;
277 spin_unlock(&server->req_lock);
278
279 trace_smb3_reconnect_detected(server->CurrentMid,
280 server->conn_id, server->hostname, scredits,
281 credits->value - new_val, in_flight);
282 cifs_server_dbg(VFS, "trying to return %d credits to old session\n",
283 credits->value - new_val);
284 return -EAGAIN;
285 }
286
287 server->credits += credits->value - new_val;
288 scredits = server->credits;
289 in_flight = server->in_flight;
290 spin_unlock(&server->req_lock);
291 wake_up(&server->request_q);
292
293 trace_smb3_add_credits(server->CurrentMid,
294 server->conn_id, server->hostname, scredits,
295 credits->value - new_val, in_flight);
296 cifs_dbg(FYI, "%s: adjust added %u credits total=%d\n",
297 __func__, credits->value - new_val, scredits);
298
299 credits->value = new_val;
300
301 return 0;
302}
303
304static __u64
305smb2_get_next_mid(struct TCP_Server_Info *server)
306{
307 __u64 mid;
308
309 spin_lock(&GlobalMid_Lock);
310 mid = server->CurrentMid++;
311 spin_unlock(&GlobalMid_Lock);
312 return mid;
313}
314
315static void
316smb2_revert_current_mid(struct TCP_Server_Info *server, const unsigned int val)
317{
318 spin_lock(&GlobalMid_Lock);
319 if (server->CurrentMid >= val)
320 server->CurrentMid -= val;
321 spin_unlock(&GlobalMid_Lock);
322}
323
324static struct mid_q_entry *
325__smb2_find_mid(struct TCP_Server_Info *server, char *buf, bool dequeue)
326{
327 struct mid_q_entry *mid;
328 struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)buf;
329 __u64 wire_mid = le64_to_cpu(shdr->MessageId);
330
331 if (shdr->ProtocolId == SMB2_TRANSFORM_PROTO_NUM) {
332 cifs_server_dbg(VFS, "Encrypted frame parsing not supported yet\n");
333 return NULL;
334 }
335
336 spin_lock(&GlobalMid_Lock);
337 list_for_each_entry(mid, &server->pending_mid_q, qhead) {
338 if ((mid->mid == wire_mid) &&
339 (mid->mid_state == MID_REQUEST_SUBMITTED) &&
340 (mid->command == shdr->Command)) {
341 kref_get(&mid->refcount);
342 if (dequeue) {
343 list_del_init(&mid->qhead);
344 mid->mid_flags |= MID_DELETED;
345 }
346 spin_unlock(&GlobalMid_Lock);
347 return mid;
348 }
349 }
350 spin_unlock(&GlobalMid_Lock);
351 return NULL;
352}
353
354static struct mid_q_entry *
355smb2_find_mid(struct TCP_Server_Info *server, char *buf)
356{
357 return __smb2_find_mid(server, buf, false);
358}
359
360static struct mid_q_entry *
361smb2_find_dequeue_mid(struct TCP_Server_Info *server, char *buf)
362{
363 return __smb2_find_mid(server, buf, true);
364}
365
366static void
367smb2_dump_detail(void *buf, struct TCP_Server_Info *server)
368{
369#ifdef CONFIG_CIFS_DEBUG2
370 struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)buf;
371
372 cifs_server_dbg(VFS, "Cmd: %d Err: 0x%x Flags: 0x%x Mid: %llu Pid: %d\n",
373 shdr->Command, shdr->Status, shdr->Flags, shdr->MessageId,
374 shdr->ProcessId);
375 cifs_server_dbg(VFS, "smb buf %p len %u\n", buf,
376 server->ops->calc_smb_size(buf, server));
377#endif
378}
379
380static bool
381smb2_need_neg(struct TCP_Server_Info *server)
382{
383 return server->max_read == 0;
384}
385
386static int
387smb2_negotiate(const unsigned int xid, struct cifs_ses *ses)
388{
389 int rc;
390
391 spin_lock(&GlobalMid_Lock);
392 cifs_ses_server(ses)->CurrentMid = 0;
393 spin_unlock(&GlobalMid_Lock);
394 rc = SMB2_negotiate(xid, ses);
395
396 if (rc == -EAGAIN)
397 rc = -EHOSTDOWN;
398 return rc;
399}
400
401static unsigned int
402smb2_negotiate_wsize(struct cifs_tcon *tcon, struct smb3_fs_context *ctx)
403{
404 struct TCP_Server_Info *server = tcon->ses->server;
405 unsigned int wsize;
406
407
408 wsize = ctx->wsize ? ctx->wsize : CIFS_DEFAULT_IOSIZE;
409 wsize = min_t(unsigned int, wsize, server->max_write);
410 if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))
411 wsize = min_t(unsigned int, wsize, SMB2_MAX_BUFFER_SIZE);
412
413 return wsize;
414}
415
416static unsigned int
417smb3_negotiate_wsize(struct cifs_tcon *tcon, struct smb3_fs_context *ctx)
418{
419 struct TCP_Server_Info *server = tcon->ses->server;
420 unsigned int wsize;
421
422
423 wsize = ctx->wsize ? ctx->wsize : SMB3_DEFAULT_IOSIZE;
424 wsize = min_t(unsigned int, wsize, server->max_write);
425#ifdef CONFIG_CIFS_SMB_DIRECT
426 if (server->rdma) {
427 if (server->sign)
428
429
430
431
432 wsize = min_t(unsigned int,
433 wsize,
434 server->smbd_conn->max_fragmented_send_size -
435 SMB2_READWRITE_PDU_HEADER_SIZE -
436 sizeof(struct smb2_transform_hdr));
437 else
438 wsize = min_t(unsigned int,
439 wsize, server->smbd_conn->max_readwrite_size);
440 }
441#endif
442 if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))
443 wsize = min_t(unsigned int, wsize, SMB2_MAX_BUFFER_SIZE);
444
445 return wsize;
446}
447
448static unsigned int
449smb2_negotiate_rsize(struct cifs_tcon *tcon, struct smb3_fs_context *ctx)
450{
451 struct TCP_Server_Info *server = tcon->ses->server;
452 unsigned int rsize;
453
454
455 rsize = ctx->rsize ? ctx->rsize : CIFS_DEFAULT_IOSIZE;
456 rsize = min_t(unsigned int, rsize, server->max_read);
457
458 if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))
459 rsize = min_t(unsigned int, rsize, SMB2_MAX_BUFFER_SIZE);
460
461 return rsize;
462}
463
464static unsigned int
465smb3_negotiate_rsize(struct cifs_tcon *tcon, struct smb3_fs_context *ctx)
466{
467 struct TCP_Server_Info *server = tcon->ses->server;
468 unsigned int rsize;
469
470
471 rsize = ctx->rsize ? ctx->rsize : SMB3_DEFAULT_IOSIZE;
472 rsize = min_t(unsigned int, rsize, server->max_read);
473#ifdef CONFIG_CIFS_SMB_DIRECT
474 if (server->rdma) {
475 if (server->sign)
476
477
478
479
480 rsize = min_t(unsigned int,
481 rsize,
482 server->smbd_conn->max_fragmented_recv_size -
483 SMB2_READWRITE_PDU_HEADER_SIZE -
484 sizeof(struct smb2_transform_hdr));
485 else
486 rsize = min_t(unsigned int,
487 rsize, server->smbd_conn->max_readwrite_size);
488 }
489#endif
490
491 if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))
492 rsize = min_t(unsigned int, rsize, SMB2_MAX_BUFFER_SIZE);
493
494 return rsize;
495}
496
497static int
498parse_server_interfaces(struct network_interface_info_ioctl_rsp *buf,
499 size_t buf_len,
500 struct cifs_server_iface **iface_list,
501 size_t *iface_count)
502{
503 struct network_interface_info_ioctl_rsp *p;
504 struct sockaddr_in *addr4;
505 struct sockaddr_in6 *addr6;
506 struct iface_info_ipv4 *p4;
507 struct iface_info_ipv6 *p6;
508 struct cifs_server_iface *info;
509 ssize_t bytes_left;
510 size_t next = 0;
511 int nb_iface = 0;
512 int rc = 0;
513
514 *iface_list = NULL;
515 *iface_count = 0;
516
517
518
519
520
521 bytes_left = buf_len;
522 p = buf;
523 while (bytes_left >= sizeof(*p)) {
524 nb_iface++;
525 next = le32_to_cpu(p->Next);
526 if (!next) {
527 bytes_left -= sizeof(*p);
528 break;
529 }
530 p = (struct network_interface_info_ioctl_rsp *)((u8 *)p+next);
531 bytes_left -= next;
532 }
533
534 if (!nb_iface) {
535 cifs_dbg(VFS, "%s: malformed interface info\n", __func__);
536 rc = -EINVAL;
537 goto out;
538 }
539
540
541 if ((bytes_left > 8) || p->Next)
542 cifs_dbg(VFS, "%s: incomplete interface info\n", __func__);
543
544
545
546
547
548
549 *iface_list = kcalloc(nb_iface, sizeof(**iface_list), GFP_KERNEL);
550 if (!*iface_list) {
551 rc = -ENOMEM;
552 goto out;
553 }
554
555 info = *iface_list;
556 bytes_left = buf_len;
557 p = buf;
558 while (bytes_left >= sizeof(*p)) {
559 info->speed = le64_to_cpu(p->LinkSpeed);
560 info->rdma_capable = le32_to_cpu(p->Capability & RDMA_CAPABLE) ? 1 : 0;
561 info->rss_capable = le32_to_cpu(p->Capability & RSS_CAPABLE) ? 1 : 0;
562
563 cifs_dbg(FYI, "%s: adding iface %zu\n", __func__, *iface_count);
564 cifs_dbg(FYI, "%s: speed %zu bps\n", __func__, info->speed);
565 cifs_dbg(FYI, "%s: capabilities 0x%08x\n", __func__,
566 le32_to_cpu(p->Capability));
567
568 switch (p->Family) {
569
570
571
572
573
574 case INTERNETWORK:
575 addr4 = (struct sockaddr_in *)&info->sockaddr;
576 p4 = (struct iface_info_ipv4 *)p->Buffer;
577 addr4->sin_family = AF_INET;
578 memcpy(&addr4->sin_addr, &p4->IPv4Address, 4);
579
580
581 addr4->sin_port = cpu_to_be16(CIFS_PORT);
582
583 cifs_dbg(FYI, "%s: ipv4 %pI4\n", __func__,
584 &addr4->sin_addr);
585 break;
586 case INTERNETWORKV6:
587 addr6 = (struct sockaddr_in6 *)&info->sockaddr;
588 p6 = (struct iface_info_ipv6 *)p->Buffer;
589 addr6->sin6_family = AF_INET6;
590 memcpy(&addr6->sin6_addr, &p6->IPv6Address, 16);
591
592
593 addr6->sin6_flowinfo = 0;
594 addr6->sin6_scope_id = 0;
595 addr6->sin6_port = cpu_to_be16(CIFS_PORT);
596
597 cifs_dbg(FYI, "%s: ipv6 %pI6\n", __func__,
598 &addr6->sin6_addr);
599 break;
600 default:
601 cifs_dbg(VFS,
602 "%s: skipping unsupported socket family\n",
603 __func__);
604 goto next_iface;
605 }
606
607 (*iface_count)++;
608 info++;
609next_iface:
610 next = le32_to_cpu(p->Next);
611 if (!next)
612 break;
613 p = (struct network_interface_info_ioctl_rsp *)((u8 *)p+next);
614 bytes_left -= next;
615 }
616
617 if (!*iface_count) {
618 rc = -EINVAL;
619 goto out;
620 }
621
622out:
623 if (rc) {
624 kfree(*iface_list);
625 *iface_count = 0;
626 *iface_list = NULL;
627 }
628 return rc;
629}
630
631static int compare_iface(const void *ia, const void *ib)
632{
633 const struct cifs_server_iface *a = (struct cifs_server_iface *)ia;
634 const struct cifs_server_iface *b = (struct cifs_server_iface *)ib;
635
636 return a->speed == b->speed ? 0 : (a->speed > b->speed ? -1 : 1);
637}
638
639static int
640SMB3_request_interfaces(const unsigned int xid, struct cifs_tcon *tcon)
641{
642 int rc;
643 unsigned int ret_data_len = 0;
644 struct network_interface_info_ioctl_rsp *out_buf = NULL;
645 struct cifs_server_iface *iface_list;
646 size_t iface_count;
647 struct cifs_ses *ses = tcon->ses;
648
649 rc = SMB2_ioctl(xid, tcon, NO_FILE_ID, NO_FILE_ID,
650 FSCTL_QUERY_NETWORK_INTERFACE_INFO, true ,
651 NULL , 0 ,
652 CIFSMaxBufSize, (char **)&out_buf, &ret_data_len);
653 if (rc == -EOPNOTSUPP) {
654 cifs_dbg(FYI,
655 "server does not support query network interfaces\n");
656 goto out;
657 } else if (rc != 0) {
658 cifs_tcon_dbg(VFS, "error %d on ioctl to get interface list\n", rc);
659 goto out;
660 }
661
662 rc = parse_server_interfaces(out_buf, ret_data_len,
663 &iface_list, &iface_count);
664 if (rc)
665 goto out;
666
667
668 sort(iface_list, iface_count, sizeof(*iface_list), compare_iface, NULL);
669
670 spin_lock(&ses->iface_lock);
671 kfree(ses->iface_list);
672 ses->iface_list = iface_list;
673 ses->iface_count = iface_count;
674 ses->iface_last_update = jiffies;
675 spin_unlock(&ses->iface_lock);
676
677out:
678 kfree(out_buf);
679 return rc;
680}
681
682static void
683smb2_close_cached_fid(struct kref *ref)
684{
685 struct cached_fid *cfid = container_of(ref, struct cached_fid,
686 refcount);
687
688 if (cfid->is_valid) {
689 cifs_dbg(FYI, "clear cached root file handle\n");
690 SMB2_close(0, cfid->tcon, cfid->fid->persistent_fid,
691 cfid->fid->volatile_fid);
692 }
693
694
695
696
697
698
699 cfid->is_valid = false;
700 cfid->file_all_info_is_valid = false;
701 cfid->has_lease = false;
702 if (cfid->dentry) {
703 dput(cfid->dentry);
704 cfid->dentry = NULL;
705 }
706}
707
708void close_cached_dir(struct cached_fid *cfid)
709{
710 mutex_lock(&cfid->fid_mutex);
711 kref_put(&cfid->refcount, smb2_close_cached_fid);
712 mutex_unlock(&cfid->fid_mutex);
713}
714
715void close_cached_dir_lease_locked(struct cached_fid *cfid)
716{
717 if (cfid->has_lease) {
718 cfid->has_lease = false;
719 kref_put(&cfid->refcount, smb2_close_cached_fid);
720 }
721}
722
723void close_cached_dir_lease(struct cached_fid *cfid)
724{
725 mutex_lock(&cfid->fid_mutex);
726 close_cached_dir_lease_locked(cfid);
727 mutex_unlock(&cfid->fid_mutex);
728}
729
730void
731smb2_cached_lease_break(struct work_struct *work)
732{
733 struct cached_fid *cfid = container_of(work,
734 struct cached_fid, lease_break);
735
736 close_cached_dir_lease(cfid);
737}
738
739
740
741
742
743int open_cached_dir(unsigned int xid, struct cifs_tcon *tcon,
744 const char *path,
745 struct cifs_sb_info *cifs_sb,
746 struct cached_fid **cfid)
747{
748 struct cifs_ses *ses = tcon->ses;
749 struct TCP_Server_Info *server = ses->server;
750 struct cifs_open_parms oparms;
751 struct smb2_create_rsp *o_rsp = NULL;
752 struct smb2_query_info_rsp *qi_rsp = NULL;
753 int resp_buftype[2];
754 struct smb_rqst rqst[2];
755 struct kvec rsp_iov[2];
756 struct kvec open_iov[SMB2_CREATE_IOV_SIZE];
757 struct kvec qi_iov[1];
758 int rc, flags = 0;
759 __le16 utf16_path = 0;
760 u8 oplock = SMB2_OPLOCK_LEVEL_II;
761 struct cifs_fid *pfid;
762 struct dentry *dentry;
763
764 if (tcon->nohandlecache)
765 return -ENOTSUPP;
766
767 if (cifs_sb->root == NULL)
768 return -ENOENT;
769
770 if (strlen(path))
771 return -ENOENT;
772
773 dentry = cifs_sb->root;
774
775 mutex_lock(&tcon->crfid.fid_mutex);
776 if (tcon->crfid.is_valid) {
777 cifs_dbg(FYI, "found a cached root file handle\n");
778 *cfid = &tcon->crfid;
779 kref_get(&tcon->crfid.refcount);
780 mutex_unlock(&tcon->crfid.fid_mutex);
781 return 0;
782 }
783
784
785
786
787
788
789
790
791 mutex_unlock(&tcon->crfid.fid_mutex);
792
793 if (smb3_encryption_required(tcon))
794 flags |= CIFS_TRANSFORM_REQ;
795
796 if (!server->ops->new_lease_key)
797 return -EIO;
798
799 pfid = tcon->crfid.fid;
800 server->ops->new_lease_key(pfid);
801
802 memset(rqst, 0, sizeof(rqst));
803 resp_buftype[0] = resp_buftype[1] = CIFS_NO_BUFFER;
804 memset(rsp_iov, 0, sizeof(rsp_iov));
805
806
807 memset(&open_iov, 0, sizeof(open_iov));
808 rqst[0].rq_iov = open_iov;
809 rqst[0].rq_nvec = SMB2_CREATE_IOV_SIZE;
810
811 oparms.tcon = tcon;
812 oparms.create_options = cifs_create_options(cifs_sb, 0);
813 oparms.desired_access = FILE_READ_ATTRIBUTES;
814 oparms.disposition = FILE_OPEN;
815 oparms.fid = pfid;
816 oparms.reconnect = false;
817
818 rc = SMB2_open_init(tcon, server,
819 &rqst[0], &oplock, &oparms, &utf16_path);
820 if (rc)
821 goto oshr_free;
822 smb2_set_next_command(tcon, &rqst[0]);
823
824 memset(&qi_iov, 0, sizeof(qi_iov));
825 rqst[1].rq_iov = qi_iov;
826 rqst[1].rq_nvec = 1;
827
828 rc = SMB2_query_info_init(tcon, server,
829 &rqst[1], COMPOUND_FID,
830 COMPOUND_FID, FILE_ALL_INFORMATION,
831 SMB2_O_INFO_FILE, 0,
832 sizeof(struct smb2_file_all_info) +
833 PATH_MAX * 2, 0, NULL);
834 if (rc)
835 goto oshr_free;
836
837 smb2_set_related(&rqst[1]);
838
839 rc = compound_send_recv(xid, ses, server,
840 flags, 2, rqst,
841 resp_buftype, rsp_iov);
842 mutex_lock(&tcon->crfid.fid_mutex);
843
844
845
846
847
848
849 if (tcon->crfid.is_valid) {
850
851
852
853 struct cifs_fid fid = {
854 .persistent_fid = pfid->persistent_fid,
855 .volatile_fid = pfid->volatile_fid,
856 };
857
858
859
860
861
862 kref_get(&tcon->crfid.refcount);
863
864 mutex_unlock(&tcon->crfid.fid_mutex);
865
866 if (rc == 0) {
867
868 SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
869 }
870 rc = 0;
871 goto oshr_free;
872 }
873
874
875
876 if (rc) {
877 if (rc == -EREMCHG) {
878 tcon->need_reconnect = true;
879 pr_warn_once("server share %s deleted\n",
880 tcon->treeName);
881 }
882 goto oshr_exit;
883 }
884
885 atomic_inc(&tcon->num_remote_opens);
886
887 o_rsp = (struct smb2_create_rsp *)rsp_iov[0].iov_base;
888 oparms.fid->persistent_fid = o_rsp->PersistentFileId;
889 oparms.fid->volatile_fid = o_rsp->VolatileFileId;
890#ifdef CONFIG_CIFS_DEBUG2
891 oparms.fid->mid = le64_to_cpu(o_rsp->sync_hdr.MessageId);
892#endif
893
894 tcon->crfid.tcon = tcon;
895 tcon->crfid.is_valid = true;
896 tcon->crfid.dentry = dentry;
897 dget(dentry);
898 kref_init(&tcon->crfid.refcount);
899
900
901 if (o_rsp->OplockLevel == SMB2_OPLOCK_LEVEL_LEASE) {
902
903
904
905
906 kref_get(&tcon->crfid.refcount);
907 tcon->crfid.has_lease = true;
908 smb2_parse_contexts(server, o_rsp,
909 &oparms.fid->epoch,
910 oparms.fid->lease_key, &oplock,
911 NULL, NULL);
912 } else
913 goto oshr_exit;
914
915 qi_rsp = (struct smb2_query_info_rsp *)rsp_iov[1].iov_base;
916 if (le32_to_cpu(qi_rsp->OutputBufferLength) < sizeof(struct smb2_file_all_info))
917 goto oshr_exit;
918 if (!smb2_validate_and_copy_iov(
919 le16_to_cpu(qi_rsp->OutputBufferOffset),
920 sizeof(struct smb2_file_all_info),
921 &rsp_iov[1], sizeof(struct smb2_file_all_info),
922 (char *)&tcon->crfid.file_all_info))
923 tcon->crfid.file_all_info_is_valid = true;
924 tcon->crfid.time = jiffies;
925
926
927oshr_exit:
928 mutex_unlock(&tcon->crfid.fid_mutex);
929oshr_free:
930 SMB2_open_free(&rqst[0]);
931 SMB2_query_info_free(&rqst[1]);
932 free_rsp_buf(resp_buftype[0], rsp_iov[0].iov_base);
933 free_rsp_buf(resp_buftype[1], rsp_iov[1].iov_base);
934 if (rc == 0)
935 *cfid = &tcon->crfid;
936 return rc;
937}
938
939int open_cached_dir_by_dentry(struct cifs_tcon *tcon,
940 struct dentry *dentry,
941 struct cached_fid **cfid)
942{
943 mutex_lock(&tcon->crfid.fid_mutex);
944 if (tcon->crfid.dentry == dentry) {
945 cifs_dbg(FYI, "found a cached root file handle by dentry\n");
946 *cfid = &tcon->crfid;
947 kref_get(&tcon->crfid.refcount);
948 mutex_unlock(&tcon->crfid.fid_mutex);
949 return 0;
950 }
951 mutex_unlock(&tcon->crfid.fid_mutex);
952 return -ENOENT;
953}
954
955static void
956smb3_qfs_tcon(const unsigned int xid, struct cifs_tcon *tcon,
957 struct cifs_sb_info *cifs_sb)
958{
959 int rc;
960 __le16 srch_path = 0;
961 u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
962 struct cifs_open_parms oparms;
963 struct cifs_fid fid;
964 struct cached_fid *cfid = NULL;
965
966 oparms.tcon = tcon;
967 oparms.desired_access = FILE_READ_ATTRIBUTES;
968 oparms.disposition = FILE_OPEN;
969 oparms.create_options = cifs_create_options(cifs_sb, 0);
970 oparms.fid = &fid;
971 oparms.reconnect = false;
972
973 rc = open_cached_dir(xid, tcon, "", cifs_sb, &cfid);
974 if (rc == 0)
975 memcpy(&fid, cfid->fid, sizeof(struct cifs_fid));
976 else
977 rc = SMB2_open(xid, &oparms, &srch_path, &oplock, NULL, NULL,
978 NULL, NULL);
979 if (rc)
980 return;
981
982 SMB3_request_interfaces(xid, tcon);
983
984 SMB2_QFS_attr(xid, tcon, fid.persistent_fid, fid.volatile_fid,
985 FS_ATTRIBUTE_INFORMATION);
986 SMB2_QFS_attr(xid, tcon, fid.persistent_fid, fid.volatile_fid,
987 FS_DEVICE_INFORMATION);
988 SMB2_QFS_attr(xid, tcon, fid.persistent_fid, fid.volatile_fid,
989 FS_VOLUME_INFORMATION);
990 SMB2_QFS_attr(xid, tcon, fid.persistent_fid, fid.volatile_fid,
991 FS_SECTOR_SIZE_INFORMATION);
992 if (cfid == NULL)
993 SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
994 else
995 close_cached_dir(cfid);
996}
997
998static void
999smb2_qfs_tcon(const unsigned int xid, struct cifs_tcon *tcon,
1000 struct cifs_sb_info *cifs_sb)
1001{
1002 int rc;
1003 __le16 srch_path = 0;
1004 u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
1005 struct cifs_open_parms oparms;
1006 struct cifs_fid fid;
1007
1008 oparms.tcon = tcon;
1009 oparms.desired_access = FILE_READ_ATTRIBUTES;
1010 oparms.disposition = FILE_OPEN;
1011 oparms.create_options = cifs_create_options(cifs_sb, 0);
1012 oparms.fid = &fid;
1013 oparms.reconnect = false;
1014
1015 rc = SMB2_open(xid, &oparms, &srch_path, &oplock, NULL, NULL,
1016 NULL, NULL);
1017 if (rc)
1018 return;
1019
1020 SMB2_QFS_attr(xid, tcon, fid.persistent_fid, fid.volatile_fid,
1021 FS_ATTRIBUTE_INFORMATION);
1022 SMB2_QFS_attr(xid, tcon, fid.persistent_fid, fid.volatile_fid,
1023 FS_DEVICE_INFORMATION);
1024 SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
1025}
1026
1027static int
1028smb2_is_path_accessible(const unsigned int xid, struct cifs_tcon *tcon,
1029 struct cifs_sb_info *cifs_sb, const char *full_path)
1030{
1031 int rc;
1032 __le16 *utf16_path;
1033 __u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
1034 struct cifs_open_parms oparms;
1035 struct cifs_fid fid;
1036
1037 if ((*full_path == 0) && tcon->crfid.is_valid)
1038 return 0;
1039
1040 utf16_path = cifs_convert_path_to_utf16(full_path, cifs_sb);
1041 if (!utf16_path)
1042 return -ENOMEM;
1043
1044 oparms.tcon = tcon;
1045 oparms.desired_access = FILE_READ_ATTRIBUTES;
1046 oparms.disposition = FILE_OPEN;
1047 oparms.create_options = cifs_create_options(cifs_sb, 0);
1048 oparms.fid = &fid;
1049 oparms.reconnect = false;
1050
1051 rc = SMB2_open(xid, &oparms, utf16_path, &oplock, NULL, NULL, NULL,
1052 NULL);
1053 if (rc) {
1054 kfree(utf16_path);
1055 return rc;
1056 }
1057
1058 rc = SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
1059 kfree(utf16_path);
1060 return rc;
1061}
1062
1063static int
1064smb2_get_srv_inum(const unsigned int xid, struct cifs_tcon *tcon,
1065 struct cifs_sb_info *cifs_sb, const char *full_path,
1066 u64 *uniqueid, FILE_ALL_INFO *data)
1067{
1068 *uniqueid = le64_to_cpu(data->IndexNumber);
1069 return 0;
1070}
1071
1072static int
1073smb2_query_file_info(const unsigned int xid, struct cifs_tcon *tcon,
1074 struct cifs_fid *fid, FILE_ALL_INFO *data)
1075{
1076 int rc;
1077 struct smb2_file_all_info *smb2_data;
1078
1079 smb2_data = kzalloc(sizeof(struct smb2_file_all_info) + PATH_MAX * 2,
1080 GFP_KERNEL);
1081 if (smb2_data == NULL)
1082 return -ENOMEM;
1083
1084 rc = SMB2_query_info(xid, tcon, fid->persistent_fid, fid->volatile_fid,
1085 smb2_data);
1086 if (!rc)
1087 move_smb2_info_to_cifs(data, smb2_data);
1088 kfree(smb2_data);
1089 return rc;
1090}
1091
1092#ifdef CONFIG_CIFS_XATTR
1093static ssize_t
1094move_smb2_ea_to_cifs(char *dst, size_t dst_size,
1095 struct smb2_file_full_ea_info *src, size_t src_size,
1096 const unsigned char *ea_name)
1097{
1098 int rc = 0;
1099 unsigned int ea_name_len = ea_name ? strlen(ea_name) : 0;
1100 char *name, *value;
1101 size_t buf_size = dst_size;
1102 size_t name_len, value_len, user_name_len;
1103
1104 while (src_size > 0) {
1105 name = &src->ea_data[0];
1106 name_len = (size_t)src->ea_name_length;
1107 value = &src->ea_data[src->ea_name_length + 1];
1108 value_len = (size_t)le16_to_cpu(src->ea_value_length);
1109
1110 if (name_len == 0)
1111 break;
1112
1113 if (src_size < 8 + name_len + 1 + value_len) {
1114 cifs_dbg(FYI, "EA entry goes beyond length of list\n");
1115 rc = -EIO;
1116 goto out;
1117 }
1118
1119 if (ea_name) {
1120 if (ea_name_len == name_len &&
1121 memcmp(ea_name, name, name_len) == 0) {
1122 rc = value_len;
1123 if (dst_size == 0)
1124 goto out;
1125 if (dst_size < value_len) {
1126 rc = -ERANGE;
1127 goto out;
1128 }
1129 memcpy(dst, value, value_len);
1130 goto out;
1131 }
1132 } else {
1133
1134 user_name_len = 5 + 1 + name_len;
1135
1136 if (buf_size == 0) {
1137
1138 rc += user_name_len;
1139 } else if (dst_size >= user_name_len) {
1140 dst_size -= user_name_len;
1141 memcpy(dst, "user.", 5);
1142 dst += 5;
1143 memcpy(dst, src->ea_data, name_len);
1144 dst += name_len;
1145 *dst = 0;
1146 ++dst;
1147 rc += user_name_len;
1148 } else {
1149
1150 rc = -ERANGE;
1151 break;
1152 }
1153 }
1154
1155 if (!src->next_entry_offset)
1156 break;
1157
1158 if (src_size < le32_to_cpu(src->next_entry_offset)) {
1159
1160 rc = -ERANGE;
1161 break;
1162 }
1163 src_size -= le32_to_cpu(src->next_entry_offset);
1164 src = (void *)((char *)src +
1165 le32_to_cpu(src->next_entry_offset));
1166 }
1167
1168
1169 if (ea_name)
1170 rc = -ENODATA;
1171
1172out:
1173 return (ssize_t)rc;
1174}
1175
1176static ssize_t
1177smb2_query_eas(const unsigned int xid, struct cifs_tcon *tcon,
1178 const unsigned char *path, const unsigned char *ea_name,
1179 char *ea_data, size_t buf_size,
1180 struct cifs_sb_info *cifs_sb)
1181{
1182 int rc;
1183 __le16 *utf16_path;
1184 struct kvec rsp_iov = {NULL, 0};
1185 int buftype = CIFS_NO_BUFFER;
1186 struct smb2_query_info_rsp *rsp;
1187 struct smb2_file_full_ea_info *info = NULL;
1188
1189 utf16_path = cifs_convert_path_to_utf16(path, cifs_sb);
1190 if (!utf16_path)
1191 return -ENOMEM;
1192
1193 rc = smb2_query_info_compound(xid, tcon, utf16_path,
1194 FILE_READ_EA,
1195 FILE_FULL_EA_INFORMATION,
1196 SMB2_O_INFO_FILE,
1197 CIFSMaxBufSize -
1198 MAX_SMB2_CREATE_RESPONSE_SIZE -
1199 MAX_SMB2_CLOSE_RESPONSE_SIZE,
1200 &rsp_iov, &buftype, cifs_sb);
1201 if (rc) {
1202
1203
1204
1205
1206
1207 if (!ea_name && rc == -ENODATA)
1208 rc = 0;
1209 goto qeas_exit;
1210 }
1211
1212 rsp = (struct smb2_query_info_rsp *)rsp_iov.iov_base;
1213 rc = smb2_validate_iov(le16_to_cpu(rsp->OutputBufferOffset),
1214 le32_to_cpu(rsp->OutputBufferLength),
1215 &rsp_iov,
1216 sizeof(struct smb2_file_full_ea_info));
1217 if (rc)
1218 goto qeas_exit;
1219
1220 info = (struct smb2_file_full_ea_info *)(
1221 le16_to_cpu(rsp->OutputBufferOffset) + (char *)rsp);
1222 rc = move_smb2_ea_to_cifs(ea_data, buf_size, info,
1223 le32_to_cpu(rsp->OutputBufferLength), ea_name);
1224
1225 qeas_exit:
1226 kfree(utf16_path);
1227 free_rsp_buf(buftype, rsp_iov.iov_base);
1228 return rc;
1229}
1230
1231
1232static int
1233smb2_set_ea(const unsigned int xid, struct cifs_tcon *tcon,
1234 const char *path, const char *ea_name, const void *ea_value,
1235 const __u16 ea_value_len, const struct nls_table *nls_codepage,
1236 struct cifs_sb_info *cifs_sb)
1237{
1238 struct cifs_ses *ses = tcon->ses;
1239 struct TCP_Server_Info *server = cifs_pick_channel(ses);
1240 __le16 *utf16_path = NULL;
1241 int ea_name_len = strlen(ea_name);
1242 int flags = CIFS_CP_CREATE_CLOSE_OP;
1243 int len;
1244 struct smb_rqst rqst[3];
1245 int resp_buftype[3];
1246 struct kvec rsp_iov[3];
1247 struct kvec open_iov[SMB2_CREATE_IOV_SIZE];
1248 struct cifs_open_parms oparms;
1249 __u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
1250 struct cifs_fid fid;
1251 struct kvec si_iov[SMB2_SET_INFO_IOV_SIZE];
1252 unsigned int size[1];
1253 void *data[1];
1254 struct smb2_file_full_ea_info *ea = NULL;
1255 struct kvec close_iov[1];
1256 struct smb2_query_info_rsp *rsp;
1257 int rc, used_len = 0;
1258
1259 if (smb3_encryption_required(tcon))
1260 flags |= CIFS_TRANSFORM_REQ;
1261
1262 if (ea_name_len > 255)
1263 return -EINVAL;
1264
1265 utf16_path = cifs_convert_path_to_utf16(path, cifs_sb);
1266 if (!utf16_path)
1267 return -ENOMEM;
1268
1269 memset(rqst, 0, sizeof(rqst));
1270 resp_buftype[0] = resp_buftype[1] = resp_buftype[2] = CIFS_NO_BUFFER;
1271 memset(rsp_iov, 0, sizeof(rsp_iov));
1272
1273 if (ses->server->ops->query_all_EAs) {
1274 if (!ea_value) {
1275 rc = ses->server->ops->query_all_EAs(xid, tcon, path,
1276 ea_name, NULL, 0,
1277 cifs_sb);
1278 if (rc == -ENODATA)
1279 goto sea_exit;
1280 } else {
1281
1282
1283
1284
1285
1286 rc = smb2_query_info_compound(xid, tcon, utf16_path,
1287 FILE_READ_EA,
1288 FILE_FULL_EA_INFORMATION,
1289 SMB2_O_INFO_FILE,
1290 CIFSMaxBufSize -
1291 MAX_SMB2_CREATE_RESPONSE_SIZE -
1292 MAX_SMB2_CLOSE_RESPONSE_SIZE,
1293 &rsp_iov[1], &resp_buftype[1], cifs_sb);
1294 if (rc == 0) {
1295 rsp = (struct smb2_query_info_rsp *)rsp_iov[1].iov_base;
1296 used_len = le32_to_cpu(rsp->OutputBufferLength);
1297 }
1298 free_rsp_buf(resp_buftype[1], rsp_iov[1].iov_base);
1299 resp_buftype[1] = CIFS_NO_BUFFER;
1300 memset(&rsp_iov[1], 0, sizeof(rsp_iov[1]));
1301 rc = 0;
1302
1303
1304
1305
1306 if(CIFSMaxBufSize - MAX_SMB2_CREATE_RESPONSE_SIZE -
1307 MAX_SMB2_CLOSE_RESPONSE_SIZE - 256 <
1308 used_len + ea_name_len + ea_value_len + 1) {
1309 rc = -ENOSPC;
1310 goto sea_exit;
1311 }
1312 }
1313 }
1314
1315
1316 memset(&open_iov, 0, sizeof(open_iov));
1317 rqst[0].rq_iov = open_iov;
1318 rqst[0].rq_nvec = SMB2_CREATE_IOV_SIZE;
1319
1320 memset(&oparms, 0, sizeof(oparms));
1321 oparms.tcon = tcon;
1322 oparms.desired_access = FILE_WRITE_EA;
1323 oparms.disposition = FILE_OPEN;
1324 oparms.create_options = cifs_create_options(cifs_sb, 0);
1325 oparms.fid = &fid;
1326 oparms.reconnect = false;
1327
1328 rc = SMB2_open_init(tcon, server,
1329 &rqst[0], &oplock, &oparms, utf16_path);
1330 if (rc)
1331 goto sea_exit;
1332 smb2_set_next_command(tcon, &rqst[0]);
1333
1334
1335
1336 memset(&si_iov, 0, sizeof(si_iov));
1337 rqst[1].rq_iov = si_iov;
1338 rqst[1].rq_nvec = 1;
1339
1340 len = sizeof(*ea) + ea_name_len + ea_value_len + 1;
1341 ea = kzalloc(len, GFP_KERNEL);
1342 if (ea == NULL) {
1343 rc = -ENOMEM;
1344 goto sea_exit;
1345 }
1346
1347 ea->ea_name_length = ea_name_len;
1348 ea->ea_value_length = cpu_to_le16(ea_value_len);
1349 memcpy(ea->ea_data, ea_name, ea_name_len + 1);
1350 memcpy(ea->ea_data + ea_name_len + 1, ea_value, ea_value_len);
1351
1352 size[0] = len;
1353 data[0] = ea;
1354
1355 rc = SMB2_set_info_init(tcon, server,
1356 &rqst[1], COMPOUND_FID,
1357 COMPOUND_FID, current->tgid,
1358 FILE_FULL_EA_INFORMATION,
1359 SMB2_O_INFO_FILE, 0, data, size);
1360 smb2_set_next_command(tcon, &rqst[1]);
1361 smb2_set_related(&rqst[1]);
1362
1363
1364
1365 memset(&close_iov, 0, sizeof(close_iov));
1366 rqst[2].rq_iov = close_iov;
1367 rqst[2].rq_nvec = 1;
1368 rc = SMB2_close_init(tcon, server,
1369 &rqst[2], COMPOUND_FID, COMPOUND_FID, false);
1370 smb2_set_related(&rqst[2]);
1371
1372 rc = compound_send_recv(xid, ses, server,
1373 flags, 3, rqst,
1374 resp_buftype, rsp_iov);
1375
1376
1377 sea_exit:
1378 kfree(ea);
1379 kfree(utf16_path);
1380 SMB2_open_free(&rqst[0]);
1381 SMB2_set_info_free(&rqst[1]);
1382 SMB2_close_free(&rqst[2]);
1383 free_rsp_buf(resp_buftype[0], rsp_iov[0].iov_base);
1384 free_rsp_buf(resp_buftype[1], rsp_iov[1].iov_base);
1385 free_rsp_buf(resp_buftype[2], rsp_iov[2].iov_base);
1386 return rc;
1387}
1388#endif
1389
1390static bool
1391smb2_can_echo(struct TCP_Server_Info *server)
1392{
1393 return server->echoes;
1394}
1395
1396static void
1397smb2_clear_stats(struct cifs_tcon *tcon)
1398{
1399 int i;
1400
1401 for (i = 0; i < NUMBER_OF_SMB2_COMMANDS; i++) {
1402 atomic_set(&tcon->stats.smb2_stats.smb2_com_sent[i], 0);
1403 atomic_set(&tcon->stats.smb2_stats.smb2_com_failed[i], 0);
1404 }
1405}
1406
1407static void
1408smb2_dump_share_caps(struct seq_file *m, struct cifs_tcon *tcon)
1409{
1410 seq_puts(m, "\n\tShare Capabilities:");
1411 if (tcon->capabilities & SMB2_SHARE_CAP_DFS)
1412 seq_puts(m, " DFS,");
1413 if (tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
1414 seq_puts(m, " CONTINUOUS AVAILABILITY,");
1415 if (tcon->capabilities & SMB2_SHARE_CAP_SCALEOUT)
1416 seq_puts(m, " SCALEOUT,");
1417 if (tcon->capabilities & SMB2_SHARE_CAP_CLUSTER)
1418 seq_puts(m, " CLUSTER,");
1419 if (tcon->capabilities & SMB2_SHARE_CAP_ASYMMETRIC)
1420 seq_puts(m, " ASYMMETRIC,");
1421 if (tcon->capabilities == 0)
1422 seq_puts(m, " None");
1423 if (tcon->ss_flags & SSINFO_FLAGS_ALIGNED_DEVICE)
1424 seq_puts(m, " Aligned,");
1425 if (tcon->ss_flags & SSINFO_FLAGS_PARTITION_ALIGNED_ON_DEVICE)
1426 seq_puts(m, " Partition Aligned,");
1427 if (tcon->ss_flags & SSINFO_FLAGS_NO_SEEK_PENALTY)
1428 seq_puts(m, " SSD,");
1429 if (tcon->ss_flags & SSINFO_FLAGS_TRIM_ENABLED)
1430 seq_puts(m, " TRIM-support,");
1431
1432 seq_printf(m, "\tShare Flags: 0x%x", tcon->share_flags);
1433 seq_printf(m, "\n\ttid: 0x%x", tcon->tid);
1434 if (tcon->perf_sector_size)
1435 seq_printf(m, "\tOptimal sector size: 0x%x",
1436 tcon->perf_sector_size);
1437 seq_printf(m, "\tMaximal Access: 0x%x", tcon->maximal_access);
1438}
1439
1440static void
1441smb2_print_stats(struct seq_file *m, struct cifs_tcon *tcon)
1442{
1443 atomic_t *sent = tcon->stats.smb2_stats.smb2_com_sent;
1444 atomic_t *failed = tcon->stats.smb2_stats.smb2_com_failed;
1445
1446
1447
1448
1449
1450 seq_printf(m, "\nBytes read: %llu Bytes written: %llu",
1451 (long long)(tcon->bytes_read),
1452 (long long)(tcon->bytes_written));
1453 seq_printf(m, "\nOpen files: %d total (local), %d open on server",
1454 atomic_read(&tcon->num_local_opens),
1455 atomic_read(&tcon->num_remote_opens));
1456 seq_printf(m, "\nTreeConnects: %d total %d failed",
1457 atomic_read(&sent[SMB2_TREE_CONNECT_HE]),
1458 atomic_read(&failed[SMB2_TREE_CONNECT_HE]));
1459 seq_printf(m, "\nTreeDisconnects: %d total %d failed",
1460 atomic_read(&sent[SMB2_TREE_DISCONNECT_HE]),
1461 atomic_read(&failed[SMB2_TREE_DISCONNECT_HE]));
1462 seq_printf(m, "\nCreates: %d total %d failed",
1463 atomic_read(&sent[SMB2_CREATE_HE]),
1464 atomic_read(&failed[SMB2_CREATE_HE]));
1465 seq_printf(m, "\nCloses: %d total %d failed",
1466 atomic_read(&sent[SMB2_CLOSE_HE]),
1467 atomic_read(&failed[SMB2_CLOSE_HE]));
1468 seq_printf(m, "\nFlushes: %d total %d failed",
1469 atomic_read(&sent[SMB2_FLUSH_HE]),
1470 atomic_read(&failed[SMB2_FLUSH_HE]));
1471 seq_printf(m, "\nReads: %d total %d failed",
1472 atomic_read(&sent[SMB2_READ_HE]),
1473 atomic_read(&failed[SMB2_READ_HE]));
1474 seq_printf(m, "\nWrites: %d total %d failed",
1475 atomic_read(&sent[SMB2_WRITE_HE]),
1476 atomic_read(&failed[SMB2_WRITE_HE]));
1477 seq_printf(m, "\nLocks: %d total %d failed",
1478 atomic_read(&sent[SMB2_LOCK_HE]),
1479 atomic_read(&failed[SMB2_LOCK_HE]));
1480 seq_printf(m, "\nIOCTLs: %d total %d failed",
1481 atomic_read(&sent[SMB2_IOCTL_HE]),
1482 atomic_read(&failed[SMB2_IOCTL_HE]));
1483 seq_printf(m, "\nQueryDirectories: %d total %d failed",
1484 atomic_read(&sent[SMB2_QUERY_DIRECTORY_HE]),
1485 atomic_read(&failed[SMB2_QUERY_DIRECTORY_HE]));
1486 seq_printf(m, "\nChangeNotifies: %d total %d failed",
1487 atomic_read(&sent[SMB2_CHANGE_NOTIFY_HE]),
1488 atomic_read(&failed[SMB2_CHANGE_NOTIFY_HE]));
1489 seq_printf(m, "\nQueryInfos: %d total %d failed",
1490 atomic_read(&sent[SMB2_QUERY_INFO_HE]),
1491 atomic_read(&failed[SMB2_QUERY_INFO_HE]));
1492 seq_printf(m, "\nSetInfos: %d total %d failed",
1493 atomic_read(&sent[SMB2_SET_INFO_HE]),
1494 atomic_read(&failed[SMB2_SET_INFO_HE]));
1495 seq_printf(m, "\nOplockBreaks: %d sent %d failed",
1496 atomic_read(&sent[SMB2_OPLOCK_BREAK_HE]),
1497 atomic_read(&failed[SMB2_OPLOCK_BREAK_HE]));
1498}
1499
1500static void
1501smb2_set_fid(struct cifsFileInfo *cfile, struct cifs_fid *fid, __u32 oplock)
1502{
1503 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1504 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
1505
1506 cfile->fid.persistent_fid = fid->persistent_fid;
1507 cfile->fid.volatile_fid = fid->volatile_fid;
1508 cfile->fid.access = fid->access;
1509#ifdef CONFIG_CIFS_DEBUG2
1510 cfile->fid.mid = fid->mid;
1511#endif
1512 server->ops->set_oplock_level(cinode, oplock, fid->epoch,
1513 &fid->purge_cache);
1514 cinode->can_cache_brlcks = CIFS_CACHE_WRITE(cinode);
1515 memcpy(cfile->fid.create_guid, fid->create_guid, 16);
1516}
1517
1518static void
1519smb2_close_file(const unsigned int xid, struct cifs_tcon *tcon,
1520 struct cifs_fid *fid)
1521{
1522 SMB2_close(xid, tcon, fid->persistent_fid, fid->volatile_fid);
1523}
1524
1525static void
1526smb2_close_getattr(const unsigned int xid, struct cifs_tcon *tcon,
1527 struct cifsFileInfo *cfile)
1528{
1529 struct smb2_file_network_open_info file_inf;
1530 struct inode *inode;
1531 int rc;
1532
1533 rc = __SMB2_close(xid, tcon, cfile->fid.persistent_fid,
1534 cfile->fid.volatile_fid, &file_inf);
1535 if (rc)
1536 return;
1537
1538 inode = d_inode(cfile->dentry);
1539
1540 spin_lock(&inode->i_lock);
1541 CIFS_I(inode)->time = jiffies;
1542
1543
1544 if (file_inf.LastWriteTime)
1545 inode->i_mtime = cifs_NTtimeToUnix(file_inf.LastWriteTime);
1546 if (file_inf.ChangeTime)
1547 inode->i_ctime = cifs_NTtimeToUnix(file_inf.ChangeTime);
1548 if (file_inf.LastAccessTime)
1549 inode->i_atime = cifs_NTtimeToUnix(file_inf.LastAccessTime);
1550
1551
1552
1553
1554
1555
1556 if (le64_to_cpu(file_inf.AllocationSize) > 4096)
1557 inode->i_blocks =
1558 (512 - 1 + le64_to_cpu(file_inf.AllocationSize)) >> 9;
1559
1560
1561 spin_unlock(&inode->i_lock);
1562}
1563
1564static int
1565SMB2_request_res_key(const unsigned int xid, struct cifs_tcon *tcon,
1566 u64 persistent_fid, u64 volatile_fid,
1567 struct copychunk_ioctl *pcchunk)
1568{
1569 int rc;
1570 unsigned int ret_data_len;
1571 struct resume_key_req *res_key;
1572
1573 rc = SMB2_ioctl(xid, tcon, persistent_fid, volatile_fid,
1574 FSCTL_SRV_REQUEST_RESUME_KEY, true ,
1575 NULL, 0 , CIFSMaxBufSize,
1576 (char **)&res_key, &ret_data_len);
1577
1578 if (rc == -EOPNOTSUPP) {
1579 pr_warn_once("Server share %s does not support copy range\n", tcon->treeName);
1580 goto req_res_key_exit;
1581 } else if (rc) {
1582 cifs_tcon_dbg(VFS, "refcpy ioctl error %d getting resume key\n", rc);
1583 goto req_res_key_exit;
1584 }
1585 if (ret_data_len < sizeof(struct resume_key_req)) {
1586 cifs_tcon_dbg(VFS, "Invalid refcopy resume key length\n");
1587 rc = -EINVAL;
1588 goto req_res_key_exit;
1589 }
1590 memcpy(pcchunk->SourceKey, res_key->ResumeKey, COPY_CHUNK_RES_KEY_SIZE);
1591
1592req_res_key_exit:
1593 kfree(res_key);
1594 return rc;
1595}
1596
1597struct iqi_vars {
1598 struct smb_rqst rqst[3];
1599 struct kvec rsp_iov[3];
1600 struct kvec open_iov[SMB2_CREATE_IOV_SIZE];
1601 struct kvec qi_iov[1];
1602 struct kvec io_iov[SMB2_IOCTL_IOV_SIZE];
1603 struct kvec si_iov[SMB2_SET_INFO_IOV_SIZE];
1604 struct kvec close_iov[1];
1605};
1606
1607static int
1608smb2_ioctl_query_info(const unsigned int xid,
1609 struct cifs_tcon *tcon,
1610 struct cifs_sb_info *cifs_sb,
1611 __le16 *path, int is_dir,
1612 unsigned long p)
1613{
1614 struct iqi_vars *vars;
1615 struct smb_rqst *rqst;
1616 struct kvec *rsp_iov;
1617 struct cifs_ses *ses = tcon->ses;
1618 struct TCP_Server_Info *server = cifs_pick_channel(ses);
1619 char __user *arg = (char __user *)p;
1620 struct smb_query_info qi;
1621 struct smb_query_info __user *pqi;
1622 int rc = 0;
1623 int flags = CIFS_CP_CREATE_CLOSE_OP;
1624 struct smb2_query_info_rsp *qi_rsp = NULL;
1625 struct smb2_ioctl_rsp *io_rsp = NULL;
1626 void *buffer = NULL;
1627 int resp_buftype[3];
1628 struct cifs_open_parms oparms;
1629 u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
1630 struct cifs_fid fid;
1631 unsigned int size[2];
1632 void *data[2];
1633 int create_options = is_dir ? CREATE_NOT_FILE : CREATE_NOT_DIR;
1634
1635 vars = kzalloc(sizeof(*vars), GFP_ATOMIC);
1636 if (vars == NULL)
1637 return -ENOMEM;
1638 rqst = &vars->rqst[0];
1639 rsp_iov = &vars->rsp_iov[0];
1640
1641 resp_buftype[0] = resp_buftype[1] = resp_buftype[2] = CIFS_NO_BUFFER;
1642
1643 if (copy_from_user(&qi, arg, sizeof(struct smb_query_info)))
1644 goto e_fault;
1645
1646 if (qi.output_buffer_length > 1024) {
1647 kfree(vars);
1648 return -EINVAL;
1649 }
1650
1651 if (!ses || !server) {
1652 kfree(vars);
1653 return -EIO;
1654 }
1655
1656 if (smb3_encryption_required(tcon))
1657 flags |= CIFS_TRANSFORM_REQ;
1658
1659 buffer = memdup_user(arg + sizeof(struct smb_query_info),
1660 qi.output_buffer_length);
1661 if (IS_ERR(buffer)) {
1662 kfree(vars);
1663 return PTR_ERR(buffer);
1664 }
1665
1666
1667 rqst[0].rq_iov = &vars->open_iov[0];
1668 rqst[0].rq_nvec = SMB2_CREATE_IOV_SIZE;
1669
1670 memset(&oparms, 0, sizeof(oparms));
1671 oparms.tcon = tcon;
1672 oparms.disposition = FILE_OPEN;
1673 oparms.create_options = cifs_create_options(cifs_sb, create_options);
1674 oparms.fid = &fid;
1675 oparms.reconnect = false;
1676
1677 if (qi.flags & PASSTHRU_FSCTL) {
1678 switch (qi.info_type & FSCTL_DEVICE_ACCESS_MASK) {
1679 case FSCTL_DEVICE_ACCESS_FILE_READ_WRITE_ACCESS:
1680 oparms.desired_access = FILE_READ_DATA | FILE_WRITE_DATA | FILE_READ_ATTRIBUTES | SYNCHRONIZE;
1681 break;
1682 case FSCTL_DEVICE_ACCESS_FILE_ANY_ACCESS:
1683 oparms.desired_access = GENERIC_ALL;
1684 break;
1685 case FSCTL_DEVICE_ACCESS_FILE_READ_ACCESS:
1686 oparms.desired_access = GENERIC_READ;
1687 break;
1688 case FSCTL_DEVICE_ACCESS_FILE_WRITE_ACCESS:
1689 oparms.desired_access = GENERIC_WRITE;
1690 break;
1691 }
1692 } else if (qi.flags & PASSTHRU_SET_INFO) {
1693 oparms.desired_access = GENERIC_WRITE;
1694 } else {
1695 oparms.desired_access = FILE_READ_ATTRIBUTES | READ_CONTROL;
1696 }
1697
1698 rc = SMB2_open_init(tcon, server,
1699 &rqst[0], &oplock, &oparms, path);
1700 if (rc)
1701 goto iqinf_exit;
1702 smb2_set_next_command(tcon, &rqst[0]);
1703
1704
1705 if (qi.flags & PASSTHRU_FSCTL) {
1706
1707 if (!capable(CAP_SYS_ADMIN))
1708 rc = -EPERM;
1709 else {
1710 rqst[1].rq_iov = &vars->io_iov[0];
1711 rqst[1].rq_nvec = SMB2_IOCTL_IOV_SIZE;
1712
1713 rc = SMB2_ioctl_init(tcon, server,
1714 &rqst[1],
1715 COMPOUND_FID, COMPOUND_FID,
1716 qi.info_type, true, buffer,
1717 qi.output_buffer_length,
1718 CIFSMaxBufSize -
1719 MAX_SMB2_CREATE_RESPONSE_SIZE -
1720 MAX_SMB2_CLOSE_RESPONSE_SIZE);
1721 }
1722 } else if (qi.flags == PASSTHRU_SET_INFO) {
1723
1724 if (!capable(CAP_SYS_ADMIN))
1725 rc = -EPERM;
1726 else {
1727 rqst[1].rq_iov = &vars->si_iov[0];
1728 rqst[1].rq_nvec = 1;
1729
1730 size[0] = 8;
1731 data[0] = buffer;
1732
1733 rc = SMB2_set_info_init(tcon, server,
1734 &rqst[1],
1735 COMPOUND_FID, COMPOUND_FID,
1736 current->tgid,
1737 FILE_END_OF_FILE_INFORMATION,
1738 SMB2_O_INFO_FILE, 0, data, size);
1739 }
1740 } else if (qi.flags == PASSTHRU_QUERY_INFO) {
1741 rqst[1].rq_iov = &vars->qi_iov[0];
1742 rqst[1].rq_nvec = 1;
1743
1744 rc = SMB2_query_info_init(tcon, server,
1745 &rqst[1], COMPOUND_FID,
1746 COMPOUND_FID, qi.file_info_class,
1747 qi.info_type, qi.additional_information,
1748 qi.input_buffer_length,
1749 qi.output_buffer_length, buffer);
1750 } else {
1751 cifs_tcon_dbg(VFS, "Invalid passthru query flags: 0x%x\n",
1752 qi.flags);
1753 rc = -EINVAL;
1754 }
1755
1756 if (rc)
1757 goto iqinf_exit;
1758 smb2_set_next_command(tcon, &rqst[1]);
1759 smb2_set_related(&rqst[1]);
1760
1761
1762 rqst[2].rq_iov = &vars->close_iov[0];
1763 rqst[2].rq_nvec = 1;
1764
1765 rc = SMB2_close_init(tcon, server,
1766 &rqst[2], COMPOUND_FID, COMPOUND_FID, false);
1767 if (rc)
1768 goto iqinf_exit;
1769 smb2_set_related(&rqst[2]);
1770
1771 rc = compound_send_recv(xid, ses, server,
1772 flags, 3, rqst,
1773 resp_buftype, rsp_iov);
1774 if (rc)
1775 goto iqinf_exit;
1776
1777
1778 if (qi.flags & PASSTHRU_FSCTL) {
1779 pqi = (struct smb_query_info __user *)arg;
1780 io_rsp = (struct smb2_ioctl_rsp *)rsp_iov[1].iov_base;
1781 if (le32_to_cpu(io_rsp->OutputCount) < qi.input_buffer_length)
1782 qi.input_buffer_length = le32_to_cpu(io_rsp->OutputCount);
1783 if (qi.input_buffer_length > 0 &&
1784 le32_to_cpu(io_rsp->OutputOffset) + qi.input_buffer_length
1785 > rsp_iov[1].iov_len)
1786 goto e_fault;
1787
1788 if (copy_to_user(&pqi->input_buffer_length,
1789 &qi.input_buffer_length,
1790 sizeof(qi.input_buffer_length)))
1791 goto e_fault;
1792
1793 if (copy_to_user((void __user *)pqi + sizeof(struct smb_query_info),
1794 (const void *)io_rsp + le32_to_cpu(io_rsp->OutputOffset),
1795 qi.input_buffer_length))
1796 goto e_fault;
1797 } else {
1798 pqi = (struct smb_query_info __user *)arg;
1799 qi_rsp = (struct smb2_query_info_rsp *)rsp_iov[1].iov_base;
1800 if (le32_to_cpu(qi_rsp->OutputBufferLength) < qi.input_buffer_length)
1801 qi.input_buffer_length = le32_to_cpu(qi_rsp->OutputBufferLength);
1802 if (copy_to_user(&pqi->input_buffer_length,
1803 &qi.input_buffer_length,
1804 sizeof(qi.input_buffer_length)))
1805 goto e_fault;
1806
1807 if (copy_to_user(pqi + 1, qi_rsp->Buffer,
1808 qi.input_buffer_length))
1809 goto e_fault;
1810 }
1811
1812 iqinf_exit:
1813 cifs_small_buf_release(rqst[0].rq_iov[0].iov_base);
1814 cifs_small_buf_release(rqst[1].rq_iov[0].iov_base);
1815 cifs_small_buf_release(rqst[2].rq_iov[0].iov_base);
1816 free_rsp_buf(resp_buftype[0], rsp_iov[0].iov_base);
1817 free_rsp_buf(resp_buftype[1], rsp_iov[1].iov_base);
1818 free_rsp_buf(resp_buftype[2], rsp_iov[2].iov_base);
1819 kfree(vars);
1820 kfree(buffer);
1821 return rc;
1822
1823e_fault:
1824 rc = -EFAULT;
1825 goto iqinf_exit;
1826}
1827
1828static ssize_t
1829smb2_copychunk_range(const unsigned int xid,
1830 struct cifsFileInfo *srcfile,
1831 struct cifsFileInfo *trgtfile, u64 src_off,
1832 u64 len, u64 dest_off)
1833{
1834 int rc;
1835 unsigned int ret_data_len;
1836 struct copychunk_ioctl *pcchunk;
1837 struct copychunk_ioctl_rsp *retbuf = NULL;
1838 struct cifs_tcon *tcon;
1839 int chunks_copied = 0;
1840 bool chunk_sizes_updated = false;
1841 ssize_t bytes_written, total_bytes_written = 0;
1842
1843 pcchunk = kmalloc(sizeof(struct copychunk_ioctl), GFP_KERNEL);
1844
1845 if (pcchunk == NULL)
1846 return -ENOMEM;
1847
1848 cifs_dbg(FYI, "%s: about to call request res key\n", __func__);
1849
1850 rc = SMB2_request_res_key(xid, tlink_tcon(srcfile->tlink),
1851 srcfile->fid.persistent_fid,
1852 srcfile->fid.volatile_fid, pcchunk);
1853
1854
1855 if (rc)
1856 goto cchunk_out;
1857
1858
1859 pcchunk->ChunkCount = cpu_to_le32(1);
1860 pcchunk->Reserved = 0;
1861 pcchunk->Reserved2 = 0;
1862
1863 tcon = tlink_tcon(trgtfile->tlink);
1864
1865 while (len > 0) {
1866 pcchunk->SourceOffset = cpu_to_le64(src_off);
1867 pcchunk->TargetOffset = cpu_to_le64(dest_off);
1868 pcchunk->Length =
1869 cpu_to_le32(min_t(u32, len, tcon->max_bytes_chunk));
1870
1871
1872 kfree(retbuf);
1873 retbuf = NULL;
1874 rc = SMB2_ioctl(xid, tcon, trgtfile->fid.persistent_fid,
1875 trgtfile->fid.volatile_fid, FSCTL_SRV_COPYCHUNK_WRITE,
1876 true , (char *)pcchunk,
1877 sizeof(struct copychunk_ioctl), CIFSMaxBufSize,
1878 (char **)&retbuf, &ret_data_len);
1879 if (rc == 0) {
1880 if (ret_data_len !=
1881 sizeof(struct copychunk_ioctl_rsp)) {
1882 cifs_tcon_dbg(VFS, "Invalid cchunk response size\n");
1883 rc = -EIO;
1884 goto cchunk_out;
1885 }
1886 if (retbuf->TotalBytesWritten == 0) {
1887 cifs_dbg(FYI, "no bytes copied\n");
1888 rc = -EIO;
1889 goto cchunk_out;
1890 }
1891
1892
1893
1894 if (le32_to_cpu(retbuf->TotalBytesWritten) >
1895 le32_to_cpu(pcchunk->Length)) {
1896 cifs_tcon_dbg(VFS, "Invalid copy chunk response\n");
1897 rc = -EIO;
1898 goto cchunk_out;
1899 }
1900 if (le32_to_cpu(retbuf->ChunksWritten) != 1) {
1901 cifs_tcon_dbg(VFS, "Invalid num chunks written\n");
1902 rc = -EIO;
1903 goto cchunk_out;
1904 }
1905 chunks_copied++;
1906
1907 bytes_written = le32_to_cpu(retbuf->TotalBytesWritten);
1908 src_off += bytes_written;
1909 dest_off += bytes_written;
1910 len -= bytes_written;
1911 total_bytes_written += bytes_written;
1912
1913 cifs_dbg(FYI, "Chunks %d PartialChunk %d Total %zu\n",
1914 le32_to_cpu(retbuf->ChunksWritten),
1915 le32_to_cpu(retbuf->ChunkBytesWritten),
1916 bytes_written);
1917 } else if (rc == -EINVAL) {
1918 if (ret_data_len != sizeof(struct copychunk_ioctl_rsp))
1919 goto cchunk_out;
1920
1921 cifs_dbg(FYI, "MaxChunks %d BytesChunk %d MaxCopy %d\n",
1922 le32_to_cpu(retbuf->ChunksWritten),
1923 le32_to_cpu(retbuf->ChunkBytesWritten),
1924 le32_to_cpu(retbuf->TotalBytesWritten));
1925
1926
1927
1928
1929
1930
1931
1932
1933 if ((chunks_copied != 0) || chunk_sizes_updated)
1934 goto cchunk_out;
1935
1936
1937 if (le32_to_cpu(retbuf->ChunkBytesWritten) <
1938 tcon->max_bytes_chunk)
1939 tcon->max_bytes_chunk =
1940 le32_to_cpu(retbuf->ChunkBytesWritten);
1941 else
1942 goto cchunk_out;
1943
1944
1945 chunk_sizes_updated = true;
1946 } else
1947 goto cchunk_out;
1948 }
1949
1950cchunk_out:
1951 kfree(pcchunk);
1952 kfree(retbuf);
1953 if (rc)
1954 return rc;
1955 else
1956 return total_bytes_written;
1957}
1958
1959static int
1960smb2_flush_file(const unsigned int xid, struct cifs_tcon *tcon,
1961 struct cifs_fid *fid)
1962{
1963 return SMB2_flush(xid, tcon, fid->persistent_fid, fid->volatile_fid);
1964}
1965
1966static unsigned int
1967smb2_read_data_offset(char *buf)
1968{
1969 struct smb2_read_rsp *rsp = (struct smb2_read_rsp *)buf;
1970
1971 return rsp->DataOffset;
1972}
1973
1974static unsigned int
1975smb2_read_data_length(char *buf, bool in_remaining)
1976{
1977 struct smb2_read_rsp *rsp = (struct smb2_read_rsp *)buf;
1978
1979 if (in_remaining)
1980 return le32_to_cpu(rsp->DataRemaining);
1981
1982 return le32_to_cpu(rsp->DataLength);
1983}
1984
1985
1986static int
1987smb2_sync_read(const unsigned int xid, struct cifs_fid *pfid,
1988 struct cifs_io_parms *parms, unsigned int *bytes_read,
1989 char **buf, int *buf_type)
1990{
1991 parms->persistent_fid = pfid->persistent_fid;
1992 parms->volatile_fid = pfid->volatile_fid;
1993 return SMB2_read(xid, parms, bytes_read, buf, buf_type);
1994}
1995
1996static int
1997smb2_sync_write(const unsigned int xid, struct cifs_fid *pfid,
1998 struct cifs_io_parms *parms, unsigned int *written,
1999 struct kvec *iov, unsigned long nr_segs)
2000{
2001
2002 parms->persistent_fid = pfid->persistent_fid;
2003 parms->volatile_fid = pfid->volatile_fid;
2004 return SMB2_write(xid, parms, written, iov, nr_segs);
2005}
2006
2007
2008static bool smb2_set_sparse(const unsigned int xid, struct cifs_tcon *tcon,
2009 struct cifsFileInfo *cfile, struct inode *inode, __u8 setsparse)
2010{
2011 struct cifsInodeInfo *cifsi;
2012 int rc;
2013
2014 cifsi = CIFS_I(inode);
2015
2016
2017 if ((cifsi->cifsAttrs & FILE_ATTRIBUTE_SPARSE_FILE) && setsparse)
2018 return true;
2019
2020 if (!(cifsi->cifsAttrs & FILE_ATTRIBUTE_SPARSE_FILE) && !setsparse)
2021 return true;
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033 if (tcon->broken_sparse_sup)
2034 return false;
2035
2036 rc = SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid,
2037 cfile->fid.volatile_fid, FSCTL_SET_SPARSE,
2038 true ,
2039 &setsparse, 1, CIFSMaxBufSize, NULL, NULL);
2040 if (rc) {
2041 tcon->broken_sparse_sup = true;
2042 cifs_dbg(FYI, "set sparse rc = %d\n", rc);
2043 return false;
2044 }
2045
2046 if (setsparse)
2047 cifsi->cifsAttrs |= FILE_ATTRIBUTE_SPARSE_FILE;
2048 else
2049 cifsi->cifsAttrs &= (~FILE_ATTRIBUTE_SPARSE_FILE);
2050
2051 return true;
2052}
2053
2054static int
2055smb2_set_file_size(const unsigned int xid, struct cifs_tcon *tcon,
2056 struct cifsFileInfo *cfile, __u64 size, bool set_alloc)
2057{
2058 __le64 eof = cpu_to_le64(size);
2059 struct inode *inode;
2060
2061
2062
2063
2064
2065 inode = d_inode(cfile->dentry);
2066
2067 if (!set_alloc && (size > inode->i_size + 8192)) {
2068 __u8 set_sparse = 1;
2069
2070
2071 smb2_set_sparse(xid, tcon, cfile, inode, set_sparse);
2072 }
2073
2074 return SMB2_set_eof(xid, tcon, cfile->fid.persistent_fid,
2075 cfile->fid.volatile_fid, cfile->pid, &eof);
2076}
2077
2078static int
2079smb2_duplicate_extents(const unsigned int xid,
2080 struct cifsFileInfo *srcfile,
2081 struct cifsFileInfo *trgtfile, u64 src_off,
2082 u64 len, u64 dest_off)
2083{
2084 int rc;
2085 unsigned int ret_data_len;
2086 struct inode *inode;
2087 struct duplicate_extents_to_file dup_ext_buf;
2088 struct cifs_tcon *tcon = tlink_tcon(trgtfile->tlink);
2089
2090
2091 if ((le32_to_cpu(tcon->fsAttrInfo.Attributes) &
2092 FILE_SUPPORTS_BLOCK_REFCOUNTING) == 0)
2093 return -EOPNOTSUPP;
2094
2095 dup_ext_buf.VolatileFileHandle = srcfile->fid.volatile_fid;
2096 dup_ext_buf.PersistentFileHandle = srcfile->fid.persistent_fid;
2097 dup_ext_buf.SourceFileOffset = cpu_to_le64(src_off);
2098 dup_ext_buf.TargetFileOffset = cpu_to_le64(dest_off);
2099 dup_ext_buf.ByteCount = cpu_to_le64(len);
2100 cifs_dbg(FYI, "Duplicate extents: src off %lld dst off %lld len %lld\n",
2101 src_off, dest_off, len);
2102
2103 inode = d_inode(trgtfile->dentry);
2104 if (inode->i_size < dest_off + len) {
2105 rc = smb2_set_file_size(xid, tcon, trgtfile, dest_off + len, false);
2106 if (rc)
2107 goto duplicate_extents_out;
2108
2109
2110
2111
2112
2113
2114
2115
2116 cifs_setsize(inode, dest_off + len);
2117 }
2118 rc = SMB2_ioctl(xid, tcon, trgtfile->fid.persistent_fid,
2119 trgtfile->fid.volatile_fid,
2120 FSCTL_DUPLICATE_EXTENTS_TO_FILE,
2121 true ,
2122 (char *)&dup_ext_buf,
2123 sizeof(struct duplicate_extents_to_file),
2124 CIFSMaxBufSize, NULL,
2125 &ret_data_len);
2126
2127 if (ret_data_len > 0)
2128 cifs_dbg(FYI, "Non-zero response length in duplicate extents\n");
2129
2130duplicate_extents_out:
2131 return rc;
2132}
2133
2134static int
2135smb2_set_compression(const unsigned int xid, struct cifs_tcon *tcon,
2136 struct cifsFileInfo *cfile)
2137{
2138 return SMB2_set_compression(xid, tcon, cfile->fid.persistent_fid,
2139 cfile->fid.volatile_fid);
2140}
2141
2142static int
2143smb3_set_integrity(const unsigned int xid, struct cifs_tcon *tcon,
2144 struct cifsFileInfo *cfile)
2145{
2146 struct fsctl_set_integrity_information_req integr_info;
2147 unsigned int ret_data_len;
2148
2149 integr_info.ChecksumAlgorithm = cpu_to_le16(CHECKSUM_TYPE_UNCHANGED);
2150 integr_info.Flags = 0;
2151 integr_info.Reserved = 0;
2152
2153 return SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid,
2154 cfile->fid.volatile_fid,
2155 FSCTL_SET_INTEGRITY_INFORMATION,
2156 true ,
2157 (char *)&integr_info,
2158 sizeof(struct fsctl_set_integrity_information_req),
2159 CIFSMaxBufSize, NULL,
2160 &ret_data_len);
2161
2162}
2163
2164
2165#define GMT_TOKEN_SIZE 50
2166
2167#define MIN_SNAPSHOT_ARRAY_SIZE 16
2168
2169
2170
2171
2172
2173static int
2174smb3_enum_snapshots(const unsigned int xid, struct cifs_tcon *tcon,
2175 struct cifsFileInfo *cfile, void __user *ioc_buf)
2176{
2177 char *retbuf = NULL;
2178 unsigned int ret_data_len = 0;
2179 int rc;
2180 u32 max_response_size;
2181 struct smb_snapshot_array snapshot_in;
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191 if (get_user(ret_data_len, (unsigned int __user *)ioc_buf))
2192 return -EFAULT;
2193
2194
2195
2196
2197
2198
2199
2200
2201 if (ret_data_len == 0)
2202 max_response_size = MIN_SNAPSHOT_ARRAY_SIZE;
2203 else
2204 max_response_size = CIFSMaxBufSize;
2205
2206 rc = SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid,
2207 cfile->fid.volatile_fid,
2208 FSCTL_SRV_ENUMERATE_SNAPSHOTS,
2209 true ,
2210 NULL, 0 , max_response_size,
2211 (char **)&retbuf,
2212 &ret_data_len);
2213 cifs_dbg(FYI, "enum snaphots ioctl returned %d and ret buflen is %d\n",
2214 rc, ret_data_len);
2215 if (rc)
2216 return rc;
2217
2218 if (ret_data_len && (ioc_buf != NULL) && (retbuf != NULL)) {
2219
2220 if (copy_from_user(&snapshot_in, ioc_buf,
2221 sizeof(struct smb_snapshot_array))) {
2222 rc = -EFAULT;
2223 kfree(retbuf);
2224 return rc;
2225 }
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235 if (snapshot_in.snapshot_array_size < GMT_TOKEN_SIZE)
2236 ret_data_len = sizeof(struct smb_snapshot_array);
2237
2238
2239
2240
2241
2242
2243 if (ret_data_len > (snapshot_in.snapshot_array_size +
2244 sizeof(struct smb_snapshot_array)))
2245 ret_data_len = snapshot_in.snapshot_array_size +
2246 sizeof(struct smb_snapshot_array);
2247
2248 if (copy_to_user(ioc_buf, retbuf, ret_data_len))
2249 rc = -EFAULT;
2250 }
2251
2252 kfree(retbuf);
2253 return rc;
2254}
2255
2256
2257
2258static int
2259smb3_notify(const unsigned int xid, struct file *pfile,
2260 void __user *ioc_buf)
2261{
2262 struct smb3_notify notify;
2263 struct dentry *dentry = pfile->f_path.dentry;
2264 struct inode *inode = file_inode(pfile);
2265 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2266 struct cifs_open_parms oparms;
2267 struct cifs_fid fid;
2268 struct cifs_tcon *tcon;
2269 const unsigned char *path;
2270 void *page = alloc_dentry_path();
2271 __le16 *utf16_path = NULL;
2272 u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
2273 int rc = 0;
2274
2275 path = build_path_from_dentry(dentry, page);
2276 if (IS_ERR(path)) {
2277 rc = PTR_ERR(path);
2278 goto notify_exit;
2279 }
2280
2281 utf16_path = cifs_convert_path_to_utf16(path, cifs_sb);
2282 if (utf16_path == NULL) {
2283 rc = -ENOMEM;
2284 goto notify_exit;
2285 }
2286
2287 if (copy_from_user(¬ify, ioc_buf, sizeof(struct smb3_notify))) {
2288 rc = -EFAULT;
2289 goto notify_exit;
2290 }
2291
2292 tcon = cifs_sb_master_tcon(cifs_sb);
2293 oparms.tcon = tcon;
2294 oparms.desired_access = FILE_READ_ATTRIBUTES | FILE_READ_DATA;
2295 oparms.disposition = FILE_OPEN;
2296 oparms.create_options = cifs_create_options(cifs_sb, 0);
2297 oparms.fid = &fid;
2298 oparms.reconnect = false;
2299
2300 rc = SMB2_open(xid, &oparms, utf16_path, &oplock, NULL, NULL, NULL,
2301 NULL);
2302 if (rc)
2303 goto notify_exit;
2304
2305 rc = SMB2_change_notify(xid, tcon, fid.persistent_fid, fid.volatile_fid,
2306 notify.watch_tree, notify.completion_filter);
2307
2308 SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
2309
2310 cifs_dbg(FYI, "change notify for path %s rc %d\n", path, rc);
2311
2312notify_exit:
2313 free_dentry_path(page);
2314 kfree(utf16_path);
2315 return rc;
2316}
2317
2318static int
2319smb2_query_dir_first(const unsigned int xid, struct cifs_tcon *tcon,
2320 const char *path, struct cifs_sb_info *cifs_sb,
2321 struct cifs_fid *fid, __u16 search_flags,
2322 struct cifs_search_info *srch_inf)
2323{
2324 __le16 *utf16_path;
2325 struct smb_rqst rqst[2];
2326 struct kvec rsp_iov[2];
2327 int resp_buftype[2];
2328 struct kvec open_iov[SMB2_CREATE_IOV_SIZE];
2329 struct kvec qd_iov[SMB2_QUERY_DIRECTORY_IOV_SIZE];
2330 int rc, flags = 0;
2331 u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
2332 struct cifs_open_parms oparms;
2333 struct smb2_query_directory_rsp *qd_rsp = NULL;
2334 struct smb2_create_rsp *op_rsp = NULL;
2335 struct TCP_Server_Info *server = cifs_pick_channel(tcon->ses);
2336 int retry_count = 0;
2337
2338 utf16_path = cifs_convert_path_to_utf16(path, cifs_sb);
2339 if (!utf16_path)
2340 return -ENOMEM;
2341
2342 if (smb3_encryption_required(tcon))
2343 flags |= CIFS_TRANSFORM_REQ;
2344
2345 memset(rqst, 0, sizeof(rqst));
2346 resp_buftype[0] = resp_buftype[1] = CIFS_NO_BUFFER;
2347 memset(rsp_iov, 0, sizeof(rsp_iov));
2348
2349
2350 memset(&open_iov, 0, sizeof(open_iov));
2351 rqst[0].rq_iov = open_iov;
2352 rqst[0].rq_nvec = SMB2_CREATE_IOV_SIZE;
2353
2354 oparms.tcon = tcon;
2355 oparms.desired_access = FILE_READ_ATTRIBUTES | FILE_READ_DATA;
2356 oparms.disposition = FILE_OPEN;
2357 oparms.create_options = cifs_create_options(cifs_sb, 0);
2358 oparms.fid = fid;
2359 oparms.reconnect = false;
2360
2361 rc = SMB2_open_init(tcon, server,
2362 &rqst[0], &oplock, &oparms, utf16_path);
2363 if (rc)
2364 goto qdf_free;
2365 smb2_set_next_command(tcon, &rqst[0]);
2366
2367
2368 srch_inf->entries_in_buffer = 0;
2369 srch_inf->index_of_last_entry = 2;
2370
2371 memset(&qd_iov, 0, sizeof(qd_iov));
2372 rqst[1].rq_iov = qd_iov;
2373 rqst[1].rq_nvec = SMB2_QUERY_DIRECTORY_IOV_SIZE;
2374
2375 rc = SMB2_query_directory_init(xid, tcon, server,
2376 &rqst[1],
2377 COMPOUND_FID, COMPOUND_FID,
2378 0, srch_inf->info_level);
2379 if (rc)
2380 goto qdf_free;
2381
2382 smb2_set_related(&rqst[1]);
2383
2384again:
2385 rc = compound_send_recv(xid, tcon->ses, server,
2386 flags, 2, rqst,
2387 resp_buftype, rsp_iov);
2388
2389 if (rc == -EAGAIN && retry_count++ < 10)
2390 goto again;
2391
2392
2393 op_rsp = (struct smb2_create_rsp *)rsp_iov[0].iov_base;
2394 if (op_rsp == NULL || op_rsp->sync_hdr.Status != STATUS_SUCCESS) {
2395 cifs_dbg(FYI, "query_dir_first: open failed rc=%d\n", rc);
2396 goto qdf_free;
2397 }
2398 fid->persistent_fid = op_rsp->PersistentFileId;
2399 fid->volatile_fid = op_rsp->VolatileFileId;
2400
2401
2402 if (rc && rc != -ENODATA) {
2403 SMB2_close(xid, tcon, fid->persistent_fid, fid->volatile_fid);
2404 cifs_dbg(FYI, "query_dir_first: query directory failed rc=%d\n", rc);
2405 trace_smb3_query_dir_err(xid, fid->persistent_fid,
2406 tcon->tid, tcon->ses->Suid, 0, 0, rc);
2407 goto qdf_free;
2408 }
2409
2410 atomic_inc(&tcon->num_remote_opens);
2411
2412 qd_rsp = (struct smb2_query_directory_rsp *)rsp_iov[1].iov_base;
2413 if (qd_rsp->sync_hdr.Status == STATUS_NO_MORE_FILES) {
2414 trace_smb3_query_dir_done(xid, fid->persistent_fid,
2415 tcon->tid, tcon->ses->Suid, 0, 0);
2416 srch_inf->endOfSearch = true;
2417 rc = 0;
2418 goto qdf_free;
2419 }
2420
2421 rc = smb2_parse_query_directory(tcon, &rsp_iov[1], resp_buftype[1],
2422 srch_inf);
2423 if (rc) {
2424 trace_smb3_query_dir_err(xid, fid->persistent_fid, tcon->tid,
2425 tcon->ses->Suid, 0, 0, rc);
2426 goto qdf_free;
2427 }
2428 resp_buftype[1] = CIFS_NO_BUFFER;
2429
2430 trace_smb3_query_dir_done(xid, fid->persistent_fid, tcon->tid,
2431 tcon->ses->Suid, 0, srch_inf->entries_in_buffer);
2432
2433 qdf_free:
2434 kfree(utf16_path);
2435 SMB2_open_free(&rqst[0]);
2436 SMB2_query_directory_free(&rqst[1]);
2437 free_rsp_buf(resp_buftype[0], rsp_iov[0].iov_base);
2438 free_rsp_buf(resp_buftype[1], rsp_iov[1].iov_base);
2439 return rc;
2440}
2441
2442static int
2443smb2_query_dir_next(const unsigned int xid, struct cifs_tcon *tcon,
2444 struct cifs_fid *fid, __u16 search_flags,
2445 struct cifs_search_info *srch_inf)
2446{
2447 return SMB2_query_directory(xid, tcon, fid->persistent_fid,
2448 fid->volatile_fid, 0, srch_inf);
2449}
2450
2451static int
2452smb2_close_dir(const unsigned int xid, struct cifs_tcon *tcon,
2453 struct cifs_fid *fid)
2454{
2455 return SMB2_close(xid, tcon, fid->persistent_fid, fid->volatile_fid);
2456}
2457
2458
2459
2460
2461
2462static bool
2463smb2_is_status_pending(char *buf, struct TCP_Server_Info *server)
2464{
2465 struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)buf;
2466 int scredits, in_flight;
2467
2468 if (shdr->Status != STATUS_PENDING)
2469 return false;
2470
2471 if (shdr->CreditRequest) {
2472 spin_lock(&server->req_lock);
2473 server->credits += le16_to_cpu(shdr->CreditRequest);
2474 scredits = server->credits;
2475 in_flight = server->in_flight;
2476 spin_unlock(&server->req_lock);
2477 wake_up(&server->request_q);
2478
2479 trace_smb3_add_credits(server->CurrentMid,
2480 server->conn_id, server->hostname, scredits,
2481 le16_to_cpu(shdr->CreditRequest), in_flight);
2482 cifs_dbg(FYI, "%s: status pending add %u credits total=%d\n",
2483 __func__, le16_to_cpu(shdr->CreditRequest), scredits);
2484 }
2485
2486 return true;
2487}
2488
2489static bool
2490smb2_is_session_expired(char *buf)
2491{
2492 struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)buf;
2493
2494 if (shdr->Status != STATUS_NETWORK_SESSION_EXPIRED &&
2495 shdr->Status != STATUS_USER_SESSION_DELETED)
2496 return false;
2497
2498 trace_smb3_ses_expired(shdr->TreeId, shdr->SessionId,
2499 le16_to_cpu(shdr->Command),
2500 le64_to_cpu(shdr->MessageId));
2501 cifs_dbg(FYI, "Session expired or deleted\n");
2502
2503 return true;
2504}
2505
2506static bool
2507smb2_is_status_io_timeout(char *buf)
2508{
2509 struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)buf;
2510
2511 if (shdr->Status == STATUS_IO_TIMEOUT)
2512 return true;
2513 else
2514 return false;
2515}
2516
2517static void
2518smb2_is_network_name_deleted(char *buf, struct TCP_Server_Info *server)
2519{
2520 struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)buf;
2521 struct list_head *tmp, *tmp1;
2522 struct cifs_ses *ses;
2523 struct cifs_tcon *tcon;
2524
2525 if (shdr->Status != STATUS_NETWORK_NAME_DELETED)
2526 return;
2527
2528 spin_lock(&cifs_tcp_ses_lock);
2529 list_for_each(tmp, &server->smb_ses_list) {
2530 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
2531 list_for_each(tmp1, &ses->tcon_list) {
2532 tcon = list_entry(tmp1, struct cifs_tcon, tcon_list);
2533 if (tcon->tid == shdr->TreeId) {
2534 tcon->need_reconnect = true;
2535 spin_unlock(&cifs_tcp_ses_lock);
2536 pr_warn_once("Server share %s deleted.\n",
2537 tcon->treeName);
2538 return;
2539 }
2540 }
2541 }
2542 spin_unlock(&cifs_tcp_ses_lock);
2543}
2544
2545static int
2546smb2_oplock_response(struct cifs_tcon *tcon, struct cifs_fid *fid,
2547 struct cifsInodeInfo *cinode)
2548{
2549 if (tcon->ses->server->capabilities & SMB2_GLOBAL_CAP_LEASING)
2550 return SMB2_lease_break(0, tcon, cinode->lease_key,
2551 smb2_get_lease_state(cinode));
2552
2553 return SMB2_oplock_break(0, tcon, fid->persistent_fid,
2554 fid->volatile_fid,
2555 CIFS_CACHE_READ(cinode) ? 1 : 0);
2556}
2557
2558void
2559smb2_set_related(struct smb_rqst *rqst)
2560{
2561 struct smb2_sync_hdr *shdr;
2562
2563 shdr = (struct smb2_sync_hdr *)(rqst->rq_iov[0].iov_base);
2564 if (shdr == NULL) {
2565 cifs_dbg(FYI, "shdr NULL in smb2_set_related\n");
2566 return;
2567 }
2568 shdr->Flags |= SMB2_FLAGS_RELATED_OPERATIONS;
2569}
2570
2571char smb2_padding[7] = {0, 0, 0, 0, 0, 0, 0};
2572
2573void
2574smb2_set_next_command(struct cifs_tcon *tcon, struct smb_rqst *rqst)
2575{
2576 struct smb2_sync_hdr *shdr;
2577 struct cifs_ses *ses = tcon->ses;
2578 struct TCP_Server_Info *server = ses->server;
2579 unsigned long len = smb_rqst_len(server, rqst);
2580 int i, num_padding;
2581
2582 shdr = (struct smb2_sync_hdr *)(rqst->rq_iov[0].iov_base);
2583 if (shdr == NULL) {
2584 cifs_dbg(FYI, "shdr NULL in smb2_set_next_command\n");
2585 return;
2586 }
2587
2588
2589
2590
2591 if (!(len & 7))
2592 goto finished;
2593
2594 num_padding = 8 - (len & 7);
2595 if (!smb3_encryption_required(tcon)) {
2596
2597
2598
2599
2600 rqst->rq_iov[rqst->rq_nvec].iov_base = smb2_padding;
2601 rqst->rq_iov[rqst->rq_nvec].iov_len = num_padding;
2602 rqst->rq_nvec++;
2603 len += num_padding;
2604 } else {
2605
2606
2607
2608
2609
2610
2611
2612 for (i = 1; i < rqst->rq_nvec; i++) {
2613 memcpy(rqst->rq_iov[0].iov_base +
2614 rqst->rq_iov[0].iov_len,
2615 rqst->rq_iov[i].iov_base,
2616 rqst->rq_iov[i].iov_len);
2617 rqst->rq_iov[0].iov_len += rqst->rq_iov[i].iov_len;
2618 }
2619 memset(rqst->rq_iov[0].iov_base + rqst->rq_iov[0].iov_len,
2620 0, num_padding);
2621 rqst->rq_iov[0].iov_len += num_padding;
2622 len += num_padding;
2623 rqst->rq_nvec = 1;
2624 }
2625
2626 finished:
2627 shdr->NextCommand = cpu_to_le32(len);
2628}
2629
2630
2631
2632
2633
2634int
2635smb2_query_info_compound(const unsigned int xid, struct cifs_tcon *tcon,
2636 __le16 *utf16_path, u32 desired_access,
2637 u32 class, u32 type, u32 output_len,
2638 struct kvec *rsp, int *buftype,
2639 struct cifs_sb_info *cifs_sb)
2640{
2641 struct cifs_ses *ses = tcon->ses;
2642 struct TCP_Server_Info *server = cifs_pick_channel(ses);
2643 int flags = CIFS_CP_CREATE_CLOSE_OP;
2644 struct smb_rqst rqst[3];
2645 int resp_buftype[3];
2646 struct kvec rsp_iov[3];
2647 struct kvec open_iov[SMB2_CREATE_IOV_SIZE];
2648 struct kvec qi_iov[1];
2649 struct kvec close_iov[1];
2650 u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
2651 struct cifs_open_parms oparms;
2652 struct cifs_fid fid;
2653 int rc;
2654
2655 if (smb3_encryption_required(tcon))
2656 flags |= CIFS_TRANSFORM_REQ;
2657
2658 memset(rqst, 0, sizeof(rqst));
2659 resp_buftype[0] = resp_buftype[1] = resp_buftype[2] = CIFS_NO_BUFFER;
2660 memset(rsp_iov, 0, sizeof(rsp_iov));
2661
2662 memset(&open_iov, 0, sizeof(open_iov));
2663 rqst[0].rq_iov = open_iov;
2664 rqst[0].rq_nvec = SMB2_CREATE_IOV_SIZE;
2665
2666 oparms.tcon = tcon;
2667 oparms.desired_access = desired_access;
2668 oparms.disposition = FILE_OPEN;
2669 oparms.create_options = cifs_create_options(cifs_sb, 0);
2670 oparms.fid = &fid;
2671 oparms.reconnect = false;
2672
2673 rc = SMB2_open_init(tcon, server,
2674 &rqst[0], &oplock, &oparms, utf16_path);
2675 if (rc)
2676 goto qic_exit;
2677 smb2_set_next_command(tcon, &rqst[0]);
2678
2679 memset(&qi_iov, 0, sizeof(qi_iov));
2680 rqst[1].rq_iov = qi_iov;
2681 rqst[1].rq_nvec = 1;
2682
2683 rc = SMB2_query_info_init(tcon, server,
2684 &rqst[1], COMPOUND_FID, COMPOUND_FID,
2685 class, type, 0,
2686 output_len, 0,
2687 NULL);
2688 if (rc)
2689 goto qic_exit;
2690 smb2_set_next_command(tcon, &rqst[1]);
2691 smb2_set_related(&rqst[1]);
2692
2693 memset(&close_iov, 0, sizeof(close_iov));
2694 rqst[2].rq_iov = close_iov;
2695 rqst[2].rq_nvec = 1;
2696
2697 rc = SMB2_close_init(tcon, server,
2698 &rqst[2], COMPOUND_FID, COMPOUND_FID, false);
2699 if (rc)
2700 goto qic_exit;
2701 smb2_set_related(&rqst[2]);
2702
2703 rc = compound_send_recv(xid, ses, server,
2704 flags, 3, rqst,
2705 resp_buftype, rsp_iov);
2706 if (rc) {
2707 free_rsp_buf(resp_buftype[1], rsp_iov[1].iov_base);
2708 if (rc == -EREMCHG) {
2709 tcon->need_reconnect = true;
2710 pr_warn_once("server share %s deleted\n",
2711 tcon->treeName);
2712 }
2713 goto qic_exit;
2714 }
2715 *rsp = rsp_iov[1];
2716 *buftype = resp_buftype[1];
2717
2718 qic_exit:
2719 SMB2_open_free(&rqst[0]);
2720 SMB2_query_info_free(&rqst[1]);
2721 SMB2_close_free(&rqst[2]);
2722 free_rsp_buf(resp_buftype[0], rsp_iov[0].iov_base);
2723 free_rsp_buf(resp_buftype[2], rsp_iov[2].iov_base);
2724 return rc;
2725}
2726
2727static int
2728smb2_queryfs(const unsigned int xid, struct cifs_tcon *tcon,
2729 struct cifs_sb_info *cifs_sb, struct kstatfs *buf)
2730{
2731 struct smb2_query_info_rsp *rsp;
2732 struct smb2_fs_full_size_info *info = NULL;
2733 __le16 utf16_path = 0;
2734 struct kvec rsp_iov = {NULL, 0};
2735 int buftype = CIFS_NO_BUFFER;
2736 int rc;
2737
2738
2739 rc = smb2_query_info_compound(xid, tcon, &utf16_path,
2740 FILE_READ_ATTRIBUTES,
2741 FS_FULL_SIZE_INFORMATION,
2742 SMB2_O_INFO_FILESYSTEM,
2743 sizeof(struct smb2_fs_full_size_info),
2744 &rsp_iov, &buftype, cifs_sb);
2745 if (rc)
2746 goto qfs_exit;
2747
2748 rsp = (struct smb2_query_info_rsp *)rsp_iov.iov_base;
2749 buf->f_type = SMB2_MAGIC_NUMBER;
2750 info = (struct smb2_fs_full_size_info *)(
2751 le16_to_cpu(rsp->OutputBufferOffset) + (char *)rsp);
2752 rc = smb2_validate_iov(le16_to_cpu(rsp->OutputBufferOffset),
2753 le32_to_cpu(rsp->OutputBufferLength),
2754 &rsp_iov,
2755 sizeof(struct smb2_fs_full_size_info));
2756 if (!rc)
2757 smb2_copy_fs_info_to_kstatfs(info, buf);
2758
2759qfs_exit:
2760 free_rsp_buf(buftype, rsp_iov.iov_base);
2761 return rc;
2762}
2763
2764static int
2765smb311_queryfs(const unsigned int xid, struct cifs_tcon *tcon,
2766 struct cifs_sb_info *cifs_sb, struct kstatfs *buf)
2767{
2768 int rc;
2769 __le16 srch_path = 0;
2770 u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
2771 struct cifs_open_parms oparms;
2772 struct cifs_fid fid;
2773
2774 if (!tcon->posix_extensions)
2775 return smb2_queryfs(xid, tcon, cifs_sb, buf);
2776
2777 oparms.tcon = tcon;
2778 oparms.desired_access = FILE_READ_ATTRIBUTES;
2779 oparms.disposition = FILE_OPEN;
2780 oparms.create_options = cifs_create_options(cifs_sb, 0);
2781 oparms.fid = &fid;
2782 oparms.reconnect = false;
2783
2784 rc = SMB2_open(xid, &oparms, &srch_path, &oplock, NULL, NULL,
2785 NULL, NULL);
2786 if (rc)
2787 return rc;
2788
2789 rc = SMB311_posix_qfs_info(xid, tcon, fid.persistent_fid,
2790 fid.volatile_fid, buf);
2791 buf->f_type = SMB2_MAGIC_NUMBER;
2792 SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
2793 return rc;
2794}
2795
2796static bool
2797smb2_compare_fids(struct cifsFileInfo *ob1, struct cifsFileInfo *ob2)
2798{
2799 return ob1->fid.persistent_fid == ob2->fid.persistent_fid &&
2800 ob1->fid.volatile_fid == ob2->fid.volatile_fid;
2801}
2802
2803static int
2804smb2_mand_lock(const unsigned int xid, struct cifsFileInfo *cfile, __u64 offset,
2805 __u64 length, __u32 type, int lock, int unlock, bool wait)
2806{
2807 if (unlock && !lock)
2808 type = SMB2_LOCKFLAG_UNLOCK;
2809 return SMB2_lock(xid, tlink_tcon(cfile->tlink),
2810 cfile->fid.persistent_fid, cfile->fid.volatile_fid,
2811 current->tgid, length, offset, type, wait);
2812}
2813
2814static void
2815smb2_get_lease_key(struct inode *inode, struct cifs_fid *fid)
2816{
2817 memcpy(fid->lease_key, CIFS_I(inode)->lease_key, SMB2_LEASE_KEY_SIZE);
2818}
2819
2820static void
2821smb2_set_lease_key(struct inode *inode, struct cifs_fid *fid)
2822{
2823 memcpy(CIFS_I(inode)->lease_key, fid->lease_key, SMB2_LEASE_KEY_SIZE);
2824}
2825
2826static void
2827smb2_new_lease_key(struct cifs_fid *fid)
2828{
2829 generate_random_uuid(fid->lease_key);
2830}
2831
2832static int
2833smb2_get_dfs_refer(const unsigned int xid, struct cifs_ses *ses,
2834 const char *search_name,
2835 struct dfs_info3_param **target_nodes,
2836 unsigned int *num_of_nodes,
2837 const struct nls_table *nls_codepage, int remap)
2838{
2839 int rc;
2840 __le16 *utf16_path = NULL;
2841 int utf16_path_len = 0;
2842 struct cifs_tcon *tcon;
2843 struct fsctl_get_dfs_referral_req *dfs_req = NULL;
2844 struct get_dfs_referral_rsp *dfs_rsp = NULL;
2845 u32 dfs_req_size = 0, dfs_rsp_size = 0;
2846
2847 cifs_dbg(FYI, "%s: path: %s\n", __func__, search_name);
2848
2849
2850
2851
2852 tcon = ses->tcon_ipc;
2853 if (tcon == NULL) {
2854 spin_lock(&cifs_tcp_ses_lock);
2855 tcon = list_first_entry_or_null(&ses->tcon_list,
2856 struct cifs_tcon,
2857 tcon_list);
2858 if (tcon)
2859 tcon->tc_count++;
2860 spin_unlock(&cifs_tcp_ses_lock);
2861 }
2862
2863 if (tcon == NULL) {
2864 cifs_dbg(VFS, "session %p has no tcon available for a dfs referral request\n",
2865 ses);
2866 rc = -ENOTCONN;
2867 goto out;
2868 }
2869
2870 utf16_path = cifs_strndup_to_utf16(search_name, PATH_MAX,
2871 &utf16_path_len,
2872 nls_codepage, remap);
2873 if (!utf16_path) {
2874 rc = -ENOMEM;
2875 goto out;
2876 }
2877
2878 dfs_req_size = sizeof(*dfs_req) + utf16_path_len;
2879 dfs_req = kzalloc(dfs_req_size, GFP_KERNEL);
2880 if (!dfs_req) {
2881 rc = -ENOMEM;
2882 goto out;
2883 }
2884
2885
2886 dfs_req->MaxReferralLevel = DFS_VERSION;
2887
2888
2889 memcpy(dfs_req->RequestFileName, utf16_path, utf16_path_len);
2890
2891 do {
2892 rc = SMB2_ioctl(xid, tcon, NO_FILE_ID, NO_FILE_ID,
2893 FSCTL_DFS_GET_REFERRALS,
2894 true ,
2895 (char *)dfs_req, dfs_req_size, CIFSMaxBufSize,
2896 (char **)&dfs_rsp, &dfs_rsp_size);
2897 } while (rc == -EAGAIN);
2898
2899 if (rc) {
2900 if ((rc != -ENOENT) && (rc != -EOPNOTSUPP))
2901 cifs_tcon_dbg(VFS, "ioctl error in %s rc=%d\n", __func__, rc);
2902 goto out;
2903 }
2904
2905 rc = parse_dfs_referrals(dfs_rsp, dfs_rsp_size,
2906 num_of_nodes, target_nodes,
2907 nls_codepage, remap, search_name,
2908 true );
2909 if (rc) {
2910 cifs_tcon_dbg(VFS, "parse error in %s rc=%d\n", __func__, rc);
2911 goto out;
2912 }
2913
2914 out:
2915 if (tcon && !tcon->ipc) {
2916
2917 spin_lock(&cifs_tcp_ses_lock);
2918 tcon->tc_count--;
2919
2920 WARN_ON(tcon->tc_count < 0);
2921 spin_unlock(&cifs_tcp_ses_lock);
2922 }
2923 kfree(utf16_path);
2924 kfree(dfs_req);
2925 kfree(dfs_rsp);
2926 return rc;
2927}
2928
2929static int
2930parse_reparse_posix(struct reparse_posix_data *symlink_buf,
2931 u32 plen, char **target_path,
2932 struct cifs_sb_info *cifs_sb)
2933{
2934 unsigned int len;
2935
2936
2937 len = le16_to_cpu(symlink_buf->ReparseDataLength);
2938
2939 if (le64_to_cpu(symlink_buf->InodeType) != NFS_SPECFILE_LNK) {
2940 cifs_dbg(VFS, "%lld not a supported symlink type\n",
2941 le64_to_cpu(symlink_buf->InodeType));
2942 return -EOPNOTSUPP;
2943 }
2944
2945 *target_path = cifs_strndup_from_utf16(
2946 symlink_buf->PathBuffer,
2947 len, true, cifs_sb->local_nls);
2948 if (!(*target_path))
2949 return -ENOMEM;
2950
2951 convert_delimiter(*target_path, '/');
2952 cifs_dbg(FYI, "%s: target path: %s\n", __func__, *target_path);
2953
2954 return 0;
2955}
2956
2957static int
2958parse_reparse_symlink(struct reparse_symlink_data_buffer *symlink_buf,
2959 u32 plen, char **target_path,
2960 struct cifs_sb_info *cifs_sb)
2961{
2962 unsigned int sub_len;
2963 unsigned int sub_offset;
2964
2965
2966
2967 sub_offset = le16_to_cpu(symlink_buf->SubstituteNameOffset);
2968 sub_len = le16_to_cpu(symlink_buf->SubstituteNameLength);
2969 if (sub_offset + 20 > plen ||
2970 sub_offset + sub_len + 20 > plen) {
2971 cifs_dbg(VFS, "srv returned malformed symlink buffer\n");
2972 return -EIO;
2973 }
2974
2975 *target_path = cifs_strndup_from_utf16(
2976 symlink_buf->PathBuffer + sub_offset,
2977 sub_len, true, cifs_sb->local_nls);
2978 if (!(*target_path))
2979 return -ENOMEM;
2980
2981 convert_delimiter(*target_path, '/');
2982 cifs_dbg(FYI, "%s: target path: %s\n", __func__, *target_path);
2983
2984 return 0;
2985}
2986
2987static int
2988parse_reparse_point(struct reparse_data_buffer *buf,
2989 u32 plen, char **target_path,
2990 struct cifs_sb_info *cifs_sb)
2991{
2992 if (plen < sizeof(struct reparse_data_buffer)) {
2993 cifs_dbg(VFS, "reparse buffer is too small. Must be at least 8 bytes but was %d\n",
2994 plen);
2995 return -EIO;
2996 }
2997
2998 if (plen < le16_to_cpu(buf->ReparseDataLength) +
2999 sizeof(struct reparse_data_buffer)) {
3000 cifs_dbg(VFS, "srv returned invalid reparse buf length: %d\n",
3001 plen);
3002 return -EIO;
3003 }
3004
3005
3006 switch (le32_to_cpu(buf->ReparseTag)) {
3007 case IO_REPARSE_TAG_NFS:
3008 return parse_reparse_posix(
3009 (struct reparse_posix_data *)buf,
3010 plen, target_path, cifs_sb);
3011 case IO_REPARSE_TAG_SYMLINK:
3012 return parse_reparse_symlink(
3013 (struct reparse_symlink_data_buffer *)buf,
3014 plen, target_path, cifs_sb);
3015 default:
3016 cifs_dbg(VFS, "srv returned unknown symlink buffer tag:0x%08x\n",
3017 le32_to_cpu(buf->ReparseTag));
3018 return -EOPNOTSUPP;
3019 }
3020}
3021
3022#define SMB2_SYMLINK_STRUCT_SIZE \
3023 (sizeof(struct smb2_err_rsp) - 1 + sizeof(struct smb2_symlink_err_rsp))
3024
3025static int
3026smb2_query_symlink(const unsigned int xid, struct cifs_tcon *tcon,
3027 struct cifs_sb_info *cifs_sb, const char *full_path,
3028 char **target_path, bool is_reparse_point)
3029{
3030 int rc;
3031 __le16 *utf16_path = NULL;
3032 __u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
3033 struct cifs_open_parms oparms;
3034 struct cifs_fid fid;
3035 struct kvec err_iov = {NULL, 0};
3036 struct smb2_err_rsp *err_buf = NULL;
3037 struct smb2_symlink_err_rsp *symlink;
3038 struct TCP_Server_Info *server = cifs_pick_channel(tcon->ses);
3039 unsigned int sub_len;
3040 unsigned int sub_offset;
3041 unsigned int print_len;
3042 unsigned int print_offset;
3043 int flags = CIFS_CP_CREATE_CLOSE_OP;
3044 struct smb_rqst rqst[3];
3045 int resp_buftype[3];
3046 struct kvec rsp_iov[3];
3047 struct kvec open_iov[SMB2_CREATE_IOV_SIZE];
3048 struct kvec io_iov[SMB2_IOCTL_IOV_SIZE];
3049 struct kvec close_iov[1];
3050 struct smb2_create_rsp *create_rsp;
3051 struct smb2_ioctl_rsp *ioctl_rsp;
3052 struct reparse_data_buffer *reparse_buf;
3053 int create_options = is_reparse_point ? OPEN_REPARSE_POINT : 0;
3054 u32 plen;
3055
3056 cifs_dbg(FYI, "%s: path: %s\n", __func__, full_path);
3057
3058 *target_path = NULL;
3059
3060 if (smb3_encryption_required(tcon))
3061 flags |= CIFS_TRANSFORM_REQ;
3062
3063 memset(rqst, 0, sizeof(rqst));
3064 resp_buftype[0] = resp_buftype[1] = resp_buftype[2] = CIFS_NO_BUFFER;
3065 memset(rsp_iov, 0, sizeof(rsp_iov));
3066
3067 utf16_path = cifs_convert_path_to_utf16(full_path, cifs_sb);
3068 if (!utf16_path)
3069 return -ENOMEM;
3070
3071
3072 memset(&open_iov, 0, sizeof(open_iov));
3073 rqst[0].rq_iov = open_iov;
3074 rqst[0].rq_nvec = SMB2_CREATE_IOV_SIZE;
3075
3076 memset(&oparms, 0, sizeof(oparms));
3077 oparms.tcon = tcon;
3078 oparms.desired_access = FILE_READ_ATTRIBUTES;
3079 oparms.disposition = FILE_OPEN;
3080 oparms.create_options = cifs_create_options(cifs_sb, create_options);
3081 oparms.fid = &fid;
3082 oparms.reconnect = false;
3083
3084 rc = SMB2_open_init(tcon, server,
3085 &rqst[0], &oplock, &oparms, utf16_path);
3086 if (rc)
3087 goto querty_exit;
3088 smb2_set_next_command(tcon, &rqst[0]);
3089
3090
3091
3092 memset(&io_iov, 0, sizeof(io_iov));
3093 rqst[1].rq_iov = io_iov;
3094 rqst[1].rq_nvec = SMB2_IOCTL_IOV_SIZE;
3095
3096 rc = SMB2_ioctl_init(tcon, server,
3097 &rqst[1], fid.persistent_fid,
3098 fid.volatile_fid, FSCTL_GET_REPARSE_POINT,
3099 true , NULL, 0,
3100 CIFSMaxBufSize -
3101 MAX_SMB2_CREATE_RESPONSE_SIZE -
3102 MAX_SMB2_CLOSE_RESPONSE_SIZE);
3103 if (rc)
3104 goto querty_exit;
3105
3106 smb2_set_next_command(tcon, &rqst[1]);
3107 smb2_set_related(&rqst[1]);
3108
3109
3110
3111 memset(&close_iov, 0, sizeof(close_iov));
3112 rqst[2].rq_iov = close_iov;
3113 rqst[2].rq_nvec = 1;
3114
3115 rc = SMB2_close_init(tcon, server,
3116 &rqst[2], COMPOUND_FID, COMPOUND_FID, false);
3117 if (rc)
3118 goto querty_exit;
3119
3120 smb2_set_related(&rqst[2]);
3121
3122 rc = compound_send_recv(xid, tcon->ses, server,
3123 flags, 3, rqst,
3124 resp_buftype, rsp_iov);
3125
3126 create_rsp = rsp_iov[0].iov_base;
3127 if (create_rsp && create_rsp->sync_hdr.Status)
3128 err_iov = rsp_iov[0];
3129 ioctl_rsp = rsp_iov[1].iov_base;
3130
3131
3132
3133
3134 if ((rc == 0) && (is_reparse_point)) {
3135
3136
3137 reparse_buf = (struct reparse_data_buffer *)
3138 ((char *)ioctl_rsp +
3139 le32_to_cpu(ioctl_rsp->OutputOffset));
3140 plen = le32_to_cpu(ioctl_rsp->OutputCount);
3141
3142 if (plen + le32_to_cpu(ioctl_rsp->OutputOffset) >
3143 rsp_iov[1].iov_len) {
3144 cifs_tcon_dbg(VFS, "srv returned invalid ioctl len: %d\n",
3145 plen);
3146 rc = -EIO;
3147 goto querty_exit;
3148 }
3149
3150 rc = parse_reparse_point(reparse_buf, plen, target_path,
3151 cifs_sb);
3152 goto querty_exit;
3153 }
3154
3155 if (!rc || !err_iov.iov_base) {
3156 rc = -ENOENT;
3157 goto querty_exit;
3158 }
3159
3160 err_buf = err_iov.iov_base;
3161 if (le32_to_cpu(err_buf->ByteCount) < sizeof(struct smb2_symlink_err_rsp) ||
3162 err_iov.iov_len < SMB2_SYMLINK_STRUCT_SIZE) {
3163 rc = -EINVAL;
3164 goto querty_exit;
3165 }
3166
3167 symlink = (struct smb2_symlink_err_rsp *)err_buf->ErrorData;
3168 if (le32_to_cpu(symlink->SymLinkErrorTag) != SYMLINK_ERROR_TAG ||
3169 le32_to_cpu(symlink->ReparseTag) != IO_REPARSE_TAG_SYMLINK) {
3170 rc = -EINVAL;
3171 goto querty_exit;
3172 }
3173
3174
3175 rc = 0;
3176 sub_len = le16_to_cpu(symlink->SubstituteNameLength);
3177 sub_offset = le16_to_cpu(symlink->SubstituteNameOffset);
3178 print_len = le16_to_cpu(symlink->PrintNameLength);
3179 print_offset = le16_to_cpu(symlink->PrintNameOffset);
3180
3181 if (err_iov.iov_len < SMB2_SYMLINK_STRUCT_SIZE + sub_offset + sub_len) {
3182 rc = -EINVAL;
3183 goto querty_exit;
3184 }
3185
3186 if (err_iov.iov_len <
3187 SMB2_SYMLINK_STRUCT_SIZE + print_offset + print_len) {
3188 rc = -EINVAL;
3189 goto querty_exit;
3190 }
3191
3192 *target_path = cifs_strndup_from_utf16(
3193 (char *)symlink->PathBuffer + sub_offset,
3194 sub_len, true, cifs_sb->local_nls);
3195 if (!(*target_path)) {
3196 rc = -ENOMEM;
3197 goto querty_exit;
3198 }
3199 convert_delimiter(*target_path, '/');
3200 cifs_dbg(FYI, "%s: target path: %s\n", __func__, *target_path);
3201
3202 querty_exit:
3203 cifs_dbg(FYI, "query symlink rc %d\n", rc);
3204 kfree(utf16_path);
3205 SMB2_open_free(&rqst[0]);
3206 SMB2_ioctl_free(&rqst[1]);
3207 SMB2_close_free(&rqst[2]);
3208 free_rsp_buf(resp_buftype[0], rsp_iov[0].iov_base);
3209 free_rsp_buf(resp_buftype[1], rsp_iov[1].iov_base);
3210 free_rsp_buf(resp_buftype[2], rsp_iov[2].iov_base);
3211 return rc;
3212}
3213
3214int
3215smb2_query_reparse_tag(const unsigned int xid, struct cifs_tcon *tcon,
3216 struct cifs_sb_info *cifs_sb, const char *full_path,
3217 __u32 *tag)
3218{
3219 int rc;
3220 __le16 *utf16_path = NULL;
3221 __u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
3222 struct cifs_open_parms oparms;
3223 struct cifs_fid fid;
3224 struct TCP_Server_Info *server = cifs_pick_channel(tcon->ses);
3225 int flags = CIFS_CP_CREATE_CLOSE_OP;
3226 struct smb_rqst rqst[3];
3227 int resp_buftype[3];
3228 struct kvec rsp_iov[3];
3229 struct kvec open_iov[SMB2_CREATE_IOV_SIZE];
3230 struct kvec io_iov[SMB2_IOCTL_IOV_SIZE];
3231 struct kvec close_iov[1];
3232 struct smb2_ioctl_rsp *ioctl_rsp;
3233 struct reparse_data_buffer *reparse_buf;
3234 u32 plen;
3235
3236 cifs_dbg(FYI, "%s: path: %s\n", __func__, full_path);
3237
3238 if (smb3_encryption_required(tcon))
3239 flags |= CIFS_TRANSFORM_REQ;
3240
3241 memset(rqst, 0, sizeof(rqst));
3242 resp_buftype[0] = resp_buftype[1] = resp_buftype[2] = CIFS_NO_BUFFER;
3243 memset(rsp_iov, 0, sizeof(rsp_iov));
3244
3245 utf16_path = cifs_convert_path_to_utf16(full_path, cifs_sb);
3246 if (!utf16_path)
3247 return -ENOMEM;
3248
3249
3250
3251
3252
3253 memset(&open_iov, 0, sizeof(open_iov));
3254 rqst[0].rq_iov = open_iov;
3255 rqst[0].rq_nvec = SMB2_CREATE_IOV_SIZE;
3256
3257 memset(&oparms, 0, sizeof(oparms));
3258 oparms.tcon = tcon;
3259 oparms.desired_access = FILE_READ_ATTRIBUTES;
3260 oparms.disposition = FILE_OPEN;
3261 oparms.create_options = cifs_create_options(cifs_sb, OPEN_REPARSE_POINT);
3262 oparms.fid = &fid;
3263 oparms.reconnect = false;
3264
3265 rc = SMB2_open_init(tcon, server,
3266 &rqst[0], &oplock, &oparms, utf16_path);
3267 if (rc)
3268 goto query_rp_exit;
3269 smb2_set_next_command(tcon, &rqst[0]);
3270
3271
3272
3273 memset(&io_iov, 0, sizeof(io_iov));
3274 rqst[1].rq_iov = io_iov;
3275 rqst[1].rq_nvec = SMB2_IOCTL_IOV_SIZE;
3276
3277 rc = SMB2_ioctl_init(tcon, server,
3278 &rqst[1], COMPOUND_FID,
3279 COMPOUND_FID, FSCTL_GET_REPARSE_POINT,
3280 true , NULL, 0,
3281 CIFSMaxBufSize -
3282 MAX_SMB2_CREATE_RESPONSE_SIZE -
3283 MAX_SMB2_CLOSE_RESPONSE_SIZE);
3284 if (rc)
3285 goto query_rp_exit;
3286
3287 smb2_set_next_command(tcon, &rqst[1]);
3288 smb2_set_related(&rqst[1]);
3289
3290
3291
3292 memset(&close_iov, 0, sizeof(close_iov));
3293 rqst[2].rq_iov = close_iov;
3294 rqst[2].rq_nvec = 1;
3295
3296 rc = SMB2_close_init(tcon, server,
3297 &rqst[2], COMPOUND_FID, COMPOUND_FID, false);
3298 if (rc)
3299 goto query_rp_exit;
3300
3301 smb2_set_related(&rqst[2]);
3302
3303 rc = compound_send_recv(xid, tcon->ses, server,
3304 flags, 3, rqst,
3305 resp_buftype, rsp_iov);
3306
3307 ioctl_rsp = rsp_iov[1].iov_base;
3308
3309
3310
3311
3312 if (rc == 0) {
3313
3314
3315 reparse_buf = (struct reparse_data_buffer *)
3316 ((char *)ioctl_rsp +
3317 le32_to_cpu(ioctl_rsp->OutputOffset));
3318 plen = le32_to_cpu(ioctl_rsp->OutputCount);
3319
3320 if (plen + le32_to_cpu(ioctl_rsp->OutputOffset) >
3321 rsp_iov[1].iov_len) {
3322 cifs_tcon_dbg(FYI, "srv returned invalid ioctl len: %d\n",
3323 plen);
3324 rc = -EIO;
3325 goto query_rp_exit;
3326 }
3327 *tag = le32_to_cpu(reparse_buf->ReparseTag);
3328 }
3329
3330 query_rp_exit:
3331 kfree(utf16_path);
3332 SMB2_open_free(&rqst[0]);
3333 SMB2_ioctl_free(&rqst[1]);
3334 SMB2_close_free(&rqst[2]);
3335 free_rsp_buf(resp_buftype[0], rsp_iov[0].iov_base);
3336 free_rsp_buf(resp_buftype[1], rsp_iov[1].iov_base);
3337 free_rsp_buf(resp_buftype[2], rsp_iov[2].iov_base);
3338 return rc;
3339}
3340
3341static struct cifs_ntsd *
3342get_smb2_acl_by_fid(struct cifs_sb_info *cifs_sb,
3343 const struct cifs_fid *cifsfid, u32 *pacllen, u32 info)
3344{
3345 struct cifs_ntsd *pntsd = NULL;
3346 unsigned int xid;
3347 int rc = -EOPNOTSUPP;
3348 struct tcon_link *tlink = cifs_sb_tlink(cifs_sb);
3349
3350 if (IS_ERR(tlink))
3351 return ERR_CAST(tlink);
3352
3353 xid = get_xid();
3354 cifs_dbg(FYI, "trying to get acl\n");
3355
3356 rc = SMB2_query_acl(xid, tlink_tcon(tlink), cifsfid->persistent_fid,
3357 cifsfid->volatile_fid, (void **)&pntsd, pacllen,
3358 info);
3359 free_xid(xid);
3360
3361 cifs_put_tlink(tlink);
3362
3363 cifs_dbg(FYI, "%s: rc = %d ACL len %d\n", __func__, rc, *pacllen);
3364 if (rc)
3365 return ERR_PTR(rc);
3366 return pntsd;
3367
3368}
3369
3370static struct cifs_ntsd *
3371get_smb2_acl_by_path(struct cifs_sb_info *cifs_sb,
3372 const char *path, u32 *pacllen, u32 info)
3373{
3374 struct cifs_ntsd *pntsd = NULL;
3375 u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
3376 unsigned int xid;
3377 int rc;
3378 struct cifs_tcon *tcon;
3379 struct tcon_link *tlink = cifs_sb_tlink(cifs_sb);
3380 struct cifs_fid fid;
3381 struct cifs_open_parms oparms;
3382 __le16 *utf16_path;
3383
3384 cifs_dbg(FYI, "get smb3 acl for path %s\n", path);
3385 if (IS_ERR(tlink))
3386 return ERR_CAST(tlink);
3387
3388 tcon = tlink_tcon(tlink);
3389 xid = get_xid();
3390
3391 utf16_path = cifs_convert_path_to_utf16(path, cifs_sb);
3392 if (!utf16_path) {
3393 rc = -ENOMEM;
3394 free_xid(xid);
3395 return ERR_PTR(rc);
3396 }
3397
3398 oparms.tcon = tcon;
3399 oparms.desired_access = READ_CONTROL;
3400 oparms.disposition = FILE_OPEN;
3401
3402
3403
3404
3405
3406 oparms.create_options = cifs_create_options(cifs_sb, 0) | OPEN_REPARSE_POINT;
3407 oparms.fid = &fid;
3408 oparms.reconnect = false;
3409
3410 if (info & SACL_SECINFO)
3411 oparms.desired_access |= SYSTEM_SECURITY;
3412
3413 rc = SMB2_open(xid, &oparms, utf16_path, &oplock, NULL, NULL, NULL,
3414 NULL);
3415 kfree(utf16_path);
3416 if (!rc) {
3417 rc = SMB2_query_acl(xid, tlink_tcon(tlink), fid.persistent_fid,
3418 fid.volatile_fid, (void **)&pntsd, pacllen,
3419 info);
3420 SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
3421 }
3422
3423 cifs_put_tlink(tlink);
3424 free_xid(xid);
3425
3426 cifs_dbg(FYI, "%s: rc = %d ACL len %d\n", __func__, rc, *pacllen);
3427 if (rc)
3428 return ERR_PTR(rc);
3429 return pntsd;
3430}
3431
3432static int
3433set_smb2_acl(struct cifs_ntsd *pnntsd, __u32 acllen,
3434 struct inode *inode, const char *path, int aclflag)
3435{
3436 u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
3437 unsigned int xid;
3438 int rc, access_flags = 0;
3439 struct cifs_tcon *tcon;
3440 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3441 struct tcon_link *tlink = cifs_sb_tlink(cifs_sb);
3442 struct cifs_fid fid;
3443 struct cifs_open_parms oparms;
3444 __le16 *utf16_path;
3445
3446 cifs_dbg(FYI, "set smb3 acl for path %s\n", path);
3447 if (IS_ERR(tlink))
3448 return PTR_ERR(tlink);
3449
3450 tcon = tlink_tcon(tlink);
3451 xid = get_xid();
3452
3453 if (aclflag & CIFS_ACL_OWNER || aclflag & CIFS_ACL_GROUP)
3454 access_flags |= WRITE_OWNER;
3455 if (aclflag & CIFS_ACL_SACL)
3456 access_flags |= SYSTEM_SECURITY;
3457 if (aclflag & CIFS_ACL_DACL)
3458 access_flags |= WRITE_DAC;
3459
3460 utf16_path = cifs_convert_path_to_utf16(path, cifs_sb);
3461 if (!utf16_path) {
3462 rc = -ENOMEM;
3463 free_xid(xid);
3464 return rc;
3465 }
3466
3467 oparms.tcon = tcon;
3468 oparms.desired_access = access_flags;
3469 oparms.create_options = cifs_create_options(cifs_sb, 0);
3470 oparms.disposition = FILE_OPEN;
3471 oparms.path = path;
3472 oparms.fid = &fid;
3473 oparms.reconnect = false;
3474
3475 rc = SMB2_open(xid, &oparms, utf16_path, &oplock, NULL, NULL,
3476 NULL, NULL);
3477 kfree(utf16_path);
3478 if (!rc) {
3479 rc = SMB2_set_acl(xid, tlink_tcon(tlink), fid.persistent_fid,
3480 fid.volatile_fid, pnntsd, acllen, aclflag);
3481 SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
3482 }
3483
3484 cifs_put_tlink(tlink);
3485 free_xid(xid);
3486 return rc;
3487}
3488
3489
3490static struct cifs_ntsd *
3491get_smb2_acl(struct cifs_sb_info *cifs_sb,
3492 struct inode *inode, const char *path,
3493 u32 *pacllen, u32 info)
3494{
3495 struct cifs_ntsd *pntsd = NULL;
3496 struct cifsFileInfo *open_file = NULL;
3497
3498 if (inode && !(info & SACL_SECINFO))
3499 open_file = find_readable_file(CIFS_I(inode), true);
3500 if (!open_file || (info & SACL_SECINFO))
3501 return get_smb2_acl_by_path(cifs_sb, path, pacllen, info);
3502
3503 pntsd = get_smb2_acl_by_fid(cifs_sb, &open_file->fid, pacllen, info);
3504 cifsFileInfo_put(open_file);
3505 return pntsd;
3506}
3507
3508static long smb3_zero_range(struct file *file, struct cifs_tcon *tcon,
3509 loff_t offset, loff_t len, bool keep_size)
3510{
3511 struct cifs_ses *ses = tcon->ses;
3512 struct inode *inode;
3513 struct cifsInodeInfo *cifsi;
3514 struct cifsFileInfo *cfile = file->private_data;
3515 struct file_zero_data_information fsctl_buf;
3516 long rc;
3517 unsigned int xid;
3518 __le64 eof;
3519
3520 xid = get_xid();
3521
3522 inode = d_inode(cfile->dentry);
3523 cifsi = CIFS_I(inode);
3524
3525 trace_smb3_zero_enter(xid, cfile->fid.persistent_fid, tcon->tid,
3526 ses->Suid, offset, len);
3527
3528
3529
3530
3531
3532 truncate_pagecache_range(inode, offset, offset + len - 1);
3533
3534
3535 if (!CIFS_CACHE_READ(cifsi))
3536 if (keep_size == false) {
3537 rc = -EOPNOTSUPP;
3538 trace_smb3_zero_err(xid, cfile->fid.persistent_fid,
3539 tcon->tid, ses->Suid, offset, len, rc);
3540 free_xid(xid);
3541 return rc;
3542 }
3543
3544 cifs_dbg(FYI, "Offset %lld len %lld\n", offset, len);
3545
3546 fsctl_buf.FileOffset = cpu_to_le64(offset);
3547 fsctl_buf.BeyondFinalZero = cpu_to_le64(offset + len);
3548
3549 rc = SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid,
3550 cfile->fid.volatile_fid, FSCTL_SET_ZERO_DATA, true,
3551 (char *)&fsctl_buf,
3552 sizeof(struct file_zero_data_information),
3553 0, NULL, NULL);
3554 if (rc)
3555 goto zero_range_exit;
3556
3557
3558
3559
3560 if (keep_size == false && i_size_read(inode) < offset + len) {
3561 eof = cpu_to_le64(offset + len);
3562 rc = SMB2_set_eof(xid, tcon, cfile->fid.persistent_fid,
3563 cfile->fid.volatile_fid, cfile->pid, &eof);
3564 }
3565
3566 zero_range_exit:
3567 free_xid(xid);
3568 if (rc)
3569 trace_smb3_zero_err(xid, cfile->fid.persistent_fid, tcon->tid,
3570 ses->Suid, offset, len, rc);
3571 else
3572 trace_smb3_zero_done(xid, cfile->fid.persistent_fid, tcon->tid,
3573 ses->Suid, offset, len);
3574 return rc;
3575}
3576
3577static long smb3_punch_hole(struct file *file, struct cifs_tcon *tcon,
3578 loff_t offset, loff_t len)
3579{
3580 struct inode *inode;
3581 struct cifsFileInfo *cfile = file->private_data;
3582 struct file_zero_data_information fsctl_buf;
3583 long rc;
3584 unsigned int xid;
3585 __u8 set_sparse = 1;
3586
3587 xid = get_xid();
3588
3589 inode = d_inode(cfile->dentry);
3590
3591
3592
3593 if (!smb2_set_sparse(xid, tcon, cfile, inode, set_sparse)) {
3594 rc = -EOPNOTSUPP;
3595 free_xid(xid);
3596 return rc;
3597 }
3598
3599 filemap_invalidate_lock(inode->i_mapping);
3600
3601
3602
3603
3604 truncate_pagecache_range(inode, offset, offset + len - 1);
3605
3606 cifs_dbg(FYI, "Offset %lld len %lld\n", offset, len);
3607
3608 fsctl_buf.FileOffset = cpu_to_le64(offset);
3609 fsctl_buf.BeyondFinalZero = cpu_to_le64(offset + len);
3610
3611 rc = SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid,
3612 cfile->fid.volatile_fid, FSCTL_SET_ZERO_DATA,
3613 true , (char *)&fsctl_buf,
3614 sizeof(struct file_zero_data_information),
3615 CIFSMaxBufSize, NULL, NULL);
3616 free_xid(xid);
3617 filemap_invalidate_unlock(inode->i_mapping);
3618 return rc;
3619}
3620
3621static int smb3_simple_fallocate_write_range(unsigned int xid,
3622 struct cifs_tcon *tcon,
3623 struct cifsFileInfo *cfile,
3624 loff_t off, loff_t len,
3625 char *buf)
3626{
3627 struct cifs_io_parms io_parms = {0};
3628 int nbytes;
3629 int rc = 0;
3630 struct kvec iov[2];
3631
3632 io_parms.netfid = cfile->fid.netfid;
3633 io_parms.pid = current->tgid;
3634 io_parms.tcon = tcon;
3635 io_parms.persistent_fid = cfile->fid.persistent_fid;
3636 io_parms.volatile_fid = cfile->fid.volatile_fid;
3637
3638 while (len) {
3639 io_parms.offset = off;
3640 io_parms.length = len;
3641 if (io_parms.length > SMB2_MAX_BUFFER_SIZE)
3642 io_parms.length = SMB2_MAX_BUFFER_SIZE;
3643
3644 iov[1].iov_base = buf;
3645 iov[1].iov_len = io_parms.length;
3646 rc = SMB2_write(xid, &io_parms, &nbytes, iov, 1);
3647 if (rc)
3648 break;
3649 if (nbytes > len)
3650 return -EINVAL;
3651 buf += nbytes;
3652 off += nbytes;
3653 len -= nbytes;
3654 }
3655 return rc;
3656}
3657
3658static int smb3_simple_fallocate_range(unsigned int xid,
3659 struct cifs_tcon *tcon,
3660 struct cifsFileInfo *cfile,
3661 loff_t off, loff_t len)
3662{
3663 struct file_allocated_range_buffer in_data, *out_data = NULL, *tmp_data;
3664 u32 out_data_len;
3665 char *buf = NULL;
3666 loff_t l;
3667 int rc;
3668
3669 in_data.file_offset = cpu_to_le64(off);
3670 in_data.length = cpu_to_le64(len);
3671 rc = SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid,
3672 cfile->fid.volatile_fid,
3673 FSCTL_QUERY_ALLOCATED_RANGES, true,
3674 (char *)&in_data, sizeof(in_data),
3675 1024 * sizeof(struct file_allocated_range_buffer),
3676 (char **)&out_data, &out_data_len);
3677 if (rc)
3678 goto out;
3679
3680 buf = kzalloc(1024 * 1024, GFP_KERNEL);
3681 if (buf == NULL) {
3682 rc = -ENOMEM;
3683 goto out;
3684 }
3685
3686 tmp_data = out_data;
3687 while (len) {
3688
3689
3690
3691 if (out_data_len == 0) {
3692 rc = smb3_simple_fallocate_write_range(xid, tcon,
3693 cfile, off, len, buf);
3694 goto out;
3695 }
3696
3697 if (out_data_len < sizeof(struct file_allocated_range_buffer)) {
3698 rc = -EINVAL;
3699 goto out;
3700 }
3701
3702 if (off < le64_to_cpu(tmp_data->file_offset)) {
3703
3704
3705
3706
3707
3708 l = le64_to_cpu(tmp_data->file_offset) - off;
3709 if (len < l)
3710 l = len;
3711 rc = smb3_simple_fallocate_write_range(xid, tcon,
3712 cfile, off, l, buf);
3713 if (rc)
3714 goto out;
3715 off = off + l;
3716 len = len - l;
3717 if (len == 0)
3718 goto out;
3719 }
3720
3721
3722
3723
3724
3725 l = le64_to_cpu(tmp_data->length);
3726 if (len < l)
3727 l = len;
3728 off += l;
3729 len -= l;
3730
3731 tmp_data = &tmp_data[1];
3732 out_data_len -= sizeof(struct file_allocated_range_buffer);
3733 }
3734
3735 out:
3736 kfree(out_data);
3737 kfree(buf);
3738 return rc;
3739}
3740
3741
3742static long smb3_simple_falloc(struct file *file, struct cifs_tcon *tcon,
3743 loff_t off, loff_t len, bool keep_size)
3744{
3745 struct inode *inode;
3746 struct cifsInodeInfo *cifsi;
3747 struct cifsFileInfo *cfile = file->private_data;
3748 long rc = -EOPNOTSUPP;
3749 unsigned int xid;
3750 __le64 eof;
3751
3752 xid = get_xid();
3753
3754 inode = d_inode(cfile->dentry);
3755 cifsi = CIFS_I(inode);
3756
3757 trace_smb3_falloc_enter(xid, cfile->fid.persistent_fid, tcon->tid,
3758 tcon->ses->Suid, off, len);
3759
3760 if (!CIFS_CACHE_READ(cifsi))
3761 if (keep_size == false) {
3762 trace_smb3_falloc_err(xid, cfile->fid.persistent_fid,
3763 tcon->tid, tcon->ses->Suid, off, len, rc);
3764 free_xid(xid);
3765 return rc;
3766 }
3767
3768
3769
3770
3771 if ((keep_size == false) && i_size_read(inode) < off + len) {
3772 rc = inode_newsize_ok(inode, off + len);
3773 if (rc)
3774 goto out;
3775
3776 if ((cifsi->cifsAttrs & FILE_ATTRIBUTE_SPARSE_FILE) == 0)
3777 smb2_set_sparse(xid, tcon, cfile, inode, false);
3778
3779 eof = cpu_to_le64(off + len);
3780 rc = SMB2_set_eof(xid, tcon, cfile->fid.persistent_fid,
3781 cfile->fid.volatile_fid, cfile->pid, &eof);
3782 if (rc == 0) {
3783 cifsi->server_eof = off + len;
3784 cifs_setsize(inode, off + len);
3785 cifs_truncate_page(inode->i_mapping, inode->i_size);
3786 truncate_setsize(inode, off + len);
3787 }
3788 goto out;
3789 }
3790
3791
3792
3793
3794
3795
3796 if ((cifsi->cifsAttrs & FILE_ATTRIBUTE_SPARSE_FILE) == 0) {
3797 rc = 0;
3798 goto out;
3799 }
3800
3801 if (keep_size == true) {
3802
3803
3804
3805
3806 if (off >= i_size_read(inode)) {
3807 rc = 0;
3808 goto out;
3809 }
3810
3811
3812
3813
3814 if (off + len > i_size_read(inode)) {
3815 len = i_size_read(inode) - off;
3816 }
3817 }
3818
3819 if ((keep_size == true) || (i_size_read(inode) >= off + len)) {
3820
3821
3822
3823
3824
3825
3826
3827
3828
3829
3830
3831
3832
3833
3834 if (len <= 1024 * 1024) {
3835 rc = smb3_simple_fallocate_range(xid, tcon, cfile,
3836 off, len);
3837 goto out;
3838 }
3839
3840
3841
3842
3843
3844
3845
3846
3847
3848 if ((off > 8192) || (off + len + 8192 < i_size_read(inode))) {
3849 rc = -EOPNOTSUPP;
3850 goto out;
3851 }
3852 }
3853
3854 smb2_set_sparse(xid, tcon, cfile, inode, false);
3855 rc = 0;
3856
3857out:
3858 if (rc)
3859 trace_smb3_falloc_err(xid, cfile->fid.persistent_fid, tcon->tid,
3860 tcon->ses->Suid, off, len, rc);
3861 else
3862 trace_smb3_falloc_done(xid, cfile->fid.persistent_fid, tcon->tid,
3863 tcon->ses->Suid, off, len);
3864
3865 free_xid(xid);
3866 return rc;
3867}
3868
3869static long smb3_collapse_range(struct file *file, struct cifs_tcon *tcon,
3870 loff_t off, loff_t len)
3871{
3872 int rc;
3873 unsigned int xid;
3874 struct cifsFileInfo *cfile = file->private_data;
3875 __le64 eof;
3876
3877 xid = get_xid();
3878
3879 if (off >= i_size_read(file->f_inode) ||
3880 off + len >= i_size_read(file->f_inode)) {
3881 rc = -EINVAL;
3882 goto out;
3883 }
3884
3885 rc = smb2_copychunk_range(xid, cfile, cfile, off + len,
3886 i_size_read(file->f_inode) - off - len, off);
3887 if (rc < 0)
3888 goto out;
3889
3890 eof = cpu_to_le64(i_size_read(file->f_inode) - len);
3891 rc = SMB2_set_eof(xid, tcon, cfile->fid.persistent_fid,
3892 cfile->fid.volatile_fid, cfile->pid, &eof);
3893 if (rc < 0)
3894 goto out;
3895
3896 rc = 0;
3897 out:
3898 free_xid(xid);
3899 return rc;
3900}
3901
3902static long smb3_insert_range(struct file *file, struct cifs_tcon *tcon,
3903 loff_t off, loff_t len)
3904{
3905 int rc;
3906 unsigned int xid;
3907 struct cifsFileInfo *cfile = file->private_data;
3908 __le64 eof;
3909 __u64 count;
3910
3911 xid = get_xid();
3912
3913 if (off >= i_size_read(file->f_inode)) {
3914 rc = -EINVAL;
3915 goto out;
3916 }
3917
3918 count = i_size_read(file->f_inode) - off;
3919 eof = cpu_to_le64(i_size_read(file->f_inode) + len);
3920
3921 rc = SMB2_set_eof(xid, tcon, cfile->fid.persistent_fid,
3922 cfile->fid.volatile_fid, cfile->pid, &eof);
3923 if (rc < 0)
3924 goto out;
3925
3926 rc = smb2_copychunk_range(xid, cfile, cfile, off, count, off + len);
3927 if (rc < 0)
3928 goto out;
3929
3930 rc = smb3_zero_range(file, tcon, off, len, 1);
3931 if (rc < 0)
3932 goto out;
3933
3934 rc = 0;
3935 out:
3936 free_xid(xid);
3937 return rc;
3938}
3939
3940static loff_t smb3_llseek(struct file *file, struct cifs_tcon *tcon, loff_t offset, int whence)
3941{
3942 struct cifsFileInfo *wrcfile, *cfile = file->private_data;
3943 struct cifsInodeInfo *cifsi;
3944 struct inode *inode;
3945 int rc = 0;
3946 struct file_allocated_range_buffer in_data, *out_data = NULL;
3947 u32 out_data_len;
3948 unsigned int xid;
3949
3950 if (whence != SEEK_HOLE && whence != SEEK_DATA)
3951 return generic_file_llseek(file, offset, whence);
3952
3953 inode = d_inode(cfile->dentry);
3954 cifsi = CIFS_I(inode);
3955
3956 if (offset < 0 || offset >= i_size_read(inode))
3957 return -ENXIO;
3958
3959 xid = get_xid();
3960
3961
3962
3963
3964
3965
3966
3967 wrcfile = find_writable_file(cifsi, FIND_WR_ANY);
3968 if (wrcfile) {
3969 filemap_write_and_wait(inode->i_mapping);
3970 smb2_flush_file(xid, tcon, &wrcfile->fid);
3971 cifsFileInfo_put(wrcfile);
3972 }
3973
3974 if (!(cifsi->cifsAttrs & FILE_ATTRIBUTE_SPARSE_FILE)) {
3975 if (whence == SEEK_HOLE)
3976 offset = i_size_read(inode);
3977 goto lseek_exit;
3978 }
3979
3980 in_data.file_offset = cpu_to_le64(offset);
3981 in_data.length = cpu_to_le64(i_size_read(inode));
3982
3983 rc = SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid,
3984 cfile->fid.volatile_fid,
3985 FSCTL_QUERY_ALLOCATED_RANGES, true,
3986 (char *)&in_data, sizeof(in_data),
3987 sizeof(struct file_allocated_range_buffer),
3988 (char **)&out_data, &out_data_len);
3989 if (rc == -E2BIG)
3990 rc = 0;
3991 if (rc)
3992 goto lseek_exit;
3993
3994 if (whence == SEEK_HOLE && out_data_len == 0)
3995 goto lseek_exit;
3996
3997 if (whence == SEEK_DATA && out_data_len == 0) {
3998 rc = -ENXIO;
3999 goto lseek_exit;
4000 }
4001
4002 if (out_data_len < sizeof(struct file_allocated_range_buffer)) {
4003 rc = -EINVAL;
4004 goto lseek_exit;
4005 }
4006 if (whence == SEEK_DATA) {
4007 offset = le64_to_cpu(out_data->file_offset);
4008 goto lseek_exit;
4009 }
4010 if (offset < le64_to_cpu(out_data->file_offset))
4011 goto lseek_exit;
4012
4013 offset = le64_to_cpu(out_data->file_offset) + le64_to_cpu(out_data->length);
4014
4015 lseek_exit:
4016 free_xid(xid);
4017 kfree(out_data);
4018 if (!rc)
4019 return vfs_setpos(file, offset, inode->i_sb->s_maxbytes);
4020 else
4021 return rc;
4022}
4023
4024static int smb3_fiemap(struct cifs_tcon *tcon,
4025 struct cifsFileInfo *cfile,
4026 struct fiemap_extent_info *fei, u64 start, u64 len)
4027{
4028 unsigned int xid;
4029 struct file_allocated_range_buffer in_data, *out_data;
4030 u32 out_data_len;
4031 int i, num, rc, flags, last_blob;
4032 u64 next;
4033
4034 rc = fiemap_prep(d_inode(cfile->dentry), fei, start, &len, 0);
4035 if (rc)
4036 return rc;
4037
4038 xid = get_xid();
4039 again:
4040 in_data.file_offset = cpu_to_le64(start);
4041 in_data.length = cpu_to_le64(len);
4042
4043 rc = SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid,
4044 cfile->fid.volatile_fid,
4045 FSCTL_QUERY_ALLOCATED_RANGES, true,
4046 (char *)&in_data, sizeof(in_data),
4047 1024 * sizeof(struct file_allocated_range_buffer),
4048 (char **)&out_data, &out_data_len);
4049 if (rc == -E2BIG) {
4050 last_blob = 0;
4051 rc = 0;
4052 } else
4053 last_blob = 1;
4054 if (rc)
4055 goto out;
4056
4057 if (out_data_len && out_data_len < sizeof(struct file_allocated_range_buffer)) {
4058 rc = -EINVAL;
4059 goto out;
4060 }
4061 if (out_data_len % sizeof(struct file_allocated_range_buffer)) {
4062 rc = -EINVAL;
4063 goto out;
4064 }
4065
4066 num = out_data_len / sizeof(struct file_allocated_range_buffer);
4067 for (i = 0; i < num; i++) {
4068 flags = 0;
4069 if (i == num - 1 && last_blob)
4070 flags |= FIEMAP_EXTENT_LAST;
4071
4072 rc = fiemap_fill_next_extent(fei,
4073 le64_to_cpu(out_data[i].file_offset),
4074 le64_to_cpu(out_data[i].file_offset),
4075 le64_to_cpu(out_data[i].length),
4076 flags);
4077 if (rc < 0)
4078 goto out;
4079 if (rc == 1) {
4080 rc = 0;
4081 goto out;
4082 }
4083 }
4084
4085 if (!last_blob) {
4086 next = le64_to_cpu(out_data[num - 1].file_offset) +
4087 le64_to_cpu(out_data[num - 1].length);
4088 len = len - (next - start);
4089 start = next;
4090 goto again;
4091 }
4092
4093 out:
4094 free_xid(xid);
4095 kfree(out_data);
4096 return rc;
4097}
4098
4099static long smb3_fallocate(struct file *file, struct cifs_tcon *tcon, int mode,
4100 loff_t off, loff_t len)
4101{
4102
4103 if (mode & FALLOC_FL_PUNCH_HOLE)
4104 return smb3_punch_hole(file, tcon, off, len);
4105 else if (mode & FALLOC_FL_ZERO_RANGE) {
4106 if (mode & FALLOC_FL_KEEP_SIZE)
4107 return smb3_zero_range(file, tcon, off, len, true);
4108 return smb3_zero_range(file, tcon, off, len, false);
4109 } else if (mode == FALLOC_FL_KEEP_SIZE)
4110 return smb3_simple_falloc(file, tcon, off, len, true);
4111 else if (mode == FALLOC_FL_COLLAPSE_RANGE)
4112 return smb3_collapse_range(file, tcon, off, len);
4113 else if (mode == FALLOC_FL_INSERT_RANGE)
4114 return smb3_insert_range(file, tcon, off, len);
4115 else if (mode == 0)
4116 return smb3_simple_falloc(file, tcon, off, len, false);
4117
4118 return -EOPNOTSUPP;
4119}
4120
4121static void
4122smb2_downgrade_oplock(struct TCP_Server_Info *server,
4123 struct cifsInodeInfo *cinode, __u32 oplock,
4124 unsigned int epoch, bool *purge_cache)
4125{
4126 server->ops->set_oplock_level(cinode, oplock, 0, NULL);
4127}
4128
4129static void
4130smb21_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock,
4131 unsigned int epoch, bool *purge_cache);
4132
4133static void
4134smb3_downgrade_oplock(struct TCP_Server_Info *server,
4135 struct cifsInodeInfo *cinode, __u32 oplock,
4136 unsigned int epoch, bool *purge_cache)
4137{
4138 unsigned int old_state = cinode->oplock;
4139 unsigned int old_epoch = cinode->epoch;
4140 unsigned int new_state;
4141
4142 if (epoch > old_epoch) {
4143 smb21_set_oplock_level(cinode, oplock, 0, NULL);
4144 cinode->epoch = epoch;
4145 }
4146
4147 new_state = cinode->oplock;
4148 *purge_cache = false;
4149
4150 if ((old_state & CIFS_CACHE_READ_FLG) != 0 &&
4151 (new_state & CIFS_CACHE_READ_FLG) == 0)
4152 *purge_cache = true;
4153 else if (old_state == new_state && (epoch - old_epoch > 1))
4154 *purge_cache = true;
4155}
4156
4157static void
4158smb2_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock,
4159 unsigned int epoch, bool *purge_cache)
4160{
4161 oplock &= 0xFF;
4162 cinode->lease_granted = false;
4163 if (oplock == SMB2_OPLOCK_LEVEL_NOCHANGE)
4164 return;
4165 if (oplock == SMB2_OPLOCK_LEVEL_BATCH) {
4166 cinode->oplock = CIFS_CACHE_RHW_FLG;
4167 cifs_dbg(FYI, "Batch Oplock granted on inode %p\n",
4168 &cinode->vfs_inode);
4169 } else if (oplock == SMB2_OPLOCK_LEVEL_EXCLUSIVE) {
4170 cinode->oplock = CIFS_CACHE_RW_FLG;
4171 cifs_dbg(FYI, "Exclusive Oplock granted on inode %p\n",
4172 &cinode->vfs_inode);
4173 } else if (oplock == SMB2_OPLOCK_LEVEL_II) {
4174 cinode->oplock = CIFS_CACHE_READ_FLG;
4175 cifs_dbg(FYI, "Level II Oplock granted on inode %p\n",
4176 &cinode->vfs_inode);
4177 } else
4178 cinode->oplock = 0;
4179}
4180
4181static void
4182smb21_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock,
4183 unsigned int epoch, bool *purge_cache)
4184{
4185 char message[5] = {0};
4186 unsigned int new_oplock = 0;
4187
4188 oplock &= 0xFF;
4189 cinode->lease_granted = true;
4190 if (oplock == SMB2_OPLOCK_LEVEL_NOCHANGE)
4191 return;
4192
4193
4194 if (oplock & SMB2_OPLOCK_LEVEL_EXCLUSIVE)
4195 return smb2_set_oplock_level(cinode, oplock, epoch,
4196 purge_cache);
4197
4198 if (oplock & SMB2_LEASE_READ_CACHING_HE) {
4199 new_oplock |= CIFS_CACHE_READ_FLG;
4200 strcat(message, "R");
4201 }
4202 if (oplock & SMB2_LEASE_HANDLE_CACHING_HE) {
4203 new_oplock |= CIFS_CACHE_HANDLE_FLG;
4204 strcat(message, "H");
4205 }
4206 if (oplock & SMB2_LEASE_WRITE_CACHING_HE) {
4207 new_oplock |= CIFS_CACHE_WRITE_FLG;
4208 strcat(message, "W");
4209 }
4210 if (!new_oplock)
4211 strncpy(message, "None", sizeof(message));
4212
4213 cinode->oplock = new_oplock;
4214 cifs_dbg(FYI, "%s Lease granted on inode %p\n", message,
4215 &cinode->vfs_inode);
4216}
4217
4218static void
4219smb3_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock,
4220 unsigned int epoch, bool *purge_cache)
4221{
4222 unsigned int old_oplock = cinode->oplock;
4223
4224 smb21_set_oplock_level(cinode, oplock, epoch, purge_cache);
4225
4226 if (purge_cache) {
4227 *purge_cache = false;
4228 if (old_oplock == CIFS_CACHE_READ_FLG) {
4229 if (cinode->oplock == CIFS_CACHE_READ_FLG &&
4230 (epoch - cinode->epoch > 0))
4231 *purge_cache = true;
4232 else if (cinode->oplock == CIFS_CACHE_RH_FLG &&
4233 (epoch - cinode->epoch > 1))
4234 *purge_cache = true;
4235 else if (cinode->oplock == CIFS_CACHE_RHW_FLG &&
4236 (epoch - cinode->epoch > 1))
4237 *purge_cache = true;
4238 else if (cinode->oplock == 0 &&
4239 (epoch - cinode->epoch > 0))
4240 *purge_cache = true;
4241 } else if (old_oplock == CIFS_CACHE_RH_FLG) {
4242 if (cinode->oplock == CIFS_CACHE_RH_FLG &&
4243 (epoch - cinode->epoch > 0))
4244 *purge_cache = true;
4245 else if (cinode->oplock == CIFS_CACHE_RHW_FLG &&
4246 (epoch - cinode->epoch > 1))
4247 *purge_cache = true;
4248 }
4249 cinode->epoch = epoch;
4250 }
4251}
4252
4253static bool
4254smb2_is_read_op(__u32 oplock)
4255{
4256 return oplock == SMB2_OPLOCK_LEVEL_II;
4257}
4258
4259static bool
4260smb21_is_read_op(__u32 oplock)
4261{
4262 return (oplock & SMB2_LEASE_READ_CACHING_HE) &&
4263 !(oplock & SMB2_LEASE_WRITE_CACHING_HE);
4264}
4265
4266static __le32
4267map_oplock_to_lease(u8 oplock)
4268{
4269 if (oplock == SMB2_OPLOCK_LEVEL_EXCLUSIVE)
4270 return SMB2_LEASE_WRITE_CACHING | SMB2_LEASE_READ_CACHING;
4271 else if (oplock == SMB2_OPLOCK_LEVEL_II)
4272 return SMB2_LEASE_READ_CACHING;
4273 else if (oplock == SMB2_OPLOCK_LEVEL_BATCH)
4274 return SMB2_LEASE_HANDLE_CACHING | SMB2_LEASE_READ_CACHING |
4275 SMB2_LEASE_WRITE_CACHING;
4276 return 0;
4277}
4278
4279static char *
4280smb2_create_lease_buf(u8 *lease_key, u8 oplock)
4281{
4282 struct create_lease *buf;
4283
4284 buf = kzalloc(sizeof(struct create_lease), GFP_KERNEL);
4285 if (!buf)
4286 return NULL;
4287
4288 memcpy(&buf->lcontext.LeaseKey, lease_key, SMB2_LEASE_KEY_SIZE);
4289 buf->lcontext.LeaseState = map_oplock_to_lease(oplock);
4290
4291 buf->ccontext.DataOffset = cpu_to_le16(offsetof
4292 (struct create_lease, lcontext));
4293 buf->ccontext.DataLength = cpu_to_le32(sizeof(struct lease_context));
4294 buf->ccontext.NameOffset = cpu_to_le16(offsetof
4295 (struct create_lease, Name));
4296 buf->ccontext.NameLength = cpu_to_le16(4);
4297
4298 buf->Name[0] = 'R';
4299 buf->Name[1] = 'q';
4300 buf->Name[2] = 'L';
4301 buf->Name[3] = 's';
4302 return (char *)buf;
4303}
4304
4305static char *
4306smb3_create_lease_buf(u8 *lease_key, u8 oplock)
4307{
4308 struct create_lease_v2 *buf;
4309
4310 buf = kzalloc(sizeof(struct create_lease_v2), GFP_KERNEL);
4311 if (!buf)
4312 return NULL;
4313
4314 memcpy(&buf->lcontext.LeaseKey, lease_key, SMB2_LEASE_KEY_SIZE);
4315 buf->lcontext.LeaseState = map_oplock_to_lease(oplock);
4316
4317 buf->ccontext.DataOffset = cpu_to_le16(offsetof
4318 (struct create_lease_v2, lcontext));
4319 buf->ccontext.DataLength = cpu_to_le32(sizeof(struct lease_context_v2));
4320 buf->ccontext.NameOffset = cpu_to_le16(offsetof
4321 (struct create_lease_v2, Name));
4322 buf->ccontext.NameLength = cpu_to_le16(4);
4323
4324 buf->Name[0] = 'R';
4325 buf->Name[1] = 'q';
4326 buf->Name[2] = 'L';
4327 buf->Name[3] = 's';
4328 return (char *)buf;
4329}
4330
4331static __u8
4332smb2_parse_lease_buf(void *buf, unsigned int *epoch, char *lease_key)
4333{
4334 struct create_lease *lc = (struct create_lease *)buf;
4335
4336 *epoch = 0;
4337 if (lc->lcontext.LeaseFlags & SMB2_LEASE_FLAG_BREAK_IN_PROGRESS)
4338 return SMB2_OPLOCK_LEVEL_NOCHANGE;
4339 return le32_to_cpu(lc->lcontext.LeaseState);
4340}
4341
4342static __u8
4343smb3_parse_lease_buf(void *buf, unsigned int *epoch, char *lease_key)
4344{
4345 struct create_lease_v2 *lc = (struct create_lease_v2 *)buf;
4346
4347 *epoch = le16_to_cpu(lc->lcontext.Epoch);
4348 if (lc->lcontext.LeaseFlags & SMB2_LEASE_FLAG_BREAK_IN_PROGRESS)
4349 return SMB2_OPLOCK_LEVEL_NOCHANGE;
4350 if (lease_key)
4351 memcpy(lease_key, &lc->lcontext.LeaseKey, SMB2_LEASE_KEY_SIZE);
4352 return le32_to_cpu(lc->lcontext.LeaseState);
4353}
4354
4355static unsigned int
4356smb2_wp_retry_size(struct inode *inode)
4357{
4358 return min_t(unsigned int, CIFS_SB(inode->i_sb)->ctx->wsize,
4359 SMB2_MAX_BUFFER_SIZE);
4360}
4361
4362static bool
4363smb2_dir_needs_close(struct cifsFileInfo *cfile)
4364{
4365 return !cfile->invalidHandle;
4366}
4367
4368static void
4369fill_transform_hdr(struct smb2_transform_hdr *tr_hdr, unsigned int orig_len,
4370 struct smb_rqst *old_rq, __le16 cipher_type)
4371{
4372 struct smb2_sync_hdr *shdr =
4373 (struct smb2_sync_hdr *)old_rq->rq_iov[0].iov_base;
4374
4375 memset(tr_hdr, 0, sizeof(struct smb2_transform_hdr));
4376 tr_hdr->ProtocolId = SMB2_TRANSFORM_PROTO_NUM;
4377 tr_hdr->OriginalMessageSize = cpu_to_le32(orig_len);
4378 tr_hdr->Flags = cpu_to_le16(0x01);
4379 if ((cipher_type == SMB2_ENCRYPTION_AES128_GCM) ||
4380 (cipher_type == SMB2_ENCRYPTION_AES256_GCM))
4381 get_random_bytes(&tr_hdr->Nonce, SMB3_AES_GCM_NONCE);
4382 else
4383 get_random_bytes(&tr_hdr->Nonce, SMB3_AES_CCM_NONCE);
4384 memcpy(&tr_hdr->SessionId, &shdr->SessionId, 8);
4385}
4386
4387
4388
4389
4390static inline void smb2_sg_set_buf(struct scatterlist *sg, const void *buf,
4391 unsigned int buflen)
4392{
4393 void *addr;
4394
4395
4396
4397 if (is_vmalloc_addr(buf))
4398 addr = vmalloc_to_page(buf);
4399 else
4400 addr = virt_to_page(buf);
4401 sg_set_page(sg, addr, buflen, offset_in_page(buf));
4402}
4403
4404
4405
4406
4407
4408
4409
4410static struct scatterlist *
4411init_sg(int num_rqst, struct smb_rqst *rqst, u8 *sign)
4412{
4413 unsigned int sg_len;
4414 struct scatterlist *sg;
4415 unsigned int i;
4416 unsigned int j;
4417 unsigned int idx = 0;
4418 int skip;
4419
4420 sg_len = 1;
4421 for (i = 0; i < num_rqst; i++)
4422 sg_len += rqst[i].rq_nvec + rqst[i].rq_npages;
4423
4424 sg = kmalloc_array(sg_len, sizeof(struct scatterlist), GFP_KERNEL);
4425 if (!sg)
4426 return NULL;
4427
4428 sg_init_table(sg, sg_len);
4429 for (i = 0; i < num_rqst; i++) {
4430 for (j = 0; j < rqst[i].rq_nvec; j++) {
4431
4432
4433
4434
4435 skip = (i == 0) && (j == 0) ? 20 : 0;
4436 smb2_sg_set_buf(&sg[idx++],
4437 rqst[i].rq_iov[j].iov_base + skip,
4438 rqst[i].rq_iov[j].iov_len - skip);
4439 }
4440
4441 for (j = 0; j < rqst[i].rq_npages; j++) {
4442 unsigned int len, offset;
4443
4444 rqst_page_get_length(&rqst[i], j, &len, &offset);
4445 sg_set_page(&sg[idx++], rqst[i].rq_pages[j], len, offset);
4446 }
4447 }
4448 smb2_sg_set_buf(&sg[idx], sign, SMB2_SIGNATURE_SIZE);
4449 return sg;
4450}
4451
4452static int
4453smb2_get_enc_key(struct TCP_Server_Info *server, __u64 ses_id, int enc, u8 *key)
4454{
4455 struct cifs_ses *ses;
4456 u8 *ses_enc_key;
4457
4458 spin_lock(&cifs_tcp_ses_lock);
4459 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
4460 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
4461 if (ses->Suid == ses_id) {
4462 ses_enc_key = enc ? ses->smb3encryptionkey :
4463 ses->smb3decryptionkey;
4464 memcpy(key, ses_enc_key, SMB3_ENC_DEC_KEY_SIZE);
4465 spin_unlock(&cifs_tcp_ses_lock);
4466 return 0;
4467 }
4468 }
4469 }
4470 spin_unlock(&cifs_tcp_ses_lock);
4471
4472 return -EAGAIN;
4473}
4474
4475
4476
4477
4478
4479
4480
4481static int
4482crypt_message(struct TCP_Server_Info *server, int num_rqst,
4483 struct smb_rqst *rqst, int enc)
4484{
4485 struct smb2_transform_hdr *tr_hdr =
4486 (struct smb2_transform_hdr *)rqst[0].rq_iov[0].iov_base;
4487 unsigned int assoc_data_len = sizeof(struct smb2_transform_hdr) - 20;
4488 int rc = 0;
4489 struct scatterlist *sg;
4490 u8 sign[SMB2_SIGNATURE_SIZE] = {};
4491 u8 key[SMB3_ENC_DEC_KEY_SIZE];
4492 struct aead_request *req;
4493 char *iv;
4494 unsigned int iv_len;
4495 DECLARE_CRYPTO_WAIT(wait);
4496 struct crypto_aead *tfm;
4497 unsigned int crypt_len = le32_to_cpu(tr_hdr->OriginalMessageSize);
4498
4499 rc = smb2_get_enc_key(server, tr_hdr->SessionId, enc, key);
4500 if (rc) {
4501 cifs_server_dbg(VFS, "%s: Could not get %scryption key\n", __func__,
4502 enc ? "en" : "de");
4503 return rc;
4504 }
4505
4506 rc = smb3_crypto_aead_allocate(server);
4507 if (rc) {
4508 cifs_server_dbg(VFS, "%s: crypto alloc failed\n", __func__);
4509 return rc;
4510 }
4511
4512 tfm = enc ? server->secmech.ccmaesencrypt :
4513 server->secmech.ccmaesdecrypt;
4514
4515 if ((server->cipher_type == SMB2_ENCRYPTION_AES256_CCM) ||
4516 (server->cipher_type == SMB2_ENCRYPTION_AES256_GCM))
4517 rc = crypto_aead_setkey(tfm, key, SMB3_GCM256_CRYPTKEY_SIZE);
4518 else
4519 rc = crypto_aead_setkey(tfm, key, SMB3_GCM128_CRYPTKEY_SIZE);
4520
4521 if (rc) {
4522 cifs_server_dbg(VFS, "%s: Failed to set aead key %d\n", __func__, rc);
4523 return rc;
4524 }
4525
4526 rc = crypto_aead_setauthsize(tfm, SMB2_SIGNATURE_SIZE);
4527 if (rc) {
4528 cifs_server_dbg(VFS, "%s: Failed to set authsize %d\n", __func__, rc);
4529 return rc;
4530 }
4531
4532 req = aead_request_alloc(tfm, GFP_KERNEL);
4533 if (!req) {
4534 cifs_server_dbg(VFS, "%s: Failed to alloc aead request\n", __func__);
4535 return -ENOMEM;
4536 }
4537
4538 if (!enc) {
4539 memcpy(sign, &tr_hdr->Signature, SMB2_SIGNATURE_SIZE);
4540 crypt_len += SMB2_SIGNATURE_SIZE;
4541 }
4542
4543 sg = init_sg(num_rqst, rqst, sign);
4544 if (!sg) {
4545 cifs_server_dbg(VFS, "%s: Failed to init sg\n", __func__);
4546 rc = -ENOMEM;
4547 goto free_req;
4548 }
4549
4550 iv_len = crypto_aead_ivsize(tfm);
4551 iv = kzalloc(iv_len, GFP_KERNEL);
4552 if (!iv) {
4553 cifs_server_dbg(VFS, "%s: Failed to alloc iv\n", __func__);
4554 rc = -ENOMEM;
4555 goto free_sg;
4556 }
4557
4558 if ((server->cipher_type == SMB2_ENCRYPTION_AES128_GCM) ||
4559 (server->cipher_type == SMB2_ENCRYPTION_AES256_GCM))
4560 memcpy(iv, (char *)tr_hdr->Nonce, SMB3_AES_GCM_NONCE);
4561 else {
4562 iv[0] = 3;
4563 memcpy(iv + 1, (char *)tr_hdr->Nonce, SMB3_AES_CCM_NONCE);
4564 }
4565
4566 aead_request_set_crypt(req, sg, sg, crypt_len, iv);
4567 aead_request_set_ad(req, assoc_data_len);
4568
4569 aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
4570 crypto_req_done, &wait);
4571
4572 rc = crypto_wait_req(enc ? crypto_aead_encrypt(req)
4573 : crypto_aead_decrypt(req), &wait);
4574
4575 if (!rc && enc)
4576 memcpy(&tr_hdr->Signature, sign, SMB2_SIGNATURE_SIZE);
4577
4578 kfree(iv);
4579free_sg:
4580 kfree(sg);
4581free_req:
4582 kfree(req);
4583 return rc;
4584}
4585
4586void
4587smb3_free_compound_rqst(int num_rqst, struct smb_rqst *rqst)
4588{
4589 int i, j;
4590
4591 for (i = 0; i < num_rqst; i++) {
4592 if (rqst[i].rq_pages) {
4593 for (j = rqst[i].rq_npages - 1; j >= 0; j--)
4594 put_page(rqst[i].rq_pages[j]);
4595 kfree(rqst[i].rq_pages);
4596 }
4597 }
4598}
4599
4600
4601
4602
4603
4604
4605
4606
4607
4608
4609
4610
4611
4612
4613static int
4614smb3_init_transform_rq(struct TCP_Server_Info *server, int num_rqst,
4615 struct smb_rqst *new_rq, struct smb_rqst *old_rq)
4616{
4617 struct page **pages;
4618 struct smb2_transform_hdr *tr_hdr = new_rq[0].rq_iov[0].iov_base;
4619 unsigned int npages;
4620 unsigned int orig_len = 0;
4621 int i, j;
4622 int rc = -ENOMEM;
4623
4624 for (i = 1; i < num_rqst; i++) {
4625 npages = old_rq[i - 1].rq_npages;
4626 pages = kmalloc_array(npages, sizeof(struct page *),
4627 GFP_KERNEL);
4628 if (!pages)
4629 goto err_free;
4630
4631 new_rq[i].rq_pages = pages;
4632 new_rq[i].rq_npages = npages;
4633 new_rq[i].rq_offset = old_rq[i - 1].rq_offset;
4634 new_rq[i].rq_pagesz = old_rq[i - 1].rq_pagesz;
4635 new_rq[i].rq_tailsz = old_rq[i - 1].rq_tailsz;
4636 new_rq[i].rq_iov = old_rq[i - 1].rq_iov;
4637 new_rq[i].rq_nvec = old_rq[i - 1].rq_nvec;
4638
4639 orig_len += smb_rqst_len(server, &old_rq[i - 1]);
4640
4641 for (j = 0; j < npages; j++) {
4642 pages[j] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
4643 if (!pages[j])
4644 goto err_free;
4645 }
4646
4647
4648 for (j = 0; j < npages; j++) {
4649 char *dst, *src;
4650 unsigned int offset, len;
4651
4652 rqst_page_get_length(&new_rq[i], j, &len, &offset);
4653
4654 dst = (char *) kmap(new_rq[i].rq_pages[j]) + offset;
4655 src = (char *) kmap(old_rq[i - 1].rq_pages[j]) + offset;
4656
4657 memcpy(dst, src, len);
4658 kunmap(new_rq[i].rq_pages[j]);
4659 kunmap(old_rq[i - 1].rq_pages[j]);
4660 }
4661 }
4662
4663
4664 fill_transform_hdr(tr_hdr, orig_len, old_rq, server->cipher_type);
4665
4666 rc = crypt_message(server, num_rqst, new_rq, 1);
4667 cifs_dbg(FYI, "Encrypt message returned %d\n", rc);
4668 if (rc)
4669 goto err_free;
4670
4671 return rc;
4672
4673err_free:
4674 smb3_free_compound_rqst(num_rqst - 1, &new_rq[1]);
4675 return rc;
4676}
4677
4678static int
4679smb3_is_transform_hdr(void *buf)
4680{
4681 struct smb2_transform_hdr *trhdr = buf;
4682
4683 return trhdr->ProtocolId == SMB2_TRANSFORM_PROTO_NUM;
4684}
4685
4686static int
4687decrypt_raw_data(struct TCP_Server_Info *server, char *buf,
4688 unsigned int buf_data_size, struct page **pages,
4689 unsigned int npages, unsigned int page_data_size,
4690 bool is_offloaded)
4691{
4692 struct kvec iov[2];
4693 struct smb_rqst rqst = {NULL};
4694 int rc;
4695
4696 iov[0].iov_base = buf;
4697 iov[0].iov_len = sizeof(struct smb2_transform_hdr);
4698 iov[1].iov_base = buf + sizeof(struct smb2_transform_hdr);
4699 iov[1].iov_len = buf_data_size;
4700
4701 rqst.rq_iov = iov;
4702 rqst.rq_nvec = 2;
4703 rqst.rq_pages = pages;
4704 rqst.rq_npages = npages;
4705 rqst.rq_pagesz = PAGE_SIZE;
4706 rqst.rq_tailsz = (page_data_size % PAGE_SIZE) ? : PAGE_SIZE;
4707
4708 rc = crypt_message(server, 1, &rqst, 0);
4709 cifs_dbg(FYI, "Decrypt message returned %d\n", rc);
4710
4711 if (rc)
4712 return rc;
4713
4714 memmove(buf, iov[1].iov_base, buf_data_size);
4715
4716 if (!is_offloaded)
4717 server->total_read = buf_data_size + page_data_size;
4718
4719 return rc;
4720}
4721
4722static int
4723read_data_into_pages(struct TCP_Server_Info *server, struct page **pages,
4724 unsigned int npages, unsigned int len)
4725{
4726 int i;
4727 int length;
4728
4729 for (i = 0; i < npages; i++) {
4730 struct page *page = pages[i];
4731 size_t n;
4732
4733 n = len;
4734 if (len >= PAGE_SIZE) {
4735
4736 n = PAGE_SIZE;
4737 len -= n;
4738 } else {
4739 zero_user(page, len, PAGE_SIZE - len);
4740 len = 0;
4741 }
4742 length = cifs_read_page_from_socket(server, page, 0, n);
4743 if (length < 0)
4744 return length;
4745 server->total_read += length;
4746 }
4747
4748 return 0;
4749}
4750
4751static int
4752init_read_bvec(struct page **pages, unsigned int npages, unsigned int data_size,
4753 unsigned int cur_off, struct bio_vec **page_vec)
4754{
4755 struct bio_vec *bvec;
4756 int i;
4757
4758 bvec = kcalloc(npages, sizeof(struct bio_vec), GFP_KERNEL);
4759 if (!bvec)
4760 return -ENOMEM;
4761
4762 for (i = 0; i < npages; i++) {
4763 bvec[i].bv_page = pages[i];
4764 bvec[i].bv_offset = (i == 0) ? cur_off : 0;
4765 bvec[i].bv_len = min_t(unsigned int, PAGE_SIZE, data_size);
4766 data_size -= bvec[i].bv_len;
4767 }
4768
4769 if (data_size != 0) {
4770 cifs_dbg(VFS, "%s: something went wrong\n", __func__);
4771 kfree(bvec);
4772 return -EIO;
4773 }
4774
4775 *page_vec = bvec;
4776 return 0;
4777}
4778
4779static int
4780handle_read_data(struct TCP_Server_Info *server, struct mid_q_entry *mid,
4781 char *buf, unsigned int buf_len, struct page **pages,
4782 unsigned int npages, unsigned int page_data_size,
4783 bool is_offloaded)
4784{
4785 unsigned int data_offset;
4786 unsigned int data_len;
4787 unsigned int cur_off;
4788 unsigned int cur_page_idx;
4789 unsigned int pad_len;
4790 struct cifs_readdata *rdata = mid->callback_data;
4791 struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)buf;
4792 struct bio_vec *bvec = NULL;
4793 struct iov_iter iter;
4794 struct kvec iov;
4795 int length;
4796 bool use_rdma_mr = false;
4797
4798 if (shdr->Command != SMB2_READ) {
4799 cifs_server_dbg(VFS, "only big read responses are supported\n");
4800 return -ENOTSUPP;
4801 }
4802
4803 if (server->ops->is_session_expired &&
4804 server->ops->is_session_expired(buf)) {
4805 if (!is_offloaded)
4806 cifs_reconnect(server);
4807 return -1;
4808 }
4809
4810 if (server->ops->is_status_pending &&
4811 server->ops->is_status_pending(buf, server))
4812 return -1;
4813
4814
4815 rdata->iov[0].iov_base = buf;
4816 rdata->iov[0].iov_len = 0;
4817 rdata->iov[1].iov_base = buf;
4818 rdata->iov[1].iov_len =
4819 min_t(unsigned int, buf_len, server->vals->read_rsp_size);
4820 cifs_dbg(FYI, "0: iov_base=%p iov_len=%zu\n",
4821 rdata->iov[0].iov_base, rdata->iov[0].iov_len);
4822 cifs_dbg(FYI, "1: iov_base=%p iov_len=%zu\n",
4823 rdata->iov[1].iov_base, rdata->iov[1].iov_len);
4824
4825 rdata->result = server->ops->map_error(buf, true);
4826 if (rdata->result != 0) {
4827 cifs_dbg(FYI, "%s: server returned error %d\n",
4828 __func__, rdata->result);
4829
4830 if (is_offloaded)
4831 mid->mid_state = MID_RESPONSE_RECEIVED;
4832 else
4833 dequeue_mid(mid, false);
4834 return 0;
4835 }
4836
4837 data_offset = server->ops->read_data_offset(buf);
4838#ifdef CONFIG_CIFS_SMB_DIRECT
4839 use_rdma_mr = rdata->mr;
4840#endif
4841 data_len = server->ops->read_data_length(buf, use_rdma_mr);
4842
4843 if (data_offset < server->vals->read_rsp_size) {
4844
4845
4846
4847
4848
4849 cifs_dbg(FYI, "%s: data offset (%u) inside read response header\n",
4850 __func__, data_offset);
4851 data_offset = server->vals->read_rsp_size;
4852 } else if (data_offset > MAX_CIFS_SMALL_BUFFER_SIZE) {
4853
4854 cifs_dbg(FYI, "%s: data offset (%u) beyond end of smallbuf\n",
4855 __func__, data_offset);
4856 rdata->result = -EIO;
4857 if (is_offloaded)
4858 mid->mid_state = MID_RESPONSE_MALFORMED;
4859 else
4860 dequeue_mid(mid, rdata->result);
4861 return 0;
4862 }
4863
4864 pad_len = data_offset - server->vals->read_rsp_size;
4865
4866 if (buf_len <= data_offset) {
4867
4868 cur_page_idx = pad_len / PAGE_SIZE;
4869 cur_off = pad_len % PAGE_SIZE;
4870
4871 if (cur_page_idx != 0) {
4872
4873 cifs_dbg(FYI, "%s: data offset (%u) beyond 1st page of response\n",
4874 __func__, data_offset);
4875 rdata->result = -EIO;
4876 if (is_offloaded)
4877 mid->mid_state = MID_RESPONSE_MALFORMED;
4878 else
4879 dequeue_mid(mid, rdata->result);
4880 return 0;
4881 }
4882
4883 if (data_len > page_data_size - pad_len) {
4884
4885 rdata->result = -EIO;
4886 if (is_offloaded)
4887 mid->mid_state = MID_RESPONSE_MALFORMED;
4888 else
4889 dequeue_mid(mid, rdata->result);
4890 return 0;
4891 }
4892
4893 rdata->result = init_read_bvec(pages, npages, page_data_size,
4894 cur_off, &bvec);
4895 if (rdata->result != 0) {
4896 if (is_offloaded)
4897 mid->mid_state = MID_RESPONSE_MALFORMED;
4898 else
4899 dequeue_mid(mid, rdata->result);
4900 return 0;
4901 }
4902
4903 iov_iter_bvec(&iter, WRITE, bvec, npages, data_len);
4904 } else if (buf_len >= data_offset + data_len) {
4905
4906 WARN_ONCE(npages > 0, "read data can be either in buf or in pages");
4907 iov.iov_base = buf + data_offset;
4908 iov.iov_len = data_len;
4909 iov_iter_kvec(&iter, WRITE, &iov, 1, data_len);
4910 } else {
4911
4912 WARN_ONCE(1, "buf can not contain only a part of read data");
4913 rdata->result = -EIO;
4914 if (is_offloaded)
4915 mid->mid_state = MID_RESPONSE_MALFORMED;
4916 else
4917 dequeue_mid(mid, rdata->result);
4918 return 0;
4919 }
4920
4921 length = rdata->copy_into_pages(server, rdata, &iter);
4922
4923 kfree(bvec);
4924
4925 if (length < 0)
4926 return length;
4927
4928 if (is_offloaded)
4929 mid->mid_state = MID_RESPONSE_RECEIVED;
4930 else
4931 dequeue_mid(mid, false);
4932 return length;
4933}
4934
4935struct smb2_decrypt_work {
4936 struct work_struct decrypt;
4937 struct TCP_Server_Info *server;
4938 struct page **ppages;
4939 char *buf;
4940 unsigned int npages;
4941 unsigned int len;
4942};
4943
4944
4945static void smb2_decrypt_offload(struct work_struct *work)
4946{
4947 struct smb2_decrypt_work *dw = container_of(work,
4948 struct smb2_decrypt_work, decrypt);
4949 int i, rc;
4950 struct mid_q_entry *mid;
4951
4952 rc = decrypt_raw_data(dw->server, dw->buf, dw->server->vals->read_rsp_size,
4953 dw->ppages, dw->npages, dw->len, true);
4954 if (rc) {
4955 cifs_dbg(VFS, "error decrypting rc=%d\n", rc);
4956 goto free_pages;
4957 }
4958
4959 dw->server->lstrp = jiffies;
4960 mid = smb2_find_dequeue_mid(dw->server, dw->buf);
4961 if (mid == NULL)
4962 cifs_dbg(FYI, "mid not found\n");
4963 else {
4964 mid->decrypted = true;
4965 rc = handle_read_data(dw->server, mid, dw->buf,
4966 dw->server->vals->read_rsp_size,
4967 dw->ppages, dw->npages, dw->len,
4968 true);
4969 if (rc >= 0) {
4970#ifdef CONFIG_CIFS_STATS2
4971 mid->when_received = jiffies;
4972#endif
4973 if (dw->server->ops->is_network_name_deleted)
4974 dw->server->ops->is_network_name_deleted(dw->buf,
4975 dw->server);
4976
4977 mid->callback(mid);
4978 } else {
4979 spin_lock(&GlobalMid_Lock);
4980 if (dw->server->tcpStatus == CifsNeedReconnect) {
4981 mid->mid_state = MID_RETRY_NEEDED;
4982 spin_unlock(&GlobalMid_Lock);
4983 mid->callback(mid);
4984 } else {
4985 mid->mid_state = MID_REQUEST_SUBMITTED;
4986 mid->mid_flags &= ~(MID_DELETED);
4987 list_add_tail(&mid->qhead,
4988 &dw->server->pending_mid_q);
4989 spin_unlock(&GlobalMid_Lock);
4990 }
4991 }
4992 cifs_mid_q_entry_release(mid);
4993 }
4994
4995free_pages:
4996 for (i = dw->npages-1; i >= 0; i--)
4997 put_page(dw->ppages[i]);
4998
4999 kfree(dw->ppages);
5000 cifs_small_buf_release(dw->buf);
5001 kfree(dw);
5002}
5003
5004
5005static int
5006receive_encrypted_read(struct TCP_Server_Info *server, struct mid_q_entry **mid,
5007 int *num_mids)
5008{
5009 char *buf = server->smallbuf;
5010 struct smb2_transform_hdr *tr_hdr = (struct smb2_transform_hdr *)buf;
5011 unsigned int npages;
5012 struct page **pages;
5013 unsigned int len;
5014 unsigned int buflen = server->pdu_size;
5015 int rc;
5016 int i = 0;
5017 struct smb2_decrypt_work *dw;
5018
5019 *num_mids = 1;
5020 len = min_t(unsigned int, buflen, server->vals->read_rsp_size +
5021 sizeof(struct smb2_transform_hdr)) - HEADER_SIZE(server) + 1;
5022
5023 rc = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1, len);
5024 if (rc < 0)
5025 return rc;
5026 server->total_read += rc;
5027
5028 len = le32_to_cpu(tr_hdr->OriginalMessageSize) -
5029 server->vals->read_rsp_size;
5030 npages = DIV_ROUND_UP(len, PAGE_SIZE);
5031
5032 pages = kmalloc_array(npages, sizeof(struct page *), GFP_KERNEL);
5033 if (!pages) {
5034 rc = -ENOMEM;
5035 goto discard_data;
5036 }
5037
5038 for (; i < npages; i++) {
5039 pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
5040 if (!pages[i]) {
5041 rc = -ENOMEM;
5042 goto discard_data;
5043 }
5044 }
5045
5046
5047 rc = read_data_into_pages(server, pages, npages, len);
5048 if (rc)
5049 goto free_pages;
5050
5051 rc = cifs_discard_remaining_data(server);
5052 if (rc)
5053 goto free_pages;
5054
5055
5056
5057
5058
5059
5060 if ((server->min_offload) && (server->in_flight > 1) &&
5061 (server->pdu_size >= server->min_offload)) {
5062 dw = kmalloc(sizeof(struct smb2_decrypt_work), GFP_KERNEL);
5063 if (dw == NULL)
5064 goto non_offloaded_decrypt;
5065
5066 dw->buf = server->smallbuf;
5067 server->smallbuf = (char *)cifs_small_buf_get();
5068
5069 INIT_WORK(&dw->decrypt, smb2_decrypt_offload);
5070
5071 dw->npages = npages;
5072 dw->server = server;
5073 dw->ppages = pages;
5074 dw->len = len;
5075 queue_work(decrypt_wq, &dw->decrypt);
5076 *num_mids = 0;
5077 return -1;
5078 }
5079
5080non_offloaded_decrypt:
5081 rc = decrypt_raw_data(server, buf, server->vals->read_rsp_size,
5082 pages, npages, len, false);
5083 if (rc)
5084 goto free_pages;
5085
5086 *mid = smb2_find_mid(server, buf);
5087 if (*mid == NULL)
5088 cifs_dbg(FYI, "mid not found\n");
5089 else {
5090 cifs_dbg(FYI, "mid found\n");
5091 (*mid)->decrypted = true;
5092 rc = handle_read_data(server, *mid, buf,
5093 server->vals->read_rsp_size,
5094 pages, npages, len, false);
5095 if (rc >= 0) {
5096 if (server->ops->is_network_name_deleted) {
5097 server->ops->is_network_name_deleted(buf,
5098 server);
5099 }
5100 }
5101 }
5102
5103free_pages:
5104 for (i = i - 1; i >= 0; i--)
5105 put_page(pages[i]);
5106 kfree(pages);
5107 return rc;
5108discard_data:
5109 cifs_discard_remaining_data(server);
5110 goto free_pages;
5111}
5112
5113static int
5114receive_encrypted_standard(struct TCP_Server_Info *server,
5115 struct mid_q_entry **mids, char **bufs,
5116 int *num_mids)
5117{
5118 int ret, length;
5119 char *buf = server->smallbuf;
5120 struct smb2_sync_hdr *shdr;
5121 unsigned int pdu_length = server->pdu_size;
5122 unsigned int buf_size;
5123 struct mid_q_entry *mid_entry;
5124 int next_is_large;
5125 char *next_buffer = NULL;
5126
5127 *num_mids = 0;
5128
5129
5130 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE) {
5131 server->large_buf = true;
5132 memcpy(server->bigbuf, buf, server->total_read);
5133 buf = server->bigbuf;
5134 }
5135
5136
5137 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
5138 pdu_length - HEADER_SIZE(server) + 1);
5139 if (length < 0)
5140 return length;
5141 server->total_read += length;
5142
5143 buf_size = pdu_length - sizeof(struct smb2_transform_hdr);
5144 length = decrypt_raw_data(server, buf, buf_size, NULL, 0, 0, false);
5145 if (length)
5146 return length;
5147
5148 next_is_large = server->large_buf;
5149one_more:
5150 shdr = (struct smb2_sync_hdr *)buf;
5151 if (shdr->NextCommand) {
5152 if (next_is_large)
5153 next_buffer = (char *)cifs_buf_get();
5154 else
5155 next_buffer = (char *)cifs_small_buf_get();
5156 memcpy(next_buffer,
5157 buf + le32_to_cpu(shdr->NextCommand),
5158 pdu_length - le32_to_cpu(shdr->NextCommand));
5159 }
5160
5161 mid_entry = smb2_find_mid(server, buf);
5162 if (mid_entry == NULL)
5163 cifs_dbg(FYI, "mid not found\n");
5164 else {
5165 cifs_dbg(FYI, "mid found\n");
5166 mid_entry->decrypted = true;
5167 mid_entry->resp_buf_size = server->pdu_size;
5168 }
5169
5170 if (*num_mids >= MAX_COMPOUND) {
5171 cifs_server_dbg(VFS, "too many PDUs in compound\n");
5172 return -1;
5173 }
5174 bufs[*num_mids] = buf;
5175 mids[(*num_mids)++] = mid_entry;
5176
5177 if (mid_entry && mid_entry->handle)
5178 ret = mid_entry->handle(server, mid_entry);
5179 else
5180 ret = cifs_handle_standard(server, mid_entry);
5181
5182 if (ret == 0 && shdr->NextCommand) {
5183 pdu_length -= le32_to_cpu(shdr->NextCommand);
5184 server->large_buf = next_is_large;
5185 if (next_is_large)
5186 server->bigbuf = buf = next_buffer;
5187 else
5188 server->smallbuf = buf = next_buffer;
5189 goto one_more;
5190 } else if (ret != 0) {
5191
5192
5193
5194
5195
5196
5197 if (next_is_large)
5198 free_rsp_buf(CIFS_LARGE_BUFFER, next_buffer);
5199 else
5200 free_rsp_buf(CIFS_SMALL_BUFFER, next_buffer);
5201 }
5202
5203 return ret;
5204}
5205
5206static int
5207smb3_receive_transform(struct TCP_Server_Info *server,
5208 struct mid_q_entry **mids, char **bufs, int *num_mids)
5209{
5210 char *buf = server->smallbuf;
5211 unsigned int pdu_length = server->pdu_size;
5212 struct smb2_transform_hdr *tr_hdr = (struct smb2_transform_hdr *)buf;
5213 unsigned int orig_len = le32_to_cpu(tr_hdr->OriginalMessageSize);
5214
5215 if (pdu_length < sizeof(struct smb2_transform_hdr) +
5216 sizeof(struct smb2_sync_hdr)) {
5217 cifs_server_dbg(VFS, "Transform message is too small (%u)\n",
5218 pdu_length);
5219 cifs_reconnect(server);
5220 return -ECONNABORTED;
5221 }
5222
5223 if (pdu_length < orig_len + sizeof(struct smb2_transform_hdr)) {
5224 cifs_server_dbg(VFS, "Transform message is broken\n");
5225 cifs_reconnect(server);
5226 return -ECONNABORTED;
5227 }
5228
5229
5230 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server)) {
5231 return receive_encrypted_read(server, &mids[0], num_mids);
5232 }
5233
5234 return receive_encrypted_standard(server, mids, bufs, num_mids);
5235}
5236
5237int
5238smb3_handle_read_data(struct TCP_Server_Info *server, struct mid_q_entry *mid)
5239{
5240 char *buf = server->large_buf ? server->bigbuf : server->smallbuf;
5241
5242 return handle_read_data(server, mid, buf, server->pdu_size,
5243 NULL, 0, 0, false);
5244}
5245
5246static int
5247smb2_next_header(char *buf)
5248{
5249 struct smb2_sync_hdr *hdr = (struct smb2_sync_hdr *)buf;
5250 struct smb2_transform_hdr *t_hdr = (struct smb2_transform_hdr *)buf;
5251
5252 if (hdr->ProtocolId == SMB2_TRANSFORM_PROTO_NUM)
5253 return sizeof(struct smb2_transform_hdr) +
5254 le32_to_cpu(t_hdr->OriginalMessageSize);
5255
5256 return le32_to_cpu(hdr->NextCommand);
5257}
5258
5259static int
5260smb2_make_node(unsigned int xid, struct inode *inode,
5261 struct dentry *dentry, struct cifs_tcon *tcon,
5262 const char *full_path, umode_t mode, dev_t dev)
5263{
5264 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
5265 int rc = -EPERM;
5266 FILE_ALL_INFO *buf = NULL;
5267 struct cifs_io_parms io_parms = {0};
5268 __u32 oplock = 0;
5269 struct cifs_fid fid;
5270 struct cifs_open_parms oparms;
5271 unsigned int bytes_written;
5272 struct win_dev *pdev;
5273 struct kvec iov[2];
5274
5275
5276
5277
5278
5279
5280
5281 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL))
5282 goto out;
5283
5284
5285
5286
5287
5288
5289
5290 if (!S_ISCHR(mode) && !S_ISBLK(mode))
5291 goto out;
5292
5293 cifs_dbg(FYI, "sfu compat create special file\n");
5294
5295 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
5296 if (buf == NULL) {
5297 rc = -ENOMEM;
5298 goto out;
5299 }
5300
5301 oparms.tcon = tcon;
5302 oparms.cifs_sb = cifs_sb;
5303 oparms.desired_access = GENERIC_WRITE;
5304 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR |
5305 CREATE_OPTION_SPECIAL);
5306 oparms.disposition = FILE_CREATE;
5307 oparms.path = full_path;
5308 oparms.fid = &fid;
5309 oparms.reconnect = false;
5310
5311 if (tcon->ses->server->oplocks)
5312 oplock = REQ_OPLOCK;
5313 else
5314 oplock = 0;
5315 rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, buf);
5316 if (rc)
5317 goto out;
5318
5319
5320
5321
5322
5323
5324 pdev = (struct win_dev *)buf;
5325 io_parms.pid = current->tgid;
5326 io_parms.tcon = tcon;
5327 io_parms.offset = 0;
5328 io_parms.length = sizeof(struct win_dev);
5329 iov[1].iov_base = buf;
5330 iov[1].iov_len = sizeof(struct win_dev);
5331 if (S_ISCHR(mode)) {
5332 memcpy(pdev->type, "IntxCHR", 8);
5333 pdev->major = cpu_to_le64(MAJOR(dev));
5334 pdev->minor = cpu_to_le64(MINOR(dev));
5335 rc = tcon->ses->server->ops->sync_write(xid, &fid, &io_parms,
5336 &bytes_written, iov, 1);
5337 } else if (S_ISBLK(mode)) {
5338 memcpy(pdev->type, "IntxBLK", 8);
5339 pdev->major = cpu_to_le64(MAJOR(dev));
5340 pdev->minor = cpu_to_le64(MINOR(dev));
5341 rc = tcon->ses->server->ops->sync_write(xid, &fid, &io_parms,
5342 &bytes_written, iov, 1);
5343 }
5344 tcon->ses->server->ops->close(xid, tcon, &fid);
5345 d_drop(dentry);
5346
5347
5348out:
5349 kfree(buf);
5350 return rc;
5351}
5352
5353
5354struct smb_version_operations smb20_operations = {
5355 .compare_fids = smb2_compare_fids,
5356 .setup_request = smb2_setup_request,
5357 .setup_async_request = smb2_setup_async_request,
5358 .check_receive = smb2_check_receive,
5359 .add_credits = smb2_add_credits,
5360 .set_credits = smb2_set_credits,
5361 .get_credits_field = smb2_get_credits_field,
5362 .get_credits = smb2_get_credits,
5363 .wait_mtu_credits = cifs_wait_mtu_credits,
5364 .get_next_mid = smb2_get_next_mid,
5365 .revert_current_mid = smb2_revert_current_mid,
5366 .read_data_offset = smb2_read_data_offset,
5367 .read_data_length = smb2_read_data_length,
5368 .map_error = map_smb2_to_linux_error,
5369 .find_mid = smb2_find_mid,
5370 .check_message = smb2_check_message,
5371 .dump_detail = smb2_dump_detail,
5372 .clear_stats = smb2_clear_stats,
5373 .print_stats = smb2_print_stats,
5374 .is_oplock_break = smb2_is_valid_oplock_break,
5375 .handle_cancelled_mid = smb2_handle_cancelled_mid,
5376 .downgrade_oplock = smb2_downgrade_oplock,
5377 .need_neg = smb2_need_neg,
5378 .negotiate = smb2_negotiate,
5379 .negotiate_wsize = smb2_negotiate_wsize,
5380 .negotiate_rsize = smb2_negotiate_rsize,
5381 .sess_setup = SMB2_sess_setup,
5382 .logoff = SMB2_logoff,
5383 .tree_connect = SMB2_tcon,
5384 .tree_disconnect = SMB2_tdis,
5385 .qfs_tcon = smb2_qfs_tcon,
5386 .is_path_accessible = smb2_is_path_accessible,
5387 .can_echo = smb2_can_echo,
5388 .echo = SMB2_echo,
5389 .query_path_info = smb2_query_path_info,
5390 .get_srv_inum = smb2_get_srv_inum,
5391 .query_file_info = smb2_query_file_info,
5392 .set_path_size = smb2_set_path_size,
5393 .set_file_size = smb2_set_file_size,
5394 .set_file_info = smb2_set_file_info,
5395 .set_compression = smb2_set_compression,
5396 .mkdir = smb2_mkdir,
5397 .mkdir_setinfo = smb2_mkdir_setinfo,
5398 .rmdir = smb2_rmdir,
5399 .unlink = smb2_unlink,
5400 .rename = smb2_rename_path,
5401 .create_hardlink = smb2_create_hardlink,
5402 .query_symlink = smb2_query_symlink,
5403 .query_mf_symlink = smb3_query_mf_symlink,
5404 .create_mf_symlink = smb3_create_mf_symlink,
5405 .open = smb2_open_file,
5406 .set_fid = smb2_set_fid,
5407 .close = smb2_close_file,
5408 .flush = smb2_flush_file,
5409 .async_readv = smb2_async_readv,
5410 .async_writev = smb2_async_writev,
5411 .sync_read = smb2_sync_read,
5412 .sync_write = smb2_sync_write,
5413 .query_dir_first = smb2_query_dir_first,
5414 .query_dir_next = smb2_query_dir_next,
5415 .close_dir = smb2_close_dir,
5416 .calc_smb_size = smb2_calc_size,
5417 .is_status_pending = smb2_is_status_pending,
5418 .is_session_expired = smb2_is_session_expired,
5419 .oplock_response = smb2_oplock_response,
5420 .queryfs = smb2_queryfs,
5421 .mand_lock = smb2_mand_lock,
5422 .mand_unlock_range = smb2_unlock_range,
5423 .push_mand_locks = smb2_push_mandatory_locks,
5424 .get_lease_key = smb2_get_lease_key,
5425 .set_lease_key = smb2_set_lease_key,
5426 .new_lease_key = smb2_new_lease_key,
5427 .calc_signature = smb2_calc_signature,
5428 .is_read_op = smb2_is_read_op,
5429 .set_oplock_level = smb2_set_oplock_level,
5430 .create_lease_buf = smb2_create_lease_buf,
5431 .parse_lease_buf = smb2_parse_lease_buf,
5432 .copychunk_range = smb2_copychunk_range,
5433 .wp_retry_size = smb2_wp_retry_size,
5434 .dir_needs_close = smb2_dir_needs_close,
5435 .get_dfs_refer = smb2_get_dfs_refer,
5436 .select_sectype = smb2_select_sectype,
5437#ifdef CONFIG_CIFS_XATTR
5438 .query_all_EAs = smb2_query_eas,
5439 .set_EA = smb2_set_ea,
5440#endif
5441 .get_acl = get_smb2_acl,
5442 .get_acl_by_fid = get_smb2_acl_by_fid,
5443 .set_acl = set_smb2_acl,
5444 .next_header = smb2_next_header,
5445 .ioctl_query_info = smb2_ioctl_query_info,
5446 .make_node = smb2_make_node,
5447 .fiemap = smb3_fiemap,
5448 .llseek = smb3_llseek,
5449 .is_status_io_timeout = smb2_is_status_io_timeout,
5450 .is_network_name_deleted = smb2_is_network_name_deleted,
5451};
5452
5453struct smb_version_operations smb21_operations = {
5454 .compare_fids = smb2_compare_fids,
5455 .setup_request = smb2_setup_request,
5456 .setup_async_request = smb2_setup_async_request,
5457 .check_receive = smb2_check_receive,
5458 .add_credits = smb2_add_credits,
5459 .set_credits = smb2_set_credits,
5460 .get_credits_field = smb2_get_credits_field,
5461 .get_credits = smb2_get_credits,
5462 .wait_mtu_credits = smb2_wait_mtu_credits,
5463 .adjust_credits = smb2_adjust_credits,
5464 .get_next_mid = smb2_get_next_mid,
5465 .revert_current_mid = smb2_revert_current_mid,
5466 .read_data_offset = smb2_read_data_offset,
5467 .read_data_length = smb2_read_data_length,
5468 .map_error = map_smb2_to_linux_error,
5469 .find_mid = smb2_find_mid,
5470 .check_message = smb2_check_message,
5471 .dump_detail = smb2_dump_detail,
5472 .clear_stats = smb2_clear_stats,
5473 .print_stats = smb2_print_stats,
5474 .is_oplock_break = smb2_is_valid_oplock_break,
5475 .handle_cancelled_mid = smb2_handle_cancelled_mid,
5476 .downgrade_oplock = smb2_downgrade_oplock,
5477 .need_neg = smb2_need_neg,
5478 .negotiate = smb2_negotiate,
5479 .negotiate_wsize = smb2_negotiate_wsize,
5480 .negotiate_rsize = smb2_negotiate_rsize,
5481 .sess_setup = SMB2_sess_setup,
5482 .logoff = SMB2_logoff,
5483 .tree_connect = SMB2_tcon,
5484 .tree_disconnect = SMB2_tdis,
5485 .qfs_tcon = smb2_qfs_tcon,
5486 .is_path_accessible = smb2_is_path_accessible,
5487 .can_echo = smb2_can_echo,
5488 .echo = SMB2_echo,
5489 .query_path_info = smb2_query_path_info,
5490 .get_srv_inum = smb2_get_srv_inum,
5491 .query_file_info = smb2_query_file_info,
5492 .set_path_size = smb2_set_path_size,
5493 .set_file_size = smb2_set_file_size,
5494 .set_file_info = smb2_set_file_info,
5495 .set_compression = smb2_set_compression,
5496 .mkdir = smb2_mkdir,
5497 .mkdir_setinfo = smb2_mkdir_setinfo,
5498 .rmdir = smb2_rmdir,
5499 .unlink = smb2_unlink,
5500 .rename = smb2_rename_path,
5501 .create_hardlink = smb2_create_hardlink,
5502 .query_symlink = smb2_query_symlink,
5503 .query_mf_symlink = smb3_query_mf_symlink,
5504 .create_mf_symlink = smb3_create_mf_symlink,
5505 .open = smb2_open_file,
5506 .set_fid = smb2_set_fid,
5507 .close = smb2_close_file,
5508 .flush = smb2_flush_file,
5509 .async_readv = smb2_async_readv,
5510 .async_writev = smb2_async_writev,
5511 .sync_read = smb2_sync_read,
5512 .sync_write = smb2_sync_write,
5513 .query_dir_first = smb2_query_dir_first,
5514 .query_dir_next = smb2_query_dir_next,
5515 .close_dir = smb2_close_dir,
5516 .calc_smb_size = smb2_calc_size,
5517 .is_status_pending = smb2_is_status_pending,
5518 .is_session_expired = smb2_is_session_expired,
5519 .oplock_response = smb2_oplock_response,
5520 .queryfs = smb2_queryfs,
5521 .mand_lock = smb2_mand_lock,
5522 .mand_unlock_range = smb2_unlock_range,
5523 .push_mand_locks = smb2_push_mandatory_locks,
5524 .get_lease_key = smb2_get_lease_key,
5525 .set_lease_key = smb2_set_lease_key,
5526 .new_lease_key = smb2_new_lease_key,
5527 .calc_signature = smb2_calc_signature,
5528 .is_read_op = smb21_is_read_op,
5529 .set_oplock_level = smb21_set_oplock_level,
5530 .create_lease_buf = smb2_create_lease_buf,
5531 .parse_lease_buf = smb2_parse_lease_buf,
5532 .copychunk_range = smb2_copychunk_range,
5533 .wp_retry_size = smb2_wp_retry_size,
5534 .dir_needs_close = smb2_dir_needs_close,
5535 .enum_snapshots = smb3_enum_snapshots,
5536 .notify = smb3_notify,
5537 .get_dfs_refer = smb2_get_dfs_refer,
5538 .select_sectype = smb2_select_sectype,
5539#ifdef CONFIG_CIFS_XATTR
5540 .query_all_EAs = smb2_query_eas,
5541 .set_EA = smb2_set_ea,
5542#endif
5543 .get_acl = get_smb2_acl,
5544 .get_acl_by_fid = get_smb2_acl_by_fid,
5545 .set_acl = set_smb2_acl,
5546 .next_header = smb2_next_header,
5547 .ioctl_query_info = smb2_ioctl_query_info,
5548 .make_node = smb2_make_node,
5549 .fiemap = smb3_fiemap,
5550 .llseek = smb3_llseek,
5551 .is_status_io_timeout = smb2_is_status_io_timeout,
5552 .is_network_name_deleted = smb2_is_network_name_deleted,
5553};
5554
5555struct smb_version_operations smb30_operations = {
5556 .compare_fids = smb2_compare_fids,
5557 .setup_request = smb2_setup_request,
5558 .setup_async_request = smb2_setup_async_request,
5559 .check_receive = smb2_check_receive,
5560 .add_credits = smb2_add_credits,
5561 .set_credits = smb2_set_credits,
5562 .get_credits_field = smb2_get_credits_field,
5563 .get_credits = smb2_get_credits,
5564 .wait_mtu_credits = smb2_wait_mtu_credits,
5565 .adjust_credits = smb2_adjust_credits,
5566 .get_next_mid = smb2_get_next_mid,
5567 .revert_current_mid = smb2_revert_current_mid,
5568 .read_data_offset = smb2_read_data_offset,
5569 .read_data_length = smb2_read_data_length,
5570 .map_error = map_smb2_to_linux_error,
5571 .find_mid = smb2_find_mid,
5572 .check_message = smb2_check_message,
5573 .dump_detail = smb2_dump_detail,
5574 .clear_stats = smb2_clear_stats,
5575 .print_stats = smb2_print_stats,
5576 .dump_share_caps = smb2_dump_share_caps,
5577 .is_oplock_break = smb2_is_valid_oplock_break,
5578 .handle_cancelled_mid = smb2_handle_cancelled_mid,
5579 .downgrade_oplock = smb3_downgrade_oplock,
5580 .need_neg = smb2_need_neg,
5581 .negotiate = smb2_negotiate,
5582 .negotiate_wsize = smb3_negotiate_wsize,
5583 .negotiate_rsize = smb3_negotiate_rsize,
5584 .sess_setup = SMB2_sess_setup,
5585 .logoff = SMB2_logoff,
5586 .tree_connect = SMB2_tcon,
5587 .tree_disconnect = SMB2_tdis,
5588 .qfs_tcon = smb3_qfs_tcon,
5589 .is_path_accessible = smb2_is_path_accessible,
5590 .can_echo = smb2_can_echo,
5591 .echo = SMB2_echo,
5592 .query_path_info = smb2_query_path_info,
5593
5594 .query_reparse_tag = smb2_query_reparse_tag,
5595 .get_srv_inum = smb2_get_srv_inum,
5596 .query_file_info = smb2_query_file_info,
5597 .set_path_size = smb2_set_path_size,
5598 .set_file_size = smb2_set_file_size,
5599 .set_file_info = smb2_set_file_info,
5600 .set_compression = smb2_set_compression,
5601 .mkdir = smb2_mkdir,
5602 .mkdir_setinfo = smb2_mkdir_setinfo,
5603 .rmdir = smb2_rmdir,
5604 .unlink = smb2_unlink,
5605 .rename = smb2_rename_path,
5606 .create_hardlink = smb2_create_hardlink,
5607 .query_symlink = smb2_query_symlink,
5608 .query_mf_symlink = smb3_query_mf_symlink,
5609 .create_mf_symlink = smb3_create_mf_symlink,
5610 .open = smb2_open_file,
5611 .set_fid = smb2_set_fid,
5612 .close = smb2_close_file,
5613 .close_getattr = smb2_close_getattr,
5614 .flush = smb2_flush_file,
5615 .async_readv = smb2_async_readv,
5616 .async_writev = smb2_async_writev,
5617 .sync_read = smb2_sync_read,
5618 .sync_write = smb2_sync_write,
5619 .query_dir_first = smb2_query_dir_first,
5620 .query_dir_next = smb2_query_dir_next,
5621 .close_dir = smb2_close_dir,
5622 .calc_smb_size = smb2_calc_size,
5623 .is_status_pending = smb2_is_status_pending,
5624 .is_session_expired = smb2_is_session_expired,
5625 .oplock_response = smb2_oplock_response,
5626 .queryfs = smb2_queryfs,
5627 .mand_lock = smb2_mand_lock,
5628 .mand_unlock_range = smb2_unlock_range,
5629 .push_mand_locks = smb2_push_mandatory_locks,
5630 .get_lease_key = smb2_get_lease_key,
5631 .set_lease_key = smb2_set_lease_key,
5632 .new_lease_key = smb2_new_lease_key,
5633 .generate_signingkey = generate_smb30signingkey,
5634 .calc_signature = smb3_calc_signature,
5635 .set_integrity = smb3_set_integrity,
5636 .is_read_op = smb21_is_read_op,
5637 .set_oplock_level = smb3_set_oplock_level,
5638 .create_lease_buf = smb3_create_lease_buf,
5639 .parse_lease_buf = smb3_parse_lease_buf,
5640 .copychunk_range = smb2_copychunk_range,
5641 .duplicate_extents = smb2_duplicate_extents,
5642 .validate_negotiate = smb3_validate_negotiate,
5643 .wp_retry_size = smb2_wp_retry_size,
5644 .dir_needs_close = smb2_dir_needs_close,
5645 .fallocate = smb3_fallocate,
5646 .enum_snapshots = smb3_enum_snapshots,
5647 .notify = smb3_notify,
5648 .init_transform_rq = smb3_init_transform_rq,
5649 .is_transform_hdr = smb3_is_transform_hdr,
5650 .receive_transform = smb3_receive_transform,
5651 .get_dfs_refer = smb2_get_dfs_refer,
5652 .select_sectype = smb2_select_sectype,
5653#ifdef CONFIG_CIFS_XATTR
5654 .query_all_EAs = smb2_query_eas,
5655 .set_EA = smb2_set_ea,
5656#endif
5657 .get_acl = get_smb2_acl,
5658 .get_acl_by_fid = get_smb2_acl_by_fid,
5659 .set_acl = set_smb2_acl,
5660 .next_header = smb2_next_header,
5661 .ioctl_query_info = smb2_ioctl_query_info,
5662 .make_node = smb2_make_node,
5663 .fiemap = smb3_fiemap,
5664 .llseek = smb3_llseek,
5665 .is_status_io_timeout = smb2_is_status_io_timeout,
5666 .is_network_name_deleted = smb2_is_network_name_deleted,
5667};
5668
5669struct smb_version_operations smb311_operations = {
5670 .compare_fids = smb2_compare_fids,
5671 .setup_request = smb2_setup_request,
5672 .setup_async_request = smb2_setup_async_request,
5673 .check_receive = smb2_check_receive,
5674 .add_credits = smb2_add_credits,
5675 .set_credits = smb2_set_credits,
5676 .get_credits_field = smb2_get_credits_field,
5677 .get_credits = smb2_get_credits,
5678 .wait_mtu_credits = smb2_wait_mtu_credits,
5679 .adjust_credits = smb2_adjust_credits,
5680 .get_next_mid = smb2_get_next_mid,
5681 .revert_current_mid = smb2_revert_current_mid,
5682 .read_data_offset = smb2_read_data_offset,
5683 .read_data_length = smb2_read_data_length,
5684 .map_error = map_smb2_to_linux_error,
5685 .find_mid = smb2_find_mid,
5686 .check_message = smb2_check_message,
5687 .dump_detail = smb2_dump_detail,
5688 .clear_stats = smb2_clear_stats,
5689 .print_stats = smb2_print_stats,
5690 .dump_share_caps = smb2_dump_share_caps,
5691 .is_oplock_break = smb2_is_valid_oplock_break,
5692 .handle_cancelled_mid = smb2_handle_cancelled_mid,
5693 .downgrade_oplock = smb3_downgrade_oplock,
5694 .need_neg = smb2_need_neg,
5695 .negotiate = smb2_negotiate,
5696 .negotiate_wsize = smb3_negotiate_wsize,
5697 .negotiate_rsize = smb3_negotiate_rsize,
5698 .sess_setup = SMB2_sess_setup,
5699 .logoff = SMB2_logoff,
5700 .tree_connect = SMB2_tcon,
5701 .tree_disconnect = SMB2_tdis,
5702 .qfs_tcon = smb3_qfs_tcon,
5703 .is_path_accessible = smb2_is_path_accessible,
5704 .can_echo = smb2_can_echo,
5705 .echo = SMB2_echo,
5706 .query_path_info = smb2_query_path_info,
5707 .query_reparse_tag = smb2_query_reparse_tag,
5708 .get_srv_inum = smb2_get_srv_inum,
5709 .query_file_info = smb2_query_file_info,
5710 .set_path_size = smb2_set_path_size,
5711 .set_file_size = smb2_set_file_size,
5712 .set_file_info = smb2_set_file_info,
5713 .set_compression = smb2_set_compression,
5714 .mkdir = smb2_mkdir,
5715 .mkdir_setinfo = smb2_mkdir_setinfo,
5716 .posix_mkdir = smb311_posix_mkdir,
5717 .rmdir = smb2_rmdir,
5718 .unlink = smb2_unlink,
5719 .rename = smb2_rename_path,
5720 .create_hardlink = smb2_create_hardlink,
5721 .query_symlink = smb2_query_symlink,
5722 .query_mf_symlink = smb3_query_mf_symlink,
5723 .create_mf_symlink = smb3_create_mf_symlink,
5724 .open = smb2_open_file,
5725 .set_fid = smb2_set_fid,
5726 .close = smb2_close_file,
5727 .close_getattr = smb2_close_getattr,
5728 .flush = smb2_flush_file,
5729 .async_readv = smb2_async_readv,
5730 .async_writev = smb2_async_writev,
5731 .sync_read = smb2_sync_read,
5732 .sync_write = smb2_sync_write,
5733 .query_dir_first = smb2_query_dir_first,
5734 .query_dir_next = smb2_query_dir_next,
5735 .close_dir = smb2_close_dir,
5736 .calc_smb_size = smb2_calc_size,
5737 .is_status_pending = smb2_is_status_pending,
5738 .is_session_expired = smb2_is_session_expired,
5739 .oplock_response = smb2_oplock_response,
5740 .queryfs = smb311_queryfs,
5741 .mand_lock = smb2_mand_lock,
5742 .mand_unlock_range = smb2_unlock_range,
5743 .push_mand_locks = smb2_push_mandatory_locks,
5744 .get_lease_key = smb2_get_lease_key,
5745 .set_lease_key = smb2_set_lease_key,
5746 .new_lease_key = smb2_new_lease_key,
5747 .generate_signingkey = generate_smb311signingkey,
5748 .calc_signature = smb3_calc_signature,
5749 .set_integrity = smb3_set_integrity,
5750 .is_read_op = smb21_is_read_op,
5751 .set_oplock_level = smb3_set_oplock_level,
5752 .create_lease_buf = smb3_create_lease_buf,
5753 .parse_lease_buf = smb3_parse_lease_buf,
5754 .copychunk_range = smb2_copychunk_range,
5755 .duplicate_extents = smb2_duplicate_extents,
5756
5757 .wp_retry_size = smb2_wp_retry_size,
5758 .dir_needs_close = smb2_dir_needs_close,
5759 .fallocate = smb3_fallocate,
5760 .enum_snapshots = smb3_enum_snapshots,
5761 .notify = smb3_notify,
5762 .init_transform_rq = smb3_init_transform_rq,
5763 .is_transform_hdr = smb3_is_transform_hdr,
5764 .receive_transform = smb3_receive_transform,
5765 .get_dfs_refer = smb2_get_dfs_refer,
5766 .select_sectype = smb2_select_sectype,
5767#ifdef CONFIG_CIFS_XATTR
5768 .query_all_EAs = smb2_query_eas,
5769 .set_EA = smb2_set_ea,
5770#endif
5771 .get_acl = get_smb2_acl,
5772 .get_acl_by_fid = get_smb2_acl_by_fid,
5773 .set_acl = set_smb2_acl,
5774 .next_header = smb2_next_header,
5775 .ioctl_query_info = smb2_ioctl_query_info,
5776 .make_node = smb2_make_node,
5777 .fiemap = smb3_fiemap,
5778 .llseek = smb3_llseek,
5779 .is_status_io_timeout = smb2_is_status_io_timeout,
5780 .is_network_name_deleted = smb2_is_network_name_deleted,
5781};
5782
5783struct smb_version_values smb20_values = {
5784 .version_string = SMB20_VERSION_STRING,
5785 .protocol_id = SMB20_PROT_ID,
5786 .req_capabilities = 0,
5787 .large_lock_type = 0,
5788 .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK,
5789 .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK,
5790 .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK,
5791 .header_size = sizeof(struct smb2_sync_hdr),
5792 .header_preamble_size = 0,
5793 .max_header_size = MAX_SMB2_HDR_SIZE,
5794 .read_rsp_size = sizeof(struct smb2_read_rsp) - 1,
5795 .lock_cmd = SMB2_LOCK,
5796 .cap_unix = 0,
5797 .cap_nt_find = SMB2_NT_FIND,
5798 .cap_large_files = SMB2_LARGE_FILES,
5799 .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED,
5800 .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED,
5801 .create_lease_size = sizeof(struct create_lease),
5802};
5803
5804struct smb_version_values smb21_values = {
5805 .version_string = SMB21_VERSION_STRING,
5806 .protocol_id = SMB21_PROT_ID,
5807 .req_capabilities = 0,
5808 .large_lock_type = 0,
5809 .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK,
5810 .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK,
5811 .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK,
5812 .header_size = sizeof(struct smb2_sync_hdr),
5813 .header_preamble_size = 0,
5814 .max_header_size = MAX_SMB2_HDR_SIZE,
5815 .read_rsp_size = sizeof(struct smb2_read_rsp) - 1,
5816 .lock_cmd = SMB2_LOCK,
5817 .cap_unix = 0,
5818 .cap_nt_find = SMB2_NT_FIND,
5819 .cap_large_files = SMB2_LARGE_FILES,
5820 .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED,
5821 .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED,
5822 .create_lease_size = sizeof(struct create_lease),
5823};
5824
5825struct smb_version_values smb3any_values = {
5826 .version_string = SMB3ANY_VERSION_STRING,
5827 .protocol_id = SMB302_PROT_ID,
5828 .req_capabilities = SMB2_GLOBAL_CAP_DFS | SMB2_GLOBAL_CAP_LEASING | SMB2_GLOBAL_CAP_LARGE_MTU | SMB2_GLOBAL_CAP_PERSISTENT_HANDLES | SMB2_GLOBAL_CAP_ENCRYPTION | SMB2_GLOBAL_CAP_DIRECTORY_LEASING,
5829 .large_lock_type = 0,
5830 .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK,
5831 .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK,
5832 .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK,
5833 .header_size = sizeof(struct smb2_sync_hdr),
5834 .header_preamble_size = 0,
5835 .max_header_size = MAX_SMB2_HDR_SIZE,
5836 .read_rsp_size = sizeof(struct smb2_read_rsp) - 1,
5837 .lock_cmd = SMB2_LOCK,
5838 .cap_unix = 0,
5839 .cap_nt_find = SMB2_NT_FIND,
5840 .cap_large_files = SMB2_LARGE_FILES,
5841 .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED,
5842 .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED,
5843 .create_lease_size = sizeof(struct create_lease_v2),
5844};
5845
5846struct smb_version_values smbdefault_values = {
5847 .version_string = SMBDEFAULT_VERSION_STRING,
5848 .protocol_id = SMB302_PROT_ID,
5849 .req_capabilities = SMB2_GLOBAL_CAP_DFS | SMB2_GLOBAL_CAP_LEASING | SMB2_GLOBAL_CAP_LARGE_MTU | SMB2_GLOBAL_CAP_PERSISTENT_HANDLES | SMB2_GLOBAL_CAP_ENCRYPTION | SMB2_GLOBAL_CAP_DIRECTORY_LEASING,
5850 .large_lock_type = 0,
5851 .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK,
5852 .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK,
5853 .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK,
5854 .header_size = sizeof(struct smb2_sync_hdr),
5855 .header_preamble_size = 0,
5856 .max_header_size = MAX_SMB2_HDR_SIZE,
5857 .read_rsp_size = sizeof(struct smb2_read_rsp) - 1,
5858 .lock_cmd = SMB2_LOCK,
5859 .cap_unix = 0,
5860 .cap_nt_find = SMB2_NT_FIND,
5861 .cap_large_files = SMB2_LARGE_FILES,
5862 .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED,
5863 .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED,
5864 .create_lease_size = sizeof(struct create_lease_v2),
5865};
5866
5867struct smb_version_values smb30_values = {
5868 .version_string = SMB30_VERSION_STRING,
5869 .protocol_id = SMB30_PROT_ID,
5870 .req_capabilities = SMB2_GLOBAL_CAP_DFS | SMB2_GLOBAL_CAP_LEASING | SMB2_GLOBAL_CAP_LARGE_MTU | SMB2_GLOBAL_CAP_PERSISTENT_HANDLES | SMB2_GLOBAL_CAP_ENCRYPTION | SMB2_GLOBAL_CAP_DIRECTORY_LEASING,
5871 .large_lock_type = 0,
5872 .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK,
5873 .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK,
5874 .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK,
5875 .header_size = sizeof(struct smb2_sync_hdr),
5876 .header_preamble_size = 0,
5877 .max_header_size = MAX_SMB2_HDR_SIZE,
5878 .read_rsp_size = sizeof(struct smb2_read_rsp) - 1,
5879 .lock_cmd = SMB2_LOCK,
5880 .cap_unix = 0,
5881 .cap_nt_find = SMB2_NT_FIND,
5882 .cap_large_files = SMB2_LARGE_FILES,
5883 .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED,
5884 .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED,
5885 .create_lease_size = sizeof(struct create_lease_v2),
5886};
5887
5888struct smb_version_values smb302_values = {
5889 .version_string = SMB302_VERSION_STRING,
5890 .protocol_id = SMB302_PROT_ID,
5891 .req_capabilities = SMB2_GLOBAL_CAP_DFS | SMB2_GLOBAL_CAP_LEASING | SMB2_GLOBAL_CAP_LARGE_MTU | SMB2_GLOBAL_CAP_PERSISTENT_HANDLES | SMB2_GLOBAL_CAP_ENCRYPTION | SMB2_GLOBAL_CAP_DIRECTORY_LEASING,
5892 .large_lock_type = 0,
5893 .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK,
5894 .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK,
5895 .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK,
5896 .header_size = sizeof(struct smb2_sync_hdr),
5897 .header_preamble_size = 0,
5898 .max_header_size = MAX_SMB2_HDR_SIZE,
5899 .read_rsp_size = sizeof(struct smb2_read_rsp) - 1,
5900 .lock_cmd = SMB2_LOCK,
5901 .cap_unix = 0,
5902 .cap_nt_find = SMB2_NT_FIND,
5903 .cap_large_files = SMB2_LARGE_FILES,
5904 .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED,
5905 .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED,
5906 .create_lease_size = sizeof(struct create_lease_v2),
5907};
5908
5909struct smb_version_values smb311_values = {
5910 .version_string = SMB311_VERSION_STRING,
5911 .protocol_id = SMB311_PROT_ID,
5912 .req_capabilities = SMB2_GLOBAL_CAP_DFS | SMB2_GLOBAL_CAP_LEASING | SMB2_GLOBAL_CAP_LARGE_MTU | SMB2_GLOBAL_CAP_PERSISTENT_HANDLES | SMB2_GLOBAL_CAP_ENCRYPTION | SMB2_GLOBAL_CAP_DIRECTORY_LEASING,
5913 .large_lock_type = 0,
5914 .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK,
5915 .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK,
5916 .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK,
5917 .header_size = sizeof(struct smb2_sync_hdr),
5918 .header_preamble_size = 0,
5919 .max_header_size = MAX_SMB2_HDR_SIZE,
5920 .read_rsp_size = sizeof(struct smb2_read_rsp) - 1,
5921 .lock_cmd = SMB2_LOCK,
5922 .cap_unix = 0,
5923 .cap_nt_find = SMB2_NT_FIND,
5924 .cap_large_files = SMB2_LARGE_FILES,
5925 .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED,
5926 .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED,
5927 .create_lease_size = sizeof(struct create_lease_v2),
5928};
5929