lib/librte_compressdev/rte_compressdev.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2017-2018 Intel Corporation
   3  */
   4
   5 #include <string.h>
   6 #include <stdarg.h>
   7 #include <stdio.h>
   8 #include <inttypes.h>
   9
  10 #include <rte_malloc.h>
  11 #include <rte_eal.h>
  12 #include <rte_memzone.h>
  13
  14 #include "rte_compressdev.h"
  15 #include "rte_compressdev_internal.h"
  16 #include "rte_compressdev_pmd.h"
  17
  18 #define RTE_COMPRESSDEV_DETACHED  (0)
  19 #define RTE_COMPRESSDEV_ATTACHED  (1)
  20
  21 struct rte_compressdev rte_comp_devices[RTE_COMPRESS_MAX_DEVS];
  22
  23 struct rte_compressdev *rte_compressdevs = &rte_comp_devices[0];
  24
  25 static struct rte_compressdev_global compressdev_globals = {
  26                 .devs                   = &rte_comp_devices[0],
  27                 .data                   = { NULL },
  28                 .nb_devs                = 0,
  29                 .max_devs               = RTE_COMPRESS_MAX_DEVS
  30 };
  31
  32 struct rte_compressdev_global *rte_compressdev_globals = &compressdev_globals;
  33
  34 static struct rte_compressdev *
  35 rte_compressdev_get_dev(uint8_t dev_id)
  36 {
  37         return &rte_compressdev_globals->devs[dev_id];
  38 }
  39
  40 struct rte_compressdev * __rte_experimental
  41 rte_compressdev_pmd_get_named_dev(const char *name)
  42 {
  43         struct rte_compressdev *dev;
  44         unsigned int i;
  45
  46         if (name == NULL)
  47                 return NULL;
  48
  49         for (i = 0; i < rte_compressdev_globals->max_devs; i++) {
  50                 dev = &rte_compressdev_globals->devs[i];
  51
  52                 if ((dev->attached == RTE_COMPRESSDEV_ATTACHED) &&
  53                                 (strcmp(dev->data->name, name) == 0))
  54                         return dev;
  55         }
  56
  57         return NULL;
  58 }
  59
  60 static unsigned int
  61 rte_compressdev_is_valid_dev(uint8_t dev_id)
  62 {
  63         struct rte_compressdev *dev = NULL;
  64
  65         if (dev_id >= rte_compressdev_globals->nb_devs)
  66                 return 0;
  67
  68         dev = rte_compressdev_get_dev(dev_id);
  69         if (dev->attached != RTE_COMPRESSDEV_ATTACHED)
  70                 return 0;
  71         else
  72                 return 1;
  73 }
  74
  75
  76 uint8_t __rte_experimental
  77 rte_compressdev_count(void)
  78 {
  79         return rte_compressdev_globals->nb_devs;
  80 }
  81
  82 uint8_t __rte_experimental
  83 rte_compressdev_devices_get(const char *driver_name, uint8_t *devices,
  84         uint8_t nb_devices)
  85 {
  86         uint8_t i, count = 0;
  87         struct rte_compressdev *devs = rte_compressdev_globals->devs;
  88         uint8_t max_devs = rte_compressdev_globals->max_devs;
  89
  90         for (i = 0; i < max_devs && count < nb_devices; i++) {
  91
  92                 if (devs[i].attached == RTE_COMPRESSDEV_ATTACHED) {
  93                         int cmp;
  94
  95                         cmp = strncmp(devs[i].device->driver->name,
  96                                         driver_name,
  97                                         strlen(driver_name));
  98
  99                         if (cmp == 0)
 100                                 devices[count++] = devs[i].data->dev_id;
 101                 }
 102         }
 103
 104         return count;
 105 }
 106
 107 int __rte_experimental
 108 rte_compressdev_socket_id(uint8_t dev_id)
 109 {
 110         struct rte_compressdev *dev;
 111
 112         if (!rte_compressdev_is_valid_dev(dev_id))
 113                 return -1;
 114
 115         dev = rte_compressdev_get_dev(dev_id);
 116
 117         return dev->data->socket_id;
 118 }
 119
 120 static inline int
 121 rte_compressdev_data_alloc(uint8_t dev_id, struct rte_compressdev_data **data,
 122                 int socket_id)
 123 {
 124         char mz_name[RTE_COMPRESSDEV_NAME_MAX_LEN];
 125         const struct rte_memzone *mz;
 126         int n;
 127
 128         /* generate memzone name */
 129         n = snprintf(mz_name, sizeof(mz_name),
 130                         "rte_compressdev_data_%u", dev_id);
 131         if (n >= (int)sizeof(mz_name))
 132                 return -EINVAL;
 133
 134         if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
 135                 mz = rte_memzone_reserve(mz_name,
 136                                 sizeof(struct rte_compressdev_data),
 137                                 socket_id, 0);
 138         } else
 139                 mz = rte_memzone_lookup(mz_name);
 140
 141         if (mz == NULL)
 142                 return -ENOMEM;
 143
 144         *data = mz->addr;
 145         if (rte_eal_process_type() == RTE_PROC_PRIMARY)
 146                 memset(*data, 0, sizeof(struct rte_compressdev_data));
 147
 148         return 0;
 149 }
 150
 151 static uint8_t
 152 rte_compressdev_find_free_device_index(void)
 153 {
 154         uint8_t dev_id;
 155
 156         for (dev_id = 0; dev_id < RTE_COMPRESS_MAX_DEVS; dev_id++) {
 157                 if (rte_comp_devices[dev_id].attached ==
 158                                 RTE_COMPRESSDEV_DETACHED)
 159                         return dev_id;
 160         }
 161         return RTE_COMPRESS_MAX_DEVS;
 162 }
 163
 164 struct rte_compressdev * __rte_experimental
 165 rte_compressdev_pmd_allocate(const char *name, int socket_id)
 166 {
 167         struct rte_compressdev *compressdev;
 168         uint8_t dev_id;
 169
 170         if (rte_compressdev_pmd_get_named_dev(name) != NULL) {
 171                 COMPRESSDEV_LOG(ERR,
 172                         "comp device with name %s already allocated!", name);
 173                 return NULL;
 174         }
 175
 176         dev_id = rte_compressdev_find_free_device_index();
 177         if (dev_id == RTE_COMPRESS_MAX_DEVS) {
 178                 COMPRESSDEV_LOG(ERR, "Reached maximum number of comp devices");
 179                 return NULL;
 180         }
 181         compressdev = rte_compressdev_get_dev(dev_id);
 182
 183         if (compressdev->data == NULL) {
 184                 struct rte_compressdev_data *compressdev_data =
 185                                 compressdev_globals.data[dev_id];
 186
 187                 int retval = rte_compressdev_data_alloc(dev_id,
 188                                 &compressdev_data, socket_id);
 189
 190                 if (retval < 0 || compressdev_data == NULL)
 191                         return NULL;
 192
 193                 compressdev->data = compressdev_data;
 194
 195                 snprintf(compressdev->data->name, RTE_COMPRESSDEV_NAME_MAX_LEN,
 196                                 "%s", name);
 197
 198                 compressdev->data->dev_id = dev_id;
 199                 compressdev->data->socket_id = socket_id;
 200                 compressdev->data->dev_started = 0;
 201
 202                 compressdev->attached = RTE_COMPRESSDEV_ATTACHED;
 203
 204                 compressdev_globals.nb_devs++;
 205         }
 206
 207         return compressdev;
 208 }
 209
 210 int __rte_experimental
 211 rte_compressdev_pmd_release_device(struct rte_compressdev *compressdev)
 212 {
 213         int ret;
 214
 215         if (compressdev == NULL)
 216                 return -EINVAL;
 217
 218         /* Close device only if device operations have been set */
 219         if (compressdev->dev_ops) {
 220                 ret = rte_compressdev_close(compressdev->data->dev_id);
 221                 if (ret < 0)
 222                         return ret;
 223         }
 224
 225         compressdev->attached = RTE_COMPRESSDEV_DETACHED;
 226         compressdev_globals.nb_devs--;
 227         return 0;
 228 }
 229
 230 uint16_t __rte_experimental
 231 rte_compressdev_queue_pair_count(uint8_t dev_id)
 232 {
 233         struct rte_compressdev *dev;
 234
 235         dev = &rte_comp_devices[dev_id];
 236         return dev->data->nb_queue_pairs;
 237 }
 238
 239 static int
 240 rte_compressdev_queue_pairs_config(struct rte_compressdev *dev,
 241                 uint16_t nb_qpairs, int socket_id)
 242 {
 243         struct rte_compressdev_info dev_info;
 244         void **qp;
 245         unsigned int i;
 246
 247         if ((dev == NULL) || (nb_qpairs < 1)) {
 248                 COMPRESSDEV_LOG(ERR, "invalid param: dev %p, nb_queues %u",
 249                                                         dev, nb_qpairs);
 250                 return -EINVAL;
 251         }
 252
 253         COMPRESSDEV_LOG(DEBUG, "Setup %d queues pairs on device %u",
 254                         nb_qpairs, dev->data->dev_id);
 255
 256         memset(&dev_info, 0, sizeof(struct rte_compressdev_info));
 257
 258         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_infos_get, -ENOTSUP);
 259         (*dev->dev_ops->dev_infos_get)(dev, &dev_info);
 260
 261         if ((dev_info.max_nb_queue_pairs != 0) &&
 262                         (nb_qpairs > dev_info.max_nb_queue_pairs)) {
 263                 COMPRESSDEV_LOG(ERR, "Invalid num queue_pairs (%u) for dev %u",
 264                                 nb_qpairs, dev->data->dev_id);
 265                 return -EINVAL;
 266         }
 267
 268         if (dev->data->queue_pairs == NULL) { /* first time configuration */
 269                 dev->data->queue_pairs = rte_zmalloc_socket(
 270                                 "compressdev->queue_pairs",
 271                                 sizeof(dev->data->queue_pairs[0]) * nb_qpairs,
 272                                 RTE_CACHE_LINE_SIZE, socket_id);
 273
 274                 if (dev->data->queue_pairs == NULL) {
 275                         dev->data->nb_queue_pairs = 0;
 276                         COMPRESSDEV_LOG(ERR,
 277                         "failed to get memory for qp meta data, nb_queues %u",
 278                                                         nb_qpairs);
 279                         return -(ENOMEM);
 280                 }
 281         } else { /* re-configure */
 282                 int ret;
 283                 uint16_t old_nb_queues = dev->data->nb_queue_pairs;
 284
 285                 qp = dev->data->queue_pairs;
 286
 287                 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_release,
 288                                 -ENOTSUP);
 289
 290                 for (i = nb_qpairs; i < old_nb_queues; i++) {
 291                         ret = (*dev->dev_ops->queue_pair_release)(dev, i);
 292                         if (ret < 0)
 293                                 return ret;
 294                 }
 295
 296                 qp = rte_realloc(qp, sizeof(qp[0]) * nb_qpairs,
 297                                 RTE_CACHE_LINE_SIZE);
 298                 if (qp == NULL) {
 299                         COMPRESSDEV_LOG(ERR,
 300                         "failed to realloc qp meta data, nb_queues %u",
 301                                                 nb_qpairs);
 302                         return -(ENOMEM);
 303                 }
 304
 305                 if (nb_qpairs > old_nb_queues) {
 306                         uint16_t new_qs = nb_qpairs - old_nb_queues;
 307
 308                         memset(qp + old_nb_queues, 0,
 309                                 sizeof(qp[0]) * new_qs);
 310                 }
 311
 312                 dev->data->queue_pairs = qp;
 313
 314         }
 315         dev->data->nb_queue_pairs = nb_qpairs;
 316         return 0;
 317 }
 318
 319 static int
 320 rte_compressdev_queue_pairs_release(struct rte_compressdev *dev)
 321 {
 322         uint16_t num_qps, i;
 323         int ret;
 324
 325         if (dev == NULL) {
 326                 COMPRESSDEV_LOG(ERR, "invalid param: dev %p", dev);
 327                 return -EINVAL;
 328         }
 329
 330         num_qps = dev->data->nb_queue_pairs;
 331
 332         if (num_qps == 0)
 333                 return 0;
 334
 335         COMPRESSDEV_LOG(DEBUG, "Free %d queues pairs on device %u",
 336                         dev->data->nb_queue_pairs, dev->data->dev_id);
 337
 338         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_release,
 339                                 -ENOTSUP);
 340
 341         for (i = 0; i < num_qps; i++) {
 342                 ret = (*dev->dev_ops->queue_pair_release)(dev, i);
 343                 if (ret < 0)
 344                         return ret;
 345         }
 346
 347         if (dev->data->queue_pairs != NULL)
 348                 rte_free(dev->data->queue_pairs);
 349         dev->data->queue_pairs = NULL;
 350         dev->data->nb_queue_pairs = 0;
 351
 352         return 0;
 353 }
 354
 355 int __rte_experimental
 356 rte_compressdev_configure(uint8_t dev_id, struct rte_compressdev_config *config)
 357 {
 358         struct rte_compressdev *dev;
 359         int diag;
 360
 361         if (!rte_compressdev_is_valid_dev(dev_id)) {
 362                 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
 363                 return -EINVAL;
 364         }
 365
 366         dev = &rte_comp_devices[dev_id];
 367
 368         if (dev->data->dev_started) {
 369                 COMPRESSDEV_LOG(ERR,
 370                     "device %d must be stopped to allow configuration", dev_id);
 371                 return -EBUSY;
 372         }
 373
 374         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_configure, -ENOTSUP);
 375
 376         /* Setup new number of queue pairs and reconfigure device. */
 377         diag = rte_compressdev_queue_pairs_config(dev, config->nb_queue_pairs,
 378                         config->socket_id);
 379         if (diag != 0) {
 380                 COMPRESSDEV_LOG(ERR,
 381                         "dev%d rte_comp_dev_queue_pairs_config = %d",
 382                                 dev_id, diag);
 383                 return diag;
 384         }
 385
 386         return (*dev->dev_ops->dev_configure)(dev, config);
 387 }
 388
 389 int __rte_experimental
 390 rte_compressdev_start(uint8_t dev_id)
 391 {
 392         struct rte_compressdev *dev;
 393         int diag;
 394
 395         COMPRESSDEV_LOG(DEBUG, "Start dev_id=%" PRIu8, dev_id);
 396
 397         if (!rte_compressdev_is_valid_dev(dev_id)) {
 398                 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
 399                 return -EINVAL;
 400         }
 401
 402         dev = &rte_comp_devices[dev_id];
 403
 404         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_start, -ENOTSUP);
 405
 406         if (dev->data->dev_started != 0) {
 407                 COMPRESSDEV_LOG(ERR,
 408                     "Device with dev_id=%" PRIu8 " already started", dev_id);
 409                 return 0;
 410         }
 411
 412         diag = (*dev->dev_ops->dev_start)(dev);
 413         if (diag == 0)
 414                 dev->data->dev_started = 1;
 415         else
 416                 return diag;
 417
 418         return 0;
 419 }
 420
 421 void __rte_experimental
 422 rte_compressdev_stop(uint8_t dev_id)
 423 {
 424         struct rte_compressdev *dev;
 425
 426         if (!rte_compressdev_is_valid_dev(dev_id)) {
 427                 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
 428                 return;
 429         }
 430
 431         dev = &rte_comp_devices[dev_id];
 432
 433         RTE_FUNC_PTR_OR_RET(*dev->dev_ops->dev_stop);
 434
 435         if (dev->data->dev_started == 0) {
 436                 COMPRESSDEV_LOG(ERR,
 437                     "Device with dev_id=%" PRIu8 " already stopped", dev_id);
 438                 return;
 439         }
 440
 441         (*dev->dev_ops->dev_stop)(dev);
 442         dev->data->dev_started = 0;
 443 }
 444
 445 int __rte_experimental
 446 rte_compressdev_close(uint8_t dev_id)
 447 {
 448         struct rte_compressdev *dev;
 449         int retval;
 450
 451         if (!rte_compressdev_is_valid_dev(dev_id)) {
 452                 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
 453                 return -1;
 454         }
 455
 456         dev = &rte_comp_devices[dev_id];
 457
 458         /* Device must be stopped before it can be closed */
 459         if (dev->data->dev_started == 1) {
 460                 COMPRESSDEV_LOG(ERR, "Device %u must be stopped before closing",
 461                                 dev_id);
 462                 return -EBUSY;
 463         }
 464
 465         /* Free queue pairs memory */
 466         retval = rte_compressdev_queue_pairs_release(dev);
 467
 468         if (retval < 0)
 469                 return retval;
 470
 471         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_close, -ENOTSUP);
 472         retval = (*dev->dev_ops->dev_close)(dev);
 473
 474         if (retval < 0)
 475                 return retval;
 476
 477         return 0;
 478 }
 479
 480 int __rte_experimental
 481 rte_compressdev_queue_pair_setup(uint8_t dev_id, uint16_t queue_pair_id,
 482                 uint32_t max_inflight_ops, int socket_id)
 483 {
 484         struct rte_compressdev *dev;
 485
 486         if (!rte_compressdev_is_valid_dev(dev_id)) {
 487                 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
 488                 return -EINVAL;
 489         }
 490
 491         dev = &rte_comp_devices[dev_id];
 492         if (queue_pair_id >= dev->data->nb_queue_pairs) {
 493                 COMPRESSDEV_LOG(ERR, "Invalid queue_pair_id=%d", queue_pair_id);
 494                 return -EINVAL;
 495         }
 496
 497         if (dev->data->dev_started) {
 498                 COMPRESSDEV_LOG(ERR,
 499                     "device %d must be stopped to allow configuration", dev_id);
 500                 return -EBUSY;
 501         }
 502
 503         if (max_inflight_ops == 0) {
 504                 COMPRESSDEV_LOG(ERR,
 505                         "Invalid maximum number of inflight operations");
 506                 return -EINVAL;
 507         }
 508
 509         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_setup, -ENOTSUP);
 510
 511         return (*dev->dev_ops->queue_pair_setup)(dev, queue_pair_id,
 512                         max_inflight_ops, socket_id);
 513 }
 514
 515 uint16_t __rte_experimental
 516 rte_compressdev_dequeue_burst(uint8_t dev_id, uint16_t qp_id,
 517                 struct rte_comp_op **ops, uint16_t nb_ops)
 518 {
 519         struct rte_compressdev *dev = &rte_compressdevs[dev_id];
 520
 521         nb_ops = (*dev->dequeue_burst)
 522                         (dev->data->queue_pairs[qp_id], ops, nb_ops);
 523
 524         return nb_ops;
 525 }
 526
 527 uint16_t __rte_experimental
 528 rte_compressdev_enqueue_burst(uint8_t dev_id, uint16_t qp_id,
 529                 struct rte_comp_op **ops, uint16_t nb_ops)
 530 {
 531         struct rte_compressdev *dev = &rte_compressdevs[dev_id];
 532
 533         return (*dev->enqueue_burst)(
 534                         dev->data->queue_pairs[qp_id], ops, nb_ops);
 535 }
 536
 537 void __rte_experimental
 538 rte_compressdev_info_get(uint8_t dev_id, struct rte_compressdev_info *dev_info)
 539 {
 540         struct rte_compressdev *dev;
 541
 542         if (dev_id >= compressdev_globals.nb_devs) {
 543                 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%d", dev_id);
 544                 return;
 545         }
 546
 547         dev = &rte_comp_devices[dev_id];
 548
 549         memset(dev_info, 0, sizeof(struct rte_compressdev_info));
 550
 551         RTE_FUNC_PTR_OR_RET(*dev->dev_ops->dev_infos_get);
 552         (*dev->dev_ops->dev_infos_get)(dev, dev_info);
 553
 554         dev_info->driver_name = dev->device->driver->name;
 555 }
 556
 557 int __rte_experimental
 558 rte_compressdev_private_xform_create(uint8_t dev_id,
 559                 const struct rte_comp_xform *xform,
 560                 void **priv_xform)
 561 {
 562         struct rte_compressdev *dev;
 563         int ret;
 564
 565         dev = rte_compressdev_get_dev(dev_id);
 566
 567         if (xform == NULL || priv_xform == NULL || dev == NULL)
 568                 return -EINVAL;
 569
 570         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->private_xform_create, -ENOTSUP);
 571         ret = (*dev->dev_ops->private_xform_create)(dev, xform, priv_xform);
 572         if (ret < 0) {
 573                 COMPRESSDEV_LOG(ERR,
 574                         "dev_id %d failed to create private_xform: err=%d",
 575                         dev_id, ret);
 576                 return ret;
 577         };
 578
 579         return 0;
 580 }
 581
 582 int __rte_experimental
 583 rte_compressdev_private_xform_free(uint8_t dev_id, void *priv_xform)
 584 {
 585         struct rte_compressdev *dev;
 586         int ret;
 587
 588         dev = rte_compressdev_get_dev(dev_id);
 589
 590         if (dev == NULL || priv_xform == NULL)
 591                 return -EINVAL;
 592
 593         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->private_xform_free, -ENOTSUP);
 594         ret = dev->dev_ops->private_xform_free(dev, priv_xform);
 595         if (ret < 0) {
 596                 COMPRESSDEV_LOG(ERR,
 597                         "dev_id %d failed to free private xform: err=%d",
 598                         dev_id, ret);
 599                 return ret;
 600         };
 601
 602         return 0;
 603 }
 604
 605 const char * __rte_experimental
 606 rte_compressdev_name_get(uint8_t dev_id)
 607 {
 608         struct rte_compressdev *dev = rte_compressdev_get_dev(dev_id);
 609
 610         if (dev == NULL)
 611                 return NULL;
 612
 613         return dev->data->name;
 614 }
 615
 616 RTE_INIT(rte_compressdev_log);
 617
 618 static void
 619 rte_compressdev_log(void)
 620 {
 621         compressdev_logtype = rte_log_register("lib.compressdev");
 622         if (compressdev_logtype >= 0)
 623                 rte_log_set_level(compressdev_logtype, RTE_LOG_NOTICE);
 624 }