Question 1

• pthread_mutex_lock(pthread_mutex_t *l): This "locks" the mutex. If no other thread has locked the mutex, then pthread_mutex_lock() returns, and the calling thread "locks" the mutex until it calls pthread_mutex_unlock() on the mutex. If another thread has locked the mutex, then pthread_mutex_lock() will block until the mutex has been unlocked, and the calling thread successfully has the lock.

• pthread_mutex_unlock(pthread_mutex_t *l): See above.

• pthread_cond_wait(pthread_cond_t *c, pthread_mutex_t *l): This unlocks the mutex and forces the calling thread to block until another thread calls pthread_cond_signal() to wake it up. It will not return from this call until pthread_cond_signal() has been called and the thread re-locks the mutex.

• pthread_cond_signal(pthread_cond_t *c): If there are no threads that are blocked because they called pthread_cond_wait() on c, then this does nothing. Otherwise, it chooses one thread that is blocked and unblocks it. That thread, of course, needs to relock its mutex before its pthread_cond_wait() call returns.

Grading:

Question 2

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

void sigpipe_handler(int i)
{
  printf("Got it\n");
  exit(0);
}

main()
{
  int fd[2];

  signal(SIGPIPE, sigpipe_handler);
  pipe(fd);
  close(fd[0]);
  write(fd[1], "Hi\n", 3);
}

Part B: You need a program that is going to write to a pipe whose read end is closed. The simple example is:

UNIX> cat f1.txt | head

Part C: There are five potential outputs:

1. Suppose file descriptor 10 is not open, or it is opened for reading. Then, the write() call returns -1, because the write fails.
2. Suppose file descriptor 10 has been opened for writing to a file. Then the write succeeds and returns 2. The output is "2".
3. Suppose file descriptor 10 has been opened for writing to a socket. Sockets are finicky and can potentially only write one byte. In that case, the output will be 1.
4. Suppose file descriptor 10 has been dup'd from standard output. Then it will write the "J\n" before "2".
5. Finally, suppose file descriptor 10 is the write end of a pipe whose read ends have been closed. Then the write can generate SIGPIPE. There will be no output (or the shell may tell you that there is a broken pipe).

Grading

Question 3

UNIX> a.out 2 2 2
T: 0
S: 0
A: 2
M: 2
UNIX> 

UNIX> a.out 2 1 2
T: 0
S: 1
T: 2
M: 2
UNIX> 

UNIX> a.out 1 0 0
T: 1
Segmentation fault
UNIX> 

UNIX> a.out 0 2 0
T: 0
S: 0
A: 0
S: 1
S: 2
M: 2
UNIX> 

UNIX> a.out 2 0 0
T: 0
S: 0
A: 0
T: 1
T: 1
..... repeating infinitely

Grading

Question 4

The child will make the appropriate dup2() calls to have one pipe go to standard input and the other go to standard output. It will then close all the pipe file descriptors and call execl() or execv() on chpmnk.

The parent will close parts of the pipes that it won't use, and set up standard IO streams (using fdopen() for the write end of the first pipe and the read end of the second pipe. Then it reads lines from standard input, calls preprocess_line() and fputs() or fprintf() to send the lines to chmpnk. It calls fgets() to read output from chmpnk, then calls postprocess_line() and prints out the resulting line. That's it.

The whole code is in q4a.c. In this code, I make up a preprocess_line() that converts all lowercase characters to uppercase, and postprocess_line() that prepends "Output: "to the strings, if there is room. You didn't need to do anything with preprocess_line() or postprocess_line() -- I just wrote them so that the program would compile completely.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>

void preprocess_line(char *s)
{
  int i;

  for (i = 0; s[i] != '\0'; i++) {
    if (s[i] <= 'z' && s[i] >= 'a') s[i] += ('A'-'a');
  }
}

void postprocess_line(char *s)
{
  int i;
  char buf[500];

  if (strlen(s) > 490) return;
  sprintf(buf, "Output: %s", s);
  strcpy(s, buf);
  return;
}

main()
{
  char line[500];
  int p1[2], p2[2];
  FILE *fin, *fout;

  pipe(p1);
  pipe(p2);

  if (fork() == 0) {
    dup2(p1[0], 0);
    dup2(p2[1], 1);
    close(p1[0]);
    close(p1[1]);
    close(p2[0]);
    close(p2[1]);
    execl("./chpmnk", "chpmnk", NULL);
    perror("execl chpmnk");
    exit(1);
  } 

  close(p1[0]);
  close(p2[1]);
  fin = fdopen(p2[0], "r");
  fout = fdopen(p1[1], "w");
  
  while (fgets(line, 500, stdin) != NULL) {

    preprocess_line(line);
    fputs(line, fout);
    fflush(fout);

    if (fgets(line, 500, fin) == NULL) {
      fprintf(stderr, "Alvin, Simon and Theodore messed up again.\n");
      exit(1);
    }
 
    postprocess_line(line);
    fputs(line, stdout);
  }
  exit(0);
}

(This is just for people studying from this question for future exams): You can test this out as is -- the child process will die because there is no chpmnk, but the parent doesn't die until you put a line of input into it. How does it die? On SIGPIPE, since there is no read end of p1:

UNIX> q4a
execl chpmnk: No such file or directory
Example input
Broken pipe
UNIX> 

UNIX> cp /bin/cat chpmnk
UNIX> q4a
Example input
Output: EXAMPLE INPUT
You probably hated answering this question, but it's a fun one!
Output: YOU PROBABLY HATED ANSWERING THIS QUESTION, BUT IT'S A FUN ONE!
UNIX> 

Grading

• Not enough closes.
• Wrong dups.
• Bad exec call.
• No fflush.
• Testing the return value of fgets()