libscsi.c

读取SCSI磁盘阵列信息的源代码,支持设备：mega scsi device

	strncpy(bi->bi_dev, scsi_adapter->adapter_dev.dv_xname, sizeof(bi->bi_dev));

	/* do we actually care how many disks we have at this point? */
	for (i = 0; i < p->ada_nld; i++)
		for (s = 0; s < p->ald[i].adl_spandepth; s++)
			for (t = 0; t < p->ald[i].adl_nstripes; t++) {
				off = p->ald[i].asp[s].adv[t].add_channel *
				    MEGASCSI_MAX_TARGET +
				    p->ald[i].asp[s].adv[t].add_target;

				if (!plist[off]) {
					plist[off] = 1;
					bi->bi_nodisk++;
				}
			}

	/*
	 * hack warning!
	 * Megaraid cards sometimes return a size in the PD structure
	 * even though there is no disk in that slot.  Work around
	 * that by issuing an INQUIRY to determine if there is
	 * an actual disk in the slot.
	 */
	for(i = 0; i < ((scsi_adapter->adapter_flags & MEGASCSI_QUARTZ) ?
	    MEGASCSI_BIG_MAX_PDRIVES : MEGASCSI_MAX_PDRIVES); i++) {
	    	/* skip claimed drives */
	    	if (plist[i])
			continue;

	    	/*
		 * poke drive to make sure its there.  If it is it is either
		 * unused or a hot spare; at this point we dont care which it is
		 */
		if (p->apd[i].adp_size) {
			ch = (i & 0xf0) >> 4;
			tg = i & 0x0f;

			if (!megascsi_drv_inq(scsi_adapter, ch, tg, 0, &inqbuf)) {
				bi->bi_novol++;
				bi->bi_nodisk++;
				plist[i] = 1;
			}
		}
	}

bail2:
	free(plist);
bail:
	free(p);

	return (error);
}


int
megascsi_vol(scsi_adapter, bv, p)
	struct megascsi_adapter *scsi_adapter;
	struct mioc_vol *bv;
	struct megascsi_big_diskarray *p;
{
	struct scsi_inquiry_data inqbuf;
	char *plist;
	int i, s, t, off;
	int ld = p->ada_nld, error = EINVAL;
	unsigned char ch, tg;

	plist = malloc(MEGASCSI_BIG_MAX_PDRIVES);
	if (!plist) {
		printf("%s: no memory for disk list\n",scsi_adapter->adapter_dev.dv_xname);
		return (ENOMEM);
	}

	memset(plist, 0, MEGASCSI_BIG_MAX_PDRIVES);

	/* setup plist */
	for (i = 0; i < p->ada_nld; i++)
		for (s = 0; s < p->ald[i].adl_spandepth; s++)
			for (t = 0; t < p->ald[i].adl_nstripes; t++) {
				off = p->ald[i].asp[s].adv[t].add_channel *
				    MEGASCSI_MAX_TARGET +
				    p->ald[i].asp[s].adv[t].add_target;

				if (!plist[off])
					plist[off] = 1;
			}

	for(i = 0; i < ((scsi_adapter->adapter_flags & MEGASCSI_QUARTZ) ?
	    MEGASCSI_BIG_MAX_PDRIVES : MEGASCSI_MAX_PDRIVES); i++) {
	    	/* skip claimed drives */
	    	if (plist[i])
			continue;

	    	/*
		 * poke drive to make sure its there.  If it is it is either
		 * unused or a hot spare; at this point we dont care which it is
		 */
		if (p->apd[i].adp_size) {
			ch = (i & 0xf0) >> 4;
			tg = i & 0x0f;

			if (!megascsi_drv_inq(scsi_adapter, ch, tg, 0, &inqbuf)) {
				if (ld != bv->bv_volid) {
					ld++;
					continue;
				}

				bv->bv_status = MIOC_SVONLINE;
				bv->bv_size = (unsigned long long)p->apd[i].adp_size *
				    (unsigned long long)512;
				bv->bv_nodisk = 1;
				strncpy(bv->bv_dev,
				    scsi_adapter->adapter_hdr[bv->bv_volid].dev,
				    sizeof(bv->bv_dev));

				if (p->apd[i].adp_ostatus == MEGASCSI_PD_HOTSPARE
				    && p->apd[i].adp_type == 0)
					bv->bv_level = -1;
				else
					bv->bv_level = -2;

				error = 0;
				goto bail;
			}
		}
	}

bail:
	free(plist);

	return (error);
}

int
megascsi_disk(scsi_adapter, bd, p)
	struct megascsi_adapter *scsi_adapter;
	struct mioc_disk *bd;
	struct megascsi_big_diskarray *p;
{
	struct scsi_inquiry_data inqbuf;
	struct scsi_inquiry_vpd vpdbuf;
	char *plist;
	int i, s, t, off;
	int ld = p->ada_nld, error = EINVAL;
	unsigned char ch, tg;

