kmfs.c

深圳市微逻辑电子有限公司 巨果&#8226 Kingmos&reg 系统核心

	if( lpfn )
	{
		memset( lpfn, 0, sizeof( FILENODE ) );
		lpfn->pNode = (PNODE)lpfn->bNodeBuf;
		lpfn->lpszFileName = (LPTSTR)(lpfn + 1);
		strcpy( lpfn->lpszFileName, lpcszFileName );
	    InitializeCriticalSection( &lpfn->csFileNode );
	}
	return lpfn;
}

// **************************************************
// 声明：static void DeleteFileNode( LPFILENODE lpfn )
// 参数：
// 		IN lpfn - 文件节点指针
// 返回值：
//		无
// 功能描述：
//		与CreateFileNode相反，删除节点
// 引用: 
// **************************************************

static void DeleteFileNode( LPFILENODE lpfn )
{
	DeleteCriticalSection( &lpfn->csFileNode );
	free( lpfn );
}

// **************************************************
// 声明：static LPCTSTR IgnoreSpace( LPCTSTR lpcszFileName )
// 参数：
// 	IN lpcszFileName - 文件名
// 返回值：
//	文件名指针
// 功能描述：
//	略过文件名开头的空格，返回第一个非空格地址
// 引用: 
// **************************************************

static LPCTSTR IgnoreSpace( LPCTSTR lpcszFileName )
{
	while( *lpcszFileName == ' ' )
		lpcszFileName++;
	return lpcszFileName;
}

// **************************************************
// 声明：static LPKFSDVOL CreateVolume( void )
// 参数：
// 	无
// 返回值：
//	假如成功，返回新分配的卷指针；否则，返回NULL
// 功能描述：
// 引用: 
// **************************************************

static LPKFSDVOL CreateVolume( void )
{
    LPKFSDVOL lpVol;
    lpVol = (LPKFSDVOL)malloc( sizeof( KFSDVOL ) );
    if( lpVol )
	{
        memset( lpVol, 0, sizeof( KFSDVOL ) );
		InitializeCriticalSection( &lpVol->csNode );
#ifdef __DEBUG
		lpVol->csNode.lpcsName = "CS-NODE";
#endif
		InitializeCriticalSection( &lpVol->csFat );
#ifdef __DEBUG
		lpVol->csFat.lpcsName = "CS-FAT";
#endif
		InitializeCriticalSection( &lpVol->csFileList );
#ifdef __DEBUG
		lpVol->csFileList.lpcsName = "CS-FILELIST";
#endif
		InitializeCriticalSection( &lpVol->csFindList );
#ifdef __DEBUG
		lpVol->csFindList.lpcsName = "CS-FINDLIST";
#endif
	    lpVol->dwMinNeedUpdate = -1;
		lpVol->dwMaxNeedUpdate = 0;
	}
    return lpVol;
}

// **************************************************
// 声明：static void DeleteVolume( LPKFSDVOL lpVol )
// 参数：
// 	IN lpVol - 卷结构指针
// 返回值：
//	无
// 功能描述：
//	与 CreateVolume 相反，删除卷
// 引用: 
// **************************************************

static void DeleteVolume( LPKFSDVOL lpVol )
{
	DeleteCriticalSection( &lpVol->csNode );
	DeleteCriticalSection( &lpVol->csFat );
	DeleteCriticalSection( &lpVol->csFileList );
	DeleteCriticalSection( &lpVol->csFindList );

	free( lpVol->lpdwFat );
	free( lpVol->lpSectorBuf );
    free( lpVol );    
}

// **************************************************
// 声明：static LPKFSDVOL FindVolume( HDSK hDsk )
// 参数：
// 	IN hDsk - 磁盘对象句柄
// 返回值：
//	假如找到，返回卷结构指针; 否则，返回NULL
// 功能描述：
//	有磁盘句柄得到其关联的卷对象
// 引用: 
// **************************************************

static LPKFSDVOL FindVolume( HDSK hDsk )
{
    LPKFSDVOL lpList = NULL;

	EnterCriticalSection( &csVolumeList );
	
	lpList = lpListVol;
	RETAILMSG(FILE_ZONE, (TEXT("KFSD: ReadDisk Success\r\n")));
	while( lpList )
	{
		if( lpList->hDsk == hDsk )
		{	// 发现
			RETAILMSG(FILE_ZONE, (TEXT("KFSD: the volume exist, serial=%x.\r\n"), lpList->rfh.dwSerialNum ) );
			break;
		}
		lpList = lpList->lpNext;
	}
				
	LeaveCriticalSection( &csVolumeList );
	return lpList;
}

