Systems Programming/ C and UNIX

Transcription

1 Systems Programming/ C and UNIX A. Fischer CSCI 4547 / 6647 November 1, 2013 A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

2 Outline 1 Signals for Threads Signals 2 Signal Handling for Processes Signals and Waits 3 What is time? 4 Unix Time Representations of Time Time Functions A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

3 Signals and Threads Signals for Threads Signal Basics Listening for and Sending Signals Condition Variables A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

4 Signals for Threads Signals Signal Basics Code example: sigthread.c A signal is an integer code sent from one process or thread to another. A particular process decides which signals it will respond to. Those signals are defined by adding them individually to a signal set. A thread can wait() until it receives a signal from the defined set. An if statement is used to implement a signal handler for each member of the set. A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

5 Signals for Threads Defining and Using a Signal Set Signals Code example: sigthread.c sigset_t set; // Set of signals we will catch sigemptyset(&set); // Initialize opaque-type object. sigaddset(&set, SIGQUIT); // Quit signal. sigaddset(&set, SIGUSR1); // User-defined sig 1 rc = pthread_sigmask(sig_block, &set, NULL); A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

6 Signals for Threads Signals Defining and Using a Signal Set 2 The pthread_sigmask() function examines and/or changes the calling thread s signal mask. The first parameter specifies what to set the signal mask to: SIG_BLOCK: Union of the current mask and set. SIG_SETMASK: set. SIG_UNBLOCK: Intersection of the current mask and the complement of set. If set is not NULL, it specifies a set of signals to be modified SIGKILL and SIGSTOP cannot be blocked, and will be silently ignored if included in the sig- nal mask. Return values: If successful, pthread_sigmask() returns 0. Otherwise, an error code is returned. It fails if the enum constant is not one of those defined. A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

7 Signals for Threads Signals Listening for Signals Code example: sigthread.c pthread_kill sends a signal to a specified thread. In the child thread: rc = sigwait( &set, &rc ); In the parent thread: // Wake up all the children for(t=num_threads-1; t>= 0; t--){ sleep(1); pthread_kill( threads[t], SIGQUIT ); } A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

8 A User-defined Signal Signals for Threads Signals Code example: badthread.c In main() pthread_kill( threads[2], SIGUSR1 ); In the child thread: rc = pthread_sigmask(sig_block, &set, NULL); rc = sigwait( &set, &sig ); if (sig == SIGUSR1) printf("oh Mama! It s me, thread #%ld! That hurts.\n", tid); else printf("hello Mama! It s me, thread #%ld! I just woke up.\n", tid); A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

9 Signal Handling for Processes Signal Handling for Processes Signals Catching Signals Handling the Signal A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

10 Signal Handling for Processes Signals Signals allow the manipulation of a process from inside itself, from its children, or from outside its domain. Some signals cause termination of a process. They might result from an irrecoverable error or from a user typing the interrupt character. Other signals provide information, rather than cause termination. They are used when the status of processes changes, or when input is ready at the control terminal. The SIGKILL and SIGSTOP signals cannot be caught or ignored. They are received and processed by the kernel. It is not possible to redefine the way they are handled. Several signals (such as SIGINT) have default handlers that terminate the process, others do not have a default action. kill -CODE pid sends the signal CODE to the process pid. kill pid means the same thing as kill -TERM pid A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

11 Signal Handling for Processes Traditional Meanings of Signals Many signals have customary interpretations, but a programmer can redefine their meanings. SIGKILL: Terminate the process immediately; it is out of control and not responding to normal signals. SIGSTOP: Pause a process until SIGCONT is received. SIGSTP ( Z): Sent to a process by its controlling terminal when the user asks to suspend the process. SIGINT ( C): Terminate the process gracefully. SIGTERM: Terminate the process gracefully, i.e. flush buffers, ask the user if he wishes to save his files, and close the files. A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

12 More Signal Codes Signal Handling for Processes These signals can all be caught and redefined. Their default meanings are listed. SIGQUIT SIGALRM SIGHUP quit program and generate a dump terminate process; real-time timer expired terminate process; terminal line hangup SIGCHLD SIGBUS SIGSEGV child status has changed bus error segmentation violation SIGUSR1 User defined signal 1 SIGUSR2 User defined signal 2 A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

