probe_nlist.c

操作系统SunOS 4.1.3版本的源码

      if (kvm_read(mem, (u_long)nl[nlvar].n_value, (char *)&sunrom,
        sizeof(struct sunromvec *)) != sizeof(struct sunromvec *))
        send_message(1, FATAL, "sunromvec Failed: %s", errmsg(errno));

      if (kvm_read(mem, (u_long)sunrom, (char *)&romvec,
        sizeof(struct sunromvec)) != sizeof(struct sunromvec)) {
        send_message(1, FATAL, "romvec Failed: %s", errmsg(errno));
      }  

      if (romvec.op_romvec_version > 0) /* Calvin uses OpenBootProm V2.0 */
      {  
        kvm_read(mem, (u_long)nl[NL_PHYSMEMORY].n_value, (char *)&pmlist,
          sizeof(struct memlist *));
      }  
      else {
        pm = romvec.v_physmemory;
        kvm_read(mem, (u_long)pm, (char *)&pmlist, sizeof(struct memlist *));
      }  
 
      while (pmlist) {    
        kvm_read(mem,(u_long)pmlist,(char *)&pmem, sizeof(struct memlist));
        physmem += pmem.size;
        pmlist = pmem.next;
      }
      physmem = physmem / 1024; /* size in KB */
      send_message (0, VERBOSE, "physmem = %dK", physmem);

  }  
  else {
    kvm_read(mem, nl[NL_PHYSMEM].n_value, (char *)&physmem, sizeof(physmem));
    physmem = (getpagesize() * physmem) / 1024; /* size in KB */
    send_message (0, VERBOSE, "physmem = %dK", physmem);
  }
    TRACE_OUT
    return(physmem);
}

#ifdef sun386

#define ctok(x) ((ctob(x)) >> 10)
static int
get_vmem(mem)
    int mem;
{
    struct anoninfo ai;
    int vmem;
 
    func_name = "get_vmem";
    TRACE_IN
    kvm_read(mem, nl[NL_SANON].n_value, (char *)&ai, sizeof(struct
anoninfo));
    vmem = ctok(ai.ani_max);
    send_message (0, VERBOSE, "vmem = %dK", vmem);
    TRACE_OUT
    return(vmem);
}

#else	sun386

static int
get_vmem(mem)
    int mem;
{
    struct anoninfo ai;
    int vmem;

    func_name = "get_vmem";
    TRACE_IN
    kvm_read(mem, nl[NL_ANONINFO].n_value, (char *)&ai,sizeof(struct anoninfo));
    vmem = (ai.ani_max*getpagesize()) >> 10;	/* in the unit of K bytes */
    send_message (0, VERBOSE, "vmem = %dK", vmem);
    TRACE_OUT
    return(vmem);
}

#endif	sun386

#ifndef SVR4
/*
 * from mark opperman's probe program:
 */
static void
get_scsi_names(mem)
    int mem;
{
    char *devname;
    int i;

    func_name = "get_scsi_names";
    TRACE_IN
    if (nl[NL_SCSINTYPE].n_value) {
        kvm_read(mem, nl[NL_SCSINTYPE].n_value, (char *)&scsi_ntype, 
	    sizeof(scsi_ntype));
        scsi_unit_subr = (struct scsi_unit_subr *) 
	    calloc((unsigned) scsi_ntype, 
	    (unsigned) sizeof(struct scsi_unit_subr));
        if (scsi_unit_subr == NULL) {
            send_message(1, FATAL,"calloc scsi_unit_subr table: %s", 
		errmsg(errno)); 
        }
        kvm_read(mem, nl[NL_SCSIUNITSUBR].n_value, (char *)scsi_unit_subr,
            (u_int) (scsi_ntype * sizeof(struct scsi_unit_subr)));
	send_message (0, DEBUG, "scsi_ntype = %d", scsi_ntype);
        for (i=0; i < scsi_ntype; i++) {
            devname = malloc((unsigned)MAX_SCSI_DEV_NAME_LENGTH);
            if (devname == NULL) {
                send_message(1, FATAL, "malloc devname: %s", errmsg(errno)); 
	    }
            kvm_read(mem, (u_long) scsi_unit_subr[i].ss_devname, devname,
                MAX_SCSI_DEV_NAME_LENGTH);
            scsi_unit_subr[i].ss_devname = devname;
	    send_message (0, DEBUG, "scsi_unit_subr[%d].ss_devname = %s",
			i, devname);
        }
    }    
    TRACE_OUT
}

/*
 * from mark opperman's probe and Guy Harris's devs programs:
 */
