How to determine Linux kernel architecture?

Question

uname -m gives i686 and uname -m gives i686 i386 output in Red Hat Enterprise Linux Server release 5.4 (Tikanga) machine. I need to install Oracle Database 10g Release 2 on that machine. So, how can I decide whether kernel architecture is 32bit or 64bit?

Is that a typo on the first sentence: uname -m and uname -m? — tshepang, May 02 '11 at 17:34
See also Linux command to return number of bits (32 or 64)?. If uname -m shows i?86, you have a 32-bit system. — Gilles 'SO- stop being evil', May 02 '11 at 21:29
The question Gilles links to gives an interesting solution: getconf WORD_BIT. — Mikel, May 02 '11 at 23:11

score 193 · Answer 1 · edited Apr 13 '17 at 12:36

193

i386 and i686 are both 32-bit.
x86_64 is 64-bit

example for 64 bit:

behrooz@behrooz:~$ uname -a  
Linux behrooz 2.6.32-5-amd64 #1 SMP Mon Mar 7 21:35:22 UTC 2011 **x86_64** GNU/Linux

EDIT:
See is my linux ARM 32 or 64 bit? for ARM

edited Apr 13 '17 at 12:36

Community

1

answered May 02 '11 at 07:59

Behrooz

2,368
2
15
13

What about armv7l? In any case, a command with a simple boolean response would be delicious. – user7543 Oct 26 '13 at 23:40
1

@user7543 It's ARM 32-bit, because we don't have 64-bit ARM yet.When we do, It's gonna be something different. – Behrooz Oct 27 '13 at 07:38
I feel like I should make my answer community wiki but don't know how. – Behrooz Dec 26 '14 at 21:20
21

Try: uname -m. That'll only show the architecture. – Alexej Magura Nov 18 '16 at 14:29
4

arm64 is called aarch64 – xdevs23 Nov 16 '19 at 13:26

score 113 · Answer 2 · edited Jan 17 '22 at 05:18

113

It's simple! Use the arch command from coreutils package.

edited Jan 17 '22 at 05:18

Pablo A

2,712

answered Mar 23 '13 at 03:33

Real Dreams

2,365

11

Odd... on my 2013 MacBook Pro, arch returns i386, but uname -a shows x86_64. – turboladen Aug 19 '13 at 20:38
7

@turboladen "why do uname and arch differ in output?" = http://superuser.com/questions/835514/why-do-uname-p-and-uname-m-and-arch-output-different-architectures – user10607 May 27 '16 at 14:44
1

note arch is not defined by POSIX http://pubs.opengroup.org/onlinepubs/9699919799/idx/utilities.html – Zombo Nov 26 '16 at 02:24
3

arch is uname -m – Themelis Jun 02 '20 at 11:07
2

arch is not pre-installed on Arch, ironic. Use uname -m instead. It returns x86_64 for me – glibg10b May 14 '21 at 05:42

score 53 · Answer 3 · answered Aug 28 '15 at 12:45

53

For Debian:

On my PC

    ~ > dpkg --print-architecture
    amd64

    ~ > dpkg --print-foreign-architectures
    i386

My Raspberry Pi 2

    ~ > dpkg --print-architecture
    armhf

answered Aug 28 '15 at 12:45

Артем Телешев

539

2

this works best when determining package architecture to use with checkinstall, thx! – Aquarius Power Feb 11 '16 at 01:59
2

Thank you. I've been looking for something that would drop the 'standard' "amd64"/"i386" architecture names rather than just "x86_64". No one uses that terminology when naming precompiled releases. – Cliff Jul 11 '19 at 19:25
Does CentOS/RedHat have an equivalent command? Or is this a problem on RH-based OSes? Trying to add support to an ansible role for the RH family to expand OS options for future servers. – Zack Dec 20 '20 at 20:48
Much better for me, thanks! – Olivier Pons May 27 '22 at 10:46

score 35 · Answer 4 · edited May 23 '17 at 12:40

35

@behrooz is correct. Unfortunately uname requires you to know architectures. Actually, I was looking for a list of architectures and I found this article that answers your question. In regards to uname -m:

