Open Build Service

_service:tar_scm_kernel_repo:kernel.spec Changed

@@ -12,7 +12,7 @@
 
 %global KernelVer %{version}-%{release}.%{_target_cpu}
 
-%global hulkrelease 2312.4.0
+%global hulkrelease 2312.6.0
 
 %define with_patch 0
 
@@ -32,7 +32,7 @@
 
 Name:	 kernel
 Version: 4.19.90
-Release: %{hulkrelease}.0231
+Release: %{hulkrelease}.0232
 Summary: Linux Kernel
 License: GPLv2
 URL:	 http://www.kernel.org/
@@ -809,6 +809,22 @@
 
 %changelog
 
+* Wed Dec 27 2023 Zhang Changzhong <zhangchangzhong@huawei.com> - 4.19.90-2312.6.0.0232
+- !3607  Fix CVE-2023-6546
+- !3606  perf/core: Fix CVE-2023-6931
+- tty: n_gsm: fix the UAF caused by race condition in gsm_cleanup_mux
+- tty: n_gsm: fix restart handling via CLD command
+- perf: Fix perf_event_validate_size() lockdep splat
+- perf: Fix perf_event_validate_size()
+- !3417  SCSI: hisi_raid: support SPxxx serial RAID/HBA controllers
+- !3531 Fix kernel panic occurs during ISO installation on the 20.03 SP3/SP4
+- i2c: hisi: Only handle the interrupt of the driver's transfer
+- i2c: hisi: Only use the completion interrupt to finish the transfer
+- i2c: hisi: Avoid redundant interrupts
+- !3483  net: Remove acked SYN flag from packet in the transmit queue correctly
+- net: Remove acked SYN flag from packet in the transmit queue correctly
+- SCSI: hisi_raid: support SPxxx serial RAID/HBA controllers
+
 * Tue Dec 19 2023 Zhang Changzhong <zhangchangzhong@huawei.com> - 4.19.90-2312.4.0.0231
 - !3426  Revert "hrtimers: Push pending hrtimers away from outgoing CPU earlier"
 - Revert "hrtimers: Push pending hrtimers away from outgoing CPU earlier"

_service:recompress:tar_scm_kernel_repo:kernel.tar.gz/Documentation/scsi/hisi_raid.rst Added

@@ -0,0 +1,84 @@
+.. SPDX-License-Identifier: GPL-2.0
+
+==============================================
+hisi_raid - HUAWEI SCSI RAID Controller driver
+==============================================
+
+This file describes the hisi_raid SCSI driver for HUAWEI
+RAID controllers. The hisi_raid driver is the first
+generation RAID driver.
+
+For hisi_raid controller support, enable the hisi_raid driver
+when configuring the kernel.
+
+hisi_raid specific entries in /sys
+=================================
+
+hisi_raid host attributes
+------------------------
+  - /sys/class/scsi_host/host*/csts_pp
+  - /sys/class/scsi_host/host*/csts_shst
+  - /sys/class/scsi_host/host*/csts_cfs
+  - /sys/class/scsi_host/host*/csts_rdy
+  - /sys/class/scsi_host/host*/fw_version
+
+  The host csts_pp attribute is a read only attribute. This attribute
+  indicates whether the controller is processing commands. If this attribute
+  is set to ‘1’, then the controller is processing commands normally. If
+  this attribute is cleared to ‘0’, then the controller has temporarily stopped
+  processing commands in order to handle an event (e.g., firmware activation).
+
+  The host csts_shst attribute is a read only attribute. This attribute
+  indicates status of shutdown processing.The shutdown status values are defined
+  as:
+        ======     ==============================
+        Value      Definition
+        ======     ==============================
+        00b        Normal operation
+        01b        Shutdown processing occurring
+        10b        Shutdown processing complete
+        11b        Reserved
+        ======     ==============================
+  The host csts_cfs attribute is a read only attribute. This attribute is set to
+  ’1’ when a fatal controller error occurred that could not be communicated in the
+  appropriate Completion Queue. This bit is cleared to ‘0’ when a fatal controller
+  error has not occurred.
+
+  The host csts_rdy attribute is a read only attribute. This attribute is set to
+  ‘1’ when the controller is ready to process submission queue entries.
+
+  The fw_version attribute is read-only and will return the driver version and the
+  controller firmware version.
+
+hisi_raid scsi device attributes
+------------------------------
+  - /sys/class/scsi_device/X\:X\:X\:X/device/raid_level
+  - /sys/class/scsi_device/X\:X\:X\:X/device/raid_state
+  - /sys/class/scsi_device/X\:X\:X\:X/device/raid_resync
+
+  The device raid_level attribute is a read only attribute. This attribute indicates
+  RAID level of scsi device(will dispaly "NA" if scsi device is not virtual disk type).
+
+  The device raid_state attribute is read-only and indicates RAID status of scsi
+  device(will dispaly "NA" if scsi device is not virtual disk type).
+
+  The device raid_resync attribute is read-only and indicates RAID rebuild processing
+  of scsi device(will dispaly "NA" if scsi device is not virtual disk type).
+
+Supported devices
+=================
+
+        ===================     ======= =======================================
+        PCI ID (pci.ids)        OEM     Product
+        ===================     ======= =======================================
+        19E5:3858               HUAWEI 	SP186-M-8i(HBA:8Ports)
+        19E5:3858               HUAWEI 	SP186-M-16i(HBA:16Ports)
+        19E5:3858               HUAWEI 	SP186-M-32i(HBA:32Ports)
+        19E5:3858               HUAWEI 	SP186-M-40i(HBA:40Ports)
+        19E5:3758               HUAWEI 	SP686C-M-16i(RAID:16Ports,2G cache)
+        19E5:3758               HUAWEI 	SP686C-M-16i(RAID:16Ports,4G cache)
+        19E5:3758               HUAWEI 	SP686C-MH-32i(RAID:32Ports,4G cache)
+        19E5:3758               HUAWEI 	SP686C-M-40i(RAID:40Ports,2G cache)
+        19E5:3758               HUAWEI 	SP686C-M-40i(RAID:40Ports,4G cache)
+        ===================     ======= =======================================
+

