source: patches/silo-1.4.14-fixes-3.patch@ 42084fb

clfs-3.0.0-systemd clfs-3.0.0-sysvinit systemd sysvinit
Last change on this file since 42084fb was a3e5d4f, checked in by William Harrington <kb0iic@…>, 12 years ago

Add header information to silo-1.4.14-fixes-3.patch
  • Property mode set to 100644
File size: 31.0 KB
RevLine 
[a3e5d4f]1Submitted By: William Harrington <kb0iic at gmail dot com>
2Date: 2012-09-01
3Initial Package Version: 1.4.14
4Upstream Status: Unknown
5Origin: git clone https://kernel.googlesource.com/pub/scm/linux/kernel/git/davem/silo
6Description: Fixes for current silo.1.4.14 not yet released.
7
[711fda6]8diff -Naur silo-1.4.14.orig/Rules.make silo-1.4.14/Rules.make
9--- silo-1.4.14.orig/Rules.make 2008-06-12 16:39:12.000000000 +0000
10+++ silo-1.4.14/Rules.make 2012-09-01 19:14:27.000000000 +0000
11@@ -1,4 +1,4 @@
12-VERSION=1.4.14
13+VERSION=1.4.14_git20120901
14 IMGVERSION=0.99
15 SHELL=/bin/bash
16 RM=rm -f
17@@ -18,8 +18,8 @@
18 > /dev/null 2>&1; then echo "y"; else echo "n"; fi;)
19
20 CFLAGS = -Os -Wall -I. -I../include -fomit-frame-pointer \
21- -fno-strict-aliasing -DSMALL_RELOC=$(SMALL_RELOC) \
22- -DLARGE_RELOC=$(LARGE_RELOC)
23+ -fno-strict-aliasing -U_FORTIFY_SOURCE \
24+ -DSMALL_RELOC=$(SMALL_RELOC) -DLARGE_RELOC=$(LARGE_RELOC)
25
26 ifeq ($(call cc-option-yn, -fno-stack-protector),y)
27 CFLAGS += -fno-stack-protector
28diff -Naur silo-1.4.14.orig/common/.gitignore silo-1.4.14/common/.gitignore
29--- silo-1.4.14.orig/common/.gitignore 1970-01-01 00:00:00.000000000 +0000
30+++ silo-1.4.14/common/.gitignore 2012-09-01 19:05:11.000000000 +0000
31@@ -0,0 +1,4 @@
32+#
33+# Generated files
34+#
35+bin2h
36diff -Naur silo-1.4.14.orig/common/divdi3.S silo-1.4.14/common/divdi3.S
37--- silo-1.4.14.orig/common/divdi3.S 2008-06-12 16:39:12.000000000 +0000
38+++ silo-1.4.14/common/divdi3.S 2012-09-01 19:06:01.000000000 +0000
39@@ -20,6 +20,8 @@
40 .data
41 .align 8
42 .globl __clz_tab
43+ .register %g2,#scratch
44+ .register %g3,#scratch
45 __clz_tab:
46 .byte 0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5
47 .byte 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6
48diff -Naur silo-1.4.14.orig/common/malloc.c silo-1.4.14/common/malloc.c
49--- silo-1.4.14.orig/common/malloc.c 2008-06-12 16:39:12.000000000 +0000
50+++ silo-1.4.14/common/malloc.c 2012-09-01 19:05:11.000000000 +0000
51@@ -18,6 +18,8 @@
52 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
53 USA. */
54
55+#include <stringops.h>
56+
57 #ifndef MALLOC_BASE
58 extern unsigned long _start;
59 static char *malloc_ptr = ((char *)&_start) + 0x30000;
60@@ -27,6 +29,12 @@
61
62 static char *last_alloc = 0;
63
64+static char *align_ptr_to(char *ptr, unsigned long align)
65+{
66+ return (char *) ((((unsigned long) ptr) + (align - 1UL)) &
67+ ~(align - 1UL));
68+}
69+
70 void *malloc (int size)
71 {
72 char *caddr;
73@@ -34,10 +42,51 @@
74 caddr = malloc_ptr;
75 malloc_ptr += size;
76 last_alloc = caddr;
77- malloc_ptr = (char *) ((((unsigned long) malloc_ptr) + 7) & (~7));
78+ malloc_ptr = align_ptr_to(malloc_ptr, 8UL);
79 return caddr;
80 }
81
82+void *calloc (int nmemb, int memb_size)
83+{
84+ char *ret;
85+ int size;
86+
87+ if (!nmemb || !memb_size)
88+ return (void *) 0;
89+
90+ size = nmemb * memb_size;
91+ ret = malloc(size);
92+
93+ if (ret)
94+ memset(ret, 0, size);
95+
96+ return ret;
97+}
98+
99+int posix_memalign(void **memptr, unsigned long alignment, unsigned long size)
100+{
101+ char *caddr;
102+
103+ if (alignment & (alignment - 1UL))
104+ return -1;
105+ if (alignment & (sizeof(void *) - 1UL))
106+ return -1;
107+
108+ if (size == 0) {
109+ *memptr = (void *) 0;
110+ return 0;
111+ }
112+
113+ caddr = align_ptr_to(malloc_ptr, alignment);
114+ malloc_ptr = (caddr + size);
115+ last_alloc = caddr;
116+ malloc_ptr = align_ptr_to(malloc_ptr, 8UL);
117+
118+ *memptr = caddr;
119+
120+ return 0;
121+}
122+
123 void free (void *m)
124 {
125 if (m == last_alloc)
126diff -Naur silo-1.4.14.orig/common/printf.c silo-1.4.14/common/printf.c
127--- silo-1.4.14.orig/common/printf.c 2008-06-12 16:39:12.000000000 +0000
128+++ silo-1.4.14/common/printf.c 2012-09-01 19:05:11.000000000 +0000
129@@ -21,6 +21,7 @@
130 USA. */
131
132 #include "promlib.h"
133+#include <stringops.h>
134
135 /*
136 * This part is rewritten by Igor Timkin <ivt@msu.su>. Than I
137@@ -147,3 +148,91 @@
138 vprintf (fmt, x1);
139 va_end (x1);
140 }
141+
142+static int sprintn (char *str, long long n, int b)
143+{
144+ static char prbuf[33];
145+ register char *cp;
146+ int count = 0;
147+
148+ if (b == 10 && n < 0) {
149+ memset (str + count, '-', 1);
150+ count++;
151+ n = -n;
152+ }
153+ cp = prbuf;
154+ do
155+ *cp++ = "0123456789ABCDEF"[(unsigned int) (((unsigned long)n) % b)];
156+ while ((n = ((unsigned long long)n) / b & 0x0FFFFFFFFFFFFFFFULL));
157+ do {
158+ memset (str + count, *--cp, 1);
159+ count++;
160+ } while (cp > prbuf);
161+
162+ return count;
163+}
164+
165+int vsprintf (char *str, char *fmt, va_list adx)
166+{
167+ register int c;
168+ char *s;
169+ int count = 0;
170+
171+ for (;;) {
172+ while ((c = *fmt++) != '%') {
173+ memset (str + count, c, 1);
174+ if (c == '\0') {
175+ return count;
176+ }
177+ }
178+ c = *fmt++;
179+ if (c == 'd' || c == 'o' || c == 'x' || c == 'X') {
180+ count += sprintn (str + count, (long long) va_arg (adx, unsigned),
181+ c == 'o' ? 8 : (c == 'd' ? 10 : 16));
182+ } else if (c == 'c') {
183+ memset (str + count, va_arg (adx, unsigned), 1);
184+ count++;
185+ } else if (c == 's') {
186+ if ((s = va_arg (adx, char *)) == NULL)
187+ s = (char *)"(null)";
188+ while ((c = *s++)) {
189+ memset (str + count, c, 1);
190+ count++;
191+ }
192+ } else if (c == 'l' || c == 'O') {
193+ count += sprintn (str + count, (long long) va_arg (adx, long), c == 'l' ? 10 : 8);
194+ } else if (c == 'L') {
195+ int hex = 0;
196+ if (*fmt == 'x') {
197+ fmt++;
198+ hex = 1;
199+ }
200+ count += sprintn (str + count, (long long) va_arg (adx, long long), hex ? 16 : 10);
201+ } else {
202+ /* This is basically what libc's printf does */
203+ memset (str + count, '%', 1);
204+ count++;
205+ memset (str + count, c, 1);
206+ count++;
207+ }
208+ }
209+
210+ return count;
211+}
212+
213+/*
214+ * Scaled down version of C Library sprintf.
215+ * Only %c %s %d (==%u) %o %x %X %l %O are recognized.
216+ */
217+
218+int sprintf (char *s, char *format, ...)
219+{
220+ va_list arg;
221+ int done;
222+
223+ va_start (arg, format);
224+ done = vsprintf (s, format, arg);
225+ va_end (arg);
226+
227+ return done;
228+}
229diff -Naur silo-1.4.14.orig/common/udivdi3.S silo-1.4.14/common/udivdi3.S
230--- silo-1.4.14.orig/common/udivdi3.S 2008-06-12 16:39:12.000000000 +0000
231+++ silo-1.4.14/common/udivdi3.S 2012-09-01 19:09:16.000000000 +0000
232@@ -20,6 +20,8 @@
233 .text
234 .align 4
235 .globl __udivdi3
236+ .register %g2,#scratch
237+ .register %g3,#scratch
238 __udivdi3:
239 save %sp,-104,%sp
240 mov %i3,%o3
241diff -Naur silo-1.4.14.orig/first/.gitignore silo-1.4.14/first/.gitignore
242--- silo-1.4.14.orig/first/.gitignore 1970-01-01 00:00:00.000000000 +0000
243+++ silo-1.4.14/first/.gitignore 2012-09-01 19:05:11.000000000 +0000
244@@ -0,0 +1,16 @@
245+#
246+# Generated files
247+#
248+fd
249+fd.b
250+fd.h
251+first
252+first.b
253+first.h
254+generic
255+generic.b
256+generic.h
257+ieee32.b
258+ultra
259+ultra.b
260+ultra.h
261diff -Naur silo-1.4.14.orig/first-isofs/.gitignore silo-1.4.14/first-isofs/.gitignore
262--- silo-1.4.14.orig/first-isofs/.gitignore 1970-01-01 00:00:00.000000000 +0000
263+++ silo-1.4.14/first-isofs/.gitignore 2012-09-01 19:05:11.000000000 +0000
264@@ -0,0 +1,5 @@
265+#
266+# Generated files
267+#
268+isofs
269+isofs.b
270diff -Naur silo-1.4.14.orig/include/ext2fs/ext2fs.h silo-1.4.14/include/ext2fs/ext2fs.h
271--- silo-1.4.14.orig/include/ext2fs/ext2fs.h 2008-06-12 16:39:12.000000000 +0000
272+++ silo-1.4.14/include/ext2fs/ext2fs.h 2012-09-01 19:05:11.000000000 +0000
273@@ -39,7 +39,7 @@
274 */
275 #define EXT2_LIB_CURRENT_REV 0
276
277-#ifdef HAVE_SYS_TYPES_H
278+#if defined(HAVE_SYS_TYPES_H)
279 #include <sys/types.h>
280 #endif
281
282diff -Naur silo-1.4.14.orig/include/silo.h silo-1.4.14/include/silo.h
283--- silo-1.4.14.orig/include/silo.h 2008-06-12 16:39:12.000000000 +0000
284+++ silo-1.4.14/include/silo.h 2012-09-01 19:05:11.000000000 +0000
285@@ -87,6 +87,8 @@
286 void silo_disk_close(void);
287 /* printf.c */
288 int vprintf (char *, va_list);
289+int vsprintf (char *str, char *fmt, va_list adx);
290+int sprintf (char *s, char *format, ...);
291 int putchar (int);
292 /* malloc.c */
293 void *malloc (int);
294@@ -123,6 +125,7 @@
295 int decompress (char *, char *, unsigned char (*)(void), void (*)(void));
296 /* main.c */
297 extern enum arch architecture;
298+extern int sun4v_cpu;
299 /* timer.c */
300 int init_timer ();
301 void close_timer ();
302diff -Naur silo-1.4.14.orig/include/stringops.h silo-1.4.14/include/stringops.h
303--- silo-1.4.14.orig/include/stringops.h 2008-06-12 16:39:12.000000000 +0000
304+++ silo-1.4.14/include/stringops.h 2012-09-01 19:05:11.000000000 +0000
305@@ -2,14 +2,13 @@
306 #define __STRINGOPS_H
307
308 #include <silo.h>
309+#include <stddef.h>
310
311 /* common */
312 #ifndef __SIZE_TYPE__
313 #define __SIZE_TYPE__ long unsigned int
314 #endif
315-#ifndef _LINUX_TYPES_H
316 typedef __SIZE_TYPE__ size_t;
317-#endif
318
319 /* stringops1.c */
320 char *strcpy(char *, const char *);
321diff -Naur silo-1.4.14.orig/second/.gitignore silo-1.4.14/second/.gitignore
322--- silo-1.4.14.orig/second/.gitignore 1970-01-01 00:00:00.000000000 +0000
323+++ silo-1.4.14/second/.gitignore 2012-09-01 19:05:11.000000000 +0000
324@@ -0,0 +1,12 @@
325+#
326+# Generated files
327+#
328+second
329+second.b
330+second.b2
331+second2
332+silotftp
333+silotftp.b
334+silotftp.b2
335+silotftp2
336+util
337diff -Naur silo-1.4.14.orig/second/Makefile silo-1.4.14/second/Makefile
338--- silo-1.4.14.orig/second/Makefile 2008-06-12 16:39:12.000000000 +0000
339+++ silo-1.4.14/second/Makefile 2012-09-01 19:05:11.000000000 +0000
340@@ -58,13 +58,13 @@
341 $(AR) rc $@ $(FS_OBJS)
342
343 second: $(OBJS) mark.o
344- $(LD) $(LDFLAGS_SMALL) -Bstatic -o second $(OBJS) -lext2fs mark.o
345- $(LD) $(LDFLAGS_LARGE) -Bstatic -o second2 $(OBJS) -lext2fs mark.o
346+ $(LD) $(LDFLAGS_SMALL) -Bstatic -o second $(OBJS) mark.o `$(CC) -print-libgcc-file-name`
347+ $(LD) $(LDFLAGS_LARGE) -Bstatic -o second2 $(OBJS) mark.o `$(CC) -print-libgcc-file-name`
348 $(NM) second | grep -v '*ABS*' | sort > second.map
349
350 silotftp: $(OBJSNET) mark.o
351- $(LD) $(LDFLAGS_SMALL) -Bstatic -o silotftp $(OBJSNET) -lext2fs mark.o
352- $(LD) $(LDFLAGS_LARGE) -Bstatic -o silotftp2 $(OBJSNET) -lext2fs mark.o
353+ $(LD) $(LDFLAGS_SMALL) -Bstatic -o silotftp $(OBJSNET) mark.o `$(CC) -print-libgcc-file-name`
354+ $(LD) $(LDFLAGS_LARGE) -Bstatic -o silotftp2 $(OBJSNET) mark.o `$(CC) -print-libgcc-file-name`
355 $(NM) silotftp | grep -v '*ABS*' | sort > silotftp.map
356
357 second.l: second
358diff -Naur silo-1.4.14.orig/second/file.c silo-1.4.14/second/file.c
359--- silo-1.4.14.orig/second/file.c 2008-06-12 16:39:12.000000000 +0000
360+++ silo-1.4.14/second/file.c 2012-09-01 19:05:11.000000000 +0000
361@@ -19,6 +19,7 @@
362 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
363 USA. */
364
365+#include <sys/types.h>
366 #include <silo.h>
367 #include <file.h>
368 #include <stringops.h>
369diff -Naur silo-1.4.14.orig/second/fs/ext2.c silo-1.4.14/second/fs/ext2.c
370--- silo-1.4.14.orig/second/fs/ext2.c 2008-06-12 16:39:12.000000000 +0000
371+++ silo-1.4.14/second/fs/ext2.c 2012-09-01 19:05:11.000000000 +0000
372@@ -3,6 +3,7 @@
373 Copyright (C) 1996 Maurizio Plaza
374 1996,1997,1999 Jakub Jelinek
375 2001 Ben Collins
376+ 2012 David S. Miller
377
378 This program is free software; you can redistribute it and/or modify
379 it under the terms of the GNU General Public License as published by
380@@ -27,118 +28,654 @@
381 static ino_t inode = 0;
382 struct fs_ops ext2_fs_ops;
383
384-void com_err (const char *a, long i, const char *fmt,...)
385+#define EXT2_SUPER_MAGIC 0xEF53
386+
387+static __u32 ext2_to_cpu_32(__u32 v)
388 {
389- printf ((char *) fmt);
390+ const __u8 *p = (const __u8 *) &v;
391+
392+ return ((__u32)p[3] << 24 |
393+ (__u32)p[2] << 16 |
394+ (__u32)p[1] << 8 |
395+ (__u32)p[0]);
396 }
397
398-static void ext2fs_error (int errcode)
399+static __u16 ext2_to_cpu_16(__u16 v)
400 {
401-#if 0
402- int i;
403- for (i = 0; i < sizeof (ext2errors) / sizeof (ext2errors[0]); i++)
404- if (ext2errors[i].errnum == errcode) {
405- printf ("%s", ext2errors [i].desc);
406- return;
407- }
408-#endif
409- printf ("Unknown ext2 error: %d", errcode);
410+ const __u8 *p = (const __u8 *) &v;
411+
412+ return ((__u16)p[1] << 8) | ((__u16)p[0]);
413 }
414
415-static int open_ext2 (char *device)
416+struct silo_ext2_state {
417+ struct ext2_super_block *super;
418+
419+ void *scratch_block[4];
420+ __u32 scratch_block_blk[4];
421+
422+ __u32 inode_size;
423+ __u32 block_size;
424+ __u32 addr_per_block;
425+ __u32 addr_per_block_bits;
426+ __u32 desc_per_block;
427+ __u32 desc_per_block_bits;
428+};
429+static struct silo_ext2_state *sstate;
430+
431+static __u32 ext2_inode_size(struct silo_ext2_state *s)
432 {
433- int retval;
434+ __u32 rev = ext2_to_cpu_32(s->super->s_rev_level);
435
436- retval = ext2fs_open (device, EXT2_FLAG_DIRTY, 0, 0, silo_io_manager, &fs);
437- if (retval == EXT2_ET_BAD_MAGIC)
438- return 0;
439- if (retval) {
440- printf ("\n");
441- ext2fs_error (retval);
442- printf ("\n");
443- return 0;
444- }
445- root = EXT2_ROOT_INO;
446- return 1;
447+ if (rev == 0)
448+ return 128;
449+
450+ return ext2_to_cpu_16(s->super->s_inode_size);
451 }
452
453-static int dump_block_ext2 (ext2_filsys fs, blk_t *blocknr,
454- int blockcnt, void *private)
455+static __u32 ext2_block_size(struct silo_ext2_state *s)
456 {
457- return dump_block(blocknr, blockcnt);
458+ __u32 x = ext2_to_cpu_32(s->super->s_log_block_size);
459+
460+ x += 1;
461+
462+ return ((__u32) 1 << x) * 512;
463 }
464
465-static int dump_ext2 (void)
466+static void read_scratch_block(struct silo_ext2_state *s, __u32 block, int N)
467 {
468- if (ext2fs_block_iterate (fs, inode, 0, 0, dump_block_ext2, 0))
469+ if (s->scratch_block_blk[N] == block)
470+ return;
471+ io_channel_read_blk(fs->io, block, 1, s->scratch_block[N]);
472+ s->scratch_block_blk[N] = block;
473+}
474+
475+static void read_data(struct silo_ext2_state *s, __u32 block, __u32 off, __u32 len, void *buf)
476+{
477+ read_scratch_block(s, block, 0);
478+ memcpy(buf, s->scratch_block[0] + off, len);
479+}
480+
481+static int has_extents(struct ext2_inode *ip)
482+{
483+ if (ext2_to_cpu_32(ip->i_flags) & 0x80000)
484+ return 1;
485 return 0;
486+}
487+
488+#define EXT4_EXT_MAGIC 0xf30a
489+
490+struct ext4_extent_header {
491+ __u16 eh_magic;
492+ __u16 eh_entries;
493+ __u16 eh_max;
494+ __u16 eh_depth;
495+ __u32 eh_generation;
496+};
497+
498+struct ext4_extent_idx {
499+ __u32 ei_block;
500+ __u32 ei_leaf_lo;
501+ __u16 ei_leaf_hi;
502+ __u16 ei_unused;
503+};
504+
505+struct ext4_extent {
506+ __u32 ee_block;
507+ __u16 ee_len;
508+ __u16 ee_start_hi;
509+ __u32 ee_start_lo;
510+};
511+
512+static struct ext4_extent_header *search_leaf(struct silo_ext2_state *s,
513+ struct ext2_inode *ip,
514+ unsigned long long file_block)
515+{
516+ struct ext4_extent_header *ehp;
517+
518+ ehp = (struct ext4_extent_header *) &ip->i_block[0];
519+ for (;;) {
520+ unsigned long long ext_block, hi, lo;
521+ struct ext4_extent_idx *idxp;
522+ int i;
523+
524+ idxp = (struct ext4_extent_idx *) (ehp + 1);
525+
526+ if (ext2_to_cpu_16(ehp->eh_magic) != EXT4_EXT_MAGIC)
527+ return (struct ext4_extent_header *) 0;
528+
529+ if (ehp->eh_depth == ext2_to_cpu_16(0))
530+ return ehp;
531+
532+ for (i = 0; i < ext2_to_cpu_16(ehp->eh_entries); i++, idxp++)
533+ if (file_block < ext2_to_cpu_32(idxp->ei_block))
534+ break;
535+
536+ if (i == 0)
537+ return (struct ext4_extent_header *) 0;
538+
539+ idxp -= 1;
540+
541+ hi = ((unsigned long long)ext2_to_cpu_16(idxp->ei_leaf_hi)) << 32;
542+ lo = ext2_to_cpu_32(idxp->ei_leaf_lo);
543+ ext_block = hi | lo;
544+
545+ read_scratch_block(s, ext_block, 0);
546+ ehp = (struct ext4_extent_header *) s->scratch_block[0];
547+ }
548+}
549+
550+#define BLOCK_MAP_ERROR (~0ULL)
551+
552+static int block_to_path(struct silo_ext2_state *s, struct ext2_inode *ip,
553+ int offsets[4], long file_block)
554+{
555+ int ptrs_bits = s->addr_per_block_bits;
556+ int ptrs = s->addr_per_block;
557+ const long direct_blocks = EXT2_NDIR_BLOCKS,
558+ indirect_blocks = ptrs,
559+ double_blocks = (1 << (ptrs_bits * 2));
560+ int n = 0;
561+
562+ if (file_block < 0) {
563+ printf("EXT2: Illegal file block %ld\n", file_block);
564+ } else if (file_block < direct_blocks) {
565+ offsets[n++] = file_block;
566+ } else if ((file_block -= direct_blocks) < indirect_blocks) {
567+ offsets[n++] = EXT2_IND_BLOCK;
568+ offsets[n++] = file_block;
569+ } else if ((file_block -= indirect_blocks) < double_blocks) {
570+ offsets[n++] = EXT2_DIND_BLOCK;
571+ offsets[n++] = file_block >> ptrs_bits;
572+ offsets[n++] = file_block & (ptrs - 1);
573+ } else if (((file_block -= double_blocks) >> (ptrs_bits * 2)) < ptrs) {
574+ offsets[n++] = EXT2_TIND_BLOCK;
575+ offsets[n++] = file_block >> (ptrs_bits * 2);
576+ offsets[n++] = (file_block >> ptrs_bits) & (ptrs - 1);
577+ offsets[n++] = file_block & (ptrs - 1);
578+ } else {
579+ printf("EXT2: File block %ld is too big\n", file_block);
580+ }
581+
582+ return n;
583+}
584+
585+static unsigned long long resolve_path(struct silo_ext2_state *s,
586+ struct ext2_inode *ip,
587+ int *offsets, int depth)
588+{
589+ __u32 *p = ip->i_block + *offsets;
590+
591+ while (--depth) {
592+ __u32 block = ext2_to_cpu_32(*p);
593+
594+ read_scratch_block(s, block, depth);
595+ p = (__u32 *) s->scratch_block[depth] + *++offsets;
596+ }
597+
598+ return ext2_to_cpu_32(*p);
599+}
600+
601+static unsigned long long resolve_extent(struct silo_ext2_state *s,
602+ struct ext4_extent_header *ehp,
603+ unsigned long long file_block)
604+{
605+ unsigned long long hi, lo;
606+ struct ext4_extent *ep;
607+ int i;
608+
609+ ep = (struct ext4_extent *) (ehp + 1);
610+
611+ for (i = 0; i < ext2_to_cpu_16(ehp->eh_entries); i++, ep++)
612+ if (file_block < ext2_to_cpu_32(ep->ee_block))
613+ break;
614+
615+ if (i == 0)
616+ return BLOCK_MAP_ERROR;
617+
618+ ep -= 1;
619+ file_block -= ext2_to_cpu_32(ep->ee_block);
620+ if (file_block >= ext2_to_cpu_16(ep->ee_len))
621+ return BLOCK_MAP_ERROR;
622
623- return dump_finish ();
624+ hi = ((unsigned long long)ext2_to_cpu_16(ep->ee_start_hi)) << 32;
625+ lo = ext2_to_cpu_32(ep->ee_start_lo);
626+
627+ return (hi | lo) + file_block;
628 }
629
630-static int ls_ext2_proc(struct ext2_dir_entry *dirent, int offset,
631- int blocksize, char *buf, void *private)
632+static unsigned long long file_to_disk_block(struct silo_ext2_state *s,
633+ struct ext2_inode *ip,
634+ unsigned long long file_block)
635 {
636- struct ext2_inode ino;
637- int sl = 0, name_len = dirent->name_len & 0xFF;
638- char name[256], symlink[256];
639+ if (has_extents(ip)) {
640+ struct ext4_extent_header *ehp = search_leaf(s, ip, file_block);
641
642- strncpy(name, dirent->name, name_len);
643- name[name_len] = 0;
644+ if (ehp)
645+ return resolve_extent(s, ehp, file_block);
646
647- if (ext2fs_read_inode(fs, dirent->inode, &ino))
648- strcpy (name, "--- error ---");
649+ printf("EXT2: Extent leaf search for block %d failed\n",
650+ (int) file_block);
651
652- if (LINUX_S_ISLNK (ino.i_mode)) {
653- sl = 1;
654- if (ext2fs_inode_data_blocks(fs, &ino)) {
655- if (io_channel_read_blk(fs->io, ino.i_block[0], 1, symlink))
656- ino.i_size = 0;
657+ return BLOCK_MAP_ERROR;
658 } else {
659- strncpy (symlink, (char *)&(ino.i_block[0]),ino.i_size);
660+ int depth, offsets[4];
661+
662+ depth = block_to_path(s, ip, offsets, file_block);
663+ if (depth)
664+ return resolve_path(s, ip, offsets, depth);
665+
666+ printf("EXT2: block --> path on block %d failed\n",
667+ (int) file_block);
668+
669+ return BLOCK_MAP_ERROR;
670+ }
671+}
672+
673+static void read_file(struct silo_ext2_state *s, struct ext2_inode *ip,
674+ __u32 off, __u32 len, void *buf)
675+{
676+ unsigned long long disk_block;
677+
678+ disk_block = file_to_disk_block(s, ip, off / s->block_size);
679+
680+ read_scratch_block(s, disk_block, 0);
681+ memcpy(buf, s->scratch_block[0] + (off % s->block_size), len);
682+}
683+
684+static void read_group(struct silo_ext2_state *s, __u32 grp_no,
685+ struct ext2_group_desc *grp)
686+{
687+ __u32 first = ext2_to_cpu_32(s->super->s_first_data_block);
688+ __u32 blk, offset;
689+
690+ blk = first + 1 + (grp_no >> s->desc_per_block_bits);
691+ offset = (grp_no & (s->desc_per_block - 1)) * sizeof(*grp);
692+
693+ read_data(s, blk, offset, sizeof(*grp), grp);
694+}
695+
696+static void read_inode(struct silo_ext2_state *s, __u32 ino, struct ext2_inode *ip)
697+{
698+ __u32 grp_no, blk_no, inode_in_block, ipg, ipb;
699+ struct ext2_super_block *sb = s->super;
700+ struct ext2_group_desc gd;
701+
702+ ipg = ext2_to_cpu_32(sb->s_inodes_per_group);
703+
704+ grp_no = (ino - 1) / ipg;
705+ read_group(s, grp_no, &gd);
706+
707+ blk_no = (ino - 1) % ipg;
708+ inode_in_block = blk_no;
709+
710+ ipb = s->block_size / s->inode_size;
711+ blk_no /= ipb;
712+ inode_in_block %= ipb;
713+
714+ read_data(s,
715+ ext2_to_cpu_32(gd.bg_inode_table) + blk_no,
716+ inode_in_block * s->inode_size,
717+ sizeof(struct ext2_inode), ip);
718+}
719+
720+static int calc_ilog2(__u32 n)
721+{
722+ int i = 0;
723+
724+ while ((n >>= 1) != 0)
725+ i++;
726+
727+ return i;
728+}
729+
730+static int open_ext2(char *device)
731+{
732+ struct silo_ext2_state *s = malloc(sizeof(*s));
733+ struct ext2_super_block *sb;
734+ int err, i;
735+
736+ if (!s) {
737+ printf("Cannot allocate silo_ext2_state\n");
738+ return 0;
739+ }
740+ memset(s, 0, sizeof(*s));
741+
742+ fs = malloc(sizeof(*fs));
743+ if (!fs) {
744+ printf("Cannot allocate ext2_filsys\n");
745+ goto out_free_s;
746+ }
747+ memset(fs, 0, sizeof(*fs));
748+ err = silo_io_manager->open(device, 0, &fs->io);
749+ if (err) {
750+ printf("I/O manager open failed (err=%d)\n", err);
751+ goto out_free_fs;
752+ }
753+ fs->io->app_data = fs;
754+
755+ sb = s->super = malloc(1024);
756+ if (!sb) {
757+ printf("Cannot allocate ext2 super block\n");
758+ goto out_free_fs;
759+ }
760+
761+ io_channel_set_blksize(fs->io, 1024);
762+ err = io_channel_read_blk(fs->io, 1, -1024, sb);
763+
764+ if (ext2_to_cpu_16(sb->s_magic) != EXT2_SUPER_MAGIC) {
765+ printf("EXT2 superblock magic is wrong\n");
766+ goto out_free_super;
767+ }
768+
769+ s->inode_size = ext2_inode_size(s);
770+ s->block_size = ext2_block_size(s);
771+
772+ io_channel_set_blksize(fs->io, s->block_size);
773+
774+ s->addr_per_block = s->block_size / sizeof(__u32);
775+ s->addr_per_block_bits = calc_ilog2(s->addr_per_block);
776+ s->desc_per_block = s->block_size / sizeof(struct ext2_group_desc);
777+ s->desc_per_block_bits = calc_ilog2(s->desc_per_block);
778+
779+ s->scratch_block[0] = malloc(s->block_size * 4);
780+ if (!s->scratch_block[0]) {
781+ printf("Cannot allocate ext2 scratch blocks\n");
782+ goto out_free_super;
783+ }
784+ for (i = 1; i < 4; i++)
785+ s->scratch_block[i] =
786+ s->scratch_block[i - 1] + s->block_size;
787+ for (i = 0; i < 4; i++)
788+ s->scratch_block_blk[i] = ~(__u32)0;
789+
790+ root = EXT2_ROOT_INO;
791+
792+ sstate = s;
793+
794+ return 1;
795+
796+out_free_super:
797+ free(s->super);
798+
799+out_free_fs:
800+ free(fs);
801+ fs = NULL;
802+
803+out_free_s:
804+ free(s);
805+ return 0;
806+}
807+
808+void close_ext2 (void)
809+{
810+ struct silo_ext2_state *s = sstate;
811+
812+ if (s) {
813+ free(s->scratch_block[0]);
814+ free(s->super);
815+ free(s);
816+
817+ sstate = (struct silo_ext2_state *) 0;
818 }
819- symlink[ino.i_size] = 0;
820- }
821+}
822+
823+static int dump_ext2 (void)
824+{
825+ struct silo_ext2_state *s = sstate;
826+ struct ext2_inode ei;
827+ long file_offset;
828+ int sz, blk_sz;
829+ int blk_cnt;
830+
831+ read_inode(s, inode, &ei);
832+
833+ sz = ext2_to_cpu_32(ei.i_size);
834+ blk_sz = s->block_size;
835+
836+ blk_cnt = 0;
837+ for (file_offset = 0; file_offset < sz; file_offset += blk_sz) {
838+ blk_t disk_block;
839+
840+ disk_block = file_to_disk_block(s, &ei,
841+ file_offset / blk_sz);
842+ if (disk_block == BLOCK_MAP_ERROR)
843+ return 0;
844+
845+ if (disk_block)
846+ dump_block(&disk_block, blk_cnt);
847+
848+ blk_cnt++;
849+ }
850+
851+ return dump_finish ();
852+}
853+
854+static char *read_symlink(struct silo_ext2_state *s, struct ext2_inode *ip, char *namebuf)
855+{
856+ __u32 isize = ext2_to_cpu_32(ip->i_size);
857+
858+ if (isize <= 60)
859+ return (char *) &ip->i_block[0];
860+
861+ read_data(s, ext2_to_cpu_32(ip->i_block[0]), 0, isize, namebuf);
862+
863+ return namebuf;
864+}
865+
866+static int is_symlink(__u16 mode)
867+{
868+ if ((mode & 0xf000) == 0xa000)
869+ return 1;
870+ return 0;
871+}
872+
873+typedef int (*dir_callback_t)(struct silo_ext2_state *, struct ext2_dir_entry_2 *, void *);
874+
875+static int ls_callback(struct silo_ext2_state *s, struct ext2_dir_entry_2 *dirent, void *priv_data)
876+{
877+ struct ext2_inode e_ino;
878+ char *sym = (char *) 0;
879+ char symlink_buf[256];
880+
881+ read_inode(s, ext2_to_cpu_32(dirent->inode), &e_ino);
882+
883+ if (is_symlink(ext2_to_cpu_16(e_ino.i_mode)))
884+ sym = read_symlink(s, &e_ino, symlink_buf);
885+
886+ register_silo_inode(ext2_to_cpu_32(e_ino.i_mtime),
887+ ext2_to_cpu_32(e_ino.i_size),
888+ ext2_to_cpu_16(e_ino.i_mode),
889+ ext2_to_cpu_16(e_ino.i_uid),
890+ ext2_to_cpu_16(e_ino.i_gid),
891+ dirent->name, sym);
892+ return 0;
893+}
894+
895+static void iterate_dir(struct silo_ext2_state *s, __u32 ino, dir_callback_t cb, void *cb_arg)
896+{
897+ struct ext2_dir_entry_2 e;
898+ struct ext2_inode ei;
899+ __u32 off, size;
900
901- register_silo_inode(ino.i_mtime, ino.i_size, ino.i_mode, ino.i_uid,
902- ino.i_gid, name, sl ? symlink : NULL);
903+ read_inode(s, ino, &ei);
904+ size = ext2_to_cpu_32(ei.i_size);
905
906- return 0;
907+ for (off = 0; off < size; ) {
908+ read_file(s, &ei, off, 8, &e);
909+
910+ if (ext2_to_cpu_16(e.rec_len) == 0)
911+ break;
912+
913+ if (ext2_to_cpu_32(e.inode) == 0 ||
914+ e.name_len == 0) {
915+ off += ext2_to_cpu_16(e.rec_len);
916+ continue;
917+ }
918+
919+ read_file(s, &ei, off + 8, e.name_len, &e.name[0]);
920+ e.name[e.name_len] = 0;
921+
922+ if (cb(s, &e, cb_arg))
923+ break;
924+
925+ off += ext2_to_cpu_16(e.rec_len);
926+ }
927 }
928
929 static int ls_ext2 (void)
930 {
931- return ext2fs_dir_iterate (fs, inode, DIRENT_FLAG_INCLUDE_EMPTY,
932- 0, ls_ext2_proc, NULL);
933+ struct silo_ext2_state *s = sstate;
934+
935+ iterate_dir(s, inode, ls_callback, 0);
936+
937+ return 0;
938+}
939+
940+static int ino_size_ext2 (void)
941+{
942+ struct silo_ext2_state *s = sstate;
943+ struct ext2_inode ei = { };
944+
945+ read_inode(s, inode, &ei);
946+
947+ return ext2_to_cpu_32(ei.i_size);
948+}
949+
950+struct namei_cb_arg {
951+ const char *name;
952+ int len;
953+ ino_t *ino;
954+ int found;
955+};
956+
957+static int lookup_cb(struct silo_ext2_state *s, struct ext2_dir_entry_2 *dirent, void *priv_data)
958+{
959+ struct namei_cb_arg *p = priv_data;
960+
961+ if (p->len != dirent->name_len)
962+ return 0;
963+ if (strncmp(p->name, dirent->name, p->len))
964+ return 0;
965+ p->found = 1;
966+ *p->ino = ext2_to_cpu_32(dirent->inode);
967+ return 1;
968 }
969
970-static int ino_size_ext2 (void) {
971- struct ext2_inode ei;
972- int retval;
973+static int do_lookup(struct silo_ext2_state *s, __u32 dir_ino, const char *name,
974+ int namelen, ino_t *ret_ino)
975+{
976+ struct namei_cb_arg arg;
977+
978+ arg.name = name;
979+ arg.len = namelen;
980+ arg.ino = ret_ino;
981+ arg.found = 0;
982+
983+ iterate_dir(s, dir_ino, lookup_cb, &arg);
984
985- if ((retval = ext2fs_read_inode (fs, inode, &ei))) {
986- printf ("\n");
987- ext2fs_error (retval);
988- printf ("\n");
989+ return arg.found ? 0 : -1;
990+}
991+
992+static int open_namei(struct silo_ext2_state *s, const char *name,
993+ int namelen, ino_t root, ino_t base, ino_t *ret_ino);
994+
995+static int follow_link(struct silo_ext2_state *s, ino_t root, ino_t dir,
996+ ino_t inode, ino_t *res_inode)
997+{
998+ struct ext2_inode ei = { };
999+ char symlink_buf[256];
1000+ char *sym;
1001+
1002+ read_inode(s, inode, &ei);
1003+ if (!is_symlink(ext2_to_cpu_16(ei.i_mode))) {
1004+ *res_inode = inode;
1005+ return 0;
1006+ }
1007+ sym = read_symlink(s, &ei, symlink_buf);
1008+ return open_namei(s, sym, ext2_to_cpu_32(ei.i_size), root, dir, res_inode);
1009+}
1010+
1011+static int dir_namei(struct silo_ext2_state *s, ino_t root, ino_t dir,
1012+ const char *pathname, int pathlen,
1013+ const char **name, int *namelen,
1014+ ino_t *res_inode)
1015+{
1016+ const char *thisname;
1017+ int len, retval;
1018+ ino_t inode;
1019+ char c;
1020+
1021+ if ((c = *pathname) == '/') {
1022+ dir = root;
1023+ pathname++;
1024+ pathlen--;
1025+ }
1026+ while (1) {
1027+ thisname = pathname;
1028+ for (len = 0; --pathlen >= 0; len++) {
1029+ c = *pathname++;
1030+ if (c == '/')
1031+ break;
1032+ }
1033+ if (pathlen < 0)
1034+ break;
1035+ retval = do_lookup(s, dir, thisname, len, &inode);
1036+ if (retval)
1037+ return retval;
1038+ retval = follow_link(s, root, dir, inode, &dir);
1039+ if (retval)
1040+ return retval;
1041+ }
1042+ *name = thisname;
1043+ *namelen = len;
1044+ *res_inode = dir;
1045 return 0;
1046- }
1047- return ei.i_size;
1048 }
1049
1050-static int namei_follow_ext2 (const char *filename) {
1051- int ret = ext2fs_namei_follow (fs, root, root, filename, &inode);
1052+static int open_namei(struct silo_ext2_state *s, const char *name,
1053+ int namelen, ino_t root, ino_t base, ino_t *ret_ino)
1054+{
1055+ const char *base_name;
1056+ ino_t dir_ino, inode;
1057+ int ret;
1058+
1059+ ret = dir_namei(s, root, base, name, namelen,
1060+ &base_name, &namelen, &dir_ino);
1061+ if (ret)
1062+ return ret;
1063+
1064+ if (!namelen) {
1065+ *ret_ino = dir_ino;
1066+ return 0;
1067+ }
1068
1069- ext2_fs_ops.have_inode = (inode) ? 1 : 0;
1070+ ret = do_lookup(s, dir_ino, base_name, namelen, &inode);
1071+ if (ret)
1072+ return ret;
1073+
1074+ ret = follow_link(s, root, dir_ino, inode, &inode);
1075+ if (ret)
1076+ return ret;
1077
1078- return ret;
1079+ *ret_ino = inode;
1080+ return 0;
1081 }
1082
1083-static void print_error_ext2 (int error_val) {
1084- ext2fs_error (error_val);
1085+static int namei_follow_ext2 (const char *filename)
1086+{
1087+ int ret;
1088+
1089+ ret = open_namei(sstate, filename, strlen(filename),
1090+ root, root, &inode);
1091+
1092+ ext2_fs_ops.have_inode = inode ? 1 : 0;
1093+
1094+ return ret;
1095 }
1096
1097-void close_ext2 (void) {
1098- ext2fs_close(fs);
1099+static void print_error_ext2 (int error_val)
1100+{
1101+ printf("error: %d", error_val);
1102 }
1103
1104 struct fs_ops ext2_fs_ops = {
1105@@ -152,14 +689,3 @@
1106 .namei_follow = namei_follow_ext2,
1107 .have_inode = 0,
1108 };
1109-
1110-/* These are silly stubs to satisfy libext2fs symbols */
1111-unsigned long time(void)
1112-{
1113- return 0;
1114-}
1115-
1116-void *realloc(void *p, int size)
1117-{
1118- return NULL;
1119-}
1120diff -Naur silo-1.4.14.orig/second/ls.c silo-1.4.14/second/ls.c
1121--- silo-1.4.14.orig/second/ls.c 2008-06-12 16:39:12.000000000 +0000
1122+++ silo-1.4.14/second/ls.c 2012-09-01 19:05:11.000000000 +0000
1123@@ -18,6 +18,7 @@
1124 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
1125 USA. */
1126
1127+#include <sys/types.h>
1128 #include <silo.h>
1129 #include <stringops.h>
1130
1131diff -Naur silo-1.4.14.orig/second/main.c silo-1.4.14/second/main.c
1132--- silo-1.4.14.orig/second/main.c 2008-06-12 16:39:12.000000000 +0000
1133+++ silo-1.4.14/second/main.c 2012-09-01 19:05:11.000000000 +0000
1134@@ -25,8 +25,7 @@
1135 /* TODO: This file is a good candidate for rewrite from scratch. */
1136
1137 #include <silo.h>
1138-#include <asm/page.h>
1139-#include <linux/elf.h>
1140+#include <elf.h>
1141 #include <stringops.h>
1142
1143 #ifndef NULL
1144@@ -65,6 +64,7 @@
1145 CMD_LS
1146 } load_cmd;
1147 enum arch architecture;
1148+int sun4v_cpu;
1149 static int timer_status = 0;
1150 static char *initrd_start;
1151 static int initrd_size;
1152diff -Naur silo-1.4.14.orig/second/misc.c silo-1.4.14/second/misc.c
1153--- silo-1.4.14.orig/second/misc.c 2008-06-12 16:39:12.000000000 +0000
1154+++ silo-1.4.14/second/misc.c 2012-09-01 19:05:11.000000000 +0000
1155@@ -501,7 +501,7 @@
1156 if ((i = prom_searchsiblings(i, "MicroSPARC-IIep")) != 0) {
1157 return sun4p;
1158 }
1159- return sun4u;
1160+ buffer[4] = 'u';
1161 }
1162 i = prom_getproperty (prom_root_node, "compatability", buffer, 8);
1163
1164@@ -517,8 +517,10 @@
1165 return sun4d;
1166 case 'e':
1167 return sun4e;
1168- case 'u':
1169 case 'v':
1170+ sun4v_cpu = 1;
1171+ /* FALLTHRU */
1172+ case 'u':
1173 return sun4u;
1174 default:
1175 for(i = 0; i < NUM_SUN_MACHINES; i++)
1176diff -Naur silo-1.4.14.orig/second/muldi3.S silo-1.4.14/second/muldi3.S
1177--- silo-1.4.14.orig/second/muldi3.S 2008-06-12 16:39:12.000000000 +0000
1178+++ silo-1.4.14/second/muldi3.S 2012-09-01 19:11:45.000000000 +0000
1179@@ -20,6 +20,8 @@
1180 .text
1181 .align 4
1182 .globl __muldi3
1183+ .register %g2,#scratch
1184+ .register %g3,#scratch
1185 __muldi3:
1186 save %sp, -104, %sp
1187 wr %g0, %i1, %y
1188diff -Naur silo-1.4.14.orig/second/timer.c silo-1.4.14/second/timer.c
1189--- silo-1.4.14.orig/second/timer.c 2008-06-12 16:39:12.000000000 +0000
1190+++ silo-1.4.14/second/timer.c 2012-09-01 19:05:11.000000000 +0000
1191@@ -156,7 +156,7 @@
1192 }
1193 if (!foundcpu || !clock_frequency)
1194 clock_frequency = prom_getint(prom_root_node, "clock-frequency") / 100;
1195- if (notimer) {
1196+ if (notimer && !sun4v_cpu) {
1197 sun4u_notimer = 1;
1198 __asm__ __volatile__ ("\t"
1199 "rd %%tick_cmpr, %%g1\n\t"
1200diff -Naur silo-1.4.14.orig/silo/.gitignore silo-1.4.14/silo/.gitignore
1201--- silo-1.4.14.orig/silo/.gitignore 1970-01-01 00:00:00.000000000 +0000
1202+++ silo-1.4.14/silo/.gitignore 2012-09-01 19:05:11.000000000 +0000
1203@@ -0,0 +1,6 @@
1204+#
1205+# Generated files
1206+#
1207+floppy.h
1208+silo
1209+silocheck
1210diff -Naur silo-1.4.14.orig/tilo/.gitignore silo-1.4.14/tilo/.gitignore
1211--- silo-1.4.14.orig/tilo/.gitignore 1970-01-01 00:00:00.000000000 +0000
1212+++ silo-1.4.14/tilo/.gitignore 2012-09-01 19:05:11.000000000 +0000
1213@@ -0,0 +1,10 @@
1214+#
1215+# Generated files
1216+#
1217+b.h
1218+b.out
1219+b2.h
1220+b2.out
1221+boot
1222+boot2
1223+maketilo
Note: See TracBrowser for help on using the repository browser.