Lines Matching full:mapping
315 static void print_mapping(const struct mapping_t* mapping);
326 array_t fat,directory,mapping;
692 * Read a directory. (the index of the corresponding mapping must be passed).
696 mapping_t* mapping = array_get(&(s->mapping), mapping_index);
698 const char* dirname = mapping->path;
699 int first_cluster = mapping->begin;
700 int parent_index = mapping->info.dir.parent_mapping_index;
702 (parent_index >= 0 ? array_get(&(s->mapping), parent_index) : NULL);
709 assert(mapping->mode & MODE_DIRECTORY);
712 mapping->end = mapping->begin;
716 i = mapping->info.dir.first_dir_index =
763 /* create mapping for this file */
765 s->current_mapping=(mapping_t*)array_get_next(&(s->mapping));
805 /* reget the mapping, since s->mapping was possibly realloc()ed */
806 mapping = (mapping_t*)array_get(&(s->mapping), mapping_index);
807 first_cluster += (s->directory.next - mapping->info.dir.first_dir_index)
809 mapping->end = first_cluster;
811 direntry = (direntry_t*)array_get(&(s->directory), mapping->dir_index);
812 set_begin_of_direntry(direntry, mapping->begin);
833 static direntry_t* get_direntry_for_mapping(BDRVVVFATState* s,mapping_t* mapping)
835 if(mapping->mode==MODE_UNDEFINED)
837 return (direntry_t*)(s->directory.pointer+sizeof(direntry_t)*mapping->dir_index);
845 mapping_t* mapping;
864 array_init(&(s->mapping),sizeof(mapping_t));
880 mapping = array_get_next(&(s->mapping));
881 mapping->begin = 0;
882 mapping->dir_index = 0;
883 mapping->info.dir.parent_mapping_index = -1;
884 mapping->first_mapping_index = -1;
885 mapping->path = strdup(dirname);
886 i = strlen(mapping->path);
887 if (i > 0 && mapping->path[i - 1] == '/')
888 mapping->path[i - 1] = '\0';
889 mapping->mode = MODE_DIRECTORY;
890 mapping->read_only = 0;
891 s->path = mapping->path;
893 for (i = 0, cluster = 0; i < s->mapping.next; i++) {
898 mapping = array_get(&(s->mapping), i);
900 if (mapping->mode & MODE_DIRECTORY) {
901 mapping->begin = cluster;
904 mapping->path);
907 mapping = array_get(&(s->mapping), i);
909 assert(mapping->mode == MODE_UNDEFINED);
910 mapping->mode=MODE_NORMAL;
911 mapping->begin = cluster;
912 if (mapping->end > 0) {
914 mapping->dir_index);
916 mapping->end = cluster + 1 + (mapping->end-1)/s->cluster_size;
917 set_begin_of_direntry(direntry, mapping->begin);
919 mapping->end = cluster + 1;
924 assert(mapping->begin < mapping->end);
927 cluster = mapping->end;
941 for(j = mapping->begin; j < mapping->end - 1; j++)
943 fat_set(s, mapping->end - 1, s->max_fat_value);
947 mapping = array_get(&(s->mapping), 0);
948 s->sectors_of_root_directory = mapping->end * s->sectors_per_cluster;
949 s->last_cluster_of_root_directory = mapping->end;
1097 * return value is the index of the last mapping for which end>cluster_num
1103 mapping_t* mapping;
1105 mapping=array_get(&(s->mapping),index3);
1106 assert(mapping->begin < mapping->end);
1107 if(mapping->begin>=cluster_num) {
1114 return mapping->end<=cluster_num ? index2 : index1;
1118 DLOG(mapping=array_get(&(s->mapping),index1);
1119 assert(mapping->begin<=cluster_num);
1120 assert(index2 >= s->mapping.next ||
1121 ((mapping = array_get(&(s->mapping),index2)) &&
1122 mapping->end>cluster_num)));
1128 int index=find_mapping_for_cluster_aux(s,cluster_num,0,s->mapping.next);
1129 mapping_t* mapping;
1130 if(index>=s->mapping.next)
1132 mapping=array_get(&(s->mapping),index);
1133 if(mapping->begin>cluster_num)
1135 assert(mapping->begin<=cluster_num && mapping->end>cluster_num);
1136 return mapping;
1140 * This function simply compares path == mapping->path. Since the mappings
1148 for (i = 0; i < s->mapping.next; i++) {
1149 mapping_t* mapping = array_get(&(s->mapping), i);
1150 if (mapping->first_mapping_index < 0 &&
1151 !strcmp(path, mapping->path))
1152 return mapping;
1158 static int open_file(BDRVVVFATState* s,mapping_t* mapping)
1160 if(!mapping)
1163 strcmp(s->current_mapping->path,mapping->path)) {
1165 int fd = open(mapping->path, O_RDONLY | O_BINARY | O_LARGEFILE);
1170 s->current_mapping = mapping;
1185 mapping_t* mapping=find_mapping_for_cluster(s,cluster_num);
1187 assert(!mapping || (cluster_num>=mapping->begin && cluster_num<mapping->end));
1189 if (mapping && mapping->mode & MODE_DIRECTORY) {
1191 s->current_mapping = mapping;
1202 if(open_file(s,mapping))
1273 static void print_mapping(const mapping_t* mapping)
1275 fprintf(stderr, "mapping (0x%x): begin, end = %d, %d, dir_index = %d, first_mapping_index = %d, name = %s, mode = 0x%x, " , (int)mapping, mapping->begin, mapping->end, mapping->dir_index, mapping->first_mapping_index, mapping->path, mapping->mode);
1276 if (mapping->mode & MODE_DIRECTORY)
1277 fprintf(stderr, "parent_mapping_index = %d, first_dir_index = %d\n", mapping->info.dir.parent_mapping_index, mapping->info.dir.first_dir_index);
1279 fprintf(stderr, "offset = %d\n", mapping->info.file.offset);
1340 * 4. walk the directories, fixing the mapping and direntries, and marking
1608 mapping_t* mapping = NULL;
1621 mapping = find_mapping_for_cluster(s, cluster_num);
1623 if (mapping) {
1626 assert(mapping->mode & MODE_DELETED);
1627 mapping->mode &= ~MODE_DELETED;
1629 basename = get_basename(mapping->path);
1631 assert(mapping->mode & MODE_NORMAL);
1648 if (mapping == NULL ||
1649 mapping->begin > cluster_num ||
1650 mapping->end <= cluster_num)
1651 mapping = find_mapping_for_cluster(s, cluster_num);
1654 if (mapping &&
1655 (mapping->mode & MODE_DIRECTORY) == 0) {
1658 if (offset != mapping->info.file.offset + s->cluster_size
1659 * (cluster_num - mapping->begin)) {
1664 const char* basename = get_basename(mapping->path);
1668 first_mapping_index = array_index(&(s->mapping), mapping);
1671 if (mapping->first_mapping_index != first_mapping_index
1672 && mapping->info.file.offset > 0) {
1680 schedule_writeout(s, mapping->dir_index, offset);
1734 mapping_t* mapping = find_mapping_for_cluster(s, cluster_num);
1745 if (mapping) {
1746 const char* basename = get_basename(mapping->path);
1749 assert(mapping->mode & MODE_DIRECTORY);
1751 assert(mapping->mode & MODE_DELETED);
1752 mapping->mode &= ~MODE_DELETED;
1891 for (i = 0; i < s->mapping.next; i++) {
1892 mapping_t* mapping = array_get(&(s->mapping), i);
1893 if (mapping->first_mapping_index < 0)
1894 mapping->mode |= MODE_DELETED;
1931 for (i = 0; i < s->mapping.next; i++) {
1932 mapping_t* mapping = array_get(&(s->mapping), i);
1935 if (mapping->name >= offset) \
1936 mapping->name += adjust
1939 if (mapping->mode & MODE_DIRECTORY)
1944 /* insert or update mapping */
1949 * - find mapping where mapping->begin >= begin,
1950 * - if mapping->begin > begin: insert
1955 int index = find_mapping_for_cluster_aux(s, begin, 0, s->mapping.next);
1956 mapping_t* mapping = NULL;
1957 mapping_t* first_mapping = array_get(&(s->mapping), 0);
1959 if (index < s->mapping.next && (mapping = array_get(&(s->mapping), index))
1960 && mapping->begin < begin) {
1961 mapping->end = begin;
1963 mapping = array_get(&(s->mapping), index);
1965 if (index >= s->mapping.next || mapping->begin > begin) {
1966 mapping = array_insert(&(s->mapping), index, 1);
1967 mapping->path = NULL;
1971 mapping->begin = begin;
1972 mapping->end = end;
1975 assert(index + 1 >= s->mapping.next ||
1976 ((next_mapping = array_get(&(s->mapping), index + 1)) &&
1979 if (s->current_mapping && first_mapping != (mapping_t*)s->mapping.pointer)
1980 s->current_mapping = array_get(&(s->mapping),
1983 return mapping;
1988 mapping_t* mapping = array_get(&(s->mapping), mapping_index);
1989 mapping_t* first_mapping = array_get(&(s->mapping), 0);
1991 /* free mapping */
1992 if (mapping->first_mapping_index < 0)
1993 free(mapping->path);
1995 /* remove from s->mapping */
1996 array_remove(&(s->mapping), mapping_index);
2001 if (s->current_mapping && first_mapping != (mapping_t*)s->mapping.pointer)
2002 s->current_mapping = array_get(&(s->mapping),
2011 for (i = 0; i < s->mapping.next; i++) {
2012 mapping_t* mapping = array_get(&(s->mapping), i);
2013 if (mapping->dir_index >= offset)
2014 mapping->dir_index += adjust;
2015 if ((mapping->mode & MODE_DIRECTORY) &&
2016 mapping->info.dir.first_dir_index >= offset)
2017 mapping->info.dir.first_dir_index += adjust;
2047 * to the modified fat, and the corresponding entries in s->mapping are
2053 mapping_t* mapping = find_mapping_for_cluster(s, first_cluster);
2059 assert(mapping);
2060 assert(mapping->begin == first_cluster);
2061 mapping->first_mapping_index = -1;
2062 mapping->dir_index = dir_index;
2063 mapping->mode = (dir_index <= 0 || is_directory(direntry)) ?
2073 if (c > mapping->end) {
2074 int index = array_index(&(s->mapping), mapping);
2075 int i, max_i = s->mapping.next - index;
2076 for (i = 1; i < max_i && mapping[i].begin < c; i++);
2080 assert(mapping == array_get(&(s->mapping), s->mapping.next - 1)
2081 || mapping[1].begin >= c);
2082 mapping->end = c;
2085 int i = find_mapping_for_cluster_aux(s, c1, 0, s->mapping.next);
2086 mapping_t* next_mapping = i >= s->mapping.next ? NULL :
2087 array_get(&(s->mapping), i);
2090 int i1 = array_index(&(s->mapping), mapping);
2096 mapping = array_get(&(s->mapping), i1);
2099 next_mapping->dir_index = mapping->dir_index;
2101 mapping->first_mapping_index < 0 ?
2102 array_index(&(s->mapping), mapping) :
2103 mapping->first_mapping_index;
2104 next_mapping->path = mapping->path;
2105 next_mapping->mode = mapping->mode;
2106 next_mapping->read_only = mapping->read_only;
2107 if (mapping->mode & MODE_DIRECTORY) {
2109 mapping->info.dir.parent_mapping_index;
2111 mapping->info.dir.first_dir_index +
2113 (mapping->end - mapping->begin);
2115 next_mapping->info.file.offset = mapping->info.file.offset +
2116 mapping->end - mapping->begin;
2118 mapping = next_mapping;
2132 mapping_t* mapping = find_mapping_for_cluster(s, first_cluster);
2136 int current_dir_index = mapping->info.dir.first_dir_index;
2141 DLOG(fprintf(stderr, "commit_direntries for %s, parent_mapping_index %d\n", mapping->path, parent_mapping_index));
2144 assert(mapping);
2145 assert(mapping->begin == first_cluster);
2146 assert(mapping->info.dir.first_dir_index < s->directory.next);
2147 assert(mapping->mode & MODE_DIRECTORY);
2150 mapping->info.dir.parent_mapping_index = parent_mapping_index;
2193 mapping = find_mapping_for_cluster(s, first_cluster);
2194 assert(mapping->mode & MODE_DIRECTORY);
2196 array_index(&(s->mapping), mapping));
2205 /* commit one file (adjust contents, adjust mapping),
2213 mapping_t* mapping = find_mapping_for_cluster(s, c);
2225 fd = open(mapping->path, O_RDWR | O_CREAT | O_BINARY, 0666);
2227 fprintf(stderr, "Could not open %s... (%s, %d)\n", mapping->path,
2270 for (i = 0; i < s->mapping.next; i++) {
2271 mapping_t* mapping = array_get(&(s->mapping), i);
2272 if (mapping->mode & MODE_DELETED) {
2276 assert(mapping->dir_index >= 0);
2277 assert(mapping->dir_index < s->directory.next);
2278 direntry_t* direntry = array_get(&(s->directory), mapping->dir_index);
2279 assert(mapping->begin == begin_of_direntry(direntry) || mapping->first_mapping_index >= 0);
2280 if (mapping->mode & MODE_DIRECTORY) {
2281 assert(mapping->info.dir.first_dir_index + 0x10 * s->sectors_per_cluster * (mapping->end - mapping->begin) <= s->directory.next);
2282 assert((mapping->info.dir.first_dir_index % (0x10 * s->sectors_per_cluster)) == 0);
2297 mapping_t* mapping = find_mapping_for_cluster(s, begin_of_direntry(direntry));
2298 assert(mapping);
2299 assert(mapping->dir_index == i || is_dot(direntry));
2300 assert(mapping->begin == begin_of_direntry(direntry) || is_dot(direntry));
2307 for (j = 0; j < s->mapping.next; j++) {
2308 mapping_t* mapping = array_get(&(s->mapping), j);
2309 if (mapping->mode & MODE_DELETED)
2311 if (mapping->mode & MODE_DIRECTORY) {
2312 if (mapping->info.dir.first_dir_index <= i && mapping->info.dir.first_dir_index + 0x10 * s->sectors_per_cluster > i) {
2314 if (mapping->first_mapping_index == -1)
2315 first_mapping = array_index(&(s->mapping), mapping);
2317 assert(first_mapping == mapping->first_mapping_index);
2318 if (mapping->info.dir.parent_mapping_index < 0)
2321 mapping_t* parent = array_get(&(s->mapping), mapping->info.dir.parent_mapping_index);
2323 assert(parent->info.dir.first_dir_index < mapping->info.dir.first_dir_index);
2350 mapping_t* mapping = find_mapping_for_cluster(s,
2352 char* old_path = mapping->path;
2355 mapping->path = commit->path;
2356 if (rename(old_path, mapping->path))
2359 if (mapping->mode & MODE_DIRECTORY) {
2360 int l1 = strlen(mapping->path);
2364 mapping->info.dir.first_dir_index);
2365 uint32_t c = mapping->begin;
2379 assert(!strncmp(m->path, mapping->path, l2));
2381 pstrcpy(new_path, l + diff + 1, mapping->path);
2397 mapping_t* mapping;
2408 mapping = insert_mapping(s, commit->param.mkdir.cluster,
2410 if (mapping == NULL)
2413 mapping->mode = MODE_DIRECTORY;
2414 mapping->read_only = 0;
2415 mapping->path = commit->path;
2420 mapping->info.dir.first_dir_index = j;
2424 for (j = 0; j < s->mapping.next; j++) {
2425 mapping_t* m = array_get(&(s->mapping), j);
2426 if (m->first_mapping_index < 0 && m != mapping &&
2427 !strncmp(m->path, mapping->path, parent_path_len) &&
2431 assert(j < s->mapping.next);
2432 mapping->info.dir.parent_mapping_index = j;
2463 mapping_t* mapping = find_mapping_for_cluster(s, begin);
2465 assert(mapping);
2466 assert(mapping->begin == begin);
2477 mapping_t* mapping = find_mapping_for_cluster(s, begin);
2493 /* make sure there exists an initial mapping */
2494 if (mapping && mapping->begin != begin) {
2495 mapping->end = begin;
2496 mapping = NULL;
2498 if (mapping == NULL) {
2499 mapping = insert_mapping(s, begin, begin+1);
2503 mapping->path = commit->path;
2504 mapping->read_only = 0;
2505 mapping->mode = MODE_NORMAL;
2506 mapping->info.file.offset = 0;
2527 /* handle DELETEs and unused mappings (modified_fat_get(s, mapping->begin) == 0) */
2532 for (i = 1; i < s->mapping.next; i++) {
2533 mapping_t* mapping = array_get(&(s->mapping), i);
2534 if (mapping->mode & MODE_DELETED) {
2536 mapping->dir_index);
2540 if (mapping->mode & MODE_DIRECTORY) {
2542 first_dir_index = mapping->info.dir.first_dir_index;
2544 if (rmdir(mapping->path) < 0) {
2552 for (j = 1; j < s->mapping.next; j++) {
2553 mapping_t* m = array_get(&(s->mapping), j);
2568 if (unlink(mapping->path))
2572 DLOG(fprintf(stderr, "DELETE (%d)\n", i); print_mapping(mapping); print_direntry(entry));
2582 * synchronize mapping with new state:
2669 mapping_t* mapping = find_mapping_for_cluster(s, i);
2670 if (mapping) {
2671 if (mapping->read_only) {
2673 mapping->path);
2677 if (mapping->mode & MODE_DIRECTORY) {
2690 dir_index = mapping->dir_index +
2691 0x10 * (begin - mapping->begin * s->sectors_per_cluster);
2712 i = mapping->end;
2811 array_free(&(s->mapping));
2836 assert(((mapping_t*)array_get(&(vvv->mapping), 0))->end == 2);
2843 mapping_t* mapping;
2845 assert(vvv->mapping.size >= vvv->mapping.item_size * vvv->mapping.next);
2847 if (vvv->mapping.next<47)
2849 assert((mapping = array_get(&(vvv->mapping), 47)));
2850 assert(mapping->dir_index < vvv->directory.next);
2851 direntry = array_get(&(vvv->directory), mapping->dir_index);
