This is the 3.10.98 stable release
-----BEGIN PGP SIGNATURE----- Version: GnuPG v2 iQIcBAABCAAGBQJWz1zgAAoJEDjbvchgkmk+yU8P/10DITNzrhCfz5wbhvvn9Uvo 7H1DziOora3u9h8/rz6xqgFEz2/9cZ03KoLcpGha7kEFBsvgVhN3uSI0YFpVV2mT 8/oh1ADdkky3Pld0f7gDGydDvrmgqx83/69SQ8hDQ8Mr2QTaKNvK05QGC2/EO9kI OcUAXjdAGglmf5rfhNhXodG/F2DtsA55uCzeyuBhcPE3bM7d4/48pwr1b2tW2CR8 hsprRvSz+kGgHXQy8jYdxKEI66OC/i22xVnxEc8PZmPZ0fFfmszzc9nzhcseWfpe 0JGgfwAtM8Va+bX4kfvqPpc2qR0r8Z2iEKNnAHnGutOvSWvow0l1OEedsb/+s1J6 /AYlPIkgTxwLDAwBIymPgowkEMOPVZzPL0tkoZI8wjB+eqUxxLlIa2dNByCyUs/U 1xTy+0UDMMDXG911mJl+yZFvd4R7lQUavIEStmMQ+A/Go2KrATaqIM8WETBlm7oH s3hZ3E+RBWmfD/6JQwsJNkwv6yWeaRXNE+bj8C1r/uBdPyGqX9T22OaIOlio+I71 XBNEM5mrTlNeNVIUIKW29qmLBxBrH2LLwpv/dRyfOfzfhi1B+dl9+3sJauvrSmWi jrR1khGmmaZcfOT2DVmpwlDQCQcyMcy8S8RTTAHhhuNmWtSjdc3TcfRlHXvP0sOu ruXBufxernb94E7sqsvF =LW9r -----END PGP SIGNATURE----- Merge tag 'v3.10.98' into HEAD This is the 3.10.98 stable release
This commit is contained in:
commit
f0bb324d50
2
Makefile
2
Makefile
|
@ -1,6 +1,6 @@
|
|||
VERSION = 3
|
||||
PATCHLEVEL = 10
|
||||
SUBLEVEL = 97
|
||||
SUBLEVEL = 98
|
||||
EXTRAVERSION =
|
||||
NAME = TOSSUG Baby Fish
|
||||
|
||||
|
|
|
@ -16,7 +16,7 @@
|
|||
*/
|
||||
#include <linux/module.h>
|
||||
#include <linux/kernel.h>
|
||||
|
||||
#include <asm/div64.h>
|
||||
#include <asm/hardware/icst.h>
|
||||
|
||||
/*
|
||||
|
@ -29,7 +29,11 @@ EXPORT_SYMBOL(icst525_s2div);
|
|||
|
||||
unsigned long icst_hz(const struct icst_params *p, struct icst_vco vco)
|
||||
{
|
||||
return p->ref * 2 * (vco.v + 8) / ((vco.r + 2) * p->s2div[vco.s]);
|
||||
u64 dividend = p->ref * 2 * (u64)(vco.v + 8);
|
||||
u32 divisor = (vco.r + 2) * p->s2div[vco.s];
|
||||
|
||||
do_div(dividend, divisor);
|
||||
return (unsigned long)dividend;
|
||||
}
|
||||
|
||||
EXPORT_SYMBOL(icst_hz);
|
||||
|
@ -58,6 +62,7 @@ icst_hz_to_vco(const struct icst_params *p, unsigned long freq)
|
|||
|
||||
if (f > p->vco_min && f <= p->vco_max)
|
||||
break;
|
||||
i++;
|
||||
} while (i < 8);
|
||||
|
||||
if (i >= 8)
|
||||
|
|
|
@ -81,7 +81,10 @@ static struct resource code_resource = {
|
|||
};
|
||||
|
||||
unsigned long memory_start;
|
||||
EXPORT_SYMBOL(memory_start);
|
||||
|
||||
unsigned long memory_end;
|
||||
EXPORT_SYMBOL(memory_end);
|
||||
|
||||
void __init setup_arch(char **);
|
||||
int get_cpuinfo(char *);
|
||||
|
|
|
@ -212,8 +212,19 @@
|
|||
#define TLS_SIZE (GDT_ENTRY_TLS_ENTRIES * 8)
|
||||
|
||||
#ifdef __KERNEL__
|
||||
|
||||
/*
|
||||
* early_idt_handler_array is an array of entry points referenced in the
|
||||
* early IDT. For simplicity, it's a real array with one entry point
|
||||
* every nine bytes. That leaves room for an optional 'push $0' if the
|
||||
* vector has no error code (two bytes), a 'push $vector_number' (two
|
||||
* bytes), and a jump to the common entry code (up to five bytes).
|
||||
*/
|
||||
#define EARLY_IDT_HANDLER_SIZE 9
|
||||
|
||||
#ifndef __ASSEMBLY__
|
||||
extern const char early_idt_handlers[NUM_EXCEPTION_VECTORS][2+2+5];
|
||||
|
||||
extern const char early_idt_handler_array[NUM_EXCEPTION_VECTORS][EARLY_IDT_HANDLER_SIZE];
|
||||
|
||||
/*
|
||||
* Load a segment. Fall back on loading the zero
|
||||
|
|
|
@ -165,7 +165,7 @@ void __init x86_64_start_kernel(char * real_mode_data)
|
|||
clear_bss();
|
||||
|
||||
for (i = 0; i < NUM_EXCEPTION_VECTORS; i++)
|
||||
set_intr_gate(i, &early_idt_handlers[i]);
|
||||
set_intr_gate(i, &early_idt_handler_array[i]);
|
||||
load_idt((const struct desc_ptr *)&idt_descr);
|
||||
|
||||
copy_bootdata(__va(real_mode_data));
|
||||
|
|
|
@ -499,21 +499,22 @@ check_x87:
|
|||
__INIT
|
||||
setup_once:
|
||||
/*
|
||||
* Set up a idt with 256 entries pointing to ignore_int,
|
||||
* interrupt gates. It doesn't actually load idt - that needs
|
||||
* to be done on each CPU. Interrupts are enabled elsewhere,
|
||||
* when we can be relatively sure everything is ok.
|
||||
* Set up a idt with 256 interrupt gates that push zero if there
|
||||
* is no error code and then jump to early_idt_handler_common.
|
||||
* It doesn't actually load the idt - that needs to be done on
|
||||
* each CPU. Interrupts are enabled elsewhere, when we can be
|
||||
* relatively sure everything is ok.
|
||||
*/
|
||||
|
||||
movl $idt_table,%edi
|
||||
movl $early_idt_handlers,%eax
|
||||
movl $early_idt_handler_array,%eax
|
||||
movl $NUM_EXCEPTION_VECTORS,%ecx
|
||||
1:
|
||||
movl %eax,(%edi)
|
||||
movl %eax,4(%edi)
|
||||
/* interrupt gate, dpl=0, present */
|
||||
movl $(0x8E000000 + __KERNEL_CS),2(%edi)
|
||||
addl $9,%eax
|
||||
addl $EARLY_IDT_HANDLER_SIZE,%eax
|
||||
addl $8,%edi
|
||||
loop 1b
|
||||
|
||||
|
@ -545,26 +546,28 @@ setup_once:
|
|||
andl $0,setup_once_ref /* Once is enough, thanks */
|
||||
ret
|
||||
|
||||
ENTRY(early_idt_handlers)
|
||||
ENTRY(early_idt_handler_array)
|
||||
# 36(%esp) %eflags
|
||||
# 32(%esp) %cs
|
||||
# 28(%esp) %eip
|
||||
# 24(%rsp) error code
|
||||
i = 0
|
||||
.rept NUM_EXCEPTION_VECTORS
|
||||
.if (EXCEPTION_ERRCODE_MASK >> i) & 1
|
||||
ASM_NOP2
|
||||
.else
|
||||
.ifeq (EXCEPTION_ERRCODE_MASK >> i) & 1
|
||||
pushl $0 # Dummy error code, to make stack frame uniform
|
||||
.endif
|
||||
pushl $i # 20(%esp) Vector number
|
||||
jmp early_idt_handler
|
||||
jmp early_idt_handler_common
|
||||
i = i + 1
|
||||
.fill early_idt_handler_array + i*EARLY_IDT_HANDLER_SIZE - ., 1, 0xcc
|
||||
.endr
|
||||
ENDPROC(early_idt_handlers)
|
||||
ENDPROC(early_idt_handler_array)
|
||||
|
||||
/* This is global to keep gas from relaxing the jumps */
|
||||
ENTRY(early_idt_handler)
|
||||
early_idt_handler_common:
|
||||
/*
|
||||
* The stack is the hardware frame, an error code or zero, and the
|
||||
* vector number.
|
||||
*/
|
||||
cld
|
||||
|
||||
cmpl $2,(%esp) # X86_TRAP_NMI
|
||||
|
@ -624,7 +627,7 @@ ex_entry:
|
|||
is_nmi:
|
||||
addl $8,%esp /* drop vector number and error code */
|
||||
iret
|
||||
ENDPROC(early_idt_handler)
|
||||
ENDPROC(early_idt_handler_common)
|
||||
|
||||
/* This is the default interrupt "handler" :-) */
|
||||
ALIGN
|
||||
|
|
|
@ -329,26 +329,28 @@ bad_address:
|
|||
jmp bad_address
|
||||
|
||||
__INIT
|
||||
.globl early_idt_handlers
|
||||
early_idt_handlers:
|
||||
ENTRY(early_idt_handler_array)
|
||||
# 104(%rsp) %rflags
|
||||
# 96(%rsp) %cs
|
||||
# 88(%rsp) %rip
|
||||
# 80(%rsp) error code
|
||||
i = 0
|
||||
.rept NUM_EXCEPTION_VECTORS
|
||||
.if (EXCEPTION_ERRCODE_MASK >> i) & 1
|
||||
ASM_NOP2
|
||||
.else
|
||||
.ifeq (EXCEPTION_ERRCODE_MASK >> i) & 1
|
||||
pushq $0 # Dummy error code, to make stack frame uniform
|
||||
.endif
|
||||
pushq $i # 72(%rsp) Vector number
|
||||
jmp early_idt_handler
|
||||
jmp early_idt_handler_common
|
||||
i = i + 1
|
||||
.fill early_idt_handler_array + i*EARLY_IDT_HANDLER_SIZE - ., 1, 0xcc
|
||||
.endr
|
||||
ENDPROC(early_idt_handler_array)
|
||||
|
||||
/* This is global to keep gas from relaxing the jumps */
|
||||
ENTRY(early_idt_handler)
|
||||
early_idt_handler_common:
|
||||
/*
|
||||
* The stack is the hardware frame, an error code or zero, and the
|
||||
* vector number.
|
||||
*/
|
||||
cld
|
||||
|
||||
cmpl $2,(%rsp) # X86_TRAP_NMI
|
||||
|
@ -420,7 +422,7 @@ ENTRY(early_idt_handler)
|
|||
is_nmi:
|
||||
addq $16,%rsp # drop vector number and error code
|
||||
INTERRUPT_RETURN
|
||||
ENDPROC(early_idt_handler)
|
||||
ENDPROC(early_idt_handler_common)
|
||||
|
||||
__INITDATA
|
||||
|
||||
|
|
|
@ -3220,6 +3220,9 @@ int blk_pre_runtime_suspend(struct request_queue *q)
|
|||
{
|
||||
int ret = 0;
|
||||
|
||||
if (!q->dev)
|
||||
return ret;
|
||||
|
||||
spin_lock_irq(q->queue_lock);
|
||||
if (q->nr_pending) {
|
||||
ret = -EBUSY;
|
||||
|
@ -3247,6 +3250,9 @@ EXPORT_SYMBOL(blk_pre_runtime_suspend);
|
|||
*/
|
||||
void blk_post_runtime_suspend(struct request_queue *q, int err)
|
||||
{
|
||||
if (!q->dev)
|
||||
return;
|
||||
|
||||
spin_lock_irq(q->queue_lock);
|
||||
if (!err) {
|
||||
q->rpm_status = RPM_SUSPENDED;
|
||||
|
@ -3271,6 +3277,9 @@ EXPORT_SYMBOL(blk_post_runtime_suspend);
|
|||
*/
|
||||
void blk_pre_runtime_resume(struct request_queue *q)
|
||||
{
|
||||
if (!q->dev)
|
||||
return;
|
||||
|
||||
spin_lock_irq(q->queue_lock);
|
||||
q->rpm_status = RPM_RESUMING;
|
||||
spin_unlock_irq(q->queue_lock);
|
||||
|
@ -3293,6 +3302,9 @@ EXPORT_SYMBOL(blk_pre_runtime_resume);
|
|||
*/
|
||||
void blk_post_runtime_resume(struct request_queue *q, int err)
|
||||
{
|
||||
if (!q->dev)
|
||||
return;
|
||||
|
||||
spin_lock_irq(q->queue_lock);
|
||||
if (!err) {
|
||||
q->rpm_status = RPM_ACTIVE;
|
||||
|
|
|
@ -101,7 +101,7 @@
|
|||
#define AD7795_CH_AIN1M_AIN1M 8 /* AIN1(-) - AIN1(-) */
|
||||
|
||||
/* ID Register Bit Designations (AD7793_REG_ID) */
|
||||
#define AD7785_ID 0xB
|
||||
#define AD7785_ID 0x3
|
||||
#define AD7792_ID 0xA
|
||||
#define AD7793_ID 0xB
|
||||
#define AD7794_ID 0xF
|
||||
|
|
|
@ -602,10 +602,16 @@ static int ad5064_i2c_write(struct ad5064_state *st, unsigned int cmd,
|
|||
unsigned int addr, unsigned int val)
|
||||
{
|
||||
struct i2c_client *i2c = to_i2c_client(st->dev);
|
||||
int ret;
|
||||
|
||||
st->data.i2c[0] = (cmd << 4) | addr;
|
||||
put_unaligned_be16(val, &st->data.i2c[1]);
|
||||
return i2c_master_send(i2c, st->data.i2c, 3);
|
||||
|
||||
ret = i2c_master_send(i2c, st->data.i2c, 3);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ad5064_i2c_probe(struct i2c_client *i2c,
|
||||
|
|
|
@ -166,6 +166,7 @@ static int mcp4725_probe(struct i2c_client *client,
|
|||
data->client = client;
|
||||
|
||||
indio_dev->dev.parent = &client->dev;
|
||||
indio_dev->name = id->name;
|
||||
indio_dev->info = &mcp4725_info;
|
||||
indio_dev->channels = &mcp4725_channel;
|
||||
indio_dev->num_channels = 1;
|
||||
|
|
|
@ -43,7 +43,7 @@ int adis_update_scan_mode(struct iio_dev *indio_dev,
|
|||
return -ENOMEM;
|
||||
|
||||
rx = adis->buffer;
|
||||
tx = rx + indio_dev->scan_bytes;
|
||||
tx = rx + scan_count;
|
||||
|
||||
spi_message_init(&adis->msg);
|
||||
|
||||
|
|
|
@ -1081,7 +1081,7 @@ static int elantech_set_input_params(struct psmouse *psmouse)
|
|||
input_set_abs_params(dev, ABS_TOOL_WIDTH, ETP_WMIN_V2,
|
||||
ETP_WMAX_V2, 0, 0);
|
||||
}
|
||||
input_mt_init_slots(dev, 2, 0);
|
||||
input_mt_init_slots(dev, 2, INPUT_MT_SEMI_MT);
|
||||
input_set_abs_params(dev, ABS_MT_POSITION_X, x_min, x_max, 0, 0);
|
||||
input_set_abs_params(dev, ABS_MT_POSITION_Y, y_min, y_max, 0, 0);
|
||||
break;
|
||||
|
@ -1357,6 +1357,13 @@ static const struct dmi_system_id no_hw_res_dmi_table[] = {
|
|||
DMI_MATCH(DMI_PRODUCT_NAME, "U2442"),
|
||||
},
|
||||
},
|
||||
{
|
||||
/* Fujitsu LIFEBOOK U745 does not work with crc_enabled == 0 */
|
||||
.matches = {
|
||||
DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
|
||||
DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK U745"),
|
||||
},
|
||||
},
|
||||
#endif
|
||||
{ }
|
||||
};
|
||||
|
|
|
@ -257,6 +257,13 @@ static const struct dmi_system_id __initconst i8042_dmi_nomux_table[] = {
|
|||
DMI_MATCH(DMI_PRODUCT_NAME, "LifeBook S6230"),
|
||||
},
|
||||
},
|
||||
{
|
||||
/* Fujitsu Lifebook U745 */
|
||||
.matches = {
|
||||
DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
|
||||
DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK U745"),
|
||||
},
|
||||
},
|
||||
{
|
||||
/* Fujitsu T70H */
|
||||
.matches = {
|
||||
|
|
|
@ -968,7 +968,7 @@ void dmar_disable_qi(struct intel_iommu *iommu)
|
|||
|
||||
raw_spin_lock_irqsave(&iommu->register_lock, flags);
|
||||
|
||||
sts = dmar_readq(iommu->reg + DMAR_GSTS_REG);
|
||||
sts = readl(iommu->reg + DMAR_GSTS_REG);
|
||||
if (!(sts & DMA_GSTS_QIES))
|
||||
goto end;
|
||||
|
||||
|
|
|
@ -495,7 +495,7 @@ static void iommu_disable_irq_remapping(struct intel_iommu *iommu)
|
|||
|
||||
raw_spin_lock_irqsave(&iommu->register_lock, flags);
|
||||
|
||||
sts = dmar_readq(iommu->reg + DMAR_GSTS_REG);
|
||||
sts = readl(iommu->reg + DMAR_GSTS_REG);
|
||||
if (!(sts & DMA_GSTS_IRES))
|
||||
goto end;
|
||||
|
||||
|
|
|
@ -545,16 +545,12 @@ static void x25_asy_receive_buf(struct tty_struct *tty,
|
|||
|
||||
static int x25_asy_open_tty(struct tty_struct *tty)
|
||||
{
|
||||
struct x25_asy *sl = tty->disc_data;
|
||||
struct x25_asy *sl;
|
||||
int err;
|
||||
|
||||
if (tty->ops->write == NULL)
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
/* First make sure we're not already connected. */
|
||||
if (sl && sl->magic == X25_ASY_MAGIC)
|
||||
return -EEXIST;
|
||||
|
||||
/* OK. Find a free X.25 channel to use. */
|
||||
sl = x25_asy_alloc();
|
||||
if (sl == NULL)
|
||||
|
|
|
@ -49,7 +49,7 @@ struct scu_ipc_data {
|
|||
|
||||
static int scu_reg_access(u32 cmd, struct scu_ipc_data *data)
|
||||
{
|
||||
int count = data->count;
|
||||
unsigned int count = data->count;
|
||||
|
||||
if (count == 0 || count == 3 || count > 4)
|
||||
return -EINVAL;
|
||||
|
|
|
@ -569,7 +569,7 @@ static int mode_select_handle_sense(struct scsi_device *sdev,
|
|||
/*
|
||||
* Command Lock contention
|
||||
*/
|
||||
err = SCSI_DH_RETRY;
|
||||
err = SCSI_DH_IMM_RETRY;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
|
@ -619,6 +619,8 @@ retry:
|
|||
err = mode_select_handle_sense(sdev, h->sense);
|
||||
if (err == SCSI_DH_RETRY && retry_cnt--)
|
||||
goto retry;
|
||||
if (err == SCSI_DH_IMM_RETRY)
|
||||
goto retry;
|
||||
}
|
||||
if (err == SCSI_DH_OK) {
|
||||
h->state = RDAC_STATE_ACTIVE;
|
||||
|
|
|
@ -305,6 +305,17 @@ static void scsi_host_dev_release(struct device *dev)
|
|||
kfree(queuedata);
|
||||
}
|
||||
|
||||
if (shost->shost_state == SHOST_CREATED) {
|
||||
/*
|
||||
* Free the shost_dev device name here if scsi_host_alloc()
|
||||
* and scsi_host_put() have been called but neither
|
||||
* scsi_host_add() nor scsi_host_remove() has been called.
|
||||
* This avoids that the memory allocated for the shost_dev
|
||||
* name is leaked.
|
||||
*/
|
||||
kfree(dev_name(&shost->shost_dev));
|
||||
}
|
||||
|
||||
scsi_destroy_command_freelist(shost);
|
||||
if (shost->bqt)
|
||||
blk_free_tags(shost->bqt);
|
||||
|
|
|
@ -789,7 +789,7 @@ sdev_store_queue_ramp_up_period(struct device *dev,
|
|||
return -EINVAL;
|
||||
|
||||
sdev->queue_ramp_up_period = msecs_to_jiffies(period);
|
||||
return period;
|
||||
return count;
|
||||
}
|
||||
|
||||
static struct device_attribute sdev_attr_queue_ramp_up_period =
|
||||
|
@ -1038,31 +1038,25 @@ static void __scsi_remove_target(struct scsi_target *starget)
|
|||
void scsi_remove_target(struct device *dev)
|
||||
{
|
||||
struct Scsi_Host *shost = dev_to_shost(dev->parent);
|
||||
struct scsi_target *starget, *last = NULL;
|
||||
struct scsi_target *starget, *last_target = NULL;
|
||||
unsigned long flags;
|
||||
|
||||
/* remove targets being careful to lookup next entry before
|
||||
* deleting the last
|
||||
*/
|
||||
restart:
|
||||
spin_lock_irqsave(shost->host_lock, flags);
|
||||
list_for_each_entry(starget, &shost->__targets, siblings) {
|
||||
if (starget->state == STARGET_DEL)
|
||||
if (starget->state == STARGET_DEL ||
|
||||
starget == last_target)
|
||||
continue;
|
||||
if (starget->dev.parent == dev || &starget->dev == dev) {
|
||||
/* assuming new targets arrive at the end */
|
||||
kref_get(&starget->reap_ref);
|
||||
last_target = starget;
|
||||
spin_unlock_irqrestore(shost->host_lock, flags);
|
||||
if (last)
|
||||
scsi_target_reap(last);
|
||||
last = starget;
|
||||
__scsi_remove_target(starget);
|
||||
spin_lock_irqsave(shost->host_lock, flags);
|
||||
scsi_target_reap(starget);
|
||||
goto restart;
|
||||
}
|
||||
}
|
||||
spin_unlock_irqrestore(shost->host_lock, flags);
|
||||
|
||||
if (last)
|
||||
scsi_target_reap(last);
|
||||
}
|
||||
EXPORT_SYMBOL(scsi_remove_target);
|
||||
|
||||
|
|
|
@ -3276,8 +3276,8 @@ static int sd_suspend(struct device *dev)
|
|||
struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
|
||||
int ret = 0;
|
||||
|
||||
if (!sdkp)
|
||||
return 0; /* this can happen */
|
||||
if (!sdkp) /* E.g.: runtime suspend following sd_remove() */
|
||||
return 0;
|
||||
|
||||
if (sdkp->WCE) {
|
||||
sd_printk(KERN_DEBUG, sdkp, "Synchronizing SCSI cache\n");
|
||||
|
@ -3301,6 +3301,9 @@ static int sd_resume(struct device *dev)
|
|||
struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
|
||||
int ret = 0;
|
||||
|
||||
if (!sdkp) /* E.g.: runtime resume at the start of sd_probe() */
|
||||
return 0;
|
||||
|
||||
if (!sdkp->device->manage_start_stop)
|
||||
goto done;
|
||||
|
||||
|
|
|
@ -1258,7 +1258,7 @@ sg_mmap(struct file *filp, struct vm_area_struct *vma)
|
|||
}
|
||||
|
||||
sfp->mmap_called = 1;
|
||||
vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
|
||||
vma->vm_flags |= VM_IO | VM_DONTEXPAND | VM_DONTDUMP;
|
||||
vma->vm_private_data = sfp;
|
||||
vma->vm_ops = &sg_mmap_vm_ops;
|
||||
return 0;
|
||||
|
|
|
@ -142,6 +142,9 @@ static int sr_runtime_suspend(struct device *dev)
|
|||
{
|
||||
struct scsi_cd *cd = dev_get_drvdata(dev);
|
||||
|
||||
if (!cd) /* E.g.: runtime suspend following sr_remove() */
|
||||
return 0;
|
||||
|
||||
if (cd->media_present)
|
||||
return -EBUSY;
|
||||
else
|
||||
|
@ -1006,6 +1009,7 @@ static int sr_remove(struct device *dev)
|
|||
|
||||
blk_queue_prep_rq(cd->device->request_queue, scsi_prep_fn);
|
||||
del_gendisk(cd->disk);
|
||||
dev_set_drvdata(dev, NULL);
|
||||
|
||||
mutex_lock(&sr_ref_mutex);
|
||||
kref_put(&cd->kref, sr_kref_release);
|
||||
|
|
|
@ -76,7 +76,7 @@ static int lpc32xx_read_raw(struct iio_dev *indio_dev,
|
|||
|
||||
if (mask == IIO_CHAN_INFO_RAW) {
|
||||
mutex_lock(&indio_dev->mlock);
|
||||
clk_enable(info->clk);
|
||||
clk_prepare_enable(info->clk);
|
||||
/* Measurement setup */
|
||||
__raw_writel(AD_INTERNAL | (chan->address) | AD_REFp | AD_REFm,
|
||||
LPC32XX_ADC_SELECT(info->adc_base));
|
||||
|
@ -84,7 +84,7 @@ static int lpc32xx_read_raw(struct iio_dev *indio_dev,
|
|||
__raw_writel(AD_PDN_CTRL | AD_STROBE,
|
||||
LPC32XX_ADC_CTRL(info->adc_base));
|
||||
wait_for_completion(&info->completion); /* set by ISR */
|
||||
clk_disable(info->clk);
|
||||
clk_disable_unprepare(info->clk);
|
||||
*val = info->value;
|
||||
mutex_unlock(&indio_dev->mlock);
|
||||
|
||||
|
|
|
@ -139,7 +139,9 @@ static void __speakup_paste_selection(struct work_struct *work)
|
|||
struct tty_ldisc *ld;
|
||||
DECLARE_WAITQUEUE(wait, current);
|
||||
|
||||
ld = tty_ldisc_ref_wait(tty);
|
||||
ld = tty_ldisc_ref(tty);
|
||||
if (!ld)
|
||||
goto tty_unref;
|
||||
|
||||
/* FIXME: this is completely unsafe */
|
||||
add_wait_queue(&vc->paste_wait, &wait);
|
||||
|
@ -158,6 +160,7 @@ static void __speakup_paste_selection(struct work_struct *work)
|
|||
current->state = TASK_RUNNING;
|
||||
|
||||
tty_ldisc_deref(ld);
|
||||
tty_unref:
|
||||
tty_kref_put(tty);
|
||||
}
|
||||
|
||||
|
|
|
@ -3960,6 +3960,17 @@ reject:
|
|||
return iscsit_add_reject(conn, ISCSI_REASON_BOOKMARK_NO_RESOURCES, buf);
|
||||
}
|
||||
|
||||
static bool iscsi_target_check_conn_state(struct iscsi_conn *conn)
|
||||
{
|
||||
bool ret;
|
||||
|
||||
spin_lock_bh(&conn->state_lock);
|
||||
ret = (conn->conn_state != TARG_CONN_STATE_LOGGED_IN);
|
||||
spin_unlock_bh(&conn->state_lock);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int iscsi_target_rx_thread(void *arg)
|
||||
{
|
||||
int ret, rc;
|
||||
|
@ -3977,7 +3988,7 @@ int iscsi_target_rx_thread(void *arg)
|
|||
* incoming iscsi/tcp socket I/O, and/or failing the connection.
|
||||
*/
|
||||
rc = wait_for_completion_interruptible(&conn->rx_login_comp);
|
||||
if (rc < 0)
|
||||
if (rc < 0 || iscsi_target_check_conn_state(conn))
|
||||
return 0;
|
||||
|
||||
if (conn->conn_transport->transport_type == ISCSI_INFINIBAND) {
|
||||
|
|
|
@ -1730,7 +1730,8 @@ static void lio_tpg_release_fabric_acl(
|
|||
}
|
||||
|
||||
/*
|
||||
* Called with spin_lock_bh(struct se_portal_group->session_lock) held..
|
||||
* Called with spin_lock_irq(struct se_portal_group->session_lock) held
|
||||
* or not held.
|
||||
*
|
||||
* Also, this function calls iscsit_inc_session_usage_count() on the
|
||||
* struct iscsi_session in question.
|
||||
|
@ -1738,19 +1739,32 @@ static void lio_tpg_release_fabric_acl(
|
|||
static int lio_tpg_shutdown_session(struct se_session *se_sess)
|
||||
{
|
||||
struct iscsi_session *sess = se_sess->fabric_sess_ptr;
|
||||
struct se_portal_group *se_tpg = se_sess->se_tpg;
|
||||
bool local_lock = false;
|
||||
|
||||
if (!spin_is_locked(&se_tpg->session_lock)) {
|
||||
spin_lock_irq(&se_tpg->session_lock);
|
||||
local_lock = true;
|
||||
}
|
||||
|
||||
spin_lock(&sess->conn_lock);
|
||||
if (atomic_read(&sess->session_fall_back_to_erl0) ||
|
||||
atomic_read(&sess->session_logout) ||
|
||||
(sess->time2retain_timer_flags & ISCSI_TF_EXPIRED)) {
|
||||
spin_unlock(&sess->conn_lock);
|
||||
if (local_lock)
|
||||
spin_unlock_irq(&sess->conn_lock);
|
||||
return 0;
|
||||
}
|
||||
atomic_set(&sess->session_reinstatement, 1);
|
||||
spin_unlock(&sess->conn_lock);
|
||||
|
||||
iscsit_stop_time2retain_timer(sess);
|
||||
spin_unlock_irq(&se_tpg->session_lock);
|
||||
|
||||
iscsit_stop_session(sess, 1, 1);
|
||||
if (!local_lock)
|
||||
spin_lock_irq(&se_tpg->session_lock);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
|
|
@ -384,6 +384,7 @@ err:
|
|||
if (login->login_complete) {
|
||||
if (conn->rx_thread && conn->rx_thread_active) {
|
||||
send_sig(SIGINT, conn->rx_thread, 1);
|
||||
complete(&conn->rx_login_comp);
|
||||
kthread_stop(conn->rx_thread);
|
||||
}
|
||||
if (conn->tx_thread && conn->tx_thread_active) {
|
||||
|
|
|
@ -623,7 +623,14 @@ static void pty_unix98_remove(struct tty_driver *driver, struct tty_struct *tty)
|
|||
/* this is called once with whichever end is closed last */
|
||||
static void pty_unix98_shutdown(struct tty_struct *tty)
|
||||
{
|
||||
devpts_kill_index(tty->driver_data, tty->index);
|
||||
struct inode *ptmx_inode;
|
||||
|
||||
if (tty->driver->subtype == PTY_TYPE_MASTER)
|
||||
ptmx_inode = tty->driver_data;
|
||||
else
|
||||
ptmx_inode = tty->link->driver_data;
|
||||
devpts_kill_index(ptmx_inode, tty->index);
|
||||
devpts_del_ref(ptmx_inode);
|
||||
}
|
||||
|
||||
static const struct tty_operations ptm_unix98_ops = {
|
||||
|
@ -714,6 +721,18 @@ static int ptmx_open(struct inode *inode, struct file *filp)
|
|||
set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
|
||||
tty->driver_data = inode;
|
||||
|
||||
/*
|
||||
* In the case where all references to ptmx inode are dropped and we
|
||||
* still have /dev/tty opened pointing to the master/slave pair (ptmx
|
||||
* is closed/released before /dev/tty), we must make sure that the inode
|
||||
* is still valid when we call the final pty_unix98_shutdown, thus we
|
||||
* hold an additional reference to the ptmx inode. For the same /dev/tty
|
||||
* last close case, we also need to make sure the super_block isn't
|
||||
* destroyed (devpts instance unmounted), before /dev/tty is closed and
|
||||
* on its release devpts_kill_index is called.
|
||||
*/
|
||||
devpts_add_ref(inode);
|
||||
|
||||
tty_add_file(tty, filp);
|
||||
|
||||
slave_inode = devpts_pty_new(inode,
|
||||
|
|
|
@ -1526,7 +1526,9 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
|
|||
if (temp == 0xffffffff || (xhci->xhc_state & XHCI_STATE_HALTED)) {
|
||||
xhci_dbg(xhci, "HW died, freeing TD.\n");
|
||||
urb_priv = urb->hcpriv;
|
||||
for (i = urb_priv->td_cnt; i < urb_priv->length; i++) {
|
||||
for (i = urb_priv->td_cnt;
|
||||
i < urb_priv->length && xhci->devs[urb->dev->slot_id];
|
||||
i++) {
|
||||
td = urb_priv->td[i];
|
||||
if (!list_empty(&td->td_list))
|
||||
list_del_init(&td->td_list);
|
||||
|
|
|
@ -1228,7 +1228,8 @@ char *btrfs_ref_to_path(struct btrfs_root *fs_root, struct btrfs_path *path,
|
|||
read_extent_buffer(eb, dest + bytes_left,
|
||||
name_off, name_len);
|
||||
if (eb != eb_in) {
|
||||
btrfs_tree_read_unlock_blocking(eb);
|
||||
if (!path->skip_locking)
|
||||
btrfs_tree_read_unlock_blocking(eb);
|
||||
free_extent_buffer(eb);
|
||||
}
|
||||
ret = inode_ref_info(parent, 0, fs_root, path, &found_key);
|
||||
|
@ -1247,9 +1248,10 @@ char *btrfs_ref_to_path(struct btrfs_root *fs_root, struct btrfs_path *path,
|
|||
eb = path->nodes[0];
|
||||
/* make sure we can use eb after releasing the path */
|
||||
if (eb != eb_in) {
|
||||
atomic_inc(&eb->refs);
|
||||
btrfs_tree_read_lock(eb);
|
||||
btrfs_set_lock_blocking_rw(eb, BTRFS_READ_LOCK);
|
||||
if (!path->skip_locking)
|
||||
btrfs_set_lock_blocking_rw(eb, BTRFS_READ_LOCK);
|
||||
path->nodes[0] = NULL;
|
||||
path->locks[0] = 0;
|
||||
}
|
||||
btrfs_release_path(path);
|
||||
iref = btrfs_item_ptr(eb, slot, struct btrfs_inode_ref);
|
||||
|
|
|
@ -591,7 +591,7 @@ setup_ntlmv2_rsp(struct cifs_ses *ses, const struct nls_table *nls_cp)
|
|||
|
||||
ses->auth_key.response = kmalloc(baselen + tilen, GFP_KERNEL);
|
||||
if (!ses->auth_key.response) {
|
||||
rc = ENOMEM;
|
||||
rc = -ENOMEM;
|
||||
ses->auth_key.len = 0;
|
||||
goto setup_ntlmv2_rsp_ret;
|
||||
}
|
||||
|
|
|
@ -565,6 +565,26 @@ void devpts_kill_index(struct inode *ptmx_inode, int idx)
|
|||
mutex_unlock(&allocated_ptys_lock);
|
||||
}
|
||||
|
||||
/*
|
||||
* pty code needs to hold extra references in case of last /dev/tty close
|
||||
*/
|
||||
|
||||
void devpts_add_ref(struct inode *ptmx_inode)
|
||||
{
|
||||
struct super_block *sb = pts_sb_from_inode(ptmx_inode);
|
||||
|
||||
atomic_inc(&sb->s_active);
|
||||
ihold(ptmx_inode);
|
||||
}
|
||||
|
||||
void devpts_del_ref(struct inode *ptmx_inode)
|
||||
{
|
||||
struct super_block *sb = pts_sb_from_inode(ptmx_inode);
|
||||
|
||||
iput(ptmx_inode);
|
||||
deactivate_super(sb);
|
||||
}
|
||||
|
||||
/**
|
||||
* devpts_pty_new -- create a new inode in /dev/pts/
|
||||
* @ptmx_inode: inode of the master
|
||||
|
|
|
@ -181,7 +181,7 @@ static struct ext4_new_flex_group_data *alloc_flex_gd(unsigned long flexbg_size)
|
|||
if (flex_gd == NULL)
|
||||
goto out3;
|
||||
|
||||
if (flexbg_size >= UINT_MAX / sizeof(struct ext4_new_flex_group_data))
|
||||
if (flexbg_size >= UINT_MAX / sizeof(struct ext4_new_group_data))
|
||||
goto out2;
|
||||
flex_gd->count = flexbg_size;
|
||||
|
||||
|
|
|
@ -1136,6 +1136,7 @@ static ssize_t fuse_fill_write_pages(struct fuse_req *req,
|
|||
|
||||
mark_page_accessed(page);
|
||||
|
||||
iov_iter_advance(ii, tmp);
|
||||
if (!tmp) {
|
||||
unlock_page(page);
|
||||
page_cache_release(page);
|
||||
|
@ -1148,7 +1149,6 @@ static ssize_t fuse_fill_write_pages(struct fuse_req *req,
|
|||
req->page_descs[req->num_pages].length = tmp;
|
||||
req->num_pages++;
|
||||
|
||||
iov_iter_advance(ii, tmp);
|
||||
count += tmp;
|
||||
pos += tmp;
|
||||
offset += tmp;
|
||||
|
|
|
@ -1005,6 +1005,7 @@ static void __update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_s
|
|||
* Protect the call to nfs4_state_set_mode_locked and
|
||||
* serialise the stateid update
|
||||
*/
|
||||
spin_lock(&state->owner->so_lock);
|
||||
write_seqlock(&state->seqlock);
|
||||
if (deleg_stateid != NULL) {
|
||||
nfs4_stateid_copy(&state->stateid, deleg_stateid);
|
||||
|
@ -1013,7 +1014,6 @@ static void __update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_s
|
|||
if (open_stateid != NULL)
|
||||
nfs_set_open_stateid_locked(state, open_stateid, fmode);
|
||||
write_sequnlock(&state->seqlock);
|
||||
spin_lock(&state->owner->so_lock);
|
||||
update_open_stateflags(state, fmode);
|
||||
spin_unlock(&state->owner->so_lock);
|
||||
}
|
||||
|
|
|
@ -398,7 +398,7 @@ static int do_task_stat(struct seq_file *m, struct pid_namespace *ns,
|
|||
|
||||
state = *get_task_state(task);
|
||||
vsize = eip = esp = 0;
|
||||
permitted = ptrace_may_access(task, PTRACE_MODE_READ | PTRACE_MODE_NOAUDIT);
|
||||
permitted = ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS | PTRACE_MODE_NOAUDIT);
|
||||
mm = get_task_mm(task);
|
||||
if (mm) {
|
||||
vsize = task_vsize(mm);
|
||||
|
|
|
@ -207,7 +207,7 @@ static int proc_pid_cmdline(struct task_struct *task, char *buffer)
|
|||
|
||||
static int proc_pid_auxv(struct task_struct *task, char *buffer)
|
||||
{
|
||||
struct mm_struct *mm = mm_access(task, PTRACE_MODE_READ);
|
||||
struct mm_struct *mm = mm_access(task, PTRACE_MODE_READ_FSCREDS);
|
||||
int res = PTR_ERR(mm);
|
||||
if (mm && !IS_ERR(mm)) {
|
||||
unsigned int nwords = 0;
|
||||
|
@ -237,7 +237,7 @@ static int proc_pid_wchan(struct task_struct *task, char *buffer)
|
|||
wchan = get_wchan(task);
|
||||
|
||||
if (lookup_symbol_name(wchan, symname) < 0)
|
||||
if (!ptrace_may_access(task, PTRACE_MODE_READ))
|
||||
if (!ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS))
|
||||
return 0;
|
||||
else
|
||||
return sprintf(buffer, "%lu", wchan);
|
||||
|
@ -251,7 +251,7 @@ static int lock_trace(struct task_struct *task)
|
|||
int err = mutex_lock_killable(&task->signal->cred_guard_mutex);
|
||||
if (err)
|
||||
return err;
|
||||
if (!ptrace_may_access(task, PTRACE_MODE_ATTACH)) {
|
||||
if (!ptrace_may_access(task, PTRACE_MODE_ATTACH_FSCREDS)) {
|
||||
mutex_unlock(&task->signal->cred_guard_mutex);
|
||||
return -EPERM;
|
||||
}
|
||||
|
@ -525,7 +525,7 @@ static int proc_fd_access_allowed(struct inode *inode)
|
|||
*/
|
||||
task = get_proc_task(inode);
|
||||
if (task) {
|
||||
allowed = ptrace_may_access(task, PTRACE_MODE_READ);
|
||||
allowed = ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS);
|
||||
put_task_struct(task);
|
||||
}
|
||||
return allowed;
|
||||
|
@ -560,7 +560,7 @@ static bool has_pid_permissions(struct pid_namespace *pid,
|
|||
return true;
|
||||
if (in_group_p(pid->pid_gid))
|
||||
return true;
|
||||
return ptrace_may_access(task, PTRACE_MODE_READ);
|
||||
return ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS);
|
||||
}
|
||||
|
||||
|
||||
|
@ -675,7 +675,7 @@ static int __mem_open(struct inode *inode, struct file *file, unsigned int mode)
|
|||
if (!task)
|
||||
return -ESRCH;
|
||||
|
||||
mm = mm_access(task, mode);
|
||||
mm = mm_access(task, mode | PTRACE_MODE_FSCREDS);
|
||||
put_task_struct(task);
|
||||
|
||||
if (IS_ERR(mm))
|
||||
|
@ -1933,7 +1933,7 @@ static int map_files_d_revalidate(struct dentry *dentry, unsigned int flags)
|
|||
if (!task)
|
||||
goto out_notask;
|
||||
|
||||
mm = mm_access(task, PTRACE_MODE_READ);
|
||||
mm = mm_access(task, PTRACE_MODE_READ_FSCREDS);
|
||||
if (IS_ERR_OR_NULL(mm))
|
||||
goto out;
|
||||
|
||||
|
@ -2068,7 +2068,7 @@ static struct dentry *proc_map_files_lookup(struct inode *dir,
|
|||
goto out;
|
||||
|
||||
result = ERR_PTR(-EACCES);
|
||||
if (!ptrace_may_access(task, PTRACE_MODE_READ))
|
||||
if (!ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS))
|
||||
goto out_put_task;
|
||||
|
||||
result = ERR_PTR(-ENOENT);
|
||||
|
@ -2124,7 +2124,7 @@ proc_map_files_readdir(struct file *filp, void *dirent, filldir_t filldir)
|
|||
goto out;
|
||||
|
||||
ret = -EACCES;
|
||||
if (!ptrace_may_access(task, PTRACE_MODE_READ))
|
||||
if (!ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS))
|
||||
goto out_put_task;
|
||||
|
||||
ret = 0;
|
||||
|
@ -2660,7 +2660,7 @@ static int do_io_accounting(struct task_struct *task, char *buffer, int whole)
|
|||
if (result)
|
||||
return result;
|
||||
|
||||
if (!ptrace_may_access(task, PTRACE_MODE_READ)) {
|
||||
if (!ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS)) {
|
||||
result = -EACCES;
|
||||
goto out_unlock;
|
||||
}
|
||||
|
|
|
@ -125,7 +125,7 @@ static void *proc_ns_follow_link(struct dentry *dentry, struct nameidata *nd)
|
|||
if (!task)
|
||||
goto out;
|
||||
|
||||
if (!ptrace_may_access(task, PTRACE_MODE_READ))
|
||||
if (!ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS))
|
||||
goto out_put_task;
|
||||
|
||||
ns_path.dentry = proc_ns_get_dentry(sb, task, ei->ns.ns_ops);
|
||||
|
@ -158,7 +158,7 @@ static int proc_ns_readlink(struct dentry *dentry, char __user *buffer, int bufl
|
|||
if (!task)
|
||||
goto out;
|
||||
|
||||
if (!ptrace_may_access(task, PTRACE_MODE_READ))
|
||||
if (!ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS))
|
||||
goto out_put_task;
|
||||
|
||||
len = -ENOENT;
|
||||
|
|
|
@ -2055,14 +2055,29 @@ void udf_write_aext(struct inode *inode, struct extent_position *epos,
|
|||
epos->offset += adsize;
|
||||
}
|
||||
|
||||
/*
|
||||
* Only 1 indirect extent in a row really makes sense but allow upto 16 in case
|
||||
* someone does some weird stuff.
|
||||
*/
|
||||
#define UDF_MAX_INDIR_EXTS 16
|
||||
|
||||
int8_t udf_next_aext(struct inode *inode, struct extent_position *epos,
|
||||
struct kernel_lb_addr *eloc, uint32_t *elen, int inc)
|
||||
{
|
||||
int8_t etype;
|
||||
unsigned int indirections = 0;
|
||||
|
||||
while ((etype = udf_current_aext(inode, epos, eloc, elen, inc)) ==
|
||||
(EXT_NEXT_EXTENT_ALLOCDECS >> 30)) {
|
||||
int block;
|
||||
|
||||
if (++indirections > UDF_MAX_INDIR_EXTS) {
|
||||
udf_err(inode->i_sb,
|
||||
"too many indirect extents in inode %lu\n",
|
||||
inode->i_ino);
|
||||
return -1;
|
||||
}
|
||||
|
||||
epos->block = *eloc;
|
||||
epos->offset = sizeof(struct allocExtDesc);
|
||||
brelse(epos->bh);
|
||||
|
|
|
@ -132,11 +132,15 @@ int udf_CS0toUTF8(struct ustr *utf_o, const struct ustr *ocu_i)
|
|||
if (c < 0x80U)
|
||||
utf_o->u_name[utf_o->u_len++] = (uint8_t)c;
|
||||
else if (c < 0x800U) {
|
||||
if (utf_o->u_len > (UDF_NAME_LEN - 4))
|
||||
break;
|
||||
utf_o->u_name[utf_o->u_len++] =
|
||||
(uint8_t)(0xc0 | (c >> 6));
|
||||
utf_o->u_name[utf_o->u_len++] =
|
||||
(uint8_t)(0x80 | (c & 0x3f));
|
||||
} else {
|
||||
if (utf_o->u_len > (UDF_NAME_LEN - 5))
|
||||
break;
|
||||
utf_o->u_name[utf_o->u_len++] =
|
||||
(uint8_t)(0xe0 | (c >> 12));
|
||||
utf_o->u_name[utf_o->u_len++] =
|
||||
|
@ -177,17 +181,22 @@ int udf_CS0toUTF8(struct ustr *utf_o, const struct ustr *ocu_i)
|
|||
static int udf_UTF8toCS0(dstring *ocu, struct ustr *utf, int length)
|
||||
{
|
||||
unsigned c, i, max_val, utf_char;
|
||||
int utf_cnt, u_len;
|
||||
int utf_cnt, u_len, u_ch;
|
||||
|
||||
memset(ocu, 0, sizeof(dstring) * length);
|
||||
ocu[0] = 8;
|
||||
max_val = 0xffU;
|
||||
u_ch = 1;
|
||||
|
||||
try_again:
|
||||
u_len = 0U;
|
||||
utf_char = 0U;
|
||||
utf_cnt = 0U;
|
||||
for (i = 0U; i < utf->u_len; i++) {
|
||||
/* Name didn't fit? */
|
||||
if (u_len + 1 + u_ch >= length)
|
||||
return 0;
|
||||
|
||||
c = (uint8_t)utf->u_name[i];
|
||||
|
||||
/* Complete a multi-byte UTF-8 character */
|
||||
|
@ -229,6 +238,7 @@ try_again:
|
|||
if (max_val == 0xffU) {
|
||||
max_val = 0xffffU;
|
||||
ocu[0] = (uint8_t)0x10U;
|
||||
u_ch = 2;
|
||||
goto try_again;
|
||||
}
|
||||
goto error_out;
|
||||
|
@ -281,7 +291,7 @@ static int udf_CS0toNLS(struct nls_table *nls, struct ustr *utf_o,
|
|||
c = (c << 8) | ocu[i++];
|
||||
|
||||
len = nls->uni2char(c, &utf_o->u_name[utf_o->u_len],
|
||||
UDF_NAME_LEN - utf_o->u_len);
|
||||
UDF_NAME_LEN - 2 - utf_o->u_len);
|
||||
/* Valid character? */
|
||||
if (len >= 0)
|
||||
utf_o->u_len += len;
|
||||
|
@ -299,15 +309,19 @@ static int udf_NLStoCS0(struct nls_table *nls, dstring *ocu, struct ustr *uni,
|
|||
int len;
|
||||
unsigned i, max_val;
|
||||
uint16_t uni_char;
|
||||
int u_len;
|
||||
int u_len, u_ch;
|
||||
|
||||
memset(ocu, 0, sizeof(dstring) * length);
|
||||
ocu[0] = 8;
|
||||
max_val = 0xffU;
|
||||
u_ch = 1;
|
||||
|
||||
try_again:
|
||||
u_len = 0U;
|
||||
for (i = 0U; i < uni->u_len; i++) {
|
||||
/* Name didn't fit? */
|
||||
if (u_len + 1 + u_ch >= length)
|
||||
return 0;
|
||||
len = nls->char2uni(&uni->u_name[i], uni->u_len - i, &uni_char);
|
||||
if (!len)
|
||||
continue;
|
||||
|
@ -320,6 +334,7 @@ try_again:
|
|||
if (uni_char > max_val) {
|
||||
max_val = 0xffffU;
|
||||
ocu[0] = (uint8_t)0x10U;
|
||||
u_ch = 2;
|
||||
goto try_again;
|
||||
}
|
||||
|
||||
|
|
|
@ -131,7 +131,7 @@ void ftrace_likely_update(struct ftrace_branch_data *f, int val, int expect);
|
|||
*/
|
||||
#define if(cond, ...) __trace_if( (cond , ## __VA_ARGS__) )
|
||||
#define __trace_if(cond) \
|
||||
if (__builtin_constant_p((cond)) ? !!(cond) : \
|
||||
if (__builtin_constant_p(!!(cond)) ? !!(cond) : \
|
||||
({ \
|
||||
int ______r; \
|
||||
static struct ftrace_branch_data \
|
||||
|
|
|
@ -19,6 +19,8 @@
|
|||
|
||||
int devpts_new_index(struct inode *ptmx_inode);
|
||||
void devpts_kill_index(struct inode *ptmx_inode, int idx);
|
||||
void devpts_add_ref(struct inode *ptmx_inode);
|
||||
void devpts_del_ref(struct inode *ptmx_inode);
|
||||
/* mknod in devpts */
|
||||
struct inode *devpts_pty_new(struct inode *ptmx_inode, dev_t device, int index,
|
||||
void *priv);
|
||||
|
@ -32,6 +34,8 @@ void devpts_pty_kill(struct inode *inode);
|
|||
/* Dummy stubs in the no-pty case */
|
||||
static inline int devpts_new_index(struct inode *ptmx_inode) { return -EINVAL; }
|
||||
static inline void devpts_kill_index(struct inode *ptmx_inode, int idx) { }
|
||||
static inline void devpts_add_ref(struct inode *ptmx_inode) { }
|
||||
static inline void devpts_del_ref(struct inode *ptmx_inode) { }
|
||||
static inline struct inode *devpts_pty_new(struct inode *ptmx_inode,
|
||||
dev_t device, int index, void *priv)
|
||||
{
|
||||
|
|
|
@ -56,7 +56,29 @@ extern void exit_ptrace(struct task_struct *tracer);
|
|||
#define PTRACE_MODE_READ 0x01
|
||||
#define PTRACE_MODE_ATTACH 0x02
|
||||
#define PTRACE_MODE_NOAUDIT 0x04
|
||||
/* Returns true on success, false on denial. */
|
||||
#define PTRACE_MODE_FSCREDS 0x08
|
||||
#define PTRACE_MODE_REALCREDS 0x10
|
||||
|
||||
/* shorthands for READ/ATTACH and FSCREDS/REALCREDS combinations */
|
||||
#define PTRACE_MODE_READ_FSCREDS (PTRACE_MODE_READ | PTRACE_MODE_FSCREDS)
|
||||
#define PTRACE_MODE_READ_REALCREDS (PTRACE_MODE_READ | PTRACE_MODE_REALCREDS)
|
||||
#define PTRACE_MODE_ATTACH_FSCREDS (PTRACE_MODE_ATTACH | PTRACE_MODE_FSCREDS)
|
||||
#define PTRACE_MODE_ATTACH_REALCREDS (PTRACE_MODE_ATTACH | PTRACE_MODE_REALCREDS)
|
||||
|
||||
/**
|
||||
* ptrace_may_access - check whether the caller is permitted to access
|
||||
* a target task.
|
||||
* @task: target task
|
||||
* @mode: selects type of access and caller credentials
|
||||
*
|
||||
* Returns true on success, false on denial.
|
||||
*
|
||||
* One of the flags PTRACE_MODE_FSCREDS and PTRACE_MODE_REALCREDS must
|
||||
* be set in @mode to specify whether the access was requested through
|
||||
* a filesystem syscall (should use effective capabilities and fsuid
|
||||
* of the caller) or through an explicit syscall such as
|
||||
* process_vm_writev or ptrace (and should use the real credentials).
|
||||
*/
|
||||
extern bool ptrace_may_access(struct task_struct *task, unsigned int mode);
|
||||
|
||||
static inline int ptrace_reparented(struct task_struct *child)
|
||||
|
|
|
@ -321,13 +321,29 @@ radix_tree_iter_init(struct radix_tree_iter *iter, unsigned long start)
|
|||
void **radix_tree_next_chunk(struct radix_tree_root *root,
|
||||
struct radix_tree_iter *iter, unsigned flags);
|
||||
|
||||
/**
|
||||
* radix_tree_iter_retry - retry this chunk of the iteration
|
||||
* @iter: iterator state
|
||||
*
|
||||
* If we iterate over a tree protected only by the RCU lock, a race
|
||||
* against deletion or creation may result in seeing a slot for which
|
||||
* radix_tree_deref_retry() returns true. If so, call this function
|
||||
* and continue the iteration.
|
||||
*/
|
||||
static inline __must_check
|
||||
void **radix_tree_iter_retry(struct radix_tree_iter *iter)
|
||||
{
|
||||
iter->next_index = iter->index;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* radix_tree_chunk_size - get current chunk size
|
||||
*
|
||||
* @iter: pointer to radix tree iterator
|
||||
* Returns: current chunk size
|
||||
*/
|
||||
static __always_inline unsigned
|
||||
static __always_inline long
|
||||
radix_tree_chunk_size(struct radix_tree_iter *iter)
|
||||
{
|
||||
return iter->next_index - iter->index;
|
||||
|
@ -361,9 +377,9 @@ radix_tree_next_slot(void **slot, struct radix_tree_iter *iter, unsigned flags)
|
|||
return slot + offset + 1;
|
||||
}
|
||||
} else {
|
||||
unsigned size = radix_tree_chunk_size(iter) - 1;
|
||||
long size = radix_tree_chunk_size(iter);
|
||||
|
||||
while (size--) {
|
||||
while (--size > 0) {
|
||||
slot++;
|
||||
iter->index++;
|
||||
if (likely(*slot))
|
||||
|
|
|
@ -3117,7 +3117,7 @@ find_lively_task_by_vpid(pid_t vpid)
|
|||
|
||||
/* Reuse ptrace permission checks for now. */
|
||||
err = -EACCES;
|
||||
if (!ptrace_may_access(task, PTRACE_MODE_READ))
|
||||
if (!ptrace_may_access(task, PTRACE_MODE_READ_REALCREDS))
|
||||
goto errout;
|
||||
|
||||
return task;
|
||||
|
@ -5896,6 +5896,10 @@ static int perf_tp_filter_match(struct perf_event *event,
|
|||
{
|
||||
void *record = data->raw->data;
|
||||
|
||||
/* only top level events have filters set */
|
||||
if (event->parent)
|
||||
event = event->parent;
|
||||
|
||||
if (likely(!event->filter) || filter_match_preds(event->filter, record))
|
||||
return 1;
|
||||
return 0;
|
||||
|
|
|
@ -2497,6 +2497,11 @@ static int futex_wait_requeue_pi(u32 __user *uaddr, unsigned int flags,
|
|||
if (q.pi_state && (q.pi_state->owner != current)) {
|
||||
spin_lock(q.lock_ptr);
|
||||
ret = fixup_pi_state_owner(uaddr2, &q, current);
|
||||
/*
|
||||
* Drop the reference to the pi state which
|
||||
* the requeue_pi() code acquired for us.
|
||||
*/
|
||||
free_pi_state(q.pi_state);
|
||||
spin_unlock(q.lock_ptr);
|
||||
}
|
||||
} else {
|
||||
|
@ -2623,7 +2628,7 @@ SYSCALL_DEFINE3(get_robust_list, int, pid,
|
|||
}
|
||||
|
||||
ret = -EPERM;
|
||||
if (!ptrace_may_access(p, PTRACE_MODE_READ))
|
||||
if (!ptrace_may_access(p, PTRACE_MODE_READ_REALCREDS))
|
||||
goto err_unlock;
|
||||
|
||||
head = p->robust_list;
|
||||
|
|
|
@ -155,7 +155,7 @@ COMPAT_SYSCALL_DEFINE3(get_robust_list, int, pid,
|
|||
}
|
||||
|
||||
ret = -EPERM;
|
||||
if (!ptrace_may_access(p, PTRACE_MODE_READ))
|
||||
if (!ptrace_may_access(p, PTRACE_MODE_READ_REALCREDS))
|
||||
goto err_unlock;
|
||||
|
||||
head = p->compat_robust_list;
|
||||
|
|
|
@ -122,8 +122,8 @@ SYSCALL_DEFINE5(kcmp, pid_t, pid1, pid_t, pid2, int, type,
|
|||
&task2->signal->cred_guard_mutex);
|
||||
if (ret)
|
||||
goto err;
|
||||
if (!ptrace_may_access(task1, PTRACE_MODE_READ) ||
|
||||
!ptrace_may_access(task2, PTRACE_MODE_READ)) {
|
||||
if (!ptrace_may_access(task1, PTRACE_MODE_READ_REALCREDS) ||
|
||||
!ptrace_may_access(task2, PTRACE_MODE_READ_REALCREDS)) {
|
||||
ret = -EPERM;
|
||||
goto err_unlock;
|
||||
}
|
||||
|
|
|
@ -3871,6 +3871,11 @@ static inline int is_arm_mapping_symbol(const char *str)
|
|||
&& (str[2] == '\0' || str[2] == '.');
|
||||
}
|
||||
|
||||
static const char *symname(struct module *mod, unsigned int symnum)
|
||||
{
|
||||
return mod->strtab + mod->symtab[symnum].st_name;
|
||||
}
|
||||
|
||||
static const char *get_ksymbol(struct module *mod,
|
||||
unsigned long addr,
|
||||
unsigned long *size,
|
||||
|
@ -3893,15 +3898,15 @@ static const char *get_ksymbol(struct module *mod,
|
|||
|
||||
/* We ignore unnamed symbols: they're uninformative
|
||||
* and inserted at a whim. */
|
||||
if (*symname(mod, i) == '\0'
|
||||
|| is_arm_mapping_symbol(symname(mod, i)))
|
||||
continue;
|
||||
|
||||
if (mod->symtab[i].st_value <= addr
|
||||
&& mod->symtab[i].st_value > mod->symtab[best].st_value
|
||||
&& *(mod->strtab + mod->symtab[i].st_name) != '\0'
|
||||
&& !is_arm_mapping_symbol(mod->strtab + mod->symtab[i].st_name))
|
||||
&& mod->symtab[i].st_value > mod->symtab[best].st_value)
|
||||
best = i;
|
||||
if (mod->symtab[i].st_value > addr
|
||||
&& mod->symtab[i].st_value < nextval
|
||||
&& *(mod->strtab + mod->symtab[i].st_name) != '\0'
|
||||
&& !is_arm_mapping_symbol(mod->strtab + mod->symtab[i].st_name))
|
||||
&& mod->symtab[i].st_value < nextval)
|
||||
nextval = mod->symtab[i].st_value;
|
||||
}
|
||||
|
||||
|
@ -3912,7 +3917,7 @@ static const char *get_ksymbol(struct module *mod,
|
|||
*size = nextval - mod->symtab[best].st_value;
|
||||
if (offset)
|
||||
*offset = addr - mod->symtab[best].st_value;
|
||||
return mod->strtab + mod->symtab[best].st_name;
|
||||
return symname(mod, best);
|
||||
}
|
||||
|
||||
/* For kallsyms to ask for address resolution. NULL means not found. Careful
|
||||
|
@ -4013,8 +4018,7 @@ int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,
|
|||
if (symnum < mod->num_symtab) {
|
||||
*value = mod->symtab[symnum].st_value;
|
||||
*type = mod->symtab[symnum].st_info;
|
||||
strlcpy(name, mod->strtab + mod->symtab[symnum].st_name,
|
||||
KSYM_NAME_LEN);
|
||||
strlcpy(name, symname(mod, symnum), KSYM_NAME_LEN);
|
||||
strlcpy(module_name, mod->name, MODULE_NAME_LEN);
|
||||
*exported = is_exported(name, *value, mod);
|
||||
preempt_enable();
|
||||
|
@ -4031,7 +4035,7 @@ static unsigned long mod_find_symname(struct module *mod, const char *name)
|
|||
unsigned int i;
|
||||
|
||||
for (i = 0; i < mod->num_symtab; i++)
|
||||
if (strcmp(name, mod->strtab+mod->symtab[i].st_name) == 0 &&
|
||||
if (strcmp(name, symname(mod, i)) == 0 &&
|
||||
mod->symtab[i].st_info != 'U')
|
||||
return mod->symtab[i].st_value;
|
||||
return 0;
|
||||
|
@ -4075,7 +4079,7 @@ int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *,
|
|||
if (mod->state == MODULE_STATE_UNFORMED)
|
||||
continue;
|
||||
for (i = 0; i < mod->num_symtab; i++) {
|
||||
ret = fn(data, mod->strtab + mod->symtab[i].st_name,
|
||||
ret = fn(data, symname(mod, i),
|
||||
mod, mod->symtab[i].st_value);
|
||||
if (ret != 0)
|
||||
return ret;
|
||||
|
|
|
@ -248,6 +248,14 @@ static bool ptrace_has_cap(const struct cred *tcred, unsigned int mode)
|
|||
static int __ptrace_may_access(struct task_struct *task, unsigned int mode)
|
||||
{
|
||||
const struct cred *cred = current_cred(), *tcred;
|
||||
int dumpable = 0;
|
||||
kuid_t caller_uid;
|
||||
kgid_t caller_gid;
|
||||
|
||||
if (!(mode & PTRACE_MODE_FSCREDS) == !(mode & PTRACE_MODE_REALCREDS)) {
|
||||
WARN(1, "denying ptrace access check without PTRACE_MODE_*CREDS\n");
|
||||
return -EPERM;
|
||||
}
|
||||
|
||||
/* May we inspect the given task?
|
||||
* This check is used both for attaching with ptrace
|
||||
|
@ -257,18 +265,33 @@ static int __ptrace_may_access(struct task_struct *task, unsigned int mode)
|
|||
* because setting up the necessary parent/child relationship
|
||||
* or halting the specified task is impossible.
|
||||
*/
|
||||
int dumpable = 0;
|
||||
|
||||
/* Don't let security modules deny introspection */
|
||||
if (same_thread_group(task, current))
|
||||
return 0;
|
||||
rcu_read_lock();
|
||||
if (mode & PTRACE_MODE_FSCREDS) {
|
||||
caller_uid = cred->fsuid;
|
||||
caller_gid = cred->fsgid;
|
||||
} else {
|
||||
/*
|
||||
* Using the euid would make more sense here, but something
|
||||
* in userland might rely on the old behavior, and this
|
||||
* shouldn't be a security problem since
|
||||
* PTRACE_MODE_REALCREDS implies that the caller explicitly
|
||||
* used a syscall that requests access to another process
|
||||
* (and not a filesystem syscall to procfs).
|
||||
*/
|
||||
caller_uid = cred->uid;
|
||||
caller_gid = cred->gid;
|
||||
}
|
||||
tcred = __task_cred(task);
|
||||
if (uid_eq(cred->uid, tcred->euid) &&
|
||||
uid_eq(cred->uid, tcred->suid) &&
|
||||
uid_eq(cred->uid, tcred->uid) &&
|
||||
gid_eq(cred->gid, tcred->egid) &&
|
||||
gid_eq(cred->gid, tcred->sgid) &&
|
||||
gid_eq(cred->gid, tcred->gid))
|
||||
if (uid_eq(caller_uid, tcred->euid) &&
|
||||
uid_eq(caller_uid, tcred->suid) &&
|
||||
uid_eq(caller_uid, tcred->uid) &&
|
||||
gid_eq(caller_gid, tcred->egid) &&
|
||||
gid_eq(caller_gid, tcred->sgid) &&
|
||||
gid_eq(caller_gid, tcred->gid))
|
||||
goto ok;
|
||||
if (ptrace_has_cap(tcred, mode))
|
||||
goto ok;
|
||||
|
@ -335,7 +358,7 @@ static int ptrace_attach(struct task_struct *task, long request,
|
|||
goto out;
|
||||
|
||||
task_lock(task);
|
||||
retval = __ptrace_may_access(task, PTRACE_MODE_ATTACH);
|
||||
retval = __ptrace_may_access(task, PTRACE_MODE_ATTACH_REALCREDS);
|
||||
task_unlock(task);
|
||||
if (retval)
|
||||
goto unlock_creds;
|
||||
|
|
|
@ -962,7 +962,7 @@ static inline bool overlap(void *addr, unsigned long len, void *start, void *end
|
|||
|
||||
static void check_for_illegal_area(struct device *dev, void *addr, unsigned long len)
|
||||
{
|
||||
if (overlap(addr, len, _text, _etext) ||
|
||||
if (overlap(addr, len, _stext, _etext) ||
|
||||
overlap(addr, len, __start_rodata, __end_rodata))
|
||||
err_printk(dev, NULL, "DMA-API: device driver maps memory from kernel text or rodata [addr=%p] [len=%lu]\n", addr, len);
|
||||
}
|
||||
|
|
|
@ -282,9 +282,9 @@ void klist_iter_init_node(struct klist *k, struct klist_iter *i,
|
|||
struct klist_node *n)
|
||||
{
|
||||
i->i_klist = k;
|
||||
i->i_cur = n;
|
||||
if (n)
|
||||
kref_get(&n->n_ref);
|
||||
i->i_cur = NULL;
|
||||
if (n && kref_get_unless_zero(&n->n_ref))
|
||||
i->i_cur = n;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(klist_iter_init_node);
|
||||
|
||||
|
|
|
@ -1015,9 +1015,13 @@ radix_tree_gang_lookup(struct radix_tree_root *root, void **results,
|
|||
return 0;
|
||||
|
||||
radix_tree_for_each_slot(slot, root, &iter, first_index) {
|
||||
results[ret] = indirect_to_ptr(rcu_dereference_raw(*slot));
|
||||
results[ret] = rcu_dereference_raw(*slot);
|
||||
if (!results[ret])
|
||||
continue;
|
||||
if (radix_tree_is_indirect_ptr(results[ret])) {
|
||||
slot = radix_tree_iter_retry(&iter);
|
||||
continue;
|
||||
}
|
||||
if (++ret == max_items)
|
||||
break;
|
||||
}
|
||||
|
@ -1094,9 +1098,13 @@ radix_tree_gang_lookup_tag(struct radix_tree_root *root, void **results,
|
|||
return 0;
|
||||
|
||||
radix_tree_for_each_tagged(slot, root, &iter, first_index, tag) {
|
||||
results[ret] = indirect_to_ptr(rcu_dereference_raw(*slot));
|
||||
results[ret] = rcu_dereference_raw(*slot);
|
||||
if (!results[ret])
|
||||
continue;
|
||||
if (radix_tree_is_indirect_ptr(results[ret])) {
|
||||
slot = radix_tree_iter_retry(&iter);
|
||||
continue;
|
||||
}
|
||||
if (++ret == max_items)
|
||||
break;
|
||||
}
|
||||
|
|
|
@ -1473,7 +1473,7 @@ static int get_any_page(struct page *page, unsigned long pfn, int flags)
|
|||
* Did it turn free?
|
||||
*/
|
||||
ret = __get_any_page(page, pfn, 0);
|
||||
if (!PageLRU(page)) {
|
||||
if (ret == 1 && !PageLRU(page)) {
|
||||
/* Drop page reference which is from __get_any_page() */
|
||||
put_page(page);
|
||||
pr_info("soft_offline: %#lx: unknown non LRU page type %lx\n",
|
||||
|
|
|
@ -1276,23 +1276,30 @@ int is_mem_section_removable(unsigned long start_pfn, unsigned long nr_pages)
|
|||
*/
|
||||
static int test_pages_in_a_zone(unsigned long start_pfn, unsigned long end_pfn)
|
||||
{
|
||||
unsigned long pfn;
|
||||
unsigned long pfn, sec_end_pfn;
|
||||
struct zone *zone = NULL;
|
||||
struct page *page;
|
||||
int i;
|
||||
for (pfn = start_pfn;
|
||||
for (pfn = start_pfn, sec_end_pfn = SECTION_ALIGN_UP(start_pfn);
|
||||
pfn < end_pfn;
|
||||
pfn += MAX_ORDER_NR_PAGES) {
|
||||
i = 0;
|
||||
/* This is just a CONFIG_HOLES_IN_ZONE check.*/
|
||||
while ((i < MAX_ORDER_NR_PAGES) && !pfn_valid_within(pfn + i))
|
||||
i++;
|
||||
if (i == MAX_ORDER_NR_PAGES)
|
||||
pfn = sec_end_pfn + 1, sec_end_pfn += PAGES_PER_SECTION) {
|
||||
/* Make sure the memory section is present first */
|
||||
if (!present_section_nr(pfn_to_section_nr(pfn)))
|
||||
continue;
|
||||
page = pfn_to_page(pfn + i);
|
||||
if (zone && page_zone(page) != zone)
|
||||
return 0;
|
||||
zone = page_zone(page);
|
||||
for (; pfn < sec_end_pfn && pfn < end_pfn;
|
||||
pfn += MAX_ORDER_NR_PAGES) {
|
||||
i = 0;
|
||||
/* This is just a CONFIG_HOLES_IN_ZONE check.*/
|
||||
while ((i < MAX_ORDER_NR_PAGES) &&
|
||||
!pfn_valid_within(pfn + i))
|
||||
i++;
|
||||
if (i == MAX_ORDER_NR_PAGES)
|
||||
continue;
|
||||
page = pfn_to_page(pfn + i);
|
||||
if (zone && page_zone(page) != zone)
|
||||
return 0;
|
||||
zone = page_zone(page);
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
|
|
@ -298,7 +298,7 @@ static ssize_t process_vm_rw_core(pid_t pid, const struct iovec *lvec,
|
|||
goto free_proc_pages;
|
||||
}
|
||||
|
||||
mm = mm_access(task, PTRACE_MODE_ATTACH);
|
||||
mm = mm_access(task, PTRACE_MODE_ATTACH_REALCREDS);
|
||||
if (!mm || IS_ERR(mm)) {
|
||||
rc = IS_ERR(mm) ? PTR_ERR(mm) : -ESRCH;
|
||||
/*
|
||||
|
|
|
@ -336,7 +336,7 @@ static struct mr6_table *ip6mr_new_table(struct net *net, u32 id)
|
|||
|
||||
static void ip6mr_free_table(struct mr6_table *mrt)
|
||||
{
|
||||
del_timer(&mrt->ipmr_expire_timer);
|
||||
del_timer_sync(&mrt->ipmr_expire_timer);
|
||||
mroute_clean_tables(mrt, true);
|
||||
kfree(mrt);
|
||||
}
|
||||
|
|
|
@ -55,8 +55,8 @@ for name in common:
|
|||
delta.sort()
|
||||
delta.reverse()
|
||||
|
||||
print "add/remove: %s/%s grow/shrink: %s/%s up/down: %s/%s (%s)" % \
|
||||
(add, remove, grow, shrink, up, -down, up-down)
|
||||
print "%-40s %7s %7s %+7s" % ("function", "old", "new", "delta")
|
||||
print("add/remove: %s/%s grow/shrink: %s/%s up/down: %s/%s (%s)" % \
|
||||
(add, remove, grow, shrink, up, -down, up-down))
|
||||
print("%-40s %7s %7s %+7s" % ("function", "old", "new", "delta"))
|
||||
for d, n in delta:
|
||||
if d: print "%-40s %7s %7s %+7d" % (n, old.get(n,"-"), new.get(n,"-"), d)
|
||||
if d: print("%-40s %7s %7s %+7d" % (n, old.get(n,"-"), new.get(n,"-"), d))
|
||||
|
|
|
@ -153,12 +153,17 @@ int cap_ptrace_access_check(struct task_struct *child, unsigned int mode)
|
|||
{
|
||||
int ret = 0;
|
||||
const struct cred *cred, *child_cred;
|
||||
const kernel_cap_t *caller_caps;
|
||||
|
||||
rcu_read_lock();
|
||||
cred = current_cred();
|
||||
child_cred = __task_cred(child);
|
||||
if (mode & PTRACE_MODE_FSCREDS)
|
||||
caller_caps = &cred->cap_effective;
|
||||
else
|
||||
caller_caps = &cred->cap_permitted;
|
||||
if (cred->user_ns == child_cred->user_ns &&
|
||||
cap_issubset(child_cred->cap_permitted, cred->cap_permitted))
|
||||
cap_issubset(child_cred->cap_permitted, *caller_caps))
|
||||
goto out;
|
||||
if (ns_capable(child_cred->user_ns, CAP_SYS_PTRACE))
|
||||
goto out;
|
||||
|
|
|
@ -540,19 +540,22 @@ static void delete_and_unsubscribe_port(struct snd_seq_client *client,
|
|||
bool is_src, bool ack)
|
||||
{
|
||||
struct snd_seq_port_subs_info *grp;
|
||||
struct list_head *list;
|
||||
bool empty;
|
||||
|
||||
grp = is_src ? &port->c_src : &port->c_dest;
|
||||
list = is_src ? &subs->src_list : &subs->dest_list;
|
||||
down_write(&grp->list_mutex);
|
||||
write_lock_irq(&grp->list_lock);
|
||||
if (is_src)
|
||||
list_del(&subs->src_list);
|
||||
else
|
||||
list_del(&subs->dest_list);
|
||||
empty = list_empty(list);
|
||||
if (!empty)
|
||||
list_del_init(list);
|
||||
grp->exclusive = 0;
|
||||
write_unlock_irq(&grp->list_lock);
|
||||
up_write(&grp->list_mutex);
|
||||
|
||||
unsubscribe_port(client, port, grp, &subs->info, ack);
|
||||
if (!empty)
|
||||
unsubscribe_port(client, port, grp, &subs->info, ack);
|
||||
}
|
||||
|
||||
/* connect two ports */
|
||||
|
|
|
@ -4190,13 +4190,12 @@ static void pretty_print(struct trace_seq *s, void *data, int size, struct event
|
|||
sizeof(long) != 8) {
|
||||
char *p;
|
||||
|
||||
ls = 2;
|
||||
/* make %l into %ll */
|
||||
p = strchr(format, 'l');
|
||||
if (p)
|
||||
if (ls == 1 && (p = strchr(format, 'l')))
|
||||
memmove(p+1, p, strlen(p)+1);
|
||||
else if (strcmp(format, "%p") == 0)
|
||||
strcpy(format, "0x%llx");
|
||||
ls = 2;
|
||||
}
|
||||
switch (ls) {
|
||||
case -2:
|
||||
|
|
Loading…
Reference in New Issue