From e435eaa19f81fc419ee65b31efea3bb8785ce64a Mon Sep 17 00:00:00 2001 From: Marc Fiuczynski Date: Thu, 4 Nov 2004 12:18:26 +0000 Subject: [PATCH] changed printk's to use KERN_DEBUG, KERN_ERR, or KERN_WARNING. --- fs/rcfs/magic.c | 247 ++++++++------- fs/rcfs/rootdir.c | 119 ++++---- fs/rcfs/super.c | 154 +++++----- include/linux/ckrm_mem_inline.h | 2 +- kernel/ckrm/ckrm.c | 526 +++++++++++++++++--------------- kernel/ckrm/ckrm_cpu_class.c | 4 +- kernel/ckrm/ckrm_cpu_monitor.c | 6 +- kernel/ckrm/ckrm_laq.c | 2 +- kernel/ckrm/ckrm_mem.c | 4 +- kernel/ckrm/ckrm_numtasks.c | 4 +- kernel/ckrm/ckrm_sockc.c | 296 +++++++++--------- kernel/ckrm/ckrm_tc.c | 16 +- kernel/ckrm/rbce/bitvector.h | 6 +- kernel/ckrm/rbce/rbce_fs.c | 51 ++-- kernel/ckrm/rbce/rbcemod.c | 40 +-- kernel/ckrm/rbce/rbcemod_ext.c | 28 +- kernel/ckrm/rbce/token.c | 2 +- 17 files changed, 792 insertions(+), 715 deletions(-) diff --git a/fs/rcfs/magic.c b/fs/rcfs/magic.c index ad92a07a8..1cada33e5 100644 --- a/fs/rcfs/magic.c +++ b/fs/rcfs/magic.c @@ -29,7 +29,6 @@ #include #include #include -#include #include #include #include @@ -41,9 +40,6 @@ #include - - - /****************************************************** * Macros * @@ -51,12 +47,12 @@ * *****************************************************/ - #define MAGIC_SHOW(FUNC) \ static int \ FUNC ## _show(struct seq_file *s, void *v) \ { \ - int rc=0; \ + int rc=0; \ + ssize_t precnt; \ ckrm_core_class_t *core ; \ \ core = (ckrm_core_class_t *) \ @@ -65,13 +61,14 @@ FUNC ## _show(struct seq_file *s, void *v) \ if (!ckrm_is_core_valid(core)) { \ return -EINVAL; \ } \ - \ + precnt = s->count ; \ if (core->classtype->show_ ## FUNC) \ rc = (* core->classtype->show_ ## FUNC)(core, s); \ - \ + \ + if (s->count == precnt) \ + seq_printf(s, "No data to display\n"); \ return rc; \ -}; - +}; #define MAGIC_OPEN(FUNC) \ static int \ @@ -86,25 +83,24 @@ FUNC ## _open(struct inode *inode, struct file *file) \ ret = single_open(file,FUNC ## _show, (void *)ri); \ } \ return ret; \ -} - +} + #define MAGIC_CLOSE(FUNC) \ static int \ FUNC ## _close(struct inode *inode, struct file *file) \ { \ return single_release(inode,file); \ } - - #define MAGIC_PARSE(FUNC) \ static int \ FUNC ## _parse(char *options, char **resstr, char **otherstr) \ { \ char *p; \ + *resstr = NULL; \ \ if (!options) \ - return 1; \ + return 0; \ \ while ((p = strsep(&options, ",")) != NULL) { \ substring_t args[MAX_OPT_ARGS]; \ @@ -117,6 +113,19 @@ FUNC ## _parse(char *options, char **resstr, char **otherstr) \ switch (token) { \ case FUNC ## _res_type: \ *resstr = match_strdup(args); \ + if (!strcmp(#FUNC, "config")) { \ + char *str = p + strlen(p) + 1; \ + *otherstr = kmalloc(strlen(str) + 1, \ + GFP_KERNEL); \ + if (*otherstr == NULL) { \ + kfree(*resstr); \ + *resstr = NULL; \ + return 0; \ + } else { \ + strcpy(*otherstr, str); \ + return 1; \ + } \ + } \ break; \ case FUNC ## _str: \ *otherstr = match_strdup(args); \ @@ -125,7 +134,7 @@ FUNC ## _parse(char *options, char **resstr, char **otherstr) \ return 0; \ } \ } \ - return 1; \ + return (*resstr != NULL); \ } #define MAGIC_WRITE(FUNC,CLSTYPEFUN) \ @@ -180,8 +189,7 @@ FUNC ## _write_out: \ kfree(resname); \ return rc ? rc : count; \ } - - + #define MAGIC_RD_FILEOPS(FUNC) \ struct file_operations FUNC ## _fileops = { \ .open = FUNC ## _open, \ @@ -191,7 +199,6 @@ struct file_operations FUNC ## _fileops = { \ }; \ EXPORT_SYMBOL(FUNC ## _fileops); - #define MAGIC_RDWR_FILEOPS(FUNC) \ struct file_operations FUNC ## _fileops = { \ .open = FUNC ## _open, \ @@ -202,95 +209,122 @@ struct file_operations FUNC ## _fileops = { \ }; \ EXPORT_SYMBOL(FUNC ## _fileops); - -/******************************************************************************** - * Target +/****************************************************************************** + * Shared function used by Target / Reclassify * - * pseudo file for manually reclassifying members to a class * - *******************************************************************************/ + *****************************************************************************/ #define TARGET_MAX_INPUT_SIZE 100 static ssize_t -target_write(struct file *file, const char __user *buf, - size_t count, loff_t *ppos) +target_reclassify_write(struct file *file, const char __user * buf, + size_t count, loff_t * ppos, int manual) { - struct rcfs_inode_info *ri= RCFS_I(file->f_dentry->d_inode); + struct rcfs_inode_info *ri = RCFS_I(file->f_dentry->d_inode); char *optbuf; int rc = -EINVAL; ckrm_classtype_t *clstype; - if ((ssize_t) count < 0 || (ssize_t) count > TARGET_MAX_INPUT_SIZE) return -EINVAL; - + if (!access_ok(VERIFY_READ, buf, count)) return -EFAULT; - + down(&(ri->vfs_inode.i_sem)); - + optbuf = kmalloc(TARGET_MAX_INPUT_SIZE, GFP_KERNEL); __copy_from_user(optbuf, buf, count); - if (optbuf[count-1] == '\n') - optbuf[count-1]='\0'; + if (optbuf[count - 1] == '\n') + optbuf[count - 1] = '\0'; clstype = ri->core->classtype; if (clstype->forced_reclassify) - rc = (* clstype->forced_reclassify)(ri->core,optbuf); + rc = (*clstype->forced_reclassify) (manual ? ri->core: NULL, optbuf); up(&(ri->vfs_inode.i_sem)); kfree(optbuf); - return !rc ? count : rc; + return (!rc ? count : rc); } +/****************************************************************************** + * Target + * + * pseudo file for manually reclassifying members to a class + * + *****************************************************************************/ + +static ssize_t +target_write(struct file *file, const char __user * buf, + size_t count, loff_t * ppos) +{ + return target_reclassify_write(file,buf,count,ppos,1); +} + struct file_operations target_fileops = { - .write = target_write, + .write = target_write, }; + EXPORT_SYMBOL(target_fileops); +/****************************************************************************** + * Reclassify + * + * pseudo file for reclassification of an object through CE + * + *****************************************************************************/ +static ssize_t +reclassify_write(struct file *file, const char __user * buf, + size_t count, loff_t * ppos) +{ + return target_reclassify_write(file,buf,count,ppos,0); +} -/******************************************************************************** +struct file_operations reclassify_fileops = { + .write = reclassify_write, +}; + +EXPORT_SYMBOL(reclassify_fileops); + +/****************************************************************************** * Config * * Set/get configuration parameters of a class. * - *******************************************************************************/ + *****************************************************************************/ /* Currently there are no per-class config parameters defined. * Use existing code as a template */ - + #define config_max_input_size 300 enum config_token_t { - config_str, config_res_type, config_err + config_str, config_res_type, config_err }; static match_table_t config_tokens = { - {config_res_type,"res=%s"}, - {config_str, "config=%s"}, - {config_err, NULL}, + {config_res_type, "res=%s"}, + {config_err, NULL}, }; - MAGIC_PARSE(config); -MAGIC_WRITE(config,set_config); +MAGIC_WRITE(config, set_config); MAGIC_SHOW(config); MAGIC_OPEN(config); MAGIC_CLOSE(config); MAGIC_RDWR_FILEOPS(config); - -/******************************************************************************** +/****************************************************************************** * Members * * List members of a class * - *******************************************************************************/ + *****************************************************************************/ MAGIC_SHOW(members); MAGIC_OPEN(members); @@ -298,46 +332,42 @@ MAGIC_CLOSE(members); MAGIC_RD_FILEOPS(members); - -/******************************************************************************** +/****************************************************************************** * Stats * * Get/reset class statistics * No standard set of stats defined. Each resource controller chooses * its own set of statistics to maintain and export. * - *******************************************************************************/ + *****************************************************************************/ #define stats_max_input_size 50 enum stats_token_t { - stats_res_type, stats_str,stats_err + stats_res_type, stats_str, stats_err }; static match_table_t stats_tokens = { - {stats_res_type,"res=%s"}, + {stats_res_type, "res=%s"}, {stats_str, NULL}, - {stats_err, NULL}, + {stats_err, NULL}, }; - MAGIC_PARSE(stats); -MAGIC_WRITE(stats,reset_stats); +MAGIC_WRITE(stats, reset_stats); MAGIC_SHOW(stats); MAGIC_OPEN(stats); MAGIC_CLOSE(stats); MAGIC_RDWR_FILEOPS(stats); - -/******************************************************************************** +/****************************************************************************** * Shares * * Set/get shares of a taskclass. * Share types and semantics are defined by rcfs and ckrm core * - *******************************************************************************/ - + *****************************************************************************/ #define SHARES_MAX_INPUT_SIZE 300 @@ -348,20 +378,19 @@ MAGIC_RDWR_FILEOPS(stats); the remaining ones are for token matching purposes */ enum share_token_t { - MY_GUAR, MY_LIM, TOT_GUAR, MAX_LIM, SHARE_RES_TYPE, SHARE_ERR + MY_GUAR, MY_LIM, TOT_GUAR, MAX_LIM, SHARE_RES_TYPE, SHARE_ERR }; /* Token matching for parsing input to this magic file */ static match_table_t shares_tokens = { {SHARE_RES_TYPE, "res=%s"}, - {MY_GUAR, "guarantee=%d"}, - {MY_LIM, "limit=%d"}, - {TOT_GUAR,"total_guarantee=%d"}, + {MY_GUAR, "guarantee=%d"}, + {MY_LIM, "limit=%d"}, + {TOT_GUAR, "total_guarantee=%d"}, {MAX_LIM, "max_limit=%d"}, - {SHARE_ERR, NULL} + {SHARE_ERR, NULL} }; - static int shares_parse(char *options, char **resstr, struct ckrm_shares *shares) { @@ -370,12 +399,12 @@ shares_parse(char *options, char **resstr, struct ckrm_shares *shares) if (!options) return 1; - + while ((p = strsep(&options, ",")) != NULL) { - + substring_t args[MAX_OPT_ARGS]; int token; - + if (!*p) continue; @@ -410,12 +439,11 @@ shares_parse(char *options, char **resstr, struct ckrm_shares *shares) } return 1; -} - +} static ssize_t -shares_write(struct file *file, const char __user *buf, - size_t count, loff_t *ppos) +shares_write(struct file *file, const char __user * buf, + size_t count, loff_t * ppos) { struct inode *inode = file->f_dentry->d_inode; struct rcfs_inode_info *ri; @@ -423,7 +451,7 @@ shares_write(struct file *file, const char __user *buf, int rc = 0; struct ckrm_core_class *core; int done; - char *resname; + char *resname = NULL; struct ckrm_shares newshares = { CKRM_SHARE_UNCHANGED, @@ -436,24 +464,29 @@ shares_write(struct file *file, const char __user *buf, if ((ssize_t) count < 0 || (ssize_t) count > SHARES_MAX_INPUT_SIZE) return -EINVAL; - + if (!access_ok(VERIFY_READ, buf, count)) return -EFAULT; ri = RCFS_I(file->f_dentry->d_parent->d_inode); - if (!ri || !ckrm_is_core_valid((ckrm_core_class_t *)(ri->core))) { + if (!ri || !ckrm_is_core_valid((ckrm_core_class_t *) (ri->core))) { printk(KERN_ERR "shares_write: Error accessing core class\n"); return -EFAULT; } - + down(&inode->i_sem); - - core = ri->core; + + core = ri->core; optbuf = kmalloc(SHARES_MAX_INPUT_SIZE, GFP_KERNEL); + if (!optbuf) { + up(&inode->i_sem); + return -ENOMEM; + } + __copy_from_user(optbuf, buf, count); - if (optbuf[count-1] == '\n') - optbuf[count-1]='\0'; + if (optbuf[count - 1] == '\n') + optbuf[count - 1] = '\0'; done = shares_parse(optbuf, &resname, &newshares); if (!done) { @@ -463,23 +496,23 @@ shares_write(struct file *file, const char __user *buf, } if (core->classtype->set_shares) { - rc = (*core->classtype->set_shares)(core,resname,&newshares); + rc = (*core->classtype->set_shares) (core, resname, &newshares); if (rc) { - printk(KERN_ERR "shares_write: resctlr share set error\n"); + printk(KERN_ERR + "shares_write: resctlr share set error\n"); goto write_out; } } - - printk(KERN_ERR "Set %s shares to %d %d %d %d\n", + + printk(KERN_DEBUG "Set %s shares to %d %d %d %d\n", resname, - newshares.my_guarantee, - newshares.my_limit, - newshares.total_guarantee, - newshares.max_limit); - - rc = count ; + newshares.my_guarantee, + newshares.my_limit, + newshares.total_guarantee, newshares.max_limit); + + rc = count; -write_out: + write_out: up(&inode->i_sem); kfree(optbuf); @@ -487,49 +520,44 @@ write_out: return rc; } - MAGIC_SHOW(shares); MAGIC_OPEN(shares); MAGIC_CLOSE(shares); MAGIC_RDWR_FILEOPS(shares); - - /* * magic file creation/deletion * */ - -int -rcfs_clear_magic(struct dentry *parent) +int rcfs_clear_magic(struct dentry *parent) { - struct dentry *mftmp, *mfdentry ; + struct dentry *mftmp, *mfdentry; list_for_each_entry_safe(mfdentry, mftmp, &parent->d_subdirs, d_child) { - + if (!rcfs_is_magic(mfdentry)) - continue ; + continue; - if (rcfs_delete_internal(mfdentry)) - printk(KERN_ERR "rcfs_clear_magic: error deleting one\n"); + if (rcfs_delete_internal(mfdentry)) + printk(KERN_ERR + "rcfs_clear_magic: error deleting one\n"); } return 0; - + } -EXPORT_SYMBOL(rcfs_clear_magic); +EXPORT_SYMBOL(rcfs_clear_magic); -int -rcfs_create_magic(struct dentry *parent, struct rcfs_magf magf[], int count) +int rcfs_create_magic(struct dentry *parent, struct rcfs_magf magf[], int count) { int i; struct dentry *mfdentry; - for (i=0; i #include #include -#include #include #include #include @@ -42,43 +40,39 @@ #include - - rbce_eng_callback_t rcfs_eng_callbacks = { NULL, NULL }; -int -rcfs_register_engine(rbce_eng_callback_t *rcbs) +int rcfs_register_engine(rbce_eng_callback_t * rcbs) { if (!rcbs->mkdir || rcfs_eng_callbacks.mkdir) { return -EINVAL; } rcfs_eng_callbacks = *rcbs; + rcfs_engine_regd++; return 0; } -EXPORT_SYMBOL(rcfs_register_engine); - +EXPORT_SYMBOL(rcfs_register_engine); -int -rcfs_unregister_engine(rbce_eng_callback_t *rcbs) +int rcfs_unregister_engine(rbce_eng_callback_t * rcbs) { if (!rcbs->mkdir || !rcfs_eng_callbacks.mkdir || - (rcbs->mkdir != rcfs_eng_callbacks.mkdir)) { + (rcbs->mkdir != rcfs_eng_callbacks.mkdir)) { return -EINVAL; } rcfs_eng_callbacks.mkdir = NULL; rcfs_eng_callbacks.rmdir = NULL; + rcfs_engine_regd--; return 0; } -EXPORT_SYMBOL(rcfs_unregister_engine); - - +EXPORT_SYMBOL(rcfs_unregister_engine); /* rcfs_mkroot - * Create and return a "root" dentry under /rcfs. Also create associated magic files + * Create and return a "root" dentry under /rcfs. + * Also create associated magic files * * @mfdesc: array of rcfs_magf describing root dir and its magic files * @count: number of entries in mfdesc @@ -86,26 +80,25 @@ EXPORT_SYMBOL(rcfs_unregister_engine); * @rootde: output parameter to return the newly created root dentry */ -int -rcfs_mkroot(struct rcfs_magf *mfdesc, int mfcount, struct dentry **rootde) +int rcfs_mkroot(struct rcfs_magf *mfdesc, int mfcount, struct dentry **rootde) { int sz; struct rcfs_magf *rootdesc = &mfdesc[0]; - struct dentry *dentry ; + struct dentry *dentry; struct rcfs_inode_info *rootri; if ((mfcount < 0) || (!mfdesc)) return -EINVAL; - + rootdesc = &mfdesc[0]; - printk("allocating classtype root <%s>\n",rootdesc->name); - dentry = rcfs_create_internal(rcfs_rootde, rootdesc,0); - + printk(KERN_DEBUG "allocating classtype root <%s>\n", rootdesc->name); + dentry = rcfs_create_internal(rcfs_rootde, rootdesc, 0); + if (!dentry) { - printk(KERN_ERR "Could not create %s\n",rootdesc->name); + printk(KERN_ERR "Could not create %s\n", rootdesc->name); return -ENOMEM; - } - + } + rootri = RCFS_I(dentry->d_inode); sz = strlen(rootdesc->name) + strlen(RCFS_ROOT) + 2; rootri->name = kmalloc(sz, GFP_KERNEL); @@ -115,8 +108,8 @@ rcfs_mkroot(struct rcfs_magf *mfdesc, int mfcount, struct dentry **rootde) rcfs_delete_internal(dentry); return -ENOMEM; } - snprintf(rootri->name,sz,"%s/%s",RCFS_ROOT,rootdesc->name); - + snprintf(rootri->name, sz, "%s/%s", RCFS_ROOT, rootdesc->name); + if (rootdesc->i_fop) dentry->d_inode->i_fop = rootdesc->i_fop; if (rootdesc->i_op) @@ -127,41 +120,43 @@ rcfs_mkroot(struct rcfs_magf *mfdesc, int mfcount, struct dentry **rootde) return 0; } -EXPORT_SYMBOL(rcfs_mkroot); +EXPORT_SYMBOL(rcfs_mkroot); -int -rcfs_rmroot(struct dentry *rootde) +int rcfs_rmroot(struct dentry *rootde) { + struct rcfs_inode_info *ri; + if (!rootde) return -EINVAL; rcfs_clear_magic(rootde); - kfree(RCFS_I(rootde->d_inode)->name); + ri = RCFS_I(rootde->d_inode); + kfree(ri->name); + ri->name = NULL; rcfs_delete_internal(rootde); return 0; } -EXPORT_SYMBOL(rcfs_rmroot); +EXPORT_SYMBOL(rcfs_rmroot); -int -rcfs_register_classtype(ckrm_classtype_t *clstype) +int rcfs_register_classtype(ckrm_classtype_t * clstype) { - int rc ; + int rc; struct rcfs_inode_info *rootri; struct rcfs_magf *mfdesc; // Initialize mfdesc, mfcount - clstype->mfdesc = (void *) genmfdesc[clstype->mfidx]->rootmf; - clstype->mfcount = genmfdesc[clstype->mfidx]->rootmflen; + clstype->mfdesc = (void *)genmfdesc[clstype->mfidx]->rootmf; + clstype->mfcount = genmfdesc[clstype->mfidx]->rootmflen; mfdesc = (struct rcfs_magf *)clstype->mfdesc; - + /* rcfs root entry has the same name as the classtype */ - strncpy(mfdesc[0].name,clstype->name,RCFS_MAGF_NAMELEN) ; + strncpy(mfdesc[0].name, clstype->name, RCFS_MAGF_NAMELEN); - rc = rcfs_mkroot(mfdesc,clstype->mfcount, - (struct dentry **)&(clstype->rootde)); + rc = rcfs_mkroot(mfdesc, clstype->mfcount, + (struct dentry **)&(clstype->rootde)); if (rc) return rc; @@ -169,43 +164,43 @@ rcfs_register_classtype(ckrm_classtype_t *clstype) rootri->core = clstype->default_class; clstype->default_class->name = rootri->name; ckrm_core_grab(clstype->default_class); - + // Create magic files under root - if ((rc = rcfs_create_magic(clstype->rootde, &mfdesc[1], - clstype->mfcount-1))) { + if ((rc = rcfs_create_magic(clstype->rootde, &mfdesc[1], + clstype->mfcount - 1))) { kfree(rootri->name); + rootri->name = NULL; rcfs_delete_internal(clstype->rootde); return rc; } return rc; } -EXPORT_SYMBOL(rcfs_register_classtype); +EXPORT_SYMBOL(rcfs_register_classtype); -int -rcfs_deregister_classtype(ckrm_classtype_t *clstype) +int rcfs_deregister_classtype(ckrm_classtype_t * clstype) { int rc; rc = rcfs_rmroot((struct dentry *)clstype->rootde); if (!rc) { - clstype->default_class->name = NULL ; + clstype->default_class->name = NULL; ckrm_core_drop(clstype->default_class); } return rc; } -EXPORT_SYMBOL(rcfs_deregister_classtype); - +EXPORT_SYMBOL(rcfs_deregister_classtype); // Common root and magic file entries. -// root name, root permissions, magic file names and magic file permissions are needed by -// all entities (classtypes and classification engines) existing under the rcfs mount point +// root name, root permissions, magic file names and magic file permissions +// are needed by all entities (classtypes and classification engines) existing +// under the rcfs mount point -// The common sets of these attributes are listed here as a table. Individual classtypes and -// classification engines can simple specify the index into the table to initialize their -// magf entries. +// The common sets of these attributes are listed here as a table. Individual +// classtypes and classification engines can simple specify the index into the +// table to initialize their magf entries. // #ifdef CONFIG_CKRM_TYPE_TASKCLASS @@ -218,8 +213,7 @@ extern struct rcfs_mfdesc sock_mfdesc; // extern struct rcfs_magf rbce_mfdesc; - -struct rcfs_mfdesc *genmfdesc[]={ +struct rcfs_mfdesc *genmfdesc[] = { #ifdef CONFIG_CKRM_TYPE_TASKCLASS &tc_mfdesc, #else @@ -230,15 +224,4 @@ struct rcfs_mfdesc *genmfdesc[]={ #else NULL, #endif -// Create similar entry for RBCE ? -//#ifdef CONFIG_CKRM_CE -// &rbce_mfdesc, -//#else -// NULL, -//#endif - }; - - - - diff --git a/fs/rcfs/super.c b/fs/rcfs/super.c index d0e78c447..f013df226 100644 --- a/fs/rcfs/super.c +++ b/fs/rcfs/super.c @@ -22,11 +22,9 @@ * Created. */ - #include #include #include -#include #include #include #include @@ -42,57 +40,55 @@ #include #include - +#include +#include static kmem_cache_t *rcfs_inode_cachep; - inline struct rcfs_inode_info *RCFS_I(struct inode *inode) { return container_of(inode, struct rcfs_inode_info, vfs_inode); } -EXPORT_SYMBOL(RCFS_I); - +EXPORT_SYMBOL(RCFS_I); -static struct inode * -rcfs_alloc_inode(struct super_block *sb) +static struct inode *rcfs_alloc_inode(struct super_block *sb) { struct rcfs_inode_info *ri; - ri = (struct rcfs_inode_info *) kmem_cache_alloc(rcfs_inode_cachep, - SLAB_KERNEL); + ri = (struct rcfs_inode_info *)kmem_cache_alloc(rcfs_inode_cachep, + SLAB_KERNEL); if (!ri) return NULL; ri->name = NULL; return &ri->vfs_inode; } -static void -rcfs_destroy_inode(struct inode *inode) +static void rcfs_destroy_inode(struct inode *inode) { struct rcfs_inode_info *ri = RCFS_I(inode); kfree(ri->name); - kmem_cache_free(rcfs_inode_cachep, RCFS_I(inode)); + kmem_cache_free(rcfs_inode_cachep, ri); } -static void -rcfs_init_once(void * foo, kmem_cache_t * cachep, unsigned long flags) +static void +rcfs_init_once(void *foo, kmem_cache_t * cachep, unsigned long flags) { - struct rcfs_inode_info *ri = (struct rcfs_inode_info *) foo; + struct rcfs_inode_info *ri = (struct rcfs_inode_info *)foo; - if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) == + if ((flags & (SLAB_CTOR_VERIFY | SLAB_CTOR_CONSTRUCTOR)) == SLAB_CTOR_CONSTRUCTOR) inode_init_once(&ri->vfs_inode); } -int -rcfs_init_inodecache(void) +int rcfs_init_inodecache(void) { rcfs_inode_cachep = kmem_cache_create("rcfs_inode_cache", - sizeof(struct rcfs_inode_info), - 0, SLAB_HWCACHE_ALIGN | SLAB_RECLAIM_ACCOUNT, - rcfs_init_once, NULL); + sizeof(struct rcfs_inode_info), + 0, + SLAB_HWCACHE_ALIGN | + SLAB_RECLAIM_ACCOUNT, + rcfs_init_once, NULL); if (rcfs_inode_cachep == NULL) return -ENOMEM; return 0; @@ -102,31 +98,28 @@ void rcfs_destroy_inodecache(void) { printk(KERN_WARNING "destroy inodecache was called\n"); if (kmem_cache_destroy(rcfs_inode_cachep)) - printk(KERN_INFO "rcfs_inode_cache: not all structures were freed\n"); + printk(KERN_INFO + "rcfs_inode_cache: not all structures were freed\n"); } -struct super_operations rcfs_super_ops = -{ - .alloc_inode = rcfs_alloc_inode, - .destroy_inode = rcfs_destroy_inode, - .statfs = simple_statfs, - .drop_inode = generic_delete_inode, +struct super_operations rcfs_super_ops = { + .alloc_inode = rcfs_alloc_inode, + .destroy_inode = rcfs_destroy_inode, + .statfs = simple_statfs, + .drop_inode = generic_delete_inode, }; - -struct dentry *rcfs_rootde; /* redundant since one can also get it from sb */ +struct dentry *rcfs_rootde; /* redundant; can also get it from sb */ static struct inode *rcfs_root; static struct rcfs_inode_info *rcfs_rootri; -static int rcfs_mounted; - -static int rcfs_fill_super(struct super_block * sb, void * data, int silent) +static int rcfs_fill_super(struct super_block *sb, void *data, int silent) { - struct inode * inode; - struct dentry * root; + struct inode *inode; + struct dentry *root; struct rcfs_inode_info *rootri; struct ckrm_classtype *clstype; - int i,rc; + int i, rc; sb->s_fs_info = NULL; if (rcfs_mounted) { @@ -135,7 +128,7 @@ static int rcfs_fill_super(struct super_block * sb, void * data, int silent) rcfs_mounted++; sb->s_blocksize = PAGE_CACHE_SIZE; - sb->s_blocksize_bits = PAGE_CACHE_SHIFT; + sb->s_blocksize_bits = PAGE_CACHE_SHIFT; sb->s_magic = RCFS_MAGIC; sb->s_op = &rcfs_super_ops; inode = rcfs_get_inode(sb, S_IFDIR | 0755, 0); @@ -150,7 +143,6 @@ static int rcfs_fill_super(struct super_block * sb, void * data, int silent) } sb->s_root = root; - // Link inode and core class rootri = RCFS_I(inode); rootri->name = kmalloc(strlen(RCFS_ROOT) + 1, GFP_KERNEL); @@ -164,20 +156,31 @@ static int rcfs_fill_super(struct super_block * sb, void * data, int silent) rcfs_root = inode; sb->s_fs_info = rcfs_root = inode; - rcfs_rootde = root ; - rcfs_rootri = rootri ; + rcfs_rootde = root; + rcfs_rootri = rootri; // register metatypes - for ( i=0; is_fs_info != rcfs_root) { @@ -206,10 +207,10 @@ rcfs_kill_sb(struct super_block *sb) } rcfs_mounted--; - for ( i=0; i < CKRM_MAX_CLASSTYPES; i++) { + for (i = 0; i < CKRM_MAX_CLASSTYPES; i++) { clstype = ckrm_classtypes[i]; - if (clstype == NULL || clstype->rootde == NULL) + if (clstype == NULL || clstype->rootde == NULL) continue; if ((rc = rcfs_deregister_classtype(clstype))) { @@ -218,8 +219,19 @@ rcfs_kill_sb(struct super_block *sb) // return ; // can also choose to stop here } } - - // do not remove comment block until ce directory issue resolved + + // do pre-umount shutdown needed by CE + // this is distinct from CE deregistration done on rcfs module unload + if (rcfs_engine_regd) { + if (rcfs_eng_callbacks.umnt) + if ((rc = (*rcfs_eng_callbacks.umnt) ())) { + printk(KERN_ERR "Error in CE umnt %d\n", rc); + // return ; until error handling improves + } + } + // Following comment handled by code above; keep nonetheless if it + // can be done better + // // deregister CE with rcfs // Check if loaded // if ce is in one directory /rcfs/ce, @@ -236,23 +248,22 @@ rcfs_kill_sb(struct super_block *sb) generic_shutdown_super(sb); // printk(KERN_ERR "Removed all entries\n"); -} - +} static struct file_system_type rcfs_fs_type = { - .name = "rcfs", - .get_sb = rcfs_get_sb, - .kill_sb = rcfs_kill_sb, + .name = "rcfs", + .get_sb = rcfs_get_sb, + .kill_sb = rcfs_kill_sb, }; struct rcfs_functions my_rcfs_fn = { - .mkroot = rcfs_mkroot, - .rmroot = rcfs_rmroot, - .register_classtype = rcfs_register_classtype, + .mkroot = rcfs_mkroot, + .rmroot = rcfs_rmroot, + .register_classtype = rcfs_register_classtype, .deregister_classtype = rcfs_deregister_classtype, }; -extern struct rcfs_functions rcfs_fn ; +extern struct rcfs_functions rcfs_fn; static int __init init_rcfs_fs(void) { @@ -266,13 +277,16 @@ static int __init init_rcfs_fs(void) if (ret) goto init_cache_err; - rcfs_fn = my_rcfs_fn ; - + rcfs_fn = my_rcfs_fn; + + // Due to tight coupling of this module with ckrm + // do not allow this module to be removed. + try_module_get(THIS_MODULE); return ret; -init_cache_err: + init_cache_err: unregister_filesystem(&rcfs_fs_type); -init_register_err: + init_register_err: return ret; } @@ -283,6 +297,6 @@ static void __exit exit_rcfs_fs(void) } module_init(init_rcfs_fs) -module_exit(exit_rcfs_fs) + module_exit(exit_rcfs_fs) -MODULE_LICENSE("GPL"); + MODULE_LICENSE("GPL"); diff --git a/include/linux/ckrm_mem_inline.h b/include/linux/ckrm_mem_inline.h index 718cc2091..221f93601 100644 --- a/include/linux/ckrm_mem_inline.h +++ b/include/linux/ckrm_mem_inline.h @@ -81,7 +81,7 @@ mem_class_put(ckrm_mem_res_t *cls) } else { name = cls->core->name; } - printk("freeing memclass %p of \n", cls, name); + printk(KERN_DEBUG "freeing memclass %p of \n", cls, name); // BUG_ON(ckrm_memclass_valid(cls)); // kfree(cls); diff --git a/kernel/ckrm/ckrm.c b/kernel/ckrm/ckrm.c index 43d14a8a9..f1cfb268c 100644 --- a/kernel/ckrm/ckrm.c +++ b/kernel/ckrm/ckrm.c @@ -52,12 +52,17 @@ #include #include +rwlock_t ckrm_class_lock = RW_LOCK_UNLOCKED; // protect classlists -rwlock_t ckrm_class_lock = RW_LOCK_UNLOCKED; // protect classlists - -struct rcfs_functions rcfs_fn ; +struct rcfs_functions rcfs_fn; EXPORT_SYMBOL(rcfs_fn); +// rcfs state needed by another module +int rcfs_engine_regd; +EXPORT_SYMBOL(rcfs_engine_regd); + +int rcfs_mounted; +EXPORT_SYMBOL(rcfs_mounted); /************************************************************************** * Helper Functions * @@ -70,33 +75,36 @@ EXPORT_SYMBOL(rcfs_fn); /* * Return TRUE if the given resource is registered. */ -inline unsigned int -is_res_regd(struct ckrm_classtype *clstype, int resid) +inline unsigned int is_res_regd(struct ckrm_classtype *clstype, int resid) { - return ( (resid>=0) && (resid < clstype->max_resid) && - test_bit(resid, &clstype->bit_res_ctlrs) - ); + return ((resid >= 0) && (resid < clstype->max_resid) && + test_bit(resid, &clstype->bit_res_ctlrs) + ); } -struct ckrm_res_ctlr* -ckrm_resctlr_lookup(struct ckrm_classtype *clstype, const char *resname) +struct ckrm_res_ctlr *ckrm_resctlr_lookup(struct ckrm_classtype *clstype, + const char *resname) { int resid = -1; - - for (resid=0; resid < clstype->max_resid; resid++) { + + if (!clstype || !resname) { + return NULL; + } + for (resid = 0; resid < clstype->max_resid; resid++) { if (test_bit(resid, &clstype->bit_res_ctlrs)) { struct ckrm_res_ctlr *rctrl = clstype->res_ctlrs[resid]; - if (!strncmp(resname, rctrl->res_name,CKRM_MAX_RES_NAME)) + if (!strncmp(resname, rctrl->res_name, + CKRM_MAX_RES_NAME)) return rctrl; } } return NULL; } + EXPORT_SYMBOL(ckrm_resctlr_lookup); /* given a classname return the class handle and its classtype*/ -void * -ckrm_classobj(char *classname, int *classTypeID) +void *ckrm_classobj(char *classname, int *classTypeID) { int i; @@ -106,11 +114,11 @@ ckrm_classobj(char *classname, int *classTypeID) } read_lock(&ckrm_class_lock); - for ( i=0 ; iclasses, clslist) { if (core->name && !strcmp(core->name, classname)) { @@ -132,15 +140,14 @@ EXPORT_SYMBOL(ckrm_classobj); * Internal Functions/macros * **************************************************************************/ -static inline void -set_callbacks_active(struct ckrm_classtype *ctype) +static inline void set_callbacks_active(struct ckrm_classtype *ctype) { - ctype->ce_cb_active = ((atomic_read(&ctype->ce_nr_users) > 0) && - (ctype->ce_callbacks.always_callback || (ctype->num_classes > 1))); + ctype->ce_cb_active = ((atomic_read(&ctype->ce_regd) > 0) && + (ctype->ce_callbacks.always_callback + || (ctype->num_classes > 1))); } -int -ckrm_validate_and_grab_core(struct ckrm_core_class *core) +int ckrm_validate_and_grab_core(struct ckrm_core_class *core) { int rc = 0; read_lock(&ckrm_class_lock); @@ -161,46 +168,49 @@ ckrm_validate_and_grab_core(struct ckrm_core_class *core) * * Returns typeId of class on success -errno for failure. */ -int -ckrm_register_engine(const char *typename, ckrm_eng_callback_t *ecbs) +int ckrm_register_engine(const char *typename, ckrm_eng_callback_t * ecbs) { struct ckrm_classtype *ctype; ctype = ckrm_find_classtype_by_name(typename); - if (ctype == NULL) + if (ctype == NULL) return (-ENOENT); - ce_protect(ctype); - if (atomic_read(&ctype->ce_nr_users) != 1) { - // Some engine is acive, deregister it first. - ce_release(ctype); + atomic_inc(&ctype->ce_regd); + + /* another engine registered or trying to register ? */ + if (atomic_read(&ctype->ce_regd) != 1) { + atomic_dec(&ctype->ce_regd); return (-EBUSY); } - - /* we require that either classify and class_delete are set (due to object reference) - * or that notify is set (in case no real classification is supported only notification - * also require that the function pointer be set the momement the mask is non-null + + /* One of the following must be set: + classify, class_delete (due to object reference) or + notify (case where notification supported but not classification) + The function pointer must be set the momement the mask is non-null */ - if ( ! (((ecbs->classify) && (ecbs->class_delete)) || (ecbs->notify)) || - (ecbs->c_interest && ecbs->classify == NULL) || - (ecbs->n_interest && ecbs->notify == NULL) ) - { - ce_release(ctype); - return (-EINVAL); - } - - /* Is any other engine registered for this classtype ? */ - if (ctype->ce_regd) { - ce_release(ctype); + if (!(((ecbs->classify) && (ecbs->class_delete)) || (ecbs->notify)) || + (ecbs->c_interest && ecbs->classify == NULL) || + (ecbs->n_interest && ecbs->notify == NULL)) { + atomic_dec(&ctype->ce_regd); return (-EINVAL); } - - ctype->ce_regd = 1; + ctype->ce_callbacks = *ecbs; set_callbacks_active(ctype); - if (ctype->ce_callbacks.class_add) - (*ctype->ce_callbacks.class_add)(ctype->default_class->name,ctype->default_class); + + if (ctype->ce_callbacks.class_add) { + struct ckrm_core_class *core; + + read_lock(&ckrm_class_lock); + + list_for_each_entry(core, &ctype->classes, clslist) { + (*ctype->ce_callbacks.class_add) (core->name, core, + ctype->typeID); + } + read_unlock(&ckrm_class_lock); + } return ctype->typeID; } @@ -209,24 +219,22 @@ ckrm_register_engine(const char *typename, ckrm_eng_callback_t *ecbs) * * Returns 0 on success -errno for failure. */ -int -ckrm_unregister_engine(const char *typename) +int ckrm_unregister_engine(const char *typename) { struct ckrm_classtype *ctype; ctype = ckrm_find_classtype_by_name(typename); - if (ctype == NULL) + if (ctype == NULL) return (-ENOENT); - ctype->ce_cb_active = 0; + ctype->ce_cb_active = 0; - if (atomic_dec_and_test(&ctype->ce_nr_users) != 1) { + if (atomic_read(&ctype->ce_nr_users) > 1) { // Somebody is currently using the engine, cannot deregister. - atomic_inc(&ctype->ce_nr_users); - return (-EBUSY); + return (-EAGAIN); } - ctype->ce_regd = 0; + atomic_set(&ctype->ce_regd, 0); memset(&ctype->ce_callbacks, 0, sizeof(ckrm_eng_callback_t)); return 0; } @@ -243,20 +251,22 @@ ckrm_add_child(struct ckrm_core_class *parent, struct ckrm_core_class *child) struct ckrm_hnode *cnode = &child->hnode; if (!ckrm_is_core_valid(child)) { - printk(KERN_ERR "Invalid child %p given in ckrm_add_child\n", child); + printk(KERN_ERR "Invalid child %p given in ckrm_add_child\n", + child); return; } - + class_lock(child); INIT_LIST_HEAD(&cnode->children); INIT_LIST_HEAD(&cnode->siblings); - if (parent) { + if (parent) { struct ckrm_hnode *pnode; if (!ckrm_is_core_valid(parent)) { - printk(KERN_ERR "Invalid parent %p given in ckrm_add_child\n", - parent); + printk(KERN_ERR + "Invalid parent %p given in ckrm_add_child\n", + parent); parent = NULL; } else { pnode = &parent->hnode; @@ -272,21 +282,23 @@ ckrm_add_child(struct ckrm_core_class *parent, struct ckrm_core_class *child) /* */ -static int -ckrm_remove_child(struct ckrm_core_class *child) +static int ckrm_remove_child(struct ckrm_core_class *child) { struct ckrm_hnode *cnode, *pnode; struct ckrm_core_class *parent; if (!ckrm_is_core_valid(child)) { - printk(KERN_ERR "Invalid child %p given in ckrm_remove_child\n", child); + printk(KERN_ERR "Invalid child %p given" + " in ckrm_remove_child\n", + child); return 0; } cnode = &child->hnode; parent = cnode->parent; if (!ckrm_is_core_valid(parent)) { - printk(KERN_ERR "Invalid parent %p in ckrm_remove_child\n", parent); + printk(KERN_ERR "Invalid parent %p in ckrm_remove_child\n", + parent); return 0; } @@ -306,16 +318,14 @@ ckrm_remove_child(struct ckrm_core_class *child) return 1; } -void -ckrm_lock_hier(struct ckrm_core_class *parent) +void ckrm_lock_hier(struct ckrm_core_class *parent) { if (ckrm_is_core_valid(parent)) { read_lock(&parent->hnode_rwlock); } } -void -ckrm_unlock_hier(struct ckrm_core_class *parent) +void ckrm_unlock_hier(struct ckrm_core_class *parent) { if (ckrm_is_core_valid(parent)) { read_unlock(&parent->hnode_rwlock); @@ -327,18 +337,19 @@ ckrm_unlock_hier(struct ckrm_core_class *parent) * external callers should 've called ckrm_lock_hier before calling this * function. */ -#define hnode_2_core(ptr) ((ptr) ? container_of(ptr, struct ckrm_core_class, hnode) : NULL) +#define hnode_2_core(ptr) \ +((ptr)? container_of(ptr, struct ckrm_core_class, hnode) : NULL) -struct ckrm_core_class * -ckrm_get_next_child(struct ckrm_core_class *parent, - struct ckrm_core_class *child) +struct ckrm_core_class *ckrm_get_next_child(struct ckrm_core_class *parent, + struct ckrm_core_class *child) { struct list_head *cnode; struct ckrm_hnode *next_cnode; struct ckrm_core_class *next_childcore; if (!ckrm_is_core_valid(parent)) { - printk(KERN_ERR "Invalid parent %p in ckrm_get_next_child\n", parent); + printk(KERN_ERR "Invalid parent %p in ckrm_get_next_child\n", + parent); return NULL; } if (list_empty(&parent->hnode.children)) { @@ -347,7 +358,9 @@ ckrm_get_next_child(struct ckrm_core_class *parent, if (child) { if (!ckrm_is_core_valid(child)) { - printk(KERN_ERR "Invalid child %p in ckrm_get_next_child\n", child); + printk(KERN_ERR + "Invalid child %p in ckrm_get_next_child\n", + child); return NULL; } cnode = child->hnode.siblings.next; @@ -355,7 +368,7 @@ ckrm_get_next_child(struct ckrm_core_class *parent, cnode = parent->hnode.children.next; } - if (cnode == &parent->hnode.children) { // back at the anchor + if (cnode == &parent->hnode.children) { // back at the anchor return NULL; } @@ -363,8 +376,9 @@ ckrm_get_next_child(struct ckrm_core_class *parent, next_childcore = hnode_2_core(next_cnode); if (!ckrm_is_core_valid(next_childcore)) { - printk(KERN_ERR "Invalid next child %p in ckrm_get_next_child\n", - next_childcore); + printk(KERN_ERR + "Invalid next child %p in ckrm_get_next_child\n", + next_childcore); return NULL; } return next_childcore; @@ -374,10 +388,9 @@ EXPORT_SYMBOL(ckrm_lock_hier); EXPORT_SYMBOL(ckrm_unlock_hier); EXPORT_SYMBOL(ckrm_get_next_child); -static void +static void ckrm_alloc_res_class(struct ckrm_core_class *core, - struct ckrm_core_class *parent, - int resid) + struct ckrm_core_class *parent, int resid) { struct ckrm_classtype *clstype; @@ -388,7 +401,7 @@ ckrm_alloc_res_class(struct ckrm_core_class *core, */ if (!ckrm_is_core_valid(core)) - return ; + return; clstype = core->classtype; core->res_class[resid] = NULL; @@ -398,9 +411,10 @@ ckrm_alloc_res_class(struct ckrm_core_class *core, atomic_inc(&clstype->nr_resusers[resid]); rcbs = clstype->res_ctlrs[resid]; - + if (rcbs && rcbs->res_alloc) { - core->res_class[resid] =(*rcbs->res_alloc)(core,parent); + core->res_class[resid] = + (*rcbs->res_alloc) (core, parent); if (core->res_class[resid]) return; printk(KERN_ERR "Error creating res class\n"); @@ -414,76 +428,76 @@ ckrm_alloc_res_class(struct ckrm_core_class *core, * */ -#define CLS_DEBUG(fmt, args...) do { /* printk("%s: " fmt, __FUNCTION__ , ## args); */ } while (0) - +#define CLS_DEBUG(fmt, args...) \ +do { /* printk("%s: " fmt, __FUNCTION__ , ## args); */ } while (0) int -ckrm_init_core_class(struct ckrm_classtype *clstype, +ckrm_init_core_class(struct ckrm_classtype *clstype, struct ckrm_core_class *dcore, - struct ckrm_core_class *parent, - const char *name) + struct ckrm_core_class *parent, const char *name) { // Hubertus ... should replace name with dentry or add dentry ? int i; // Hubertus .. how is this used in initialization - CLS_DEBUG("name %s => %p\n", name?name:"default",dcore); - - if ((dcore != clstype->default_class) && ( !ckrm_is_core_valid(parent))) { - printk("error not a valid parent %p\n", parent); + CLS_DEBUG("name %s => %p\n", name ? name : "default", dcore); + + if ((dcore != clstype->default_class) && (!ckrm_is_core_valid(parent))){ + printk(KERN_DEBUG "error not a valid parent %p\n", parent); return -EINVAL; } -#if 0 // Hubertus .. dynamic allocation still breaks when RCs registers. See def in ckrm_rc.h +#if 0 +// Hubertus .. dynamic allocation still breaks when RCs registers. +// See def in ckrm_rc.h dcore->res_class = NULL; if (clstype->max_resid > 0) { - dcore->res_class = (void**)kmalloc(clstype->max_resid * sizeof(void*) , GFP_KERNEL); + dcore->res_class = + (void **)kmalloc(clstype->max_resid * sizeof(void *), + GFP_KERNEL); if (dcore->res_class == NULL) { - printk("error no mem\n"); + printk(KERN_DEBUG "error no mem\n"); return -ENOMEM; } } #endif - dcore->classtype = clstype; - dcore->magic = CKRM_CORE_MAGIC; - dcore->name = name; - dcore->class_lock = SPIN_LOCK_UNLOCKED; + dcore->classtype = clstype; + dcore->magic = CKRM_CORE_MAGIC; + dcore->name = name; + dcore->class_lock = SPIN_LOCK_UNLOCKED; dcore->hnode_rwlock = RW_LOCK_UNLOCKED; - dcore->delayed = 0; + dcore->delayed = 0; atomic_set(&dcore->refcnt, 0); write_lock(&ckrm_class_lock); INIT_LIST_HEAD(&dcore->objlist); - list_add(&dcore->clslist,&clstype->classes); + list_add_tail(&dcore->clslist, &clstype->classes); clstype->num_classes++; set_callbacks_active(clstype); write_unlock(&ckrm_class_lock); - ckrm_add_child(parent, dcore); + ckrm_add_child(parent, dcore); - for (i = 0; i < clstype->max_resid; i++) - ckrm_alloc_res_class(dcore,parent,i); + for (i = 0; i < clstype->max_resid; i++) + ckrm_alloc_res_class(dcore, parent, i); // fix for race condition seen in stress with numtasks - if (parent) + if (parent) ckrm_core_grab(parent); - ckrm_core_grab( dcore ); + ckrm_core_grab(dcore); return 0; } - -static void -ckrm_free_res_class(struct ckrm_core_class *core, int resid) +static void ckrm_free_res_class(struct ckrm_core_class *core, int resid) { /* * Free a resource class only if the resource controller has * registered with core */ - if (core->res_class[resid]) { ckrm_res_ctlr_t *rcbs; struct ckrm_classtype *clstype = core->classtype; @@ -492,15 +506,15 @@ ckrm_free_res_class(struct ckrm_core_class *core, int resid) rcbs = clstype->res_ctlrs[resid]; if (rcbs->res_free) { - (*rcbs->res_free)(core->res_class[resid]); - atomic_dec(&clstype->nr_resusers[resid]); // for inc in alloc - core->res_class[resid] = NULL; + (*rcbs->res_free) (core->res_class[resid]); + // compensate inc in alloc + atomic_dec(&clstype->nr_resusers[resid]); } atomic_dec(&clstype->nr_resusers[resid]); } + core->res_class[resid] = NULL; } - /* * Free a core class * requires that all tasks were previously reassigned to another class @@ -508,31 +522,31 @@ ckrm_free_res_class(struct ckrm_core_class *core, int resid) * Returns 0 on success -errno on failure. */ -void -ckrm_free_core_class(struct ckrm_core_class *core) +void ckrm_free_core_class(struct ckrm_core_class *core) { int i; struct ckrm_classtype *clstype = core->classtype; struct ckrm_core_class *parent = core->hnode.parent; - - CLS_DEBUG("core=%p:%s parent=%p:%s\n",core,core->name,parent,parent->name); + + CLS_DEBUG("core=%p:%s parent=%p:%s\n", core, core->name, parent, + parent->name); if (core->delayed) { /* this core was marked as late */ - printk("class <%s> finally deleted %lu\n",core->name,jiffies); + printk(KERN_DEBUG "class <%s> finally deleted %lu\n", core->name, jiffies); } if (ckrm_remove_child(core) == 0) { - printk("Core class removal failed. Chilren present\n"); + printk(KERN_DEBUG "Core class removal failed. Chilren present\n"); } for (i = 0; i < clstype->max_resid; i++) { - ckrm_free_res_class(core,i); + ckrm_free_res_class(core, i); } write_lock(&ckrm_class_lock); // Clear the magic, so we would know if this core is reused. core->magic = 0; -#if 0 // Dynamic not yet enabled +#if 0 // Dynamic not yet enabled core->res_class = NULL; #endif // Remove this core class from its linked list. @@ -542,14 +556,13 @@ ckrm_free_core_class(struct ckrm_core_class *core) write_unlock(&ckrm_class_lock); // fix for race condition seen in stress with numtasks - if (parent) + if (parent) ckrm_core_drop(parent); - + kfree(core); } -int -ckrm_release_core_class(struct ckrm_core_class *core) +int ckrm_release_core_class(struct ckrm_core_class *core) { if (!ckrm_is_core_valid(core)) { // Invalid core @@ -557,13 +570,13 @@ ckrm_release_core_class(struct ckrm_core_class *core) } if (core == core->classtype->default_class) - return 0; + return 0; /* need to make sure that the classgot really dropped */ if (atomic_read(&core->refcnt) != 1) { CLS_DEBUG("class <%s> deletion delayed refcnt=%d jif=%ld\n", - core->name,atomic_read(&core->refcnt),jiffies); - core->delayed = 1; /* just so we have a ref point */ + core->name, atomic_read(&core->refcnt), jiffies); + core->delayed = 1; /* just so we have a ref point */ } ckrm_core_drop(core); return 0; @@ -578,25 +591,27 @@ ckrm_release_core_class(struct ckrm_core_class *core) * Returns the resource id(0 or +ve) on success, -errno for failure. */ static int -ckrm_register_res_ctlr_intern(struct ckrm_classtype *clstype, ckrm_res_ctlr_t *rcbs) +ckrm_register_res_ctlr_intern(struct ckrm_classtype *clstype, + ckrm_res_ctlr_t * rcbs) { - int resid, ret,i; - + int resid, ret, i; + if (!rcbs) return -EINVAL; resid = rcbs->resid; - + spin_lock(&clstype->res_ctlrs_lock); - - printk(KERN_WARNING "resid is %d name is %s %s\n", - resid, rcbs->res_name,clstype->res_ctlrs[resid]->res_name); + + printk(KERN_WARNING "resid is %d name is %s %s\n", + resid, rcbs->res_name, clstype->res_ctlrs[resid]->res_name); if (resid >= 0) { - if ((resid < CKRM_MAX_RES_CTLRS) && (clstype->res_ctlrs[resid] == NULL)) { + if ((resid < CKRM_MAX_RES_CTLRS) + && (clstype->res_ctlrs[resid] == NULL)) { clstype->res_ctlrs[resid] = rcbs; atomic_set(&clstype->nr_resusers[resid], 0); - set_bit(resid, &clstype->bit_res_ctlrs); + set_bit(resid, &clstype->bit_res_ctlrs); ret = resid; if (resid >= clstype->max_resid) { clstype->max_resid = resid + 1; @@ -613,7 +628,7 @@ ckrm_register_res_ctlr_intern(struct ckrm_classtype *clstype, ckrm_res_ctlr_t *r clstype->res_ctlrs[i] = rcbs; rcbs->resid = i; atomic_set(&clstype->nr_resusers[i], 0); - set_bit(i, &clstype->bit_res_ctlrs); + set_bit(i, &clstype->bit_res_ctlrs); if (i >= clstype->max_resid) { clstype->max_resid = i + 1; } @@ -621,30 +636,35 @@ ckrm_register_res_ctlr_intern(struct ckrm_classtype *clstype, ckrm_res_ctlr_t *r return i; } } - + spin_unlock(&clstype->res_ctlrs_lock); return (-ENOMEM); } int -ckrm_register_res_ctlr(struct ckrm_classtype *clstype, ckrm_res_ctlr_t *rcbs) +ckrm_register_res_ctlr(struct ckrm_classtype *clstype, ckrm_res_ctlr_t * rcbs) { struct ckrm_core_class *core; int resid; - - resid = ckrm_register_res_ctlr_intern(clstype,rcbs); - + + resid = ckrm_register_res_ctlr_intern(clstype, rcbs); + if (resid >= 0) { - /* run through all classes and create the resource class object and - * if necessary "initialize" class in context of this resource + /* run through all classes and create the resource class + * object and if necessary "initialize" class in context + * of this resource */ read_lock(&ckrm_class_lock); list_for_each_entry(core, &clstype->classes, clslist) { - printk("CKRM .. create res clsobj for resouce <%s> class <%s> par=%p\n", - rcbs->res_name, core->name, core->hnode.parent); + printk(KERN_INFO "CKRM .. create res clsobj for resouce <%s>" + "class <%s> par=%p\n", rcbs->res_name, + core->name, core->hnode.parent); ckrm_alloc_res_class(core, core->hnode.parent, resid); - if (clstype->add_resctrl) // FIXME: this should be mandatory - (*clstype->add_resctrl)(core,resid); + + if (clstype->add_resctrl) { + // FIXME: this should be mandatory + (*clstype->add_resctrl) (core, resid); + } } read_unlock(&ckrm_class_lock); } @@ -656,27 +676,35 @@ ckrm_register_res_ctlr(struct ckrm_classtype *clstype, ckrm_res_ctlr_t *rcbs) * * Returns 0 on success -errno for failure. */ -int -ckrm_unregister_res_ctlr(struct ckrm_res_ctlr *rcbs) -{ +int ckrm_unregister_res_ctlr(struct ckrm_res_ctlr *rcbs) +{ struct ckrm_classtype *clstype = rcbs->classtype; + struct ckrm_core_class *core = NULL; int resid = rcbs->resid; - if ((clstype == NULL) || (resid < 0)) + if ((clstype == NULL) || (resid < 0)) { return -EINVAL; - - if (atomic_read(&clstype->nr_resusers[resid])) - return -EBUSY; - + } // FIXME: probably need to also call deregistration function + read_lock(&ckrm_class_lock); + // free up this resource from all the classes + list_for_each_entry(core, &clstype->classes, clslist) { + ckrm_free_res_class(core, resid); + } + read_unlock(&ckrm_class_lock); + + if (atomic_read(&clstype->nr_resusers[resid])) { + return -EBUSY; + } + spin_lock(&clstype->res_ctlrs_lock); clstype->res_ctlrs[resid] = NULL; - clear_bit(resid, &clstype->bit_res_ctlrs); + clear_bit(resid, &clstype->bit_res_ctlrs); clstype->max_resid = fls(clstype->bit_res_ctlrs); rcbs->resid = -1; spin_unlock(&clstype->res_ctlrs_lock); - + return 0; } @@ -686,50 +714,52 @@ ckrm_unregister_res_ctlr(struct ckrm_res_ctlr *rcbs) /* Hubertus ... we got to do some locking here */ -struct ckrm_classtype* ckrm_classtypes[CKRM_MAX_CLASSTYPES]; -EXPORT_SYMBOL(ckrm_classtypes); // really should build a better interface for this -int -ckrm_register_classtype(struct ckrm_classtype *clstype) +struct ckrm_classtype *ckrm_classtypes[CKRM_MAX_CLASSTYPES]; +// really should build a better interface for this +EXPORT_SYMBOL(ckrm_classtypes); + +int ckrm_register_classtype(struct ckrm_classtype *clstype) { int tid = clstype->typeID; if (tid != -1) { - if ((tid < 0) || (tid > CKRM_MAX_CLASSTYPES) || (ckrm_classtypes[tid])) + if ((tid < 0) || (tid > CKRM_MAX_CLASSTYPES) + || (ckrm_classtypes[tid])) return -EINVAL; } else { int i; - for ( i=CKRM_RESV_CLASSTYPES ; itypeID = tid; ckrm_classtypes[tid] = clstype; - + /* Hubertus .. we need to call the callbacks of the RCFS client */ if (rcfs_fn.register_classtype) { - (* rcfs_fn.register_classtype)(clstype); + (*rcfs_fn.register_classtype) (clstype); // No error return for now ; } return tid; } -int -ckrm_unregister_classtype(struct ckrm_classtype *clstype) +int ckrm_unregister_classtype(struct ckrm_classtype *clstype) { int tid = clstype->typeID; - if ((tid < 0) || (tid > CKRM_MAX_CLASSTYPES) || (ckrm_classtypes[tid] != clstype)) + if ((tid < 0) || (tid > CKRM_MAX_CLASSTYPES) + || (ckrm_classtypes[tid] != clstype)) return -EINVAL; if (rcfs_fn.deregister_classtype) { - (* rcfs_fn.deregister_classtype)(clstype); + (*rcfs_fn.deregister_classtype) (clstype); // No error return for now } @@ -738,43 +768,39 @@ ckrm_unregister_classtype(struct ckrm_classtype *clstype) return 0; } -struct ckrm_classtype* -ckrm_find_classtype_by_name(const char *name) +struct ckrm_classtype *ckrm_find_classtype_by_name(const char *name) { int i; - for ( i=0 ; iname,name,CKRM_MAX_TYPENAME_LEN)) + if (ctype && !strncmp(ctype->name, name, CKRM_MAX_TYPENAME_LEN)) return ctype; } return NULL; } - /******************************************************************* * Event callback invocation *******************************************************************/ -struct ckrm_hook_cb* ckrm_event_callbacks[CKRM_NONLATCHABLE_EVENTS]; +struct ckrm_hook_cb *ckrm_event_callbacks[CKRM_NONLATCHABLE_EVENTS]; /* Registration / Deregistration / Invocation functions */ -int -ckrm_register_event_cb(enum ckrm_event ev, struct ckrm_hook_cb *cb) +int ckrm_register_event_cb(enum ckrm_event ev, struct ckrm_hook_cb *cb) { struct ckrm_hook_cb **cbptr; if ((ev < CKRM_LATCHABLE_EVENTS) || (ev >= CKRM_NONLATCHABLE_EVENTS)) return 1; cbptr = &ckrm_event_callbacks[ev]; - while (*cbptr != NULL) + while (*cbptr != NULL) cbptr = &((*cbptr)->next); *cbptr = cb; return 0; } -int -ckrm_unregister_event_cb(enum ckrm_event ev, struct ckrm_hook_cb *cb) +int ckrm_unregister_event_cb(enum ckrm_event ev, struct ckrm_hook_cb *cb) { struct ckrm_hook_cb **cbptr; @@ -788,37 +814,35 @@ ckrm_unregister_event_cb(enum ckrm_event ev, struct ckrm_hook_cb *cb) return (*cbptr == NULL); } -int -ckrm_register_event_set(struct ckrm_event_spec especs[]) +int ckrm_register_event_set(struct ckrm_event_spec especs[]) { struct ckrm_event_spec *espec = especs; - for ( espec = especs ; espec->ev != -1 ; espec++ ) - ckrm_register_event_cb(espec->ev,&espec->cb); + for (espec = especs; espec->ev != -1; espec++) + ckrm_register_event_cb(espec->ev, &espec->cb); return 0; } -int -ckrm_unregister_event_set(struct ckrm_event_spec especs[]) +int ckrm_unregister_event_set(struct ckrm_event_spec especs[]) { struct ckrm_event_spec *espec = especs; - for ( espec = especs ; espec->ev != -1 ; espec++ ) - ckrm_unregister_event_cb(espec->ev,&espec->cb); + for (espec = especs; espec->ev != -1; espec++) + ckrm_unregister_event_cb(espec->ev, &espec->cb); return 0; } -#define ECC_PRINTK(fmt, args...) // printk("%s: " fmt, __FUNCTION__ , ## args) +#define ECC_PRINTK(fmt, args...) \ +// printk(KERN_DEBUG "%s: " fmt, __FUNCTION__ , ## args) -void -ckrm_invoke_event_cb_chain(enum ckrm_event ev, void *arg) +void ckrm_invoke_event_cb_chain(enum ckrm_event ev, void *arg) { struct ckrm_hook_cb *cb, *anchor; - ECC_PRINTK("%d %x\n",current,ev,arg); + ECC_PRINTK("%d %x\n", current, ev, arg); if ((anchor = ckrm_event_callbacks[ev]) != NULL) { - for ( cb = anchor ; cb ; cb = cb->next ) - (*cb->fct)(arg); + for (cb = anchor; cb; cb = cb->next) + (*cb->fct) (arg); } } @@ -829,8 +853,7 @@ ckrm_invoke_event_cb_chain(enum ckrm_event ev, void *arg) * (b) function invoker on a named resource *******************************************************************/ -int -ckrm_class_show_shares(struct ckrm_core_class *core, struct seq_file *seq) +int ckrm_class_show_shares(struct ckrm_core_class *core, struct seq_file *seq) { int i; struct ckrm_res_ctlr *rcbs; @@ -841,12 +864,11 @@ ckrm_class_show_shares(struct ckrm_core_class *core, struct seq_file *seq) atomic_inc(&clstype->nr_resusers[i]); rcbs = clstype->res_ctlrs[i]; if (rcbs && rcbs->get_share_values) { - (*rcbs->get_share_values)(core->res_class[i], &shares); - seq_printf(seq,"res=%s,guarantee=%d,limit=%d,total_guarantee=%d,max_limit=%d\n", - rcbs->res_name, - shares.my_guarantee, - shares.my_limit, - shares.total_guarantee, + (*rcbs->get_share_values) (core->res_class[i], &shares); + seq_printf(seq,"res=%s,guarantee=%d,limit=%d," + "total_guarantee=%d,max_limit=%d\n", + rcbs->res_name, shares.my_guarantee, + shares.my_limit, shares.total_guarantee, shares.max_limit); } atomic_dec(&clstype->nr_resusers[i]); @@ -854,8 +876,7 @@ ckrm_class_show_shares(struct ckrm_core_class *core, struct seq_file *seq) return 0; } -int -ckrm_class_show_stats(struct ckrm_core_class *core, struct seq_file *seq) +int ckrm_class_show_stats(struct ckrm_core_class *core, struct seq_file *seq) { int i; struct ckrm_res_ctlr *rcbs; @@ -864,15 +885,14 @@ ckrm_class_show_stats(struct ckrm_core_class *core, struct seq_file *seq) for (i = 0; i < clstype->max_resid; i++) { atomic_inc(&clstype->nr_resusers[i]); rcbs = clstype->res_ctlrs[i]; - if (rcbs && rcbs->get_stats) - (*rcbs->get_stats)(core->res_class[i], seq); + if (rcbs && rcbs->get_stats) + (*rcbs->get_stats) (core->res_class[i], seq); atomic_dec(&clstype->nr_resusers[i]); } return 0; } -int -ckrm_class_show_config(struct ckrm_core_class *core, struct seq_file *seq) +int ckrm_class_show_config(struct ckrm_core_class *core, struct seq_file *seq) { int i; struct ckrm_res_ctlr *rcbs; @@ -881,96 +901,102 @@ ckrm_class_show_config(struct ckrm_core_class *core, struct seq_file *seq) for (i = 0; i < clstype->max_resid; i++) { atomic_inc(&clstype->nr_resusers[i]); rcbs = clstype->res_ctlrs[i]; - if (rcbs && rcbs->show_config) - (*rcbs->show_config)(core->res_class[i], seq); + if (rcbs && rcbs->show_config) + (*rcbs->show_config) (core->res_class[i], seq); atomic_dec(&clstype->nr_resusers[i]); } return 0; } -int -ckrm_class_set_config(struct ckrm_core_class *core, const char *resname, const char *cfgstr) +int ckrm_class_set_config(struct ckrm_core_class *core, const char *resname, + const char *cfgstr) { struct ckrm_classtype *clstype = core->classtype; - struct ckrm_res_ctlr *rcbs = ckrm_resctlr_lookup(clstype,resname); + struct ckrm_res_ctlr *rcbs = ckrm_resctlr_lookup(clstype, resname); int rc; if (rcbs == NULL || rcbs->set_config == NULL) - return -EINVAL; - rc = (*rcbs->set_config)(core->res_class[rcbs->resid],cfgstr); + return -EINVAL; + rc = (*rcbs->set_config) (core->res_class[rcbs->resid], cfgstr); return rc; } -int -ckrm_class_set_shares(struct ckrm_core_class *core, const char *resname, - struct ckrm_shares *shares) +#define legalshare(a) \ + ( ((a) >=0) \ + || ((a) == CKRM_SHARE_UNCHANGED) \ + || ((a) == CKRM_SHARE_DONTCARE) ) + +int ckrm_class_set_shares(struct ckrm_core_class *core, const char *resname, + struct ckrm_shares *shares) { struct ckrm_classtype *clstype = core->classtype; struct ckrm_res_ctlr *rcbs; int rc; - printk("ckrm_class_set_shares(%s,%s)\n",core->name,resname); - rcbs = ckrm_resctlr_lookup(clstype,resname); + // Check for legal values + if (!legalshare(shares->my_guarantee) || !legalshare(shares->my_limit) + || !legalshare(shares->total_guarantee) + || !legalshare(shares->max_limit)) + return -EINVAL; + + rcbs = ckrm_resctlr_lookup(clstype, resname); if (rcbs == NULL || rcbs->set_share_values == NULL) - return -EINVAL; - rc = (*rcbs->set_share_values)(core->res_class[rcbs->resid],shares); + return -EINVAL; + rc = (*rcbs->set_share_values) (core->res_class[rcbs->resid], shares); return rc; } -int -ckrm_class_reset_stats(struct ckrm_core_class *core, const char *resname, const char *unused) +int ckrm_class_reset_stats(struct ckrm_core_class *core, const char *resname, + const char *unused) { struct ckrm_classtype *clstype = core->classtype; - struct ckrm_res_ctlr *rcbs = ckrm_resctlr_lookup(clstype,resname); + struct ckrm_res_ctlr *rcbs = ckrm_resctlr_lookup(clstype, resname); int rc; if (rcbs == NULL || rcbs->reset_stats == NULL) - return -EINVAL; - rc = (*rcbs->reset_stats)(core->res_class[rcbs->resid]); + return -EINVAL; + rc = (*rcbs->reset_stats) (core->res_class[rcbs->resid]); return rc; -} +} /******************************************************************* * Initialization *******************************************************************/ -void -ckrm_cb_newtask(struct task_struct *tsk) +void ckrm_cb_newtask(struct task_struct *tsk) { - tsk->ce_data = NULL; + tsk->ce_data = NULL; spin_lock_init(&tsk->ckrm_tsklock); - ckrm_invoke_event_cb_chain(CKRM_EVENT_NEWTASK,tsk); + ckrm_invoke_event_cb_chain(CKRM_EVENT_NEWTASK, tsk); } -void -ckrm_cb_exit(struct task_struct *tsk) +void ckrm_cb_exit(struct task_struct *tsk) { - ckrm_invoke_event_cb_chain(CKRM_EVENT_EXIT,tsk); + ckrm_invoke_event_cb_chain(CKRM_EVENT_EXIT, tsk); tsk->ce_data = NULL; } -void __init -ckrm_init(void) +void __init ckrm_init(void) { - printk("CKRM Initialization\n"); - + printk(KERN_DEBUG "CKRM Initialization\n"); + // register/initialize the Metatypes - + #ifdef CONFIG_CKRM_TYPE_TASKCLASS - { + { extern void ckrm_meta_init_taskclass(void); ckrm_meta_init_taskclass(); } #endif #ifdef CONFIG_CKRM_TYPE_SOCKETCLASS - { + { extern void ckrm_meta_init_sockclass(void); ckrm_meta_init_sockclass(); } #endif // prepare init_task and then rely on inheritance of properties ckrm_cb_newtask(&init_task); - printk("CKRM Initialization done\n"); + printk(KERN_DEBUG "CKRM Initialization done\n"); } EXPORT_SYMBOL(ckrm_register_engine); @@ -1005,5 +1031,3 @@ EXPORT_SYMBOL(ckrm_class_set_config); EXPORT_SYMBOL(ckrm_class_set_shares); EXPORT_SYMBOL(ckrm_class_reset_stats); - - diff --git a/kernel/ckrm/ckrm_cpu_class.c b/kernel/ckrm/ckrm_cpu_class.c index 09ea6ba80..917875b18 100644 --- a/kernel/ckrm/ckrm_cpu_class.c +++ b/kernel/ckrm/ckrm_cpu_class.c @@ -318,7 +318,7 @@ static int ckrm_cpu_set_config(void *my_res, const char *cfgstr) if (!cls) return -EINVAL; - printk("ckrm_cpu config='%s'\n",cfgstr); + printk(KERN_DEBUG "ckrm_cpu config='%s'\n",cfgstr); return 0; } @@ -349,7 +349,7 @@ int __init init_ckrm_sched_res(void) if (resid == -1) { /*not registered */ resid = ckrm_register_res_ctlr(clstype,&cpu_rcbs); - printk("........init_ckrm_sched_res , resid= %d\n",resid); + printk(KERN_DEBUG "........init_ckrm_sched_res , resid= %d\n",resid); } return 0; } diff --git a/kernel/ckrm/ckrm_cpu_monitor.c b/kernel/ckrm/ckrm_cpu_monitor.c index 5095c1c30..d8c199a20 100644 --- a/kernel/ckrm/ckrm_cpu_monitor.c +++ b/kernel/ckrm/ckrm_cpu_monitor.c @@ -963,7 +963,7 @@ static int ckrm_cpu_monitord(void *nothing) } cpu_monitor_pid = -1; thread_exit = 2; - printk("cpu_monitord exit\n"); + printk(KERN_DEBUG "cpu_monitord exit\n"); return 0; } @@ -971,13 +971,13 @@ void ckrm_start_monitor(void) { cpu_monitor_pid = kernel_thread(ckrm_cpu_monitord, 0, CLONE_KERNEL); if (cpu_monitor_pid < 0) { - printk("ckrm_cpu_monitord for failed\n"); + printk(KERN_DEBUG "ckrm_cpu_monitord for failed\n"); } } void ckrm_kill_monitor(void) { - printk("killing process %d\n", cpu_monitor_pid); + printk(KERN_DEBUG "killing process %d\n", cpu_monitor_pid); if (cpu_monitor_pid > 0) { thread_exit = 1; while (thread_exit != 2) { diff --git a/kernel/ckrm/ckrm_laq.c b/kernel/ckrm/ckrm_laq.c index 3271f10bd..b64205a06 100644 --- a/kernel/ckrm/ckrm_laq.c +++ b/kernel/ckrm/ckrm_laq.c @@ -477,7 +477,7 @@ int __init init_ckrm_laq_res(void) resid = ckrm_register_res_ctlr(clstype, &laq_rcbs); if (resid >= 0) my_resid = resid; - printk("........init_ckrm_listen_aq_res -> %d\n", my_resid); + printk(KERN_DEBUG "........init_ckrm_listen_aq_res -> %d\n", my_resid); } return 0; diff --git a/kernel/ckrm/ckrm_mem.c b/kernel/ckrm/ckrm_mem.c index 765311819..c6c594a96 100644 --- a/kernel/ckrm/ckrm_mem.c +++ b/kernel/ckrm/ckrm_mem.c @@ -736,7 +736,7 @@ ckrm_mem_evaluate_all_pages() } spin_unlock_irq(&zone->lru_lock); } - printk("all_pages: active %d inactive %d cleared %d\n", + printk(KERN_DEBUG "all_pages: active %d inactive %d cleared %d\n", active, inactive, cleared); spin_lock(&ckrm_mem_lock); list_for_each_entry(res, &ckrm_memclass_list, mcls_list) { @@ -746,7 +746,7 @@ ckrm_mem_evaluate_all_pages() inact_cnt += res->nr_inactive[idx]; idx++; } - printk("all_pages: %s: tmp_cnt %d; act_cnt %d inact_cnt %d\n", + printk(KERN_DEBUG "all_pages: %s: tmp_cnt %d; act_cnt %d inact_cnt %d\n", res->core->name, res->tmp_cnt, act_cnt, inact_cnt); } spin_unlock(&ckrm_mem_lock); diff --git a/kernel/ckrm/ckrm_numtasks.c b/kernel/ckrm/ckrm_numtasks.c index 23b3549d4..61517aee0 100644 --- a/kernel/ckrm/ckrm_numtasks.c +++ b/kernel/ckrm/ckrm_numtasks.c @@ -453,7 +453,7 @@ static int numtasks_set_config(void *my_res, const char *cfgstr) if (!res) return -EINVAL; - printk("numtasks config='%s'\n", cfgstr); + printk(KERN_DEBUG "numtasks config='%s'\n", cfgstr); return 0; } @@ -505,7 +505,7 @@ int __init init_ckrm_numtasks_res(void) if (resid == -1) { resid = ckrm_register_res_ctlr(clstype, &numtasks_rcbs); - printk("........init_ckrm_numtasks_res -> %d\n", resid); + printk(KERN_DEBUG "........init_ckrm_numtasks_res -> %d\n", resid); if (resid != -1) { ckrm_numtasks_register(numtasks_get_ref_local, numtasks_put_ref_local); diff --git a/kernel/ckrm/ckrm_sockc.c b/kernel/ckrm/ckrm_sockc.c index 26731bb20..8ccadfa39 100644 --- a/kernel/ckrm/ckrm_sockc.c +++ b/kernel/ckrm/ckrm_sockc.c @@ -56,70 +56,71 @@ struct ckrm_sock_class { struct ckrm_core_class core; }; -static struct ckrm_sock_class sockclass_dflt_class = { +static struct ckrm_sock_class sockclass_dflt_class = { }; -#define SOCKET_CLASS_TYPE_NAME "socket_class" +#define SOCKET_CLASS_TYPE_NAME "socketclass" const char *dflt_sockclass_name = SOCKET_CLASS_TYPE_NAME; -static struct ckrm_core_class *sock_alloc_class(struct ckrm_core_class *parent, const char *name); -static int sock_free_class(struct ckrm_core_class *core); +static struct ckrm_core_class *sock_alloc_class(struct ckrm_core_class *parent, + const char *name); +static int sock_free_class(struct ckrm_core_class *core); -static int sock_forced_reclassify(ckrm_core_class_t *target, const char *resname); -static int sock_show_members(struct ckrm_core_class *core, struct seq_file *seq); +static int sock_forced_reclassify(ckrm_core_class_t * target, + const char *resname); +static int sock_show_members(struct ckrm_core_class *core, + struct seq_file *seq); static void sock_add_resctrl(struct ckrm_core_class *core, int resid); static void sock_reclassify_class(struct ckrm_sock_class *cls); struct ckrm_classtype CT_sockclass = { - .mfidx = 1, - .name = SOCKET_CLASS_TYPE_NAME, - .typeID = CKRM_CLASSTYPE_SOCKET_CLASS, - .maxdepth = 3, - .resid_reserved = 0, - .max_res_ctlrs = CKRM_MAX_RES_CTLRS, - .max_resid = 0, - .bit_res_ctlrs = 0L, + .mfidx = 1, + .name = SOCKET_CLASS_TYPE_NAME, + .typeID = CKRM_CLASSTYPE_SOCKET_CLASS, + .maxdepth = 3, + .resid_reserved = 0, + .max_res_ctlrs = CKRM_MAX_RES_CTLRS, + .max_resid = 0, + .bit_res_ctlrs = 0L, .res_ctlrs_lock = SPIN_LOCK_UNLOCKED, - .classes = LIST_HEAD_INIT(CT_sockclass.classes), + .classes = LIST_HEAD_INIT(CT_sockclass.classes), + + .default_class = &sockclass_dflt_class.core, - .default_class = &sockclass_dflt_class.core, - // private version of functions - .alloc = &sock_alloc_class, - .free = &sock_free_class, - .show_members = &sock_show_members, + .alloc = &sock_alloc_class, + .free = &sock_free_class, + .show_members = &sock_show_members, .forced_reclassify = &sock_forced_reclassify, // use of default functions - .show_shares = &ckrm_class_show_shares, - .show_stats = &ckrm_class_show_stats, - .show_config = &ckrm_class_show_config, - .set_config = &ckrm_class_set_config, - .set_shares = &ckrm_class_set_shares, - .reset_stats = &ckrm_class_reset_stats, + .show_shares = &ckrm_class_show_shares, + .show_stats = &ckrm_class_show_stats, + .show_config = &ckrm_class_show_config, + .set_config = &ckrm_class_set_config, + .set_shares = &ckrm_class_set_shares, + .reset_stats = &ckrm_class_reset_stats, // mandatory private version .. no dflt available - .add_resctrl = &sock_add_resctrl, + .add_resctrl = &sock_add_resctrl, }; /* helper functions */ -void -ckrm_ns_hold(struct ckrm_net_struct *ns) +void ckrm_ns_hold(struct ckrm_net_struct *ns) { - atomic_inc(&ns->ns_refcnt); - return; + atomic_inc(&ns->ns_refcnt); + return; } -void -ckrm_ns_put(struct ckrm_net_struct *ns) +void ckrm_ns_put(struct ckrm_net_struct *ns) { - if (atomic_dec_and_test(&ns->ns_refcnt)) - kfree(ns); - - return; + if (atomic_dec_and_test(&ns->ns_refcnt)) + kfree(ns); + return; } + /* * Change the class of a netstruct * @@ -130,12 +131,12 @@ ckrm_ns_put(struct ckrm_net_struct *ns) static void sock_set_class(struct ckrm_net_struct *ns, struct ckrm_sock_class *newcls, - struct ckrm_sock_class *oldcls, enum ckrm_event event) + struct ckrm_sock_class *oldcls, enum ckrm_event event) { int i; struct ckrm_res_ctlr *rcbs; struct ckrm_classtype *clstype; - void *old_res_class, *new_res_class; + void *old_res_class, *new_res_class; if ((newcls == oldcls) || (newcls == NULL)) { ns->core = (void *)oldcls; @@ -147,43 +148,46 @@ sock_set_class(struct ckrm_net_struct *ns, struct ckrm_sock_class *newcls, list_add(&ns->ckrm_link, &class_core(newcls)->objlist); class_unlock(class_core(newcls)); - clstype = class_isa(newcls); + clstype = class_isa(newcls); for (i = 0; i < clstype->max_resid; i++) { atomic_inc(&clstype->nr_resusers[i]); - old_res_class = oldcls ? class_core(oldcls)->res_class[i] : NULL; - new_res_class = newcls ? class_core(newcls)->res_class[i] : NULL; + old_res_class = + oldcls ? class_core(oldcls)->res_class[i] : NULL; + new_res_class = + newcls ? class_core(newcls)->res_class[i] : NULL; rcbs = clstype->res_ctlrs[i]; - if (rcbs && rcbs->change_resclass && (old_res_class != new_res_class)) - (*rcbs->change_resclass)(ns, old_res_class, new_res_class); + if (rcbs && rcbs->change_resclass + && (old_res_class != new_res_class)) + (*rcbs->change_resclass) (ns, old_res_class, + new_res_class); atomic_dec(&clstype->nr_resusers[i]); } return; } -static void -sock_add_resctrl(struct ckrm_core_class *core, int resid) +static void sock_add_resctrl(struct ckrm_core_class *core, int resid) { struct ckrm_net_struct *ns; struct ckrm_res_ctlr *rcbs; - if ((resid < 0) || (resid >= CKRM_MAX_RES_CTLRS) || ((rcbs = core->classtype->res_ctlrs[resid]) == NULL)) + if ((resid < 0) || (resid >= CKRM_MAX_RES_CTLRS) + || ((rcbs = core->classtype->res_ctlrs[resid]) == NULL)) return; class_lock(core); list_for_each_entry(ns, &core->objlist, ckrm_link) { if (rcbs->change_resclass) - (*rcbs->change_resclass)(ns, NULL, core->res_class[resid]); + (*rcbs->change_resclass) (ns, NULL, + core->res_class[resid]); } class_unlock(core); } - /************************************************************************** * Functions called from classification points * **************************************************************************/ -static void -cb_sockclass_listen_start(struct sock *sk) +static void cb_sockclass_listen_start(struct sock *sk) { struct ckrm_net_struct *ns = NULL; struct ckrm_sock_class *newcls = NULL; @@ -192,43 +196,43 @@ cb_sockclass_listen_start(struct sock *sk) int i = 0; // XXX - TBD ipv6 - if (sk->sk_family == IPPROTO_IPV6) + if (sk->sk_family == AF_INET6) return; // to store the socket address ns = (struct ckrm_net_struct *) - kmalloc(sizeof(struct ckrm_net_struct), GFP_ATOMIC); + kmalloc(sizeof(struct ckrm_net_struct), GFP_ATOMIC); if (!ns) return; - memset(ns,0, sizeof(ns)); + memset(ns, 0, sizeof(*ns)); INIT_LIST_HEAD(&ns->ckrm_link); + ckrm_ns_hold(ns); ns->ns_family = sk->sk_family; - if (ns->ns_family == IPPROTO_IPV6) // IPv6 not supported yet. + if (ns->ns_family == AF_INET6) // IPv6 not supported yet. return; ns->ns_daddrv4 = inet_sk(sk)->rcv_saddr; ns->ns_dport = inet_sk(sk)->num; - + ns->ns_pid = current->pid; ns->ns_tgid = current->tgid; - + ns->ns_tsk = current; ce_protect(&CT_sockclass); - CE_CLASSIFY_RET(newcls,&CT_sockclass,CKRM_EVENT_LISTEN_START,ns,current); + CE_CLASSIFY_RET(newcls, &CT_sockclass, CKRM_EVENT_LISTEN_START, ns, + current); ce_release(&CT_sockclass); - if (newcls == NULL) { + if (newcls == NULL) { newcls = &sockclass_dflt_class; ckrm_core_grab(class_core(newcls)); } class_lock(class_core(newcls)); list_add(&ns->ckrm_link, &class_core(newcls)->objlist); - ckrm_ns_put(ns); ns->core = newcls; class_unlock(class_core(newcls)); - // the socket is already locked // take a reference on socket on our behalf @@ -242,26 +246,27 @@ cb_sockclass_listen_start(struct sock *sk) atomic_inc(&clstype->nr_resusers[i]); rcbs = clstype->res_ctlrs[i]; if (rcbs && rcbs->change_resclass) { - (*rcbs->change_resclass)((void *)ns, - NULL,class_core(newcls)->res_class[i]); + (*rcbs->change_resclass) ((void *)ns, + NULL, + class_core(newcls)-> + res_class[i]); } atomic_dec(&clstype->nr_resusers[i]); } return; } -static void -cb_sockclass_listen_stop(struct sock *sk) +static void cb_sockclass_listen_stop(struct sock *sk) { struct ckrm_net_struct *ns = NULL; struct ckrm_sock_class *newcls = NULL; // XXX - TBD ipv6 - if (sk->sk_family == IPPROTO_IPV6) + if (sk->sk_family == AF_INET6) return; - ns = (struct ckrm_net_struct *)sk->sk_ns; - if (!ns) // listen_start called before socket_aq was loaded + ns = (struct ckrm_net_struct *)sk->sk_ns; + if (!ns) // listen_start called before socket_aq was loaded return; newcls = ns->core; @@ -272,7 +277,6 @@ cb_sockclass_listen_stop(struct sock *sk) class_unlock(class_core(newcls)); ckrm_core_drop(class_core(newcls)); } - // the socket is already locked sk->sk_ns = NULL; sock_put(sk); @@ -283,35 +287,36 @@ cb_sockclass_listen_stop(struct sock *sk) } static struct ckrm_event_spec sock_events_callbacks[] = { - CKRM_EVENT_SPEC( LISTEN_START, cb_sockclass_listen_start ), - CKRM_EVENT_SPEC( LISTEN_STOP, cb_sockclass_listen_stop ), - { -1 } + CKRM_EVENT_SPEC(LISTEN_START, cb_sockclass_listen_start), + CKRM_EVENT_SPEC(LISTEN_STOP, cb_sockclass_listen_stop), + {-1} }; /************************************************************************** * Class Object Creation / Destruction **************************************************************************/ -static struct ckrm_core_class * -sock_alloc_class(struct ckrm_core_class *parent, const char *name) +static struct ckrm_core_class *sock_alloc_class(struct ckrm_core_class *parent, + const char *name) { struct ckrm_sock_class *sockcls; sockcls = kmalloc(sizeof(struct ckrm_sock_class), GFP_KERNEL); - if (sockcls == NULL) + if (sockcls == NULL) return NULL; + memset(sockcls, 0, sizeof(struct ckrm_sock_class)); - ckrm_init_core_class(&CT_sockclass,class_core(sockcls),parent,name); + ckrm_init_core_class(&CT_sockclass, class_core(sockcls), parent, name); ce_protect(&CT_sockclass); if (CT_sockclass.ce_cb_active && CT_sockclass.ce_callbacks.class_add) - (*CT_sockclass.ce_callbacks.class_add)(name,sockcls); + (*CT_sockclass.ce_callbacks.class_add) (name, sockcls, + CT_sockclass.typeID); ce_release(&CT_sockclass); return class_core(sockcls); } -static int -sock_free_class(struct ckrm_core_class *core) +static int sock_free_class(struct ckrm_core_class *core) { struct ckrm_sock_class *sockcls; @@ -322,7 +327,7 @@ sock_free_class(struct ckrm_core_class *core) if (core == core->classtype->default_class) { // reset the name tag core->name = dflt_sockclass_name; - return 0; + return 0; } sockcls = class_type(struct ckrm_sock_class, core); @@ -330,28 +335,29 @@ sock_free_class(struct ckrm_core_class *core) ce_protect(&CT_sockclass); if (CT_sockclass.ce_cb_active && CT_sockclass.ce_callbacks.class_delete) - (*CT_sockclass.ce_callbacks.class_delete)(core->name,sockcls); + (*CT_sockclass.ce_callbacks.class_delete) (core->name, sockcls, + CT_sockclass.typeID); - sock_reclassify_class ( sockcls ); + sock_reclassify_class(sockcls); ce_release(&CT_sockclass); - ckrm_release_core_class(core); // Hubertus .... could just drop the class .. error message + ckrm_release_core_class(core); + // Hubertus .... could just drop the class .. error message + return 0; } - -static int -sock_show_members(struct ckrm_core_class *core, struct seq_file *seq) +static int sock_show_members(struct ckrm_core_class *core, struct seq_file *seq) { struct list_head *lh; struct ckrm_net_struct *ns = NULL; class_lock(core); list_for_each(lh, &core->objlist) { - ns = container_of(lh, struct ckrm_net_struct,ckrm_link); - seq_printf(seq, "%d.%d.%d.%d\\%d\n", - NIPQUAD(ns->ns_daddrv4),ns->ns_dport); + ns = container_of(lh, struct ckrm_net_struct, ckrm_link); + seq_printf(seq, "%d.%d.%d.%d\\%d\n", + NIPQUAD(ns->ns_daddrv4), ns->ns_dport); } class_unlock(core); @@ -359,7 +365,8 @@ sock_show_members(struct ckrm_core_class *core, struct seq_file *seq) } static int -sock_forced_reclassify_ns(struct ckrm_net_struct *tns, struct ckrm_core_class *core) +sock_forced_reclassify_ns(struct ckrm_net_struct *tns, + struct ckrm_core_class *core) { struct ckrm_net_struct *ns = NULL; struct sock *sk = NULL; @@ -373,10 +380,13 @@ sock_forced_reclassify_ns(struct ckrm_net_struct *tns, struct ckrm_core_class *c newcls = class_type(struct ckrm_sock_class, core); // lookup the listening sockets // returns with a reference count set on socket - sk = tcp_v4_lookup_listener(tns->ns_daddrv4,tns->ns_dport,0); + if (tns->ns_family == AF_INET6) + return -EOPNOTSUPP; + + sk = tcp_v4_lookup_listener(tns->ns_daddrv4, tns->ns_dport, 0); if (!sk) { printk(KERN_INFO "No such listener 0x%x:%d\n", - tns->ns_daddrv4, tns->ns_dport); + tns->ns_daddrv4, tns->ns_dport); return rc; } lock_sock(sk); @@ -385,12 +395,17 @@ sock_forced_reclassify_ns(struct ckrm_net_struct *tns, struct ckrm_core_class *c } ns = sk->sk_ns; ckrm_ns_hold(ns); + if (!capable(CAP_NET_ADMIN) && (ns->ns_tsk->user != current->user)) { + ckrm_ns_put(ns); + rc = -EPERM; + goto out; + } + oldcls = ns->core; if ((oldcls == NULL) || (oldcls == newcls)) { ckrm_ns_put(ns); goto out; } - // remove the net_struct from the current class class_lock(class_core(oldcls)); list_del(&ns->ckrm_link); @@ -401,37 +416,35 @@ sock_forced_reclassify_ns(struct ckrm_net_struct *tns, struct ckrm_core_class *c sock_set_class(ns, newcls, oldcls, CKRM_EVENT_MANUAL); ckrm_ns_put(ns); rc = 0; -out: + out: release_sock(sk); sock_put(sk); return rc; -} +} enum sock_target_token_t { - IPV4, IPV6, SOCKC_TARGET_ERR + IPV4, IPV6, SOCKC_TARGET_ERR }; static match_table_t sock_target_tokens = { {IPV4, "ipv4=%s"}, {IPV6, "ipv6=%s"}, - {SOCKC_TARGET_ERR, NULL}, + {SOCKC_TARGET_ERR, NULL}, }; -char * -v4toi(char *s, char c, __u32 *v) +char *v4toi(char *s, char c, __u32 * v) { - unsigned int k = 0, n = 0; + unsigned int k = 0, n = 0; - while(*s && (*s != c)) { + while (*s && (*s != c)) { if (*s == '.') { n <<= 8; n |= k; k = 0; - } - else - k = k *10 + *s - '0'; + } else + k = k * 10 + *s - '0'; s++; } @@ -442,19 +455,29 @@ v4toi(char *s, char c, __u32 *v) } static int -sock_forced_reclassify(struct ckrm_core_class *target,const char *options) -{ - char *p,*p2; +sock_forced_reclassify(struct ckrm_core_class *target, const char *options) +{ + char *p, *p2; struct ckrm_net_struct ns; __u32 v4addr, tmp; if (!options) - return 1; - - while ((p = strsep((char**)&options, ",")) != NULL) { + return -EINVAL; + + if (target == NULL) { + unsigned long id = simple_strtol(options,NULL,0); + if (!capable(CAP_NET_ADMIN)) + return -EPERM; + if (id != 0) + return -EINVAL; + printk(KERN_DEBUG "sock_class: reclassify all not net implemented\n"); + return 0; + } + + while ((p = strsep((char **)&options, ",")) != NULL) { substring_t args[MAX_OPT_ARGS]; int token; - + if (!*p) continue; token = match_token(p, sock_target_tokens, args); @@ -463,33 +486,33 @@ sock_forced_reclassify(struct ckrm_core_class *target,const char *options) case IPV4: p2 = p; - while(*p2 && (*p2 != '=')) + while (*p2 && (*p2 != '=')) ++p2; p2++; - p2 = v4toi(p2, '\\',&(v4addr)); + p2 = v4toi(p2, '\\', &(v4addr)); ns.ns_daddrv4 = htonl(v4addr); - ns.ns_family = 4; //IPPROTO_IPV4 - p2 = v4toi(++p2, ':',&tmp); ns.ns_dport = (__u16)tmp; - p2 = v4toi(++p2,'\0',&ns.ns_pid); - - sock_forced_reclassify_ns(&ns,target); + ns.ns_family = AF_INET; + p2 = v4toi(++p2, ':', &tmp); + ns.ns_dport = (__u16) tmp; + if (*p2) + p2 = v4toi(++p2, '\0', &ns.ns_pid); + sock_forced_reclassify_ns(&ns, target); break; case IPV6: printk(KERN_INFO "rcfs: IPV6 not supported yet\n"); - return 0; + return -ENOSYS; default: - return 0; + return -EINVAL; } } - return 1; -} + return -EINVAL; +} /* * Listen_aq reclassification. */ -static void -sock_reclassify_class(struct ckrm_sock_class *cls) +static void sock_reclassify_class(struct ckrm_sock_class *cls) { struct ckrm_net_struct *ns, *tns; struct ckrm_core_class *core = class_core(cls); @@ -513,42 +536,41 @@ sock_reclassify_class(struct ckrm_sock_class *cls) list_splice_init(&core->objlist, &local_list); class_unlock(core); ckrm_core_drop(core); - + list_for_each_entry_safe(ns, tns, &local_list, ckrm_link) { ckrm_ns_hold(ns); list_del(&ns->ckrm_link); if (ns->ns_sk) { lock_sock(ns->ns_sk); - sock_set_class(ns, &sockclass_dflt_class, NULL, CKRM_EVENT_MANUAL); + sock_set_class(ns, &sockclass_dflt_class, NULL, + CKRM_EVENT_MANUAL); release_sock(ns->ns_sk); } ckrm_ns_put(ns); } - return ; + return; } -void __init -ckrm_meta_init_sockclass(void) +void __init ckrm_meta_init_sockclass(void) { - printk("...... Initializing ClassType<%s> ........\n",CT_sockclass.name); + printk(KERN_DEBUG "...... Initializing ClassType<%s> ........\n", + CT_sockclass.name); // intialize the default class ckrm_init_core_class(&CT_sockclass, class_core(&sockclass_dflt_class), - NULL,dflt_sockclass_name); + NULL, dflt_sockclass_name); // register classtype and initialize default task class ckrm_register_classtype(&CT_sockclass); ckrm_register_event_set(sock_events_callbacks); - // note registeration of all resource controllers will be done later dynamically - // as these are specified as modules + // note registeration of all resource controllers will be done + // later dynamically as these are specified as modules } - - #if 1 -/*************************************************************************************** +/***************************************************************************** * Debugging Network Classes: Utility functions - **************************************************************************************/ + *****************************************************************************/ #endif diff --git a/kernel/ckrm/ckrm_tc.c b/kernel/ckrm/ckrm_tc.c index 23ebb3a20..af95644f2 100644 --- a/kernel/ckrm/ckrm_tc.c +++ b/kernel/ckrm/ckrm_tc.c @@ -318,7 +318,7 @@ static void cb_taskclass_fork(struct task_struct *tsk) ckrm_task_unlock(tsk->parent); } if (!list_empty(&tsk->taskclass_link)) - printk("BUG in cb_fork.. tsk (%s:%d> already linked\n", + printk(KERN_WARNING "BUG in cb_fork.. tsk (%s:%d> already linked\n", tsk->comm, tsk->pid); ckrm_set_taskclass(tsk, cls, NULL, CKRM_EVENT_FORK); @@ -669,7 +669,7 @@ static int ckrm_free_task_class(struct ckrm_core_class *core) void __init ckrm_meta_init_taskclass(void) { - printk("...... Initializing ClassType<%s> ........\n", + printk(KERN_DEBUG "...... Initializing ClassType<%s> ........\n", CT_taskclass.name); // intialize the default class ckrm_init_core_class(&CT_taskclass, class_core(&taskclass_dflt_class), @@ -737,7 +737,7 @@ void check_tasklist_sanity(struct ckrm_task_class *cls) class_lock(core); if (list_empty(&core->objlist)) { class_lock(core); - printk("check_tasklist_sanity: class %s empty list\n", + printk(KERN_DEBUG "check_tasklist_sanity: class %s empty list\n", core->name); return; } @@ -746,14 +746,14 @@ void check_tasklist_sanity(struct ckrm_task_class *cls) container_of(lh1, struct task_struct, taskclass_link); if (count++ > 20000) { - printk("list is CORRUPTED\n"); + printk(KERN_WARNING "list is CORRUPTED\n"); break; } if (tsk->taskclass != cls) { const char *tclsname; tclsname = (tsk->taskclass) ? class_core(tsk->taskclass)->name:"NULL"; - printk("sanity: task %s:%d has ckrm_core " + printk(KERN_WARNING "sanity: task %s:%d has ckrm_core " "|%s| but in list |%s|\n", tsk->comm, tsk->pid, tclsname, core->name); } @@ -767,7 +767,7 @@ void ckrm_debug_free_task_class(struct ckrm_task_class *tskcls) struct task_struct *proc, *thread; int count = 0; - printk("Analyze Error <%s> %d\n", + printk(KERN_DEBUG "Analyze Error <%s> %d\n", class_core(tskcls)->name, atomic_read(&(class_core(tskcls)->refcnt))); @@ -779,7 +779,7 @@ void ckrm_debug_free_task_class(struct ckrm_task_class *tskcls) const char *tclsname; tclsname = (thread->taskclass) ? class_core(thread->taskclass)->name :"NULL"; - printk("%d thread=<%s:%d> -> <%s> <%lx>\n", count, + printk(KERN_DEBUG "%d thread=<%s:%d> -> <%s> <%lx>\n", count, thread->comm, thread->pid, tclsname, thread->flags & PF_EXITING); } @@ -787,7 +787,7 @@ void ckrm_debug_free_task_class(struct ckrm_task_class *tskcls) class_unlock(class_core(tskcls)); read_unlock(&tasklist_lock); - printk("End Analyze Error <%s> %d\n", + printk(KERN_DEBUG "End Analyze Error <%s> %d\n", class_core(tskcls)->name, atomic_read(&(class_core(tskcls)->refcnt))); } diff --git a/kernel/ckrm/rbce/bitvector.h b/kernel/ckrm/rbce/bitvector.h index 4f53f9847..098cc2327 100644 --- a/kernel/ckrm/rbce/bitvector.h +++ b/kernel/ckrm/rbce/bitvector.h @@ -136,12 +136,12 @@ inline static void bitvector_print(int flag, bitvector_t * vec) return; } if (vec == NULL) { - printk("v<0>-NULL\n"); + printk(KERN_DEBUG "v<0>-NULL\n"); return; } - printk("v<%d>-", sz = vec->size); + printk(KERN_DEBUG "v<%d>-", sz = vec->size); for (i = 0; i < sz; i++) { - printk("%c", test_bit(i, vec->bits) ? '1' : '0'); + printk(KERN_DEBUG "%c", test_bit(i, vec->bits) ? '1' : '0'); } return; } diff --git a/kernel/ckrm/rbce/rbce_fs.c b/kernel/ckrm/rbce/rbce_fs.c index bb92fb94c..187e7cdba 100644 --- a/kernel/ckrm/rbce/rbce_fs.c +++ b/kernel/ckrm/rbce/rbce_fs.c @@ -1,6 +1,26 @@ -/* - * This file is released under the GPL. +/* RCFS API for Rule-based Classification Engine (RBCE) and + * Consolidated RBCE module code (combined) + * + * Copyright (C) Hubertus Franke, IBM Corp. 2003 + * (C) Chandra Seetharaman, IBM Corp. 2003 + * (C) Vivek Kashyap, IBM Corp. 2004 + * + * Module for loading of classification policies and providing + * a user API for Class-based Kernel Resource Management (CKRM) + * + * Latest version, more details at http://ckrm.sf.net + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it would be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * */ + #include #include #include @@ -54,12 +74,6 @@ rbce_write(struct file *file, const char __user * buf, if (*ptr == '\n') { *ptr = '\0'; } -#if 0 - if (!strcmp(file->f_dentry->d_name.name, "rbce_reclassify")) { - pid = simple_strtol(line, NULL, 0); - rc = reclassify_pid(pid); - } else -#endif if (!strcmp(file->f_dentry->d_name.name, "rbce_tag")) { pid = simple_strtol(line, &ptr, 0); rc = set_tasktag(pid, ptr + 1); // expected syntax "pid tag" @@ -87,8 +101,7 @@ static int rbce_show(struct seq_file *seq, void *offset) char result[256]; memset(result, 0, 256); - if (!strcmp(file->f_dentry->d_name.name, "rbce_reclassify") || - !strcmp(file->f_dentry->d_name.name, "rbce_tag")) { + if (!strcmp(file->f_dentry->d_name.name, "rbce_tag")) { return -EPERM; } if (!strcmp(file->f_dentry->d_name.name, "rbce_state")) { @@ -117,8 +130,7 @@ static int rbce_close(struct inode *ino, struct file *file) { const char *name = file->f_dentry->d_name.name; - if (strcmp(name, "rbce_reclassify") && - strcmp(name, "rbce_state") && + if (strcmp(name, "rbce_state") && strcmp(name, "rbce_tag") && strcmp(name, "rbce_info")) { if (!rule_exists(name)) { @@ -292,11 +304,9 @@ rbce_create(struct inode *dir, struct dentry *dentry, struct dentry *pd = list_entry(dir->i_dentry.next, struct dentry, d_alias); - // Under /ce only "rbce_reclassify", "rbce_state", "rbce_tag" and - // "rbce_info" are allowed + // Under /ce only "rbce_state", "rbce_tag" and "rbce_info" are allowed if (!strcmp(pd->d_name.name, "ce")) { - if (strcmp(dentry->d_name.name, "rbce_reclassify") && - strcmp(dentry->d_name.name, "rbce_state") && + if (strcmp(dentry->d_name.name, "rbce_state") && strcmp(dentry->d_name.name, "rbce_tag") && strcmp(dentry->d_name.name, "rbce_info")) { return -EINVAL; @@ -319,7 +329,7 @@ rbce_symlink(struct inode *dir, struct dentry *dentry, const char *symname) /******************************* Magic files ********************/ -#define RBCE_NR_MAGF 6 +#define RBCE_NR_MAGF 5 struct rcfs_magf rbce_magf_files[RBCE_NR_MAGF] = { { .name = "ce", @@ -341,11 +351,6 @@ struct rcfs_magf rbce_magf_files[RBCE_NR_MAGF] = { .mode = RCFS_DEFAULT_FILE_MODE, .i_fop = &rbce_file_operations, }, - { - .name = "rbce_reclassify", - .mode = RCFS_DEFAULT_FILE_MODE, - .i_fop = &rbce_file_operations, - }, { .name = "rules", .mode = (RCFS_DEFAULT_DIR_MODE | S_IWUSR), @@ -417,7 +422,7 @@ static struct inode_operations rbce_dir_inode_operations = { static void rbce_put_super(struct super_block *sb) { module_put(THIS_MODULE); - printk("rbce_put_super called\n"); + printk(KERN_DEBUG "rbce_put_super called\n"); } static struct super_operations rbce_ops = { diff --git a/kernel/ckrm/rbce/rbcemod.c b/kernel/ckrm/rbce/rbcemod.c index 4d5f40aef..e0df4d134 100644 --- a/kernel/ckrm/rbce/rbcemod.c +++ b/kernel/ckrm/rbce/rbcemod.c @@ -254,7 +254,7 @@ int rbcedebug = 0x00; #define DBG_RULE ( 0x20 ) #define DBG_POLICY ( 0x40 ) -#define DPRINTK(x, y...) if (rbcedebug & (x)) printk(y) +#define DPRINTK(x, y...) if (rbcedebug & (x)) printk(KERN_DEBUG y) // debugging selectively enabled through /proc/sys/debug/rbce static void print_context_vectors(void) @@ -265,9 +265,9 @@ static void print_context_vectors(void) return; } for (i = 0; i < NUM_TERM_MASK_VECTOR; i++) { - printk("%d: ", i); + printk(KERN_DEBUG "%d: ", i); bitvector_print(DBG_OPTIMIZATION, gl_mask_vecs[i]); - printk("\n"); + printk(KERN_DEBUG "\n"); } } #else @@ -1816,7 +1816,7 @@ static inline int valid_pdata(struct rbce_private_data *pdata) } } spin_unlock(&pdata_lock); - printk("INVALID/CORRUPT PDATA %p\n", pdata); + printk(KERN_WARNING "INVALID/CORRUPT PDATA %p\n", pdata); return 0; } @@ -1829,7 +1829,7 @@ static inline void store_pdata(struct rbce_private_data *pdata) while (i < MAX_PDATA) { if (pdata_arr[pdata_next] == NULL) { - printk("storing %p at %d, count %d\n", pdata, + printk(KERN_DEBUG "storing %p at %d, count %d\n", pdata, pdata_next, pdata_count); pdata_arr[pdata_next++] = pdata; if (pdata_next == MAX_PDATA) { @@ -1844,7 +1844,7 @@ static inline void store_pdata(struct rbce_private_data *pdata) spin_unlock(&pdata_lock); } if (i == MAX_PDATA) { - printk("PDATA BUFFER FULL pdata_count %d pdata %p\n", + printk(KERN_DEBUG "PDATA BUFFER FULL pdata_count %d pdata %p\n", pdata_count, pdata); } } @@ -1856,7 +1856,7 @@ static inline void unstore_pdata(struct rbce_private_data *pdata) spin_lock(&pdata_lock); for (i = 0; i < MAX_PDATA; i++) { if (pdata_arr[i] == pdata) { - printk("unstoring %p at %d, count %d\n", pdata, + printk(KERN_DEBUG "unstoring %p at %d, count %d\n", pdata, i, pdata_count); pdata_arr[i] = NULL; pdata_count--; @@ -1866,7 +1866,7 @@ static inline void unstore_pdata(struct rbce_private_data *pdata) } spin_unlock(&pdata_lock); if (i == MAX_PDATA) { - printk("pdata %p not found in the stored array\n", + printk(KERN_DEBUG "pdata %p not found in the stored array\n", pdata); } } @@ -1929,7 +1929,7 @@ static struct rbce_private_data *create_private_data(struct rbce_private_data // pdata->evaluate = src->evaluate; // if(src->app_tag) { // int len = strlen(src->app_tag)+1; - // printk("CREATE_PRIVATE: apptag %s len %d\n", + // printk(KERN_DEBUG "CREATE_PRIVATE: apptag %s len %d\n", // src->app_tag,len); // pdata->app_tag = kmalloc(len, GFP_ATOMIC); // if (pdata->app_tag) { @@ -2262,7 +2262,7 @@ void *rbce_tc_classify(enum ckrm_event event, ...) * [ CKRM_LATCHABLE_EVENTS .. CKRM_NONLATCHABLE_EVENTS ) */ - // printk("tc_classify %p:%d:%s '%s'\n",tsk,tsk->pid, + // printk(KERN_DEBUG "tc_classify %p:%d:%s '%s'\n",tsk,tsk->pid, // tsk->comm,event_names[event]); switch (event) { @@ -2314,7 +2314,7 @@ void *rbce_tc_classify(enum ckrm_event event, ...) break; } - // printk("tc_classify %p:%d:%s '%s' ==> %p\n",tsk,tsk->pid, + // printk(KERN_DEBUG "tc_classify %p:%d:%s '%s' ==> %p\n",tsk,tsk->pid, // tsk->comm,event_names[event],cls); return cls; @@ -2323,7 +2323,7 @@ void *rbce_tc_classify(enum ckrm_event event, ...) #ifndef RBCE_EXTENSION static void rbce_tc_notify(int event, void *core, struct task_struct *tsk) { - printk("tc_manual %p:%d:%s '%s'\n", tsk, tsk->pid, tsk->comm, + printk(KERN_DEBUG "tc_manual %p:%d:%s '%s'\n", tsk, tsk->pid, tsk->comm, event_names[event]); if (event != CKRM_EVENT_MANUAL) return; @@ -2409,10 +2409,10 @@ static void unregister_classtype_engines(void) while (ceptr->name) { if (*ceptr->clsvar >= 0) { - printk("ce unregister with <%s>\n",ceptr->name); + printk(KERN_DEBUG "ce unregister with <%s>\n",ceptr->name); while ((rc = ckrm_unregister_engine(ceptr->name)) == -EAGAIN) ; - printk("ce unregister with <%s> rc=%d\n",ceptr->name,rc); + printk(KERN_DEBUG "ce unregister with <%s> rc=%d\n",ceptr->name,rc); *ceptr->clsvar = -1; } ceptr++; @@ -2426,7 +2426,7 @@ static int register_classtype_engines(void) while (ceptr->name) { rc = ckrm_register_engine(ceptr->name, ceptr->cbs); - printk("ce register with <%s> typeId=%d\n",ceptr->name,rc); + printk(KERN_DEBUG "ce register with <%s> typeId=%d\n",ceptr->name,rc); if ((rc < 0) && (rc != -ENOENT)) { unregister_classtype_engines(); return (rc); @@ -2506,7 +2506,7 @@ int init_rbce(void) { int rc, i, line; - printk("<1>\nInstalling \'%s\' module\n", modname); + printk(KERN_DEBUG "<1>\nInstalling \'%s\' module\n", modname); for (i = 0; i < CKRM_MAX_CLASSTYPES; i++) { INIT_LIST_HEAD(&rules_list[i]); @@ -2555,7 +2555,7 @@ int init_rbce(void) exit_rbce_ext(); out: - printk("<1>%s: error installing rc=%d line=%d\n", __FUNCTION__, rc, + printk(KERN_DEBUG "<1>%s: error installing rc=%d line=%d\n", __FUNCTION__, rc, line); return rc; } @@ -2564,19 +2564,19 @@ void exit_rbce(void) { int i; - printk("<1>Removing \'%s\' module\n", modname); + printk(KERN_DEBUG "<1>Removing \'%s\' module\n", modname); stop_debug(); exit_rbce_ext(); // Print warnings if lists are not empty, which is a bug if (!list_empty(&class_list)) { - printk("exit_rbce: Class list is not empty\n"); + printk(KERN_DEBUG "exit_rbce: Class list is not empty\n"); } for (i = 0; i < CKRM_MAX_CLASSTYPES; i++) { if (!list_empty(&rules_list[i])) { - printk("exit_rbce: Rules list for classtype %d" + printk(KERN_DEBUG "exit_rbce: Rules list for classtype %d" " is not empty\n", i); } } diff --git a/kernel/ckrm/rbce/rbcemod_ext.c b/kernel/ckrm/rbce/rbcemod_ext.c index b0c6ee9aa..3cae550f7 100644 --- a/kernel/ckrm/rbce/rbcemod_ext.c +++ b/kernel/ckrm/rbce/rbcemod_ext.c @@ -62,10 +62,10 @@ static int ukcc_fileop_notify(int rchan_id, { static int readers = 0; if (fileop == RELAY_FILE_OPEN) { - // printk("got fileop_notify RELAY_FILE_OPEN for file %p\n", + // printk(KERN_DEBUG "got fileop_notify RELAY_FILE_OPEN for file %p\n", // filp); if (readers) { - printk("only one client allowed, backoff .... \n"); + printk(KERN_DEBUG "only one client allowed, backoff .... \n"); return -EPERM; } if (!try_module_get(THIS_MODULE)) @@ -74,7 +74,7 @@ static int ukcc_fileop_notify(int rchan_id, client_attached(); } else if (fileop == RELAY_FILE_CLOSE) { - // printk("got fileop_notify RELAY_FILE_CLOSE for file %p\n", + // printk(KERN_DEBUG "got fileop_notify RELAY_FILE_CLOSE for file %p\n", // filp); client_detached(); readers--; @@ -109,10 +109,10 @@ static int create_ukcc_channel(void) channel_flags, &ukcc_callbacks, 0, 0, 0, 0, 0, 0, NULL, 0); if (ukcc_channel < 0) - printk("crbce: ukcc creation failed, errcode: %d\n", + printk(KERN_DEBUG "crbce: ukcc creation failed, errcode: %d\n", ukcc_channel); else - printk("crbce: ukcc created (%u KB)\n", + printk(KERN_DEBUG "crbce: ukcc created (%u KB)\n", UKCC_TOTAL_BUFFER_SIZE >> 10); return ukcc_channel; } @@ -144,9 +144,9 @@ static inline void close_ukcc_channel(void) (r),(l),-1,NULL) > 0); \ chan_state = chan_isok ? UKCC_OK : UKCC_STANDBY; \ if (chan_wasok && !chan_isok) { \ - printk("Channel stalled\n"); \ + printk(KERN_DEBUG "Channel stalled\n"); \ } else if (!chan_wasok && chan_isok) { \ - printk("Channel continues\n"); \ + printk(KERN_DEBUG "Channel continues\n"); \ } \ } while (0) @@ -288,7 +288,7 @@ send_task_record(struct task_struct *tsk, int event, return 0; pdata = RBCE_DATA(tsk); if (pdata == NULL) { - // printk("send [%d]<%s>: no pdata\n",tsk->pid,tsk->comm); + // printk(KERN_DEBUG "send [%d]<%s>: no pdata\n",tsk->pid,tsk->comm); return 0; } if (send_forced || (delta_mode == 0) @@ -384,7 +384,7 @@ static void send_task_data(void) rec_set_timehdr(&limrec, CRBCE_REC_DATA_DELIMITER, 0, 0); rec_send(&limrec); - // printk("send_task_data mode=%d t#=%d s#=%d\n", + // printk(KERN_DEBUG "send_task_data mode=%d t#=%d s#=%d\n", // delta_mode,taskcnt,sendcnt); } @@ -503,7 +503,7 @@ static void sample_task_data(unsigned long unused) } while_each_thread(proc, thread); read_unlock(&tasklist_lock); -// printk("sample_timer: run=%d wait=%d\n",run,wait); +// printk(KERN_DEBUG "sample_timer: run=%d wait=%d\n",run,wait); start_sample_timer(); } @@ -513,7 +513,7 @@ static void ukcc_cmd_deliver(int rchan_id, char *from, u32 len) struct crbce_cmd_done cmdret; int rc = 0; -// printk("ukcc_cmd_deliver: %d %d len=%d:%d\n",cmdrec->type, +// printk(KERN_DEBUG "ukcc_cmd_deliver: %d %d len=%d:%d\n",cmdrec->type, // cmdrec->cmd,cmdrec->len,len); cmdrec->len = len; // add this to reflection so the user doesn't @@ -578,20 +578,20 @@ static void ukcc_cmd_deliver(int rchan_id, char *from, u32 len) cmdret.hdr.cmd = cmdrec->cmd; cmdret.rc = rc; rec_send(&cmdret); -// printk("ukcc_cmd_deliver ACK: %d %d rc=%d %d\n",cmdret.hdr.type, +// printk(KERN_DEBUG "ukcc_cmd_deliver ACK: %d %d rc=%d %d\n",cmdret.hdr.type, // cmdret.hdr.cmd,rc,sizeof(cmdret)); } static void client_attached(void) { - printk("client [%d]<%s> attached to UKCC\n", current->pid, + printk(KERN_DEBUG "client [%d]<%s> attached to UKCC\n", current->pid, current->comm); relay_reset(ukcc_channel); } static void client_detached(void) { - printk("client [%d]<%s> detached to UKCC\n", current->pid, + printk(KERN_DEBUG "client [%d]<%s> detached to UKCC\n", current->pid, current->comm); chan_state = UKCC_STANDBY; stop_sample_timer(); diff --git a/kernel/ckrm/rbce/token.c b/kernel/ckrm/rbce/token.c index 7bcdf5492..32446fb2b 100644 --- a/kernel/ckrm/rbce/token.c +++ b/kernel/ckrm/rbce/token.c @@ -293,7 +293,7 @@ rules_parse(char *rule_defn, struct rbce_rule_term **rterms, int *term_mask) *term_mask = 0; } /* else { for (i = 0; i < nterms; i++) { - printk("token: i %d; op %d, operator %d, str %ld\n", + printk(KERN_DEBUG "token: i %d; op %d, operator %d, str %ld\n", i, terms[i].op, terms[i].operator, terms[i].u.id); } } */ -- 2.43.0