| #include <dprintf.h> |
| #include <stdio.h> |
| #include <ctype.h> |
| #include <string.h> |
| #include <sys/dirent.h> |
| #include <cache.h> |
| #include <core.h> |
| #include <disk.h> |
| #include <fs.h> |
| #include <ilog2.h> |
| #include <klibc/compiler.h> |
| #include "codepage.h" |
| #include "fat_fs.h" |
| |
| static struct inode * new_fat_inode(struct fs_info *fs) |
| { |
| struct inode *inode = alloc_inode(fs, 0, sizeof(struct fat_pvt_inode)); |
| if (!inode) |
| malloc_error("inode structure"); |
| |
| return inode; |
| } |
| |
| /* |
| * Check for a particular sector in the FAT cache |
| */ |
| static const void *get_fat_sector(struct fs_info *fs, sector_t sector) |
| { |
| return get_cache(fs->fs_dev, FAT_SB(fs)->fat + sector); |
| } |
| |
| static uint32_t get_next_cluster(struct fs_info *fs, uint32_t clust_num) |
| { |
| uint32_t next_cluster = 0; |
| sector_t fat_sector; |
| uint32_t offset; |
| uint32_t sector_mask = SECTOR_SIZE(fs) - 1; |
| const uint8_t *data; |
| |
| switch(FAT_SB(fs)->fat_type) { |
| case FAT12: |
| offset = clust_num + (clust_num >> 1); |
| fat_sector = offset >> SECTOR_SHIFT(fs); |
| offset &= sector_mask; |
| data = get_fat_sector(fs, fat_sector); |
| if (offset == sector_mask) { |
| /* |
| * we got the end of the one fat sector, |
| * but we have just one byte and we need two, |
| * so store the low part, then read the next fat |
| * sector, read the high part, then combine it. |
| */ |
| next_cluster = data[offset]; |
| data = get_fat_sector(fs, fat_sector + 1); |
| next_cluster += data[0] << 8; |
| } else { |
| next_cluster = *(const uint16_t *)(data + offset); |
| } |
| |
| if (clust_num & 0x0001) |
| next_cluster >>= 4; /* cluster number is ODD */ |
| else |
| next_cluster &= 0x0fff; /* cluster number is EVEN */ |
| break; |
| |
| case FAT16: |
| offset = clust_num << 1; |
| fat_sector = offset >> SECTOR_SHIFT(fs); |
| offset &= sector_mask; |
| data = get_fat_sector(fs, fat_sector); |
| next_cluster = *(const uint16_t *)(data + offset); |
| break; |
| |
| case FAT32: |
| offset = clust_num << 2; |
| fat_sector = offset >> SECTOR_SHIFT(fs); |
| offset &= sector_mask; |
| data = get_fat_sector(fs, fat_sector); |
| next_cluster = *(const uint32_t *)(data + offset); |
| next_cluster &= 0x0fffffff; |
| break; |
| } |
| |
| return next_cluster; |
| } |
| |
| static int fat_next_extent(struct inode *inode, uint32_t lstart) |
| { |
| struct fs_info *fs = inode->fs; |
| struct fat_sb_info *sbi = FAT_SB(fs); |
| uint32_t mcluster = lstart >> sbi->clust_shift; |
| uint32_t lcluster; |
| uint32_t pcluster; |
| uint32_t tcluster; |
| uint32_t xcluster; |
| const uint32_t cluster_bytes = UINT32_C(1) << sbi->clust_byte_shift; |
| const uint32_t cluster_secs = UINT32_C(1) << sbi->clust_shift; |
| sector_t data_area = sbi->data; |
| |
| tcluster = (inode->size + cluster_bytes - 1) >> sbi->clust_byte_shift; |
| if (mcluster >= tcluster) |
| goto err; /* Requested cluster beyond end of file */ |
| |
| lcluster = PVT(inode)->offset >> sbi->clust_shift; |
| pcluster = ((PVT(inode)->here - data_area) >> sbi->clust_shift) + 2; |
| |
| if (lcluster > mcluster || PVT(inode)->here < data_area) { |
| lcluster = 0; |
| pcluster = PVT(inode)->start_cluster; |
| } |
| |
| for (;;) { |
| if (pcluster-2 >= sbi->clusters) { |
| inode->size = lcluster << sbi->clust_shift; |
| goto err; |
| } |
| |
| if (lcluster >= mcluster) |
| break; |
| |
| lcluster++; |
| pcluster = get_next_cluster(fs, pcluster); |
| } |
| |
| inode->next_extent.pstart = |
| ((sector_t)(pcluster-2) << sbi->clust_shift) + data_area; |
| inode->next_extent.len = cluster_secs; |
| xcluster = 0; /* Nonsense */ |
| |
| while (++lcluster < tcluster) { |
| xcluster = get_next_cluster(fs, pcluster); |
| if (xcluster != ++pcluster) |
| break; /* Not contiguous */ |
| inode->next_extent.len += cluster_secs; |
| } |
| |
| /* Note: ->here is bogus if ->offset >= EOF, but that's okay */ |
| PVT(inode)->offset = lcluster << sbi->clust_shift; |
| PVT(inode)->here = ((xcluster-2) << sbi->clust_shift) + data_area; |
| |
| return 0; |
| |
| err: |
| dprintf("fat_next_extent: return error\n"); |
| return -1; |
| } |
| |
| static sector_t get_next_sector(struct fs_info* fs, uint32_t sector) |
| { |
| struct fat_sb_info *sbi = FAT_SB(fs); |
| sector_t data_area = sbi->data; |
| sector_t data_sector; |
| uint32_t cluster; |
| int clust_shift = sbi->clust_shift; |
| |
| if (sector < data_area) { |
| /* Root directory sector... */ |
| sector++; |
| if (sector >= data_area) |
| sector = 0; /* Ran out of root directory, return EOF */ |
| return sector; |
| } |
| |
| data_sector = sector - data_area; |
| if ((data_sector + 1) & sbi->clust_mask) /* Still in the same cluster */ |
| return sector + 1; /* Next sector inside cluster */ |
| |
| /* get a new cluster */ |
| cluster = data_sector >> clust_shift; |
| cluster = get_next_cluster(fs, cluster + 2) - 2; |
| |
| if (cluster >= sbi->clusters) |
| return 0; |
| |
| /* return the start of the new cluster */ |
| sector = (cluster << clust_shift) + data_area; |
| return sector; |
| } |
| |
| /* |
| * The FAT is a single-linked list. We remember the last place we |
| * were, so for a forward seek we can move forward from there, but |
| * for a reverse seek we have to start over... |
| */ |
| static sector_t get_the_right_sector(struct file *file) |
| { |
| struct inode *inode = file->inode; |
| uint32_t sector_pos = file->offset >> SECTOR_SHIFT(file->fs); |
| uint32_t where; |
| sector_t sector; |
| |
| if (sector_pos < PVT(inode)->offset) { |
| /* Reverse seek */ |
| where = 0; |
| sector = PVT(inode)->start; |
| } else { |
| where = PVT(inode)->offset; |
| sector = PVT(inode)->here; |
| } |
| |
| while (where < sector_pos) { |
| sector = get_next_sector(file->fs, sector); |
| where++; |
| } |
| |
| PVT(inode)->offset = sector_pos; |
| PVT(inode)->here = sector; |
| |
| return sector; |
| } |
| |
| /* |
| * Get the next sector in sequence |
| */ |
| static sector_t next_sector(struct file *file) |
| { |
| struct inode *inode = file->inode; |
| sector_t sector = get_next_sector(file->fs, PVT(inode)->here); |
| PVT(inode)->offset++; |
| PVT(inode)->here = sector; |
| |
| return sector; |
| } |
| |
| /** |
| * mangle_name: |
| * |
| * Mangle a filename pointed to by src into a buffer pointed |
| * to by dst; ends on encountering any whitespace. |
| * dst is preserved. |
| * |
| * This verifies that a filename is < FILENAME_MAX characters, |
| * doesn't contain whitespace, zero-pads the output buffer, |
| * and removes redundant slashes. |
| * |
| * Unlike the generic version, this also converts backslashes to |
| * forward slashes. |
| * |
| */ |
| static void vfat_mangle_name(char *dst, const char *src) |
| { |
| char *p = dst; |
| int i = FILENAME_MAX-1; |
| char c; |
| |
| while (not_whitespace(c = *src)) { |
| if (c == '\\') |
| c = '/'; |
| |
| if (c == '/') { |
| if (src[1] == '/' || src[1] == '\\') { |
| src++; |
| i--; |
| continue; |
| } |
| } |
| i--; |
| *dst++ = *src++; |
| } |
| |
| while (1) { |
| if (dst == p) |
| break; |
| if (dst[-1] != '/') |
| break; |
| if ((dst[-1] == '/') && ((dst - 1) == p)) |
| break; |
| |
| dst--; |
| i++; |
| } |
| |
| i++; |
| for (; i > 0; i --) |
| *dst++ = '\0'; |
| } |
| |
| /* |
| * Mangle a normal style string to DOS style string. |
| */ |
| static void mangle_dos_name(char *mangle_buf, const char *src) |
| { |
| int i; |
| unsigned char c; |
| |
| if (src[0] == '.' && (!src[1] || (src[1] == '.' && !src[2]))) { |
| /* . and .. mangle to their respective zero-padded version */ |
| i = stpcpy(mangle_buf, src) - mangle_buf; |
| } else { |
| i = 0; |
| while (i < 11) { |
| c = *src++; |
| |
| if ((c <= ' ') || (c == '/')) |
| break; |
| |
| if (c == '.') { |
| while (i < 8) |
| mangle_buf[i++] = ' '; |
| i = 8; |
| continue; |
| } |
| |
| c = codepage.upper[c]; |
| if (i == 0 && c == 0xe5) |
| c = 0x05; /* Special hack for the first byte only! */ |
| |
| mangle_buf[i++] = c; |
| } |
| } |
| |
| while (i < 11) |
| mangle_buf[i++] = ' '; |
| |
| mangle_buf[i] = '\0'; |
| } |
| |
| /* |
| * Match a string name against a longname. "len" is the number of |
| * codepoints in the input; including padding. |
| * |
| * Returns true on match. |
| */ |
| static bool vfat_match_longname(const char *str, const uint16_t *match, |
| int len) |
| { |
| unsigned char c = -1; /* Nonzero: we have not yet seen NUL */ |
| uint16_t cp; |
| |
| dprintf("Matching: %s len %d\n", str, len); |
| |
| while (len) { |
| cp = *match++; |
| len--; |
| if (!cp) |
| break; |
| c = *str++; |
| if (cp != codepage.uni[0][c] && cp != codepage.uni[1][c]) |
| return false; /* Also handles c == '\0' */ |
| } |
| |
| /* This should have been the end of the matching string */ |
| if (*str) |
| return false; |
| |
| /* Any padding entries must be FFFF */ |
| while (len--) |
| if (*match++ != 0xffff) |
| return false; |
| |
| return true; |
| } |
| |
| /* |
| * Convert an UTF-16 longname to the system codepage; return |
| * the length on success or -1 on failure. |
| */ |
| static int vfat_cvt_longname(char *entry_name, const uint16_t *long_name) |
| { |
| struct unicache { |
| uint16_t utf16; |
| uint8_t cp; |
| }; |
| static struct unicache unicache[256]; |
| struct unicache *uc; |
| uint16_t cp; |
| unsigned int c; |
| char *p = entry_name; |
| |
| do { |
| cp = *long_name++; |
| uc = &unicache[cp % 256]; |
| |
| if (__likely(uc->utf16 == cp)) { |
| *p++ = uc->cp; |
| } else { |
| for (c = 0; c < 512; c++) { |
| /* This is a bit hacky... */ |
| if (codepage.uni[0][c] == cp) { |
| uc->utf16 = cp; |
| *p++ = uc->cp = (uint8_t)c; |
| goto found; |
| } |
| } |
| return -1; /* Impossible character */ |
| found: |
| ; |
| } |
| } while (cp); |
| |
| return (p-entry_name)-1; |
| } |
| |
| static void copy_long_chunk(uint16_t *buf, const struct fat_dir_entry *de) |
| { |
| const struct fat_long_name_entry *le = |
| (const struct fat_long_name_entry *)de; |
| |
| memcpy(buf, le->name1, 5 * 2); |
| memcpy(buf + 5, le->name2, 6 * 2); |
| memcpy(buf + 11, le->name3, 2 * 2); |
| } |
| |
| static uint8_t get_checksum(const char *dir_name) |
| { |
| int i; |
| uint8_t sum = 0; |
| |
| for (i = 11; i; i--) |
| sum = ((sum & 1) << 7) + (sum >> 1) + (uint8_t)*dir_name++; |
| return sum; |
| } |
| |
| |
| /* compute the first sector number of one dir where the data stores */ |
| static inline sector_t first_sector(struct fs_info *fs, |
| const struct fat_dir_entry *dir) |
| { |
| const struct fat_sb_info *sbi = FAT_SB(fs); |
| sector_t first_clust; |
| sector_t sector; |
| |
| first_clust = (dir->first_cluster_high << 16) + dir->first_cluster_low; |
| if (first_clust == 0) |
| sector = sbi->root; /* first_clust == 0 means root directory */ |
| else |
| sector = ((first_clust - 2) << sbi->clust_shift) + sbi->data; |
| |
| return sector; |
| } |
| |
| static inline enum dirent_type get_inode_mode(uint8_t attr) |
| { |
| return (attr & FAT_ATTR_DIRECTORY) ? DT_DIR : DT_REG; |
| } |
| |
| |
| static struct inode *vfat_find_entry(const char *dname, struct inode *dir) |
| { |
| struct fs_info *fs = dir->fs; |
| struct inode *inode; |
| const struct fat_dir_entry *de; |
| struct fat_long_name_entry *long_de; |
| |
| char mangled_name[12]; |
| uint16_t long_name[260]; /* == 20*13 */ |
| int long_len; |
| |
| sector_t dir_sector = PVT(dir)->start; |
| uint8_t vfat_init, vfat_next, vfat_csum = 0; |
| uint8_t id; |
| int slots; |
| int entries; |
| int checksum; |
| int long_match = 0; |
| |
| slots = (strlen(dname) + 12) / 13; |
| if (slots > 20) |
| return NULL; /* Name too long */ |
| |
| slots |= 0x40; |
| vfat_init = vfat_next = slots; |
| long_len = slots*13; |
| |
| /* Produce the shortname version, in case we need it. */ |
| mangle_dos_name(mangled_name, dname); |
| |
| while (dir_sector) { |
| de = get_cache(fs->fs_dev, dir_sector); |
| entries = 1 << (fs->sector_shift - 5); |
| |
| while (entries--) { |
| if (de->name[0] == 0) |
| return NULL; |
| |
| if (de->attr == 0x0f) { |
| /* |
| * It's a long name entry. |
| */ |
| long_de = (struct fat_long_name_entry *)de; |
| id = long_de->id; |
| if (id != vfat_next) |
| goto not_match; |
| |
| if (id & 0x40) { |
| /* get the initial checksum value */ |
| vfat_csum = long_de->checksum; |
| id &= 0x3f; |
| long_len = id * 13; |
| |
| /* ZERO the long_name buffer */ |
| memset(long_name, 0, sizeof long_name); |
| } else { |
| if (long_de->checksum != vfat_csum) |
| goto not_match; |
| } |
| |
| vfat_next = --id; |
| |
| /* got the long entry name */ |
| copy_long_chunk(long_name + id*13, de); |
| |
| /* |
| * If we got the last entry, check it. |
| * Or, go on with the next entry. |
| */ |
| if (id == 0) { |
| if (!vfat_match_longname(dname, long_name, long_len)) |
| goto not_match; |
| long_match = 1; |
| } |
| de++; |
| continue; /* Try the next entry */ |
| } else { |
| /* |
| * It's a short entry |
| */ |
| if (de->attr & 0x08) /* ignore volume labels */ |
| goto not_match; |
| |
| if (long_match) { |
| /* |
| * We already have a VFAT long name match. However, the |
| * match is only valid if the checksum matches. |
| */ |
| checksum = get_checksum(de->name); |
| if (checksum == vfat_csum) |
| goto found; /* Got it */ |
| } else { |
| if (!memcmp(mangled_name, de->name, 11)) |
| goto found; |
| } |
| } |
| |
| not_match: |
| vfat_next = vfat_init; |
| long_match = 0; |
| |
| de++; |
| } |
| |
| /* Try with the next sector */ |
| dir_sector = get_next_sector(fs, dir_sector); |
| } |
| return NULL; /* Nothing found... */ |
| |
| found: |
| inode = new_fat_inode(fs); |
| inode->size = de->file_size; |
| PVT(inode)->start_cluster = |
| (de->first_cluster_high << 16) + de->first_cluster_low; |
| if (PVT(inode)->start_cluster == 0) { |
| /* Root directory */ |
| int root_size = FAT_SB(fs)->root_size; |
| |
| PVT(inode)->start_cluster = FAT_SB(fs)->root_cluster; |
| inode->size = root_size ? root_size << fs->sector_shift : ~0; |
| PVT(inode)->start = PVT(inode)->here = FAT_SB(fs)->root; |
| } else { |
| PVT(inode)->start = PVT(inode)->here = first_sector(fs, de); |
| } |
| inode->mode = get_inode_mode(de->attr); |
| |
| return inode; |
| } |
| |
| static struct inode *vfat_iget_root(struct fs_info *fs) |
| { |
| struct inode *inode = new_fat_inode(fs); |
| int root_size = FAT_SB(fs)->root_size; |
| |
| /* |
| * For FAT32, the only way to get the root directory size is to |
| * follow the entire FAT chain to the end... which seems pointless. |
| */ |
| PVT(inode)->start_cluster = FAT_SB(fs)->root_cluster; |
| inode->size = root_size ? root_size << fs->sector_shift : ~0; |
| PVT(inode)->start = PVT(inode)->here = FAT_SB(fs)->root; |
| inode->mode = DT_DIR; |
| |
| return inode; |
| } |
| |
| static struct inode *vfat_iget(const char *dname, struct inode *parent) |
| { |
| return vfat_find_entry(dname, parent); |
| } |
| |
| static int vfat_readdir(struct file *file, struct dirent *dirent) |
| { |
| struct fs_info *fs = file->fs; |
| const struct fat_dir_entry *de; |
| const char *data; |
| const struct fat_long_name_entry *long_de; |
| |
| sector_t sector = get_the_right_sector(file); |
| |
| uint16_t long_name[261]; /* == 20*13 + 1 (to guarantee null) */ |
| char filename[261]; |
| int name_len = 0; |
| |
| uint8_t vfat_next, vfat_csum; |
| uint8_t id; |
| int entries_left; |
| bool long_entry = false; |
| int sec_off = file->offset & ((1 << fs->sector_shift) - 1); |
| |
| data = get_cache(fs->fs_dev, sector); |
| de = (const struct fat_dir_entry *)(data + sec_off); |
| entries_left = ((1 << fs->sector_shift) - sec_off) >> 5; |
| |
| vfat_next = vfat_csum = 0xff; |
| |
| while (1) { |
| while (entries_left--) { |
| if (de->name[0] == 0) |
| return -1; /* End of directory */ |
| if ((uint8_t)de->name[0] == 0xe5) |
| goto invalid; |
| |
| if (de->attr == 0x0f) { |
| /* |
| * It's a long name entry. |
| */ |
| long_de = (struct fat_long_name_entry *)de; |
| id = long_de->id; |
| |
| if (id & 0x40) { |
| /* init vfat_csum */ |
| vfat_csum = long_de->checksum; |
| id &= 0x3f; |
| if (id >= 20) |
| goto invalid; /* Too long! */ |
| |
| /* ZERO the long_name buffer */ |
| memset(long_name, 0, sizeof long_name); |
| } else { |
| if (long_de->checksum != vfat_csum || id != vfat_next) |
| goto invalid; |
| } |
| |
| vfat_next = --id; |
| |
| /* got the long entry name */ |
| copy_long_chunk(long_name + id*13, de); |
| |
| if (id == 0) { |
| name_len = vfat_cvt_longname(filename, long_name); |
| if (name_len > 0 && name_len < sizeof(dirent->d_name)) |
| long_entry = true; |
| } |
| |
| goto next; |
| } else { |
| /* |
| * It's a short entry |
| */ |
| if (de->attr & 0x08) /* ignore volume labels */ |
| goto invalid; |
| |
| if (long_entry && get_checksum(de->name) == vfat_csum) { |
| /* Got a long entry */ |
| } else { |
| /* Use the shortname */ |
| int i; |
| uint8_t c; |
| char *p = filename; |
| |
| for (i = 0; i < 8; i++) { |
| c = de->name[i]; |
| if (c == ' ') |
| break; |
| if (de->lcase & LCASE_BASE) |
| c = codepage.lower[c]; |
| *p++ = c; |
| } |
| if (de->name[8] != ' ') { |
| *p++ = '.'; |
| for (i = 8; i < 11; i++) { |
| c = de->name[i]; |
| if (c == ' ') |
| break; |
| if (de->lcase & LCASE_EXT) |
| c = codepage.lower[c]; |
| *p++ = c; |
| } |
| } |
| *p = '\0'; |
| name_len = p - filename; |
| } |
| goto got; /* Got something one way or the other */ |
| } |
| |
| invalid: |
| long_entry = false; |
| next: |
| de++; |
| file->offset += sizeof(struct fat_dir_entry); |
| } |
| |
| /* Try with the next sector */ |
| sector = next_sector(file); |
| if (!sector) |
| return -1; |
| de = get_cache(fs->fs_dev, sector); |
| entries_left = 1 << (fs->sector_shift - 5); |
| } |
| |
| got: |
| name_len++; /* Include final null */ |
| dirent->d_ino = de->first_cluster_low | (de->first_cluster_high << 16); |
| dirent->d_off = file->offset; |
| dirent->d_reclen = offsetof(struct dirent, d_name) + name_len; |
| dirent->d_type = get_inode_mode(de->attr); |
| memcpy(dirent->d_name, filename, name_len); |
| |
| file->offset += sizeof(*de); /* Update for next reading */ |
| |
| return 0; |
| } |
| |
| /* init. the fs meta data, return the block size in bits */ |
| static int vfat_fs_init(struct fs_info *fs) |
| { |
| struct fat_bpb fat; |
| struct fat_sb_info *sbi; |
| struct disk *disk = fs->fs_dev->disk; |
| int sectors_per_fat; |
| uint32_t clusters; |
| sector_t total_sectors; |
| |
| fs->sector_shift = fs->block_shift = disk->sector_shift; |
| fs->sector_size = 1 << fs->sector_shift; |
| fs->block_size = 1 << fs->block_shift; |
| |
| disk->rdwr_sectors(disk, &fat, 0, 1, 0); |
| |
| /* XXX: Find better sanity checks... */ |
| if (!fat.bxResSectors || !fat.bxFATs) |
| return -1; |
| sbi = malloc(sizeof(*sbi)); |
| if (!sbi) |
| malloc_error("fat_sb_info structure"); |
| fs->fs_info = sbi; |
| |
| sectors_per_fat = fat.bxFATsecs ? : fat.fat32.bxFATsecs_32; |
| total_sectors = fat.bxSectors ? : fat.bsHugeSectors; |
| |
| sbi->fat = fat.bxResSectors; |
| sbi->root = sbi->fat + sectors_per_fat * fat.bxFATs; |
| sbi->root_size = root_dir_size(fs, &fat); |
| sbi->data = sbi->root + sbi->root_size; |
| |
| sbi->clust_shift = ilog2(fat.bxSecPerClust); |
| sbi->clust_byte_shift = sbi->clust_shift + fs->sector_shift; |
| sbi->clust_mask = fat.bxSecPerClust - 1; |
| sbi->clust_size = fat.bxSecPerClust << fs->sector_shift; |
| |
| clusters = (total_sectors - sbi->data) >> sbi->clust_shift; |
| if (clusters <= 0xff4) { |
| sbi->fat_type = FAT12; |
| } else if (clusters <= 0xfff4) { |
| sbi->fat_type = FAT16; |
| } else { |
| sbi->fat_type = FAT32; |
| |
| if (clusters > 0x0ffffff4) |
| clusters = 0x0ffffff4; /* Maximum possible */ |
| |
| if (fat.fat32.extended_flags & 0x80) { |
| /* Non-mirrored FATs, we need to read the active one */ |
| sbi->fat += (fat.fat32.extended_flags & 0x0f) * sectors_per_fat; |
| } |
| |
| /* FAT32: root directory is a cluster chain */ |
| sbi->root = sbi->data |
| + ((fat.fat32.root_cluster-2) << sbi->clust_shift); |
| } |
| sbi->clusters = clusters; |
| |
| /* fs UUID - serial number */ |
| if (FAT32 == sbi->fat_type) |
| sbi->uuid = fat.fat32.num_serial; |
| else |
| sbi->uuid = fat.fat12_16.num_serial; |
| |
| /* Initialize the cache */ |
| cache_init(fs->fs_dev, fs->block_shift); |
| |
| return fs->block_shift; |
| } |
| |
| static int vfat_copy_superblock(void *buf) |
| { |
| struct fat_bpb fat; |
| struct disk *disk; |
| size_t sb_off; |
| void *dst; |
| int sb_len; |
| |
| disk = this_fs->fs_dev->disk; |
| disk->rdwr_sectors(disk, &fat, 0, 1, 0); |
| |
| /* XXX: Find better sanity checks... */ |
| if (!fat.bxResSectors || !fat.bxFATs) |
| return -1; |
| |
| sb_off = offsetof(struct fat_bpb, sector_size); |
| sb_len = offsetof(struct fat_bpb, fat12_16) - sb_off \ |
| + sizeof(fat.fat12_16); |
| |
| /* |
| * Only copy fields of the superblock we actually care about. |
| */ |
| dst = buf + sb_off; |
| memcpy(dst, (void *)&fat + sb_off, sb_len); |
| |
| return 0; |
| } |
| |
| #define FAT_UUID_LEN (4 + 1 + 4 + 1) |
| static char *vfat_fs_uuid(struct fs_info *fs) |
| { |
| char *uuid = NULL; |
| char *ptr; |
| |
| uuid = malloc(FAT_UUID_LEN); |
| if (!uuid) |
| return NULL; |
| |
| if (snprintf(uuid, FAT_UUID_LEN, "%04x-%04x", |
| (uint16_t)(FAT_SB(fs)->uuid >> 16), |
| (uint16_t)FAT_SB(fs)->uuid) < 0) { |
| free(uuid); |
| return NULL; |
| } |
| |
| for (ptr = uuid; ptr && *ptr; ptr++) |
| *ptr = toupper(*ptr); |
| |
| return uuid; |
| } |
| |
| const struct fs_ops vfat_fs_ops = { |
| .fs_name = "vfat", |
| .fs_flags = FS_USEMEM | FS_THISIND, |
| .fs_init = vfat_fs_init, |
| .searchdir = NULL, |
| .getfssec = generic_getfssec, |
| .close_file = generic_close_file, |
| .mangle_name = vfat_mangle_name, |
| .chdir_start = generic_chdir_start, |
| .open_config = generic_open_config, |
| .readdir = vfat_readdir, |
| .iget_root = vfat_iget_root, |
| .iget = vfat_iget, |
| .next_extent = fat_next_extent, |
| .copy_super = vfat_copy_superblock, |
| .fs_uuid = vfat_fs_uuid, |
| }; |