Lines Matching refs:Fs
156 static int comp_fat_bits(Fs_t *Fs, int estimate,
164 TOTAL_DISK_SIZE((bits), Fs->sector_size, (clusters), \
165 Fs->num_fat, MAX_BYTES_PER_CLUSTER/Fs->sector_size)
191 min_fat16_size = DISK_SIZE(16, Fs->sector_size, FAT12,
192 Fs->num_fat, 1);
223 static void calc_fat_bits2(Fs_t *Fs, unsigned long tot_sectors, int fat_bits,
233 rem_sect = tot_sectors - Fs->dir_len - Fs->fat_start;
238 DISK_SIZE( (bits), Fs->sector_size, (clusters), \
239 Fs->num_fat, Fs->cluster_size)
248 set_fat16(Fs);
251 set_fat12(Fs);
257 Fs->cluster_size * Fs->sector_size * 2
259 Fs->cluster_size <<= 1;
261 Fs->dir_len +=
264 set_fat12(Fs);
270 set_fat12(Fs);
273 set_fat16(Fs);
276 set_fat32(Fs);
281 static __inline__ void format_root(Fs_t *Fs, char *label, struct bootsector *boot)
293 buf = safe_malloc(Fs->sector_size);
294 RootDir = OpenRoot((Stream_t *)Fs);
300 memset(buf, '\0', Fs->sector_size);
302 if(Fs->fat_bits == 32) {
305 dirlen = Fs->cluster_size;
306 fatAllocate(Fs, Fs->rootCluster, Fs->end_fat);
308 dirlen = Fs->dir_len;
310 WRITES(RootDir, buf, sectorsToBytes((Stream_t*)Fs, i),
311 Fs->sector_size);
318 if(Fs->fat_bits == 32)
321 set_word(boot->dirents, Fs->dir_len * (Fs->sector_size / 32));
326 static void xdf_calc_fat_size(Fs_t *Fs, unsigned long tot_sectors,
331 rem_sect = tot_sectors - Fs->dir_len - Fs->fat_start - 2 * Fs->fat_len;
333 if(Fs->fat_len) {
339 for(Fs->cluster_size = 1; 1 ; Fs->cluster_size <<= 1) {
340 Fs->num_clus = rem_sect / Fs->cluster_size;
341 if(abs(fat_bits) == 16 || Fs->num_clus >= FAT12)
342 set_fat16(Fs);
344 set_fat12(Fs);
345 if (Fs->fat_len >= NEEDED_FAT_SIZE(Fs))
354 static void calc_fat_size(Fs_t *Fs, unsigned long tot_sectors)
365 fprintf(stderr, "Fat start=%d\n", Fs->fat_start);
367 fprintf(stderr, "dir_len=%d\n", Fs->dir_len);
369 real_rem_sect = rem_sect = tot_sectors - Fs->dir_len - Fs->fat_start;
375 Fs->num_fat %2 == 0 &&
376 Fs->cluster_size %2 == 0)
383 if(Fs->fat_bits == 0) {
394 fat_nybbles = Fs->fat_bits / 4;
395 numerator = rem_sect+2*Fs->cluster_size;
397 Fs->cluster_size * Fs->sector_size * 2 +
398 Fs->num_fat * fat_nybbles;
412 Fs->fat_len = (numerator-1)/denominator+1;
413 Fs->num_clus = (rem_sect-(Fs->fat_len*Fs->num_fat))/Fs->cluster_size;
416 if(Fs->fat_bits == 16 && Fs->num_clus >= FAT16)
417 Fs->num_clus = FAT16-1;
418 if(Fs->fat_bits == 12 && Fs->num_clus >= FAT12)
419 Fs->num_clus = FAT12-1;
422 if(Fs->num_clus > (Fs->fat_len * Fs->sector_size * 2 /
426 Fs->num_clus);
427 Fs->num_clus = (Fs->fat_len * Fs->sector_size * 2 /
429 fprintf(stderr, " to %d\n", Fs->num_clus);
433 Fs->num_clus, Fs->fat_len, fat_nybbles);
436 if ( Fs->num_clus < FAT16 && Fs->fat_bits > 16 ){
449 assert(rem_sect >= Fs->num_clus * Fs->cluster_size +
450 Fs->fat_len * Fs->num_fat);
453 Fs->num_clus * Fs->cluster_size -
454 Fs->fat_len * Fs->num_fat;
455 if(slack >= Fs->cluster_size) {
463 Fs->fat_len);
465 Fs->fat_len +=
466 (slack - Fs->cluster_size) / Fs->num_fat + 1;
470 Fs->fat_len);
472 Fs->num_clus = (rem_sect-(Fs->fat_len*Fs->num_fat))/
473 Fs->cluster_size;
479 assert( ((Fs->num_clus+2) * fat_nybbles) <=
480 (Fs->fat_len*Fs->sector_size*2));
485 assert(Fs->num_clus ==
486 (real_rem_sect - Fs->num_fat * Fs->fat_len) / Fs->cluster_size);
516 static void calc_cluster_size(struct Fs_t *Fs, unsigned long tot_sectors,
530 max_fat_size = Fs->num_fat *
531 FAT_SIZE(12, Fs->sector_size, max_clusters);
536 max_fat_size = Fs->num_fat *
537 FAT_SIZE(16, Fs->sector_size, max_clusters);
540 Fs->cluster_size = 8;
551 rem_sect = tot_sectors - Fs->dir_len - Fs->fat_start;
555 while(Fs->cluster_size * max_clusters + max_fat_size < rem_sect) {
556 if(Fs->cluster_size > 64) {
562 Fs->cluster_size <<= 1;
598 struct Fs_t *Fs, struct bootsector *boot)
607 (Fs->dir_len == 0 || Fs->dir_len == old_dos[i].dir_len) &&
608 (Fs->cluster_size == 0 ||
609 Fs->cluster_size == old_dos[i].cluster_size)) {
611 Fs->cluster_size = old_dos[i].cluster_size;
612 Fs->dir_len = old_dos[i].dir_len;
613 Fs->fat_len = old_dos[i].fat_len;
614 Fs->fat_bits = 12;
619 int may_change_cluster_size = (Fs->cluster_size == 0);
620 int may_change_root_size = (Fs->dir_len == 0);
629 if(!Fs->cluster_size) {
631 Fs->cluster_size = 1;
633 Fs->cluster_size = (tot_sectors > 2000 ) ? 1:2;
635 Fs->cluster_size = 1;
639 if(!Fs->dir_len) {
641 Fs->dir_len = 4;
643 Fs->dir_len = (tot_sectors > 2000) ? 32 : 7;
646 calc_cluster_size(Fs, tot_sectors, dev->fat_bits);
647 if(Fs->fat_len)
648 xdf_calc_fat_size(Fs, tot_sectors, dev->fat_bits);
650 calc_fat_bits2(Fs, tot_sectors, dev->fat_bits,
653 calc_fat_size(Fs, tot_sectors);
657 set_word(boot->fatlen, Fs->fat_len);
663 struct Fs_t *Fs, struct bootsector *boot)
669 if(!Fs->cluster_size)
674 Fs->cluster_size = 8;
676 Fs->dir_len = 0;
677 Fs->num_clus = tot_sectors / Fs->cluster_size;
678 set_fat32(Fs);
679 calc_fat_size(Fs, tot_sectors);
681 set_dword(boot->ext.fat32.bigFat, Fs->fat_len);
757 Fs_t Fs;
811 Fs.cluster_size = 0;
812 Fs.refs = 1;
813 Fs.dir_len = 0;
815 Fs.dir_len = atoi(getenv("MTOOLS_DIR_LEN"));
816 if(Fs.dir_len <= 0)
817 Fs.dir_len=0;
819 Fs.fat_len = 0;
820 Fs.num_fat = 2;
822 Fs.num_fat = atoi(getenv("MTOOLS_NFATS"));
823 if(Fs.num_fat <= 0)
824 Fs.num_fat=2;
826 Fs.Class = &FsClass;
959 Fs.cluster_size = atoi(optarg);
963 Fs.dir_len = strtoul(optarg,0,0);
966 Fs.fat_len = strtoul(optarg,0,0);
980 Fs.num_fat = atoi(optarg);
1005 Fs.Direct = NULL;
1008 FREE(&(Fs.Direct));
1030 Fs.Direct = 0;
1032 Fs.Direct = FloppydOpen(&used_dev, dev, name,
1035 if(Fs.Direct) {
1039 if(!Fs.Direct) {
1040 Fs.Direct = SimpleFileOpen(&used_dev, dev, name,
1048 Fs.Direct = XdfOpen(&used_dev, name, O_RDWR,
1050 if(Fs.Direct && !Fs.fat_len)
1051 Fs.fat_len = info.FatSize;
1052 if(Fs.Direct && !Fs.dir_len)
1053 Fs.dir_len = info.RootDirSize;
1057 if (!Fs.Direct)
1063 int fd= get_fd(Fs.Direct);
1089 if(SET_GEOM(Fs.Direct, &used_dev, 0xf0, boot)){
1095 Fs.sector_size = 512;
1097 Fs.sector_size = 128 << (used_dev.ssize & 0x7f);
1100 SET_INT(Fs.sector_size, msize);
1104 if (Fs.sector_size == (unsigned int) (1 << j)) {
1105 Fs.sectorShift = j;
1109 Fs.sectorMask = Fs.sector_size - 1;
1112 if(!used_dev.blocksize || used_dev.blocksize < Fs.sector_size)
1113 blocksize = Fs.sector_size;
1122 READS(Fs.Direct, (char *) buf, 0, Fs.sector_size) !=
1123 (signed int) Fs.sector_size) {
1135 FREE(&Fs.Direct);
1145 WRITES(Fs.Direct, (char *) buf,
1146 sectorsToBytes((Stream_t*)&Fs, tot_sectors-1),
1147 Fs.sector_size);
1164 memset((char *)boot, '\0', Fs.sector_size);
1165 if(Fs.sector_size == 512 && !used_dev.partition) {
1176 Fs.Next = buf_init(Fs.Direct,
1180 Fs.Buffer = 0;
1182 boot->nfat = Fs.num_fat;
1190 used_dev.fat_bits = comp_fat_bits(&Fs,used_dev.fat_bits, tot_sectors, fat32);
1193 Fs.primaryFat = 0;
1194 Fs.writeAllFats = 1;
1195 Fs.fat_start = 32;
1196 calc_fs_parameters_32(tot_sectors, &Fs, boot);
1198 Fs.clus_start = Fs.num_fat * Fs.fat_len + Fs.fat_start;
1207 set_dword(boot->ext.fat32.rootCluster, Fs.rootCluster = 2);
1210 set_word(boot->ext.fat32.infoSector, Fs.infoSectorLoc = 1);
1211 Fs.infoSectorLoc = 1;
1218 Fs.infoSectorLoc = 0;
1219 Fs.fat_start = 1;
1220 calc_fs_parameters(&used_dev, tot_sectors, &Fs, boot);
1221 Fs.dir_start = Fs.num_fat * Fs.fat_len + Fs.fat_start;
1222 Fs.clus_start = Fs.dir_start + Fs.dir_len;
1228 Fs.cp = cp_open(used_dev.codepage);
1229 if(Fs.cp == NULL)
1244 label_name(GET_DOSCONVERT((Stream_t *)&Fs),
1247 sprintf(labelBlock->fat_type, "FAT%2.2d ", Fs.fat_bits);
1250 set_word(boot->secsiz, Fs.sector_size);
1251 boot->clsiz = (unsigned char) Fs.cluster_size;
1252 set_word(boot->nrsvsect, Fs.fat_start);
1279 Fs.num_fat = 1;
1282 Fs.lastFatSectorNr = 0;
1283 Fs.lastFatSectorData = 0;
1284 zero_fat(&Fs, boot->descr);
1285 Fs.freeSpace = Fs.num_clus;
1286 Fs.last = 2;
1291 i < (info.BadSectors+Fs.cluster_size-1)/Fs.cluster_size;
1293 fatEncode(&Fs, i+2, 0xfff7);
1296 format_root(&Fs, label, boot);
1297 WRITES((Stream_t *)&Fs, (char *) boot, (mt_off_t) 0, Fs.sector_size);
1298 if(Fs.fat_bits == 32 && WORD(ext.fat32.backupBoot) != MAX16) {
1299 WRITES((Stream_t *)&Fs, (char *) boot,
1300 sectorsToBytes((Stream_t*)&Fs, WORD(ext.fat32.backupBoot)),
1301 Fs.sector_size);
1303 FLUSH((Stream_t *)&Fs); /* flushes Fs.
1305 FREE(&Fs.Next);
1306 Fs.Class->freeFunc((Stream_t *)&Fs);