security: tlk_driver: kernel mem type allocation
[linux-3.10.git] / fs / hfsplus / attributes.c
1 /*
2  * linux/fs/hfsplus/attributes.c
3  *
4  * Vyacheslav Dubeyko <slava@dubeyko.com>
5  *
6  * Handling of records in attributes tree
7  */
8
9 #include "hfsplus_fs.h"
10 #include "hfsplus_raw.h"
11
12 static struct kmem_cache *hfsplus_attr_tree_cachep;
13
14 int hfsplus_create_attr_tree_cache(void)
15 {
16         if (hfsplus_attr_tree_cachep)
17                 return -EEXIST;
18
19         hfsplus_attr_tree_cachep =
20                 kmem_cache_create("hfsplus_attr_cache",
21                         sizeof(hfsplus_attr_entry), 0,
22                         SLAB_HWCACHE_ALIGN, NULL);
23         if (!hfsplus_attr_tree_cachep)
24                 return -ENOMEM;
25
26         return 0;
27 }
28
29 void hfsplus_destroy_attr_tree_cache(void)
30 {
31         kmem_cache_destroy(hfsplus_attr_tree_cachep);
32 }
33
34 int hfsplus_attr_bin_cmp_key(const hfsplus_btree_key *k1,
35                                 const hfsplus_btree_key *k2)
36 {
37         __be32 k1_cnid, k2_cnid;
38
39         k1_cnid = k1->attr.cnid;
40         k2_cnid = k2->attr.cnid;
41         if (k1_cnid != k2_cnid)
42                 return be32_to_cpu(k1_cnid) < be32_to_cpu(k2_cnid) ? -1 : 1;
43
44         return hfsplus_strcmp(
45                         (const struct hfsplus_unistr *)&k1->attr.key_name,
46                         (const struct hfsplus_unistr *)&k2->attr.key_name);
47 }
48
49 int hfsplus_attr_build_key(struct super_block *sb, hfsplus_btree_key *key,
50                         u32 cnid, const char *name)
51 {
52         int len;
53
54         memset(key, 0, sizeof(struct hfsplus_attr_key));
55         key->attr.cnid = cpu_to_be32(cnid);
56         if (name) {
57                 len = strlen(name);
58                 if (len > HFSPLUS_ATTR_MAX_STRLEN) {
59                         pr_err("invalid xattr name's length\n");
60                         return -EINVAL;
61                 }
62                 hfsplus_asc2uni(sb,
63                                 (struct hfsplus_unistr *)&key->attr.key_name,
64                                 HFSPLUS_ATTR_MAX_STRLEN, name, len);
65                 len = be16_to_cpu(key->attr.key_name.length);
66         } else {
67                 key->attr.key_name.length = 0;
68                 len = 0;
69         }
70
71         /* The length of the key, as stored in key_len field, does not include
72          * the size of the key_len field itself.
73          * So, offsetof(hfsplus_attr_key, key_name) is a trick because
74          * it takes into consideration key_len field (__be16) of
75          * hfsplus_attr_key structure instead of length field (__be16) of
76          * hfsplus_attr_unistr structure.
77          */
78         key->key_len =
79                 cpu_to_be16(offsetof(struct hfsplus_attr_key, key_name) +
80                                 2 * len);
81
82         return 0;
83 }
84
85 void hfsplus_attr_build_key_uni(hfsplus_btree_key *key,
86                                         u32 cnid,
87                                         struct hfsplus_attr_unistr *name)
88 {
89         int ustrlen;
90
91         memset(key, 0, sizeof(struct hfsplus_attr_key));
92         ustrlen = be16_to_cpu(name->length);
93         key->attr.cnid = cpu_to_be32(cnid);
94         key->attr.key_name.length = cpu_to_be16(ustrlen);
95         ustrlen *= 2;
96         memcpy(key->attr.key_name.unicode, name->unicode, ustrlen);
97
98         /* The length of the key, as stored in key_len field, does not include
99          * the size of the key_len field itself.
100          * So, offsetof(hfsplus_attr_key, key_name) is a trick because
101          * it takes into consideration key_len field (__be16) of
102          * hfsplus_attr_key structure instead of length field (__be16) of
103          * hfsplus_attr_unistr structure.
104          */
105         key->key_len =
106                 cpu_to_be16(offsetof(struct hfsplus_attr_key, key_name) +
107                                 ustrlen);
108 }
109
110 hfsplus_attr_entry *hfsplus_alloc_attr_entry(void)
111 {
112         return kmem_cache_alloc(hfsplus_attr_tree_cachep, GFP_KERNEL);
113 }
114
115 void hfsplus_destroy_attr_entry(hfsplus_attr_entry *entry)
116 {
117         if (entry)
118                 kmem_cache_free(hfsplus_attr_tree_cachep, entry);
119 }
120
121 #define HFSPLUS_INVALID_ATTR_RECORD -1
122
123 static int hfsplus_attr_build_record(hfsplus_attr_entry *entry, int record_type,
124                                 u32 cnid, const void *value, size_t size)
125 {
126         if (record_type == HFSPLUS_ATTR_FORK_DATA) {
127                 /*
128                  * Mac OS X supports only inline data attributes.
129                  * Do nothing
130                  */
131                 memset(entry, 0, sizeof(*entry));
132                 return sizeof(struct hfsplus_attr_fork_data);
133         } else if (record_type == HFSPLUS_ATTR_EXTENTS) {
134                 /*
135                  * Mac OS X supports only inline data attributes.
136                  * Do nothing.
137                  */
138                 memset(entry, 0, sizeof(*entry));
139                 return sizeof(struct hfsplus_attr_extents);
140         } else if (record_type == HFSPLUS_ATTR_INLINE_DATA) {
141                 u16 len;
142
143                 memset(entry, 0, sizeof(struct hfsplus_attr_inline_data));
144                 entry->inline_data.record_type = cpu_to_be32(record_type);
145                 if (size <= HFSPLUS_MAX_INLINE_DATA_SIZE)
146                         len = size;
147                 else
148                         return HFSPLUS_INVALID_ATTR_RECORD;
149                 entry->inline_data.length = cpu_to_be16(len);
150                 memcpy(entry->inline_data.raw_bytes, value, len);
151                 /*
152                  * Align len on two-byte boundary.
153                  * It needs to add pad byte if we have odd len.
154                  */
155                 len = round_up(len, 2);
156                 return offsetof(struct hfsplus_attr_inline_data, raw_bytes) +
157                                         len;
158         } else /* invalid input */
159                 memset(entry, 0, sizeof(*entry));
160
161         return HFSPLUS_INVALID_ATTR_RECORD;
162 }
163
164 int hfsplus_find_attr(struct super_block *sb, u32 cnid,
165                         const char *name, struct hfs_find_data *fd)
166 {
167         int err = 0;
168
169         hfs_dbg(ATTR_MOD, "find_attr: %s,%d\n", name ? name : NULL, cnid);
170
171         if (!HFSPLUS_SB(sb)->attr_tree) {
172                 pr_err("attributes file doesn't exist\n");
173                 return -EINVAL;
174         }
175
176         if (name) {
177                 err = hfsplus_attr_build_key(sb, fd->search_key, cnid, name);
178                 if (err)
179                         goto failed_find_attr;
180                 err = hfs_brec_find(fd, hfs_find_rec_by_key);
181                 if (err)
182                         goto failed_find_attr;
183         } else {
184                 err = hfsplus_attr_build_key(sb, fd->search_key, cnid, NULL);
185                 if (err)
186                         goto failed_find_attr;
187                 err = hfs_brec_find(fd, hfs_find_1st_rec_by_cnid);
188                 if (err)
189                         goto failed_find_attr;
190         }
191
192 failed_find_attr:
193         return err;
194 }
195
196 int hfsplus_attr_exists(struct inode *inode, const char *name)
197 {
198         int err = 0;
199         struct super_block *sb = inode->i_sb;
200         struct hfs_find_data fd;
201
202         if (!HFSPLUS_SB(sb)->attr_tree)
203                 return 0;
204
205         err = hfs_find_init(HFSPLUS_SB(sb)->attr_tree, &fd);
206         if (err)
207                 return 0;
208
209         err = hfsplus_find_attr(sb, inode->i_ino, name, &fd);
210         if (err)
211                 goto attr_not_found;
212
213         hfs_find_exit(&fd);
214         return 1;
215
216 attr_not_found:
217         hfs_find_exit(&fd);
218         return 0;
219 }
220
221 int hfsplus_create_attr(struct inode *inode,
222                                 const char *name,
223                                 const void *value, size_t size)
224 {
225         struct super_block *sb = inode->i_sb;
226         struct hfs_find_data fd;
227         hfsplus_attr_entry *entry_ptr;
228         int entry_size;
229         int err;
230
231         hfs_dbg(ATTR_MOD, "create_attr: %s,%ld\n",
232                 name ? name : NULL, inode->i_ino);
233
234         if (!HFSPLUS_SB(sb)->attr_tree) {
235                 pr_err("attributes file doesn't exist\n");
236                 return -EINVAL;
237         }
238
239         entry_ptr = hfsplus_alloc_attr_entry();
240         if (!entry_ptr)
241                 return -ENOMEM;
242
243         err = hfs_find_init(HFSPLUS_SB(sb)->attr_tree, &fd);
244         if (err)
245                 goto failed_init_create_attr;
246
247         if (name) {
248                 err = hfsplus_attr_build_key(sb, fd.search_key,
249                                                 inode->i_ino, name);
250                 if (err)
251                         goto failed_create_attr;
252         } else {
253                 err = -EINVAL;
254                 goto failed_create_attr;
255         }
256
257         /* Mac OS X supports only inline data attributes. */
258         entry_size = hfsplus_attr_build_record(entry_ptr,
259                                         HFSPLUS_ATTR_INLINE_DATA,
260                                         inode->i_ino,
261                                         value, size);
262         if (entry_size == HFSPLUS_INVALID_ATTR_RECORD) {
263                 err = -EINVAL;
264                 goto failed_create_attr;
265         }
266
267         err = hfs_brec_find(&fd, hfs_find_rec_by_key);
268         if (err != -ENOENT) {
269                 if (!err)
270                         err = -EEXIST;
271                 goto failed_create_attr;
272         }
273
274         err = hfs_brec_insert(&fd, entry_ptr, entry_size);
275         if (err)
276                 goto failed_create_attr;
277
278         hfsplus_mark_inode_dirty(inode, HFSPLUS_I_ATTR_DIRTY);
279
280 failed_create_attr:
281         hfs_find_exit(&fd);
282
283 failed_init_create_attr:
284         hfsplus_destroy_attr_entry(entry_ptr);
285         return err;
286 }
287
288 static int __hfsplus_delete_attr(struct inode *inode, u32 cnid,
289                                         struct hfs_find_data *fd)
290 {
291         int err = 0;
292         __be32 found_cnid, record_type;
293
294         hfs_bnode_read(fd->bnode, &found_cnid,
295                         fd->keyoffset +
296                         offsetof(struct hfsplus_attr_key, cnid),
297                         sizeof(__be32));
298         if (cnid != be32_to_cpu(found_cnid))
299                 return -ENOENT;
300
301         hfs_bnode_read(fd->bnode, &record_type,
302                         fd->entryoffset, sizeof(record_type));
303
304         switch (be32_to_cpu(record_type)) {
305         case HFSPLUS_ATTR_INLINE_DATA:
306                 /* All is OK. Do nothing. */
307                 break;
308         case HFSPLUS_ATTR_FORK_DATA:
309         case HFSPLUS_ATTR_EXTENTS:
310                 pr_err("only inline data xattr are supported\n");
311                 return -EOPNOTSUPP;
312         default:
313                 pr_err("invalid extended attribute record\n");
314                 return -ENOENT;
315         }
316
317         err = hfs_brec_remove(fd);
318         if (err)
319                 return err;
320
321         hfsplus_mark_inode_dirty(inode, HFSPLUS_I_ATTR_DIRTY);
322         return err;
323 }
324
325 int hfsplus_delete_attr(struct inode *inode, const char *name)
326 {
327         int err = 0;
328         struct super_block *sb = inode->i_sb;
329         struct hfs_find_data fd;
330
331         hfs_dbg(ATTR_MOD, "delete_attr: %s,%ld\n",
332                 name ? name : NULL, inode->i_ino);
333
334         if (!HFSPLUS_SB(sb)->attr_tree) {
335                 pr_err("attributes file doesn't exist\n");
336                 return -EINVAL;
337         }
338
339         err = hfs_find_init(HFSPLUS_SB(sb)->attr_tree, &fd);
340         if (err)
341                 return err;
342
343         if (name) {
344                 err = hfsplus_attr_build_key(sb, fd.search_key,
345                                                 inode->i_ino, name);
346                 if (err)
347                         goto out;
348         } else {
349                 pr_err("invalid extended attribute name\n");
350                 err = -EINVAL;
351                 goto out;
352         }
353
354         err = hfs_brec_find(&fd, hfs_find_rec_by_key);
355         if (err)
356                 goto out;
357
358         err = __hfsplus_delete_attr(inode, inode->i_ino, &fd);
359         if (err)
360                 goto out;
361
362 out:
363         hfs_find_exit(&fd);
364         return err;
365 }
366
367 int hfsplus_delete_all_attrs(struct inode *dir, u32 cnid)
368 {
369         int err = 0;
370         struct hfs_find_data fd;
371
372         hfs_dbg(ATTR_MOD, "delete_all_attrs: %d\n", cnid);
373
374         if (!HFSPLUS_SB(dir->i_sb)->attr_tree) {
375                 pr_err("attributes file doesn't exist\n");
376                 return -EINVAL;
377         }
378
379         err = hfs_find_init(HFSPLUS_SB(dir->i_sb)->attr_tree, &fd);
380         if (err)
381                 return err;
382
383         for (;;) {
384                 err = hfsplus_find_attr(dir->i_sb, cnid, NULL, &fd);
385                 if (err) {
386                         if (err != -ENOENT)
387                                 pr_err("xattr search failed\n");
388                         goto end_delete_all;
389                 }
390
391                 err = __hfsplus_delete_attr(dir, cnid, &fd);
392                 if (err)
393                         goto end_delete_all;
394         }
395
396 end_delete_all:
397         hfs_find_exit(&fd);
398         return err;
399 }