	plist = malloc(MEGASCSI_BIG_MAX_PDRIVES);
	if (!plist) {
		printf("%s: no memory for disk list\n",scsi_adapter->adapter_dev.dv_xname);
		return (ENOMEM);
	}

	memset(plist, 0, MEGASCSI_BIG_MAX_PDRIVES);

	/* setup plist */
	for (i = 0; i < p->ada_nld; i++)
		for (s = 0; s < p->ald[i].adl_spandepth; s++)
			for (t = 0; t < p->ald[i].adl_nstripes; t++) {
				off = p->ald[i].asp[s].adv[t].add_channel *
				    MEGASCSI_MAX_TARGET +
				    p->ald[i].asp[s].adv[t].add_target;

				if (!plist[off])
					plist[off] = 1;
			}

	for(i = 0; i < ((scsi_adapter->adapter_flags & MEGASCSI_QUARTZ) ?
	    MEGASCSI_BIG_MAX_PDRIVES : MEGASCSI_MAX_PDRIVES); i++) {
	    	/* skip claimed drives */
	    	if (plist[i])
			continue;

	    	/*
		 * poke drive to make sure its there.  If it is it is either
		 * unused or a hot spare; at this point we dont care which it is
		 */
		if (p->apd[i].adp_size) {
			ch = (i & 0xf0) >> 4;
			tg = i & 0x0f;

			if (!megascsi_drv_inq(scsi_adapter, ch, tg, 0, &inqbuf)) {
				char vend[8+16+4+1];

				if (ld != bd->bd_volid) {
					ld++;
					continue;
				}

				memcpy(vend, inqbuf.vendor,
				    sizeof vend - 1);

				vend[sizeof vend - 1] = '\0';
				strncpy(bd->bd_vendor, vend,
				    sizeof(bd->bd_vendor));

				if (!megascsi_drv_inq(scsi_adapter, ch, tg, 0x80, &vpdbuf)) {
					char ser[32 + 1];

					memcpy(ser, vpdbuf.serial,
					    sizeof ser - 1);

					ser[sizeof ser - 1] = '\0';
					if (vpdbuf.page_length < sizeof ser)
						ser[vpdbuf.page_length] = '\0';
					strncpy(bd->bd_serial, ser,
					    sizeof(bd->bd_serial));
				}

				bd->bd_size = (unsigned long long)p->apd[i].adp_size *
				    (unsigned long long)512;

				bd->bd_channel = ch;
				bd->bd_target = tg;

				strncpy(bd->bd_procdev,
				    scsi_adapter->adapter_rawadapters[ch].adapter_procdev,
				    sizeof(bd->bd_procdev));

				if (p->apd[i].adp_ostatus == MEGASCSI_PD_HOTSPARE
				    && p->apd[i].adp_type == 0)
					bd->bd_status = MIOC_SDHOTSPARE;
				else
					bd->bd_status = MIOC_SDUNUSED;

				error = 0;
				goto bail;
			}
		}
	}

bail:
	free(plist);

	return (error);
}

int
megascsi_ioctl_vol(scsi_adapter, bv)
	struct megascsi_adapter *scsi_adapter;
	struct mioc_vol *bv;
{
	struct megascsi_big_diskarray *p; /* struct too large for stack */
	int i, s, t;
	int error = 0;

	p = malloc(sizeof(struct megascsi_big_diskarray));
	if (!p) {
		printf("%s: no memory for raw interface\n",scsi_adapter->adapter_dev.dv_xname);
		return (ENOMEM);
	}

	memset(p, 0, sizeof(struct megascsi_big_diskarray));
	if (megascsi_mgmt(scsi_adapter, MEGASCSI_FCOP, MEGASCSI_FC_RDCONF, 0, 0, sizeof *p, p)) {
		error = EINVAL;
		goto bail;
	}

	if (bv->bv_volid >= p->ada_nld) {
		error = megascsi_vol(scsi_adapter, bv, p);
		goto bail;
	}

	i = bv->bv_volid;

	switch (p->ald[i].adl_status) {
	case MEGASCSI_RDRV_OFFLINE:
		bv->bv_status = MIOC_SVOFFLINE;
		break;

	case MEGASCSI_RDRV_DEGRADED:
		bv->bv_status = MIOC_SVDEGRADED;
		break;

	case MEGASCSI_RDRV_OPTIMAL:
		bv->bv_status = MIOC_SVONLINE;
		break;

	default:
		bv->bv_status = MIOC_SVINVALID;
	}

	bv->bv_size = 0;
	bv->bv_level = p->ald[i].adl_raidlvl;
	bv->bv_nodisk = 0;

