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 | ||
7cc4bcc6 | 24 | long hfsplus_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) |
1da177e4 | 25 | { |
7cc4bcc6 | 26 | struct inode *inode = filp->f_path.dentry->d_inode; |
1da177e4 LT |
27 | unsigned int flags; |
28 | ||
7cc4bcc6 | 29 | lock_kernel(); |
1da177e4 LT |
30 | switch (cmd) { |
31 | case HFSPLUS_IOC_EXT2_GETFLAGS: | |
32 | flags = 0; | |
33 | if (HFSPLUS_I(inode).rootflags & HFSPLUS_FLG_IMMUTABLE) | |
36695673 | 34 | flags |= FS_IMMUTABLE_FL; /* EXT2_IMMUTABLE_FL */ |
1da177e4 | 35 | if (HFSPLUS_I(inode).rootflags & HFSPLUS_FLG_APPEND) |
36695673 | 36 | flags |= FS_APPEND_FL; /* EXT2_APPEND_FL */ |
1da177e4 | 37 | if (HFSPLUS_I(inode).userflags & HFSPLUS_FLG_NODUMP) |
36695673 | 38 | flags |= FS_NODUMP_FL; /* EXT2_NODUMP_FL */ |
1da177e4 LT |
39 | return put_user(flags, (int __user *)arg); |
40 | case HFSPLUS_IOC_EXT2_SETFLAGS: { | |
42a74f20 DH |
41 | int err = 0; |
42 | err = mnt_want_write(filp->f_path.mnt); | |
7cc4bcc6 AB |
43 | if (err) { |
44 | unlock_kernel(); | |
42a74f20 | 45 | return err; |
7cc4bcc6 | 46 | } |
1da177e4 | 47 | |
42a74f20 DH |
48 | if (!is_owner_or_cap(inode)) { |
49 | err = -EACCES; | |
50 | goto setflags_out; | |
51 | } | |
52 | if (get_user(flags, (int __user *)arg)) { | |
53 | err = -EFAULT; | |
54 | goto setflags_out; | |
55 | } | |
36695673 | 56 | if (flags & (FS_IMMUTABLE_FL|FS_APPEND_FL) || |
1da177e4 | 57 | HFSPLUS_I(inode).rootflags & (HFSPLUS_FLG_IMMUTABLE|HFSPLUS_FLG_APPEND)) { |
42a74f20 DH |
58 | if (!capable(CAP_LINUX_IMMUTABLE)) { |
59 | err = -EPERM; | |
60 | goto setflags_out; | |
61 | } | |
1da177e4 LT |
62 | } |
63 | ||
64 | /* don't silently ignore unsupported ext2 flags */ | |
42a74f20 DH |
65 | if (flags & ~(FS_IMMUTABLE_FL|FS_APPEND_FL|FS_NODUMP_FL)) { |
66 | err = -EOPNOTSUPP; | |
67 | goto setflags_out; | |
68 | } | |
36695673 | 69 | if (flags & FS_IMMUTABLE_FL) { /* EXT2_IMMUTABLE_FL */ |
1da177e4 LT |
70 | inode->i_flags |= S_IMMUTABLE; |
71 | HFSPLUS_I(inode).rootflags |= HFSPLUS_FLG_IMMUTABLE; | |
72 | } else { | |
73 | inode->i_flags &= ~S_IMMUTABLE; | |
74 | HFSPLUS_I(inode).rootflags &= ~HFSPLUS_FLG_IMMUTABLE; | |
75 | } | |
36695673 | 76 | if (flags & FS_APPEND_FL) { /* EXT2_APPEND_FL */ |
1da177e4 LT |
77 | inode->i_flags |= S_APPEND; |
78 | HFSPLUS_I(inode).rootflags |= HFSPLUS_FLG_APPEND; | |
79 | } else { | |
80 | inode->i_flags &= ~S_APPEND; | |
81 | HFSPLUS_I(inode).rootflags &= ~HFSPLUS_FLG_APPEND; | |
82 | } | |
36695673 | 83 | if (flags & FS_NODUMP_FL) /* EXT2_NODUMP_FL */ |
1da177e4 LT |
84 | HFSPLUS_I(inode).userflags |= HFSPLUS_FLG_NODUMP; |
85 | else | |
86 | HFSPLUS_I(inode).userflags &= ~HFSPLUS_FLG_NODUMP; | |
87 | ||
88 | inode->i_ctime = CURRENT_TIME_SEC; | |
89 | mark_inode_dirty(inode); | |
42a74f20 DH |
90 | setflags_out: |
91 | mnt_drop_write(filp->f_path.mnt); | |
7cc4bcc6 | 92 | unlock_kernel(); |
42a74f20 | 93 | return err; |
1da177e4 LT |
94 | } |
95 | default: | |
7cc4bcc6 | 96 | unlock_kernel(); |
1da177e4 LT |
97 | return -ENOTTY; |
98 | } | |
99 | } | |
100 | ||
101 | int hfsplus_setxattr(struct dentry *dentry, const char *name, | |
102 | const void *value, size_t size, int flags) | |
103 | { | |
104 | struct inode *inode = dentry->d_inode; | |
105 | struct hfs_find_data fd; | |
106 | hfsplus_cat_entry entry; | |
107 | struct hfsplus_cat_file *file; | |
108 | int res; | |
109 | ||
110 | if (!S_ISREG(inode->i_mode) || HFSPLUS_IS_RSRC(inode)) | |
111 | return -EOPNOTSUPP; | |
112 | ||
113 | res = hfs_find_init(HFSPLUS_SB(inode->i_sb).cat_tree, &fd); | |
114 | if (res) | |
115 | return res; | |
116 | res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd); | |
117 | if (res) | |
118 | goto out; | |
119 | hfs_bnode_read(fd.bnode, &entry, fd.entryoffset, | |
120 | sizeof(struct hfsplus_cat_file)); | |
121 | file = &entry.file; | |
122 | ||
123 | if (!strcmp(name, "hfs.type")) { | |
124 | if (size == 4) | |
125 | memcpy(&file->user_info.fdType, value, 4); | |
126 | else | |
127 | res = -ERANGE; | |
128 | } else if (!strcmp(name, "hfs.creator")) { | |
129 | if (size == 4) | |
130 | memcpy(&file->user_info.fdCreator, value, 4); | |
131 | else | |
132 | res = -ERANGE; | |
133 | } else | |
134 | res = -EOPNOTSUPP; | |
135 | if (!res) | |
136 | hfs_bnode_write(fd.bnode, &entry, fd.entryoffset, | |
137 | sizeof(struct hfsplus_cat_file)); | |
138 | out: | |
139 | hfs_find_exit(&fd); | |
140 | return res; | |
141 | } | |
142 | ||
143 | ssize_t hfsplus_getxattr(struct dentry *dentry, const char *name, | |
144 | void *value, size_t size) | |
145 | { | |
146 | struct inode *inode = dentry->d_inode; | |
147 | struct hfs_find_data fd; | |
148 | hfsplus_cat_entry entry; | |
149 | struct hfsplus_cat_file *file; | |
150 | ssize_t res = 0; | |
151 | ||
152 | if (!S_ISREG(inode->i_mode) || HFSPLUS_IS_RSRC(inode)) | |
153 | return -EOPNOTSUPP; | |
154 | ||
155 | if (size) { | |
156 | res = hfs_find_init(HFSPLUS_SB(inode->i_sb).cat_tree, &fd); | |
157 | if (res) | |
158 | return res; | |
159 | res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd); | |
160 | if (res) | |
161 | goto out; | |
162 | hfs_bnode_read(fd.bnode, &entry, fd.entryoffset, | |
163 | sizeof(struct hfsplus_cat_file)); | |
164 | } | |
165 | file = &entry.file; | |
166 | ||
167 | if (!strcmp(name, "hfs.type")) { | |
168 | if (size >= 4) { | |
169 | memcpy(value, &file->user_info.fdType, 4); | |
170 | res = 4; | |
171 | } else | |
172 | res = size ? -ERANGE : 4; | |
173 | } else if (!strcmp(name, "hfs.creator")) { | |
174 | if (size >= 4) { | |
175 | memcpy(value, &file->user_info.fdCreator, 4); | |
176 | res = 4; | |
177 | } else | |
178 | res = size ? -ERANGE : 4; | |
179 | } else | |
180 | res = -ENODATA; | |
181 | out: | |
182 | if (size) | |
183 | hfs_find_exit(&fd); | |
184 | return res; | |
185 | } | |
186 | ||
187 | #define HFSPLUS_ATTRLIST_SIZE (sizeof("hfs.creator")+sizeof("hfs.type")) | |
188 | ||
189 | ssize_t hfsplus_listxattr(struct dentry *dentry, char *buffer, size_t size) | |
190 | { | |
191 | struct inode *inode = dentry->d_inode; | |
192 | ||
193 | if (!S_ISREG(inode->i_mode) || HFSPLUS_IS_RSRC(inode)) | |
194 | return -EOPNOTSUPP; | |
195 | ||
196 | if (!buffer || !size) | |
197 | return HFSPLUS_ATTRLIST_SIZE; | |
198 | if (size < HFSPLUS_ATTRLIST_SIZE) | |
199 | return -ERANGE; | |
200 | strcpy(buffer, "hfs.type"); | |
201 | strcpy(buffer + sizeof("hfs.type"), "hfs.creator"); | |
202 | ||
203 | return HFSPLUS_ATTRLIST_SIZE; | |
204 | } |