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.1 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 "sysemu/stats.h" 27 #include "qapi/error.h" 28 #include "qapi/qapi-commands-cryptodev.h" 29 #include "qapi/qapi-types-stats.h" 30 #include "qapi/visitor.h" 31 #include "qemu/config-file.h" 32 #include "qemu/error-report.h" 33 #include "qemu/main-loop.h" 34 #include "qom/object_interfaces.h" 35 #include "hw/virtio/virtio-crypto.h" 36 37 #define SYM_ENCRYPT_OPS_STR "sym-encrypt-ops" 38 #define SYM_DECRYPT_OPS_STR "sym-decrypt-ops" 39 #define SYM_ENCRYPT_BYTES_STR "sym-encrypt-bytes" 40 #define SYM_DECRYPT_BYTES_STR "sym-decrypt-bytes" 41 42 #define ASYM_ENCRYPT_OPS_STR "asym-encrypt-ops" 43 #define ASYM_DECRYPT_OPS_STR "asym-decrypt-ops" 44 #define ASYM_SIGN_OPS_STR "asym-sign-ops" 45 #define ASYM_VERIFY_OPS_STR "asym-verify-ops" 46 #define ASYM_ENCRYPT_BYTES_STR "asym-encrypt-bytes" 47 #define ASYM_DECRYPT_BYTES_STR "asym-decrypt-bytes" 48 #define ASYM_SIGN_BYTES_STR "asym-sign-bytes" 49 #define ASYM_VERIFY_BYTES_STR "asym-verify-bytes" 50 51 typedef struct StatsArgs { 52 union StatsResultsType { 53 StatsResultList **stats; 54 StatsSchemaList **schema; 55 } result; 56 strList *names; 57 Error **errp; 58 } StatsArgs; 59 60 static QTAILQ_HEAD(, CryptoDevBackendClient) crypto_clients; 61 62 static int qmp_query_cryptodev_foreach(Object *obj, void *data) 63 { 64 CryptoDevBackend *backend; 65 QCryptodevInfoList **infolist = data; 66 uint32_t services, i; 67 68 if (!object_dynamic_cast(obj, TYPE_CRYPTODEV_BACKEND)) { 69 return 0; 70 } 71 72 QCryptodevInfo *info = g_new0(QCryptodevInfo, 1); 73 info->id = g_strdup(object_get_canonical_path_component(obj)); 74 75 backend = CRYPTODEV_BACKEND(obj); 76 services = backend->conf.crypto_services; 77 for (i = 0; i < QCRYPTODEV_BACKEND_SERVICE__MAX; i++) { 78 if (services & (1 << i)) { 79 QAPI_LIST_PREPEND(info->service, i); 80 } 81 } 82 83 for (i = 0; i < backend->conf.peers.queues; i++) { 84 CryptoDevBackendClient *cc = backend->conf.peers.ccs[i]; 85 QCryptodevBackendClient *client = g_new0(QCryptodevBackendClient, 1); 86 87 client->queue = cc->queue_index; 88 client->type = cc->type; 89 QAPI_LIST_PREPEND(info->client, client); 90 } 91 92 QAPI_LIST_PREPEND(*infolist, info); 93 94 return 0; 95 } 96 97 QCryptodevInfoList *qmp_query_cryptodev(Error **errp) 98 { 99 QCryptodevInfoList *list = NULL; 100 Object *objs = container_get(object_get_root(), "/objects"); 101 102 object_child_foreach(objs, qmp_query_cryptodev_foreach, &list); 103 104 return list; 105 } 106 107 CryptoDevBackendClient *cryptodev_backend_new_client(void) 108 { 109 CryptoDevBackendClient *cc; 110 111 cc = g_new0(CryptoDevBackendClient, 1); 112 QTAILQ_INSERT_TAIL(&crypto_clients, cc, next); 113 114 return cc; 115 } 116 117 void cryptodev_backend_free_client( 118 CryptoDevBackendClient *cc) 119 { 120 QTAILQ_REMOVE(&crypto_clients, cc, next); 121 g_free(cc->info_str); 122 g_free(cc); 123 } 124 125 void cryptodev_backend_cleanup( 126 CryptoDevBackend *backend, 127 Error **errp) 128 { 129 CryptoDevBackendClass *bc = 130 CRYPTODEV_BACKEND_GET_CLASS(backend); 131 132 if (bc->cleanup) { 133 bc->cleanup(backend, errp); 134 } 135 136 g_free(backend->sym_stat); 137 g_free(backend->asym_stat); 138 } 139 140 int cryptodev_backend_create_session( 141 CryptoDevBackend *backend, 142 CryptoDevBackendSessionInfo *sess_info, 143 uint32_t queue_index, 144 CryptoDevCompletionFunc cb, 145 void *opaque) 146 { 147 CryptoDevBackendClass *bc = 148 CRYPTODEV_BACKEND_GET_CLASS(backend); 149 150 if (bc->create_session) { 151 return bc->create_session(backend, sess_info, queue_index, cb, opaque); 152 } 153 return -VIRTIO_CRYPTO_NOTSUPP; 154 } 155 156 int cryptodev_backend_close_session( 157 CryptoDevBackend *backend, 158 uint64_t session_id, 159 uint32_t queue_index, 160 CryptoDevCompletionFunc cb, 161 void *opaque) 162 { 163 CryptoDevBackendClass *bc = 164 CRYPTODEV_BACKEND_GET_CLASS(backend); 165 166 if (bc->close_session) { 167 return bc->close_session(backend, session_id, queue_index, cb, opaque); 168 } 169 return -VIRTIO_CRYPTO_NOTSUPP; 170 } 171 172 static int cryptodev_backend_operation( 173 CryptoDevBackend *backend, 174 CryptoDevBackendOpInfo *op_info) 175 { 176 CryptoDevBackendClass *bc = 177 CRYPTODEV_BACKEND_GET_CLASS(backend); 178 179 if (bc->do_op) { 180 return bc->do_op(backend, op_info); 181 } 182 return -VIRTIO_CRYPTO_NOTSUPP; 183 } 184 185 static int cryptodev_backend_account(CryptoDevBackend *backend, 186 CryptoDevBackendOpInfo *op_info) 187 { 188 enum QCryptodevBackendAlgType algtype = op_info->algtype; 189 int len; 190 191 if (algtype == QCRYPTODEV_BACKEND_ALG_ASYM) { 192 CryptoDevBackendAsymOpInfo *asym_op_info = op_info->u.asym_op_info; 193 len = asym_op_info->src_len; 194 195 if (unlikely(!backend->asym_stat)) { 196 error_report("cryptodev: Unexpected asym operation"); 197 return -VIRTIO_CRYPTO_NOTSUPP; 198 } 199 switch (op_info->op_code) { 200 case VIRTIO_CRYPTO_AKCIPHER_ENCRYPT: 201 CryptodevAsymStatIncEncrypt(backend, len); 202 break; 203 case VIRTIO_CRYPTO_AKCIPHER_DECRYPT: 204 CryptodevAsymStatIncDecrypt(backend, len); 205 break; 206 case VIRTIO_CRYPTO_AKCIPHER_SIGN: 207 CryptodevAsymStatIncSign(backend, len); 208 break; 209 case VIRTIO_CRYPTO_AKCIPHER_VERIFY: 210 CryptodevAsymStatIncVerify(backend, len); 211 break; 212 default: 213 return -VIRTIO_CRYPTO_NOTSUPP; 214 } 215 } else if (algtype == QCRYPTODEV_BACKEND_ALG_SYM) { 216 CryptoDevBackendSymOpInfo *sym_op_info = op_info->u.sym_op_info; 217 len = sym_op_info->src_len; 218 219 if (unlikely(!backend->sym_stat)) { 220 error_report("cryptodev: Unexpected sym operation"); 221 return -VIRTIO_CRYPTO_NOTSUPP; 222 } 223 switch (op_info->op_code) { 224 case VIRTIO_CRYPTO_CIPHER_ENCRYPT: 225 CryptodevSymStatIncEncrypt(backend, len); 226 break; 227 case VIRTIO_CRYPTO_CIPHER_DECRYPT: 228 CryptodevSymStatIncDecrypt(backend, len); 229 break; 230 default: 231 return -VIRTIO_CRYPTO_NOTSUPP; 232 } 233 } else { 234 error_report("Unsupported cryptodev alg type: %" PRIu32 "", algtype); 235 return -VIRTIO_CRYPTO_NOTSUPP; 236 } 237 238 return len; 239 } 240 241 static void cryptodev_backend_throttle_timer_cb(void *opaque) 242 { 243 CryptoDevBackend *backend = (CryptoDevBackend *)opaque; 244 CryptoDevBackendOpInfo *op_info, *tmpop; 245 int ret; 246 247 QTAILQ_FOREACH_SAFE(op_info, &backend->opinfos, next, tmpop) { 248 QTAILQ_REMOVE(&backend->opinfos, op_info, next); 249 ret = cryptodev_backend_account(backend, op_info); 250 if (ret < 0) { 251 op_info->cb(op_info->opaque, ret); 252 continue; 253 } 254 255 throttle_account(&backend->ts, true, ret); 256 cryptodev_backend_operation(backend, op_info); 257 if (throttle_enabled(&backend->tc) && 258 throttle_schedule_timer(&backend->ts, &backend->tt, true)) { 259 break; 260 } 261 } 262 } 263 264 int cryptodev_backend_crypto_operation( 265 CryptoDevBackend *backend, 266 CryptoDevBackendOpInfo *op_info) 267 { 268 int ret; 269 270 if (!throttle_enabled(&backend->tc)) { 271 goto do_account; 272 } 273 274 if (throttle_schedule_timer(&backend->ts, &backend->tt, true) || 275 !QTAILQ_EMPTY(&backend->opinfos)) { 276 QTAILQ_INSERT_TAIL(&backend->opinfos, op_info, next); 277 return 0; 278 } 279 280 do_account: 281 ret = cryptodev_backend_account(backend, op_info); 282 if (ret < 0) { 283 return ret; 284 } 285 286 throttle_account(&backend->ts, true, ret); 287 288 return cryptodev_backend_operation(backend, op_info); 289 } 290 291 static void 292 cryptodev_backend_get_queues(Object *obj, Visitor *v, const char *name, 293 void *opaque, Error **errp) 294 { 295 CryptoDevBackend *backend = CRYPTODEV_BACKEND(obj); 296 uint32_t value = backend->conf.peers.queues; 297 298 visit_type_uint32(v, name, &value, errp); 299 } 300 301 static void 302 cryptodev_backend_set_queues(Object *obj, Visitor *v, const char *name, 303 void *opaque, Error **errp) 304 { 305 CryptoDevBackend *backend = CRYPTODEV_BACKEND(obj); 306 uint32_t value; 307 308 if (!visit_type_uint32(v, name, &value, errp)) { 309 return; 310 } 311 if (!value) { 312 error_setg(errp, "Property '%s.%s' doesn't take value '%" PRIu32 "'", 313 object_get_typename(obj), name, value); 314 return; 315 } 316 backend->conf.peers.queues = value; 317 } 318 319 static void cryptodev_backend_set_throttle(CryptoDevBackend *backend, int field, 320 uint64_t value, Error **errp) 321 { 322 uint64_t orig = backend->tc.buckets[field].avg; 323 bool enabled = throttle_enabled(&backend->tc); 324 325 if (orig == value) { 326 return; 327 } 328 329 backend->tc.buckets[field].avg = value; 330 if (!throttle_enabled(&backend->tc)) { 331 throttle_timers_destroy(&backend->tt); 332 cryptodev_backend_throttle_timer_cb(backend); /* drain opinfos */ 333 return; 334 } 335 336 if (!throttle_is_valid(&backend->tc, errp)) { 337 backend->tc.buckets[field].avg = orig; /* revert change */ 338 return; 339 } 340 341 if (!enabled) { 342 throttle_init(&backend->ts); 343 throttle_timers_init(&backend->tt, qemu_get_aio_context(), 344 QEMU_CLOCK_REALTIME, NULL, 345 cryptodev_backend_throttle_timer_cb, backend); 346 } 347 348 throttle_config(&backend->ts, QEMU_CLOCK_REALTIME, &backend->tc); 349 } 350 351 static void cryptodev_backend_get_bps(Object *obj, Visitor *v, 352 const char *name, void *opaque, 353 Error **errp) 354 { 355 CryptoDevBackend *backend = CRYPTODEV_BACKEND(obj); 356 uint64_t value = backend->tc.buckets[THROTTLE_BPS_TOTAL].avg; 357 358 visit_type_uint64(v, name, &value, errp); 359 } 360 361 static void cryptodev_backend_set_bps(Object *obj, Visitor *v, const char *name, 362 void *opaque, Error **errp) 363 { 364 CryptoDevBackend *backend = CRYPTODEV_BACKEND(obj); 365 uint64_t value; 366 367 if (!visit_type_uint64(v, name, &value, errp)) { 368 return; 369 } 370 371 cryptodev_backend_set_throttle(backend, THROTTLE_BPS_TOTAL, value, errp); 372 } 373 374 static void cryptodev_backend_get_ops(Object *obj, Visitor *v, const char *name, 375 void *opaque, Error **errp) 376 { 377 CryptoDevBackend *backend = CRYPTODEV_BACKEND(obj); 378 uint64_t value = backend->tc.buckets[THROTTLE_OPS_TOTAL].avg; 379 380 visit_type_uint64(v, name, &value, errp); 381 } 382 383 static void cryptodev_backend_set_ops(Object *obj, Visitor *v, 384 const char *name, void *opaque, 385 Error **errp) 386 { 387 CryptoDevBackend *backend = CRYPTODEV_BACKEND(obj); 388 uint64_t value; 389 390 if (!visit_type_uint64(v, name, &value, errp)) { 391 return; 392 } 393 394 cryptodev_backend_set_throttle(backend, THROTTLE_OPS_TOTAL, value, errp); 395 } 396 397 static void 398 cryptodev_backend_complete(UserCreatable *uc, Error **errp) 399 { 400 CryptoDevBackend *backend = CRYPTODEV_BACKEND(uc); 401 CryptoDevBackendClass *bc = CRYPTODEV_BACKEND_GET_CLASS(uc); 402 uint32_t services; 403 uint64_t value; 404 405 QTAILQ_INIT(&backend->opinfos); 406 value = backend->tc.buckets[THROTTLE_OPS_TOTAL].avg; 407 cryptodev_backend_set_throttle(backend, THROTTLE_OPS_TOTAL, value, errp); 408 value = backend->tc.buckets[THROTTLE_BPS_TOTAL].avg; 409 cryptodev_backend_set_throttle(backend, THROTTLE_BPS_TOTAL, value, errp); 410 411 if (bc->init) { 412 bc->init(backend, errp); 413 } 414 415 services = backend->conf.crypto_services; 416 if (services & (1 << QCRYPTODEV_BACKEND_SERVICE_CIPHER)) { 417 backend->sym_stat = g_new0(CryptodevBackendSymStat, 1); 418 } 419 420 if (services & (1 << QCRYPTODEV_BACKEND_SERVICE_AKCIPHER)) { 421 backend->asym_stat = g_new0(CryptodevBackendAsymStat, 1); 422 } 423 } 424 425 void cryptodev_backend_set_used(CryptoDevBackend *backend, bool used) 426 { 427 backend->is_used = used; 428 } 429 430 bool cryptodev_backend_is_used(CryptoDevBackend *backend) 431 { 432 return backend->is_used; 433 } 434 435 void cryptodev_backend_set_ready(CryptoDevBackend *backend, bool ready) 436 { 437 backend->ready = ready; 438 } 439 440 bool cryptodev_backend_is_ready(CryptoDevBackend *backend) 441 { 442 return backend->ready; 443 } 444 445 static bool 446 cryptodev_backend_can_be_deleted(UserCreatable *uc) 447 { 448 return !cryptodev_backend_is_used(CRYPTODEV_BACKEND(uc)); 449 } 450 451 static void cryptodev_backend_instance_init(Object *obj) 452 { 453 CryptoDevBackend *backend = CRYPTODEV_BACKEND(obj); 454 455 /* Initialize devices' queues property to 1 */ 456 object_property_set_int(obj, "queues", 1, NULL); 457 458 throttle_config_init(&backend->tc); 459 } 460 461 static void cryptodev_backend_finalize(Object *obj) 462 { 463 CryptoDevBackend *backend = CRYPTODEV_BACKEND(obj); 464 465 cryptodev_backend_cleanup(backend, NULL); 466 if (throttle_enabled(&backend->tc)) { 467 throttle_timers_destroy(&backend->tt); 468 } 469 } 470 471 static StatsList *cryptodev_backend_stats_add(const char *name, int64_t *val, 472 StatsList *stats_list) 473 { 474 Stats *stats = g_new0(Stats, 1); 475 476 stats->name = g_strdup(name); 477 stats->value = g_new0(StatsValue, 1); 478 stats->value->type = QTYPE_QNUM; 479 stats->value->u.scalar = *val; 480 481 QAPI_LIST_PREPEND(stats_list, stats); 482 return stats_list; 483 } 484 485 static int cryptodev_backend_stats_query(Object *obj, void *data) 486 { 487 StatsArgs *stats_args = data; 488 StatsResultList **stats_results = stats_args->result.stats; 489 StatsList *stats_list = NULL; 490 StatsResult *entry; 491 CryptoDevBackend *backend; 492 CryptodevBackendSymStat *sym_stat; 493 CryptodevBackendAsymStat *asym_stat; 494 495 if (!object_dynamic_cast(obj, TYPE_CRYPTODEV_BACKEND)) { 496 return 0; 497 } 498 499 backend = CRYPTODEV_BACKEND(obj); 500 sym_stat = backend->sym_stat; 501 if (sym_stat) { 502 stats_list = cryptodev_backend_stats_add(SYM_ENCRYPT_OPS_STR, 503 &sym_stat->encrypt_ops, stats_list); 504 stats_list = cryptodev_backend_stats_add(SYM_DECRYPT_OPS_STR, 505 &sym_stat->decrypt_ops, stats_list); 506 stats_list = cryptodev_backend_stats_add(SYM_ENCRYPT_BYTES_STR, 507 &sym_stat->encrypt_bytes, stats_list); 508 stats_list = cryptodev_backend_stats_add(SYM_DECRYPT_BYTES_STR, 509 &sym_stat->decrypt_bytes, stats_list); 510 } 511 512 asym_stat = backend->asym_stat; 513 if (asym_stat) { 514 stats_list = cryptodev_backend_stats_add(ASYM_ENCRYPT_OPS_STR, 515 &asym_stat->encrypt_ops, stats_list); 516 stats_list = cryptodev_backend_stats_add(ASYM_DECRYPT_OPS_STR, 517 &asym_stat->decrypt_ops, stats_list); 518 stats_list = cryptodev_backend_stats_add(ASYM_SIGN_OPS_STR, 519 &asym_stat->sign_ops, stats_list); 520 stats_list = cryptodev_backend_stats_add(ASYM_VERIFY_OPS_STR, 521 &asym_stat->verify_ops, stats_list); 522 stats_list = cryptodev_backend_stats_add(ASYM_ENCRYPT_BYTES_STR, 523 &asym_stat->encrypt_bytes, stats_list); 524 stats_list = cryptodev_backend_stats_add(ASYM_DECRYPT_BYTES_STR, 525 &asym_stat->decrypt_bytes, stats_list); 526 stats_list = cryptodev_backend_stats_add(ASYM_SIGN_BYTES_STR, 527 &asym_stat->sign_bytes, stats_list); 528 stats_list = cryptodev_backend_stats_add(ASYM_VERIFY_BYTES_STR, 529 &asym_stat->verify_bytes, stats_list); 530 } 531 532 entry = g_new0(StatsResult, 1); 533 entry->provider = STATS_PROVIDER_CRYPTODEV; 534 entry->qom_path = object_get_canonical_path(obj); 535 entry->stats = stats_list; 536 QAPI_LIST_PREPEND(*stats_results, entry); 537 538 return 0; 539 } 540 541 static void cryptodev_backend_stats_cb(StatsResultList **result, 542 StatsTarget target, 543 strList *names, strList *targets, 544 Error **errp) 545 { 546 switch (target) { 547 case STATS_TARGET_CRYPTODEV: 548 { 549 Object *objs = container_get(object_get_root(), "/objects"); 550 StatsArgs stats_args; 551 stats_args.result.stats = result; 552 stats_args.names = names; 553 stats_args.errp = errp; 554 555 object_child_foreach(objs, cryptodev_backend_stats_query, &stats_args); 556 break; 557 } 558 default: 559 break; 560 } 561 } 562 563 static StatsSchemaValueList *cryptodev_backend_schemas_add(const char *name, 564 StatsSchemaValueList *list) 565 { 566 StatsSchemaValueList *schema_entry = g_new0(StatsSchemaValueList, 1); 567 568 schema_entry->value = g_new0(StatsSchemaValue, 1); 569 schema_entry->value->type = STATS_TYPE_CUMULATIVE; 570 schema_entry->value->name = g_strdup(name); 571 schema_entry->next = list; 572 573 return schema_entry; 574 } 575 576 static void cryptodev_backend_schemas_cb(StatsSchemaList **result, 577 Error **errp) 578 { 579 StatsSchemaValueList *stats_list = NULL; 580 const char *sym_stats[] = { SYM_ENCRYPT_OPS_STR, SYM_DECRYPT_OPS_STR, 581 SYM_ENCRYPT_BYTES_STR, SYM_DECRYPT_BYTES_STR }; 582 const char *asym_stats[] = { ASYM_ENCRYPT_OPS_STR, ASYM_DECRYPT_OPS_STR, 583 ASYM_SIGN_OPS_STR, ASYM_VERIFY_OPS_STR, 584 ASYM_ENCRYPT_BYTES_STR, ASYM_DECRYPT_BYTES_STR, 585 ASYM_SIGN_BYTES_STR, ASYM_VERIFY_BYTES_STR }; 586 587 for (int i = 0; i < ARRAY_SIZE(sym_stats); i++) { 588 stats_list = cryptodev_backend_schemas_add(sym_stats[i], stats_list); 589 } 590 591 for (int i = 0; i < ARRAY_SIZE(asym_stats); i++) { 592 stats_list = cryptodev_backend_schemas_add(asym_stats[i], stats_list); 593 } 594 595 add_stats_schema(result, STATS_PROVIDER_CRYPTODEV, STATS_TARGET_CRYPTODEV, 596 stats_list); 597 } 598 599 static void 600 cryptodev_backend_class_init(ObjectClass *oc, void *data) 601 { 602 UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc); 603 604 ucc->complete = cryptodev_backend_complete; 605 ucc->can_be_deleted = cryptodev_backend_can_be_deleted; 606 607 QTAILQ_INIT(&crypto_clients); 608 object_class_property_add(oc, "queues", "uint32", 609 cryptodev_backend_get_queues, 610 cryptodev_backend_set_queues, 611 NULL, NULL); 612 object_class_property_add(oc, "throttle-bps", "uint64", 613 cryptodev_backend_get_bps, 614 cryptodev_backend_set_bps, 615 NULL, NULL); 616 object_class_property_add(oc, "throttle-ops", "uint64", 617 cryptodev_backend_get_ops, 618 cryptodev_backend_set_ops, 619 NULL, NULL); 620 621 add_stats_callbacks(STATS_PROVIDER_CRYPTODEV, cryptodev_backend_stats_cb, 622 cryptodev_backend_schemas_cb); 623 } 624 625 static const TypeInfo cryptodev_backend_info = { 626 .name = TYPE_CRYPTODEV_BACKEND, 627 .parent = TYPE_OBJECT, 628 .instance_size = sizeof(CryptoDevBackend), 629 .instance_init = cryptodev_backend_instance_init, 630 .instance_finalize = cryptodev_backend_finalize, 631 .class_size = sizeof(CryptoDevBackendClass), 632 .class_init = cryptodev_backend_class_init, 633 .interfaces = (InterfaceInfo[]) { 634 { TYPE_USER_CREATABLE }, 635 { } 636 } 637 }; 638 639 static void 640 cryptodev_backend_register_types(void) 641 { 642 type_register_static(&cryptodev_backend_info); 643 } 644 645 type_init(cryptodev_backend_register_types); 646