ra8_fs_fat_protos_a_internal.h

Go to the documentation of this file.

 
#pragma once
 
#include "ra8_attributes.h"
#include "ra8_fs_fat_types_internal.h"
 
/* ===========================================================================
 * Cross-TU helper prototypes. Each is defined `static`-free in exactly one
 * FAT/exFAT translation unit and called from at least one other.
 * ===========================================================================
 */

RA8_PRIV
void priv_83_to_str(const uint8_t* in11, uint8_t ntres, char* out13);

RA8_PRIV
ra8_err_t priv_alloc_cluster(const ra8_fs_mount_t* m, uint32_t* out_cluster);

RA8_PRIV
ra8_err_t priv_alloc_eoc_cluster(const ra8_fs_mount_t* m, uint32_t* out_c);

RA8_PRIV
ra8_fs_file_t* priv_alloc_file_slot(void);

RA8_PRIV
char priv_ascii_upper(char c);

RA8_PRIV
void priv_byte_copy(uint8_t* dst, const uint8_t* src, uint32_t n);

RA8_PRIV
uint8_t priv_byte_equal(const uint8_t* a, const uint8_t* b, uint32_t n);

RA8_PRIV
RA8_EXPECTS_LOCK("ra8_fs_lock")
ra8_err_t priv_close_locked(ra8_fs_file_t* file);

RA8_PRIV
uint64_t priv_cluster_to_lba(const ra8_fs_mount_t* m, uint32_t cluster);

RA8_PRIV
ra8_err_t priv_dir_find(const ra8_fs_mount_t* m,
                        const dir_loc_t*      loc,
                        const uint8_t*        name83,
                        uint64_t*             out_lba,
                        uint32_t*             out_entry_off,
                        uint8_t               out_entry[k_ra8_fs_dir_entry_bytes]);

RA8_PRIV
ra8_err_t priv_dir_find_long(const ra8_fs_mount_t* m,
                             const dir_loc_t*      loc,
                             const char*           want,
                             uint64_t*             out_lba,
                             uint32_t*             out_entry_off,
                             uint8_t               out_entry[k_ra8_fs_dir_entry_bytes]);

RA8_PRIV
void priv_dir_walk_init_loc(const ra8_fs_mount_t* m, const dir_loc_t* loc, dir_walk_t* w);

RA8_PRIV
ra8_err_t priv_dir_walk_next_sector(const ra8_fs_mount_t* m, dir_walk_t* w, uint8_t* out_eod);

RA8_PRIV
uint32_t priv_entry_first_cluster(const uint8_t* entry);

RA8_PRIV
void priv_entry_set_cluster_size(uint8_t* entry, uint32_t cluster, uint32_t size);
RA8_PRIV
uint32_t priv_eoc_write(const ra8_fs_mount_t* m);

RA8_PRIV
ra8_err_t
priv_exfat_bmp_switch(const ra8_fs_mount_t* m, uint64_t lba, uint64_t* loaded, uint8_t* sec);

RA8_PRIV
uint32_t priv_exfat_csum32(uint32_t cs, const uint8_t* buf, uint32_t len);

RA8_PRIV
ra8_err_t priv_exfat_find(const ra8_fs_mount_t* m,
                          const exfat_dir_t*    dir,
                          const char*           path,
                          uint8_t*              out_strm,
                          uint8_t*              out_attr);

RA8_PRIV
ra8_err_t priv_exfat_find_bitmap(const ra8_fs_mount_t* m, uint32_t* out_clus, uint32_t* out_len);

RA8_PRIV
ra8_err_t priv_exfat_format(const ra8_fs_backend_t* backend,
                            uint64_t                total_sectors,
                            uint32_t                bps,
                            const char*             label);

RA8_PRIV
ra8_err_t priv_exfat_listdir(const ra8_fs_mount_t* m,
                             const exfat_dir_t*    dir,
                             ra8_fs_listdir_cb_t   cb,
                             void*                 ctx);
RA8_PRIV ra8_err_t priv_exfat_dir_next(const ra8_fs_mount_t* m,
                                       exfat_cursor_t*       cur,
                                       ra8_fs_dirent_t*      out,
                                       bool*                 out_entry);
RA8_PRIV
uint8_t
priv_exfat_name_chunk_eq(const uint8_t* entry, const uint16_t* name, uint32_t pos, uint32_t nlen);

RA8_PRIV
uint16_t priv_exfat_name_hash(const uint16_t* name, uint32_t nlen);

RA8_PRIV
ra8_err_t priv_exfat_name_to_units(const ra8_fs_mount_t* m,
                                   const char*           path,
                                   uint16_t*             out,
                                   uint32_t*             out_units);

RA8_PRIV
ra8_err_t priv_exfat_needle_units(const ra8_fs_mount_t* m,
                                  const char*           name,
                                  uint16_t*             out,
                                  uint32_t*             out_units,
                                  ra8_err_t             too_long);

RA8_PRIV
ra8_err_t priv_exfat_next_entry(const ra8_fs_mount_t* m, exfat_cursor_t* cur, uint8_t* out);

RA8_PRIV
ra8_err_t priv_exfat_open(ra8_fs_mount_t* handle,
                          const char*     path,
                          ra8_fs_mode_t   mode,
                          ra8_fs_file_t** out_file);

RA8_PRIV
ra8_err_t priv_exfat_rename(const ra8_fs_mount_t* m, const char* old_path, const char* new_path);

RA8_PRIV
uint16_t priv_exfat_set_checksum(const uint8_t* set, uint32_t bytes);

RA8_PRIV
ra8_err_t priv_exfat_unlink(const ra8_fs_mount_t* m, const char* path);

RA8_PRIV
uint16_t priv_exfat_upcase_unit(uint16_t unit);

RA8_PRIV
uint32_t priv_exfat_upcase_checksum(void);

RA8_PRIV
void priv_exfat_upcase_verify(ra8_fs_mount_t* m);