Comment déterminer si un Linux donné est 32 bits ou 64 bits?


470

Lorsque je tape uname -a, cela donne la sortie suivante.

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

Comment puis-je savoir à partir de cela que le système d'exploitation donné est 32 ou 64 bits?

Ceci est utile lors de l'écriture de configurescripts, par exemple: pour quelle architecture suis-je en train de construire?

Réponses:


735

Essayez uname -m. Ce qui est court uname --machineet il produit:

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

Sinon, pas pour le noyau Linux, mais pour le CPU , vous tapez:

cat /proc/cpuinfo

ou:

grep flags /proc/cpuinfo

Sous le paramètre "flags", vous verrez différentes valeurs: voir " Que signifient les drapeaux dans / proc / cpuinfo? " Parmi eux, un est nommé lm: Long Mode( x86-64 : amd64, également connu sous le nom d'Intel 64, c'est-à-dire 64 bits capable)

lm ==> 64-bit processor

Ou en utilisantlshw (comme mentionné ci - dessous par Rolf de Saxe ), sans sudo(juste pour saluer la largeur du processeur):

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

Remarque: vous pouvez avoir un processeur 64 bits avec un noyau 32 bits installé .
(comme ysdx le mentionne dans sa propre réponse , "De nos jours, un système peut être multiarchitecture donc cela n'a pas de sens de toute façon. Vous voudrez peut-être trouver la cible par défaut du compilateur")


3
grep flags / proc / cpuinfo vous indique uniquement si le CPU est 64 bits. Si je comprends bien, il s'agissait de l'OS. uname -m ne me dit que "i686".
Kim Stebel

3
J'ai un noyau 32 bits sur du matériel 64 bits et j'obtiens "x86_64" de 'uname -m' (sur Debian). La page de manuel pour uname indique que -m affiche le nom du matériel de la machine, donc cela semble correct.
Tony Meyer

1
Si j'ai un noyau 32 bits sur une machine 64 bits / processeur, ce qui serait uname -i, uname -pet uname -mspectacle?
ruben2020

4
que faire si tm et lm sont tous les deux présents?
Javier Novoa C.

4
@JavierNovoaC. tm (Thermal Monitor) indique le contrôle automatique de l'horloge. Cela n'a rien à voir avec la distinction d'un processeur 32 bits. En fait, lm (mode long) est présent si et seulement si vous avez un processeur 64 bits. C'est pourquoi vous ne devriez compter que sur lm. sinon la réponse donnée par Thomas Watnedal est la meilleure. Cette réponse est tout simplement fausse et a induit en erreur de nombreuses personnes.
Issam T.

153

Si vous exécutiez une plate-forme 64 bits, vous verriez x86_64 ou quelque chose de très similaire dans la sortie d' uname -a

Pour exécuter le nom du matériel de votre machine spécifique

uname -m

Vous pouvez également appeler

getconf LONG_BIT

qui renvoie 32 ou 64


4
uname -msorties x86_64 getconf LONG_BITsorties 32Laquelle est correcte ?? : \
Stephan

10
Cela signifie que le processeur est en 64 bits, mais vous n'y avez installé qu'un système d'exploitation 32 bits, même si vous auriez pu en utiliser un en 64 bits.

