PAE, windows 10

Witam,

Jak włączyć PAE na windows 10 technical preview 32bit?

Pozdrawiam,
d4rq000z

http://msdn.microsoft.com/en-us/library/windows/desktop/aa366796(v=vs.85).aspx
To nie działa? Ewentualnie patche do W8.1?

Jak włączyć PAE na windows 10 technical preview 32bit?

Może inaczej: co chcesz osiągnąć i do czego ci to?

Zainstalować 64-bitową wersję i nie wydziwiać. W ogóle się dziwię, że Windows 10 ma wersję 32-bit - o odejściu od tej architektury mówi się od czasu następcy Visty.

A jako to się ma do tego: http://msdn.microsoft.com/en-us/library/windows/desktop/aa366778(v=vs.85).aspx ?

Wydaje mi się, że niby PAE da się (prawie) wszędzie włączyć, ale Windows i tak będzie wykrywał tyle ile będzie chciał (czyli zależnie od konkretnej wersji).

Ależ Windows 8 (i jak sądzę 10) działa zawsze w trybie PAE. Więc nie ma czego włączać.
Pytającemu chodzi zapewne o hacka na obsługę powyżej 4 GB na 32-bitowym systemie.
Wymaga to oczywiście włączonego PAE, ale 32-bitowe Windowsy mają sztuczny limit 4 GB niezależnie od tego, czy włączono PAE.

Włączone PAE nie oznacza automatycznie obsługi powyżej 4 GB RAM-u.

Istnieje patch pozwalający na obsługę powyżej 4 GB pod Vistą, Win7, Win8 i Win8.1.

(sam pod Win7 używam innej metody, samodzielnie poprawiam kernel pod hexedytorem)

A jak zrobić to pod Win10? Zakładając że jest to w ogóle możliwe, trzeba by rozpracować kernel Win10 i zaktualizować patcha. Coś co jego autor pewnie prędzej czy później zrobi.
A na razie zapomnij. Aktualne buildy Win10 są i tak bardzo niestabilne, nie nadają się do użytku.

@Azarien albo ktośinny, czy sprawdzałeś dla Windows 7 SP1 32bit ten patch:
http://wj32.org/wp/2011/02/23/pae-patch-updated-for-windows-7-sp1/
?

Kiedyś robiłem do niego podchody ale gdzieś doczytałem że Windows potem co prawda widzi wiecej RAMu ale korzysta i tak tylko z 3,2 - 3,5 GB, i odpuściłem.

PS. Jeżeli będę podążał wg instrukcji z read.me z tego patcha nie wiedząc dokładnie co robie ani na czym pracuje, moge coś schrzanić w systemie? Pytam bo takie akcje to dla mnie czarna magia a nie mam teraz ani checi ani czasu na przeinstalowywanie systemu a denerwuje mnie to ze juz tyle czasu lezy dodatkowe niepodłączone 4GB ramu obok kompa.

@Azarien albo ktośinny, czy sprawdzałeś dla Windows 7 SP1 32bit ten patch:
Nie; sprawdzałem inny.

ale gdzieś doczytałem że Windows potem co prawda widzi wiecej RAMu ale korzysta i tak tylko z 3,2 - 3,5 GB, i odpuściłem.
Coś chyba źle wyczytałeś.
Powyżej 4 GB oficjalnie wspiera 32-bitowa wersja Windows Server 2008 poprzez mechanizm PAE. Równoległa z nim Vista ma to samo jądro, również z obsługą PAE, ale ze sztucznie wprowadzonym limitem do 4 GB. Patch ma za zadanie ten limit obejść i przywrócić funkcjonalność z Server 2008.
Nie istnieje 32-bitowa wersja serwerowa Windows 7 (Server 2008 R2 istnieje tylko 64-bitowy) ale 32-bitowy Win7 działa pod tym względem tak samo jak Vista: PAE jest zaimplementowane, ale rozmiar pamięci obcięty do 4 gigabajtów. Dlatego patch działa.

