Merge tag 'edac/v4.3-1' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab...
[linux-2.6-microblaze.git] / include / linux / audit.h
1 /* audit.h -- Auditing support
2  *
3  * Copyright 2003-2004 Red Hat Inc., Durham, North Carolina.
4  * All Rights Reserved.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  *
20  * Written by Rickard E. (Rik) Faith <faith@redhat.com>
21  *
22  */
23 #ifndef _LINUX_AUDIT_H_
24 #define _LINUX_AUDIT_H_
25
26 #include <linux/sched.h>
27 #include <linux/ptrace.h>
28 #include <uapi/linux/audit.h>
29
30 #define AUDIT_INO_UNSET ((unsigned long)-1)
31 #define AUDIT_DEV_UNSET ((dev_t)-1)
32
33 struct audit_sig_info {
34         uid_t           uid;
35         pid_t           pid;
36         char            ctx[0];
37 };
38
39 struct audit_buffer;
40 struct audit_context;
41 struct inode;
42 struct netlink_skb_parms;
43 struct path;
44 struct linux_binprm;
45 struct mq_attr;
46 struct mqstat;
47 struct audit_watch;
48 struct audit_tree;
49 struct sk_buff;
50
51 struct audit_krule {
52         u32                     pflags;
53         u32                     flags;
54         u32                     listnr;
55         u32                     action;
56         u32                     mask[AUDIT_BITMASK_SIZE];
57         u32                     buflen; /* for data alloc on list rules */
58         u32                     field_count;
59         char                    *filterkey; /* ties events to rules */
60         struct audit_field      *fields;
61         struct audit_field      *arch_f; /* quick access to arch field */
62         struct audit_field      *inode_f; /* quick access to an inode field */
63         struct audit_watch      *watch; /* associated watch */
64         struct audit_tree       *tree;  /* associated watched tree */
65         struct audit_fsnotify_mark      *exe;
66         struct list_head        rlist;  /* entry in audit_{watch,tree}.rules list */
67         struct list_head        list;   /* for AUDIT_LIST* purposes only */
68         u64                     prio;
69 };
70
71 /* Flag to indicate legacy AUDIT_LOGINUID unset usage */
72 #define AUDIT_LOGINUID_LEGACY           0x1
73
74 struct audit_field {
75         u32                             type;
76         union {
77                 u32                     val;
78                 kuid_t                  uid;
79                 kgid_t                  gid;
80                 struct {
81                         char            *lsm_str;
82                         void            *lsm_rule;
83                 };
84         };
85         u32                             op;
86 };
87
88 extern int is_audit_feature_set(int which);
89
90 extern int __init audit_register_class(int class, unsigned *list);
91 extern int audit_classify_syscall(int abi, unsigned syscall);
92 extern int audit_classify_arch(int arch);
93 /* only for compat system calls */
94 extern unsigned compat_write_class[];
95 extern unsigned compat_read_class[];
96 extern unsigned compat_dir_class[];
97 extern unsigned compat_chattr_class[];
98 extern unsigned compat_signal_class[];
99
100 extern int audit_classify_compat_syscall(int abi, unsigned syscall);
101
102 /* audit_names->type values */
103 #define AUDIT_TYPE_UNKNOWN      0       /* we don't know yet */
104 #define AUDIT_TYPE_NORMAL       1       /* a "normal" audit record */
105 #define AUDIT_TYPE_PARENT       2       /* a parent audit record */
106 #define AUDIT_TYPE_CHILD_DELETE 3       /* a child being deleted */
107 #define AUDIT_TYPE_CHILD_CREATE 4       /* a child being created */
108
109 /* maximized args number that audit_socketcall can process */
110 #define AUDITSC_ARGS            6
111
112 struct filename;
113
114 extern void audit_log_session_info(struct audit_buffer *ab);
115
116 #ifdef CONFIG_AUDIT_COMPAT_GENERIC
117 #define audit_is_compat(arch)  (!((arch) & __AUDIT_ARCH_64BIT))
118 #else
119 #define audit_is_compat(arch)  false
120 #endif
121
122 #ifdef CONFIG_AUDITSYSCALL
123 #include <asm/syscall.h> /* for syscall_get_arch() */
124
125 /* These are defined in auditsc.c */
126                                 /* Public API */
127 extern int  audit_alloc(struct task_struct *task);
128 extern void __audit_free(struct task_struct *task);
129 extern void __audit_syscall_entry(int major, unsigned long a0, unsigned long a1,
130                                   unsigned long a2, unsigned long a3);
131 extern void __audit_syscall_exit(int ret_success, long ret_value);
132 extern struct filename *__audit_reusename(const __user char *uptr);
133 extern void __audit_getname(struct filename *name);
134
135 #define AUDIT_INODE_PARENT      1       /* dentry represents the parent */
136 #define AUDIT_INODE_HIDDEN      2       /* audit record should be hidden */
137 extern void __audit_inode(struct filename *name, const struct dentry *dentry,
138                                 unsigned int flags);
139 extern void __audit_file(const struct file *);
140 extern void __audit_inode_child(const struct inode *parent,
141                                 const struct dentry *dentry,
142                                 const unsigned char type);
143 extern void __audit_seccomp(unsigned long syscall, long signr, int code);
144 extern void __audit_ptrace(struct task_struct *t);
145
146 static inline int audit_dummy_context(void)
147 {
148         void *p = current->audit_context;
149         return !p || *(int *)p;
150 }
151 static inline void audit_free(struct task_struct *task)
152 {
153         if (unlikely(task->audit_context))
154                 __audit_free(task);
155 }
156 static inline void audit_syscall_entry(int major, unsigned long a0,
157                                        unsigned long a1, unsigned long a2,
158                                        unsigned long a3)
159 {
160         if (unlikely(current->audit_context))
161                 __audit_syscall_entry(major, a0, a1, a2, a3);
162 }
163 static inline void audit_syscall_exit(void *pt_regs)
164 {
165         if (unlikely(current->audit_context)) {
166                 int success = is_syscall_success(pt_regs);
167                 long return_code = regs_return_value(pt_regs);
168
169                 __audit_syscall_exit(success, return_code);
170         }
171 }
172 static inline struct filename *audit_reusename(const __user char *name)
173 {
174         if (unlikely(!audit_dummy_context()))
175                 return __audit_reusename(name);
176         return NULL;
177 }
178 static inline void audit_getname(struct filename *name)
179 {
180         if (unlikely(!audit_dummy_context()))
181                 __audit_getname(name);
182 }
183 static inline void audit_inode(struct filename *name,
184                                 const struct dentry *dentry,
185                                 unsigned int parent) {
186         if (unlikely(!audit_dummy_context())) {
187                 unsigned int flags = 0;
188                 if (parent)
189                         flags |= AUDIT_INODE_PARENT;
190                 __audit_inode(name, dentry, flags);
191         }
192 }
193 static inline void audit_file(struct file *file)
194 {
195         if (unlikely(!audit_dummy_context()))
196                 __audit_file(file);
197 }
198 static inline void audit_inode_parent_hidden(struct filename *name,
199                                                 const struct dentry *dentry)
200 {
201         if (unlikely(!audit_dummy_context()))
202                 __audit_inode(name, dentry,
203                                 AUDIT_INODE_PARENT | AUDIT_INODE_HIDDEN);
204 }
205 static inline void audit_inode_child(const struct inode *parent,
206                                      const struct dentry *dentry,
207                                      const unsigned char type) {
208         if (unlikely(!audit_dummy_context()))
209                 __audit_inode_child(parent, dentry, type);
210 }
211 void audit_core_dumps(long signr);
212
213 static inline void audit_seccomp(unsigned long syscall, long signr, int code)
214 {
215         /* Force a record to be reported if a signal was delivered. */
216         if (signr || unlikely(!audit_dummy_context()))
217                 __audit_seccomp(syscall, signr, code);
218 }
219
220 static inline void audit_ptrace(struct task_struct *t)
221 {
222         if (unlikely(!audit_dummy_context()))
223                 __audit_ptrace(t);
224 }
225
226                                 /* Private API (for audit.c only) */
227 extern unsigned int audit_serial(void);
228 extern int auditsc_get_stamp(struct audit_context *ctx,
229                               struct timespec *t, unsigned int *serial);
230 extern int audit_set_loginuid(kuid_t loginuid);
231
232 static inline kuid_t audit_get_loginuid(struct task_struct *tsk)
233 {
234         return tsk->loginuid;
235 }
236
237 static inline unsigned int audit_get_sessionid(struct task_struct *tsk)
238 {
239         return tsk->sessionid;
240 }
241
242 extern void __audit_ipc_obj(struct kern_ipc_perm *ipcp);
243 extern void __audit_ipc_set_perm(unsigned long qbytes, uid_t uid, gid_t gid, umode_t mode);
244 extern void __audit_bprm(struct linux_binprm *bprm);
245 extern int __audit_socketcall(int nargs, unsigned long *args);
246 extern int __audit_sockaddr(int len, void *addr);
247 extern void __audit_fd_pair(int fd1, int fd2);
248 extern void __audit_mq_open(int oflag, umode_t mode, struct mq_attr *attr);
249 extern void __audit_mq_sendrecv(mqd_t mqdes, size_t msg_len, unsigned int msg_prio, const struct timespec *abs_timeout);
250 extern void __audit_mq_notify(mqd_t mqdes, const struct sigevent *notification);
251 extern void __audit_mq_getsetattr(mqd_t mqdes, struct mq_attr *mqstat);
252 extern int __audit_log_bprm_fcaps(struct linux_binprm *bprm,
253                                   const struct cred *new,
254                                   const struct cred *old);
255 extern void __audit_log_capset(const struct cred *new, const struct cred *old);
256 extern void __audit_mmap_fd(int fd, int flags);
257
258 static inline void audit_ipc_obj(struct kern_ipc_perm *ipcp)
259 {
260         if (unlikely(!audit_dummy_context()))
261                 __audit_ipc_obj(ipcp);
262 }
263 static inline void audit_fd_pair(int fd1, int fd2)
264 {
265         if (unlikely(!audit_dummy_context()))
266                 __audit_fd_pair(fd1, fd2);
267 }
268 static inline void audit_ipc_set_perm(unsigned long qbytes, uid_t uid, gid_t gid, umode_t mode)
269 {
270         if (unlikely(!audit_dummy_context()))
271                 __audit_ipc_set_perm(qbytes, uid, gid, mode);
272 }
273 static inline void audit_bprm(struct linux_binprm *bprm)
274 {
275         if (unlikely(!audit_dummy_context()))
276                 __audit_bprm(bprm);
277 }
278 static inline int audit_socketcall(int nargs, unsigned long *args)
279 {
280         if (unlikely(!audit_dummy_context()))
281                 return __audit_socketcall(nargs, args);
282         return 0;
283 }
284 static inline int audit_sockaddr(int len, void *addr)
285 {
286         if (unlikely(!audit_dummy_context()))
287                 return __audit_sockaddr(len, addr);
288         return 0;
289 }
290 static inline void audit_mq_open(int oflag, umode_t mode, struct mq_attr *attr)
291 {
292         if (unlikely(!audit_dummy_context()))
293                 __audit_mq_open(oflag, mode, attr);
294 }
295 static inline void audit_mq_sendrecv(mqd_t mqdes, size_t msg_len, unsigned int msg_prio, const struct timespec *abs_timeout)
296 {
297         if (unlikely(!audit_dummy_context()))
298                 __audit_mq_sendrecv(mqdes, msg_len, msg_prio, abs_timeout);
299 }
300 static inline void audit_mq_notify(mqd_t mqdes, const struct sigevent *notification)
301 {
302         if (unlikely(!audit_dummy_context()))
303                 __audit_mq_notify(mqdes, notification);
304 }
305 static inline void audit_mq_getsetattr(mqd_t mqdes, struct mq_attr *mqstat)
306 {
307         if (unlikely(!audit_dummy_context()))
308                 __audit_mq_getsetattr(mqdes, mqstat);
309 }
310
311 static inline int audit_log_bprm_fcaps(struct linux_binprm *bprm,
312                                        const struct cred *new,
313                                        const struct cred *old)
314 {
315         if (unlikely(!audit_dummy_context()))
316                 return __audit_log_bprm_fcaps(bprm, new, old);
317         return 0;
318 }
319
320 static inline void audit_log_capset(const struct cred *new,
321                                    const struct cred *old)
322 {
323         if (unlikely(!audit_dummy_context()))
324                 __audit_log_capset(new, old);
325 }
326
327 static inline void audit_mmap_fd(int fd, int flags)
328 {
329         if (unlikely(!audit_dummy_context()))
330                 __audit_mmap_fd(fd, flags);
331 }
332
333 extern int audit_n_rules;
334 extern int audit_signals;
335 #else /* CONFIG_AUDITSYSCALL */
336 static inline int audit_alloc(struct task_struct *task)
337 {
338         return 0;
339 }
340 static inline void audit_free(struct task_struct *task)
341 { }
342 static inline void audit_syscall_entry(int major, unsigned long a0,
343                                        unsigned long a1, unsigned long a2,
344                                        unsigned long a3)
345 { }
346 static inline void audit_syscall_exit(void *pt_regs)
347 { }
348 static inline int audit_dummy_context(void)
349 {
350         return 1;
351 }
352 static inline struct filename *audit_reusename(const __user char *name)
353 {
354         return NULL;
355 }
356 static inline void audit_getname(struct filename *name)
357 { }
358 static inline void __audit_inode(struct filename *name,
359                                         const struct dentry *dentry,
360                                         unsigned int flags)
361 { }
362 static inline void __audit_inode_child(const struct inode *parent,
363                                         const struct dentry *dentry,
364                                         const unsigned char type)
365 { }
366 static inline void audit_inode(struct filename *name,
367                                 const struct dentry *dentry,
368                                 unsigned int parent)
369 { }
370 static inline void audit_file(struct file *file)
371 {
372 }
373 static inline void audit_inode_parent_hidden(struct filename *name,
374                                 const struct dentry *dentry)
375 { }
376 static inline void audit_inode_child(const struct inode *parent,
377                                      const struct dentry *dentry,
378                                      const unsigned char type)
379 { }
380 static inline void audit_core_dumps(long signr)
381 { }
382 static inline void __audit_seccomp(unsigned long syscall, long signr, int code)
383 { }
384 static inline void audit_seccomp(unsigned long syscall, long signr, int code)
385 { }
386 static inline int auditsc_get_stamp(struct audit_context *ctx,
387                               struct timespec *t, unsigned int *serial)
388 {
389         return 0;
390 }
391 static inline kuid_t audit_get_loginuid(struct task_struct *tsk)
392 {
393         return INVALID_UID;
394 }
395 static inline unsigned int audit_get_sessionid(struct task_struct *tsk)
396 {
397         return -1;
398 }
399 static inline void audit_ipc_obj(struct kern_ipc_perm *ipcp)
400 { }
401 static inline void audit_ipc_set_perm(unsigned long qbytes, uid_t uid,
402                                         gid_t gid, umode_t mode)
403 { }
404 static inline void audit_bprm(struct linux_binprm *bprm)
405 { }
406 static inline int audit_socketcall(int nargs, unsigned long *args)
407 {
408         return 0;
409 }
410 static inline void audit_fd_pair(int fd1, int fd2)
411 { }
412 static inline int audit_sockaddr(int len, void *addr)
413 {
414         return 0;
415 }
416 static inline void audit_mq_open(int oflag, umode_t mode, struct mq_attr *attr)
417 { }
418 static inline void audit_mq_sendrecv(mqd_t mqdes, size_t msg_len,
419                                      unsigned int msg_prio,
420                                      const struct timespec *abs_timeout)
421 { }
422 static inline void audit_mq_notify(mqd_t mqdes,
423                                    const struct sigevent *notification)
424 { }
425 static inline void audit_mq_getsetattr(mqd_t mqdes, struct mq_attr *mqstat)
426 { }
427 static inline int audit_log_bprm_fcaps(struct linux_binprm *bprm,
428                                        const struct cred *new,
429                                        const struct cred *old)
430 {
431         return 0;
432 }
433 static inline void audit_log_capset(const struct cred *new,
434                                     const struct cred *old)
435 { }
436 static inline void audit_mmap_fd(int fd, int flags)
437 { }
438 static inline void audit_ptrace(struct task_struct *t)
439 { }
440 #define audit_n_rules 0
441 #define audit_signals 0
442 #endif /* CONFIG_AUDITSYSCALL */
443
444 static inline bool audit_loginuid_set(struct task_struct *tsk)
445 {
446         return uid_valid(audit_get_loginuid(tsk));
447 }
448
449 #ifdef CONFIG_AUDIT
450 /* These are defined in audit.c */
451                                 /* Public API */
452 extern __printf(4, 5)
453 void audit_log(struct audit_context *ctx, gfp_t gfp_mask, int type,
454                const char *fmt, ...);
455
456 extern struct audit_buffer *audit_log_start(struct audit_context *ctx, gfp_t gfp_mask, int type);
457 extern __printf(2, 3)
458 void audit_log_format(struct audit_buffer *ab, const char *fmt, ...);
459 extern void                 audit_log_end(struct audit_buffer *ab);
460 extern int                  audit_string_contains_control(const char *string,
461                                                           size_t len);
462 extern void                 audit_log_n_hex(struct audit_buffer *ab,
463                                           const unsigned char *buf,
464                                           size_t len);
465 extern void                 audit_log_n_string(struct audit_buffer *ab,
466                                                const char *buf,
467                                                size_t n);
468 extern void                 audit_log_n_untrustedstring(struct audit_buffer *ab,
469                                                         const char *string,
470                                                         size_t n);
471 extern void                 audit_log_untrustedstring(struct audit_buffer *ab,
472                                                       const char *string);
473 extern void                 audit_log_d_path(struct audit_buffer *ab,
474                                              const char *prefix,
475                                              const struct path *path);
476 extern void                 audit_log_key(struct audit_buffer *ab,
477                                           char *key);
478 extern void                 audit_log_link_denied(const char *operation,
479                                                   struct path *link);
480 extern void                 audit_log_lost(const char *message);
481 #ifdef CONFIG_SECURITY
482 extern void                 audit_log_secctx(struct audit_buffer *ab, u32 secid);
483 #else
484 static inline void          audit_log_secctx(struct audit_buffer *ab, u32 secid)
485 { }
486 #endif
487
488 extern int audit_log_task_context(struct audit_buffer *ab);
489 extern void audit_log_task_info(struct audit_buffer *ab,
490                                 struct task_struct *tsk);
491
492 extern int                  audit_update_lsm_rules(void);
493
494                                 /* Private API (for audit.c only) */
495 extern int audit_filter_user(int type);
496 extern int audit_filter_type(int type);
497 extern int audit_rule_change(int type, __u32 portid, int seq,
498                                 void *data, size_t datasz);
499 extern int audit_list_rules_send(struct sk_buff *request_skb, int seq);
500
501 extern u32 audit_enabled;
502 #else /* CONFIG_AUDIT */
503 static inline __printf(4, 5)
504 void audit_log(struct audit_context *ctx, gfp_t gfp_mask, int type,
505                const char *fmt, ...)
506 { }
507 static inline struct audit_buffer *audit_log_start(struct audit_context *ctx,
508                                                    gfp_t gfp_mask, int type)
509 {
510         return NULL;
511 }
512 static inline __printf(2, 3)
513 void audit_log_format(struct audit_buffer *ab, const char *fmt, ...)
514 { }
515 static inline void audit_log_end(struct audit_buffer *ab)
516 { }
517 static inline void audit_log_n_hex(struct audit_buffer *ab,
518                                    const unsigned char *buf, size_t len)
519 { }
520 static inline void audit_log_n_string(struct audit_buffer *ab,
521                                       const char *buf, size_t n)
522 { }
523 static inline void  audit_log_n_untrustedstring(struct audit_buffer *ab,
524                                                 const char *string, size_t n)
525 { }
526 static inline void audit_log_untrustedstring(struct audit_buffer *ab,
527                                              const char *string)
528 { }
529 static inline void audit_log_d_path(struct audit_buffer *ab,
530                                     const char *prefix,
531                                     const struct path *path)
532 { }
533 static inline void audit_log_key(struct audit_buffer *ab, char *key)
534 { }
535 static inline void audit_log_link_denied(const char *string,
536                                          const struct path *link)
537 { }
538 static inline void audit_log_secctx(struct audit_buffer *ab, u32 secid)
539 { }
540 static inline int audit_log_task_context(struct audit_buffer *ab)
541 {
542         return 0;
543 }
544 static inline void audit_log_task_info(struct audit_buffer *ab,
545                                        struct task_struct *tsk)
546 { }
547 #define audit_enabled 0
548 #endif /* CONFIG_AUDIT */
549 static inline void audit_log_string(struct audit_buffer *ab, const char *buf)
550 {
551         audit_log_n_string(ab, buf, strlen(buf));
552 }
553
554 #endif