13 Signal Handling for Processes Catching Signals: siggy Many system-defined signals will terminate the process if they are not caught and handled. In the demo program, both the producer and consumer processes catch SIGINT. Catching and handling the signal requires three actions: Define the function that processes the signal. Define a signal handling structure. Attach the structure to the signal you want to catch. The program siggy shows how to set up these three parts. A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

14 Signal Handling for Processes The Signal-handling Structure We need an object of type sigset_t to use as a mask. sigset_t emptyset; // Create a signal set. sigemptyset(&emptyset); // Initialize it to empty. Define an object of type struct sigaction: struct sigaction newact; newact.sa_handler = breakhandler; // handler to use newact.sa_mask = emptyset; // signals to disable newact.sa_flags = 0; // 0 = default Attach the action to the interrupt code: sigaction(sigint, &newact, NULL); // interrupt signal A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

15 Signal Handling for Processes Signal Handlers The function that processes the signal is normally short, and a lot like an exception handler. Many signal handlers supply user information and terminate the process. Others set memory variables that will enable the process to continue meaningfully. The parameter to the handler-function is the code number of the signal that was sent. Depending on what the handler does, it may not work properly to use high-level IO or any other library functions that have internal state. A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

16 Signal Handling for Processes siggy s Signal Handler In siggy, we demonstrate the quick exit. This process prints a message using low-level output and writing to stderr. siggy s main loop (line 32) prints an infinite series of +. until the user types C to generate a SIGINT. When that interrupt happens, the breakhandler is called and siggy exits with an error code (1). void breakhandler(int sig) { char* message = " Process interrupted.\n"; write(2, message, strlen(message)); exit(1); } A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

17 Using sigwait() Signal Handling for Processes Signals and Waits The sigtest demo shows what happens when we reenter execution after catching a signal. We call sigwait() to put the process into a blocked state. To do so, we must define the set of signals that can end the wait. We need a sigset_t object: sigset_t sigset; sigemptyset(&sigset); sigaddset(&sigset, SIGINT); If we wanted to wake up for more than one reason, we could add more signal-types to the sigset. A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

18 Signal Handling for Processes Signals and Waits Catch, Handle, and Continue The sigtest demo shows the ugly interaction between signals and waits. This function catches the signal, sets a flag to say that it happened, and writes to stderr. It does NOT kill the process. void siginthandler(int sig) { flag = true; printf(" Signal %d received\n", sig); } When a signal handler returns, control goes back to wherever it was when the signal happened. In sigtest, we prompt the user twice to enter a SIGINT. The first time we are executing an output loop, the second time we are in a sigwait(). A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

19 Signal Handling for Processes Signals and Waits The Strange Behavior of sigtest On lines 44-45, we prompt the user for a signal, then execute a busy wait until the signal happens. Busy waits keep the CPU busy doing useless work. They should be avoided because they can severely damage performance in an application that uses multiple concurrent processes or threads. When the signal comes, the handler catches it and sets the flag. Then we leave the busy wait loop and provide feedback. Note that the flag has been set. After the second prompt (line 50), we call sigwait() and block. When the signal comes, it wakes us up but it DOES NOT call the signal handler. (The flag is not set.) This uncontrollable and unpredictable behavior makes signals very tricky to use. A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

20 What is time? What is time? Real Time and Elapsed Time Universal Time Time Accuracy A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

21 What is time? Real Time and Elapsed Time We use the word time in two ways: When: at what point in the history of the universe did an event take place. What time is it now? I will use time or clock time or real time to talk about when. How long: how many time units elapsed between the beginning and the end of an event? I will call this elapsed time. This seems like a simple subject but it is truly NOT simple. A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

22 What is time? Universal Time We have to measure a physical phenomenon, like time, before we can talk about it, store it, or use it. The world has an official time standard, maintained by a standards committee. It is based on astronomical observations and the UT1 is one form of Universal time, established by measuring the Earth s movement relative to a distant quasar. It is the same if measured anywhere on earth. The problem is that Earth s rotation is slightly irregular. UTC, or Coordinated Universal Time is measured using a completely regular atomic clock. It approximates UT1 and is the basis for world-wide civil time. This is kept synchronized with UT1 by adding leap-seconds to the UTC clock when the drift reaches.9 seconds. A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

