Ros-diffs April 2020

ros-diffs@reactos.org

45 participants
395 discussions

[reactos] 02/02: [REACTOS] Remove some ending spaces

by Serge Gautherie

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=268b21f92e833a096d814… commit 268b21f92e833a096d814997c7059d1bae04a871 Author: Serge Gautherie <reactos-git_serge_171003(a)gautherie.fr> AuthorDate: Sat Apr 18 16:40:42 2020 +0200 Commit: Stanislav Motylkov <x86corez(a)gmail.com> CommitDate: Fri Apr 24 02:32:05 2020 +0300 [REACTOS] Remove some ending spaces --- CONTRIBUTING.md | 6 +++--- CREDITS | 6 +++--- INSTALL | 4 ++-- README.md | 6 +++--- 4 files changed, 11 insertions(+), 11 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 562785073a6..73ea943e487 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -7,8 +7,8 @@ There are several ways to contribute to the development of ReactOS. The most oft - [Where To Start?](#where-to-start?) **Legal notice:** If you have seen Microsoft Windows source code, your contribution won't be accepted because of potential copyright violation. Before contributing, you must affirm that the following is true: ->I hereby swear that I have not used nor seen the source code to any version of the Windows operating system ->nor any Microsoft product that may be related to the proposed project that is under a license incompatible +>I hereby swear that I have not used nor seen the source code to any version of the Windows operating system +>nor any Microsoft product that may be related to the proposed project that is under a license incompatible >with contribution to ReactOS, including but not limited to the leaked Windows 2000 source code and the Windows Research Kernel. ## What To Do? @@ -53,7 +53,7 @@ Since our [migration to GitHub] we gladly accept __[Pull Requests]__. Pull reque ### Patches -A __[patch]__ is a set of changes to existing source code. The changes in a patch can be merged into existing source code. This process is referred to as applying a patch (to source code). Which changes a patch contains and the way the patch is structured can have significant impact on the consequences that can happen from applying the patch. +A __[patch]__ is a set of changes to existing source code. The changes in a patch can be merged into existing source code. This process is referred to as applying a patch (to source code). Which changes a patch contains and the way the patch is structured can have significant impact on the consequences that can happen from applying the patch. See [Submitting Patches] for details. diff --git a/CREDITS b/CREDITS index a5f36cb7e2d..f085df8cc22 100644 --- a/CREDITS +++ b/CREDITS @@ -44,11 +44,11 @@ Jason Eager Jason Filby <jasonfilby(a)yahoo.com> Jason Weiler Jean Michault -Jeffrey Morlan <mrnobo1024(a)yahoo.com> +Jeffrey Morlan <mrnobo1024(a)yahoo.com> Jerome Gardou <jerome.gardou(a)reactos.org> Jim Noeth Joachim Henze <joachim.henze(a)reactos.org> -Johannes Anderwald <johannes.anderwald(a)reactos.org> +Johannes Anderwald <johannes.anderwald(a)reactos.org> Jonathan Wilson <jonwil(a)tpgi.com.au> Jurgen van Gael <jurgen.vangael(a)student.kuleuven.ac.be> Katayama Hirofumi MZ <katayama.hirofumi.mz(a)gmail.com> @@ -93,6 +93,6 @@ Vizzini <vizzini(a)plasmic.com> Graphic Design from -Mindflyer <mf(a)mufunyo.net> +Mindflyer <mf(a)mufunyo.net> Tango Desktop Project <http://tango-project.org/> Everaldo <https://www.everaldo.com/> diff --git a/INSTALL b/INSTALL index 997812d640e..33b1710b5cf 100644 --- a/INSTALL +++ b/INSTALL @@ -88,8 +88,8 @@ contents. Then burn the CD image, boot from it, and follow instructions. ------- If you run into problems or have suggestions for making ReactOS better, please -visit the address below. Mailing lists are available for a variety of topics, -bugs should be submitted to JIRA and general chat takes place in the forums, +visit the address below. Mailing lists are available for a variety of topics, +bugs should be submitted to JIRA and general chat takes place in the forums, or #reactos on freenode. https://reactos.org/ diff --git a/README.md b/README.md index 5185d1fe77c..f093644398f 100644 --- a/README.md +++ b/README.md @@ -70,7 +70,7 @@ You can always download fresh binary builds of bootable images from the ["Daily ## Installing -By default, ReactOS currently can only be installed on a machine that has a FAT16 or FAT32 partition as the active (bootable) partition. +By default, ReactOS currently can only be installed on a machine that has a FAT16 or FAT32 partition as the active (bootable) partition. The partition on which ReactOS is to be installed (which may or may not be the bootable partition) must also be formatted as FAT16 or FAT32. ReactOS Setup can format the partitions if needed. @@ -102,10 +102,10 @@ You can also support ReactOS by [donating](https://reactos.org/donate/)! We rely ## More information -ReactOS is a Free and Open Source operating system based on the Windows architecture, +ReactOS is a Free and Open Source operating system based on the Windows architecture, providing support for existing applications and drivers, and an alternative to the current dominant consumer operating system. -It is not another wrapper built on Linux, like WINE. It does not attempt or plan to compete with WINE; in fact, the user-mode part of ReactOS is almost entirely WINE-based and our two teams have cooperated closely in the past. +It is not another wrapper built on Linux, like WINE. It does not attempt or plan to compete with WINE; in fact, the user-mode part of ReactOS is almost entirely WINE-based and our two teams have cooperated closely in the past. ReactOS is also not "yet another OS". It does not attempt to be a third player like any other alternative OS out there. People are not meant to uninstall Linux and use ReactOS instead; ReactOS is a replacement for Windows users who want a Windows replacement that behaves just like Windows.

5 years, 1 month

[reactos] 01/02: [REACTOS] Update some external URLs

by Serge Gautherie

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=7f8929c59543901f9d93a… commit 7f8929c59543901f9d93a6106a8ea05f7ba141f9 Author: Serge Gautherie <reactos-git_serge_171003(a)gautherie.fr> AuthorDate: Sat Apr 18 16:40:42 2020 +0200 Commit: Stanislav Motylkov <x86corez(a)gmail.com> CommitDate: Fri Apr 24 02:32:05 2020 +0300 [REACTOS] Update some external URLs --- .github/FUNDING.yml | 2 +- .travis.yml | 2 +- CONTRIBUTING.md | 2 +- CREDITS | 4 ++-- README.md | 6 +++--- 5 files changed, 8 insertions(+), 8 deletions(-) diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml index 7f376a5f477..a5c570ac644 100644 --- a/.github/FUNDING.yml +++ b/.github/FUNDING.yml @@ -1,2 +1,2 @@ -custom: ['https://reactos.org/donate/', 'https://paypal.me/ReactOS'] +custom: ['https://reactos.org/donate/', 'https://www.paypal.me/ReactOS'] liberapay: ReactOS diff --git a/.travis.yml b/.travis.yml index f3d331a0f89..9f123a95180 100644 --- a/.travis.yml +++ b/.travis.yml @@ -4,7 +4,7 @@ language: cpp addons: apt: sources: - - sourceline: 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-9 main' + - sourceline: 'deb https://apt.llvm.org/bionic/ llvm-toolchain-bionic-9 main' key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key' packages: clang-format-9 diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 1f3657733c8..562785073a6 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -90,7 +90,7 @@ Finding a good project to start with can be a challenge, because when starting o [migration to GitHub]: https://reactos.org/project-news/reactos-repository-migrated-github/ [humans are terrible at tracking large amount of information]: https://www.eurekalert.org/pub_releases/2005-03/aps-hmc030805.php [Pull requests]: https://help.github.com/articles/about-pull-requests/ - [tips for reviewing patches]: https://drupal.org/patch/review + [tips for reviewing patches]: https://www.drupal.org/patch/review [missing functionality]: https://reactos.org/wiki/Missing_ReactOS_Functionality [patch]: https://git-scm.com/docs/git-format-patch [Submitting Patches]: https://reactos.org/wiki/Submitting_Patches diff --git a/CREDITS b/CREDITS index 92da65f8947..a5f36cb7e2d 100644 --- a/CREDITS +++ b/CREDITS @@ -94,5 +94,5 @@ Vizzini <vizzini(a)plasmic.com> Graphic Design from Mindflyer <mf(a)mufunyo.net> -Tango Desktop Project <http://tango-project.org> -Everaldo <http://everaldo.com> +Tango Desktop Project <http://tango-project.org/> +Everaldo <https://www.everaldo.com/> diff --git a/README.md b/README.md index af6a476a985..5185d1fe77c 100644 --- a/README.md +++ b/README.md @@ -13,7 +13,7 @@ <a href="https://reactos.org/download/"> <img alt="Download ReactOS" src="https://img.shields.io/badge/download-latest-0688CB.svg"> </a> - <a href="https://sourceforge.net/projects/reactos"> + <a href="https://sourceforge.net/projects/reactos/"> <img alt="SourceForge Download" src="https://img.shields.io/sourceforge/dm/reactos.svg?colorB=0688CB"> </a> <a href="https://github.com/reactos/reactos/blob/master/COPYING"> @@ -124,14 +124,14 @@ The main development is done on [GitHub](https://github.com/reactos/reactos). We There is also an obsolete [SVN archive repository](https://svn.reactos.org/reactos/) that is kept for historical purposes. -[travis.badge]: https://travis-ci.org/reactos/reactos.svg?branch=master +[travis.badge]: https://api.travis-ci.org/reactos/reactos.svg?branch=master [appveyor.badge]: https://ci.appveyor.com/api/projects/status/github/reactos/reactos?branch=m… [coverity.badge]: https://scan.coverity.com/projects/205/badge.svg?flat=1 [rosbewin.badge]: https://img.shields.io/badge/RosBE_Windows-2.1.6-0688CB.svg [rosbeunix.badge]: https://img.shields.io/badge/RosBE_Unix-2.1.2-0688CB.svg [prwelcome.badge]: https://img.shields.io/badge/PR-welcome-0688CB.svg -[travis.link]: https://travis-ci.org/reactos/reactos +[travis.link]: https://travis-ci.org/github/reactos/reactos [appveyor.link]: https://ci.appveyor.com/project/AmineKhaldi/reactos [coverity.link]: https://scan.coverity.com/projects/205 [rosbewin.link]: https://sourceforge.net/projects/reactos/files/RosBE-Windows/i386/2.1.6/

5 years, 1 month

[reactos] 01/01: [README] Update now-redirected 'www.reactos.org' URLs (#2633)

by Serge Gautherie

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=b7503df6edf7552d20f32… commit b7503df6edf7552d20f3232db027baa987569b28 Author: Serge Gautherie <32623169+SergeGautherie(a)users.noreply.github.com> AuthorDate: Fri Apr 24 01:30:40 2020 +0200 Commit: GitHub <noreply(a)github.com> CommitDate: Fri Apr 24 02:30:40 2020 +0300 [README] Update now-redirected 'www.reactos.org' URLs (#2633) --- boot/bootdata/readme.txt | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/boot/bootdata/readme.txt b/boot/bootdata/readme.txt index 13b8e0332a6..cf8353a1a34 100644 --- a/boot/bootdata/readme.txt +++ b/boot/bootdata/readme.txt @@ -10,7 +10,7 @@ ReactOS™ is an Open Source effort to develop a quality operating system that i compatible with applications and drivers written for the Microsoft® Windows™ NT family of operating systems (NT4, 2000, XP, 2003, Vista, Seven). -More information is available at: https://www.reactos.org +More information is available at: https://reactos.org/ 2. Relationship with the WINE project @@ -56,7 +56,7 @@ exposed by the operating system. 6. Tutorials ------------ -Developer and User Tutorials: https://www.reactos.org/wiki +Developer and User Tutorials: https://reactos.org/wiki The tutorials contain more information on the project, compiling and testing ReactOS - amongst other topics. Contributors to the project are always welcome. @@ -65,8 +65,8 @@ ReactOS - amongst other topics. Contributors to the project are always welcome. 7. Frequently Asked Questions ----------------------------- -Some of your questions may be answered in: https://www.reactos.org/joining/faqs -In addition, the ReactOS forum: https://www.reactos.org/forum/ may contain +Some of your questions may be answered in: https://reactos.org/faq/ +In addition, the ReactOS forum: https://reactos.org/forum/ may contain complementary, yet non-official, information.

5 years, 1 month

[reactos] 01/01: [NETKVM] Fix GCC build

by Sylvain Deverre

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=ca2aab6964d3ea03e8874… commit ca2aab6964d3ea03e887488d21c732acb66b396d Author: Sylvain Deverre <deverre.sylv(a)gmail.com> AuthorDate: Thu Apr 23 20:11:10 2020 +0200 Commit: Sylvain Deverre <deverre.sylv(a)gmail.com> CommitDate: Thu Apr 23 20:11:10 2020 +0200 [NETKVM] Fix GCC build --- drivers/network/dd/netkvm/CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/network/dd/netkvm/CMakeLists.txt b/drivers/network/dd/netkvm/CMakeLists.txt index 5e8e5ccad0e..729068401ff 100644 --- a/drivers/network/dd/netkvm/CMakeLists.txt +++ b/drivers/network/dd/netkvm/CMakeLists.txt @@ -1,5 +1,5 @@ -include_directories(BEFORE common virtio) +include_directories(BEFORE Common virtio) add_definitions( -DNDIS_MINIPORT_DRIVER

5 years, 1 month

[reactos] 01/01: [SENDMAIL] Add french translation for "Send To" shell extension

by Kyle Katarn

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=9118a1b8af9e76ac99fa3… commit 9118a1b8af9e76ac99fa32c850c26553ca00de1b Author: Kyle Katarn <contact(a)kcsoftwares.com> AuthorDate: Thu Apr 23 19:58:32 2020 +0200 Commit: GitHub <noreply(a)github.com> CommitDate: Thu Apr 23 19:58:32 2020 +0200 [SENDMAIL] Add french translation for "Send To" shell extension --- dll/shellext/sendmail/lang/fr-FR.rc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dll/shellext/sendmail/lang/fr-FR.rc b/dll/shellext/sendmail/lang/fr-FR.rc index a5a65575e90..9b53cfd5654 100644 --- a/dll/shellext/sendmail/lang/fr-FR.rc +++ b/dll/shellext/sendmail/lang/fr-FR.rc @@ -3,5 +3,5 @@ LANGUAGE LANG_FRENCH, SUBLANG_NEUTRAL STRINGTABLE { IDS_DESKLINK, "Bureau (Créer un raccourci)" - IDS_SHORTCUT, "Shortcut to %s" + IDS_SHORTCUT, "Raccourci vers %s" }

5 years, 1 month

[reactos] 01/01: [NETKVM] Fix Build

by James Tabor

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=eecfb2362d16107be4c65… commit eecfb2362d16107be4c658daf8a8ca947cd1bfc4 Author: James Tabor <james.tabor(a)reactos.org> AuthorDate: Thu Apr 23 09:33:32 2020 -0500 Commit: James Tabor <james.tabor(a)reactos.org> CommitDate: Thu Apr 23 09:33:32 2020 -0500 [NETKVM] Fix Build --- drivers/network/dd/netkvm/CMakeLists.txt | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/drivers/network/dd/netkvm/CMakeLists.txt b/drivers/network/dd/netkvm/CMakeLists.txt index 6906334f40e..5e8e5ccad0e 100644 --- a/drivers/network/dd/netkvm/CMakeLists.txt +++ b/drivers/network/dd/netkvm/CMakeLists.txt @@ -6,11 +6,11 @@ add_definitions( -DNDIS51_MINIPORT=1) list(APPEND SOURCE - common/ParaNdis-Common.c - common/ParaNdis-Oid.c - common/ParaNdis-VirtIO.c - common/ParaNdis-Debug.c - common/sw-offload.c + Common/ParaNdis-Common.c + Common/ParaNdis-Oid.c + Common/ParaNdis-VirtIO.c + Common/ParaNdis-Debug.c + Common/sw-offload.c virtio/VirtIOPCICommon.c virtio/VirtIOPCILegacy.c virtio/VirtIOPCIModern.c

5 years, 1 month

[reactos] 01/01: [NETKVM] Import NetKVM network adapter driver by Red Hat CORE-15841

by Nguyen Trung Khanh

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=4c37757e81109128109fe… commit 4c37757e81109128109feb0a0a9342452c6caf78 Author: Nguyen Trung Khanh <nguyentrungkhanh97(a)gmail.com> AuthorDate: Thu Mar 5 10:58:56 2020 +0700 Commit: Victor Perevertkin <victor.perevertkin(a)reactos.org> CommitDate: Thu Apr 23 16:33:09 2020 +0300 [NETKVM] Import NetKVM network adapter driver by Red Hat CORE-15841 --- drivers/network/dd/CMakeLists.txt | 1 + drivers/network/dd/netkvm/CMakeLists.txt | 37 + drivers/network/dd/netkvm/Common/DebugData.h | 193 ++ drivers/network/dd/netkvm/Common/IONetDescriptor.h | 133 + drivers/network/dd/netkvm/Common/ParaNdis-Common.c | 3017 ++++++++++++++++++++ drivers/network/dd/netkvm/Common/ParaNdis-Debug.c | 394 +++ drivers/network/dd/netkvm/Common/ParaNdis-Oid.c | 677 +++++ drivers/network/dd/netkvm/Common/ParaNdis-Oid.h | 104 + drivers/network/dd/netkvm/Common/ParaNdis-VirtIO.c | 389 +++ drivers/network/dd/netkvm/Common/ethernetutils.h | 123 + drivers/network/dd/netkvm/Common/kdebugprint.h | 108 + drivers/network/dd/netkvm/Common/ndis56common.h | 892 ++++++ drivers/network/dd/netkvm/Common/quverp.h | 45 + drivers/network/dd/netkvm/Common/rhel.ver | 64 + drivers/network/dd/netkvm/Common/sw-offload.c | 619 ++++ drivers/network/dd/netkvm/Common/vendor.ver | 98 + drivers/network/dd/netkvm/virtio/LICENSE | 30 + drivers/network/dd/netkvm/virtio/VirtIO.h | 128 + drivers/network/dd/netkvm/virtio/VirtIOPCICommon.c | 411 +++ drivers/network/dd/netkvm/virtio/VirtIOPCILegacy.c | 283 ++ drivers/network/dd/netkvm/virtio/VirtIOPCIModern.c | 597 ++++ .../network/dd/netkvm/virtio/VirtIORing-Packed.c | 651 +++++ drivers/network/dd/netkvm/virtio/VirtIORing.c | 562 ++++ drivers/network/dd/netkvm/virtio/kdebugprint.h | 11 + drivers/network/dd/netkvm/virtio/linux/types.h | 19 + .../network/dd/netkvm/virtio/linux/virtio_config.h | 73 + .../network/dd/netkvm/virtio/linux/virtio_types.h | 47 + drivers/network/dd/netkvm/virtio/osdep.h | 39 + drivers/network/dd/netkvm/virtio/virtio_pci.h | 392 +++ .../network/dd/netkvm/virtio/virtio_pci_common.h | 88 + drivers/network/dd/netkvm/virtio/virtio_ring.h | 50 + .../netkvm/virtio/windows/virtio_ring_allocation.h | 24 + drivers/network/dd/netkvm/wxp/ParaNdis5-Driver.c | 452 +++ drivers/network/dd/netkvm/wxp/ParaNdis5-Impl.c | 1474 ++++++++++ drivers/network/dd/netkvm/wxp/ParaNdis5-Oid.c | 785 +++++ drivers/network/dd/netkvm/wxp/ParaNdis5.h | 88 + drivers/network/dd/netkvm/wxp/netkvm.inx | 331 +++ drivers/network/dd/netkvm/wxp/parandis.rc | 31 + media/inf/CMakeLists.txt | 1 + media/inf/netkvm.inf | 331 +++ sdk/include/ddk/ndis.h | 6 +- sdk/include/xdk/kefuncs.h | 2 +- 42 files changed, 13796 insertions(+), 4 deletions(-) diff --git a/drivers/network/dd/CMakeLists.txt b/drivers/network/dd/CMakeLists.txt index 89b96df4897..39a20fce8e3 100644 --- a/drivers/network/dd/CMakeLists.txt +++ b/drivers/network/dd/CMakeLists.txt @@ -1,5 +1,6 @@ add_subdirectory(e1000) add_subdirectory(ne2000) +add_subdirectory(netkvm) add_subdirectory(pcnet) add_subdirectory(rtl8139) diff --git a/drivers/network/dd/netkvm/CMakeLists.txt b/drivers/network/dd/netkvm/CMakeLists.txt new file mode 100644 index 00000000000..6906334f40e --- /dev/null +++ b/drivers/network/dd/netkvm/CMakeLists.txt @@ -0,0 +1,37 @@ + +include_directories(BEFORE common virtio) + +add_definitions( + -DNDIS_MINIPORT_DRIVER + -DNDIS51_MINIPORT=1) + +list(APPEND SOURCE + common/ParaNdis-Common.c + common/ParaNdis-Oid.c + common/ParaNdis-VirtIO.c + common/ParaNdis-Debug.c + common/sw-offload.c + virtio/VirtIOPCICommon.c + virtio/VirtIOPCILegacy.c + virtio/VirtIOPCIModern.c + virtio/VirtIORing.c + virtio/VirtIORing-Packed.c + wxp/ParaNdis5-Driver.c + wxp/ParaNdis5-Impl.c + wxp/ParaNdis5-Oid.c) + +add_library(netkvm MODULE ${SOURCE} wxp/parandis.rc) +set_module_type(netkvm kernelmodedriver) +add_importlibs(netkvm ndis ntoskrnl hal) +add_cd_file(TARGET netkvm DESTINATION reactos/system32/drivers FOR all) + +if (NOT MSVC) + add_compile_flags("-Wno-unused-function") + add_compile_flags("-Wno-old-style-declaration") + add_compile_flags("-Wno-unknown-pragmas") + add_compile_flags("-Wno-unused-but-set-variable") + add_compile_flags("-Wno-pointer-sign") + add_compile_flags("-Wno-pointer-to-int-cast") + add_compile_flags("-Wno-int-to-pointer-cast") + add_compile_flags("-Wno-attributes") +endif() diff --git a/drivers/network/dd/netkvm/Common/DebugData.h b/drivers/network/dd/netkvm/Common/DebugData.h new file mode 100644 index 00000000000..cf0bf849f6a --- /dev/null +++ b/drivers/network/dd/netkvm/Common/DebugData.h @@ -0,0 +1,193 @@ +/* + * This file contains definitions and data structures, common between + * NDIS driver and debugger helper unit, processing crash dump with built-in + * data provided by the driver. + * + * Included in NetKVM NDIS kernel driver for Windows. + * Included in NetKVMDumpParser application. + * + * Copyright (c) 2008-2017 Red Hat, Inc. + * + * 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 names of the copyright holders nor the names of their 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 HOLDERS 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. + */ + +#ifndef PARANDIS_DEBUG_DATA_H +#define PARANDIS_DEBUG_DATA_H + +typedef enum _etagHistoryLogOperation +{ + hopPowerOff, // common::PowerOff, 1/0 - entry/exit (none, entry, none, none) + hopPowerOn, // common::PowerOn, 1/0 - entry/exit (none, entry, none, none) + hopSysPause, // ndis6::Pause, 1/0 - entry/completion + hopSysResume, // ndis6::Restart, 1/0 - entry/completion + hopInternalSendPause, // implementation, 1/0 - entry/completion + hopInternalReceivePause, // implementation, 1/0 - entry/completion + hopInternalSendResume, // implementation + hopInternalReceiveResume, // implementation + hopSysReset, // implementation driver, 1/0 - entry/completion + hopHalt, // implementation driver, 1/0 - entry/completion + hopConnectIndication, // implementation + hopDPC, // common::DpcWorkBody (1, none, none, none) (0, left, free buffers, free desc) + hopSend, // implementation, when Send requested (nbl, nof lists, nof bufs, nof bytes) (packet, 1, nof packets, none) + hopSendNBLRequest, // ndis6 implementation (nbl, nof packets, none, none) + hopSendPacketRequest, // not used + hopSendPacketMapped, // implementation, before the packet inserted into queue (nbl, which packet, nof frags, none) + hopSubmittedPacket, // implementation, when the packet submitted (nbl, which packet, result, flags) + hopBufferSent, // implementation, when the packet returned from VirtIO queue (nbl, packet no., free buf, free desc) + hopReceiveStat, // common: RX (none, retrieved, reported, ready rx buffers) + hopBufferReturned, // not used + hopSendComplete, // implementation, when the packet completed + hopTxProcess, + hopPacketReceived, // implementation, when the packet prepared for indication (nbl, length, prio tag, type) + hopOidRequest, // implementation, none, OID, on entry(type, 1), on exit (status, 0), on complete (status, 2) + hopPnpEvent // common, none, event, 0, 0 +}eHistoryLogOperation; + +// {E51FCE18-B3E7-441e-B18C-D9E9B71616F3} +static const GUID ParaNdis_CrashGuid = +{ 0xe51fce18, 0xb3e7, 0x441e, { 0xb1, 0x8c, 0xd9, 0xe9, 0xb7, 0x16, 0x16, 0xf3 } }; + +/* This structure is NOT changeable */ +typedef struct _tagBugCheckStaticDataHeader +{ + USHORT SizeOfPointer; + USHORT StaticDataVersion; + USHORT PerNicDataVersion; + USHORT ulMaxContexts; + LARGE_INTEGER qCrashTime; + UINT64 PerNicData; + UINT64 DataArea; + UINT64 DataAreaSize; +}tBugCheckStaticDataHeader; + +/* This structure is NOT changeable */ +typedef struct _tagBugCheckDataLocation +{ + UINT64 Address; + UINT64 Size; +}tBugCheckDataLocation; + +#define PARANDIS_DEBUG_STATIC_DATA_VERSION 0 +#define PARANDIS_DEBUG_PER_NIC_DATA_VERSION 0 +#define PARANDIS_DEBUG_HISTORY_DATA_VERSION 1 +/* This structure is NOT changeable */ +typedef struct _tagBugCheckStaticDataContent_V0 +{ + ULONG SizeOfHistory; + ULONG SizeOfHistoryEntry; + LONG CurrentHistoryIndex; + ULONG HistoryDataVersion; + ULONG64 HistoryData; +}tBugCheckStaticDataContent_V0; + +#define PARANDIS_DEBUG_INTERRUPTS + +#ifdef PARANDIS_DEBUG_INTERRUPTS +# define PARANDIS_STORE_LAST_INTERRUPT_TIMESTAMP(p) \ + NdisGetCurrentSystemTime(&(p)->LastInterruptTimeStamp) +# define PARANDIS_GET_LAST_INTERRUPT_TIMESTAMP(p) \ + (p)->LastInterruptTimeStamp.QuadPart +#else +# define PARANDIS_STORE_LAST_INTERRUPT_TIMESTAMP(p) +# define PARANDIS_GET_LAST_INTERRUPT_TIMESTAMP(p) (0) +#endif + +typedef struct _tagBugCheckPerNicDataContent_V0 +{ + UINT64 Context; + LARGE_INTEGER LastInterruptTimeStamp; + LARGE_INTEGER LastTxCompletionTimeStamp; + ULONG nofPacketsToComplete; + ULONG nofReadyTxBuffers; +}tBugCheckPerNicDataContent_V0; + +typedef struct _tagBugCheckHistoryDataEntry_V0 +{ + LARGE_INTEGER TimeStamp; + UINT64 Context; + UINT64 pParam1; + ULONG operation; + ULONG lParam2; + ULONG lParam3; + ULONG lParam4; +}tBugCheckHistoryDataEntry_V0; + +typedef struct _tagBugCheckHistoryDataEntry_V1 +{ + LARGE_INTEGER TimeStamp; + UINT64 Context; + ULONG uIRQL; + ULONG uProcessor; + UINT64 pParam1; + ULONG operation; + ULONG lParam2; + ULONG lParam3; + ULONG lParam4; +}tBugCheckHistoryDataEntry_V1; + + +#if (PARANDIS_DEBUG_STATIC_DATA_VERSION == 0) +typedef tBugCheckStaticDataContent_V0 tBugCheckStaticDataContent; +#endif + +#if (PARANDIS_DEBUG_PER_NIC_DATA_VERSION == 0) +typedef tBugCheckPerNicDataContent_V0 tBugCheckPerNicDataContent; +#endif + +#if (PARANDIS_DEBUG_HISTORY_DATA_VERSION == 0) +typedef tBugCheckHistoryDataEntry_V0 tBugCheckHistoryDataEntry; +#elif (PARANDIS_DEBUG_HISTORY_DATA_VERSION == 1) +typedef tBugCheckHistoryDataEntry_V1 tBugCheckHistoryDataEntry; +#endif + +typedef struct _tagBugCheckStaticDataContent_V1 +{ + UINT64 res1; + UINT64 res2; + UINT64 History; +}tBugCheckStaticDataContent_V1; + +typedef struct _tagBugCheckPerNicDataContent_V1 +{ + UINT64 Context; + LARGE_INTEGER LastInterruptTimeStamp; + LARGE_INTEGER LastTxCompletionTimeStamp; + ULONG nofPacketsToComplete; + ULONG nofReadyTxBuffers; +}tBugCheckPerNicDataContent_V1; + + +#if (PARANDIS_DEBUG_HEADER_VERSION == 1) +typedef tBugCheckStaticDataContent_V1 tBugCheckStaticDataContent; +#endif + +#if (PARANDIS_DEBUG_PER_NIC_DATA_VERSION == 1) +typedef tBugCheckPerNicDataContent_V1 tBugCheckPerNicDataContent; +#endif + +// etc + + + +#endif diff --git a/drivers/network/dd/netkvm/Common/IONetDescriptor.h b/drivers/network/dd/netkvm/Common/IONetDescriptor.h new file mode 100644 index 00000000000..8e9a05b2110 --- /dev/null +++ b/drivers/network/dd/netkvm/Common/IONetDescriptor.h @@ -0,0 +1,133 @@ +/* + * This file contains common guest/host definition, related + * to VirtIO network adapter + * + * Copyright (c) 2008-2017 Red Hat, Inc. + * + * 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 names of the copyright holders nor the names of their 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 HOLDERS 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. + */ +#ifndef IONETDESCRIPTOR_H +#define IONETDESCRIPTOR_H + +#pragma pack (push) +#pragma pack (1) +/* This is the first element of the scatter-gather list. If you don't + * specify GSO or CSUM features, you can simply ignore the header. */ +typedef struct _tagvirtio_net_hdr +{ +#define VIRTIO_NET_HDR_F_NEEDS_CSUM 1 // Use csum_start, csum_offset +#define VIRTIO_NET_HDR_F_DATA_VALID 2 // Host checked checksum, no need to recheck + u8 flags; +#define VIRTIO_NET_HDR_GSO_NONE 0 // Not a GSO frame +#define VIRTIO_NET_HDR_GSO_TCPV4 1 // GSO frame, IPv4 TCP (TSO) +#define VIRTIO_NET_HDR_GSO_UDP 3 // GSO frame, IPv4 UDP (UFO) +#define VIRTIO_NET_HDR_GSO_TCPV6 4 // GSO frame, IPv6 TCP +#define VIRTIO_NET_HDR_GSO_ECN 0x80 // TCP has ECN set + u8 gso_type; + u16 hdr_len; // Ethernet + IP + tcp/udp hdrs + u16 gso_size; // Bytes to append to gso_hdr_len per frame + u16 csum_start; // Position to start checksumming from + u16 csum_offset; // Offset after that to place checksum +}virtio_net_hdr_basic; + +typedef struct _tagvirtio_net_hdr_ext +{ + virtio_net_hdr_basic BasicHeader; + u16 nBuffers; +}virtio_net_hdr_ext; + +/* + * Control virtqueue data structures + * + * The control virtqueue expects a header in the first sg entry + * and an ack/status response in the last entry. Data for the + * command goes in between. + */ +typedef struct tag_virtio_net_ctrl_hdr { + u8 class_of_command; + u8 cmd; +}virtio_net_ctrl_hdr; + +typedef u8 virtio_net_ctrl_ack; + +#define VIRTIO_NET_OK 0 +#define VIRTIO_NET_ERR 1 + +/* + * Control the RX mode, ie. promiscuous, allmulti, etc... + * All commands require an "out" sg entry containing a 1 byte + * state value, zero = disable, non-zero = enable. Commands + * 0 and 1 are supported with the VIRTIO_NET_F_CTRL_RX feature. + * Commands 2-5 are added with VIRTIO_NET_F_CTRL_RX_EXTRA. + */ +#define VIRTIO_NET_CTRL_RX_MODE 0 + #define VIRTIO_NET_CTRL_RX_MODE_PROMISC 0 + #define VIRTIO_NET_CTRL_RX_MODE_ALLMULTI 1 + #define VIRTIO_NET_CTRL_RX_MODE_ALLUNI 2 + #define VIRTIO_NET_CTRL_RX_MODE_NOMULTI 3 + #define VIRTIO_NET_CTRL_RX_MODE_NOUNI 4 + #define VIRTIO_NET_CTRL_RX_MODE_NOBCAST 5 + +/* + * Control the MAC filter table. + * + * The MAC filter table is managed by the hypervisor, the guest should + * assume the size is infinite. Filtering should be considered + * non-perfect, ie. based on hypervisor resources, the guest may + * received packets from sources not specified in the filter list. + * + * In addition to the class/cmd header, the TABLE_SET command requires + * two out scatterlists. Each contains a 4 byte count of entries followed + * by a concatenated byte stream of the ETH_ALEN MAC addresses. The + * first sg list contains unicast addresses, the second is for multicast. + * This functionality is present if the VIRTIO_NET_F_CTRL_RX feature + * is available. + */ +#define ETH_ALEN 6 + +struct virtio_net_ctrl_mac { + u32 entries; + // follows + //u8 macs[][ETH_ALEN]; +}; +#define VIRTIO_NET_CTRL_MAC 1 + #define VIRTIO_NET_CTRL_MAC_TABLE_SET 0 + +/* + * Control VLAN filtering + * + * The VLAN filter table is controlled via a simple ADD/DEL interface. + * VLAN IDs not added may be filterd by the hypervisor. Del is the + * opposite of add. Both commands expect an out entry containing a 2 + * byte VLAN ID. VLAN filtering is available with the + * VIRTIO_NET_F_CTRL_VLAN feature bit. + */ +#define VIRTIO_NET_CTRL_VLAN 2 + #define VIRTIO_NET_CTRL_VLAN_ADD 0 + #define VIRTIO_NET_CTRL_VLAN_DEL 1 + + +#pragma pack (pop) + +#endif diff --git a/drivers/network/dd/netkvm/Common/ParaNdis-Common.c b/drivers/network/dd/netkvm/Common/ParaNdis-Common.c new file mode 100644 index 00000000000..ebb0c04b981 --- /dev/null +++ b/drivers/network/dd/netkvm/Common/ParaNdis-Common.c @@ -0,0 +1,3017 @@ +/* + * This file contains NDIS driver procedures, common for NDIS5 and NDIS6 + * + * Copyright (c) 2008-2017 Red Hat, Inc. + * + * 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 names of the copyright holders nor the names of their 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 HOLDERS 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 "ndis56common.h" + +#ifdef WPP_EVENT_TRACING +#include "ParaNdis-Common.tmh" +#endif + +static void ReuseReceiveBufferRegular(PARANDIS_ADAPTER *pContext, pIONetDescriptor pBuffersDescriptor); +static void ReuseReceiveBufferPowerOff(PARANDIS_ADAPTER *pContext, pIONetDescriptor pBuffersDescriptor); + +//#define ROUNDSIZE(sz) ((sz + 15) & ~15) +#define MAX_VLAN_ID 4095 + +#if 0 +void FORCEINLINE DebugDumpPacket(LPCSTR prefix, PVOID header, int level) +{ + PUCHAR peth = (PUCHAR)header; + DPrintf(level, ("[%s] %02X%02X%02X%02X%02X%02X => %02X%02X%02X%02X%02X%02X", prefix, + peth[6], peth[7], peth[8], peth[9], peth[10], peth[11], + peth[0], peth[1], peth[2], peth[3], peth[4], peth[5])); +} +#else +void FORCEINLINE DebugDumpPacket(LPCSTR prefix, PVOID header, int level) +{ +} +#endif + + + +/********************************************************** +Validates MAC address +Valid MAC address is not broadcast, not multicast, not empty +if bLocal is set, it must be LOCAL +if not, is must be non-local or local +Parameters: + PUCHAR pcMacAddress - MAC address to validate + BOOLEAN bLocal - TRUE, if we validate locally administered address +Return value: + TRUE if valid +***********************************************************/ +BOOLEAN ParaNdis_ValidateMacAddress(PUCHAR pcMacAddress, BOOLEAN bLocal) +{ + BOOLEAN bLA = FALSE, bEmpty, bBroadcast, bMulticast = FALSE; + bBroadcast = ETH_IS_BROADCAST(pcMacAddress); + bLA = !bBroadcast && ETH_IS_LOCALLY_ADMINISTERED(pcMacAddress); + bMulticast = !bBroadcast && ETH_IS_MULTICAST(pcMacAddress); + bEmpty = ETH_IS_EMPTY(pcMacAddress); + return !bBroadcast && !bEmpty && !bMulticast && (!bLocal || bLA); +} + +static eInspectedPacketType QueryPacketType(PVOID data) +{ + if (ETH_IS_BROADCAST(data)) + return iptBroadcast; + if (ETH_IS_MULTICAST(data)) + return iptMulticast; + return iptUnicast; +} + +typedef struct _tagConfigurationEntry +{ + const char *Name; + ULONG ulValue; + ULONG ulMinimal; + ULONG ulMaximal; +}tConfigurationEntry; + +typedef struct _tagConfigurationEntries +{ + tConfigurationEntry isPromiscuous; + tConfigurationEntry PrioritySupport; + tConfigurationEntry ConnectRate; + tConfigurationEntry isLogEnabled; + tConfigurationEntry debugLevel; + tConfigurationEntry connectTimer; + tConfigurationEntry dpcChecker; + tConfigurationEntry TxCapacity; + tConfigurationEntry RxCapacity; + tConfigurationEntry InterruptRecovery; + tConfigurationEntry LogStatistics; + tConfigurationEntry PacketFiltering; + tConfigurationEntry ScatterGather; + tConfigurationEntry BatchReceive; + tConfigurationEntry OffloadTxChecksum; + tConfigurationEntry OffloadTxLSO; + tConfigurationEntry OffloadRxCS; + tConfigurationEntry OffloadGuestCS; + tConfigurationEntry UseSwTxChecksum; + tConfigurationEntry IPPacketsCheck; + tConfigurationEntry stdIpcsV4; + tConfigurationEntry stdTcpcsV4; + tConfigurationEntry stdTcpcsV6; + tConfigurationEntry stdUdpcsV4; + tConfigurationEntry stdUdpcsV6; + tConfigurationEntry stdLsoV1; + tConfigurationEntry stdLsoV2ip4; + tConfigurationEntry stdLsoV2ip6; + tConfigurationEntry PriorityVlanTagging; + tConfigurationEntry VlanId; + tConfigurationEntry UseMergeableBuffers; + tConfigurationEntry MTU; + tConfigurationEntry NumberOfHandledRXPackersInDPC; + tConfigurationEntry Indirect; +}tConfigurationEntries; + +static const tConfigurationEntries defaultConfiguration = +{ + { "Promiscuous", 0, 0, 1 }, + { "Priority", 0, 0, 1 }, + { "ConnectRate", 100,10,10000 }, + { "DoLog", 1, 0, 1 }, + { "DebugLevel", 2, 0, 8 }, + { "ConnectTimer", 0, 0, 300000 }, + { "DpcCheck", 0, 0, 2 }, + { "TxCapacity", 1024, 16, 1024 }, + { "RxCapacity", 256, 32, 1024 }, + { "InterruptRecovery", 0, 0, 1}, + { "LogStatistics", 0, 0, 10000}, + { "PacketFilter", 1, 0, 1}, + { "Gather", 1, 0, 1}, + { "BatchReceive", 1, 0, 1}, + { "Offload.TxChecksum", 0, 0, 31}, + { "Offload.TxLSO", 0, 0, 2}, + { "Offload.RxCS", 0, 0, 31}, + { "Offload.GuestCS", 0, 0, 1}, + { "UseSwTxChecksum", 0, 0, 1 }, + { "IPPacketsCheck", 0, 0, 3 }, + { "*IPChecksumOffloadIPv4", 3, 0, 3 }, + { "*TCPChecksumOffloadIPv4",3, 0, 3 }, + { "*TCPChecksumOffloadIPv6",3, 0, 3 }, + { "*UDPChecksumOffloadIPv4",3, 0, 3 }, + { "*UDPChecksumOffloadIPv6",3, 0, 3 }, + { "*LsoV1IPv4", 1, 0, 1 }, + { "*LsoV2IPv4", 1, 0, 1 }, + { "*LsoV2IPv6", 1, 0, 1 }, + { "*PriorityVLANTag", 3, 0, 3}, + { "VlanId", 0, 0, MAX_VLAN_ID}, + { "MergeableBuf", 1, 0, 1}, + { "MTU", 1500, 500, 65500}, + { "NumberOfHandledRXPackersInDPC", MAX_RX_LOOPS, 1, 10000}, + { "Indirect", 0, 0, 2}, +}; + +static void ParaNdis_ResetVirtIONetDevice(PARANDIS_ADAPTER *pContext) +{ + virtio_device_reset(&pContext->IODevice); + DPrintf(0, ("[%s] Done", __FUNCTION__)); + /* reset all the features in the device */ + pContext->ulCurrentVlansFilterSet = 0; + pContext->ullGuestFeatures = 0; +#ifdef VIRTIO_RESET_VERIFY + if (1) + { + u8 devStatus; + devStatus = virtio_get_status(&pContext->IODevice); + if (devStatus) + { + DPrintf(0, ("[%s] Device status is still %02X", __FUNCTION__, (ULONG)devStatus)); + virtio_device_reset(&pContext->IODevice); + devStatus = virtio_get_status(&pContext->IODevice); + DPrintf(0, ("[%s] Device status on retry %02X", __FUNCTION__, (ULONG)devStatus)); + } + } +#endif +} + +/********************************************************** +Gets integer value for specifies in pEntry->Name name +Parameters: + NDIS_HANDLE cfg previously open configuration + tConfigurationEntry *pEntry - Entry to fill value in +***********************************************************/ +static void GetConfigurationEntry(NDIS_HANDLE cfg, tConfigurationEntry *pEntry) +{ + NDIS_STATUS status; + const char *statusName; + NDIS_STRING name = {0}; + PNDIS_CONFIGURATION_PARAMETER pParam = NULL; + NDIS_PARAMETER_TYPE ParameterType = NdisParameterInteger; + NdisInitializeString(&name, (PUCHAR)pEntry->Name); + NdisReadConfiguration( + &status, + &pParam, + cfg, + &name, + ParameterType); + if (status == NDIS_STATUS_SUCCESS) + { + ULONG ulValue = pParam->ParameterData.IntegerData; + if (ulValue >= pEntry->ulMinimal && ulValue <= pEntry->ulMaximal) + { + pEntry->ulValue = ulValue; + statusName = "value"; + } + else + { + statusName = "out of range"; + } + } + else + { + statusName = "nothing"; + } + DPrintf(2, ("[%s] %s read for %s - 0x%x", + __FUNCTION__, + statusName, + pEntry->Name, + pEntry->ulValue)); + if (name.Buffer) NdisFreeString(name); +} + +static void DisableLSOv4Permanently(PARANDIS_ADAPTER *pContext, LPCSTR procname, LPCSTR reason) +{ + if (pContext->Offload.flagsValue & osbT4Lso) + { + DPrintf(0, ("[%s] Warning: %s", procname, reason)); + pContext->Offload.flagsValue &= ~osbT4Lso; + ParaNdis_ResetOffloadSettings(pContext, NULL, NULL); + } +} + +static void DisableLSOv6Permanently(PARANDIS_ADAPTER *pContext, LPCSTR procname, LPCSTR reason) +{ + if (pContext->Offload.flagsValue & osbT6Lso) + { + DPrintf(0, ("[%s] Warning: %s", procname, reason)); + pContext->Offload.flagsValue &= ~osbT6Lso; + ParaNdis_ResetOffloadSettings(pContext, NULL, NULL); + } +} + +static void DisableBothLSOPermanently(PARANDIS_ADAPTER *pContext, LPCSTR procname, LPCSTR reason) +{ + if (pContext->Offload.flagsValue & (osbT4Lso | osbT6Lso)) + { + DPrintf(0, ("[%s] Warning: %s", procname, reason)); + pContext->Offload.flagsValue &= ~(osbT6Lso | osbT4Lso); + ParaNdis_ResetOffloadSettings(pContext, NULL, NULL); + } +} + +/********************************************************** +Loads NIC parameters from adapter registry key +Parameters: + context + PUCHAR *ppNewMACAddress - pointer to hold MAC address if configured from host +***********************************************************/ +static void ReadNicConfiguration(PARANDIS_ADAPTER *pContext, PUCHAR *ppNewMACAddress) +{ + NDIS_HANDLE cfg; + tConfigurationEntries *pConfiguration = ParaNdis_AllocateMemory(pContext, sizeof(tConfigurationEntries)); + if (pConfiguration) + { + *pConfiguration = defaultConfiguration; + cfg = ParaNdis_OpenNICConfiguration(pContext); + if (cfg) + { + GetConfigurationEntry(cfg, &pConfiguration->isLogEnabled); + GetConfigurationEntry(cfg, &pConfiguration->debugLevel); + GetConfigurationEntry(cfg, &pConfiguration->ConnectRate); + GetConfigurationEntry(cfg, &pConfiguration->PrioritySupport); + GetConfigurationEntry(cfg, &pConfiguration->isPromiscuous); + GetConfigurationEntry(cfg, &pConfiguration->TxCapacity); + GetConfigurationEntry(cfg, &pConfiguration->RxCapacity); + GetConfigurationEntry(cfg, &pConfiguration->connectTimer); + GetConfigurationEntry(cfg, &pConfiguration->dpcChecker); + GetConfigurationEntry(cfg, &pConfiguration->InterruptRecovery); + GetConfigurationEntry(cfg, &pConfiguration->LogStatistics); + GetConfigurationEntry(cfg, &pConfiguration->PacketFiltering); + GetConfigurationEntry(cfg, &pConfiguration->ScatterGather); + GetConfigurationEntry(cfg, &pConfiguration->BatchReceive); + GetConfigurationEntry(cfg, &pConfiguration->OffloadTxChecksum); + GetConfigurationEntry(cfg, &pConfiguration->OffloadTxLSO); + GetConfigurationEntry(cfg, &pConfiguration->OffloadRxCS); + GetConfigurationEntry(cfg, &pConfiguration->OffloadGuestCS); + GetConfigurationEntry(cfg, &pConfiguration->UseSwTxChecksum); + GetConfigurationEntry(cfg, &pConfiguration->IPPacketsCheck); + GetConfigurationEntry(cfg, &pConfiguration->stdIpcsV4); + GetConfigurationEntry(cfg, &pConfiguration->stdTcpcsV4); + GetConfigurationEntry(cfg, &pConfiguration->stdTcpcsV6); + GetConfigurationEntry(cfg, &pConfiguration->stdUdpcsV4); + GetConfigurationEntry(cfg, &pConfiguration->stdUdpcsV6); + GetConfigurationEntry(cfg, &pConfiguration->stdLsoV1); + GetConfigurationEntry(cfg, &pConfiguration->stdLsoV2ip4); + GetConfigurationEntry(cfg, &pConfiguration->stdLsoV2ip6); + GetConfigurationEntry(cfg, &pConfiguration->PriorityVlanTagging); + GetConfigurationEntry(cfg, &pConfiguration->VlanId); + GetConfigurationEntry(cfg, &pConfiguration->UseMergeableBuffers); + GetConfigurationEntry(cfg, &pConfiguration->MTU); + GetConfigurationEntry(cfg, &pConfiguration->NumberOfHandledRXPackersInDPC); + GetConfigurationEntry(cfg, &pConfiguration->Indirect); + + #if !defined(WPP_EVENT_TRACING) + bDebugPrint = pConfiguration->isLogEnabled.ulValue; + nDebugLevel = pConfiguration->debugLevel.ulValue; + #endif + // ignoring promiscuous setting, nothing to do with it + pContext->maxFreeTxDescriptors = pConfiguration->TxCapacity.ulValue; + pContext->NetMaxReceiveBuffers = pConfiguration->RxCapacity.ulValue; + pContext->ulMilliesToConnect = pConfiguration->connectTimer.ulValue; + pContext->nEnableDPCChecker = pConfiguration->dpcChecker.ulValue; + pContext->bDoInterruptRecovery = pConfiguration->InterruptRecovery.ulValue != 0; + pContext->Limits.nPrintDiagnostic = pConfiguration->LogStatistics.ulValue; + pContext->uNumberOfHandledRXPacketsInDPC = pConfiguration->NumberOfHandledRXPackersInDPC.ulValue; + pContext->bDoSupportPriority = pConfiguration->PrioritySupport.ulValue != 0; + pContext->ulFormalLinkSpeed = pConfiguration->ConnectRate.ulValue; + pContext->ulFormalLinkSpeed *= 1000000; + pContext->bDoHwPacketFiltering = pConfiguration->PacketFiltering.ulValue != 0; + pContext->bUseScatterGather = pConfiguration->ScatterGather.ulValue != 0; + pContext->bBatchReceive = pConfiguration->BatchReceive.ulValue != 0; + pContext->bDoHardwareChecksum = pConfiguration->UseSwTxChecksum.ulValue == 0; + pContext->bDoGuestChecksumOnReceive = pConfiguration->OffloadGuestCS.ulValue != 0; + pContext->bDoIPCheckTx = pConfiguration->IPPacketsCheck.ulValue & 1; + pContext->bDoIPCheckRx = pConfiguration->IPPacketsCheck.ulValue & 2; + pContext->Offload.flagsValue = 0; + // TX caps: 1 - TCP, 2 - UDP, 4 - IP, 8 - TCPv6, 16 - UDPv6 + if (pConfiguration->OffloadTxChecksum.ulValue & 1) pContext->Offload.flagsValue |= osbT4TcpChecksum | osbT4TcpOptionsChecksum; + if (pConfiguration->OffloadTxChecksum.ulValue & 2) pContext->Offload.flagsValue |= osbT4UdpChecksum; + if (pConfiguration->OffloadTxChecksum.ulValue & 4) pContext->Offload.flagsValue |= osbT4IpChecksum | osbT4IpOptionsChecksum; + if (pConfiguration->OffloadTxChecksum.ulValue & 8) pContext->Offload.flagsValue |= osbT6TcpChecksum | osbT6TcpOptionsChecksum; + if (pConfiguration->OffloadTxChecksum.ulValue & 16) pContext->Offload.flagsValue |= osbT6UdpChecksum; + if (pConfiguration->OffloadTxLSO.ulValue) pContext->Offload.flagsValue |= osbT4Lso | osbT4LsoIp | osbT4LsoTcp; + if (pConfiguration->OffloadTxLSO.ulValue > 1) pContext->Offload.flagsValue |= osbT6Lso | osbT6LsoTcpOptions; + // RX caps: 1 - TCP, 2 - UDP, 4 - IP, 8 - TCPv6, 16 - UDPv6 + if (pConfiguration->OffloadRxCS.ulValue & 1) pContext->Offload.flagsValue |= osbT4RxTCPChecksum | osbT4RxTCPOptionsChecksum; + if (pConfiguration->OffloadRxCS.ulValue & 2) pContext->Offload.flagsValue |= osbT4RxUDPChecksum; + if (pConfiguration->OffloadRxCS.ulValue & 4) pContext->Offload.flagsValue |= osbT4RxIPChecksum | osbT4RxIPOptionsChecksum; + if (pConfiguration->OffloadRxCS.ulValue & 8) pContext->Offload.flagsValue |= osbT6RxTCPChecksum | osbT6RxTCPOptionsChecksum; + if (pConfiguration->OffloadRxCS.ulValue & 16) pContext->Offload.flagsValue |= osbT6RxUDPChecksum; + /* full packet size that can be configured as GSO for VIRTIO is short */ + /* NDIS test fails sometimes fails on segments 50-60K */ + pContext->Offload.maxPacketSize = PARANDIS_MAX_LSO_SIZE; + pContext->InitialOffloadParameters.IPv4Checksum = (UCHAR)pConfiguration->stdIpcsV4.ulValue; + pContext->InitialOffloadParameters.TCPIPv4Checksum = (UCHAR)pConfiguration->stdTcpcsV4.ulValue; + pContext->InitialOffloadParameters.TCPIPv6Checksum = (UCHAR)pConfiguration->stdTcpcsV6.ulValue; + pContext->InitialOffloadParameters.UDPIPv4Checksum = (UCHAR)pConfiguration->stdUdpcsV4.ulValue; + pContext->InitialOffloadParameters.UDPIPv6Checksum = (UCHAR)pConfiguration->stdUdpcsV6.ulValue; + pContext->InitialOffloadParameters.LsoV1 = (UCHAR)pConfiguration->stdLsoV1.ulValue; + pContext->InitialOffloadParameters.LsoV2IPv4 = (UCHAR)pConfiguration->stdLsoV2ip4.ulValue; + pContext->InitialOffloadParameters.LsoV2IPv6 = (UCHAR)pConfiguration->stdLsoV2ip6.ulValue; + pContext->ulPriorityVlanSetting = pConfiguration->PriorityVlanTagging.ulValue; + pContext->VlanId = pConfiguration->VlanId.ulValue & 0xfff; + pContext->bUseMergedBuffers = pConfiguration->UseMergeableBuffers.ulValue != 0; + pContext->MaxPacketSize.nMaxDataSize = pConfiguration->MTU.ulValue; + pContext->bUseIndirect = pConfiguration->Indirect.ulValue != 0; + if (!pContext->bDoSupportPriority) + pContext->ulPriorityVlanSetting = 0; + // if Vlan not supported + if (!IsVlanSupported(pContext)) + pContext->VlanId = 0; + if (1) + { + NDIS_STATUS status; + PVOID p; + UINT len = 0; + NdisReadNetworkAddress(&status, &p, &len, cfg); + if (status == NDIS_STATUS_SUCCESS && len == sizeof(pContext->CurrentMacAddress)) + { + *ppNewMACAddress = ParaNdis_AllocateMemory(pContext, sizeof(pContext->CurrentMacAddress)); + if (*ppNewMACAddress) + { + NdisMoveMemory(*ppNewMACAddress, p, len); + } + else + { + DPrintf(0, ("[%s] MAC address present, but some problem also...", __FUNCTION__)); + } + } + else if (len && len != sizeof(pContext->CurrentMacAddress)) + { + DPrintf(0, ("[%s] MAC address has wrong length of %d", __FUNCTION__, len)); + } + else + { + DPrintf(4, ("[%s] Nothing read for MAC, error %X", __FUNCTION__, status)); + } + } + NdisCloseConfiguration(cfg); + } + NdisFreeMemory(pConfiguration, 0, 0); + } +} + +void ParaNdis_ResetOffloadSettings(PARANDIS_ADAPTER *pContext, tOffloadSettingsFlags *pDest, PULONG from) +{ + if (!pDest) pDest = &pContext->Offload.flags; + if (!from) from = &pContext->Offload.flagsValue; + + pDest->fTxIPChecksum = !!(*from & osbT4IpChecksum); + pDest->fTxTCPChecksum = !!(*from & osbT4TcpChecksum); + pDest->fTxUDPChecksum = !!(*from & osbT4UdpChecksum); + pDest->fTxTCPOptions = !!(*from & osbT4TcpOptionsChecksum); + pDest->fTxIPOptions = !!(*from & osbT4IpOptionsChecksum); + + pDest->fTxLso = !!(*from & osbT4Lso); + pDest->fTxLsoIP = !!(*from & osbT4LsoIp); + pDest->fTxLsoTCP = !!(*from & osbT4LsoTcp); + + pDest->fRxIPChecksum = !!(*from & osbT4RxIPChecksum); + pDest->fRxIPOptions = !!(*from & osbT4RxIPOptionsChecksum); + pDest->fRxTCPChecksum = !!(*from & osbT4RxTCPChecksum); + pDest->fRxTCPOptions = !!(*from & osbT4RxTCPOptionsChecksum); + pDest->fRxUDPChecksum = !!(*from & osbT4RxUDPChecksum); + + pDest->fTxTCPv6Checksum = !!(*from & osbT6TcpChecksum); + pDest->fTxTCPv6Options = !!(*from & osbT6TcpOptionsChecksum); + pDest->fTxUDPv6Checksum = !!(*from & osbT6UdpChecksum); + pDest->fTxIPv6Ext = !!(*from & osbT6IpExtChecksum); + + pDest->fTxLsov6 = !!(*from & osbT6Lso); + pDest->fTxLsov6IP = !!(*from & osbT6LsoIpExt); + pDest->fTxLsov6TCP = !!(*from & osbT6LsoTcpOptions); + + pDest->fRxTCPv6Checksum = !!(*from & osbT6RxTCPChecksum); + pDest->fRxTCPv6Options = !!(*from & osbT6RxTCPOptionsChecksum); + pDest->fRxUDPv6Checksum = !!(*from & osbT6RxUDPChecksum); + pDest->fRxIPv6Ext = !!(*from & osbT6RxIpExtChecksum); +} + +/********************************************************** +Enumerates adapter resources and fills the structure holding them +Verifies that IO assigned and has correct size +Verifies that interrupt assigned +Parameters: + PNDIS_RESOURCE_LIST RList - list of resources, received from NDIS + tAdapterResources *pResources - structure to fill +Return value: + TRUE if everything is OK +***********************************************************/ +static BOOLEAN GetAdapterResources(NDIS_HANDLE MiniportHandle, PNDIS_RESOURCE_LIST RList, tAdapterResources *pResources) +{ + UINT i; + int read, bar = -1; + PCI_COMMON_HEADER pci_config; + NdisZeroMemory(pResources, sizeof(*pResources)); + + // read the PCI config space header + read = NdisReadPciSlotInformation( + MiniportHandle, + 0 /* SlotNumber, reserved */, + 0 /* Offset */, + &pci_config, + sizeof(pci_config)); + if (read != sizeof(pci_config)) { + return FALSE; + } + + for (i = 0; i < RList->Count; ++i) + { + ULONG type = RList->PartialDescriptors[i].Type; + if (type == CmResourceTypePort) + { + PHYSICAL_ADDRESS Start = RList->PartialDescriptors[i].u.Port.Start; + ULONG len = RList->PartialDescriptors[i].u.Port.Length; + DPrintf(0, ("Found IO ports at %08lX(%d)", Start.LowPart, len)); + bar = virtio_get_bar_index(&pci_config, Start); + if (bar < 0) { + break; + } + pResources->PciBars[bar].BasePA = Start; + pResources->PciBars[bar].uLength = len; + pResources->PciBars[bar].bPortSpace = TRUE; + } + else if (type == CmResourceTypeMemory) + { + PHYSICAL_ADDRESS Start = RList->PartialDescriptors[i].u.Memory.Start; + ULONG len = RList->PartialDescriptors[i].u.Memory.Length; + DPrintf(0, ("Found IO memory at %08I64X(%d)", Start.QuadPart, len)); + bar = virtio_get_bar_index(&pci_config, Start); + if (bar < 0) { + break; + } + pResources->PciBars[bar].BasePA = Start; + pResources->PciBars[bar].uLength = len; + pResources->PciBars[bar].bPortSpace = FALSE; + } + else if (type == CmResourceTypeInterrupt) + { + pResources->Vector = RList->PartialDescriptors[i].u.Interrupt.Vector; + pResources->Level = RList->PartialDescriptors[i].u.Interrupt.Level; + pResources->Affinity = RList->PartialDescriptors[i].u.Interrupt.Affinity; + pResources->InterruptFlags = RList->PartialDescriptors[i].Flags; + DPrintf(0, ("Found Interrupt vector %d, level %d, affinity %X, flags %X", + pResources->Vector, pResources->Level, (ULONG)pResources->Affinity, pResources->InterruptFlags)); + } + } + return bar >= 0 && pResources->Vector; +} + +static void DumpVirtIOFeatures(PARANDIS_ADAPTER *pContext) +{ + const struct { ULONG bitmask; const PCHAR Name; } Features[] = + { + + {VIRTIO_NET_F_CSUM, "VIRTIO_NET_F_CSUM" }, + {VIRTIO_NET_F_GUEST_CSUM, "VIRTIO_NET_F_GUEST_CSUM" }, + {VIRTIO_NET_F_MAC, "VIRTIO_NET_F_MAC" }, + {VIRTIO_NET_F_GSO, "VIRTIO_NET_F_GSO" }, + {VIRTIO_NET_F_GUEST_TSO4, "VIRTIO_NET_F_GUEST_TSO4"}, + {VIRTIO_NET_F_GUEST_TSO6, "VIRTIO_NET_F_GUEST_TSO6"}, + {VIRTIO_NET_F_GUEST_ECN, "VIRTIO_NET_F_GUEST_ECN"}, + {VIRTIO_NET_F_GUEST_UFO, "VIRTIO_NET_F_GUEST_UFO"}, + {VIRTIO_NET_F_HOST_TSO4, "VIRTIO_NET_F_HOST_TSO4"}, + {VIRTIO_NET_F_HOST_TSO6, "VIRTIO_NET_F_HOST_TSO6"}, + {VIRTIO_NET_F_HOST_ECN, "VIRTIO_NET_F_HOST_ECN"}, + {VIRTIO_NET_F_HOST_UFO, "VIRTIO_NET_F_HOST_UFO"}, + {VIRTIO_NET_F_MRG_RXBUF, "VIRTIO_NET_F_MRG_RXBUF"}, + {VIRTIO_NET_F_STATUS, "VIRTIO_NET_F_STATUS"}, + {VIRTIO_NET_F_CTRL_VQ, "VIRTIO_NET_F_CTRL_VQ"}, + {VIRTIO_NET_F_CTRL_RX, "VIRTIO_NET_F_CTRL_RX"}, + {VIRTIO_NET_F_CTRL_VLAN, "VIRTIO_NET_F_CTRL_VLAN"}, + {VIRTIO_NET_F_CTRL_RX_EXTRA, "VIRTIO_NET_F_CTRL_RX_EXTRA"}, + {VIRTIO_RING_F_INDIRECT_DESC, "VIRTIO_RING_F_INDIRECT_DESC"}, + {VIRTIO_F_VERSION_1, "VIRTIO_F_VERSION_1" }, + {VIRTIO_F_ANY_LAYOUT, "VIRTIO_F_ANY_LAYOUT" }, + }; + UINT i; + for (i = 0; i < sizeof(Features)/sizeof(Features[0]); ++i) + { + if (VirtIODeviceGetHostFeature(pContext, Features[i].bitmask)) + { + DPrintf(0, ("VirtIO Host Feature %s", Features[i].Name)); + } + } +} + +/********************************************************** + Only for test. Prints out if the interrupt line is ON +Parameters: +Return value: +***********************************************************/ +static void JustForCheckClearInterrupt(PARANDIS_ADAPTER *pContext, const char *Label) +{ + if (pContext->bEnableInterruptChecking) + { + ULONG ulActive; + ulActive = virtio_read_isr_status(&pContext->IODevice); + if (ulActive) + { + DPrintf(0,("WARNING: Interrupt Line %d(%s)!", ulActive, Label)); + } + } +} + +/********************************************************** +Prints out statistics +***********************************************************/ +static void PrintStatistics(PARANDIS_ADAPTER *pContext) +{ + ULONG64 totalTxFrames = + pContext->Statistics.ifHCOutBroadcastPkts + + pContext->Statistics.ifHCOutMulticastPkts + + pContext->Statistics.ifHCOutUcastPkts; + ULONG64 totalRxFrames = + pContext->Statistics.ifHCInBroadcastPkts + + pContext->Statistics.ifHCInMulticastPkts + + pContext->Statistics.ifHCInUcastPkts; + + DPrintf(0, ("[Diag!%X] RX buffers at VIRTIO %d of %d", + pContext->CurrentMacAddress[5], + pContext->NetNofReceiveBuffers, + pContext->NetMaxReceiveBuffers)); + DPrintf(0, ("[Diag!] TX desc available %d/%d, buf %d/min. %d", + pContext->nofFreeTxDescriptors, + pContext->maxFreeTxDescriptors, + pContext->nofFreeHardwareBuffers, + pContext->minFreeHardwareBuffers)); + pContext->minFreeHardwareBuffers = pContext->nofFreeHardwareBuffers; + if (pContext->NetTxPacketsToReturn) + { + DPrintf(0, ("[Diag!] TX packets to return %d", pContext->NetTxPacketsToReturn)); + } + DPrintf(0, ("[Diag!] Bytes transmitted %I64u, received %I64u", + pContext->Statistics.ifHCOutOctets, + pContext->Statistics.ifHCInOctets)); + DPrintf(0, ("[Diag!] Tx frames %I64u, CSO %d, LSO %d, indirect %d", + totalTxFrames, + pContext->extraStatistics.framesCSOffload, + pContext->extraStatistics.framesLSO, + pContext->extraStatistics.framesIndirect)); + DPrintf(0, ("[Diag!] Rx frames %I64u, Rx.Pri %d, RxHwCS.OK %d, FiltOut %d", + totalRxFrames, pContext->extraStatistics.framesRxPriority, + pContext->extraStatistics.framesRxCSHwOK, pContext->extraStatistics.framesFilteredOut)); + if (pContext->extraStatistics.framesRxCSHwMissedBad || pContext->extraStatistics.framesRxCSHwMissedGood) + { + DPrintf(0, ("[Diag!] RxHwCS mistakes: missed bad %d, missed good %d", + pContext->extraStatistics.framesRxCSHwMissedBad, pContext->extraStatistics.framesRxCSHwMissedGood)); + } +} + +static NDIS_STATUS NTStatusToNdisStatus(NTSTATUS nt_status) { + switch (nt_status) { + case STATUS_SUCCESS: + return NDIS_STATUS_SUCCESS; + case STATUS_NOT_FOUND: + case STATUS_DEVICE_NOT_CONNECTED: + return NDIS_STATUS_ADAPTER_NOT_FOUND; + case STATUS_INSUFFICIENT_RESOURCES: + return NDIS_STATUS_RESOURCES; + case STATUS_INVALID_PARAMETER: + return NDIS_STATUS_INVALID_DEVICE_REQUEST; + default: + return NDIS_STATUS_FAILURE; + } +} + +static NDIS_STATUS FinalizeFeatures(PARANDIS_ADAPTER *pContext) +{ + NTSTATUS nt_status = virtio_set_features(&pContext->IODevice, pContext->ullGuestFeatures); + if (!NT_SUCCESS(nt_status)) { + DPrintf(0, ("[%s] virtio_set_features failed with %x\n", __FUNCTION__, nt_status)); + } + return NTStatusToNdisStatus(nt_status); +} + +/********************************************************** +Initializes the context structure +Major variables, received from NDIS on initialization, must be be set before this call +(for ex. pContext->MiniportHandle) + +If this procedure fails, no need to call + ParaNdis_CleanupContext + + +Parameters: +Return value: + SUCCESS, if resources are OK + NDIS_STATUS_RESOURCE_CONFLICT if not +***********************************************************/ +NDIS_STATUS ParaNdis_InitializeContext( + PARANDIS_ADAPTER *pContext, + PNDIS_RESOURCE_LIST pResourceList) +{ + NDIS_STATUS status = NDIS_STATUS_SUCCESS; + PUCHAR pNewMacAddress = NULL; + USHORT linkStatus = 0; + NTSTATUS nt_status; + + DEBUG_ENTRY(0); + /* read first PCI IO bar*/ + //ulIOAddress = ReadPCIConfiguration(miniportAdapterHandle, 0x10); + /* check this is IO and assigned */ + ReadNicConfiguration(pContext, &pNewMacAddress); + if (pNewMacAddress) + { + if (ParaNdis_ValidateMacAddress(pNewMacAddress, TRUE)) + { + DPrintf(0, ("[%s] WARNING: MAC address reloaded", __FUNCTION__)); + NdisMoveMemory(pContext->CurrentMacAddress, pNewMacAddress, sizeof(pContext->CurrentMacAddress)); + } + else + { + DPrintf(0, ("[%s] WARNING: Invalid MAC address ignored", __FUNCTION__)); + } + NdisFreeMemory(pNewMacAddress, 0, 0); + } + + pContext->MaxPacketSize.nMaxFullSizeOS = pContext->MaxPacketSize.nMaxDataSize + ETH_HEADER_SIZE; + pContext->MaxPacketSize.nMaxFullSizeHwTx = pContext->MaxPacketSize.nMaxFullSizeOS; + pContext->MaxPacketSize.nMaxFullSizeHwRx = pContext->MaxPacketSize.nMaxFullSizeOS + ETH_PRIORITY_HEADER_SIZE; + if (pContext->ulPriorityVlanSetting) + pContext->MaxPacketSize.nMaxFullSizeHwTx = pContext->MaxPacketSize.nMaxFullSizeHwRx; + + if (GetAdapterResources(pContext->MiniportHandle, pResourceList, &pContext->AdapterResources)) + { + if (pContext->AdapterResources.InterruptFlags & CM_RESOURCE_INTERRUPT_MESSAGE) + { + DPrintf(0, ("[%s] Message interrupt assigned", __FUNCTION__)); + pContext->bUsingMSIX = TRUE; + } + + nt_status = virtio_device_initialize( + &pContext->IODevice, + &ParaNdisSystemOps, + pContext, + pContext->bUsingMSIX); + if (!NT_SUCCESS(nt_status)) { + DPrintf(0, ("[%s] virtio_device_initialize failed with %x\n", __FUNCTION__, nt_status)); + status = NTStatusToNdisStatus(nt_status); + DEBUG_EXIT_STATUS(0, status); + return status; + } + + pContext->bIODeviceInitialized = TRUE; + JustForCheckClearInterrupt(pContext, "init 0"); + ParaNdis_ResetVirtIONetDevice(pContext); + JustForCheckClearInterrupt(pContext, "init 1"); + virtio_add_status(&pContext->IODevice, VIRTIO_CONFIG_S_ACKNOWLEDGE); + JustForCheckClearInterrupt(pContext, "init 2"); + virtio_add_status(&pContext->IODevice, VIRTIO_CONFIG_S_DRIVER); + pContext->ullHostFeatures = virtio_get_features(&pContext->IODevice); + DumpVirtIOFeatures(pContext); + JustForCheckClearInterrupt(pContext, "init 3"); + pContext->bLinkDetectSupported = 0 != VirtIODeviceGetHostFeature(pContext, VIRTIO_NET_F_STATUS); + + if(pContext->bLinkDetectSupported) { + virtio_get_config(&pContext->IODevice, sizeof(pContext->CurrentMacAddress), &linkStatus, sizeof(linkStatus)); + pContext->bConnected = (linkStatus & VIRTIO_NET_S_LINK_UP) != 0; + DPrintf(0, ("[%s] Link status on driver startup: %d", __FUNCTION__, pContext->bConnected)); + } + + if (VirtIODeviceGetHostFeature(pContext, VIRTIO_F_VERSION_1)) + { + // virtio 1.0 always uses the extended header + pContext->nVirtioHeaderSize = sizeof(virtio_net_hdr_ext); + VirtIODeviceEnableGuestFeature(pContext, VIRTIO_F_VERSION_1); + } + else + { + pContext->nVirtioHeaderSize = sizeof(virtio_net_hdr_basic); + } + + if (VirtIODeviceGetHostFeature(pContext, VIRTIO_F_ANY_LAYOUT)) + { + VirtIODeviceEnableGuestFeature(pContext, VIRTIO_F_ANY_LAYOUT); + } + if (VirtIODeviceGetHostFeature(pContext, VIRTIO_RING_F_EVENT_IDX)) + { + VirtIODeviceEnableGuestFeature(pContext, VIRTIO_RING_F_EVENT_IDX); + } + + if (!pContext->bUseMergedBuffers && VirtIODeviceGetHostFeature(pContext, VIRTIO_NET_F_MRG_RXBUF)) + { + DPrintf(0, ("[%s] Not using mergeable buffers", __FUNCTION__)); + } + else + { + pContext->bUseMergedBuffers = VirtIODeviceGetHostFeature(pContext, VIRTIO_NET_F_MRG_RXBUF) != 0; + if (pContext->bUseMergedBuffers) + { + pContext->nVirtioHeaderSize = sizeof(virtio_net_hdr_ext); + VirtIODeviceEnableGuestFeature(pContext, VIRTIO_NET_F_MRG_RXBUF); + } + } + if (VirtIODeviceGetHostFeature(pContext, VIRTIO_NET_F_MAC)) + { + virtio_get_config( + &pContext->IODevice, + 0, // + offsetof(struct virtio_net_config, mac) + &pContext->PermanentMacAddress, + ETH_LENGTH_OF_ADDRESS); + if (!ParaNdis_ValidateMacAddress(pContext->PermanentMacAddress, FALSE)) + { + DPrintf(0,("Invalid device MAC ignored(%02x-%02x-%02x-%02x-%02x-%02x)", + pContext->PermanentMacAddress[0], + pContext->PermanentMacAddress[1], + pContext->PermanentMacAddress[2], + pContext->PermanentMacAddress[3], + pContext->PermanentMacAddress[4], + pContext->PermanentMacAddress[5])); + NdisZeroMemory(pContext->PermanentMacAddress, sizeof(pContext->PermanentMacAddress)); + } + } + + if (ETH_IS_EMPTY(pContext->PermanentMacAddress)) + { + DPrintf(0, ("No device MAC present, use default")); + pContext->PermanentMacAddress[0] = 0x02; + pContext->PermanentMacAddress[1] = 0x50; + pContext->PermanentMacAddress[2] = 0xF2; + pContext->PermanentMacAddress[3] = 0x00; + pContext->PermanentMacAddress[4] = 0x01; + pContext->PermanentMacAddress[5] = 0x80 | (UCHAR)(pContext->ulUniqueID & 0xFF); + } + DPrintf(0,("Device MAC = %02x-%02x-%02x-%02x-%02x-%02x", + pContext->PermanentMacAddress[0], + pContext->PermanentMacAddress[1], + pContext->PermanentMacAddress[2], + pContext->PermanentMacAddress[3], + pContext->PermanentMacAddress[4], + pContext->PermanentMacAddress[5])); + + if (ETH_IS_EMPTY(pContext->CurrentMacAddress)) + { + NdisMoveMemory( + &pContext->CurrentMacAddress, + &pContext->PermanentMacAddress, + ETH_LENGTH_OF_ADDRESS); + } + else + { + DPrintf(0,("Current MAC = %02x-%02x-%02x-%02x-%02x-%02x", + pContext->CurrentMacAddress[0], + pContext->CurrentMacAddress[1], + pContext->CurrentMacAddress[2], + pContext->CurrentMacAddress[3], + pContext->CurrentMacAddress[4], + pContext->CurrentMacAddress[5])); + } + if (VirtIODeviceGetHostFeature(pContext, VIRTIO_NET_F_CTRL_VQ)) { + pContext->bHasControlQueue = TRUE; + VirtIODeviceEnableGuestFeature(pContext, VIRTIO_NET_F_CTRL_VQ); + } + } + else + { + DPrintf(0, ("[%s] Error: Incomplete resources", __FUNCTION__)); + status = NDIS_STATUS_RESOURCE_CONFLICT; + } + + + if (pContext->bDoHardwareChecksum) + { + ULONG dependentOptions; + dependentOptions = osbT4TcpChecksum | osbT4UdpChecksum | osbT4TcpOptionsChecksum; + if (!VirtIODeviceGetHostFeature(pContext, VIRTIO_NET_F_CSUM) && + (pContext->Offload.flagsValue & dependentOptions)) + { + DPrintf(0, ("[%s] Host does not support CSUM, disabling CS offload", __FUNCTION__) ); + pContext->Offload.flagsValue &= ~dependentOptions; + } + } + + if (pContext->bDoGuestChecksumOnReceive && VirtIODeviceGetHostFeature(pContext, VIRTIO_NET_F_GUEST_CSUM)) + { + DPrintf(0, ("[%s] Enabling guest checksum", __FUNCTION__) ); + VirtIODeviceEnableGuestFeature(pContext, VIRTIO_NET_F_GUEST_CSUM); + } + else + { + pContext->bDoGuestChecksumOnReceive = FALSE; + } + + // now, after we checked the capabilities, we can initialize current + // configuration of offload tasks + ParaNdis_ResetOffloadSettings(pContext, NULL, NULL); + if (pContext->Offload.flags.fTxLso && !pContext->bUseScatterGather) + { + DisableBothLSOPermanently(pContext, __FUNCTION__, "SG is not active"); + } + if (pContext->Offload.flags.fTxLso && + !VirtIODeviceGetHostFeature(pContext, VIRTIO_NET_F_HOST_TSO4)) + { + DisableLSOv4Permanently(pContext, __FUNCTION__, "Host does not support TSOv4"); + } + if (pContext->Offload.flags.fTxLsov6 && + !VirtIODeviceGetHostFeature(pContext, VIRTIO_NET_F_HOST_TSO6)) + { + DisableLSOv6Permanently(pContext, __FUNCTION__, "Host does not support TSOv6"); + } + if (pContext->bUseIndirect) + { + const char *reason = ""; + if (!VirtIODeviceGetHostFeature(pContext, VIRTIO_RING_F_INDIRECT_DESC)) + { + pContext->bUseIndirect = FALSE; + reason = "Host support"; + } + else if (!pContext->bUseScatterGather) + { + pContext->bUseIndirect = FALSE; + reason = "SG"; + } + DPrintf(0, ("[%s] %sable indirect Tx(!%s)", __FUNCTION__, pContext->bUseIndirect ? "En" : "Dis", reason) ); + } + + if (VirtIODeviceGetHostFeature(pContext, VIRTIO_NET_F_CTRL_RX_EXTRA) && + pContext->bDoHwPacketFiltering) + { + DPrintf(0, ("[%s] Using hardware packet filtering", __FUNCTION__)); + pContext->bHasHardwareFilters = TRUE; + } + + status = FinalizeFeatures(pContext); + + pContext->ReuseBufferProc = (tReuseReceiveBufferProc)ReuseReceiveBufferRegular; + + NdisInitializeEvent(&pContext->ResetEvent); + DEBUG_EXIT_STATUS(0, status); + return status; +} + +/********************************************************** +Free the resources allocated for VirtIO buffer descriptor +Parameters: + PVOID pParam pIONetDescriptor to free + BOOLEAN bRemoveFromList TRUE, if also remove it from list +***********************************************************/ +static void VirtIONetFreeBufferDescriptor(PARANDIS_ADAPTER *pContext, pIONetDescriptor pBufferDescriptor) +{ + if(pBufferDescriptor) + { + if (pBufferDescriptor->pHolder) + ParaNdis_UnbindBufferFromPacket(pContext, pBufferDescriptor); + if (pBufferDescriptor->DataInfo.Virtual) + ParaNdis_FreePhysicalMemory(pContext, &pBufferDescriptor->DataInfo); + if (pBufferDescriptor->HeaderInfo.Virtual) + ParaNdis_FreePhysicalMemory(pContext, &pBufferDescriptor->HeaderInfo); + NdisFreeMemory(pBufferDescriptor, 0, 0); + } +} + +/********************************************************** +Free all the buffer descriptors from specified list +Parameters: + PLIST_ENTRY pListRoot list containing pIONetDescriptor structures + PNDIS_SPIN_LOCK pLock lock to protest this list +Return value: +***********************************************************/ +static void FreeDescriptorsFromList(PARANDIS_ADAPTER *pContext, PLIST_ENTRY pListRoot, PNDIS_SPIN_LOCK pLock) +{ + pIONetDescriptor pBufferDescriptor; + LIST_ENTRY TempList; + InitializeListHead(&TempList); + NdisAcquireSpinLock(pLock); + while(!IsListEmpty(pListRoot)) + { + pBufferDescriptor = (pIONetDescriptor)RemoveHeadList(pListRoot); + InsertTailList(&TempList, &pBufferDescriptor->listEntry); + } + NdisReleaseSpinLock(pLock); + while(!IsListEmpty(&TempList)) + { + pBufferDescriptor = (pIONetDescriptor)RemoveHeadList(&TempList); + VirtIONetFreeBufferDescriptor(pContext, pBufferDescriptor); + } +} + +static pIONetDescriptor AllocatePairOfBuffersOnInit( + PARANDIS_ADAPTER *pContext, + ULONG size1, + ULONG size2, + BOOLEAN bForTx) +{ + pIONetDescriptor p; + p = (pIONetDescriptor)ParaNdis_AllocateMemory(pContext, sizeof(*p)); + if (p) + { + BOOLEAN b1 = FALSE, b2 = FALSE; + NdisZeroMemory(p, sizeof(*p)); + p->HeaderInfo.size = size1; + p->DataInfo.size = size2; + p->HeaderInfo.IsCached = p->DataInfo.IsCached = 1; + p->HeaderInfo.IsTX = p->DataInfo.IsTX = bForTx; + p->nofUsedBuffers = 0; + b1 = ParaNdis_InitialAllocatePhysicalMemory(pContext, &p->HeaderInfo); + if (b1) b2 = ParaNdis_InitialAllocatePhysicalMemory(pContext, &p->DataInfo); + if (b1 && b2) + { + BOOLEAN b = bForTx || ParaNdis_BindBufferToPacket(pContext, p); + if (!b) + { + DPrintf(0, ("[INITPHYS](%s) Failed to bind memory to net packet", bForTx ? "TX" : "RX")); + VirtIONetFreeBufferDescriptor(pContext, p); + p = NULL; + } + } + else + { + if (b1) ParaNdis_FreePhysicalMemory(pContext, &p->HeaderInfo); + if (b2) ParaNdis_FreePhysicalMemory(pContext, &p->DataInfo); + NdisFreeMemory(p, 0, 0); + p = NULL; + DPrintf(0, ("[INITPHYS](%s) Failed to allocate memory block", bForTx ? "TX" : "RX")); + } + } + if (p) + { + DPrintf(3, ("[INITPHYS](%s) Header v%p(p%08lX), Data v%p(p%08lX)", bForTx ? "TX" : "RX", + p->HeaderInfo.Virtual, p->HeaderInfo.Physical.LowPart, + p->DataInfo.Virtual, p->DataInfo.Physical.LowPart)); + } + return p; +} + +/********************************************************** +Allocates TX buffers according to startup setting (pContext->maxFreeTxDescriptors as got from registry) +Buffers are chained in NetFreeSendBuffers +Parameters: + context +***********************************************************/ +static void PrepareTransmitBuffers(PARANDIS_ADAPTER *pContext) +{ + UINT nBuffers, nMaxBuffers; + DEBUG_ENTRY(4); + nMaxBuffers = virtio_get_queue_size(pContext->NetSendQueue) / 2; + if (nMaxBuffers > pContext->maxFreeTxDescriptors) nMaxBuffers = pContext->maxFreeTxDescriptors; + + for (nBuffers = 0; nBuffers < nMaxBuffers; ++nBuffers) + { + pIONetDescriptor pBuffersDescriptor = + AllocatePairOfBuffersOnInit( + pContext, + pContext->nVirtioHeaderSize, + pContext->MaxPacketSize.nMaxFullSizeHwTx, + TRUE); + if (!pBuffersDescriptor) break; + + NdisZeroMemory(pBuffersDescriptor->HeaderInfo.Virtual, pBuffersDescriptor->HeaderInfo.size); + InsertTailList(&pContext->NetFreeSendBuffers, &pBuffersDescriptor->listEntry); + pContext->nofFreeTxDescriptors++; + } + + pContext->maxFreeTxDescriptors = pContext->nofFreeTxDescriptors; + pContext->nofFreeHardwareBuffers = pContext->nofFreeTxDescriptors * 2; + pContext->maxFreeHardwareBuffers = pContext->minFreeHardwareBuffers = pContext->nofFreeHardwareBuffers; + DPrintf(0, ("[%s] available %d Tx descriptors, %d hw buffers", + __FUNCTION__, pContext->nofFreeTxDescriptors, pContext->nofFreeHardwareBuffers)); +} + +static BOOLEAN AddRxBufferToQueue(PARANDIS_ADAPTER *pContext, pIONetDescriptor pBufferDescriptor) +{ + UINT nBuffersToSubmit = 2; + struct VirtIOBufferDescriptor sg[2]; + if (!pContext->bUseMergedBuffers) + { + sg[0].physAddr = pBufferDescriptor->HeaderInfo.Physical; + sg[0].length = pBufferDescriptor->HeaderInfo.size; + sg[1].physAddr = pBufferDescriptor->DataInfo.Physical; + sg[1].length = pBufferDescriptor->DataInfo.size; + } + else + { + sg[0].physAddr = pBufferDescriptor->DataInfo.Physical; + sg[0].length = pBufferDescriptor->DataInfo.size; + nBuffersToSubmit = 1; + } + return 0 <= virtqueue_add_buf( + pContext->NetReceiveQueue, + sg, + 0, + nBuffersToSubmit, + pBufferDescriptor, + NULL, + 0); +} + + +/********************************************************** +Allocates maximum RX buffers for incoming packets +Buffers are chained in NetReceiveBuffers +Parameters: + context +***********************************************************/ +static int PrepareReceiveBuffers(PARANDIS_ADAPTER *pContext) +{ + int nRet = 0; + UINT i; + DEBUG_ENTRY(4); + + for (i = 0; i < pContext->NetMaxReceiveBuffers; ++i) + { + ULONG size1 = pContext->bUseMergedBuffers ? 4 : pContext->nVirtioHeaderSize; + ULONG size2 = pContext->MaxPacketSize.nMaxFullSizeHwRx + + (pContext->bUseMergedBuffers ? pContext->nVirtioHeaderSize : 0); + pIONetDescriptor pBuffersDescriptor = + AllocatePairOfBuffersOnInit(pContext, size1, size2, FALSE); + if (!pBuffersDescriptor) break; + + if (!AddRxBufferToQueue(pContext, pBuffersDescriptor)) + { + VirtIONetFreeBufferDescriptor(pContext, pBuffersDescriptor); + break; + } + + InsertTailList(&pContext->NetReceiveBuffers, &pBuffersDescriptor->listEntry); + + pContext->NetNofReceiveBuffers++; + } + + pContext->NetMaxReceiveBuffers = pContext->NetNofReceiveBuffers; + DPrintf(0, ("[%s] MaxReceiveBuffers %d\n", __FUNCTION__, pContext->NetMaxReceiveBuffers) ); + + virtqueue_kick(pContext->NetReceiveQueue); + + return nRet; +} + +static NDIS_STATUS FindNetQueues(PARANDIS_ADAPTER *pContext) +{ + struct virtqueue *queues[3]; + unsigned nvqs = pContext->bHasControlQueue ? 3 : 2; + NTSTATUS status; + + // We work with two or three virtqueues, 0 - receive, 1 - send, 2 - control + status = virtio_find_queues( + &pContext->IODevice, + nvqs, + queues); + if (!NT_SUCCESS(status)) { + DPrintf(0, ("[%s] virtio_find_queues failed with %x\n", __FUNCTION__, status)); + return NTStatusToNdisStatus(status); + } + + pContext->NetReceiveQueue = queues[0]; + pContext->NetSendQueue = queues[1]; + if (pContext->bHasControlQueue) { + pContext->NetControlQueue = queues[2]; + } + + return NDIS_STATUS_SUCCESS; +} + +// called on PASSIVE upon unsuccessful Init or upon Halt +static void DeleteNetQueues(PARANDIS_ADAPTER *pContext) +{ + virtio_delete_queues(&pContext->IODevice); +} + +/********************************************************** +Initializes VirtIO buffering and related stuff: +Allocates RX and TX queues and buffers +Parameters: + context +Return value: + TRUE if both queues are allocated +***********************************************************/ +static NDIS_STATUS ParaNdis_VirtIONetInit(PARANDIS_ADAPTER *pContext) +{ + NDIS_STATUS status; + DEBUG_ENTRY(0); + + pContext->ControlData.IsCached = 1; + pContext->ControlData.size = 512; + + status = FindNetQueues(pContext); + if (status != NDIS_STATUS_SUCCESS) { + return status; + } + + if (pContext->NetReceiveQueue && pContext->NetSendQueue) + { + PrepareTransmitBuffers(pContext); + PrepareReceiveBuffers(pContext); + + if (pContext->NetControlQueue) + ParaNdis_InitialAllocatePhysicalMemory(pContext, &pContext->ControlData); + if (!pContext->NetControlQueue || !pContext->ControlData.Virtual) + { + DPrintf(0, ("[%s] The Control vQueue does not work!\n", __FUNCTION__) ); + pContext->bHasHardwareFilters = FALSE; + } + if (pContext->nofFreeTxDescriptors && + pContext->NetMaxReceiveBuffers && + pContext->maxFreeHardwareBuffers) + { + pContext->sgTxGatherTable = ParaNdis_AllocateMemory(pContext, + pContext->maxFreeHardwareBuffers * sizeof(pContext->sgTxGatherTable[0])); + if (!pContext->sgTxGatherTable) + { + DisableBothLSOPermanently(pContext, __FUNCTION__, "Can not allocate SG table"); + } + status = NDIS_STATUS_SUCCESS; + } + } + else + { + DeleteNetQueues(pContext); + status = NDIS_STATUS_RESOURCES; + } + return status; +} + +static void VirtIODeviceRemoveStatus(VirtIODevice *vdev, u8 status) +{ + virtio_set_status( + vdev, + virtio_get_status(vdev) & ~status); +} + +/********************************************************** +Finishes initialization of context structure, calling also version dependent part +If this procedure failed, ParaNdis_CleanupContext must be called +Parameters: + context +Return value: + SUCCESS or some kind of failure +***********************************************************/ +NDIS_STATUS ParaNdis_FinishInitialization(PARANDIS_ADAPTER *pContext) +{ + NDIS_STATUS status = NDIS_STATUS_SUCCESS; + DEBUG_ENTRY(0); + + NdisAllocateSpinLock(&pContext->SendLock); +#if !defined(UNIFY_LOCKS) + NdisAllocateSpinLock(&pContext->ReceiveLock); +#endif + + InitializeListHead(&pContext->NetReceiveBuffers); + InitializeListHead(&pContext->NetReceiveBuffersWaiting); + InitializeListHead(&pContext->NetSendBuffersInUse); + InitializeListHead(&pContext->NetFreeSendBuffers); + + status = ParaNdis_FinishSpecificInitialization(pContext); + + if (status == NDIS_STATUS_SUCCESS) + { + status = ParaNdis_VirtIONetInit(pContext); + } + + pContext->Limits.nReusedRxBuffers = pContext->NetMaxReceiveBuffers / 4 + 1; + + if (status == NDIS_STATUS_SUCCESS) + { + JustForCheckClearInterrupt(pContext, "start 3"); + pContext->bEnableInterruptHandlingDPC = TRUE; + ParaNdis_SetPowerState(pContext, NdisDeviceStateD0); + virtio_device_ready(&pContext->IODevice); + JustForCheckClearInterrupt(pContext, "start 4"); + ParaNdis_UpdateDeviceFilters(pContext); + } + else + { + virtio_add_status(&pContext->IODevice, VIRTIO_CONFIG_S_FAILED); + } + DEBUG_EXIT_STATUS(0, status); + return status; +} + +/********************************************************** +Releases VirtIO related resources - queues and buffers +Parameters: + context +Return value: +***********************************************************/ +static void VirtIONetRelease(PARANDIS_ADAPTER *pContext) +{ + BOOLEAN b; + DEBUG_ENTRY(0); + + /* list NetReceiveBuffersWaiting must be free */ + do + { + NdisAcquireSpinLock(&pContext->ReceiveLock); + b = !IsListEmpty(&pContext->NetReceiveBuffersWaiting); + NdisReleaseSpinLock(&pContext->ReceiveLock); + if (b) + { + DPrintf(0, ("[%s] There are waiting buffers", __FUNCTION__)); + PrintStatistics(pContext); + NdisMSleep(5000000); + } + }while (b); + + DeleteNetQueues(pContext); + virtio_device_shutdown(&pContext->IODevice); + pContext->bIODeviceInitialized = FALSE; + + /* intentionally commented out + FreeDescriptorsFromList( + pContext, + &pContext->NetReceiveBuffersWaiting, + &pContext->ReceiveLock); + */ + + /* this can be freed, queue shut down */ + FreeDescriptorsFromList( + pContext, + &pContext->NetReceiveBuffers, + &pContext->ReceiveLock); + + /* this can be freed, queue shut down */ + FreeDescriptorsFromList( + pContext, + &pContext->NetSendBuffersInUse, + &pContext->SendLock); + + /* this can be freed, send disabled */ + FreeDescriptorsFromList( + pContext, + &pContext->NetFreeSendBuffers, + &pContext->SendLock); + + if (pContext->ControlData.Virtual) + ParaNdis_FreePhysicalMemory(pContext, &pContext->ControlData); + + PrintStatistics(pContext); + if (pContext->sgTxGatherTable) + { + NdisFreeMemory(pContext->sgTxGatherTable, 0, 0); + } +} + +static void PreventDPCServicing(PARANDIS_ADAPTER *pContext) +{ + LONG inside;; + pContext->bEnableInterruptHandlingDPC = FALSE; + do + { + inside = InterlockedIncrement(&pContext->counterDPCInside); + InterlockedDecrement(&pContext->counterDPCInside); + if (inside > 1) + { + DPrintf(0, ("[%s] waiting!", __FUNCTION__)); + NdisMSleep(20000); + } + } while (inside > 1); +} + +/********************************************************** +Frees all the resources allocated when the context initialized, + calling also version-dependent part +Parameters: + context +***********************************************************/ +VOID ParaNdis_CleanupContext(PARANDIS_ADAPTER *pContext) +{ + UINT i; + + /* disable any interrupt generation */ + if (pContext->IODevice.addr) + { + //int nActive; + //nActive = virtio_read_isr_status(&pContext->IODevice); + /* back compat - remove the OK flag only in legacy mode */ + VirtIODeviceRemoveStatus(&pContext->IODevice, VIRTIO_CONFIG_S_DRIVER_OK); + JustForCheckClearInterrupt(pContext, "exit 1"); + //nActive += virtio_read_isr_status(&pContext->IODevice); + //nActive += virtio_read_isr_status(&pContext->IODevice); + //DPrintf(0, ("cleanup %d", nActive)); + } + + PreventDPCServicing(pContext); + + /**************************************** + ensure all the incoming packets returned, + free all the buffers and their descriptors + *****************************************/ + + if (pContext->bIODeviceInitialized) + { + JustForCheckClearInterrupt(pContext, "exit 2"); + ParaNdis_ResetVirtIONetDevice(pContext); + JustForCheckClearInterrupt(pContext, "exit 3"); + } + + ParaNdis_SetPowerState(pContext, NdisDeviceStateD3); + VirtIONetRelease(pContext); + + ParaNdis_FinalizeCleanup(pContext); + + if (pContext->SendLock.SpinLock) + { + NdisFreeSpinLock(&pContext->SendLock); + } + +#if !defined(UNIFY_LOCKS) + if (pContext->ReceiveLock.SpinLock) + { + NdisFreeSpinLock(&pContext->ReceiveLock); + } +#endif + + /* free queue shared memory */ + for (i = 0; i < MAX_NUM_OF_QUEUES; i++) { + if (pContext->SharedMemoryRanges[i].pBase != NULL) { + NdisMFreeSharedMemory( + pContext->MiniportHandle, + pContext->SharedMemoryRanges[i].uLength, + TRUE /* Cached */, + pContext->SharedMemoryRanges[i].pBase, + pContext->SharedMemoryRanges[i].BasePA); + pContext->SharedMemoryRanges[i].pBase = NULL; + } + } + + /* unmap our port and memory IO resources */ + for (i = 0; i < PCI_TYPE0_ADDRESSES; i++) + { + tBusResource *pRes = &pContext->AdapterResources.PciBars[i]; + if (pRes->pBase != NULL) + { + if (pRes->bPortSpace) + { + NdisMDeregisterIoPortRange( + pContext->MiniportHandle, + pRes->BasePA.LowPart, + pRes->uLength, + pRes->pBase); + } + else + { + NdisMUnmapIoSpace( + pContext->MiniportHandle, + pRes->pBase, + pRes->uLength); + } + } + } +} + + +/********************************************************** +System shutdown handler (shutdown, restart, bugcheck) +Parameters: + context +***********************************************************/ +VOID ParaNdis_OnShutdown(PARANDIS_ADAPTER *pContext) +{ + DEBUG_ENTRY(0); // this is only for kdbg :) + ParaNdis_ResetVirtIONetDevice(pContext); +} + +/********************************************************** +Handles hardware interrupt +Parameters: + context + ULONG knownInterruptSources - bitmask of +Return value: + TRUE, if it is our interrupt + sets *pRunDpc to TRUE if the DPC should be fired +***********************************************************/ +BOOLEAN ParaNdis_OnLegacyInterrupt( + PARANDIS_ADAPTER *pContext, + OUT BOOLEAN *pRunDpc) +{ + ULONG status = virtio_read_isr_status(&pContext->IODevice); + + if((status == 0) || + (status == VIRTIO_NET_INVALID_INTERRUPT_STATUS) || + (pContext->powerState != NdisDeviceStateD0)) + { + *pRunDpc = FALSE; + return FALSE; + } + + PARANDIS_STORE_LAST_INTERRUPT_TIMESTAMP(pContext); + ParaNdis_VirtIODisableIrqSynchronized(pContext, isAny); + InterlockedOr(&pContext->InterruptStatus, (LONG) ((status & isControl) | isReceive | isTransmit)); + *pRunDpc = TRUE; + return TRUE; +} + +BOOLEAN ParaNdis_OnQueuedInterrupt( + PARANDIS_ADAPTER *pContext, + OUT BOOLEAN *pRunDpc, + ULONG knownInterruptSources) +{ + struct virtqueue* _vq = ParaNdis_GetQueueForInterrupt(pContext, knownInterruptSources); + + /* If interrupts for this queue disabled do nothing */ + if((_vq != NULL) && !ParaNDIS_IsQueueInterruptEnabled(_vq)) + { + *pRunDpc = FALSE; + } + else + { + PARANDIS_STORE_LAST_INTERRUPT_TIMESTAMP(pContext); + InterlockedOr(&pContext->InterruptStatus, (LONG)knownInterruptSources); + ParaNdis_VirtIODisableIrqSynchronized(pContext, knownInterruptSources); + *pRunDpc = TRUE; + } + + return *pRunDpc; +} + + +/********************************************************** +It is called from Rx processing routines in regular mode of operation. +Returns received buffer back to VirtIO queue, inserting it to NetReceiveBuffers. +If needed, signals end of RX pause operation + +Must be called with &pContext->ReceiveLock acquired + +Parameters: + context + void *pDescriptor - pIONetDescriptor to return +***********************************************************/ +void ReuseReceiveBufferRegular(PARANDIS_ADAPTER *pContext, pIONetDescriptor pBuffersDescriptor) +{ + DEBUG_ENTRY(4); + + if(!pBuffersDescriptor) + return; + + RemoveEntryList(&pBuffersDescriptor->listEntry); + + if(AddRxBufferToQueue(pContext, pBuffersDescriptor)) + { + InsertTailList(&pContext->NetReceiveBuffers, &pBuffersDescriptor->listEntry); + + pContext->NetNofReceiveBuffers++; + + if (pContext->NetNofReceiveBuffers > pContext->NetMaxReceiveBuffers) + { + DPrintf(0, (" Error: NetNofReceiveBuffers > NetMaxReceiveBuffers(%d>%d)", + pContext->NetNofReceiveBuffers, pContext->NetMaxReceiveBuffers)); + } + + if (++pContext->Counters.nReusedRxBuffers >= pContext->Limits.nReusedRxBuffers) + { + pContext->Counters.nReusedRxBuffers = 0; + virtqueue_kick_always(pContext->NetReceiveQueue); + } + + if (IsListEmpty(&pContext->NetReceiveBuffersWaiting)) + { + if (pContext->ReceiveState == srsPausing || pContext->ReceivePauseCompletionProc) + { + ONPAUSECOMPLETEPROC callback = pContext->ReceivePauseCompletionProc; + pContext->ReceiveState = srsDisabled; + pContext->ReceivePauseCompletionProc = NULL; + ParaNdis_DebugHistory(pContext, hopInternalReceivePause, NULL, 0, 0, 0); + if (callback) callback(pContext); + } + } + } + else + { + DPrintf(0, ("FAILED TO REUSE THE BUFFER!!!!")); + VirtIONetFreeBufferDescriptor(pContext, pBuffersDescriptor); + pContext->NetMaxReceiveBuffers--; + } +} + +/********************************************************** +It is called from Rx processing routines between power off and power on in non-paused mode (Win8). +Returns received buffer to NetReceiveBuffers. +All the buffers will be placed into Virtio queue during power-on procedure + +Must be called with &pContext->ReceiveLock acquired + +Parameters: + context + void *pDescriptor - pIONetDescriptor to return +***********************************************************/ +static void ReuseReceiveBufferPowerOff(PARANDIS_ADAPTER *pContext, pIONetDescriptor pBuffersDescriptor) +{ + RemoveEntryList(&pBuffersDescriptor->listEntry); + InsertTailList(&pContext->NetReceiveBuffers, &pBuffersDescriptor->listEntry); +} + +/********************************************************** +It is called from Tx processing routines +Gets all the finished buffer from VirtIO TX path and +returns them to NetFreeSendBuffers + +Must be called with &pContext->SendLock acquired + +Parameters: + context +Return value: + (for reference) number of TX buffers returned +***********************************************************/ +UINT ParaNdis_VirtIONetReleaseTransmitBuffers( + PARANDIS_ADAPTER *pContext) +{ + UINT len, i = 0; + pIONetDescriptor pBufferDescriptor; + + DEBUG_ENTRY(4); + + while(NULL != (pBufferDescriptor = virtqueue_get_buf(pContext->NetSendQueue, &len))) + { + RemoveEntryList(&pBufferDescriptor->listEntry); + pContext->nofFreeTxDescriptors++; + if (!pBufferDescriptor->nofUsedBuffers) + { + DPrintf(0, ("[%s] ERROR: nofUsedBuffers not set!", __FUNCTION__)); + } + pContext->nofFreeHardwareBuffers += pBufferDescriptor->nofUsedBuffers; + ParaNdis_OnTransmitBufferReleased(pContext, pBufferDescriptor); + InsertTailList(&pContext->NetFreeSendBuffers, &pBufferDescriptor->listEntry); + DPrintf(3, ("[%s] Free Tx: desc %d, buff %d", __FUNCTION__, pContext->nofFreeTxDescriptors, pContext->nofFreeHardwareBuffers)); + pBufferDescriptor->nofUsedBuffers = 0; + ++i; + } + if (i) + { + NdisGetCurrentSystemTime(&pContext->LastTxCompletionTimeStamp); + pContext->bDoKickOnNoBuffer = TRUE; + pContext->nDetectedStoppedTx = 0; + } + DEBUG_EXIT_STATUS((i ? 3 : 5), i); + return i; +} + +static ULONG FORCEINLINE QueryTcpHeaderOffset(PVOID packetData, ULONG ipHeaderOffset, ULONG ipPacketLength) +{ + ULONG res; + tTcpIpPacketParsingResult ppr = ParaNdis_ReviewIPPacket( + (PUCHAR)packetData + ipHeaderOffset, + ipPacketLength, + __FUNCTION__); + if (ppr.xxpStatus == ppresXxpKnown) + { + res = ipHeaderOffset + ppr.ipHeaderSize; + } + else + { + DPrintf(0, ("[%s] ERROR: NOT a TCP or UDP packet - expected troubles!", __FUNCTION__)); + res = 0; + } + return res; +} + + +/********************************************************* +Called with from ProcessTx routine with TxLock held +Uses pContext->sgTxGatherTable +***********************************************************/ +tCopyPacketResult ParaNdis_DoSubmitPacket(PARANDIS_ADAPTER *pContext, tTxOperationParameters *Params) +{ + tCopyPacketResult result; + tMapperResult mapResult = {0,0,0}; + // populating priority tag or LSO MAY require additional SG element + UINT nRequiredBuffers; + BOOLEAN bUseCopy = FALSE; + struct VirtIOBufferDescriptor *sg = pContext->sgTxGatherTable; + + nRequiredBuffers = Params->nofSGFragments + 1 + ((Params->flags & (pcrPriorityTag | pcrLSO)) ? 1 : 0); + + result.size = 0; + result.error = cpeOK; + if (!pContext->bUseScatterGather || // only copy available + Params->nofSGFragments == 0 || // theoretical case + !sg || // only copy available + ((~Params->flags & pcrLSO) && nRequiredBuffers > pContext->maxFreeHardwareBuffers) // to many fragments and normal size of packet + ) + { + nRequiredBuffers = 2; + bUseCopy = TRUE; + } + else if (pContext->bUseIndirect && !(Params->flags & pcrNoIndirect)) + { + nRequiredBuffers = 1; + } + + // I do not think this will help, but at least we can try freeing some buffers right now + if (pContext->nofFreeHardwareBuffers < nRequiredBuffers || !pContext->nofFreeTxDescriptors) + { + ParaNdis_VirtIONetReleaseTransmitBuffers(pContext); + } + + if (nRequiredBuffers > pContext->maxFreeHardwareBuffers) + { + // LSO and too many buffers, impossible to send + result.error = cpeTooLarge; + DPrintf(0, ("[%s] ERROR: too many fragments(%d required, %d max.avail)!", __FUNCTION__, + nRequiredBuffers, pContext->maxFreeHardwareBuffers)); + } + else if (pContext->nofFreeHardwareBuffers < nRequiredBuffers || !pContext->nofFreeTxDescriptors) + { + virtqueue_enable_cb_delayed(pContext->NetSendQueue); + result.error = cpeNoBuffer; + } + else if (Params->offloadMss && bUseCopy) + { + result.error = cpeInternalError; + DPrintf(0, ("[%s] ERROR: expecting SG for TSO! (%d buffers, %d bytes)", __FUNCTION__, + Params->nofSGFragments, Params->ulDataSize)); + } + else if (bUseCopy) + { + result = ParaNdis_DoCopyPacketData(pContext, Params); + } + else + { + UINT nMappedBuffers; + ULONGLONG paOfIndirectArea = 0; + PVOID vaOfIndirectArea = NULL; + pIONetDescriptor pBuffersDescriptor = (pIONetDescriptor)RemoveHeadList(&pContext->NetFreeSendBuffers); + pContext->nofFreeTxDescriptors--; + NdisZeroMemory(pBuffersDescriptor->HeaderInfo.Virtual, pBuffersDescriptor->HeaderInfo.size); + sg[0].physAddr = pBuffersDescriptor->HeaderInfo.Physical; + sg[0].length = pBuffersDescriptor->HeaderInfo.size; + ParaNdis_PacketMapper( + pContext, + Params->packet, + Params->ReferenceValue, + sg + 1, + pBuffersDescriptor, + &mapResult); + nMappedBuffers = mapResult.usBuffersMapped; + if (nMappedBuffers) + { + nMappedBuffers++; + if (pContext->bUseIndirect && !(Params->flags & pcrNoIndirect)) + { + ULONG space1 = (mapResult.usBufferSpaceUsed + 7) & ~7; + ULONG space2 = nMappedBuffers * SIZE_OF_SINGLE_INDIRECT_DESC; + if (pBuffersDescriptor->DataInfo.size >= (space1 + space2)) + { + vaOfIndirectArea = RtlOffsetToPointer(pBuffersDescriptor->DataInfo.Virtual, space1); + paOfIndirectArea = pBuffersDescriptor->DataInfo.Physical.QuadPart + space1; + pContext->extraStatistics.framesIndirect++; + } + else if (nMappedBuffers <= pContext->nofFreeHardwareBuffers) + { + // send as is, no indirect + } + else + { + result.error = cpeNoIndirect; + DPrintf(0, ("[%s] Unexpected ERROR of placement!", __FUNCTION__)); + } + } + if (result.error == cpeOK) + { + if (Params->flags & (pcrTcpChecksum | pcrUdpChecksum)) + { + unsigned short addPriorityLen = (Params->flags & pcrPriorityTag) ? ETH_PRIORITY_HEADER_SIZE : 0; + if (pContext->bDoHardwareChecksum) + { + virtio_net_hdr_basic *pheader = pBuffersDescriptor->HeaderInfo.Virtual; + pheader->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM; + if (!Params->tcpHeaderOffset) + { + Params->tcpHeaderOffset = QueryTcpHeaderOffset( + pBuffersDescriptor->DataInfo.Virtual, + pContext->Offload.ipHeaderOffset + addPriorityLen, + mapResult.usBufferSpaceUsed - pContext->Offload.ipHeaderOffset - addPriorityLen); + } + else + { + Params->tcpHeaderOffset += addPriorityLen; + } + pheader->csum_start = (USHORT)Params->tcpHeaderOffset; + pheader->csum_offset = (Params->flags & pcrTcpChecksum) ? TCP_CHECKSUM_OFFSET : UDP_CHECKSUM_OFFSET; + } + else + { + // emulation mode - it is slow and intended only for test of flows + // and debugging of WLK test cases + PVOID pCopy = ParaNdis_AllocateMemory(pContext, Params->ulDataSize); + if (pCopy) + { + tTcpIpPacketParsingResult ppr; + // duplicate entire packet + ParaNdis_PacketCopier(Params->packet, pCopy, Params->ulDataSize, Params->ReferenceValue, FALSE); + // calculate complete TCP/UDP checksum + ppr = ParaNdis_CheckSumVerify( + RtlOffsetToPointer(pCopy, pContext->Offload.ipHeaderOffset + addPriorityLen), + Params->ulDataSize - pContext->Offload.ipHeaderOffset - addPriorityLen, + pcrAnyChecksum | pcrFixXxpChecksum, + __FUNCTION__); + // data portion in aside buffer contains complete IP+TCP header + // rewrite copy of original buffer by one new with calculated data + NdisMoveMemory( + pBuffersDescriptor->DataInfo.Virtual, + pCopy, + mapResult.usBufferSpaceUsed); + NdisFreeMemory(pCopy, 0, 0); + } + } + } + + if (0 <= virtqueue_add_buf( + pContext->NetSendQueue, + sg, + nMappedBuffers, + 0, + pBuffersDescriptor, + vaOfIndirectArea, + paOfIndirectArea)) + { + pBuffersDescriptor->nofUsedBuffers = nMappedBuffers; + pContext->nofFreeHardwareBuffers -= nMappedBuffers; + if (pContext->minFreeHardwareBuffers > pContext->nofFreeHardwareBuffers) + pContext->minFreeHardwareBuffers = pContext->nofFreeHardwareBuffers; + pBuffersDescriptor->ReferenceValue = Params->ReferenceValue; + result.size = Params->ulDataSize; + DPrintf(2, ("[%s] Submitted %d buffers (%d bytes), avail %d desc, %d bufs", + __FUNCTION__, nMappedBuffers, result.size, + pContext->nofFreeTxDescriptors, pContext->nofFreeHardwareBuffers + )); + } + else + { + result.error = cpeInternalError; + DPrintf(0, ("[%s] Unexpected ERROR adding buffer to TX engine!..", __FUNCTION__)); + } + } + } + else + { + DPrintf(0, ("[%s] Unexpected ERROR: packet not mapped!", __FUNCTION__)); + result.error = cpeInternalError; + } + + if (result.error == cpeOK) + { + UCHAR ethernetHeader[sizeof(ETH_HEADER)]; + eInspectedPacketType packetType; + /* get the ethernet header for review */ + ParaNdis_PacketCopier(Params->packet, ethernetHeader, sizeof(ethernetHeader), Params->ReferenceValue, TRUE); + packetType = QueryPacketType(ethernetHeader); + DebugDumpPacket("sending", ethernetHeader, 3); + InsertTailList(&pContext->NetSendBuffersInUse, &pBuffersDescriptor->listEntry); + pContext->Statistics.ifHCOutOctets += result.size; + switch (packetType) + { + case iptBroadcast: + pContext->Statistics.ifHCOutBroadcastOctets += result.size; + pContext->Statistics.ifHCOutBroadcastPkts++; + break; + case iptMulticast: + pContext->Statistics.ifHCOutMulticastOctets += result.size; + pContext->Statistics.ifHCOutMulticastPkts++; + break; + default: + pContext->Statistics.ifHCOutUcastOctets += result.size; + pContext->Statistics.ifHCOutUcastPkts++; + break; + } + + if (Params->flags & pcrLSO) + pContext->extraStatistics.framesLSO++; + } + else + { + pContext->nofFreeTxDescriptors++; + InsertHeadList(&pContext->NetFreeSendBuffers, &pBuffersDescriptor->listEntry); + } + } + if (result.error == cpeNoBuffer && pContext->bDoKickOnNoBuffer) + { + virtqueue_kick_always(pContext->NetSendQueue); + pContext->bDoKickOnNoBuffer = FALSE; + } + if (result.error == cpeOK) + { + if (Params->flags & (pcrTcpChecksum | pcrUdpChecksum)) + pContext->extraStatistics.framesCSOffload++; + } + return result; +} + + +/********************************************************** +It is called from Tx processing routines +Prepares the VirtIO buffer and copies to it the data from provided packet + +Must be called with &pContext->SendLock acquired + +Parameters: + context + tPacketType packet specific type is NDIS dependent + tCopyPacketDataFunction PacketCopier procedure for NDIS-specific type of packet +Return value: + (for reference) number of TX buffers returned +***********************************************************/ +tCopyPacketResult ParaNdis_DoCopyPacketData( + PARANDIS_ADAPTER *pContext, + tTxOperationParameters *pParams) +{ + tCopyPacketResult result; + tCopyPacketResult CopierResult; + struct VirtIOBufferDescriptor sg[2]; + pIONetDescriptor pBuffersDescriptor = NULL; + ULONG flags = pParams->flags; + UINT nRequiredHardwareBuffers = 2; + result.size = 0; + result.error = cpeOK; + if (pContext->nofFreeHardwareBuffers < nRequiredHardwareBuffers || + IsListEmpty(&pContext->NetFreeSendBuffers)) + { + result.error = cpeNoBuffer; + } + if(result.error == cpeOK) + { + pBuffersDescriptor = (pIONetDescriptor)RemoveHeadList(&pContext->NetFreeSendBuffers); + NdisZeroMemory(pBuffersDescriptor->HeaderInfo.Virtual, pBuffersDescriptor->HeaderInfo.size); + sg[0].physAddr = pBuffersDescriptor->HeaderInfo.Physical; + sg[0].length = pBuffersDescriptor->HeaderInfo.size; + sg[1].physAddr = pBuffersDescriptor->DataInfo.Physical; + CopierResult = ParaNdis_PacketCopier( + pParams->packet, + pBuffersDescriptor->DataInfo.Virtual, + pBuffersDescriptor->DataInfo.size, + pParams->ReferenceValue, + FALSE); + sg[1].length = result.size = CopierResult.size; + // did NDIS ask us to compute CS? + if ((flags & (pcrTcpChecksum | pcrUdpChecksum | pcrIpChecksum)) != 0) + { + // we asked + unsigned short addPriorityLen = (pParams->flags & pcrPriorityTag) ? ETH_PRIORITY_HEADER_SIZE : 0; + PVOID ipPacket = RtlOffsetToPointer( + pBuffersDescriptor->DataInfo.Virtual, pContext->Offload.ipHeaderOffset + addPriorityLen); + ULONG ipPacketLength = CopierResult.size - pContext->Offload.ipHeaderOffset - addPriorityLen; + if (!pParams->tcpHeaderOffset && + (flags & (pcrTcpChecksum | pcrUdpChecksum)) ) + { + pParams->tcpHeaderOffset = QueryTcpHeaderOffset( + pBuffersDescriptor->DataInfo.Virtual, + pContext->Offload.ipHeaderOffset + addPriorityLen, + ipPacketLength); + } + else + { + pParams->tcpHeaderOffset += addPriorityLen; + } + + if (pContext->bDoHardwareChecksum) + { + if (flags & (pcrTcpChecksum | pcrUdpChecksum)) + { + // hardware offload + virtio_net_hdr_basic *pvnh = (virtio_net_hdr_basic *)pBuffersDescriptor->HeaderInfo.Virtual; + pvnh->csum_start = (USHORT)pParams->tcpHeaderOffset; + pvnh->csum_offset = (flags & pcrTcpChecksum) ? TCP_CHECKSUM_OFFSET : UDP_CHECKSUM_OFFSET; + pvnh->flags |= VIRTIO_NET_HDR_F_NEEDS_CSUM; + } + if (flags & (pcrIpChecksum)) + { + ParaNdis_CheckSumVerify( + ipPacket, + ipPacketLength, + pcrIpChecksum | pcrFixIPChecksum, + __FUNCTION__); + } + } + else if (CopierResult.size > pContext->Offload.ipHeaderOffset) + { + ULONG csFlags = 0; + if (flags & pcrIpChecksum) csFlags |= pcrIpChecksum | pcrFixIPChecksum; + if (flags & (pcrTcpChecksum | pcrUdpChecksum)) csFlags |= pcrTcpChecksum | pcrUdpChecksum| pcrFixXxpChecksum; + // software offload + ParaNdis_CheckSumVerify( + ipPacket, + ipPacketLength, + csFlags, + __FUNCTION__); + } + else + { + DPrintf(0, ("[%s] ERROR: Invalid buffer size for offload!", __FUNCTION__)); + result.size = 0; + result.error = cpeInternalError; + } + } + pContext->nofFreeTxDescriptors--; + if (result.size) + { + eInspectedPacketType packetType; + packetType = QueryPacketType(pBuffersDescriptor->DataInfo.Virtual); + DebugDumpPacket("sending", pBuffersDescriptor->DataInfo.Virtual, 3); + + pBuffersDescriptor->nofUsedBuffers = nRequiredHardwareBuffers; + pContext->nofFreeHardwareBuffers -= nRequiredHardwareBuffers; + if (pContext->minFreeHardwareBuffers > pContext->nofFreeHardwareBuffers) + pContext->minFreeHardwareBuffers = pContext->nofFreeHardwareBuffers; + if (0 > virtqueue_add_buf( + pContext->NetSendQueue, + sg, + 2, + 0, + pBuffersDescriptor, + NULL, + 0 + )) + { + pBuffersDescriptor->nofUsedBuffers = 0; + pContext->nofFreeHardwareBuffers += nRequiredHardwareBuffers; + result.error = cpeInternalError; + result.size = 0; + DPrintf(0, ("[%s] Unexpected ERROR adding buffer to TX engine!..", __FUNCTION__)); + } + else + { + DPrintf(2, ("[%s] Submitted %d buffers (%d bytes), avail %d desc, %d bufs", + __FUNCTION__, nRequiredHardwareBuffers, result.size, + pContext->nofFreeTxDescriptors, pContext->nofFreeHardwareBuffers + )); + } + if (result.error != cpeOK) + { + InsertTailList(&pContext->NetFreeSendBuffers, &pBuffersDescriptor->listEntry); + pContext->nofFreeTxDescriptors++; + } + else + { + ULONG reportedSize = pParams->ulDataSize; + pBuffersDescriptor->ReferenceValue = pParams->ReferenceValue; + InsertTailList(&pContext->NetSendBuffersInUse, &pBuffersDescriptor->listEntry); + pContext->Statistics.ifHCOutOctets += reportedSize; + switch (packetType) + { + case iptBroadcast: + pContext->Statistics.ifHCOutBroadcastOctets += reportedSize; + pContext->Statistics.ifHCOutBroadcastPkts++; + break; + case iptMulticast: + pContext->Statistics.ifHCOutMulticastOctets += reportedSize; + pContext->Statistics.ifHCOutMulticastPkts++; + break; + default: + pContext->Statistics.ifHCOutUcastOctets += reportedSize; + pContext->Statistics.ifHCOutUcastPkts++; + break; + } + } + } + else + { + DPrintf(0, ("[%s] Unexpected ERROR in copying packet data! Continue...", __FUNCTION__)); + InsertTailList(&pContext->NetFreeSendBuffers, &pBuffersDescriptor->listEntry); + pContext->nofFreeTxDescriptors++; + // the buffer is not copied and the callback will not be called + result.error = cpeInternalError; + } + } + + return result; +} + +static ULONG ShallPassPacket(PARANDIS_ADAPTER *pContext, PVOID address, UINT len, eInspectedPacketType *pType) +{ + ULONG b; + if (len <= sizeof(ETH_HEADER)) return FALSE; + if (len > pContext->MaxPacketSize.nMaxFullSizeHwRx) return FALSE; + if (len > pContext->MaxPacketSize.nMaxFullSizeOS && !ETH_HAS_PRIO_HEADER(address)) return FALSE; + *pType = QueryPacketType(address); + if (pContext->PacketFilter & NDIS_PACKET_TYPE_PROMISCUOUS) return TRUE; + + switch(*pType) + { + case iptBroadcast: + b = pContext->PacketFilter & NDIS_PACKET_TYPE_BROADCAST; + break; + case iptMulticast: + b = pContext->PacketFilter & NDIS_PACKET_TYPE_ALL_MULTICAST; + if (!b && (pContext->PacketFilter & NDIS_PACKET_TYPE_MULTICAST)) + { + UINT i, n = pContext->MulticastData.nofMulticastEntries * ETH_LENGTH_OF_ADDRESS; + b = 1; + for (i = 0; b && i < n; i += ETH_LENGTH_OF_ADDRESS) + { + ETH_COMPARE_NETWORK_ADDRESSES((PUCHAR)address, &pContext->MulticastData.MulticastList[i], &b) + } + b = !b; + } + break; + default: + ETH_COMPARE_NETWORK_ADDRESSES((PUCHAR)address, pContext->CurrentMacAddress, &b); + b = !b && (pContext->PacketFilter & NDIS_PACKET_TYPE_DIRECTED); + break; + } + if (!b) + { + pContext->extraStatistics.framesFilteredOut++; + } + return b; +} + +void +ParaNdis_PadPacketReceived(PVOID pDataBuffer, PULONG pLength) +{ + // Ethernet standard declares minimal possible packet size + // Packets smaller than that must be padded before transfer + // Ethernet HW pads packets on transmit, however in our case + // some packets do not travel over Ethernet but being routed + // guest-to-guest by virtual switch. + // In this case padding is not performed and we may + // receive packet smaller than minimal allowed size. This is not + // a problem for real life scenarios however WHQL/HCK contains + // tests that check padding of received packets. + // To make these tests happy we have to pad small packets on receive + + //NOTE: This function assumes that VLAN header has been already stripped out + + if(*pLength < ETH_MIN_PACKET_SIZE) + { + RtlZeroMemory(RtlOffsetToPointer(pDataBuffer, *pLength), ETH_MIN_PACKET_SIZE - *pLength); + *pLength = ETH_MIN_PACKET_SIZE; + } +} + +/********************************************************** +Manages RX path, calling NDIS-specific procedure for packet indication +Parameters: + context +***********************************************************/ +static UINT ParaNdis_ProcessRxPath(PARANDIS_ADAPTER *pContext, ULONG ulMaxPacketsToIndicate) +{ + pIONetDescriptor pBuffersDescriptor; + UINT len, headerSize = pContext->nVirtioHeaderSize; + eInspectedPacketType packetType = iptInvalid; + UINT nReceived = 0, nRetrieved = 0, nReported = 0; + tPacketIndicationType *pBatchOfPackets; + UINT maxPacketsInBatch = pContext->NetMaxReceiveBuffers; + pBatchOfPackets = pContext->bBatchReceive ? + ParaNdis_AllocateMemory(pContext, maxPacketsInBatch * sizeof(tPacketIndicationType)) : NULL; + NdisAcquireSpinLock(&pContext->ReceiveLock); + while ((nReported < ulMaxPacketsToIndicate) && NULL != (pBuffersDescriptor = virtqueue_get_buf(pContext->NetReceiveQueue, &len))) + { + PVOID pDataBuffer = RtlOffsetToPointer(pBuffersDescriptor->DataInfo.Virtual, pContext->bUseMergedBuffers ? pContext->nVirtioHeaderSize : 0); + RemoveEntryList(&pBuffersDescriptor->listEntry); + InsertTailList(&pContext->NetReceiveBuffersWaiting, &pBuffersDescriptor->listEntry); + pContext->NetNofReceiveBuffers--; + nRetrieved++; + DPrintf(2, ("[%s] retrieved header+%d b.", __FUNCTION__, len - headerSize)); + DebugDumpPacket("receive", pDataBuffer, 3); + + if( !pContext->bSurprizeRemoved && + ShallPassPacket(pContext, pDataBuffer, len - headerSize, &packetType) && + pContext->ReceiveState == srsEnabled && + pContext->bConnected) + { + BOOLEAN b = FALSE; + ULONG length = len - headerSize; + if (!pBatchOfPackets) + { + NdisReleaseSpinLock(&pContext->ReceiveLock); + b = NULL != ParaNdis_IndicateReceivedPacket( + pContext, + pDataBuffer, + &length, + FALSE, + pBuffersDescriptor); + NdisAcquireSpinLock(&pContext->ReceiveLock); + } + else + { + tPacketIndicationType packet; + packet = ParaNdis_IndicateReceivedPacket( + pContext, + pDataBuffer, + &length, + TRUE, + pBuffersDescriptor); + b = packet != NULL; + if (b) pBatchOfPackets[nReceived] = packet; + } + if (!b) + { + pContext->ReuseBufferProc(pContext, pBuffersDescriptor); + //only possible reason for that is unexpected Vlan tag + //shall I count it as error? + pContext->Statistics.ifInErrors++; + pContext->Statistics.ifInDiscards++; + } + else + { + nReceived++; + nReported++; + pContext->Statistics.ifHCInOctets += length; + switch(packetType) + { + case iptBroadcast: + pContext->Statistics.ifHCInBroadcastPkts++; + pContext->Statistics.ifHCInBroadcastOctets += length; + break; + case iptMulticast: + pContext->Statistics.ifHCInMulticastPkts++; + pContext->Statistics.ifHCInMulticastOctets += length; + break; + default: + pContext->Statistics.ifHCInUcastPkts++; + pContext->Statistics.ifHCInUcastOctets += length; + break; + } + if (pBatchOfPackets && nReceived == maxPacketsInBatch) + { + DPrintf(1, ("[%s] received %d buffers of max %d", __FUNCTION__, nReceived, ulMaxPacketsToIndicate)); + NdisReleaseSpinLock(&pContext->ReceiveLock); + ParaNdis_IndicateReceivedBatch(pContext, pBatchOfPackets, nReceived); + NdisAcquireSpinLock(&pContext->ReceiveLock); + nReceived = 0; + } + } + } + else + { + // reuse packet, there is no data or the RX is suppressed + pContext->ReuseBufferProc(pContext, pBuffersDescriptor); + } + } + ParaNdis_DebugHistory(pContext, hopReceiveStat, NULL, nRetrieved, nReported, pContext->NetNofReceiveBuffers); + NdisReleaseSpinLock(&pContext->ReceiveLock); + if (nReceived && pBatchOfPackets) + { + DPrintf(1, ("[%s]%d: received %d buffers of max %d", __FUNCTION__, KeGetCurrentProcessorNumber(), nReceived, ulMaxPacketsToIndicate)); + ParaNdis_IndicateReceivedBatch(pContext, pBatchOfPackets, nReceived); + } + if (pBatchOfPackets) NdisFreeMemory(pBatchOfPackets, 0, 0); + return nReported; +} + +void ParaNdis_ReportLinkStatus(PARANDIS_ADAPTER *pContext, BOOLEAN bForce) +{ + BOOLEAN bConnected = TRUE; + if (pContext->bLinkDetectSupported) + { + USHORT linkStatus = 0; + USHORT offset = sizeof(pContext->CurrentMacAddress); + // link changed + virtio_get_config(&pContext->IODevice, offset, &linkStatus, sizeof(linkStatus)); + bConnected = (linkStatus & VIRTIO_NET_S_LINK_UP) != 0; + } + ParaNdis_IndicateConnect(pContext, bConnected, bForce); +} + +static BOOLEAN RestartQueueSynchronously(tSynchronizedContext *SyncContext) +{ + struct virtqueue * _vq = (struct virtqueue *) SyncContext->Parameter; + bool res = true; + if (!virtqueue_enable_cb(_vq)) + { + virtqueue_disable_cb(_vq); + res = false; + } + + ParaNdis_DebugHistory(SyncContext->pContext, hopDPC, (PVOID)SyncContext->Parameter, 0x20, res, 0); + return !res; +} +/********************************************************** +DPC implementation, common for both NDIS +Parameters: + context +***********************************************************/ +ULONG ParaNdis_DPCWorkBody(PARANDIS_ADAPTER *pContext, ULONG ulMaxPacketsToIndicate) +{ + ULONG stillRequiresProcessing = 0; + ULONG interruptSources; + UINT uIndicatedRXPackets = 0; + UINT numOfPacketsToIndicate = min(ulMaxPacketsToIndicate, pContext->uNumberOfHandledRXPacketsInDPC); + + DEBUG_ENTRY(5); + if (pContext->bEnableInterruptHandlingDPC) + { + InterlockedIncrement(&pContext->counterDPCInside); + if (pContext->bEnableInterruptHandlingDPC) + { + BOOLEAN bDoKick = FALSE; + + InterlockedExchange(&pContext->bDPCInactive, 0); + interruptSources = InterlockedExchange(&pContext->InterruptStatus, 0); + ParaNdis_DebugHistory(pContext, hopDPC, (PVOID)1, interruptSources, 0, 0); + if ((interruptSources & isControl) && pContext->bLinkDetectSupported) + { + ParaNdis_ReportLinkStatus(pContext, FALSE); + } + if (interruptSources & isTransmit) + { + bDoKick = ParaNdis_ProcessTx(pContext, TRUE, TRUE); + } + if (interruptSources & isReceive) + { + int nRestartResult = 0; + + do + { + LONG rxActive = InterlockedIncrement(&pContext->dpcReceiveActive); + if (rxActive == 1) + { + uIndicatedRXPackets += ParaNdis_ProcessRxPath(pContext, numOfPacketsToIndicate - uIndicatedRXPackets); + InterlockedDecrement(&pContext->dpcReceiveActive); + NdisAcquireSpinLock(&pContext->ReceiveLock); + nRestartResult = ParaNdis_SynchronizeWithInterrupt( + pContext, pContext->ulRxMessage, RestartQueueSynchronously, pContext->NetReceiveQueue); + ParaNdis_DebugHistory(pContext, hopDPC, (PVOID)3, nRestartResult, 0, 0); + NdisReleaseSpinLock(&pContext->ReceiveLock); + DPrintf(nRestartResult ? 2 : 6, ("[%s] queue restarted%s", __FUNCTION__, nRestartResult ? "(Rerun)" : "(Done)")); + + if (uIndicatedRXPackets < numOfPacketsToIndicate) + { + + } + else if (uIndicatedRXPackets == numOfPacketsToIndicate) + { + DPrintf(1, ("[%s] Breaking Rx loop after %d indications", __FUNCTION__, uIndicatedRXPackets)); + ParaNdis_DebugHistory(pContext, hopDPC, (PVOID)4, nRestartResult, 0, 0); + break; + } + else + { + DPrintf(0, ("[%s] Glitch found: %d allowed, %d indicated", __FUNCTION__, numOfPacketsToIndicate, uIndicatedRXPackets)); + ParaNdis_DebugHistory(pContext, hopDPC, (PVOID)6, nRestartResult, 0, 0); + } + } + else + { + InterlockedDecrement(&pContext->dpcReceiveActive); + if (!nRestartResult) + { + NdisAcquireSpinLock(&pContext->ReceiveLock); + nRestartResult = ParaNdis_SynchronizeWithInterrupt( + pContext, pContext->ulRxMessage, RestartQueueSynchronously, pContext->NetReceiveQueue); + ParaNdis_DebugHistory(pContext, hopDPC, (PVOID)5, nRestartResult, 0, 0); + NdisReleaseSpinLock(&pContext->ReceiveLock); + } + DPrintf(1, ("[%s] Skip Rx processing no.%d", __FUNCTION__, rxActive)); + break; + } + } while (nRestartResult); + + if (nRestartResult) stillRequiresProcessing |= isReceive; + } + + if (interruptSources & isTransmit) + { + NdisAcquireSpinLock(&pContext->SendLock); + if (ParaNdis_SynchronizeWithInterrupt(pContext, pContext->ulTxMessage, RestartQueueSynchronously, pContext->NetSendQueue)) + stillRequiresProcessing |= isTransmit; + if(bDoKick) + { +#ifdef PARANDIS_TEST_TX_KICK_ALWAYS + virtqueue_kick_always(pContext->NetSendQueue); +#else + virtqueue_kick(pContext->NetSendQueue); +#endif + } + NdisReleaseSpinLock(&pContext->SendLock); + } + } + InterlockedDecrement(&pContext->counterDPCInside); + ParaNdis_DebugHistory(pContext, hopDPC, NULL, stillRequiresProcessing, pContext->nofFreeHardwareBuffers, pContext->nofFreeTxDescriptors); + } + return stillRequiresProcessing; +} + +/********************************************************** +Periodically called procedure, checking dpc activity +If DPC are not running, it does exactly the same that the DPC +Parameters: + context +***********************************************************/ +static BOOLEAN CheckRunningDpc(PARANDIS_ADAPTER *pContext) +{ + BOOLEAN bStopped; + BOOLEAN bReportHang = FALSE; + bStopped = 0 != InterlockedExchange(&pContext->bDPCInactive, TRUE); + + if (bStopped) + { + pContext->nDetectedInactivity++; + if (pContext->nEnableDPCChecker) + { + if (pContext->NetTxPacketsToReturn) + { + DPrintf(0, ("[%s] - NO ACTIVITY!", __FUNCTION__)); + if (!pContext->Limits.nPrintDiagnostic) PrintStatistics(pContext); + if (pContext->nEnableDPCChecker > 1) + { + int isrStatus1, isrStatus2; + isrStatus1 = virtio_read_isr_status(&pContext->IODevice); + isrStatus2 = virtio_read_isr_status(&pContext->IODevice); + if (isrStatus1 || isrStatus2) + { + DPrintf(0, ("WARNING: Interrupt status %d=>%d", isrStatus1, isrStatus2)); + } + } + // simulateDPC + InterlockedOr(&pContext->InterruptStatus, isAny); + ParaNdis_DPCWorkBody(pContext, PARANDIS_UNLIMITED_PACKETS_TO_INDICATE); + } + } + } + else + { + pContext->nDetectedInactivity = 0; + } + + NdisAcquireSpinLock(&pContext->SendLock); + if (pContext->nofFreeHardwareBuffers != pContext->maxFreeHardwareBuffers) + { + if (pContext->nDetectedStoppedTx++ > 1) + { + DPrintf(0, ("[%s] - Suspicious Tx inactivity (%d)!", __FUNCTION__, pContext->nofFreeHardwareBuffers)); + //bReportHang = TRUE; +#ifdef DBG_USE_VIRTIO_PCI_ISR_FOR_HOST_REPORT + WriteVirtIODeviceByte(pContext->IODevice.isr, 0); +#endif + } + } + NdisReleaseSpinLock(&pContext->SendLock); + + + if (pContext->Limits.nPrintDiagnostic && + ++pContext->Counters.nPrintDiagnostic >= pContext->Limits.nPrintDiagnostic) + { + pContext->Counters.nPrintDiagnostic = 0; + // todo - collect more and put out optionally + PrintStatistics(pContext); + } + + if (pContext->Statistics.ifHCInOctets == pContext->Counters.prevIn) + { + pContext->Counters.nRxInactivity++; + if (pContext->Counters.nRxInactivity >= 10) + { +//#define CRASH_ON_NO_RX +#if defined(CRASH_ON_NO_RX) + ONPAUSECOMPLETEPROC proc = (ONPAUSECOMPLETEPROC)(PVOID)1; + proc(pContext); +#endif + } + } + else + { + pContext->Counters.nRxInactivity = 0; + pContext->Counters.prevIn = pContext->Statistics.ifHCInOctets; + } + return bReportHang; +} + +/********************************************************** +Common implementation of periodic poll +Parameters: + context +Return: + TRUE, if reset required +***********************************************************/ +BOOLEAN ParaNdis_CheckForHang(PARANDIS_ADAPTER *pContext) +{ + static int nHangOn = 0; + BOOLEAN b = nHangOn >= 3 && nHangOn < 6; + DEBUG_ENTRY(3); + b |= CheckRunningDpc(pContext); + //uncomment to cause 3 consecutive resets + //nHangOn++; + DEBUG_EXIT_STATUS(b ? 0 : 6, b); + return b; +} + +/********************************************************** +Common handler of multicast address configuration +Parameters: + PVOID Buffer array of addresses from NDIS + ULONG BufferSize size of incoming buffer + PUINT pBytesRead update on success + PUINT pBytesNeeded update on wrong buffer size +Return value: + SUCCESS or kind of failure +***********************************************************/ +NDIS_STATUS ParaNdis_SetMulticastList( + PARANDIS_ADAPTER *pContext, + PVOID Buffer, + ULONG BufferSize, + PUINT pBytesRead, + PUINT pBytesNeeded) +{ + NDIS_STATUS status; + ULONG length = BufferSize; + if (length > sizeof(pContext->MulticastData.MulticastList)) + { + status = NDIS_STATUS_MULTICAST_FULL; + *pBytesNeeded = sizeof(pContext->MulticastData.MulticastList); + } + else if (length % ETH_LENGTH_OF_ADDRESS) + { + status = NDIS_STATUS_INVALID_LENGTH; + *pBytesNeeded = (length / ETH_LENGTH_OF_ADDRESS) * ETH_LENGTH_OF_ADDRESS; + } + else + { + NdisZeroMemory(pContext->MulticastData.MulticastList, sizeof(pContext->MulticastData.MulticastList)); + if (length) + NdisMoveMemory(pContext->MulticastData.MulticastList, Buffer, length); + pContext->MulticastData.nofMulticastEntries = length / ETH_LENGTH_OF_ADDRESS; + DPrintf(1, ("[%s] New multicast list of %d bytes", __FUNCTION__, length)); + *pBytesRead = length; + status = NDIS_STATUS_SUCCESS; + } + return status; +} + +/********************************************************** +Callable from synchronized routine or interrupt handler +to enable or disable Rx and/or Tx interrupt generation +Parameters: + context + interruptSource - isReceive, isTransmit + b - 1/0 enable/disable +***********************************************************/ +VOID ParaNdis_VirtIOEnableIrqSynchronized(PARANDIS_ADAPTER *pContext, ULONG interruptSource) +{ + if (interruptSource & isTransmit) + virtqueue_enable_cb(pContext->NetSendQueue); + if (interruptSource & isReceive) + virtqueue_enable_cb(pContext->NetReceiveQueue); + ParaNdis_DebugHistory(pContext, hopDPC, (PVOID)0x10, interruptSource, TRUE, 0); +} + +VOID ParaNdis_VirtIODisableIrqSynchronized(PARANDIS_ADAPTER *pContext, ULONG interruptSource) +{ + if (interruptSource & isTransmit) + virtqueue_disable_cb(pContext->NetSendQueue); + if (interruptSource & isReceive) + virtqueue_disable_cb(pContext->NetReceiveQueue); + ParaNdis_DebugHistory(pContext, hopDPC, (PVOID)0x10, interruptSource, FALSE, 0); +} + +/********************************************************** +Common handler of PnP events +Parameters: +Return value: +***********************************************************/ +VOID ParaNdis_OnPnPEvent( + PARANDIS_ADAPTER *pContext, + NDIS_DEVICE_PNP_EVENT pEvent, + PVOID pInfo, + ULONG ulSize) +{ + const char *pName = ""; + DEBUG_ENTRY(0); +#undef MAKECASE +#define MAKECASE(x) case (x): pName = #x; break; + switch (pEvent) + { + MAKECASE(NdisDevicePnPEventQueryRemoved) + MAKECASE(NdisDevicePnPEventRemoved) + MAKECASE(NdisDevicePnPEventSurpriseRemoved) + MAKECASE(NdisDevicePnPEventQueryStopped) + MAKECASE(NdisDevicePnPEventStopped) + MAKECASE(NdisDevicePnPEventPowerProfileChanged) + default: + break; + } + ParaNdis_DebugHistory(pContext, hopPnpEvent, NULL, pEvent, 0, 0); + DPrintf(0, ("[%s] (%s)", __FUNCTION__, pName)); + if (pEvent == NdisDevicePnPEventSurpriseRemoved) + { + // on simulated surprise removal (under PnpTest) we need to reset the device + // to prevent any access of device queues to memory buffers + pContext->bSurprizeRemoved = TRUE; + ParaNdis_ResetVirtIONetDevice(pContext); + } + pContext->PnpEvents[pContext->nPnpEventIndex++] = pEvent; + if (pContext->nPnpEventIndex > sizeof(pContext->PnpEvents)/sizeof(pContext->PnpEvents[0])) + pContext->nPnpEventIndex = 0; +} + +static BOOLEAN SendControlMessage( + PARANDIS_ADAPTER *pContext, + UCHAR cls, + UCHAR cmd, + PVOID buffer1, + ULONG size1, + PVOID buffer2, + ULONG size2, + int levelIfOK + ) +{ + BOOLEAN bOK = FALSE; + NdisAcquireSpinLock(&pContext->ReceiveLock); + if (pContext->ControlData.Virtual && pContext->ControlData.size > (size1 + size2 + 16)) + { + struct VirtIOBufferDescriptor sg[4]; + PUCHAR pBase = (PUCHAR)pContext->ControlData.Virtual; + PHYSICAL_ADDRESS phBase = pContext->ControlData.Physical; + ULONG offset = 0; + UINT nOut = 1; + + ((virtio_net_ctrl_hdr *)pBase)->class_of_command = cls; + ((virtio_net_ctrl_hdr *)pBase)->cmd = cmd; + sg[0].physAddr = phBase; + sg[0].length = sizeof(virtio_net_ctrl_hdr); + offset += sg[0].length; + offset = (offset + 3) & ~3; + if (size1) + { + NdisMoveMemory(pBase + offset, buffer1, size1); + sg[nOut].physAddr = phBase; + sg[nOut].physAddr.QuadPart += offset; + sg[nOut].length = size1; + offset += size1; + offset = (offset + 3) & ~3; + nOut++; + } + if (size2) + { + NdisMoveMemory(pBase + offset, buffer2, size2); + sg[nOut].physAddr = phBase; + sg[nOut].physAddr.QuadPart += offset; + sg[nOut].length = size2; + offset += size2; + offset = (offset + 3) & ~3; + nOut++; + } + sg[nOut].physAddr = phBase; + sg[nOut].physAddr.QuadPart += offset; + sg[nOut].length = sizeof(virtio_net_ctrl_ack); + *(virtio_net_ctrl_ack *)(pBase + offset) = VIRTIO_NET_ERR; + + if (0 <= virtqueue_add_buf(pContext->NetControlQueue, sg, nOut, 1, (PVOID)1, NULL, 0)) + { + UINT len; + void *p; + virtqueue_kick_always(pContext->NetControlQueue); + p = virtqueue_get_buf(pContext->NetControlQueue, &len); + if (!p) + { + DPrintf(0, ("%s - ERROR: get_buf failed", __FUNCTION__)); + } + else if (len != sizeof(virtio_net_ctrl_ack)) + { + DPrintf(0, ("%s - ERROR: wrong len %d", __FUNCTION__, len)); + } + else if (*(virtio_net_ctrl_ack *)(pBase + offset) != VIRTIO_NET_OK) + { + DPrintf(0, ("%s - ERROR: error %d returned", __FUNCTION__, *(virtio_net_ctrl_ack *)(pBase + offset))); + } + else + { + // everything is OK + DPrintf(levelIfOK, ("%s OK(%d.%d,buffers of %d and %d) ", __FUNCTION__, cls, cmd, size1, size2)); + bOK = TRUE; + } + } + else + { + DPrintf(0, ("%s - ERROR: add_buf failed", __FUNCTION__)); + } + } + else + { + DPrintf(0, ("%s (buffer %d,%d) - ERROR: message too LARGE", __FUNCTION__, size1, size2)); + } + NdisReleaseSpinLock(&pContext->ReceiveLock); + return bOK; +} + +static VOID ParaNdis_DeviceFiltersUpdateRxMode(PARANDIS_ADAPTER *pContext) +{ + u8 val; + ULONG f = pContext->PacketFilter; + val = (f & NDIS_PACKET_TYPE_ALL_MULTICAST) ? 1 : 0; + SendControlMessage(pContext, VIRTIO_NET_CTRL_RX_MODE, VIRTIO_NET_CTRL_RX_MODE_ALLMULTI, &val, sizeof(val), NULL, 0, 2); + //SendControlMessage(pContext, VIRTIO_NET_CTRL_RX_MODE, VIRTIO_NET_CTRL_RX_MODE_ALLUNI, &val, sizeof(val), NULL, 0, 2); + val = (f & (NDIS_PACKET_TYPE_MULTICAST | NDIS_PACKET_TYPE_ALL_MULTICAST)) ? 0 : 1; + SendControlMessage(pContext, VIRTIO_NET_CTRL_RX_MODE, VIRTIO_NET_CTRL_RX_MODE_NOMULTI, &val, sizeof(val), NULL, 0, 2); + val = (f & NDIS_PACKET_TYPE_DIRECTED) ? 0 : 1; + SendControlMessage(pContext, VIRTIO_NET_CTRL_RX_MODE, VIRTIO_NET_CTRL_RX_MODE_NOUNI, &val, sizeof(val), NULL, 0, 2); + val = (f & NDIS_PACKET_TYPE_BROADCAST) ? 0 : 1; + SendControlMessage(pContext, VIRTIO_NET_CTRL_RX_MODE, VIRTIO_NET_CTRL_RX_MODE_NOBCAST, &val, sizeof(val), NULL, 0, 2); + val = (f & NDIS_PACKET_TYPE_PROMISCUOUS) ? 1 : 0; + SendControlMessage(pContext, VIRTIO_NET_CTRL_RX_MODE, VIRTIO_NET_CTRL_RX_MODE_PROMISC, &val, sizeof(val), NULL, 0, 2); +} + +static VOID ParaNdis_DeviceFiltersUpdateAddresses(PARANDIS_ADAPTER *pContext) +{ + struct + { + struct virtio_net_ctrl_mac header; + UCHAR addr[ETH_LENGTH_OF_ADDRESS]; + } uCast; + uCast.header.entries = 1; + NdisMoveMemory(uCast.addr, pContext->CurrentMacAddress, sizeof(uCast.addr)); + SendControlMessage(pContext, VIRTIO_NET_CTRL_MAC, VIRTIO_NET_CTRL_MAC_TABLE_SET, + &uCast, sizeof(uCast), &pContext->MulticastData,sizeof(pContext->MulticastData.nofMulticastEntries) + pContext->MulticastData.nofMulticastEntries * ETH_ALEN, 2); +} + +static VOID SetSingleVlanFilter(PARANDIS_ADAPTER *pContext, ULONG vlanId, BOOLEAN bOn, int levelIfOK) +{ + u16 val = vlanId & 0xfff; + UCHAR cmd = bOn ? VIRTIO_NET_CTRL_VLAN_ADD : VIRTIO_NET_CTRL_VLAN_DEL; + SendControlMessage(pContext, VIRTIO_NET_CTRL_VLAN, cmd, &val, sizeof(val), NULL, 0, levelIfOK); +} + +static VOID SetAllVlanFilters(PARANDIS_ADAPTER *pContext, BOOLEAN bOn) +{ + ULONG i; + for (i = 0; i <= MAX_VLAN_ID; ++i) + SetSingleVlanFilter(pContext, i, bOn, 7); +} + +/* + possible values of filter set (pContext->ulCurrentVlansFilterSet): + 0 - all disabled + 1..4095 - one selected enabled + 4096 - all enabled + Note that only 0th vlan can't be enabled +*/ +VOID ParaNdis_DeviceFiltersUpdateVlanId(PARANDIS_ADAPTER *pContext) +{ + if (pContext->bHasHardwareFilters) + { + ULONG newFilterSet; + if (IsVlanSupported(pContext)) + newFilterSet = pContext->VlanId ? pContext->VlanId : (MAX_VLAN_ID + 1); + else + newFilterSet = IsPrioritySupported(pContext) ? (MAX_VLAN_ID + 1) : 0; + if (newFilterSet != pContext->ulCurrentVlansFilterSet) + { + if (pContext->ulCurrentVlansFilterSet > MAX_VLAN_ID) + SetAllVlanFilters(pContext, FALSE); + else if (pContext->ulCurrentVlansFilterSet) + SetSingleVlanFilter(pContext, pContext->ulCurrentVlansFilterSet, FALSE, 2); + + pContext->ulCurrentVlansFilterSet = newFilterSet; + + if (pContext->ulCurrentVlansFilterSet > MAX_VLAN_ID) + SetAllVlanFilters(pContext, TRUE); + else if (pContext->ulCurrentVlansFilterSet) + SetSingleVlanFilter(pContext, pContext->ulCurrentVlansFilterSet, TRUE, 2); + } + } +} + +VOID ParaNdis_UpdateDeviceFilters(PARANDIS_ADAPTER *pContext) +{ + if (pContext->bHasHardwareFilters) + { + ParaNdis_DeviceFiltersUpdateRxMode(pContext); + ParaNdis_DeviceFiltersUpdateAddresses(pContext); + ParaNdis_DeviceFiltersUpdateVlanId(pContext); + } +} + +NDIS_STATUS ParaNdis_PowerOn(PARANDIS_ADAPTER *pContext) +{ + LIST_ENTRY TempList; + NDIS_STATUS status; + DEBUG_ENTRY(0); + ParaNdis_DebugHistory(pContext, hopPowerOn, NULL, 1, 0, 0); + ParaNdis_ResetVirtIONetDevice(pContext); + virtio_add_status(&pContext->IODevice, VIRTIO_CONFIG_S_ACKNOWLEDGE | VIRTIO_CONFIG_S_DRIVER); + /* virtio_get_features must be called once upon device initialization: + otherwise the device will not work properly */ + (void)virtio_get_features(&pContext->IODevice); + + if (pContext->bUseMergedBuffers) + VirtIODeviceEnableGuestFeature(pContext, VIRTIO_NET_F_MRG_RXBUF); + if (VirtIODeviceGetHostFeature(pContext, VIRTIO_RING_F_EVENT_IDX)) + VirtIODeviceEnableGuestFeature(pContext, VIRTIO_RING_F_EVENT_IDX); + if (pContext->bDoGuestChecksumOnReceive) + VirtIODeviceEnableGuestFeature(pContext, VIRTIO_NET_F_GUEST_CSUM); + if (VirtIODeviceGetHostFeature(pContext, VIRTIO_F_VERSION_1)) + VirtIODeviceEnableGuestFeature(pContext, VIRTIO_F_VERSION_1); + if (VirtIODeviceGetHostFeature(pContext, VIRTIO_F_ANY_LAYOUT)) + VirtIODeviceEnableGuestFeature(pContext, VIRTIO_F_ANY_LAYOUT); + + status = FinalizeFeatures(pContext); + if (status == NDIS_STATUS_SUCCESS) { + status = FindNetQueues(pContext); + } + if (status != NDIS_STATUS_SUCCESS) { + virtio_add_status(&pContext->IODevice, VIRTIO_CONFIG_S_FAILED); + return status; + } + + ParaNdis_RestoreDeviceConfigurationAfterReset(pContext); + + ParaNdis_UpdateDeviceFilters(pContext); + + InitializeListHead(&TempList); + + /* submit all the receive buffers */ + NdisAcquireSpinLock(&pContext->ReceiveLock); + + pContext->ReuseBufferProc = (tReuseReceiveBufferProc)ReuseReceiveBufferRegular; + + while (!IsListEmpty(&pContext->NetReceiveBuffers)) + { + pIONetDescriptor pBufferDescriptor = + (pIONetDescriptor)RemoveHeadList(&pContext->NetReceiveBuffers); + InsertTailList(&TempList, &pBufferDescriptor->listEntry); + } + pContext->NetNofReceiveBuffers = 0; + while (!IsListEmpty(&TempList)) + { + pIONetDescriptor pBufferDescriptor = + (pIONetDescriptor)RemoveHeadList(&TempList); + if (AddRxBufferToQueue(pContext, pBufferDescriptor)) + { + InsertTailList(&pContext->NetReceiveBuffers, &pBufferDescriptor->listEntry); + pContext->NetNofReceiveBuffers++; + } + else + { + DPrintf(0, ("FAILED TO REUSE THE BUFFER!!!!")); + VirtIONetFreeBufferDescriptor(pContext, pBufferDescriptor); + pContext->NetMaxReceiveBuffers--; + } + } + virtqueue_kick(pContext->NetReceiveQueue); + ParaNdis_SetPowerState(pContext, NdisDeviceStateD0); + pContext->bEnableInterruptHandlingDPC = TRUE; + virtio_device_ready(&pContext->IODevice); + + NdisReleaseSpinLock(&pContext->ReceiveLock); + + // if bFastSuspendInProcess is set by Win8 power-off procedure, + // the ParaNdis_Resume enables Tx and RX + // otherwise it does not do anything in Vista+ (Tx and RX are enabled after power-on by Restart) + ParaNdis_Resume(pContext); + pContext->bFastSuspendInProcess = FALSE; + + ParaNdis_ReportLinkStatus(pContext, TRUE); + ParaNdis_DebugHistory(pContext, hopPowerOn, NULL, 0, 0, 0); + + return status; +} + +VOID ParaNdis_PowerOff(PARANDIS_ADAPTER *pContext) +{ + DEBUG_ENTRY(0); + ParaNdis_DebugHistory(pContext, hopPowerOff, NULL, 1, 0, 0); + + ParaNdis_IndicateConnect(pContext, FALSE, FALSE); + + // if bFastSuspendInProcess is set by Win8 power-off procedure + // the ParaNdis_Suspend does fast Rx stop without waiting (=>srsPausing, if there are some RX packets in Ndis) + pContext->bFastSuspendInProcess = pContext->bNoPauseOnSuspend && pContext->ReceiveState == srsEnabled; + ParaNdis_Suspend(pContext); + if (pContext->IODevice.addr) + { + /* back compat - remove the OK flag only in legacy mode */ + VirtIODeviceRemoveStatus(&pContext->IODevice, VIRTIO_CONFIG_S_DRIVER_OK); + } + + if (pContext->bFastSuspendInProcess) + { + NdisAcquireSpinLock(&pContext->ReceiveLock); + pContext->ReuseBufferProc = (tReuseReceiveBufferProc)ReuseReceiveBufferPowerOff; + NdisReleaseSpinLock(&pContext->ReceiveLock); + } + + ParaNdis_SetPowerState(pContext, NdisDeviceStateD3); + + PreventDPCServicing(pContext); + + /******************************************************************* + shutdown queues to have all the receive buffers under our control + all the transmit buffers move to list of free buffers + ********************************************************************/ + + NdisAcquireSpinLock(&pContext->SendLock); + virtqueue_shutdown(pContext->NetSendQueue); + while (!IsListEmpty(&pContext->NetSendBuffersInUse)) + { + pIONetDescriptor pBufferDescriptor = + (pIONetDescriptor)RemoveHeadList(&pContext->NetSendBuffersInUse); + InsertTailList(&pContext->NetFreeSendBuffers, &pBufferDescriptor->listEntry); + pContext->nofFreeTxDescriptors++; + pContext->nofFreeHardwareBuffers += pBufferDescriptor->nofUsedBuffers; + } + NdisReleaseSpinLock(&pContext->SendLock); + + NdisAcquireSpinLock(&pContext->ReceiveLock); + virtqueue_shutdown(pContext->NetReceiveQueue); + NdisReleaseSpinLock(&pContext->ReceiveLock); + if (pContext->NetControlQueue) { + virtqueue_shutdown(pContext->NetControlQueue); + } + + DPrintf(0, ("WARNING: deleting queues!!!!!!!!!")); + DeleteNetQueues(pContext); + pContext->NetSendQueue = NULL; + pContext->NetReceiveQueue = NULL; + pContext->NetControlQueue = NULL; + + ParaNdis_ResetVirtIONetDevice(pContext); + ParaNdis_DebugHistory(pContext, hopPowerOff, NULL, 0, 0, 0); +} + +void ParaNdis_CallOnBugCheck(PARANDIS_ADAPTER *pContext) +{ + if (pContext->IODevice.isr) + { +#ifdef DBG_USE_VIRTIO_PCI_ISR_FOR_HOST_REPORT + WriteVirtIODeviceByte(pContext->IODevice.isr, 1); +#endif + } +} + +tChecksumCheckResult ParaNdis_CheckRxChecksum(PARANDIS_ADAPTER *pContext, ULONG virtioFlags, PVOID pRxPacket, ULONG len) +{ + tOffloadSettingsFlags f = pContext->Offload.flags; + tChecksumCheckResult res, resIp; + PVOID pIpHeader = RtlOffsetToPointer(pRxPacket, ETH_HEADER_SIZE); + tTcpIpPacketParsingResult ppr; + ULONG flagsToCalculate = 0; + res.value = 0; + resIp.value = 0; + + //VIRTIO_NET_HDR_F_NEEDS_CSUM - we need to calculate TCP/UDP CS + //VIRTIO_NET_HDR_F_DATA_VALID - host tells us TCP/UDP CS is OK + + if (f.fRxIPChecksum) flagsToCalculate |= pcrIpChecksum; // check only + + if (!(virtioFlags & VIRTIO_NET_HDR_F_DATA_VALID)) + { + if (virtioFlags & VIRTIO_NET_HDR_F_NEEDS_CSUM) + { + flagsToCalculate |= pcrFixXxpChecksum | pcrTcpChecksum | pcrUdpChecksum; + } + else + { + if (f.fRxTCPChecksum) flagsToCalculate |= pcrTcpV4Checksum; + if (f.fRxUDPChecksum) flagsToCalculate |= pcrUdpV4Checksum; + if (f.fRxTCPv6Checksum) flagsToCalculate |= pcrTcpV6Checksum; + if (f.fRxUDPv6Checksum) flagsToCalculate |= pcrUdpV6Checksum; + } + } + + ppr = ParaNdis_CheckSumVerify(pIpHeader, len - ETH_HEADER_SIZE, flagsToCalculate, __FUNCTION__); + + if (virtioFlags & VIRTIO_NET_HDR_F_DATA_VALID) + { + pContext->extraStatistics.framesRxCSHwOK++; + ppr.xxpCheckSum = ppresCSOK; + } + + if (ppr.ipStatus == ppresIPV4 && !ppr.IsFragment) + { + if (f.fRxIPChecksum) + { + res.flags.IpOK = ppr.ipCheckSum == ppresCSOK; + res.flags.IpFailed = ppr.ipCheckSum == ppresCSBad; + } + if(ppr.xxpStatus == ppresXxpKnown) + { + if(ppr.TcpUdp == ppresIsTCP) /* TCP */ + { + if (f.fRxTCPChecksum) + { + res.flags.TcpOK = ppr.xxpCheckSum == ppresCSOK || ppr.fixedXxpCS; + res.flags.TcpFailed = !res.flags.TcpOK; + } + } + else /* UDP */ + { + if (f.fRxUDPChecksum) + { + res.flags.UdpOK = ppr.xxpCheckSum == ppresCSOK || ppr.fixedXxpCS; + res.flags.UdpFailed = !res.flags.UdpOK; + } + } + } + } + else if (ppr.ipStatus == ppresIPV6) + { + if(ppr.xxpStatus == ppresXxpKnown) + { + if(ppr.TcpUdp == ppresIsTCP) /* TCP */ + { + if (f.fRxTCPv6Checksum) + { + res.flags.TcpOK = ppr.xxpCheckSum == ppresCSOK || ppr.fixedXxpCS; + res.flags.TcpFailed = !res.flags.TcpOK; + } + } + else /* UDP */ + { + if (f.fRxUDPv6Checksum) + { + res.flags.UdpOK = ppr.xxpCheckSum == ppresCSOK || ppr.fixedXxpCS; + res.flags.UdpFailed = !res.flags.UdpOK; + } + } + } + } + + if (pContext->bDoIPCheckRx && + (f.fRxIPChecksum || f.fRxTCPChecksum || f.fRxUDPChecksum || f.fRxTCPv6Checksum || f.fRxUDPv6Checksum)) + { + ppr = ParaNdis_CheckSumVerify(pIpHeader, len - ETH_HEADER_SIZE, pcrAnyChecksum, __FUNCTION__); + if (ppr.ipStatus == ppresIPV4 && !ppr.IsFragment) + { + resIp.flags.IpOK = !!f.fRxIPChecksum && ppr.ipCheckSum == ppresCSOK; + resIp.flags.IpFailed = !!f.fRxIPChecksum && ppr.ipCheckSum == ppresCSBad; + if (f.fRxTCPChecksum && ppr.xxpStatus == ppresXxpKnown && ppr.TcpUdp == ppresIsTCP) + { + resIp.flags.TcpOK = ppr.xxpCheckSum == ppresCSOK; + resIp.flags.TcpFailed = ppr.xxpCheckSum == ppresCSBad; + } + if (f.fRxUDPChecksum && ppr.xxpStatus == ppresXxpKnown && ppr.TcpUdp == ppresIsUDP) + { + resIp.flags.UdpOK = ppr.xxpCheckSum == ppresCSOK; + resIp.flags.UdpFailed = ppr.xxpCheckSum == ppresCSBad; + } + } + else if (ppr.ipStatus == ppresIPV6) + { + if (f.fRxTCPv6Checksum && ppr.xxpStatus == ppresXxpKnown && ppr.TcpUdp == ppresIsTCP) + { + resIp.flags.TcpOK = ppr.xxpCheckSum == ppresCSOK; + resIp.flags.TcpFailed = ppr.xxpCheckSum == ppresCSBad; + } + if (f.fRxUDPv6Checksum && ppr.xxpStatus == ppresXxpKnown && ppr.TcpUdp == ppresIsUDP) + { + resIp.flags.UdpOK = ppr.xxpCheckSum == ppresCSOK; + resIp.flags.UdpFailed = ppr.xxpCheckSum == ppresCSBad; + } + } + + if (res.value != resIp.value) + { + // if HW did not set some bits that IP checker set, it is a mistake: + // or GOOD CS is not labeled, or BAD checksum is not labeled + tChecksumCheckResult diff; + diff.value = resIp.value & ~res.value; + if (diff.flags.IpFailed || diff.flags.TcpFailed || diff.flags.UdpFailed) + pContext->extraStatistics.framesRxCSHwMissedBad++; + if (diff.flags.IpOK || diff.flags.TcpOK || diff.flags.UdpOK) + pContext->extraStatistics.framesRxCSHwMissedGood++; + if (diff.value) + { + DPrintf(0, ("[%s] real %X <> %X (virtio %X)", __FUNCTION__, resIp.value, res.value, virtioFlags)); + } + res.value = resIp.value; + } + } + + return res; +} diff --git a/drivers/network/dd/netkvm/Common/ParaNdis-Debug.c b/drivers/network/dd/netkvm/Common/ParaNdis-Debug.c new file mode 100644 index 00000000000..f66b92502f8 --- /dev/null +++ b/drivers/network/dd/netkvm/Common/ParaNdis-Debug.c @@ -0,0 +1,394 @@ +/* + * This file contains debug support procedures, common for NDIS5 and NDIS6 + * + * Copyright (c) 2008-2017 Red Hat, Inc. + * + * 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 names of the copyright holders nor the names of their 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 HOLDERS 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 "ndis56common.h" +#include "stdarg.h" +#include "ntstrsafe.h" + +//#define OVERRIDE_DEBUG_BREAK + +#ifdef WPP_EVENT_TRACING +#include "ParaNdis-Debug.tmh" +#endif + +int virtioDebugLevel = 1; +int nDebugLevel = 1; +int bDebugPrint = 1; + +static NDIS_SPIN_LOCK CrashLock; + +static KBUGCHECK_REASON_CALLBACK_ROUTINE ParaNdis_OnBugCheck; +static VOID NTAPI ParaNdis_OnBugCheck( + IN KBUGCHECK_CALLBACK_REASON Reason, + IN PKBUGCHECK_REASON_CALLBACK_RECORD Record, + IN OUT PVOID ReasonSpecificData, + IN ULONG ReasonSpecificDataLength +); +static VOID ParaNdis_PrepareBugCheckData(); + +typedef BOOLEAN (*KeRegisterBugCheckReasonCallbackType) ( + __out PKBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord, + __in PKBUGCHECK_REASON_CALLBACK_ROUTINE CallbackRoutine, + __in KBUGCHECK_CALLBACK_REASON Reason, + __in PUCHAR Component + ); + +typedef BOOLEAN (*KeDeregisterBugCheckReasonCallbackType) ( + __inout PKBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord + ); + +typedef ULONG (*vDbgPrintExType)( + __in ULONG ComponentId, + __in ULONG Level, + __in PCCH Format, + __in va_list arglist + ); + +static ULONG DummyPrintProcedure( + __in ULONG ComponentId, + __in ULONG Level, + __in PCCH Format, + __in va_list arglist + ) +{ + return 0; +} +static BOOLEAN KeRegisterBugCheckReasonCallbackDummyProc( + __out PKBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord, + __in PKBUGCHECK_REASON_CALLBACK_ROUTINE CallbackRoutine, + __in KBUGCHECK_CALLBACK_REASON Reason, + __in PUCHAR Component + ) +{ + CallbackRecord->State = 0; + return FALSE; +} + +BOOLEAN KeDeregisterBugCheckReasonCallbackDummyProc( + __inout PKBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord + ) +{ + return FALSE; +} + +static vDbgPrintExType PrintProcedure = DummyPrintProcedure; +static KeRegisterBugCheckReasonCallbackType BugCheckRegisterCallback = KeRegisterBugCheckReasonCallbackDummyProc; +static KeDeregisterBugCheckReasonCallbackType BugCheckDeregisterCallback = KeDeregisterBugCheckReasonCallbackDummyProc; +KBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord; + +#if !defined(WPP_EVENT_TRACING) || defined(WPP_USE_BYPASS) +#if defined(DPFLTR_MASK) + +//common case, except Win2K +static void DebugPrint(const char *fmt, ...) +{ + va_list list; + va_start(list, fmt); + PrintProcedure(DPFLTR_DEFAULT_ID, 9 | DPFLTR_MASK, fmt, list); +#if defined(VIRTIO_DBG_USE_IOPORT) + { + NTSTATUS status; + // use this way of output only for DISPATCH_LEVEL, + // higher requires more protection + if (KeGetCurrentIrql() <= DISPATCH_LEVEL) + { + char buf[256]; + size_t len, i; + buf[0] = 0; + status = RtlStringCbVPrintfA(buf, sizeof(buf), fmt, list); + if (status == STATUS_SUCCESS) len = strlen(buf); + else if (status == STATUS_BUFFER_OVERFLOW) len = sizeof(buf); + else { memcpy(buf, "Can't print", 11); len = 11; } + NdisAcquireSpinLock(&CrashLock); + for (i = 0; i < len; ++i) + { + NdisRawWritePortUchar(VIRTIO_DBG_USE_IOPORT, buf[i]); + } + NdisRawWritePortUchar(VIRTIO_DBG_USE_IOPORT, '\n'); + NdisReleaseSpinLock(&CrashLock); + } + } +#endif +} + +DEBUGPRINTFUNC pDebugPrint = DebugPrint; +DEBUGPRINTFUNC VirtioDebugPrintProc = DebugPrint; + +#else //DPFLTR_MASK +#pragma message("DebugPrint for Win2K") + +DEBUGPRINTFUNC pDebugPrint = DbgPrint; +DEBUGPRINTFUNC VirtioDebugPrintProc = DbgPrint; + +#endif //DPFLTR_MASK +#endif //!defined(WPP_EVENT_TRACING) || defined(WPP_USE_BYPASS) + + + +void _LogOutEntry(int level, const char *s) +{ + DPrintf(level, ("[%s]=>", s)); +} + +void _LogOutExitValue(int level, const char *s, ULONG value) +{ + DPrintf(level, ("[%s]<=0x%X", s, value)); +} + +void _LogOutString(int level, const char *s) +{ + DPrintf(level, ("[%s]", s)); +} + +VOID WppEnableCallback( + __in LPCGUID Guid, + __in __int64 Logger, + __in BOOLEAN Enable, + __in ULONG Flags, + __in UCHAR Level) +{ +#if WPP_USE_BYPASS + DPrintfBypass(0, ("[%s] %s, flags %X, level %d", + __FUNCTION__, Enable ? "enabled" : "disabled", + Flags, (ULONG)Level)); +#endif + nDebugLevel = Level; + bDebugPrint = Enable; +} + + +#ifdef OVERRIDE_DEBUG_BREAK +static PUCHAR pDbgBreakPoint; +static UCHAR DbgBreakPointChunk[5]; +static void AnotherDbgBreak() +{ + DPrintf(0, ("Somebody tried to break into the debugger!")); +} +#endif + +void ParaNdis_DebugInitialize(PVOID DriverObject,PVOID RegistryPath) +{ + NDIS_STRING usRegister, usDeregister, usPrint; + PVOID pr, pd; + BOOLEAN res; + WPP_INIT_TRACING(DriverObject, RegistryPath); + + NdisAllocateSpinLock(&CrashLock); + KeInitializeCallbackRecord(&CallbackRecord); + ParaNdis_PrepareBugCheckData(); + NdisInitUnicodeString(&usPrint, L"vDbgPrintEx"); + NdisInitUnicodeString(&usRegister, L"KeRegisterBugCheckReasonCallback"); + NdisInitUnicodeString(&usDeregister, L"KeDeregisterBugCheckReasonCallback"); + pd = MmGetSystemRoutineAddress(&usPrint); + if (pd) PrintProcedure = (vDbgPrintExType)pd; + pr = MmGetSystemRoutineAddress(&usRegister); + pd = MmGetSystemRoutineAddress(&usDeregister); + if (pr && pd) + { + BugCheckRegisterCallback = (KeRegisterBugCheckReasonCallbackType)pr; + BugCheckDeregisterCallback = (KeDeregisterBugCheckReasonCallbackType)pd; + } + res = BugCheckRegisterCallback(&CallbackRecord, ParaNdis_OnBugCheck, KbCallbackSecondaryDumpData, "NetKvm"); + DPrintf(0, ("[%s] Crash callback %sregistered", __FUNCTION__, res ? "" : "NOT ")); + +#ifdef OVERRIDE_DEBUG_BREAK + if (sizeof(PVOID) == sizeof(ULONG)) + { + UCHAR replace[5] = {0xe9,0,0,0,0}; + ULONG replacement; + NDIS_STRING usDbgBreakPointName; + NdisInitUnicodeString(&usDbgBreakPointName, L"DbgBreakPoint"); + pDbgBreakPoint = (PUCHAR)MmGetSystemRoutineAddress(&usDbgBreakPointName); + if (pDbgBreakPoint) + { + DPrintf(0, ("Replacing original BP handler at %p", pDbgBreakPoint)); + replacement = RtlPointerToOffset(pDbgBreakPoint + 5, AnotherDbgBreak); + RtlCopyMemory(replace + 1, &replacement, sizeof(replacement)); + RtlCopyMemory(DbgBreakPointChunk, pDbgBreakPoint, sizeof(DbgBreakPointChunk)); + RtlCopyMemory(pDbgBreakPoint, replace, sizeof(replace)); + } + } +#endif +} + +void ParaNdis_DebugCleanup(PDRIVER_OBJECT pDriverObject) +{ +#ifdef OVERRIDE_DEBUG_BREAK + if (sizeof(PVOID) == sizeof(ULONG) && pDbgBreakPoint) + { + DPrintf(0, ("Restoring original BP handler at %p", pDbgBreakPoint)); + RtlCopyMemory(pDbgBreakPoint, DbgBreakPointChunk, sizeof(DbgBreakPointChunk)); + } +#endif + BugCheckDeregisterCallback(&CallbackRecord); + WPP_CLEANUP(pDriverObject); +} + + +#define MAX_CONTEXTS 4 +#if defined(ENABLE_HISTORY_LOG) +#define MAX_HISTORY 0x40000 +#else +#define MAX_HISTORY 2 +#endif +typedef struct _tagBugCheckStaticData +{ + tBugCheckStaticDataHeader Header; + tBugCheckPerNicDataContent PerNicData[MAX_CONTEXTS]; + tBugCheckStaticDataContent Data; + tBugCheckHistoryDataEntry History[MAX_HISTORY]; +}tBugCheckStaticData; + + +typedef struct _tagBugCheckData +{ + tBugCheckStaticData StaticData; + tBugCheckDataLocation Location; +}tBugCheckData; + +static tBugCheckData BugCheckData; +static BOOLEAN bNative = TRUE; + +VOID ParaNdis_PrepareBugCheckData() +{ + BugCheckData.StaticData.Header.StaticDataVersion = PARANDIS_DEBUG_STATIC_DATA_VERSION; + BugCheckData.StaticData.Header.PerNicDataVersion = PARANDIS_DEBUG_PER_NIC_DATA_VERSION; + BugCheckData.StaticData.Header.ulMaxContexts = MAX_CONTEXTS; + BugCheckData.StaticData.Header.SizeOfPointer = sizeof(PVOID); + BugCheckData.StaticData.Header.PerNicData = (UINT_PTR)(PVOID)BugCheckData.StaticData.PerNicData; + BugCheckData.StaticData.Header.DataArea = (UINT64)&BugCheckData.StaticData.Data; + BugCheckData.StaticData.Header.DataAreaSize = sizeof(BugCheckData.StaticData.Data); + BugCheckData.StaticData.Data.HistoryDataVersion = PARANDIS_DEBUG_HISTORY_DATA_VERSION; + BugCheckData.StaticData.Data.SizeOfHistory = MAX_HISTORY; + BugCheckData.StaticData.Data.SizeOfHistoryEntry = sizeof(tBugCheckHistoryDataEntry); + BugCheckData.StaticData.Data.HistoryData = (UINT_PTR)(PVOID)BugCheckData.StaticData.History; + BugCheckData.Location.Address = (UINT64)&BugCheckData; + BugCheckData.Location.Size = sizeof(BugCheckData); +} + +void ParaNdis_DebugRegisterMiniport(PARANDIS_ADAPTER *pContext, BOOLEAN bRegister) +{ + UINT i; + NdisAcquireSpinLock(&CrashLock); + for (i = 0; i < MAX_CONTEXTS; ++i) + { + UINT64 val1 = bRegister ? 0 : (UINT_PTR)pContext; + UINT64 val2 = bRegister ? (UINT_PTR)pContext : 0; + if (BugCheckData.StaticData.PerNicData[i].Context != val1) continue; + BugCheckData.StaticData.PerNicData[i].Context = val2; + break; + } + NdisReleaseSpinLock(&CrashLock); +} + +static UINT FillDataOnBugCheck() +{ + UINT i, n = 0; + NdisGetCurrentSystemTime(&BugCheckData.StaticData.Header.qCrashTime); + for (i = 0; i < MAX_CONTEXTS; ++i) + { + tBugCheckPerNicDataContent *pSave = &BugCheckData.StaticData.PerNicData[i]; + PARANDIS_ADAPTER *p = (PARANDIS_ADAPTER *)pSave->Context; + if (!p) continue; + pSave->nofPacketsToComplete = p->NetTxPacketsToReturn; + pSave->nofReadyTxBuffers = p->nofFreeHardwareBuffers; + pSave->LastInterruptTimeStamp.QuadPart = PARANDIS_GET_LAST_INTERRUPT_TIMESTAMP(p); + pSave->LastTxCompletionTimeStamp = p->LastTxCompletionTimeStamp; + ParaNdis_CallOnBugCheck(p); + ++n; + } + return n; +} + +VOID NTAPI ParaNdis_OnBugCheck( + IN KBUGCHECK_CALLBACK_REASON Reason, + IN PKBUGCHECK_REASON_CALLBACK_RECORD Record, + IN OUT PVOID ReasonSpecificData, + IN ULONG ReasonSpecificDataLength + ) +{ + KBUGCHECK_SECONDARY_DUMP_DATA *pDump = (KBUGCHECK_SECONDARY_DUMP_DATA *)ReasonSpecificData; + if (KbCallbackSecondaryDumpData == Reason && ReasonSpecificDataLength >= sizeof(*pDump)) + { + ULONG dumpSize = sizeof(BugCheckData.Location); + if (!pDump->OutBuffer) + { + UINT nSaved; + nSaved = FillDataOnBugCheck(); + if (pDump->InBufferLength >= dumpSize) + { + pDump->OutBuffer = pDump->InBuffer; + pDump->OutBufferLength = dumpSize; + } + else + { + pDump->OutBuffer = &BugCheckData.Location; + pDump->OutBufferLength = dumpSize; + bNative = FALSE; + } + DPrintf(0, ("[%s] system buffer of %d, saving data for %d NIC", __FUNCTION__,pDump->InBufferLength, nSaved)); + DPrintf(0, ("[%s] using %s buffer", __FUNCTION__, bNative ? "native" : "own")); + } + else if (pDump->OutBuffer == pDump->InBuffer) + { + RtlCopyMemory(&pDump->Guid, &ParaNdis_CrashGuid, sizeof(pDump->Guid)); + RtlCopyMemory(pDump->InBuffer, &BugCheckData.Location, dumpSize); + pDump->OutBufferLength = dumpSize; + DPrintf(0, ("[%s] written %d to %p", __FUNCTION__, (ULONG)BugCheckData.Location.Size, (UINT_PTR)BugCheckData.Location.Address )); + DPrintf(0, ("[%s] dump data (%d) at %p", __FUNCTION__, pDump->OutBufferLength, pDump->OutBuffer)); + } + } +} + +#if defined(ENABLE_HISTORY_LOG) +void ParaNdis_DebugHistory( + PARANDIS_ADAPTER *pContext, + eHistoryLogOperation op, + PVOID pParam1, + ULONG lParam2, + ULONG lParam3, + ULONG lParam4) +{ + tBugCheckHistoryDataEntry *phe; + ULONG index = InterlockedIncrement(&BugCheckData.StaticData.Data.CurrentHistoryIndex); + index = (index - 1) % MAX_HISTORY; + phe = &BugCheckData.StaticData.History[index]; + phe->Context = (UINT_PTR)pContext; + phe->operation = op; + phe->pParam1 = (UINT_PTR)pParam1; + phe->lParam2 = lParam2; + phe->lParam3 = lParam3; + phe->lParam4 = lParam4; +#if (PARANDIS_DEBUG_HISTORY_DATA_VERSION == 1) + phe->uIRQL = KeGetCurrentIrql(); + phe->uProcessor = KeGetCurrentProcessorNumber(); +#endif + NdisGetCurrentSystemTime(&phe->TimeStamp); +} + +#endif diff --git a/drivers/network/dd/netkvm/Common/ParaNdis-Oid.c b/drivers/network/dd/netkvm/Common/ParaNdis-Oid.c new file mode 100644 index 00000000000..8d54b445dca --- /dev/null +++ b/drivers/network/dd/netkvm/Common/ParaNdis-Oid.c @@ -0,0 +1,677 @@ +/* + * This file contains NDIS OID support procedures, common for NDIS5 and NDIS6 + * + * Copyright (c) 2008-2017 Red Hat, Inc. + * + * 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 names of the copyright holders nor the names of their 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 HOLDERS 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 "ParaNdis-Oid.h" + +#ifdef WPP_EVENT_TRACING +#include "ParaNdis-Oid.tmh" +#endif +#include <sal.h> + +static const char VendorName[] = "Red Hat"; + +static UCHAR FORCEINLINE hexdigit(UCHAR nibble) +{ + UCHAR c = nibble & 0xf; + c += (c <= 9) ? 0 : 7; + c += '0'; + return c; +} + +/********************************************************** +Common implementation of copy operation when OID is set +pOid->Flags (if used) controls when the source data may be truncated or padded on copy +Parameters: + tOidDesc *pOid - descriptor of OID + PVOID pDest - buffer to receive data sent by NDIS + ULONG ulSize - size of data to copy +Return value: + SUCCESS or NDIS error code if target buffer size is wrong +Rules: + +PDEST <>OK SIZE PAYLOAD SZ +NULL any n/a any fail +BUFF any 0 any success, none copied +BUFF any SZ ==SZ success, copied SZ +BUFF !lessok SZ <SZ fail (small), none copied +BUFF !moreok SZ >SZ fail (overflow), none copied +BUFF lessok SZ <SZ success, SZ cleared, payload sz copied +BUFF moreok SZ >SZ success, copied SZ +***************************************************/ +NDIS_STATUS ParaNdis_OidSetCopy( + tOidDesc *pOid, + PVOID pDest, + ULONG ulSize) +{ + NDIS_STATUS status = NDIS_STATUS_SUCCESS; + if (!pDest) + { + status = NDIS_STATUS_INVALID_OID; + *(pOid->pBytesRead) = 0; + *(pOid->pBytesNeeded) = 0; + } + else if (ulSize) + { + if (pOid->InformationBufferLength < ulSize) + { + if (pOid->ulToDoFlags & ohfSetLessOK) + { + *(pOid->pBytesRead) = pOid->InformationBufferLength; + NdisZeroMemory(pDest, ulSize); + NdisMoveMemory(pDest, pOid->InformationBuffer, pOid->InformationBufferLength); + } + else + { + status = NDIS_STATUS_BUFFER_TOO_SHORT; + *(pOid->pBytesRead) = 0; + *(pOid->pBytesNeeded) = ulSize; + } + } + else if (pOid->InformationBufferLength == ulSize || (pOid->ulToDoFlags & ohfSetMoreOK)) + { + *(pOid->pBytesRead) = ulSize; + NdisMoveMemory(pDest, pOid->InformationBuffer, ulSize); + } + else + { + status = NDIS_STATUS_BUFFER_OVERFLOW; + *(pOid->pBytesNeeded) = ulSize; + *(pOid->pBytesRead) = 0; + } + } + else + { + *(pOid->pBytesRead) = pOid->InformationBufferLength; + } + return status; +} + + +/********************************************************** +Common handler of setting packet filter +***********************************************************/ +NDIS_STATUS ParaNdis_OnSetPacketFilter(PARANDIS_ADAPTER *pContext, tOidDesc *pOid) +{ + ULONG newValue; + NDIS_STATUS status = ParaNdis_OidSetCopy( + pOid, + &newValue, + sizeof(newValue)); + + if (newValue & ~PARANDIS_PACKET_FILTERS) + status = NDIS_STATUS_INVALID_DATA; + + if (status == NDIS_STATUS_SUCCESS) + { + pContext->PacketFilter = newValue; + DPrintf(1, ("[%s] PACKET FILTER SET TO %x", __FUNCTION__, pContext->PacketFilter)); + ParaNdis_UpdateDeviceFilters(pContext); + } + return status; +} + +void ParaNdis_FillPowerCapabilities(PNDIS_PNP_CAPABILITIES pCaps) +{ + NdisZeroMemory(pCaps, sizeof(*pCaps)); + pCaps->WakeUpCapabilities.MinMagicPacketWakeUp = NdisDeviceStateUnspecified; + pCaps->WakeUpCapabilities.MinPatternWakeUp = NdisDeviceStateUnspecified; + pCaps->WakeUpCapabilities.MinLinkChangeWakeUp = NdisDeviceStateUnspecified; +} + + +/********************************************************** +Common handler of setting multicast list +***********************************************************/ +NDIS_STATUS ParaNdis_OnOidSetMulticastList(PARANDIS_ADAPTER *pContext, tOidDesc *pOid) +{ + NDIS_STATUS status; + status = ParaNdis_SetMulticastList( + pContext, + pOid->InformationBuffer, + pOid->InformationBufferLength, + pOid->pBytesRead, + pOid->pBytesNeeded); + ParaNdis_UpdateDeviceFilters(pContext); + return status; +} + +/********************************************************** +Common helper of copy operation on GET OID +Copies data from specified location to NDIS buffer +64-bit variable will be casted to 32-bit, if specified on pOid->Flags + +Parameters: + tOidDesc *pOid - descriptor of OID + PVOID pInfo - source to copy from + ULONG ulSize - source info size +Return value: + SUCCESS or kind of failure when the dest buffer size is wrong +Comments: +pInfo must be non-NULL, otherwise error returned +ulSize may be 0, then SUCCESS returned without copy +***********************************************************/ +NDIS_STATUS ParaNdis_OidQueryCopy( + tOidDesc *pOid, + PVOID pInfo, + ULONG ulSize, + BOOLEAN bFreeInfo) +{ + NDIS_STATUS status = NDIS_STATUS_SUCCESS; + *(pOid->pBytesNeeded) = ulSize; + if (!pInfo) + { + status = NDIS_STATUS_INVALID_OID; + *(pOid->pBytesWritten) = 0; + *(pOid->pBytesNeeded) = 0; + } + else if (pOid->InformationBufferLength >= ulSize) + { + if (ulSize) NdisMoveMemory(pOid->InformationBuffer, pInfo, ulSize); + *(pOid->pBytesWritten) = ulSize; + *(pOid->pBytesNeeded) = 0; + } + else if ((pOid->ulToDoFlags & ohfQuery3264) && pOid->InformationBufferLength == sizeof(ULONG) && ulSize == sizeof(ULONG64)) + { + ULONG64 u64 = *(ULONG64 *)pInfo; + ULONG ul = (ULONG)u64; + NdisMoveMemory(pOid->InformationBuffer, &ul, sizeof(ul)); + *(pOid->pBytesWritten) = sizeof(ul); + } + else + { + status = NDIS_STATUS_BUFFER_TOO_SHORT; + *(pOid->pBytesWritten) = 0; + } + if (bFreeInfo && pInfo) + { + NdisFreeMemory(pInfo, 0, 0); + } + return status; +} + +/********************************************************** +Common handler of Oid queries +Parameters: + context + tOidDesc *pOid - filled descriptor of OID operation +Return value: + SUCCESS or kind of failure +***********************************************************/ +NDIS_STATUS ParaNdis_OidQueryCommon(PARANDIS_ADAPTER *pContext, tOidDesc *pOid) +{ + NDIS_STATUS status = NDIS_STATUS_SUCCESS; + PVOID pInfo = NULL; + ULONG ulSize = 0; + BOOLEAN bFreeInfo = FALSE; + union _tagtemp + { + NDIS_MEDIUM Medium; + ULONG64 ul64; + ULONG ul; + USHORT us; + NDIS_PNP_CAPABILITIES PMCaps; + } u; +#if defined(_MSC_VER) + #define CONCATFIELD(object, field) object.##field +#else + #define CONCATFIELD(object, field) object.field +#endif +#define SETINFO(field, value) pInfo = CONCATFIELD(&u, field); ulSize = sizeof(CONCATFIELD(u, field)); CONCATFIELD(u, field) = (value) + switch (pOid->Oid) + { + case OID_GEN_SUPPORTED_LIST: + ParaNdis_GetSupportedOid(&pInfo, &ulSize); + break; + case OID_GEN_HARDWARE_STATUS: + SETINFO(ul, NdisHardwareStatusReady); + break; + case OID_GEN_MEDIA_SUPPORTED: + __fallthrough; + case OID_GEN_MEDIA_IN_USE: + SETINFO(Medium, NdisMedium802_3); + break; + case OID_GEN_MAXIMUM_LOOKAHEAD: + SETINFO(ul, pContext->MaxPacketSize.nMaxFullSizeOS); + break; + case OID_GEN_MAXIMUM_FRAME_SIZE: + SETINFO(ul, pContext->MaxPacketSize.nMaxDataSize); + break; + case OID_GEN_TRANSMIT_BUFFER_SPACE: + SETINFO(ul, pContext->MaxPacketSize.nMaxFullSizeOS * pContext->nofFreeTxDescriptors); + break; + case OID_GEN_RECEIVE_BUFFER_SPACE: + SETINFO(ul, pContext->MaxPacketSize.nMaxFullSizeOS * pContext->NetMaxReceiveBuffers); + break; + case OID_GEN_RECEIVE_BLOCK_SIZE: + __fallthrough; + case OID_GEN_TRANSMIT_BLOCK_SIZE: + __fallthrough; + case OID_GEN_MAXIMUM_TOTAL_SIZE: + SETINFO(ul, pContext->MaxPacketSize.nMaxFullSizeOS); + break; + case OID_GEN_TRANSMIT_QUEUE_LENGTH: + // TODO: this is not completely correct, but only if + // the TX queue is not full + SETINFO(ul, pContext->maxFreeTxDescriptors - pContext->nofFreeTxDescriptors); + break; + case OID_GEN_VENDOR_ID: + SETINFO(ul, 0x00ffffff); + break; + case OID_GEN_VENDOR_DESCRIPTION: + pInfo = (PVOID)VendorName; + ulSize = sizeof(VendorName); + break; + + case OID_GEN_VENDOR_DRIVER_VERSION: + SETINFO(ul, (NDIS_MINIPORT_MAJOR_VERSION << 16) | NDIS_MINIPORT_MINOR_VERSION); + break; + case OID_GEN_CURRENT_PACKET_FILTER: + pInfo = &pContext->PacketFilter; + ulSize = sizeof(pContext->PacketFilter); + break; + case OID_GEN_DRIVER_VERSION: + SETINFO(us, ((NDIS_MINIPORT_MAJOR_VERSION << 8) | NDIS_MINIPORT_MINOR_VERSION)); + break; + case OID_GEN_MAC_OPTIONS: + { + ULONG options = NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA | + NDIS_MAC_OPTION_TRANSFERS_NOT_PEND | + NDIS_MAC_OPTION_NO_LOOPBACK; + if (IsPrioritySupported(pContext)) + options |= NDIS_MAC_OPTION_8021P_PRIORITY; + if (IsVlanSupported(pContext)) + options |= NDIS_MAC_OPTION_8021Q_VLAN; + SETINFO(ul, options); + } + break; + case OID_GEN_MEDIA_CONNECT_STATUS: + SETINFO(ul, pContext->bConnected ? NdisMediaStateConnected : NdisMediaStateDisconnected); + //NdisMediaStateConnected: + break; + case OID_GEN_MAXIMUM_SEND_PACKETS: + // NDIS ignores it for deserialized drivers + SETINFO(ul,pContext->nofFreeTxDescriptors); + break; + case OID_802_3_PERMANENT_ADDRESS: + pInfo = pContext->PermanentMacAddress; + ulSize = sizeof(pContext->PermanentMacAddress); + break; + case OID_802_3_CURRENT_ADDRESS: + pInfo = pContext->CurrentMacAddress; + ulSize = sizeof(pContext->CurrentMacAddress); + break; + case OID_PNP_QUERY_POWER: + // size if 0, just to indicate success + pInfo = &status; + break; + case OID_GEN_DIRECTED_BYTES_XMIT: + SETINFO(ul64, pContext->Statistics.ifHCOutUcastOctets); + break; + case OID_GEN_DIRECTED_FRAMES_XMIT: + SETINFO(ul64, pContext->Statistics.ifHCOutUcastPkts); + break; + case OID_GEN_MULTICAST_BYTES_XMIT: + SETINFO(ul64, pContext->Statistics.ifHCOutMulticastOctets); + break; + case OID_GEN_MULTICAST_FRAMES_XMIT: + SETINFO(ul64, pContext->Statistics.ifHCOutMulticastPkts); + break; + case OID_GEN_BROADCAST_BYTES_XMIT: + SETINFO(ul64, pContext->Statistics.ifHCOutBroadcastOctets); + break; + case OID_GEN_BROADCAST_FRAMES_XMIT: + SETINFO(ul64, pContext->Statistics.ifHCOutBroadcastPkts); + break; + case OID_GEN_DIRECTED_BYTES_RCV: + SETINFO(ul64, pContext->Statistics.ifHCInUcastOctets); + break; + case OID_GEN_DIRECTED_FRAMES_RCV: + SETINFO(ul64, pContext->Statistics.ifHCInUcastPkts); + break; + case OID_GEN_MULTICAST_BYTES_RCV: + SETINFO(ul64, pContext->Statistics.ifHCInMulticastOctets); + break; + case OID_GEN_MULTICAST_FRAMES_RCV: + SETINFO(ul64, pContext->Statistics.ifHCInMulticastPkts); + break; + case OID_GEN_BROADCAST_BYTES_RCV: + SETINFO(ul64, pContext->Statistics.ifHCInBroadcastOctets); + break; + case OID_GEN_BROADCAST_FRAMES_RCV: + SETINFO(ul64, pContext->Statistics.ifHCInBroadcastPkts); + break; + case OID_GEN_XMIT_OK: + SETINFO(ul64, + pContext->Statistics.ifHCOutUcastPkts + + pContext->Statistics.ifHCOutMulticastPkts + + pContext->Statistics.ifHCOutBroadcastPkts); + break; + case OID_GEN_RCV_OK: + SETINFO(ul64, + pContext->Statistics.ifHCInUcastPkts + + pContext->Statistics.ifHCInMulticastPkts + + pContext->Statistics.ifHCInBroadcastPkts); + DPrintf(4, ("[%s] Total frames %I64u", __FUNCTION__, u.ul64)); + break; + case OID_GEN_XMIT_ERROR: + SETINFO(ul64, pContext->Statistics.ifOutErrors ); + break; + case OID_GEN_RCV_ERROR: + __fallthrough; + case OID_GEN_RCV_NO_BUFFER: + __fallthrough; + case OID_802_3_RCV_OVERRUN: + __fallthrough; + case OID_GEN_RCV_CRC_ERROR: + __fallthrough; + case OID_802_3_RCV_ERROR_ALIGNMENT: + __fallthrough; + case OID_802_3_XMIT_UNDERRUN: + __fallthrough; + case OID_802_3_XMIT_ONE_COLLISION: + __fallthrough; + case OID_802_3_XMIT_DEFERRED: + __fallthrough; + case OID_802_3_XMIT_MAX_COLLISIONS: + __fallthrough; + case OID_802_3_XMIT_MORE_COLLISIONS: + __fallthrough; + case OID_802_3_XMIT_HEARTBEAT_FAILURE: + __fallthrough; + case OID_802_3_XMIT_TIMES_CRS_LOST: + __fallthrough; + case OID_802_3_XMIT_LATE_COLLISIONS: + SETINFO(ul64, 0); + break; + case OID_802_3_MULTICAST_LIST: + pInfo = pContext->MulticastData.MulticastList; + ulSize = pContext->MulticastData.nofMulticastEntries * ETH_LENGTH_OF_ADDRESS; + break; + case OID_802_3_MAXIMUM_LIST_SIZE: + SETINFO(ul, PARANDIS_MULTICAST_LIST_SIZE); + break; + case OID_PNP_CAPABILITIES: + pInfo = &u.PMCaps; + ulSize = sizeof(u.PMCaps); + ParaNdis_FillPowerCapabilities(&u.PMCaps); + break; + case OID_802_3_MAC_OPTIONS: + SETINFO(ul, 0); + break; + case OID_GEN_VLAN_ID: + SETINFO(ul, pContext->VlanId); + if (!IsVlanSupported(pContext)) + status = NDIS_STATUS_NOT_SUPPORTED; + break; + case OID_GEN_CURRENT_LOOKAHEAD: + if (!pContext->DummyLookAhead) pContext->DummyLookAhead = pContext->MaxPacketSize.nMaxFullSizeOS; + pInfo = &pContext->DummyLookAhead; + ulSize = sizeof(pContext->DummyLookAhead); + break; + case OID_PNP_ENABLE_WAKE_UP: + SETINFO(ul, pContext->ulEnableWakeup); + break; + default: + status = NDIS_STATUS_NOT_SUPPORTED; + break; + } + + if (status == NDIS_STATUS_SUCCESS) + { + status = ParaNdis_OidQueryCopy(pOid, pInfo, ulSize, bFreeInfo); + } + + return status; +} + + +/********************************************************** + Just gets OID name +***********************************************************/ +const char *ParaNdis_OidName(NDIS_OID oid) +{ +#undef MAKECASE +#define MAKECASE(id) case id: return #id; + switch (oid) + { + MAKECASE(OID_GEN_SUPPORTED_LIST) + MAKECASE(OID_GEN_HARDWARE_STATUS) + MAKECASE(OID_GEN_MEDIA_SUPPORTED) + MAKECASE(OID_GEN_MEDIA_IN_USE) + MAKECASE(OID_GEN_MAXIMUM_LOOKAHEAD) + MAKECASE(OID_GEN_MAXIMUM_FRAME_SIZE) + MAKECASE(OID_GEN_LINK_SPEED) + MAKECASE(OID_GEN_TRANSMIT_BUFFER_SPACE) + MAKECASE(OID_GEN_RECEIVE_BUFFER_SPACE) + MAKECASE(OID_GEN_TRANSMIT_BLOCK_SIZE) + MAKECASE(OID_GEN_RECEIVE_BLOCK_SIZE) + MAKECASE(OID_GEN_VENDOR_ID) + MAKECASE(OID_GEN_VENDOR_DESCRIPTION) + MAKECASE(OID_GEN_CURRENT_PACKET_FILTER) + MAKECASE(OID_GEN_CURRENT_LOOKAHEAD) + MAKECASE(OID_GEN_DRIVER_VERSION) + MAKECASE(OID_GEN_MAXIMUM_TOTAL_SIZE) + MAKECASE(OID_GEN_PROTOCOL_OPTIONS) + MAKECASE(OID_GEN_MAC_OPTIONS) + MAKECASE(OID_GEN_MEDIA_CONNECT_STATUS) + MAKECASE(OID_GEN_MAXIMUM_SEND_PACKETS) + MAKECASE(OID_GEN_VENDOR_DRIVER_VERSION) + MAKECASE(OID_GEN_SUPPORTED_GUIDS) + MAKECASE(OID_GEN_TRANSPORT_HEADER_OFFSET) + MAKECASE(OID_GEN_MEDIA_CAPABILITIES) + MAKECASE(OID_GEN_PHYSICAL_MEDIUM) + MAKECASE(OID_GEN_XMIT_OK) + MAKECASE(OID_GEN_RCV_OK) + MAKECASE(OID_GEN_XMIT_ERROR) + MAKECASE(OID_GEN_RCV_ERROR) + MAKECASE(OID_GEN_RCV_NO_BUFFER) + MAKECASE(OID_GEN_DIRECTED_BYTES_XMIT) + MAKECASE(OID_GEN_DIRECTED_FRAMES_XMIT) + MAKECASE(OID_GEN_MULTICAST_BYTES_XMIT) + MAKECASE(OID_GEN_MULTICAST_FRAMES_XMIT) + MAKECASE(OID_GEN_BROADCAST_BYTES_XMIT) + MAKECASE(OID_GEN_BROADCAST_FRAMES_XMIT) + MAKECASE(OID_GEN_DIRECTED_BYTES_RCV) + MAKECASE(OID_GEN_DIRECTED_FRAMES_RCV) + MAKECASE(OID_GEN_MULTICAST_BYTES_RCV) + MAKECASE(OID_GEN_MULTICAST_FRAMES_RCV) + MAKECASE(OID_GEN_BROADCAST_BYTES_RCV) + MAKECASE(OID_GEN_BROADCAST_FRAMES_RCV) + MAKECASE(OID_GEN_RCV_CRC_ERROR) + MAKECASE(OID_GEN_TRANSMIT_QUEUE_LENGTH) + MAKECASE(OID_GEN_GET_TIME_CAPS) + MAKECASE(OID_GEN_GET_NETCARD_TIME) + MAKECASE(OID_GEN_NETCARD_LOAD) + MAKECASE(OID_GEN_DEVICE_PROFILE) + MAKECASE(OID_GEN_INIT_TIME_MS) + MAKECASE(OID_GEN_RESET_COUNTS) + MAKECASE(OID_GEN_MEDIA_SENSE_COUNTS) + MAKECASE(OID_GEN_VLAN_ID) + MAKECASE(OID_PNP_CAPABILITIES) + MAKECASE(OID_PNP_SET_POWER) + MAKECASE(OID_PNP_QUERY_POWER) + MAKECASE(OID_PNP_ADD_WAKE_UP_PATTERN) + MAKECASE(OID_PNP_REMOVE_WAKE_UP_PATTERN) + MAKECASE(OID_PNP_ENABLE_WAKE_UP) + MAKECASE(OID_802_3_PERMANENT_ADDRESS) + MAKECASE(OID_802_3_CURRENT_ADDRESS) + MAKECASE(OID_802_3_MULTICAST_LIST) + MAKECASE(OID_802_3_MAXIMUM_LIST_SIZE) + MAKECASE(OID_802_3_MAC_OPTIONS) + MAKECASE(OID_802_3_RCV_ERROR_ALIGNMENT) + MAKECASE(OID_802_3_XMIT_ONE_COLLISION) + MAKECASE(OID_802_3_XMIT_MORE_COLLISIONS) + MAKECASE(OID_802_3_XMIT_DEFERRED) + MAKECASE(OID_802_3_XMIT_MAX_COLLISIONS) + MAKECASE(OID_802_3_RCV_OVERRUN) + MAKECASE(OID_802_3_XMIT_UNDERRUN) + MAKECASE(OID_802_3_XMIT_HEARTBEAT_FAILURE) + MAKECASE(OID_802_3_XMIT_TIMES_CRS_LOST) + MAKECASE(OID_802_3_XMIT_LATE_COLLISIONS) + MAKECASE(OID_GEN_MACHINE_NAME) + MAKECASE(OID_TCP_TASK_OFFLOAD) + MAKECASE(OID_TCP_OFFLOAD_PARAMETERS) + MAKECASE(OID_OFFLOAD_ENCAPSULATION) + MAKECASE(OID_IP4_OFFLOAD_STATS) + MAKECASE(OID_IP6_OFFLOAD_STATS) + default: + { + static UCHAR buffer[9]; + UINT i; + for (i = 0; i < 8; ++i) + { + UCHAR nibble = (UCHAR)((oid >> (28 - i * 4)) & 0xf); + buffer[i] = hexdigit(nibble); + } + return (char *)buffer; + } + } +} + +/********************************************************** +Checker of valid size of provided wake-up patter +Return value: SUCCESS or kind of failure where the buffer is wrong +***********************************************************/ +static NDIS_STATUS ValidateWakeupPattern(PNDIS_PM_PACKET_PATTERN p, PULONG pValidSize) +{ + NDIS_STATUS status = NDIS_STATUS_BUFFER_TOO_SHORT; + + if (*pValidSize < sizeof(*p)) + { + *pValidSize = sizeof(*p); + } + else + { + ULONG ul = p->PatternOffset + p->PatternSize; + if (*pValidSize >= ul) status = NDIS_STATUS_SUCCESS; + *pValidSize = ul; + DPrintf(2, ("[%s] pattern of %d at %d, mask %d (%s)", + __FUNCTION__, p->PatternSize, p->PatternOffset, p->MaskSize, + status == NDIS_STATUS_SUCCESS ? "OK" : "Fail")); + } + return status; +} + + +/********************************************************** +Common handler of wake-up pattern addition +***********************************************************/ +NDIS_STATUS ParaNdis_OnAddWakeupPattern(PARANDIS_ADAPTER *pContext, tOidDesc *pOid) +{ + NDIS_STATUS status; + PNDIS_PM_PACKET_PATTERN pPmPattern = (PNDIS_PM_PACKET_PATTERN) pOid->InformationBuffer; + ULONG ulValidSize = pOid->InformationBufferLength; + status = ValidateWakeupPattern(pPmPattern, &ulValidSize); + if (status == NDIS_STATUS_SUCCESS) + { + *pOid->pBytesRead = ulValidSize; + } + else + { + *pOid->pBytesRead = 0; + *pOid->pBytesNeeded = ulValidSize; + } + // TODO: Apply + return status; +} + +/********************************************************** +Common handler of wake-up pattern removal +***********************************************************/ +NDIS_STATUS ParaNdis_OnRemoveWakeupPattern(PARANDIS_ADAPTER *pContext, tOidDesc *pOid) +{ + NDIS_STATUS status; + PNDIS_PM_PACKET_PATTERN pPmPattern = (PNDIS_PM_PACKET_PATTERN) pOid->InformationBuffer; + ULONG ulValidSize = pOid->InformationBufferLength; + status = ValidateWakeupPattern(pPmPattern, &ulValidSize); + if (status == NDIS_STATUS_SUCCESS) + { + *pOid->pBytesRead = ulValidSize; + } + else + { + *pOid->pBytesRead = 0; + *pOid->pBytesNeeded = ulValidSize; + } + return status; +} + +/********************************************************** +Common handler of wake-up enabling upon standby +***********************************************************/ +NDIS_STATUS ParaNdis_OnEnableWakeup(PARANDIS_ADAPTER *pContext, tOidDesc *pOid) +{ + NDIS_STATUS status = ParaNdis_OidSetCopy(pOid, &pContext->ulEnableWakeup, sizeof(pContext->ulEnableWakeup)); + if (status == NDIS_STATUS_SUCCESS) + { + DPrintf(0, ("[%s] new value %lX", __FUNCTION__, pContext->ulEnableWakeup)); + } + return status; +} + +/********************************************************** +Dummy implementation +***********************************************************/ +NDIS_STATUS ParaNdis_OnSetLookahead(PARANDIS_ADAPTER *pContext, tOidDesc *pOid) +{ + return ParaNdis_OidSetCopy(pOid, &pContext->DummyLookAhead, sizeof(pContext->DummyLookAhead)); +} + +NDIS_STATUS ParaNdis_OnSetVlanId(PARANDIS_ADAPTER *pContext, tOidDesc *pOid) +{ + NDIS_STATUS status = NDIS_STATUS_NOT_SUPPORTED; + if (IsVlanSupported(pContext)) + { + status = ParaNdis_OidSetCopy(pOid, &pContext->VlanId, sizeof(pContext->VlanId)); + pContext->VlanId &= 0xfff; + DPrintf(0, ("[%s] new value %d on MAC %X", __FUNCTION__, pContext->VlanId, pContext->CurrentMacAddress[5])); + ParaNdis_DeviceFiltersUpdateVlanId(pContext); + } + return status; +} + +/********************************************************** +Retrieves support rules for specific OID +***********************************************************/ +void ParaNdis_GetOidSupportRules(NDIS_OID oid, tOidWhatToDo *pRule, const tOidWhatToDo *Table) +{ + static const tOidWhatToDo defaultRule = { 0, 0, 0, 0, 0, NULL, "Unknown OID" }; + UINT i; + *pRule = defaultRule; + pRule->oid = oid; + + for (i = 0; Table[i].oid != 0; ++i) + { + if (Table[i].oid == oid) + { + *pRule = Table[i]; + break; + } + } + pRule->name = ParaNdis_OidName(oid); +} diff --git a/drivers/network/dd/netkvm/Common/ParaNdis-Oid.h b/drivers/network/dd/netkvm/Common/ParaNdis-Oid.h new file mode 100644 index 00000000000..aac453ab97c --- /dev/null +++ b/drivers/network/dd/netkvm/Common/ParaNdis-Oid.h @@ -0,0 +1,104 @@ +/* + * This file contains common for NDIS5/NDIS6 definition, + * related to OID support + * + * Copyright (c) 2008-2017 Red Hat, Inc. + * + * 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 names of the copyright holders nor the names of their 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 HOLDERS 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. + */ +#ifndef PARANDIS_COMMON_OID_H +#define PARANDIS_COMMON_OID_H + +#include "ndis56common.h" + +/********************************************************** +Wrapper for all the data, related to any OID request +***********************************************************/ +typedef struct _tagOidDesc +{ + NDIS_OID Oid; // oid code + ULONG ulToDoFlags; // combination of eOidHelperFlags + PVOID InformationBuffer; // buffer received from NDIS + UINT InformationBufferLength; // its length + PUINT pBytesWritten; // OUT for query/method + PUINT pBytesNeeded; // OUT for query/set/method when length of buffer is wrong + PUINT pBytesRead; // OUT for set/method + PVOID Reserved; // Reserved for pending requests +} tOidDesc; + +typedef NDIS_STATUS (*OIDHANDLERPROC)(PARANDIS_ADAPTER *pContext, tOidDesc *pOid); + +typedef struct _tagOidWhatToDo +{ + NDIS_OID oid; // oid number + int nEntryLevel; // do print on entry level + int nExitFailLevel; // do print on exit if failed + int nExitOKLevel; // do print on exit if OK + UINT Flags; + OIDHANDLERPROC OidSetProc; // procedure to call on SET + const char *name; // printable name +}tOidWhatToDo; + + +typedef enum _tageOidHelperFlags { + ohfQuery = 1, // can be queried + ohfSet = 2, // can be set + ohfQuerySet = ohfQuery | ohfSet, + ohfQueryStatOnly = 4, // redirect query stat to query + ohfQueryStat = ohfQueryStatOnly | ohfQuery, + ohfQuery3264 = 8 | ohfQuery, // convert 64 to 32 on query + ohfQueryStat3264 = 8 | ohfQueryStat, // convert 64 to 32 on query stat + ohfSetLessOK = 16, // on set: if buffer is smaller, cleanup and copy + ohfSetMoreOK = 32 // on set: if buffer is larger, copy anyway +} eOidHelperFlags; + + + + +/********************************************************** +Common procedures related to OID support +***********************************************************/ +NDIS_STATUS ParaNdis_OidQueryCommon(PARANDIS_ADAPTER *pContext, tOidDesc *pOid); +NDIS_STATUS ParaNdis_OidQueryCopy(tOidDesc *pOid, PVOID pInfo, ULONG ulSize, BOOLEAN bFreeInfo); +static NDIS_STATUS ParaNdis_OidQuery(PARANDIS_ADAPTER *pContext, tOidDesc *pOid); +NDIS_STATUS ParaNdis_OnOidSetMulticastList(PARANDIS_ADAPTER *pContext, tOidDesc *pOid); +NDIS_STATUS ParaNdis_OnSetPacketFilter(PARANDIS_ADAPTER *pContext, tOidDesc *pOid); +NDIS_STATUS ParaNdis_OnAddWakeupPattern(PARANDIS_ADAPTER *pContext, tOidDesc *pOid); +NDIS_STATUS ParaNdis_OnRemoveWakeupPattern(PARANDIS_ADAPTER *pContext, tOidDesc *pOid); +NDIS_STATUS ParaNdis_OnEnableWakeup(PARANDIS_ADAPTER *pContext, tOidDesc *pOid); +NDIS_STATUS ParaNdis_OnSetLookahead(PARANDIS_ADAPTER *pContext, tOidDesc *pOid); +NDIS_STATUS ParaNdis_OnSetVlanId(PARANDIS_ADAPTER *pContext, tOidDesc *pOid); +NDIS_STATUS ParaNdis_OidSetCopy(tOidDesc *pOid, PVOID pDest, ULONG ulSize); +void ParaNdis_FillPowerCapabilities(PNDIS_PNP_CAPABILITIES pCaps); +void ParaNdis_GetOidSupportRules(NDIS_OID oid, tOidWhatToDo *pRule, const tOidWhatToDo *Table); + + +const char *ParaNdis_OidName(NDIS_OID oid); +/********************************************************** +Procedures to be implemented in NDIS5/NDIS6 specific modules +***********************************************************/ +void ParaNdis_GetSupportedOid(PVOID *pOidsArray, PULONG pLength); +NDIS_STATUS ParaNdis_OnSetPower(PARANDIS_ADAPTER *pContext, tOidDesc *pOid); + +#endif diff --git a/drivers/network/dd/netkvm/Common/ParaNdis-VirtIO.c b/drivers/network/dd/netkvm/Common/ParaNdis-VirtIO.c new file mode 100644 index 00000000000..a1525502696 --- /dev/null +++ b/drivers/network/dd/netkvm/Common/ParaNdis-VirtIO.c @@ -0,0 +1,389 @@ +/* + * This file contains NDIS driver VirtIO callbacks + * + * Copyright (c) 2008-2017 Red Hat, Inc. + * + * 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 names of the copyright holders nor the names of their 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 HOLDERS 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 "ndis56common.h" + +///////////////////////////////////////////////////////////////////////////////////// +// +// ReadVirtIODeviceRegister\WriteVirtIODeviceRegister +// NDIS specific implementation of the IO and memory space read\write +// +// The lower 64k of memory is never mapped so we can use the same routines +// for both port I/O and memory access and use the address alone to decide +// which space to use. +///////////////////////////////////////////////////////////////////////////////////// + +#define PORT_MASK 0xFFFF + +static u32 ReadVirtIODeviceRegister(ULONG_PTR ulRegister) +{ + ULONG ulValue; + + if (ulRegister & ~PORT_MASK) { + NdisReadRegisterUlong(ulRegister, &ulValue); + } else { + NdisRawReadPortUlong(ulRegister, &ulValue); + } + + DPrintf(6, ("[%s]R[%x]=%x", __FUNCTION__, (ULONG)ulRegister, ulValue)); + return ulValue; +} + +static void WriteVirtIODeviceRegister(ULONG_PTR ulRegister, u32 ulValue) +{ + DPrintf(6, ("[%s]R[%x]=%x", __FUNCTION__, (ULONG)ulRegister, ulValue)); + + if (ulRegister & ~PORT_MASK) { + NdisWriteRegisterUlong((PULONG)ulRegister, ulValue); + } else { + NdisRawWritePortUlong(ulRegister, ulValue); + } +} + +static u8 ReadVirtIODeviceByte(ULONG_PTR ulRegister) +{ + u8 bValue; + + if (ulRegister & ~PORT_MASK) { + NdisReadRegisterUchar(ulRegister, &bValue); + } else { + NdisRawReadPortUchar(ulRegister, &bValue); + } + + DPrintf(6, ("[%s]R[%x]=%x", __FUNCTION__, (ULONG)ulRegister, bValue)); + return bValue; +} + +static void WriteVirtIODeviceByte(ULONG_PTR ulRegister, u8 bValue) +{ + DPrintf(6, ("[%s]R[%x]=%x", __FUNCTION__, (ULONG)ulRegister, bValue)); + + if (ulRegister & ~PORT_MASK) { + NdisWriteRegisterUchar((PUCHAR)ulRegister, bValue); + } else { + NdisRawWritePortUchar(ulRegister, bValue); + } +} + +static u16 ReadVirtIODeviceWord(ULONG_PTR ulRegister) +{ + u16 wValue; + + if (ulRegister & ~PORT_MASK) { + NdisReadRegisterUshort(ulRegister, &wValue); + } else { + NdisRawReadPortUshort(ulRegister, &wValue); + } + + DPrintf(6, ("[%s]R[%x]=%x\n", __FUNCTION__, (ULONG)ulRegister, wValue)); + return wValue; +} + +static void WriteVirtIODeviceWord(ULONG_PTR ulRegister, u16 wValue) +{ +#if 1 + if (ulRegister & ~PORT_MASK) { + NdisWriteRegisterUshort((PUSHORT)ulRegister, wValue); + } else { + NdisRawWritePortUshort(ulRegister, wValue); + } +#else + // test only to cause long TX waiting queue of NDIS packets + // to recognize it and request for reset via Hang handler + static int nCounterToFail = 0; + static const int StartFail = 200, StopFail = 600; + BOOLEAN bFail = FALSE; + DPrintf(6, ("%s> R[%x] = %x\n", __FUNCTION__, (ULONG)ulRegister, wValue)); + if ((ulRegister & 0x1F) == 0x10) + { + nCounterToFail++; + bFail = nCounterToFail >= StartFail && nCounterToFail < StopFail; + } + if (!bFail) NdisRawWritePortUshort(ulRegister, wValue); + else + { + DPrintf(0, ("%s> FAILING R[%x] = %x\n", __FUNCTION__, (ULONG)ulRegister, wValue)); + } +#endif +} + +static void *mem_alloc_contiguous_pages(void *context, size_t size) +{ + PARANDIS_ADAPTER *pContext = (PARANDIS_ADAPTER *)context; + PVOID retVal = NULL; + ULONG i; + + /* find the first unused memory range of the requested size */ + for (i = 0; i < MAX_NUM_OF_QUEUES; i++) { + if (pContext->SharedMemoryRanges[i].pBase != NULL && + pContext->SharedMemoryRanges[i].bUsed == FALSE && + pContext->SharedMemoryRanges[i].uLength == (ULONG)size) { + retVal = pContext->SharedMemoryRanges[i].pBase; + pContext->SharedMemoryRanges[i].bUsed = TRUE; + break; + } + } + + if (!retVal) { + /* find the first null memory range descriptor and allocate */ + for (i = 0; i < MAX_NUM_OF_QUEUES; i++) { + if (pContext->SharedMemoryRanges[i].pBase == NULL) { + break; + } + } + if (i < MAX_NUM_OF_QUEUES) { + NdisMAllocateSharedMemory( + pContext->MiniportHandle, + (ULONG)size, + TRUE /* Cached */, + &pContext->SharedMemoryRanges[i].pBase, + &pContext->SharedMemoryRanges[i].BasePA); + retVal = pContext->SharedMemoryRanges[i].pBase; + if (retVal) { + NdisZeroMemory(retVal, size); + pContext->SharedMemoryRanges[i].uLength = (ULONG)size; + pContext->SharedMemoryRanges[i].bUsed = TRUE; + } + } + } + + if (retVal) { + DPrintf(6, ("[%s] returning %p, size %x\n", __FUNCTION__, retVal, (ULONG)size)); + } else { + DPrintf(0, ("[%s] failed to allocate size %x\n", __FUNCTION__, (ULONG)size)); + } + return retVal; +} + +static void mem_free_contiguous_pages(void *context, void *virt) +{ + PARANDIS_ADAPTER *pContext = (PARANDIS_ADAPTER *)context; + ULONG i; + + for (i = 0; i < MAX_NUM_OF_QUEUES; i++) { + if (pContext->SharedMemoryRanges[i].pBase == virt) { + pContext->SharedMemoryRanges[i].bUsed = FALSE; + break; + } + } + + if (i < MAX_NUM_OF_QUEUES) { + DPrintf(6, ("[%s] freed %p at index %d\n", __FUNCTION__, virt, i)); + } else { + DPrintf(0, ("[%s] failed to free %p\n", __FUNCTION__, virt)); + } +} + +static ULONGLONG mem_get_physical_address(void *context, void *virt) +{ + PARANDIS_ADAPTER *pContext = (PARANDIS_ADAPTER *)context; + ULONG_PTR uAddr = (ULONG_PTR)virt; + ULONG i; + + for (i = 0; i < MAX_NUM_OF_QUEUES; i++) { + ULONG_PTR uBase = (ULONG_PTR)pContext->SharedMemoryRanges[i].pBase; + if (uAddr >= uBase && uAddr < (uBase + pContext->SharedMemoryRanges[i].uLength)) { + ULONGLONG retVal = pContext->SharedMemoryRanges[i].BasePA.QuadPart + (uAddr - uBase); + + DPrintf(6, ("[%s] translated %p to %I64X\n", __FUNCTION__, virt, retVal)); + return retVal; + } + } + + DPrintf(0, ("[%s] failed to translate %p\n", __FUNCTION__, virt)); + return 0; +} + +static void *mem_alloc_nonpaged_block(void *context, size_t size) +{ + PVOID retVal; + + if (NdisAllocateMemoryWithTag( + &retVal, + (UINT)size, + PARANDIS_MEMORY_TAG) != NDIS_STATUS_SUCCESS) { + retVal = NULL; + } + + if (retVal) { + NdisZeroMemory(retVal, size); + DPrintf(6, ("[%s] returning %p, len %x\n", __FUNCTION__, retVal, (ULONG)size)); + } else { + DPrintf(0, ("[%s] failed to allocate size %x\n", __FUNCTION__, (ULONG)size)); + } + return retVal; +} + +static void mem_free_nonpaged_block(void *context, void *addr) +{ + UNREFERENCED_PARAMETER(context); + + NdisFreeMemory(addr, 0, 0); + DPrintf(6, ("[%s] freed %p\n", __FUNCTION__, addr)); +} + +static int PCIReadConfig(PPARANDIS_ADAPTER pContext, + int where, + void *buffer, + size_t length) +{ + ULONG read; + + read = NdisReadPciSlotInformation( + pContext->MiniportHandle, + 0 /* SlotNumber */, + where, + buffer, + (ULONG)length); + + if (read == length) { + DPrintf(6, ("[%s] read %d bytes at %d\n", __FUNCTION__, read, where)); + return 0; + } else { + DPrintf(0, ("[%s] failed to read %d bytes at %d\n", __FUNCTION__, read, where)); + return -1; + } +} + +static int pci_read_config_byte(void *context, int where, u8 *bVal) +{ + return PCIReadConfig((PPARANDIS_ADAPTER)context, where, bVal, sizeof(*bVal)); +} + +static int pci_read_config_word(void *context, int where, u16 *wVal) +{ + return PCIReadConfig((PPARANDIS_ADAPTER)context, where, wVal, sizeof(*wVal)); +} + +static int pci_read_config_dword(void *context, int where, u32 *dwVal) +{ + return PCIReadConfig((PPARANDIS_ADAPTER)context, where, dwVal, sizeof(*dwVal)); +} + +static size_t pci_get_resource_len(void *context, int bar) +{ + PARANDIS_ADAPTER *pContext = (PARANDIS_ADAPTER *)context; + + if (bar < PCI_TYPE0_ADDRESSES) { + return pContext->AdapterResources.PciBars[bar].uLength; + } + + DPrintf(0, ("[%s] queried invalid BAR %d\n", __FUNCTION__, bar)); + return 0; +} + +static void *pci_map_address_range(void *context, int bar, size_t offset, size_t maxlen) +{ + PARANDIS_ADAPTER *pContext = (PARANDIS_ADAPTER *)context; + + if (bar < PCI_TYPE0_ADDRESSES) { + tBusResource *pRes = &pContext->AdapterResources.PciBars[bar]; + if (pRes->pBase == NULL) { + /* BAR not mapped yet */ + if (pRes->bPortSpace) { + if (NDIS_STATUS_SUCCESS == NdisMRegisterIoPortRange( + &pRes->pBase, + pContext->MiniportHandle, + pRes->BasePA.LowPart, + pRes->uLength)) { + DPrintf(6, ("[%s] mapped port BAR at %x\n", __FUNCTION__, pRes->BasePA.LowPart)); + } else { + pRes->pBase = NULL; + DPrintf(0, ("[%s] failed to map port BAR at %x\n", __FUNCTION__, pRes->BasePA.LowPart)); + } + } else { + if (NDIS_STATUS_SUCCESS == NdisMMapIoSpace( + &pRes->pBase, + pContext->MiniportHandle, + pRes->BasePA, + pRes->uLength)) { + DPrintf(6, ("[%s] mapped memory BAR at %I64x\n", __FUNCTION__, pRes->BasePA.QuadPart)); + } else { + pRes->pBase = NULL; + DPrintf(0, ("[%s] failed to map memory BAR at %I64x\n", __FUNCTION__, pRes->BasePA.QuadPart)); + } + } + } + if (pRes->pBase != NULL && offset < pRes->uLength) { + if (pRes->bPortSpace) { ... 9139 lines suppressed ...

5 years, 1 month

[reactos] 01/01: [NTGDI][FREETYPE] Return non-zero gm.gmBlackBoxX/Y (#2643)

by Katayama Hirofumi MZ

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=52fb8c1a8d1d1ef2ddb46… commit 52fb8c1a8d1d1ef2ddb46c017b461011b26188ee Author: Katayama Hirofumi MZ <katayama.hirofumi.mz(a)gmail.com> AuthorDate: Thu Apr 23 22:02:41 2020 +0900 Commit: GitHub <noreply(a)github.com> CommitDate: Thu Apr 23 22:02:41 2020 +0900 [NTGDI][FREETYPE] Return non-zero gm.gmBlackBoxX/Y (#2643) In return of GetGlyphOutline function call, gm.gmBlackBoxX and gm.gmBlackBoxY must be non-zero to avoid Division by Zero. At epilogue of ftGdiGetGlyphOutline, we adjust the values. CORE-15949 --- win32ss/gdi/ntgdi/freetype.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/win32ss/gdi/ntgdi/freetype.c b/win32ss/gdi/ntgdi/freetype.c index 7d646807e7b..c53bf1a12aa 100644 --- a/win32ss/gdi/ntgdi/freetype.c +++ b/win32ss/gdi/ntgdi/freetype.c @@ -4203,6 +4203,12 @@ ftGdiGetGlyphOutline( } DPRINT("ftGdiGetGlyphOutline END and needed %lu\n", needed); + + if (gm.gmBlackBoxX == 0) + gm.gmBlackBoxX = 1; + if (gm.gmBlackBoxY == 0) + gm.gmBlackBoxY = 1; + *pgm = gm; return needed; }

5 years, 1 month

[reactos] 01/01: [EXPLORER] Update now-redirected 'http' and 'www.reactos.org' URLs

by Serge Gautherie

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=5ce61092b5d4ad6579f41… commit 5ce61092b5d4ad6579f415e5b10ea41c8acf28e3 Author: Serge Gautherie <reactos-git_serge_171003(a)gautherie.fr> AuthorDate: Wed Apr 22 21:39:25 2020 +0200 Commit: Mark Jansen <mark.jansen(a)reactos.org> CommitDate: Thu Apr 23 10:20:15 2020 +0200 [EXPLORER] Update now-redirected 'http' and 'www.reactos.org' URLs --- base/shell/explorer/explorer.rc | 2 +- base/shell/explorer/lang/pl-PL.rc | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/base/shell/explorer/explorer.rc b/base/shell/explorer/explorer.rc index 7c9b5846589..f23251e6422 100644 --- a/base/shell/explorer/explorer.rc +++ b/base/shell/explorer/explorer.rc @@ -63,7 +63,7 @@ CREATEPROCESS_MANIFEST_RESOURCE_ID RT_MANIFEST "explorer.exe.manifest" STRINGTABLE BEGIN //IDS_HELP_COMMAND "helpctr.exe>-FromStartHelp" - IDS_HELP_COMMAND "http://www.reactos.org/" + IDS_HELP_COMMAND "https://reactos.org/" END IDA_TASKBAR ACCELERATORS diff --git a/base/shell/explorer/lang/pl-PL.rc b/base/shell/explorer/lang/pl-PL.rc index 0ed59d19177..40dad7a73c1 100644 --- a/base/shell/explorer/lang/pl-PL.rc +++ b/base/shell/explorer/lang/pl-PL.rc @@ -1,7 +1,7 @@ /* * Translated by Caemyr - Olaf Siejka (Jun, 2007) * Use ReactOS forum PM or IRC to contact me - * http://www.reactos.org + * https://reactos.org/ * IRC: irc.freenode.net #reactos-pl; * Updated by niski - Maciej Bialas (bjauy(a)o2.pl), July 2009 * UTF-8 conversion by Caemyr (May, 2011)

5 years, 1 month

[reactos] 01/01: [ACPPAGE] Update now-redirected 'www.reactos.org' URLs

by Serge Gautherie

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=c2040413ec81649f097f1… commit c2040413ec81649f097f1379422b2fc950556a6e Author: Serge Gautherie <reactos-git_serge_171003(a)gautherie.fr> AuthorDate: Wed Apr 22 22:03:42 2020 +0200 Commit: Mark Jansen <mark.jansen(a)reactos.org> CommitDate: Thu Apr 23 10:18:10 2020 +0200 [ACPPAGE] Update now-redirected 'www.reactos.org' URLs --- dll/shellext/acppage/CLayerUIPropPage.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dll/shellext/acppage/CLayerUIPropPage.cpp b/dll/shellext/acppage/CLayerUIPropPage.cpp index a02a8d845d4..2f74b0d31f5 100644 --- a/dll/shellext/acppage/CLayerUIPropPage.cpp +++ b/dll/shellext/acppage/CLayerUIPropPage.cpp @@ -413,7 +413,7 @@ LRESULT CLayerUIPropPage::OnEditModes(WORD wNotifyCode, WORD wID, HWND hWndCtl, LRESULT CLayerUIPropPage::OnClickNotify(INT uCode, LPNMHDR hdr, BOOL& bHandled) { if (hdr->idFrom == IDC_INFOLINK) - ShellExecute(NULL, L"open", L"https://www.reactos.org/forum/viewforum.php?f=4", NULL, NULL, SW_SHOW); + ShellExecute(NULL, L"open", L"https://reactos.org/forum/viewforum.php?f=4", NULL, NULL, SW_SHOW); return 0; }

5 years, 1 month

← Newer
1
...
11
12
13
14
15
16
17
...
40
Older →

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs April 2020