Projectname large_stringclasses 15
values | Filepath large_stringlengths 4 106 ⌀ | Function large_stringlengths 11 3.45k | Label list |
|---|---|---|---|
Linux Kernel | arch/powerpc/kernel/sysfs.c |
static ssize_t show_smt_snooze_delay(struct device *dev,
struct device_attribute *attr, char *buf) {
pr_warn_once("%s (%d) read from unsupported smt_snooze_delay\n",
current->comm, current->pid);
return sprintf(buf, "100\n");
} | [
1,
0
] |
Linux Kernel | arch/powerpc/kernel/sysfs.c | static void read_dscr(void *val) {
*(unsigned long *)val = get_paca()->dscr_default;
} | [
1,
0
] |
Linux Kernel | arch/powerpc/kernel/sysfs.c |
static void add_write_permission_dev_attr(struct device_attribute *attr) {
attr->attr.mode |= 0200;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/sysfs.c |
static ssize_t store_pw20_state(struct device *dev,
struct device_attribute *attr, const char *buf,
size_t count) {
u32 value;
unsigned int cpu = dev->id;
if (kstrtou32(buf, 0, &value))
return -EINVAL;
if (value > 1)
return -EINVAL;
s... | [
1,
0
] |
Linux Kernel | arch/powerpc/kernel/sysfs.c | static ssize_t show_pw20_wait_time(struct device *dev,
struct device_attribute *attr, char *buf) {
u32 value;
u64 tb_cycle = 1;
u64 time;
unsigned int cpu = dev->id;
if (!pw20_wt) {
smp_call_function_single(cpu, do_show_pwrmgtcr0, &value, 1);
value = (value & PWRMG... | [
1,
0
] |
Linux Kernel | arch/powerpc/kernel/sysfs.c |
static ssize_t store_pw20_wait_time(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count) {
u32 entry_bit;
u64 value;
unsigned int cpu = dev->id;
if (kstrtou64(buf, 0, &value))
return -EINVAL;
if (!valu... | [
1,
0
] |
Linux Kernel | arch/powerpc/kernel/sysfs.c | static void set_altivec_idle_wait_entry_bit(void *val) {
u32 *value = val;
u32 altivec_idle;
altivec_idle = mfspr(SPRN_PWRMGTCR0);
/* clear count */
altivec_idle &= ~PWRMGTCR0_AV_IDLE_CNT;
/* set count */
altivec_idle |= ((MAX_BIT - *value) << PWRMGTCR0_AV_IDLE_CNT_SHIFT);
mtspr(SPRN_PWRMGTCR0, alti... | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/sysfs.c | void ppc_enable_pmcs(void) {
ppc_set_pmu_inuse(1);
if (__this_cpu_read(pmcs_enabled))
return;
__this_cpu_write(pmcs_enabled, 1);
if (ppc_md.enable_pmcs)
ppc_md.enable_pmcs();
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/sysfs.c |
static void remove_idle_purr_file(struct device *s) {
if (firmware_has_feature(FW_FEATURE_LPAR))
device_remove_file(s, &dev_attr_idle_purr);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/sysfs.c |
static void read_idle_spurr(void *val) {
u64 *ret = val;
*ret = read_this_idle_spurr();
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/sysfs.c |
static ssize_t idle_spurr_show(struct device *dev,
struct device_attribute *attr, char *buf) {
struct cpu *cpu = container_of(dev, struct cpu, dev);
u64 val;
smp_call_function_single(cpu->dev.id, read_idle_spurr, &val, 1);
return sprintf(buf, "%llx\n", val);
} | [
1,
0
] |
Linux Kernel | arch/powerpc/kernel/sysfs.c | ssize_t arch_cpu_probe(const char *buf, size_t count) {
if (ppc_md.cpu_probe)
return ppc_md.cpu_probe(buf, count);
return -EINVAL;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/tau_6xx.c | static void TAUupdate(int cpu) {
u32 thrm;
u32 bits = THRM1_TIV | THRM1_TIN | THRM1_V;
thrm = mfspr(SPRN_THRM1);
if ((thrm & bits) == bits) {
mtspr(SPRN_THRM1, 0);
if (tau[cpu].low >= step_size) {
tau[cpu].low -= step_size;
tau[cpu].high -= (step_size - window_expand);
}
tau[cpu].g... | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/time.c |
void vtime_account_kernel(struct task_struct *tsk) {
struct cpu_accounting_data *acct = get_accounting(tsk);
unsigned long stime, stime_scaled;
vtime_delta_kernel(acct, &stime, &stime_scaled);
if (tsk->flags & PF_VCPU) {
acct->gtime += stime;
#ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME
acct->utime_scaled +... | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/time.c | void __delay(unsigned long loops) {
unsigned long start;
spin_begin();
if (tb_invalid) {
spin_cpu_relax();
} else {
start = mftb();
while (mftb() - start < loops)
spin_cpu_relax();
}
spin_end();
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/time.c |
void udelay(unsigned long usecs) { __delay(tb_ticks_per_usec * usecs); } | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/time.c |
static inline void set_irq_work_pending_flag(void) {
asm volatile("stb %0,%1(13)"
:
: "r"(1), "i"(offsetof(struct paca_struct, irq_work_pending)));
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/time.c | void timer_rearm_host_dec(u64 now) {
u64 *next_tb = this_cpu_ptr(&decrementers_next_tb);
WARN_ON_ONCE(!arch_irqs_disabled());
WARN_ON_ONCE(mfmsr() & MSR_EE);
if (now >= *next_tb) {
local_paca->irq_happened |= PACA_IRQ_DEC;
} else {
now = *next_tb - now;
if (now > decrementer_max)
now = dec... | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/time.c | void timer_broadcast_interrupt(void) {
tick_receive_broadcast();
__this_cpu_inc(irq_stat.broadcast_irqs_event);
}
#endif
#ifdef CONFIG_SUSPEND | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/time.c | static void start_cpu_decrementer(void) {
#ifdef CONFIG_BOOKE_OR_40x
unsigned int tcr;
mtspr(SPRN_TSR, TSR_ENW | TSR_WIS | TSR_DIS | TSR_FIS);
tcr = mfspr(SPRN_TCR);
/*
* The watchdog may have already been enabled by u-boot. So leave
* TRC[WP] (Watchdog Period) alone.
*/
tcr &= TCR_WP_MASK; /* Clea... | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/time.c | static void register_decrementer_clockevent(int cpu) {
struct clock_event_device *dec = &per_cpu(decrementers, cpu);
*dec = decrementer_clockevent;
dec->cpumask = cpumask_of(cpu);
clockevents_config_and_register(dec, ppc_tb_freq, 2, decrementer_max);
printk_once(KERN_DEBUG "clockevent: %s mult[%x] shift[%d... | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/trace/ftrace.c | static ppc_inst_t ftrace_call_replace(unsigned long ip, unsigned long addr,
int link) {
ppc_inst_t op;
addr = ppc_function_entry((void *)addr);
create_branch(&op, (u32 *)ip, addr, link ? BRANCH_SET_LINK : 0);
return op;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/trace/ftrace.c |
static int is_b_op(ppc_inst_t op) {
return (ppc_inst_val(op) & ~PPC_LI_MASK) == PPC_RAW_BRANCH(0);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/trace/ftrace.c | static int __ftrace_make_nop(struct module *mod, struct dyn_ftrace *rec,
unsigned long addr) {
return 0;
}
#endif | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/trace/ftrace.c |
static int add_ftrace_tramp(unsigned long tramp) {
int i;
for (i = 0; i < NUM_FTRACE_TRAMPS; i++)
if (!ftrace_tramps[i]) {
ftrace_tramps[i] = tramp;
return 0;
}
return -1;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/trace/ftrace.c | static int __ftrace_make_nop_kernel(struct dyn_ftrace *rec,
unsigned long addr) {
unsigned long tramp, ip = rec->ip;
ppc_inst_t op;
if (copy_inst_from_kernel_nofault(&op, (void *)ip)) {
pr_err("Fetching opcode failed.\n");
return -EFAULT;
}
/* Make sure that this ... | [
1,
0
] |
Linux Kernel | arch/powerpc/kernel/trace/ftrace.c | static int __ftrace_make_call_kernel(struct dyn_ftrace *rec,
unsigned long addr) {
ppc_inst_t op;
void *ip = (void *)rec->ip;
unsigned long tramp, entry, ptr;
entry = ppc_global_function_entry((void *)ftrace_caller);
ptr = ppc_global_function_entry((void *)addr);
if (p... | [
1,
0
] |
Linux Kernel | arch/powerpc/kernel/trace/ftrace.c | void arch_ftrace_update_code(int command) { ftrace_modify_all_code(command); }
#ifdef CONFIG_PPC64
#define PACATOC offsetof(struct paca_struct, kernel_toc) | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/trace/ftrace.c |
void ftrace_free_init_tramp(void) {
int i;
for (i = 0; i < NUM_FTRACE_TRAMPS && ftrace_tramps[i]; i++)
if (ftrace_tramps[i] == (unsigned long)ftrace_tramp_init) {
ftrace_tramps[i] = 0;
return;
}
} | [
1,
0
] |
Linux Kernel | arch/powerpc/kernel/trace/ftrace.c |
static int ftrace_modify_ftrace_graph_caller(bool enable) {
unsigned long ip = (unsigned long)(&ftrace_graph_call);
unsigned long addr = (unsigned long)(&ftrace_graph_caller);
unsigned long stub = (unsigned long)(&ftrace_graph_stub);
ppc_inst_t old, new;
if (IS_ENABLED(CONFIG_DYNAMIC_FTRACE_WITH_ARGS))
... | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/trace/ftrace.c | static unsigned long __prepare_ftrace_return(unsigned long parent,
unsigned long ip,
unsigned long sp) {
unsigned long return_hooker;
int bit;
if (unlikely(ftrace_graph_is_dead()))
goto out;
if (unlikely(atomic_read(... | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/trace/ftrace.c | char *arch_ftrace_match_adjust(char *str, const char *search) {
if (str[0] == '.' && search[0] != '.')
return str + 1;
else
return str;
}
#endif | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/traps.c | extern void panic_flush_kmsg_start(void) {
console_verbose();
bust_spinlocks(1);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/traps.c |
void user_single_step_report(struct pt_regs *regs) {
force_sig_fault(SIGTRAP, TRAP_TRACE, (void __user *)regs->nip);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/traps.c | static bool exception_common(int signr, struct pt_regs *regs, int code,
unsigned long addr) {
if (!user_mode(regs)) {
die("Exception in kernel mode", regs, signr);
return false;
}
show_signal_msg(signr, regs, code, addr);
current->thread.trap_nr = code;
return true;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/traps.c | static inline int check_io_access(struct pt_regs *regs) {
#ifdef CONFIG_PPC32
unsigned long msr = regs->msr;
const struct exception_table_entry *entry;
unsigned int *nip = (unsigned int *)regs->nip;
if (((msr & 0xffff0000) == 0 || (msr & (0x80000 | 0x40000))) &&
(entry = search_exception_tables(regs->nip... | [
1,
0
] |
Linux Kernel | arch/powerpc/kernel/traps.c | int machine_check_generic(struct pt_regs *regs) {
unsigned long reason = regs->msr;
printk("Machine check in kernel mode.\n");
printk("Caused by (from SRR1=%lx): ", reason);
switch (reason & 0x601F0000) {
case 0x80000:
pr_cont("Machine check signal\n");
break;
case 0x40000:
case 0x140000:
pr_... | [
1,
0
] |
Linux Kernel | arch/powerpc/kernel/traps.c | void die_mce(const char *str, struct pt_regs *regs, long err) {
if (in_nmi())
nmi_exit();
else
irq_exit();
die(str, regs, err);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/traps.c |
static void __single_step_exception(struct pt_regs *regs) {
clear_single_step(regs);
clear_br_trace(regs);
if (kprobe_post_handler(regs))
return;
if (notify_die(DIE_SSTEP, "single_step", regs, 5, 5, SIGTRAP) == NOTIFY_STOP)
return;
if (debugger_sstep(regs))
return;
_exception(SIGTRAP, regs, ... | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/traps.c |
static int emulate_popcntb_inst(struct pt_regs *regs, u32 instword) {
u32 ra, rs;
unsigned long tmp;
ra = (instword >> 16) & 0x1f;
rs = (instword >> 21) & 0x1f;
tmp = regs->gpr[rs];
tmp = tmp - ((tmp >> 1) & 0x5555555555555555ULL);
tmp = (tmp & 0x3333333333333333ULL) + ((tmp >> 2) & 0x3333333333333333U... | [
1,
0
] |
Linux Kernel | arch/powerpc/kernel/traps.c |
static int emulate_isel(struct pt_regs *regs, u32 instword) {
u8 rT = (instword >> 21) & 0x1f;
u8 rA = (instword >> 16) & 0x1f;
u8 rB = (instword >> 11) & 0x1f;
u8 BC = (instword >> 6) & 0x1f;
u8 bit;
unsigned long tmp;
tmp = (rA == 0) ? 0 : regs->gpr[rA];
bit = (regs->ccr >> (31 - BC)) & 0x1;
regs... | [
1,
0
] |
Linux Kernel | arch/powerpc/kernel/traps.c | static inline bool tm_abort_check(struct pt_regs *regs, int reason) {
return false;
}
#endif | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/udbg.c | void udbg_puts(const char *s) {
if (udbg_putc) {
char c;
if (s && *s != '\0') {
while ((c = *s++) != '\0')
udbg_putc(c);
}
if (udbg_flush)
udbg_flush();
}
#if 0
else {
printk("%s", s);
}
#endif
} | [
1,
0
] |
Linux Kernel | arch/powerpc/kernel/udbg_16550.c | void __init udbg_uart_setup(unsigned int speed, unsigned int clock) {
unsigned int dll, base_bauds;
if (!udbg_uart_out)
return;
if (clock == 0)
clock = 1843200;
if (speed == 0)
speed = 9600;
base_bauds = clock / 16;
dll = base_bauds / speed;
udbg_uart_out(UART_LCR, 0x00);
udbg_uart_out(U... | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/udbg_16550.c | unsigned int __init udbg_probe_uart_speed(unsigned int clock) {
unsigned int dll, dlm, divisor, prescaler, speed;
u8 old_lcr;
old_lcr = udbg_uart_in(UART_LCR);
udbg_uart_out(UART_LCR, old_lcr | LCR_DLAB);
/* now, read the divisor */
dll = udbg_uart_in(UART_DLL);
dlm = udbg_uart_in(UART_DLM);
divisor ... | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/udbg_16550.c |
static u8 udbg_uart_in_pio(unsigned int reg) {
return inb(udbg_uart.pio_base + (reg * udbg_uart_stride));
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/udbg_16550.c |
static void udbg_uart_out_pio(unsigned int reg, u8 data) {
outb(data, udbg_uart.pio_base + (reg * udbg_uart_stride));
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/udbg_16550.c |
static void udbg_uart_out_mmio(unsigned int reg, u8 data) {
out_8(udbg_uart.mmio_base + (reg * udbg_uart_stride), data);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/udbg_16550.c |
void __init udbg_uart_init_mmio(void __iomem *addr, unsigned int stride) {
if (!addr)
return;
udbg_uart.mmio_base = addr;
udbg_uart_stride = stride;
udbg_uart_in = udbg_uart_in_mmio;
udbg_uart_out = udbg_uart_out_mmio;
udbg_use_uart();
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/udbg_16550.c |
void __init udbg_init_pas_realmode(void) {
udbg_uart_in = udbg_uart_in_pas;
udbg_uart_out = udbg_uart_out_pas;
udbg_use_uart();
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/udbg_16550.c |
void __init udbg_init_44x_as1(void) {
udbg_uart_in = udbg_uart_in_44x_as1;
udbg_uart_out = udbg_uart_out_44x_as1;
udbg_use_uart();
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/udbg_16550.c |
static u8 udbg_uart_in_40x(unsigned int reg) {
return real_readb((void __iomem *)CONFIG_PPC_EARLY_DEBUG_40x_PHYSADDR + reg);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/uprobes.c | int arch_uprobe_pre_xol(struct arch_uprobe *auprobe, struct pt_regs *regs) {
struct arch_uprobe_task *autask = ¤t->utask->autask;
autask->saved_trap_nr = current->thread.trap_nr;
current->thread.trap_nr = UPROBE_TRAP_NR;
regs_set_return_ip(regs, current->utask->xol_vaddr);
user_enable_single_step(curr... | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/uprobes.c | bool arch_uprobe_xol_was_trapped(struct task_struct *t) {
if (t->thread.trap_nr != UPROBE_TRAP_NR)
return true;
return false;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/uprobes.c | int arch_uprobe_post_xol(struct arch_uprobe *auprobe, struct pt_regs *regs) {
struct uprobe_task *utask = current->utask;
WARN_ON_ONCE(current->thread.trap_nr != UPROBE_TRAP_NR);
current->thread.trap_nr = utask->autask.saved_trap_nr;
regs_set_return_ip(
regs, (unsigned long)ppc_inst_next((void *)utask-... | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/uprobes.c | bool arch_uprobe_skip_sstep(struct arch_uprobe *auprobe, struct pt_regs *regs) {
int ret;
ret = emulate_step(regs, ppc_inst_read(auprobe->insn));
if (ret > 0)
return true;
return false;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/uprobes.c |
bool arch_uretprobe_is_alive(struct return_instance *ret, enum rp_check ctx,
struct pt_regs *regs) {
if (ctx == RP_CHECK_CHAIN_CALL)
return regs->gpr[1] <= ret->stack;
else
return regs->gpr[1] < ret->stack;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/vdso/vgettimeofday.c | int __c_kernel_clock_gettime(clockid_t clock, struct __kernel_timespec *ts,
const struct vdso_data *vd) {
return __cvdso_clock_gettime_data(vd, clock, ts);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/vdso.c | struct vdso_data *arch_get_vdso_data(void *vvar_page) {
return ((struct vdso_arch_data *)vvar_page)->data;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/vdso.c | int vdso_getcpu_init(void) {
unsigned long cpu, node, val;
cpu = get_cpu();
WARN_ON_ONCE(cpu > 0xffff);
node = cpu_to_node(cpu);
WARN_ON_ONCE(node > 0xffff);
val = (cpu & 0xffff) | ((node & 0xffff) << 16);
mtspr(SPRN_SPRG_VDSO_WRITE, val);
get_paca()->sprg_vdso = val;
put_cpu();
return 0;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/vecemu.c | static unsigned int eexp2(unsigned int s) {
int exp, pwr;
unsigned int mant, frac;
exp = ((s >> 23) & 0xff) - 127;
if (exp > 7) {
/* check for NaN input */
if (exp == 128 && (s & 0x7fffff) != 0)
return s | 0x400000; /* return QNaN */
/* 2^-big = 0, 2^+big = +Inf */
return (s & 0x80000000)... | [
1,
0
] |
Linux Kernel | arch/powerpc/kernel/vecemu.c | static unsigned int rfin(unsigned int x) {
int exp, half;
exp = ((x >> 23) & 0xff) - 127;
if (exp == 128 && (x & 0x7fffff) != 0)
return x | 0x400000;
if (exp >= 23)
return x; /* it's an integer already (or Inf) */
if (exp < -1)
return x & 0x80000000; /* |x| < 0.5 -> +/-0 */
if (exp == -1)
/... | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/watchdog.c | static void watchdog_smp_panic(int cpu) {
static cpumask_t wd_smp_cpus_ipi;
unsigned long flags;
u64 tb, last_reset;
int c;
wd_smp_lock(&flags);
/* Double check some things under lock */
tb = get_tb();
last_reset = wd_smp_last_reset_tb;
if ((s64)(tb - last_reset) < (s64)wd_smp_panic_timeout_tb)
g... | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/watchdog.c |
static int stop_watchdog_on_cpu(unsigned int cpu) {
return smp_call_function_single(cpu, stop_watchdog, NULL, true);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kernel/watchdog.c |
void watchdog_nmi_start(void) {
int cpu;
watchdog_calc_timeouts();
for_each_cpu_and(cpu, cpu_online_mask, &watchdog_cpumask)
start_watchdog_on_cpu(cpu);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kexec/core.c |
void machine_kexec_mask_interrupts(void) {
unsigned int i;
struct irq_desc *desc;
for_each_irq_desc(i, desc) {
struct irq_chip *chip;
chip = irq_desc_get_chip(desc);
if (!chip)
continue;
if (chip->irq_eoi && irqd_irq_inprogress(&desc->irq_data))
chip->irq_eoi(&desc->irq_data);
... | [
0,
0
] |
Linux Kernel | arch/powerpc/kexec/core.c |
void machine_kexec_cleanup(struct kimage *image) {} | [
0,
0
] |
Linux Kernel | arch/powerpc/kexec/core_32.c |
int machine_kexec_prepare(struct kimage *image) { return 0; } | [
0,
0
] |
Linux Kernel | arch/powerpc/kexec/core_64.c | static void kexec_prepare_cpus_wait(int wait_state) {
int my_cpu, i, notified = -1;
hw_breakpoint_disable();
my_cpu = get_cpu();
/* Make sure each CPU has at least made it to the state we need.
*
* FIXME: There is a (slim) chance of a problem if not all of the CPUs
* are correctly onlined. If somehow... | [
0,
1
] |
Linux Kernel | arch/powerpc/kexec/crash.c | static void crash_kexec_prepare_cpus(void) {
#ifdef CONFIG_PPC64
smp_release_cpus();
#else
/* FIXME */
#endif
} | [
0,
1
] |
Linux Kernel | arch/powerpc/kexec/crash.c | static inline void crash_kexec_wait_realmode(int cpu) {}
#endif | [
0,
0
] |
Linux Kernel | arch/powerpc/kexec/file_load_64.c | static int __locate_mem_hole_top_down(struct kexec_buf *kbuf, u64 buf_min,
u64 buf_max) {
int ret = -EADDRNOTAVAIL;
phys_addr_t start, end;
u64 i;
for_each_mem_range_rev(i, &start, &end) {
end -= 1;
if (start > buf_max)
continue;
/* Memory hole not fou... | [
1,
0
] |
Linux Kernel | arch/powerpc/kexec/file_load_64.c | static int locate_mem_hole_bottom_up_ppc64(struct kexec_buf *kbuf, u64 buf_min,
u64 buf_max,
const struct crash_mem *emem) {
int i, ret = 0, err = -EADDRNOTAVAIL;
u64 start, end, tmin, tmax;
tmin = buf_min;
for (i = 0; i < em... | [
0,
0
] |
Linux Kernel | arch/powerpc/kexec/file_load_64.c | static int add_usable_mem(struct umem_info *um_info, u64 base, u64 end) {
u64 loc_base, loc_end;
bool add;
int i;
for (i = 0; i < um_info->nr_ranges; i++) {
add = false;
loc_base = um_info->ranges[i].start;
loc_end = um_info->ranges[i].end;
if (loc_base >= base && loc_end <= end)
add = tr... | [
1,
0
] |
Linux Kernel | arch/powerpc/kexec/file_load_64.c | static int kdump_setup_usable_lmb(struct drmem_lmb *lmb, const __be32 **usm,
void *data) {
struct umem_info *um_info;
int tmp_idx, ret;
u64 base, end;
if (*usm) {
pr_err("linux,drconf-usable-memory property already exists!");
return -EINVAL;
}
um_info = data;
tm... | [
1,
0
] |
Linux Kernel | arch/powerpc/kexec/file_load_64.c | static int update_usable_mem_fdt(void *fdt, struct crash_mem *usable_mem) {
struct umem_info um_info;
struct device_node *dn;
int node, ret = 0;
if (!usable_mem) {
pr_err("Usable memory ranges for kdump kernel not found\n");
return -ENOENT;
}
node = fdt_path_offset(fdt, "/ibm,dynamic-reconfigurati... | [
1,
0
] |
Linux Kernel | arch/powerpc/kexec/file_load_64.c | int load_crashdump_segments_ppc64(struct kimage *image,
struct kexec_buf *kbuf) {
int ret;
ret = load_backup_segment(image, kbuf);
if (ret) {
pr_err("Failed to load backup segment\n");
return ret;
}
pr_debug("Loaded the backup region at 0x%lx\n", kbuf->mem);
/* Lo... | [
0,
0
] |
Linux Kernel | arch/powerpc/kexec/file_load_64.c | unsigned int kexec_extra_fdt_size_ppc64(struct kimage *image) {
u64 usm_entries;
if (image->type != KEXEC_TYPE_CRASH)
return 0;
usm_entries = ((memblock_end_of_DRAM() / drmem_lmb_size()) +
(2 * (resource_size(&crashk_res) / drmem_lmb_size())));
return (unsigned int)(usm_entries * sizeof(u... | [
1,
0
] |
Linux Kernel | arch/powerpc/kexec/file_load_64.c |
static int copy_property(void *fdt, int node_offset,
const struct device_node *dn, const char *propname) {
const void *prop, *fdtprop;
int len = 0, fdtlen = 0;
prop = of_get_property(dn, propname, &len);
fdtprop = fdt_getprop(fdt, node_offset, propname, &fdtlen);
if (fdtprop && !pr... | [
0,
0
] |
Linux Kernel | arch/powerpc/kexec/file_load_64.c | int arch_kexec_locate_mem_hole(struct kexec_buf *kbuf) {
struct crash_mem **emem;
u64 buf_min, buf_max;
int ret;
emem = &(kbuf->image->arch.exclude_ranges);
if (!(*emem) || ((*emem)->nr_ranges == 0)) {
pr_warn(
"No exclude range list. Using the default locate mem hole method\n");
return kexec... | [
1,
0
] |
Linux Kernel | arch/powerpc/kexec/file_load_64.c | int arch_kexec_kernel_image_probe(struct kimage *image, void *buf,
unsigned long buf_len) {
int ret;
ret = get_exclude_memory_ranges(&(image->arch.exclude_ranges));
if (ret) {
pr_err("Failed to setup exclude memory ranges for buffer lookup\n");
return ret;
}
return ... | [
0,
0
] |
Linux Kernel | arch/powerpc/kexec/file_load_64.c | int arch_kimage_file_post_load_cleanup(struct kimage *image) {
kfree(image->arch.exclude_ranges);
image->arch.exclude_ranges = NULL;
vfree(image->arch.backup_buf);
image->arch.backup_buf = NULL;
vfree(image->elf_headers);
image->elf_headers = NULL;
image->elf_headers_sz = 0;
kvfree(image->arch.fdt);
... | [
0,
0
] |
Linux Kernel | arch/powerpc/kexec/ranges.c | static inline unsigned int get_max_nr_ranges(size_t size) {
return ((size - sizeof(struct crash_mem)) / sizeof(struct range));
} | [
1,
0
] |
Linux Kernel | arch/powerpc/kexec/ranges.c | static int rngcmp(const void *_x, const void *_y) {
const struct range *x = _x, *y = _y;
if (x->start > y->start)
return 1;
if (x->start < y->start)
return -1;
return 0;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kexec/ranges.c | void sort_memory_ranges(struct crash_mem *mem_rngs, bool merge) {
int i;
if (!mem_rngs)
return;
sort(&(mem_rngs->ranges[0]), mem_rngs->nr_ranges, sizeof(mem_rngs->ranges[0]),
rngcmp, NULL);
if (merge)
__merge_memory_ranges(mem_rngs);
/* For debugging purpose */
pr_debug("Memory ranges:\n"... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s.c |
static inline void kvmppc_update_int_pending(struct kvm_vcpu *vcpu,
unsigned long pending_now,
unsigned long old_pending) {
if (is_kvmppc_hv_enabled(vcpu->kvm))
return;
if (pending_now)
kvmppc_set_int_pending(vcpu, 1)... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s.c | static inline bool kvmppc_critical_section(struct kvm_vcpu *vcpu) {
ulong crit_raw;
ulong crit_r1;
bool crit;
if (is_kvmppc_hv_enabled(vcpu->kvm))
return false;
crit_raw = kvmppc_get_critical(vcpu);
crit_r1 = kvmppc_get_gpr(vcpu, 1);
if (!(kvmppc_get_msr(vcpu) & MSR_SF)) {
crit_raw &= 0xfffffff... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s.c |
static int kvmppc_book3s_vec2irqprio(unsigned int vec) {
unsigned int prio;
switch (vec) {
case 0x100:
prio = BOOK3S_IRQPRIO_SYSTEM_RESET;
break;
case 0x200:
prio = BOOK3S_IRQPRIO_MACHINE_CHECK;
break;
case 0x300:
prio = BOOK3S_IRQPRIO_DATA_STORAGE;
break;
case 0x380:
prio = BO... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s.c |
void kvmppc_book3s_dequeue_irqprio(struct kvm_vcpu *vcpu, unsigned int vec) {
unsigned long old_pending = vcpu->arch.pending_exceptions;
clear_bit(kvmppc_book3s_vec2irqprio(vec), &vcpu->arch.pending_exceptions);
kvmppc_update_int_pending(vcpu, vcpu->arch.pending_exceptions, old_pending);
} | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s.c | void kvmppc_core_queue_machine_check(struct kvm_vcpu *vcpu, ulong flags) {
kvmppc_inject_interrupt(vcpu, BOOK3S_INTERRUPT_MACHINE_CHECK, flags);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s.c |
void kvmppc_core_queue_syscall(struct kvm_vcpu *vcpu) {
kvmppc_inject_interrupt(vcpu, BOOK3S_INTERRUPT_SYSCALL, 0);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s.c | void kvmppc_core_queue_program(struct kvm_vcpu *vcpu, ulong flags) {
kvmppc_inject_interrupt(vcpu, BOOK3S_INTERRUPT_PROGRAM, flags);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s.c |
void kvmppc_core_dequeue_dec(struct kvm_vcpu *vcpu) {
kvmppc_book3s_dequeue_irqprio(vcpu, BOOK3S_INTERRUPT_DECREMENTER);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s.c |
void kvmppc_core_queue_data_storage(struct kvm_vcpu *vcpu, ulong dar,
ulong flags) {
kvmppc_set_dar(vcpu, dar);
kvmppc_set_dsisr(vcpu, flags);
kvmppc_inject_interrupt(vcpu, BOOK3S_INTERRUPT_DATA_STORAGE, 0);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s.c |
int kvmppc_xlate(struct kvm_vcpu *vcpu, ulong eaddr, enum xlate_instdata xlid,
enum xlate_readwrite xlrw, struct kvmppc_pte *pte) {
bool data = (xlid == XLATE_DATA);
bool iswrite = (xlrw == XLATE_WRITE);
int relocated = (kvmppc_get_msr(vcpu) & (data ? MSR_DR : MSR_IR));
int r;
if (relocated... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s.c |
int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
struct kvm_sregs *sregs) {
int ret;
vcpu_load(vcpu);
ret = vcpu->kvm->arch.kvm_ops->get_sregs(vcpu, sregs);
vcpu_put(vcpu);
return ret;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s.c |
int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) {
int i;
kvmppc_set_pc(vcpu, regs->pc);
kvmppc_set_cr(vcpu, regs->cr);
kvmppc_set_ctr(vcpu, regs->ctr);
kvmppc_set_lr(vcpu, regs->lr);
kvmppc_set_xer(vcpu, regs->xer);
kvmppc_set_msr(vcpu, regs->msr);
kvmppc_set_srr0(vcpu, ... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s.c |
void kvmppc_core_vcpu_load(struct kvm_vcpu *vcpu, int cpu) {
vcpu->kvm->arch.kvm_ops->vcpu_load(vcpu, cpu);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s.c |
int kvmppc_core_prepare_memory_region(struct kvm *kvm,
const struct kvm_memory_slot *old,
struct kvm_memory_slot *new,
enum kvm_mr_change change) {
return kvm->arch.kvm_ops->prepare_memory_region(kvm, ol... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s.c |
bool kvm_unmap_gfn_range(struct kvm *kvm, struct kvm_gfn_range *range) {
return kvm->arch.kvm_ops->unmap_gfn_range(kvm, range);
} | [
0,
0
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.