x86_64 GNU/Linux indicates that you've a 64bit Linux kernel running. If you use see i386/i486/i586/i686 it is a 32 bit kernel.

To determine if the hardware is capable of running a 64-bit kernel

grep flags /proc/cpuinfo

Look for the following in the output (all flags retrieved from this stackoverflow answer for the same question )

lm flag means Long mode cpu - 64 bit CPU
tm flag means Protected mode - 32-bit CPU
rm flag means Real Mode - 16 bit CPU

edited May 23 '17 at 12:40

Community

1

answered May 02 '11 at 18:04

xenoterracide

59,188
74
187
252

Does the lm flag simply mean the CPU supports 64-bit or does it mean that it's running in 64-bit. I recommend relying on the arch knowing that it will be x86_64 for 64-bit or i?86 for 32-bit. – penguin359 May 02 '11 at 21:45
1

@penguin359 it means that the cpu supports 64-bit. – xenoterracide May 02 '11 at 22:57
@xeno so then is can't be used to determine the kernel architecture. – penguin359 May 02 '11 at 23:58
@penguin359 no, was that unclear in the answer? – xenoterracide May 03 '11 at 08:55
@xeno When I first read your answer, I took it as implying an alternative to looking at the kernel architecture. On a re-read, I do notice you were specifying the CPU architecture, but I wanted to clarify that that does not help with the user's question which is specifically whether the kernel is 64-bit. – penguin359 May 03 '11 at 11:01
2

@penguin359, no but it's often useful to find out if your OS is running 64-bit and if not if the hardware is capable, imo – xenoterracide May 03 '11 at 20:09
+1, much more accurate than my answer. – Behrooz May 04 '11 at 17:56

dannyw · Answer 5 · 2015-09-01T05:40:58.060

14

The simplest way is to run:

getconf LONG_BIT

which will output 64 or 32 depending on whether it is 32 or 64 bits.

eg:

dannyw@dannyw-redhat:~$ getconf LONG_BIT
64

edited Sep 01 '15 at 05:40

answered Aug 27 '15 at 01:48

dannyw

241

4

This answer is misleading. If you enable multiarch support and install 64 bit kernel over 32 bit installation getconf LONG_BIT will print 32 though you are running 64 bit kernel. – kenn Jul 23 '18 at 07:42

Adam · Answer 6 · 2021-08-18T15:35:57.017

There is also lscpu: display information about the CPU architecture

lscpu
Architektura:                    x86_64
Tryb(y) pracy CPU:               32-bit, 64-bit
Kolejność bajtów:                Little Endian
Address sizes:                   39 bits physical, 48 bits virtual
CPU:                             8
Lista aktywnych CPU:             0-7
Wątków na rdzeń:                 2
Rdzeni na gniazdo:               4
Gniazd:                          1
Węzłów NUMA:                     1
ID producenta:                   GenuineIntel
Rodzina CPU:                     6
Model:                           60
Nazwa modelu:                    Intel(R) Core(TM) i7-4770 CPU @ 3.40GHz
Wersja:                          3
CPU MHz:                         3392.293
CPU max MHz:                     3900,0000
CPU min MHz:                     800,0000
BogoMIPS:                        6784.24
Wirtualizacja:                   VT-x
Cache L1d:                       128 KiB
Cache L1i:                       128 KiB
Cache L2:                        1 MiB
Cache L3:                        8 MiB
Procesory węzła NUMA 0:          0-7

score 3 · Answer 7 · edited May 14 '21 at 02:59

3

Here's another method using uname.

From uname(1):

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

# uname -i
x86_64

edited May 14 '21 at 02:59

Scott - Слава Україні

10,519

answered Nov 17 '16 at 23:57

clusterdude

133

1

Until it gives "unknown" – Dagelf Jul 05 '19 at 19:22

score 2 · Answer 8 · edited Apr 02 '17 at 22:09

2

use syscap from Formake project

syscap allows to probe many system properties and test dependencies. It is a portable shell script.

Get CPU architecture:

