ReactOS  0.4.14-dev-317-g96040ec
boot.c File Reference
#include "vfatlib.h"
#include <debug.h>
Include dependency graph for boot.c:

Go to the source code of this file.

Macros

#define NDEBUG
 
#define ROUND_TO_MULTIPLE(n, m)   ((n) && (m) ? (n)+(m)-1-((n)-1)%(m) : 0)
 
#define FAT12_THRESHOLD   4085
 
#define FAT16_THRESHOLD   65525
 
#define GET_UNALIGNED_W(f)   ( (uint16_t)f[0] | ((uint16_t)f[1]<<8) )
 

Functions

static const charget_media_descr (unsigned char media)
 
static void dump_boot (DOS_FS *fs, struct boot_sector *b, unsigned lss)
 
static void check_backup_boot (DOS_FS *fs, struct boot_sector *b, unsigned int lss)
 
static void init_fsinfo (struct info_sector *i)
 
static void read_fsinfo (DOS_FS *fs, struct boot_sector *b, unsigned int lss)
 
static char print_fat_dirty_state (void)
 
static void check_fat_state_bit (DOS_FS *fs, void *b)
 
void read_boot (DOS_FS *fs)
 
static void write_boot_label (DOS_FS *fs, char *label)
 
off_t find_volume_de (DOS_FS *fs, DIR_ENT *de)
 
static void write_volume_label (DOS_FS *fs, char *label)
 
void write_label (DOS_FS *fs, char *label)
 

Variables

struct {
   uint8_t   media
 
   const char *   descr
 
mediabytes []
 

Macro Definition Documentation

◆ FAT12_THRESHOLD

#define FAT12_THRESHOLD   4085

Definition at line 40 of file boot.c.

◆ FAT16_THRESHOLD

#define FAT16_THRESHOLD   65525

Definition at line 41 of file boot.c.

◆ GET_UNALIGNED_W

#define GET_UNALIGNED_W (   f)    ( (uint16_t)f[0] | ((uint16_t)f[1]<<8) )

Definition at line 60 of file boot.c.

◆ NDEBUG

#define NDEBUG

Definition at line 33 of file boot.c.

◆ ROUND_TO_MULTIPLE

#define ROUND_TO_MULTIPLE (   n,
  m 
)    ((n) && (m) ? (n)+(m)-1-((n)-1)%(m) : 0)

Definition at line 36 of file boot.c.

Function Documentation

◆ check_backup_boot()

static void check_backup_boot ( DOS_FS fs,
struct boot_sector b,
unsigned int  lss 
)
static

Definition at line 127 of file boot.c.

128 {
129  struct boot_sector b2;
130 
131  if (!fs->backupboot_start) {
132  printf("There is no backup boot sector.\n");
133  if (le16toh(b->reserved) < 3) {
134  printf("And there is no space for creating one!\n");
135  return;
136  }
137  if (interactive)
138  printf("1) Create one\n2) Do without a backup\n");
139  else
140  printf(" Auto-creating backup boot block.\n");
141  if (!interactive || get_key("12", "?") == '1') {
142  unsigned int bbs;
143  /* The usual place for the backup boot sector is sector 6. Choose
144  * that or the last reserved sector. */
145  if (le16toh(b->reserved) >= 7 && le16toh(b->info_sector) != 6)
146  bbs = 6;
147  else {
148  bbs = le16toh(b->reserved) - 1;
149  if (bbs == le16toh(b->info_sector))
150  --bbs; /* this is never 0, as we checked reserved >= 3! */
151  }
152  fs->backupboot_start = bbs * lss;
153  b->backup_boot = htole16(bbs);
154  fs_write(fs->backupboot_start, sizeof(*b), b);
156  sizeof(b->backup_boot), &b->backup_boot);
157  printf("Created backup of boot sector in sector %d\n", bbs);
158  return;
159  } else
160  return;
161  }
162 
163  fs_read(fs->backupboot_start, sizeof(b2), &b2);
164  if (memcmp(b, &b2, sizeof(b2)) != 0) {
165  /* there are any differences */
166  uint8_t *p, *q;
167  int i, pos, first = 1;
168  char buf[20];
169 
170  printf("There are differences between boot sector and its backup.\n");
171  printf("This is mostly harmless. Differences: (offset:original/backup)\n ");
172  pos = 2;
173  for (p = (uint8_t *) b, q = (uint8_t *) & b2, i = 0; i < sizeof(b2);
174  ++p, ++q, ++i) {
175  if (*p != *q) {
176 #ifndef __REACTOS__
177  sprintf(buf, "%s%u:%02x/%02x", first ? "" : ", ",
178 #else
179  RtlStringCbPrintfA(buf, sizeof(buf), "%s%u:%02x/%02x", first ? "" : ", ",
180 #endif // __REACTOS__
181  (unsigned)(p - (uint8_t *) b), *p, *q);
182  if (pos + strlen(buf) > 78)
183  printf("\n "), pos = 2;
184  printf("%s", buf);
185  pos += strlen(buf);
186  first = 0;
187  }
188  }
189  printf("\n");
190 
191  if (interactive)
192  printf("1) Copy original to backup\n"
193  "2) Copy backup to original\n" "3) No action\n");
194  else
195  printf(" Not automatically fixing this.\n");
196  switch (interactive ? get_key("123", "?") : '3') {
197  case '1':
198  fs_write(fs->backupboot_start, sizeof(*b), b);
199  break;
200  case '2':
201  fs_write(0, sizeof(b2), &b2);
202  break;
203  default:
204  break;
205  }
206  }
207 }
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
const GLint * first
Definition: glext.h:5794
#define htole16(x)
Definition: storage32.h:546
#define interactive
Definition: rosglue.h:34
Definition: fs.h:235
void fs_write(off_t pos, int size, void *data)
Definition: io.c:344
#define sprintf(buf, format,...)
Definition: sprintf.c:55
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define offsetof(TYPE, MEMBER)
NTSTRSAFEVAPI RtlStringCbPrintfA(_Out_writes_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PSTR pszDest, _In_ size_t cbDest, _In_ _Printf_format_string_ NTSTRSAFE_PCSTR pszFormat,...)
Definition: ntstrsafe.h:1148
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
char get_key(const char *valid, const char *prompt)
Definition: common.c:184
void fs_read(off_t pos, int size, void *data)
Definition: io.c:282
GLdouble GLdouble GLdouble GLdouble q
Definition: gl.h:2063
BYTE uint8_t
Definition: msvideo1.c:66
static CRYPT_DATA_BLOB b2[]
Definition: msg.c:582
GLfloat GLfloat p
Definition: glext.h:8902
uint16_t backup_boot
Definition: fsck.fat.h:57
#define printf
Definition: config.h:203