23 What is time? Time Accuracy We set our clocks from some Universal Time reference clock, and hope they stay accurate. Any clock could be off in two ways: Drift: A clock could run a bit too fast or a bit too slow, or irregularly, and thus differ from the actual global time standard by some number of time units. Resolution: A time could be exactly on the global time standard, but be expressed in units that offer little precision. A measurement in seconds is less precise than a measurement in nanoseconds. When we record a real-time value, it might be recorded in an absolute frame of reference (UTC, or Universal Time) or in a relative frame of reference (Eastern Standard Time). A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

24 What is time? Drift Are our clocks always right? If a clock loses power and stops, it must be reset before it can be used at all. When the seasons change, clocks are set forward or back for daylight savings time. If a clock s time drifts gradually, it must be reset eventually. However, the drift may be small and not be noticed or corrected for a while. When a clock is corrected, its time suddenly jumps forward or back. People can cope with these changes. Computers cope less well. A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

25 What is time? Resolution What units do we use to measure time? Years? Good enough for ages. Days? Good enough for due dates. Seconds? Good enough for most human work, and to time program execution on a Commadore-64 The system s software clock measures time in jiffies:.01 to.001 seconds, depending on the version of your kernel. Microseconds? Appropriate for timing events at the scale of today s CPU. Modern computers are able to measure time at this resolution. The resolution of our clocks and timers must be meaningful for the measurement task. A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

26 Unix Time Unix Time System Time How Time is Used in Unix Representations of Time A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

27 Unix Time System Time Most computers have a battery-powered hardware clock that the system reads at boot time in order to initialize the system s software clock. The software clock defines the system time. Unix systems run a daemon that constantly communicates using the SNTP protocol (Simple Network Time Protocol) to stay synchronized with the official network time authority. The system clock is adjusted to conform to the network clock. It could be set either forward or backward. It is probable that some of the protocols will slow down a clock that is too fast, until it comes into synchrony with the standard. A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

28 System Time Unix Time Star time Global time International Telecommunication Union Network Time System Time A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

29 Unix Time How Time is Used in Unix Unix uses an absolute coordinate system that is based on global time. Each file has a creation time, a time of last modification, and a time of last access, recorded in system time. File times are the basis for maintaining consistency and currency among related files and file systems. cron jobs are executed automatically to do tasks such as backup at specific system times. A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

30 Unix Time How Intervals are Used in Unix Each process maintains a total elapsed time, the total execution time of system calls, and the total execution time of the user code, including all daughter threads, and excluding system calls. Execution time is used for time-sharing the CPU, for measuring performance and for charging customers on shared commercial systems. Modern systems support measurement of microsecond intervals, some smaller. Intervals are used to end timeouts (sleep). A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

31 Unix Time Mirrors and Backups These programs use date the of last modification of a file. rsync is a brilliant algorithm developed by Andrew Tridgell. It is capable of maintaining a backup mirror of a directory either locally or remotely over the network. The number of bytes that must be transmitted is minimized by sending differences, not whole files. I use the rsync command constantly to move files from one to another of my four personal machines. rsync machine1:source/ machine1:destination/ I can push files from here to elsewhere, or pull from there to here. rsync. machine2:destination/ rsync machine1:source/. My home file directory is backed up automatically each night by a cron job running rdiff-backup, which is based on the rsync library. A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

32 Unix Time Problems with Time Because our time tools are not perfect Recorded Unix times are absolute, but they are displayed in local time coordinates. A translation must therefore be done each time a date is displayed. A time recorded by non-unix-aware software might be in a relative, not absolute, coordinate system. The real time, recorded simultaneously on two different Unix machines, might be different if one is not connected to the internet. Systems like rsync rely on the accuracy of the timestamps of files on two different machines. If one machine is off, the software cannot work properly. When the local time is adjusted to synchronize with network time, it might need to go backwards. A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

