Exemplo n.º 1
0
int my_fstat(int type, int fd, void *buf)
{
  log_msg(MOD_MSG "fstat\n");
  plash_libc_lock();

  if(0 <= fd && fd < g_fds_size && g_fds[fd].fd_dir_obj) {
    /* Handle directory FDs specially:  send a message. */
    cap_t dir_obj = g_fds[fd].fd_dir_obj;
    region_t r = region_make();
    cap_t fs_op_server;
    struct cap_args result;
    int rc = -1;
    log_fd(fd, "fstat on directory");
    if(!buf) {
      __set_errno(EINVAL);
      goto exit;
    }
    if(libc_get_fs_op(&fs_op_server) < 0)
      goto exit;
    cap_call(fs_op_server, r,
	     cap_args_dc(mk_int(r, METHOD_FSOP_DIR_FSTAT),
			 mk_caps1(r, inc_ref(dir_obj))),
	     &result);
    {
      seqf_t msg = flatten_reuse(r, result.data);
      int ok = 1;
      m_int_const(&ok, &msg, METHOD_R_FSOP_STAT);
      m_stat_info(&ok, &msg, type, buf);
      m_end(&ok, &msg);
      if(ok && result.fds.count == 0 && result.caps.size == 0) {
	rc = 0;
	goto exit;
      }
    }
    pl_args_free(&result);
    set_errno_from_reply(flatten_reuse(r, result.data));
  exit:
    plash_libc_unlock();
    region_free(r);
    return rc;
  }
  else {
    plash_libc_unlock();

    /* Use the normal fstat system call. */
    log_fd(fd, "normal fstat");
    if(type == TYPE_STAT) {
      return kernel_fxstat(_STAT_VER, fd, (struct stat *) buf);
    }
    else if(type == TYPE_STAT64) {
      return kernel_fxstat64(_STAT_VER, fd, (struct stat64 *) buf);
    }
    else {
      /* Don't recognise ABI version requested. */
      __set_errno(ENOSYS);
      return -1;
    }
  }
}
Exemplo n.º 2
0
void log_preamble(Config_t *cfg)
{
  time_t t = get_starttime();
  
  log_printf(0, "\n");
  log_printf(0, "*****************************************************************\n");
  log_printf(0, "Starting ibp_server on %s", ctime(&t));
  log_printf(0, "*****************************************************************\n");
  log_printf(0, "\n");

  log_printf(0, "*********************Printing configuration file **********************\n\n");
   
  print_config(log_fd(), cfg);  

  log_printf(0, "*****************************************************************\n\n");
}
Exemplo n.º 3
0
int main(int argc, char *argv[])
{
    signal(SIGCHLD, signal_sigchld);
    signal(SIGINT, signal_sigint);
    signal(SIGPIPE, signal_sigint);
    signal(SIGTERM, signal_sigint);
    signal(SIGTSTP, signal_sigint);
    signal(SIGHUP, signal_sigint);

    log_level(_LOG_DEBUG);
    log_msg("Start zoodis.");

    zoodis.keepalive_interval           = DEFAULT_KEEPALIVE_INTERVAL;

    zoodis.zoo_stat                     = ZOO_STAT_NOT_CONNECTED;
    zoodis.zoo_timeout                  = DEFAULT_ZOO_TIMEOUT;
    zoodis.zoo_connect_wait_interval    = DEFAULT_ZOO_CONNECT_WAIT_INTERVAL;

    zoodis.redis_port                   = DEFAULT_REDIS_PORT;
    zoodis.redis_ping_interval          = DEFAULT_REDIS_PING_INTERVAL;
    zoodis.redis_pong_timeout_sec       = DEFAULT_REDIS_PONG_TIMEOUT_SEC;
    zoodis.redis_pong_timeout_usec      = DEFAULT_REDIS_PONG_TIMEOUT_USEC;
    zoodis.redis_max_fail_count         = DEFAULT_REDIS_MAX_FAIL_COUNT;
    zoodis.pid_file                     = NULL;

    zoodis.redis_stat = REDIS_STAT_NONE;

    static struct option long_options[] =
    {
        {"help",                no_argument,        0,  'h'},
        {"version",             no_argument,        0,  'v'},
        {"log-level",           required_argument,  0,  'l'},
        {"pid-file",            required_argument,  0,  'f'},
        {"keepalive",           no_argument,        0,  'k'},
        {"keepalive-interval",  required_argument,  0,  'i'},
        {"redis-bin",           required_argument,  0,  'b'},
        {"redis-conf",          required_argument,  0,  'c'},
        {"redis-port",          required_argument,  0,  'r'},
        {"redis-ping-interval", required_argument,  0,  's'},
        {"zoo-host",            required_argument,  0,  'z'},
        {"zoo-path",            required_argument,  0,  'p'},
        {"zoo-nodename",        required_argument,  0,  'n'},
        {"zoo-nodedata",        required_argument,  0,  'd'},
        {"zoo-timeout",         required_argument,  0,  't'},
        {0, 0, 0, 0}
    };

    enum zoo_res zres;

    if(argc < 3)
        print_help(argv);

    while (1)
    {
        /* getopt_long stores the option index here. */
        int option_index = 0;
        int opt;

        opt = getopt_long_only(argc, argv, "", long_options, &option_index);

        /* Detect the end of the options. */
        if (opt == -1)
            break;

        switch (opt)
        {
            case 'h':
                print_help(argv);
                break;

            case 'v':
                print_version(argv);
                break;

            case 'l':
                set_logging(optarg);
                break;

            case 'k':
                zoodis.keepalive = 1;
                break;

            case 'f':
                zoodis.pid_file = check_pid_file(optarg);

            case 'i':
                zoodis.keepalive_interval = check_option_int(optarg, DEFAULT_KEEPALIVE_INTERVAL);
                break;

            case 'b':
                zoodis.redis_bin = check_redis_bin(optarg);
                break;

            case 'c':
                zoodis.redis_conf = check_redis_conf(optarg);
                break;

            case 'r':
                zoodis.redis_port = check_option_int(optarg, DEFAULT_REDIS_PORT);
                break;

            case 's':
                zoodis.redis_ping_interval = check_option_int(optarg, DEFAULT_REDIS_PING_INTERVAL);
                break;

            case 'z':
                zoodis.zoo_host = check_zoo_host(optarg);
                break;

            case 'p':
                zoodis.zoo_path = check_zoo_path(optarg);
                break;

            case 'n':
                zoodis.zoo_nodename = check_zoo_nodename(optarg);
                break;

            case 'd':
                zoodis.zoo_nodedata = check_zoo_nodedata(optarg);
                break;

            case 't':
                zoodis.zoo_timeout = check_option_int(optarg, DEFAULT_ZOO_TIMEOUT);
                break;

            default:
                exit_proc(-1);
        }
    }

    zoodis.zookeeper = check_zoo_options(&zoodis);

    if(zoodis.zoo_nodedata == NULL)
        zoodis.zoo_nodedata = mstr_alloc_dup(DEFAULT_ZOO_NODEDATA, strlen(DEFAULT_ZOO_NODEDATA));

    check_redis_options(&zoodis);

    if(zoodis.zookeeper)
    {
        zoodis.zoo_nodepath = mstr_concat(3, zoodis.zoo_path->data, "/", zoodis.zoo_nodename->data);
        zu_set_log_level(log_level(0));
        zu_set_log_stream(log_fd(stdout));
        zres = zu_connect(&zoodis);
        if(zres != ZOO_RES_OK)
        {
            exit_proc(-1);
        }
    }

//    sleep(1);
//    while(zoodis.zoo_stat != ZOO_STAT_CONNECTED)
//    if(zoodis.zoo_stat != ZOO_STAT_CONNECTED)
//    {
//        log_warn("Zookeeper: is not connected yet.");
//        sleep(zoodis.zoo_connect_wait_interval);
//    }

    exec_redis();
    redis_health();
    return 0;
}