#include <linux/module.h>
#include <linux/fs.h>
#include <linux/namei.h>
-#include <asm/namei.h>
#include <linux/namespace.h>
#include <linux/dcache.h>
#include <linux/seq_file.h>
#include <linux/rcfs.h>
-
-
-
/******************************************************
* Macros
*
*
*****************************************************/
-
#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 *) \
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 \
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]; \
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); \
return 0; \
} \
} \
- return 1; \
+ return (*resstr != NULL); \
}
#define MAGIC_WRITE(FUNC,CLSTYPEFUN) \
kfree(resname); \
return rc ? rc : count; \
}
-
-
+
#define MAGIC_RD_FILEOPS(FUNC) \
struct file_operations FUNC ## _fileops = { \
.open = FUNC ## _open, \
}; \
EXPORT_SYMBOL(FUNC ## _fileops);
-
#define MAGIC_RDWR_FILEOPS(FUNC) \
struct file_operations FUNC ## _fileops = { \
.open = FUNC ## _open, \
}; \
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);
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
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)
{
if (!options)
return 1;
-
+
while ((p = strsep(&options, ",")) != NULL) {
-
+
substring_t args[MAX_OPT_ARGS];
int token;
-
+
if (!*p)
continue;
}
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;
int rc = 0;
struct ckrm_core_class *core;
int done;
- char *resname;
+ char *resname = NULL;
struct ckrm_shares newshares = {
CKRM_SHARE_UNCHANGED,
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) {
}
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);
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<count; i++) {
- mfdentry = rcfs_create_internal(parent, &magf[i],0);
+ for (i = 0; i < count; i++) {
+ mfdentry = rcfs_create_internal(parent, &magf[i], 0);
if (IS_ERR(mfdentry)) {
rcfs_clear_magic(parent);
return -ENOMEM;
}
return 0;
}
+
EXPORT_SYMBOL(rcfs_create_magic);
* Created.
*/
-
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/namei.h>
-#include <asm/namei.h>
#include <linux/namespace.h>
#include <linux/dcache.h>
#include <linux/seq_file.h>
#include <linux/rcfs.h>
-
-
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
* @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);
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)
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;
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
// extern struct rcfs_magf rbce_mfdesc;
-
-struct rcfs_mfdesc *genmfdesc[]={
+struct rcfs_mfdesc *genmfdesc[] = {
#ifdef CONFIG_CKRM_TYPE_TASKCLASS
&tc_mfdesc,
#else
#else
NULL,
#endif
-// Create similar entry for RBCE ?
-//#ifdef CONFIG_CKRM_CE
-// &rbce_mfdesc,
-//#else
-// NULL,
-//#endif
-
};
-
-
-
-
* Created.
*/
-
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/namei.h>
-#include <asm/namei.h>
#include <linux/namespace.h>
#include <linux/dcache.h>
#include <linux/seq_file.h>
#include <linux/rcfs.h>
#include <linux/ckrm.h>
-
+#include <linux/ckrm_rc.h>
+#include <linux/ckrm_ce.h>
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;
{
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) {
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);
}
sb->s_root = root;
-
// Link inode and core class
rootri = RCFS_I(inode);
rootri->name = kmalloc(strlen(RCFS_ROOT) + 1, GFP_KERNEL);
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; i<CKRM_MAX_CLASSTYPES; i++) {
+ for (i = 0; i < CKRM_MAX_CLASSTYPES; i++) {
clstype = ckrm_classtypes[i];
- if (clstype == NULL)
+ if (clstype == NULL)
continue;
- printk("A non null classtype\n");
+ printk(KERN_DEBUG "A non null classtype\n");
if ((rc = rcfs_register_classtype(clstype)))
- continue ; // could return with an error too
+ continue; // could return with an error too
}
+ // do post-mount initializations needed by CE
+ // this is distinct from CE registration done on rcfs module load
+ if (rcfs_engine_regd) {
+ if (rcfs_eng_callbacks.mnt)
+ if ((rc = (*rcfs_eng_callbacks.mnt) ())) {
+ printk(KERN_ERR "Error in CE mnt %d\n", rc);
+ }
+ }
+ // Following comment handled by code above; keep nonetheless if it
+ // can be done better
+ //
// register CE's with rcfs
// check if CE loaded
// call rcfs_register_engine for each classtype
return 0;
}
-
static struct super_block *rcfs_get_sb(struct file_system_type *fs_type,
- int flags, const char *dev_name, void *data)
+ int flags, const char *dev_name,
+ void *data)
{
return get_sb_nodev(fs_type, flags, data, rcfs_fill_super);
}
-
-void
-rcfs_kill_sb(struct super_block *sb)
+void rcfs_kill_sb(struct super_block *sb)
{
- int i,rc;
+ int i, rc;
struct ckrm_classtype *clstype;
if (sb->s_fs_info != rcfs_root) {
}
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))) {
// 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,
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)
{
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;
}
}
module_init(init_rcfs_fs)
-module_exit(exit_rcfs_fs)
+ module_exit(exit_rcfs_fs)
-MODULE_LICENSE("GPL");
+ MODULE_LICENSE("GPL");
} else {
name = cls->core->name;
}
- printk("freeing memclass %p of <core:%s>\n", cls, name);
+ printk(KERN_DEBUG "freeing memclass %p of <core:%s>\n", cls, name);
// BUG_ON(ckrm_memclass_valid(cls));
// kfree(cls);
#include <net/sock.h>
#include <linux/ip.h>
+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 *
/*
* 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;
}
read_lock(&ckrm_class_lock);
- for ( i=0 ; i<CKRM_MAX_CLASSTYPES; i++) {
+ for (i = 0; i < CKRM_MAX_CLASSTYPES; i++) {
struct ckrm_classtype *ctype = ckrm_classtypes[i];
struct ckrm_core_class *core;
- if (ctype == NULL)
+ if (ctype == NULL)
continue;
list_for_each_entry(core, &ctype->classes, clslist) {
if (core->name && !strcmp(core->name, classname)) {
* 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);
*
* 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;
}
*
* 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;
}
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;
/*
*/
-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;
}
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);
* 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)) {
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;
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;
}
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;
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;
*/
if (!ckrm_is_core_valid(core))
- return ;
+ return;
clstype = core->classtype;
core->res_class[resid] = NULL;
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");
*
*/
-#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;
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
* 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.
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
}
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;
* 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;
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;
}
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);
}
*
* 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;
}
/* 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 ; i<CKRM_MAX_CLASSTYPES; i++) {
+ for (i = CKRM_RESV_CLASSTYPES; i < CKRM_MAX_CLASSTYPES; i++) {
if (ckrm_classtypes[i] == NULL) {
tid = i;
break;
}
}
}
- if (tid == -1)
+ if (tid == -1)
return -EBUSY;
clstype->typeID = 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
}
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 ; i<CKRM_MAX_CLASSTYPES; i++) {
+ for (i = 0; i < CKRM_MAX_CLASSTYPES; i++) {
struct ckrm_classtype *ctype = ckrm_classtypes[i];
- if (ctype && !strncmp(ctype->name,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;
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);
}
}
* (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;
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]);
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;
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;
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);
EXPORT_SYMBOL(ckrm_class_set_shares);
EXPORT_SYMBOL(ckrm_class_reset_stats);
-
-
if (!cls)
return -EINVAL;
- printk("ckrm_cpu config='%s'\n",cfgstr);
+ printk(KERN_DEBUG "ckrm_cpu config='%s'\n",cfgstr);
return 0;
}
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;
}
}
cpu_monitor_pid = -1;
thread_exit = 2;
- printk("cpu_monitord exit\n");
+ printk(KERN_DEBUG "cpu_monitord exit\n");
return 0;
}
{
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) {
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;
}
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) {
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);
if (!res)
return -EINVAL;
- printk("numtasks config='%s'\n", cfgstr);
+ printk(KERN_DEBUG "numtasks config='%s'\n", cfgstr);
return 0;
}
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);
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
*
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;
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;
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
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;
class_unlock(class_core(newcls));
ckrm_core_drop(class_core(newcls));
}
-
// the socket is already locked
sk->sk_ns = NULL;
sock_put(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;
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);
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);
}
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;
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);
}
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);
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++;
}
}
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);
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);
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
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);
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),
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;
}
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);
}
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)));
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);
}
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)));
}
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;
}
-/*
- * 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 <linux/fs.h>
#include <linux/init.h>
#include <linux/errno.h>
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"
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")) {
{
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)) {
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;
/******************************* Magic files ********************/
-#define RBCE_NR_MAGF 6
+#define RBCE_NR_MAGF 5
struct rcfs_magf rbce_magf_files[RBCE_NR_MAGF] = {
{
.name = "ce",
.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),
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 = {
#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)
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
}
}
spin_unlock(&pdata_lock);
- printk("INVALID/CORRUPT PDATA %p\n", pdata);
+ printk(KERN_WARNING "INVALID/CORRUPT PDATA %p\n", pdata);
return 0;
}
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) {
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);
}
}
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--;
}
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);
}
}
// 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) {
* [ 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) {
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;
#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;
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++;
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);
{
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]);
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;
}
{
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);
}
}
{
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))
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--;
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;
}
(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)
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)
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);
}
}
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();
}
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
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();
*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);
}
} */
git://git.onelab.eu / linux-2.6.git / commitdiff