Pamiętaj jednak, że 32-bitowa aplikacja nadal ma 32-bitową przestrzeń adresową, w której da się zamapować 4 gigabajty, z czego standardowo 2 giga na aplikację a 2 giga na system. Dopiero system widzi 36 bitów dzięki PAE.
W ten sposób możesz odpalić 10 programów, każdy zajmuje np. 1 giga, razem 10 ale mając 16 giga RAM-u to przejdzie nawet przy wyłączonym swapie.

Istnieją sposoby na zaalokowanie wielkiej ilości pamięci pod 32-bitową aplikacją (nawet przy aktywnym systemowym limicie do 4 giga) ale to program musi to specjalnie obsługiwać. Działa to podobnie jak w przedpotopowych czasach działała pamięć EMS: można zaalokować dużo pamięci (powyżej 4 giga) a w danym momencie mamy małe „okienko” (umieszczone w obszarze poniżej 4 giga) do tej górnej pamięci, które możemy sobie przesuwać po zaalokowanym obszarze.

Jeżeli będę podążał wg instrukcji z read.me z tego patcha nie wiedząc dokładnie co robie ani na czym pracuje, moge coś schrzanić w systemie?
Nie czytałem tej instrukcji. Najgorsze co to system przestanie ci odpalać. Dlatego trzeba utworzyć menu startowe z wyborem: stare jądro (z limitem) i nowe (spatchowane).

Varran napisał(a):

denerwuje mnie to ze juz tyle czasu lezy dodatkowe niepodłączone 4GB ramu obok kompa.

to sobie wtyknij i już będzie podłączone, zamiast obok. :)

jak wtykne to mi komputer nie startuje

Ahaaaaa! Ty chcesz tym PAE-em wsadzać ram w sloty.

Wiesz co?
Sprzedaj ten gips za 22zł... i się nachlej. :)

Duża dyskusja się zrobiła, mało konkretów.

Nie wiem dlaczego ktoś daje odpowiedzi:

• Może inaczej: co chcesz osiągnąć i do czego ci to?
• Zainstalować 64-bitową wersję i nie wydziwiac
  ??
  -- Wydaje mi się, że niby PAE da się (prawie) wszędzie włączyć, ale Windows i tak będzie wykrywał tyle ile będzie chciał (czyli zależnie od konkretnej wersji).