static void
get_devices(mem)
    int mem;
{
    struct mb_device mb_device;
    u_long dev_addr;
    int ndev;

    func_name = "get_devices";
    TRACE_IN
    for (dev_addr = nl[NL_MBDINIT].n_value, ndev=0; ;ndev++) {
        kvm_read(mem, dev_addr, (caddr_t) &mb_device, sizeof(struct mb_device));
        if (mb_device.md_driver == NULL)
            break;
        dev_addr += sizeof(struct mb_device);
    }
    mbdinit = (struct mb_device *) calloc((unsigned) ndev+1, 
	(unsigned) sizeof(struct mb_device));
    if (mbdinit == NULL) {
        send_message(1, FATAL, "calloc mbdinit table: %s", errmsg(errno)); 
    }
    kvm_read(mem, nl[NL_MBDINIT].n_value, (caddr_t) mbdinit,
        (u_int) (ndev * sizeof(struct mb_device)));
    mbdinit[ndev].md_driver = (struct mb_driver *) NULL;
    send_message (0, VERBOSE, "ndev = %d", ndev);
    TRACE_OUT
}
 
/*
 * from mark opperman's probe and Guy Harris's devs programs:
 */
static void
get_drivers(mem)
    int mem;
{
    struct mb_device *md;
    struct mb_driver *mdr;
    u_long drv_addr;
    char name[16];
 
    func_name = "get_drivers";
    TRACE_IN
    for (md=mbdinit; md->md_driver != NULL; md++ ) {
        mdr = (struct mb_driver *) malloc((unsigned) sizeof(struct mb_driver));
	if (mdr == NULL) {
            send_message(1, FATAL, "malloc mdr: %s", errmsg(errno)); 
	}
        drv_addr = (unsigned long) md->md_driver;
        kvm_read(mem, drv_addr, (caddr_t) mdr, sizeof(struct mb_driver));
        md->md_driver = mdr;
        if (mdr->mdr_dname != NULL) {
            kvm_read(mem, (u_long) mdr->mdr_dname, (char *) name, sizeof(name));
            if (((strcmp(name, SD) == 0) || (strcmp(name, SF) == 0) ||
                (strcmp(name, ST) == 0) || (strcmp(name, CDROM) == 0))
		&& scsi_unit_subr)
                mdr->mdr_dname =
                    scsi_unit_subr[TYPE(md->md_flags)].ss_devname;
            else {
                mdr->mdr_dname = malloc((unsigned) strlen(name)+1);
		if (mdr->mdr_dname == NULL) {
            	    send_message(1,FATAL,"malloc mdr_dname: %s", errmsg(errno));
		}
                (void) strcpy(mdr->mdr_dname, name);
            }
        }
        if (mdr->mdr_cname != NULL) {
            kvm_read(mem, (u_long) mdr->mdr_cname, (char *) name, sizeof(name));
	    mdr->mdr_cname = malloc((unsigned) strlen(name)+1);
	    if (mdr->mdr_cname == NULL) {
            	send_message(1, FATAL, "malloc mdr_cname: %s", errmsg(errno));
	    }
            (void) strcpy(mdr->mdr_cname, name);
        }
    }
    TRACE_OUT
}
 
#ifdef sun3 
/*
 * from Locore.c:
 * 0 = no 81, 1 = 81 enable, -1 = 81 disabled
 */
static int
get_fpp(mem)
    int mem;
{
    short fppstate;
 
    func_name = "get_fpp";
    TRACE_IN
    kvm_read(mem, nl[FPPSTATE].n_value, &fppstate, sizeof(fppstate));
    if (fppstate == -1)
	send_message(0, INFO, "mc68881 disabled");
    TRACE_OUT
    return((int)fppstate);
}

/*
 * from fpa.c:
 * Fpa_exist == 0 if FPA does not exist.  Fpa_exist == 1 if there is a
 * functioning FPA attached.  Fpa_exist == -1 if the FPA is disabled
 * due to FPA hardware problems.
 */
static int
get_fpa(mem)
    int mem;
{
    short fpa_exist;
 
    func_name = "get_fpa";
    TRACE_IN
    kvm_read(mem, nl[FPA_EXIST].n_value, &fpa_exist, sizeof(fpa_exist));
    send_message (0, DEBUG, "fpa_exist = %d", fpa_exist);
    if (fpa_exist == -1) 
        send_message(0, INFO, "FPA disabled");
    TRACE_OUT
    return((int)fpa_exist);
}

#endif

#endif SVR4
 
#ifdef sun4
/*
 * from Locore.c: flag for fpu existence
 *
 * get_fpu() returns:	 0 if fpu does not exist.
 *			-1 if fpu is disabled.
 *			 1 if functioning fpu exists.
 *			 2 if functioning fpu2 exists.
 *		
 * Currently (4/89), the Sunray/Stingray use the Cypress IU; their fsr
 * identify the rev number of the fpc and not the type of fpu.  The Sunrise/
 * Cobra machines use either the fpu or fpu2, as identified in their fsr.
 */