Referenced by read_boot().

◆ check_fat_state_bit()

static void check_fat_state_bit ( DOS_FS fs,
void b 
)
static

Definition at line 309 of file boot.c.

310 {
311  if (fs->fat_bits == 32) {
312  struct boot_sector *b32 = b;
313 
314  if (b32->reserved3 & FAT_STATE_DIRTY) {
315  printf("0x41: ");
316  if (print_fat_dirty_state() == '1') {
317  b32->reserved3 &= ~FAT_STATE_DIRTY;
318  fs_write(0, sizeof(*b32), b32);
319  }
320  }
321  } else {
322  struct boot_sector_16 *b16 = b;
323 
324  if (b16->reserved2 & FAT_STATE_DIRTY) {
325  printf("0x25: ");
326  if (print_fat_dirty_state() == '1') {
327  b16->reserved2 &= ~FAT_STATE_DIRTY;
328  fs_write(0, sizeof(*b16), b16);
329  }
330  }
331  }
332 }
Definition: fs.h:235
void fs_write(off_t pos, int size, void *data)
Definition: io.c:344
#define FAT_STATE_DIRTY
Definition: fsck.fat.h:80
uint8_t reserved3
Definition: fsck.fat.h:115
#define b
Definition: ke_i.h:79
static char print_fat_dirty_state(void)
Definition: boot.c:288
uint8_t reserved2
Definition: fsck.fat.h:144
#define printf
Definition: config.h:203

Referenced by read_boot().

◆ dump_boot()

static void dump_boot ( DOS_FS fs,
struct boot_sector b,
unsigned  lss 
)
static

Definition at line 74 of file boot.c.

