aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--drivers/scsi/mpt2sas/mpt2sas_ctl.c297
1 files changed, 122 insertions, 175 deletions
diff --git a/drivers/scsi/mpt2sas/mpt2sas_ctl.c b/drivers/scsi/mpt2sas/mpt2sas_ctl.c
index 3b9a28efea82..8eb85e1a0c37 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_ctl.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_ctl.c
@@ -620,11 +620,10 @@ _ctl_set_task_mid(struct MPT2SAS_ADAPTER *ioc, struct mpt2_ioctl_command *karg,
620 * @ioc: per adapter object 620 * @ioc: per adapter object
621 * @karg - (struct mpt2_ioctl_command) 621 * @karg - (struct mpt2_ioctl_command)
622 * @mf - pointer to mf in user space 622 * @mf - pointer to mf in user space
623 * @state - NON_BLOCKING or BLOCKING
624 */ 623 */
625static long 624static long
626_ctl_do_mpt_command(struct MPT2SAS_ADAPTER *ioc, 625_ctl_do_mpt_command(struct MPT2SAS_ADAPTER *ioc, struct mpt2_ioctl_command karg,
627 struct mpt2_ioctl_command karg, void __user *mf, enum block_state state) 626 void __user *mf)
628{ 627{
629 MPI2RequestHeader_t *mpi_request = NULL, *request; 628 MPI2RequestHeader_t *mpi_request = NULL, *request;
630 MPI2DefaultReply_t *mpi_reply; 629 MPI2DefaultReply_t *mpi_reply;
@@ -647,11 +646,6 @@ _ctl_do_mpt_command(struct MPT2SAS_ADAPTER *ioc,
647 646
648 issue_reset = 0; 647 issue_reset = 0;
649 648
650 if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
651 return -EAGAIN;
652 else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
653 return -ERESTARTSYS;
654
655 if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) { 649 if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) {
656 printk(MPT2SAS_ERR_FMT "%s: ctl_cmd in use\n", 650 printk(MPT2SAS_ERR_FMT "%s: ctl_cmd in use\n",
657 ioc->name, __func__); 651 ioc->name, __func__);
@@ -1013,27 +1007,24 @@ _ctl_do_mpt_command(struct MPT2SAS_ADAPTER *ioc,
1013 1007
1014 kfree(mpi_request); 1008 kfree(mpi_request);
1015 ioc->ctl_cmds.status = MPT2_CMD_NOT_USED; 1009 ioc->ctl_cmds.status = MPT2_CMD_NOT_USED;
1016 mutex_unlock(&ioc->ctl_cmds.mutex);
1017 return ret; 1010 return ret;
1018} 1011}
1019 1012
1020/** 1013/**
1021 * _ctl_getiocinfo - main handler for MPT2IOCINFO opcode 1014 * _ctl_getiocinfo - main handler for MPT2IOCINFO opcode
1015 * @ioc: per adapter object
1022 * @arg - user space buffer containing ioctl content 1016 * @arg - user space buffer containing ioctl content
1023 */ 1017 */
1024static long 1018static long
1025_ctl_getiocinfo(void __user *arg) 1019_ctl_getiocinfo(struct MPT2SAS_ADAPTER *ioc, void __user *arg)
1026{ 1020{
1027 struct mpt2_ioctl_iocinfo karg; 1021 struct mpt2_ioctl_iocinfo karg;
1028 struct MPT2SAS_ADAPTER *ioc;
1029 1022
1030 if (copy_from_user(&karg, arg, sizeof(karg))) { 1023 if (copy_from_user(&karg, arg, sizeof(karg))) {
1031 printk(KERN_ERR "failure at %s:%d/%s()!\n", 1024 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1032 __FILE__, __LINE__, __func__); 1025 __FILE__, __LINE__, __func__);
1033 return -EFAULT; 1026 return -EFAULT;
1034 } 1027 }
1035 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1036 return -ENODEV;
1037 1028
1038 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name, 1029 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name,
1039 __func__)); 1030 __func__));
@@ -1069,21 +1060,19 @@ _ctl_getiocinfo(void __user *arg)
1069 1060
1070/** 1061/**
1071 * _ctl_eventquery - main handler for MPT2EVENTQUERY opcode 1062 * _ctl_eventquery - main handler for MPT2EVENTQUERY opcode
1063 * @ioc: per adapter object
1072 * @arg - user space buffer containing ioctl content 1064 * @arg - user space buffer containing ioctl content
1073 */ 1065 */
1074static long 1066static long
1075_ctl_eventquery(void __user *arg) 1067_ctl_eventquery(struct MPT2SAS_ADAPTER *ioc, void __user *arg)
1076{ 1068{
1077 struct mpt2_ioctl_eventquery karg; 1069 struct mpt2_ioctl_eventquery karg;
1078 struct MPT2SAS_ADAPTER *ioc;
1079 1070
1080 if (copy_from_user(&karg, arg, sizeof(karg))) { 1071 if (copy_from_user(&karg, arg, sizeof(karg))) {
1081 printk(KERN_ERR "failure at %s:%d/%s()!\n", 1072 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1082 __FILE__, __LINE__, __func__); 1073 __FILE__, __LINE__, __func__);
1083 return -EFAULT; 1074 return -EFAULT;
1084 } 1075 }
1085 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1086 return -ENODEV;
1087 1076
1088 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name, 1077 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name,
1089 __func__)); 1078 __func__));
@@ -1102,21 +1091,19 @@ _ctl_eventquery(void __user *arg)
1102 1091
1103/** 1092/**
1104 * _ctl_eventenable - main handler for MPT2EVENTENABLE opcode 1093 * _ctl_eventenable - main handler for MPT2EVENTENABLE opcode
1094 * @ioc: per adapter object
1105 * @arg - user space buffer containing ioctl content 1095 * @arg - user space buffer containing ioctl content
1106 */ 1096 */
1107static long 1097static long
1108_ctl_eventenable(void __user *arg) 1098_ctl_eventenable(struct MPT2SAS_ADAPTER *ioc, void __user *arg)
1109{ 1099{
1110 struct mpt2_ioctl_eventenable karg; 1100 struct mpt2_ioctl_eventenable karg;
1111 struct MPT2SAS_ADAPTER *ioc;
1112 1101
1113 if (copy_from_user(&karg, arg, sizeof(karg))) { 1102 if (copy_from_user(&karg, arg, sizeof(karg))) {
1114 printk(KERN_ERR "failure at %s:%d/%s()!\n", 1103 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1115 __FILE__, __LINE__, __func__); 1104 __FILE__, __LINE__, __func__);
1116 return -EFAULT; 1105 return -EFAULT;
1117 } 1106 }
1118 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1119 return -ENODEV;
1120 1107
1121 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name, 1108 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name,
1122 __func__)); 1109 __func__));
@@ -1142,13 +1129,13 @@ _ctl_eventenable(void __user *arg)
1142 1129
1143/** 1130/**
1144 * _ctl_eventreport - main handler for MPT2EVENTREPORT opcode 1131 * _ctl_eventreport - main handler for MPT2EVENTREPORT opcode
1132 * @ioc: per adapter object
1145 * @arg - user space buffer containing ioctl content 1133 * @arg - user space buffer containing ioctl content
1146 */ 1134 */
1147static long 1135static long
1148_ctl_eventreport(void __user *arg) 1136_ctl_eventreport(struct MPT2SAS_ADAPTER *ioc, void __user *arg)
1149{ 1137{
1150 struct mpt2_ioctl_eventreport karg; 1138 struct mpt2_ioctl_eventreport karg;
1151 struct MPT2SAS_ADAPTER *ioc;
1152 u32 number_bytes, max_events, max; 1139 u32 number_bytes, max_events, max;
1153 struct mpt2_ioctl_eventreport __user *uarg = arg; 1140 struct mpt2_ioctl_eventreport __user *uarg = arg;
1154 1141
@@ -1157,8 +1144,6 @@ _ctl_eventreport(void __user *arg)
1157 __FILE__, __LINE__, __func__); 1144 __FILE__, __LINE__, __func__);
1158 return -EFAULT; 1145 return -EFAULT;
1159 } 1146 }
1160 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1161 return -ENODEV;
1162 1147
1163 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name, 1148 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name,
1164 __func__)); 1149 __func__));
@@ -1188,13 +1173,13 @@ _ctl_eventreport(void __user *arg)
1188 1173
1189/** 1174/**
1190 * _ctl_do_reset - main handler for MPT2HARDRESET opcode 1175 * _ctl_do_reset - main handler for MPT2HARDRESET opcode
1176 * @ioc: per adapter object
1191 * @arg - user space buffer containing ioctl content 1177 * @arg - user space buffer containing ioctl content
1192 */ 1178 */
1193static long 1179static long
1194_ctl_do_reset(void __user *arg) 1180_ctl_do_reset(struct MPT2SAS_ADAPTER *ioc, void __user *arg)
1195{ 1181{
1196 struct mpt2_ioctl_diag_reset karg; 1182 struct mpt2_ioctl_diag_reset karg;
1197 struct MPT2SAS_ADAPTER *ioc;
1198 int retval; 1183 int retval;
1199 1184
1200 if (copy_from_user(&karg, arg, sizeof(karg))) { 1185 if (copy_from_user(&karg, arg, sizeof(karg))) {
@@ -1202,8 +1187,6 @@ _ctl_do_reset(void __user *arg)
1202 __FILE__, __LINE__, __func__); 1187 __FILE__, __LINE__, __func__);
1203 return -EFAULT; 1188 return -EFAULT;
1204 } 1189 }
1205 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1206 return -ENODEV;
1207 1190
1208 if (ioc->shost_recovery || ioc->pci_error_recovery || 1191 if (ioc->shost_recovery || ioc->pci_error_recovery ||
1209 ioc->is_driver_loading) 1192 ioc->is_driver_loading)
@@ -1292,13 +1275,13 @@ _ctl_btdh_search_raid_device(struct MPT2SAS_ADAPTER *ioc,
1292 1275
1293/** 1276/**
1294 * _ctl_btdh_mapping - main handler for MPT2BTDHMAPPING opcode 1277 * _ctl_btdh_mapping - main handler for MPT2BTDHMAPPING opcode
1278 * @ioc: per adapter object
1295 * @arg - user space buffer containing ioctl content 1279 * @arg - user space buffer containing ioctl content
1296 */ 1280 */
1297static long 1281static long
1298_ctl_btdh_mapping(void __user *arg) 1282_ctl_btdh_mapping(struct MPT2SAS_ADAPTER *ioc, void __user *arg)
1299{ 1283{
1300 struct mpt2_ioctl_btdh_mapping karg; 1284 struct mpt2_ioctl_btdh_mapping karg;
1301 struct MPT2SAS_ADAPTER *ioc;
1302 int rc; 1285 int rc;
1303 1286
1304 if (copy_from_user(&karg, arg, sizeof(karg))) { 1287 if (copy_from_user(&karg, arg, sizeof(karg))) {
@@ -1306,8 +1289,6 @@ _ctl_btdh_mapping(void __user *arg)
1306 __FILE__, __LINE__, __func__); 1289 __FILE__, __LINE__, __func__);
1307 return -EFAULT; 1290 return -EFAULT;
1308 } 1291 }
1309 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1310 return -ENODEV;
1311 1292
1312 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name, 1293 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
1313 __func__)); 1294 __func__));
@@ -1576,17 +1557,16 @@ mpt2sas_enable_diag_buffer(struct MPT2SAS_ADAPTER *ioc, u8 bits_to_register)
1576 1557
1577/** 1558/**
1578 * _ctl_diag_register - application register with driver 1559 * _ctl_diag_register - application register with driver
1560 * @ioc: per adapter object
1579 * @arg - user space buffer containing ioctl content 1561 * @arg - user space buffer containing ioctl content
1580 * @state - NON_BLOCKING or BLOCKING
1581 * 1562 *
1582 * This will allow the driver to setup any required buffers that will be 1563 * This will allow the driver to setup any required buffers that will be
1583 * needed by firmware to communicate with the driver. 1564 * needed by firmware to communicate with the driver.
1584 */ 1565 */
1585static long 1566static long
1586_ctl_diag_register(void __user *arg, enum block_state state) 1567_ctl_diag_register(struct MPT2SAS_ADAPTER *ioc, void __user *arg)
1587{ 1568{
1588 struct mpt2_diag_register karg; 1569 struct mpt2_diag_register karg;
1589 struct MPT2SAS_ADAPTER *ioc;
1590 long rc; 1570 long rc;
1591 1571
1592 if (copy_from_user(&karg, arg, sizeof(karg))) { 1572 if (copy_from_user(&karg, arg, sizeof(karg))) {
@@ -1594,30 +1574,23 @@ _ctl_diag_register(void __user *arg, enum block_state state)
1594 __FILE__, __LINE__, __func__); 1574 __FILE__, __LINE__, __func__);
1595 return -EFAULT; 1575 return -EFAULT;
1596 } 1576 }
1597 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1598 return -ENODEV;
1599 1577
1600 if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
1601 return -EAGAIN;
1602 else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
1603 return -ERESTARTSYS;
1604 rc = _ctl_diag_register_2(ioc, &karg); 1578 rc = _ctl_diag_register_2(ioc, &karg);
1605 mutex_unlock(&ioc->ctl_cmds.mutex);
1606 return rc; 1579 return rc;
1607} 1580}
1608 1581
1609/** 1582/**
1610 * _ctl_diag_unregister - application unregister with driver 1583 * _ctl_diag_unregister - application unregister with driver
1584 * @ioc: per adapter object
1611 * @arg - user space buffer containing ioctl content 1585 * @arg - user space buffer containing ioctl content
1612 * 1586 *
1613 * This will allow the driver to cleanup any memory allocated for diag 1587 * This will allow the driver to cleanup any memory allocated for diag
1614 * messages and to free up any resources. 1588 * messages and to free up any resources.
1615 */ 1589 */
1616static long 1590static long
1617_ctl_diag_unregister(void __user *arg) 1591_ctl_diag_unregister(struct MPT2SAS_ADAPTER *ioc, void __user *arg)
1618{ 1592{
1619 struct mpt2_diag_unregister karg; 1593 struct mpt2_diag_unregister karg;
1620 struct MPT2SAS_ADAPTER *ioc;
1621 void *request_data; 1594 void *request_data;
1622 dma_addr_t request_data_dma; 1595 dma_addr_t request_data_dma;
1623 u32 request_data_sz; 1596 u32 request_data_sz;
@@ -1628,8 +1601,6 @@ _ctl_diag_unregister(void __user *arg)
1628 __FILE__, __LINE__, __func__); 1601 __FILE__, __LINE__, __func__);
1629 return -EFAULT; 1602 return -EFAULT;
1630 } 1603 }
1631 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1632 return -ENODEV;
1633 1604
1634 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name, 1605 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
1635 __func__)); 1606 __func__));
@@ -1678,6 +1649,7 @@ _ctl_diag_unregister(void __user *arg)
1678 1649
1679/** 1650/**
1680 * _ctl_diag_query - query relevant info associated with diag buffers 1651 * _ctl_diag_query - query relevant info associated with diag buffers
1652 * @ioc: per adapter object
1681 * @arg - user space buffer containing ioctl content 1653 * @arg - user space buffer containing ioctl content
1682 * 1654 *
1683 * The application will send only buffer_type and unique_id. Driver will 1655 * The application will send only buffer_type and unique_id. Driver will
@@ -1685,10 +1657,9 @@ _ctl_diag_unregister(void __user *arg)
1685 * 0x00, the driver will return info specified by Buffer Type. 1657 * 0x00, the driver will return info specified by Buffer Type.
1686 */ 1658 */
1687static long 1659static long
1688_ctl_diag_query(void __user *arg) 1660_ctl_diag_query(struct MPT2SAS_ADAPTER *ioc, void __user *arg)
1689{ 1661{
1690 struct mpt2_diag_query karg; 1662 struct mpt2_diag_query karg;
1691 struct MPT2SAS_ADAPTER *ioc;
1692 void *request_data; 1663 void *request_data;
1693 int i; 1664 int i;
1694 u8 buffer_type; 1665 u8 buffer_type;
@@ -1698,8 +1669,6 @@ _ctl_diag_query(void __user *arg)
1698 __FILE__, __LINE__, __func__); 1669 __FILE__, __LINE__, __func__);
1699 return -EFAULT; 1670 return -EFAULT;
1700 } 1671 }
1701 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1702 return -ENODEV;
1703 1672
1704 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name, 1673 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
1705 __func__)); 1674 __func__));
@@ -1866,17 +1835,15 @@ _ctl_send_release(struct MPT2SAS_ADAPTER *ioc, u8 buffer_type, u8 *issue_reset)
1866/** 1835/**
1867 * _ctl_diag_release - request to send Diag Release Message to firmware 1836 * _ctl_diag_release - request to send Diag Release Message to firmware
1868 * @arg - user space buffer containing ioctl content 1837 * @arg - user space buffer containing ioctl content
1869 * @state - NON_BLOCKING or BLOCKING
1870 * 1838 *
1871 * This allows ownership of the specified buffer to returned to the driver, 1839 * This allows ownership of the specified buffer to returned to the driver,
1872 * allowing an application to read the buffer without fear that firmware is 1840 * allowing an application to read the buffer without fear that firmware is
1873 * overwritting information in the buffer. 1841 * overwritting information in the buffer.
1874 */ 1842 */
1875static long 1843static long
1876_ctl_diag_release(void __user *arg, enum block_state state) 1844_ctl_diag_release(struct MPT2SAS_ADAPTER *ioc, void __user *arg)
1877{ 1845{
1878 struct mpt2_diag_release karg; 1846 struct mpt2_diag_release karg;
1879 struct MPT2SAS_ADAPTER *ioc;
1880 void *request_data; 1847 void *request_data;
1881 int rc; 1848 int rc;
1882 u8 buffer_type; 1849 u8 buffer_type;
@@ -1887,8 +1854,6 @@ _ctl_diag_release(void __user *arg, enum block_state state)
1887 __FILE__, __LINE__, __func__); 1854 __FILE__, __LINE__, __func__);
1888 return -EFAULT; 1855 return -EFAULT;
1889 } 1856 }
1890 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1891 return -ENODEV;
1892 1857
1893 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name, 1858 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
1894 __func__)); 1859 __func__));
@@ -1942,32 +1907,25 @@ _ctl_diag_release(void __user *arg, enum block_state state)
1942 return 0; 1907 return 0;
1943 } 1908 }
1944 1909
1945 if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
1946 return -EAGAIN;
1947 else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
1948 return -ERESTARTSYS;
1949
1950 rc = _ctl_send_release(ioc, buffer_type, &issue_reset); 1910 rc = _ctl_send_release(ioc, buffer_type, &issue_reset);
1951 1911
1952 if (issue_reset) 1912 if (issue_reset)
1953 mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP, 1913 mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
1954 FORCE_BIG_HAMMER); 1914 FORCE_BIG_HAMMER);
1955 1915
1956 mutex_unlock(&ioc->ctl_cmds.mutex);
1957 return rc; 1916 return rc;
1958} 1917}
1959 1918
1960/** 1919/**
1961 * _ctl_diag_read_buffer - request for copy of the diag buffer 1920 * _ctl_diag_read_buffer - request for copy of the diag buffer
1921 * @ioc: per adapter object
1962 * @arg - user space buffer containing ioctl content 1922 * @arg - user space buffer containing ioctl content
1963 * @state - NON_BLOCKING or BLOCKING
1964 */ 1923 */
1965static long 1924static long
1966_ctl_diag_read_buffer(void __user *arg, enum block_state state) 1925_ctl_diag_read_buffer(struct MPT2SAS_ADAPTER *ioc, void __user *arg)
1967{ 1926{
1968 struct mpt2_diag_read_buffer karg; 1927 struct mpt2_diag_read_buffer karg;
1969 struct mpt2_diag_read_buffer __user *uarg = arg; 1928 struct mpt2_diag_read_buffer __user *uarg = arg;
1970 struct MPT2SAS_ADAPTER *ioc;
1971 void *request_data, *diag_data; 1929 void *request_data, *diag_data;
1972 Mpi2DiagBufferPostRequest_t *mpi_request; 1930 Mpi2DiagBufferPostRequest_t *mpi_request;
1973 Mpi2DiagBufferPostReply_t *mpi_reply; 1931 Mpi2DiagBufferPostReply_t *mpi_reply;
@@ -1983,8 +1941,6 @@ _ctl_diag_read_buffer(void __user *arg, enum block_state state)
1983 __FILE__, __LINE__, __func__); 1941 __FILE__, __LINE__, __func__);
1984 return -EFAULT; 1942 return -EFAULT;
1985 } 1943 }
1986 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1987 return -ENODEV;
1988 1944
1989 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name, 1945 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
1990 __func__)); 1946 __func__));
@@ -2055,10 +2011,6 @@ _ctl_diag_read_buffer(void __user *arg, enum block_state state)
2055 } 2011 }
2056 /* Get a free request frame and save the message context. 2012 /* Get a free request frame and save the message context.
2057 */ 2013 */
2058 if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
2059 return -EAGAIN;
2060 else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
2061 return -ERESTARTSYS;
2062 2014
2063 if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) { 2015 if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) {
2064 printk(MPT2SAS_ERR_FMT "%s: ctl_cmd in use\n", 2016 printk(MPT2SAS_ERR_FMT "%s: ctl_cmd in use\n",
@@ -2139,115 +2091,170 @@ _ctl_diag_read_buffer(void __user *arg, enum block_state state)
2139 out: 2091 out:
2140 2092
2141 ioc->ctl_cmds.status = MPT2_CMD_NOT_USED; 2093 ioc->ctl_cmds.status = MPT2_CMD_NOT_USED;
2142 mutex_unlock(&ioc->ctl_cmds.mutex);
2143 return rc; 2094 return rc;
2144} 2095}
2145 2096
2097
2098#ifdef CONFIG_COMPAT
2099/**
2100 * _ctl_compat_mpt_command - convert 32bit pointers to 64bit.
2101 * @ioc: per adapter object
2102 * @cmd - ioctl opcode
2103 * @arg - (struct mpt2_ioctl_command32)
2104 *
2105 * MPT2COMMAND32 - Handle 32bit applications running on 64bit os.
2106 */
2107static long
2108_ctl_compat_mpt_command(struct MPT2SAS_ADAPTER *ioc, unsigned cmd,
2109 void __user *arg)
2110{
2111 struct mpt2_ioctl_command32 karg32;
2112 struct mpt2_ioctl_command32 __user *uarg;
2113 struct mpt2_ioctl_command karg;
2114
2115 if (_IOC_SIZE(cmd) != sizeof(struct mpt2_ioctl_command32))
2116 return -EINVAL;
2117
2118 uarg = (struct mpt2_ioctl_command32 __user *) arg;
2119
2120 if (copy_from_user(&karg32, (char __user *)arg, sizeof(karg32))) {
2121 printk(KERN_ERR "failure at %s:%d/%s()!\n",
2122 __FILE__, __LINE__, __func__);
2123 return -EFAULT;
2124 }
2125
2126 memset(&karg, 0, sizeof(struct mpt2_ioctl_command));
2127 karg.hdr.ioc_number = karg32.hdr.ioc_number;
2128 karg.hdr.port_number = karg32.hdr.port_number;
2129 karg.hdr.max_data_size = karg32.hdr.max_data_size;
2130 karg.timeout = karg32.timeout;
2131 karg.max_reply_bytes = karg32.max_reply_bytes;
2132 karg.data_in_size = karg32.data_in_size;
2133 karg.data_out_size = karg32.data_out_size;
2134 karg.max_sense_bytes = karg32.max_sense_bytes;
2135 karg.data_sge_offset = karg32.data_sge_offset;
2136 karg.reply_frame_buf_ptr = compat_ptr(karg32.reply_frame_buf_ptr);
2137 karg.data_in_buf_ptr = compat_ptr(karg32.data_in_buf_ptr);
2138 karg.data_out_buf_ptr = compat_ptr(karg32.data_out_buf_ptr);
2139 karg.sense_data_ptr = compat_ptr(karg32.sense_data_ptr);
2140 return _ctl_do_mpt_command(ioc, karg, &uarg->mf);
2141}
2142#endif
2143
2146/** 2144/**
2147 * _ctl_ioctl_main - main ioctl entry point 2145 * _ctl_ioctl_main - main ioctl entry point
2148 * @file - (struct file) 2146 * @file - (struct file)
2149 * @cmd - ioctl opcode 2147 * @cmd - ioctl opcode
2150 * @arg - 2148 * @arg -
2149 * compat - handles 32 bit applications in 64bit os
2151 */ 2150 */
2152static long 2151static long
2153_ctl_ioctl_main(struct file *file, unsigned int cmd, void __user *arg) 2152_ctl_ioctl_main(struct file *file, unsigned int cmd, void __user *arg,
2153 u8 compat)
2154{ 2154{
2155 struct MPT2SAS_ADAPTER *ioc;
2156 struct mpt2_ioctl_header ioctl_header;
2155 enum block_state state; 2157 enum block_state state;
2156 long ret = -EINVAL; 2158 long ret = -EINVAL;
2157 2159
2158 state = (file->f_flags & O_NONBLOCK) ? NON_BLOCKING : 2160 /* get IOCTL header */
2159 BLOCKING; 2161 if (copy_from_user(&ioctl_header, (char __user *)arg,
2162 sizeof(struct mpt2_ioctl_header))) {
2163 printk(KERN_ERR "failure at %s:%d/%s()!\n",
2164 __FILE__, __LINE__, __func__);
2165 return -EFAULT;
2166 }
2167
2168 if (_ctl_verify_adapter(ioctl_header.ioc_number, &ioc) == -1 || !ioc)
2169 return -ENODEV;
2170 if (ioc->shost_recovery || ioc->pci_error_recovery ||
2171 ioc->is_driver_loading)
2172 return -EAGAIN;
2173
2174 state = (file->f_flags & O_NONBLOCK) ? NON_BLOCKING : BLOCKING;
2175 if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
2176 return -EAGAIN;
2177 else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
2178 return -ERESTARTSYS;
2160 2179
2161 switch (cmd) { 2180 switch (cmd) {
2162 case MPT2IOCINFO: 2181 case MPT2IOCINFO:
2163 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_iocinfo)) 2182 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_iocinfo))
2164 ret = _ctl_getiocinfo(arg); 2183 ret = _ctl_getiocinfo(ioc, arg);
2165 break; 2184 break;
2185#ifdef CONFIG_COMPAT
2186 case MPT2COMMAND32:
2187#endif
2166 case MPT2COMMAND: 2188 case MPT2COMMAND:
2167 { 2189 {
2168 struct mpt2_ioctl_command karg;
2169 struct mpt2_ioctl_command __user *uarg; 2190 struct mpt2_ioctl_command __user *uarg;
2170 struct MPT2SAS_ADAPTER *ioc; 2191 struct mpt2_ioctl_command karg;
2171 2192#ifdef CONFIG_COMPAT
2193 if (compat) {
2194 ret = _ctl_compat_mpt_command(ioc, cmd, arg);
2195 break;
2196 }
2197#endif
2172 if (copy_from_user(&karg, arg, sizeof(karg))) { 2198 if (copy_from_user(&karg, arg, sizeof(karg))) {
2173 printk(KERN_ERR "failure at %s:%d/%s()!\n", 2199 printk(KERN_ERR "failure at %s:%d/%s()!\n",
2174 __FILE__, __LINE__, __func__); 2200 __FILE__, __LINE__, __func__);
2175 return -EFAULT; 2201 ret = -EFAULT;
2202 break;
2176 } 2203 }
2177 2204
2178 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 ||
2179 !ioc)
2180 return -ENODEV;
2181
2182 if (ioc->shost_recovery || ioc->pci_error_recovery ||
2183 ioc->is_driver_loading)
2184 return -EAGAIN;
2185
2186 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_command)) { 2205 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_command)) {
2187 uarg = arg; 2206 uarg = arg;
2188 ret = _ctl_do_mpt_command(ioc, karg, &uarg->mf, state); 2207 ret = _ctl_do_mpt_command(ioc, karg, &uarg->mf);
2189 } 2208 }
2190 break; 2209 break;
2191 } 2210 }
2192 case MPT2EVENTQUERY: 2211 case MPT2EVENTQUERY:
2193 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_eventquery)) 2212 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_eventquery))
2194 ret = _ctl_eventquery(arg); 2213 ret = _ctl_eventquery(ioc, arg);
2195 break; 2214 break;
2196 case MPT2EVENTENABLE: 2215 case MPT2EVENTENABLE:
2197 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_eventenable)) 2216 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_eventenable))
2198 ret = _ctl_eventenable(arg); 2217 ret = _ctl_eventenable(ioc, arg);
2199 break; 2218 break;
2200 case MPT2EVENTREPORT: 2219 case MPT2EVENTREPORT:
2201 ret = _ctl_eventreport(arg); 2220 ret = _ctl_eventreport(ioc, arg);
2202 break; 2221 break;
2203 case MPT2HARDRESET: 2222 case MPT2HARDRESET:
2204 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_diag_reset)) 2223 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_diag_reset))
2205 ret = _ctl_do_reset(arg); 2224 ret = _ctl_do_reset(ioc, arg);
2206 break; 2225 break;
2207 case MPT2BTDHMAPPING: 2226 case MPT2BTDHMAPPING:
2208 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_btdh_mapping)) 2227 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_btdh_mapping))
2209 ret = _ctl_btdh_mapping(arg); 2228 ret = _ctl_btdh_mapping(ioc, arg);
2210 break; 2229 break;
2211 case MPT2DIAGREGISTER: 2230 case MPT2DIAGREGISTER:
2212 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_register)) 2231 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_register))
2213 ret = _ctl_diag_register(arg, state); 2232 ret = _ctl_diag_register(ioc, arg);
2214 break; 2233 break;
2215 case MPT2DIAGUNREGISTER: 2234 case MPT2DIAGUNREGISTER:
2216 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_unregister)) 2235 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_unregister))
2217 ret = _ctl_diag_unregister(arg); 2236 ret = _ctl_diag_unregister(ioc, arg);
2218 break; 2237 break;
2219 case MPT2DIAGQUERY: 2238 case MPT2DIAGQUERY:
2220 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_query)) 2239 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_query))
2221 ret = _ctl_diag_query(arg); 2240 ret = _ctl_diag_query(ioc, arg);
2222 break; 2241 break;
2223 case MPT2DIAGRELEASE: 2242 case MPT2DIAGRELEASE:
2224 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_release)) 2243 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_release))
2225 ret = _ctl_diag_release(arg, state); 2244 ret = _ctl_diag_release(ioc, arg);
2226 break; 2245 break;
2227 case MPT2DIAGREADBUFFER: 2246 case MPT2DIAGREADBUFFER:
2228 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_read_buffer)) 2247 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_read_buffer))
2229 ret = _ctl_diag_read_buffer(arg, state); 2248 ret = _ctl_diag_read_buffer(ioc, arg);
2230 break; 2249 break;
2231 default: 2250 default:
2232 {
2233 struct mpt2_ioctl_command karg;
2234 struct MPT2SAS_ADAPTER *ioc;
2235
2236 if (copy_from_user(&karg, arg, sizeof(karg))) {
2237 printk(KERN_ERR "failure at %s:%d/%s()!\n",
2238 __FILE__, __LINE__, __func__);
2239 return -EFAULT;
2240 }
2241
2242 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 ||
2243 !ioc)
2244 return -ENODEV;
2245 2251
2246 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT 2252 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT
2247 "unsupported ioctl opcode(0x%08x)\n", ioc->name, cmd)); 2253 "unsupported ioctl opcode(0x%08x)\n", ioc->name, cmd));
2248 break; 2254 break;
2249 } 2255 }
2250 } 2256
2257 mutex_unlock(&ioc->ctl_cmds.mutex);
2251 return ret; 2258 return ret;
2252} 2259}
2253 2260
@@ -2262,66 +2269,11 @@ _ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2262{ 2269{
2263 long ret; 2270 long ret;
2264 2271
2265 mutex_lock(&_ctl_mutex); 2272 ret = _ctl_ioctl_main(file, cmd, (void __user *)arg, 0);
2266 ret = _ctl_ioctl_main(file, cmd, (void __user *)arg);
2267 mutex_unlock(&_ctl_mutex);
2268 return ret; 2273 return ret;
2269} 2274}
2270
2271#ifdef CONFIG_COMPAT 2275#ifdef CONFIG_COMPAT
2272/** 2276/**
2273 * _ctl_compat_mpt_command - convert 32bit pointers to 64bit.
2274 * @file - (struct file)
2275 * @cmd - ioctl opcode
2276 * @arg - (struct mpt2_ioctl_command32)
2277 *
2278 * MPT2COMMAND32 - Handle 32bit applications running on 64bit os.
2279 */
2280static long
2281_ctl_compat_mpt_command(struct file *file, unsigned cmd, unsigned long arg)
2282{
2283 struct mpt2_ioctl_command32 karg32;
2284 struct mpt2_ioctl_command32 __user *uarg;
2285 struct mpt2_ioctl_command karg;
2286 struct MPT2SAS_ADAPTER *ioc;
2287 enum block_state state;
2288
2289 if (_IOC_SIZE(cmd) != sizeof(struct mpt2_ioctl_command32))
2290 return -EINVAL;
2291
2292 uarg = (struct mpt2_ioctl_command32 __user *) arg;
2293
2294 if (copy_from_user(&karg32, (char __user *)arg, sizeof(karg32))) {
2295 printk(KERN_ERR "failure at %s:%d/%s()!\n",
2296 __FILE__, __LINE__, __func__);
2297 return -EFAULT;
2298 }
2299 if (_ctl_verify_adapter(karg32.hdr.ioc_number, &ioc) == -1 || !ioc)
2300 return -ENODEV;
2301
2302 if (ioc->shost_recovery || ioc->pci_error_recovery ||
2303 ioc->is_driver_loading)
2304 return -EAGAIN;
2305
2306 memset(&karg, 0, sizeof(struct mpt2_ioctl_command));
2307 karg.hdr.ioc_number = karg32.hdr.ioc_number;
2308 karg.hdr.port_number = karg32.hdr.port_number;
2309 karg.hdr.max_data_size = karg32.hdr.max_data_size;
2310 karg.timeout = karg32.timeout;
2311 karg.max_reply_bytes = karg32.max_reply_bytes;
2312 karg.data_in_size = karg32.data_in_size;
2313 karg.data_out_size = karg32.data_out_size;
2314 karg.max_sense_bytes = karg32.max_sense_bytes;
2315 karg.data_sge_offset = karg32.data_sge_offset;
2316 karg.reply_frame_buf_ptr = compat_ptr(karg32.reply_frame_buf_ptr);
2317 karg.data_in_buf_ptr = compat_ptr(karg32.data_in_buf_ptr);
2318 karg.data_out_buf_ptr = compat_ptr(karg32.data_out_buf_ptr);
2319 karg.sense_data_ptr = compat_ptr(karg32.sense_data_ptr);
2320 state = (file->f_flags & O_NONBLOCK) ? NON_BLOCKING : BLOCKING;
2321 return _ctl_do_mpt_command(ioc, karg, &uarg->mf, state);
2322}
2323
2324/**
2325 * _ctl_ioctl_compat - main ioctl entry point (compat) 2277 * _ctl_ioctl_compat - main ioctl entry point (compat)
2326 * @file - 2278 * @file -
2327 * @cmd - 2279 * @cmd -
@@ -2334,12 +2286,7 @@ _ctl_ioctl_compat(struct file *file, unsigned cmd, unsigned long arg)
2334{ 2286{
2335 long ret; 2287 long ret;
2336 2288
2337 mutex_lock(&_ctl_mutex); 2289 ret = _ctl_ioctl_main(file, cmd, (void __user *)arg, 1);
2338 if (cmd == MPT2COMMAND32)
2339 ret = _ctl_compat_mpt_command(file, cmd, arg);
2340 else
2341 ret = _ctl_ioctl_main(file, cmd, (void __user *)arg);
2342 mutex_unlock(&_ctl_mutex);
2343 return ret; 2290 return ret;
2344} 2291}
2345#endif 2292#endif