Commit | Line | Data |
---|---|---|
1da177e4 LT |
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 | ||
16f7e0fe | 15 | #include <linux/capability.h> |
1da177e4 | 16 | #include <linux/fs.h> |
42a74f20 | 17 | #include <linux/mount.h> |
1da177e4 LT |
18 | #include <linux/sched.h> |
19 | #include <linux/xattr.h> | |
7cc4bcc6 | 20 | #include <linux/smp_lock.h> |
1da177e4 LT |
21 | #include <asm/uaccess.h> |
22 | #include "hfsplus_fs.h" | |
23 | ||
94744567 | 24 | static int hfsplus_ioctl_getflags(struct file *file, int __user *user_flags) |
1da177e4 | 25 | { |
94744567 CH |
26 | struct inode *inode = file->f_path.dentry->d_inode; |
27 | unsigned int flags = 0; | |
28 | ||
29 | if (HFSPLUS_I(inode).rootflags & HFSPLUS_FLG_IMMUTABLE) | |
30 | flags |= FS_IMMUTABLE_FL; | |
31 | if (HFSPLUS_I(inode).rootflags & HFSPLUS_FLG_APPEND) | |
32 | flags |= FS_APPEND_FL; | |
33 | if (HFSPLUS_I(inode).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; | |
1da177e4 | 42 | unsigned int flags; |
94744567 | 43 | int err = 0; |
1da177e4 | 44 | |
94744567 CH |
45 | lock_kernel(); |
46 | err = mnt_want_write(file->f_path.mnt); | |
47 | if (err) | |
48 | goto out_unlock_kernel; | |
1da177e4 | 49 | |
94744567 CH |
50 | if (!is_owner_or_cap(inode)) { |
51 | err = -EACCES; | |
52 | goto out_drop_write; | |
53 | } | |
1da177e4 | 54 | |
94744567 CH |
55 | if (get_user(flags, user_flags)) { |
56 | err = -EFAULT; | |
57 | goto out_drop_write; | |
58 | } | |
59 | ||
60 | if (flags & (FS_IMMUTABLE_FL|FS_APPEND_FL) || | |
61 | HFSPLUS_I(inode).rootflags & (HFSPLUS_FLG_IMMUTABLE|HFSPLUS_FLG_APPEND)) { | |
62 | if (!capable(CAP_LINUX_IMMUTABLE)) { | |
63 | err = -EPERM; | |
64 | goto out_drop_write; | |
1da177e4 | 65 | } |
1da177e4 | 66 | } |
94744567 CH |
67 | |
68 | /* don't silently ignore unsupported ext2 flags */ | |
69 | if (flags & ~(FS_IMMUTABLE_FL|FS_APPEND_FL|FS_NODUMP_FL)) { | |
70 | err = -EOPNOTSUPP; | |
71 | goto out_drop_write; | |
72 | } | |
73 | if (flags & FS_IMMUTABLE_FL) { | |
74 | inode->i_flags |= S_IMMUTABLE; | |
75 | HFSPLUS_I(inode).rootflags |= HFSPLUS_FLG_IMMUTABLE; | |
76 | } else { | |
77 | inode->i_flags &= ~S_IMMUTABLE; | |
78 | HFSPLUS_I(inode).rootflags &= ~HFSPLUS_FLG_IMMUTABLE; | |
79 | } | |
80 | if (flags & FS_APPEND_FL) { | |
81 | inode->i_flags |= S_APPEND; | |
82 | HFSPLUS_I(inode).rootflags |= HFSPLUS_FLG_APPEND; | |
83 | } else { | |
84 | inode->i_flags &= ~S_APPEND; | |
85 | HFSPLUS_I(inode).rootflags &= ~HFSPLUS_FLG_APPEND; | |
86 | } | |
87 | if (flags & FS_NODUMP_FL) | |
88 | HFSPLUS_I(inode).userflags |= HFSPLUS_FLG_NODUMP; | |
89 | else | |
90 | HFSPLUS_I(inode).userflags &= ~HFSPLUS_FLG_NODUMP; | |
91 | ||
92 | inode->i_ctime = CURRENT_TIME_SEC; | |
93 | mark_inode_dirty(inode); | |
94 | ||
95 | out_drop_write: | |
96 | mnt_drop_write(file->f_path.mnt); | |
97 | out_unlock_kernel: | |
98 | unlock_kernel(); | |
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); | |
1da177e4 LT |
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 | } |