mit 6.s081 lab1

sleep(easy)

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

int main(int argc, char *argv[])
{
  // If the user forgets to pass an argument, sleep should print an error message.
  if (argc != 2)
  {
    fprintf(2, "usage: sleep <number>\n");
    exit(1);
  }
  // The command-line argument is passed as a string; you can convert it to an integer using atoi (see user/ulib.c).
  int sleepTime = atoi(argv[1]);
  // Use the system call sleep.
  sleep(sleepTime);
  exit(0);
}

pingpong(easy)

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

int main(int argc, char *argv[])
{
  // the byte to be sent
  char *ping = "p";
  // pipe file descriptors
  int fd[2];
  // create pipe
  pipe(fd);
  // fd[0] for read
  // fd[1] for write
  // create child process
  int cpid = fork();
  if (cpid == 0)
  {
    // child process
    // read a byte from the pipe
    char buf[1];
    if (read(fd[0], buf, 1) == 1)
    {
      // the child should print "<pid>: received ping"
      fprintf(1, "received a byte from the pipe: %s\n", buf);
      fprintf(1, "%d: received ping\n", getpid());
      close(fd[0]);
    }

    // write the byte on the pipe to the parent
    write(fd[1], buf, 1);
    close(fd[1]);
    // exit
    exit(0);
  }
  else if (cpid > 0)
  {
    // parent process
    // The parent should send a byte to the child
    write(fd[1], ping, 1);
    close(fd[1]);
    // wait for the child to finish
    wait(0);
    // read the byte from the child
    char buf[1];
    if (read(fd[0], buf, 1) == 1)
    {
      fprintf(1, "received a byte from the pipe: %s\n", buf);
      // print "<pid>: received pong"
      fprintf(1, "%d: received pong\n", getpid());
      close(fd[0]);
    }
    // exit
    exit(0);
  }
  exit(0);
}

primes(hard)

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

void func(int fd[2])
{
  int receivedNum;
  int currentPrime;

  close(fd[1]);
  if (read(fd[0], &currentPrime, 4) != 4)
  {
    fprintf(2, "read error\n");
    exit(1);
  }
  // the first number received must be a prime number
  fprintf(1, "prime %d\n", currentPrime);

  // judge whether the next is not exist
  if (read(fd[0], &receivedNum, 4) == 0)
  {
    close(fd[0]);
    exit(0);
  }

  // !!!!!!!!! SHOULD CREATE NEW PIPE !!!!!!!!!
  int newfd[2];
  pipe(newfd);

  // fork a child process
  if (fork() == 0)
  {
    func(newfd);
  }
  else
  {
    close(newfd[0]);
    // eliminate all the numbers that are multiples of the prime number
    // first should process the "receivedNum" which recevied just now
    if (receivedNum % currentPrime != 0)
    {
      if (write(newfd[1], &receivedNum, 4) != 4)
      {
        fprintf(2, "write error\n");
        exit(1);
      }
    }
    // read old pipe and write new pipe
    while (read(fd[0], &receivedNum, 4) == 4)
    {
      if (receivedNum % currentPrime != 0)
      {
        if (write(newfd[1], &receivedNum, 4) != 4)
        {
          fprintf(2, "write error\n");
          exit(1);
        }
      }
    }
    // no need for every process to close the pipe, just close the pipe in the end
    close(fd[0]);
    close(newfd[1]);
    wait(0);
  }
  exit(0);
}

int main(int argc, char *argv[])
{
  // create a pipe
  int fd[2];
  pipe(fd);

  // use fork create a child process
  int cpid = fork();

  if (cpid == 0)
  {
    // child process
    // call func
    func(fd);
  }
  else if (cpid > 0)
  {
    // parent process
    close(fd[0]);
    // pass [2...35] to the child process

    for (int i = 2; i <= 35; i++)
    {
      if (write(fd[1], &i, 4) != 4)
      {
        fprintf(2, "write error\n");
        exit(1);
      }
    }
    close(fd[1]);
    wait(0);
    exit(0);
  }

  exit(0);
}

find(just follow hints)

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

char *fmtname(char *path)
{
  static char buf[DIRSIZ + 1];
  char *p;

  // Find first character after last slash.
  for (p = path + strlen(path); p >= path && *p != '/'; p--)
    ;
  p++;

  // Return blank-padded name.
  if (strlen(p) >= DIRSIZ)
    return p;
  memmove(buf, p, strlen(p));
  memset(buf + strlen(p), ' ', DIRSIZ - strlen(p));
  return buf;
}

