Loading...
Note: File does not exist in v4.17.
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}