¿Cómo determinar si un Linux dado es de 32 bits o de 64 bits?

Cuando escribo uname -a, da el siguiente resultado.

Linux mars 2.6.9-67.0.15.ELsmp #1 SMP Tue Apr 22 13:50:33 EDT 2008 i686 i686 i386 GNU/Linux

¿Cómo puedo saber de esto que el sistema operativo dado es de 32 o 64 bits?

Esto es útil cuando escribo configureguiones, por ejemplo: ¿para qué arquitectura estoy construyendo?

Tratar uname -m. Que es corto uname --machiney produce:

x86_64 ==> 64-bit kernel
i686   ==> 32-bit kernel

De lo contrario, no para el kernel de Linux, sino para la CPU , escriba:

cat /proc/cpuinfo

o:

grep flags /proc/cpuinfo

En el parámetro "flags", verá varios valores: vea " ¿Qué significan los flags en / proc / cpuinfo? " Entre ellos, uno se llama lm: Long Mode( x86-64 : amd64, también conocido como Intel 64, es decir, 64 bits capaz)

lm ==> 64-bit processor

O usandolshw (como se menciona a continuación por Rolf de Sajonia ), sin sudo(solo para aprovechar el ancho de la CPU):

lshw -class cpu|grep "^       width"|uniq|awk '{print $2}'

Nota: puede tener una CPU de 64 bits con un núcleo de 32 bits instalado .
(como ysdx menciona en su propia respuesta , "Hoy en día, un sistema puede ser multiarch, por lo que no tiene sentido de todos modos. Es posible que desee encontrar el objetivo predeterminado del compilador")

Si estuviera ejecutando una plataforma de 64 bits, vería x86_64 o algo muy similar en la salida de uname -a

Para obtener el nombre de hardware específico de su máquina, ejecute

uname -m

Tambien puedes llamar

getconf LONG_BIT

que devuelve 32 o 64

lscpu enumerará estos entre otra información con respecto a su CPU:

Architecture:          x86_64
CPU op-mode(s):        32-bit, 64-bit
...

Otro comando útil para una fácil determinación es el siguiente:

Mando:

getconf LONG_BIT

Responder:

• 32, si el sistema operativo es de 32 bits
• 64, si el sistema operativo es de 64 bits

El comando

$ arch    

es equivalente a

$ uname -m

pero es el doble de rápido para escribir

Me preguntaba sobre esto específicamente para construir software en Debian (el sistema Debian instalado puede ser una versión de 32 bits con un núcleo de 32 bits, bibliotecas, etc., o puede ser una versión de 64 bits con material compilado para 64- bit en lugar del modo de compatibilidad de 32 bits).

Los paquetes Debian necesitan saber para qué arquitectura son (por supuesto) cuando realmente crean el paquete con todos sus metadatos, incluida la arquitectura de la plataforma, por lo que hay una herramienta de empaque que lo genera para que otras herramientas de empaque y scripts lo usen, llamado dpkg-architecture . Incluye tanto para qué está configurado para construir, como el host actual. (Normalmente, estos son los mismos). Ejemplo de salida en una máquina de 64 bits:

DEB_BUILD_ARCH=amd64
DEB_BUILD_ARCH_OS=linux
DEB_BUILD_ARCH_CPU=amd64
DEB_BUILD_GNU_CPU=x86_64
DEB_BUILD_GNU_SYSTEM=linux-gnu
DEB_BUILD_GNU_TYPE=x86_64-linux-gnu
DEB_HOST_ARCH=amd64
DEB_HOST_ARCH_OS=linux
DEB_HOST_ARCH_CPU=amd64
DEB_HOST_GNU_CPU=x86_64
DEB_HOST_GNU_SYSTEM=linux-gnu
DEB_HOST_GNU_TYPE=x86_64-linux-gnu

Puede imprimir solo una de esas variables o hacer una prueba con sus valores con opciones de línea de comando para dpkg -architecture.

No tengo idea de cómo dpkg-architecture deduce la arquitectura, pero podría ver su documentación o código fuente (dpkg-architecture y gran parte del sistema dpkg en general son Perl).

#include <stdio.h>

int main(void)
{
    printf("%d\n", __WORDSIZE);
    return 0;
}

Si tiene un sistema operativo de 64 bits, en lugar de i686, tiene x86_64o ia64en la salida de uname -a. En eso no tienes ninguna de estas dos cadenas; tiene un sistema operativo de 32 bits (tenga en cuenta que esto no significa que su CPU no sea de 64 bits).

