dpartcbio.c

vxworks操作系统的文件系统部分原代码

    if(TRUE == cbioRdyChgdGet (dev))
	{
	errno = S_ioLib_DISK_NOT_PRESENT ;
	return ERROR;
	}

    if( (srcBlock) > pDev->cbioParams.nBlocks ||
        (dstBlock) > pDev->cbioParams.nBlocks )
	return ERROR;

    if( (srcBlock+numBlocks) > pDev->cbioParams.nBlocks ||
        (dstBlock+numBlocks) > pDev->cbioParams.nBlocks )
	return ERROR;

    srcBlock += pDev->cbioParams.blockOffset;
    dstBlock += pDev->cbioParams.blockOffset;

    if( semTake( pDev->cbioMutex, WAIT_FOREVER) == ERROR )
	return ERROR;

    retStat = pDev->pDc->subDev->pFuncs->cbioDevBlkCopy(
		pDev->pDc->subDev,
		srcBlock,
		dstBlock,
		numBlocks
		);

    if( retStat == ERROR )
	if( TRUE == cbioRdyChgdGet (dev->pDc->subDev))
	    CBIO_READYCHANGED (dev) = TRUE;

    semGive( pDev->cbioMutex );

    return ( retStat);
    }

/*******************************************************************************
*
* dpartIoctl - Misc control operations 
*
* This performs the requested ioctl() operation.
* 
* CBIO modules can expect the following ioctl() codes from cbioLib.h:
* CBIO_RESET - reset the CBIO device and the lower layer
* CBIO_STATUS_CHK - check device status of CBIO device and lower layer
* CBIO_DEVICE_LOCK - Prevent disk removal 
* CBIO_DEVICE_UNLOCK - Allow disk removal
* CBIO_DEVICE_EJECT - Unmount and eject device
* CBIO_CACHE_FLUSH - Flush any dirty cached data
* CBIO_CACHE_INVAL - Flush & Invalidate all cached data
* CBIO_CACHE_NEWBLK - Allocate scratch block
*
* 
* command - ioctl() command being issued
* 
* arg - specific to the particular ioctl() function requested or un-used.
*
* RETURNS OK or ERROR and may otherwise set errno.
*/
LOCAL STATUS dpartIoctl
    (
    CBIO_DEV_ID	dev,
    UINT32	command,
    addr_t	arg
    )
    {
    STATUS retStat = ERROR ;

    if(OK != cbioDevVerify (dev))
	{
	INFO_MSG("dpartIoctl: invalid handle\n");
	return ERROR;
	}

    if( semTake( dev->cbioMutex, WAIT_FOREVER) == ERROR )
	return ERROR;

    switch ( command )
	{
	case CBIO_RESET :
		/*
		 * if this is the first partition to issue RESET
		 * we need to RESET the lower level device too,
		 * otherwise, RESET only this partition.
		 */
		if((TRUE == cbioRdyChgdGet (dev->pDc->subDev)) ||
		   (TRUE == cbioRdyChgdGet (dev->pDc->masterDev)))
		    {
		    DEBUG_MSG("dpartCbio: resetting subordinate\n");
		    retStat = dev->pDc->subDev->pFuncs->cbioDevIoctl(
				dev->pDc->subDev,
				command,
				arg );

		    /* and also fill  the partitions geometry now */
		    if( retStat == OK )
			{
			retStat = dpartPartTableFill( dev->pDc );
			}

		    if( retStat == OK )
			{
			CBIO_READYCHANGED (dev->pDc->masterDev) = FALSE;
			}
		    }
		else
		    {
		    /*
		     * if masterDev does not have readyChanged
		     * there is no need to reset subDev, its been
		     * already reset
		     */
		    retStat = OK;
		    }

		/* non-existent partitions will remain "removed" */
		if (retStat == OK && dev->cbioParams.nBlocks == 0)
		    {
		    errno = S_ioLib_DISK_NOT_PRESENT ;
		    retStat = ERROR ;
		    }

		if( retStat == OK )
		    CBIO_READYCHANGED(dev) = FALSE;
		break;

	/* NEWBLK is the only ioctl where block# is coded in arg */

	case CBIO_CACHE_NEWBLK:
	    arg += dev->cbioParams.blockOffset ;

	    /*FALLTHROUGH*/

	/* all other commands should be executed by the lower layer */
	case CBIO_STATUS_CHK : 
	case CBIO_DEVICE_LOCK :
	case CBIO_DEVICE_UNLOCK :
	case CBIO_DEVICE_EJECT :

	    /* check if master has readyChanged */

	    if((TRUE == cbioRdyChgdGet (dev->pDc->subDev)) ||
	       (TRUE == cbioRdyChgdGet (dev->pDc->masterDev)))
		{
		CBIO_READYCHANGED (dev) = TRUE;
		}

	    /*FALLTHROUGH*/

	case CBIO_CACHE_FLUSH :
	case CBIO_CACHE_INVAL :
	default:
	    if(TRUE == cbioRdyChgdGet (dev))
		{
		errno = S_ioLib_DISK_NOT_PRESENT ;
		retStat = ERROR ;
		}
	    else
		{
		if( command == (int)CBIO_DEVICE_LOCK )
		    semTake( dev->pDc->subDev->cbioMutex, WAIT_FOREVER) ;

		retStat = dev->pDc->subDev->pFuncs->cbioDevIoctl(
			    dev->pDc->subDev,
			    command,
			    arg );

		if( command == (int)CBIO_DEVICE_UNLOCK )
		    semGive( dev->pDc->subDev->cbioMutex) ;
		}
	} /* end of switch */

    if( retStat == ERROR )
	if( TRUE == cbioRdyChgdGet (dev->pDc->subDev))
	    CBIO_READYCHANGED (dev) = TRUE;

    semGive( dev->cbioMutex );

    return( retStat );
    }

