Attachment #202055 for bug #282455

View | Details | Raw Unified | Return to bug 282455 | Differences between
Collapse All | Expand All




++ raidutils-0.0.6/lib/engmsg.c

     //
     // Send off the message to the engine
     //
     if((i = msgsnd(msqID,(struct msgbuf *)&HdrBuff,MsgDataSize,0)) != -1)
      {
        //
        // Let's set up a little loop here receiving messages in case
++ raidutils-0.0.6/lib/engcalls.cpp


  /* The Attach Failed, So DeAllocate The Shared Memory */

        if((long)SharedMemoryPtr == -1)
          {
            shmctl(BufferID,IPC_RMID,&shm_buff);
            SharedMemoryPtr = NULL;
++ raidutils-0.0.6/raideng/eng_unix.cpp


  /* Make Sure That We Could Attach */

            if((long)toEng_P != -1)
              {
                 fromEng_P = toEng_P + HdrBuff.FromEngBuffOffset;


#else
void DisplayHelp(void)
  {
    printf("The Parameters For This Program Are :\n");
    printf(
"  /VERBOSE            :  Display All Connection And Message Information\n");
    printf(
++ raidutils-0.0.6/raideng/unreslvd.cpp

   char *__nw__FUi(int size)
   {
        char *p;
	p = (char *)malloc((size_t)size);
        return(p);
   }

++ raidutils-0.0.6/raideng/i2odep.h

# define _F_set12bit4(w,x,y,z,u) ((w)->z = (u))
# define _F_get16bit(w,x,y,z)    ((U16)((w)->z))
# define _F_set16bit(w,x,y,z,u)  ((w)->z = (u))
#elif (defined(_DPT_BIG_ENDIAN) || defined(sparc))
/* First 12 bits */
# define _F_getTID(w,x,y)     getL12bit(w,x,0)
# define _F_setTID(w,x,y,z)   setL12bit(w,x,0,z)
++ raidutils-0.0.6/raideng/connect.hpp


// Constructor/Destructor.............................

			dptSCSIcon_C();

// Message Handlers...................................

++ raidutils-0.0.6/raideng/raid.h


// Constructor/Destructor.............................

			raidDef_S();

};
#endif  // c++
++ raidutils-0.0.6/raideng/osd_unix.cpp

#define TO_LOGGER_BUFFER_SIZE    0x1000
#define FROM_LOGGER_BUFFER_SIZE  0x10000

/* Definitions - Device names -----------------------------------------------*/

char *DEV_CTL = "/dev/i2octl";	// formerly /dev/i2o/ctl

/* Function Prototypes ------------------------------------------------------*/

DPT_RTN_T osdIOrequest(uSHORT ioMethod);


   if(ioMethod==DPT_IO_PASS_THRU)
     {
       // make sure the device entry represents an active device and not
       // just a device file that was probed without actually finding a
       // device, so we don't wait 20 seconds trying to connect to 
       // it...
       if(DefaultHbaDev->Flags == 0 )
         {
           FormatTimeString(TimeString,time(0));
           printf("\nosdIDrequest   : %s Fatal error, DefaultHbaDev does not point to an active controller.\n", TimeString);
           fflush(stdout);
         }
       else {

              /* Try To Open The First Adapter Device */

                     for(Index = 0; Index < 20; ++Index)
               {
                 FileID = open(DefaultHbaDev->NodeName,O_RDONLY);
                 if((FileID == -1)&&(errno == ENOENT))
                  {
                    sleep(1);
                  }
                  else {
                         break;
                  }
               }

#ifdef _SINIX_ADDON
              if (DemoMode)
                  FileID = 99;
#endif
              if(FileID != -1)
                {
                  retVal = MSG_RTN_COMPLETED;
                  close(FileID);
                }
              else printf("\nosdIOrequest : File %s Could Not Be Opened",
                            DefaultHbaDev->NodeName);
            }
     }
   if(Verbose)
        printf("\nosdIOrequest   : Return = %x",retVal);

   retVal = MSG_RTN_COMPLETED;
   NumHBAs = BuildNodeNameList();

   // If there are no HBAs found, abort with an explict error message.
   if(NumHBAs == 0)
     {
     FormatTimeString(TimeString,time(0));
     printf("\nosdOpenEngine  : %s Fatal error, no active controller device files found.\n", TimeString);
     retVal = MSG_RTN_FAILED;
     fflush(stdout);
     }

   if(Verbose)
     {
        FormatTimeString(TimeString,time(0));

#elif defined (_DPT_SCO) || defined (SNI_MIPS) || defined(_DPT_SOLARIS) || defined(_DPT_BSDI) || defined(_DPT_FREE_BSD) || defined(_DPT_LINUX)

#if defined(_DPT_LINUX_I2O)
		     if(strcmp(HbaDevs[HbaNum].NodeName, DEV_CTL))
                        i = ioctl(FileID,I2OUSRCMD,IoctlBuffer_P);
		     else {
                        struct i2o_cmd_passthru pt;

                       i = 0;
                }
#elif defined(_DPT_LINUX_I2O)
                if(strcmp(HbaDevs[Count].NodeName, DEV_CTL))
                   i = osdSendIoctl(&HbaDevs[Count],DPT_CTRLINFO,DataBuff,&pkt);
		else {
		   /*

       SysInfo_P->busType = SI_PCI_BUS;
       SysInfo_P->processorFamily = PROC_INTEL;
       buffer_size = sysinfo(SI_ARCHITECTURE, buffer_ptr, 0);
       buffer_ptr = (char *)malloc((size_t)buffer_size);
       status = sysinfo(SI_ARCHITECTURE, buffer_ptr, buffer_size);
       if (status != -1)
        {


  /* The Attach Failed, So DeAllocate The Shared Memory */

            if((long)SharedMemoryPtr == -1)
              {
                Rtnval = 1;
                shmctl(BufferID,IPC_RMID,&shm_buff);

        toLoggerTotalSize = toLoggerSize + sizeof(dptBuffer_S);
        fromLoggerTotalSize = fromEngSize + sizeof(dptBuffer_S);
        FromLoggerBuffOffset = toLoggerTotalSize;
        Ptr = (char *)malloc((size_t)(toLoggerTotalSize + fromLoggerTotalSize));
        if(Ptr != NULL)
          {
            *toLogger_P_P = Ptr;

 {
   void *Rtnval;

   Rtnval = (void *)malloc((size_t)size);
   if(Verbose)
     {
       FormatTimeString(TimeString,time(0));

   NumEntries = 0;

#  if (defined(_DPT_LINUX_I2O))
   uCHAR LinuxI2ODataBuff[MAX_I2O_CONTROLLERS];

   memset(&pkt, 0, sizeof(EATA_CP));
   HbaDevs[NumEntries].Flags = 0;
   strcpy(HbaDevs[NumEntries].NodeName, DEV_CTL);
   IoctlRtn = osdSendIoctl(&HbaDevs[NumEntries], I2OGETIOPS, LinuxI2ODataBuff, &pkt);
   if(!IoctlRtn) {
     // step through the returned data buffer and look for the 
     // non-zero entries, which indicate an active IOP.  For each
     // one we find, add a corresponding entry in HbaDevs.
     for(i = 0; i < MAX_I2O_CONTROLLERS; i ++) {
       if ( LinuxI2ODataBuff[i] != 0  ) 
        {
          if(NumEntries >= MAX_HAS)
           {
             FormatTimeString(TimeString,time(0));

             printf("\nBuildNodeNameList  : %s Warning: Found more than %d Linux I2O Controlers; ignoring those that won't fit in the HbaDevs array.",
                    TimeString, MAX_HAS);

             fflush(stdout);
             break;
            }
          if(Verbose)
            {
              FormatTimeString(TimeString,time(0));

              printf("\nBuildNodeNameList  : %s Found Linux I2O Controler, using %s device file for utility-relative controller number %d.",
                     TimeString, DEV_CTL, NumEntries);

              fflush(stdout);
            }

          HbaDevs[NumEntries].Flags = NODE_FILE_VALID_HBA_B | NODE_FILE_I2O_HBA_B;
          HbaDevs[NumEntries].IoAddress = UINTPTR_MAX;
          strcpy(HbaDevs[NumEntries].NodeName, DEV_CTL);

          ++NumEntries;
        }
       else {
              // for now, we'll assume that all the active IOP entries
              // are at the front of the returned buffer.  In order to
              // support "gaps", we'd need to record the IOP index in the
              // NodeFiles_S structure and use that instead of HbaNum when
              // we call the I2OPASSTHRU ioctl (or make sure that
              // everything that looks at HbaDevs can handle inactive
              // entries in the middle of the array).
              break;
       }
     } // for(i = 0; i < MAX_I2O_CONTROLLERS; i ++) 
   }
#  endif

++ raidutils-0.0.6/include/get_info.h

   #include    "device.hh"
   #include    "raid_dev.hh"

     // use PACK for things that should be packed;
     // PACK_A for things that you'd like packed by would give a
     // warning on anything except an ARM if actually packed; and
     // PACK_WAS if it used to be packed by this gave warnings
     // everywhere so now it isn't.

#undef PACK
#if (defined(__GNUC__))
# define PACK __attribute__ ((packed))

#define PACK
#endif

#ifdef __arm__
# define PACK_A PACK
#else
# define PACK_A
#endif

#define PACK_WAS

   uSHORT flags2;        // Supplemental flags word
   uSHORT hbaIndex; // HBA index # (slot #)
   uSHORT hbaFlags; // HBA flags - see bit definitions below
#if defined (_DPT_STRICT_ALIGN)
   uSHORT sniAdjust3;
#endif
   uLONG  magicNum  PACK;	// RAID magic #
   uLONG  hbaTag    PACK;	// Reserved for future expansion
   uLONG  flags3    PACK;	// Miscellaneous flags - see bit definitions above
   uSHORT busSpeed  PACK;	// Negotiated bus speed (in Mhz)
   uCHAR  p2Flags   PACK_WAS;	// Path 2 flags - see bit definitions above
   uCHAR  reserved4 PACK_WAS;	// Reserved for future expansion
   uLONG  availableCapacity PACK;	// Reserved for future expansion

   uCHAR  udmaModeSupported;// The maximum UDMA mode supported
   uCHAR  udmaModeSelected;	// The current operational UDMA mode
++ raidutils-0.0.6/include/osd_unix.h

#define DPT_EngineKey      0x02    /* Message Que and Type for engine         */
#define DPT_LoggerKey      0x03    /* Message Type For Logger                 */
#define DPT_CommEngineKey  0x04    /* Message Que Type Created                */

#define MSG_RECEIVE    0x40000000  /* Ored Into Logger PID For Return Msg     */

#define ENGMSG_ECHO        0x00    /* Turnarround Echo Engine Message         */


  /* Message Que Creation Flags */

#define MSG_URD            00400
#define MSG_UWR            00200
#define MSG_GRD            00040
#define MSG_GWR            00020
#define MSG_ORD            00004
#define MSG_OWR            00002
#define MSG_ALLRD          00444
#define MSG_ALLWR          00222

  /* Message Que Creation Flags */

#define SHM_URD            00400
#define SHM_UWR            00200
#define SHM_GRD            00040
#define SHM_GWR            00020
#define SHM_ORD            00004
#define SHM_OWR            00002
#define SHM_ALLRD          00444
#define SHM_ALLWR          00222


#define ExitEngOpenFail          10
#define ExitDuplicateEngine      11

#define ExitCommAllocFail        12
#define ExitDuplicateCommEng     13
#define ExitCommConnectFail      14


	uCHAR ConfigLength[4];       /* Len in bytes after this field.      */
	uCHAR EATAsignature[4];
	uCHAR EATAversion;
        uCHAR Flags1;
	uCHAR PadLength[2];
	uCHAR HBA[4];
	uCHAR CPlength[4];           /* Command Packet Length               */

        uCHAR Flags2;
	uCHAR Reserved0;             /* Reserved Field                       */
        uCHAR Flags3;
        uCHAR ScsiValues;
	uCHAR MaxLUN;                /* Maximun LUN Supported                */
        uCHAR Flags4;
	uCHAR RaidNum;               /* RAID HBA Number For Stripping        */
	uCHAR Reserved3;             /* Reserved Field                       */

/* Inform driver to reset adapter */
#define I2ORESETCMD	(('D'<<8)|78)

#else

  /* Unix Ioctl Command definitions */



        uCHAR     HbaTargetID;
        uCHAR     HbaLUN;

#endif  /* _DPT_AIX */

        uCHAR    cp_Flags1;          /* Command Flags                       */
	uCHAR    cp_Req_Len;         /* AutoRequestSense Data length.       */
	uCHAR    cp_Resv1[3];        /* Reserved Fields                     */
        uCHAR    cp_Flags2;
        uCHAR    cp_Flags3;
        uCHAR    cp_ScsiAddr;
	uCHAR    cp_msg0;            /* Identify and Disconnect Message.    */

	struct  dpt_sg SG_List[DPT_MAX_DMA_SEGS];
	union {
		char *b_scratch;
		struct scsi_cmd *b_ownerp;
	      } cc;
	paddr_t ccb_paddr;
	uSHORT IOAddress;

#else  /* _DPT_SOLARIS */

	uLONG     TimeOut ;
	uCHAR     HostStatus;
	uCHAR     TargetStatus;
	uCHAR     Retries;

#endif  /* _DPT_SOLARIS else */


	uCHAR    eataVersion;      /* EATA Version                    */
	uLONG    cpLength;         /* EATA Command Packet Length      */
	uLONG    spLength;         /* EATA Status Packet Length       */
	uCHAR    drqNum;           /* DRQ Index (0,5,6,7)             */
	uCHAR    flag1;            /* EATA Flags 1 (Byte 9)           */
	uCHAR    flag2;            /* EATA Flags 2 (Byte 30)          */



typedef struct {

	uINT     state;            /* Operational state            */
	uCHAR    id[4];            /* Host adapter SCSI id         */
	uINT     vect;             /* Interrupt vector number      */
	uLONG    base;             /* Base I/O address             */
	int      ha_max_jobs;      /* Max number of Active Jobs    */
        uLONG    ha_cacheParams;
	int      ha_nbus;          /* Number Of Busses on HBA      */

	uCHAR  eataVersion;      /* EATA Version                    */
	uLONG  cpLength;         /* EATA Command Packet Length      */
	uLONG  spLength;         /* EATA Status Packet Length       */
	uCHAR  drqNum;           /* DRQ Index (0,5,6,7)             */
	uCHAR  eataflag1;        /* EATA Flags 1 (Byte 9)           */
	uCHAR  eataflag2;        /* EATA Flags 2 (Byte 30)          */
	uCHAR  maxChannel;       /* Maximum Channel Number          */
	uCHAR  maxID;            /* Maximum Target ID               */
	uCHAR  maxLUN;           /* Maximum LUN                     */
	uCHAR  HbaBusType;       /* HBA Bus Type, EISA, PCI, etc    */
	uCHAR  RaidNum;          /* Host Adapter RAID Number        */

	       } HbaInfo;



/*
 * DPT Host Adapter config information structure - this structure contains
 * configuration information about an adapter.  It is imbedded into the
 * dpt_ctl structure.
 */


/*
 * DPT statistics structure definitions
 */
typedef struct IO_SIZE_STATS
{
  uLONG TotalIoCount;
  uLONG IoCountRead;


} IO_SIZE_STATS_T, *pIO_SIZE_STATS_T;

typedef struct STATS_DATA
{
  uLONG TotalIoCount;
  uLONG TotalUnCachedIoCount;
++ raidutils-0.0.6/include/mgr.hh

#define PACK
#endif

   dptCaddr_S	maxAddr PACK_A;	// Maximum physical address supported
   dptCaddr_S	minAddr PACK_A;	// Minimum physical address supported

// RAID manager information (Ignore if not a RAID manager)

++ raidutils-0.0.6/include/device.hh

 */

// Data unique to every engine device


// use PACK for things that should be packed;
// PACK_A for things that you'd like packed by would give a
// warning on anything except an ARM if actually packed; and
// PACK_WAS if it used to be packed by this gave warnings
// everywhere so now it isn't.

#undef PACK
#if (defined(__GNUC__))
# define PACK __attribute__ ((packed))

#define PACK
#endif

#ifdef __arm__
# define PACK_A PACK
#else
# define PACK_A
#endif

uSHORT		scsiOffset;	// 0=Async mode
				// Non-zero = SCSI offset
uSHORT		xfrSpeed;	// SCSI transfer speed
dptCcapacity_S	capacity PACK_A;	// Device capacity
dptCemuParam_S	emulation PACK_A;	// Emulated drive parameters
  // DPT specific name (ASCII string)
  // (Up to 8 valid chars + NULL terminator + 1)
uCHAR		dptName[DPT_NAME_SIZE+2];
++ raidutils-0.0.6/include/hba.hh

#define PACK
#endif

   dptIOaddr_U ioAddr PACK_A;             // EISA/ISA/PCI address
   uSHORT drvrRefNum;         // Number by which the driver ref-
					// erences this HBA
#if defined (_DPT_STRICT_ALIGN)
   uSHORT sniAdjust4;
#endif
   dptHBAid_U  id PACK_A;       // EISA = ID PAL bytes
					// ISA = Not used
					// PCI = vendor ID, product ID
   uSHORT drqNum;             // DRQ # (0,5,6,7,0xffff=invalid)

   uCHAR  raidID;        // Software selectable RAID ID #
   uCHAR  slotID;        // Slot specific RAID ID #

   dptChanInfo_S chanInfo[NUM_CHAN_INFO] PACK_A; // SCSI channel info (multi-channel boards)

   uCHAR  excludeStart;
   uCHAR  excludeEnd;
++ raidutils-0.0.6/include/linux/i2o-dev.h

/* How many controllers are we allowing */
#define MAX_I2O_CONTROLLERS	32

#include <linux/compiler.h>

#ifndef __KERNEL__

++ raidutils-0.0.6/raidutil/setscfg.hpp

{

	public:
		setscfg();
		virtual	~setscfg();

		Dpt_Error execute(String_List **output);
++ raidutils-0.0.6/raidutil/setcache.hpp

class SetCache:public Command
	{
	public:
		SetCache(
			SCSI_Addr_List	*addresses,		// a list of addresses
			int				on,				// Whether to enable or disable
			int				rw				// Read or write cacheing.
			);								// to delete raid tables on
		SetCache( const SetCache &new_SetCache );
		virtual	~SetCache();
		SetCache	&operator = ( SetCache &right );
++ raidutils-0.0.6/raidutil/setscfg.cpp

        ENTER("Command &setscfg::Clone() const");
        EXIT();
        return(*new setscfg(*this));
}
++ raidutils-0.0.6/raidutil/eventlog.hpp

	{

	public:
		EventLog(SCSI_Addr_List *deviceList, 
            EventLogOptions cmd);
		EventLog(const EventLog &new_EventLog);
		virtual	~EventLog();
++ raidutils-0.0.6/raidutil/alarm.hpp

class AlarmStatus:public Command
	{
	public:
		AlarmStatus( int hba, AlarmCommand cmd );							
		AlarmStatus( const AlarmStatus &new_AlarmStatus );
		virtual	~AlarmStatus();
		AlarmStatus	&operator = ( AlarmStatus &right );
++ raidutils-0.0.6/raidutil/rmwflash.hpp

{

        public:
                RMWFlash(int hbaNo, char *Data, int Region, unsigned long Offset, unsigned Size);
                RMWFlash(const RMWFlash &new_RMWFlash);
                virtual ~RMWFlash();

++ raidutils-0.0.6/raidutil/segment.hpp

{

	public:
		arraySegment(SCSI_Address raidToSeg, uLONG segSize[8], uLONG segOffset[8], bool showSeg);
		arraySegment(const arraySegment &new_arraySegment);
		virtual	~arraySegment();

++ raidutils-0.0.6/raidutil/namarray.hpp

{

	public:
		NameArray(SCSI_Address arrayToName, char *arrayName);
		NameArray(const NameArray &new_NameArray);
		virtual	~NameArray();

++ raidutils-0.0.6/raidutil/expand.hpp

class Expand:public Command
{
   public:
                Expand (SCSI_Address raid, SCSI_Addr_List *list);
		Expand (const Expand &new_Expand);
		virtual ~Expand();
		Expand &operator = (Expand &right);
++ raidutils-0.0.6/raidutil/uartdmp.hpp

{

	public:
		UartDmp(int hbaNo, char *fileName);
		UartDmp(const UartDmp &new_UartDmp);
		virtual	~UartDmp();

++ raidutils-0.0.6/raidutil/command.cpp

}


//// Comment out this stuff, for Debian.
// #ifdef sparc
// # define VOLATILE volatile
// #else
// # define VOLATILE
// #endif
//
// extern "C" { VOLATILE void exit (int);}

void Command::Init_Engine(int scanHbasOnly)
{
++ raidutils-0.0.6/raidutil/forcest.hpp

class ForceState:public Command
	{
	public:
		ForceState(SCSI_Addr_List *deviceList, ForceStateOptions cmd);
		ForceState(const ForceState &new_ForceState);
		virtual	~ForceState();

++ raidutils-0.0.6/raidutil/setrate.hpp

	public:

		// Set the (global) rebuild rate
                SetRate(int rate, SCSI_Addr_List *objs);
                SetRate(const SetRate &right);
		virtual	~SetRate();

		Dpt_Error execute(String_List **output);
++ raidutils-0.0.6/raidutil/parser.cpp

                    {
                             EventLog *temp = new EventLog (components, eventLogOpts);
                             cmd_List->add_Item (*temp);
                             delete temp;
                    }
                    else
                        Error_in_Parsing(EventStrings[STR_PARSE_ERR_MUST_SPECIFY_ADDRESS], this_Commands_Text);

                    temp = new NvramBit (Cache_Stale, params.hba_Num, temp_set);
                else
                    temp = new NvramBit (Cache_Stale, -1, temp_set);
                cmd_List->add_Item (*temp);
                delete temp;
            }
            else if (!strncmp(command_Line, "+cluster", strlen("cluster")))
++ raidutils-0.0.6/raidutil/taskctrl.hpp

class TaskControl:public Command
	{
	public:
		TaskControl(SCSI_Addr_List *deviceList, TaskCommandOptions cmd);
		TaskControl(const TaskControl &new_TaskControl);
		virtual	~TaskControl();

++ raidutils-0.0.6/raidutil/zap.hpp

class Zap:public Command
	{
	public:
		Zap(
				SCSI_Addr_List	*addresses,  // a list of addresses
            int resync = 0            // (send reset to hba or not)
      );								         // to delete raid tables on

Return to bug 282455