¿Cómo determinar la arquitectura del kernel de Linux?

uname -mda i686 y uname -mda salida i686 i386 en la máquina Red Hat Enterprise Linux Server versión 5.4 (Tikanga). Necesito instalar Oracle Database 10g Release 2 en esa máquina. Entonces, ¿cómo puedo decidir si la arquitectura del núcleo es de 32 bits o de 64 bits?

i386 e i686 son ambos de 32 bits.
x86_64 es de 64 bits

ejemplo para 64 bit:

behrooz@behrooz:~$ uname -a  
Linux behrooz 2.6.32-5-amd64 #1 SMP Mon Mar 7 21:35:22 UTC 2011 **x86_64** GNU/Linux

EDITAR: ¿
Ves mi linux ARM de 32 o 64 bits? para BRAZO

¡Es sencillo! Usa el archcomando.

@behrooz es correcto. Lamentablemente unamerequiere que sepas arquitecturas. En realidad, estaba buscando una lista de arquitecturas y encontré este artículo que responde a su pregunta. En cuanto a uname -m:

x86_64 GNU / Linux indica que tiene un núcleo Linux de 64 bits en ejecución. Si usa ver i386 / i486 / i586 / i686, es un kernel de 32 bits.

Para determinar si el hardware es capaz de ejecutar un núcleo de 64 bits

grep flags /proc/cpuinfo

Busque lo siguiente en la salida (todas las banderas recuperadas de esta respuesta de stackoverflow para la misma pregunta)

• lm bandera significa CPU de modo largo - CPU de 64 bits
• tm bandera significa modo protegido - CPU de 32 bits
• rm la bandera significa Modo Real - CPU de 16 bits

(EDITAR: esta respuesta es INCORRECTA. Gracias al comentario de @ Lizardx)

En Bash, usando el desbordamiento de enteros:

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

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

Para Debian :

En mi PC

    ~> dpkg --print-architecture
    amd64

    ~> dpkg --print-foreign-architectures
    i386

Mi frambuesa pi 2

    ~> dpkg --print-architecture
    armhf

La forma más simple es ejecutar:

getconf LONG_BIT

que generará 64 o 32 dependiendo de si es de 32 o 64 bits.

p.ej:

dannyw@dannyw-redhat:~$ getconf LONG_BIT
64

usar syscap del proyecto Formake

syscap permite probar muchas propiedades del sistema y probar dependencias. Es un script de shell portátil.

Obtener arquitectura de CPU:

syscap info -arch

Obtenga el nombre y la versión del kernel:

syscap info -kernel -kernver

Otra forma es verificar la arquitectura para la que se compiló un archivo de sistema, como

$ file /usr/bin/ld
/usr/bin/ld: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.15, stripped

O puede usar la forma de lo que hace internamente el comando uname si desea implementar algunas cosas por su cuenta:

#include <sys/utsname.h>
#include <stdio.h>

int main() {
    struct utsname name;
    uname(&name);
    printf("%s\n",name.machine);
    return 0;
}

Aquí hay otro método usando uname.

De man uname:

... -i, --hardware-platform print the hardware platform or "unknown" ...

# uname -i x86_64 #

Si está buscando una línea simple, esta es la solución más confiable que he encontrado que devuelve 64 o 32 . No le importa si está ejecutando ARM o no, y debería funcionar en cualquier sistema que use bash o sh .

Cuidado, esto supondrá que el sistema es de 32 bits o de 64 bits. Vea mi explicación a continuación si necesita detectar una arquitectura de 8-16 o algún otro tipo de arquitectura.

[$ ((0xffffffff)) -eq -1] && echo 32 || echo 64

¿Qué pasa aquí?
La lógica es muy simple y todo se reduce a cómo las computadoras almacenan enteros firmados. ¡Una arquitectura de 32 bits solo tiene 32 bits que puede usar para almacenar enteros con signo, mientras que una arquitectura de 64 bits tiene 64 bits! En otras palabras, el conjunto de enteros que se pueden almacenar es finito. La mitad de este conjunto representa números negativos y la otra mitad representa números positivos. El entero con signo igual a -1 se representa como el número más grande que se puede almacenar en un número dado de bits para esa arquitectura. En un sistema de 32 bits, -1 puede representarse por el valor hexadecimal 0xFFFFFFFF (que es 32 bits binarios, todos iguales a 1). En un sistema de 64 bits, 0xFFFFFFFF se traduce en 4,294,967,295, base 10, mientras que 0xFFFFFFFFFFFFFFFF es la representación de -1). Puede ver cómo esto se escalaría fácilmente para sistemas de 8 o 16 bits que serían iguales a -1 en 0xFF y 0xFFFF,