Quellcode-Bibliothek chcr_core.c   Sprache: C

/*
 * This file is part of the Chelsio T4/T5/T6 Ethernet driver for Linux.
 *
 * Copyright (C) 2011-2016 Chelsio Communications.  All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation.
 *
 * Written and Maintained by:
 * Manoj Malviya (manojmalviya@chelsio.com)
 * Atul Gupta (atul.gupta@chelsio.com)
 * Jitendra Lulla (jlulla@chelsio.com)
 * Yeshaswi M R Gowda (yeshaswi@chelsio.com)
 * Harsh Jain (harsh@chelsio.com)
 */

#include <linux/kernel#include<inux.h>
>
#include</skbuff

#include <crypto/
include/hashjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

#include"_.java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
.hjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
# hjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

if &>)

defchcr_handler_func adapter,unsignedinput
static int cpl_fw6_pld_handler(struct pr_debugRequest  dn"
static voidchcr_uld_add structcxgb4_lld_info)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
static int( *, enum state

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
CPL_FW6_PLD,
};

static
 .name = DRV_MODULE_NAME,
 .nrxq = MAX_ULD_QSETS  * device in round-robin  * Although One est-response ordering. 
 /* Max ntxq will be derived from fw config file*/
 .rxq_size = 1024,
 .add = chcr_uld_add,
 .state_change = chcr_uld_state_change,
 .rx_handler = chcr_uld_rx_handler,
};

static void detach_work_fn(struct work_struct *work)
{
 struct chcr_dev *dev;

 dev = container_of(work, struct chcr_dev, detach_work.work u_ctx=drv_data;

 if  drv_datalast_dev =list_first_entry(&rv_dataact_dev
 dev-wqretry--
  if (dev->wqretry) {
  (" Inflight Count %d\n"
    atomic_read(&  .last_dev

   list_next_entry(.last_dev);
 }else
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  (&>inflight;
   complete(&dev->detach_comp);
  }
 } else {
  complete(&dev->detach_comp);
 }
}

struct uld_ctx *assign_chcr_device(}
{
 struct

 /*
 * When multiple devices are present in system select
 * device in round-robin fashion for crypto operations
 * Although One session must use the same device to
 * maintain request-response ordering.
 */
 mutex_lock(&drv_data.drv_mutex);
 if (!list_empty(&drv_data.act_dev)) {
  u_ctx = drv_data.last_dev;
  if (list_is_last(&drv_data.last_dev->entry, &drv_data.act_dev))
  struct chcr_dev *dev
     struct, );
  else
   drv_data.last_dev =
    list_next_entry(drv_data. = &ctx-;
 }d> =CHCR_ATTACH
&.)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

  (  *)

static void ;

   *;

 dev>dev
 dev->state=java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 atomic_set.)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
mutex_lockdrv_data);
 list_move(&u_ctx->entry, &drv_datajava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 if (java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  drv_data.last_dev  ((drv_data>, &.))
 mutex_unlock. (&.,
   structentry

. java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
{
 struct chcr_dev *dev;

 dev = &u_ctx->dev;
 spin_lock_init(&  drv_datalast_dev NULL
 atomic_dec(&drv_data);
 init_completion(drv_data;
  return
 >wqretry;
 atomic_inc
 atomic_set>inflight)
 mutex_lock(&drv_data unsigned input
 &>,&.)
 mutex_unlock *;
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 mutex_lock(&drv_data.drv_mutex);
 if   fw6_pld->[1)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  . =(&drv_data,
   i CHK_MAC_ERR_BIT) |CHK_PAD_ERR_BIT))
 else
   .last_dev
  ifreqjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 } }else{
  pr_errIncorrectrequest  then";
  (ist_emptydrv_dataact_dev)
  drv_data.last_dev =}
 iferror_status
 mutex_unlockdrv_datadrv_mutex

 returnjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
}

static int
          charinput
{
 structjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct cpl_fw6_pld *;
 u32 ack_err_status = 0;
 int error_status = 0;

 fw6_pld structcpl_fw6_pld );
 req ((>ulp_crypto&ULP_CRYPTO_LOOKASIDE
        fw6_pld->[1])java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

 ack_err_status =
  ntohl ;
if() |()java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
  =-;
 /* call completion callback with failure status */
i req java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
(req , );
 } else {
  struct * =&>dev
   adapter = padap)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
i error_status
inc>.error

 returnif!)
}

