CS360 Midterm -- October 15, 2002. Answers.

Question 1: Answer

Procedure 1

a:
    push #4

    mov #5 -> %r0
    st %r0 -> [fp]

    ld [fp] -> %r0
    add %r0, %g1 -> %r0
    ret

Procedure 2

.globl tmp
s:
    ld [fp+12] -> %r0
    ld [r0] -> %r0
    st %r0 -> tmp

    ld [fp+16] -> %r0
    ld [r0] -> %r0
    ld [fp+12] -> %r1
    st %r0 -> [r1]

    ld tmp -> %r0
    ld [fp+16] -> %r1
    st %r0 -> [r1]
    ret

Procedure 3

s:
    ld [fp+12] -> %r0
    mov #12 -> %r1
    add %r0, %r1 -> %r0
    ld [r0] -> %r0
    ld [r0] -> %r0
    ret

Procedure 4

1. Multiply j by 3 and put the result in %r0
2. Multiply k by 5 and put the result in %r1
3. Add %r0 and %r1 and put them in %r0, so that 3*j+5*k is in %r0
4. Multiply %r0 by 4 and add it to i, put the result in r0
5. Dereference [r0] into %r0, so that i[3*j+5*k] is there.
6. Subtract 3 from m and put the result in %r1
7. Multiply %r1 by 4, and add it to %r0 -- now (i[3*j+5*k] + (m-3)) is in %r0.
8. Dereference [r0] into %r0 and return.

s:
    st %r2 -> [sp]--

    ld [fp+16] -> %r0     / Step 1
    mov #3 -> %r1
    mul %r0, %r1 -> %r0
    ld [fp+20] -> %r1     / Step 2
    mov #5 -> %r2
    mul %r1, %r2 -> %r1
    add %r0, %r1 -> %r0   / Step 3
    mov #4 -> %r1         / Step 4
    mul %r0, %r1 -> %r0
    ld [fp+12] -> %r1
    add %r0, %r1 -> %r0
    ld [r0] -> %r0        / Step 5
    ld [fp+24] -> %r1     / Step 6
    mov #3 -> %r2
    sub %r1, %r2 -> %r1
    mov #4 -> %r2         / Step 7
    mul %r1, %r2 -> %r1
    add %r0, %r1 -> %r0
    ld [r0] -> %r0        / Step 8
    ld ++[sp] -> %r2
    ret

• exam-q1a.jas -- Procedure 1
• exam-q1b.jas -- Procedure 2
• exam-q1c.jas -- Procedure 3
• exam-q1d.jas -- Procedure 4

Question 2: Answer

main()
{
  struct stat buf;
  JRB t1, t2, tmp, tmp2;
  struct dirent *de;
  DIR *d;

  d = opendir(".");
  if (d == NULL) { perror("opendir .");  exit(1); }

  t1 = make_jrb();

  for (de = readdir(d); de != NULL; de = readdir(d)) {
    if (de->d_name[0] != '.') {
      if (stat(de->d_name, &buf) != 0) {
        perror(de->d_name);
        exit(1);
      }
      tmp = jrb_find_int(t1, buf.st_mtime);
      if (tmp == NULL) {
        tmp = jrb_insert_int(t1, buf.st_mtime, new_jval_v((void *) make_jrb()));
      }
      t2 = (JRB) tmp->val.v;
      jrb_insert_str(t2, strdup(de->d_name), JNULL);
    }
  }
  
  jrb_rtraverse(tmp, t1) {
    t2 = (JRB) tmp->val.v;
    jrb_traverse(tmp2, t2) {
      printf("%s\n", tmp2->key.s);
    }
  }
}

Question 3: Answer

You set the setuid bit of file f with:

UNIX> chmod 04755 f

Part 2: You first write a program that prints out the first line of the file in question. That file's name should be hard-coded into the executable, and that should be an absolute pathname. Then you set the setuid bit of the program using the chmod command above. Finally, you set the permissions of the file to something like 0600 or 0400. Now, when another user runs the program, he/she will assume your identity, and will be able to read the first line of the file.

This cannot be done without the setuid bit, because otherwise you would have to set the permissions of the file to be world readable (0644 or 0444), giving users access to all lines of the file, and not just the first line.

Question 4: Answer

Question 5: Answer

main:
     push #8
     st %g0 -> [fp]
     
mtop:
     ld stdin -> %r0
     st %r0 -> [sp]--
     st %g1 -> [sp]--
     mov #4 -> %r0
     st %r0 -> [sp]--
     mov #-4 -> %r0
     add %r0, %fp -> %r0
     st %r0 -> [sp]--
     jsr fread
     pop #16
     cmp %r0, %g0
     ble mbot
     ld [fp] -> %r0
     add %r0, %g0 -> %r0
     st %r0 -> [fp]
     b mtop
mbot:
     ret

Question 6: Answer

• The first two lines and the last line of the procedure are executed exactly once. That's three instructions.
• The code from mtop to the ``ble mbot'' statement is executed exactly x/4+1 times. This is 12 instructions.
• The code from the ``ld [fp] -> %r0'' statement and mbot is executed exactly x/4 times. This is 4 instructions.
• Fread is executed x/4+1 times. As stated in the assumptions, this call takes an average of 10 instructions, plus read() calls. The first call to fread() has to call read(). Thereafter, it is called every 4192/4 times that fread() is called. This means: 10(x/4+1) instructions, and 1 + (x div 4192) read() system calls.

Procedure 2 differs from Procedure 1 in two ways:

• The read() call takes only three arguments. Therefore there are only 10 instructions between mtop and the ``ble mbot'' statement.
• Read() is called instead of fread(). Since it is called x/4+1 times, it contrubutes 200(x/4+1) microseconds.

So the final tally is:

Extra Credit: Answer