/*******************************************************************************
*
* dpartDevCreate - Initialize a partitioned disk
*
* To handle a partitioned disk, this function should be called,
* with <subDev> as the handle returned from dcacheDevCreate(),
* It is recommended that for efficient operation a single disk cache
* be allocated for the entire disk and shared by its partitions.
*
* <nPart> is the maximum number of partitions which are expected
* for the particular disk drive. Up to 24 (C-Z) partitions per disk 
* are supported.
*
* PARTITION DECODE FUNCTION
* An external partition table decode function is provided via the
* <pPartDecodeFunc> argument, which implements a particular style and
* format of partition tables, and fill in the results into a table
* defined as Pn array of PART_TABLE_ENTRY types. See dpartCbio.h
* for definition of PART_TABLE_ENTRY.
* The prototype for this function is as follows:
* 
* .CS
*     STATUS parDecodeFunc
* 	(
* 	CBIO_DEV_ID dev,	/@ device from which to read blocks @/
* 	PART_TABLE_ENTRY *pPartTab, /@ table where to fill results @/
* 	int nPart		/@ # of entries in <pPartTable> @/
* 	)
* .CE
*
* RETURNS: CBIO_DEV_ID or NULL if error creating CBIO device.
* 
* SEE ALSO: dosFsDevCreate().
* INTERNAL
* during create, readyChanged bit is TRUE, so no accesses are allowed
* until after a CBIO_RESET, at which time the actual partition table
* will be brought in and applied.
*/

CBIO_DEV_ID dpartDevCreate
    (
    CBIO_DEV_ID	subDev,		/* lower level CBIO device */
    int		nPart,		/* # of partitions */
    FUNCPTR	pPartDecodeFunc	/* function to decode partition table */
    )
    {
    CBIO_DEV_ID	cbio = subDev ;
    CBIO_DEV_ID	pDev = NULL ;
    DPART_CTRL * pDc ;
    int p ;

    if( nPart > PART_MAX_ENTRIES || pPartDecodeFunc == NULL )
	{
	printErr ("%d is too many partitions, max limit %d\n",
		  nPart, PART_MAX_ENTRIES);
	errno = EINVAL;
	return NULL;
	}

    cbioLibInit();	/* just in case */

    /* if this is a BLK_DEV, create a CBIO_DEV */

    if (OK != cbioDevVerify( subDev ))
        {
        /* attempt to handle BLK_DEV subDev */
        cbio = cbioWrapBlkDev ((BLK_DEV *) subDev);

        if( NULL != cbio )
            {
            /* SPR#71633, clear the errno set in cbioDevVerify() */
            errno = 0;
            }
        }
    else
	{
	cbio = subDev;
	}

    if( NULL == cbio )
	{
	DEBUG_MSG("dpartDevCreate: invalid handle\n");
	return NULL;
	}


    /* allocate our main DPART_CTRL structure */

    pDc = KHEAP_ALLOC((sizeof(DPART_CTRL)));

    if( pDc == NULL )
	{
	return( NULL );
	}

    bzero( (char *) pDc, sizeof( DPART_CTRL) );

    /* create the primary CBIO handle */

    pDev = cbioDevCreate ( NULL, 0 );

    if( pDev == NULL )
	{
	return( NULL );
	}

    /* the primary CBIO handle is not for any actual I/O, just for show */

    pDev->cbioDesc	= "dpartCbio Partition Manager" ;
    CBIO_READYCHANGED (pDev)		= CBIO_READYCHANGED (cbio);
    pDev->cbioParams.cbioRemovable	= cbio->cbioParams.cbioRemovable ;
    pDev->cbioParams.nBlocks		= cbio->cbioParams.nBlocks ;
    pDev->cbioParams.bytesPerBlk	= cbio->cbioParams.bytesPerBlk ;
    pDev->cbioParams.blocksPerTrack	= cbio->cbioParams.blocksPerTrack ;
    pDev->cbioParams.nHeads		= cbio->cbioParams.nHeads ;
    pDev->cbioMode			= cbio->cbioMode ;
    pDev->cbioParams.blockOffset	= 0 ;
    pDev->cbioParams.lastErrBlk		= NONE ;
    pDev->cbioParams.lastErrno		= 0 ;
    pDev->cbioPartIndx			= NONE ; /* master device */

    /* SPR#67729: Fill in the members subDev and isDriver appropriately */

    pDev->blkSubDev = NULL;    /* Since lower layer is not BLKDEV  */
    pDev->cbioSubDev = cbio;    /* Storing the reference to the sub Device  */
    pDev->isDriver = FALSE;   /* == FALSE since this is a CBIO TO CBIO layer */
    pDev->pDc				= pDc ;  /* DPART_CTRL */
    pDev->pFuncs 			= &cbioFuncs;

    /* setup main fields */

    pDc->subDev				= cbio ;
    pDc->pPartDecodeFunc		= pPartDecodeFunc ;
    pDc->nPart				= nPart ;
    pDc->masterDev			= pDev ;

    /* Now initialize the partition virtual devs */

    for(p = 0; p < PART_MAX_ENTRIES; p++ )
	{
	CBIO_DEV_ID tmpDev = & ( pDc->vDev[ p ] );

	/* inherit most fields from the primary handle */

	*tmpDev = *pDev ;

	tmpDev->cbioDesc        = "dpartCbio Partition Slave Device";
	tmpDev->cbioPartIndx    = p;   /* partition # */

	CBIO_READYCHANGED (tmpDev) = TRUE;

	/* semaphore can be just copied, it has to be init'ed */

        tmpDev->cbioMutex = semMCreate (dpartSemOptions);

        if (NULL == tmpDev->cbioMutex)
	    {
	    DEBUG_MSG("Error Creating the device semaphore\n");
	    pDev = NULL;
	    break;
	    }

#ifdef _WRS_DOSFS2_VXWORKS_AE	
	/* init the handle */
	handleInit (&tmpDev->cbioHandle, handleTypeCbioHdl);
#endif  /* _WRS_DOSFS2_VXWORKS_AE */

	/* these will be filled later from actual geometry */
	tmpDev->cbioParams.nBlocks	= 0 ;
	tmpDev->cbioParams.blockOffset	= 0 ;
	}

    DEBUG_MSG("dpartDevCreate: handle dev %x subDev %x\n", pDev, cbio );

    /* return device handle */
    return( pDev );
    }

