¿Cómo sé si mi kernel de Linux se ejecuta en 32 bits o 64 bits?

Cuando hago un gato en / proc / cpuinfo, muestra una línea con clflushsize: 64

¿Significa esto que mi núcleo se ejecuta en 64 bits?

uname -a

le dirá el núcleo: el bit final le indica la arquitectura.

Dos ejemplos:

Mi 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

Mi alojamiento de 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 bit

x86_64 = 64 bit

uname -mle dará la arquitectura para la que está compilado el núcleo. Si se imprime i686, su núcleo es de 32 bits, si x86_64es de 64 bits, suponiendo que tenga un chip Intel / AMD.

Creo que la forma más precisa es

getconf LONG_BIT

aquí se muestra exactamente 64

encontrado en este consejo

getconf es del paquete libc-bin (en ubuntu)

Si desea un informe sencillo pero detallado sobre su sistema (CPU, Kernel y software Core OS) y no solo el kernel , aquí hay un pequeño script bash que le dará las respuestas rápidamente.

Si conoce lo suficiente sobre las peculiaridades de las CPU de 32 bits / 64 bits y S / W, es simplemente útil. Si no sabe mucho y cree que su "sistema" es de 32 bits o de 64 bits, le ayudará a descubrir que la verdad puede ser más compleja (partes de su sistema pueden ser de 64 bits mientras que otras de 32 bits) sin confundirlo.

Una vez más, este script (y respuesta) no es para la pregunta literal "¿Cómo sé si mi kernel de Linux se ejecuta en 32 bits o 64 bits?" pero para aquellos que también quieren conocer el arco de su CPU y el núcleo del SO SW.

Reportes de ejemplo

Estos son ejemplos de un caso bastante inusual:

Informe de mini-script (para usuarios experimentados)

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

Informe de script más grande (para usuarios menos experimentados)

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)

Los guiones

Mini script (para administradores experimentados)

Estas 4 líneas brindan toda la información esencial.

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"

Script más grande (para usuarios menos experimentados)

Este script imprime muchas explicaciones y es útil si no tiene experiencia en el tema y se enfrenta a un caso peculiar.

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

Si desea obtener más información, lea estas dos páginas de donde obtuve la mayor parte de la información a) /programming/246007/how-to-determine-whether-a-given-linux-is-32- bit-or-64-bit b) /unix//a/134394/73271

Si desea ver solo la plataforma en la que se está ejecutando, puede usar

uname -i

La lista completa de opciones admitidas para unamees

$ 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

CLFLUSHSIZEno le dice nada sobre el modo operativo del procesador. Según esta respuesta , se refiere a la unidad de caché de descarga más pequeña. En su caso, las líneas de caché se leen / escriben en unidades de 64 bytes.

unamela salida varía demasiado para ser útil, como lo muestra un vistazo a la tabla de ejemplos de Wikipedia . El método más confiable es getconf LONG_BITcomo se muestra en la respuesta de Aquarius Power . Esto funciona independientemente de la arquitectura del procesador, por lo que es justo en casa en ARM, Power o MIPS como en x86.