Loading...
1// SPDX-License-Identifier: LGPL-2.1
2/*
3 *
4 * vfs operations that deal with io control
5 *
6 * Copyright (C) International Business Machines Corp., 2005,2013
7 * Author(s): Steve French (sfrench@us.ibm.com)
8 *
9 */
10
11#include <linux/fs.h>
12#include <linux/file.h>
13#include <linux/mount.h>
14#include <linux/mm.h>
15#include <linux/pagemap.h>
16#include "cifspdu.h"
17#include "cifsglob.h"
18#include "cifsproto.h"
19#include "cifs_debug.h"
20#include "cifsfs.h"
21#include "cifs_ioctl.h"
22#include "smb2proto.h"
23#include "smb2glob.h"
24#include <linux/btrfs.h>
25
26static long cifs_ioctl_query_info(unsigned int xid, struct file *filep,
27 unsigned long p)
28{
29 struct inode *inode = file_inode(filep);
30 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
31 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
32 struct dentry *dentry = filep->f_path.dentry;
33 const unsigned char *path;
34 void *page = alloc_dentry_path();
35 __le16 *utf16_path = NULL, root_path;
36 int rc = 0;
37
38 path = build_path_from_dentry(dentry, page);
39 if (IS_ERR(path)) {
40 free_dentry_path(page);
41 return PTR_ERR(path);
42 }
43
44 cifs_dbg(FYI, "%s %s\n", __func__, path);
45
46 if (!path[0]) {
47 root_path = 0;
48 utf16_path = &root_path;
49 } else {
50 utf16_path = cifs_convert_path_to_utf16(path + 1, cifs_sb);
51 if (!utf16_path) {
52 rc = -ENOMEM;
53 goto ici_exit;
54 }
55 }
56
57 if (tcon->ses->server->ops->ioctl_query_info)
58 rc = tcon->ses->server->ops->ioctl_query_info(
59 xid, tcon, cifs_sb, utf16_path,
60 filep->private_data ? 0 : 1, p);
61 else
62 rc = -EOPNOTSUPP;
63
64 ici_exit:
65 if (utf16_path != &root_path)
66 kfree(utf16_path);
67 free_dentry_path(page);
68 return rc;
69}
70
71static long cifs_ioctl_copychunk(unsigned int xid, struct file *dst_file,
72 unsigned long srcfd)
73{
74 int rc;
75 struct inode *src_inode;
76
77 cifs_dbg(FYI, "ioctl copychunk range\n");
78 /* the destination must be opened for writing */
79 if (!(dst_file->f_mode & FMODE_WRITE)) {
80 cifs_dbg(FYI, "file target not open for write\n");
81 return -EINVAL;
82 }
83
84 /* check if target volume is readonly and take reference */
85 rc = mnt_want_write_file(dst_file);
86 if (rc) {
87 cifs_dbg(FYI, "mnt_want_write failed with rc %d\n", rc);
88 return rc;
89 }
90
91 CLASS(fd, src_file)(srcfd);
92 if (fd_empty(src_file)) {
93 rc = -EBADF;
94 goto out_drop_write;
95 }
96
97 if (fd_file(src_file)->f_op->unlocked_ioctl != cifs_ioctl) {
98 rc = -EBADF;
99 cifs_dbg(VFS, "src file seems to be from a different filesystem type\n");
100 goto out_drop_write;
101 }
102
103 src_inode = file_inode(fd_file(src_file));
104 rc = -EINVAL;
105 if (S_ISDIR(src_inode->i_mode))
106 goto out_drop_write;
107
108 rc = cifs_file_copychunk_range(xid, fd_file(src_file), 0, dst_file, 0,
109 src_inode->i_size, 0);
110 if (rc > 0)
111 rc = 0;
112out_drop_write:
113 mnt_drop_write_file(dst_file);
114 return rc;
115}
116
117static long smb_mnt_get_tcon_info(struct cifs_tcon *tcon, void __user *arg)
118{
119 int rc = 0;
120 struct smb_mnt_tcon_info tcon_inf;
121
122 tcon_inf.tid = tcon->tid;
123 tcon_inf.session_id = tcon->ses->Suid;
124
125 if (copy_to_user(arg, &tcon_inf, sizeof(struct smb_mnt_tcon_info)))
126 rc = -EFAULT;
127
128 return rc;
129}
130
131static long smb_mnt_get_fsinfo(unsigned int xid, struct cifs_tcon *tcon,
132 void __user *arg)
133{
134 int rc = 0;
135 struct smb_mnt_fs_info *fsinf;
136
137 fsinf = kzalloc(sizeof(struct smb_mnt_fs_info), GFP_KERNEL);
138 if (fsinf == NULL)
139 return -ENOMEM;
140
141 fsinf->version = 1;
142 fsinf->protocol_id = tcon->ses->server->vals->protocol_id;
143 fsinf->tcon_flags = tcon->Flags;
144 fsinf->device_characteristics =
145 le32_to_cpu(tcon->fsDevInfo.DeviceCharacteristics);
146 fsinf->device_type = le32_to_cpu(tcon->fsDevInfo.DeviceType);
147 fsinf->fs_attributes = le32_to_cpu(tcon->fsAttrInfo.Attributes);
148 fsinf->max_path_component =
149 le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength);
150 fsinf->vol_serial_number = tcon->vol_serial_number;
151 fsinf->vol_create_time = le64_to_cpu(tcon->vol_create_time);
152 fsinf->share_flags = tcon->share_flags;
153 fsinf->share_caps = le32_to_cpu(tcon->capabilities);
154 fsinf->sector_flags = tcon->ss_flags;
155 fsinf->optimal_sector_size = tcon->perf_sector_size;
156 fsinf->max_bytes_chunk = tcon->max_bytes_chunk;
157 fsinf->maximal_access = tcon->maximal_access;
158 fsinf->cifs_posix_caps = le64_to_cpu(tcon->fsUnixInfo.Capability);
159
160 if (copy_to_user(arg, fsinf, sizeof(struct smb_mnt_fs_info)))
161 rc = -EFAULT;
162
163 kfree(fsinf);
164 return rc;
165}
166
167static int cifs_shutdown(struct super_block *sb, unsigned long arg)
168{
169 struct cifs_sb_info *sbi = CIFS_SB(sb);
170 struct tcon_link *tlink;
171 struct cifs_tcon *tcon;
172 __u32 flags;
173 int rc;
174
175 if (!capable(CAP_SYS_ADMIN))
176 return -EPERM;
177
178 if (get_user(flags, (__u32 __user *)arg))
179 return -EFAULT;
180
181 tlink = cifs_sb_tlink(sbi);
182 if (IS_ERR(tlink))
183 return PTR_ERR(tlink);
184 tcon = tlink_tcon(tlink);
185
186 trace_smb3_shutdown_enter(flags, tcon->tid);
187 if (flags > CIFS_GOING_FLAGS_NOLOGFLUSH) {
188 rc = -EINVAL;
189 goto shutdown_out_err;
190 }
191
192 if (cifs_forced_shutdown(sbi))
193 goto shutdown_good;
194
195 cifs_dbg(VFS, "shut down requested (%d)", flags);
196
197 /*
198 * see:
199 * https://man7.org/linux/man-pages/man2/ioctl_xfs_goingdown.2.html
200 * for more information and description of original intent of the flags
201 */
202 switch (flags) {
203 /*
204 * We could add support later for default flag which requires:
205 * "Flush all dirty data and metadata to disk"
206 * would need to call syncfs or equivalent to flush page cache for
207 * the mount and then issue fsync to server (if nostrictsync not set)
208 */
209 case CIFS_GOING_FLAGS_DEFAULT:
210 cifs_dbg(FYI, "shutdown with default flag not supported\n");
211 rc = -EINVAL;
212 goto shutdown_out_err;
213 /*
214 * FLAGS_LOGFLUSH is easy since it asks to write out metadata (not
215 * data) but metadata writes are not cached on the client, so can treat
216 * it similarly to NOLOGFLUSH
217 */
218 case CIFS_GOING_FLAGS_LOGFLUSH:
219 case CIFS_GOING_FLAGS_NOLOGFLUSH:
220 sbi->mnt_cifs_flags |= CIFS_MOUNT_SHUTDOWN;
221 goto shutdown_good;
222 default:
223 rc = -EINVAL;
224 goto shutdown_out_err;
225 }
226
227shutdown_good:
228 trace_smb3_shutdown_done(flags, tcon->tid);
229 cifs_put_tlink(tlink);
230 return 0;
231shutdown_out_err:
232 trace_smb3_shutdown_err(rc, flags, tcon->tid);
233 cifs_put_tlink(tlink);
234 return rc;
235}
236
237static int cifs_dump_full_key(struct cifs_tcon *tcon, struct smb3_full_key_debug_info __user *in)
238{
239 struct smb3_full_key_debug_info out;
240 struct cifs_ses *ses;
241 int rc = 0;
242 bool found = false;
243 u8 __user *end;
244
245 if (!smb3_encryption_required(tcon)) {
246 rc = -EOPNOTSUPP;
247 goto out;
248 }
249
250 /* copy user input into our output buffer */
251 if (copy_from_user(&out, in, sizeof(out))) {
252 rc = -EINVAL;
253 goto out;
254 }
255
256 if (!out.session_id) {
257 /* if ses id is 0, use current user session */
258 ses = tcon->ses;
259 } else {
260 /* otherwise if a session id is given, look for it in all our sessions */
261 struct cifs_ses *ses_it = NULL;
262 struct TCP_Server_Info *server_it = NULL;
263
264 spin_lock(&cifs_tcp_ses_lock);
265 list_for_each_entry(server_it, &cifs_tcp_ses_list, tcp_ses_list) {
266 list_for_each_entry(ses_it, &server_it->smb_ses_list, smb_ses_list) {
267 spin_lock(&ses_it->ses_lock);
268 if (ses_it->ses_status != SES_EXITING &&
269 ses_it->Suid == out.session_id) {
270 ses = ses_it;
271 /*
272 * since we are using the session outside the crit
273 * section, we need to make sure it won't be released
274 * so increment its refcount
275 */
276 cifs_smb_ses_inc_refcount(ses);
277 spin_unlock(&ses_it->ses_lock);
278 found = true;
279 goto search_end;
280 }
281 spin_unlock(&ses_it->ses_lock);
282 }
283 }
284search_end:
285 spin_unlock(&cifs_tcp_ses_lock);
286 if (!found) {
287 rc = -ENOENT;
288 goto out;
289 }
290 }
291
292 switch (ses->server->cipher_type) {
293 case SMB2_ENCRYPTION_AES128_CCM:
294 case SMB2_ENCRYPTION_AES128_GCM:
295 out.session_key_length = CIFS_SESS_KEY_SIZE;
296 out.server_in_key_length = out.server_out_key_length = SMB3_GCM128_CRYPTKEY_SIZE;
297 break;
298 case SMB2_ENCRYPTION_AES256_CCM:
299 case SMB2_ENCRYPTION_AES256_GCM:
300 out.session_key_length = CIFS_SESS_KEY_SIZE;
301 out.server_in_key_length = out.server_out_key_length = SMB3_GCM256_CRYPTKEY_SIZE;
302 break;
303 default:
304 rc = -EOPNOTSUPP;
305 goto out;
306 }
307
308 /* check if user buffer is big enough to store all the keys */
309 if (out.in_size < sizeof(out) + out.session_key_length + out.server_in_key_length
310 + out.server_out_key_length) {
311 rc = -ENOBUFS;
312 goto out;
313 }
314
315 out.session_id = ses->Suid;
316 out.cipher_type = le16_to_cpu(ses->server->cipher_type);
317
318 /* overwrite user input with our output */
319 if (copy_to_user(in, &out, sizeof(out))) {
320 rc = -EINVAL;
321 goto out;
322 }
323
324 /* append all the keys at the end of the user buffer */
325 end = in->data;
326 if (copy_to_user(end, ses->auth_key.response, out.session_key_length)) {
327 rc = -EINVAL;
328 goto out;
329 }
330 end += out.session_key_length;
331
332 if (copy_to_user(end, ses->smb3encryptionkey, out.server_in_key_length)) {
333 rc = -EINVAL;
334 goto out;
335 }
336 end += out.server_in_key_length;
337
338 if (copy_to_user(end, ses->smb3decryptionkey, out.server_out_key_length)) {
339 rc = -EINVAL;
340 goto out;
341 }
342
343out:
344 if (found)
345 cifs_put_smb_ses(ses);
346 return rc;
347}
348
349long cifs_ioctl(struct file *filep, unsigned int command, unsigned long arg)
350{
351 struct inode *inode = file_inode(filep);
352 struct smb3_key_debug_info pkey_inf;
353 int rc = -ENOTTY; /* strange error - but the precedent */
354 unsigned int xid;
355 struct cifsFileInfo *pSMBFile = filep->private_data;
356 struct cifs_tcon *tcon;
357 struct tcon_link *tlink;
358 struct cifs_sb_info *cifs_sb;
359 __u64 ExtAttrBits = 0;
360#ifdef CONFIG_CIFS_POSIX
361#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
362 __u64 caps;
363#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
364#endif /* CONFIG_CIFS_POSIX */
365
366 xid = get_xid();
367
368 cifs_dbg(FYI, "cifs ioctl 0x%x\n", command);
369 if (pSMBFile == NULL)
370 trace_smb3_ioctl(xid, 0, command);
371 else
372 trace_smb3_ioctl(xid, pSMBFile->fid.persistent_fid, command);
373
374 switch (command) {
375 case FS_IOC_GETFLAGS:
376 if (pSMBFile == NULL)
377 break;
378 tcon = tlink_tcon(pSMBFile->tlink);
379#ifdef CONFIG_CIFS_POSIX
380#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
381 caps = le64_to_cpu(tcon->fsUnixInfo.Capability);
382 if (CIFS_UNIX_EXTATTR_CAP & caps) {
383 __u64 ExtAttrMask = 0;
384 rc = CIFSGetExtAttr(xid, tcon,
385 pSMBFile->fid.netfid,
386 &ExtAttrBits, &ExtAttrMask);
387 if (rc == 0)
388 rc = put_user(ExtAttrBits &
389 FS_FL_USER_VISIBLE,
390 (int __user *)arg);
391 if (rc != -EOPNOTSUPP)
392 break;
393 }
394#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
395#endif /* CONFIG_CIFS_POSIX */
396 rc = 0;
397 if (CIFS_I(inode)->cifsAttrs & ATTR_COMPRESSED) {
398 /* add in the compressed bit */
399 ExtAttrBits = FS_COMPR_FL;
400 rc = put_user(ExtAttrBits & FS_FL_USER_VISIBLE,
401 (int __user *)arg);
402 }
403 break;
404 case FS_IOC_SETFLAGS:
405 if (pSMBFile == NULL)
406 break;
407 tcon = tlink_tcon(pSMBFile->tlink);
408 /* caps = le64_to_cpu(tcon->fsUnixInfo.Capability); */
409
410 if (get_user(ExtAttrBits, (int __user *)arg)) {
411 rc = -EFAULT;
412 break;
413 }
414
415 /*
416 * if (CIFS_UNIX_EXTATTR_CAP & caps)
417 * rc = CIFSSetExtAttr(xid, tcon,
418 * pSMBFile->fid.netfid,
419 * extAttrBits,
420 * &ExtAttrMask);
421 * if (rc != -EOPNOTSUPP)
422 * break;
423 */
424
425 /* Currently only flag we can set is compressed flag */
426 if ((ExtAttrBits & FS_COMPR_FL) == 0)
427 break;
428
429 /* Try to set compress flag */
430 if (tcon->ses->server->ops->set_compression) {
431 rc = tcon->ses->server->ops->set_compression(
432 xid, tcon, pSMBFile);
433 cifs_dbg(FYI, "set compress flag rc %d\n", rc);
434 }
435 break;
436 case CIFS_IOC_COPYCHUNK_FILE:
437 rc = cifs_ioctl_copychunk(xid, filep, arg);
438 break;
439 case CIFS_QUERY_INFO:
440 rc = cifs_ioctl_query_info(xid, filep, arg);
441 break;
442 case CIFS_IOC_SET_INTEGRITY:
443 if (pSMBFile == NULL)
444 break;
445 tcon = tlink_tcon(pSMBFile->tlink);
446 if (tcon->ses->server->ops->set_integrity)
447 rc = tcon->ses->server->ops->set_integrity(xid,
448 tcon, pSMBFile);
449 else
450 rc = -EOPNOTSUPP;
451 break;
452 case CIFS_IOC_GET_MNT_INFO:
453 if (pSMBFile == NULL)
454 break;
455 tcon = tlink_tcon(pSMBFile->tlink);
456 rc = smb_mnt_get_fsinfo(xid, tcon, (void __user *)arg);
457 break;
458 case CIFS_IOC_GET_TCON_INFO:
459 cifs_sb = CIFS_SB(inode->i_sb);
460 tlink = cifs_sb_tlink(cifs_sb);
461 if (IS_ERR(tlink)) {
462 rc = PTR_ERR(tlink);
463 break;
464 }
465 tcon = tlink_tcon(tlink);
466 rc = smb_mnt_get_tcon_info(tcon, (void __user *)arg);
467 cifs_put_tlink(tlink);
468 break;
469 case CIFS_ENUMERATE_SNAPSHOTS:
470 if (pSMBFile == NULL)
471 break;
472 if (arg == 0) {
473 rc = -EINVAL;
474 goto cifs_ioc_exit;
475 }
476 tcon = tlink_tcon(pSMBFile->tlink);
477 if (tcon->ses->server->ops->enum_snapshots)
478 rc = tcon->ses->server->ops->enum_snapshots(xid, tcon,
479 pSMBFile, (void __user *)arg);
480 else
481 rc = -EOPNOTSUPP;
482 break;
483 case CIFS_DUMP_KEY:
484 /*
485 * Dump encryption keys. This is an old ioctl that only
486 * handles AES-128-{CCM,GCM}.
487 */
488 if (!capable(CAP_SYS_ADMIN)) {
489 rc = -EACCES;
490 break;
491 }
492
493 cifs_sb = CIFS_SB(inode->i_sb);
494 tlink = cifs_sb_tlink(cifs_sb);
495 if (IS_ERR(tlink)) {
496 rc = PTR_ERR(tlink);
497 break;
498 }
499 tcon = tlink_tcon(tlink);
500 if (!smb3_encryption_required(tcon)) {
501 rc = -EOPNOTSUPP;
502 cifs_put_tlink(tlink);
503 break;
504 }
505 pkey_inf.cipher_type =
506 le16_to_cpu(tcon->ses->server->cipher_type);
507 pkey_inf.Suid = tcon->ses->Suid;
508 memcpy(pkey_inf.auth_key, tcon->ses->auth_key.response,
509 16 /* SMB2_NTLMV2_SESSKEY_SIZE */);
510 memcpy(pkey_inf.smb3decryptionkey,
511 tcon->ses->smb3decryptionkey, SMB3_SIGN_KEY_SIZE);
512 memcpy(pkey_inf.smb3encryptionkey,
513 tcon->ses->smb3encryptionkey, SMB3_SIGN_KEY_SIZE);
514 if (copy_to_user((void __user *)arg, &pkey_inf,
515 sizeof(struct smb3_key_debug_info)))
516 rc = -EFAULT;
517 else
518 rc = 0;
519 cifs_put_tlink(tlink);
520 break;
521 case CIFS_DUMP_FULL_KEY:
522 /*
523 * Dump encryption keys (handles any key sizes)
524 */
525 if (pSMBFile == NULL)
526 break;
527 if (!capable(CAP_SYS_ADMIN)) {
528 rc = -EACCES;
529 break;
530 }
531 cifs_sb = CIFS_SB(inode->i_sb);
532 tlink = cifs_sb_tlink(cifs_sb);
533 if (IS_ERR(tlink)) {
534 rc = PTR_ERR(tlink);
535 break;
536 }
537
538 tcon = tlink_tcon(tlink);
539 rc = cifs_dump_full_key(tcon, (void __user *)arg);
540 cifs_put_tlink(tlink);
541 break;
542 case CIFS_IOC_NOTIFY:
543 if (!S_ISDIR(inode->i_mode)) {
544 /* Notify can only be done on directories */
545 rc = -EOPNOTSUPP;
546 break;
547 }
548 cifs_sb = CIFS_SB(inode->i_sb);
549 tlink = cifs_sb_tlink(cifs_sb);
550 if (IS_ERR(tlink)) {
551 rc = PTR_ERR(tlink);
552 break;
553 }
554 tcon = tlink_tcon(tlink);
555 if (tcon && tcon->ses->server->ops->notify) {
556 rc = tcon->ses->server->ops->notify(xid,
557 filep, (void __user *)arg,
558 false /* no ret data */);
559 cifs_dbg(FYI, "ioctl notify rc %d\n", rc);
560 } else
561 rc = -EOPNOTSUPP;
562 cifs_put_tlink(tlink);
563 break;
564 case CIFS_IOC_NOTIFY_INFO:
565 if (!S_ISDIR(inode->i_mode)) {
566 /* Notify can only be done on directories */
567 rc = -EOPNOTSUPP;
568 break;
569 }
570 cifs_sb = CIFS_SB(inode->i_sb);
571 tlink = cifs_sb_tlink(cifs_sb);
572 if (IS_ERR(tlink)) {
573 rc = PTR_ERR(tlink);
574 break;
575 }
576 tcon = tlink_tcon(tlink);
577 if (tcon && tcon->ses->server->ops->notify) {
578 rc = tcon->ses->server->ops->notify(xid,
579 filep, (void __user *)arg,
580 true /* return details */);
581 cifs_dbg(FYI, "ioctl notify info rc %d\n", rc);
582 } else
583 rc = -EOPNOTSUPP;
584 cifs_put_tlink(tlink);
585 break;
586 case CIFS_IOC_SHUTDOWN:
587 rc = cifs_shutdown(inode->i_sb, arg);
588 break;
589 default:
590 cifs_dbg(FYI, "unsupported ioctl\n");
591 break;
592 }
593cifs_ioc_exit:
594 free_xid(xid);
595 return rc;
596}
1// SPDX-License-Identifier: LGPL-2.1
2/*
3 *
4 * vfs operations that deal with io control
5 *
6 * Copyright (C) International Business Machines Corp., 2005,2013
7 * Author(s): Steve French (sfrench@us.ibm.com)
8 *
9 */
10
11#include <linux/fs.h>
12#include <linux/file.h>
13#include <linux/mount.h>
14#include <linux/mm.h>
15#include <linux/pagemap.h>
16#include "cifspdu.h"
17#include "cifsglob.h"
18#include "cifsproto.h"
19#include "cifs_debug.h"
20#include "cifsfs.h"
21#include "cifs_ioctl.h"
22#include "smb2proto.h"
23#include "smb2glob.h"
24#include <linux/btrfs.h>
25
26static long cifs_ioctl_query_info(unsigned int xid, struct file *filep,
27 unsigned long p)
28{
29 struct inode *inode = file_inode(filep);
30 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
31 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
32 struct dentry *dentry = filep->f_path.dentry;
33 const unsigned char *path;
34 void *page = alloc_dentry_path();
35 __le16 *utf16_path = NULL, root_path;
36 int rc = 0;
37
38 path = build_path_from_dentry(dentry, page);
39 if (IS_ERR(path)) {
40 free_dentry_path(page);
41 return PTR_ERR(path);
42 }
43
44 cifs_dbg(FYI, "%s %s\n", __func__, path);
45
46 if (!path[0]) {
47 root_path = 0;
48 utf16_path = &root_path;
49 } else {
50 utf16_path = cifs_convert_path_to_utf16(path + 1, cifs_sb);
51 if (!utf16_path) {
52 rc = -ENOMEM;
53 goto ici_exit;
54 }
55 }
56
57 if (tcon->ses->server->ops->ioctl_query_info)
58 rc = tcon->ses->server->ops->ioctl_query_info(
59 xid, tcon, cifs_sb, utf16_path,
60 filep->private_data ? 0 : 1, p);
61 else
62 rc = -EOPNOTSUPP;
63
64 ici_exit:
65 if (utf16_path != &root_path)
66 kfree(utf16_path);
67 free_dentry_path(page);
68 return rc;
69}
70
71static long cifs_ioctl_copychunk(unsigned int xid, struct file *dst_file,
72 unsigned long srcfd)
73{
74 int rc;
75 struct fd src_file;
76 struct inode *src_inode;
77
78 cifs_dbg(FYI, "ioctl copychunk range\n");
79 /* the destination must be opened for writing */
80 if (!(dst_file->f_mode & FMODE_WRITE)) {
81 cifs_dbg(FYI, "file target not open for write\n");
82 return -EINVAL;
83 }
84
85 /* check if target volume is readonly and take reference */
86 rc = mnt_want_write_file(dst_file);
87 if (rc) {
88 cifs_dbg(FYI, "mnt_want_write failed with rc %d\n", rc);
89 return rc;
90 }
91
92 src_file = fdget(srcfd);
93 if (!src_file.file) {
94 rc = -EBADF;
95 goto out_drop_write;
96 }
97
98 if (src_file.file->f_op->unlocked_ioctl != cifs_ioctl) {
99 rc = -EBADF;
100 cifs_dbg(VFS, "src file seems to be from a different filesystem type\n");
101 goto out_fput;
102 }
103
104 src_inode = file_inode(src_file.file);
105 rc = -EINVAL;
106 if (S_ISDIR(src_inode->i_mode))
107 goto out_fput;
108
109 rc = cifs_file_copychunk_range(xid, src_file.file, 0, dst_file, 0,
110 src_inode->i_size, 0);
111 if (rc > 0)
112 rc = 0;
113out_fput:
114 fdput(src_file);
115out_drop_write:
116 mnt_drop_write_file(dst_file);
117 return rc;
118}
119
120static long smb_mnt_get_tcon_info(struct cifs_tcon *tcon, void __user *arg)
121{
122 int rc = 0;
123 struct smb_mnt_tcon_info tcon_inf;
124
125 tcon_inf.tid = tcon->tid;
126 tcon_inf.session_id = tcon->ses->Suid;
127
128 if (copy_to_user(arg, &tcon_inf, sizeof(struct smb_mnt_tcon_info)))
129 rc = -EFAULT;
130
131 return rc;
132}
133
134static long smb_mnt_get_fsinfo(unsigned int xid, struct cifs_tcon *tcon,
135 void __user *arg)
136{
137 int rc = 0;
138 struct smb_mnt_fs_info *fsinf;
139
140 fsinf = kzalloc(sizeof(struct smb_mnt_fs_info), GFP_KERNEL);
141 if (fsinf == NULL)
142 return -ENOMEM;
143
144 fsinf->version = 1;
145 fsinf->protocol_id = tcon->ses->server->vals->protocol_id;
146 fsinf->tcon_flags = tcon->Flags;
147 fsinf->device_characteristics =
148 le32_to_cpu(tcon->fsDevInfo.DeviceCharacteristics);
149 fsinf->device_type = le32_to_cpu(tcon->fsDevInfo.DeviceType);
150 fsinf->fs_attributes = le32_to_cpu(tcon->fsAttrInfo.Attributes);
151 fsinf->max_path_component =
152 le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength);
153 fsinf->vol_serial_number = tcon->vol_serial_number;
154 fsinf->vol_create_time = le64_to_cpu(tcon->vol_create_time);
155 fsinf->share_flags = tcon->share_flags;
156 fsinf->share_caps = le32_to_cpu(tcon->capabilities);
157 fsinf->sector_flags = tcon->ss_flags;
158 fsinf->optimal_sector_size = tcon->perf_sector_size;
159 fsinf->max_bytes_chunk = tcon->max_bytes_chunk;
160 fsinf->maximal_access = tcon->maximal_access;
161 fsinf->cifs_posix_caps = le64_to_cpu(tcon->fsUnixInfo.Capability);
162
163 if (copy_to_user(arg, fsinf, sizeof(struct smb_mnt_fs_info)))
164 rc = -EFAULT;
165
166 kfree(fsinf);
167 return rc;
168}
169
170static int cifs_shutdown(struct super_block *sb, unsigned long arg)
171{
172 struct cifs_sb_info *sbi = CIFS_SB(sb);
173 __u32 flags;
174
175 if (!capable(CAP_SYS_ADMIN))
176 return -EPERM;
177
178 if (get_user(flags, (__u32 __user *)arg))
179 return -EFAULT;
180
181 if (flags > CIFS_GOING_FLAGS_NOLOGFLUSH)
182 return -EINVAL;
183
184 if (cifs_forced_shutdown(sbi))
185 return 0;
186
187 cifs_dbg(VFS, "shut down requested (%d)", flags);
188/* trace_cifs_shutdown(sb, flags);*/
189
190 /*
191 * see:
192 * https://man7.org/linux/man-pages/man2/ioctl_xfs_goingdown.2.html
193 * for more information and description of original intent of the flags
194 */
195 switch (flags) {
196 /*
197 * We could add support later for default flag which requires:
198 * "Flush all dirty data and metadata to disk"
199 * would need to call syncfs or equivalent to flush page cache for
200 * the mount and then issue fsync to server (if nostrictsync not set)
201 */
202 case CIFS_GOING_FLAGS_DEFAULT:
203 cifs_dbg(FYI, "shutdown with default flag not supported\n");
204 return -EINVAL;
205 /*
206 * FLAGS_LOGFLUSH is easy since it asks to write out metadata (not
207 * data) but metadata writes are not cached on the client, so can treat
208 * it similarly to NOLOGFLUSH
209 */
210 case CIFS_GOING_FLAGS_LOGFLUSH:
211 case CIFS_GOING_FLAGS_NOLOGFLUSH:
212 sbi->mnt_cifs_flags |= CIFS_MOUNT_SHUTDOWN;
213 return 0;
214 default:
215 return -EINVAL;
216 }
217 return 0;
218}
219
220static int cifs_dump_full_key(struct cifs_tcon *tcon, struct smb3_full_key_debug_info __user *in)
221{
222 struct smb3_full_key_debug_info out;
223 struct cifs_ses *ses;
224 int rc = 0;
225 bool found = false;
226 u8 __user *end;
227
228 if (!smb3_encryption_required(tcon)) {
229 rc = -EOPNOTSUPP;
230 goto out;
231 }
232
233 /* copy user input into our output buffer */
234 if (copy_from_user(&out, in, sizeof(out))) {
235 rc = -EINVAL;
236 goto out;
237 }
238
239 if (!out.session_id) {
240 /* if ses id is 0, use current user session */
241 ses = tcon->ses;
242 } else {
243 /* otherwise if a session id is given, look for it in all our sessions */
244 struct cifs_ses *ses_it = NULL;
245 struct TCP_Server_Info *server_it = NULL;
246
247 spin_lock(&cifs_tcp_ses_lock);
248 list_for_each_entry(server_it, &cifs_tcp_ses_list, tcp_ses_list) {
249 list_for_each_entry(ses_it, &server_it->smb_ses_list, smb_ses_list) {
250 if (ses_it->Suid == out.session_id) {
251 ses = ses_it;
252 /*
253 * since we are using the session outside the crit
254 * section, we need to make sure it won't be released
255 * so increment its refcount
256 */
257 cifs_smb_ses_inc_refcount(ses);
258 found = true;
259 goto search_end;
260 }
261 }
262 }
263search_end:
264 spin_unlock(&cifs_tcp_ses_lock);
265 if (!found) {
266 rc = -ENOENT;
267 goto out;
268 }
269 }
270
271 switch (ses->server->cipher_type) {
272 case SMB2_ENCRYPTION_AES128_CCM:
273 case SMB2_ENCRYPTION_AES128_GCM:
274 out.session_key_length = CIFS_SESS_KEY_SIZE;
275 out.server_in_key_length = out.server_out_key_length = SMB3_GCM128_CRYPTKEY_SIZE;
276 break;
277 case SMB2_ENCRYPTION_AES256_CCM:
278 case SMB2_ENCRYPTION_AES256_GCM:
279 out.session_key_length = CIFS_SESS_KEY_SIZE;
280 out.server_in_key_length = out.server_out_key_length = SMB3_GCM256_CRYPTKEY_SIZE;
281 break;
282 default:
283 rc = -EOPNOTSUPP;
284 goto out;
285 }
286
287 /* check if user buffer is big enough to store all the keys */
288 if (out.in_size < sizeof(out) + out.session_key_length + out.server_in_key_length
289 + out.server_out_key_length) {
290 rc = -ENOBUFS;
291 goto out;
292 }
293
294 out.session_id = ses->Suid;
295 out.cipher_type = le16_to_cpu(ses->server->cipher_type);
296
297 /* overwrite user input with our output */
298 if (copy_to_user(in, &out, sizeof(out))) {
299 rc = -EINVAL;
300 goto out;
301 }
302
303 /* append all the keys at the end of the user buffer */
304 end = in->data;
305 if (copy_to_user(end, ses->auth_key.response, out.session_key_length)) {
306 rc = -EINVAL;
307 goto out;
308 }
309 end += out.session_key_length;
310
311 if (copy_to_user(end, ses->smb3encryptionkey, out.server_in_key_length)) {
312 rc = -EINVAL;
313 goto out;
314 }
315 end += out.server_in_key_length;
316
317 if (copy_to_user(end, ses->smb3decryptionkey, out.server_out_key_length)) {
318 rc = -EINVAL;
319 goto out;
320 }
321
322out:
323 if (found)
324 cifs_put_smb_ses(ses);
325 return rc;
326}
327
328long cifs_ioctl(struct file *filep, unsigned int command, unsigned long arg)
329{
330 struct inode *inode = file_inode(filep);
331 struct smb3_key_debug_info pkey_inf;
332 int rc = -ENOTTY; /* strange error - but the precedent */
333 unsigned int xid;
334 struct cifsFileInfo *pSMBFile = filep->private_data;
335 struct cifs_tcon *tcon;
336 struct tcon_link *tlink;
337 struct cifs_sb_info *cifs_sb;
338 __u64 ExtAttrBits = 0;
339#ifdef CONFIG_CIFS_POSIX
340#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
341 __u64 caps;
342#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
343#endif /* CONFIG_CIFS_POSIX */
344
345 xid = get_xid();
346
347 cifs_dbg(FYI, "cifs ioctl 0x%x\n", command);
348 switch (command) {
349 case FS_IOC_GETFLAGS:
350 if (pSMBFile == NULL)
351 break;
352 tcon = tlink_tcon(pSMBFile->tlink);
353#ifdef CONFIG_CIFS_POSIX
354#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
355 caps = le64_to_cpu(tcon->fsUnixInfo.Capability);
356 if (CIFS_UNIX_EXTATTR_CAP & caps) {
357 __u64 ExtAttrMask = 0;
358 rc = CIFSGetExtAttr(xid, tcon,
359 pSMBFile->fid.netfid,
360 &ExtAttrBits, &ExtAttrMask);
361 if (rc == 0)
362 rc = put_user(ExtAttrBits &
363 FS_FL_USER_VISIBLE,
364 (int __user *)arg);
365 if (rc != -EOPNOTSUPP)
366 break;
367 }
368#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
369#endif /* CONFIG_CIFS_POSIX */
370 rc = 0;
371 if (CIFS_I(inode)->cifsAttrs & ATTR_COMPRESSED) {
372 /* add in the compressed bit */
373 ExtAttrBits = FS_COMPR_FL;
374 rc = put_user(ExtAttrBits & FS_FL_USER_VISIBLE,
375 (int __user *)arg);
376 }
377 break;
378 case FS_IOC_SETFLAGS:
379 if (pSMBFile == NULL)
380 break;
381 tcon = tlink_tcon(pSMBFile->tlink);
382 /* caps = le64_to_cpu(tcon->fsUnixInfo.Capability); */
383
384 if (get_user(ExtAttrBits, (int __user *)arg)) {
385 rc = -EFAULT;
386 break;
387 }
388
389 /*
390 * if (CIFS_UNIX_EXTATTR_CAP & caps)
391 * rc = CIFSSetExtAttr(xid, tcon,
392 * pSMBFile->fid.netfid,
393 * extAttrBits,
394 * &ExtAttrMask);
395 * if (rc != -EOPNOTSUPP)
396 * break;
397 */
398
399 /* Currently only flag we can set is compressed flag */
400 if ((ExtAttrBits & FS_COMPR_FL) == 0)
401 break;
402
403 /* Try to set compress flag */
404 if (tcon->ses->server->ops->set_compression) {
405 rc = tcon->ses->server->ops->set_compression(
406 xid, tcon, pSMBFile);
407 cifs_dbg(FYI, "set compress flag rc %d\n", rc);
408 }
409 break;
410 case CIFS_IOC_COPYCHUNK_FILE:
411 rc = cifs_ioctl_copychunk(xid, filep, arg);
412 break;
413 case CIFS_QUERY_INFO:
414 rc = cifs_ioctl_query_info(xid, filep, arg);
415 break;
416 case CIFS_IOC_SET_INTEGRITY:
417 if (pSMBFile == NULL)
418 break;
419 tcon = tlink_tcon(pSMBFile->tlink);
420 if (tcon->ses->server->ops->set_integrity)
421 rc = tcon->ses->server->ops->set_integrity(xid,
422 tcon, pSMBFile);
423 else
424 rc = -EOPNOTSUPP;
425 break;
426 case CIFS_IOC_GET_MNT_INFO:
427 if (pSMBFile == NULL)
428 break;
429 tcon = tlink_tcon(pSMBFile->tlink);
430 rc = smb_mnt_get_fsinfo(xid, tcon, (void __user *)arg);
431 break;
432 case CIFS_IOC_GET_TCON_INFO:
433 cifs_sb = CIFS_SB(inode->i_sb);
434 tlink = cifs_sb_tlink(cifs_sb);
435 if (IS_ERR(tlink)) {
436 rc = PTR_ERR(tlink);
437 break;
438 }
439 tcon = tlink_tcon(tlink);
440 rc = smb_mnt_get_tcon_info(tcon, (void __user *)arg);
441 cifs_put_tlink(tlink);
442 break;
443 case CIFS_ENUMERATE_SNAPSHOTS:
444 if (pSMBFile == NULL)
445 break;
446 if (arg == 0) {
447 rc = -EINVAL;
448 goto cifs_ioc_exit;
449 }
450 tcon = tlink_tcon(pSMBFile->tlink);
451 if (tcon->ses->server->ops->enum_snapshots)
452 rc = tcon->ses->server->ops->enum_snapshots(xid, tcon,
453 pSMBFile, (void __user *)arg);
454 else
455 rc = -EOPNOTSUPP;
456 break;
457 case CIFS_DUMP_KEY:
458 /*
459 * Dump encryption keys. This is an old ioctl that only
460 * handles AES-128-{CCM,GCM}.
461 */
462 if (!capable(CAP_SYS_ADMIN)) {
463 rc = -EACCES;
464 break;
465 }
466
467 cifs_sb = CIFS_SB(inode->i_sb);
468 tlink = cifs_sb_tlink(cifs_sb);
469 if (IS_ERR(tlink)) {
470 rc = PTR_ERR(tlink);
471 break;
472 }
473 tcon = tlink_tcon(tlink);
474 if (!smb3_encryption_required(tcon)) {
475 rc = -EOPNOTSUPP;
476 cifs_put_tlink(tlink);
477 break;
478 }
479 pkey_inf.cipher_type =
480 le16_to_cpu(tcon->ses->server->cipher_type);
481 pkey_inf.Suid = tcon->ses->Suid;
482 memcpy(pkey_inf.auth_key, tcon->ses->auth_key.response,
483 16 /* SMB2_NTLMV2_SESSKEY_SIZE */);
484 memcpy(pkey_inf.smb3decryptionkey,
485 tcon->ses->smb3decryptionkey, SMB3_SIGN_KEY_SIZE);
486 memcpy(pkey_inf.smb3encryptionkey,
487 tcon->ses->smb3encryptionkey, SMB3_SIGN_KEY_SIZE);
488 if (copy_to_user((void __user *)arg, &pkey_inf,
489 sizeof(struct smb3_key_debug_info)))
490 rc = -EFAULT;
491 else
492 rc = 0;
493 cifs_put_tlink(tlink);
494 break;
495 case CIFS_DUMP_FULL_KEY:
496 /*
497 * Dump encryption keys (handles any key sizes)
498 */
499 if (pSMBFile == NULL)
500 break;
501 if (!capable(CAP_SYS_ADMIN)) {
502 rc = -EACCES;
503 break;
504 }
505 cifs_sb = CIFS_SB(inode->i_sb);
506 tlink = cifs_sb_tlink(cifs_sb);
507 if (IS_ERR(tlink)) {
508 rc = PTR_ERR(tlink);
509 break;
510 }
511
512 tcon = tlink_tcon(tlink);
513 rc = cifs_dump_full_key(tcon, (void __user *)arg);
514 cifs_put_tlink(tlink);
515 break;
516 case CIFS_IOC_NOTIFY:
517 if (!S_ISDIR(inode->i_mode)) {
518 /* Notify can only be done on directories */
519 rc = -EOPNOTSUPP;
520 break;
521 }
522 cifs_sb = CIFS_SB(inode->i_sb);
523 tlink = cifs_sb_tlink(cifs_sb);
524 if (IS_ERR(tlink)) {
525 rc = PTR_ERR(tlink);
526 break;
527 }
528 tcon = tlink_tcon(tlink);
529 if (tcon && tcon->ses->server->ops->notify) {
530 rc = tcon->ses->server->ops->notify(xid,
531 filep, (void __user *)arg,
532 false /* no ret data */);
533 cifs_dbg(FYI, "ioctl notify rc %d\n", rc);
534 } else
535 rc = -EOPNOTSUPP;
536 cifs_put_tlink(tlink);
537 break;
538 case CIFS_IOC_NOTIFY_INFO:
539 if (!S_ISDIR(inode->i_mode)) {
540 /* Notify can only be done on directories */
541 rc = -EOPNOTSUPP;
542 break;
543 }
544 cifs_sb = CIFS_SB(inode->i_sb);
545 tlink = cifs_sb_tlink(cifs_sb);
546 if (IS_ERR(tlink)) {
547 rc = PTR_ERR(tlink);
548 break;
549 }
550 tcon = tlink_tcon(tlink);
551 if (tcon && tcon->ses->server->ops->notify) {
552 rc = tcon->ses->server->ops->notify(xid,
553 filep, (void __user *)arg,
554 true /* return details */);
555 cifs_dbg(FYI, "ioctl notify info rc %d\n", rc);
556 } else
557 rc = -EOPNOTSUPP;
558 cifs_put_tlink(tlink);
559 break;
560 case CIFS_IOC_SHUTDOWN:
561 rc = cifs_shutdown(inode->i_sb, arg);
562 break;
563 default:
564 cifs_dbg(FYI, "unsupported ioctl\n");
565 break;
566 }
567cifs_ioc_exit:
568 free_xid(xid);
569 return rc;
570}