qi-hardware/openwrt-xburst
1
0
Fork 0
mirror of git://projects.qi-hardware.com/openwrt-xburst.git synced 2024-11-29 07:31:54 +02:00
Code
4cd0737e57
openwrt-xburst/target/linux/xburst/files-2.6.27/drivers/mtd/mtd-utils/jffs-dump.c
Mirko Vogt dc3d3f1c49 yet another patchset - 2.6.27 
it's basically also provided by ingenic and nativly based on 2.6.27,
adjusted to fit into the OpenWrt-environment
2009-10-28 03:13:11 +08:00

360 lines
8.4 KiB
C
Raw Blame History

/*
* Dump JFFS filesystem.
* Useful when it buggers up.
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <unistd.h>
#include <linux/types.h>
#include <asm/byteorder.h>
#define BLOCK_SIZE 1024
#define JFFS_MAGIC 0x34383931 /* "1984" */
#define JFFS_MAX_NAME_LEN 256
#define JFFS_MIN_INO 1
#define JFFS_TRACE_INDENT 4
#define JFFS_ALIGN_SIZE 4
#define MAX_CHUNK_SIZE 32768
/* How many padding bytes should be inserted between two chunks of data
on the flash? */
#define JFFS_GET_PAD_BYTES(size) ((JFFS_ALIGN_SIZE \
- ((uint32_t)(size) % JFFS_ALIGN_SIZE)) \
% JFFS_ALIGN_SIZE)
#define JFFS_EMPTY_BITMASK 0xffffffff
#define JFFS_MAGIC_BITMASK 0x34383931
#define JFFS_DIRTY_BITMASK 0x00000000
#define min(x,y) (x) > (y) ? (y) : (x)
struct jffs_raw_inode
{
uint32_t magic; /* A constant magic number. */
uint32_t ino; /* Inode number. */
uint32_t pino; /* Parent's inode number. */
uint32_t version; /* Version number. */
uint32_t mode; /* file_type, mode */
uint16_t uid;
uint16_t gid;
uint32_t atime;
uint32_t mtime;
uint32_t ctime;
uint32_t offset; /* Where to begin to write. */
uint32_t dsize; /* Size of the file data. */
uint32_t rsize; /* How much are going to be replaced? */
uint8_t nsize; /* Name length. */
uint8_t nlink; /* Number of links. */
uint8_t spare : 6; /* For future use. */
uint8_t rename : 1; /* Is this a special rename? */
uint8_t deleted : 1; /* Has this file been deleted? */
uint8_t accurate; /* The inode is obsolete if accurate == 0. */
uint32_t dchksum; /* Checksum for the data. */
uint16_t nchksum; /* Checksum for the name. */
uint16_t chksum; /* Checksum for the raw_inode. */
};
struct jffs_file
{
struct jffs_raw_inode inode;
char *name;
unsigned char *data;
};
char *root_directory_name = NULL;
int fs_pos = 0;
int verbose = 0;
#define ENDIAN_HOST 0
#define ENDIAN_BIG 1
#define ENDIAN_LITTLE 2
int endian = ENDIAN_HOST;
static uint32_t jffs_checksum(void *data, int size);
void jffs_print_trace(const char *path, int depth);
int make_root_dir(FILE *fs, int first_ino, const char *root_dir_path,
int depth);
void write_file(struct jffs_file *f, FILE *fs, struct stat st);
void read_data(struct jffs_file *f, const char *path, int offset);
int mkfs(FILE *fs, const char *path, int ino, int parent, int depth);
static uint32_t
jffs_checksum(void *data, int size)
{
uint32_t sum = 0;
uint8_t *ptr = (uint8_t *)data;
while (size-- > 0)
{
sum += *ptr++;
}
return sum;
}
void
jffs_print_trace(const char *path, int depth)
{
int path_len = strlen(path);
int out_pos = depth * JFFS_TRACE_INDENT;
int pos = path_len - 1;
char *out = (char *)alloca(depth * JFFS_TRACE_INDENT + path_len + 1);
if (verbose >= 2)
{
fprintf(stderr, "jffs_print_trace(): path: \"%s\"\n", path);
}
if (!out) {
fprintf(stderr, "jffs_print_trace(): Allocation failed.\n");
fprintf(stderr, " path: \"%s\"\n", path);
fprintf(stderr, "depth: %d\n", depth);
exit(1);
}
memset(out, ' ', depth * JFFS_TRACE_INDENT);
if (path[pos] == '/')
{
pos--;
}
while (path[pos] && (path[pos] != '/'))
{
pos--;
}
for (pos++; path[pos] && (path[pos] != '/'); pos++)
{
out[out_pos++] = path[pos];
}
out[out_pos] = '\0';
fprintf(stderr, "%s\n", out);
}
/* Print the contents of a raw inode. */
void
jffs_print_raw_inode(struct jffs_raw_inode *raw_inode)
{
fprintf(stdout, "jffs_raw_inode: inode number: %u, version %u\n", raw_inode->ino, raw_inode->version);
fprintf(stdout, "{\n");
fprintf(stdout, " 0x%08x, /* magic */\n", raw_inode->magic);
fprintf(stdout, " 0x%08x, /* ino */\n", raw_inode->ino);
fprintf(stdout, " 0x%08x, /* pino */\n", raw_inode->pino);
fprintf(stdout, " 0x%08x, /* version */\n", raw_inode->version);
fprintf(stdout, " 0x%08x, /* mode */\n", raw_inode->mode);
fprintf(stdout, " 0x%04x, /* uid */\n", raw_inode->uid);
fprintf(stdout, " 0x%04x, /* gid */\n", raw_inode->gid);
fprintf(stdout, " 0x%08x, /* atime */\n", raw_inode->atime);
fprintf(stdout, " 0x%08x, /* mtime */\n", raw_inode->mtime);
fprintf(stdout, " 0x%08x, /* ctime */\n", raw_inode->ctime);
fprintf(stdout, " 0x%08x, /* offset */\n", raw_inode->offset);
fprintf(stdout, " 0x%08x, /* dsize */\n", raw_inode->dsize);
fprintf(stdout, " 0x%08x, /* rsize */\n", raw_inode->rsize);
fprintf(stdout, " 0x%02x, /* nsize */\n", raw_inode->nsize);
fprintf(stdout, " 0x%02x, /* nlink */\n", raw_inode->nlink);
fprintf(stdout, " 0x%02x, /* spare */\n",
raw_inode->spare);
fprintf(stdout, " %u, /* rename */\n",
raw_inode->rename);
fprintf(stdout, " %u, /* deleted */\n",
raw_inode->deleted);
fprintf(stdout, " 0x%02x, /* accurate */\n",
raw_inode->accurate);
fprintf(stdout, " 0x%08x, /* dchksum */\n", raw_inode->dchksum);
fprintf(stdout, " 0x%04x, /* nchksum */\n", raw_inode->nchksum);
fprintf(stdout, " 0x%04x, /* chksum */\n", raw_inode->chksum);
fprintf(stdout, "}\n");
}
static void write_val32(uint32_t *adr, uint32_t val)
{
switch(endian) {
case ENDIAN_HOST:
*adr = val;
break;
case ENDIAN_LITTLE:
*adr = __cpu_to_le32(val);
break;
case ENDIAN_BIG:
*adr = __cpu_to_be32(val);
break;
}
}
static void write_val16(uint16_t *adr, uint16_t val)
{
switch(endian) {
case ENDIAN_HOST:
*adr = val;
break;
case ENDIAN_LITTLE:
*adr = __cpu_to_le16(val);
break;
case ENDIAN_BIG:
*adr = __cpu_to_be16(val);
break;
}
}
static uint32_t read_val32(uint32_t *adr)
{
uint32_t val;
switch(endian) {
case ENDIAN_HOST:
val = *adr;
break;
case ENDIAN_LITTLE:
val = __le32_to_cpu(*adr);
break;
case ENDIAN_BIG:
val = __be32_to_cpu(*adr);
break;
}
return val;
}
static uint16_t read_val16(uint16_t *adr)
{
uint16_t val;
switch(endian) {
case ENDIAN_HOST:
val = *adr;
break;
case ENDIAN_LITTLE:
val = __le16_to_cpu(*adr);
break;
case ENDIAN_BIG:
val = __be16_to_cpu(*adr);
break;
}
return val;
}
int
main(int argc, char **argv)
{
int fs;
struct stat sb;
uint32_t wordbuf;
off_t pos = 0;
off_t end;
struct jffs_raw_inode ino;
unsigned char namebuf[4096];
int myino = -1;
if (argc < 2) {
printf("no filesystem given\n");
exit(1);
}
fs = open(argv[1], O_RDONLY);
if (fs < 0) {
perror("open");
exit(1);
}
if (argc > 2) {
myino = atol(argv[2]);
printf("Printing ino #%d\n" , myino);
}
if (fstat(fs, &sb) < 0) {
perror("stat");
close(fs);
exit(1);
}
end = sb.st_size;
while (pos < end) {
if (pread(fs, &wordbuf, 4, pos) < 0) {
perror("pread");
exit(1);
}
switch(wordbuf) {
case JFFS_EMPTY_BITMASK:
// printf("0xff started at 0x%lx\n", pos);
for (; pos < end && wordbuf == JFFS_EMPTY_BITMASK; pos += 4) {
if (pread(fs, &wordbuf, 4, pos) < 0) {
perror("pread");
exit(1);
}
}
if (pos < end)
pos -= 4;
// printf("0xff ended at 0x%lx\n", pos);
continue;
case JFFS_DIRTY_BITMASK:
// printf("0x00 started at 0x%lx\n", pos);
for (; pos < end && wordbuf == JFFS_DIRTY_BITMASK; pos += 4) {
if (pread(fs, &wordbuf, 4, pos) < 0) {
perror("pread");
exit(1);
}
}
if (pos < end)
pos -=4;
// printf("0x00 ended at 0x%lx\n", pos);
continue;
default:
printf("Argh. Dirty memory at 0x%lx\n", pos);
// file_hexdump(fs, pos, 128);
for (pos += 4; pos < end; pos += 4) {
if (pread(fs, &wordbuf, 4, pos) < 0) {
perror("pread");
exit(1);
}
if (wordbuf == JFFS_MAGIC_BITMASK)
break;
}
case JFFS_MAGIC_BITMASK:
if (pread(fs, &ino, sizeof(ino), pos) < 0) {
perror("pread");
exit(1);
}
if (myino == -1 || ino.ino == myino) {
printf("Magic found at 0x%lx\n", pos);
jffs_print_raw_inode(&ino);
}
pos += sizeof(ino);
if (myino == -1 || ino.ino == myino) {
if (ino.nsize) {
if (pread(fs, namebuf, min(ino.nsize, 4095), pos) < 0) {
perror("pread");
exit(1);
}
if (ino.nsize < 4095)
namebuf[ino.nsize] = 0;
else
namebuf[4095] = 0;
printf("Name: \"%s\"\n", namebuf);
} else {
printf("No Name\n");
}
}
pos += (ino.nsize + 3) & ~3;
pos += (ino.dsize + 3) & ~3;
}
}
}
View Git Blame Copy Permalink