[a3e5d4f] | 1 | Submitted By: William Harrington <kb0iic at gmail dot com>
|
---|
| 2 | Date: 2012-09-01
|
---|
| 3 | Initial Package Version: 1.4.14
|
---|
| 4 | Upstream Status: Unknown
|
---|
| 5 | Origin: git clone https://kernel.googlesource.com/pub/scm/linux/kernel/git/davem/silo
|
---|
| 6 | Description: Fixes for current silo.1.4.14 not yet released.
|
---|
| 7 |
|
---|
[711fda6] | 8 | diff -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
|
---|
| 28 | diff -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
|
---|
| 36 | diff -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
|
---|
| 48 | diff -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)
|
---|
| 126 | diff -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 | +}
|
---|
| 229 | diff -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
|
---|
| 241 | diff -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
|
---|
| 261 | diff -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
|
---|
| 270 | diff -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 |
|
---|
| 282 | diff -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 ();
|
---|
| 302 | diff -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 *);
|
---|
| 321 | diff -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
|
---|
| 337 | diff -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
|
---|
| 358 | diff -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>
|
---|
| 369 | diff -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 | -}
|
---|
| 1120 | diff -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 |
|
---|
| 1131 | diff -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;
|
---|
| 1152 | diff -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++)
|
---|
| 1176 | diff -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
|
---|
| 1188 | diff -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"
|
---|
| 1200 | diff -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
|
---|
| 1210 | diff -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
|
---|