75 {
76  unsigned short sectors;
77 
78  printf("Boot sector contents:\n");
79  if (!atari_format) {
80  char id[9];
81  strncpy(id, (const char *)b->system_id, 8);
82  id[8] = 0;
83  printf("System ID \"%s\"\n", id);
84  } else {
85  /* On Atari, a 24 bit serial number is stored at offset 8 of the boot
86  * sector */
87  printf("Serial number 0x%x\n",
88  b->system_id[5] | (b->system_id[6] << 8) | (b->
89  system_id[7] << 16));
90  }
91  printf("Media byte 0x%02x (%s)\n", b->media, get_media_descr(b->media));
92  printf("%10d bytes per logical sector\n", GET_UNALIGNED_W(b->sector_size));
93  printf("%10d bytes per cluster\n", fs->cluster_size);
94  printf("%10d reserved sector%s\n", le16toh(b->reserved),
95  le16toh(b->reserved) == 1 ? "" : "s");
96  printf("First FAT starts at byte %llu (sector %llu)\n",
97  (unsigned long long)fs->fat_start,
98  (unsigned long long)fs->fat_start / lss);
99  printf("%10d FATs, %d bit entries\n", b->fats, fs->fat_bits);
100  printf("%10lld bytes per FAT (= %llu sectors)\n", (long long)fs->fat_size,
101  (long long)fs->fat_size / lss);
102  if (!fs->root_cluster) {
103  printf("Root directory starts at byte %llu (sector %llu)\n",
104  (unsigned long long)fs->root_start,
105  (unsigned long long)fs->root_start / lss);
106  printf("%10d root directory entries\n", fs->root_entries);
107  } else {
108  printf("Root directory start at cluster %lu (arbitrary size)\n",
109  (unsigned long)fs->root_cluster);
110  }
111  printf("Data area starts at byte %llu (sector %llu)\n",
112  (unsigned long long)fs->data_start,
113  (unsigned long long)fs->data_start / lss);
114  printf("%10lu data clusters (%llu bytes)\n",
115  (unsigned long)fs->data_clusters,
116  (unsigned long long)fs->data_clusters * fs->cluster_size);
117  printf("%u sectors/track, %u heads\n", le16toh(b->secs_track),
118  le16toh(b->heads));
119  printf("%10u hidden sectors\n", atari_format ?
120  /* On Atari, the hidden field is only 16 bit wide and unused */
121  (((unsigned char *)&b->hidden)[0] |
122  ((unsigned char *)&b->hidden)[1] << 8) : le32toh(b->hidden));
123  sectors = GET_UNALIGNED_W(b->sectors);
124  printf("%10u sectors total\n", sectors ? sectors : le32toh(b->total_sect));
125 }
char * strncpy(char *DstString, const char *SrcString, ACPI_SIZE Count)
Definition: utclib.c:427
Definition: fs.h:235
#define GET_UNALIGNED_W(f)
Definition: boot.c:60
int atari_format
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
static const char * get_media_descr(unsigned char media)
Definition: boot.c:63
__u8 sectors[2]
Definition: mkdosfs.c:366
__u8 system_id[8]
Definition: mkdosfs.c:359
#define printf
Definition: config.h:203

Referenced by read_boot().

◆ find_volume_de()

off_t find_volume_de ( DOS_FS fs,
DIR_ENT *  de 
)

Definition at line 524 of file boot.c.

525 {
526  uint32_t cluster;
527  off_t offset;
528  int i;
529 
530  if (fs->root_cluster) {
531  for (cluster = fs->root_cluster;
532  cluster != 0 && cluster != -1;
533  cluster = next_cluster(fs, cluster)) {
534  offset = cluster_start(fs, cluster);
535  for (i = 0; i * sizeof(DIR_ENT) < fs->cluster_size; i++) {
536  fs_read(offset, sizeof(DIR_ENT), de);
537  if (de->attr != VFAT_LN_ATTR && de->attr & ATTR_VOLUME)
538  return offset;
539  offset += sizeof(DIR_ENT);
540  }
541  }
542  } else {
543  for (i = 0; i < fs->root_entries; i++) {
544  offset = fs->root_start + i * sizeof(DIR_ENT);
545  fs_read(offset, sizeof(DIR_ENT), de);
546  if (de->attr != VFAT_LN_ATTR && de->attr & ATTR_VOLUME)
547  return offset;
548  }
549  }
550 
551  return 0;
552 }
#define ATTR_VOLUME
Definition: mkdosfs.c:369
__kernel_off_t off_t
Definition: linux.h:201
GLintptr offset
Definition: glext.h:5920
Definition: fs.h:235
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
uint32_t next_cluster(DOS_FS *fs, uint32_t cluster)
Definition: fat.c:276
void fs_read(off_t pos, int size, void *data)
Definition: io.c:282
UINT32 uint32_t
Definition: types.h:75
off_t cluster_start(DOS_FS *fs, uint32_t cluster)
Definition: fat.c:289
#define VFAT_LN_ATTR
Definition: fsck.fat.h:78

Referenced by write_volume_label().

◆ get_media_descr()

static const char* get_media_descr ( unsigned char  media)
static

Definition at line 63 of file boot.c.

64 {
65  int i;
66 
67  for (i = 0; i < sizeof(mediabytes) / sizeof(*mediabytes); ++i) {
68  if (mediabytes[i].media == media)
69  return (mediabytes[i].descr);
70  }
71  return ("undefined");
72 }
static struct @3987 mediabytes[]
uint8_t media
Definition: boot.c:44
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
const char * descr
Definition: boot.c:45

Referenced by dump_boot().

◆ init_fsinfo()

static void init_fsinfo ( struct info_sector i)
static

Definition at line 209 of file boot.c.

