Despite having a data bus size of 64 bit, the address bus size of modern AMD64-compatible CPUs is/was 48 bit for some time which allows using 48-bit long virtual memory addresses with a maximum of addressable virtual memory of 2^48 => 256 TB. Intel says that since the Ice Lake CPU architecture, their CPUs support 5-Level Paging with 57-bit long virtual memory addresses. Linux supports this since Kernel 4.14 . Does this mean that CPUs that support 5-Level Paging with 57-bit long virtual memory addresses implement a 57-bit long address bus? The background of my question is that around 10-15 years ago, it was not a problem to learn about the address bus and data bus size of modern CPUs, but since approximately ten years, it is not simple to find information about the address bus size. https://software.intel.com/content/www/us/en/develop/download/5-level-paging-and-5-level-ept-white-paper.html https://www.kernel.org/doc/html/latest/arch/x86/x86_64/5level-paging.html

Two very common ways of getting the machine architecture are these: uname -m and arch. They both print things like x86_64. But I remember there is a third way to do that, but I can't remember what it was. I saw it some sort of Makefile-like script once, and for the love of god, I can't recall what it was. Does anyone remember what it was, and perhaps remember its use in build scripts? Thanks in advance -- this is kinda driving me a little crazy, tbh...

There's a lot of information on installing 64-bit Linux on 32-bit UEFI. It's a mess even here, but I've seen ways (rEFInd, etc). But this laptop (HP Envy X2) has a 32-bit architecture and exclusively EFI (no CSM / legacy BIOS). So, how can I install a **32-bit** Linux distribution on a **32-bit** architecture, with **EFI** only? At this point I'd be fine with pretty much any distribution. But if there's choice, I'd go with Arch-based, or Debian-based. I have experience in GNU/Linux and installation / etc. I'm looking for EFI-specific help. The laptop currently runs Windows 10 with basically no drivers, but I have access to Debian and Windows on my desktop. Thanks! PS: [This](https://unix.stackexchange.com/questions/251705/32bit-or-64bit-linux-distro-with-32bit-uefi-support) is not a duplicate as the questioner is (I believe) wrong in believing that the X2's CPU supports 64-bit. The answer there is also merely a distribution name.

I have a project where I need to get the size of the cache on my Linux machine. I don't know the linux distro, and the /etc/os-release file does not exist. I only know the kernel and architecture: Kernel: Linux 6.1.20-rt8 Architecture: arm64 I cannot install libraries onto the machine. To get the size of the cache, I tried the following methods, all of which failed:

$ lscpu | grep cache
L1d cache:           unknown size
L1i cache:           unknown size
L2 cache:            unknown size

$ cat /proc/cpuinfo | grep cache
$

$ ls /sys/devices/system/cpu/cpu*/cache/index*/size
ls: /sys/devices/system/cpu/cpu*/cache/index*/size: No such file or directory

dmesg | grep -i cache
[    0.000000] Detected VIPT I-cache on CPU0
[    0.000000] Dentry cache hash table entries: 524288 (order: 10, 4194304 bytes, linear)
[    0.000000] Inode-cache hash table entries: 262144 (order: 9, 2097152 bytes, linear)
[    0.405602] Mount-cache hash table entries: 8192 (order: 4, 65536 bytes, linear)
[    0.405623] Mountpoint-cache hash table entries: 8192 (order: 4, 65536 bytes, linear)
[    0.490323] Detected VIPT I-cache on CPU1
[    0.508655] Detected VIPT I-cache on CPU2
[    0.526850] Detected VIPT I-cache on CPU3
[    0.547628] Detected PIPT I-cache on CPU4
[    0.591655] Detected PIPT I-cache on CPU5
[    0.762359] VFS: Dquot-cache hash table entries: 512 (order 0, 4096 bytes)
[   22.216417] Detected PIPT I-cache on CPU4
[   22.412738] Detected PIPT I-cache on CPU5

The /proc/cpu info file:

$ cat /proc/cpuinfo
processor       : 0
BogoMIPS        : 16.00
Features        : fp asimd evtstrm aes pmull sha1 sha2 crc32 cpuid
CPU implementer : 0x41
CPU architecture: 8
CPU variant     : 0x0
CPU part        : 0xd03
CPU revision    : 4

