blob: b5fc27969e9d31bc0a9e951cc50a83c66d9c1352 [file] [log] [blame]
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001/*
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
Al Viro073aaa12009-06-09 12:11:54 -040058#include "ubifs.h"
Jens Axboe7dcda1c2011-04-05 23:51:48 +020059#include <linux/fs.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090060#include <linux/slab.h>
Artem Bityutskiy1e517642008-07-14 19:08:37 +030061#include <linux/xattr.h>
Artem Bityutskiy1e517642008-07-14 19:08:37 +030062
63/*
64 * Limit the number of extended attributes per inode so that the total size
Artem Bityutskiyc78c7e32008-08-12 16:30:12 +030065 * (@xattr_size) is guaranteeded to fit in an 'unsigned int'.
Artem Bityutskiy1e517642008-07-14 19:08:37 +030066 */
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
Sedat Dilek14ffd5d2011-04-04 01:55:39 +020082static const struct inode_operations empty_iops;
83static const struct file_operations empty_fops;
Artem Bityutskiy1e517642008-07-14 19:08:37 +030084
85/**
86 * create_xattr - create an extended attribute.
87 * @c: UBIFS file-system description object
88 * @host: host inode
89 * @nm: extended attribute name
90 * @value: extended attribute value
91 * @size: size of extended attribute value
92 *
93 * This is a helper function which creates an extended attribute of name @nm
94 * and value @value for inode @host. The host inode is also updated on flash
95 * because the ctime and extended attribute accounting data changes. This
96 * function returns zero in case of success and a negative error code in case
97 * of failure.
98 */
99static int create_xattr(struct ubifs_info *c, struct inode *host,
100 const struct qstr *nm, const void *value, int size)
101{
Subodh Nijsurefee17562014-10-31 13:50:31 -0500102 int err, names_len;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300103 struct inode *inode;
104 struct ubifs_inode *ui, *host_ui = ubifs_inode(host);
105 struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
Zoltan Sogor5acd6ff2008-08-12 13:54:54 +0300106 .new_ino_d = ALIGN(size, 8), .dirtied_ino = 1,
107 .dirtied_ino_d = ALIGN(host_ui->data_len, 8) };
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300108
Subodh Nijsurefee17562014-10-31 13:50:31 -0500109 if (host_ui->xattr_cnt >= MAX_XATTRS_PER_INODE) {
Sheng Yong235c3622015-03-20 10:39:42 +0000110 ubifs_err(c, "inode %lu already has too many xattrs (%d), cannot create more",
Subodh Nijsurefee17562014-10-31 13:50:31 -0500111 host->i_ino, host_ui->xattr_cnt);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300112 return -ENOSPC;
Subodh Nijsurefee17562014-10-31 13:50:31 -0500113 }
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300114 /*
115 * Linux limits the maximum size of the extended attribute names list
Artem Bityutskiyc78c7e32008-08-12 16:30:12 +0300116 * to %XATTR_LIST_MAX. This means we should not allow creating more
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300117 * extended attributes if the name list becomes larger. This limitation
118 * is artificial for UBIFS, though.
119 */
Subodh Nijsurefee17562014-10-31 13:50:31 -0500120 names_len = host_ui->xattr_names + host_ui->xattr_cnt + nm->len + 1;
121 if (names_len > XATTR_LIST_MAX) {
Sheng Yong235c3622015-03-20 10:39:42 +0000122 ubifs_err(c, "cannot add one more xattr name to inode %lu, total names length would become %d, max. is %d",
Subodh Nijsurefee17562014-10-31 13:50:31 -0500123 host->i_ino, names_len, XATTR_LIST_MAX);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300124 return -ENOSPC;
Subodh Nijsurefee17562014-10-31 13:50:31 -0500125 }
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300126
127 err = ubifs_budget_space(c, &req);
128 if (err)
129 return err;
130
131 inode = ubifs_new_inode(c, host, S_IFREG | S_IRWXUGO);
132 if (IS_ERR(inode)) {
133 err = PTR_ERR(inode);
134 goto out_budg;
135 }
136
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300137 /* Re-define all operations to be "nothing" */
Jens Axboe7dcda1c2011-04-05 23:51:48 +0200138 inode->i_mapping->a_ops = &empty_aops;
Sedat Dilek14ffd5d2011-04-04 01:55:39 +0200139 inode->i_op = &empty_iops;
140 inode->i_fop = &empty_fops;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300141
142 inode->i_flags |= S_SYNC | S_NOATIME | S_NOCMTIME | S_NOQUOTA;
143 ui = ubifs_inode(inode);
144 ui->xattr = 1;
145 ui->flags |= UBIFS_XATTR_FL;
Thomas Meyereaecf432011-11-18 00:00:52 +0100146 ui->data = kmemdup(value, size, GFP_NOFS);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300147 if (!ui->data) {
148 err = -ENOMEM;
Artem Bityutskiyc78c7e32008-08-12 16:30:12 +0300149 goto out_free;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300150 }
Artem Bityutskiyc78c7e32008-08-12 16:30:12 +0300151 inode->i_size = ui->ui_size = size;
152 ui->data_len = size;
153
154 mutex_lock(&host_ui->ui_mutex);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300155 host->i_ctime = ubifs_current_time(host);
156 host_ui->xattr_cnt += 1;
157 host_ui->xattr_size += CALC_DENT_SIZE(nm->len);
158 host_ui->xattr_size += CALC_XATTR_BYTES(size);
159 host_ui->xattr_names += nm->len;
160
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300161 err = ubifs_jnl_update(c, host, nm, inode, 0, 1);
162 if (err)
163 goto out_cancel;
164 mutex_unlock(&host_ui->ui_mutex);
165
166 ubifs_release_budget(c, &req);
167 insert_inode_hash(inode);
168 iput(inode);
169 return 0;
170
171out_cancel:
172 host_ui->xattr_cnt -= 1;
173 host_ui->xattr_size -= CALC_DENT_SIZE(nm->len);
174 host_ui->xattr_size -= CALC_XATTR_BYTES(size);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300175 mutex_unlock(&host_ui->ui_mutex);
Artem Bityutskiyc78c7e32008-08-12 16:30:12 +0300176out_free:
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300177 make_bad_inode(inode);
178 iput(inode);
179out_budg:
180 ubifs_release_budget(c, &req);
181 return err;
182}
183
184/**
185 * change_xattr - change an extended attribute.
186 * @c: UBIFS file-system description object
187 * @host: host inode
188 * @inode: extended attribute inode
189 * @value: extended attribute value
190 * @size: size of extended attribute value
191 *
192 * This helper function changes the value of extended attribute @inode with new
193 * data from @value. Returns zero in case of success and a negative error code
194 * in case of failure.
195 */
196static int change_xattr(struct ubifs_info *c, struct inode *host,
197 struct inode *inode, const void *value, int size)
198{
199 int err;
200 struct ubifs_inode *host_ui = ubifs_inode(host);
201 struct ubifs_inode *ui = ubifs_inode(inode);
Dongsheng Yangab92a202015-08-18 12:38:36 +0800202 void *buf = NULL;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300203 struct ubifs_budget_req req = { .dirtied_ino = 2,
Zoltan Sogor5acd6ff2008-08-12 13:54:54 +0300204 .dirtied_ino_d = ALIGN(size, 8) + ALIGN(host_ui->data_len, 8) };
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300205
206 ubifs_assert(ui->data_len == inode->i_size);
207 err = ubifs_budget_space(c, &req);
208 if (err)
209 return err;
210
Dongsheng Yangab92a202015-08-18 12:38:36 +0800211 buf = kmemdup(value, size, GFP_NOFS);
212 if (!buf) {
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300213 err = -ENOMEM;
Artem Bityutskiyc78c7e32008-08-12 16:30:12 +0300214 goto out_free;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300215 }
Dongsheng Yangab92a202015-08-18 12:38:36 +0800216 mutex_lock(&ui->ui_mutex);
217 kfree(ui->data);
218 ui->data = buf;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300219 inode->i_size = ui->ui_size = size;
220 ui->data_len = size;
Dongsheng Yangab92a202015-08-18 12:38:36 +0800221 mutex_unlock(&ui->ui_mutex);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300222
Artem Bityutskiyc78c7e32008-08-12 16:30:12 +0300223 mutex_lock(&host_ui->ui_mutex);
224 host->i_ctime = ubifs_current_time(host);
225 host_ui->xattr_size -= CALC_XATTR_BYTES(ui->data_len);
226 host_ui->xattr_size += CALC_XATTR_BYTES(size);
227
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300228 /*
229 * It is important to write the host inode after the xattr inode
230 * because if the host inode gets synchronized (via 'fsync()'), then
231 * the extended attribute inode gets synchronized, because it goes
232 * before the host inode in the write-buffer.
233 */
234 err = ubifs_jnl_change_xattr(c, inode, host);
235 if (err)
236 goto out_cancel;
237 mutex_unlock(&host_ui->ui_mutex);
238
239 ubifs_release_budget(c, &req);
240 return 0;
241
242out_cancel:
243 host_ui->xattr_size -= CALC_XATTR_BYTES(size);
244 host_ui->xattr_size += CALC_XATTR_BYTES(ui->data_len);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300245 mutex_unlock(&host_ui->ui_mutex);
Artem Bityutskiyc78c7e32008-08-12 16:30:12 +0300246 make_bad_inode(inode);
247out_free:
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300248 ubifs_release_budget(c, &req);
249 return err;
250}
251
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300252static struct inode *iget_xattr(struct ubifs_info *c, ino_t inum)
253{
254 struct inode *inode;
255
256 inode = ubifs_iget(c->vfs_sb, inum);
257 if (IS_ERR(inode)) {
Sheng Yong235c3622015-03-20 10:39:42 +0000258 ubifs_err(c, "dead extended attribute entry, error %d",
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300259 (int)PTR_ERR(inode));
260 return inode;
261 }
262 if (ubifs_inode(inode)->xattr)
263 return inode;
Sheng Yong235c3622015-03-20 10:39:42 +0000264 ubifs_err(c, "corrupt extended attribute entry");
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300265 iput(inode);
266 return ERR_PTR(-EINVAL);
267}
268
Andreas Gruenbacher2b88fc22016-04-22 19:14:00 +0200269static int __ubifs_setxattr(struct inode *host, const char *name,
270 const void *value, size_t size, int flags)
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300271{
Subodh Nijsure895d9db22014-10-31 13:50:29 -0500272 struct inode *inode;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300273 struct ubifs_info *c = host->i_sb->s_fs_info;
Linus Torvalds26fe5752012-05-10 13:14:12 -0700274 struct qstr nm = QSTR_INIT(name, strlen(name));
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300275 struct ubifs_dent_node *xent;
276 union ubifs_key key;
Andreas Gruenbacher2b88fc22016-04-22 19:14:00 +0200277 int err;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300278
Al Viro59551022016-01-22 15:40:57 -0500279 ubifs_assert(inode_is_locked(host));
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300280
281 if (size > UBIFS_MAX_INO_DATA)
282 return -ERANGE;
283
Andreas Gruenbacher2b88fc22016-04-22 19:14:00 +0200284 if (nm.len > UBIFS_MAX_NLEN)
285 return -ENAMETOOLONG;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300286
287 xent = kmalloc(UBIFS_MAX_XENT_NODE_SZ, GFP_NOFS);
288 if (!xent)
289 return -ENOMEM;
290
291 /*
292 * The extended attribute entries are stored in LNC, so multiple
293 * look-ups do not involve reading the flash.
294 */
295 xent_key_init(c, &key, host->i_ino, &nm);
296 err = ubifs_tnc_lookup_nm(c, &key, xent, &nm);
297 if (err) {
298 if (err != -ENOENT)
299 goto out_free;
300
301 if (flags & XATTR_REPLACE)
302 /* We are asked not to create the xattr */
303 err = -ENODATA;
304 else
305 err = create_xattr(c, host, &nm, value, size);
306 goto out_free;
307 }
308
309 if (flags & XATTR_CREATE) {
310 /* We are asked not to replace the xattr */
311 err = -EEXIST;
312 goto out_free;
313 }
314
315 inode = iget_xattr(c, le64_to_cpu(xent->inum));
316 if (IS_ERR(inode)) {
317 err = PTR_ERR(inode);
318 goto out_free;
319 }
320
321 err = change_xattr(c, host, inode, value, size);
322 iput(inode);
323
324out_free:
325 kfree(xent);
326 return err;
327}
328
Andreas Gruenbacher2b88fc22016-04-22 19:14:00 +0200329static ssize_t __ubifs_getxattr(struct inode *host, const char *name,
330 void *buf, size_t size)
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300331{
Al Viroce23e642016-04-11 00:48:00 -0400332 struct inode *inode;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300333 struct ubifs_info *c = host->i_sb->s_fs_info;
Linus Torvalds26fe5752012-05-10 13:14:12 -0700334 struct qstr nm = QSTR_INIT(name, strlen(name));
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300335 struct ubifs_inode *ui;
336 struct ubifs_dent_node *xent;
337 union ubifs_key key;
338 int err;
339
Andreas Gruenbacher2b88fc22016-04-22 19:14:00 +0200340 if (nm.len > UBIFS_MAX_NLEN)
341 return -ENAMETOOLONG;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300342
343 xent = kmalloc(UBIFS_MAX_XENT_NODE_SZ, GFP_NOFS);
344 if (!xent)
345 return -ENOMEM;
346
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300347 xent_key_init(c, &key, host->i_ino, &nm);
348 err = ubifs_tnc_lookup_nm(c, &key, xent, &nm);
349 if (err) {
350 if (err == -ENOENT)
351 err = -ENODATA;
352 goto out_unlock;
353 }
354
355 inode = iget_xattr(c, le64_to_cpu(xent->inum));
356 if (IS_ERR(inode)) {
357 err = PTR_ERR(inode);
358 goto out_unlock;
359 }
360
361 ui = ubifs_inode(inode);
362 ubifs_assert(inode->i_size == ui->data_len);
363 ubifs_assert(ubifs_inode(host)->xattr_size > ui->data_len);
364
Dongsheng Yangab92a202015-08-18 12:38:36 +0800365 mutex_lock(&ui->ui_mutex);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300366 if (buf) {
367 /* If @buf is %NULL we are supposed to return the length */
368 if (ui->data_len > size) {
Sheng Yong235c3622015-03-20 10:39:42 +0000369 ubifs_err(c, "buffer size %zd, xattr len %d",
Artem Bityutskiya6aae4d2012-05-16 20:11:23 +0300370 size, ui->data_len);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300371 err = -ERANGE;
372 goto out_iput;
373 }
374
375 memcpy(buf, ui->data, ui->data_len);
376 }
377 err = ui->data_len;
378
379out_iput:
Dongsheng Yangab92a202015-08-18 12:38:36 +0800380 mutex_unlock(&ui->ui_mutex);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300381 iput(inode);
382out_unlock:
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300383 kfree(xent);
384 return err;
385}
386
387ssize_t ubifs_listxattr(struct dentry *dentry, char *buffer, size_t size)
388{
389 union ubifs_key key;
David Howells2b0143b2015-03-17 22:25:59 +0000390 struct inode *host = d_inode(dentry);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300391 struct ubifs_info *c = host->i_sb->s_fs_info;
392 struct ubifs_inode *host_ui = ubifs_inode(host);
393 struct ubifs_dent_node *xent, *pxent = NULL;
394 int err, len, written = 0;
395 struct qstr nm = { .name = NULL };
396
Al Viro4cb2a012013-09-16 10:58:53 -0400397 dbg_gen("ino %lu ('%pd'), buffer size %zd", host->i_ino,
398 dentry, size);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300399
400 len = host_ui->xattr_names + host_ui->xattr_cnt;
401 if (!buffer)
402 /*
403 * We should return the minimum buffer size which will fit a
404 * null-terminated list of all the extended attribute names.
405 */
406 return len;
407
408 if (len > size)
409 return -ERANGE;
410
411 lowest_xent_key(c, &key, host->i_ino);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300412 while (1) {
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300413 xent = ubifs_tnc_next_ent(c, &key, &nm);
Hirofumi Nakagawa8d47aef2008-08-21 17:16:40 +0300414 if (IS_ERR(xent)) {
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300415 err = PTR_ERR(xent);
416 break;
417 }
418
419 nm.name = xent->name;
420 nm.len = le16_to_cpu(xent->nlen);
421
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300422 /* Show trusted namespace only for "power" users */
Andreas Gruenbacher2b88fc22016-04-22 19:14:00 +0200423 if (strncmp(xent->name, XATTR_TRUSTED_PREFIX,
424 XATTR_TRUSTED_PREFIX_LEN) ||
425 capable(CAP_SYS_ADMIN)) {
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300426 memcpy(buffer + written, nm.name, nm.len + 1);
427 written += nm.len + 1;
428 }
429
430 kfree(pxent);
431 pxent = xent;
432 key_read(c, &xent->key, &key);
433 }
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300434
435 kfree(pxent);
436 if (err != -ENOENT) {
Sheng Yong235c3622015-03-20 10:39:42 +0000437 ubifs_err(c, "cannot find next direntry, error %d", err);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300438 return err;
439 }
440
441 ubifs_assert(written <= size);
442 return written;
443}
444
445static int remove_xattr(struct ubifs_info *c, struct inode *host,
446 struct inode *inode, const struct qstr *nm)
447{
448 int err;
449 struct ubifs_inode *host_ui = ubifs_inode(host);
450 struct ubifs_inode *ui = ubifs_inode(inode);
Zoltan Sogor5acd6ff2008-08-12 13:54:54 +0300451 struct ubifs_budget_req req = { .dirtied_ino = 2, .mod_dent = 1,
452 .dirtied_ino_d = ALIGN(host_ui->data_len, 8) };
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300453
454 ubifs_assert(ui->data_len == inode->i_size);
455
456 err = ubifs_budget_space(c, &req);
457 if (err)
458 return err;
459
460 mutex_lock(&host_ui->ui_mutex);
461 host->i_ctime = ubifs_current_time(host);
462 host_ui->xattr_cnt -= 1;
463 host_ui->xattr_size -= CALC_DENT_SIZE(nm->len);
464 host_ui->xattr_size -= CALC_XATTR_BYTES(ui->data_len);
465 host_ui->xattr_names -= nm->len;
466
467 err = ubifs_jnl_delete_xattr(c, host, inode, nm);
468 if (err)
469 goto out_cancel;
470 mutex_unlock(&host_ui->ui_mutex);
471
472 ubifs_release_budget(c, &req);
473 return 0;
474
475out_cancel:
476 host_ui->xattr_cnt += 1;
477 host_ui->xattr_size += CALC_DENT_SIZE(nm->len);
478 host_ui->xattr_size += CALC_XATTR_BYTES(ui->data_len);
479 mutex_unlock(&host_ui->ui_mutex);
480 ubifs_release_budget(c, &req);
481 make_bad_inode(inode);
482 return err;
483}
484
Andreas Gruenbacher2b88fc22016-04-22 19:14:00 +0200485static int __ubifs_removexattr(struct inode *host, const char *name)
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300486{
Andreas Gruenbacher2b88fc22016-04-22 19:14:00 +0200487 struct inode *inode;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300488 struct ubifs_info *c = host->i_sb->s_fs_info;
Linus Torvalds26fe5752012-05-10 13:14:12 -0700489 struct qstr nm = QSTR_INIT(name, strlen(name));
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300490 struct ubifs_dent_node *xent;
491 union ubifs_key key;
492 int err;
493
Al Viro59551022016-01-22 15:40:57 -0500494 ubifs_assert(inode_is_locked(host));
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300495
Andreas Gruenbacher2b88fc22016-04-22 19:14:00 +0200496 if (nm.len > UBIFS_MAX_NLEN)
497 return -ENAMETOOLONG;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300498
499 xent = kmalloc(UBIFS_MAX_XENT_NODE_SZ, GFP_NOFS);
500 if (!xent)
501 return -ENOMEM;
502
503 xent_key_init(c, &key, host->i_ino, &nm);
504 err = ubifs_tnc_lookup_nm(c, &key, xent, &nm);
505 if (err) {
506 if (err == -ENOENT)
507 err = -ENODATA;
508 goto out_free;
509 }
510
511 inode = iget_xattr(c, le64_to_cpu(xent->inum));
512 if (IS_ERR(inode)) {
513 err = PTR_ERR(inode);
514 goto out_free;
515 }
516
517 ubifs_assert(inode->i_nlink == 1);
Miklos Szeredi6d6b77f2011-10-28 14:13:28 +0200518 clear_nlink(inode);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300519 err = remove_xattr(c, host, inode, &nm);
520 if (err)
Miklos Szeredibfe86842011-10-28 14:13:29 +0200521 set_nlink(inode, 1);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300522
523 /* If @i_nlink is 0, 'iput()' will delete the inode */
524 iput(inode);
525
526out_free:
527 kfree(xent);
528 return err;
529}
Subodh Nijsured7f0b702014-10-31 13:50:30 -0500530
Subodh Nijsured7f0b702014-10-31 13:50:30 -0500531static int init_xattrs(struct inode *inode, const struct xattr *xattr_array,
532 void *fs_info)
533{
534 const struct xattr *xattr;
535 char *name;
536 int err = 0;
537
538 for (xattr = xattr_array; xattr->name != NULL; xattr++) {
539 name = kmalloc(XATTR_SECURITY_PREFIX_LEN +
540 strlen(xattr->name) + 1, GFP_NOFS);
541 if (!name) {
542 err = -ENOMEM;
543 break;
544 }
545 strcpy(name, XATTR_SECURITY_PREFIX);
546 strcpy(name + XATTR_SECURITY_PREFIX_LEN, xattr->name);
Andreas Gruenbacher2b88fc22016-04-22 19:14:00 +0200547 err = __ubifs_setxattr(inode, name, xattr->value, xattr->value_len, 0);
Subodh Nijsured7f0b702014-10-31 13:50:30 -0500548 kfree(name);
549 if (err < 0)
550 break;
551 }
552
553 return err;
554}
555
556int ubifs_init_security(struct inode *dentry, struct inode *inode,
557 const struct qstr *qstr)
558{
559 int err;
560
Subodh Nijsured7f0b702014-10-31 13:50:30 -0500561 err = security_inode_init_security(inode, dentry, qstr,
562 &init_xattrs, 0);
Sheng Yong235c3622015-03-20 10:39:42 +0000563 if (err) {
564 struct ubifs_info *c = dentry->i_sb->s_fs_info;
565 ubifs_err(c, "cannot initialize security for inode %lu, error %d",
Subodh Nijsurefee17562014-10-31 13:50:31 -0500566 inode->i_ino, err);
Sheng Yong235c3622015-03-20 10:39:42 +0000567 }
Subodh Nijsured7f0b702014-10-31 13:50:30 -0500568 return err;
569}
Andreas Gruenbacher2b88fc22016-04-22 19:14:00 +0200570
571static int ubifs_xattr_get(const struct xattr_handler *handler,
572 struct dentry *dentry, struct inode *inode,
573 const char *name, void *buffer, size_t size)
574{
575 dbg_gen("xattr '%s', ino %lu ('%pd'), buf size %zd", name,
576 inode->i_ino, dentry, size);
577
578 return __ubifs_getxattr(inode, name, buffer, size);
579}
580
581static int ubifs_xattr_set(const struct xattr_handler *handler,
Al Viro59301222016-05-27 10:19:30 -0400582 struct dentry *dentry, struct inode *inode,
583 const char *name, const void *value,
584 size_t size, int flags)
Andreas Gruenbacher2b88fc22016-04-22 19:14:00 +0200585{
Andreas Gruenbacher2b88fc22016-04-22 19:14:00 +0200586 dbg_gen("xattr '%s', host ino %lu ('%pd'), size %zd",
587 name, inode->i_ino, dentry, size);
588
589 if (value)
590 return __ubifs_setxattr(inode, name, value, size, flags);
591 else
592 return __ubifs_removexattr(inode, name);
593}
594
595const struct xattr_handler ubifs_user_xattr_handler = {
596 .prefix = XATTR_USER_PREFIX,
597 .get = ubifs_xattr_get,
598 .set = ubifs_xattr_set,
599};
600
601const struct xattr_handler ubifs_trusted_xattr_handler = {
602 .prefix = XATTR_TRUSTED_PREFIX,
603 .get = ubifs_xattr_get,
604 .set = ubifs_xattr_set,
605};
606
607const struct xattr_handler ubifs_security_xattr_handler = {
608 .prefix = XATTR_SECURITY_PREFIX,
609 .get = ubifs_xattr_get,
610 .set = ubifs_xattr_set,
611};
612
613const struct xattr_handler *ubifs_xattr_handlers[] = {
614 &ubifs_user_xattr_handler,
615 &ubifs_trusted_xattr_handler,
616 &ubifs_security_xattr_handler,
617 NULL
618};