xref: /illumos-gate/usr/src/common/fs/pcfs.c (revision c40a6cd7)
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 2005 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 /*
28  * Basic file system reading code for standalone I/O system.
29  * Simulates a primitive UNIX I/O system (read(), write(), open(), etc).
30  * Does not support writes.
31  */
32 
33 /*
34  * WARNING:
35  * This is currently used by installgrub for creating bootable floppy.
36  * The special part is diskread_callback/fileread_callback for gathering
37  * fileblock list.
38  */
39 
40 #include <sys/param.h>
41 #include <sys/sysmacros.h>
42 #include <sys/vnode.h>
43 #include <sys/fs/pc_label.h>
44 #include <sys/bootvfs.h>
45 #include <sys/filep.h>
46 #include "pcfilep.h"
47 
48 #if	defined(_BOOT)
49 #include "../common/util.h"
50 #elif	defined(_KERNEL)
51 #include <sys/sunddi.h>
52 #else
53 #include <stdio.h>
54 #include <strings.h>
55 #include <ctype.h>
56 #endif
57 
58 #if	defined(_BOOT)
59 #define	dprintf	if (bootrd_debug) printf
60 #elif	defined(_KERNEL)
61 #define	printf	kobj_printf
62 #define	dprintf	if (bootrd_debug) kobj_printf
63 
64 /* PRINTLIKE */
65 extern void kobj_printf(char *, ...);
66 #else
67 #define	dprintf if (bootrd_debug) printf
68 #endif
69 
70 #define	FI_STARTCLUST(fp)	(*(ushort_t *)(fp)->fi_buf)
71 #define	FI_LENGTH(fp)		(*(long *)((fp)->fi_buf + 4))
72 
73 extern int bootrd_debug;
74 extern void *bkmem_alloc(size_t);
75 extern void bkmem_free(void *, size_t);
76 
77 /*
78  * NOTE: The fileread_callback is set by the calling program
79  * during a file read. diskread_callback is set to fileread_callback
80  * only if reading a file block. It needs to be NULL while reading
81  * cluster blocks.
82  */
83 extern int (*diskread_callback)(int, int);
84 extern int (*fileread_callback)(int, int);
85 
86 /*
87  *  Local prototypes
88  */
89 static int lookuppn(char *, _dir_entry_p);
90 static fileid_t *find_fp(int);
91 static void *readblock(int, int);
92 static int fat_map(int, int);
93 static int cluster_valid(long, int);
94 static int fat_ctodb(int, int);
95 
96 static int bpcfs_mountroot(char *str);
97 static int bpcfs_unmountroot(void);
98 static int bpcfs_open(char *str, int flags);
99 static int bpcfs_close(int fd);
100 static void bpcfs_closeall(void);
101 static ssize_t bpcfs_read(int fdesc, char *buf, size_t count);
102 static off_t bpcfs_lseek(int fdesc, off_t addr, int whence);
103 
104 static fileid_t *head;
105 static _fat_controller_p pcfsp;
106 
107 /* cache the cluster */
108 static int nsec_cache;
109 static int nsec_start;
110 static char *cluster_cache;
111 
112 /*ARGSUSED*/
113 static int
bpcfs_mountroot(char * str)114 bpcfs_mountroot(char *str)
115 {
116 	int ncluster;
117 	if (pcfsp != NULL)
118 		return (0);	/* already mounted */
119 
120 	pcfsp = bkmem_alloc(sizeof (_fat_controller_t));
121 	head = (fileid_t *)bkmem_alloc(sizeof (fileid_t));
122 	head->fi_back = head->fi_forw = head;
123 	head->fi_filedes = 0;
124 	head->fi_taken = 0;
125 
126 	/* read of first floppy sector */
127 	head->fi_blocknum = 0;
128 	head->fi_count = SECSIZ;
129 	head->fi_memp = (caddr_t)pcfsp->f_sector;
130 	if (diskread(head)) {
131 		printf("failed to read first sector\n");
132 		bkmem_free(pcfsp, sizeof (*pcfsp));
133 		pcfsp = NULL;
134 		return (-1);
135 	}
136 
137 	if (pcfsp->f_bpb.bs_spc == 0) {
138 		printf("invalid bios paramet block\n");
139 		return (-1);
140 	}
141 
142 	pcfsp->f_rootsec =
143 	    (pcfsp->f_bpb.bs_num_fats * ltohs(pcfsp->f_bpb.bs_spf)) +
144 	    ltohs(pcfsp->f_bpb.bs_resv_sectors);
145 	pcfsp->f_rootlen =
146 	    ltohs(pcfsp->f_bpb.bs_num_root_entries) *
147 	    sizeof (_dir_entry_t) / SECSIZ;
148 	pcfsp->f_adjust = 0;
149 	pcfsp->f_dclust = CLUSTER_ROOTDIR;
150 	pcfsp->f_filesec = pcfsp->f_rootsec + pcfsp->f_rootlen;
151 	pcfsp->f_nxtfree = CLUSTER_FIRST;
152 
153 	/* figure out the number of clusters in this partition */
154 	ncluster = (((ulong_t)ltohs(pcfsp->f_bpb.bs_siv) ?
155 	    (ulong_t)ltohs(pcfsp->f_bpb.bs_siv) :
156 	    (ulong_t)ltohi(pcfsp->f_bpb.bs_siv)) -
157 	    pcfsp->f_filesec) / (ulong_t)pcfsp->f_bpb.bs_spc;
158 	pcfsp->f_16bit = ncluster >= CLUSTER_MAX_12;
159 	pcfsp->f_ncluster = ncluster;
160 
161 	/* cache the cluster */
162 	if (pcfsp->f_16bit)
163 		nsec_cache = (((ncluster << 1) + 511) >> 9);
164 	else
165 		nsec_cache = (ncluster + ((ncluster + 1) >> 1) + 511) >> 9;
166 	cluster_cache = bkmem_alloc(nsec_cache * SECSIZ);
167 	if (cluster_cache == NULL) {
168 		printf("bpcfs_mountroot: out of memory\n");
169 		bkmem_free(pcfsp, sizeof (*pcfsp));
170 		pcfsp = NULL;
171 		return (-1);
172 	}
173 
174 	head->fi_blocknum = nsec_start =
175 	    ltohs(pcfsp->f_bpb.bs_resv_sectors) + pcfsp->f_adjust;
176 	head->fi_count = nsec_cache * SECSIZ;
177 	head->fi_memp = cluster_cache;
178 	if (diskread(head)) {
179 		printf("bpcfs_mountroot: failed to read cluster\n");
180 		bkmem_free(pcfsp, sizeof (*pcfsp));
181 		pcfsp = NULL;
182 		return (-1);
183 	}
184 	dprintf("read cluster sectors %d starting at %d\n",
185 	    nsec_cache, nsec_start);
186 	return (0);
187 }
188 
189 static int
bpcfs_unmountroot(void)190 bpcfs_unmountroot(void)
191 {
192 	if (pcfsp == NULL)
193 		return (-1);
194 
195 	(void) bpcfs_closeall();
196 
197 	return (0);
198 }
199 
200 /*
201  * Open a file.
202  */
203 /*ARGSUSED*/
204 int
bpcfs_open(char * str,int flags)205 bpcfs_open(char *str, int flags)
206 {
207 	static int filedes = 1;
208 
209 	fileid_t *filep;
210 	_dir_entry_t d;
211 
212 	dprintf("open %s\n", str);
213 	filep = (fileid_t *)bkmem_alloc(sizeof (fileid_t));
214 	filep->fi_back = head->fi_back;
215 	filep->fi_forw = head;
216 	head->fi_back->fi_forw = filep;
217 	head->fi_back = filep;
218 	filep->fi_filedes = filedes++;
219 	filep->fi_taken = 1;
220 	filep->fi_path = (char *)bkmem_alloc(strlen(str) + 1);
221 	(void) strcpy(filep->fi_path, str);
222 
223 	if (lookuppn(str, &d)) {
224 		(void) bpcfs_close(filep->fi_filedes);
225 		return (-1);
226 	}
227 
228 	filep->fi_offset = 0;
229 	FI_STARTCLUST(filep) = d.d_cluster;
230 	FI_LENGTH(filep) = d.d_size;
231 	dprintf("file %s size = %ld\n", str, d.d_size);
232 	return (filep->fi_filedes);
233 }
234 
235 int
bpcfs_close(int fd)236 bpcfs_close(int fd)
237 {
238 	fileid_t *filep;
239 
240 	dprintf("close %d\n", fd);
241 	if (!(filep = find_fp(fd)))
242 		return (-1);
243 
244 	if (filep->fi_taken == 0 || filep == head) {
245 		printf("File descripter %d no allocated!\n", fd);
246 		return (-1);
247 	}
248 
249 	/* unlink and deallocate node */
250 	filep->fi_forw->fi_back = filep->fi_back;
251 	filep->fi_back->fi_forw = filep->fi_forw;
252 	bkmem_free(filep->fi_path, strlen(filep->fi_path) + 1);
253 	bkmem_free((char *)filep, sizeof (fileid_t));
254 	dprintf("close done\n");
255 	return (0);
256 }
257 
258 static void
bpcfs_closeall(void)259 bpcfs_closeall(void)
260 {
261 	fileid_t *filep;
262 
263 	while ((filep = head->fi_forw) != head)
264 		if (filep->fi_taken && bpcfs_close(filep->fi_filedes))
265 			printf("Filesystem may be inconsistent.\n");
266 
267 	bkmem_free(pcfsp, sizeof (*pcfsp));
268 	bkmem_free(head, sizeof (fileid_t));
269 	pcfsp = NULL;
270 	head = NULL;
271 }
272 
273 static ssize_t
bpcfs_read(int fd,caddr_t b,size_t c)274 bpcfs_read(int fd, caddr_t b, size_t c)
275 {
276 	ulong_t sector;
277 	uint_t count = 0, xfer, i;
278 	char *block;
279 	ulong_t off, blk;
280 	int rd, spc;
281 	fileid_t *fp;
282 
283 	dprintf("bpcfs_read: fd = %d, buf = %p, size = %d\n",
284 		fd, (void *)b, c);
285 	fp = find_fp(fd);
286 	if (fp == NULL) {
287 		printf("invalid file descriptor %d\n", fd);
288 		return (-1);
289 	}
290 
291 	spc = pcfsp->f_bpb.bs_spc;
292 	off = fp->fi_offset;
293 	blk = FI_STARTCLUST(fp);
294 	rd = blk == CLUSTER_ROOTDIR ? 1 : 0;
295 
296 	spc = pcfsp->f_bpb.bs_spc;
297 	off = fp->fi_offset;
298 	blk = FI_STARTCLUST(fp);
299 	rd = (blk == CLUSTER_ROOTDIR) ? 1 : 0;
300 
301 	if ((c = MIN(FI_LENGTH(fp) - off, c)) == 0)
302 		return (0);
303 
304 	while (off >= pcfsp->f_bpb.bs_spc * SECSIZ) {
305 		blk = fat_map(blk, rd);
306 		off -= pcfsp->f_bpb.bs_spc * SECSIZ;
307 
308 		if (!cluster_valid(blk, rd)) {
309 			printf("bpcfs_read: invalid cluster: %ld, %d\n",
310 			    blk, rd);
311 			return (-1);
312 		}
313 	}
314 
315 	while (count < c) {
316 		sector = fat_ctodb(blk, rd);
317 		diskread_callback = fileread_callback;
318 		for (i = ((off / SECSIZ) % pcfsp->f_bpb.bs_spc); i < spc; i++) {
319 			xfer = MIN(SECSIZ - (off % SECSIZ), c - count);
320 			if (xfer == 0)
321 				break;	/* last sector done */
322 
323 			block = (char *)readblock(sector + i, 1);
324 			if (block == NULL) {
325 				return (-1);
326 			}
327 			dprintf("bpcfs_read: read %d bytes\n", xfer);
328 			if (diskread_callback == NULL)
329 				(void) bcopy(&block[off % SECSIZ], b, xfer);
330 			count += xfer;
331 			off += xfer;
332 			b += xfer;
333 		}
334 
335 		diskread_callback = NULL;
336 		if (count < c) {
337 			blk = fat_map(blk, rd);
338 			if (!cluster_valid(blk, rd)) {
339 				printf("bpcfs_read: invalid cluster: %ld, %d\n",
340 				    blk, rd);
341 				break;
342 			}
343 		}
344 	}
345 
346 	fp->fi_offset += count;
347 	return (count);
348 }
349 
350 /*
351  * This version of seek() only performs absolute seeks (whence == 0).
352  */
353 static off_t
bpcfs_lseek(int fd,off_t addr,int whence)354 bpcfs_lseek(int fd, off_t addr, int whence)
355 {
356 	fileid_t *filep;
357 
358 	dprintf("lseek %d, off = %lx\n", fd, addr);
359 	if (!(filep = find_fp(fd)))
360 		return (-1);
361 
362 	switch (whence) {
363 	case SEEK_CUR:
364 		filep->fi_offset += addr;
365 		break;
366 	case SEEK_SET:
367 		filep->fi_offset = addr;
368 		break;
369 	default:
370 	case SEEK_END:
371 		printf("lseek(): invalid whence value %d\n", whence);
372 		break;
373 	}
374 
375 	filep->fi_blocknum = addr / DEV_BSIZE;
376 	filep->fi_count = 0;
377 	return (0);
378 }
379 
380 static fileid_t *
find_fp(int fd)381 find_fp(int fd)
382 {
383 	fileid_t *filep = head;
384 
385 	if (fd >= 0) {
386 		while ((filep = filep->fi_forw) != head)
387 			if (fd == filep->fi_filedes)
388 				return (filep->fi_taken ? filep : 0);
389 	}
390 
391 	return (0);
392 }
393 
394 static int
cluster_valid(long c,int rd)395 cluster_valid(long c, int rd)
396 {
397 	return ((rd && (c == 0)) ? 1 : (c >= CLUSTER_RES_16_0 ? 0 : c));
398 }
399 
400 static int
fat_ctodb(int blk,int r)401 fat_ctodb(int blk, int r)
402 {
403 	uint_t s;
404 
405 	s = r ? blk + pcfsp->f_rootsec + pcfsp->f_adjust :
406 	    ((blk - 2) * pcfsp->f_bpb.bs_spc) +
407 	    pcfsp->f_filesec + pcfsp->f_adjust;
408 
409 	return (s);
410 }
411 
412 static int
fat_map(int blk,int rootdir)413 fat_map(int blk, int rootdir)
414 {
415 	ulong_t sectn, fat_index;
416 	uchar_t *fp;
417 
418 	if (rootdir) {
419 		return (blk > pcfsp->f_rootlen ? CLUSTER_EOF : blk + 1);
420 	}
421 
422 	/* ---- Find out what sector this cluster is in ---- */
423 	fat_index = (pcfsp->f_16bit) ? ((ulong_t)blk << 1) :
424 	    ((ulong_t)blk + ((uint_t)blk >> 1));
425 
426 	sectn = (fat_index / SECSIZ) + ltohs(pcfsp->f_bpb.bs_resv_sectors)
427 	    + pcfsp->f_adjust;
428 
429 	/*
430 	 * Read two sectors so that if our fat_index points at the last byte
431 	 * byte we'll have the data needed.  This is only a problem for fat12
432 	 * entries.
433 	 */
434 	if (!(fp = (uchar_t *)readblock(sectn, 2))) {
435 		printf("fat_map: bad cluster\n");
436 		return (CLUSTER_BAD_16);
437 	}
438 
439 	fp += (fat_index % SECSIZ);
440 
441 	if (pcfsp->f_16bit)
442 		blk = fp[0] | (fp[1] << 8);
443 	else {
444 		if (blk & 1)
445 			blk = ((fp[0] >> 4) & 0xf) | (fp[1] << 4);
446 		else
447 			blk = ((fp[1] & 0xf) << 8) | fp[0];
448 
449 		/*
450 		 * This makes compares easier because we can just compare
451 		 * against one value instead of two.
452 		 */
453 		if (blk >= CLUSTER_RES_12_0)
454 			blk |= CLUSTER_RES_16_0;
455 	}
456 	return (blk);
457 }
458 
459 static int
namecmp(char * pn,char * dn,int cs)460 namecmp(char *pn, char *dn, int cs)
461 {
462 	dprintf("namecmp %s, %s, len = %d\n", pn, dn, cs);
463 
464 	/* starting char must match */
465 	while (*pn && *dn) {
466 		--cs;
467 		if (toupper(*pn++) != toupper(*dn++))
468 			return (1);
469 	}
470 
471 	dprintf("namecmp: cs = %d\n", cs);
472 	/* remainder should be either ~# or all spaces */
473 	if (cs > 0 && *dn == '~')
474 		return (0);
475 	while (cs > 0) {
476 		if (*dn++ != ' ')
477 			return (1);
478 		--cs;
479 	}
480 	return (0);
481 }
482 
483 static int
dircmp(char * name,char * d_name,char * d_ext)484 dircmp(char *name, char *d_name, char *d_ext)
485 {
486 	int ret;
487 	char *sep, *ext;
488 
489 	sep = (char *)strchr(name, '.');
490 
491 	if (sep) {
492 		*sep = '\0';
493 		ext = sep + 1;
494 	} else
495 		ext = "   ";
496 
497 	if (namecmp(name, d_name, NAMESIZ) || namecmp(ext, d_ext, EXTSIZ))
498 		ret = 1;
499 	else
500 		ret = 0;
501 	if (sep)
502 		*sep = '.';
503 	return (ret);
504 }
505 
506 static int
lookup(char * n,_dir_entry_p dp,ulong_t dir_blk)507 lookup(char *n, _dir_entry_p dp, ulong_t dir_blk)
508 {
509 	int spc = pcfsp->f_bpb.bs_spc;
510 	int rd = (dir_blk == CLUSTER_ROOTDIR ? 1 : 0);
511 	_dir_entry_p dxp;
512 	int j, sector;
513 
514 	dprintf("lookup: name = %s\n", n);
515 
516 	while (cluster_valid(dir_blk, rd)) {
517 		sector = fat_ctodb(dir_blk, rd);
518 		dxp = readblock(sector, 1);	/* read one sector */
519 		if (dxp == NULL)
520 			return (0);
521 		for (j = 0; j < DIRENTS * spc; j++, dxp++) {
522 			dprintf("lookup: dir entry %s.%s;\n",
523 			    dxp->d_name, dxp->d_ext);
524 			if (dxp->d_name[0] == 0)
525 				return (0);
526 			if ((uchar_t)dxp->d_name[0] != 0xE5 &&
527 			    (dxp->d_attr & (DE_LABEL|DE_HIDDEN)) == 0 &&
528 			    dircmp(n, dxp->d_name, dxp->d_ext) == 0) {
529 				dprintf("lookup: match found\n");
530 				(void) bcopy(dxp, dp, sizeof (*dp));
531 				return (1);
532 			}
533 		}
534 		/* next cluster */
535 		dir_blk = fat_map(dir_blk, rd);
536 	}
537 
538 	return (0);
539 }
540 
541 static int
lookuppn(char * n,_dir_entry_p dp)542 lookuppn(char *n, _dir_entry_p dp)
543 {
544 	long dir_blk;
545 	char name[8 + 1 + 3 + 1];	/* <8>.<3>'\0' */
546 	char *p, *ep;
547 	_dir_entry_t dd;
548 
549 	dprintf("lookuppn: path = %s\n", n);
550 	dir_blk = pcfsp->f_dclust;
551 	if ((*n == '\\') || (*n == '/')) {
552 		dir_blk = CLUSTER_ROOTDIR;
553 		while ((*n == '\\') || (*n == '/'))
554 			n++;
555 		if (*n == '\0') {
556 			(void) bzero(dp, sizeof (*dp));
557 			dp->d_cluster = CLUSTER_ROOTDIR;
558 			dp->d_attr = DE_DIRECTORY;
559 			return (0);
560 		}
561 	}
562 
563 	ep = &name[0] + sizeof (name);
564 	while (*n) {
565 		(void) bzero(name, sizeof (name));
566 		p = &name[0];
567 		while (*n && (*n != '\\') && (*n != '/'))
568 			if (p != ep)
569 				*p++ = *n++;
570 			else {
571 				dprintf("return, name %s is too long\n", name);
572 				return (-1);	/* name is too long */
573 			}
574 		while ((*n == '\\') || (*n == '/'))
575 			n++;
576 		if (lookup(name, &dd, dir_blk) == 0) {
577 			dprintf("return, name %s not found\n", name);
578 			return (-1);
579 		}
580 		dprintf("dd = %x:%x:%x attr = %x\n",
581 		    *(int *)&dd, *(((int *)&dd) + 1),
582 		    *(((int *)&dd) + 2), dd.d_attr);
583 		if (*n && ((dd.d_attr & DE_DIRECTORY) == 0)) {
584 			dprintf("return, not a directory\n");
585 			return (-1);
586 		}
587 
588 		dir_blk = dd.d_cluster;
589 	}
590 	(void) bcopy(&dd, dp, sizeof (dd));
591 	return (0);
592 }
593 
594 static void *
readblock(int sector,int nsec)595 readblock(int sector, int nsec)
596 {
597 	if (sector >= nsec_start && sector + nsec <= nsec_start + nsec_cache)
598 		return (cluster_cache + (sector - nsec_start) * SECSIZ);
599 
600 	/* read disk sectors */
601 	head->fi_blocknum = sector;
602 	head->fi_count = nsec * SECSIZ;
603 	head->fi_memp = head->fi_buf;
604 	if (diskread(head)) {
605 		printf("failed to %d sectors at %d\n", nsec, sector);
606 		return (NULL);
607 	}
608 
609 	return (head->fi_buf);
610 }
611 
612 struct boot_fs_ops bpcfs_ops = {
613 	"boot_pcfs",
614 	bpcfs_mountroot,
615 	bpcfs_unmountroot,
616 	bpcfs_open,
617 	bpcfs_close,
618 	bpcfs_read,
619 	bpcfs_lseek,
620 	NULL
621 };
622