int kreq_init(void)
{
int err, size = TGT_RING_SIZE;
char *buf;
err = tgt_miscdev_init(CHRDEV_PATH, &chrfd);
if (err)
return err;
if (size < pagesize)
size = pagesize;
buf = mmap(NULL, size * 2, PROT_READ | PROT_WRITE, MAP_SHARED, chrfd, 0);
if (buf == MAP_FAILED) {
eprintf("fail to mmap, %m\n");
close(chrfd);
return -EINVAL;
}
tgt_ring_pages = size >> pageshift;
tgt_event_per_page = pagesize / sizeof(struct tgt_event);
tgt_max_events = tgt_event_per_page * tgt_ring_pages;
kuring.idx = ukring.idx = 0;
kuring.buf = buf;
ukring.buf = buf + size;
err = tgt_event_add(chrfd, EPOLLIN, kern_event_handler, NULL);
if (err)
close(chrfd);
return err;
}
int spt_sg_open(struct tgt_device *dev, char *path, int *fd, uint64_t *size)
{
int err;
int nr_queue_cmd;
*size = 0;
*fd = open(path, O_RDWR | O_NONBLOCK);
if (*fd < 0)
return *fd;
/* workaround */
nr_queue_cmd = 128;
err = ioctl(*fd, SG_SET_COMMAND_Q, &nr_queue_cmd);
if (err) {
eprintf("can't set the queue depth %d, %m\n", nr_queue_cmd);
goto close_fd;
}
err = tgt_event_add(*fd, EPOLLIN, sgv3_handler, dev);
if (err) {
free(dev);
goto close_fd;
}
return 0;
close_fd:
close(*fd);
return err;
}
static void mgmt_event_handler(int accept_fd, int events, void *data)
{
int fd, err;
struct mgmt_task *mtask;
fd = ipc_accept(accept_fd);
if (fd < 0) {
eprintf("failed to accept a socket\n");
return;
}
err = ipc_perm(fd);
if (err < 0) {
eprintf("permission error\n");
goto out;
}
err = set_non_blocking(fd);
if (err) {
eprintf("failed to set a socket non-blocking\n");
goto out;
}
mtask = zalloc(sizeof(*mtask));
if (!mtask) {
eprintf("can't allocate mtask\n");
goto out;
}
mtask->buf = zalloc(BUFSIZE);
if (!mtask->buf) {
eprintf("can't allocate mtask buffer\n");
free(mtask);
goto out;
}
mtask->bsize = BUFSIZE;
mtask->mtask_state = MTASK_STATE_HDR_RECV;
err = tgt_event_add(fd, EPOLLIN, mtask_handler, mtask);
if (err) {
eprintf("failed to add a socket to epoll %d\n", fd);
free(mtask->buf);
free(mtask);
goto out;
}
return;
out:
if (fd > 0)
close(fd);
return;
}
static void mgmt_event_handler(int accept_fd, int events, void *data)
{
int fd, err;
struct mgmt_task *mtask;
fd = ipc_accept(accept_fd);
if (fd < 0) {
eprintf("failed to accept a socket\n");
return;
}
err = ipc_perm(fd);
if (err < 0) {
eprintf("permission error\n");
goto out;
}
err = set_non_blocking(fd);
if (err) {
eprintf("failed to set a socket non-blocking\n");
goto out;
}
mtask = mtask_alloc();
if (!mtask)
goto out;
err = tgt_event_add(fd, EPOLLIN, mtask_recv_send_handler, mtask);
if (err) {
eprintf("failed to add a socket to epoll %d\n", fd);
mtask_free(mtask);
goto out;
}
return;
out:
if (fd > 0)
close(fd);
return;
}
int ipc_init(void)
{
extern short control_port;
int fd, err;
struct sockaddr_un addr;
fd = socket(AF_LOCAL, SOCK_STREAM, 0);
if (fd < 0) {
eprintf("can't open a socket, %m\n");
return -1;
}
sprintf(mgmt_path, "%s.%d", TGT_IPC_NAMESPACE, control_port);
unlink(mgmt_path);
memset(&addr, 0, sizeof(addr));
addr.sun_family = AF_LOCAL;
strncpy(addr.sun_path, mgmt_path, sizeof(addr.sun_path));
err = bind(fd, (struct sockaddr *) &addr, sizeof(addr));
if (err) {
eprintf("can't bind a socket, %m\n");
goto out;
}
err = listen(fd, 32);
if (err) {
eprintf("can't listen a socket, %m\n");
goto out;
}
err = tgt_event_add(fd, EPOLLIN, mgmt_event_handler, NULL);
if (err)
goto out;
ipc_fd = fd;
return 0;
out:
close(fd);
return -1;
}
static int bs_paio_init(struct scsi_lu *lu)
{
int ret;
struct bs_paio_info *info =
(struct bs_paio_info *) ((char *)lu + sizeof(*lu));
ret=pipe(info->efd);
if(ret){
eprintf("fail to create pipe, %m\n");
goto err_exit;
}
ret=fcntl(info->efd[0], F_SETFL,
fcntl(info->efd[0], F_GETFL, 0)|O_NONBLOCK);
if(ret){
eprintf("fail to confiture pipe, %m\n");
goto close_pipe;
}
ret=fcntl(info->efd[1], F_SETFL,
fcntl(info->efd[1], F_GETFL, 0)|O_NONBLOCK);
if(ret){
eprintf("fail to confiture pipe, %m\n");
goto close_pipe;
}
ret = tgt_event_add(info->efd[0], EPOLLIN, bs_paio_endio, info);
if (ret)
goto close_pipe;
return 0;
close_pipe:
close(info->efd[0]);
close(info->efd[1]);
err_exit:
return -1;
}
int ipc_init(void)
{
extern short control_port;
int fd = 0, err;
struct sockaddr_un addr;
struct stat st = {0};
char *path;
if ((path = getenv("TGT_IPC_SOCKET")) == NULL) {
path = TGT_IPC_NAMESPACE;
if (stat(TGT_IPC_DIR, &st) == -1)
mkdir(TGT_IPC_DIR, 0755);
}
sprintf(mgmt_lock_path, "%s.%d.lock", path, control_port);
ipc_lock_fd = open(mgmt_lock_path, O_WRONLY | O_CREAT,
S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
if (ipc_lock_fd < 0) {
eprintf("failed to open lock file for management IPC\n");
return -1;
}
if (lockf(ipc_lock_fd, F_TLOCK, 1) < 0) {
if (errno == EACCES || errno == EAGAIN)
eprintf("another tgtd is using %s\n", mgmt_lock_path);
else
eprintf("unable to get lock of management IPC: %s"\
" (errno: %m)\n", mgmt_lock_path);
goto close_lock_fd;
}
fd = socket(AF_LOCAL, SOCK_STREAM, 0);
if (fd < 0) {
eprintf("can't open a socket, %m\n");
goto close_lock_fd;
}
snprintf(mgmt_path, sizeof(mgmt_path) - 1, "%s.%d", path, control_port);
if (strlen(mgmt_path) > (sizeof(addr.sun_path) - 1)) {
eprintf("managment path too long: %s\n", mgmt_path);
goto close_ipc_fd;
}
unlink(mgmt_path);
memset(&addr, 0, sizeof(addr));
addr.sun_family = AF_LOCAL;
/* no need for strncpy because we already checked length */
strcpy(addr.sun_path, mgmt_path);
err = bind(fd, (struct sockaddr *) &addr, sizeof(addr));
if (err) {
eprintf("can't bind a socket, %m\n");
goto close_ipc_fd;
}
err = listen(fd, 32);
if (err) {
eprintf("can't listen a socket, %m\n");
goto close_ipc_fd;
}
err = tgt_event_add(fd, EPOLLIN, mgmt_event_handler, NULL);
if (err)
goto close_ipc_fd;
ipc_fd = fd;
return 0;
close_ipc_fd:
close(fd);
close_lock_fd:
close(ipc_lock_fd);
return -1;
}
