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