1 ===============================================================================
2 GNU Parted FAT file system documentation
3 ===============================================================================
5 by Andrew Clausen <clausen@gnu.org>
7 Copyright (C) 2000, 2001 Free Software Foundation, Inc.
9 Permission is granted to copy, distribute and/or modify this document
10 under the terms of the GNU Free Documentation License, Version 1.1
11 or any later version published by the Free Software Foundation;
12 with the no Invariant Sections, with the no Front-Cover Texts, and
13 with no Back-Cover Texts. A copy of the license is included in the
20 PART I - THE FAT FILE SYSTEM
28 3.2 Descriptions of Fields
29 3.3 Calculating the ignored fields
30 3.4 DOS/Windows bootstrap process
34 4.2 Descriptions of Fields
36 5 File Allocation Tables
41 PART II - GNU PARTED'S FAT IMPLEMENTATION
45 8 Overview of GNU Parted's Strategy
47 ===============================================================================
48 PART I - THE FAT FILE SYSTEM
49 ===============================================================================
51 -------------------------------------------------------------------------------
53 -------------------------------------------------------------------------------
55 This document describes the FAT filesystem, and GNU Parted's support for it.
57 Unfortunately, there are no particularly good sources of information on the FAT
58 filesystem. The information here was deduced from the source code of about 10
59 different programs, documentation from about 20 different sources and testing.
60 There are many cases where documentation for FAT from various sources
61 (including Microsoft) are misleading, or just plain wrong. For us,
62 documentation is correct if it matches the behaviour of Microsoft's
66 -------------------------------------------------------------------------------
68 -------------------------------------------------------------------------------
70 FAT is a filesystem that is mainly used by Microsoft DOS, Windows 95,
71 Windows 98 and Windows 2000. FAT also stands for File Allocation Table - a
72 part of the FAT filesystem.
74 FAT comes in three flavors: FAT12, FAT16 and FAT32.
75 FAT12 is used on floppy disks, and REALLY old hard drives <32Mb. FAT16 is
76 typically used on small hard drives <500Mb, and is very inefficient for large
77 hard drives. FAT32 is used on hard drives >500Mb under Windows 95 OSR2 and
78 later and Windows 2000. These three flavors have important differences (not
79 JUST an increase in the maximum possible number of clusters). On FAT12 and
80 FAT16 cluster size directly relates to the filesystem size: the number of
81 clusters is always between 2041 and 4080 resp. 32761 and 65520.
83 The FAT filesystem has these parts (on disk, in this order):
84 * a bootsector. This contains all of the information about the filesystem
85 - whether it's FAT12, FAT16 or FAT32, how big it is, etc.
87 * an information sector (FAT32 only). This contains additional information
88 that couldn't fit in the boot sector.
90 * file allocation tables (FATs). There are usually two identical copies.
91 This is used to store the sequence of clusters that make of files. Essentially,
92 if you want to know the number of the cluster that comes after cluster X
93 in a file, you look up the number for X. If X is a magic number, it means
94 it's the end of the file.
96 * clusters. The data inside files are stored in clusters. Most directory
97 information is stored in clusters (except the root directory in FAT12 and
98 FAT16). Clusters may be 1, 2, 4, 8, etc. sectors. Clusters are numbered,
101 * directory tree. The FAT filesystem has files and directories (no named
102 pipes, links, or anything fancy like that), that are stored in clusters. The
103 root directory on FAT12 and FAT16 is stored separately. In FAT32, the root
104 directory is stored inside a normal cluster, just like everything else.
107 -------------------------------------------------------------------------------
109 -------------------------------------------------------------------------------
111 The boot sector contains all of the information about the filesystem
112 - whether it's FAT12, FAT16 or FAT32, how big it is, etc. It also contains
113 the boot loader for the operating system, if there is an operating system
114 on the file system. It is always the first thing to appear in the filesystem
115 - i.e. it's found at sector 0.
117 A word of warning: while the values inside the boot sector will always be
118 consistent with the file system, many of these values are not read by
119 Microsoft's implementation - they are calculated independently.
123 -------------------------------------------------------------------------------
125 Taken from libparted/fs_fat/bootsector.h:
127 struct __attribute__ ((packed)) _FatBootSector {
128 __u8 boot_jump[3]; /* 00: Boot strap short or near jump */
129 __u8 system_id[8]; /* 03: system name */
130 __u16 sector_size; /* 0b: bytes per logical sector */
131 __u8 cluster_size; /* 0d: sectors/cluster */
132 __u16 reserved; /* 0e: reserved sectors */
133 __u8 fats; /* 10: number of FATs */
134 __u16 dir_entries; /* 11: number of root directory entries */
135 __u16 sectors; /* 13: if 0, sector_count supersedes */
136 __u8 media; /* 15: media code */
137 __u16 fat_length; /* 16: sectors/FAT for FAT12/16 */
138 __u16 secs_track; /* 18: sectors per track */
139 __u16 heads; /* 1a: number of heads */
140 __u32 hidden; /* 1c: hidden sectors (partition start) */
141 __u32 sector_count; /* 20: no. of sectors (if sectors == 0) */
143 union __attribute__ ((packed)) {
145 struct __attribute__ ((packed)) {
146 __u8 drive_num; /* 24: */
147 __u8 empty_1; /* 25: */
148 __u8 ext_signature; /* 26: always 0x29 */
149 __u32 serial_number; /* 27: */
150 __u8 volume_name [11]; /* 2b: */
151 __u8 fat_name [8]; /* 37: */
152 __u8 boot_code[448]; /* 3f: Boot code (or message) */
155 struct __attribute__ ((packed)) {
156 __u32 fat_length; /* 24: size of FAT in sectors */
157 __u16 flags; /* 28: bit8: fat mirroring, low4: active fat */
158 __u16 version; /* 2a: minor * 256 + major */
159 __u32 root_dir_cluster; /* 2c: */
160 __u16 info_sector; /* 30: */
161 __u16 backup_sector; /* 32: */
162 __u8 empty_1 [12]; /* 34: */
163 __u16 drive_num; /* 40: */
164 __u8 ext_signature; /* 42: always 0x29 */
165 __u32 serial_number; /* 43: */
166 __u8 volume_name [11]; /* 47: */
167 __u8 fat_name [8]; /* 52: */
168 __u8 boot_code[420]; /* 5a: Boot code (or message) */
172 __u16 boot_sign; /* 1fe: always 0xAA55 */
176 3.2 Descriptions of Fields
177 -------------------------------------------------------------------------------
179 3.2.1 Fields common to FAT12, FAT16 and FAT32
180 -----------------------------------------------
181 __u8 boot_jump[3]; /* 00: Boot strap short or near jump */
182 This contains the Intel x86 instruction to "jump" to further down in the
183 boot sector. This is necessary, because on PC systems, the first sector of
184 the disk is loaded and executed. On hard disks of PC systems, the first
185 sector of the disk is in fact the Master Boot Record - which contains the
186 partition table. The master boot record loads the first sector of the boot
187 partition, so the end result is the same for floppy's and hard disks.
190 __u8 system_id[8]; /* 03: system name */
191 This contains the name of the program or operatings system that created the
192 file system. For FAT32, it seems you must have "MSWIN4.1" here.
193 If this is "MSDMF3.2" (afaik only the "MSDMF" is checked") the partition
194 can't be written under Windows 9x, Windows NT and Windows 2000. This is
195 how Microsoft realizes read-only installation or distribution floppy disks.
198 __u16 sector_size; /* 0b: bytes per logical sector */
199 This is bizarre. Sectors are always 512 bytes. However, a "logical" sector
200 is a hack that allows sectors to be bigger (a multiple of 512 bytes). This
201 is rarely used, and untested in GNU Parted at the moment. (Side note: is
202 it possible to use this to avoid requiring a cluster resize?)
205 __u8 cluster_size; /* 0d: sectors/cluster */
206 THIS IS IGNORED BY MICROSOFT'S IMPLEMENTATION OF FAT12 AND FAT16! (See section
207 3.3) This contains the size of all clusters, given in sectors. This value is
211 __u16 reserved; /* 0e: reserved sectors */
212 The number of sectors before the file allocation tables begin. i.e. The
213 number of the first sector of the first file allocation table.
216 __u8 fats; /* 10: number of FATs */
217 The number of file allocation tables (usually 2).
220 __u16 dir_entries; /* 11: number of root directory entries */
221 The size of the root directory (FAT12 and FAT16 only), in "directory entries"
222 (32 bytes). The root directory is immediately after the FATs (FAT12 and
223 FAT16 only). The first cluster (i.e. cluster number 2) starts immediately
224 after the root directory (or after the FATs for FAT32).
227 __u16 sectors; /* 13: if 0, sector_count supersedes */
228 THIS IS IGNORED BY MICROSOFT'S IMPLEMENTATION! The total size of the file
229 system. If the file system is bigger than 65536 sectors, this is set to 0,
230 and a 32 bit field is used instead. Microsoft's implementation gets this
231 values from hardware (for floppy disks), or the partition table (for hard
232 disks), rather than reading it off disk.
235 __u8 media; /* 15: media code */
236 For hard disks, this should always be 0xf8.
239 __u16 fat_length; /* 16: sectors/FAT for FAT12/16 */
240 THIS IS IGNORED BY MICROSOFT'S IMPLEMENTATION! (See section 3.3) The size in
241 sectors of each file allocation table (FAT12 and FAT16 only). A 32-bit field
242 is used for FAT32. This value is "read-only".
246 __u16 secs_track; /* 18: sectors per track */
247 __u16 heads; /* 1a: number of heads */
248 These should match the BIOS geometry. The GNU Parted README file explains
252 __u32 hidden; /* 1c: hidden sectors (partition start) */
253 On a hard disk, this should be the number of sectors from the start of the
254 head (in terms of BIOS geometry) to the start of the partition. i.e. the
255 S in the CHS partition start.
258 __u32 sector_count; /* 20: no. of sectors (if sectors == 0) */
259 The size of the file system in sectors (if sectors is 0).
262 __u16 boot_sign; /* 1fe: always 0xAA55 */
263 Boot sector signature. Don't use this exclusively to detect FAT file systems!
264 It's also the signature for partition table sectors (and it appears in the
265 same place too!) Idiots.
267 3.2.2 Fields in FAT12 and FAT16
268 ---------------------------------
270 __u8 drive_num; /* 24: */
274 __u8 ext_signature; /* 26: always 0x29 */
278 __u32 serial_number; /* 27: */
279 Serial number: Used to detect media change on floppy disk and removable drives.
282 __u8 volume_name [11]; /* 2b: */
286 __u8 fat_name [8]; /* 37: */
287 "FAT12\0\0\0" or "FAT16\0\0\0".
290 3.2.3 Fields in FAT32
291 -----------------------
293 __u32 fat_length; /* 24: size of FAT in sectors */
294 The size in sectors of each file allocation table.
297 __u16 flags; /* 28: bit8: fat mirroring, low4: active fat */
298 No idea what these are.
301 __u16 version; /* 2a: minor * 256 + major */
305 __u32 root_dir_cluster; /* 2c: */
306 The number of the first cluster in the root directory.
309 __u16 info_sector; /* 30: */
310 The number of the information sector.
313 __u16 backup_sector; /* 32: */
314 The number of the backup of the boot sector (i.e. this sector).
317 __u16 drive_num; /* 40: */
321 __u8 ext_signature; /* 42: always 0x29 */
325 __u32 serial_number; /* 43: */
326 Serial number (for Echelon, or something)
329 __u8 volume_name [11]; /* 47: */
333 __u8 fat_name [8]; /* 52: */
337 3.3 Calculating the ignored fields
338 -------------------------------------------------------------------------------
339 The cluster_size and fat_length fields are ignored by Microsoft's
340 implementation of FAT12 and FAT16, but NOT FAT32. That is, they are written out
341 correctly, but NOT READ IN. (Note: if FAT32 file system is configured to
342 have less than 65520 clusters, then Windows assumes it's FAT16)
344 Since these values don't usually change unless you resize a filesystem, this
345 causes no problems. However, if you want to resize the filesystem, you have to
346 calculate these values to what Microsoft calculates them to, from the size of
347 the filesystem. It took me 2 months to figure this out (I want to KILL
350 Here's the algorithm I came up with that seemed to match all my test data:
351 (from libparted/fs_fat/calc.c)
354 fat_max_cluster_count (FatType fat_type) {
356 case FAT_TYPE_FAT12: return 0xff0;
357 case FAT_TYPE_FAT16: return 0xfff0;
358 case FAT_TYPE_FAT32: return 0x0ffffff0;
364 fat_min_cluster_count (FatType fat_type) {
368 return fat_max_cluster_count (fat_type) / 2;
370 case FAT_TYPE_FAT32: return 0xfff0;
376 calc_sizes (PedGeometry* geom, PedSector align, int cluster_size,
377 PedSector root_dir_sectors, FatCluster* out_cluster_count,
378 PedSector* out_fat_size, FatType fat_type)
380 PedSector data_fat_size;
381 PedSector fat_sectors;
382 PedSector cluster_sectors;
383 FatCluster cluster_count;
386 data_fat_size = geom->length - fat_min_reserved_sector_count (fat_type)
388 if (fat_type == FAT_TYPE_FAT16)
389 data_fat_size -= root_dir_sectors;
392 for (i = 0; i < 2; i++) {
393 if (fat_type == FAT_TYPE_FAT32)
394 cluster_sectors = data_fat_size - fat_sectors;
396 cluster_sectors = data_fat_size - 2 * fat_sectors;
398 cluster_count = cluster_sectors / (cluster_size / 512);
399 fat_sectors = div_round_up (cluster_count + 2,
400 entries_per_sector (fat_type));
403 cluster_sectors = data_fat_size - 2 * fat_sectors;
404 cluster_count = cluster_sectors / (cluster_size / 512);
406 if (cluster_count > fat_max_cluster_count (fat_type)
407 || cluster_count < fat_min_cluster_count (fat_type))
410 *out_cluster_count = cluster_count;
411 *out_fat_size = fat_sectors;
416 FIXME: this is the "trial and error" algorithm. What happened to my simple,
419 If the implications of the above code aren't that clear, here are some of
421 * for FAT16, the minimum number of clusters is 32760.
422 * the cluster size is completely determined by the size of the file system,
423 for FAT16. That means, if a file system is to be resized, it is quite
424 possible that the cluster size must be changed just to be compatible
425 with Microsoft's implementation (Linux, for example, doesn't calculate the
426 numbers independently, so it would work fine. So always test your code on
427 Microsoft as well as Linux)
430 3.4 DOS/Windows bootstrap process
431 -------------------------------------------------------------------------------
432 All of the information that follows is from me reverse-engineering different
433 versions of Microsoft's boot sectors. It's pretty weird code (as you can
434 imagine...), so there might be mistakes here.
435 There are many different versions of the boot sector:
436 * Windows 98/2000/ME FAT12/FAT16 (supports CHS and LBA)
437 * Windows 98/2000/ME FAT32 (supports CHS and LBA)
439 (1) The MBR, LILO, or whatever loads in the first sector of the FAT
440 partition into 0000:7c00, and executes it.
442 (2) The first sector of the FAT partition (the "boot sector") does:
443 (a) loads the Master Boot Record (sector 0 of the disk) using the
444 BIOS's CHS calls, and finds the boot partition. If the boot partition
445 has the LBA flag marked, it writes 0xe to [bp+2] (0000:7c02). The "read
446 sectors" function in the boot loader checks for 0xe here, and uses LBA if
447 it finds it, and CHS otherwise.
449 (b) If it is the FAT32 version of the boot sector, it loads sectors 1
450 through 3 of the partition (it finds this from the "hidden" field in the
451 FAT boot sector, that was loaded by the MBR/LILO) at address 0000:7e00, and
452 continues executing at 0000:8000. Note: the FAT16 version doesn't require
453 any more sectors to be read (they crammed it all in!), and it goes
456 (3) The code loads IO.SYS (starting at address 0000:0700), off the same
457 partition, and executes it, beginning execution at 0070:0200. (Note:
458 According to the x86 real mode segmentation scheme, 0070:0200 refers to the
459 same physical memory as 0000:0900)
462 -------------------------------------------------------------------------------
464 -------------------------------------------------------------------------------
466 The info sector is used in FAT32 to store additional information about the
471 -------------------------------------------------------------------------------
473 struct __attribute__ ((packed)) _FatInfoSector {
474 __u32 signature_1; /* should be 0x41615252 */
476 __u32 signature_2; /* should be 0x61417272 */
478 __u32 next_cluster; /* most recently allocated cluster */
480 __u16 signature_3; /* should be 0xaa55 */
484 4.2 Descriptions of Fields
485 -------------------------------------------------------------------------------
487 __u32 signature_1; /* should be 0x41615252 */
488 Always 0x41615252 ("AaRR")
491 __u32 signature_2; /* should be 0x61417272 */
492 Always 0x61417272 ("aArr")
496 The number of free clusters. This could be calculated by going through the
497 FATs, but this is stored on shutdown to speed things up.
500 __u32 next_cluster; /* most recently allocated cluster */
501 This contains the number of the last cluster allocated. This speeds up
502 cluster allocation, because free clusters usually come in chunks, so you
503 can scan right for free clusters in the FAT.
506 __u16 signature_3; /* should be 0xaa55 */
510 -------------------------------------------------------------------------------
511 5 FILE ALLOCATION TABLES
512 -------------------------------------------------------------------------------
514 File allocation table (FAT) is a strange name, come to think of it. Perhaps it
515 should be called cluster allocation table, or something (?). Essentially,
516 it is used to represent file chains (i.e. linked lists) for files and
517 directories. There are usually two FATs (one is a backup, and should be
520 Anyway, a FAT is essentially an array. In FAT12, each entry is 12 bits,
521 FAT16 - 16 bits, FAT32 - 32 bits. Hence the names.
523 The first byte of each FAT must match the "media" field in the boot sector.
524 The rest of the first 2 entries are filled with 0xff.
526 All remaining entries - from 2 onwards - correspond to a cluster. i.e.
527 the second entry corresponds to cluster 2. Clusters are numbered from 2 onwards
528 (i.e. there is no cluster 1).
530 The number in each entry gives the number of the cluster that occurs next in
531 the file chain (linked list). However, there are a few magic numbers:
533 * unused (0). Indicates the cluster is unused.
534 * end of file (0xff0 for FAT12, 0xfff0 for FAT16, 0x0ffffff0 for FAT32).
535 Indicates this is the last cluster in the file or directory. Obviouslly for
536 FAT32, the number of clusters must be < 0x0ffffff0. So it should be called
538 * bad cluster (0xff7 for FAT12, 0xfff7 for FAT16, 0x0ffffff7 for FAT32).
539 Indicates the disk is physically damaged where the cluster is stored.
542 -------------------------------------------------------------------------------
544 -------------------------------------------------------------------------------
546 The directory tree is simple: there are files and directories. Files and
547 directories are stored in clusters (except the root directory on FAT12 and
548 FAT16). Directories are essentially special files that contain directory
551 In FAT12 and FAT16, the root directory is stored immediately after the FATs.
552 In FAT32, the first cluster of the root directory is given in the FAT. (To
553 get the second cluster - if there is one - you just look up the FAT)
556 6.1 Directory Entries
557 ------------------------------------------------------------------------------
558 Directories are made up of directory entries, each of which represent a file,
559 a directory or part of a file name (the VFAT extension - YUCK!!!).
561 Each directory (except the root directory) contains a '.' (this directory) and
562 '..' (parent directory) entry.
567 From libparted/fs_fat/fat.h:
569 struct __attribute__ ((packed)) _FatDirEntry {
573 __u8 is_upper_case_name;
574 __u8 creation_time_low; /* milliseconds */
575 __u16 creation_time_high;
578 __u16 first_cluster_high; /* for FAT32 */
585 6.1.2 Field Descriptions
586 --------------------------
589 The first part of the file name. Eg, for a file called README.TXT, this is
590 README. Files with names longer than 8 characters use the VFAT extension (not
591 described here). When a file is deleted, the first character is set to 0xe5.
592 If the first character is 0x0, then the entire directory entry is unused.
596 The last part of the file name. Eg, for a file called README.TXT, this is TXT.
597 This explains all those .HTM files around the place...
601 If this is 0x0f, then this directory entry is a VFAT entry, and stores part
602 of a file name. Otherwise, it's treated as various bit fields:
612 __u8 is_upper_case_name;
613 A Microsoft cludge: create a file with 8.3 name BUT containing small letters
614 (like ReadMe.Txt) which is treated as an LFN (long file name) and occupies
615 three directory entries. Now when you rename this file to all uppercase
616 README.TXT,- under Windows NT 4 the then superfluous LFN-VFAT entries are
617 removed, resulting in a smaller directory, but under Windows 9x the LFN-VFAT
618 entries are just upd- and this flag is set. Executing DEFRAG on such entries
619 MIGHT then remove the superfluous LFN-VFAT entries and shrink the directory.
622 __u8 creation_time_low; /* milliseconds */
623 __u16 creation_time_high;
625 Creation time and date. Not used wih MS-DOS <7.0!
629 Last access date. Not used wih MS-DOS <7.0!
632 __u16 first_cluster_high; /* for FAT32 */
633 High 32 bits of the first cluster in the file or directory (FAT32 only)
642 Low 16 bits of first cluster.
646 Length of file in bytes.
650 ===============================================================================
651 PART II - GNU PARTED'S FAT IMPLEMENTATION
652 ===============================================================================
654 -------------------------------------------------------------------------------
656 -------------------------------------------------------------------------------
658 To resize a FAT file system, a program must:
659 * copy all used clusters that lie outside of the new partition onto free
660 space on that partition. The directory tree and FATs must be updated to
662 * grow or shrink the file allocation table(s) to the size corresponding
663 to the size of the partition.
664 * convert between FAT16 and FAT32 if necessary. This involves:
665 - changing the form of the root directory (FAT16 has it's before the
666 clusters whereas FAT32 stores it in normal clusters).
667 - creating space for the backup boot sector and info sector.
668 - updating the directory tree to use 32 bit first cluster entries.
669 * align the start of the clusters (using the "reserved" field in the
670 boot sector), so that the clusters that are common to the old and new
671 partition can be preserved.
672 * re-number clusters. e.g. if you chop out some clusters from the beginning
673 (i.e. move the start forward), then the first cluster (i.e. number 2) will
674 be refer to a different cluster on the disk. The directory tree and FATs must
675 be updated to reflect this.
676 * create a new boot sector (and the info sector and backup boot sector for
680 -------------------------------------------------------------------------------
681 8 OVERVIEW OF GNU PARTED'S STRATEGY
682 -------------------------------------------------------------------------------
684 GNU Parted copies all clusters that are not accessible from the new file system
685 (either because it lies outside the file system, or file system meta-data must
686 reside there instead) to an accessible place.
688 Since all clusters must be renumbered (in most cases), the entire directory
689 tree must be updated. However converting the directory tree from one numbering
690 system to another would break the file system if it was interrupted halfway
691 through. Instead, GNU Parted duplicates the directory tree (except the root
692 directory for FAT16) along with clusters that need to be copied because they
693 lie outside the new file system. The directory tree is duplicated at the same
694 time as inaccessible clusters are. The relevant function,
695 needs_duplicating() in libparted/fs_fat/clstdup.c is:
698 needs_duplicating (FatOpContext* ctx, FatCluster cluster)
700 FatSpecific* fs_info = FAT_SPECIFIC (ctx->old_fs);
702 return (fs_info->fat_flag_map [cluster] == FAT_FLAG_FILE
703 && !fat_op_context_map_static_cluster (ctx, cluster))
704 || fs_info->fat_flag_map [cluster]
705 == FAT_FLAG_DIRECTORY;
710 A good overview of this implementation is in the fat_resize() function, in
711 libparted/fs_fat/resize.c (slightly edited):
714 fat_resize (PedFileSystem* fs, PedGeometry* geom)
716 FatSpecific* fs_info = FAT_SPECIFIC (fs);
717 FatSpecific* new_fs_info;
719 PedFileSystem* new_fs;
721 ctx = create_resize_context (fs, geom);
724 new_fs = ctx->new_fs;
725 new_fs_info = FAT_SPECIFIC (new_fs);
727 if (!fat_duplicate_clusters (ctx))
729 if (fs_info->fat_type == FAT_TYPE_FAT16
730 && new_fs_info->fat_type == FAT_TYPE_FAT32) {
731 if (!alloc_root_dir (ctx))
734 if (!fat_construct_new_fat (ctx))
736 if (!fat_construct_dir_tree (ctx))
738 if (!fat_table_write_all (new_fs_info->fat, new_fs))
741 if (!fat_boot_sector_generate (&new_fs_info->boot_sector,
744 if (!fat_boot_sector_write (&new_fs_info->boot_sector, new_fs))
746 if (new_fs_info->fat_type == FAT_TYPE_FAT32) {
747 if (!fat_info_sector_generate (
748 &new_fs_info->info_sector, new_fs))
750 if (!fat_info_sector_write (&new_fs_info->info_sector,
755 if (!resize_context_assimilate (ctx))