Ese sistema es de 32 bits. iX86 en unamesignifica que es una arquitectura de 32 bits. Si fuera de 64 bits, volvería

Linux mars 2.6.9-67.0.15.ELsmp #1 SMP Tue Apr 22 13:50:33 EDT 2008 x86_64 i686 x86_64 x86_64 GNU/Linux

Hoy en día, un sistema puede ser multiarch, por lo que no tiene sentido de todos modos. Es posible que desee encontrar el destino predeterminado del compilador:

$ cc -v 2> y 1 | grep ^ Target
Destino: x86_64-pc-linux-gn

Puedes intentar compilar un hola mundo:

$ echo 'int main () {return 0; } '| cc -xc - -o foo
$ file foo
foo: ELF ejecutable LSB de 64 bits, x86-64, versión 1 (SYSV), vinculado dinámicamente, intérprete /lib64/ld-linux-x86-64.so.2, para GNU / Linux 2.6.32, BuildID [sha1] = b114e029a08abfb3c98db93d3dcdb7435b5bba0c, no despojado

Con respecto a la respuesta "getconf LONG_BIT" .

Escribí una función simple para hacerlo en 'C':

/*
 * check_os_64bit
 *
 * Returns integer:
 *   1 = it is a 64-bit OS
 *   0 = it is NOT a 64-bit OS (probably 32-bit)
 *   < 0 = failure
 *     -1 = popen failed
 *     -2 = fgets failed
 *
 * **WARNING**
 * Be CAREFUL! Just testing for a boolean return may not cut it
 * with this (trivial) implementation! (Think of when it fails,
 * returning -ve; this could be seen as non-zero & therefore true!)
 * Suggestions?
 */
static int check_os_64bit(void)
{
    FILE *fp=NULL;
    char cb64[3];

    fp = popen ("getconf LONG_BIT", "r");
    if (!fp)
       return -1;

    if (!fgets(cb64, 3, fp))
        return -2;

    if (!strncmp (cb64, "64", 3)) {
        return 1;
    }
    else {
        return 0;
    }
}

Buena idea, el 'getconf'!

También puede verificar usando una variable de entorno:

echo $HOSTTYPE

Resultado:

i386 -> 32 bits

x86_64 -> 64 bits

Extraído de: http://www.sysadmit.com/2016/02/linux-como-saber-si-es-32-o-64-bits.html

En Bash, usando el desbordamiento de enteros:

if ((1 == 1<<32)); then
  echo 32bits
else
  echo 64bits
fi

Es mucho más eficiente que invocar otro proceso o abrir archivos.

getconf usa la menor cantidad de llamadas al sistema:

$ strace getconf LONG_BIT | wc -l
253

$ strace arch | wc -l
280

$ strace uname -m | wc -l
281

$ strace grep -q lm /proc/cpuinfo | wc -l
301

Si desplaza 1 a la izquierda por 32 y obtiene 1, su sistema es de 32 bits. Si desplaza 1 a la izquierda por 64 y obtiene 1, su sistema es de 64 bits.

En otras palabras,

if echo $((1<<32)) gives 1 then your system is 32 bit.

if echo $((1<<64)) gives 1 then your system is 64 bit.

Si uno está severamente limitado en binarios disponibles (por ejemplo, en initramfs), mis colegas sugirieron:

$ ls -l /lib*/ld-linux*.so.2

En mis sistemas ALT Linux, i586 tiene /lib/ld-linux.so.2y x86_64 tiene /lib64/ld-linux-x86-64.so.2.

$ grep "CONFIG_64" /lib/modules/*/build/.config
# CONFIG_64BIT is not set

No puedo creer que en todo este tiempo, nadie haya mencionado:

sudo lshw -class cpu

para obtener detalles sobre la velocidad, cantidad, tamaño y capacidades del hardware de la CPU.

Script simple para obtener 64 bits o 32 bits

        if $(getconf LONG_BIT | grep '64'); then
           echo "64 bit system"
        else
            echo "32 bit system"
        fi

[ -z `uname -m | grep 64` ] && echo "32-bit" || echo "64-bit"

Basado en el hecho de que generalmente es de 64 bits x86_64y de 32 bits, i686etc.

Primero tienes que descargar Virtual Box. Luego seleccione nuevo y un Linux de 32 bits. Luego arranque el linux usándolo. Si arranca, entonces es de 32 bits, si no es así, es de 64 bits.