_service:recompress:tar_scm_kernel_repo:kernel.tar.gz/MAINTAINERS Changed

_service:recompress:tar_scm_kernel_repo:kernel.tar.gz/arch/arm64/configs/openeuler_defconfig Changed

_service:recompress:tar_scm_kernel_repo:kernel.tar.gz/arch/x86/configs/openeuler_defconfig Changed

_service:recompress:tar_scm_kernel_repo:kernel.tar.gz/drivers/i2c/busses/i2c-hisi.c Changed

@@ -320,6 +320,13 @@
 		    max_write == 0)
 			break;
 	}
+
+	/*
+	 * Disable the TX_EMPTY interrupt after finishing all the messages to
+	 * avoid overwhelming the CPU.
+	 */
+	if (ctlr->msg_tx_idx == ctlr->msg_num)
+		hisi_i2c_disable_int(ctlr, HISI_I2C_INT_TX_EMPTY);
 }
 
 static irqreturn_t hisi_i2c_irq(int irq, void *context)
@@ -327,6 +334,14 @@
 	struct hisi_i2c_controller *ctlr = context;
 	u32 int_stat;
 
+	/*
+	 * Don't handle the interrupt if cltr->completion is NULL. We may
+	 * reach here because the interrupt is spurious or the transfer is
+	 * started by another port (e.g. firmware) rather than us.
+	 */
+	if (!ctlr->completion)
+		return IRQ_NONE;
+
 	int_stat = readl(ctlr->iobase + HISI_I2C_INT_MSTAT);
 	hisi_i2c_clear_int(ctlr, int_stat);
 	if (!(int_stat & HISI_I2C_INT_ALL))
@@ -345,7 +360,11 @@
 		hisi_i2c_read_rx_fifo(ctlr);
 
 out:
