usr/ioctl.c

   1 /*
   2  * iSCSI Ioctl/Unix Interface
   3  *
   4  * Copyright (C) 2004 Dmitry Yusupov, Alex Aizman
   5  * maintained by open-iscsi@googlegroups.com
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published
   9  * by the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15  * General Public License for more details.
  16  *
  17  * See the file COPYING included with this distribution for more details.
  18  */
  19
  20 #include <ctype.h>
  21 #include <errno.h>
  22 #include <fcntl.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <unistd.h>
  27 #include <sys/types.h>
  28 #include <sys/stat.h>
  29
  30 #include "iscsi_if.h"
  31 #include "iscsid.h"
  32 #include "log.h"
  33 #include "iscsi_ipc.h"
  34
  35 #define CTL_DEVICE      "/dev/iscsictl"
  36
  37 static int ctrl_fd;
  38 static void *xmitbuf = NULL;
  39 static int xmitlen = 0;
  40 static void *recvbuf = NULL;
  41 static int recvlen = 0;
  42 static void *ioctl_sendbuf;
  43 static void *ioctl_recvbuf;
  44 static void *pdu_sendbuf;
  45
  46 #define IOCTL_BUF_DEFAULT_MAX \
  47         (ISCSI_DEF_MAX_RECV_SEG_LEN + sizeof(struct iscsi_hdr))
  48
  49 #define PDU_SENDBUF_DEFAULT_MAX \
  50         (ISCSI_DEF_MAX_RECV_SEG_LEN + sizeof(struct iscsi_hdr))
  51
  52 static int
  53 kread(char *data, int count)
  54 {
  55         log_debug(7, "in %s", __FUNCTION__);
  56         return count;
  57 }
  58
  59 static int
  60 kwritev(enum iscsi_uevent_e type, struct iovec *iovp, int count)
  61 {
  62         log_debug(7, "in %s", __FUNCTION__);
  63         return 0;
  64 }
  65
  66 /*
  67  * __kipc_call() should never block
  68  */
  69 static int
  70 __kipc_call(void *iov_base, int iov_len)
  71 {
  72         log_debug(7, "in %s", __FUNCTION__);
  73         return 0;
  74 }
  75
  76 static int
  77 kcreate_session(uint64_t transport_handle, uint32_t initial_cmdsn,
  78                 uint32_t *out_sid, uint32_t *out_hostno)
  79 {
  80         int rc;
  81         struct iscsi_uevent ev;
  82
  83         log_debug(7, "in %s", __FUNCTION__);
  84
  85         memset(&ev, 0, sizeof(struct iscsi_uevent));
  86
  87         ev.type = ISCSI_UEVENT_CREATE_SESSION;
  88         ev.transport_handle = transport_handle;
  89         ev.u.c_session.initial_cmdsn = initial_cmdsn;
  90
  91         if ((rc = __kipc_call(&ev, sizeof(ev))) < 0) {
  92                 return rc;
  93         }
  94         if (!ev.r.c_session_ret.session_handle || ev.r.c_session_ret.sid < 0)
  95                 return -EIO;
  96
  97         *out_handle = ev.r.c_session_ret.session_handle;
  98         *out_sid = ev.r.c_session_ret.sid;
  99
 100         return 0;
 101 }
 102
 103 static int
 104 kdestroy_session(uint64_t transport_handle, uint64_t sessionh, uint32_t sid)
 105 {
 106         int rc;
 107         struct iscsi_uevent ev;
 108
 109         log_debug(7, "in %s", __FUNCTION__);
 110
 111         memset(&ev, 0, sizeof(struct iscsi_uevent));
 112
 113         ev.type = ISCSI_UEVENT_DESTROY_SESSION;
 114         ev.transport_handle = transport_handle;
 115         ev.u.d_session.session_handle = sessionh;
 116         ev.u.d_session.sid = sid;
 117
 118         if ((rc = __kipc_call(&ev, sizeof(ev))) < 0) {
 119                 return rc;
 120         }
 121
 122         return 0;
 123 }
 124
 125 static int
 126 kcreate_conn(uint64_t transport_handle, uint64_t sessionh, uint32_t sid,
 127             uint32_t cid, uint64_t *out_handle)
 128 {
 129         int rc;
 130         struct iscsi_uevent ev;
 131
 132         log_debug(7, "in %s", __FUNCTION__);
 133
 134         memset(&ev, 0, sizeof(struct iscsi_uevent));
 135
 136         ev.type = ISCSI_UEVENT_CREATE_CONN;
 137         ev.transport_handle = transport_handle;
 138         ev.u.c_conn.session_handle = sessionh;
 139         ev.u.c_conn.cid = cid;
 140         ev.u.c_conn.sid = sid;
 141
 142         if ((rc = __kipc_call(&ev, sizeof(ev))) < 0) {
 143                 return rc;
 144         }
 145         if (!ev.r.handle)
 146                 return -EIO;
 147
 148         *out_handle = ev.r.handle;
 149         return 0;
 150 }
 151
 152 static int
 153 kdestroy_conn(uint64_t transport_handle, uint64_t connh, int cid)
 154 {
 155         int rc;
 156         struct iscsi_uevent ev;
 157
 158         log_debug(7, "in %s", __FUNCTION__);
 159
 160         memset(&ev, 0, sizeof(struct iscsi_uevent));
 161
 162         ev.type = ISCSI_UEVENT_DESTROY_CONN;
 163         ev.transport_handle = transport_handle;
 164         ev.u.d_conn.conn_handle = connh;
 165         ev.u.d_conn.cid = cid;
 166
 167         if ((rc = __kipc_call(&ev, sizeof(ev))) < 0) {
 168                 return rc;
 169         }
 170
 171         return 0;
 172 }
 173
 174 static int
 175 kbind_conn(uint64_t transport_handle, uint64_t sessionh, uint64_t connh,
 176            uint32_t transport_fd, int is_leading, int *retcode)
 177 {
 178         int rc;
 179         struct iscsi_uevent ev;
 180
 181         log_debug(7, "in %s", __FUNCTION__);
 182
 183         memset(&ev, 0, sizeof(struct iscsi_uevent));
 184
 185         ev.type = ISCSI_UEVENT_BIND_CONN;
 186         ev.transport_handle = transport_handle;
 187         ev.u.b_conn.session_handle = sessionh;
 188         ev.u.b_conn.conn_handle = connh;
 189         ev.u.b_conn.transport_fd = transport_fd;
 190         ev.u.b_conn.is_leading = is_leading;
 191
 192         if ((rc = __kipc_call(&ev, sizeof(ev))) < 0) {
 193                 return rc;
 194         }
 195
 196         *retcode = ev.r.retcode;
 197
 198         return 0;
 199 }
 200
 201 static void
 202 ksend_pdu_begin(uint64_t transport_handle, uint64_t connh,
 203                         int hdr_size, int data_size)
 204 {
 205         struct iscsi_uevent *ev;
 206
 207         log_debug(7, "in %s", __FUNCTION__);
 208
 209         if (xmitbuf) {
 210                 log_error("send's begin state machine bug?");
 211                 exit(-EIO);
 212         }
 213
 214         xmitbuf = pdu_sendbuf;
 215         memset(xmitbuf, 0, sizeof(*ev) + hdr_size + data_size);
 216         xmitlen = sizeof(*ev);
 217         ev = xmitbuf;
 218         memset(ev, 0, sizeof(*ev));
 219         ev->type = ISCSI_UEVENT_SEND_PDU;
 220         ev->transport_handle = transport_handle;
 221         ev->u.send_pdu.conn_handle = connh;
 222         ev->u.send_pdu.hdr_size = hdr_size;
 223         ev->u.send_pdu.data_size = data_size;
 224
 225         log_debug(3, "send PDU began for hdr %d bytes and data %d bytes",
 226                 hdr_size, data_size);
 227 }
 228
 229 static int
 230 ksend_pdu_end(uint64_t transport_handle, uint64_t connh, int *retcode)
 231 {
 232         int rc;
 233         struct iscsi_uevent *ev;
 234         struct iovec iov;
 235
 236         log_debug(7, "in %s", __FUNCTION__);
 237
 238         if (!xmitbuf) {
 239                 log_error("send's end state machine bug?");
 240                 exit(-EIO);
 241         }
 242         ev = xmitbuf;
 243         if (ev->u.send_pdu.conn_handle != connh) {
 244                 log_error("send's end state machine corruption?");
 245                 exit(-EIO);
 246         }
 247
 248         iov.iov_base = xmitbuf;
 249         iov.iov_len = xmitlen;
 250
 251         if ((rc = __kipc_call(xmitbuf, xmitlen)) < 0)
 252                 goto err;
 253         if (ev->r.retcode) {
 254                 *retcode = ev->r.retcode;
 255                 goto err;
 256         }
 257         if (ev->type != ISCSI_UEVENT_SEND_PDU) {
 258                 log_error("bad event: bug on send_pdu_end?");
 259                 exit(-EIO);
 260         }
 261
 262         log_debug(3, "send PDU finished for conn (handle %p)", iscsi_ptr(connh));
 263
 264         xmitbuf = NULL;
 265         return 0;
 266
 267 err:
 268         xmitbuf = NULL;
 269         xmitlen = 0;
 270         return rc;
 271 }
 272
 273 static int
 274 kset_param(uint64_t transport_handle, uint64_t connh,
 275                enum iscsi_param param, uint32_t value, int *retcode)
 276 {
 277         int rc;
 278         struct iscsi_uevent ev;
 279
 280         log_debug(7, "in %s", __FUNCTION__);
 281
 282         memset(&ev, 0, sizeof(struct iscsi_uevent));
 283
 284         ev.type = ISCSI_UEVENT_SET_PARAM;
 285         ev.transport_handle = transport_handle;
 286         ev.u.set_param.conn_handle = connh;
 287         ev.u.set_param.param = param;
 288         ev.u.set_param.value = value;
 289
 290         if ((rc = __kipc_call(&ev, sizeof(ev))) < 0) {
 291                 return rc;
 292         }
 293
 294         *retcode = ev.r.retcode;
 295
 296         return 0;
 297 }
 298
 299 static int
 300 kstop_conn(uint64_t transport_handle, uint64_t connh, int flag)
 301 {
 302         int rc;
 303         struct iscsi_uevent ev;
 304
 305         log_debug(7, "in %s", __FUNCTION__);
 306
 307         memset(&ev, 0, sizeof(struct iscsi_uevent));
 308
 309         ev.type = ISCSI_UEVENT_STOP_CONN;
 310         ev.transport_handle = transport_handle;
 311         ev.u.stop_conn.conn_handle = connh;
 312         ev.u.stop_conn.flag = flag;
 313
 314         if ((rc = __kipc_call(&ev, sizeof(ev))) < 0) {
 315                 return rc;
 316         }
 317
 318         return 0;
 319 }
 320
 321 static int
 322 kstart_conn(uint64_t transport_handle, uint64_t connh, int *retcode)
 323 {
 324         int rc;
 325         struct iscsi_uevent ev;
 326
 327         log_debug(7, "in %s", __FUNCTION__);
 328
 329         memset(&ev, 0, sizeof(struct iscsi_uevent));
 330
 331         ev.type = ISCSI_UEVENT_START_CONN;
 332         ev.transport_handle = transport_handle;
 333         ev.u.start_conn.conn_handle = connh;
 334
 335         if ((rc = __kipc_call(&ev, sizeof(ev))) < 0) {
 336                 return rc;
 337         }
 338
 339         *retcode = ev.r.retcode;
 340         return 0;
 341 }
 342
 343 static int
 344 krecv_pdu_begin(uint64_t transport_handle, uint64_t connh,
 345                 uintptr_t recv_handle, uintptr_t *pdu_handle, int *pdu_size)
 346 {
 347         log_debug(7, "in %s", __FUNCTION__);
 348
 349         if (recvbuf) {
 350                 log_error("recv's begin state machine bug?");
 351                 return -EIO;
 352         }
 353         recvbuf = (void*)recv_handle + sizeof(struct iscsi_uevent);
 354         recvlen = 0;
 355         *pdu_handle = recv_handle;
 356
 357         log_debug(3, "recv PDU began, pdu handle 0x%p",
 358                   (void*)*pdu_handle);
 359
 360         return 0;
 361 }
 362
 363 static int
 364 krecv_pdu_end(uint64_t transport_handle, uintptr_t conn_handle,
 365               uintptr_t pdu_handle)
 366 {
 367         log_debug(7, "in %s", __FUNCTION__);
 368
 369         if (!recvbuf) {
 370                 log_error("recv's end state machine bug?");
 371                 return -EIO;
 372         }
 373
 374         log_debug(3, "recv PDU finished for pdu handle 0x%p",
 375                   (void*)pdu_handle);
 376
 377         recvpool_put((void*)conn_handle, (void*)pdu_handle);
 378         recvbuf = NULL;
 379         return 0;
 380 }
 381
 382 static int
 383 ktrans_list(void)
 384 {
 385         struct iscsi_uevent ev;
 386         int rc;
 387
 388         log_debug(7, "in %s", __FUNCTION__);
 389
 390         memset(ev, 0, sizeof(struct iscsi_uevent));
 391         /*
 392          * need to define this for bsd
 393          */
 394         ev->type = ISCSI_UEVENT_TRANS_LIST;
 395
 396         if ((rc = __kipc_call(&ev, sizeof(ev))) < 0) {
 397                 return rc;
 398         }
 399
 400         for (i = 0; i < ISCSI_TRANSPORT_MAX; i++) {
 401                 if (ev.r.t_list.elements[i].trans_handle) {
 402                         provider[i].handle =
 403                                 ev.r.t_list.elements[i].trans_handle;
 404                         strncpy(provider[i].name, ev.r.t_list.elements[i].name,
 405                                 ISCSI_TRANSPORT_NAME_MAXLEN);
 406                         provider[i].caps = ev.r.t_list.elements[i].caps;
 407                 }
 408         }
 409         return 0;
 410 }
 411
 412 static int
 413 ctldev_handle(void)
 414 {
 415         log_debug(7, "in %s", __FUNCTION__);
 416         return 0;
 417 }
 418
 419 static int
 420 ctldev_open(void)
 421 {
 422         log_debug(7, "in %s", __FUNCTION__);
 423
 424         ioctl_sendbuf = calloc(1, IOCTL_BUF_DEFAULT_MAX);
 425         if (!ioctl_sendbuf) {
 426                 log_error("can not allocate ioctl_sendbuf");
 427                 return -1;
 428         }
 429
 430         ioctl_recvbuf = calloc(1, IOCTL_BUF_DEFAULT_MAX);
 431         if (!ioctl_recvbuf) {
 432                 free(ioctl_sendbuf);
 433                 log_error("can not allocate ioctl_recvbuf");
 434                 return -1;
 435         }
 436
 437         pdu_sendbuf = calloc(1, PDU_SENDBUF_DEFAULT_MAX);
 438         if (!pdu_sendbuf) {
 439                 free(ioctl_recvbuf);
 440                 free(ioctl_sendbuf);
 441                 log_error("can not allocate ioctl_sendbuf");
 442                 return -1;
 443         }
 444
 445         return ctrl_fd;
 446 }
 447
 448 static void
 449 ctldev_close(void)
 450 {
 451         free(pdu_sendbuf);
 452         free(ioctl_recvbuf);
 453         free(ioctl_sendbuf);
 454         //close(ctrl_fd);
 455 }
 456
 457 struct iscsi_ipc ioctl_ipc = {
 458         .name                   = "Open-iSCSI Kernel IPC/IOCTL v.1",
 459         .ctldev_bufmax          = IOCTL_BUF_DEFAULT_MAX,
 460         .ctldev_open            = ctldev_open,
 461         .ctldev_close           = ctldev_close,
 462         .ctldev_handle          = ctldev_handle,
 463         .trans_list             = ktrans_list,
 464         .create_session         = kcreate_session,
 465         .destroy_session        = kdestroy_session,
 466         .create_conn            = kcreate_conn,
 467         .destroy_conn           = kdestroy_conn,
 468         .bind_conn              = kbind_conn,
 469         .set_param              = kset_param,
 470         .get_param              = NULL,
 471         .start_conn             = kstart_conn,
 472         .stop_conn              = kstop_conn,
 473         .writev                 = kwritev,
 474         .send_pdu_begin         = ksend_pdu_begin,
 475         .send_pdu_end           = ksend_pdu_end,
 476         .read                   = kread,
 477         .recv_pdu_begin         = krecv_pdu_begin,
 478         .recv_pdu_end           = krecv_pdu_end,
 479 };
 480 struct iscsi_ipc *ipc = &ioctl_ipc;