return RESOURCED_ERROR_NONE;
}
-int proc_get_mem_status(pid_t pid, unsigned int *vmswap, unsigned int *vmrss)
+int proc_get_mem_status(pid_t pid, unsigned int *vmswap_kb, unsigned int *vmrss_kb)
{
char filename[PROC_BUF_MAX];
_cleanup_fclose_ FILE *fp = NULL;
- unsigned int swap = 0, rss = 0;
+ unsigned int swap_kb = 0, rss_kb = 0;
snprintf(filename, PROC_BUF_MAX, "/proc/%d/status", pid);
fp = fopen(filename, "r");
if (!fp)
return RESOURCED_ERROR_FAIL;
- if (vmrss != NULL) {
+ if (vmrss_kb != NULL) {
while (fgets(filename, sizeof(filename), fp)) {
/* Skip the lines, until first match */
if (!strstart_with(filename, "VmRSS:"))
continue;
/* Read RSS value and end this loop. */
- if (sscanf(filename, "VmRSS: %d kB", &rss) == 1)
+ if (sscanf(filename, "VmRSS: %u kB", &rss_kb) == 1)
break;
return RESOURCED_ERROR_NO_DATA;
}
- *vmrss = rss;
+ *vmrss_kb = rss_kb;
}
- if (vmswap != NULL) {
+ if (vmswap_kb != NULL) {
/* Interate over rest of Vm* values */
while (fgets(filename, sizeof(filename), fp)) {
/* Read VmSwap and return with positive result */
- if (sscanf(filename, "VmSwap: %d kB", &swap) == 1)
+ if (sscanf(filename, "VmSwap: %d kB", &swap_kb) == 1)
break;
/* End of file before VmSwap read, return with error */
if (feof(fp))
return RESOURCED_ERROR_NO_DATA;
}
- *vmswap = swap;
+ *vmswap_kb = swap_kb;
}
return RESOURCED_ERROR_NONE;
return RESOURCED_ERROR_NONE;
}
-int proc_get_zram_usage(pid_t pid, unsigned int *usage)
+int proc_get_zram_usage(pid_t pid, unsigned int *usage_kb)
{
int ret;
struct meminfo mi;
- static unsigned int swap_total = 0;
- unsigned int proc_swap_usage, zram_usage;
+ static unsigned int swap_total_kb = 0;
+ unsigned int proc_swap_usage_kb;
+ unsigned long long zram_usage_bytes;
/* Read total swap size just once and cache it */
- if (!swap_total) {
+ if (!swap_total_kb) {
ret = proc_get_meminfo(&mi, MEMINFO_MASK_SWAP_TOTAL);
if (ret < 0) {
_E("Failed to get %s: %m",
meminfo_id_to_string(MEMINFO_ID_SWAP_TOTAL));
return RESOURCED_ERROR_FAIL;
}
- swap_total = mi.value[MEMINFO_ID_SWAP_TOTAL];
+ swap_total_kb = mi.value[MEMINFO_ID_SWAP_TOTAL];
}
/* Read usage of Swap (VmSwap) of interested process */
- ret = proc_get_mem_status(pid, &proc_swap_usage, NULL);
+ ret = proc_get_mem_status(pid, &proc_swap_usage_kb, NULL);
if (ret != RESOURCED_ERROR_NONE)
return ret;
/* Read current total memory usage of zram device */
- ret = fread_nth_uint(SWAP_ZRAM_SYSFILE"mm_stat", 2, &zram_usage);
+ ret = fread_nth_ulonglong(SWAP_ZRAM_SYSFILE"mm_stat", 2, &zram_usage_bytes);
if (ret == -ENOENT) {
- ret = fread_uint(SWAP_ZRAM_SYSFILE"mem_used_total", &zram_usage);
+ ret = fread_ulonglong(SWAP_ZRAM_SYSFILE"mem_used_total", &zram_usage_bytes);
}
if (ret < 0)
* Calculate aproximated value of zram usage for selected process
* by formula: proc_zram_usage = ( VmSwap x ZramMemoryUsage )/SwapTotal
*/
- *usage = (int)((float)proc_swap_usage * BYTE_TO_KBYTE(zram_usage) / swap_total);
+ *usage_kb = (int)((float)proc_swap_usage_kb * BYTE_TO_KBYTE(zram_usage_bytes) / swap_total_kb);
return RESOURCED_ERROR_NONE;
}
-int proc_get_approx_mem_usage(pid_t pid, unsigned int *usage)
+int proc_get_approx_mem_usage(pid_t pid, unsigned int *usage_kb)
{
int ret;
- unsigned long resident = 0, shared = 0;
+ unsigned long resident_pages = 0, shared_pages = 0;
char filename[PROC_BUF_MAX];
_cleanup_fclose_ FILE *fp = NULL;
* seq_printf(m, "%lu %lu %lu %lu 0 %lu 0\n",
* size, resident, shared, text, data);
*/
- ret = fscanf(fp, "%*s %lu %lu %*s %*s %*s %*s\n", &resident, &shared);
+ ret = fscanf(fp, "%*s %lu %lu %*s %*s %*s %*s\n", &resident_pages, &shared_pages);
if (ret < 0)
return RESOURCED_ERROR_FAIL;
/*
* The value resident - shared is mostly similar to Uss.
*/
- *usage = BYTE_TO_KBYTE((resident - shared) << PAGE_SHIFT);
+ *usage_kb = BYTE_TO_KBYTE((unsigned long long)(resident_pages - shared_pages) << PAGE_SHIFT);
return RESOURCED_ERROR_NONE;
}
* @desc get how much ram is used in each application
* @return negative value if error or pid doesn't exist
*/
-int proc_get_ram_usage(pid_t pid, unsigned int *usage)
+int proc_get_ram_usage(pid_t pid, unsigned int *usage_kb)
{
int ret;
- unsigned int vmswap = 0, total = 0;
+ unsigned int vmswap_kb = 0, total_kb = 0;
- ret = proc_get_approx_mem_usage(pid, &total);
+ ret = proc_get_approx_mem_usage(pid, &total_kb);
if (ret < 0) {
_E("Failed to get usage : %d", pid);
return ret;
}
if (swap_get_state() == SWAP_ON) {
- ret = proc_get_mem_status(pid, &vmswap, NULL);
+ ret = proc_get_mem_status(pid, &vmswap_kb, NULL);
if (ret != RESOURCED_ERROR_NONE)
goto out;
* If it is necessary to know real ram size about each application,
* it should consider compression ratio.
*/
- vmswap *= MEM_SWAP_RATIO;
- total += vmswap;
+ vmswap_kb *= MEM_SWAP_RATIO;
+ total_kb += vmswap_kb;
}
out:
- *usage = total;
+ *usage_kb = total_kb;
return RESOURCED_ERROR_NONE;
}
return 0;
}
-int proc_get_ram_total(unsigned int *total)
+int proc_get_ram_total(unsigned int *total_kb)
{
unsigned long total_spanned = 0;
- static unsigned int total_ram = 0;
+ static unsigned int total_ram_kb = 0;
int ret;
const struct parse_arg args[] = {
PARSE_TAG("spanned[[:blank:]]+([0-9]+)\n",
PARSE_TAG_EMPTY(),
};
- if (total_ram > 0) {
- *total = total_ram;
+ if (total_ram_kb > 0) {
+ *total_kb = total_ram_kb;
return RESOURCED_ERROR_NONE;
}
if (ret != RESOURCED_ERROR_NONE)
return RESOURCED_ERROR_NO_DATA;
- total_ram = (unsigned int)BYTE_TO_KBYTE(total_spanned << PAGE_SHIFT);
- *total = total_ram;
+ total_ram_kb = (unsigned int)BYTE_TO_KBYTE((unsigned long long)total_spanned << PAGE_SHIFT);
+ *total_kb = total_ram_kb;
return RESOURCED_ERROR_NONE;
}
int oom_score_adj, ret;
unsigned int rss, swap;
struct meminfo mi;
- unsigned int free = 0;
- unsigned int total_mem = 0, available = 0, used;
- unsigned int swap_total = 0, swap_free = 0, zram_used, swap_used;
+ unsigned int free_kb = 0;
+ unsigned int total_mem_kb = 0, available_kb = 0, used_kb;
+ unsigned int swap_total_kb = 0, swap_free_kb = 0, swap_used_kb;
+ unsigned long long zram_used_bytes;
dir = opendir("/proc");
if (dir == NULL) {
return;
}
- total_mem = mi.value[MEMINFO_ID_MEM_TOTAL];
- free = mi.value[MEMINFO_ID_MEM_FREE];
- available = mi.value[MEMINFO_ID_MEM_AVAILABLE];
- swap_total = mi.value[MEMINFO_ID_SWAP_TOTAL];
- swap_free = mi.value[MEMINFO_ID_SWAP_FREE];
+ total_mem_kb = mi.value[MEMINFO_ID_MEM_TOTAL];
+ free_kb = mi.value[MEMINFO_ID_MEM_FREE];
+ available_kb = mi.value[MEMINFO_ID_MEM_AVAILABLE];
+ swap_total_kb = mi.value[MEMINFO_ID_SWAP_TOTAL];
+ swap_free_kb = mi.value[MEMINFO_ID_SWAP_FREE];
- used = total_mem - available;
- swap_used = swap_total - swap_free;
+ used_kb = total_mem_kb - available_kb;
+ swap_used_kb = swap_total_kb - swap_free_kb;
- ret = fread_nth_uint(SWAP_ZRAM_SYSFILE"mm_stat", 2, &zram_used);
+ ret = fread_nth_ulonglong(SWAP_ZRAM_SYSFILE"mm_stat", 2, &zram_used_bytes);
if (ret == -ENOENT) {
- ret = fread_uint(SWAP_ZRAM_SYSFILE"mem_used_total", &zram_used);
+ ret = fread_ulonglong(SWAP_ZRAM_SYSFILE"mem_used_total", &zram_used_bytes);
}
if (ret != RESOURCED_ERROR_NONE)
- zram_used = 0;
+ zram_used_bytes = 0;
LOG_DUMP(fp, "====================================================================\n");
LOG_DUMP(fp, "Total RAM size: \t%15d MB( %6d kB)\n",
- KBYTE_TO_MBYTE(total_mem), total_mem);
+ KBYTE_TO_MBYTE(total_mem_kb), total_mem_kb);
LOG_DUMP(fp, "Used (Mem+Reclaimable): %15d MB( %6d kB)\n",
- KBYTE_TO_MBYTE(total_mem - free), total_mem - free);
+ KBYTE_TO_MBYTE(total_mem_kb - free_kb), total_mem_kb - free_kb);
LOG_DUMP(fp, "Used (Mem+Swap): \t%15d MB( %6d kB)\n",
- KBYTE_TO_MBYTE(used), used);
+ KBYTE_TO_MBYTE(used_kb), used_kb);
LOG_DUMP(fp, "Used (Mem): \t\t%15d MB( %6d kB)\n",
- KBYTE_TO_MBYTE(used), used);
+ KBYTE_TO_MBYTE(used_kb), used_kb);
LOG_DUMP(fp, "Used (Swap): \t\t%15d MB( %6d kB)\n",
- KBYTE_TO_MBYTE(swap_used), swap_used);
+ KBYTE_TO_MBYTE(swap_used_kb), swap_used_kb);
LOG_DUMP(fp, "Used (Zram block device): %13d MB( %6d kB)\n",
- BYTE_TO_MBYTE(zram_used), BYTE_TO_KBYTE(zram_used));
+ (int)BYTE_TO_MBYTE(zram_used_bytes), (int)BYTE_TO_KBYTE(zram_used_bytes));
LOG_DUMP(fp, "Mem Free:\t\t%15d MB( %6d kB)\n",
- KBYTE_TO_MBYTE(free), free);
+ KBYTE_TO_MBYTE(free_kb), free_kb);
LOG_DUMP(fp, "Available (Free+Reclaimable):%10d MB( %6d kB)\n",
- KBYTE_TO_MBYTE(available), available);
+ KBYTE_TO_MBYTE(available_kb), available_kb);
return;
}
projects / platform / core / system / resourced.git / blobdiff