Unix/FreeBSD/scsidump.cpp

/*
 *  scsidump.cpp - SCSI Dump (to see FreeBSD remappings)
 *  Compile as (CAM version): gcc -I/sys -DCAM -o scsidump scsidump.cpp -lcam
 *        (old SCSI version): gcc -o scsidump scsidump.cpp -lscsi
 *  Copyright (C) 1999 Orlando Bassotto
 *
 *  Basilisk II (C) 1997-2004 Christian Bauer
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *  History:
 *    29-Jun-1999 Started
 *    05-Jul-1999 Changed from array to queue removing the limit of 8 
 *                devices.
 *                Implemented old SCSI manager for FreeBSD 2.x.
 *                (Note: This implementation have been never tested;
 *                 I don't own anymore a machine with FreeBSD 2.x,
 *                 so if something goes wrong, please mail me at
 *                 future@mediabit.net).
 */

#include <sys/ioctl.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <ctype.h>
#include <err.h>

#ifdef CAM
#include <cam/cam.h>
#include <cam/cam_debug.h>
#include <cam/cam_ccb.h>
#include <cam/scsi/scsi_all.h>
#include <cam/scsi/scsi_da.h>
#include <cam/scsi/scsi_pass.h>
#include <cam/scsi/scsi_message.h>
#include <camlib.h>
#else /* !CAM */
#include <sys/scsiio.h>
#include <scsi.h>
#endif /* !CAM */

#undef u_int8_t
#define u_int8_t unsigned char

typedef struct _SCSIDevice {
        int             controller;             // SCSI Controller
        int             controller_bus;         // SCSI Controller Bus
        char            controller_name[33];    // SCSI Controller name
        int             mac_unit;               // Macintosh SCSI ID (remapped)
        int             faked_controller;       // "Faked" SCSI Controller (Always 0)
        int             faked_unit;             // "Faked" SCSI ID
        int             unit;                   // Real SCSI ID
        int             lun;                    // Real SCSI LUN
        u_int8_t        vendor[16];             // SCSI Vendor
        u_int8_t        product[48];            // SCSI Product
        u_int8_t        revision[16];           // SCSI Revision
        char            device[33];             // SCSI Device
#ifdef CAM
        char            pass_device[33];        // SCSI Pass Device
#else /* !CAM */
        int             dev_fd;                 // Device File Descriptor
#endif /* !CAM */
        void*           dev_ptr;                // Pointer to CAM/SCSI structure
        bool            enabled;                // Device enabled ?
        struct _SCSIDevice* next;               // Pointer to the next device
} SCSIDevice;

static int nDevices = 0;
static SCSIDevice* Devices = NULL;

inline static SCSIDevice* _GetSCSIDeviceByID(int id)
{
        SCSIDevice* aux = Devices;
        while(aux) {
                if(aux->faked_unit==id) {
                        return aux;
                }
                aux = aux->next;
        }
        return NULL;
}

inline static SCSIDevice* _GetSCSIDeviceByIDLUN(int id, int lun)
{
        SCSIDevice* aux = Devices;
        while(aux) {
                if(aux->faked_unit==id&&aux->lun==lun) {
                        return aux;
                }
                aux = aux->next;
        }
        return NULL;
}

inline static SCSIDevice* _GetSCSIDeviceByMacID(int id)
{
        SCSIDevice* aux = Devices;
        while(aux) {
                if(aux->mac_unit==id) {
                        return aux;
                }
                aux = aux->next;
        }
        return NULL;
}

inline static SCSIDevice* _GetSCSIDeviceByMacIDLUN(int id, int lun)
{
        SCSIDevice* aux = Devices;
        while(aux) {
                if(aux->mac_unit==id&&aux->lun==lun) {
                        return aux;
                }
                aux = aux->next;
        }
        return NULL;
}

inline static SCSIDevice* _AllocNewDevice()
{
        SCSIDevice* aux;
        
        aux = new SCSIDevice;
        if(aux==NULL) return NULL;
        memset(aux, 0, sizeof(SCSIDevice));
        aux->next = Devices;
        Devices = aux;
        return aux;
}

