path: root/src/procfs.c

/*
 * Copyright (c) 2018 Samsung Electronics Co., Ltd.
 *
 * Licensed under the Flora License, Version 1.1 (the License);
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://floralicense.org/license/
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an AS IS BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <stdio.h>
#include <string.h>
#include <dirent.h>
#include <stdlib.h>
#include <unistd.h>
#include <ctype.h>

#include "procfs.h"
#include "log.h"
#include "err-check.h"

#define LOADAVG_FILEPATH "/proc/loadavg"
#define UPTIME_FILEPATH  "/proc/uptime"
#define POSSIBLE_CPUS_FILEPATH  "/sys/devices/system/cpu/possible"
#define MEMINFO_FILEPATH "/proc/meminfo"
#define STAT_FILEPATH "/proc/stat"
#define PIDSTAT_FILEPATH "/proc/%d/stat"
#define SMAPS_FILEPATH "/proc/%d/smaps"
#define PROC_DIR_PATH "/proc/"
#define PROC_PID_EXE_PATH "/proc/%d/exe"
#define PROC_PID_CMDLINE_PATH "/proc/%d/cmdline"

int procfs_read_system_load_average(struct procfs_load_average_info *info)
{
	float a1, a5, a15;

	ON_NULL_RETURN_VAL(info, -1);

	FILE *loadavg_fp = fopen(LOADAVG_FILEPATH, "r");
	if (!loadavg_fp) {
		ERR("failed to open " LOADAVG_FILEPATH);
		return -1;
	}

	if (fscanf(loadavg_fp, "%f %f %f", &a1, &a5, &a15) != 3) {
		ERR("failed to read " LOADAVG_FILEPATH);
		fclose(loadavg_fp);
		return -1;
	}

	info->one_min_avg = a1;
	info->five_min_avg = a5;
	info->fifteen_min_avg = a15;

	fclose(loadavg_fp);

	return 0;
}

int procfs_read_system_cpu_usage(struct procfs_system_cpu_usage_info *usage)
{
	ON_NULL_RETURN_VAL(usage, -1);

	char line[256];
	struct procfs_system_cpu_usage_info tmp;
	const char *prefix = "cpu ";

	FILE *stat_fp = fopen(STAT_FILEPATH, "r");
	if (!stat_fp) {
		ERR("failed to open " STAT_FILEPATH);
		return -1;
	}

	while (fgets(line, sizeof(line), stat_fp)) {
		if (!strncmp(line, prefix, strlen(prefix)) &&
		    sscanf(line + 4, "%llu %llu %llu %llu %llu %llu %llu",
				&tmp.user, &tmp.nice, &tmp.system, &tmp.idle,
				&tmp.iowait, &tmp.irq, &tmp.softirq) == 7) {
			*usage = tmp;
			fclose(stat_fp);
			return 0;
		}
	}

	fclose(stat_fp);

	return -1;
}

int procfs_read_system_percpu_usage(int max_cpus, struct procfs_system_cpu_usage_info usage[])
{
	return -1;
}

int procfs_read_system_memory_usage(struct procfs_system_memory_usage_info *usage)
{
	ON_NULL_RETURN_VAL(usage, -1);

	char line[128];
	unsigned long value;
	unsigned long mem_total = 0;
	unsigned long mem_free = 0;
	unsigned long cached = 0;
	unsigned long mem_available = 0;
	unsigned long swap_total = 0;
	unsigned long swap_free = 0;

	FILE *meminfo_fp = fopen(MEMINFO_FILEPATH, "r");
	if (!meminfo_fp) {
		ERR("failed to open " MEMINFO_FILEPATH);
		return -1;
	}

	while (fgets(line, sizeof(line), meminfo_fp)) {
		if (sscanf(line, "MemTotal: %lu", &mem_total) == 1)
			usage->total = mem_total;
		else if (sscanf(line, "MemFree: %lu", &mem_free) == 1)
			usage->free = mem_free;
		else if (sscanf(line, "Cached: %lu", &cached) == 1)
			usage->cache = cached;
		else if (sscanf(line, "MemAvailable: %lu", &value) == 1)
			mem_available = value;
		else if (sscanf(line, "SwapTotal: %lu", &value) == 1)
			swap_total = value;
		else if (sscanf(line, "SwapFree: %lu", &value) == 1)
			swap_free = value;
	}

	// Calculate used memory
	// MemAvailable is exposed since Linux 3.14, so handle also previous
	// kernel versions
	usage->used = 0;
	if (mem_available > 0) {
		if (mem_total > mem_available)
			usage->used = mem_total - mem_available;
	} else {
		if ((mem_total > mem_free) && ((mem_total - mem_free) > cached))
			usage->used = mem_total - mem_free - cached;
	}

	usage->swap = (swap_total > swap_free) ? (swap_total - swap_free) : 0;

	fclose(meminfo_fp);

	return 0;
}

int procfs_read_process_memory_usage(int pid, struct procfs_process_memory_usage_info *usage)
{
	ON_NULL_RETURN_VAL(usage, -1);
	ON_TRUE_RETURN_VAL(pid <= 0, -1);

	char smapspath[64], line[256];
	unsigned long value;

	snprintf(smapspath, sizeof(smapspath), SMAPS_FILEPATH, pid);

	FILE *smaps_fp = fopen(smapspath, "r");
	if (!smaps_fp) {
		 ERR("failed to open path: %s", smapspath);
		 return -1;
	}

	memset(usage, 0x0, sizeof(struct procfs_process_memory_usage_info));

	while (fgets(line, sizeof(line), smaps_fp)) {
		if (sscanf(line, "Size: %lu", &value) == 1)
			usage->vsz += value;
		else if (sscanf(line, "Rss: %lu", &value) == 1)
			usage->rss += value;
		else if (sscanf(line, "Pss: %lu", &value) == 1)
			usage->pss += value;
		else if (sscanf(line, "Shared_Clean: %lu", &value) == 1)
			usage->shared_clean += value;
		else if (sscanf(line, "Shared_Dirty: %lu", &value) == 1)
			usage->shared_dirty += value;
		else if (sscanf(line, "Private_Clean: %lu", &value) == 1)
			usage->private_clean += value;
		else if (sscanf(line, "Private_Dirty: %lu", &value) == 1)
			usage->private_dirty += value;
	}

	fclose(smaps_fp);

	return 0;
}

int procfs_read_process_cpu_usage(int pid, struct procfs_process_cpu_usage_info *usage)
{
	ON_NULL_RETURN_VAL(usage, -1);
	ON_TRUE_RETURN_VAL(pid <= 0, -1);

	char statpath[64];
	unsigned long long utime, stime;

	snprintf(statpath, sizeof(statpath), PIDSTAT_FILEPATH, pid);

	FILE *stat_fp = fopen(statpath, "r");
	if (!stat_fp) {
		ERR("failed to open %s", statpath);
		return -1;
	}

	if (fscanf(stat_fp, "%*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s") < 0) {
		ERR("reading pid stat file failed");
		fclose(stat_fp);
		return -1;
	}

	if (fscanf(stat_fp, "%llu %llu", &utime, &stime) != 2) {
		ERR("reading pid stat file failed");
		fclose(stat_fp);
		return -1;
	}

	usage->utime = utime;
	usage->stime = stime;

	fclose(stat_fp);
	return 0;
}

int procfs_read_uptime(unsigned long *uptime)
{
	ON_NULL_RETURN_VAL(uptime, -1);

	double duptime;

	FILE *uptime_fp = fopen(UPTIME_FILEPATH, "r");
	if (!uptime_fp) {
		ERR("failed to open " UPTIME_FILEPATH);
		return -1;
	}

	if (fscanf(uptime_fp, "%lf ", &duptime) != 1) {
		ERR("failed to read " UPTIME_FILEPATH);
		fclose(uptime_fp);
		return -1;
	}

	fclose(uptime_fp);
	*uptime = (unsigned long)duptime;

	return 0;
}

int procfs_read_cpu_count(int *cpu_count)
{
	ON_NULL_RETURN_VAL(cpu_count, -1);

	int cpus, dummy;

	FILE *possible_fp = fopen(POSSIBLE_CPUS_FILEPATH, "r");
	if (!possible_fp) {
		ERR("failed to open " POSSIBLE_CPUS_FILEPATH);
		return -1;
	}

	if (fscanf(possible_fp, "%d-%d", &dummy, &cpus) != 2) {
		ERR("failed to read " POSSIBLE_CPUS_FILEPATH);
		fclose(possible_fp);
		return -1;
	}

	*cpu_count = cpus + 1;

	fclose(possible_fp);

	return 0;
}

bool _procfs_dirname_parse_pid(const char *dirname, int *pid)
{
	int parsed_pid;

	if (!isdigit(*dirname))
		return false;

	if (sscanf(dirname, "%d", &parsed_pid) != 1) {
		return false;
	}
	*pid = parsed_pid;
	return true;
}

int procfs_iterate_pids(procfs_pid_iterator_cb iterator, void *user_data)
{
	ON_NULL_RETURN_VAL(iterator, -1);

	struct dirent *entry;
	int pid;

	DIR *dir = opendir(PROC_DIR_PATH);
	if (!dir) {
		ERR("opendir failed.");
		return -1;
	}

	// According to POSIX docs readdir is not-thread safe.
	// however in glib recent implementations readdir
	// is thread safe, so we can avoid using locks here.
	while ((entry = readdir(dir)) != NULL) {
		if (!_procfs_dirname_parse_pid(entry->d_name, &pid))
			continue;

		if (iterator(pid, user_data))
			continue;
		else
			break;;
	}

	closedir(dir);
	return 0;
}

int procfs_read_exe(int pid, char **exe)
{
	ON_TRUE_RETURN_VAL(pid < 0, -1);
	ON_NULL_RETURN_VAL(exe, -1);

	char buf[256];
	size_t size = 32;
	char *buffer = NULL;
	int ret;

	snprintf(buf, sizeof(buf), PROC_PID_EXE_PATH, pid);

	do
	{
		size *= 2;
		char *tmp = realloc(buffer, size);
		if (!tmp) {
			free(buffer);
			return -1;
		}
		buffer = tmp;
		ret = readlink(buf, buffer, size);
		if (ret == -1) {
			free(buffer);
			return -1;
		}
		buffer[ret] = '\0';
	} while (ret >= size);

	*exe = buffer;
	return 0;
}

int procfs_read_cmdline(int pid, char **cmdline)
{
	ON_TRUE_RETURN_VAL(pid < 0, -1);
	ON_NULL_RETURN_VAL(cmdline, -1);

	char buf[64];
	int read, read_total = 0;
	char *cmd = NULL;

	snprintf(buf, sizeof(buf), PROC_PID_CMDLINE_PATH, pid);

	FILE *cmdline_fp = fopen(buf, "r");
	if (!cmdline_fp) {
		ERR("failed to open %s", buf);
		return -1;
	}

	while ((read = fread(buf, 1, sizeof(buf), cmdline_fp)) != 0) {
		char *tmp = realloc(cmd, read_total + read + 1);
		if (!tmp) {
			fclose(cmdline_fp);
			free(cmd);
			return -1;
		}
		cmd = tmp;
		memcpy(cmd + read_total, buf, read);
		read_total += read;
	}

	if (read_total == 0) {
		fclose(cmdline_fp);
		*cmdline = NULL;
		return 0;
	}

	// clear string from end-of-string characters
	for (int i = 0; i < read_total; ++i) {
		if (cmd[i] == '\0')
			cmd[i] = ' ';
	}
	cmd[read_total] = '\0';

	fclose(cmdline_fp);
	*cmdline = cmd;
	return 0;
}