Hi Warner, I'm not sure but this change seems include lots of unintended changes ( maybe some local WIP ) .
> On Aug 16, 2024, at 10:30 AM, Warner Losh <i...@freebsd.org> wrote: > > The branch main has been updated by imp: > > URL: > https://cgit.FreeBSD.org/src/commit/?id=d5507f9e436698ac17dc5ace7ef58493988a9b04 > > commit d5507f9e436698ac17dc5ace7ef58493988a9b04 > Author: Warner Losh <i...@freebsd.org> > AuthorDate: 2024-08-14 22:55:49 +0000 > Commit: Warner Losh <i...@freebsd.org> > CommitDate: 2024-08-16 02:22:18 +0000 > > nvme: Separate total failures from I/O failures > > When it's a I/O failure, we can still send admin commands. Separate out > the admin failures and flag them as such so that we can still send admin > commands on half-failed drives. > > Fixes: 9229b3105d88 (nvme: Fail passthrough commands right away in failed > state) > Sponsored by: Netflix > --- > sys/amd64/conf/IOSCHED | 2 + > sys/amd64/conf/MPI3MR | 10 + > sys/arm64/conf/GENERIC16K | 4 + > .../linuxkpi/common/include/linux/#compiler.h# | 117 + > sys/contrib/dev/iwlwifi/fw/api/soc.h | 35 + > sys/contrib/zlib/contrib/asm686/README.686 | 51 + > sys/contrib/zlib/contrib/asm686/match.S | 357 + > sys/dev/ice/ice_sriov.c | 595 ++ > sys/dev/ice/ice_sriov.h | 64 + > sys/dev/mps/mpi/mpi2_pci.h | 141 + > sys/dev/nvme/nvme_ctrlr.c | 46 +- > sys/dev/nvme/nvme_private.h | 1 + > sys/dev/nvme/nvme_qpair.c | 23 +- > sys/dev/nvme/nvme_sim.c | 13 +- > sys/dev/sound/pci/aureal.c | 686 ++ > sys/dev/sound/pci/aureal.h | 99 + > sys/dev/sound/pci/ds1-fw.h | 1602 ++++ > sys/dev/sound/pci/ds1.c | 1103 +++ > sys/dev/sound/pci/ds1.h | 146 + > sys/dev/sound/pci/maestro.c | 2043 +++++ > sys/dev/sound/pci/maestro_reg.h | 381 + > sys/kern/bsduser-syscalls.c | 8712 ++++++++++++++++++++ > sys/modules/sound/driver/ds1/Makefile | 8 + > sys/modules/sound/driver/maestro/Makefile | 8 + > 24 files changed, 16219 insertions(+), 28 deletions(-) > > diff --git a/sys/amd64/conf/IOSCHED b/sys/amd64/conf/IOSCHED > new file mode 100644 > index 000000000000..e15106bc4c1f > --- /dev/null > +++ b/sys/amd64/conf/IOSCHED > @@ -0,0 +1,2 @@ > +include "GENERIC" > +options CAM_IOSCHED_DYNAMIC > diff --git a/sys/amd64/conf/MPI3MR b/sys/amd64/conf/MPI3MR > new file mode 100644 > index 000000000000..99e5244cb49d > --- /dev/null > +++ b/sys/amd64/conf/MPI3MR > @@ -0,0 +1,10 @@ > +include GENERIC > + > +device mpi3mr > +# All the debugging options > +options DEADLKRES # Enable the deadlock resolver > +options INVARIANTS # Enable calls of extra sanity checking > +options INVARIANT_SUPPORT # Extra sanity checks of internal structures, > required by INVARIANTS > +options QUEUE_MACRO_DEBUG_TRASH # Trash queue(2) internal pointers on > invalidation > +options WITNESS # Enable checks to detect deadlocks and cycles > +options WITNESS_SKIPSPIN # Don't run witness on spinlocks for speed > diff --git a/sys/arm64/conf/GENERIC16K b/sys/arm64/conf/GENERIC16K > new file mode 100644 > index 000000000000..9bf9e2dadb08 > --- /dev/null > +++ b/sys/arm64/conf/GENERIC16K > @@ -0,0 +1,4 @@ > +include "GENERIC" > + > +ident GENERIC_16K > + > diff --git a/sys/compat/linuxkpi/common/include/linux/#compiler.h# > b/sys/compat/linuxkpi/common/include/linux/#compiler.h# > new file mode 100644 > index 000000000000..1177674aa68f > --- /dev/null > +++ b/sys/compat/linuxkpi/common/include/linux/#compiler.h# > @@ -0,0 +1,117 @@ > +/*- > + * Copyright (c) 2010 Isilon Systems, Inc. > + * Copyright (c) 2010 iX Systems, Inc. > + * Copyright (c) 2010 Panasas, Inc. > + * Copyright (c) 2013-2016 Mellanox Technologies, Ltd. > + * Copyright (c) 2015 François Tigeot > + * 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 unmodified, 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. > + * > + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 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. > + * > + * $FreeBSD$ > + */ > +#ifndef _LINUX_COMPILER_H_ > +#define _LINUX_COMPILER_H_ > + > +#include <sys/cdefs.h> > + > +#define __user > +#define __kernel > +#define __safe > +#define __force > +#define __nocast > +#define __iomem > +#define __chk_user_ptr(x) ((void)0) > +#define __chk_io_ptr(x) ((void)0) > +#define __builtin_warning(x, y...) (1) > +#define __acquires(x) > +#define __releases(x) > +#define __acquire(x) do { } while (0) > +#define __release(x) do { } while (0) > +#define __cond_lock(x,c) (c) > +#define __bitwise > +#define __devinitdata > +#define __deprecated > +#define __init > +#define __initconst > +#define __devinit > +#define __devexit > +#define __exit > +#define __rcu > +#define __percpu > +#define __weak __weak_symbol > +#define __malloc > +#define ___stringify(...) #__VA_ARGS__ > +#define __stringify(...) ___stringify(__VA_ARGS__) > +#define __attribute_const__ __attribute__((__const__)) > +#undef __always_inline > +#define __always_inline inline > +#define noinline __noinline > +#define ____cacheline_aligned __aligned(CACHE_LINE_SIZE) > + > +#define likely(x) __builtin_expect(!!(x), 1) > +#define unlikely(x) __builtin_expect(!!(x), 0) > +#define typeof(x) __typeof(x) > + > +#define uninitialized_var(x) x = x > +#define __maybe_unused __unused > +#define __always_unused __unused > +#define __must_check __result_use_check > + > +#define __printf(a,b) __printflike(a,b) > + > +#define barrier() __asm__ __volatile__("": : > :"memory") > + > +#if defined(LINUXKPI_VERSION) && LINUXKPI_VERSION >= 50000 > +/* Moved from drm_os_freebsd.h */ > +#define lower_32_bits(n) ((u32)(n)) > +#define upper_32_bits(n) ((u32)(((n) >> 16) >> 16)) > +#endif > + > +#define ___PASTE(a,b) a##b > +#define __PASTE(a,b) ___PASTE(a,b) > + > +#define ACCESS_ONCE(x) (*(volatile __typeof(x) *)&(x)) > + > +#define WRITE_ONCE(x,v) do { \ > + barrier(); \ > + ACCESS_ONCE(x) = (v); \ > + barrier(); \ > +} while (0) > + > +#define READ_ONCE(x) ({ \ > + __typeof(x) __var = ({ \ > + barrier(); \ > + ACCESS_ONCE(x); \ > + }); \ > + barrier(); \ > + __var; \ > +}) > + > +#define lockless_dereference(p) READ_ONCE(p) > + > +#define _AT(T,X) ((T)(X)) > + > +#define __same_type(a, b) __builtin_types_compatible_p(typeof(a), > typeof(b)) > +#define __must_be_array(a) __same_type(a, &(a)[0]) > + > +#endif /* _LINUX_COMPILER_H_ */ > diff --git a/sys/contrib/dev/iwlwifi/fw/api/soc.h > b/sys/contrib/dev/iwlwifi/fw/api/soc.h > new file mode 100644 > index 000000000000..c5df1171462b > --- /dev/null > +++ b/sys/contrib/dev/iwlwifi/fw/api/soc.h > @@ -0,0 +1,35 @@ > +/* SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause */ > +/* > + * Copyright (C) 2012-2014, 2019-2020 Intel Corporation > + * Copyright (C) 2013-2015 Intel Mobile Communications GmbH > + * Copyright (C) 2016-2017 Intel Deutschland GmbH > + */ > +#ifndef __iwl_fw_api_soc_h__ > +#define __iwl_fw_api_soc_h__ > + > +#define SOC_CONFIG_CMD_FLAGS_DISCRETE BIT(0) > +#define SOC_CONFIG_CMD_FLAGS_LOW_LATENCY BIT(1) > + > +#define SOC_FLAGS_LTR_APPLY_DELAY_MASK 0xc > +#define SOC_FLAGS_LTR_APPLY_DELAY_NONE 0 > +#define SOC_FLAGS_LTR_APPLY_DELAY_200 1 > +#define SOC_FLAGS_LTR_APPLY_DELAY_2500 2 > +#define SOC_FLAGS_LTR_APPLY_DELAY_1820 3 > + > +/** > + * struct iwl_soc_configuration_cmd - Set device stabilization latency > + * > + * @flags: soc settings flags. In VER_1, we can only set the DISCRETE > + * flag, because the FW treats the whole value as an integer. In > + * VER_2, we can set the bits independently. > + * @latency: time for SOC to ensure stable power & XTAL > + */ > +struct iwl_soc_configuration_cmd { > + __le32 flags; > + __le32 latency; > +} __packed; /* > + * SOC_CONFIGURATION_CMD_S_VER_1 (see description above) > + * SOC_CONFIGURATION_CMD_S_VER_2 > + */ > + > +#endif /* __iwl_fw_api_soc_h__ */ > diff --git a/sys/contrib/zlib/contrib/asm686/README.686 > b/sys/contrib/zlib/contrib/asm686/README.686 > new file mode 100644 > index 000000000000..a0bf3bea4aff > --- /dev/null > +++ b/sys/contrib/zlib/contrib/asm686/README.686 > @@ -0,0 +1,51 @@ > +This is a patched version of zlib, modified to use > +Pentium-Pro-optimized assembly code in the deflation algorithm. The > +files changed/added by this patch are: > + > +README.686 > +match.S > + > +The speedup that this patch provides varies, depending on whether the > +compiler used to build the original version of zlib falls afoul of the > +PPro's speed traps. My own tests show a speedup of around 10-20% at > +the default compression level, and 20-30% using -9, against a version > +compiled using gcc 2.7.2.3. Your mileage may vary. > + > +Note that this code has been tailored for the PPro/PII in particular, > +and will not perform particuarly well on a Pentium. > + > +If you are using an assembler other than GNU as, you will have to > +translate match.S to use your assembler's syntax. (Have fun.) > + > +Brian Raiter > +bread...@muppetlabs.com > +April, 1998 > + > + > +Added for zlib 1.1.3: > + > +The patches come from > +http://www.muppetlabs.com/~breadbox/software/assembly.html > + > +To compile zlib with this asm file, copy match.S to the zlib directory > +then do: > + > +CFLAGS="-O3 -DASMV" ./configure > +make OBJA=match.o > + > + > +Update: > + > +I've been ignoring these assembly routines for years, believing that > +gcc's generated code had caught up with it sometime around gcc 2.95 > +and the major rearchitecting of the Pentium 4. However, I recently > +learned that, despite what I believed, this code still has some life > +in it. On the Pentium 4 and AMD64 chips, it continues to run about 8% > +faster than the code produced by gcc 4.1. > + > +In acknowledgement of its continuing usefulness, I've altered the > +license to match that of the rest of zlib. Share and Enjoy! > + > +Brian Raiter > +bread...@muppetlabs.com > +April, 2007 > diff --git a/sys/contrib/zlib/contrib/asm686/match.S > b/sys/contrib/zlib/contrib/asm686/match.S > new file mode 100644 > index 000000000000..fa421092785d > --- /dev/null > +++ b/sys/contrib/zlib/contrib/asm686/match.S > @@ -0,0 +1,357 @@ > +/* match.S -- x86 assembly version of the zlib longest_match() function. > + * Optimized for the Intel 686 chips (PPro and later). > + * > + * Copyright (C) 1998, 2007 Brian Raiter <bread...@muppetlabs.com> > + * > + * This software is provided 'as-is', without any express or implied > + * warranty. In no event will the author be held liable for any damages > + * arising from the use of this software. > + * > + * Permission is granted to anyone to use this software for any purpose, > + * including commercial applications, and to alter it and redistribute it > + * freely, subject to the following restrictions: > + * > + * 1. The origin of this software must not be misrepresented; you must not > + * claim that you wrote the original software. If you use this software > + * in a product, an acknowledgment in the product documentation would be > + * appreciated but is not required. > + * 2. Altered source versions must be plainly marked as such, and must not be > + * misrepresented as being the original software. > + * 3. This notice may not be removed or altered from any source distribution. > + */ > + > +#ifndef NO_UNDERLINE > +#define match_init _match_init > +#define longest_match _longest_match > +#endif > + > +#define MAX_MATCH (258) > +#define MIN_MATCH (3) > +#define MIN_LOOKAHEAD (MAX_MATCH + MIN_MATCH + 1) > +#define MAX_MATCH_8 ((MAX_MATCH + 7) & ~7) > + > +/* stack frame offsets */ > + > +#define chainlenwmask 0 /* high word: current chain len > */ > + /* low word: s->wmask */ > +#define window 4 /* local copy of s->window > */ > +#define windowbestlen 8 /* s->window + bestlen > */ > +#define scanstart 16 /* first two bytes of string > */ > +#define scanend 12 /* last two bytes of string > */ > +#define scanalign 20 /* dword-misalignment of string > */ > +#define nicematch 24 /* a good enough match size > */ > +#define bestlen 28 /* size of best match so far > */ > +#define scan 32 /* ptr to string wanting match > */ > + > +#define LocalVarsSize (36) > +/* saved ebx 36 */ > +/* saved edi 40 */ > +/* saved esi 44 */ > +/* saved ebp 48 */ > +/* return address 52 */ > +#define deflatestate 56 /* the function arguments > */ > +#define curmatch 60 > + > +/* All the +zlib1222add offsets are due to the addition of fields > + * in zlib in the deflate_state structure since the asm code was first > written > + * (if you compile with zlib 1.0.4 or older, use "zlib1222add equ (-4)"). > + * (if you compile with zlib between 1.0.5 and 1.2.2.1, use "zlib1222add equ > 0"). > + * if you compile with zlib 1.2.2.2 or later , use "zlib1222add equ 8"). > + */ > + > +#define zlib1222add (8) > + > +#define dsWSize (36+zlib1222add) > +#define dsWMask (44+zlib1222add) > +#define dsWindow (48+zlib1222add) > +#define dsPrev (56+zlib1222add) > +#define dsMatchLen (88+zlib1222add) > +#define dsPrevMatch (92+zlib1222add) > +#define dsStrStart (100+zlib1222add) > +#define dsMatchStart (104+zlib1222add) > +#define dsLookahead (108+zlib1222add) > +#define dsPrevLen (112+zlib1222add) > +#define dsMaxChainLen (116+zlib1222add) > +#define dsGoodMatch (132+zlib1222add) > +#define dsNiceMatch (136+zlib1222add) > + > + > +.file "match.S" > + > +.globl match_init, longest_match > + > +.text > + > +/* uInt longest_match(deflate_state *deflatestate, IPos curmatch) */ > +.cfi_sections .debug_frame > + > +longest_match: > + > +.cfi_startproc > +/* Save registers that the compiler may be using, and adjust %esp to */ > +/* make room for our stack frame. */ > + > + pushl %ebp > + .cfi_def_cfa_offset 8 > + .cfi_offset ebp, -8 > + pushl %edi > + .cfi_def_cfa_offset 12 > + pushl %esi > + .cfi_def_cfa_offset 16 > + pushl %ebx > + .cfi_def_cfa_offset 20 > + subl $LocalVarsSize, %esp > + .cfi_def_cfa_offset LocalVarsSize+20 > + > +/* Retrieve the function arguments. %ecx will hold cur_match */ > +/* throughout the entire function. %edx will hold the pointer to the */ > +/* deflate_state structure during the function's setup (before > */ > +/* entering the main loop). */ > + > + movl deflatestate(%esp), %edx > + movl curmatch(%esp), %ecx > + > +/* uInt wmask = s->w_mask; */ > +/* unsigned chain_length = s->max_chain_length; > */ > +/* if (s->prev_length >= s->good_match) { */ > +/* chain_length >>= 2; */ > +/* } */ > + > + movl dsPrevLen(%edx), %eax > + movl dsGoodMatch(%edx), %ebx > + cmpl %ebx, %eax > + movl dsWMask(%edx), %eax > + movl dsMaxChainLen(%edx), %ebx > + jl LastMatchGood > + shrl $2, %ebx > +LastMatchGood: > + > +/* chainlen is decremented once beforehand so that the function can */ > +/* use the sign flag instead of the zero flag for the exit test. */ > +/* It is then shifted into the high word, to make room for the wmask */ > +/* value, which it will always accompany. */ > + > + decl %ebx > + shll $16, %ebx > + orl %eax, %ebx > + movl %ebx, chainlenwmask(%esp) > + > +/* if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; */ > + > + movl dsNiceMatch(%edx), %eax > + movl dsLookahead(%edx), %ebx > + cmpl %eax, %ebx > + jl LookaheadLess > + movl %eax, %ebx > +LookaheadLess: movl %ebx, nicematch(%esp) > + > +/* register Bytef *scan = s->window + s->strstart; */ > + > + movl dsWindow(%edx), %esi > + movl %esi, window(%esp) > + movl dsStrStart(%edx), %ebp > + lea (%esi,%ebp), %edi > + movl %edi, scan(%esp) > + > +/* Determine how many bytes the scan ptr is off from being */ > +/* dword-aligned. */ > + > + movl %edi, %eax > + negl %eax > + andl $3, %eax > + movl %eax, scanalign(%esp) > + > +/* IPos limit = s->strstart > (IPos)MAX_DIST(s) ? */ > +/* s->strstart - (IPos)MAX_DIST(s) : NIL; > */ > + > + movl dsWSize(%edx), %eax > + subl $MIN_LOOKAHEAD, %eax > + subl %eax, %ebp > + jg LimitPositive > + xorl %ebp, %ebp > +LimitPositive: > + > +/* int best_len = s->prev_length; */ > + > + movl dsPrevLen(%edx), %eax > + movl %eax, bestlen(%esp) > + > +/* Store the sum of s->window + best_len in %esi locally, and in %esi. > */ > + > + addl %eax, %esi > + movl %esi, windowbestlen(%esp) > + > +/* register ush scan_start = *(ushf*)scan; */ > +/* register ush scan_end = *(ushf*)(scan+best_len-1); > */ > +/* Posf *prev = s->prev; */ > + > + movzwl (%edi), %ebx > + movl %ebx, scanstart(%esp) > + movzwl -1(%edi,%eax), %ebx > + movl %ebx, scanend(%esp) > + movl dsPrev(%edx), %edi > + > +/* Jump into the main loop. */ > + > + movl chainlenwmask(%esp), %edx > + jmp LoopEntry > + > +.balign 16 > + > +/* do { > + * match = s->window + cur_match; > + * if (*(ushf*)(match+best_len-1) != scan_end || > + * *(ushf*)match != scan_start) continue; > + * [...] > + * } while ((cur_match = prev[cur_match & wmask]) > limit > + * && --chain_length != 0); > + * > + * Here is the inner loop of the function. The function will spend the > + * majority of its time in this loop, and majority of that time will > + * be spent in the first ten instructions. > + * > + * Within this loop: > + * %ebx = scanend > + * %ecx = curmatch > + * %edx = chainlenwmask - i.e., ((chainlen << 16) | wmask) > + * %esi = windowbestlen - i.e., (window + bestlen) > + * %edi = prev > + * %ebp = limit > + */ > +LookupLoop: > + andl %edx, %ecx > + movzwl (%edi,%ecx,2), %ecx > + cmpl %ebp, %ecx > + jbe LeaveNow > + subl $0x00010000, %edx > + js LeaveNow > +LoopEntry: movzwl -1(%esi,%ecx), %eax > + cmpl %ebx, %eax > + jnz LookupLoop > + movl window(%esp), %eax > + movzwl (%eax,%ecx), %eax > + cmpl scanstart(%esp), %eax > + jnz LookupLoop > + > +/* Store the current value of chainlen. > */ > + > + movl %edx, chainlenwmask(%esp) > + > +/* Point %edi to the string under scrutiny, and %esi to the string we > */ > +/* are hoping to match it up with. In actuality, %esi and %edi are */ > +/* both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and %edx is */ > +/* initialized to -(MAX_MATCH_8 - scanalign). > */ > + > + movl window(%esp), %esi > + movl scan(%esp), %edi > + addl %ecx, %esi > + movl scanalign(%esp), %eax > + movl $(-MAX_MATCH_8), %edx > + lea MAX_MATCH_8(%edi,%eax), %edi > + lea MAX_MATCH_8(%esi,%eax), %esi > + > +/* Test the strings for equality, 8 bytes at a time. At the end, > + * adjust %edx so that it is offset to the exact byte that mismatched. > + * > + * We already know at this point that the first three bytes of the > + * strings match each other, and they can be safely passed over before > + * starting the compare loop. So what this code does is skip over 0-3 > + * bytes, as much as necessary in order to dword-align the %edi > + * pointer. (%esi will still be misaligned three times out of four.) > + * > + * It should be confessed that this loop usually does not represent > + * much of the total running time. Replacing it with a more > + * straightforward "rep cmpsb" would not drastically degrade > + * performance. > + */ > +LoopCmps: > + movl (%esi,%edx), %eax > + xorl (%edi,%edx), %eax > + jnz LeaveLoopCmps > + movl 4(%esi,%edx), %eax > + xorl 4(%edi,%edx), %eax > + jnz LeaveLoopCmps4 > + addl $8, %edx > + jnz LoopCmps > + jmp LenMaximum > +LeaveLoopCmps4: addl $4, %edx > +LeaveLoopCmps: testl $0x0000FFFF, %eax > + jnz LenLower > + addl $2, %edx > + shrl $16, %eax > +LenLower: subb $1, %al > + adcl $0, %edx > + > +/* Calculate the length of the match. If it is longer than MAX_MATCH, > */ > +/* then automatically accept it as the best possible match and leave. > */ > + > + lea (%edi,%edx), %eax > + movl scan(%esp), %edi > + subl %edi, %eax > + cmpl $MAX_MATCH, %eax > + jge LenMaximum > + > +/* If the length of the match is not longer than the best match we */ > +/* have so far, then forget it and return to the lookup loop. > */ > + > + movl deflatestate(%esp), %edx > + movl bestlen(%esp), %ebx > + cmpl %ebx, %eax > + jg LongerMatch > + movl windowbestlen(%esp), %esi > + movl dsPrev(%edx), %edi > + movl scanend(%esp), %ebx > + movl chainlenwmask(%esp), %edx > + jmp LookupLoop > + > +/* s->match_start = cur_match; > */ > +/* best_len = len; */ > +/* if (len >= nice_match) break; */ > +/* scan_end = *(ushf*)(scan+best_len-1); */ > + > +LongerMatch: movl nicematch(%esp), %ebx > + movl %eax, bestlen(%esp) > + movl %ecx, dsMatchStart(%edx) > + cmpl %ebx, %eax > + jge LeaveNow > + movl window(%esp), %esi > + addl %eax, %esi > + movl %esi, windowbestlen(%esp) > + movzwl -1(%edi,%eax), %ebx > + movl dsPrev(%edx), %edi > + movl %ebx, scanend(%esp) > + movl chainlenwmask(%esp), %edx > + jmp LookupLoop > + > +/* Accept the current string, with the maximum possible length. > */ > + > +LenMaximum: movl deflatestate(%esp), %edx > + movl $MAX_MATCH, bestlen(%esp) > + movl %ecx, dsMatchStart(%edx) > + > +/* if ((uInt)best_len <= s->lookahead) return (uInt)best_len; > */ > +/* return s->lookahead; > */ > + > +LeaveNow: > + movl deflatestate(%esp), %edx > + movl bestlen(%esp), %ebx > + movl dsLookahead(%edx), %eax > + cmpl %eax, %ebx > + jg LookaheadRet > + movl %ebx, %eax > +LookaheadRet: > + > +/* Restore the stack and return from whence we came. */ > + > + addl $LocalVarsSize, %esp > + .cfi_def_cfa_offset 20 > + popl %ebx > + .cfi_def_cfa_offset 16 > + popl %esi > + .cfi_def_cfa_offset 12 > + popl %edi > + .cfi_def_cfa_offset 8 > + popl %ebp > + .cfi_def_cfa_offset 4 > +.cfi_endproc > +match_init: ret > diff --git a/sys/dev/ice/ice_sriov.c b/sys/dev/ice/ice_sriov.c > new file mode 100644 > index 000000000000..c0521e667fa2 > --- /dev/null > +++ b/sys/dev/ice/ice_sriov.c > @@ -0,0 +1,595 @@ > +/* SPDX-License-Identifier: BSD-3-Clause */ > +/* Copyright (c) 2021, Intel 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 the Intel 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 COPYRIGHT HOLDERS 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 COPYRIGHT OWNER 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. > + */ > + > +#include "ice_common.h" > +#include "ice_sriov.h" > + > +/** > + * ice_aq_send_msg_to_vf > + * @hw: pointer to the hardware structure > + * @vfid: VF ID to send msg > + * @v_opcode: opcodes for VF-PF communication > + * @v_retval: return error code > + * @msg: pointer to the msg buffer > + * @msglen: msg length > + * @cd: pointer to command details > + * > + * Send message to VF driver (0x0802) using mailbox > + * queue and asynchronously sending message via > + * ice_sq_send_cmd() function > + */ > +enum ice_status > +ice_aq_send_msg_to_vf(struct ice_hw *hw, u16 vfid, u32 v_opcode, u32 > v_retval, > + u8 *msg, u16 msglen, struct ice_sq_cd *cd) > +{ > + struct ice_aqc_pf_vf_msg *cmd; > + struct ice_aq_desc desc; > + > + ice_fill_dflt_direct_cmd_desc(&desc, ice_mbx_opc_send_msg_to_vf); > + > + cmd = &desc.params.virt; > + cmd->id = CPU_TO_LE32(vfid); > + > + desc.cookie_high = CPU_TO_LE32(v_opcode); > + desc.cookie_low = CPU_TO_LE32(v_retval); > + > + if (msglen) > + desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD); > + > + return ice_sq_send_cmd(hw, &hw->mailboxq, &desc, msg, msglen, cd); > +} > + > +/** > + * ice_aq_send_msg_to_pf > + * @hw: pointer to the hardware structure > + * @v_opcode: opcodes for VF-PF communication > + * @v_retval: return error code > + * @msg: pointer to the msg buffer > + * @msglen: msg length > + * @cd: pointer to command details > + * > + * Send message to PF driver using mailbox queue. By default, this > + * message is sent asynchronously, i.e. ice_sq_send_cmd() > + * does not wait for completion before returning. > + */ > +enum ice_status > +ice_aq_send_msg_to_pf(struct ice_hw *hw, enum virtchnl_ops v_opcode, > + enum ice_status v_retval, u8 *msg, u16 msglen, > + struct ice_sq_cd *cd) > +{ > + struct ice_aq_desc desc; > + > + ice_fill_dflt_direct_cmd_desc(&desc, ice_mbx_opc_send_msg_to_pf); > + desc.cookie_high = CPU_TO_LE32(v_opcode); > + desc.cookie_low = CPU_TO_LE32(v_retval); > + > + if (msglen) > + desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD); > + > + return ice_sq_send_cmd(hw, &hw->mailboxq, &desc, msg, msglen, cd); > +} > + > +/** > + * ice_conv_link_speed_to_virtchnl > + * @adv_link_support: determines the format of the returned link speed > + * @link_speed: variable containing the link_speed to be converted > + * > + * Convert link speed supported by HW to link speed supported by virtchnl. > + * If adv_link_support is true, then return link speed in Mbps. Else return > + * link speed as a VIRTCHNL_LINK_SPEED_* casted to a u32. Note that the > caller > + * needs to cast back to an enum virtchnl_link_speed in the case where > + * adv_link_support is false, but when adv_link_support is true the caller > can > + * expect the speed in Mbps. > + */ > +u32 ice_conv_link_speed_to_virtchnl(bool adv_link_support, u16 link_speed) > +{ > + u32 speed; > + > + if (adv_link_support) > + switch (link_speed) { > + case ICE_AQ_LINK_SPEED_10MB: > + speed = ICE_LINK_SPEED_10MBPS; > + break; > + case ICE_AQ_LINK_SPEED_100MB: > + speed = ICE_LINK_SPEED_100MBPS; > + break; > + case ICE_AQ_LINK_SPEED_1000MB: > + speed = ICE_LINK_SPEED_1000MBPS; > + break; > + case ICE_AQ_LINK_SPEED_2500MB: > + speed = ICE_LINK_SPEED_2500MBPS; > + break; > + case ICE_AQ_LINK_SPEED_5GB: > + speed = ICE_LINK_SPEED_5000MBPS; > + break; > + case ICE_AQ_LINK_SPEED_10GB: > + speed = ICE_LINK_SPEED_10000MBPS; > + break; > + case ICE_AQ_LINK_SPEED_20GB: > + speed = ICE_LINK_SPEED_20000MBPS; > + break; > + case ICE_AQ_LINK_SPEED_25GB: > + speed = ICE_LINK_SPEED_25000MBPS; > + break; > + case ICE_AQ_LINK_SPEED_40GB: > + speed = ICE_LINK_SPEED_40000MBPS; > + break; > + case ICE_AQ_LINK_SPEED_50GB: > + speed = ICE_LINK_SPEED_50000MBPS; > + break; > + case ICE_AQ_LINK_SPEED_100GB: > + speed = ICE_LINK_SPEED_100000MBPS; > + break; > + default: > + speed = ICE_LINK_SPEED_UNKNOWN; > + break; > + } > + else > + /* Virtchnl speeds are not defined for every speed supported in > + * the hardware. To maintain compatibility with older AVF > + * drivers, while reporting the speed the new speed values are > + * resolved to the closest known virtchnl speeds > + */ > + switch (link_speed) { > + case ICE_AQ_LINK_SPEED_10MB: > + case ICE_AQ_LINK_SPEED_100MB: > + speed = (u32)VIRTCHNL_LINK_SPEED_100MB; > + break; > + case ICE_AQ_LINK_SPEED_1000MB: > + case ICE_AQ_LINK_SPEED_2500MB: > + case ICE_AQ_LINK_SPEED_5GB: > + speed = (u32)VIRTCHNL_LINK_SPEED_1GB; > + break; > + case ICE_AQ_LINK_SPEED_10GB: > + speed = (u32)VIRTCHNL_LINK_SPEED_10GB; > + break; > + case ICE_AQ_LINK_SPEED_20GB: > + speed = (u32)VIRTCHNL_LINK_SPEED_20GB; > + break; > + case ICE_AQ_LINK_SPEED_25GB: > + speed = (u32)VIRTCHNL_LINK_SPEED_25GB; > + break; > + case ICE_AQ_LINK_SPEED_40GB: > + case ICE_AQ_LINK_SPEED_50GB: > + case ICE_AQ_LINK_SPEED_100GB: > + speed = (u32)VIRTCHNL_LINK_SPEED_40GB; > + break; > + default: > + speed = (u32)VIRTCHNL_LINK_SPEED_UNKNOWN; > + break; > + } > + > + return speed; > +} > + > +/* The mailbox overflow detection algorithm helps to check if there > + * is a possibility of a malicious VF transmitting too many MBX messages to > the > + * PF. > + * 1. The mailbox snapshot structure, ice_mbx_snapshot, is initialized during > + * driver initialization in ice_init_hw() using ice_mbx_init_snapshot(). > + * The struct ice_mbx_snapshot helps to track and traverse a static window of > + * messages within the mailbox queue while looking for a malicious VF. > + * > + * 2. When the caller starts processing its mailbox queue in response to an > + * interrupt, the structure ice_mbx_snapshot is expected to be cleared before > + * the algorithm can be run for the first time for that interrupt. This can > be > + * done via ice_mbx_reset_snapshot(). > + * > + * 3. For every message read by the caller from the MBX Queue, the caller > must > + * call the detection algorithm's entry function ice_mbx_vf_state_handler(). > + * Before every call to ice_mbx_vf_state_handler() the struct ice_mbx_data is > + * filled as it is required to be passed to the algorithm. > + * > + * 4. Every time a message is read from the MBX queue, a VFId is received > which > + * is passed to the state handler. The boolean output is_malvf of the state > + * handler ice_mbx_vf_state_handler() serves as an indicator to the caller > + * whether this VF is malicious or not. > + * > + * 5. When a VF is identified to be malicious, the caller can send a message > + * to the system administrator. The caller can invoke ice_mbx_report_malvf() > + * to help determine if a malicious VF is to be reported or not. This > function > + * requires the caller to maintain a global bitmap to track all malicious VFs > + * and pass that to ice_mbx_report_malvf() along with the VFID which was > identified > + * to be malicious by ice_mbx_vf_state_handler(). > + * > + * 6. The global bitmap maintained by PF can be cleared completely if PF is > in > + * reset or the bit corresponding to a VF can be cleared if that VF is in > reset. > + * When a VF is shut down and brought back up, we assume that the new VF > + * brought up is not malicious and hence report it if found malicious. > + * > + * 7. The function ice_mbx_reset_snapshot() is called to reset the > information > + * in ice_mbx_snapshot for every new mailbox interrupt handled. > + * > + * 8. The memory allocated for variables in ice_mbx_snapshot is de-allocated > + * when driver is unloaded. > + */ > +#define ICE_RQ_DATA_MASK(rq_data) ((rq_data) & PF_MBX_ARQH_ARQH_M) > +/* Using the highest value for an unsigned 16-bit value 0xFFFF to indicate > that > + * the max messages check must be ignored in the algorithm > + */ > +#define ICE_IGNORE_MAX_MSG_CNT 0xFFFF > + > +/** > + * ice_mbx_traverse - Pass through mailbox snapshot > + * @hw: pointer to the HW struct > + * @new_state: new algorithm state > + * > + * Traversing the mailbox static snapshot without checking > + * for malicious VFs. > + */ > +static void > +ice_mbx_traverse(struct ice_hw *hw, > + enum ice_mbx_snapshot_state *new_state) > +{ > + struct ice_mbx_snap_buffer_data *snap_buf; > + u32 num_iterations; > + > + snap_buf = &hw->mbx_snapshot.mbx_buf; > + > + /* As mailbox buffer is circular, applying a mask > + * on the incremented iteration count. > + */ > + num_iterations = ICE_RQ_DATA_MASK(++snap_buf->num_iterations); > + > + /* Checking either of the below conditions to exit snapshot traversal: > + * Condition-1: If the number of iterations in the mailbox is equal to > + * the mailbox head which would indicate that we have reached the end > + * of the static snapshot. > + * Condition-2: If the maximum messages serviced in the mailbox for a > + * given interrupt is the highest possible value then there is no need > + * to check if the number of messages processed is equal to it. If not > + * check if the number of messages processed is greater than or equal > + * to the maximum number of mailbox entries serviced in current work > item. > + */ > + if (num_iterations == snap_buf->head || > + (snap_buf->max_num_msgs_mbx < ICE_IGNORE_MAX_MSG_CNT && > + ++snap_buf->num_msg_proc >= snap_buf->max_num_msgs_mbx)) > + *new_state = ICE_MAL_VF_DETECT_STATE_NEW_SNAPSHOT; > +} > + > +/** > + * ice_mbx_detect_malvf - Detect malicious VF in snapshot > + * @hw: pointer to the HW struct > + * @vf_id: relative virtual function ID > + * @new_state: new algorithm state > + * @is_malvf: boolean output to indicate if VF is malicious > + * > + * This function tracks the number of asynchronous messages > + * sent per VF and marks the VF as malicious if it exceeds > + * the permissible number of messages to send. > + */ > +static enum ice_status > +ice_mbx_detect_malvf(struct ice_hw *hw, u16 vf_id, > + enum ice_mbx_snapshot_state *new_state, > + bool *is_malvf) > +{ > + struct ice_mbx_snapshot *snap = &hw->mbx_snapshot; > + > + if (vf_id >= snap->mbx_vf.vfcntr_len) > + return ICE_ERR_OUT_OF_RANGE; > + > + /* increment the message count in the VF array */ > + snap->mbx_vf.vf_cntr[vf_id]++; > + > + if (snap->mbx_vf.vf_cntr[vf_id] >= ICE_ASYNC_VF_MSG_THRESHOLD) > + *is_malvf = true; > + > + /* continue to iterate through the mailbox snapshot */ > + ice_mbx_traverse(hw, new_state); > + > + return ICE_SUCCESS; > +} > + > +/** > + * ice_mbx_reset_snapshot - Reset mailbox snapshot structure > + * @snap: pointer to mailbox snapshot structure in the ice_hw struct > + * > + * Reset the mailbox snapshot structure and clear VF counter array. > + */ > +static void ice_mbx_reset_snapshot(struct ice_mbx_snapshot *snap) > *** 15611 LINES SKIPPED ***
