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 "qapi/error.h"
  27 #include "qapi/visitor.h"
  28 #include "qemu/config-file.h"
  29 #include "qom/object_interfaces.h"
  30 #include "hw/virtio/virtio-crypto.h"
  31
  32
  33 static QTAILQ_HEAD(, CryptoDevBackendClient) crypto_clients;
  34
  35
  36 CryptoDevBackendClient *
  37 cryptodev_backend_new_client(const char *model,
  38                                     const char *name)
  39 {
  40     CryptoDevBackendClient *cc;
  41
  42     cc = g_malloc0(sizeof(CryptoDevBackendClient));
  43     cc->model = g_strdup(model);
  44     if (name) {
  45         cc->name = g_strdup(name);
  46     }
  47
  48     QTAILQ_INSERT_TAIL(&crypto_clients, cc, next);
  49
  50     return cc;
  51 }
  52
  53 void cryptodev_backend_free_client(
  54                   CryptoDevBackendClient *cc)
  55 {
  56     QTAILQ_REMOVE(&crypto_clients, cc, next);
  57     g_free(cc->name);
  58     g_free(cc->model);
  59     g_free(cc->info_str);
  60     g_free(cc);
  61 }
  62
  63 void cryptodev_backend_cleanup(
  64              CryptoDevBackend *backend,
  65              Error **errp)
  66 {
  67     CryptoDevBackendClass *bc =
  68                   CRYPTODEV_BACKEND_GET_CLASS(backend);
  69
  70     if (bc->cleanup) {
  71         bc->cleanup(backend, errp);
  72     }
  73 }
  74
  75 int64_t cryptodev_backend_sym_create_session(
  76            CryptoDevBackend *backend,
  77            CryptoDevBackendSymSessionInfo *sess_info,
  78            uint32_t queue_index, Error **errp)
  79 {
  80     CryptoDevBackendClass *bc =
  81                       CRYPTODEV_BACKEND_GET_CLASS(backend);
  82
  83     if (bc->create_session) {
  84         return bc->create_session(backend, sess_info, queue_index, errp);
  85     }
  86
  87     return -1;
  88 }
  89
  90 int cryptodev_backend_sym_close_session(
  91            CryptoDevBackend *backend,
  92            uint64_t session_id,
  93            uint32_t queue_index, Error **errp)
  94 {
  95     CryptoDevBackendClass *bc =
  96                       CRYPTODEV_BACKEND_GET_CLASS(backend);
  97
  98     if (bc->close_session) {
  99         return bc->close_session(backend, session_id, queue_index, errp);
 100     }
 101
 102     return -1;
 103 }
 104
 105 static int cryptodev_backend_sym_operation(
 106                  CryptoDevBackend *backend,
 107                  CryptoDevBackendSymOpInfo *op_info,
 108                  uint32_t queue_index, Error **errp)
 109 {
 110     CryptoDevBackendClass *bc =
 111                       CRYPTODEV_BACKEND_GET_CLASS(backend);
 112
 113     if (bc->do_sym_op) {
 114         return bc->do_sym_op(backend, op_info, queue_index, errp);
 115     }
 116
 117     return -VIRTIO_CRYPTO_ERR;
 118 }
 119
 120 int cryptodev_backend_crypto_operation(
 121                  CryptoDevBackend *backend,
 122                  void *opaque,
 123                  uint32_t queue_index, Error **errp)
 124 {
 125     VirtIOCryptoReq *req = opaque;
 126
 127     if (req->flags == CRYPTODEV_BACKEND_ALG_SYM) {
 128         CryptoDevBackendSymOpInfo *op_info;
 129         op_info = req->u.sym_op_info;
 130
 131         return cryptodev_backend_sym_operation(backend,
 132                          op_info, queue_index, errp);
 133     } else {
 134         error_setg(errp, "Unsupported cryptodev alg type: %" PRIu32 "",
 135                    req->flags);
 136        return -VIRTIO_CRYPTO_NOTSUPP;
 137     }
 138
 139     return -VIRTIO_CRYPTO_ERR;
 140 }
 141
 142 static void
 143 cryptodev_backend_get_queues(Object *obj, Visitor *v, const char *name,
 144                              void *opaque, Error **errp)
 145 {
 146     CryptoDevBackend *backend = CRYPTODEV_BACKEND(obj);
 147     uint32_t value = backend->conf.peers.queues;
 148
 149     visit_type_uint32(v, name, &value, errp);
 150 }
 151
 152 static void
 153 cryptodev_backend_set_queues(Object *obj, Visitor *v, const char *name,
 154                              void *opaque, Error **errp)
 155 {
 156     CryptoDevBackend *backend = CRYPTODEV_BACKEND(obj);
 157     Error *local_err = NULL;
 158     uint32_t value;
 159
 160     visit_type_uint32(v, name, &value, &local_err);
 161     if (local_err) {
 162         goto out;
 163     }
 164     if (!value) {
 165         error_setg(&local_err, "Property '%s.%s' doesn't take value '%"
 166                    PRIu32 "'", object_get_typename(obj), name, value);
 167         goto out;
 168     }
 169     backend->conf.peers.queues = value;
 170 out:
 171     error_propagate(errp, local_err);
 172 }
 173
 174 static void
 175 cryptodev_backend_complete(UserCreatable *uc, Error **errp)
 176 {
 177     CryptoDevBackend *backend = CRYPTODEV_BACKEND(uc);
 178     CryptoDevBackendClass *bc = CRYPTODEV_BACKEND_GET_CLASS(uc);
 179     Error *local_err = NULL;
 180
 181     if (bc->init) {
 182         bc->init(backend, &local_err);
 183         if (local_err) {
 184             goto out;
 185         }
 186     }
 187
 188     return;
 189
 190 out:
 191     error_propagate(errp, local_err);
 192 }
 193
 194 void cryptodev_backend_set_used(CryptoDevBackend *backend, bool used)
 195 {
 196     backend->is_used = used;
 197 }
 198
 199 bool cryptodev_backend_is_used(CryptoDevBackend *backend)
 200 {
 201     return backend->is_used;
 202 }
 203
 204 void cryptodev_backend_set_ready(CryptoDevBackend *backend, bool ready)
 205 {
 206     backend->ready = ready;
 207 }
 208
 209 bool cryptodev_backend_is_ready(CryptoDevBackend *backend)
 210 {
 211     return backend->ready;
 212 }
 213
 214 static bool
 215 cryptodev_backend_can_be_deleted(UserCreatable *uc)
 216 {
 217     return !cryptodev_backend_is_used(CRYPTODEV_BACKEND(uc));
 218 }
 219
 220 static void cryptodev_backend_instance_init(Object *obj)
 221 {
 222     object_property_add(obj, "queues", "uint32",
 223                           cryptodev_backend_get_queues,
 224                           cryptodev_backend_set_queues,
 225                           NULL, NULL, NULL);
 226     /* Initialize devices' queues property to 1 */
 227     object_property_set_int(obj, 1, "queues", NULL);
 228 }
 229
 230 static void cryptodev_backend_finalize(Object *obj)
 231 {
 232     CryptoDevBackend *backend = CRYPTODEV_BACKEND(obj);
 233
 234     cryptodev_backend_cleanup(backend, NULL);
 235 }
 236
 237 static void
 238 cryptodev_backend_class_init(ObjectClass *oc, void *data)
 239 {
 240     UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);
 241
 242     ucc->complete = cryptodev_backend_complete;
 243     ucc->can_be_deleted = cryptodev_backend_can_be_deleted;
 244
 245     QTAILQ_INIT(&crypto_clients);
 246 }
 247
 248 static const TypeInfo cryptodev_backend_info = {
 249     .name = TYPE_CRYPTODEV_BACKEND,
 250     .parent = TYPE_OBJECT,
 251     .instance_size = sizeof(CryptoDevBackend),
 252     .instance_init = cryptodev_backend_instance_init,
 253     .instance_finalize = cryptodev_backend_finalize,
 254     .class_size = sizeof(CryptoDevBackendClass),
 255     .class_init = cryptodev_backend_class_init,
 256     .interfaces = (InterfaceInfo[]) {
 257         { TYPE_USER_CREATABLE },
 258         { }
 259     }
 260 };
 261
 262 static void
 263 cryptodev_backend_register_types(void)
 264 {
 265     type_register_static(&cryptodev_backend_info);
 266 }
 267
 268 type_init(cryptodev_backend_register_types);