-	if (int_stat & HISI_I2C_INT_TRANS_CPLT || ctlr->xfer_err) {
+	/*
+	 * Only use TRANS_CPLT to indicate the completion. On error cases we'll
+	 * get two interrupts, INT_ERR first then TRANS_CPLT.
+	 */
+	if (int_stat & HISI_I2C_INT_TRANS_CPLT) {
 		hisi_i2c_disable_int(ctlr, HISI_I2C_INT_ALL);
 		hisi_i2c_clear_int(ctlr, HISI_I2C_INT_ALL);
 		complete(ctlr->completion);

_service:recompress:tar_scm_kernel_repo:kernel.tar.gz/drivers/scsi/Kconfig Changed

_service:recompress:tar_scm_kernel_repo:kernel.tar.gz/drivers/scsi/Makefile Changed

_service:recompress:tar_scm_kernel_repo:kernel.tar.gz/drivers/scsi/hisi_raid Added

_service:recompress:tar_scm_kernel_repo:kernel.tar.gz/drivers/scsi/hisi_raid/Kconfig Added

_service:recompress:tar_scm_kernel_repo:kernel.tar.gz/drivers/scsi/hisi_raid/Makefile Added

_service:recompress:tar_scm_kernel_repo:kernel.tar.gz/drivers/scsi/hisi_raid/hiraid.h Added

@@ -0,0 +1,760 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/* Copyright(c) 2022 Huawei Technologies Co., Ltd */
+
+#ifndef __HIRAID_H_
+#define __HIRAID_H_
+
+#define HIRAID_HDD_PD_QD 64
+#define HIRAID_HDD_VD_QD 256
+#define HIRAID_SSD_PD_QD 64
+#define HIRAID_SSD_VD_QD 256
+
+#define BGTASK_TYPE_REBUILD 4
+#define USR_CMD_READ 0xc2
+#define USR_CMD_RDLEN 0x1000
+#define USR_CMD_VDINFO 0x704
+#define USR_CMD_BGTASK 0x504
+#define VDINFO_PARAM_LEN 0x04
+
+#define HIRAID_DEFAULT_MAX_CHANNEL 4
+#define HIRAID_DEFAULT_MAX_ID 240
+#define HIRAID_DEFAULT_MAX_LUN_PER_HOST 8
+
+#define FUA_MASK 0x08
+
+#define HIRAID_IO_SQES 7
+#define HIRAID_IO_CQES 4
+#define PRP_ENTRY_SIZE 8
+
+#define EXTRA_POOL_SIZE 256
+#define MAX_EXTRA_POOL_NUM 16
+#define MAX_CMD_PER_DEV 64
+#define MAX_CDB_LEN 16
+
+#define HIRAID_AQ_DEPTH 128
+#define HIRAID_ASYN_COMMANDS 16
+#define HIRAID_AQ_BLK_MQ_DEPTH (HIRAID_AQ_DEPTH - HIRAID_ASYN_COMMANDS)
+#define HIRAID_AQ_MQ_TAG_DEPTH (HIRAID_AQ_BLK_MQ_DEPTH - 1)
+
+#define HIRAID_ADMIN_QUEUE_NUM 1
+#define HIRAID_PTHRU_CMDS_PERQ 1
+#define HIRAID_TOTAL_PTCMDS(qn) (HIRAID_PTHRU_CMDS_PERQ * (qn))
+
+#define HIRAID_DEV_INFO_ATTR_BOOT(attr) ((attr) & 0x01)
+#define HIRAID_DEV_INFO_ATTR_VD(attr) (((attr) & 0x02) == 0x0)
+#define HIRAID_DEV_INFO_ATTR_PT(attr) (((attr) & 0x22) == 0x02)
+#define HIRAID_DEV_INFO_ATTR_RAWDISK(attr) ((attr) & 0x20)
+#define HIRAID_DEV_DISK_TYPE(attr) ((attr) & 0x1e)
+
+#define HIRAID_DEV_INFO_FLAG_VALID(flag) ((flag) & 0x01)
+#define HIRAID_DEV_INFO_FLAG_CHANGE(flag) ((flag) & 0x02)
+
+#define HIRAID_CAP_MQES(cap) ((cap) & 0xffff)
+#define HIRAID_CAP_STRIDE(cap) (((cap) >> 32) & 0xf)
+#define HIRAID_CAP_MPSMIN(cap) (((cap) >> 48) & 0xf)
+#define HIRAID_CAP_MPSMAX(cap) (((cap) >> 52) & 0xf)
+#define HIRAID_CAP_TIMEOUT(cap) (((cap) >> 24) & 0xff)
+#define HIRAID_CAP_DMAMASK(cap) (((cap) >> 37) & 0xff)
+
+#define IO_SQE_SIZE sizeof(struct hiraid_scsi_io_cmd)
+#define ADMIN_SQE_SIZE sizeof(struct hiraid_admin_command)
+#define SQE_SIZE(qid) (((qid) > 0) ? IO_SQE_SIZE : ADMIN_SQE_SIZE)
+#define CQ_SIZE(depth) ((depth) * sizeof(struct hiraid_completion))
+#define SQ_SIZE(qid, depth) ((depth) * SQE_SIZE(qid))
+
+#define SENSE_SIZE(depth)	((depth) * SCSI_SENSE_BUFFERSIZE)
+
+#define IO_6_DEFAULT_TX_LEN 256
+
+#define MAX_DEV_ENTRY_PER_PAGE_4K	340
+
+#define MAX_REALTIME_BGTASK_NUM 32
+
+#define PCI_VENDOR_ID_HUAWEI_LOGIC 0x19E5
+#define HIRAID_SERVER_DEVICE_HBA_DID	0x3858
+#define HIRAID_SERVER_DEVICE_RAID_DID	0x3758
+
+enum {
+	HIRAID_SC_SUCCESS = 0x0,
+	HIRAID_SC_INVALID_OPCODE = 0x1,
+	HIRAID_SC_INVALID_FIELD  = 0x2,
+
+	HIRAID_SC_ABORT_LIMIT = 0x103,
+	HIRAID_SC_ABORT_MISSING = 0x104,
+	HIRAID_SC_ASYNC_LIMIT = 0x105,
+
+	HIRAID_SC_DNR = 0x4000,
+};
+
+enum {
+	HIRAID_REG_CAP  = 0x0000,
+	HIRAID_REG_CC   = 0x0014,
+	HIRAID_REG_CSTS = 0x001c,
+	HIRAID_REG_AQA  = 0x0024,
+	HIRAID_REG_ASQ  = 0x0028,
+	HIRAID_REG_ACQ  = 0x0030,
+	HIRAID_REG_DBS  = 0x1000,
+};
+
+enum {
+	HIRAID_CC_ENABLE     = 1 << 0,
+	HIRAID_CC_CSS_NVM    = 0 << 4,
+	HIRAID_CC_MPS_SHIFT  = 7,
+	HIRAID_CC_AMS_SHIFT  = 11,
+	HIRAID_CC_SHN_SHIFT  = 14,
+	HIRAID_CC_IOSQES_SHIFT = 16,
+	HIRAID_CC_IOCQES_SHIFT = 20,
+	HIRAID_CC_AMS_RR       = 0 << HIRAID_CC_AMS_SHIFT,
+	HIRAID_CC_SHN_NONE     = 0 << HIRAID_CC_SHN_SHIFT,
+	HIRAID_CC_IOSQES       = HIRAID_IO_SQES << HIRAID_CC_IOSQES_SHIFT,
+	HIRAID_CC_IOCQES       = HIRAID_IO_CQES << HIRAID_CC_IOCQES_SHIFT,
+	HIRAID_CC_SHN_NORMAL   = 1 << HIRAID_CC_SHN_SHIFT,
+	HIRAID_CC_SHN_MASK     = 3 << HIRAID_CC_SHN_SHIFT,
+	HIRAID_CSTS_CFS_SHIFT  = 1,
+	HIRAID_CSTS_SHST_SHIFT = 2,
+	HIRAID_CSTS_PP_SHIFT   = 5,
+	HIRAID_CSTS_RDY	       = 1 << 0,
+	HIRAID_CSTS_SHST_CMPLT = 2 << 2,
+	HIRAID_CSTS_SHST_MASK  = 3 << 2,
+	HIRAID_CSTS_CFS_MASK   = 1 << HIRAID_CSTS_CFS_SHIFT,
+	HIRAID_CSTS_PP_MASK    = 1 << HIRAID_CSTS_PP_SHIFT,
+};
+
+enum {
+	HIRAID_ADMIN_DELETE_SQ = 0x00,
+	HIRAID_ADMIN_CREATE_SQ = 0x01,
+	HIRAID_ADMIN_DELETE_CQ = 0x04,
+	HIRAID_ADMIN_CREATE_CQ = 0x05,
+	HIRAID_ADMIN_ABORT_CMD = 0x08,
+	HIRAID_ADMIN_SET_FEATURES = 0x09,
+	HIRAID_ADMIN_ASYNC_EVENT = 0x0c,
+	HIRAID_ADMIN_GET_INFO = 0xc6,
+	HIRAID_ADMIN_RESET = 0xc8,
+};
+
+enum {
+	HIRAID_GET_CTRL_INFO = 0,
+	HIRAID_GET_DEVLIST_INFO = 1,
+};
+
+enum hiraid_rst_type {
+	HIRAID_RESET_TARGET = 0,
+	HIRAID_RESET_BUS = 1,
+};
+
+enum {
+	HIRAID_ASYN_EVENT_ERROR = 0,
+	HIRAID_ASYN_EVENT_NOTICE = 2,
+	HIRAID_ASYN_EVENT_VS = 7,
+};
+
+enum {
+	HIRAID_ASYN_DEV_CHANGED = 0x00,
+	HIRAID_ASYN_FW_ACT_START = 0x01,
+	HIRAID_ASYN_HOST_PROBING = 0x10,
+};
+
+enum {
+	HIRAID_ASYN_TIMESYN = 0x00,
+	HIRAID_ASYN_FW_ACT_FINISH = 0x02,
+	HIRAID_ASYN_EVENT_MIN = 0x80,
+	HIRAID_ASYN_EVENT_MAX = 0xff,
+};
+
+enum {
+	HIRAID_CMD_WRITE = 0x01,
+	HIRAID_CMD_READ = 0x02,
+
+	HIRAID_CMD_NONRW_NONE = 0x80,
+	HIRAID_CMD_NONRW_TODEV = 0x81,
+	HIRAID_CMD_NONRW_FROMDEV = 0x82,
+};
+
+enum {
+	HIRAID_QUEUE_PHYS_CONTIG = (1 << 0),
+	HIRAID_CQ_IRQ_ENABLED = (1 << 1),
+
+	HIRAID_FEATURE_NUM_QUEUES = 0x07,
+	HIRAID_FEATURE_ASYNC_EVENT = 0x0b,
+	HIRAID_FEATURE_TIMESTAMP = 0x0e,
+};
+
+enum hiraid_dev_state {
+	DEV_NEW,
+	DEV_LIVE,
+	DEV_RESETTING,
+	DEV_DELETING,
+	DEV_DEAD,
+};
+
+enum {
+	HIRAID_CARD_HBA,
+	HIRAID_CARD_RAID,
+};
+
+enum hiraid_cmd_type {
+	HIRAID_CMD_ADMIN,
+	HIRAID_CMD_PTHRU,
+};
+

_service:recompress:tar_scm_kernel_repo:kernel.tar.gz/drivers/scsi/hisi_raid/hiraid_main.c Added

@@ -0,0 +1,4160 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright(c) 2022 Huawei Technologies Co., Ltd */
+
+/* Huawei Raid Series Linux Driver */
+
+#define pr_fmt(fmt) "hiraid: " fmt
+
+#include <linux/sched/signal.h>
+#include <linux/version.h>
+#include <linux/pci.h>
+#include <linux/aer.h>
+#include <linux/module.h>
+#include <linux/ioport.h>
+#include <linux/device.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/cdev.h>
+#include <linux/sysfs.h>
+#include <linux/gfp.h>
+#include <linux/types.h>
+#include <linux/ratelimit.h>
+#include <linux/once.h>
+#include <linux/debugfs.h>
+#include <linux/io-64-nonatomic-lo-hi.h>
+#include <linux/blkdev.h>
+#include <linux/bsg-lib.h>
+#include <asm/unaligned.h>
+#include <linux/sort.h>
+#include <target/target_core_backend.h>
+
+#include <scsi/scsi.h>
+#include <scsi/scsi_cmnd.h>
+#include <scsi/scsi_device.h>
+#include <scsi/scsi_host.h>
+#include <scsi/scsi_transport.h>
+#include <scsi/scsi_dbg.h>
+#include <scsi/sg.h>
+
+#include "hiraid.h"
+
+static u32 admin_tmout = 60;
+module_param(admin_tmout, uint, 0644);
+MODULE_PARM_DESC(admin_tmout, "admin commands timeout (seconds)");
+
+static u32 scmd_tmout_rawdisk = 180;
+module_param(scmd_tmout_rawdisk, uint, 0644);
+MODULE_PARM_DESC(scmd_tmout_rawdisk, "scsi commands timeout for rawdisk(seconds)");
+
+static u32 scmd_tmout_vd = 180;
+module_param(scmd_tmout_vd, uint, 0644);
+MODULE_PARM_DESC(scmd_tmout_vd, "scsi commands timeout for vd(seconds)");
+
+static bool max_io_force;
+module_param(max_io_force, bool, 0644);
+MODULE_PARM_DESC(max_io_force, "force max_hw_sectors_kb = 1024, default false(performance first)");
+
+static bool work_mode;
+module_param(work_mode, bool, 0444);
+MODULE_PARM_DESC(work_mode, "work mode switch, default false for multi hw queues");
+
+#define MAX_IO_QUEUES		128
+#define MIN_IO_QUEUES		1
+
+static int ioq_num_set(const char *val, const struct kernel_param *kp)
+{
+	int n = 0;
+	int ret;
+
+	ret = kstrtoint(val, 10, &n);
+	if (ret != 0 || n < MIN_IO_QUEUES || n > MAX_IO_QUEUES)
+		return -EINVAL;
+
+	return param_set_int(val, kp);
+}
+
+static const struct kernel_param_ops max_hwq_num_ops = {
+	.set = ioq_num_set,
+	.get = param_get_uint,
+};
+
+static u32 max_hwq_num = 128;
+module_param_cb(max_hwq_num, &max_hwq_num_ops, &max_hwq_num, 0444);
+MODULE_PARM_DESC(max_hwq_num, "max num of hw io queues, should >= 1, default 128");
+
+static int io_queue_depth_set(const char *val, const struct kernel_param *kp)
+{
+	int n = 0;
+	int ret;
+
+	ret = kstrtoint(val, 10, &n);
+	if (ret != 0 || n < 2)
+		return -EINVAL;
+
+	return param_set_int(val, kp);
+}
+
+static const struct kernel_param_ops io_queue_depth_ops = {
+	.set = io_queue_depth_set,
+	.get = param_get_uint,
+};
+
+static u32 io_queue_depth = 1024;
+module_param_cb(io_queue_depth, &io_queue_depth_ops, &io_queue_depth, 0644);
+MODULE_PARM_DESC(io_queue_depth, "set io queue depth, should >= 2");
+
+static u32 log_debug_switch;
+module_param(log_debug_switch, uint, 0644);
+MODULE_PARM_DESC(log_debug_switch, "set log state, default zero for switch off");
+
+static int extra_pool_num_set(const char *val, const struct kernel_param *kp)
+{
+	u8 n = 0;
+	int ret;
+
+	ret = kstrtou8(val, 10, &n);
+	if (ret != 0)
+		return -EINVAL;
+	if (n > MAX_EXTRA_POOL_NUM)
+		n = MAX_EXTRA_POOL_NUM;
+	if (n < 1)
+		n = 1;
+	*((u8 *)kp->arg) = n;
+
+	return 0;
+}
+
+static const struct kernel_param_ops small_pool_num_ops = {
+	.set = extra_pool_num_set,
+	.get = param_get_byte,
+};
+
+/* It was found that the spindlock of a single pool conflicts
+ * a lot with multiple CPUs.So multiple pools are introduced
+ * to reduce the conflictions.
+ */
+static unsigned char extra_pool_num = 4;
+module_param_cb(extra_pool_num, &small_pool_num_ops, &extra_pool_num, 0644);
+MODULE_PARM_DESC(extra_pool_num, "set prp extra pool num, default 4, MAX 16");
+
+static void hiraid_handle_async_notice(struct hiraid_dev *hdev, u32 result);
+static void hiraid_handle_async_vs(struct hiraid_dev *hdev,
+					u32 result, u32 result1);
+
+static struct class *hiraid_class;
+
+#define HIRAID_CAP_TIMEOUT_UNIT_MS	(HZ / 2)
+
+static struct workqueue_struct *work_queue;
+
+#define dev_log_dbg(dev, fmt, ...)	do { \
+	if (unlikely(log_debug_switch))	\
+		dev_info(dev, "[%s] " fmt,	\
+			__func__, ##__VA_ARGS__);	\
+} while (0)
+
+#define HIRAID_DRV_VERSION	"1.1.0.0"
+
+#define ADMIN_TIMEOUT		(admin_tmout * HZ)
+#define USRCMD_TIMEOUT		(180 * HZ)
+#define CTL_RST_TIME		(600 * HZ)
+
+#define HIRAID_WAIT_ABNL_CMD_TIMEOUT	6
+#define HIRAID_WAIT_RST_IO_TIMEOUT		10
+
+#define HIRAID_DMA_MSK_BIT_MAX	64
+
+#define IOQ_PT_DATA_LEN		    4096
+#define IOQ_PT_SGL_DATA_LEN		(1024 * 1024)
+
+#define MAX_CAN_QUEUE		(4096 - 1)
+#define MIN_CAN_QUEUE		(1024 - 1)
+
+enum SENSE_STATE_CODE {
+	SENSE_STATE_OK = 0,
+	SENSE_STATE_NEED_CHECK,
+	SENSE_STATE_ERROR,
+	SENSE_STATE_EP_PCIE_ERROR,
+	SENSE_STATE_NAC_DMA_ERROR,
+	SENSE_STATE_ABORTED,
+	SENSE_STATE_NEED_RETRY
+};
+
+enum {
+	FW_EH_OK = 0,
+	FW_EH_DEV_NONE = 0x701
+};
+
+static const char * const raid_levels[] = {"0", "1", "5", "6",
+					   "10", "50", "60", "NA"};
+
+static const char * const raid_states[] = {
+	"NA", "NORMAL", "FAULT", "DEGRADE", "NOT_FORMATTED", "FORMATTING",
+	"SANITIZING", "INITIALIZING", "INITIALIZE_FAIL", "DELETING",
+	"DELETE_FAIL", "WRITE_PROTECT"
+};
+
+static int hiraid_remap_bar(struct hiraid_dev *hdev, u32 size)
+{
+	struct pci_dev *pdev = hdev->pdev;

_service:recompress:tar_scm_kernel_repo:kernel.tar.gz/drivers/tty/n_gsm.c Changed

@@ -2024,49 +2024,36 @@
 	gsm->io_error++;
 }
 
-static int gsm_disconnect(struct gsm_mux *gsm)
-{
-	struct gsm_dlci *dlci = gsm->dlci[0];
-	struct gsm_control *gc;
-
-	if (!dlci)
-		return 0;
-
-	/* In theory disconnecting DLCI 0 is sufficient but for some
-	   modems this is apparently not the case. */
-	gc = gsm_control_send(gsm, CMD_CLD, NULL, 0);
-	if (gc)
-		gsm_control_wait(gsm, gc);
-
-	del_timer_sync(&gsm->t2_timer);
-	/* Now we are sure T2 has stopped */
-
-	gsm_dlci_begin_close(dlci);
-	wait_event_interruptible(gsm->event,
-				dlci->state == DLCI_CLOSED);
-
-	if (signal_pending(current))
-		return -EINTR;
-
-	return 0;
-}
-
 /**
  *	gsm_cleanup_mux		-	generic GSM protocol cleanup
  *	@gsm: our mux
+ *	@disc: disconnect link?
  *
  *	Clean up the bits of the mux which are the same for all framing
  *	protocols. Remove the mux from the mux table, stop all the timers
  *	and then shut down each device hanging up the channels as we go.
  */
 
-static void gsm_cleanup_mux(struct gsm_mux *gsm)
+static void gsm_cleanup_mux(struct gsm_mux *gsm, bool disc)
 {
 	int i;
-	struct gsm_dlci *dlci = gsm->dlci[0];
+	struct gsm_dlci *dlci;
 	struct gsm_msg *txq, *ntxq;
 
 	gsm->dead = 1;
+	mutex_lock(&gsm->mutex);
+
+	dlci = gsm->dlci[0];
+	if (dlci) {
+		if (disc && dlci->state != DLCI_CLOSED) {
+			gsm_dlci_begin_close(dlci);
+			wait_event(gsm->event, dlci->state == DLCI_CLOSED);
+		}
+		dlci->dead = true;
+	}
+
+	/* Finish outstanding timers, making sure they are done */
+	del_timer_sync(&gsm->t2_timer);
 
 	spin_lock(&gsm_mux_lock);
 	for (i = 0; i < MAX_MUX; i++) {
@@ -2080,13 +2067,7 @@
 	if (i == MAX_MUX)
 		return;
 
-	del_timer_sync(&gsm->t2_timer);
-	/* Now we are sure T2 has stopped */
-	if (dlci)
-		dlci->dead = 1;
-
 	/* Free up any link layer users */
-	mutex_lock(&gsm->mutex);
 	for (i = 0; i < NUM_DLCI; i++)
 		if (gsm->dlci[i])
 			gsm_dlci_release(gsm->dlci[i]);
@@ -2285,7 +2266,7 @@
 	WARN_ON(tty != gsm->tty);
 	for (i = 1; i < NUM_DLCI; i++)
 		tty_unregister_device(gsm_tty_driver, base + i);
-	gsm_cleanup_mux(gsm);
+	gsm_cleanup_mux(gsm, false);
 	tty_kref_put(gsm->tty);
 	gsm->tty = NULL;
 }
@@ -2391,7 +2372,7 @@
 
 	ret = gsmld_attach_gsm(tty, gsm);
 	if (ret != 0) {
-		gsm_cleanup_mux(gsm);
+		gsm_cleanup_mux(gsm, false);
 		mux_put(gsm);
 	}
 	return ret;
@@ -2540,19 +2521,11 @@
 
 	/*
 	 *	Close down what is needed, restart and initiate the new
-	 *	configuration
+	 *	configuration. On the first time there is no DLCI[0]
+	 *	and closing or cleaning up is not necessary.
 	 */
-
-	if (need_close || need_restart) {
-		int ret;
-
-		ret = gsm_disconnect(gsm);
-
-		if (ret)
-			return ret;
-	}
-	if (need_restart)
-		gsm_cleanup_mux(gsm);
+	if (need_close || need_restart)
+		gsm_cleanup_mux(gsm, true);
 
 	gsm->initiator = c->initiator;
 	gsm->mru = c->mru;

_service:recompress:tar_scm_kernel_repo:kernel.tar.gz/kernel/events/core.c Changed

@@ -1705,28 +1705,31 @@
 					      PERF_EVENT_STATE_INACTIVE;
 }
 
-static void __perf_event_read_size(struct perf_event *event, int nr_siblings)
+static int __perf_event_read_size(u64 read_format, int nr_siblings)
 {
 	int entry = sizeof(u64); /* value */
 	int size = 0;
 	int nr = 1;
 
-	if (event->attr.read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
+	if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
 		size += sizeof(u64);
 
-	if (event->attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
+	if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
 		size += sizeof(u64);
 
-	if (event->attr.read_format & PERF_FORMAT_ID)
+	if (read_format & PERF_FORMAT_ID)
 		entry += sizeof(u64);
 
-	if (event->attr.read_format & PERF_FORMAT_GROUP) {
+	if (read_format & PERF_FORMAT_GROUP) {
 		nr += nr_siblings;
 		size += sizeof(u64);
 	}
 
-	size += entry * nr;
-	event->read_size = size;
+	/*
+	 * Since perf_event_validate_size() limits this to 16k and inhibits
+	 * adding more siblings, this will never overflow.
+	 */
+	return size + nr * entry;
 }
 
 static void __perf_event_header_size(struct perf_event *event, u64 sample_type)
@@ -1767,8 +1770,9 @@
  */
 static void perf_event__header_size(struct perf_event *event)
 {
-	__perf_event_read_size(event,
-			       event->group_leader->nr_siblings);
+	event->read_size =
+		__perf_event_read_size(event->attr.read_format,
+				       event->group_leader->nr_siblings);
 	__perf_event_header_size(event, event->attr.sample_type);
 }
 
@@ -1799,23 +1803,44 @@
 	event->id_header_size = size;
 }
 
+/*
+ * Check that adding an event to the group does not result in anybody
+ * overflowing the 64k event limit imposed by the output buffer.
+ *
+ * Specifically, check that the read_size for the event does not exceed 16k,
+ * read_size being the one term that grows with groups size. Since read_size
+ * depends on per-event read_format, also (re)check the existing events.
+ *
+ * This leaves 48k for the constant size fields and things like callchains,
+ * branch stacks and register sets.
+ */
 static bool perf_event_validate_size(struct perf_event *event)
 {
-	/*
-	 * The values computed here will be over-written when we actually
-	 * attach the event.
-	 */
-	__perf_event_read_size(event, event->group_leader->nr_siblings + 1);
-	__perf_event_header_size(event, event->attr.sample_type & ~PERF_SAMPLE_READ);
-	perf_event__id_header_size(event);
+	struct perf_event *sibling, *group_leader = event->group_leader;
+
+	if (__perf_event_read_size(event->attr.read_format,
+				   group_leader->nr_siblings + 1) > 16*1024)
+		return false;
+
+	if (__perf_event_read_size(group_leader->attr.read_format,
+				   group_leader->nr_siblings + 1) > 16*1024)
+		return false;
 
 	/*
-	 * Sum the lot; should not exceed the 64k limit we have on records.
-	 * Conservative limit to allow for callchains and other variable fields.
+	 * When creating a new group leader, group_leader->ctx is initialized
+	 * after the size has been validated, but we cannot safely use
+	 * for_each_sibling_event() until group_leader->ctx is set. A new group
+	 * leader cannot have any siblings yet, so we can safely skip checking
+	 * the non-existent siblings.
 	 */
-	if (event->read_size + event->header_size +
-	    event->id_header_size + sizeof(struct perf_event_header) >= 16*1024)
-		return false;
+	if (event == group_leader)
+		return true;
+
+	for_each_sibling_event(sibling, group_leader) {
+		if (__perf_event_read_size(sibling->attr.read_format,
+					   group_leader->nr_siblings + 1) > 16*1024)
+			return false;
+	}
 
 	return true;
 }

_service:recompress:tar_scm_kernel_repo:kernel.tar.gz/net/ipv4/tcp_output.c Changed

_service:tar_scm_kernel_repo:SOURCE Changed

Changes of Revision 344