Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * fs/cifs/ioctl.c |
| 3 | * |
| 4 | * vfs operations that deal with io control |
| 5 | * |
Steve French | 64a5cfa | 2013-10-14 15:31:32 -0500 | [diff] [blame] | 6 | * Copyright (C) International Business Machines Corp., 2005,2013 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 7 | * Author(s): Steve French (sfrench@us.ibm.com) |
| 8 | * |
| 9 | * This library is free software; you can redistribute it and/or modify |
| 10 | * it under the terms of the GNU Lesser General Public License as published |
| 11 | * by the Free Software Foundation; either version 2.1 of the License, or |
| 12 | * (at your option) any later version. |
| 13 | * |
| 14 | * This library is distributed in the hope that it will be useful, |
| 15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See |
| 17 | * the GNU Lesser General Public License for more details. |
| 18 | * |
| 19 | * You should have received a copy of the GNU Lesser General Public License |
| 20 | * along with this library; if not, write to the Free Software |
| 21 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 22 | */ |
Steve French | f654bac | 2005-04-28 22:41:04 -0700 | [diff] [blame] | 23 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 24 | #include <linux/fs.h> |
Steve French | 41c1358 | 2013-11-14 00:05:36 -0600 | [diff] [blame] | 25 | #include <linux/file.h> |
| 26 | #include <linux/mount.h> |
| 27 | #include <linux/mm.h> |
| 28 | #include <linux/pagemap.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 29 | #include "cifspdu.h" |
| 30 | #include "cifsglob.h" |
| 31 | #include "cifsproto.h" |
| 32 | #include "cifs_debug.h" |
Steve French | c67593a | 2005-04-28 22:41:04 -0700 | [diff] [blame] | 33 | #include "cifsfs.h" |
Steve French | 0de1f4c | 2015-07-04 18:40:10 -0500 | [diff] [blame] | 34 | #include "cifs_ioctl.h" |
Ronnie Sahlberg | 8d8b26e | 2018-10-17 05:47:58 +1000 | [diff] [blame] | 35 | #include "smb2proto.h" |
Steve French | 02b1666 | 2015-06-27 21:18:36 -0700 | [diff] [blame] | 36 | #include <linux/btrfs.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 37 | |
Ronnie Sahlberg | f5b05d6 | 2018-10-07 19:19:58 -0500 | [diff] [blame] | 38 | static long cifs_ioctl_query_info(unsigned int xid, struct file *filep, |
| 39 | unsigned long p) |
| 40 | { |
Ronnie Sahlberg | 8d8b26e | 2018-10-17 05:47:58 +1000 | [diff] [blame] | 41 | struct inode *inode = file_inode(filep); |
| 42 | struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); |
| 43 | struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb); |
| 44 | struct dentry *dentry = filep->f_path.dentry; |
| 45 | unsigned char *path; |
| 46 | __le16 *utf16_path = NULL, root_path; |
| 47 | int rc = 0; |
Ronnie Sahlberg | f5b05d6 | 2018-10-07 19:19:58 -0500 | [diff] [blame] | 48 | |
Ronnie Sahlberg | 8d8b26e | 2018-10-17 05:47:58 +1000 | [diff] [blame] | 49 | path = build_path_from_dentry(dentry); |
| 50 | if (path == NULL) |
| 51 | return -ENOMEM; |
| 52 | |
| 53 | cifs_dbg(FYI, "%s %s\n", __func__, path); |
| 54 | |
| 55 | if (!path[0]) { |
| 56 | root_path = 0; |
| 57 | utf16_path = &root_path; |
| 58 | } else { |
| 59 | utf16_path = cifs_convert_path_to_utf16(path + 1, cifs_sb); |
| 60 | if (!utf16_path) { |
| 61 | rc = -ENOMEM; |
| 62 | goto ici_exit; |
| 63 | } |
| 64 | } |
Ronnie Sahlberg | f5b05d6 | 2018-10-07 19:19:58 -0500 | [diff] [blame] | 65 | |
| 66 | if (tcon->ses->server->ops->ioctl_query_info) |
Ronnie Sahlberg | 8d8b26e | 2018-10-17 05:47:58 +1000 | [diff] [blame] | 67 | rc = tcon->ses->server->ops->ioctl_query_info( |
| 68 | xid, tcon, utf16_path, |
| 69 | filep->private_data ? 0 : 1, p); |
Ronnie Sahlberg | f5b05d6 | 2018-10-07 19:19:58 -0500 | [diff] [blame] | 70 | else |
Ronnie Sahlberg | 8d8b26e | 2018-10-17 05:47:58 +1000 | [diff] [blame] | 71 | rc = -EOPNOTSUPP; |
| 72 | |
| 73 | ici_exit: |
| 74 | if (utf16_path != &root_path) |
| 75 | kfree(utf16_path); |
| 76 | kfree(path); |
| 77 | return rc; |
Ronnie Sahlberg | f5b05d6 | 2018-10-07 19:19:58 -0500 | [diff] [blame] | 78 | } |
| 79 | |
Sachin Prabhu | 312bbc5 | 2017-04-04 02:12:04 -0500 | [diff] [blame] | 80 | static long cifs_ioctl_copychunk(unsigned int xid, struct file *dst_file, |
Christoph Hellwig | 04b38d6 | 2015-12-03 12:59:50 +0100 | [diff] [blame] | 81 | unsigned long srcfd) |
Steve French | 41c1358 | 2013-11-14 00:05:36 -0600 | [diff] [blame] | 82 | { |
| 83 | int rc; |
Steve French | 41c1358 | 2013-11-14 00:05:36 -0600 | [diff] [blame] | 84 | struct fd src_file; |
Steve French | 41c1358 | 2013-11-14 00:05:36 -0600 | [diff] [blame] | 85 | struct inode *src_inode; |
Steve French | 41c1358 | 2013-11-14 00:05:36 -0600 | [diff] [blame] | 86 | |
Sachin Prabhu | 312bbc5 | 2017-04-04 02:12:04 -0500 | [diff] [blame] | 87 | cifs_dbg(FYI, "ioctl copychunk range\n"); |
Steve French | 41c1358 | 2013-11-14 00:05:36 -0600 | [diff] [blame] | 88 | /* the destination must be opened for writing */ |
| 89 | if (!(dst_file->f_mode & FMODE_WRITE)) { |
| 90 | cifs_dbg(FYI, "file target not open for write\n"); |
| 91 | return -EINVAL; |
| 92 | } |
| 93 | |
| 94 | /* check if target volume is readonly and take reference */ |
| 95 | rc = mnt_want_write_file(dst_file); |
| 96 | if (rc) { |
| 97 | cifs_dbg(FYI, "mnt_want_write failed with rc %d\n", rc); |
| 98 | return rc; |
| 99 | } |
| 100 | |
| 101 | src_file = fdget(srcfd); |
| 102 | if (!src_file.file) { |
| 103 | rc = -EBADF; |
| 104 | goto out_drop_write; |
| 105 | } |
| 106 | |
Jann Horn | 4c17a6d | 2015-09-11 16:27:27 +0200 | [diff] [blame] | 107 | if (src_file.file->f_op->unlocked_ioctl != cifs_ioctl) { |
| 108 | rc = -EBADF; |
| 109 | cifs_dbg(VFS, "src file seems to be from a different filesystem type\n"); |
| 110 | goto out_fput; |
| 111 | } |
| 112 | |
Libo Chen | 2d4f84b | 2013-12-11 11:02:27 +0800 | [diff] [blame] | 113 | src_inode = file_inode(src_file.file); |
Al Viro | 378ff1a | 2015-01-18 23:37:32 -0500 | [diff] [blame] | 114 | rc = -EINVAL; |
| 115 | if (S_ISDIR(src_inode->i_mode)) |
| 116 | goto out_fput; |
Steve French | 41c1358 | 2013-11-14 00:05:36 -0600 | [diff] [blame] | 117 | |
Sachin Prabhu | 620d874 | 2017-02-10 16:03:51 +0530 | [diff] [blame] | 118 | rc = cifs_file_copychunk_range(xid, src_file.file, 0, dst_file, 0, |
| 119 | src_inode->i_size, 0); |
Sachin Prabhu | 7d0c234 | 2017-04-26 17:10:17 +0100 | [diff] [blame] | 120 | if (rc > 0) |
| 121 | rc = 0; |
Steve French | 41c1358 | 2013-11-14 00:05:36 -0600 | [diff] [blame] | 122 | out_fput: |
| 123 | fdput(src_file); |
| 124 | out_drop_write: |
| 125 | mnt_drop_write_file(dst_file); |
| 126 | return rc; |
| 127 | } |
| 128 | |
Steve French | 0de1f4c | 2015-07-04 18:40:10 -0500 | [diff] [blame] | 129 | static long smb_mnt_get_fsinfo(unsigned int xid, struct cifs_tcon *tcon, |
| 130 | void __user *arg) |
| 131 | { |
| 132 | int rc = 0; |
| 133 | struct smb_mnt_fs_info *fsinf; |
| 134 | |
| 135 | fsinf = kzalloc(sizeof(struct smb_mnt_fs_info), GFP_KERNEL); |
| 136 | if (fsinf == NULL) |
| 137 | return -ENOMEM; |
| 138 | |
| 139 | fsinf->version = 1; |
| 140 | fsinf->protocol_id = tcon->ses->server->vals->protocol_id; |
| 141 | fsinf->device_characteristics = |
| 142 | le32_to_cpu(tcon->fsDevInfo.DeviceCharacteristics); |
| 143 | fsinf->device_type = le32_to_cpu(tcon->fsDevInfo.DeviceType); |
| 144 | fsinf->fs_attributes = le32_to_cpu(tcon->fsAttrInfo.Attributes); |
| 145 | fsinf->max_path_component = |
| 146 | le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength); |
Steve French | 0de1f4c | 2015-07-04 18:40:10 -0500 | [diff] [blame] | 147 | fsinf->vol_serial_number = tcon->vol_serial_number; |
| 148 | fsinf->vol_create_time = le64_to_cpu(tcon->vol_create_time); |
| 149 | fsinf->share_flags = tcon->share_flags; |
| 150 | fsinf->share_caps = le32_to_cpu(tcon->capabilities); |
| 151 | fsinf->sector_flags = tcon->ss_flags; |
| 152 | fsinf->optimal_sector_size = tcon->perf_sector_size; |
| 153 | fsinf->max_bytes_chunk = tcon->max_bytes_chunk; |
| 154 | fsinf->maximal_access = tcon->maximal_access; |
Steve French | 0de1f4c | 2015-07-04 18:40:10 -0500 | [diff] [blame] | 155 | fsinf->cifs_posix_caps = le64_to_cpu(tcon->fsUnixInfo.Capability); |
| 156 | |
| 157 | if (copy_to_user(arg, fsinf, sizeof(struct smb_mnt_fs_info))) |
| 158 | rc = -EFAULT; |
| 159 | |
| 160 | kfree(fsinf); |
| 161 | return rc; |
| 162 | } |
| 163 | |
Steve French | f9ddcca | 2008-05-15 05:51:55 +0000 | [diff] [blame] | 164 | long cifs_ioctl(struct file *filep, unsigned int command, unsigned long arg) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 165 | { |
Al Viro | 496ad9a | 2013-01-23 17:07:38 -0500 | [diff] [blame] | 166 | struct inode *inode = file_inode(filep); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 167 | int rc = -ENOTTY; /* strange error - but the precedent */ |
Pavel Shilovsky | 6d5786a | 2012-06-20 11:21:16 +0400 | [diff] [blame] | 168 | unsigned int xid; |
Jeff Layton | ba00ba64 | 2010-09-20 16:01:31 -0700 | [diff] [blame] | 169 | struct cifsFileInfo *pSMBFile = filep->private_data; |
Steve French | 96daf2b | 2011-05-27 04:34:02 +0000 | [diff] [blame] | 170 | struct cifs_tcon *tcon; |
Steve French | f654bac | 2005-04-28 22:41:04 -0700 | [diff] [blame] | 171 | __u64 ExtAttrBits = 0; |
Jeff Layton | 6187639 | 2010-11-08 07:28:32 -0500 | [diff] [blame] | 172 | __u64 caps; |
Steve French | f654bac | 2005-04-28 22:41:04 -0700 | [diff] [blame] | 173 | |
Pavel Shilovsky | 6d5786a | 2012-06-20 11:21:16 +0400 | [diff] [blame] | 174 | xid = get_xid(); |
Steve French | f654bac | 2005-04-28 22:41:04 -0700 | [diff] [blame] | 175 | |
Pavel Shilovsky | b0a752b | 2016-11-16 15:17:15 -0800 | [diff] [blame] | 176 | cifs_dbg(FYI, "cifs ioctl 0x%x\n", command); |
Steve French | 5fdae1f | 2007-06-05 18:30:44 +0000 | [diff] [blame] | 177 | switch (command) { |
David Howells | 3669567 | 2006-08-29 19:06:16 +0100 | [diff] [blame] | 178 | case FS_IOC_GETFLAGS: |
Jeff Layton | 6187639 | 2010-11-08 07:28:32 -0500 | [diff] [blame] | 179 | if (pSMBFile == NULL) |
| 180 | break; |
| 181 | tcon = tlink_tcon(pSMBFile->tlink); |
| 182 | caps = le64_to_cpu(tcon->fsUnixInfo.Capability); |
Steve French | 64a5cfa | 2013-10-14 15:31:32 -0500 | [diff] [blame] | 183 | #ifdef CONFIG_CIFS_POSIX |
Steve French | 5fdae1f | 2007-06-05 18:30:44 +0000 | [diff] [blame] | 184 | if (CIFS_UNIX_EXTATTR_CAP & caps) { |
Steve French | f10d9ba | 2013-10-13 22:32:30 -0500 | [diff] [blame] | 185 | __u64 ExtAttrMask = 0; |
Pavel Shilovsky | 4b4de76 | 2012-09-18 16:20:26 -0700 | [diff] [blame] | 186 | rc = CIFSGetExtAttr(xid, tcon, |
| 187 | pSMBFile->fid.netfid, |
| 188 | &ExtAttrBits, &ExtAttrMask); |
Steve French | 5fdae1f | 2007-06-05 18:30:44 +0000 | [diff] [blame] | 189 | if (rc == 0) |
Steve French | f654bac | 2005-04-28 22:41:04 -0700 | [diff] [blame] | 190 | rc = put_user(ExtAttrBits & |
David Howells | 3669567 | 2006-08-29 19:06:16 +0100 | [diff] [blame] | 191 | FS_FL_USER_VISIBLE, |
Steve French | f654bac | 2005-04-28 22:41:04 -0700 | [diff] [blame] | 192 | (int __user *)arg); |
Steve French | 64a5cfa | 2013-10-14 15:31:32 -0500 | [diff] [blame] | 193 | if (rc != EOPNOTSUPP) |
| 194 | break; |
| 195 | } |
| 196 | #endif /* CONFIG_CIFS_POSIX */ |
| 197 | rc = 0; |
| 198 | if (CIFS_I(inode)->cifsAttrs & ATTR_COMPRESSED) { |
| 199 | /* add in the compressed bit */ |
| 200 | ExtAttrBits = FS_COMPR_FL; |
| 201 | rc = put_user(ExtAttrBits & FS_FL_USER_VISIBLE, |
| 202 | (int __user *)arg); |
Steve French | f654bac | 2005-04-28 22:41:04 -0700 | [diff] [blame] | 203 | } |
| 204 | break; |
David Howells | 3669567 | 2006-08-29 19:06:16 +0100 | [diff] [blame] | 205 | case FS_IOC_SETFLAGS: |
Jeff Layton | 6187639 | 2010-11-08 07:28:32 -0500 | [diff] [blame] | 206 | if (pSMBFile == NULL) |
| 207 | break; |
| 208 | tcon = tlink_tcon(pSMBFile->tlink); |
| 209 | caps = le64_to_cpu(tcon->fsUnixInfo.Capability); |
Steve French | 64a5cfa | 2013-10-14 15:31:32 -0500 | [diff] [blame] | 210 | |
| 211 | if (get_user(ExtAttrBits, (int __user *)arg)) { |
| 212 | rc = -EFAULT; |
| 213 | break; |
Steve French | f654bac | 2005-04-28 22:41:04 -0700 | [diff] [blame] | 214 | } |
Steve French | 64a5cfa | 2013-10-14 15:31:32 -0500 | [diff] [blame] | 215 | |
| 216 | /* |
| 217 | * if (CIFS_UNIX_EXTATTR_CAP & caps) |
| 218 | * rc = CIFSSetExtAttr(xid, tcon, |
| 219 | * pSMBFile->fid.netfid, |
| 220 | * extAttrBits, |
| 221 | * &ExtAttrMask); |
| 222 | * if (rc != EOPNOTSUPP) |
| 223 | * break; |
| 224 | */ |
| 225 | |
| 226 | /* Currently only flag we can set is compressed flag */ |
| 227 | if ((ExtAttrBits & FS_COMPR_FL) == 0) |
| 228 | break; |
| 229 | |
| 230 | /* Try to set compress flag */ |
| 231 | if (tcon->ses->server->ops->set_compression) { |
| 232 | rc = tcon->ses->server->ops->set_compression( |
| 233 | xid, tcon, pSMBFile); |
| 234 | cifs_dbg(FYI, "set compress flag rc %d\n", rc); |
| 235 | } |
Steve French | f654bac | 2005-04-28 22:41:04 -0700 | [diff] [blame] | 236 | break; |
Steve French | f19e84d | 2013-11-24 21:53:17 -0600 | [diff] [blame] | 237 | case CIFS_IOC_COPYCHUNK_FILE: |
Sachin Prabhu | 312bbc5 | 2017-04-04 02:12:04 -0500 | [diff] [blame] | 238 | rc = cifs_ioctl_copychunk(xid, filep, arg); |
Steve French | 41c1358 | 2013-11-14 00:05:36 -0600 | [diff] [blame] | 239 | break; |
Ronnie Sahlberg | f5b05d6 | 2018-10-07 19:19:58 -0500 | [diff] [blame] | 240 | case CIFS_QUERY_INFO: |
| 241 | rc = cifs_ioctl_query_info(xid, filep, arg); |
| 242 | break; |
Steve French | b3152e2 | 2015-06-24 03:17:02 -0500 | [diff] [blame] | 243 | case CIFS_IOC_SET_INTEGRITY: |
| 244 | if (pSMBFile == NULL) |
| 245 | break; |
| 246 | tcon = tlink_tcon(pSMBFile->tlink); |
| 247 | if (tcon->ses->server->ops->set_integrity) |
| 248 | rc = tcon->ses->server->ops->set_integrity(xid, |
| 249 | tcon, pSMBFile); |
| 250 | else |
| 251 | rc = -EOPNOTSUPP; |
| 252 | break; |
Steve French | 0de1f4c | 2015-07-04 18:40:10 -0500 | [diff] [blame] | 253 | case CIFS_IOC_GET_MNT_INFO: |
David Disseldorp | d8a6e50 | 2017-05-04 00:41:13 +0200 | [diff] [blame] | 254 | if (pSMBFile == NULL) |
| 255 | break; |
Steve French | 0de1f4c | 2015-07-04 18:40:10 -0500 | [diff] [blame] | 256 | tcon = tlink_tcon(pSMBFile->tlink); |
| 257 | rc = smb_mnt_get_fsinfo(xid, tcon, (void __user *)arg); |
| 258 | break; |
Steve French | 834170c | 2016-09-30 21:14:26 -0500 | [diff] [blame] | 259 | case CIFS_ENUMERATE_SNAPSHOTS: |
David Disseldorp | 6026685d | 2017-05-03 17:39:08 +0200 | [diff] [blame] | 260 | if (pSMBFile == NULL) |
| 261 | break; |
Steve French | 834170c | 2016-09-30 21:14:26 -0500 | [diff] [blame] | 262 | if (arg == 0) { |
| 263 | rc = -EINVAL; |
| 264 | goto cifs_ioc_exit; |
| 265 | } |
| 266 | tcon = tlink_tcon(pSMBFile->tlink); |
| 267 | if (tcon->ses->server->ops->enum_snapshots) |
| 268 | rc = tcon->ses->server->ops->enum_snapshots(xid, tcon, |
| 269 | pSMBFile, (void __user *)arg); |
| 270 | else |
| 271 | rc = -EOPNOTSUPP; |
| 272 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 273 | default: |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 274 | cifs_dbg(FYI, "unsupported ioctl\n"); |
Steve French | f28ac91 | 2005-04-28 22:41:07 -0700 | [diff] [blame] | 275 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 276 | } |
Steve French | 834170c | 2016-09-30 21:14:26 -0500 | [diff] [blame] | 277 | cifs_ioc_exit: |
Pavel Shilovsky | 6d5786a | 2012-06-20 11:21:16 +0400 | [diff] [blame] | 278 | free_xid(xid); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 279 | return rc; |
Steve French | 5fdae1f | 2007-06-05 18:30:44 +0000 | [diff] [blame] | 280 | } |