Compare commits
1 Commits
main
...
agent/w092
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
dce04216f8 |
@@ -53,9 +53,9 @@ Progress
|
||||
<!-- progress:start -->
|
||||
| Decompiled | Matched | Linked | Data |
|
||||
|:---:|:---:|:---:|:---:|
|
||||
| 85.10% | 75.39% | 56.76% | 86.72% |
|
||||
| 85.47% | 75.70% | 56.76% | 86.72% |
|
||||
|
||||
units 748/1027 complete, functions 10999/12563 matched.
|
||||
units 748/1027 complete, functions 11024/12563 matched.
|
||||
|
||||
decompiled = code with a C/C++ implementation (objdiff fuzzy), matched = byte-exact code, linked = code actually linked into the DOL, data = byte-exact data
|
||||
<!-- progress:end -->
|
||||
|
||||
644
libs/RVL_SDK/src/fa/pf_cluster.c
Normal file
644
libs/RVL_SDK/src/fa/pf_cluster.c
Normal file
@@ -0,0 +1,644 @@
|
||||
#include <private/vf/PrFILE2/fatfs/pf_entry.h>
|
||||
|
||||
typedef struct PFCLUSTER_FAT_HINT {
|
||||
pf_u32 chain_index;
|
||||
pf_u32 cluster;
|
||||
pf_u32 previous_cluster;
|
||||
} PFCLUSTER_FAT_HINT;
|
||||
|
||||
typedef struct PFCLUSTER_FFD {
|
||||
pf_u32 start_cluster;
|
||||
pf_u32 current_start_cluster;
|
||||
pf_u32* p_start_cluster;
|
||||
PF_LAST_CLUSTER last_cluster;
|
||||
PF_FAT_LAST_ACCESS last_access_cluster;
|
||||
PF_CLUSTER_LINK cluster_link;
|
||||
PFCLUSTER_FAT_HINT* p_hint;
|
||||
PF_VOLUME* p_vol;
|
||||
} PFCLUSTER_FFD;
|
||||
|
||||
typedef struct PFCLUSTER_ENT_ITER {
|
||||
pf_u32 index;
|
||||
PF_VOLUME* p_vol;
|
||||
PFCLUSTER_FFD ffd;
|
||||
pf_u32 file_sector_index;
|
||||
pf_u32 sector;
|
||||
pf_u16 offset;
|
||||
pf_u16 offset_mask;
|
||||
pf_u8 buf[32];
|
||||
pf_u8 log2_entries_per_sector;
|
||||
} PFCLUSTER_ENT_ITER;
|
||||
|
||||
typedef struct PFCLUSTER_BPB {
|
||||
pf_u16 bytes_per_sector;
|
||||
pf_u16 num_reserved_sectors;
|
||||
pf_u16 num_root_dir_entries;
|
||||
pf_u8 sectors_per_cluster;
|
||||
pf_u8 num_FATs;
|
||||
pf_u32 total_sectors;
|
||||
pf_u32 sectors_per_FAT;
|
||||
pf_u32 root_dir_cluster;
|
||||
pf_u16 fs_info_sector;
|
||||
pf_u16 backup_boot_sector;
|
||||
pf_u16 ext_flags;
|
||||
pf_u8 media;
|
||||
pf_s32 fat_type;
|
||||
pf_u8 log2_bytes_per_sector;
|
||||
pf_u8 log2_sectors_per_cluster;
|
||||
pf_u8 num_active_FATs;
|
||||
pf_u16 num_root_dir_sectors;
|
||||
pf_u32 active_FAT_sector;
|
||||
pf_u32 first_root_dir_sector;
|
||||
pf_u32 first_data_sector;
|
||||
pf_u32 num_clusters;
|
||||
} PFCLUSTER_BPB;
|
||||
|
||||
struct PF_VOLUME {
|
||||
PFCLUSTER_BPB bpb;
|
||||
pf_u32 num_free_clusters;
|
||||
pf_u32 last_free_cluster;
|
||||
pf_u8 file_and_directory_state[0x1624 - 0x40];
|
||||
pf_u32 cache_mode;
|
||||
pf_u8 cache_and_driver_state[0x1f90 - 0x1628];
|
||||
pf_u16 fsi_flag;
|
||||
};
|
||||
|
||||
typedef struct PFCLUSTER_CURSOR {
|
||||
pf_u32 position;
|
||||
pf_u32 sector;
|
||||
pf_u32 file_sector_index;
|
||||
pf_u16 offset_in_sector;
|
||||
pf_u16 reserved;
|
||||
} PFCLUSTER_CURSOR;
|
||||
|
||||
typedef struct PFCLUSTER_SFD {
|
||||
pf_u32 stat;
|
||||
PFCLUSTER_FFD ffd;
|
||||
PF_DIR_ENT dir_entry;
|
||||
} PFCLUSTER_SFD;
|
||||
|
||||
typedef struct PFCLUSTER_FILE {
|
||||
pf_u32 stat;
|
||||
pf_u32 open_mode;
|
||||
PFCLUSTER_SFD* p_sfd;
|
||||
PFCLUSTER_FAT_HINT hint;
|
||||
pf_s32 last_error;
|
||||
PFCLUSTER_CURSOR cursor;
|
||||
} PFCLUSTER_FILE;
|
||||
|
||||
extern pf_s32 PFFILE_Cursor_MoveToClusterEnd(PFCLUSTER_FILE*, pf_u32);
|
||||
extern pf_s32 PFFILE_Cursor_MoveToEnd(PFCLUSTER_FILE*);
|
||||
extern pf_s32 PFFAT_GetSectorAllocated(PFCLUSTER_FFD*, pf_u32, pf_u32, pf_u32*);
|
||||
extern pf_s32 PFFAT_getContinuousSector(PFCLUSTER_FFD*, pf_u32, pf_u32, pf_u32*, pf_u32*);
|
||||
extern pf_s32 PFFAT_TraceClustersChain(PFCLUSTER_FFD*, pf_u32, pf_u32, pf_u32*, pf_u32*);
|
||||
extern pf_u32 PFFAT_GetValueOfEOC2(PF_VOLUME*);
|
||||
extern pf_s32 PFFAT_WriteValueToSpecifiedCluster(PF_VOLUME*, pf_u32, pf_u32);
|
||||
extern pf_s32 PFFAT_ReadValueToSpecifiedCluster(PF_VOLUME*, pf_u32, pf_u32*);
|
||||
extern pf_s32 PFFAT_FreeChain(PFCLUSTER_FFD*, pf_u32, pf_u32, pf_u32);
|
||||
extern pf_s32 PFFAT_AllocateNumClusters(PFCLUSTER_FFD*, pf_u32, pf_u32*, pf_u32*, pf_u32*);
|
||||
extern pf_s32 PFENT_updateEntry(PF_DIR_ENT*, pf_u32);
|
||||
extern pf_u8 PFENT_getcurrentDateTimeForEnt(pf_u16*, pf_u16*);
|
||||
extern pf_s32 PFCACHE_FlushDataCacheSpecific(PF_VOLUME*, void*);
|
||||
extern pf_s32 PFCACHE_AllocateDataPage(PF_VOLUME*, pf_u32, PF_CACHE_PAGE**, pf_bool*);
|
||||
extern void PFCACHE_FreeDataPage(PF_VOLUME*, PF_CACHE_PAGE*);
|
||||
extern pf_s32 PFSEC_ReadData(PF_VOLUME*, pf_u8*, pf_u32, pf_u16, pf_u32, pf_u32*, pf_bool);
|
||||
extern pf_s32 PFSEC_WriteData(PF_VOLUME*, const pf_u8*, pf_u32, pf_u16, pf_u32, pf_u32*, pf_bool);
|
||||
|
||||
|
||||
|
||||
void PFCLUSTER_UpdateLastAccessCluster(PFCLUSTER_FILE* p_file, pf_u32 sector) {
|
||||
PF_VOLUME* p_vol;
|
||||
|
||||
if (p_file->cursor.position == 0) {
|
||||
p_file->p_sfd->ffd.last_access_cluster.cluster = 0;
|
||||
p_file->p_sfd->ffd.last_access_cluster.chain_index = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
p_vol = p_file == PF_NULL ? PF_NULL : p_file->p_sfd->dir_entry.p_vol;
|
||||
if ((p_file->cursor.position & (p_vol->bpb.bytes_per_sector - 1)) == 0 &&
|
||||
(p_file->cursor.file_sector_index & (p_vol->bpb.sectors_per_cluster - 1)) == 0) {
|
||||
if (p_file->cursor.file_sector_index != 0) {
|
||||
p_file->p_sfd->ffd.last_access_cluster.chain_index = (p_file->cursor.file_sector_index - 1) >> p_vol->bpb.log2_sectors_per_cluster;
|
||||
p_file->p_sfd->ffd.last_access_cluster.cluster = (((sector - 1) - p_vol->bpb.first_data_sector) >> p_vol->bpb.log2_sectors_per_cluster) + 2;
|
||||
}
|
||||
} else {
|
||||
p_file->p_sfd->ffd.last_access_cluster.chain_index = p_file->cursor.file_sector_index >> p_vol->bpb.log2_sectors_per_cluster;
|
||||
p_file->p_sfd->ffd.last_access_cluster.cluster = ((sector - p_vol->bpb.first_data_sector) >> p_vol->bpb.log2_sectors_per_cluster) + 2;
|
||||
}
|
||||
}
|
||||
|
||||
pf_s32 PFCLUSTER_AppendCluster(PFCLUSTER_FILE* p_file, pf_u32 byte, pf_bool* p_success) {
|
||||
pf_s32 err;
|
||||
PF_VOLUME* p_vol;
|
||||
pf_u32 sector;
|
||||
pf_u32 num_sector;
|
||||
pf_u32 max_appendable_size;
|
||||
PFCLUSTER_CURSOR save_cursor;
|
||||
PFCLUSTER_FAT_HINT save_hint;
|
||||
|
||||
*p_success = 0;
|
||||
if ((p_file->p_sfd->stat & 0x01) == 0 || (p_file->p_sfd->stat & 0x02) == 0) {
|
||||
return 38;
|
||||
}
|
||||
|
||||
p_vol = p_file == PF_NULL ? PF_NULL : p_file->p_sfd->dir_entry.p_vol;
|
||||
|
||||
save_cursor = p_file->cursor;
|
||||
save_hint = p_file->hint;
|
||||
|
||||
p_file->p_sfd->ffd.p_hint = &p_file->hint;
|
||||
sector = 0xFFFFFFFF;
|
||||
if ((p_vol->fsi_flag & 0x04) != 0 && p_vol->num_free_clusters != -1 && p_vol->num_free_clusters == 0) {
|
||||
return 6;
|
||||
}
|
||||
PFFILE_Cursor_MoveToClusterEnd(p_file, p_file->p_sfd->dir_entry.file_size + byte);
|
||||
if (p_file->cursor.position == -1) {
|
||||
*p_success = 0;
|
||||
return 37;
|
||||
}
|
||||
err = PFFAT_GetSectorAllocated(&p_file->p_sfd->ffd, p_file->cursor.file_sector_index, byte, §or);
|
||||
if (err != 0) {
|
||||
p_file->cursor = save_cursor;
|
||||
p_file->hint = save_hint;
|
||||
return err;
|
||||
}
|
||||
num_sector = 0;
|
||||
err = PFFAT_getContinuousSector(&p_file->p_sfd->ffd, p_file->cursor.file_sector_index, byte, §or, &num_sector);
|
||||
p_file->cursor = save_cursor;
|
||||
p_file->hint = save_hint;
|
||||
if (err != 0) return err;
|
||||
if (sector == -1U) {
|
||||
PFFILE_Cursor_MoveToEnd(p_file);
|
||||
return 28;
|
||||
}
|
||||
max_appendable_size = num_sector << p_vol->bpb.log2_bytes_per_sector;
|
||||
if (byte < max_appendable_size) {
|
||||
max_appendable_size = byte;
|
||||
}
|
||||
*p_success = max_appendable_size;
|
||||
return 0;
|
||||
}
|
||||
|
||||
pf_s32 PFCLUSTER_AdjustCluster(PFCLUSTER_FILE* p_file) {
|
||||
PF_VOLUME* p_vol;
|
||||
pf_u32 num_cluster;
|
||||
pf_u32 file_end_cluster;
|
||||
pf_u32 spare_cluster;
|
||||
pf_u32 sig_eoc;
|
||||
pf_u32 chain_index;
|
||||
pf_s32 err;
|
||||
|
||||
if (((p_file->p_sfd->stat & 1) == 0) || ((p_file->p_sfd->stat & 2) == 0)) {
|
||||
return 0x26;
|
||||
}
|
||||
p_vol = p_file == PF_NULL ? PF_NULL : p_file->p_sfd->dir_entry.p_vol;
|
||||
|
||||
p_file->p_sfd->ffd.p_hint = &p_file->hint;
|
||||
chain_index = -1U;
|
||||
if (p_file->p_sfd->ffd.last_cluster.max_chain_index != 0) {
|
||||
num_cluster = ((p_file->p_sfd->dir_entry.file_size & ((p_vol->bpb.bytes_per_sector << p_vol->bpb.log2_sectors_per_cluster) - 1)) ? 1 : 0) +
|
||||
(p_file->p_sfd->dir_entry.file_size >> (p_vol->bpb.log2_bytes_per_sector + p_vol->bpb.log2_sectors_per_cluster));
|
||||
|
||||
if ((p_file->p_sfd->ffd.last_cluster.max_chain_index + 1) == num_cluster) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
if (p_file->p_sfd->dir_entry.file_size != 0) {
|
||||
err = PFFAT_TraceClustersChain(&p_file->p_sfd->ffd, p_file->p_sfd->dir_entry.start_cluster, p_file->p_sfd->dir_entry.file_size,
|
||||
&file_end_cluster, &spare_cluster);
|
||||
if (err != 0) {
|
||||
return err;
|
||||
}
|
||||
} else {
|
||||
file_end_cluster = 0;
|
||||
spare_cluster = p_file->p_sfd->dir_entry.start_cluster;
|
||||
}
|
||||
if (spare_cluster != 0) {
|
||||
sig_eoc = PFFAT_GetValueOfEOC2(p_vol);
|
||||
if (spare_cluster != sig_eoc) {
|
||||
if (file_end_cluster != 0) {
|
||||
err = PFFAT_WriteValueToSpecifiedCluster(p_vol, file_end_cluster, sig_eoc);
|
||||
if (err != 0) {
|
||||
return err;
|
||||
}
|
||||
p_file->p_sfd->ffd.last_cluster.num_last_cluster = file_end_cluster;
|
||||
p_file->p_sfd->ffd.last_cluster.max_chain_index =
|
||||
((p_file->p_sfd->dir_entry.file_size >> (p_vol->bpb.log2_bytes_per_sector + p_vol->bpb.log2_sectors_per_cluster)) +
|
||||
((p_file->p_sfd->dir_entry.file_size & ((p_vol->bpb.bytes_per_sector << p_vol->bpb.log2_sectors_per_cluster) - 1)) ? 1 : 0)) -
|
||||
1;
|
||||
chain_index = p_file->p_sfd->ffd.last_cluster.max_chain_index + 1;
|
||||
|
||||
} else {
|
||||
p_file->p_sfd->dir_entry.start_cluster = 0;
|
||||
*p_file->p_sfd->ffd.p_start_cluster = 0;
|
||||
p_file->p_sfd->ffd.last_cluster.num_last_cluster = 0;
|
||||
p_file->p_sfd->ffd.last_cluster.max_chain_index = 0;
|
||||
err = PFENT_updateEntry(&p_file->p_sfd->dir_entry, 1U);
|
||||
if (err != 0) {
|
||||
return err;
|
||||
}
|
||||
if ((p_vol->cache_mode & 4) != 0) {
|
||||
err = PFCACHE_FlushDataCacheSpecific(p_vol, p_file);
|
||||
if (err != 0) {
|
||||
return err;
|
||||
}
|
||||
}
|
||||
}
|
||||
err = PFFAT_FreeChain(&p_file->p_sfd->ffd, spare_cluster, chain_index, -1U);
|
||||
if (err != 0) {
|
||||
return err;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
pf_s32 PFCLUSTER_GetAppendSize(PFCLUSTER_FILE* p_file, pf_u32* p_size) {
|
||||
PF_VOLUME* p_vol;
|
||||
pf_u32 cluster_size;
|
||||
pf_u32 file_cluster_size;
|
||||
pf_u32 total_allocated_size;
|
||||
pf_u32 file_end_cluster;
|
||||
pf_u32 spare_cluster;
|
||||
pf_u32 next_cluster;
|
||||
pf_u32 num_append_cluster;
|
||||
pf_u32 sig_eoc;
|
||||
pf_s32 err;
|
||||
|
||||
*p_size = 0;
|
||||
if ((p_file->p_sfd->stat & 0x01) == 0 || (p_file->p_sfd->stat & 0x02) == 0) {
|
||||
return 38;
|
||||
}
|
||||
|
||||
p_vol = p_file == PF_NULL ? PF_NULL : p_file->p_sfd->dir_entry.p_vol;
|
||||
|
||||
cluster_size = p_vol->bpb.bytes_per_sector << p_vol->bpb.log2_sectors_per_cluster;
|
||||
if (p_file->p_sfd->dir_entry.start_cluster != 0) {
|
||||
file_cluster_size =
|
||||
p_file->p_sfd->dir_entry.file_size +
|
||||
((p_file->p_sfd->dir_entry.file_size % cluster_size) != 0 ? cluster_size - (p_file->p_sfd->dir_entry.file_size % cluster_size) : 0);
|
||||
if (p_file->p_sfd->ffd.last_cluster.max_chain_index != 0) {
|
||||
total_allocated_size = (p_file->p_sfd->ffd.last_cluster.max_chain_index + 1) * cluster_size;
|
||||
|
||||
} else {
|
||||
if (p_file->p_sfd->dir_entry.file_size != 0) {
|
||||
err = PFFAT_TraceClustersChain(&p_file->p_sfd->ffd, p_file->p_sfd->dir_entry.start_cluster, p_file->p_sfd->dir_entry.file_size,
|
||||
&file_end_cluster, &spare_cluster);
|
||||
if (err != 0) {
|
||||
return err;
|
||||
}
|
||||
} else {
|
||||
spare_cluster = p_file->p_sfd->dir_entry.start_cluster;
|
||||
}
|
||||
|
||||
sig_eoc = PFFAT_GetValueOfEOC2(p_vol);
|
||||
num_append_cluster = 0;
|
||||
for (; spare_cluster != sig_eoc; spare_cluster = next_cluster) {
|
||||
num_append_cluster++;
|
||||
err = PFFAT_ReadValueToSpecifiedCluster(p_vol, spare_cluster, &next_cluster);
|
||||
if (err != 0) {
|
||||
return err;
|
||||
}
|
||||
}
|
||||
|
||||
total_allocated_size = file_cluster_size + (num_append_cluster * cluster_size);
|
||||
}
|
||||
*p_size = total_allocated_size - file_cluster_size;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
pf_s32 PFCLUSTER_CombineFiles(PFCLUSTER_ENT_ITER* p_first_iter, PFCLUSTER_ENT_ITER* p_second_iter,
|
||||
PF_DIR_ENT* p_first_entry, PF_DIR_ENT* p_second_entry) {
|
||||
pf_s32 err;
|
||||
pf_u32 end_cluster;
|
||||
pf_u32 spare_cluster;
|
||||
pf_u32 cluster_size;
|
||||
pf_u32 first_used_clusters;
|
||||
pf_u32 second_used_clusters;
|
||||
pf_u32 first_spare_clusters;
|
||||
pf_u32 second_spare_clusters;
|
||||
pf_u32 excess_clusters;
|
||||
pf_u32 first_end_cluster;
|
||||
pf_u32 first_spare_cluster;
|
||||
pf_u32 second_spare_cluster;
|
||||
pf_u32 sig_eoc;
|
||||
PF_VOLUME* p_vol;
|
||||
|
||||
p_vol = p_first_entry->p_vol;
|
||||
first_used_clusters = 0;
|
||||
second_used_clusters = 0;
|
||||
first_spare_clusters = 0;
|
||||
second_spare_clusters = 0;
|
||||
first_spare_cluster = 0;
|
||||
err = PFFAT_TraceClustersChain(&p_first_iter->ffd, *p_first_iter->ffd.p_start_cluster,
|
||||
p_first_entry->file_size, &end_cluster, &spare_cluster);
|
||||
if (err != 0) return err;
|
||||
cluster_size = p_vol->bpb.bytes_per_sector << p_vol->bpb.log2_sectors_per_cluster;
|
||||
first_end_cluster = end_cluster;
|
||||
if (p_first_entry->file_size != 0) {
|
||||
first_used_clusters = p_first_entry->file_size / cluster_size;
|
||||
if (p_first_entry->file_size % cluster_size != 0) ++first_used_clusters;
|
||||
}
|
||||
sig_eoc = PFFAT_GetValueOfEOC2(p_vol);
|
||||
if (spare_cluster != sig_eoc) {
|
||||
if (p_first_entry->file_size != 0 && spare_cluster != 0) first_spare_cluster = spare_cluster;
|
||||
else first_spare_cluster = *p_first_iter->ffd.p_start_cluster;
|
||||
err = PFFAT_TraceClustersChain(&p_first_iter->ffd, first_spare_cluster, -1U, &end_cluster, &spare_cluster);
|
||||
if (err != 0) return err;
|
||||
if (*p_first_iter->ffd.p_start_cluster != 0) {
|
||||
first_spare_clusters = p_first_iter->ffd.last_cluster.max_chain_index + 1 - first_used_clusters;
|
||||
}
|
||||
}
|
||||
err = PFFAT_TraceClustersChain(&p_second_iter->ffd, *p_second_iter->ffd.p_start_cluster,
|
||||
p_second_entry->file_size, &end_cluster, &spare_cluster);
|
||||
if (err != 0) return err;
|
||||
if (p_second_entry->file_size != 0) {
|
||||
second_used_clusters = p_second_entry->file_size / cluster_size;
|
||||
if (p_second_entry->file_size % cluster_size != 0) ++second_used_clusters;
|
||||
}
|
||||
second_spare_cluster = spare_cluster;
|
||||
if (second_spare_cluster != sig_eoc) {
|
||||
if (p_second_entry->file_size != 0 && spare_cluster != 0) {
|
||||
second_spare_cluster = spare_cluster;
|
||||
} else second_spare_cluster = *p_second_iter->ffd.p_start_cluster;
|
||||
err = PFFAT_TraceClustersChain(&p_second_iter->ffd, second_spare_cluster, -1U, &end_cluster, &spare_cluster);
|
||||
if (err != 0) return err;
|
||||
if (*p_second_iter->ffd.p_start_cluster != 0) {
|
||||
second_spare_clusters = p_second_iter->ffd.last_cluster.max_chain_index + 1 - second_used_clusters;
|
||||
}
|
||||
if (-1U / cluster_size + 1 < (second_used_clusters + second_spare_clusters) + first_used_clusters) {
|
||||
excess_clusters = (second_used_clusters + second_spare_clusters) + first_used_clusters - (-1U / cluster_size + 1);
|
||||
err = PFFAT_TraceClustersChain(&p_second_iter->ffd, second_spare_cluster,
|
||||
cluster_size * ((p_second_iter->ffd.last_cluster.max_chain_index + 1 - excess_clusters) - second_used_clusters),
|
||||
&end_cluster, &spare_cluster);
|
||||
if (err != 0) return err;
|
||||
err = PFFAT_WriteValueToSpecifiedCluster(p_vol, end_cluster, sig_eoc);
|
||||
if (err != 0) return err;
|
||||
err = PFFAT_FreeChain(&p_second_iter->ffd, spare_cluster, -1U, excess_clusters * cluster_size);
|
||||
if (err != 0) return err;
|
||||
if (p_second_entry->file_size == 0 && second_spare_clusters == excess_clusters) {
|
||||
*p_second_iter->ffd.p_start_cluster = 0;
|
||||
p_second_entry->start_cluster = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (first_spare_clusters != 0) {
|
||||
err = PFFAT_FreeChain(&p_first_iter->ffd, first_spare_cluster, -1U, first_spare_clusters * cluster_size);
|
||||
if (err != 0) return err;
|
||||
if (p_first_entry->file_size == 0) {
|
||||
*p_first_iter->ffd.p_start_cluster = 0;
|
||||
p_first_entry->start_cluster = 0;
|
||||
}
|
||||
}
|
||||
if (*p_first_iter->ffd.p_start_cluster != 0 && *p_second_iter->ffd.p_start_cluster != 0) {
|
||||
err = PFFAT_WriteValueToSpecifiedCluster(p_vol, first_end_cluster, *p_second_iter->ffd.p_start_cluster);
|
||||
if (err != 0) return err;
|
||||
} else if (*p_first_iter->ffd.p_start_cluster == 0 && *p_second_iter->ffd.p_start_cluster != 0) {
|
||||
p_first_entry->start_cluster = p_second_entry->start_cluster;
|
||||
}
|
||||
p_first_entry->file_size = p_second_entry->file_size + first_used_clusters * cluster_size;
|
||||
return 0;
|
||||
}
|
||||
pf_s32 PFCLUSTER_DivideFile(PFCLUSTER_ENT_ITER* p_source_iter, PFCLUSTER_ENT_ITER* p_dest_iter,
|
||||
PF_DIR_ENT* p_source_entry, PF_DIR_ENT* p_dest_entry, pf_u32 split_size) {
|
||||
pf_s32 err;
|
||||
pf_u32 source_end;
|
||||
pf_u32 success_size;
|
||||
pf_u32 allocated_start;
|
||||
pf_u32 allocated_end;
|
||||
pf_u32 dest_cluster;
|
||||
PF_CACHE_PAGE* p_page;
|
||||
pf_bool cache_hit;
|
||||
pf_u32 source_sector;
|
||||
pf_u32 dest_sector;
|
||||
pf_u32 sector_index;
|
||||
pf_u32 cluster_size;
|
||||
pf_u32 last_cluster;
|
||||
pf_u32 allocated_size;
|
||||
pf_u32 dest_first;
|
||||
pf_u32 remaining;
|
||||
PF_VOLUME* p_vol;
|
||||
pf_u32 saved_next;
|
||||
pf_u32 sig_eoc;
|
||||
|
||||
allocated_start = 0;
|
||||
p_vol = p_source_entry->p_vol;
|
||||
dest_first = 0;
|
||||
last_cluster = 0;
|
||||
remaining = 0;
|
||||
|
||||
if (split_size == 0) {
|
||||
dest_cluster = p_source_entry->start_cluster;
|
||||
} else {
|
||||
err = PFFAT_TraceClustersChain(&p_source_iter->ffd, *p_source_iter->ffd.p_start_cluster,
|
||||
split_size, &source_end, &dest_cluster);
|
||||
if (err != 0) return err;
|
||||
saved_next = dest_cluster;
|
||||
sig_eoc = PFFAT_GetValueOfEOC2(p_vol);
|
||||
err = PFFAT_WriteValueToSpecifiedCluster(p_vol, source_end, sig_eoc);
|
||||
if (err != 0) return err;
|
||||
if (split_size == p_source_entry->file_size) {
|
||||
if (dest_cluster == sig_eoc) dest_cluster = 0;
|
||||
} else {
|
||||
cluster_size = p_vol->bpb.bytes_per_sector << p_vol->bpb.log2_sectors_per_cluster;
|
||||
remaining = split_size % cluster_size;
|
||||
if (remaining != 0) {
|
||||
for (allocated_size = 0; allocated_size < cluster_size; ) {
|
||||
err = PFFAT_AllocateNumClusters(&p_dest_iter->ffd, cluster_size,
|
||||
&allocated_start, &allocated_end, &success_size);
|
||||
if (err != 0) {
|
||||
PFFAT_WriteValueToSpecifiedCluster(p_vol, source_end, saved_next);
|
||||
return err;
|
||||
}
|
||||
if (success_size == 0) break;
|
||||
if (allocated_size == 0) {
|
||||
dest_first = allocated_start;
|
||||
} else {
|
||||
err = PFFAT_WriteValueToSpecifiedCluster(p_vol, last_cluster, allocated_start);
|
||||
if (err != 0) {
|
||||
PFFAT_FreeChain(&p_dest_iter->ffd, dest_first, -1U, allocated_size);
|
||||
PFFAT_WriteValueToSpecifiedCluster(p_vol, source_end, saved_next);
|
||||
return err;
|
||||
}
|
||||
}
|
||||
allocated_size += success_size;
|
||||
last_cluster = allocated_end;
|
||||
}
|
||||
if (cluster_size != allocated_size) {
|
||||
if (allocated_size != 0) {
|
||||
err = PFFAT_FreeChain(&p_dest_iter->ffd, dest_first, -1U, allocated_size);
|
||||
if (err != 0) {
|
||||
PFFAT_WriteValueToSpecifiedCluster(p_vol, source_end, saved_next);
|
||||
return err;
|
||||
}
|
||||
}
|
||||
PFFAT_FreeChain(&p_dest_iter->ffd, dest_first, -1U, allocated_size);
|
||||
PFFAT_WriteValueToSpecifiedCluster(p_vol, source_end, saved_next);
|
||||
return 6;
|
||||
}
|
||||
err = PFFAT_WriteValueToSpecifiedCluster(p_vol, last_cluster, dest_cluster);
|
||||
if (err != 0) {
|
||||
PFFAT_FreeChain(&p_dest_iter->ffd, dest_first, -1U, allocated_size);
|
||||
PFFAT_WriteValueToSpecifiedCluster(p_vol, source_end, saved_next);
|
||||
return err;
|
||||
}
|
||||
dest_cluster = dest_first;
|
||||
source_sector = p_vol->bpb.first_data_sector + ((source_end - 2) << p_vol->bpb.log2_sectors_per_cluster);
|
||||
dest_sector = p_vol->bpb.first_data_sector + ((allocated_start - 2) << p_vol->bpb.log2_sectors_per_cluster);
|
||||
err = PFCACHE_AllocateDataPage(p_vol, -1U, &p_page, &cache_hit);
|
||||
if (err != 0) {
|
||||
PFFAT_FreeChain(&p_dest_iter->ffd, dest_first, -1U, allocated_size);
|
||||
PFFAT_WriteValueToSpecifiedCluster(p_vol, source_end, saved_next);
|
||||
return err;
|
||||
}
|
||||
for (sector_index = 0; sector_index < p_vol->bpb.sectors_per_cluster; ++sector_index) {
|
||||
err = PFSEC_ReadData(p_vol, p_page->p_buf, source_sector, 0,
|
||||
p_vol->bpb.bytes_per_sector, &success_size, 0);
|
||||
if (err != 0) {
|
||||
PFFAT_FreeChain(&p_dest_iter->ffd, dest_first, -1U, allocated_size);
|
||||
PFFAT_WriteValueToSpecifiedCluster(p_vol, source_end, saved_next);
|
||||
return err;
|
||||
}
|
||||
if (success_size != p_vol->bpb.bytes_per_sector) {
|
||||
PFFAT_FreeChain(&p_dest_iter->ffd, dest_first, -1U, allocated_size);
|
||||
PFFAT_WriteValueToSpecifiedCluster(p_vol, source_end, saved_next);
|
||||
return 17;
|
||||
}
|
||||
err = PFSEC_WriteData(p_vol, p_page->p_buf, dest_sector, 0,
|
||||
p_vol->bpb.bytes_per_sector, &success_size, 0);
|
||||
if (err != 0) {
|
||||
PFFAT_FreeChain(&p_dest_iter->ffd, dest_first, -1U, allocated_size);
|
||||
PFFAT_WriteValueToSpecifiedCluster(p_vol, source_end, saved_next);
|
||||
return err;
|
||||
}
|
||||
if (success_size != p_vol->bpb.bytes_per_sector) {
|
||||
PFFAT_FreeChain(&p_dest_iter->ffd, dest_first, -1U, allocated_size);
|
||||
PFFAT_WriteValueToSpecifiedCluster(p_vol, source_end, saved_next);
|
||||
return 17;
|
||||
}
|
||||
++source_sector;
|
||||
++dest_sector;
|
||||
}
|
||||
PFCACHE_FreeDataPage(p_vol, p_page);
|
||||
}
|
||||
}
|
||||
}
|
||||
p_dest_entry->start_cluster = dest_cluster;
|
||||
p_dest_entry->file_size = p_source_entry->file_size - split_size + remaining;
|
||||
return 0;
|
||||
}
|
||||
|
||||
pf_s32 PFCLUSTER_InsertCluster(PFCLUSTER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent,
|
||||
pf_u32 cluster_index, pf_u32 num_clusters, pf_u32* p_inserted_clusters) {
|
||||
pf_s32 err;
|
||||
pf_u32 previous_cluster;
|
||||
pf_u32 next_cluster;
|
||||
pf_u32 success_size;
|
||||
pf_u32 allocated_start;
|
||||
pf_u32 allocated_end;
|
||||
pf_u32 cluster_size;
|
||||
pf_u32 allocated_size;
|
||||
pf_u32 first_cluster;
|
||||
pf_u32 last_cluster;
|
||||
pf_u32 requested_size;
|
||||
pf_u32 file_clusters;
|
||||
pf_u32 remainder;
|
||||
pf_u32 extra_size;
|
||||
PF_VOLUME* p_vol;
|
||||
|
||||
p_vol = p_ent->p_vol;
|
||||
cluster_size = p_vol->bpb.bytes_per_sector << p_vol->bpb.log2_sectors_per_cluster;
|
||||
first_cluster = 0;
|
||||
last_cluster = 0;
|
||||
err = PFFAT_TraceClustersChain(&p_iter->ffd, *p_iter->ffd.p_start_cluster,
|
||||
cluster_index * cluster_size, &previous_cluster, &next_cluster);
|
||||
if (err != 0) return err;
|
||||
file_clusters = p_ent->file_size / cluster_size;
|
||||
if (p_ent->file_size % cluster_size != 0) ++file_clusters;
|
||||
if (-1U / cluster_size + 1 < file_clusters + num_clusters) {
|
||||
num_clusters = file_clusters + num_clusters - (-1U / cluster_size + 1);
|
||||
}
|
||||
requested_size = num_clusters * cluster_size;
|
||||
for (allocated_size = 0; allocated_size < requested_size; ) {
|
||||
err = PFFAT_AllocateNumClusters(&p_iter->ffd, requested_size, &allocated_start, &allocated_end, &success_size);
|
||||
if (err != 0) return err;
|
||||
if (success_size == 0) {
|
||||
if (allocated_size != 0) break;
|
||||
return 6;
|
||||
}
|
||||
if (allocated_size == 0) first_cluster = allocated_start;
|
||||
else {
|
||||
err = PFFAT_WriteValueToSpecifiedCluster(p_vol, last_cluster, allocated_start);
|
||||
if (err != 0) return err;
|
||||
}
|
||||
allocated_size += success_size;
|
||||
last_cluster = allocated_end;
|
||||
}
|
||||
if (next_cluster == 0) {
|
||||
next_cluster = p_ent->start_cluster != 0 ? p_ent->start_cluster : PFFAT_GetValueOfEOC2(p_vol);
|
||||
}
|
||||
err = PFFAT_WriteValueToSpecifiedCluster(p_vol, last_cluster, next_cluster);
|
||||
if (err != 0) return err;
|
||||
if (cluster_index != 0) {
|
||||
err = PFFAT_WriteValueToSpecifiedCluster(p_vol, previous_cluster, first_cluster);
|
||||
if (err != 0) return err;
|
||||
} else p_ent->start_cluster = first_cluster;
|
||||
file_clusters = p_ent->file_size / cluster_size;
|
||||
remainder = p_ent->file_size % cluster_size;
|
||||
if (remainder != 0) ++file_clusters;
|
||||
extra_size = 0;
|
||||
if (cluster_index == file_clusters && remainder != 0) extra_size = cluster_size - remainder;
|
||||
p_ent->file_size += allocated_size + extra_size;
|
||||
*p_inserted_clusters = allocated_size / cluster_size;
|
||||
return 0;
|
||||
}
|
||||
|
||||
pf_s32 PFCLUSTER_DeleteCluster(PFCLUSTER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent,
|
||||
pf_u32 cluster_index, pf_u32 num_clusters, pf_u32* p_deleted_clusters) {
|
||||
pf_s32 err;
|
||||
pf_u32 previous_cluster;
|
||||
pf_u32 next_cluster;
|
||||
pf_u32 first_deleted_cluster;
|
||||
pf_u32 last_deleted_cluster;
|
||||
PF_VOLUME* p_vol;
|
||||
pf_u32 cluster_size;
|
||||
pf_u32 byte_position;
|
||||
|
||||
p_vol = p_ent->p_vol;
|
||||
cluster_size = p_vol->bpb.bytes_per_sector << p_vol->bpb.log2_sectors_per_cluster;
|
||||
byte_position = cluster_index * cluster_size;
|
||||
err = PFFAT_TraceClustersChain(&p_iter->ffd, *p_iter->ffd.p_start_cluster,
|
||||
byte_position, &previous_cluster, &first_deleted_cluster);
|
||||
if (err != 0) return err;
|
||||
if (cluster_index == 0) first_deleted_cluster = p_ent->start_cluster;
|
||||
num_clusters = num_clusters * cluster_size;
|
||||
if (num_clusters > p_ent->file_size - byte_position) num_clusters = p_ent->file_size - byte_position;
|
||||
err = PFFAT_TraceClustersChain(&p_iter->ffd, first_deleted_cluster, num_clusters, &last_deleted_cluster, &next_cluster);
|
||||
if (err != 0) return err;
|
||||
if (cluster_index == 0) {
|
||||
if (next_cluster == PFFAT_GetValueOfEOC2(p_vol)) next_cluster = 0;
|
||||
p_ent->start_cluster = next_cluster;
|
||||
}
|
||||
p_ent->file_size -= num_clusters;
|
||||
PFENT_getcurrentDateTimeForEnt(&p_ent->modify_date, &p_ent->modify_time);
|
||||
p_ent->access_date = p_ent->modify_date;
|
||||
err = PFENT_updateEntry(p_ent, 1);
|
||||
if (err != 0) return err;
|
||||
if (p_vol->cache_mode & 4) {
|
||||
err = PFCACHE_FlushDataCacheSpecific(p_vol, PF_NULL);
|
||||
if (err != 0) return err;
|
||||
}
|
||||
err = PFFAT_FreeChain(&p_iter->ffd, first_deleted_cluster, -1U, num_clusters);
|
||||
if (err != 0) return err;
|
||||
if (cluster_index != 0) {
|
||||
err = PFFAT_WriteValueToSpecifiedCluster(p_vol, previous_cluster, next_cluster);
|
||||
if (err != 0) return err;
|
||||
}
|
||||
*p_deleted_clusters = num_clusters / cluster_size;
|
||||
if (num_clusters % cluster_size != 0) ++*p_deleted_clusters;
|
||||
return 0;
|
||||
}
|
||||
759
libs/RVL_SDK/src/fa/pf_entry.c
Normal file
759
libs/RVL_SDK/src/fa/pf_entry.c
Normal file
@@ -0,0 +1,759 @@
|
||||
#include <private/vf/PrFILE2/fatfs/pf_entry.h>
|
||||
|
||||
typedef struct PFENTRY_FAT_HINT {
|
||||
pf_u32 chain_index;
|
||||
pf_u32 cluster;
|
||||
pf_u32 previous_cluster;
|
||||
} PFENTRY_FAT_HINT;
|
||||
|
||||
typedef struct PFENTRY_FFD {
|
||||
pf_u32 start_cluster;
|
||||
pf_u32 current_start_cluster;
|
||||
pf_u32* p_start_cluster;
|
||||
PF_LAST_CLUSTER last_cluster;
|
||||
PF_FAT_LAST_ACCESS last_access_cluster;
|
||||
PF_CLUSTER_LINK cluster_link;
|
||||
PFENTRY_FAT_HINT* p_hint;
|
||||
PF_VOLUME* p_vol;
|
||||
} PFENTRY_FFD;
|
||||
|
||||
typedef struct PFENTRY_ENT_ITER {
|
||||
pf_u32 index;
|
||||
PF_VOLUME* p_vol;
|
||||
PFENTRY_FFD ffd;
|
||||
pf_u32 file_sector_index;
|
||||
pf_u32 sector;
|
||||
pf_u16 offset;
|
||||
pf_u16 offset_mask;
|
||||
pf_u8 buf[32];
|
||||
pf_u8 log2_entries_per_sector;
|
||||
} PFENTRY_ENT_ITER;
|
||||
|
||||
typedef struct PFENTRY_BPB {
|
||||
pf_u16 bytes_per_sector;
|
||||
pf_u16 num_reserved_sectors;
|
||||
pf_u16 num_root_dir_entries;
|
||||
pf_u8 sectors_per_cluster;
|
||||
pf_u8 num_FATs;
|
||||
pf_u32 total_sectors;
|
||||
pf_u32 sectors_per_FAT;
|
||||
pf_u32 root_dir_cluster;
|
||||
pf_u16 fs_info_sector;
|
||||
pf_u16 backup_boot_sector;
|
||||
pf_u16 ext_flags;
|
||||
pf_u8 media;
|
||||
pf_s32 fat_type;
|
||||
pf_u8 log2_bytes_per_sector;
|
||||
pf_u8 log2_sectors_per_cluster;
|
||||
pf_u8 num_active_FATs;
|
||||
pf_u16 num_root_dir_sectors;
|
||||
pf_u32 active_FAT_sector;
|
||||
pf_u32 first_root_dir_sector;
|
||||
pf_u32 first_data_sector;
|
||||
pf_u32 num_clusters;
|
||||
} PFENTRY_BPB;
|
||||
|
||||
struct PF_VOLUME {
|
||||
PFENTRY_BPB bpb;
|
||||
pf_u32 num_free_clusters;
|
||||
pf_u32 last_free_cluster;
|
||||
pf_u8 file_and_directory_state[0x1f74 - 0x40];
|
||||
struct {
|
||||
pf_u32 tracker_size;
|
||||
pf_u32 tracker_max;
|
||||
pf_u32* tracker_bits;
|
||||
} tail_entry;
|
||||
};
|
||||
|
||||
typedef struct PFENTRY_CONTEXT_VOLUME {
|
||||
pf_u32 stat;
|
||||
pf_s32 context_id;
|
||||
PF_VOLUME* p_vol;
|
||||
} PFENTRY_CONTEXT_VOLUME;
|
||||
|
||||
typedef struct PFENTRY_VOLUME_SET {
|
||||
pf_u32 flags;
|
||||
pf_u32 reserved;
|
||||
PF_VOLUME* current_volume;
|
||||
PFENTRY_CONTEXT_VOLUME context_volumes[3];
|
||||
pf_s32 num_attached;
|
||||
pf_s32 num_mounted;
|
||||
pf_u32 config;
|
||||
void* user_data;
|
||||
pf_s32 last_error;
|
||||
pf_s32 last_driver_error;
|
||||
void (*code_callbacks[6])(void);
|
||||
pf_u32 setting;
|
||||
} PFENTRY_VOLUME_SET;
|
||||
|
||||
typedef struct PFENTRY_SYS_DATE { pf_u32 sys_year, sys_month, sys_day; } PFENTRY_SYS_DATE;
|
||||
typedef struct PFENTRY_SYS_TIME { pf_u32 sys_hour, sys_min, sys_sec, sys_ms; } PFENTRY_SYS_TIME;
|
||||
|
||||
extern PFENTRY_VOLUME_SET pf_vol_set;
|
||||
void* pf_memcpy(void* dst, void* src, pf_u32 length);
|
||||
void* pf_memset(void* dst, pf_s32 c, pf_u32 length);
|
||||
void PF_LE16_TO_U16_STR(pf_u8* sSrc, pf_u32 num);
|
||||
pf_s32 PFPATH_cmpNameUni(const pf_u16* p_name, PF_STR* sPattern);
|
||||
pf_s32 PFPATH_cmpName(const pf_s8* sShort, PF_STR* p_pattern, pf_bool is_short_search);
|
||||
pf_s32 PFPATH_cmpTailSFN(const pf_s8* sfn_name, const pf_s8* pattern);
|
||||
pf_s32 PFPATH_putShortName(pf_u8* pDirEntry, const pf_s8* short_name, pf_u8 attr);
|
||||
pf_s32 PFPATH_getShortName(pf_s8* short_name, const pf_u8* pDirEntry, pf_u8 attr);
|
||||
void PFPATH_getLongNameformShortName(pf_s8* short_name, pf_s8* long_name, pf_u8 flag);
|
||||
pf_s32 PFPATH_transformInUnicode(pf_u16* sDestStr, const pf_s8* sSrcStr);
|
||||
pf_s32 PFPATH_parseShortNameNumeric(pf_s8* p_char, pf_u32 count);
|
||||
pf_u32 PFPATH_CheckExtShortNameSignature(PF_STR* p_str);
|
||||
pf_bool PFPATH_GetExtShortNameIndex(PF_STR* p_str, pf_u32* p_index);
|
||||
pf_s32 PFSEC_WriteData(PF_VOLUME* p_vol, const pf_u8* p_buf, pf_u32 sector, pf_u16 offset, pf_u32 size, pf_u32* p_success_size, pf_bool set_sig);
|
||||
pf_s32 PFCACHE_AllocateDataPage(PF_VOLUME*, pf_u32, PF_CACHE_PAGE**, pf_bool*);
|
||||
void PFCACHE_FreeDataPage(PF_VOLUME*, PF_CACHE_PAGE*);
|
||||
pf_s32 PFCACHE_FlushDataCacheSpecific(PF_VOLUME*, void*);
|
||||
pf_s32 PFFAT_InitFFD(PFENTRY_FFD*, PFENTRY_FAT_HINT*, PF_VOLUME*, pf_u32*);
|
||||
pf_s32 PFFAT_GetSectorSpecified(PFENTRY_FFD*, pf_u32, pf_u32, pf_u32*);
|
||||
pf_s32 PFFAT_MakeRootDir(PF_VOLUME*);
|
||||
pf_s32 PFENT_ITER_IteratorInitialize(PFENTRY_ENT_ITER*, pf_u32);
|
||||
pf_s32 PFENT_ITER_Advance(PFENTRY_ENT_ITER*, pf_u32);
|
||||
pf_s32 PFENT_ITER_Retreat(PFENTRY_ENT_ITER*, pf_u32);
|
||||
pf_bool PFENT_ITER_IsAtLogicalEnd(PFENTRY_ENT_ITER*);
|
||||
void PFDRV_LoadVolumeLabelFromBuf(PF_VOLUME*, const pf_u8*);
|
||||
void PFSYS_TimeStamp(PFENTRY_SYS_DATE*, PFENTRY_SYS_TIME*);
|
||||
void PFENT_LoadShortNameFromBuf(PF_DIR_ENT*, const pf_u8*);
|
||||
pf_u8 PFENT_CalcCheckSum(PF_DIR_ENT*);
|
||||
void PFENT_loadEntryNumericFieldsFromBuf(PF_DIR_ENT*, const pf_u8*);
|
||||
pf_s32 PFENT_LoadLFNEntryFieldsFromBuf(PF_DIR_ENT*, const pf_u8*);
|
||||
|
||||
static void PFENT_storeShortNameToBuf(pf_u8* buf, const PF_DIR_ENT* p_ent) {
|
||||
PFPATH_putShortName(buf, p_ent->short_name, p_ent->attr);
|
||||
|
||||
if (*buf == 0xE5) {
|
||||
*buf = 5;
|
||||
}
|
||||
}
|
||||
pf_s32 PFENT_compareEntry(PF_DIR_ENT* p_ent, const pf_u8* buf, PF_STR* p_pattern, pf_s32 attr,
|
||||
pf_u32 attr_required, pf_u32 attr_forbidden, pf_u32* p_lpos) {
|
||||
pf_s32 is_match = 1;
|
||||
pf_u32 is_valid = 1;
|
||||
if ((attr & 15) == 15) {
|
||||
is_match = 1;
|
||||
} else {
|
||||
if (attr == 0) attr = 0x40;
|
||||
if (attr_required & 0x80) {
|
||||
attr_required &= 0x7f;
|
||||
attr_forbidden &= 0x7f;
|
||||
if ((attr_required && (pf_s32)(attr_required & attr) != (pf_s32)attr_required) ||
|
||||
(attr_forbidden && (pf_s32)(attr_forbidden & attr) == (pf_s32)attr_forbidden)) is_valid = 0;
|
||||
} else if (attr_required != 0x7f && (pf_u32)attr != attr_required &&
|
||||
(!(attr & attr_required) || (attr & attr_forbidden))) is_valid = 0;
|
||||
if (is_valid == 0) {
|
||||
is_match = 1;
|
||||
} else {
|
||||
if (attr & 8) {
|
||||
p_ent->num_entry_LFNs = 0;
|
||||
p_ent->long_name[0] = 0;
|
||||
}
|
||||
PFENT_LoadShortNameFromBuf(p_ent, buf);
|
||||
if (p_ent->num_entry_LFNs && p_ent->ordinal == 1 && p_ent->check_sum == PFENT_CalcCheckSum(p_ent)) {
|
||||
is_match = PFPATH_cmpNameUni(p_ent->long_name, p_pattern) != 0;
|
||||
}
|
||||
if (is_match == 1) {
|
||||
if ((pf_vol_set.setting & 2) == 2 && !(attr & 8)) {
|
||||
if (PFPATH_cmpName(p_ent->short_name, p_pattern, 0) == 0) is_match = 0;
|
||||
} else {
|
||||
if (PFPATH_cmpName(p_ent->short_name, p_pattern, 1) == 0) is_match = 0;
|
||||
}
|
||||
}
|
||||
if (is_match == 1) ++*p_lpos;
|
||||
}
|
||||
}
|
||||
return is_match;
|
||||
}
|
||||
|
||||
pf_s32 PFENT_getEntry(PF_DIR_ENT* p_ent, PFENTRY_ENT_ITER* p_iter, PF_STR* p_pattern,
|
||||
pf_u32 attr_required, pf_u32 attr_forbidden, pf_u32* p_lpos) {
|
||||
pf_s32 err;
|
||||
pf_u8 attr = p_iter->buf[11];
|
||||
if (PFENT_compareEntry(p_ent, p_iter->buf, p_pattern, attr, attr_required, attr_forbidden, p_lpos) == 1) {
|
||||
if ((attr & 15) == 15) {
|
||||
err = PFENT_LoadLFNEntryFieldsFromBuf(p_ent, p_iter->buf);
|
||||
if (err != 0) {
|
||||
p_ent->num_entry_LFNs = 0;
|
||||
p_ent->long_name[0] = 0;
|
||||
}
|
||||
} else {
|
||||
p_ent->num_entry_LFNs = 0;
|
||||
p_ent->long_name[0] = 0;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
if (p_ent->num_entry_LFNs == 0 && (p_iter->buf[12] & 0x18)) {
|
||||
pf_s8 filename[13];
|
||||
pf_s32 length;
|
||||
PFPATH_getLongNameformShortName(p_ent->short_name, filename, p_iter->buf[12]);
|
||||
length = PFPATH_transformInUnicode(p_ent->long_name, filename);
|
||||
p_ent->num_entry_LFNs = length / 13 + ((length % 13) != 0);
|
||||
p_ent->check_sum = PFENT_CalcCheckSum(p_ent);
|
||||
p_ent->ordinal = 1;
|
||||
}
|
||||
PFENT_loadEntryNumericFieldsFromBuf(p_ent, p_iter->buf);
|
||||
p_ent->entry_sector = p_iter->sector;
|
||||
p_ent->entry_offset = p_iter->offset;
|
||||
if ((p_ent->attr & 0x10) && p_ent->start_cluster == 0) p_ent->start_cluster = 1;
|
||||
return 0;
|
||||
}
|
||||
pf_s32 PFENT_searchEmptyTailSFN(PFENTRY_FFD* p_ffd, pf_u32 tail_index, const pf_s8* pattern, pf_u32* p_tail_bit) {
|
||||
PFENTRY_ENT_ITER iter;
|
||||
pf_u8 attr;
|
||||
pf_s32 err = 0;
|
||||
pf_u32 bit_pos;
|
||||
pf_u32 sfn_taillen;
|
||||
pf_u32 sfn_baselen;
|
||||
pf_u32 i;
|
||||
pf_s8 sfnbuf[13];
|
||||
pf_s8 patbuf[13];
|
||||
PF_VOLUME* p_vol = p_ffd->p_vol;
|
||||
|
||||
pf_memset(p_tail_bit, 0, p_vol->tail_entry.tracker_size * 4);
|
||||
iter.ffd = *p_ffd;
|
||||
|
||||
for (err = PFENT_ITER_IteratorInitialize(&iter, 0); PFENT_ITER_IsAtLogicalEnd(&iter) == PF_FALSE;
|
||||
err = PFENT_ITER_Advance(&iter, PF_FALSE)) {
|
||||
if (err != 0) {
|
||||
return err;
|
||||
}
|
||||
if (*iter.buf == 0) {
|
||||
break;
|
||||
}
|
||||
if (*iter.buf != 0xE5) {
|
||||
attr = iter.buf[11];
|
||||
if (((attr & (0x01 | 0x02 | 0x04 | 0x08)) != (0x01 | 0x02 | 0x04 | 0x08)) && ((attr & 8) == 0)) {
|
||||
PFPATH_getShortName((pf_s8*)&sfnbuf, (pf_u8*)&iter.buf, 0);
|
||||
for (sfn_taillen = 1; (sfnbuf[sfn_taillen] != 0x7E) && (sfnbuf[sfn_taillen] != 0) && (sfn_taillen < 7U); sfn_taillen++) {
|
||||
}
|
||||
|
||||
if (sfn_taillen < 7 && sfnbuf[sfn_taillen] == 0x7E) {
|
||||
for (sfn_baselen = sfn_taillen + 1; sfnbuf[sfn_baselen] >= 0x30 && sfnbuf[sfn_baselen] <= 0x39; sfn_baselen++) {
|
||||
}
|
||||
|
||||
if (sfnbuf[sfn_baselen] == '.' || sfnbuf[sfn_baselen] == 0) {
|
||||
i = (sfn_baselen - sfn_taillen) - 1;
|
||||
bit_pos = 0;
|
||||
for (; i != 0; i--) {
|
||||
bit_pos *= 10;
|
||||
bit_pos += (sfnbuf[sfn_baselen - i]) - 0x30;
|
||||
}
|
||||
|
||||
pf_strcpy((pf_s8*)&patbuf, pattern);
|
||||
PFPATH_parseShortNameNumeric((pf_s8*)&patbuf, bit_pos);
|
||||
if (PFPATH_cmpTailSFN((pf_s8*)&sfnbuf, (pf_s8*)&patbuf) == 0 && bit_pos >= tail_index &&
|
||||
bit_pos < (tail_index + (p_vol->tail_entry.tracker_size << 5))) {
|
||||
bit_pos -= tail_index;
|
||||
p_tail_bit[bit_pos >> 5] |= 1 << bit_pos;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
pf_s32 PFENT_findEmptyTailSFN(PF_DIR_ENT* p_ent_containig_dir, const pf_s8* name, pf_u32* p_tails) {
|
||||
PFENTRY_FFD ffd;
|
||||
PFENTRY_FAT_HINT hint;
|
||||
pf_s32 err;
|
||||
pf_u32 num;
|
||||
PF_VOLUME* p_vol = p_ent_containig_dir->p_vol;
|
||||
pf_u32 track_num;
|
||||
|
||||
*p_tails = 1;
|
||||
PFFAT_InitFFD(&ffd, &hint, p_ent_containig_dir->p_vol, &p_ent_containig_dir->start_cluster);
|
||||
|
||||
for (num = 1; num <= (1000000 - 1); num += p_vol->tail_entry.tracker_size << 5) {
|
||||
err = PFENT_searchEmptyTailSFN(&ffd, num, name, p_vol->tail_entry.tracker_bits);
|
||||
if (err != 0) {
|
||||
return err;
|
||||
}
|
||||
|
||||
for (track_num = 0; track_num < p_vol->tail_entry.tracker_size; track_num += 1) {
|
||||
if (p_vol->tail_entry.tracker_bits[track_num] != -1) {
|
||||
for (; (p_vol->tail_entry.tracker_bits[track_num] & 1) != 0; p_vol->tail_entry.tracker_bits[track_num] >>= 1, (*p_tails)++) {
|
||||
}
|
||||
num = 1000000;
|
||||
break;
|
||||
} else {
|
||||
*p_tails += 0x20;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
pf_u8 PFENT_CalcCheckSum(PF_DIR_ENT* p_ent) {
|
||||
pf_u16 i;
|
||||
pf_u8 sum;
|
||||
pf_u8 buf[13];
|
||||
|
||||
PFPATH_putShortName((pf_u8*)buf, p_ent->short_name, 0);
|
||||
|
||||
sum = 0;
|
||||
for (i = 0; i < 11; i++) {
|
||||
sum = ((sum & 1) != 0 ? 0x80 : 0) + (sum >> 1) + buf[i];
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
|
||||
void PFENT_LoadShortNameFromBuf(PF_DIR_ENT* p_ent, const pf_u8* buf) {
|
||||
PFPATH_getShortName(p_ent->short_name, buf, buf[11]);
|
||||
if (p_ent->short_name[0] == 5) {
|
||||
p_ent->short_name[0] = -0x1B;
|
||||
}
|
||||
}
|
||||
|
||||
void PFENT_loadEntryNumericFieldsFromBuf(PF_DIR_ENT* p_ent, const pf_u8* buf) {
|
||||
p_ent->attr = buf[0xB];
|
||||
p_ent->small_letter_flag = buf[0xC];
|
||||
p_ent->create_time_ms = buf[0xD];
|
||||
p_ent->create_time = PF_SWAP_16(*(pf_u16*)&buf[0xE]);
|
||||
p_ent->create_date = PF_SWAP_16(*(pf_u16*)&buf[0x10]);
|
||||
p_ent->access_date = PF_SWAP_16(*(pf_u16*)&buf[0x12]);
|
||||
p_ent->modify_time = PF_SWAP_16(*(pf_u16*)&buf[0x16]);
|
||||
p_ent->modify_date = PF_SWAP_16(*(pf_u16*)&buf[0x18]);
|
||||
p_ent->file_size = PF_SWAP_32(*(pf_u32*)&buf[0x1C]);
|
||||
p_ent->start_cluster = ((pf_u16)PF_SWAP_16(*(pf_u16*)&buf[0x14]) << 16) | (pf_u16)(PF_SWAP_16(*(pf_u16*)&buf[0x1A]));
|
||||
}
|
||||
|
||||
void PFENT_StoreEntryNumericFieldsToBuf(pf_u8* buf, const PF_DIR_ENT* p_ent) {
|
||||
buf[0x0B] = p_ent->attr;
|
||||
buf[0x0C] = p_ent->small_letter_flag;
|
||||
buf[0x0D] = p_ent->create_time_ms;
|
||||
*(pf_u16*)&buf[0x0E] = PF_SWAP_16(p_ent->create_time);
|
||||
*(pf_u16*)&buf[0x10] = PF_SWAP_16(p_ent->create_date);
|
||||
*(pf_u16*)&buf[0x12] = PF_SWAP_16(p_ent->access_date);
|
||||
*(pf_u16*)&buf[0x16] = PF_SWAP_16(p_ent->modify_time);
|
||||
*(pf_u16*)&buf[0x18] = PF_SWAP_16(p_ent->modify_date);
|
||||
*(pf_u16*)&buf[0x14] = PF_SWAP_16((pf_u16)(p_ent->start_cluster >> 16));
|
||||
*(pf_u16*)&buf[0x1A] = PF_SWAP_16((pf_u16)(p_ent->start_cluster));
|
||||
*(pf_u32*)&buf[0x1C] = PF_SWAP_32(p_ent->file_size);
|
||||
}
|
||||
|
||||
pf_s32 PFENT_LoadLFNEntryFieldsFromBuf(PF_DIR_ENT* p_ent, const pf_u8* buf) {
|
||||
pf_u8 ordinal;
|
||||
pf_u8 check_sum;
|
||||
pf_u32 is_last_LFN_ent;
|
||||
pf_u8* p;
|
||||
pf_u16* q;
|
||||
pf_u16* q_after;
|
||||
|
||||
ordinal = buf[0];
|
||||
check_sum = buf[13];
|
||||
if ((ordinal & ~0x40U) > 0x14U) {
|
||||
p_ent->ordinal = 0;
|
||||
p_ent->check_sum = 0;
|
||||
p_ent->num_entry_LFNs = 0;
|
||||
return 33;
|
||||
}
|
||||
if ((buf[0] & 0x40) != 0) {
|
||||
ordinal &= ~0x40;
|
||||
p_ent->num_entry_LFNs = 0;
|
||||
is_last_LFN_ent = 1;
|
||||
} else {
|
||||
is_last_LFN_ent = 0;
|
||||
if (p_ent->num_entry_LFNs == 0) return 33;
|
||||
if (ordinal != p_ent->ordinal - 1 || check_sum != p_ent->check_sum) {
|
||||
p_ent->ordinal = 0;
|
||||
p_ent->check_sum = 0;
|
||||
p_ent->num_entry_LFNs = 0;
|
||||
return 33;
|
||||
}
|
||||
}
|
||||
p_ent->ordinal = ordinal;
|
||||
p_ent->check_sum = check_sum;
|
||||
p = (pf_u8*)p_ent->long_name;
|
||||
p += (ordinal - 1) * 0x1A;
|
||||
pf_memcpy(&p[0x0], (pf_s8*)&buf[0x1], 10);
|
||||
pf_memcpy(&p[10], (pf_s8*)&buf[0xE], 0xC);
|
||||
pf_memcpy(&p[0x16], (pf_s8*)&buf[0x1C], 4U);
|
||||
PF_LE16_TO_U16_STR(&p[0x0], 10);
|
||||
PF_LE16_TO_U16_STR(&p[10], 0xC);
|
||||
PF_LE16_TO_U16_STR(&p[0x16], 4U);
|
||||
if (is_last_LFN_ent != 0) {
|
||||
((pf_u16*)p)[13] = 0;
|
||||
q = (pf_u16*)p;
|
||||
q_after = (pf_u16*)&p[0x1A];
|
||||
for (; q < q_after; q++) {
|
||||
if (*q == 0) {
|
||||
q++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
for (; q < q_after; q++) {
|
||||
if (*q != 0xFFFF) {
|
||||
p_ent->num_entry_LFNs = 0;
|
||||
return 33;
|
||||
}
|
||||
}
|
||||
}
|
||||
p_ent->num_entry_LFNs++;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void PFENT_storeLFNEntryFieldsToBuf(pf_u8* buf, PF_DIR_ENT* p_ent, pf_u8 ord, pf_u8 sum, pf_bool is_last) {
|
||||
pf_u8* p_seg;
|
||||
pf_u16* p;
|
||||
pf_u16* p_after;
|
||||
|
||||
if (is_last) {
|
||||
*buf = ord | 0x40;
|
||||
} else {
|
||||
*buf = ord;
|
||||
}
|
||||
buf[0xB] = (0x01 | 0x02 | 0x04 | 0x08);
|
||||
buf[0xD] = sum;
|
||||
buf[0xC] = 0;
|
||||
*(pf_u16*)&buf[0x1A] = 0;
|
||||
p_seg = (pf_u8*)p_ent->long_name;
|
||||
p_seg += (ord - 1) * 0x1A;
|
||||
if (is_last != 0) {
|
||||
p = (pf_u16*)p_seg;
|
||||
p_after = (pf_u16*)&p_seg[0x1A];
|
||||
for (; p < p_after; p++) {
|
||||
if (*p == 0x0000) {
|
||||
p++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
for (; p < p_after; p++) {
|
||||
*p = 0xFFFF;
|
||||
}
|
||||
}
|
||||
pf_memcpy(&buf[1], p_seg, 10);
|
||||
pf_memcpy(&buf[0xE], &p_seg[10], 0xC);
|
||||
pf_memcpy(&buf[0x1C], &p_seg[0x16], 4);
|
||||
PF_LE16_TO_U16_STR(&buf[1], 10);
|
||||
PF_LE16_TO_U16_STR(&buf[0xE], 0xC);
|
||||
PF_LE16_TO_U16_STR(&buf[0x1C], 4);
|
||||
}
|
||||
|
||||
pf_s32 PFENT_findEntryPos(PFENTRY_FFD* p_ffd, PF_DIR_ENT* p_ent, pf_u32 index_search_from, PF_STR* p_pattern,
|
||||
pf_u32 attr_required, pf_u32 attr_forbidden, pf_u32* p_lpos, pf_u32* p_ppos) {
|
||||
pf_s32 err;
|
||||
PFENTRY_ENT_ITER iter;
|
||||
pf_u32 lpos;
|
||||
pf_bool is_extsfn = 0;
|
||||
*p_lpos = 0;
|
||||
*p_ppos = 0;
|
||||
p_ent->num_entry_LFNs = 0;
|
||||
p_ent->ordinal = 0;
|
||||
p_ent->check_sum = 0;
|
||||
p_ent->long_name[0] = 0;
|
||||
lpos = 0;
|
||||
if ((pf_vol_set.setting & 2) == 2) is_extsfn = PFPATH_GetExtShortNameIndex(p_pattern, &index_search_from);
|
||||
iter.ffd = *p_ffd;
|
||||
if (is_extsfn == 1) {
|
||||
err = PFENT_ITER_IteratorInitialize(&iter, index_search_from - 1);
|
||||
{
|
||||
if (err != 0) {
|
||||
*p_lpos = 999999;
|
||||
*p_ppos = 999999;
|
||||
return err;
|
||||
}
|
||||
if (PFENT_getEntry(p_ent, &iter, p_pattern, attr_required, attr_forbidden, &lpos) == 0) {
|
||||
*p_lpos = 999999;
|
||||
*p_ppos = 999999;
|
||||
return 3;
|
||||
}
|
||||
if (iter.buf[0] & 0x40) {
|
||||
err = PFENT_ITER_IteratorInitialize(&iter, index_search_from);
|
||||
if (err != 0) {
|
||||
*p_lpos = 999999;
|
||||
*p_ppos = 999999;
|
||||
return err;
|
||||
}
|
||||
if (PFENT_getEntry(p_ent, &iter, p_pattern, attr_required, attr_forbidden, &lpos) == 0) {
|
||||
p_ent->p_vol = p_ffd->p_vol;
|
||||
*p_lpos = lpos;
|
||||
*p_ppos = iter.index;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (err = PFENT_ITER_IteratorInitialize(&iter, index_search_from); !PFENT_ITER_IsAtLogicalEnd(&iter); err = PFENT_ITER_Advance(&iter, 0)) {
|
||||
if (err != 0) {
|
||||
*p_lpos = 999999;
|
||||
*p_ppos = 999999;
|
||||
return err;
|
||||
}
|
||||
if (iter.buf[0] == 0) break;
|
||||
if (iter.buf[0] == 0xe5) {
|
||||
p_ent->num_entry_LFNs = 0;
|
||||
p_ent->long_name[0] = 0;
|
||||
} else if (PFENT_getEntry(p_ent, &iter, p_pattern, attr_required, attr_forbidden, &lpos) == 0) {
|
||||
p_ent->p_vol = p_ffd->p_vol;
|
||||
*p_lpos = lpos;
|
||||
*p_ppos = iter.index;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
*p_lpos = 999999;
|
||||
*p_ppos = 999999;
|
||||
return 3;
|
||||
}
|
||||
|
||||
pf_s32 PFENT_findEntry(PFENTRY_FFD* p_ffd, PF_DIR_ENT* p_ent, pf_u32 index_search_from, PF_STR* p_pattern,
|
||||
pf_u32 attr_required, pf_u32 attr_forbidden) {
|
||||
pf_u32 lpos;
|
||||
pf_u32 ppos;
|
||||
return PFENT_findEntryPos(p_ffd, p_ent, index_search_from, p_pattern, attr_required, attr_forbidden, &lpos, &ppos);
|
||||
}
|
||||
|
||||
pf_s32 PFENT_allocateEntryPos(PF_DIR_ENT* p_ent, pf_u32 num_entries, PFENTRY_FFD* p_ffd, pf_u32* p_prev_chain,
|
||||
PF_STR* p_filename, pf_u32* p_pos) {
|
||||
pf_s32 err;
|
||||
PFENTRY_ENT_ITER iter;
|
||||
PF_DIR_ENT current_ent;
|
||||
PF_VOLUME* p_vol;
|
||||
pf_u32 next_sector;
|
||||
pf_u32 logical_scratch;
|
||||
pf_u32 saved_sector;
|
||||
pf_u16 saved_offset;
|
||||
pf_u32 current_sector;
|
||||
pf_u32 previous_sector0;
|
||||
pf_u32 previous_sector1;
|
||||
pf_bool is_found;
|
||||
pf_u32 num_free_entries;
|
||||
pf_u32 logical_position;
|
||||
if ((pf_vol_set.setting & 2) == 2 && PFPATH_CheckExtShortNameSignature(p_filename) == 1) return 1;
|
||||
p_vol = p_ffd->p_vol;
|
||||
saved_sector = -1U;
|
||||
p_prev_chain[0] = p_prev_chain[1] = saved_sector;
|
||||
num_free_entries = 0;
|
||||
logical_position = 0;
|
||||
saved_offset = 0;
|
||||
current_sector = -1U;
|
||||
previous_sector1 = -1U;
|
||||
previous_sector0 = -1U;
|
||||
is_found = 0;
|
||||
iter.sector = 0;
|
||||
iter.index = 0;
|
||||
iter.ffd = *p_ffd;
|
||||
for (err = PFENT_ITER_IteratorInitialize(&iter, 0);; err = PFENT_ITER_Advance(&iter, 1)) {
|
||||
if (err != 0) {
|
||||
if (err == 16) break;
|
||||
return err;
|
||||
}
|
||||
if (iter.sector == -1U) break;
|
||||
if (is_found == 0 && num_free_entries == 0) {
|
||||
saved_offset = iter.offset;
|
||||
saved_sector = iter.sector;
|
||||
current_sector = iter.sector;
|
||||
}
|
||||
if (is_found == 0) {
|
||||
if (iter.buf[0] == 0 || iter.buf[0] == 0xe5) {
|
||||
if (current_sector != iter.sector) {
|
||||
pf_bool is_first = previous_sector0 == -1U;
|
||||
if (is_first) previous_sector0 = iter.sector;
|
||||
if (!is_first) previous_sector1 = iter.sector;
|
||||
current_sector = iter.sector;
|
||||
}
|
||||
++num_free_entries;
|
||||
} else {
|
||||
num_free_entries = 0;
|
||||
previous_sector0 = -1U;
|
||||
previous_sector1 = -1U;
|
||||
}
|
||||
}
|
||||
if (num_free_entries >= num_entries) {
|
||||
if (is_found == 0) {
|
||||
logical_position = iter.index;
|
||||
is_found = 1;
|
||||
}
|
||||
if (iter.buf[0] == 0) break;
|
||||
}
|
||||
if (iter.buf[0] != 0 && iter.buf[0] != 0xe5 && PFENT_getEntry(¤t_ent, &iter, p_filename, 0x7f, 0, &logical_scratch) == 0) {
|
||||
*p_ent = current_ent;
|
||||
p_ent->p_vol = p_ffd->p_vol;
|
||||
return 8;
|
||||
}
|
||||
if (iter.offset + 32 == p_vol->bpb.bytes_per_sector) {
|
||||
err = PFFAT_GetSectorSpecified(p_ffd, iter.file_sector_index + 1, 0, &next_sector);
|
||||
if (err != 0) return err;
|
||||
if (next_sector == -1U && is_found == 1) break;
|
||||
}
|
||||
}
|
||||
if (is_found == 0) return 5;
|
||||
p_prev_chain[0] = previous_sector0;
|
||||
p_prev_chain[1] = previous_sector1;
|
||||
p_ent->entry_sector = saved_sector;
|
||||
p_ent->entry_offset = saved_offset;
|
||||
*p_pos = logical_position;
|
||||
return 0;
|
||||
}
|
||||
|
||||
pf_s32 PFENT_allocateEntry(PF_DIR_ENT* p_ent, pf_u32 num_entries, PFENTRY_FFD* p_ffd, pf_u32* p_prev_chain, PF_STR* p_filename) {
|
||||
pf_u32 position;
|
||||
return PFENT_allocateEntryPos(p_ent, num_entries, p_ffd, p_prev_chain, p_filename, &position);
|
||||
}
|
||||
|
||||
pf_s32 PFENT_GetRootDir(PF_VOLUME* p_vol, PF_DIR_ENT* p_ent) {
|
||||
p_ent->long_name[0] = 0x5C;
|
||||
p_ent->long_name[1] = 0;
|
||||
p_ent->num_entry_LFNs = 0;
|
||||
p_ent->ordinal = 0;
|
||||
p_ent->check_sum = 0;
|
||||
p_ent->short_name[0] = 0x5C;
|
||||
p_ent->short_name[1] = 0;
|
||||
p_ent->small_letter_flag = 0;
|
||||
p_ent->attr = 0x10;
|
||||
p_ent->create_time_ms = 0;
|
||||
p_ent->create_time = 0;
|
||||
p_ent->create_date = 0;
|
||||
p_ent->access_date = 0;
|
||||
p_ent->modify_time = 0;
|
||||
p_ent->modify_date = 0;
|
||||
p_ent->file_size = 0;
|
||||
p_ent->p_vol = p_vol;
|
||||
p_ent->path_len = 3;
|
||||
p_ent->start_cluster = 1;
|
||||
p_ent->entry_sector = -1;
|
||||
p_ent->entry_offset = 0;
|
||||
return 0;
|
||||
}
|
||||
pf_s32 PFENT_MakeRootDir(PF_VOLUME* p_vol) {
|
||||
PF_CACHE_PAGE* p_page;
|
||||
pf_u32 sector;
|
||||
pf_u32 success_size;
|
||||
pf_bool hit;
|
||||
pf_s32 err;
|
||||
switch (p_vol->bpb.fat_type) {
|
||||
case FAT_32:
|
||||
PFFAT_MakeRootDir(p_vol);
|
||||
break;
|
||||
case FAT_12:
|
||||
case FAT_16:
|
||||
err = PFCACHE_AllocateDataPage(p_vol, -1U, &p_page, &hit);
|
||||
if (err != 0) return err;
|
||||
pf_memset(p_page->p_buf, 0, p_vol->bpb.bytes_per_sector);
|
||||
for (sector = p_vol->bpb.first_root_dir_sector; sector < p_vol->bpb.first_data_sector; ++sector) {
|
||||
err = PFSEC_WriteData(p_vol, p_page->p_buf, sector, 0, p_vol->bpb.bytes_per_sector, &success_size, 0);
|
||||
if (err != 0) {
|
||||
PFCACHE_FreeDataPage(p_vol, p_page);
|
||||
return err;
|
||||
}
|
||||
if (success_size != p_vol->bpb.bytes_per_sector) {
|
||||
PFCACHE_FreeDataPage(p_vol, p_page);
|
||||
return 17;
|
||||
}
|
||||
}
|
||||
PFCACHE_FreeDataPage(p_vol, p_page);
|
||||
break;
|
||||
default:
|
||||
return 7;
|
||||
}
|
||||
PFDRV_LoadVolumeLabelFromBuf(p_vol, (pf_u8*)"NO NAME ");
|
||||
return 0;
|
||||
}
|
||||
|
||||
pf_s32 PFENT_updateEntry(PF_DIR_ENT* p_ent, pf_u32 flag) {
|
||||
PF_VOLUME* p_vol;
|
||||
pf_u32 success_size;
|
||||
pf_u8 buf[32];
|
||||
pf_s32 err;
|
||||
|
||||
p_vol = p_ent->p_vol;
|
||||
if (p_ent->start_cluster == 1) {
|
||||
return 0xE;
|
||||
}
|
||||
if (flag == 1) {
|
||||
p_ent->attr |= (pf_u8)0x20;
|
||||
}
|
||||
PFENT_storeShortNameToBuf(buf, p_ent);
|
||||
PFENT_StoreEntryNumericFieldsToBuf(buf, p_ent);
|
||||
err = PFSEC_WriteData(p_vol, buf, p_ent->entry_sector, p_ent->entry_offset, 32, &success_size, 0U);
|
||||
if (err != 0) {
|
||||
return err;
|
||||
}
|
||||
if (success_size != 0x20) {
|
||||
return 0x11;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
pf_s32 PFENT_AdjustSFN(PF_DIR_ENT* p_ent, pf_s8* p_short_name) {
|
||||
pf_u32 i = 0;
|
||||
pf_u32 tail_num;
|
||||
pf_s32 err = 0;
|
||||
|
||||
for (i = 1; (p_short_name[i] != 0x7E) && (p_short_name[i] != 0) && (i < 7U); i++) {
|
||||
}
|
||||
if ((i < 7U) && (p_short_name[i] == 0x7E)) {
|
||||
for (i++; (p_short_name[i] >= 0x30) && (p_short_name[i] <= 0x39); i++) {
|
||||
}
|
||||
if ((p_short_name[i] == '.') || (p_short_name[i] == 0)) {
|
||||
err = PFENT_findEmptyTailSFN(p_ent, p_short_name, &tail_num);
|
||||
if (err != 0) {
|
||||
return err;
|
||||
}
|
||||
if (tail_num != 1) {
|
||||
PFPATH_parseShortNameNumeric(p_short_name, tail_num);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
pf_u8 PFENT_getcurrentDateTimeForEnt(pf_u16* p_date, pf_u16* p_time) {
|
||||
PFENTRY_SYS_DATE sys_date;
|
||||
PFENTRY_SYS_TIME sys_time;
|
||||
|
||||
PFSYS_TimeStamp(&sys_date, &sys_time);
|
||||
*p_date = ((sys_date.sys_day & 0x1F) | ((sys_date.sys_month << 5) & 0x1E0)) | (((sys_date.sys_year - 0x7BC) << 9) & 0xFE00);
|
||||
*p_time = (((sys_time.sys_sec >> 1) & 0x1F) | ((sys_time.sys_min << 5) & 0x7E0)) | ((sys_time.sys_hour << 0xB) & 0xF800);
|
||||
|
||||
return sys_time.sys_ms;
|
||||
}
|
||||
pf_s32 PFENT_RemoveEntry(PF_DIR_ENT* p_ent, PFENTRY_ENT_ITER* p_iter) {
|
||||
pf_u32 success_size;
|
||||
pf_s32 err = 0;
|
||||
pf_u32 entry_sector;
|
||||
pf_u16 entry_offset;
|
||||
pf_u32 i;
|
||||
PF_VOLUME* p_vol = PF_NULL;
|
||||
const pf_u8 dir_fb_free[1] = {0xE5};
|
||||
|
||||
p_vol = p_ent->p_vol;
|
||||
entry_sector = p_ent->entry_sector;
|
||||
entry_offset = p_ent->entry_offset;
|
||||
if ((p_ent->num_entry_LFNs != 0) && ((p_ent->small_letter_flag & 0x18) == 0)) {
|
||||
for (i = 1; i <= p_ent->num_entry_LFNs; i++) {
|
||||
err = PFENT_ITER_Retreat(p_iter, 0);
|
||||
if (err != 0) {
|
||||
return err;
|
||||
}
|
||||
entry_sector = p_iter->sector;
|
||||
entry_offset = p_iter->offset;
|
||||
err = PFSEC_WriteData(p_vol, (pf_u8*)&dir_fb_free, entry_sector, entry_offset, 1, &success_size, 0);
|
||||
if (err != 0) {
|
||||
return err;
|
||||
}
|
||||
if (success_size != 1) {
|
||||
return 17;
|
||||
}
|
||||
}
|
||||
}
|
||||
err = PFSEC_WriteData(p_vol, (pf_u8*)&dir_fb_free, p_ent->entry_sector, p_ent->entry_offset, 1, &success_size, 0);
|
||||
if (err != 0) {
|
||||
return err;
|
||||
}
|
||||
if (success_size != 1) {
|
||||
return 17;
|
||||
}
|
||||
err = PFCACHE_FlushDataCacheSpecific(p_vol, PF_NULL);
|
||||
if (err != 0) {
|
||||
return err;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
26
tools/decomp-assist/fa_pf_cluster_attempts.md
Normal file
26
tools/decomp-assist/fa_pf_cluster_attempts.md
Normal file
@@ -0,0 +1,26 @@
|
||||
# fa/pf_cluster matching attempts
|
||||
|
||||
All eight functions are implemented. The five exact functions have zero instruction differences. The three open functions have identical instruction counts to the target and differ in register allocation or arithmetic scheduling. The unit has no target data section.
|
||||
|
||||
## PFCLUSTER_CombineFiles (207 instructions)
|
||||
|
||||
1. Initial C reconstruction: 206 instructions; swapped stack addresses and one missing branch in the second spare-chain selection.
|
||||
2. Separate second-chain selection assignment, reversed stack declarations, and grouped cluster totals: 207 instructions, four differences in the overflow comparison's registers and addition order. Retained.
|
||||
3. Explicit total-cluster temporary, then an explicit maximum-cluster temporary: seven differences in the same comparison; the compiler retained different temporary registers.
|
||||
4. Reversed temporary initialization order: seven differences; restored attempt 2.
|
||||
|
||||
## PFCLUSTER_InsertCluster (126 instructions)
|
||||
|
||||
1. Initial C reconstruction: 28 register differences; stack locations and instruction count match. Retained.
|
||||
2. Reused the incoming cluster count as the allocation-loop byte count: the same 28 differences.
|
||||
3. Copied the incoming count to an allocation local before the first call: 29 differences, including changed argument scheduling; no improved register assignment.
|
||||
4. Initialized the allocation count before tracing and removed the loop initializer: 36 differences, with the same total instruction count; restored attempt 1.
|
||||
|
||||
## PFCLUSTER_DeleteCluster (108 instructions)
|
||||
|
||||
1. Initial C reconstruction: 51 differences, including reversed stack locations and saved-register assignments.
|
||||
2. Reordered output locals, moved volume before size locals, and reused the incoming count for the deletion byte count: 35 register differences; all stack locations and instruction count match. Retained.
|
||||
3. Reversed the volume/size declaration order: 42 register differences; no instruction-count improvement.
|
||||
4. Scoped the size computations in a nested block with a separate deletion-size local: 35 differences, with a different count register; restored attempt 2.
|
||||
|
||||
The forbidden-pattern scan initially classified the real FAT spare-chain variables as dummy objects because their inherited names contained `unused`. Renamed them to `spare`; these variables are consumed by chain tracing and freeing.
|
||||
Reference in New Issue
Block a user