backends/cryptodev.c

   1 /*
   2  * QEMU Crypto Device Implementation
   3  *
   4  * Copyright (c) 2016 HUAWEI TECHNOLOGIES CO., LTD.
   5  *
   6  * Authors:
   7  *    Gonglei <arei.gonglei@huawei.com>
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  21  *
  22  */
  23
  24 #include "qemu/osdep.h"
  25 #include "sysemu/cryptodev.h"
  26 #include "hw/boards.h"
  27 #include "qapi/error.h"
  28 #include "qapi/visitor.h"
  29 #include "qemu/config-file.h"
  30 #include "qom/object_interfaces.h"
  31 #include "hw/virtio/virtio-crypto.h"
  32
  33
  34 static QTAILQ_HEAD(, CryptoDevBackendClient) crypto_clients;
  35
  36
  37 CryptoDevBackendClient *
  38 cryptodev_backend_new_client(const char *model,
  39                                     const char *name)
  40 {
  41     CryptoDevBackendClient *cc;
  42
  43     cc = g_malloc0(sizeof(CryptoDevBackendClient));
  44     cc->model = g_strdup(model);
  45     if (name) {
  46         cc->name = g_strdup(name);
  47     }
  48
  49     QTAILQ_INSERT_TAIL(&crypto_clients, cc, next);
  50
  51     return cc;
  52 }
  53
  54 void cryptodev_backend_free_client(
  55                   CryptoDevBackendClient *cc)
  56 {
  57     QTAILQ_REMOVE(&crypto_clients, cc, next);
  58     g_free(cc->name);
  59     g_free(cc->model);
  60     g_free(cc->info_str);
  61     g_free(cc);
  62 }
  63
  64 void cryptodev_backend_cleanup(
  65              CryptoDevBackend *backend,
  66              Error **errp)
  67 {
  68     CryptoDevBackendClass *bc =
  69                   CRYPTODEV_BACKEND_GET_CLASS(backend);
  70
  71     if (bc->cleanup) {
  72         bc->cleanup(backend, errp);
  73     }
  74 }
  75
  76 int64_t cryptodev_backend_sym_create_session(
  77            CryptoDevBackend *backend,
  78            CryptoDevBackendSymSessionInfo *sess_info,
  79            uint32_t queue_index, Error **errp)
  80 {
  81     CryptoDevBackendClass *bc =
  82                       CRYPTODEV_BACKEND_GET_CLASS(backend);
  83
  84     if (bc->create_session) {
  85         return bc->create_session(backend, sess_info, queue_index, errp);
  86     }
  87
  88     return -1;
  89 }
  90
  91 int cryptodev_backend_sym_close_session(
  92            CryptoDevBackend *backend,
  93            uint64_t session_id,
  94            uint32_t queue_index, Error **errp)
  95 {
  96     CryptoDevBackendClass *bc =
  97                       CRYPTODEV_BACKEND_GET_CLASS(backend);
  98
  99     if (bc->close_session) {
 100         return bc->close_session(backend, session_id, queue_index, errp);
 101     }
 102
 103     return -1;
 104 }
 105
 106 static int cryptodev_backend_sym_operation(
 107                  CryptoDevBackend *backend,
 108                  CryptoDevBackendSymOpInfo *op_info,
 109                  uint32_t queue_index, Error **errp)
 110 {
 111     CryptoDevBackendClass *bc =
 112                       CRYPTODEV_BACKEND_GET_CLASS(backend);
 113
 114     if (bc->do_sym_op) {
 115         return bc->do_sym_op(backend, op_info, queue_index, errp);
 116     }
 117
 118     return -VIRTIO_CRYPTO_ERR;
 119 }
 120
 121 int cryptodev_backend_crypto_operation(
 122                  CryptoDevBackend *backend,
 123                  void *opaque,
 124                  uint32_t queue_index, Error **errp)
 125 {
 126     VirtIOCryptoReq *req = opaque;
 127
 128     if (req->flags == CRYPTODEV_BACKEND_ALG_SYM) {
 129         CryptoDevBackendSymOpInfo *op_info;
 130         op_info = req->u.sym_op_info;
 131
 132         return cryptodev_backend_sym_operation(backend,
 133                          op_info, queue_index, errp);
 134     } else {
 135         error_setg(errp, "Unsupported cryptodev alg type: %" PRIu32 "",
 136                    req->flags);
 137        return -VIRTIO_CRYPTO_NOTSUPP;
 138     }
 139
 140     return -VIRTIO_CRYPTO_ERR;
 141 }
 142
 143 static void
 144 cryptodev_backend_get_queues(Object *obj, Visitor *v, const char *name,
 145                              void *opaque, Error **errp)
 146 {
 147     CryptoDevBackend *backend = CRYPTODEV_BACKEND(obj);
 148     uint32_t value = backend->conf.peers.queues;
 149
 150     visit_type_uint32(v, name, &value, errp);
 151 }
 152
 153 static void
 154 cryptodev_backend_set_queues(Object *obj, Visitor *v, const char *name,
 155                              void *opaque, Error **errp)
 156 {
 157     CryptoDevBackend *backend = CRYPTODEV_BACKEND(obj);
 158     Error *local_err = NULL;
 159     uint32_t value;
 160
 161     visit_type_uint32(v, name, &value, &local_err);
 162     if (local_err) {
 163         goto out;
 164     }
 165     if (!value) {
 166         error_setg(&local_err, "Property '%s.%s' doesn't take value '%"
 167                    PRIu32 "'", object_get_typename(obj), name, value);
 168         goto out;
 169     }
 170     backend->conf.peers.queues = value;
 171 out:
 172     error_propagate(errp, local_err);
 173 }
 174
 175 static void
 176 cryptodev_backend_complete(UserCreatable *uc, Error **errp)
 177 {
 178     CryptoDevBackend *backend = CRYPTODEV_BACKEND(uc);
 179     CryptoDevBackendClass *bc = CRYPTODEV_BACKEND_GET_CLASS(uc);
 180     Error *local_err = NULL;
 181
 182     if (bc->init) {
 183         bc->init(backend, &local_err);
 184         if (local_err) {
 185             goto out;
 186         }
 187     }
 188
 189     return;
 190
 191 out:
 192     error_propagate(errp, local_err);
 193 }
 194
 195 void cryptodev_backend_set_used(CryptoDevBackend *backend, bool used)
 196 {
 197     backend->is_used = used;
 198 }
 199
 200 bool cryptodev_backend_is_used(CryptoDevBackend *backend)
 201 {
 202     return backend->is_used;
 203 }
 204
 205 void cryptodev_backend_set_ready(CryptoDevBackend *backend, bool ready)
 206 {
 207     backend->ready = ready;
 208 }
 209
 210 bool cryptodev_backend_is_ready(CryptoDevBackend *backend)
 211 {
 212     return backend->ready;
 213 }
 214
 215 static bool
 216 cryptodev_backend_can_be_deleted(UserCreatable *uc)
 217 {
 218     return !cryptodev_backend_is_used(CRYPTODEV_BACKEND(uc));
 219 }
 220
 221 static void cryptodev_backend_instance_init(Object *obj)
 222 {
 223     object_property_add(obj, "queues", "uint32",
 224                           cryptodev_backend_get_queues,
 225                           cryptodev_backend_set_queues,
 226                           NULL, NULL, NULL);
 227     /* Initialize devices' queues property to 1 */
 228     object_property_set_int(obj, 1, "queues", NULL);
 229 }
 230
 231 static void cryptodev_backend_finalize(Object *obj)
 232 {
 233     CryptoDevBackend *backend = CRYPTODEV_BACKEND(obj);
 234
 235     cryptodev_backend_cleanup(backend, NULL);
 236 }
 237
 238 static void
 239 cryptodev_backend_class_init(ObjectClass *oc, void *data)
 240 {
 241     UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);
 242
 243     ucc->complete = cryptodev_backend_complete;
 244     ucc->can_be_deleted = cryptodev_backend_can_be_deleted;
 245
 246     QTAILQ_INIT(&crypto_clients);
 247 }
 248
 249 static const TypeInfo cryptodev_backend_info = {
 250     .name = TYPE_CRYPTODEV_BACKEND,
 251     .parent = TYPE_OBJECT,
 252     .instance_size = sizeof(CryptoDevBackend),
 253     .instance_init = cryptodev_backend_instance_init,
 254     .instance_finalize = cryptodev_backend_finalize,
 255     .class_size = sizeof(CryptoDevBackendClass),
 256     .class_init = cryptodev_backend_class_init,
 257     .interfaces = (InterfaceInfo[]) {
 258         { TYPE_USER_CREATABLE },
 259         { }
 260     }
 261 };
 262
 263 static void
 264 cryptodev_backend_register_types(void)
 265 {
 266     type_register_static(&cryptodev_backend_info);
 267 }
 268
 269 type_init(cryptodev_backend_register_types);