1/*
2 * Security plug functions
3 *
4 * Copyright (C) 2001 WireX Communications, Inc <chris@wirex.com>
5 * Copyright (C) 2001-2002 Greg Kroah-Hartman <greg@kroah.com>
6 * Copyright (C) 2001 Networks Associates Technology, Inc <ssmalley@nai.com>
7 * Copyright (C) 2016 Mellanox Technologies
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 */
14
15#define pr_fmt(fmt) "LSM: " fmt
16
17#include <linux/bpf.h>
18#include <linux/capability.h>
19#include <linux/dcache.h>
20#include <linux/export.h>
21#include <linux/init.h>
22#include <linux/kernel.h>
23#include <linux/lsm_hooks.h>
24#include <linux/integrity.h>
25#include <linux/ima.h>
26#include <linux/evm.h>
27#include <linux/fsnotify.h>
28#include <linux/mman.h>
29#include <linux/mount.h>
30#include <linux/personality.h>
31#include <linux/backing-dev.h>
32#include <linux/string.h>
33#include <linux/msg.h>
34#include <net/flow.h>
35
36#define MAX_LSM_EVM_XATTR 2
37
38/* How many LSMs were built into the kernel? */
39#define LSM_COUNT (__end_lsm_info - __start_lsm_info)
40
41struct security_hook_heads security_hook_heads __lsm_ro_after_init;
42static ATOMIC_NOTIFIER_HEAD(lsm_notifier_chain);
43
44static struct kmem_cache *lsm_file_cache;
45static struct kmem_cache *lsm_inode_cache;
46
47char *lsm_names;
48static struct lsm_blob_sizes blob_sizes __lsm_ro_after_init;
49
50/* Boot-time LSM user choice */
51static __initdata const char *chosen_lsm_order;
52static __initdata const char *chosen_major_lsm;
53
54static __initconst const char * const builtin_lsm_order = CONFIG_LSM;
55
56/* Ordered list of LSMs to initialize. */
57static __initdata struct lsm_info **ordered_lsms;
58static __initdata struct lsm_info *exclusive;
59
60static __initdata bool debug;
61#define init_debug(...) \
62 do { \
63 if (debug) \
64 pr_info(__VA_ARGS__); \
65 } while (0)
66
67static bool __init is_enabled(struct lsm_info *lsm)
68{
69 if (!lsm->enabled)
70 return false;
71
72 return *lsm->enabled;
73}
74
75/* Mark an LSM's enabled flag. */
76static int lsm_enabled_true __initdata = 1;
77static int lsm_enabled_false __initdata = 0;
78static void __init set_enabled(struct lsm_info *lsm, bool enabled)
79{
80 /*
81 * When an LSM hasn't configured an enable variable, we can use
82 * a hard-coded location for storing the default enabled state.
83 */
84 if (!lsm->enabled) {
85 if (enabled)
86 lsm->enabled = &lsm_enabled_true;
87 else
88 lsm->enabled = &lsm_enabled_false;
89 } else if (lsm->enabled == &lsm_enabled_true) {
90 if (!enabled)
91 lsm->enabled = &lsm_enabled_false;
92 } else if (lsm->enabled == &lsm_enabled_false) {
93 if (enabled)
94 lsm->enabled = &lsm_enabled_true;
95 } else {
96 *lsm->enabled = enabled;
97 }
98}
99
100/* Is an LSM already listed in the ordered LSMs list? */
101static bool __init exists_ordered_lsm(struct lsm_info *lsm)
102{
103 struct lsm_info **check;
104
105 for (check = ordered_lsms; *check; check++)
106 if (*check == lsm)
107 return true;
108
109 return false;
110}
111
112/* Append an LSM to the list of ordered LSMs to initialize. */
113static int last_lsm __initdata;
114static void __init append_ordered_lsm(struct lsm_info *lsm, const char *from)
115{
116 /* Ignore duplicate selections. */
117 if (exists_ordered_lsm(lsm))
118 return;
119
120 if (WARN(last_lsm == LSM_COUNT, "%s: out of LSM slots!?\n", from))
121 return;
122
123 /* Enable this LSM, if it is not already set. */
124 if (!lsm->enabled)
125 lsm->enabled = &lsm_enabled_true;
126 ordered_lsms[last_lsm++] = lsm;
127
128 init_debug("%s ordering: %s (%sabled)\n", from, lsm->name,
129 is_enabled(lsm) ? "en" : "dis");
130}
131
132/* Is an LSM allowed to be initialized? */
133static bool __init lsm_allowed(struct lsm_info *lsm)
134{
135 /* Skip if the LSM is disabled. */
136 if (!is_enabled(lsm))
137 return false;
138
139 /* Not allowed if another exclusive LSM already initialized. */
140 if ((lsm->flags & LSM_FLAG_EXCLUSIVE) && exclusive) {
141 init_debug("exclusive disabled: %s\n", lsm->name);
142 return false;
143 }
144
145 return true;
146}
147
148static void __init lsm_set_blob_size(int *need, int *lbs)
149{
150 int offset;
151
152 if (*need > 0) {
153 offset = *lbs;
154 *lbs += *need;
155 *need = offset;
156 }
157}
158
159static void __init lsm_set_blob_sizes(struct lsm_blob_sizes *needed)
160{
161 if (!needed)
162 return;
163
164 lsm_set_blob_size(&needed->lbs_cred, &blob_sizes.lbs_cred);
165 lsm_set_blob_size(&needed->lbs_file, &blob_sizes.lbs_file);
166 /*
167 * The inode blob gets an rcu_head in addition to
168 * what the modules might need.
169 */
170 if (needed->lbs_inode && blob_sizes.lbs_inode == 0)
171 blob_sizes.lbs_inode = sizeof(struct rcu_head);
172 lsm_set_blob_size(&needed->lbs_inode, &blob_sizes.lbs_inode);
173 lsm_set_blob_size(&needed->lbs_ipc, &blob_sizes.lbs_ipc);
174 lsm_set_blob_size(&needed->lbs_msg_msg, &blob_sizes.lbs_msg_msg);
175 lsm_set_blob_size(&needed->lbs_task, &blob_sizes.lbs_task);
176}
177
178/* Prepare LSM for initialization. */
179static void __init prepare_lsm(struct lsm_info *lsm)
180{
181 int enabled = lsm_allowed(lsm);
182
183 /* Record enablement (to handle any following exclusive LSMs). */
184 set_enabled(lsm, enabled);
185
186 /* If enabled, do pre-initialization work. */
187 if (enabled) {
188 if ((lsm->flags & LSM_FLAG_EXCLUSIVE) && !exclusive) {
189 exclusive = lsm;
190 init_debug("exclusive chosen: %s\n", lsm->name);
191 }
192
193 lsm_set_blob_sizes(lsm->blobs);
194 }
195}
196
197/* Initialize a given LSM, if it is enabled. */
198static void __init initialize_lsm(struct lsm_info *lsm)
199{
200 if (is_enabled(lsm)) {
201 int ret;
202
203 init_debug("initializing %s\n", lsm->name);
204 ret = lsm->init();
205 WARN(ret, "%s failed to initialize: %d\n", lsm->name, ret);
206 }
207}
208
209/* Populate ordered LSMs list from comma-separated LSM name list. */
210static void __init ordered_lsm_parse(const char *order, const char *origin)
211{
212 struct lsm_info *lsm;
213 char *sep, *name, *next;
214
215 /* LSM_ORDER_FIRST is always first. */
216 for (lsm = __start_lsm_info; lsm < __end_lsm_info; lsm++) {
217 if (lsm->order == LSM_ORDER_FIRST)
218 append_ordered_lsm(lsm, "first");
219 }
220
221 /* Process "security=", if given. */
222 if (chosen_major_lsm) {
223 struct lsm_info *major;
224
225 /*
226 * To match the original "security=" behavior, this
227 * explicitly does NOT fallback to another Legacy Major
228 * if the selected one was separately disabled: disable
229 * all non-matching Legacy Major LSMs.
230 */
231 for (major = __start_lsm_info; major < __end_lsm_info;
232 major++) {
233 if ((major->flags & LSM_FLAG_LEGACY_MAJOR) &&
234 strcmp(major->name, chosen_major_lsm) != 0) {
235 set_enabled(major, false);
236 init_debug("security=%s disabled: %s\n",
237 chosen_major_lsm, major->name);
238 }
239 }
240 }
241
242 sep = kstrdup(order, GFP_KERNEL);
243 next = sep;
244 /* Walk the list, looking for matching LSMs. */
245 while ((name = strsep(&next, ",")) != NULL) {
246 bool found = false;
247
248 for (lsm = __start_lsm_info; lsm < __end_lsm_info; lsm++) {
249 if (lsm->order == LSM_ORDER_MUTABLE &&
250 strcmp(lsm->name, name) == 0) {
251 append_ordered_lsm(lsm, origin);
252 found = true;
253 }
254 }
255
256 if (!found)
257 init_debug("%s ignored: %s\n", origin, name);
258 }
259
260 /* Process "security=", if given. */
261 if (chosen_major_lsm) {
262 for (lsm = __start_lsm_info; lsm < __end_lsm_info; lsm++) {
263 if (exists_ordered_lsm(lsm))
264 continue;
265 if (strcmp(lsm->name, chosen_major_lsm) == 0)
266 append_ordered_lsm(lsm, "security=");
267 }
268 }
269
270 /* Disable all LSMs not in the ordered list. */
271 for (lsm = __start_lsm_info; lsm < __end_lsm_info; lsm++) {
272 if (exists_ordered_lsm(lsm))
273 continue;
274 set_enabled(lsm, false);
275 init_debug("%s disabled: %s\n", origin, lsm->name);
276 }
277
278 kfree(sep);
279}
280
281static void __init lsm_early_cred(struct cred *cred);
282static void __init lsm_early_task(struct task_struct *task);
283
284static void __init ordered_lsm_init(void)
285{
286 struct lsm_info **lsm;
287
288 ordered_lsms = kcalloc(LSM_COUNT + 1, sizeof(*ordered_lsms),
289 GFP_KERNEL);
290
291 if (chosen_lsm_order) {
292 if (chosen_major_lsm) {
293 pr_info("security= is ignored because it is superseded by lsm=\n");
294 chosen_major_lsm = NULL;
295 }
296 ordered_lsm_parse(chosen_lsm_order, "cmdline");
297 } else
298 ordered_lsm_parse(builtin_lsm_order, "builtin");
299
300 for (lsm = ordered_lsms; *lsm; lsm++)
301 prepare_lsm(*lsm);
302
303 init_debug("cred blob size = %d\n", blob_sizes.lbs_cred);
304 init_debug("file blob size = %d\n", blob_sizes.lbs_file);
305 init_debug("inode blob size = %d\n", blob_sizes.lbs_inode);
306 init_debug("ipc blob size = %d\n", blob_sizes.lbs_ipc);
307 init_debug("msg_msg blob size = %d\n", blob_sizes.lbs_msg_msg);
308 init_debug("task blob size = %d\n", blob_sizes.lbs_task);
309
310 /*
311 * Create any kmem_caches needed for blobs
312 */
313 if (blob_sizes.lbs_file)
314 lsm_file_cache = kmem_cache_create("lsm_file_cache",
315 blob_sizes.lbs_file, 0,
316 SLAB_PANIC, NULL);
317 if (blob_sizes.lbs_inode)
318 lsm_inode_cache = kmem_cache_create("lsm_inode_cache",
319 blob_sizes.lbs_inode, 0,
320 SLAB_PANIC, NULL);
321
322 lsm_early_cred((struct cred *) current->cred);
323 lsm_early_task(current);
324 for (lsm = ordered_lsms; *lsm; lsm++)
325 initialize_lsm(*lsm);
326
327 kfree(ordered_lsms);
328}
329
330/**
331 * security_init - initializes the security framework
332 *
333 * This should be called early in the kernel initialization sequence.
334 */
335int __init security_init(void)
336{
337 int i;
338 struct hlist_head *list = (struct hlist_head *) &security_hook_heads;
339
340 pr_info("Security Framework initializing\n");
341
342 for (i = 0; i < sizeof(security_hook_heads) / sizeof(struct hlist_head);
343 i++)
344 INIT_HLIST_HEAD(&list[i]);
345
346 /* Load LSMs in specified order. */
347 ordered_lsm_init();
348
349 return 0;
350}
351
352/* Save user chosen LSM */
353static int __init choose_major_lsm(char *str)
354{
355 chosen_major_lsm = str;
356 return 1;
357}
358__setup("security=", choose_major_lsm);
359
360/* Explicitly choose LSM initialization order. */
361static int __init choose_lsm_order(char *str)
362{
363 chosen_lsm_order = str;
364 return 1;
365}
366__setup("lsm=", choose_lsm_order);
367
368/* Enable LSM order debugging. */
369static int __init enable_debug(char *str)
370{
371 debug = true;
372 return 1;
373}
374__setup("lsm.debug", enable_debug);
375
376static bool match_last_lsm(const char *list, const char *lsm)
377{
378 const char *last;
379
380 if (WARN_ON(!list || !lsm))
381 return false;
382 last = strrchr(list, ',');
383 if (last)
384 /* Pass the comma, strcmp() will check for '\0' */
385 last++;
386 else
387 last = list;
388 return !strcmp(last, lsm);
389}
390
391static int lsm_append(char *new, char **result)
392{
393 char *cp;
394
395 if (*result == NULL) {
396 *result = kstrdup(new, GFP_KERNEL);
397 if (*result == NULL)
398 return -ENOMEM;
399 } else {
400 /* Check if it is the last registered name */
401 if (match_last_lsm(*result, new))
402 return 0;
403 cp = kasprintf(GFP_KERNEL, "%s,%s", *result, new);
404 if (cp == NULL)
405 return -ENOMEM;
406 kfree(*result);
407 *result = cp;
408 }
409 return 0;
410}
411
412/**
413 * security_add_hooks - Add a modules hooks to the hook lists.
414 * @hooks: the hooks to add
415 * @count: the number of hooks to add
416 * @lsm: the name of the security module
417 *
418 * Each LSM has to register its hooks with the infrastructure.
419 */
420void __init security_add_hooks(struct security_hook_list *hooks, int count,
421 char *lsm)
422{
423 int i;
424
425 for (i = 0; i < count; i++) {
426 hooks[i].lsm = lsm;
427 hlist_add_tail_rcu(&hooks[i].list, hooks[i].head);
428 }
429 if (lsm_append(lsm, &lsm_names) < 0)
430 panic("%s - Cannot get early memory.\n", __func__);
431}
432
433int call_lsm_notifier(enum lsm_event event, void *data)
434{
435 return atomic_notifier_call_chain(&lsm_notifier_chain, event, data);
436}
437EXPORT_SYMBOL(call_lsm_notifier);
438
439int register_lsm_notifier(struct notifier_block *nb)
440{
441 return atomic_notifier_chain_register(&lsm_notifier_chain, nb);
442}
443EXPORT_SYMBOL(register_lsm_notifier);
444
445int unregister_lsm_notifier(struct notifier_block *nb)
446{
447 return atomic_notifier_chain_unregister(&lsm_notifier_chain, nb);
448}
449EXPORT_SYMBOL(unregister_lsm_notifier);
450
451/**
452 * lsm_cred_alloc - allocate a composite cred blob
453 * @cred: the cred that needs a blob
454 * @gfp: allocation type
455 *
456 * Allocate the cred blob for all the modules
457 *
458 * Returns 0, or -ENOMEM if memory can't be allocated.
459 */
460static int lsm_cred_alloc(struct cred *cred, gfp_t gfp)
461{
462 if (blob_sizes.lbs_cred == 0) {
463 cred->security = NULL;
464 return 0;
465 }
466
467 cred->security = kzalloc(blob_sizes.lbs_cred, gfp);
468 if (cred->security == NULL)
469 return -ENOMEM;
470 return 0;
471}
472
473/**
474 * lsm_early_cred - during initialization allocate a composite cred blob
475 * @cred: the cred that needs a blob
476 *
477 * Allocate the cred blob for all the modules
478 */
479static void __init lsm_early_cred(struct cred *cred)
480{
481 int rc = lsm_cred_alloc(cred, GFP_KERNEL);
482
483 if (rc)
484 panic("%s: Early cred alloc failed.\n", __func__);
485}
486
487/**
488 * lsm_file_alloc - allocate a composite file blob
489 * @file: the file that needs a blob
490 *
491 * Allocate the file blob for all the modules
492 *
493 * Returns 0, or -ENOMEM if memory can't be allocated.
494 */
495static int lsm_file_alloc(struct file *file)
496{
497 if (!lsm_file_cache) {
498 file->f_security = NULL;
499 return 0;
500 }
501
502 file->f_security = kmem_cache_zalloc(lsm_file_cache, GFP_KERNEL);
503 if (file->f_security == NULL)
504 return -ENOMEM;
505 return 0;
506}
507
508/**
509 * lsm_inode_alloc - allocate a composite inode blob
510 * @inode: the inode that needs a blob
511 *
512 * Allocate the inode blob for all the modules
513 *
514 * Returns 0, or -ENOMEM if memory can't be allocated.
515 */
516int lsm_inode_alloc(struct inode *inode)
517{
518 if (!lsm_inode_cache) {
519 inode->i_security = NULL;
520 return 0;
521 }
522
523 inode->i_security = kmem_cache_zalloc(lsm_inode_cache, GFP_NOFS);
524 if (inode->i_security == NULL)
525 return -ENOMEM;
526 return 0;
527}
528
529/**
530 * lsm_task_alloc - allocate a composite task blob
531 * @task: the task that needs a blob
532 *
533 * Allocate the task blob for all the modules
534 *
535 * Returns 0, or -ENOMEM if memory can't be allocated.
536 */
537static int lsm_task_alloc(struct task_struct *task)
538{
539 if (blob_sizes.lbs_task == 0) {
540 task->security = NULL;
541 return 0;
542 }
543
544 task->security = kzalloc(blob_sizes.lbs_task, GFP_KERNEL);
545 if (task->security == NULL)
546 return -ENOMEM;
547 return 0;
548}
549
550/**
551 * lsm_ipc_alloc - allocate a composite ipc blob
552 * @kip: the ipc that needs a blob
553 *
554 * Allocate the ipc blob for all the modules
555 *
556 * Returns 0, or -ENOMEM if memory can't be allocated.
557 */
558static int lsm_ipc_alloc(struct kern_ipc_perm *kip)
559{
560 if (blob_sizes.lbs_ipc == 0) {
561 kip->security = NULL;
562 return 0;
563 }
564
565 kip->security = kzalloc(blob_sizes.lbs_ipc, GFP_KERNEL);
566 if (kip->security == NULL)
567 return -ENOMEM;
568 return 0;
569}
570
571/**
572 * lsm_msg_msg_alloc - allocate a composite msg_msg blob
573 * @mp: the msg_msg that needs a blob
574 *
575 * Allocate the ipc blob for all the modules
576 *
577 * Returns 0, or -ENOMEM if memory can't be allocated.
578 */
579static int lsm_msg_msg_alloc(struct msg_msg *mp)
580{
581 if (blob_sizes.lbs_msg_msg == 0) {
582 mp->security = NULL;
583 return 0;
584 }
585
586 mp->security = kzalloc(blob_sizes.lbs_msg_msg, GFP_KERNEL);
587 if (mp->security == NULL)
588 return -ENOMEM;
589 return 0;
590}
591
592/**
593 * lsm_early_task - during initialization allocate a composite task blob
594 * @task: the task that needs a blob
595 *
596 * Allocate the task blob for all the modules
597 */
598static void __init lsm_early_task(struct task_struct *task)
599{
600 int rc = lsm_task_alloc(task);
601
602 if (rc)
603 panic("%s: Early task alloc failed.\n", __func__);
604}
605
606/*
607 * Hook list operation macros.
608 *
609 * call_void_hook:
610 * This is a hook that does not return a value.
611 *
612 * call_int_hook:
613 * This is a hook that returns a value.
614 */
615
616#define call_void_hook(FUNC, ...) \
617 do { \
618 struct security_hook_list *P; \
619 \
620 hlist_for_each_entry(P, &security_hook_heads.FUNC, list) \
621 P->hook.FUNC(__VA_ARGS__); \
622 } while (0)
623
624#define call_int_hook(FUNC, IRC, ...) ({ \
625 int RC = IRC; \
626 do { \
627 struct security_hook_list *P; \
628 \
629 hlist_for_each_entry(P, &security_hook_heads.FUNC, list) { \
630 RC = P->hook.FUNC(__VA_ARGS__); \
631 if (RC != 0) \
632 break; \
633 } \
634 } while (0); \
635 RC; \
636})
637
638/* Security operations */
639
640int security_binder_set_context_mgr(struct task_struct *mgr)
641{
642 return call_int_hook(binder_set_context_mgr, 0, mgr);
643}
644
645int security_binder_transaction(struct task_struct *from,
646 struct task_struct *to)
647{
648 return call_int_hook(binder_transaction, 0, from, to);
649}
650
651int security_binder_transfer_binder(struct task_struct *from,
652 struct task_struct *to)
653{
654 return call_int_hook(binder_transfer_binder, 0, from, to);
655}
656
657int security_binder_transfer_file(struct task_struct *from,
658 struct task_struct *to, struct file *file)
659{
660 return call_int_hook(binder_transfer_file, 0, from, to, file);
661}
662
663int security_ptrace_access_check(struct task_struct *child, unsigned int mode)
664{
665 return call_int_hook(ptrace_access_check, 0, child, mode);
666}
667
668int security_ptrace_traceme(struct task_struct *parent)
669{
670 return call_int_hook(ptrace_traceme, 0, parent);
671}
672
673int security_capget(struct task_struct *target,
674 kernel_cap_t *effective,
675 kernel_cap_t *inheritable,
676 kernel_cap_t *permitted)
677{
678 return call_int_hook(capget, 0, target,
679 effective, inheritable, permitted);
680}
681
682int security_capset(struct cred *new, const struct cred *old,
683 const kernel_cap_t *effective,
684 const kernel_cap_t *inheritable,
685 const kernel_cap_t *permitted)
686{
687 return call_int_hook(capset, 0, new, old,
688 effective, inheritable, permitted);
689}
690
691int security_capable(const struct cred *cred,
692 struct user_namespace *ns,
693 int cap,
694 unsigned int opts)
695{
696 return call_int_hook(capable, 0, cred, ns, cap, opts);
697}
698
699int security_quotactl(int cmds, int type, int id, struct super_block *sb)
700{
701 return call_int_hook(quotactl, 0, cmds, type, id, sb);
702}
703
704int security_quota_on(struct dentry *dentry)
705{
706 return call_int_hook(quota_on, 0, dentry);
707}
708
709int security_syslog(int type)
710{
711 return call_int_hook(syslog, 0, type);
712}
713
714int security_settime64(const struct timespec64 *ts, const struct timezone *tz)
715{
716 return call_int_hook(settime, 0, ts, tz);
717}
718
719int security_vm_enough_memory_mm(struct mm_struct *mm, long pages)
720{
721 struct security_hook_list *hp;
722 int cap_sys_admin = 1;
723 int rc;
724
725 /*
726 * The module will respond with a positive value if
727 * it thinks the __vm_enough_memory() call should be
728 * made with the cap_sys_admin set. If all of the modules
729 * agree that it should be set it will. If any module
730 * thinks it should not be set it won't.
731 */
732 hlist_for_each_entry(hp, &security_hook_heads.vm_enough_memory, list) {
733 rc = hp->hook.vm_enough_memory(mm, pages);
734 if (rc <= 0) {
735 cap_sys_admin = 0;
736 break;
737 }
738 }
739 return __vm_enough_memory(mm, pages, cap_sys_admin);
740}
741
742int security_bprm_set_creds(struct linux_binprm *bprm)
743{
744 return call_int_hook(bprm_set_creds, 0, bprm);
745}
746
747int security_bprm_check(struct linux_binprm *bprm)
748{
749 int ret;
750
751 ret = call_int_hook(bprm_check_security, 0, bprm);
752 if (ret)
753 return ret;
754 return ima_bprm_check(bprm);
755}
756
757void security_bprm_committing_creds(struct linux_binprm *bprm)
758{
759 call_void_hook(bprm_committing_creds, bprm);
760}
761
762void security_bprm_committed_creds(struct linux_binprm *bprm)
763{
764 call_void_hook(bprm_committed_creds, bprm);
765}
766
767int security_fs_context_dup(struct fs_context *fc, struct fs_context *src_fc)
768{
769 return call_int_hook(fs_context_dup, 0, fc, src_fc);
770}
771
772int security_fs_context_parse_param(struct fs_context *fc, struct fs_parameter *param)
773{
774 return call_int_hook(fs_context_parse_param, -ENOPARAM, fc, param);
775}
776
777int security_sb_alloc(struct super_block *sb)
778{
779 return call_int_hook(sb_alloc_security, 0, sb);
780}
781
782void security_sb_free(struct super_block *sb)
783{
784 call_void_hook(sb_free_security, sb);
785}
786
787void security_free_mnt_opts(void **mnt_opts)
788{
789 if (!*mnt_opts)
790 return;
791 call_void_hook(sb_free_mnt_opts, *mnt_opts);
792 *mnt_opts = NULL;
793}
794EXPORT_SYMBOL(security_free_mnt_opts);
795
796int security_sb_eat_lsm_opts(char *options, void **mnt_opts)
797{
798 return call_int_hook(sb_eat_lsm_opts, 0, options, mnt_opts);
799}
800EXPORT_SYMBOL(security_sb_eat_lsm_opts);
801
802int security_sb_remount(struct super_block *sb,
803 void *mnt_opts)
804{
805 return call_int_hook(sb_remount, 0, sb, mnt_opts);
806}
807EXPORT_SYMBOL(security_sb_remount);
808
809int security_sb_kern_mount(struct super_block *sb)
810{
811 return call_int_hook(sb_kern_mount, 0, sb);
812}
813
814int security_sb_show_options(struct seq_file *m, struct super_block *sb)
815{
816 return call_int_hook(sb_show_options, 0, m, sb);
817}
818
819int security_sb_statfs(struct dentry *dentry)
820{
821 return call_int_hook(sb_statfs, 0, dentry);
822}
823
824int security_sb_mount(const char *dev_name, const struct path *path,
825 const char *type, unsigned long flags, void *data)
826{
827 return call_int_hook(sb_mount, 0, dev_name, path, type, flags, data);
828}
829
830int security_sb_umount(struct vfsmount *mnt, int flags)
831{
832 return call_int_hook(sb_umount, 0, mnt, flags);
833}
834
835int security_sb_pivotroot(const struct path *old_path, const struct path *new_path)
836{
837 return call_int_hook(sb_pivotroot, 0, old_path, new_path);
838}
839
840int security_sb_set_mnt_opts(struct super_block *sb,
841 void *mnt_opts,
842 unsigned long kern_flags,
843 unsigned long *set_kern_flags)
844{
845 return call_int_hook(sb_set_mnt_opts,
846 mnt_opts ? -EOPNOTSUPP : 0, sb,
847 mnt_opts, kern_flags, set_kern_flags);
848}
849EXPORT_SYMBOL(security_sb_set_mnt_opts);
850
851int security_sb_clone_mnt_opts(const struct super_block *oldsb,
852 struct super_block *newsb,
853 unsigned long kern_flags,
854 unsigned long *set_kern_flags)
855{
856 return call_int_hook(sb_clone_mnt_opts, 0, oldsb, newsb,
857 kern_flags, set_kern_flags);
858}
859EXPORT_SYMBOL(security_sb_clone_mnt_opts);
860
861int security_add_mnt_opt(const char *option, const char *val, int len,
862 void **mnt_opts)
863{
864 return call_int_hook(sb_add_mnt_opt, -EINVAL,
865 option, val, len, mnt_opts);
866}
867EXPORT_SYMBOL(security_add_mnt_opt);
868
869int security_inode_alloc(struct inode *inode)
870{
871 int rc = lsm_inode_alloc(inode);
872
873 if (unlikely(rc))
874 return rc;
875 rc = call_int_hook(inode_alloc_security, 0, inode);
876 if (unlikely(rc))
877 security_inode_free(inode);
878 return rc;
879}
880
881static void inode_free_by_rcu(struct rcu_head *head)
882{
883 /*
884 * The rcu head is at the start of the inode blob
885 */
886 kmem_cache_free(lsm_inode_cache, head);
887}
888
889void security_inode_free(struct inode *inode)
890{
891 integrity_inode_free(inode);
892 call_void_hook(inode_free_security, inode);
893 /*
894 * The inode may still be referenced in a path walk and
895 * a call to security_inode_permission() can be made
896 * after inode_free_security() is called. Ideally, the VFS
897 * wouldn't do this, but fixing that is a much harder
898 * job. For now, simply free the i_security via RCU, and
899 * leave the current inode->i_security pointer intact.
900 * The inode will be freed after the RCU grace period too.
901 */
902 if (inode->i_security)
903 call_rcu((struct rcu_head *)inode->i_security,
904 inode_free_by_rcu);
905}
906
907int security_dentry_init_security(struct dentry *dentry, int mode,
908 const struct qstr *name, void **ctx,
909 u32 *ctxlen)
910{
911 return call_int_hook(dentry_init_security, -EOPNOTSUPP, dentry, mode,
912 name, ctx, ctxlen);
913}
914EXPORT_SYMBOL(security_dentry_init_security);
915
916int security_dentry_create_files_as(struct dentry *dentry, int mode,
917 struct qstr *name,
918 const struct cred *old, struct cred *new)
919{
920 return call_int_hook(dentry_create_files_as, 0, dentry, mode,
921 name, old, new);
922}
923EXPORT_SYMBOL(security_dentry_create_files_as);
924
925int security_inode_init_security(struct inode *inode, struct inode *dir,
926 const struct qstr *qstr,
927 const initxattrs initxattrs, void *fs_data)
928{
929 struct xattr new_xattrs[MAX_LSM_EVM_XATTR + 1];
930 struct xattr *lsm_xattr, *evm_xattr, *xattr;
931 int ret;
932
933 if (unlikely(IS_PRIVATE(inode)))
934 return 0;
935
936 if (!initxattrs)
937 return call_int_hook(inode_init_security, -EOPNOTSUPP, inode,
938 dir, qstr, NULL, NULL, NULL);
939 memset(new_xattrs, 0, sizeof(new_xattrs));
940 lsm_xattr = new_xattrs;
941 ret = call_int_hook(inode_init_security, -EOPNOTSUPP, inode, dir, qstr,
942 &lsm_xattr->name,
943 &lsm_xattr->value,
944 &lsm_xattr->value_len);
945 if (ret)
946 goto out;
947
948 evm_xattr = lsm_xattr + 1;
949 ret = evm_inode_init_security(inode, lsm_xattr, evm_xattr);
950 if (ret)
951 goto out;
952 ret = initxattrs(inode, new_xattrs, fs_data);
953out:
954 for (xattr = new_xattrs; xattr->value != NULL; xattr++)
955 kfree(xattr->value);
956 return (ret == -EOPNOTSUPP) ? 0 : ret;
957}
958EXPORT_SYMBOL(security_inode_init_security);
959
960int security_old_inode_init_security(struct inode *inode, struct inode *dir,
961 const struct qstr *qstr, const char **name,
962 void **value, size_t *len)
963{
964 if (unlikely(IS_PRIVATE(inode)))
965 return -EOPNOTSUPP;
966 return call_int_hook(inode_init_security, -EOPNOTSUPP, inode, dir,
967 qstr, name, value, len);
968}
969EXPORT_SYMBOL(security_old_inode_init_security);
970
971#ifdef CONFIG_SECURITY_PATH
972int security_path_mknod(const struct path *dir, struct dentry *dentry, umode_t mode,
973 unsigned int dev)
974{
975 if (unlikely(IS_PRIVATE(d_backing_inode(dir->dentry))))
976 return 0;
977 return call_int_hook(path_mknod, 0, dir, dentry, mode, dev);
978}
979EXPORT_SYMBOL(security_path_mknod);
980
981int security_path_mkdir(const struct path *dir, struct dentry *dentry, umode_t mode)
982{
983 if (unlikely(IS_PRIVATE(d_backing_inode(dir->dentry))))
984 return 0;
985 return call_int_hook(path_mkdir, 0, dir, dentry, mode);
986}
987EXPORT_SYMBOL(security_path_mkdir);
988
989int security_path_rmdir(const struct path *dir, struct dentry *dentry)
990{
991 if (unlikely(IS_PRIVATE(d_backing_inode(dir->dentry))))
992 return 0;
993 return call_int_hook(path_rmdir, 0, dir, dentry);
994}
995
996int security_path_unlink(const struct path *dir, struct dentry *dentry)
997{
998 if (unlikely(IS_PRIVATE(d_backing_inode(dir->dentry))))
999 return 0;
1000 return call_int_hook(path_unlink, 0, dir, dentry);
1001}
1002EXPORT_SYMBOL(security_path_unlink);
1003
1004int security_path_symlink(const struct path *dir, struct dentry *dentry,
1005 const char *old_name)
1006{
1007 if (unlikely(IS_PRIVATE(d_backing_inode(dir->dentry))))
1008 return 0;
1009 return call_int_hook(path_symlink, 0, dir, dentry, old_name);
1010}
1011
1012int security_path_link(struct dentry *old_dentry, const struct path *new_dir,
1013 struct dentry *new_dentry)
1014{
1015 if (unlikely(IS_PRIVATE(d_backing_inode(old_dentry))))
1016 return 0;
1017 return call_int_hook(path_link, 0, old_dentry, new_dir, new_dentry);
1018}
1019
1020int security_path_rename(const struct path *old_dir, struct dentry *old_dentry,
1021 const struct path *new_dir, struct dentry *new_dentry,
1022 unsigned int flags)
1023{
1024 if (unlikely(IS_PRIVATE(d_backing_inode(old_dentry)) ||
1025 (d_is_positive(new_dentry) && IS_PRIVATE(d_backing_inode(new_dentry)))))
1026 return 0;
1027
1028 if (flags & RENAME_EXCHANGE) {
1029 int err = call_int_hook(path_rename, 0, new_dir, new_dentry,
1030 old_dir, old_dentry);
1031 if (err)
1032 return err;
1033 }
1034
1035 return call_int_hook(path_rename, 0, old_dir, old_dentry, new_dir,
1036 new_dentry);
1037}
1038EXPORT_SYMBOL(security_path_rename);
1039
1040int security_path_truncate(const struct path *path)
1041{
1042 if (unlikely(IS_PRIVATE(d_backing_inode(path->dentry))))
1043 return 0;
1044 return call_int_hook(path_truncate, 0, path);
1045}
1046
1047int security_path_chmod(const struct path *path, umode_t mode)
1048{
1049 if (unlikely(IS_PRIVATE(d_backing_inode(path->dentry))))
1050 return 0;
1051 return call_int_hook(path_chmod, 0, path, mode);
1052}
1053
1054int security_path_chown(const struct path *path, kuid_t uid, kgid_t gid)
1055{
1056 if (unlikely(IS_PRIVATE(d_backing_inode(path->dentry))))
1057 return 0;
1058 return call_int_hook(path_chown, 0, path, uid, gid);
1059}
1060
1061int security_path_chroot(const struct path *path)
1062{
1063 return call_int_hook(path_chroot, 0, path);
1064}
1065#endif
1066
1067int security_inode_create(struct inode *dir, struct dentry *dentry, umode_t mode)
1068{
1069 if (unlikely(IS_PRIVATE(dir)))
1070 return 0;
1071 return call_int_hook(inode_create, 0, dir, dentry, mode);
1072}
1073EXPORT_SYMBOL_GPL(security_inode_create);
1074
1075int security_inode_link(struct dentry *old_dentry, struct inode *dir,
1076 struct dentry *new_dentry)
1077{
1078 if (unlikely(IS_PRIVATE(d_backing_inode(old_dentry))))
1079 return 0;
1080 return call_int_hook(inode_link, 0, old_dentry, dir, new_dentry);
1081}
1082
1083int security_inode_unlink(struct inode *dir, struct dentry *dentry)
1084{
1085 if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
1086 return 0;
1087 return call_int_hook(inode_unlink, 0, dir, dentry);
1088}
1089
1090int security_inode_symlink(struct inode *dir, struct dentry *dentry,
1091 const char *old_name)
1092{
1093 if (unlikely(IS_PRIVATE(dir)))
1094 return 0;
1095 return call_int_hook(inode_symlink, 0, dir, dentry, old_name);
1096}
1097
1098int security_inode_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
1099{
1100 if (unlikely(IS_PRIVATE(dir)))
1101 return 0;
1102 return call_int_hook(inode_mkdir, 0, dir, dentry, mode);
1103}
1104EXPORT_SYMBOL_GPL(security_inode_mkdir);
1105
1106int security_inode_rmdir(struct inode *dir, struct dentry *dentry)
1107{
1108 if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
1109 return 0;
1110 return call_int_hook(inode_rmdir, 0, dir, dentry);
1111}
1112
1113int security_inode_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
1114{
1115 if (unlikely(IS_PRIVATE(dir)))
1116 return 0;
1117 return call_int_hook(inode_mknod, 0, dir, dentry, mode, dev);
1118}
1119
1120int security_inode_rename(struct inode *old_dir, struct dentry *old_dentry,
1121 struct inode *new_dir, struct dentry *new_dentry,
1122 unsigned int flags)
1123{
1124 if (unlikely(IS_PRIVATE(d_backing_inode(old_dentry)) ||
1125 (d_is_positive(new_dentry) && IS_PRIVATE(d_backing_inode(new_dentry)))))
1126 return 0;
1127
1128 if (flags & RENAME_EXCHANGE) {
1129 int err = call_int_hook(inode_rename, 0, new_dir, new_dentry,
1130 old_dir, old_dentry);
1131 if (err)
1132 return err;
1133 }
1134
1135 return call_int_hook(inode_rename, 0, old_dir, old_dentry,
1136 new_dir, new_dentry);
1137}
1138
1139int security_inode_readlink(struct dentry *dentry)
1140{
1141 if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
1142 return 0;
1143 return call_int_hook(inode_readlink, 0, dentry);
1144}
1145
1146int security_inode_follow_link(struct dentry *dentry, struct inode *inode,
1147 bool rcu)
1148{
1149 if (unlikely(IS_PRIVATE(inode)))
1150 return 0;
1151 return call_int_hook(inode_follow_link, 0, dentry, inode, rcu);
1152}
1153
1154int security_inode_permission(struct inode *inode, int mask)
1155{
1156 if (unlikely(IS_PRIVATE(inode)))
1157 return 0;
1158 return call_int_hook(inode_permission, 0, inode, mask);
1159}
1160
1161int security_inode_setattr(struct dentry *dentry, struct iattr *attr)
1162{
1163 int ret;
1164
1165 if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
1166 return 0;
1167 ret = call_int_hook(inode_setattr, 0, dentry, attr);
1168 if (ret)
1169 return ret;
1170 return evm_inode_setattr(dentry, attr);
1171}
1172EXPORT_SYMBOL_GPL(security_inode_setattr);
1173
1174int security_inode_getattr(const struct path *path)
1175{
1176 if (unlikely(IS_PRIVATE(d_backing_inode(path->dentry))))
1177 return 0;
1178 return call_int_hook(inode_getattr, 0, path);
1179}
1180
1181int security_inode_setxattr(struct dentry *dentry, const char *name,
1182 const void *value, size_t size, int flags)
1183{
1184 int ret;
1185
1186 if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
1187 return 0;
1188 /*
1189 * SELinux and Smack integrate the cap call,
1190 * so assume that all LSMs supplying this call do so.
1191 */
1192 ret = call_int_hook(inode_setxattr, 1, dentry, name, value, size,
1193 flags);
1194
1195 if (ret == 1)
1196 ret = cap_inode_setxattr(dentry, name, value, size, flags);
1197 if (ret)
1198 return ret;
1199 ret = ima_inode_setxattr(dentry, name, value, size);
1200 if (ret)
1201 return ret;
1202 return evm_inode_setxattr(dentry, name, value, size);
1203}
1204
1205void security_inode_post_setxattr(struct dentry *dentry, const char *name,
1206 const void *value, size_t size, int flags)
1207{
1208 if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
1209 return;
1210 call_void_hook(inode_post_setxattr, dentry, name, value, size, flags);
1211 evm_inode_post_setxattr(dentry, name, value, size);
1212}
1213
1214int security_inode_getxattr(struct dentry *dentry, const char *name)
1215{
1216 if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
1217 return 0;
1218 return call_int_hook(inode_getxattr, 0, dentry, name);
1219}
1220
1221int security_inode_listxattr(struct dentry *dentry)
1222{
1223 if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
1224 return 0;
1225 return call_int_hook(inode_listxattr, 0, dentry);
1226}
1227
1228int security_inode_removexattr(struct dentry *dentry, const char *name)
1229{
1230 int ret;
1231
1232 if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
1233 return 0;
1234 /*
1235 * SELinux and Smack integrate the cap call,
1236 * so assume that all LSMs supplying this call do so.
1237 */
1238 ret = call_int_hook(inode_removexattr, 1, dentry, name);
1239 if (ret == 1)
1240 ret = cap_inode_removexattr(dentry, name);
1241 if (ret)
1242 return ret;
1243 ret = ima_inode_removexattr(dentry, name);
1244 if (ret)
1245 return ret;
1246 return evm_inode_removexattr(dentry, name);
1247}
1248
1249int security_inode_need_killpriv(struct dentry *dentry)
1250{
1251 return call_int_hook(inode_need_killpriv, 0, dentry);
1252}
1253
1254int security_inode_killpriv(struct dentry *dentry)
1255{
1256 return call_int_hook(inode_killpriv, 0, dentry);
1257}
1258
1259int security_inode_getsecurity(struct inode *inode, const char *name, void **buffer, bool alloc)
1260{
1261 struct security_hook_list *hp;
1262 int rc;
1263
1264 if (unlikely(IS_PRIVATE(inode)))
1265 return -EOPNOTSUPP;
1266 /*
1267 * Only one module will provide an attribute with a given name.
1268 */
1269 hlist_for_each_entry(hp, &security_hook_heads.inode_getsecurity, list) {
1270 rc = hp->hook.inode_getsecurity(inode, name, buffer, alloc);
1271 if (rc != -EOPNOTSUPP)
1272 return rc;
1273 }
1274 return -EOPNOTSUPP;
1275}
1276
1277int security_inode_setsecurity(struct inode *inode, const char *name, const void *value, size_t size, int flags)
1278{
1279 struct security_hook_list *hp;
1280 int rc;
1281
1282 if (unlikely(IS_PRIVATE(inode)))
1283 return -EOPNOTSUPP;
1284 /*
1285 * Only one module will provide an attribute with a given name.
1286 */
1287 hlist_for_each_entry(hp, &security_hook_heads.inode_setsecurity, list) {
1288 rc = hp->hook.inode_setsecurity(inode, name, value, size,
1289 flags);
1290 if (rc != -EOPNOTSUPP)
1291 return rc;
1292 }
1293 return -EOPNOTSUPP;
1294}
1295
1296int security_inode_listsecurity(struct inode *inode, char *buffer, size_t buffer_size)
1297{
1298 if (unlikely(IS_PRIVATE(inode)))
1299 return 0;
1300 return call_int_hook(inode_listsecurity, 0, inode, buffer, buffer_size);
1301}
1302EXPORT_SYMBOL(security_inode_listsecurity);
1303
1304void security_inode_getsecid(struct inode *inode, u32 *secid)
1305{
1306 call_void_hook(inode_getsecid, inode, secid);
1307}
1308
1309int security_inode_copy_up(struct dentry *src, struct cred **new)
1310{
1311 return call_int_hook(inode_copy_up, 0, src, new);
1312}
1313EXPORT_SYMBOL(security_inode_copy_up);
1314
1315int security_inode_copy_up_xattr(const char *name)
1316{
1317 return call_int_hook(inode_copy_up_xattr, -EOPNOTSUPP, name);
1318}
1319EXPORT_SYMBOL(security_inode_copy_up_xattr);
1320
1321int security_file_permission(struct file *file, int mask)
1322{
1323 int ret;
1324
1325 ret = call_int_hook(file_permission, 0, file, mask);
1326 if (ret)
1327 return ret;
1328
1329 return fsnotify_perm(file, mask);
1330}
1331
1332int security_file_alloc(struct file *file)
1333{
1334 int rc = lsm_file_alloc(file);
1335
1336 if (rc)
1337 return rc;
1338 rc = call_int_hook(file_alloc_security, 0, file);
1339 if (unlikely(rc))
1340 security_file_free(file);
1341 return rc;
1342}
1343
1344void security_file_free(struct file *file)
1345{
1346 void *blob;
1347
1348 call_void_hook(file_free_security, file);
1349
1350 blob = file->f_security;
1351 if (blob) {
1352 file->f_security = NULL;
1353 kmem_cache_free(lsm_file_cache, blob);
1354 }
1355}
1356
1357int security_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1358{
1359 return call_int_hook(file_ioctl, 0, file, cmd, arg);
1360}
1361
1362static inline unsigned long mmap_prot(struct file *file, unsigned long prot)
1363{
1364 /*
1365 * Does we have PROT_READ and does the application expect
1366 * it to imply PROT_EXEC? If not, nothing to talk about...
1367 */
1368 if ((prot & (PROT_READ | PROT_EXEC)) != PROT_READ)
1369 return prot;
1370 if (!(current->personality & READ_IMPLIES_EXEC))
1371 return prot;
1372 /*
1373 * if that's an anonymous mapping, let it.
1374 */
1375 if (!file)
1376 return prot | PROT_EXEC;
1377 /*
1378 * ditto if it's not on noexec mount, except that on !MMU we need
1379 * NOMMU_MAP_EXEC (== VM_MAYEXEC) in this case
1380 */
1381 if (!path_noexec(&file->f_path)) {
1382#ifndef CONFIG_MMU
1383 if (file->f_op->mmap_capabilities) {
1384 unsigned caps = file->f_op->mmap_capabilities(file);
1385 if (!(caps & NOMMU_MAP_EXEC))
1386 return prot;
1387 }
1388#endif
1389 return prot | PROT_EXEC;
1390 }
1391 /* anything on noexec mount won't get PROT_EXEC */
1392 return prot;
1393}
1394
1395int security_mmap_file(struct file *file, unsigned long prot,
1396 unsigned long flags)
1397{
1398 int ret;
1399 ret = call_int_hook(mmap_file, 0, file, prot,
1400 mmap_prot(file, prot), flags);
1401 if (ret)
1402 return ret;
1403 return ima_file_mmap(file, prot);
1404}
1405
1406int security_mmap_addr(unsigned long addr)
1407{
1408 return call_int_hook(mmap_addr, 0, addr);
1409}
1410
1411int security_file_mprotect(struct vm_area_struct *vma, unsigned long reqprot,
1412 unsigned long prot)
1413{
1414 return call_int_hook(file_mprotect, 0, vma, reqprot, prot);
1415}
1416
1417int security_file_lock(struct file *file, unsigned int cmd)
1418{
1419 return call_int_hook(file_lock, 0, file, cmd);
1420}
1421
1422int security_file_fcntl(struct file *file, unsigned int cmd, unsigned long arg)
1423{
1424 return call_int_hook(file_fcntl, 0, file, cmd, arg);
1425}
1426
1427void security_file_set_fowner(struct file *file)
1428{
1429 call_void_hook(file_set_fowner, file);
1430}
1431
1432int security_file_send_sigiotask(struct task_struct *tsk,
1433 struct fown_struct *fown, int sig)
1434{
1435 return call_int_hook(file_send_sigiotask, 0, tsk, fown, sig);
1436}
1437
1438int security_file_receive(struct file *file)
1439{
1440 return call_int_hook(file_receive, 0, file);
1441}
1442
1443int security_file_open(struct file *file)
1444{
1445 int ret;
1446
1447 ret = call_int_hook(file_open, 0, file);
1448 if (ret)
1449 return ret;
1450
1451 return fsnotify_perm(file, MAY_OPEN);
1452}
1453
1454int security_task_alloc(struct task_struct *task, unsigned long clone_flags)
1455{
1456 int rc = lsm_task_alloc(task);
1457
1458 if (rc)
1459 return rc;
1460 rc = call_int_hook(task_alloc, 0, task, clone_flags);
1461 if (unlikely(rc))
1462 security_task_free(task);
1463 return rc;
1464}
1465
1466void security_task_free(struct task_struct *task)
1467{
1468 call_void_hook(task_free, task);
1469
1470 kfree(task->security);
1471 task->security = NULL;
1472}
1473
1474int security_cred_alloc_blank(struct cred *cred, gfp_t gfp)
1475{
1476 int rc = lsm_cred_alloc(cred, gfp);
1477
1478 if (rc)
1479 return rc;
1480
1481 rc = call_int_hook(cred_alloc_blank, 0, cred, gfp);
1482 if (unlikely(rc))
1483 security_cred_free(cred);
1484 return rc;
1485}
1486
1487void security_cred_free(struct cred *cred)
1488{
1489 /*
1490 * There is a failure case in prepare_creds() that
1491 * may result in a call here with ->security being NULL.
1492 */
1493 if (unlikely(cred->security == NULL))
1494 return;
1495
1496 call_void_hook(cred_free, cred);
1497
1498 kfree(cred->security);
1499 cred->security = NULL;
1500}
1501
1502int security_prepare_creds(struct cred *new, const struct cred *old, gfp_t gfp)
1503{
1504 int rc = lsm_cred_alloc(new, gfp);
1505
1506 if (rc)
1507 return rc;
1508
1509 rc = call_int_hook(cred_prepare, 0, new, old, gfp);
1510 if (unlikely(rc))
1511 security_cred_free(new);
1512 return rc;
1513}
1514
1515void security_transfer_creds(struct cred *new, const struct cred *old)
1516{
1517 call_void_hook(cred_transfer, new, old);
1518}
1519
1520void security_cred_getsecid(const struct cred *c, u32 *secid)
1521{
1522 *secid = 0;
1523 call_void_hook(cred_getsecid, c, secid);
1524}
1525EXPORT_SYMBOL(security_cred_getsecid);
1526
1527int security_kernel_act_as(struct cred *new, u32 secid)
1528{
1529 return call_int_hook(kernel_act_as, 0, new, secid);
1530}
1531
1532int security_kernel_create_files_as(struct cred *new, struct inode *inode)
1533{
1534 return call_int_hook(kernel_create_files_as, 0, new, inode);
1535}
1536
1537int security_kernel_module_request(char *kmod_name)
1538{
1539 int ret;
1540
1541 ret = call_int_hook(kernel_module_request, 0, kmod_name);
1542 if (ret)
1543 return ret;
1544 return integrity_kernel_module_request(kmod_name);
1545}
1546
1547int security_kernel_read_file(struct file *file, enum kernel_read_file_id id)
1548{
1549 int ret;
1550
1551 ret = call_int_hook(kernel_read_file, 0, file, id);
1552 if (ret)
1553 return ret;
1554 return ima_read_file(file, id);
1555}
1556EXPORT_SYMBOL_GPL(security_kernel_read_file);
1557
1558int security_kernel_post_read_file(struct file *file, char *buf, loff_t size,
1559 enum kernel_read_file_id id)
1560{
1561 int ret;
1562
1563 ret = call_int_hook(kernel_post_read_file, 0, file, buf, size, id);
1564 if (ret)
1565 return ret;
1566 return ima_post_read_file(file, buf, size, id);
1567}
1568EXPORT_SYMBOL_GPL(security_kernel_post_read_file);
1569
1570int security_kernel_load_data(enum kernel_load_data_id id)
1571{
1572 int ret;
1573
1574 ret = call_int_hook(kernel_load_data, 0, id);
1575 if (ret)
1576 return ret;
1577 return ima_load_data(id);
1578}
1579EXPORT_SYMBOL_GPL(security_kernel_load_data);
1580
1581int security_task_fix_setuid(struct cred *new, const struct cred *old,
1582 int flags)
1583{
1584 return call_int_hook(task_fix_setuid, 0, new, old, flags);
1585}
1586
1587int security_task_setpgid(struct task_struct *p, pid_t pgid)
1588{
1589 return call_int_hook(task_setpgid, 0, p, pgid);
1590}
1591
1592int security_task_getpgid(struct task_struct *p)
1593{
1594 return call_int_hook(task_getpgid, 0, p);
1595}
1596
1597int security_task_getsid(struct task_struct *p)
1598{
1599 return call_int_hook(task_getsid, 0, p);
1600}
1601
1602void security_task_getsecid(struct task_struct *p, u32 *secid)
1603{
1604 *secid = 0;
1605 call_void_hook(task_getsecid, p, secid);
1606}
1607EXPORT_SYMBOL(security_task_getsecid);
1608
1609int security_task_setnice(struct task_struct *p, int nice)
1610{
1611 return call_int_hook(task_setnice, 0, p, nice);
1612}
1613
1614int security_task_setioprio(struct task_struct *p, int ioprio)
1615{
1616 return call_int_hook(task_setioprio, 0, p, ioprio);
1617}
1618
1619int security_task_getioprio(struct task_struct *p)
1620{
1621 return call_int_hook(task_getioprio, 0, p);
1622}
1623
1624int security_task_prlimit(const struct cred *cred, const struct cred *tcred,
1625 unsigned int flags)
1626{
1627 return call_int_hook(task_prlimit, 0, cred, tcred, flags);
1628}
1629
1630int security_task_setrlimit(struct task_struct *p, unsigned int resource,
1631 struct rlimit *new_rlim)
1632{
1633 return call_int_hook(task_setrlimit, 0, p, resource, new_rlim);
1634}
1635
1636int security_task_setscheduler(struct task_struct *p)
1637{
1638 return call_int_hook(task_setscheduler, 0, p);
1639}
1640
1641int security_task_getscheduler(struct task_struct *p)
1642{
1643 return call_int_hook(task_getscheduler, 0, p);
1644}
1645
1646int security_task_movememory(struct task_struct *p)
1647{
1648 return call_int_hook(task_movememory, 0, p);
1649}
1650
1651int security_task_kill(struct task_struct *p, struct kernel_siginfo *info,
1652 int sig, const struct cred *cred)
1653{
1654 return call_int_hook(task_kill, 0, p, info, sig, cred);
1655}
1656
1657int security_task_prctl(int option, unsigned long arg2, unsigned long arg3,
1658 unsigned long arg4, unsigned long arg5)
1659{
1660 int thisrc;
1661 int rc = -ENOSYS;
1662 struct security_hook_list *hp;
1663
1664 hlist_for_each_entry(hp, &security_hook_heads.task_prctl, list) {
1665 thisrc = hp->hook.task_prctl(option, arg2, arg3, arg4, arg5);
1666 if (thisrc != -ENOSYS) {
1667 rc = thisrc;
1668 if (thisrc != 0)
1669 break;
1670 }
1671 }
1672 return rc;
1673}
1674
1675void security_task_to_inode(struct task_struct *p, struct inode *inode)
1676{
1677 call_void_hook(task_to_inode, p, inode);
1678}
1679
1680int security_ipc_permission(struct kern_ipc_perm *ipcp, short flag)
1681{
1682 return call_int_hook(ipc_permission, 0, ipcp, flag);
1683}
1684
1685void security_ipc_getsecid(struct kern_ipc_perm *ipcp, u32 *secid)
1686{
1687 *secid = 0;
1688 call_void_hook(ipc_getsecid, ipcp, secid);
1689}
1690
1691int security_msg_msg_alloc(struct msg_msg *msg)
1692{
1693 int rc = lsm_msg_msg_alloc(msg);
1694
1695 if (unlikely(rc))
1696 return rc;
1697 rc = call_int_hook(msg_msg_alloc_security, 0, msg);
1698 if (unlikely(rc))
1699 security_msg_msg_free(msg);
1700 return rc;
1701}
1702
1703void security_msg_msg_free(struct msg_msg *msg)
1704{
1705 call_void_hook(msg_msg_free_security, msg);
1706 kfree(msg->security);
1707 msg->security = NULL;
1708}
1709
1710int security_msg_queue_alloc(struct kern_ipc_perm *msq)
1711{
1712 int rc = lsm_ipc_alloc(msq);
1713
1714 if (unlikely(rc))
1715 return rc;
1716 rc = call_int_hook(msg_queue_alloc_security, 0, msq);
1717 if (unlikely(rc))
1718 security_msg_queue_free(msq);
1719 return rc;
1720}
1721
1722void security_msg_queue_free(struct kern_ipc_perm *msq)
1723{
1724 call_void_hook(msg_queue_free_security, msq);
1725 kfree(msq->security);
1726 msq->security = NULL;
1727}
1728
1729int security_msg_queue_associate(struct kern_ipc_perm *msq, int msqflg)
1730{
1731 return call_int_hook(msg_queue_associate, 0, msq, msqflg);
1732}
1733
1734int security_msg_queue_msgctl(struct kern_ipc_perm *msq, int cmd)
1735{
1736 return call_int_hook(msg_queue_msgctl, 0, msq, cmd);
1737}
1738
1739int security_msg_queue_msgsnd(struct kern_ipc_perm *msq,
1740 struct msg_msg *msg, int msqflg)
1741{
1742 return call_int_hook(msg_queue_msgsnd, 0, msq, msg, msqflg);
1743}
1744
1745int security_msg_queue_msgrcv(struct kern_ipc_perm *msq, struct msg_msg *msg,
1746 struct task_struct *target, long type, int mode)
1747{
1748 return call_int_hook(msg_queue_msgrcv, 0, msq, msg, target, type, mode);
1749}
1750
1751int security_shm_alloc(struct