hfsplus: remove superflous rootflags field in hfsplus_inode_info
[linux-2.6.git] / fs / hfsplus / ioctl.c
1 /*
2  *  linux/fs/hfsplus/ioctl.c
3  *
4  * Copyright (C) 2003
5  * Ethan Benson <erbenson@alaska.net>
6  * partially derived from linux/fs/ext2/ioctl.c
7  * Copyright (C) 1993, 1994, 1995
8  * Remy Card (card@masi.ibp.fr)
9  * Laboratoire MASI - Institut Blaise Pascal
10  * Universite Pierre et Marie Curie (Paris VI)
11  *
12  * hfsplus ioctls
13  */
14
15 #include <linux/capability.h>
16 #include <linux/fs.h>
17 #include <linux/mount.h>
18 #include <linux/sched.h>
19 #include <linux/xattr.h>
20 #include <asm/uaccess.h>
21 #include "hfsplus_fs.h"
22
23 static int hfsplus_ioctl_getflags(struct file *file, int __user *user_flags)
24 {
25         struct inode *inode = file->f_path.dentry->d_inode;
26         struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
27         unsigned int flags = 0;
28
29         if (inode->i_flags & S_IMMUTABLE)
30                 flags |= FS_IMMUTABLE_FL;
31         if (inode->i_flags |= S_APPEND)
32                 flags |= FS_APPEND_FL;
33         if (hip->userflags & HFSPLUS_FLG_NODUMP)
34                 flags |= FS_NODUMP_FL;
35
36         return put_user(flags, user_flags);
37 }
38
39 static int hfsplus_ioctl_setflags(struct file *file, int __user *user_flags)
40 {
41         struct inode *inode = file->f_path.dentry->d_inode;
42         struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
43         unsigned int flags;
44         int err = 0;
45
46         err = mnt_want_write(file->f_path.mnt);
47         if (err)
48                 goto out;
49
50         if (!is_owner_or_cap(inode)) {
51                 err = -EACCES;
52                 goto out_drop_write;
53         }
54
55         if (get_user(flags, user_flags)) {
56                 err = -EFAULT;
57                 goto out_drop_write;
58         }
59
60         mutex_lock(&inode->i_mutex);
61
62         if ((flags & (FS_IMMUTABLE_FL|FS_APPEND_FL)) ||
63             inode->i_flags & (S_IMMUTABLE|S_APPEND)) {
64                 if (!capable(CAP_LINUX_IMMUTABLE)) {
65                         err = -EPERM;
66                         goto out_unlock_inode;
67                 }
68         }
69
70         /* don't silently ignore unsupported ext2 flags */
71         if (flags & ~(FS_IMMUTABLE_FL|FS_APPEND_FL|FS_NODUMP_FL)) {
72                 err = -EOPNOTSUPP;
73                 goto out_unlock_inode;
74         }
75
76         if (flags & FS_IMMUTABLE_FL)
77                 inode->i_flags |= S_IMMUTABLE;
78         else
79                 inode->i_flags &= ~S_IMMUTABLE;
80
81         if (flags & FS_APPEND_FL)
82                 inode->i_flags |= S_APPEND;
83         else
84                 inode->i_flags &= ~S_APPEND;
85
86         if (flags & FS_NODUMP_FL)
87                 hip->userflags |= HFSPLUS_FLG_NODUMP;
88         else
89                 hip->userflags &= ~HFSPLUS_FLG_NODUMP;
90
91         inode->i_ctime = CURRENT_TIME_SEC;
92         mark_inode_dirty(inode);
93
94 out_unlock_inode:
95         mutex_lock(&inode->i_mutex);
96 out_drop_write:
97         mnt_drop_write(file->f_path.mnt);
98 out:
99         return err;
100 }
101
102 long hfsplus_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
103 {
104         void __user *argp = (void __user *)arg;
105
106         switch (cmd) {
107         case HFSPLUS_IOC_EXT2_GETFLAGS:
108                 return hfsplus_ioctl_getflags(file, argp);
109         case HFSPLUS_IOC_EXT2_SETFLAGS:
110                 return hfsplus_ioctl_setflags(file, argp);
111         default:
112                 return -ENOTTY;
113         }
114 }
115
116 int hfsplus_setxattr(struct dentry *dentry, const char *name,
117                      const void *value, size_t size, int flags)
118 {
119         struct inode *inode = dentry->d_inode;
120         struct hfs_find_data fd;
121         hfsplus_cat_entry entry;
122         struct hfsplus_cat_file *file;
123         int res;
124
125         if (!S_ISREG(inode->i_mode) || HFSPLUS_IS_RSRC(inode))
126                 return -EOPNOTSUPP;
127
128         res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd);
129         if (res)
130                 return res;
131         res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);
132         if (res)
133                 goto out;
134         hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
135                         sizeof(struct hfsplus_cat_file));
136         file = &entry.file;
137
138         if (!strcmp(name, "hfs.type")) {
139                 if (size == 4)
140                         memcpy(&file->user_info.fdType, value, 4);
141                 else
142                         res = -ERANGE;
143         } else if (!strcmp(name, "hfs.creator")) {
144                 if (size == 4)
145                         memcpy(&file->user_info.fdCreator, value, 4);
146                 else
147                         res = -ERANGE;
148         } else
149                 res = -EOPNOTSUPP;
150         if (!res)
151                 hfs_bnode_write(fd.bnode, &entry, fd.entryoffset,
152                                 sizeof(struct hfsplus_cat_file));
153 out:
154         hfs_find_exit(&fd);
155         return res;
156 }
157
158 ssize_t hfsplus_getxattr(struct dentry *dentry, const char *name,
159                          void *value, size_t size)
160 {
161         struct inode *inode = dentry->d_inode;
162         struct hfs_find_data fd;
163         hfsplus_cat_entry entry;
164         struct hfsplus_cat_file *file;
165         ssize_t res = 0;
166
167         if (!S_ISREG(inode->i_mode) || HFSPLUS_IS_RSRC(inode))
168                 return -EOPNOTSUPP;
169
170         if (size) {
171                 res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd);
172                 if (res)
173                         return res;
174                 res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);
175                 if (res)
176                         goto out;
177                 hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
178                                 sizeof(struct hfsplus_cat_file));
179         }
180         file = &entry.file;
181
182         if (!strcmp(name, "hfs.type")) {
183                 if (size >= 4) {
184                         memcpy(value, &file->user_info.fdType, 4);
185                         res = 4;
186                 } else
187                         res = size ? -ERANGE : 4;
188         } else if (!strcmp(name, "hfs.creator")) {
189                 if (size >= 4) {
190                         memcpy(value, &file->user_info.fdCreator, 4);
191                         res = 4;
192                 } else
193                         res = size ? -ERANGE : 4;
194         } else
195                 res = -ENODATA;
196 out:
197         if (size)
198                 hfs_find_exit(&fd);
199         return res;
200 }
201
202 #define HFSPLUS_ATTRLIST_SIZE (sizeof("hfs.creator")+sizeof("hfs.type"))
203
204 ssize_t hfsplus_listxattr(struct dentry *dentry, char *buffer, size_t size)
205 {
206         struct inode *inode = dentry->d_inode;
207
208         if (!S_ISREG(inode->i_mode) || HFSPLUS_IS_RSRC(inode))
209                 return -EOPNOTSUPP;
210
211         if (!buffer || !size)
212                 return HFSPLUS_ATTRLIST_SIZE;
213         if (size < HFSPLUS_ATTRLIST_SIZE)
214                 return -ERANGE;
215         strcpy(buffer, "hfs.type");
216         strcpy(buffer + sizeof("hfs.type"), "hfs.creator");
217
218         return HFSPLUS_ATTRLIST_SIZE;
219 }