xref: /linux/fs/ubifs/xattr.c (revision 04b43ea325d21c4c98e831383a1b7d540721898a)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * This file is part of UBIFS.
4  *
5  * Copyright (C) 2006-2008 Nokia Corporation.
6  *
7  * Authors: Artem Bityutskiy (Битюцкий Артём)
8  *          Adrian Hunter
9  */
10 
11 /*
12  * This file implements UBIFS extended attributes support.
13  *
14  * Extended attributes are implemented as regular inodes with attached data,
15  * which limits extended attribute size to UBIFS block size (4KiB). Names of
16  * extended attributes are described by extended attribute entries (xentries),
17  * which are almost identical to directory entries, but have different key type.
18  *
19  * In other words, the situation with extended attributes is very similar to
20  * directories. Indeed, any inode (but of course not xattr inodes) may have a
21  * number of associated xentries, just like directory inodes have associated
22  * directory entries. Extended attribute entries store the name of the extended
23  * attribute, the host inode number, and the extended attribute inode number.
24  * Similarly, direntries store the name, the parent and the target inode
25  * numbers. Thus, most of the common UBIFS mechanisms may be re-used for
26  * extended attributes.
27  *
28  * The number of extended attributes is not limited, but there is Linux
29  * limitation on the maximum possible size of the list of all extended
30  * attributes associated with an inode (%XATTR_LIST_MAX), so UBIFS makes sure
31  * the sum of all extended attribute names of the inode does not exceed that
32  * limit.
33  *
34  * Extended attributes are synchronous, which means they are written to the
35  * flash media synchronously and there is no write-back for extended attribute
36  * inodes. The extended attribute values are not stored in compressed form on
37  * the media.
38  *
39  * Since extended attributes are represented by regular inodes, they are cached
40  * in the VFS inode cache. The xentries are cached in the LNC cache (see
41  * tnc.c).
42  *
43  * ACL support is not implemented.
44  */
45 
46 #include "ubifs.h"
47 #include <linux/fs.h>
48 #include <linux/slab.h>
49 #include <linux/xattr.h>
50 
51 static const struct inode_operations empty_iops;
52 static const struct file_operations empty_fops;
53 
54 /**
55  * create_xattr - create an extended attribute.
56  * @c: UBIFS file-system description object
57  * @host: host inode
58  * @nm: extended attribute name
59  * @value: extended attribute value
60  * @size: size of extended attribute value
61  *
62  * This is a helper function which creates an extended attribute of name @nm
63  * and value @value for inode @host. The host inode is also updated on flash
64  * because the ctime and extended attribute accounting data changes. This
65  * function returns zero in case of success and a negative error code in case
66  * of failure.
67  */
create_xattr(struct ubifs_info * c,struct inode * host,const struct fscrypt_name * nm,const void * value,int size)68 static int create_xattr(struct ubifs_info *c, struct inode *host,
69 			const struct fscrypt_name *nm, const void *value, int size)
70 {
71 	int err, names_len;
72 	struct inode *inode;
73 	struct ubifs_inode *ui, *host_ui = ubifs_inode(host);
74 	struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
75 				.new_ino_d = ALIGN(size, 8), .dirtied_ino = 1,
76 				.dirtied_ino_d = ALIGN(host_ui->data_len, 8) };
77 
78 	if (host_ui->xattr_cnt >= ubifs_xattr_max_cnt(c)) {
79 		ubifs_err(c, "inode %lu already has too many xattrs (%d), cannot create more",
80 			  host->i_ino, host_ui->xattr_cnt);
81 		return -ENOSPC;
82 	}
83 	/*
84 	 * Linux limits the maximum size of the extended attribute names list
85 	 * to %XATTR_LIST_MAX. This means we should not allow creating more
86 	 * extended attributes if the name list becomes larger. This limitation
87 	 * is artificial for UBIFS, though.
88 	 */
89 	names_len = host_ui->xattr_names + host_ui->xattr_cnt + fname_len(nm) + 1;
90 	if (names_len > XATTR_LIST_MAX) {
91 		ubifs_err(c, "cannot add one more xattr name to inode %lu, total names length would become %d, max. is %d",
92 			  host->i_ino, names_len, XATTR_LIST_MAX);
93 		return -ENOSPC;
94 	}
95 
96 	err = ubifs_budget_space(c, &req);
97 	if (err)
98 		return err;
99 
100 	inode = ubifs_new_inode(c, host, S_IFREG | S_IRWXUGO, true);
101 	if (IS_ERR(inode)) {
102 		err = PTR_ERR(inode);
103 		goto out_budg;
104 	}
105 
106 	/* Re-define all operations to be "nothing" */
107 	inode->i_mapping->a_ops = &empty_aops;
108 	inode->i_op = &empty_iops;
109 	inode->i_fop = &empty_fops;
110 
111 	inode->i_flags |= S_SYNC | S_NOATIME | S_NOCMTIME;
112 	ui = ubifs_inode(inode);
113 	ui->xattr = 1;
114 	ui->flags |= UBIFS_XATTR_FL;
115 	ui->data = kmemdup(value, size, GFP_NOFS);
116 	if (!ui->data) {
117 		err = -ENOMEM;
118 		goto out_free;
119 	}
120 	inode->i_size = ui->ui_size = size;
121 	ui->data_len = size;
122 
123 	mutex_lock(&host_ui->ui_mutex);
124 	inode_set_ctime_current(host);
125 	host_ui->xattr_cnt += 1;
126 	host_ui->xattr_size += CALC_DENT_SIZE(fname_len(nm));
127 	host_ui->xattr_size += CALC_XATTR_BYTES(size);
128 	host_ui->xattr_names += fname_len(nm);
129 
130 	/*
131 	 * We handle UBIFS_XATTR_NAME_ENCRYPTION_CONTEXT here because we
132 	 * have to set the UBIFS_CRYPT_FL flag on the host inode.
133 	 * To avoid multiple updates of the same inode in the same operation,
134 	 * let's do it here.
135 	 */
136 	if (strcmp(fname_name(nm), UBIFS_XATTR_NAME_ENCRYPTION_CONTEXT) == 0)
137 		host_ui->flags |= UBIFS_CRYPT_FL;
138 
139 	err = ubifs_jnl_update(c, host, nm, inode, 0, 1, 0);
140 	if (err)
141 		goto out_cancel;
142 	ubifs_set_inode_flags(host);
143 	mutex_unlock(&host_ui->ui_mutex);
144 
145 	ubifs_release_budget(c, &req);
146 	insert_inode_hash(inode);
147 	iput(inode);
148 	return 0;
149 
150 out_cancel:
151 	host_ui->xattr_cnt -= 1;
152 	host_ui->xattr_size -= CALC_DENT_SIZE(fname_len(nm));
153 	host_ui->xattr_size -= CALC_XATTR_BYTES(size);
154 	host_ui->xattr_names -= fname_len(nm);
155 	host_ui->flags &= ~UBIFS_CRYPT_FL;
156 	mutex_unlock(&host_ui->ui_mutex);
157 out_free:
158 	make_bad_inode(inode);
159 	iput(inode);
160 out_budg:
161 	ubifs_release_budget(c, &req);
162 	return err;
163 }
164 
165 /**
166  * change_xattr - change an extended attribute.
167  * @c: UBIFS file-system description object
168  * @host: host inode
169  * @inode: extended attribute inode
170  * @value: extended attribute value
171  * @size: size of extended attribute value
172  *
173  * This helper function changes the value of extended attribute @inode with new
174  * data from @value. Returns zero in case of success and a negative error code
175  * in case of failure.
176  */
change_xattr(struct ubifs_info * c,struct inode * host,struct inode * inode,const void * value,int size)177 static int change_xattr(struct ubifs_info *c, struct inode *host,
178 			struct inode *inode, const void *value, int size)
179 {
180 	int err;
181 	struct ubifs_inode *host_ui = ubifs_inode(host);
182 	struct ubifs_inode *ui = ubifs_inode(inode);
183 	void *buf = NULL;
184 	int old_size;
185 	struct ubifs_budget_req req = { .dirtied_ino = 2,
186 		.dirtied_ino_d = ALIGN(size, 8) + ALIGN(host_ui->data_len, 8) };
187 
188 	ubifs_assert(c, ui->data_len == inode->i_size);
189 	err = ubifs_budget_space(c, &req);
190 	if (err)
191 		return err;
192 
193 	buf = kmemdup(value, size, GFP_NOFS);
194 	if (!buf) {
195 		err = -ENOMEM;
196 		goto out_free;
197 	}
198 	kfree(ui->data);
199 	ui->data = buf;
200 	inode->i_size = ui->ui_size = size;
201 	old_size = ui->data_len;
202 	ui->data_len = size;
203 
204 	mutex_lock(&host_ui->ui_mutex);
205 	inode_set_ctime_current(host);
206 	host_ui->xattr_size -= CALC_XATTR_BYTES(old_size);
207 	host_ui->xattr_size += CALC_XATTR_BYTES(size);
208 
209 	/*
210 	 * It is important to write the host inode after the xattr inode
211 	 * because if the host inode gets synchronized (via 'fsync()'), then
212 	 * the extended attribute inode gets synchronized, because it goes
213 	 * before the host inode in the write-buffer.
214 	 */
215 	err = ubifs_jnl_change_xattr(c, inode, host);
216 	if (err)
217 		goto out_cancel;
218 	mutex_unlock(&host_ui->ui_mutex);
219 
220 	ubifs_release_budget(c, &req);
221 	return 0;
222 
223 out_cancel:
224 	host_ui->xattr_size -= CALC_XATTR_BYTES(size);
225 	host_ui->xattr_size += CALC_XATTR_BYTES(old_size);
226 	mutex_unlock(&host_ui->ui_mutex);
227 	make_bad_inode(inode);
228 out_free:
229 	ubifs_release_budget(c, &req);
230 	return err;
231 }
232 
iget_xattr(struct ubifs_info * c,ino_t inum)233 static struct inode *iget_xattr(struct ubifs_info *c, ino_t inum)
234 {
235 	struct inode *inode;
236 
237 	inode = ubifs_iget(c->vfs_sb, inum);
238 	if (IS_ERR(inode)) {
239 		ubifs_err(c, "dead extended attribute entry, error %d",
240 			  (int)PTR_ERR(inode));
241 		return inode;
242 	}
243 	if (ubifs_inode(inode)->xattr)
244 		return inode;
245 	ubifs_err(c, "corrupt extended attribute entry");
246 	iput(inode);
247 	return ERR_PTR(-EINVAL);
248 }
249 
ubifs_xattr_set(struct inode * host,const char * name,const void * value,size_t size,int flags,bool check_lock)250 int ubifs_xattr_set(struct inode *host, const char *name, const void *value,
251 		    size_t size, int flags, bool check_lock)
252 {
253 	struct inode *inode;
254 	struct ubifs_info *c = host->i_sb->s_fs_info;
255 	struct fscrypt_name nm = { .disk_name = FSTR_INIT((char *)name, strlen(name))};
256 	struct ubifs_dent_node *xent;
257 	union ubifs_key key;
258 	int err;
259 
260 	if (check_lock)
261 		ubifs_assert(c, inode_is_locked(host));
262 
263 	if (size > UBIFS_MAX_INO_DATA)
264 		return -ERANGE;
265 
266 	if (fname_len(&nm) > UBIFS_MAX_NLEN)
267 		return -ENAMETOOLONG;
268 
269 	xent = kmalloc(UBIFS_MAX_XENT_NODE_SZ, GFP_NOFS);
270 	if (!xent)
271 		return -ENOMEM;
272 
273 	down_write(&ubifs_inode(host)->xattr_sem);
274 	/*
275 	 * The extended attribute entries are stored in LNC, so multiple
276 	 * look-ups do not involve reading the flash.
277 	 */
278 	xent_key_init(c, &key, host->i_ino, &nm);
279 	err = ubifs_tnc_lookup_nm(c, &key, xent, &nm);
280 	if (err) {
281 		if (err != -ENOENT)
282 			goto out_free;
283 
284 		if (flags & XATTR_REPLACE)
285 			/* We are asked not to create the xattr */
286 			err = -ENODATA;
287 		else
288 			err = create_xattr(c, host, &nm, value, size);
289 		goto out_free;
290 	}
291 
292 	if (flags & XATTR_CREATE) {
293 		/* We are asked not to replace the xattr */
294 		err = -EEXIST;
295 		goto out_free;
296 	}
297 
298 	inode = iget_xattr(c, le64_to_cpu(xent->inum));
299 	if (IS_ERR(inode)) {
300 		err = PTR_ERR(inode);
301 		goto out_free;
302 	}
303 
304 	err = change_xattr(c, host, inode, value, size);
305 	iput(inode);
306 
307 out_free:
308 	up_write(&ubifs_inode(host)->xattr_sem);
309 	kfree(xent);
310 	return err;
311 }
312 
ubifs_xattr_get(struct inode * host,const char * name,void * buf,size_t size)313 ssize_t ubifs_xattr_get(struct inode *host, const char *name, void *buf,
314 			size_t size)
315 {
316 	struct inode *inode;
317 	struct ubifs_info *c = host->i_sb->s_fs_info;
318 	struct fscrypt_name nm = { .disk_name = FSTR_INIT((char *)name, strlen(name))};
319 	struct ubifs_inode *ui;
320 	struct ubifs_dent_node *xent;
321 	union ubifs_key key;
322 	int err;
323 
324 	if (fname_len(&nm) > UBIFS_MAX_NLEN)
325 		return -ENAMETOOLONG;
326 
327 	xent = kmalloc(UBIFS_MAX_XENT_NODE_SZ, GFP_NOFS);
328 	if (!xent)
329 		return -ENOMEM;
330 
331 	down_read(&ubifs_inode(host)->xattr_sem);
332 	xent_key_init(c, &key, host->i_ino, &nm);
333 	err = ubifs_tnc_lookup_nm(c, &key, xent, &nm);
334 	if (err) {
335 		if (err == -ENOENT)
336 			err = -ENODATA;
337 		goto out_cleanup;
338 	}
339 
340 	inode = iget_xattr(c, le64_to_cpu(xent->inum));
341 	if (IS_ERR(inode)) {
342 		err = PTR_ERR(inode);
343 		goto out_cleanup;
344 	}
345 
346 	ui = ubifs_inode(inode);
347 	ubifs_assert(c, inode->i_size == ui->data_len);
348 	ubifs_assert(c, ubifs_inode(host)->xattr_size > ui->data_len);
349 
350 	if (buf) {
351 		/* If @buf is %NULL we are supposed to return the length */
352 		if (ui->data_len > size) {
353 			err = -ERANGE;
354 			goto out_iput;
355 		}
356 
357 		memcpy(buf, ui->data, ui->data_len);
358 	}
359 	err = ui->data_len;
360 
361 out_iput:
362 	iput(inode);
363 out_cleanup:
364 	up_read(&ubifs_inode(host)->xattr_sem);
365 	kfree(xent);
366 	return err;
367 }
368 
xattr_visible(const char * name)369 static bool xattr_visible(const char *name)
370 {
371 	/* File encryption related xattrs are for internal use only */
372 	if (strcmp(name, UBIFS_XATTR_NAME_ENCRYPTION_CONTEXT) == 0)
373 		return false;
374 
375 	/* Show trusted namespace only for "power" users */
376 	if (strncmp(name, XATTR_TRUSTED_PREFIX,
377 		    XATTR_TRUSTED_PREFIX_LEN) == 0 && !capable(CAP_SYS_ADMIN))
378 		return false;
379 
380 	return true;
381 }
382 
ubifs_listxattr(struct dentry * dentry,char * buffer,size_t size)383 ssize_t ubifs_listxattr(struct dentry *dentry, char *buffer, size_t size)
384 {
385 	union ubifs_key key;
386 	struct inode *host = d_inode(dentry);
387 	struct ubifs_info *c = host->i_sb->s_fs_info;
388 	struct ubifs_inode *host_ui = ubifs_inode(host);
389 	struct ubifs_dent_node *xent, *pxent = NULL;
390 	int err, len, written = 0;
391 	struct fscrypt_name nm = {0};
392 
393 	dbg_gen("ino %lu ('%pd'), buffer size %zd", host->i_ino,
394 		dentry, size);
395 
396 	down_read(&host_ui->xattr_sem);
397 	len = host_ui->xattr_names + host_ui->xattr_cnt;
398 	if (!buffer) {
399 		/*
400 		 * We should return the minimum buffer size which will fit a
401 		 * null-terminated list of all the extended attribute names.
402 		 */
403 		err = len;
404 		goto out_err;
405 	}
406 
407 	if (len > size) {
408 		err = -ERANGE;
409 		goto out_err;
410 	}
411 
412 	lowest_xent_key(c, &key, host->i_ino);
413 	while (1) {
414 		xent = ubifs_tnc_next_ent(c, &key, &nm);
415 		if (IS_ERR(xent)) {
416 			err = PTR_ERR(xent);
417 			break;
418 		}
419 
420 		fname_name(&nm) = xent->name;
421 		fname_len(&nm) = le16_to_cpu(xent->nlen);
422 
423 		if (xattr_visible(xent->name)) {
424 			memcpy(buffer + written, fname_name(&nm), fname_len(&nm) + 1);
425 			written += fname_len(&nm) + 1;
426 		}
427 
428 		kfree(pxent);
429 		pxent = xent;
430 		key_read(c, &xent->key, &key);
431 	}
432 	kfree(pxent);
433 	up_read(&host_ui->xattr_sem);
434 
435 	if (err != -ENOENT) {
436 		ubifs_err(c, "cannot find next direntry, error %d", err);
437 		return err;
438 	}
439 
440 	ubifs_assert(c, written <= size);
441 	return written;
442 
443 out_err:
444 	up_read(&host_ui->xattr_sem);
445 	return err;
446 }
447 
remove_xattr(struct ubifs_info * c,struct inode * host,struct inode * inode,const struct fscrypt_name * nm)448 static int remove_xattr(struct ubifs_info *c, struct inode *host,
449 			struct inode *inode, const struct fscrypt_name *nm)
450 {
451 	int err;
452 	struct ubifs_inode *host_ui = ubifs_inode(host);
453 	struct ubifs_inode *ui = ubifs_inode(inode);
454 	struct ubifs_budget_req req = { .dirtied_ino = 2, .mod_dent = 1,
455 				.dirtied_ino_d = ALIGN(host_ui->data_len, 8) };
456 
457 	ubifs_assert(c, ui->data_len == inode->i_size);
458 
459 	err = ubifs_budget_space(c, &req);
460 	if (err)
461 		return err;
462 
463 	mutex_lock(&host_ui->ui_mutex);
464 	inode_set_ctime_current(host);
465 	host_ui->xattr_cnt -= 1;
466 	host_ui->xattr_size -= CALC_DENT_SIZE(fname_len(nm));
467 	host_ui->xattr_size -= CALC_XATTR_BYTES(ui->data_len);
468 	host_ui->xattr_names -= fname_len(nm);
469 
470 	err = ubifs_jnl_delete_xattr(c, host, inode, nm);
471 	if (err)
472 		goto out_cancel;
473 	mutex_unlock(&host_ui->ui_mutex);
474 
475 	ubifs_release_budget(c, &req);
476 	return 0;
477 
478 out_cancel:
479 	host_ui->xattr_cnt += 1;
480 	host_ui->xattr_size += CALC_DENT_SIZE(fname_len(nm));
481 	host_ui->xattr_size += CALC_XATTR_BYTES(ui->data_len);
482 	host_ui->xattr_names += fname_len(nm);
483 	mutex_unlock(&host_ui->ui_mutex);
484 	ubifs_release_budget(c, &req);
485 	make_bad_inode(inode);
486 	return err;
487 }
488 
ubifs_purge_xattrs(struct inode * host)489 int ubifs_purge_xattrs(struct inode *host)
490 {
491 	union ubifs_key key;
492 	struct ubifs_info *c = host->i_sb->s_fs_info;
493 	struct ubifs_dent_node *xent, *pxent = NULL;
494 	struct inode *xino;
495 	struct fscrypt_name nm = {0};
496 	int err;
497 
498 	if (ubifs_inode(host)->xattr_cnt <= ubifs_xattr_max_cnt(c))
499 		return 0;
500 
501 	ubifs_warn(c, "inode %lu has too many xattrs, doing a non-atomic deletion",
502 		   host->i_ino);
503 
504 	down_write(&ubifs_inode(host)->xattr_sem);
505 	lowest_xent_key(c, &key, host->i_ino);
506 	while (1) {
507 		xent = ubifs_tnc_next_ent(c, &key, &nm);
508 		if (IS_ERR(xent)) {
509 			err = PTR_ERR(xent);
510 			break;
511 		}
512 
513 		fname_name(&nm) = xent->name;
514 		fname_len(&nm) = le16_to_cpu(xent->nlen);
515 
516 		xino = ubifs_iget(c->vfs_sb, le64_to_cpu(xent->inum));
517 		if (IS_ERR(xino)) {
518 			err = PTR_ERR(xino);
519 			ubifs_err(c, "dead directory entry '%s', error %d",
520 				  xent->name, err);
521 			ubifs_ro_mode(c, err);
522 			goto out_err;
523 		}
524 
525 		ubifs_assert(c, ubifs_inode(xino)->xattr);
526 
527 		clear_nlink(xino);
528 		err = remove_xattr(c, host, xino, &nm);
529 		iput(xino);
530 		if (err) {
531 			ubifs_err(c, "cannot remove xattr, error %d", err);
532 			goto out_err;
533 		}
534 
535 		kfree(pxent);
536 		pxent = xent;
537 		key_read(c, &xent->key, &key);
538 	}
539 	kfree(pxent);
540 	up_write(&ubifs_inode(host)->xattr_sem);
541 
542 	if (err != -ENOENT) {
543 		ubifs_err(c, "cannot find next direntry, error %d", err);
544 		return err;
545 	}
546 
547 	return 0;
548 
549 out_err:
550 	kfree(pxent);
551 	kfree(xent);
552 	up_write(&ubifs_inode(host)->xattr_sem);
553 	return err;
554 }
555 
ubifs_xattr_remove(struct inode * host,const char * name)556 static int ubifs_xattr_remove(struct inode *host, const char *name)
557 {
558 	struct inode *inode;
559 	struct ubifs_info *c = host->i_sb->s_fs_info;
560 	struct fscrypt_name nm = { .disk_name = FSTR_INIT((char *)name, strlen(name))};
561 	struct ubifs_dent_node *xent;
562 	union ubifs_key key;
563 	int err;
564 
565 	ubifs_assert(c, inode_is_locked(host));
566 
567 	if (fname_len(&nm) > UBIFS_MAX_NLEN)
568 		return -ENAMETOOLONG;
569 
570 	xent = kmalloc(UBIFS_MAX_XENT_NODE_SZ, GFP_NOFS);
571 	if (!xent)
572 		return -ENOMEM;
573 
574 	down_write(&ubifs_inode(host)->xattr_sem);
575 	xent_key_init(c, &key, host->i_ino, &nm);
576 	err = ubifs_tnc_lookup_nm(c, &key, xent, &nm);
577 	if (err) {
578 		if (err == -ENOENT)
579 			err = -ENODATA;
580 		goto out_free;
581 	}
582 
583 	inode = iget_xattr(c, le64_to_cpu(xent->inum));
584 	if (IS_ERR(inode)) {
585 		err = PTR_ERR(inode);
586 		goto out_free;
587 	}
588 
589 	ubifs_assert(c, inode->i_nlink == 1);
590 	clear_nlink(inode);
591 	err = remove_xattr(c, host, inode, &nm);
592 	if (err)
593 		set_nlink(inode, 1);
594 
595 	/* If @i_nlink is 0, 'iput()' will delete the inode */
596 	iput(inode);
597 
598 out_free:
599 	up_write(&ubifs_inode(host)->xattr_sem);
600 	kfree(xent);
601 	return err;
602 }
603 
604 #ifdef CONFIG_UBIFS_FS_SECURITY
init_xattrs(struct inode * inode,const struct xattr * xattr_array,void * fs_info)605 static int init_xattrs(struct inode *inode, const struct xattr *xattr_array,
606 		      void *fs_info)
607 {
608 	const struct xattr *xattr;
609 	char *name;
610 	int err = 0;
611 
612 	for (xattr = xattr_array; xattr->name != NULL; xattr++) {
613 		name = kmalloc(XATTR_SECURITY_PREFIX_LEN +
614 			       strlen(xattr->name) + 1, GFP_NOFS);
615 		if (!name) {
616 			err = -ENOMEM;
617 			break;
618 		}
619 		strcpy(name, XATTR_SECURITY_PREFIX);
620 		strcpy(name + XATTR_SECURITY_PREFIX_LEN, xattr->name);
621 		/*
622 		 * creating a new inode without holding the inode rwsem,
623 		 * no need to check whether inode is locked.
624 		 */
625 		err = ubifs_xattr_set(inode, name, xattr->value,
626 				      xattr->value_len, 0, false);
627 		kfree(name);
628 		if (err < 0)
629 			break;
630 	}
631 
632 	return err;
633 }
634 
ubifs_init_security(struct inode * dentry,struct inode * inode,const struct qstr * qstr)635 int ubifs_init_security(struct inode *dentry, struct inode *inode,
636 			const struct qstr *qstr)
637 {
638 	int err;
639 
640 	err = security_inode_init_security(inode, dentry, qstr,
641 					   &init_xattrs, NULL);
642 	if (err) {
643 		struct ubifs_info *c = dentry->i_sb->s_fs_info;
644 		ubifs_err(c, "cannot initialize security for inode %lu, error %d",
645 			  inode->i_ino, err);
646 	}
647 	return err;
648 }
649 #endif
650 
xattr_get(const struct xattr_handler * handler,struct dentry * dentry,struct inode * inode,const char * name,void * buffer,size_t size)651 static int xattr_get(const struct xattr_handler *handler,
652 			   struct dentry *dentry, struct inode *inode,
653 			   const char *name, void *buffer, size_t size)
654 {
655 	dbg_gen("xattr '%s', ino %lu ('%pd'), buf size %zd", name,
656 		inode->i_ino, dentry, size);
657 
658 	name = xattr_full_name(handler, name);
659 	return ubifs_xattr_get(inode, name, buffer, size);
660 }
661 
xattr_set(const struct xattr_handler * handler,struct mnt_idmap * idmap,struct dentry * dentry,struct inode * inode,const char * name,const void * value,size_t size,int flags)662 static int xattr_set(const struct xattr_handler *handler,
663 			   struct mnt_idmap *idmap,
664 			   struct dentry *dentry, struct inode *inode,
665 			   const char *name, const void *value,
666 			   size_t size, int flags)
667 {
668 	dbg_gen("xattr '%s', host ino %lu ('%pd'), size %zd",
669 		name, inode->i_ino, dentry, size);
670 
671 	name = xattr_full_name(handler, name);
672 
673 	if (value)
674 		return ubifs_xattr_set(inode, name, value, size, flags, true);
675 	else
676 		return ubifs_xattr_remove(inode, name);
677 }
678 
679 static const struct xattr_handler ubifs_user_xattr_handler = {
680 	.prefix = XATTR_USER_PREFIX,
681 	.get = xattr_get,
682 	.set = xattr_set,
683 };
684 
685 static const struct xattr_handler ubifs_trusted_xattr_handler = {
686 	.prefix = XATTR_TRUSTED_PREFIX,
687 	.get = xattr_get,
688 	.set = xattr_set,
689 };
690 
691 #ifdef CONFIG_UBIFS_FS_SECURITY
692 static const struct xattr_handler ubifs_security_xattr_handler = {
693 	.prefix = XATTR_SECURITY_PREFIX,
694 	.get = xattr_get,
695 	.set = xattr_set,
696 };
697 #endif
698 
699 const struct xattr_handler * const ubifs_xattr_handlers[] = {
700 	&ubifs_user_xattr_handler,
701 	&ubifs_trusted_xattr_handler,
702 #ifdef CONFIG_UBIFS_FS_SECURITY
703 	&ubifs_security_xattr_handler,
704 #endif
705 	NULL
706 };
707