processor       : 1
BogoMIPS        : 16.00
Features        : fp asimd evtstrm aes pmull sha1 sha2 crc32 cpuid
CPU implementer : 0x41
CPU architecture: 8
CPU variant     : 0x0
CPU part        : 0xd03
CPU revision    : 4

processor       : 2
BogoMIPS        : 16.00
Features        : fp asimd evtstrm aes pmull sha1 sha2 crc32 cpuid
CPU implementer : 0x41
CPU architecture: 8
CPU variant     : 0x0
CPU part        : 0xd03
CPU revision    : 4

processor       : 3
BogoMIPS        : 16.00
Features        : fp asimd evtstrm aes pmull sha1 sha2 crc32 cpuid
CPU implementer : 0x41
CPU architecture: 8
CPU variant     : 0x0
CPU part        : 0xd03
CPU revision    : 4

processor       : 4
BogoMIPS        : 16.00
Features        : fp asimd evtstrm aes pmull sha1 sha2 crc32 cpuid
CPU implementer : 0x41
CPU architecture: 8
CPU variant     : 0x0
CPU part        : 0xd08
CPU revision    : 2

processor       : 5
BogoMIPS        : 16.00
Features        : fp asimd evtstrm aes pmull sha1 sha2 crc32 cpuid
CPU implementer : 0x41
CPU architecture: 8
CPU variant     : 0x0
CPU part        : 0xd08
CPU revision    : 2

The full lscpu:

$ lscpu
Architecture:        aarch64
Byte Order:          Little Endian
CPU(s):              6
On-line CPU(s) list: 0-5
Thread(s) per core:  1
Core(s) per socket:  6
Socket(s):           1
NUMA node(s):        1
Vendor ID:           ARM
Model:               4
Model name:          Cortex-A53
Stepping:            r0p4
BogoMIPS:            16.00
L1d cache:           unknown size
L1i cache:           unknown size
L2 cache:            unknown size
NUMA node0 CPU(s):   0-5
Flags:               fp asimd evtstrm aes pmull sha1 sha2 crc32 cpuid