static int
get_fpu(mem)
    int mem;
{
    int			fpu_exists;
    int			fpu_type;	/* fpu or fpu2 */
    unsigned long	cputype;	/* Sunray/Stingray don't have fpu2 */
 
    func_name = "get_fpu";
    TRACE_IN
    kvm_read(mem, nl[FPUEXISTS].n_value, (char *)&fpu_exists,
						sizeof(fpu_exists));
    switch(fpu_exists) {
    case 1:
	cputype = sun_cpu();
	if ((cputype == CPU_SUN4_260) || (cputype == CPU_SUN4_110) ||
		(cputype == CPU_SUN4_890)) {
	    fpu_type = ((get_fsr() >> 17) & 0x3);  /* check for fpu or fpu2 */
	    if (fpu_type == FPU2_EXIST)
		fpu_exists = FPU2_EXIST;
	}
	break;
    case 0:
	break;
    case -1:
	send_message(0, INFO, "fpu disabled");
	break;
    }
    TRACE_OUT
    return(fpu_exists);
}

/*
 * get_fsr():  returns the contents of the fsr.
 */
get_fsr()
{
    asm("set	_fsr_temp, %l0"); /* set the address of the result holder */
    asm("st	%fsr, [%l0]");	  /* store the contents of FSR in fsr_temp */
#ifdef SVR4
    return(_fsr_temp);	  	  /* return the fsr to caller */
#else SVR4
    return(fsr_temp);	  	  /* return the fsr to caller */
#endif SVR4
}

/*
 * Function to get all other hardware devices exist on the system.
 * The dev_info structure in this routine is specific to Campus1 machine
 * only.
 */
void
get_c_devices(mem)
int	mem;
{
	struct dev_info *top;

    	func_name = "get_c_devices";
#ifndef SVR4
  	TRACE_IN
#endif SVR4
	kvm_read(mem,nl[NL_TOPDEVINFO].n_value,(char *)&top,
					sizeof(struct dev_info *));
	if (top) walk_devs(top,0,mem);
#ifndef SVR4
	TRACE_OUT
#endif SVR4
}


/*
 * Function recursively gets all devices from the dev_info tree and
 * puts into the mbdinfo array.
 */
walk_devs(dp,parent,mem)
struct dev_info *dp, *parent;
int	mem;
{

	func_name = "walk_devs";
#ifndef SVR4
	TRACE_IN
#endif SVR4
	kvm_read(mem,(u_long)dp,(char *)&mbdinfo[numdev].info,
					sizeof(struct dev_info));
	mbdinfo[numdev].info.devi_parent = parent;
	dp = &mbdinfo[numdev].info;
	get_devname(mbdinfo[numdev].name,dp->devi_name,mem);
	dp->devi_name = mbdinfo[numdev].name;
	numdev++;
	if (dp->devi_slaves)			/* next sibbling */
		walk_devs(dp->devi_slaves,dp,mem);
	if (dp->devi_next)			/* next child */
		walk_devs(dp->devi_next,parent,mem);
#ifndef SVR4
	TRACE_OUT
#endif SVR4
}


/*
 * Function gets the device name and stored in string buf.
 */
get_devname(buf,dname,mem)
char *buf, *dname;
int  mem;
{
	int k;

  	func_name = "get_devname";
#ifndef SVR4
	TRACE_IN
#endif SVR4
	if (dname)
	{
		for (k = 0; k < NAMELEN; k++)
		{
			kvm_read(mem,(u_long)dname++,buf,1);
			if (!*buf) break;
			buf++;
		}
	}
	*buf = '\0';
#ifndef SVR4
	TRACE_OUT
#endif SVR4
}

#endif  sun4

#ifdef sun386
weitek_probe()
{
        asm("movl    0xffc0c400, %eax");
}
 
i387_probe()
{
        asm("finit");
}
 
#define VGA_BASE                0xA00000    /* board base addr */
#define VGA_REG_OFFSET          0x1c0000
 
int sunvga_probe()
{
    u_short *vga_capture_reg_base;
    register bit_bucket;

    func_name = "sunvga_probe";
    TRACE_IN
    vga_capture_reg_base = (u_short *) ((u_char *)VGA_BASE +
VGA_REG_OFFSET);

    *vga_capture_reg_base = 0x08;  /* benign allows cpu access to mem */
    bit_bucket = *vga_capture_reg_base;
    TRACE_OUT
}

bus()
{
        longjmp(error_buf, 1);
}
segv()
{
        longjmp(error_buf, 2);
}

#endif