/*
 * _Build_SCSI_Controller()
 *
 * This function builds a virtual SCSI Controller (Controller=0)
 * where keeps all the devices found, this is due the fact
 * I have two SCSI controllers in my PC. :-)
 * Use FreeBSD-SCSIDump in contrib/ to see how is remapped your 
 * SCSI device (only if you have more than one controller, 
 * that's for sure :-).
 */

#define GET_FREE_ID(id) \
        { \
                for(int x=0;x<32;x++) { \
                        if(!(busyIDs&(1<<(x+1)))) { \
                                id = x; \
                                break; \
                        } \
                } \
        }
        
static void _Build_SCSI_Controller()
{
        unsigned int id = 0;
        unsigned long long busyIDs = 0x0ll;
        SCSIDevice* aux, * dev;
                
        // What IDs are busy?
        dev = Devices;
        while(dev) {
                dev->enabled = false;
                dev->faked_controller = 0;
                dev->faked_unit = dev->unit;
                busyIDs |= (1 << (dev->unit+1));
                dev = dev->next;
        }
        
        // Find out the duplicate IDs and change them
        dev = Devices, aux = NULL;
        while(dev) {
                aux = dev;
                while(aux) {
                        SCSIDevice* dev1, * dev2;
                        
                        dev1 = dev, dev2 = aux;
                        
                        if(dev1->controller!=dev2->controller&&
                                dev1->unit==dev2->unit) {
                                int free_id;
                                GET_FREE_ID(free_id);
                                busyIDs |= (1<<(free_id+1));
                                dev1->faked_unit = free_id;
                        }
                        aux = aux->next;
                }
                dev = dev->next;
        }
        
        // Now reorder the queue 
        dev = Devices;
        while(dev) {
                aux = dev;
                while(aux) {
                        SCSIDevice* dev1, * dev2;
        
                        dev1 = dev, dev2 = aux;
/*                      
                        if(dev1->faked_unit>dev2->faked_unit) {
                                SCSIDevice tmp;
                                
                                memcpy(&tmp, dev1, sizeof(SCSIDevice));
                                memcpy(dev1, dev2, sizeof(SCSIDevice));
                                memcpy(dev2, &tmp, sizeof(SCSIDevice));
                        }
                        */
                        aux = aux->next;
                }
                dev = dev->next;
        }
}       

#define SCSIReset()
        
/*
 *  Initialization
 */