210 {
211  memset(i, 0, sizeof (struct info_sector));
212  i->magic = htole32(0x41615252);
213  i->signature = htole32(0x61417272);
214  i->free_clusters = htole32(-1);
215  i->next_cluster = htole32(2);
216  i->boot_sign = htole32(0xaa550000);
217 }
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define htole32(x)
Definition: storage32.h:543
#define memset(x, y, z)
Definition: compat.h:39

Referenced by read_fsinfo().

◆ print_fat_dirty_state()

static char print_fat_dirty_state ( void  )
static

Definition at line 288 of file boot.c.

289 {
290  printf("Dirty bit is set. Fs was not properly unmounted and"
291  " some data may be corrupt.\n");
292 
293  if (interactive) {
294  printf("1) Remove dirty bit\n" "2) No action\n");
295  return get_key("12", "?");
296 #ifndef __REACTOS__
297  } else
298 #else
299  } else if (rw) {
300 #endif
301  printf(" Automatically removing dirty bit.\n");
302  return '1';
303 #ifdef __REACTOS__
304  }
305  return '2';
306 #endif
307 }
#define interactive
Definition: rosglue.h:34
char get_key(const char *valid, const char *prompt)
Definition: common.c:184
int rw
#define printf
Definition: config.h:203

Referenced by check_fat_state_bit().

◆ read_boot()

void read_boot ( DOS_FS fs)

Definition at line 334 of file boot.c.

