According to the official GPL 2 FAQ, I have to use GPL for any project using a library under GPL (even if I don't directly use its sources), because my program links to the library.
But when I run an executable, I am using an operating system obviously. So do I have to use GPL for any project I am running on Linux? I think this does sound strange, but I can't explain to myself, what is wrong and why.
You don't have to publish your Linux software under the GPL. You are of course welcome to do so, but you are under no legal obligation.
You've taken a mental shortcut: “using a GPL library means I have to license under GPL”. But the GPL (and copyright law in general) doesn't care about what other software you use, but only whether your software is a derivative work of the GPL-covered software. For example, a software might be derivative if it is a modification of the original software, or if it includes the original software (in whole or in part). Using a library means linking the library, and the act of linking includes parts of the library in your program.
But when you write a software that runs on Linux, you are not including or modifying any part of Linux. Your software is not a derivative work of Linux. Thus, the license of the Linux kernel doesn't affect the license of the software running on it. (In fact, there is lots of software running on Linux that's completely incompatible with the GPLv2, such as Apache-2 licensed software or proprietary software.)
(For technical reasons the Linux kernel actually does inject the vdso pseudo-library into every running process as part of Linux' implementation of syscalls. But this is widely considered to be no licensing problem.)
Also, GPL does not mean that you have to publish your software. If your software is derivative of GPL-covered code and if you publish the software then the software as whole can only be licensed under the GPL. The GPL's requirements only trigger when you give a copy of your software to someone else.
The linux kernel has a couple of exceptions from GPLv2. Namely the exception to not treat a syscall to the kernel as linking and the exception to allow non-GPL code to link to kernel-related services exposed via libc:
NOTE! This copyright does not cover user programs that use kernel services by normal system calls - this is merely considered normal use of the kernel, and does not fall under the heading of "derived work". Also note that the GPL below is copyrighted by the Free Software Foundation, but the instance of code that it refers to (the Linux kernel) is copyrighted by me and others who actually wrote it.
In addition to the permissions in the GNU Library General Public License, the Free Software Foundation gives you unlimited permission to link the compiled version of this file into combinations with other programs, and to distribute those programs without any restriction coming from the use of this file. (The General Public License restrictions do apply in other respects; for example, they cover modification of the file, and distribution when not linked into another program.)
Note that these exceptions are not applied to the entire kernel but only to specific parts. Which parts of the kernel has what exception is documented by a tagging system as described by the kernel licensing rules document: https://www.kernel.org/doc/html/v4.18/process/license-rules.html
In general it can be assumed that you can distribute any non-GPL userland software that run on linux. When distributing kernel modules (devices drivers) however you need to be a bit more careful which parts of the kernel you are interfacing with.
COPYING: github.com/torvalds/linux/blob/master/COPYING
The official GPL FAQ, in the #PortProgramToGPL section, says
If I port my program to GNU/Linux, does that mean I have to release it as free software under the GPL or some other Free Software license? (#PortProgramToGPL)
In general, the answer is no—this is not a legal requirement. In specific, the answer depends on which libraries you want to use and what their licenses are. Most system libraries either use the GNU Lesser GPL, or use the GNU GPL plus an exception permitting linking the library with anything. These libraries can be used in nonfree programs; but in the case of the Lesser GPL, it does have some requirements you must follow.
Some libraries are released under the GNU GPL alone; you must use a GPL-compatible license to use those libraries. But these are normally the more specialized libraries, and you would not have had anything much like them on another platform, so you probably won't find yourself wanting to use these libraries for simple porting.
Of course, your software is not a contribution to our community if it is not free, and people who value their freedom will refuse to use it. Only people willing to give up their freedom will use your software, which means that it will effectively function as an inducement for people to lose their freedom.
If you hope some day to look back on your career and feel that it has contributed to the growth of a good and free society, you need to make your software free.
(The GPL 2 FAQ you link to has word-for-word the same text in its corresponding section ).
According to the official GPL 2 FAQ, I have to use GPL for any project using a library under GPL (even if I don't directly use its sources), because my program links to the library.
This is correct. But you go on to ask a very different question, "...do I have to use GPL for any project I am running on Linux?" Running a program on the GPL'd Linux kernel is not linking the program to a GPL'd library; other answers have explained how this works.
That said, if you port a program to Linux you will most likely be linking against libraries commonly distributed with Linux, and here you must be aware of the license for each library you decide to use. The GNU C Library, a popular libc implementation, is under the LGPL so there are no issues there. But some other commonly used libraries, such as readline, are under the GPL and linking to them (including dynamic linking) would require you to relicense your whole work under the GPL. (This is one of the primary reasons that there are serveral API-compatible alternatives to readline.)
readline library forcing me to license my work under GPL even when dynamically linking or there is some general rule when I have to treat my work as a derivative from a library which I dynamically link?