Poziom tego forum z tego co widzę jest bardzo niski:( Sorry za to co napisałem.

Windows 10 używam jako główny system, jak dla mnie stabilność jest wystarczająca. Wykrywa mi 3,5GB ramu zamiast 4GB.
64bitów nie zainstaluje z taką ilością bo to bez sensu. Do tego większość aplikacji mam 32 bitowych.

Konkret jest prosty - aby Windows 10 w trybie PAE obsługiwał powyżej 4 GB RAM potrzebuje modyfikacji jądra. Ktoś musi taką modyfikację zrobić. Jeżeli sam nie potrafisz - czekaj, może ktoś kiedyś zrobi. Obecnie wygląda na to, że wersje jądra Windows Technical Preview będą się zmieniać co około miesiąc - oznaczałoby to, że w najgorszym wypadku trzeba by robić modyfikacje jądra co miesiąc. Spodziewałbym się tego typu łatki dopiero w wersji finalnej.

Ja chce żeby obsługiwał równe 4GB, a nie powyżej ;p

Dzięki Rev, z tego co widziałem patch ma udostępnione kody źródłowe. Spróbuje samemu to ogarnac ;p

A jednak nudziło mi się.

VOID PatchLoader9841Part1(
    __in PLOADED_IMAGE LoadedImage,
    __out PBOOLEAN Success
    )
{
    // ImgpLoadPEImage

    UCHAR target[] =
    {
        // push eax
        0x50,
        // push ecx
        0x51,
        // lea eax, [ebp+var_D4]
        0x8d, 0x85, 0x2c, 0xff, 0xff, 0xff,
        // push eax
        0x50,
        // mov eax, [ebp+var_2C]
        0x8b, 0x45, 0xd4,
        // push [ebp+arg_1C]
        0xff, 0x75, 0x24,
        // mov ecx, [eax+0Ch]
        0x8b, 0x48, 0x0c
        // call _ImgpValidateImageHash@40
        // 0xe8, 0x08, 0x0a, 0x00, 0x00
        // mov ebx, eax
        // 0x8b, 0xd8
        // test ebx, ebx
        // 0x85, 0xdb
        // jns short loc_435CBA
        // 0x79 0x2d
    };

    ULONG jnsOffset = 27;
    PUCHAR ptr = LoadedImage->MappedAddress;
    ULONG i, j;

    for (i = 0; i < LoadedImage->SizeOfImage - sizeof(target); i++)
    {
        for (j = 0; j < sizeof(target); j++)
        {
            if (ptr[j] != target[j])
                break;
        }

        if (j == sizeof(target))
        {
            // Found it. Patch the code.
            // Note that eax and ebx are not used later, so we can ignore them.

            // jns short loc_434bc2 -> jmp short loc_434bc2
            // 0x79, 0x2d -> 0xeb, 0x2d
            ptr[jnsOffset] = 0xeb;

            *Success = TRUE;

            break;
        }

        ptr++;
    }
}

VOID PatchLoader9841Part2(
    __in PLOADED_IMAGE LoadedImage,
    __out PBOOLEAN Success
    )
{
    // BlImgLoadImageWithProgress2

    UCHAR target[] =
    {
        // push ecx
        0x51,
        // push ecx
        0x51,
        // push [ebp+var_34]
        0xff, 0x75, 0xcc,
        // push [ebp+var_28]
        0xff, 0x75, 0xd8,
        // push eax
        0x50,
        // push [ebp+var_16C]
        0xff, 0xb5, 0x94, 0xfe, 0xff, 0xff,
        // push ecx
        0x51,
        // push [ebp+var_C]
        0xff, 0x75, 0xf4,
        // mov ecx, [ebp+arg_0]
        0x8b, 0x4d, 0x08,
        // call _ImgpValidateImageHash@40
        // 0xe8, 0x34, 0x19, 0x00, 0x00
        // mov esi, eax
        // 0x8b, 0xf0
        // test esi, esi
        // 0x85, 0xf6
        // jns short_loc_434db3
        // 0x79, 0x52
    };
    ULONG movOffset = 27;
    PUCHAR ptr = LoadedImage->MappedAddress;
    ULONG i, j;

    for (i = 0; i < LoadedImage->SizeOfImage - sizeof(target); i++)
    {
        for (j = 0; j < sizeof(target); j++)
        {
            if (ptr[j] != target[j])
                break;
        }

        if (j == sizeof(target))
        {
            // Found it. Patch the code.

            // mov esi, eax -> xor esi, esi
            // 0x8b, 0xf0 -> 0x33, 0xf6
            ptr[movOffset] = 0x33;
            ptr[movOffset + 1] = 0xf6;

            *Success = TRUE;

            break;
        }

        ptr++;
    }
}

VOID PatchLoader9841(
    __in PLOADED_IMAGE LoadedImage,
    __out PBOOLEAN Success
    )
{
    // ImgpLoadPEImage and BlImgLoadImageWithProgressEx

    // There is a function called ImgpValidateImageHash. We are 
    // going to patch ImgpLoadPEImage and BlImgLoadImageWithProgressEx
    // so that they don't care what the result of the function is.

    BOOLEAN success1 = FALSE;
    BOOLEAN success2 = FALSE;

    PatchLoader9841Part1(LoadedImage, &success1);
    PatchLoader9841Part2(LoadedImage, &success2);
    *Success = success1 && success2;
}

I na dole (w funkcji kernela nie zmieniło się nic w porównaniu z 8.1)

else if (buildNumber == 9600 || buildNumber == 9841)
    Patch(ArgOutput, PatchKernel9600);

else if (buildNumber == 9841)
    Patch(ArgOutput, PatchLoader9841);

Kod zadziała raczej tylko i wyłącznie dla tego konkretnego buildu, nie bawiłem się w omijanie konkretnych offsetów.

ps. nie daję na nic żadnej gwarancji, każdy używa na swoją odpowiedzialność

Nie wiem dlaczego ktoś daje odpowiedzi:

• Może inaczej: co chcesz osiągnąć i do czego ci to?

Dlatego że zadałeś złe pytanie "jak włączyć PAE" (które jest na stałe włączone) zamiast "jak sprawić by system widział pełen RAM" (i od razu byłoby wiadomo o co ci chodzi)

-- Wydaje mi się, że niby PAE da się (prawie) wszędzie włączyć, ale Windows i tak będzie wykrywał tyle ile będzie chciał (czyli zależnie od konkretnej wersji).

Bo to jest prawda.

Poziom tego forum z tego co widzę jest bardzo niski:( Sorry za to co napisałem.
Poziom jest dobry. Naucz się słuchać co inni mówią i przyjmij do wiadomości fakt, że możesz się w każdej sprawie mylić.

PAE (Physical Address Extension) to mechanizm procesora (alternatywny algorytm stronicowania) poszerzający fizyczną przestrzeń adresową z 32 do 36 bitów, więc z 4 do 64 GB. Ale to nie oznacza automatycznie obsługi powyżej 4 GB, bo Windows mimo że z PAE korzysta, to aplikuje sztuczny limit obcinający przestrzeń adresową do 4 gigabajtów.
Patch na jądro usuwa ten limit, a nie włącza PAE.

Teraz poniał dlaczego PAE nie równa się obsłudze powyżej 4 giga RAM?
Dlatego nie spinaj się, gdzieś wyczytałeś „trzeba włączyć PAE” ale to tylko półprawda.

Ja chce żeby obsługiwał równe 4GB, a nie powyżej ;p
Równe 4 giga to powyżej 4 giga na potrzeby niniejszej dyskusji, bo trzeba mieć ponad 4-gigową przestrzeń adresową żeby zaadresować 4 giga RAM.

A ja mam taki gips w informacjach z windy:

Zainstalowana pamięć: 8.00 GB (dostępne 2.72 GB)

No, czyli mi PEA działa dobrze - wsadza kości w te ramy jak trzeba... :)

Hi Rev. I just registered on this forum to ask if you could possibly upload or pm a compiled patchpae2.exe -

I found this forum via another guy's blog who mentioned you while giving your compile info.

https://wseiitenglish.wordpress.com/2014/11/16/limit-up-to-128gb-of-memory-on-32bit-windows/

anyways - I have spent 6 ½ hours trying to compile this and can't seem to get it right. The original for Windows 7 worked miracles - but no matter what I try my own compiled version from your knowledge refuses to work on the same computer updated to Windows 10 Pro.

Is there any chance you can help me? PM or post here?

Thanks /Pete

Rev napisał(a):

A jednak nudziło mi się.

VOID PatchLoader9841Part1(
    __in PLOADED_IMAGE LoadedImage,
    __out PBOOLEAN Success
    )
{
    // ImgpLoadPEImage

    UCHAR target[] =
    {
        // push eax
        0x50,
        // push ecx
        0x51,
        // lea eax, [ebp+var_D4]
        0x8d, 0x85, 0x2c, 0xff, 0xff, 0xff,
        // push eax
        0x50,
        // mov eax, [ebp+var_2C]
        0x8b, 0x45, 0xd4,
        // push [ebp+arg_1C]
        0xff, 0x75, 0x24,
        // mov ecx, [eax+0Ch]
        0x8b, 0x48, 0x0c
        // call _ImgpValidateImageHash@40
        // 0xe8, 0x08, 0x0a, 0x00, 0x00
        // mov ebx, eax
        // 0x8b, 0xd8
        // test ebx, ebx
        // 0x85, 0xdb
        // jns short loc_435CBA
        // 0x79 0x2d
    };

    ULONG jnsOffset = 27;
    PUCHAR ptr = LoadedImage->MappedAddress;
    ULONG i, j;

    for (i = 0; i < LoadedImage->SizeOfImage - sizeof(target); i++)
    {
        for (j = 0; j < sizeof(target); j++)
        {
            if (ptr[j] != target[j])
                break;
        }

        if (j == sizeof(target))
        {
            // Found it. Patch the code.
            // Note that eax and ebx are not used later, so we can ignore them.

            // jns short loc_434bc2 -> jmp short loc_434bc2
            // 0x79, 0x2d -> 0xeb, 0x2d
            ptr[jnsOffset] = 0xeb;

            *Success = TRUE;

            break;
        }

        ptr++;
    }
}

VOID PatchLoader9841Part2(
    __in PLOADED_IMAGE LoadedImage,
    __out PBOOLEAN Success
    )
{
    // BlImgLoadImageWithProgress2

    UCHAR target[] =
    {
        // push ecx
        0x51,
        // push ecx
        0x51,
        // push [ebp+var_34]
        0xff, 0x75, 0xcc,
        // push [ebp+var_28]
        0xff, 0x75, 0xd8,
        // push eax
        0x50,
        // push [ebp+var_16C]
        0xff, 0xb5, 0x94, 0xfe, 0xff, 0xff,
        // push ecx
        0x51,
        // push [ebp+var_C]
        0xff, 0x75, 0xf4,
        // mov ecx, [ebp+arg_0]
        0x8b, 0x4d, 0x08,
        // call _ImgpValidateImageHash@40
        // 0xe8, 0x34, 0x19, 0x00, 0x00
        // mov esi, eax
        // 0x8b, 0xf0
        // test esi, esi
        // 0x85, 0xf6
        // jns short_loc_434db3
        // 0x79, 0x52
    };
    ULONG movOffset = 27;
    PUCHAR ptr = LoadedImage->MappedAddress;
    ULONG i, j;

    for (i = 0; i < LoadedImage->SizeOfImage - sizeof(target); i++)
    {
        for (j = 0; j < sizeof(target); j++)
        {
            if (ptr[j] != target[j])
                break;
        }

        if (j == sizeof(target))
        {
            // Found it. Patch the code.

            // mov esi, eax -> xor esi, esi
            // 0x8b, 0xf0 -> 0x33, 0xf6
            ptr[movOffset] = 0x33;
            ptr[movOffset + 1] = 0xf6;

            *Success = TRUE;

            break;
        }

        ptr++;
    }
}

VOID PatchLoader9841(
    __in PLOADED_IMAGE LoadedImage,
    __out PBOOLEAN Success
    )
{
    // ImgpLoadPEImage and BlImgLoadImageWithProgressEx

    // There is a function called ImgpValidateImageHash. We are 
    // going to patch ImgpLoadPEImage and BlImgLoadImageWithProgressEx
    // so that they don't care what the result of the function is.

    BOOLEAN success1 = FALSE;
    BOOLEAN success2 = FALSE;

    PatchLoader9841Part1(LoadedImage, &success1);
    PatchLoader9841Part2(LoadedImage, &success2);
    *Success = success1 && success2;
}

I na dole (w funkcji kernela nie zmieniło się nic w porównaniu z 8.1)

else if (buildNumber == 9600 || buildNumber == 9841)
    Patch(ArgOutput, PatchKernel9600);

else if (buildNumber == 9841)
    Patch(ArgOutput, PatchLoader9841);

Kod zadziała raczej tylko i wyłącznie dla tego konkretnego buildu, nie bawiłem się w omijanie konkretnych offsetów.

ps. nie daję na nic żadnej gwarancji, każdy używa na swoją odpowiedzialność

hrrrm... sigh strange system. trying again. ;) Edited due to misunderstanding

