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, 345 cryptodev_backend_throttle_timer_cb, /* FIXME */ 346 cryptodev_backend_throttle_timer_cb, backend); 347 } 348 349 throttle_config(&backend->ts, QEMU_CLOCK_REALTIME, &backend->tc); 350 } 351 352 static void cryptodev_backend_get_bps(Object *obj, Visitor *v, 353 const char *name, void *opaque, 354 Error **errp) 355 { 356 CryptoDevBackend *backend = CRYPTODEV_BACKEND(obj); 357 uint64_t value = backend->tc.buckets[THROTTLE_BPS_TOTAL].avg; 358 359 visit_type_uint64(v, name, &value, errp); 360 } 361 362 static void cryptodev_backend_set_bps(Object *obj, Visitor *v, const char *name, 363 void *opaque, Error **errp) 364 { 365 CryptoDevBackend *backend = CRYPTODEV_BACKEND(obj); 366 uint64_t value; 367 368 if (!visit_type_uint64(v, name, &value, errp)) { 369 return; 370 } 371 372 cryptodev_backend_set_throttle(backend, THROTTLE_BPS_TOTAL, value, errp); 373 } 374 375 static void cryptodev_backend_get_ops(Object *obj, Visitor *v, const char *name, 376 void *opaque, Error **errp) 377 { 378 CryptoDevBackend *backend = CRYPTODEV_BACKEND(obj); 379 uint64_t value = backend->tc.buckets[THROTTLE_OPS_TOTAL].avg; 380 381 visit_type_uint64(v, name, &value, errp); 382 } 383 384 static void cryptodev_backend_set_ops(Object *obj, Visitor *v, 385 const char *name, void *opaque, 386 Error **errp) 387 { 388 CryptoDevBackend *backend = CRYPTODEV_BACKEND(obj); 389 uint64_t value; 390 391 if (!visit_type_uint64(v, name, &value, errp)) { 392 return; 393 } 394 395 cryptodev_backend_set_throttle(backend, THROTTLE_OPS_TOTAL, value, errp); 396 } 397 398 static void 399 cryptodev_backend_complete(UserCreatable *uc, Error **errp) 400 { 401 CryptoDevBackend *backend = CRYPTODEV_BACKEND(uc); 402 CryptoDevBackendClass *bc = CRYPTODEV_BACKEND_GET_CLASS(uc); 403 uint32_t services; 404 uint64_t value; 405 406 QTAILQ_INIT(&backend->opinfos); 407 value = backend->tc.buckets[THROTTLE_OPS_TOTAL].avg; 408 cryptodev_backend_set_throttle(backend, THROTTLE_OPS_TOTAL, value, errp); 409 value = backend->tc.buckets[THROTTLE_BPS_TOTAL].avg; 410 cryptodev_backend_set_throttle(backend, THROTTLE_BPS_TOTAL, value, errp); 411 412 if (bc->init) { 413 bc->init(backend, errp); 414 } 415 416 services = backend->conf.crypto_services; 417 if (services & (1 << QCRYPTODEV_BACKEND_SERVICE_CIPHER)) { 418 backend->sym_stat = g_new0(CryptodevBackendSymStat, 1); 419 } 420 421 if (services & (1 << QCRYPTODEV_BACKEND_SERVICE_AKCIPHER)) { 422 backend->asym_stat = g_new0(CryptodevBackendAsymStat, 1); 423 } 424 } 425 426 void cryptodev_backend_set_used(CryptoDevBackend *backend, bool used) 427 { 428 backend->is_used = used; 429 } 430 431 bool cryptodev_backend_is_used(CryptoDevBackend *backend) 432 { 433 return backend->is_used; 434 } 435 436 void cryptodev_backend_set_ready(CryptoDevBackend *backend, bool ready) 437 { 438 backend->ready = ready; 439 } 440 441 bool cryptodev_backend_is_ready(CryptoDevBackend *backend) 442 { 443 return backend->ready; 444 } 445 446 static bool 447 cryptodev_backend_can_be_deleted(UserCreatable *uc) 448 { 449 return !cryptodev_backend_is_used(CRYPTODEV_BACKEND(uc)); 450 } 451 452 static void cryptodev_backend_instance_init(Object *obj) 453 { 454 CryptoDevBackend *backend = CRYPTODEV_BACKEND(obj); 455 456 /* Initialize devices' queues property to 1 */ 457 object_property_set_int(obj, "queues", 1, NULL); 458 459 throttle_config_init(&backend->tc); 460 } 461 462 static void cryptodev_backend_finalize(Object *obj) 463 { 464 CryptoDevBackend *backend = CRYPTODEV_BACKEND(obj); 465 466 cryptodev_backend_cleanup(backend, NULL); 467 if (throttle_enabled(&backend->tc)) { 468 throttle_timers_destroy(&backend->tt); 469 } 470 } 471 472 static StatsList *cryptodev_backend_stats_add(const char *name, int64_t *val, 473 StatsList *stats_list) 474 { 475 Stats *stats = g_new0(Stats, 1); 476 477 stats->name = g_strdup(name); 478 stats->value = g_new0(StatsValue, 1); 479 stats->value->type = QTYPE_QNUM; 480 stats->value->u.scalar = *val; 481 482 QAPI_LIST_PREPEND(stats_list, stats); 483 return stats_list; 484 } 485 486 static int cryptodev_backend_stats_query(Object *obj, void *data) 487 { 488 StatsArgs *stats_args = data; 489 StatsResultList **stats_results = stats_args->result.stats; 490 StatsList *stats_list = NULL; 491 StatsResult *entry; 492 CryptoDevBackend *backend; 493 CryptodevBackendSymStat *sym_stat; 494 CryptodevBackendAsymStat *asym_stat; 495 496 if (!object_dynamic_cast(obj, TYPE_CRYPTODEV_BACKEND)) { 497 return 0; 498 } 499 500 backend = CRYPTODEV_BACKEND(obj); 501 sym_stat = backend->sym_stat; 502 if (sym_stat) { 503 stats_list = cryptodev_backend_stats_add(SYM_ENCRYPT_OPS_STR, 504 &sym_stat->encrypt_ops, stats_list); 505 stats_list = cryptodev_backend_stats_add(SYM_DECRYPT_OPS_STR, 506 &sym_stat->decrypt_ops, stats_list); 507 stats_list = cryptodev_backend_stats_add(SYM_ENCRYPT_BYTES_STR, 508 &sym_stat->encrypt_bytes, stats_list); 509 stats_list = cryptodev_backend_stats_add(SYM_DECRYPT_BYTES_STR, 510 &sym_stat->decrypt_bytes, stats_list); 511 } 512 513 asym_stat = backend->asym_stat; 514 if (asym_stat) { 515 stats_list = cryptodev_backend_stats_add(ASYM_ENCRYPT_OPS_STR, 516 &asym_stat->encrypt_ops, stats_list); 517 stats_list = cryptodev_backend_stats_add(ASYM_DECRYPT_OPS_STR, 518 &asym_stat->decrypt_ops, stats_list); 519 stats_list = cryptodev_backend_stats_add(ASYM_SIGN_OPS_STR, 520 &asym_stat->sign_ops, stats_list); 521 stats_list = cryptodev_backend_stats_add(ASYM_VERIFY_OPS_STR, 522 &asym_stat->verify_ops, stats_list); 523 stats_list = cryptodev_backend_stats_add(ASYM_ENCRYPT_BYTES_STR, 524 &asym_stat->encrypt_bytes, stats_list); 525 stats_list = cryptodev_backend_stats_add(ASYM_DECRYPT_BYTES_STR, 526 &asym_stat->decrypt_bytes, stats_list); 527 stats_list = cryptodev_backend_stats_add(ASYM_SIGN_BYTES_STR, 528 &asym_stat->sign_bytes, stats_list); 529 stats_list = cryptodev_backend_stats_add(ASYM_VERIFY_BYTES_STR, 530 &asym_stat->verify_bytes, stats_list); 531 } 532 533 entry = g_new0(StatsResult, 1); 534 entry->provider = STATS_PROVIDER_CRYPTODEV; 535 entry->qom_path = object_get_canonical_path(obj); 536 entry->stats = stats_list; 537 QAPI_LIST_PREPEND(*stats_results, entry); 538 539 return 0; 540 } 541 542 static void cryptodev_backend_stats_cb(StatsResultList **result, 543 StatsTarget target, 544 strList *names, strList *targets, 545 Error **errp) 546 { 547 switch (target) { 548 case STATS_TARGET_CRYPTODEV: 549 { 550 Object *objs = container_get(object_get_root(), "/objects"); 551 StatsArgs stats_args; 552 stats_args.result.stats = result; 553 stats_args.names = names; 554 stats_args.errp = errp; 555 556 object_child_foreach(objs, cryptodev_backend_stats_query, &stats_args); 557 break; 558 } 559 default: 560 break; 561 } 562 } 563 564 static StatsSchemaValueList *cryptodev_backend_schemas_add(const char *name, 565 StatsSchemaValueList *list) 566 { 567 StatsSchemaValueList *schema_entry = g_new0(StatsSchemaValueList, 1); 568 569 schema_entry->value = g_new0(StatsSchemaValue, 1); 570 schema_entry->value->type = STATS_TYPE_CUMULATIVE; 571 schema_entry->value->name = g_strdup(name); 572 schema_entry->next = list; 573 574 return schema_entry; 575 } 576 577 static void cryptodev_backend_schemas_cb(StatsSchemaList **result, 578 Error **errp) 579 { 580 StatsSchemaValueList *stats_list = NULL; 581 const char *sym_stats[] = { SYM_ENCRYPT_OPS_STR, SYM_DECRYPT_OPS_STR, 582 SYM_ENCRYPT_BYTES_STR, SYM_DECRYPT_BYTES_STR }; 583 const char *asym_stats[] = { ASYM_ENCRYPT_OPS_STR, ASYM_DECRYPT_OPS_STR, 584 ASYM_SIGN_OPS_STR, ASYM_VERIFY_OPS_STR, 585 ASYM_ENCRYPT_BYTES_STR, ASYM_DECRYPT_BYTES_STR, 586 ASYM_SIGN_BYTES_STR, ASYM_VERIFY_BYTES_STR }; 587 588 for (int i = 0; i < ARRAY_SIZE(sym_stats); i++) { 589 stats_list = cryptodev_backend_schemas_add(sym_stats[i], stats_list); 590 } 591 592 for (int i = 0; i < ARRAY_SIZE(asym_stats); i++) { 593 stats_list = cryptodev_backend_schemas_add(asym_stats[i], stats_list); 594 } 595 596 add_stats_schema(result, STATS_PROVIDER_CRYPTODEV, STATS_TARGET_CRYPTODEV, 597 stats_list); 598 } 599 600 static void 601 cryptodev_backend_class_init(ObjectClass *oc, void *data) 602 { 603 UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc); 604 605 ucc->complete = cryptodev_backend_complete; 606 ucc->can_be_deleted = cryptodev_backend_can_be_deleted; 607 608 QTAILQ_INIT(&crypto_clients); 609 object_class_property_add(oc, "queues", "uint32", 610 cryptodev_backend_get_queues, 611 cryptodev_backend_set_queues, 612 NULL, NULL); 613 object_class_property_add(oc, "throttle-bps", "uint64", 614 cryptodev_backend_get_bps, 615 cryptodev_backend_set_bps, 616 NULL, NULL); 617 object_class_property_add(oc, "throttle-ops", "uint64", 618 cryptodev_backend_get_ops, 619 cryptodev_backend_set_ops, 620 NULL, NULL); 621 622 add_stats_callbacks(STATS_PROVIDER_CRYPTODEV, cryptodev_backend_stats_cb, 623 cryptodev_backend_schemas_cb); 624 } 625 626 static const TypeInfo cryptodev_backend_info = { 627 .name = TYPE_CRYPTODEV_BACKEND, 628 .parent = TYPE_OBJECT, 629 .instance_size = sizeof(CryptoDevBackend), 630 .instance_init = cryptodev_backend_instance_init, 631 .instance_finalize = cryptodev_backend_finalize, 632 .class_size = sizeof(CryptoDevBackendClass), 633 .class_init = cryptodev_backend_class_init, 634 .interfaces = (InterfaceInfo[]) { 635 { TYPE_USER_CREATABLE }, 636 { } 637 } 638 }; 639 640 static void 641 cryptodev_backend_register_types(void) 642 { 643 type_register_static(&cryptodev_backend_info); 644 } 645 646 type_init(cryptodev_backend_register_types); 647