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