How to determine Linux kernel architecture?
uname -mgives i686 and
uname -mgives 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?
See also Linux command to return number of bits (32 or 64)?. If `uname -m` shows i?86, you have a 32-bit system.
i386 and i686 are both 32-bit.
x86_64 is 64-bit
example for 64 bit:
[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
See is my linux ARM 32 or 64 bit? for ARM
What about armv7l? In any case, a command with a simple boolean response would be delicious.
@user7543 It's ARM 32-bit, because we don't have 64-bit ARM yet.When we do, It's gonna be something different.
It's simple! Use the
Odd... on my 2013 MacBook Pro, `arch` returns `i386`, but `uname -a` shows `x86_64`.
@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
note arch is not defined by POSIX http://pubs.opengroup.org/onlinepubs/9699919799/idx/utilities.html
@behrooz is correct. Unfortunately
unamerequires 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
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 )
lmflag means Long mode cpu - 64 bit CPU
tmflag means Protected mode - 32-bit CPU
rmflag means Real Mode - 16 bit CPU
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.
@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, 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
(EDIT: this answer is WRONG. Thanks to @Lizardx's comment)
In Bash, using integer overflow:
if ((1<<32)); then echo 64bits else echo 32bits fi
It's much more efficient than invoking another process or opening files.
While elegant, this is unfortunately not correct: uname -m == i686 BUT if ((1<<32)); then echo 64bits;fi == 64bits This is a PAE kernel, 32 bit, not a 64 bit kernel. The cpu is 64 bit capable however, amd64. Since the question was how to determine kernel arch, this solution would yield incorrect results.
note `((` is a Bashism and not defined by POSIX http://mywiki.wooledge.org/Bashism#Conditionals
On my PC
~ > dpkg --print-architecture amd64
~ > dpkg --print-foreign-architectures i386
My Raspberry Pi 2
~ > dpkg --print-architecture armhf
this works best when determining package architecture to use with `checkinstall`, thx!
The simplest way is to run:
which will output 64 or 32 depending on whether it is 32 or 64 bits.
[email protected]:~$ getconf LONG_BIT 64
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
That's the system architecture, which isn't always the kernel architecture. See this answer at SU for more variations.
Theoretically, they may differ, but is there a chance they would mismatch on any real-life installation?
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.
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.