peteratebs/rtfsprorelease
1
Fork 0
mirror of https://github.com/peteratebs/rtfsprorelease.git synced 2025-06-18 16:55:34 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity
master
rtfsprorelease/include/rtfsprotos.h
peteratebs 2109360d7d first commit
2016-06-05 16:09:54 -04:00

947 lines
47 KiB
C
Raw Permalink Blame History

/*****************************************************************************
*Filename: RTFSPROTOS.H - RTFS common function prototypes
*
*
* EBS - RTFS (Real Time File Manager)
*
* Copyright EBS, 2007
* All rights reserved.
* This code may not be redistributed in source or linkable object form
* without the consent of its author.
*
*
*
* Description:
*
*
*
*
****************************************************************************/
#ifndef __RTFSPROTOS__
#define __RTFSPROTOS__ 1
/* =========================== */
/* Rtfs internal prototypes */
/* =========================== */
#ifdef __cplusplus
extern "C" {
#endif
/* Application callbacks */
#define RTFS_CBS_INIT 0
#define RTFS_CBS_PUTS 1
#define RTFS_CBS_GETS 2
#define RTFS_CBS_GETDATE 3
#define RTFS_CBS_POLL_DEVICE_READY 4
/* Exfat buffering and operating parameters are via callback not from the device layer */
#define RTFS_CBS_GETEXFATBUFFERS 5
#define RTFS_CBS_RELEASEEXFATBUFFERS 6
/* Exfat date extensions via callback not from the device layer */
#define RTFS_CBS_UTCOFFSET 7
#define RTFS_CBS_10MSINCREMENT 8
#define RTFS_CBA_INFO_MOUNT_STARTED 0
#define RTFS_CBA_INFO_MOUNT_FAILED 1
#define RTFS_CBA_INFO_MOUNT_COMPLETE 2
#define RTFS_CBA_ASYNC_MOUNT_CHECK 3
#define RTFS_CBA_ASYNC_START 4
#define RTFS_CBA_ASYNC_DRIVE_COMPLETE 5
#define RTFS_CBA_ASYNC_FILE_COMPLETE 6
#define RTFS_CBA_DVR_EXTRACT_RELEASE 7
#define RTFS_CBD_ASSERT 0
#define RTFS_CBD_ASSERT_TEST 1
#define RTFS_CBD_SETERRNO 2
#define RTFS_CBD_IOERROR 3
#define RTFS_CB_FS_RETRIEVE_FIXED_JOURNAL_LOCATION 200
#define RTFS_CB_FS_FAIL_ON_JOURNAL_RESIZE 201
#define RTFS_CB_FS_FAIL_ON_JOURNAL_FULL 202
#define RTFS_CB_FS_RETRIEVE_JOURNAL_SIZE 203
#define RTFS_CB_FS_RETRIEVE_RESTORE_STRATEGY 204
#define RTFS_CB_FS_FAIL_ON_JOURNAL_CHANGED 205
#define RTFS_CB_FS_CHECK_JOURNAL_BEGIN_NOT 206
#define RTFS_CB_FS_RETRIEVE_FLUSH_STRATEGY 207
int rtfs_sys_callback(int cb_code, void *pvargs);
int rtfs_app_callback(int cb_code, int iarg0, int iargs1, int iargs2, void *pvargs);
void rtfs_diag_callback(int cb_code, int iarg0);
int rtfs_failsafe_callback(int cb_code, int driveno, int iarg0, void *pvargs0, void *pvargs1);
#if (INCLUDE_FAILSAFE_RUNTIME)
BOOLEAN pc_failsafe_init(void);
#endif
#if (INCLUDE_CS_UNICODE)
/* Prototypes of unicode / Non-Unicode selectable APIS */
BOOLEAN pc_get_volume_cs(byte *driveid, byte *volume_label,int use_charset);
BOOLEAN pc_set_volume_cs(byte *driveid, byte *volume_label,int use_charset);
BOOLEAN pc_mv_cs(byte *old_name, byte *new_name,int use_charset);
BOOLEAN pc_get_cwd_cs(byte *drive, byte *path, int use_charset);
BOOLEAN pc_pwd_cs(byte *drive, byte *path, int use_charset);
BOOLEAN pc_gfirst_cs(DSTAT *statobj, byte *name, int use_charset);
BOOLEAN pc_glast_cs(DSTAT *statobj, byte *name, int use_charset);
BOOLEAN pc_gnext_cs(DSTAT *statobj, int use_charset);
BOOLEAN pc_gprev_cs(DSTAT *statobj, int use_charset);
BOOLEAN pc_isdir_cs(byte *path, int use_charset);
BOOLEAN pc_isvol_cs(byte *path, int use_charset);
BOOLEAN pc_get_attributes_cs(byte *path, byte *p_return, int use_charset);
BOOLEAN pc_mkdir_cs(byte *name, int use_charset);
BOOLEAN pc_rmdir_cs(byte *name, int use_charset);
BOOLEAN pc_set_attributes_cs(byte *path, byte attributes, int use_charset);
BOOLEAN pc_set_cwd_cs(byte *name, int use_charset);
int pc_stat_cs(byte *name, ERTFS_STAT *pstat, int use_charset);
BOOLEAN pc_unlink_cs(byte *name, int use_charset);
int po_open_cs(byte *name, word flag, word mode, int use_charset);
int pc_get_default_drive_cs(byte *drive_name, int use_charset);
BOOLEAN pc_deltree_cs(byte *name, int use_charset);
int pc_enumerate_cs( /* __apifn__ */
byte * from_path_buffer,
byte * from_pattern_buffer,
byte * spath_buffer,
byte * dpath_buffer,
byte * root_search,
word match_flags,
byte * match_pattern,
int maxdepth,
PENUMCALLBACK pcallback,
int use_charset);
BOOLEAN pc_get_dirent_info_cs(byte *path, DIRENT_INFO *pinfo, int use_charset);
BOOLEAN pc_set_dirent_info_cs(byte *path, DIRENT_INFO *pinfo, int use_charset);
BOOLEAN pc_get_media_parms_cs(byte *path, PDEV_GEOMETRY pgeometry, int use_charset);
BOOLEAN pc_format_media_cs(byte *path, int use_charset);
BOOLEAN pc_format_volume_cs(byte *path, int use_charset);
BOOLEAN pc_format_volume_ex_cs(byte *path, RTFSFMTPARMSEX *pappfmt, int use_charset);
BOOLEAN pc_partition_media_cs(byte *path, struct mbr_specification *pmbrspec, int use_charset);
#else
/* Prototypes of Non-Unicode APIS */
BOOLEAN pc_get_volume(byte *driveid, byte *volume_label);
BOOLEAN pc_set_volume(byte *driveid, byte *volume_label);
BOOLEAN pc_mv(byte *old_name, byte *new_name);
BOOLEAN pc_get_cwd(byte *drive, byte *path);
BOOLEAN pc_pwd(byte *drive, byte *path);
BOOLEAN pc_gfirst(DSTAT *statobj, byte *name);
BOOLEAN pc_glast(DSTAT *statobj, byte *name);
BOOLEAN pc_gnext(DSTAT *statobj);
BOOLEAN pc_gprev(DSTAT *statobj);
BOOLEAN pc_isdir(byte *path);
BOOLEAN pc_isvol(byte *path);
BOOLEAN pc_get_attributes(byte *path, byte *p_return);
BOOLEAN pc_rmdir(byte *name);
BOOLEAN pc_mkdir(byte *name);
BOOLEAN pc_set_attributes(byte *path, byte attributes);
BOOLEAN pc_set_cwd(byte *name);
int pc_stat(byte *name, ERTFS_STAT *pstat);
BOOLEAN pc_unlink(byte *name);
int po_open(byte *name, word flag, word mode);
int pc_get_default_drive(byte *drive_name);
BOOLEAN pc_deltree(byte *name);
int pc_enumerate( /* __apifn__ */
byte * from_path_buffer,
byte * from_pattern_buffer,
byte * spath_buffer,
byte * dpath_buffer,
byte * root_search,
word match_flags,
byte * match_pattern,
int maxdepth,
PENUMCALLBACK pcallback);
BOOLEAN pc_get_dirent_info(byte *path, DIRENT_INFO *pinfo);
BOOLEAN pc_set_dirent_info(byte *path, DIRENT_INFO *pinfo);
BOOLEAN pc_get_media_parms(byte *path, PDEV_GEOMETRY pgeometry);
BOOLEAN pc_format_media(byte *path);
BOOLEAN pc_format_volume(byte *path);
BOOLEAN pc_format_volume_ex(byte *path, RTFSFMTPARMSEX *pappfmt);
BOOLEAN pc_partition_media(byte *path, struct mbr_specification *pmbrspec);
#endif
/* Versions of these entry points are provided by both Pro and ProPlus */
int rtfs_app_entry(void); /* Pro style See apirun.c */
int pc_ertfs_run(void); /* ProPlus style See apirun.c */
int _pc_ertfs_run(void);
void pc_ertfs_shutdown(void);
#if (INCLUDE_EXFATORFAT64)
#define FINODESIZEISZERO(P) ((!ISEXFATORFAT64(P->my_drive)&&P->fsizeu.fsize== 0)||(ISEXFATORFAT64(P->my_drive)&&M64ISZERO(P->fsizeu.fsize64)))
BOOLEAN pcexfat_format_volume(byte *path);
#else
#define FINODESIZEISZERO(P) (P->fsizeu.fsize == 0)
#endif
/* rtfs shell entry point */
void tst_shell(void);
void pc_free_disk_configuration(int drive_number);
int po_read(int fd, byte *in_buff, int count);
int po_write(int fd, byte *buf, int count);
BOOLEAN po_truncate(int fd, dword offset);
int po_chsize(int fd, dword offset);
BOOLEAN po_flush(int fd);
long po_lseek(int fd, long offset, int origin);
BOOLEAN po_ulseek(int fd, dword offset, dword *pnew_offset, int origin);
int po_close(int fd);
int pc_fstat(int fd, ERTFS_STAT *pstat);
BOOLEAN pc_check_automount(DDRIVE *pdr);
BOOLEAN _pc_diskflush(DDRIVE *pdrive);
long pc_free(byte *path, dword *blocks_total, dword *blocks_free);
BOOLEAN pc_raw_read(int driveno, byte *buf, dword blockno, dword nblocks, BOOLEAN raw);
BOOLEAN pc_raw_write(int driveno, byte *buf, dword blockno, dword nblocks, BOOLEAN raw);
/* apickdsk.c */
BOOLEAN pc_check_disk_ex(byte *drive_id, CHKDISK_STATS *pstat, dword chkdsk_opmode, CHKDSK_CONTEXT *pgl, void *scratch_memory, dword scratch_memory_size);
BOOLEAN pc_diskflush(byte *path); /* apidiskflush.c */
BOOLEAN pc_diskclose(byte *driveid, BOOLEAN clear_init);
BOOLEAN pc_diskio_free_list(byte *drivename, int listsize, FREELISTINFO *plist, dword startcluster, dword endcluster, dword threshhold);
BOOLEAN pc_diskio_info(byte *drive_name, DRIVE_INFO *pinfo, BOOLEAN extended);
BOOLEAN pc_diskio_runtime_stats(byte *drive_name, DRIVE_RUNTIME_STATS *pstats, BOOLEAN clear);
int pc_get_file_extents(int fd, int infolistsize, FILESEGINFO *plist, BOOLEAN report_clusters, BOOLEAN raw);
void pc_calculate_chs(dword total, dword *cylinders, int *heads, int *secptrack);/* apifrmat.c */
void pc_gdone(DSTAT *statobj);
BOOLEAN pc_gread(DSTAT *statobj, int blocks_to_read, byte *buffer, int *blocks_read);
BOOLEAN pc_set_default_drive(byte *drive); /* apiinfo.c */
BOOLEAN pc_blocks_free(byte *path, dword *blocks_total, dword *blocks_free);
int pc_cluster_size(byte *drive);
int pc_sector_size(byte *drive);
void pc_drno_to_drname(int driveno, byte *pdrive_name, int use_charset);
int pc_drname_to_drno(byte *drive_name, int use_charset);
int pc_fd_to_driveno(int fd,byte *pdrive_name, int use_charset);
BOOLEAN pc_ertfs_init(void); /* apiinit.c */
BOOLEAN pc_regression_test(byte *driveid, BOOLEAN do_clean);/* apiregress.c */
void pc_finode_stat(FINODE *pi, ERTFS_STAT *pstat);
void rtfs_print_string_1(byte *pstring ,int flags); /* rttermin.c */
void rtfs_print_string_2(byte *pstring,byte *pstr2, int flags);
void rtfs_print_long_1(dword l,int flags);
void rtfs_print_one_string(byte *pstr,int flags);
byte *pc_ltoa(dword num, byte *dest, int number_base);
#if (INCLUDE_CS_UNICODE)
void map_jis_ascii_to_unicode(byte *unicode_to, byte *ascii_from);
BOOLEAN map_unicode_to_jis_ascii(byte *to, byte *from);
#endif
void rtfs_cs_char_copy(byte *to, byte *from, int use_charset);
byte *rtfs_cs_increment(byte *p, int use_charset);
int rtfs_cs_compare(byte *p1, byte *p2, int use_charset);
int rtfs_cs_compare_nc(byte *p1, byte *p2, int use_charset);
int rtfs_cs_ascii_index(byte *p, byte base, int use_charset);
void rtfs_cs_to_unicode(byte *to, byte *p, int use_charset);
void rtfs_cs_unicode_to_cs(byte *to, byte *punicode, int use_charset);
BOOLEAN rtfs_cs_is_eos(byte *p, int use_charset);
BOOLEAN rtfs_cs_is_not_eos(byte *p, int use_charset);
void rtfs_cs_term_string(byte *p, int use_charset);
int rtfs_cs_cmp_to_ascii_char(byte *p, byte c, int use_charset);
void rtfs_cs_assign_ascii_char(byte *p, byte c, int use_charset);
byte *rtfs_cs_goto_eos(byte *p, int use_charset);
BOOLEAN rtfs_cs_ascii_fileparse(byte *filename, byte *fileext, byte *p);
byte *pc_cs_mfile(byte *to, byte *filename, byte *ext, int use_charset);
byte *pc_cs_mfileNT(byte *to, byte *filename, byte *ext, int use_charset, byte ntflags);
byte *rtfs_cs_strcat(byte * targ, byte * src, int use_charset);
int rtfs_cs_strcmp(byte * s1, byte * s2, int use_charset);
int rtfs_cs_strcpy(byte * targ, byte * src, int use_charset);
int rtfs_cs_strlen(byte * string, int use_charset);
void pc_cs_ascii_str2upper(byte *to, byte *from);
void pc_cs_ascii_strn2upper(byte *to, byte *from, int n);
BOOLEAN pc_cs_malias(byte *alias, byte *input_file, int which_try, int use_charset);
BOOLEAN pc_cs_valid_sfn(byte *filename, BOOLEAN case_sensitive);
BOOLEAN pc_cs_validate_filename(byte * name, byte * ext, int use_charset);
BOOLEAN pc_cs_validate_8_3_name(byte * name,int len);
BOOLEAN rtfs_cs_patcmp_8(byte *p, byte *pattern, BOOLEAN dowildcard);
dword pc_finode_cluster(DDRIVE *pdr, FINODE *finode); /* rtcomonglue.c */
void pc_pfinode_cluster(DDRIVE *pdr, FINODE *finode, dword value);
dword pc_get_parent_cluster(DDRIVE *pdrive, DROBJ *pobj);
dword pc_alloc_dir(DDRIVE *pdrive, DROBJ *pmom);
dword pc_grow_dir(DDRIVE *pdrive, DROBJ *pobj, dword *previous_end);
int _pc_file_open(DDRIVE *pdrive, byte *name, word flag, word mode, dword extended, BOOLEAN *created, int use_charset);
BOOLEAN pc_alloc_path_buffers(DDRIVE *pdrive);
void pc_release_path_buffers(DDRIVE *pdrive);
PC_FILE *pc_fd2file(int fd,int flags);
PC_FILE *pc_allocfile(void);
void pc_freefile(PC_FILE *pfile);
BOOLEAN pc_load_file_buffer(FINODE *pfinode, dword new_blockno, BOOLEAN read_buffer);
void pc_release_file_buffer(BLKBUFF *pblk);
BOOLEAN pc_buffered_fileio(FINODE *pfinode, dword start_sector, dword start_byte_offset, dword n_todo, byte *pdata, BOOLEAN reading, BOOLEAN appending);
BOOLEAN pc_flush_file_buffer(FINODE *pfinode);
dword pc_get_media_sector_size(DDRIVE *pdr);
int pc_enum_file(DDRIVE *pdrive, int chore);
void pc_free_all_fil(DDRIVE *pdrive);
BOOLEAN pc_flush_all_fil(DDRIVE *pdrive);
void pc_release_all_prealloc(DDRIVE *pdrive);
int pc_test_all_fil(DDRIVE *pdrive);
BOOLEAN pc_init_drv_fat_info16(DDRIVE *pdr, struct pcblk0 *pbl0);
dword pc_byte2clmod(DDRIVE *pdr, dword nbytes);
dword pc_alloced_bytes_from_clusters(DDRIVE *pdr, dword total_alloced_clusters);
void pc_set_file_dirty(PC_FILE * pfile, BOOLEAN isdirty); /* rtconditionalglue.c */
byte *pc_claim_user_buffer(DDRIVE *pdr, dword *pbuffer_size_blocks, dword minimimum_size_sectors);
void pc_release_user_buffer(DDRIVE *pdr, byte *pbuffer);
BOOLEAN pc_check_file_dirty(PC_FILE * pfile);
void pc_set_file_buffer_dirty(FINODE *pfinode, BOOLEAN isdirty);
BOOLEAN pc_check_file_buffer_dirty(FINODE *pfinode);
void set_fat_dirty(DDRIVE *pdr);
void clear_fat_dirty(DDRIVE *pdr);
BOOLEAN chk_fat_dirty(DDRIVE *pdr);
void set_mount_abort_status(DDRIVE *pdr);
void clear_mount_valid(DDRIVE *pdr);
void clear_mount_abort(DDRIVE *pdr);
void set_mount_valid(DDRIVE *pdr);
BOOLEAN chk_mount_abort(DDRIVE *pdr);
BOOLEAN chk_mount_valid(DDRIVE *pdr);
BOOLEAN pc_update_inode(DROBJ *pobj, BOOLEAN set_archive, int set_date_mask);
FINODE *pc_file2_finode(PC_FILE * pfile);
BOOLEAN pc_force_file_flush(PC_FILE * pfile);
BOOLEAN block_devio_read(DDRIVE *pdrive, dword blockno, byte * buf); /* rtdblock.c */
BOOLEAN block_devio_write(BLKBUFF *pblk);
BOOLEAN block_devio_xfer(DDRIVE *pdrive, dword blockno, byte * buf, dword n_to_xfer, BOOLEAN reading);
BLKBUFF *pc_allocate_blk(DDRIVE *pdrive, BLKBUFFCNTXT *pbuffcntxt);
void pc_release_buf(BLKBUFF *pblk);
void pc_discard_buf(BLKBUFF *pblk);
BLKBUFF *pc_read_blk(DDRIVE *pdrive, dword blockno);
BLKBUFF *pc_sys_sector(DDRIVE *pdr, BLKBUFF *pscratch_buff);
BLKBUFF *pc_scratch_blk(void);
void pc_free_sys_sector(BLKBUFF *pblk);
void pc_free_scratch_blk(BLKBUFF *pblk);
BLKBUFF *pc_init_blk(DDRIVE *pdrive, dword blockno);
void pc_free_all_blk(DDRIVE *pdrive);
BOOLEAN pc_write_blk(BLKBUFF *pblk);
BLKBUFF *pc_find_blk(DDRIVE *pdrive, dword blockno);
void pc_flush_chain_blk(DDRIVE *pdrive, dword cluster);
void pc_initialize_block_pool(BLKBUFFCNTXT *pbuffcntxt, int nblkbuffs, BLKBUFF *pmem_block_pool, byte *raw_buffer_space, dword data_size_bytes);
void debug_check_blocks(BLKBUFFCNTXT *pbuffcntxt, int numblocks, char *where, dword line);
void display_free_lists(char *in_where);
void check_blocks(DDRIVE *pdrive, char *prompt, dword line);
int check_drive_name_mount(byte *name, int use_charset); /* rtdevio.c */
BOOLEAN check_drive_number_mount(int driveno);
DDRIVE *check_drive_by_name(byte *name, int use_charset);
DDRIVE *check_drive_by_number(int driveno, BOOLEAN check_mount);
void release_drive_mount(int driveno);
BOOLEAN release_drive_mount_write(int driveno);
BOOLEAN raw_devio_xfer(DDRIVE *pdr, dword blockno, byte * buf, dword n_to_xfer, BOOLEAN raw, BOOLEAN reading);
DROBJ *_pc_get_user_cwd(DDRIVE *pdrive); /* rtdrobj.c */
DROBJ *pc_fndnode(byte *path, int use_charset);
DROBJ *pc_get_inode( DROBJ *pobj, DROBJ *pmom, byte *filename, byte *fileext, int action, int use_charset);
DROBJ *pc_rget_inode( DROBJ *pobj, DROBJ *pmom, byte *filename, byte *fileext, int action, int use_charset);
DROBJ *pc_get_mom(DROBJ *pdotdot);
DROBJ *pc_mkchild( DROBJ *pmom);
#if (INCLUDE_EXFATORFAT64)
/* Note: This is a new way of doing things for all. Leave conditional until testing is completer */
DROBJ *pc_mknode(DROBJ *pmom ,byte *filename, byte *fileext, byte attributes, FINODE *infinode,int use_charset);
#else
DROBJ *pc_mknode(DROBJ *pmom ,byte *filename, byte *fileext, byte attributes, dword incluster,int use_charset);
#endif
void pc_init_directory_cluster(DROBJ *pobj, byte *pbuffer);
BOOLEAN pc_rmnode( DROBJ *pobj);
void pc_update_finode_datestamp(FINODE *pfinode, BOOLEAN set_archive, int set_date_mask);
BOOLEAN pc_update_by_finode(FINODE *pfinode, int entry_index, BOOLEAN set_archive, int set_date_mask);
void pc_init_inode(FINODE *pdir, KS_CONSTANT byte *filename,
KS_CONSTANT byte *fileext, byte attr,
dword cluster, dword size, DATESTR *crdate);
void pc_ino2dos (DOSINODE *pbuff, FINODE *pdir);
DROBJ *pc_get_root( DDRIVE *pdrive);
dword pc_firstblock( DROBJ *pobj);
BOOLEAN pc_next_block( DROBJ *pobj);
dword pc_l_next_block(DDRIVE *pdrive, dword curblock);
void pc_marki( FINODE *pfi, DDRIVE *pdrive, dword sectorno, int index);
FINODE *pc_scani( DDRIVE *pdrive, dword sectorno, int index);
DROBJ *pc_allocobj(void);
FINODE *pc_alloci(void);
void pc_free_all_drobj( DDRIVE *pdrive);
void pc_free_all_i( DDRIVE *pdrive);
void pc_freei(FINODE *pfi);
void pc_freeobj( DROBJ *pobj);
void pc_dos2inode (FINODE *pdir, DOSINODE *pbuff);
BOOLEAN pc_isavol( DROBJ *pobj);
BOOLEAN pc_isadir( DROBJ *pobj);
BOOLEAN pc_isroot( DROBJ *pobj);
BOOLEAN pc_init_drv_fat_info32(DDRIVE *pdr, struct pcblk0 *pbl0); /* rtfat32.c */
BOOLEAN pc_mkfs32(int driveno, FMTPARMS *pfmt, BOOLEAN use_raw);
BOOLEAN pc_gblk0_32(DDRIVE *pdr, struct pcblk0 *pbl0, byte *b);
BOOLEAN pc_validate_partition_type(byte p_type);
BOOLEAN fat_flushinfo(DDRIVE *pdr);
/* rtfatdrvrd.c */
BOOLEAN fatop_check_freespace(DDRIVE *pdr);
void fatop_close_driver(DDRIVE *pdr);
BOOLEAN fatop_get_cluster(DDRIVE *pdr, dword clno, dword *pvalue);
dword fatop_next_cluster(DDRIVE *pdr, dword cluster);
BOOLEAN fatop_add_free_region(DDRIVE *pdr, dword cluster, dword ncontig, BOOLEAN do_erase);
dword fatop_get_frag_async(DDRIVE *pdr, byte *palt_buffer, dword alt_buffer_size, dword startpt, dword *pnext_cluster, dword n_clusters, int *end_of_chain);
dword fatop_get_frag(DDRIVE *pdr, byte *palt_buffer, dword alt_buffer_size, dword startpt, dword *pnext_cluster, dword n_clusters, int *end_of_chain);
int fatop_page_continue_check_freespace(DDRIVE *pdr);
void fatop_page_start_check_freespace(DDRIVE *pdr);
byte * fatxx_pfswap(DDRIVE *pdr, dword index, BOOLEAN for_write);
void fatop_get_page_masks(DDRIVE *pdr, dword *mask_offset, dword *mask_cl_page, dword *cl_per_block, dword *cl_to_page_shift, dword * bytes_per_entry);
BOOLEAN fatxx_fword(DDRIVE *pdr, dword index, word *pvalue, BOOLEAN putting);
/* rtfatdrvwr.c */
dword fatop_alloc_chain(DDRIVE *pdr, BOOLEAN is_file, dword hint_cluster, dword previous_end, dword *pfirst_new_cluster, dword n_clusters, dword min_clusters);
dword fatop_grow_dir(DDRIVE *pdr, dword previous_end);
dword fatop_alloc_dir(DDRIVE *pdr, dword clhint);
dword fatop_clgrow(DDRIVE *pdr, dword clno, dword *previous_end);
void fatop_truncate_dir(DDRIVE *pdr, DROBJ *pobj, dword cluster, dword previous_end);
void fatop_clrelease_dir(DDRIVE *pdr, dword clno);
BOOLEAN fatop_freechain(DDRIVE *pdr, dword cluster, dword max_clusters_to_free);
BOOLEAN fatop_free_frag(DDRIVE *pdr, dword flags, dword prev_cluster, dword startpt, dword n_contig);
BOOLEAN fatop_remove_free_region(DDRIVE *pdr, dword cluster, dword ncontig);
BOOLEAN fatop_flushfat(DDRIVE *pdr);
BOOLEAN fatop_link_frag(DDRIVE *pdr, byte *palt_buffer, dword alt_buffer_size, dword flags, dword cluster, dword startpt, dword n_contig);
dword fatop_find_contiguous_free_clusters(DDRIVE *pdr, dword startpt, dword endpt, dword min_clusters, dword max_clusters, dword *p_contig, int *is_error, int allocation_scheme);
dword _fatop_find_contiguous_free_clusters(DDRIVE *pdr, dword startpt, dword endpt, dword min_clusters, dword max_clusters, dword *p_contig, int *is_error);
BOOLEAN fatop_pfaxxterm(DDRIVE *pdr, dword clno);
BOOLEAN fatop_pfaxx(DDRIVE *pdr, dword clno, dword value);
#if (INCLUDE_NAND_DRIVER)
/* rteraseblock.c */
BOOLEAN eraseop_erase_blocks(DDRIVE *pdr, dword cluster, dword ncontig);
dword eraseop_find_free_clusters(DDRIVE *pdr, dword startpt, dword endpt, dword min_clusters, dword max_clusters, int allocation_scheme, dword *p_contig, int *is_error);
#endif
/* drdynamic.c */
void pc_rtfs_poll_devices_ready(void);
BOOLEAN pc_rtfs_media_remount(void *devicehandle);
void pc_rtfs_regen_insert_parms(struct rtfs_media_insert_args *prtfs_insert_parms, RTFS_DEVI_MEDIA_PARMS *pmedia_info);
byte *pc_rtfs_iomalloc(dword alloc_size, void **paligned_data);
BOOLEAN rtfs_dynamic_init_configuration(struct rtfs_init_resource_reply *preply);
BOOLEAN RTFS_DEVI_process_mount_parms(DDRIVE *pdr);
BLKBUFF *RTFS_DEVI_alloc_filebuffer(DDRIVE *pdr);
void RTFS_DEVI_release_filebuffer(BLKBUFF *pblk);
BOOLEAN fat_devio_write(DDRIVE *pdrive, dword fat_blockno, dword nblocks, byte *fat_data, int fatnumber); /* rtfblock.c */
BOOLEAN fat_devio_read(DDRIVE *pdrive, dword blockno,dword nblocks, byte *fat_data);
BOOLEAN pc_flush_fat_blocks(DDRIVE *pdrive);
BOOLEAN pc_write_fat_blocks(DDRIVE *pdrive,dword fat_blockno, dword nblocks, byte *fat_data,dword which_copy);
BOOLEAN pc_write_fat_block_buffer_page(DDRIVE *pdrive, FATBUFF *pblk);
int pc_read_fat_blocks (DDRIVE* pdrive, byte* buffer, dword first_block, dword num_blocks);
BOOLEAN pc_initialize_fat_block_pool(FATBUFFCNTXT *pfatbuffcntxt,
int fat_buffer_size, FATBUFF *pfat_buffers,
int fat_hashtbl_size, FATBUFF **pfat_hash_table,
byte **pfat_primary_cache, dword *pfat_primary_index);
void pc_free_all_fat_buffers(DDRIVE *pdrive);
byte *pc_map_fat_stream(DDRIVE *pdrive, dword *return_block_count, dword first_block, dword byte_offset, dword byte_count, byte *alt_buffer, dword alt_buffer_size, BOOLEAN is_a_read);
byte *pc_map_fat_sector(DDRIVE *pdrive, FATBUFFCNTXT *pfatbuffcntxt,dword blockno, int n_dirty, dword usage_flags);
int pc_async_flush_fat_blocks(DDRIVE *pdrive,dword max_flushes_per_pass);
void pc_set_mbuff_dirty(PCMBUFF *pcmb, dword block_offset, int block_count);
void pc_zero_mbuff_dirty(PCMBUFF *pcmb);
BOOLEAN rtfs_resource_init(void); /* rtkernfn.c */
void pc_rtfs_register_poll_devices_ready_handler(RTFS_DEVI_POLL_REQUEST_VECTOR *poll_device_vector, void (*poll_device_ready)(void));
DDRIVE *rtfs_claim_media_and_buffers(int driveno);
void rtfs_release_media_and_buffers(int driveno);
DROBJ *rtfs_get_user_pwd(RTFS_SYSTEM_USER *pu,int driveno, BOOLEAN doclear);
void rtfs_set_user_pwd(RTFS_SYSTEM_USER *pu, DROBJ *pobj);
PRTFS_SYSTEM_USER rtfs_get_system_user(void);
void pc_free_user(void);
void pc_free_other_user(dword taskId);
void pc_free_all_users(int driveno);
void rtfs_set_driver_errno(dword error);
dword rtfs_get_driver_errno(void);
void rtfs_clear_errno(void);
void _rtfs_set_errno(int error);
void _debug_rtfs_set_errno(int error, char *filename, long linenumber);
int get_errno(void);
int pc_num_drives(void);
int pc_num_users(void);
int pc_nuserfiles(void);
BOOLEAN pc_validate_driveno(int driveno);
BOOLEAN pc_memory_init(void);
DDRIVE *pc_memory_ddrive(DDRIVE *pdrive);
DROBJ *pc_memory_drobj(DROBJ *pobj);
FINODE *pc_memory_finode(FINODE *pinode);
void rtfs_kern_gets(byte *buffer);
void rtfs_kern_puts(byte *buffer);
int rtfs_debug_zero(void);
void rtfs_assert_break(void);
void rtfs_assert_test(void);
BOOLEAN pc_i_dskopen(int driveno, BOOLEAN is_async); /* rtlowl.c */
void pc_drive_scaleto_blocksize(DDRIVE *pdr, int bytspsector);
BOOLEAN pc_auto_dskopen(DDRIVE *pdr);
void pc_i_dskopen_complete(DDRIVE *pdr);
int pc_read_partition_table(DDRIVE *pdr, struct mbr_entry_specification *pspec);
BOOLEAN pc_gblk0(DDRIVE *pdr, struct pcblk0 *pbl0);
BOOLEAN pc_clzero(DDRIVE *pdrive, dword cluster);
DDRIVE *pc_drno_to_drive_struct(int driveno);
DDRIVE *pc_drno2dr(int driveno);
BOOLEAN pc_dskfree(int driveno);
dword pc_sec2cluster(DDRIVE *pdrive, dword blockno);
dword pc_sec2index(DDRIVE *pdrive, dword blockno);
dword pc_cl2sector(DDRIVE *pdrive, dword cluster);
/* rtvfatrd.c rtnvfatrd.c */
BOOLEAN pc_findin( DROBJ *pobj, byte *filename, byte *fileext, int action, int use_charset);
BOOLEAN pc_rfindin( DROBJ *pobj, byte *filename, int action, int use_charset, BOOLEAN starting);
byte *pc_nibbleparse(byte *filename, byte *fileext, byte *path, int use_charset);
BOOLEAN pc_parsepath(byte *topath, byte *filename, byte *fileext, byte *path, int use_charset);
BOOLEAN pc_patcmp_vfat(byte *in_pat, byte *name, BOOLEAN dowildcard, int use_charset);
byte pc_cksum(byte *test);
BOOLEAN pc_isdot(byte *fname, byte *fext);
BOOLEAN pc_isdotdot(byte *fname, byte *fext);
BOOLEAN pc_get_lfn_filename(DROBJ *pobj, byte *path, int use_charset);
BOOLEAN pc_multi_dir_get(DROBJ *pobj, BLKBUFF **pscan_buff, byte **pscan_data, byte *puser_buffer, dword *n_blocks, BOOLEAN do_increment);
/* rtvfatwr.c and rtnvfatwr.c */
BOOLEAN pc_insert_inode(DROBJ *pobj , DROBJ *pmom, byte attr, dword initcluster, byte *filename, byte *fileext, int use_charset);
void pc_zero_lfn_info(FINODE *pdir);
BOOLEAN _illegal_lfn_char(byte ch);
BOOLEAN pc_delete_lfn_info(DROBJ *pobj);
/* rtfreemanager.c */
BOOLEAN free_manager_attach(DDRIVE *pdr);
BOOLEAN free_manager_is_attached(DDRIVE *pdr);
dword free_manager_count_frags(DDRIVE *pdr);
void free_manager_close(DDRIVE *pdr);
void free_manager_revert(DDRIVE *pdr);
dword free_manager_find_contiguous_free_clusters(DDRIVE *pdr, dword startpt, dword endpt, dword min_clusters, dword max_clusters, dword *p_contig, int *is_error);
BOOLEAN free_manager_release_clusters(DDRIVE *pdr, dword cluster, dword ncontig, BOOLEAN do_erase);
void free_manager_claim_clusters(DDRIVE *pdr, dword cluster, dword ncontig);
/* rtfragmt.c */
void pc_fraglist_init_freelist(void);
dword pc_fraglist_count_clusters(REGION_FRAGMENT *pf,REGION_FRAGMENT *pfend);
REGION_FRAGMENT *pc_end_fragment_chain(REGION_FRAGMENT *pf);
REGION_FRAGMENT *pc_fraglist_frag_alloc(DDRIVE *pdr, dword frag_start,
dword frag_end,
REGION_FRAGMENT *pnext);
void pc_fraglist_frag_free(REGION_FRAGMENT *pf);
void pc_fraglist_free_list(REGION_FRAGMENT *pf);
REGION_FRAGMENT *pc_fraglist_set_range(REGION_FRAGMENT *inpf, dword start_location, dword end_location, int *is_error);
REGION_FRAGMENT *pc_fraglist_clear_range(REGION_FRAGMENT *inpf, dword start_location, dword end_location, int *is_error);
dword pc_fragment_size_32(DDRIVE *pdr, REGION_FRAGMENT *pf);
BOOLEAN pc_grow_basic_fragment(FINODE *pefinode, dword first_new_cluster, dword nclusters);
/* rtutbyte.c */
BOOLEAN pc_check_dir_end(byte *fname);
byte *pc_strchr(byte *string, byte ch);
BOOLEAN _illegal_alias_char(byte ch);
void copybuff(void *vto, void *vfrom, int size);
void pc_cppad(byte *to, byte *from, int size);
void rtfs_memset(void *pv, byte b, int n);
BOOLEAN rtfs_bytecomp(byte *p1, byte *p2, int n);
int pc_path_to_driveno(byte *path, int use_charset); /* rtutil.c */
int pc_parse_raw_drive(byte *path, int use_charset);
byte *pc_parsedrive(int *driveno, byte *path, int use_charset);
byte *pc_mpath(byte *to, byte *path, byte *filename, int use_charset);
BOOLEAN pc_search_csl(byte *set, byte *string);
BOOLEAN name_is_reserved(byte *filename);
void RTFS_ARGSUSED_PVOID(void * p);
void RTFS_ARGSUSED_INT(int i);
void RTFS_ARGSUSED_DWORD(dword l);
dword to_DWORD( byte *from);
word to_WORD( byte *from);
void fr_WORD( byte *to, word from);
void fr_DWORD( byte *to, dword from);
#if (INCLUDE_MATH64)
void to_DDWORD(ddword *to, byte *from);
void fr_DDWORD( byte *to, ddword from);
ddword m64_native_set32(dword a, dword b);
ddword m64_lshift(ddword b, dword c);
ddword m64_rshift(ddword b, dword c);
ddword m64_minus(ddword b, ddword c);
ddword m64_minus32(ddword b, dword c);
ddword m64_plus(ddword b, ddword c);
ddword m64_plus32(ddword b, dword c);
ddword m64_set32(dword hi, dword lo);
#endif
void *rtfs_port_malloc(int nbytes); /* portkern.c (target specific) */
void rtfs_port_free(void *pbytes);
dword rtfs_port_alloc_mutex(char *mutex_name);
void rtfs_port_free_mutex(dword handle);
void rtfs_port_claim_mutex(dword handle);
void rtfs_port_release_mutex(dword handle);
dword rtfs_port_alloc_signal(void);
void rtfs_port_shutdown(void);
void rtfs_port_set_task_env(void *pusercontext);
void *rtfs_port_get_task_env(dword taskId);
void rtfs_port_clear_signal(dword handle);
int rtfs_port_test_signal(dword handle, int timeout);
void rtfs_port_set_signal(dword handle);
void rtfs_port_sleep(int sleeptime);
dword rtfs_port_elapsed_zero(void);
int rtfs_port_elapsed_check(dword zero_val, int timeout);
dword rtfs_port_get_taskid(void);
void rtfs_port_disable(void);
void rtfs_port_enable(void);
void rtfs_port_exit(void);
DATESTR *pc_getsysdate(DATESTR * pd);
/* In prefiocom but should be global for Pro */
dword truncate_32_count(dword file_pointer, dword count);
dword truncate_32_sum(dword val1, dword val2);
#ifdef __cplusplus
}
#endif
/* =========================== */
/* End Rtfs internal prototypes */
/* =========================== */
#define rtfs_set_errno(ERROR,CALLER, LINENUMBER) _debug_rtfs_set_errno(ERROR, CALLER, LINENUMBER)
#if (INCLUDE_DEBUG_RUNTIME_STATS)
#define UPDATE_RUNTIME_STATS(DRIVE, FIELD, COUNT) DRIVE->drive_rtstats.FIELD += COUNT;
#else
#define UPDATE_RUNTIME_STATS(DRIVE, FIELD, COUNT)
#endif
#if (INCLUDE_CS_UNICODE)
/* Unicode API */
#define pc_mv_uc(A,B) pc_mv_cs((A),(B),CS_CHARSET_UNICODE)
#define pc_get_volume_uc(A,B) pc_get_volume_cs((A),(B),CS_CHARSET_UNICODE)
#define pc_set_volume_uc(A,B) pc_set_volume_cs((A),(B),CS_CHARSET_UNICODE)
#define pc_get_cwd_uc(A,B) pc_get_cwd_cs((A),(B),CS_CHARSET_UNICODE)
#define pc_pwd_uc(A,B) pc_pwd_cs((A),(B),CS_CHARSET_UNICODE)
#define pc_gfirst_uc(A,B) pc_gfirst_cs((A),(B),CS_CHARSET_UNICODE)
#define pc_glast_uc(A,B) pc_glast_cs((A),(B),CS_CHARSET_UNICODE)
#define pc_gnext_uc(A) pc_gnext_cs((A),CS_CHARSET_UNICODE)
#define pc_gprev_uc(A) pc_gprev_cs((A),CS_CHARSET_UNICODE)
#define pc_isdir_uc(A) pc_isdir_cs((A),CS_CHARSET_UNICODE)
#define pc_isvol_uc(A) pc_isvol_cs((A),CS_CHARSET_UNICODE)
#define pc_get_attributes_uc(A,B) pc_get_attributes_cs((A),(B),CS_CHARSET_UNICODE)
#define pc_mkdir_uc(A) pc_mkdir_cs((A),CS_CHARSET_UNICODE)
#define pc_rmdir_uc(A) pc_rmdir_cs((A),CS_CHARSET_UNICODE)
#define pc_set_attributes_uc(A,B) pc_set_attributes_cs((A),(B),CS_CHARSET_UNICODE)
#define pc_set_cwd_uc(A) pc_set_cwd_cs((A),CS_CHARSET_UNICODE)
#define pc_stat_uc(A,B) pc_stat_cs((A),(B),CS_CHARSET_UNICODE)
#define pc_unlink_uc(A) pc_unlink_cs((A),CS_CHARSET_UNICODE)
#define po_open_uc(A,B,C) po_open_cs((A),(B),(C), CS_CHARSET_UNICODE)
#define pc_get_default_drive_uc(A) pc_get_default_drive_cs((A), CS_CHARSET_UNICODE)
#define pc_deltree_uc(A) pc_deltree_cs((A),CS_CHARSET_UNICODE)
#define pc_enumerate_uc(A,B,C,D,E,F,G,H,I) pc_enumerate_cs((A),(B),(C),(D),(E),(F),(G),(H),(I),CS_CHARSET_UNICODE)
#define pc_get_dirent_info_uc(A,B) pc_get_dirent_info_cs((A),(B),CS_CHARSET_UNICODE)
#define pc_set_dirent_info_uc(A,B) pc_set_dirent_info_cs((A),(B),CS_CHARSET_UNICODE)
#define pc_get_media_parms_uc(A,B) pc_get_media_parms_cs((A),(B),CS_CHARSET_UNICODE)
#define pc_format_media_uc(A) pc_format_media_cs((A),CS_CHARSET_UNICODE)
#define pc_format_volume_uc(A) pc_format_volume_cs((A),CS_CHARSET_UNICODE)
#define pc_format_volume_ex_uc(A, B) pc_format_volume_ex_cs((A), (B), CS_CHARSET_UNICODE)
#define pc_partition_media_uc(A,B) pc_partition_media_cs((A),(B), CS_CHARSET_UNICODE)
/* Non-Unicode API */
#define pc_mv(A,B) pc_mv_cs((A),(B),CS_CHARSET_NOT_UNICODE)
#define pc_get_volume(A,B) pc_get_volume_cs((A),(B),CS_CHARSET_NOT_UNICODE)
#define pc_set_volume(A,B) pc_set_volume_cs((A),(B),CS_CHARSET_NOT_UNICODE)
#define pc_get_cwd(A,B) pc_get_cwd_cs((A),(B),CS_CHARSET_NOT_UNICODE)
#define pc_pwd(A,B) pc_pwd_cs((A),(B),CS_CHARSET_NOT_UNICODE)
#define pc_gfirst(A,B) pc_gfirst_cs((A),(B),CS_CHARSET_NOT_UNICODE)
#define pc_glast(A,B) pc_glast_cs((A),(B),CS_CHARSET_NOT_UNICODE)
#define pc_gnext(A) pc_gnext_cs((A) ,CS_CHARSET_NOT_UNICODE)
#define pc_gprev(A) pc_gprev_cs((A) ,CS_CHARSET_NOT_UNICODE)
#define pc_isdir(A) pc_isdir_cs((A),CS_CHARSET_NOT_UNICODE)
#define pc_isvol(A) pc_isvol_cs((A),CS_CHARSET_NOT_UNICODE)
#define pc_get_attributes(A,B) pc_get_attributes_cs((A),(B),CS_CHARSET_NOT_UNICODE)
#define pc_mkdir(A) pc_mkdir_cs((A),CS_CHARSET_NOT_UNICODE)
#define pc_rmdir(A) pc_rmdir_cs((A),CS_CHARSET_NOT_UNICODE)
#define pc_set_attributes(A,B) pc_set_attributes_cs((A), (B),CS_CHARSET_NOT_UNICODE)
#define pc_set_cwd(A) pc_set_cwd_cs((A),CS_CHARSET_NOT_UNICODE)
#define pc_stat(A,B) pc_stat_cs((A),(B),CS_CHARSET_NOT_UNICODE)
#define pc_unlink(A) pc_unlink_cs((A),CS_CHARSET_NOT_UNICODE)
#define po_open(A,B,C) po_open_cs((A),(B),(C), CS_CHARSET_NOT_UNICODE)
#define pc_get_default_drive(A) pc_get_default_drive_cs((A), CS_CHARSET_NOT_UNICODE)
#define pc_deltree(A) pc_deltree_cs((A),CS_CHARSET_NOT_UNICODE)
#define pc_enumerate(A,B,C,D,E,F,G,H,I) pc_enumerate_cs((A),(B),(C),(D),(E),(F),(G),(H),(I),CS_CHARSET_NOT_UNICODE)
#define pc_get_dirent_info(A,B) pc_get_dirent_info_cs((A),(B),CS_CHARSET_NOT_UNICODE)
#define pc_set_dirent_info(A,B) pc_set_dirent_info_cs((A),(B),CS_CHARSET_NOT_UNICODE)
#define pc_get_media_parms(A,B) pc_get_media_parms_cs((A),(B),CS_CHARSET_NOT_UNICODE)
#define pc_format_media(A) pc_format_media_cs((A),CS_CHARSET_NOT_UNICODE)
#define pc_format_volume(A) pc_format_volume_cs((A),CS_CHARSET_NOT_UNICODE)
#define pc_format_volume_ex(A, B) pc_format_volume_ex_cs((A), (B), CS_CHARSET_NOT_UNICODE)
#define pc_partition_media(A,B) pc_partition_media_cs((A),(B), CS_CHARSET_NOT_UNICODE)
#endif
#if (INCLUDE_CS_UNICODE)
#define CS_CHARSET_ARGS use_charset /* Extracts character set from passed parameters */
#else
#define CS_CHARSET_ARGS CS_CHARSET_NOT_UNICODE /* Default character set do not change */
#endif
#if (INCLUDE_RTFS_PROPLUS) /* Include additional ProPlus internal declarations */
/* =========================== */
/* RtfsProPlus prototypes */
/* =========================== */
#ifdef __cplusplus
extern "C" {
#endif
/* ============================ */
/* ProPlus API Prototypes */
/* ============================ */
#if (INCLUDE_CS_UNICODE)
/* Prototypes of unicode / Non-Unicode selectable APIS */
int pc_cfilio_open_cs(byte *name, word flag, EFILEOPTIONS *poptions,int use_charset);
int pc_efilio_async_unlink_start_cs(byte *filename,int use_charset);
int pc_efilio_open_cs(byte *name, word flag, word mode, EFILEOPTIONS *poptions, int use_charset);
#else
/* Prototypes of Non-Unicode APIS */
int pc_cfilio_open(byte *name, word flag, EFILEOPTIONS *poptions);
int pc_efilio_async_unlink_start(byte *filename);
int pc_efilio_open(byte *name, word flag, word mode, EFILEOPTIONS *poptions);
#endif
/* rtfsproplustests\efishell.c */
void efio_shell(void);
/* rtfsproplus\prapiasy.c */
int pc_async_continue(int driveno, int target_state, int steps);
int pc_diskio_async_flush_start(byte *path);
int pc_diskio_async_mount_start(byte *diskid);
int pc_efilio_async_flush_start(int fd);
int pc_efilio_async_close_start(int fd);
/* rtfsproplus\prapiefi.c */
BOOLEAN pc_efilio_settime(int fd,word new_time, word new_date);
BOOLEAN pc_efilio_flush(int fd);
BOOLEAN pc_efilio_lseek(int fd, dword offset_hi, dword offset_lo, int origin, dword *pnewoffset_hi, dword *pnewoffset_lo);
#if (INCLUDE_MATH64)
ddword pc_efilio_lseek64(int fd, ddword offset, int origin);
#endif
BOOLEAN pc_efilio_chsize(int fd, dword newsize_hi, dword newsize_lo);
BOOLEAN pc_efilio_read(int fd, byte *buf, dword count, dword *nread);
BOOLEAN pc_efilio_write(int fd, byte *buff, dword count, dword *nwritten);
BOOLEAN pc_efilio_setalloc(int fd, dword cluster, dword reserve_count);
BOOLEAN pc_efilio_setbuff(byte *path, byte *buffer, dword buffer_size_blocks);
int pc_efilio_get_file_extents(int fd, int infolistsize, FILESEGINFO *plist, BOOLEAN report_clusters, BOOLEAN raw);
/* rtfsproplus\prapilinext.c */
BOOLEAN pc_efilio_extract(int fd1, int fd2, dword n_clusters);
BOOLEAN pc_efilio_swap(int fd1, int fd2, dword n_clusters);
BOOLEAN pc_efilio_remove(int fd1, dword n_clusters);
/* rtfsproplus\prfastio.c */
BOOLEAN pc_efilio_fpos_sector(int fd, BOOLEAN isreadfp, BOOLEAN raw, dword *psectorno, dword *psectorcount);
/* rtfsproplus\proplusglue.c */
BOOLEAN pc_bytes_to_clusters(int driveno, dword bytes_hi, dword bytes_lo, dword *pcluster_mod);
BOOLEAN pc_clusters_to_bytes(int driveno, dword n_clusters, dword *pbytes_hi, dword *pbytes_lo);
void pc_subtract_64(dword hi_1, dword lo_1, dword hi_0, dword lo_0, dword *presult_hi, dword *presult_lo);
void pc_add_64(dword hi_1, dword lo_1, dword hi_0, dword lo_0, dword *presult_hi, dword *presult_lo);
dword pc_cluster_to_sector(int driveno, dword cluster, BOOLEAN raw);
dword pc_sector_to_cluster(int driveno, dword sector, BOOLEAN raw);
void pc_clusters2bytes64(DDRIVE *pdr, dword n_clusters, dword *pbytes_hi, dword *pbytes_lo);
/* ============================ */
/* End ProPlus API Prototypes */
/* ============================ */
/* ============================ */
/* ProPlus Internal Prototypes */
/* ============================ */
/* rtfsproplus\prapiasy.c */
BOOLEAN _pc_check_if_async(PC_FILE *pefile);
dword _get_operating_flags(PC_FILE *pefile);
void _set_asy_operating_flags(PC_FILE *pefile, dword new_operating_flags, int success);
/* rtfsproplus\prapicfi.c */
BOOLEAN _pc_cfilio_read(PC_FILE *preaderefile, byte *buff, dword count, dword *nread);
BOOLEAN _pc_cfilio_write(PC_FILE *pwriterefile, byte *buff, dword count, dword *nwritten);
dword _pc_cfilio_get_max_write_count(PC_FILE *pwriterefile, dword count);
dword _pc_cfilio_get_max_read_count(PC_FILE *pefile, dword count);
PC_FILE *pc_cfilio_fd2file(int fd, BOOLEAN unlock);
void pc_cfilio_clear_open_flags(PC_FILE *pefile, word flags);
void pc_cfilio_set_open_flags(PC_FILE *pefile, word flags);
ddword pc_efilio_get_fp_ddw(PC_FILE *pefile);
ddword pc_cfilio_get_fp_ddw(PC_FILE *pefile);
ddword pc_cfilio_get_file_size_ddw(PC_FILE *pefile);
/* rtfsproplus\prapicsk.c */
BOOLEAN _pc_cfilio_lseek(PC_FILE *pwriterefile, int which_pointer, dword offset_hi, dword offset_lo, int origin, dword *poffset_hi, dword *poffset_lo);
BOOLEAN _pc_cstreamio_lseek(PC_FILE *pwriterefile, int which_pointer, ddword offset_ddw, int origin, ddword *poffset_ddw);
/* rtfsproplus\prapiefi.c */
int _pc_efilio_open(DDRIVE *pdrive, byte *name, word flag, word mode, EFILEOPTIONS *poptions, int use_charset);
BOOLEAN _pc_efilio_flush_file_buffer(PC_FILE *pefile);
BOOLEAN _pc_efilio_flush(PC_FILE *pefile);
void _pc_efilio_free_excess_clusters(PC_FILE *pefile);
BOOLEAN pc_efilio_close(int fd);
PC_FILE *pc_efilio_start_close(int fd, BOOLEAN *is_aborted);
BOOLEAN _pc_efilio_close(PC_FILE *pefile);
void _pc_cfilio_set_file_size(PC_FILE *pefile, dword dstart, dword length_hi, dword length_lo);
dword _pc_efilio_first_cluster(PC_FILE *pefile);
dword _pc_efilio_last_cluster(PC_FILE *pefile);
void _pc_efilio_reset_seek(PC_FILE *pefile);
void _pc_efilio_coalesce_fragments(PC_FILE *pefile);
BOOLEAN _pc_efilio_lseek(PC_FILE *pefile, dword offset_hi, dword offset_lo, int origin, dword *pnewoffset_hi, dword *pnewoffset_lo);
BOOLEAN _pc_efilio_read(PC_FILE *pefile, byte *buf, dword count, dword *nread);
BOOLEAN _pc_efilio_write(PC_FILE *pefile, byte *buff, dword count, dword *nwritten);
BOOLEAN pc_efilio_fstat(int fd, ERTFS_EFILIO_STAT *pestat);
BOOLEAN _pc_efilio_fstat(PC_FILE *pefile, ERTFS_EFILIO_STAT *pestat);
BOOLEAN _pc_check_efile_open_mode(PC_FILE *pefile);
void fatop_page_start_check_freespace(DDRIVE *pdr);
#if (INCLUDE_CIRCULAR_FILES)
/* rtfsproplus\prapicfi.c */
BOOLEAN pc_cfilio_close(int fd);
BOOLEAN pc_cfilio_read(int fd, byte *buff, dword count, dword *nread);
BOOLEAN pc_cfilio_write(int fd, byte *buff, dword count, dword *nwritten);
BOOLEAN pc_cfilio_setalloc(int fd, dword cluster, dword reserve_count);
/* rtfsproplus\prapicsk.c */
BOOLEAN pc_cfilio_lseek(int fd, int which_pointer, dword offset_hi, dword offset_lo, int origin, dword *poffset_hi, dword *poffset_lo);
BOOLEAN pc_cstreamio_lseek(int fd, int which_pointer, dword offset_hi, dword offset_lo, int origin, dword *poffset_hi, dword *poffset_lo);
BOOLEAN pc_cfilio_extract(int circ_fd, int linear_fd, dword length_hi, dword length_lo,byte *header_buffer, int header_size);
/* rtfsproplus\prapiext.c */
BOOLEAN pc_cfilio_release_all_remap_files(PC_FILE *preaderefile, int abort);
BOOLEAN pc_cfilio_remap_region_purge(PC_FILE *preaderefile,ddword purge_start_ddw, ddword purge_length_ddw);
BOOLEAN pc_cfilio_remap_read(PC_FILE *preaderefile,
ddword reader_file_pointer_ddw,
byte *buf,
dword read_count,
REMAP_RECORD *remap_record);
void pc_cfilio_check_remap_read(PC_FILE *preaderefile,ddword data_start_ddw,ddword data_length_ddw,
ddword *bytes_to_region_ddw,ddword *byte_offset_in_region_ddw,
ddword *bytes_in_region_ddw, REMAP_RECORD **preturn);
void pc_remap_free_list(PC_FILE *preaderefile, REMAP_RECORD *premap);
void pc_cfilio_remap_region_init(PC_FILE *preaderefile,REMAP_RECORD *premap_records,int num_records);
void pc_cfilio_release_remap_file(PC_FILE *premapfile, int abort);
#endif /* (INCLUDE_CIRCULAR_FILES) */
/* rtfsproplus\prasyint.c */
int _pc_async_step(DDRIVE *pdrive, int target_state, int steps);
/* rtfsproplus\prefi32.c */
int _pc_efilio32_open(DDRIVE *pdr,byte *name, word flag, word mode, EFILEOPTIONS *poptions, int use_charset);
void pc_efilio32_open_error(PC_FILE *pefile);
BOOLEAN pc_efilio32_open_complete(PC_FILE *pefile);
int pc_efilio_async_open32_continue(PC_FILE *pefile);
BOOLEAN _pc_efilio32_common_fstat(PC_FILE *pefile, ERTFS_EFILIO_STAT *pestat);
BOOLEAN _pc_efilio32_close(PC_FILE *pefile);
BOOLEAN _pc_efilio32_settime(PC_FILE *pefile,word new_time, word new_date);
BOOLEAN _pc_efilio32_flush(PC_FILE *pefile,dword max_clusters_per_pass);
BOOLEAN _pc_efilio32_read(PC_FILE *pefile, byte *buf, dword count, dword *nread);
/* rtfsproplus\preficom.c */
void _pc_efiliocom_sync_current_fragment(PC_FILE *pefile,FINODE *peffinode);
BOOLEAN _pc_efiliocom_write(PC_FILE *pefile,FINODE *peffinode, byte *buff, dword count, dword *nwritten);
void _pc_efiliocom_reset_seek(PC_FILE *pefile,FINODE *peffinode);
BOOLEAN _pc_efiliocom_lseek(PC_FILE *pefile,FINODE *peffinode, dword offset_hi, dword offset, int origin, dword *pnewoffset_hi,dword *pnewoffset);
BOOLEAN _pc_efiliocom_io(PC_FILE *pefile,FINODE *peffinode, byte *pdata, dword n_bytes, BOOLEAN reading, BOOLEAN appending);
BOOLEAN _pc_efiliocom_resize_current_fragment(PC_FILE *pefile,FINODE *peffinode,dword new_size);
/* rtfsproplus\prefinode.c */
int pc_efinode_async_load_continue(FINODE *pefinode);
dword _pc_efinode_count_to_link(FINODE *pefinode,dword allocation_policy);
BOOLEAN _pc_efinode_queue_cluster_links(FINODE *pefinode, dword allocation_policy);
void _pc_efinode_coalesce_fragments(FINODE *pefinode);
BOOLEAN load_efinode_fragment_list(FINODE *pefinode);
BOOLEAN load_efinode_fragments_until(FINODE *pefinode, llword offset);
void pc_free_excess_clusters(FINODE *pefinode);
void pc_free_efinode(FINODE *pefinode);
BOOLEAN pc_efinode_link_or_delete_cluster_chain(FINODE *pefinode, dword flags, dword max_clusters_per_pass);
BOOLEAN pc_efinode_delete_cluster_chain(FINODE *pefinode, dword max_clusters_per_pass);
BOOLEAN _pc_efinode_truncate_finode(FINODE *pfi);
void _pc_efinode_set_file_size(FINODE *pefinode, dword length_hi, dword length_lo);
BOOLEAN _pc_efinode_chsize(FINODE *pefinode, dword newsize_hi, dword newsize_lo);
REGION_FRAGMENT *pc_region_file_find_free_chain(
DDRIVE *pdrive,
dword allocation_policy,
dword alloc_start_hint,
dword chain_size,
int *p_is_error);
/* rtfsproplus\prfragmt.c */
dword pc_frag_chain_delete_or_link(DDRIVE *pdr,
dword flags,
REGION_FRAGMENT *pf,
dword prev_end_chain,
dword start_contig,
dword clusters_to_process);
REGION_FRAGMENT *pc_fraglist_find_next_cluster(REGION_FRAGMENT *pfstart,REGION_FRAGMENT *pfend ,dword this_cluster,dword *pnext_cluster,dword *pstart_offset);
REGION_FRAGMENT *pc_fragment_seek_clusters(REGION_FRAGMENT *pf,dword n_clusters, dword *region_base_offset);
REGION_FRAGMENT *pc_fraglist_split(DDRIVE *pdr, REGION_FRAGMENT *pfstart,dword n_clusters,int *is_error);
REGION_FRAGMENT *pc_fraglist_find_cluster(REGION_FRAGMENT *pfstart,REGION_FRAGMENT *pfend ,dword cluster);
void pc_fraglist_coalesce(REGION_FRAGMENT *pfstart);
dword pc_fraglist_count_list(REGION_FRAGMENT *pf,REGION_FRAGMENT *pfend);
BOOLEAN pc_fraglist_remove_free_region(DDRIVE *pdr, REGION_FRAGMENT *pf);
BOOLEAN pc_fraglist_add_free_region(DDRIVE *pdr, REGION_FRAGMENT *pf);
BOOLEAN pc_fraglist_fat_free_list(DDRIVE *pdr, REGION_FRAGMENT *pf);
/* rtfsproplus\prmath64.c */
BOOLEAN return_false(void);
ddword pc_byte2ddwclmodbytes(DDRIVE *pdr, ddword nbytes64);
ddword pc_alloced_bytes_from_clusters_64(DDRIVE *pdr, dword total_alloced_clusters);
FINODE_EXTENDED *pc_memory_finode_ex(FINODE_EXTENDED *pinode);
dword pc_byte2clmodbytes(DDRIVE *pdr, dword nbytes);
dword pc_byte2cloff(DDRIVE *pdr, dword nbytes);
dword pc_byte2cloffbytes(DDRIVE *pdr, dword nbytes);
#ifdef __cplusplus
}
#endif
/* =========================== */
/* End RtfsPro Plus prototypes */
/* =========================== */
#if (INCLUDE_CS_UNICODE)
/* Unicode API */
#define pc_cfilio_open_uc(A,B,C) pc_cfilio_open_cs((A),(B),(C),CS_CHARSET_UNICODE)
#define pc_efilio_async_unlink_start_uc(A) pc_efilio_async_unlink_start_cs((A), CS_CHARSET_UNICODE)
#define pc_efilio_open_uc(A,B,C,D) pc_efilio_open_cs((A),(B),(C),(D),CS_CHARSET_UNICODE)
/* Non-Unicode API */
#define pc_cfilio_open(A,B,C) pc_cfilio_open_cs((A),(B),(C),CS_CHARSET_NOT_UNICODE)
#define pc_efilio_async_unlink_start(A) pc_efilio_async_unlink_start_cs((A), CS_CHARSET_NOT_UNICODE)
#define pc_efilio_open(A,B,C,D) pc_efilio_open_cs((A),(B),(C),(D),CS_CHARSET_NOT_UNICODE)
#endif
#endif
#if (INCLUDE_MATH64) /* ddword type, ProPlus only */
ddword po_lseek64(int fd, ddword offset, int origin);
ddword m64_native_set32(dword a, dword b);
#endif
#if (INCLUDE_EXTENDED_ATTRIBUTES)
#define RTFS_EXTATTRIBUTE_SIGNATURE "RTFSEXTENTENDEDATTRIBUTE"
#define RTFS_EXTATTRIBUTE_SIGNATURE_SIZE 24
#define RTFS_EXTATTRIBUTE_RECORD_SIZE 28
dword pc_efilio32_get_dstart(PC_FILE *pefile);
BOOLEAN pc_efilio32_set_dstart(PC_FILE *pefile, dword dstart);
#endif
#if (INCLUDE_FAT64 && !INCLUDE_EXFAT)
BOOLEAN exfatop_remove_free_region(DDRIVE *pdr, dword cluster, dword ncontig);
BOOLEAN exfatop_add_free_region(DDRIVE *pdr, dword cluster, dword ncontig, BOOLEAN do_erase);
#define pcexfat_set_volume_dirty(A) /* Implement to set and clear dirty bytes in bpb */
#define pcexfat_clear_volume_dirty(A)
dword pc_byte2clmod64(DDRIVE *pdr, dword nbytes_hi, dword nbytes_lo);
ddword pc_fragment_size_64(DDRIVE *pdr,REGION_FRAGMENT *pfragment);
#define EXFATALLOCATIONPOSSIBLE 0x1
#define EXFATNOFATCHAIN 0x2
BOOLEAN pcexfat_insert_inode(DROBJ *pobj , DROBJ *pmom, byte _attr, FINODE *infinode, dword initcluster, byte *filename, byte secondaryflags, dword sizehi, dword sizelow, int use_charset);
BOOLEAN pcexfat_grow_directory(DROBJ *pobj);
void pcexfat_update_finode_datestamp(FINODE *pfi, BOOLEAN set_archive, int set_date_mask);
#endif
#endif /* _RTFSPROTOS_*/
Reference in New Issue View Git Blame Copy Permalink