1 /*
2 * GRUB -- GRand Unified Bootloader
3 * Copyright (C) 2000, 2001 Free Software Foundation, Inc.
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
18 * MA 02110-1301, USA.
19 */
20
21 /*
22 * Elements of this file were originally from the FreeBSD "biosboot"
23 * bootloader file "disk.c" dated 4/12/95.
24 *
25 * The license and header comments from that file are included here.
26 */
27
28 /*
29 * Mach Operating System
30 * Copyright (c) 1992, 1991 Carnegie Mellon University
31 * All Rights Reserved.
32 *
33 * Permission to use, copy, modify and distribute this software and its
34 * documentation is hereby granted, provided that both the copyright
35 * notice and this permission notice appear in all copies of the
36 * software, derivative works or modified versions, and any portions
37 * thereof, and that both notices appear in supporting documentation.
38 *
39 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
40 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
41 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
42 *
43 * Carnegie Mellon requests users of this software to return to
44 *
45 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
46 * School of Computer Science
47 * Carnegie Mellon University
48 * Pittsburgh PA 15213-3890
49 *
50 * any improvements or extensions that they make and grant Carnegie Mellon
51 * the rights to redistribute these changes.
52 *
53 * from: Mach, Revision 2.2 92/04/04 11:35:49 rpd
54 * $Id: fsys_ffs.c,v 1.10 2001/11/12 06:57:29 okuji Exp $
55 */
56
57 #ifdef FSYS_FFS
58
59 #include "shared.h"
60
61 #include "filesys.h"
62
63 #include "defs.h"
64 #include "disk_inode.h"
65 #include "disk_inode_ffs.h"
66 #include "dir.h"
67 #include "fs.h"
68
69 /* used for filesystem map blocks */
70 static int mapblock;
71 static int mapblock_offset;
72 static int mapblock_bsize;
73
74 /* pointer to superblock */
75 #define SUPERBLOCK ((struct fs *) ( FSYS_BUF + 8192 ))
76 #define INODE ((struct icommon *) ( FSYS_BUF + 16384 ))
77 #define MAPBUF ( FSYS_BUF + 24576 )
78 #define MAPBUF_LEN 8192
79
80
81 int
ffs_mount(void)82 ffs_mount (void)
83 {
84 int retval = 1;
85
86 if ((((current_drive & 0x80) || (current_slice != 0))
87 && ! IS_PC_SLICE_TYPE_BSD_WITH_FS (current_slice, FS_BSDFFS))
88 || part_length < (SBLOCK + (SBSIZE / DEV_BSIZE))
89 || !devread (SBLOCK, 0, SBSIZE, (char *) SUPERBLOCK)
90 || SUPERBLOCK->fs_magic != FS_MAGIC)
91 retval = 0;
92
93 mapblock = -1;
94 mapblock_offset = -1;
95
96 return retval;
97 }
98
99 static int
block_map(int file_block)100 block_map (int file_block)
101 {
102 int bnum, offset, bsize;
103
104 if (file_block < NDADDR)
105 return (INODE->i_db[file_block]);
106
107 /* If the blockmap loaded does not include FILE_BLOCK,
108 load a new blockmap. */
109 if ((bnum = fsbtodb (SUPERBLOCK, INODE->i_ib[0])) != mapblock
110 || (mapblock_offset <= bnum && bnum <= mapblock_offset + mapblock_bsize))
111 {
112 if (MAPBUF_LEN < SUPERBLOCK->fs_bsize)
113 {
114 offset = ((file_block - NDADDR) % NINDIR (SUPERBLOCK));
115 bsize = MAPBUF_LEN;
116
117 if (offset + MAPBUF_LEN > SUPERBLOCK->fs_bsize)
118 offset = (SUPERBLOCK->fs_bsize - MAPBUF_LEN) / sizeof (int);
119 }
120 else
121 {
122 bsize = SUPERBLOCK->fs_bsize;
123 offset = 0;
124 }
125
126 if (! devread (bnum, offset * sizeof (int), bsize, (char *) MAPBUF))
127 {
128 mapblock = -1;
129 mapblock_bsize = -1;
130 mapblock_offset = -1;
131 errnum = ERR_FSYS_CORRUPT;
132 return -1;
133 }
134
135 mapblock = bnum;
136 mapblock_bsize = bsize;
137 mapblock_offset = offset;
138 }
139
140 return (((int *) MAPBUF)[((file_block - NDADDR) % NINDIR (SUPERBLOCK))
141 - mapblock_offset]);
142 }
143
144
145 int
ffs_read(char * buf,int len)146 ffs_read (char *buf, int len)
147 {
148 int logno, off, size, map, ret = 0;
149
150 while (len && !errnum)
151 {
152 off = blkoff (SUPERBLOCK, filepos);
153 logno = lblkno (SUPERBLOCK, filepos);
154 size = blksize (SUPERBLOCK, INODE, logno);
155
156 if ((map = block_map (logno)) < 0)
157 break;
158
159 size -= off;
160
161 if (size > len)
162 size = len;
163
164 disk_read_func = disk_read_hook;
165
166 devread (fsbtodb (SUPERBLOCK, map), off, size, buf);
167
168 disk_read_func = NULL;
169
170 buf += size;
171 len -= size;
172 filepos += size;
173 ret += size;
174 }
175
176 if (errnum)
177 ret = 0;
178
179 return ret;
180 }
181
182
183 int
ffs_dir(char * dirname)184 ffs_dir (char *dirname)
185 {
186 char *rest, ch;
187 int block, off, loc, map, ino = ROOTINO;
188 struct direct *dp;
189
190 /* main loop to find destination inode */
191 loop:
192
193 /* load current inode (defaults to the root inode) */
194
195 if (!devread (fsbtodb (SUPERBLOCK, itod (SUPERBLOCK, ino)),
196 ino % (SUPERBLOCK->fs_inopb) * sizeof (struct dinode),
197 sizeof (struct dinode), (char *) INODE))
198 return 0; /* XXX what return value? */
199
200 /* if we have a real file (and we're not just printing possibilities),
201 then this is where we want to exit */
202
203 if (!*dirname || isspace (*dirname))
204 {
205 if ((INODE->i_mode & IFMT) != IFREG)
206 {
207 errnum = ERR_BAD_FILETYPE;
208 return 0;
209 }
210
211 filemax = INODE->i_size;
212
213 /* incomplete implementation requires this! */
214 fsmax = (NDADDR + NINDIR (SUPERBLOCK)) * SUPERBLOCK->fs_bsize;
215 return 1;
216 }
217
218 /* continue with file/directory name interpretation */
219
220 while (*dirname == '/')
221 dirname++;
222
223 if (!(INODE->i_size) || ((INODE->i_mode & IFMT) != IFDIR))
224 {
225 errnum = ERR_BAD_FILETYPE;
226 return 0;
227 }
228
229 for (rest = dirname; (ch = *rest) && !isspace (ch) && ch != '/'; rest++);
230
231 *rest = 0;
232 loc = 0;
233
234 /* loop for reading a the entries in a directory */
235
236 do
237 {
238 if (loc >= INODE->i_size)
239 {
240 #if 0
241 putchar ('\n');
242 #endif
243
244 if (print_possibilities < 0)
245 return 1;
246
247 errnum = ERR_FILE_NOT_FOUND;
248 *rest = ch;
249 return 0;
250 }
251
252 if (!(off = blkoff (SUPERBLOCK, loc)))
253 {
254 block = lblkno (SUPERBLOCK, loc);
255
256 if ((map = block_map (block)) < 0
257 || !devread (fsbtodb (SUPERBLOCK, map), 0,
258 blksize (SUPERBLOCK, INODE, block),
259 (char *) FSYS_BUF))
260 {
261 errnum = ERR_FSYS_CORRUPT;
262 *rest = ch;
263 return 0;
264 }
265 }
266
267 dp = (struct direct *) (FSYS_BUF + off);
268 loc += dp->d_reclen;
269
270 #ifndef STAGE1_5
271 if (dp->d_ino && print_possibilities && ch != '/'
272 && (!*dirname || substring (dirname, dp->d_name) <= 0))
273 {
274 if (print_possibilities > 0)
275 print_possibilities = -print_possibilities;
276
277 print_a_completion (dp->d_name);
278 }
279 #endif /* STAGE1_5 */
280 }
281 while (!dp->d_ino || (substring (dirname, dp->d_name) != 0
282 || (print_possibilities && ch != '/')));
283
284 /* only get here if we have a matching directory entry */
285
286 ino = dp->d_ino;
287 *(dirname = rest) = ch;
288
289 /* go back to main loop at top of function */
290 goto loop;
291 }
292
293 int
ffs_embed(int * start_sector,int needed_sectors)294 ffs_embed (int *start_sector, int needed_sectors)
295 {
296 /* XXX: I don't know if this is really correct. Someone who is
297 familiar with BSD should check for this. */
298 if (needed_sectors > 14)
299 return 0;
300
301 *start_sector = 1;
302 #if 1
303 /* FIXME: Disable the embedding in FFS until someone checks if
304 the code above is correct. */
305 return 0;
306 #else
307 return 1;
308 #endif
309 }
310
311 #endif /* FSYS_FFS */
312