web-dev-qa-db-fra.com

Comment déterminer l'architecture du noyau Linux?

uname -m donne i686 et uname -m donne la sortie i686 i386 sur la machine Red Hat Enterprise Linux Server version 5.4 (Tikanga). J'ai besoin d'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?

linuxcommand-linex86cpu-architecture
105
user2914

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

MODIFIER:
Voir mon Linux est-il ARM 32 ou 64 bits? pour ARM

99
Behrooz

C'est simple! Utilisez la commande Arch.

49
PHPst

@ behrooz est correct. Malheureusement, uname nécessite que vous connaissiez 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 avez un noyau Linux 64 bits en cours d'exécution. 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

Recherchez les éléments suivants dans la sortie (tous les indicateurs récupérés de cette réponse stackoverflow pour la même question)

  • lm flag signifie CPU en mode long - CPU 64 bits
  • tm flag signifie Mode protégé - CPU 32 bits
  • rm flag signifie Real Mode - CPU 16 bits
32
xenoterracide

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

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

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

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

21
Luchostein

Pour Debian:

Sur mon PC

 ~> dpkg --print-architecture 
 AMD64 

 ~> dpkg --print-foreign-architectures 
 i386

My Raspberry Pi 2

 ~> dpkg --print-architecture 
 armhf
18
Артем Телешев

Le moyen le plus simple est d'exécuter:

getconf LONG_BIT

qui sortira 64 ou 32 selon qu'il s'agit de 32 ou 64 bits.

par exemple:

dannyw@dannyw-redhat:~$ getconf LONG_BIT
64
13
dannyw

utiliser syscap de projet Formake

syscap permet de sonder de nombreuses propriétés système et de tester les dépendances. Il s'agit d'un script Shell portable.

Obtenez l'architecture CPU:

syscap info -Arch

Obtenez le nom et la version du noyau:

syscap info -kernel -kernver
2
Alex

Une autre façon 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
1
minaev

Ou vous pouvez utiliser la façon dont la commande name fait en interne si vous voulez 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;
}
0
Meow

Voici une autre méthode utilisant uname.

De man uname:

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

# uname -i x86_64#

0
clusterdude

Si vous cherchez un simple liner, c'est la solution la plus fiable que j'ai trouvée qui renvoie 64 ou 2. Peu importe que vous exécutiez ARM ou non, et cela devrait fonctionner sur n'importe quel système utilisant bash ou sh.

Attention, cela supposera que le système est soit 32 bits soit 64 bits. Voir mon explication ci-dessous si vous avez besoin de détecter une architecture 8-16 ou un autre bit. 

[$ ((0xffffffff)) -eq -1] && echo 32 || écho 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 n'a que 32 bits qu'elle peut utiliser pour stocker des entiers signés tandis qu'une architecture 64 bits a 64 bits! En d'autres termes, l'ensemble des entiers qui peuvent être stockés est fini. La moitié de cet ensemble représente des nombres négatifs et la moitié représente des nombres positifs. L'entier signé égal à -1 est représenté comme 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 est de 32 bits binaires, tous égaux à 1). Sur un système 64 bits, 0xFFFFFFFF se traduit par 4 294 967 295, base 10 tandis que 0xFFFFFFFFFFFFFFFF est la représentation de -1). Vous pouvez voir comment cela évoluerait facilement pour les systèmes 8 ou 16 bits, ce qui équivaudrait à -1 à 0xFF et 0xFFFF, respectivement.

0
b_laoshi