Deleted Added
sdiff udiff text old ( 275446 ) new ( 275942 )
full compact
ctl_tpc.c (275446) ctl_tpc.c (275942)
1/*-
2 * Copyright (c) 2014 Alexander Motin <mav@FreeBSD.org>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright

--- 11 unchanged lines hidden (view full) ---

20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27#include <sys/cdefs.h>
1/*-
2 * Copyright (c) 2014 Alexander Motin <mav@FreeBSD.org>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright

--- 11 unchanged lines hidden (view full) ---

20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27#include <sys/cdefs.h>
28__FBSDID("$FreeBSD: head/sys/cam/ctl/ctl_tpc.c 275446 2014-12-03 08:25:41Z mav $");
28__FBSDID("$FreeBSD: head/sys/cam/ctl/ctl_tpc.c 275942 2014-12-19 20:35:06Z mav $");
29
30#include <sys/param.h>
31#include <sys/systm.h>
32#include <sys/kernel.h>
33#include <sys/types.h>
34#include <sys/lock.h>
35#include <sys/module.h>
36#include <sys/mutex.h>

--- 103 unchanged lines hidden (view full) ---

140 uint8_t scsi_status;
141 struct ctl_scsiio *ctsio;
142 struct ctl_lun *lun;
143 int res_token_valid;
144 uint8_t res_token[512];
145 TAILQ_ENTRY(tpc_list) links;
146};
147
29
30#include <sys/param.h>
31#include <sys/systm.h>
32#include <sys/kernel.h>
33#include <sys/types.h>
34#include <sys/lock.h>
35#include <sys/module.h>
36#include <sys/mutex.h>

--- 103 unchanged lines hidden (view full) ---

140 uint8_t scsi_status;
141 struct ctl_scsiio *ctsio;
142 struct ctl_lun *lun;
143 int res_token_valid;
144 uint8_t res_token[512];
145 TAILQ_ENTRY(tpc_list) links;
146};
147
148extern struct ctl_softc *control_softc;
149
150static void
151tpc_timeout(void *arg)
152{
153 struct ctl_softc *softc = arg;
154 struct ctl_lun *lun;
155 struct tpc_token *token, *ttoken;
156 struct tpc_list *list, *tlist;
157

--- 53 unchanged lines hidden (view full) ---

211{
212
213 TAILQ_INIT(&lun->tpc_lists);
214}
215
216void
217ctl_tpc_lun_shutdown(struct ctl_lun *lun)
218{
148static void
149tpc_timeout(void *arg)
150{
151 struct ctl_softc *softc = arg;
152 struct ctl_lun *lun;
153 struct tpc_token *token, *ttoken;
154 struct tpc_list *list, *tlist;
155

--- 53 unchanged lines hidden (view full) ---

209{
210
211 TAILQ_INIT(&lun->tpc_lists);
212}
213
214void
215ctl_tpc_lun_shutdown(struct ctl_lun *lun)
216{
217 struct ctl_softc *softc = lun->ctl_softc;
219 struct tpc_list *list;
220 struct tpc_token *token, *ttoken;
221
222 /* Free lists for this LUN. */
223 while ((list = TAILQ_FIRST(&lun->tpc_lists)) != NULL) {
224 TAILQ_REMOVE(&lun->tpc_lists, list, links);
225 KASSERT(list->completed,
226 ("Not completed TPC (%p) on shutdown", list));
227 free(list, M_CTL);
228 }
229
230 /* Free ROD tokens for this LUN. */
218 struct tpc_list *list;
219 struct tpc_token *token, *ttoken;
220
221 /* Free lists for this LUN. */
222 while ((list = TAILQ_FIRST(&lun->tpc_lists)) != NULL) {
223 TAILQ_REMOVE(&lun->tpc_lists, list, links);
224 KASSERT(list->completed,
225 ("Not completed TPC (%p) on shutdown", list));
226 free(list, M_CTL);
227 }
228
229 /* Free ROD tokens for this LUN. */
231 mtx_assert(&control_softc->ctl_lock, MA_OWNED);
232 TAILQ_FOREACH_SAFE(token, &control_softc->tpc_tokens, links, ttoken) {
230 mtx_assert(&softc->ctl_lock, MA_OWNED);
231 TAILQ_FOREACH_SAFE(token, &softc->tpc_tokens, links, ttoken) {
233 if (token->lun != lun->lun || token->active)
234 continue;
232 if (token->lun != lun->lun || token->active)
233 continue;
235 TAILQ_REMOVE(&control_softc->tpc_tokens, token, links);
234 TAILQ_REMOVE(&softc->tpc_tokens, token, links);
236 free(token->params, M_CTL);
237 free(token, M_CTL);
238 }
239}
240
241int
242ctl_inquiry_evpd_tpc(struct ctl_scsiio *ctsio, int alloc_len)
243{

--- 547 unchanged lines hidden (view full) ---

791
792 if (idx == 0xffff) {
793 if (ss && list->lun->be_lun)
794 *ss = list->lun->be_lun->blocksize;
795 return (list->lun->lun);
796 }
797 if (idx >= list->ncscd)
798 return (UINT64_MAX);
235 free(token->params, M_CTL);
236 free(token, M_CTL);
237 }
238}
239
240int
241ctl_inquiry_evpd_tpc(struct ctl_scsiio *ctsio, int alloc_len)
242{

--- 547 unchanged lines hidden (view full) ---

790
791 if (idx == 0xffff) {
792 if (ss && list->lun->be_lun)
793 *ss = list->lun->be_lun->blocksize;
794 return (list->lun->lun);
795 }
796 if (idx >= list->ncscd)
797 return (UINT64_MAX);
799 return (tpcl_resolve(list->init_port, &list->cscd[idx], ss));
798 return (tpcl_resolve(list->lun->ctl_softc,
799 list->init_port, &list->cscd[idx], ss));
800}
801
802static int
803tpc_process_b2b(struct tpc_list *list)
804{
805 struct scsi_ec_segment_b2b *seg;
806 struct scsi_ec_cscd_dtsp *sdstp, *ddstp;
807 struct tpc_io *tior, *tiow;

--- 483 unchanged lines hidden (view full) ---

1291 list->stage++;
1292 return (CTL_RETVAL_QUEUED);
1293}
1294
1295static void
1296tpc_process(struct tpc_list *list)
1297{
1298 struct ctl_lun *lun = list->lun;
800}
801
802static int
803tpc_process_b2b(struct tpc_list *list)
804{
805 struct scsi_ec_segment_b2b *seg;
806 struct scsi_ec_cscd_dtsp *sdstp, *ddstp;
807 struct tpc_io *tior, *tiow;

--- 483 unchanged lines hidden (view full) ---

1291 list->stage++;
1292 return (CTL_RETVAL_QUEUED);
1293}
1294
1295static void
1296tpc_process(struct tpc_list *list)
1297{
1298 struct ctl_lun *lun = list->lun;
1299 struct ctl_softc *softc = lun->ctl_softc;
1299 struct scsi_ec_segment *seg;
1300 struct ctl_scsiio *ctsio = list->ctsio;
1301 int retval = CTL_RETVAL_COMPLETE;
1302
1303 if (list->service_action == EC_WUT) {
1304 if (list->token != NULL)
1305 retval = tpc_process_wut(list);
1306 else

--- 37 unchanged lines hidden (view full) ---

1344
1345 ctl_set_success(ctsio);
1346
1347done:
1348//printf("ZZZ done\n");
1349 free(list->params, M_CTL);
1350 list->params = NULL;
1351 if (list->token) {
1300 struct scsi_ec_segment *seg;
1301 struct ctl_scsiio *ctsio = list->ctsio;
1302 int retval = CTL_RETVAL_COMPLETE;
1303
1304 if (list->service_action == EC_WUT) {
1305 if (list->token != NULL)
1306 retval = tpc_process_wut(list);
1307 else

--- 37 unchanged lines hidden (view full) ---

1345
1346 ctl_set_success(ctsio);
1347
1348done:
1349//printf("ZZZ done\n");
1350 free(list->params, M_CTL);
1351 list->params = NULL;
1352 if (list->token) {
1352 mtx_lock(&control_softc->ctl_lock);
1353 mtx_lock(&softc->ctl_lock);
1353 if (--list->token->active == 0)
1354 list->token->last_active = time_uptime;
1354 if (--list->token->active == 0)
1355 list->token->last_active = time_uptime;
1355 mtx_unlock(&control_softc->ctl_lock);
1356 mtx_unlock(&softc->ctl_lock);
1356 list->token = NULL;
1357 }
1358 mtx_lock(&lun->lun_lock);
1359 if ((list->flags & EC_LIST_ID_USAGE_MASK) == EC_LIST_ID_USAGE_NONE) {
1360 TAILQ_REMOVE(&lun->tpc_lists, list, links);
1361 free(list, M_CTL);
1362 } else {
1363 list->completed = 1;

--- 462 unchanged lines hidden (view full) ---

1826 arc4rand(&token->body[120 + targid_len], 384 - targid_len, 0);
1827};
1828
1829int
1830ctl_populate_token(struct ctl_scsiio *ctsio)
1831{
1832 struct scsi_populate_token *cdb;
1833 struct scsi_populate_token_data *data;
1357 list->token = NULL;
1358 }
1359 mtx_lock(&lun->lun_lock);
1360 if ((list->flags & EC_LIST_ID_USAGE_MASK) == EC_LIST_ID_USAGE_NONE) {
1361 TAILQ_REMOVE(&lun->tpc_lists, list, links);
1362 free(list, M_CTL);
1363 } else {
1364 list->completed = 1;

--- 462 unchanged lines hidden (view full) ---

1827 arc4rand(&token->body[120 + targid_len], 384 - targid_len, 0);
1828};
1829
1830int
1831ctl_populate_token(struct ctl_scsiio *ctsio)
1832{
1833 struct scsi_populate_token *cdb;
1834 struct scsi_populate_token_data *data;
1835 struct ctl_softc *softc;
1834 struct ctl_lun *lun;
1835 struct ctl_port *port;
1836 struct tpc_list *list, *tlist;
1837 struct tpc_token *token;
1838 int len, lendesc;
1839
1840 CTL_DEBUG_PRINT(("ctl_populate_token\n"));
1841
1842 lun = (struct ctl_lun *)ctsio->io_hdr.ctl_private[CTL_PRIV_LUN].ptr;
1836 struct ctl_lun *lun;
1837 struct ctl_port *port;
1838 struct tpc_list *list, *tlist;
1839 struct tpc_token *token;
1840 int len, lendesc;
1841
1842 CTL_DEBUG_PRINT(("ctl_populate_token\n"));
1843
1844 lun = (struct ctl_lun *)ctsio->io_hdr.ctl_private[CTL_PRIV_LUN].ptr;
1843 port = control_softc->ctl_ports[ctl_port_idx(ctsio->io_hdr.nexus.targ_port)];
1845 softc = lun->ctl_softc;
1846 port = softc->ctl_ports[ctl_port_idx(ctsio->io_hdr.nexus.targ_port)];
1844 cdb = (struct scsi_populate_token *)ctsio->cdb;
1845 len = scsi_4btoul(cdb->length);
1846
1847 if (len < sizeof(struct scsi_populate_token_data) ||
1848 len > sizeof(struct scsi_populate_token_data) +
1849 TPC_MAX_SEGS * sizeof(struct scsi_range_desc)) {
1850 ctl_set_invalid_field(ctsio, /*sks_valid*/ 1, /*command*/ 1,
1851 /*field*/ 9, /*bit_valid*/ 0, /*bit*/ 0);

--- 87 unchanged lines hidden (view full) ---

1939 /*command*/ 0, /*field*/ 4, /*bit_valid*/ 0,
1940 /*bit*/ 0);
1941 }
1942 memcpy(list->res_token, token->token, sizeof(list->res_token));
1943 list->res_token_valid = 1;
1944 list->curseg = 0;
1945 list->completed = 1;
1946 list->last_active = time_uptime;
1847 cdb = (struct scsi_populate_token *)ctsio->cdb;
1848 len = scsi_4btoul(cdb->length);
1849
1850 if (len < sizeof(struct scsi_populate_token_data) ||
1851 len > sizeof(struct scsi_populate_token_data) +
1852 TPC_MAX_SEGS * sizeof(struct scsi_range_desc)) {
1853 ctl_set_invalid_field(ctsio, /*sks_valid*/ 1, /*command*/ 1,
1854 /*field*/ 9, /*bit_valid*/ 0, /*bit*/ 0);

--- 87 unchanged lines hidden (view full) ---

1942 /*command*/ 0, /*field*/ 4, /*bit_valid*/ 0,
1943 /*bit*/ 0);
1944 }
1945 memcpy(list->res_token, token->token, sizeof(list->res_token));
1946 list->res_token_valid = 1;
1947 list->curseg = 0;
1948 list->completed = 1;
1949 list->last_active = time_uptime;
1947 mtx_lock(&control_softc->ctl_lock);
1948 TAILQ_INSERT_TAIL(&control_softc->tpc_tokens, token, links);
1949 mtx_unlock(&control_softc->ctl_lock);
1950 mtx_lock(&softc->ctl_lock);
1951 TAILQ_INSERT_TAIL(&softc->tpc_tokens, token, links);
1952 mtx_unlock(&softc->ctl_lock);
1950 ctl_set_success(ctsio);
1951 ctl_done((union ctl_io *)ctsio);
1952 return (CTL_RETVAL_COMPLETE);
1953
1954done:
1955 if (ctsio->io_hdr.flags & CTL_FLAG_ALLOCATED) {
1956 free(ctsio->kern_data_ptr, M_CTL);
1957 ctsio->io_hdr.flags &= ~CTL_FLAG_ALLOCATED;
1958 }
1959 ctl_done((union ctl_io *)ctsio);
1960 return (CTL_RETVAL_COMPLETE);
1961}
1962
1963int
1964ctl_write_using_token(struct ctl_scsiio *ctsio)
1965{
1966 struct scsi_write_using_token *cdb;
1967 struct scsi_write_using_token_data *data;
1953 ctl_set_success(ctsio);
1954 ctl_done((union ctl_io *)ctsio);
1955 return (CTL_RETVAL_COMPLETE);
1956
1957done:
1958 if (ctsio->io_hdr.flags & CTL_FLAG_ALLOCATED) {
1959 free(ctsio->kern_data_ptr, M_CTL);
1960 ctsio->io_hdr.flags &= ~CTL_FLAG_ALLOCATED;
1961 }
1962 ctl_done((union ctl_io *)ctsio);
1963 return (CTL_RETVAL_COMPLETE);
1964}
1965
1966int
1967ctl_write_using_token(struct ctl_scsiio *ctsio)
1968{
1969 struct scsi_write_using_token *cdb;
1970 struct scsi_write_using_token_data *data;
1971 struct ctl_softc *softc;
1968 struct ctl_lun *lun;
1969 struct tpc_list *list, *tlist;
1970 struct tpc_token *token;
1971 int len, lendesc;
1972
1973 CTL_DEBUG_PRINT(("ctl_write_using_token\n"));
1974
1975 lun = (struct ctl_lun *)ctsio->io_hdr.ctl_private[CTL_PRIV_LUN].ptr;
1972 struct ctl_lun *lun;
1973 struct tpc_list *list, *tlist;
1974 struct tpc_token *token;
1975 int len, lendesc;
1976
1977 CTL_DEBUG_PRINT(("ctl_write_using_token\n"));
1978
1979 lun = (struct ctl_lun *)ctsio->io_hdr.ctl_private[CTL_PRIV_LUN].ptr;
1980 softc = lun->ctl_softc;
1976 cdb = (struct scsi_write_using_token *)ctsio->cdb;
1977 len = scsi_4btoul(cdb->length);
1978
1979 if (len < sizeof(struct scsi_populate_token_data) ||
1980 len > sizeof(struct scsi_populate_token_data) +
1981 TPC_MAX_SEGS * sizeof(struct scsi_range_desc)) {
1982 ctl_set_invalid_field(ctsio, /*sks_valid*/ 1, /*command*/ 1,
1983 /*field*/ 9, /*bit_valid*/ 0, /*bit*/ 0);

--- 62 unchanged lines hidden (view full) ---

2046 mtx_unlock(&lun->lun_lock);
2047
2048 /* Block device zero ROD token -> no token. */
2049 if (scsi_4btoul(data->rod_token) == ROD_TYPE_BLOCK_ZERO) {
2050 tpc_process(list);
2051 return (CTL_RETVAL_COMPLETE);
2052 }
2053
1981 cdb = (struct scsi_write_using_token *)ctsio->cdb;
1982 len = scsi_4btoul(cdb->length);
1983
1984 if (len < sizeof(struct scsi_populate_token_data) ||
1985 len > sizeof(struct scsi_populate_token_data) +
1986 TPC_MAX_SEGS * sizeof(struct scsi_range_desc)) {
1987 ctl_set_invalid_field(ctsio, /*sks_valid*/ 1, /*command*/ 1,
1988 /*field*/ 9, /*bit_valid*/ 0, /*bit*/ 0);

--- 62 unchanged lines hidden (view full) ---

2051 mtx_unlock(&lun->lun_lock);
2052
2053 /* Block device zero ROD token -> no token. */
2054 if (scsi_4btoul(data->rod_token) == ROD_TYPE_BLOCK_ZERO) {
2055 tpc_process(list);
2056 return (CTL_RETVAL_COMPLETE);
2057 }
2058
2054 mtx_lock(&control_softc->ctl_lock);
2055 TAILQ_FOREACH(token, &control_softc->tpc_tokens, links) {
2059 mtx_lock(&softc->ctl_lock);
2060 TAILQ_FOREACH(token, &softc->tpc_tokens, links) {
2056 if (memcmp(token->token, data->rod_token,
2057 sizeof(data->rod_token)) == 0)
2058 break;
2059 }
2060 if (token != NULL) {
2061 token->active++;
2062 list->token = token;
2063 if (data->flags & EC_WUT_DEL_TKN)
2064 token->timeout = 0;
2065 }
2061 if (memcmp(token->token, data->rod_token,
2062 sizeof(data->rod_token)) == 0)
2063 break;
2064 }
2065 if (token != NULL) {
2066 token->active++;
2067 list->token = token;
2068 if (data->flags & EC_WUT_DEL_TKN)
2069 token->timeout = 0;
2070 }
2066 mtx_unlock(&control_softc->ctl_lock);
2071 mtx_unlock(&softc->ctl_lock);
2067 if (token == NULL) {
2068 mtx_lock(&lun->lun_lock);
2069 TAILQ_REMOVE(&lun->tpc_lists, list, links);
2070 mtx_unlock(&lun->lun_lock);
2071 free(list, M_CTL);
2072 ctl_set_sense(ctsio, /*current_error*/ 1,
2073 /*sense_key*/ SSD_KEY_ILLEGAL_REQUEST,
2074 /*asc*/ 0x23, /*ascq*/ 0x04, SSD_ELEM_NONE);

--- 108 unchanged lines hidden (view full) ---

2183 ctsio->be_move_done = ctl_config_move_done;
2184 ctl_datamove((union ctl_io *)ctsio);
2185 return (retval);
2186}
2187
2188int
2189ctl_report_all_rod_tokens(struct ctl_scsiio *ctsio)
2190{
2072 if (token == NULL) {
2073 mtx_lock(&lun->lun_lock);
2074 TAILQ_REMOVE(&lun->tpc_lists, list, links);
2075 mtx_unlock(&lun->lun_lock);
2076 free(list, M_CTL);
2077 ctl_set_sense(ctsio, /*current_error*/ 1,
2078 /*sense_key*/ SSD_KEY_ILLEGAL_REQUEST,
2079 /*asc*/ 0x23, /*ascq*/ 0x04, SSD_ELEM_NONE);

--- 108 unchanged lines hidden (view full) ---

2188 ctsio->be_move_done = ctl_config_move_done;
2189 ctl_datamove((union ctl_io *)ctsio);
2190 return (retval);
2191}
2192
2193int
2194ctl_report_all_rod_tokens(struct ctl_scsiio *ctsio)
2195{
2196 struct ctl_softc *softc;
2191 struct ctl_lun *lun;
2192 struct scsi_report_all_rod_tokens *cdb;
2193 struct scsi_report_all_rod_tokens_data *data;
2194 struct tpc_token *token;
2195 int retval;
2196 int alloc_len, total_len, tokens, i;
2197
2198 CTL_DEBUG_PRINT(("ctl_receive_rod_token_information\n"));
2199
2200 cdb = (struct scsi_report_all_rod_tokens *)ctsio->cdb;
2201 lun = (struct ctl_lun *)ctsio->io_hdr.ctl_private[CTL_PRIV_LUN].ptr;
2197 struct ctl_lun *lun;
2198 struct scsi_report_all_rod_tokens *cdb;
2199 struct scsi_report_all_rod_tokens_data *data;
2200 struct tpc_token *token;
2201 int retval;
2202 int alloc_len, total_len, tokens, i;
2203
2204 CTL_DEBUG_PRINT(("ctl_receive_rod_token_information\n"));
2205
2206 cdb = (struct scsi_report_all_rod_tokens *)ctsio->cdb;
2207 lun = (struct ctl_lun *)ctsio->io_hdr.ctl_private[CTL_PRIV_LUN].ptr;
2208 softc = lun->ctl_softc;
2202
2203 retval = CTL_RETVAL_COMPLETE;
2204
2205 tokens = 0;
2209
2210 retval = CTL_RETVAL_COMPLETE;
2211
2212 tokens = 0;
2206 mtx_lock(&control_softc->ctl_lock);
2207 TAILQ_FOREACH(token, &control_softc->tpc_tokens, links)
2213 mtx_lock(&softc->ctl_lock);
2214 TAILQ_FOREACH(token, &softc->tpc_tokens, links)
2208 tokens++;
2215 tokens++;
2209 mtx_unlock(&control_softc->ctl_lock);
2216 mtx_unlock(&softc->ctl_lock);
2210 if (tokens > 512)
2211 tokens = 512;
2212
2213 total_len = sizeof(*data) + tokens * 96;
2214 alloc_len = scsi_4btoul(cdb->length);
2215
2216 ctsio->kern_data_ptr = malloc(total_len, M_CTL, M_WAITOK | M_ZERO);
2217

--- 8 unchanged lines hidden (view full) ---

2226 ctsio->kern_data_len = alloc_len;
2227 ctsio->kern_total_len = alloc_len;
2228 }
2229 ctsio->kern_data_resid = 0;
2230 ctsio->kern_rel_offset = 0;
2231
2232 data = (struct scsi_report_all_rod_tokens_data *)ctsio->kern_data_ptr;
2233 i = 0;
2217 if (tokens > 512)
2218 tokens = 512;
2219
2220 total_len = sizeof(*data) + tokens * 96;
2221 alloc_len = scsi_4btoul(cdb->length);
2222
2223 ctsio->kern_data_ptr = malloc(total_len, M_CTL, M_WAITOK | M_ZERO);
2224

--- 8 unchanged lines hidden (view full) ---

2233 ctsio->kern_data_len = alloc_len;
2234 ctsio->kern_total_len = alloc_len;
2235 }
2236 ctsio->kern_data_resid = 0;
2237 ctsio->kern_rel_offset = 0;
2238
2239 data = (struct scsi_report_all_rod_tokens_data *)ctsio->kern_data_ptr;
2240 i = 0;
2234 mtx_lock(&control_softc->ctl_lock);
2235 TAILQ_FOREACH(token, &control_softc->tpc_tokens, links) {
2241 mtx_lock(&softc->ctl_lock);
2242 TAILQ_FOREACH(token, &softc->tpc_tokens, links) {
2236 if (i >= tokens)
2237 break;
2238 memcpy(&data->rod_management_token_list[i * 96],
2239 token->token, 96);
2240 i++;
2241 }
2243 if (i >= tokens)
2244 break;
2245 memcpy(&data->rod_management_token_list[i * 96],
2246 token->token, 96);
2247 i++;
2248 }
2242 mtx_unlock(&control_softc->ctl_lock);
2249 mtx_unlock(&softc->ctl_lock);
2243 scsi_ulto4b(sizeof(*data) - 4 + i * 96, data->available_data);
2244/*
2245 printf("RART tokens=%d\n", i);
2246*/
2247 ctl_set_success(ctsio);
2248 ctsio->io_hdr.flags |= CTL_FLAG_ALLOCATED;
2249 ctsio->be_move_done = ctl_config_move_done;
2250 ctl_datamove((union ctl_io *)ctsio);
2251 return (retval);
2252}
2253
2250 scsi_ulto4b(sizeof(*data) - 4 + i * 96, data->available_data);
2251/*
2252 printf("RART tokens=%d\n", i);
2253*/
2254 ctl_set_success(ctsio);
2255 ctsio->io_hdr.flags |= CTL_FLAG_ALLOCATED;
2256 ctsio->be_move_done = ctl_config_move_done;
2257 ctl_datamove((union ctl_io *)ctsio);
2258 return (retval);
2259}
2260