// **************************************************
// 声明：static BOOL RemoveVolume( LPKFSDVOL lpVol )
// 参数：
// 	IN lpVol - 卷结构指针
// 返回值：
//	假如成功，返回TRUE; 否则，返回FALSE
// 功能描述：
//	从系统移出卷
// 引用: 
// **************************************************

static BOOL RemoveVolume( LPKFSDVOL lpVol )
{
    BOOL retv = FALSE;

	EnterCriticalSection( &csVolumeList );  // 进入冲突段

    if( lpListVol )
    {
        LPKFSDVOL lpList = lpListVol;
        if( lpListVol == lpVol )  
        {	// 链表的第一个
            lpListVol = lpListVol->lpNext;
            retv =  TRUE;
        }
        else
        {
            while( lpList->lpNext )
            {
                if( lpList->lpNext == lpVol )
                {   // 发现， 移出
                    lpList->lpNext = lpVol->lpNext;
                    retv =  TRUE;
                    break;
                }
                lpList = lpList->lpNext;
            }
        }
    }

	LeaveCriticalSection( &csVolumeList ); // 离开冲突段

    return retv;
}

// **************************************************
// 声明：static BOOL AddToVolumeList( LPKFSDVOL lpvol )
// 参数：
// 	IN lpvol - 卷结构指针
// 返回值：
//	假如成功，返回TRUE; 否则，返回FALSE
// 功能描述：
//	将新卷加入卷链表
// 引用: 
// **************************************************

static BOOL AddToVolumeList( LPKFSDVOL lpvol )
{
	BOOL bRetv = FALSE;

	EnterCriticalSection( &csVolumeList ); // 进入冲突段

    if( lpvol->lpNext == 0 )
    {	// 加入
        lpvol->lpNext = lpListVol;
        lpListVol = lpvol;
        bRetv = TRUE;
    }

	LeaveCriticalSection( &csVolumeList );// 离开冲突段

    return bRetv;
}

// **************************************************
// 声明：static void CheckFat( LPKFSDVOL lpVol )
// 参数：
// 	IN lpVol - 卷结构指针
// 返回值：
//	无
// 功能描述：
//	调试版本，检查FAT是否有效
// 引用: 
// **************************************************

static void CheckFat( LPKFSDVOL lpVol )
{
	EnterCriticalSection( &lpVol->csFat );// 进入冲突段

	{
		DWORD dwSector = lpVol->rfh.dwFreeSector;
		DWORD num = lpVol->rfh.nFreeCount;
		DWORD i;
		DWORD end = (lpVol->fdd.nSectors - 1);
		DWORD *lpdwFat;
		
		
		
		lpdwFat = lpVol->lpdwFat;
		
		for( i = 0; i < num; i++ )
		{
			if( dwSector > end )
			{
				RETAILMSG(FILE_ZONE, (TEXT("KFSD: Error Alloc=%d, i=%d, num=%d=====================================\r\n"), dwSector, i, num));
				break;
			}
			dwSector = *(lpdwFat+dwSector);
		}

	}
	LeaveCriticalSection( &lpVol->csFat );// 离开冲突段
}

// **************************************************
// 声明：static BOOL FreeSector( LPKFSDVOL lpVol, DWORD dwStartSector ) 
// 参数：
// 	IN lpVol - 卷结构指针
//	IN dwStartSector - 开始扇区
// 返回值：
//	假如成功，返回TRUE; 否则，返回FALSE
// 功能描述：
//	释放扇区
// 引用: 
// **************************************************

