sergiotarxz/nuttx-apps
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
b88057fffd
nuttx-apps/nshlib/nsh_proccmds.c
wangmingrong 7981278021 apps/nshlib: Add the pidof command and API nsh_getpid 
Add the API "nsh_getpid" in "nsh_fsutils. c" and the nsh command pidof. Temporarily support two parameters, - s, and process name

Signed-off-by: wangmingrong <wangmingrong@xiaomi.com>
2023-08-29 02:58:45 +08:00

962 lines
25 KiB
C
Raw Blame History

/****************************************************************************
* apps/nshlib/nsh_proccmds.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* 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.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
#include <fcntl.h>
#include <dirent.h>
#include <errno.h>
#include <signal.h>
#include <sys/sysinfo.h>
#include <sys/param.h>
#include <time.h>
#include "nsh.h"
#include "nsh_console.h"
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#ifndef CONFIG_NSH_PROC_MOUNTPOINT
# define CONFIG_NSH_PROC_MOUNTPOINT "/proc"
#endif
#ifndef CONFIG_NSH_DISABLE_UPTIME
# ifndef FSHIFT
# define FSHIFT SI_LOAD_SHIFT
# endif
# define FIXED_1 (1 << FSHIFT) /* 1.0 as fixed-point */
# define LOAD_INT(x) ((x) >> FSHIFT)
# define LOAD_FRAC(x) (LOAD_INT(((x) & (FIXED_1 - 1)) * 100))
#endif
#if CONFIG_MM_BACKTRACE >= 0 && !defined(CONFIG_NSH_DISABLE_PSHEAPUSAGE)
# define PS_SHOW_HEAPSIZE
#endif
#ifndef CONFIG_NSH_DISABLE_PSSTACKUSAGE
# define PS_SHOW_STACKSIZE
# ifdef CONFIG_STACK_COLORATION
# define PS_SHOW_STACKUSAGE
# endif
#endif
/****************************************************************************
* Private Types
****************************************************************************/
/* The returned value should be zero for success or TRUE or non zero for
* failure or FALSE.
*/
typedef int (*exec_t)(void);
/* This structure represents the parsed task characteristics */
struct nsh_taskstatus_s
{
FAR const char *td_type; /* Thread type */
FAR const char *td_groupid; /* Group ID */
#ifdef CONFIG_SMP
FAR const char *td_cpu; /* CPU */
#endif
FAR const char *td_state; /* Thread state */
FAR const char *td_event; /* Thread wait event */
FAR const char *td_flags; /* Thread flags */
FAR const char *td_priority; /* Thread priority */
FAR const char *td_policy; /* Thread scheduler */
FAR const char *td_sigmask; /* Signal mask */
};
/* Status strings */
#ifndef CONFIG_NSH_DISABLE_PS
#if 0 /* Not used */
static const char g_name[] = "Name:";
#endif
static const char g_type[] = "Type:";
static const char g_groupid[] = "Group:";
#ifdef CONFIG_SMP
static const char g_cpu[] = "CPU:";
#endif
static const char g_state[] = "State:";
static const char g_flags[] = "Flags:";
static const char g_priority[] = "Priority:";
static const char g_scheduler[] = "Scheduler:";
static const char g_sigmask[] = "SigMask:";
#if CONFIG_MM_BACKTRACE >= 0 && !defined(CONFIG_NSH_DISABLE_PSHEAPUSAGE)
static const char g_heapsize[] = "AllocSize:";
#endif /* CONFIG_DEBUG _MM && !CONFIG_NSH_DISABLE_PSHEAPUSAGE */
#if !defined(CONFIG_NSH_DISABLE_PSSTACKUSAGE)
static const char g_stacksize[] = "StackSize:";
#ifdef CONFIG_STACK_COLORATION
static const char g_stackused[] = "StackUsed:";
#endif
#endif /* !CONFIG_NSH_DISABLE_PSSTACKUSAGE */
#endif /* !CONFIG_NSH_DISABLE_PS */
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: nsh_parse_statusline
****************************************************************************/
#ifndef CONFIG_NSH_DISABLE_PS
static void nsh_parse_statusline(FAR char *line,
FAR struct nsh_taskstatus_s *status)
{
/* Parse the task status.
*
* Format:
*
* 111111111122222222223
* 123456789012345678901234567890
* Name: xxxx... Task/thread name
* (See CONFIG_TASK_NAME_SIZE)
* Type: xxxxxxx {Task, pthread, Kthread, Invalid}
* Type: xxxxxxx {Task, pthread, Kthread, Invalid}
* PPID: xxxxx Parent thread ID
* State: xxxxxxxx,xxxxxxxxx {Invalid, Waiting, Ready, Running,
* Inactive}, {Unlock, Semaphore, Signal,
* MQ empty, MQ full}
* Flags: xxx N,P,X
* Priority: nnn Decimal, 0-255
* Scheduler: xxxxxxxxxxxxxx {SCHED_FIFO, SCHED_RR, SCHED_SPORADIC,
* SCHED_OTHER}
* Sigmask: nnnnnnnn Hexadecimal, 32-bit
*/
#if 0 /* Not used */
/* Task name */
if (strncmp(line, g_name, strlen(g_name)) == 0)
{
/* Not used */
}
else
#endif
/* Task/thread type */
if (strncmp(line, g_type, strlen(g_type)) == 0)
{
/* Save the thread type */
status->td_type = nsh_trimspaces(&line[12]);
}
else if (strncmp(line, g_groupid, strlen(g_groupid)) == 0)
{
/* Save the Group ID */
status->td_groupid = nsh_trimspaces(&line[12]);
}
#ifdef CONFIG_SMP
else if (strncmp(line, g_cpu, strlen(g_cpu)) == 0)
{
/* Save the current CPU */
status->td_cpu = nsh_trimspaces(&line[12]);
}
#endif
else if (strncmp(line, g_state, strlen(g_state)) == 0)
{
FAR char *ptr;
/* Save the thread state */
status->td_state = nsh_trimspaces(&line[12]);
/* Check if an event follows the state */
ptr = strchr(status->td_state, ',');
if (ptr != NULL)
{
*ptr++ = '\0';
status->td_event = nsh_trimspaces(ptr);
}
}
else if (strncmp(line, g_flags, strlen(g_flags)) == 0)
{
status->td_flags = nsh_trimspaces(&line[12]);
}
else if (strncmp(line, g_priority, strlen(g_priority)) == 0)
{
FAR char *ptr = nsh_trimspaces(&line[12]);
status->td_priority = ptr;
/* If priority inheritance is enabled, use current pri, ignore base */
while (isdigit(*ptr))
{
++ptr;
}
*ptr = '\0';
}
else if (strncmp(line, g_scheduler, strlen(g_scheduler)) == 0)
{
/* Skip over the SCHED_ part of the policy. Result is max 8 bytes. */
status->td_policy = nsh_trimspaces(&line[12 + 6]);
}
else if (strncmp(line, g_sigmask, strlen(g_sigmask)) == 0)
{
status->td_sigmask = nsh_trimspaces(&line[12]);
}
}
#endif
/****************************************************************************
* Name: ps_callback
****************************************************************************/
#ifndef CONFIG_NSH_DISABLE_PS
static int ps_callback(FAR struct nsh_vtbl_s *vtbl, FAR const char *dirpath,
FAR struct dirent *entryp, FAR void *pvarg)
{
UNUSED(pvarg);
struct nsh_taskstatus_s status;
FAR char *filepath;
FAR char *line;
FAR char *nextline;
int ret;
int i;
#if CONFIG_MM_BACKTRACE >= 0 && !defined(CONFIG_NSH_DISABLE_PSHEAPUSAGE)
unsigned long heap_size = 0;
#endif
#if !defined(CONFIG_NSH_DISABLE_PSSTACKUSAGE)
unsigned long stack_size = 0;
#ifdef CONFIG_STACK_COLORATION
unsigned long stack_used = 0;
unsigned long stack_filled = 0;
#endif
#endif
/* Task/thread entries in the /proc directory will all be (1) directories
* with (2) all numeric names.
*/
if (!DIRENT_ISDIRECTORY(entryp->d_type))
{
/* Not a directory... skip this entry */
return OK;
}
/* Check each character in the name */
for (i = 0; i < NAME_MAX && entryp->d_name[i] != '\0'; i++)
{
if (!isdigit(entryp->d_name[i]))
{
/* Name contains something other than a numeric character */
return OK;
}
}
/* Set all pointers to the empty string. */
status.td_type = "";
status.td_groupid = "";
#ifdef CONFIG_SMP
status.td_cpu = "";
#endif
status.td_state = "";
status.td_event = "";
status.td_flags = "";
status.td_priority = "";
status.td_policy = "";
status.td_sigmask = "";
/* Read the task status */
filepath = NULL;
ret = asprintf(&filepath, "%s/%s/status", dirpath, entryp->d_name);
if (ret < 0 || filepath == NULL)
{
nsh_error(vtbl, g_fmtcmdfailed, "ps", "asprintf", NSH_ERRNO);
}
else
{
ret = nsh_readfile(vtbl, "ps", filepath, vtbl->iobuffer, IOBUFFERSIZE);
free(filepath);
if (ret >= 0)
{
/* Parse the task status. */
nextline = vtbl->iobuffer;
do
{
/* Find the beginning of the next line and NUL-terminate the
* current line.
*/
line = nextline;
for (nextline++;
*nextline != '\n' && *nextline != '\0';
nextline++);
if (*nextline == '\n')
{
*nextline++ = '\0';
}
else
{
nextline = NULL;
}
/* Parse the current line */
nsh_parse_statusline(line, &status);
}
while (nextline != NULL);
}
}
/* Finally, print the status information */
nsh_output(vtbl,
"%5s %5s "
#ifdef CONFIG_SMP
"%3s "
#endif
"%3s %-8s %-7s %3s %-8s %-9s %-8s ",
entryp->d_name, status.td_groupid,
#ifdef CONFIG_SMP
status.td_cpu,
#endif
status.td_priority, status.td_policy, status.td_type,
status.td_flags, status.td_state, status.td_event,
status.td_sigmask);
#if CONFIG_MM_BACKTRACE >= 0 && !defined(CONFIG_NSH_DISABLE_PSHEAPUSAGE)
/* Get the Heap AllocSize */
filepath = NULL;
ret = asprintf(&filepath, "%s/%s/heap", dirpath, entryp->d_name);
if (ret < 0 || filepath == NULL)
{
nsh_error(vtbl, g_fmtcmdfailed, "ps", "asprintf", NSH_ERRNO);
vtbl->iobuffer[0] = '\0';
}
else
{
ret = nsh_readfile(vtbl, "ps", filepath, vtbl->iobuffer,
IOBUFFERSIZE);
free(filepath);
if (ret >= 0)
{
nextline = vtbl->iobuffer;
do
{
/* Find the beginning of the next line and NUL-terminate the
* current line.
*/
line = nextline;
for (nextline++;
*nextline != '\n' && *nextline != '\0';
nextline++);
if (*nextline == '\n')
{
*nextline++ = '\0';
}
else
{
nextline = NULL;
}
/* Parse the current line
*
* Format:
*
* 111111111122222222223
* 123456789012345678901234567890
* AllocSize: xxxx
* AllocBlks: xxxx
*/
if (strncmp(line, g_heapsize, strlen(g_heapsize)) == 0)
{
heap_size = strtoul(&line[12], NULL, 0);
break;
}
}
while (nextline != NULL);
}
}
#endif
#if !defined(CONFIG_NSH_DISABLE_PSSTACKUSAGE)
/* Get the StackSize and StackUsed */
filepath = NULL;
ret = asprintf(&filepath, "%s/%s/stack", dirpath, entryp->d_name);
if (ret < 0 || filepath == NULL)
{
nsh_error(vtbl, g_fmtcmdfailed, "ps", "asprintf", NSH_ERRNO);
vtbl->iobuffer[0] = '\0';
}
else
{
ret = nsh_readfile(vtbl, "ps", filepath, vtbl->iobuffer,
IOBUFFERSIZE);
free(filepath);
if (ret >= 0)
{
nextline = vtbl->iobuffer;
do
{
/* Find the beginning of the next line and NUL-terminate the
* current line.
*/
line = nextline;
for (nextline++;
*nextline != '\n' && *nextline != '\0';
nextline++);
if (*nextline == '\n')
{
*nextline++ = '\0';
}
else
{
nextline = NULL;
}
/* Parse the current line
*
* Format:
*
* 111111111122222222223
* 123456789012345678901234567890
* StackBase: xxxxxxxxxx
* StackSize: xxxx
* StackUsed: xxxx
*/
if (strncmp(line, g_stacksize, strlen(g_stacksize)) == 0)
{
stack_size = strtoul(&line[12], NULL, 0);
}
#ifdef CONFIG_STACK_COLORATION
else if (strncmp(line, g_stackused, strlen(g_stackused)) == 0)
{
stack_used = strtoul(&line[12], NULL, 0);
}
#endif
}
while (nextline != NULL);
}
}
#ifdef CONFIG_STACK_COLORATION
if (stack_size > 0 && stack_used > 0)
{
/* Use fixed-point math with one decimal place */
stack_filled = 10 * 100 * stack_used / stack_size;
}
#endif
#endif
#ifdef NSH_HAVE_CPULOAD
/* Get the CPU load */
filepath = NULL;
ret = asprintf(&filepath, "%s/%s/loadavg", dirpath, entryp->d_name);
if (ret < 0 || filepath == NULL)
{
nsh_error(vtbl, g_fmtcmdfailed, "ps", "asprintf", NSH_ERRNO);
vtbl->iobuffer[0] = '\0';
}
else
{
ret = nsh_readfile(vtbl, "ps", filepath, vtbl->iobuffer, IOBUFFERSIZE);
free(filepath);
if (ret < 0)
{
vtbl->iobuffer[0] = '\0';
}
}
#endif
#if defined(PS_SHOW_HEAPSIZE) || defined (PS_SHOW_STACKSIZE) || \
defined (PS_SHOW_STACKUSAGE) || defined (NSH_HAVE_CPULOAD)
nsh_output(vtbl,
#ifdef PS_SHOW_HEAPSIZE
"%08lu "
#endif
#ifdef PS_SHOW_STACKSIZE
"%06lu "
#endif
#ifdef PS_SHOW_STACKUSAGE
"%06lu "
"%3lu.%lu%%%c "
#endif
#ifdef NSH_HAVE_CPULOAD
"%6s "
#endif
#if CONFIG_MM_BACKTRACE >= 0 && !defined(CONFIG_NSH_DISABLE_PSHEAPUSAGE)
, heap_size
#endif
#if !defined(CONFIG_NSH_DISABLE_PSSTACKUSAGE)
, stack_size
#endif
#ifdef PS_SHOW_STACKUSAGE
, stack_used,
stack_filled / 10,
stack_filled % 10,
(stack_filled >= 10 * 80 ? '!' : ' ')
#endif
#ifdef NSH_HAVE_CPULOAD
, nsh_trimspaces(vtbl->iobuffer)
#endif
);
#endif
/* Read the task/thread command line */
filepath = NULL;
ret = asprintf(&filepath, "%s/%s/cmdline", dirpath, entryp->d_name);
if (ret < 0 || filepath == NULL)
{
nsh_error(vtbl, g_fmtcmdfailed, "ps", "asprintf", NSH_ERRNO);
return ERROR;
}
ret = nsh_readfile(vtbl, "ps", filepath, vtbl->iobuffer, IOBUFFERSIZE);
free(filepath);
if (ret < 0)
{
return ERROR;
}
nsh_output(vtbl, "%s\n", nsh_trimspaces(vtbl->iobuffer));
return OK;
}
#endif
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: cmd_exec
****************************************************************************/
#ifndef CONFIG_NSH_DISABLE_EXEC
int cmd_exec(FAR struct nsh_vtbl_s *vtbl, int argc, FAR char **argv)
{
UNUSED(argc);
FAR char *endptr;
uintptr_t addr;
addr = (uintptr_t)strtol(argv[1], &endptr, 0);
if (!addr || endptr == argv[1] || *endptr != '\0')
{
nsh_error(vtbl, g_fmtarginvalid, argv[0]);
return ERROR;
}
nsh_output(vtbl, "Calling %p\n", (void *)addr);
return ((exec_t)addr)();
}
#endif
/****************************************************************************
* Name: cmd_ps
****************************************************************************/
#ifndef CONFIG_NSH_DISABLE_PS
int cmd_ps(FAR struct nsh_vtbl_s *vtbl, int argc, FAR char **argv)
{
UNUSED(argc);
UNUSED(argv);
nsh_output(vtbl, "%5s %5s "
#ifdef CONFIG_SMP
"%3s "
#endif
"%3s %-8s %-7s %3s %-8s %-9s "
"%-16s "
#if CONFIG_MM_BACKTRACE >= 0 && !defined(CONFIG_NSH_DISABLE_PSHEAPUSAGE)
"%8s "
#endif
#if !defined(CONFIG_NSH_DISABLE_PSSTACKUSAGE)
"%6s "
#ifdef CONFIG_STACK_COLORATION
"%6s "
"%7s "
#endif
#endif
#ifdef NSH_HAVE_CPULOAD
"%6s "
#endif
"%s\n",
"PID", "GROUP",
#ifdef CONFIG_SMP
"CPU",
#endif
"PRI", "POLICY", "TYPE", "NPX", "STATE", "EVENT",
"SIGMASK",
#if CONFIG_MM_BACKTRACE >= 0 && !defined(CONFIG_NSH_DISABLE_PSHEAPUSAGE)
"HEAP",
#endif
#if !defined(CONFIG_NSH_DISABLE_PSSTACKUSAGE)
"STACK",
#ifdef CONFIG_STACK_COLORATION
"USED",
"FILLED",
#endif
#endif
#ifdef NSH_HAVE_CPULOAD
"CPU",
#endif
"COMMAND"
);
return nsh_foreach_direntry(vtbl, "ps", CONFIG_NSH_PROC_MOUNTPOINT,
ps_callback, NULL);
}
#endif
/****************************************************************************
* Name: cmd_pidof
****************************************************************************/
#if defined(CONFIG_FS_PROCFS) && !defined(CONFIG_NSH_DISABLE_PIDOF)
int cmd_pidof(FAR struct nsh_vtbl_s *vtbl, int argc, FAR char **argv)
{
FAR const char *name = argv[argc - 1];
pid_t pids[8];
ssize_t ret;
int i;
ret = nsh_getpid(vtbl, name, pids, nitems(pids));
if (ret <= 0)
{
nsh_error(vtbl, g_fmtnosuch, argv[0], "task", name);
return ERROR;
}
for (i = 0; i < ret; i++)
{
nsh_output(vtbl, "%d ", pids[i]);
}
return OK;
}
#endif
/****************************************************************************
* Name: cmd_kill
****************************************************************************/
#ifndef CONFIG_NSH_DISABLE_KILL
int cmd_kill(FAR struct nsh_vtbl_s *vtbl, int argc, FAR char **argv)
{
FAR char *ptr;
FAR char *endptr;
long signal;
long pid;
/* kill will send SIGTERM to the task in case no signal is selected by
* -<signal> option
*/
if (argc == 3) /* kill -<signal> <pid> */
{
/* Check incoming parameters.
* The first parameter should be "-<signal>"
*/
ptr = argv[1];
if (*ptr != '-' || ptr[1] < '0' || ptr[1] > '9')
{
goto invalid_arg;
}
/* Extract the signal number */
signal = strtol(&ptr[1], &endptr, 0);
/* The second parameter should be <pid> */
ptr = argv[2];
if (*ptr < '0' || *ptr > '9')
{
goto invalid_arg;
}
}
else if (argc == 2) /* kill <pid> */
{
/* uses default signal number as SIGTERM */
signal = (long) SIGTERM; /* SIGTERM is always defined in signal.h */
/* The first parameter should be <pid> */
ptr = argv[1];
if (*ptr < '0' || *ptr > '9')
{
goto invalid_arg;
}
}
else
{
/* invalid number of arguments */
goto invalid_arg;
}
/* Extract the pid */
pid = strtol(ptr, &endptr, 0);
/* Send the signal. Kill return values:
*
* EINVAL An invalid signal was specified.
* EPERM The process does not have permission to send the signal to any
* of the target processes.
* ESRCH The pid or process group does not exist.
* ENOSYS Do not support sending signals to process groups.
*/
if (kill((pid_t)pid, (int)signal) == 0)
{
return OK;
}
switch (errno)
{
case EINVAL:
goto invalid_arg;
case ESRCH:
nsh_error(vtbl, g_fmtnosuch, argv[0], "task", argv[2]);
return ERROR;
case EPERM:
case ENOSYS:
default:
nsh_error(vtbl, g_fmtcmdfailed, argv[0], "kill", NSH_ERRNO);
return ERROR;
}
invalid_arg:
nsh_error(vtbl, g_fmtarginvalid, argv[0]);
return ERROR;
}
#endif
/****************************************************************************
* Name: cmd_sleep
****************************************************************************/
#ifndef CONFIG_NSH_DISABLE_SLEEP
int cmd_sleep(FAR struct nsh_vtbl_s *vtbl, int argc, FAR char **argv)
{
UNUSED(argc);
FAR char *endptr;
long secs;
secs = strtol(argv[1], &endptr, 0);
if (!secs || endptr == argv[1] || *endptr != '\0')
{
nsh_error(vtbl, g_fmtarginvalid, argv[0]);
return ERROR;
}
sleep(secs);
return OK;
}
#endif
/****************************************************************************
* Name: cmd_usleep
****************************************************************************/
#ifndef CONFIG_NSH_DISABLE_USLEEP
int cmd_usleep(FAR struct nsh_vtbl_s *vtbl, int argc, FAR char **argv)
{
UNUSED(argc);
FAR char *endptr;
long usecs;
usecs = strtol(argv[1], &endptr, 0);
if (!usecs || endptr == argv[1] || *endptr != '\0')
{
nsh_error(vtbl, g_fmtarginvalid, argv[0]);
return ERROR;
}
usleep(usecs);
return OK;
}
#endif
/****************************************************************************
* Name: cmd_uptime
****************************************************************************/
#ifndef CONFIG_NSH_DISABLE_UPTIME
int cmd_uptime(FAR struct nsh_vtbl_s *vtbl, int argc, FAR char **argv)
{
uint32_t updays;
uint32_t uphours;
uint32_t upminutes;
time_t current_time_seconds;
FAR struct tm *current_time;
struct sysinfo sys_info;
time_t uptime = 0;
bool pretty_format_opt = false;
bool system_load_opt = false;
if (argc < 2)
{
system_load_opt = true;
current_time_seconds = time(NULL);
current_time = localtime(&current_time_seconds);
nsh_output(vtbl, "%02u:%02u:%02u ", current_time->tm_hour,
current_time->tm_min, current_time->tm_sec);
}
else if (strcmp(argv[1], "-p") == 0)
{
pretty_format_opt = true;
}
else if (strcmp(argv[1], "-s") == 0)
{
sysinfo(&sys_info);
time(&current_time_seconds);
current_time_seconds -= sys_info.uptime;
current_time = localtime(&current_time_seconds);
nsh_output(vtbl, "%04u-%02u-%02u %02u:%02u:%02u\n",
current_time->tm_year + 1900, current_time->tm_mon + 1,
current_time->tm_mday, current_time->tm_hour,
current_time->tm_min, current_time->tm_sec);
return OK;
}
else
{
if (strcmp(argv[1], "-h") != 0)
{
nsh_output(vtbl, "uptime: invalid option -- %s\n", argv[1]);
}
nsh_output(vtbl, "Usage:\n");
nsh_output(vtbl, "uptime [options]\n");
nsh_output(vtbl, "Options:\n");
nsh_output(vtbl, "-p, show uptime in pretty format\n");
nsh_output(vtbl, "-h, display this help and exit\n");
nsh_output(vtbl, "-s, system up since\n");
return ERROR;
}
sysinfo(&sys_info);
uptime = sys_info.uptime;
updays = uptime / 86400;
uptime -= updays * 86400;
uphours = uptime / 3600;
uptime -= uphours * 3600;
upminutes = uptime / 60;
nsh_output(vtbl, "up ");
if (updays)
{
nsh_output(vtbl, "%" PRIu32 " day%s, ", updays,
(updays > 1) ? "s" : "");
}
if (pretty_format_opt)
{
if (uphours)
{
nsh_output(vtbl, "%" PRIu32 " hour%s, ", uphours,
(uphours > 1) ? "s" : "");
}
nsh_output(vtbl, "%" PRIu32 " minute%s", upminutes,
(upminutes > 1) ? "s" : "");
}
else
{
nsh_output(vtbl, "%2" PRIu32 ":" "%02" PRIu32, uphours, upminutes);
}
if (system_load_opt)
{
nsh_output(vtbl, ", load average: %lu.%02lu, %lu.%02lu, %lu.%02lu",
LOAD_INT(sys_info.loads[0]), LOAD_FRAC(sys_info.loads[0]),
LOAD_INT(sys_info.loads[1]), LOAD_FRAC(sys_info.loads[1]),
LOAD_INT(sys_info.loads[2]), LOAD_FRAC(sys_info.loads[2]));
}
nsh_output(vtbl, "\n");
return OK;
}
#endif
Reference in New Issue View Git Blame Copy Permalink