1/*
2 * This file is part of UBIFS.
3 *
4 * Copyright (C) 2006-2008 Nokia Corporation.
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 as published by
8 * the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13 * more details.
14 *
15 * You should have received a copy of the GNU General Public License along with
16 * this program; if not, write to the Free Software Foundation, Inc., 51
17 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18 *
19 * Authors: Artem Bityutskiy (���������������� ����������)
20 *          Adrian Hunter
21 */
22
23/*
24 * This file implements UBIFS extended attributes support.
25 *
26 * Extended attributes are implemented as regular inodes with attached data,
27 * which limits extended attribute size to UBIFS block size (4KiB). Names of
28 * extended attributes are described by extended attribute entries (xentries),
29 * which are almost identical to directory entries, but have different key type.
30 *
31 * In other words, the situation with extended attributes is very similar to
32 * directories. Indeed, any inode (but of course not xattr inodes) may have a
33 * number of associated xentries, just like directory inodes have associated
34 * directory entries. Extended attribute entries store the name of the extended
35 * attribute, the host inode number, and the extended attribute inode number.
36 * Similarly, direntries store the name, the parent and the target inode
37 * numbers. Thus, most of the common UBIFS mechanisms may be re-used for
38 * extended attributes.
39 *
40 * The number of extended attributes is not limited, but there is Linux
41 * limitation on the maximum possible size of the list of all extended
42 * attributes associated with an inode (%XATTR_LIST_MAX), so UBIFS makes sure
43 * the sum of all extended attribute names of the inode does not exceed that
44 * limit.
45 *
46 * Extended attributes are synchronous, which means they are written to the
47 * flash media synchronously and there is no write-back for extended attribute
48 * inodes. The extended attribute values are not stored in compressed form on
49 * the media.
50 *
51 * Since extended attributes are represented by regular inodes, they are cached
52 * in the VFS inode cache. The xentries are cached in the LNC cache (see
53 * tnc.c).
54 *
55 * ACL support is not implemented.
56 */
57
58#include "ubifs.h"
59#include <linux/slab.h>
60#include <linux/xattr.h>
61#include <linux/posix_acl_xattr.h>
62
63/*
64 * Limit the number of extended attributes per inode so that the total size
65 * (@xattr_size) is guaranteeded to fit in an 'unsigned int'.
66 */
67#define MAX_XATTRS_PER_INODE 65535
68
69/*
70 * Extended attribute type constants.
71 *
72 * USER_XATTR: user extended attribute ("user.*")
73 * TRUSTED_XATTR: trusted extended attribute ("trusted.*)
74 * SECURITY_XATTR: security extended attribute ("security.*")
75 */
76enum {
77	USER_XATTR,
78	TRUSTED_XATTR,
79	SECURITY_XATTR,
80};
81
82static const struct inode_operations none_inode_operations;
83static const struct address_space_operations none_address_operations;
84static const struct file_operations none_file_operations;
85
86/**
87 * create_xattr - create an extended attribute.
88 * @c: UBIFS file-system description object
89 * @host: host inode
90 * @nm: extended attribute name
91 * @value: extended attribute value
92 * @size: size of extended attribute value
93 *
94 * This is a helper function which creates an extended attribute of name @nm
95 * and value @value for inode @host. The host inode is also updated on flash
96 * because the ctime and extended attribute accounting data changes. This
97 * function returns zero in case of success and a negative error code in case
98 * of failure.
99 */
100static int create_xattr(struct ubifs_info *c, struct inode *host,
101			const struct qstr *nm, const void *value, int size)
102{
103	int err;
104	struct inode *inode;
105	struct ubifs_inode *ui, *host_ui = ubifs_inode(host);
106	struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
107				.new_ino_d = ALIGN(size, 8), .dirtied_ino = 1,
108				.dirtied_ino_d = ALIGN(host_ui->data_len, 8) };
109
110	if (host_ui->xattr_cnt >= MAX_XATTRS_PER_INODE)
111		return -ENOSPC;
112	/*
113	 * Linux limits the maximum size of the extended attribute names list
114	 * to %XATTR_LIST_MAX. This means we should not allow creating more
115	 * extended attributes if the name list becomes larger. This limitation
116	 * is artificial for UBIFS, though.
117	 */
118	if (host_ui->xattr_names + host_ui->xattr_cnt +
119					nm->len + 1 > XATTR_LIST_MAX)
120		return -ENOSPC;
121
122	err = ubifs_budget_space(c, &req);
123	if (err)
124		return err;
125
126	inode = ubifs_new_inode(c, host, S_IFREG | S_IRWXUGO);
127	if (IS_ERR(inode)) {
128		err = PTR_ERR(inode);
129		goto out_budg;
130	}
131
132	/* Re-define all operations to be "nothing" */
133	inode->i_mapping->a_ops = &none_address_operations;
134	inode->i_op = &none_inode_operations;
135	inode->i_fop = &none_file_operations;
136
137	inode->i_flags |= S_SYNC | S_NOATIME | S_NOCMTIME | S_NOQUOTA;
138	ui = ubifs_inode(inode);
139	ui->xattr = 1;
140	ui->flags |= UBIFS_XATTR_FL;
141	ui->data = kmalloc(size, GFP_NOFS);
142	if (!ui->data) {
143		err = -ENOMEM;
144		goto out_free;
145	}
146	memcpy(ui->data, value, size);
147	inode->i_size = ui->ui_size = size;
148	ui->data_len = size;
149
150	mutex_lock(&host_ui->ui_mutex);
151	host->i_ctime = ubifs_current_time(host);
152	host_ui->xattr_cnt += 1;
153	host_ui->xattr_size += CALC_DENT_SIZE(nm->len);
154	host_ui->xattr_size += CALC_XATTR_BYTES(size);
155	host_ui->xattr_names += nm->len;
156
157	err = ubifs_jnl_update(c, host, nm, inode, 0, 1);
158	if (err)
159		goto out_cancel;
160	mutex_unlock(&host_ui->ui_mutex);
161
162	ubifs_release_budget(c, &req);
163	insert_inode_hash(inode);
164	iput(inode);
165	return 0;
166
167out_cancel:
168	host_ui->xattr_cnt -= 1;
169	host_ui->xattr_size -= CALC_DENT_SIZE(nm->len);
170	host_ui->xattr_size -= CALC_XATTR_BYTES(size);
171	mutex_unlock(&host_ui->ui_mutex);
172out_free:
173	make_bad_inode(inode);
174	iput(inode);
175out_budg:
176	ubifs_release_budget(c, &req);
177	return err;
178}
179
180/**
181 * change_xattr - change an extended attribute.
182 * @c: UBIFS file-system description object
183 * @host: host inode
184 * @inode: extended attribute inode
185 * @value: extended attribute value
186 * @size: size of extended attribute value
187 *
188 * This helper function changes the value of extended attribute @inode with new
189 * data from @value. Returns zero in case of success and a negative error code
190 * in case of failure.
191 */
192static int change_xattr(struct ubifs_info *c, struct inode *host,
193			struct inode *inode, const void *value, int size)
194{
195	int err;
196	struct ubifs_inode *host_ui = ubifs_inode(host);
197	struct ubifs_inode *ui = ubifs_inode(inode);
198	struct ubifs_budget_req req = { .dirtied_ino = 2,
199		.dirtied_ino_d = ALIGN(size, 8) + ALIGN(host_ui->data_len, 8) };
200
201	ubifs_assert(ui->data_len == inode->i_size);
202	err = ubifs_budget_space(c, &req);
203	if (err)
204		return err;
205
206	kfree(ui->data);
207	ui->data = kmalloc(size, GFP_NOFS);
208	if (!ui->data) {
209		err = -ENOMEM;
210		goto out_free;
211	}
212	memcpy(ui->data, value, size);
213	inode->i_size = ui->ui_size = size;
214	ui->data_len = size;
215
216	mutex_lock(&host_ui->ui_mutex);
217	host->i_ctime = ubifs_current_time(host);
218	host_ui->xattr_size -= CALC_XATTR_BYTES(ui->data_len);
219	host_ui->xattr_size += CALC_XATTR_BYTES(size);
220
221	/*
222	 * It is important to write the host inode after the xattr inode
223	 * because if the host inode gets synchronized (via 'fsync()'), then
224	 * the extended attribute inode gets synchronized, because it goes
225	 * before the host inode in the write-buffer.
226	 */
227	err = ubifs_jnl_change_xattr(c, inode, host);
228	if (err)
229		goto out_cancel;
230	mutex_unlock(&host_ui->ui_mutex);
231
232	ubifs_release_budget(c, &req);
233	return 0;
234
235out_cancel:
236	host_ui->xattr_size -= CALC_XATTR_BYTES(size);
237	host_ui->xattr_size += CALC_XATTR_BYTES(ui->data_len);
238	mutex_unlock(&host_ui->ui_mutex);
239	make_bad_inode(inode);
240out_free:
241	ubifs_release_budget(c, &req);
242	return err;
243}
244
245/**
246 * check_namespace - check extended attribute name-space.
247 * @nm: extended attribute name
248 *
249 * This function makes sure the extended attribute name belongs to one of the
250 * supported extended attribute name-spaces. Returns name-space index in case
251 * of success and a negative error code in case of failure.
252 */
253static int check_namespace(const struct qstr *nm)
254{
255	int type;
256
257	if (nm->len > UBIFS_MAX_NLEN)
258		return -ENAMETOOLONG;
259
260	if (!strncmp(nm->name, XATTR_TRUSTED_PREFIX,
261		     XATTR_TRUSTED_PREFIX_LEN)) {
262		if (nm->name[sizeof(XATTR_TRUSTED_PREFIX) - 1] == '\0')
263			return -EINVAL;
264		type = TRUSTED_XATTR;
265	} else if (!strncmp(nm->name, XATTR_USER_PREFIX,
266				      XATTR_USER_PREFIX_LEN)) {
267		if (nm->name[XATTR_USER_PREFIX_LEN] == '\0')
268			return -EINVAL;
269		type = USER_XATTR;
270	} else if (!strncmp(nm->name, XATTR_SECURITY_PREFIX,
271				     XATTR_SECURITY_PREFIX_LEN)) {
272		if (nm->name[sizeof(XATTR_SECURITY_PREFIX) - 1] == '\0')
273			return -EINVAL;
274		type = SECURITY_XATTR;
275	} else
276		return -EOPNOTSUPP;
277
278	return type;
279}
280
281static struct inode *iget_xattr(struct ubifs_info *c, ino_t inum)
282{
283	struct inode *inode;
284
285	inode = ubifs_iget(c->vfs_sb, inum);
286	if (IS_ERR(inode)) {
287		ubifs_err("dead extended attribute entry, error %d",
288			  (int)PTR_ERR(inode));
289		return inode;
290	}
291	if (ubifs_inode(inode)->xattr)
292		return inode;
293	ubifs_err("corrupt extended attribute entry");
294	iput(inode);
295	return ERR_PTR(-EINVAL);
296}
297
298int ubifs_setxattr(struct dentry *dentry, const char *name,
299		   const void *value, size_t size, int flags)
300{
301	struct inode *inode, *host = dentry->d_inode;
302	struct ubifs_info *c = host->i_sb->s_fs_info;
303	struct qstr nm = { .name = name, .len = strlen(name) };
304	struct ubifs_dent_node *xent;
305	union ubifs_key key;
306	int err, type;
307
308	dbg_gen("xattr '%s', host ino %lu ('%.*s'), size %zd", name,
309		host->i_ino, dentry->d_name.len, dentry->d_name.name, size);
310	ubifs_assert(mutex_is_locked(&host->i_mutex));
311
312	if (size > UBIFS_MAX_INO_DATA)
313		return -ERANGE;
314
315	type = check_namespace(&nm);
316	if (type < 0)
317		return type;
318
319	xent = kmalloc(UBIFS_MAX_XENT_NODE_SZ, GFP_NOFS);
320	if (!xent)
321		return -ENOMEM;
322
323	/*
324	 * The extended attribute entries are stored in LNC, so multiple
325	 * look-ups do not involve reading the flash.
326	 */
327	xent_key_init(c, &key, host->i_ino, &nm);
328	err = ubifs_tnc_lookup_nm(c, &key, xent, &nm);
329	if (err) {
330		if (err != -ENOENT)
331			goto out_free;
332
333		if (flags & XATTR_REPLACE)
334			/* We are asked not to create the xattr */
335			err = -ENODATA;
336		else
337			err = create_xattr(c, host, &nm, value, size);
338		goto out_free;
339	}
340
341	if (flags & XATTR_CREATE) {
342		/* We are asked not to replace the xattr */
343		err = -EEXIST;
344		goto out_free;
345	}
346
347	inode = iget_xattr(c, le64_to_cpu(xent->inum));
348	if (IS_ERR(inode)) {
349		err = PTR_ERR(inode);
350		goto out_free;
351	}
352
353	err = change_xattr(c, host, inode, value, size);
354	iput(inode);
355
356out_free:
357	kfree(xent);
358	return err;
359}
360
361ssize_t ubifs_getxattr(struct dentry *dentry, const char *name, void *buf,
362		       size_t size)
363{
364	struct inode *inode, *host = dentry->d_inode;
365	struct ubifs_info *c = host->i_sb->s_fs_info;
366	struct qstr nm = { .name = name, .len = strlen(name) };
367	struct ubifs_inode *ui;
368	struct ubifs_dent_node *xent;
369	union ubifs_key key;
370	int err;
371
372	dbg_gen("xattr '%s', ino %lu ('%.*s'), buf size %zd", name,
373		host->i_ino, dentry->d_name.len, dentry->d_name.name, size);
374
375	err = check_namespace(&nm);
376	if (err < 0)
377		return err;
378
379	xent = kmalloc(UBIFS_MAX_XENT_NODE_SZ, GFP_NOFS);
380	if (!xent)
381		return -ENOMEM;
382
383	xent_key_init(c, &key, host->i_ino, &nm);
384	err = ubifs_tnc_lookup_nm(c, &key, xent, &nm);
385	if (err) {
386		if (err == -ENOENT)
387			err = -ENODATA;
388		goto out_unlock;
389	}
390
391	inode = iget_xattr(c, le64_to_cpu(xent->inum));
392	if (IS_ERR(inode)) {
393		err = PTR_ERR(inode);
394		goto out_unlock;
395	}
396
397	ui = ubifs_inode(inode);
398	ubifs_assert(inode->i_size == ui->data_len);
399	ubifs_assert(ubifs_inode(host)->xattr_size > ui->data_len);
400
401	if (buf) {
402		/* If @buf is %NULL we are supposed to return the length */
403		if (ui->data_len > size) {
404			dbg_err("buffer size %zd, xattr len %d",
405				size, ui->data_len);
406			err = -ERANGE;
407			goto out_iput;
408		}
409
410		memcpy(buf, ui->data, ui->data_len);
411	}
412	err = ui->data_len;
413
414out_iput:
415	iput(inode);
416out_unlock:
417	kfree(xent);
418	return err;
419}
420
421ssize_t ubifs_listxattr(struct dentry *dentry, char *buffer, size_t size)
422{
423	union ubifs_key key;
424	struct inode *host = dentry->d_inode;
425	struct ubifs_info *c = host->i_sb->s_fs_info;
426	struct ubifs_inode *host_ui = ubifs_inode(host);
427	struct ubifs_dent_node *xent, *pxent = NULL;
428	int err, len, written = 0;
429	struct qstr nm = { .name = NULL };
430
431	dbg_gen("ino %lu ('%.*s'), buffer size %zd", host->i_ino,
432		dentry->d_name.len, dentry->d_name.name, size);
433
434	len = host_ui->xattr_names + host_ui->xattr_cnt;
435	if (!buffer)
436		/*
437		 * We should return the minimum buffer size which will fit a
438		 * null-terminated list of all the extended attribute names.
439		 */
440		return len;
441
442	if (len > size)
443		return -ERANGE;
444
445	lowest_xent_key(c, &key, host->i_ino);
446	while (1) {
447		int type;
448
449		xent = ubifs_tnc_next_ent(c, &key, &nm);
450		if (IS_ERR(xent)) {
451			err = PTR_ERR(xent);
452			break;
453		}
454
455		nm.name = xent->name;
456		nm.len = le16_to_cpu(xent->nlen);
457
458		type = check_namespace(&nm);
459		if (unlikely(type < 0)) {
460			err = type;
461			break;
462		}
463
464		/* Show trusted namespace only for "power" users */
465		if (type != TRUSTED_XATTR || capable(CAP_SYS_ADMIN)) {
466			memcpy(buffer + written, nm.name, nm.len + 1);
467			written += nm.len + 1;
468		}
469
470		kfree(pxent);
471		pxent = xent;
472		key_read(c, &xent->key, &key);
473	}
474
475	kfree(pxent);
476	if (err != -ENOENT) {
477		ubifs_err("cannot find next direntry, error %d", err);
478		return err;
479	}
480
481	ubifs_assert(written <= size);
482	return written;
483}
484
485static int remove_xattr(struct ubifs_info *c, struct inode *host,
486			struct inode *inode, const struct qstr *nm)
487{
488	int err;
489	struct ubifs_inode *host_ui = ubifs_inode(host);
490	struct ubifs_inode *ui = ubifs_inode(inode);
491	struct ubifs_budget_req req = { .dirtied_ino = 2, .mod_dent = 1,
492				.dirtied_ino_d = ALIGN(host_ui->data_len, 8) };
493
494	ubifs_assert(ui->data_len == inode->i_size);
495
496	err = ubifs_budget_space(c, &req);
497	if (err)
498		return err;
499
500	mutex_lock(&host_ui->ui_mutex);
501	host->i_ctime = ubifs_current_time(host);
502	host_ui->xattr_cnt -= 1;
503	host_ui->xattr_size -= CALC_DENT_SIZE(nm->len);
504	host_ui->xattr_size -= CALC_XATTR_BYTES(ui->data_len);
505	host_ui->xattr_names -= nm->len;
506
507	err = ubifs_jnl_delete_xattr(c, host, inode, nm);
508	if (err)
509		goto out_cancel;
510	mutex_unlock(&host_ui->ui_mutex);
511
512	ubifs_release_budget(c, &req);
513	return 0;
514
515out_cancel:
516	host_ui->xattr_cnt += 1;
517	host_ui->xattr_size += CALC_DENT_SIZE(nm->len);
518	host_ui->xattr_size += CALC_XATTR_BYTES(ui->data_len);
519	mutex_unlock(&host_ui->ui_mutex);
520	ubifs_release_budget(c, &req);
521	make_bad_inode(inode);
522	return err;
523}
524
525int ubifs_removexattr(struct dentry *dentry, const char *name)
526{
527	struct inode *inode, *host = dentry->d_inode;
528	struct ubifs_info *c = host->i_sb->s_fs_info;
529	struct qstr nm = { .name = name, .len = strlen(name) };
530	struct ubifs_dent_node *xent;
531	union ubifs_key key;
532	int err;
533
534	dbg_gen("xattr '%s', ino %lu ('%.*s')", name,
535		host->i_ino, dentry->d_name.len, dentry->d_name.name);
536	ubifs_assert(mutex_is_locked(&host->i_mutex));
537
538	err = check_namespace(&nm);
539	if (err < 0)
540		return err;
541
542	xent = kmalloc(UBIFS_MAX_XENT_NODE_SZ, GFP_NOFS);
543	if (!xent)
544		return -ENOMEM;
545
546	xent_key_init(c, &key, host->i_ino, &nm);
547	err = ubifs_tnc_lookup_nm(c, &key, xent, &nm);
548	if (err) {
549		if (err == -ENOENT)
550			err = -ENODATA;
551		goto out_free;
552	}
553
554	inode = iget_xattr(c, le64_to_cpu(xent->inum));
555	if (IS_ERR(inode)) {
556		err = PTR_ERR(inode);
557		goto out_free;
558	}
559
560	ubifs_assert(inode->i_nlink == 1);
561	inode->i_nlink = 0;
562	err = remove_xattr(c, host, inode, &nm);
563	if (err)
564		inode->i_nlink = 1;
565
566	/* If @i_nlink is 0, 'iput()' will delete the inode */
567	iput(inode);
568
569out_free:
570	kfree(xent);
571	return err;
572}
573