Codes

1. Return Process PID

Modify sys_hello to return the calling process's PID instead of returning a fixed 0

// kernel/sysproc.c
uint64
sys_hello(void)
{
  printf("Hello from kernel syscall!\n");
  return myproc()->pid; // Returns the current process ID
}

2. Repeating Message

Update the syscall hello(void) to hello(int n), where the kernel prints the message n times.

// kernel/sysproc.c
uint64
sys_hello(void)
{
  int n;
  argint(0, &n); // Fetch the first integer argument from user space
  for(int i = 0; i < n; i++){
    printf("Hello from kernel syscall!\n");
  }
  return 0;
}

3. Print Execution Core

Modify the kernel handler to print which CPU core (hart ID) is currently executing the call.

// kernel/sysproc.c
uint64
sys_hello(void)
{
  printf("Hello from kernel on hart %d!\n", cpuid()); // cpuid() returns the current CPU ID
  return 0;
}

4. User-Provided Name

Create a syscall hello_user(char *name) that fetches a string from user space to print "Hello [name]".

// kernel/sysproc.c
uint64
sys_hello_user(void)
{
  char name[64];
  argstr(0, name, sizeof(name)); // Fetches string from user space address
  printf("Hello %s\n", name);
  return 0;
}

5. Global Call Counter

Add a global counter in kernel/sysproc.c that tracks and returns the total times hello was called.

// kernel/sysproc.c
int hello_count = 0; // Global variable

uint64
sys_hello(void)
{
  hello_count++;
  printf("Total hello calls: %d\n", hello_count);
  return hello_count;
}

6. PID Filtering

Modify the kernel handler to print "Hello from Kernel!" only if the caller has PID 1 or 2.

// kernel/sysproc.c
uint64
sys_hello(void)
{
  struct proc *p = myproc();
  if(p->pid == 1 || p->pid == 2){
    printf("Hello from Kernel!\n");
  }
  return 0;
}

7. Rate Limiting

Change the syscall to return -1 (failure) if it is called more than 3 times by the same process.

// kernel/sysproc.c (requires adding 'int h_calls' to struct proc in kernel/proc.h)
uint64
sys_hello(void)
{
  struct proc *p = myproc();
  if(p->h_calls >= 3) return -1;
  p->h_calls++;
  printf("Hello from kernel syscall!\n");
  return 0;
}

8. Kernel Arithmetic

Implement a version where hello(int a, int b) prints the sum of the two integers in the kernel log.

// kernel/sysproc.c
uint64
sys_hello(void)
{
  int a, b;
  argint(0, &a);
  argint(1, &b);
  printf("Kernel sum: %d\n", a + b);
  return 0;
}

9. Syscall Number Logging

Modify kernel/syscall.c to log the syscall number specifically whenever SYS_hello is invoked.

// kernel/syscall.c, inside syscall() function
void
syscall(void)
{
  int num = myproc()->tf->a7; // Syscall number is in a7 register
  if(num == SYS_hello){
    printf("Invoking syscall number: %d\n", num);
  }
  // ... existing syscall table logic ...
}

10. Conditional Success Output

Update the user program hello.c to print "Syscall Successful" only if the return value is exactly 0.

// user/hello.c
int
main(void)
{
  if(hello() == 0){
    printf("Syscall Successful\n");
  }
  exit(0);
}