335 {
336  struct boot_sector b;
337  unsigned total_sectors;
338  unsigned int logical_sector_size, sectors;
340  unsigned total_fat_entries;
341  off_t data_size;
342 
343  fs_read(0, sizeof(b), &b);
344  logical_sector_size = GET_UNALIGNED_W(b.sector_size);
345  if (!logical_sector_size)
346  die("Logical sector size is zero.");
347 
348  /* This was moved up because it's the first thing that will fail */
349  /* if the platform needs special handling of unaligned multibyte accesses */
350  /* but such handling isn't being provided. See GET_UNALIGNED_W() above. */
351  if (logical_sector_size & (SECTOR_SIZE - 1))
352  die("Logical sector size (%d bytes) is not a multiple of the physical "
353  "sector size.", logical_sector_size);
354 
355  fs->cluster_size = b.cluster_size * logical_sector_size;
356  if (!fs->cluster_size)
357  die("Cluster size is zero.");
358  if (b.fats != 2 && b.fats != 1)
359  die("Currently, only 1 or 2 FATs are supported, not %d.\n", b.fats);
360  fs->nfats = b.fats;
361  sectors = GET_UNALIGNED_W(b.sectors);
362  total_sectors = sectors ? sectors : le32toh(b.total_sect);
363  if (verbose)
364  printf("Checking we can access the last sector of the filesystem\n");
365  /* Can't access last odd sector anyway, so round down */
366  fs_test((off_t)((total_sectors & ~1) - 1) * logical_sector_size,
367  logical_sector_size);
368 
369  fat_length = le16toh(b.fat_length) ?
370  le16toh(b.fat_length) : le32toh(b.fat32_length);
371  if (!fat_length)
372  die("FAT size is zero.");
373 
374  fs->fat_start = (off_t)le16toh(b.reserved) * logical_sector_size;
375  fs->root_start = ((off_t)le16toh(b.reserved) + b.fats * fat_length) *
376  logical_sector_size;
377  fs->root_entries = GET_UNALIGNED_W(b.dir_entries);
378  fs->data_start = fs->root_start + ROUND_TO_MULTIPLE(fs->root_entries <<
380  logical_sector_size);
381 
382  data_size = (off_t)total_sectors * logical_sector_size - fs->data_start;
383  if (data_size < fs->cluster_size)
384  die("Filesystem has no space for any data clusters");
385 
386  fs->data_clusters = data_size / fs->cluster_size;
387  fs->root_cluster = 0; /* indicates standard, pre-FAT32 root dir */
388  fs->fsinfo_start = 0; /* no FSINFO structure */
389  fs->free_clusters = -1; /* unknown */
390  if (!b.fat_length && b.fat32_length) {
391  fs->fat_bits = 32;
392  fs->root_cluster = le32toh(b.root_cluster);
393  if (!fs->root_cluster && fs->root_entries)
394  /* M$ hasn't specified this, but it looks reasonable: If
395  * root_cluster is 0 but there is a separate root dir
396  * (root_entries != 0), we handle the root dir the old way. Give a
397  * warning, but convertig to a root dir in a cluster chain seems
398  * to complex for now... */
399  printf("Warning: FAT32 root dir not in cluster chain! "
400  "Compatibility mode...\n");
401  else if (!fs->root_cluster && !fs->root_entries)
402  die("No root directory!");
403  else if (fs->root_cluster && fs->root_entries)
404  printf("Warning: FAT32 root dir is in a cluster chain, but "
405  "a separate root dir\n"
406  " area is defined. Cannot fix this easily.\n");
407  if (fs->data_clusters < FAT16_THRESHOLD)
408  printf("Warning: Filesystem is FAT32 according to fat_length "
409  "and fat32_length fields,\n"
410  " but has only %lu clusters, less than the required "
411  "minimum of %d.\n"
412  " This may lead to problems on some systems.\n",
413  (unsigned long)fs->data_clusters, FAT16_THRESHOLD);
414 
416  fs->backupboot_start = le16toh(b.backup_boot) * logical_sector_size;
417  check_backup_boot(fs, &b, logical_sector_size);
418 
419  read_fsinfo(fs, &b, logical_sector_size);
420  } else if (!atari_format) {
421  /* On real MS-DOS, a 16 bit FAT is used whenever there would be too
422  * much clusers otherwise. */
423  fs->fat_bits = (fs->data_clusters >= FAT12_THRESHOLD) ? 16 : 12;
424  if (fs->data_clusters >= FAT16_THRESHOLD)
425  die("Too many clusters (%lu) for FAT16 filesystem.",
426  (unsigned long)fs->data_clusters);
428  } else {
429  /* On Atari, things are more difficult: GEMDOS always uses 12bit FATs
430  * on floppies, and always 16 bit on harddisks. */
431  fs->fat_bits = 16; /* assume 16 bit FAT for now */
432  /* If more clusters than fat entries in 16-bit fat, we assume
433  * it's a real MSDOS FS with 12-bit fat. */
434  if (fs->data_clusters + 2 > fat_length * logical_sector_size * 8 / 16 ||
435  /* if it has one of the usual floppy sizes -> 12bit FAT */
436  (total_sectors == 720 || total_sectors == 1440 ||
437  total_sectors == 2880))
438  fs->fat_bits = 12;
439  }
440  /* On FAT32, the high 4 bits of a FAT entry are reserved */
441  fs->eff_fat_bits = (fs->fat_bits == 32) ? 28 : fs->fat_bits;
442  fs->fat_size = fat_length * logical_sector_size;
443 
444  fs->label = calloc(12, sizeof(uint8_t));
445  if (fs->fat_bits == 12 || fs->fat_bits == 16) {
446  struct boot_sector_16 *b16 = (struct boot_sector_16 *)&b;
447  if (b16->extended_sig == 0x29)
448  memmove(fs->label, b16->label, 11);
449  else
450 #ifdef __REACTOS__
451  {
452  free(fs->label);
453 #endif
454  fs->label = NULL;
455 #ifdef __REACTOS__
456  }
457 #endif
458  } else if (fs->fat_bits == 32) {
459  if (b.extended_sig == 0x29)
460  memmove(fs->label, &b.label, 11);
461  else
462 #ifdef __REACTOS__
463  {
464  free(fs->label);
465 #endif
466  fs->label = NULL;
467 #ifdef __REACTOS__
468  }
469 #endif
470  }
471 
472  total_fat_entries = (uint64_t)fs->fat_size * 8 / fs->fat_bits;
473  if (fs->data_clusters > total_fat_entries - 2)
474  die("Filesystem has %u clusters but only space for %u FAT entries.",
475  fs->data_clusters, total_fat_entries - 2);
476  if (!fs->root_entries && !fs->root_cluster)
477  die("Root directory has zero size.");
478  if (fs->root_entries & (MSDOS_DPS - 1))
479  die("Root directory (%d entries) doesn't span an integral number of "
480  "sectors.", fs->root_entries);
481  if (logical_sector_size & (SECTOR_SIZE - 1))
482  die("Logical sector size (%u bytes) is not a multiple of the physical "
483  "sector size.", logical_sector_size);
484 #if 0 /* linux kernel doesn't check that either */
485  /* ++roman: On Atari, these two fields are often left uninitialized */
486  if (!atari_format && (!b.secs_track || !b.heads))
487  die("Invalid disk format in boot sector.");
488 #endif
489  if (verbose)
490  dump_boot(fs, &b, logical_sector_size);
491 }
uint8_t label[11]
Definition: fsck.fat.h:148
#define memmove(s1, s2, n)
Definition: mkisofs.h:881
#define FAT12_THRESHOLD
Definition: boot.c:40
#define free
Definition: debug_ros.c:5
__kernel_off_t off_t
Definition: linux.h:201
uint32_t fat32_length
Definition: fsck.fat.h:52
DWORD total_sectors
Definition: cdmake.c:201
static void read_fsinfo(DOS_FS *fs, struct boot_sector *b, unsigned int lss)
Definition: boot.c:219
__u16 fat_length
Definition: mkdosfs.c:368
Definition: fs.h:235
#define verbose
Definition: rosglue.h:36
int fs_test(off_t pos, int size)
Definition: io.c:322
#define GET_UNALIGNED_W(f)
Definition: boot.c:60
#define FAT16_THRESHOLD
Definition: boot.c:41
#define MSDOS_DPS
Definition: msdos_fs.h:28
__u8 cluster_size
Definition: mkdosfs.c:362
smooth NULL
Definition: ftsmooth.c:416
int atari_format
#define off_t
Definition: dosfsck.h:5
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
if(!(yy_init))
Definition: macro.lex.yy.c:714
void fs_read(off_t pos, int size, void *data)
Definition: io.c:282
static void check_backup_boot(DOS_FS *fs, struct boot_sector *b, unsigned int lss)
Definition: boot.c:127
#define ROUND_TO_MULTIPLE(n, m)
Definition: boot.c:36
BYTE uint8_t
Definition: msvideo1.c:66
#define uint64_t
Definition: nsiface.idl:62
#define MSDOS_DIR_BITS
Definition: msdos_fs.h:30
__u8 sectors[2]
Definition: mkdosfs.c:366
static void dump_boot(DOS_FS *fs, struct boot_sector *b, unsigned lss)
Definition: boot.c:74
static void check_fat_state_bit(DOS_FS *fs, void *b)
Definition: boot.c:309
#define calloc
Definition: rosglue.h:14
uint8_t extended_sig
Definition: fsck.fat.h:146
#define die(str)
Definition: mkdosfs.c:347
#define SECTOR_SIZE
Definition: fs.h:22
#define printf
Definition: config.h:203

