FreeBSD/Linux Kernel Cross Reference
sys/servers/rs/service.c

     /* Utility to start or stop system services.  Requests are sent to the 
      * reincarnation server that does the actual work. 
      *
      * Changes:
      *   Jul 22, 2005:      Created  (Jorrit N. Herder)
      */
     
     #include <stdlib.h>
     #include <stdio.h>
    #include <string.h>
    #include <errno.h>
    #include <minix/config.h>
    #include <minix/com.h>
    #include <minix/const.h>
    #include <minix/type.h>
    #include <minix/ipc.h>
    #include <minix/syslib.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    
    
    /* This array defines all known requests. */
    PRIVATE char *known_requests[] = {
      "up", 
      "down",
      "refresh", 
      "rescue", 
      "shutdown", 
      "catch for illegal requests"
    };
    #define ILLEGAL_REQUEST  sizeof(known_requests)/sizeof(char *)
    
    /* Global error number set for failed system calls. */
    #define OK 0
    extern int errno;
    
    /* Define names for arguments provided to this utility. The first few 
     * arguments are required and have a known index. Thereafter, some optional
     * argument pairs like "-args arglist" follow.
     */
    #define ARG_NAME        0               /* own application name */
    #define ARG_REQUEST     1               /* request to perform */
    #define ARG_PATH        2               /* rescue dir or system service */
    #define ARG_PID         2               /* pid of system service */
    
    #define MIN_ARG_COUNT   2               /* require an action */
    
    #define ARG_ARGS        "-args"         /* list of arguments to be passed */
    #define ARG_DEV         "-dev"          /* major device number for drivers */
    #define ARG_PRIV        "-priv"         /* required privileges */
    #define ARG_PERIOD      "-period"       /* heartbeat period in ticks */
    
    /* The function parse_arguments() verifies and parses the command line 
     * parameters passed to this utility. Request parameters that are needed
     * are stored globally in the following variables:
     */
    PRIVATE int req_type;
    PRIVATE int req_pid;
    PRIVATE char *req_path;
    PRIVATE char *req_args;
    PRIVATE int req_major;
    PRIVATE long req_period;
    PRIVATE char *req_priv;
    
    /* Buffer to build "/command arg1 arg2 ..." string to pass to RS server. */
    PRIVATE char command[4096];     
    
    /* An error occurred. Report the problem, print the usage, and exit. 
     */
    PRIVATE void print_usage(char *app_name, char *problem) 
    {
      printf("Warning, %s\n", problem);
      printf("Usage:\n");
      printf("    %s up <binary> [%s <args>] [%s <special>] [%s <ticks>]\n", 
            app_name, ARG_ARGS, ARG_DEV, ARG_PERIOD);
      printf("    %s down <pid>\n", app_name);
      printf("    %s refresh <pid>\n", app_name);
      printf("    %s rescue <dir>\n", app_name);
      printf("    %s shutdown\n", app_name);
      printf("\n");
    }
    
    /* A request to the RS server failed. Report and exit. 
     */
    PRIVATE void failure(int num) 
    {
      printf("Request to RS failed: %s (%d)\n", strerror(num), num);
      exit(num);
    }
    
    
    /* Parse and verify correctness of arguments. Report problem and exit if an 
     * error is found. Store needed parameters in global variables.
     */
    PRIVATE int parse_arguments(int argc, char **argv)
    {
      struct stat stat_buf;
      char *hz;
      int req_nr;
     int i;
   
     /* Verify argument count. */ 
     if (argc < MIN_ARG_COUNT) {
         print_usage(argv[ARG_NAME], "wrong number of arguments");
         exit(EINVAL);
     }
   
     /* Verify request type. */
     for (req_type=0; req_type< ILLEGAL_REQUEST; req_type++) {
         if (strcmp(known_requests[req_type],argv[ARG_REQUEST])==0) break;
     }
     if (req_type == ILLEGAL_REQUEST) {
         print_usage(argv[ARG_NAME], "illegal request type");
         exit(ENOSYS);
     }
     req_nr = RS_RQ_BASE + req_type;
   
     if (req_nr == RS_UP) {
   
         /* Verify argument count. */ 
         if (argc - 1 < ARG_PATH) {
             print_usage(argv[ARG_NAME], "action requires a binary to start");
             exit(EINVAL);
         }
   
         /* Verify the name of the binary of the system service. */
         req_path = argv[ARG_PATH];
         if (req_path[0] != '/') {
             print_usage(argv[ARG_NAME], "binary should be absolute path");
             exit(EINVAL);
         }
         if (stat(req_path, &stat_buf) == -1) {
             print_usage(argv[ARG_NAME], "couldn't get status of binary");
             exit(errno);
         }
         if (! (stat_buf.st_mode & S_IFREG)) {
             print_usage(argv[ARG_NAME], "binary is not a regular file");
             exit(EINVAL);
         }
   
         /* Check optional arguments that come in pairs like "-args arglist". */
         for (i=MIN_ARG_COUNT+1; i<argc; i=i+2) {
             if (! (i+1 < argc)) {
                 print_usage(argv[ARG_NAME], "optional argument not complete");
                 exit(EINVAL);
             }
             if (strcmp(argv[i], ARG_ARGS)==0) {
                 req_args = argv[i+1];
             }
             else if (strcmp(argv[i], ARG_PERIOD)==0) {
                 req_period = strtol(argv[i+1], &hz, 10);
                 if (strcmp(hz,"HZ")==0) req_period *= HZ;
                 if (req_period < 1) {
                     print_usage(argv[ARG_NAME], "period is at least be one tick");
                     exit(EINVAL);
                 }
             }
             else if (strcmp(argv[i], ARG_DEV)==0) {
                 if (stat(argv[i+1], &stat_buf) == -1) {
                     print_usage(argv[ARG_NAME], "couldn't get status of device");
                     exit(errno);
                 }
                 if ( ! (stat_buf.st_mode & (S_IFBLK | S_IFCHR))) {
                     print_usage(argv[ARG_NAME], "special file is not a device");
                     exit(EINVAL);
                 } 
                 req_major = (stat_buf.st_rdev >> MAJOR) & BYTE;
             }
             else if (strcmp(argv[i], ARG_ARGS)==0) {
                 req_priv = argv[i+1];
             }
             else {
                 print_usage(argv[ARG_NAME], "unknown optional argument given");
                 exit(EINVAL);
             }
         }
     }
     else if (req_nr == RS_DOWN || req_nr == RS_REFRESH) {
   
         /* Verify argument count. */ 
         if (argc - 1 < ARG_PID) {
             print_usage(argv[ARG_NAME], "action requires a pid to stop");
             exit(EINVAL);
         }
         if (! (req_pid = atoi(argv[ARG_PID])) > 0) {
             print_usage(argv[ARG_NAME], "pid must be greater than zero");
             exit(EINVAL);
         }
     } 
     else if (req_nr == RS_RESCUE) {
   
         /* Verify argument count. */ 
         if (argc - 1 < ARG_PATH) {
             print_usage(argv[ARG_NAME], "action requires rescue directory");
             exit(EINVAL);
         }
         req_path = argv[ARG_PATH];
         if (req_path[0] != '/') {
             print_usage(argv[ARG_NAME], "rescue dir should be absolute path");
             exit(EINVAL);
         }
         if (stat(argv[ARG_PATH], &stat_buf) == -1) {
             print_usage(argv[ARG_NAME], "couldn't get status of directory");
             exit(errno);
         }
         if ( ! (stat_buf.st_mode & S_IFDIR)) {
             print_usage(argv[ARG_NAME], "file is not a directory");
             exit(EINVAL);
         } 
     } 
     else if (req_nr == RS_SHUTDOWN) {
           /* no extra arguments required */
     }
   
     /* Return the request number if no error were found. */
     return(req_nr);
   }
   
   
   /* Main program. 
    */
   PUBLIC int main(int argc, char **argv)
   {
     message m;
     int result;
     int request;
     int s;
   
     /* Verify and parse the command line arguments. All arguments are checked
      * here. If an error occurs, the problem is reported and exit(2) is called. 
      * all needed parameters to perform the request are extracted and stored
      * global variables. 
      */
     request = parse_arguments(argc, argv);
   
     /* Arguments seem fine. Try to perform the request. Only valid requests 
      * should end up here. The default is used for not yet supported requests. 
      */
     switch(request) {
     case RS_UP:
         /* Build space-separated command string to be passed to RS server. */
         strcpy(command, req_path);
         command[strlen(req_path)] = ' ';
         strcpy(command+strlen(req_path)+1, req_args);
   
         /* Build request message and send the request. */
         m.RS_CMD_ADDR = command;
         m.RS_CMD_LEN = strlen(command);
         m.RS_DEV_MAJOR = req_major;
         m.RS_PERIOD = req_period;
         if (OK != (s=_taskcall(RS_PROC_NR, request, &m))) 
             failure(s);
         result = m.m_type;
         break;
     case RS_DOWN:
     case RS_REFRESH:
         m.RS_PID = req_pid;
         if (OK != (s=_taskcall(RS_PROC_NR, request, &m))) 
             failure(s);
         break;
     case RS_RESCUE:
         m.RS_CMD_ADDR = req_path;
         m.RS_CMD_LEN = strlen(req_path);
         if (OK != (s=_taskcall(RS_PROC_NR, request, &m))) 
             failure(s);
         break;
     case RS_SHUTDOWN:
         if (OK != (s=_taskcall(RS_PROC_NR, request, &m))) 
             failure(s);
         break;
     default:
         print_usage(argv[ARG_NAME], "request is not yet supported");
         result = EGENERIC;
     }
     return(result);
   }
   

Cache object: af02c7dadeabf75e52f8f65736dbe8e9