void *collector(void *args) { Collector_args_s *a = args; /* * 1 ms -> 7% overhead * 10 ms -> 3% overhead */ struct timespec sleep = { 0, 10 * ONE_MILLION }; u8 buf[BUF_SIZE]; int cpu = a->cpu_id; int trace_pipe; int rc; int i; ignore_pid(gettid()); trace_pipe = open_raw(cpu); for (i = 0;; i++) { rc = read(trace_pipe, buf, sizeof(buf)); if (rc == -1) { close(trace_pipe); cleanup(0); } rc = parse_buf(buf); if (rc < SMALL_READ) { ++Slept; nanosleep(&sleep, NULL); } } return NULL; }
int divert_open(int port, divert_cb cb) { unsigned int bufsize = 1024 * 1024 * 1; unsigned int rc; char *m; int fd, flags; _h = nfq_open(); if (!_h) err(1, "nfq_open()"); rc = nfnl_rcvbufsiz(nfq_nfnlh(_h), bufsize); if (rc != bufsize) xprintf(XP_DEBUG, "Buffer size %u wanted %u\n", rc, bufsize); /* reset in case of previous crash */ if (nfq_unbind_pf(_h, AF_INET) < 0) err(1, "nfq_unbind_pf()"); if (nfq_bind_pf(_h, AF_INET) < 0) err(1, "nfq_bind_pf()"); _q = nfq_create_queue(_h, port, packet_input, cb); if (!_q) err(1, "nfq_create_queue()"); if (nfq_set_mode(_q, NFQNL_COPY_PACKET, 0xffff) < 0) err(1, "nfq_set_mode()"); if (nfq_set_queue_maxlen(_q, 10000) < 0) err(1, "nfq_set_queue_maxlen()"); xprintf(XP_DEFAULT, "Divert packets using iptables -j NFQUEUE --queue-num %d\n", port); m = driver_param(0); if (m) { _mark = strtoul(m, NULL, 16); xprintf(XP_DEFAULT, "Also, add -m mark --mark 0x0/0x%x\n", _mark); } fd = nfq_fd(_h); flags = fcntl(fd, F_GETFL); if (flags == -1) err(1, "fcntl()"); if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) err(1, "fcntl()"); open_raw(); return fd; }
bool RawInput::do_unpack () { if (m_unpacked) return true; // We need to unpack but we didn't when we opened the file. Close and // re-open with unpack. close (); bool ok = open_raw (true, m_filename, m_config); m_unpacked = true; return ok; }
bool RawInput::open (const std::string &name, ImageSpec &newspec, const ImageSpec &config) { m_filename = name; m_config = config; // For a fresh open, we are concerned with just reading all the // meatadata quickly, because maybe that's all that will be needed. So // call open_raw passing unpack=false. This will not read the pixels! We // will need to close and re-open with unpack=true if and when we need // the actual pixel values. bool ok = open_raw (false, m_filename, m_config); if (ok) newspec = m_spec; return ok; }
int divert_open(int port, divert_cb cb) { struct sockaddr_in s_in; memset(&s_in, 0, sizeof(s_in)); s_in.sin_family = PF_INET; s_in.sin_port = htons(port); if ((_s = socket(PF_INET, SOCK_RAW, IPPROTO_DIVERT)) == -1) err(1, "socket()"); if (bind(_s, (struct sockaddr*) &s_in, sizeof(s_in)) == -1) err(1, "bind()"); _cb = cb; xprintf(XP_DEFAULT, "Divert packets using ipfw add divert %d\n", port); open_raw(); return _s; }
void run( const gchar* plugin_name, gint nparams, const GimpParam* param, gint* nreturn_vals, GimpParam** return_vals, enum pix_fmt fmt, struct raw_data* img_data ) { static GimpParam values[2]; GimpRunMode run_mode; gchar* check_button_label; gint32 img = ERROR; if (!img_data) goto call_error; run_mode = param[0].data.d_int32; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = GIMP_PDB_SUCCESS; values[1].type = GIMP_PDB_IMAGE; values[1].data.d_image = ERROR; *return_vals = values; *nreturn_vals = 2; switch (run_mode) { case GIMP_RUN_INTERACTIVE: /* Possibly retrieve data */ gimp_get_data(plugin_name, img_data); switch(fmt) { case RGB_888: check_button_label = "BGR"; break; case UYVY_422: check_button_label = "YUYV"; break; default: check_button_label = NULL; break; } if (!load_dialog(img_data, check_button_label)) goto exec_error; break; case GIMP_RUN_NONINTERACTIVE: /* TODO */ goto call_error; break; case GIMP_RUN_WITH_LAST_VALS: gimp_get_data(plugin_name, img_data); break; } if (img_data->checked) { switch(fmt) { case RGB_888: fmt = BGR_888; break; case UYVY_422: fmt = YUYV_422; break; default: break; } } img = open_raw(param[1].data.d_string, fmt, img_data, plugin_name); if (img == ERROR) goto exec_error; if (run_mode != GIMP_RUN_INTERACTIVE) { gimp_image_clean_all(img); } else { gimp_set_data(plugin_name, img_data, sizeof(struct raw_data)); } values[0].data.d_status = GIMP_PDB_SUCCESS; values[1].data.d_image = img; return; call_error: values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR; return; exec_error: values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR; return; }