blob: 88d30fc975e74de87422011d2554ce74298fec94 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Linux Security plug
3 *
4 * Copyright (C) 2001 WireX Communications, Inc <chris@wirex.com>
5 * Copyright (C) 2001 Greg Kroah-Hartman <greg@kroah.com>
6 * Copyright (C) 2001 Networks Associates Technology, Inc <ssmalley@nai.com>
7 * Copyright (C) 2001 James Morris <jmorris@intercode.com.au>
8 * Copyright (C) 2001 Silicon Graphics, Inc. (Trust Technology Group)
Daniel Jurgensd291f1a2017-05-19 15:48:52 +03009 * Copyright (C) 2016 Mellanox Techonologies
Linus Torvalds1da177e2005-04-16 15:20:36 -070010 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * Due to this file being licensed under the GPL there is controversy over
17 * whether this permits you to write a module that #includes this file
18 * without placing your module under the GPL. Please consult a lawyer for
19 * advice before doing this.
20 *
21 */
22
23#ifndef __LINUX_SECURITY_H
24#define __LINUX_SECURITY_H
25
David Howells29db9192005-10-30 15:02:44 -080026#include <linux/key.h>
Al Viro40401532012-02-13 03:58:52 +000027#include <linux/capability.h>
Mimi Zoharcf222212016-01-14 17:57:47 -050028#include <linux/fs.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090029#include <linux/slab.h>
Al Viro40401532012-02-13 03:58:52 +000030#include <linux/err.h>
David Quigleyd47be3d2013-05-22 12:50:34 -040031#include <linux/string.h>
Casey Schauflerb1d9e6b2015-05-02 15:11:42 -070032#include <linux/mm.h>
Mimi Zoharbc8ca5b2016-01-24 10:07:32 -050033#include <linux/fs.h>
Al Viro40401532012-02-13 03:58:52 +000034
35struct linux_binprm;
36struct cred;
37struct rlimit;
38struct siginfo;
Al Viro40401532012-02-13 03:58:52 +000039struct sembuf;
40struct kern_ipc_perm;
41struct audit_context;
42struct super_block;
43struct inode;
44struct dentry;
45struct file;
46struct vfsmount;
47struct path;
48struct qstr;
Al Viro40401532012-02-13 03:58:52 +000049struct iattr;
50struct fown_struct;
51struct file_operations;
Al Viro40401532012-02-13 03:58:52 +000052struct msg_msg;
Al Viro40401532012-02-13 03:58:52 +000053struct xattr;
54struct xfrm_sec_ctx;
55struct mm_struct;
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
Eric Paris06112162008-11-11 22:02:50 +110057/* If capable should audit the security request */
58#define SECURITY_CAP_NOAUDIT 0
59#define SECURITY_CAP_AUDIT 1
60
David Quigleyeb9ae682013-05-22 12:50:37 -040061/* LSM Agnostic defines for sb_set_mnt_opts */
62#define SECURITY_LSM_NATIVE_LABELS 1
63
Linus Torvalds1da177e2005-04-16 15:20:36 -070064struct ctl_table;
Ahmed S. Darwish03d37d22008-03-01 22:00:05 +020065struct audit_krule;
Serge E. Hallyn34867402011-03-23 16:43:17 -070066struct user_namespace;
Al Viro40401532012-02-13 03:58:52 +000067struct timezone;
Linus Torvalds1da177e2005-04-16 15:20:36 -070068
Daniel Jurgens8f408ab2017-05-19 15:48:53 +030069enum lsm_event {
70 LSM_POLICY_CHANGE,
71};
72
Casey Schauflerb1d9e6b2015-05-02 15:11:42 -070073/* These functions are in security/commoncap.c */
Eric Paris6a9de492012-01-03 12:25:14 -050074extern int cap_capable(const struct cred *cred, struct user_namespace *ns,
75 int cap, int audit);
Baolin Wang457db292016-04-08 14:02:11 +080076extern int cap_settime(const struct timespec64 *ts, const struct timezone *tz);
Ingo Molnar9e488582009-05-07 19:26:19 +100077extern int cap_ptrace_access_check(struct task_struct *child, unsigned int mode);
David Howells5cd9c582008-08-14 11:37:28 +010078extern int cap_ptrace_traceme(struct task_struct *parent);
Eric Paris7b41b172008-04-23 14:10:25 -040079extern int cap_capget(struct task_struct *target, kernel_cap_t *effective, kernel_cap_t *inheritable, kernel_cap_t *permitted);
David Howellsd84f4f92008-11-14 10:39:23 +110080extern int cap_capset(struct cred *new, const struct cred *old,
81 const kernel_cap_t *effective,
82 const kernel_cap_t *inheritable,
83 const kernel_cap_t *permitted);
David Howellsa6f76f22008-11-14 10:39:24 +110084extern int cap_bprm_set_creds(struct linux_binprm *bprm);
David Howells8f0cfa52008-04-29 00:59:41 -070085extern int cap_inode_setxattr(struct dentry *dentry, const char *name,
86 const void *value, size_t size, int flags);
87extern int cap_inode_removexattr(struct dentry *dentry, const char *name);
Serge E. Hallynb5376772007-10-16 23:31:36 -070088extern int cap_inode_need_killpriv(struct dentry *dentry);
89extern int cap_inode_killpriv(struct dentry *dentry);
Serge E. Hallyn8db6c342017-05-08 13:11:56 -050090extern int cap_inode_getsecurity(struct inode *inode, const char *name,
91 void **buffer, bool alloc);
Al Virod0077942012-05-30 13:11:37 -040092extern int cap_mmap_addr(unsigned long addr);
Al Viroe5467852012-05-30 13:30:51 -040093extern int cap_mmap_file(struct file *file, unsigned long reqprot,
94 unsigned long prot, unsigned long flags);
David Howellsd84f4f92008-11-14 10:39:23 +110095extern int cap_task_fix_setuid(struct cred *new, const struct cred *old, int flags);
Andrew G. Morgan3898b1b2008-04-28 02:13:40 -070096extern int cap_task_prctl(int option, unsigned long arg2, unsigned long arg3,
David Howellsd84f4f92008-11-14 10:39:23 +110097 unsigned long arg4, unsigned long arg5);
KOSAKI Motohirob0ae1982010-10-15 04:21:18 +090098extern int cap_task_setscheduler(struct task_struct *p);
Eric Paris7b41b172008-04-23 14:10:25 -040099extern int cap_task_setioprio(struct task_struct *p, int ioprio);
100extern int cap_task_setnice(struct task_struct *p, int nice);
James Morris20510f22007-10-16 23:31:32 -0700101extern int cap_vm_enough_memory(struct mm_struct *mm, long pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102
103struct msghdr;
104struct sk_buff;
105struct sock;
106struct sockaddr;
107struct socket;
Trent Jaegerdf718372005-12-13 23:12:27 -0800108struct flowi;
109struct dst_entry;
110struct xfrm_selector;
111struct xfrm_policy;
112struct xfrm_state;
113struct xfrm_user_sec_ctx;
Eric Paris2069f452008-07-04 09:47:13 +1000114struct seq_file;
Richard Haines72e89f52018-02-13 20:53:21 +0000115struct sctp_endpoint;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116
David Howells6e141542009-12-15 19:27:45 +0000117#ifdef CONFIG_MMU
Eric Parised032182007-06-28 15:55:21 -0400118extern unsigned long mmap_min_addr;
Eric Parisa2551df72009-07-31 12:54:11 -0400119extern unsigned long dac_mmap_min_addr;
David Howells6e141542009-12-15 19:27:45 +0000120#else
Mark Salterbe8cfc42012-09-24 17:17:38 -0700121#define mmap_min_addr 0UL
David Howells6e141542009-12-15 19:27:45 +0000122#define dac_mmap_min_addr 0UL
123#endif
124
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125/*
126 * Values used in the task_security_ops calls
127 */
128/* setuid or setgid, id0 == uid or gid */
129#define LSM_SETID_ID 1
130
131/* setreuid or setregid, id0 == real, id1 == eff */
132#define LSM_SETID_RE 2
133
134/* setresuid or setresgid, id0 == real, id1 == eff, uid2 == saved */
135#define LSM_SETID_RES 4
136
137/* setfsuid or setfsgid, id0 == fsuid or fsgid */
138#define LSM_SETID_FS 8
139
Stephen Smalley791ec492017-02-17 07:57:00 -0500140/* Flags for security_task_prlimit(). */
141#define LSM_PRLIMIT_READ 1
142#define LSM_PRLIMIT_WRITE 2
143
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144/* forward declares to avoid warnings */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145struct sched_param;
Venkat Yekkirala4237c752006-07-24 23:32:50 -0700146struct request_sock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147
David Howellsa6f76f22008-11-14 10:39:24 +1100148/* bprm->unsafe reasons */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149#define LSM_UNSAFE_SHARE 1
150#define LSM_UNSAFE_PTRACE 2
Eric W. Biederman9227dd22017-01-23 17:26:31 +1300151#define LSM_UNSAFE_NO_NEW_PRIVS 4
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152
David Howells6e141542009-12-15 19:27:45 +0000153#ifdef CONFIG_MMU
Alexey Dobriyan8d65af72009-09-23 15:57:19 -0700154extern int mmap_min_addr_handler(struct ctl_table *table, int write,
Eric Paris47d439e2009-08-07 14:53:57 -0400155 void __user *buffer, size_t *lenp, loff_t *ppos);
David Howells6e141542009-12-15 19:27:45 +0000156#endif
Eric Paris47d439e2009-08-07 14:53:57 -0400157
Mimi Zohar9d8f13b2011-06-06 15:29:25 -0400158/* security_inode_init_security callback function to write xattrs */
159typedef int (*initxattrs) (struct inode *inode,
160 const struct xattr *xattr_array, void *fs_data);
161
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162#ifdef CONFIG_SECURITY
163
Eric Parise0007522008-03-05 10:31:54 -0500164struct security_mnt_opts {
165 char **mnt_opts;
166 int *mnt_opts_flags;
167 int num_mnt_opts;
168};
169
Daniel Jurgens8f408ab2017-05-19 15:48:53 +0300170int call_lsm_notifier(enum lsm_event event, void *data);
171int register_lsm_notifier(struct notifier_block *nb);
172int unregister_lsm_notifier(struct notifier_block *nb);
173
Eric Parise0007522008-03-05 10:31:54 -0500174static inline void security_init_mnt_opts(struct security_mnt_opts *opts)
175{
176 opts->mnt_opts = NULL;
177 opts->mnt_opts_flags = NULL;
178 opts->num_mnt_opts = 0;
179}
180
181static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
182{
183 int i;
184 if (opts->mnt_opts)
Eric Paris7b41b172008-04-23 14:10:25 -0400185 for (i = 0; i < opts->num_mnt_opts; i++)
Eric Parise0007522008-03-05 10:31:54 -0500186 kfree(opts->mnt_opts[i]);
187 kfree(opts->mnt_opts);
188 opts->mnt_opts = NULL;
189 kfree(opts->mnt_opts_flags);
190 opts->mnt_opts_flags = NULL;
191 opts->num_mnt_opts = 0;
192}
193
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194/* prototypes */
Eric Paris7b41b172008-04-23 14:10:25 -0400195extern int security_init(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196
James Morris20510f22007-10-16 23:31:32 -0700197/* Security operations */
Stephen Smalley79af7302015-01-21 10:54:10 -0500198int security_binder_set_context_mgr(struct task_struct *mgr);
199int security_binder_transaction(struct task_struct *from,
200 struct task_struct *to);
201int security_binder_transfer_binder(struct task_struct *from,
202 struct task_struct *to);
203int security_binder_transfer_file(struct task_struct *from,
204 struct task_struct *to, struct file *file);
Ingo Molnar9e488582009-05-07 19:26:19 +1000205int security_ptrace_access_check(struct task_struct *child, unsigned int mode);
David Howells5cd9c582008-08-14 11:37:28 +0100206int security_ptrace_traceme(struct task_struct *parent);
James Morris20510f22007-10-16 23:31:32 -0700207int security_capget(struct task_struct *target,
Eric Paris7b41b172008-04-23 14:10:25 -0400208 kernel_cap_t *effective,
209 kernel_cap_t *inheritable,
210 kernel_cap_t *permitted);
David Howellsd84f4f92008-11-14 10:39:23 +1100211int security_capset(struct cred *new, const struct cred *old,
212 const kernel_cap_t *effective,
213 const kernel_cap_t *inheritable,
214 const kernel_cap_t *permitted);
Eric Parisb7e724d2012-01-03 12:25:15 -0500215int security_capable(const struct cred *cred, struct user_namespace *ns,
Serge E. Hallyn34867402011-03-23 16:43:17 -0700216 int cap);
Eric Parisc7eba4a2012-01-03 12:25:15 -0500217int security_capable_noaudit(const struct cred *cred, struct user_namespace *ns,
218 int cap);
James Morris20510f22007-10-16 23:31:32 -0700219int security_quotactl(int cmds, int type, int id, struct super_block *sb);
220int security_quota_on(struct dentry *dentry);
Eric Paris12b30522010-11-15 18:36:29 -0500221int security_syslog(int type);
Baolin Wang457db292016-04-08 14:02:11 +0800222int security_settime64(const struct timespec64 *ts, const struct timezone *tz);
James Morris20510f22007-10-16 23:31:32 -0700223int security_vm_enough_memory_mm(struct mm_struct *mm, long pages);
David Howellsa6f76f22008-11-14 10:39:24 +1100224int security_bprm_set_creds(struct linux_binprm *bprm);
James Morris20510f22007-10-16 23:31:32 -0700225int security_bprm_check(struct linux_binprm *bprm);
David Howellsa6f76f22008-11-14 10:39:24 +1100226void security_bprm_committing_creds(struct linux_binprm *bprm);
227void security_bprm_committed_creds(struct linux_binprm *bprm);
James Morris20510f22007-10-16 23:31:32 -0700228int security_sb_alloc(struct super_block *sb);
229void security_sb_free(struct super_block *sb);
Eric Parise0007522008-03-05 10:31:54 -0500230int security_sb_copy_data(char *orig, char *copy);
Eric Parisff36fe22011-03-03 16:09:14 -0500231int security_sb_remount(struct super_block *sb, void *data);
James Morris12204e22008-12-19 10:44:42 +1100232int security_sb_kern_mount(struct super_block *sb, int flags, void *data);
Eric Paris2069f452008-07-04 09:47:13 +1000233int security_sb_show_options(struct seq_file *m, struct super_block *sb);
James Morris20510f22007-10-16 23:31:32 -0700234int security_sb_statfs(struct dentry *dentry);
Al Viro8a04c432016-03-25 14:52:53 -0400235int security_sb_mount(const char *dev_name, const struct path *path,
Al Viro808d4e32012-10-11 11:42:01 -0400236 const char *type, unsigned long flags, void *data);
James Morris20510f22007-10-16 23:31:32 -0700237int security_sb_umount(struct vfsmount *mnt, int flags);
Al Viro3b73b682016-03-25 15:31:19 -0400238int security_sb_pivotroot(const struct path *old_path, const struct path *new_path);
David Quigley649f6e72013-05-22 12:50:36 -0400239int security_sb_set_mnt_opts(struct super_block *sb,
240 struct security_mnt_opts *opts,
241 unsigned long kern_flags,
242 unsigned long *set_kern_flags);
Jeff Layton094f7b62013-04-01 08:14:24 -0400243int security_sb_clone_mnt_opts(const struct super_block *oldsb,
Scott Mayhew0b4d3452017-06-05 11:45:04 -0400244 struct super_block *newsb,
245 unsigned long kern_flags,
246 unsigned long *set_kern_flags);
Eric Parise0007522008-03-05 10:31:54 -0500247int security_sb_parse_opts_str(char *options, struct security_mnt_opts *opts);
David Quigleyd47be3d2013-05-22 12:50:34 -0400248int security_dentry_init_security(struct dentry *dentry, int mode,
Al Viro4f3ccd72016-07-20 16:06:15 -0400249 const struct qstr *name, void **ctx,
David Quigleyd47be3d2013-05-22 12:50:34 -0400250 u32 *ctxlen);
Vivek Goyal26026252016-07-13 10:44:52 -0400251int security_dentry_create_files_as(struct dentry *dentry, int mode,
252 struct qstr *name,
253 const struct cred *old,
254 struct cred *new);
Eric Parisc9180a52007-11-30 13:00:35 -0500255
James Morris20510f22007-10-16 23:31:32 -0700256int security_inode_alloc(struct inode *inode);
257void security_inode_free(struct inode *inode);
258int security_inode_init_security(struct inode *inode, struct inode *dir,
Mimi Zohar9d8f13b2011-06-06 15:29:25 -0400259 const struct qstr *qstr,
260 initxattrs initxattrs, void *fs_data);
261int security_old_inode_init_security(struct inode *inode, struct inode *dir,
Tetsuo Handa95489062013-07-25 05:44:02 +0900262 const struct qstr *qstr, const char **name,
Mimi Zohar9d8f13b2011-06-06 15:29:25 -0400263 void **value, size_t *len);
Al Viro4acdaf22011-07-26 01:42:34 -0400264int security_inode_create(struct inode *dir, struct dentry *dentry, umode_t mode);
James Morris20510f22007-10-16 23:31:32 -0700265int security_inode_link(struct dentry *old_dentry, struct inode *dir,
266 struct dentry *new_dentry);
267int security_inode_unlink(struct inode *dir, struct dentry *dentry);
268int security_inode_symlink(struct inode *dir, struct dentry *dentry,
Eric Paris7b41b172008-04-23 14:10:25 -0400269 const char *old_name);
Al Viro18bb1db2011-07-26 01:41:39 -0400270int security_inode_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode);
James Morris20510f22007-10-16 23:31:32 -0700271int security_inode_rmdir(struct inode *dir, struct dentry *dentry);
Al Viro1a67aaf2011-07-26 01:52:52 -0400272int security_inode_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev);
James Morris20510f22007-10-16 23:31:32 -0700273int security_inode_rename(struct inode *old_dir, struct dentry *old_dentry,
Miklos Szeredi0b3974e2014-04-01 17:08:43 +0200274 struct inode *new_dir, struct dentry *new_dentry,
275 unsigned int flags);
James Morris20510f22007-10-16 23:31:32 -0700276int security_inode_readlink(struct dentry *dentry);
NeilBrownbda0be72015-03-23 13:37:39 +1100277int security_inode_follow_link(struct dentry *dentry, struct inode *inode,
278 bool rcu);
Al Virob77b0642008-07-17 09:37:02 -0400279int security_inode_permission(struct inode *inode, int mask);
James Morris20510f22007-10-16 23:31:32 -0700280int security_inode_setattr(struct dentry *dentry, struct iattr *attr);
Al Viro3f7036a2015-03-08 19:28:30 -0400281int security_inode_getattr(const struct path *path);
David Howells8f0cfa52008-04-29 00:59:41 -0700282int security_inode_setxattr(struct dentry *dentry, const char *name,
283 const void *value, size_t size, int flags);
284void security_inode_post_setxattr(struct dentry *dentry, const char *name,
285 const void *value, size_t size, int flags);
286int security_inode_getxattr(struct dentry *dentry, const char *name);
James Morris20510f22007-10-16 23:31:32 -0700287int security_inode_listxattr(struct dentry *dentry);
David Howells8f0cfa52008-04-29 00:59:41 -0700288int security_inode_removexattr(struct dentry *dentry, const char *name);
Serge E. Hallynb5376772007-10-16 23:31:36 -0700289int security_inode_need_killpriv(struct dentry *dentry);
290int security_inode_killpriv(struct dentry *dentry);
Andreas Gruenbacherea861df2015-12-24 11:09:39 -0500291int security_inode_getsecurity(struct inode *inode, const char *name, void **buffer, bool alloc);
James Morris20510f22007-10-16 23:31:32 -0700292int security_inode_setsecurity(struct inode *inode, const char *name, const void *value, size_t size, int flags);
293int security_inode_listsecurity(struct inode *inode, char *buffer, size_t buffer_size);
Andreas Gruenbacherd6335d72015-12-24 11:09:39 -0500294void security_inode_getsecid(struct inode *inode, u32 *secid);
Vivek Goyald8ad8b42016-07-13 11:13:56 -0400295int security_inode_copy_up(struct dentry *src, struct cred **new);
Vivek Goyal121ab822016-07-13 10:44:49 -0400296int security_inode_copy_up_xattr(const char *name);
James Morris20510f22007-10-16 23:31:32 -0700297int security_file_permission(struct file *file, int mask);
298int security_file_alloc(struct file *file);
299void security_file_free(struct file *file);
300int security_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
Al Viro8b3ec682012-05-30 17:11:23 -0400301int security_mmap_file(struct file *file, unsigned long prot,
302 unsigned long flags);
Al Viroe5467852012-05-30 13:30:51 -0400303int security_mmap_addr(unsigned long addr);
James Morris20510f22007-10-16 23:31:32 -0700304int security_file_mprotect(struct vm_area_struct *vma, unsigned long reqprot,
Eric Paris7b41b172008-04-23 14:10:25 -0400305 unsigned long prot);
James Morris20510f22007-10-16 23:31:32 -0700306int security_file_lock(struct file *file, unsigned int cmd);
307int security_file_fcntl(struct file *file, unsigned int cmd, unsigned long arg);
Jeff Laytone0b93ed2014-08-22 11:27:32 -0400308void security_file_set_fowner(struct file *file);
James Morris20510f22007-10-16 23:31:32 -0700309int security_file_send_sigiotask(struct task_struct *tsk,
Eric Paris7b41b172008-04-23 14:10:25 -0400310 struct fown_struct *fown, int sig);
James Morris20510f22007-10-16 23:31:32 -0700311int security_file_receive(struct file *file);
Al Viroe3f20ae2018-07-10 13:25:29 -0400312int security_file_open(struct file *file);
Tetsuo Handae4e55b42017-03-24 20:46:33 +0900313int security_task_alloc(struct task_struct *task, unsigned long clone_flags);
Kees Cook1a2a4d02011-12-21 12:17:03 -0800314void security_task_free(struct task_struct *task);
David Howellsee18d642009-09-02 09:14:21 +0100315int security_cred_alloc_blank(struct cred *cred, gfp_t gfp);
David Howellsf1752ee2008-11-14 10:39:17 +1100316void security_cred_free(struct cred *cred);
David Howellsd84f4f92008-11-14 10:39:23 +1100317int security_prepare_creds(struct cred *new, const struct cred *old, gfp_t gfp);
David Howellsee18d642009-09-02 09:14:21 +0100318void security_transfer_creds(struct cred *new, const struct cred *old);
Matthew Garrett3ec30112018-01-08 13:36:19 -0800319void security_cred_getsecid(const struct cred *c, u32 *secid);
David Howells3a3b7ce2008-11-14 10:39:28 +1100320int security_kernel_act_as(struct cred *new, u32 secid);
321int security_kernel_create_files_as(struct cred *new, struct inode *inode);
Eric Parisdd8dbf22009-11-03 16:35:32 +1100322int security_kernel_module_request(char *kmod_name);
Mimi Zohar39eeb4f2016-01-30 22:23:26 -0500323int security_kernel_read_file(struct file *file, enum kernel_read_file_id id);
Mimi Zoharbc8ca5b2016-01-24 10:07:32 -0500324int security_kernel_post_read_file(struct file *file, char *buf, loff_t size,
325 enum kernel_read_file_id id);
David Howellsd84f4f92008-11-14 10:39:23 +1100326int security_task_fix_setuid(struct cred *new, const struct cred *old,
327 int flags);
James Morris20510f22007-10-16 23:31:32 -0700328int security_task_setpgid(struct task_struct *p, pid_t pgid);
329int security_task_getpgid(struct task_struct *p);
330int security_task_getsid(struct task_struct *p);
331void security_task_getsecid(struct task_struct *p, u32 *secid);
James Morris20510f22007-10-16 23:31:32 -0700332int security_task_setnice(struct task_struct *p, int nice);
333int security_task_setioprio(struct task_struct *p, int ioprio);
334int security_task_getioprio(struct task_struct *p);
Stephen Smalley791ec492017-02-17 07:57:00 -0500335int security_task_prlimit(const struct cred *cred, const struct cred *tcred,
336 unsigned int flags);
Jiri Slaby8fd00b42009-08-26 18:41:16 +0200337int security_task_setrlimit(struct task_struct *p, unsigned int resource,
338 struct rlimit *new_rlim);
KOSAKI Motohirob0ae1982010-10-15 04:21:18 +0900339int security_task_setscheduler(struct task_struct *p);
James Morris20510f22007-10-16 23:31:32 -0700340int security_task_getscheduler(struct task_struct *p);
341int security_task_movememory(struct task_struct *p);
342int security_task_kill(struct task_struct *p, struct siginfo *info,
Stephen Smalley6b4f3d02017-09-08 12:40:01 -0400343 int sig, const struct cred *cred);
James Morris20510f22007-10-16 23:31:32 -0700344int security_task_prctl(int option, unsigned long arg2, unsigned long arg3,
David Howellsd84f4f92008-11-14 10:39:23 +1100345 unsigned long arg4, unsigned long arg5);
James Morris20510f22007-10-16 23:31:32 -0700346void security_task_to_inode(struct task_struct *p, struct inode *inode);
347int security_ipc_permission(struct kern_ipc_perm *ipcp, short flag);
Ahmed S. Darwish8a076192008-03-01 21:51:09 +0200348void security_ipc_getsecid(struct kern_ipc_perm *ipcp, u32 *secid);
James Morris20510f22007-10-16 23:31:32 -0700349int security_msg_msg_alloc(struct msg_msg *msg);
350void security_msg_msg_free(struct msg_msg *msg);
Eric W. Biedermand8c6e852018-03-22 21:22:26 -0500351int security_msg_queue_alloc(struct kern_ipc_perm *msq);
352void security_msg_queue_free(struct kern_ipc_perm *msq);
353int security_msg_queue_associate(struct kern_ipc_perm *msq, int msqflg);
354int security_msg_queue_msgctl(struct kern_ipc_perm *msq, int cmd);
355int security_msg_queue_msgsnd(struct kern_ipc_perm *msq,
Eric Paris7b41b172008-04-23 14:10:25 -0400356 struct msg_msg *msg, int msqflg);
Eric W. Biedermand8c6e852018-03-22 21:22:26 -0500357int security_msg_queue_msgrcv(struct kern_ipc_perm *msq, struct msg_msg *msg,
Eric Paris7b41b172008-04-23 14:10:25 -0400358 struct task_struct *target, long type, int mode);
Eric W. Biederman7191adf2018-03-22 21:08:27 -0500359int security_shm_alloc(struct kern_ipc_perm *shp);
360void security_shm_free(struct kern_ipc_perm *shp);
361int security_shm_associate(struct kern_ipc_perm *shp, int shmflg);
362int security_shm_shmctl(struct kern_ipc_perm *shp, int cmd);
363int security_shm_shmat(struct kern_ipc_perm *shp, char __user *shmaddr, int shmflg);
Eric W. Biedermanaefad952018-03-22 20:52:43 -0500364int security_sem_alloc(struct kern_ipc_perm *sma);
365void security_sem_free(struct kern_ipc_perm *sma);
366int security_sem_associate(struct kern_ipc_perm *sma, int semflg);
367int security_sem_semctl(struct kern_ipc_perm *sma, int cmd);
368int security_sem_semop(struct kern_ipc_perm *sma, struct sembuf *sops,
James Morris20510f22007-10-16 23:31:32 -0700369 unsigned nsops, int alter);
Eric Paris7b41b172008-04-23 14:10:25 -0400370void security_d_instantiate(struct dentry *dentry, struct inode *inode);
James Morris20510f22007-10-16 23:31:32 -0700371int security_getprocattr(struct task_struct *p, char *name, char **value);
Stephen Smalleyb21507e2017-01-09 10:07:31 -0500372int security_setprocattr(const char *name, void *value, size_t size);
James Morris20510f22007-10-16 23:31:32 -0700373int security_netlink_send(struct sock *sk, struct sk_buff *skb);
David Quigley746df9b2013-05-22 12:50:35 -0400374int security_ismaclabel(const char *name);
James Morris20510f22007-10-16 23:31:32 -0700375int security_secid_to_secctx(u32 secid, char **secdata, u32 *seclen);
David Howells7bf570d2008-04-29 20:52:51 +0100376int security_secctx_to_secid(const char *secdata, u32 seclen, u32 *secid);
James Morris20510f22007-10-16 23:31:32 -0700377void security_release_secctx(char *secdata, u32 seclen);
378
Andreas Gruenbacher6f3be9f2015-12-24 11:09:40 -0500379void security_inode_invalidate_secctx(struct inode *inode);
David P. Quigley1ee65e32009-09-03 14:25:57 -0400380int security_inode_notifysecctx(struct inode *inode, void *ctx, u32 ctxlen);
381int security_inode_setsecctx(struct dentry *dentry, void *ctx, u32 ctxlen);
382int security_inode_getsecctx(struct inode *inode, void **ctx, u32 *ctxlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383#else /* CONFIG_SECURITY */
Eric Parise0007522008-03-05 10:31:54 -0500384struct security_mnt_opts {
385};
386
Daniel Jurgens8f408ab2017-05-19 15:48:53 +0300387static inline int call_lsm_notifier(enum lsm_event event, void *data)
388{
389 return 0;
390}
391
392static inline int register_lsm_notifier(struct notifier_block *nb)
393{
394 return 0;
395}
396
397static inline int unregister_lsm_notifier(struct notifier_block *nb)
398{
399 return 0;
400}
401
Eric Parise0007522008-03-05 10:31:54 -0500402static inline void security_init_mnt_opts(struct security_mnt_opts *opts)
403{
404}
405
406static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
407{
408}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409
410/*
411 * This is the default capabilities functionality. Most of these functions
412 * are just stubbed out, but a few must call the proper capable code.
413 */
414
415static inline int security_init(void)
416{
417 return 0;
418}
419
Stephen Smalley79af7302015-01-21 10:54:10 -0500420static inline int security_binder_set_context_mgr(struct task_struct *mgr)
421{
422 return 0;
423}
424
425static inline int security_binder_transaction(struct task_struct *from,
426 struct task_struct *to)
427{
428 return 0;
429}
430
431static inline int security_binder_transfer_binder(struct task_struct *from,
432 struct task_struct *to)
433{
434 return 0;
435}
436
437static inline int security_binder_transfer_file(struct task_struct *from,
438 struct task_struct *to,
439 struct file *file)
440{
441 return 0;
442}
443
Ingo Molnar9e488582009-05-07 19:26:19 +1000444static inline int security_ptrace_access_check(struct task_struct *child,
David Howells5cd9c582008-08-14 11:37:28 +0100445 unsigned int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446{
Ingo Molnar9e488582009-05-07 19:26:19 +1000447 return cap_ptrace_access_check(child, mode);
David Howells5cd9c582008-08-14 11:37:28 +0100448}
449
Alexander Beregalov5e186b52008-08-17 05:34:20 +0400450static inline int security_ptrace_traceme(struct task_struct *parent)
David Howells5cd9c582008-08-14 11:37:28 +0100451{
452 return cap_ptrace_traceme(parent);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453}
454
Eric Paris7b41b172008-04-23 14:10:25 -0400455static inline int security_capget(struct task_struct *target,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 kernel_cap_t *effective,
457 kernel_cap_t *inheritable,
458 kernel_cap_t *permitted)
459{
Eric Paris7b41b172008-04-23 14:10:25 -0400460 return cap_capget(target, effective, inheritable, permitted);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461}
462
David Howellsd84f4f92008-11-14 10:39:23 +1100463static inline int security_capset(struct cred *new,
464 const struct cred *old,
465 const kernel_cap_t *effective,
466 const kernel_cap_t *inheritable,
467 const kernel_cap_t *permitted)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468{
David Howellsd84f4f92008-11-14 10:39:23 +1100469 return cap_capset(new, old, effective, inheritable, permitted);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470}
471
Eric Parisb7e724d2012-01-03 12:25:15 -0500472static inline int security_capable(const struct cred *cred,
473 struct user_namespace *ns, int cap)
Chris Wright12b59892006-03-25 03:07:41 -0800474{
Eric Paris6a9de492012-01-03 12:25:14 -0500475 return cap_capable(cred, ns, cap, SECURITY_CAP_AUDIT);
Eric Paris06112162008-11-11 22:02:50 +1100476}
477
Eric Parisc7eba4a2012-01-03 12:25:15 -0500478static inline int security_capable_noaudit(const struct cred *cred,
479 struct user_namespace *ns, int cap) {
480 return cap_capable(cred, ns, cap, SECURITY_CAP_NOAUDIT);
Chris Wright12b59892006-03-25 03:07:41 -0800481}
482
Eric Paris7b41b172008-04-23 14:10:25 -0400483static inline int security_quotactl(int cmds, int type, int id,
484 struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485{
486 return 0;
487}
488
Eric Paris7b41b172008-04-23 14:10:25 -0400489static inline int security_quota_on(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490{
491 return 0;
492}
493
Eric Paris12b30522010-11-15 18:36:29 -0500494static inline int security_syslog(int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495{
Eric Paris12b30522010-11-15 18:36:29 -0500496 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497}
498
Baolin Wang457db292016-04-08 14:02:11 +0800499static inline int security_settime64(const struct timespec64 *ts,
500 const struct timezone *tz)
501{
502 return cap_settime(ts, tz);
503}
504
Alan Cox34b4e4a2007-08-22 14:01:28 -0700505static inline int security_vm_enough_memory_mm(struct mm_struct *mm, long pages)
506{
Casey Schauflerb1d9e6b2015-05-02 15:11:42 -0700507 return __vm_enough_memory(mm, pages, cap_vm_enough_memory(mm, pages));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508}
509
David Howellsa6f76f22008-11-14 10:39:24 +1100510static inline int security_bprm_set_creds(struct linux_binprm *bprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511{
David Howellsa6f76f22008-11-14 10:39:24 +1100512 return cap_bprm_set_creds(bprm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513}
514
Eric Paris7b41b172008-04-23 14:10:25 -0400515static inline int security_bprm_check(struct linux_binprm *bprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516{
517 return 0;
518}
519
David Howellsa6f76f22008-11-14 10:39:24 +1100520static inline void security_bprm_committing_creds(struct linux_binprm *bprm)
521{
522}
523
524static inline void security_bprm_committed_creds(struct linux_binprm *bprm)
525{
526}
527
Eric Paris7b41b172008-04-23 14:10:25 -0400528static inline int security_sb_alloc(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529{
530 return 0;
531}
532
Eric Paris7b41b172008-04-23 14:10:25 -0400533static inline void security_sb_free(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534{ }
535
Eric Paris7b41b172008-04-23 14:10:25 -0400536static inline int security_sb_copy_data(char *orig, char *copy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537{
538 return 0;
539}
540
Eric Parisff36fe22011-03-03 16:09:14 -0500541static inline int security_sb_remount(struct super_block *sb, void *data)
542{
543 return 0;
544}
545
James Morris12204e22008-12-19 10:44:42 +1100546static inline int security_sb_kern_mount(struct super_block *sb, int flags, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547{
548 return 0;
549}
550
Eric Paris2069f452008-07-04 09:47:13 +1000551static inline int security_sb_show_options(struct seq_file *m,
552 struct super_block *sb)
553{
554 return 0;
555}
556
Eric Paris7b41b172008-04-23 14:10:25 -0400557static inline int security_sb_statfs(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558{
559 return 0;
560}
561
Al Viro8a04c432016-03-25 14:52:53 -0400562static inline int security_sb_mount(const char *dev_name, const struct path *path,
Al Viro808d4e32012-10-11 11:42:01 -0400563 const char *type, unsigned long flags,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 void *data)
565{
566 return 0;
567}
568
Eric Paris7b41b172008-04-23 14:10:25 -0400569static inline int security_sb_umount(struct vfsmount *mnt, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570{
571 return 0;
572}
573
Al Viro3b73b682016-03-25 15:31:19 -0400574static inline int security_sb_pivotroot(const struct path *old_path,
575 const struct path *new_path)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576{
577 return 0;
578}
579
Eric Parise0007522008-03-05 10:31:54 -0500580static inline int security_sb_set_mnt_opts(struct super_block *sb,
David Quigley649f6e72013-05-22 12:50:36 -0400581 struct security_mnt_opts *opts,
582 unsigned long kern_flags,
583 unsigned long *set_kern_flags)
Eric Parise0007522008-03-05 10:31:54 -0500584{
585 return 0;
586}
587
Jeff Layton094f7b62013-04-01 08:14:24 -0400588static inline int security_sb_clone_mnt_opts(const struct super_block *oldsb,
Scott Mayhew0b4d3452017-06-05 11:45:04 -0400589 struct super_block *newsb,
590 unsigned long kern_flags,
591 unsigned long *set_kern_flags)
Jeff Layton094f7b62013-04-01 08:14:24 -0400592{
593 return 0;
594}
Eric Parise0007522008-03-05 10:31:54 -0500595
596static inline int security_sb_parse_opts_str(char *options, struct security_mnt_opts *opts)
597{
598 return 0;
599}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600
Eric Paris7b41b172008-04-23 14:10:25 -0400601static inline int security_inode_alloc(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602{
603 return 0;
604}
605
Eric Paris7b41b172008-04-23 14:10:25 -0400606static inline void security_inode_free(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607{ }
Stephen Smalley5e41ff92005-09-09 13:01:35 -0700608
David Quigleyd47be3d2013-05-22 12:50:34 -0400609static inline int security_dentry_init_security(struct dentry *dentry,
610 int mode,
Al Viro4f3ccd72016-07-20 16:06:15 -0400611 const struct qstr *name,
David Quigleyd47be3d2013-05-22 12:50:34 -0400612 void **ctx,
613 u32 *ctxlen)
614{
615 return -EOPNOTSUPP;
616}
617
Vivek Goyal26026252016-07-13 10:44:52 -0400618static inline int security_dentry_create_files_as(struct dentry *dentry,
619 int mode, struct qstr *name,
620 const struct cred *old,
621 struct cred *new)
622{
623 return 0;
624}
625
David Quigleyd47be3d2013-05-22 12:50:34 -0400626
Eric Paris7b41b172008-04-23 14:10:25 -0400627static inline int security_inode_init_security(struct inode *inode,
Stephen Smalley5e41ff92005-09-09 13:01:35 -0700628 struct inode *dir,
Eric Paris2a7dba32011-02-01 11:05:39 -0500629 const struct qstr *qstr,
Mark Rustadfbff6612014-08-28 04:43:09 -0700630 const initxattrs xattrs,
Mimi Zohar9d8f13b2011-06-06 15:29:25 -0400631 void *fs_data)
Stephen Smalley5e41ff92005-09-09 13:01:35 -0700632{
Mimi Zohar1e39f382011-08-15 09:09:16 -0400633 return 0;
Stephen Smalley5e41ff92005-09-09 13:01:35 -0700634}
Eric Paris7b41b172008-04-23 14:10:25 -0400635
Mimi Zohar1e39f382011-08-15 09:09:16 -0400636static inline int security_old_inode_init_security(struct inode *inode,
637 struct inode *dir,
638 const struct qstr *qstr,
Tetsuo Handa95489062013-07-25 05:44:02 +0900639 const char **name,
640 void **value, size_t *len)
Mimi Zohare1c9b232011-08-11 00:22:51 -0400641{
Jan Kara30e05322012-01-03 13:14:29 +0100642 return -EOPNOTSUPP;
Mimi Zohare1c9b232011-08-11 00:22:51 -0400643}
644
Eric Paris7b41b172008-04-23 14:10:25 -0400645static inline int security_inode_create(struct inode *dir,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 struct dentry *dentry,
Al Viro4acdaf22011-07-26 01:42:34 -0400647 umode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648{
649 return 0;
650}
651
Eric Paris7b41b172008-04-23 14:10:25 -0400652static inline int security_inode_link(struct dentry *old_dentry,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 struct inode *dir,
654 struct dentry *new_dentry)
655{
656 return 0;
657}
658
Eric Paris7b41b172008-04-23 14:10:25 -0400659static inline int security_inode_unlink(struct inode *dir,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 struct dentry *dentry)
661{
662 return 0;
663}
664
Eric Paris7b41b172008-04-23 14:10:25 -0400665static inline int security_inode_symlink(struct inode *dir,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 struct dentry *dentry,
667 const char *old_name)
668{
669 return 0;
670}
671
Eric Paris7b41b172008-04-23 14:10:25 -0400672static inline int security_inode_mkdir(struct inode *dir,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 struct dentry *dentry,
674 int mode)
675{
676 return 0;
677}
678
Eric Paris7b41b172008-04-23 14:10:25 -0400679static inline int security_inode_rmdir(struct inode *dir,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 struct dentry *dentry)
681{
682 return 0;
683}
684
Eric Paris7b41b172008-04-23 14:10:25 -0400685static inline int security_inode_mknod(struct inode *dir,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 struct dentry *dentry,
687 int mode, dev_t dev)
688{
689 return 0;
690}
691
Eric Paris7b41b172008-04-23 14:10:25 -0400692static inline int security_inode_rename(struct inode *old_dir,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 struct dentry *old_dentry,
694 struct inode *new_dir,
Miklos Szeredi0b3974e2014-04-01 17:08:43 +0200695 struct dentry *new_dentry,
696 unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697{
698 return 0;
699}
700
Eric Paris7b41b172008-04-23 14:10:25 -0400701static inline int security_inode_readlink(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702{
703 return 0;
704}
705
NeilBrownbda0be72015-03-23 13:37:39 +1100706static inline int security_inode_follow_link(struct dentry *dentry,
707 struct inode *inode,
708 bool rcu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709{
710 return 0;
711}
712
Al Virob77b0642008-07-17 09:37:02 -0400713static inline int security_inode_permission(struct inode *inode, int mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714{
715 return 0;
716}
717
Eric Paris7b41b172008-04-23 14:10:25 -0400718static inline int security_inode_setattr(struct dentry *dentry,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 struct iattr *attr)
720{
721 return 0;
722}
723
Al Viro3f7036a2015-03-08 19:28:30 -0400724static inline int security_inode_getattr(const struct path *path)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725{
726 return 0;
727}
728
David Howells8f0cfa52008-04-29 00:59:41 -0700729static inline int security_inode_setxattr(struct dentry *dentry,
730 const char *name, const void *value, size_t size, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731{
732 return cap_inode_setxattr(dentry, name, value, size, flags);
733}
734
David Howells8f0cfa52008-04-29 00:59:41 -0700735static inline void security_inode_post_setxattr(struct dentry *dentry,
736 const char *name, const void *value, size_t size, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737{ }
738
David Howells8f0cfa52008-04-29 00:59:41 -0700739static inline int security_inode_getxattr(struct dentry *dentry,
740 const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741{
742 return 0;
743}
744
Eric Paris7b41b172008-04-23 14:10:25 -0400745static inline int security_inode_listxattr(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746{
747 return 0;
748}
749
David Howells8f0cfa52008-04-29 00:59:41 -0700750static inline int security_inode_removexattr(struct dentry *dentry,
751 const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752{
753 return cap_inode_removexattr(dentry, name);
754}
755
Serge E. Hallynb5376772007-10-16 23:31:36 -0700756static inline int security_inode_need_killpriv(struct dentry *dentry)
757{
758 return cap_inode_need_killpriv(dentry);
759}
760
761static inline int security_inode_killpriv(struct dentry *dentry)
762{
763 return cap_inode_killpriv(dentry);
764}
765
Andreas Gruenbacherea861df2015-12-24 11:09:39 -0500766static inline int security_inode_getsecurity(struct inode *inode, const char *name, void **buffer, bool alloc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767{
768 return -EOPNOTSUPP;
769}
770
771static inline int security_inode_setsecurity(struct inode *inode, const char *name, const void *value, size_t size, int flags)
772{
773 return -EOPNOTSUPP;
774}
775
776static inline int security_inode_listsecurity(struct inode *inode, char *buffer, size_t buffer_size)
777{
778 return 0;
779}
780
Andreas Gruenbacherd6335d72015-12-24 11:09:39 -0500781static inline void security_inode_getsecid(struct inode *inode, u32 *secid)
Ahmed S. Darwish8a076192008-03-01 21:51:09 +0200782{
783 *secid = 0;
784}
785
Vivek Goyald8ad8b42016-07-13 11:13:56 -0400786static inline int security_inode_copy_up(struct dentry *src, struct cred **new)
787{
788 return 0;
789}
790
Vivek Goyal121ab822016-07-13 10:44:49 -0400791static inline int security_inode_copy_up_xattr(const char *name)
792{
793 return -EOPNOTSUPP;
794}
795
Eric Paris7b41b172008-04-23 14:10:25 -0400796static inline int security_file_permission(struct file *file, int mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797{
798 return 0;
799}
800
Eric Paris7b41b172008-04-23 14:10:25 -0400801static inline int security_file_alloc(struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802{
803 return 0;
804}
805
Eric Paris7b41b172008-04-23 14:10:25 -0400806static inline void security_file_free(struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807{ }
808
Eric Paris7b41b172008-04-23 14:10:25 -0400809static inline int security_file_ioctl(struct file *file, unsigned int cmd,
810 unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811{
812 return 0;
813}
814
Al Viro8b3ec682012-05-30 17:11:23 -0400815static inline int security_mmap_file(struct file *file, unsigned long prot,
Al Viroe5467852012-05-30 13:30:51 -0400816 unsigned long flags)
817{
818 return 0;
819}
820
821static inline int security_mmap_addr(unsigned long addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822{
Al Virod0077942012-05-30 13:11:37 -0400823 return cap_mmap_addr(addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824}
825
Eric Paris7b41b172008-04-23 14:10:25 -0400826static inline int security_file_mprotect(struct vm_area_struct *vma,
827 unsigned long reqprot,
828 unsigned long prot)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829{
830 return 0;
831}
832
Eric Paris7b41b172008-04-23 14:10:25 -0400833static inline int security_file_lock(struct file *file, unsigned int cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834{
835 return 0;
836}
837
Eric Paris7b41b172008-04-23 14:10:25 -0400838static inline int security_file_fcntl(struct file *file, unsigned int cmd,
839 unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840{
841 return 0;
842}
843
Jeff Laytone0b93ed2014-08-22 11:27:32 -0400844static inline void security_file_set_fowner(struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845{
Jeff Laytone0b93ed2014-08-22 11:27:32 -0400846 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847}
848
Eric Paris7b41b172008-04-23 14:10:25 -0400849static inline int security_file_send_sigiotask(struct task_struct *tsk,
850 struct fown_struct *fown,
851 int sig)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852{
853 return 0;
854}
855
Eric Paris7b41b172008-04-23 14:10:25 -0400856static inline int security_file_receive(struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857{
858 return 0;
859}
860
Al Viroe3f20ae2018-07-10 13:25:29 -0400861static inline int security_file_open(struct file *file)
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +0900862{
863 return 0;
864}
865
Tetsuo Handae4e55b42017-03-24 20:46:33 +0900866static inline int security_task_alloc(struct task_struct *task,
867 unsigned long clone_flags)
868{
869 return 0;
870}
871
Kees Cook1a2a4d02011-12-21 12:17:03 -0800872static inline void security_task_free(struct task_struct *task)
873{ }
874
David Howells945af7c2009-09-04 09:19:48 +0100875static inline int security_cred_alloc_blank(struct cred *cred, gfp_t gfp)
876{
877 return 0;
878}
David Howellsee18d642009-09-02 09:14:21 +0100879
David Howellsd84f4f92008-11-14 10:39:23 +1100880static inline void security_cred_free(struct cred *cred)
881{ }
882
883static inline int security_prepare_creds(struct cred *new,
884 const struct cred *old,
885 gfp_t gfp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886{
887 return 0;
888}
889
David Howellsee18d642009-09-02 09:14:21 +0100890static inline void security_transfer_creds(struct cred *new,
891 const struct cred *old)
892{
893}
894
David Howells3a3b7ce2008-11-14 10:39:28 +1100895static inline int security_kernel_act_as(struct cred *cred, u32 secid)
896{
897 return 0;
898}
899
900static inline int security_kernel_create_files_as(struct cred *cred,
901 struct inode *inode)
902{
903 return 0;
904}
905
Eric Parisdd8dbf22009-11-03 16:35:32 +1100906static inline int security_kernel_module_request(char *kmod_name)
Eric Paris91884992009-08-13 09:44:57 -0400907{
908 return 0;
909}
910
Mimi Zohar39eeb4f2016-01-30 22:23:26 -0500911static inline int security_kernel_read_file(struct file *file,
912 enum kernel_read_file_id id)
913{
914 return 0;
915}
916
Mimi Zoharb44a7df2015-12-28 16:02:29 -0500917static inline int security_kernel_post_read_file(struct file *file,
Mimi Zoharbc8ca5b2016-01-24 10:07:32 -0500918 char *buf, loff_t size,
919 enum kernel_read_file_id id)
Mimi Zoharb44a7df2015-12-28 16:02:29 -0500920{
921 return 0;
922}
923
David Howellsd84f4f92008-11-14 10:39:23 +1100924static inline int security_task_fix_setuid(struct cred *new,
925 const struct cred *old,
926 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927{
David Howellsd84f4f92008-11-14 10:39:23 +1100928 return cap_task_fix_setuid(new, old, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929}
930
Eric Paris7b41b172008-04-23 14:10:25 -0400931static inline int security_task_setpgid(struct task_struct *p, pid_t pgid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932{
933 return 0;
934}
935
Eric Paris7b41b172008-04-23 14:10:25 -0400936static inline int security_task_getpgid(struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937{
938 return 0;
939}
940
Eric Paris7b41b172008-04-23 14:10:25 -0400941static inline int security_task_getsid(struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942{
943 return 0;
944}
945
Eric Paris7b41b172008-04-23 14:10:25 -0400946static inline void security_task_getsecid(struct task_struct *p, u32 *secid)
Ahmed S. Darwish8a076192008-03-01 21:51:09 +0200947{
948 *secid = 0;
949}
David Quigleyf9008e4c2006-06-30 01:55:46 -0700950
Eric Paris7b41b172008-04-23 14:10:25 -0400951static inline int security_task_setnice(struct task_struct *p, int nice)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952{
Serge E. Hallynb5376772007-10-16 23:31:36 -0700953 return cap_task_setnice(p, nice);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954}
955
Eric Paris7b41b172008-04-23 14:10:25 -0400956static inline int security_task_setioprio(struct task_struct *p, int ioprio)
James Morris03e68062006-06-23 02:03:58 -0700957{
Serge E. Hallynb5376772007-10-16 23:31:36 -0700958 return cap_task_setioprio(p, ioprio);
James Morris03e68062006-06-23 02:03:58 -0700959}
960
Eric Paris7b41b172008-04-23 14:10:25 -0400961static inline int security_task_getioprio(struct task_struct *p)
David Quigleya1836a42006-06-30 01:55:49 -0700962{
963 return 0;
964}
965
Stephen Smalley791ec492017-02-17 07:57:00 -0500966static inline int security_task_prlimit(const struct cred *cred,
967 const struct cred *tcred,
968 unsigned int flags)
969{
970 return 0;
971}
972
Jiri Slaby8fd00b42009-08-26 18:41:16 +0200973static inline int security_task_setrlimit(struct task_struct *p,
974 unsigned int resource,
Eric Paris7b41b172008-04-23 14:10:25 -0400975 struct rlimit *new_rlim)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976{
977 return 0;
978}
979
KOSAKI Motohirob0ae1982010-10-15 04:21:18 +0900980static inline int security_task_setscheduler(struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981{
KOSAKI Motohirob0ae1982010-10-15 04:21:18 +0900982 return cap_task_setscheduler(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983}
984
Eric Paris7b41b172008-04-23 14:10:25 -0400985static inline int security_task_getscheduler(struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986{
987 return 0;
988}
989
Eric Paris7b41b172008-04-23 14:10:25 -0400990static inline int security_task_movememory(struct task_struct *p)
David Quigley35601542006-06-23 02:04:01 -0700991{
992 return 0;
993}
994
Eric Paris7b41b172008-04-23 14:10:25 -0400995static inline int security_task_kill(struct task_struct *p,
996 struct siginfo *info, int sig,
Stephen Smalley6b4f3d02017-09-08 12:40:01 -0400997 const struct cred *cred)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998{
Serge Hallynaedb60a2008-02-29 15:14:57 +0000999 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000}
1001
Eric Paris7b41b172008-04-23 14:10:25 -04001002static inline int security_task_prctl(int option, unsigned long arg2,
1003 unsigned long arg3,
1004 unsigned long arg4,
David Howellsd84f4f92008-11-14 10:39:23 +11001005 unsigned long arg5)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006{
Jann Hornb7f76ea2015-09-18 23:41:23 +02001007 return cap_task_prctl(option, arg2, arg3, arg4, arg5);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008}
1009
1010static inline void security_task_to_inode(struct task_struct *p, struct inode *inode)
1011{ }
1012
Eric Paris7b41b172008-04-23 14:10:25 -04001013static inline int security_ipc_permission(struct kern_ipc_perm *ipcp,
1014 short flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015{
1016 return 0;
1017}
1018
Ahmed S. Darwish8a076192008-03-01 21:51:09 +02001019static inline void security_ipc_getsecid(struct kern_ipc_perm *ipcp, u32 *secid)
1020{
1021 *secid = 0;
1022}
1023
Eric Paris7b41b172008-04-23 14:10:25 -04001024static inline int security_msg_msg_alloc(struct msg_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025{
1026 return 0;
1027}
1028
Eric Paris7b41b172008-04-23 14:10:25 -04001029static inline void security_msg_msg_free(struct msg_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030{ }
1031
Eric W. Biedermand8c6e852018-03-22 21:22:26 -05001032static inline int security_msg_queue_alloc(struct kern_ipc_perm *msq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033{
1034 return 0;
1035}
1036
Eric W. Biedermand8c6e852018-03-22 21:22:26 -05001037static inline void security_msg_queue_free(struct kern_ipc_perm *msq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038{ }
1039
Eric W. Biedermand8c6e852018-03-22 21:22:26 -05001040static inline int security_msg_queue_associate(struct kern_ipc_perm *msq,
Eric Paris7b41b172008-04-23 14:10:25 -04001041 int msqflg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042{
1043 return 0;
1044}
1045
Eric W. Biedermand8c6e852018-03-22 21:22:26 -05001046static inline int security_msg_queue_msgctl(struct kern_ipc_perm *msq, int cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047{
1048 return 0;
1049}
1050
Eric W. Biedermand8c6e852018-03-22 21:22:26 -05001051static inline int security_msg_queue_msgsnd(struct kern_ipc_perm *msq,
Eric Paris7b41b172008-04-23 14:10:25 -04001052 struct msg_msg *msg, int msqflg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053{
1054 return 0;
1055}
1056
Eric W. Biedermand8c6e852018-03-22 21:22:26 -05001057static inline int security_msg_queue_msgrcv(struct kern_ipc_perm *msq,
Eric Paris7b41b172008-04-23 14:10:25 -04001058 struct msg_msg *msg,
1059 struct task_struct *target,
1060 long type, int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061{
1062 return 0;
1063}
1064
Eric W. Biederman7191adf2018-03-22 21:08:27 -05001065static inline int security_shm_alloc(struct kern_ipc_perm *shp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066{
1067 return 0;
1068}
1069
Eric W. Biederman7191adf2018-03-22 21:08:27 -05001070static inline void security_shm_free(struct kern_ipc_perm *shp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071{ }
1072
Eric W. Biederman7191adf2018-03-22 21:08:27 -05001073static inline int security_shm_associate(struct kern_ipc_perm *shp,
Eric Paris7b41b172008-04-23 14:10:25 -04001074 int shmflg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075{
1076 return 0;
1077}
1078
Eric W. Biederman7191adf2018-03-22 21:08:27 -05001079static inline int security_shm_shmctl(struct kern_ipc_perm *shp, int cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080{
1081 return 0;
1082}
1083
Eric W. Biederman7191adf2018-03-22 21:08:27 -05001084static inline int security_shm_shmat(struct kern_ipc_perm *shp,
Eric Paris7b41b172008-04-23 14:10:25 -04001085 char __user *shmaddr, int shmflg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086{
1087 return 0;
1088}
1089
Eric W. Biedermanaefad952018-03-22 20:52:43 -05001090static inline int security_sem_alloc(struct kern_ipc_perm *sma)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091{
1092 return 0;
1093}
1094
Eric W. Biedermanaefad952018-03-22 20:52:43 -05001095static inline void security_sem_free(struct kern_ipc_perm *sma)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096{ }
1097
Eric W. Biedermanaefad952018-03-22 20:52:43 -05001098static inline int security_sem_associate(struct kern_ipc_perm *sma, int semflg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099{
1100 return 0;
1101}
1102
Eric W. Biedermanaefad952018-03-22 20:52:43 -05001103static inline int security_sem_semctl(struct kern_ipc_perm *sma, int cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104{
1105 return 0;
1106}
1107
Eric W. Biedermanaefad952018-03-22 20:52:43 -05001108static inline int security_sem_semop(struct kern_ipc_perm *sma,
Eric Paris7b41b172008-04-23 14:10:25 -04001109 struct sembuf *sops, unsigned nsops,
1110 int alter)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111{
1112 return 0;
1113}
1114
Eric Paris7b41b172008-04-23 14:10:25 -04001115static inline void security_d_instantiate(struct dentry *dentry, struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116{ }
1117
Al Viro04ff9702007-03-12 16:17:58 +00001118static inline int security_getprocattr(struct task_struct *p, char *name, char **value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119{
1120 return -EINVAL;
1121}
1122
Stephen Smalleyb21507e2017-01-09 10:07:31 -05001123static inline int security_setprocattr(char *name, void *value, size_t size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124{
1125 return -EINVAL;
1126}
1127
Eric Paris7b41b172008-04-23 14:10:25 -04001128static inline int security_netlink_send(struct sock *sk, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129{
Casey Schauflerb1d9e6b2015-05-02 15:11:42 -07001130 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131}
1132
David Quigley746df9b2013-05-22 12:50:35 -04001133static inline int security_ismaclabel(const char *name)
1134{
1135 return 0;
1136}
1137
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07001138static inline int security_secid_to_secctx(u32 secid, char **secdata, u32 *seclen)
1139{
1140 return -EOPNOTSUPP;
1141}
1142
David Howells7bf570d2008-04-29 20:52:51 +01001143static inline int security_secctx_to_secid(const char *secdata,
David Howells63cb3442008-01-15 23:47:35 +00001144 u32 seclen,
1145 u32 *secid)
1146{
1147 return -EOPNOTSUPP;
1148}
1149
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07001150static inline void security_release_secctx(char *secdata, u32 seclen)
1151{
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07001152}
David P. Quigley1ee65e32009-09-03 14:25:57 -04001153
Andreas Gruenbacher6f3be9f2015-12-24 11:09:40 -05001154static inline void security_inode_invalidate_secctx(struct inode *inode)
1155{
1156}
1157
David P. Quigley1ee65e32009-09-03 14:25:57 -04001158static inline int security_inode_notifysecctx(struct inode *inode, void *ctx, u32 ctxlen)
1159{
1160 return -EOPNOTSUPP;
1161}
1162static inline int security_inode_setsecctx(struct dentry *dentry, void *ctx, u32 ctxlen)
1163{
1164 return -EOPNOTSUPP;
1165}
1166static inline int security_inode_getsecctx(struct inode *inode, void **ctx, u32 *ctxlen)
1167{
1168 return -EOPNOTSUPP;
1169}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170#endif /* CONFIG_SECURITY */
1171
1172#ifdef CONFIG_SECURITY_NETWORK
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173
David S. Miller3610cda2011-01-05 15:38:53 -08001174int security_unix_stream_connect(struct sock *sock, struct sock *other, struct sock *newsk);
James Morris20510f22007-10-16 23:31:32 -07001175int security_unix_may_send(struct socket *sock, struct socket *other);
1176int security_socket_create(int family, int type, int protocol, int kern);
1177int security_socket_post_create(struct socket *sock, int family,
1178 int type, int protocol, int kern);
David Herrmannaae7cfc2018-05-04 16:28:19 +02001179int security_socket_socketpair(struct socket *socka, struct socket *sockb);
James Morris20510f22007-10-16 23:31:32 -07001180int security_socket_bind(struct socket *sock, struct sockaddr *address, int addrlen);
1181int security_socket_connect(struct socket *sock, struct sockaddr *address, int addrlen);
1182int security_socket_listen(struct socket *sock, int backlog);
1183int security_socket_accept(struct socket *sock, struct socket *newsock);
James Morris20510f22007-10-16 23:31:32 -07001184int security_socket_sendmsg(struct socket *sock, struct msghdr *msg, int size);
1185int security_socket_recvmsg(struct socket *sock, struct msghdr *msg,
1186 int size, int flags);
1187int security_socket_getsockname(struct socket *sock);
1188int security_socket_getpeername(struct socket *sock);
1189int security_socket_getsockopt(struct socket *sock, int level, int optname);
1190int security_socket_setsockopt(struct socket *sock, int level, int optname);
1191int security_socket_shutdown(struct socket *sock, int how);
1192int security_sock_rcv_skb(struct sock *sk, struct sk_buff *skb);
1193int security_socket_getpeersec_stream(struct socket *sock, char __user *optval,
1194 int __user *optlen, unsigned len);
1195int security_socket_getpeersec_dgram(struct socket *sock, struct sk_buff *skb, u32 *secid);
1196int security_sk_alloc(struct sock *sk, int family, gfp_t priority);
1197void security_sk_free(struct sock *sk);
1198void security_sk_clone(const struct sock *sk, struct sock *newsk);
1199void security_sk_classify_flow(struct sock *sk, struct flowi *fl);
1200void security_req_classify_flow(const struct request_sock *req, struct flowi *fl);
1201void security_sock_graft(struct sock*sk, struct socket *parent);
1202int security_inet_conn_request(struct sock *sk,
1203 struct sk_buff *skb, struct request_sock *req);
1204void security_inet_csk_clone(struct sock *newsk,
1205 const struct request_sock *req);
1206void security_inet_conn_established(struct sock *sk,
1207 struct sk_buff *skb);
Eric Paris2606fd12010-10-13 16:24:41 -04001208int security_secmark_relabel_packet(u32 secid);
1209void security_secmark_refcount_inc(void);
1210void security_secmark_refcount_dec(void);
Paul Moore5dbbaf22013-01-14 07:12:19 +00001211int security_tun_dev_alloc_security(void **security);
1212void security_tun_dev_free_security(void *security);
Paul Moore2b980db2009-08-28 18:12:43 -04001213int security_tun_dev_create(void);
Paul Moore5dbbaf22013-01-14 07:12:19 +00001214int security_tun_dev_attach_queue(void *security);
1215int security_tun_dev_attach(struct sock *sk, void *security);
1216int security_tun_dev_open(void *security);
Richard Haines72e89f52018-02-13 20:53:21 +00001217int security_sctp_assoc_request(struct sctp_endpoint *ep, struct sk_buff *skb);
1218int security_sctp_bind_connect(struct sock *sk, int optname,
1219 struct sockaddr *address, int addrlen);
1220void security_sctp_sk_clone(struct sctp_endpoint *ep, struct sock *sk,
1221 struct sock *newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223#else /* CONFIG_SECURITY_NETWORK */
David S. Miller3610cda2011-01-05 15:38:53 -08001224static inline int security_unix_stream_connect(struct sock *sock,
1225 struct sock *other,
Eric Paris7b41b172008-04-23 14:10:25 -04001226 struct sock *newsk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227{
1228 return 0;
1229}
1230
Eric Paris7b41b172008-04-23 14:10:25 -04001231static inline int security_unix_may_send(struct socket *sock,
1232 struct socket *other)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233{
1234 return 0;
1235}
1236
Eric Paris7b41b172008-04-23 14:10:25 -04001237static inline int security_socket_create(int family, int type,
1238 int protocol, int kern)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239{
1240 return 0;
1241}
1242
Eric Paris7b41b172008-04-23 14:10:25 -04001243static inline int security_socket_post_create(struct socket *sock,
Venkat Yekkirala7420ed22006-08-04 23:17:57 -07001244 int family,
1245 int type,
1246 int protocol, int kern)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247{
Venkat Yekkirala7420ed22006-08-04 23:17:57 -07001248 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249}
1250
David Herrmannaae7cfc2018-05-04 16:28:19 +02001251static inline int security_socket_socketpair(struct socket *socka,
1252 struct socket *sockb)
1253{
1254 return 0;
1255}
1256
Eric Paris7b41b172008-04-23 14:10:25 -04001257static inline int security_socket_bind(struct socket *sock,
1258 struct sockaddr *address,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259 int addrlen)
1260{
1261 return 0;
1262}
1263
Eric Paris7b41b172008-04-23 14:10:25 -04001264static inline int security_socket_connect(struct socket *sock,
1265 struct sockaddr *address,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 int addrlen)
1267{
1268 return 0;
1269}
1270
Eric Paris7b41b172008-04-23 14:10:25 -04001271static inline int security_socket_listen(struct socket *sock, int backlog)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272{
1273 return 0;
1274}
1275
Eric Paris7b41b172008-04-23 14:10:25 -04001276static inline int security_socket_accept(struct socket *sock,
1277 struct socket *newsock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278{
1279 return 0;
1280}
1281
Eric Paris7b41b172008-04-23 14:10:25 -04001282static inline int security_socket_sendmsg(struct socket *sock,
1283 struct msghdr *msg, int size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284{
1285 return 0;
1286}
1287
Eric Paris7b41b172008-04-23 14:10:25 -04001288static inline int security_socket_recvmsg(struct socket *sock,
1289 struct msghdr *msg, int size,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290 int flags)
1291{
1292 return 0;
1293}
1294
Eric Paris7b41b172008-04-23 14:10:25 -04001295static inline int security_socket_getsockname(struct socket *sock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296{
1297 return 0;
1298}
1299
Eric Paris7b41b172008-04-23 14:10:25 -04001300static inline int security_socket_getpeername(struct socket *sock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301{
1302 return 0;
1303}
1304
Eric Paris7b41b172008-04-23 14:10:25 -04001305static inline int security_socket_getsockopt(struct socket *sock,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306 int level, int optname)
1307{
1308 return 0;
1309}
1310
Eric Paris7b41b172008-04-23 14:10:25 -04001311static inline int security_socket_setsockopt(struct socket *sock,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 int level, int optname)
1313{
1314 return 0;
1315}
1316
Eric Paris7b41b172008-04-23 14:10:25 -04001317static inline int security_socket_shutdown(struct socket *sock, int how)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318{
1319 return 0;
1320}
Eric Paris7b41b172008-04-23 14:10:25 -04001321static inline int security_sock_rcv_skb(struct sock *sk,
1322 struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323{
1324 return 0;
1325}
1326
Catherine Zhang2c7946a2006-03-20 22:41:23 -08001327static inline int security_socket_getpeersec_stream(struct socket *sock, char __user *optval,
1328 int __user *optlen, unsigned len)
1329{
1330 return -ENOPROTOOPT;
1331}
1332
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07001333static inline int security_socket_getpeersec_dgram(struct socket *sock, struct sk_buff *skb, u32 *secid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334{
1335 return -ENOPROTOOPT;
1336}
1337
Al Virodd0fc662005-10-07 07:46:04 +01001338static inline int security_sk_alloc(struct sock *sk, int family, gfp_t priority)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339{
1340 return 0;
1341}
1342
1343static inline void security_sk_free(struct sock *sk)
1344{
1345}
Trent Jaegerdf718372005-12-13 23:12:27 -08001346
Venkat Yekkirala892c1412006-08-04 23:08:56 -07001347static inline void security_sk_clone(const struct sock *sk, struct sock *newsk)
1348{
1349}
1350
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -07001351static inline void security_sk_classify_flow(struct sock *sk, struct flowi *fl)
Trent Jaegerdf718372005-12-13 23:12:27 -08001352{
Trent Jaegerdf718372005-12-13 23:12:27 -08001353}
Venkat Yekkirala4237c752006-07-24 23:32:50 -07001354
1355static inline void security_req_classify_flow(const struct request_sock *req, struct flowi *fl)
1356{
1357}
1358
Eric Paris7b41b172008-04-23 14:10:25 -04001359static inline void security_sock_graft(struct sock *sk, struct socket *parent)
Venkat Yekkirala4237c752006-07-24 23:32:50 -07001360{
1361}
1362
1363static inline int security_inet_conn_request(struct sock *sk,
1364 struct sk_buff *skb, struct request_sock *req)
1365{
1366 return 0;
1367}
1368
1369static inline void security_inet_csk_clone(struct sock *newsk,
1370 const struct request_sock *req)
1371{
1372}
Venkat Yekkirala6b877692006-11-08 17:04:09 -06001373
1374static inline void security_inet_conn_established(struct sock *sk,
1375 struct sk_buff *skb)
1376{
1377}
Paul Moore2b980db2009-08-28 18:12:43 -04001378
Eric Paris2606fd12010-10-13 16:24:41 -04001379static inline int security_secmark_relabel_packet(u32 secid)
1380{
1381 return 0;
1382}
1383
1384static inline void security_secmark_refcount_inc(void)
1385{
1386}
1387
1388static inline void security_secmark_refcount_dec(void)
1389{
1390}
1391
Paul Moore5dbbaf22013-01-14 07:12:19 +00001392static inline int security_tun_dev_alloc_security(void **security)
1393{
1394 return 0;
1395}
1396
1397static inline void security_tun_dev_free_security(void *security)
1398{
1399}
1400
Paul Moore2b980db2009-08-28 18:12:43 -04001401static inline int security_tun_dev_create(void)
1402{
1403 return 0;
1404}
1405
Paul Moore5dbbaf22013-01-14 07:12:19 +00001406static inline int security_tun_dev_attach_queue(void *security)
Paul Moore2b980db2009-08-28 18:12:43 -04001407{
Paul Moore5dbbaf22013-01-14 07:12:19 +00001408 return 0;
Paul Moore2b980db2009-08-28 18:12:43 -04001409}
1410
Paul Moore5dbbaf22013-01-14 07:12:19 +00001411static inline int security_tun_dev_attach(struct sock *sk, void *security)
1412{
1413 return 0;
1414}
1415
1416static inline int security_tun_dev_open(void *security)
Paul Moore2b980db2009-08-28 18:12:43 -04001417{
1418 return 0;
1419}
Richard Haines72e89f52018-02-13 20:53:21 +00001420
1421static inline int security_sctp_assoc_request(struct sctp_endpoint *ep,
1422 struct sk_buff *skb)
1423{
1424 return 0;
1425}
1426
1427static inline int security_sctp_bind_connect(struct sock *sk, int optname,
1428 struct sockaddr *address,
1429 int addrlen)
1430{
1431 return 0;
1432}
1433
1434static inline void security_sctp_sk_clone(struct sctp_endpoint *ep,
1435 struct sock *sk,
1436 struct sock *newsk)
1437{
1438}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439#endif /* CONFIG_SECURITY_NETWORK */
1440
Daniel Jurgensd291f1a2017-05-19 15:48:52 +03001441#ifdef CONFIG_SECURITY_INFINIBAND
1442int security_ib_pkey_access(void *sec, u64 subnet_prefix, u16 pkey);
Daniel Jurgens47a2b332017-05-19 15:48:54 +03001443int security_ib_endport_manage_subnet(void *sec, const char *name, u8 port_num);
Daniel Jurgensd291f1a2017-05-19 15:48:52 +03001444int security_ib_alloc_security(void **sec);
1445void security_ib_free_security(void *sec);
1446#else /* CONFIG_SECURITY_INFINIBAND */
1447static inline int security_ib_pkey_access(void *sec, u64 subnet_prefix, u16 pkey)
1448{
1449 return 0;
1450}
1451
Daniel Jurgens47a2b332017-05-19 15:48:54 +03001452static inline int security_ib_endport_manage_subnet(void *sec, const char *dev_name, u8 port_num)
1453{
1454 return 0;
1455}
1456
Daniel Jurgensd291f1a2017-05-19 15:48:52 +03001457static inline int security_ib_alloc_security(void **sec)
1458{
1459 return 0;
1460}
1461
1462static inline void security_ib_free_security(void *sec)
1463{
1464}
1465#endif /* CONFIG_SECURITY_INFINIBAND */
1466
Trent Jaegerdf718372005-12-13 23:12:27 -08001467#ifdef CONFIG_SECURITY_NETWORK_XFRM
Venkat Yekkiralacb969f02006-07-24 23:32:20 -07001468
Nikolay Aleksandrov52a4c642014-03-07 12:44:19 +01001469int security_xfrm_policy_alloc(struct xfrm_sec_ctx **ctxp,
1470 struct xfrm_user_sec_ctx *sec_ctx, gfp_t gfp);
Paul Moore03e1ad72008-04-12 19:07:52 -07001471int security_xfrm_policy_clone(struct xfrm_sec_ctx *old_ctx, struct xfrm_sec_ctx **new_ctxp);
1472void security_xfrm_policy_free(struct xfrm_sec_ctx *ctx);
1473int security_xfrm_policy_delete(struct xfrm_sec_ctx *ctx);
James Morris20510f22007-10-16 23:31:32 -07001474int security_xfrm_state_alloc(struct xfrm_state *x, struct xfrm_user_sec_ctx *sec_ctx);
1475int security_xfrm_state_alloc_acquire(struct xfrm_state *x,
1476 struct xfrm_sec_ctx *polsec, u32 secid);
1477int security_xfrm_state_delete(struct xfrm_state *x);
1478void security_xfrm_state_free(struct xfrm_state *x);
Paul Moore03e1ad72008-04-12 19:07:52 -07001479int security_xfrm_policy_lookup(struct xfrm_sec_ctx *ctx, u32 fl_secid, u8 dir);
James Morris20510f22007-10-16 23:31:32 -07001480int security_xfrm_state_pol_flow_match(struct xfrm_state *x,
David S. Millere33f7702011-02-22 18:13:15 -08001481 struct xfrm_policy *xp,
1482 const struct flowi *fl);
James Morris20510f22007-10-16 23:31:32 -07001483int security_xfrm_decode_session(struct sk_buff *skb, u32 *secid);
1484void security_skb_classify_flow(struct sk_buff *skb, struct flowi *fl);
Trent Jaegerdf718372005-12-13 23:12:27 -08001485
Trent Jaegerdf718372005-12-13 23:12:27 -08001486#else /* CONFIG_SECURITY_NETWORK_XFRM */
James Morris20510f22007-10-16 23:31:32 -07001487
Nikolay Aleksandrov52a4c642014-03-07 12:44:19 +01001488static inline int security_xfrm_policy_alloc(struct xfrm_sec_ctx **ctxp,
1489 struct xfrm_user_sec_ctx *sec_ctx,
1490 gfp_t gfp)
Trent Jaegerdf718372005-12-13 23:12:27 -08001491{
1492 return 0;
1493}
1494
Paul Moore03e1ad72008-04-12 19:07:52 -07001495static inline int security_xfrm_policy_clone(struct xfrm_sec_ctx *old, struct xfrm_sec_ctx **new_ctxp)
Trent Jaegerdf718372005-12-13 23:12:27 -08001496{
1497 return 0;
1498}
1499
Paul Moore03e1ad72008-04-12 19:07:52 -07001500static inline void security_xfrm_policy_free(struct xfrm_sec_ctx *ctx)
Trent Jaegerdf718372005-12-13 23:12:27 -08001501{
1502}
1503
Paul Moore03e1ad72008-04-12 19:07:52 -07001504static inline int security_xfrm_policy_delete(struct xfrm_sec_ctx *ctx)
Catherine Zhangc8c05a82006-06-08 23:39:49 -07001505{
1506 return 0;
1507}
1508
Venkat Yekkiralae0d1caa2006-07-24 23:29:07 -07001509static inline int security_xfrm_state_alloc(struct xfrm_state *x,
1510 struct xfrm_user_sec_ctx *sec_ctx)
1511{
1512 return 0;
1513}
1514
1515static inline int security_xfrm_state_alloc_acquire(struct xfrm_state *x,
1516 struct xfrm_sec_ctx *polsec, u32 secid)
Trent Jaegerdf718372005-12-13 23:12:27 -08001517{
1518 return 0;
1519}
1520
1521static inline void security_xfrm_state_free(struct xfrm_state *x)
1522{
1523}
1524
David S. Miller6f68dc32006-06-08 23:58:52 -07001525static inline int security_xfrm_state_delete(struct xfrm_state *x)
Catherine Zhangc8c05a82006-06-08 23:39:49 -07001526{
1527 return 0;
1528}
1529
Paul Moore03e1ad72008-04-12 19:07:52 -07001530static inline int security_xfrm_policy_lookup(struct xfrm_sec_ctx *ctx, u32 fl_secid, u8 dir)
Trent Jaegerdf718372005-12-13 23:12:27 -08001531{
1532 return 0;
1533}
Venkat Yekkiralae0d1caa2006-07-24 23:29:07 -07001534
1535static inline int security_xfrm_state_pol_flow_match(struct xfrm_state *x,
David S. Millere33f7702011-02-22 18:13:15 -08001536 struct xfrm_policy *xp, const struct flowi *fl)
Venkat Yekkiralae0d1caa2006-07-24 23:29:07 -07001537{
1538 return 1;
1539}
1540
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -07001541static inline int security_xfrm_decode_session(struct sk_buff *skb, u32 *secid)
Venkat Yekkiralae0d1caa2006-07-24 23:29:07 -07001542{
1543 return 0;
1544}
1545
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -07001546static inline void security_skb_classify_flow(struct sk_buff *skb, struct flowi *fl)
1547{
1548}
1549
Trent Jaegerdf718372005-12-13 23:12:27 -08001550#endif /* CONFIG_SECURITY_NETWORK_XFRM */
1551
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09001552#ifdef CONFIG_SECURITY_PATH
Al Viro989f74e2016-03-25 15:13:39 -04001553int security_path_unlink(const struct path *dir, struct dentry *dentry);
Al Virod3607752016-03-25 15:21:09 -04001554int security_path_mkdir(const struct path *dir, struct dentry *dentry, umode_t mode);
Al Viro989f74e2016-03-25 15:13:39 -04001555int security_path_rmdir(const struct path *dir, struct dentry *dentry);
Al Virod3607752016-03-25 15:21:09 -04001556int security_path_mknod(const struct path *dir, struct dentry *dentry, umode_t mode,
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09001557 unsigned int dev);
Al Viro81f4c502016-03-25 14:22:01 -04001558int security_path_truncate(const struct path *path);
Al Virod3607752016-03-25 15:21:09 -04001559int security_path_symlink(const struct path *dir, struct dentry *dentry,
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09001560 const char *old_name);
Al Viro3ccee462016-03-25 15:27:45 -04001561int security_path_link(struct dentry *old_dentry, const struct path *new_dir,
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09001562 struct dentry *new_dentry);
Al Viro3ccee462016-03-25 15:27:45 -04001563int security_path_rename(const struct path *old_dir, struct dentry *old_dentry,
1564 const struct path *new_dir, struct dentry *new_dentry,
Miklos Szeredi0b3974e2014-04-01 17:08:43 +02001565 unsigned int flags);
Al Virobe01f9f2016-03-25 14:56:23 -04001566int security_path_chmod(const struct path *path, umode_t mode);
Al Viro7fd25da2016-03-25 14:44:41 -04001567int security_path_chown(const struct path *path, kuid_t uid, kgid_t gid);
Al Viro77b286c2016-03-25 15:28:43 -04001568int security_path_chroot(const struct path *path);
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09001569#else /* CONFIG_SECURITY_PATH */
Al Viro989f74e2016-03-25 15:13:39 -04001570static inline int security_path_unlink(const struct path *dir, struct dentry *dentry)
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09001571{
1572 return 0;
1573}
1574
Al Virod3607752016-03-25 15:21:09 -04001575static inline int security_path_mkdir(const struct path *dir, struct dentry *dentry,
Al Viro4572bef2011-11-21 14:56:21 -05001576 umode_t mode)
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09001577{
1578 return 0;
1579}
1580
Al Viro989f74e2016-03-25 15:13:39 -04001581static inline int security_path_rmdir(const struct path *dir, struct dentry *dentry)
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09001582{
1583 return 0;
1584}
1585
Al Virod3607752016-03-25 15:21:09 -04001586static inline int security_path_mknod(const struct path *dir, struct dentry *dentry,
Al Viro04fc66e2011-11-21 14:58:38 -05001587 umode_t mode, unsigned int dev)
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09001588{
1589 return 0;
1590}
1591
Al Viro81f4c502016-03-25 14:22:01 -04001592static inline int security_path_truncate(const struct path *path)
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09001593{
1594 return 0;
1595}
1596
Al Virod3607752016-03-25 15:21:09 -04001597static inline int security_path_symlink(const struct path *dir, struct dentry *dentry,
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09001598 const char *old_name)
1599{
1600 return 0;
1601}
1602
1603static inline int security_path_link(struct dentry *old_dentry,
Al Viro3ccee462016-03-25 15:27:45 -04001604 const struct path *new_dir,
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09001605 struct dentry *new_dentry)
1606{
1607 return 0;
1608}
1609
Al Viro3ccee462016-03-25 15:27:45 -04001610static inline int security_path_rename(const struct path *old_dir,
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09001611 struct dentry *old_dentry,
Al Viro3ccee462016-03-25 15:27:45 -04001612 const struct path *new_dir,
Miklos Szeredi0b3974e2014-04-01 17:08:43 +02001613 struct dentry *new_dentry,
1614 unsigned int flags)
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09001615{
1616 return 0;
1617}
Tetsuo Handa89eda062009-10-04 21:49:47 +09001618
Al Virobe01f9f2016-03-25 14:56:23 -04001619static inline int security_path_chmod(const struct path *path, umode_t mode)
Tetsuo Handa89eda062009-10-04 21:49:47 +09001620{
1621 return 0;
1622}
1623
Al Viro7fd25da2016-03-25 14:44:41 -04001624static inline int security_path_chown(const struct path *path, kuid_t uid, kgid_t gid)
Tetsuo Handa89eda062009-10-04 21:49:47 +09001625{
1626 return 0;
1627}
Tetsuo Handa8b8efb42009-10-04 21:49:48 +09001628
Al Viro77b286c2016-03-25 15:28:43 -04001629static inline int security_path_chroot(const struct path *path)
Tetsuo Handa8b8efb42009-10-04 21:49:48 +09001630{
1631 return 0;
1632}
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09001633#endif /* CONFIG_SECURITY_PATH */
1634
David Howells29db9192005-10-30 15:02:44 -08001635#ifdef CONFIG_KEYS
1636#ifdef CONFIG_SECURITY
David Howells29db9192005-10-30 15:02:44 -08001637
David Howellsd84f4f92008-11-14 10:39:23 +11001638int security_key_alloc(struct key *key, const struct cred *cred, unsigned long flags);
James Morris20510f22007-10-16 23:31:32 -07001639void security_key_free(struct key *key);
1640int security_key_permission(key_ref_t key_ref,
David Howellsf5895942014-03-14 17:44:49 +00001641 const struct cred *cred, unsigned perm);
David Howells70a5bb72008-04-29 01:01:26 -07001642int security_key_getsecurity(struct key *key, char **_buffer);
David Howells29db9192005-10-30 15:02:44 -08001643
1644#else
1645
Michael LeMayd7200242006-06-22 14:47:17 -07001646static inline int security_key_alloc(struct key *key,
David Howellsd84f4f92008-11-14 10:39:23 +11001647 const struct cred *cred,
David Howells7e047ef2006-06-26 00:24:50 -07001648 unsigned long flags)
David Howells29db9192005-10-30 15:02:44 -08001649{
1650 return 0;
1651}
1652
1653static inline void security_key_free(struct key *key)
1654{
1655}
1656
1657static inline int security_key_permission(key_ref_t key_ref,
David Howellsd84f4f92008-11-14 10:39:23 +11001658 const struct cred *cred,
David Howellsf5895942014-03-14 17:44:49 +00001659 unsigned perm)
David Howells29db9192005-10-30 15:02:44 -08001660{
1661 return 0;
1662}
1663
David Howells70a5bb72008-04-29 01:01:26 -07001664static inline int security_key_getsecurity(struct key *key, char **_buffer)
1665{
1666 *_buffer = NULL;
1667 return 0;
1668}
1669
David Howells29db9192005-10-30 15:02:44 -08001670#endif
1671#endif /* CONFIG_KEYS */
1672
Ahmed S. Darwish03d37d22008-03-01 22:00:05 +02001673#ifdef CONFIG_AUDIT
1674#ifdef CONFIG_SECURITY
1675int security_audit_rule_init(u32 field, u32 op, char *rulestr, void **lsmrule);
1676int security_audit_rule_known(struct audit_krule *krule);
1677int security_audit_rule_match(u32 secid, u32 field, u32 op, void *lsmrule,
1678 struct audit_context *actx);
1679void security_audit_rule_free(void *lsmrule);
1680
1681#else
1682
1683static inline int security_audit_rule_init(u32 field, u32 op, char *rulestr,
1684 void **lsmrule)
1685{
1686 return 0;
1687}
1688
1689static inline int security_audit_rule_known(struct audit_krule *krule)
1690{
1691 return 0;
1692}
1693
1694static inline int security_audit_rule_match(u32 secid, u32 field, u32 op,
1695 void *lsmrule, struct audit_context *actx)
1696{
1697 return 0;
1698}
1699
1700static inline void security_audit_rule_free(void *lsmrule)
1701{ }
1702
1703#endif /* CONFIG_SECURITY */
1704#endif /* CONFIG_AUDIT */
1705
Eric Parisda318942008-08-22 11:35:57 -04001706#ifdef CONFIG_SECURITYFS
1707
Al Viro52ef0c02011-07-26 04:30:04 -04001708extern struct dentry *securityfs_create_file(const char *name, umode_t mode,
Eric Parisda318942008-08-22 11:35:57 -04001709 struct dentry *parent, void *data,
1710 const struct file_operations *fops);
1711extern struct dentry *securityfs_create_dir(const char *name, struct dentry *parent);
John Johansen6623ec72017-05-07 05:53:37 -07001712struct dentry *securityfs_create_symlink(const char *name,
1713 struct dentry *parent,
1714 const char *target,
1715 const struct inode_operations *iops);
Eric Parisda318942008-08-22 11:35:57 -04001716extern void securityfs_remove(struct dentry *dentry);
1717
1718#else /* CONFIG_SECURITYFS */
1719
1720static inline struct dentry *securityfs_create_dir(const char *name,
1721 struct dentry *parent)
1722{
1723 return ERR_PTR(-ENODEV);
1724}
1725
1726static inline struct dentry *securityfs_create_file(const char *name,
Al Viro52ef0c02011-07-26 04:30:04 -04001727 umode_t mode,
Eric Parisda318942008-08-22 11:35:57 -04001728 struct dentry *parent,
1729 void *data,
1730 const struct file_operations *fops)
1731{
1732 return ERR_PTR(-ENODEV);
1733}
1734
John Johansen6623ec72017-05-07 05:53:37 -07001735static inline struct dentry *securityfs_create_symlink(const char *name,
1736 struct dentry *parent,
1737 const char *target,
1738 const struct inode_operations *iops)
1739{
1740 return ERR_PTR(-ENODEV);
1741}
1742
Eric Parisda318942008-08-22 11:35:57 -04001743static inline void securityfs_remove(struct dentry *dentry)
1744{}
1745
1746#endif
1747
Chenbo Fengafdb09c2017-10-18 13:00:24 -07001748#ifdef CONFIG_BPF_SYSCALL
Jakub Kicinski1495dc92017-11-01 11:48:00 -07001749union bpf_attr;
1750struct bpf_map;
1751struct bpf_prog;
1752struct bpf_prog_aux;
Chenbo Fengafdb09c2017-10-18 13:00:24 -07001753#ifdef CONFIG_SECURITY
1754extern int security_bpf(int cmd, union bpf_attr *attr, unsigned int size);
1755extern int security_bpf_map(struct bpf_map *map, fmode_t fmode);
1756extern int security_bpf_prog(struct bpf_prog *prog);
1757extern int security_bpf_map_alloc(struct bpf_map *map);
1758extern void security_bpf_map_free(struct bpf_map *map);
1759extern int security_bpf_prog_alloc(struct bpf_prog_aux *aux);
1760extern void security_bpf_prog_free(struct bpf_prog_aux *aux);
1761#else
1762static inline int security_bpf(int cmd, union bpf_attr *attr,
1763 unsigned int size)
1764{
1765 return 0;
1766}
1767
1768static inline int security_bpf_map(struct bpf_map *map, fmode_t fmode)
1769{
1770 return 0;
1771}
1772
1773static inline int security_bpf_prog(struct bpf_prog *prog)
1774{
1775 return 0;
1776}
1777
1778static inline int security_bpf_map_alloc(struct bpf_map *map)
1779{
1780 return 0;
1781}
1782
1783static inline void security_bpf_map_free(struct bpf_map *map)
1784{ }
1785
1786static inline int security_bpf_prog_alloc(struct bpf_prog_aux *aux)
1787{
1788 return 0;
1789}
1790
1791static inline void security_bpf_prog_free(struct bpf_prog_aux *aux)
1792{ }
1793#endif /* CONFIG_SECURITY */
1794#endif /* CONFIG_BPF_SYSCALL */
1795
Pekka Enberg3d544f42009-03-24 11:59:23 +02001796#ifdef CONFIG_SECURITY
1797
1798static inline char *alloc_secdata(void)
1799{
1800 return (char *)get_zeroed_page(GFP_KERNEL);
1801}
1802
1803static inline void free_secdata(void *secdata)
1804{
1805 free_page((unsigned long)secdata);
1806}
1807
1808#else
1809
1810static inline char *alloc_secdata(void)
1811{
1812 return (char *)1;
1813}
1814
1815static inline void free_secdata(void *secdata)
1816{ }
1817#endif /* CONFIG_SECURITY */
1818
Linus Torvalds1da177e2005-04-16 15:20:36 -07001819#endif /* ! __LINUX_SECURITY_H */
1820