33 Unix Time Representations of Time Representations of Time and Date The basic Unix times representation is an integer type, time_t, giving milliseconds since Jan 1, 1970 Negative date values go back to December 13, On February 13, 2009 at 23:31:30 (UTC) the Unix time was Worldwide, people had parties to celebrate this event. Currently, type time_t is the same length as a long int. This representation will be good until January 19, Before then, the Unix world will need to begin using more than 4 bytes for a date. Already, our hardware is beginning to support 8-byte integers. Also, we already need a finer mesh than milliseconds. So... it will change and we don t know when. So... don t rely on any particular implementation use type time_t and library functions to process dates.. A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

34 The Time Structure Unix Time Representations of Time A secondary time representation is broken down into readable fields: #include <time.h> struct tm { int tm_sec; // seconds int tm_min; // minutes int tm_hour; // hours int tm_mday; // day of the month int tm_mon; // month int tm_year; // year int tm_wday; // day of the week int tm_yday; // day in the year int tm_isdst; // daylight saving time }; Standard functions are used to convert between time_t and struct tm. A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

35 High-resolution Time Unix Time Representations of Time The timespec structure is normally used in combination with time_t to provide finer resolution for binary times. struct timeval { // defined in <sys/time.h> time_t tv_sec; // seconds since Jan suseconds_t tv_usec; // and microseconds }; struct timespec { // defined in <time.h> time_t tv_sec; // Seconds since 00:00:00 GMT Jan 1, 1970 long tv_nsec; // Additional nanoseconds since then } timespec_t; A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

36 More Time Definitions Unix Time Representations of Time useconds_t // defined in <unistd.h> an integer rep for microseconds that depends on the hardware. struct timezone { int tz_minuteswest; int tz_dsttime; }; // defined in <sys/time.h> // of Greenwich // type of dst correction to use struct itimerval { // defined in <sys/time.h> struct timeval it_interval; // timer interval struct timeval it_value; // current value }; A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

37 Unix Time Time Functions Time Functions All of these are in time.h. System time is stored as UTC (Coordinated Universal Time) time_t now = time( NULL ); // Read the system clock. Once you have a time_t, it can be converted to and from other forms using library functions: struct tm nowstruct = localtime( now ); struct tm nowstruct = gmtime( now ); These two formats can be converted to printable strings: char nowstring[25] = ctime( now ); char* now2 = asctime( &nowstruct ); tools contains a set of functions to extract the date (today()) and time (oclock()) separately. A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

38 Unix Time Time Functions Time Functions Use these variables: time_t time1, time2, elapsed; struct tm timestr; Convert from struct to integer format in current time zone: time1 = mktime( &timestr ); Convert from struct to integer format in UTC time: time1 = timegm( &timestr ); Interval from time1 to time2, in seconds. elapsed = difftime(time2, time1); A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

39 Unix Time Time Functions Functions for Formatting Times Use these variables: int resultlength; struct tm timestr; char *st; char buffer[25]; Format the time, producing a string. (Like a Java tostring().) See man page for format details. resultlength = strftime(buffer, 25, format, &imestr); The opposite operation from strftime(). Parse the string st, according to the format given, and fill in the fields of timestr. Return a pointer to the first character in st that has not been converted. st = strptime( st1, "%H:%M:%S", &timestr); A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

40 Hi-res Time Functions Unix Time Time Functions useconds_t ualarm( useconds_t, useconds_t ); A simplified interface to setitimer The first argument is the total lifetime of this timer. The second argument is the frequency at which the alarm should ring. int usleep( useconds_t usecs ); suspend thread execution for usecs microseconds int nanosleep( const struct timespec *rqtp, struct timespec *rmtp); suspend thread execution for rqtp nanoseconds The interval may be slightly longer, but will be as close as the system hardware can measure the interval. A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41

41 Unix Time Time Functions Adding and Subtracting Hi-Res Times The C libraries do not contain functions for adding and subtracting hi-res times. The code for working on microsecond-times is given at this website: libc Elapsed time This code can be easily modified to work on nanosecond-times. Basically, an addition or subtraction is done on the microsecond member of the timeval, and if that overflows, a carry is added to the member representing seconds. A. Fischer CSCI 4547 / 6647 () Systems Programming Lecture /41 November 1, / 41