void SCSIInit(void)
{
        // Find the SCSI hosts in the system
        // Filling out the SCSIDevices queue.
        // Stolen from camcontrol.c
        int bufsize, fd;
        int need_close = 0;
        int error = 0;
        int skip_device = 0;
        SCSIDevice* Dev, * dev, * PrevDev = NULL;
        
        nDevices = 0;

#ifdef CAM
        union ccb ccb;

        if ((fd = open(XPT_DEVICE, O_RDWR)) == -1) {
                fprintf(stderr, "Cannot open CAM device: %s\n", XPT_DEVICE);
                goto no_scsi;
        }
        
        memset(&(&ccb.ccb_h)[1], 0, sizeof(struct ccb_dev_match)-sizeof(struct ccb_hdr));
        ccb.ccb_h.func_code = XPT_DEV_MATCH;
        bufsize = sizeof(struct dev_match_result) * 100;
        ccb.cdm.match_buf_len = bufsize;
        ccb.cdm.matches = (struct dev_match_result *)malloc(bufsize);
        ccb.cdm.num_matches = 0;
        
        ccb.cdm.num_patterns = 0;
        ccb.cdm.pattern_buf_len = 0;
        
        do {
                Dev = _AllocNewDevice();        
                if(ioctl(fd, CAMIOCOMMAND, &ccb)==-1) {
                        fprintf(stderr, "Error sending CAMIOCOMMAND ioctl\n");
                        return;
                }
                
                if((ccb.ccb_h.status != CAM_REQ_CMP)
                || ((ccb.cdm.status != CAM_DEV_MATCH_LAST)
                 && (ccb.cdm.status != CAM_DEV_MATCH_MORE))) {
                        fprintf(stderr, "Got CAM error %#x, CDM error %d\n",
                                ccb.ccb_h.status, ccb.cdm.status);
                        return;
                }
                 
                char current_controller_name[33];
                int current_controller = -1;
                for(int i=0;i<ccb.cdm.num_matches;i++) {
                        switch(ccb.cdm.matches[i].type) {
                        case DEV_MATCH_BUS:
                        {
                                struct bus_match_result* bus_result;
                                                                
                                bus_result = &ccb.cdm.matches[i].result.bus_result;
                                
                                if(bus_result->path_id==-1) break;
                                Dev->controller = bus_result->path_id;
                                snprintf(Dev->controller_name, sizeof(Dev->controller_name), "%s%d", 
                                        bus_result->dev_name,
                                        bus_result->unit_number);
                                strncpy(current_controller_name, Dev->controller_name, sizeof(current_controller_name));
                                current_controller = Dev->controller;
                                Dev->controller_bus = bus_result->bus_id;
                                break;
                        }
                        case DEV_MATCH_DEVICE:
                        {
                                struct device_match_result* dev_result;
                                char tmpstr[256];
                                
                                dev_result = &ccb.cdm.matches[i].result.device_result;
                                if(current_controller==-1||dev_result->target_id==-1) {
                                        skip_device = 1;
                                        break;
                                }
                                else skip_device = 0;
                                
                                cam_strvis(Dev->vendor, (u_int8_t*)dev_result->inq_data.vendor,
                                        sizeof(dev_result->inq_data.vendor),
                                        sizeof(Dev->vendor));
                                cam_strvis(Dev->product, (u_int8_t*)dev_result->inq_data.product,
                                        sizeof(dev_result->inq_data.product),
                                        sizeof(Dev->product));
                                cam_strvis(Dev->revision, (u_int8_t*)dev_result->inq_data.revision,
                                        sizeof(dev_result->inq_data.revision),
                                        sizeof(Dev->revision));
                                strncpy(Dev->controller_name, current_controller_name, sizeof(Dev->controller_name));
                                Dev->controller = current_controller;
                                Dev->unit = dev_result->target_id;
                                Dev->lun = dev_result->target_lun;
                                break;
                        }
                        case DEV_MATCH_PERIPH:
                        {
                                struct periph_match_result* periph_result;
                                
                                periph_result = &ccb.cdm.matches[i].result.periph_result;
                                
                                if(skip_device != 0) break;
                                
                                if(need_close==1) {
                                        snprintf(Dev->device, sizeof(Dev->device), "%s%d*",
                                                periph_result->periph_name,
                                                periph_result->unit_number);
                                        need_close = 0;
                                }
                                else if(need_close==0) {
                                        snprintf(Dev->pass_device, sizeof(Dev->pass_device), "%s%d",
                                                periph_result->periph_name,
                                                periph_result->unit_number);
                                        need_close++;
                                        break;
                                }
                                else {
                                        need_close = 0;
                                }
                                PrevDev = Dev;
                                Dev = _AllocNewDevice();
                                break;
                        }
                        }
                }
        } while (ccb.ccb_h.status == CAM_REQ_CMP
             && ccb.cdm.status == CAM_DEV_MATCH_MORE);

        /* Remove last one (ugly coding) */
        Devices = PrevDev;
        delete Dev;
end_loop:
        close(fd);
#else /* !CAM */
        /*
         * FreeBSD 2.x SCSI management is quiet different and 
         * unfortunatly not flexible as CAM library in FreeBSD 3.x...
         * I only scan for the first bus, LUN 0, and the 
         * first 8 devices only.
         */
        u_char* inq_buf;
        scsireq_t* scsireq;
        struct scsi_addr scsi;
        int ssc_fd;
        
        if((ssc_fd=open("/dev/ssc", O_RDWR))==-1) {
                fprintf(stderr, "Cannot open SCSI manager: /dev/ssc\n");
                SCSIReset();
                return;
        }       
        
        inq_buf = (u_char*)malloc(96);
        if(inq_buf==NULL) {
                perror("malloc failed");
                SCSIReset();
                return;
        }
        
        scsireq = scsireq_build((scsireq_t*)dev->dev_ptr,
                                96, inq_buf, SCCMD_READ,
                                "12 0 0 0 v 0", 96);
        
        addr.scbus = 0;
        addr.lun = 0;

        for(int n=0;n<8;n++) {
                addr.target = n;
                
                if(ioctl(ssc_fd, SCIOCADDR, &addr) != -1) {
                        Dev = _AllocNewDevice();
                        Dev->controller = addr.scbus;
                        Dev->lun = addr.lun;
                        Dev->unit = addr.target;

                        struct scsi_devinfo devInfo;
                        devInfo.addr = addr;
                        if(ioctl(ssc_fd, SCIOCGETDEVINFO, &devInfo) != -1) {
                                strncpy(Dev->device, devInfo.devname, sizeof(Dev->device));
                        }
                        strncpy(Dev->controller_name, "FreeBSD 2.x SCSI Manager", sizeof(Dev->controller_name));
                        if(scsireq_enter(ssc_fd, scsireq)!=-1) {
                                Dev->vendor[sizeof(Dev->vendor)-1] = 0;
                                Dev->product[sizeof(Dev->product)-1] = 0;
                                Dev->revision[sizeof(Dev->revision)-1] = 0;
                                
                                scsireq_decode(scsireq, "s8 c8 c16 c4",
                                        Dev->vendor, Dev->product, Dev->revision);
                        }                       
                }
        }
        free(inq_buf);
        close(ssc_fd);
#endif /* !CAM */
        _Build_SCSI_Controller();

        // Print out the periph with ID:LUNs
        fprintf(stderr, "Device                            RealID FkdID\n");
        fprintf(stderr, "----------------------------------------------\n");
                      // 012345678901234567890123456789012 0:0:0    0/0
        dev = Devices;
        while(dev) {
                char tmp[40];
                snprintf(tmp, sizeof(tmp), "%s %s %s",
                        dev->vendor,
                        dev->product,
                        dev->revision);
                fprintf(stderr, "%-33s %d:%d:%d    %d/%d\n",
                        tmp, dev->controller, dev->unit, dev->lun,
                        dev->faked_unit, dev->lun);
                dev = dev->next;
        }

no_scsi:
        // Reset SCSI bus
        SCSIReset();
}