The latest [spec for ELF](https://www.sco.com/developers/gabi/latest/ch4.eheader.html) list many architectures that can be used with it, but some self-assignments are made in the wild (e.g. [Chinese LoongArch](https://loongson.github.io/LoongArch-Documentation/LoongArch-ELF-ABI-EN.html#_e_machine_identifies_the_machine)) . Is there anyone coordinating these assignments? LANANA doesn't seem to have such list, or am I missing something?

AMD, Intel, Red Hat, and SUSE have defined a set of ["architecture levels" for x86-64 CPUs](https://developers.redhat.com/blog/2021/01/05/building-red-hat-enterprise-linux-9-for-the-x86-64-v2-microarchitecture-level/) . For example x86-64-v2 means that a CPU support not only the basic x86-64 instructions set, but also other instructions like SSE4.2, SSSE3 or POPCNT. How can I check which architecture levels are supported by my CPU?

What is the difference between WORD_BIT and LONG_BIT? And which one should I use to find out the word size of my system? Both return different results

➜  ~ getconf LONG_BIT
64
➜  ~ getconf WORD_BIT
32
➜  ~

I also read in some other post that a reliable way to find out word size can be to print the size of void. This gives me 8 bytes.

printf("%d\n", (int)sizeof(void*));

Will this always be equal to the result returned by getconf LONG_BIT? Sorry, sneaking one more question here - word size is related to the CPU architecture. Will OS also work on the same word size that CPU architecture has defined?

I get access to some xeon machines for checking performance. I want to find out what architecture they are using such as Haswell, Sandybridge , Ivybridge. Is there a command to find this out?

I'm trying to write a script which will determine actions based on the architecture of the machine. I already use uname -m to gather the architecture line, however I do not know how many ARM architectures there are, nor do I know whether one is armhf, armel, or arm64. As this is required for this script to determine whether portions of the script can be run or not, I am trying to find a simple way to determine if the architecture is armhf, armel or arm64. Is there any one-liner or simple command that can be used to output either armhf, armel, or arm64? The script is specifically written for Debian and Ubuntu systems, and I am tagging as such with this in mind (it quits automatically if you aren't on one of those distros, but this could be applied in a much wider way as well if the command(s) exist) ------ EDIT: Recently learned that armel is dead, and arm64 software builders (PPA or virtual based) aren't the most stable. So I have a wildcard search finding arm* and assuming armhf, but it's still necessary to figure out a one liner that returns one of the three - whether it's a Ubuntu/Debian command or a kernel call or something.

I need to set the arch option in debootstrap. So I did some research and read the manual. After reading the manual I see that the section on the options simply says --arch=ARCH Implying that I should know the correct syntax for the architecture I need. I don't. I need 64 bit architecture. I know that "i386" can be used for 32bit architecture. What should I set the --arch option to if I want 64 bit architecture? Or more generally what would the range of options be? I could guess (but don't know and can't determine) that potentially the range or arch options depends on the OS being booted. In my case its a version of ubuntu that I know should work in 64bit. So the question becomes how would I determine the 64bit architecture option syntax? I could further guess (but again don't know and can't determine) that the option syntaxes are actually supplied by the booted OS and if I knew where to look I could figure it out. In which case, where would I look?

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?

# Tl;dr I need to mock info about CPU architecture on the server for testing purpose. The only way that I can achieve it, is by changing info source about CPU architecture, that is used by lscpu command (**lscpu | grep Architecture HAS to return mocked architecture**). I know that lscpu gets data from /proc/cpuinfo and sysf, but I cannot find **what exactly** I need to change, for lscpu to return different architecture? # Context I'm performing simple checks for CPU architecture used by user. I'm doing it by check like if 'arm' =~ (lscpu | grep Architecture | awk '{print $2}'). It's trivial check, that I want to cover. However, the issue is, that I don't know how to perform different checks for different types of architecture. What I've tried to do: 1. Pre-preparing lscpu file with mocked echo Architecture: and adding it to $PATH - tested app uses different $PATH, so it is not effective. 2. Pre-preparing lscpu file with mocked lscpu | sed -r and binding it over orginal lscpu by sudo mount --bind /usr/bin/lscpu - in this case, every lscpu call hangs the machine. 3. Using different command than lscpu - tested app uses lscpu explicitly. That's how I've assumed that the only way is to mock the data in /proc/cpuinfo (example output below: there's no "CPU Architecture" field):

processor	: 31
vendor_id	: AuthenticAMD
cpu family	: 25
model		: 33
model name	: AMD Ryzen 9 5950X 16-Core Processor
stepping	: 0
microcode	: 0xa201025
cpu MHz		: 4065.719
cache size	: 512 KB
physical id	: 0
siblings	: 32
core id		: 15
cpu cores	: 16
apicid		: 31
initial apicid	: 31
fpu		: yes
fpu_exception	: yes
cpuid level	: 16
wp		: yes
flags		: fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx mmxext fxsr_opt pdpe1gb rdtscp lm constant_tsc rep_good nopl nonstop_tsc cpuid extd_apicid aperfmperf rapl pni pclmulqdq monitor ssse3 fma cx16 sse4_1 sse4_2 x2apic movbe popcnt aes xsave avx f16c rdrand lahf_lm cmp_legacy svm extapic cr8_legacy abm sse4a misalignsse 3dnowprefetch osvw ibs skinit wdt tce topoext perfctr_core perfctr_nb bpext perfctr_llc mwaitx cpb cat_l3 cdp_l3 hw_pstate ssbd mba ibrs ibpb stibp vmmcall fsgsbase bmi1 avx2 smep bmi2 erms invpcid cqm rdt_a rdseed adx smap clflushopt clwb sha_ni xsaveopt xsavec xgetbv1 xsaves cqm_llc cqm_occup_llc cqm_mbm_total cqm_mbm_local clzero irperf xsaveerptr rdpru wbnoinvd arat npt lbrv svm_lock nrip_save tsc_scale vmcb_clean flushbyasid decodeassists pausefilter pfthreshold avic v_vmsave_vmload vgif v_spec_ctrl umip pku ospke vaes vpclmulqdq rdpid overflow_recov succor smca fsrm
bugs		: sysret_ss_attrs spectre_v1 spectre_v2 spec_store_bypass
bogomips	: 6787.39
TLB size	: 2560 4K pages
clflush size	: 64
cache_alignment	: 64
address sizes	: 48 bits physical, 48 bits virtual
power management: ts ttp tm hwpstate cpb eff_freq_ro

or sysfs, for lscpu to be ran normally and output the mocked data. However I cannot find the specific place for this CPU architecture data to change - is it possible? If yes, what is the exact place where this data is stored, and how to mock it? Every idea would be appreciated!

I see the term **i386** instead of **x86** in many places related to Linux. As of my knowledge, **they are not interchangeable**. x86 is a family of instruction set architectures where i386 is a specific one of the x86 processors. But why do Linux world uses the term i386 instead of x86 ?
References:
x86 | Wikipeadia
Intel 80386 | Wikipeadia

When I do cat /proc/interrupts on my multicore x86_64 desktop PC (kernel 3.16) I see this: 0: 16 0 IO-APIC-edge timer LOC: 529283 401319 Local timer interrupts When I do cat /proc/interrupts on my multicore x86_64 laptop (kernel 3.19) I see this: 0: 1009220 0 IO-APIC-edge timer LOC: 206713 646587 Local timer interrupts When I saw this difference, I asked myself what the difference between those two is? I hope someone can explain this rather thoroughly, the explanation given [here](https://stackoverflow.com/questions/25931134/why-the-count-of-io-apic-edge-timer-showed-in-proc-interrupts-does-not-change-o) is not very detailed and does not explain why my desktop PC does not use timer, but my laptop does.

I'm in an ARM machine and I wanted to use an x86 program. Installed Box86 and the program and it's libraries. The program crashes because of this error: Error initializing native *libname* (last dlerror is *libname*: wrong ELF class: ELFCLASS64). This error is repeated several times for each of the libraries I installed. According to this answer , it's beacause they are 64 bit libraries, but I made sure to install the i386 version of the packages. Also, their workaround doesen't solve the problem for me, causing the same output. Any clue of what's happening here? Thanks in advance.

When execute:

$ cat /sys/devices/system/cpu/modalias;
cpu:type:x86,ven0002fam0019mod0021:feature:,0000,

Says have a 32 bit cpu, but have a ryzen 7 5800X3D, is a 64 bit cpu, what happens?

$ cat /proc/cpuinfo | grep Ryzen | head -n 1
model name	: AMD Ryzen 7 5800X3D 8-Core Processor
$ uname -i
x86_64

modalias file is not the cpu architecture representation?

By example, i can get the architecture of the cpu of my pc:

$ cat /sys/devices/system/cpu/modalias;
cpu:type:x86,ven0002fam0019mod0021:feature:,0000,

Ok, is x86, but what happens with 1u rackable servers where they can have 2 or 4 xeon physical sockets cpu?, how does linux make that difference?, all cpu sockets has same architecture? can have 2 differents architecture?, if the motherboard have only one architecture, the architecture is defined by motherboard?, i have heard that some models of android mobiles have CPUs with some 64-bit cores and others with 32 in same chip to save resources.

In the Debian download CD/DVD images page they have different ISO's for the different instruction set architectures. How do I know what is the ISA of a CPU before I buy one? I know about using the commands cat /proc/cpuinfo and lscpu but these are only good after getting the CPU and running these commands on a Linux based OS. How do I find out this information **before** getting the CPU? For example the CPU: Intel(r) core(tm) i5-6300hq cpu @ 2.30ghz In the official intel website they show the ISA is "64 bits". But nothing specific as mentioned in the debian website: amd64 / arm64 / armel / armhf / i386 / mips64el /mipsel / ppc64el / s390x / multi-arch Can someone tell me how they would go about finding this information?

On my computer, uname -m prints x86_64 as output. What is the list of possible values that this command could output? I intend to use this command from a dynamic runtime to check the CPU architecture.

man uname -m, --machine print the machine hardware name -i, --hardware-platform print the hardware platform or "unknown" What exactly is meant by hardware platform here and how is it different from the "machine hardware name"? I found some related questions on SE but there seems to be some contradictions among the accepted answers. Where can I find accurate information about this nomenclature?