1 /* 2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README 3 */ 4 5 #include <linux/capability.h> 6 #include <linux/fs.h> 7 #include <linux/mount.h> 8 #include <linux/reiserfs_fs.h> 9 #include <linux/time.h> 10 #include <asm/uaccess.h> 11 #include <linux/pagemap.h> 12 #include <linux/smp_lock.h> 13 #include <linux/compat.h> 14 15 /* 16 * reiserfs_ioctl - handler for ioctl for inode 17 * supported commands: 18 * 1) REISERFS_IOC_UNPACK - try to unpack tail from direct item into indirect 19 * and prevent packing file (argument arg has to be non-zero) 20 * 2) REISERFS_IOC_[GS]ETFLAGS, REISERFS_IOC_[GS]ETVERSION 21 * 3) That's all for a while ... 22 */ 23 long reiserfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) 24 { 25 struct inode *inode = filp->f_path.dentry->d_inode; 26 unsigned int flags; 27 int err = 0; 28 29 reiserfs_write_lock(inode->i_sb); 30 31 switch (cmd) { 32 case REISERFS_IOC_UNPACK: 33 if (S_ISREG(inode->i_mode)) { 34 if (arg) 35 err = reiserfs_unpack(inode, filp); 36 } else 37 err = -ENOTTY; 38 break; 39 /* 40 * following two cases are taken from fs/ext2/ioctl.c by Remy 41 * Card (card@masi.ibp.fr) 42 */ 43 case REISERFS_IOC_GETFLAGS: 44 if (!reiserfs_attrs(inode->i_sb)) { 45 err = -ENOTTY; 46 break; 47 } 48 49 flags = REISERFS_I(inode)->i_attrs; 50 i_attrs_to_sd_attrs(inode, (__u16 *) & flags); 51 err = put_user(flags, (int __user *)arg); 52 break; 53 case REISERFS_IOC_SETFLAGS:{ 54 if (!reiserfs_attrs(inode->i_sb)) { 55 err = -ENOTTY; 56 break; 57 } 58 59 err = mnt_want_write(filp->f_path.mnt); 60 if (err) 61 break; 62 63 if (!is_owner_or_cap(inode)) { 64 err = -EPERM; 65 goto setflags_out; 66 } 67 if (get_user(flags, (int __user *)arg)) { 68 err = -EFAULT; 69 goto setflags_out; 70 } 71 /* 72 * Is it quota file? Do not allow user to mess with it 73 */ 74 if (IS_NOQUOTA(inode)) { 75 err = -EPERM; 76 goto setflags_out; 77 } 78 if (((flags ^ REISERFS_I(inode)-> 79 i_attrs) & (REISERFS_IMMUTABLE_FL | 80 REISERFS_APPEND_FL)) 81 && !capable(CAP_LINUX_IMMUTABLE)) { 82 err = -EPERM; 83 goto setflags_out; 84 } 85 if ((flags & REISERFS_NOTAIL_FL) && 86 S_ISREG(inode->i_mode)) { 87 int result; 88 89 result = reiserfs_unpack(inode, filp); 90 if (result) { 91 err = result; 92 goto setflags_out; 93 } 94 } 95 sd_attrs_to_i_attrs(flags, inode); 96 REISERFS_I(inode)->i_attrs = flags; 97 inode->i_ctime = CURRENT_TIME_SEC; 98 mark_inode_dirty(inode); 99 setflags_out: 100 mnt_drop_write(filp->f_path.mnt); 101 break; 102 } 103 case REISERFS_IOC_GETVERSION: 104 err = put_user(inode->i_generation, (int __user *)arg); 105 break; 106 case REISERFS_IOC_SETVERSION: 107 if (!is_owner_or_cap(inode)) { 108 err = -EPERM; 109 break; 110 } 111 err = mnt_want_write(filp->f_path.mnt); 112 if (err) 113 break; 114 if (get_user(inode->i_generation, (int __user *)arg)) { 115 err = -EFAULT; 116 goto setversion_out; 117 } 118 inode->i_ctime = CURRENT_TIME_SEC; 119 mark_inode_dirty(inode); 120 setversion_out: 121 mnt_drop_write(filp->f_path.mnt); 122 break; 123 default: 124 err = -ENOTTY; 125 } 126 127 reiserfs_write_unlock(inode->i_sb); 128 129 return err; 130 } 131 132 #ifdef CONFIG_COMPAT 133 long reiserfs_compat_ioctl(struct file *file, unsigned int cmd, 134 unsigned long arg) 135 { 136 /* These are just misnamed, they actually get/put from/to user an int */ 137 switch (cmd) { 138 case REISERFS_IOC32_UNPACK: 139 cmd = REISERFS_IOC_UNPACK; 140 break; 141 case REISERFS_IOC32_GETFLAGS: 142 cmd = REISERFS_IOC_GETFLAGS; 143 break; 144 case REISERFS_IOC32_SETFLAGS: 145 cmd = REISERFS_IOC_SETFLAGS; 146 break; 147 case REISERFS_IOC32_GETVERSION: 148 cmd = REISERFS_IOC_GETVERSION; 149 break; 150 case REISERFS_IOC32_SETVERSION: 151 cmd = REISERFS_IOC_SETVERSION; 152 break; 153 default: 154 return -ENOIOCTLCMD; 155 } 156 157 return reiserfs_ioctl(file, cmd, (unsigned long) compat_ptr(arg)); 158 } 159 #endif 160 161 int reiserfs_commit_write(struct file *f, struct page *page, 162 unsigned from, unsigned to); 163 int reiserfs_prepare_write(struct file *f, struct page *page, 164 unsigned from, unsigned to); 165 /* 166 ** reiserfs_unpack 167 ** Function try to convert tail from direct item into indirect. 168 ** It set up nopack attribute in the REISERFS_I(inode)->nopack 169 */ 170 int reiserfs_unpack(struct inode *inode, struct file *filp) 171 { 172 int retval = 0; 173 int depth; 174 int index; 175 struct page *page; 176 struct address_space *mapping; 177 unsigned long write_from; 178 unsigned long blocksize = inode->i_sb->s_blocksize; 179 180 if (inode->i_size == 0) { 181 REISERFS_I(inode)->i_flags |= i_nopack_mask; 182 return 0; 183 } 184 /* ioctl already done */ 185 if (REISERFS_I(inode)->i_flags & i_nopack_mask) { 186 return 0; 187 } 188 189 /* we need to make sure nobody is changing the file size beneath 190 ** us 191 */ 192 reiserfs_mutex_lock_safe(&inode->i_mutex, inode->i_sb); 193 depth = reiserfs_write_lock_once(inode->i_sb); 194 195 write_from = inode->i_size & (blocksize - 1); 196 /* if we are on a block boundary, we are already unpacked. */ 197 if (write_from == 0) { 198 REISERFS_I(inode)->i_flags |= i_nopack_mask; 199 goto out; 200 } 201 202 /* we unpack by finding the page with the tail, and calling 203 ** reiserfs_prepare_write on that page. This will force a 204 ** reiserfs_get_block to unpack the tail for us. 205 */ 206 index = inode->i_size >> PAGE_CACHE_SHIFT; 207 mapping = inode->i_mapping; 208 page = grab_cache_page(mapping, index); 209 retval = -ENOMEM; 210 if (!page) { 211 goto out; 212 } 213 retval = reiserfs_prepare_write(NULL, page, write_from, write_from); 214 if (retval) 215 goto out_unlock; 216 217 /* conversion can change page contents, must flush */ 218 flush_dcache_page(page); 219 retval = reiserfs_commit_write(NULL, page, write_from, write_from); 220 REISERFS_I(inode)->i_flags |= i_nopack_mask; 221 222 out_unlock: 223 unlock_page(page); 224 page_cache_release(page); 225 226 out: 227 mutex_unlock(&inode->i_mutex); 228 reiserfs_write_unlock_once(inode->i_sb, depth); 229 return retval; 230 } 231