syscap info -arch

Get kernel name and version:

syscap info -kernel -kernver

edited Apr 02 '17 at 22:09

Stephen Rauch

4,239

answered Apr 02 '17 at 21:49

Alex

21

score 1 · Answer 9 · answered May 04 '11 at 08:51

1

Another way is to check the architecture some system file was compiled for, like

$ 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

answered May 04 '11 at 08:51

minaev

721

1

That's the system architecture, which isn't always the kernel architecture. See this answer at SU for more variations. – Gilles 'SO- stop being evil' May 04 '11 at 09:47
Theoretically, they may differ, but is there a chance they would mismatch on any real-life installation? – minaev May 05 '11 at 11:30
Some distributions ship an amd64 kernel on the x86 version. I don't know how many people use them, I checked Debian popcon but it doesn't correlate between the various stats. I think the main use case is having a 32-bit main OS and running a 64-bit OS in a chroot or in a VM. – Gilles 'SO- stop being evil' May 05 '11 at 20:00
@Gilles You're gonna love what you'll read about the new x32 architecture, If I'm not too late, off course. https://wiki.debian.org/X32Port – Behrooz Oct 27 '13 at 07:41

score 1 · Answer 10 · answered Feb 16 '15 at 14:28

Or you can use the way of what the uname command internally does if you want to implement some stuff on your own:

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

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

b_laoshi · Answer 11 · 2018-09-26T08:16:31.683

If you're looking for a simple one-liner, this is the most reliable solution that I've found that returns 64 or 32. It doesn't care if you're running ARM or not, and it should work on any system using bash or sh.

Beware, this will assume the system is either 32-bit or 64-bit. See my explanation below if you need to detect 8- 16- or some-other-bit architecture.

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

What's happing here?
The logic is very simple and it all boils down to how computers store signed integers. A 32-bit architecture only has 32 bits that it can use for storing signed integers while a 64-bit architecture has 64 bits! In other words the set of integers that can be stored is finite. Half of this set represents negative numbers and half represents positive numbers. The signed integer equalling -1 is represented as the largest number that can be stored in a given number of bits for that architecture. On a 32-bit system, -1 can be represented by the hex value 0xFFFFFFFF (which is 32 binary bits, all equalling 1). On a 64-bit system, 0xFFFFFFFF translates to 4,294,967,295, base 10 while 0xFFFFFFFFFFFFFFFF is the representation for -1). You can see how this would easily scale for systems that are 8- or 16-bit as well which would equal -1 at 0xFF and 0xFFFF, respectively.

score 1 · Answer 12 · answered Sep 20 '20 at 18:59

1

For debian Linux derived systems.

On 64bits systems :

$ dpkg-architecture -q DEB_BUILD_ARCH
amd64

On 32bits systems :

$ dpkg-architecture -q DEB_BUILD_ARCH
i386

answered Sep 20 '20 at 18:59

SebMa

2,149

score 1 · Answer 13 · answered Jul 12 '23 at 20:14

This is a small bash function that helped my a lot:

initArch() {
  ARCH=$(uname -m)
  case $ARCH in
    armv5*) ARCH="armv5";;
    armv6*) ARCH="armv6";;
    armv7*) ARCH="arm";;
    aarch64) ARCH="arm64";;
    x86) ARCH="386";;
    x86_64) ARCH="amd64";;
    i686) ARCH="386";;
    i386) ARCH="386";;
  esac
}

In my case, uname -m gives me x86_64, but the binary I am trying to dowload refers to it as amd64.

This code is part of the get_helm.sh script to install helm binary.

score 0 · Answer 14 · edited May 15 '23 at 03:09

0

Not sure how useful this is, but I crafted this for Arch:

grep "model name" /proc/cpuinfo | sed "s/model name   : //" | head -n 1

(Only answered because I searched for Arch and found this; I know the OP asked about Red Hat.)

edited May 15 '23 at 03:09

张馆长

131

answered Dec 19 '22 at 01:30

Jesse

351

How to determine Linux kernel architecture?

14 Answers14

Linked