As I m switching distribution, this question is an extension of [this problem](https://stackoverflow.com/a/54301847) for getting maximum performance from a cpu hungry program which can t handle 64 bits pointers. Because the problem isn t just about using the required binutils and compilers. It also requires libraries like glibc. And so far, not packages contains x32.

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...

I need to download stress-ng deb package from a PC, and then copy it to an offline arm board. So, I tried apt download stress-ng:arm64, and get: Error: Unable to locate package stress-ng:arm64. Then I guess maybe stress-ng isn't packaged for arm64, so I want to get a list of architectures supported by stress-ng. But how? I found some 3rd-party packages can achieve this. But what's about apt? Shouldn't apt support this feature if missing?

I'm using 64 bit Kali Linux, previously installed i386 architecture and now I want to remove it, because it downloads about 30Mb data for 32bit package every time apt update. I tried dpkg --remove-architecture i386, it failed with *dpkg: error: cannot remove architecture 'i386' currently in use by the database* Google says the i386 packages should be removed first, but some package like "gcc-12-base:i386, libc6:i386, libcrypt1:i386, libgcc-s1:i386" cannot be removed, how to solve it?

Can someone provide me with a very clear and practical example of a "windowing system"? I was reading on Linux, and although I've always known that it's a kernel, I didn't really know what a kernel is because I haven't taken an OS class yet. My understanding of it is that it's basically the layer between hardware and software. Would that be correct? Now the Linux distros everyone uses is combination of GNU/Linux/X Window System. I think I got the Linux kernel part, but what is a windowing system and what is GNU? Wikipedia says GNU is an OS, but then that would mean Linux distros are composed of another OS. Can someone clear this up for me?

I'm in the process of upgrading my desktop/server setup and am considering using POWER9 architecture. However, I'm a bit concerned about the level of support it receives from GNU/Linux distributions and applications. Can anyone provide insights on how well supported POWER9 is within the GNU/Linux ecosystem in 2024? Any advice or recommendations would be greatly appreciated!

According to Bryant and O'Hallaron's (somewhat abstracted) model of the page table on Linux-like systems, each page table entry (PTE) has an address field that holds one of three kinds of value: (1) the physical address (actually, the page number) to which the virtual page is mapped; (2) an equivalent location identifier for a long-term storage device -- where the page can be found; or (3) 0, for an unallocated page. Suppose a page has been swapped in from long-term storage to main memory. In this account, the kernel replaces the long-term storage address (2) with the physical address (1). Now suppose that same page in physical memory needs to be evicted to make room for some other page to be swapped in. How does the original long-term storage address get restored to the PTE, if it has been overwritten with the physical address? Thanks.

I compiled a simple "Hello World" C program on Raspberry Pi 3, which was then transferred to an AMD64 laptop. Out of curiosity, I executed it, and it runs even though I did not expect it to:

$ uname -a
Linux 15ud490-gx76k 6.5.0-25-generic #25~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Tue Feb 20 16:09:15 UTC 2 x86_64 x86_64 x86_64 GNU/Linux

$ file hello64
hello64: ELF 64-bit LSB executable, ARM aarch64, version 1 (GNU/Linux), statically linked, BuildID[sha1]=486ee1cde035cd704b49c037a32fb77239b6a1c2, for GNU/Linux 3.7.0, not stripped

$ ./hello64
Hello World!

Like that, how can it execute? QEMU User Emulation is installed, but I don't know whether it is playing a part in this or not.

I'm benchmarking core-to-core latency on my server to find good core affinities. I'm trying to set the core affinities of two threads to different CPUs, and time the latency of message between the threads. The message is passed via std::atomic. Runtimes are computed via https://github.com/fuatu/core-latency-atomic Core affinities are assigned (POSIX) via

void set_affinity(long cpu_num) {
  cpu_set_t cpuset;
  CPU_ZERO(&cpuset);
  CPU_SET(cpu_num, &cpuset);
  pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
}

Runtimes are measured via an atomic accessed by two threads:

enum State
{
  Preparing,
  Ready,
  Ping,
  Pong,
  Finish,
};

class Sync
{
public:
  State wait_as_long_as(State wait_state)
  {
    State loaded_state = state.load();
    while (loaded_state == wait_state)
      loaded_state = state.load();
    return loaded_state;
  }

  void wait_until(State expected_state)
  {
    while (state.load() != expected_state)
    {
    }
  }

  void set(State new_state, State expected_state)
  {
    //state.store(new_state);
    state.compare_exchange_strong(expected_state, new_state);
  }

private:
  std::atomic state{Preparing};
};

static void set_affinity(unsigned int cpu_num)
{
  cpu_set_t cpuset;
  CPU_ZERO(&cpuset);
  CPU_SET(cpu_num, &cpuset);
  pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
}

struct LatencyBench
{
  LatencyBench(long first_cpu_, long second_cpu_)
    : first_cpu{first_cpu_}
    , second_cpu{second_cpu_}
  {
  }

  void operator()(nonius::chronometer meter) const
  {
    Sync sync;

    set_affinity(first_cpu);

    std::thread t([&] {
      set_affinity(second_cpu);
      sync.set(Ready,Preparing);

      State state = sync.wait_as_long_as(Ready);
      while (state != Finish)
      {
        //if (state == Ping)
        sync.set(Pong,Ping);
        state = sync.wait_as_long_as(Pong);
      }
    });

    sync.wait_until(Ready);

    // start timer
    sync.set(Ping,Ready);
    sync.wait_until(Pong);
    // stop timer

    sync.set(Finish,Pong);
    t.join();
  }

  const long first_cpu;
  const long second_cpu;
};

Runtimes are only measured during the thread communication; they do not include time to start ./a.out or the time to start the second thread. The latencies measured are robust to replicate trials within the same program; if I sleep in main and then run the analysis a second time, the latencies are still within roughly 1ns from the first measurement. But if I run ./a.out again, the latency measured can change by roughly 40ns. This can also change the core pair with best latency. Do you know what could be behind these stochastic latency changes when running the same executable twice? **Additional details:** Using numactl -m 0 -N 0 ./a.out and focusing on core pairs within NUMA node 0 doesn't alleviate. Using a server with sub-NUMA nodes configured and staying withing one sub-NUMA node likewise doesn't change this. The variability in latency has been replicated on both Xeon and EPYC processors. I'd expect that multiple analysis within main would likewise suggest it is not a caching issue, since the second analysis in main would likely have everything cached.

I just created a simple .deb package (using this tutorial ). This is my control file:

Package: bla
Version: 1.0
Architecture: x86_64
Maintainer: bla
Description: bla

The Architecture I got from uname -m: x86_64, however, dpkg-deb broke due to _ being an invalid char, so I changed to - which worked but broke on the installation phase:

dpkg: error processing archive bla_x86_64.deb (--install):
 package architecture (x86-64) does not match system (amd64)

So I turned to use amd64 as my architecture, and voila! Now I just don't understand this mismatch in architectures between uname -m and dpkg...

Can someone please explain the set-user-ID mechanism in Unix ? What was the rationale behind this design decision? How is it different from effective user id mechanism ?

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 was trying to crossgrade my architecture from i386 to amd64 (from https://wiki.debian.org/CrossGrading) and I got some error and broke apt-get and dpkg. apt-get and dpkg output cannot execute binary file: Exec format error sudo apt-get outputs /usr/bin/apt-get: 3: /usr/bin/apt-get: Syntax error: ")" unexpected Here is the output from running some commands to give you the idea: http://paste.debian.net/949117/ uname -a outputs Linux chowder 3.16.0-4-686-pae #1 SMP Debian 3.16.43-2 (2017-04-30) i686 GNU/Linux so I think I'm i686 which I think is 32 bit. Therefore I think the issue is that I'm on a 32 bit system running 64 bit apt-get and dpkg. This makes sense because I could have done the "Crossgrade dpkg, tar, and apt" part of that wiki without properly crossgrading my architecture - I could have missed an error. Eventually I want to be on an amd64 bit architecture to download chrome and all sorts of stuff, but first I'll need to fix my apt-get and dpkg, and maybe that end goal is just a pipe dream. Should I just reinstall my os instead of crossgrading? Should I downgrade apt-get and dpkg (change them from 64 bit to 32 bit)? If so, where can I get an official copy of apt-get or dpkg - 32 bit? I wonder how I would have to install it once I got it too... I was on the #debian IRC chat as nate_ (and nate__ at one point because I accidentally had two tabs open) talking about this issue, but had to leave before I got an answer. There "flying_commands" said "maybe you could manually extract the i686 debs from debian.org (on another machine?) to get the binaries back?" but I'm not quite sure how to do that, and how to install the debs without dpkg working. Thank you to those at #debian, who helped extract a lot of this information so far. And thanks in advance to anyone who can help out.

(This is not a "which distribution is better" question!) GNU GUIX and NixOS are two Linux distributions based on the NixOS package manager. I realize that GUIX seems to use Guile for defining packages/dependencies or other meta-data uses; and I'm guess everything in GUIX is GPL'ed, while perhaps not everything in NixOS is... but those seem more like superficial differences. What I'm hoping to understand is whether these two distributions have _architectural_ differences of any significance.

From reading the man pages on the read() and write() calls it appears that these calls get interrupted by signals regardless of whether they have to block or not. In particular, assume - a process establishes a handler for some signal. - a device is opened (say, a terminal) with the O_NONBLOCK **not** set (i.e. operating in blocking mode) - the process then makes a read() system call to read from the device and as a result executes a kernel control path in kernel-space. - while the precess is executing its read() in kernel-space, the signal for which the handler was installed earlier is delivered to that process and its signal handler is invoked. Reading the man pages and the appropriate sections in [SUSv3 'System Interfaces volume (XSH)'](http://pubs.opengroup.org/onlinepubs/009695399/) , one finds that: i. If a read() is interrupted by a signal before it reads any data (i.e. it had to block because no data was available), it returns -1 with errno set to [EINTR]. ii. If a read() is interrupted by a signal after it has successfully read some data (i.e. it was possible to start servicing the request immediately), it returns the number of bytes read. **Question A):** Am I correct to assume that in either case (block/no block) the delivery and handling of the signal is not entirely transparent to the read()? Case i. seems understandable since the blocking read() would normally place the process in the TASK_INTERRUPTIBLE state so that when a signal is delivered, the kernel places the process into TASK_RUNNING state. However when the read() doesn't need to block (case ii.) and is processing the request in kernel-space, I would have thought that the arrival of a signal and its handling would be transparent much like the arrival and proper handling of a HW interrupt would be. In particular I would have assumed that upon delivery of the signal, the process would be temporarily placed into **user mode** to execute its signal handler from which it would return eventually to finish off processing the interrupted read() (in kernel-space) so that the read() runs its course to completion after which the process returns back to the point just after the call to read() (in user-space), with all of the available bytes read as a result. But ii. seems to imply that the read() is interrupted, since data is available immediately, but it returns returns only some of the data (instead of all). This brings me to my second (and final) question: **Question B):** If my assumption under A) is correct, why does the read() get interrupted, even though it does not need to block because there is data available to satisfy the request immediately? In other words, why is the read() not resumed after executing the signal handler, eventually resulting in all of the available data (which was available after all) to be returned?

I know that "Everything is a file" means that even devices have their filename and path in Unix and Unix-like systems, and that this allows for common tools to be used on a variety of resources regardless of their nature. But I can't contrast that to Windows, the only other OS I have worked with. I have read some articles about the concept, but I think they are somewhat uneasy to grasp for non-developers. A layman's explanation is what people need! For example, when I want to copy a file to CF card that is attached to a card reader, I will use something like zcat name_of_file > /dev/sdb In Windows, I think the card reader will appear as a driver, and we will do something similar, I think. So, how does the "Everything is a file" philosophy make a difference here?

I reverse engineered Bluetooth interfaces of the UE Boom 3 speaker and Pebble 2 smartwatch, documented them and made Python scripts to use all the same features of their official iOS apps. I could make UIs etc. for my scripts, but I would like to add support for this more wide in Linux (OS). To which software/component of the Linux (OS) stack should I do a PR? To the kernel?

What's the internal process of opening a file? To open a file, the system converts the pathname to inode and from the inode search the corresponding driver disk portion to look for the content of the file? Is that it? I only have a vague sense of the process of opening a file, but I want more detail.

I've been reading about unnamed pipes and as I understood them they're implemented as a buffer in memory. When creating the pipe I need to pass an array of size two and it returns two pointers (file descriptors) to the buffer. The index 0 is used for reading from the pipe and index 1 for writing to it. My question is, if the buffer is just one and both indexes point to the same memory location and two processes can't read and write at the same time, then why do I need two file descriptors? I hope my question makes sense.

I've been pulling my hair out for days trying to run a 32 bit binary on a 64 bit arch installation. When I do try to run it, using ./scarlet, I get this:

bash: ./scarlet: no such file or directory

and it's driving me insane. I've tried to install libstdc++, and a bunch of others, but none seem to work. However, when I do install libstdc++, I get a new error:

./scarlet: error while loading shared libraries: libstdc++.so.6: cannot open shared object file: No such file or directory

So it seems that I'm missing whatever package holds the library libstdc++.so.6. A simple web search would point to all of the packages that I've already installed, and none of them work. I primarily use Arch, but I would be fine with answers pointing towards Fedora as well. So how do I fix this? output of ldd scarlet

linux-gate.so.1 (0xf7efa000)
	libstdc++.so.6 => not found
	libGL.so.1 => not found
	libX11.so.6 => not found
	libXrandr.so.2 => not found
	libXxf86vm.so.1 => not found
	libXi.so.6 => not found
	libXcursor.so.1 => not found
	libXinerama.so.1 => not found
	libm.so.6 => /lib/libm.so.6 (0xf7e13000)
	libgcc_s.so.1 => /lib/libgcc_s.so.1 (0xf7dee000)
	libc.so.6 => /lib/libc.so.6 (0xf7c01000)
	/lib/ld-linux.so.2 (0xf7efc000)

Thanks. ## Update After installing a bunch of stuff:

sudo dnf install libstdc++.i686 libX11.i686 libXrandr.i686  ibXxf86vm.i686 libXi.i686 libXcursor.i686 libXinerama.i686

I now get a new error that I'm missing the library libGL.so.1 I've tried to:

sudo dnf install libGL.i686 #and just the standard libGL, but it's already installed

but no luck, because Fedora can't find the package.

Last metadata expiration check: 0:33:42 ago on Fri 26 Aug 2022 09:51:02 AM EDT.
No match for argument: libGL.i686
Error: Unable to find a match: libGL.i686