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

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?

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")

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

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

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

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

La commande

$ arch    

est équivalent à

$ uname -m

mais est deux fois plus rapide à taper

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).

#include <stdio.h>

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

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).

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

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é

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»!

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

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.

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

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.

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.

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

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.

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

[ -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.

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.