/*******************************************************************************
*
* dpartPartGet - retrieve handle for a partition
*
* This function retrieves a CBIO handle into a particular partition
* of a partitioned device. This handle is intended to be used with
* dosFsDevCreate().
*
* RETURNS: CBIO_DEV_ID or NULL if partition is out of range, or
* <masterHandle> is invalid.
*
* SEE ALSO: dosFsDevCreate()
*/
CBIO_DEV_ID dpartPartGet
    (
    CBIO_DEV_ID masterHandle,	/* CBIO handle of the master partition */
    int partNum			/* partition number from 0 to nPart */
    )
    {
    if(OK != cbioDevVerify( masterHandle))
	{
	return NULL;
	}

    if( partNum >= masterHandle->pDc->nPart )
	{
	errno = EINVAL;
	return NULL;
	}

    return ( & masterHandle->pDc->vDev[ partNum ] );
    }

/*******************************************************************************
*
* dpartShow - show current parameters of the RAM disk device
*
* NOMANUAL
*/
STATUS dpartShow( CBIO_DEV_ID dev, int verb )
    {
    DPART_CTRL * pDc ;
    int pn ;

    if( (OK != cbioDevVerify (dev)))
	{
	DEBUG_MSG("dpartShow: invalid handle\n");
	return ERROR;
	}

    pDc = dev->pDc ;

    if( TRUE == cbioRdyChgdGet (dev))
	dev->pFuncs->cbioDevIoctl( dev, CBIO_RESET, 0);

    if( dev->cbioPartIndx == (u_long)NONE )
	printf("  Device %#lx is Master handle, Partition Table:\n",
		(u_long) dev);
    else
	printf("  Device %#lx is partition %ld, Partition Table:\n",
		(u_long) dev, dev->cbioPartIndx );

    for( pn = 0; pn < pDc->nPart ; pn ++ )
	{
	printf("  #%ld: from %ld to %ld (%ld blocks)\n",
		pDc->vDev[ pn ].cbioPartIndx,
		(block_t) pDc->vDev[ pn ].cbioParams.blockOffset,
		pDc->vDev[ pn ].cbioParams.nBlocks + 
			pDc->vDev[ pn ].cbioParams.blockOffset,
		pDc->vDev[ pn ].cbioParams.nBlocks );
	}

    printf("  master dev %#lx, subordinate dev %#lx, with total %ld blocks\n",
	(u_long) pDc->masterDev, (u_long) pDc->subDev,
	pDc->subDev->cbioParams.nBlocks );

    return OK;
    }
/* End of File */