Woher weiß ich, ob mein Linux-Kernel in 32-Bit oder 64-Bit ausgeführt wird?

Wenn ich eine Katze in / proc / cpuinfo mache, zeigt sie eine Zeile mit clflushsize: 64

Bedeutet dies, dass mein Kernel in 64 Bit ausgeführt wird?

uname -a

wird Ihnen den Kernel sagen - das Endbit sagt Ihnen die Architektur.

Zwei Beispiele:

Mein 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

Mein Dreamhost-Hosting:

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 Bit

x86_64 = 64 Bit

uname -mgibt Ihnen die Architektur, für die der Kernel kompiliert wurde. Wenn es gedruckt wird, i686ist Ihr Kernel 32-Bit, wenn x86_64es 64-Bit ist, vorausgesetzt, Sie haben einen Intel / AMD-Chip.

Ich denke, der genaueste Weg ist

getconf LONG_BIT

hier zeigt es genau 64

auf diesem Tipp gefunden

getconf ist aus dem Paket libc-bin (auf Ubuntu)

Wenn Sie einen einfachen, aber detaillierten Bericht über Ihr System (CPU-, Kernel- und Core OS-Software) und nicht nur über den Kernel wünschen , finden Sie hier ein kleines Bash-Skript, mit dem Sie schnell Antworten erhalten.

Wenn Sie genug über die Besonderheiten von 32-Bit / 64-Bit-CPUs und S / W wissen, ist dies einfach praktisch. Wenn Sie nicht viel wissen und denken, dass Ihr "System" entweder 32-Bit oder 64-Bit ist, können Sie feststellen, dass die Wahrheit komplexer sein kann (Teile Ihres Systems können 64-Bit sein, während andere 32-Bit), ohne Sie zu verwirren.

Auch dieses Skript (und die Antwort) sind nicht für die wörtliche Frage "Woher weiß ich, ob mein Linux-Kernel in 32-Bit oder 64-Bit ausgeführt wird?" aber für diejenigen, die auch den Bogen ihrer CPU und Kern-Betriebssystem-SW kennen wollen.

Beispielberichte

Dies sind Beispiele für einen eher ungewöhnlichen Fall:

Bericht aus dem Miniskript (für erfahrene Benutzer)

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

Bericht aus einem größeren Skript (für weniger erfahrene Benutzer)

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)

Die Skripte

Mini-Skript (für erfahrene Administratoren)

Diese 4 Zeilen enthalten alle wesentlichen Informationen.

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"

Größeres Skript (für weniger erfahrene Benutzer)

Dieses Skript enthält viele Erklärungen und ist nützlich, wenn Sie keine Erfahrung mit diesem Thema haben und mit einem besonderen Fall konfrontiert sind.

#!/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

Wenn Sie mehr wissen möchten, lesen Sie diese beiden Seiten, von denen ich die meisten Informationen erhalten habe. A) /programming/246007/how-to-determine-whether-a-given-linux-is-32- Bit-oder-64-Bit b) /unix//a/134394/73271

Wenn Sie nur die Plattform sehen möchten, auf der Sie ausgeführt werden, können Sie verwenden

uname -i

Die vollständige Liste der unterstützten Optionen für unameist

$ 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

CLFLUSHSIZEsagt nichts über den Betriebsmodus des Prozessors aus. Nach dieser Antwort bezieht es sich auf die kleinste spülbare Cache-Einheit. In Ihrem Fall werden Cache-Zeilen in Einheiten von 64 Bytes gelesen / geschrieben.

unameDie Ausgabe variiert zu stark, um nützlich zu sein, wie ein Blick auf die Beispieltabelle von Wikipedia zeigt. Die zuverlässigste Methode ist getconf LONG_BITals Show in Wassermann Power Antwort . Dies funktioniert unabhängig von der Prozessorarchitektur und ist daher auf ARM, Power oder MIPS wie auf x86 zu Hause.