Lines Matching refs: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));
881 mapping = array_get_next(&(s->mapping));
882 mapping->begin = 0;
883 mapping->dir_index = 0;
884 mapping->info.dir.parent_mapping_index = -1;
885 mapping->first_mapping_index = -1;
886 mapping->path = qemu_strdup(dirname);
887 i = strlen(mapping->path);
888 if (i > 0 && mapping->path[i - 1] == '/')
889 mapping->path[i - 1] = '\0';
890 mapping->mode = MODE_DIRECTORY;
891 mapping->read_only = 0;
892 s->path = mapping->path;
894 for (i = 0, cluster = 0; i < s->mapping.next; i++) {
899 mapping = array_get(&(s->mapping), i);
901 if (mapping->mode & MODE_DIRECTORY) {
902 mapping->begin = cluster;
905 mapping->path);
908 mapping = array_get(&(s->mapping), i);
910 assert(mapping->mode == MODE_UNDEFINED);
911 mapping->mode=MODE_NORMAL;
912 mapping->begin = cluster;
913 if (mapping->end > 0) {
915 mapping->dir_index);
917 mapping->end = cluster + 1 + (mapping->end-1)/s->cluster_size;
918 set_begin_of_direntry(direntry, mapping->begin);
920 mapping->end = cluster + 1;
925 assert(mapping->begin < mapping->end);
928 cluster = mapping->end;
942 for(j = mapping->begin; j < mapping->end - 1; j++)
944 fat_set(s, mapping->end - 1, s->max_fat_value);
948 mapping = array_get(&(s->mapping), 0);
949 s->sectors_of_root_directory = mapping->end * s->sectors_per_cluster;
950 s->last_cluster_of_root_directory = mapping->end;
1098 * return value is the index of the last mapping for which end>cluster_num
1104 mapping_t* mapping;
1106 mapping=array_get(&(s->mapping),index3);
1107 assert(mapping->begin < mapping->end);
1108 if(mapping->begin>=cluster_num) {
1115 return mapping->end<=cluster_num ? index2 : index1;
1119 DLOG(mapping=array_get(&(s->mapping),index1);
1120 assert(mapping->begin<=cluster_num);
1121 assert(index2 >= s->mapping.next ||
1122 ((mapping = array_get(&(s->mapping),index2)) &&
1123 mapping->end>cluster_num)));
1129 int index=find_mapping_for_cluster_aux(s,cluster_num,0,s->mapping.next);
1130 mapping_t* mapping;
1131 if(index>=s->mapping.next)
1133 mapping=array_get(&(s->mapping),index);
1134 if(mapping->begin>cluster_num)
1136 assert(mapping->begin<=cluster_num && mapping->end>cluster_num);
1137 return mapping;
1141 * This function simply compares path == mapping->path. Since the mappings
1149 for (i = 0; i < s->mapping.next; i++) {
1150 mapping_t* mapping = array_get(&(s->mapping), i);
1151 if (mapping->first_mapping_index < 0 &&
1152 !strcmp(path, mapping->path))
1153 return mapping;
1159 static int open_file(BDRVVVFATState* s,mapping_t* mapping)
1161 if(!mapping)
1164 strcmp(s->current_mapping->path,mapping->path)) {
1166 int fd = open(mapping->path, O_RDONLY | O_BINARY | O_LARGEFILE);
1171 s->current_mapping = mapping;
1186 mapping_t* mapping=find_mapping_for_cluster(s,cluster_num);
1188 assert(!mapping || (cluster_num>=mapping->begin && cluster_num<mapping->end));
1190 if (mapping && mapping->mode & MODE_DIRECTORY) {
1192 s->current_mapping = mapping;
1203 if(open_file(s,mapping))
1274 static void print_mapping(const mapping_t* mapping)
1276 fprintf(stderr, "mapping (%p): begin, end = %d, %d, dir_index = %d, "
1278 mapping, mapping->begin, mapping->end, mapping->dir_index,
1279 mapping->first_mapping_index, mapping->path, mapping->mode);
1281 if (mapping->mode & MODE_DIRECTORY)
1282 fprintf(stderr, "parent_mapping_index = %d, first_dir_index = %d\n", mapping->info.dir.parent_mapping_index, mapping->info.dir.first_dir_index);
1284 fprintf(stderr, "offset = %d\n", mapping->info.file.offset);
1345 * 4. walk the directories, fixing the mapping and direntries, and marking
1613 mapping_t* mapping = NULL;
1626 mapping = find_mapping_for_cluster(s, cluster_num);
1628 if (mapping) {
1631 assert(mapping->mode & MODE_DELETED);
1632 mapping->mode &= ~MODE_DELETED;
1634 basename = get_basename(mapping->path);
1636 assert(mapping->mode & MODE_NORMAL);
1653 if (mapping == NULL ||
1654 mapping->begin > cluster_num ||
1655 mapping->end <= cluster_num)
1656 mapping = find_mapping_for_cluster(s, cluster_num);
1659 if (mapping &&
1660 (mapping->mode & MODE_DIRECTORY) == 0) {
1663 if (offset != mapping->info.file.offset + s->cluster_size
1664 * (cluster_num - mapping->begin)) {
1669 const char* basename = get_basename(mapping->path);
1673 first_mapping_index = array_index(&(s->mapping), mapping);
1676 if (mapping->first_mapping_index != first_mapping_index
1677 && mapping->info.file.offset > 0) {
1685 schedule_writeout(s, mapping->dir_index, offset);
1739 mapping_t* mapping = find_mapping_for_cluster(s, cluster_num);
1750 if (mapping) {
1751 const char* basename = get_basename(mapping->path);
1754 assert(mapping->mode & MODE_DIRECTORY);
1756 assert(mapping->mode & MODE_DELETED);
1757 mapping->mode &= ~MODE_DELETED;
1896 for (i = 0; i < s->mapping.next; i++) {
1897 mapping_t* mapping = array_get(&(s->mapping), i);
1898 if (mapping->first_mapping_index < 0)
1899 mapping->mode |= MODE_DELETED;
1936 for (i = 0; i < s->mapping.next; i++) {
1937 mapping_t* mapping = array_get(&(s->mapping), i);
1940 if (mapping->name >= offset) \
1941 mapping->name += adjust
1944 if (mapping->mode & MODE_DIRECTORY)
1949 /* insert or update mapping */
1954 * - find mapping where mapping->begin >= begin,
1955 * - if mapping->begin > begin: insert
1960 int index = find_mapping_for_cluster_aux(s, begin, 0, s->mapping.next);
1961 mapping_t* mapping = NULL;
1962 mapping_t* first_mapping = array_get(&(s->mapping), 0);
1964 if (index < s->mapping.next && (mapping = array_get(&(s->mapping), index))
1965 && mapping->begin < begin) {
1966 mapping->end = begin;
1968 mapping = array_get(&(s->mapping), index);
1970 if (index >= s->mapping.next || mapping->begin > begin) {
1971 mapping = array_insert(&(s->mapping), index, 1);
1972 mapping->path = NULL;
1976 mapping->begin = begin;
1977 mapping->end = end;
1980 assert(index + 1 >= s->mapping.next ||
1981 ((next_mapping = array_get(&(s->mapping), index + 1)) &&
1984 if (s->current_mapping && first_mapping != (mapping_t*)s->mapping.pointer)
1985 s->current_mapping = array_get(&(s->mapping),
1988 return mapping;
1993 mapping_t* mapping = array_get(&(s->mapping), mapping_index);
1994 mapping_t* first_mapping = array_get(&(s->mapping), 0);
1996 /* free mapping */
1997 if (mapping->first_mapping_index < 0)
1998 free(mapping->path);
2000 /* remove from s->mapping */
2001 array_remove(&(s->mapping), mapping_index);
2006 if (s->current_mapping && first_mapping != (mapping_t*)s->mapping.pointer)
2007 s->current_mapping = array_get(&(s->mapping),
2016 for (i = 0; i < s->mapping.next; i++) {
2017 mapping_t* mapping = array_get(&(s->mapping), i);
2018 if (mapping->dir_index >= offset)
2019 mapping->dir_index += adjust;
2020 if ((mapping->mode & MODE_DIRECTORY) &&
2021 mapping->info.dir.first_dir_index >= offset)
2022 mapping->info.dir.first_dir_index += adjust;
2052 * to the modified fat, and the corresponding entries in s->mapping are
2058 mapping_t* mapping = find_mapping_for_cluster(s, first_cluster);
2064 assert(mapping);
2065 assert(mapping->begin == first_cluster);
2066 mapping->first_mapping_index = -1;
2067 mapping->dir_index = dir_index;
2068 mapping->mode = (dir_index <= 0 || is_directory(direntry)) ?
2078 if (c > mapping->end) {
2079 int index = array_index(&(s->mapping), mapping);
2080 int i, max_i = s->mapping.next - index;
2081 for (i = 1; i < max_i && mapping[i].begin < c; i++);
2085 assert(mapping == array_get(&(s->mapping), s->mapping.next - 1)
2086 || mapping[1].begin >= c);
2087 mapping->end = c;
2090 int i = find_mapping_for_cluster_aux(s, c1, 0, s->mapping.next);
2091 mapping_t* next_mapping = i >= s->mapping.next ? NULL :
2092 array_get(&(s->mapping), i);
2095 int i1 = array_index(&(s->mapping), mapping);
2101 mapping = array_get(&(s->mapping), i1);
2104 next_mapping->dir_index = mapping->dir_index;
2106 mapping->first_mapping_index < 0 ?
2107 array_index(&(s->mapping), mapping) :
2108 mapping->first_mapping_index;
2109 next_mapping->path = mapping->path;
2110 next_mapping->mode = mapping->mode;
2111 next_mapping->read_only = mapping->read_only;
2112 if (mapping->mode & MODE_DIRECTORY) {
2114 mapping->info.dir.parent_mapping_index;
2116 mapping->info.dir.first_dir_index +
2118 (mapping->end - mapping->begin);
2120 next_mapping->info.file.offset = mapping->info.file.offset +
2121 mapping->end - mapping->begin;
2123 mapping = next_mapping;
2137 mapping_t* mapping = find_mapping_for_cluster(s, first_cluster);
2141 int current_dir_index = mapping->info.dir.first_dir_index;
2146 DLOG(fprintf(stderr, "commit_direntries for %s, parent_mapping_index %d\n", mapping->path, parent_mapping_index));
2149 assert(mapping);
2150 assert(mapping->begin == first_cluster);
2151 assert(mapping->info.dir.first_dir_index < s->directory.next);
2152 assert(mapping->mode & MODE_DIRECTORY);
2155 mapping->info.dir.parent_mapping_index = parent_mapping_index;
2198 mapping = find_mapping_for_cluster(s, first_cluster);
2199 assert(mapping->mode & MODE_DIRECTORY);
2201 array_index(&(s->mapping), mapping));
2210 /* commit one file (adjust contents, adjust mapping),
2218 mapping_t* mapping = find_mapping_for_cluster(s, c);
2230 fd = open(mapping->path, O_RDWR | O_CREAT | O_BINARY, 0666);
2232 fprintf(stderr, "Could not open %s... (%s, %d)\n", mapping->path,
2279 for (i = 0; i < s->mapping.next; i++) {
2280 mapping_t* mapping = array_get(&(s->mapping), i);
2281 if (mapping->mode & MODE_DELETED) {
2285 assert(mapping->dir_index >= 0);
2286 assert(mapping->dir_index < s->directory.next);
2287 direntry_t* direntry = array_get(&(s->directory), mapping->dir_index);
2288 assert(mapping->begin == begin_of_direntry(direntry) || mapping->first_mapping_index >= 0);
2289 if (mapping->mode & MODE_DIRECTORY) {
2290 assert(mapping->info.dir.first_dir_index + 0x10 * s->sectors_per_cluster * (mapping->end - mapping->begin) <= s->directory.next);
2291 assert((mapping->info.dir.first_dir_index % (0x10 * s->sectors_per_cluster)) == 0);
2306 mapping_t* mapping = find_mapping_for_cluster(s, begin_of_direntry(direntry));
2307 assert(mapping);
2308 assert(mapping->dir_index == i || is_dot(direntry));
2309 assert(mapping->begin == begin_of_direntry(direntry) || is_dot(direntry));
2316 for (j = 0; j < s->mapping.next; j++) {
2317 mapping_t* mapping = array_get(&(s->mapping), j);
2318 if (mapping->mode & MODE_DELETED)
2320 if (mapping->mode & MODE_DIRECTORY) {
2321 if (mapping->info.dir.first_dir_index <= i && mapping->info.dir.first_dir_index + 0x10 * s->sectors_per_cluster > i) {
2323 if (mapping->first_mapping_index == -1)
2324 first_mapping = array_index(&(s->mapping), mapping);
2326 assert(first_mapping == mapping->first_mapping_index);
2327 if (mapping->info.dir.parent_mapping_index < 0)
2330 mapping_t* parent = array_get(&(s->mapping), mapping->info.dir.parent_mapping_index);
2332 assert(parent->info.dir.first_dir_index < mapping->info.dir.first_dir_index);
2359 mapping_t* mapping = find_mapping_for_cluster(s,
2361 char* old_path = mapping->path;
2364 mapping->path = commit->path;
2365 if (rename(old_path, mapping->path))
2368 if (mapping->mode & MODE_DIRECTORY) {
2369 int l1 = strlen(mapping->path);
2373 mapping->info.dir.first_dir_index);
2374 uint32_t c = mapping->begin;
2388 assert(!strncmp(m->path, mapping->path, l2));
2390 pstrcpy(new_path, l + diff + 1, mapping->path);
2406 mapping_t* mapping;
2417 mapping = insert_mapping(s, commit->param.mkdir.cluster,
2419 if (mapping == NULL)
2422 mapping->mode = MODE_DIRECTORY;
2423 mapping->read_only = 0;
2424 mapping->path = commit->path;
2429 mapping->info.dir.first_dir_index = j;
2433 for (j = 0; j < s->mapping.next; j++) {
2434 mapping_t* m = array_get(&(s->mapping), j);
2435 if (m->first_mapping_index < 0 && m != mapping &&
2436 !strncmp(m->path, mapping->path, parent_path_len) &&
2440 assert(j < s->mapping.next);
2441 mapping->info.dir.parent_mapping_index = j;
2474 mapping_t* mapping = find_mapping_for_cluster(s, begin);
2477 assert(mapping);
2478 assert(mapping->begin == begin);
2489 mapping_t* mapping = find_mapping_for_cluster(s, begin);
2505 /* make sure there exists an initial mapping */
2506 if (mapping && mapping->begin != begin) {
2507 mapping->end = begin;
2508 mapping = NULL;
2510 if (mapping == NULL) {
2511 mapping = insert_mapping(s, begin, begin+1);
2515 mapping->path = commit->path;
2516 mapping->read_only = 0;
2517 mapping->mode = MODE_NORMAL;
2518 mapping->info.file.offset = 0;
2539 /* handle DELETEs and unused mappings (modified_fat_get(s, mapping->begin) == 0) */
2544 for (i = 1; i < s->mapping.next; i++) {
2545 mapping_t* mapping = array_get(&(s->mapping), i);
2546 if (mapping->mode & MODE_DELETED) {
2548 mapping->dir_index);
2552 if (mapping->mode & MODE_DIRECTORY) {
2554 first_dir_index = mapping->info.dir.first_dir_index;
2556 if (rmdir(mapping->path) < 0) {
2564 for (j = 1; j < s->mapping.next; j++) {
2565 mapping_t* m = array_get(&(s->mapping), j);
2580 if (unlink(mapping->path))
2584 DLOG(fprintf(stderr, "DELETE (%d)\n", i); print_mapping(mapping); print_direntry(entry));
2594 * synchronize mapping with new state:
2681 mapping_t* mapping = find_mapping_for_cluster(s, i);
2682 if (mapping) {
2683 if (mapping->read_only) {
2685 mapping->path);
2689 if (mapping->mode & MODE_DIRECTORY) {
2702 dir_index = mapping->dir_index +
2703 0x10 * (begin - mapping->begin * s->sectors_per_cluster);
2724 i = mapping->end;
2826 array_free(&(s->mapping));
2851 assert(((mapping_t*)array_get(&(vvv->mapping), 0))->end == 2);
2858 mapping_t* mapping;
2860 assert(vvv->mapping.size >= vvv->mapping.item_size * vvv->mapping.next);
2862 if (vvv->mapping.next<47)
2864 assert((mapping = array_get(&(vvv->mapping), 47)));
2865 assert(mapping->dir_index < vvv->directory.next);
2866 direntry = array_get(&(vvv->directory), mapping->dir_index);