CS 111

What can go wrong?

File descriptors:

• close(-1) [some time passes] close(39) == 1 errno == EBADF

• fd = open(...) read(fd)... fd leak

• fd = open("/dev/usb/dr1"...) read(fd, ...) *unplug* read(fd, ...) // return -1

Race Conditons:

• (cat a & cat b) > outfile

    a\n    (bad: output discarded)
    b\n    (bad: output discarded)
    a\nb\n (ok)
    b\na\n (ok)
    ab\n\n (bad: interleaved)
                    

• (cat > a & cat > b) < infile

    |a| + |b| = |infile|
                    

• (cat a & cat b) | (cat > c & cat > d)

Task: rotate a log file

    $ mv log old log
    $ >log
                    

i.e.
    close(fd);
    fd = open("log", O_WRONLY ...);
                    

    write(fd, "good stuff\n", 11);
    write(fd, "more good stuff\n", 16);
                    

    checklog();
    write(fd, "good stuff\n", 11);
    checklog();
    write(fd, "more good stuff\n", 16);
                    

                        
    int checklog(void) {
        if(stat("log", &st) < 0 || st.st_size == 0) {
            close(fd);
            fd = open("log",...);
        }
    }
                        
                    

Signals

• terminate processes
• continue as before
• cause program to call one of your functions with an asynchronous function call

• programmers were embarrassed and frustrated by receiving SIGFPE
• told hardware designers to make systems where floating point exceptions would not occur
• hardware designers added handling such as INF-INF=NaN instead of triggering SIGFPE
• still one way to get SIGFPE:

    int x = INT_MIN / (-1);
                    

Some more information about kill:

                    
    int kill(pid_t pid, int sig); // send signal to process
        // can send only to own processes on lnxsrv

    pid_t p = fork();
    if(p > 0) {
        sleep(30);
        kill(p, SIGINT);
    }
    wait_pid(p, ...); // weird exit status > 127
                    
                

How do you handle signals?

Typedef of a Signal Handler

                    
    typedef void (*sighandler_t)(int); // pointer to function that takes int & returns void

    sighandler_t signal(int, sighandler_t); // int is sig num, returns old handler
                    
                

example:
                    
    int main(void) {
        signal(SIGALRM, bing); // set up handler before action that provokes signal
        alarm(30);
        // really complicated main code
        return 0;
    }
                    
                

                    
    void bing(int sig) {
        printf("BING! %d\n", sig);
        exit(27);
    }
                    
                

• signal could arrive while printf is being called. printf is not safe when called 'recursively'
• don't call exit. Exit flushes I/O buffers... could drop core.

• write
• read
• close
• _exit

• stdio (printf, fopen, fclose)
• malloc, free
• any function that looks at shared memory

    void bing(int sig) {
        write(1, "BING!\n", 6);
        _exit(27);
    }
                

• SIG_DFL
• SIG_IGN <= discard signals

Example of Signal Handling with gzip

                    
    gzip(...) {
        int in = open("foo", O_RDONLY);
        int out = open("foo.gz", OWRONLY);
        magiczip(in, out);
        close(in);
        close(out);
        unlink("foo");
    }
                    
                

                    
    gzip(...) {
        signal(SIGINT, SIG_IGN); // but then we can't use ^C
        int in = open("foo", O_RDONLY);
        int out = open("foo.gz", O_WRONLY);
        magiczip(in, out);
        close(in);
        close(out);
        unlink("foo");
    }   
                    
                

                    
    gzip(...) {
        signal(SIGINT, cleanup);
        int in = open("foo", O_RDONLY);
        int out = open("foo.gz", O_WRONLY);
        magicaip(in, out);
        close(in);
        close(out);
        unlink("foo");
    }

    void cleanup(int sig) {
        unlink("foo.gz");
        _exit(97);
    }
                    
                

                    
    gzip(...) {
        signal(SIGINT, cleanup);
        int in = open("foo", O_RDONLY);
        int out = open("foo.gz", O_WRONLY);
        magiczip(in, out);
        close(in);
        close(out);
        pthread sigmask(SIG_BLOCK);
        unlink("foo");
    }
                    
                

pthread_sigmask

                    
    int pthread_sigmask(int how,
                        sigset_t const * restrict set,
                        sigset_t * restrict oset);
                    
                

• how: handles altering of signal that it intercepts. i.e. how = {SIG_BLOCK or SIG_UNBLOCK or SIG_SETMASK}
• set: gets the old signal and combines values to figure what the new set will be
• oset: pointer to RO signal set

Threads

• we want a lot of them
• we want fast context-switching
• threads are not insulated from each other (threads utilize shared memory) which gives faster communication

+ performance
- simplicity (can be very complicated and lead to race conditions)
- reliability