Comment déterminer l'architecture du noyau Linux?

uname -mdonne i686 et uname -mi686 en sortie sur la machine Red Hat Enterprise Linux Server version 5.4 (Tikanga). Je dois installer Oracle Database 10g Release 2 sur cette machine. Alors, comment puis-je décider si l'architecture du noyau est 32 bits ou 64 bits?

i386 et i686 sont tous deux 32 bits.
x86_64 est 64 bits

exemple pour 64 bits:

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

EDIT:
Voir est mon linux ARM 32 ou 64 bits? pour ARM

C'est simple! Utilisez la archcommande.

@ Behrooz est correct. Malheureusement, unamevous devez connaître les architectures. En fait, je cherchais une liste d'architectures et j'ai trouvé cet article qui répond à votre question. En ce qui concerne uname -m:

x86_64 GNU / Linux indique que vous utilisez un noyau Linux 64 bits. Si vous utilisez, voir i386 / i486 / i586 / i686, il s’agit d’un noyau 32 bits.

Pour déterminer si le matériel est capable d'exécuter un noyau 64 bits

grep flags /proc/cpuinfo

Cherchez ce qui suit dans la sortie (tous les drapeaux extraits de cette réponse de stackoverflow répondent à la même question)

• lm indicateur signifie cpu en mode long - CPU 64 bits
• tm indicateur signifie mode protégé - CPU 32 bits
• rm drapeau signifie mode réel - CPU 16 bits

(EDIT: cette réponse est fausse. Merci au commentaire de @ Lizardx)

Dans Bash, en utilisant un dépassement d'entier:

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

C'est beaucoup plus efficace que d'invoquer un autre processus ou d'ouvrir des fichiers.

Pour Debian :

Sur mon pc

    ~> dpkg --print-architecture
    amd64

    ~> dpkg --print-foreign-architectures
    i386

Mon Raspberry Pi 2

    ~> dpkg --print-architecture
    armhf

Le moyen le plus simple consiste à exécuter:

getconf LONG_BIT

qui affichera 64 ou 32 en fonction du format 32 ou 64 bits.

par exemple:

dannyw@dannyw-redhat:~$ getconf LONG_BIT
64

utiliser syscap à partir du projet Formake

syscap permet de sonder de nombreuses propriétés système et de tester des dépendances. C'est un script shell portable.

Obtenir l'architecture du processeur:

syscap info -arch

Obtenez le nom du noyau et la version:

syscap info -kernel -kernver

Une autre méthode consiste à vérifier l’architecture pour laquelle un fichier système a été compilé, comme

$ 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

Ou vous pouvez utiliser le même principe que la commande uname en interne si vous souhaitez implémenter vous-même certaines choses:

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

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

Voici une autre méthode utilisant uname.

De man uname:

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

# uname -i x86_64 #

Si vous recherchez une solution simple, cette solution est la plus fiable à ce jour et renvoie 64 ou 32 . Peu importe que vous utilisiez ARM ou non, et cela devrait fonctionner sur tout système utilisant bash ou sh .

Attention, cela suppose que le système est en 32 bits ou en 64 bits. Voir l'explication ci-dessous si vous devez détecter une architecture 8-16 ou autre.

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

Qu'est-ce qui se passe ici?
La logique est très simple et tout se résume à la façon dont les ordinateurs stockent les entiers signés. Une architecture 32 bits ne comporte que 32 bits et peut être utilisée pour stocker des entiers signés, alors qu'une architecture 64 bits en a 64! En d'autres termes, l'ensemble des entiers pouvant être stockés est fini. La moitié de cet ensemble représente des nombres négatifs et l'autre moitié des nombres positifs. L'entier signé égal à -1 est représenté par le plus grand nombre pouvant être stocké dans un nombre donné de bits pour cette architecture. Sur un système 32 bits, -1 peut être représenté par la valeur hexadécimale 0xFFFFFFFF (qui correspond à 32 bits binaires, tous égaux à 1). Sur un système 64 bits, 0xFFFFFFFF correspond à 4 294 967 295, base 10, tandis que 0xFFFFFFFFFFFFFFFF correspond à la représentation de -1). Vous pouvez voir comment cela évoluerait facilement pour les systèmes de 8 ou 16 bits égaux à -1 en 0xFF et 0xFFFF,