2 * This file is part of UBIFS.
4 * Copyright (C) 2006-2008 Nokia Corporation.
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.
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
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
19 * Authors: Artem Bityutskiy (Битюцкий Артём)
24 * This file implements UBIFS extended attributes support.
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.
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.
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
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
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
55 * ACL support is not implemented.
60 #include <linux/slab.h>
61 #include <linux/xattr.h>
62 #include <linux/posix_acl_xattr.h>
65 * Limit the number of extended attributes per inode so that the total size
66 * (@xattr_size) is guaranteeded to fit in an 'unsigned int'.
68 #define MAX_XATTRS_PER_INODE 65535
71 * Extended attribute type constants.
73 * USER_XATTR: user extended attribute ("user.*")
74 * TRUSTED_XATTR: trusted extended attribute ("trusted.*)
75 * SECURITY_XATTR: security extended attribute ("security.*")
83 static const struct inode_operations empty_iops
;
84 static const struct file_operations empty_fops
;
87 * create_xattr - create an extended attribute.
88 * @c: UBIFS file-system description object
90 * @nm: extended attribute name
91 * @value: extended attribute value
92 * @size: size of extended attribute value
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
100 static int create_xattr(struct ubifs_info
*c
, struct inode
*host
,
101 const struct qstr
*nm
, const void *value
, int size
)
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) };
110 if (host_ui
->xattr_cnt
>= MAX_XATTRS_PER_INODE
) {
111 ubifs_err(c
, "inode %lu already has too many xattrs (%d), cannot create more",
112 host
->i_ino
, host_ui
->xattr_cnt
);
116 * Linux limits the maximum size of the extended attribute names list
117 * to %XATTR_LIST_MAX. This means we should not allow creating more
118 * extended attributes if the name list becomes larger. This limitation
119 * is artificial for UBIFS, though.
121 names_len
= host_ui
->xattr_names
+ host_ui
->xattr_cnt
+ nm
->len
+ 1;
122 if (names_len
> XATTR_LIST_MAX
) {
123 ubifs_err(c
, "cannot add one more xattr name to inode %lu, total names length would become %d, max. is %d",
124 host
->i_ino
, names_len
, XATTR_LIST_MAX
);
128 err
= ubifs_budget_space(c
, &req
);
132 inode
= ubifs_new_inode(c
, host
, S_IFREG
| S_IRWXUGO
);
134 err
= PTR_ERR(inode
);
138 /* Re-define all operations to be "nothing" */
139 inode
->i_mapping
->a_ops
= &empty_aops
;
140 inode
->i_op
= &empty_iops
;
141 inode
->i_fop
= &empty_fops
;
143 inode
->i_flags
|= S_SYNC
| S_NOATIME
| S_NOCMTIME
| S_NOQUOTA
;
144 ui
= ubifs_inode(inode
);
146 ui
->flags
|= UBIFS_XATTR_FL
;
147 ui
->data
= kmemdup(value
, size
, GFP_NOFS
);
152 inode
->i_size
= ui
->ui_size
= size
;
155 mutex_lock(&host_ui
->ui_mutex
);
156 host
->i_ctime
= ubifs_current_time(host
);
157 host_ui
->xattr_cnt
+= 1;
158 host_ui
->xattr_size
+= CALC_DENT_SIZE(nm
->len
);
159 host_ui
->xattr_size
+= CALC_XATTR_BYTES(size
);
160 host_ui
->xattr_names
+= nm
->len
;
162 err
= ubifs_jnl_update(c
, host
, nm
, inode
, 0, 1);
165 mutex_unlock(&host_ui
->ui_mutex
);
167 ubifs_release_budget(c
, &req
);
168 insert_inode_hash(inode
);
173 host_ui
->xattr_cnt
-= 1;
174 host_ui
->xattr_size
-= CALC_DENT_SIZE(nm
->len
);
175 host_ui
->xattr_size
-= CALC_XATTR_BYTES(size
);
176 mutex_unlock(&host_ui
->ui_mutex
);
178 make_bad_inode(inode
);
181 ubifs_release_budget(c
, &req
);
186 * change_xattr - change an extended attribute.
187 * @c: UBIFS file-system description object
189 * @inode: extended attribute inode
190 * @value: extended attribute value
191 * @size: size of extended attribute value
193 * This helper function changes the value of extended attribute @inode with new
194 * data from @value. Returns zero in case of success and a negative error code
195 * in case of failure.
197 static int change_xattr(struct ubifs_info
*c
, struct inode
*host
,
198 struct inode
*inode
, const void *value
, int size
)
201 struct ubifs_inode
*host_ui
= ubifs_inode(host
);
202 struct ubifs_inode
*ui
= ubifs_inode(inode
);
203 struct ubifs_budget_req req
= { .dirtied_ino
= 2,
204 .dirtied_ino_d
= ALIGN(size
, 8) + ALIGN(host_ui
->data_len
, 8) };
206 ubifs_assert(ui
->data_len
== inode
->i_size
);
207 err
= ubifs_budget_space(c
, &req
);
212 ui
->data
= kmemdup(value
, size
, GFP_NOFS
);
217 inode
->i_size
= ui
->ui_size
= size
;
220 mutex_lock(&host_ui
->ui_mutex
);
221 host
->i_ctime
= ubifs_current_time(host
);
222 host_ui
->xattr_size
-= CALC_XATTR_BYTES(ui
->data_len
);
223 host_ui
->xattr_size
+= CALC_XATTR_BYTES(size
);
226 * It is important to write the host inode after the xattr inode
227 * because if the host inode gets synchronized (via 'fsync()'), then
228 * the extended attribute inode gets synchronized, because it goes
229 * before the host inode in the write-buffer.
231 err
= ubifs_jnl_change_xattr(c
, inode
, host
);
234 mutex_unlock(&host_ui
->ui_mutex
);
236 ubifs_release_budget(c
, &req
);
240 host_ui
->xattr_size
-= CALC_XATTR_BYTES(size
);
241 host_ui
->xattr_size
+= CALC_XATTR_BYTES(ui
->data_len
);
242 mutex_unlock(&host_ui
->ui_mutex
);
243 make_bad_inode(inode
);
245 ubifs_release_budget(c
, &req
);
250 * check_namespace - check extended attribute name-space.
251 * @nm: extended attribute name
253 * This function makes sure the extended attribute name belongs to one of the
254 * supported extended attribute name-spaces. Returns name-space index in case
255 * of success and a negative error code in case of failure.
257 static int check_namespace(const struct qstr
*nm
)
261 if (nm
->len
> UBIFS_MAX_NLEN
)
262 return -ENAMETOOLONG
;
264 if (!strncmp(nm
->name
, XATTR_TRUSTED_PREFIX
,
265 XATTR_TRUSTED_PREFIX_LEN
)) {
266 if (nm
->name
[sizeof(XATTR_TRUSTED_PREFIX
) - 1] == '\0')
268 type
= TRUSTED_XATTR
;
269 } else if (!strncmp(nm
->name
, XATTR_USER_PREFIX
,
270 XATTR_USER_PREFIX_LEN
)) {
271 if (nm
->name
[XATTR_USER_PREFIX_LEN
] == '\0')
274 } else if (!strncmp(nm
->name
, XATTR_SECURITY_PREFIX
,
275 XATTR_SECURITY_PREFIX_LEN
)) {
276 if (nm
->name
[sizeof(XATTR_SECURITY_PREFIX
) - 1] == '\0')
278 type
= SECURITY_XATTR
;
285 static struct inode
*iget_xattr(struct ubifs_info
*c
, ino_t inum
)
289 inode
= ubifs_iget(c
->vfs_sb
, inum
);
291 ubifs_err(c
, "dead extended attribute entry, error %d",
292 (int)PTR_ERR(inode
));
295 if (ubifs_inode(inode
)->xattr
)
297 ubifs_err(c
, "corrupt extended attribute entry");
299 return ERR_PTR(-EINVAL
);
302 static int setxattr(struct inode
*host
, const char *name
, const void *value
,
303 size_t size
, int flags
)
306 struct ubifs_info
*c
= host
->i_sb
->s_fs_info
;
307 struct qstr nm
= QSTR_INIT(name
, strlen(name
));
308 struct ubifs_dent_node
*xent
;
312 ubifs_assert(mutex_is_locked(&host
->i_mutex
));
314 if (size
> UBIFS_MAX_INO_DATA
)
317 type
= check_namespace(&nm
);
321 xent
= kmalloc(UBIFS_MAX_XENT_NODE_SZ
, GFP_NOFS
);
326 * The extended attribute entries are stored in LNC, so multiple
327 * look-ups do not involve reading the flash.
329 xent_key_init(c
, &key
, host
->i_ino
, &nm
);
330 err
= ubifs_tnc_lookup_nm(c
, &key
, xent
, &nm
);
335 if (flags
& XATTR_REPLACE
)
336 /* We are asked not to create the xattr */
339 err
= create_xattr(c
, host
, &nm
, value
, size
);
343 if (flags
& XATTR_CREATE
) {
344 /* We are asked not to replace the xattr */
349 inode
= iget_xattr(c
, le64_to_cpu(xent
->inum
));
351 err
= PTR_ERR(inode
);
355 err
= change_xattr(c
, host
, inode
, value
, size
);
363 int ubifs_setxattr(struct dentry
*dentry
, const char *name
,
364 const void *value
, size_t size
, int flags
)
366 dbg_gen("xattr '%s', host ino %lu ('%pd'), size %zd",
367 name
, d_inode(dentry
)->i_ino
, dentry
, size
);
369 return setxattr(d_inode(dentry
), name
, value
, size
, flags
);
372 ssize_t
ubifs_getxattr(struct dentry
*dentry
, const char *name
, void *buf
,
375 struct inode
*inode
, *host
= d_inode(dentry
);
376 struct ubifs_info
*c
= host
->i_sb
->s_fs_info
;
377 struct qstr nm
= QSTR_INIT(name
, strlen(name
));
378 struct ubifs_inode
*ui
;
379 struct ubifs_dent_node
*xent
;
383 dbg_gen("xattr '%s', ino %lu ('%pd'), buf size %zd", name
,
384 host
->i_ino
, dentry
, size
);
386 err
= check_namespace(&nm
);
390 xent
= kmalloc(UBIFS_MAX_XENT_NODE_SZ
, GFP_NOFS
);
394 xent_key_init(c
, &key
, host
->i_ino
, &nm
);
395 err
= ubifs_tnc_lookup_nm(c
, &key
, xent
, &nm
);
402 inode
= iget_xattr(c
, le64_to_cpu(xent
->inum
));
404 err
= PTR_ERR(inode
);
408 ui
= ubifs_inode(inode
);
409 ubifs_assert(inode
->i_size
== ui
->data_len
);
410 ubifs_assert(ubifs_inode(host
)->xattr_size
> ui
->data_len
);
413 /* If @buf is %NULL we are supposed to return the length */
414 if (ui
->data_len
> size
) {
415 ubifs_err(c
, "buffer size %zd, xattr len %d",
421 memcpy(buf
, ui
->data
, ui
->data_len
);
432 ssize_t
ubifs_listxattr(struct dentry
*dentry
, char *buffer
, size_t size
)
435 struct inode
*host
= d_inode(dentry
);
436 struct ubifs_info
*c
= host
->i_sb
->s_fs_info
;
437 struct ubifs_inode
*host_ui
= ubifs_inode(host
);
438 struct ubifs_dent_node
*xent
, *pxent
= NULL
;
439 int err
, len
, written
= 0;
440 struct qstr nm
= { .name
= NULL
};
442 dbg_gen("ino %lu ('%pd'), buffer size %zd", host
->i_ino
,
445 len
= host_ui
->xattr_names
+ host_ui
->xattr_cnt
;
448 * We should return the minimum buffer size which will fit a
449 * null-terminated list of all the extended attribute names.
456 lowest_xent_key(c
, &key
, host
->i_ino
);
460 xent
= ubifs_tnc_next_ent(c
, &key
, &nm
);
466 nm
.name
= xent
->name
;
467 nm
.len
= le16_to_cpu(xent
->nlen
);
469 type
= check_namespace(&nm
);
470 if (unlikely(type
< 0)) {
475 /* Show trusted namespace only for "power" users */
476 if (type
!= TRUSTED_XATTR
|| capable(CAP_SYS_ADMIN
)) {
477 memcpy(buffer
+ written
, nm
.name
, nm
.len
+ 1);
478 written
+= nm
.len
+ 1;
483 key_read(c
, &xent
->key
, &key
);
487 if (err
!= -ENOENT
) {
488 ubifs_err(c
, "cannot find next direntry, error %d", err
);
492 ubifs_assert(written
<= size
);
496 static int remove_xattr(struct ubifs_info
*c
, struct inode
*host
,
497 struct inode
*inode
, const struct qstr
*nm
)
500 struct ubifs_inode
*host_ui
= ubifs_inode(host
);
501 struct ubifs_inode
*ui
= ubifs_inode(inode
);
502 struct ubifs_budget_req req
= { .dirtied_ino
= 2, .mod_dent
= 1,
503 .dirtied_ino_d
= ALIGN(host_ui
->data_len
, 8) };
505 ubifs_assert(ui
->data_len
== inode
->i_size
);
507 err
= ubifs_budget_space(c
, &req
);
511 mutex_lock(&host_ui
->ui_mutex
);
512 host
->i_ctime
= ubifs_current_time(host
);
513 host_ui
->xattr_cnt
-= 1;
514 host_ui
->xattr_size
-= CALC_DENT_SIZE(nm
->len
);
515 host_ui
->xattr_size
-= CALC_XATTR_BYTES(ui
->data_len
);
516 host_ui
->xattr_names
-= nm
->len
;
518 err
= ubifs_jnl_delete_xattr(c
, host
, inode
, nm
);
521 mutex_unlock(&host_ui
->ui_mutex
);
523 ubifs_release_budget(c
, &req
);
527 host_ui
->xattr_cnt
+= 1;
528 host_ui
->xattr_size
+= CALC_DENT_SIZE(nm
->len
);
529 host_ui
->xattr_size
+= CALC_XATTR_BYTES(ui
->data_len
);
530 mutex_unlock(&host_ui
->ui_mutex
);
531 ubifs_release_budget(c
, &req
);
532 make_bad_inode(inode
);
536 int ubifs_removexattr(struct dentry
*dentry
, const char *name
)
538 struct inode
*inode
, *host
= d_inode(dentry
);
539 struct ubifs_info
*c
= host
->i_sb
->s_fs_info
;
540 struct qstr nm
= QSTR_INIT(name
, strlen(name
));
541 struct ubifs_dent_node
*xent
;
545 dbg_gen("xattr '%s', ino %lu ('%pd')", name
,
546 host
->i_ino
, dentry
);
547 ubifs_assert(mutex_is_locked(&host
->i_mutex
));
549 err
= check_namespace(&nm
);
553 xent
= kmalloc(UBIFS_MAX_XENT_NODE_SZ
, GFP_NOFS
);
557 xent_key_init(c
, &key
, host
->i_ino
, &nm
);
558 err
= ubifs_tnc_lookup_nm(c
, &key
, xent
, &nm
);
565 inode
= iget_xattr(c
, le64_to_cpu(xent
->inum
));
567 err
= PTR_ERR(inode
);
571 ubifs_assert(inode
->i_nlink
== 1);
573 err
= remove_xattr(c
, host
, inode
, &nm
);
577 /* If @i_nlink is 0, 'iput()' will delete the inode */
585 static size_t security_listxattr(struct dentry
*d
, char *list
, size_t list_size
,
586 const char *name
, size_t name_len
, int flags
)
588 const int prefix_len
= XATTR_SECURITY_PREFIX_LEN
;
589 const size_t total_len
= prefix_len
+ name_len
+ 1;
591 if (list
&& total_len
<= list_size
) {
592 memcpy(list
, XATTR_SECURITY_PREFIX
, prefix_len
);
593 memcpy(list
+ prefix_len
, name
, name_len
);
594 list
[prefix_len
+ name_len
] = '\0';
600 static int security_getxattr(struct dentry
*d
, const char *name
, void *buffer
,
601 size_t size
, int flags
)
603 return ubifs_getxattr(d
, name
, buffer
, size
);
606 static int security_setxattr(struct dentry
*d
, const char *name
,
607 const void *value
, size_t size
, int flags
,
610 return ubifs_setxattr(d
, name
, value
, size
, flags
);
613 static const struct xattr_handler ubifs_xattr_security_handler
= {
614 .prefix
= XATTR_SECURITY_PREFIX
,
615 .list
= security_listxattr
,
616 .get
= security_getxattr
,
617 .set
= security_setxattr
,
620 const struct xattr_handler
*ubifs_xattr_handlers
[] = {
621 &ubifs_xattr_security_handler
,
625 static int init_xattrs(struct inode
*inode
, const struct xattr
*xattr_array
,
628 const struct xattr
*xattr
;
632 for (xattr
= xattr_array
; xattr
->name
!= NULL
; xattr
++) {
633 name
= kmalloc(XATTR_SECURITY_PREFIX_LEN
+
634 strlen(xattr
->name
) + 1, GFP_NOFS
);
639 strcpy(name
, XATTR_SECURITY_PREFIX
);
640 strcpy(name
+ XATTR_SECURITY_PREFIX_LEN
, xattr
->name
);
641 err
= setxattr(inode
, name
, xattr
->value
, xattr
->value_len
, 0);
650 int ubifs_init_security(struct inode
*dentry
, struct inode
*inode
,
651 const struct qstr
*qstr
)
655 err
= security_inode_init_security(inode
, dentry
, qstr
,
658 struct ubifs_info
*c
= dentry
->i_sb
->s_fs_info
;
659 ubifs_err(c
, "cannot initialize security for inode %lu, error %d",