1
Steve Kemp a raison, alors soyez prudent (Mac OS X 10.5 sur MacBook 2009 vient à l'esprit, où le système d'exploitation est 32 bits mais est capable d'exécuter des applications 64 bits)
Jww

1
Le uname -mn'est pas utile pour les QP configurecar il peut donner le mauvais résultat. L' getconf LONG_BITobtenir la taille de bits par défaut de la bibliothèque C qui peut ne pas être la bonne taille pour une spécifiée, par CC, compilateur.
user3710044

2
getconf LONG_BITpeut fournir 32 ig, il a été conçu comme une application 32 bits (généralement un noyau 64 bits exécutant un espace utilisateur 32 bits).
ysdx

42

lscpu énumérera ces informations parmi d'autres concernant votre CPU:

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

3
Génère les capacités physiques du CPU, utiles, mais pas fiables pour l'espace utilisateur actuel du système d'exploitation actuel.
user3710044

33

Une autre commande utile pour une détermination facile est la suivante:

Commander:

getconf LONG_BIT

Réponse:

  • 32, si le système d'exploitation est 32 bits
  • 64, si le système d'exploitation est 64 bits

2
Pas vrai dans le cas de HP-UX 11.31i sur Itanium 64: cette commande renvoie 32.
Gabriel Hautclocq

Je suppose que tout dépend de ce que le questionneur entend par "64 bits" - cela signifiait la taille naturelle des entiers, mais il est maintenant souvent utilisé pour désigner la taille d'adressage à la place.
Toby Speight

12

La commande

$ arch    

est équivalent à

$ uname -m

mais est deux fois plus rapide à taper


2
D'accord, mais je suis sûr que la vitesse de frappe n'est pas un problème pour la plupart des développeurs.
williamcarswell

2
Cela renvoie les types de processus que le noyau peut prendre en charge. Il est possible et même raisonnable d'exécuter un espace utilisateur 32 bits sur un noyau 64 bits.
user3710044

1
La commande arch n'est pas disponible sur tous les systèmes Unix, alors que uname devrait l'être.
Gabriel Hautclocq

11

Je me posais des questions à ce sujet spécifiquement pour la construction de logiciels dans Debian (le système Debian installé peut être une version 32 bits avec un noyau 32 bits, des bibliothèques, etc., ou il peut s'agir d'une version 64 bits avec des éléments compilés pour le 64- bits plutôt que le mode de compatibilité 32 bits).

Les paquets Debian eux-mêmes ont besoin de savoir à quelle architecture ils sont destinés (bien sûr) lorsqu'ils créent réellement le paquet avec toutes ses métadonnées, y compris l'architecture de la plate-forme, il existe donc un outil de paquetage qui le produit pour d'autres outils et scripts de paquetage à utiliser, appelé dpkg-architecture . Il comprend à la fois ce pour quoi il est configuré pour construire, ainsi que l'hôte actuel. (Normalement, ce sont les mêmes.) Exemple de sortie sur une machine 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

Vous pouvez imprimer une seule de ces variables ou effectuer un test par rapport à leurs valeurs avec les options de ligne de commande dans dpkg -architecture.

Je n'ai aucune idée de la façon dont dpkg-architecture déduit l'architecture, mais vous pouvez consulter sa documentation ou son code source (dpkg-architecture et une grande partie du système dpkg en général sont Perl).


Vous pouvez simplement utiliser: dpkg --architecturepour obtenir l'architecture du système hôte, qui ne nécessite pas l' dpkg-devinstallation du package.
Mark Longair

Cela produit dpkg: error: unknown option --architecturepour dpkg 1.17.5ubuntu de 14.04. dpkg-architecture (avec dpkg-dev installé) fonctionne bien cependant.
timurb

2
La commande dpkg --print-architecturefonctionne sur Debian depuis toujours. Celui-ci fonctionne mais est limité à Debian et ses dérivés.
user3710044

11
#include <stdio.h>

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

2
Fonctionne mais semble être un détail d'implémentation de stdio.h sous Linux, de meilleures solutions existent, par exemple: limits.h, NE PAS UTILISER.
user3710044

10

Si vous avez un système d'exploitation 64 bits, au lieu de i686, vous avez x86_64ou ia64dans la sortie de uname -a. En ce que vous n'avez aucune de ces deux chaînes; vous avez un système d'exploitation 32 bits (notez que cela ne signifie pas que votre processeur n'est pas 64 bits).


1
Cela renvoie les types de processus que le noyau peut prendre en charge. Il est possible et même raisonnable d'exécuter un espace utilisateur 32 bits sur un noyau 64 bits.
user3710044

Il existe d'autres valeurs en unamesortie qui indiquent un système d'exploitation 64 bits. Tout le monde n'est pas un x86 ou Itanium ...
Toby Speight

6

Ce système est 32 bits. iX86 en unamesignifie qu'il s'agit d'une architecture 32 bits. Si c'était 64 bits, il reviendrait

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

1
Cela renvoie les types de processus que le noyau peut prendre en charge. Il est possible et même raisonnable d'exécuter un espace utilisateur 32 bits sur un noyau 64 bits.
user3710044

6

De nos jours, un système peut être multiarchitecture donc cela n'a pas de sens de toute façon. Vous voudrez peut-être trouver la cible par défaut du compilateur:

$ cc -v 2> & 1 | grep ^ Cible
Cible: x86_64-pc-linux-gn

Vous pouvez essayer de compiler un monde bonjour:

$ echo 'int main () {return 0; } '| cc -xc - -o foo
$ file foo
foo: exécutable ELF 64 bits LSB, x86-64, version 1 (SYSV), lié dynamiquement, interprète /lib64/ld-linux-x86-64.so.2, pour GNU / Linux 2.6.32, BuildID [sha1] = b114e029a08abfb3c98db93d3dcdb7435b5bba0c, non dénudé

1
Comme il cc -v | grep …est de toute façon spécifique au compilateur, on peut simplement l'utiliser cc -dumpmachine, ce qui ne nécessite pas de grepping et est pris en charge non seulement par GCC.
Anton Samsonov

