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