lib/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2025-12-03 12:11:17 +03:00
Code Activity

Remove kernel version check

Browse Source 
The kernel version check is used to avoid glibc to run on older
kernels where some syscall are not available and fallback code are
not enabled to handle graciously fail.  However, it does not prevent
if the kernel does not correctly advertise its version through
vDSO note, uname or procfs.

Also kernel version checks are sometime not desirable by users,
where they want to deploy on different system with different kernel
version knowing the minimum set of syscall is always presented on
such systems.

The kernel version check has been removed along with the
LD_ASSUME_KERNEL environment variable.  The minimum kernel used to
built glibc is still provided through NT_GNU_ABI_TAG ELF note and
also printed when libc.so is issued.

Checked on x86_64-linux-gnu.
This commit is contained in:
Adhemerval Zanella
2022-02-21 08:32:32 -03:00
parent 97a912f7a8
commit b46d250656
17 changed files with 33 additions and 309 deletions
Download Patch File Download Diff File Expand all files Collapse all files

93
sysdeps/unix/sysv/linux/dl-sysdep.c
View File

@@ -250,96 +250,3 @@ _dl_show_auxv (void)
}
#endif /* SHARED */
int
attribute_hidden
_dl_discover_osversion (void)
{
#ifdef SHARED
if (GLRO(dl_sysinfo_map) != NULL)
{
/* If the kernel-supplied DSO contains a note indicating the kernel's
version, we don't need to call uname or parse any strings. */
static const struct
{
ElfW(Nhdr) hdr;
char vendor[8];
} expected_note = { { sizeof "Linux", sizeof (ElfW(Word)), 0 }, "Linux" };
const ElfW(Phdr) *const phdr = GLRO(dl_sysinfo_map)->l_phdr;
const ElfW(Word) phnum = GLRO(dl_sysinfo_map)->l_phnum;
for (unsigned int i = 0; i < phnum; ++i)
if (phdr[i].p_type == PT_NOTE)
{
const ElfW(Addr) start = (phdr[i].p_vaddr
+ GLRO(dl_sysinfo_map)->l_addr);
const ElfW(Nhdr) *note = (const void *) start;
while ((ElfW(Addr)) (note + 1) - start < phdr[i].p_memsz)
{
if (!memcmp (note, &expected_note, sizeof expected_note))
return *(const ElfW(Word) *) ((const void *) note
+ sizeof expected_note);
#define ROUND(len) (((len) + sizeof note->n_type - 1) & -sizeof note->n_type)
note = ((const void *) (note + 1)
+ ROUND (note->n_namesz) + ROUND (note->n_descsz));
#undef ROUND
}
}
}
#endif /* SHARED */
char bufmem[64];
char *buf = bufmem;
unsigned int version;
int parts;
char *cp;
struct utsname uts;
/* Try the uname system call. */
if (__uname (&uts))
{
/* This was not successful. Now try reading the /proc filesystem. */
int fd = __open64_nocancel ("/proc/sys/kernel/osrelease", O_RDONLY);
if (fd < 0)
return -1;
ssize_t reslen = __read_nocancel (fd, bufmem, sizeof (bufmem));
__close_nocancel (fd);
if (reslen <= 0)
/* This also didn't work. We give up since we cannot
make sure the library can actually work. */
return -1;
buf[MIN (reslen, (ssize_t) sizeof (bufmem) - 1)] = '\0';
}
else
buf = uts.release;
/* Now convert it into a number. The string consists of at most
three parts. */
version = 0;
parts = 0;
cp = buf;
while ((*cp >= '0') && (*cp <= '9'))
{
unsigned int here = *cp++ - '0';
while ((*cp >= '0') && (*cp <= '9'))
{
here *= 10;
here += *cp++ - '0';
}
++parts;
version <<= 8;
version |= here;
if (*cp++ != '.' || parts == 3)
/* Another part following? */
break;
}
if (parts < 3)
version <<= 8 * (3 - parts);
return version;
}