实现一些系统状态的 abi 比如 /proc/update

Co-authored-by: wenxuanjun <41050170+wenxuanjun@users.noreply.github.com>

Author: xiaoyi1212

src/arch/x86_64/include/nr.h

@@ -88,6 +88,8 @@
 #define SYSCALL_SYSLOG        103
 #define SYSCALL_GETGID        104
 #define SYSCALL_GETSID        124
+#define SYSCALL_CAPGET        125
+#define SYSCALL_CAPSET        126
 #define SYSCALL_SETUID        105
 #define SYSCALL_SETGID        106
 #define SYSCALL_GETEUID       107

src/arch/x86_64/syscall.c

@@ -200,6 +200,8 @@ syscall_t syscall_handlers[MAX_SYSCALLS] = {
     [SYSCALL_CHROOT]        = (syscall_t)syscall_chroot,
     [SYSCALL_SETITIMER]     = (syscall_t)syscall_setitimer,
     [SYSCALL_KILL]          = (syscall_t)syscall_kill,
+    [SYSCALL_CAPGET]        = (syscall_t)syscall_capget,
+    [SYSCALL_CAPSET]        = (syscall_t)syscall_capset,
     [SYSCALL_CHOWN]         = (syscall_t)syscall_chown,
     [SYSCALL_FCHOWN]        = (syscall_t)syscall_fchown,
     [SYSCALL_LCHOWN]        = (syscall_t)syscall_lchown,

src/fs/procfs/proc_dpatch.c

@@ -53,7 +53,8 @@ void load_procfs_root() {
     create_procfs_node("meminfo", proc_meminfo_read, proc_meminfo_stat);
     create_procfs_node("cpuinfo", proc_cpuinfo_read, proc_cpuinfo_stat);
     create_procfs_node("stat", proc_stat_read, proc_stat_stat);
-
+    create_procfs_node("uptime", proc_uptime_read, proc_uptime_stat);
+    create_procfs_node("loadavg", proc_loadavg_read, proc_loadavg_stat);
     create_procfs_handle("proc_cmdline",proc_pcmdline_read,proc_pcmdline_stat);
     create_procfs_handle("proc_maps",proc_pmaps_read,proc_pmaps_stat);
     create_procfs_handle("proc_stat",proc_pstat_read,proc_pstat_stat);

src/fs/procfs/proc_stat.c

@@ -2,27 +2,56 @@
 #include "intctl.h"
 #include "task/smp.h"
 #include "string_builder.h"
+#include "timer.h"
+#include "metadata.h"
 
-static bool gen_ctxt_processes(string_builder_t *builder){
-    size_t all_ctxt = 0;
-    size_t processes_all = 0;
-    for (size_t i = 0; i < get_cpu_count(); i++) {
+char *proc_gen_stat(size_t *context_len) {
+    string_builder_t *builder = create_string_builder(4096);
+    size_t cpu_count = get_cpu_count();
+
+    uint64_t total_idle = 0;
+    uint64_t total_system = 0;
+    size_t   processes_all = 0;
+    size_t   procs_running = 0;
+
+    for (size_t i = 0; i < cpu_count; i++) {
         cpu_local_t *info = get_cpu_local(i);
-        if(info == NULL) continue;
-        all_ctxt += info->jiffies;
+        if (info == NULL || !info->enable) continue;
+        total_system += info->jiffies - info->idle_jiffies;
+        total_idle += info->idle_jiffies;
         processes_all += info->task_count;
+        if (info->current_task && info->current_task->status == T_RUNNING)
+            procs_running++;
     }
-    bool status = string_builder_append(builder,"ctxt %llu\n",all_ctxt);
-    status &= string_builder_append(builder,"processes %llu\n",processes_all);
-    return !status;
-}
 
-char *proc_gen_stat(size_t *context_len) {
-    string_builder_t *builder = create_string_builder(4096);
+    string_builder_append(builder, "cpu  0 0 %llu %llu 0 0 0 0 0 0\n",
+                          total_system, total_idle);
+
+    for (size_t i = 0; i < cpu_count; i++) {
+        cpu_local_t *info = get_cpu_local(i);
+        if (info == NULL || !info->enable) continue;
+        uint64_t sys  = info->jiffies - info->idle_jiffies;
+        uint64_t idle = info->idle_jiffies;
+        string_builder_append(builder, "cpu%llu 0 0 %llu %llu 0 0 0 0 0 0\n",
+                              (uint64_t)i, sys, idle);
+    }
+
+    string_builder_append(builder, "intr %llu\n", get_all_irq_count());
+    string_builder_append(builder, "ctxt %llu\n", total_system + total_idle);
+
+    int64_t btime = mktime_universal();
+    if (btime > 0) {
+        uint64_t uptime_sec = nano_time() / 1000000000ULL;
+        string_builder_append(builder, "btime %llu\n", (uint64_t)(btime - uptime_sec));
+    } else {
+        string_builder_append(builder, "btime 0\n");
+    }
 
-    if(gen_ctxt_processes(builder)) goto end;
+    string_builder_append(builder, "processes %llu\n", (uint64_t)processes_all);
+    string_builder_append(builder, "procs_running %llu\n", (uint64_t)procs_running);
+    string_builder_append(builder, "procs_blocked 0\n");
+    string_builder_append(builder, "softirq 0 0 0 0 0 0 0 0 0 0 0\n");
 
-end:
     *context_len = builder->size;
     char *data = builder->data;
     free(builder);

src/include/fs/procfs.h

@@ -62,6 +62,10 @@ size_t proc_cpuinfo_stat(proc_handle_t *handle);
 size_t proc_cpuinfo_read(proc_handle_t *handle, void *addr, size_t offset, size_t size);
 size_t proc_stat_stat(proc_handle_t *handle);
 size_t proc_stat_read(proc_handle_t *handle, void *addr, size_t offset, size_t size);
+size_t proc_uptime_stat(proc_handle_t *handle);
+size_t proc_uptime_read(proc_handle_t *handle, void *addr, size_t offset, size_t size);
+size_t proc_loadavg_stat(proc_handle_t *handle);
+size_t proc_loadavg_read(proc_handle_t *handle, void *addr, size_t offset, size_t size);
 
 size_t procfs_node_read(size_t len, size_t offset, size_t size, char *addr, char *contect);
 

src/include/syscall.h

@@ -332,6 +332,22 @@ struct tms {
     long tms_cstime;
 };
 
+// Linux capability 版本号
+#define _LINUX_CAPABILITY_VERSION_1 0x19980330
+#define _LINUX_CAPABILITY_VERSION_2 0x20071026
+#define _LINUX_CAPABILITY_VERSION_3 0x20080522
+
+typedef struct {
+    uint32_t version;
+    int      pid;
+} cap_user_header_t;
+
+typedef struct {
+    uint32_t effective;
+    uint32_t permitted;
+    uint32_t inheritable;
+} cap_user_data_t;
+
 void arch_enable_syscall();
 
 // fs syscall
@@ -467,6 +483,8 @@ syscall_(prlimit64, uint64_t pid, int resource, const struct rlimit *new_rlim,
 syscall_(getresgid, int *rgid, int *egid, int *sgid);
 syscall_(getresuid, int *ruid, int *euid, int *suid);
 syscall_(kill, int pid, int sig);
+syscall_(capget, cap_user_header_t *header, cap_user_data_t *data);
+syscall_(capset, cap_user_header_t *header, cap_user_data_t *data);
 
 // mem syscall
 syscall_(mmap, uint64_t addr, size_t length, uint64_t prot, uint64_t flags, int fd,

src/include/task/smp.h

@@ -21,6 +21,7 @@ typedef struct cpu_local_info {
     arch_cpu_t        arch_data;    // 架构私有数据
     size_t            task_count;   // 任务数量
     uint64_t          jiffies;      // 时钟计数器计数 (不包含 yield)
+    uint64_t          idle_jiffies; // 空闲时钟计数
     bool              is_yield;     // 此次调度是否为 yield
 } __attribute__((packed)) cpu_local_t;
 

src/mod/elf_load.c

@@ -196,8 +196,7 @@ void launch_init_process() {
         "HOME=/root",
         "TERM=linux",
         "PATH=/bin:/sbin:/usr/bin",
-        // "PS1=\\[\\e[01;93m\\][\\[\\e[01;34m\\]\\u\\[\\e[01;32m\\]@\\h\\[\\e[00m\\] "
-        // "\\[\\e[01;33m\\]\\w\\[\\e[01;93m\\]]\\[\\e[01;34m\\]\\$\\[\\e[00m\\] ",
+        "PS1=\\u@\\h \\w# ",
         NULL,
     };
     size_t envc        = (sizeof(init_envp_src) / sizeof(init_envp_src[0])) - 1;

src/task/prsys.c

@@ -448,3 +448,47 @@ syscall_(getrusage, int who, struct rusage *usage) {
     if (usage) { memset(usage, 0, sizeof(struct rusage)); }
     return EOK;
 }
+
+syscall_(capget, cap_user_header_t *header, cap_user_data_t *data) {
+    if (header == NULL) return SYSCALL_FAULT_(EFAULT);
+    uint32_t ver = header->version;
+    if (ver != _LINUX_CAPABILITY_VERSION_1 &&
+        ver != _LINUX_CAPABILITY_VERSION_2 &&
+        ver != _LINUX_CAPABILITY_VERSION_3) {
+        header->version = _LINUX_CAPABILITY_VERSION_3;
+        return SYSCALL_FAULT_(EINVAL);
+    }
+    if (data == NULL) return EOK;
+    pcb_t process;
+    if (header->pid == 0) {
+        process = get_current_task()->process;
+    } else {
+        process = found_pcb(header->pid);
+        if (process == NULL) return SYSCALL_FAULT_(ESRCH);
+    }
+    uint32_t all_caps = (process->uid == 0) ? 0xFFFFFFFF : 0;
+    data[0].effective   = all_caps;
+    data[0].permitted   = all_caps;
+    data[0].inheritable = 0;
+    if (ver != _LINUX_CAPABILITY_VERSION_1) {
+        data[1].effective   = all_caps;
+        data[1].permitted   = all_caps;
+        data[1].inheritable = 0;
+    }
+    return EOK;
+}
+
+syscall_(capset, cap_user_header_t *header, cap_user_data_t *data) {
+    if (header == NULL) return SYSCALL_FAULT_(EFAULT);
+    uint32_t ver = header->version;
+    if (ver != _LINUX_CAPABILITY_VERSION_1 &&
+        ver != _LINUX_CAPABILITY_VERSION_2 &&
+        ver != _LINUX_CAPABILITY_VERSION_3) {
+        header->version = _LINUX_CAPABILITY_VERSION_3;
+        return SYSCALL_FAULT_(EINVAL);
+    }
+    if (data == NULL) return SYSCALL_FAULT_(EFAULT);
+    pcb_t process = get_current_task()->process;
+    if (process->uid != 0) return SYSCALL_FAULT_(EPERM);
+    return EOK;
+}

src/task/scheduler.c

@@ -164,7 +164,12 @@ void scheduler_handler(uint64_t irq_num, void *data, struct pt_regs *regs) {
     cpu_local_t *cpu = arch_current_cpu();
     if (unlikely(cpu == NULL)) return;
 
-    if (!cpu->is_yield) { cpu->jiffies++; }
+    if (!cpu->is_yield) {
+        cpu->jiffies++;
+        if (cpu->current_task == cpu->idle_task) {
+            cpu->idle_jiffies++;
+        }
+    }
     cpu->is_yield = false;
 
     tcb_t current_thread = get_current_task();