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 22:07:57 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
|
* Architecture-specific setup.
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 1998-2003 Hewlett-Packard Co
|
|
|
|
|
* David Mosberger-Tang <davidm@hpl.hp.com>
|
2005-04-23 05:44:40 +08:00
|
|
|
* 04/11/17 Ashok Raj <ashok.raj@intel.com> Added CPU Hotplug Support
|
[IA64] Extend notify_die() hooks for IA64
notify_die() added for MCA_{MONARCH,SLAVE,RENDEZVOUS}_{ENTER,PROCESS,LEAVE} and
INIT_{MONARCH,SLAVE}_{ENTER,PROCESS,LEAVE}. We need multiple
notification points for these events because they can take many seconds
to run which has nasty effects on the behaviour of the rest of the
system.
DIE_SS replaced by a generic DIE_FAULT which checks the vector number,
to allow interception of faults other than SS.
DIE_MACHINE_{HALT,RESTART} added to allow last minute close down
processing, especially when the halt/restart routines are called from
error handlers.
DIE_OOPS added.
The check for kprobe's break numbers has been moved from traps.c to
kprobes.c, allowing DIE_BREAK to be used for any additional break
numbers, i.e. it is no longer kprobes specific.
Hooks for kernel debuggers and kernel dumpers added, ENTER and LEAVE.
Both of these disable the system for long periods which impact on
watchdogs and heartbeat systems in general. More patches to come that
use these events to reset watchdogs and heartbeats.
unregister_die_notifier() added and both routines exported. Requested
by Dean Nelson.
Lock removed from {un,}register_die_notifier. notifier_chain_register()
already takes a lock. Also the generic notifier chain locking is being
reworked to distinguish between callbacks that can block and those that
cannot, the lock in {un,}register_die_notifier would interfere with
that change. http://marc.theaimsgroup.com/?l=linux-kernel&m=113018709002036&w=2
Leading white space removed from arch/ia64/kernel/kprobes.c.
Typo in mca.c in original version of this patch found & fixed by Dean
Nelson.
Signed-off-by: Keith Owens <kaos@sgi.com>
Acked-by: Dean Nelson <dcn@sgi.com>
Acked-by: Anil Keshavamurthy <anil.s.keshavamurthy@intel.com>
Signed-off-by: Tony Luck <tony.luck@intel.com>
2005-11-08 03:27:13 +08:00
|
|
|
*
|
|
|
|
|
* 2005-10-07 Keith Owens <kaos@sgi.com>
|
|
|
|
|
* Add notify_die() hooks.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
|
#include <linux/cpu.h>
|
|
|
|
|
#include <linux/pm.h>
|
|
|
|
|
#include <linux/elf.h>
|
|
|
|
|
#include <linux/errno.h>
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
|
#include <linux/mm.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 16:04:11 +08:00
|
|
|
#include <linux/slab.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/module.h>
|
|
|
|
|
#include <linux/notifier.h>
|
|
|
|
|
#include <linux/personality.h>
|
|
|
|
|
#include <linux/sched.h>
|
2017-02-09 01:51:35 +08:00
|
|
|
#include <linux/sched/debug.h>
|
2017-02-09 01:51:36 +08:00
|
|
|
#include <linux/sched/hotplug.h>
|
2017-02-09 01:51:36 +08:00
|
|
|
#include <linux/sched/task.h>
|
2017-02-09 01:51:37 +08:00
|
|
|
#include <linux/sched/task_stack.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/stddef.h>
|
|
|
|
|
#include <linux/thread_info.h>
|
|
|
|
|
#include <linux/unistd.h>
|
|
|
|
|
#include <linux/efi.h>
|
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
|
#include <linux/delay.h>
|
2007-05-08 15:27:03 +08:00
|
|
|
#include <linux/kdebug.h>
|
2007-12-19 03:46:38 +08:00
|
|
|
#include <linux/utsname.h>
|
2008-10-07 01:43:06 +08:00
|
|
|
#include <linux/tracehook.h>
|
2012-08-25 04:22:13 +08:00
|
|
|
#include <linux/rcupdate.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
#include <asm/cpu.h>
|
|
|
|
|
#include <asm/delay.h>
|
|
|
|
|
#include <asm/elf.h>
|
|
|
|
|
#include <asm/irq.h>
|
2007-02-06 05:49:10 +08:00
|
|
|
#include <asm/kexec.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <asm/processor.h>
|
|
|
|
|
#include <asm/sal.h>
|
2012-03-30 04:35:22 +08:00
|
|
|
#include <asm/switch_to.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <asm/tlbflush.h>
|
2016-12-25 03:46:01 +08:00
|
|
|
#include <linux/uaccess.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <asm/unwind.h>
|
|
|
|
|
#include <asm/user.h>
|
2020-08-06 20:36:20 +08:00
|
|
|
#include <asm/xtp.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
#include "entry.h"
|
|
|
|
|
|
|
|
|
|
#include "sigframe.h"
|
|
|
|
|
|
|
|
|
|
void (*ia64_mark_idle)(int);
|
|
|
|
|
|
2010-11-04 00:06:14 +08:00
|
|
|
unsigned long boot_option_idle_override = IDLE_NO_OVERRIDE;
|
2005-04-17 06:20:36 +08:00
|
|
|
EXPORT_SYMBOL(boot_option_idle_override);
|
2010-02-26 05:09:52 +08:00
|
|
|
void (*pm_power_off) (void);
|
|
|
|
|
EXPORT_SYMBOL(pm_power_off);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2020-06-09 12:30:41 +08:00
|
|
|
static void
|
2005-04-17 06:20:36 +08:00
|
|
|
ia64_do_show_stack (struct unw_frame_info *info, void *arg)
|
|
|
|
|
{
|
|
|
|
|
unsigned long ip, sp, bsp;
|
2020-06-09 12:30:41 +08:00
|
|
|
const char *loglvl = arg;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2020-06-09 12:30:41 +08:00
|
|
|
printk("%s\nCall Trace:\n", loglvl);
|
2005-04-17 06:20:36 +08:00
|
|
|
do {
|
|
|
|
|
unw_get_ip(info, &ip);
|
|
|
|
|
if (ip == 0)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
unw_get_sp(info, &sp);
|
|
|
|
|
unw_get_bsp(info, &bsp);
|
2020-06-09 12:30:41 +08:00
|
|
|
printk("%s [<%016lx>] %pS\n"
|
2005-04-17 06:20:36 +08:00
|
|
|
" sp=%016lx bsp=%016lx\n",
|
2020-06-09 12:30:41 +08:00
|
|
|
loglvl, ip, (void *)ip, sp, bsp);
|
2005-04-17 06:20:36 +08:00
|
|
|
} while (unw_unwind(info) >= 0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2020-06-09 12:32:29 +08:00
|
|
|
show_stack (struct task_struct *task, unsigned long *sp, const char *loglvl)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
if (!task)
|
2020-06-09 12:30:44 +08:00
|
|
|
unw_init_running(ia64_do_show_stack, (void *)loglvl);
|
2005-04-17 06:20:36 +08:00
|
|
|
else {
|
|
|
|
|
struct unw_frame_info info;
|
|
|
|
|
|
|
|
|
|
unw_init_from_blocked_task(&info, task);
|
2020-06-09 12:30:44 +08:00
|
|
|
ia64_do_show_stack(&info, (void *)loglvl);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
show_regs (struct pt_regs *regs)
|
|
|
|
|
{
|
|
|
|
|
unsigned long ip = regs->cr_iip + ia64_psr(regs)->ri;
|
|
|
|
|
|
|
|
|
|
print_modules();
|
dump_stack: unify debug information printed by show_regs()
show_regs() is inherently arch-dependent but it does make sense to print
generic debug information and some archs already do albeit in slightly
different forms. This patch introduces a generic function to print debug
information from show_regs() so that different archs print out the same
information and it's much easier to modify what's printed.
show_regs_print_info() prints out the same debug info as dump_stack()
does plus task and thread_info pointers.
* Archs which didn't print debug info now do.
alpha, arc, blackfin, c6x, cris, frv, h8300, hexagon, ia64, m32r,
metag, microblaze, mn10300, openrisc, parisc, score, sh64, sparc,
um, xtensa
* Already prints debug info. Replaced with show_regs_print_info().
The printed information is superset of what used to be there.
arm, arm64, avr32, mips, powerpc, sh32, tile, unicore32, x86
* s390 is special in that it used to print arch-specific information
along with generic debug info. Heiko and Martin think that the
arch-specific extra isn't worth keeping s390 specfic implementation.
Converted to use the generic version.
Note that now all archs print the debug info before actual register
dumps.
An example BUG() dump follows.
kernel BUG at /work/os/work/kernel/workqueue.c:4841!
invalid opcode: 0000 [#1] PREEMPT SMP DEBUG_PAGEALLOC
Modules linked in:
CPU: 0 PID: 1 Comm: swapper/0 Not tainted 3.9.0-rc1-work+ #7
Hardware name: empty empty/S3992, BIOS 080011 10/26/2007
task: ffff88007c85e040 ti: ffff88007c860000 task.ti: ffff88007c860000
RIP: 0010:[<ffffffff8234a07e>] [<ffffffff8234a07e>] init_workqueues+0x4/0x6
RSP: 0000:ffff88007c861ec8 EFLAGS: 00010246
RAX: ffff88007c861fd8 RBX: ffffffff824466a8 RCX: 0000000000000001
RDX: 0000000000000046 RSI: 0000000000000001 RDI: ffffffff8234a07a
RBP: ffff88007c861ec8 R08: 0000000000000000 R09: 0000000000000000
R10: 0000000000000001 R11: 0000000000000000 R12: ffffffff8234a07a
R13: 0000000000000000 R14: 0000000000000000 R15: 0000000000000000
FS: 0000000000000000(0000) GS:ffff88007dc00000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 000000008005003b
CR2: ffff88015f7ff000 CR3: 00000000021f1000 CR4: 00000000000007f0
DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
DR3: 0000000000000000 DR6: 00000000ffff0ff0 DR7: 0000000000000400
Stack:
ffff88007c861ef8 ffffffff81000312 ffffffff824466a8 ffff88007c85e650
0000000000000003 0000000000000000 ffff88007c861f38 ffffffff82335e5d
ffff88007c862080 ffffffff8223d8c0 ffff88007c862080 ffffffff81c47760
Call Trace:
[<ffffffff81000312>] do_one_initcall+0x122/0x170
[<ffffffff82335e5d>] kernel_init_freeable+0x9b/0x1c8
[<ffffffff81c47760>] ? rest_init+0x140/0x140
[<ffffffff81c4776e>] kernel_init+0xe/0xf0
[<ffffffff81c6be9c>] ret_from_fork+0x7c/0xb0
[<ffffffff81c47760>] ? rest_init+0x140/0x140
...
v2: Typo fix in x86-32.
v3: CPU number dropped from show_regs_print_info() as
dump_stack_print_info() has been updated to print it. s390
specific implementation dropped as requested by s390 maintainers.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: David S. Miller <davem@davemloft.net>
Acked-by: Jesper Nilsson <jesper.nilsson@axis.com>
Cc: Heiko Carstens <heiko.carstens@de.ibm.com>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: Bjorn Helgaas <bhelgaas@google.com>
Cc: Fengguang Wu <fengguang.wu@intel.com>
Cc: Mike Frysinger <vapier@gentoo.org>
Cc: Vineet Gupta <vgupta@synopsys.com>
Cc: Sam Ravnborg <sam@ravnborg.org>
Acked-by: Chris Metcalf <cmetcalf@tilera.com> [tile bits]
Acked-by: Richard Kuo <rkuo@codeaurora.org> [hexagon bits]
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-05-01 06:27:17 +08:00
|
|
|
printk("\n");
|
|
|
|
|
show_regs_print_info(KERN_DEFAULT);
|
2007-12-19 03:46:38 +08:00
|
|
|
printk("psr : %016lx ifs : %016lx ip : [<%016lx>] %s (%s)\n",
|
|
|
|
|
regs->cr_ipsr, regs->cr_ifs, ip, print_tainted(),
|
|
|
|
|
init_utsname()->release);
|
2017-12-11 20:50:16 +08:00
|
|
|
printk("ip is at %pS\n", (void *)ip);
|
2005-04-17 06:20:36 +08:00
|
|
|
printk("unat: %016lx pfs : %016lx rsc : %016lx\n",
|
|
|
|
|
regs->ar_unat, regs->ar_pfs, regs->ar_rsc);
|
|
|
|
|
printk("rnat: %016lx bsps: %016lx pr : %016lx\n",
|
|
|
|
|
regs->ar_rnat, regs->ar_bspstore, regs->pr);
|
|
|
|
|
printk("ldrs: %016lx ccv : %016lx fpsr: %016lx\n",
|
|
|
|
|
regs->loadrs, regs->ar_ccv, regs->ar_fpsr);
|
|
|
|
|
printk("csd : %016lx ssd : %016lx\n", regs->ar_csd, regs->ar_ssd);
|
|
|
|
|
printk("b0 : %016lx b6 : %016lx b7 : %016lx\n", regs->b0, regs->b6, regs->b7);
|
|
|
|
|
printk("f6 : %05lx%016lx f7 : %05lx%016lx\n",
|
|
|
|
|
regs->f6.u.bits[1], regs->f6.u.bits[0],
|
|
|
|
|
regs->f7.u.bits[1], regs->f7.u.bits[0]);
|
|
|
|
|
printk("f8 : %05lx%016lx f9 : %05lx%016lx\n",
|
|
|
|
|
regs->f8.u.bits[1], regs->f8.u.bits[0],
|
|
|
|
|
regs->f9.u.bits[1], regs->f9.u.bits[0]);
|
|
|
|
|
printk("f10 : %05lx%016lx f11 : %05lx%016lx\n",
|
|
|
|
|
regs->f10.u.bits[1], regs->f10.u.bits[0],
|
|
|
|
|
regs->f11.u.bits[1], regs->f11.u.bits[0]);
|
|
|
|
|
|
|
|
|
|
printk("r1 : %016lx r2 : %016lx r3 : %016lx\n", regs->r1, regs->r2, regs->r3);
|
|
|
|
|
printk("r8 : %016lx r9 : %016lx r10 : %016lx\n", regs->r8, regs->r9, regs->r10);
|
|
|
|
|
printk("r11 : %016lx r12 : %016lx r13 : %016lx\n", regs->r11, regs->r12, regs->r13);
|
|
|
|
|
printk("r14 : %016lx r15 : %016lx r16 : %016lx\n", regs->r14, regs->r15, regs->r16);
|
|
|
|
|
printk("r17 : %016lx r18 : %016lx r19 : %016lx\n", regs->r17, regs->r18, regs->r19);
|
|
|
|
|
printk("r20 : %016lx r21 : %016lx r22 : %016lx\n", regs->r20, regs->r21, regs->r22);
|
|
|
|
|
printk("r23 : %016lx r24 : %016lx r25 : %016lx\n", regs->r23, regs->r24, regs->r25);
|
|
|
|
|
printk("r26 : %016lx r27 : %016lx r28 : %016lx\n", regs->r26, regs->r27, regs->r28);
|
|
|
|
|
printk("r29 : %016lx r30 : %016lx r31 : %016lx\n", regs->r29, regs->r30, regs->r31);
|
|
|
|
|
|
|
|
|
|
if (user_mode(regs)) {
|
|
|
|
|
/* print the stacked registers */
|
|
|
|
|
unsigned long val, *bsp, ndirty;
|
|
|
|
|
int i, sof, is_nat = 0;
|
|
|
|
|
|
|
|
|
|
sof = regs->cr_ifs & 0x7f; /* size of frame */
|
|
|
|
|
ndirty = (regs->loadrs >> 19);
|
|
|
|
|
bsp = ia64_rse_skip_regs((unsigned long *) regs->ar_bspstore, ndirty);
|
|
|
|
|
for (i = 0; i < sof; ++i) {
|
|
|
|
|
get_user(val, (unsigned long __user *) ia64_rse_skip_regs(bsp, i));
|
|
|
|
|
printk("r%-3u:%c%016lx%s", 32 + i, is_nat ? '*' : ' ', val,
|
|
|
|
|
((i == sof - 1) || (i % 3) == 2) ? "\n" : " ");
|
|
|
|
|
}
|
|
|
|
|
} else
|
2020-06-09 12:32:29 +08:00
|
|
|
show_stack(NULL, NULL, KERN_DEFAULT);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
2009-09-15 02:13:37 +08:00
|
|
|
/* local support for deprecated console_print */
|
|
|
|
|
void
|
|
|
|
|
console_print(const char *s)
|
|
|
|
|
{
|
|
|
|
|
printk(KERN_EMERG "%s", s);
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
void
|
2008-05-09 14:26:35 +08:00
|
|
|
do_notify_resume_user(sigset_t *unused, struct sigscratch *scr, long in_syscall)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
if (fsys_mode(current, &scr->pt)) {
|
2008-05-09 14:26:35 +08:00
|
|
|
/*
|
|
|
|
|
* defer signal-handling etc. until we return to
|
|
|
|
|
* privilege-level 0.
|
|
|
|
|
*/
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!ia64_psr(&scr->pt)->lp)
|
|
|
|
|
ia64_psr(&scr->pt)->lp = 1;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* deal with pending signal delivery */
|
2020-10-10 04:49:43 +08:00
|
|
|
if (test_thread_flag(TIF_SIGPENDING) ||
|
|
|
|
|
test_thread_flag(TIF_NOTIFY_SIGNAL)) {
|
2008-05-09 14:26:35 +08:00
|
|
|
local_irq_enable(); /* force interrupt enable */
|
2007-01-24 00:03:17 +08:00
|
|
|
ia64_do_signal(scr, in_syscall);
|
2008-05-09 14:26:35 +08:00
|
|
|
}
|
2007-12-12 22:23:34 +08:00
|
|
|
|
2020-10-04 00:49:22 +08:00
|
|
|
if (test_thread_flag(TIF_NOTIFY_RESUME)) {
|
2012-09-21 02:47:13 +08:00
|
|
|
local_irq_enable(); /* force interrupt enable */
|
2008-10-07 01:43:06 +08:00
|
|
|
tracehook_notify_resume(&scr->pt);
|
|
|
|
|
}
|
|
|
|
|
|
2007-12-12 22:23:34 +08:00
|
|
|
/* copy user rbs to kernel rbs */
|
2008-05-09 14:26:35 +08:00
|
|
|
if (unlikely(test_thread_flag(TIF_RESTORE_RSE))) {
|
|
|
|
|
local_irq_enable(); /* force interrupt enable */
|
2007-12-12 22:23:34 +08:00
|
|
|
ia64_sync_krbs();
|
2008-05-09 14:26:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
local_irq_disable(); /* force interrupt disable */
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int __init nohalt_setup(char * str)
|
|
|
|
|
{
|
2013-03-22 05:49:47 +08:00
|
|
|
cpu_idle_poll_ctrl(true);
|
2005-04-17 06:20:36 +08:00
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
__setup("nohalt", nohalt_setup);
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_HOTPLUG_CPU
|
|
|
|
|
/* We don't actually take CPU down, just spin without interrupts. */
|
|
|
|
|
static inline void play_dead(void)
|
|
|
|
|
{
|
2005-04-23 05:44:40 +08:00
|
|
|
unsigned int this_cpu = smp_processor_id();
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* Ack it */
|
ia64: Replace __get_cpu_var uses
__get_cpu_var() is used for multiple purposes in the kernel source. One of
them is address calculation via the form &__get_cpu_var(x). This calculates
the address for the instance of the percpu variable of the current processor
based on an offset.
Other use cases are for storing and retrieving data from the current
processors percpu area. __get_cpu_var() can be used as an lvalue when
writing data or on the right side of an assignment.
__get_cpu_var() is defined as :
#define __get_cpu_var(var) (*this_cpu_ptr(&(var)))
__get_cpu_var() always only does an address determination. However, store
and retrieve operations could use a segment prefix (or global register on
other platforms) to avoid the address calculation.
this_cpu_write() and this_cpu_read() can directly take an offset into a
percpu area and use optimized assembly code to read and write per cpu
variables.
This patch converts __get_cpu_var into either an explicit address
calculation using this_cpu_ptr() or into a use of this_cpu operations that
use the offset. Thereby address calculations are avoided and less registers
are used when code is generated.
At the end of the patch set all uses of __get_cpu_var have been removed so
the macro is removed too.
The patch set includes passes over all arches as well. Once these operations
are used throughout then specialized macros can be defined in non -x86
arches as well in order to optimize per cpu access by f.e. using a global
register that may be set to the per cpu base.
Transformations done to __get_cpu_var()
1. Determine the address of the percpu instance of the current processor.
DEFINE_PER_CPU(int, y);
int *x = &__get_cpu_var(y);
Converts to
int *x = this_cpu_ptr(&y);
2. Same as #1 but this time an array structure is involved.
DEFINE_PER_CPU(int, y[20]);
int *x = __get_cpu_var(y);
Converts to
int *x = this_cpu_ptr(y);
3. Retrieve the content of the current processors instance of a per cpu
variable.
DEFINE_PER_CPU(int, y);
int x = __get_cpu_var(y)
Converts to
int x = __this_cpu_read(y);
4. Retrieve the content of a percpu struct
DEFINE_PER_CPU(struct mystruct, y);
struct mystruct x = __get_cpu_var(y);
Converts to
memcpy(&x, this_cpu_ptr(&y), sizeof(x));
5. Assignment to a per cpu variable
DEFINE_PER_CPU(int, y)
__get_cpu_var(y) = x;
Converts to
__this_cpu_write(y, x);
6. Increment/Decrement etc of a per cpu variable
DEFINE_PER_CPU(int, y);
__get_cpu_var(y)++
Converts to
__this_cpu_inc(y)
Cc: Tony Luck <tony.luck@intel.com>
Cc: Fenghua Yu <fenghua.yu@intel.com>
Cc: linux-ia64@vger.kernel.org
Signed-off-by: Christoph Lameter <cl@linux.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
2014-08-18 01:30:47 +08:00
|
|
|
__this_cpu_write(cpu_state, CPU_DEAD);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
max_xtp();
|
|
|
|
|
local_irq_disable();
|
2005-04-23 05:44:40 +08:00
|
|
|
idle_task_exit();
|
|
|
|
|
ia64_jump_to_sal(&sal_boot_rendez_state[this_cpu]);
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
2005-04-23 05:44:40 +08:00
|
|
|
* The above is a point of no-return, the processor is
|
|
|
|
|
* expected to be in SAL loop now.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2005-04-23 05:44:40 +08:00
|
|
|
BUG();
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
#else
|
|
|
|
|
static inline void play_dead(void)
|
|
|
|
|
{
|
|
|
|
|
BUG();
|
|
|
|
|
}
|
|
|
|
|
#endif /* CONFIG_HOTPLUG_CPU */
|
|
|
|
|
|
2013-03-22 05:49:47 +08:00
|
|
|
void arch_cpu_idle_dead(void)
|
|
|
|
|
{
|
|
|
|
|
play_dead();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void arch_cpu_idle(void)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
void (*mark_idle)(int) = ia64_mark_idle;
|
2005-11-16 06:37:05 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#ifdef CONFIG_SMP
|
2013-03-22 05:49:47 +08:00
|
|
|
min_xtp();
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
2013-03-22 05:49:47 +08:00
|
|
|
rmb();
|
|
|
|
|
if (mark_idle)
|
|
|
|
|
(*mark_idle)(1);
|
|
|
|
|
|
2020-11-20 18:50:35 +08:00
|
|
|
raw_safe_halt();
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-03-22 05:49:47 +08:00
|
|
|
if (mark_idle)
|
|
|
|
|
(*mark_idle)(0);
|
2005-04-17 06:20:36 +08:00
|
|
|
#ifdef CONFIG_SMP
|
2013-03-22 05:49:47 +08:00
|
|
|
normal_xtp();
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
ia64_save_extra (struct task_struct *task)
|
|
|
|
|
{
|
|
|
|
|
if ((task->thread.flags & IA64_THREAD_DBG_VALID) != 0)
|
|
|
|
|
ia64_save_debug_regs(&task->thread.dbr[0]);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
ia64_load_extra (struct task_struct *task)
|
|
|
|
|
{
|
|
|
|
|
if ((task->thread.flags & IA64_THREAD_DBG_VALID) != 0)
|
|
|
|
|
ia64_load_debug_regs(&task->thread.dbr[0]);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Copy the state of an ia-64 thread.
|
|
|
|
|
*
|
|
|
|
|
* We get here through the following call chain:
|
|
|
|
|
*
|
|
|
|
|
* from user-level: from kernel:
|
|
|
|
|
*
|
|
|
|
|
* <clone syscall> <some kernel call frames>
|
|
|
|
|
* sys_clone :
|
2020-08-19 18:46:47 +08:00
|
|
|
* kernel_clone kernel_clone
|
2005-04-17 06:20:36 +08:00
|
|
|
* copy_thread copy_thread
|
|
|
|
|
*
|
|
|
|
|
* This means that the stack layout is as follows:
|
|
|
|
|
*
|
|
|
|
|
* +---------------------+ (highest addr)
|
|
|
|
|
* | struct pt_regs |
|
|
|
|
|
* +---------------------+
|
|
|
|
|
* | struct switch_stack |
|
|
|
|
|
* +---------------------+
|
|
|
|
|
* | |
|
|
|
|
|
* | memory stack |
|
|
|
|
|
* | | <-- sp (lowest addr)
|
|
|
|
|
* +---------------------+
|
|
|
|
|
*
|
|
|
|
|
* Observe that we copy the unat values that are in pt_regs and switch_stack. Spilling an
|
|
|
|
|
* integer to address X causes bit N in ar.unat to be set to the NaT bit of the register,
|
|
|
|
|
* with N=(X & 0x1ff)/8. Thus, copying the unat value preserves the NaT bits ONLY if the
|
|
|
|
|
* pt_regs structure in the parent is congruent to that of the child, modulo 512. Since
|
|
|
|
|
* the stack is page aligned and the page size is at least 4KB, this is always the case,
|
|
|
|
|
* so there is nothing to worry about.
|
|
|
|
|
*/
|
|
|
|
|
int
|
2020-06-11 17:04:15 +08:00
|
|
|
copy_thread(unsigned long clone_flags, unsigned long user_stack_base,
|
|
|
|
|
unsigned long user_stack_size, struct task_struct *p, unsigned long tls)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2010-02-09 02:42:17 +08:00
|
|
|
extern char ia64_ret_from_clone;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct switch_stack *child_stack, *stack;
|
|
|
|
|
unsigned long rbs, child_rbs, rbs_size;
|
|
|
|
|
struct pt_regs *child_ptregs;
|
2012-10-23 10:51:14 +08:00
|
|
|
struct pt_regs *regs = current_pt_regs();
|
2005-04-17 06:20:36 +08:00
|
|
|
int retval = 0;
|
|
|
|
|
|
|
|
|
|
child_ptregs = (struct pt_regs *) ((unsigned long) p + IA64_STK_OFFSET) - 1;
|
|
|
|
|
child_stack = (struct switch_stack *) child_ptregs - 1;
|
|
|
|
|
|
|
|
|
|
rbs = (unsigned long) current + IA64_RBS_OFFSET;
|
|
|
|
|
child_rbs = (unsigned long) p + IA64_RBS_OFFSET;
|
|
|
|
|
|
|
|
|
|
/* copy parts of thread_struct: */
|
|
|
|
|
p->thread.ksp = (unsigned long) child_stack - 16;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* NOTE: The calling convention considers all floating point
|
|
|
|
|
* registers in the high partition (fph) to be scratch. Since
|
|
|
|
|
* the only way to get to this point is through a system call,
|
|
|
|
|
* we know that the values in fph are all dead. Hence, there
|
|
|
|
|
* is no need to inherit the fph state from the parent to the
|
|
|
|
|
* child and all we have to do is to make sure that
|
|
|
|
|
* IA64_THREAD_FPH_VALID is cleared in the child.
|
|
|
|
|
*
|
|
|
|
|
* XXX We could push this optimization a bit further by
|
|
|
|
|
* clearing IA64_THREAD_FPH_VALID on ANY system call.
|
|
|
|
|
* However, it's not clear this is worth doing. Also, it
|
|
|
|
|
* would be a slight deviation from the normal Linux system
|
|
|
|
|
* call behavior where scratch registers are preserved across
|
|
|
|
|
* system calls (unless used by the system call itself).
|
|
|
|
|
*/
|
|
|
|
|
# define THREAD_FLAGS_TO_CLEAR (IA64_THREAD_FPH_VALID | IA64_THREAD_DBG_VALID \
|
|
|
|
|
| IA64_THREAD_PM_VALID)
|
|
|
|
|
# define THREAD_FLAGS_TO_SET 0
|
|
|
|
|
p->thread.flags = ((current->thread.flags & ~THREAD_FLAGS_TO_CLEAR)
|
|
|
|
|
| THREAD_FLAGS_TO_SET);
|
2012-10-15 03:43:06 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
ia64_drop_fpu(p); /* don't pick up stale state from a CPU's fph */
|
|
|
|
|
|
2012-10-15 03:43:06 +08:00
|
|
|
if (unlikely(p->flags & PF_KTHREAD)) {
|
|
|
|
|
if (unlikely(!user_stack_base)) {
|
|
|
|
|
/* fork_idle() called us */
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
memset(child_stack, 0, sizeof(*child_ptregs) + sizeof(*child_stack));
|
|
|
|
|
child_stack->r4 = user_stack_base; /* payload */
|
|
|
|
|
child_stack->r5 = user_stack_size; /* argument */
|
|
|
|
|
/*
|
|
|
|
|
* Preserve PSR bits, except for bits 32-34 and 37-45,
|
|
|
|
|
* which we can't read.
|
|
|
|
|
*/
|
|
|
|
|
child_ptregs->cr_ipsr = ia64_getreg(_IA64_REG_PSR) | IA64_PSR_BN;
|
|
|
|
|
/* mark as valid, empty frame */
|
|
|
|
|
child_ptregs->cr_ifs = 1UL << 63;
|
|
|
|
|
child_stack->ar_fpsr = child_ptregs->ar_fpsr
|
|
|
|
|
= ia64_getreg(_IA64_REG_AR_FPSR);
|
|
|
|
|
child_stack->pr = (1 << PRED_KERNEL_STACK);
|
|
|
|
|
child_stack->ar_bspstore = child_rbs;
|
|
|
|
|
child_stack->b0 = (unsigned long) &ia64_ret_from_clone;
|
|
|
|
|
|
|
|
|
|
/* stop some PSR bits from being inherited.
|
|
|
|
|
* the psr.up/psr.pp bits must be cleared on fork but inherited on execve()
|
|
|
|
|
* therefore we must specify them explicitly here and not include them in
|
|
|
|
|
* IA64_PSR_BITS_TO_CLEAR.
|
|
|
|
|
*/
|
|
|
|
|
child_ptregs->cr_ipsr = ((child_ptregs->cr_ipsr | IA64_PSR_BITS_TO_SET)
|
|
|
|
|
& ~(IA64_PSR_BITS_TO_CLEAR | IA64_PSR_PP | IA64_PSR_UP));
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
stack = ((struct switch_stack *) regs) - 1;
|
|
|
|
|
/* copy parent's switch_stack & pt_regs to child: */
|
|
|
|
|
memcpy(child_stack, stack, sizeof(*child_ptregs) + sizeof(*child_stack));
|
|
|
|
|
|
|
|
|
|
/* copy the parent's register backing store to the child: */
|
|
|
|
|
rbs_size = stack->ar_bspstore - rbs;
|
|
|
|
|
memcpy((void *) child_rbs, (void *) rbs, rbs_size);
|
|
|
|
|
if (clone_flags & CLONE_SETTLS)
|
ia64: enable HAVE_COPY_THREAD_TLS, switch to kernel_clone_args
This is part of a larger series that aims at getting rid of the
copy_thread()/copy_thread_tls() split that makes the process creation
codepaths in the kernel more convoluted and error-prone than they need
to be.
I'm converting all the remaining arches that haven't yet switched and
am collecting individual acks. Once I have them, I'll send the whole series
removing the copy_thread()/copy_thread_tls() split, the
HAVE_COPY_THREAD_TLS define and the legacy do_fork() helper. The only
kernel-wide process creation entry point for anything not going directly
through the syscall path will then be based on struct kernel_clone_args.
No more danger of weird process creation abi quirks between architectures
hopefully, and easier to maintain overall.
It also unblocks implementing clone3() on architectures not support
copy_thread_tls(). Any architecture that wants to implement clone3()
will need to select HAVE_COPY_THREAD_TLS and thus need to implement
copy_thread_tls(). So both goals are connected but independently
beneficial.
HAVE_COPY_THREAD_TLS means that a given architecture supports
CLONE_SETTLS and not setting it should usually mean that the
architectures doesn't implement it but that's not how things are. In
fact all architectures support CLONE_TLS it's just that they don't
follow the calling convention that HAVE_COPY_THREAD_TLS implies. That
means all architectures can be switched over to select
HAVE_COPY_THREAD_TLS. Once that is done we can remove that macro (yay,
less code), the unnecessary do_fork() export in kernel/fork.c, and also
rename copy_thread_tls() back to copy_thread(). At this point
copy_thread() becomes the main architecture specific part of process
creation but it will be the same layout and calling convention for all
architectures. (Once that is done we can probably cleanup each
copy_thread() function even more but that's for the future.)
Since ia64 does support CLONE_SETTLS there's no reason to not select
HAVE_COPY_THREAD_TLS. This brings us one step closer to getting rid of
the copy_thread()/copy_thread_tls() split we still have and ultimately
the HAVE_COPY_THREAD_TLS define in general. A lot of architectures have
already converted and ia64 is one of the few hat haven't yet. This also
unblocks implementing the clone3() syscall on ia64. Once that is done we
can get of another ARCH_WANTS_* macro.
Once Any architecture that supports HAVE_COPY_THREAD_TLS cannot call the
do_fork() helper anymore. This is fine and intended since it should be
removed in favor of the new, cleaner _do_fork() calling convention based
on struct kernel_clone_args. In fact, most architectures have already
switched. With this patch, ia64 joins the other arches which can't use
the fork(), vfork(), clone(), clone3() syscalls directly and who follow
the new process creation calling convention that is based on struct
kernel_clone_args which we introduced a while back. This means less
custom assembly in the architectures entry path to set up the registers
before calling into the process creation helper and it is easier to to
support new features without having to adapt calling conventions. It
also unifies all process creation paths between fork(), vfork(),
clone(), and clone3(). (We can't fix the ABI nightmare that legacy
clone() is but we can prevent stuff like this happening in the future.)
Well, the first version I nothing to test this with. I don't know how to
reasonably explain what happened but thanks to Adrian I'm now sitting at
home next to a HP Integrity RX2600. I've done some testing and my initial
version had a bug that became obvious when I took a closer look. The switch
stack logic assumes that ar.pfs is stored in r16 and I changed that to r2.
So with that fixed the following test program runs without any problems:
#ifndef _GNU_SOURCE
#define _GNU_SOURCE 1
#endif
#include <errno.h>
#include <fcntl.h>
#include <linux/sched.h>
#include <sched.h>
#include <signal.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <syscall.h>
#include <unistd.h>
#define IA64_SYSCALL_OFFSET 1024
#ifndef __NR_clone
#define __NR_clone (104 + IA64_SYSCALL_OFFSET)
#endif
#ifndef __NR_clone2
#define __NR_clone2 (189 + IA64_SYSCALL_OFFSET)
#endif
/*
* sys_clone(unsigned long flags,
* unsigned long stack,
* int *parent_tidptr,
* int *child_tidptr,
* unsigned long tls)
*/
static pid_t ia64_raw_clone(void)
{
return syscall(__NR_clone, SIGCHLD, 0, NULL, NULL, 0);
}
/*
* sys_clone2(unsigned long flags,
* unsigned long stack,
* unsigned long stack_size,
* int *parent_tidptr,
* int *child_tidptr,
* unsigned long tls)
*/
static pid_t ia64_raw_clone2(void)
{
return syscall(__NR_clone2, SIGCHLD, 0, 0, NULL, NULL, 0);
}
/*
* Let's use the "standard stack limit" (i.e. glibc thread size default) for
* stack sizes: 8MB.
*/
#define __STACK_SIZE (8 * 1024 * 1024)
/* This is not always defined in sched.h. */
extern int __clone2 (int (*__fn) (void *__arg), void *__child_stack_base,
size_t __child_stack_size, int __flags, void *__arg, ...);
pid_t libc_clone2(int (*fn)(void *), void *arg)
{
pid_t ret;
void *stack;
stack = malloc(__STACK_SIZE);
if (!stack)
return -ENOMEM;
return __clone2(fn, stack, __STACK_SIZE, SIGCHLD, arg, NULL, NULL, NULL);
}
static int libc_clone2_child(void *data)
{
fprintf(stderr, "I'll just see myself out\n");
_exit(EXIT_SUCCESS);
}
int main(void)
{
for (int i = 0; i < 1000; i++) {
pid_t pid = ia64_raw_clone();
if (pid < 0)
_exit(EXIT_FAILURE);
if (pid == 0)
_exit(EXIT_SUCCESS);
if (wait(NULL) != pid)
_exit(EXIT_FAILURE);
fprintf(stderr, "ia64_raw_clone() passed\n");
pid = ia64_raw_clone2();
if (pid < 0)
_exit(EXIT_FAILURE);
if (pid == 0)
_exit(EXIT_SUCCESS);
if (wait(NULL) != pid)
_exit(EXIT_FAILURE);
fprintf(stderr, "ia64_raw_clone2() passed\n");
pid = libc_clone2(libc_clone2_child, NULL);
if (pid < 0)
_exit(EXIT_FAILURE);
if (wait(NULL) != pid)
_exit(EXIT_FAILURE);
fprintf(stderr, "libc_clone2() passed\n");
}
_exit(EXIT_SUCCESS);
}
For some more context, please see:
commit 606e9ad20094f6d500166881d301f31a51bc8aa7
Merge: ac61145a725a 457677c70c76
Author: Linus Torvalds <torvalds@linux-foundation.org>
Date: Sat Jan 11 15:33:48 2020 -0800
Merge tag 'clone3-tls-v5.5-rc6' of git://git.kernel.org/pub/scm/linux/kernel/git/brauner/linux
Pull thread fixes from Christian Brauner:
"This contains a series of patches to fix CLONE_SETTLS when used with
clone3().
The clone3() syscall passes the tls argument through struct clone_args
instead of a register. This means, all architectures that do not
implement copy_thread_tls() but still support CLONE_SETTLS via
copy_thread() expecting the tls to be located in a register argument
based on clone() are currently unfortunately broken. Their tls value
will be garbage.
The patch series fixes this on all architectures that currently define
__ARCH_WANT_SYS_CLONE3. It also adds a compile-time check to ensure
that any architecture that enables clone3() in the future is forced to
also implement copy_thread_tls().
My ultimate goal is to get rid of the copy_thread()/copy_thread_tls()
split and just have copy_thread_tls() at some point in the not too
distant future (Maybe even renaming copy_thread_tls() back to simply
copy_thread() once the old function is ripped from all arches). This
is dependent now on all arches supporting clone3().
While all relevant arches do that now there are still four missing:
ia64, m68k, sh and sparc. They have the system call reserved, but not
implemented. Once they all implement clone3() we can get rid of
ARCH_WANT_SYS_CLONE3 and HAVE_COPY_THREAD_TLS.
Note that in the meantime, m68k has already switched to the new calling
convention. And I've got sparc patches acked by Dave, too.
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
Cc: Tony Luck <tony.luck@intel.com>
Cc: Fenghua Yu <fenghua.yu@intel.com>
Cc: John Paul Adrian Glaubitz <glaubitz@physik.fu-berlin.de>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
Cc: "Peter Zijlstra (Intel)" <peterz@infradead.org>
Cc: Qais Yousef <qais.yousef@arm.com>
Cc: linux-ia64@vger.kernel.org
Cc: linux-kernel@vger.kernel.org
Link: https://lore.kernel.org/r/20200517151635.3085756-1-christian.brauner@ubuntu.com
2020-05-17 23:16:35 +08:00
|
|
|
child_ptregs->r13 = tls;
|
2012-10-15 03:43:06 +08:00
|
|
|
if (user_stack_base) {
|
|
|
|
|
child_ptregs->r12 = user_stack_base + user_stack_size - 16;
|
|
|
|
|
child_ptregs->ar_bspstore = user_stack_base;
|
|
|
|
|
child_ptregs->ar_rnat = 0;
|
|
|
|
|
child_ptregs->loadrs = 0;
|
|
|
|
|
}
|
|
|
|
|
child_stack->ar_bspstore = child_rbs + rbs_size;
|
|
|
|
|
child_stack->b0 = (unsigned long) &ia64_ret_from_clone;
|
|
|
|
|
|
|
|
|
|
/* stop some PSR bits from being inherited.
|
|
|
|
|
* the psr.up/psr.pp bits must be cleared on fork but inherited on execve()
|
|
|
|
|
* therefore we must specify them explicitly here and not include them in
|
|
|
|
|
* IA64_PSR_BITS_TO_CLEAR.
|
|
|
|
|
*/
|
|
|
|
|
child_ptregs->cr_ipsr = ((child_ptregs->cr_ipsr | IA64_PSR_BITS_TO_SET)
|
|
|
|
|
& ~(IA64_PSR_BITS_TO_CLEAR | IA64_PSR_PP | IA64_PSR_UP));
|
2005-04-17 06:20:36 +08:00
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
|
ia64: enable HAVE_COPY_THREAD_TLS, switch to kernel_clone_args
This is part of a larger series that aims at getting rid of the
copy_thread()/copy_thread_tls() split that makes the process creation
codepaths in the kernel more convoluted and error-prone than they need
to be.
I'm converting all the remaining arches that haven't yet switched and
am collecting individual acks. Once I have them, I'll send the whole series
removing the copy_thread()/copy_thread_tls() split, the
HAVE_COPY_THREAD_TLS define and the legacy do_fork() helper. The only
kernel-wide process creation entry point for anything not going directly
through the syscall path will then be based on struct kernel_clone_args.
No more danger of weird process creation abi quirks between architectures
hopefully, and easier to maintain overall.
It also unblocks implementing clone3() on architectures not support
copy_thread_tls(). Any architecture that wants to implement clone3()
will need to select HAVE_COPY_THREAD_TLS and thus need to implement
copy_thread_tls(). So both goals are connected but independently
beneficial.
HAVE_COPY_THREAD_TLS means that a given architecture supports
CLONE_SETTLS and not setting it should usually mean that the
architectures doesn't implement it but that's not how things are. In
fact all architectures support CLONE_TLS it's just that they don't
follow the calling convention that HAVE_COPY_THREAD_TLS implies. That
means all architectures can be switched over to select
HAVE_COPY_THREAD_TLS. Once that is done we can remove that macro (yay,
less code), the unnecessary do_fork() export in kernel/fork.c, and also
rename copy_thread_tls() back to copy_thread(). At this point
copy_thread() becomes the main architecture specific part of process
creation but it will be the same layout and calling convention for all
architectures. (Once that is done we can probably cleanup each
copy_thread() function even more but that's for the future.)
Since ia64 does support CLONE_SETTLS there's no reason to not select
HAVE_COPY_THREAD_TLS. This brings us one step closer to getting rid of
the copy_thread()/copy_thread_tls() split we still have and ultimately
the HAVE_COPY_THREAD_TLS define in general. A lot of architectures have
already converted and ia64 is one of the few hat haven't yet. This also
unblocks implementing the clone3() syscall on ia64. Once that is done we
can get of another ARCH_WANTS_* macro.
Once Any architecture that supports HAVE_COPY_THREAD_TLS cannot call the
do_fork() helper anymore. This is fine and intended since it should be
removed in favor of the new, cleaner _do_fork() calling convention based
on struct kernel_clone_args. In fact, most architectures have already
switched. With this patch, ia64 joins the other arches which can't use
the fork(), vfork(), clone(), clone3() syscalls directly and who follow
the new process creation calling convention that is based on struct
kernel_clone_args which we introduced a while back. This means less
custom assembly in the architectures entry path to set up the registers
before calling into the process creation helper and it is easier to to
support new features without having to adapt calling conventions. It
also unifies all process creation paths between fork(), vfork(),
clone(), and clone3(). (We can't fix the ABI nightmare that legacy
clone() is but we can prevent stuff like this happening in the future.)
Well, the first version I nothing to test this with. I don't know how to
reasonably explain what happened but thanks to Adrian I'm now sitting at
home next to a HP Integrity RX2600. I've done some testing and my initial
version had a bug that became obvious when I took a closer look. The switch
stack logic assumes that ar.pfs is stored in r16 and I changed that to r2.
So with that fixed the following test program runs without any problems:
#ifndef _GNU_SOURCE
#define _GNU_SOURCE 1
#endif
#include <errno.h>
#include <fcntl.h>
#include <linux/sched.h>
#include <sched.h>
#include <signal.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <syscall.h>
#include <unistd.h>
#define IA64_SYSCALL_OFFSET 1024
#ifndef __NR_clone
#define __NR_clone (104 + IA64_SYSCALL_OFFSET)
#endif
#ifndef __NR_clone2
#define __NR_clone2 (189 + IA64_SYSCALL_OFFSET)
#endif
/*
* sys_clone(unsigned long flags,
* unsigned long stack,
* int *parent_tidptr,
* int *child_tidptr,
* unsigned long tls)
*/
static pid_t ia64_raw_clone(void)
{
return syscall(__NR_clone, SIGCHLD, 0, NULL, NULL, 0);
}
/*
* sys_clone2(unsigned long flags,
* unsigned long stack,
* unsigned long stack_size,
* int *parent_tidptr,
* int *child_tidptr,
* unsigned long tls)
*/
static pid_t ia64_raw_clone2(void)
{
return syscall(__NR_clone2, SIGCHLD, 0, 0, NULL, NULL, 0);
}
/*
* Let's use the "standard stack limit" (i.e. glibc thread size default) for
* stack sizes: 8MB.
*/
#define __STACK_SIZE (8 * 1024 * 1024)
/* This is not always defined in sched.h. */
extern int __clone2 (int (*__fn) (void *__arg), void *__child_stack_base,
size_t __child_stack_size, int __flags, void *__arg, ...);
pid_t libc_clone2(int (*fn)(void *), void *arg)
{
pid_t ret;
void *stack;
stack = malloc(__STACK_SIZE);
if (!stack)
return -ENOMEM;
return __clone2(fn, stack, __STACK_SIZE, SIGCHLD, arg, NULL, NULL, NULL);
}
static int libc_clone2_child(void *data)
{
fprintf(stderr, "I'll just see myself out\n");
_exit(EXIT_SUCCESS);
}
int main(void)
{
for (int i = 0; i < 1000; i++) {
pid_t pid = ia64_raw_clone();
if (pid < 0)
_exit(EXIT_FAILURE);
if (pid == 0)
_exit(EXIT_SUCCESS);
if (wait(NULL) != pid)
_exit(EXIT_FAILURE);
fprintf(stderr, "ia64_raw_clone() passed\n");
pid = ia64_raw_clone2();
if (pid < 0)
_exit(EXIT_FAILURE);
if (pid == 0)
_exit(EXIT_SUCCESS);
if (wait(NULL) != pid)
_exit(EXIT_FAILURE);
fprintf(stderr, "ia64_raw_clone2() passed\n");
pid = libc_clone2(libc_clone2_child, NULL);
if (pid < 0)
_exit(EXIT_FAILURE);
if (wait(NULL) != pid)
_exit(EXIT_FAILURE);
fprintf(stderr, "libc_clone2() passed\n");
}
_exit(EXIT_SUCCESS);
}
For some more context, please see:
commit 606e9ad20094f6d500166881d301f31a51bc8aa7
Merge: ac61145a725a 457677c70c76
Author: Linus Torvalds <torvalds@linux-foundation.org>
Date: Sat Jan 11 15:33:48 2020 -0800
Merge tag 'clone3-tls-v5.5-rc6' of git://git.kernel.org/pub/scm/linux/kernel/git/brauner/linux
Pull thread fixes from Christian Brauner:
"This contains a series of patches to fix CLONE_SETTLS when used with
clone3().
The clone3() syscall passes the tls argument through struct clone_args
instead of a register. This means, all architectures that do not
implement copy_thread_tls() but still support CLONE_SETTLS via
copy_thread() expecting the tls to be located in a register argument
based on clone() are currently unfortunately broken. Their tls value
will be garbage.
The patch series fixes this on all architectures that currently define
__ARCH_WANT_SYS_CLONE3. It also adds a compile-time check to ensure
that any architecture that enables clone3() in the future is forced to
also implement copy_thread_tls().
My ultimate goal is to get rid of the copy_thread()/copy_thread_tls()
split and just have copy_thread_tls() at some point in the not too
distant future (Maybe even renaming copy_thread_tls() back to simply
copy_thread() once the old function is ripped from all arches). This
is dependent now on all arches supporting clone3().
While all relevant arches do that now there are still four missing:
ia64, m68k, sh and sparc. They have the system call reserved, but not
implemented. Once they all implement clone3() we can get rid of
ARCH_WANT_SYS_CLONE3 and HAVE_COPY_THREAD_TLS.
Note that in the meantime, m68k has already switched to the new calling
convention. And I've got sparc patches acked by Dave, too.
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
Cc: Tony Luck <tony.luck@intel.com>
Cc: Fenghua Yu <fenghua.yu@intel.com>
Cc: John Paul Adrian Glaubitz <glaubitz@physik.fu-berlin.de>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
Cc: "Peter Zijlstra (Intel)" <peterz@infradead.org>
Cc: Qais Yousef <qais.yousef@arm.com>
Cc: linux-ia64@vger.kernel.org
Cc: linux-kernel@vger.kernel.org
Link: https://lore.kernel.org/r/20200517151635.3085756-1-christian.brauner@ubuntu.com
2020-05-17 23:16:35 +08:00
|
|
|
asmlinkage long ia64_clone(unsigned long clone_flags, unsigned long stack_start,
|
|
|
|
|
unsigned long stack_size, unsigned long parent_tidptr,
|
|
|
|
|
unsigned long child_tidptr, unsigned long tls)
|
|
|
|
|
{
|
|
|
|
|
struct kernel_clone_args args = {
|
|
|
|
|
.flags = (lower_32_bits(clone_flags) & ~CSIGNAL),
|
|
|
|
|
.pidfd = (int __user *)parent_tidptr,
|
|
|
|
|
.child_tid = (int __user *)child_tidptr,
|
|
|
|
|
.parent_tid = (int __user *)parent_tidptr,
|
|
|
|
|
.exit_signal = (lower_32_bits(clone_flags) & CSIGNAL),
|
|
|
|
|
.stack = stack_start,
|
|
|
|
|
.stack_size = stack_size,
|
|
|
|
|
.tls = tls,
|
|
|
|
|
};
|
|
|
|
|
|
2020-08-19 18:46:47 +08:00
|
|
|
return kernel_clone(&args);
|
ia64: enable HAVE_COPY_THREAD_TLS, switch to kernel_clone_args
This is part of a larger series that aims at getting rid of the
copy_thread()/copy_thread_tls() split that makes the process creation
codepaths in the kernel more convoluted and error-prone than they need
to be.
I'm converting all the remaining arches that haven't yet switched and
am collecting individual acks. Once I have them, I'll send the whole series
removing the copy_thread()/copy_thread_tls() split, the
HAVE_COPY_THREAD_TLS define and the legacy do_fork() helper. The only
kernel-wide process creation entry point for anything not going directly
through the syscall path will then be based on struct kernel_clone_args.
No more danger of weird process creation abi quirks between architectures
hopefully, and easier to maintain overall.
It also unblocks implementing clone3() on architectures not support
copy_thread_tls(). Any architecture that wants to implement clone3()
will need to select HAVE_COPY_THREAD_TLS and thus need to implement
copy_thread_tls(). So both goals are connected but independently
beneficial.
HAVE_COPY_THREAD_TLS means that a given architecture supports
CLONE_SETTLS and not setting it should usually mean that the
architectures doesn't implement it but that's not how things are. In
fact all architectures support CLONE_TLS it's just that they don't
follow the calling convention that HAVE_COPY_THREAD_TLS implies. That
means all architectures can be switched over to select
HAVE_COPY_THREAD_TLS. Once that is done we can remove that macro (yay,
less code), the unnecessary do_fork() export in kernel/fork.c, and also
rename copy_thread_tls() back to copy_thread(). At this point
copy_thread() becomes the main architecture specific part of process
creation but it will be the same layout and calling convention for all
architectures. (Once that is done we can probably cleanup each
copy_thread() function even more but that's for the future.)
Since ia64 does support CLONE_SETTLS there's no reason to not select
HAVE_COPY_THREAD_TLS. This brings us one step closer to getting rid of
the copy_thread()/copy_thread_tls() split we still have and ultimately
the HAVE_COPY_THREAD_TLS define in general. A lot of architectures have
already converted and ia64 is one of the few hat haven't yet. This also
unblocks implementing the clone3() syscall on ia64. Once that is done we
can get of another ARCH_WANTS_* macro.
Once Any architecture that supports HAVE_COPY_THREAD_TLS cannot call the
do_fork() helper anymore. This is fine and intended since it should be
removed in favor of the new, cleaner _do_fork() calling convention based
on struct kernel_clone_args. In fact, most architectures have already
switched. With this patch, ia64 joins the other arches which can't use
the fork(), vfork(), clone(), clone3() syscalls directly and who follow
the new process creation calling convention that is based on struct
kernel_clone_args which we introduced a while back. This means less
custom assembly in the architectures entry path to set up the registers
before calling into the process creation helper and it is easier to to
support new features without having to adapt calling conventions. It
also unifies all process creation paths between fork(), vfork(),
clone(), and clone3(). (We can't fix the ABI nightmare that legacy
clone() is but we can prevent stuff like this happening in the future.)
Well, the first version I nothing to test this with. I don't know how to
reasonably explain what happened but thanks to Adrian I'm now sitting at
home next to a HP Integrity RX2600. I've done some testing and my initial
version had a bug that became obvious when I took a closer look. The switch
stack logic assumes that ar.pfs is stored in r16 and I changed that to r2.
So with that fixed the following test program runs without any problems:
#ifndef _GNU_SOURCE
#define _GNU_SOURCE 1
#endif
#include <errno.h>
#include <fcntl.h>
#include <linux/sched.h>
#include <sched.h>
#include <signal.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <syscall.h>
#include <unistd.h>
#define IA64_SYSCALL_OFFSET 1024
#ifndef __NR_clone
#define __NR_clone (104 + IA64_SYSCALL_OFFSET)
#endif
#ifndef __NR_clone2
#define __NR_clone2 (189 + IA64_SYSCALL_OFFSET)
#endif
/*
* sys_clone(unsigned long flags,
* unsigned long stack,
* int *parent_tidptr,
* int *child_tidptr,
* unsigned long tls)
*/
static pid_t ia64_raw_clone(void)
{
return syscall(__NR_clone, SIGCHLD, 0, NULL, NULL, 0);
}
/*
* sys_clone2(unsigned long flags,
* unsigned long stack,
* unsigned long stack_size,
* int *parent_tidptr,
* int *child_tidptr,
* unsigned long tls)
*/
static pid_t ia64_raw_clone2(void)
{
return syscall(__NR_clone2, SIGCHLD, 0, 0, NULL, NULL, 0);
}
/*
* Let's use the "standard stack limit" (i.e. glibc thread size default) for
* stack sizes: 8MB.
*/
#define __STACK_SIZE (8 * 1024 * 1024)
/* This is not always defined in sched.h. */
extern int __clone2 (int (*__fn) (void *__arg), void *__child_stack_base,
size_t __child_stack_size, int __flags, void *__arg, ...);
pid_t libc_clone2(int (*fn)(void *), void *arg)
{
pid_t ret;
void *stack;
stack = malloc(__STACK_SIZE);
if (!stack)
return -ENOMEM;
return __clone2(fn, stack, __STACK_SIZE, SIGCHLD, arg, NULL, NULL, NULL);
}
static int libc_clone2_child(void *data)
{
fprintf(stderr, "I'll just see myself out\n");
_exit(EXIT_SUCCESS);
}
int main(void)
{
for (int i = 0; i < 1000; i++) {
pid_t pid = ia64_raw_clone();
if (pid < 0)
_exit(EXIT_FAILURE);
if (pid == 0)
_exit(EXIT_SUCCESS);
if (wait(NULL) != pid)
_exit(EXIT_FAILURE);
fprintf(stderr, "ia64_raw_clone() passed\n");
pid = ia64_raw_clone2();
if (pid < 0)
_exit(EXIT_FAILURE);
if (pid == 0)
_exit(EXIT_SUCCESS);
if (wait(NULL) != pid)
_exit(EXIT_FAILURE);
fprintf(stderr, "ia64_raw_clone2() passed\n");
pid = libc_clone2(libc_clone2_child, NULL);
if (pid < 0)
_exit(EXIT_FAILURE);
if (wait(NULL) != pid)
_exit(EXIT_FAILURE);
fprintf(stderr, "libc_clone2() passed\n");
}
_exit(EXIT_SUCCESS);
}
For some more context, please see:
commit 606e9ad20094f6d500166881d301f31a51bc8aa7
Merge: ac61145a725a 457677c70c76
Author: Linus Torvalds <torvalds@linux-foundation.org>
Date: Sat Jan 11 15:33:48 2020 -0800
Merge tag 'clone3-tls-v5.5-rc6' of git://git.kernel.org/pub/scm/linux/kernel/git/brauner/linux
Pull thread fixes from Christian Brauner:
"This contains a series of patches to fix CLONE_SETTLS when used with
clone3().
The clone3() syscall passes the tls argument through struct clone_args
instead of a register. This means, all architectures that do not
implement copy_thread_tls() but still support CLONE_SETTLS via
copy_thread() expecting the tls to be located in a register argument
based on clone() are currently unfortunately broken. Their tls value
will be garbage.
The patch series fixes this on all architectures that currently define
__ARCH_WANT_SYS_CLONE3. It also adds a compile-time check to ensure
that any architecture that enables clone3() in the future is forced to
also implement copy_thread_tls().
My ultimate goal is to get rid of the copy_thread()/copy_thread_tls()
split and just have copy_thread_tls() at some point in the not too
distant future (Maybe even renaming copy_thread_tls() back to simply
copy_thread() once the old function is ripped from all arches). This
is dependent now on all arches supporting clone3().
While all relevant arches do that now there are still four missing:
ia64, m68k, sh and sparc. They have the system call reserved, but not
implemented. Once they all implement clone3() we can get rid of
ARCH_WANT_SYS_CLONE3 and HAVE_COPY_THREAD_TLS.
Note that in the meantime, m68k has already switched to the new calling
convention. And I've got sparc patches acked by Dave, too.
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
Cc: Tony Luck <tony.luck@intel.com>
Cc: Fenghua Yu <fenghua.yu@intel.com>
Cc: John Paul Adrian Glaubitz <glaubitz@physik.fu-berlin.de>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
Cc: "Peter Zijlstra (Intel)" <peterz@infradead.org>
Cc: Qais Yousef <qais.yousef@arm.com>
Cc: linux-ia64@vger.kernel.org
Cc: linux-kernel@vger.kernel.org
Link: https://lore.kernel.org/r/20200517151635.3085756-1-christian.brauner@ubuntu.com
2020-05-17 23:16:35 +08:00
|
|
|
}
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
static void
|
|
|
|
|
do_copy_task_regs (struct task_struct *task, struct unw_frame_info *info, void *arg)
|
|
|
|
|
{
|
2007-07-11 23:26:30 +08:00
|
|
|
unsigned long mask, sp, nat_bits = 0, ar_rnat, urbs_end, cfm;
|
treewide: Remove uninitialized_var() usage
Using uninitialized_var() is dangerous as it papers over real bugs[1]
(or can in the future), and suppresses unrelated compiler warnings
(e.g. "unused variable"). If the compiler thinks it is uninitialized,
either simply initialize the variable or make compiler changes.
In preparation for removing[2] the[3] macro[4], remove all remaining
needless uses with the following script:
git grep '\buninitialized_var\b' | cut -d: -f1 | sort -u | \
xargs perl -pi -e \
's/\buninitialized_var\(([^\)]+)\)/\1/g;
s:\s*/\* (GCC be quiet|to make compiler happy) \*/$::g;'
drivers/video/fbdev/riva/riva_hw.c was manually tweaked to avoid
pathological white-space.
No outstanding warnings were found building allmodconfig with GCC 9.3.0
for x86_64, i386, arm64, arm, powerpc, powerpc64le, s390x, mips, sparc64,
alpha, and m68k.
[1] https://lore.kernel.org/lkml/20200603174714.192027-1-glider@google.com/
[2] https://lore.kernel.org/lkml/CA+55aFw+Vbj0i=1TGqCR5vQkCzWJ0QxK6CernOU6eedsudAixw@mail.gmail.com/
[3] https://lore.kernel.org/lkml/CA+55aFwgbgqhbp1fkxvRKEpzyR5J8n1vKT1VZdz9knmPuXhOeg@mail.gmail.com/
[4] https://lore.kernel.org/lkml/CA+55aFz2500WfbKXAx8s67wrm9=yVJu65TpLgN_ybYNv0VEOKA@mail.gmail.com/
Reviewed-by: Leon Romanovsky <leonro@mellanox.com> # drivers/infiniband and mlx4/mlx5
Acked-by: Jason Gunthorpe <jgg@mellanox.com> # IB
Acked-by: Kalle Valo <kvalo@codeaurora.org> # wireless drivers
Reviewed-by: Chao Yu <yuchao0@huawei.com> # erofs
Signed-off-by: Kees Cook <keescook@chromium.org>
2020-06-04 04:09:38 +08:00
|
|
|
unsigned long ip;
|
2005-04-17 06:20:36 +08:00
|
|
|
elf_greg_t *dst = arg;
|
|
|
|
|
struct pt_regs *pt;
|
|
|
|
|
char nat;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
memset(dst, 0, sizeof(elf_gregset_t)); /* don't leak any kernel bits to user-level */
|
|
|
|
|
|
|
|
|
|
if (unw_unwind_to_user(info) < 0)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
unw_get_sp(info, &sp);
|
|
|
|
|
pt = (struct pt_regs *) (sp + 16);
|
|
|
|
|
|
|
|
|
|
urbs_end = ia64_get_user_rbs_end(task, pt, &cfm);
|
|
|
|
|
|
|
|
|
|
if (ia64_sync_user_rbs(task, info->sw, pt->ar_bspstore, urbs_end) < 0)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
ia64_peek(task, info->sw, urbs_end, (long) ia64_rse_rnat_addr((long *) urbs_end),
|
|
|
|
|
&ar_rnat);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* coredump format:
|
|
|
|
|
* r0-r31
|
|
|
|
|
* NaT bits (for r0-r31; bit N == 1 iff rN is a NaT)
|
|
|
|
|
* predicate registers (p0-p63)
|
|
|
|
|
* b0-b7
|
|
|
|
|
* ip cfm user-mask
|
|
|
|
|
* ar.rsc ar.bsp ar.bspstore ar.rnat
|
|
|
|
|
* ar.ccv ar.unat ar.fpsr ar.pfs ar.lc ar.ec
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/* r0 is zero */
|
|
|
|
|
for (i = 1, mask = (1UL << i); i < 32; ++i) {
|
|
|
|
|
unw_get_gr(info, i, &dst[i], &nat);
|
|
|
|
|
if (nat)
|
|
|
|
|
nat_bits |= mask;
|
|
|
|
|
mask <<= 1;
|
|
|
|
|
}
|
|
|
|
|
dst[32] = nat_bits;
|
|
|
|
|
unw_get_pr(info, &dst[33]);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < 8; ++i)
|
|
|
|
|
unw_get_br(info, i, &dst[34 + i]);
|
|
|
|
|
|
|
|
|
|
unw_get_rp(info, &ip);
|
|
|
|
|
dst[42] = ip + ia64_psr(pt)->ri;
|
|
|
|
|
dst[43] = cfm;
|
|
|
|
|
dst[44] = pt->cr_ipsr & IA64_PSR_UM;
|
|
|
|
|
|
|
|
|
|
unw_get_ar(info, UNW_AR_RSC, &dst[45]);
|
|
|
|
|
/*
|
|
|
|
|
* For bsp and bspstore, unw_get_ar() would return the kernel
|
|
|
|
|
* addresses, but we need the user-level addresses instead:
|
|
|
|
|
*/
|
|
|
|
|
dst[46] = urbs_end; /* note: by convention PT_AR_BSP points to the end of the urbs! */
|
|
|
|
|
dst[47] = pt->ar_bspstore;
|
|
|
|
|
dst[48] = ar_rnat;
|
|
|
|
|
unw_get_ar(info, UNW_AR_CCV, &dst[49]);
|
|
|
|
|
unw_get_ar(info, UNW_AR_UNAT, &dst[50]);
|
|
|
|
|
unw_get_ar(info, UNW_AR_FPSR, &dst[51]);
|
|
|
|
|
dst[52] = pt->ar_pfs; /* UNW_AR_PFS is == to pt->cr_ifs for interrupt frames */
|
|
|
|
|
unw_get_ar(info, UNW_AR_LC, &dst[53]);
|
|
|
|
|
unw_get_ar(info, UNW_AR_EC, &dst[54]);
|
|
|
|
|
unw_get_ar(info, UNW_AR_CSD, &dst[55]);
|
|
|
|
|
unw_get_ar(info, UNW_AR_SSD, &dst[56]);
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-07 23:37:16 +08:00
|
|
|
static void
|
2005-04-17 06:20:36 +08:00
|
|
|
do_copy_regs (struct unw_frame_info *info, void *arg)
|
|
|
|
|
{
|
|
|
|
|
do_copy_task_regs(current, info, arg);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
ia64_elf_core_copy_regs (struct pt_regs *pt, elf_gregset_t dst)
|
|
|
|
|
{
|
|
|
|
|
unw_init_running(do_copy_regs, dst);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Flush thread state. This is called when a thread does an execve().
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
flush_thread (void)
|
|
|
|
|
{
|
|
|
|
|
/* drop floating-point and debug-register state if it exists: */
|
|
|
|
|
current->thread.flags &= ~(IA64_THREAD_FPH_VALID | IA64_THREAD_DBG_VALID);
|
|
|
|
|
ia64_drop_fpu(current);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
2016-05-21 08:00:20 +08:00
|
|
|
* Clean up state associated with a thread. This is called when
|
2005-04-17 06:20:36 +08:00
|
|
|
* the thread calls exit().
|
|
|
|
|
*/
|
|
|
|
|
void
|
2016-05-21 08:00:20 +08:00
|
|
|
exit_thread (struct task_struct *tsk)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-06-28 06:17:12 +08:00
|
|
|
|
2016-05-21 08:00:20 +08:00
|
|
|
ia64_drop_fpu(tsk);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
unsigned long
|
|
|
|
|
get_wchan (struct task_struct *p)
|
|
|
|
|
{
|
|
|
|
|
struct unw_frame_info info;
|
|
|
|
|
unsigned long ip;
|
|
|
|
|
int count = 0;
|
|
|
|
|
|
2007-05-19 02:46:52 +08:00
|
|
|
if (!p || p == current || p->state == TASK_RUNNING)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
|
* Note: p may not be a blocked task (it could be current or
|
|
|
|
|
* another process running on some other CPU. Rather than
|
|
|
|
|
* trying to determine if p is really blocked, we just assume
|
|
|
|
|
* it's blocked and rely on the unwind routines to fail
|
|
|
|
|
* gracefully if the process wasn't really blocked after all.
|
|
|
|
|
* --davidm 99/12/15
|
|
|
|
|
*/
|
|
|
|
|
unw_init_from_blocked_task(&info, p);
|
|
|
|
|
do {
|
2007-05-19 02:46:52 +08:00
|
|
|
if (p->state == TASK_RUNNING)
|
|
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
if (unw_unwind(&info) < 0)
|
|
|
|
|
return 0;
|
|
|
|
|
unw_get_ip(&info, &ip);
|
|
|
|
|
if (!in_sched_functions(ip))
|
|
|
|
|
return ip;
|
|
|
|
|
} while (count++ < 16);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
cpu_halt (void)
|
|
|
|
|
{
|
|
|
|
|
pal_power_mgmt_info_u_t power_info[8];
|
|
|
|
|
unsigned long min_power;
|
|
|
|
|
int i, min_power_state;
|
|
|
|
|
|
|
|
|
|
if (ia64_pal_halt_info(power_info) != 0)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
min_power_state = 0;
|
|
|
|
|
min_power = power_info[0].pal_power_mgmt_info_s.power_consumption;
|
|
|
|
|
for (i = 1; i < 8; ++i)
|
|
|
|
|
if (power_info[i].pal_power_mgmt_info_s.im
|
|
|
|
|
&& power_info[i].pal_power_mgmt_info_s.power_consumption < min_power) {
|
|
|
|
|
min_power = power_info[i].pal_power_mgmt_info_s.power_consumption;
|
|
|
|
|
min_power_state = i;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
while (1)
|
|
|
|
|
ia64_pal_halt(min_power_state);
|
|
|
|
|
}
|
|
|
|
|
|
2007-02-06 05:49:10 +08:00
|
|
|
void machine_shutdown(void)
|
|
|
|
|
{
|
2020-03-23 21:50:56 +08:00
|
|
|
smp_shutdown_nonboot_cpus(reboot_cpu);
|
2007-02-06 05:49:10 +08:00
|
|
|
|
|
|
|
|
#ifdef CONFIG_KEXEC
|
|
|
|
|
kexec_disable_iosapic();
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
void
|
|
|
|
|
machine_restart (char *restart_cmd)
|
|
|
|
|
{
|
[IA64] Extend notify_die() hooks for IA64
notify_die() added for MCA_{MONARCH,SLAVE,RENDEZVOUS}_{ENTER,PROCESS,LEAVE} and
INIT_{MONARCH,SLAVE}_{ENTER,PROCESS,LEAVE}. We need multiple
notification points for these events because they can take many seconds
to run which has nasty effects on the behaviour of the rest of the
system.
DIE_SS replaced by a generic DIE_FAULT which checks the vector number,
to allow interception of faults other than SS.
DIE_MACHINE_{HALT,RESTART} added to allow last minute close down
processing, especially when the halt/restart routines are called from
error handlers.
DIE_OOPS added.
The check for kprobe's break numbers has been moved from traps.c to
kprobes.c, allowing DIE_BREAK to be used for any additional break
numbers, i.e. it is no longer kprobes specific.
Hooks for kernel debuggers and kernel dumpers added, ENTER and LEAVE.
Both of these disable the system for long periods which impact on
watchdogs and heartbeat systems in general. More patches to come that
use these events to reset watchdogs and heartbeats.
unregister_die_notifier() added and both routines exported. Requested
by Dean Nelson.
Lock removed from {un,}register_die_notifier. notifier_chain_register()
already takes a lock. Also the generic notifier chain locking is being
reworked to distinguish between callbacks that can block and those that
cannot, the lock in {un,}register_die_notifier would interfere with
that change. http://marc.theaimsgroup.com/?l=linux-kernel&m=113018709002036&w=2
Leading white space removed from arch/ia64/kernel/kprobes.c.
Typo in mca.c in original version of this patch found & fixed by Dean
Nelson.
Signed-off-by: Keith Owens <kaos@sgi.com>
Acked-by: Dean Nelson <dcn@sgi.com>
Acked-by: Anil Keshavamurthy <anil.s.keshavamurthy@intel.com>
Signed-off-by: Tony Luck <tony.luck@intel.com>
2005-11-08 03:27:13 +08:00
|
|
|
(void) notify_die(DIE_MACHINE_RESTART, restart_cmd, NULL, 0, 0, 0);
|
2014-06-13 19:22:22 +08:00
|
|
|
efi_reboot(REBOOT_WARM, NULL);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
machine_halt (void)
|
|
|
|
|
{
|
[IA64] Extend notify_die() hooks for IA64
notify_die() added for MCA_{MONARCH,SLAVE,RENDEZVOUS}_{ENTER,PROCESS,LEAVE} and
INIT_{MONARCH,SLAVE}_{ENTER,PROCESS,LEAVE}. We need multiple
notification points for these events because they can take many seconds
to run which has nasty effects on the behaviour of the rest of the
system.
DIE_SS replaced by a generic DIE_FAULT which checks the vector number,
to allow interception of faults other than SS.
DIE_MACHINE_{HALT,RESTART} added to allow last minute close down
processing, especially when the halt/restart routines are called from
error handlers.
DIE_OOPS added.
The check for kprobe's break numbers has been moved from traps.c to
kprobes.c, allowing DIE_BREAK to be used for any additional break
numbers, i.e. it is no longer kprobes specific.
Hooks for kernel debuggers and kernel dumpers added, ENTER and LEAVE.
Both of these disable the system for long periods which impact on
watchdogs and heartbeat systems in general. More patches to come that
use these events to reset watchdogs and heartbeats.
unregister_die_notifier() added and both routines exported. Requested
by Dean Nelson.
Lock removed from {un,}register_die_notifier. notifier_chain_register()
already takes a lock. Also the generic notifier chain locking is being
reworked to distinguish between callbacks that can block and those that
cannot, the lock in {un,}register_die_notifier would interfere with
that change. http://marc.theaimsgroup.com/?l=linux-kernel&m=113018709002036&w=2
Leading white space removed from arch/ia64/kernel/kprobes.c.
Typo in mca.c in original version of this patch found & fixed by Dean
Nelson.
Signed-off-by: Keith Owens <kaos@sgi.com>
Acked-by: Dean Nelson <dcn@sgi.com>
Acked-by: Anil Keshavamurthy <anil.s.keshavamurthy@intel.com>
Signed-off-by: Tony Luck <tony.luck@intel.com>
2005-11-08 03:27:13 +08:00
|
|
|
(void) notify_die(DIE_MACHINE_HALT, "", NULL, 0, 0, 0);
|
2005-04-17 06:20:36 +08:00
|
|
|
cpu_halt();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
machine_power_off (void)
|
|
|
|
|
{
|
|
|
|
|
if (pm_power_off)
|
|
|
|
|
pm_power_off();
|
|
|
|
|
machine_halt();
|
|
|
|
|
}
|
|
|
|
|
|
2020-03-21 19:25:53 +08:00
|
|
|
EXPORT_SYMBOL(ia64_delay_loop);
|