Any chance you can help me, @Azarien?

or @Rev?

Like this @Shalom ? ;) also how can I like a direct reply - like your answers?

ok, but can you compile @Rev version successfully? @Azarien ? other than this issue Win 10 is very much recommended. Had very few problems yet.

Even if you'd get it to compile it's a patch for a quite old build of Win10, the 9841 (and the newest version of Windows is the RTM build, 10240). So a new patch has to be made, but I don't really have time to do it right now, I just upgraded myself and have to setup all my tools and et cetera. Maybe in a few days. Remind me then if you still haven't found anything.

I know that much - but do you think it has changed that much @Rev ? Can you up / pm your old one and I'll give it a go?

Rev napisał(a):

Even if you'd get it to compile it's a patch for a quite old build of Win10, the 9841 (and the newest version of Windows is the RTM build, 10240). So a new patch has to be made, but I don't really have time to do it right now, I just upgraded myself and have to setup all my tools and et cetera. Maybe in a few days. Remind me then if you still haven't found anything.

I don't even have an executable anymore, but the old one won't run on the RTM version of Windows for sure (it checked the actual build number before trying to apply).

Ahh... @Rev

I see - then maybe that's why my compile of your version won't work. Says Kernel mismatch or something like that.

Well. Anytime you are "bored" again I'd be more than grateful for a new precompiled version - does the command line at the prompt differ in any way? as far as I saw you didn't write anything about that... (Google Translate from Polish doesn't exactly help though... ;) )

If upping precompiled versions is not allowed in this forum I'd much appreciate a PM. Can't even seem to activate PAE at all....

Rev napisał(a):

I don't even have an executable anymore, but the old one won't run on the RTM version of Windows for sure (it checked the actual build number before trying to apply).

After having some headache, I've compiled the patch successfully (but I don't have a system yet on which I could test it).

