14cfbe33a8dcd631040f842bc2f385b4a158c0f3
[linux-2.6.git] / include / linux / ckrm_events.h
1 /*
2  * ckrm_events.h - Class-based Kernel Resource Management (CKRM)
3  *                 event handling
4  *
5  * Copyright (C) Hubertus Franke, IBM Corp. 2003,2004
6  *           (C) Shailabh Nagar,  IBM Corp. 2003
7  *           (C) Chandra Seetharaman, IBM Corp. 2003
8  * 
9  * 
10  * Provides a base header file including macros and basic data structures.
11  *
12  * Latest version, more details at http://ckrm.sf.net
13  * 
14  * This program is free software; you can redistribute it and/or modify it
15  * under the terms of version 2.1 of the GNU Lesser General Public License
16  * as published by the Free Software Foundation.
17  *
18  * This program is distributed in the hope that it would be useful, but
19  * WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
21  *
22  */
23
24 /*
25  * Changes
26  *
27  * 28 Aug 2003
28  *        Created.
29  * 06 Nov 2003
30  *        Made modifications to suit the new RBCE module.
31  * 10 Nov 2003
32  *        Added callbacks_active and surrounding logic. Added task paramter
33  *        for all CE callbacks.
34  * 19 Nov 2004
35  *        New Event callback structure
36  */
37
38 #ifndef _LINUX_CKRM_EVENTS_H
39 #define _LINUX_CKRM_EVENTS_H
40
41 #ifdef CONFIG_CKRM
42
43 /*
44  * Data structure and function to get the list of registered 
45  * resource controllers.
46  */
47
48 /*
49  * CKRM defines a set of events at particular points in the kernel
50  * at which callbacks registered by various class types are called
51  */
52
53 enum ckrm_event {
54         /*
55          * we distinguish these events types:
56          *
57          * (a) CKRM_LATCHABLE_EVENTS
58          *      events can be latched for event callbacks by classtypes
59          *
60          * (b) CKRM_NONLATACHBLE_EVENTS
61          *     events can not be latched but can be used to call classification
62          * 
63          * (c) event that are used for notification purposes
64          *     range: [ CKRM_EVENT_CANNOT_CLASSIFY .. )
65          */
66
67         /* events (a) */
68
69         CKRM_LATCHABLE_EVENTS,
70
71         CKRM_EVENT_NEWTASK = CKRM_LATCHABLE_EVENTS,
72         CKRM_EVENT_FORK,
73         CKRM_EVENT_EXIT,
74         CKRM_EVENT_EXEC,
75         CKRM_EVENT_UID,
76         CKRM_EVENT_GID,
77         CKRM_EVENT_XID,
78         CKRM_EVENT_LOGIN,
79         CKRM_EVENT_USERADD,
80         CKRM_EVENT_USERDEL,
81         CKRM_EVENT_LISTEN_START,
82         CKRM_EVENT_LISTEN_STOP,
83         CKRM_EVENT_APPTAG,
84
85         /* events (b) */
86
87         CKRM_NONLATCHABLE_EVENTS,
88
89         CKRM_EVENT_RECLASSIFY = CKRM_NONLATCHABLE_EVENTS,
90
91         /* events (c) */
92
93         CKRM_NOTCLASSIFY_EVENTS,
94
95         CKRM_EVENT_MANUAL = CKRM_NOTCLASSIFY_EVENTS,
96
97         CKRM_NUM_EVENTS
98 };
99 #endif
100
101 #ifdef __KERNEL__
102 #ifdef CONFIG_CKRM
103
104 /*
105  * CKRM event callback specification for the classtypes or resource controllers 
106  *   typically an array is specified using CKRM_EVENT_SPEC terminated with 
107  *   CKRM_EVENT_SPEC_LAST and then that array is registered using
108  *   ckrm_register_event_set.
109  *   Individual registration of event_cb is also possible
110  */
111
112 typedef void (*ckrm_event_cb) (void *arg);
113
114 struct ckrm_hook_cb {
115         ckrm_event_cb fct;
116         struct ckrm_hook_cb *next;
117 };
118
119 struct ckrm_event_spec {
120         enum ckrm_event ev;
121         struct ckrm_hook_cb cb;
122 };
123
124 #define CKRM_EVENT_SPEC(EV,FCT) { CKRM_EVENT_##EV, \
125                                         { (ckrm_event_cb)FCT, NULL } }
126
127 int ckrm_register_event_set(struct ckrm_event_spec especs[]);
128 int ckrm_unregister_event_set(struct ckrm_event_spec especs[]);
129 int ckrm_register_event_cb(enum ckrm_event ev, struct ckrm_hook_cb *cb);
130 int ckrm_unregister_event_cb(enum ckrm_event ev, struct ckrm_hook_cb *cb);
131
132 extern void ckrm_invoke_event_cb_chain(enum ckrm_event ev, void *arg);
133
134 #define CKRM_DEF_CB(EV,fct)                                     \
135 static inline void ckrm_cb_##fct(void)                          \
136 {                                                               \
137          ckrm_invoke_event_cb_chain(CKRM_EVENT_##EV,NULL);      \
138 }
139
140 #define CKRM_DEF_CB_ARG(EV,fct,argtp)                                   \
141 static inline void ckrm_cb_##fct(argtp arg)                             \
142 {                                                                       \
143          ckrm_invoke_event_cb_chain(CKRM_EVENT_##EV,(void*)arg);        \
144 }
145
146 #else /* !CONFIG_CKRM */
147
148 #define CKRM_DEF_CB(EV,fct)                     \
149 static inline void ckrm_cb_##fct(void)  { }
150
151 #define CKRM_DEF_CB_ARG(EV,fct,argtp)           \
152 static inline void ckrm_cb_##fct(argtp arg) { }
153
154 #endif /* CONFIG_CKRM */
155
156 /*
157  *   define the CKRM event functions 
158  *               EVENT          FCT           ARG         
159  */
160
161 /* forward declarations for function arguments */
162 struct task_struct;
163 struct sock;
164 struct user_struct;
165
166 CKRM_DEF_CB_ARG(FORK, fork, struct task_struct *);
167 CKRM_DEF_CB_ARG(EXEC, exec, const char *);
168 CKRM_DEF_CB(UID, uid);
169 CKRM_DEF_CB(GID, gid);
170 CKRM_DEF_CB_ARG(XID, xid, struct task_struct *);
171 CKRM_DEF_CB(APPTAG, apptag);
172 CKRM_DEF_CB(LOGIN, login);
173 CKRM_DEF_CB_ARG(USERADD, useradd, struct user_struct *);
174 CKRM_DEF_CB_ARG(USERDEL, userdel, struct user_struct *);
175 CKRM_DEF_CB_ARG(LISTEN_START, listen_start, struct sock *);
176 CKRM_DEF_CB_ARG(LISTEN_STOP, listen_stop, struct sock *);
177
178 /* some other functions required */
179 #ifdef CONFIG_CKRM
180 extern void ckrm_init(void);
181 extern void ckrm_cb_newtask(struct task_struct *);
182 extern void ckrm_cb_exit(struct task_struct *);
183 #else
184 #define ckrm_init()             do { } while (0)
185 #define ckrm_cb_newtask(x)      do { } while (0)
186 #define ckrm_cb_exit(x)         do { } while (0)
187 #endif
188
189 extern int get_exe_path_name(struct task_struct *, char *, int);
190
191 #endif /* __KERNEL__ */
192 #endif /* _LINUX_CKRM_EVENTS_H */