proc.h

Go to the documentation of this file.

#ifndef _SYS_PROC_H
#define _SYS_PROC_H
 
#include <core/system.h>
 
struct proc;
struct pgroup;
struct session;
 
#include <mm/vm.h>
#include <fs/vfs.h>
#include <ds/queue.h>
#include <sys/waitq.h>
#include <sys/thread.h>
#include <sys/signal.h>
#include <dev/dev.h>
 
struct tty;
 
/*
 * Processes, their process groups and sessions (sys/proc.c). See
 * docs/kernel/processes.md.
 */

struct session {
    pid_t sid;

    struct queue *pgps;

    struct proc *leader;

    struct tty *ctty;

    struct qnode *qnode;
};

struct fd {
    struct file *file;  /* NULL when it's free, FD_RESERVED while it's being set up */
    int flags;          /* FD_CLOEXEC */
};
 
/* A descriptor that's taken, but not set up yet. */
#define FD_RESERVED ((struct file *) -1)

struct pgroup {
    pid_t pgid;

    struct session *session;

    struct qnode *session_node;

    struct queue *procs;

    struct proc *leader;
 
};

struct proc {
    pid_t pid;

    struct pgroup *pgrp;
    struct qnode  *pgrp_node;

    char *name;

    struct fd *fds;

    struct proc *parent;

    struct vnode *cwd;

    mode_t mask;

    int stopped;
    int wait_event;

    struct waitq stop_queue;

    uint64_t utime, stime;
    uint64_t cutime, cstime;

    uint64_t alarm_at, alarm_interval;
    struct list_node alarm_link;

    uid_t uid;
    gid_t gid;

    uintptr_t heap_start;
    uintptr_t heap;

    uintptr_t entry;

    struct vm_space vm_space;

    struct vm_entry *heap_vm;
    struct vm_entry *stack_vm;

    struct queue threads;

    int tid_last;

    struct waitq thread_join;

    sigset_t sig_pending;

    sigset_t sigmask;

    struct waitq wait_queue;

    struct aquila_sigaction sigaction[SIG_MAX+1];

    int exit;

    int running;

    int zombie;
};
 
/* sys/fork.c: copies the process of `thread` */
int proc_fork(struct thread *thread, struct proc **ref);
 
/* sys/execve.c: loads a program into the process of `thread` */
int proc_execve(struct thread *thread, const char *fn, char * const argv[], char * const env[]);
 
/* Sets up init, the first process, to start its program, at boot. */
void init_execve(struct proc *proc, int argc, char * const argv[], int envc, char * const envp[]);
 
/* sys/proc.c: process IDs, making and ending processes, groups and
 * sessions, file descriptors */
pid_t proc_pid_alloc(void);
void  proc_pid_free(int pid);
struct proc *proc_pid_find(pid_t pid);
 
int proc_new(struct proc **ref);
int session_new(struct proc *proc);
int proc_setpgid(struct proc *proc, pid_t pgid);
void pgrp_release(struct pgroup *pgrp);
int  pgrp_orphaned(struct pgroup *pgrp, struct proc *gone);
 
void proc_kill(struct proc *proc);
int  proc_threads_end(struct proc *proc, struct thread *keep, int exiting);
void proc_threads_exec(struct proc *proc);
int  proc_reap(struct proc *proc);
int  proc_fd_get(struct proc *proc);
void proc_fd_release(struct proc *proc, int fd);
void proc_fd_install(struct proc *proc, int fd, struct file *file, int flags);
struct file *proc_fd_file(struct proc *proc, int fd);
int  proc_fd_close(struct proc *proc, int fd);
void proc_dump(struct proc *proc);
 
int  proc_init(struct proc *proc);
 
/* An exit status, as waitpid() reports it: `info` (the exit code) in the
 * second byte, and `code` (the signal that ended the process, or 0) in
 * the first. */
#define PROC_EXIT(info, code) ((((info) & 0xff) << 8) | ((code) & 0xff))
 
/* A process's uio: its current directory and credentials. */
#define PROC_UIO(proc) ((struct uio){.cwd = (proc)->cwd, .uid = (proc)->uid, .gid = (proc)->gid, .mask = (proc)->mask})
 
/* All the processes. */
extern struct queue *procs;
 
/* init (PID 1), the orphans' parent; only it and the kernel's process have
 * no parent. And the sessions. */
extern struct proc *initproc;
extern struct queue *sessions;
 
#endif /* ! _SYS_PROC_H */