web-dev-qa-db-fra.com

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

Lorsque je tape uname -a, il génère le résultat suivant.

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 scripts configure, par exemple: pour quelle architecture suis-je en train de construire?

linuxshell32bit-64bitprocessor
466
Swapnonil Mukherjee

Essayez uname -m . Ce qui est proche de _uname --machine_ et il affiche:

_x86_64 ==> 64-bit kernel
i686   ==> 32-bit kernel
_

Sinon, pas pour le noyau Linux, mais pour le processeur , 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, l'un s'appelle lm: _Long Mode_ ( x86-64 : AMD64, également appelé Intel 64, c'est-à-dire compatible 64 bits)

_lm ==> 64-bit processor
_

Ou en utilisant lshw (comme mentionné ci-dessous par Rolf de Saxe ), sans Sudo (juste pour greping le cpu largeur):

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

Remarque: vous pouvez avoir un processeur 64 bits avec un noyau 32 bits installé .
(as ysdx mentionne dans sa propre réponse , "De nos jours, un système peut être multiarch donc cela n’a aucun sens. Vous voulez peut-être trouver la cible par défaut du compilateur ")

731
VonC

Si vous utilisiez une plate-forme 64 bits, vous verriez x86_64 ou quelque chose de très similaire dans la sortie de name -a

Pour obtenir le nom de votre matériel informatique spécifique

uname -m

Vous pouvez aussi appeler

getconf LONG_BIT

qui renvoie 32 ou 64

153
Thomas Watnedal

lscpu listera ces informations parmi d’autres informations concernant votre CPU:

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

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

Commander:

getconf LONG_BIT

Répondre:

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

La commande

$ Arch

est équivalent à

$ uname -m

mais est deux fois plus rapide à taper

12
Greg von Winckel
#include <stdio.h>

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

Je m'interrogeais à ce sujet en particulier pour la construction de logiciels sous Debian (le système Debian installé peut être une version 32 bits avec un noyau 32 bits, des bibliothèques, etc., ou une version 64 bits. avec des trucs compilés pour le mode de compatibilité 64 bits plutôt que 32 bits).

Les paquets Debian eux-mêmes ont besoin de savoir à quelle architecture ils appartiennent (bien sûr) quand 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 création de package qui le sort pour les autres outils de compression et scripts à utiliser. dpkg-architecture . Il inclut à la fois ce pour quoi il est configuré et celui de 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 faire un test de leurs valeurs avec les options de ligne de commande pour dpkg - architecture.

Je ne sais pas du tout comment 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 en Perl).

11
Reed Hedges

Si vous avez un système d'exploitation 64 bits, au lieu de i686, vous avez x86_64 ou ia64 dans la sortie de uname -a. En cela 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).

10
Denis R.

Ce système est 32bit. iX86 dans uname signifie 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
6
Louis Gerbarg

De nos jours, un système peut être multi-architecture, ce qui n’a aucun sens. 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 salut:

$ echo 'int main () {return 0; } '| cc -xc - -o foo 
 $ fichier foo 
 foo: ELF exécutable LSB 64 bits, x86-64, version 1 (SYSV), lié dynamiquement, interpréteur/lib64/ld-linux- x86-64.so.2, pour GNU/Linux 2.6.32, ID de construction [sha1] = b114e029a08abfb3c98db93d3dcdb7435b5bba0c, non mis à nu
6
ysdx

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
kaiwan

Vous pouvez également vérifier en utilisant 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

4
LinuxMaintwo

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
3
user5859111

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

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

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

3
Luchostein

Si vous passez de 1 à 32 et que vous obtenez 1, votre système est en 32 bits. Si vous décalez de 1 à 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.

2
Sandeep Giri

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
lakshmikandan
$ grep "CONFIG_64" /lib/modules/*/build/.config
# CONFIG_64BIT is not set
1
alex

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 de la CPU.

1
Rolf of Saxony

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

Basé sur le fait que 64 bits est généralement x86_64 et 32 ​​bits est i686 etc.

1
79man

Si l’un des fichiers binaires disponibles est extrêmement limité (par exemple, dans initramfs), mes collègues ont suggéré:

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

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

1
Michael Shigorin