int
process_manpage(int srv_fd, int dstdir_fd, const char *path)
{
int in_fd, out_fd;
int irc;
if ((in_fd = open(path, O_RDONLY)) == -1) {
warn("open(%s)", path);
return 0;
}
if ((out_fd = openat(dstdir_fd, path,
O_WRONLY | O_NOFOLLOW | O_CREAT | O_TRUNC,
S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) == -1) {
warn("openat(%s)", path);
close(in_fd);
return 0;
}
irc = sock_fd_write(srv_fd, in_fd, out_fd, STDERR_FILENO);
close(in_fd);
close(out_fd);
if (irc < 0) {
warn("sendmsg");
return -1;
}
return 0;
}
void slave_send_to_worker(struct ev_loop *loop, struct ev_io *w, int revents)
{
// get slave socket
int slave_socket = w->fd;
// think we should stop watcher
ev_io_stop(loop, w);
// find a free worker and send slave socket to it
for(auto it = workers.begin(); it != workers.end(); it++)
{
if ((*it).second)
{
// found free worker, it is busy from now
(*it).second = false;
char tmp[1];
sock_fd_write((*it).first, tmp, sizeof(tmp), slave_socket);
return;
}
}
// add to queue for later processing
safe_push_back(slave_socket);
}
void parent(int sock) {
ssize_t size;
int fd,i;
struct perf_event_attr pe;
memset(&pe,0,sizeof(struct perf_event_attr));
pe.type=PERF_TYPE_HARDWARE;
pe.size=sizeof(struct perf_event_attr);
pe.config=PERF_COUNT_HW_INSTRUCTIONS;
pe.disabled=1;
pe.exclude_kernel=1;
pe.exclude_hv=1;
arch_adjust_domain(&pe,quiet);
fd=perf_event_open(&pe,0,-1,-1,0);
if (fd<0) {
fprintf(stderr,"Error opening leader %llx %s\n",pe.config,strerror(errno));
test_fail(test_string);
}
size = sock_fd_write(sock, "1", 1, fd);
if (!quiet) printf ("wrote fd %d (size %d)\n", fd, (int)size);
sleep(1);
for(i=0;i<20;i++) instructions_million();
}
void
parent(int sock)
{
ssize_t size;
int i;
int fd;
fd = 1;
size = sock_fd_write(sock, (void *) "1", 1, 1);
printf ("wrote %d\n", (int) size);
}
static void handle_comm(void)
{
char c = 0;
int tmp_fd = TEMP_FAILURE_RETRY(accept(comm_fd, NULL, 0));
if (tmp_fd < 0)
fatal("accept (%s)", strerror(errno));
sock_fd_write(tmp_fd, &c, 1, server_fd);
close(tmp_fd);
}
void do_work(struct ev_loop *loop, struct ev_io *w, int revents)
{
// get appropriate slave socket and read from it
int slave_socket;
char tmp[1];
sock_fd_read(w->fd, tmp, sizeof(tmp), &slave_socket);
if (slave_socket == -1)
{
std::cout << "do_work: slave_socket == -1" << std::endl;
exit(4);
}
// do it
process_slave_socket(slave_socket);
// write back to paired socket to update worker status
sock_fd_write(w->fd, tmp, sizeof(tmp), slave_socket);
}
int main(int argc, char **argv)
{
char path[64] = "/home/box/final";
char ip[16] = "127.0.0.1";
int port = 12345;
int opt;
int server_socket, conn_socket;
struct epoll_event events[MAX_EVENTS];
struct epoll_event event;
struct sockaddr_in sock_addr;
int epollfd, nfds, i, robin = 0;
int pid;
int on = 1;
int sv[2][2];
pid = fork();
if(pid != 0) return 0;
pid = fork();
if(pid != 0) return 0;
while ((opt = getopt(argc, argv, "h:p:d:")) != -1) {
switch (opt) {
case 'h':
//ip.assign( optarg) ;
sprintf(ip,"%s", optarg);
break;
case 'p':
port = atoi(optarg);
break;
case 'd':
//path.assign(optarg);
sprintf(path, "%s", optarg);
break;
default: /* '?' */
//std::cout << "Usage: " << argv[0] << " [-h host_ip] [-p host_port] [-d directory]" << std::endl;
printf("Ussage: %s [-h host_ip] [-p host_port][-d directory]",argv[0]);
return -1;
}
}
for(i = 0; i < 1 ; i++){
if (socketpair(AF_LOCAL, SOCK_STREAM, 0, sv[i]) < 0) {
// printf("socketpair error");
exit(1);
}
switch ((pid = fork())) {
case 0:
close(sv[i][0]);
worker(sv[i][1], path);
return 0;
case -1:
//printf("fork error");
exit(1);
default:
close(sv[i][1]);
/// parent(sv[i][0]);
break;
}
}
server_socket = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
setsockopt ( server_socket, SOL_SOCKET, SO_REUSEADDR, (const char *) &on, sizeof(on));
sock_addr.sin_family = AF_INET;
sock_addr.sin_port = htons(port);
sock_addr.sin_addr.s_addr = inet_addr(ip);
//inet_pton(AF_INET, ip, &sock_addr);
bind(server_socket, (struct sockaddr *) (&sock_addr), sizeof(sock_addr));
set_nonblock(server_socket);
listen(server_socket, SOMAXCONN);
epollfd = epoll_create1(0);
if (epollfd == -1) {
goto error;
}
event.data.fd = server_socket;
event.events = EPOLLIN;
if(epoll_ctl (epollfd, EPOLL_CTL_ADD, server_socket, &event) == -1) {
goto error;
}
while (1) {
nfds = epoll_wait(epollfd, events, MAX_EVENTS, -1);
if(nfds == -1){
goto error;
}
for (i = 0; i < nfds; ++ i) {
if (events[i].data.fd == server_socket) {
conn_socket = accept(server_socket, 0, 0);
if (conn_socket == -1) {
goto error;
}
set_nonblock(conn_socket);
event.data.fd = conn_socket;
event.events = EPOLLIN | EPOLLET;
if(epoll_ctl(epollfd, EPOLL_CTL_ADD, conn_socket, & event) == -1){
goto error;
}
}
else {
epoll_ctl(epollfd, EPOLL_CTL_DEL, events[i].data.fd, NULL);
if(robin ) robin = 0;
else robin = 1;
sock_fd_write(sv[robin][0], "1", 1, events[i].data.fd);
}
}
}
error:
shutdown(server_socket, SHUT_RDWR);
close(server_socket);
return 0;
}
void parent_writes(int sock)
{
ssize_t size = sock_fd_write(sock, "TEST", 4, 1);
printf ("wrote size: %d\n", (int)size);
}
static int
tst_ioctl(const char * fnp, int sg_fd, const char * fn2p, int sg_fd2,
int sock, const char * cp)
{
uint32_t cflags;
struct sg_extended_info sei;
struct sg_extended_info * seip;
seip = &sei;
memset(seip, 0, sizeof(*seip));
seip->valid_wr_mask |= SG_SEIM_RESERVED_SIZE;
seip->reserved_sz = reserve_buff_sz;
seip->sgat_elem_sz = 64 * 1024;;
seip->valid_rd_mask |= SG_SEIM_RESERVED_SIZE;
seip->valid_rd_mask |= SG_SEIM_RQ_REM_THRESH;
seip->valid_rd_mask |= SG_SEIM_TOT_FD_THRESH;
seip->valid_wr_mask |= SG_SEIM_CTL_FLAGS;
seip->valid_rd_mask |= SG_SEIM_CTL_FLAGS; /* this or previous optional */
seip->valid_rd_mask |= SG_SEIM_MINOR_INDEX;
seip->valid_wr_mask |= SG_SEIM_SGAT_ELEM_SZ;
seip->ctl_flags_wr_mask |= SG_CTL_FLAGM_TIME_IN_NS;
seip->ctl_flags_rd_mask |= SG_CTL_FLAGM_TIME_IN_NS;
seip->ctl_flags_rd_mask |= SG_CTL_FLAGM_OTHER_OPENS;
seip->ctl_flags_rd_mask |= SG_CTL_FLAGM_ORPHANS;
seip->ctl_flags_rd_mask |= SG_CTL_FLAGM_Q_TAIL;
seip->ctl_flags_rd_mask |= SG_CTL_FLAGM_IS_SHARE;
seip->ctl_flags_rd_mask |= SG_CTL_FLAGM_IS_MASTER;
seip->ctl_flags_rd_mask |= SG_CTL_FLAGM_UNSHARE;
seip->ctl_flags_rd_mask |= SG_CTL_FLAGM_MASTER_FINI;
seip->ctl_flags_rd_mask |= SG_CTL_FLAGM_MASTER_ERR;
seip->ctl_flags_rd_mask |= SG_CTL_FLAGM_CHECK_FOR_MORE;
seip->ctl_flags |= SG_CTL_FLAGM_TIME_IN_NS;
if (ioctl(sg_fd, SG_SET_GET_EXTENDED, seip) < 0) {
pr2serr("ioctl(SG_SET_GET_EXTENDED) failed, errno=%d %s\n", errno,
strerror(errno));
return 1;
}
#if 1
printf("%sSG_SET_GET_EXTENDED ioctl ok\n", cp);
if (SG_SEIM_RESERVED_SIZE & seip->valid_rd_mask)
printf(" %sreserved size: %u\n", cp, seip->reserved_sz);
if (SG_SEIM_MINOR_INDEX & seip->valid_rd_mask)
printf(" %sminor index: %u\n", cp, seip->minor_index);
if (SG_SEIM_RQ_REM_THRESH & seip->valid_rd_mask)
printf(" %srq_rem_sgat_thresh: %u\n", cp, seip->rq_rem_sgat_thresh);
if (SG_SEIM_TOT_FD_THRESH & seip->valid_rd_mask)
printf(" %stot_fd_thresh: %u\n", cp, seip->tot_fd_thresh);
if ((SG_SEIM_CTL_FLAGS & seip->valid_rd_mask) ||
(SG_SEIM_CTL_FLAGS & seip->valid_wr_mask)) {
cflags = seip->ctl_flags;
if (SG_CTL_FLAGM_TIME_IN_NS & seip->ctl_flags_rd_mask)
printf(" %sTIME_IN_NS: %s\n", cp,
(SG_CTL_FLAGM_TIME_IN_NS & cflags) ? "true" : "false");
if (SG_CTL_FLAGM_OTHER_OPENS & seip->ctl_flags_rd_mask)
printf(" %sOTHER_OPENS: %s\n", cp,
(SG_CTL_FLAGM_OTHER_OPENS & cflags) ? "true" : "false");
if (SG_CTL_FLAGM_ORPHANS & seip->ctl_flags_rd_mask)
printf(" %sORPHANS: %s\n", cp,
(SG_CTL_FLAGM_ORPHANS & cflags) ? "true" : "false");
if (SG_CTL_FLAGM_Q_TAIL & seip->ctl_flags_rd_mask)
printf(" %sQ_TAIL: %s\n", cp,
(SG_CTL_FLAGM_Q_TAIL & cflags) ? "true" : "false");
if (SG_CTL_FLAGM_IS_SHARE & seip->ctl_flags_rd_mask)
printf(" %sIS_SHARE: %s\n", cp,
(SG_CTL_FLAGM_IS_SHARE & cflags) ? "true" : "false");
if (SG_CTL_FLAGM_IS_MASTER & seip->ctl_flags_rd_mask)
printf(" %sIS_MASTER: %s\n", cp,
(SG_CTL_FLAGM_IS_MASTER & cflags) ? "true" : "false");
if (SG_CTL_FLAGM_UNSHARE & seip->ctl_flags_rd_mask)
printf(" %sUNSHARE: %s\n", cp,
(SG_CTL_FLAGM_UNSHARE & cflags) ? "true" : "false");
if (SG_CTL_FLAGM_MASTER_FINI & seip->ctl_flags_rd_mask)
printf(" %sMASTER_FINI: %s\n", cp,
(SG_CTL_FLAGM_MASTER_FINI & cflags) ? "true" : "false");
if (SG_CTL_FLAGM_MASTER_ERR & seip->ctl_flags_rd_mask)
printf(" %sMASTER_ERR: %s\n", cp,
(SG_CTL_FLAGM_MASTER_ERR & cflags) ? "true" : "false");
if (SG_CTL_FLAGM_CHECK_FOR_MORE & seip->ctl_flags_rd_mask)
printf(" %sCHECK_FOR_MORE: %s\n", cp,
(SG_CTL_FLAGM_CHECK_FOR_MORE & cflags) ? "true" : "false");
}
if (SG_SEIM_MINOR_INDEX & seip->valid_rd_mask)
printf(" %sminor_index: %u\n", cp, seip->minor_index);
printf("\n");
#endif
memset(seip, 0, sizeof(*seip));
seip->valid_wr_mask |= SG_SEIM_READ_VAL;
seip->valid_rd_mask |= SG_SEIM_READ_VAL;
seip->read_value = SG_SEIRV_INT_MASK;
if (ioctl(sg_fd, SG_SET_GET_EXTENDED, seip) < 0) {
pr2serr("ioctl(SG_SET_GET_EXTENDED) failed, errno=%d %s\n", errno,
strerror(errno));
return 1;
}
printf(" %sread_value[SG_SEIRV_INT_MASK]= %u\n", cp, seip->read_value);
memset(seip, 0, sizeof(*seip));
seip->valid_wr_mask |= SG_SEIM_READ_VAL;
seip->valid_rd_mask |= SG_SEIM_READ_VAL;
seip->read_value = SG_SEIRV_BOOL_MASK;
if (ioctl(sg_fd, SG_SET_GET_EXTENDED, seip) < 0) {
pr2serr("ioctl(SG_SET_GET_EXTENDED) failed, errno=%d %s\n", errno,
strerror(errno));
return 1;
}
printf(" %sread_value[SG_SEIRV_BOOL_MASK]= %u\n", cp, seip->read_value);
memset(seip, 0, sizeof(*seip));
seip->valid_wr_mask |= SG_SEIM_READ_VAL;
seip->valid_rd_mask |= SG_SEIM_READ_VAL;
seip->read_value = SG_SEIRV_VERS_NUM;
if (ioctl(sg_fd, SG_SET_GET_EXTENDED, seip) < 0) {
pr2serr("ioctl(SG_SET_GET_EXTENDED) failed, errno=%d %s\n", errno,
strerror(errno));
return 1;
}
printf(" %sread_value[SG_SEIRV_VERS_NUM]= %u\n", cp, seip->read_value);
memset(seip, 0, sizeof(*seip));
seip->valid_wr_mask |= SG_SEIM_READ_VAL;
seip->valid_rd_mask |= SG_SEIM_READ_VAL;
seip->read_value = SG_SEIRV_FL_RQS;
if (ioctl(sg_fd, SG_SET_GET_EXTENDED, seip) < 0) {
pr2serr("ioctl(SG_SET_GET_EXTENDED) failed, errno=%d %s\n", errno,
strerror(errno));
return 1;
}
printf(" %sread_value[SG_SEIRV_FL_RQS]= %u\n", cp, seip->read_value);
memset(seip, 0, sizeof(*seip));
seip->valid_wr_mask |= SG_SEIM_READ_VAL;
seip->valid_rd_mask |= SG_SEIM_READ_VAL;
seip->read_value = SG_SEIRV_DEV_FL_RQS;
if (ioctl(sg_fd, SG_SET_GET_EXTENDED, seip) < 0) {
pr2serr("ioctl(SG_SET_GET_EXTENDED) failed, errno=%d %s\n", errno,
strerror(errno));
return 1;
}
printf(" %sread_value[SG_SEIRV_DEV_FL_RQS]= %u\n", cp, seip->read_value);
memset(seip, 0, sizeof(*seip));
seip->valid_wr_mask |= SG_SEIM_READ_VAL;
seip->valid_rd_mask |= SG_SEIM_READ_VAL;
seip->read_value = SG_SEIRV_TRC_SZ;
if (ioctl(sg_fd, SG_SET_GET_EXTENDED, seip) < 0) {
pr2serr("ioctl(SG_SET_GET_EXTENDED) failed, errno=%d %s\n", errno,
strerror(errno));
return 1;
}
printf(" %sread_value[SG_SEIRV_TRC_SZ]= %u\n", cp, seip->read_value);
memset(seip, 0, sizeof(*seip));
seip->valid_wr_mask |= SG_SEIM_READ_VAL;
seip->valid_rd_mask |= SG_SEIM_READ_VAL;
seip->read_value = SG_SEIRV_TRC_MAX_SZ;
if (ioctl(sg_fd, SG_SET_GET_EXTENDED, seip) < 0) {
pr2serr("ioctl(SG_SET_GET_EXTENDED) failed, errno=%d %s\n", errno,
strerror(errno));
return 1;
}
printf(" %sread_value[SG_SEIRV_TRC_MAX_SZ]= %u\n", cp, seip->read_value);
memset(seip, 0, sizeof(*seip));
seip->valid_wr_mask |= SG_SEIM_SHARE_FD;
seip->valid_rd_mask |= SG_SEIM_SHARE_FD;
#if 1
seip->share_fd = sg_fd2;
#else
seip->share_fd = sg_fd;
#endif
if (do_fork && is_parent)
goto bypass_share;
if (ioctl(sg_fd, SG_SET_GET_EXTENDED, seip) < 0) {
pr2serr("%sioctl(SG_SET_GET_EXTENDED) shared_fd=%d, failed errno=%d "
"%s\n", cp, sg_fd2, errno, strerror(errno));
}
printf(" %sshare successful, read back shared_fd= %d\n", cp,
(int)seip->share_fd);
bypass_share:
// printf("SG_IOSUBMIT value=0x%lx\n", SG_IOSUBMIT);
// printf("SG_IORECEIVE value=0x%lx\n", SG_IORECEIVE);
if (ioctl(sg_fd, SG_GET_TRANSFORM, NULL) < 0)
pr2serr("ioctl(SG_GET_TRANSFORM) fail expected, errno=%d %s\n",
errno, strerror(errno));
else
printf("%sSG_GET_TRANSFORM okay (does nothing)\n", cp);
if (ioctl(sg_fd, SG_SET_TRANSFORM, NULL) < 0)
pr2serr("ioctl(SG_SET_TRANSFORM) fail expected, errno=%d %s\n",
errno, strerror(errno));
else
printf("%sSG_SET_TRANSFORM okay (does nothing)\n", cp);
printf("\n");
/* test sending a sg file descriptor between 2 processes using UNIX
* sockets */
if (do_fork && is_parent && fnp && (sock >= 0)) { /* master/READ side */
int res;
int fd_ma = open(fnp, O_RDWR);
if (fd_ma < 0) {
pr2serr("%s: opening %s failed: %s\n", __func__, fnp,
strerror(errno));
return 1;
}
res = sock_fd_write(sock, "boo", 4, fd_ma);
if (res < 0)
pr2serr("%s: sock_fd_write() failed\n", __func__);
else
printf("%s: sock_fd_write() returned: %d\n", __func__, res);
} else if (do_fork && !is_parent && fn2p && (sock >= 0)) {
int res, fd_ma;
/* int fd_sl = open(fn2p, O_RDWR); not needed */
uint8_t b[32];
fd_ma = -1;
res = sock_fd_read(sock, b, sizeof(b), &fd_ma);
if (res < 0)
pr2serr("%s: sock_fd_read() failed\n", __func__);
else
printf("%s: sock_fd_read() returned: %d, fd_ma=%d\n", __func__,
res, fd_ma);
/* yes it works! */
}
return 0;
}
