// System call numbers
#define SYS_fork    1
..........
#define SYS_close  21
#define SYS_ps    22

// proc.c
void            exit(void);
......
void            yield(void);
int             ps ( void ); 

  // system calls
int fork(void);
.....
int uptime(void);
int ps ( void );

uint64
sys_ps ( void )
{
return cps ();
}  

.global ps
ps:
li a7, SYS_ps
ecall
retSYS_ps

extern int sys_chdir(void);
.....
extern int sys_ps(void);
.....
static int (*syscalls[])(void) = {
[SYS_fork]    sys_fork,
.....
[SYS_close]   sys_close,
[SYS_ps]     sys_ps,
};    

 //current process status
int
ps()
{
struct proc *p;

// Enable interrupts on this processor.
sti();

// Loop over process table looking for process with pid.
acquire(&wait_lock);
printf("name \t pid \t state \n");
for(p = proc; p < &proc[NPROC]; p++){
if ( p->state == SLEEPING )
  printf("%s \t %d  \t SLEEPING \n ", p->name, p->pid );
else if ( p->state == RUNNING )
  printf("%s \t %d  \t RUNNING \n", p->name, p->pid );
 else if ( p->state == RUNNABLE )
   printf("%s \t %d  \t RUNNABLE \n", p->name, p->pid );
   else if ( p->state == ZOMBIE )
   printf("%s \t %d  \t ZOMBIE \n", p->name, p->pid );
   else if ( p->state == USED )
   printf("%s \t %d  \t USED \n", p->name, p->pid );
}

release(&wait_lock);

return 22;
}

#include "kernel/types.h"
#include "kernel/stat.h"
#include "user/user.h"
#include "kernel/fs.h"
#include "kernel/fcntl.h"

int
main(int argc, char *argv[])
{
ps();

exit(0);
}

// System call numbers
#define SYS_fork    1
..........
#define SYS_ps     22
#define SYS_fork2  23

  // system calls
int fork(void);
.....
int uptime(void);
int fork2(int priority);

uint64
sys_fork2(void)
{
 int priority;

 argint(0, &priority); 

 return fork_with_priority(priority);
}

.global fork2
fork2:
li a7, SYS_fork2
ecall
ret

extern int sys_chdir(void);
.....
extern uint64 sys_fork2(void);
.....
static int (*syscalls[])(void) = {
[SYS_fork]    sys_fork,
.....
[SYS_close]   sys_close,
[SYS_fork2]    sys_fork2,
};    

 int fork_with_priority(int priority);

int fork_with_priority(int priority) {
 struct proc *np;
 struct proc *curproc = myproc();

 // Allocate a new process. This function acquires the process lock.
 if ((np = allocproc()) == 0)
     return -1;

 // Copy the parent process's address space to the child.
 if (uvmcopy(curproc->pagetable, np->pagetable, curproc->sz) < 0) {
     freeproc(np);
     return -1;
 }

 // Set up the new process's state based on the parent process.
 np->sz = curproc->sz;
 np->parent = curproc;
 *np->trapframe = *curproc->trapframe; // Copy the trapframe

 // Set the priority for the new process.
 np->priority = priority;

 // Copy file descriptors from parent to child.
 for (int i = 0; i < NOFILE; i++) {
     if (curproc->ofile[i])
         np->ofile[i] = filedup(curproc->ofile[i]);
 }

 // Copy the current working directory.
 np->cwd = idup(curproc->cwd);
 safestrcpy(np->name, curproc->name, sizeof(curproc->name));

 int pid = np->pid;

 // The process lock is already held here (from allocproc), so we just set the state.
 np->state = RUNNABLE;

 // Release the lock before returning.
 release(&np->lock);

 return pid;
}

#include "../kernel/types.h"
#include "user.h"
#include "printf.h"

int main() {
 int pid = fork2(10); // Create a child process with priority 10

 if (pid < 0) {
     printf("fork2 failed\n");
     exit(1);
 }

 if (pid == 0) {
     // This is the child process
     printf("Child process with priority 10\n");
     exit(0);
 } else {
     // Parent waits for the child to finish
     wait(0); // Wait for the child process to complete
     printf("Parent process created child with PID: %d\n", pid);
 }

 exit(0);
}

// System call numbers
#define SYS_fork    1
..........
#define SYS_fork2  23
#define SYS_get_ppid 24 

// proc.c
void            exit(void);
......
void            yield(void);
int             ps ( void ); 

  // system calls
int fork(void);
.....
int uptime(void);
int get_ppid(void);

uint64
sys_get_ppid(void)
{
 struct proc *p = myproc(); // Get the current process
 if (p->parent) {
     return p->parent->pid; // Return parent PID
 }
 return -1; // No parent (e.g., init process)
}

.global get_ppid
get_ppid:
 li a7, SYS_get_ppid
 ecall
 ret

extern int sys_chdir(void);
.....
extern uint64 sys_get_ppid(void);
.....
static int (*syscalls[])(void) = {
[SYS_fork]    sys_fork,
.....
[SYS_fork2]    sys_fork2,
[SYS_get_ppid] sys_get_ppid,
};    

#include "kernel/types.h"
#include "kernel/stat.h"
#include "user/user.h"

int main(void)
{
 int ppid = get_ppid();
 printf("Parent Process ID: %d\n", ppid);
 exit(0);
}

#define SYS_set_perm 23

int set_perm(int pid, int perm_flags);

int set_perm(int pid, int perm_flags);

uint64
sys_set_perm(void)
{
    int pid, perm_flags;

    // Retrieve arguments using argint
    argint(0, &pid);
    argint(1, &perm_flags);

    struct proc *p;

    // Loop through the process table to find the process with the given PID
    for (p = proc; p < &proc[NPROC]; p++) {
        if (p->pid == pid) {
            p->perm_flags = perm_flags;  // Set the permission flags
            return 0;  // Success
        }
    }

    return -1;  // Process not found
}

struct proc {
    ...
    int perm_flags;  // Permissions for the process
};

#include "kernel/types.h"
#include "kernel/stat.h"
#include "user/user.h"

int main(int argc, char *argv[])
{
    if (argc != 3) {
        printf("Usage: set_perm <pid> <perm_flags>\n");
        exit(1);
    }

    int pid = atoi(argv[1]);
    int perm_flags = atoi(argv[2]);

    if (set_perm(pid, perm_flags) < 0) {
        printf("Error: Unable to set permissions for process %d\n", pid);
    } else {
        printf("Permissions set for process %d\n", pid);
    }

    exit(0);
}