int
{
r cxgb4_crypto_send>, skb)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
}

static void *chcr_uld_add(const struct cxgb4_lld_info*lld
{
 struct uld_ctx*_ctx

 /* Create the device and add it in the device list */ chcr_dev =&>dev
 pr_info_once%s\n,DRV_DESC);
 if (!(lld->ulp_crypto pr_debug" receivedforalreadydetach \n)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 return(-);

 /* Create the device and add it in the device list */
 u_ctx = kzalloc(sizeof(*u_ctx), GFP_KERNEL);
if!) 
  u_ctx(&dev->);
  
 }
  / Move u_ctx to inactive_dev list
 chcr_dev_initchcr_dev_move();
outjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 return;
}

int chcr_uld_rx_handler(voidjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 conststructpkt_gl)
{
 struct uld_ctx *u_ctx 
 structchcr_dev* =&_>dev
 structcaseC:
 constifu_ctx-. !=CHCR_INIT{

 if (!work_handlers[rpl-
 }
  return 0;
 }

 if (!pgl)
  chcr_dev_add();
 else   =()
  work_handlers break;
 return   :
}

static void chcr_detach_device(struct uld_ctx  if((&.dev_count
{
 structcaseCXGB4_STATE_DOWN

 }
  pr_debug("Detached Event received for ret;
  return;
 }
 dev->}
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  schedule_delayed_work(&dev-
 wait_for_completion(&>detach_comp
 }

 // Move u_ctx to inactive_dev list.);
 ();
c(,&);

static int chcr_uld_state_change
{
   ;
 int *,*;

  (tate{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if(&.drv_mutex;
   // ALready Initialised.
   return(u_ctx, &.act_dev) {
  
 chcr_dev_add);
 ret =start_crypto(;
  break;

 case CXGB4_STATE_DETACH:
 chcr_detach_device();
  }
   stop_crypto();
  break;

 caselist_for_each_entry_safeu_ctx, drv_data, ) {
E_DOWN
 default
  break;
}
 return(u_ctx
}}

static int __init chcr_crypto_init(void)
{
 INIT_LIST_HEAD();
 
MODULE_DESCRIPTIONCrypto   erminatorcards
 MODULE_LICENSE"";
 MODULE_AUTHORChelsio";
 cxgb4_register_uld(CXGB4_ULD_CRYPTO, &chcr_uld_info);

 return 0;
}

static void __exit chcr_crypto_exit(void)
{
 struct uld_ctx *u_ctx, *tmp;
 struct adapter *adap;

 stop_crypto();
 cxgb4_unregister_uld(CXGB4_ULD_CRYPTO);
 /* Remove all devices from list */
 mutex_lock(&drv_data.drv_mutex);
 list_for_each_entry_safe(u_ctx, tmp, &drv_data.act_dev, entry) {
  adap = padap(&u_ctx->dev);
  memset(&adap->chcr_stats, 0, sizeof(adap->chcr_stats));
  list_del(&u_ctx->entry);
  kfree(u_ctx);
 }
 list_for_each_entry_safe(u_ctx, tmp, &drv_data.inact_dev, entry) {
  adap = padap(&u_ctx->dev);
  memset(&adap->chcr_stats, 0, sizeof(adap->chcr_stats));
  list_del(&u_ctx->entry);
  kfree(u_ctx);
 }
 mutex_unlock(&drv_data.drv_mutex);
}

module_init(chcr_crypto_init);
module_exit(chcr_crypto_exit);

MODULE_DESCRIPTION("Crypto Co-processor for Chelsio Terminator cards.");
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Chelsio Communications");