xref: /illumos-gate/usr/src/cmd/fs.d/pcfs/fsck/fat.c (revision 7c478bd9)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright (c) 1999 by Sun Microsystems, Inc.
24  * All rights reserved.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 /*
30  * fsck_pcfs -- routines for manipulating the FAT.
31  */
32 #include <stdio.h>
33 #include <unistd.h>
34 #include <stdlib.h>
35 #include <libintl.h>
36 #include <sys/dktp/fdisk.h>
37 #include <sys/fs/pc_fs.h>
38 #include <sys/fs/pc_dir.h>
39 #include <sys/fs/pc_label.h>
40 #include "pcfs_common.h"
41 #include "fsck_pcfs.h"
42 
43 extern	int32_t	BytesPerCluster;
44 extern	int32_t	TotalClusters;
45 extern	int32_t	LastCluster;
46 extern	off64_t	FirstClusterOffset;
47 extern	off64_t	PartitionOffset;
48 extern	bpb_t	TheBIOSParameterBlock;
49 extern	int	ReadOnly;
50 extern	int	IsFAT32;
51 extern	int	Verbose;
52 
53 static	uchar_t	*TheFAT;
54 static	int	FATRewriteNeeded = 0;
55 
56 int32_t		FATSize;
57 short		FATEntrySize;
58 
59 static off64_t
seekFAT(int fd)60 seekFAT(int fd)
61 {
62 	off64_t seekto;
63 	/*
64 	 *  The FAT(s) immediately follows the reserved sectors.
65 	 */
66 	seekto = TheBIOSParameterBlock.bpb.resv_sectors *
67 		TheBIOSParameterBlock.bpb.bytes_per_sector + PartitionOffset;
68 	return (lseek64(fd, seekto, SEEK_SET));
69 }
70 
71 void
getFAT(int fd)72 getFAT(int fd)
73 {
74 	ssize_t bytesRead;
75 
76 	if (TheFAT != NULL) {
77 		return;
78 	} else if ((TheFAT = (uchar_t *)malloc(FATSize)) == NULL) {
79 		mountSanityCheckFails();
80 		perror(gettext("No memory for a copy of the FAT"));
81 		(void) close(fd);
82 		exit(7);
83 	}
84 	if (seekFAT(fd) < 0) {
85 		mountSanityCheckFails();
86 		perror(gettext("Cannot seek to FAT"));
87 		(void) close(fd);
88 		exit(7);
89 	}
90 	if (Verbose)
91 		(void) fprintf(stderr,
92 		    gettext("Reading FAT\n"));
93 	if ((bytesRead = read(fd, TheFAT, FATSize)) != FATSize) {
94 		mountSanityCheckFails();
95 		if (bytesRead < 0) {
96 			perror(gettext("Cannot read a FAT"));
97 		} else {
98 			(void) fprintf(stderr,
99 			    gettext("Short read of FAT."));
100 		}
101 		(void) close(fd);
102 		exit(7);
103 	}
104 	/*
105 	 * XXX - might want to read the other copies of the FAT
106 	 * for comparison and/or to use if the first one seems hosed.
107 	 */
108 	if (Verbose) {
109 		(void) fprintf(stderr,
110 		    gettext("Dump of FAT's first 32 bytes.\n"));
111 		header_for_dump();
112 		dump_bytes(TheFAT, 32);
113 	}
114 }
115 
116 void
writeFATMods(int fd)117 writeFATMods(int fd)
118 {
119 	ssize_t bytesWritten;
120 
121 	if (TheFAT == NULL) {
122 		(void) fprintf(stderr,
123 		    gettext("Internal error: No FAT to write\n"));
124 		(void) close(fd);
125 		exit(11);
126 	}
127 	if (!FATRewriteNeeded) {
128 		if (Verbose) {
129 			(void) fprintf(stderr,
130 			    gettext("No FAT changes need to be written.\n"));
131 		}
132 		return;
133 	}
134 	if (ReadOnly)
135 		return;
136 	if (Verbose)
137 		(void) fprintf(stderr, gettext("Writing FAT\n"));
138 	if (seekFAT(fd) < 0) {
139 		perror(gettext("Cannot seek to FAT"));
140 		(void) close(fd);
141 		exit(11);
142 	}
143 	if ((bytesWritten = write(fd, TheFAT, FATSize)) != FATSize) {
144 		if (bytesWritten < 0) {
145 			perror(gettext("Cannot write FAT"));
146 		} else {
147 			(void) fprintf(stderr,
148 			    gettext("Short write of FAT."));
149 		}
150 		(void) close(fd);
151 		exit(11);
152 	}
153 	FATRewriteNeeded = 0;
154 }
155 
156 /*
157  *  checkFAT32CleanBit()
158  *	Return non-zero if the bit indicating proper Windows shutdown has
159  *	been set.
160  */
161 int
checkFAT32CleanBit(int fd)162 checkFAT32CleanBit(int fd)
163 {
164 	getFAT(fd);
165 	return (TheFAT[WIN_SHUTDOWN_STATUS_BYTE] & WIN_SHUTDOWN_BIT_MASK);
166 }
167 
168 static uchar_t *
findClusterEntryInFAT(int32_t currentCluster)169 findClusterEntryInFAT(int32_t currentCluster)
170 {
171 	int32_t idx;
172 	if (FATEntrySize == 32) {
173 		idx = currentCluster * 4;
174 	} else if (FATEntrySize == 16) {
175 		idx = currentCluster * 2;
176 	} else {
177 		idx = currentCluster + currentCluster/2;
178 	}
179 	return (TheFAT + idx);
180 }
181 
182 /*
183  *  {read,write}FATentry
184  *	For the 16 and 32 bit FATs these routines are relatively easy
185  *	to follow.
186  *
187  *	12 bit FATs are kind of strange, though.  The magic index for
188  *	12 bit FATS computed below, 1.5 * clusterNum, is a
189  *	simplification that there are 8 bits in a byte, so you need
190  *	1.5 bytes per entry.
191  *
192  *	It's easiest to think about FAT12 entries in pairs:
193  *
194  *	---------------------------------------------
195  *	| mid1 | low1 | low2 | high1 | high2 | mid2 |
196  *	---------------------------------------------
197  *
198  *	Each box in the diagram represents a nibble (4 bits) of a FAT
199  *	entry.  A FAT entry is made up of three nibbles.  So if you
200  *	look closely, you'll see that first byte of the pair of
201  *	entries contains the low and middle nibbles of the first
202  *	entry.  The second byte has the low nibble of the second entry
203  *	and the high nibble of the first entry.  Those two bytes alone
204  *	are enough to read the first entry.  The second FAT entry is
205  *	finished out by the last nibble pair.
206  */
207 int32_t
readFATEntry(int32_t currentCluster)208 readFATEntry(int32_t currentCluster)
209 {
210 	int32_t value;
211 	uchar_t *ep;
212 
213 	ep = findClusterEntryInFAT(currentCluster);
214 	if (FATEntrySize == 32) {
215 		read_32_bits(ep, (uint32_t *)&value);
216 	} else if (FATEntrySize == 16) {
217 		read_16_bits(ep, (uint32_t *)&value);
218 		/*
219 		 *  Convert 16 bit entry to 32 bit if we are
220 		 *  into the reserved or higher values.
221 		 */
222 		if (value >= PCF_RESCLUSTER)
223 			value |= 0xFFF0000;
224 	} else {
225 		value = 0;
226 		if (currentCluster & 1) {
227 			/*
228 			 * Odd numbered cluster
229 			 */
230 			value = (((unsigned int)*ep++ & 0xf0) >> 4);
231 			value += (*ep << 4);
232 		} else {
233 			value = *ep++;
234 			value += ((*ep & 0x0f) << 8);
235 		}
236 		/*
237 		 *  Convert 12 bit entry to 32 bit if we are
238 		 *  into the reserved or higher values.
239 		 */
240 		if (value >= PCF_12BCLUSTER)
241 			value |= 0xFFFF000;
242 	}
243 	return (value);
244 }
245 
246 void
writeFATEntry(int32_t currentCluster,int32_t value)247 writeFATEntry(int32_t currentCluster, int32_t value)
248 {
249 	uchar_t *ep;
250 
251 	FATRewriteNeeded = 1;
252 	ep = findClusterEntryInFAT(currentCluster);
253 	if (FATEntrySize == 32) {
254 		store_32_bits(&ep, value);
255 	} else if (FATEntrySize == 16) {
256 		store_16_bits(&ep, value);
257 	} else {
258 		if (currentCluster & 1) {
259 			/*
260 			 * Odd numbered cluster
261 			 */
262 			*ep = (*ep & 0x0f) | ((value << 4) & 0xf0);
263 			ep++;
264 			*ep = (value >> 4) & 0xff;
265 		} else {
266 			*ep++ = value & 0xff;
267 			*ep = (*ep & 0xf0) | ((value >> 8) & 0x0f);
268 		}
269 	}
270 }
271 
272 /*
273  * reservedInFAT - Is this cluster marked in the reserved range?
274  *	The range from PCF_RESCLUSTER32 to PCF_BADCLUSTER32 - 1,
275  *	have been reserved by Microsoft.  No cluster should be
276  *	marked with these; they are effectively invalid cluster values.
277  */
278 int
reservedInFAT(int32_t clusterNum)279 reservedInFAT(int32_t clusterNum)
280 {
281 	int32_t e;
282 
283 	e = readFATEntry(clusterNum);
284 	return (e >= PCF_RESCLUSTER32 && e < PCF_BADCLUSTER32);
285 }
286 
287 /*
288  *  badInFAT - Is this cluster marked as bad?  I.e., is it inaccessible?
289  */
290 int
badInFAT(int32_t clusterNum)291 badInFAT(int32_t clusterNum)
292 {
293 	return (readFATEntry(clusterNum) == PCF_BADCLUSTER32);
294 }
295 
296 /*
297  *  lastInFAT - Is this cluster marked as free?  I.e., is it available
298  *	for use?
299  */
300 int
freeInFAT(int32_t clusterNum)301 freeInFAT(int32_t clusterNum)
302 {
303 	return (readFATEntry(clusterNum) == PCF_FREECLUSTER);
304 }
305 
306 /*
307  *  lastInFAT - Is this cluster the last in its cluster chain?
308  */
309 int
lastInFAT(int32_t clusterNum)310 lastInFAT(int32_t clusterNum)
311 {
312 	return (readFATEntry(clusterNum) == PCF_LASTCLUSTER32);
313 }
314 
315 /*
316  *  markLastInFAT - Mark this cluster as the last in its cluster chain.
317  */
318 void
markLastInFAT(int32_t clusterNum)319 markLastInFAT(int32_t clusterNum)
320 {
321 	writeFATEntry(clusterNum, PCF_LASTCLUSTER32);
322 }
323 
324 void
markFreeInFAT(int32_t clusterNum)325 markFreeInFAT(int32_t clusterNum)
326 {
327 	writeFATEntry(clusterNum, PCF_FREECLUSTER);
328 }
329 
330 void
markBadInFAT(int32_t clusterNum)331 markBadInFAT(int32_t clusterNum)
332 {
333 	writeFATEntry(clusterNum, PCF_BADCLUSTER32);
334 }
335