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