From: Wilm Hoyer <W.Hoyer@dental-vision.de>
To: Julien Rouhaud <rjuju123@gmail.com>
CC: Michael Paquier <michael@paquier.xyz>,
	"pgsql-hackers@lists.postgresql.org" <pgsql-hackers@lists.postgresql.org>
Subject: AW: BUG #17448: In Windows 10, version 1703 and later, huge_pages
 doesn't work.
Thread-Topic: BUG #17448: In Windows 10, version 1703 and later, huge_pages
 doesn't work.
Thread-Index: 
 AQHYQLLari2s00oie0yrcUkVcNdgtqzRF5eAgAAr+QCAAC3FgIAGApsAgAFhPgCAAC2tgIAABR2AgAAuZoCAAASEgIABhzwQgCbuaICAAcnTAIAAPCWggABU8ACAASmTcA==
Date: Thu, 28 Apr 2022 09:31:17 +0000
Message-ID: <6389b5a88e114bee85593af2853c08cd@dental-vision.de>
References: <YkQMyhsP7xgLDDT/@paquier.xyz>
 <20220331045908.bm5edcacvymgwwv2@jrouhaud> <YkVbbZBiC4yxXPuc@paquier.xyz>
 <20220331080055.hjrrsrd4lxwlt7f5@jrouhaud>
 <20220331104659.ol6pqe7s3tpkymuk@jrouhaud>
 <20220331110309.ws25d6dl5yyzprye@jrouhaud>
 <a6859029835d4abdb6ba2970614905d1@dental-vision.de>
 <Ymd7C+QineDpi7Eb@jrouhaud> <Ymj7GHBfTnaN5kWW@paquier.xyz>
 <9178d683d05d420a887369ffb38d8fbd@dental-vision.de>
 <20220427165228.dkxndmm4lsrd5zgg@jrouhaud>
In-Reply-To: <20220427165228.dkxndmm4lsrd5zgg@jrouhaud>
Accept-Language: de-DE, en-US
Content-Language: de-DE
Content-Type: text/plain; charset="us-ascii"
Content-Transfer-Encoding: quoted-printable
MIME-Version: 1.0
Archived-At: 
 <https://www.postgresql.org/message-id/6389b5a88e114bee85593af2853c08cd%40dental-vision.de>
Precedence: bulk


On Wed, Apr 27, 2022 at 03:04:23PM +0000, Wilm Hoyer wrote:
>>
>> I used the following hack to get the "real" Major and Minor Version of=20
>> Windows - it's in C# (.Net) and needs to be adjusted (you can compile=20
>> as x64 and use a long-long as return value ) to return the Service=20
>> Number too and translated it into C.
>> I share it anyways, as it might help - please be kind, as it really is=20
>> a little hack.
>>
>> Situation:
>> Main Application can't or is not willing to add a manifest file into=20
>> its resources.
>>
>> Solution:
>> Start a small executable (which has a manifest file compiled into its=20
>> resources), let it read the OS Version and code the Version into its=20
>> return Code.

> Thanks for sharing.

You are welcome.

> Having to compile another tool just for that seems like a very high price=
 to pay, especially since we don't have any C# code in the tree.  I'm not e=
ven sure that compiling this wouldn't need additional  requirements and/or =
if it would work on our oldest supported Windows versions.

With "translate it into C" I meant "tread it as pseudo code, for a solution=
 in plain C" (e.g. substitude Environment.OSVersion with IsWindowsVersionOr=
Greater or GetVersion )

On Wed, Apr 27, 2022 at 05:13:12PM +0900, Michael Paquier wrote:
> On Tue, Apr 26, 2022 at 12:54:35PM +0800, Julien Rouhaud wrote:
> > so I'm still on the opinion that we should unconditionally use the=20
> > FILE_MAP_LARGE_PAGES flag if it's defined and call it a day.
>=20
> Are we sure that this is not going to cause failures in environments=20
> where the flag is not supported?

I'm not that familiar with the Microsoft OS or C (that's why I haven't migr=
ated the c# code to C in the first place) to have a clear answer to that qu=
estion.

If there is any risk and you want to avoid it, I can share a search result =
when I faced the same issue for our application. I declined this solution i=
n favor of the previously shared one.
It's from NUnit (and needs migration to C as well - but since it just invol=
ves the Registry this should be pretty forward).
Just in case the Framework is not known: NUnit is the most popular .Net por=
t of the Unit Testing Framework JUnit. There exits a C port too (CUnit) May=
be in there you can find an OS Version check too.

// Copyright (c) Charlie Poole, Rob Prouse and Contributors. MIT License - =
see LICENSE.txt
[...]
namespace NUnit.Framework.Internal
{
    [SecuritySafeCritical]
    public class OSPlatform
    {
[...]
        /// <summary>
        /// Gets the actual OS Version, not the incorrect value that might =
be
        /// returned for Win 8.1 and Win 10
        /// </summary>
        /// <remarks>
        /// If an application is not manifested as Windows 8.1 or Windows 1=
0,
        /// the version returned from Environment.OSVersion will not be 6.3=
 and 10.0
        /// respectively, but will be 6.2 and 6.3. The correct value can be=
 found in
        /// the registry.
        /// </remarks>
        /// <param name=3D"version">The original version</param>
        /// <returns>The correct OS version</returns>
        private static Version GetWindows81PlusVersion(Version version)
        {
            try
            {
                using (var key =3D Registry.LocalMachine.OpenSubKey(@"SOFTW=
ARE\Microsoft\Windows NT\CurrentVersion"))
                {
                    if (key !=3D null)
                    {
                        var buildStr =3D key.GetValue("CurrentBuildNumber")=
 as string;
                        int.TryParse(buildStr, out var build);

                        // These two keys are in Windows 10 only and are DW=
ORDS
                        var major =3D key.GetValue("CurrentMajorVersionNumb=
er") as int?;
                        var minor =3D key.GetValue("CurrentMinorVersionNumb=
er") as int?;
                        if (major.HasValue && minor.HasValue)
                        {
                            return new Version(major.Value, minor.Value, bu=
ild);
                        }

                        // If we get here, we are not Windows 10, so we are=
 Windows 8
                        // or 8.1. 8.1 might report itself as 6.2, but will=
 have 6.3
                        // in the registry. We can't do this earlier becaus=
e for backwards
                        // compatibility, Windows 10 also has 6.3 for this =
key.
                        var currentVersion =3D key.GetValue("CurrentVersion=
") as string;
                        if(currentVersion =3D=3D "6.3")
                        {
                            return new Version(6, 3, build);
                        }
                    }
                }
            }
            catch (Exception)
            {
            }
            return version;
        }
[...]
   }
}

Finally, my reasoning to use the executable solution in favor of the NUnit =
one:=20
I found no guarantee from Microsoft regarding the keys and values in the re=
gistry - hence a change with an update or in a newer Windows is not likely,=
 but still possible. That's no problem for a heavily used and supported fra=
mework like NUnit - they are likely to adopt within days of a new Windows r=
elease. I on the other hand wanted a solution with small to no support. Tha=
t's why I decided to implement a solution that's as in line as possible wit=
h the official Microsoft advice for targeting newer OS Versions.

Best regards
Wilm.