static BOOL FreeSector( LPKFSDVOL lpVol, DWORD dwStartSector ) 
{
    DWORD * lpdwFat = lpVol->lpdwFat;
    DWORD n, w, k;

	//CheckFat(lpVol);

    ASSERT( dwStartSector != NULL_SECTOR );
	if( dwStartSector == NULL_SECTOR )
		return TRUE;
	
	EnterCriticalSection( &lpVol->csFat );// 进入冲突段

	// 检查扇区链表，并得到扇区数和最后扇区位置
	k = w = dwStartSector;
    for( n = 0; w != NULL_SECTOR; n++ )
	{
        k = w;
		w = NEXT_SECTOR( lpdwFat, w );		
	}
	// k 需要释放的最后一个扇区索引
	// 连接系统FAT的空闲扇区
    *(lpdwFat+k) = lpVol->rfh.dwFreeSector;
	// 需要更新的FAT数据区
	lpVol->dwMaxNeedUpdate = MAX( lpVol->dwMaxNeedUpdate, k );
	lpVol->dwMinNeedUpdate = MIN( lpVol->dwMinNeedUpdate, k );

    lpVol->rfh.dwFreeSector = dwStartSector;  // 新的空闲扇区索引
    lpVol->rfh.nFreeCount += n; // 新的空闲扇区数
	lpVol->fUpdate = 1;	// 更新标志

	LeaveCriticalSection( &lpVol->csFat );// 离开冲突段

    return TRUE;
}

// **************************************************
// 声明：static DWORD AllocSector( LPKFSDVOL lpVol, DWORD nSectorNum )
// 参数：
// 	IN lpVol - 卷对象指针
//	IN nSectorNum - 需要的扇区数
// 返回值：
//	假如成功，返回非NULL_SECTOR值；否则，返回NULL_SECTOR
// 功能描述：
//	分配一定数量的扇区
// 引用: 
// **************************************************

static DWORD AllocSector( LPKFSDVOL lpVol, DWORD nSectorNum )
{
	DWORD first, n, k;
	DWORD * pfat;
	DWORD end;
	
    EnterCriticalSection( &lpVol->csFat ); // 进入冲突段
	
	end = (lpVol->fdd.nSectors - 1);
		
	RETAILMSG( FILE_ZONE, ( TEXT("KFSD: AllocSector=%d, end=%d, free count=%d\r\n"), nSectorNum, end, lpVol->rfh.nFreeCount ) );
	
	//CheckFat(lpVol);
	
	if( nSectorNum > 0 && lpVol->rfh.nFreeCount >= nSectorNum )
	{   // 系统有足够的扇区
		first = lpVol->rfh.dwFreeSector;
		k = (nSectorNum-1);
		pfat = lpVol->lpdwFat;
		for( n = 0; n < k; n++ )
		{
			first = *(pfat+first);  // get next block
			if( first > end )
			{   // 决不应该到这里
				ERRORMSG(FILE_ZONE, (TEXT("error in KFSD's AllocSector:  Alloc=%d, n=%d\r\n"), first, n));
			}
		}
		n = first;  // n 为分配的最后一个块 end block
		first = *(pfat+first);  // get next block
		*(pfat+n) = NULL_SECTOR;  // 设置块链结束标志
		// 设置FAT更新区间
		lpVol->dwMaxNeedUpdate = MAX( lpVol->dwMaxNeedUpdate, n );
		lpVol->dwMinNeedUpdate = MIN( lpVol->dwMinNeedUpdate, n );
		// 重新设置系统空闲参数 reset free block and count
		n = lpVol->rfh.dwFreeSector;  // n = 返回值
		lpVol->rfh.dwFreeSector = first;
		lpVol->rfh.nFreeCount -= nSectorNum;
		lpVol->fUpdate = 1;
		//		
		LeaveCriticalSection( &lpVol->csFat );// 离开冲突段		
		return n;
	}

	SetLastError(ERROR_DISK_FULL);

	WARNMSG( FILE_ZONE, (TEXT("error in KFSD's AllocSector: AllocSector no enough Sector.\r\n")));
	
	LeaveCriticalSection( &lpVol->csFat );// 离开冲突段
	
    return NULL_SECTOR;
}

// **************************************************
// 声明：static DWORD ReallocSector(
//                          LPKFSDVOL lpVol, 
//                          DWORD dwAllocSector, 
//                          DWORD nSectorNum )
// 参数：
// 	IN lpVol - 卷对象指针
//	IN dwAllocSector - 已分配扇区
//	IN nSectorNum - 新的扇区数
// 返回值：
//	假如成功，返回非NULL_SECTOR值；否则，返回NULL_SECTOR
// 功能描述：
//	改变/重新分配之前已分配扇区的块数
// 引用: 
// **************************************************

static DWORD ReallocSector(
                          LPKFSDVOL lpVol, 
                          DWORD dwAllocSector, 
                          DWORD nSectorNum )
{