void relay_dns_result(struct rsession *con, u_int8_t *buf, size_t len) { struct relay *rlay = (struct relay *)con->se_relay; struct relay_dns_priv *priv = (struct relay_dns_priv *)con->se_priv; struct relay_dnshdr *hdr; socklen_t slen; if (priv == NULL) fatalx("relay_dns_result: response to invalid session"); if (debug) relay_dns_log(con, buf, len); /* * Replace the random DNS request Id with the original Id */ hdr = (struct relay_dnshdr *)buf; hdr->dns_id = htons(priv->dp_outkey); slen = con->se_out.ss.ss_len; if (sendto(rlay->rl_s, buf, len, 0, (struct sockaddr *)&con->se_in.ss, slen) == -1) { relay_close(con, "response failed"); return; } relay_close(con, "session closed"); }
static void guc_log_relay_destroy(struct intel_guc_log *log) { lockdep_assert_held(&log->relay.lock); relay_close(log->relay.channel); log->relay.channel = NULL; }
void ath9k_cmn_spectral_deinit_debug(struct ath_spec_scan_priv *spec_priv) { if (config_enabled(CONFIG_ATH9K_DEBUGFS) && spec_priv->rfs_chan_spec_scan) { relay_close(spec_priv->rfs_chan_spec_scan); spec_priv->rfs_chan_spec_scan = NULL; } }
void ath9k_spectral_deinit_debug(struct ath_softc *sc) { if (config_enabled(CPTCFG_ATH9K_DEBUGFS) && sc->rfs_chan_spec_scan) { relay_close(sc->rfs_chan_spec_scan); sc->rfs_chan_spec_scan = NULL; } }
void relay_udp_response(int fd, short sig, void *arg) { struct rsession *con = (struct rsession *)arg; struct relay *rlay = con->se_relay; struct protocol *proto = rlay->rl_proto; void *priv = NULL; struct sockaddr_storage ss; u_int8_t buf[IBUF_READ_SIZE]; ssize_t len; socklen_t slen; if (sig == EV_TIMEOUT) { relay_udp_timeout(fd, sig, arg); return; } if (relay_sessions >= RELAY_MAX_SESSIONS || rlay->rl_conf.flags & F_DISABLE) return; slen = sizeof(ss); if ((len = recvfrom(fd, buf, sizeof(buf), 0, (struct sockaddr*)&ss, &slen)) < 1) return; /* Parse and validate the packet header */ if (proto->validate != NULL && (priv = (*proto->validate)(con, rlay, &ss, buf, len)) == NULL) return; relay_close(con, "unknown response"); if (priv != NULL) free(priv); }
static void blk_trace_cleanup(struct blk_trace *bt) { relay_close(bt->rchan); debugfs_remove(bt->dropped_file); blk_remove_tree(bt->dir); free_percpu(bt->sequence); kfree(bt); }
void relay_udp_timeout(int fd, short sig, void *arg) { struct rsession *con = (struct rsession *)arg; if (sig != EV_TIMEOUT) fatalx("invalid timeout event"); relay_close(con, "udp timeout"); }
static void blk_trace_free(struct blk_trace *bt) { debugfs_remove(bt->msg_file); debugfs_remove(bt->dropped_file); relay_close(bt->rchan); debugfs_remove(bt->dir); free_percpu(bt->sequence); free_percpu(bt->msg_data); kfree(bt); }
static void __exit kt_exit(void) { unsigned long entry; remove_proc_entry("kmalloc_test", NULL); relay_close(relay); for (entry = 0; entry < MAX_SWAP_SIZE / PAGE_SIZE; entry++) if (table[entry]) kfree(table[entry]); vfree(table); }
void * relay_dns_validate(struct rsession *con, struct relay *rlay, struct sockaddr_storage *ss, u_int8_t *buf, size_t len) { struct relay_dnshdr *hdr = (struct relay_dnshdr *)buf; struct rsession lookup; u_int16_t key; struct relay_dns_priv *priv, lpriv; /* Validate the header length */ if (len < sizeof(*hdr)) return (NULL); key = ntohs(hdr->dns_id); /* * Check if the header has the response flag set, otherwise * return 0 to tell the UDP server to create a new session. */ if ((hdr->dns_flags0 & DNS_F0_QR) == 0) { priv = malloc(sizeof(struct relay_dns_priv)); if (priv == NULL) return (NULL); priv->dp_inkey = shuffle_generate16(&relay_shuffle); priv->dp_outkey = key; return ((void *)priv); } /* * Lookup if this response is for a known session and if the * remote host matches the original destination of the request. */ if (con == NULL) { lpriv.dp_inkey = key; lookup.se_priv = &lpriv; if ((con = SPLAY_FIND(session_tree, &rlay->rl_sessions, &lookup)) != NULL && con->se_priv != NULL && relay_cmp_af(ss, &con->se_out.ss) == 0) relay_dns_result(con, buf, len); } else { priv = (struct relay_dns_priv *)con->se_priv; if (priv == NULL || key != priv->dp_inkey) { relay_close(con, "invalid response"); return (NULL); } relay_dns_result(con, buf, len); } /* * This is not a new session, ignore it in the UDP server. */ return (NULL); }
static void __exit tlsf_kmod_exit(void) { unsigned long entry; remove_proc_entry("tlsf_test", &proc_root); relay_close(relay); for (entry = 0; entry < MAX_SWAP_SIZE / PAGE_SIZE; entry++) if (table[entry]) tlsf_free(table[entry], mem_pool); vfree(table); tlsf_destroy_memory_pool(mem_pool); }
void st_relayfs_close(void) { int n; for(n=0;n<RELAY_NUMBER_OF_TYPES;n++) { if(relay_entries[n].dentry) debugfs_remove(relay_entries[n].dentry); } if(strelay_dir) debugfs_remove(strelay_dir); if (st_relay_chan) relay_close(st_relay_chan); st_relay_chan = 0; }
static void blk_trace_cleanup(struct blk_trace *bt) { debugfs_remove(bt->msg_file); debugfs_remove(bt->dropped_file); relay_close(bt->rchan); free_percpu(bt->sequence); free_percpu(bt->msg_data); kfree(bt); mutex_lock(&blk_probe_mutex); if (atomic_dec_and_test(&blk_probes_ref)) blk_unregister_tracepoints(); mutex_unlock(&blk_probe_mutex); }
static int do_kvm_trace_enable(struct kvm_user_trace_setup *kuts) { struct kvm_trace *kt; int i, r = -ENOMEM; if (!kuts->buf_size || !kuts->buf_nr) return -EINVAL; kt = kzalloc(sizeof(*kt), GFP_KERNEL); if (!kt) goto err; r = -EIO; atomic_set(&kt->lost_records, 0); kt->lost_file = debugfs_create_file("lost_records", 0444, kvm_debugfs_dir, kt, &kvm_trace_lost_ops); if (!kt->lost_file) goto err; kt->rchan = relay_open("trace", kvm_debugfs_dir, kuts->buf_size, kuts->buf_nr, &kvm_relay_callbacks, kt); if (!kt->rchan) goto err; kvm_trace = kt; for (i = 0; i < ARRAY_SIZE(kvm_trace_probes); i++) { struct kvm_trace_probe *p = &kvm_trace_probes[i]; r = marker_probe_register(p->name, p->format, p->probe_func, p); if (r) printk(KERN_INFO "Unable to register probe %s\n", p->name); } kvm_trace->trace_state = KVM_TRACE_STATE_RUNNING; return 0; err: if (kt) { if (kt->lost_file) debugfs_remove(kt->lost_file); if (kt->rchan) relay_close(kt->rchan); kfree(kt); } return r; }
void kvm_trace_cleanup(void) { struct kvm_trace *kt = kvm_trace; int i; if (kt == NULL) return; if (kt->trace_state == KVM_TRACE_STATE_RUNNING || kt->trace_state == KVM_TRACE_STATE_PAUSE) { kt->trace_state = KVM_TRACE_STATE_CLEARUP; for (i = 0; i < ARRAY_SIZE(kvm_trace_probes); i++) { struct kvm_trace_probe *p = &kvm_trace_probes[i]; marker_probe_unregister(p->name, p->probe_func, p); } relay_close(kt->rchan); debugfs_remove(kt->lost_file); kfree(kt); } }
/* * Setup everything required to start tracing */ int do_blk_trace_setup(struct request_queue *q, char *name, dev_t dev, struct blk_user_trace_setup *buts) { struct blk_trace *old_bt, *bt = NULL; struct dentry *dir = NULL; int ret, i; if (!buts->buf_size || !buts->buf_nr) return -EINVAL; strcpy(buts->name, name); /* * some device names have larger paths - convert the slashes * to underscores for this to work as expected */ for (i = 0; i < strlen(buts->name); i++) if (buts->name[i] == '/') buts->name[i] = '_'; ret = -ENOMEM; bt = kzalloc(sizeof(*bt), GFP_KERNEL); if (!bt) goto err; bt->sequence = alloc_percpu(unsigned long); if (!bt->sequence) goto err; ret = -ENOENT; dir = blk_create_tree(buts->name); if (!dir) goto err; bt->dir = dir; bt->dev = dev; atomic_set(&bt->dropped, 0); ret = -EIO; bt->dropped_file = debugfs_create_file("dropped", 0444, dir, bt, &blk_dropped_fops); if (!bt->dropped_file) goto err; bt->rchan = relay_open("trace", dir, buts->buf_size, buts->buf_nr, &blk_relay_callbacks, bt); if (!bt->rchan) goto err; bt->act_mask = buts->act_mask; if (!bt->act_mask) bt->act_mask = (u16) -1; bt->start_lba = buts->start_lba; bt->end_lba = buts->end_lba; if (!bt->end_lba) bt->end_lba = -1ULL; bt->pid = buts->pid; bt->trace_state = Blktrace_setup; ret = -EBUSY; old_bt = xchg(&q->blk_trace, bt); if (old_bt) { (void) xchg(&q->blk_trace, old_bt); goto err; } return 0; err: if (dir) blk_remove_tree(dir); if (bt) { if (bt->dropped_file) debugfs_remove(bt->dropped_file); free_percpu(bt->sequence); if (bt->rchan) relay_close(bt->rchan); kfree(bt); } return ret; }
void relay_udp_server(int fd, short sig, void *arg) { struct relay *rlay = (struct relay *)arg; struct protocol *proto = rlay->rl_proto; struct rsession *con = NULL; struct ctl_natlook *cnl = NULL; socklen_t slen; struct timeval tv; struct sockaddr_storage ss; u_int8_t buf[IBUF_READ_SIZE]; void *priv = NULL; ssize_t len; if (relay_sessions >= RELAY_MAX_SESSIONS || rlay->rl_conf.flags & F_DISABLE) return; slen = sizeof(ss); if ((len = recvfrom(fd, buf, sizeof(buf), 0, (struct sockaddr*)&ss, &slen)) < 1) return; if (proto->validate != NULL && (priv = (*proto->validate)(NULL, rlay, &ss, buf, len)) == NULL) return; if ((con = (struct rsession *) calloc(1, sizeof(struct rsession))) == NULL) { free(priv); return; } /* * Replace the DNS request Id with a random Id. */ con->se_priv = priv; con->se_in.s = -1; con->se_out.s = -1; con->se_in.dst = &con->se_out; con->se_out.dst = &con->se_in; con->se_in.con = con; con->se_out.con = con; con->se_relay = rlay; con->se_hashkey = rlay->rl_dstkey; con->se_id = ++relay_conid; con->se_in.tree = &proto->request_tree; con->se_out.tree = &proto->response_tree; con->se_in.dir = RELAY_DIR_REQUEST; con->se_out.dir = RELAY_DIR_RESPONSE; con->se_retry = rlay->rl_conf.dstretry; if (gettimeofday(&con->se_tv_start, NULL) == -1) { free(con); free(priv); return; } bcopy(&con->se_tv_start, &con->se_tv_last, sizeof(con->se_tv_last)); bcopy(&ss, &con->se_in.ss, sizeof(con->se_in.ss)); con->se_out.port = rlay->rl_conf.dstport; switch (ss.ss_family) { case AF_INET: con->se_in.port = ((struct sockaddr_in *)&ss)->sin_port; break; case AF_INET6: con->se_in.port = ((struct sockaddr_in6 *)&ss)->sin6_port; break; } relay_sessions++; SPLAY_INSERT(session_tree, &rlay->rl_sessions, con); /* Increment the per-relay session counter */ rlay->rl_stats[proc_id].last++; /* Pre-allocate output buffer */ con->se_out.output = evbuffer_new(); if (con->se_out.output == NULL) { relay_close(con, "failed to allocate output buffer"); return; } /* Pre-allocate log buffer */ con->se_log = evbuffer_new(); if (con->se_log == NULL) { relay_close(con, "failed to allocate log buffer"); return; } if (rlay->rl_conf.flags & F_NATLOOK) { if ((cnl = (struct ctl_natlook *) calloc(1, sizeof(struct ctl_natlook))) == NULL) { relay_close(con, "failed to allocate natlookup"); return; } } /* Save the received data */ if (evbuffer_add(con->se_out.output, buf, len) == -1) { relay_close(con, "failed to store buffer"); if (cnl != NULL) free(cnl); return; } if (rlay->rl_conf.flags & F_NATLOOK && cnl != NULL) { con->se_cnl = cnl; bzero(cnl, sizeof(*cnl)); cnl->in = -1; cnl->id = con->se_id; cnl->proc = proc_id; cnl->proto = IPPROTO_UDP; bcopy(&con->se_in.ss, &cnl->src, sizeof(cnl->src)); bcopy(&rlay->rl_conf.ss, &cnl->dst, sizeof(cnl->dst)); proc_compose_imsg(env->sc_ps, PROC_PFE, -1, IMSG_NATLOOK, -1, cnl, sizeof(*cnl)); /* Schedule timeout */ evtimer_set(&con->se_ev, relay_natlook, con); bcopy(&rlay->rl_conf.timeout, &tv, sizeof(tv)); evtimer_add(&con->se_ev, &tv); return; } relay_session(con); }
/* * Setup everything required to start tracing */ static int blk_trace_setup(request_queue_t *q, struct block_device *bdev, char __user *arg) { struct blk_user_trace_setup buts; struct blk_trace *old_bt, *bt = NULL; struct dentry *dir = NULL; char b[BDEVNAME_SIZE]; int ret, i; if (copy_from_user(&buts, arg, sizeof(buts))) return -EFAULT; if (!buts.buf_size || !buts.buf_nr) return -EINVAL; strcpy(buts.name, bdevname(bdev, b)); /* * some device names have larger paths - convert the slashes * to underscores for this to work as expected */ for (i = 0; i < strlen(buts.name); i++) if (buts.name[i] == '/') buts.name[i] = '_'; if (copy_to_user(arg, &buts, sizeof(buts))) return -EFAULT; ret = -ENOMEM; bt = kzalloc(sizeof(*bt), GFP_KERNEL); if (!bt) goto err; bt->sequence = alloc_percpu(unsigned long); if (!bt->sequence) goto err; ret = -ENOENT; dir = blk_create_tree(buts.name); if (!dir) goto err; bt->dir = dir; bt->dev = bdev->bd_dev; atomic_set(&bt->dropped, 0); ret = -EIO; bt->dropped_file = debugfs_create_file("dropped", 0444, dir, bt, &blk_dropped_fops); if (!bt->dropped_file) goto err; bt->rchan = relay_open("trace", dir, buts.buf_size, buts.buf_nr, &blk_relay_callbacks); if (!bt->rchan) goto err; bt->rchan->private_data = bt; bt->act_mask = buts.act_mask; if (!bt->act_mask) bt->act_mask = (u16) -1; bt->start_lba = buts.start_lba; bt->end_lba = buts.end_lba; if (!bt->end_lba) bt->end_lba = -1ULL; bt->pid = buts.pid; bt->trace_state = Blktrace_setup; ret = -EBUSY; old_bt = xchg(&q->blk_trace, bt); if (old_bt) { (void) xchg(&q->blk_trace, old_bt); goto err; } return 0; err: if (dir) blk_remove_tree(dir); if (bt) { if (bt->dropped_file) debugfs_remove(bt->dropped_file); if (bt->sequence) free_percpu(bt->sequence); if (bt->rchan) relay_close(bt->rchan); kfree(bt); } return ret; }
void kp_transport_exit(ktap_State *ks) { if (G(ks)->ktap_chan) relay_close(G(ks)->ktap_chan); }
/* * Setup everything required to start tracing */ int do_blk_trace_setup(struct request_queue *q, char *name, dev_t dev, struct blk_user_trace_setup *buts) { struct blk_trace *old_bt, *bt = NULL; struct dentry *dir = NULL; int ret, i; if (!buts->buf_size || !buts->buf_nr) return -EINVAL; strncpy(buts->name, name, BLKTRACE_BDEV_SIZE); buts->name[BLKTRACE_BDEV_SIZE - 1] = '\0'; /* * some device names have larger paths - convert the slashes * to underscores for this to work as expected */ for (i = 0; i < strlen(buts->name); i++) if (buts->name[i] == '/') buts->name[i] = '_'; ret = -ENOMEM; bt = kzalloc(sizeof(*bt), GFP_KERNEL); if (!bt) goto err; bt->sequence = alloc_percpu(unsigned long); if (!bt->sequence) goto err; bt->msg_data = __alloc_percpu(BLK_TN_MAX_MSG); if (!bt->msg_data) goto err; ret = -ENOENT; if (!blk_tree_root) { blk_tree_root = debugfs_create_dir("block", NULL); if (!blk_tree_root) return -ENOMEM; } dir = debugfs_create_dir(buts->name, blk_tree_root); if (!dir) goto err; bt->dir = dir; bt->dev = dev; atomic_set(&bt->dropped, 0); ret = -EIO; bt->dropped_file = debugfs_create_file("dropped", 0444, dir, bt, &blk_dropped_fops); if (!bt->dropped_file) goto err; bt->msg_file = debugfs_create_file("msg", 0222, dir, bt, &blk_msg_fops); if (!bt->msg_file) goto err; bt->rchan = relay_open("trace", dir, buts->buf_size, buts->buf_nr, &blk_relay_callbacks, bt); if (!bt->rchan) goto err; bt->act_mask = buts->act_mask; if (!bt->act_mask) bt->act_mask = (u16) -1; bt->start_lba = buts->start_lba; bt->end_lba = buts->end_lba; if (!bt->end_lba) bt->end_lba = -1ULL; bt->pid = buts->pid; bt->trace_state = Blktrace_setup; mutex_lock(&blk_probe_mutex); if (atomic_add_return(1, &blk_probes_ref) == 1) { ret = blk_register_tracepoints(); if (ret) goto probe_err; } mutex_unlock(&blk_probe_mutex); ret = -EBUSY; old_bt = xchg(&q->blk_trace, bt); if (old_bt) { (void) xchg(&q->blk_trace, old_bt); goto err; } return 0; probe_err: atomic_dec(&blk_probes_ref); mutex_unlock(&blk_probe_mutex); err: if (bt) { if (bt->msg_file) debugfs_remove(bt->msg_file); if (bt->dropped_file) debugfs_remove(bt->dropped_file); free_percpu(bt->sequence); free_percpu(bt->msg_data); if (bt->rchan) relay_close(bt->rchan); kfree(bt); } return ret; }
static void __exit my_exit(void) { relay_close(mychan); printk(KERN_INFO "Relay Channel %s unloaded.\n", fname); }