mirror of
https://github.com/rd-stuffs/msm-4.14.git
synced 2025-02-20 11:45:48 +08:00
This is the 4.14.327 stable release
-----BEGIN PGP SIGNATURE-----
iQIzBAABCAAdFiEEZH8oZUiU471FcZm+ONu9yGCSaT4FAmUlqXsACgkQONu9yGCS
aT7KDQ//QlDFupXGqqqAkyOVgKr1eIP0/V6LarJFCRsHt+zTzdijtex7UrAX26R0
d8cN6oGZmuPJSRifvJkNI2zijVq/K/nYoN5+RA9+TjiYX7+kOsZcmWcjkwEfbDGZ
SMU13d7owzsqmM48pMQtPkqjxvo+3486icaiNLl+gEPex4BERVSX5k2Nu48J+JKX
kH4ebxCpiAqlCBXvz0cuR3Eto97cWJV7KiLGdgllhiCInDguIySA5GduPytvm4qx
+W+Ya1JN3lUxziODoFZ7eG1WrRaw4EigG1YQTvqafu3FVJcm/0Uxl1RHmeMDTcwP
vWmPHvrCR1x/vYEiAOmV5sOjDJSDKR/LZ8eVi2psgD3BTRo+ESOGtAj7rDyMyznU
02SzorFdRUm4VXJOjSnZer3Mv+0vLhXwIM2KYkdcDpXCnvfN3bIvlip17dI6p4yz
2/DxB82wr1C/OGPW/jQzKLpZh2JAT3N0Fmoy1R96UTa6tTdiGE7jS7xarwbPJnwZ
IuF45Vq4Y9FKI3xIn0+7FjbVi7O3X1z95b9v9SH8YoKhzAoKUaRh9RtoPjZmAJt3
s0JHeMMX7fPJl4C8mjMW1UGcAfysootll1/naGopgNXAl7qj8YrOWpQK8Pavn21q
AdoAwUOOsM9INMfDFpgJ89dgkixw1jeDSsHMEZtBAj3nWcjIj+8=
=ac+3
-----END PGP SIGNATURE-----
Merge 4.14.327 into android-4.14-stable
Changes in 4.14.327
NFS/pNFS: Report EINVAL errors from connect() to the server
ipv4: fix null-deref in ipv4_link_failure
powerpc/perf/hv-24x7: Update domain value check
dccp: fix dccp_v4_err()/dccp_v6_err() again
team: fix null-ptr-deref when team device type is changed
gpio: tb10x: Fix an error handling path in tb10x_gpio_probe()
i2c: mux: demux-pinctrl: check the return value of devm_kstrdup()
clk: tegra: fix error return case for recalc_rate
xtensa: boot: don't add include-dirs
xtensa: boot/lib: fix function prototypes
parisc: sba: Fix compile warning wrt list of SBA devices
parisc: iosapic.c: Fix sparse warnings
parisc: irq: Make irq_stack_union static to avoid sparse warning
selftests/ftrace: Correctly enable event in instance-event.tc
ring-buffer: Avoid softlockup in ring_buffer_resize()
ata: libata-eh: do not clear ATA_PFLAG_EH_PENDING in ata_eh_reset()
fbdev/sh7760fb: Depend on FB=y
ata: ahci: Drop pointless VPRINTK() calls and convert the remaining ones
ata: libahci: clear pending interrupt status
watchdog: iTCO_wdt: No need to stop the timer in probe
watchdog: iTCO_wdt: Set NO_REBOOT if the watchdog is not already running
serial: 8250_port: Check IRQ data before use
nilfs2: fix potential use after free in nilfs_gccache_submit_read_data()
ata: libata-scsi: ignore reserved bits for REPORT SUPPORTED OPERATION CODES
i2c: i801: unregister tco_pdev in i801_probe() error path
btrfs: properly report 0 avail for very full file systems
ata: libata-core: Fix ata_port_request_pm() locking
ata: libata-core: Fix port and device removal
ata: libata-sata: increase PMP SRST timeout to 10s
fs: binfmt_elf_efpic: fix personality for ELF-FDPIC
vc_screen: reload load of struct vc_data pointer in vcs_write() to avoid UAF
ext4: fix rec_len verify error
net/sched: sch_hfsc: Ensure inner classes have fsc curve
ata: libata: disallow dev-initiated LPM transitions to unsupported states
media: dvb: symbol fixup for dvb_attach() - again
scsi: zfcp: Fix a double put in zfcp_port_enqueue()
wifi: mwifiex: Fix tlv_buf_left calculation
ubi: Refuse attaching if mtd's erasesize is 0
wifi: mwifiex: Fix oob check condition in mwifiex_process_rx_packet
drivers/net: process the result of hdlc_open() and add call of hdlc_close() in uhdlc_close()
regmap: rbtree: Fix wrong register marked as in-cache when creating new node
scsi: target: core: Fix deadlock due to recursive locking
modpost: add missing else to the "of" check
ipv4, ipv6: Fix handling of transhdrlen in __ip{,6}_append_data()
net: usb: smsc75xx: Fix uninit-value access in __smsc75xx_read_reg
tcp: fix delayed ACKs for MSS boundary condition
sctp: update transport state when processing a dupcook packet
sctp: update hb timer immediately after users change hb_interval
cpupower: add Makefile dependencies for install targets
IB/mlx4: Fix the size of a buffer in add_port_entries()
gpio: aspeed: fix the GPIO number passed to pinctrl_gpio_set_config()
RDMA/cma: Fix truncation compilation warning in make_cma_ports
RDMA/mlx5: Fix NULL string error
parisc: Restore __ldcw_align for PA-RISC 2.0 processors
Revert "rtnetlink: Reject negative ifindexes in RTM_NEWLINK"
rtnetlink: Reject negative ifindexes in RTM_NEWLINK
xen/events: replace evtchn_rwlock with RCU
Linux 4.14.327
Change-Id: Id05d43bbb2482e858390f6cb31f43ba16c669675
Signed-off-by: Greg Kroah-Hartman <gregkh@google.com>
This commit is contained in:
Greg Kroah-Hartman
commit
27c2ecdf37
2
Makefile
2
Makefile
@ -1,7 +1,7 @@
|
||||
# SPDX-License-Identifier: GPL-2.0
|
||||
VERSION = 4
|
||||
PATCHLEVEL = 14
|
||||
SUBLEVEL = 326
|
||||
SUBLEVEL = 327
|
||||
EXTRAVERSION =
|
||||
NAME = Petit Gorille
|
||||
|
||||
|
||||
@ -2,14 +2,28 @@
|
||||
#ifndef __PARISC_LDCW_H
|
||||
#define __PARISC_LDCW_H
|
||||
|
||||
#ifndef CONFIG_PA20
|
||||
/* Because kmalloc only guarantees 8-byte alignment for kmalloc'd data,
|
||||
and GCC only guarantees 8-byte alignment for stack locals, we can't
|
||||
be assured of 16-byte alignment for atomic lock data even if we
|
||||
specify "__attribute ((aligned(16)))" in the type declaration. So,
|
||||
we use a struct containing an array of four ints for the atomic lock
|
||||
type and dynamically select the 16-byte aligned int from the array
|
||||
for the semaphore. */
|
||||
for the semaphore. */
|
||||
|
||||
/* From: "Jim Hull" <jim.hull of hp.com>
|
||||
I've attached a summary of the change, but basically, for PA 2.0, as
|
||||
long as the ",CO" (coherent operation) completer is implemented, then the
|
||||
16-byte alignment requirement for ldcw and ldcd is relaxed, and instead
|
||||
they only require "natural" alignment (4-byte for ldcw, 8-byte for
|
||||
ldcd).
|
||||
|
||||
Although the cache control hint is accepted by all PA 2.0 processors,
|
||||
it is only implemented on PA8800/PA8900 CPUs. Prior PA8X00 CPUs still
|
||||
require 16-byte alignment. If the address is unaligned, the operation
|
||||
of the instruction is undefined. The ldcw instruction does not generate
|
||||
unaligned data reference traps so misaligned accesses are not detected.
|
||||
This hid the problem for years. So, restore the 16-byte alignment dropped
|
||||
by Kyle McMartin in "Remove __ldcw_align for PA-RISC 2.0 processors". */
|
||||
|
||||
#define __PA_LDCW_ALIGNMENT 16
|
||||
#define __PA_LDCW_ALIGN_ORDER 4
|
||||
@ -19,22 +33,12 @@
|
||||
& ~(__PA_LDCW_ALIGNMENT - 1); \
|
||||
(volatile unsigned int *) __ret; \
|
||||
})
|
||||
#define __LDCW "ldcw"
|
||||
|
||||
#else /*CONFIG_PA20*/
|
||||
/* From: "Jim Hull" <jim.hull of hp.com>
|
||||
I've attached a summary of the change, but basically, for PA 2.0, as
|
||||
long as the ",CO" (coherent operation) completer is specified, then the
|
||||
16-byte alignment requirement for ldcw and ldcd is relaxed, and instead
|
||||
they only require "natural" alignment (4-byte for ldcw, 8-byte for
|
||||
ldcd). */
|
||||
|
||||
#define __PA_LDCW_ALIGNMENT 4
|
||||
#define __PA_LDCW_ALIGN_ORDER 2
|
||||
#define __ldcw_align(a) (&(a)->slock)
|
||||
#ifdef CONFIG_PA20
|
||||
#define __LDCW "ldcw,co"
|
||||
|
||||
#endif /*!CONFIG_PA20*/
|
||||
#else
|
||||
#define __LDCW "ldcw"
|
||||
#endif
|
||||
|
||||
/* LDCW, the only atomic read-write operation PA-RISC has. *sigh*.
|
||||
We don't explicitly expose that "*a" may be written as reload
|
||||
|
||||
@ -86,6 +86,9 @@ struct sba_device {
|
||||
struct ioc ioc[MAX_IOC];
|
||||
};
|
||||
|
||||
/* list of SBA's in system, see drivers/parisc/sba_iommu.c */
|
||||
extern struct sba_device *sba_list;
|
||||
|
||||
#define ASTRO_RUNWAY_PORT 0x582
|
||||
#define IKE_MERCED_PORT 0x803
|
||||
#define REO_MERCED_PORT 0x804
|
||||
|
||||
@ -3,13 +3,8 @@
|
||||
#define __ASM_SPINLOCK_TYPES_H
|
||||
|
||||
typedef struct {
|
||||
#ifdef CONFIG_PA20
|
||||
volatile unsigned int slock;
|
||||
# define __ARCH_SPIN_LOCK_UNLOCKED { 1 }
|
||||
#else
|
||||
volatile unsigned int lock[4];
|
||||
# define __ARCH_SPIN_LOCK_UNLOCKED { { 1, 1, 1, 1 } }
|
||||
#endif
|
||||
} arch_spinlock_t;
|
||||
|
||||
typedef struct {
|
||||
|
||||
@ -392,7 +392,7 @@ union irq_stack_union {
|
||||
volatile unsigned int lock[1];
|
||||
};
|
||||
|
||||
DEFINE_PER_CPU(union irq_stack_union, irq_stack_union) = {
|
||||
static DEFINE_PER_CPU(union irq_stack_union, irq_stack_union) = {
|
||||
.slock = { 1,1,1,1 },
|
||||
};
|
||||
#endif
|
||||
|
||||
@ -1326,7 +1326,7 @@ static int h_24x7_event_init(struct perf_event *event)
|
||||
}
|
||||
|
||||
domain = event_get_domain(event);
|
||||
if (domain >= HV_PERF_DOMAIN_MAX) {
|
||||
if (domain == 0 || domain >= HV_PERF_DOMAIN_MAX) {
|
||||
pr_devel("invalid domain %d\n", domain);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
@ -9,8 +9,7 @@
|
||||
|
||||
|
||||
# KBUILD_CFLAGS used when building rest of boot (takes effect recursively)
|
||||
KBUILD_CFLAGS += -fno-builtin -Iarch/$(ARCH)/boot/include
|
||||
HOSTFLAGS += -Iarch/$(ARCH)/boot/include
|
||||
KBUILD_CFLAGS += -fno-builtin
|
||||
|
||||
BIG_ENDIAN := $(shell echo __XTENSA_EB__ | $(CC) -E - | grep -v "\#")
|
||||
|
||||
|
||||
@ -4,13 +4,14 @@
|
||||
/* bits taken from ppc */
|
||||
|
||||
extern void *avail_ram, *end_avail;
|
||||
void gunzip(void *dst, int dstlen, unsigned char *src, int *lenp);
|
||||
|
||||
void exit (void)
|
||||
static void exit(void)
|
||||
{
|
||||
for (;;);
|
||||
}
|
||||
|
||||
void *zalloc(unsigned size)
|
||||
static void *zalloc(unsigned int size)
|
||||
{
|
||||
void *p = avail_ram;
|
||||
|
||||
|
||||
@ -670,7 +670,7 @@ static void ahci_pci_init_controller(struct ata_host *host)
|
||||
|
||||
/* clear port IRQ */
|
||||
tmp = readl(port_mmio + PORT_IRQ_STAT);
|
||||
VPRINTK("PORT_IRQ_STAT 0x%x\n", tmp);
|
||||
dev_dbg(&pdev->dev, "PORT_IRQ_STAT 0x%x\n", tmp);
|
||||
if (tmp)
|
||||
writel(tmp, port_mmio + PORT_IRQ_STAT);
|
||||
}
|
||||
@ -1480,7 +1480,6 @@ static irqreturn_t ahci_thunderx_irq_handler(int irq, void *dev_instance)
|
||||
u32 irq_stat, irq_masked;
|
||||
unsigned int handled = 1;
|
||||
|
||||
VPRINTK("ENTER\n");
|
||||
hpriv = host->private_data;
|
||||
mmio = hpriv->mmio;
|
||||
irq_stat = readl(mmio + HOST_IRQ_STAT);
|
||||
@ -1497,7 +1496,6 @@ static irqreturn_t ahci_thunderx_irq_handler(int irq, void *dev_instance)
|
||||
irq_stat = readl(mmio + HOST_IRQ_STAT);
|
||||
spin_unlock(&host->lock);
|
||||
} while (irq_stat);
|
||||
VPRINTK("EXIT\n");
|
||||
|
||||
return IRQ_RETVAL(handled);
|
||||
}
|
||||
@ -1777,6 +1775,15 @@ static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
|
||||
else
|
||||
dev_info(&pdev->dev, "SSS flag set, parallel bus scan disabled\n");
|
||||
|
||||
if (!(hpriv->cap & HOST_CAP_PART))
|
||||
host->flags |= ATA_HOST_NO_PART;
|
||||
|
||||
if (!(hpriv->cap & HOST_CAP_SSC))
|
||||
host->flags |= ATA_HOST_NO_SSC;
|
||||
|
||||
if (!(hpriv->cap2 & HOST_CAP2_SDS))
|
||||
host->flags |= ATA_HOST_NO_DEVSLP;
|
||||
|
||||
if (pi.flags & ATA_FLAG_EM)
|
||||
ahci_reset_em(host);
|
||||
|
||||
|
||||
@ -601,8 +601,6 @@ static irqreturn_t xgene_ahci_irq_intr(int irq, void *dev_instance)
|
||||
void __iomem *mmio;
|
||||
u32 irq_stat, irq_masked;
|
||||
|
||||
VPRINTK("ENTER\n");
|
||||
|
||||
hpriv = host->private_data;
|
||||
mmio = hpriv->mmio;
|
||||
|
||||
@ -625,8 +623,6 @@ static irqreturn_t xgene_ahci_irq_intr(int irq, void *dev_instance)
|
||||
|
||||
spin_unlock(&host->lock);
|
||||
|
||||
VPRINTK("EXIT\n");
|
||||
|
||||
return IRQ_RETVAL(rc);
|
||||
}
|
||||
|
||||
|
||||
@ -1196,6 +1196,26 @@ static ssize_t ahci_activity_show(struct ata_device *dev, char *buf)
|
||||
return sprintf(buf, "%d\n", emp->blink_policy);
|
||||
}
|
||||
|
||||
static void ahci_port_clear_pending_irq(struct ata_port *ap)
|
||||
{
|
||||
struct ahci_host_priv *hpriv = ap->host->private_data;
|
||||
void __iomem *port_mmio = ahci_port_base(ap);
|
||||
u32 tmp;
|
||||
|
||||
/* clear SError */
|
||||
tmp = readl(port_mmio + PORT_SCR_ERR);
|
||||
dev_dbg(ap->host->dev, "PORT_SCR_ERR 0x%x\n", tmp);
|
||||
writel(tmp, port_mmio + PORT_SCR_ERR);
|
||||
|
||||
/* clear port IRQ */
|
||||
tmp = readl(port_mmio + PORT_IRQ_STAT);
|
||||
dev_dbg(ap->host->dev, "PORT_IRQ_STAT 0x%x\n", tmp);
|
||||
if (tmp)
|
||||
writel(tmp, port_mmio + PORT_IRQ_STAT);
|
||||
|
||||
writel(1 << ap->port_no, hpriv->mmio + HOST_IRQ_STAT);
|
||||
}
|
||||
|
||||
static void ahci_port_init(struct device *dev, struct ata_port *ap,
|
||||
int port_no, void __iomem *mmio,
|
||||
void __iomem *port_mmio)
|
||||
@ -1210,18 +1230,7 @@ static void ahci_port_init(struct device *dev, struct ata_port *ap,
|
||||
if (rc)
|
||||
dev_warn(dev, "%s (%d)\n", emsg, rc);
|
||||
|
||||
/* clear SError */
|
||||
tmp = readl(port_mmio + PORT_SCR_ERR);
|
||||
VPRINTK("PORT_SCR_ERR 0x%x\n", tmp);
|
||||
writel(tmp, port_mmio + PORT_SCR_ERR);
|
||||
|
||||
/* clear port IRQ */
|
||||
tmp = readl(port_mmio + PORT_IRQ_STAT);
|
||||
VPRINTK("PORT_IRQ_STAT 0x%x\n", tmp);
|
||||
if (tmp)
|
||||
writel(tmp, port_mmio + PORT_IRQ_STAT);
|
||||
|
||||
writel(1 << port_no, mmio + HOST_IRQ_STAT);
|
||||
ahci_port_clear_pending_irq(ap);
|
||||
|
||||
/* mark esata ports */
|
||||
tmp = readl(port_mmio + PORT_CMD);
|
||||
@ -1248,10 +1257,10 @@ void ahci_init_controller(struct ata_host *host)
|
||||
}
|
||||
|
||||
tmp = readl(mmio + HOST_CTL);
|
||||
VPRINTK("HOST_CTL 0x%x\n", tmp);
|
||||
dev_dbg(host->dev, "HOST_CTL 0x%x\n", tmp);
|
||||
writel(tmp | HOST_IRQ_EN, mmio + HOST_CTL);
|
||||
tmp = readl(mmio + HOST_CTL);
|
||||
VPRINTK("HOST_CTL 0x%x\n", tmp);
|
||||
dev_dbg(host->dev, "HOST_CTL 0x%x\n", tmp);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(ahci_init_controller);
|
||||
|
||||
@ -1551,6 +1560,8 @@ int ahci_do_hardreset(struct ata_link *link, unsigned int *class,
|
||||
tf.command = ATA_BUSY;
|
||||
ata_tf_to_fis(&tf, 0, 0, d2h_fis);
|
||||
|
||||
ahci_port_clear_pending_irq(ap);
|
||||
|
||||
rc = sata_link_hardreset(link, timing, deadline, online,
|
||||
ahci_check_ready);
|
||||
|
||||
@ -1902,8 +1913,6 @@ static irqreturn_t ahci_multi_irqs_intr_hard(int irq, void *dev_instance)
|
||||
void __iomem *port_mmio = ahci_port_base(ap);
|
||||
u32 status;
|
||||
|
||||
VPRINTK("ENTER\n");
|
||||
|
||||
status = readl(port_mmio + PORT_IRQ_STAT);
|
||||
writel(status, port_mmio + PORT_IRQ_STAT);
|
||||
|
||||
@ -1911,8 +1920,6 @@ static irqreturn_t ahci_multi_irqs_intr_hard(int irq, void *dev_instance)
|
||||
ahci_handle_port_interrupt(ap, port_mmio, status);
|
||||
spin_unlock(ap->lock);
|
||||
|
||||
VPRINTK("EXIT\n");
|
||||
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
|
||||
@ -1929,9 +1936,7 @@ u32 ahci_handle_port_intr(struct ata_host *host, u32 irq_masked)
|
||||
ap = host->ports[i];
|
||||
if (ap) {
|
||||
ahci_port_intr(ap);
|
||||
VPRINTK("port %u\n", i);
|
||||
} else {
|
||||
VPRINTK("port %u (no irq)\n", i);
|
||||
if (ata_ratelimit())
|
||||
dev_warn(host->dev,
|
||||
"interrupt on disabled port %u\n", i);
|
||||
@ -1952,8 +1957,6 @@ static irqreturn_t ahci_single_level_irq_intr(int irq, void *dev_instance)
|
||||
void __iomem *mmio;
|
||||
u32 irq_stat, irq_masked;
|
||||
|
||||
VPRINTK("ENTER\n");
|
||||
|
||||
hpriv = host->private_data;
|
||||
mmio = hpriv->mmio;
|
||||
|
||||
@ -1981,8 +1984,6 @@ static irqreturn_t ahci_single_level_irq_intr(int irq, void *dev_instance)
|
||||
|
||||
spin_unlock(&host->lock);
|
||||
|
||||
VPRINTK("EXIT\n");
|
||||
|
||||
return IRQ_RETVAL(rc);
|
||||
}
|
||||
|
||||
|
||||
@ -3993,10 +3993,23 @@ int sata_link_scr_lpm(struct ata_link *link, enum ata_lpm_policy policy,
|
||||
scontrol |= (0x6 << 8);
|
||||
break;
|
||||
case ATA_LPM_MIN_POWER:
|
||||
if (ata_link_nr_enabled(link) > 0)
|
||||
/* no restrictions on LPM transitions */
|
||||
if (ata_link_nr_enabled(link) > 0) {
|
||||
/* assume no restrictions on LPM transitions */
|
||||
scontrol &= ~(0x7 << 8);
|
||||
else {
|
||||
|
||||
/*
|
||||
* If the controller does not support partial, slumber,
|
||||
* or devsleep, then disallow these transitions.
|
||||
*/
|
||||
if (link->ap->host->flags & ATA_HOST_NO_PART)
|
||||
scontrol |= (0x1 << 8);
|
||||
|
||||
if (link->ap->host->flags & ATA_HOST_NO_SSC)
|
||||
scontrol |= (0x2 << 8);
|
||||
|
||||
if (link->ap->host->flags & ATA_HOST_NO_DEVSLP)
|
||||
scontrol |= (0x4 << 8);
|
||||
} else {
|
||||
/* empty port, power off */
|
||||
scontrol &= ~0xf;
|
||||
scontrol |= (0x1 << 2);
|
||||
@ -5708,17 +5721,19 @@ static void ata_port_request_pm(struct ata_port *ap, pm_message_t mesg,
|
||||
struct ata_link *link;
|
||||
unsigned long flags;
|
||||
|
||||
/* Previous resume operation might still be in
|
||||
* progress. Wait for PM_PENDING to clear.
|
||||
*/
|
||||
if (ap->pflags & ATA_PFLAG_PM_PENDING) {
|
||||
ata_port_wait_eh(ap);
|
||||
WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING);
|
||||
}
|
||||
|
||||
/* request PM ops to EH */
|
||||
spin_lock_irqsave(ap->lock, flags);
|
||||
|
||||
/*
|
||||
* A previous PM operation might still be in progress. Wait for
|
||||
* ATA_PFLAG_PM_PENDING to clear.
|
||||
*/
|
||||
if (ap->pflags & ATA_PFLAG_PM_PENDING) {
|
||||
spin_unlock_irqrestore(ap->lock, flags);
|
||||
ata_port_wait_eh(ap);
|
||||
spin_lock_irqsave(ap->lock, flags);
|
||||
}
|
||||
|
||||
/* Request PM operation to EH */
|
||||
ap->pm_mesg = mesg;
|
||||
ap->pflags |= ATA_PFLAG_PM_PENDING;
|
||||
ata_for_each_link(link, ap, HOST_FIRST) {
|
||||
@ -5730,10 +5745,8 @@ static void ata_port_request_pm(struct ata_port *ap, pm_message_t mesg,
|
||||
|
||||
spin_unlock_irqrestore(ap->lock, flags);
|
||||
|
||||
if (!async) {
|
||||
if (!async)
|
||||
ata_port_wait_eh(ap);
|
||||
WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
@ -6672,11 +6685,30 @@ static void ata_port_detach(struct ata_port *ap)
|
||||
if (!ap->ops->error_handler)
|
||||
goto skip_eh;
|
||||
|
||||
/* tell EH we're leaving & flush EH */
|
||||
/* Wait for any ongoing EH */
|
||||
ata_port_wait_eh(ap);
|
||||
|
||||
mutex_lock(&ap->scsi_scan_mutex);
|
||||
spin_lock_irqsave(ap->lock, flags);
|
||||
|
||||
/* Remove scsi devices */
|
||||
ata_for_each_link(link, ap, HOST_FIRST) {
|
||||
ata_for_each_dev(dev, link, ALL) {
|
||||
if (dev->sdev) {
|
||||
spin_unlock_irqrestore(ap->lock, flags);
|
||||
scsi_remove_device(dev->sdev);
|
||||
spin_lock_irqsave(ap->lock, flags);
|
||||
dev->sdev = NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Tell EH to disable all devices */
|
||||
ap->pflags |= ATA_PFLAG_UNLOADING;
|
||||
ata_port_schedule_eh(ap);
|
||||
|
||||
spin_unlock_irqrestore(ap->lock, flags);
|
||||
mutex_unlock(&ap->scsi_scan_mutex);
|
||||
|
||||
/* wait till EH commits suicide */
|
||||
ata_port_wait_eh(ap);
|
||||
|
||||
@ -2948,18 +2948,11 @@ int ata_eh_reset(struct ata_link *link, int classify,
|
||||
postreset(slave, classes);
|
||||
}
|
||||
|
||||
/*
|
||||
* Some controllers can't be frozen very well and may set spurious
|
||||
* error conditions during reset. Clear accumulated error
|
||||
* information and re-thaw the port if frozen. As reset is the
|
||||
* final recovery action and we cross check link onlineness against
|
||||
* device classification later, no hotplug event is lost by this.
|
||||
*/
|
||||
/* clear cached SError */
|
||||
spin_lock_irqsave(link->ap->lock, flags);
|
||||
memset(&link->eh_info, 0, sizeof(link->eh_info));
|
||||
link->eh_info.serror = 0;
|
||||
if (slave)
|
||||
memset(&slave->eh_info, 0, sizeof(link->eh_info));
|
||||
ap->pflags &= ~ATA_PFLAG_EH_PENDING;
|
||||
slave->eh_info.serror = 0;
|
||||
spin_unlock_irqrestore(link->ap->lock, flags);
|
||||
|
||||
if (ap->pflags & ATA_PFLAG_FROZEN)
|
||||
|
||||
@ -4562,7 +4562,7 @@ void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd)
|
||||
break;
|
||||
|
||||
case MAINTENANCE_IN:
|
||||
if (scsicmd[1] == MI_REPORT_SUPPORTED_OPERATION_CODES)
|
||||
if ((scsicmd[1] & 0x1f) == MI_REPORT_SUPPORTED_OPERATION_CODES)
|
||||
ata_scsi_rbuf_fill(&args, ata_scsiop_maint_in);
|
||||
else
|
||||
ata_scsi_set_invalid_field(dev, cmd, 1, 0xff);
|
||||
|
||||
@ -467,7 +467,8 @@ static int regcache_rbtree_write(struct regmap *map, unsigned int reg,
|
||||
if (!rbnode)
|
||||
return -ENOMEM;
|
||||
regcache_rbtree_set_register(map, rbnode,
|
||||
reg - rbnode->base_reg, value);
|
||||
(reg - rbnode->base_reg) / map->reg_stride,
|
||||
value);
|
||||
regcache_rbtree_insert(map, &rbtree_ctx->root, rbnode);
|
||||
rbtree_ctx->cached_rbnode = rbnode;
|
||||
}
|
||||
|
||||
@ -385,8 +385,6 @@ find_quicksilver(struct device *dev, void *data)
|
||||
static int __init
|
||||
parisc_agp_init(void)
|
||||
{
|
||||
extern struct sba_device *sba_list;
|
||||
|
||||
int err = -1;
|
||||
struct parisc_device *sba = NULL, *lba = NULL;
|
||||
struct lba_device *lbadev = NULL;
|
||||
|
||||
@ -154,7 +154,7 @@ static unsigned long tegra_bpmp_clk_recalc_rate(struct clk_hw *hw,
|
||||
|
||||
err = tegra_bpmp_clk_transfer(clk->bpmp, &msg);
|
||||
if (err < 0)
|
||||
return err;
|
||||
return 0;
|
||||
|
||||
return response.rate;
|
||||
}
|
||||
|
||||
@ -763,7 +763,7 @@ static int aspeed_gpio_set_config(struct gpio_chip *chip, unsigned int offset,
|
||||
else if (param == PIN_CONFIG_BIAS_DISABLE ||
|
||||
param == PIN_CONFIG_BIAS_PULL_DOWN ||
|
||||
param == PIN_CONFIG_DRIVE_STRENGTH)
|
||||
return pinctrl_gpio_set_config(offset, config);
|
||||
return pinctrl_gpio_set_config(chip->base + offset, config);
|
||||
else if (param == PIN_CONFIG_DRIVE_OPEN_DRAIN ||
|
||||
param == PIN_CONFIG_DRIVE_OPEN_SOURCE)
|
||||
/* Return -ENOTSUPP to trigger emulation, as per datasheet */
|
||||
|
||||
@ -244,7 +244,7 @@ static int tb10x_gpio_probe(struct platform_device *pdev)
|
||||
handle_edge_irq, IRQ_NOREQUEST, IRQ_NOPROBE,
|
||||
IRQ_GC_INIT_MASK_CACHE);
|
||||
if (ret)
|
||||
return ret;
|
||||
goto err_remove_domain;
|
||||
|
||||
gc = tb10x_gpio->domain->gc->gc[0];
|
||||
gc->reg_base = tb10x_gpio->base;
|
||||
@ -258,6 +258,10 @@ static int tb10x_gpio_probe(struct platform_device *pdev)
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
err_remove_domain:
|
||||
irq_domain_remove(tb10x_gpio->domain);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int tb10x_gpio_remove(struct platform_device *pdev)
|
||||
|
||||
@ -1670,6 +1670,7 @@ static int i801_probe(struct pci_dev *dev, const struct pci_device_id *id)
|
||||
"SMBus I801 adapter at %04lx", priv->smba);
|
||||
err = i2c_add_adapter(&priv->adapter);
|
||||
if (err) {
|
||||
platform_device_unregister(priv->tco_pdev);
|
||||
i801_acpi_remove(priv);
|
||||
return err;
|
||||
}
|
||||
|
||||
@ -243,6 +243,10 @@ static int i2c_demux_pinctrl_probe(struct platform_device *pdev)
|
||||
|
||||
props[i].name = devm_kstrdup(&pdev->dev, "status", GFP_KERNEL);
|
||||
props[i].value = devm_kstrdup(&pdev->dev, "ok", GFP_KERNEL);
|
||||
if (!props[i].name || !props[i].value) {
|
||||
err = -ENOMEM;
|
||||
goto err_rollback;
|
||||
}
|
||||
props[i].length = 3;
|
||||
|
||||
of_changeset_init(&priv->chan[i].chgset);
|
||||
|
||||
@ -215,7 +215,7 @@ static int make_cma_ports(struct cma_dev_group *cma_dev_group,
|
||||
}
|
||||
|
||||
for (i = 0; i < ports_num; i++) {
|
||||
char port_str[10];
|
||||
char port_str[11];
|
||||
|
||||
ports[i].port_num = i + 1;
|
||||
snprintf(port_str, sizeof(port_str), "%u", i + 1);
|
||||
|
||||
@ -221,7 +221,7 @@ void del_sysfs_port_mcg_attr(struct mlx4_ib_dev *device, int port_num,
|
||||
static int add_port_entries(struct mlx4_ib_dev *device, int port_num)
|
||||
{
|
||||
int i;
|
||||
char buff[11];
|
||||
char buff[12];
|
||||
struct mlx4_ib_iov_port *port = NULL;
|
||||
int ret = 0 ;
|
||||
struct ib_port_attr attr;
|
||||
|
||||
@ -1680,7 +1680,7 @@ static inline char *mmap_cmd2str(enum mlx5_ib_mmap_cmd cmd)
|
||||
case MLX5_IB_MMAP_NC_PAGE:
|
||||
return "NC";
|
||||
default:
|
||||
return NULL;
|
||||
return "Unknown";
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -619,4 +619,4 @@ MODULE_DESCRIPTION("Spase SP8870 DVB-T Demodulator driver");
|
||||
MODULE_AUTHOR("Juergen Peitz");
|
||||
MODULE_LICENSE("GPL");
|
||||
|
||||
EXPORT_SYMBOL(sp8870_attach);
|
||||
EXPORT_SYMBOL_GPL(sp8870_attach);
|
||||
|
||||
@ -1516,7 +1516,7 @@ fail:
|
||||
return NULL;
|
||||
}
|
||||
|
||||
EXPORT_SYMBOL(xc2028_attach);
|
||||
EXPORT_SYMBOL_GPL(xc2028_attach);
|
||||
|
||||
MODULE_DESCRIPTION("Xceive xc2028/xc3028 tuner driver");
|
||||
MODULE_AUTHOR("Michel Ludwig <michel.ludwig@gmail.com>");
|
||||
|
||||
@ -869,6 +869,13 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num,
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* UBI cannot work on flashes with zero erasesize. */
|
||||
if (!mtd->erasesize) {
|
||||
pr_err("ubi: refuse attaching mtd%d - zero erasesize flash is not supported\n",
|
||||
mtd->index);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (ubi_num == UBI_DEV_NUM_AUTO) {
|
||||
/* Search for an empty slot in the @ubi_devices array */
|
||||
for (ubi_num = 0; ubi_num < UBI_MAX_DEVICES; ubi_num++)
|
||||
|
||||
@ -2087,7 +2087,12 @@ static const struct ethtool_ops team_ethtool_ops = {
|
||||
static void team_setup_by_port(struct net_device *dev,
|
||||
struct net_device *port_dev)
|
||||
{
|
||||
dev->header_ops = port_dev->header_ops;
|
||||
struct team *team = netdev_priv(dev);
|
||||
|
||||
if (port_dev->type == ARPHRD_ETHER)
|
||||
dev->header_ops = team->header_ops_cache;
|
||||
else
|
||||
dev->header_ops = port_dev->header_ops;
|
||||
dev->type = port_dev->type;
|
||||
dev->hard_header_len = port_dev->hard_header_len;
|
||||
dev->needed_headroom = port_dev->needed_headroom;
|
||||
@ -2134,8 +2139,11 @@ static int team_dev_type_check_change(struct net_device *dev,
|
||||
|
||||
static void team_setup(struct net_device *dev)
|
||||
{
|
||||
struct team *team = netdev_priv(dev);
|
||||
|
||||
ether_setup(dev);
|
||||
dev->max_mtu = ETH_MAX_MTU;
|
||||
team->header_ops_cache = dev->header_ops;
|
||||
|
||||
dev->netdev_ops = &team_netdev_ops;
|
||||
dev->ethtool_ops = &team_ethtool_ops;
|
||||
|
||||
@ -102,7 +102,9 @@ static int __must_check __smsc75xx_read_reg(struct usbnet *dev, u32 index,
|
||||
ret = fn(dev, USB_VENDOR_REQUEST_READ_REGISTER, USB_DIR_IN
|
||||
| USB_TYPE_VENDOR | USB_RECIP_DEVICE,
|
||||
0, index, &buf, 4);
|
||||
if (unlikely(ret < 0)) {
|
||||
if (unlikely(ret < 4)) {
|
||||
ret = ret < 0 ? ret : -ENODATA;
|
||||
|
||||
netdev_warn(dev->net, "Failed to read reg index 0x%08x: %d\n",
|
||||
index, ret);
|
||||
return ret;
|
||||
|
||||
@ -37,6 +37,8 @@
|
||||
|
||||
#define TDM_PPPOHT_SLIC_MAXIN
|
||||
|
||||
static int uhdlc_close(struct net_device *dev);
|
||||
|
||||
static struct ucc_tdm_info utdm_primary_info = {
|
||||
.uf_info = {
|
||||
.tsa = 0,
|
||||
@ -662,6 +664,7 @@ static int uhdlc_open(struct net_device *dev)
|
||||
hdlc_device *hdlc = dev_to_hdlc(dev);
|
||||
struct ucc_hdlc_private *priv = hdlc->priv;
|
||||
struct ucc_tdm *utdm = priv->utdm;
|
||||
int rc = 0;
|
||||
|
||||
if (priv->hdlc_busy != 1) {
|
||||
if (request_irq(priv->ut_info->uf_info.irq,
|
||||
@ -684,10 +687,13 @@ static int uhdlc_open(struct net_device *dev)
|
||||
netif_device_attach(priv->ndev);
|
||||
napi_enable(&priv->napi);
|
||||
netif_start_queue(dev);
|
||||
hdlc_open(dev);
|
||||
|
||||
rc = hdlc_open(dev);
|
||||
if (rc)
|
||||
uhdlc_close(dev);
|
||||
}
|
||||
|
||||
return 0;
|
||||
return rc;
|
||||
}
|
||||
|
||||
static void uhdlc_memclean(struct ucc_hdlc_private *priv)
|
||||
@ -776,6 +782,8 @@ static int uhdlc_close(struct net_device *dev)
|
||||
netif_stop_queue(dev);
|
||||
priv->hdlc_busy = 0;
|
||||
|
||||
hdlc_close(dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -992,8 +992,8 @@ void mwifiex_11n_rxba_sync_event(struct mwifiex_private *priv,
|
||||
}
|
||||
}
|
||||
|
||||
tlv_buf_left -= (sizeof(*tlv_rxba) + tlv_len);
|
||||
tmp = (u8 *)tlv_rxba + tlv_len + sizeof(*tlv_rxba);
|
||||
tlv_buf_left -= (sizeof(tlv_rxba->header) + tlv_len);
|
||||
tmp = (u8 *)tlv_rxba + sizeof(tlv_rxba->header) + tlv_len;
|
||||
tlv_rxba = (struct mwifiex_ie_types_rxba_sync *)tmp;
|
||||
}
|
||||
}
|
||||
|
||||
@ -98,7 +98,8 @@ int mwifiex_process_rx_packet(struct mwifiex_private *priv,
|
||||
rx_pkt_len = le16_to_cpu(local_rx_pd->rx_pkt_length);
|
||||
rx_pkt_hdr = (void *)local_rx_pd + rx_pkt_off;
|
||||
|
||||
if (sizeof(*rx_pkt_hdr) + rx_pkt_off > skb->len) {
|
||||
if (sizeof(rx_pkt_hdr->eth803_hdr) + sizeof(rfc1042_header) +
|
||||
rx_pkt_off > skb->len) {
|
||||
mwifiex_dbg(priv->adapter, ERROR,
|
||||
"wrong rx packet offset: len=%d, rx_pkt_off=%d\n",
|
||||
skb->len, rx_pkt_off);
|
||||
@ -107,12 +108,13 @@ int mwifiex_process_rx_packet(struct mwifiex_private *priv,
|
||||
return -1;
|
||||
}
|
||||
|
||||
if ((!memcmp(&rx_pkt_hdr->rfc1042_hdr, bridge_tunnel_header,
|
||||
sizeof(bridge_tunnel_header))) ||
|
||||
(!memcmp(&rx_pkt_hdr->rfc1042_hdr, rfc1042_header,
|
||||
sizeof(rfc1042_header)) &&
|
||||
ntohs(rx_pkt_hdr->rfc1042_hdr.snap_type) != ETH_P_AARP &&
|
||||
ntohs(rx_pkt_hdr->rfc1042_hdr.snap_type) != ETH_P_IPX)) {
|
||||
if (sizeof(*rx_pkt_hdr) + rx_pkt_off <= skb->len &&
|
||||
((!memcmp(&rx_pkt_hdr->rfc1042_hdr, bridge_tunnel_header,
|
||||
sizeof(bridge_tunnel_header))) ||
|
||||
(!memcmp(&rx_pkt_hdr->rfc1042_hdr, rfc1042_header,
|
||||
sizeof(rfc1042_header)) &&
|
||||
ntohs(rx_pkt_hdr->rfc1042_hdr.snap_type) != ETH_P_AARP &&
|
||||
ntohs(rx_pkt_hdr->rfc1042_hdr.snap_type) != ETH_P_IPX))) {
|
||||
/*
|
||||
* Replace the 803 header and rfc1042 header (llc/snap) with an
|
||||
* EthernetII header, keep the src/dst and snap_type
|
||||
|
||||
@ -216,9 +216,9 @@ static inline void iosapic_write(void __iomem *iosapic, unsigned int reg, u32 va
|
||||
|
||||
static DEFINE_SPINLOCK(iosapic_lock);
|
||||
|
||||
static inline void iosapic_eoi(void __iomem *addr, unsigned int data)
|
||||
static inline void iosapic_eoi(__le32 __iomem *addr, __le32 data)
|
||||
{
|
||||
__raw_writel(data, addr);
|
||||
__raw_writel((__force u32)data, addr);
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
@ -132,8 +132,8 @@ struct iosapic_irt {
|
||||
struct vector_info {
|
||||
struct iosapic_info *iosapic; /* I/O SAPIC this vector is on */
|
||||
struct irt_entry *irte; /* IRT entry */
|
||||
u32 __iomem *eoi_addr; /* precalculate EOI reg address */
|
||||
u32 eoi_data; /* IA64: ? PA: swapped txn_data */
|
||||
__le32 __iomem *eoi_addr; /* precalculate EOI reg address */
|
||||
__le32 eoi_data; /* IA64: ? PA: swapped txn_data */
|
||||
int txn_irq; /* virtual IRQ number for processor */
|
||||
ulong txn_addr; /* IA64: id_eid PA: partial HPA */
|
||||
u32 txn_data; /* CPU interrupt bit */
|
||||
|
||||
@ -492,12 +492,12 @@ struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, u64 wwpn,
|
||||
if (port) {
|
||||
put_device(&port->dev);
|
||||
retval = -EEXIST;
|
||||
goto err_out;
|
||||
goto err_put;
|
||||
}
|
||||
|
||||
port = kzalloc(sizeof(struct zfcp_port), GFP_KERNEL);
|
||||
if (!port)
|
||||
goto err_out;
|
||||
goto err_put;
|
||||
|
||||
rwlock_init(&port->unit_list_lock);
|
||||
INIT_LIST_HEAD(&port->unit_list);
|
||||
@ -520,7 +520,7 @@ struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, u64 wwpn,
|
||||
|
||||
if (dev_set_name(&port->dev, "0x%016llx", (unsigned long long)wwpn)) {
|
||||
kfree(port);
|
||||
goto err_out;
|
||||
goto err_put;
|
||||
}
|
||||
retval = -EINVAL;
|
||||
|
||||
@ -537,8 +537,9 @@ struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, u64 wwpn,
|
||||
|
||||
return port;
|
||||
|
||||
err_out:
|
||||
err_put:
|
||||
zfcp_ccw_adapter_put(adapter);
|
||||
err_out:
|
||||
return ERR_PTR(retval);
|
||||
}
|
||||
|
||||
|
||||
@ -906,7 +906,6 @@ struct se_device *target_find_device(int id, bool do_depend)
|
||||
EXPORT_SYMBOL(target_find_device);
|
||||
|
||||
struct devices_idr_iter {
|
||||
struct config_item *prev_item;
|
||||
int (*fn)(struct se_device *dev, void *data);
|
||||
void *data;
|
||||
};
|
||||
@ -916,11 +915,9 @@ static int target_devices_idr_iter(int id, void *p, void *data)
|
||||
{
|
||||
struct devices_idr_iter *iter = data;
|
||||
struct se_device *dev = p;
|
||||
struct config_item *item;
|
||||
int ret;
|
||||
|
||||
config_item_put(iter->prev_item);
|
||||
iter->prev_item = NULL;
|
||||
|
||||
/*
|
||||
* We add the device early to the idr, so it can be used
|
||||
* by backend modules during configuration. We do not want
|
||||
@ -930,12 +927,13 @@ static int target_devices_idr_iter(int id, void *p, void *data)
|
||||
if (!(dev->dev_flags & DF_CONFIGURED))
|
||||
return 0;
|
||||
|
||||
iter->prev_item = config_item_get_unless_zero(&dev->dev_group.cg_item);
|
||||
if (!iter->prev_item)
|
||||
item = config_item_get_unless_zero(&dev->dev_group.cg_item);
|
||||
if (!item)
|
||||
return 0;
|
||||
mutex_unlock(&device_mutex);
|
||||
|
||||
ret = iter->fn(dev, iter->data);
|
||||
config_item_put(item);
|
||||
|
||||
mutex_lock(&device_mutex);
|
||||
return ret;
|
||||
@ -958,7 +956,6 @@ int target_for_each_device(int (*fn)(struct se_device *dev, void *data),
|
||||
mutex_lock(&device_mutex);
|
||||
ret = idr_for_each(&devices_idr, target_devices_idr_iter, &iter);
|
||||
mutex_unlock(&device_mutex);
|
||||
config_item_put(iter.prev_item);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
@ -1911,7 +1911,10 @@ int serial8250_handle_irq(struct uart_port *port, unsigned int iir)
|
||||
skip_rx = true;
|
||||
|
||||
if (status & (UART_LSR_DR | UART_LSR_BI) && !skip_rx) {
|
||||
if (irqd_is_wakeup_set(irq_get_irq_data(port->irq)))
|
||||
struct irq_data *d;
|
||||
|
||||
d = irq_get_irq_data(port->irq);
|
||||
if (d && irqd_is_wakeup_set(d))
|
||||
pm_wakeup_event(tport->tty->dev, 0);
|
||||
if (!up->dma || handle_rx_dma(up, iir))
|
||||
status = serial8250_rx_chars(up, status);
|
||||
|
||||
@ -437,10 +437,17 @@ vcs_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
|
||||
}
|
||||
}
|
||||
|
||||
/* The vcs_size might have changed while we slept to grab
|
||||
* the user buffer, so recheck.
|
||||
/* The vc might have been freed or vcs_size might have changed
|
||||
* while we slept to grab the user buffer, so recheck.
|
||||
* Return data written up to now on failure.
|
||||
*/
|
||||
vc = vcs_vc(inode, &viewed);
|
||||
if (!vc) {
|
||||
if (written)
|
||||
break;
|
||||
ret = -ENXIO;
|
||||
goto unlock_out;
|
||||
}
|
||||
size = vcs_size(inode);
|
||||
if (size < 0) {
|
||||
if (written)
|
||||
|
||||
@ -2197,7 +2197,7 @@ config FB_COBALT
|
||||
|
||||
config FB_SH7760
|
||||
bool "SH7760/SH7763/SH7720/SH7721 LCDC support"
|
||||
depends on FB && (CPU_SUBTYPE_SH7760 || CPU_SUBTYPE_SH7763 \
|
||||
depends on FB=y && (CPU_SUBTYPE_SH7760 || CPU_SUBTYPE_SH7763 \
|
||||
|| CPU_SUBTYPE_SH7720 || CPU_SUBTYPE_SH7721)
|
||||
select FB_CFB_FILLRECT
|
||||
select FB_CFB_COPYAREA
|
||||
|
||||
@ -401,6 +401,20 @@ static unsigned int iTCO_wdt_get_timeleft(struct watchdog_device *wd_dev)
|
||||
return time_left;
|
||||
}
|
||||
|
||||
/* Returns true if the watchdog was running */
|
||||
static bool iTCO_wdt_set_running(struct iTCO_wdt_private *p)
|
||||
{
|
||||
u16 val;
|
||||
|
||||
/* Bit 11: TCO Timer Halt -> 0 = The TCO timer is enabled */
|
||||
val = inw(TCO1_CNT(p));
|
||||
if (!(val & BIT(11))) {
|
||||
set_bit(WDOG_HW_RUNNING, &p->wddev.status);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
* Kernel Interfaces
|
||||
*/
|
||||
@ -476,9 +490,6 @@ static int iTCO_wdt_probe(struct platform_device *pdev)
|
||||
return -ENODEV; /* Cannot reset NO_REBOOT bit */
|
||||
}
|
||||
|
||||
/* Set the NO_REBOOT bit to prevent later reboots, just for sure */
|
||||
p->update_no_reboot_bit(p->no_reboot_priv, true);
|
||||
|
||||
/* The TCO logic uses the TCO_EN bit in the SMI_EN register */
|
||||
if (!devm_request_region(dev, p->smi_res->start,
|
||||
resource_size(p->smi_res),
|
||||
@ -537,8 +548,13 @@ static int iTCO_wdt_probe(struct platform_device *pdev)
|
||||
watchdog_set_drvdata(&p->wddev, p);
|
||||
platform_set_drvdata(pdev, p);
|
||||
|
||||
/* Make sure the watchdog is not running */
|
||||
iTCO_wdt_stop(&p->wddev);
|
||||
if (!iTCO_wdt_set_running(p)) {
|
||||
/*
|
||||
* If the watchdog was not running set NO_REBOOT now to
|
||||
* prevent later reboots.
|
||||
*/
|
||||
p->update_no_reboot_bit(p->no_reboot_priv, true);
|
||||
}
|
||||
|
||||
/* Check that the heartbeat value is within it's range;
|
||||
if not reset to the default */
|
||||
|
||||
@ -82,23 +82,13 @@ const struct evtchn_ops *evtchn_ops;
|
||||
*/
|
||||
static DEFINE_MUTEX(irq_mapping_update_lock);
|
||||
|
||||
/*
|
||||
* Lock protecting event handling loop against removing event channels.
|
||||
* Adding of event channels is no issue as the associated IRQ becomes active
|
||||
* only after everything is setup (before request_[threaded_]irq() the handler
|
||||
* can't be entered for an event, as the event channel will be unmasked only
|
||||
* then).
|
||||
*/
|
||||
static DEFINE_RWLOCK(evtchn_rwlock);
|
||||
|
||||
/*
|
||||
* Lock hierarchy:
|
||||
*
|
||||
* irq_mapping_update_lock
|
||||
* evtchn_rwlock
|
||||
* IRQ-desc lock
|
||||
* percpu eoi_list_lock
|
||||
* irq_info->lock
|
||||
* IRQ-desc lock
|
||||
* percpu eoi_list_lock
|
||||
* irq_info->lock
|
||||
*/
|
||||
|
||||
static LIST_HEAD(xen_irq_list_head);
|
||||
@ -213,6 +203,29 @@ static void set_info_for_irq(unsigned int irq, struct irq_info *info)
|
||||
irq_set_chip_data(irq, info);
|
||||
}
|
||||
|
||||
static void delayed_free_irq(struct work_struct *work)
|
||||
{
|
||||
struct irq_info *info = container_of(work, struct irq_info,
|
||||
work);
|
||||
unsigned int irq = info->irq;
|
||||
|
||||
/* Remove the info pointer only now, with no potential users left. */
|
||||
set_info_for_irq(irq, NULL);
|
||||
|
||||
kfree(info);
|
||||
|
||||
/* Legacy IRQ descriptors are managed by the arch. */
|
||||
if (irq >= nr_legacy_irqs())
|
||||
irq_free_desc(irq);
|
||||
}
|
||||
|
||||
static void rcu_free_irq(struct rcu_head *rcu_head)
|
||||
{
|
||||
struct irq_info *info = container_of(rcu_head, struct irq_info, rcu);
|
||||
|
||||
queue_work(system_wq, &info->work);
|
||||
}
|
||||
|
||||
/* Constructors for packed IRQ information. */
|
||||
static int xen_irq_info_common_setup(struct irq_info *info,
|
||||
unsigned irq,
|
||||
@ -547,33 +560,36 @@ static void xen_irq_lateeoi_worker(struct work_struct *work)
|
||||
|
||||
eoi = container_of(to_delayed_work(work), struct lateeoi_work, delayed);
|
||||
|
||||
read_lock_irqsave(&evtchn_rwlock, flags);
|
||||
rcu_read_lock();
|
||||
|
||||
while (true) {
|
||||
spin_lock(&eoi->eoi_list_lock);
|
||||
spin_lock_irqsave(&eoi->eoi_list_lock, flags);
|
||||
|
||||
info = list_first_entry_or_null(&eoi->eoi_list, struct irq_info,
|
||||
eoi_list);
|
||||
|
||||
if (info == NULL || now < info->eoi_time) {
|
||||
spin_unlock(&eoi->eoi_list_lock);
|
||||
if (info == NULL)
|
||||
break;
|
||||
|
||||
if (now < info->eoi_time) {
|
||||
mod_delayed_work_on(info->eoi_cpu, system_wq,
|
||||
&eoi->delayed,
|
||||
info->eoi_time - now);
|
||||
break;
|
||||
}
|
||||
|
||||
list_del_init(&info->eoi_list);
|
||||
|
||||
spin_unlock(&eoi->eoi_list_lock);
|
||||
spin_unlock_irqrestore(&eoi->eoi_list_lock, flags);
|
||||
|
||||
info->eoi_time = 0;
|
||||
|
||||
xen_irq_lateeoi_locked(info, false);
|
||||
}
|
||||
|
||||
if (info)
|
||||
mod_delayed_work_on(info->eoi_cpu, system_wq,
|
||||
&eoi->delayed, info->eoi_time - now);
|
||||
spin_unlock_irqrestore(&eoi->eoi_list_lock, flags);
|
||||
|
||||
read_unlock_irqrestore(&evtchn_rwlock, flags);
|
||||
rcu_read_unlock();
|
||||
}
|
||||
|
||||
static void xen_cpu_init_eoi(unsigned int cpu)
|
||||
@ -588,16 +604,15 @@ static void xen_cpu_init_eoi(unsigned int cpu)
|
||||
void xen_irq_lateeoi(unsigned int irq, unsigned int eoi_flags)
|
||||
{
|
||||
struct irq_info *info;
|
||||
unsigned long flags;
|
||||
|
||||
read_lock_irqsave(&evtchn_rwlock, flags);
|
||||
rcu_read_lock();
|
||||
|
||||
info = info_for_irq(irq);
|
||||
|
||||
if (info)
|
||||
xen_irq_lateeoi_locked(info, eoi_flags & XEN_EOI_FLAG_SPURIOUS);
|
||||
|
||||
read_unlock_irqrestore(&evtchn_rwlock, flags);
|
||||
rcu_read_unlock();
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(xen_irq_lateeoi);
|
||||
|
||||
@ -616,6 +631,7 @@ static void xen_irq_init(unsigned irq)
|
||||
|
||||
info->type = IRQT_UNBOUND;
|
||||
info->refcnt = -1;
|
||||
INIT_WORK(&info->work, delayed_free_irq);
|
||||
|
||||
set_info_for_irq(irq, info);
|
||||
|
||||
@ -668,31 +684,18 @@ static int __must_check xen_allocate_irq_gsi(unsigned gsi)
|
||||
static void xen_free_irq(unsigned irq)
|
||||
{
|
||||
struct irq_info *info = info_for_irq(irq);
|
||||
unsigned long flags;
|
||||
|
||||
if (WARN_ON(!info))
|
||||
return;
|
||||
|
||||
write_lock_irqsave(&evtchn_rwlock, flags);
|
||||
|
||||
if (!list_empty(&info->eoi_list))
|
||||
lateeoi_list_del(info);
|
||||
|
||||
list_del(&info->list);
|
||||
|
||||
set_info_for_irq(irq, NULL);
|
||||
|
||||
WARN_ON(info->refcnt > 0);
|
||||
|
||||
write_unlock_irqrestore(&evtchn_rwlock, flags);
|
||||
|
||||
kfree(info);
|
||||
|
||||
/* Legacy IRQ descriptors are managed by the arch. */
|
||||
if (irq < nr_legacy_irqs())
|
||||
return;
|
||||
|
||||
irq_free_desc(irq);
|
||||
call_rcu(&info->rcu, rcu_free_irq);
|
||||
}
|
||||
|
||||
static void xen_evtchn_close(unsigned int port)
|
||||
@ -1603,7 +1606,14 @@ static void __xen_evtchn_do_upcall(void)
|
||||
unsigned count;
|
||||
struct evtchn_loop_ctrl ctrl = { 0 };
|
||||
|
||||
read_lock(&evtchn_rwlock);
|
||||
/*
|
||||
* When closing an event channel the associated IRQ must not be freed
|
||||
* until all cpus have left the event handling loop. This is ensured
|
||||
* by taking the rcu_read_lock() while handling events, as freeing of
|
||||
* the IRQ is handled via queue_rcu_work() _after_ closing the event
|
||||
* channel.
|
||||
*/
|
||||
rcu_read_lock();
|
||||
|
||||
do {
|
||||
vcpu_info->evtchn_upcall_pending = 0;
|
||||
@ -1620,7 +1630,7 @@ static void __xen_evtchn_do_upcall(void)
|
||||
} while (count != 1 || vcpu_info->evtchn_upcall_pending);
|
||||
|
||||
out:
|
||||
read_unlock(&evtchn_rwlock);
|
||||
rcu_read_unlock();
|
||||
|
||||
/*
|
||||
* Increment irq_epoch only now to defer EOIs only for
|
||||
|
||||
@ -8,6 +8,8 @@
|
||||
*/
|
||||
#ifndef __EVENTS_INTERNAL_H__
|
||||
#define __EVENTS_INTERNAL_H__
|
||||
#include <linux/rcupdate.h>
|
||||
#include <linux/workqueue.h>
|
||||
|
||||
/* Interrupt types. */
|
||||
enum xen_irq_type {
|
||||
@ -33,6 +35,8 @@ enum xen_irq_type {
|
||||
struct irq_info {
|
||||
struct list_head list;
|
||||
struct list_head eoi_list;
|
||||
struct rcu_head rcu;
|
||||
struct work_struct work;
|
||||
short refcnt;
|
||||
short spurious_cnt;
|
||||
short type; /* type */
|
||||
|
||||
@ -349,10 +349,9 @@ static int load_elf_fdpic_binary(struct linux_binprm *bprm)
|
||||
/* there's now no turning back... the old userspace image is dead,
|
||||
* defunct, deceased, etc.
|
||||
*/
|
||||
SET_PERSONALITY(exec_params.hdr);
|
||||
if (elf_check_fdpic(&exec_params.hdr))
|
||||
set_personality(PER_LINUX_FDPIC);
|
||||
else
|
||||
set_personality(PER_LINUX);
|
||||
current->personality |= PER_LINUX_FDPIC;
|
||||
if (elf_read_implies_exec(&exec_params.hdr, executable_stack))
|
||||
current->personality |= READ_IMPLIES_EXEC;
|
||||
|
||||
|
||||
@ -2138,7 +2138,7 @@ static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
|
||||
* calculated f_bavail.
|
||||
*/
|
||||
if (!mixed && block_rsv->space_info->full &&
|
||||
total_free_meta - thresh < block_rsv->size)
|
||||
(total_free_meta < thresh || total_free_meta - thresh < block_rsv->size))
|
||||
buf->f_bavail = 0;
|
||||
|
||||
buf->f_type = BTRFS_SUPER_MAGIC;
|
||||
|
||||
@ -324,17 +324,17 @@ static struct ext4_dir_entry_tail *get_dirent_tail(struct inode *inode,
|
||||
struct ext4_dir_entry *de)
|
||||
{
|
||||
struct ext4_dir_entry_tail *t;
|
||||
int blocksize = EXT4_BLOCK_SIZE(inode->i_sb);
|
||||
|
||||
#ifdef PARANOID
|
||||
struct ext4_dir_entry *d, *top;
|
||||
|
||||
d = de;
|
||||
top = (struct ext4_dir_entry *)(((void *)de) +
|
||||
(EXT4_BLOCK_SIZE(inode->i_sb) -
|
||||
sizeof(struct ext4_dir_entry_tail)));
|
||||
while (d < top && d->rec_len)
|
||||
(blocksize - sizeof(struct ext4_dir_entry_tail)));
|
||||
while (d < top && ext4_rec_len_from_disk(d->rec_len, blocksize))
|
||||
d = (struct ext4_dir_entry *)(((void *)d) +
|
||||
le16_to_cpu(d->rec_len));
|
||||
ext4_rec_len_from_disk(d->rec_len, blocksize));
|
||||
|
||||
if (d != top)
|
||||
return NULL;
|
||||
@ -345,7 +345,8 @@ static struct ext4_dir_entry_tail *get_dirent_tail(struct inode *inode,
|
||||
#endif
|
||||
|
||||
if (t->det_reserved_zero1 ||
|
||||
le16_to_cpu(t->det_rec_len) != sizeof(struct ext4_dir_entry_tail) ||
|
||||
(ext4_rec_len_from_disk(t->det_rec_len, blocksize) !=
|
||||
sizeof(struct ext4_dir_entry_tail)) ||
|
||||
t->det_reserved_zero2 ||
|
||||
t->det_reserved_ft != EXT4_FT_DIR_CSUM)
|
||||
return NULL;
|
||||
@ -427,13 +428,14 @@ static struct dx_countlimit *get_dx_countlimit(struct inode *inode,
|
||||
struct ext4_dir_entry *dp;
|
||||
struct dx_root_info *root;
|
||||
int count_offset;
|
||||
int blocksize = EXT4_BLOCK_SIZE(inode->i_sb);
|
||||
unsigned int rlen = ext4_rec_len_from_disk(dirent->rec_len, blocksize);
|
||||
|
||||
if (le16_to_cpu(dirent->rec_len) == EXT4_BLOCK_SIZE(inode->i_sb))
|
||||
if (rlen == blocksize)
|
||||
count_offset = 8;
|
||||
else if (le16_to_cpu(dirent->rec_len) == 12) {
|
||||
else if (rlen == 12) {
|
||||
dp = (struct ext4_dir_entry *)(((void *)dirent) + 12);
|
||||
if (le16_to_cpu(dp->rec_len) !=
|
||||
EXT4_BLOCK_SIZE(inode->i_sb) - 12)
|
||||
if (ext4_rec_len_from_disk(dp->rec_len, blocksize) != blocksize - 12)
|
||||
return NULL;
|
||||
root = (struct dx_root_info *)(((void *)dp + 12));
|
||||
if (root->reserved_zero ||
|
||||
@ -1284,6 +1286,7 @@ static int dx_make_map(struct inode *dir, struct buffer_head *bh,
|
||||
unsigned int buflen = bh->b_size;
|
||||
char *base = bh->b_data;
|
||||
struct dx_hash_info h = *hinfo;
|
||||
int blocksize = EXT4_BLOCK_SIZE(dir->i_sb);
|
||||
|
||||
if (ext4_has_metadata_csum(dir->i_sb))
|
||||
buflen -= sizeof(struct ext4_dir_entry_tail);
|
||||
@ -1300,11 +1303,12 @@ static int dx_make_map(struct inode *dir, struct buffer_head *bh,
|
||||
map_tail--;
|
||||
map_tail->hash = h.hash;
|
||||
map_tail->offs = ((char *) de - base)>>2;
|
||||
map_tail->size = le16_to_cpu(de->rec_len);
|
||||
map_tail->size = ext4_rec_len_from_disk(de->rec_len,
|
||||
blocksize);
|
||||
count++;
|
||||
cond_resched();
|
||||
}
|
||||
de = ext4_next_entry(de, dir->i_sb->s_blocksize);
|
||||
de = ext4_next_entry(de, blocksize);
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
@ -1195,6 +1195,7 @@ static void ff_layout_io_track_ds_error(struct pnfs_layout_segment *lseg,
|
||||
case -EPFNOSUPPORT:
|
||||
case -EPROTONOSUPPORT:
|
||||
case -EOPNOTSUPP:
|
||||
case -EINVAL:
|
||||
case -ECONNREFUSED:
|
||||
case -ECONNRESET:
|
||||
case -EHOSTDOWN:
|
||||
|
||||
@ -82,10 +82,8 @@ int nilfs_gccache_submit_read_data(struct inode *inode, sector_t blkoff,
|
||||
struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
|
||||
|
||||
err = nilfs_dat_translate(nilfs->ns_dat, vbn, &pbn);
|
||||
if (unlikely(err)) { /* -EIO, -ENOMEM, -ENOENT */
|
||||
brelse(bh);
|
||||
if (unlikely(err)) /* -EIO, -ENOMEM, -ENOENT */
|
||||
goto failed;
|
||||
}
|
||||
}
|
||||
|
||||
lock_buffer(bh);
|
||||
@ -111,6 +109,8 @@ int nilfs_gccache_submit_read_data(struct inode *inode, sector_t blkoff,
|
||||
failed:
|
||||
unlock_page(bh->b_page);
|
||||
put_page(bh->b_page);
|
||||
if (unlikely(err))
|
||||
brelse(bh);
|
||||
return err;
|
||||
}
|
||||
|
||||
|
||||
@ -178,6 +178,8 @@ struct team {
|
||||
struct net_device *dev; /* associated netdevice */
|
||||
struct team_pcpu_stats __percpu *pcpu_stats;
|
||||
|
||||
const struct header_ops *header_ops_cache;
|
||||
|
||||
struct mutex lock; /* used for overall locking, e.g. port lists write */
|
||||
|
||||
/*
|
||||
|
||||
@ -279,6 +279,10 @@ enum {
|
||||
ATA_HOST_PARALLEL_SCAN = (1 << 2), /* Ports on this host can be scanned in parallel */
|
||||
ATA_HOST_IGNORE_ATA = (1 << 3), /* Ignore ATA devices on this host. */
|
||||
|
||||
ATA_HOST_NO_PART = (1 << 4), /* Host does not support partial */
|
||||
ATA_HOST_NO_SSC = (1 << 5), /* Host does not support slumber */
|
||||
ATA_HOST_NO_DEVSLP = (1 << 6), /* Host does not support devslp */
|
||||
|
||||
/* bits 24:31 of host->flags are reserved for LLD specific flags */
|
||||
|
||||
/* various lengths of time */
|
||||
@ -312,7 +316,7 @@ enum {
|
||||
* advised to wait only for the following duration before
|
||||
* doing SRST.
|
||||
*/
|
||||
ATA_TMOUT_PMP_SRST_WAIT = 5000,
|
||||
ATA_TMOUT_PMP_SRST_WAIT = 10000,
|
||||
|
||||
/* When the LPM policy is set to ATA_LPM_MAX_POWER, there might
|
||||
* be a spurious PHY event, so ignore the first PHY event that
|
||||
|
||||
@ -1686,6 +1686,8 @@ int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size,
|
||||
err = -ENOMEM;
|
||||
goto out_err;
|
||||
}
|
||||
|
||||
cond_resched();
|
||||
}
|
||||
|
||||
get_online_cpus();
|
||||
|
||||
@ -2311,10 +2311,7 @@ static int rtnl_setlink(struct sk_buff *skb, struct nlmsghdr *nlh,
|
||||
ifm = nlmsg_data(nlh);
|
||||
if (ifm->ifi_index > 0)
|
||||
dev = __dev_get_by_index(net, ifm->ifi_index);
|
||||
else if (ifm->ifi_index < 0) {
|
||||
NL_SET_ERR_MSG(extack, "ifindex can't be negative");
|
||||
return -EINVAL;
|
||||
} else if (tb[IFLA_IFNAME])
|
||||
else if (tb[IFLA_IFNAME])
|
||||
dev = __dev_get_by_name(net, ifname);
|
||||
else
|
||||
goto errout;
|
||||
@ -2550,9 +2547,12 @@ replay:
|
||||
ifname[0] = '\0';
|
||||
|
||||
ifm = nlmsg_data(nlh);
|
||||
if (ifm->ifi_index > 0)
|
||||
if (ifm->ifi_index > 0) {
|
||||
dev = __dev_get_by_index(net, ifm->ifi_index);
|
||||
else {
|
||||
} else if (ifm->ifi_index < 0) {
|
||||
NL_SET_ERR_MSG(extack, "ifindex can't be negative");
|
||||
return -EINVAL;
|
||||
} else {
|
||||
if (ifname[0])
|
||||
dev = __dev_get_by_name(net, ifname);
|
||||
else
|
||||
|
||||
@ -247,13 +247,8 @@ static void dccp_v4_err(struct sk_buff *skb, u32 info)
|
||||
int err;
|
||||
struct net *net = dev_net(skb->dev);
|
||||
|
||||
/* For the first __dccp_basic_hdr_len() check, we only need dh->dccph_x,
|
||||
* which is in byte 7 of the dccp header.
|
||||
* Our caller (icmp_socket_deliver()) already pulled 8 bytes for us.
|
||||
*
|
||||
* Later on, we want to access the sequence number fields, which are
|
||||
* beyond 8 bytes, so we have to pskb_may_pull() ourselves.
|
||||
*/
|
||||
if (!pskb_may_pull(skb, offset + sizeof(*dh)))
|
||||
return;
|
||||
dh = (struct dccp_hdr *)(skb->data + offset);
|
||||
if (!pskb_may_pull(skb, offset + __dccp_basic_hdr_len(dh)))
|
||||
return;
|
||||
|
||||
@ -80,13 +80,8 @@ static void dccp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
|
||||
__u64 seq;
|
||||
struct net *net = dev_net(skb->dev);
|
||||
|
||||
/* For the first __dccp_basic_hdr_len() check, we only need dh->dccph_x,
|
||||
* which is in byte 7 of the dccp header.
|
||||
* Our caller (icmpv6_notify()) already pulled 8 bytes for us.
|
||||
*
|
||||
* Later on, we want to access the sequence number fields, which are
|
||||
* beyond 8 bytes, so we have to pskb_may_pull() ourselves.
|
||||
*/
|
||||
if (!pskb_may_pull(skb, offset + sizeof(*dh)))
|
||||
return;
|
||||
dh = (struct dccp_hdr *)(skb->data + offset);
|
||||
if (!pskb_may_pull(skb, offset + __dccp_basic_hdr_len(dh)))
|
||||
return;
|
||||
|
||||
@ -1221,6 +1221,7 @@ static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie)
|
||||
|
||||
static void ipv4_send_dest_unreach(struct sk_buff *skb)
|
||||
{
|
||||
struct net_device *dev;
|
||||
struct ip_options opt;
|
||||
int res;
|
||||
|
||||
@ -1238,7 +1239,8 @@ static void ipv4_send_dest_unreach(struct sk_buff *skb)
|
||||
opt.optlen = ip_hdr(skb)->ihl * 4 - sizeof(struct iphdr);
|
||||
|
||||
rcu_read_lock();
|
||||
res = __ip_options_compile(dev_net(skb->dev), &opt, skb, NULL);
|
||||
dev = skb->dev ? skb->dev : skb_rtable(skb)->dst.dev;
|
||||
res = __ip_options_compile(dev_net(dev), &opt, skb, NULL);
|
||||
rcu_read_unlock();
|
||||
|
||||
if (res)
|
||||
|
||||
@ -166,6 +166,19 @@ static void tcp_measure_rcv_mss(struct sock *sk, const struct sk_buff *skb)
|
||||
if (unlikely(len > icsk->icsk_ack.rcv_mss +
|
||||
MAX_TCP_OPTION_SPACE))
|
||||
tcp_gro_dev_warn(sk, skb, len);
|
||||
/* If the skb has a len of exactly 1*MSS and has the PSH bit
|
||||
* set then it is likely the end of an application write. So
|
||||
* more data may not be arriving soon, and yet the data sender
|
||||
* may be waiting for an ACK if cwnd-bound or using TX zero
|
||||
* copy. So we set ICSK_ACK_PUSHED here so that
|
||||
* tcp_cleanup_rbuf() will send an ACK immediately if the app
|
||||
* reads all of the data and is not ping-pong. If len > MSS
|
||||
* then this logic does not matter (and does not hurt) because
|
||||
* tcp_cleanup_rbuf() will always ACK immediately if the app
|
||||
* reads data and there is more than an MSS of unACKed data.
|
||||
*/
|
||||
if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_PSH)
|
||||
icsk->icsk_ack.pending |= ICSK_ACK_PUSHED;
|
||||
} else {
|
||||
/* Otherwise, we make more careful check taking into account,
|
||||
* that SACKs block is variable.
|
||||
|
||||
@ -531,7 +531,6 @@ static int l2tp_ip6_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
|
||||
*/
|
||||
if (len > INT_MAX - transhdrlen)
|
||||
return -EMSGSIZE;
|
||||
ulen = len + transhdrlen;
|
||||
|
||||
/* Mirror BSD error message compatibility */
|
||||
if (msg->msg_flags & MSG_OOB)
|
||||
@ -658,6 +657,7 @@ static int l2tp_ip6_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
|
||||
|
||||
back_from_confirm:
|
||||
lock_sock(sk);
|
||||
ulen = len + skb_queue_empty(&sk->sk_write_queue) ? transhdrlen : 0;
|
||||
err = ip6_append_data(sk, ip_generic_getfrag, msg,
|
||||
ulen, transhdrlen, &ipc6,
|
||||
&fl6, (struct rt6_info *)dst,
|
||||
|
||||
@ -1020,6 +1020,8 @@ hfsc_change_class(struct Qdisc *sch, u32 classid, u32 parentid,
|
||||
if (parent == NULL)
|
||||
return -ENOENT;
|
||||
}
|
||||
if (!(parent->cl_flags & HFSC_FSC) && parent != &q->root)
|
||||
return -EINVAL;
|
||||
|
||||
if (classid == 0 || TC_H_MAJ(classid ^ sch->handle) != 0)
|
||||
return -EINVAL;
|
||||
|
||||
@ -1204,8 +1204,7 @@ int sctp_assoc_update(struct sctp_association *asoc,
|
||||
/* Add any peer addresses from the new association. */
|
||||
list_for_each_entry(trans, &new->peer.transport_addr_list,
|
||||
transports)
|
||||
if (!sctp_assoc_lookup_paddr(asoc, &trans->ipaddr) &&
|
||||
!sctp_assoc_add_peer(asoc, &trans->ipaddr,
|
||||
if (!sctp_assoc_add_peer(asoc, &trans->ipaddr,
|
||||
GFP_ATOMIC, trans->state))
|
||||
return -ENOMEM;
|
||||
|
||||
|
||||
@ -2479,6 +2479,7 @@ static int sctp_apply_peer_addr_params(struct sctp_paddrparams *params,
|
||||
if (trans) {
|
||||
trans->hbinterval =
|
||||
msecs_to_jiffies(params->spp_hbinterval);
|
||||
sctp_transport_reset_hb_timer(trans);
|
||||
} else if (asoc) {
|
||||
asoc->hbinterval =
|
||||
msecs_to_jiffies(params->spp_hbinterval);
|
||||
|
||||
@ -1331,7 +1331,7 @@ void handle_moddevtable(struct module *mod, struct elf_info *info,
|
||||
/* First handle the "special" cases */
|
||||
if (sym_is(name, namelen, "usb"))
|
||||
do_usb_table(symval, sym->st_size, mod);
|
||||
if (sym_is(name, namelen, "of"))
|
||||
else if (sym_is(name, namelen, "of"))
|
||||
do_of_table(symval, sym->st_size, mod);
|
||||
else if (sym_is(name, namelen, "pnp"))
|
||||
do_pnp_device_entry(symval, sym->st_size, mod);
|
||||
|
||||
@ -272,14 +272,14 @@ clean:
|
||||
$(MAKE) -C bench O=$(OUTPUT) clean
|
||||
|
||||
|
||||
install-lib:
|
||||
install-lib: libcpupower
|
||||
$(INSTALL) -d $(DESTDIR)${libdir}
|
||||
$(CP) $(OUTPUT)libcpupower.so* $(DESTDIR)${libdir}/
|
||||
$(INSTALL) -d $(DESTDIR)${includedir}
|
||||
$(INSTALL_DATA) lib/cpufreq.h $(DESTDIR)${includedir}/cpufreq.h
|
||||
$(INSTALL_DATA) lib/cpuidle.h $(DESTDIR)${includedir}/cpuidle.h
|
||||
|
||||
install-tools:
|
||||
install-tools: $(OUTPUT)cpupower
|
||||
$(INSTALL) -d $(DESTDIR)${bindir}
|
||||
$(INSTALL_PROGRAM) $(OUTPUT)cpupower $(DESTDIR)${bindir}
|
||||
|
||||
@ -293,14 +293,14 @@ install-man:
|
||||
$(INSTALL_DATA) -D man/cpupower-info.1 $(DESTDIR)${mandir}/man1/cpupower-info.1
|
||||
$(INSTALL_DATA) -D man/cpupower-monitor.1 $(DESTDIR)${mandir}/man1/cpupower-monitor.1
|
||||
|
||||
install-gmo:
|
||||
install-gmo: create-gmo
|
||||
$(INSTALL) -d $(DESTDIR)${localedir}
|
||||
for HLANG in $(LANGUAGES); do \
|
||||
echo '$(INSTALL_DATA) -D $(OUTPUT)po/$$HLANG.gmo $(DESTDIR)${localedir}/$$HLANG/LC_MESSAGES/cpupower.mo'; \
|
||||
$(INSTALL_DATA) -D $(OUTPUT)po/$$HLANG.gmo $(DESTDIR)${localedir}/$$HLANG/LC_MESSAGES/cpupower.mo; \
|
||||
done;
|
||||
|
||||
install-bench:
|
||||
install-bench: compile-bench
|
||||
@#DESTDIR must be set from outside to survive
|
||||
@sbindir=$(sbindir) bindir=$(bindir) docdir=$(docdir) confdir=$(confdir) $(MAKE) -C bench O=$(OUTPUT) install
|
||||
|
||||
|
||||
@ -27,7 +27,7 @@ $(OUTPUT)cpufreq-bench: $(OBJS)
|
||||
|
||||
all: $(OUTPUT)cpufreq-bench
|
||||
|
||||
install:
|
||||
install: $(OUTPUT)cpufreq-bench
|
||||
mkdir -p $(DESTDIR)/$(sbindir)
|
||||
mkdir -p $(DESTDIR)/$(bindir)
|
||||
mkdir -p $(DESTDIR)/$(docdir)
|
||||
|
||||
@ -43,7 +43,7 @@ instance_read() {
|
||||
|
||||
instance_set() {
|
||||
while :; do
|
||||
echo 1 > foo/events/sched/sched_switch
|
||||
echo 1 > foo/events/sched/sched_switch/enable
|
||||
done 2> /dev/null
|
||||
}
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user