*len = newlen;
}
-static char *slurp_file(const char *from)
+static char *slurp_file(const char *from, int fd)
{
char *line = NULL;
char *contents = NULL;
- FILE *f = fopen(from, "r");
+ FILE *f = fdopen(fd, "r");
size_t len = 0, fulllen = 0;
ssize_t linelen;
return true;
}
-/*
- * hierarchies, i.e. 'cpu,cpuacct'
- */
-char **hierarchies;
-int num_hierarchies;
-
struct cgfs_files {
char *name;
uint32_t uid, gid;
}
hierarchies = tmp;
}
-
+
hierarchies[num_hierarchies++] = must_copy_string(h);
return true;
}
{
int i;
- fprintf(stderr, "hierarchies:");
+ fprintf(stderr, "hierarchies:\n");
for (i = 0; i < num_hierarchies; i++) {
if (hierarchies[i])
fprintf(stderr, " %d: %s\n", i, hierarchies[i]);
}
/* do we need to do any massaging here? I'm not sure... */
-static char *find_mounted_controller(const char *controller)
+/* Return the mounted controller and store the corresponding open file descriptor
+ * referring to the controller mountpoint in the private lxcfs namespace in
+ * @cfd.
+ */
+static char *find_mounted_controller(const char *controller, int *cfd)
{
int i;
for (i = 0; i < num_hierarchies; i++) {
if (!hierarchies[i])
continue;
- if (strcmp(hierarchies[i], controller) == 0)
+ if (strcmp(hierarchies[i], controller) == 0) {
+ *cfd = fd_hierarchies[i];
return hierarchies[i];
- if (in_comma_list(controller, hierarchies[i]))
+ }
+ if (in_comma_list(controller, hierarchies[i])) {
+ *cfd = fd_hierarchies[i];
return hierarchies[i];
+ }
}
return NULL;
bool cgfs_set_value(const char *controller, const char *cgroup, const char *file,
const char *value)
{
+ int cfd;
size_t len;
- char *fnam, *tmpc = find_mounted_controller(controller);
+ char *fnam, *tmpc = find_mounted_controller(controller, &cfd);
if (!tmpc)
return false;
- /* basedir / tmpc / cgroup / file \0 */
- len = strlen(basedir) + strlen(tmpc) + strlen(cgroup) + strlen(file) + 4;
+ /* BASEDIR / tmpc / cgroup / file \0 */
+ len = strlen(BASEDIR) + strlen(tmpc) + strlen(cgroup) + strlen(file) + 4;
fnam = alloca(len);
- snprintf(fnam, len, "%s/%s/%s/%s", basedir, tmpc, cgroup, file);
-
+ snprintf(fnam, len, "%s/%s/%s/%s", BASEDIR, tmpc, cgroup, file);
+
return write_string(fnam, value);
}
int cgfs_create(const char *controller, const char *cg, uid_t uid, gid_t gid)
{
+ int cfd;
size_t len;
- char *dirnam, *tmpc = find_mounted_controller(controller);
+ char *dirnam, *tmpc = find_mounted_controller(controller, &cfd);
if (!tmpc)
return -EINVAL;
- /* basedir / tmpc / cg \0 */
- len = strlen(basedir) + strlen(tmpc) + strlen(cg) + 3;
+ /* BASEDIR / tmpc / cg \0 */
+ len = strlen(BASEDIR) + strlen(tmpc) + strlen(cg) + 3;
dirnam = alloca(len);
- snprintf(dirnam, len, "%s/%s/%s", basedir,tmpc, cg);
+ snprintf(dirnam, len, "%s/%s/%s", BASEDIR,tmpc, cg);
if (mkdir(dirnam, 0755) < 0)
return -errno;
bool cgfs_remove(const char *controller, const char *cg)
{
+ int cfd;
size_t len;
- char *dirnam, *tmpc = find_mounted_controller(controller);
+ char *dirnam, *tmpc = find_mounted_controller(controller, &cfd);
if (!tmpc)
return false;
- /* basedir / tmpc / cg \0 */
- len = strlen(basedir) + strlen(tmpc) + strlen(cg) + 3;
+ /* BASEDIR / tmpc / cg \0 */
+ len = strlen(BASEDIR) + strlen(tmpc) + strlen(cg) + 3;
dirnam = alloca(len);
- snprintf(dirnam, len, "%s/%s/%s", basedir,tmpc, cg);
+ snprintf(dirnam, len, "%s/%s/%s", BASEDIR,tmpc, cg);
return recursive_rmdir(dirnam);
}
bool cgfs_chmod_file(const char *controller, const char *file, mode_t mode)
{
+ int cfd;
size_t len;
- char *pathname, *tmpc = find_mounted_controller(controller);
+ char *pathname, *tmpc = find_mounted_controller(controller, &cfd);
if (!tmpc)
return false;
- /* basedir / tmpc / file \0 */
- len = strlen(basedir) + strlen(tmpc) + strlen(file) + 3;
+ /* BASEDIR / tmpc / file \0 */
+ len = strlen(BASEDIR) + strlen(tmpc) + strlen(file) + 3;
pathname = alloca(len);
- snprintf(pathname, len, "%s/%s/%s", basedir, tmpc, file);
+ snprintf(pathname, len, "%s/%s/%s", BASEDIR, tmpc, file);
if (chmod(pathname, mode) < 0)
return false;
return true;
int cgfs_chown_file(const char *controller, const char *file, uid_t uid, gid_t gid)
{
+ int cfd;
size_t len;
- char *pathname, *tmpc = find_mounted_controller(controller);
+ char *pathname, *tmpc = find_mounted_controller(controller, &cfd);
if (!tmpc)
return -EINVAL;
- /* basedir / tmpc / file \0 */
- len = strlen(basedir) + strlen(tmpc) + strlen(file) + 3;
+ /* BASEDIR / tmpc / file \0 */
+ len = strlen(BASEDIR) + strlen(tmpc) + strlen(file) + 3;
pathname = alloca(len);
- snprintf(pathname, len, "%s/%s/%s", basedir, tmpc, file);
+ snprintf(pathname, len, "%s/%s/%s", BASEDIR, tmpc, file);
if (chown(pathname, uid, gid) < 0)
return -errno;
FILE *open_pids_file(const char *controller, const char *cgroup)
{
+ int cfd;
size_t len;
- char *pathname, *tmpc = find_mounted_controller(controller);
+ char *pathname, *tmpc = find_mounted_controller(controller, &cfd);
if (!tmpc)
return NULL;
- /* basedir / tmpc / cgroup / "cgroup.procs" \0 */
- len = strlen(basedir) + strlen(tmpc) + strlen(cgroup) + 4 + strlen("cgroup.procs");
+ /* BASEDIR / tmpc / cgroup / "cgroup.procs" \0 */
+ len = strlen(BASEDIR) + strlen(tmpc) + strlen(cgroup) + 4 + strlen("cgroup.procs");
pathname = alloca(len);
- snprintf(pathname, len, "%s/%s/%s/cgroup.procs", basedir, tmpc, cgroup);
+ snprintf(pathname, len, "%s/%s/%s/cgroup.procs", BASEDIR, tmpc, cgroup);
return fopen(pathname, "w");
}
void ***list, size_t typesize,
void* (*iterator)(const char*, const char*, const char*))
{
+ int cfd, fd, ret;
size_t len;
- char *dirname, *tmpc = find_mounted_controller(controller);
+ char *cg, *tmpc;
char pathname[MAXPATHLEN];
size_t sz = 0, asz = 0;
- struct dirent dirent, *direntp;
+ struct dirent *dirent;
DIR *dir;
- int ret;
+ tmpc = find_mounted_controller(controller, &cfd);
*list = NULL;
if (!tmpc)
return false;
- /* basedir / tmpc / cgroup \0 */
- len = strlen(basedir) + strlen(tmpc) + strlen(cgroup) + 3;
- dirname = alloca(len);
- snprintf(dirname, len, "%s/%s/%s", basedir, tmpc, cgroup);
+ /* Make sure we pass a relative path to openat(). */
+ len = strlen(cgroup) + 1 /* . */ + 1 /* \0 */;
+ cg = alloca(len);
+ ret = snprintf(cg, len, "%s%s", *cgroup == '/' ? "." : "", cgroup);
+ if (ret < 0 || (size_t)ret >= len) {
+ fprintf(stderr, "%s: pathname too long under %s\n", __func__, cgroup);
+ return false;
+ }
- dir = opendir(dirname);
+ fd = openat(cfd, cg, O_DIRECTORY);
+ if (fd < 0)
+ return false;
+
+ dir = fdopendir(fd);
if (!dir)
return false;
- while (!readdir_r(dir, &dirent, &direntp)) {
+ while ((dirent = readdir(dir))) {
struct stat mystat;
- int rc;
-
- if (!direntp)
- break;
- if (!strcmp(direntp->d_name, ".") ||
- !strcmp(direntp->d_name, ".."))
+ if (!strcmp(dirent->d_name, ".") ||
+ !strcmp(dirent->d_name, ".."))
continue;
- rc = snprintf(pathname, MAXPATHLEN, "%s/%s", dirname, direntp->d_name);
- if (rc < 0 || rc >= MAXPATHLEN) {
- fprintf(stderr, "%s: pathname too long under %s\n", __func__, dirname);
+ ret = snprintf(pathname, MAXPATHLEN, "%s/%s", cg, dirent->d_name);
+ if (ret < 0 || ret >= MAXPATHLEN) {
+ fprintf(stderr, "%s: pathname too long under %s\n", __func__, cg);
continue;
}
- ret = lstat(pathname, &mystat);
+ ret = fstatat(cfd, pathname, &mystat, AT_SYMLINK_NOFOLLOW);
if (ret) {
fprintf(stderr, "%s: failed to stat %s: %s\n", __func__, pathname, strerror(errno));
continue;
} while (!tmp);
*list = tmp;
}
- (*list)[sz] = (*iterator)(controller, cgroup, direntp->d_name);
+ (*list)[sz] = (*iterator)(controller, cg, dirent->d_name);
(*list)[sz+1] = NULL;
sz++;
}
if (closedir(dir) < 0) {
- fprintf(stderr, "%s: failed closedir for %s: %s\n", __func__, dirname, strerror(errno));
+ fprintf(stderr, "%s: failed closedir for %s: %s\n", __func__, cgroup, strerror(errno));
return false;
}
return true;
bool cgfs_get_value(const char *controller, const char *cgroup, const char *file, char **value)
{
+ int ret, fd, cfd;
size_t len;
- char *fnam, *tmpc = find_mounted_controller(controller);
+ char *fnam, *tmpc = find_mounted_controller(controller, &cfd);
if (!tmpc)
return false;
- /* basedir / tmpc / cgroup / file \0 */
- len = strlen(basedir) + strlen(tmpc) + strlen(cgroup) + strlen(file) + 4;
+ /* . + /cgroup + / + file + \0 */
+ len = strlen(cgroup) + strlen(file) + 3;
fnam = alloca(len);
- snprintf(fnam, len, "%s/%s/%s/%s", basedir, tmpc, cgroup, file);
+ ret = snprintf(fnam, len, "%s%s/%s", *cgroup == '/' ? "." : "", cgroup, file);
+ if (ret < 0 || (size_t)ret >= len)
+ return NULL;
+
+ fd = openat(cfd, fnam, O_RDONLY);
+ if (fd < 0)
+ return NULL;
- *value = slurp_file(fnam);
+ *value = slurp_file(fnam, fd);
return *value != NULL;
}
struct cgfs_files *cgfs_get_key(const char *controller, const char *cgroup, const char *file)
{
+ int ret, cfd;
size_t len;
- char *fnam, *tmpc = find_mounted_controller(controller);
+ char *fnam, *tmpc = find_mounted_controller(controller, &cfd);
struct stat sb;
struct cgfs_files *newkey;
- int ret;
if (!tmpc)
return false;
if (file && index(file, '/'))
return NULL;
- /* basedir / tmpc / cgroup / file \0 */
- len = strlen(basedir) + strlen(tmpc) + strlen(cgroup) + 3;
+ /* . + /cgroup + / + file + \0 */
+ len = strlen(cgroup) + 3;
if (file)
len += strlen(file) + 1;
fnam = alloca(len);
- snprintf(fnam, len, "%s/%s/%s%s%s", basedir, tmpc, cgroup,
- file ? "/" : "", file ? file : "");
+ snprintf(fnam, len, "%s%s%s%s", *cgroup == '/' ? "." : "", cgroup,
+ file ? "/" : "", file ? file : "");
- ret = stat(fnam, &sb);
+ ret = fstatat(cfd, fnam, &sb, 0);
if (ret < 0)
return NULL;
}
bool is_child_cgroup(const char *controller, const char *cgroup, const char *f)
-{ size_t len;
- char *fnam, *tmpc = find_mounted_controller(controller);
+{
+ int cfd;
+ size_t len;
+ char *fnam, *tmpc = find_mounted_controller(controller, &cfd);
int ret;
struct stat sb;
if (!tmpc)
return false;
- /* basedir / tmpc / cgroup / f \0 */
- len = strlen(basedir) + strlen(tmpc) + strlen(cgroup) + strlen(f) + 4;
+ /* . + /cgroup + / + f + \0 */
+ len = strlen(cgroup) + strlen(f) + 3;
fnam = alloca(len);
- snprintf(fnam, len, "%s/%s/%s/%s", basedir, tmpc, cgroup, f);
+ ret = snprintf(fnam, len, "%s%s/%s", *cgroup == '/' ? "." : "", cgroup, f);
+ if (ret < 0 || (size_t)ret >= len)
+ return false;
- ret = stat(fnam, &sb);
+ ret = fstatat(cfd, fnam, &sb, 0);
if (ret < 0 || !S_ISDIR(sb.st_mode))
return false;
return true;
static char *get_pid_cgroup(pid_t pid, const char *contrl)
{
+ int cfd;
char fnam[PROCLEN];
FILE *f;
char *answer = NULL;
char *line = NULL;
size_t len = 0;
int ret;
- const char *h = find_mounted_controller(contrl);
+ const char *h = find_mounted_controller(contrl, &cfd);
if (!h)
return NULL;
prune_init_slice(c2);
/*
- * callers pass in '/' for root cgroup, otherwise they pass
- * in a cgroup without leading '/'
+ * callers pass in '/' or './' (openat()) for root cgroup, otherwise
+ * they pass in a cgroup without leading '/'
+ *
+ * The original line here was:
+ * linecmp = *cg == '/' ? c2 : c2+1;
+ * TODO: I'm not sure why you'd want to increment when *cg != '/'?
+ * Serge, do you know?
*/
- linecmp = *cg == '/' ? c2 : c2+1;
+ if (*cg == '/' || !strncmp(cg, "./", 2))
+ linecmp = c2;
+ else
+ linecmp = c2 + 1;
if (strncmp(linecmp, cg, strlen(linecmp)) != 0) {
if (nextcg) {
*nextcg = get_next_cgroup_dir(linecmp, cg);
char *c2, *task_cg;
size_t target_len, task_len;
- if (strcmp(cg, "/") == 0)
+ if (strcmp(cg, "/") == 0 || strcmp(cg, "./") == 0)
return true;
c2 = get_pid_cgroup(pid, contrl);
return ret;
}
-static void do_release_file_info(struct file_info *f)
+static void do_release_file_info(struct fuse_file_info *fi)
{
+ struct file_info *f = (struct file_info *)fi->fh;
+
if (!f)
return;
+
+ fi->fh = 0;
+
free(f->controller);
+ f->controller = NULL;
free(f->cgroup);
+ f->cgroup = NULL;
free(f->file);
+ f->file = NULL;
free(f->buf);
+ f->buf = NULL;
free(f);
}
int cg_releasedir(const char *path, struct fuse_file_info *fi)
{
- struct file_info *d = (struct file_info *)fi->fh;
-
- do_release_file_info(d);
+ do_release_file_info(fi);
return 0;
}
if (!controller)
return -EIO;
cgroup = find_cgroup_in_path(path);
- if (!cgroup)
- return -EINVAL;
+ if (!cgroup) {
+ // access("/sys/fs/cgroup/systemd", mode) - rx allowed, w not
+ if ((mode & W_OK) == 0)
+ return 0;
+ return -EACCES;
+ }
get_cgdir_and_path(cgroup, &cgdir, &last);
if (!last) {
k = cgfs_get_key(controller, path1, path2);
if (!k) {
- ret = -EINVAL;
+ if ((mode & W_OK) == 0)
+ ret = 0;
+ else
+ ret = -EACCES;
goto out;
}
free_key(k);
int cg_release(const char *path, struct fuse_file_info *fi)
{
- struct file_info *f = (struct file_info *)fi->fh;
-
- do_release_file_info(f);
+ do_release_file_info(fi);
return 0;
}
return 0;
while (getline(&line, &linelen, f) != -1) {
- size_t l = snprintf(cache, cache_size, "%s", line);
+ ssize_t l = snprintf(cache, cache_size, "%s", line);
if (l < 0) {
perror("Error writing to cache");
rv = 0;
}
d->size = total_len;
- if (total_len > size ) total_len = size;
+ if (total_len > size)
+ total_len = size;
/* read from off 0 */
memcpy(buf, d->buf, total_len);
goto err;
while (getline(&line, &linelen, f) != -1) {
- size_t l;
+ ssize_t l;
char *printme, lbuf[100];
memset(lbuf, 0, 100);
snprintf(lbuf, 100, "SwapTotal: %8lu kB\n", memswlimit - memlimit);
printme = lbuf;
} else if (startswith(line, "SwapFree:") && memswlimit > 0 && memswusage > 0) {
- snprintf(lbuf, 100, "SwapFree: %8lu kB\n",
+ snprintf(lbuf, 100, "SwapFree: %8lu kB\n",
(memswlimit - memlimit) - (memswusage - memusage));
printme = lbuf;
} else if (startswith(line, "Slab:")) {
char *cpuset = NULL;
char *line = NULL;
size_t linelen = 0, total_len = 0, rv = 0;
- bool am_printing = false;
- int curcpu = -1;
+ bool am_printing = false, firstline = true, is_s390x = false;
+ int curcpu = -1, cpu;
char *cache = d->buf;
size_t cache_size = d->buflen;
FILE *f = NULL;
goto err;
while (getline(&line, &linelen, f) != -1) {
- size_t l;
+ ssize_t l;
+ if (firstline) {
+ firstline = false;
+ if (strstr(line, "IBM/S390") != NULL) {
+ is_s390x = true;
+ am_printing = true;
+ continue;
+ }
+ }
+ if (strncmp(line, "# processors:", 12) == 0)
+ continue;
if (is_processor_line(line)) {
am_printing = cpuline_in_cpuset(line, cpuset);
if (am_printing) {
total_len += l;
}
continue;
+ } else if (is_s390x && sscanf(line, "processor %d:", &cpu) == 1) {
+ char *p;
+ if (!cpu_in_cpuset(cpu, cpuset))
+ continue;
+ curcpu ++;
+ p = strchr(line, ':');
+ if (!p || !*p)
+ goto err;
+ p++;
+ l = snprintf(cache, cache_size, "processor %d:%s", curcpu, p);
+ if (l < 0) {
+ perror("Error writing to cache");
+ rv = 0;
+ goto err;
+ }
+ if (l >= cache_size) {
+ fprintf(stderr, "Internal error: truncated write to cache\n");
+ rv = 0;
+ goto err;
+ }
+ cache += l;
+ cache_size -= l;
+ total_len += l;
+ continue;
+
}
if (am_printing) {
l = snprintf(cache, cache_size, "%s", line);
}
}
+ if (is_s390x) {
+ char *origcache = d->buf;
+ ssize_t l;
+ do {
+ d->buf = malloc(d->buflen);
+ } while (!d->buf);
+ cache = d->buf;
+ cache_size = d->buflen;
+ total_len = 0;
+ l = snprintf(cache, cache_size, "vendor_id : IBM/S390\n");
+ if (l < 0 || l >= cache_size) {
+ free(origcache);
+ goto err;
+ }
+ cache_size -= l;
+ cache += l;
+ total_len += l;
+ l = snprintf(cache, cache_size, "# processors : %d\n", curcpu + 1);
+ if (l < 0 || l >= cache_size) {
+ free(origcache);
+ goto err;
+ }
+ cache_size -= l;
+ cache += l;
+ total_len += l;
+ l = snprintf(cache, cache_size, "%s", origcache);
+ free(origcache);
+ if (l < 0 || l >= cache_size)
+ goto err;
+ total_len += l;
+ }
+
d->cached = 1;
d->size = total_len;
if (total_len > size ) total_len = size;
}
while (getline(&line, &linelen, f) != -1) {
- size_t l;
+ ssize_t l;
int cpu;
char cpu_char[10]; /* That's a lot of cores */
char *c;
long int reaperage = getreaperage(fc->pid);
unsigned long int busytime = get_reaper_busy(fc->pid), idletime;
char *cache = d->buf;
- size_t total_len = 0;
+ ssize_t total_len = 0;
#if RELOADTEST
iwashere();
return read_file("/proc/diskstats", buf, size, d);
prune_init_slice(cg);
- if (!cgfs_get_value("blkio", cg, "blkio.io_serviced", &io_serviced_str))
+ if (!cgfs_get_value("blkio", cg, "blkio.io_serviced_recursive", &io_serviced_str))
goto err;
- if (!cgfs_get_value("blkio", cg, "blkio.io_merged", &io_merged_str))
+ if (!cgfs_get_value("blkio", cg, "blkio.io_merged_recursive", &io_merged_str))
goto err;
- if (!cgfs_get_value("blkio", cg, "blkio.io_service_bytes", &io_service_bytes_str))
+ if (!cgfs_get_value("blkio", cg, "blkio.io_service_bytes_recursive", &io_service_bytes_str))
goto err;
- if (!cgfs_get_value("blkio", cg, "blkio.io_wait_time", &io_wait_time_str))
+ if (!cgfs_get_value("blkio", cg, "blkio.io_wait_time_recursive", &io_wait_time_str))
goto err;
- if (!cgfs_get_value("blkio", cg, "blkio.io_service_time", &io_service_time_str))
+ if (!cgfs_get_value("blkio", cg, "blkio.io_service_time_recursive", &io_service_time_str))
goto err;
goto err;
while (getline(&line, &linelen, f) != -1) {
- size_t l;
- char *printme, lbuf[256];
+ ssize_t l;
+ char lbuf[256];
i = sscanf(line, "%u %u %71s", &major, &minor, dev_name);
- if(i == 3){
- get_blkio_io_value(io_serviced_str, major, minor, "Read", &read);
- get_blkio_io_value(io_serviced_str, major, minor, "Write", &write);
- get_blkio_io_value(io_merged_str, major, minor, "Read", &read_merged);
- get_blkio_io_value(io_merged_str, major, minor, "Write", &write_merged);
- get_blkio_io_value(io_service_bytes_str, major, minor, "Read", &read_sectors);
- read_sectors = read_sectors/512;
- get_blkio_io_value(io_service_bytes_str, major, minor, "Write", &write_sectors);
- write_sectors = write_sectors/512;
-
- get_blkio_io_value(io_service_time_str, major, minor, "Read", &rd_svctm);
- rd_svctm = rd_svctm/1000000;
- get_blkio_io_value(io_wait_time_str, major, minor, "Read", &rd_wait);
- rd_wait = rd_wait/1000000;
- read_ticks = rd_svctm + rd_wait;
-
- get_blkio_io_value(io_service_time_str, major, minor, "Write", &wr_svctm);
- wr_svctm = wr_svctm/1000000;
- get_blkio_io_value(io_wait_time_str, major, minor, "Write", &wr_wait);
- wr_wait = wr_wait/1000000;
- write_ticks = wr_svctm + wr_wait;
-
- get_blkio_io_value(io_service_time_str, major, minor, "Total", &tot_ticks);
- tot_ticks = tot_ticks/1000000;
- }else{
+ if (i != 3)
continue;
- }
+
+ get_blkio_io_value(io_serviced_str, major, minor, "Read", &read);
+ get_blkio_io_value(io_serviced_str, major, minor, "Write", &write);
+ get_blkio_io_value(io_merged_str, major, minor, "Read", &read_merged);
+ get_blkio_io_value(io_merged_str, major, minor, "Write", &write_merged);
+ get_blkio_io_value(io_service_bytes_str, major, minor, "Read", &read_sectors);
+ read_sectors = read_sectors/512;
+ get_blkio_io_value(io_service_bytes_str, major, minor, "Write", &write_sectors);
+ write_sectors = write_sectors/512;
+
+ get_blkio_io_value(io_service_time_str, major, minor, "Read", &rd_svctm);
+ rd_svctm = rd_svctm/1000000;
+ get_blkio_io_value(io_wait_time_str, major, minor, "Read", &rd_wait);
+ rd_wait = rd_wait/1000000;
+ read_ticks = rd_svctm + rd_wait;
+
+ get_blkio_io_value(io_service_time_str, major, minor, "Write", &wr_svctm);
+ wr_svctm = wr_svctm/1000000;
+ get_blkio_io_value(io_wait_time_str, major, minor, "Write", &wr_wait);
+ wr_wait = wr_wait/1000000;
+ write_ticks = wr_svctm + wr_wait;
+
+ get_blkio_io_value(io_service_time_str, major, minor, "Total", &tot_ticks);
+ tot_ticks = tot_ticks/1000000;
memset(lbuf, 0, 256);
- if (read || write || read_merged || write_merged || read_sectors || write_sectors || read_ticks || write_ticks) {
+ if (read || write || read_merged || write_merged || read_sectors || write_sectors || read_ticks || write_ticks)
snprintf(lbuf, 256, "%u %u %s %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu\n",
major, minor, dev_name, read, read_merged, read_sectors, read_ticks,
write, write_merged, write_sectors, write_ticks, ios_pgr, tot_ticks, rq_ticks);
- printme = lbuf;
- } else
+ else
continue;
- l = snprintf(cache, cache_size, "%s", printme);
+ l = snprintf(cache, cache_size, "%s", lbuf);
if (l < 0) {
perror("Error writing to fuse buf");
rv = 0;
char *memswlimit_str = NULL, *memlimit_str = NULL, *memusage_str = NULL, *memswusage_str = NULL,
*memswlimit_default_str = NULL, *memswusage_default_str = NULL;
unsigned long memswlimit = 0, memlimit = 0, memusage = 0, memswusage = 0, swap_total = 0, swap_free = 0;
- size_t total_len = 0, rv = 0;
+ ssize_t total_len = 0, rv = 0;
+ ssize_t l = 0;
char *cache = d->buf;
if (offset) {
}
if (swap_total > 0) {
- total_len += snprintf(d->buf + total_len, d->size - total_len,
- "none%*svirtual\t\t%lu\t%lu\t0\n", 36, " ",
- swap_total, swap_free);
+ l = snprintf(d->buf + total_len, d->size - total_len,
+ "none%*svirtual\t\t%lu\t%lu\t0\n", 36, " ",
+ swap_total, swap_free);
+ total_len += l;
}
- if (total_len < 0) {
+ if (total_len < 0 || l < 0) {
perror("Error writing to cache");
rv = 0;
goto err;
int proc_release(const char *path, struct fuse_file_info *fi)
{
- struct file_info *f = (struct file_info *)fi->fh;
-
- do_release_file_info(f);
+ do_release_file_info(fi);
return 0;
}
goto out;
*p2 = '\0';
+ /* With cgroupv2 /proc/self/cgroup can contain entries of the
+ * form: 0::/ This will cause lxcfs to fail the cgroup mounts
+ * because it parses out the empty string "" and later on passes
+ * it to mount(). Let's skip such entries.
+ */
+ if (!strcmp(p, ""))
+ continue;
+
if (!store_hierarchy(line, p))
goto out;
}