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