Skąd mam wiedzieć, czy moje jądro Linuksa działa w wersji 32-bitowej lub 64-bitowej?

Kiedy robię kota w katalogu / proc / cpuinfo, pokazuje on linię z clflushsize: 64

Czy to oznacza, że ​​moje jądro działa w 64 bitach?

uname -a

powie ci jądro - bit końcowy mówi ci o architekturze.

Dwa przykłady:

Mój Mac:

Darwin Mac.local 9.8.0 Darwin Kernel Version 9.8.0: Wed Jul 15 16:55:01 PDT 2009; root:xnu-1228.15.4~1/RELEASE_I386 i386

Hosting My Dreamhost:

Linux ecco 2.6.24.5-serf-xeon-c6.1-grsec #1 SMP Tue Oct 7 06:18:04 PDT 2008 x86_64 GNU/Linux

i386 = 32 bity

x86_64 = 64 bity

uname -mda ci architekturę, dla której skompilowane jest jądro. Jeśli się drukuje, i686wtedy twoje jądro jest 32-bitowe, jeśli x86_64to 64-bitowe, zakładając, że masz układ Intel / AMD.

Myślę, że najbardziej precyzyjny sposób

getconf LONG_BIT

tutaj to dokładnie pokazuje 64

znalezione w tej końcówce

getconf pochodzi z pakietu libc-bin (na Ubuntu)

Jeśli potrzebujesz łatwego, ale szczegółowego raportu o swoim systemie (procesorze, jądrze i oprogramowaniu Core OS), a nie tylko jądrze, oto mały skrypt bash, który szybko udzieli odpowiedzi.

Jeśli wiesz wystarczająco dużo o osobliwościach 32-bitowych / 64-bitowych procesorów i S / W, jest to po prostu przydatne. Jeśli nie wiesz dużo i myślisz, że twój „system” jest albo 32-bitowy, albo 64-bitowy, pomoże ci to odkryć, że prawda może być bardziej złożona (niektóre części twojego systemu mogą być 64-bitowe, a inne 32-bitowe), nie wprowadzając w błąd.

Znowu ten skrypt (i odpowiedź) nie dotyczy dosłownego pytania „Skąd mam wiedzieć, czy moje jądro Linuksa działa w wersji 32- lub 64-bitowej?” ale dla tych, którzy również chcą poznać łuk swojego procesora i rdzeń oprogramowania systemowego.

Przykładowe raporty

Oto przykłady raczej nietypowego przypadku:

Raport z mini-skryptu (dla doświadczonych użytkowników)

You have a 64 bit CPU
Your kernel reports that the architecture is 32 bit
Your /sbin/init process is 64 bit
Your C compiler is configured to produce 32 bit executables

Raport z większego skryptu (dla mniej doświadczonych użytkowników)

You have a 64 bit CPU
Your kernel reports that the architecture is 32 bit
    If you are not the admin he can make a 64bit kernel report 32bit (see man setarch)
    In this case he has (because we have 64bit programs)
Your /sbin/init process is 64 bit
    Most other core OS programs will probably be 64 bits also.
    You may use the following command to check a specific program.
      file -L /path/to/program
Your C compiler is configured to produce 32 bit executables
    (Note that a 64bit compiler may be setup to produce 32bit code)

Skrypty

Mini-skrypt (dla doświadczonych administratorów)

Te 4 wiersze zawierają wszystkie niezbędne informacje.

grep -w 'lm' /proc/cpuinfo > /dev/null && echo "You have a 64 bit CPU" || echo "You have a 32 bit CPU"
echo "Your kernel reports that the architecture is $(uname -m|sed -e 's/x86_64/64 bit/' -e 's/i.86/32 bit/')"
echo "Your /sbin/init process is $(file /sbin/init|sed -e 's/^.* \(32\|64\) bit.*$/\1bit/')"
echo "Your C compiler is configured to produce $(getconf LONG_BIT) bit executables"

