/**
* Free a single cgroup_rule struct.
- * @param r The rule to free from memory
+ * @param r The rule to free from memory
*/
static void cgroup_free_rule(struct cgroup_rule *r)
{
r->procname = NULL;
}
/* We must free any used controller strings, too. */
- for(i = 0; i < MAX_MNT_ELEMENTS; i++) {
+ for (i = 0; i < MAX_MNT_ELEMENTS; i++) {
if (r->controllers[i])
free(r->controllers[i]);
}
/**
* Free a list of cgroup_rule structs. If rl is the main list of rules,
* the lock must be taken for writing before calling this function!
- * @param rl Pointer to the list of rules to free from memory
+ * @param rl Pointer to the list of rules to free from memory
*/
static void cgroup_free_rule_list(struct cgroup_rule_list *rl)
{
* as well as any children rules (rules that begin with a %) that it has.
*
* This function is NOT thread safe!
- * @param cache True to cache rules, else false
- * @param muid If cache is false, the UID to match against
- * @param mgid If cache is false, the GID to match against
- * @return 0 on success, -1 if no cache and match found, > 0 on error.
+ * @param cache True to cache rules, else false
+ * @param muid If cache is false, the UID to match against
+ * @param mgid If cache is false, the GID to match against
+ * @return 0 on success, -1 if no cache and match found, > 0 on error.
* TODO: Make this function thread safe!
*/
static int cgroup_parse_rules(bool cache, uid_t muid,
}
}
- if (uid == muid || gid == mgid || uid == CGRULE_WILD) {
+ if (uid == muid || gid == mgid || uid == CGRULE_WILD)
matched = true;
- }
if (!cache) {
if (!matched)
continue;
}
- /* FIXME: basename() modifies the string and really shouldn't! */
+ /*
+ * FIXME: basename() modifies the
+ * string and really shouldn't!
+ **/
if (strcmp(mprocname, procname) &&
strcmp(basename(mprocname), procname)) {
cgroup_dbg("Added rule %s (UID: %d, GID: %d) -> %s for"
" controllers:", lst->tail->username, lst->tail->uid,
lst->tail->gid, lst->tail->destination);
- for (i = 0; lst->tail->controllers[i]; i++) {
+ for (i = 0; lst->tail->controllers[i]; i++)
cgroup_dbg(" %s", lst->tail->controllers[i]);
- }
cgroup_dbg("\n");
/* Finally, clear the buffer. */
FILE *proc_cgroup = NULL;
char subsys_name[FILENAME_MAX];
int hierarchy, num_cgroups, enabled;
- int i=0;
+ int i = 0;
int j;
int duplicate = 0;
char *mntopt = NULL;
/* do not have duplicates in mount table */
duplicate = 0;
for (j = 0; j < found_mnt; j++) {
- if (strncmp(mntopt, cg_mount_table[j].name, FILENAME_MAX)
- == 0) {
+ if (strncmp(mntopt, cg_mount_table[j].name,
+ FILENAME_MAX) == 0) {
duplicate = 1;
break;
}
int ret = 1;
proc_mount = fopen("/proc/mounts", "r");
- if (proc_mount == NULL) {
+ if (proc_mount == NULL)
return 0;
- }
temp_ent = (struct mntent *) malloc(sizeof(struct mntent));
if (!temp_ent) {
goto done;
}
- while (strcmp(ent->mnt_type, "cgroup") !=0) {
+ while (strcmp(ent->mnt_type, "cgroup") != 0) {
ent = getmntent_r(proc_mount, temp_ent, mntent_buff,
sizeof(mntent_buff));
if (ent == NULL) {
/* Call with cg_mount_table_lock taken */
-static char *cg_build_path_locked(const char *name, char *path, const char *type)
+static char *cg_build_path_locked(const char *name, char *path,
+ const char *type)
{
int i;
for (i = 0; cg_mount_table[i].name[0] != '\0'; i++) {
char *tmp;
tmp = strdup(path);
- /* FIXME: missing OOM check here! */
+ /* FIXME: missing OOM check here! */
sprintf(path, "%s%s/", tmp, name);
free(tmp);
cgroup_dbg("libcgroup is not initialized\n");
return ECGROUPNOTINITIALIZED;
}
- if(!cgroup)
- {
+ if (!cgroup) {
pthread_rwlock_rdlock(&cg_mount_table_lock);
- for(i = 0; i < CG_CONTROLLER_MAX &&
- cg_mount_table[i].name[0]!='\0'; i++) {
+ for (i = 0; i < CG_CONTROLLER_MAX &&
+ cg_mount_table[i].name[0] != '\0'; i++) {
if (!cg_build_path_locked(NULL, path,
cg_mount_table[i].name))
continue;
* @param target_tasks Opened tasks file of the target group, where all
* processes should be moved.
* @param flags Flag indicating whether the errors from task
- * migration should be ignored (CGROUP_DELETE_IGNORE_MIGRATION) or not (0).
+ * migration should be ignored (CGROUP_DELETE_IGNORE_MIGRATION) or not (0).
* @returns 0 on success, >0 on error.
*/
static int cg_delete_cgroup_controller(char *cgroup_name, char *controller,
* will assume that the callers have taken care of everything.
* Including the locking.
*/
-static int cg_rd_ctrl_file(const char *subsys, const char *cgroup, const char *file, char **value)
+static int cg_rd_ctrl_file(const char *subsys, const char *cgroup,
+ const char *file, char **value)
{
char path[FILENAME_MAX];
FILE *ctrl_file = NULL;
* This function uses rl_lock.
*
* This function may NOT be thread safe.
- * @param uid The UID to match
- * @param gid The GID to match
- * @param procname The PROCESS NAME to match
- * @return Pointer to the first matching rule, or NULL if no match
+ * @param uid The UID to match
+ * @param gid The GID to match
+ * @param procname The PROCESS NAME to match
+ * @return Pointer to the first matching rule, or NULL if no match
* TODO: Determine thread-safeness and fix if not safe.
*/
static struct cgroup_rule *cgroup_find_matching_rule(uid_t uid,
break;
if (!strcmp(ret->procname, procname))
break;
-
- /* FIXME: basename() modifies the string and really shouldn't! */
+ /*
+ * FIXME: basename() modifies the string and really shouldn't!
+ **/
if (!strcmp(ret->procname, basename(procname)))
/* Check a rule of basename. */
cgroup_dbg("Executing rule %s for PID %d... ", tmp->username,
pid);
ret = cgroup_change_cgroup_path(tmp->destination,
- pid, (const char* const*)tmp->controllers);
+ pid, (const char * const *)tmp->controllers);
if (ret) {
cgroup_dbg("FAILED! (Error Code: %d)\n", ret);
goto finished;
* function is deprecated, and cgroup_change_cgroup_uid_gid_flags() should be
* used instead. In fact, this function simply calls the newer one with flags
* set to 0 (none).
- * @param uid The UID to match
- * @param gid The GID to match
- * @param pid The PID of the process to move
- * @return 0 on success, > 0 on error
+ * @param uid The UID to match
+ * @param gid The GID to match
+ * @param pid The PID of the process to move
+ * @return 0 on success, > 0 on error
*
*/
int cgroup_change_cgroup_uid_gid(uid_t uid, gid_t gid, pid_t pid)
*
* returns 0 on success.
*/
-int cgroup_change_cgroup_path(const char *dest, pid_t pid, const char *const controllers[])
+int cgroup_change_cgroup_path(const char *dest, pid_t pid,
+ const char *const controllers[])
{
int ret;
struct cgroup cgroup;
* Print the cached rules table. This function should be called only after
* first calling cgroup_parse_config(), but it will work with an empty rule
* list.
- * @param fp The file stream to print to
+ * @param fp The file stream to print to
*/
void cgroup_print_rules_config(FILE *fp)
{
fprintf(fp, " CONTROLLERS:\n");
for (i = 0; i < MAX_MNT_ELEMENTS; i++) {
- if (itr->controllers[i]) {
+ if (itr->controllers[i])
fprintf(fp, " %s\n", itr->controllers[i]);
- }
}
fprintf(fp, "\n");
itr = itr->next;
/**
* Reloads the rules list, using the given configuration file. This function
* is probably NOT thread safe (calls cgroup_parse_rules()).
- * @return 0 on success, > 0 on failure
+ * @return 0 on success, > 0 on failure
*/
int cgroup_reload_cached_rules(void)
{
/**
* Initializes the rules cache.
- * @return 0 on success, > 0 on error
+ * @return 0 on success, > 0 on error
*/
int cgroup_init_rules_cache(void)
{
* @pid: pid of the current process for which the path is to be determined
* @controller: name of the controller for which to determine current path
* @current_path: a pointer that is filled with the value of the current
- * path as seen in /proc/<pid>/cgroup
+ * path as seen in /proc/<pid>/cgroup
*/
int cgroup_get_current_controller_path(pid_t pid, const char *controller,
char **current_path)
const char *cgroup_strerror(int code)
{
- if (code == ECGOTHER) {
+ if (code == ECGOTHER)
return strerror_r(cgroup_get_last_errno(), errtext, MAXLEN);
- }
+
return cgroup_strerror_codes[code % ECGROUPNOTCOMPILED];
}
/*
* TODO: Need to decide a better place to put this function.
*/
-int cgroup_walk_tree_begin(const char *controller, const char *base_path, int depth,
- void **handle, struct cgroup_file_info *info,
- int *base_level)
+int cgroup_walk_tree_begin(const char *controller, const char *base_path,
+ int depth, void **handle, struct cgroup_file_info *info,
+ int *base_level)
{
int ret = 0;
cgroup_dbg("path is %s\n", base_path);
/*
* TODO: Need to decide a better place to put this function.
*/
-int cgroup_read_stats_begin(const char *controller, const char *path, void **handle,
- struct cgroup_stat *stat)
+int cgroup_read_stats_begin(const char *controller, const char *path,
+ void **handle, struct cgroup_stat *stat)
{
int ret = 0;
char stat_file[FILENAME_MAX];
return 0;
}
-int cgroup_get_task_begin(const char *cgroup, const char *controller, void **handle,
- pid_t *pid)
+int cgroup_get_task_begin(const char *cgroup, const char *controller,
+ void **handle, pid_t *pid)
{
int ret = 0;
char path[FILENAME_MAX];
* @param pname_cmdline: The process name taken from /proc/<pid>/cmdline
* @return 0 on success, > 0 on error.
*/
-static int cg_get_procname_from_proc_cmdline(pid_t pid, const char *pname_status,
- char **pname_cmdline)
+static int cg_get_procname_from_proc_cmdline(pid_t pid,
+ const char *pname_status, char **pname_cmdline)
{
FILE *f;
int ret = ECGFAIL;
projects / thirdparty / libcgroup.git / commitdiff