Referenced by VfatChkdsk().

◆ read_fsinfo()

static void read_fsinfo ( DOS_FS fs,
struct boot_sector b,
unsigned int  lss 
)
static

Definition at line 219 of file boot.c.

220 {
221  struct info_sector i;
222 
223  if (!b->info_sector) {
224  printf("No FSINFO sector\n");
225  if (interactive)
226  printf("1) Create one\n2) Do without FSINFO\n");
227  else
228  printf(" Not automatically creating it.\n");
229  if (interactive && get_key("12", "?") == '1') {
230  /* search for a free reserved sector (not boot sector and not
231  * backup boot sector) */
232  uint32_t s;
233  for (s = 1; s < le16toh(b->reserved); ++s)
234  if (s != le16toh(b->backup_boot))
235  break;
236  if (s > 0 && s < le16toh(b->reserved)) {
237  init_fsinfo(&i);
238  fs_write((off_t)s * lss, sizeof(i), &i);
239  b->info_sector = htole16(s);
241  sizeof(b->info_sector), &b->info_sector);
242  if (fs->backupboot_start)
243  fs_write(fs->backupboot_start +
245  sizeof(b->info_sector), &b->info_sector);
246  } else {
247  printf("No free reserved sector found -- "
248  "no space for FSINFO sector!\n");
249  return;
250  }
251  } else
252  return;
253  }
254 
255  fs->fsinfo_start = le16toh(b->info_sector) * lss;
256  fs_read(fs->fsinfo_start, sizeof(i), &i);
257 
258  if (i.magic != htole32(0x41615252) ||
259  i.signature != htole32(0x61417272) || i.boot_sign != htole32(0xaa550000)) {
260  printf("FSINFO sector has bad magic number(s):\n");
261  if (i.magic != htole32(0x41615252))
262  printf(" Offset %llu: 0x%08x != expected 0x%08x\n",
263  (unsigned long long)offsetof(struct info_sector, magic),
264  le32toh(i.magic), 0x41615252);
265  if (i.signature != htole32(0x61417272))
266  printf(" Offset %llu: 0x%08x != expected 0x%08x\n",
267  (unsigned long long)offsetof(struct info_sector, signature),
268  le32toh(i.signature), 0x61417272);
269  if (i.boot_sign != htole32(0xaa550000))
270  printf(" Offset %llu: 0x%08x != expected 0x%08x\n",
271  (unsigned long long)offsetof(struct info_sector, boot_sign),
272  le32toh(i.boot_sign), 0xaa550000);
273  if (interactive)
274  printf("1) Correct\n2) Don't correct (FSINFO invalid then)\n");
275  else
276  printf(" Auto-correcting it.\n");
277  if (!interactive || get_key("12", "?") == '1') {
278  init_fsinfo(&i);
279  fs_write(fs->fsinfo_start, sizeof(i), &i);
280  } else
281  fs->fsinfo_start = 0;
282  }
283 
284  if (fs->fsinfo_start)
285  fs->free_clusters = le32toh(i.free_clusters);
286 }
__kernel_off_t off_t
Definition: linux.h:201
#define htole16(x)
Definition: storage32.h:546
u32_t magic(void)
#define interactive
Definition: rosglue.h:34
Definition: fs.h:235
void fs_write(off_t pos, int size, void *data)
Definition: io.c:344
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define offsetof(TYPE, MEMBER)
#define htole32(x)
Definition: storage32.h:543
uint32_t boot_sign
Definition: fsck.fat.h:162
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
char get_key(const char *valid, const char *prompt)
Definition: common.c:184
void fs_read(off_t pos, int size, void *data)
Definition: io.c:282
static void init_fsinfo(struct info_sector *i)
Definition: boot.c:209
GLdouble s
Definition: gl.h:2039
UINT32 uint32_t
Definition: types.h:75
#define printf
Definition: config.h:203
uint32_t signature
Definition: fsck.fat.h:158

