.ct_owner = THIS_MODULE,
 };
 
-static struct dlm_cluster *to_cluster(struct config_item *i)
+static struct dlm_cluster *config_item_to_cluster(struct config_item *i)
 {
        return i ? container_of(to_config_group(i), struct dlm_cluster, group) :
                   NULL;
 }
 
-static struct dlm_space *to_space(struct config_item *i)
+static struct dlm_space *config_item_to_space(struct config_item *i)
 {
        return i ? container_of(to_config_group(i), struct dlm_space, group) :
                   NULL;
 }
 
-static struct dlm_comm *to_comm(struct config_item *i)
+static struct dlm_comm *config_item_to_comm(struct config_item *i)
 {
        return i ? container_of(i, struct dlm_comm, item) : NULL;
 }
 
-static struct dlm_node *to_node(struct config_item *i)
+static struct dlm_node *config_item_to_node(struct config_item *i)
 {
        return i ? container_of(i, struct dlm_node, item) : NULL;
 }
 
 static void drop_cluster(struct config_group *g, struct config_item *i)
 {
-       struct dlm_cluster *cl = to_cluster(i);
+       struct dlm_cluster *cl = config_item_to_cluster(i);
        struct config_item *tmp;
        int j;
 
 
 static void release_cluster(struct config_item *i)
 {
-       struct dlm_cluster *cl = to_cluster(i);
+       struct dlm_cluster *cl = config_item_to_cluster(i);
        kfree(cl->group.default_groups);
        kfree(cl);
 }
 
 static void drop_space(struct config_group *g, struct config_item *i)
 {
-       struct dlm_space *sp = to_space(i);
+       struct dlm_space *sp = config_item_to_space(i);
        struct config_item *tmp;
        int j;
 
 
 static void release_space(struct config_item *i)
 {
-       struct dlm_space *sp = to_space(i);
+       struct dlm_space *sp = config_item_to_space(i);
        kfree(sp->group.default_groups);
        kfree(sp);
 }
 
 static void drop_comm(struct config_group *g, struct config_item *i)
 {
-       struct dlm_comm *cm = to_comm(i);
+       struct dlm_comm *cm = config_item_to_comm(i);
        if (local_comm == cm)
                local_comm = NULL;
        dlm_lowcomms_close(cm->nodeid);
 
 static void release_comm(struct config_item *i)
 {
-       struct dlm_comm *cm = to_comm(i);
+       struct dlm_comm *cm = config_item_to_comm(i);
        kfree(cm);
 }
 
 static struct config_item *make_node(struct config_group *g, const char *name)
 {
-       struct dlm_space *sp = to_space(g->cg_item.ci_parent);
+       struct dlm_space *sp = config_item_to_space(g->cg_item.ci_parent);
        struct dlm_node *nd;
 
        nd = kzalloc(sizeof(struct dlm_node), GFP_KERNEL);
 
 static void drop_node(struct config_group *g, struct config_item *i)
 {
-       struct dlm_space *sp = to_space(g->cg_item.ci_parent);
-       struct dlm_node *nd = to_node(i);
+       struct dlm_space *sp = config_item_to_space(g->cg_item.ci_parent);
+       struct dlm_node *nd = config_item_to_node(i);
 
        mutex_lock(&sp->members_lock);
        list_del(&nd->list);
 
 static void release_node(struct config_item *i)
 {
-       struct dlm_node *nd = to_node(i);
+       struct dlm_node *nd = config_item_to_node(i);
        kfree(nd);
 }
 
 static ssize_t show_cluster(struct config_item *i, struct configfs_attribute *a,
                            char *buf)
 {
-       struct dlm_cluster *cl = to_cluster(i);
+       struct dlm_cluster *cl = config_item_to_cluster(i);
        struct cluster_attribute *cla =
                        container_of(a, struct cluster_attribute, attr);
        return cla->show ? cla->show(cl, buf) : 0;
                             struct configfs_attribute *a,
                             const char *buf, size_t len)
 {
-       struct dlm_cluster *cl = to_cluster(i);
+       struct dlm_cluster *cl = config_item_to_cluster(i);
        struct cluster_attribute *cla =
                container_of(a, struct cluster_attribute, attr);
        return cla->store ? cla->store(cl, buf, len) : -EINVAL;
 static ssize_t show_comm(struct config_item *i, struct configfs_attribute *a,
                         char *buf)
 {
-       struct dlm_comm *cm = to_comm(i);
+       struct dlm_comm *cm = config_item_to_comm(i);
        struct comm_attribute *cma =
                        container_of(a, struct comm_attribute, attr);
        return cma->show ? cma->show(cm, buf) : 0;
 static ssize_t store_comm(struct config_item *i, struct configfs_attribute *a,
                          const char *buf, size_t len)
 {
-       struct dlm_comm *cm = to_comm(i);
+       struct dlm_comm *cm = config_item_to_comm(i);
        struct comm_attribute *cma =
                container_of(a, struct comm_attribute, attr);
        return cma->store ? cma->store(cm, buf, len) : -EINVAL;
 static ssize_t show_node(struct config_item *i, struct configfs_attribute *a,
                         char *buf)
 {
-       struct dlm_node *nd = to_node(i);
+       struct dlm_node *nd = config_item_to_node(i);
        struct node_attribute *nda =
                        container_of(a, struct node_attribute, attr);
        return nda->show ? nda->show(nd, buf) : 0;
 static ssize_t store_node(struct config_item *i, struct configfs_attribute *a,
                          const char *buf, size_t len)
 {
-       struct dlm_node *nd = to_node(i);
+       struct dlm_node *nd = config_item_to_node(i);
        struct node_attribute *nda =
                container_of(a, struct node_attribute, attr);
        return nda->store ? nda->store(nd, buf, len) : -EINVAL;
        i = config_group_find_item(space_list, name);
        mutex_unlock(&space_list->cg_subsys->su_mutex);
 
-       return to_space(i);
+       return config_item_to_space(i);
 }
 
 static void put_space(struct dlm_space *sp)
        mutex_lock(&clusters_root.subsys.su_mutex);
 
        list_for_each_entry(i, &comm_list->cg_children, ci_entry) {
-               cm = to_comm(i);
+               cm = config_item_to_comm(i);
 
                if (nodeid) {
                        if (cm->nodeid != nodeid)