/*
 *  Deinitialization
 */

void SCSIExit(void)
{
        SCSIDevice* aux;
        while(Devices) {
                aux = Devices->next;
                if(Devices->dev_ptr!=NULL) {
#ifdef CAM
                        cam_close_device((struct cam_device*)Devices->dev_ptr);
#else /* !CAM */
                        free(Devices->dev_ptr); // Is this right?
                        close(Devices->dev_fd); // And this one?
#endif /* !CAM */
                }
                delete Devices;
                Devices = aux;
        }
        nDevices = 0;
}

int main()
{
        SCSIInit();
        SCSIExit();
        return 0;
}
Revision:	1.5
Committed:	2004-01-12T15:54:44Z (20 years, 8 months ago) by cebix
Branch:	MAIN
CVS Tags:	nigel-build-16, nigel-build-15
Changes since 1.4:	+1 -1 lines
Log Message:	Happy New Year!
#	User	Rev	Content
1	cebix	1.1	/*
2			* scsidump.cpp - SCSI Dump (to see FreeBSD remappings)
3			* Compile as (CAM version): gcc -I/sys -DCAM -o scsidump scsidump.cpp -lcam
4			* (old SCSI version): gcc -o scsidump scsidump.cpp -lscsi
5			* Copyright (C) 1999 Orlando Bassotto
6			*
7	cebix	1.5	* Basilisk II (C) 1997-2004 Christian Bauer
8	cebix	1.1	*
9			* This program is free software; you can redistribute it and/or modify
10			* it under the terms of the GNU General Public License as published by
11			* the Free Software Foundation; either version 2 of the License, or
12			* (at your option) any later version.
13			*
14			* This program is distributed in the hope that it will be useful,
15			* but WITHOUT ANY WARRANTY; without even the implied warranty of
16			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17			* GNU General Public License for more details.
18			*
19			* You should have received a copy of the GNU General Public License
20			* along with this program; if not, write to the Free Software
21			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22			*
23			* History:
24			* 29-Jun-1999 Started
25			* 05-Jul-1999 Changed from array to queue removing the limit of 8
26			* devices.
27			* Implemented old SCSI manager for FreeBSD 2.x.
28			* (Note: This implementation have been never tested;
29			* I don't own anymore a machine with FreeBSD 2.x,
30			* so if something goes wrong, please mail me at
31			* future@mediabit.net).
32			*/
33
34			#include <sys/ioctl.h>
35			#include <sys/types.h>
36			#include <stdio.h>
37			#include <stdlib.h>
38			#include <string.h>
39			#include <unistd.h>
40			#include <fcntl.h>
41			#include <ctype.h>
42			#include <err.h>
43
44			#ifdef CAM
45			#include <cam/cam.h>
46			#include <cam/cam_debug.h>
47			#include <cam/cam_ccb.h>
48			#include <cam/scsi/scsi_all.h>
49			#include <cam/scsi/scsi_da.h>
50			#include <cam/scsi/scsi_pass.h>
51			#include <cam/scsi/scsi_message.h>
52			#include <camlib.h>
53			#else /* !CAM */
54			#include <sys/scsiio.h>
55			#include <scsi.h>
56			#endif /* !CAM */
57
58			#undef u_int8_t
59			#define u_int8_t unsigned char
60
61			typedef struct _SCSIDevice {
62			int controller; // SCSI Controller
63			int controller_bus; // SCSI Controller Bus
64			char controller_name[33]; // SCSI Controller name
65			int mac_unit; // Macintosh SCSI ID (remapped)
66			int faked_controller; // "Faked" SCSI Controller (Always 0)
67			int faked_unit; // "Faked" SCSI ID
68			int unit; // Real SCSI ID
69			int lun; // Real SCSI LUN
70			u_int8_t vendor[16]; // SCSI Vendor
71			u_int8_t product[48]; // SCSI Product
72			u_int8_t revision[16]; // SCSI Revision
73			char device[33]; // SCSI Device
74			#ifdef CAM
75			char pass_device[33]; // SCSI Pass Device
76			#else /* !CAM */
77			int dev_fd; // Device File Descriptor
78			#endif /* !CAM */
79			void* dev_ptr; // Pointer to CAM/SCSI structure
80			bool enabled; // Device enabled ?
81			struct _SCSIDevice* next; // Pointer to the next device
82			} SCSIDevice;
83
84			static int nDevices = 0;
85			static SCSIDevice* Devices = NULL;
86
87			inline static SCSIDevice* _GetSCSIDeviceByID(int id)
88			{
89			SCSIDevice* aux = Devices;
90			while(aux) {
91			if(aux->faked_unit==id) {
92			return aux;
93			}
94			aux = aux->next;
95			}
96			return NULL;
97			}
98
99			inline static SCSIDevice* _GetSCSIDeviceByIDLUN(int id, int lun)
100			{
101			SCSIDevice* aux = Devices;
102			while(aux) {
103			if(aux->faked_unit==id&&aux->lun==lun) {
104			return aux;
105			}
106			aux = aux->next;
107			}
108			return NULL;
109			}
110
111			inline static SCSIDevice* _GetSCSIDeviceByMacID(int id)
112			{
113			SCSIDevice* aux = Devices;
114			while(aux) {
115			if(aux->mac_unit==id) {
116			return aux;
117			}
118			aux = aux->next;
119			}
120			return NULL;
121			}
122
123			inline static SCSIDevice* _GetSCSIDeviceByMacIDLUN(int id, int lun)
124			{
125			SCSIDevice* aux = Devices;
126			while(aux) {
127			if(aux->mac_unit==id&&aux->lun==lun) {
128			return aux;
129			}
130			aux = aux->next;
131			}
132			return NULL;
133			}
134
135			inline static SCSIDevice* _AllocNewDevice()
136			{
137			SCSIDevice* aux;
138
139			aux = new SCSIDevice;
140			if(aux==NULL) return NULL;
141			memset(aux, 0, sizeof(SCSIDevice));
142			aux->next = Devices;
143			Devices = aux;
144			return aux;
145			}
146
147			/*
148			* _Build_SCSI_Controller()
149			*
150			* This function builds a virtual SCSI Controller (Controller=0)
151			* where keeps all the devices found, this is due the fact
152			* I have two SCSI controllers in my PC. :-)
153			* Use FreeBSD-SCSIDump in contrib/ to see how is remapped your
154			* SCSI device (only if you have more than one controller,
155			* that's for sure :-).
156			*/
157
158			#define GET_FREE_ID(id) \
159			{ \
160			for(int x=0;x<32;x++) { \
161			if(!(busyIDs&(1<<(x+1)))) { \
162			id = x; \
163			break; \
164			} \
165			} \
166			}
167
168			static void _Build_SCSI_Controller()
169			{
170			unsigned int id = 0;
171			unsigned long long busyIDs = 0x0ll;
172			SCSIDevice* aux, * dev;
173
174			// What IDs are busy?
175			dev = Devices;
176			while(dev) {
177			dev->enabled = false;
178			dev->faked_controller = 0;
179			dev->faked_unit = dev->unit;
180			busyIDs \|= (1 << (dev->unit+1));
181			dev = dev->next;
182			}
183
184			// Find out the duplicate IDs and change them
185			dev = Devices, aux = NULL;
186			while(dev) {
187			aux = dev;
188			while(aux) {
189			SCSIDevice* dev1, * dev2;
190
191			dev1 = dev, dev2 = aux;
192
193			if(dev1->controller!=dev2->controller&&
194			dev1->unit==dev2->unit) {
195			int free_id;
196			GET_FREE_ID(free_id);
197			busyIDs \|= (1<<(free_id+1));
198			dev1->faked_unit = free_id;
199			}
200			aux = aux->next;
201			}
202			dev = dev->next;
203			}
204
205			// Now reorder the queue
206			dev = Devices;
207			while(dev) {
208			aux = dev;
209			while(aux) {
210			SCSIDevice* dev1, * dev2;
211
212			dev1 = dev, dev2 = aux;
213			/*
214			if(dev1->faked_unit>dev2->faked_unit) {
215			SCSIDevice tmp;
216
217			memcpy(&tmp, dev1, sizeof(SCSIDevice));
218			memcpy(dev1, dev2, sizeof(SCSIDevice));
219			memcpy(dev2, &tmp, sizeof(SCSIDevice));
220			}
221			*/
222			aux = aux->next;
223			}
224			dev = dev->next;
225			}
226			}
227
228			#define SCSIReset()
229
230			/*
231			* Initialization
232			*/
233
234			void SCSIInit(void)
235			{
236			// Find the SCSI hosts in the system
237			// Filling out the SCSIDevices queue.
238			// Stolen from camcontrol.c
239			int bufsize, fd;
240			int need_close = 0;
241			int error = 0;
242			int skip_device = 0;
243			SCSIDevice* Dev, * dev, * PrevDev = NULL;
244
245			nDevices = 0;
246
247			#ifdef CAM
248			union ccb ccb;
249
250			if ((fd = open(XPT_DEVICE, O_RDWR)) == -1) {
251			fprintf(stderr, "Cannot open CAM device: %s\n", XPT_DEVICE);
252			goto no_scsi;
253			}
254
255			memset(&(&ccb.ccb_h)[1], 0, sizeof(struct ccb_dev_match)-sizeof(struct ccb_hdr));
256			ccb.ccb_h.func_code = XPT_DEV_MATCH;
257			bufsize = sizeof(struct dev_match_result) * 100;
258			ccb.cdm.match_buf_len = bufsize;
259			ccb.cdm.matches = (struct dev_match_result *)malloc(bufsize);
260			ccb.cdm.num_matches = 0;
261
262			ccb.cdm.num_patterns = 0;
263			ccb.cdm.pattern_buf_len = 0;
264
265			do {
266			Dev = _AllocNewDevice();
267			if(ioctl(fd, CAMIOCOMMAND, &ccb)==-1) {
268			fprintf(stderr, "Error sending CAMIOCOMMAND ioctl\n");
269			return;
270			}
271
272			if((ccb.ccb_h.status != CAM_REQ_CMP)
273			\|\| ((ccb.cdm.status != CAM_DEV_MATCH_LAST)
274			&& (ccb.cdm.status != CAM_DEV_MATCH_MORE))) {
275			fprintf(stderr, "Got CAM error %#x, CDM error %d\n",
276			ccb.ccb_h.status, ccb.cdm.status);
277			return;
278			}
279
280			char current_controller_name[33];
281			int current_controller = -1;
282			for(int i=0;i<ccb.cdm.num_matches;i++) {
283			switch(ccb.cdm.matches[i].type) {
284			case DEV_MATCH_BUS:
285			{
286			struct bus_match_result* bus_result;
287
288			bus_result = &ccb.cdm.matches[i].result.bus_result;
289
290			if(bus_result->path_id==-1) break;
291			Dev->controller = bus_result->path_id;
292			snprintf(Dev->controller_name, sizeof(Dev->controller_name), "%s%d",
293			bus_result->dev_name,
294			bus_result->unit_number);
295			strncpy(current_controller_name, Dev->controller_name, sizeof(current_controller_name));
296			current_controller = Dev->controller;
297			Dev->controller_bus = bus_result->bus_id;
298			break;
299			}
300			case DEV_MATCH_DEVICE:
301			{
302			struct device_match_result* dev_result;
303			char tmpstr[256];
304
305			dev_result = &ccb.cdm.matches[i].result.device_result;
306			if(current_controller==-1\|\|dev_result->target_id==-1) {
307			skip_device = 1;
308			break;
309			}
310			else skip_device = 0;
311
312			cam_strvis(Dev->vendor, (u_int8_t*)dev_result->inq_data.vendor,
313			sizeof(dev_result->inq_data.vendor),
314			sizeof(Dev->vendor));
315			cam_strvis(Dev->product, (u_int8_t*)dev_result->inq_data.product,
316			sizeof(dev_result->inq_data.product),
317			sizeof(Dev->product));
318			cam_strvis(Dev->revision, (u_int8_t*)dev_result->inq_data.revision,
319			sizeof(dev_result->inq_data.revision),
320			sizeof(Dev->revision));
321			strncpy(Dev->controller_name, current_controller_name, sizeof(Dev->controller_name));
322			Dev->controller = current_controller;
323			Dev->unit = dev_result->target_id;
324			Dev->lun = dev_result->target_lun;
325			break;
326			}
327			case DEV_MATCH_PERIPH:
328			{
329			struct periph_match_result* periph_result;
330
331			periph_result = &ccb.cdm.matches[i].result.periph_result;
332
333			if(skip_device != 0) break;
334
335			if(need_close==1) {
336			snprintf(Dev->device, sizeof(Dev->device), "%s%d*",
337			periph_result->periph_name,
338			periph_result->unit_number);
339			need_close = 0;
340			}
341			else if(need_close==0) {
342			snprintf(Dev->pass_device, sizeof(Dev->pass_device), "%s%d",
343			periph_result->periph_name,
344			periph_result->unit_number);
345			need_close++;
346			break;
347			}
348			else {
349			need_close = 0;
350			}
351			PrevDev = Dev;
352			Dev = _AllocNewDevice();
353			break;
354			}
355			}
356			}
357			} while (ccb.ccb_h.status == CAM_REQ_CMP
358			&& ccb.cdm.status == CAM_DEV_MATCH_MORE);
359
360			/* Remove last one (ugly coding) */
361			Devices = PrevDev;
362			delete Dev;
363			end_loop:
364			close(fd);
365			#else /* !CAM */
366			/*
367			* FreeBSD 2.x SCSI management is quiet different and
368			* unfortunatly not flexible as CAM library in FreeBSD 3.x...
369			* I only scan for the first bus, LUN 0, and the
370			* first 8 devices only.
371			*/
372			u_char* inq_buf;
373			scsireq_t* scsireq;
374			struct scsi_addr scsi;
375			int ssc_fd;
376
377			if((ssc_fd=open("/dev/ssc", O_RDWR))==-1) {
378			fprintf(stderr, "Cannot open SCSI manager: /dev/ssc\n");
379			SCSIReset();
380			return;
381			}
382
383			inq_buf = (u_char*)malloc(96);
384			if(inq_buf==NULL) {
385			perror("malloc failed");
386			SCSIReset();
387			return;
388			}
389
390			scsireq = scsireq_build((scsireq_t*)dev->dev_ptr,
391			96, inq_buf, SCCMD_READ,
392			"12 0 0 0 v 0", 96);
393
394			addr.scbus = 0;
395			addr.lun = 0;
396
397			for(int n=0;n<8;n++) {
398			addr.target = n;
399
400			if(ioctl(ssc_fd, SCIOCADDR, &addr) != -1) {
401			Dev = _AllocNewDevice();
402			Dev->controller = addr.scbus;
403			Dev->lun = addr.lun;
404			Dev->unit = addr.target;
405
406			struct scsi_devinfo devInfo;
407			devInfo.addr = addr;
408			if(ioctl(ssc_fd, SCIOCGETDEVINFO, &devInfo) != -1) {
409			strncpy(Dev->device, devInfo.devname, sizeof(Dev->device));
410			}
411			strncpy(Dev->controller_name, "FreeBSD 2.x SCSI Manager", sizeof(Dev->controller_name));
412			if(scsireq_enter(ssc_fd, scsireq)!=-1) {
413			Dev->vendor[sizeof(Dev->vendor)-1] = 0;
414			Dev->product[sizeof(Dev->product)-1] = 0;
415			Dev->revision[sizeof(Dev->revision)-1] = 0;
416
417			scsireq_decode(scsireq, "s8 c8 c16 c4",
418			Dev->vendor, Dev->product, Dev->revision);
419			}
420			}
421			}
422			free(inq_buf);
423			close(ssc_fd);
424			#endif /* !CAM */
425			_Build_SCSI_Controller();
426
427			// Print out the periph with ID:LUNs
428			fprintf(stderr, "Device RealID FkdID\n");
429			fprintf(stderr, "----------------------------------------------\n");
430			// 012345678901234567890123456789012 0:0:0 0/0
431			dev = Devices;
432			while(dev) {
433			char tmp[40];
434			snprintf(tmp, sizeof(tmp), "%s %s %s",
435			dev->vendor,
436			dev->product,
437			dev->revision);
438			fprintf(stderr, "%-33s %d:%d:%d %d/%d\n",
439			tmp, dev->controller, dev->unit, dev->lun,
440			dev->faked_unit, dev->lun);
441			dev = dev->next;
442			}
443
444			no_scsi:
445			// Reset SCSI bus
446			SCSIReset();
447			}
448
449
450			/*
451			* Deinitialization
452			*/
453
454			void SCSIExit(void)
455			{
456			SCSIDevice* aux;
457			while(Devices) {
458			aux = Devices->next;
459			if(Devices->dev_ptr!=NULL) {
460			#ifdef CAM
461			cam_close_device((struct cam_device*)Devices->dev_ptr);
462			#else /* !CAM */
463			free(Devices->dev_ptr); // Is this right?
464			close(Devices->dev_fd); // And this one?
465			#endif /* !CAM */
466			}
467			delete Devices;
468			Devices = aux;
469			}
470			nDevices = 0;
471			}
472
473			int main()
474			{
475			SCSIInit();
476			SCSIExit();
477			return 0;
478			}