patch-2.6.6-vs1.9.0
[linux-2.6.git] / fs / ext3 / ioctl.c
1 /*
2  * linux/fs/ext3/ioctl.c
3  *
4  * Copyright (C) 1993, 1994, 1995
5  * Remy Card (card@masi.ibp.fr)
6  * Laboratoire MASI - Institut Blaise Pascal
7  * Universite Pierre et Marie Curie (Paris VI)
8  */
9
10 #include <linux/fs.h>
11 #include <linux/jbd.h>
12 #include <linux/ext3_fs.h>
13 #include <linux/ext3_jbd.h>
14 #include <linux/time.h>
15 #include <linux/vserver/xid.h>
16 #include <asm/uaccess.h>
17
18
19 int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
20                 unsigned long arg)
21 {
22         struct ext3_inode_info *ei = EXT3_I(inode);
23         unsigned int flags;
24
25         ext3_debug ("cmd = %u, arg = %lu\n", cmd, arg);
26
27         switch (cmd) {
28         case EXT3_IOC_GETFLAGS:
29                 flags = ei->i_flags & EXT3_FL_USER_VISIBLE;
30                 return put_user(flags, (int *) arg);
31         case EXT3_IOC_SETFLAGS: {
32                 handle_t *handle = NULL;
33                 int err;
34                 struct ext3_iloc iloc;
35                 unsigned int oldflags;
36                 unsigned int jflag;
37
38                 if (IS_RDONLY(inode))
39                         return -EROFS;
40
41                 if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
42                         return -EACCES;
43
44                 if (get_user(flags, (int *) arg))
45                         return -EFAULT;
46
47                 if (!S_ISDIR(inode->i_mode))
48                         flags &= ~EXT3_DIRSYNC_FL;
49
50                 oldflags = ei->i_flags;
51
52                 /* The JOURNAL_DATA flag is modifiable only by root */
53                 jflag = flags & EXT3_JOURNAL_DATA_FL;
54
55                 /*
56                  * The IMMUTABLE and APPEND_ONLY flags can only be changed by
57                  * the relevant capability.
58                  *
59                  * This test looks nicer. Thanks to Pauline Middelink
60                  */
61                 if ((flags ^ oldflags) & (EXT3_APPEND_FL | EXT3_IMMUTABLE_FL)) {
62                         if (!capable(CAP_LINUX_IMMUTABLE))
63                                 return -EPERM;
64                 }
65
66                 /*
67                  * The JOURNAL_DATA flag can only be changed by
68                  * the relevant capability.
69                  */
70                 if ((jflag ^ oldflags) & (EXT3_JOURNAL_DATA_FL)) {
71                         if (!capable(CAP_SYS_RESOURCE))
72                                 return -EPERM;
73                 }
74
75
76                 handle = ext3_journal_start(inode, 1);
77                 if (IS_ERR(handle))
78                         return PTR_ERR(handle);
79                 if (IS_SYNC(inode))
80                         handle->h_sync = 1;
81                 err = ext3_reserve_inode_write(handle, inode, &iloc);
82                 if (err)
83                         goto flags_err;
84
85                 flags = flags & EXT3_FL_USER_MODIFIABLE;
86                 flags |= oldflags & ~EXT3_FL_USER_MODIFIABLE;
87                 ei->i_flags = flags;
88
89                 ext3_set_inode_flags(inode);
90                 inode->i_ctime = CURRENT_TIME;
91
92                 err = ext3_mark_iloc_dirty(handle, inode, &iloc);
93 flags_err:
94                 ext3_journal_stop(handle);
95                 if (err)
96                         return err;
97
98                 if ((jflag ^ oldflags) & (EXT3_JOURNAL_DATA_FL))
99                         err = ext3_change_inode_journal_flag(inode, jflag);
100                 return err;
101         }
102         case EXT3_IOC_GETVERSION:
103         case EXT3_IOC_GETVERSION_OLD:
104                 return put_user(inode->i_generation, (int *) arg);
105         case EXT3_IOC_SETVERSION:
106         case EXT3_IOC_SETVERSION_OLD: {
107                 handle_t *handle;
108                 struct ext3_iloc iloc;
109                 __u32 generation;
110                 int err;
111
112                 if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
113                         return -EPERM;
114                 if (IS_RDONLY(inode))
115                         return -EROFS;
116                 if (get_user(generation, (int *) arg))
117                         return -EFAULT;
118
119                 handle = ext3_journal_start(inode, 1);
120                 if (IS_ERR(handle))
121                         return PTR_ERR(handle);
122                 err = ext3_reserve_inode_write(handle, inode, &iloc);
123                 if (err == 0) {
124                         inode->i_ctime = CURRENT_TIME;
125                         inode->i_generation = generation;
126                         err = ext3_mark_iloc_dirty(handle, inode, &iloc);
127                 }
128                 ext3_journal_stop(handle);
129                 return err;
130         }
131 #ifdef CONFIG_JBD_DEBUG
132         case EXT3_IOC_WAIT_FOR_READONLY:
133                 /*
134                  * This is racy - by the time we're woken up and running,
135                  * the superblock could be released.  And the module could
136                  * have been unloaded.  So sue me.
137                  *
138                  * Returns 1 if it slept, else zero.
139                  */
140                 {
141                         struct super_block *sb = inode->i_sb;
142                         DECLARE_WAITQUEUE(wait, current);
143                         int ret = 0;
144
145                         set_current_state(TASK_INTERRUPTIBLE);
146                         add_wait_queue(&EXT3_SB(sb)->ro_wait_queue, &wait);
147                         if (timer_pending(&EXT3_SB(sb)->turn_ro_timer)) {
148                                 schedule();
149                                 ret = 1;
150                         }
151                         remove_wait_queue(&EXT3_SB(sb)->ro_wait_queue, &wait);
152                         return ret;
153                 }
154 #endif
155 #if defined(CONFIG_VSERVER_LEGACY) && !defined(CONFIG_INOXID_NONE)
156         case EXT3_IOC_SETXID: {
157                 handle_t *handle;
158                 struct ext3_iloc iloc;
159                 int xid;
160                 int err;
161
162                 /* fixme: if stealth, return -ENOTTY */
163                 if (!capable(CAP_CONTEXT))
164                         return -EPERM;
165                 if (IS_RDONLY(inode))
166                         return -EROFS;
167                 if (!(inode->i_sb->s_flags & MS_TAGXID))
168                         return -ENOSYS;
169                 if (get_user(xid, (int *) arg))
170                         return -EFAULT; 
171
172                 handle = ext3_journal_start(inode, 1);
173                 if (IS_ERR(handle))
174                         return PTR_ERR(handle);
175                 err = ext3_reserve_inode_write(handle, inode, &iloc);
176                 if (err)
177                         return err;
178
179                 inode->i_xid = (xid & 0xFFFF);
180                 inode->i_ctime = CURRENT_TIME;
181
182                 err = ext3_mark_iloc_dirty(handle, inode, &iloc);
183                 ext3_journal_stop(handle);
184                 return err;
185         }
186 #endif
187         default:
188                 return -ENOTTY;
189         }
190 }