mirror of
https://github.com/SCST-project/scst.git
synced 2026-08-19 21:56:31 +00:00
Vladislav Bolkhovitin
293c0ee1a3
- Other iSCSI-SCST user space fixes, improvements and cleanups. git-svn-id: http://svn.code.sf.net/p/scst/svn/trunk@667 d57e44dd-8a1f-0410-8b47-8ef2f437770f
450 lines
9.2 KiB
C
450 lines
9.2 KiB
C
/*
|
|
* Copyright (C) 2004 - 2005 FUJITA Tomonori <tomof@acm.org>
|
|
* Copyright (C) 2007 - 2008 Vladislav Bolkhovitin
|
|
* Copyright (C) 2007 - 2008 CMS Distribution Limited
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*/
|
|
|
|
#include <ctype.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#include <sys/ioctl.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
|
|
#include "iscsid.h"
|
|
|
|
#define CTL_DEVICE "/dev/iscsi-scst-ctl"
|
|
|
|
struct session_file_operations {
|
|
int (*target_op) (int fd, u32 tid, void *arg);
|
|
int (*session_op) (int fd, u32 tid, u64 sid, void *arg);
|
|
int (*connection_op) (int fd, u32 tid, u64 sid, u32 cid, void *arg);
|
|
};
|
|
|
|
static int ctrdev_open(int *max_data_seg_len)
|
|
{
|
|
FILE *f;
|
|
char devname[256];
|
|
char buf[256];
|
|
int devn;
|
|
int ctlfd = -1;
|
|
int err;
|
|
struct iscsi_register_info reg = { 0 };
|
|
|
|
if (!(f = fopen("/proc/devices", "r"))) {
|
|
perror("Cannot open control path to the driver");
|
|
goto out;
|
|
}
|
|
|
|
devn = 0;
|
|
while (!feof(f)) {
|
|
if (!fgets(buf, sizeof (buf), f)) {
|
|
break;
|
|
}
|
|
if (sscanf(buf, "%d %s", &devn, devname) != 2) {
|
|
continue;
|
|
}
|
|
if (!strcmp(devname, "iscsi-scst-ctl")) {
|
|
break;
|
|
}
|
|
devn = 0;
|
|
}
|
|
|
|
fclose(f);
|
|
if (!devn) {
|
|
printf("cannot find iscsictl in /proc/devices - "
|
|
"make sure the module is loaded\n");
|
|
goto out;
|
|
}
|
|
|
|
unlink(CTL_DEVICE);
|
|
if (mknod(CTL_DEVICE, (S_IFCHR | 0600), (devn << 8))) {
|
|
printf("cannot create %s %d\n", CTL_DEVICE, errno);
|
|
goto out;
|
|
}
|
|
|
|
ctlfd = open(CTL_DEVICE, O_RDWR);
|
|
if (ctlfd < 0) {
|
|
printf("cannot open %s %d\n", CTL_DEVICE, errno);
|
|
goto out;
|
|
}
|
|
|
|
reg.version = (uintptr_t)ISCSI_SCST_INTERFACE_VERSION;
|
|
|
|
err = ioctl(ctlfd, REGISTER_USERD, ®);
|
|
if (err < 0) {
|
|
err = -errno;
|
|
log_error("Unable to register: %s. Incompatible version of the "
|
|
"kernel module?\n", strerror(errno));
|
|
goto out_close;
|
|
} else {
|
|
log_debug(0, "MAX_DATA_SEG_LEN %d", err);
|
|
*max_data_seg_len = err;
|
|
}
|
|
|
|
out:
|
|
return ctlfd;
|
|
|
|
out_close:
|
|
close(ctlfd);
|
|
ctlfd = err;
|
|
goto out;
|
|
}
|
|
|
|
static int iscsi_target_create(u32 *tid, char *name)
|
|
{
|
|
int err;
|
|
struct target_info info;
|
|
|
|
memset(&info, 0, sizeof(info));
|
|
|
|
memcpy(info.name, name, sizeof(info.name) - 1);
|
|
info.tid = *tid;
|
|
if ((err = ioctl(ctrl_fd, ADD_TARGET, &info)) < 0) {
|
|
err = -errno;
|
|
log_error("can't create a target %d %u\n", errno, info.tid);
|
|
}
|
|
|
|
*tid = info.tid;
|
|
return err;
|
|
}
|
|
|
|
static int iscsi_target_destroy(u32 tid)
|
|
{
|
|
struct target_info info;
|
|
int res;
|
|
|
|
memset(&info, 0, sizeof(info));
|
|
info.tid = tid;
|
|
|
|
res = ioctl(ctrl_fd, DEL_TARGET, &info);
|
|
if (res < 0)
|
|
res = -errno;
|
|
|
|
return res;
|
|
}
|
|
|
|
static int iscsi_conn_destroy(u32 tid, u64 sid, u32 cid)
|
|
{
|
|
int err;
|
|
struct conn_info info;
|
|
|
|
info.tid = tid;
|
|
info.sid = sid;
|
|
info.cid = cid;
|
|
|
|
if ((err = ioctl(ctrl_fd, DEL_CONN, &info)) < 0)
|
|
err = -errno;
|
|
|
|
return err;
|
|
}
|
|
|
|
static int __conn_close(int fd, u32 tid, u64 sid, u32 cid, void *arg)
|
|
{
|
|
return ki->conn_destroy(tid, sid, cid);
|
|
}
|
|
|
|
static int __target_del(int fd, u32 tid, void *arg)
|
|
{
|
|
return ki->target_destroy(tid);
|
|
}
|
|
|
|
static int proc_session_parse(int fd, struct session_file_operations *ops,
|
|
int op_tid, void *arg)
|
|
{
|
|
FILE *f;
|
|
char buf[8192], *p;
|
|
u32 tid, cid;
|
|
u64 sid;
|
|
int err, skip, done = 0;
|
|
|
|
if ((f = fopen(PROC_SESSION, "r")) == NULL) {
|
|
fprintf(stderr, "Can't open %s\n", PROC_SESSION);
|
|
return errno;
|
|
}
|
|
|
|
skip = 0;
|
|
while (fgets(buf, sizeof(buf), f)) {
|
|
p = buf;
|
|
while (isspace((int) *p))
|
|
p++;
|
|
|
|
if (!strncmp(p, "tid:", 4)) {
|
|
if (sscanf(p, "tid:%u", &tid) != 1)
|
|
break;
|
|
if (op_tid != -1) {
|
|
if (tid == op_tid)
|
|
skip = 0;
|
|
else {
|
|
skip = 1;
|
|
if (done)
|
|
break;
|
|
else
|
|
continue;
|
|
}
|
|
}
|
|
if (ops->target_op)
|
|
if ((err = ops->target_op(fd, tid, arg)) < 0)
|
|
goto out;
|
|
continue;
|
|
}
|
|
if (skip)
|
|
continue;
|
|
if (!strncmp(p, "sid:", 4)) {
|
|
if (sscanf(p, "sid:%" SCNu64, &sid) != 1) {
|
|
log_error("Unknown %s sid syntax: %s\n", PROC_SESSION, p);
|
|
break;
|
|
}
|
|
|
|
if (ops->session_op)
|
|
if ((err = ops->session_op(fd, tid, sid, arg)) < 0)
|
|
goto out;
|
|
} else if (!strncmp(p, "cid:", 4)) {
|
|
if (sscanf(p, "cid:%u", &cid) != 1) {
|
|
log_error("Unknown %s cid syntax: %s\n", PROC_SESSION, p);
|
|
break;
|
|
}
|
|
if (ops->connection_op)
|
|
if ((err = ops->connection_op(fd, tid, sid, cid, arg)) < 0)
|
|
goto out;
|
|
} else
|
|
log_error("Unknown %s string: %s\n", PROC_SESSION, p);
|
|
|
|
done = 1;
|
|
}
|
|
|
|
err = 0;
|
|
out:
|
|
fclose(f);
|
|
|
|
return err;
|
|
}
|
|
|
|
static int session_retry (int fd, u32 tid, u64 sid, void *arg)
|
|
{
|
|
return -EAGAIN;
|
|
}
|
|
|
|
static int conn_retry (int fd, u32 tid, u64 sid, u32 cid, void *arg)
|
|
{
|
|
return -EAGAIN;
|
|
}
|
|
|
|
static int __sess_cleanup(int fd, u32 tid, void *arg)
|
|
{
|
|
wait_4_iscsi_event(100);
|
|
return 0;
|
|
}
|
|
|
|
static struct session_file_operations conn_close_ops = {
|
|
.connection_op = __conn_close,
|
|
};
|
|
|
|
static struct session_file_operations conn_sess_cleanup_ops = {
|
|
.target_op = __sess_cleanup,
|
|
};
|
|
|
|
static struct session_file_operations shutdown_wait_ops = {
|
|
.session_op = session_retry,
|
|
.connection_op = conn_retry,
|
|
};
|
|
|
|
static struct session_file_operations target_del_ops = {
|
|
.target_op = __target_del,
|
|
};
|
|
|
|
int target_destroy(u32 tid)
|
|
{
|
|
int err;
|
|
|
|
conn_blocked = 1;
|
|
|
|
proc_session_parse(ctrl_fd, &conn_close_ops, tid, NULL);
|
|
|
|
while (proc_session_parse(ctrl_fd, &shutdown_wait_ops, tid, NULL) < 0) {
|
|
sleep(1);
|
|
}
|
|
proc_session_parse(ctrl_fd, &conn_sess_cleanup_ops, tid, NULL);
|
|
|
|
err = proc_session_parse(ctrl_fd, &target_del_ops, tid, NULL);
|
|
|
|
conn_blocked = 0;
|
|
|
|
return err;
|
|
}
|
|
|
|
struct session_conn_close_arg {
|
|
u64 sid;
|
|
};
|
|
|
|
static int session_conn_close(int fd, u32 tid, u64 sid, u32 cid, void *opaque)
|
|
{
|
|
struct session_conn_close_arg *arg = (struct session_conn_close_arg *) opaque;
|
|
int err;
|
|
|
|
if (arg->sid == sid)
|
|
err = ki->conn_destroy(tid, sid, cid);
|
|
|
|
return 0;
|
|
}
|
|
|
|
struct session_file_operations session_conns_close_ops = {
|
|
.connection_op = session_conn_close,
|
|
};
|
|
|
|
int session_conns_close(u32 tid, u64 sid)
|
|
{
|
|
int err;
|
|
struct session_conn_close_arg arg = {sid};
|
|
|
|
err = proc_session_parse(ctrl_fd, &session_conns_close_ops, tid, &arg);
|
|
|
|
return err;
|
|
}
|
|
|
|
static int iscsi_param_get(u32 tid, u64 sid, int type, struct iscsi_param *param)
|
|
{
|
|
int err, i;
|
|
struct iscsi_param_info info;
|
|
|
|
memset(&info, 0, sizeof(info));
|
|
info.tid = tid;
|
|
info.sid = sid;
|
|
info.param_type = type;
|
|
|
|
if ((err = ioctl(ctrl_fd, ISCSI_PARAM_GET, &info)) < 0) {
|
|
log_error("Can't get session param for session 0x%" PRIu64
|
|
" (tid %u, err %d): %s\n", sid, tid, err, strerror(errno));
|
|
err = -errno;
|
|
}
|
|
|
|
if (type == key_session)
|
|
for (i = 0; i < session_key_last; i++)
|
|
param[i].val = info.session_param[i];
|
|
else
|
|
for (i = 0; i < target_key_last; i++)
|
|
param[i].val = info.target_param[i];
|
|
|
|
return err;
|
|
}
|
|
|
|
static int iscsi_param_set(u32 tid, u64 sid, int type, u32 partial,
|
|
struct iscsi_param *param)
|
|
{
|
|
int i, err;
|
|
struct iscsi_param_info info;
|
|
|
|
memset(&info, 0, sizeof(info));
|
|
info.tid = tid;
|
|
info.sid = sid;
|
|
info.param_type = type;
|
|
info.partial = partial;
|
|
|
|
if (info.param_type == key_session)
|
|
for (i = 0; i < session_key_last; i++)
|
|
info.session_param[i] = param[i].val;
|
|
else
|
|
for (i = 0; i < target_key_last; i++)
|
|
info.target_param[i] = param[i].val;
|
|
|
|
if ((err = ioctl(ctrl_fd, ISCSI_PARAM_SET, &info)) < 0) {
|
|
fprintf(stderr, "%d %u " "%" PRIu64 " %d %u\n",
|
|
errno, tid, sid, type, partial);
|
|
err = -errno;
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
static int iscsi_session_create(u32 tid, u64 sid, u32 exp_cmd_sn,
|
|
char *name, char *user)
|
|
{
|
|
struct session_info info;
|
|
int res;
|
|
|
|
memset(&info, 0, sizeof(info));
|
|
|
|
info.tid = tid;
|
|
info.sid = sid;
|
|
info.exp_cmd_sn = exp_cmd_sn;
|
|
strncpy(info.initiator_name, name, sizeof(info.initiator_name) - 1);
|
|
strncpy(info.user_name, user, sizeof(info.user_name) - 1);
|
|
|
|
res = ioctl(ctrl_fd, ADD_SESSION, &info);
|
|
if (res < 0)
|
|
res = -errno;
|
|
|
|
return res;
|
|
}
|
|
|
|
static int iscsi_session_destroy(u32 tid, u64 sid)
|
|
{
|
|
struct session_info info;
|
|
int res;
|
|
|
|
memset(&info, 0, sizeof(info));
|
|
|
|
info.tid = tid;
|
|
info.sid = sid;
|
|
|
|
do {
|
|
res = ioctl(ctrl_fd, DEL_SESSION, &info);
|
|
} while (res < 0 && errno == EINTR);
|
|
|
|
if (res < 0)
|
|
res = -errno;
|
|
|
|
return res;
|
|
}
|
|
|
|
static int iscsi_conn_create(u32 tid, u64 sid, u32 cid, u32 stat_sn, u32 exp_stat_sn,
|
|
int fd, u32 hdigest, u32 ddigest)
|
|
{
|
|
struct conn_info info;
|
|
int res;
|
|
|
|
memset(&info, 0, sizeof(info));
|
|
|
|
info.tid = tid;
|
|
info.sid = sid;
|
|
info.cid = cid;
|
|
info.stat_sn = stat_sn;
|
|
info.exp_stat_sn = exp_stat_sn;
|
|
info.fd = fd;
|
|
info.header_digest = hdigest;
|
|
info.data_digest = ddigest;
|
|
|
|
res = ioctl(ctrl_fd, ADD_CONN, &info);
|
|
if (res < 0)
|
|
res = -errno;
|
|
|
|
return res;
|
|
}
|
|
|
|
struct iscsi_kernel_interface ioctl_ki = {
|
|
.ctldev_open = ctrdev_open,
|
|
.param_get = iscsi_param_get,
|
|
.param_set = iscsi_param_set,
|
|
.target_create = iscsi_target_create,
|
|
.target_destroy = iscsi_target_destroy,
|
|
.session_create = iscsi_session_create,
|
|
.session_destroy = iscsi_session_destroy,
|
|
.conn_create = iscsi_conn_create,
|
|
.conn_destroy = iscsi_conn_destroy,
|
|
};
|
|
|
|
struct iscsi_kernel_interface *ki = &ioctl_ki;
|