[PATCH] reiserfs: Check if attrs are enabled for attr ioctls
[sfrench/cifs-2.6.git] / 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;
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                 if (!reiserfs_attrs (inode->i_sb))
40                         return -ENOTTY;
41
42                 flags = REISERFS_I(inode) -> i_attrs;
43                 i_attrs_to_sd_attrs( inode, ( __u16 * ) &flags );
44                 return put_user(flags, (int __user *) arg);
45         case REISERFS_IOC_SETFLAGS: {
46                 if (!reiserfs_attrs (inode->i_sb))
47                         return -ENOTTY;
48
49                 if (IS_RDONLY(inode))
50                         return -EROFS;
51
52                 if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
53                         return -EPERM;
54
55                 if (get_user(flags, (int __user *) arg))
56                         return -EFAULT;
57
58                 if ( ( ( flags ^ REISERFS_I(inode) -> i_attrs) & ( REISERFS_IMMUTABLE_FL | REISERFS_APPEND_FL)) &&
59                      !capable( CAP_LINUX_IMMUTABLE ) )
60                         return -EPERM;
61                         
62                 if( ( flags & REISERFS_NOTAIL_FL ) &&
63                     S_ISREG( inode -> i_mode ) ) {
64                                 int result;
65
66                                 result = reiserfs_unpack( inode, filp );
67                                 if( result )
68                                         return result;
69                 }
70                 sd_attrs_to_i_attrs( flags, inode );
71                 REISERFS_I(inode) -> i_attrs = flags;
72                 inode->i_ctime = CURRENT_TIME_SEC;
73                 mark_inode_dirty(inode);
74                 return 0;
75         }
76         case REISERFS_IOC_GETVERSION:
77                 return put_user(inode->i_generation, (int __user *) arg);
78         case REISERFS_IOC_SETVERSION:
79                 if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
80                         return -EPERM;
81                 if (IS_RDONLY(inode))
82                         return -EROFS;
83                 if (get_user(inode->i_generation, (int __user *) arg))
84                         return -EFAULT; 
85                 inode->i_ctime = CURRENT_TIME_SEC;
86                 mark_inode_dirty(inode);
87                 return 0;
88         default:
89                 return -ENOTTY;
90         }
91 }
92
93 /*
94 ** reiserfs_unpack
95 ** Function try to convert tail from direct item into indirect.
96 ** It set up nopack attribute in the REISERFS_I(inode)->nopack
97 */
98 static int reiserfs_unpack (struct inode * inode, struct file * filp)
99 {
100     int retval = 0;
101     int index ;
102     struct page *page ;
103     struct address_space *mapping ;
104     unsigned long write_from ;
105     unsigned long blocksize = inode->i_sb->s_blocksize ;
106         
107     if (inode->i_size == 0) {
108         REISERFS_I(inode)->i_flags |= i_nopack_mask;
109         return 0 ;
110     }
111     /* ioctl already done */
112     if (REISERFS_I(inode)->i_flags & i_nopack_mask) {
113         return 0 ;
114     }
115     reiserfs_write_lock(inode->i_sb);
116
117     /* we need to make sure nobody is changing the file size beneath
118     ** us
119     */
120     down(&inode->i_sem) ;
121
122     write_from = inode->i_size & (blocksize - 1) ;
123     /* if we are on a block boundary, we are already unpacked.  */
124     if ( write_from == 0) {
125         REISERFS_I(inode)->i_flags |= i_nopack_mask;
126         goto out ;
127     }
128
129     /* we unpack by finding the page with the tail, and calling
130     ** reiserfs_prepare_write on that page.  This will force a 
131     ** reiserfs_get_block to unpack the tail for us.
132     */
133     index = inode->i_size >> PAGE_CACHE_SHIFT ;
134     mapping = inode->i_mapping ;
135     page = grab_cache_page(mapping, index) ;
136     retval = -ENOMEM;
137     if (!page) {
138         goto out ;
139     }
140     retval = mapping->a_ops->prepare_write(NULL, page, write_from, write_from) ;
141     if (retval)
142         goto out_unlock ;
143
144     /* conversion can change page contents, must flush */
145     flush_dcache_page(page) ;
146     retval = mapping->a_ops->commit_write(NULL, page, write_from, write_from) ;
147     REISERFS_I(inode)->i_flags |= i_nopack_mask;
148
149 out_unlock:
150     unlock_page(page) ;
151     page_cache_release(page) ;
152
153 out:
154     up(&inode->i_sem) ;
155     reiserfs_write_unlock(inode->i_sb);
156     return retval;
157 }