8cc6cc81dd
Copy sys/dev/rmi to sys/mips/rmi/dev [sic]. For devices that are on only one SoC, or family of SoC, we place them under sys/<vendor>/dev. I'll fix the build problems this causes as best I can since rmi kernel require external toolchains due to lack of support for rmi op-codes in the ancient binutils we have in the tree.
470 lines
13 KiB
C
470 lines
13 KiB
C
/*-
|
|
* Copyright (c) 2003-2009 RMI Corporation
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. Neither the name of RMI Corporation, nor the names of its contributors,
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
* RMI_BSD */
|
|
|
|
#ifndef _STATS_H_
|
|
#define _STATS_H_
|
|
|
|
typedef struct hmac_stats
|
|
{
|
|
unsigned long md5_count;
|
|
unsigned long long md5_bytes;
|
|
unsigned long sha1_count;
|
|
unsigned long long sha1_bytes;
|
|
unsigned long sha256_count;
|
|
unsigned long long sha256_bytes;
|
|
unsigned long sha384_count;
|
|
unsigned long long sha384_bytes;
|
|
unsigned long sha512_count;
|
|
unsigned long long sha512_bytes;
|
|
unsigned long gcm_count;
|
|
unsigned long long gcm_bytes;
|
|
unsigned long kasumi_f9_count;
|
|
unsigned long long kasumi_f9_bytes;
|
|
unsigned long reverts;
|
|
unsigned long long reverts_bytes;
|
|
} hmac_stats_t, *hmac_stats_pt;
|
|
|
|
typedef struct cipher_stats
|
|
{
|
|
unsigned long des_encrypts;
|
|
unsigned long long des_encrypt_bytes;
|
|
unsigned long des_decrypts;
|
|
unsigned long long des_decrypt_bytes;
|
|
unsigned long des3_encrypts;
|
|
unsigned long long des3_encrypt_bytes;
|
|
unsigned long des3_decrypts;
|
|
unsigned long long des3_decrypt_bytes;
|
|
unsigned long aes_encrypts;
|
|
unsigned long long aes_encrypt_bytes;
|
|
unsigned long aes_decrypts;
|
|
unsigned long long aes_decrypt_bytes;
|
|
unsigned long arc4_encrypts;
|
|
unsigned long long arc4_encrypt_bytes;
|
|
unsigned long arc4_decrypts;
|
|
unsigned long long arc4_decrypt_bytes;
|
|
unsigned long kasumi_f8_encrypts;
|
|
unsigned long long kasumi_f8_encrypt_bytes;
|
|
unsigned long kasumi_f8_decrypts;
|
|
unsigned long long kasumi_f8_decrypt_bytes;
|
|
unsigned long reverts;
|
|
unsigned long long reverts_bytes;
|
|
} cipher_stats_t, *cipher_stats_pt;
|
|
|
|
|
|
typedef struct modexp_stats
|
|
{
|
|
unsigned long modexp_512s;
|
|
unsigned long modexp_1024s;
|
|
} modexp_stats_t, *modexp_stats_pt;
|
|
|
|
typedef struct ecc_stats
|
|
{
|
|
unsigned long ecc_mul;
|
|
unsigned long ecc_add;
|
|
unsigned long ecc_dbl;
|
|
unsigned long ecc_vfy;
|
|
unsigned long ecc_bin_mul;
|
|
unsigned long ecc_field_bin_inv;
|
|
unsigned long ecc_field_bin_mul;
|
|
unsigned long ecc_field_bin_add;
|
|
unsigned long ecc_field_add;
|
|
unsigned long ecc_field_sub;
|
|
unsigned long ecc_field_mul;
|
|
unsigned long ecc_field_inv;
|
|
unsigned long ecc_field_div;
|
|
unsigned long ecc_field_red;
|
|
} ecc_stats_t, *ecc_stats_pt;
|
|
|
|
|
|
typedef struct opt_stats
|
|
{
|
|
unsigned long combined;
|
|
unsigned long unaligned_auth_dest;
|
|
unsigned long sym_failed;
|
|
unsigned long modexp_failed;
|
|
unsigned long ecc_failed;
|
|
} opt_stats_t, *opt_stats_pt;
|
|
|
|
typedef struct rmisec_stats
|
|
{
|
|
uint32_t sent;
|
|
uint32_t received;
|
|
uint32_t stats_mask;
|
|
uint32_t control_mask;
|
|
rwlock_t rmisec_control_lock;
|
|
rwlock_t rmisec_stats_lock;
|
|
char clear_start[0];
|
|
uint64_t wait_time;
|
|
uint32_t max_wait_time;
|
|
uint32_t maxsnd_wait_time;
|
|
uint32_t wait_count;
|
|
hmac_stats_t hmac;
|
|
cipher_stats_t cipher;
|
|
modexp_stats_t modexp;
|
|
ecc_stats_t ecc;
|
|
opt_stats_t opt;
|
|
} rmisec_stats_t, *rmisec_stats_pt;
|
|
|
|
|
|
/* stats routines */
|
|
|
|
static void inline phxdrv_record_sent(rmisec_stats_pt stats)
|
|
{
|
|
write_lock(&stats->rmisec_stats_lock);
|
|
stats->sent++;
|
|
write_unlock(&stats->rmisec_stats_lock);
|
|
}
|
|
|
|
static void inline phxdrv_record_received(rmisec_stats_pt stats)
|
|
{
|
|
write_lock(&stats->rmisec_stats_lock);
|
|
stats->received++;
|
|
write_unlock(&stats->rmisec_stats_lock);
|
|
}
|
|
|
|
|
|
static void inline phxdrv_record_des(rmisec_stats_pt stats, int enc,
|
|
int nbytes)
|
|
{
|
|
if (stats->stats_mask & PHXDRV_PROFILE_DES) {
|
|
write_lock(&stats->rmisec_stats_lock);
|
|
if (enc) {
|
|
stats->cipher.des_encrypts++;
|
|
stats->cipher.des_encrypt_bytes += nbytes;
|
|
}
|
|
else {
|
|
stats->cipher.des_decrypts++;
|
|
stats->cipher.des_decrypt_bytes += nbytes;
|
|
}
|
|
write_unlock(&stats->rmisec_stats_lock);
|
|
}
|
|
}
|
|
|
|
|
|
static void inline phxdrv_record_3des(rmisec_stats_pt stats, int enc,
|
|
int nbytes)
|
|
{
|
|
if (stats->stats_mask & PHXDRV_PROFILE_3DES) {
|
|
write_lock(&stats->rmisec_stats_lock);
|
|
if (enc) {
|
|
stats->cipher.des3_encrypts++;
|
|
stats->cipher.des3_encrypt_bytes += nbytes;
|
|
}
|
|
else {
|
|
stats->cipher.des3_decrypts++;
|
|
stats->cipher.des3_decrypt_bytes += nbytes;
|
|
}
|
|
write_unlock(&stats->rmisec_stats_lock);
|
|
}
|
|
}
|
|
|
|
|
|
static void inline phxdrv_record_aes(rmisec_stats_pt stats, int enc,
|
|
int nbytes)
|
|
{
|
|
if (stats->stats_mask & PHXDRV_PROFILE_AES) {
|
|
write_lock(&stats->rmisec_stats_lock);
|
|
if (enc) {
|
|
stats->cipher.aes_encrypts++;
|
|
stats->cipher.aes_encrypt_bytes += nbytes;
|
|
}
|
|
else {
|
|
stats->cipher.aes_decrypts++;
|
|
stats->cipher.aes_decrypt_bytes += nbytes;
|
|
}
|
|
write_unlock(&stats->rmisec_stats_lock);
|
|
}
|
|
}
|
|
|
|
|
|
static void inline phxdrv_record_arc4(rmisec_stats_pt stats, int enc,
|
|
int nbytes)
|
|
{
|
|
if (stats->stats_mask & PHXDRV_PROFILE_ARC4) {
|
|
write_lock(&stats->rmisec_stats_lock);
|
|
if (enc) {
|
|
stats->cipher.arc4_encrypts++;
|
|
stats->cipher.arc4_encrypt_bytes += nbytes;
|
|
}
|
|
else {
|
|
stats->cipher.arc4_decrypts++;
|
|
stats->cipher.arc4_decrypt_bytes += nbytes;
|
|
}
|
|
write_unlock(&stats->rmisec_stats_lock);
|
|
}
|
|
}
|
|
|
|
static void inline phxdrv_record_kasumi_f8(rmisec_stats_pt stats, int enc,
|
|
int nbytes)
|
|
{
|
|
if (stats->stats_mask & PHXDRV_PROFILE_KASUMI_F8) {
|
|
write_lock(&stats->rmisec_stats_lock);
|
|
if (enc) {
|
|
stats->cipher.kasumi_f8_encrypts++;
|
|
stats->cipher.kasumi_f8_encrypt_bytes += nbytes;
|
|
}
|
|
else {
|
|
stats->cipher.kasumi_f8_decrypts++;
|
|
stats->cipher.kasumi_f8_decrypt_bytes += nbytes;
|
|
}
|
|
write_unlock(&stats->rmisec_stats_lock);
|
|
}
|
|
}
|
|
|
|
|
|
static void inline phxdrv_record_modexp(rmisec_stats_pt stats,
|
|
int blksize)
|
|
{
|
|
if (stats->stats_mask & PHXDRV_PROFILE_MODEXP) {
|
|
write_lock(&stats->rmisec_stats_lock);
|
|
if (blksize == 512) {
|
|
stats->modexp.modexp_512s++;
|
|
}
|
|
if (blksize == 1024) {
|
|
stats->modexp.modexp_1024s++;
|
|
}
|
|
write_unlock(&stats->rmisec_stats_lock);
|
|
}
|
|
}
|
|
|
|
|
|
static void inline phxdrv_record_ecc(rmisec_stats_pt stats, PHX_ECC_OP op)
|
|
{
|
|
if (stats->stats_mask & PHXDRV_PROFILE_ECC) {
|
|
write_lock(&stats->rmisec_stats_lock);
|
|
switch (op) {
|
|
case PHX_ECC_NOP:
|
|
break;
|
|
case PHX_ECC_MUL:
|
|
stats->ecc.ecc_mul++;
|
|
break;
|
|
case PHX_ECC_BIN_MUL:
|
|
stats->ecc.ecc_bin_mul++;
|
|
break;
|
|
case PHX_ECC_ADD:
|
|
stats->ecc.ecc_add++;
|
|
break;
|
|
case PHX_ECC_DBL:
|
|
stats->ecc.ecc_dbl++;
|
|
break;
|
|
case PHX_ECC_VFY:
|
|
stats->ecc.ecc_vfy++;
|
|
break;
|
|
case PHX_ECC_FIELD_BIN_INV:
|
|
stats->ecc.ecc_field_bin_inv++;
|
|
break;
|
|
case PHX_ECC_FIELD_BIN_MUL:
|
|
stats->ecc.ecc_field_bin_mul++;
|
|
break;
|
|
case PHX_ECC_FIELD_BIN_ADD:
|
|
stats->ecc.ecc_field_bin_add++;
|
|
break;
|
|
case PHX_ECC_FIELD_ADD:
|
|
stats->ecc.ecc_field_add++;
|
|
break;
|
|
case PHX_ECC_FIELD_SUB:
|
|
stats->ecc.ecc_field_sub++;
|
|
break;
|
|
case PHX_ECC_FIELD_MUL:
|
|
stats->ecc.ecc_field_mul++;
|
|
break;
|
|
case PHX_ECC_FIELD_INV:
|
|
stats->ecc.ecc_field_inv++;
|
|
break;
|
|
case PHX_ECC_FIELD_DIV:
|
|
stats->ecc.ecc_field_div++;
|
|
break;
|
|
case PHX_ECC_FIELD_RED:
|
|
stats->ecc.ecc_field_red++;
|
|
break;
|
|
case PHX_ECC_FIELD:
|
|
case PHX_ECC_BIN:
|
|
break;
|
|
}
|
|
write_unlock(&stats->rmisec_stats_lock);
|
|
}
|
|
}
|
|
|
|
static void inline phxdrv_record_cipher_revert(rmisec_stats_pt stats,
|
|
int nbytes)
|
|
{
|
|
if (stats->stats_mask & PHXDRV_PROFILE_CPHR_REVERTS) {
|
|
write_lock(&stats->rmisec_stats_lock);
|
|
stats->cipher.reverts++;
|
|
stats->cipher.reverts_bytes += nbytes;
|
|
write_unlock(&stats->rmisec_stats_lock);
|
|
}
|
|
}
|
|
|
|
static void inline phxdrv_record_hmac_revert(rmisec_stats_pt stats,
|
|
int nbytes)
|
|
{
|
|
if (stats->stats_mask & PHXDRV_PROFILE_HMAC_REVERTS) {
|
|
write_lock(&stats->rmisec_stats_lock);
|
|
stats->hmac.reverts++;
|
|
stats->hmac.reverts_bytes += nbytes;
|
|
write_unlock(&stats->rmisec_stats_lock);
|
|
}
|
|
}
|
|
|
|
|
|
static void inline phxdrv_record_md5(rmisec_stats_pt stats,
|
|
int nbytes)
|
|
{
|
|
if (stats->stats_mask & PHXDRV_PROFILE_MD5) {
|
|
write_lock(&stats->rmisec_stats_lock);
|
|
stats->hmac.md5_count++;
|
|
stats->hmac.md5_bytes += nbytes;
|
|
write_unlock(&stats->rmisec_stats_lock);
|
|
}
|
|
}
|
|
|
|
static void inline phxdrv_record_sha1(rmisec_stats_pt stats,
|
|
int nbytes)
|
|
{
|
|
if (stats->stats_mask & PHXDRV_PROFILE_SHA1) {
|
|
write_lock(&stats->rmisec_stats_lock);
|
|
stats->hmac.sha1_count++;
|
|
stats->hmac.sha1_bytes += nbytes;
|
|
write_unlock(&stats->rmisec_stats_lock);
|
|
}
|
|
}
|
|
|
|
|
|
static void inline phxdrv_record_sha256(rmisec_stats_pt stats,
|
|
int nbytes)
|
|
{
|
|
if (stats->stats_mask & PHXDRV_PROFILE_SHA256) {
|
|
write_lock(&stats->rmisec_stats_lock);
|
|
stats->hmac.sha256_count++;
|
|
stats->hmac.sha256_bytes += nbytes;
|
|
write_unlock(&stats->rmisec_stats_lock);
|
|
}
|
|
}
|
|
|
|
static void inline phxdrv_record_sha384(rmisec_stats_pt stats,
|
|
int nbytes)
|
|
{
|
|
if (stats->stats_mask & PHXDRV_PROFILE_SHA384) {
|
|
write_lock(&stats->rmisec_stats_lock);
|
|
stats->hmac.sha384_count++;
|
|
stats->hmac.sha384_bytes += nbytes;
|
|
write_unlock(&stats->rmisec_stats_lock);
|
|
}
|
|
}
|
|
|
|
|
|
static void inline phxdrv_record_sha512(rmisec_stats_pt stats,
|
|
int nbytes)
|
|
{
|
|
if (stats->stats_mask & PHXDRV_PROFILE_SHA512) {
|
|
write_lock(&stats->rmisec_stats_lock);
|
|
stats->hmac.sha512_count++;
|
|
stats->hmac.sha512_bytes += nbytes;
|
|
write_unlock(&stats->rmisec_stats_lock);
|
|
}
|
|
}
|
|
|
|
static void inline phxdrv_record_gcm(rmisec_stats_pt stats,
|
|
int nbytes)
|
|
{
|
|
if (stats->stats_mask & PHXDRV_PROFILE_GCM) {
|
|
write_lock(&stats->rmisec_stats_lock);
|
|
stats->hmac.gcm_count++;
|
|
stats->hmac.gcm_bytes += nbytes;
|
|
write_unlock(&stats->rmisec_stats_lock);
|
|
}
|
|
}
|
|
|
|
|
|
static void inline phxdrv_record_kasumi_f9(rmisec_stats_pt stats,
|
|
int nbytes)
|
|
{
|
|
if (stats->stats_mask & PHXDRV_PROFILE_KASUMI_F9) {
|
|
write_lock(&stats->rmisec_stats_lock);
|
|
stats->hmac.kasumi_f9_count++;
|
|
stats->hmac.kasumi_f9_bytes += nbytes;
|
|
write_unlock(&stats->rmisec_stats_lock);
|
|
}
|
|
}
|
|
|
|
static void inline phxdrv_record_unaligned_auth_dest(rmisec_stats_pt stats,
|
|
int nbytes)
|
|
{
|
|
if (stats->stats_mask & PHXDRV_PROFILE_UNALIGNED_AUTH_DEST) {
|
|
write_lock(&stats->rmisec_stats_lock);
|
|
stats->opt.unaligned_auth_dest++;
|
|
write_unlock(&stats->rmisec_stats_lock);
|
|
}
|
|
}
|
|
|
|
|
|
static void inline phxdrv_record_combined(rmisec_stats_pt stats,
|
|
int nbytes)
|
|
{
|
|
if (stats->stats_mask & PHXDRV_PROFILE_COMBINED) {
|
|
write_lock(&stats->rmisec_stats_lock);
|
|
stats->opt.combined++;
|
|
write_unlock(&stats->rmisec_stats_lock);
|
|
}
|
|
}
|
|
|
|
static void inline phxdrv_record_sym_failed(rmisec_stats_pt stats,
|
|
int nbytes)
|
|
{
|
|
if (stats->stats_mask & PHXDRV_PROFILE_COMBINED) {
|
|
write_lock(&stats->rmisec_stats_lock);
|
|
stats->opt.sym_failed++;
|
|
write_unlock(&stats->rmisec_stats_lock);
|
|
}
|
|
}
|
|
|
|
static void inline phxdrv_record_modexp_failed(rmisec_stats_pt stats,
|
|
int nbytes)
|
|
{
|
|
if (stats->stats_mask & PHXDRV_PROFILE_COMBINED) {
|
|
write_lock(&stats->rmisec_stats_lock);
|
|
stats->opt.modexp_failed++;
|
|
write_unlock(&stats->rmisec_stats_lock);
|
|
}
|
|
}
|
|
|
|
static void inline phxdrv_record_ecc_failed(rmisec_stats_pt stats,
|
|
int nbytes)
|
|
{
|
|
if (stats->stats_mask & PHXDRV_PROFILE_COMBINED) {
|
|
write_lock(&stats->rmisec_stats_lock);
|
|
stats->opt.ecc_failed++;
|
|
write_unlock(&stats->rmisec_stats_lock);
|
|
}
|
|
}
|
|
|
|
#endif
|