Referenced by read_boot().

◆ write_boot_label()

static void write_boot_label ( DOS_FS fs,
char label 
)
static

Definition at line 494 of file boot.c.

495 {
496  if (fs->fat_bits == 12 || fs->fat_bits == 16) {
497  struct boot_sector_16 b16;
498 
499  fs_read(0, sizeof(b16), &b16);
500  if (b16.extended_sig != 0x29) {
501  b16.extended_sig = 0x29;
502  b16.serial = 0;
503  memmove(b16.fs_type, fs->fat_bits == 12 ? "FAT12 " : "FAT16 ",
504  8);
505  }
506  memmove(b16.label, label, 11);
507  fs_write(0, sizeof(b16), &b16);
508  } else if (fs->fat_bits == 32) {
509  struct boot_sector b;
510 
511  fs_read(0, sizeof(b), &b);
512  if (b.extended_sig != 0x29) {
513  b.extended_sig = 0x29;
514  b.serial = 0;
515  memmove(b.fs_type, "FAT32 ", 8);
516  }
517  memmove(b.label, label, 11);
518  fs_write(0, sizeof(b), &b);
519  if (fs->backupboot_start)
520  fs_write(fs->backupboot_start, sizeof(b), &b);
521  }
522 }
#define memmove(s1, s2, n)
Definition: mkisofs.h:881
Definition: fs.h:235
void fs_write(off_t pos, int size, void *data)
Definition: io.c:344
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
void fs_read(off_t pos, int size, void *data)
Definition: io.c:282
uint8_t label[11]
Definition: fsck.fat.h:65

Referenced by write_label().

◆ write_label()

void write_label ( DOS_FS fs,
char label 
)

Definition at line 589 of file boot.c.

590 {
591  int l = strlen(label);
592 
593  while (l < 11)
594  label[l++] = ' ';
595 
598 }
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
Definition: fs.h:235
static void write_boot_label(DOS_FS *fs, char *label)
Definition: boot.c:494
r l[0]
Definition: byte_order.h:167
static void write_volume_label(DOS_FS *fs, char *label)
Definition: boot.c:554
uint8_t label[11]
Definition: fsck.fat.h:65

◆ write_volume_label()

static void write_volume_label ( DOS_FS fs,
char label 
)
static

Definition at line 554 of file boot.c.

555 {
556  time_t now = time(NULL);
557  struct tm *mtime = localtime(&now);
558  off_t offset;
559  int created;
560  DIR_ENT de;
561 
562  created = 0;
563  offset = find_volume_de(fs, &de);
564  if (offset == 0) {
565  created = 1;
566  offset = alloc_rootdir_entry(fs, &de, label, 0);
567  }
568  memcpy(de.name, label, 11);
569  de.time = htole16((unsigned short)((mtime->tm_sec >> 1) +
570  (mtime->tm_min << 5) +
571  (mtime->tm_hour << 11)));
572  de.date = htole16((unsigned short)(mtime->tm_mday +
573  ((mtime->tm_mon + 1) << 5) +
574  ((mtime->tm_year - 80) << 9)));
575  if (created) {
576  de.attr = ATTR_VOLUME;
577  de.ctime_ms = 0;
578  de.ctime = de.time;
579  de.cdate = de.date;
580  de.adate = de.date;
581  de.starthi = 0;
582  de.start = 0;
583  de.size = 0;
584  }
585 
586  fs_write(offset, sizeof(DIR_ENT), &de);
587 }
off_t alloc_rootdir_entry(DOS_FS *fs, DIR_ENT *de, const char *pattern, int gen_name)
Definition: check.c:74
int tm_min
Definition: time.h:78
#define ATTR_VOLUME
Definition: mkdosfs.c:369
off_t find_volume_de(DOS_FS *fs, DIR_ENT *de)
Definition: boot.c:524
__kernel_off_t off_t
Definition: linux.h:201
int tm_mday
Definition: time.h:80
GLintptr offset
Definition: glext.h:5920
#define htole16(x)
Definition: storage32.h:546
int tm_year
Definition: time.h:82
__u16 time
Definition: mkdosfs.c:366
Definition: fs.h:235
void fs_write(off_t pos, int size, void *data)
Definition: io.c:344
time_t now
Definition: finger.c:65
smooth NULL
Definition: ftsmooth.c:416
int tm_mon
Definition: time.h:81
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
Definition: time.h:76
_CRTIMP struct tm *__cdecl localtime(const time_t *_Time)
Definition: time.h:424
uint8_t label[11]
Definition: fsck.fat.h:65
__kernel_time_t time_t
Definition: linux.h:252
int tm_sec
Definition: time.h:77
int tm_hour
Definition: time.h:79

