Merge remote-tracking branch 'f2fs/linux-3.10.y' into HEAD
Change-Id: Ic2fe24529f029909ddd96490bd6d885d60f88be2
This commit is contained in:
commit
82b37d9f2f
|
@ -0,0 +1,114 @@
|
|||
What: /sys/fs/f2fs/<disk>/gc_max_sleep_time
|
||||
Date: July 2013
|
||||
Contact: "Namjae Jeon" <namjae.jeon@samsung.com>
|
||||
Description:
|
||||
Controls the maximun sleep time for gc_thread. Time
|
||||
is in milliseconds.
|
||||
|
||||
What: /sys/fs/f2fs/<disk>/gc_min_sleep_time
|
||||
Date: July 2013
|
||||
Contact: "Namjae Jeon" <namjae.jeon@samsung.com>
|
||||
Description:
|
||||
Controls the minimum sleep time for gc_thread. Time
|
||||
is in milliseconds.
|
||||
|
||||
What: /sys/fs/f2fs/<disk>/gc_no_gc_sleep_time
|
||||
Date: July 2013
|
||||
Contact: "Namjae Jeon" <namjae.jeon@samsung.com>
|
||||
Description:
|
||||
Controls the default sleep time for gc_thread. Time
|
||||
is in milliseconds.
|
||||
|
||||
What: /sys/fs/f2fs/<disk>/gc_idle
|
||||
Date: July 2013
|
||||
Contact: "Namjae Jeon" <namjae.jeon@samsung.com>
|
||||
Description:
|
||||
Controls the victim selection policy for garbage collection.
|
||||
|
||||
What: /sys/fs/f2fs/<disk>/reclaim_segments
|
||||
Date: October 2013
|
||||
Contact: "Jaegeuk Kim" <jaegeuk.kim@samsung.com>
|
||||
Description:
|
||||
Controls the issue rate of segment discard commands.
|
||||
|
||||
What: /sys/fs/f2fs/<disk>/ipu_policy
|
||||
Date: November 2013
|
||||
Contact: "Jaegeuk Kim" <jaegeuk.kim@samsung.com>
|
||||
Description:
|
||||
Controls the in-place-update policy.
|
||||
|
||||
What: /sys/fs/f2fs/<disk>/min_ipu_util
|
||||
Date: November 2013
|
||||
Contact: "Jaegeuk Kim" <jaegeuk.kim@samsung.com>
|
||||
Description:
|
||||
Controls the FS utilization condition for the in-place-update
|
||||
policies.
|
||||
|
||||
What: /sys/fs/f2fs/<disk>/min_fsync_blocks
|
||||
Date: September 2014
|
||||
Contact: "Jaegeuk Kim" <jaegeuk@kernel.org>
|
||||
Description:
|
||||
Controls the dirty page count condition for the in-place-update
|
||||
policies.
|
||||
|
||||
What: /sys/fs/f2fs/<disk>/max_small_discards
|
||||
Date: November 2013
|
||||
Contact: "Jaegeuk Kim" <jaegeuk.kim@samsung.com>
|
||||
Description:
|
||||
Controls the issue rate of small discard commands.
|
||||
|
||||
What: /sys/fs/f2fs/<disk>/max_victim_search
|
||||
Date: January 2014
|
||||
Contact: "Jaegeuk Kim" <jaegeuk.kim@samsung.com>
|
||||
Description:
|
||||
Controls the number of trials to find a victim segment.
|
||||
|
||||
What: /sys/fs/f2fs/<disk>/dir_level
|
||||
Date: March 2014
|
||||
Contact: "Jaegeuk Kim" <jaegeuk.kim@samsung.com>
|
||||
Description:
|
||||
Controls the directory level for large directory.
|
||||
|
||||
What: /sys/fs/f2fs/<disk>/ram_thresh
|
||||
Date: March 2014
|
||||
Contact: "Jaegeuk Kim" <jaegeuk.kim@samsung.com>
|
||||
Description:
|
||||
Controls the memory footprint used by f2fs.
|
||||
|
||||
What: /sys/fs/f2fs/<disk>/trim_sections
|
||||
Date: February 2015
|
||||
Contact: "Jaegeuk Kim" <jaegeuk@kernel.org>
|
||||
Description:
|
||||
Controls the trimming rate in batch mode.
|
||||
|
||||
What: /sys/fs/f2fs/<disk>/cp_interval
|
||||
Date: October 2015
|
||||
Contact: "Jaegeuk Kim" <jaegeuk@kernel.org>
|
||||
Description:
|
||||
Controls the checkpoint timing.
|
||||
|
||||
What: /sys/fs/f2fs/<disk>/idle_interval
|
||||
Date: January 2016
|
||||
Contact: "Jaegeuk Kim" <jaegeuk@kernel.org>
|
||||
Description:
|
||||
Controls the idle timing.
|
||||
|
||||
What: /sys/fs/f2fs/<disk>/ra_nid_pages
|
||||
Date: October 2015
|
||||
Contact: "Chao Yu" <chao2.yu@samsung.com>
|
||||
Description:
|
||||
Controls the count of nid pages to be readaheaded.
|
||||
|
||||
What: /sys/fs/f2fs/<disk>/dirty_nats_ratio
|
||||
Date: January 2016
|
||||
Contact: "Chao Yu" <chao2.yu@samsung.com>
|
||||
Description:
|
||||
Controls dirty nat entries ratio threshold, if current
|
||||
ratio exceeds configured threshold, checkpoint will
|
||||
be triggered for flushing dirty nat entries.
|
||||
|
||||
What: /sys/fs/f2fs/<disk>/lifetime_write_kbytes
|
||||
Date: January 2016
|
||||
Contact: "Shuoran Liu" <liushuoran@huawei.com>
|
||||
Description:
|
||||
Shows total written kbytes issued to disk.
|
|
@ -91,5 +91,5 @@ mpp61 61 gpo, dev(wen1), uart1(txd), audio(rclk)
|
|||
mpp62 62 gpio, dev(a2), uart1(cts), tdm(drx), pcie(clkreq0),
|
||||
audio(mclk), uart0(cts)
|
||||
mpp63 63 gpo, spi0(sck), tclk
|
||||
mpp64 64 gpio, spi0(miso), spi0-1(cs1)
|
||||
mpp65 65 gpio, spi0(mosi), spi0-1(cs2)
|
||||
mpp64 64 gpio, spi0(miso), spi0(cs1)
|
||||
mpp65 65 gpio, spi0(mosi), spi0(cs2)
|
||||
|
|
|
@ -41,15 +41,15 @@ mpp20 20 gpio, ge0(rxd4), ge1(rxd2), lcd(d20), ptp(clk)
|
|||
mpp21 21 gpio, ge0(rxd5), ge1(rxd3), lcd(d21), mem(bat)
|
||||
mpp22 22 gpio, ge0(rxd6), ge1(rxctl), lcd(d22), sata0(prsnt)
|
||||
mpp23 23 gpio, ge0(rxd7), ge1(rxclk), lcd(d23), sata1(prsnt)
|
||||
mpp24 24 gpio, lcd(hsync), sata1(prsnt), nf(bootcs-re), tdm(rst)
|
||||
mpp25 25 gpio, lcd(vsync), sata0(prsnt), nf(bootcs-we), tdm(pclk)
|
||||
mpp26 26 gpio, lcd(clk), tdm(fsync), vdd(cpu1-pd)
|
||||
mpp24 24 gpio, lcd(hsync), sata1(prsnt), tdm(rst)
|
||||
mpp25 25 gpio, lcd(vsync), sata0(prsnt), tdm(pclk)
|
||||
mpp26 26 gpio, lcd(clk), tdm(fsync)
|
||||
mpp27 27 gpio, lcd(e), tdm(dtx), ptp(trig)
|
||||
mpp28 28 gpio, lcd(pwm), tdm(drx), ptp(evreq)
|
||||
mpp29 29 gpio, lcd(ref-clk), tdm(int0), ptp(clk), vdd(cpu0-pd)
|
||||
mpp29 29 gpio, lcd(ref-clk), tdm(int0), ptp(clk)
|
||||
mpp30 30 gpio, tdm(int1), sd0(clk)
|
||||
mpp31 31 gpio, tdm(int2), sd0(cmd), vdd(cpu0-pd)
|
||||
mpp32 32 gpio, tdm(int3), sd0(d0), vdd(cpu1-pd)
|
||||
mpp31 31 gpio, tdm(int2), sd0(cmd)
|
||||
mpp32 32 gpio, tdm(int3), sd0(d0)
|
||||
mpp33 33 gpio, tdm(int4), sd0(d1), mem(bat)
|
||||
mpp34 34 gpio, tdm(int5), sd0(d2), sata0(prsnt)
|
||||
mpp35 35 gpio, tdm(int6), sd0(d3), sata1(prsnt)
|
||||
|
@ -57,21 +57,18 @@ mpp36 36 gpio, spi(mosi)
|
|||
mpp37 37 gpio, spi(miso)
|
||||
mpp38 38 gpio, spi(sck)
|
||||
mpp39 39 gpio, spi(cs0)
|
||||
mpp40 40 gpio, spi(cs1), uart2(cts), lcd(vga-hsync), vdd(cpu1-pd),
|
||||
pcie(clkreq0)
|
||||
mpp40 40 gpio, spi(cs1), uart2(cts), lcd(vga-hsync), pcie(clkreq0)
|
||||
mpp41 41 gpio, spi(cs2), uart2(rts), lcd(vga-vsync), sata1(prsnt),
|
||||
pcie(clkreq1)
|
||||
mpp42 42 gpio, uart2(rxd), uart0(cts), tdm(int7), tdm-1(timer),
|
||||
vdd(cpu0-pd)
|
||||
mpp43 43 gpio, uart2(txd), uart0(rts), spi(cs3), pcie(rstout),
|
||||
vdd(cpu2-3-pd){1}
|
||||
mpp42 42 gpio, uart2(rxd), uart0(cts), tdm(int7), tdm-1(timer)
|
||||
mpp43 43 gpio, uart2(txd), uart0(rts), spi(cs3), pcie(rstout)
|
||||
mpp44 44 gpio, uart2(cts), uart3(rxd), spi(cs4), pcie(clkreq2),
|
||||
mem(bat)
|
||||
mpp45 45 gpio, uart2(rts), uart3(txd), spi(cs5), sata1(prsnt)
|
||||
mpp46 46 gpio, uart3(rts), uart1(rts), spi(cs6), sata0(prsnt)
|
||||
mpp47 47 gpio, uart3(cts), uart1(cts), spi(cs7), pcie(clkreq3),
|
||||
ref(clkout)
|
||||
mpp48 48 gpio, tclk, dev(burst/last)
|
||||
mpp48 48 gpio, dev(clkout), dev(burst/last)
|
||||
|
||||
* Marvell Armada XP (mv78260 and mv78460 only)
|
||||
|
||||
|
@ -83,9 +80,9 @@ mpp51 51 gpio, dev(ad16)
|
|||
mpp52 52 gpio, dev(ad17)
|
||||
mpp53 53 gpio, dev(ad18)
|
||||
mpp54 54 gpio, dev(ad19)
|
||||
mpp55 55 gpio, dev(ad20), vdd(cpu0-pd)
|
||||
mpp56 56 gpio, dev(ad21), vdd(cpu1-pd)
|
||||
mpp57 57 gpio, dev(ad22), vdd(cpu2-3-pd){1}
|
||||
mpp55 55 gpio, dev(ad20)
|
||||
mpp56 56 gpio, dev(ad21)
|
||||
mpp57 57 gpio, dev(ad22)
|
||||
mpp58 58 gpio, dev(ad23)
|
||||
mpp59 59 gpio, dev(ad24)
|
||||
mpp60 60 gpio, dev(ad25)
|
||||
|
@ -95,6 +92,3 @@ mpp63 63 gpio, dev(ad28)
|
|||
mpp64 64 gpio, dev(ad29)
|
||||
mpp65 65 gpio, dev(ad30)
|
||||
mpp66 66 gpio, dev(ad31)
|
||||
|
||||
Notes:
|
||||
* {1} vdd(cpu2-3-pd) only available on mv78460.
|
||||
|
|
|
@ -4,9 +4,9 @@ Required properties:
|
|||
- compatible : "arm,pl022", "arm,primecell"
|
||||
- reg : Offset and length of the register set for the device
|
||||
- interrupts : Should contain SPI controller interrupt
|
||||
- num-cs : total number of chipselects
|
||||
|
||||
Optional properties:
|
||||
- num-cs : total number of chipselects
|
||||
- cs-gpios : should specify GPIOs used for chipselects.
|
||||
The gpios will be referred to as reg = <index> in the SPI child nodes.
|
||||
If unspecified, a single SPI device without a chip select can be used.
|
||||
|
|
|
@ -98,10 +98,20 @@ Cleaning Overhead
|
|||
MOUNT OPTIONS
|
||||
================================================================================
|
||||
|
||||
background_gc_off Turn off cleaning operations, namely garbage collection,
|
||||
triggered in background when I/O subsystem is idle.
|
||||
background_gc=%s Turn on/off cleaning operations, namely garbage
|
||||
collection, triggered in background when I/O subsystem is
|
||||
idle. If background_gc=on, it will turn on the garbage
|
||||
collection and if background_gc=off, garbage collection
|
||||
will be turned off. If background_gc=sync, it will turn
|
||||
on synchronous garbage collection running in background.
|
||||
Default value for this option is on. So garbage
|
||||
collection is on by default.
|
||||
disable_roll_forward Disable the roll-forward recovery routine
|
||||
discard Issue discard/TRIM commands when a segment is cleaned.
|
||||
norecovery Disable the roll-forward recovery routine, mounted read-
|
||||
only (i.e., -o ro,disable_roll_forward)
|
||||
discard/nodiscard Enable/disable real-time discard in f2fs, if discard is
|
||||
enabled, f2fs will issue discard/TRIM commands when a
|
||||
segment is cleaned.
|
||||
no_heap Disable heap-style segment allocation which finds free
|
||||
segments for data from the beginning of main area, while
|
||||
for node from the end of main area.
|
||||
|
@ -114,6 +124,42 @@ active_logs=%u Support configuring the number of active logs. In the
|
|||
Default number is 6.
|
||||
disable_ext_identify Disable the extension list configured by mkfs, so f2fs
|
||||
does not aware of cold files such as media files.
|
||||
inline_xattr Enable the inline xattrs feature.
|
||||
noinline_xattr Disable the inline xattrs feature.
|
||||
inline_data Enable the inline data feature: New created small(<~3.4k)
|
||||
files can be written into inode block.
|
||||
inline_dentry Enable the inline dir feature: data in new created
|
||||
directory entries can be written into inode block. The
|
||||
space of inode block which is used to store inline
|
||||
dentries is limited to ~3.4k.
|
||||
noinline_dentry Diable the inline dentry feature.
|
||||
flush_merge Merge concurrent cache_flush commands as much as possible
|
||||
to eliminate redundant command issues. If the underlying
|
||||
device handles the cache_flush command relatively slowly,
|
||||
recommend to enable this option.
|
||||
nobarrier This option can be used if underlying storage guarantees
|
||||
its cached data should be written to the novolatile area.
|
||||
If this option is set, no cache_flush commands are issued
|
||||
but f2fs still guarantees the write ordering of all the
|
||||
data writes.
|
||||
fastboot This option is used when a system wants to reduce mount
|
||||
time as much as possible, even though normal performance
|
||||
can be sacrificed.
|
||||
extent_cache Enable an extent cache based on rb-tree, it can cache
|
||||
as many as extent which map between contiguous logical
|
||||
address and physical address per inode, resulting in
|
||||
increasing the cache hit ratio. Set by default.
|
||||
noextent_cache Disable an extent cache based on rb-tree explicitly, see
|
||||
the above extent_cache mount option.
|
||||
noinline_data Disable the inline data feature, inline data feature is
|
||||
enabled by default.
|
||||
data_flush Enable data flushing before checkpoint in order to
|
||||
persist data of regular and symlink.
|
||||
mode=%s Control block allocation mode which supports "adaptive"
|
||||
and "lfs". In "lfs" mode, there should be no random
|
||||
writes towards main area.
|
||||
io_bits=%u Set the bit size of write IO requests. It should be set
|
||||
with "mode=lfs".
|
||||
|
||||
================================================================================
|
||||
DEBUGFS ENTRIES
|
||||
|
|
2
Makefile
2
Makefile
|
@ -1,6 +1,6 @@
|
|||
VERSION = 3
|
||||
PATCHLEVEL = 10
|
||||
SUBLEVEL = 84
|
||||
SUBLEVEL = 93
|
||||
EXTRAVERSION =
|
||||
NAME = TOSSUG Baby Fish
|
||||
|
||||
|
|
|
@ -25,10 +25,11 @@ __cmpxchg(volatile void *ptr, unsigned long expected, unsigned long new)
|
|||
" scond %3, [%1] \n"
|
||||
" bnz 1b \n"
|
||||
"2: \n"
|
||||
: "=&r"(prev)
|
||||
: "r"(ptr), "ir"(expected),
|
||||
"r"(new) /* can't be "ir". scond can't take limm for "b" */
|
||||
: "cc");
|
||||
: "=&r"(prev) /* Early clobber, to prevent reg reuse */
|
||||
: "r"(ptr), /* Not "m": llock only supports reg direct addr mode */
|
||||
"ir"(expected),
|
||||
"r"(new) /* can't be "ir". scond can't take LIMM for "b" */
|
||||
: "cc", "memory"); /* so that gcc knows memory is being written here */
|
||||
|
||||
return prev;
|
||||
}
|
||||
|
|
|
@ -83,7 +83,7 @@ struct callee_regs {
|
|||
long r13;
|
||||
};
|
||||
|
||||
#define instruction_pointer(regs) ((regs)->ret)
|
||||
#define instruction_pointer(regs) (unsigned long)((regs)->ret)
|
||||
#define profile_pc(regs) instruction_pointer(regs)
|
||||
|
||||
/* return 1 if user mode or 0 if kernel mode */
|
||||
|
|
|
@ -51,6 +51,14 @@ endif
|
|||
|
||||
comma = ,
|
||||
|
||||
#
|
||||
# The Scalar Replacement of Aggregates (SRA) optimization pass in GCC 4.9 and
|
||||
# later may result in code being generated that handles signed short and signed
|
||||
# char struct members incorrectly. So disable it.
|
||||
# (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=65932)
|
||||
#
|
||||
KBUILD_CFLAGS += $(call cc-option,-fno-ipa-sra)
|
||||
|
||||
# This selects which instruction set is used.
|
||||
# Note that GCC does not numerically define an architecture version
|
||||
# macro, but instead defines a whole series of macros which makes
|
||||
|
|
|
@ -358,7 +358,8 @@ ENDPROC(__pabt_svc)
|
|||
.endm
|
||||
|
||||
.macro kuser_cmpxchg_check
|
||||
#if !defined(CONFIG_CPU_32v6K) && !defined(CONFIG_NEEDS_SYSCALL_FOR_CMPXCHG)
|
||||
#if !defined(CONFIG_CPU_32v6K) && defined(CONFIG_KUSER_HELPERS) && \
|
||||
!defined(CONFIG_NEEDS_SYSCALL_FOR_CMPXCHG)
|
||||
#ifndef CONFIG_MMU
|
||||
#warning "NPTL on non MMU needs fixing"
|
||||
#else
|
||||
|
|
|
@ -56,6 +56,8 @@
|
|||
#define PAGE_OFFSET1 (PAGE_OFFSET + 0x10000000)
|
||||
#define PAGE_OFFSET2 (PAGE_OFFSET + 0x30000000)
|
||||
|
||||
#define PHYS_OFFSET PLAT_PHYS_OFFSET
|
||||
|
||||
#define __phys_to_virt(phys) \
|
||||
((phys) >= 0x80000000 ? (phys) - 0x80000000 + PAGE_OFFSET2 : \
|
||||
(phys) >= 0x20000000 ? (phys) - 0x20000000 + PAGE_OFFSET1 : \
|
||||
|
|
|
@ -111,6 +111,10 @@ config ILLEGAL_POINTER_VALUE
|
|||
config STACKTRACE_SUPPORT
|
||||
def_bool y
|
||||
|
||||
config ILLEGAL_POINTER_VALUE
|
||||
hex
|
||||
default 0xdead000000000000
|
||||
|
||||
config LOCKDEP_SUPPORT
|
||||
def_bool y
|
||||
|
||||
|
|
|
@ -539,6 +539,11 @@ CPU_LE( movk x0, #0x30d0, lsl #16 ) // Clear EE and E0E on LE systems
|
|||
msr hstr_el2, xzr // Disable CP15 traps to EL2
|
||||
#endif
|
||||
|
||||
/* EL2 debug */
|
||||
mrs x0, pmcr_el0 // Disable debug access traps
|
||||
ubfx x0, x0, #11, #5 // to EL2 and allow access to
|
||||
msr mdcr_el2, x0 // all PMU counters from EL1
|
||||
|
||||
/* Stage-2 translation */
|
||||
msr vttbr_el2, xzr
|
||||
|
||||
|
|
|
@ -168,7 +168,8 @@ int copy_siginfo_to_user32(compat_siginfo_t __user *to, const siginfo_t *from)
|
|||
* Other callers might not initialize the si_lsb field,
|
||||
* so check explicitely for the right codes here.
|
||||
*/
|
||||
if (from->si_code == BUS_MCEERR_AR || from->si_code == BUS_MCEERR_AO)
|
||||
if (from->si_signo == SIGBUS &&
|
||||
(from->si_code == BUS_MCEERR_AR || from->si_code == BUS_MCEERR_AO))
|
||||
err |= __put_user(from->si_addr_lsb, &to->si_addr_lsb);
|
||||
#endif
|
||||
break;
|
||||
|
@ -203,8 +204,6 @@ int copy_siginfo_to_user32(compat_siginfo_t __user *to, const siginfo_t *from)
|
|||
|
||||
int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
|
||||
{
|
||||
memset(to, 0, sizeof *to);
|
||||
|
||||
if (copy_from_user(to, from, __ARCH_SI_PREAMBLE_SIZE) ||
|
||||
copy_from_user(to->_sifields._pad,
|
||||
from->_sifields._pad, SI_PAD_SIZE))
|
||||
|
@ -215,14 +214,32 @@ int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
|
|||
|
||||
/*
|
||||
* VFP save/restore code.
|
||||
*
|
||||
* We have to be careful with endianness, since the fpsimd context-switch
|
||||
* code operates on 128-bit (Q) register values whereas the compat ABI
|
||||
* uses an array of 64-bit (D) registers. Consequently, we need to swap
|
||||
* the two halves of each Q register when running on a big-endian CPU.
|
||||
*/
|
||||
union __fpsimd_vreg {
|
||||
__uint128_t raw;
|
||||
struct {
|
||||
#ifdef __AARCH64EB__
|
||||
u64 hi;
|
||||
u64 lo;
|
||||
#else
|
||||
u64 lo;
|
||||
u64 hi;
|
||||
#endif
|
||||
};
|
||||
};
|
||||
|
||||
static int compat_preserve_vfp_context(struct compat_vfp_sigframe __user *frame)
|
||||
{
|
||||
struct fpsimd_state *fpsimd = ¤t->thread.fpsimd_state;
|
||||
compat_ulong_t magic = VFP_MAGIC;
|
||||
compat_ulong_t size = VFP_STORAGE_SIZE;
|
||||
compat_ulong_t fpscr, fpexc;
|
||||
int err = 0;
|
||||
int i, err = 0;
|
||||
|
||||
/*
|
||||
* Save the hardware registers to the fpsimd_state structure.
|
||||
|
@ -238,10 +255,15 @@ static int compat_preserve_vfp_context(struct compat_vfp_sigframe __user *frame)
|
|||
/*
|
||||
* Now copy the FP registers. Since the registers are packed,
|
||||
* we can copy the prefix we want (V0-V15) as it is.
|
||||
* FIXME: Won't work if big endian.
|
||||
*/
|
||||
err |= __copy_to_user(&frame->ufp.fpregs, fpsimd->vregs,
|
||||
sizeof(frame->ufp.fpregs));
|
||||
for (i = 0; i < ARRAY_SIZE(frame->ufp.fpregs); i += 2) {
|
||||
union __fpsimd_vreg vreg = {
|
||||
.raw = fpsimd->vregs[i >> 1],
|
||||
};
|
||||
|
||||
__put_user_error(vreg.lo, &frame->ufp.fpregs[i], err);
|
||||
__put_user_error(vreg.hi, &frame->ufp.fpregs[i + 1], err);
|
||||
}
|
||||
|
||||
/* Create an AArch32 fpscr from the fpsr and the fpcr. */
|
||||
fpscr = (fpsimd->fpsr & VFP_FPSCR_STAT_MASK) |
|
||||
|
@ -266,7 +288,7 @@ static int compat_restore_vfp_context(struct compat_vfp_sigframe __user *frame)
|
|||
compat_ulong_t magic = VFP_MAGIC;
|
||||
compat_ulong_t size = VFP_STORAGE_SIZE;
|
||||
compat_ulong_t fpscr;
|
||||
int err = 0;
|
||||
int i, err = 0;
|
||||
|
||||
__get_user_error(magic, &frame->magic, err);
|
||||
__get_user_error(size, &frame->size, err);
|
||||
|
@ -276,12 +298,14 @@ static int compat_restore_vfp_context(struct compat_vfp_sigframe __user *frame)
|
|||
if (magic != VFP_MAGIC || size != VFP_STORAGE_SIZE)
|
||||
return -EINVAL;
|
||||
|
||||
/*
|
||||
* Copy the FP registers into the start of the fpsimd_state.
|
||||
* FIXME: Won't work if big endian.
|
||||
*/
|
||||
err |= __copy_from_user(fpsimd.vregs, frame->ufp.fpregs,
|
||||
sizeof(frame->ufp.fpregs));
|
||||
/* Copy the FP registers into the start of the fpsimd_state. */
|
||||
for (i = 0; i < ARRAY_SIZE(frame->ufp.fpregs); i += 2) {
|
||||
union __fpsimd_vreg vreg;
|
||||
|
||||
__get_user_error(vreg.lo, &frame->ufp.fpregs[i], err);
|
||||
__get_user_error(vreg.hi, &frame->ufp.fpregs[i + 1], err);
|
||||
fpsimd.vregs[i >> 1] = vreg.raw;
|
||||
}
|
||||
|
||||
/* Extract the fpsr and the fpcr from the fpscr */
|
||||
__get_user_error(fpscr, &frame->ufp.fpscr, err);
|
||||
|
|
|
@ -48,11 +48,7 @@ int notrace unwind_frame(struct stackframe *frame)
|
|||
|
||||
frame->sp = fp + 0x10;
|
||||
frame->fp = *(unsigned long *)(fp);
|
||||
/*
|
||||
* -4 here because we care about the PC at time of bl,
|
||||
* not where the return will go.
|
||||
*/
|
||||
frame->pc = *(unsigned long *)(fp + 8) - 4;
|
||||
frame->pc = *(unsigned long *)(fp + 8);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -15,6 +15,10 @@ ccflags-y := -shared -fno-common -fno-builtin
|
|||
ccflags-y += -nostdlib -Wl,-soname=linux-vdso.so.1 \
|
||||
$(call cc-ldoption, -Wl$(comma)--hash-style=sysv)
|
||||
|
||||
# Workaround for bare-metal (ELF) toolchains that neglect to pass -shared
|
||||
# down to collect2, resulting in silent corruption of the vDSO image.
|
||||
ccflags-y += -Wl,-shared
|
||||
|
||||
obj-y += vdso.o
|
||||
extra-y += vdso.lds vdso-offsets.h
|
||||
CPPFLAGS_vdso.lds += -P -C -U$(ARCH)
|
||||
|
|
|
@ -92,6 +92,14 @@ static void reset_context(void *info)
|
|||
unsigned int cpu = smp_processor_id();
|
||||
struct mm_struct *mm = current->active_mm;
|
||||
|
||||
/*
|
||||
* current->active_mm could be init_mm for the idle thread immediately
|
||||
* after secondary CPU boot or hotplug. TTBR0_EL1 is already set to
|
||||
* the reserved value, so no need to reset any context.
|
||||
*/
|
||||
if (mm == &init_mm)
|
||||
return;
|
||||
|
||||
smp_rmb();
|
||||
asid = cpu_last_asid + cpu;
|
||||
|
||||
|
|
|
@ -254,7 +254,7 @@ static void __init free_unused_memmap(void)
|
|||
* memmap entries are valid from the bank end aligned to
|
||||
* MAX_ORDER_NR_PAGES.
|
||||
*/
|
||||
prev_end = ALIGN(start + __phys_to_pfn(reg->size),
|
||||
prev_end = ALIGN(__phys_to_pfn(reg->base + reg->size),
|
||||
MAX_ORDER_NR_PAGES);
|
||||
}
|
||||
|
||||
|
|
|
@ -4,4 +4,34 @@
|
|||
#define __ALIGN .align 4
|
||||
#define __ALIGN_STR ".align 4"
|
||||
|
||||
/*
|
||||
* Make sure the compiler doesn't do anything stupid with the
|
||||
* arguments on the stack - they are owned by the *caller*, not
|
||||
* the callee. This just fools gcc into not spilling into them,
|
||||
* and keeps it from doing tailcall recursion and/or using the
|
||||
* stack slots for temporaries, since they are live and "used"
|
||||
* all the way to the end of the function.
|
||||
*/
|
||||
#define asmlinkage_protect(n, ret, args...) \
|
||||
__asmlinkage_protect##n(ret, ##args)
|
||||
#define __asmlinkage_protect_n(ret, args...) \
|
||||
__asm__ __volatile__ ("" : "=r" (ret) : "0" (ret), ##args)
|
||||
#define __asmlinkage_protect0(ret) \
|
||||
__asmlinkage_protect_n(ret)
|
||||
#define __asmlinkage_protect1(ret, arg1) \
|
||||
__asmlinkage_protect_n(ret, "m" (arg1))
|
||||
#define __asmlinkage_protect2(ret, arg1, arg2) \
|
||||
__asmlinkage_protect_n(ret, "m" (arg1), "m" (arg2))
|
||||
#define __asmlinkage_protect3(ret, arg1, arg2, arg3) \
|
||||
__asmlinkage_protect_n(ret, "m" (arg1), "m" (arg2), "m" (arg3))
|
||||
#define __asmlinkage_protect4(ret, arg1, arg2, arg3, arg4) \
|
||||
__asmlinkage_protect_n(ret, "m" (arg1), "m" (arg2), "m" (arg3), \
|
||||
"m" (arg4))
|
||||
#define __asmlinkage_protect5(ret, arg1, arg2, arg3, arg4, arg5) \
|
||||
__asmlinkage_protect_n(ret, "m" (arg1), "m" (arg2), "m" (arg3), \
|
||||
"m" (arg4), "m" (arg5))
|
||||
#define __asmlinkage_protect6(ret, arg1, arg2, arg3, arg4, arg5, arg6) \
|
||||
__asmlinkage_protect_n(ret, "m" (arg1), "m" (arg2), "m" (arg3), \
|
||||
"m" (arg4), "m" (arg5), "m" (arg6))
|
||||
|
||||
#endif
|
||||
|
|
|
@ -90,7 +90,7 @@ asm volatile ("\n" \
|
|||
__put_user_asm(__pu_err, __pu_val, ptr, b, d, -EFAULT); \
|
||||
break; \
|
||||
case 2: \
|
||||
__put_user_asm(__pu_err, __pu_val, ptr, w, d, -EFAULT); \
|
||||
__put_user_asm(__pu_err, __pu_val, ptr, w, r, -EFAULT); \
|
||||
break; \
|
||||
case 4: \
|
||||
__put_user_asm(__pu_err, __pu_val, ptr, l, r, -EFAULT); \
|
||||
|
@ -158,7 +158,7 @@ asm volatile ("\n" \
|
|||
__get_user_asm(__gu_err, x, ptr, u8, b, d, -EFAULT); \
|
||||
break; \
|
||||
case 2: \
|
||||
__get_user_asm(__gu_err, x, ptr, u16, w, d, -EFAULT); \
|
||||
__get_user_asm(__gu_err, x, ptr, u16, w, r, -EFAULT); \
|
||||
break; \
|
||||
case 4: \
|
||||
__get_user_asm(__gu_err, x, ptr, u32, l, r, -EFAULT); \
|
||||
|
@ -245,7 +245,7 @@ __constant_copy_from_user(void *to, const void __user *from, unsigned long n)
|
|||
__get_user_asm(res, *(u8 *)to, (u8 __user *)from, u8, b, d, 1);
|
||||
break;
|
||||
case 2:
|
||||
__get_user_asm(res, *(u16 *)to, (u16 __user *)from, u16, w, d, 2);
|
||||
__get_user_asm(res, *(u16 *)to, (u16 __user *)from, u16, w, r, 2);
|
||||
break;
|
||||
case 3:
|
||||
__constant_copy_from_user_asm(res, to, from, tmp, 3, w, b,);
|
||||
|
@ -326,7 +326,7 @@ __constant_copy_to_user(void __user *to, const void *from, unsigned long n)
|
|||
__put_user_asm(res, *(u8 *)from, (u8 __user *)to, b, d, 1);
|
||||
break;
|
||||
case 2:
|
||||
__put_user_asm(res, *(u16 *)from, (u16 __user *)to, w, d, 2);
|
||||
__put_user_asm(res, *(u16 *)from, (u16 __user *)to, w, r, 2);
|
||||
break;
|
||||
case 3:
|
||||
__constant_copy_to_user_asm(res, to, from, tmp, 3, w, b,);
|
||||
|
|
|
@ -52,7 +52,7 @@ unsigned long __generic_copy_from_user(void *to, const void __user *from,
|
|||
" .long 3b,30b\n"
|
||||
" .long 5b,50b\n"
|
||||
" .previous"
|
||||
: "=d" (res), "+a" (from), "+a" (to), "=&r" (tmp)
|
||||
: "=d" (res), "+a" (from), "+a" (to), "=&d" (tmp)
|
||||
: "0" (n / 4), "d" (n & 3));
|
||||
|
||||
return res;
|
||||
|
@ -96,7 +96,7 @@ unsigned long __generic_copy_to_user(void __user *to, const void *from,
|
|||
" .long 7b,50b\n"
|
||||
" .long 8b,50b\n"
|
||||
" .previous"
|
||||
: "=d" (res), "+a" (from), "+a" (to), "=&r" (tmp)
|
||||
: "=d" (res), "+a" (from), "+a" (to), "=&d" (tmp)
|
||||
: "0" (n / 4), "d" (n & 3));
|
||||
|
||||
return res;
|
||||
|
@ -141,7 +141,7 @@ unsigned long __clear_user(void __user *to, unsigned long n)
|
|||
" .long 7b,40b\n"
|
||||
" .previous"
|
||||
: "=d" (res), "+a" (to)
|
||||
: "r" (0), "0" (n / 4), "d" (n & 3));
|
||||
: "d" (0), "0" (n / 4), "d" (n & 3));
|
||||
|
||||
return res;
|
||||
}
|
||||
|
|
|
@ -150,8 +150,39 @@ static inline void set_pte(pte_t *ptep, pte_t pteval)
|
|||
* Make sure the buddy is global too (if it's !none,
|
||||
* it better already be global)
|
||||
*/
|
||||
#ifdef CONFIG_SMP
|
||||
/*
|
||||
* For SMP, multiple CPUs can race, so we need to do
|
||||
* this atomically.
|
||||
*/
|
||||
#ifdef CONFIG_64BIT
|
||||
#define LL_INSN "lld"
|
||||
#define SC_INSN "scd"
|
||||
#else /* CONFIG_32BIT */
|
||||
#define LL_INSN "ll"
|
||||
#define SC_INSN "sc"
|
||||
#endif
|
||||
unsigned long page_global = _PAGE_GLOBAL;
|
||||
unsigned long tmp;
|
||||
|
||||
__asm__ __volatile__ (
|
||||
" .set push\n"
|
||||
" .set noreorder\n"
|
||||
"1: " LL_INSN " %[tmp], %[buddy]\n"
|
||||
" bnez %[tmp], 2f\n"
|
||||
" or %[tmp], %[tmp], %[global]\n"
|
||||
" " SC_INSN " %[tmp], %[buddy]\n"
|
||||
" beqz %[tmp], 1b\n"
|
||||
" nop\n"
|
||||
"2:\n"
|
||||
" .set pop"
|
||||
: [buddy] "+m" (buddy->pte),
|
||||
[tmp] "=&r" (tmp)
|
||||
: [global] "r" (page_global));
|
||||
#else /* !CONFIG_SMP */
|
||||
if (pte_none(*buddy))
|
||||
pte_val(*buddy) = pte_val(*buddy) | _PAGE_GLOBAL;
|
||||
#endif /* CONFIG_SMP */
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
|
|
@ -154,7 +154,7 @@ asmlinkage long mipsmt_sys_sched_getaffinity(pid_t pid, unsigned int len,
|
|||
unsigned long __user *user_mask_ptr)
|
||||
{
|
||||
unsigned int real_len;
|
||||
cpumask_t mask;
|
||||
cpumask_t allowed, mask;
|
||||
int retval;
|
||||
struct task_struct *p;
|
||||
|
||||
|
@ -173,7 +173,8 @@ asmlinkage long mipsmt_sys_sched_getaffinity(pid_t pid, unsigned int len,
|
|||
if (retval)
|
||||
goto out_unlock;
|
||||
|
||||
cpumask_and(&mask, &p->thread.user_cpus_allowed, cpu_possible_mask);
|
||||
cpumask_or(&allowed, &p->thread.user_cpus_allowed, &p->cpus_allowed);
|
||||
cpumask_and(&mask, &allowed, cpu_active_mask);
|
||||
|
||||
out_unlock:
|
||||
read_unlock(&tasklist_lock);
|
||||
|
|
|
@ -368,8 +368,6 @@ int copy_siginfo_to_user32(compat_siginfo_t __user *to, const siginfo_t *from)
|
|||
|
||||
int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
|
||||
{
|
||||
memset(to, 0, sizeof *to);
|
||||
|
||||
if (copy_from_user(to, from, 3*sizeof(int)) ||
|
||||
copy_from_user(to->_sifields._pad,
|
||||
from->_sifields._pad, SI_PAD_SIZE32))
|
||||
|
|
|
@ -1626,7 +1626,7 @@ kvm_mips_complete_mmio_load(struct kvm_vcpu *vcpu, struct kvm_run *run)
|
|||
if (vcpu->mmio_needed == 2)
|
||||
*gpr = *(int16_t *) run->mmio.data;
|
||||
else
|
||||
*gpr = *(int16_t *) run->mmio.data;
|
||||
*gpr = *(uint16_t *)run->mmio.data;
|
||||
|
||||
break;
|
||||
case 1:
|
||||
|
|
|
@ -91,7 +91,7 @@ static gfp_t massage_gfp_flags(const struct device *dev, gfp_t gfp)
|
|||
else
|
||||
#endif
|
||||
#if defined(CONFIG_ZONE_DMA) && !defined(CONFIG_ZONE_DMA32)
|
||||
if (dev->coherent_dma_mask < DMA_BIT_MASK(64))
|
||||
if (dev->coherent_dma_mask < DMA_BIT_MASK(sizeof(phys_addr_t) * 8))
|
||||
dma_flag = __GFP_DMA;
|
||||
else
|
||||
#endif
|
||||
|
|
|
@ -524,8 +524,8 @@ void do_cpu_irq_mask(struct pt_regs *regs)
|
|||
struct pt_regs *old_regs;
|
||||
unsigned long eirr_val;
|
||||
int irq, cpu = smp_processor_id();
|
||||
#ifdef CONFIG_SMP
|
||||
struct irq_desc *desc;
|
||||
#ifdef CONFIG_SMP
|
||||
cpumask_t dest;
|
||||
#endif
|
||||
|
||||
|
@ -538,8 +538,12 @@ void do_cpu_irq_mask(struct pt_regs *regs)
|
|||
goto set_out;
|
||||
irq = eirr_to_irq(eirr_val);
|
||||
|
||||
#ifdef CONFIG_SMP
|
||||
/* Filter out spurious interrupts, mostly from serial port at bootup */
|
||||
desc = irq_to_desc(irq);
|
||||
if (unlikely(!desc->action))
|
||||
goto set_out;
|
||||
|
||||
#ifdef CONFIG_SMP
|
||||
cpumask_copy(&dest, desc->irq_data.affinity);
|
||||
if (irqd_is_per_cpu(&desc->irq_data) &&
|
||||
!cpu_isset(smp_processor_id(), dest)) {
|
||||
|
|
|
@ -130,7 +130,19 @@
|
|||
#define pte_iterate_hashed_end() } while(0)
|
||||
|
||||
#ifdef CONFIG_PPC_HAS_HASH_64K
|
||||
#define pte_pagesize_index(mm, addr, pte) get_slice_psize(mm, addr)
|
||||
/*
|
||||
* We expect this to be called only for user addresses or kernel virtual
|
||||
* addresses other than the linear mapping.
|
||||
*/
|
||||
#define pte_pagesize_index(mm, addr, pte) \
|
||||
({ \
|
||||
unsigned int psize; \
|
||||
if (is_kernel_addr(addr)) \
|
||||
psize = MMU_PAGE_4K; \
|
||||
else \
|
||||
psize = get_slice_psize(mm, addr); \
|
||||
psize; \
|
||||
})
|
||||
#else
|
||||
#define pte_pagesize_index(mm, addr, pte) MMU_PAGE_4K
|
||||
#endif
|
||||
|
|
|
@ -255,6 +255,7 @@ extern void rtas_power_off(void);
|
|||
extern void rtas_halt(void);
|
||||
extern void rtas_os_term(char *str);
|
||||
extern int rtas_get_sensor(int sensor, int index, int *state);
|
||||
extern int rtas_get_sensor_fast(int sensor, int index, int *state);
|
||||
extern int rtas_get_power_level(int powerdomain, int *level);
|
||||
extern int rtas_set_power_level(int powerdomain, int level, int *setlevel);
|
||||
extern bool rtas_indicator_present(int token, int *maxindex);
|
||||
|
|
|
@ -584,6 +584,23 @@ int rtas_get_sensor(int sensor, int index, int *state)
|
|||
}
|
||||
EXPORT_SYMBOL(rtas_get_sensor);
|
||||
|
||||
int rtas_get_sensor_fast(int sensor, int index, int *state)
|
||||
{
|
||||
int token = rtas_token("get-sensor-state");
|
||||
int rc;
|
||||
|
||||
if (token == RTAS_UNKNOWN_SERVICE)
|
||||
return -ENOENT;
|
||||
|
||||
rc = rtas_call(token, 2, 2, state, sensor, index);
|
||||
WARN_ON(rc == RTAS_BUSY || (rc >= RTAS_EXTENDED_DELAY_MIN &&
|
||||
rc <= RTAS_EXTENDED_DELAY_MAX));
|
||||
|
||||
if (rc < 0)
|
||||
return rtas_error_rc(rc);
|
||||
return rc;
|
||||
}
|
||||
|
||||
bool rtas_indicator_present(int token, int *maxindex)
|
||||
{
|
||||
int proplen, count, i;
|
||||
|
@ -1024,6 +1041,9 @@ asmlinkage int ppc_rtas(struct rtas_args __user *uargs)
|
|||
if (!capable(CAP_SYS_ADMIN))
|
||||
return -EPERM;
|
||||
|
||||
if (!rtas.entry)
|
||||
return -EINVAL;
|
||||
|
||||
if (copy_from_user(&args, uargs, 3 * sizeof(u32)) != 0)
|
||||
return -EFAULT;
|
||||
|
||||
|
|
|
@ -949,8 +949,6 @@ int copy_siginfo_to_user32(struct compat_siginfo __user *d, const siginfo_t *s)
|
|||
|
||||
int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from)
|
||||
{
|
||||
memset(to, 0, sizeof *to);
|
||||
|
||||
if (copy_from_user(to, from, 3*sizeof(int)) ||
|
||||
copy_from_user(to->_sifields._pad,
|
||||
from->_sifields._pad, SI_PAD_SIZE32))
|
||||
|
|
|
@ -106,6 +106,7 @@ static void pnv_teardown_msi_irqs(struct pci_dev *pdev)
|
|||
struct pci_controller *hose = pci_bus_to_host(pdev->bus);
|
||||
struct pnv_phb *phb = hose->private_data;
|
||||
struct msi_desc *entry;
|
||||
irq_hw_number_t hwirq;
|
||||
|
||||
if (WARN_ON(!phb))
|
||||
return;
|
||||
|
@ -113,10 +114,10 @@ static void pnv_teardown_msi_irqs(struct pci_dev *pdev)
|
|||
list_for_each_entry(entry, &pdev->msi_list, list) {
|
||||
if (entry->irq == NO_IRQ)
|
||||
continue;
|
||||
hwirq = virq_to_hw(entry->irq);
|
||||
irq_set_msi_desc(entry->irq, NULL);
|
||||
msi_bitmap_free_hwirqs(&phb->msi_bmp,
|
||||
virq_to_hw(entry->irq) - phb->msi_base, 1);
|
||||
irq_dispose_mapping(entry->irq);
|
||||
msi_bitmap_free_hwirqs(&phb->msi_bmp, hwirq - phb->msi_base, 1);
|
||||
}
|
||||
}
|
||||
#endif /* CONFIG_PCI_MSI */
|
||||
|
|
|
@ -187,7 +187,8 @@ static irqreturn_t ras_epow_interrupt(int irq, void *dev_id)
|
|||
int state;
|
||||
int critical;
|
||||
|
||||
status = rtas_get_sensor(EPOW_SENSOR_TOKEN, EPOW_SENSOR_INDEX, &state);
|
||||
status = rtas_get_sensor_fast(EPOW_SENSOR_TOKEN, EPOW_SENSOR_INDEX,
|
||||
&state);
|
||||
|
||||
if (state > 3)
|
||||
critical = 1; /* Time Critical */
|
||||
|
|
|
@ -108,15 +108,16 @@ static void fsl_teardown_msi_irqs(struct pci_dev *pdev)
|
|||
{
|
||||
struct msi_desc *entry;
|
||||
struct fsl_msi *msi_data;
|
||||
irq_hw_number_t hwirq;
|
||||
|
||||
list_for_each_entry(entry, &pdev->msi_list, list) {
|
||||
if (entry->irq == NO_IRQ)
|
||||
continue;
|
||||
hwirq = virq_to_hw(entry->irq);
|
||||
msi_data = irq_get_chip_data(entry->irq);
|
||||
irq_set_msi_desc(entry->irq, NULL);
|
||||
msi_bitmap_free_hwirqs(&msi_data->bitmap,
|
||||
virq_to_hw(entry->irq), 1);
|
||||
irq_dispose_mapping(entry->irq);
|
||||
msi_bitmap_free_hwirqs(&msi_data->bitmap, hwirq, 1);
|
||||
}
|
||||
|
||||
return;
|
||||
|
|
|
@ -74,6 +74,7 @@ static int pasemi_msi_check_device(struct pci_dev *pdev, int nvec, int type)
|
|||
static void pasemi_msi_teardown_msi_irqs(struct pci_dev *pdev)
|
||||
{
|
||||
struct msi_desc *entry;
|
||||
irq_hw_number_t hwirq;
|
||||
|
||||
pr_debug("pasemi_msi_teardown_msi_irqs, pdev %p\n", pdev);
|
||||
|
||||
|
@ -81,10 +82,11 @@ static void pasemi_msi_teardown_msi_irqs(struct pci_dev *pdev)
|
|||
if (entry->irq == NO_IRQ)
|
||||
continue;
|
||||
|
||||
hwirq = virq_to_hw(entry->irq);
|
||||
irq_set_msi_desc(entry->irq, NULL);
|
||||
msi_bitmap_free_hwirqs(&msi_mpic->msi_bitmap,
|
||||
virq_to_hw(entry->irq), ALLOC_CHUNK);
|
||||
irq_dispose_mapping(entry->irq);
|
||||
msi_bitmap_free_hwirqs(&msi_mpic->msi_bitmap,
|
||||
hwirq, ALLOC_CHUNK);
|
||||
}
|
||||
|
||||
return;
|
||||
|
|
|
@ -124,15 +124,16 @@ static int u3msi_msi_check_device(struct pci_dev *pdev, int nvec, int type)
|
|||
static void u3msi_teardown_msi_irqs(struct pci_dev *pdev)
|
||||
{
|
||||
struct msi_desc *entry;
|
||||
irq_hw_number_t hwirq;
|
||||
|
||||
list_for_each_entry(entry, &pdev->msi_list, list) {
|
||||
if (entry->irq == NO_IRQ)
|
||||
continue;
|
||||
|
||||
hwirq = virq_to_hw(entry->irq);
|
||||
irq_set_msi_desc(entry->irq, NULL);
|
||||
msi_bitmap_free_hwirqs(&msi_mpic->msi_bitmap,
|
||||
virq_to_hw(entry->irq), 1);
|
||||
irq_dispose_mapping(entry->irq);
|
||||
msi_bitmap_free_hwirqs(&msi_mpic->msi_bitmap, hwirq, 1);
|
||||
}
|
||||
|
||||
return;
|
||||
|
|
|
@ -121,16 +121,17 @@ void ppc4xx_teardown_msi_irqs(struct pci_dev *dev)
|
|||
{
|
||||
struct msi_desc *entry;
|
||||
struct ppc4xx_msi *msi_data = &ppc4xx_msi;
|
||||
irq_hw_number_t hwirq;
|
||||
|
||||
dev_dbg(&dev->dev, "PCIE-MSI: tearing down msi irqs\n");
|
||||
|
||||
list_for_each_entry(entry, &dev->msi_list, list) {
|
||||
if (entry->irq == NO_IRQ)
|
||||
continue;
|
||||
hwirq = virq_to_hw(entry->irq);
|
||||
irq_set_msi_desc(entry->irq, NULL);
|
||||
msi_bitmap_free_hwirqs(&msi_data->bitmap,
|
||||
virq_to_hw(entry->irq), 1);
|
||||
irq_dispose_mapping(entry->irq);
|
||||
msi_bitmap_free_hwirqs(&msi_data->bitmap, hwirq, 1);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -276,6 +276,8 @@ ENTRY(_sclp_print_early)
|
|||
jno .Lesa2
|
||||
ahi %r15,-80
|
||||
stmh %r6,%r15,96(%r15) # store upper register halves
|
||||
basr %r13,0
|
||||
lmh %r0,%r15,.Lzeroes-.(%r13) # clear upper register halves
|
||||
.Lesa2:
|
||||
#endif
|
||||
lr %r10,%r2 # save string pointer
|
||||
|
@ -299,6 +301,8 @@ ENTRY(_sclp_print_early)
|
|||
#endif
|
||||
lm %r6,%r15,120(%r15) # restore registers
|
||||
br %r14
|
||||
.Lzeroes:
|
||||
.fill 64,4,0
|
||||
|
||||
.LwritedataS4:
|
||||
.long 0x00760005 # SCLP command for write data
|
||||
|
|
|
@ -433,6 +433,7 @@ static struct crypto_alg algs[] = { {
|
|||
.blkcipher = {
|
||||
.min_keysize = AES_MIN_KEY_SIZE,
|
||||
.max_keysize = AES_MAX_KEY_SIZE,
|
||||
.ivsize = AES_BLOCK_SIZE,
|
||||
.setkey = aes_set_key,
|
||||
.encrypt = cbc_encrypt,
|
||||
.decrypt = cbc_decrypt,
|
||||
|
@ -452,6 +453,7 @@ static struct crypto_alg algs[] = { {
|
|||
.blkcipher = {
|
||||
.min_keysize = AES_MIN_KEY_SIZE,
|
||||
.max_keysize = AES_MAX_KEY_SIZE,
|
||||
.ivsize = AES_BLOCK_SIZE,
|
||||
.setkey = aes_set_key,
|
||||
.encrypt = ctr_crypt,
|
||||
.decrypt = ctr_crypt,
|
||||
|
|
|
@ -274,6 +274,7 @@ static struct crypto_alg algs[] = { {
|
|||
.blkcipher = {
|
||||
.min_keysize = CAMELLIA_MIN_KEY_SIZE,
|
||||
.max_keysize = CAMELLIA_MAX_KEY_SIZE,
|
||||
.ivsize = CAMELLIA_BLOCK_SIZE,
|
||||
.setkey = camellia_set_key,
|
||||
.encrypt = cbc_encrypt,
|
||||
.decrypt = cbc_decrypt,
|
||||
|
|
|
@ -429,6 +429,7 @@ static struct crypto_alg algs[] = { {
|
|||
.blkcipher = {
|
||||
.min_keysize = DES_KEY_SIZE,
|
||||
.max_keysize = DES_KEY_SIZE,
|
||||
.ivsize = DES_BLOCK_SIZE,
|
||||
.setkey = des_set_key,
|
||||
.encrypt = cbc_encrypt,
|
||||
.decrypt = cbc_decrypt,
|
||||
|
@ -485,6 +486,7 @@ static struct crypto_alg algs[] = { {
|
|||
.blkcipher = {
|
||||
.min_keysize = DES3_EDE_KEY_SIZE,
|
||||
.max_keysize = DES3_EDE_KEY_SIZE,
|
||||
.ivsize = DES3_EDE_BLOCK_SIZE,
|
||||
.setkey = des3_ede_set_key,
|
||||
.encrypt = cbc3_encrypt,
|
||||
.decrypt = cbc3_decrypt,
|
||||
|
|
|
@ -28,18 +28,20 @@
|
|||
* Must preserve %o5 between VISEntryHalf and VISExitHalf */
|
||||
|
||||
#define VISEntryHalf \
|
||||
VISEntry
|
||||
|
||||
#define VISExitHalf \
|
||||
VISExit
|
||||
|
||||
#define VISEntryHalfFast(fail_label) \
|
||||
rd %fprs, %o5; \
|
||||
andcc %o5, FPRS_FEF, %g0; \
|
||||
be,pt %icc, 297f; \
|
||||
sethi %hi(298f), %g7; \
|
||||
sethi %hi(VISenterhalf), %g1; \
|
||||
jmpl %g1 + %lo(VISenterhalf), %g0; \
|
||||
or %g7, %lo(298f), %g7; \
|
||||
clr %o5; \
|
||||
297: wr %o5, FPRS_FEF, %fprs; \
|
||||
298:
|
||||
nop; \
|
||||
ba,a,pt %xcc, fail_label; \
|
||||
297: wr %o5, FPRS_FEF, %fprs;
|
||||
|
||||
#define VISExitHalf \
|
||||
#define VISExitHalfFast \
|
||||
wr %o5, 0, %fprs;
|
||||
|
||||
#ifndef __ASSEMBLY__
|
||||
|
|
|
@ -41,6 +41,10 @@
|
|||
#endif
|
||||
#endif
|
||||
|
||||
#if !defined(EX_LD) && !defined(EX_ST)
|
||||
#define NON_USER_COPY
|
||||
#endif
|
||||
|
||||
#ifndef EX_LD
|
||||
#define EX_LD(x) x
|
||||
#endif
|
||||
|
@ -197,9 +201,13 @@ FUNC_NAME: /* %o0=dst, %o1=src, %o2=len */
|
|||
mov EX_RETVAL(%o3), %o0
|
||||
|
||||
.Llarge_src_unaligned:
|
||||
#ifdef NON_USER_COPY
|
||||
VISEntryHalfFast(.Lmedium_vis_entry_fail)
|
||||
#else
|
||||
VISEntryHalf
|
||||
#endif
|
||||
andn %o2, 0x3f, %o4
|
||||
sub %o2, %o4, %o2
|
||||
VISEntryHalf
|
||||
alignaddr %o1, %g0, %g1
|
||||
add %o1, %o4, %o1
|
||||
EX_LD(LOAD(ldd, %g1 + 0x00, %f0))
|
||||
|
@ -232,14 +240,21 @@ FUNC_NAME: /* %o0=dst, %o1=src, %o2=len */
|
|||
add %o0, 0x40, %o0
|
||||
bne,pt %icc, 1b
|
||||
LOAD(prefetch, %g1 + 0x200, #n_reads_strong)
|
||||
#ifdef NON_USER_COPY
|
||||
VISExitHalfFast
|
||||
#else
|
||||
VISExitHalf
|
||||
|
||||
#endif
|
||||
brz,pn %o2, .Lexit
|
||||
cmp %o2, 19
|
||||
ble,pn %icc, .Lsmall_unaligned
|
||||
nop
|
||||
ba,a,pt %icc, .Lmedium_unaligned
|
||||
|
||||
#ifdef NON_USER_COPY
|
||||
.Lmedium_vis_entry_fail:
|
||||
or %o0, %o1, %g2
|
||||
#endif
|
||||
.Lmedium:
|
||||
LOAD(prefetch, %o1 + 0x40, #n_reads_strong)
|
||||
andcc %g2, 0x7, %g0
|
||||
|
|
|
@ -44,9 +44,8 @@ vis1: ldub [%g6 + TI_FPSAVED], %g3
|
|||
|
||||
stx %g3, [%g6 + TI_GSR]
|
||||
2: add %g6, %g1, %g3
|
||||
cmp %o5, FPRS_DU
|
||||
be,pn %icc, 6f
|
||||
sll %g1, 3, %g1
|
||||
mov FPRS_DU | FPRS_DL | FPRS_FEF, %o5
|
||||
sll %g1, 3, %g1
|
||||
stb %o5, [%g3 + TI_FPSAVED]
|
||||
rd %gsr, %g2
|
||||
add %g6, %g1, %g3
|
||||
|
@ -80,65 +79,3 @@ vis1: ldub [%g6 + TI_FPSAVED], %g3
|
|||
.align 32
|
||||
80: jmpl %g7 + %g0, %g0
|
||||
nop
|
||||
|
||||
6: ldub [%g3 + TI_FPSAVED], %o5
|
||||
or %o5, FPRS_DU, %o5
|
||||
add %g6, TI_FPREGS+0x80, %g2
|
||||
stb %o5, [%g3 + TI_FPSAVED]
|
||||
|
||||
sll %g1, 5, %g1
|
||||
add %g6, TI_FPREGS+0xc0, %g3
|
||||
wr %g0, FPRS_FEF, %fprs
|
||||
membar #Sync
|
||||
stda %f32, [%g2 + %g1] ASI_BLK_P
|
||||
stda %f48, [%g3 + %g1] ASI_BLK_P
|
||||
membar #Sync
|
||||
ba,pt %xcc, 80f
|
||||
nop
|
||||
|
||||
.align 32
|
||||
80: jmpl %g7 + %g0, %g0
|
||||
nop
|
||||
|
||||
.align 32
|
||||
VISenterhalf:
|
||||
ldub [%g6 + TI_FPDEPTH], %g1
|
||||
brnz,a,pn %g1, 1f
|
||||
cmp %g1, 1
|
||||
stb %g0, [%g6 + TI_FPSAVED]
|
||||
stx %fsr, [%g6 + TI_XFSR]
|
||||
clr %o5
|
||||
jmpl %g7 + %g0, %g0
|
||||
wr %g0, FPRS_FEF, %fprs
|
||||
|
||||
1: bne,pn %icc, 2f
|
||||
srl %g1, 1, %g1
|
||||
ba,pt %xcc, vis1
|
||||
sub %g7, 8, %g7
|
||||
2: addcc %g6, %g1, %g3
|
||||
sll %g1, 3, %g1
|
||||
andn %o5, FPRS_DU, %g2
|
||||
stb %g2, [%g3 + TI_FPSAVED]
|
||||
|
||||
rd %gsr, %g2
|
||||
add %g6, %g1, %g3
|
||||
stx %g2, [%g3 + TI_GSR]
|
||||
add %g6, %g1, %g2
|
||||
stx %fsr, [%g2 + TI_XFSR]
|
||||
sll %g1, 5, %g1
|
||||
3: andcc %o5, FPRS_DL, %g0
|
||||
be,pn %icc, 4f
|
||||
add %g6, TI_FPREGS, %g2
|
||||
|
||||
add %g6, TI_FPREGS+0x40, %g3
|
||||
membar #Sync
|
||||
stda %f0, [%g2 + %g1] ASI_BLK_P
|
||||
stda %f16, [%g3 + %g1] ASI_BLK_P
|
||||
membar #Sync
|
||||
ba,pt %xcc, 4f
|
||||
nop
|
||||
|
||||
.align 32
|
||||
4: and %o5, FPRS_DU, %o5
|
||||
jmpl %g7 + %g0, %g0
|
||||
wr %o5, FPRS_FEF, %fprs
|
||||
|
|
|
@ -126,10 +126,6 @@ EXPORT_SYMBOL(copy_user_page);
|
|||
void VISenter(void);
|
||||
EXPORT_SYMBOL(VISenter);
|
||||
|
||||
/* CRYPTO code needs this */
|
||||
void VISenterhalf(void);
|
||||
EXPORT_SYMBOL(VISenterhalf);
|
||||
|
||||
extern void xor_vis_2(unsigned long, unsigned long *, unsigned long *);
|
||||
extern void xor_vis_3(unsigned long, unsigned long *, unsigned long *,
|
||||
unsigned long *);
|
||||
|
|
|
@ -1064,7 +1064,7 @@ static void __init load_hv_initrd(void)
|
|||
|
||||
void __init free_initrd_mem(unsigned long begin, unsigned long end)
|
||||
{
|
||||
free_bootmem(__pa(begin), end - begin);
|
||||
free_bootmem_late(__pa(begin), end - begin);
|
||||
}
|
||||
|
||||
#else
|
||||
|
|
|
@ -54,7 +54,7 @@ ENTRY(efi_pe_entry)
|
|||
call reloc
|
||||
reloc:
|
||||
popl %ecx
|
||||
subl reloc, %ecx
|
||||
subl $reloc, %ecx
|
||||
movl %ecx, BP_code32_start(%eax)
|
||||
|
||||
sub $0x4, %esp
|
||||
|
|
|
@ -291,6 +291,7 @@ static struct ahash_alg ghash_async_alg = {
|
|||
.cra_name = "ghash",
|
||||
.cra_driver_name = "ghash-clmulni",
|
||||
.cra_priority = 400,
|
||||
.cra_ctxsize = sizeof(struct ghash_async_ctx),
|
||||
.cra_flags = CRYPTO_ALG_TYPE_AHASH | CRYPTO_ALG_ASYNC,
|
||||
.cra_blocksize = GHASH_BLOCK_SIZE,
|
||||
.cra_type = &crypto_ahash_type,
|
||||
|
|
|
@ -77,11 +77,10 @@ int copy_to_user(void __user *dst, const void *src, unsigned size)
|
|||
}
|
||||
|
||||
static __always_inline __must_check
|
||||
int __copy_from_user(void *dst, const void __user *src, unsigned size)
|
||||
int __copy_from_user_nocheck(void *dst, const void __user *src, unsigned size)
|
||||
{
|
||||
int ret = 0;
|
||||
|
||||
might_fault();
|
||||
if (!__builtin_constant_p(size))
|
||||
return copy_user_generic(dst, (__force void *)src, size);
|
||||
switch (size) {
|
||||
|
@ -121,11 +120,17 @@ int __copy_from_user(void *dst, const void __user *src, unsigned size)
|
|||
}
|
||||
|
||||
static __always_inline __must_check
|
||||
int __copy_to_user(void __user *dst, const void *src, unsigned size)
|
||||
int __copy_from_user(void *dst, const void __user *src, unsigned size)
|
||||
{
|
||||
might_fault();
|
||||
return __copy_from_user_nocheck(dst, src, size);
|
||||
}
|
||||
|
||||
static __always_inline __must_check
|
||||
int __copy_to_user_nocheck(void __user *dst, const void *src, unsigned size)
|
||||
{
|
||||
int ret = 0;
|
||||
|
||||
might_fault();
|
||||
if (!__builtin_constant_p(size))
|
||||
return copy_user_generic((__force void *)dst, src, size);
|
||||
switch (size) {
|
||||
|
@ -164,6 +169,13 @@ int __copy_to_user(void __user *dst, const void *src, unsigned size)
|
|||
}
|
||||
}
|
||||
|
||||
static __always_inline __must_check
|
||||
int __copy_to_user(void __user *dst, const void *src, unsigned size)
|
||||
{
|
||||
might_fault();
|
||||
return __copy_to_user_nocheck(dst, src, size);
|
||||
}
|
||||
|
||||
static __always_inline __must_check
|
||||
int __copy_in_user(void __user *dst, const void __user *src, unsigned size)
|
||||
{
|
||||
|
@ -220,13 +232,13 @@ int __copy_in_user(void __user *dst, const void __user *src, unsigned size)
|
|||
static __must_check __always_inline int
|
||||
__copy_from_user_inatomic(void *dst, const void __user *src, unsigned size)
|
||||
{
|
||||
return copy_user_generic(dst, (__force const void *)src, size);
|
||||
return __copy_from_user_nocheck(dst, (__force const void *)src, size);
|
||||
}
|
||||
|
||||
static __must_check __always_inline int
|
||||
__copy_to_user_inatomic(void __user *dst, const void *src, unsigned size)
|
||||
{
|
||||
return copy_user_generic((__force void *)dst, src, size);
|
||||
return __copy_to_user_nocheck((__force void *)dst, src, size);
|
||||
}
|
||||
|
||||
extern long __copy_user_nocache(void *dst, const void __user *src,
|
||||
|
|
|
@ -350,6 +350,13 @@ static void __setup_APIC_LVTT(unsigned int clocks, int oneshot, int irqen)
|
|||
apic_write(APIC_LVTT, lvtt_value);
|
||||
|
||||
if (lvtt_value & APIC_LVT_TIMER_TSCDEADLINE) {
|
||||
/*
|
||||
* See Intel SDM: TSC-Deadline Mode chapter. In xAPIC mode,
|
||||
* writing to the APIC LVTT and TSC_DEADLINE MSR isn't serialized.
|
||||
* According to Intel, MFENCE can do the serialization here.
|
||||
*/
|
||||
asm volatile("mfence" : : : "memory");
|
||||
|
||||
printk_once(KERN_DEBUG "TSC deadline timer enabled\n");
|
||||
return;
|
||||
}
|
||||
|
|
|
@ -648,48 +648,48 @@ static __initconst const struct x86_pmu amd_pmu = {
|
|||
.cpu_dead = amd_pmu_cpu_dead,
|
||||
};
|
||||
|
||||
static int setup_event_constraints(void)
|
||||
static int __init amd_core_pmu_init(void)
|
||||
{
|
||||
if (boot_cpu_data.x86 == 0x15)
|
||||
x86_pmu.get_event_constraints = amd_get_event_constraints_f15h;
|
||||
return 0;
|
||||
}
|
||||
if (!cpu_has_perfctr_core)
|
||||
return 0;
|
||||
|
||||
static int setup_perfctr_core(void)
|
||||
{
|
||||
if (!cpu_has_perfctr_core) {
|
||||
WARN(x86_pmu.get_event_constraints == amd_get_event_constraints_f15h,
|
||||
KERN_ERR "Odd, counter constraints enabled but no core perfctrs detected!");
|
||||
switch (boot_cpu_data.x86) {
|
||||
case 0x15:
|
||||
pr_cont("Fam15h ");
|
||||
x86_pmu.get_event_constraints = amd_get_event_constraints_f15h;
|
||||
break;
|
||||
|
||||
default:
|
||||
pr_err("core perfctr but no constraints; unknown hardware!\n");
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
WARN(x86_pmu.get_event_constraints == amd_get_event_constraints,
|
||||
KERN_ERR "hw perf events core counters need constraints handler!");
|
||||
|
||||
/*
|
||||
* If core performance counter extensions exists, we must use
|
||||
* MSR_F15H_PERF_CTL/MSR_F15H_PERF_CTR msrs. See also
|
||||
* x86_pmu_addr_offset().
|
||||
* amd_pmu_addr_offset().
|
||||
*/
|
||||
x86_pmu.eventsel = MSR_F15H_PERF_CTL;
|
||||
x86_pmu.perfctr = MSR_F15H_PERF_CTR;
|
||||
x86_pmu.num_counters = AMD64_NUM_COUNTERS_CORE;
|
||||
|
||||
printk(KERN_INFO "perf: AMD core performance counters detected\n");
|
||||
|
||||
pr_cont("core perfctr, ");
|
||||
return 0;
|
||||
}
|
||||
|
||||
__init int amd_pmu_init(void)
|
||||
{
|
||||
int ret;
|
||||
|
||||
/* Performance-monitoring supported from K7 and later: */
|
||||
if (boot_cpu_data.x86 < 6)
|
||||
return -ENODEV;
|
||||
|
||||
x86_pmu = amd_pmu;
|
||||
|
||||
setup_event_constraints();
|
||||
setup_perfctr_core();
|
||||
ret = amd_core_pmu_init();
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
/* Events are common for all AMDs */
|
||||
memcpy(hw_cache_event_ids, amd_hw_cache_event_ids,
|
||||
|
|
|
@ -20,6 +20,7 @@
|
|||
#include <asm/hypervisor.h>
|
||||
#include <asm/nmi.h>
|
||||
#include <asm/x86_init.h>
|
||||
#include <asm/geode.h>
|
||||
|
||||
unsigned int __read_mostly cpu_khz; /* TSC clocks / usec, not used here */
|
||||
EXPORT_SYMBOL(cpu_khz);
|
||||
|
@ -806,15 +807,17 @@ EXPORT_SYMBOL_GPL(mark_tsc_unstable);
|
|||
|
||||
static void __init check_system_tsc_reliable(void)
|
||||
{
|
||||
#ifdef CONFIG_MGEODE_LX
|
||||
/* RTSC counts during suspend */
|
||||
#if defined(CONFIG_MGEODEGX1) || defined(CONFIG_MGEODE_LX) || defined(CONFIG_X86_GENERIC)
|
||||
if (is_geode_lx()) {
|
||||
/* RTSC counts during suspend */
|
||||
#define RTSC_SUSP 0x100
|
||||
unsigned long res_low, res_high;
|
||||
unsigned long res_low, res_high;
|
||||
|
||||
rdmsr_safe(MSR_GEODE_BUSCONT_CONF0, &res_low, &res_high);
|
||||
/* Geode_LX - the OLPC CPU has a very reliable TSC */
|
||||
if (res_low & RTSC_SUSP)
|
||||
tsc_clocksource_reliable = 1;
|
||||
rdmsr_safe(MSR_GEODE_BUSCONT_CONF0, &res_low, &res_high);
|
||||
/* Geode_LX - the OLPC CPU has a very reliable TSC */
|
||||
if (res_low & RTSC_SUSP)
|
||||
tsc_clocksource_reliable = 1;
|
||||
}
|
||||
#endif
|
||||
if (boot_cpu_has(X86_FEATURE_TSC_RELIABLE))
|
||||
tsc_clocksource_reliable = 1;
|
||||
|
|
|
@ -165,7 +165,7 @@ static inline u16 apic_logical_id(struct kvm_apic_map *map, u32 ldr)
|
|||
|
||||
static inline bool kvm_apic_has_events(struct kvm_vcpu *vcpu)
|
||||
{
|
||||
return vcpu->arch.apic->pending_events;
|
||||
return kvm_vcpu_has_lapic(vcpu) && vcpu->arch.apic->pending_events;
|
||||
}
|
||||
|
||||
bool kvm_apic_pending_eoi(struct kvm_vcpu *vcpu, int vector);
|
||||
|
|
|
@ -496,7 +496,7 @@ static void skip_emulated_instruction(struct kvm_vcpu *vcpu)
|
|||
struct vcpu_svm *svm = to_svm(vcpu);
|
||||
|
||||
if (svm->vmcb->control.next_rip != 0) {
|
||||
WARN_ON(!static_cpu_has(X86_FEATURE_NRIPS));
|
||||
WARN_ON_ONCE(!static_cpu_has(X86_FEATURE_NRIPS));
|
||||
svm->next_rip = svm->vmcb->control.next_rip;
|
||||
}
|
||||
|
||||
|
|
|
@ -137,6 +137,7 @@ page_table_range_init_count(unsigned long start, unsigned long end)
|
|||
|
||||
vaddr = start;
|
||||
pgd_idx = pgd_index(vaddr);
|
||||
pmd_idx = pmd_index(vaddr);
|
||||
|
||||
for ( ; (pgd_idx < PTRS_PER_PGD) && (vaddr != end); pgd_idx++) {
|
||||
for (; (pmd_idx < PTRS_PER_PMD) && (vaddr != end);
|
||||
|
|
|
@ -1163,7 +1163,7 @@ void mark_rodata_ro(void)
|
|||
* has been zapped already via cleanup_highmem().
|
||||
*/
|
||||
all_end = roundup((unsigned long)_brk_end, PMD_SIZE);
|
||||
set_memory_nx(rodata_start, (all_end - rodata_start) >> PAGE_SHIFT);
|
||||
set_memory_nx(text_end, (all_end - text_end) >> PAGE_SHIFT);
|
||||
|
||||
rodata_test();
|
||||
|
||||
|
|
|
@ -176,7 +176,12 @@ void bpf_jit_compile(struct sk_filter *fp)
|
|||
}
|
||||
cleanup_addr = proglen; /* epilogue address */
|
||||
|
||||
for (pass = 0; pass < 10; pass++) {
|
||||
/* JITed image shrinks with every pass and the loop iterates
|
||||
* until the image stops shrinking. Very large bpf programs
|
||||
* may converge on the last pass. In such case do one more
|
||||
* pass to emit the final image
|
||||
*/
|
||||
for (pass = 0; pass < 10 || image; pass++) {
|
||||
u8 seen_or_pass0 = (pass == 0) ? (SEEN_XREG | SEEN_DATAREF | SEEN_MEM) : seen;
|
||||
/* no prologue/epilogue for trivial filters (RET something) */
|
||||
proglen = 0;
|
||||
|
|
|
@ -33,6 +33,10 @@
|
|||
#include <linux/memblock.h>
|
||||
#include <linux/edd.h>
|
||||
|
||||
#ifdef CONFIG_KEXEC
|
||||
#include <linux/kexec.h>
|
||||
#endif
|
||||
|
||||
#include <xen/xen.h>
|
||||
#include <xen/events.h>
|
||||
#include <xen/interface/xen.h>
|
||||
|
@ -481,6 +485,7 @@ static void set_aliased_prot(void *v, pgprot_t prot)
|
|||
pte_t pte;
|
||||
unsigned long pfn;
|
||||
struct page *page;
|
||||
unsigned char dummy;
|
||||
|
||||
ptep = lookup_address((unsigned long)v, &level);
|
||||
BUG_ON(ptep == NULL);
|
||||
|
@ -490,6 +495,32 @@ static void set_aliased_prot(void *v, pgprot_t prot)
|
|||
|
||||
pte = pfn_pte(pfn, prot);
|
||||
|
||||
/*
|
||||
* Careful: update_va_mapping() will fail if the virtual address
|
||||
* we're poking isn't populated in the page tables. We don't
|
||||
* need to worry about the direct map (that's always in the page
|
||||
* tables), but we need to be careful about vmap space. In
|
||||
* particular, the top level page table can lazily propagate
|
||||
* entries between processes, so if we've switched mms since we
|
||||
* vmapped the target in the first place, we might not have the
|
||||
* top-level page table entry populated.
|
||||
*
|
||||
* We disable preemption because we want the same mm active when
|
||||
* we probe the target and when we issue the hypercall. We'll
|
||||
* have the same nominal mm, but if we're a kernel thread, lazy
|
||||
* mm dropping could change our pgd.
|
||||
*
|
||||
* Out of an abundance of caution, this uses __get_user() to fault
|
||||
* in the target address just in case there's some obscure case
|
||||
* in which the target address isn't readable.
|
||||
*/
|
||||
|
||||
preempt_disable();
|
||||
|
||||
pagefault_disable(); /* Avoid warnings due to being atomic. */
|
||||
__get_user(dummy, (unsigned char __user __force *)v);
|
||||
pagefault_enable();
|
||||
|
||||
if (HYPERVISOR_update_va_mapping((unsigned long)v, pte, 0))
|
||||
BUG();
|
||||
|
||||
|
@ -501,6 +532,8 @@ static void set_aliased_prot(void *v, pgprot_t prot)
|
|||
BUG();
|
||||
} else
|
||||
kmap_flush_unused();
|
||||
|
||||
preempt_enable();
|
||||
}
|
||||
|
||||
static void xen_alloc_ldt(struct desc_struct *ldt, unsigned entries)
|
||||
|
@ -508,6 +541,17 @@ static void xen_alloc_ldt(struct desc_struct *ldt, unsigned entries)
|
|||
const unsigned entries_per_page = PAGE_SIZE / LDT_ENTRY_SIZE;
|
||||
int i;
|
||||
|
||||
/*
|
||||
* We need to mark the all aliases of the LDT pages RO. We
|
||||
* don't need to call vm_flush_aliases(), though, since that's
|
||||
* only responsible for flushing aliases out the TLBs, not the
|
||||
* page tables, and Xen will flush the TLB for us if needed.
|
||||
*
|
||||
* To avoid confusing future readers: none of this is necessary
|
||||
* to load the LDT. The hypervisor only checks this when the
|
||||
* LDT is faulted in due to subsequent descriptor access.
|
||||
*/
|
||||
|
||||
for(i = 0; i < entries; i += entries_per_page)
|
||||
set_aliased_prot(ldt + i, PAGE_KERNEL_RO);
|
||||
}
|
||||
|
@ -1704,6 +1748,21 @@ static struct notifier_block xen_hvm_cpu_notifier __cpuinitdata = {
|
|||
.notifier_call = xen_hvm_cpu_notify,
|
||||
};
|
||||
|
||||
#ifdef CONFIG_KEXEC
|
||||
static void xen_hvm_shutdown(void)
|
||||
{
|
||||
native_machine_shutdown();
|
||||
if (kexec_in_progress)
|
||||
xen_reboot(SHUTDOWN_soft_reset);
|
||||
}
|
||||
|
||||
static void xen_hvm_crash_shutdown(struct pt_regs *regs)
|
||||
{
|
||||
native_machine_crash_shutdown(regs);
|
||||
xen_reboot(SHUTDOWN_soft_reset);
|
||||
}
|
||||
#endif
|
||||
|
||||
static void __init xen_hvm_guest_init(void)
|
||||
{
|
||||
init_hvm_pv_info();
|
||||
|
@ -1718,6 +1777,10 @@ static void __init xen_hvm_guest_init(void)
|
|||
x86_init.irqs.intr_init = xen_init_IRQ;
|
||||
xen_hvm_init_time_ops();
|
||||
xen_hvm_init_mmu_ops();
|
||||
#ifdef CONFIG_KEXEC
|
||||
machine_ops.shutdown = xen_hvm_shutdown;
|
||||
machine_ops.crash_shutdown = xen_hvm_crash_shutdown;
|
||||
#endif
|
||||
}
|
||||
|
||||
static bool __init xen_hvm_platform(void)
|
||||
|
|
|
@ -55,10 +55,10 @@ ifneq ($(CONFIG_LD_NO_RELAX),)
|
|||
LDFLAGS := --no-relax
|
||||
endif
|
||||
|
||||
ifeq ($(shell echo -e __XTENSA_EB__ | $(CC) -E - | grep -v "\#"),1)
|
||||
ifeq ($(shell echo __XTENSA_EB__ | $(CC) -E - | grep -v "\#"),1)
|
||||
CHECKFLAGS += -D__XTENSA_EB__
|
||||
endif
|
||||
ifeq ($(shell echo -e __XTENSA_EL__ | $(CC) -E - | grep -v "\#"),1)
|
||||
ifeq ($(shell echo __XTENSA_EL__ | $(CC) -E - | grep -v "\#"),1)
|
||||
CHECKFLAGS += -D__XTENSA_EL__
|
||||
endif
|
||||
|
||||
|
|
|
@ -12,7 +12,7 @@
|
|||
KBUILD_CFLAGS += -fno-builtin -Iarch/$(ARCH)/boot/include
|
||||
HOSTFLAGS += -Iarch/$(ARCH)/boot/include
|
||||
|
||||
BIG_ENDIAN := $(shell echo -e __XTENSA_EB__ | $(CC) -E - | grep -v "\#")
|
||||
BIG_ENDIAN := $(shell echo __XTENSA_EB__ | $(CC) -E - | grep -v "\#")
|
||||
|
||||
export ccflags-y
|
||||
export BIG_ENDIAN
|
||||
|
|
|
@ -24,30 +24,39 @@ static inline void spill_registers(void)
|
|||
{
|
||||
#if XCHAL_NUM_AREGS > 16
|
||||
__asm__ __volatile__ (
|
||||
" call12 1f\n"
|
||||
" call8 1f\n"
|
||||
" _j 2f\n"
|
||||
" retw\n"
|
||||
" .align 4\n"
|
||||
"1:\n"
|
||||
#if XCHAL_NUM_AREGS == 32
|
||||
" _entry a1, 32\n"
|
||||
" addi a8, a0, 3\n"
|
||||
" _entry a1, 16\n"
|
||||
" mov a12, a12\n"
|
||||
" retw\n"
|
||||
#else
|
||||
" _entry a1, 48\n"
|
||||
" addi a12, a0, 3\n"
|
||||
#if XCHAL_NUM_AREGS > 32
|
||||
" .rept (" __stringify(XCHAL_NUM_AREGS) " - 32) / 12\n"
|
||||
" call12 1f\n"
|
||||
" retw\n"
|
||||
" .align 4\n"
|
||||
"1:\n"
|
||||
" .rept (" __stringify(XCHAL_NUM_AREGS) " - 16) / 12\n"
|
||||
" _entry a1, 48\n"
|
||||
" mov a12, a0\n"
|
||||
" .endr\n"
|
||||
#endif
|
||||
" _entry a1, 48\n"
|
||||
" _entry a1, 16\n"
|
||||
#if XCHAL_NUM_AREGS % 12 == 0
|
||||
" mov a8, a8\n"
|
||||
#elif XCHAL_NUM_AREGS % 12 == 4
|
||||
" mov a12, a12\n"
|
||||
#elif XCHAL_NUM_AREGS % 12 == 8
|
||||
#elif XCHAL_NUM_AREGS % 12 == 4
|
||||
" mov a4, a4\n"
|
||||
#elif XCHAL_NUM_AREGS % 12 == 8
|
||||
" mov a8, a8\n"
|
||||
#endif
|
||||
" retw\n"
|
||||
#endif
|
||||
"2:\n"
|
||||
: : : "a12", "a13", "memory");
|
||||
: : : "a8", "a9", "memory");
|
||||
#else
|
||||
__asm__ __volatile__ (
|
||||
" mov a12, a12\n"
|
||||
|
|
|
@ -549,12 +549,13 @@ user_exception_exit:
|
|||
* (if we have restored WSBITS-1 frames).
|
||||
*/
|
||||
|
||||
2:
|
||||
#if XCHAL_HAVE_THREADPTR
|
||||
l32i a3, a1, PT_THREADPTR
|
||||
wur a3, threadptr
|
||||
#endif
|
||||
|
||||
2: j common_exception_exit
|
||||
j common_exception_exit
|
||||
|
||||
/* This is the kernel exception exit.
|
||||
* We avoided to do a MOVSP when we entered the exception, but we
|
||||
|
@ -1933,7 +1934,7 @@ ENDPROC(system_call)
|
|||
mov a12, a0
|
||||
.endr
|
||||
#endif
|
||||
_entry a1, 48
|
||||
_entry a1, 16
|
||||
#if XCHAL_NUM_AREGS % 12 == 0
|
||||
mov a8, a8
|
||||
#elif XCHAL_NUM_AREGS % 12 == 4
|
||||
|
@ -1957,7 +1958,7 @@ ENDPROC(system_call)
|
|||
|
||||
ENTRY(_switch_to)
|
||||
|
||||
entry a1, 16
|
||||
entry a1, 48
|
||||
|
||||
mov a11, a3 # and 'next' (a3)
|
||||
|
||||
|
|
|
@ -720,8 +720,12 @@ int blkg_conf_prep(struct blkcg *blkcg, const struct blkcg_policy *pol,
|
|||
return -EINVAL;
|
||||
|
||||
disk = get_gendisk(MKDEV(major, minor), &part);
|
||||
if (!disk || part)
|
||||
if (!disk)
|
||||
return -EINVAL;
|
||||
if (part) {
|
||||
put_disk(disk);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
rcu_read_lock();
|
||||
spin_lock_irq(disk->queue->queue_lock);
|
||||
|
|
|
@ -700,7 +700,7 @@ struct crypto_ablkcipher *crypto_alloc_ablkcipher(const char *alg_name,
|
|||
err:
|
||||
if (err != -EAGAIN)
|
||||
break;
|
||||
if (signal_pending(current)) {
|
||||
if (fatal_signal_pending(current)) {
|
||||
err = -EINTR;
|
||||
break;
|
||||
}
|
||||
|
|
|
@ -462,7 +462,8 @@ static int ahash_prepare_alg(struct ahash_alg *alg)
|
|||
struct crypto_alg *base = &alg->halg.base;
|
||||
|
||||
if (alg->halg.digestsize > PAGE_SIZE / 8 ||
|
||||
alg->halg.statesize > PAGE_SIZE / 8)
|
||||
alg->halg.statesize > PAGE_SIZE / 8 ||
|
||||
alg->halg.statesize == 0)
|
||||
return -EINVAL;
|
||||
|
||||
base->cra_type = &crypto_ahash_type;
|
||||
|
|
|
@ -325,7 +325,7 @@ static void crypto_wait_for_test(struct crypto_larval *larval)
|
|||
crypto_alg_tested(larval->alg.cra_driver_name, 0);
|
||||
}
|
||||
|
||||
err = wait_for_completion_interruptible(&larval->completion);
|
||||
err = wait_for_completion_killable(&larval->completion);
|
||||
WARN_ON(err);
|
||||
|
||||
out:
|
||||
|
|
|
@ -172,7 +172,7 @@ static struct crypto_alg *crypto_larval_wait(struct crypto_alg *alg)
|
|||
struct crypto_larval *larval = (void *)alg;
|
||||
long timeout;
|
||||
|
||||
timeout = wait_for_completion_interruptible_timeout(
|
||||
timeout = wait_for_completion_killable_timeout(
|
||||
&larval->completion, 60 * HZ);
|
||||
|
||||
alg = larval->adult;
|
||||
|
@ -435,7 +435,7 @@ struct crypto_tfm *crypto_alloc_base(const char *alg_name, u32 type, u32 mask)
|
|||
err:
|
||||
if (err != -EAGAIN)
|
||||
break;
|
||||
if (signal_pending(current)) {
|
||||
if (fatal_signal_pending(current)) {
|
||||
err = -EINTR;
|
||||
break;
|
||||
}
|
||||
|
@ -552,7 +552,7 @@ void *crypto_alloc_tfm(const char *alg_name,
|
|||
err:
|
||||
if (err != -EAGAIN)
|
||||
break;
|
||||
if (signal_pending(current)) {
|
||||
if (fatal_signal_pending(current)) {
|
||||
err = -EINTR;
|
||||
break;
|
||||
}
|
||||
|
|
|
@ -361,7 +361,7 @@ static struct crypto_alg *crypto_user_aead_alg(const char *name, u32 type,
|
|||
err = PTR_ERR(alg);
|
||||
if (err != -EAGAIN)
|
||||
break;
|
||||
if (signal_pending(current)) {
|
||||
if (fatal_signal_pending(current)) {
|
||||
err = -EINTR;
|
||||
break;
|
||||
}
|
||||
|
|
|
@ -165,10 +165,12 @@ acpi_status acpi_enable_subsystem(u32 flags)
|
|||
* Obtain a permanent mapping for the FACS. This is required for the
|
||||
* Global Lock and the Firmware Waking Vector
|
||||
*/
|
||||
status = acpi_tb_initialize_facs();
|
||||
if (ACPI_FAILURE(status)) {
|
||||
ACPI_WARNING((AE_INFO, "Could not map the FACS table"));
|
||||
return_ACPI_STATUS(status);
|
||||
if (!(flags & ACPI_NO_FACS_INIT)) {
|
||||
status = acpi_tb_initialize_facs();
|
||||
if (ACPI_FAILURE(status)) {
|
||||
ACPI_WARNING((AE_INFO, "Could not map the FACS table"));
|
||||
return_ACPI_STATUS(status);
|
||||
}
|
||||
}
|
||||
#endif /* !ACPI_REDUCED_HARDWARE */
|
||||
|
||||
|
|
|
@ -4150,9 +4150,10 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
|
|||
{ "ST3320[68]13AS", "SD1[5-9]", ATA_HORKAGE_NONCQ |
|
||||
ATA_HORKAGE_FIRMWARE_WARN },
|
||||
|
||||
/* Seagate Momentus SpinPoint M8 seem to have FPMDA_AA issues */
|
||||
/* drives which fail FPDMA_AA activation (some may freeze afterwards) */
|
||||
{ "ST1000LM024 HN-M101MBB", "2AR10001", ATA_HORKAGE_BROKEN_FPDMA_AA },
|
||||
{ "ST1000LM024 HN-M101MBB", "2BA30001", ATA_HORKAGE_BROKEN_FPDMA_AA },
|
||||
{ "VB0250EAVER", "HPG7", ATA_HORKAGE_BROKEN_FPDMA_AA },
|
||||
|
||||
/* Blacklist entries taken from Silicon Image 3124/3132
|
||||
Windows driver .inf file - also several Linux problem reports */
|
||||
|
@ -4200,6 +4201,9 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
|
|||
{ "PIONEER DVD-RW DVR-212D", NULL, ATA_HORKAGE_NOSETXFER },
|
||||
{ "PIONEER DVD-RW DVR-216D", NULL, ATA_HORKAGE_NOSETXFER },
|
||||
|
||||
/* devices that don't properly handle TRIM commands */
|
||||
{ "SuperSSpeed S238*", NULL, ATA_HORKAGE_NOTRIM, },
|
||||
|
||||
/*
|
||||
* Some WD SATA-I drives spin up and down erratically when the link
|
||||
* is put into the slumber mode. We don't have full list of the
|
||||
|
@ -4504,7 +4508,8 @@ static unsigned int ata_dev_set_xfermode(struct ata_device *dev)
|
|||
else /* In the ancient relic department - skip all of this */
|
||||
return 0;
|
||||
|
||||
err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
|
||||
/* On some disks, this command causes spin-up, so we need longer timeout */
|
||||
err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 15000);
|
||||
|
||||
DPRINTK("EXIT, err_mask=%x\n", err_mask);
|
||||
return err_mask;
|
||||
|
|
|
@ -460,6 +460,13 @@ static void sata_pmp_quirks(struct ata_port *ap)
|
|||
ATA_LFLAG_NO_SRST |
|
||||
ATA_LFLAG_ASSUME_ATA;
|
||||
}
|
||||
} else if (vendor == 0x11ab && devid == 0x4140) {
|
||||
/* Marvell 4140 quirks */
|
||||
ata_for_each_link(link, ap, EDGE) {
|
||||
/* port 4 is for SEMB device and it doesn't like SRST */
|
||||
if (link->pmp == 4)
|
||||
link->flags |= ATA_LFLAG_DISABLED;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -2512,7 +2512,8 @@ static unsigned int ata_scsiop_read_cap(struct ata_scsi_args *args, u8 *rbuf)
|
|||
rbuf[14] = (lowest_aligned >> 8) & 0x3f;
|
||||
rbuf[15] = lowest_aligned;
|
||||
|
||||
if (ata_id_has_trim(args->id)) {
|
||||
if (ata_id_has_trim(args->id) &&
|
||||
!(dev->horkage & ATA_HORKAGE_NOTRIM)) {
|
||||
rbuf[14] |= 0x80; /* TPE */
|
||||
|
||||
if (ata_id_has_zero_after_trim(args->id))
|
||||
|
|
|
@ -139,6 +139,7 @@ static int __init ks0108_init(void)
|
|||
|
||||
ks0108_pardevice = parport_register_device(ks0108_parport, KS0108_NAME,
|
||||
NULL, NULL, NULL, PARPORT_DEV_EXCL, NULL);
|
||||
parport_put_port(ks0108_parport);
|
||||
if (ks0108_pardevice == NULL) {
|
||||
printk(KERN_ERR KS0108_NAME ": ERROR: "
|
||||
"parport didn't register new device\n");
|
||||
|
|
|
@ -297,10 +297,10 @@ void * devres_get(struct device *dev, void *new_res,
|
|||
if (!dr) {
|
||||
add_dr(dev, &new_dr->node);
|
||||
dr = new_dr;
|
||||
new_dr = NULL;
|
||||
new_res = NULL;
|
||||
}
|
||||
spin_unlock_irqrestore(&dev->devres_lock, flags);
|
||||
devres_free(new_dr);
|
||||
devres_free(new_res);
|
||||
|
||||
return dr->data;
|
||||
}
|
||||
|
|
|
@ -589,10 +589,8 @@ static void fw_dev_release(struct device *dev)
|
|||
module_put(THIS_MODULE);
|
||||
}
|
||||
|
||||
static int firmware_uevent(struct device *dev, struct kobj_uevent_env *env)
|
||||
static int do_firmware_uevent(struct firmware_priv *fw_priv, struct kobj_uevent_env *env)
|
||||
{
|
||||
struct firmware_priv *fw_priv = to_firmware_priv(dev);
|
||||
|
||||
if (add_uevent_var(env, "FIRMWARE=%s", fw_priv->buf->fw_id))
|
||||
return -ENOMEM;
|
||||
if (add_uevent_var(env, "TIMEOUT=%i", loading_timeout))
|
||||
|
@ -603,6 +601,18 @@ static int firmware_uevent(struct device *dev, struct kobj_uevent_env *env)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int firmware_uevent(struct device *dev, struct kobj_uevent_env *env)
|
||||
{
|
||||
struct firmware_priv *fw_priv = to_firmware_priv(dev);
|
||||
int err = 0;
|
||||
|
||||
mutex_lock(&fw_lock);
|
||||
if (fw_priv->buf)
|
||||
err = do_firmware_uevent(fw_priv, env);
|
||||
mutex_unlock(&fw_lock);
|
||||
return err;
|
||||
}
|
||||
|
||||
static struct class firmware_class = {
|
||||
.name = "firmware",
|
||||
.class_attrs = firmware_class_attrs,
|
||||
|
|
|
@ -347,9 +347,7 @@ int platform_device_add(struct platform_device *pdev)
|
|||
|
||||
while (--i >= 0) {
|
||||
struct resource *r = &pdev->resource[i];
|
||||
unsigned long type = resource_type(r);
|
||||
|
||||
if (type == IORESOURCE_MEM || type == IORESOURCE_IO)
|
||||
if (r->parent)
|
||||
release_resource(r);
|
||||
}
|
||||
|
||||
|
@ -380,9 +378,7 @@ void platform_device_del(struct platform_device *pdev)
|
|||
|
||||
for (i = 0; i < pdev->num_resources; i++) {
|
||||
struct resource *r = &pdev->resource[i];
|
||||
unsigned long type = resource_type(r);
|
||||
|
||||
if (type == IORESOURCE_MEM || type == IORESOURCE_IO)
|
||||
if (r->parent)
|
||||
release_resource(r);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -23,8 +23,7 @@ static struct dentry *regmap_debugfs_root;
|
|||
/* Calculate the length of a fixed format */
|
||||
static size_t regmap_calc_reg_len(int max_val, char *buf, size_t buf_size)
|
||||
{
|
||||
snprintf(buf, buf_size, "%x", max_val);
|
||||
return strlen(buf);
|
||||
return snprintf(NULL, 0, "%x", max_val);
|
||||
}
|
||||
|
||||
static ssize_t regmap_name_read_file(struct file *file,
|
||||
|
@ -418,7 +417,7 @@ static ssize_t regmap_access_read_file(struct file *file,
|
|||
/* If we're in the region the user is trying to read */
|
||||
if (p >= *ppos) {
|
||||
/* ...but not beyond it */
|
||||
if (buf_pos >= count - 1 - tot_len)
|
||||
if (buf_pos + tot_len + 1 >= count)
|
||||
break;
|
||||
|
||||
/* Format the register */
|
||||
|
|
|
@ -1839,7 +1839,7 @@ int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
|
|||
&ival);
|
||||
if (ret != 0)
|
||||
return ret;
|
||||
memcpy(val + (i * val_bytes), &ival, val_bytes);
|
||||
map->format.format_val(val + (i * val_bytes), ival, 0);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -93,6 +93,8 @@ static int atomic_dec_return_safe(atomic_t *v)
|
|||
|
||||
#define RBD_MINORS_PER_MAJOR 256 /* max minors per blkdev */
|
||||
|
||||
#define RBD_MAX_PARENT_CHAIN_LEN 16
|
||||
|
||||
#define RBD_SNAP_DEV_NAME_PREFIX "snap_"
|
||||
#define RBD_MAX_SNAP_NAME_LEN \
|
||||
(NAME_MAX - (sizeof (RBD_SNAP_DEV_NAME_PREFIX) - 1))
|
||||
|
@ -394,7 +396,7 @@ static ssize_t rbd_add(struct bus_type *bus, const char *buf,
|
|||
size_t count);
|
||||
static ssize_t rbd_remove(struct bus_type *bus, const char *buf,
|
||||
size_t count);
|
||||
static int rbd_dev_image_probe(struct rbd_device *rbd_dev, bool mapping);
|
||||
static int rbd_dev_image_probe(struct rbd_device *rbd_dev, int depth);
|
||||
static void rbd_spec_put(struct rbd_spec *spec);
|
||||
|
||||
static struct bus_attribute rbd_bus_attrs[] = {
|
||||
|
@ -457,6 +459,7 @@ void rbd_warn(struct rbd_device *rbd_dev, const char *fmt, ...)
|
|||
# define rbd_assert(expr) ((void) 0)
|
||||
#endif /* !RBD_DEBUG */
|
||||
|
||||
static void rbd_osd_copyup_callback(struct rbd_obj_request *obj_request);
|
||||
static int rbd_img_obj_request_submit(struct rbd_obj_request *obj_request);
|
||||
static void rbd_img_parent_read(struct rbd_obj_request *obj_request);
|
||||
static void rbd_dev_remove_parent(struct rbd_device *rbd_dev);
|
||||
|
@ -1670,6 +1673,16 @@ static void rbd_osd_stat_callback(struct rbd_obj_request *obj_request)
|
|||
obj_request_done_set(obj_request);
|
||||
}
|
||||
|
||||
static void rbd_osd_call_callback(struct rbd_obj_request *obj_request)
|
||||
{
|
||||
dout("%s: obj %p\n", __func__, obj_request);
|
||||
|
||||
if (obj_request_img_data_test(obj_request))
|
||||
rbd_osd_copyup_callback(obj_request);
|
||||
else
|
||||
obj_request_done_set(obj_request);
|
||||
}
|
||||
|
||||
static void rbd_osd_req_callback(struct ceph_osd_request *osd_req,
|
||||
struct ceph_msg *msg)
|
||||
{
|
||||
|
@ -1708,6 +1721,8 @@ static void rbd_osd_req_callback(struct ceph_osd_request *osd_req,
|
|||
rbd_osd_stat_callback(obj_request);
|
||||
break;
|
||||
case CEPH_OSD_OP_CALL:
|
||||
rbd_osd_call_callback(obj_request);
|
||||
break;
|
||||
case CEPH_OSD_OP_NOTIFY_ACK:
|
||||
case CEPH_OSD_OP_WATCH:
|
||||
rbd_osd_trivial_callback(obj_request);
|
||||
|
@ -1851,11 +1866,11 @@ static struct rbd_obj_request *rbd_obj_request_create(const char *object_name,
|
|||
rbd_assert(obj_request_type_valid(type));
|
||||
|
||||
size = strlen(object_name) + 1;
|
||||
name = kmalloc(size, GFP_KERNEL);
|
||||
name = kmalloc(size, GFP_NOIO);
|
||||
if (!name)
|
||||
return NULL;
|
||||
|
||||
obj_request = kmem_cache_zalloc(rbd_obj_request_cache, GFP_KERNEL);
|
||||
obj_request = kmem_cache_zalloc(rbd_obj_request_cache, GFP_NOIO);
|
||||
if (!obj_request) {
|
||||
kfree(name);
|
||||
return NULL;
|
||||
|
@ -2305,13 +2320,15 @@ out_unwind:
|
|||
}
|
||||
|
||||
static void
|
||||
rbd_img_obj_copyup_callback(struct rbd_obj_request *obj_request)
|
||||
rbd_osd_copyup_callback(struct rbd_obj_request *obj_request)
|
||||
{
|
||||
struct rbd_img_request *img_request;
|
||||
struct rbd_device *rbd_dev;
|
||||
struct page **pages;
|
||||
u32 page_count;
|
||||
|
||||
dout("%s: obj %p\n", __func__, obj_request);
|
||||
|
||||
rbd_assert(obj_request->type == OBJ_REQUEST_BIO);
|
||||
rbd_assert(obj_request_img_data_test(obj_request));
|
||||
img_request = obj_request->img_request;
|
||||
|
@ -2337,9 +2354,7 @@ rbd_img_obj_copyup_callback(struct rbd_obj_request *obj_request)
|
|||
if (!obj_request->result)
|
||||
obj_request->xferred = obj_request->length;
|
||||
|
||||
/* Finish up with the normal image object callback */
|
||||
|
||||
rbd_img_obj_callback(obj_request);
|
||||
obj_request_done_set(obj_request);
|
||||
}
|
||||
|
||||
static void
|
||||
|
@ -2436,7 +2451,6 @@ rbd_img_obj_parent_read_full_callback(struct rbd_img_request *img_request)
|
|||
|
||||
/* All set, send it off. */
|
||||
|
||||
orig_request->callback = rbd_img_obj_copyup_callback;
|
||||
osdc = &rbd_dev->rbd_client->client->osdc;
|
||||
img_result = rbd_obj_request_submit(osdc, orig_request);
|
||||
if (!img_result)
|
||||
|
@ -3441,6 +3455,9 @@ static int rbd_init_disk(struct rbd_device *rbd_dev)
|
|||
blk_queue_io_opt(q, segment_size);
|
||||
|
||||
blk_queue_merge_bvec(q, rbd_merge_bvec);
|
||||
if (!ceph_test_opt(rbd_dev->rbd_client->client, NOCRC))
|
||||
q->backing_dev_info.capabilities |= BDI_CAP_STABLE_WRITES;
|
||||
|
||||
disk->queue = q;
|
||||
|
||||
q->queuedata = rbd_dev;
|
||||
|
@ -4816,45 +4833,50 @@ out_err:
|
|||
return ret;
|
||||
}
|
||||
|
||||
static int rbd_dev_probe_parent(struct rbd_device *rbd_dev)
|
||||
/*
|
||||
* @depth is rbd_dev_image_probe() -> rbd_dev_probe_parent() ->
|
||||
* rbd_dev_image_probe() recursion depth, which means it's also the
|
||||
* length of the already discovered part of the parent chain.
|
||||
*/
|
||||
static int rbd_dev_probe_parent(struct rbd_device *rbd_dev, int depth)
|
||||
{
|
||||
struct rbd_device *parent = NULL;
|
||||
struct rbd_spec *parent_spec;
|
||||
struct rbd_client *rbdc;
|
||||
int ret;
|
||||
|
||||
if (!rbd_dev->parent_spec)
|
||||
return 0;
|
||||
/*
|
||||
* We need to pass a reference to the client and the parent
|
||||
* spec when creating the parent rbd_dev. Images related by
|
||||
* parent/child relationships always share both.
|
||||
*/
|
||||
parent_spec = rbd_spec_get(rbd_dev->parent_spec);
|
||||
rbdc = __rbd_get_client(rbd_dev->rbd_client);
|
||||
|
||||
ret = -ENOMEM;
|
||||
parent = rbd_dev_create(rbdc, parent_spec);
|
||||
if (!parent)
|
||||
if (++depth > RBD_MAX_PARENT_CHAIN_LEN) {
|
||||
pr_info("parent chain is too long (%d)\n", depth);
|
||||
ret = -EINVAL;
|
||||
goto out_err;
|
||||
|
||||
ret = rbd_dev_image_probe(parent, false);
|
||||
if (ret < 0)
|
||||
goto out_err;
|
||||
rbd_dev->parent = parent;
|
||||
atomic_set(&rbd_dev->parent_ref, 1);
|
||||
|
||||
return 0;
|
||||
out_err:
|
||||
if (parent) {
|
||||
rbd_dev_unparent(rbd_dev);
|
||||
kfree(rbd_dev->header_name);
|
||||
rbd_dev_destroy(parent);
|
||||
} else {
|
||||
rbd_put_client(rbdc);
|
||||
rbd_spec_put(parent_spec);
|
||||
}
|
||||
|
||||
parent = rbd_dev_create(rbd_dev->rbd_client, rbd_dev->parent_spec);
|
||||
if (!parent) {
|
||||
ret = -ENOMEM;
|
||||
goto out_err;
|
||||
}
|
||||
|
||||
/*
|
||||
* Images related by parent/child relationships always share
|
||||
* rbd_client and spec/parent_spec, so bump their refcounts.
|
||||
*/
|
||||
__rbd_get_client(rbd_dev->rbd_client);
|
||||
rbd_spec_get(rbd_dev->parent_spec);
|
||||
|
||||
ret = rbd_dev_image_probe(parent, depth);
|
||||
if (ret < 0)
|
||||
goto out_err;
|
||||
|
||||
rbd_dev->parent = parent;
|
||||
atomic_set(&rbd_dev->parent_ref, 1);
|
||||
return 0;
|
||||
|
||||
out_err:
|
||||
rbd_dev_unparent(rbd_dev);
|
||||
if (parent)
|
||||
rbd_dev_destroy(parent);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
@ -4960,7 +4982,7 @@ static void rbd_dev_image_release(struct rbd_device *rbd_dev)
|
|||
* parent), initiate a watch on its header object before using that
|
||||
* object to get detailed information about the rbd image.
|
||||
*/
|
||||
static int rbd_dev_image_probe(struct rbd_device *rbd_dev, bool mapping)
|
||||
static int rbd_dev_image_probe(struct rbd_device *rbd_dev, int depth)
|
||||
{
|
||||
int ret;
|
||||
int tmp;
|
||||
|
@ -4981,7 +5003,7 @@ static int rbd_dev_image_probe(struct rbd_device *rbd_dev, bool mapping)
|
|||
if (ret)
|
||||
goto err_out_format;
|
||||
|
||||
if (mapping) {
|
||||
if (!depth) {
|
||||
ret = rbd_dev_header_watch_sync(rbd_dev, true);
|
||||
if (ret)
|
||||
goto out_header_name;
|
||||
|
@ -4998,7 +5020,7 @@ static int rbd_dev_image_probe(struct rbd_device *rbd_dev, bool mapping)
|
|||
if (ret)
|
||||
goto err_out_probe;
|
||||
|
||||
ret = rbd_dev_probe_parent(rbd_dev);
|
||||
ret = rbd_dev_probe_parent(rbd_dev, depth);
|
||||
if (ret)
|
||||
goto err_out_probe;
|
||||
|
||||
|
@ -5009,7 +5031,7 @@ static int rbd_dev_image_probe(struct rbd_device *rbd_dev, bool mapping)
|
|||
err_out_probe:
|
||||
rbd_dev_unprobe(rbd_dev);
|
||||
err_out_watch:
|
||||
if (mapping) {
|
||||
if (!depth) {
|
||||
tmp = rbd_dev_header_watch_sync(rbd_dev, false);
|
||||
if (tmp)
|
||||
rbd_warn(rbd_dev, "unable to tear down "
|
||||
|
@ -5080,7 +5102,7 @@ static ssize_t rbd_add(struct bus_type *bus,
|
|||
rbdc = NULL; /* rbd_dev now owns this */
|
||||
spec = NULL; /* rbd_dev now owns this */
|
||||
|
||||
rc = rbd_dev_image_probe(rbd_dev, true);
|
||||
rc = rbd_dev_image_probe(rbd_dev, 0);
|
||||
if (rc < 0)
|
||||
goto err_out_rbd_dev;
|
||||
|
||||
|
|
|
@ -1590,7 +1590,8 @@ static void blkback_changed(struct xenbus_device *dev,
|
|||
break;
|
||||
/* Missed the backend's Closing state -- fallthrough */
|
||||
case XenbusStateClosing:
|
||||
blkfront_closing(info);
|
||||
if (info)
|
||||
blkfront_closing(info);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1239,6 +1239,8 @@ static int btusb_setup_intel(struct hci_dev *hdev)
|
|||
}
|
||||
fw_ptr = fw->data;
|
||||
|
||||
kfree_skb(skb);
|
||||
|
||||
/* This Intel specific command enables the manufacturer mode of the
|
||||
* controller.
|
||||
*
|
||||
|
|
|
@ -583,7 +583,7 @@ static inline int needs_ilk_vtd_wa(void)
|
|||
/* Query intel_iommu to see if we need the workaround. Presumably that
|
||||
* was loaded first.
|
||||
*/
|
||||
if ((gpu_devid == PCI_DEVICE_ID_INTEL_IRONLAKE_M_HB ||
|
||||
if ((gpu_devid == PCI_DEVICE_ID_INTEL_IRONLAKE_D_IG ||
|
||||
gpu_devid == PCI_DEVICE_ID_INTEL_IRONLAKE_M_IG) &&
|
||||
intel_iommu_gfx_mapped)
|
||||
return 1;
|
||||
|
|
|
@ -2717,7 +2717,7 @@ static int wait_for_msg_done(struct smi_info *smi_info)
|
|||
smi_result == SI_SM_CALL_WITH_TICK_DELAY) {
|
||||
schedule_timeout_uninterruptible(1);
|
||||
smi_result = smi_info->handlers->event(
|
||||
smi_info->si_sm, 100);
|
||||
smi_info->si_sm, jiffies_to_usecs(1));
|
||||
} else if (smi_result == SI_SM_CALL_WITHOUT_DELAY) {
|
||||
smi_result = smi_info->handlers->event(
|
||||
smi_info->si_sm, 0);
|
||||
|
|
|
@ -618,6 +618,9 @@ static int tpm_ibmvtpm_probe(struct vio_dev *vio_dev,
|
|||
goto cleanup;
|
||||
}
|
||||
|
||||
ibmvtpm->dev = dev;
|
||||
ibmvtpm->vdev = vio_dev;
|
||||
|
||||
crq_q = &ibmvtpm->crq_queue;
|
||||
crq_q->crq_addr = (struct ibmvtpm_crq *)get_zeroed_page(GFP_KERNEL);
|
||||
if (!crq_q->crq_addr) {
|
||||
|
@ -662,8 +665,6 @@ static int tpm_ibmvtpm_probe(struct vio_dev *vio_dev,
|
|||
|
||||
crq_q->index = 0;
|
||||
|
||||
ibmvtpm->dev = dev;
|
||||
ibmvtpm->vdev = vio_dev;
|
||||
TPM_VPRIV(chip) = (void *)ibmvtpm;
|
||||
|
||||
spin_lock_init(&ibmvtpm->rtce_lock);
|
||||
|
|
|
@ -128,8 +128,8 @@ struct clk *clk_sp810_timerclken_of_get(struct of_phandle_args *clkspec,
|
|||
{
|
||||
struct clk_sp810 *sp810 = data;
|
||||
|
||||
if (WARN_ON(clkspec->args_count != 1 || clkspec->args[0] >
|
||||
ARRAY_SIZE(sp810->timerclken)))
|
||||
if (WARN_ON(clkspec->args_count != 1 ||
|
||||
clkspec->args[0] >= ARRAY_SIZE(sp810->timerclken)))
|
||||
return NULL;
|
||||
|
||||
return sp810->timerclken[clkspec->args[0]].clk;
|
||||
|
|
|
@ -122,6 +122,9 @@ int cpuidle_idle_call(void)
|
|||
|
||||
/* ask the governor for the next state */
|
||||
next_state = cpuidle_curr_governor->select(drv, dev);
|
||||
if (next_state < 0)
|
||||
return -EBUSY;
|
||||
|
||||
if (need_resched()) {
|
||||
dev->last_residency = 0;
|
||||
/* give the governor an opportunity to reflect on the outcome */
|
||||
|
|
|
@ -257,7 +257,7 @@ static int menu_select(struct cpuidle_driver *drv, struct cpuidle_device *dev)
|
|||
data->needs_update = 0;
|
||||
}
|
||||
|
||||
data->last_state_idx = 0;
|
||||
data->last_state_idx = CPUIDLE_DRIVER_STATE_START - 1;
|
||||
data->exit_us = 0;
|
||||
|
||||
/* Special case when user has set very strict latency requirement */
|
||||
|
|
|
@ -895,13 +895,14 @@ static int ahash_final_ctx(struct ahash_request *req)
|
|||
state->buflen_1;
|
||||
u32 *sh_desc = ctx->sh_desc_fin, *desc;
|
||||
dma_addr_t ptr = ctx->sh_desc_fin_dma;
|
||||
int sec4_sg_bytes;
|
||||
int sec4_sg_bytes, sec4_sg_src_index;
|
||||
int digestsize = crypto_ahash_digestsize(ahash);
|
||||
struct ahash_edesc *edesc;
|
||||
int ret = 0;
|
||||
int sh_len;
|
||||
|
||||
sec4_sg_bytes = (1 + (buflen ? 1 : 0)) * sizeof(struct sec4_sg_entry);
|
||||
sec4_sg_src_index = 1 + (buflen ? 1 : 0);
|
||||
sec4_sg_bytes = sec4_sg_src_index * sizeof(struct sec4_sg_entry);
|
||||
|
||||
/* allocate space for base edesc and hw desc commands, link tables */
|
||||
edesc = kmalloc(sizeof(struct ahash_edesc) + DESC_JOB_IO_LEN +
|
||||
|
@ -928,7 +929,7 @@ static int ahash_final_ctx(struct ahash_request *req)
|
|||
state->buf_dma = try_buf_map_to_sec4_sg(jrdev, edesc->sec4_sg + 1,
|
||||
buf, state->buf_dma, buflen,
|
||||
last_buflen);
|
||||
(edesc->sec4_sg + sec4_sg_bytes - 1)->len |= SEC4_SG_LEN_FIN;
|
||||
(edesc->sec4_sg + sec4_sg_src_index - 1)->len |= SEC4_SG_LEN_FIN;
|
||||
|
||||
append_seq_in_ptr(desc, edesc->sec4_sg_dma, ctx->ctx_len + buflen,
|
||||
LDST_SGF);
|
||||
|
|
|
@ -915,7 +915,6 @@ static int ablk_perform(struct ablkcipher_request *req, int encrypt)
|
|||
crypt->mode |= NPE_OP_NOT_IN_PLACE;
|
||||
/* This was never tested by Intel
|
||||
* for more than one dst buffer, I think. */
|
||||
BUG_ON(req->dst->length < nbytes);
|
||||
req_ctx->dst = NULL;
|
||||
if (!chainup_buffers(dev, req->dst, nbytes, &dst_hook,
|
||||
flags, DMA_FROM_DEVICE))
|
||||
|
|
|
@ -393,7 +393,8 @@ static void __mv_xor_slot_cleanup(struct mv_xor_chan *mv_chan)
|
|||
dma_cookie_t cookie = 0;
|
||||
int busy = mv_chan_is_busy(mv_chan);
|
||||
u32 current_desc = mv_chan_get_current_desc(mv_chan);
|
||||
int seen_current = 0;
|
||||
int current_cleaned = 0;
|
||||
struct mv_xor_desc *hw_desc;
|
||||
|
||||
dev_dbg(mv_chan_to_devp(mv_chan), "%s %d\n", __func__, __LINE__);
|
||||
dev_dbg(mv_chan_to_devp(mv_chan), "current_desc %x\n", current_desc);
|
||||
|
@ -405,38 +406,57 @@ static void __mv_xor_slot_cleanup(struct mv_xor_chan *mv_chan)
|
|||
|
||||
list_for_each_entry_safe(iter, _iter, &mv_chan->chain,
|
||||
chain_node) {
|
||||
prefetch(_iter);
|
||||
prefetch(&_iter->async_tx);
|
||||
|
||||
/* do not advance past the current descriptor loaded into the
|
||||
* hardware channel, subsequent descriptors are either in
|
||||
* process or have not been submitted
|
||||
*/
|
||||
if (seen_current)
|
||||
break;
|
||||
/* clean finished descriptors */
|
||||
hw_desc = iter->hw_desc;
|
||||
if (hw_desc->status & XOR_DESC_SUCCESS) {
|
||||
cookie = mv_xor_run_tx_complete_actions(iter, mv_chan,
|
||||
cookie);
|
||||
|
||||
/* stop the search if we reach the current descriptor and the
|
||||
* channel is busy
|
||||
*/
|
||||
if (iter->async_tx.phys == current_desc) {
|
||||
seen_current = 1;
|
||||
if (busy)
|
||||
/* done processing desc, clean slot */
|
||||
mv_xor_clean_slot(iter, mv_chan);
|
||||
|
||||
/* break if we did cleaned the current */
|
||||
if (iter->async_tx.phys == current_desc) {
|
||||
current_cleaned = 1;
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
if (iter->async_tx.phys == current_desc) {
|
||||
current_cleaned = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
cookie = mv_xor_run_tx_complete_actions(iter, mv_chan, cookie);
|
||||
|
||||
if (mv_xor_clean_slot(iter, mv_chan))
|
||||
break;
|
||||
}
|
||||
|
||||
if ((busy == 0) && !list_empty(&mv_chan->chain)) {
|
||||
struct mv_xor_desc_slot *chain_head;
|
||||
chain_head = list_entry(mv_chan->chain.next,
|
||||
struct mv_xor_desc_slot,
|
||||
chain_node);
|
||||
|
||||
mv_xor_start_new_chain(mv_chan, chain_head);
|
||||
if (current_cleaned) {
|
||||
/*
|
||||
* current descriptor cleaned and removed, run
|
||||
* from list head
|
||||
*/
|
||||
iter = list_entry(mv_chan->chain.next,
|
||||
struct mv_xor_desc_slot,
|
||||
chain_node);
|
||||
mv_xor_start_new_chain(mv_chan, iter);
|
||||
} else {
|
||||
if (!list_is_last(&iter->chain_node, &mv_chan->chain)) {
|
||||
/*
|
||||
* descriptors are still waiting after
|
||||
* current, trigger them
|
||||
*/
|
||||
iter = list_entry(iter->chain_node.next,
|
||||
struct mv_xor_desc_slot,
|
||||
chain_node);
|
||||
mv_xor_start_new_chain(mv_chan, iter);
|
||||
} else {
|
||||
/*
|
||||
* some descriptors are still waiting
|
||||
* to be cleaned
|
||||
*/
|
||||
tasklet_schedule(&mv_chan->irq_tasklet);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (cookie > 0)
|
||||
|
|
|
@ -32,6 +32,7 @@
|
|||
#define XOR_OPERATION_MODE_XOR 0
|
||||
#define XOR_OPERATION_MODE_MEMCPY 2
|
||||
#define XOR_OPERATION_MODE_MEMSET 4
|
||||
#define XOR_DESC_SUCCESS 0x40000000
|
||||
|
||||
#define XOR_CURR_DESC(chan) (chan->mmr_base + 0x210 + (chan->idx * 4))
|
||||
#define XOR_NEXT_DESC(chan) (chan->mmr_base + 0x200 + (chan->idx * 4))
|
||||
|
|
|
@ -921,7 +921,7 @@ static int ppc4xx_edac_init_csrows(struct mem_ctl_info *mci, u32 mcopt1)
|
|||
*/
|
||||
|
||||
for (row = 0; row < mci->nr_csrows; row++) {
|
||||
struct csrow_info *csi = &mci->csrows[row];
|
||||
struct csrow_info *csi = mci->csrows[row];
|
||||
|
||||
/*
|
||||
* Get the configuration settings for this
|
||||
|
|
|
@ -1955,8 +1955,11 @@ int drm_mode_setcrtc(struct drm_device *dev, void *data,
|
|||
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
||||
return -EINVAL;
|
||||
|
||||
/* For some reason crtc x/y offsets are signed internally. */
|
||||
if (crtc_req->x > INT_MAX || crtc_req->y > INT_MAX)
|
||||
/*
|
||||
* Universal plane src offsets are only 16.16, prevent havoc for
|
||||
* drivers using universal plane code internally.
|
||||
*/
|
||||
if (crtc_req->x & 0xffff0000 || crtc_req->y & 0xffff0000)
|
||||
return -ERANGE;
|
||||
|
||||
drm_modeset_lock_all(dev);
|
||||
|
|
|
@ -58,6 +58,9 @@ int drm_lock(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
|||
struct drm_master *master = file_priv->master;
|
||||
int ret = 0;
|
||||
|
||||
if (drm_core_check_feature(dev, DRIVER_MODESET))
|
||||
return -EINVAL;
|
||||
|
||||
++file_priv->lock_count;
|
||||
|
||||
if (lock->context == DRM_KERNEL_CONTEXT) {
|
||||
|
@ -151,6 +154,9 @@ int drm_unlock(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
|||
struct drm_lock *lock = data;
|
||||
struct drm_master *master = file_priv->master;
|
||||
|
||||
if (drm_core_check_feature(dev, DRIVER_MODESET))
|
||||
return -EINVAL;
|
||||
|
||||
if (lock->context == DRM_KERNEL_CONTEXT) {
|
||||
DRM_ERROR("Process %d using kernel context %d\n",
|
||||
task_pid_nr(current), lock->context);
|
||||
|
|
|
@ -177,11 +177,12 @@ nouveau_gem_info(struct drm_file *file_priv, struct drm_gem_object *gem,
|
|||
struct nouveau_bo *nvbo = nouveau_gem_object(gem);
|
||||
struct nouveau_vma *vma;
|
||||
|
||||
if (nvbo->bo.mem.mem_type == TTM_PL_TT)
|
||||
if (is_power_of_2(nvbo->valid_domains))
|
||||
rep->domain = nvbo->valid_domains;
|
||||
else if (nvbo->bo.mem.mem_type == TTM_PL_TT)
|
||||
rep->domain = NOUVEAU_GEM_DOMAIN_GART;
|
||||
else
|
||||
rep->domain = NOUVEAU_GEM_DOMAIN_VRAM;
|
||||
|
||||
rep->offset = nvbo->bo.offset;
|
||||
if (cli->base.vm) {
|
||||
vma = nouveau_bo_vma_find(nvbo, cli->base.vm);
|
||||
|
|
|
@ -500,6 +500,7 @@ int qxl_hw_surface_alloc(struct qxl_device *qdev,
|
|||
|
||||
cmd = (struct qxl_surface_cmd *)qxl_release_map(qdev, release);
|
||||
cmd->type = QXL_SURFACE_CMD_CREATE;
|
||||
cmd->flags = QXL_SURF_FLAG_KEEP_DATA;
|
||||
cmd->u.surface_create.format = surf->surf.format;
|
||||
cmd->u.surface_create.width = surf->surf.width;
|
||||
cmd->u.surface_create.height = surf->surf.height;
|
||||
|
|
|
@ -1271,10 +1271,15 @@ struct radeon_encoder_lvds *radeon_combios_get_lvds_info(struct radeon_encoder
|
|||
|
||||
if ((RBIOS16(tmp) == lvds->native_mode.hdisplay) &&
|
||||
(RBIOS16(tmp + 2) == lvds->native_mode.vdisplay)) {
|
||||
u32 hss = (RBIOS16(tmp + 21) - RBIOS16(tmp + 19) - 1) * 8;
|
||||
|
||||
if (hss > lvds->native_mode.hdisplay)
|
||||
hss = (10 - 1) * 8;
|
||||
|
||||
lvds->native_mode.htotal = lvds->native_mode.hdisplay +
|
||||
(RBIOS16(tmp + 17) - RBIOS16(tmp + 19)) * 8;
|
||||
lvds->native_mode.hsync_start = lvds->native_mode.hdisplay +
|
||||
(RBIOS16(tmp + 21) - RBIOS16(tmp + 19) - 1) * 8;
|
||||
hss;
|
||||
lvds->native_mode.hsync_end = lvds->native_mode.hsync_start +
|
||||
(RBIOS8(tmp + 23) * 8);
|
||||
|
||||
|
@ -3398,6 +3403,14 @@ void radeon_combios_asic_init(struct drm_device *dev)
|
|||
rdev->pdev->subsystem_device == 0x30ae)
|
||||
return;
|
||||
|
||||
/* quirk for rs4xx HP Compaq dc5750 Small Form Factor to make it resume
|
||||
* - it hangs on resume inside the dynclk 1 table.
|
||||
*/
|
||||
if (rdev->family == CHIP_RS480 &&
|
||||
rdev->pdev->subsystem_vendor == 0x103c &&
|
||||
rdev->pdev->subsystem_device == 0x280a)
|
||||
return;
|
||||
|
||||
/* DYN CLK 1 */
|
||||
table = combios_get_table_offset(dev, COMBIOS_DYN_CLK_1_TABLE);
|
||||
if (table)
|
||||
|
|
|
@ -78,6 +78,11 @@ void radeon_connector_hotplug(struct drm_connector *connector)
|
|||
if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
|
||||
drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF);
|
||||
} else if (radeon_dp_needs_link_train(radeon_connector)) {
|
||||
/* Don't try to start link training before we
|
||||
* have the dpcd */
|
||||
if (!radeon_dp_getdpcd(radeon_connector))
|
||||
return;
|
||||
|
||||
/* set it to OFF so that drm_helper_connector_dpms()
|
||||
* won't return immediately since the current state
|
||||
* is ON at this point.
|
||||
|
|
|
@ -251,8 +251,10 @@ void radeon_gart_unbind(struct radeon_device *rdev, unsigned offset,
|
|||
}
|
||||
}
|
||||
}
|
||||
mb();
|
||||
radeon_gart_tlb_flush(rdev);
|
||||
if (rdev->gart.ptr) {
|
||||
mb();
|
||||
radeon_gart_tlb_flush(rdev);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -294,8 +296,10 @@ int radeon_gart_bind(struct radeon_device *rdev, unsigned offset,
|
|||
}
|
||||
}
|
||||
}
|
||||
mb();
|
||||
radeon_gart_tlb_flush(rdev);
|
||||
if (rdev->gart.ptr) {
|
||||
mb();
|
||||
radeon_gart_tlb_flush(rdev);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -73,10 +73,12 @@ static void radeon_hotplug_work_func(struct work_struct *work)
|
|||
struct drm_mode_config *mode_config = &dev->mode_config;
|
||||
struct drm_connector *connector;
|
||||
|
||||
mutex_lock(&mode_config->mutex);
|
||||
if (mode_config->num_connector) {
|
||||
list_for_each_entry(connector, &mode_config->connector_list, head)
|
||||
radeon_connector_hotplug(connector);
|
||||
}
|
||||
mutex_unlock(&mode_config->mutex);
|
||||
/* Just fire off a uevent and let userspace tell us what to do */
|
||||
drm_helper_hpd_irq_event(dev);
|
||||
}
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue