proto.h

嵌入式操作系统Nucleus Plus中使用的文件系统

/*****************************************************************************
*Filename: PROTO.H - Function prototypes for ms-dos utilities
*					   
* EBS - RTFS (Real Time File Manager)
* Accelerated Technology, Inc.	-  Nucleus FILE Extensions, copyright 1993
*
* Copyright Peter Van Oudenaren , 1993
* All rights reserved.
* This code may not be redistributed in source or linkable object form
* without the consent of its author.
*
* Description: 
*	
    BobB       2/19/99    Changed name of NU_Free to NU_FreeSpace (SPR420)

*
*
*****************************************************************************/


/* File API.C */
BOOL NU_Open_Disk(TEXT *path);
BOOL NU_Close_Disk(TEXT *path);
VOID NU_Disk_Abort(TEXT *path);
BOOL NU_Make_Dir(TEXT  *name);
VOID  _synch_file_ptrs(PC_FILE *pfile);
PCFD NU_Open(TEXT *name, UCOUNT flag, UCOUNT mode);
COUNT NU_Read(PCFD fd,  UTINY *buf, UCOUNT count);
COUNT NU_Write(PCFD fd, UTINY *buf, UCOUNT count);
LONG NU_Seek(PCFD fd, LONG offset, COUNT origin);
BOOL NU_Truncate(PCFD fd, LONG offset);
LONG _po_lseek(PC_FILE *pfile, LONG offset, COUNT origin);
BOOL _po_flush(PC_FILE *pfile);
BOOL NU_Flush(PCFD fd);
INT NU_Close(PCFD fd);
BOOL NU_Rename(TEXT *name, TEXT *newname);
BOOL NU_Delete(TEXT *name);
BOOL NU_Remove_Dir(TEXT  *name);
UCOUNT pc_fat_size(UCOUNT nreserved, UCOUNT cluster_size, UCOUNT n_fat_copies, UCOUNT root_entries, ULONG volume_size);
BOOL NU_Format(COUNT driveno, FMTPARMS *pfmt);
LONG NU_FreeSpace(TEXT *path);
BOOL NU_Get_First(DSTAT *statobj, TEXT *name);
BOOL NU_Get_Next(DSTAT *statobj);
VOID NU_Done(DSTAT *statobj);
BOOL pc_set_default_drive(TEXT *drive);
BOOL NU_Set_Default_Drive(COUNT driveno);
COUNT	NU_Get_Default_Drive(VOID);
BOOL NU_Set_Current_Dir(TEXT *name);
BOOL NU_Current_Dir(TEXT *drive, TEXT *path);
/* File APIEXT.C */
COUNT pc_cluster_size(TEXT *drive);
UCOUNT po_extend_file(PCFD fd, UCOUNT n_clusters, COUNT method);
UCOUNT pc_find_contig_clusters(DDRIVE *pdr, UCOUNT startpt, UCOUNT  *pchain, UCOUNT min_clusters, COUNT method);
/* File APIUTIL.C */
PC_FILE *pc_fd2file(PCFD fd,BOOL allow_err);
PCFD pc_allocfile(VOID);
VOID pc_freefile(PCFD fd);
VOID pc_free_all_fil(DDRIVE *pdrive);
COUNT pc_log_base_2(UCOUNT n);
BOOL pc_dskinit(COUNT driveno);
BOOL pc_idskclose(COUNT driveno);
DROBJ *pc_get_cwd(DDRIVE *pdrive);
BOOL NU_Is_Dir(TEXT *path);
BOOL pc_isvol(TEXT *path);
VOID pc_upstat(DSTAT *statobj);
/* File BIOS.C */
BOOL bios_init_drive(COUNT phys_drive);
/* File BLOCK.C */
BOOL pc_alloc_blk(BLKBUFF **ppblk, DDRIVE *pdrive, BLOCKT blockno);
BLKBUFF *pc_blkpool(DDRIVE *pdrive);
VOID pc_free_all_blk(DDRIVE *pdrive);
VOID pc_free_buf(BLKBUFF *pblk, BOOL    waserr);
BLKBUFF *pc_init_blk(DDRIVE *pdrive, BLOCKT blockno);
BLKBUFF *pc_read_blk(DDRIVE *pdrive, BLOCKT blockno);
BOOL pc_write_blk(BLKBUFF *pblk);
/* File DROBJ.C */
DROBJ *pc_fndnode(TEXT *path);
DROBJ *pc_get_inode( DROBJ *pobj, DROBJ *pmom, UTEXT *filename, UTEXT *fileext);
BOOL pc_findin( DROBJ *pobj, UTEXT *filename, UTEXT *fileext);
DROBJ *pc_get_mom(DROBJ *pdotdot);
DROBJ *pc_mkchild( DROBJ *pmom);
DROBJ *pc_mknode(DROBJ *pmom ,TEXT *filename, TEXT *fileext, UTINY attributes);
BOOL pc_insert_inode( DROBJ *pobj, DROBJ *pmom);
BOOL pc_rmnode( DROBJ *pobj);
BOOL pc_update_inode( DROBJ *pobj);
BLKBUFF *pc_read_obj(DROBJ *pobj);
BOOL pc_write_obj(DROBJ *pobj);
DROBJ *pc_get_root( DDRIVE *pdrive);
BLOCKT pc_firstblock( DROBJ *pobj);
BOOL pc_next_block( DROBJ *pobj);
BLOCKT pc_l_next_block(DDRIVE *pdrive, BLOCKT curblock);
VOID pc_marki( FINODE *pfi, DDRIVE *pdrive, BLOCKT sectorno, COUNT  index);
FINODE *pc_scani( DDRIVE *pdrive, BLOCKT sectorno, COUNT index);
DROBJ *pc_allocobj(VOID);
FINODE *pc_alloci(VOID);
VOID pc_free_all_i( DDRIVE *pdrive);
VOID pc_freei( FINODE *pfi);
VOID pc_freeobj( DROBJ *pobj);
VOID pc_dos2inode (FINODE *pdir, DOSINODE *pbuff);
VOID pc_init_inode(FINODE *pdir, TEXT *filename, TEXT *fileext, UTINY attr, UCOUNT cluster, ULONG size, DATESTR *crdate);
VOID pc_ino2dos (DOSINODE *pbuff, FINODE *pdir);
BOOL pc_isavol( DROBJ *pobj);
BOOL pc_isadir( DROBJ *pobj);
BOOL pc_isroot( DROBJ *pobj);
/* File LOWL.C */
UCOUNT pc_alloc_chain(DDRIVE *pdr, UCOUNT *pstart_cluster, UCOUNT n_clusters);
UCOUNT pc_find_free_cluster(DDRIVE *pdr, UCOUNT startpt, UCOUNT endpt);
UCOUNT pc_clalloc(DDRIVE *pdr, UCOUNT clhint);
UCOUNT  pc_clgrow(DDRIVE *pdr, UCOUNT  clno);
UCOUNT pc_clnext(DDRIVE *pdr, UCOUNT  clno);
VOID pc_clrelease(DDRIVE   *pdr, UCOUNT  clno);
BOOL pc_faxx(DDRIVE *pdr, UCOUNT clno, UCOUNT *pvalue);
BOOL pc_flushfat(COUNT driveno);
VOID pc_freechain(DDRIVE *pdr, UCOUNT cluster);
UCOUNT pc_get_chain(DDRIVE *pdr, UCOUNT start_cluster, UCOUNT *pnext_cluster, UCOUNT n_clusters);
BOOL pc_pfaxx(DDRIVE   *pdr, UCOUNT  clno, UCOUNT  value);
UTINY FAR *pc_pfswap(DDRIVE *pdr, UCOUNT index, BOOL for_write);
BOOL pc_pfpword(DDRIVE *pdr, UCOUNT index, UCOUNT *pvalue);
BOOL pc_pfgword(DDRIVE *pdr, UCOUNT index, UCOUNT *value);
BOOL pc_pfflush(DDRIVE *pdr);
BOOL pc_gblk0(UCOUNT driveno, struct pcblk0 *pbl0);
BOOL pc_clzero(DDRIVE *pdrive, UCOUNT cluster);
DDRIVE  *pc_drno2dr(COUNT driveno);
BOOL pc_dskfree(COUNT driveno, BOOL  unconditional);
LONG pc_ifree(COUNT driveno);
UCOUNT pc_sec2cluster(DDRIVE *pdrive, BLOCKT blockno);
UCOUNT pc_sec2index(DDRIVE *pdrive, BLOCKT blockno);
BLOCKT pc_cl2sector(DDRIVE *pdrive, UCOUNT cluster);
COUNT ext_partition_init(COUNT driveno, ULONG *pstart, ULONG *pend, COUNT max);
/* File PC_CNVRT.C */
ULONG to_DWORD ( UTINY *from);
UCOUNT to_WORD ( UTINY *from);
VOID fr_WORD ( UTINY *to,  UCOUNT from);
VOID fr_DWORD ( UTINY *to,  ULONG from);
/* File PC_ERROR.C */
VOID pc_report_error(INT error_number);
/* File PC_LOCKS.C */
#if (NUM_USERS > 1)
UCOUNT pc_fs_enter(VOID);
VOID pc_fs_exit(UCOUNT restore_state);
#if (LOCK_METHOD == 2)
WAIT_HANDLE_TYPE pc_alloc_lock(VOID);
VOID pc_wait_lock(WAIT_HANDLE_TYPE wait_handle);
VOID pc_wake_lock(WAIT_HANDLE_TYPE wait_handle);
VOID pc_drive_enter(COUNT driveno, BOOL exclusive);
VOID  pc_drive_exit(COUNT driveno);
VOID pc_inode_enter(FINODE *pinode, BOOL exclusive);
VOID pc_inode_exit(FINODE *pinode);
VOID pc_fat_enter(COUNT driveno);
VOID  pc_fat_exit(COUNT driveno);
VOID pc_drive_io_enter(COUNT driveno);
VOID pc_drive_io_exit(COUNT driveno);
VOID pc_generic_enter(LOCKOBJ *plock, BOOL exclusive);
VOID pc_generic_exit(LOCKOBJ *plock);
VOID fs_suspend_task(VOID);
VOID fs_release(VOID);
VOID fs_reclaim(VOID);
#endif
#endif
/* File PC_MEMRY.C */
BOOL pc_memory_init(VOID);
VOID pc_memory_close(VOID);
DROBJ *pc_memory_drobj(DROBJ *pobj);
FINODE *pc_memory_finode(FINODE *pinode);
UTINY FAR *pc_memory_fat_blocks_alloc(COUNT driveno, UCOUNT min, UCOUNT max, UCOUNT *p_nalloced);
VOID pc_memory_fat_blocks_free(COUNT driveno, UTINY FAR *pdata, UCOUNT nblocks);
/* File PC_PRINT.C */
int printf(const char *fmt, ...);
TEXT *pc_stoa(short int num, TEXT *dest, INT  base);
TEXT *pc_itoa(INT  num, TEXT *dest, INT  base);
TEXT *pc_ltoa(LONG num, TEXT *dest, INT  base);
TEXT *pc_strjust(TEXT *to, TEXT *from, BOOL leftjust, INT	 width, TEXT padchar);
VOID pc_putstr(TEXT *p);
/* File PC_UDATE.C */
DATESTR *pc_getsysdate(DATESTR *pd);
/* File PC_USERS.C */
VOID  pc_free_all_users(COUNT driveno);
#if (NUM_USERS> 1)
BOOL NU_Become_File_User(VOID);
VOID NU_Release_File_User(VOID);
BOOL NU_Check_File_User(VOID);
VOID  pc_rtfs_switch_in(VOID);
#endif
/* File RAMDISK.C */
UTINY FAR *rd_alloc_page(VOID);
VOID   rd_free_page(UTINY FAR *page);
BOOL pc_rd_ioctl(UCOUNT driveno, UCOUNT command, VOID *buffer);
BOOL pc_rd_raw_open(UCOUNT driveno);
BOOL pc_rd_open(UCOUNT driveno);
BOOL pc_rd_close(UCOUNT driveno);
BOOL pc_rd_io(UCOUNT driveno, ULONG block, VOID FAR *buffer, UCOUNT count, BOOL reading);
/* File UTIL.C */
BOOL pc_allspace(UTEXT *p, INT i);
VOID copybuff(VOID *vto, VOID *vfrom, INT size);
VOID pc_cppad(UTEXT *to, UTEXT *from, INT size);
BOOL pc_isdot(UTEXT *fname, UTEXT *fext);
BOOL pc_isdotdot(UTEXT *fname, UTEXT *fext);
VOID pc_memfill(VOID *vto, INT size, UTINY c);
UTEXT *pc_mfile(UTEXT *to, UTEXT *filename, UTEXT *ext);
UTEXT *pc_mpath(UTEXT *to, UTEXT *path, UTEXT *filename);
TEXT *pc_parsedrive(COUNT *driveno, TEXT  *path);
BOOL pc_fileparse(TEXT *filename, TEXT *fileext, TEXT *p);
TEXT *pc_nibbleparse(TEXT *filename, TEXT *fileext, TEXT *path);
BOOL pc_parsepath(TEXT *topath, TEXT *filename, TEXT *fileext, TEXT *path);
BOOL pc_patcmp(UTEXT *p, UTEXT *pattern, INT size);
VOID pc_strcat(TEXT *to, TEXT *from);
VOID pc_str2upper(TEXT *to, TEXT *from);