projects/linux·blob master · refs

856 lines · 20.5 KiB

1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (C) 2005,2006,2007,2008 IBM Corporation
4 *
5 * Authors:
6 * Kylene Hall <[email protected]>
7 * Reiner Sailer <[email protected]>
8 * Mimi Zohar <[email protected]>
9 *
10 * File: ima_fs.c
11 * implemenents security file system for reporting
12 * current measurement list and IMA statistics
13 */
14
15#include <linux/fcntl.h>
16#include <linux/kernel_read_file.h>
17#include <linux/slab.h>
18#include <linux/init.h>
19#include <linux/seq_file.h>
20#include <linux/rculist.h>
21#include <linux/rcupdate.h>
22#include <linux/parser.h>
23#include <linux/vmalloc.h>
24
25#include "ima.h"
26
27/*
28 * Requests:
29 * 'A\n': stage the entire measurements list
30 * 'D\n': delete all staged measurements
31 * '[1, ULONG_MAX]\n' delete N measurements records
32 */
33#define STAGED_REQ_LENGTH 21
34
35/* lock for protecting concurrent IMA policy updates */
36DEFINE_MUTEX(ima_write_mutex);
37
38static DEFINE_MUTEX(ima_measure_mutex);
39static long ima_measure_users;
40static struct task_struct *measure_writer;
41static long measure_writer_extra_writes;
42
43bool ima_canonical_fmt;
44static int __init default_canonical_fmt_setup(char *str)
45{
46#ifdef __BIG_ENDIAN
47 ima_canonical_fmt = true;
48#endif
49 return 1;
50}
51__setup("ima_canonical_fmt", default_canonical_fmt_setup);
52
53static int valid_policy = 1;
54
55static ssize_t ima_show_counter(char __user *buf, size_t count, loff_t *ppos,
56 atomic_long_t *val)
57{
58 char tmpbuf[32]; /* greater than largest 'long' string value */
59 ssize_t len;
60
61 len = scnprintf(tmpbuf, sizeof(tmpbuf), "%li\n", atomic_long_read(val));
62 return simple_read_from_buffer(buf, count, ppos, tmpbuf, len);
63}
64
65static ssize_t ima_show_num_violations(struct file *filp, char __user *buf,
66 size_t count, loff_t *ppos)
67{
68 return ima_show_counter(buf, count, ppos, &ima_num_violations);
69}
70
71static const struct file_operations ima_num_violations_ops = {
72 .read = ima_show_num_violations,
73 .llseek = generic_file_llseek,
74};
75
76static ssize_t ima_show_measurements_count(struct file *filp,
77 char __user *buf,
78 size_t count, loff_t *ppos)
79{
80 return ima_show_counter(buf, count, ppos, &ima_num_records[BINARY]);
81}
82
83static const struct file_operations ima_measurements_count_ops = {
84 .read = ima_show_measurements_count,
85 .llseek = generic_file_llseek,
86};
87
88/* returns pointer to hlist_node */
89static void *_ima_measurements_start(struct seq_file *m, loff_t *pos,
90 struct list_head *head)
91{
92 loff_t l = *pos;
93 struct ima_queue_entry *qe;
94
95 /* we need a lock since pos could point beyond last element */
96 rcu_read_lock();
97 list_for_each_entry_rcu(qe, head, later) {
98 if (!l--) {
99 rcu_read_unlock();
100 return qe;
101 }
102 }
103 rcu_read_unlock();
104 return NULL;
105}
106
107static void *ima_measurements_start(struct seq_file *m, loff_t *pos)
108{
109 return _ima_measurements_start(m, pos, &ima_measurements);
110}
111
112static void *ima_measurements_staged_start(struct seq_file *m, loff_t *pos)
113{
114 return _ima_measurements_start(m, pos, &ima_measurements_staged);
115}
116
117static void *_ima_measurements_next(struct seq_file *m, void *v, loff_t *pos,
118 struct list_head *head)
119{
120 struct ima_queue_entry *qe = v;
121
122 /* lock protects when reading beyond last element
123 * against concurrent list-extension
124 */
125 rcu_read_lock();
126 qe = list_entry_rcu(qe->later.next, struct ima_queue_entry, later);
127 rcu_read_unlock();
128 (*pos)++;
129
130 return (&qe->later == head) ? NULL : qe;
131}
132
133static void *ima_measurements_next(struct seq_file *m, void *v, loff_t *pos)
134{
135 return _ima_measurements_next(m, v, pos, &ima_measurements);
136}
137
138static void *ima_measurements_staged_next(struct seq_file *m, void *v,
139 loff_t *pos)
140{
141 return _ima_measurements_next(m, v, pos, &ima_measurements_staged);
142}
143
144static void ima_measurements_stop(struct seq_file *m, void *v)
145{
146}
147
148void ima_putc(struct seq_file *m, void *data, int datalen)
149{
150 while (datalen--)
151 seq_putc(m, *(char *)data++);
152}
153
154/* print format:
155 * 32bit-le=pcr#
156 * char[n]=template digest
157 * 32bit-le=template name size
158 * char[n]=template name
159 * [eventdata length]
160 * eventdata[n]=template specific data
161 */
162int ima_measurements_show(struct seq_file *m, void *v)
163{
164 /* the list never shrinks, so we don't need a lock here */
165 struct ima_queue_entry *qe = v;
166 struct ima_template_entry *e;
167 char *template_name;
168 u32 pcr, namelen, template_data_len; /* temporary fields */
169 bool is_ima_template = false;
170 int i, algo_idx;
171
172 algo_idx = ima_sha1_idx;
173
174 if (m->file != NULL)
175 algo_idx = (unsigned long)file_inode(m->file)->i_private;
176
177 /* get entry */
178 e = qe->entry;
179 if (e == NULL)
180 return -1;
181
182 template_name = (e->template_desc->name[0] != '\0') ?
183 e->template_desc->name : e->template_desc->fmt;
184
185 /*
186 * 1st: PCRIndex
187 * PCR used defaults to the same (config option) in
188 * little-endian format, unless set in policy
189 */
190 pcr = !ima_canonical_fmt ? e->pcr : (__force u32)cpu_to_le32(e->pcr);
191 ima_putc(m, &pcr, sizeof(e->pcr));
192
193 /* 2nd: template digest */
194 ima_putc(m, e->digests[algo_idx].digest,
195 ima_algo_array[algo_idx].digest_size);
196
197 /* 3rd: template name size */
198 namelen = !ima_canonical_fmt ? strlen(template_name) :
199 (__force u32)cpu_to_le32(strlen(template_name));
200 ima_putc(m, &namelen, sizeof(namelen));
201
202 /* 4th: template name */
203 ima_putc(m, template_name, strlen(template_name));
204
205 /* 5th: template length (except for 'ima' template) */
206 if (strcmp(template_name, IMA_TEMPLATE_IMA_NAME) == 0)
207 is_ima_template = true;
208
209 if (!is_ima_template) {
210 template_data_len = !ima_canonical_fmt ? e->template_data_len :
211 (__force u32)cpu_to_le32(e->template_data_len);
212 ima_putc(m, &template_data_len, sizeof(e->template_data_len));
213 }
214
215 /* 6th: template specific data */
216 for (i = 0; i < e->template_desc->num_fields; i++) {
217 enum ima_show_type show = IMA_SHOW_BINARY;
218 const struct ima_template_field *field =
219 e->template_desc->fields[i];
220
221 if (is_ima_template && strcmp(field->field_id, "d") == 0)
222 show = IMA_SHOW_BINARY_NO_FIELD_LEN;
223 if (is_ima_template && strcmp(field->field_id, "n") == 0)
224 show = IMA_SHOW_BINARY_OLD_STRING_FMT;
225 field->field_show(m, show, &e->template_data[i]);
226 }
227 return 0;
228}
229
230static const struct seq_operations ima_measurments_seqops = {
231 .start = ima_measurements_start,
232 .next = ima_measurements_next,
233 .stop = ima_measurements_stop,
234 .show = ima_measurements_show
235};
236
237static const struct seq_operations ima_measurments_staged_seqops = {
238 .start = ima_measurements_staged_start,
239 .next = ima_measurements_staged_next,
240 .stop = ima_measurements_stop,
241 .show = ima_measurements_show
242};
243
244static int ima_measure_lock(bool write)
245{
246 mutex_lock(&ima_measure_mutex);
247 /* Overflow check. */
248 if (!write && ima_measure_users == LONG_MAX) {
249 mutex_unlock(&ima_measure_mutex);
250 return -ENFILE;
251 }
252
253 /* Same writer can do additional writes or read/writes. */
254 if (write && current == measure_writer) {
255 measure_writer_extra_writes++;
256 mutex_unlock(&ima_measure_mutex);
257 return 0;
258 }
259
260 /*
261 * ima_measure_users: > 0 open readers
262 * ima_measure_users: == -1 open writer
263 */
264 if ((write && ima_measure_users != 0) ||
265 (!write && ima_measure_users < 0)) {
266 mutex_unlock(&ima_measure_mutex);
267 return -EBUSY;
268 }
269
270 if (write) {
271 ima_measure_users--;
272 /* Pointer valid, no reuse while the file descriptor is open. */
273 measure_writer = current;
274 } else {
275 ima_measure_users++;
276 }
277 mutex_unlock(&ima_measure_mutex);
278 return 0;
279}
280
281static void ima_measure_unlock(bool write)
282{
283 mutex_lock(&ima_measure_mutex);
284 /* Decrement additional writes or read/writes. */
285 if (write && current == measure_writer &&
286 measure_writer_extra_writes != 0) {
287 measure_writer_extra_writes--;
288 mutex_unlock(&ima_measure_mutex);
289 return;
290 }
291 if (write) {
292 ima_measure_users++;
293 measure_writer = NULL;
294 } else {
295 ima_measure_users--;
296 }
297 mutex_unlock(&ima_measure_mutex);
298}
299
300static int _ima_measurements_open(struct inode *inode, struct file *file,
301 const struct seq_operations *seq_ops)
302{
303 bool write = (file->f_mode & FMODE_WRITE);
304 int ret;
305
306 if (write && !capable(CAP_SYS_ADMIN))
307 return -EPERM;
308
309 ret = ima_measure_lock(write);
310 if (ret < 0)
311 return ret;
312
313 ret = seq_open(file, seq_ops);
314 if (ret < 0)
315 ima_measure_unlock(write);
316
317 return ret;
318}
319
320static int ima_measurements_open(struct inode *inode, struct file *file)
321{
322 return _ima_measurements_open(inode, file, &ima_measurments_seqops);
323}
324
325static int ima_measurements_release(struct inode *inode, struct file *file)
326{
327 bool write = (file->f_mode & FMODE_WRITE);
328 int ret;
329
330 /* seq_release() always returns zero. */
331 ret = seq_release(inode, file);
332
333 ima_measure_unlock(write);
334
335 return ret;
336}
337
338static int ima_measurements_staged_open(struct inode *inode, struct file *file)
339{
340 return _ima_measurements_open(inode, file,
341 &ima_measurments_staged_seqops);
342}
343
344static ssize_t _ima_measurements_write(struct file *file,
345 const char __user *buf, size_t datalen,
346 loff_t *ppos, bool staged_interface)
347{
348 char req[STAGED_REQ_LENGTH];
349 unsigned long req_value;
350 int ret;
351
352 if (datalen < 2 || datalen > STAGED_REQ_LENGTH)
353 return -EINVAL;
354
355 if (copy_from_user(req, buf, datalen) != 0)
356 return -EFAULT;
357
358 if (req[datalen - 1] != '\n')
359 return -EINVAL;
360
361 req[datalen - 1] = '\0';
362
363 switch (req[0]) {
364 case 'A':
365 if (datalen != 2 || !staged_interface)
366 return -EINVAL;
367
368 ret = ima_queue_stage();
369 break;
370 case 'D':
371 if (datalen != 2 || !staged_interface)
372 return -EINVAL;
373
374 ret = ima_queue_staged_delete_all();
375 break;
376 default:
377 if (staged_interface)
378 return -EINVAL;
379
380 if (ima_flush_htable) {
381 pr_debug("Deleting staged N measurements not supported when flushing the hash table is requested\n");
382 return -EINVAL;
383 }
384
385 ret = kstrtoul(req, 10, &req_value);
386 if (ret < 0)
387 return ret;
388
389 if (req_value == 0) {
390 pr_debug("Must delete at least one entry\n");
391 return -EINVAL;
392 }
393
394 ret = ima_queue_delete_partial(req_value);
395 }
396
397 if (ret < 0)
398 return ret;
399
400 return datalen;
401}
402
403static ssize_t ima_measurements_write(struct file *file, const char __user *buf,
404 size_t datalen, loff_t *ppos)
405{
406 return _ima_measurements_write(file, buf, datalen, ppos, false);
407}
408
409static ssize_t ima_measurements_staged_write(struct file *file,
410 const char __user *buf,
411 size_t datalen, loff_t *ppos)
412{
413 return _ima_measurements_write(file, buf, datalen, ppos, true);
414}
415
416static const struct file_operations ima_measurements_ops = {
417 .open = ima_measurements_open,
418 .read = seq_read,
419 .write = ima_measurements_write,
420 .llseek = seq_lseek,
421 .release = ima_measurements_release,
422};
423
424static const struct file_operations ima_measurements_staged_ops = {
425 .open = ima_measurements_staged_open,
426 .read = seq_read,
427 .write = ima_measurements_staged_write,
428 .llseek = seq_lseek,
429 .release = ima_measurements_release,
430};
431
432void ima_print_digest(struct seq_file *m, u8 *digest, u32 size)
433{
434 u32 i;
435
436 for (i = 0; i < size; i++)
437 seq_printf(m, "%02x", *(digest + i));
438}
439
440/* print in ascii */
441static int ima_ascii_measurements_show(struct seq_file *m, void *v)
442{
443 /* the list never shrinks, so we don't need a lock here */
444 struct ima_queue_entry *qe = v;
445 struct ima_template_entry *e;
446 char *template_name;
447 int i, algo_idx;
448
449 algo_idx = ima_sha1_idx;
450
451 if (m->file != NULL)
452 algo_idx = (unsigned long)file_inode(m->file)->i_private;
453
454 /* get entry */
455 e = qe->entry;
456 if (e == NULL)
457 return -1;
458
459 template_name = (e->template_desc->name[0] != '\0') ?
460 e->template_desc->name : e->template_desc->fmt;
461
462 /* 1st: PCR used (config option) */
463 seq_printf(m, "%2d ", e->pcr);
464
465 /* 2nd: template hash */
466 ima_print_digest(m, e->digests[algo_idx].digest,
467 ima_algo_array[algo_idx].digest_size);
468
469 /* 3th: template name */
470 seq_printf(m, " %s", template_name);
471
472 /* 4th: template specific data */
473 for (i = 0; i < e->template_desc->num_fields; i++) {
474 seq_puts(m, " ");
475 if (e->template_data[i].len == 0)
476 continue;
477
478 e->template_desc->fields[i]->field_show(m, IMA_SHOW_ASCII,
479 &e->template_data[i]);
480 }
481 seq_puts(m, "\n");
482 return 0;
483}
484
485static const struct seq_operations ima_ascii_measurements_seqops = {
486 .start = ima_measurements_start,
487 .next = ima_measurements_next,
488 .stop = ima_measurements_stop,
489 .show = ima_ascii_measurements_show
490};
491
492static int ima_ascii_measurements_open(struct inode *inode, struct file *file)
493{
494 return _ima_measurements_open(inode, file,
495 &ima_ascii_measurements_seqops);
496}
497
498static const struct file_operations ima_ascii_measurements_ops = {
499 .open = ima_ascii_measurements_open,
500 .read = seq_read,
501 .write = ima_measurements_write,
502 .llseek = seq_lseek,
503 .release = ima_measurements_release,
504};
505
506static const struct seq_operations ima_ascii_measurements_staged_seqops = {
507 .start = ima_measurements_staged_start,
508 .next = ima_measurements_staged_next,
509 .stop = ima_measurements_stop,
510 .show = ima_ascii_measurements_show
511};
512
513static int ima_ascii_measurements_staged_open(struct inode *inode,
514 struct file *file)
515{
516 return _ima_measurements_open(inode, file,
517 &ima_ascii_measurements_staged_seqops);
518}
519
520static const struct file_operations ima_ascii_measurements_staged_ops = {
521 .open = ima_ascii_measurements_staged_open,
522 .read = seq_read,
523 .write = ima_measurements_staged_write,
524 .llseek = seq_lseek,
525 .release = ima_measurements_release,
526};
527
528static ssize_t ima_read_policy(char *path)
529{
530 void *data = NULL;
531 char *datap;
532 size_t size;
533 int rc, pathlen = strlen(path);
534
535 char *p;
536
537 /* remove \n */
538 datap = path;
539 strsep(&datap, "\n");
540
541 rc = kernel_read_file_from_path(path, 0, &data, INT_MAX, NULL,
542 READING_POLICY);
543 if (rc < 0) {
544 pr_err("Unable to open file: %s (%d)", path, rc);
545 return rc;
546 }
547 size = rc;
548 rc = 0;
549
550 datap = data;
551 while (size > 0 && (p = strsep(&datap, "\n"))) {
552 pr_debug("rule: %s\n", p);
553 rc = ima_parse_add_rule(p);
554 if (rc < 0)
555 break;
556 size -= rc;
557 }
558
559 vfree(data);
560 if (rc < 0)
561 return rc;
562 else if (size)
563 return -EINVAL;
564 else
565 return pathlen;
566}
567
568static ssize_t ima_write_policy(struct file *file, const char __user *buf,
569 size_t datalen, loff_t *ppos)
570{
571 char *data;
572 ssize_t result;
573
574 if (datalen >= PAGE_SIZE)
575 datalen = PAGE_SIZE - 1;
576
577 /* No partial writes. */
578 result = -EINVAL;
579 if (*ppos != 0)
580 goto out;
581
582 data = memdup_user_nul(buf, datalen);
583 if (IS_ERR(data)) {
584 result = PTR_ERR(data);
585 goto out;
586 }
587
588 result = mutex_lock_interruptible(&ima_write_mutex);
589 if (result < 0)
590 goto out_free;
591
592 if (data[0] == '/') {
593 result = ima_read_policy(data);
594 } else if (ima_appraise & IMA_APPRAISE_POLICY) {
595 pr_err("signed policy file (specified as an absolute pathname) required\n");
596 integrity_audit_msg(AUDIT_INTEGRITY_STATUS, NULL, NULL,
597 "policy_update", "signed policy required",
598 1, 0);
599 result = -EACCES;
600 } else {
601 ima_measure_raw_policy(data, datalen);
602 result = ima_parse_add_rule(data);
603 }
604 mutex_unlock(&ima_write_mutex);
605out_free:
606 kfree(data);
607out:
608 if (result < 0)
609 valid_policy = 0;
610
611 return result;
612}
613
614static struct dentry *ima_dir;
615static struct dentry *ima_symlink;
616
617enum ima_fs_flags {
618 IMA_FS_BUSY,
619};
620
621static unsigned long ima_fs_flags;
622
623#ifdef CONFIG_IMA_READ_POLICY
624static const struct seq_operations ima_policy_seqops = {
625 .start = ima_policy_start,
626 .next = ima_policy_next,
627 .stop = ima_policy_stop,
628 .show = ima_policy_show,
629};
630#endif
631
632static int __init create_securityfs_measurement_lists(bool staging)
633{
634 const struct file_operations *ascii_ops = &ima_ascii_measurements_ops;
635 const struct file_operations *binary_ops = &ima_measurements_ops;
636 umode_t permissions = (S_IRUSR | S_IRGRP | S_IWUSR | S_IWGRP);
637 const char *file_suffix = "";
638 int count = NR_BANKS(ima_tpm_chip);
639
640 if (staging) {
641 ascii_ops = &ima_ascii_measurements_staged_ops;
642 binary_ops = &ima_measurements_staged_ops;
643 file_suffix = "_staged";
644 }
645
646 if (ima_sha1_idx >= NR_BANKS(ima_tpm_chip))
647 count++;
648
649 for (int i = 0; i < count; i++) {
650 u16 algo = ima_algo_array[i].algo;
651 char file_name[NAME_MAX + 1];
652 struct dentry *dentry;
653
654 if (algo == HASH_ALGO__LAST)
655 snprintf(file_name, sizeof(file_name),
656 "ascii_runtime_measurements_tpm_alg_%x%s",
657 ima_tpm_chip->allocated_banks[i].alg_id,
658 file_suffix);
659 else
660 snprintf(file_name, sizeof(file_name),
661 "ascii_runtime_measurements_%s%s",
662 hash_algo_name[algo], file_suffix);
663 dentry = securityfs_create_file(file_name, permissions,
664 ima_dir, (void *)(uintptr_t)i,
665 ascii_ops);
666 if (IS_ERR(dentry))
667 return PTR_ERR(dentry);
668
669 if (algo == HASH_ALGO__LAST)
670 snprintf(file_name, sizeof(file_name),
671 "binary_runtime_measurements_tpm_alg_%x%s",
672 ima_tpm_chip->allocated_banks[i].alg_id,
673 file_suffix);
674 else
675 snprintf(file_name, sizeof(file_name),
676 "binary_runtime_measurements_%s%s",
677 hash_algo_name[algo], file_suffix);
678
679 dentry = securityfs_create_file(file_name, permissions,
680 ima_dir, (void *)(uintptr_t)i,
681 binary_ops);
682 if (IS_ERR(dentry))
683 return PTR_ERR(dentry);
684 }
685
686 return 0;
687}
688
689static int __init create_securityfs_staging_links(void)
690{
691 struct dentry *dentry;
692
693 dentry = securityfs_create_symlink("binary_runtime_measurements_staged",
694 ima_dir, "binary_runtime_measurements_sha1_staged", NULL);
695 if (IS_ERR(dentry))
696 return PTR_ERR(dentry);
697
698 dentry = securityfs_create_symlink("ascii_runtime_measurements_staged",
699 ima_dir, "ascii_runtime_measurements_sha1_staged", NULL);
700 if (IS_ERR(dentry))
701 return PTR_ERR(dentry);
702
703 return 0;
704}
705
706/*
707 * ima_open_policy: sequentialize access to the policy file
708 */
709static int ima_open_policy(struct inode *inode, struct file *filp)
710{
711 if (!(filp->f_flags & O_WRONLY)) {
712#ifndef CONFIG_IMA_READ_POLICY
713 return -EACCES;
714#else
715 if ((filp->f_flags & O_ACCMODE) != O_RDONLY)
716 return -EACCES;
717 if (!capable(CAP_SYS_ADMIN))
718 return -EPERM;
719 return seq_open(filp, &ima_policy_seqops);
720#endif
721 }
722 if (test_and_set_bit(IMA_FS_BUSY, &ima_fs_flags))
723 return -EBUSY;
724 return 0;
725}
726
727/*
728 * ima_release_policy - start using the new measure policy rules.
729 *
730 * Initially, ima_measure points to the default policy rules, now
731 * point to the new policy rules, and remove the securityfs policy file,
732 * assuming a valid policy.
733 */
734static int ima_release_policy(struct inode *inode, struct file *file)
735{
736 const char *cause = valid_policy ? "completed" : "failed";
737
738 if ((file->f_flags & O_ACCMODE) == O_RDONLY)
739 return seq_release(inode, file);
740
741 if (valid_policy && ima_check_policy() < 0) {
742 cause = "failed";
743 valid_policy = 0;
744 }
745
746 pr_info("policy update %s\n", cause);
747 integrity_audit_msg(AUDIT_INTEGRITY_STATUS, NULL, NULL,
748 "policy_update", cause, !valid_policy, 0);
749
750 if (!valid_policy) {
751 ima_delete_rules();
752 valid_policy = 1;
753 clear_bit(IMA_FS_BUSY, &ima_fs_flags);
754 return 0;
755 }
756
757 ima_update_policy();
758
759 mutex_lock(&ima_write_mutex);
760 ima_measure_loaded_policy();
761 mutex_unlock(&ima_write_mutex);
762#if !defined(CONFIG_IMA_WRITE_POLICY) && !defined(CONFIG_IMA_READ_POLICY)
763 securityfs_remove(file->f_path.dentry);
764#elif defined(CONFIG_IMA_WRITE_POLICY)
765 clear_bit(IMA_FS_BUSY, &ima_fs_flags);
766#elif defined(CONFIG_IMA_READ_POLICY)
767 inode->i_mode &= ~S_IWUSR;
768#endif
769 return 0;
770}
771
772static const struct file_operations ima_measure_policy_ops = {
773 .open = ima_open_policy,
774 .write = ima_write_policy,
775 .read = seq_read,
776 .release = ima_release_policy,
777 .llseek = generic_file_llseek,
778};
779
780int __init ima_fs_init(void)
781{
782 struct dentry *dentry;
783 int ret;
784
785 ret = integrity_fs_init();
786 if (ret < 0)
787 return ret;
788
789 ima_dir = securityfs_create_dir("ima", integrity_dir);
790 if (IS_ERR(ima_dir)) {
791 ret = PTR_ERR(ima_dir);
792 goto out;
793 }
794
795 ima_symlink = securityfs_create_symlink("ima", NULL, "integrity/ima",
796 NULL);
797 if (IS_ERR(ima_symlink)) {
798 ret = PTR_ERR(ima_symlink);
799 goto out;
800 }
801
802 ret = create_securityfs_measurement_lists(false);
803 if (ret == 0 && IS_ENABLED(CONFIG_IMA_STAGING)) {
804 ret = create_securityfs_measurement_lists(true);
805 if (ret == 0)
806 ret = create_securityfs_staging_links();
807 }
808
809 if (ret != 0)
810 goto out;
811
812 dentry = securityfs_create_symlink("binary_runtime_measurements", ima_dir,
813 "binary_runtime_measurements_sha1", NULL);
814 if (IS_ERR(dentry)) {
815 ret = PTR_ERR(dentry);
816 goto out;
817 }
818
819 dentry = securityfs_create_symlink("ascii_runtime_measurements", ima_dir,
820 "ascii_runtime_measurements_sha1", NULL);
821 if (IS_ERR(dentry)) {
822 ret = PTR_ERR(dentry);
823 goto out;
824 }
825
826 dentry = securityfs_create_file("runtime_measurements_count",
827 S_IRUSR | S_IRGRP, ima_dir, NULL,
828 &ima_measurements_count_ops);
829 if (IS_ERR(dentry)) {
830 ret = PTR_ERR(dentry);
831 goto out;
832 }
833
834 dentry = securityfs_create_file("violations", S_IRUSR | S_IRGRP,
835 ima_dir, NULL, &ima_num_violations_ops);
836 if (IS_ERR(dentry)) {
837 ret = PTR_ERR(dentry);
838 goto out;
839 }
840
841 dentry = securityfs_create_file("policy", POLICY_FILE_FLAGS,
842 ima_dir, NULL,
843 &ima_measure_policy_ops);
844 if (IS_ERR(dentry)) {
845 ret = PTR_ERR(dentry);
846 goto out;
847 }
848
849 return 0;
850out:
851 securityfs_remove(ima_symlink);
852 securityfs_remove(ima_dir);
853 integrity_fs_fini();
854
855 return ret;
856}