Branch data Line data Source code
1 : : /*
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)
9 : : * Copyright (C) 2016 Mellanox Techonologies
10 : : *
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 : :
26 : : #include <linux/key.h>
27 : : #include <linux/capability.h>
28 : : #include <linux/fs.h>
29 : : #include <linux/slab.h>
30 : : #include <linux/err.h>
31 : : #include <linux/string.h>
32 : : #include <linux/mm.h>
33 : : #include <linux/fs.h>
34 : :
35 : : struct linux_binprm;
36 : : struct cred;
37 : : struct rlimit;
38 : : struct kernel_siginfo;
39 : : struct sembuf;
40 : : struct kern_ipc_perm;
41 : : struct audit_context;
42 : : struct super_block;
43 : : struct inode;
44 : : struct dentry;
45 : : struct file;
46 : : struct vfsmount;
47 : : struct path;
48 : : struct qstr;
49 : : struct iattr;
50 : : struct fown_struct;
51 : : struct file_operations;
52 : : struct msg_msg;
53 : : struct xattr;
54 : : struct kernfs_node;
55 : : struct xfrm_sec_ctx;
56 : : struct mm_struct;
57 : : struct fs_context;
58 : : struct fs_parameter;
59 : : enum fs_value_type;
60 : :
61 : : /* Default (no) options for the capable function */
62 : : #define CAP_OPT_NONE 0x0
63 : : /* If capable should audit the security request */
64 : : #define CAP_OPT_NOAUDIT BIT(1)
65 : : /* If capable is being called by a setid function */
66 : : #define CAP_OPT_INSETID BIT(2)
67 : :
68 : : /* LSM Agnostic defines for fs_context::lsm_flags */
69 : : #define SECURITY_LSM_NATIVE_LABELS 1
70 : :
71 : : struct ctl_table;
72 : : struct audit_krule;
73 : : struct user_namespace;
74 : : struct timezone;
75 : :
76 : : enum lsm_event {
77 : : LSM_POLICY_CHANGE,
78 : : };
79 : :
80 : : /*
81 : : * These are reasons that can be passed to the security_locked_down()
82 : : * LSM hook. Lockdown reasons that protect kernel integrity (ie, the
83 : : * ability for userland to modify kernel code) are placed before
84 : : * LOCKDOWN_INTEGRITY_MAX. Lockdown reasons that protect kernel
85 : : * confidentiality (ie, the ability for userland to extract
86 : : * information from the running kernel that would otherwise be
87 : : * restricted) are placed before LOCKDOWN_CONFIDENTIALITY_MAX.
88 : : *
89 : : * LSM authors should note that the semantics of any given lockdown
90 : : * reason are not guaranteed to be stable - the same reason may block
91 : : * one set of features in one kernel release, and a slightly different
92 : : * set of features in a later kernel release. LSMs that seek to expose
93 : : * lockdown policy at any level of granularity other than "none",
94 : : * "integrity" or "confidentiality" are responsible for either
95 : : * ensuring that they expose a consistent level of functionality to
96 : : * userland, or ensuring that userland is aware that this is
97 : : * potentially a moving target. It is easy to misuse this information
98 : : * in a way that could break userspace. Please be careful not to do
99 : : * so.
100 : : *
101 : : * If you add to this, remember to extend lockdown_reasons in
102 : : * security/lockdown/lockdown.c.
103 : : */
104 : : enum lockdown_reason {
105 : : LOCKDOWN_NONE,
106 : : LOCKDOWN_MODULE_SIGNATURE,
107 : : LOCKDOWN_DEV_MEM,
108 : : LOCKDOWN_EFI_TEST,
109 : : LOCKDOWN_KEXEC,
110 : : LOCKDOWN_HIBERNATION,
111 : : LOCKDOWN_PCI_ACCESS,
112 : : LOCKDOWN_IOPORT,
113 : : LOCKDOWN_MSR,
114 : : LOCKDOWN_ACPI_TABLES,
115 : : LOCKDOWN_PCMCIA_CIS,
116 : : LOCKDOWN_TIOCSSERIAL,
117 : : LOCKDOWN_MODULE_PARAMETERS,
118 : : LOCKDOWN_MMIOTRACE,
119 : : LOCKDOWN_DEBUGFS,
120 : : LOCKDOWN_XMON_WR,
121 : : LOCKDOWN_INTEGRITY_MAX,
122 : : LOCKDOWN_KCORE,
123 : : LOCKDOWN_KPROBES,
124 : : LOCKDOWN_BPF_READ,
125 : : LOCKDOWN_PERF,
126 : : LOCKDOWN_TRACEFS,
127 : : LOCKDOWN_XMON_RW,
128 : : LOCKDOWN_CONFIDENTIALITY_MAX,
129 : : };
130 : :
131 : : extern const char *const lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1];
132 : :
133 : : /* These functions are in security/commoncap.c */
134 : : extern int cap_capable(const struct cred *cred, struct user_namespace *ns,
135 : : int cap, unsigned int opts);
136 : : extern int cap_settime(const struct timespec64 *ts, const struct timezone *tz);
137 : : extern int cap_ptrace_access_check(struct task_struct *child, unsigned int mode);
138 : : extern int cap_ptrace_traceme(struct task_struct *parent);
139 : : extern int cap_capget(struct task_struct *target, kernel_cap_t *effective, kernel_cap_t *inheritable, kernel_cap_t *permitted);
140 : : extern int cap_capset(struct cred *new, const struct cred *old,
141 : : const kernel_cap_t *effective,
142 : : const kernel_cap_t *inheritable,
143 : : const kernel_cap_t *permitted);
144 : : extern int cap_bprm_set_creds(struct linux_binprm *bprm);
145 : : extern int cap_inode_setxattr(struct dentry *dentry, const char *name,
146 : : const void *value, size_t size, int flags);
147 : : extern int cap_inode_removexattr(struct dentry *dentry, const char *name);
148 : : extern int cap_inode_need_killpriv(struct dentry *dentry);
149 : : extern int cap_inode_killpriv(struct dentry *dentry);
150 : : extern int cap_inode_getsecurity(struct inode *inode, const char *name,
151 : : void **buffer, bool alloc);
152 : : extern int cap_mmap_addr(unsigned long addr);
153 : : extern int cap_mmap_file(struct file *file, unsigned long reqprot,
154 : : unsigned long prot, unsigned long flags);
155 : : extern int cap_task_fix_setuid(struct cred *new, const struct cred *old, int flags);
156 : : extern int cap_task_prctl(int option, unsigned long arg2, unsigned long arg3,
157 : : unsigned long arg4, unsigned long arg5);
158 : : extern int cap_task_setscheduler(struct task_struct *p);
159 : : extern int cap_task_setioprio(struct task_struct *p, int ioprio);
160 : : extern int cap_task_setnice(struct task_struct *p, int nice);
161 : : extern int cap_vm_enough_memory(struct mm_struct *mm, long pages);
162 : :
163 : : struct msghdr;
164 : : struct sk_buff;
165 : : struct sock;
166 : : struct sockaddr;
167 : : struct socket;
168 : : struct flowi;
169 : : struct dst_entry;
170 : : struct xfrm_selector;
171 : : struct xfrm_policy;
172 : : struct xfrm_state;
173 : : struct xfrm_user_sec_ctx;
174 : : struct seq_file;
175 : : struct sctp_endpoint;
176 : :
177 : : #ifdef CONFIG_MMU
178 : : extern unsigned long mmap_min_addr;
179 : : extern unsigned long dac_mmap_min_addr;
180 : : #else
181 : : #define mmap_min_addr 0UL
182 : : #define dac_mmap_min_addr 0UL
183 : : #endif
184 : :
185 : : /*
186 : : * Values used in the task_security_ops calls
187 : : */
188 : : /* setuid or setgid, id0 == uid or gid */
189 : : #define LSM_SETID_ID 1
190 : :
191 : : /* setreuid or setregid, id0 == real, id1 == eff */
192 : : #define LSM_SETID_RE 2
193 : :
194 : : /* setresuid or setresgid, id0 == real, id1 == eff, uid2 == saved */
195 : : #define LSM_SETID_RES 4
196 : :
197 : : /* setfsuid or setfsgid, id0 == fsuid or fsgid */
198 : : #define LSM_SETID_FS 8
199 : :
200 : : /* Flags for security_task_prlimit(). */
201 : : #define LSM_PRLIMIT_READ 1
202 : : #define LSM_PRLIMIT_WRITE 2
203 : :
204 : : /* forward declares to avoid warnings */
205 : : struct sched_param;
206 : : struct request_sock;
207 : :
208 : : /* bprm->unsafe reasons */
209 : : #define LSM_UNSAFE_SHARE 1
210 : : #define LSM_UNSAFE_PTRACE 2
211 : : #define LSM_UNSAFE_NO_NEW_PRIVS 4
212 : :
213 : : #ifdef CONFIG_MMU
214 : : extern int mmap_min_addr_handler(struct ctl_table *table, int write,
215 : : void __user *buffer, size_t *lenp, loff_t *ppos);
216 : : #endif
217 : :
218 : : /* security_inode_init_security callback function to write xattrs */
219 : : typedef int (*initxattrs) (struct inode *inode,
220 : : const struct xattr *xattr_array, void *fs_data);
221 : :
222 : :
223 : : /* Keep the kernel_load_data_id enum in sync with kernel_read_file_id */
224 : : #define __data_id_enumify(ENUM, dummy) LOADING_ ## ENUM,
225 : : #define __data_id_stringify(dummy, str) #str,
226 : :
227 : : enum kernel_load_data_id {
228 : : __kernel_read_file_id(__data_id_enumify)
229 : : };
230 : :
231 : : static const char * const kernel_load_data_str[] = {
232 : : __kernel_read_file_id(__data_id_stringify)
233 : : };
234 : :
235 : : static inline const char *kernel_load_data_id_str(enum kernel_load_data_id id)
236 : : {
237 : : if ((unsigned)id >= LOADING_MAX_ID)
238 : : return kernel_load_data_str[LOADING_UNKNOWN];
239 : :
240 : : return kernel_load_data_str[id];
241 : : }
242 : :
243 : : #ifdef CONFIG_SECURITY
244 : :
245 : : int call_blocking_lsm_notifier(enum lsm_event event, void *data);
246 : : int register_blocking_lsm_notifier(struct notifier_block *nb);
247 : : int unregister_blocking_lsm_notifier(struct notifier_block *nb);
248 : :
249 : : /* prototypes */
250 : : extern int security_init(void);
251 : : extern int early_security_init(void);
252 : :
253 : : /* Security operations */
254 : : int security_binder_set_context_mgr(struct task_struct *mgr);
255 : : int security_binder_transaction(struct task_struct *from,
256 : : struct task_struct *to);
257 : : int security_binder_transfer_binder(struct task_struct *from,
258 : : struct task_struct *to);
259 : : int security_binder_transfer_file(struct task_struct *from,
260 : : struct task_struct *to, struct file *file);
261 : : int security_ptrace_access_check(struct task_struct *child, unsigned int mode);
262 : : int security_ptrace_traceme(struct task_struct *parent);
263 : : int security_capget(struct task_struct *target,
264 : : kernel_cap_t *effective,
265 : : kernel_cap_t *inheritable,
266 : : kernel_cap_t *permitted);
267 : : int security_capset(struct cred *new, const struct cred *old,
268 : : const kernel_cap_t *effective,
269 : : const kernel_cap_t *inheritable,
270 : : const kernel_cap_t *permitted);
271 : : int security_capable(const struct cred *cred,
272 : : struct user_namespace *ns,
273 : : int cap,
274 : : unsigned int opts);
275 : : int security_quotactl(int cmds, int type, int id, struct super_block *sb);
276 : : int security_quota_on(struct dentry *dentry);
277 : : int security_syslog(int type);
278 : : int security_settime64(const struct timespec64 *ts, const struct timezone *tz);
279 : : int security_vm_enough_memory_mm(struct mm_struct *mm, long pages);
280 : : int security_bprm_set_creds(struct linux_binprm *bprm);
281 : : int security_bprm_check(struct linux_binprm *bprm);
282 : : void security_bprm_committing_creds(struct linux_binprm *bprm);
283 : : void security_bprm_committed_creds(struct linux_binprm *bprm);
284 : : int security_fs_context_dup(struct fs_context *fc, struct fs_context *src_fc);
285 : : int security_fs_context_parse_param(struct fs_context *fc, struct fs_parameter *param);
286 : : int security_sb_alloc(struct super_block *sb);
287 : : void security_sb_free(struct super_block *sb);
288 : : void security_free_mnt_opts(void **mnt_opts);
289 : : int security_sb_eat_lsm_opts(char *options, void **mnt_opts);
290 : : int security_sb_remount(struct super_block *sb, void *mnt_opts);
291 : : int security_sb_kern_mount(struct super_block *sb);
292 : : int security_sb_show_options(struct seq_file *m, struct super_block *sb);
293 : : int security_sb_statfs(struct dentry *dentry);
294 : : int security_sb_mount(const char *dev_name, const struct path *path,
295 : : const char *type, unsigned long flags, void *data);
296 : : int security_sb_umount(struct vfsmount *mnt, int flags);
297 : : int security_sb_pivotroot(const struct path *old_path, const struct path *new_path);
298 : : int security_sb_set_mnt_opts(struct super_block *sb,
299 : : void *mnt_opts,
300 : : unsigned long kern_flags,
301 : : unsigned long *set_kern_flags);
302 : : int security_sb_clone_mnt_opts(const struct super_block *oldsb,
303 : : struct super_block *newsb,
304 : : unsigned long kern_flags,
305 : : unsigned long *set_kern_flags);
306 : : int security_add_mnt_opt(const char *option, const char *val,
307 : : int len, void **mnt_opts);
308 : : int security_move_mount(const struct path *from_path, const struct path *to_path);
309 : : int security_dentry_init_security(struct dentry *dentry, int mode,
310 : : const struct qstr *name, void **ctx,
311 : : u32 *ctxlen);
312 : : int security_dentry_create_files_as(struct dentry *dentry, int mode,
313 : : struct qstr *name,
314 : : const struct cred *old,
315 : : struct cred *new);
316 : : int security_path_notify(const struct path *path, u64 mask,
317 : : unsigned int obj_type);
318 : : int security_inode_alloc(struct inode *inode);
319 : : void security_inode_free(struct inode *inode);
320 : : int security_inode_init_security(struct inode *inode, struct inode *dir,
321 : : const struct qstr *qstr,
322 : : initxattrs initxattrs, void *fs_data);
323 : : int security_old_inode_init_security(struct inode *inode, struct inode *dir,
324 : : const struct qstr *qstr, const char **name,
325 : : void **value, size_t *len);
326 : : int security_inode_create(struct inode *dir, struct dentry *dentry, umode_t mode);
327 : : int security_inode_link(struct dentry *old_dentry, struct inode *dir,
328 : : struct dentry *new_dentry);
329 : : int security_inode_unlink(struct inode *dir, struct dentry *dentry);
330 : : int security_inode_symlink(struct inode *dir, struct dentry *dentry,
331 : : const char *old_name);
332 : : int security_inode_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode);
333 : : int security_inode_rmdir(struct inode *dir, struct dentry *dentry);
334 : : int security_inode_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev);
335 : : int security_inode_rename(struct inode *old_dir, struct dentry *old_dentry,
336 : : struct inode *new_dir, struct dentry *new_dentry,
337 : : unsigned int flags);
338 : : int security_inode_readlink(struct dentry *dentry);
339 : : int security_inode_follow_link(struct dentry *dentry, struct inode *inode,
340 : : bool rcu);
341 : : int security_inode_permission(struct inode *inode, int mask);
342 : : int security_inode_setattr(struct dentry *dentry, struct iattr *attr);
343 : : int security_inode_getattr(const struct path *path);
344 : : int security_inode_setxattr(struct dentry *dentry, const char *name,
345 : : const void *value, size_t size, int flags);
346 : : void security_inode_post_setxattr(struct dentry *dentry, const char *name,
347 : : const void *value, size_t size, int flags);
348 : : int security_inode_getxattr(struct dentry *dentry, const char *name);
349 : : int security_inode_listxattr(struct dentry *dentry);
350 : : int security_inode_removexattr(struct dentry *dentry, const char *name);
351 : : int security_inode_need_killpriv(struct dentry *dentry);
352 : : int security_inode_killpriv(struct dentry *dentry);
353 : : int security_inode_getsecurity(struct inode *inode, const char *name, void **buffer, bool alloc);
354 : : int security_inode_setsecurity(struct inode *inode, const char *name, const void *value, size_t size, int flags);
355 : : int security_inode_listsecurity(struct inode *inode, char *buffer, size_t buffer_size);
356 : : void security_inode_getsecid(struct inode *inode, u32 *secid);
357 : : int security_inode_copy_up(struct dentry *src, struct cred **new);
358 : : int security_inode_copy_up_xattr(const char *name);
359 : : int security_kernfs_init_security(struct kernfs_node *kn_dir,
360 : : struct kernfs_node *kn);
361 : : int security_file_permission(struct file *file, int mask);
362 : : int security_file_alloc(struct file *file);
363 : : void security_file_free(struct file *file);
364 : : int security_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
365 : : int security_mmap_file(struct file *file, unsigned long prot,
366 : : unsigned long flags);
367 : : int security_mmap_addr(unsigned long addr);
368 : : int security_file_mprotect(struct vm_area_struct *vma, unsigned long reqprot,
369 : : unsigned long prot);
370 : : int security_file_lock(struct file *file, unsigned int cmd);
371 : : int security_file_fcntl(struct file *file, unsigned int cmd, unsigned long arg);
372 : : void security_file_set_fowner(struct file *file);
373 : : int security_file_send_sigiotask(struct task_struct *tsk,
374 : : struct fown_struct *fown, int sig);
375 : : int security_file_receive(struct file *file);
376 : : int security_file_open(struct file *file);
377 : : int security_task_alloc(struct task_struct *task, unsigned long clone_flags);
378 : : void security_task_free(struct task_struct *task);
379 : : int security_cred_alloc_blank(struct cred *cred, gfp_t gfp);
380 : : void security_cred_free(struct cred *cred);
381 : : int security_prepare_creds(struct cred *new, const struct cred *old, gfp_t gfp);
382 : : void security_transfer_creds(struct cred *new, const struct cred *old);
383 : : void security_cred_getsecid(const struct cred *c, u32 *secid);
384 : : int security_kernel_act_as(struct cred *new, u32 secid);
385 : : int security_kernel_create_files_as(struct cred *new, struct inode *inode);
386 : : int security_kernel_module_request(char *kmod_name);
387 : : int security_kernel_load_data(enum kernel_load_data_id id);
388 : : int security_kernel_read_file(struct file *file, enum kernel_read_file_id id);
389 : : int security_kernel_post_read_file(struct file *file, char *buf, loff_t size,
390 : : enum kernel_read_file_id id);
391 : : int security_task_fix_setuid(struct cred *new, const struct cred *old,
392 : : int flags);
393 : : int security_task_setpgid(struct task_struct *p, pid_t pgid);
394 : : int security_task_getpgid(struct task_struct *p);
395 : : int security_task_getsid(struct task_struct *p);
396 : : void security_task_getsecid(struct task_struct *p, u32 *secid);
397 : : int security_task_setnice(struct task_struct *p, int nice);
398 : : int security_task_setioprio(struct task_struct *p, int ioprio);
399 : : int security_task_getioprio(struct task_struct *p);
400 : : int security_task_prlimit(const struct cred *cred, const struct cred *tcred,
401 : : unsigned int flags);
402 : : int security_task_setrlimit(struct task_struct *p, unsigned int resource,
403 : : struct rlimit *new_rlim);
404 : : int security_task_setscheduler(struct task_struct *p);
405 : : int security_task_getscheduler(struct task_struct *p);
406 : : int security_task_movememory(struct task_struct *p);
407 : : int security_task_kill(struct task_struct *p, struct kernel_siginfo *info,
408 : : int sig, const struct cred *cred);
409 : : int security_task_prctl(int option, unsigned long arg2, unsigned long arg3,
410 : : unsigned long arg4, unsigned long arg5);
411 : : void security_task_to_inode(struct task_struct *p, struct inode *inode);
412 : : int security_ipc_permission(struct kern_ipc_perm *ipcp, short flag);
413 : : void security_ipc_getsecid(struct kern_ipc_perm *ipcp, u32 *secid);
414 : : int security_msg_msg_alloc(struct msg_msg *msg);
415 : : void security_msg_msg_free(struct msg_msg *msg);
416 : : int security_msg_queue_alloc(struct kern_ipc_perm *msq);
417 : : void security_msg_queue_free(struct kern_ipc_perm *msq);
418 : : int security_msg_queue_associate(struct kern_ipc_perm *msq, int msqflg);
419 : : int security_msg_queue_msgctl(struct kern_ipc_perm *msq, int cmd);
420 : : int security_msg_queue_msgsnd(struct kern_ipc_perm *msq,
421 : : struct msg_msg *msg, int msqflg);
422 : : int security_msg_queue_msgrcv(struct kern_ipc_perm *msq, struct msg_msg *msg,
423 : : struct task_struct *target, long type, int mode);
424 : : int security_shm_alloc(struct kern_ipc_perm *shp);
425 : : void security_shm_free(struct kern_ipc_perm *shp);
426 : : int security_shm_associate(struct kern_ipc_perm *shp, int shmflg);
427 : : int security_shm_shmctl(struct kern_ipc_perm *shp, int cmd);
428 : : int security_shm_shmat(struct kern_ipc_perm *shp, char __user *shmaddr, int shmflg);
429 : : int security_sem_alloc(struct kern_ipc_perm *sma);
430 : : void security_sem_free(struct kern_ipc_perm *sma);
431 : : int security_sem_associate(struct kern_ipc_perm *sma, int semflg);
432 : : int security_sem_semctl(struct kern_ipc_perm *sma, int cmd);
433 : : int security_sem_semop(struct kern_ipc_perm *sma, struct sembuf *sops,
434 : : unsigned nsops, int alter);
435 : : void security_d_instantiate(struct dentry *dentry, struct inode *inode);
436 : : int security_getprocattr(struct task_struct *p, const char *lsm, char *name,
437 : : char **value);
438 : : int security_setprocattr(const char *lsm, const char *name, void *value,
439 : : size_t size);
440 : : int security_netlink_send(struct sock *sk, struct sk_buff *skb);
441 : : int security_ismaclabel(const char *name);
442 : : int security_secid_to_secctx(u32 secid, char **secdata, u32 *seclen);
443 : : int security_secctx_to_secid(const char *secdata, u32 seclen, u32 *secid);
444 : : void security_release_secctx(char *secdata, u32 seclen);
445 : : void security_inode_invalidate_secctx(struct inode *inode);
446 : : int security_inode_notifysecctx(struct inode *inode, void *ctx, u32 ctxlen);
447 : : int security_inode_setsecctx(struct dentry *dentry, void *ctx, u32 ctxlen);
448 : : int security_inode_getsecctx(struct inode *inode, void **ctx, u32 *ctxlen);
449 : : int security_locked_down(enum lockdown_reason what);
450 : : #else /* CONFIG_SECURITY */
451 : :
452 : : static inline int call_blocking_lsm_notifier(enum lsm_event event, void *data)
453 : : {
454 : : return 0;
455 : : }
456 : :
457 : : static inline int register_blocking_lsm_notifier(struct notifier_block *nb)
458 : : {
459 : : return 0;
460 : : }
461 : :
462 : : static inline int unregister_blocking_lsm_notifier(struct notifier_block *nb)
463 : : {
464 : : return 0;
465 : : }
466 : :
467 : : static inline void security_free_mnt_opts(void **mnt_opts)
468 : : {
469 : : }
470 : :
471 : : /*
472 : : * This is the default capabilities functionality. Most of these functions
473 : : * are just stubbed out, but a few must call the proper capable code.
474 : : */
475 : :
476 : : static inline int security_init(void)
477 : : {
478 : : return 0;
479 : : }
480 : :
481 : : static inline int early_security_init(void)
482 : : {
483 : : return 0;
484 : : }
485 : :
486 : : static inline int security_binder_set_context_mgr(struct task_struct *mgr)
487 : : {
488 : : return 0;
489 : : }
490 : :
491 : : static inline int security_binder_transaction(struct task_struct *from,
492 : : struct task_struct *to)
493 : : {
494 : : return 0;
495 : : }
496 : :
497 : : static inline int security_binder_transfer_binder(struct task_struct *from,
498 : : struct task_struct *to)
499 : : {
500 : : return 0;
501 : : }
502 : :
503 : : static inline int security_binder_transfer_file(struct task_struct *from,
504 : : struct task_struct *to,
505 : : struct file *file)
506 : : {
507 : : return 0;
508 : : }
509 : :
510 : : static inline int security_ptrace_access_check(struct task_struct *child,
511 : : unsigned int mode)
512 : : {
513 : : return cap_ptrace_access_check(child, mode);
514 : : }
515 : :
516 : : static inline int security_ptrace_traceme(struct task_struct *parent)
517 : : {
518 : : return cap_ptrace_traceme(parent);
519 : : }
520 : :
521 : : static inline int security_capget(struct task_struct *target,
522 : : kernel_cap_t *effective,
523 : : kernel_cap_t *inheritable,
524 : : kernel_cap_t *permitted)
525 : : {
526 : : return cap_capget(target, effective, inheritable, permitted);
527 : : }
528 : :
529 : : static inline int security_capset(struct cred *new,
530 : : const struct cred *old,
531 : : const kernel_cap_t *effective,
532 : : const kernel_cap_t *inheritable,
533 : : const kernel_cap_t *permitted)
534 : : {
535 : : return cap_capset(new, old, effective, inheritable, permitted);
536 : : }
537 : :
538 : : static inline int security_capable(const struct cred *cred,
539 : : struct user_namespace *ns,
540 : : int cap,
541 : : unsigned int opts)
542 : : {
543 : : return cap_capable(cred, ns, cap, opts);
544 : : }
545 : :
546 : : static inline int security_quotactl(int cmds, int type, int id,
547 : : struct super_block *sb)
548 : : {
549 : : return 0;
550 : : }
551 : :
552 : : static inline int security_quota_on(struct dentry *dentry)
553 : : {
554 : : return 0;
555 : : }
556 : :
557 : : static inline int security_syslog(int type)
558 : : {
559 : : return 0;
560 : : }
561 : :
562 : : static inline int security_settime64(const struct timespec64 *ts,
563 : : const struct timezone *tz)
564 : : {
565 : : return cap_settime(ts, tz);
566 : : }
567 : :
568 : : static inline int security_vm_enough_memory_mm(struct mm_struct *mm, long pages)
569 : : {
570 : : return __vm_enough_memory(mm, pages, cap_vm_enough_memory(mm, pages));
571 : : }
572 : :
573 : : static inline int security_bprm_set_creds(struct linux_binprm *bprm)
574 : : {
575 : : return cap_bprm_set_creds(bprm);
576 : : }
577 : :
578 : : static inline int security_bprm_check(struct linux_binprm *bprm)
579 : : {
580 : : return 0;
581 : : }
582 : :
583 : : static inline void security_bprm_committing_creds(struct linux_binprm *bprm)
584 : : {
585 : : }
586 : :
587 : : static inline void security_bprm_committed_creds(struct linux_binprm *bprm)
588 : : {
589 : : }
590 : :
591 : : static inline int security_fs_context_dup(struct fs_context *fc,
592 : : struct fs_context *src_fc)
593 : : {
594 : : return 0;
595 : : }
596 : : static inline int security_fs_context_parse_param(struct fs_context *fc,
597 : : struct fs_parameter *param)
598 : : {
599 : : return -ENOPARAM;
600 : : }
601 : :
602 : : static inline int security_sb_alloc(struct super_block *sb)
603 : : {
604 : : return 0;
605 : : }
606 : :
607 : : static inline void security_sb_free(struct super_block *sb)
608 : : { }
609 : :
610 : : static inline int security_sb_eat_lsm_opts(char *options,
611 : : void **mnt_opts)
612 : : {
613 : : return 0;
614 : : }
615 : :
616 : : static inline int security_sb_remount(struct super_block *sb,
617 : : void *mnt_opts)
618 : : {
619 : : return 0;
620 : : }
621 : :
622 : : static inline int security_sb_kern_mount(struct super_block *sb)
623 : : {
624 : : return 0;
625 : : }
626 : :
627 : : static inline int security_sb_show_options(struct seq_file *m,
628 : : struct super_block *sb)
629 : : {
630 : : return 0;
631 : : }
632 : :
633 : : static inline int security_sb_statfs(struct dentry *dentry)
634 : : {
635 : : return 0;
636 : : }
637 : :
638 : : static inline int security_sb_mount(const char *dev_name, const struct path *path,
639 : : const char *type, unsigned long flags,
640 : : void *data)
641 : : {
642 : : return 0;
643 : : }
644 : :
645 : : static inline int security_sb_umount(struct vfsmount *mnt, int flags)
646 : : {
647 : : return 0;
648 : : }
649 : :
650 : : static inline int security_sb_pivotroot(const struct path *old_path,
651 : : const struct path *new_path)
652 : : {
653 : : return 0;
654 : : }
655 : :
656 : : static inline int security_sb_set_mnt_opts(struct super_block *sb,
657 : : void *mnt_opts,
658 : : unsigned long kern_flags,
659 : : unsigned long *set_kern_flags)
660 : : {
661 : : return 0;
662 : : }
663 : :
664 : : static inline int security_sb_clone_mnt_opts(const struct super_block *oldsb,
665 : : struct super_block *newsb,
666 : : unsigned long kern_flags,
667 : : unsigned long *set_kern_flags)
668 : : {
669 : : return 0;
670 : : }
671 : :
672 : : static inline int security_add_mnt_opt(const char *option, const char *val,
673 : : int len, void **mnt_opts)
674 : : {
675 : : return 0;
676 : : }
677 : :
678 : : static inline int security_move_mount(const struct path *from_path,
679 : : const struct path *to_path)
680 : : {
681 : : return 0;
682 : : }
683 : :
684 : : static inline int security_path_notify(const struct path *path, u64 mask,
685 : : unsigned int obj_type)
686 : : {
687 : : return 0;
688 : : }
689 : :
690 : : static inline int security_inode_alloc(struct inode *inode)
691 : : {
692 : : return 0;
693 : : }
694 : :
695 : : static inline void security_inode_free(struct inode *inode)
696 : : { }
697 : :
698 : : static inline int security_dentry_init_security(struct dentry *dentry,
699 : : int mode,
700 : : const struct qstr *name,
701 : : void **ctx,
702 : : u32 *ctxlen)
703 : : {
704 : : return -EOPNOTSUPP;
705 : : }
706 : :
707 : : static inline int security_dentry_create_files_as(struct dentry *dentry,
708 : : int mode, struct qstr *name,
709 : : const struct cred *old,
710 : : struct cred *new)
711 : : {
712 : : return 0;
713 : : }
714 : :
715 : :
716 : : static inline int security_inode_init_security(struct inode *inode,
717 : : struct inode *dir,
718 : : const struct qstr *qstr,
719 : : const initxattrs xattrs,
720 : : void *fs_data)
721 : : {
722 : : return 0;
723 : : }
724 : :
725 : : static inline int security_old_inode_init_security(struct inode *inode,
726 : : struct inode *dir,
727 : : const struct qstr *qstr,
728 : : const char **name,
729 : : void **value, size_t *len)
730 : : {
731 : : return -EOPNOTSUPP;
732 : : }
733 : :
734 : : static inline int security_inode_create(struct inode *dir,
735 : : struct dentry *dentry,
736 : : umode_t mode)
737 : : {
738 : : return 0;
739 : : }
740 : :
741 : : static inline int security_inode_link(struct dentry *old_dentry,
742 : : struct inode *dir,
743 : : struct dentry *new_dentry)
744 : : {
745 : : return 0;
746 : : }
747 : :
748 : : static inline int security_inode_unlink(struct inode *dir,
749 : : struct dentry *dentry)
750 : : {
751 : : return 0;
752 : : }
753 : :
754 : : static inline int security_inode_symlink(struct inode *dir,
755 : : struct dentry *dentry,
756 : : const char *old_name)
757 : : {
758 : : return 0;
759 : : }
760 : :
761 : : static inline int security_inode_mkdir(struct inode *dir,
762 : : struct dentry *dentry,
763 : : int mode)
764 : : {
765 : : return 0;
766 : : }
767 : :
768 : : static inline int security_inode_rmdir(struct inode *dir,
769 : : struct dentry *dentry)
770 : : {
771 : : return 0;
772 : : }
773 : :
774 : : static inline int security_inode_mknod(struct inode *dir,
775 : : struct dentry *dentry,
776 : : int mode, dev_t dev)
777 : : {
778 : : return 0;
779 : : }
780 : :
781 : : static inline int security_inode_rename(struct inode *old_dir,
782 : : struct dentry *old_dentry,
783 : : struct inode *new_dir,
784 : : struct dentry *new_dentry,
785 : : unsigned int flags)
786 : : {
787 : : return 0;
788 : : }
789 : :
790 : : static inline int security_inode_readlink(struct dentry *dentry)
791 : : {
792 : : return 0;
793 : : }
794 : :
795 : : static inline int security_inode_follow_link(struct dentry *dentry,
796 : : struct inode *inode,
797 : : bool rcu)
798 : : {
799 : : return 0;
800 : : }
801 : :
802 : : static inline int security_inode_permission(struct inode *inode, int mask)
803 : : {
804 : : return 0;
805 : : }
806 : :
807 : : static inline int security_inode_setattr(struct dentry *dentry,
808 : : struct iattr *attr)
809 : : {
810 : : return 0;
811 : : }
812 : :
813 : : static inline int security_inode_getattr(const struct path *path)
814 : : {
815 : : return 0;
816 : : }
817 : :
818 : : static inline int security_inode_setxattr(struct dentry *dentry,
819 : : const char *name, const void *value, size_t size, int flags)
820 : : {
821 : : return cap_inode_setxattr(dentry, name, value, size, flags);
822 : : }
823 : :
824 : : static inline void security_inode_post_setxattr(struct dentry *dentry,
825 : : const char *name, const void *value, size_t size, int flags)
826 : : { }
827 : :
828 : : static inline int security_inode_getxattr(struct dentry *dentry,
829 : : const char *name)
830 : : {
831 : : return 0;
832 : : }
833 : :
834 : : static inline int security_inode_listxattr(struct dentry *dentry)
835 : : {
836 : : return 0;
837 : : }
838 : :
839 : : static inline int security_inode_removexattr(struct dentry *dentry,
840 : : const char *name)
841 : : {
842 : : return cap_inode_removexattr(dentry, name);
843 : : }
844 : :
845 : : static inline int security_inode_need_killpriv(struct dentry *dentry)
846 : : {
847 : : return cap_inode_need_killpriv(dentry);
848 : : }
849 : :
850 : : static inline int security_inode_killpriv(struct dentry *dentry)
851 : : {
852 : : return cap_inode_killpriv(dentry);
853 : : }
854 : :
855 : : static inline int security_inode_getsecurity(struct inode *inode, const char *name, void **buffer, bool alloc)
856 : : {
857 : : return -EOPNOTSUPP;
858 : : }
859 : :
860 : : static inline int security_inode_setsecurity(struct inode *inode, const char *name, const void *value, size_t size, int flags)
861 : : {
862 : : return -EOPNOTSUPP;
863 : : }
864 : :
865 : : static inline int security_inode_listsecurity(struct inode *inode, char *buffer, size_t buffer_size)
866 : : {
867 : : return 0;
868 : : }
869 : :
870 : : static inline void security_inode_getsecid(struct inode *inode, u32 *secid)
871 : : {
872 : : *secid = 0;
873 : : }
874 : :
875 : : static inline int security_inode_copy_up(struct dentry *src, struct cred **new)
876 : : {
877 : : return 0;
878 : : }
879 : :
880 : : static inline int security_kernfs_init_security(struct kernfs_node *kn_dir,
881 : : struct kernfs_node *kn)
882 : : {
883 : : return 0;
884 : : }
885 : :
886 : : static inline int security_inode_copy_up_xattr(const char *name)
887 : : {
888 : : return -EOPNOTSUPP;
889 : : }
890 : :
891 : : static inline int security_file_permission(struct file *file, int mask)
892 : : {
893 : : return 0;
894 : : }
895 : :
896 : : static inline int security_file_alloc(struct file *file)
897 : : {
898 : : return 0;
899 : : }
900 : :
901 : : static inline void security_file_free(struct file *file)
902 : : { }
903 : :
904 : : static inline int security_file_ioctl(struct file *file, unsigned int cmd,
905 : : unsigned long arg)
906 : : {
907 : : return 0;
908 : : }
909 : :
910 : : static inline int security_mmap_file(struct file *file, unsigned long prot,
911 : : unsigned long flags)
912 : : {
913 : : return 0;
914 : : }
915 : :
916 : : static inline int security_mmap_addr(unsigned long addr)
917 : : {
918 : : return cap_mmap_addr(addr);
919 : : }
920 : :
921 : : static inline int security_file_mprotect(struct vm_area_struct *vma,
922 : : unsigned long reqprot,
923 : : unsigned long prot)
924 : : {
925 : : return 0;
926 : : }
927 : :
928 : : static inline int security_file_lock(struct file *file, unsigned int cmd)
929 : : {
930 : : return 0;
931 : : }
932 : :
933 : : static inline int security_file_fcntl(struct file *file, unsigned int cmd,
934 : : unsigned long arg)
935 : : {
936 : : return 0;
937 : : }
938 : :
939 : : static inline void security_file_set_fowner(struct file *file)
940 : : {
941 : : return;
942 : : }
943 : :
944 : : static inline int security_file_send_sigiotask(struct task_struct *tsk,
945 : : struct fown_struct *fown,
946 : : int sig)
947 : : {
948 : : return 0;
949 : : }
950 : :
951 : : static inline int security_file_receive(struct file *file)
952 : : {
953 : : return 0;
954 : : }
955 : :
956 : : static inline int security_file_open(struct file *file)
957 : : {
958 : : return 0;
959 : : }
960 : :
961 : : static inline int security_task_alloc(struct task_struct *task,
962 : : unsigned long clone_flags)
963 : : {
964 : : return 0;
965 : : }
966 : :
967 : : static inline void security_task_free(struct task_struct *task)
968 : : { }
969 : :
970 : : static inline int security_cred_alloc_blank(struct cred *cred, gfp_t gfp)
971 : : {
972 : : return 0;
973 : : }
974 : :
975 : : static inline void security_cred_free(struct cred *cred)
976 : : { }
977 : :
978 : : static inline int security_prepare_creds(struct cred *new,
979 : : const struct cred *old,
980 : : gfp_t gfp)
981 : : {
982 : : return 0;
983 : : }
984 : :
985 : : static inline void security_transfer_creds(struct cred *new,
986 : : const struct cred *old)
987 : : {
988 : : }
989 : :
990 : : static inline int security_kernel_act_as(struct cred *cred, u32 secid)
991 : : {
992 : : return 0;
993 : : }
994 : :
995 : : static inline int security_kernel_create_files_as(struct cred *cred,
996 : : struct inode *inode)
997 : : {
998 : : return 0;
999 : : }
1000 : :
1001 : : static inline int security_kernel_module_request(char *kmod_name)
1002 : : {
1003 : : return 0;
1004 : : }
1005 : :
1006 : : static inline int security_kernel_load_data(enum kernel_load_data_id id)
1007 : : {
1008 : : return 0;
1009 : : }
1010 : :
1011 : : static inline int security_kernel_read_file(struct file *file,
1012 : : enum kernel_read_file_id id)
1013 : : {
1014 : : return 0;
1015 : : }
1016 : :
1017 : : static inline int security_kernel_post_read_file(struct file *file,
1018 : : char *buf, loff_t size,
1019 : : enum kernel_read_file_id id)
1020 : : {
1021 : : return 0;
1022 : : }
1023 : :
1024 : : static inline int security_task_fix_setuid(struct cred *new,
1025 : : const struct cred *old,
1026 : : int flags)
1027 : : {
1028 : : return cap_task_fix_setuid(new, old, flags);
1029 : : }
1030 : :
1031 : : static inline int security_task_setpgid(struct task_struct *p, pid_t pgid)
1032 : : {
1033 : : return 0;
1034 : : }
1035 : :
1036 : : static inline int security_task_getpgid(struct task_struct *p)
1037 : : {
1038 : : return 0;
1039 : : }
1040 : :
1041 : : static inline int security_task_getsid(struct task_struct *p)
1042 : : {
1043 : : return 0;
1044 : : }
1045 : :
1046 : : static inline void security_task_getsecid(struct task_struct *p, u32 *secid)
1047 : : {
1048 : : *secid = 0;
1049 : : }
1050 : :
1051 : : static inline int security_task_setnice(struct task_struct *p, int nice)
1052 : : {
1053 : : return cap_task_setnice(p, nice);
1054 : : }
1055 : :
1056 : : static inline int security_task_setioprio(struct task_struct *p, int ioprio)
1057 : : {
1058 : : return cap_task_setioprio(p, ioprio);
1059 : : }
1060 : :
1061 : : static inline int security_task_getioprio(struct task_struct *p)
1062 : : {
1063 : : return 0;
1064 : : }
1065 : :
1066 : : static inline int security_task_prlimit(const struct cred *cred,
1067 : : const struct cred *tcred,
1068 : : unsigned int flags)
1069 : : {
1070 : : return 0;
1071 : : }
1072 : :
1073 : : static inline int security_task_setrlimit(struct task_struct *p,
1074 : : unsigned int resource,
1075 : : struct rlimit *new_rlim)
1076 : : {
1077 : : return 0;
1078 : : }
1079 : :
1080 : : static inline int security_task_setscheduler(struct task_struct *p)
1081 : : {
1082 : : return cap_task_setscheduler(p);
1083 : : }
1084 : :
1085 : : static inline int security_task_getscheduler(struct task_struct *p)
1086 : : {
1087 : : return 0;
1088 : : }
1089 : :
1090 : : static inline int security_task_movememory(struct task_struct *p)
1091 : : {
1092 : : return 0;
1093 : : }
1094 : :
1095 : : static inline int security_task_kill(struct task_struct *p,
1096 : : struct kernel_siginfo *info, int sig,
1097 : : const struct cred *cred)
1098 : : {
1099 : : return 0;
1100 : : }
1101 : :
1102 : : static inline int security_task_prctl(int option, unsigned long arg2,
1103 : : unsigned long arg3,
1104 : : unsigned long arg4,
1105 : : unsigned long arg5)
1106 : : {
1107 : : return cap_task_prctl(option, arg2, arg3, arg4, arg5);
1108 : : }
1109 : :
1110 : : static inline void security_task_to_inode(struct task_struct *p, struct inode *inode)
1111 : : { }
1112 : :
1113 : : static inline int security_ipc_permission(struct kern_ipc_perm *ipcp,
1114 : : short flag)
1115 : : {
1116 : : return 0;
1117 : : }
1118 : :
1119 : : static inline void security_ipc_getsecid(struct kern_ipc_perm *ipcp, u32 *secid)
1120 : : {
1121 : : *secid = 0;
1122 : : }
1123 : :
1124 : : static inline int security_msg_msg_alloc(struct msg_msg *msg)
1125 : : {
1126 : : return 0;
1127 : : }
1128 : :
1129 : : static inline void security_msg_msg_free(struct msg_msg *msg)
1130 : : { }
1131 : :
1132 : : static inline int security_msg_queue_alloc(struct kern_ipc_perm *msq)
1133 : : {
1134 : : return 0;
1135 : : }
1136 : :
1137 : : static inline void security_msg_queue_free(struct kern_ipc_perm *msq)
1138 : : { }
1139 : :
1140 : : static inline int security_msg_queue_associate(struct kern_ipc_perm *msq,
1141 : : int msqflg)
1142 : : {
1143 : : return 0;
1144 : : }
1145 : :
1146 : : static inline int security_msg_queue_msgctl(struct kern_ipc_perm *msq, int cmd)
1147 : : {
1148 : : return 0;
1149 : : }
1150 : :
1151 : : static inline int security_msg_queue_msgsnd(struct kern_ipc_perm *msq,
1152 : : struct msg_msg *msg, int msqflg)
1153 : : {
1154 : : return 0;
1155 : : }
1156 : :
1157 : : static inline int security_msg_queue_msgrcv(struct kern_ipc_perm *msq,
1158 : : struct msg_msg *msg,
1159 : : struct task_struct *target,
1160 : : long type, int mode)
1161 : : {
1162 : : return 0;
1163 : : }
1164 : :
1165 : : static inline int security_shm_alloc(struct kern_ipc_perm *shp)
1166 : : {
1167 : : return 0;
1168 : : }
1169 : :
1170 : : static inline void security_shm_free(struct kern_ipc_perm *shp)
1171 : : { }
1172 : :
1173 : : static inline int security_shm_associate(struct kern_ipc_perm *shp,
1174 : : int shmflg)
1175 : : {
1176 : : return 0;
1177 : : }
1178 : :
1179 : : static inline int security_shm_shmctl(struct kern_ipc_perm *shp, int cmd)
1180 : : {
1181 : : return 0;
1182 : : }
1183 : :
1184 : : static inline int security_shm_shmat(struct kern_ipc_perm *shp,
1185 : : char __user *shmaddr, int shmflg)
1186 : : {
1187 : : return 0;
1188 : : }
1189 : :
1190 : : static inline int security_sem_alloc(struct kern_ipc_perm *sma)
1191 : : {
1192 : : return 0;
1193 : : }
1194 : :
1195 : : static inline void security_sem_free(struct kern_ipc_perm *sma)
1196 : : { }
1197 : :
1198 : : static inline int security_sem_associate(struct kern_ipc_perm *sma, int semflg)
1199 : : {
1200 : : return 0;
1201 : : }
1202 : :
1203 : : static inline int security_sem_semctl(struct kern_ipc_perm *sma, int cmd)
1204 : : {
1205 : : return 0;
1206 : : }
1207 : :
1208 : : static inline int security_sem_semop(struct kern_ipc_perm *sma,
1209 : : struct sembuf *sops, unsigned nsops,
1210 : : int alter)
1211 : : {
1212 : : return 0;
1213 : : }
1214 : :
1215 : : static inline void security_d_instantiate(struct dentry *dentry,
1216 : : struct inode *inode)
1217 : : { }
1218 : :
1219 : : static inline int security_getprocattr(struct task_struct *p, const char *lsm,
1220 : : char *name, char **value)
1221 : : {
1222 : : return -EINVAL;
1223 : : }
1224 : :
1225 : : static inline int security_setprocattr(const char *lsm, char *name,
1226 : : void *value, size_t size)
1227 : : {
1228 : : return -EINVAL;
1229 : : }
1230 : :
1231 : : static inline int security_netlink_send(struct sock *sk, struct sk_buff *skb)
1232 : : {
1233 : : return 0;
1234 : : }
1235 : :
1236 : : static inline int security_ismaclabel(const char *name)
1237 : : {
1238 : : return 0;
1239 : : }
1240 : :
1241 : : static inline int security_secid_to_secctx(u32 secid, char **secdata, u32 *seclen)
1242 : : {
1243 : : return -EOPNOTSUPP;
1244 : : }
1245 : :
1246 : : static inline int security_secctx_to_secid(const char *secdata,
1247 : : u32 seclen,
1248 : : u32 *secid)
1249 : : {
1250 : : return -EOPNOTSUPP;
1251 : : }
1252 : :
1253 : : static inline void security_release_secctx(char *secdata, u32 seclen)
1254 : : {
1255 : : }
1256 : :
1257 : : static inline void security_inode_invalidate_secctx(struct inode *inode)
1258 : : {
1259 : : }
1260 : :
1261 : : static inline int security_inode_notifysecctx(struct inode *inode, void *ctx, u32 ctxlen)
1262 : : {
1263 : : return -EOPNOTSUPP;
1264 : : }
1265 : : static inline int security_inode_setsecctx(struct dentry *dentry, void *ctx, u32 ctxlen)
1266 : : {
1267 : : return -EOPNOTSUPP;
1268 : : }
1269 : : static inline int security_inode_getsecctx(struct inode *inode, void **ctx, u32 *ctxlen)
1270 : : {
1271 : : return -EOPNOTSUPP;
1272 : : }
1273 : : static inline int security_locked_down(enum lockdown_reason what)
1274 : : {
1275 : : return 0;
1276 : : }
1277 : : #endif /* CONFIG_SECURITY */
1278 : :
1279 : : #ifdef CONFIG_SECURITY_NETWORK
1280 : :
1281 : : int security_unix_stream_connect(struct sock *sock, struct sock *other, struct sock *newsk);
1282 : : int security_unix_may_send(struct socket *sock, struct socket *other);
1283 : : int security_socket_create(int family, int type, int protocol, int kern);
1284 : : int security_socket_post_create(struct socket *sock, int family,
1285 : : int type, int protocol, int kern);
1286 : : int security_socket_socketpair(struct socket *socka, struct socket *sockb);
1287 : : int security_socket_bind(struct socket *sock, struct sockaddr *address, int addrlen);
1288 : : int security_socket_connect(struct socket *sock, struct sockaddr *address, int addrlen);
1289 : : int security_socket_listen(struct socket *sock, int backlog);
1290 : : int security_socket_accept(struct socket *sock, struct socket *newsock);
1291 : : int security_socket_sendmsg(struct socket *sock, struct msghdr *msg, int size);
1292 : : int security_socket_recvmsg(struct socket *sock, struct msghdr *msg,
1293 : : int size, int flags);
1294 : : int security_socket_getsockname(struct socket *sock);
1295 : : int security_socket_getpeername(struct socket *sock);
1296 : : int security_socket_getsockopt(struct socket *sock, int level, int optname);
1297 : : int security_socket_setsockopt(struct socket *sock, int level, int optname);
1298 : : int security_socket_shutdown(struct socket *sock, int how);
1299 : : int security_sock_rcv_skb(struct sock *sk, struct sk_buff *skb);
1300 : : int security_socket_getpeersec_stream(struct socket *sock, char __user *optval,
1301 : : int __user *optlen, unsigned len);
1302 : : int security_socket_getpeersec_dgram(struct socket *sock, struct sk_buff *skb, u32 *secid);
1303 : : int security_sk_alloc(struct sock *sk, int family, gfp_t priority);
1304 : : void security_sk_free(struct sock *sk);
1305 : : void security_sk_clone(const struct sock *sk, struct sock *newsk);
1306 : : void security_sk_classify_flow(struct sock *sk, struct flowi *fl);
1307 : : void security_req_classify_flow(const struct request_sock *req, struct flowi *fl);
1308 : : void security_sock_graft(struct sock*sk, struct socket *parent);
1309 : : int security_inet_conn_request(struct sock *sk,
1310 : : struct sk_buff *skb, struct request_sock *req);
1311 : : void security_inet_csk_clone(struct sock *newsk,
1312 : : const struct request_sock *req);
1313 : : void security_inet_conn_established(struct sock *sk,
1314 : : struct sk_buff *skb);
1315 : : int security_secmark_relabel_packet(u32 secid);
1316 : : void security_secmark_refcount_inc(void);
1317 : : void security_secmark_refcount_dec(void);
1318 : : int security_tun_dev_alloc_security(void **security);
1319 : : void security_tun_dev_free_security(void *security);
1320 : : int security_tun_dev_create(void);
1321 : : int security_tun_dev_attach_queue(void *security);
1322 : : int security_tun_dev_attach(struct sock *sk, void *security);
1323 : : int security_tun_dev_open(void *security);
1324 : : int security_sctp_assoc_request(struct sctp_endpoint *ep, struct sk_buff *skb);
1325 : : int security_sctp_bind_connect(struct sock *sk, int optname,
1326 : : struct sockaddr *address, int addrlen);
1327 : : void security_sctp_sk_clone(struct sctp_endpoint *ep, struct sock *sk,
1328 : : struct sock *newsk);
1329 : :
1330 : : #else /* CONFIG_SECURITY_NETWORK */
1331 : : static inline int security_unix_stream_connect(struct sock *sock,
1332 : : struct sock *other,
1333 : : struct sock *newsk)
1334 : : {
1335 : : return 0;
1336 : : }
1337 : :
1338 : : static inline int security_unix_may_send(struct socket *sock,
1339 : : struct socket *other)
1340 : : {
1341 : : return 0;
1342 : : }
1343 : :
1344 : : static inline int security_socket_create(int family, int type,
1345 : : int protocol, int kern)
1346 : : {
1347 : : return 0;
1348 : : }
1349 : :
1350 : : static inline int security_socket_post_create(struct socket *sock,
1351 : : int family,
1352 : : int type,
1353 : : int protocol, int kern)
1354 : : {
1355 : : return 0;
1356 : : }
1357 : :
1358 : : static inline int security_socket_socketpair(struct socket *socka,
1359 : : struct socket *sockb)
1360 : : {
1361 : : return 0;
1362 : : }
1363 : :
1364 : : static inline int security_socket_bind(struct socket *sock,
1365 : : struct sockaddr *address,
1366 : : int addrlen)
1367 : : {
1368 : : return 0;
1369 : : }
1370 : :
1371 : : static inline int security_socket_connect(struct socket *sock,
1372 : : struct sockaddr *address,
1373 : : int addrlen)
1374 : : {
1375 : : return 0;
1376 : : }
1377 : :
1378 : : static inline int security_socket_listen(struct socket *sock, int backlog)
1379 : : {
1380 : : return 0;
1381 : : }
1382 : :
1383 : : static inline int security_socket_accept(struct socket *sock,
1384 : : struct socket *newsock)
1385 : : {
1386 : : return 0;
1387 : : }
1388 : :
1389 : : static inline int security_socket_sendmsg(struct socket *sock,
1390 : : struct msghdr *msg, int size)
1391 : : {
1392 : : return 0;
1393 : : }
1394 : :
1395 : : static inline int security_socket_recvmsg(struct socket *sock,
1396 : : struct msghdr *msg, int size,
1397 : : int flags)
1398 : : {
1399 : : return 0;
1400 : : }
1401 : :
1402 : : static inline int security_socket_getsockname(struct socket *sock)
1403 : : {
1404 : : return 0;
1405 : : }
1406 : :
1407 : : static inline int security_socket_getpeername(struct socket *sock)
1408 : : {
1409 : : return 0;
1410 : : }
1411 : :
1412 : : static inline int security_socket_getsockopt(struct socket *sock,
1413 : : int level, int optname)
1414 : : {
1415 : : return 0;
1416 : : }
1417 : :
1418 : : static inline int security_socket_setsockopt(struct socket *sock,
1419 : : int level, int optname)
1420 : : {
1421 : : return 0;
1422 : : }
1423 : :
1424 : : static inline int security_socket_shutdown(struct socket *sock, int how)
1425 : : {
1426 : : return 0;
1427 : : }
1428 : : static inline int security_sock_rcv_skb(struct sock *sk,
1429 : : struct sk_buff *skb)
1430 : : {
1431 : : return 0;
1432 : : }
1433 : :
1434 : : static inline int security_socket_getpeersec_stream(struct socket *sock, char __user *optval,
1435 : : int __user *optlen, unsigned len)
1436 : : {
1437 : : return -ENOPROTOOPT;
1438 : : }
1439 : :
1440 : : static inline int security_socket_getpeersec_dgram(struct socket *sock, struct sk_buff *skb, u32 *secid)
1441 : : {
1442 : : return -ENOPROTOOPT;
1443 : : }
1444 : :
1445 : : static inline int security_sk_alloc(struct sock *sk, int family, gfp_t priority)
1446 : : {
1447 : : return 0;
1448 : : }
1449 : :
1450 : : static inline void security_sk_free(struct sock *sk)
1451 : : {
1452 : : }
1453 : :
1454 : : static inline void security_sk_clone(const struct sock *sk, struct sock *newsk)
1455 : : {
1456 : : }
1457 : :
1458 : : static inline void security_sk_classify_flow(struct sock *sk, struct flowi *fl)
1459 : : {
1460 : : }
1461 : :
1462 : : static inline void security_req_classify_flow(const struct request_sock *req, struct flowi *fl)
1463 : : {
1464 : : }
1465 : :
1466 : : static inline void security_sock_graft(struct sock *sk, struct socket *parent)
1467 : : {
1468 : : }
1469 : :
1470 : : static inline int security_inet_conn_request(struct sock *sk,
1471 : : struct sk_buff *skb, struct request_sock *req)
1472 : : {
1473 : : return 0;
1474 : : }
1475 : :
1476 : : static inline void security_inet_csk_clone(struct sock *newsk,
1477 : : const struct request_sock *req)
1478 : : {
1479 : : }
1480 : :
1481 : : static inline void security_inet_conn_established(struct sock *sk,
1482 : : struct sk_buff *skb)
1483 : : {
1484 : : }
1485 : :
1486 : : static inline int security_secmark_relabel_packet(u32 secid)
1487 : : {
1488 : : return 0;
1489 : : }
1490 : :
1491 : : static inline void security_secmark_refcount_inc(void)
1492 : : {
1493 : : }
1494 : :
1495 : : static inline void security_secmark_refcount_dec(void)
1496 : : {
1497 : : }
1498 : :
1499 : : static inline int security_tun_dev_alloc_security(void **security)
1500 : : {
1501 : : return 0;
1502 : : }
1503 : :
1504 : : static inline void security_tun_dev_free_security(void *security)
1505 : : {
1506 : : }
1507 : :
1508 : : static inline int security_tun_dev_create(void)
1509 : : {
1510 : : return 0;
1511 : : }
1512 : :
1513 : : static inline int security_tun_dev_attach_queue(void *security)
1514 : : {
1515 : : return 0;
1516 : : }
1517 : :
1518 : : static inline int security_tun_dev_attach(struct sock *sk, void *security)
1519 : : {
1520 : : return 0;
1521 : : }
1522 : :
1523 : : static inline int security_tun_dev_open(void *security)
1524 : : {
1525 : : return 0;
1526 : : }
1527 : :
1528 : : static inline int security_sctp_assoc_request(struct sctp_endpoint *ep,
1529 : : struct sk_buff *skb)
1530 : : {
1531 : : return 0;
1532 : : }
1533 : :
1534 : : static inline int security_sctp_bind_connect(struct sock *sk, int optname,
1535 : : struct sockaddr *address,
1536 : : int addrlen)
1537 : : {
1538 : : return 0;
1539 : : }
1540 : :
1541 : : static inline void security_sctp_sk_clone(struct sctp_endpoint *ep,
1542 : : struct sock *sk,
1543 : : struct sock *newsk)
1544 : : {
1545 : : }
1546 : : #endif /* CONFIG_SECURITY_NETWORK */
1547 : :
1548 : : #ifdef CONFIG_SECURITY_INFINIBAND
1549 : : int security_ib_pkey_access(void *sec, u64 subnet_prefix, u16 pkey);
1550 : : int security_ib_endport_manage_subnet(void *sec, const char *name, u8 port_num);
1551 : : int security_ib_alloc_security(void **sec);
1552 : : void security_ib_free_security(void *sec);
1553 : : #else /* CONFIG_SECURITY_INFINIBAND */
1554 : : static inline int security_ib_pkey_access(void *sec, u64 subnet_prefix, u16 pkey)
1555 : : {
1556 : : return 0;
1557 : : }
1558 : :
1559 : : static inline int security_ib_endport_manage_subnet(void *sec, const char *dev_name, u8 port_num)
1560 : : {
1561 : : return 0;
1562 : : }
1563 : :
1564 : : static inline int security_ib_alloc_security(void **sec)
1565 : : {
1566 : : return 0;
1567 : : }
1568 : :
1569 : : static inline void security_ib_free_security(void *sec)
1570 : : {
1571 : : }
1572 : : #endif /* CONFIG_SECURITY_INFINIBAND */
1573 : :
1574 : : #ifdef CONFIG_SECURITY_NETWORK_XFRM
1575 : :
1576 : : int security_xfrm_policy_alloc(struct xfrm_sec_ctx **ctxp,
1577 : : struct xfrm_user_sec_ctx *sec_ctx, gfp_t gfp);
1578 : : int security_xfrm_policy_clone(struct xfrm_sec_ctx *old_ctx, struct xfrm_sec_ctx **new_ctxp);
1579 : : void security_xfrm_policy_free(struct xfrm_sec_ctx *ctx);
1580 : : int security_xfrm_policy_delete(struct xfrm_sec_ctx *ctx);
1581 : : int security_xfrm_state_alloc(struct xfrm_state *x, struct xfrm_user_sec_ctx *sec_ctx);
1582 : : int security_xfrm_state_alloc_acquire(struct xfrm_state *x,
1583 : : struct xfrm_sec_ctx *polsec, u32 secid);
1584 : : int security_xfrm_state_delete(struct xfrm_state *x);
1585 : : void security_xfrm_state_free(struct xfrm_state *x);
1586 : : int security_xfrm_policy_lookup(struct xfrm_sec_ctx *ctx, u32 fl_secid, u8 dir);
1587 : : int security_xfrm_state_pol_flow_match(struct xfrm_state *x,
1588 : : struct xfrm_policy *xp,
1589 : : const struct flowi *fl);
1590 : : int security_xfrm_decode_session(struct sk_buff *skb, u32 *secid);
1591 : : void security_skb_classify_flow(struct sk_buff *skb, struct flowi *fl);
1592 : :
1593 : : #else /* CONFIG_SECURITY_NETWORK_XFRM */
1594 : :
1595 : 0 : static inline int security_xfrm_policy_alloc(struct xfrm_sec_ctx **ctxp,
1596 : : struct xfrm_user_sec_ctx *sec_ctx,
1597 : : gfp_t gfp)
1598 : : {
1599 [ # # ]: 0 : return 0;
1600 : : }
1601 : :
1602 : 0 : static inline int security_xfrm_policy_clone(struct xfrm_sec_ctx *old, struct xfrm_sec_ctx **new_ctxp)
1603 : : {
1604 : 0 : return 0;
1605 : : }
1606 : :
1607 : 0 : static inline void security_xfrm_policy_free(struct xfrm_sec_ctx *ctx)
1608 : : {
1609 : 0 : }
1610 : :
1611 : 0 : static inline int security_xfrm_policy_delete(struct xfrm_sec_ctx *ctx)
1612 : : {
1613 : 0 : return 0;
1614 : : }
1615 : :
1616 : : static inline int security_xfrm_state_alloc(struct xfrm_state *x,
1617 : : struct xfrm_user_sec_ctx *sec_ctx)
1618 : : {
1619 : : return 0;
1620 : : }
1621 : :
1622 : 0 : static inline int security_xfrm_state_alloc_acquire(struct xfrm_state *x,
1623 : : struct xfrm_sec_ctx *polsec, u32 secid)
1624 : : {
1625 : 0 : return 0;
1626 : : }
1627 : :
1628 : 0 : static inline void security_xfrm_state_free(struct xfrm_state *x)
1629 : : {
1630 : 0 : }
1631 : :
1632 : 0 : static inline int security_xfrm_state_delete(struct xfrm_state *x)
1633 : : {
1634 : 0 : return 0;
1635 : : }
1636 : :
1637 : 0 : static inline int security_xfrm_policy_lookup(struct xfrm_sec_ctx *ctx, u32 fl_secid, u8 dir)
1638 : : {
1639 : 0 : return 0;
1640 : : }
1641 : :
1642 : 0 : static inline int security_xfrm_state_pol_flow_match(struct xfrm_state *x,
1643 : : struct xfrm_policy *xp, const struct flowi *fl)
1644 : : {
1645 [ # # ]: 0 : return 1;
1646 : : }
1647 : :
1648 : 0 : static inline int security_xfrm_decode_session(struct sk_buff *skb, u32 *secid)
1649 : : {
1650 : 0 : return 0;
1651 : : }
1652 : :
1653 : 0 : static inline void security_skb_classify_flow(struct sk_buff *skb, struct flowi *fl)
1654 : : {
1655 [ # # ]: 0 : }
1656 : :
1657 : : #endif /* CONFIG_SECURITY_NETWORK_XFRM */
1658 : :
1659 : : #ifdef CONFIG_SECURITY_PATH
1660 : : int security_path_unlink(const struct path *dir, struct dentry *dentry);
1661 : : int security_path_mkdir(const struct path *dir, struct dentry *dentry, umode_t mode);
1662 : : int security_path_rmdir(const struct path *dir, struct dentry *dentry);
1663 : : int security_path_mknod(const struct path *dir, struct dentry *dentry, umode_t mode,
1664 : : unsigned int dev);
1665 : : int security_path_truncate(const struct path *path);
1666 : : int security_path_symlink(const struct path *dir, struct dentry *dentry,
1667 : : const char *old_name);
1668 : : int security_path_link(struct dentry *old_dentry, const struct path *new_dir,
1669 : : struct dentry *new_dentry);
1670 : : int security_path_rename(const struct path *old_dir, struct dentry *old_dentry,
1671 : : const struct path *new_dir, struct dentry *new_dentry,
1672 : : unsigned int flags);
1673 : : int security_path_chmod(const struct path *path, umode_t mode);
1674 : : int security_path_chown(const struct path *path, kuid_t uid, kgid_t gid);
1675 : : int security_path_chroot(const struct path *path);
1676 : : #else /* CONFIG_SECURITY_PATH */
1677 : 2634 : static inline int security_path_unlink(const struct path *dir, struct dentry *dentry)
1678 : : {
1679 : 2634 : return 0;
1680 : : }
1681 : :
1682 : 11508 : static inline int security_path_mkdir(const struct path *dir, struct dentry *dentry,
1683 : : umode_t mode)
1684 : : {
1685 : 11508 : return 0;
1686 : : }
1687 : :
1688 : 990 : static inline int security_path_rmdir(const struct path *dir, struct dentry *dentry)
1689 : : {
1690 : 990 : return 0;
1691 : : }
1692 : :
1693 : 19590 : static inline int security_path_mknod(const struct path *dir, struct dentry *dentry,
1694 : : umode_t mode, unsigned int dev)
1695 : : {
1696 [ + + + - : 19590 : return 0;
+ - ]
1697 : : }
1698 : :
1699 : 427 : static inline int security_path_truncate(const struct path *path)
1700 : : {
1701 : 427 : return 0;
1702 : : }
1703 : :
1704 : 6186 : static inline int security_path_symlink(const struct path *dir, struct dentry *dentry,
1705 : : const char *old_name)
1706 : : {
1707 : 6186 : return 0;
1708 : : }
1709 : :
1710 : 0 : static inline int security_path_link(struct dentry *old_dentry,
1711 : : const struct path *new_dir,
1712 : : struct dentry *new_dentry)
1713 : : {
1714 : 0 : return 0;
1715 : : }
1716 : :
1717 : 7026 : static inline int security_path_rename(const struct path *old_dir,
1718 : : struct dentry *old_dentry,
1719 : : const struct path *new_dir,
1720 : : struct dentry *new_dentry,
1721 : : unsigned int flags)
1722 : : {
1723 : 7026 : return 0;
1724 : : }
1725 : :
1726 : 9666 : static inline int security_path_chmod(const struct path *path, umode_t mode)
1727 : : {
1728 : 9666 : return 0;
1729 : : }
1730 : :
1731 : : static inline int security_path_chown(const struct path *path, kuid_t uid, kgid_t gid)
1732 : : {
1733 : : return 0;
1734 : : }
1735 : :
1736 : 120 : static inline int security_path_chroot(const struct path *path)
1737 : : {
1738 : 120 : return 0;
1739 : : }
1740 : : #endif /* CONFIG_SECURITY_PATH */
1741 : :
1742 : : #ifdef CONFIG_KEYS
1743 : : #ifdef CONFIG_SECURITY
1744 : :
1745 : : int security_key_alloc(struct key *key, const struct cred *cred, unsigned long flags);
1746 : : void security_key_free(struct key *key);
1747 : : int security_key_permission(key_ref_t key_ref,
1748 : : const struct cred *cred, unsigned perm);
1749 : : int security_key_getsecurity(struct key *key, char **_buffer);
1750 : :
1751 : : #else
1752 : :
1753 : : static inline int security_key_alloc(struct key *key,
1754 : : const struct cred *cred,
1755 : : unsigned long flags)
1756 : : {
1757 : : return 0;
1758 : : }
1759 : :
1760 : : static inline void security_key_free(struct key *key)
1761 : : {
1762 : : }
1763 : :
1764 : : static inline int security_key_permission(key_ref_t key_ref,
1765 : : const struct cred *cred,
1766 : : unsigned perm)
1767 : : {
1768 : : return 0;
1769 : : }
1770 : :
1771 : : static inline int security_key_getsecurity(struct key *key, char **_buffer)
1772 : : {
1773 : : *_buffer = NULL;
1774 : : return 0;
1775 : : }
1776 : :
1777 : : #endif
1778 : : #endif /* CONFIG_KEYS */
1779 : :
1780 : : #ifdef CONFIG_AUDIT
1781 : : #ifdef CONFIG_SECURITY
1782 : : int security_audit_rule_init(u32 field, u32 op, char *rulestr, void **lsmrule);
1783 : : int security_audit_rule_known(struct audit_krule *krule);
1784 : : int security_audit_rule_match(u32 secid, u32 field, u32 op, void *lsmrule);
1785 : : void security_audit_rule_free(void *lsmrule);
1786 : :
1787 : : #else
1788 : :
1789 : : static inline int security_audit_rule_init(u32 field, u32 op, char *rulestr,
1790 : : void **lsmrule)
1791 : : {
1792 : : return 0;
1793 : : }
1794 : :
1795 : : static inline int security_audit_rule_known(struct audit_krule *krule)
1796 : : {
1797 : : return 0;
1798 : : }
1799 : :
1800 : : static inline int security_audit_rule_match(u32 secid, u32 field, u32 op,
1801 : : void *lsmrule)
1802 : : {
1803 : : return 0;
1804 : : }
1805 : :
1806 : : static inline void security_audit_rule_free(void *lsmrule)
1807 : : { }
1808 : :
1809 : : #endif /* CONFIG_SECURITY */
1810 : : #endif /* CONFIG_AUDIT */
1811 : :
1812 : : #ifdef CONFIG_SECURITYFS
1813 : :
1814 : : extern struct dentry *securityfs_create_file(const char *name, umode_t mode,
1815 : : struct dentry *parent, void *data,
1816 : : const struct file_operations *fops);
1817 : : extern struct dentry *securityfs_create_dir(const char *name, struct dentry *parent);
1818 : : struct dentry *securityfs_create_symlink(const char *name,
1819 : : struct dentry *parent,
1820 : : const char *target,
1821 : : const struct inode_operations *iops);
1822 : : extern void securityfs_remove(struct dentry *dentry);
1823 : :
1824 : : #else /* CONFIG_SECURITYFS */
1825 : :
1826 : : static inline struct dentry *securityfs_create_dir(const char *name,
1827 : : struct dentry *parent)
1828 : : {
1829 : : return ERR_PTR(-ENODEV);
1830 : : }
1831 : :
1832 : : static inline struct dentry *securityfs_create_file(const char *name,
1833 : : umode_t mode,
1834 : : struct dentry *parent,
1835 : : void *data,
1836 : : const struct file_operations *fops)
1837 : : {
1838 : : return ERR_PTR(-ENODEV);
1839 : : }
1840 : :
1841 : : static inline struct dentry *securityfs_create_symlink(const char *name,
1842 : : struct dentry *parent,
1843 : : const char *target,
1844 : : const struct inode_operations *iops)
1845 : : {
1846 : : return ERR_PTR(-ENODEV);
1847 : : }
1848 : :
1849 : : static inline void securityfs_remove(struct dentry *dentry)
1850 : : {}
1851 : :
1852 : : #endif
1853 : :
1854 : : #ifdef CONFIG_BPF_SYSCALL
1855 : : union bpf_attr;
1856 : : struct bpf_map;
1857 : : struct bpf_prog;
1858 : : struct bpf_prog_aux;
1859 : : #ifdef CONFIG_SECURITY
1860 : : extern int security_bpf(int cmd, union bpf_attr *attr, unsigned int size);
1861 : : extern int security_bpf_map(struct bpf_map *map, fmode_t fmode);
1862 : : extern int security_bpf_prog(struct bpf_prog *prog);
1863 : : extern int security_bpf_map_alloc(struct bpf_map *map);
1864 : : extern void security_bpf_map_free(struct bpf_map *map);
1865 : : extern int security_bpf_prog_alloc(struct bpf_prog_aux *aux);
1866 : : extern void security_bpf_prog_free(struct bpf_prog_aux *aux);
1867 : : #else
1868 : : static inline int security_bpf(int cmd, union bpf_attr *attr,
1869 : : unsigned int size)
1870 : : {
1871 : : return 0;
1872 : : }
1873 : :
1874 : : static inline int security_bpf_map(struct bpf_map *map, fmode_t fmode)
1875 : : {
1876 : : return 0;
1877 : : }
1878 : :
1879 : : static inline int security_bpf_prog(struct bpf_prog *prog)
1880 : : {
1881 : : return 0;
1882 : : }
1883 : :
1884 : : static inline int security_bpf_map_alloc(struct bpf_map *map)
1885 : : {
1886 : : return 0;
1887 : : }
1888 : :
1889 : : static inline void security_bpf_map_free(struct bpf_map *map)
1890 : : { }
1891 : :
1892 : : static inline int security_bpf_prog_alloc(struct bpf_prog_aux *aux)
1893 : : {
1894 : : return 0;
1895 : : }
1896 : :
1897 : : static inline void security_bpf_prog_free(struct bpf_prog_aux *aux)
1898 : : { }
1899 : : #endif /* CONFIG_SECURITY */
1900 : : #endif /* CONFIG_BPF_SYSCALL */
1901 : :
1902 : : #ifdef CONFIG_PERF_EVENTS
1903 : : struct perf_event_attr;
1904 : : struct perf_event;
1905 : :
1906 : : #ifdef CONFIG_SECURITY
1907 : : extern int security_perf_event_open(struct perf_event_attr *attr, int type);
1908 : : extern int security_perf_event_alloc(struct perf_event *event);
1909 : : extern void security_perf_event_free(struct perf_event *event);
1910 : : extern int security_perf_event_read(struct perf_event *event);
1911 : : extern int security_perf_event_write(struct perf_event *event);
1912 : : #else
1913 : : static inline int security_perf_event_open(struct perf_event_attr *attr,
1914 : : int type)
1915 : : {
1916 : : return 0;
1917 : : }
1918 : :
1919 : : static inline int security_perf_event_alloc(struct perf_event *event)
1920 : : {
1921 : : return 0;
1922 : : }
1923 : :
1924 : : static inline void security_perf_event_free(struct perf_event *event)
1925 : : {
1926 : : }
1927 : :
1928 : : static inline int security_perf_event_read(struct perf_event *event)
1929 : : {
1930 : : return 0;
1931 : : }
1932 : :
1933 : : static inline int security_perf_event_write(struct perf_event *event)
1934 : : {
1935 : : return 0;
1936 : : }
1937 : : #endif /* CONFIG_SECURITY */
1938 : : #endif /* CONFIG_PERF_EVENTS */
1939 : :
1940 : : #endif /* ! __LINUX_SECURITY_H */
|
