Programming Concepts

• You should read chapter 3.
• A system call is an entry point into the kernel.
• System Calls:
  • Change the processor state from user mode to protected mode.
  • Perform an action on behalf of the program.
  • Allow the system to perform kernel activity
• Each system call has
  • A unique integer, which is used in a lookup table to make the system call.
  • A set of arguments that are passed to the kernel.
• On page 44/45 he goes into real detail about what happens in a system call.
  • The program calls a wrapper function in the c library
    • The arguments are place in the proper location (most likely registers, but I bet this depends on the architecture.
    • This includes placing the system call number in the proper location as well (x86 the EAX register)
  • The wrapper executes the instruction that changes processor mode.
    • On the x86 this is the trap instruction.
    • But the processor enters protected mode.
  • The processor
    • Performs a context switch.
    • Checks the validity of the system call
    • Saves all registers.
    • Based on the system call number invokes a service routine.
      • This is just a computed goto.
      • And jumps into a portion of the kernel designed to handle the request.
  • Once the system call is completed, the environment for some process is restored.
    • Selected by the scheduler
    • This may or may not be the process we started with.
    • But the process we started with will eventually be restored through this process.
  • If the system call had an error, a global variable errno will be set.
  • 
• Errors
  • Let's take a look at two system calls.
    • int gethostname(char *name, size_t len);
    • int sethostname(const char *name, size_t len);
    • The first will attempt to get the system's host name.
    • The second will attempt to set the system's host name.
    • These routines require the user to supply a memory location
    • Take a quick look at the man pages.
      • Note the description
      • Note the return value
      • Note errors
  • So an acceptable program might be

    // myHostName.C
    #include <iostream>
    
    #include <unistd.h>  // get/set hostname
    #include <limits.h>   // for HOST_NAME_MAX
    
    using namespace std;
    
    const int LEN = HOST_NAME_MAX;
    
    int main() {
         char name[LEN];
    
         gethostname(name, LEN);
         cout << "The host name is " << name << endl;
    
         return 0;
    } 

  • And this probably would be safe for a normal program but.
  • But we are writing systems utilities, and we want to be a little more careful.
  • Note that system calls can set errno and the documentation on how this is set

    // errors.C
    int main() {
         char name[LEN];
         char eName[1];
    
         cout << "Before the call errno is " << errno << endl;
         gethostname(eName, 1);
         cout << "After the first call errno is " << errno << endl;
         sethostname(eName, 1);
         cout << "After the second call errno is " << errno << endl;
    
         return 0;
    } 

  • Notice several things
    • errno may be set, but it may also be changed by additional system calls.
    • the number alone in meaningless.
    • But note, it does not automatically get set to 0 after an error.
  • So you need to use errno right away if there is an error
  • And not really trust errno to tell you that there was an error.
  • void perror(const char *s);
    • You might need stdio.h
    • Will print a message to standard error describing the error
    • And will print the string you pass it as well.

      // part of error2.C
      if (0 != gethostname(eName, 1)) {
          perror("Failed to get the host name");
      } 

  • A second alternative is strerror
    • Needs string.h
    • char *strerror(int errnum);
    • The pointer returned is to system memory, not yours
    • You should not modify or free it.
    • It will be changed by other calls to strerror
    • strerror may cause an error, thus errno may be changed.

    // part of error3.C
        int errorNum;
         char * errorMessage;
    
         if (0 != gethostname(eName, 1)) {
             errorNum = errno;
             errorMessage = strerror(errorNum);
             cerr << "\tThe call to gethostname failed" << endl ;
             cerr << "\tThe system says " << errorMessage << endl;
         } 

• Code for this section