void findFunc(const char *path, const char *name)
{
  // modify from ls.c
  char buf[512], *p;
  int fd;
  struct dirent de;
  struct stat st;

  if ((fd = open(path, 0)) < 0)
  {
    fprintf(2, "find: cannot open %s\n", path);
    return;
  }

  if (fstat(fd, &st) < 0)
  {
    fprintf(2, "find: cannot stat %s\n", path);
    close(fd);
    return;
  }

  switch (st.type)
  {
  case T_FILE:
    // if the raw path is a file, it goes wrong
    fprintf(2, "Usage: find dir file\n");
    break;

  case T_DIR:
    if (strlen(path) + 1 + DIRSIZ + 1 > sizeof buf)
    {
      printf("find: path too long\n");
      break;
    }
    strcpy(buf, path);
    p = buf + strlen(buf);
    *p++ = '/';
    while (read(fd, &de, sizeof(de)) == sizeof(de))
    {
      // ignore the . and ..
      if (de.inum == 0 || strcmp(de.name, ".") == 0 || strcmp(de.name, "..") == 0)
        continue;
      memmove(p, de.name, DIRSIZ);
      p[DIRSIZ] = 0;
      if (stat(buf, &st) < 0)
      {
        printf("find: cannot stat %s\n", buf);
        continue;
      }
      // if the path is dir
      if (st.type == T_DIR)
      {
        // recursive call
        findFunc(buf, name);
      }
      else if (st.type == T_FILE)
      {
        // if the path is file
        if (strcmp(de.name, name) == 0)
        {
          printf("%s\n", buf);
        }
      }
    }
    break;
  }
  close(fd);
}

int main(int argc, char *argv[])
{
  if (argc != 3)
  {
    fprintf(2, "usage: find <path> <name>\n");
    exit(1);
  }
  const char *path = argv[1];
  const char *name = argv[2];

  findFunc(path, name);

  exit(0);
}

xargs(not easy)

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

int readLine(char **argvlist, int i)
{
  int maxBufSize = 1024;
  char buf[maxBufSize];
  int bufSize = 0;
  // read one line
  // each loop read one char
  while (read(0, buf + bufSize, 1))
  {
    if (buf[bufSize] == '\n')
    {
      buf[bufSize] = 0;
      break;
    }
    bufSize++;
    if (bufSize >= maxBufSize)
    {
      fprintf(2, "xargs: input too long\n");
      exit(1);
    }
  }

  if (bufSize == 0)
  {
    return -1;
  }

  // processing space, add to argvlist
  int idx = 0;
  while (idx < bufSize)
  {
    if (i > MAXARG)
    {
      fprintf(2, "xargs: too many arguments\n");
      exit(1);
    }

    // find the first non-space char
    while ((idx < bufSize) && (buf[idx] == ' '))
    {
      idx++;
    }

    int argsStart = idx;
    // find the first space char
    while ((idx < bufSize) && (buf[idx] != ' '))
    {
      idx++;
    }
    int argsEnd = idx;
    // add args to argvlist
    argvlist[i] = malloc(argsEnd - argsStart + 1);
    buf[idx++] = 0;
    strcpy(argvlist[i], buf + argsStart);
    i++;
  }
  return i;
}

int main(int argc, char *argv[])
{
  // wait the process before | finish
  sleep(3);
  // argvlist
  char *argvlist[MAXARG];
  if (argc < 2)
  {
    fprintf(2, "usage: xargs command\n");
    exit(1);
  }
  else
  {
    // add array argv to argvlist
    for (int i = 1; i < argc; i++)
    {
      // manipulate the argvlist
      argvlist[i - 1] = malloc(strlen(argv[i]) + 1);
      strcpy(argvlist[i - 1], argv[i]);
    }
  }
  // read the input from the standard input
  int end;
  while ((end = readLine(argvlist, argc - 1)) != -1)
  {
    argvlist[end] = 0;
    if (fork() == 0)
    {
      exec(argvlist[0], argvlist);
      exit(0);
    }
    else
    {
      wait(0);
    }
  }
  exit(0);
}