int main(int argc, char *argv[]) { int i; char *x = 0; int n = 100; int p = getpagesize(); if (argc > 1) { n = atoi(argv[1]); } rusage_init(); ldbg("Calling malloc for %d bytes\n", n * p); x = (char *) malloc(n * p); if (x == 0) { perror("main: Unable to malloc"); exit(1); } ldbg("x = %p\n", x); for (i = 0; i < n * p; i += p) { x[i] = 'A'; } rusage_print(); exit(0); }
int aio_sock_read(conn_t sd, void *buf, size_t count, void *reg_handle) { char *tmp = (char *) buf; PRINT_TIME(sd, &tnow, &tprev, "aio_sock_read: addr = %p count = %d handle %p", buf, count, reg_handle); /* load up the buffer so we can later trigger an event */ if (request_count < REQUESTS_PER_CONN) { ldbg("aio_sock_read: request_num = %d request = [%s]\n", request_num, fake_requests[request_num]); read_len = strlen(fake_requests[request_num]); strncpy((char *) buf, fake_requests[request_num], count); tmp[count] = '\0'; reg_verify(buf, count, reg_handle); request_num++; if (request_num >= FAKE_REQUESTS) { request_num = 0; } } else { ldbg("aio_sock_read: will return zero bytes (EOF)\n"); reg_verify(buf, count, reg_handle); read_len = 0; } return 1; }
void reg_verify(void *buf, size_t count, void *reg_handle) { struct reg_entry *rptr = 0; char *bufend = (char *) buf + count; int i = 0; int verified = 0; PRINT_TIME(NOFD, &tnow, &tprev, "reg_verify: buf = %p count = %d " "reg_handle = %p", buf, count, reg_handle); for (i = 0; i < MAX_REGIONS; i++) { rptr = &(reg_table[i]); PRINT_TIME(NOFD, &tnow, &tprev, "reg_verify: i = %d start = %p " "end = %p handle = %p", i, rptr->start, rptr->end, rptr->handle); if (((char *) buf >= rptr->start) && ((char *) bufend <= rptr->end) && ((char *) reg_handle == rptr->handle)) { PRINT_TIME(NOFD, &tnow, &tprev, "reg_verify: found match\n"); verified = 1; break; } } if (verified != 1) { ldbg("reg_table_verify : unable to verify specified region\n"); ldbg("reg_table_verify : buf = %p count = %d bufend = %p " "reg_handle = %p\n", buf, count, bufend, reg_handle); reg_table_print(); exit(1); } }
void reg_table_print(void) { struct reg_entry *rptr; int i; ldbg("Region Table Contents\n"); ldbg("%6s %20s %20s %20s\n", "index", "start", "end", "handle"); for (i = 0; i < MAX_REGIONS; i++) { rptr = &(reg_table[i]); ldbg("%6d %20p %20p %20p\n", i, rptr->start, rptr->end, rptr->handle); } ldbg("------------------------------\n"); }
/* This is only ever done once for each socket and it's * done before we actually start serving anything so * efficiency is not an issue. * * Not clear that there is a need to do set_not_special. */ void sock_set_special(int sd) { if (sd > FD_SETSIZE && options.ignore_fd_setsize) { printf ("sock_set_special: can't set special socket larger than FD_SETSIZE " "permits\n"); printf("sock_set_special: sd = %d FD_SETSIZE = %d\n", sd, FD_SETSIZE); exit(1); } assert(!FD_ISSET(sd, &special_set)); FD_SET(sd, &special_set); if (sd > sock_special_max) { sock_special_max = sd; } if (sd < sock_special_min) { sock_special_min = sd; } if (min_usable_sd == -1) { min_usable_sd = sd; } sock_special_num++; first_regular_sd = sock_special_max + 1; ldbg("sock_special_min %d max %d num %d\n", sock_special_min, sock_special_max, sock_special_num); }
static void parse_options(int argc, char **argv) { int c; while ((c = getopt(argc, argv, "u:hd")) != -1) { switch (c) { case 'h': usage(); exit(EXIT_OK); case 'd': set_log_level(LOG_LEVEL_DBG); break; case 'u': username = optarg; break; default: usage(); exit(EXIT_CLIOPT_ERR); } } /* get server hostname */ if (optind < argc) { server = argv[optind]; ldbg ("Parsed server host name as %s", server); optind++; } else { fprintf(stderr, "ERROR: IVPN server hostname required\n\n"); usage(); exit(EXIT_CLIOPT_ERR); } /* get the optional port number */ if (optind < argc) { port = atoi(argv[optind]); ldbg ("Parsed server port as %u", port); optind++; } if (optind < argc) { fprintf(stderr, "ERROR: Extra arguments in command line\n\n"); usage(); exit(EXIT_CLIOPT_ERR); } }
static inline int check_tty_opened(struct rawbulk_function *fn) { int opened; unsigned long flags; ldbg("%s\n", __func__); spin_lock_irqsave(&fn->lock, flags); opened = fn->tty_opened? 1: 0; spin_unlock_irqrestore(&fn->lock, flags); return opened; }
static inline int check_enable_state(struct rawbulk_function *fn) { int enab; unsigned long flags; ldbg("%s\n", __func__); spin_lock_irqsave(&fn->lock, flags); enab = fn->enable? 1: 0; spin_unlock_irqrestore(&fn->lock, flags); return enab; }
static struct rawbulk_function *lookup_by_tty_minor(int minor) { int n; struct rawbulk_function *fn; ldbg("%s\n", __func__); for (n = 0; n < _MAX_TID; n ++) { fn = prealloced_functions[n]; if (fn->tty_minor == minor) return fn; } return NULL; }
/** * wm8350_reg_unlock() * * The WM8350 has a hardware lock which can be used to prevent writes to * some registers (generally those which can cause particularly serious * problems if misused). This function disables that lock so updates * can be performed. For maximum safety this should be done only when * required. */ int wm8350_reg_unlock(struct wm8350 *wm8350) { u16 key = WM8350_UNLOCK_KEY; int ret; ldbg(__func__); mutex_lock(&io_mutex); ret = wm8350_write(wm8350, WM8350_SECURITY, 1, &key); if (ret) dev_err(wm8350->dev, "unlock failed\n"); mutex_unlock(&io_mutex); return ret; }
static int run_client() { int connfd = -1; ldbg ("Client attempting to connect to %s:%u", server, port); connfd = tcputil_connect(server, port); if (connfd == -1) return -1; linfo ("Connected to %s:%u", server, port); return control_channel_handler(connfd); }
/*---------------------------------------------------------------------*/ unsigned long int hash(char *uri) { unsigned long int ret = 0; switch (USE_HASH) { case USE_HASH_ADDITIVE: ret = do_hash_additive(uri); break; case USE_HASH_BOB: ret = do_hash_bob((unsigned char *) uri, strlen(uri), 0); break; default: printf("hash: unknown hash function defined %d\n", USE_HASH); exit(1); break; } ldbg("hash: ret = %lu\n", ret); return ret; }
int rawbulk_check_enable(struct rawbulk_function *fn) { ldbg("%s\n", __func__); return check_enable_state(fn); }
struct rawbulk_function *rawbulk_lookup_function(int transfer_id) { ldbg("%s\n", __func__); if (transfer_id >= 0 && transfer_id < _MAX_TID) return prealloced_functions[transfer_id]; return NULL; }
int rawbulk_function_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl) { struct rawbulk_function *fn = function_to_rbf(f); unsigned int setdtr = 0; unsigned int data_connect = 0; struct usb_composite_dev *cdev = f->config->cdev; struct usb_request *req = cdev->req; int value = -EOPNOTSUPP; u16 w_index = le16_to_cpu(ctrl->wIndex); u16 w_value = le16_to_cpu(ctrl->wValue); u16 w_length = le16_to_cpu(ctrl->wLength); if(ctrl->bRequest) { ldbg("ctrl->bRequestType = %0x ctrl->bRequest = %0x \n", ctrl->bRequestType, ctrl->bRequest); } switch(ctrl->bRequest) { case 0x01: if(ctrl->bRequestType == (USB_DIR_OUT | USB_TYPE_VENDOR)) {//0x40 // set/clear DTR ldbg("setdtr = %d, w_value =%d\n", setdtr, w_value); if(fn->activated){ setdtr = w_value & 0x01; //schedule_work(&flow_control); modem_dtr_set(setdtr, 0); modem_dcd_state(); } value = 0; } break; case 0x02: if(ctrl->bRequestType == (USB_DIR_IN | USB_TYPE_VENDOR)) {//0xC0 // DSR | CD109 //schedule_work(&dtr_status); data_connect = modem_dcd_state(); //modem_dtr_query(&data_connect, 0); if(fn->activated) { if(data_connect && fn->enable) { *((unsigned char *)req->buf) = 0x3; ldbg("connect %d\n", data_connect); } else { *((unsigned char *)req->buf) = 0x2; ldbg("disconnect=%d, setdtr=%d\n", data_connect, setdtr); } } else //set CD CSR state to 0 if modem bypass not inactive *((unsigned char *)req->buf) = 0x0; value = 1; } break; case 0x03: if(ctrl->bRequestType == (USB_DIR_OUT | USB_TYPE_VENDOR)) {//0x40 // xcvr ldbg("CTRL SET XCVR 0x%02x\n", w_value); value = 0; } break; case 0x04: if((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_VENDOR) { if(ctrl->bRequestType & USB_DIR_IN) {//0xC0 // return ID sprintf(req->buf, "CBP_8.2"); value = 1; } else {//0x40 value = 0; } } break; case 0x05: if(ctrl->bRequestType == (USB_DIR_IN | USB_TYPE_VENDOR)) {//0xC0 // connect status ldbg("CTRL CONNECT STATUS\n"); *((unsigned char *)req->buf) = 0x0; value = 1; } break; default: ldbg("invalid control req%02x.%02x v%04x i%04x l%d\n", ctrl->bRequestType, ctrl->bRequest, w_value, w_index, w_length); } // respond with data transfer or status phase? if (value >= 0) { req->zero = 0; req->length = value; req->complete = simple_setup_complete; value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC); if (value < 0) printk(KERN_ERR "response err %d\n", value); } // device either stalls (value < 0) or reports success return value; }
/* Move SELF to the front of the LRU queue: */ void lru_access(int sd) { int self; assert(!sock_is_listener(sd)); if (sock_is_special(sd)) { return; } self = info_index(sd); if (self == NULL_INDEX) { printf("lru_access: no mapping for sd = %d\n", sd); exit(1); } if (LRU_DEBUG) printf("%d: lru_access(%d) ->\n", (int) getpid(), self); if (!(self < lru_size)) { printf ("lru_access: trying to access element %d but lru array is of size %d\n", self, lru_size); exit(1); } lru[self].time = lru_now; lru[self].sd = sd; if (lru_head != lru_tail && self != lru_head) { if (self == lru_tail) { lru_tail = lru[self].prev; } else { lru[lru[self].prev].next = lru[self].next; lru[lru[self].next].prev = lru[self].prev; } lru[self].next = lru_head; lru[lru_head].prev = self; lru_head = self; } if (LRU_DEBUG) { int i, j, p = 0; for (i = 0, j = lru_head; i < lru_size; ++i) { printf(" %d@%d [%d,%d]", j, lru[j].sd, lru[j].prev, lru[j].next); if (i > 0 && lru[j].prev != p) printf(" -BAD!"); p = j; j = lru[j].next; printf("\n"); } if (lru_tail != p) { printf(" BAD lru_tail = %d p = %d", lru_tail, p); } printf("\n"); } ldbg("lru_access: sd = %d self = %d lru_head = %d lru_tail = %d\n", sd, lru_head, lru_tail, self); }