1 /*
2 * cramfs.c
3 *
4 * Copyright (C) 1999 Linus Torvalds
5 *
6 * Copyright (C) 2000-2002 Transmeta Corporation
7 *
8 * Copyright (C) 2003 Kai-Uwe Bloem,
9 * Auerswald GmbH & Co KG, <linux-development@auerswald.de>
10 * - adapted from the www.tuxbox.org u-boot tree, added "ls" command
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License (Version 2) as
14 * published by the Free Software Foundation.
15 *
16 * Compressed ROM filesystem for Linux.
17 *
18 * TODO:
19 * add support for resolving symbolic links
20 */
21
22 /*
23 * These are the VFS interfaces to the compressed ROM filesystem.
24 * The actual compression is based on zlib, see the other files.
25 */
26
27 #include <common.h>
28 #include <malloc.h>
29 #include <asm/byteorder.h>
30 #include <linux/stat.h>
31 #include <jffs2/jffs2.h>
32 #include <jffs2/load_kernel.h>
33 #include <cramfs/cramfs_fs.h>
34
35 /* These two macros may change in future, to provide better st_ino
36 semantics. */
37 #define CRAMINO(x) (CRAMFS_GET_OFFSET(x) ? CRAMFS_GET_OFFSET(x)<<2 : 1)
38 #define OFFSET(x) ((x)->i_ino)
39
40 struct cramfs_super super;
41
42 /* CPU address space offset calculation macro, struct part_info offset is
43 * device address space offset, so we need to shift it by a device start address. */
44 extern flash_info_t flash_info[];
45 #define PART_OFFSET(x) (x->offset + flash_info[x->dev->id->num].start[0])
46
cramfs_read_super(struct part_info * info)47 static int cramfs_read_super (struct part_info *info)
48 {
49 unsigned long root_offset;
50
51 /* Read the first block and get the superblock from it */
52 memcpy (&super, (void *) PART_OFFSET(info), sizeof (super));
53
54 /* Do sanity checks on the superblock */
55 if (super.magic != CRAMFS_32 (CRAMFS_MAGIC)) {
56 /* check at 512 byte offset */
57 memcpy (&super, (void *) PART_OFFSET(info) + 512, sizeof (super));
58 if (super.magic != CRAMFS_32 (CRAMFS_MAGIC)) {
59 printf ("cramfs: wrong magic\n");
60 return -1;
61 }
62 }
63
64 /* flags is reused several times, so swab it once */
65 super.flags = CRAMFS_32 (super.flags);
66 super.size = CRAMFS_32 (super.size);
67
68 /* get feature flags first */
69 if (super.flags & ~CRAMFS_SUPPORTED_FLAGS) {
70 printf ("cramfs: unsupported filesystem features\n");
71 return -1;
72 }
73
74 /* Check that the root inode is in a sane state */
75 if (!S_ISDIR (CRAMFS_16 (super.root.mode))) {
76 printf ("cramfs: root is not a directory\n");
77 return -1;
78 }
79 root_offset = CRAMFS_GET_OFFSET (&(super.root)) << 2;
80 if (root_offset == 0) {
81 printf ("cramfs: empty filesystem");
82 } else if (!(super.flags & CRAMFS_FLAG_SHIFTED_ROOT_OFFSET) &&
83 ((root_offset != sizeof (struct cramfs_super)) &&
84 (root_offset != 512 + sizeof (struct cramfs_super)))) {
85 printf ("cramfs: bad root offset %lu\n", root_offset);
86 return -1;
87 }
88
89 return 0;
90 }
91
cramfs_resolve(unsigned long begin,unsigned long offset,unsigned long size,int raw,char * filename)92 static unsigned long cramfs_resolve (unsigned long begin, unsigned long offset,
93 unsigned long size, int raw,
94 char *filename)
95 {
96 unsigned long inodeoffset = 0, nextoffset;
97
98 while (inodeoffset < size) {
99 struct cramfs_inode *inode;
100 char *name;
101 int namelen;
102
103 inode = (struct cramfs_inode *) (begin + offset +
104 inodeoffset);
105
106 /*
107 * Namelengths on disk are shifted by two
108 * and the name padded out to 4-byte boundaries
109 * with zeroes.
110 */
111 namelen = CRAMFS_GET_NAMELEN (inode) << 2;
112 name = (char *) inode + sizeof (struct cramfs_inode);
113
114 nextoffset =
115 inodeoffset + sizeof (struct cramfs_inode) + namelen;
116
117 for (;;) {
118 if (!namelen)
119 return -1;
120 if (name[namelen - 1])
121 break;
122 namelen--;
123 }
124
125 if (!strncmp (filename, name, namelen)) {
126 char *p = strtok (NULL, "/");
127
128 if (raw && (p == NULL || *p == '\0'))
129 return offset + inodeoffset;
130
131 if (S_ISDIR (CRAMFS_16 (inode->mode))) {
132 return cramfs_resolve (begin,
133 CRAMFS_GET_OFFSET
134 (inode) << 2,
135 CRAMFS_24 (inode->
136 size), raw,
137 p);
138 } else if (S_ISREG (CRAMFS_16 (inode->mode))) {
139 return offset + inodeoffset;
140 } else {
141 printf ("%*.*s: unsupported file type (%x)\n",
142 namelen, namelen, name,
143 CRAMFS_16 (inode->mode));
144 return 0;
145 }
146 }
147
148 inodeoffset = nextoffset;
149 }
150
151 printf ("can't find corresponding entry\n");
152 return 0;
153 }
154
cramfs_uncompress(unsigned long begin,unsigned long offset,unsigned long loadoffset)155 static int cramfs_uncompress (unsigned long begin, unsigned long offset,
156 unsigned long loadoffset)
157 {
158 struct cramfs_inode *inode = (struct cramfs_inode *) (begin + offset);
159 unsigned long *block_ptrs = (unsigned long *)
160 (begin + (CRAMFS_GET_OFFSET (inode) << 2));
161 unsigned long curr_block = (CRAMFS_GET_OFFSET (inode) +
162 (((CRAMFS_24 (inode->size)) +
163 4095) >> 12)) << 2;
164 int size, total_size = 0;
165 int i;
166
167 cramfs_uncompress_init ();
168
169 for (i = 0; i < ((CRAMFS_24 (inode->size) + 4095) >> 12); i++) {
170 size = cramfs_uncompress_block ((void *) loadoffset,
171 (void *) (begin + curr_block),
172 (CRAMFS_32 (block_ptrs[i]) -
173 curr_block));
174 if (size < 0)
175 return size;
176 loadoffset += size;
177 total_size += size;
178 curr_block = CRAMFS_32 (block_ptrs[i]);
179 }
180
181 cramfs_uncompress_exit ();
182 return total_size;
183 }
184
cramfs_load(char * loadoffset,struct part_info * info,char * filename)185 int cramfs_load (char *loadoffset, struct part_info *info, char *filename)
186 {
187 unsigned long offset;
188
189 if (cramfs_read_super (info))
190 return -1;
191
192 offset = cramfs_resolve (PART_OFFSET(info),
193 CRAMFS_GET_OFFSET (&(super.root)) << 2,
194 CRAMFS_24 (super.root.size), 0,
195 strtok (filename, "/"));
196
197 if (offset <= 0)
198 return offset;
199
200 return cramfs_uncompress (PART_OFFSET(info), offset,
201 (unsigned long) loadoffset);
202 }
203
cramfs_list_inode(struct part_info * info,unsigned long offset)204 static int cramfs_list_inode (struct part_info *info, unsigned long offset)
205 {
206 struct cramfs_inode *inode = (struct cramfs_inode *)
207 (PART_OFFSET(info) + offset);
208 char *name, str[20];
209 int namelen, nextoff;
210
211 /*
212 * Namelengths on disk are shifted by two
213 * and the name padded out to 4-byte boundaries
214 * with zeroes.
215 */
216 namelen = CRAMFS_GET_NAMELEN (inode) << 2;
217 name = (char *) inode + sizeof (struct cramfs_inode);
218 nextoff = namelen;
219
220 for (;;) {
221 if (!namelen)
222 return namelen;
223 if (name[namelen - 1])
224 break;
225 namelen--;
226 }
227
228 printf (" %s %8d %*.*s", mkmodestr (CRAMFS_16 (inode->mode), str),
229 CRAMFS_24 (inode->size), namelen, namelen, name);
230
231 if ((CRAMFS_16 (inode->mode) & S_IFMT) == S_IFLNK) {
232 /* symbolic link.
233 * Unpack the link target, trusting in the inode's size field.
234 */
235 unsigned long size = CRAMFS_24 (inode->size);
236 char *link = malloc (size);
237
238 if (link != NULL && cramfs_uncompress (PART_OFFSET(info), offset,
239 (unsigned long) link)
240 == size)
241 printf (" -> %*.*s\n", (int) size, (int) size, link);
242 else
243 printf (" [Error reading link]\n");
244 if (link)
245 free (link);
246 } else
247 printf ("\n");
248
249 return nextoff;
250 }
251
cramfs_ls(struct part_info * info,char * filename)252 int cramfs_ls (struct part_info *info, char *filename)
253 {
254 struct cramfs_inode *inode;
255 unsigned long inodeoffset = 0, nextoffset;
256 unsigned long offset, size;
257
258 if (cramfs_read_super (info))
259 return -1;
260
261 if (strlen (filename) == 0 || !strcmp (filename, "/")) {
262 /* Root directory. Use root inode in super block */
263 offset = CRAMFS_GET_OFFSET (&(super.root)) << 2;
264 size = CRAMFS_24 (super.root.size);
265 } else {
266 /* Resolve the path */
267 offset = cramfs_resolve (PART_OFFSET(info),
268 CRAMFS_GET_OFFSET (&(super.root)) <<
269 2, CRAMFS_24 (super.root.size), 1,
270 strtok (filename, "/"));
271
272 if (offset <= 0)
273 return offset;
274
275 /* Resolving was successful. Examine the inode */
276 inode = (struct cramfs_inode *) (PART_OFFSET(info) + offset);
277 if (!S_ISDIR (CRAMFS_16 (inode->mode))) {
278 /* It's not a directory - list it, and that's that */
279 return (cramfs_list_inode (info, offset) > 0);
280 }
281
282 /* It's a directory. List files within */
283 offset = CRAMFS_GET_OFFSET (inode) << 2;
284 size = CRAMFS_24 (inode->size);
285 }
286
287 /* List the given directory */
288 while (inodeoffset < size) {
289 inode = (struct cramfs_inode *) (PART_OFFSET(info) + offset +
290 inodeoffset);
291
292 nextoffset = cramfs_list_inode (info, offset + inodeoffset);
293 if (nextoffset == 0)
294 break;
295 inodeoffset += sizeof (struct cramfs_inode) + nextoffset;
296 }
297
298 return 1;
299 }
300
cramfs_info(struct part_info * info)301 int cramfs_info (struct part_info *info)
302 {
303 if (cramfs_read_super (info))
304 return 0;
305
306 printf ("size: 0x%x (%u)\n", super.size, super.size);
307
308 if (super.flags != 0) {
309 printf ("flags:\n");
310 if (super.flags & CRAMFS_FLAG_FSID_VERSION_2)
311 printf ("\tFSID version 2\n");
312 if (super.flags & CRAMFS_FLAG_SORTED_DIRS)
313 printf ("\tsorted dirs\n");
314 if (super.flags & CRAMFS_FLAG_HOLES)
315 printf ("\tholes\n");
316 if (super.flags & CRAMFS_FLAG_SHIFTED_ROOT_OFFSET)
317 printf ("\tshifted root offset\n");
318 }
319
320 printf ("fsid:\n\tcrc: 0x%x\n\tedition: 0x%x\n",
321 super.fsid.crc, super.fsid.edition);
322 printf ("name: %16s\n", super.name);
323
324 return 1;
325 }
326
cramfs_check(struct part_info * info)327 int cramfs_check (struct part_info *info)
328 {
329 struct cramfs_super *sb;
330
331 if (info->dev->id->type != MTD_DEV_TYPE_NOR)
332 return 0;
333
334 sb = (struct cramfs_super *) PART_OFFSET(info);
335 if (sb->magic != CRAMFS_32 (CRAMFS_MAGIC)) {
336 /* check at 512 byte offset */
337 sb = (struct cramfs_super *) (PART_OFFSET(info) + 512);
338 if (sb->magic != CRAMFS_32 (CRAMFS_MAGIC))
339 return 0;
340 }
341 return 1;
342 }
343