== Compiling ==
To compile PatchPae2, you need to get Process Hacker from processhacker.sourceforge.net and build it.
The directory structure should look like this:

• ...\ProcessHacker2\lib...
• ...\ProcessHacker2\phlib...
• ...\src\PatchPae2.sln

The code is intended to be compiled with Visual Studio 2012. I have managed to compile it with VS Community 2013.
Forget about VS 2015, the source code uses some internal undocumented functions which are gone in 2015.

1. download sources of Process Hacker version 2.33 (only lib and phlib folders are needed)
   http://sourceforge.net/projects/processhacker/files/processhacker2/processhacker-2.33-src.zip/download
   put them as mentioned above. note that the latest version of PH will not work.

2. open phlib.vcxproj and build as Release

3. open PatchPae2.sln and build as Release

Google Translate from Polish doesn't exactly help though
Yeah, it's almost useless. Try with Bing Translator, sometimes it works better.

@Azarien - did you compile it as it was - or update the version info?

could you share it or pm it to me please?

Never tried bing. Is it actually better than Google Translate???

Azarien napisał(a):

After having some headache, I've compiled the patch successfully (but I don't have a system yet on which I could test it).

== Compiling ==
To compile PatchPae2, you need to get Process Hacker from processhacker.sourceforge.net and build it.
The directory structure should look like this:

• ...\ProcessHacker2\lib...
• ...\ProcessHacker2\phlib...
• ...\src\PatchPae2.sln

The code is intended to be compiled with Visual Studio 2012. I have managed to compile it with VS Community 2013.
Forget about VS 2015, the source code uses some internal undocumented functions which are gone in 2015.

1. download sources of Process Hacker version 2.33 (only lib and phlib folders are needed)
   http://sourceforge.net/projects/processhacker/files/processhacker2/processhacker-2.33-src.zip/download
   put them as mentioned above. note that the latest version of PH will not work.

2. open phlib.vcxproj and build as Release

3. open PatchPae2.sln and build as Release

Google Translate from Polish doesn't exactly help though
Yeah, it's almost useless. Try with Bing Translator, sometimes it works better.

i tried with process hacker - but wouldn't go through. Kernel didn't like it at all...

You need the new source code with updated opcodes either way.

which you have access to? @Rev

Rev napisał(a):

You need the new source code with updated opcodes either way.

I don't, it's not written yet. I told you to give me a message in a few days.