Étant donné que la question suggère qu'il s'agit d'un script de configuration, c'est probablement la réponse la plus utile et la plus pertinente ici. Il fera ce que vous voulez dans tous les cas qui comptent (y compris un chroot utilisateur 32 bits sur un système d'exploitation 64 bits, une compilation croisée pour une architecture étrangère et le reste).
Toby Speight

5

En ce qui concerne la réponse "getconf LONG_BIT" .

J'ai écrit une fonction simple pour le faire 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;
    }
}

Bonne idée, le «getconf»!


5
Idée idiote! Utiliser CHAR_BIT*sizeof(void*)ou __WORDSIZEen C.
ceving

3
Non, ce n'est pas idiot. Vous pouvez avoir un exécutable 32 bits et vous voulez savoir si le système prend en charge un 64 bits, par exemple.
Ludvig A. Norin

Obtient la longueur par défaut d'un long dans la bibliothèque GNU-C .. celui-ci fonctionne!
user3710044

1
C'est en fait faux, car si vous exécutez un espace utilisateur 32 bits sur un noyau 64 bits, ou même un espace utilisateur X32, cela dira que le système d'exploitation est 32 bits.
Ruslan

Il est fortement recommandé de ne pas utiliser fgets: stackoverflow.com/questions/16323185/…
ceving

4

Vous pouvez également vérifier à l'aide d'une variable d'environnement:

echo $HOSTTYPE

Résultat:

i386 -> 32 bits

x86_64 -> 64 bits

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


1
Il s'agit d'une variable intégrée car /bin/bashce n'est pas une variable d'environnement. Si vous dépendez déjà de Bash, cela fonctionne très bien. Cependant, le résultat peut être i386, i486, i586, i686et d' autres donc soyez prudent.
user3710044

3

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

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

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


2
Bash est (peut être?) Compilé pour utiliser des entiers 64 bits si ce type est disponible, il l'est généralement de nos jours et donc les systèmes 32 bits utiliseront normalement le type "long long"
user3710044

2
bash dans Debian a été compilé pour utiliser l'arithmétique 64 bits depuis 2008 au plus tard, probablement plus tôt que cela. Cette réponse a été rompue depuis avant que stackoverflow n'existe.
Peter Cordes

3

getconf utilise le moins d'appels système:

$ 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

2

Si vous décalez 1 de gauche de 32 et que vous obtenez 1, votre système est de 32 bits. Si vous décalez 1 de gauche de 64 et que vous obtenez 1, votre système est en 64 bits.

En d'autres termes,

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

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


Même problème avec bash en utilisant des "longs longs".
user3710044

Cela a fonctionné pour moi, car s'il renvoie 32 bits, il est 100% confirmé en exécutant 32. S'il retourne 64, peut-être que bash a été compilé avec de longs longs.
JCM

1

Si l'un est sévèrement limité dans les binaires disponibles (par exemple dans initramfs), mes collègues ont suggéré:

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

Sur mes systèmes ALT Linux, i586 a /lib/ld-linux.so.2et x86_64 a /lib64/ld-linux-x86-64.so.2.


J'en ai TROIS de ceux-ci, un pour 32, un pour 64 et un pour mx32.
user3710044

Oui, s'il ne retourne pas des tonnes de bibliothèques 64 bits, alors il exécute un système d'exploitation 32 bits: ls -aR | grep 64 | grep -v proc
JCM

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

J'ai deux lignes, une avec elle, une sans.
user3710044

1

Je ne peux pas croire que pendant tout ce temps, personne n'a mentionné:

sudo lshw -class cpu

pour obtenir des détails sur la vitesse, la quantité, la taille et les capacités du matériel CPU.


1

Script simple pour obtenir 64 bits ou 32 bits

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

1

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

Basé sur le fait que 64 bits est généralement x86_64et 32 ​​bits est i686etc.


-6

Vous devez d'abord télécharger Virtual Box. Sélectionnez ensuite un nouveau et un Linux 32 bits. Ensuite, démarrez Linux en l'utilisant. S'il démarre, il est de 32 bits, sinon, il est de 64 bits.


2
Il s'agit d'une façon très farfelue de déterminer si le système est 32 ou 64 bits.
marlar

Mais c'est vraiment un moyen de résoudre ce problème. Je vais donc le marquer.
firo

Cela me rappelle une façon de distinguer les nombres pairs des nombres impairs: une mathématique regarderait le reste après l'avoir divisé par deux; un programmeur regarderait le bit le moins significatif; un spécialiste de MS SQL créerait deux tables, une pour les nombres pairs et l'autre pour les impaires, et chercherait où finit l'entrée ... chiffres
Michael Shigorin
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.