void *kr_audioport_process_thread (void *arg) { kr_audioport_t *kr_audioport = (kr_audioport_t *)arg; int ret; char buf[1]; krad_system_set_thread_name ("krc_audioport"); while (kr_audioport->active == 1) { // wait for socket to have a byte ret = read (kr_audioport->sd, buf, 1); if (ret != 1) { printke ("krad mixer client: unexpected read return value %d in kr_audioport_process_thread", ret); } //kr_audioport->callback (kr_audioport->kr_shm->buffer, kr_audioport->pointer); kr_audioport->callback (1600, kr_audioport->pointer); // write a byte to socket ret = write (kr_audioport->sd, buf, 1); if (ret != 1) { printke ("krad mixer client: unexpected write return value %d in kr_audioport_process_thread", ret); } } return NULL; }
static void *krad_mixer_ticker_thread (void *arg) { krad_mixer_t *krad_mixer = (krad_mixer_t *)arg; krad_system_set_thread_name ("kr_mixer"); pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, NULL); krad_mixer->krad_ticker = krad_ticker_create (krad_mixer->sample_rate, krad_mixer->ticker_period); pthread_cleanup_push (krad_mixer_ticker_thread_cleanup, krad_mixer); pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, NULL); krad_ticker_start_at (krad_mixer->krad_ticker, krad_mixer->start_time); while (krad_mixer->ticker_running == 1) { pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, NULL); krad_mixer_process (krad_mixer->ticker_period, krad_mixer); pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, NULL); krad_ticker_wait (krad_mixer->krad_ticker); } pthread_cleanup_pop (1); return NULL; }
void *krad_transmitter_listening_thread (void *arg) { krad_transmitter_t *krad_transmitter = (krad_transmitter_t *)arg; krad_system_set_thread_name ("kr_tx_listen"); krad_transmission_receiver_t *krad_transmission_receiver; int e; int ret; int eret; int cret; int addr_size; int client_fd; struct sockaddr_in remote_address; char hbuf[NI_MAXHOST]; char sbuf[NI_MAXSERV]; printk ("Krad Transmitter: Listening thread starting"); addr_size = 0; e = 0; ret = 0; eret = 0; cret = 0; krad_transmission_receiver = NULL; memset (&remote_address, 0, sizeof(remote_address)); addr_size = sizeof (remote_address); while (krad_transmitter->stop_listening == 0) { ret = epoll_wait (krad_transmitter->incoming_connections_efd, krad_transmitter->incoming_connection_events, KRAD_TRANSMITTER_MAXEVENTS, 50); if (ret < 0) { if ((ret < 0) && (errno == EINTR)) { continue; } printke ("Krad Transmitter: Failed on epoll wait %s", strerror(errno)); krad_transmitter->stop_listening = 1; break; } if (ret > 0) { for (e = 0; e < ret; e++) { if ((krad_transmitter->incoming_connection_events[e].events & EPOLLERR) || (krad_transmitter->incoming_connection_events[e].events & EPOLLHUP)) { if (krad_transmitter->incoming_connections_sd == krad_transmitter->incoming_connection_events[e].data.fd) { failfast ("Krad Transmitter: error on listen socket"); } else { if (krad_transmitter->incoming_connection_events[e].events & EPOLLHUP) { printke ("Krad Transmitter: incoming transmitter connection hangup"); } if (krad_transmitter->incoming_connection_events[e].events & EPOLLERR) { printke ("Krad Transmitter: incoming transmitter connection error"); } krad_transmitter_receiver_destroy (krad_transmitter->incoming_connection_events[e].data.ptr); continue; } } if (krad_transmitter->incoming_connections_sd == krad_transmitter->incoming_connection_events[e].data.fd) { while (1) { client_fd = accept (krad_transmitter->incoming_connections_sd, (struct sockaddr *)&remote_address, (socklen_t *)&addr_size); if (client_fd == -1) { if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) { // We have processed all incoming connections. break; } else { failfast ("Krad Transmitter: error on listen socket accept"); } } if (getnameinfo ((struct sockaddr *)&remote_address, addr_size, hbuf, sizeof hbuf, sbuf, sizeof sbuf, NI_NUMERICHOST | NI_NUMERICSERV) == 0) { printk ("Krad Transmitter: Accepted transmitter connection on descriptor %d (host=%s, port=%s)", client_fd, hbuf, sbuf); } else { printke ("Krad Transmitter: Accepted transmitter connection on descriptor %d ... but could not getnameinfo()?", client_fd, hbuf, sbuf); } krad_system_set_socket_nonblocking (client_fd); krad_transmission_receiver = krad_transmitter_receiver_create (krad_transmitter, client_fd); if (krad_transmission_receiver == NULL) { failfast ("Krad Transmitter: ran out of connections!"); } eret = epoll_ctl (krad_transmitter->incoming_connections_efd, EPOLL_CTL_ADD, client_fd, &krad_transmission_receiver->event); if (eret != 0) { failfast ("Krad Transmitter: incoming transmitter connection epoll error eret is %d errno is %i", eret, errno); } } continue; } if (krad_transmitter->incoming_connection_events[e].events & EPOLLIN) { while (1) { krad_transmission_receiver = (krad_transmission_receiver_t *)krad_transmitter->incoming_connection_events[e].data.ptr; cret = read (krad_transmission_receiver->fd, krad_transmission_receiver->buffer + krad_transmission_receiver->position, sizeof (krad_transmission_receiver->buffer) - krad_transmission_receiver->position); if (cret == -1) { if (errno != EAGAIN) { printke ("Krad Transmitter: error reading from a new incoming connection socket"); krad_transmitter_receiver_destroy (krad_transmitter->incoming_connection_events[e].data.ptr); } break; } if (cret == 0) { printk ("Krad Transmitter: Client EOF Closed connection"); krad_transmitter_receiver_destroy (krad_transmitter->incoming_connection_events[e].data.ptr); break; } if (cret > 0) { krad_transmission_receiver->position += cret; krad_transmitter_handle_incoming_connection (krad_transmitter, krad_transmission_receiver); break; } } } } } if (ret == 0) { //printk ("Krad Transmitter: Listening thread... nothing happened"); } } close (krad_transmitter->incoming_connections_efd); close (krad_transmitter->incoming_connections_sd); free (krad_transmitter->incoming_connection_events); krad_transmitter->port = 0; krad_transmitter->listening = 0; printk ("Krad Transmitter: Listening thread exiting"); return NULL; }
static void *krad_transmitter_transmission_thread (void *arg) { krad_transmission_t *krad_transmission = (krad_transmission_t *)arg; krad_system_set_thread_name ("kr_tx_txmtr"); int r; int e; int ret; int wait_time; uint64_t last_position; uint32_t new_bytes_avail; uint32_t space_avail; uint32_t drop_count; krad_transmission_receiver_t *krad_transmission_receiver; r = 0; e = 0; ret = 0; wait_time = 2; last_position = 0; new_bytes_avail = 0; space_avail = 0; drop_count = 0; krad_transmission_receiver = NULL; printk ("Krad Transmitter: transmission thread starting for %s", krad_transmission->sysname); while (krad_transmission->active == 1) { if (krad_transmission->new_data == 1) { if (krad_transmission->new_sync_point == 1) { krad_transmission->sync_point = krad_transmission->position; krad_transmission->new_sync_point = 0; } space_avail = krad_ringbuffer_write_space (krad_transmission->transmission_ringbuffer); new_bytes_avail = krad_ringbuffer_read_space (krad_transmission->ringbuffer); if (space_avail < new_bytes_avail) { drop_count = new_bytes_avail - space_avail; krad_ringbuffer_read_advance (krad_transmission->transmission_ringbuffer, drop_count); } krad_ringbuffer_read (krad_transmission->ringbuffer, (char *)krad_transmission->transmission_buffer, new_bytes_avail); krad_ringbuffer_write (krad_transmission->transmission_ringbuffer, (char *)krad_transmission->transmission_buffer, new_bytes_avail); krad_transmission->position += new_bytes_avail; if (krad_transmission->position > DEFAULT_RING_SIZE) { krad_transmission->horizon = krad_transmission->position - DEFAULT_RING_SIZE; } krad_ringbuffer_get_read_vector (krad_transmission->transmission_ringbuffer, &krad_transmission->tx_vec[0]); krad_transmission->new_data = 0; } ret = epoll_wait (krad_transmission->connections_efd, krad_transmission->transmission_events, KRAD_TRANSMITTER_MAXEVENTS, wait_time); if (ret < 0) { if ((ret < 0) && (errno == EINTR)) { continue; } printke ("Krad Transmitter: Failed on epoll wait %s", strerror(errno)); krad_transmission->active = 2; break; } if (ret > 0) { for (e = 0; e < ret; e++) { krad_transmission_receiver = (krad_transmission_receiver_t *)krad_transmission->transmission_events[e].data.ptr; if (krad_transmission_receiver->noob == 1) { krad_transmission_receiver->noob = 0; krad_transmission->receivers++; } if ((krad_transmission->transmission_events[e].events & EPOLLERR) || (krad_transmission->transmission_events[e].events & EPOLLHUP) || (krad_transmission->transmission_events[e].events & EPOLLHUP)) { if (krad_transmission->transmission_events[e].events & EPOLLHUP) { printke ("Krad Transmitter: transmitter transmission receiver connection hangup"); } if (krad_transmission->transmission_events[e].events & EPOLLERR) { printke ("Krad Transmitter: transmitter transmission receiver connection error"); } if (krad_transmission->transmission_events[e].events & EPOLLHUP) { printk ("Krad Transmitter: client disconnected %d", krad_transmission_receiver->fd); } krad_transmitter_receiver_destroy (krad_transmission_receiver); continue; } if (krad_transmission->transmission_events[e].events & EPOLLOUT) { krad_transmitter_transmission_transmit (krad_transmission, krad_transmission_receiver); } } } if ((last_position != krad_transmission->position) && (krad_transmission->ready_receiver_count > 0)) { last_position = krad_transmission->position; for (r = 0; r < TOTAL_RECEIVERS; r++) { if ((krad_transmission->krad_transmitter->krad_transmission_receivers[r].krad_transmission == krad_transmission) && (krad_transmission->krad_transmitter->krad_transmission_receivers[r].active == 1) && (krad_transmission->krad_transmitter->krad_transmission_receivers[r].ready == 1)) { krad_transmission_receiver = &krad_transmission->krad_transmitter->krad_transmission_receivers[r]; krad_transmitter_transmission_transmit (krad_transmission, krad_transmission_receiver); } } } } krad_transmission->active = 3; printk ("Krad Transmitter: transmission thread exiting for %s", krad_transmission->sysname); return NULL; }
void *krad_ipc_server_run_thread (void *arg) { krad_ipc_server_t *krad_ipc_server = (krad_ipc_server_t *)arg; krad_ipc_server_client_t *client; int ret, s; krad_system_set_thread_name ("kr_ipc_server"); krad_ipc_server->shutdown = KRAD_IPC_RUNNING; krad_ipc_server_update_pollfds (krad_ipc_server); while (!krad_ipc_server->shutdown) { ret = poll (krad_ipc_server->sockets, krad_ipc_server->socket_count, KRAD_IPC_SERVER_TIMEOUT_MS); if (ret > 0) { if (krad_ipc_server->shutdown) { break; } s = 0; if (krad_ipc_server->sockets[s].revents & POLLIN) { krad_ipc_server_accept_client (krad_ipc_server, krad_ipc_server->sd); ret--; } s++; if ((krad_ipc_server->tcp_sd != 0) && (krad_ipc_server->sockets[s].revents & POLLIN)) { krad_ipc_server_accept_client (krad_ipc_server, krad_ipc_server->tcp_sd); ret--; } if (krad_ipc_server->tcp_sd != 0) { s++; } for (; ret > 0; s++) { if (krad_ipc_server->sockets[s].revents) { ret--; client = krad_ipc_server->sockets_clients[s]; if (krad_ipc_server->sockets[s].revents & POLLIN) { client->input_buffer_pos += recv(krad_ipc_server->sockets[s].fd, client->input_buffer + client->input_buffer_pos, (sizeof (client->input_buffer) - client->input_buffer_pos), 0); //printk ("Krad IPC Server: Got %d bytes\n", client->input_buffer_pos); if (client->input_buffer_pos == 0) { //printk ("Krad IPC Server: Client EOF\n"); krad_ipc_disconnect_client (client); continue; } if (client->input_buffer_pos == -1) { printke ("Krad IPC Server: Client Socket Error"); krad_ipc_disconnect_client (client); continue; } // big enough to read element id and data size if ((client->input_buffer_pos > 7) && (client->confirmed == 0)) { krad_ebml_io_buffer_push(&client->krad_ebml->io_adapter, client->input_buffer, client->input_buffer_pos); client->input_buffer_pos = 0; krad_ebml_read_ebml_header (client->krad_ebml, client->krad_ebml->header); krad_ebml_check_ebml_header (client->krad_ebml->header); //krad_ebml_print_ebml_header (client->krad_ebml->header); if (krad_ebml_check_doctype_header (client->krad_ebml->header, KRAD_IPC_CLIENT_DOCTYPE, KRAD_IPC_DOCTYPE_VERSION, KRAD_IPC_DOCTYPE_READ_VERSION)) { //printk ("Matched %s Version: %d Read Version: %d\n", KRAD_IPC_CLIENT_DOCTYPE, KRAD_IPC_DOCTYPE_VERSION, KRAD_IPC_DOCTYPE_READ_VERSION); client->confirmed = 1; } else { printke ("Did Not Match %s Version: %d Read Version: %d\n", KRAD_IPC_CLIENT_DOCTYPE, KRAD_IPC_DOCTYPE_VERSION, KRAD_IPC_DOCTYPE_READ_VERSION); krad_ipc_disconnect_client (client); continue; } client->krad_ebml2 = krad_ebml_open_active_socket (client->sd, KRAD_EBML_IO_READWRITE); krad_ebml_header_advanced (client->krad_ebml2, KRAD_IPC_SERVER_DOCTYPE, KRAD_IPC_DOCTYPE_VERSION, KRAD_IPC_DOCTYPE_READ_VERSION); krad_ebml_write_sync (client->krad_ebml2); } else { if ((client->input_buffer_pos > 3) && (client->confirmed == 1)) { krad_ebml_io_buffer_push(&client->krad_ebml->io_adapter, client->input_buffer, client->input_buffer_pos); client->input_buffer_pos = 0; } while (krad_ebml_io_buffer_read_space (&client->krad_ebml->io_adapter)) { client->krad_ipc_server->current_client = client; /* single thread has a few perks */ if (krad_ipc_aquire_client (client)) { //resp = client->krad_ipc_server->handler (client->output_buffer, &client->command_response_len, client->krad_ipc_server->pointer); client->krad_ipc_server->handler (client->output_buffer, &client->command_response_len, client->krad_ipc_server->pointer); //printk ("Krad IPC Server: CMD Response %d %d bytes\n", resp, client->command_response_len); krad_ebml_write_sync (krad_ipc_server->current_client->krad_ebml2); krad_ipc_release_client (client); } } } } if (krad_ipc_server->sockets[s].revents & POLLOUT) { //printk ("I could write\n"); } if (krad_ipc_server->sockets[s].revents & POLLHUP) { //printk ("Krad IPC Server: POLLHUP\n"); krad_ipc_disconnect_client (client); continue; } if (krad_ipc_server->sockets[s].revents & POLLERR) { printke ("Krad IPC Server: POLLERR\n"); krad_ipc_disconnect_client (client); continue; } if (krad_ipc_server->sockets[s].revents & POLLNVAL) { printke ("Krad IPC Server: POLLNVAL\n"); krad_ipc_disconnect_client (client); continue; } } } } } krad_ipc_server->shutdown = KRAD_IPC_SHUTINGDOWN; return NULL; }
void *krad_system_monitor_cpu_thread (void *arg) { krad_system_cpu_monitor_t *kcm; krad_system_set_thread_name ("kr_system_mon"); printk ("Krad System CPU Monitor On"); kcm = &krad_system.kcm; kcm->fd = open ( "/proc/stat", O_RDONLY ); if (kcm->fd < 1) { kcm->on = 0; return NULL; } while (1) { kcm->ret = lseek (kcm->fd, 0, SEEK_SET); if (kcm->ret != 0) { break; } kcm->ret = read (kcm->fd, kcm->buffer, KRAD_BUFLEN_CPUSTAT); if (kcm->ret != KRAD_BUFLEN_CPUSTAT) { break; } sscanf (kcm->buffer + 3, "%d %d %d %d", &kcm->user, &kcm->nice, &kcm->system, &kcm->idle ); kcm->total = kcm->user + kcm->nice + kcm->system + kcm->idle; if (kcm->total != kcm->last_total) { kcm->diff_idle = kcm->idle - kcm->last_idle; kcm->diff_total = kcm->total - kcm->last_total; kcm->usage = (1000 * (kcm->diff_total - kcm->diff_idle) / kcm->diff_total + 5) / 10; if (kcm->usage < 0) { kcm->usage = 0; } else { if (kcm->usage > 100) { kcm->usage = 100; } } krad_system.system_cpu_usage = kcm->usage; //printk ("user %d nice %d system %d idle %d usage %d\n", // kcm->user, kcm->nice, kcm->system, kcm->idle, kcm->usage); kcm->last_idle = kcm->idle; kcm->last_total = kcm->total; if (kcm->unset_cpu_monitor_callback == 1) { kcm->callback_pointer = NULL; kcm->cpu_monitor_callback = NULL; kcm->unset_cpu_monitor_callback = 0; } if (kcm->cpu_monitor_callback) { kcm->cpu_monitor_callback (kcm->callback_pointer, krad_system.system_cpu_usage); } } if (krad_controller_client_wait (&kcm->control, kcm->interval)) { break; } } close (kcm->fd); kcm->fd = 0; krad_controller_client_close (&kcm->control); krad_system.kcm.on = 0; printk ("Krad System CPU Monitor Off"); return NULL; }