Referenced by write_label().

Variable Documentation

◆ descr

const char* descr

Definition at line 45 of file boot.c.

Referenced by AddItem(), CRYPT_AsnDecodeAccessDescription(), CRYPT_AsnEncodeAccessDescription(), CxxHandleV8Frame(), dwarf2_parse_line_numbers(), get_dc_data_ex(), get_media_descr(), LISTBOX_Create(), LISTBOX_DeleteItem(), LISTBOX_Destroy(), LISTBOX_Directory(), LISTBOX_DrawFocusRect(), LISTBOX_FindFileStrPos(), LISTBOX_FindString(), LISTBOX_FindStringPos(), LISTBOX_GetCurrentPageSize(), LISTBOX_GetItemFromPoint(), LISTBOX_GetItemHeight(), LISTBOX_GetItemRect(), LISTBOX_GetMaxTopIndex(), LISTBOX_GetSelCount(), LISTBOX_GetSelItems(), LISTBOX_GetText(), LISTBOX_HandleChar(), LISTBOX_HandleHScroll(), LISTBOX_HandleKeyDown(), LISTBOX_HandleLButtonDown(), LISTBOX_HandleLButtonDownCombo(), LISTBOX_HandleLButtonUp(), LISTBOX_HandleMouseMove(), LISTBOX_HandleMouseWheel(), LISTBOX_HandleSystemTimer(), LISTBOX_HandleTimer(), LISTBOX_HandleVScroll(), LISTBOX_InitStorage(), LISTBOX_InsertItem(), LISTBOX_InsertString(), LISTBOX_InvalidateItemRect(), LISTBOX_InvalidateItems(), LISTBOX_MakeItemVisible(), LISTBOX_MoveCaret(), LISTBOX_NCPaint(), LISTBOX_Paint(), LISTBOX_PaintItem(), LISTBOX_RemoveItem(), LISTBOX_RepaintItem(), LISTBOX_ResetContent(), LISTBOX_SelectItemRange(), LISTBOX_SetCaretIndex(), LISTBOX_SetColumnWidth(), LISTBOX_SetCount(), LISTBOX_SetFont(), LISTBOX_SetHorizontalExtent(), LISTBOX_SetHorizontalPos(), LISTBOX_SetItemHeight(), LISTBOX_SetRedraw(), LISTBOX_SetSelection(), LISTBOX_SetTabStops(), LISTBOX_SetTopItem(), LISTBOX_update_uistate(), LISTBOX_UpdatePage(), LISTBOX_UpdateScroll(), LISTBOX_UpdateSize(), LISTBOX_WindowProc(), ListBoxWndProc_common(), NtUserGetListBoxInfo(), output_typelib_regscript(), process_comment(), process_extra(), sw_DescribePixelFormat(), test_DC_bitmap(), test_device_caps(), test_import_resolution(), test_multiselect(), test_stdout_handle(), wglDescribePixelFormat(), write_coclass(), and write_progid().

◆ media

uint8_t media

Definition at line 44 of file boot.c.

Referenced by get_media_descr().

◆ mediabytes

struct { ... } mediabytes[]
Initial value:
= {
{
0xf0, "5.25\" or 3.5\" HD floppy"}, {
0xf8, "hard disk"}, {
0xf9, "3,5\" 720k floppy 2s/80tr/9sec or "
"5.25\" 1.2M floppy 2s/80tr/15sec"}, {
0xfa, "5.25\" 320k floppy 1s/80tr/8sec"}, {
0xfb, "3.5\" 640k floppy 2s/80tr/8sec"}, {
0xfc, "5.25\" 180k floppy 1s/40tr/9sec"}, {
0xfd, "5.25\" 360k floppy 2s/40tr/9sec"}, {
0xfe, "5.25\" 160k floppy 1s/40tr/8sec"}, {
0xff, "5.25\" 320k floppy 2s/40tr/8sec"},}

Referenced by get_media_descr().