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 */