xref: /illumos-gate/usr/src/stand/lib/fs/hsfs/hsfsops.c (revision b531f6d16eb39863e7bbc34773fb7ef7a282a0a2)
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 (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 #include <sys/param.h>
27 #include <sys/vnode.h>
28 #include <sys/fs/ufs_fsdir.h>
29 #include <sys/fs/ufs_fs.h>
30 #include <sys/fs/ufs_inode.h>
31 #include <sys/sysmacros.h>
32 #include <sys/promif.h>
33 #include <sys/filep.h>
34 #include <sys/salib.h>
35 #include <sys/sacache.h>
36 
37 #include <sys/fs/hsfs_spec.h>
38 #include <sys/fs/hsfs_isospec.h>
39 #include <sys/fs/hsfs_node.h>
40 #include <sys/fs/hsfs_susp.h>
41 #include <sys/fs/hsfs_rrip.h>
42 
43 #include "hsfs_sig.h"
44 
45 #include <sys/stat.h>
46 #include <sys/bootvfs.h>
47 #include <sys/bootconf.h>
48 #include <sys/bootdebug.h>
49 
50 #define	hdbtodb(n)	((ISO_SECTOR_SIZE / DEV_BSIZE) * (n))
51 
52 #define	THE_EPOCH	1970
53 #define	END_OF_TIME	2099
54 
55 /* May not need this... */
56 static uint_t	sua_offset = 0;
57 
58 /* The root inode on an HSFS filesystem can be anywhere! */
59 static uint_t	root_ino = 0;		/* This is both a flag and a value */
60 
61 static fileid_t *head;
62 
63 /* Only got one of these...ergo, only 1 fs open at once */
64 static devid_t *devp;
65 
66 struct dirinfo {
67 	int 	loc;
68 	fileid_t *fi;
69 };
70 
71 struct hs_direct {
72     struct	direct	hs_ufs_dir;
73     struct	hs_direntry hs_dir;
74 };
75 
76 /*
77  *  Function prototypes
78  */
79 
80 static int	boot_hsfs_mountroot(char *str);
81 static int	boot_hsfs_unmountroot(void);
82 static int	boot_hsfs_open(char *filename, int flags);
83 static int	boot_hsfs_close(int fd);
84 static ssize_t	boot_hsfs_read(int fd, caddr_t buf, size_t size);
85 static off_t	boot_hsfs_lseek(int, off_t, int);
86 static int	boot_hsfs_fstat(int fd, struct bootstat *stp);
87 static void	boot_hsfs_closeall(int flag);
88 static int	boot_hsfs_getdents(int fd, struct dirent *dep, unsigned size);
89 
90 struct boot_fs_ops boot_hsfs_ops = {
91 	"hsfs",
92 	boot_hsfs_mountroot,
93 	boot_hsfs_unmountroot,
94 	boot_hsfs_open,
95 	boot_hsfs_close,
96 	boot_hsfs_read,
97 	boot_hsfs_lseek,
98 	boot_hsfs_fstat,
99 	boot_hsfs_closeall,
100 	boot_hsfs_getdents
101 };
102 
103 static 	ino_t	find(fileid_t *, char *);
104 static	ino_t	dlook(fileid_t *, char *);
105 static	int	opendir(fileid_t *, ino_t);
106 static	struct	hs_direct *readdir(struct dirinfo *);
107 static	uint_t	parse_dir(fileid_t *, int, struct hs_direct *);
108 static	uint_t	parse_susp(char *, uint_t *, struct hs_direct *);
109 static	void	hs_seti(fileid_t *,  struct hs_direct *, ino_t);
110 static void	hs_dodates(enum hs_vol_type, struct hs_direntry *, char *);
111 static time_t	hs_date_to_gmtime(int, int, int, int);
112 
113 /*
114  *	There is only 1 open (mounted) device at any given time.
115  *	So we can keep a single, global devp file descriptor to
116  *	use to index into the di[] array.  This is not true for the
117  *	fi[] array.  We can have more than one file open at once,
118  *	so there is no global fd for the fi[].
119  *	The user program must save the fd passed back from open()
120  *	and use it to do subsequent read()'s.
121  */
122 
123 static int
opendir(fileid_t * filep,ino_t inode)124 opendir(fileid_t *filep, ino_t inode)
125 {
126 	struct hs_direct hsdep;
127 	int retval;
128 
129 	/* Set up the saio request */
130 	filep->fi_offset = 0;
131 	filep->fi_blocknum = hdbtodb(inode);
132 	filep->fi_count = ISO_SECTOR_SIZE;
133 
134 	/* Maybe the block is in the disk block cache */
135 	if ((filep->fi_memp = get_bcache(filep)) == NULL) {
136 		/* Not in the block cache so read it from disk */
137 		if (retval = set_bcache(filep)) {
138 			return (retval);
139 		}
140 	}
141 
142 	filep->fi_offset = 0;
143 	filep->fi_blocknum = hdbtodb(inode);
144 
145 	if (inode != root_ino)
146 		return (0);
147 
148 	if ((int)(parse_dir(filep, 0, &hsdep)) > 0) {
149 		hs_seti(filep, &hsdep, inode);
150 		return (0);
151 	}
152 	return (1);
153 }
154 
155 static ino_t
find(fileid_t * filep,char * path)156 find(fileid_t *filep, char *path)
157 {
158 	register char *q;
159 	char c;
160 	ino_t inode;
161 
162 	if (path == NULL || *path == '\0') {
163 		printf("null path\n");
164 		return (0);
165 	}
166 
167 	if ((boothowto & RB_DEBUG) && (boothowto & RB_VERBOSE))
168 		printf("find(): path=<%s>\n", path);
169 
170 	/* Read the ROOT directory */
171 	if (opendir(filep, inode = root_ino)) {
172 		printf("find(): root_ino opendir() failed!\n");
173 		return ((ino_t)-1);
174 	}
175 
176 	while (*path) {
177 		while (*path == '/')
178 			path++;
179 		if (*(q = path) == '\0')
180 			break;
181 		while (*q != '/' && *q != '\0')
182 			q++;
183 		c = *q;
184 		*q = '\0';
185 
186 		if ((inode = dlook(filep, path)) != 0) {
187 			if (c == '\0')
188 				break;
189 			if (opendir(filep, inode)) {
190 				printf("find(): opendir(%d) failed!\n", inode);
191 				*q = c;
192 				return ((ino_t)-1);
193 			}
194 			*q = c;
195 			path = q;
196 			continue;
197 		} else {
198 			*q = c;
199 			return (0);
200 		}
201 	}
202 	return (inode);
203 }
204 
205 static fileid_t *
find_fp(int fd)206 find_fp(int fd)
207 {
208 	fileid_t *filep = head;
209 
210 	if (fd >= 0) {
211 		while ((filep = filep->fi_forw) != head)
212 			if (fd == filep->fi_filedes)
213 				return (filep->fi_taken ? filep : 0);
214 	}
215 
216 	return (0);
217 }
218 
219 static ino_t
dlook(fileid_t * filep,char * path)220 dlook(fileid_t *filep, char *path)
221 {
222 	int dv = filep->fi_devp->di_dcookie;
223 	register struct hs_direct *hsdep;
224 	register struct direct *udp;
225 	register struct inode *ip;
226 	struct dirinfo dirp;
227 	register int len;
228 	ino_t in;
229 
230 	ip = filep->fi_inode;
231 	if (path == NULL || *path == '\0')
232 		return (0);
233 	if ((ip->i_smode & IFMT) != IFDIR) {
234 		return (0);
235 	}
236 	if (ip->i_size == 0) {
237 		return (0);
238 	}
239 	len = strlen(path);
240 	/* first look through the directory entry cache */
241 	if (in = get_dcache(dv, path, ip->i_number)) {
242 		if ((filep->fi_inode = get_icache(dv, in)) != NULL) {
243 			filep->fi_offset = 0;
244 			filep->fi_blocknum = hdbtodb(in);
245 			return (in);
246 		}
247 	}
248 	dirp.loc = 0;
249 	dirp.fi = filep;
250 	for (hsdep = readdir(&dirp); hsdep != NULL; hsdep = readdir(&dirp)) {
251 		udp = &hsdep->hs_ufs_dir;
252 		if (udp->d_namlen == 1 &&
253 		    udp->d_name[0] == '.' &&
254 		    udp->d_name[1] == '\0')
255 			continue;
256 		if (udp->d_namlen == 2 &&
257 		    udp->d_name[0] == '.' &&
258 		    udp->d_name[1] == '.' &&
259 		    udp->d_name[2] == '\0')
260 			continue;
261 		if (udp->d_namlen == len && (strcmp(path, udp->d_name) == 0)) {
262 			set_dcache(dv, path, ip->i_number, udp->d_ino);
263 			hs_seti(filep, hsdep, udp->d_ino);
264 			filep->fi_offset = 0;
265 			filep->fi_blocknum = hdbtodb(udp->d_ino);
266 			/* put this entry into the cache */
267 			return (udp->d_ino);
268 		}
269 		/* Allow "*" to print all names at that level, w/out match */
270 		if (strcmp(path, "*") == 0)
271 			printf("%s\n", udp->d_name);
272 	}
273 	return (0);
274 }
275 
276 /*
277  * get next entry in a directory.
278  */
279 static struct hs_direct *
readdir(struct dirinfo * dirp)280 readdir(struct dirinfo *dirp)
281 {
282 	static struct hs_direct hsdep;
283 	register struct direct *udp = &hsdep.hs_ufs_dir;
284 	register struct inode *ip;
285 	register fileid_t *filep;
286 	register daddr_t lbn;
287 	register int off;
288 
289 	filep = dirp->fi;
290 	ip = filep->fi_inode;
291 	for (;;) {
292 		if (dirp->loc >= ip->i_size) {
293 			return (NULL);
294 		}
295 		off = dirp->loc & ((1 << ISO_SECTOR_SHIFT) - 1);
296 		if (off == 0) {
297 			lbn = hdbtodb(dirp->loc >> ISO_SECTOR_SHIFT);
298 			filep->fi_blocknum = lbn + hdbtodb(ip->i_number);
299 			filep->fi_count = ISO_SECTOR_SIZE;
300 			/* check the block cache */
301 			if ((filep->fi_memp = get_bcache(filep)) == 0)
302 				if (set_bcache(filep))
303 					return ((struct hs_direct *)-1);
304 		}
305 		dirp->loc += parse_dir(filep, off, &hsdep);
306 		if (udp->d_reclen == 0 && dirp->loc <= ip->i_size) {
307 			dirp->loc = roundup(dirp->loc, ISO_SECTOR_SIZE);
308 			continue;
309 		}
310 		return (&hsdep);
311 	}
312 }
313 
314 /*
315  * Get the next block of data from the file.  If possible, dma right into
316  * user's buffer
317  */
318 static int
getblock(fileid_t * filep,caddr_t buf,int count,int * rcount)319 getblock(fileid_t *filep, caddr_t buf, int count, int *rcount)
320 {
321 	register struct inode *ip;
322 	register caddr_t p;
323 	register int off, size, diff;
324 	register daddr_t lbn;
325 	static int	pos;
326 	static char 	ind[] = "|/-\\";	/* that's entertainment? */
327 	static int	blks_read;
328 
329 	ip = filep->fi_inode;
330 	p = filep->fi_memp;
331 	if ((signed)filep->fi_count <= 0) {
332 
333 		/* find the amt left to be read in the file */
334 		diff = ip->i_size - filep->fi_offset;
335 		if (diff <= 0) {
336 			printf("Short read\n");
337 			return (-1);
338 		}
339 
340 		/* which block (or frag) in the file do we read? */
341 		lbn = hdbtodb(filep->fi_offset >> ISO_SECTOR_SHIFT);
342 
343 		/* which physical block on the device do we read? */
344 		filep->fi_blocknum = lbn + hdbtodb(ip->i_number);
345 
346 		off = filep->fi_offset & ((1 << ISO_SECTOR_SHIFT) - 1);
347 
348 		size = sizeof (filep->fi_buf);
349 		if (size > ISO_SECTOR_SIZE)
350 			size = ISO_SECTOR_SIZE;
351 
352 		filep->fi_count = size;
353 		filep->fi_memp = filep->fi_buf;
354 
355 		/*
356 		 * optimization if we are reading large blocks of data then
357 		 * we can go directly to user's buffer
358 		 */
359 		*rcount = 0;
360 		if (off == 0 && count >= size) {
361 			filep->fi_memp = buf;
362 			if (diskread(filep)) {
363 				return (-1);
364 			}
365 			*rcount = size;
366 			filep->fi_count = 0;
367 			read_opt++;
368 			if ((blks_read++ & 0x3) == 0)
369 				printf("%c\b", ind[pos++ & 3]);
370 			return (0);
371 		} else
372 			if (diskread(filep))
373 				return (-1);
374 
375 		/*
376 		 * round and round she goes (though not on every block..
377 		 * - OBP's take a fair bit of time to actually print stuff)
378 		 */
379 		if ((blks_read++ & 0x3) == 0)
380 			printf("%c\b", ind[pos++ & 3]);
381 
382 		if (filep->fi_offset - off + size >= ip->i_size)
383 			filep->fi_count = diff + off;
384 		filep->fi_count -= off;
385 		p = &filep->fi_memp[off];
386 	}
387 	filep->fi_memp = p;
388 	return (0);
389 }
390 
391 
392 /*
393  *  This is the high-level read function.  It works like this.
394  *  We assume that our IO device buffers up some amount of
395  *  data ant that we can get a ptr to it.  Thus we need
396  *  to actually call the device func about filesize/blocksize times
397  *  and this greatly increases our IO speed.  When we already
398  *  have data in the buffer, we just return that data (with bcopy() ).
399  */
400 
401 static ssize_t
boot_hsfs_read(int fd,caddr_t buf,size_t count)402 boot_hsfs_read(int fd, caddr_t buf, size_t count)
403 {
404 	size_t i, j;
405 	struct inode *ip;
406 	caddr_t	n;
407 	fileid_t *filep;
408 	int rcount;
409 
410 	if (!(filep = find_fp(fd))) {
411 		return (-1);
412 	}
413 
414 	ip = filep->fi_inode;
415 
416 	if (filep->fi_offset + count > ip->i_size)
417 		count = ip->i_size - filep->fi_offset;
418 
419 	/* that was easy */
420 	if ((i = count) == 0)
421 		return (0);
422 
423 	n = buf;
424 	while (i > 0) {
425 		/* If we need to reload the buffer, do so */
426 		if ((j = filep->fi_count) == 0) {
427 			(void) getblock(filep, buf, i, &rcount);
428 			i -= rcount;
429 			buf += rcount;
430 			filep->fi_offset += rcount;
431 		} else {
432 			/* else just bcopy from our buffer */
433 			j = MIN(i, j);
434 			bcopy(filep->fi_memp, buf, (unsigned)j);
435 			buf += j;
436 			filep->fi_memp += j;
437 			filep->fi_offset += j;
438 			filep->fi_count -= j;
439 			i -= j;
440 		}
441 	}
442 	return (buf - n);
443 }
444 
445 /*
446  *	This routine will open a device as it is known by the
447  *	V2 OBP.
448  *	Interface Defn:
449  *	err = mountroot(string);
450  *	err:	0 on success
451  *		-1 on failure
452  *	string:	char string describing the properties of the device.
453  *	We must not dork with any fi[]'s here.  Save that for later.
454  */
455 
456 static int
boot_hsfs_mountroot(char * str)457 boot_hsfs_mountroot(char *str)
458 {
459 	ihandle_t	h;
460 	struct hs_volume *fsp;
461 	char 		*bufp;
462 
463 	if ((boothowto & RB_DEBUG) && (boothowto & RB_VERBOSE))
464 		printf("mountroot()\n");
465 
466 	/*
467 	 * If already mounted, just return success.
468 	 */
469 	if (root_ino != 0) {
470 		return (0);
471 	}
472 
473 	h = prom_open(str);
474 
475 	if (h == 0) {
476 		printf("Cannot open %s\n", str);
477 		return (-1);
478 	}
479 
480 	devp = (devid_t *)bkmem_alloc(sizeof (devid_t));
481 	devp->di_taken = 1;
482 	devp->di_dcookie = h;
483 	devp->di_desc = (char *)bkmem_alloc(strlen(str) + 1);
484 	(void) strcpy(devp->di_desc, str);
485 	bzero(devp->un_fs.dummy, sizeof (devp->un_fs.dummy));
486 	head = (fileid_t *)bkmem_alloc(sizeof (fileid_t));
487 	head->fi_back = head->fi_forw = head;
488 	head->fi_filedes = 0;
489 	head->fi_taken = 0;
490 
491 	/* Setup read of the "superblock" */
492 	bzero(head->fi_buf, sizeof (head->fi_buf));
493 	head->fi_devp = devp;
494 	head->fi_blocknum = hdbtodb(ISO_VOLDESC_SEC);
495 	head->fi_count = ISO_SECTOR_SIZE;
496 	head->fi_memp = head->fi_buf;
497 	head->fi_offset = 0;
498 
499 	if (diskread(head)) {
500 		printf("mountroot(): read super block failed!\n");
501 		boot_hsfs_closeall(1);
502 		return (-1);
503 	}
504 
505 	bufp = head->fi_memp;
506 	fsp = (struct hs_volume *)devp->un_fs.dummy;
507 	/* Since RRIP is based on ISO9660, that's where we start */
508 
509 	if (ISO_DESC_TYPE(bufp) != ISO_VD_PVD ||
510 	    strncmp((char *)(ISO_std_id(bufp)), (char *)(ISO_ID_STRING),
511 	    ISO_ID_STRLEN) != 0 || ISO_STD_VER(bufp) != ISO_ID_VER) {
512 		boot_hsfs_closeall(1);
513 		return (-1);
514 	}
515 
516 	/* Now we fill in the volume descriptor */
517 	fsp->vol_size = ISO_VOL_SIZE(bufp);
518 	fsp->lbn_size = ISO_BLK_SIZE(bufp);
519 	fsp->lbn_shift = ISO_SECTOR_SHIFT;
520 	fsp->lbn_secshift = ISO_SECTOR_SHIFT;
521 	fsp->vol_set_size = (ushort_t)ISO_SET_SIZE(bufp);
522 	fsp->vol_set_seq = (ushort_t)ISO_SET_SEQ(bufp);
523 
524 	/* Make sure we have a valid logical block size */
525 	if (fsp->lbn_size & ~(1 << fsp->lbn_shift)) {
526 		printf("%d byte logical block size invalid.\n", fsp->lbn_size);
527 		boot_hsfs_closeall(1);
528 		return (-1);
529 	}
530 
531 	/* Since an HSFS root could be located anywhere on the media! */
532 	root_ino = IDE_EXT_LBN(ISO_root_dir(bufp));
533 
534 	if ((boothowto & RB_DEBUG) && (boothowto & RB_VERBOSE)) {
535 		int	i;
536 
537 		printf("root_ino=%d\n", root_ino);
538 		printf("ID=");
539 		for (i = 0; i < ISO_ID_STRLEN; i++)
540 			printf("%c", *(ISO_std_id(bufp)+i));
541 		printf(" VS=%d\n", fsp->vol_size);
542 	}
543 
544 	return (0);
545 }
546 
547 /*
548  * Unmount the currently mounted root fs.  In practice, this means
549  * closing all open files and releasing resources.  All of this
550  * is done by boot_hsfs_closeall().
551  */
552 
553 int
boot_hsfs_unmountroot(void)554 boot_hsfs_unmountroot(void)
555 {
556 	if (root_ino == 0)
557 		return (-1);
558 
559 	boot_hsfs_closeall(1);
560 
561 	return (0);
562 }
563 
564 /*
565  *	We allocate an fd here for use when talking
566  *	to the file itself.
567  */
568 
569 /*ARGSUSED*/
570 static int
boot_hsfs_open(char * filename,int flags)571 boot_hsfs_open(char *filename, int flags)
572 {
573 	fileid_t	*filep;
574 	ino_t		inode;
575 	static int	filedes = 1;
576 
577 	/* build and link a new file descriptor */
578 	filep = (fileid_t *)bkmem_alloc(sizeof (fileid_t));
579 	filep->fi_back = head->fi_back;
580 	filep->fi_forw = head;
581 	head->fi_back->fi_forw = filep;
582 	head->fi_back = filep;
583 
584 	filep->fi_filedes = filedes++;
585 	filep->fi_taken = 1;
586 	filep->fi_path = (char *)bkmem_alloc(strlen(filename) + 1);
587 	(void) strcpy(filep->fi_path, filename);
588 	filep->fi_devp = devp; /* dev is already "mounted" */
589 
590 	filep->fi_inode = 0;
591 
592 	inode = find(filep, filename);
593 	if (inode == (ino_t)0) {
594 		if ((boothowto & RB_DEBUG) && (boothowto & RB_VERBOSE))
595 			printf("open(%s) ENOENT\n", filename);
596 		(void) boot_hsfs_close(filep->fi_filedes);
597 		return (-1);
598 	}
599 
600 	filep->fi_blocknum = hdbtodb(inode);
601 	filep->fi_offset = filep->fi_count = 0;
602 
603 	if ((boothowto & RB_DEBUG) && (boothowto & RB_VERBOSE))
604 		printf("open(%s) fd=%d\n", filename, filep->fi_filedes);
605 	return (filep->fi_filedes);
606 }
607 
608 /*
609  * hsfs_fstat() only supports size, mode and times at present time.
610  */
611 
612 static int
boot_hsfs_fstat(int fd,struct bootstat * stp)613 boot_hsfs_fstat(int fd, struct bootstat *stp)
614 {
615 	fileid_t	*filep;
616 	struct inode	*ip;
617 
618 	if (!(filep = find_fp(fd)))
619 		return (-1);
620 
621 	ip = filep->fi_inode;
622 
623 	stp->st_mode = 0;
624 	stp->st_size = 0;
625 
626 	if (ip == NULL)
627 		return (0);
628 
629 	switch (ip->i_smode & IFMT) {
630 	case IFDIR:
631 		stp->st_mode = S_IFDIR;
632 		break;
633 	case IFREG:
634 		stp->st_mode = S_IFREG;
635 		break;
636 	default:
637 		break;
638 	}
639 	stp->st_size = ip->i_size;
640 
641 	/* file times */
642 	stp->st_atim.tv_sec = ip->i_atime.tv_sec;
643 	stp->st_atim.tv_nsec = ip->i_atime.tv_usec * 1000;
644 	stp->st_mtim.tv_sec = ip->i_mtime.tv_sec;
645 	stp->st_mtim.tv_nsec = ip->i_mtime.tv_usec * 1000;
646 	stp->st_ctim.tv_sec = ip->i_ctime.tv_sec;
647 	stp->st_ctim.tv_nsec = ip->i_ctime.tv_usec * 1000;
648 
649 	return (0);
650 }
651 
652 /*
653  *  We don't do any IO here.
654  *  We just play games with the device pointers.
655  */
656 
657 /*ARGSUSED*/
658 static off_t
boot_hsfs_lseek(int fd,off_t addr,int whence)659 boot_hsfs_lseek(int fd, off_t addr, int whence)
660 {
661 	fileid_t *filep;
662 
663 	if (!(filep = find_fp(fd)))
664 		return (-1);
665 
666 	filep->fi_offset = addr;
667 	filep->fi_blocknum = addr / DEV_BSIZE;
668 	filep->fi_count = 0;
669 
670 	return (0);
671 }
672 
673 static int
boot_hsfs_close(int fd)674 boot_hsfs_close(int fd)
675 {
676 	fileid_t *filep;
677 
678 	if ((boothowto & RB_DEBUG) && (boothowto & RB_VERBOSE))
679 		printf("close(%d)\n", fd);
680 
681 	if (filep = find_fp(fd)) {
682 		/* Clear the ranks */
683 		bkmem_free(filep->fi_path, strlen(filep->fi_path)+1);
684 		filep->fi_blocknum = filep->fi_count = filep->fi_offset = 0;
685 		filep->fi_memp = (caddr_t)0;
686 		filep->fi_devp = 0;
687 		filep->fi_taken = 0;
688 
689 		/* unlink and deallocate node */
690 		filep->fi_forw->fi_back = filep->fi_back;
691 		filep->fi_back->fi_forw = filep->fi_forw;
692 		bkmem_free((char *)filep, sizeof (fileid_t));
693 
694 		return (0);
695 	} else {
696 		/* Big problem */
697 		printf("\nFile descrip %d not allocated!", fd);
698 		return (-1);
699 	}
700 }
701 
702 /* closeall is now idempotent */
703 /*ARGSUSED*/
704 static void
boot_hsfs_closeall(int flag)705 boot_hsfs_closeall(int flag)
706 {
707 	fileid_t	*filep = head;
708 	extern int verbosemode;
709 
710 	if (devp == NULL) {
711 		if (head)
712 			prom_panic("boot_hsfs_closeall: head != NULL.\n");
713 		return;
714 	}
715 
716 	while ((filep = filep->fi_forw) != head)
717 		if (filep->fi_taken)
718 			if (boot_hsfs_close(filep->fi_filedes))
719 				prom_panic("Filesystem may be inconsistent.\n");
720 
721 
722 	release_cache(devp->di_dcookie);
723 	(void) prom_close(devp->di_dcookie);
724 	devp->di_taken = 0;
725 	if (verbosemode)
726 		print_cache_data();
727 	bkmem_free((char *)devp, sizeof (devid_t));
728 	bkmem_free((char *)head, sizeof (fileid_t));
729 	root_ino = 0;
730 	devp = NULL;
731 	head = NULL;
732 }
733 
734 static uint_t
parse_dir(fileid_t * filep,int offset,struct hs_direct * hsdep)735 parse_dir(fileid_t *filep, int offset, struct hs_direct *hsdep)
736 {
737 	char *bufp = (char *)(filep->fi_memp + offset);
738 	struct direct *udp = &hsdep->hs_ufs_dir;
739 	struct hs_direntry *hdp = &hsdep->hs_dir;
740 	uint_t ce_lbn;
741 	uint_t ce_len;
742 	uint_t nmlen;
743 	uint_t i;
744 	uchar_t c;
745 	int ret_code = 0;
746 
747 	if ((udp->d_reclen = IDE_DIR_LEN(bufp)) == 0)
748 		return (0);
749 
750 	hdp->ext_lbn  = IDE_EXT_LBN(bufp);
751 	hdp->ext_size = IDE_EXT_SIZE(bufp);
752 	hs_dodates(HS_VOL_TYPE_ISO, hdp, bufp);
753 	hdp->xar_len  = IDE_XAR_LEN(bufp);
754 	hdp->intlf_sz = IDE_INTRLV_SIZE(bufp);
755 	hdp->intlf_sk = IDE_INTRLV_SKIP(bufp);
756 	hdp->sym_link = NULL;
757 
758 	udp->d_ino = hdp->ext_lbn;
759 
760 	c = IDE_FLAGS(bufp);
761 	if (IDE_REGULAR_FILE(c)) {
762 		hdp->type = VREG;
763 		hdp->mode = IFREG;
764 		hdp->nlink = 1;
765 	} else if (IDE_REGULAR_DIR(c)) {
766 		hdp->type = VDIR;
767 		hdp->mode = IFDIR;
768 		hdp->nlink = 2;
769 	} else {
770 		printf("parse_dir(): file type=0x%x unknown.\n", c);
771 		return ((uint_t)-1);
772 	}
773 
774 	/* Some initial conditions */
775 	nmlen = IDE_NAME_LEN(bufp);
776 	c = *IDE_NAME(bufp);
777 	/* Special Case: Current Directory */
778 	if (nmlen == 1 && c == '\0') {
779 		udp->d_name[0] = '.';
780 		udp->d_name[1] = '\0';
781 		udp->d_namlen = 1;
782 	/* Special Case: Parent Directory */
783 	} else if (nmlen == 1 && c == '\001') {
784 		udp->d_name[0] = '.';
785 		udp->d_name[1] = '.';
786 		udp->d_name[2] = '\0';
787 		udp->d_namlen = 2;
788 	/* Other file name */
789 	} else {
790 		udp->d_namlen = 0;
791 		for (i = 0; i < nmlen; i++) {
792 			c = *(IDE_name(bufp)+i);
793 			if (c == ';')
794 				break;
795 			else if (c == ' ')
796 				continue;
797 			else
798 				udp->d_name[udp->d_namlen++] = c;
799 		}
800 		udp->d_name[udp->d_namlen] = '\0';
801 	}
802 	/* System Use Fields */
803 	ce_len = IDE_SUA_LEN(bufp);
804 	ce_lbn = 0;
805 	if ((int)(ce_len) > 0) {
806 		ce_lbn = parse_susp((char *)IDE_sys_use_area(bufp),
807 		    &ce_len, hsdep);
808 		while (ce_lbn) {
809 			daddr_t save_blocknum = filep->fi_blocknum;
810 			daddr_t save_offset = filep->fi_offset;
811 			caddr_t save_memp = filep->fi_memp;
812 			uint_t save_count = filep->fi_count;
813 
814 #ifdef	noisy
815 			print_io_req(filep, "parse_dir(): [I]");
816 #endif	/* noisy */
817 
818 			filep->fi_blocknum = hdbtodb(ce_lbn);
819 			filep->fi_offset = 0;
820 			filep->fi_count = ISO_SECTOR_SIZE;
821 
822 #ifdef	noisy
823 			print_io_req(filep, "parse_dir(): [0]");
824 #endif	/* noisy */
825 
826 			if ((filep->fi_memp = get_bcache(filep)) == 0)
827 				ret_code = set_bcache(filep);
828 
829 #ifdef	noisy
830 			print_io_req(filep, "parse_dir(): [1]");
831 #endif	/* noisy */
832 
833 			if (ret_code) {
834 				filep->fi_blocknum = save_blocknum;
835 				filep->fi_offset = save_offset;
836 				filep->fi_memp = save_memp;
837 				filep->fi_count = save_count;
838 				printf("parse_dir(): "
839 				    "set_bcache() failed (%d)\n", ret_code);
840 				break;
841 			}
842 			ce_lbn = parse_susp(filep->fi_memp, &ce_len, hsdep);
843 
844 			filep->fi_blocknum = save_blocknum;
845 			filep->fi_offset = save_offset;
846 			filep->fi_memp = save_memp;
847 			filep->fi_count = save_count;
848 
849 #ifdef	noisy
850 			print_io_req(filep, "parse_dir(): [2]");
851 #endif	/* noisy */
852 		}
853 	}
854 
855 	return (udp->d_reclen);
856 }
857 
858 static uint_t
parse_susp(char * bufp,uint_t * ce_len,struct hs_direct * hsdep)859 parse_susp(char *bufp, uint_t *ce_len, struct hs_direct *hsdep)
860 {
861 	struct direct *udp = &hsdep->hs_ufs_dir;
862 	uchar_t *susp;
863 	uint_t cur_off = 0;
864 	uint_t blk_len = *ce_len;
865 	uint_t susp_len = 0;
866 	uint_t ce_lbn = 0;
867 	uint_t i;
868 
869 	while (cur_off < blk_len) {
870 		susp = (uchar_t *)(bufp + cur_off);
871 		if (susp[0] == '\0' || susp[1] == '\0')
872 			break;
873 		susp_len = SUF_LEN(susp);
874 		if (susp_len == 0)
875 			break;
876 		for (i = 0; i < hsfs_num_sig; i++) {
877 			if (strncmp(hsfs_sig_tab[i],
878 			    (char *)susp, SUF_SIG_LEN) == 0) {
879 #ifdef	noisy
880 				if ((boothowto & RB_DEBUG) &&
881 				    (boothowto & RB_VERBOSE))
882 					printf("  SUSP_%c%c %d\n",
883 					    susp[0], susp[1], susp_len);
884 #endif	/* noisy */
885 				switch (i) {
886 				case SUSP_SP_IX:
887 					if (CHECK_BYTES_OK(susp)) {
888 						sua_offset =
889 						    SP_SUA_OFFSET(susp);
890 #ifdef	lint
891 						/* this may not be needed */
892 						i = (int)sua_offset;
893 #endif	/* lint */
894 					}
895 					break;
896 
897 				case SUSP_CE_IX:
898 					ce_lbn = CE_BLK_LOC(susp);
899 					*ce_len = CE_CONT_LEN(susp);
900 #ifdef	noisy
901 					if ((boothowto & RB_DEBUG) &&
902 					    (boothowto & RB_VERBOSE))
903 						printf("parse_susp(): "
904 						    "CE: ce_lbn = %d "
905 						    "ce_len=%d\n",
906 						    ce_lbn, *ce_len);
907 #endif	/* noisy */
908 					break;
909 
910 				case SUSP_ST_IX:
911 					printf("parse_susp(): ST: returning "
912 					    "%d\n", ce_lbn);
913 					return (ce_lbn);
914 
915 				case RRIP_SL_IX:
916 #ifdef	noisy
917 					if ((boothowto & RB_DEBUG) &&
918 					    (boothowto & RB_VERBOSE))
919 						printf("parse_susp(): "
920 						    "******* SL *******\n");
921 #endif	/* noisy */
922 					break;
923 
924 				case RRIP_RR_IX:
925 					break;
926 
927 				case RRIP_NM_IX:
928 					if (!RRIP_NAME_FLAGS(susp)) {
929 						udp->d_namlen =
930 						    RRIP_NAME_LEN(susp);
931 						bcopy((char *)RRIP_name(susp),
932 						    (char *)udp->d_name,
933 						    udp->d_namlen);
934 						udp->d_name
935 						    [udp->d_namlen] = '\0';
936 					}
937 					break;
938 				}
939 				cur_off += susp_len;
940 				break;
941 			}
942 		}
943 		if (i > hsfs_num_sig) {
944 			printf("parse_susp(): Bad SUSP\n");
945 			cur_off = blk_len;
946 			break;
947 		}
948 	}
949 	return (ce_lbn);
950 }
951 
952 static void
hs_seti(fileid_t * filep,struct hs_direct * hsdep,ino_t inode)953 hs_seti(fileid_t *filep, struct hs_direct *hsdep, ino_t inode)
954 {
955 	register struct inode *ip;
956 	int dv = filep->fi_devp->di_dcookie;
957 
958 	/* Try the inode cache first */
959 	if ((filep->fi_inode = get_icache(dv, inode)) != NULL)
960 		return;
961 
962 	filep->fi_inode = (struct inode *)bkmem_alloc(sizeof (struct inode));
963 	ip = filep->fi_inode;
964 	bzero((char *)ip, sizeof (struct inode));
965 	ip->i_size = hsdep->hs_dir.ext_size;
966 	ip->i_smode = hsdep->hs_dir.mode;
967 	ip->i_number = inode;
968 	ip->i_atime.tv_sec = hsdep->hs_dir.adate.tv_sec;
969 	ip->i_atime.tv_usec = hsdep->hs_dir.adate.tv_usec;
970 	ip->i_ctime.tv_sec = hsdep->hs_dir.cdate.tv_sec;
971 	ip->i_ctime.tv_usec = hsdep->hs_dir.cdate.tv_usec;
972 	ip->i_mtime.tv_sec = hsdep->hs_dir.mdate.tv_sec;
973 	ip->i_mtime.tv_usec = hsdep->hs_dir.mdate.tv_usec;
974 	set_icache(dv, inode, ip, sizeof (struct inode));
975 }
976 
977 #ifdef	noisy
978 static void
print_io_req(fileid_t * filep,char * str)979 print_io_req(fileid_t *filep, char *str)
980 {
981 	printf("%s o=%d b=%d c=%d m=%x\n",
982 	    str,
983 	    filep->fi_offset,
984 	    filep->fi_blocknum,
985 	    filep->fi_count,
986 	    (uint_t)filep->fi_memp);
987 }
988 #endif	/* noisy */
989 
990 static int
boot_hsfs_getdents(int fd,struct dirent * dep,unsigned size)991 boot_hsfs_getdents(int fd, struct dirent *dep, unsigned size)
992 {
993 	/*
994 	 * Read directory entries from the file open on "fd" into the
995 	 * "size"-byte buffer at "dep" until the buffer is exhausted
996 	 * or we reach EOF on the directory.  Returns the number of
997 	 * entries read.
998 	 */
999 	int n;
1000 	int cnt = 0;
1001 	struct dirinfo dir;
1002 	struct hs_direct *hdp;
1003 	unsigned long oldoff, oldblok;
1004 
1005 #define	SLOP (sizeof (struct dirent) - offsetof(struct dirent, d_name[1]))
1006 
1007 	if (!(dir.fi = find_fp(fd)) ||
1008 	    ((dir.fi->fi_inode->i_smode & IFMT) != IFDIR)) {
1009 		/*
1010 		 *  Bogus file descriptor, bail out now!
1011 		 */
1012 		return (-1);
1013 	}
1014 
1015 	oldoff = dir.loc = dir.fi->fi_offset;
1016 	oldblok = dir.fi->fi_blocknum;
1017 
1018 	for (hdp = readdir(&dir); hdp; hdp = readdir(&dir)) {
1019 		/*
1020 		 * Compute name length and break loop if there's not
1021 		 * enough space in the output buffer for the next
1022 		 * entry.
1023 		 *
1024 		 *  NOTE: "SLOP" is the number of bytes inserted into the dirent
1025 		 *	  struct's "d_name" field by the compiler to preserve
1026 		 *	  alignment.
1027 		 */
1028 		n = strlen(hdp->hs_ufs_dir.d_name);
1029 		n = roundup((sizeof (struct dirent) + ((n > SLOP) ? n : 0)),
1030 		    sizeof (off_t));
1031 
1032 		if (n > size) {
1033 			dir.fi->fi_blocknum = oldblok;
1034 			dir.fi->fi_offset = oldoff;
1035 			break;
1036 		}
1037 
1038 		oldblok = dir.fi->fi_blocknum;
1039 		oldoff = dir.loc;
1040 		size -= n;
1041 		cnt += 1;
1042 
1043 		(void) strlcpy(dep->d_name, hdp->hs_ufs_dir.d_name,
1044 		    strlen(hdp->hs_ufs_dir.d_name) + 1);
1045 		dep->d_ino = hdp->hs_ufs_dir.d_ino;
1046 		dep->d_off = dir.loc;
1047 		dep->d_reclen = (unsigned short)n;
1048 
1049 		dep = (struct dirent *)((char *)dep + n);
1050 	}
1051 
1052 #undef SLOP
1053 
1054 	return (cnt);
1055 }
1056 
1057 static void
hs_dodates(enum hs_vol_type type,struct hs_direntry * hdp,char * bufp)1058 hs_dodates(enum hs_vol_type type, struct hs_direntry *hdp, char *bufp)
1059 {
1060 	if (type == HS_VOL_TYPE_HS) {
1061 		hs_parse_dirdate(HDE_cdate(bufp), &hdp->cdate);
1062 		hs_parse_dirdate(HDE_cdate(bufp), &hdp->adate);
1063 		hs_parse_dirdate(HDE_cdate(bufp), &hdp->mdate);
1064 	} else if (type == HS_VOL_TYPE_ISO) {
1065 		hs_parse_dirdate(IDE_cdate(bufp), &hdp->cdate);
1066 		hs_parse_dirdate(IDE_cdate(bufp), &hdp->adate);
1067 		hs_parse_dirdate(IDE_cdate(bufp), &hdp->mdate);
1068 	} else
1069 		prom_panic("hs_dodates:  bad volume type");
1070 }
1071 
1072 /*
1073  * hs_parse_dirdate
1074  *
1075  * Parse the short 'directory-format' date into a Unix timeval.
1076  * This is the date format used in Directory Entries.
1077  *
1078  * If the date is not representable, make something up.
1079  */
1080 void
hs_parse_dirdate(uchar_t * dp,struct timeval * tvp)1081 hs_parse_dirdate(uchar_t *dp, struct timeval *tvp)
1082 {
1083 	int year, month, day, hour, minute, sec, gmtoff;
1084 
1085 	year = HDE_DATE_YEAR(dp);
1086 	month = HDE_DATE_MONTH(dp);
1087 	day = HDE_DATE_DAY(dp);
1088 	hour = HDE_DATE_HOUR(dp);
1089 	minute = HDE_DATE_MIN(dp);
1090 	sec = HDE_DATE_SEC(dp);
1091 	gmtoff = HDE_DATE_GMTOFF(dp);
1092 
1093 	tvp->tv_usec = 0;
1094 	if (year < THE_EPOCH) {
1095 		tvp->tv_sec = 0;
1096 	} else {
1097 		tvp->tv_sec = hs_date_to_gmtime(year, month, day, gmtoff);
1098 		if (tvp->tv_sec != -1) {
1099 			tvp->tv_sec += ((hour * 60) + minute) * 60 + sec;
1100 		}
1101 	}
1102 
1103 	return;
1104 
1105 }
1106 
1107 /*
1108  * hs_parse_longdate
1109  *
1110  * Parse the long 'user-oriented' date into a Unix timeval.
1111  * This is the date format used in the Volume Descriptor.
1112  *
1113  * If the date is not representable, make something up.
1114  */
1115 void
hs_parse_longdate(uchar_t * dp,struct timeval * tvp)1116 hs_parse_longdate(uchar_t *dp, struct timeval *tvp)
1117 {
1118 	int year, month, day, hour, minute, sec, gmtoff;
1119 
1120 	year = HSV_DATE_YEAR(dp);
1121 	month = HSV_DATE_MONTH(dp);
1122 	day = HSV_DATE_DAY(dp);
1123 	hour = HSV_DATE_HOUR(dp);
1124 	minute = HSV_DATE_MIN(dp);
1125 	sec = HSV_DATE_SEC(dp);
1126 	gmtoff = HSV_DATE_GMTOFF(dp);
1127 
1128 	tvp->tv_usec = 0;
1129 	if (year < THE_EPOCH) {
1130 		tvp->tv_sec = 0;
1131 	} else {
1132 		tvp->tv_sec = hs_date_to_gmtime(year, month, day, gmtoff);
1133 		if (tvp->tv_sec != -1) {
1134 			tvp->tv_sec += ((hour * 60) + minute) * 60 + sec;
1135 			tvp->tv_usec = HSV_DATE_HSEC(dp) * 10000;
1136 		}
1137 	}
1138 
1139 }
1140 
1141 /* cumulative number of seconds per month,  non-leap and leap-year versions */
1142 static time_t cum_sec[] = {
1143 	0x0, 0x28de80, 0x4dc880, 0x76a700, 0x9e3400, 0xc71280,
1144 	0xee9f80, 0x1177e00, 0x1405c80, 0x167e980, 0x190c800, 0x1b85500
1145 };
1146 static time_t cum_sec_leap[] = {
1147 	0x0, 0x28de80, 0x4f1a00, 0x77f880, 0x9f8580, 0xc86400,
1148 	0xeff100, 0x118cf80, 0x141ae00, 0x1693b00, 0x1921980, 0x1b9a680
1149 };
1150 #define	SEC_PER_DAY	0x15180
1151 #define	SEC_PER_YEAR	0x1e13380
1152 
1153 /*
1154  * hs_date_to_gmtime
1155  *
1156  * Convert year(1970-2099)/month(1-12)/day(1-31) to seconds-since-1970/1/1.
1157  *
1158  * Returns -1 if the date is out of range.
1159  */
1160 static time_t
hs_date_to_gmtime(int year,int mon,int day,int gmtoff)1161 hs_date_to_gmtime(int year, int mon, int day, int gmtoff)
1162 {
1163 	time_t sum;
1164 	time_t *cp;
1165 	int y;
1166 
1167 	if ((year < THE_EPOCH) || (year > END_OF_TIME) ||
1168 	    (mon < 1) || (mon > 12) ||
1169 	    (day < 1) || (day > 31))
1170 		return (-1);
1171 
1172 	/*
1173 	 * Figure seconds until this year and correct for leap years.
1174 	 * Note: 2000 is a leap year but not 2100.
1175 	 */
1176 	y = year - THE_EPOCH;
1177 	sum = y * SEC_PER_YEAR;
1178 	sum += ((y + 1) / 4) * SEC_PER_DAY;
1179 	/*
1180 	 * Point to the correct table for this year and
1181 	 * add in seconds until this month.
1182 	 */
1183 	cp = ((y + 2) % 4) ? cum_sec : cum_sec_leap;
1184 	sum += cp[mon - 1];
1185 	/*
1186 	 * Add in seconds until 0:00 of this day.
1187 	 * (days-per-month validation is not done here)
1188 	 */
1189 	sum += (day - 1) * SEC_PER_DAY;
1190 	sum -= (gmtoff * 15 * 60);
1191 	return (sum);
1192 }
1193