fs/reiserfs/ioctl.c

   1 /*
   2  * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
   3  */
   4
   5 #include <linux/fs.h>
   6 #include <linux/reiserfs_fs.h>
   7 #include <linux/time.h>
   8 #include <asm/uaccess.h>
   9 #include <linux/pagemap.h>
  10 #include <linux/smp_lock.h>
  11
  12 /*
  13 ** reiserfs_ioctl - handler for ioctl for inode
  14 ** supported commands:
  15 **  1) REISERFS_IOC_UNPACK - try to unpack tail from direct item into indirect
  16 **                           and prevent packing file (argument arg has to be non-zero)
  17 **  2) REISERFS_IOC_[GS]ETFLAGS, REISERFS_IOC_[GS]ETVERSION
  18 **  3) That's all for a while ...
  19 */
  20 int reiserfs_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
  21                 unsigned long arg)
  22 {
  23         unsigned int flags;
  24
  25         switch (cmd) {
  26             case REISERFS_IOC_UNPACK:
  27                 if( S_ISREG( inode -> i_mode ) ) {
  28                 if (arg)
  29                     return reiserfs_unpack (inode, filp);
  30                         else
  31                                 return 0;
  32                 } else
  33                         return -ENOTTY;
  34         /* following two cases are taken from fs/ext2/ioctl.c by Remy
  35            Card (card@masi.ibp.fr) */
  36         case REISERFS_IOC_GETFLAGS:
  37                 flags = REISERFS_I(inode) -> i_attrs;
  38                 i_attrs_to_sd_attrs( inode, ( __u16 * ) &flags );
  39                 return put_user(flags, (int __user *) arg);
  40         case REISERFS_IOC_SETFLAGS: {
  41                 if (IS_RDONLY(inode))
  42                         return -EROFS;
  43
  44                 if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
  45                         return -EPERM;
  46
  47                 if (get_user(flags, (int __user *) arg))
  48                         return -EFAULT;
  49
  50                 if ( ( ( flags ^ REISERFS_I(inode) -> i_attrs) & ( REISERFS_IMMUTABLE_FL | REISERFS_APPEND_FL)) &&
  51                      !capable( CAP_LINUX_IMMUTABLE ) )
  52                         return -EPERM;
  53
  54                 if( ( flags & REISERFS_NOTAIL_FL ) &&
  55                     S_ISREG( inode -> i_mode ) ) {
  56                                 int result;
  57
  58                                 result = reiserfs_unpack( inode, filp );
  59                                 if( result )
  60                                         return result;
  61                 }
  62                 sd_attrs_to_i_attrs( flags, inode );
  63                 REISERFS_I(inode) -> i_attrs = flags;
  64                 inode->i_ctime = CURRENT_TIME;
  65                 mark_inode_dirty(inode);
  66                 return 0;
  67         }
  68         case REISERFS_IOC_GETVERSION:
  69                 return put_user(inode->i_generation, (int __user *) arg);
  70         case REISERFS_IOC_SETVERSION:
  71                 if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
  72                         return -EPERM;
  73                 if (IS_RDONLY(inode))
  74                         return -EROFS;
  75                 if (get_user(inode->i_generation, (int __user *) arg))
  76                         return -EFAULT;
  77                 inode->i_ctime = CURRENT_TIME;
  78                 mark_inode_dirty(inode);
  79                 return 0;
  80         default:
  81                 return -ENOTTY;
  82         }
  83 }
  84
  85 /*
  86 ** reiserfs_unpack
  87 ** Function try to convert tail from direct item into indirect.
  88 ** It set up nopack attribute in the REISERFS_I(inode)->nopack
  89 */
  90 int reiserfs_unpack (struct inode * inode, struct file * filp)
  91 {
  92     int retval = 0;
  93     int index ;
  94     struct page *page ;
  95     struct address_space *mapping ;
  96     unsigned long write_from ;
  97     unsigned long blocksize = inode->i_sb->s_blocksize ;
  98
  99     if (inode->i_size == 0) {
 100         REISERFS_I(inode)->i_flags |= i_nopack_mask;
 101         return 0 ;
 102     }
 103     /* ioctl already done */
 104     if (REISERFS_I(inode)->i_flags & i_nopack_mask) {
 105         return 0 ;
 106     }
 107     reiserfs_write_lock(inode->i_sb);
 108
 109     /* we need to make sure nobody is changing the file size beneath
 110     ** us
 111     */
 112     down(&inode->i_sem) ;
 113
 114     write_from = inode->i_size & (blocksize - 1) ;
 115     /* if we are on a block boundary, we are already unpacked.  */
 116     if ( write_from == 0) {
 117         REISERFS_I(inode)->i_flags |= i_nopack_mask;
 118         goto out ;
 119     }
 120
 121     /* we unpack by finding the page with the tail, and calling
 122     ** reiserfs_prepare_write on that page.  This will force a
 123     ** reiserfs_get_block to unpack the tail for us.
 124     */
 125     index = inode->i_size >> PAGE_CACHE_SHIFT ;
 126     mapping = inode->i_mapping ;
 127     page = grab_cache_page(mapping, index) ;
 128     retval = -ENOMEM;
 129     if (!page) {
 130         goto out ;
 131     }
 132     retval = mapping->a_ops->prepare_write(NULL, page, write_from, write_from) ;
 133     if (retval)
 134         goto out_unlock ;
 135
 136     /* conversion can change page contents, must flush */
 137     flush_dcache_page(page) ;
 138     retval = mapping->a_ops->commit_write(NULL, page, write_from, write_from) ;
 139     REISERFS_I(inode)->i_flags |= i_nopack_mask;
 140
 141 out_unlock:
 142     unlock_page(page) ;
 143     page_cache_release(page) ;
 144
 145 out:
 146     up(&inode->i_sem) ;
 147     reiserfs_write_unlock(inode->i_sb);
 148     return retval;
 149 }