Większy skrypt (dla mniej doświadczonych użytkowników)

Ten skrypt drukuje wiele wyjaśnień i jest przydatny, jeśli nie masz doświadczenia w tym temacie i masz do czynienia z osobliwym przypadkiem.

#!/bin/bash

# collect system info
grep -w 'lm' /proc/cpuinfo > /dev/null && CPU=64 || CPU=32
ARCH=$(uname -m|sed -e 's/x86_64/64/' -e 's/i.86/32/')
INIT=$(file -L /sbin/init|sed -e 's/^.* \(32\|64\)-bit.*$/\1/')
COMPILER=$(getconf LONG_BIT)

# if all values are the same we set UNIFORM="YES"
! echo "$CPU $ARCH $INIT $COMPILER" | grep -q "$CPU $CPU $CPU $CPU" && UNIFORM="NO" || UNIFORM="YES"

# report to the user
echo "You have a $CPU bit CPU"
echo "Your kernel reports that the architecture is $ARCH bit"
if [ "$UNIFORM" = "NO" ] && [ "$ARCH" = "32" ] ; then
       echo "    If you are not the admin he can make a 64bit kernel report 32bit (see man setarch)"
       if  [ "$INIT" = "64" ] ||  [ "$COMPILER" = "64" ] ; then
           echo "    In this case he has (because we have 64bit programs)"
       else
           echo "    We don't see such signs so you most likely run a 32bit kernel"
           echo "    (A 64bit CPU can run 32bit kernels)"
       fi
fi
echo "Your /sbin/init process is $INIT bit"
if [ "$CPU" = "64" ] ; then
     echo "    Most other core OS programs will probably be $INIT bits also."
     echo "    You may use the following command to check a specific program."
     echo "      file -L /path/to/program"
fi
if [ "$UNIFORM" = "NO" ] && [ "$INIT" = "32" ] ; then
     echo "    (Note that a 64bit kernel may start a 32bit init process)"
fi
echo "Your C compiler is configured to produce $COMPILER bit executables"
if [ "$UNIFORM" = "NO" ] && [ "$COMPILER" = "32" ] ; then
        echo "    (Note that a 64bit compiler may be setup to produce 32bit code)"
fi

Jeśli chcesz dowiedzieć się więcej, przeczytaj te dwie strony, z których uzyskałem większość informacji a) /programming/246007/how-to-determine-whether-a-given-linux-is-32- bit-or-64-bit b) https://unix.stackexchange.com/a/134394/73271

Jeśli chcesz zobaczyć tylko platformę, na której pracujesz, możesz użyć

uname -i

Pełna lista obsługiwanych opcji dla unameto

$ uname --help
Usage: uname [OPTION]...
Print certain system information.  With no OPTION, same as -s.

  -a, --all                print all information, in the following order,
                             except omit -p and -i if unknown:
  -s, --kernel-name        print the kernel name
  -n, --nodename           print the network node hostname
  -r, --kernel-release     print the kernel release
  -v, --kernel-version     print the kernel version
  -m, --machine            print the machine hardware name
  -p, --processor          print the processor type or "unknown"
  -i, --hardware-platform  print the hardware platform or "unknown"
  -o, --operating-system   print the operating system
      --help     display this help and exit
      --version  output version information and exit

CLFLUSHSIZEnic nie mówi o trybie pracy procesora. Zgodnie z tą odpowiedzią odnosi się do najmniejszej spłukiwanej jednostki pamięci podręcznej. W twoim przypadku wiersze pamięci podręcznej są odczytywane / zapisywane w jednostkach 64 bajtów.

unamewyniki różnią się zbytnio, aby były użyteczne, jak pokazuje rzut oka w tabeli przykładów Wikipedii . Najbardziej niezawodną metodą jest getconf LONG_BITjak pokazano w odpowiedzi Aquarius Power . Działa to niezależnie od architektury procesora, więc jest w domu na ARM, Power lub MIPS jak na x86.