xref: /openbmc/linux/fs/hfsplus/attributes.c (revision e2d413f9)
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 }
387