1/* 2 * fs/cifs/ioctl.c 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 * 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 */ 23 24#include <linux/fs.h> 25#include <linux/file.h> 26#include <linux/mount.h> 27#include <linux/mm.h> 28#include <linux/pagemap.h> 29#include "cifspdu.h" 30#include "cifsglob.h" 31#include "cifsproto.h" 32#include "cifs_debug.h" 33#include "cifsfs.h" 34#include "cifs_ioctl.h" 35#include "smb2proto.h" 36#include <linux/btrfs.h> 37 38static long cifs_ioctl_query_info(unsigned int xid, struct file *filep, 39 unsigned long p) 40{ 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; 48 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 } 65 66 if (tcon->ses->server->ops->ioctl_query_info) 67 rc = tcon->ses->server->ops->ioctl_query_info( 68 xid, tcon, cifs_sb, utf16_path, 69 filep->private_data ? 0 : 1, p); 70 else 71 rc = -EOPNOTSUPP; 72 73 ici_exit: 74 if (utf16_path != &root_path) 75 kfree(utf16_path); 76 kfree(path); 77 return rc; 78} 79 80static long cifs_ioctl_copychunk(unsigned int xid, struct file *dst_file, 81 unsigned long srcfd) 82{ 83 int rc; 84 struct fd src_file; 85 struct inode *src_inode; 86 87 cifs_dbg(FYI, "ioctl copychunk range\n"); 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 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 113 src_inode = file_inode(src_file.file); 114 rc = -EINVAL; 115 if (S_ISDIR(src_inode->i_mode)) 116 goto out_fput; 117 118 rc = cifs_file_copychunk_range(xid, src_file.file, 0, dst_file, 0, 119 src_inode->i_size, 0); 120 if (rc > 0) 121 rc = 0; 122out_fput: 123 fdput(src_file); 124out_drop_write: 125 mnt_drop_write_file(dst_file); 126 return rc; 127} 128 129static 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); 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; 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 164long cifs_ioctl(struct file *filep, unsigned int command, unsigned long arg) 165{ 166 struct inode *inode = file_inode(filep); 167 struct smb3_key_debug_info pkey_inf; 168 int rc = -ENOTTY; /* strange error - but the precedent */ 169 unsigned int xid; 170 struct cifsFileInfo *pSMBFile = filep->private_data; 171 struct cifs_tcon *tcon; 172 struct tcon_link *tlink; 173 struct cifs_sb_info *cifs_sb; 174 __u64 ExtAttrBits = 0; 175 __u64 caps; 176 177 xid = get_xid(); 178 179 cifs_dbg(FYI, "cifs ioctl 0x%x\n", command); 180 switch (command) { 181 case FS_IOC_GETFLAGS: 182 if (pSMBFile == NULL) 183 break; 184 tcon = tlink_tcon(pSMBFile->tlink); 185 caps = le64_to_cpu(tcon->fsUnixInfo.Capability); 186#ifdef CONFIG_CIFS_POSIX 187 if (CIFS_UNIX_EXTATTR_CAP & caps) { 188 __u64 ExtAttrMask = 0; 189 rc = CIFSGetExtAttr(xid, tcon, 190 pSMBFile->fid.netfid, 191 &ExtAttrBits, &ExtAttrMask); 192 if (rc == 0) 193 rc = put_user(ExtAttrBits & 194 FS_FL_USER_VISIBLE, 195 (int __user *)arg); 196 if (rc != -EOPNOTSUPP) 197 break; 198 } 199#endif /* CONFIG_CIFS_POSIX */ 200 rc = 0; 201 if (CIFS_I(inode)->cifsAttrs & ATTR_COMPRESSED) { 202 /* add in the compressed bit */ 203 ExtAttrBits = FS_COMPR_FL; 204 rc = put_user(ExtAttrBits & FS_FL_USER_VISIBLE, 205 (int __user *)arg); 206 } 207 break; 208 case FS_IOC_SETFLAGS: 209 if (pSMBFile == NULL) 210 break; 211 tcon = tlink_tcon(pSMBFile->tlink); 212 caps = le64_to_cpu(tcon->fsUnixInfo.Capability); 213 214 if (get_user(ExtAttrBits, (int __user *)arg)) { 215 rc = -EFAULT; 216 break; 217 } 218 219 /* 220 * if (CIFS_UNIX_EXTATTR_CAP & caps) 221 * rc = CIFSSetExtAttr(xid, tcon, 222 * pSMBFile->fid.netfid, 223 * extAttrBits, 224 * &ExtAttrMask); 225 * if (rc != -EOPNOTSUPP) 226 * break; 227 */ 228 229 /* Currently only flag we can set is compressed flag */ 230 if ((ExtAttrBits & FS_COMPR_FL) == 0) 231 break; 232 233 /* Try to set compress flag */ 234 if (tcon->ses->server->ops->set_compression) { 235 rc = tcon->ses->server->ops->set_compression( 236 xid, tcon, pSMBFile); 237 cifs_dbg(FYI, "set compress flag rc %d\n", rc); 238 } 239 break; 240 case CIFS_IOC_COPYCHUNK_FILE: 241 rc = cifs_ioctl_copychunk(xid, filep, arg); 242 break; 243 case CIFS_QUERY_INFO: 244 rc = cifs_ioctl_query_info(xid, filep, arg); 245 break; 246 case CIFS_IOC_SET_INTEGRITY: 247 if (pSMBFile == NULL) 248 break; 249 tcon = tlink_tcon(pSMBFile->tlink); 250 if (tcon->ses->server->ops->set_integrity) 251 rc = tcon->ses->server->ops->set_integrity(xid, 252 tcon, pSMBFile); 253 else 254 rc = -EOPNOTSUPP; 255 break; 256 case CIFS_IOC_GET_MNT_INFO: 257 if (pSMBFile == NULL) 258 break; 259 tcon = tlink_tcon(pSMBFile->tlink); 260 rc = smb_mnt_get_fsinfo(xid, tcon, (void __user *)arg); 261 break; 262 case CIFS_ENUMERATE_SNAPSHOTS: 263 if (pSMBFile == NULL) 264 break; 265 if (arg == 0) { 266 rc = -EINVAL; 267 goto cifs_ioc_exit; 268 } 269 tcon = tlink_tcon(pSMBFile->tlink); 270 if (tcon->ses->server->ops->enum_snapshots) 271 rc = tcon->ses->server->ops->enum_snapshots(xid, tcon, 272 pSMBFile, (void __user *)arg); 273 else 274 rc = -EOPNOTSUPP; 275 break; 276 case CIFS_DUMP_KEY: 277 if (pSMBFile == NULL) 278 break; 279 if (!capable(CAP_SYS_ADMIN)) { 280 rc = -EACCES; 281 break; 282 } 283 284 tcon = tlink_tcon(pSMBFile->tlink); 285 if (!smb3_encryption_required(tcon)) { 286 rc = -EOPNOTSUPP; 287 break; 288 } 289 pkey_inf.cipher_type = 290 le16_to_cpu(tcon->ses->server->cipher_type); 291 pkey_inf.Suid = tcon->ses->Suid; 292 memcpy(pkey_inf.auth_key, tcon->ses->auth_key.response, 293 16 /* SMB2_NTLMV2_SESSKEY_SIZE */); 294 memcpy(pkey_inf.smb3decryptionkey, 295 tcon->ses->smb3decryptionkey, SMB3_SIGN_KEY_SIZE); 296 memcpy(pkey_inf.smb3encryptionkey, 297 tcon->ses->smb3encryptionkey, SMB3_SIGN_KEY_SIZE); 298 if (copy_to_user((void __user *)arg, &pkey_inf, 299 sizeof(struct smb3_key_debug_info))) 300 rc = -EFAULT; 301 else 302 rc = 0; 303 break; 304 case CIFS_IOC_NOTIFY: 305 if (!S_ISDIR(inode->i_mode)) { 306 /* Notify can only be done on directories */ 307 rc = -EOPNOTSUPP; 308 break; 309 } 310 cifs_sb = CIFS_SB(inode->i_sb); 311 tlink = cifs_sb_tlink(cifs_sb); 312 if (IS_ERR(tlink)) { 313 rc = PTR_ERR(tlink); 314 break; 315 } 316 tcon = tlink_tcon(tlink); 317 if (tcon && tcon->ses->server->ops->notify) { 318 rc = tcon->ses->server->ops->notify(xid, 319 filep, (void __user *)arg); 320 cifs_dbg(FYI, "ioctl notify rc %d\n", rc); 321 } else 322 rc = -EOPNOTSUPP; 323 cifs_put_tlink(tlink); 324 break; 325 default: 326 cifs_dbg(FYI, "unsupported ioctl\n"); 327 break; 328 } 329cifs_ioc_exit: 330 free_xid(xid); 331 return rc; 332} 333