- PL2545 WAR: disable CKRM numtasks controller
[linux-2.6.git] / kernel / ckrm / ckrm_null_class.c
1 /* kernel/ckrm/ckrm_null_class.c - NULL TaskClass controller for CKRM
2  *
3  * Copyright (C) Haoqiang Zheng,     IBM Corp. 2004
4  *           (C) Hubertus Franke,    IBM Corp. 2004
5  *
6  * Copyright (C) Marc E. Fiuczynski, Princeton University 2005
7  *               Adapted from ckrm_cpu_class.c.
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  */
15 #include <linux/module.h>
16 #include <linux/init.h>
17 #include <linux/slab.h>
18 #include <asm/errno.h>
19 #include <linux/ckrm_events.h>
20 #include <linux/ckrm_rc.h>
21 #include <linux/ckrm_tc.h>
22 #include <linux/ckrm_classqueue.h>
23 #include <linux/seq_file.h>
24
25 #define CKRM_NULL_CLASS_MAGIC 0xdeadbeef
26
27 static struct ckrm_res_ctlr null_rcbs;
28
29 /*
30  * manages the class status
31  * there should be only one instance of this object for each class in the whole system  
32  */
33 struct ckrm_null_class {
34         struct ckrm_core_class *core;
35         struct ckrm_core_class *parent;
36         struct ckrm_shares shares;
37         spinlock_t cnt_lock;    // always grab parent's lock first and then child's
38         unsigned long magic;    //for debugging
39 };
40
41 /*
42  *  initialize a class object and its local queues
43  */
44 static void init_null_class(struct ckrm_null_class *cls,ckrm_shares_t* shares) 
45 {
46         cls->shares = *shares;
47         cls->cnt_lock = SPIN_LOCK_UNLOCKED;
48         cls->magic = CKRM_NULL_CLASS_MAGIC;
49 }
50
51 static inline void set_default_share(ckrm_shares_t *shares)
52 {
53         shares->my_guarantee     = 0;
54         shares->total_guarantee  = CKRM_SHARE_DFLT_TOTAL_GUARANTEE;
55         shares->unused_guarantee = CKRM_SHARE_DFLT_TOTAL_GUARANTEE;
56         shares->my_limit         = CKRM_SHARE_DFLT_MAX_LIMIT;
57         shares->max_limit        = CKRM_SHARE_DFLT_MAX_LIMIT;
58         shares->cur_max_limit    = 0;
59 }
60
61 static inline int valid_null_class(struct ckrm_null_class * cls)
62 {
63         return (cls && cls->magic == CKRM_NULL_CLASS_MAGIC);
64 }
65
66
67 static struct ckrm_null_class * ckrm_get_null_class(struct ckrm_core_class *core)
68 {
69         struct ckrm_null_class * cls;
70         cls = ckrm_get_res_class(core, null_rcbs.resid, struct ckrm_null_class);
71         if (valid_null_class(cls))
72                 return cls;
73         else
74                 return NULL;
75 }
76
77
78 static struct ckrm_null_class default_null_class_obj;
79
80 static struct ckrm_null_class * get_default_null_class(void) {
81         return (&default_null_class_obj);
82 }
83
84
85 static void* ckrm_alloc_null_class(struct ckrm_core_class *core, struct ckrm_core_class *parent) 
86 {               
87         struct ckrm_null_class *cls;
88
89         if (! parent) /*root class*/
90                 cls =  get_default_null_class();
91         else
92                 cls = (struct ckrm_null_class *) kmalloc(sizeof(struct ckrm_null_class),GFP_ATOMIC);
93
94         if (cls) {
95                 ckrm_shares_t shares;           
96                 if ((! parent) && (core)) { 
97                         /*
98                          * the default class is already initialized
99                          * so only update the core structure
100                          */
101                         cls->core = core;                       
102                 } else {
103                         set_default_share(&shares);
104                         init_null_class(cls,&shares);
105                         cls->core = core;
106                         cls->parent = parent;                   
107                 }
108         } else
109                 printk(KERN_ERR"alloc_null_class failed\n");
110
111         return cls;
112 }               
113
114 /*
115  * hzheng: this is not a stable implementation
116  *         need to check race condition issue here
117  */             
118 static void ckrm_free_null_class(void *my_res) 
119 {                       
120         struct ckrm_null_class *cls = my_res, *parres, *childres;
121         ckrm_core_class_t *child = NULL;
122         int maxlimit;
123
124         if (!cls) 
125                 return;
126
127         /*the default class can't be freed*/
128         if (cls == get_default_null_class()) 
129                 return;
130
131         // Assuming there will be no children when this function is called
132         parres = ckrm_get_null_class(cls->parent);
133
134         // return child's limit/guarantee to parent node
135         spin_lock(&parres->cnt_lock);
136         child_guarantee_changed(&parres->shares, cls->shares.my_guarantee, 0);
137
138         // run thru parent's children and get the new max_limit of the parent
139         ckrm_lock_hier(parres->core);
140         maxlimit = 0;
141         while ((child = ckrm_get_next_child(parres->core, child)) != NULL) {
142                 childres = ckrm_get_null_class(child);
143                 if (maxlimit < childres->shares.my_limit) {
144                         maxlimit = childres->shares.my_limit;
145                 }
146         }
147         ckrm_unlock_hier(parres->core);
148         if (parres->shares.cur_max_limit < maxlimit) {
149                 parres->shares.cur_max_limit = maxlimit;
150         }
151
152         spin_unlock(&parres->cnt_lock);
153         kfree(cls);
154 }                               
155
156 /*
157  *  the system will adjust to the new share automatically  
158  */                     
159 static int ckrm_null_set_share(void *my_res, struct ckrm_shares *new_share) 
160 {       
161         struct ckrm_null_class *parres, *cls = my_res;
162         struct ckrm_shares *cur = &cls->shares, *par;
163         int rc = -EINVAL;
164
165         if (!cls)
166                 return rc;
167
168         if (cls->parent) {
169                 parres = ckrm_get_null_class(cls->parent);
170                 spin_lock(&parres->cnt_lock);
171                 spin_lock(&cls->cnt_lock);
172                 par = &parres->shares;
173         } else {
174                 spin_lock(&cls->cnt_lock);
175                 par = NULL;
176                 parres = NULL;
177         }
178
179         /*
180          * hzheng: CKRM_SHARE_DONTCARE should be handled
181          */
182         if (new_share->my_guarantee == CKRM_SHARE_DONTCARE)
183                 new_share->my_guarantee = 0;
184
185         rc = set_shares(new_share, cur, par);
186         if (cur->my_limit == CKRM_SHARE_DONTCARE)
187                 cur->my_limit = cur->max_limit;
188
189
190         spin_unlock(&cls->cnt_lock);
191         if (cls->parent) {
192                 spin_unlock(&parres->cnt_lock);
193         }
194
195         return rc;
196 }                                                       
197                         
198 static int ckrm_null_get_share(void *my_res,
199                               struct ckrm_shares *shares)
200 {                       
201         struct ckrm_null_class *cls = my_res;
202
203         if (!cls)
204                 return -EINVAL;
205         *shares = cls->shares;
206         return 0;
207 }                               
208
209 static int ckrm_null_get_stats(void *my_res, struct seq_file * sfile)
210 {
211         struct ckrm_null_class *cls = my_res;
212
213         if (!cls) 
214                 return -EINVAL;
215
216         seq_printf(sfile, "-------- Null Class Status Start---------\n");
217         seq_printf(sfile, "Share:\n\tgrt= %d limit= %d total_grt= %d max_limit= %d\n",
218                    cls->shares.my_guarantee,
219                    cls->shares.my_limit,
220                    cls->shares.total_guarantee,
221                    cls->shares.max_limit);
222         seq_printf(sfile, "\tunused_grt= %d cur_max_limit= %d\n",
223                    cls->shares.unused_guarantee,
224                    cls->shares.cur_max_limit);
225
226         seq_printf(sfile, "-------- Null Class Status END ---------\n");
227
228         return 0;
229 }
230
231 /*
232  * task will remain in the same null but on a different local runqueue
233  */
234 static void ckrm_null_change_class(void *task, void *old, void *new)
235 {               
236         /*sanity checking*/
237         if (!task || ! old || !new)
238                 return; 
239
240         /* hook to controller */
241 }                                                       
242
243 /*dummy function, not used*/
244 static int ckrm_null_show_config(void *my_res, struct seq_file *sfile)
245 {
246         struct ckrm_null_class *cls = my_res;
247
248         if (!cls) 
249                 return -EINVAL;
250
251         seq_printf(sfile, "cls=%s,parameter=somevalue\n","ckrm_null class");
252         return 0;
253 }
254
255 /*dummy function, not used*/
256 static int ckrm_null_set_config(void *my_res, const char *cfgstr)
257 {
258         struct ckrm_nullclass *cls = my_res;
259
260         if (!cls) 
261                 return -EINVAL;
262         printk(KERN_DEBUG "ckrm_null config='%s'\n",cfgstr);
263         return 0;
264 }
265         
266 static struct ckrm_res_ctlr null_rcbs = {
267         .res_name          = "null",
268         .res_hdepth        = 1,
269         .resid             = -1,
270         .res_alloc         = ckrm_alloc_null_class,
271         .res_free          = ckrm_free_null_class,
272         .set_share_values  = ckrm_null_set_share,
273         .get_share_values  = ckrm_null_get_share,
274         .get_stats         = ckrm_null_get_stats,
275         .show_config       = ckrm_null_show_config,
276         .set_config        = ckrm_null_set_config,
277         .change_resclass   = ckrm_null_change_class,
278 };
279
280 int __init init_ckrm_null_res(void)
281 {
282         struct ckrm_classtype *clstype;
283         int resid = null_rcbs.resid;
284
285         clstype = ckrm_find_classtype_by_name("taskclass");
286         if (clstype == NULL) {
287                 printk(KERN_INFO" Unknown ckrm classtype<taskclass>");
288                 return -ENOENT;
289         }
290
291         /* Initialize default class obj before registering with core */
292         ckrm_alloc_null_class(NULL,NULL);
293
294         if (resid == -1) { /*not registered */
295                 resid = ckrm_register_res_ctlr(clstype,&null_rcbs);
296                 printk(KERN_DEBUG "........init_ckrm_null_res , resid= %d\n",resid);
297         }
298         return 0;
299 }
300
301 void __exit exit_ckrm_null_res(void)
302 {
303         ckrm_unregister_res_ctlr(&null_rcbs);
304         null_rcbs.resid = -1;
305 }
306
307 module_init(init_ckrm_null_res)
308 module_exit(exit_ckrm_null_res)