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, oldflags;
  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                 flags &= REISERFS_FL_USER_VISIBLE;
  40                 return put_user(flags, (int __user *) arg);
  41         case REISERFS_IOC_SETFLAGS: {
  42                 if (IS_RDONLY(inode) ||
  43                         (filp && MNT_IS_RDONLY(filp->f_vfsmnt)))
  44                         return -EROFS;
  45
  46                 if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
  47                         return -EPERM;
  48
  49                 if (get_user(flags, (int __user *) arg))
  50                         return -EFAULT;
  51
  52                 oldflags = REISERFS_I(inode) -> i_attrs;
  53                 if ( ( (oldflags & REISERFS_IMMUTABLE_FL) ||
  54                         ( (flags ^ oldflags) &
  55                         (REISERFS_IMMUTABLE_FL | REISERFS_IUNLINK_FL |
  56                          REISERFS_APPEND_FL) ) ) &&
  57                         !capable( CAP_LINUX_IMMUTABLE ) )
  58                         return -EPERM;
  59
  60                 if( ( flags & REISERFS_NOTAIL_FL ) &&
  61                     S_ISREG( inode -> i_mode ) ) {
  62                                 int result;
  63
  64                                 result = reiserfs_unpack( inode, filp );
  65                                 if( result )
  66                                         return result;
  67                 }
  68
  69                 flags = flags & REISERFS_FL_USER_MODIFYABLE;
  70                 flags |= oldflags & ~REISERFS_FL_USER_MODIFYABLE;
  71                 sd_attrs_to_i_attrs( flags, inode );
  72                 REISERFS_I(inode) -> i_attrs = flags;
  73                 inode->i_ctime = CURRENT_TIME;
  74                 mark_inode_dirty(inode);
  75                 return 0;
  76         }
  77         case REISERFS_IOC_GETVERSION:
  78                 return put_user(inode->i_generation, (int __user *) arg);
  79         case REISERFS_IOC_SETVERSION:
  80                 if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
  81                         return -EPERM;
  82                 if (IS_RDONLY(inode) ||
  83                         (filp && MNT_IS_RDONLY(filp->f_vfsmnt)))
  84                         return -EROFS;
  85                 if (get_user(inode->i_generation, (int __user *) arg))
  86                         return -EFAULT;
  87                 inode->i_ctime = CURRENT_TIME;
  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 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 }