1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58#include "ubifs.h"
59#include <linux/xattr.h>
60#include <linux/posix_acl_xattr.h>
61
62
63
64
65
66#define MAX_XATTRS_PER_INODE 65535
67
68
69
70
71
72
73
74
75enum {
76 USER_XATTR,
77 TRUSTED_XATTR,
78 SECURITY_XATTR,
79};
80
81static const struct inode_operations none_inode_operations;
82static const struct address_space_operations none_address_operations;
83static const struct file_operations none_file_operations;
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99static int create_xattr(struct ubifs_info *c, struct inode *host,
100 const struct qstr *nm, const void *value, int size)
101{
102 int err;
103 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,
106 .new_ino_d = ALIGN(size, 8), .dirtied_ino = 1,
107 .dirtied_ino_d = ALIGN(host_ui->data_len, 8) };
108
109 if (host_ui->xattr_cnt >= MAX_XATTRS_PER_INODE)
110 return -ENOSPC;
111
112
113
114
115
116
117 if (host_ui->xattr_names + host_ui->xattr_cnt +
118 nm->len + 1 > XATTR_LIST_MAX)
119 return -ENOSPC;
120
121 err = ubifs_budget_space(c, &req);
122 if (err)
123 return err;
124
125 inode = ubifs_new_inode(c, host, S_IFREG | S_IRWXUGO);
126 if (IS_ERR(inode)) {
127 err = PTR_ERR(inode);
128 goto out_budg;
129 }
130
131
132 inode->i_mapping->a_ops = &none_address_operations;
133 inode->i_op = &none_inode_operations;
134 inode->i_fop = &none_file_operations;
135
136 inode->i_flags |= S_SYNC | S_NOATIME | S_NOCMTIME | S_NOQUOTA;
137 ui = ubifs_inode(inode);
138 ui->xattr = 1;
139 ui->flags |= UBIFS_XATTR_FL;
140 ui->data = kmalloc(size, GFP_NOFS);
141 if (!ui->data) {
142 err = -ENOMEM;
143 goto out_free;
144 }
145 memcpy(ui->data, value, size);
146 inode->i_size = ui->ui_size = size;
147 ui->data_len = size;
148
149 mutex_lock(&host_ui->ui_mutex);
150 host->i_ctime = ubifs_current_time(host);
151 host_ui->xattr_cnt += 1;
152 host_ui->xattr_size += CALC_DENT_SIZE(nm->len);
153 host_ui->xattr_size += CALC_XATTR_BYTES(size);
154 host_ui->xattr_names += nm->len;
155
156 err = ubifs_jnl_update(c, host, nm, inode, 0, 1);
157 if (err)
158 goto out_cancel;
159 mutex_unlock(&host_ui->ui_mutex);
160
161 ubifs_release_budget(c, &req);
162 insert_inode_hash(inode);
163 iput(inode);
164 return 0;
165
166out_cancel:
167 host_ui->xattr_cnt -= 1;
168 host_ui->xattr_size -= CALC_DENT_SIZE(nm->len);
169 host_ui->xattr_size -= CALC_XATTR_BYTES(size);
170 mutex_unlock(&host_ui->ui_mutex);
171out_free:
172 make_bad_inode(inode);
173 iput(inode);
174out_budg:
175 ubifs_release_budget(c, &req);
176 return err;
177}
178
179
180
181
182
183
184
185
186
187
188
189
190
191static int change_xattr(struct ubifs_info *c, struct inode *host,
192 struct inode *inode, const void *value, int size)
193{
194 int err;
195 struct ubifs_inode *host_ui = ubifs_inode(host);
196 struct ubifs_inode *ui = ubifs_inode(inode);
197 struct ubifs_budget_req req = { .dirtied_ino = 2,
198 .dirtied_ino_d = ALIGN(size, 8) + ALIGN(host_ui->data_len, 8) };
199
200 ubifs_assert(ui->data_len == inode->i_size);
201 err = ubifs_budget_space(c, &req);
202 if (err)
203 return err;
204
205 kfree(ui->data);
206 ui->data = kmalloc(size, GFP_NOFS);
207 if (!ui->data) {
208 err = -ENOMEM;
209 goto out_free;
210 }
211 memcpy(ui->data, value, size);
212 inode->i_size = ui->ui_size = size;
213 ui->data_len = size;
214
215 mutex_lock(&host_ui->ui_mutex);
216 host->i_ctime = ubifs_current_time(host);
217 host_ui->xattr_size -= CALC_XATTR_BYTES(ui->data_len);
218 host_ui->xattr_size += CALC_XATTR_BYTES(size);
219
220
221
222
223
224
225
226 err = ubifs_jnl_change_xattr(c, inode, host);
227 if (err)
228 goto out_cancel;
229 mutex_unlock(&host_ui->ui_mutex);
230
231 ubifs_release_budget(c, &req);
232 return 0;
233
234out_cancel:
235 host_ui->xattr_size -= CALC_XATTR_BYTES(size);
236 host_ui->xattr_size += CALC_XATTR_BYTES(ui->data_len);
237 mutex_unlock(&host_ui->ui_mutex);
238 make_bad_inode(inode);
239out_free:
240 ubifs_release_budget(c, &req);
241 return err;
242}
243
244
245
246
247
248
249
250
251
252static int check_namespace(const struct qstr *nm)
253{
254 int type;
255
256 if (nm->len > UBIFS_MAX_NLEN)
257 return -ENAMETOOLONG;
258
259 if (!strncmp(nm->name, XATTR_TRUSTED_PREFIX,
260 XATTR_TRUSTED_PREFIX_LEN)) {
261 if (nm->name[sizeof(XATTR_TRUSTED_PREFIX) - 1] == '\0')
262 return -EINVAL;
263 type = TRUSTED_XATTR;
264 } else if (!strncmp(nm->name, XATTR_USER_PREFIX,
265 XATTR_USER_PREFIX_LEN)) {
266 if (nm->name[XATTR_USER_PREFIX_LEN] == '\0')
267 return -EINVAL;
268 type = USER_XATTR;
269 } else if (!strncmp(nm->name, XATTR_SECURITY_PREFIX,
270 XATTR_SECURITY_PREFIX_LEN)) {
271 if (nm->name[sizeof(XATTR_SECURITY_PREFIX) - 1] == '\0')
272 return -EINVAL;
273 type = SECURITY_XATTR;
274 } else
275 return -EOPNOTSUPP;
276
277 return type;
278}
279
280static struct inode *iget_xattr(struct ubifs_info *c, ino_t inum)
281{
282 struct inode *inode;
283
284 inode = ubifs_iget(c->vfs_sb, inum);
285 if (IS_ERR(inode)) {
286 ubifs_err("dead extended attribute entry, error %d",
287 (int)PTR_ERR(inode));
288 return inode;
289 }
290 if (ubifs_inode(inode)->xattr)
291 return inode;
292 ubifs_err("corrupt extended attribute entry");
293 iput(inode);
294 return ERR_PTR(-EINVAL);
295}
296
297int ubifs_setxattr(struct dentry *dentry, const char *name,
298 const void *value, size_t size, int flags)
299{
300 struct inode *inode, *host = dentry->d_inode;
301 struct ubifs_info *c = host->i_sb->s_fs_info;
302 struct qstr nm = { .name = name, .len = strlen(name) };
303 struct ubifs_dent_node *xent;
304 union ubifs_key key;
305 int err, type;
306
307 dbg_gen("xattr '%s', host ino %lu ('%.*s'), size %zd", name,
308 host->i_ino, dentry->d_name.len, dentry->d_name.name, size);
309 ubifs_assert(mutex_is_locked(&host->i_mutex));
310
311 if (size > UBIFS_MAX_INO_DATA)
312 return -ERANGE;
313
314 type = check_namespace(&nm);
315 if (type < 0)
316 return type;
317
318 xent = kmalloc(UBIFS_MAX_XENT_NODE_SZ, GFP_NOFS);
319 if (!xent)
320 return -ENOMEM;
321
322
323
324
325
326 xent_key_init(c, &key, host->i_ino, &nm);
327 err = ubifs_tnc_lookup_nm(c, &key, xent, &nm);
328 if (err) {
329 if (err != -ENOENT)
330 goto out_free;
331
332 if (flags & XATTR_REPLACE)
333
334 err = -ENODATA;
335 else
336 err = create_xattr(c, host, &nm, value, size);
337 goto out_free;
338 }
339
340 if (flags & XATTR_CREATE) {
341
342 err = -EEXIST;
343 goto out_free;
344 }
345
346 inode = iget_xattr(c, le64_to_cpu(xent->inum));
347 if (IS_ERR(inode)) {
348 err = PTR_ERR(inode);
349 goto out_free;
350 }
351
352 err = change_xattr(c, host, inode, value, size);
353 iput(inode);
354
355out_free:
356 kfree(xent);
357 return err;
358}
359
360ssize_t ubifs_getxattr(struct dentry *dentry, const char *name, void *buf,
361 size_t size)
362{
363 struct inode *inode, *host = dentry->d_inode;
364 struct ubifs_info *c = host->i_sb->s_fs_info;
365 struct qstr nm = { .name = name, .len = strlen(name) };
366 struct ubifs_inode *ui;
367 struct ubifs_dent_node *xent;
368 union ubifs_key key;
369 int err;
370
371 dbg_gen("xattr '%s', ino %lu ('%.*s'), buf size %zd", name,
372 host->i_ino, dentry->d_name.len, dentry->d_name.name, size);
373
374 err = check_namespace(&nm);
375 if (err < 0)
376 return err;
377
378 xent = kmalloc(UBIFS_MAX_XENT_NODE_SZ, GFP_NOFS);
379 if (!xent)
380 return -ENOMEM;
381
382 xent_key_init(c, &key, host->i_ino, &nm);
383 err = ubifs_tnc_lookup_nm(c, &key, xent, &nm);
384 if (err) {
385 if (err == -ENOENT)
386 err = -ENODATA;
387 goto out_unlock;
388 }
389
390 inode = iget_xattr(c, le64_to_cpu(xent->inum));
391 if (IS_ERR(inode)) {
392 err = PTR_ERR(inode);
393 goto out_unlock;
394 }
395
396 ui = ubifs_inode(inode);
397 ubifs_assert(inode->i_size == ui->data_len);
398 ubifs_assert(ubifs_inode(host)->xattr_size > ui->data_len);
399
400 if (buf) {
401
402 if (ui->data_len > size) {
403 dbg_err("buffer size %zd, xattr len %d",
404 size, ui->data_len);
405 err = -ERANGE;
406 goto out_iput;
407 }
408
409 memcpy(buf, ui->data, ui->data_len);
410 }
411 err = ui->data_len;
412
413out_iput:
414 iput(inode);
415out_unlock:
416 kfree(xent);
417 return err;
418}
419
420ssize_t ubifs_listxattr(struct dentry *dentry, char *buffer, size_t size)
421{
422 union ubifs_key key;
423 struct inode *host = dentry->d_inode;
424 struct ubifs_info *c = host->i_sb->s_fs_info;
425 struct ubifs_inode *host_ui = ubifs_inode(host);
426 struct ubifs_dent_node *xent, *pxent = NULL;
427 int err, len, written = 0;
428 struct qstr nm = { .name = NULL };
429
430 dbg_gen("ino %lu ('%.*s'), buffer size %zd", host->i_ino,
431 dentry->d_name.len, dentry->d_name.name, size);
432
433 len = host_ui->xattr_names + host_ui->xattr_cnt;
434 if (!buffer)
435
436
437
438
439 return len;
440
441 if (len > size)
442 return -ERANGE;
443
444 lowest_xent_key(c, &key, host->i_ino);
445 while (1) {
446 int type;
447
448 xent = ubifs_tnc_next_ent(c, &key, &nm);
449 if (IS_ERR(xent)) {
450 err = PTR_ERR(xent);
451 break;
452 }
453
454 nm.name = xent->name;
455 nm.len = le16_to_cpu(xent->nlen);
456
457 type = check_namespace(&nm);
458 if (unlikely(type < 0)) {
459 err = type;
460 break;
461 }
462
463
464 if (type != TRUSTED_XATTR || capable(CAP_SYS_ADMIN)) {
465 memcpy(buffer + written, nm.name, nm.len + 1);
466 written += nm.len + 1;
467 }
468
469 kfree(pxent);
470 pxent = xent;
471 key_read(c, &xent->key, &key);
472 }
473
474 kfree(pxent);
475 if (err != -ENOENT) {
476 ubifs_err("cannot find next direntry, error %d", err);
477 return err;
478 }
479
480 ubifs_assert(written <= size);
481 return written;
482}
483
484static int remove_xattr(struct ubifs_info *c, struct inode *host,
485 struct inode *inode, const struct qstr *nm)
486{
487 int err;
488 struct ubifs_inode *host_ui = ubifs_inode(host);
489 struct ubifs_inode *ui = ubifs_inode(inode);
490 struct ubifs_budget_req req = { .dirtied_ino = 2, .mod_dent = 1,
491 .dirtied_ino_d = ALIGN(host_ui->data_len, 8) };
492
493 ubifs_assert(ui->data_len == inode->i_size);
494
495 err = ubifs_budget_space(c, &req);
496 if (err)
497 return err;
498
499 mutex_lock(&host_ui->ui_mutex);
500 host->i_ctime = ubifs_current_time(host);
501 host_ui->xattr_cnt -= 1;
502 host_ui->xattr_size -= CALC_DENT_SIZE(nm->len);
503 host_ui->xattr_size -= CALC_XATTR_BYTES(ui->data_len);
504 host_ui->xattr_names -= nm->len;
505
506 err = ubifs_jnl_delete_xattr(c, host, inode, nm);
507 if (err)
508 goto out_cancel;
509 mutex_unlock(&host_ui->ui_mutex);
510
511 ubifs_release_budget(c, &req);
512 return 0;
513
514out_cancel:
515 host_ui->xattr_cnt += 1;
516 host_ui->xattr_size += CALC_DENT_SIZE(nm->len);
517 host_ui->xattr_size += CALC_XATTR_BYTES(ui->data_len);
518 mutex_unlock(&host_ui->ui_mutex);
519 ubifs_release_budget(c, &req);
520 make_bad_inode(inode);
521 return err;
522}
523
524int ubifs_removexattr(struct dentry *dentry, const char *name)
525{
526 struct inode *inode, *host = dentry->d_inode;
527 struct ubifs_info *c = host->i_sb->s_fs_info;
528 struct qstr nm = { .name = name, .len = strlen(name) };
529 struct ubifs_dent_node *xent;
530 union ubifs_key key;
531 int err;
532
533 dbg_gen("xattr '%s', ino %lu ('%.*s')", name,
534 host->i_ino, dentry->d_name.len, dentry->d_name.name);
535 ubifs_assert(mutex_is_locked(&host->i_mutex));
536
537 err = check_namespace(&nm);
538 if (err < 0)
539 return err;
540
541 xent = kmalloc(UBIFS_MAX_XENT_NODE_SZ, GFP_NOFS);
542 if (!xent)
543 return -ENOMEM;
544
545 xent_key_init(c, &key, host->i_ino, &nm);
546 err = ubifs_tnc_lookup_nm(c, &key, xent, &nm);
547 if (err) {
548 if (err == -ENOENT)
549 err = -ENODATA;
550 goto out_free;
551 }
552
553 inode = iget_xattr(c, le64_to_cpu(xent->inum));
554 if (IS_ERR(inode)) {
555 err = PTR_ERR(inode);
556 goto out_free;
557 }
558
559 ubifs_assert(inode->i_nlink == 1);
560 inode->i_nlink = 0;
561 err = remove_xattr(c, host, inode, &nm);
562 if (err)
563 inode->i_nlink = 1;
564
565
566 iput(inode);
567
568out_free:
569 kfree(xent);
570 return err;
571}
572