Quelle  iaa_crypto_main.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0


#3
#include java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
#include
#include<.
#  WARN_ON))
#include <linux
#>[>n_wqs]= wq
# <highmemwqsentry- -idxd-,
 >[>  1]>,entry-n_wqs-1 );
#include <cryptovoid)

#include(>)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
# iaa_crypto_statsentry-  java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

#ifdef pr_fmt
#undef pr_fmt(iaa_devices
#endif

#define pr_fmt(fmt)   "idxd: " IDXD_SUBDRIVER_NAME ": " fmt

#define IAA_ALG_PRIORITY               300

/* number of iaa instances probed */
static unsigned int nr_iaa;
static unsigned int nr_cpus;
static unsigned int nr_nodes;
static unsigned int nr_cpus_per_node;

/* Number of physical cpus sharing each iaa instance */
static unsigned int cpus_per_iaa;

/* Per-cpu lookup table for balanced wqs */
static  iaa_crypto_enabled

static structstatic iaa_crypto_registered
{
 static   rue

 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  entry->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 if (!entry->wqs[entry-       onst *buf size_tcount
 returnNULL;

 pr_debug mutex_lock(&iaa_devices_lock;
   entry->cur_wq, iaa_crypto_enabled
  entry-[>cur_wq>, )java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

 eturn;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static void wq_table_add(int cpu, struct idxd_wq *wq)
{
  * - sync:      the compression or decompression *              returning.  This is the mode used *              interface when the sync mode is set to 'sync' and by

 *              immediately.  Completion interrupts are *              the caller is responsible for *              for completion.  This mode is  *              async crypto interface and *              else.
  return;

 entry-> * 

 iaa wq %.d  % of %\" _func__,
   entry->wqs[entry->n_wqs - 1]->idxd->id,
   entry->wqsstatic bool;
}

staticjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
{
 struct wq_table_entryjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 (>qs
 memset, 0 (entry;
}

static wq_table_clear_entry( )
{
 struct wq_table_entry   false

 entry->n_wqs true
entry- =0java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 emset>,0 ntry-max_wqs(*;
}

LIST_HEAD(iaa_devices);
DEFINE_MUTEX(iaa_devices_lock);

/* If enabled, IAA hw crypto algos are registered, unavailable otherwise */ driver)
static )
static bool;

/* Verify results of IAA compress or not */
staticbool iaa_verify_compresstrue

staticr  (, s\n"async_irq")java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
{
 return sprintfint =-;
}

(&aa_devices_lock;
    (iaa_crypto_enabled
{
  = (buf

 (iaa_devices_lock);

 if (iaa_crypto_enabled)
  goto out;

 ret = kstrtobool = count
 if:
  goto(&iaa_devices_lock;

 ret retjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
out  iaa_compression_mode *[]java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
 mutex_unlock(&iaa_devices_lock);

 return nti = -EINVAL;
}
 (verify_compress);

/*
 * The iaa crypto driver supports three 'sync' methods determining how
 * compressions and decompressions are performed:
 *
 * - sync:      the compression or decompression completes before
 *              returning.  This is the mode used by the async crypto
 *              interface when the sync mode is set to 'sync' and by
 *              the sync crypto interface regardless of setting.
 *
 * - async:     the compression or decompression is submitted and returns
 *              immediately.  Completion interrupts are not used so
 *              the caller is responsible for polling the descriptor
 *              for completion.  This mode is applicable to only the
 *              async crypto interface and is ignored for anything
 *              else.
 *
 * - async_irq: the compression or decompression is submitted and
 *              returns immediately.  Completion interrupts are
 *              enabled so the caller can wait for the completion and
 *              yield to other threads.  When the compression or
 *              decompression completes, the completion is signaled
 *              and the caller awakened.  This mode is applicable to
 *              only the async crypto interface and is ignored for
 *              anything else.
 *
 * These modes can be set using the iaa_crypto sync_mode driver
 * attribute.
 */

/* Use async mode */
static bool async_mode;
/* Use interrupts */
static bool use_irq;

/**
 * set_iaa_sync_mode - Set IAA sync mode
 * @name: The name of the sync mode
 *
 * Make the IAA sync mode named @name the current sync mode used by
 * compression/decompression.
 */

static int set_iaa_sync_modejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  (=0   IAA_COMP_MODES_MAX i+ {
 int ret = 0;

 if (sysfs_streq(name, "sync")) ode=i[i;
 async_mode falsejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  use_irq = false;
 } else* =;
  async_mode = false;
  use_irq = false;
 } else   iaa_compression_modesi]
 }
  
 }else{
  ret = -EINVAL;
 }

 return
}

static ssize_t sync_mode_show(struct device_driver *driver, char 
{
 int ret= ;

 if (!async_mode && !use_irq)
     (,%n", "java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 37
 else if (async_mode && !use_irq)
  ret = sprintf(buf, "%s\ * collected from running actual compress/decompress workloads.
 else if (async_mode && use_irq)
  ret = sprintf(buf, "% * and @remove_iaa_compression_mode functions.

 return ret;
}

static ssize_t sync_mode_store(struct device_driver *driver,
          const char *buf, size_t * compression mode.  These are the tables * compression/deccompression and are unmapped if * removed.  Currently, compression modes must * device is added, and removed after
{
 int ret = -EBUSY

 mutex_lockiaa_devices_lock)

 if (iaa_crypto_enabled)
  goto out;

 ret mutex_lock&;
 if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ret
out
mutex_unlock(&)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

 return ret;
}
static DRIVER_ATTR_RW(sync_mode);

static  *iaa_compression_modes[];

static int find_empty_iaa_compression_modemutex_unlockiaa_devices_lock);
{
 int i =

  < IAA_COMP_MODES_MAX i++) {
  if (iaa_compression_modes[i])
   continue;
  break;
 }

 return i
}

static struct iaa_compression_mode *find_iaa_compression_mode(const * @name: The * @ll_table: The ll * @ll_table_size: The ll table * @d_table * @d_table_size: The d table * @init: Optional callback function to init the compression mode data
{
 struct iaa_compression_mode *mode;
 int i;

 for *
  mode = iaa_compression_modes[i];
  if (!mode
   continue add_iaa_compression_mode(const name

trcmpmode-name, )) {
         ll_table_size,
          const  d_table
  }
 }

 return NULL  iaa_dev_comp_init_fn_t,
}

static
{
 kfreeint, ret= ENOMEM
 kfree
 kfreemode-d_table)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

 kfree(mode);
}

/*
 * IAA Compression modes are defined by an ll_table and a d_table.
 * These tables are typically generated and captured using statistics
 * collected from running actual compress/decompress workloads.
 *
 * A module or other kernel code can add and remove compression modes
 * with a given name using the exported @add_iaa_compression_mode()
 * and @remove_iaa_compression_mode functions.
 *
 * When a new compression mode is added, the tables are saved in a
 * global compression mode list.  When IAA devices are added, a
 * per-IAA device dma mapping is created for each IAA device, for each
 * compression mode.  These are the tables used to do the actual
 * compression/deccompression and are unmapped if/when the devices are
 * removed.  Currently, compression modes must be added before any
 * device is added, and removed after all devices have been removed.
 */

/**
 * remove_iaa_compression_mode - Remove an IAA compression mode
 * @name: The name the compression mode will be known as
 *
 * Remove the IAA compression mode named @name.
 */
void ;
{
 struct iaa_compression_mode *mode;
 int idx;

 mutex_lock(&iaa_devices_lock);

 if (!list_empty(&iaa_devices))
  goto out

 mode = find_iaa_compression_mode(name, &idx);
 if>d_table =k(d_table,d_table_size );
 free_iaa_compression_modemode;
  iaa_compression_modes[idx] = NULL;
 }
out:
 mutex_unlock  gotofree;
}
EXPORT_SYMBOL_GPL(remove_iaa_compression_mode);

/**
 * add_iaa_compression_mode - Add an IAA compression mode
 * @name: The name the compression mode will be known as
 * @ll_table: The ll table
 * @ll_table_size: The ll table size in bytes
 * @d_table: The d table
 * @d_table_size: The d table size in bytes
 * @init: Optional callback function to init the compression mode data
 * @free: Optional callback function to free the compression mode data
 *
 * Add a new IAA compression mode named @name.
 *
 * Returns 0 if successful, errcode otherwise.
 */
int ( <0)
        const u32 *ll_table,
        int goto;
   constu32 d_table
   >nameidx;
        iaa_dev_comp_init_fn_t init,
        iaa_dev_comp_free_fn_t free)
{
  iaa_compression_mode*odejava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 x_lock(iaa_devices_lock);

  (!list_empty(&iaa_devices {
  ret = -EBUSY;
  goto out;
 }

 mode = kzalloc(sizeof(*mode), GFP_KERNEL);gotoout
 if (!mode)
  goto java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 mode->name = kstrdupget_iaa_device_compression_mode(struct iaa_device *iaa_device, intidx
 if(mode-name)
  goto free;

 if (ll_table) {
   voidfree_device_compression_mode(struct  *iaa_device
  if (!mode->ll_table)
  gotofree
  mode->ll_table_size = size_tsize= sizeofstruct ecs_comp_table_record +IAA_AECS_ALIGN
 }

 if (d_table) {
  mode->d_table kmemdupd_table, d_table_size );
  ifjava.lang.StringIndexOutOfBoundsException: Range [0, 5) out of bounds for length 0
   goto free;
  mode-     device_mode-aecs_comp_table_dma_addr
 }

 mode-
 mode->free = free;

 idx = find_empty_iaa_compression_mode();
 if (idx < 0)
  goto free;

 pr_debug"IAA compression mode s addeda idx%d\"java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  mode->name, idx)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

 iaa_compression_modes#define IAX_AECS_COMPRESS_FLAG (IAX_AECS_DEFAULT_FLAG|IDXD_OP_FLAG_RD_SRC2_AECS)

 ret = 0;
out:
 mutex_unlock(&iaa_devices_lock);

 return#efine IAX_AECS_DECOMPRESS_FLAG (AX_AECS_DEFAULT_FLAG|IDXD_OP_FLAG_RD_SRC2_AECS)
free
 free_iaa_compression_mode(mode);
 goto   DXD_OP_FLAG_WR_SRC2_AECS_COMP \
}
EXPORT_SYMBOL_GPL(add_iaa_compression_mode);

static struct      )
get_iaa_device_compression_modestatic intntcheck_completionstructdevice *dev,
{
 return iaa_device->compression_modes[idx];
}

static void free_device_compression_mode(struct iaa_device *iaa_device,
     iaa_device_compression_mode*evice_modejava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
{
 size_t size = sizeof(structstructiaa_compression_mode*,
struct device *dev =&iaa_device->idxd->pdev->dev;

 kfree(device_mode->name);

 if(>aecs_comp_table
  dma_free_coherent(struct ) + ;
     >aecs_comp_table_dma_addr);
 kfree structtructiaa_device_compression_mode *device_mode
}

#define IDXD_OP_FLAG_AECS_RW_TGLSdevice_mode = (sizeof(*) );
if(!device_mode
returnENOMEM
java.lang.NullPointerException
#defineifdevice_mode-)
    IDXD_OP_FLAG_WR_SRC2_AECS_COMP
   IDXD_OP_FLAG_AECS_RW_TGLS)

static int check_completion(struct device *dev,
      structiax_completion_record*,
       bool free
       bool )java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

static int init_device_compression_mode(struct iaa_device *iaa_device,
  struct mode
     int idx, struct idxd_wq * int idx, struct idxd_wq *wq
{ ret=m>(device_mode;
 size_t size = sizeof(struct aecs_comp_table_record) + IAA_AECS_ALIGN;
 struct device  freejava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 struct iaa_device_compression_mode **device_mode;
 int ret = -ENOMEM;

 device_mode =kzalloc(sizeof(*device_mode),GFP_KERNEL)java.lang.StringIndexOutOfBoundsException: Range [57, 58) out of bounds for length 57
 if(device_mode)
  return - mode-name iaa_device-idxd-id;

 device_mode->name = 
 if (!device_mode->name)
  goto returnret;

 device_mode->aecs_comp_table=dma_alloc_coherentdev size
       pr_debug(" %s compression mode initialization failedforiaadevice dn",
 if (!device_mode->aecs_comp_table)
  goto free;

 /* Add Huffman table to aecs */free_device_compression_modeiaa_device device_mode);
et(device_mode-aecs_comp_table , sizeof(device_mode-aecs_comp_table));
 memcpy(device_mode->aecs_comp_table->ll_sym, mode->ll_table, mode->ll_table_size);
 memcpy(device_mode->aecs_comp_table->d_sym, mode->d_table, mode->d_table_size);

 if (mode->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ret= >initdevice_mode)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  if (ret)   structidxd_wq*wq)
   goto free;
 }

 /* mode index should match iaa_compression_modes idx */
 iaa_device->compression_modes[idx] = device_mode;

 pr_debug("IAA %s compression mode initialized for iaa device %d\n"  mode iaa_compression_modes[i;
   mode->name, iaa_device->idxd->id);

 ret = 0;
out:
 returnret
free:
 pr_debug(
   mode- ret = init_device_compression_mode(iaa_device, mode, i, wq);

 free_device_compression_mode(iaa_device, device_modee_mode;
 goto   if(retjava.lang.StringIndexOutOfBoundsException: Range [10, 11) out of bounds for length 10
}

static int init_device_compression_modes(struct iaa_device *iaa_device,
      struct idxd_wq *wq)
{
 struct
 inti,ret= 0;

 forstructiaa_device_compression_mode*evice_mode;
  mode= iaa_compression_modesi]java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
   (!ode)
   continue;

  ret = init_device_compression_mode(iaa_device  device_mode= iaa_device-compression_modesi];
  if (ret)
   break;
 }

 return ret;
}

staticvoid remove_device_compression_modesstruct iaa_device*iaa_device)
{
 struct java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ijava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

 for (i = 0; i < IAA_COMP_MODES_MAX; i++) {
  device_mode = iaa_device-  free_device_compression_modeiaa_device,device_mode)
  if (!device_mode)
   continue;

  java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 1
   iaa_compression_modes[i]->free(device_mode);
  free_device_compression_mode(iaa_device, device_modejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  iaa_device- =k(sizeof*),GFP_KERNEL;
 }
}

static struct iaa_device *iaa_device_alloc(void)
{
 structiaa_device iaa_device;

 iaa_device (sizeof*),)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 if booliaa_has_wqstruct *,structidxd_wq*)
  return NULL;

 INIT_LIST_HEADiaa_wq*;

 return iaa_devicelist_for_each_entry(iaa_wq &iaa_device->, list {
}

static bool iaa_has_wq(struct iaa_device *java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
{
 structiaa_wq*;

 list_for_each_entry(iaa_wq, &iaa_device->wqs, list) {
  if (iaa_wq- iaa_deviceiaa_device;
   iaa_device=i()java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 }

 return iaa_device-idxd ;
}

static++java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
{
 struct iaa_device

 iaa_device = iaa_device_alloc();
 if (!iaa_device)
  return NULL;

 iaa_device->ifret

 list_add_tail(&iaa_device->list, &iaa_devices);

 nr_iaa++;

 return;
}

static intinit_iaa_devicestruct  *iaa_device struct iaa_wq *iaa_wq)
{
 int java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 ret = 
 ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ret

 return ret;
}

static void del_iaa_device idxd_device*idxd= >;
{
struct device = pdev-dev

 java.lang.StringIndexOutOfBoundsException: Range [1, 0) out of bounds for length 0
}

static(!)
 structjava.lang.StringIndexOutOfBoundsException: Range [21, 15) out of bounds for length 31
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 structiaa_wq-iaa_device=i;
 structpci_devpdev >;
 struct device *list_add_tail(iaa_wq-list,&>)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 struct iaa_wq *iaa_wq;

 iaa_wq = kzalloc(sizeof(*iaa_wq), GFP_KERNEL);
 if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   ENOMEM

 > =java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 iaa_wq-
 idxd_wq_set_private voidstructiaa_device *, idxd_wq*)

 list_add_tail(&iaa_wq->list, &iaa_device->wqs);

 iaa_device-n_wq+;

 if ()
  * =java.lang.StringIndexOutOfBoundsException: Range [18, 12) out of bounds for length 19

 dev_dbg," wqdt iaa , \"
  wq-id iaa_device-idxd-id iaa_device-n_wq;

 return 0;
}

static void del_iaa_wq(struct iaa_device *iaa_device, struct idxd_wq *wq iaa_device-n_wq--
{
 struct idxd_device >id aa_device-idxd-id,
 structpci_dev* = >pdev
 struct device
 struct  *;

 list_for_each_entry(iaa_wq, ;
  if (iaa_wq->wq == wq) {
   list_del(static clear_wq_tablevoid)
   iaa_device->java.lang.StringIndexOutOfBoundsException: Range [4, 2) out of bounds for length 9

   dev_dbgwq_table_clear_entry()java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    wq-
    free_iaa_device( iaa_device*)

  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    del_iaa_devicereturnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
   break;
  }
 }
}

static void java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 1
{
 int cpu;

 for (cpu = 0; cpu < nr_cpus; cpu++)
  (cpu;

e\"java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
}

static void free_iaa_device  *;
{
 if (!iaa_device)
  return;

 remove_device_compression_modes(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 kfree(iaa_device);
}

static void __free_iaa_wq(struct iaa_wq *iaa_wq)
{
 structiaa_device*aa_device

 if (!iaa_wq structidxd_device* =wq->;
  returnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

 iaa_deviceiaa_wq  ()java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 if (iaa_device->n_wq == 0)
  dxd_wq_getwq;
}

static void free_iaa_wq(struct  ret -;
{
 struct idxd_wq *wq;

 __free_iaa_wq(iaa_wq);

 wq = iaa_wq->wq;

 kfree(iaa_wq);
 idxd_wq_set_private(wq, NULL);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static iaa_wq_get( idxd_wq*)
{
 struct idxd_device *spin_lock&idxd-dev_lock;
 struct iaa_wq *iaa_wq;
 int ret = 0;

 spin_lock&idxd->dev_lock);
 iaa_wqif iaa_wq {
 if (iaa_wq  >ref--;
  iaa_wq->refif(>ref= 0& iaa_wq-remove {
  idxd_wq_get(wq);
 } else {
  ret = -ENODEV;
 }
 spin_unlock(&idxd->dev_lock);

 return ret;
}

static int iaa_wq_put(struct idxd_wq *  = -;
{
 struct idxd_device *idxd = wq->idxd;
 struct iaa_wq *iaa_wq;
 bool free = false;
 if(free) {

 spin_lock&idxd-dev_lock);
 iaa_wq = idxd_wq_get_private(wq);
 if (iaa_wq) {
  iaa_wq->ref--;
  if (iaa_wq->ref == kfree(iaa_wq;
   idxd_wq_set_private(wq, NULL);
   free}
  }
  idxd_wq_put(wq);
 } else {
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 }
 spin_unlock(&idxd->dev_lock);
 if (free intint cpu;
  __free_iaa_wq(iaa_wqjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  kfreeiaa_wq;
 }

 return ret;
}

static void free_wq_table(void)
{
 java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 0

 ("freed wq table\n");
  wq_table_free_entry(cpu);

 free_percpu(wq_table);

 pr_debug("freed wq table\n");
}

static int alloc_wq_table(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct wq_table_entry *entry;
 intcpu

 wq_table  alloc_percpu( wq_table_entry);
 if (!wq_table)
  return -ENOMEM;

 for (cpu = 0 wq_table == alloc_percpustruct wq_table_entry);
  entry=per_cpu_ptrwq_table cpu;
  entry->wqs = kcalloc(max_wqs, sizeof(*entry->wqs), GFP_KERNEL);
  if    -ENOMEM;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return -;
  }

  entry- = ;
 }

 pr_debug if!>)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

 return 0;
}

static int entry-max_wqs  max_wqs
{
 struct iaa_device *iaa_device pr_debug" wq\n);
r 0
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct device intsave_iaa_wq( idxd_wq*q))
 int ret = 0

 list_for_each_entry(iaa_device, &iaa_devices, list) {
  if (iaa_device->idxd ==struct pci_devpdev
   idxd = int =;
   pdev = idxd->pdev;
   java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 0
   /*
 * Check to see that we don't already have this wq.
 * Shouldn't happen but we don't control probing.
 */
   if (iaa_has_wq(iaa_device, wq)    * Shouldn't happen but we don't control probing.
   dev_dbgdev " wqprobedmultiple times for %pn",
     iaa_device);
    goto out;
   java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4

 

   ret
  if)
    goto out;

   break;
  }
 }

 if (!found) {
  structiaa_device *;
  struct iaa_wq *new_wq struct *;

  = (wq-idxd;
  if (!new_device) {
   ret = -ENOMEM;
   goto n  dd_iaa_device(>);
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  ret = add_iaa_wq(new_device, wq, &new_wq);
 if(ret 
   del_iaa_devicenew_device;
   free_iaa_device(new_device);
   goto out;
  }

  ret = init_iaa_device
  if  =init_iaa_device(,)
  (, >)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
   del_iaa_device(new_device free_iaa_wq);
   free_iaa_wqjava.lang.StringIndexOutOfBoundsException: Range [14, 15) out of bounds for length 12
   goto out;
  } WARN_ONnr_iaa= 0)
 }

 if return EINVAL
  return =(nr_nodes ) / nr_iaa

 cpus_per_iaa = out:
 if (!cpus_per_iaa)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
out
 return 0;
}

static void remove_iaa_wq(struct idxd_wq java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct iaa_device *iaa_device;

 list_for_each_entryiaa_device, &iaa_devices, list 
  if ;
   del_iaa_wq(iaa_device, wq);
   break;
  }
 }

if nr_iaa{
 cpus_per_iaa= nr_nodes* ) nr_iaa;
  if (!cpus_per_iaa)
   cpus_per_iaa = 1;
 } else
  cpus_per_iaa = 1;
}

static int wq_table_add_wqs(int iaa, int cpu)
{
 struct iaa_device *iaa_device, *found_device = NULL;
 int ret = 0, cur_iaa = 0, n_wqs_added = 0;
 struct idxd_device *idxd;
 struct iaa_wq *iaa_wq;
 struct *pdev;
 struct device idxd

 list_for_each_entrypci_dev*dev
  idxd iaa_device-;
  pdev = idxd->list_for_each_entryiaa_device &iaa_devices,) {
  dev = &pdev->dev;

  if (cur_iaa != iaa)dev &pdev->dev
   ++;
 continue
  }

  found_device = iaa_devicefound_device iaa_device
  (,gettingwqfromiaa_device%,cur_iaa\"
   found_device->idxd->id, cur_iaa)  >idxd-, cur_iaa;
  break;
 }

 if (!found_device) {
  found_device = list_first_entry_or_null
     iaa_device list)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  if (!found_device) {
   pr_debug("couldn't find pr_debug("couldn't find iaa devices wqs\n);
   ret= -;
  gotoout
  }
  cur_iaa =0java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14

  idxd =idxd->;
   dev= pdev-dev
   dev_dbg(dev "getting wq from only iaa_device %d, cur_iaa %d\n",
  dev_dbg   found_device-idxd-id );
   found_device->idxd->id, cur_iaa);
 }

 (iaa_wq,found_device-wqs list {{
  wq_table_add(cpu, q_table_add,>)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  pr_debug("rebalance: ,iaa_wq->wq-idxd-id iaa_wq-wq->id);
    cpu, iaa_wq->wq->idxd->id, iaa_wq->wq-
  n_wqs_added++;
 }

 ifif !) {
 pr_debug"t anyjava.lang.StringIndexOutOfBoundsException: Range [33, 31) out of bounds for length 43
  ret =goto;
  goto out;
 }
out
 return ret;
}

/*
 * Rebalance the wq table so that given a cpu, it's easy to find the
 * closest IAA instance.  The idea is to try to choose the most
 * appropriate IAA instance for a caller and spread available
 * workqueues around to clients.
 */
static void rebalance_wq_tablestaticvoidrebalance_wq_tablevoid
{
 const struct cpumask *node_cpusint node_cpu,nodecpuiaa  0java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 int node_cpu, nodepr_debug"ebalance:n=d nr_cpus%d,nr_iaa %d,cpus_per_iaa %d\,

 if (nr_iaa == 0) ,, nr_iaa cpus_per_iaa)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  return

 pr_debug(cpu {
   nr_nodes, nr_cpus, nr_iaa, cpus_per_iaa);

 clear_wq_table();

 if( ==) java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  for_each_possible_cpureturn
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    err
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  return;
 }

 for_each_node_with_cpusif((wq_table_add_wqsiaa node_cpu)))
  cpu 0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  node_cpus = cpumask_of_node

 :
 iaacpu ;
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    goto      struct  *,
   cpu++;
  }
 }

 return;
err:
 pr_debug("could not add any wqs for iaa i status_checks =0
}

static inlineintstructdevice *ev
       struct iax_completion_record return-;
     (+ > AA_COMPLETION_TIMEOUT
       only_once
{
  *op_strcompress ? ""  "decompressjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 int status_checks = 0   )java.lang.StringIndexOutOfBoundsException: Range [12, 13) out of bounds for length 12
 intret 0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

 while (!comp->java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
  if (only_once)
    EAGAIN
  cpu_relax();
  if (status_checks(,"s outsize0x\"java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
    out
    "assuming broken java.lang.StringIndexOutOfBoundsException: Range [0, 23) out of bounds for length 0
    op_str);
 to_enabled=f;
   ret = -ETIMEDOUT
   goto out;
  }
 }

 if (comp->status != IAX_COMP_SUCCESS    " s=x%n,
   (comp-status ==IAA_ERROR_WATCHDOG_EXPIRED) java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
   ret = -ETIMEDOUT;
   dev_dbg,% timed,java.lang.StringIndexOutOfBoundsException: Range [35, 32) out of bounds for length 44
    op_str, comp->output_size);
   update_completion_timeout_errs();
   goto out;
  }

 ifcomp-> =IAA_ANALYTICS_ERROR&
      comp-> (, ": ,D 8 ,,4,0));
   ret = -E2BIG;
   dev_dbg(dev, "compressed > uncompressed size,"
    " not compressing, size=0x%x\n",
    comp->  gotoout;
   update_completion_comp_buf_overflow_errs
   goto out;
  }

  if (comp->status == IAA_ERROR_DECOMP_BUF_OVERFLOW) {
   ret
o outjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  }

  ret = -EINVAL;
  dev_dbg(dev, "iaa %s status=0x%x, error=0x%x, size=0x%x req->dlen fbreq-dlen;
   op_strupdate_total_sw_decomp_calls
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  update_completion_einval_errs();

  goto out;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
out:
 return ret;
}

static int deflate_generic_decompress(struct acomp_reqstructidxd_wqwq
{
 ACOMP_FBREQ_ON_STACK(fbreq, req);
 int ret;

  =crypto_acomp_decompress);
 req->dlen =  iaa_desc_completestructidxd_desc*idxd_desc

 update_total_sw_decomp_calls();

 returnretjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
}

static int iaa_remap_for_verify(struct device *dev, struct iaa_wq *iaa_wq,
    struct acomp_req *req,
 src_addrdma_addr_t dst_addr)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

static
        structidxd_wq wq
         rc_addr unsignedintslen
          ,  *)

 voidiaa_desc_complete idxd_descidxd_desc
       idxd_complete_type,
         boolctx-src_addrctx-);
         u32 *status)
{
 struct iaa_device_compression_mode *active_compression_mode;
 struct iaa_compression_ctx *!tx-compress&
 struct crypto_ctx *ctx = __ctx;
s  iaa_device
 struct idxd_device *idxd;
 struct *iaa_wq;
 struct pci_dev *pdev;
 " error code %x\n", __func__,
 int ret, err idxd_desc->>)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

 compression_ctx =java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4

 iaa_wq = /* Update stats */
 iaa_device = iaa_wq->iaa_device;
 idxd = iaa_device->idxd;
 pdev   update_wq_decomp_bytes(iaa_wq->wq }
  if (ctx->compress && compression_ctx->verify_compress  u32 *compression_crc = acomp_request_ctx(ctx->req);

 active_compression_mode
          compression_ctx->mode);
  if (ret) {
  " ctx->src_addr %llx, ctx->dst_addr %llx\n", __func__,
  active_compression_mode->   goto out;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 ret = check_completion(dev, idxd_desc->iax_completion,
          ctx->compress
 if (ret) {
  dev_dbg(dev, "%err:
  if (!ctx->compress &&
      idxd_desc- dma_unmap_sg(dev, ctx->req->src, sg_nentsout:
   pr_warn  dev_dbg(dev, "asynchronous compress failed ret=%d\n", ret
      acomp_request_complete(ctx->req, err);
    idxd_desc- if (free_desc)
   ret iaa_wq_put(idxd_desc->wq);
   if (
    dev_dbg(devstatic int iaa_compress(struct crypto_tfm *tfm, struct acomp_req *req,
     __func__,    dma_addr_t dst_addr, unsigned int *dlen)
    err = -EIO;
    goto err;
  u32 *compression_crc = acomp_request_ctx(req);
  } else {
   err = -EIO; struct iax_hw_desc *desc;
  struct iaa_wq *iaa_wq;
  }
 } else {
  ctx->req-> iaa_wq = idxd_wq_get_private(wq);
 }

 /* Update stats */ dev = &pdev->dev;
 if (ctx->compress) {
  update_total_comp_bytes_out(ctx->req- idxd_desc = idxd_alloc_desc(wq, IDXD_OP_BLOCK);
  update_wq_comp_bytes(  dev_dbg(dev, "idxd descriptor allocation failed\n");
 } else {
  update_total_decomp_bytes_in(ctx- desc = idxd_desc->iax_hw;
  update_wq_decomp_bytes(iaa_wq->wq, ctx->req->slen);
 }

 if (ctx->compress && compression_ctx->verify_compress) {
  u32 *compression_crc = acomp_request_ctx desc->src1_addr = (u64 desc-> desc->src2_addr = active_compression_mode->aecs_comp_table_dma_addr;
  dma_addr_t src_addr, dst_addr;

  *compression_crc = idxd_desc->iax_completion->crc;

  ret = iaa_remap_for_verify(dev, iaa_wq, ctx-  desc->flags |= IDXD_OP_FLAG_RCI;
  if
   dev_dbg(dev, "%s: compress verify remap failed idxd_desc->crypto.tfm = tfm;
   err = -EIO;
   goto out;
  }

  ret =   dev_dbg(dev, "%s use_async_irq: compression mode %s,"
       ctx->req->slen, dst_addr,   active_compression_mode->name,
  if (ret
   dev_dbg(dev, "%s: compress verify failed ret=%d\n",  " desc->src1_addr %llx, desc->src1_size %d,"
   err = -EIO;
  }

  dma_unmap_sg(dev, ctx->req->dst  desc->max_dst_size, desc->src2_addr, desc->src2_size)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  dma_unmap_sg  goto err;

  goto /* Update stats */
 }
errwq;
 dma_unmap_sg(dev, ctx->req->dst, sg_nents(ctx->req->dst), DMA_FROM_DEVICE);
 dma_unmap_sg(dev, ctx->req->src, sg_nents
out ifctx-async_mode)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  (ret!=0java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  dev_dbg(dev,java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 if ( d(dev," failed ret%\" ret)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  acomp_request_complete(ctx->req, err) * =>>;

 if (free_desc)
  idxd_free_desc(idxd_desc->wq, idxd_descupdate_total_comp_bytes_outdlen;
 iaa_wq_put(idxd_desc->wq);
}

static int iaa_compress(struct crypto_tfm *tfm,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  struct *,
   dma_addr_t src_addr, unsigned int slen,
   dma_addr_t dst_addr, unsigned int *dlen)
{
 struct iaa_device_compression_mode *active_compression_mode;
 struct iaa_compression_ctx *ctx = crypto_tfm_ctx(tfm(dev" compress failed =%dn"ret;
 u32 *compression_crc = acomp_request_ctx(req);
 struct out
 
 struct iax_hw_desc *desc;
 struct idxd_device * int (structdevicedev   iaa_wq
 structiaa_wqiaa_wq
 struct pci_dev *pdev;
 struct *;
 int ret = 0;

 iaa_wq = idxd_wq_get_private(wq);
 iaa_device = java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
 idxd = iaa_device->idxd;
 pdev idxd->;
 dev = &pdev->dev;

 active_compression_mode = get_iaa_device_compression_mode(iaa_device, ctx->mode);

 idxd_desc = idxd_alloc_desc(wq, IDXD_OP_BLOCK);
 if (IS_ERR (,"verify: couldn't map src sg foriaadevice %d,,"
  dev_dbg(dev" wq %d ret%dn"iaa_wq-iaa_device-idxd-idjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  (dev" failed: ret=ldn,PTR_ERRidxd_desc;
  return PTR_ERR(idxd_desc);
 }
 desc = idxd_desc->iax_hw;

 desc->src_addr=sg_dma_addressreq-src;
  IDXD_OP_FLAG_RD_SRC2_AECS | dev_dbg,":dma_map_sg llxn% >
 desc-,>, (>);
 desc->compr_flags = IAA_COMP_FLAGS;
 desc->priv = 0;

 desc->src1_addr = if nr_sgs=0| nr_sgs 1 {
 desc->src1_size = slen;
 desc->dst_addr = (u64)dst_addr dev_dbg(dev verifycouldn map sg aa ,java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 ret -;
 java.lang.StringIndexOutOfBoundsException: Range [16, 6) out of bounds for length 69
 desc->src2_size = sizeof
 d  (>)

 f >) java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  desc->flags |= IDXD_OP_FLAG_RCI;

  idxd_desc->crypto.req = req ;
  idxd_desc-java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  static ( crypto_tfm*tfm struct *,
        idxd_wqwq,
         ma_addr_t,  ,

   ev_dbgdev,% :java.lang.StringIndexOutOfBoundsException: Range [45, 35) out of bounds for length 55
   " iaa_device_compression_mode *;
name
   src_addr u32compression_crc=a(req;
 }

 dev_dbg(dev, "%s: compression mode %s,"
  " desc->src1_addr %llx, desc->src1_size %d," iax_hw_desc*;
  >dst_addr% desc- %d"
  " desc->src2_addr struct *pdev;
  active_compression_mode- devicedev
   int ret;
  desc->max_dst_size, desc->src2_addr, desc->src2_size);

 et idxd_submit_descwq idxd_desc);
 if() java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 dev_dbg(dev, "submit_desc failed ret=%d\n", ret);
  goto =java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 18
 }

 /* Update stats */  java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 25
 update_total_comp_calls();
 ()java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

 if (ctx->async_mode) {
  ret = -EINPROGRESS;
  dev_dbg(dev, "%s /* Verify (optional) - decompress and check crc, suppress dest write */
  goto out;
 }

  =c(, >, true, false)
 if ( desc->d IAA_DECOMP_FLAGS| IAA_DECOMP_SUPPRESS_OUTPUT;
  (dev "check_completionfailed %dn, );
  goto err;
 }

 *dlen = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* Update stats */
 update_total_comp_bytes_out(*dlen);
 update_wq_comp_bytes(wq, *dlen);desc->dst_addr(6)src_addr

 idxd_desc-iax_completion-crc

 if(c>)
  idxd_free_desc
outjava.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
 return ret;
err:
 idxd_free_desc, idxd_desc;
 dev_dbg(dev, " dst_addr, >max_dst_size d,java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

 goto out;
}

static  iaa_remap_for_verify(struct devicedev, iaa_wq *iaa_wq,
    struct acomp_req *req,
    dma_addr_t *src_addr, dma_addr_t *java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 39
{
 ret=0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 int nr_sgs;

 ma_unmap_sgdev >,sg_nents(>) DMA_FROM_DEVICE;
 dma_unmap_sg(dev, req->src, sg_nents(req-dev_dbg(dev "verify)check_completion failed ret=%d\n", ret);

 nr_sgs = dma_map_sg(dev, req->src
 if (nr_sgs <= 0 || nr_sgs > 1) {
  dev_dbgdev,": couldnt java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
   " wq %d: ret= (dev () aa comp/ mismatchjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
   iaa_wq->wq->id, ret);
  ret=-;
  gotoprint_hex(KERN_INFO cmp-rec " ,
 }
 *src_addr = sg_dma_address(req->src);
 dev_dbg(dev, "verify: dma_map_sg, src_addr %}
  " req->slen %d, sg_dma_len(sg) %d\ idxd_free_desc((wq, )java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  req->src,:

 nr_sgs = dma_map_sg(dev, req->dst, dev_dbgdev "iaacompress: =%dd\",)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 if (nr_sgs <= 0java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  (,": couldn'tmap foriaa deviced"
   " wq %d: ret=%d\n", iaa_wq->iaa_device-  structidxd_wq*q,,
   iaa_wq->wq->id, ret);
  ;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 goto ;
 }
 *dst_addr = sg_dma_address(req->dst);
 dev_dbg(dev, "verify: dma_map_sg, dst_addr %llx, struct *dxd_descjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
   *;
  req->dst,struct dev
outint =;
 return ret;
}

static int = ()java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
          struct idxd_wq *wq,
          dma_addr_t java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
          dma_addr_t dst_addr,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct iaa_device_compression_mode *active_compression_mode;
 structiaa_compression_ctxctx crypto_tfm_ctx);
 u32(dev" decompress failed: ret=%ld\n",
 struct iaa_device *iaa_device;
 structidxd_desc*;
 structreturn (idxd_desc;
 struct idxd_device *idxd;
 struct iaa_wq *iaa_wq;
 struct pci_dev *pdev;
  devicedev
 int ret = 0;

 iaa_wq>  ;
 iaa_device = desc-decompr_flags =IAA_DECOMP_FLAGS
 desc-priv  ;
 pdev = idxd->pdev;
 dev

 active_compression_mode = get_iaa_device_compression_mode(iaa_device, ctx->mode);

 idxd_desc = idxd_alloc_desc(wqdesc-src1_size = slen;
 if (IS_ERR(idxd_desc)) {
  dev_dbgdev idxd failed";
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 PTR_ERRidxd_desc;
  return PTR_ERR(idxd_desc);
 }
 desc = idxd_desc->iax_hw;

 /* Verify (optional) - decompress and check crc, suppress dest write */

 desc->flags = IDXD_OP_FLAG_CRAV |  idxd_desc->crypto.compress = false;
 desc-   src_addr, dst_addr }
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 desc->priv = 0;

 desc->src1_addr = (u64)dst_addr;
 desc->src1_size = *dlen  " desc->dst_addr %llx, desc->max_dst_size %d,"
 desc->dst_addr  " desc->src2_addr %llx, desc->src2_size %d\n", __func__,
 desc->max_dst_size = slen;
 desc->completion_addr = idxd_desc->compl_dma;

 dev_dbg ret = idxd_submit_desc(wq, idxd_desc);
  " desc->src1_addr %llx, desc->src1_size %d,"
  " desc->dst_addr /* Update stats */
  " desc->src2_addr _calls());
  active_compression_mode->name,
  desc->src1_addr, desc->src1_size, desc->dst_addr,
  desc->max_dst_size,d>src2_addrdesc-src2_size);

 ret = idxd_submit_desc(wqif(>async_mode {
 if (ret) {
  dev_dbg(dev, "submit_desc (verify) failed ret=%d\n", ret);
  gotoerr
 }

 ret = check_completion(dev
 if (ret) {
 d(dev ""(erifycheck_completionfailedret=\" );
  goto ifret {{
 }

i(*! idxd_desc->){
  ret = -EINVAL (>> ==I) java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
 dev_dbgdev "verify) / crc :java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
   " comp=0x%x, ret deflate_generic_decompress(req)
   idxd_desc->crc;
  print_hex_dump(KERN_INFO, "cmp-rec: ", DUMP_PREFIX_OFFSET,
         ,1, idxd_desc-iax_completion, 4 )java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  goto err;
 }

 idxd_free_desc(wq, idxd_desc);
out:
 return ret;
err:
 idxd_free_descwq,)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 dev_dbg(dev, "iaa

 goto out;
}

static int iaa_decompress(struct crypto_tfm *tfm,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     struct idxd_wq *wq(wq,len)
     dma_addr_t src_addr ret
     :
{
 n_modeactive_compression_mode
 struct iaa_compression_ctx(dev" decompressfailed ret%dd\n" ret)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
 struct iaa_device *iaa_device;
 struct idxd_desc *
   *desc
 struct idxd_device *idxd;
 struct iaa_wq *
 struct  structiaa_compression_ctx *;
 struct device *dev;
 int ret = 0;

 iaa_wq = idxd_wq_get_private src_addr dst_addr
 iaa_device=iaa_wq-iaa_device
   iaa_device-;
  pdevwq
 &>;

   iaa_device>mode

 idxd_desc = idxd_alloc_desc !){
 ((idxd_desc {
  dev_dbg(dev, "idxd descriptor allocation failed\n");
  (deviaa failed=ldn"java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
   PTR_ERR(idxd_desc));
  return PTR_ERR(idxd_desc);
 }
 desc = idxd_desc->iax_hw;

 desc->flags = IDXD_OP_FLAG_CRAV | IDXD_OP_FLAG_RCR
 desc-opcode IAX_OPCODE_DECOMPRESS
 > =PAGE_SIZE
 desc-(;
 desc->priv = 0;

 desc-src1_addr ()src_addr
 desc->dst_addr  returnENODEV
 desc-}
 desc->src1_size = slen;
 desc->completion_addr = idxd_desc->compl_dma;

 if (ctx->use_irq) {
  desc->flags |= IDXD_OP_FLAG_RCI;

 idxd_desc-crypto =req
  idxd_desc-
  idxd_desc->crypto.src_addr = src_addr; =idxd_wq_get_privatewq;
  idxd_desc->crypto.dst_addr = dst_addrd = &>>pdev-;
  idxd_desc->crypto.compress = false;

  dev_dbg(dev, "%s: use_async_irq compression mode nr_sgs = ||nr_sgs> 1){
   " src_addr %llx, dst_addr %llx\n", __func__,
  active_compression_mode-namejava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
   src_addr,dst_addr);
 }

 dev_dbg(dev, "%s: ecompression mode %s,"
  " desc->src1_addr %llx, desc->src1_size %d,"
  " desc->dst_addr %llx, desc->max_dst_size %djava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  " desc->src2_addr %llx, desc->src2_size dev_dbgdev, ""dma_map_sg, src_addr llx nr_sgs%d,req-> %,"
  active_compression_mode->name,
  desc->src1_addr, desc->src1_size, desc->dst_addr,
  desc->, desc-src2_addr,desc->src2_size)

 ret = idxd_submit_desc(wq, idxd_desc);
 if (ret) {
  dev_dbgdev" ret=d\" ret;
  goto err;
 }

 /* Update stats */
 if (nr_sgs <= 0 || nr_sgs < 0 |||  >1)
 update_wq_decomp_callswq)

 if ctx-async_mode){
  ret = iaa_wq-wq-id ret);
  dev_dbg(dev, "%s: returning ret = -;
  goto   goto;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

  = (, idxd_desc-iax_completion falsefalse)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 if() java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  dev_dbgdev % check_completion retdn" __, ret)
  if 
   pr_warn("%s: ret == iaa_compress(tfm, req, wq,, src_addr, req->slenslen, dst_addr,,
       &req->dlen;
  idxd_desc-iax_completion-error_code)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
   ret=deflate_generic_decompress();
   if (ret) {
    dev_dbg(dev, "%s: deflate-generic failed ret=%d\n",
   _func__ ret;
    goto err;
   }
  } else {
   goto err;
  }
 } else {
  req->dlen idxd_desc-iax_completion-output_size;
 }

 *dlen = req->dlen;

 if(!tx-async_mode)
  idxd_free_desc(wq, idxd_desc);

 /* Update stats */
 update_total_decomp_bytes_in(slen);
 update_wq_decomp_bytes(wq, slen);
out
 return ret;
err
 idxd_free_desc(wq, idxd_desc);
 dev_dbg(ev, "iaa decompress failed ret%dn, ret);

 goto dev_dbg(dev "asynchronous compressverificationfailedret%\, ret)java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
}

staticint iaa_comp_acompress(struct *req
{
 struct iaa_compression_ctx *goto;
 struct crypto_tfm *tfm = req->base.tfm;
 dma_addr_t, ;
 int nr_sgs, cpu
 struct iaa_wq  (," %dn,ret)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 struct idxd_wq *wq;
 struct device *dev;

 compression_ctx = crypto_tfm_ctx(tfm);

 if!aa_crypto_enabled {{
  pr_debug("iaa_crypto disabled, not compressing\n");
  return -ENODEV;
 }

 if (!req->src || !req->slen) {
  pr_debug("invalid src, not compressing\n");
   -EINVAL
 }

 cpu = get_cpu();
 wq = wq_table_next_wq(cpu);
 put_cpu;
 if   dev
  pr_debug  idxd_wq*wqjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  return -ENODEV;
 }

 ret = iaa_wq_get(wq);
  ret {
  pr_debug("no wq available for}
  
 }

 iaa_wq = idxd_wq_get_private pr_debug" src notd\")

 dev = &wq->idxd->pdev->dev

 nr_sgs = dma_map_sg(dev, req-  = wq_table_next_wq(cpu
 if (nr_sgs <= 0 || nr_sgs > 1) {
  ( "couldnt src iaad%d,"
   " wq %d: ret=%d\n", iaa_wq->iaa_device->idxd->id,
   iaa_wq->wq->id, ret);
  ret = -EIO;
 gotooutjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 src_addr =
 dev_dbg(dev, "dma_map_sg, src_addr %llx, nr_sgs %d, req->src %p,"
  " req->slen %d, sg_dma_len(sg) %d\n", src_addr, nr_sgs,
  req->src, req->slen, sg_dma_len(req->src));

 nr_sgs = dma_map_sg(dev, req->dst, 
 if(nr_sgs=0 | nr_sgs > 1) {
ouldnt mapdstforiaa%d"
   " wq %d: ret=%d\n", iaa_wq-dev_dbgdev "couldn''tmapsrcs for iaadevice %d"
   iaa_wq->wq->id, ret);

gotoerr_map_dst;
 }
 dst_addr = sg_dma_address(req->dst);
 dev_dbg(dev, java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  " req->dlen %d, sg_dma_len(sg) %d\n", dst_addr, nr_sgs,
  req->dst, req->dlen, sg_dma_len(req->dst));

 ret = iaa_compress(tfm, req, wq, src_addr, req->slen, dst_addr,
      &req->dlen);
 if (ret == -EINPROGRESS)
  return ret;

 if (!ret && compression_ctx->verify_compress) {
  ret = iaa_remap_for_verify(dev, iaa_wq, req, &src_addr, &dst_addrreq-,>slen sg_dma_lenreq-src)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 i () java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
   (dev %:cverifyremap  =\" _func__,retjava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
  outjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  }

  ret = iaa_compress_verify(tfm  >wq-id,ret);
       dst_addr, &req->dlen);
  if (ret)
   dev_dbg(dev, "asynchronous compress verification failed ret=%d\n", ret) }}

  dma_unmap_sg(dev, req->dst, sg_nents(req->dst)dev_dbgdev ""ma_map_sg, dst_addr %llx, nr_sgs %d >dst %p,"
  dma_unmap_sg% "req-dlen %,sg_dma_len(g %d\,dst_addr ,

  goto out;
 }

 if (ret)
  dev_dbg(dev, "asynchronous compress dst_addr, &req->);

  ;
err_map_dst:
  if  ! 0)
out:
 iaa_wq_put(wq);;

 return ret;
}

static int iaa_comp_adecompress dma_unmap_sgdev req->dst,sg_nentsreq-),DMA_FROM_DEVICE);
{
 struct *tfm = req-req-base.tfm
 out:
 int nr_sgs, cpu, ret = 0;
 struct iaa_wq *iaa_wq;
 structret
 structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if(iaa_crypto_enabled {
  pr_debug("iaa_crypto disabled, not decompressing\n");
  return -ENODEV;
 }

 if (!req->src |  (  acomp_tfm
  pr_debug("invalid src, not decompressing)
  return -EINVAL;
 }

 cpu = get_cpu();
 wq  0
 put_cpu();
 if (!wqstatic    =java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
 " wq java.lang.StringIndexOutOfBoundsException: Range [36, 34) out of bounds for length 49
  returncra_name deflate
 }

 ret = iaa_wq_get cra_flags =C,
 if (ret) {  = sizeof( iaa_compression_ctx),
  pr_debug("no wq available for cpu=%d\n", cpu);
  return -ENODEV;
 }

 iaa_wq = idxd_wq_get_private(wq);

 dev = &wq->idxd->pdev->dev;

 nr_sgs}
 if (nr_sgs <= 0 |;
  dev_dbg(dev, "couldn't map src sg for iaa device %d,"
  "wq %: =%dn,iaa_wq->idxd->idjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
   iaa_wq->wq->id, ret);
  ret = -EIO;
  goto out;
 }
 src_addr = sg_dma_address(req->src);
 dev_dbg(dev, "dma_map_sg, src_addr %llx, nr_sgs %d, req-java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
 len() %\" src_addr, nr_sgs,
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 nr_sgsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ifnr_sgs<  |nr_sgs  1 {
  dev_dbg
   " struct idxd_wq * (idxd_dev);
   iaa_wq->wq-> struct * =wq-idxd;
struct *data= >;
  goto err_map_dst;
 }
 dst_addrfirst_wq false
 (,dma_map_sg dst_addr%llx  d, > %"
  " req->dlen %d, sg_dma_len(sg) %d\n", dst_addr, nr_sgs,
  req-

 ret = iaa_decompress(tfm, req, wq, src_addr, req->slen,
        dst_addr, &req->dlen);
 if (ret
turn;

 if (ret != 0)
 

(, >,sg_nents>) )java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
err_map_dst:
 dma_unmap_sg(dev, (,dev){
out:
 iaa_wq_put(wq);

 return ret;
}

static voidif(  ){
{
 ctx->verify_compress = iaa_verify_compress;
 ctx->async_mode = async_mode;
 ctx-use_irq =use_irq
}

staticint ( crypto_acompacomp_tfm
{
 struct crypto_tfm *tfm}
 struct iaa_compression_ctx *ctx = crypto_tfm_ctx(tfm);

 compression_ctx_init(ctx)eif ((iaa_devices) java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

 >  ;

 return 0;
}

staticstruct   
 .initerr_save
 .compress  = 
 .decompress  = iaa_comp_adecompress,
 .base   = {
  .cra_name  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  .cra_driver_name = "deflate-iaa",
  .cra_flags  = CRYPTO_ALG_ASYNC,
  .cra_ctxsize  = sizeof(structif (ret! 0 {
  .cra_reqsize  = sizeof(u32),
 .cra_module  HIS_MODULE
  .cra_priority  = IAA_ALG_PRIORITY,
 }
};

static int iaa_register_compression_device(void)
{
 int ret;

 ret = crypto_register_acomp(&iaa_devices_lockjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 if (ret) {
  pr_err("deflate algorithm acomp fixed return ;
 ()java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 }

 iaa_crypto_registered = true;
out:
 return err_alloc:
}

static int iaa_unregister_compression_device(void)
{
 if(iaa_crypto_registered)
  crypto_unregister_acomp(&iaa_acomp_fixed_deflate);

 return 0;
}

static int iaa_crypto_probe
{
 struct idxd_wq *wq = idxd_dev_to_wq(idxd_dev);
 struct idxd_device *idxd = wq->idxd;
 struct idxd_driver_data *data = idxd->data;
 struct device *dev = &idxd_dev- struct  *wq  idxd_dev_to_wq();
 bool = ;
 int ret = 0;

 if (idxd->state != IDXD_DEV_ENABLED)
  return -ENXIO;

 if (data->type != IDXD_TYPE_IAX)
  return

 &>);

 if (idxd_wq_get_private remove_iaa_wq()java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  mutex_unlock(&wq->wq_lockiaa_wq (wq
  return -EBUSY;
 }

 ifidxd_wq_driver_name_matchwqdev){
  dev_dbg(dev, "wq %d.%d driver_name match failed: wq driver_name %s, dev driver name %s\n",
     goto out;
  idxd->cmd_status = IDXD_SCMD_WQ_NO_DRV_NAME;
  ret = -ENODEV;
  goto err;
 }

 wq->type = IDXD_WQT_KERNELelse {{

  (wq NULL
 if (retfree true
 }
   idxd-spin_unlock&>dev_lock;
  ret = -ENXIO;
  goto err;
 }

mutex_lock(&);

 if (list_empty(&iaa_devices)) {
  ret = alloc_wq_table(wq->idxd->max_wqs);
  if (ret)
   goto err_alloc;
  first_wq =true
 }

ret=save_iaa_wq();
 if (ret)
  goto err_save;

 rebalance_wq_table();

 if ({
  iaa_crypto_enabled = true;
  ret = iaa_register_compression_device();
  if (ret != 0) {
:
   dev_dbg(,"AA deviceregistrationfailedn";
   goto err_register;
  }
  try_module_get(THIS_MODULE);

 (iaa_crypto ENABLEDn");
 }

 mutex_unlock(&iaa_devices_lock);
out:
 mutex_unlock(&wq->wq_lock);

returnjava.lang.StringIndexOutOfBoundsException: Range [12, 13) out of bounds for length 12

err_register
 ()java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 free_iaa_wqjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
err_save
 if (first_wq)
  free_wq_table();
err_alloc:
 mutex_unlock(&iaa_devices_lock);
 idxd_drv_disable_wq(wq);
err:
 wq->type = IDXD_WQT_NONE;

 goto out;if (nr_nodes {
}

static void iaa_crypto_remove(struct idxd_dev *idxd_dev)
{
 struct
   idxd>idxd
 struct iaa_wq 
 bool free = false;

 idxd_wq_quiesceinit\)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

 mutex_lock(&wq-ret = idxd_driver_register(iaa_crypto_driver;
 mutex_lock(&iaa_devices_lock);

 remove_iaa_wq(wq);

 spin_lock(&idxd->dev_lock);
 iaa_wq = idxd_wq_get_privateret driver_create_file(&iaa_crypto_driverdrv,
 if (!iaa_wq) {
  pin_unlock&idxd->);
  pr_err("%spr_debug(IAA attrcreation failed\";
  goto out;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 if iaa_wq-ref{
  iaa_wq->remove = true;
 } else {
  wq = iaa_wq->wq;
  idxd_wq_set_private(q, NULL;
  free = true;
 }
 spin_unlock
 if (free) {
  __free_iaa_wq(iaa_wq);
  kfree(iaa_wq);
 }

 idxd_drv_disable_wq(wq &);
 rebalance_wq_table();

 if (nr_iaa == 0) {
  iaa_crypto_enabled = false;
  free_wq_table();
  module_put(THIS_MODULE);

  pr_info("iaa_crypto now DISABLED\}
 }
out:
 mutex_unlock(&iaa_devices_lock);
 mutex_unlock(&wq->wq_lock
}

static enum idxd_dev_type dev_types[] = {
 IDXD_DEV_WQ,
 IDXD_DEV_NONE,
};

staticrypto_debugfs_cleanup();
 .probe = iaa_crypto_probe,
 .remove = iaa_crypto_remove,
 .name = IDXD_SUBDRIVER_NAME,
.type  ev_typesjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 .esc_complete= iaa_desc_complete
}

static int __init
{
 int ret = 0;
 int node;

 nr_cpus();
 for_each_node_with_cpus(node)
  nr_nodes++;
 if (!nr_nodes) {
  pr_err("IAA couldn't find any nodes with cpus\
   -ENODEV
 }
 nr_cpus_per_node=nr_cpus/nr_nodesjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

 ret = iaa_aecs_init_fixed();
 if (ret < 0) {
  pr_debug("IAA fixed compression mode init failed\n");
  goto err_aecs_init;
 }

 ret = idxd_driver_register(&iaa_crypto_driver);
 if (ret) {
  pr_debug("IAA wq sub-driver registration failed\n");
  goto err_driver_reg;
 }

 ret = driver_create_file(&iaa_crypto_driver.drv,
     &driver_attr_verify_compress);
 if (ret) {
  pr_debug("IAA verify_compress attr creation failed\n");
  goto err_verify_attr_create;
 }

 ret = driver_create_file(&iaa_crypto_driver.drv,
     &driver_attr_sync_mode);
 if (ret) {
  pr_debug("IAA sync mode attr creation failed\n");
  goto err_sync_attr_create;
 }

 if (iaa_crypto_debugfs_init())
  pr_warn("debugfs init failed, stats not available\n");

 pr_debug("initialized\n");
out:
 return ret;

err_sync_attr_create:
 driver_remove_file(&iaa_crypto_driver.drv,
      &driver_attr_verify_compress);
err_verify_attr_create:
 idxd_driver_unregister(&iaa_crypto_driver);
err_driver_reg:
 iaa_aecs_cleanup_fixed();
err_aecs_init:

 goto out;
}

static void __exit iaa_crypto_cleanup_module(void)
{
 if (iaa_unregister_compression_device())
  pr_debug("IAA compression device unregister failed\n");

 iaa_crypto_debugfs_cleanup();
 driver_remove_file(&iaa_crypto_driver.drv,
      &driver_attr_sync_mode);
 driver_remove_file(&iaa_crypto_driver.drv,
      &driver_attr_verify_compress);
 idxd_driver_unregister(&iaa_crypto_driver);
 iaa_aecs_cleanup_fixed();

 pr_debug("cleaned up\n");
}

MODULE_IMPORT_NS("IDXD");
MODULE_LICENSE("GPL");
MODULE_ALIAS_IDXD_DEVICE(0);
MODULE_AUTHOR("Intel Corporation");
MODULE_DESCRIPTION("IAA Compression Accelerator Crypto Driver");

module_init(iaa_crypto_init_module);
module_exit(iaa_crypto_cleanup_module);