License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 15:07:57 +01:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2012-06-01 01:26:10 +02:00
|
|
|
/*
|
|
|
|
* Many of the syscalls used in this file expect some of the arguments
|
|
|
|
* to be __user pointers not __kernel pointers. To limit the sparse
|
|
|
|
* noise, turn off sparse checking for this file.
|
|
|
|
*/
|
|
|
|
#ifdef __CHECKER__
|
|
|
|
#undef __CHECKER__
|
|
|
|
#warning "Sparse checking disabled for this file"
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/fcntl.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/string.h>
|
2008-08-13 11:26:01 +02:00
|
|
|
#include <linux/dirent.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <linux/syscalls.h>
|
2008-10-16 07:01:40 +02:00
|
|
|
#include <linux/utime.h>
|
2017-02-27 23:28:12 +01:00
|
|
|
#include <linux/file.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
initramfs: support initrd that is bigger than 2GiB
When initrd (compressed or not) is used, kernel report data corrupted with
/dev/ram0.
The root cause:
During initramfs checking, if it is initrd, it will be transferred to
/initrd.image with sys_write.
sys_write only support 2G-4K write, so if the initrd ram is more than
that, /initrd.image will not complete at all.
Add local xwrite to loop calling sys_write to workaround the problem.
Also need to use xwrite in write_buffer() to handle:
image is uncompressed cpio and there is one big file (>2G) in it.
unpack_to_rootfs ===> write_buffer ===> actions[]/do_copy
At the same time, we don't need to worry about sys_read/sys_write in
do_mounts_rd.c::crd_load. As decompressor will have fill/flush and local
buffer that is smaller than 2G.
Test with uncompressed initrd, and compressed ones with gz, bz2, lzma,xz,
lzop.
Signed-off-by: Yinghai Lu <yinghai@kernel.org>
Acked-by: H. Peter Anvin <hpa@zytor.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Geert Uytterhoeven <geert@linux-m68k.org>
Cc: Tetsuo Handa <penguin-kernel@i-love.sakura.ne.jp>
Cc: "Daniel M. Weeks" <dan@danweeks.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-08-08 23:23:12 +02:00
|
|
|
static ssize_t __init xwrite(int fd, const char *p, size_t count)
|
|
|
|
{
|
|
|
|
ssize_t out = 0;
|
|
|
|
|
|
|
|
/* sys_write only can write MAX_RW_COUNT aka 2G-4K bytes at most */
|
|
|
|
while (count) {
|
2018-03-11 11:34:41 +01:00
|
|
|
ssize_t rv = ksys_write(fd, p, count);
|
initramfs: support initrd that is bigger than 2GiB
When initrd (compressed or not) is used, kernel report data corrupted with
/dev/ram0.
The root cause:
During initramfs checking, if it is initrd, it will be transferred to
/initrd.image with sys_write.
sys_write only support 2G-4K write, so if the initrd ram is more than
that, /initrd.image will not complete at all.
Add local xwrite to loop calling sys_write to workaround the problem.
Also need to use xwrite in write_buffer() to handle:
image is uncompressed cpio and there is one big file (>2G) in it.
unpack_to_rootfs ===> write_buffer ===> actions[]/do_copy
At the same time, we don't need to worry about sys_read/sys_write in
do_mounts_rd.c::crd_load. As decompressor will have fill/flush and local
buffer that is smaller than 2G.
Test with uncompressed initrd, and compressed ones with gz, bz2, lzma,xz,
lzop.
Signed-off-by: Yinghai Lu <yinghai@kernel.org>
Acked-by: H. Peter Anvin <hpa@zytor.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Geert Uytterhoeven <geert@linux-m68k.org>
Cc: Tetsuo Handa <penguin-kernel@i-love.sakura.ne.jp>
Cc: "Daniel M. Weeks" <dan@danweeks.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-08-08 23:23:12 +02:00
|
|
|
|
|
|
|
if (rv < 0) {
|
|
|
|
if (rv == -EINTR || rv == -EAGAIN)
|
|
|
|
continue;
|
|
|
|
return out ? out : rv;
|
|
|
|
} else if (rv == 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
p += rv;
|
|
|
|
out += rv;
|
|
|
|
count -= rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static __initdata char *message;
|
|
|
|
static void __init error(char *x)
|
|
|
|
{
|
|
|
|
if (!message)
|
|
|
|
message = x;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* link hash */
|
|
|
|
|
2006-05-15 18:44:03 +02:00
|
|
|
#define N_ALIGN(len) ((((len) + 1) & ~3) + 2)
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static __initdata struct hash {
|
|
|
|
int ino, minor, major;
|
2011-07-26 10:34:13 +02:00
|
|
|
umode_t mode;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct hash *next;
|
2006-05-15 18:44:03 +02:00
|
|
|
char name[N_ALIGN(PATH_MAX)];
|
2005-04-17 00:20:36 +02:00
|
|
|
} *head[32];
|
|
|
|
|
|
|
|
static inline int hash(int major, int minor, int ino)
|
|
|
|
{
|
|
|
|
unsigned long tmp = ino + minor + (major << 3);
|
|
|
|
tmp += tmp >> 5;
|
|
|
|
return tmp & 31;
|
|
|
|
}
|
|
|
|
|
2006-06-26 09:28:02 +02:00
|
|
|
static char __init *find_link(int major, int minor, int ino,
|
2011-07-26 10:34:13 +02:00
|
|
|
umode_t mode, char *name)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct hash **p, *q;
|
|
|
|
for (p = head + hash(major, minor, ino); *p; p = &(*p)->next) {
|
|
|
|
if ((*p)->ino != ino)
|
|
|
|
continue;
|
|
|
|
if ((*p)->minor != minor)
|
|
|
|
continue;
|
|
|
|
if ((*p)->major != major)
|
|
|
|
continue;
|
2006-06-26 09:28:02 +02:00
|
|
|
if (((*p)->mode ^ mode) & S_IFMT)
|
|
|
|
continue;
|
2005-04-17 00:20:36 +02:00
|
|
|
return (*p)->name;
|
|
|
|
}
|
2008-04-29 09:59:43 +02:00
|
|
|
q = kmalloc(sizeof(struct hash), GFP_KERNEL);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!q)
|
|
|
|
panic("can't allocate link hash entry");
|
|
|
|
q->major = major;
|
2006-06-26 09:28:02 +02:00
|
|
|
q->minor = minor;
|
|
|
|
q->ino = ino;
|
|
|
|
q->mode = mode;
|
2006-05-15 18:44:03 +02:00
|
|
|
strcpy(q->name, name);
|
2005-04-17 00:20:36 +02:00
|
|
|
q->next = NULL;
|
|
|
|
*p = q;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __init free_hash(void)
|
|
|
|
{
|
|
|
|
struct hash **p, *q;
|
|
|
|
for (p = head; p < head + 32; p++) {
|
|
|
|
while (*p) {
|
|
|
|
q = *p;
|
|
|
|
*p = q->next;
|
2008-04-29 09:59:43 +02:00
|
|
|
kfree(q);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-11-18 00:31:04 +01:00
|
|
|
static long __init do_utime(char *filename, time64_t mtime)
|
2008-10-16 07:01:40 +02:00
|
|
|
{
|
2017-08-03 04:51:15 +02:00
|
|
|
struct timespec64 t[2];
|
2008-10-16 07:01:40 +02:00
|
|
|
|
|
|
|
t[0].tv_sec = mtime;
|
|
|
|
t[0].tv_nsec = 0;
|
|
|
|
t[1].tv_sec = mtime;
|
|
|
|
t[1].tv_nsec = 0;
|
|
|
|
|
|
|
|
return do_utimes(AT_FDCWD, filename, t, AT_SYMLINK_NOFOLLOW);
|
|
|
|
}
|
|
|
|
|
|
|
|
static __initdata LIST_HEAD(dir_list);
|
|
|
|
struct dir_entry {
|
|
|
|
struct list_head list;
|
|
|
|
char *name;
|
2017-11-18 00:31:04 +01:00
|
|
|
time64_t mtime;
|
2008-10-16 07:01:40 +02:00
|
|
|
};
|
|
|
|
|
2017-11-18 00:31:04 +01:00
|
|
|
static void __init dir_add(const char *name, time64_t mtime)
|
2008-10-16 07:01:40 +02:00
|
|
|
{
|
|
|
|
struct dir_entry *de = kmalloc(sizeof(struct dir_entry), GFP_KERNEL);
|
|
|
|
if (!de)
|
|
|
|
panic("can't allocate dir_entry buffer");
|
|
|
|
INIT_LIST_HEAD(&de->list);
|
|
|
|
de->name = kstrdup(name, GFP_KERNEL);
|
|
|
|
de->mtime = mtime;
|
|
|
|
list_add(&de->list, &dir_list);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __init dir_utime(void)
|
|
|
|
{
|
|
|
|
struct dir_entry *de, *tmp;
|
|
|
|
list_for_each_entry_safe(de, tmp, &dir_list, list) {
|
|
|
|
list_del(&de->list);
|
|
|
|
do_utime(de->name, de->mtime);
|
|
|
|
kfree(de->name);
|
|
|
|
kfree(de);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-11-18 00:31:04 +01:00
|
|
|
static __initdata time64_t mtime;
|
2008-10-16 07:01:40 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* cpio header parsing */
|
|
|
|
|
|
|
|
static __initdata unsigned long ino, major, minor, nlink;
|
2011-07-26 10:34:13 +02:00
|
|
|
static __initdata umode_t mode;
|
2005-04-17 00:20:36 +02:00
|
|
|
static __initdata unsigned long body_len, name_len;
|
|
|
|
static __initdata uid_t uid;
|
|
|
|
static __initdata gid_t gid;
|
|
|
|
static __initdata unsigned rdev;
|
|
|
|
|
|
|
|
static void __init parse_header(char *s)
|
|
|
|
{
|
|
|
|
unsigned long parsed[12];
|
|
|
|
char buf[9];
|
|
|
|
int i;
|
|
|
|
|
|
|
|
buf[8] = '\0';
|
|
|
|
for (i = 0, s += 6; i < 12; i++, s += 8) {
|
|
|
|
memcpy(buf, s, 8);
|
|
|
|
parsed[i] = simple_strtoul(buf, NULL, 16);
|
|
|
|
}
|
|
|
|
ino = parsed[0];
|
|
|
|
mode = parsed[1];
|
|
|
|
uid = parsed[2];
|
|
|
|
gid = parsed[3];
|
|
|
|
nlink = parsed[4];
|
2017-11-18 00:31:04 +01:00
|
|
|
mtime = parsed[5]; /* breaks in y2106 */
|
2005-04-17 00:20:36 +02:00
|
|
|
body_len = parsed[6];
|
|
|
|
major = parsed[7];
|
|
|
|
minor = parsed[8];
|
|
|
|
rdev = new_encode_dev(MKDEV(parsed[9], parsed[10]));
|
|
|
|
name_len = parsed[11];
|
|
|
|
}
|
|
|
|
|
|
|
|
/* FSM */
|
|
|
|
|
|
|
|
static __initdata enum state {
|
|
|
|
Start,
|
|
|
|
Collect,
|
|
|
|
GotHeader,
|
|
|
|
SkipIt,
|
|
|
|
GotName,
|
|
|
|
CopyFile,
|
|
|
|
GotSymlink,
|
|
|
|
Reset
|
|
|
|
} state, next_state;
|
|
|
|
|
|
|
|
static __initdata char *victim;
|
2014-10-14 00:54:07 +02:00
|
|
|
static unsigned long byte_count __initdata;
|
2005-04-17 00:20:36 +02:00
|
|
|
static __initdata loff_t this_header, next_header;
|
|
|
|
|
2007-07-26 18:33:59 +02:00
|
|
|
static inline void __init eat(unsigned n)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
victim += n;
|
|
|
|
this_header += n;
|
2014-10-14 00:54:07 +02:00
|
|
|
byte_count -= n;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-10-16 07:01:40 +02:00
|
|
|
static __initdata char *vcollected;
|
2005-04-17 00:20:36 +02:00
|
|
|
static __initdata char *collected;
|
initramfs: support initramfs that is bigger than 2GiB
Now with 64bit bzImage and kexec tools, we support ramdisk that size is
bigger than 2g, as we could put it above 4G.
Found compressed initramfs image could not be decompressed properly. It
turns out that image length is int during decompress detection, and it
will become < 0 when length is more than 2G. Furthermore, during
decompressing len as int is used for inbuf count, that has problem too.
Change len to long, that should be ok as on 32 bit platform long is
32bits.
Tested with following compressed initramfs image as root with kexec.
gzip, bzip2, xz, lzma, lzop, lz4.
run time for populate_rootfs():
size name Nehalem-EX Westmere-EX Ivybridge-EX
9034400256 root_img : 26s 24s 30s
3561095057 root_img.lz4 : 28s 27s 27s
3459554629 root_img.lzo : 29s 29s 28s
3219399480 root_img.gz : 64s 62s 49s
2251594592 root_img.xz : 262s 260s 183s
2226366598 root_img.lzma: 386s 376s 277s
2901482513 root_img.bz2 : 635s 599s
Signed-off-by: Yinghai Lu <yinghai@kernel.org>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Rashika Kheria <rashika.kheria@gmail.com>
Cc: Josh Triplett <josh@joshtriplett.org>
Cc: Kyungsik Lee <kyungsik.lee@lge.com>
Cc: P J P <ppandit@redhat.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Tetsuo Handa <penguin-kernel@i-love.sakura.ne.jp>
Cc: "Daniel M. Weeks" <dan@danweeks.net>
Cc: Alexandre Courbot <acourbot@nvidia.com>
Cc: Jan Beulich <JBeulich@suse.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-08-08 23:23:14 +02:00
|
|
|
static long remains __initdata;
|
2005-04-17 00:20:36 +02:00
|
|
|
static __initdata char *collect;
|
|
|
|
|
|
|
|
static void __init read_into(char *buf, unsigned size, enum state next)
|
|
|
|
{
|
2014-10-14 00:54:07 +02:00
|
|
|
if (byte_count >= size) {
|
2005-04-17 00:20:36 +02:00
|
|
|
collected = victim;
|
|
|
|
eat(size);
|
|
|
|
state = next;
|
|
|
|
} else {
|
|
|
|
collect = collected = buf;
|
|
|
|
remains = size;
|
|
|
|
next_state = next;
|
|
|
|
state = Collect;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static __initdata char *header_buf, *symlink_buf, *name_buf;
|
|
|
|
|
|
|
|
static int __init do_start(void)
|
|
|
|
{
|
|
|
|
read_into(header_buf, 110, GotHeader);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init do_collect(void)
|
|
|
|
{
|
initramfs: support initramfs that is bigger than 2GiB
Now with 64bit bzImage and kexec tools, we support ramdisk that size is
bigger than 2g, as we could put it above 4G.
Found compressed initramfs image could not be decompressed properly. It
turns out that image length is int during decompress detection, and it
will become < 0 when length is more than 2G. Furthermore, during
decompressing len as int is used for inbuf count, that has problem too.
Change len to long, that should be ok as on 32 bit platform long is
32bits.
Tested with following compressed initramfs image as root with kexec.
gzip, bzip2, xz, lzma, lzop, lz4.
run time for populate_rootfs():
size name Nehalem-EX Westmere-EX Ivybridge-EX
9034400256 root_img : 26s 24s 30s
3561095057 root_img.lz4 : 28s 27s 27s
3459554629 root_img.lzo : 29s 29s 28s
3219399480 root_img.gz : 64s 62s 49s
2251594592 root_img.xz : 262s 260s 183s
2226366598 root_img.lzma: 386s 376s 277s
2901482513 root_img.bz2 : 635s 599s
Signed-off-by: Yinghai Lu <yinghai@kernel.org>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Rashika Kheria <rashika.kheria@gmail.com>
Cc: Josh Triplett <josh@joshtriplett.org>
Cc: Kyungsik Lee <kyungsik.lee@lge.com>
Cc: P J P <ppandit@redhat.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Tetsuo Handa <penguin-kernel@i-love.sakura.ne.jp>
Cc: "Daniel M. Weeks" <dan@danweeks.net>
Cc: Alexandre Courbot <acourbot@nvidia.com>
Cc: Jan Beulich <JBeulich@suse.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-08-08 23:23:14 +02:00
|
|
|
unsigned long n = remains;
|
2014-10-14 00:54:07 +02:00
|
|
|
if (byte_count < n)
|
|
|
|
n = byte_count;
|
2005-04-17 00:20:36 +02:00
|
|
|
memcpy(collect, victim, n);
|
|
|
|
eat(n);
|
|
|
|
collect += n;
|
|
|
|
if ((remains -= n) != 0)
|
|
|
|
return 1;
|
|
|
|
state = next_state;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init do_header(void)
|
|
|
|
{
|
2006-12-07 05:37:19 +01:00
|
|
|
if (memcmp(collected, "070707", 6)==0) {
|
|
|
|
error("incorrect cpio method used: use -H newc option");
|
|
|
|
return 1;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
if (memcmp(collected, "070701", 6)) {
|
|
|
|
error("no cpio magic");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
parse_header(collected);
|
|
|
|
next_header = this_header + N_ALIGN(name_len) + body_len;
|
|
|
|
next_header = (next_header + 3) & ~3;
|
|
|
|
state = SkipIt;
|
|
|
|
if (name_len <= 0 || name_len > PATH_MAX)
|
|
|
|
return 0;
|
|
|
|
if (S_ISLNK(mode)) {
|
|
|
|
if (body_len > PATH_MAX)
|
|
|
|
return 0;
|
|
|
|
collect = collected = symlink_buf;
|
|
|
|
remains = N_ALIGN(name_len) + body_len;
|
|
|
|
next_state = GotSymlink;
|
|
|
|
state = Collect;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (S_ISREG(mode) || !body_len)
|
|
|
|
read_into(name_buf, N_ALIGN(name_len), GotName);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init do_skip(void)
|
|
|
|
{
|
2014-10-14 00:54:07 +02:00
|
|
|
if (this_header + byte_count < next_header) {
|
|
|
|
eat(byte_count);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 1;
|
|
|
|
} else {
|
|
|
|
eat(next_header - this_header);
|
|
|
|
state = next_state;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init do_reset(void)
|
|
|
|
{
|
2014-10-14 00:54:07 +02:00
|
|
|
while (byte_count && *victim == '\0')
|
2005-04-17 00:20:36 +02:00
|
|
|
eat(1);
|
2014-10-14 00:54:07 +02:00
|
|
|
if (byte_count && (this_header & 3))
|
2005-04-17 00:20:36 +02:00
|
|
|
error("broken padding");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init maybe_link(void)
|
|
|
|
{
|
|
|
|
if (nlink >= 2) {
|
2006-06-26 09:28:02 +02:00
|
|
|
char *old = find_link(major, minor, ino, mode, collected);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (old)
|
|
|
|
return (sys_link(old, collected) < 0) ? -1 : 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-10-14 00:54:07 +02:00
|
|
|
static void __init clean_path(char *path, umode_t fmode)
|
2006-06-26 09:28:02 +02:00
|
|
|
{
|
2017-05-09 00:57:00 +02:00
|
|
|
struct kstat st;
|
2006-06-26 09:28:02 +02:00
|
|
|
|
2017-05-09 00:57:00 +02:00
|
|
|
if (!vfs_lstat(path, &st) && (st.mode ^ fmode) & S_IFMT) {
|
|
|
|
if (S_ISDIR(st.mode))
|
2006-06-26 09:28:02 +02:00
|
|
|
sys_rmdir(path);
|
|
|
|
else
|
|
|
|
sys_unlink(path);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static __initdata int wfd;
|
|
|
|
|
|
|
|
static int __init do_name(void)
|
|
|
|
{
|
|
|
|
state = SkipIt;
|
|
|
|
next_state = Reset;
|
|
|
|
if (strcmp(collected, "TRAILER!!!") == 0) {
|
|
|
|
free_hash();
|
|
|
|
return 0;
|
|
|
|
}
|
2006-06-26 09:28:02 +02:00
|
|
|
clean_path(collected, mode);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (S_ISREG(mode)) {
|
2006-06-26 09:28:02 +02:00
|
|
|
int ml = maybe_link();
|
|
|
|
if (ml >= 0) {
|
|
|
|
int openflags = O_WRONLY|O_CREAT;
|
|
|
|
if (ml != 1)
|
|
|
|
openflags |= O_TRUNC;
|
|
|
|
wfd = sys_open(collected, openflags, mode);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (wfd >= 0) {
|
|
|
|
sys_fchown(wfd, uid, gid);
|
|
|
|
sys_fchmod(wfd, mode);
|
2009-04-13 23:40:04 +02:00
|
|
|
if (body_len)
|
|
|
|
sys_ftruncate(wfd, body_len);
|
2008-10-16 07:01:40 +02:00
|
|
|
vcollected = kstrdup(collected, GFP_KERNEL);
|
2005-04-17 00:20:36 +02:00
|
|
|
state = CopyFile;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (S_ISDIR(mode)) {
|
|
|
|
sys_mkdir(collected, mode);
|
|
|
|
sys_chown(collected, uid, gid);
|
|
|
|
sys_chmod(collected, mode);
|
2008-10-16 07:01:40 +02:00
|
|
|
dir_add(collected, mtime);
|
2005-04-17 00:20:36 +02:00
|
|
|
} else if (S_ISBLK(mode) || S_ISCHR(mode) ||
|
|
|
|
S_ISFIFO(mode) || S_ISSOCK(mode)) {
|
|
|
|
if (maybe_link() == 0) {
|
|
|
|
sys_mknod(collected, mode, rdev);
|
|
|
|
sys_chown(collected, uid, gid);
|
|
|
|
sys_chmod(collected, mode);
|
2008-10-16 07:01:40 +02:00
|
|
|
do_utime(collected, mtime);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init do_copy(void)
|
|
|
|
{
|
2014-10-14 00:54:07 +02:00
|
|
|
if (byte_count >= body_len) {
|
2014-08-08 23:23:16 +02:00
|
|
|
if (xwrite(wfd, victim, body_len) != body_len)
|
|
|
|
error("write error");
|
2005-04-17 00:20:36 +02:00
|
|
|
sys_close(wfd);
|
2008-10-16 07:01:40 +02:00
|
|
|
do_utime(vcollected, mtime);
|
|
|
|
kfree(vcollected);
|
2005-04-17 00:20:36 +02:00
|
|
|
eat(body_len);
|
|
|
|
state = SkipIt;
|
|
|
|
return 0;
|
|
|
|
} else {
|
2014-10-14 00:54:07 +02:00
|
|
|
if (xwrite(wfd, victim, byte_count) != byte_count)
|
2014-08-08 23:23:16 +02:00
|
|
|
error("write error");
|
2014-10-14 00:54:07 +02:00
|
|
|
body_len -= byte_count;
|
|
|
|
eat(byte_count);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init do_symlink(void)
|
|
|
|
{
|
|
|
|
collected[N_ALIGN(name_len) + body_len] = '\0';
|
2006-06-26 09:28:02 +02:00
|
|
|
clean_path(collected, 0);
|
2005-04-17 00:20:36 +02:00
|
|
|
sys_symlink(collected + N_ALIGN(name_len), collected);
|
|
|
|
sys_lchown(collected, uid, gid);
|
2008-10-16 07:01:40 +02:00
|
|
|
do_utime(collected, mtime);
|
2005-04-17 00:20:36 +02:00
|
|
|
state = SkipIt;
|
|
|
|
next_state = Reset;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __initdata int (*actions[])(void) = {
|
|
|
|
[Start] = do_start,
|
|
|
|
[Collect] = do_collect,
|
|
|
|
[GotHeader] = do_header,
|
|
|
|
[SkipIt] = do_skip,
|
|
|
|
[GotName] = do_name,
|
|
|
|
[CopyFile] = do_copy,
|
|
|
|
[GotSymlink] = do_symlink,
|
|
|
|
[Reset] = do_reset,
|
|
|
|
};
|
|
|
|
|
initramfs: support initramfs that is bigger than 2GiB
Now with 64bit bzImage and kexec tools, we support ramdisk that size is
bigger than 2g, as we could put it above 4G.
Found compressed initramfs image could not be decompressed properly. It
turns out that image length is int during decompress detection, and it
will become < 0 when length is more than 2G. Furthermore, during
decompressing len as int is used for inbuf count, that has problem too.
Change len to long, that should be ok as on 32 bit platform long is
32bits.
Tested with following compressed initramfs image as root with kexec.
gzip, bzip2, xz, lzma, lzop, lz4.
run time for populate_rootfs():
size name Nehalem-EX Westmere-EX Ivybridge-EX
9034400256 root_img : 26s 24s 30s
3561095057 root_img.lz4 : 28s 27s 27s
3459554629 root_img.lzo : 29s 29s 28s
3219399480 root_img.gz : 64s 62s 49s
2251594592 root_img.xz : 262s 260s 183s
2226366598 root_img.lzma: 386s 376s 277s
2901482513 root_img.bz2 : 635s 599s
Signed-off-by: Yinghai Lu <yinghai@kernel.org>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Rashika Kheria <rashika.kheria@gmail.com>
Cc: Josh Triplett <josh@joshtriplett.org>
Cc: Kyungsik Lee <kyungsik.lee@lge.com>
Cc: P J P <ppandit@redhat.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Tetsuo Handa <penguin-kernel@i-love.sakura.ne.jp>
Cc: "Daniel M. Weeks" <dan@danweeks.net>
Cc: Alexandre Courbot <acourbot@nvidia.com>
Cc: Jan Beulich <JBeulich@suse.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-08-08 23:23:14 +02:00
|
|
|
static long __init write_buffer(char *buf, unsigned long len)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2014-10-14 00:54:07 +02:00
|
|
|
byte_count = len;
|
2005-04-17 00:20:36 +02:00
|
|
|
victim = buf;
|
|
|
|
|
|
|
|
while (!actions[state]())
|
|
|
|
;
|
2014-10-14 00:54:07 +02:00
|
|
|
return len - byte_count;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
initramfs: support initramfs that is bigger than 2GiB
Now with 64bit bzImage and kexec tools, we support ramdisk that size is
bigger than 2g, as we could put it above 4G.
Found compressed initramfs image could not be decompressed properly. It
turns out that image length is int during decompress detection, and it
will become < 0 when length is more than 2G. Furthermore, during
decompressing len as int is used for inbuf count, that has problem too.
Change len to long, that should be ok as on 32 bit platform long is
32bits.
Tested with following compressed initramfs image as root with kexec.
gzip, bzip2, xz, lzma, lzop, lz4.
run time for populate_rootfs():
size name Nehalem-EX Westmere-EX Ivybridge-EX
9034400256 root_img : 26s 24s 30s
3561095057 root_img.lz4 : 28s 27s 27s
3459554629 root_img.lzo : 29s 29s 28s
3219399480 root_img.gz : 64s 62s 49s
2251594592 root_img.xz : 262s 260s 183s
2226366598 root_img.lzma: 386s 376s 277s
2901482513 root_img.bz2 : 635s 599s
Signed-off-by: Yinghai Lu <yinghai@kernel.org>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Rashika Kheria <rashika.kheria@gmail.com>
Cc: Josh Triplett <josh@joshtriplett.org>
Cc: Kyungsik Lee <kyungsik.lee@lge.com>
Cc: P J P <ppandit@redhat.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Tetsuo Handa <penguin-kernel@i-love.sakura.ne.jp>
Cc: "Daniel M. Weeks" <dan@danweeks.net>
Cc: Alexandre Courbot <acourbot@nvidia.com>
Cc: Jan Beulich <JBeulich@suse.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-08-08 23:23:14 +02:00
|
|
|
static long __init flush_buffer(void *bufv, unsigned long len)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2009-01-04 22:46:17 +01:00
|
|
|
char *buf = (char *) bufv;
|
initramfs: support initramfs that is bigger than 2GiB
Now with 64bit bzImage and kexec tools, we support ramdisk that size is
bigger than 2g, as we could put it above 4G.
Found compressed initramfs image could not be decompressed properly. It
turns out that image length is int during decompress detection, and it
will become < 0 when length is more than 2G. Furthermore, during
decompressing len as int is used for inbuf count, that has problem too.
Change len to long, that should be ok as on 32 bit platform long is
32bits.
Tested with following compressed initramfs image as root with kexec.
gzip, bzip2, xz, lzma, lzop, lz4.
run time for populate_rootfs():
size name Nehalem-EX Westmere-EX Ivybridge-EX
9034400256 root_img : 26s 24s 30s
3561095057 root_img.lz4 : 28s 27s 27s
3459554629 root_img.lzo : 29s 29s 28s
3219399480 root_img.gz : 64s 62s 49s
2251594592 root_img.xz : 262s 260s 183s
2226366598 root_img.lzma: 386s 376s 277s
2901482513 root_img.bz2 : 635s 599s
Signed-off-by: Yinghai Lu <yinghai@kernel.org>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Rashika Kheria <rashika.kheria@gmail.com>
Cc: Josh Triplett <josh@joshtriplett.org>
Cc: Kyungsik Lee <kyungsik.lee@lge.com>
Cc: P J P <ppandit@redhat.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Tetsuo Handa <penguin-kernel@i-love.sakura.ne.jp>
Cc: "Daniel M. Weeks" <dan@danweeks.net>
Cc: Alexandre Courbot <acourbot@nvidia.com>
Cc: Jan Beulich <JBeulich@suse.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-08-08 23:23:14 +02:00
|
|
|
long written;
|
|
|
|
long origLen = len;
|
2005-04-17 00:20:36 +02:00
|
|
|
if (message)
|
2009-01-04 22:46:17 +01:00
|
|
|
return -1;
|
2005-04-17 00:20:36 +02:00
|
|
|
while ((written = write_buffer(buf, len)) < len && !message) {
|
|
|
|
char c = buf[written];
|
|
|
|
if (c == '0') {
|
|
|
|
buf += written;
|
|
|
|
len -= written;
|
|
|
|
state = Start;
|
|
|
|
} else if (c == 0) {
|
|
|
|
buf += written;
|
|
|
|
len -= written;
|
|
|
|
state = Reset;
|
|
|
|
} else
|
|
|
|
error("junk in compressed archive");
|
|
|
|
}
|
2009-01-04 22:46:17 +01:00
|
|
|
return origLen;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
initramfs: support initramfs that is bigger than 2GiB
Now with 64bit bzImage and kexec tools, we support ramdisk that size is
bigger than 2g, as we could put it above 4G.
Found compressed initramfs image could not be decompressed properly. It
turns out that image length is int during decompress detection, and it
will become < 0 when length is more than 2G. Furthermore, during
decompressing len as int is used for inbuf count, that has problem too.
Change len to long, that should be ok as on 32 bit platform long is
32bits.
Tested with following compressed initramfs image as root with kexec.
gzip, bzip2, xz, lzma, lzop, lz4.
run time for populate_rootfs():
size name Nehalem-EX Westmere-EX Ivybridge-EX
9034400256 root_img : 26s 24s 30s
3561095057 root_img.lz4 : 28s 27s 27s
3459554629 root_img.lzo : 29s 29s 28s
3219399480 root_img.gz : 64s 62s 49s
2251594592 root_img.xz : 262s 260s 183s
2226366598 root_img.lzma: 386s 376s 277s
2901482513 root_img.bz2 : 635s 599s
Signed-off-by: Yinghai Lu <yinghai@kernel.org>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Rashika Kheria <rashika.kheria@gmail.com>
Cc: Josh Triplett <josh@joshtriplett.org>
Cc: Kyungsik Lee <kyungsik.lee@lge.com>
Cc: P J P <ppandit@redhat.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Tetsuo Handa <penguin-kernel@i-love.sakura.ne.jp>
Cc: "Daniel M. Weeks" <dan@danweeks.net>
Cc: Alexandre Courbot <acourbot@nvidia.com>
Cc: Jan Beulich <JBeulich@suse.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-08-08 23:23:14 +02:00
|
|
|
static unsigned long my_inptr; /* index of next byte to be processed in inbuf */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2009-01-09 00:14:17 +01:00
|
|
|
#include <linux/decompress/generic.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
initramfs: support initramfs that is bigger than 2GiB
Now with 64bit bzImage and kexec tools, we support ramdisk that size is
bigger than 2g, as we could put it above 4G.
Found compressed initramfs image could not be decompressed properly. It
turns out that image length is int during decompress detection, and it
will become < 0 when length is more than 2G. Furthermore, during
decompressing len as int is used for inbuf count, that has problem too.
Change len to long, that should be ok as on 32 bit platform long is
32bits.
Tested with following compressed initramfs image as root with kexec.
gzip, bzip2, xz, lzma, lzop, lz4.
run time for populate_rootfs():
size name Nehalem-EX Westmere-EX Ivybridge-EX
9034400256 root_img : 26s 24s 30s
3561095057 root_img.lz4 : 28s 27s 27s
3459554629 root_img.lzo : 29s 29s 28s
3219399480 root_img.gz : 64s 62s 49s
2251594592 root_img.xz : 262s 260s 183s
2226366598 root_img.lzma: 386s 376s 277s
2901482513 root_img.bz2 : 635s 599s
Signed-off-by: Yinghai Lu <yinghai@kernel.org>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Rashika Kheria <rashika.kheria@gmail.com>
Cc: Josh Triplett <josh@joshtriplett.org>
Cc: Kyungsik Lee <kyungsik.lee@lge.com>
Cc: P J P <ppandit@redhat.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Tetsuo Handa <penguin-kernel@i-love.sakura.ne.jp>
Cc: "Daniel M. Weeks" <dan@danweeks.net>
Cc: Alexandre Courbot <acourbot@nvidia.com>
Cc: Jan Beulich <JBeulich@suse.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-08-08 23:23:14 +02:00
|
|
|
static char * __init unpack_to_rootfs(char *buf, unsigned long len)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
initramfs: support initramfs that is bigger than 2GiB
Now with 64bit bzImage and kexec tools, we support ramdisk that size is
bigger than 2g, as we could put it above 4G.
Found compressed initramfs image could not be decompressed properly. It
turns out that image length is int during decompress detection, and it
will become < 0 when length is more than 2G. Furthermore, during
decompressing len as int is used for inbuf count, that has problem too.
Change len to long, that should be ok as on 32 bit platform long is
32bits.
Tested with following compressed initramfs image as root with kexec.
gzip, bzip2, xz, lzma, lzop, lz4.
run time for populate_rootfs():
size name Nehalem-EX Westmere-EX Ivybridge-EX
9034400256 root_img : 26s 24s 30s
3561095057 root_img.lz4 : 28s 27s 27s
3459554629 root_img.lzo : 29s 29s 28s
3219399480 root_img.gz : 64s 62s 49s
2251594592 root_img.xz : 262s 260s 183s
2226366598 root_img.lzma: 386s 376s 277s
2901482513 root_img.bz2 : 635s 599s
Signed-off-by: Yinghai Lu <yinghai@kernel.org>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Rashika Kheria <rashika.kheria@gmail.com>
Cc: Josh Triplett <josh@joshtriplett.org>
Cc: Kyungsik Lee <kyungsik.lee@lge.com>
Cc: P J P <ppandit@redhat.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Tetsuo Handa <penguin-kernel@i-love.sakura.ne.jp>
Cc: "Daniel M. Weeks" <dan@danweeks.net>
Cc: Alexandre Courbot <acourbot@nvidia.com>
Cc: Jan Beulich <JBeulich@suse.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-08-08 23:23:14 +02:00
|
|
|
long written;
|
2009-01-09 00:14:17 +01:00
|
|
|
decompress_fn decompress;
|
2009-01-12 23:24:04 +01:00
|
|
|
const char *compress_name;
|
|
|
|
static __initdata char msg_buf[64];
|
2009-01-09 00:14:17 +01:00
|
|
|
|
2008-04-29 09:59:43 +02:00
|
|
|
header_buf = kmalloc(110, GFP_KERNEL);
|
|
|
|
symlink_buf = kmalloc(PATH_MAX + N_ALIGN(PATH_MAX) + 1, GFP_KERNEL);
|
|
|
|
name_buf = kmalloc(N_ALIGN(PATH_MAX), GFP_KERNEL);
|
2009-01-04 22:46:17 +01:00
|
|
|
|
|
|
|
if (!header_buf || !symlink_buf || !name_buf)
|
2005-04-17 00:20:36 +02:00
|
|
|
panic("can't allocate buffers");
|
2009-01-04 22:46:17 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
state = Start;
|
|
|
|
this_header = 0;
|
|
|
|
message = NULL;
|
|
|
|
while (!message && len) {
|
|
|
|
loff_t saved_offset = this_header;
|
|
|
|
if (*buf == '0' && !(this_header & 3)) {
|
|
|
|
state = Start;
|
|
|
|
written = write_buffer(buf, len);
|
|
|
|
buf += written;
|
|
|
|
len -= written;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!*buf) {
|
|
|
|
buf++;
|
|
|
|
len--;
|
|
|
|
this_header++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
this_header = 0;
|
2009-01-12 23:24:04 +01:00
|
|
|
decompress = decompress_method(buf, len, &compress_name);
|
2014-04-08 00:39:16 +02:00
|
|
|
pr_debug("Detected %s compressed data\n", compress_name);
|
2009-12-14 22:45:19 +01:00
|
|
|
if (decompress) {
|
initramfs: support initramfs that is bigger than 2GiB
Now with 64bit bzImage and kexec tools, we support ramdisk that size is
bigger than 2g, as we could put it above 4G.
Found compressed initramfs image could not be decompressed properly. It
turns out that image length is int during decompress detection, and it
will become < 0 when length is more than 2G. Furthermore, during
decompressing len as int is used for inbuf count, that has problem too.
Change len to long, that should be ok as on 32 bit platform long is
32bits.
Tested with following compressed initramfs image as root with kexec.
gzip, bzip2, xz, lzma, lzop, lz4.
run time for populate_rootfs():
size name Nehalem-EX Westmere-EX Ivybridge-EX
9034400256 root_img : 26s 24s 30s
3561095057 root_img.lz4 : 28s 27s 27s
3459554629 root_img.lzo : 29s 29s 28s
3219399480 root_img.gz : 64s 62s 49s
2251594592 root_img.xz : 262s 260s 183s
2226366598 root_img.lzma: 386s 376s 277s
2901482513 root_img.bz2 : 635s 599s
Signed-off-by: Yinghai Lu <yinghai@kernel.org>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Rashika Kheria <rashika.kheria@gmail.com>
Cc: Josh Triplett <josh@joshtriplett.org>
Cc: Kyungsik Lee <kyungsik.lee@lge.com>
Cc: P J P <ppandit@redhat.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Tetsuo Handa <penguin-kernel@i-love.sakura.ne.jp>
Cc: "Daniel M. Weeks" <dan@danweeks.net>
Cc: Alexandre Courbot <acourbot@nvidia.com>
Cc: Jan Beulich <JBeulich@suse.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-08-08 23:23:14 +02:00
|
|
|
int res = decompress(buf, len, NULL, flush_buffer, NULL,
|
2009-01-09 00:14:17 +01:00
|
|
|
&my_inptr, error);
|
2009-12-14 22:45:19 +01:00
|
|
|
if (res)
|
|
|
|
error("decompressor failed");
|
|
|
|
} else if (compress_name) {
|
2009-01-12 23:24:04 +01:00
|
|
|
if (!message) {
|
|
|
|
snprintf(msg_buf, sizeof msg_buf,
|
|
|
|
"compression method %s not configured",
|
|
|
|
compress_name);
|
|
|
|
message = msg_buf;
|
|
|
|
}
|
2010-04-23 19:18:11 +02:00
|
|
|
} else
|
|
|
|
error("junk in compressed archive");
|
2005-04-17 00:20:36 +02:00
|
|
|
if (state != Reset)
|
2009-01-04 22:46:17 +01:00
|
|
|
error("junk in compressed archive");
|
|
|
|
this_header = saved_offset + my_inptr;
|
|
|
|
buf += my_inptr;
|
|
|
|
len -= my_inptr;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-10-16 07:01:40 +02:00
|
|
|
dir_utime();
|
2008-04-29 09:59:43 +02:00
|
|
|
kfree(name_buf);
|
|
|
|
kfree(symlink_buf);
|
|
|
|
kfree(header_buf);
|
2005-04-17 00:20:36 +02:00
|
|
|
return message;
|
|
|
|
}
|
|
|
|
|
2007-02-10 10:44:33 +01:00
|
|
|
static int __initdata do_retain_initrd;
|
|
|
|
|
|
|
|
static int __init retain_initrd_param(char *str)
|
|
|
|
{
|
|
|
|
if (*str)
|
|
|
|
return 0;
|
|
|
|
do_retain_initrd = 1;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
__setup("retain_initrd", retain_initrd_param);
|
|
|
|
|
initramfs: fix initramfs size calculation
The size of a built-in initramfs is calculated in init/initramfs.c by
"__initramfs_end - __initramfs_start". Those symbols are defined in the
linker script include/asm-generic/vmlinux.lds.h:
#define INIT_RAM_FS \
. = ALIGN(PAGE_SIZE); \
VMLINUX_SYMBOL(__initramfs_start) = .; \
*(.init.ramfs) \
VMLINUX_SYMBOL(__initramfs_end) = .;
If the initramfs file has an odd number of bytes, the "__initramfs_end"
symbol points to an odd address, for example, the symbols in the
System.map might look like:
0000000000572000 T __initramfs_start
00000000005bcd05 T __initramfs_end <-- odd address
At least on s390 this causes a problem:
Certain s390 instructions, especially instructions for loading addresses
(larl) or branch addresses must be on even addresses. The compiler loads
the symbol addresses with the "larl" instruction. This instruction sets
the last bit to 0 and, therefore, for odd size files, the calculated size
is one byte less than it should be:
0000000000540a9c <populate_rootfs>:
540a9c: eb cf f0 78 00 24 stmg %r12,%r15,120(%r15),
540aa2: c0 10 00 01 8a af larl %r1,572000 <__initramfs_start>
540aa8: c0 c0 00 03 e1 2e larl %r12,5bcd04 <initramfs_end>
(Instead of 5bcd05)
...
540abe: 1b c1 sr %r12,%r1
To fix the problem, this patch introduces the global variable
__initramfs_size, which is calculated in the "usr/initramfs_data.S" file.
The populate_rootfs() function can then use the start marker of the
.init.ramfs section and the value of __initramfs_size for loading the
initramfs. Because the start marker and size is sufficient, the
__initramfs_end symbol is no longer needed and is removed.
Signed-off-by: Michael Holzheu <holzheu@linux.vnet.ibm.com>
Signed-off-by: Hendrik Brueckner <brueckner@linux.vnet.ibm.com>
Reviewed-by: WANG Cong <xiyou.wangcong@gmail.com>
Acked-by: Michal Marek <mmarek@suse.cz>
Acked-by: "H. Peter Anvin" <hpa@zytor.com>
Cc: Heiko Carstens <heiko.carstens@de.ibm.com>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Michal Marek <mmarek@suse.cz>
2010-09-18 00:24:11 +02:00
|
|
|
extern char __initramfs_start[];
|
|
|
|
extern unsigned long __initramfs_size;
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <linux/initrd.h>
|
2006-02-10 10:51:05 +01:00
|
|
|
#include <linux/kexec.h>
|
2005-09-13 10:25:12 +02:00
|
|
|
|
|
|
|
static void __init free_initrd(void)
|
|
|
|
{
|
2015-09-10 00:38:55 +02:00
|
|
|
#ifdef CONFIG_KEXEC_CORE
|
2006-02-10 10:51:05 +01:00
|
|
|
unsigned long crashk_start = (unsigned long)__va(crashk_res.start);
|
|
|
|
unsigned long crashk_end = (unsigned long)__va(crashk_res.end);
|
2007-02-10 10:44:33 +01:00
|
|
|
#endif
|
|
|
|
if (do_retain_initrd)
|
|
|
|
goto skip;
|
2006-02-10 10:51:05 +01:00
|
|
|
|
2015-09-10 00:38:55 +02:00
|
|
|
#ifdef CONFIG_KEXEC_CORE
|
2006-02-10 10:51:05 +01:00
|
|
|
/*
|
|
|
|
* If the initrd region is overlapped with crashkernel reserved region,
|
|
|
|
* free only memory that is not part of crashkernel region.
|
|
|
|
*/
|
|
|
|
if (initrd_start < crashk_end && initrd_end > crashk_start) {
|
|
|
|
/*
|
|
|
|
* Initialize initrd memory region since the kexec boot does
|
|
|
|
* not do.
|
|
|
|
*/
|
|
|
|
memset((void *)initrd_start, 0, initrd_end - initrd_start);
|
|
|
|
if (initrd_start < crashk_start)
|
|
|
|
free_initrd_mem(initrd_start, crashk_start);
|
|
|
|
if (initrd_end > crashk_end)
|
|
|
|
free_initrd_mem(crashk_end, initrd_end);
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
free_initrd_mem(initrd_start, initrd_end);
|
2007-02-10 10:44:33 +01:00
|
|
|
skip:
|
2005-09-13 10:25:12 +02:00
|
|
|
initrd_start = 0;
|
|
|
|
initrd_end = 0;
|
|
|
|
}
|
|
|
|
|
2009-04-13 23:39:38 +02:00
|
|
|
#ifdef CONFIG_BLK_DEV_RAM
|
2008-08-13 11:26:01 +02:00
|
|
|
#define BUF_SIZE 1024
|
|
|
|
static void __init clean_rootfs(void)
|
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
void *buf;
|
|
|
|
struct linux_dirent64 *dirp;
|
2010-03-05 22:42:39 +01:00
|
|
|
int num;
|
2008-08-13 11:26:01 +02:00
|
|
|
|
2012-06-01 01:26:10 +02:00
|
|
|
fd = sys_open("/", O_RDONLY, 0);
|
2008-08-13 11:26:01 +02:00
|
|
|
WARN_ON(fd < 0);
|
|
|
|
if (fd < 0)
|
|
|
|
return;
|
|
|
|
buf = kzalloc(BUF_SIZE, GFP_KERNEL);
|
|
|
|
WARN_ON(!buf);
|
|
|
|
if (!buf) {
|
|
|
|
sys_close(fd);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
dirp = buf;
|
2010-03-05 22:42:39 +01:00
|
|
|
num = sys_getdents64(fd, dirp, BUF_SIZE);
|
|
|
|
while (num > 0) {
|
|
|
|
while (num > 0) {
|
2017-05-09 00:57:00 +02:00
|
|
|
struct kstat st;
|
2008-08-13 11:26:01 +02:00
|
|
|
int ret;
|
|
|
|
|
2017-05-09 00:57:00 +02:00
|
|
|
ret = vfs_lstat(dirp->d_name, &st);
|
2008-08-13 11:26:01 +02:00
|
|
|
WARN_ON_ONCE(ret);
|
|
|
|
if (!ret) {
|
2017-05-09 00:57:00 +02:00
|
|
|
if (S_ISDIR(st.mode))
|
2008-08-13 11:26:01 +02:00
|
|
|
sys_rmdir(dirp->d_name);
|
|
|
|
else
|
|
|
|
sys_unlink(dirp->d_name);
|
|
|
|
}
|
|
|
|
|
2010-03-05 22:42:39 +01:00
|
|
|
num -= dirp->d_reclen;
|
2008-08-13 11:26:01 +02:00
|
|
|
dirp = (void *)dirp + dirp->d_reclen;
|
|
|
|
}
|
|
|
|
dirp = buf;
|
|
|
|
memset(buf, 0, BUF_SIZE);
|
2010-03-05 22:42:39 +01:00
|
|
|
num = sys_getdents64(fd, dirp, BUF_SIZE);
|
2008-08-13 11:26:01 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
sys_close(fd);
|
|
|
|
kfree(buf);
|
|
|
|
}
|
2009-04-13 23:39:38 +02:00
|
|
|
#endif
|
2008-08-13 11:26:01 +02:00
|
|
|
|
2008-03-15 19:53:32 +01:00
|
|
|
static int __init populate_rootfs(void)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2017-05-04 14:15:56 +02:00
|
|
|
/* Load the built in initramfs */
|
initramfs: fix initramfs size calculation
The size of a built-in initramfs is calculated in init/initramfs.c by
"__initramfs_end - __initramfs_start". Those symbols are defined in the
linker script include/asm-generic/vmlinux.lds.h:
#define INIT_RAM_FS \
. = ALIGN(PAGE_SIZE); \
VMLINUX_SYMBOL(__initramfs_start) = .; \
*(.init.ramfs) \
VMLINUX_SYMBOL(__initramfs_end) = .;
If the initramfs file has an odd number of bytes, the "__initramfs_end"
symbol points to an odd address, for example, the symbols in the
System.map might look like:
0000000000572000 T __initramfs_start
00000000005bcd05 T __initramfs_end <-- odd address
At least on s390 this causes a problem:
Certain s390 instructions, especially instructions for loading addresses
(larl) or branch addresses must be on even addresses. The compiler loads
the symbol addresses with the "larl" instruction. This instruction sets
the last bit to 0 and, therefore, for odd size files, the calculated size
is one byte less than it should be:
0000000000540a9c <populate_rootfs>:
540a9c: eb cf f0 78 00 24 stmg %r12,%r15,120(%r15),
540aa2: c0 10 00 01 8a af larl %r1,572000 <__initramfs_start>
540aa8: c0 c0 00 03 e1 2e larl %r12,5bcd04 <initramfs_end>
(Instead of 5bcd05)
...
540abe: 1b c1 sr %r12,%r1
To fix the problem, this patch introduces the global variable
__initramfs_size, which is calculated in the "usr/initramfs_data.S" file.
The populate_rootfs() function can then use the start marker of the
.init.ramfs section and the value of __initramfs_size for loading the
initramfs. Because the start marker and size is sufficient, the
__initramfs_end symbol is no longer needed and is removed.
Signed-off-by: Michael Holzheu <holzheu@linux.vnet.ibm.com>
Signed-off-by: Hendrik Brueckner <brueckner@linux.vnet.ibm.com>
Reviewed-by: WANG Cong <xiyou.wangcong@gmail.com>
Acked-by: Michal Marek <mmarek@suse.cz>
Acked-by: "H. Peter Anvin" <hpa@zytor.com>
Cc: Heiko Carstens <heiko.carstens@de.ibm.com>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Michal Marek <mmarek@suse.cz>
2010-09-18 00:24:11 +02:00
|
|
|
char *err = unpack_to_rootfs(__initramfs_start, __initramfs_size);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (err)
|
2014-01-24 00:54:56 +01:00
|
|
|
panic("%s", err); /* Failed to decompress INTERNAL initramfs */
|
2017-05-04 14:15:56 +02:00
|
|
|
/* If available load the bootloader supplied initrd */
|
2017-05-09 00:56:57 +02:00
|
|
|
if (initrd_start && !IS_ENABLED(CONFIG_INITRAMFS_FORCE)) {
|
2006-03-25 12:07:49 +01:00
|
|
|
#ifdef CONFIG_BLK_DEV_RAM
|
2005-04-17 00:20:36 +02:00
|
|
|
int fd;
|
2009-05-07 01:03:06 +02:00
|
|
|
printk(KERN_INFO "Trying to unpack rootfs image as initramfs...\n");
|
2005-04-17 00:20:36 +02:00
|
|
|
err = unpack_to_rootfs((char *)initrd_start,
|
2008-08-13 11:26:01 +02:00
|
|
|
initrd_end - initrd_start);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!err) {
|
2005-09-13 10:25:12 +02:00
|
|
|
free_initrd();
|
2013-01-18 23:05:56 +01:00
|
|
|
goto done;
|
2008-08-13 11:26:01 +02:00
|
|
|
} else {
|
|
|
|
clean_rootfs();
|
initramfs: fix initramfs size calculation
The size of a built-in initramfs is calculated in init/initramfs.c by
"__initramfs_end - __initramfs_start". Those symbols are defined in the
linker script include/asm-generic/vmlinux.lds.h:
#define INIT_RAM_FS \
. = ALIGN(PAGE_SIZE); \
VMLINUX_SYMBOL(__initramfs_start) = .; \
*(.init.ramfs) \
VMLINUX_SYMBOL(__initramfs_end) = .;
If the initramfs file has an odd number of bytes, the "__initramfs_end"
symbol points to an odd address, for example, the symbols in the
System.map might look like:
0000000000572000 T __initramfs_start
00000000005bcd05 T __initramfs_end <-- odd address
At least on s390 this causes a problem:
Certain s390 instructions, especially instructions for loading addresses
(larl) or branch addresses must be on even addresses. The compiler loads
the symbol addresses with the "larl" instruction. This instruction sets
the last bit to 0 and, therefore, for odd size files, the calculated size
is one byte less than it should be:
0000000000540a9c <populate_rootfs>:
540a9c: eb cf f0 78 00 24 stmg %r12,%r15,120(%r15),
540aa2: c0 10 00 01 8a af larl %r1,572000 <__initramfs_start>
540aa8: c0 c0 00 03 e1 2e larl %r12,5bcd04 <initramfs_end>
(Instead of 5bcd05)
...
540abe: 1b c1 sr %r12,%r1
To fix the problem, this patch introduces the global variable
__initramfs_size, which is calculated in the "usr/initramfs_data.S" file.
The populate_rootfs() function can then use the start marker of the
.init.ramfs section and the value of __initramfs_size for loading the
initramfs. Because the start marker and size is sufficient, the
__initramfs_end symbol is no longer needed and is removed.
Signed-off-by: Michael Holzheu <holzheu@linux.vnet.ibm.com>
Signed-off-by: Hendrik Brueckner <brueckner@linux.vnet.ibm.com>
Reviewed-by: WANG Cong <xiyou.wangcong@gmail.com>
Acked-by: Michal Marek <mmarek@suse.cz>
Acked-by: "H. Peter Anvin" <hpa@zytor.com>
Cc: Heiko Carstens <heiko.carstens@de.ibm.com>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Michal Marek <mmarek@suse.cz>
2010-09-18 00:24:11 +02:00
|
|
|
unpack_to_rootfs(__initramfs_start, __initramfs_size);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2009-04-03 01:57:00 +02:00
|
|
|
printk(KERN_INFO "rootfs image is not initramfs (%s)"
|
|
|
|
"; looks like an initrd\n", err);
|
2012-06-01 01:26:10 +02:00
|
|
|
fd = sys_open("/initrd.image",
|
2010-10-26 23:22:42 +02:00
|
|
|
O_WRONLY|O_CREAT, 0700);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (fd >= 0) {
|
initramfs: support initrd that is bigger than 2GiB
When initrd (compressed or not) is used, kernel report data corrupted with
/dev/ram0.
The root cause:
During initramfs checking, if it is initrd, it will be transferred to
/initrd.image with sys_write.
sys_write only support 2G-4K write, so if the initrd ram is more than
that, /initrd.image will not complete at all.
Add local xwrite to loop calling sys_write to workaround the problem.
Also need to use xwrite in write_buffer() to handle:
image is uncompressed cpio and there is one big file (>2G) in it.
unpack_to_rootfs ===> write_buffer ===> actions[]/do_copy
At the same time, we don't need to worry about sys_read/sys_write in
do_mounts_rd.c::crd_load. As decompressor will have fill/flush and local
buffer that is smaller than 2G.
Test with uncompressed initrd, and compressed ones with gz, bz2, lzma,xz,
lzop.
Signed-off-by: Yinghai Lu <yinghai@kernel.org>
Acked-by: H. Peter Anvin <hpa@zytor.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Geert Uytterhoeven <geert@linux-m68k.org>
Cc: Tetsuo Handa <penguin-kernel@i-love.sakura.ne.jp>
Cc: "Daniel M. Weeks" <dan@danweeks.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-08-08 23:23:12 +02:00
|
|
|
ssize_t written = xwrite(fd, (char *)initrd_start,
|
|
|
|
initrd_end - initrd_start);
|
|
|
|
|
|
|
|
if (written != initrd_end - initrd_start)
|
|
|
|
pr_err("/initrd.image: incomplete write (%zd != %ld)\n",
|
|
|
|
written, initrd_end - initrd_start);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
sys_close(fd);
|
2005-09-13 10:25:12 +02:00
|
|
|
free_initrd();
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2013-01-18 23:05:56 +01:00
|
|
|
done:
|
2017-05-06 19:27:13 +02:00
|
|
|
/* empty statement */;
|
2006-03-25 12:07:49 +01:00
|
|
|
#else
|
2009-05-07 01:03:06 +02:00
|
|
|
printk(KERN_INFO "Unpacking initramfs...\n");
|
2006-03-25 12:07:49 +01:00
|
|
|
err = unpack_to_rootfs((char *)initrd_start,
|
2008-08-13 11:26:01 +02:00
|
|
|
initrd_end - initrd_start);
|
2009-05-07 01:03:06 +02:00
|
|
|
if (err)
|
|
|
|
printk(KERN_EMERG "Initramfs unpacking failed: %s\n", err);
|
2006-03-25 12:07:49 +01:00
|
|
|
free_initrd();
|
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2017-05-04 14:15:56 +02:00
|
|
|
flush_delayed_fput();
|
|
|
|
/*
|
|
|
|
* Try loading default modules from initramfs. This gives
|
|
|
|
* us a chance to load before device_initcalls.
|
|
|
|
*/
|
|
|
|
load_default_modules();
|
|
|
|
|
2006-12-11 21:12:04 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2006-12-11 21:12:04 +01:00
|
|
|
rootfs_initcall(populate_rootfs);
|