desenv-web-rp.com

Como determinar a arquitetura do kernel do Linux?

uname -m fornece i686 e uname -m fornece saída para i686 i386 na máquina do Red Hat Enterprise Linux Server versão 5.4 (Tikanga). Preciso instalar o Oracle Database 10g Release 2 nessa máquina. Então, como posso decidir se a arquitetura do kernel é 32 bits ou 64 bits?

105
user2914

i386 e i686 são ambos de 32 bits.
x86_64 é de 64 bits

exemplo para 64 bits:

[email protected]:~$ uname -a  
Linux behrooz 2.6.32-5-AMD64 #1 SMP Mon Mar 7 21:35:22 UTC 2011 **x86_64** GNU/Linux

EDIT:
Veja é meu linux ARM 32 ou 64 bits? para ARM

99
Behrooz

É simples! Use o comando Arch.

49
PHPst

@ behrooz está correto. Infelizmente uname requer que você conheça arquiteturas. Na verdade, eu estava procurando uma lista de arquiteturas e encontrei este artigo que responde à sua pergunta. Em relação a uname -m:

x86_64 GNU/Linux indica que você tem um kernel Linux de 64 bits em execução. Se você usar, consulte i386/i486/i586/i686, é um kernel de 32 bits.

Para determinar se o hardware é capaz de executar um kernel de 64 bits

grep flags /proc/cpuinfo

Procure o seguinte na saída (todos os sinalizadores recuperados de esta resposta do stackoverflow para a mesma pergunta)

  • lm flag significa CPU no modo Longo - CPU de 64 bits
  • tm flag significa modo protegido - CPU de 32 bits
  • rm flag significa Modo Real - CPU de 16 bits
32
xenoterracide

(EDIT: esta resposta está errada. Obrigado ao comentário de @ Lizardx)

No Bash, usando excesso de número inteiro:

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

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

21
Luchostein

Para Debian:

No meu PC

 ~> dpkg --print-architecture 
 AMD64 
 ~> dpkg --print-estrangeiras-arquiteturas 
 i386 

My Raspberry Pi 2

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

A maneira mais simples é executar:

getconf LONG_BIT

que produzirá 64 ou 32, dependendo de 32 ou 64 bits.

por exemplo:

[email protected]:~$ getconf LONG_BIT
64
13
dannyw

use syscap de projeto Formake

syscap permite analisar muitas propriedades do sistema e testar dependências. É um script portátil do Shell.

Obtenha arquitetura da CPU:

syscap info -Arch

Obtenha o nome e a versão do kernel:

syscap info -kernel -kernver
2
Alex

Outra maneira é verificar a arquitetura para a qual um arquivo de sistema foi compilado, como

$ 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 você pode usar a maneira como o comando name internamente faz se você deseja implementar algumas coisas por conta própria:

#include <sys/utsname.h>
#include <stdio.h>

int main() {
    struct utsname name;
    uname(&name);
    printf("%s\n",name.machine);
    return 0;
}
0
Meow

Aqui está outro método usando uname.

De man uname:

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

# uname -i x86_64#

0
clusterdude

Se você está procurando uma linha única, essa é a solução mais confiável que eu descobri que retorna 64 ou 2. Não importa se você está executando o ARM ou não, e deve funcionar em qualquer sistema usando bash ou sh.

Cuidado, isso pressupõe que o sistema seja de 32 ou 64 bits. Veja minha explicação abaixo se você precisar detectar a arquitetura 8-16 ou algum outro bit.

[$ ((0xffffffff)) -eq -1] && eco 32 || eco 64

O que está acontecendo aqui?
A lógica é muito simples e tudo se resume a como os computadores armazenam números inteiros assinados. Uma arquitetura de 32 bits possui apenas 32 bits que pode ser usada para armazenar números inteiros assinados, enquanto uma arquitetura de 64 bits possui 64 bits! Em outras palavras, o conjunto de números inteiros que podem ser armazenados é finito. Metade deste conjunto representa números negativos e metade representa números positivos. O número inteiro assinado igual a -1 é representado como o maior número que pode ser armazenado em um determinado número de bits para essa arquitetura. Em um sistema de 32 bits, -1 pode ser representado pelo valor hexadecimal 0xFFFFFFFF (que é de 32 bits binários, todos iguais a 1). Em um sistema de 64 bits, 0xFFFFFFFF converte para 4.294.967.295, base 10, enquanto 0xFFFFFFFFFFFFFFFFFF é a representação para -1). Você pode ver como isso seria facilmente dimensionado para sistemas de 8 ou 16 bits, que seriam iguais a -1 em 0xFF e 0xFFFF, respectivamente.

0
b_laoshi