	for (s = 0; s < p->ald[i].adl_spandepth; s++) {
		for (t = 0; t < p->ald[i].adl_nstripes; t++)
			bv->bv_nodisk++;

		switch (bv->bv_level) {
		case 0:
			bv->bv_size += p->ald[i].asp[s].ads_length *
			    p->ald[i].adl_nstripes;
			break;

		case 1:
			bv->bv_size += p->ald[i].asp[s].ads_length;
			break;

		case 5:
			bv->bv_size += p->ald[i].asp[s].ads_length *
			    (p->ald[i].adl_nstripes - 1);
			break;
		}
	}

	if (p->ald[i].adl_spandepth > 1)
		bv->bv_level *= 10;

	bv->bv_size *= (unsigned long long)512;

	strncpy(bv->bv_dev, scsi_adapter->adapter_hdr[i].dev, sizeof(bv->bv_dev));
	
bail:
	free(p);

	return (error);
}

int
megascsi_ioctl_disk(scsi_adapter, bd)
	struct megascsi_adapter *scsi_adapter;
	struct mioc_disk *bd;
{
	struct scsi_inquiry_data inqbuf;
	struct scsi_inquiry_vpd vpdbuf;
	struct megascsi_big_diskarray *p; /* struct too large for stack */
	int i, s, t, d;
	int off;
	int error = 0;
	unsigned short ch, tg;

	p = malloc(sizeof(struct megascsi_big_diskarray));
	if (!p) {
		printf("%s: no memory for raw interface\n",scsi_adapter->adapter_dev.dv_xname);
		return (ENOMEM);
	}

	memset(p, 0, sizeof(struct megascsi_big_diskarray));
	if (megascsi_mgmt(scsi_adapter, MEGASCSI_FCOP, MEGASCSI_FC_RDCONF, 0, 0, sizeof *p, p)) {
		error = EINVAL;
		goto bail;
	}

	if (bd->bd_volid >= p->ada_nld) {
		error = megascsi_disk(scsi_adapter, bd, p);
		goto bail;
	}

	i = bd->bd_volid;
	error = EINVAL;

	for (s = 0, d = 0; s < p->ald[i].adl_spandepth; s++)
		for (t = 0; t < p->ald[i].adl_nstripes; t++) {
			if (d != bd->bd_diskid) {
				d++;
				continue;
			}

			off = p->ald[i].asp[s].adv[t].add_channel *
			    MEGASCSI_MAX_TARGET +
			    p->ald[i].asp[s].adv[t].add_target;

			switch (p->apd[off].adp_ostatus) {
			case MEGASCSI_PD_UNCNF:
				bd->bd_status = MIOC_SDUNUSED;
				break;

			case MEGASCSI_PD_ONLINE:
				bd->bd_status = MIOC_SDONLINE;
				break;

			case MEGASCSI_PD_FAILED:
				bd->bd_status = MIOC_SDFAILED;
				break;

			case MEGASCSI_PD_RBLD:
				bd->bd_status = MIOC_SDREBUILD;
				break;

			case MEGASCSI_PD_HOTSPARE:
				bd->bd_status = MIOC_SDHOTSPARE;
				break;

			default:
				bd->bd_status = MIOC_SDINVALID;
			}

			bd->bd_size = (unsigned long long)p->apd[off].adp_size *
			    (unsigned long long)512;

			ch = p->ald[i].asp[s].adv[t].add_target >> 4;
			tg = p->ald[i].asp[s].adv[t].add_target & 0x0f;

			if (!megascsi_drv_inq(scsi_adapter, ch, tg, 0, &inqbuf)) {
				char vend[8+16+4+1];

				memcpy(vend, inqbuf.vendor, sizeof vend - 1);

				vend[sizeof vend - 1] = '\0';
				strncpy(bd->bd_vendor, vend,
				    sizeof(bd->bd_vendor));
			}

			if (!megascsi_drv_inq(scsi_adapter, ch, tg, 0x80, &vpdbuf)) {
				char ser[32 + 1];

				memcpy(ser, vpdbuf.serial, sizeof ser - 1);

				ser[sizeof ser - 1] = '\0';
				if (vpdbuf.page_length < sizeof ser)
					ser[vpdbuf.page_length] = '\0';
				strncpy(bd->bd_serial, ser,
				    sizeof(bd->bd_serial));
			}

			bd->bd_channel = ch;
			bd->bd_target = tg;

			strncpy(bd->bd_procdev, scsi_adapter->adapter_rawadapters[ch].adapter_procdev,
			    sizeof(bd->bd_procdev));

			error = 0;
			goto bail;
		}

	/* XXX if we reach this do dedicated hotspare magic*/
bail:
	free(p);

	return (error);
}