mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-12 15:46:54 +07:00
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rw/uml
Pull UML fixes from Richard Weinberger: "Assorted fixes for UML" * 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rw/uml: um: Memory corruption on startup um: Missing pipe handling uml: Simplify tempdir logic.
This commit is contained in:
Linus Torvalds
commit
c089b229df
@ -136,6 +136,7 @@ extern int os_ioctl_generic(int fd, unsigned int cmd, unsigned long arg);
|
||||
extern int os_get_ifname(int fd, char *namebuf);
|
||||
extern int os_set_slip(int fd);
|
||||
extern int os_mode_fd(int fd, int mode);
|
||||
extern int os_fsync_file(int fd);
|
||||
|
||||
extern int os_seek_file(int fd, unsigned long long offset);
|
||||
extern int os_open_file(const char *file, struct openflags flags, int mode);
|
||||
|
||||
@ -103,6 +103,7 @@ void __init setup_physmem(unsigned long start, unsigned long reserve_end,
|
||||
*/
|
||||
os_seek_file(physmem_fd, __pa(&__syscall_stub_start));
|
||||
os_write_file(physmem_fd, &__syscall_stub_start, PAGE_SIZE);
|
||||
os_fsync_file(physmem_fd);
|
||||
|
||||
bootmap_size = init_bootmem(pfn, pfn + delta);
|
||||
free_bootmem(__pa(reserve_end) + bootmap_size,
|
||||
|
||||
@ -237,6 +237,12 @@ void os_close_file(int fd)
|
||||
{
|
||||
close(fd);
|
||||
}
|
||||
int os_fsync_file(int fd)
|
||||
{
|
||||
if (fsync(fd) < 0)
|
||||
return -errno;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int os_seek_file(int fd, unsigned long long offset)
|
||||
{
|
||||
|
||||
@ -151,6 +151,7 @@ int __init main(int argc, char **argv, char **envp)
|
||||
#endif
|
||||
|
||||
do_uml_initcalls();
|
||||
change_sig(SIGPIPE, 0);
|
||||
ret = linux_main(argc, argv);
|
||||
|
||||
/*
|
||||
|
||||
@ -12,337 +12,117 @@
|
||||
#include <string.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/mman.h>
|
||||
#include <sys/param.h>
|
||||
#include <sys/vfs.h>
|
||||
#include <linux/magic.h>
|
||||
#include <init.h>
|
||||
#include <os.h>
|
||||
|
||||
/* Modified by which_tmpdir, which is called during early boot */
|
||||
static char *default_tmpdir = "/tmp";
|
||||
|
||||
/*
|
||||
* Modified when creating the physical memory file and when checking
|
||||
* the tmp filesystem for usability, both happening during early boot.
|
||||
*/
|
||||
/* Set by make_tempfile() during early boot. */
|
||||
static char *tempdir = NULL;
|
||||
|
||||
static void __init find_tempdir(void)
|
||||
/* Check if dir is on tmpfs. Return 0 if yes, -1 if no or error. */
|
||||
static int __init check_tmpfs(const char *dir)
|
||||
{
|
||||
const char *dirs[] = { "TMP", "TEMP", "TMPDIR", NULL };
|
||||
int i;
|
||||
char *dir = NULL;
|
||||
struct statfs st;
|
||||
|
||||
if (tempdir != NULL)
|
||||
/* We've already been called */
|
||||
return;
|
||||
for (i = 0; dirs[i]; i++) {
|
||||
dir = getenv(dirs[i]);
|
||||
if ((dir != NULL) && (*dir != '\0'))
|
||||
break;
|
||||
}
|
||||
if ((dir == NULL) || (*dir == '\0'))
|
||||
dir = default_tmpdir;
|
||||
|
||||
tempdir = malloc(strlen(dir) + 2);
|
||||
if (tempdir == NULL) {
|
||||
fprintf(stderr, "Failed to malloc tempdir, "
|
||||
"errno = %d\n", errno);
|
||||
return;
|
||||
}
|
||||
strcpy(tempdir, dir);
|
||||
strcat(tempdir, "/");
|
||||
}
|
||||
|
||||
/*
|
||||
* Remove bytes from the front of the buffer and refill it so that if there's a
|
||||
* partial string that we care about, it will be completed, and we can recognize
|
||||
* it.
|
||||
*/
|
||||
static int pop(int fd, char *buf, size_t size, size_t npop)
|
||||
{
|
||||
ssize_t n;
|
||||
size_t len = strlen(&buf[npop]);
|
||||
|
||||
memmove(buf, &buf[npop], len + 1);
|
||||
n = read(fd, &buf[len], size - len - 1);
|
||||
if (n < 0)
|
||||
return -errno;
|
||||
|
||||
buf[len + n] = '\0';
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* This will return 1, with the first character in buf being the
|
||||
* character following the next instance of c in the file. This will
|
||||
* read the file as needed. If there's an error, -errno is returned;
|
||||
* if the end of the file is reached, 0 is returned.
|
||||
*/
|
||||
static int next(int fd, char *buf, size_t size, char c)
|
||||
{
|
||||
ssize_t n;
|
||||
char *ptr;
|
||||
|
||||
while ((ptr = strchr(buf, c)) == NULL) {
|
||||
n = read(fd, buf, size - 1);
|
||||
if (n == 0)
|
||||
return 0;
|
||||
else if (n < 0)
|
||||
return -errno;
|
||||
|
||||
buf[n] = '\0';
|
||||
}
|
||||
|
||||
return pop(fd, buf, size, ptr - buf + 1);
|
||||
}
|
||||
|
||||
/*
|
||||
* Decode an octal-escaped and space-terminated path of the form used by
|
||||
* /proc/mounts. May be used to decode a path in-place. "out" must be at least
|
||||
* as large as the input. The output is always null-terminated. "len" gets the
|
||||
* length of the output, excluding the trailing null. Returns 0 if a full path
|
||||
* was successfully decoded, otherwise an error.
|
||||
*/
|
||||
static int decode_path(const char *in, char *out, size_t *len)
|
||||
{
|
||||
char *first = out;
|
||||
int c;
|
||||
int i;
|
||||
int ret = -EINVAL;
|
||||
while (1) {
|
||||
switch (*in) {
|
||||
case '\0':
|
||||
goto out;
|
||||
|
||||
case ' ':
|
||||
ret = 0;
|
||||
goto out;
|
||||
|
||||
case '\\':
|
||||
in++;
|
||||
c = 0;
|
||||
for (i = 0; i < 3; i++) {
|
||||
if (*in < '0' || *in > '7')
|
||||
goto out;
|
||||
c = (c << 3) | (*in++ - '0');
|
||||
}
|
||||
*(unsigned char *)out++ = (unsigned char) c;
|
||||
break;
|
||||
|
||||
default:
|
||||
*out++ = *in++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
out:
|
||||
*out = '\0';
|
||||
*len = out - first;
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* Computes the length of s when encoded with three-digit octal escape sequences
|
||||
* for the characters in chars.
|
||||
*/
|
||||
static size_t octal_encoded_length(const char *s, const char *chars)
|
||||
{
|
||||
size_t len = strlen(s);
|
||||
while ((s = strpbrk(s, chars)) != NULL) {
|
||||
len += 3;
|
||||
s++;
|
||||
}
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
enum {
|
||||
OUTCOME_NOTHING_MOUNTED,
|
||||
OUTCOME_TMPFS_MOUNT,
|
||||
OUTCOME_NON_TMPFS_MOUNT,
|
||||
};
|
||||
|
||||
/* Read a line of /proc/mounts data looking for a tmpfs mount at "path". */
|
||||
static int read_mount(int fd, char *buf, size_t bufsize, const char *path,
|
||||
int *outcome)
|
||||
{
|
||||
int found;
|
||||
int match;
|
||||
char *space;
|
||||
size_t len;
|
||||
|
||||
enum {
|
||||
MATCH_NONE,
|
||||
MATCH_EXACT,
|
||||
MATCH_PARENT,
|
||||
};
|
||||
|
||||
found = next(fd, buf, bufsize, ' ');
|
||||
if (found != 1)
|
||||
return found;
|
||||
|
||||
/*
|
||||
* If there's no following space in the buffer, then this path is
|
||||
* truncated, so it can't be the one we're looking for.
|
||||
*/
|
||||
space = strchr(buf, ' ');
|
||||
if (space) {
|
||||
match = MATCH_NONE;
|
||||
if (!decode_path(buf, buf, &len)) {
|
||||
if (!strcmp(buf, path))
|
||||
match = MATCH_EXACT;
|
||||
else if (!strncmp(buf, path, len)
|
||||
&& (path[len] == '/' || !strcmp(buf, "/")))
|
||||
match = MATCH_PARENT;
|
||||
}
|
||||
|
||||
found = pop(fd, buf, bufsize, space - buf + 1);
|
||||
if (found != 1)
|
||||
return found;
|
||||
|
||||
switch (match) {
|
||||
case MATCH_EXACT:
|
||||
if (!strncmp(buf, "tmpfs", strlen("tmpfs")))
|
||||
*outcome = OUTCOME_TMPFS_MOUNT;
|
||||
else
|
||||
*outcome = OUTCOME_NON_TMPFS_MOUNT;
|
||||
break;
|
||||
|
||||
case MATCH_PARENT:
|
||||
/* This mount obscures any previous ones. */
|
||||
*outcome = OUTCOME_NOTHING_MOUNTED;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return next(fd, buf, bufsize, '\n');
|
||||
}
|
||||
|
||||
/* which_tmpdir is called only during early boot */
|
||||
static int checked_tmpdir = 0;
|
||||
|
||||
/*
|
||||
* Look for a tmpfs mounted at /dev/shm. I couldn't find a cleaner
|
||||
* way to do this than to parse /proc/mounts. statfs will return the
|
||||
* same filesystem magic number and fs id for both /dev and /dev/shm
|
||||
* when they are both tmpfs, so you can't tell if they are different
|
||||
* filesystems. Also, there seems to be no other way of finding the
|
||||
* mount point of a filesystem from within it.
|
||||
*
|
||||
* If a /dev/shm tmpfs entry is found, then we switch to using it.
|
||||
* Otherwise, we stay with the default /tmp.
|
||||
*/
|
||||
static void which_tmpdir(void)
|
||||
{
|
||||
int fd;
|
||||
int found;
|
||||
int outcome;
|
||||
char *path;
|
||||
char *buf;
|
||||
size_t bufsize;
|
||||
|
||||
if (checked_tmpdir)
|
||||
return;
|
||||
|
||||
checked_tmpdir = 1;
|
||||
|
||||
printf("Checking for tmpfs mount on /dev/shm...");
|
||||
|
||||
path = realpath("/dev/shm", NULL);
|
||||
if (!path) {
|
||||
printf("failed to check real path, errno = %d\n", errno);
|
||||
return;
|
||||
}
|
||||
printf("%s...", path);
|
||||
|
||||
/*
|
||||
* The buffer needs to be able to fit the full octal-escaped path, a
|
||||
* space, and a trailing null in order to successfully decode it.
|
||||
*/
|
||||
bufsize = octal_encoded_length(path, " \t\n\\") + 2;
|
||||
|
||||
if (bufsize < 128)
|
||||
bufsize = 128;
|
||||
|
||||
buf = malloc(bufsize);
|
||||
if (!buf) {
|
||||
printf("malloc failed, errno = %d\n", errno);
|
||||
goto out;
|
||||
}
|
||||
buf[0] = '\0';
|
||||
|
||||
fd = open("/proc/mounts", O_RDONLY);
|
||||
if (fd < 0) {
|
||||
printf("failed to open /proc/mounts, errno = %d\n", errno);
|
||||
goto out1;
|
||||
}
|
||||
|
||||
outcome = OUTCOME_NOTHING_MOUNTED;
|
||||
while (1) {
|
||||
found = read_mount(fd, buf, bufsize, path, &outcome);
|
||||
if (found != 1)
|
||||
break;
|
||||
}
|
||||
|
||||
if (found < 0) {
|
||||
printf("read returned errno %d\n", -found);
|
||||
printf("Checking if %s is on tmpfs...", dir);
|
||||
if (statfs(dir, &st) < 0) {
|
||||
printf("%s\n", strerror(errno));
|
||||
} else if (st.f_type != TMPFS_MAGIC) {
|
||||
printf("no\n");
|
||||
} else {
|
||||
switch (outcome) {
|
||||
case OUTCOME_TMPFS_MOUNT:
|
||||
printf("OK\n");
|
||||
default_tmpdir = "/dev/shm";
|
||||
break;
|
||||
|
||||
case OUTCOME_NON_TMPFS_MOUNT:
|
||||
printf("not tmpfs\n");
|
||||
break;
|
||||
|
||||
default:
|
||||
printf("nothing mounted on /dev/shm\n");
|
||||
break;
|
||||
}
|
||||
printf("OK\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
close(fd);
|
||||
out1:
|
||||
free(buf);
|
||||
out:
|
||||
free(path);
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int __init make_tempfile(const char *template, char **out_tempname,
|
||||
int do_unlink)
|
||||
/*
|
||||
* Choose the tempdir to use. We want something on tmpfs so that our memory is
|
||||
* not subject to the host's vm.dirty_ratio. If a tempdir is specified in the
|
||||
* environment, we use that even if it's not on tmpfs, but we warn the user.
|
||||
* Otherwise, we try common tmpfs locations, and if no tmpfs directory is found
|
||||
* then we fall back to /tmp.
|
||||
*/
|
||||
static char * __init choose_tempdir(void)
|
||||
{
|
||||
static const char * const vars[] = {
|
||||
"TMPDIR",
|
||||
"TMP",
|
||||
"TEMP",
|
||||
NULL
|
||||
};
|
||||
static const char fallback_dir[] = "/tmp";
|
||||
static const char * const tmpfs_dirs[] = {
|
||||
"/dev/shm",
|
||||
fallback_dir,
|
||||
NULL
|
||||
};
|
||||
int i;
|
||||
const char *dir;
|
||||
|
||||
printf("Checking environment variables for a tempdir...");
|
||||
for (i = 0; vars[i]; i++) {
|
||||
dir = getenv(vars[i]);
|
||||
if ((dir != NULL) && (*dir != '\0')) {
|
||||
printf("%s\n", dir);
|
||||
if (check_tmpfs(dir) >= 0)
|
||||
goto done;
|
||||
else
|
||||
goto warn;
|
||||
}
|
||||
}
|
||||
printf("none found\n");
|
||||
|
||||
for (i = 0; tmpfs_dirs[i]; i++) {
|
||||
dir = tmpfs_dirs[i];
|
||||
if (check_tmpfs(dir) >= 0)
|
||||
goto done;
|
||||
}
|
||||
|
||||
dir = fallback_dir;
|
||||
warn:
|
||||
printf("Warning: tempdir %s is not on tmpfs\n", dir);
|
||||
done:
|
||||
/* Make a copy since getenv results may not remain valid forever. */
|
||||
return strdup(dir);
|
||||
}
|
||||
|
||||
/*
|
||||
* Create an unlinked tempfile in a suitable tempdir. template must be the
|
||||
* basename part of the template with a leading '/'.
|
||||
*/
|
||||
static int __init make_tempfile(const char *template)
|
||||
{
|
||||
char *tempname;
|
||||
int fd;
|
||||
|
||||
which_tmpdir();
|
||||
tempname = malloc(MAXPATHLEN);
|
||||
if (tempdir == NULL) {
|
||||
tempdir = choose_tempdir();
|
||||
if (tempdir == NULL) {
|
||||
fprintf(stderr, "Failed to choose tempdir: %s\n",
|
||||
strerror(errno));
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
tempname = malloc(strlen(tempdir) + strlen(template) + 1);
|
||||
if (tempname == NULL)
|
||||
return -1;
|
||||
|
||||
find_tempdir();
|
||||
if ((tempdir == NULL) || (strlen(tempdir) >= MAXPATHLEN))
|
||||
goto out;
|
||||
|
||||
if (template[0] != '/')
|
||||
strcpy(tempname, tempdir);
|
||||
else
|
||||
tempname[0] = '\0';
|
||||
strncat(tempname, template, MAXPATHLEN-1-strlen(tempname));
|
||||
strcpy(tempname, tempdir);
|
||||
strcat(tempname, template);
|
||||
fd = mkstemp(tempname);
|
||||
if (fd < 0) {
|
||||
fprintf(stderr, "open - cannot create %s: %s\n", tempname,
|
||||
strerror(errno));
|
||||
goto out;
|
||||
}
|
||||
if (do_unlink && (unlink(tempname) < 0)) {
|
||||
if (unlink(tempname) < 0) {
|
||||
perror("unlink");
|
||||
goto close;
|
||||
}
|
||||
if (out_tempname) {
|
||||
*out_tempname = tempname;
|
||||
} else
|
||||
free(tempname);
|
||||
free(tempname);
|
||||
return fd;
|
||||
close:
|
||||
close(fd);
|
||||
@ -351,14 +131,14 @@ static int __init make_tempfile(const char *template, char **out_tempname,
|
||||
return -1;
|
||||
}
|
||||
|
||||
#define TEMPNAME_TEMPLATE "vm_file-XXXXXX"
|
||||
#define TEMPNAME_TEMPLATE "/vm_file-XXXXXX"
|
||||
|
||||
static int __init create_tmp_file(unsigned long long len)
|
||||
{
|
||||
int fd, err;
|
||||
char zero;
|
||||
|
||||
fd = make_tempfile(TEMPNAME_TEMPLATE, NULL, 1);
|
||||
fd = make_tempfile(TEMPNAME_TEMPLATE);
|
||||
if (fd < 0)
|
||||
exit(1);
|
||||
|
||||
@ -402,7 +182,6 @@ int __init create_mem_file(unsigned long long len)
|
||||
return fd;
|
||||
}
|
||||
|
||||
|
||||
void __init check_tmpexec(void)
|
||||
{
|
||||
void *addr;
|
||||
@ -410,14 +189,13 @@ void __init check_tmpexec(void)
|
||||
|
||||
addr = mmap(NULL, UM_KERN_PAGE_SIZE,
|
||||
PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE, fd, 0);
|
||||
printf("Checking PROT_EXEC mmap in %s...",tempdir);
|
||||
fflush(stdout);
|
||||
printf("Checking PROT_EXEC mmap in %s...", tempdir);
|
||||
if (addr == MAP_FAILED) {
|
||||
err = errno;
|
||||
perror("failed");
|
||||
printf("%s\n", strerror(err));
|
||||
close(fd);
|
||||
if (err == EPERM)
|
||||
printf("%s must be not mounted noexec\n",tempdir);
|
||||
printf("%s must be not mounted noexec\n", tempdir);
|
||||
exit(1);
|
||||
}
|
||||
printf("OK\n");
|
||||
|
||||
Loading…
Reference in New Issue
Block a user