Lines Matching refs:sense
928 /*sense key entries*/NULL,
939 /*sense key entries*/NULL,
949 /*sense key entries*/NULL,
959 /*sense key entries*/NULL,
999 "No additional sense information") },
2159 "Failed to sense top-of-form") },
2162 "Failed to sense bottom-of-form") },
2306 "Inspect referrals sense descriptors") },
3366 * Given sense and device type information, return the appropriate action.
3368 * pair, fall back on the more generic actions derived from the sense key.
3387 * with this request sense. A deferred error is an error
3405 * sense handler or punted back up to a user mode daemon
3416 * with the error action of the sense key.
3617 * Iterate over sense descriptors. Each descriptor is passed into iter_func().
3622 scsi_desc_iterate(struct scsi_sense_data_desc *sense, u_int sense_len,
3623 int (*iter_func)(struct scsi_sense_data_desc *sense,
3633 if (SSD_DESC_IS_PRESENT(sense, sense_len, extra_len) == 0)
3646 desc_len = MIN(desc_len, MIN(sense->extra_len, SSD_EXTRA_MAX));
3660 &sense->sense_desc[cur_pos];
3675 if (iter_func(sense, sense_len, header, arg) != 0)
3688 scsi_find_desc_func(struct scsi_sense_data_desc *sense, u_int sense_len,
3705 * Given a descriptor type, return a pointer to it if it is in the sense
3706 * data and not truncated. Avoiding truncating sense data will simplify
3710 scsi_find_desc(struct scsi_sense_data_desc *sense, u_int sense_len,
3718 scsi_desc_iterate(sense, sense_len, scsi_find_desc_func, &desc_info);
3724 * Fill in SCSI sense data with the specified parameters. This routine can
3725 * fill in either fixed or descriptor type sense data.
3736 * Determine whether to return fixed or descriptor format sense
3738 * they'll just get fixed sense data.
3746 * Zero the sense data, so that we don't pass back any garbage data
3752 struct scsi_sense_data_desc *sense;
3754 sense = (struct scsi_sense_data_desc *)sense_data;
3756 * The descriptor sense format eliminates the use of the
3760 sense->error_code = SSD_DESC_CURRENT_ERROR;
3762 sense->error_code = SSD_DESC_DEFERRED_ERROR;
3763 sense->sense_key = sense_key;
3764 sense->add_sense_code = asc;
3765 sense->add_sense_code_qual = ascq;
3768 * fits in the standard descriptor sense information.
3770 sense->extra_len = 0;
3777 printf("%s: invalid sense type %d\n", __func__,
3784 sense->extra_len);
3800 bcopy(data, &sense->sense_desc[
3801 sense->extra_len], len_to_copy);
3802 sense->extra_len += len_to_copy;
3811 * This is already-formatted sense key
3822 bcopy(&sks,&sense->sense_desc[sense->extra_len],
3824 sense->extra_len += sizeof(sks);
3890 SSD_EXTRA_MAX - sense->extra_len);
3891 bcopy(descriptor, &sense->sense_desc[
3892 sense->extra_len], copy_len);
3893 sense->extra_len += copy_len;
3908 sense->extra_len);
3909 bcopy(&fru, &sense->sense_desc[
3910 sense->extra_len], copy_len);
3911 sense->extra_len += copy_len;
3925 SSD_EXTRA_MAX - sense->extra_len);
3926 bcopy(&stream_sense, &sense->sense_desc[
3927 sense->extra_len], copy_len);
3928 sense->extra_len += copy_len;
3941 struct scsi_sense_data_fixed *sense;
3943 sense = (struct scsi_sense_data_fixed *)sense_data;
3946 sense->error_code = SSD_CURRENT_ERROR;
3948 sense->error_code = SSD_DEFERRED_ERROR;
3950 sense->flags = sense_key;
3951 sense->add_sense_code = asc;
3952 sense->add_sense_code_qual = ascq;
3958 sense->extra_len = 6;
3966 printf("%s: invalid sense type %d\n", __func__,
3975 sense->extra_len = 10;
3982 * The user passed in pre-formatted sense
3985 bcopy(data, &sense->sense_key_spec[0],
3986 MIN(sizeof(sense->sense_key_spec),
3995 data_dest = &sense->cmd_spec_info[0];
3997 sizeof(sense->cmd_spec_info));
3999 data_dest = &sense->info[0];
4001 sizeof(sense->info));
4006 sense->error_code |= SSD_ERRCODE_VALID;
4023 sense->fru = *data;
4026 sense->flags |= *data;
4032 * If the user passes in descriptor sense,
4057 * Get sense information for three similar sense data types.
4072 struct scsi_sense_data_desc *sense;
4075 sense = (struct scsi_sense_data_desc *)sense_data;
4077 desc = scsi_find_desc(sense, sense_len, info_type);
4118 struct scsi_sense_data_fixed *sense;
4120 sense = (struct scsi_sense_data_fixed *)sense_data;
4126 if ((sense->error_code & SSD_ERRCODE_VALID) == 0)
4129 if (SSD_FIXED_IS_PRESENT(sense, sense_len, info) == 0)
4132 info_val = scsi_4btoul(sense->info);
4142 if ((SSD_FIXED_IS_PRESENT(sense, sense_len,
4144 || (SSD_FIXED_IS_FILLED(sense, cmd_spec_info) == 0))
4147 cmd_val = scsi_4btoul(sense->cmd_spec_info);
4157 if ((SSD_FIXED_IS_PRESENT(sense, sense_len, fru) == 0)
4158 || (SSD_FIXED_IS_FILLED(sense, fru) == 0))
4161 if (sense->fru == 0)
4164 *info = sense->fru;
4166 *signed_info = (int8_t)sense->fru;
4196 struct scsi_sense_data_desc *sense;
4199 sense = (struct scsi_sense_data_desc *)sense_data;
4201 desc = (struct scsi_sense_sks *)scsi_find_desc(sense, sense_len,
4207 * No need to check the SKS valid bit for descriptor sense.
4214 struct scsi_sense_data_fixed *sense;
4216 sense = (struct scsi_sense_data_fixed *)sense_data;
4218 if ((SSD_FIXED_IS_PRESENT(sense, sense_len, sense_key_spec)== 0)
4219 || (SSD_FIXED_IS_FILLED(sense, sense_key_spec) == 0))
4222 if ((sense->sense_key_spec[0] & SSD_SCS_VALID) == 0)
4225 bcopy(sense->sense_key_spec, sks,sizeof(sense->sense_key_spec));
4238 * Provide a common interface for fixed and descriptor sense to detect
4239 * whether we have block-specific sense information. It is clear by the
4264 struct scsi_sense_data_desc *sense;
4267 sense = (struct scsi_sense_data_desc *)sense_data;
4269 block = (struct scsi_sense_block *)scsi_find_desc(sense,
4278 struct scsi_sense_data_fixed *sense;
4280 sense = (struct scsi_sense_data_fixed *)sense_data;
4282 if (SSD_FIXED_IS_PRESENT(sense, sense_len, flags) == 0)
4285 if ((sense->flags & SSD_ILI) == 0)
4288 *block_bits = sense->flags & SSD_ILI;
4320 struct scsi_sense_data_desc *sense;
4323 sense = (struct scsi_sense_data_desc *)sense_data;
4325 stream = (struct scsi_sense_stream *)scsi_find_desc(sense,
4334 struct scsi_sense_data_fixed *sense;
4336 sense = (struct scsi_sense_data_fixed *)sense_data;
4338 if (SSD_FIXED_IS_PRESENT(sense, sense_len, flags) == 0)
4341 if ((sense->flags & (SSD_ILI|SSD_EOM|SSD_FILEMARK)) == 0)
4344 *stream_bits = sense->flags & (SSD_ILI|SSD_EOM|SSD_FILEMARK);
4515 scsi_sense_info_sbuf(struct sbuf *sb, struct scsi_sense_data *sense,
4528 scsi_sense_command_sbuf(struct sbuf *sb, struct scsi_sense_data *sense,
4542 scsi_sense_sks_sbuf(struct sbuf *sb, struct scsi_sense_data *sense,
4552 scsi_extract_sense_len(sense, sense_len, &error_code, &sense_key,
4559 scsi_sense_fru_sbuf(struct sbuf *sb, struct scsi_sense_data *sense,
4572 scsi_sense_stream_sbuf(struct sbuf *sb, struct scsi_sense_data *sense,
4583 scsi_get_sense_info(sense, sense_len, SSD_DESC_INFO, &info, NULL);
4589 scsi_sense_block_sbuf(struct sbuf *sb, struct scsi_sense_data *sense,
4600 scsi_get_sense_info(sense, sense_len, SSD_DESC_INFO, &info, NULL);
4606 scsi_sense_progress_sbuf(struct sbuf *sb, struct scsi_sense_data *sense,
4619 * Get descriptions for the sense key, ASC, and ASCQ in the
4621 * in the overall sense data.
4631 * sense key, ASC, and ASCQ in the descriptor.
4640 * Generic sense descriptor printing routine. This is used when we have
4644 scsi_sense_generic_sbuf(struct sbuf *sb, struct scsi_sense_data *sense,
4669 * Sense key specific descriptors need the sense key.
4671 * The sense, cdb, and inquiry data arguments may be NULL, but the
4674 void (*print_func)(struct sbuf *sb, struct scsi_sense_data *sense,
4689 scsi_sense_desc_sbuf(struct sbuf *sb, struct scsi_sense_data *sense,
4712 printer->print_func(sb, sense, sense_len, cdb, cdb_len,
4721 scsi_sense_generic_sbuf(sb, sense, sense_len, cdb, cdb_len,
4753 scsi_print_desc_func(struct scsi_sense_data_desc *sense, u_int sense_len,
4775 (struct scsi_sense_data *)sense, sense_len,
4791 scsi_sense_only_sbuf(struct scsi_sense_data *sense, u_int sense_len,
4800 scsi_extract_sense_len(sense, sense_len, &error_code, &sense_key,
4803 sbuf_printf(sb, "SCSI sense: ");
4822 * Get descriptions for the sense key, ASC, and ASCQ. If
4823 * these aren't present in the sense data (i.e. the sense
4832 * We first print the sense key and ASC/ASCQ.
4840 if (scsi_get_sense_info(sense, sense_len, SSD_DESC_INFO,
4853 if (scsi_get_block_info(sense, sense_len, inq_data,
4858 } else if (scsi_get_stream_info(sense, sense_len,
4879 if (scsi_get_sense_info(sense, sense_len, SSD_DESC_FRU,
4889 if (scsi_get_sense_info(sense, sense_len, SSD_DESC_COMMAND,
4897 * Print out any sense-key-specific information.
4899 if (scsi_get_sks(sense, sense_len, sks) == 0) {
4906 * If this is fixed sense, we're done. If we have
4907 * descriptor sense, we might have more information
4910 if (scsi_sense_type(sense) != SSD_TYPE_DESC)
4913 desc_sense = (struct scsi_sense_data_desc *)sense;
4922 * Print any sense descriptors that we have not already printed.
4933 * sense data. This means that sense_len is 0.
4935 sbuf_printf(sb, "No sense data present\n");
4939 if (sense->error_code & SSD_ERRCODE_VALID) {
4942 fixed_sense = (struct scsi_sense_data_fixed *)sense;
4972 struct scsi_sense_data *sense;
5026 sense = NULL;
5041 * If the sense data is a physical pointer, forget it.
5053 * ensure that the sense data is pointer aligned.
5055 bcopy(&csio->sense_data, &sense,
5060 * If the physical sense flag is set, but the sense pointer
5073 sense = &csio->sense_data;
5081 scsi_sense_only_sbuf(sense, csio->sense_len - csio->sense_resid, sb,
5155 * Extract basic sense information. This is backward-compatible with the
5168 * Extract basic sense information from SCSI I/O CCB structure.
5176 /* Make sure there are some sense data we can access. */
5198 * Extract basic sense information. If show_errors is set, sense values
5207 * If we have no length, we have no sense.
5229 struct scsi_sense_data_desc *sense;
5231 sense = (struct scsi_sense_data_desc *)sense_data;
5233 if (SSD_DESC_IS_PRESENT(sense, sense_len, sense_key))
5234 *sense_key = sense->sense_key & SSD_KEY;
5238 if (SSD_DESC_IS_PRESENT(sense, sense_len, add_sense_code))
5239 *asc = sense->add_sense_code;
5243 if (SSD_DESC_IS_PRESENT(sense, sense_len, add_sense_code_qual))
5244 *ascq = sense->add_sense_code_qual;
5252 struct scsi_sense_data_fixed *sense;
5254 sense = (struct scsi_sense_data_fixed *)sense_data;
5256 if (SSD_FIXED_IS_PRESENT(sense, sense_len, flags))
5257 *sense_key = sense->flags & SSD_KEY;
5261 if ((SSD_FIXED_IS_PRESENT(sense, sense_len, add_sense_code))
5262 && (SSD_FIXED_IS_FILLED(sense, add_sense_code)))
5263 *asc = sense->add_sense_code;
5267 if ((SSD_FIXED_IS_PRESENT(sense, sense_len,add_sense_code_qual))
5268 && (SSD_FIXED_IS_FILLED(sense, add_sense_code_qual)))
5269 *ascq = sense->add_sense_code_qual;
7002 * A field size of 0 doesn't make sense here. The device