Como determinar se um determinado Linux é de 32 ou 64 bits?

Quando digito uname -a, ele fornece a seguinte saída.

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

Como posso saber com isso que o sistema operacional fornecido é 32 ou 64 bits?

Isso é útil ao escrever configurescripts, por exemplo: para qual arquitetura estou construindo?

Tente uname -m. Qual é curto uname --machinee produz:

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

Caso contrário, não para o kernel do Linux, mas para a CPU , você digita:

cat /proc/cpuinfo

ou:

grep flags /proc/cpuinfo

No parâmetro "flags", você verá vários valores: consulte " O que significam os sinalizadores em / proc / cpuinfo? " Entre eles, um é nomeado lm: Long Mode( x86-64 : amd64, também conhecido como Intel 64, ou seja, 64 bits capaz)

lm ==> 64-bit processor

Ou usandolshw (como mencionado abaixo por Rolf da Saxônia ), sem sudo(apenas para manter a largura da CPU):

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

Nota: você pode ter uma CPU de 64 bits com um kernel de 32 bits instalado .
(como ysdx menciona em sua própria resposta : "Atualmente, um sistema pode ser multiarca, para que não faça sentido de qualquer maneira. Você pode encontrar o destino padrão do compilador")

Se você estivesse executando uma plataforma de 64 bits, veria x86_64 ou algo muito semelhante na saída de uname -a

Para obter o nome específico do hardware da sua máquina, execute

uname -m

Você também pode ligar

getconf LONG_BIT

que retorna 32 ou 64

lscpu listará estas entre outras informações sobre sua CPU:

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

Outro comando útil para facilitar a determinação é o seguinte:

Comando:

getconf LONG_BIT

Responda:

• 32, se o SO for 32 bits
• 64, se o SO for 64 bits

O comando

$ arch    

é equivalente a

$ uname -m

mas é duas vezes mais rápido para digitar

Eu estava pensando sobre isso especificamente para a construção de software no Debian (o sistema Debian instalado pode ser uma versão de 32 bits com um kernel de 32 bits, bibliotecas etc.) ou pode ser uma versão de 64 bits com material compilado para o sistema 64-bit. em vez do modo de compatibilidade de 32 bits).

Os próprios pacotes Debian precisam saber para qual arquitetura eles são (é claro) quando eles realmente criam o pacote com todos os seus metadados, incluindo a arquitetura da plataforma, para que exista uma ferramenta de empacotamento que o produza para outras ferramentas e scripts de empacotamento, chamados arquitetura dpkg . Inclui tanto o que ele está configurado para construir, quanto o host atual. (Normalmente, eles são os mesmos.) Exemplo de saída em uma máquina de 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

Você pode imprimir apenas uma dessas variáveis ​​ou fazer um teste em relação a seus valores com as opções de linha de comando para dpkg -architecture.

Não tenho idéia de como o dpkg-architecture deduz a arquitetura, mas você pode ver a documentação ou o código fonte (dpkg-architecture e grande parte do sistema dpkg em geral são Perl).

#include <stdio.h>

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

Se você possui um sistema operacional de 64 bits, em vez do i686, possui x86_64ou ia64na saída de uname -a. Na medida em que você não possui nenhuma dessas duas strings; você possui um sistema operacional de 32 bits (observe que isso não significa que sua CPU não é de 64 bits).

Esse sistema é de 32 bits. iX86 in unamesignifica que é uma arquitetura de 32 bits. Se fosse de 64 bits, retornaria

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

Atualmente, um sistema pode ser multiarca, por isso não faz sentido. Você pode encontrar o destino padrão do compilador:

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

Você pode tentar compilar um olá mundo:

$ echo 'int main () {retorno 0; } '| cc -xc - -o foo
$ file foo
foo: Executável ELF de 64 bits LSB, x86-64, versão 1 (SYSV), vinculado dinamicamente, intérprete /lib64/ld-linux-x86-64.so.2, para GNU / Linux 2.6.32, BuildID [sha1] = b114e029a08abfb3c98db93d3dcdb7435b5bba0c, não retirado

Com relação à resposta "getconf LONG_BIT" .

Eu escrevi uma função simples para fazê-lo em '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;
    }
}

Boa ideia, o 'getconf'!

Você também pode verificar usando uma variável de ambiente:

echo $HOSTTYPE

Resultado:

i386 -> 32 bits

x86_64 -> 64 bits

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

No Bash, usando excesso de número inteiro:

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

É muito mais eficiente do que invocar outro processo ou abrir arquivos.

O getconf usa o menor número de chamadas do sistema:

$ 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

Se você alternar 1 deixado por 32 e você obtém 1, seu sistema é de 32 bits. Se você alternar 1 deixado por 64 e obtiver 1, seu sistema será de 64 bits.

Em outras palavras,

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

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

Se alguém está severamente limitado nos binários disponíveis (por exemplo, no initramfs), meus colegas sugeriram:

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

Nos meus sistemas ALT Linux, o i586 possui /lib/ld-linux.so.2e o x86_64 possui /lib64/ld-linux-x86-64.so.2.

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

Não acredito que, durante todo esse tempo, ninguém tenha mencionado:

sudo lshw -class cpu

para obter detalhes sobre a velocidade, quantidade, tamanho e recursos do hardware da CPU.

Script simples para obter 64 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"

Com base no fato de que 64 bits é geralmente x86_64e 32 bits é i686etc.

Primeiro você precisa baixar o Virtual Box. Em seguida, selecione um novo e um Linux de 32 bits. Então inicie o linux usando-o. Se inicializar, será de 32 bits, se não for, será de 64 bits.