static int multipath_pr_in(int fd, const uint8_t *cdb, uint8_t *sense, uint8_t *data, int sz) { int rq_servact = cdb[1]; struct prin_resp resp; size_t written; int r; switch (rq_servact) { case MPATH_PRIN_RKEY_SA: case MPATH_PRIN_RRES_SA: case MPATH_PRIN_RCAP_SA: break; case MPATH_PRIN_RFSTAT_SA: /* Nobody implements it anyway, so bail out. */ default: /* Cannot parse any other output. */ scsi_build_sense(sense, SENSE_CODE(INVALID_FIELD)); return CHECK_CONDITION; } r = mpath_persistent_reserve_in(fd, rq_servact, &resp, noisy, verbose); if (r == MPATH_PR_SUCCESS) { switch (rq_servact) { case MPATH_PRIN_RKEY_SA: case MPATH_PRIN_RRES_SA: { struct prin_readdescr *out = &resp.prin_descriptor.prin_readkeys; assert(sz >= 8); written = MIN(out->additional_length + 8, sz); stl_be_p(&data[0], out->prgeneration); stl_be_p(&data[4], out->additional_length); memcpy(&data[8], out->key_list, written - 8); break; } case MPATH_PRIN_RCAP_SA: { struct prin_capdescr *out = &resp.prin_descriptor.prin_readcap; assert(sz >= 6); written = 6; stw_be_p(&data[0], out->length); data[2] = out->flags[0]; data[3] = out->flags[1]; stw_be_p(&data[4], out->pr_type_mask); break; } default: scsi_build_sense(sense, SENSE_CODE(INVALID_OPCODE)); return CHECK_CONDITION; } assert(written <= sz); memset(data + written, 0, sz - written); } return mpath_reconstruct_sense(fd, r, sense); }
static int do_sgio_worker(void *opaque) { PRHelperSGIOData *data = opaque; struct sg_io_hdr io_hdr; int ret; int status; SCSISense sense_code; memset(data->sense, 0, PR_HELPER_SENSE_SIZE); memset(&io_hdr, 0, sizeof(io_hdr)); io_hdr.interface_id = 'S'; io_hdr.cmd_len = PR_HELPER_CDB_SIZE; io_hdr.cmdp = (uint8_t *)data->cdb; io_hdr.sbp = data->sense; io_hdr.mx_sb_len = PR_HELPER_SENSE_SIZE; io_hdr.timeout = 1; io_hdr.dxfer_direction = data->dir; io_hdr.dxferp = (char *)data->buf; io_hdr.dxfer_len = data->sz; ret = ioctl(data->fd, SG_IO, &io_hdr); status = sg_io_sense_from_errno(ret < 0 ? errno : 0, &io_hdr, &sense_code); if (status == GOOD) { data->sz -= io_hdr.resid; } else { data->sz = 0; } if (status == CHECK_CONDITION && !(io_hdr.driver_status & SG_ERR_DRIVER_SENSE)) { scsi_build_sense(data->sense, sense_code); } return status; }
static int scsi_get_sense(SCSIRequest *req, uint8_t *outbuf, int len) { SCSIGenericState *s = DO_UPCAST(SCSIGenericState, qdev, req->dev); int size = SCSI_SENSE_BUF_SIZE; if (!(s->driver_status & SG_ERR_DRIVER_SENSE)) { size = scsi_build_sense(SENSE_CODE(NO_SENSE), s->sensebuf, SCSI_SENSE_BUF_SIZE, 0); } if (size > len) { size = len; } memcpy(outbuf, s->sensebuf, size); return size; }
static int mpath_reconstruct_sense(int fd, int r, uint8_t *sense) { switch (r) { case MPATH_PR_SUCCESS: return GOOD; case MPATH_PR_SENSE_NOT_READY: case MPATH_PR_SENSE_MEDIUM_ERROR: case MPATH_PR_SENSE_HARDWARE_ERROR: case MPATH_PR_SENSE_ABORTED_COMMAND: { /* libmpathpersist ate the exact sense. Try to find it by * issuing TEST UNIT READY. */ uint8_t cdb[6] = { TEST_UNIT_READY }; int sz = 0; int r = do_sgio(fd, cdb, sense, NULL, &sz, SG_DXFER_NONE); if (r != GOOD) { return r; } scsi_build_sense(sense, mpath_generic_sense(r)); return CHECK_CONDITION; } case MPATH_PR_SENSE_UNIT_ATTENTION: /* Congratulations libmpathpersist, you ruined the Unit Attention... * Return a heavyweight one. */ scsi_build_sense(sense, SENSE_CODE(SCSI_BUS_RESET)); return CHECK_CONDITION; case MPATH_PR_SENSE_INVALID_OP: /* Only one valid sense. */ scsi_build_sense(sense, SENSE_CODE(INVALID_OPCODE)); return CHECK_CONDITION; case MPATH_PR_ILLEGAL_REQ: /* Guess. */ scsi_build_sense(sense, SENSE_CODE(INVALID_PARAM)); return CHECK_CONDITION; case MPATH_PR_NO_SENSE: scsi_build_sense(sense, SENSE_CODE(NO_SENSE)); return CHECK_CONDITION; case MPATH_PR_RESERV_CONFLICT: return RESERVATION_CONFLICT; case MPATH_PR_OTHER: default: scsi_build_sense(sense, SENSE_CODE(LUN_COMM_FAILURE)); return CHECK_CONDITION; } }
static int multipath_pr_out(int fd, const uint8_t *cdb, uint8_t *sense, const uint8_t *param, int sz) { int rq_servact = cdb[1]; int rq_scope = cdb[2] >> 4; int rq_type = cdb[2] & 0xf; struct prout_param_descriptor paramp; char transportids[PR_HELPER_DATA_SIZE]; int r; if (sz < PR_OUT_FIXED_PARAM_SIZE) { /* Illegal request, Parameter list length error. This isn't fatal; * we have read the data, send an error without closing the socket. */ scsi_build_sense(sense, SENSE_CODE(INVALID_PARAM_LEN)); return CHECK_CONDITION; } switch (rq_servact) { case MPATH_PROUT_REG_SA: case MPATH_PROUT_RES_SA: case MPATH_PROUT_REL_SA: case MPATH_PROUT_CLEAR_SA: case MPATH_PROUT_PREE_SA: case MPATH_PROUT_PREE_AB_SA: case MPATH_PROUT_REG_IGN_SA: break; case MPATH_PROUT_REG_MOV_SA: /* Not supported by struct prout_param_descriptor. */ default: /* Cannot parse any other input. */ scsi_build_sense(sense, SENSE_CODE(INVALID_FIELD)); return CHECK_CONDITION; } /* Convert input data, especially transport IDs, to the structs * used by libmpathpersist (which, of course, will immediately * do the opposite). */ memset(¶mp, 0, sizeof(paramp)); memcpy(¶mp.key, ¶m[0], 8); memcpy(¶mp.sa_key, ¶m[8], 8); paramp.sa_flags = param[20]; if (sz > PR_OUT_FIXED_PARAM_SIZE) { size_t transportid_len; int i, j; if (sz < PR_OUT_FIXED_PARAM_SIZE + 4) { scsi_build_sense(sense, SENSE_CODE(INVALID_PARAM_LEN)); return CHECK_CONDITION; } transportid_len = ldl_be_p(¶m[24]) + PR_OUT_FIXED_PARAM_SIZE + 4; if (transportid_len > sz) { scsi_build_sense(sense, SENSE_CODE(INVALID_PARAM)); return CHECK_CONDITION; } for (i = PR_OUT_FIXED_PARAM_SIZE + 4, j = 0; i < transportid_len; ) { struct transportid *id = (struct transportid *) &transportids[j]; int len; id->format_code = param[i] & 0xc0; id->protocol_id = param[i] & 0x0f; switch (param[i] & 0xcf) { case 0: /* FC transport. */ if (i + 24 > transportid_len) { goto illegal_req; } memcpy(id->n_port_name, ¶m[i + 8], 8); j += offsetof(struct transportid, n_port_name[8]); i += 24; break; case 5: case 0x45: /* iSCSI transport. */ len = lduw_be_p(¶m[i + 2]); if (len > 252 || (len & 3) || i + len + 4 > transportid_len) { /* For format code 00, the standard says the maximum is 223 * plus the NUL terminator. For format code 01 there is no * maximum length, but libmpathpersist ignores the first * byte of id->iscsi_name so our maximum is 252. */ goto illegal_req; } if (memchr(¶m[i + 4], 0, len) == NULL) { goto illegal_req; } memcpy(id->iscsi_name, ¶m[i + 2], len + 2); j += offsetof(struct transportid, iscsi_name[len + 2]); i += len + 4; break; case 6: /* SAS transport. */ if (i + 24 > transportid_len) { goto illegal_req; } memcpy(id->sas_address, ¶m[i + 4], 8); j += offsetof(struct transportid, sas_address[8]); i += 24; break; default: illegal_req: scsi_build_sense(sense, SENSE_CODE(INVALID_PARAM)); return CHECK_CONDITION; } paramp.trnptid_list[paramp.num_transportid++] = id; } }
static void scsi_set_sense(SCSIGenericState *s, SCSISense sense) { s->senselen = scsi_build_sense(sense, s->sensebuf, SCSI_SENSE_BUF_SIZE, 0); s->driver_status = SG_ERR_DRIVER_SENSE; }