| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| #include <stdio.h> |
| #include <string.h> |
| #include <assert.h> |
| #include <stdlib.h> |
| #include <errno.h> |
| #include "hal/hal_flash.h" |
| #include "testutil/testutil.h" |
| #include "fs/fs.h" |
| #include "nffs/nffs.h" |
| #include "nffs_test.h" |
| #include "nffs_test_priv.h" |
| #include "nffs_priv.h" |
| |
| int print_verbose; |
| |
| void |
| print_inode_entry(struct nffs_inode_entry *inode_entry, int indent) |
| { |
| struct nffs_inode inode; |
| char name[NFFS_FILENAME_MAX_LEN + 1]; |
| uint32_t area_offset; |
| uint8_t area_idx; |
| int rc; |
| |
| if (inode_entry == nffs_root_dir) { |
| printf("%*s/\n", indent, ""); |
| return; |
| } |
| |
| rc = nffs_inode_from_entry(&inode, inode_entry); |
| /* |
| * Dummy inode |
| */ |
| if (rc == FS_ENOENT) { |
| printf(" DUMMY %d\n", rc); |
| return; |
| } |
| |
| nffs_flash_loc_expand(inode_entry->nie_hash_entry.nhe_flash_loc, |
| &area_idx, &area_offset); |
| |
| |
| rc = nffs_flash_read(area_idx, |
| area_offset + sizeof (struct nffs_disk_inode), |
| name, inode.ni_filename_len); |
| |
| name[inode.ni_filename_len] = '\0'; |
| |
| printf("%*s%s %ju %jx\n", indent, "", name[0] == '\0' ? "/" : name, |
| (uintmax_t) inode.ni_seq, |
| (uintmax_t) inode.ni_inode_entry->nie_flags); |
| } |
| |
| void |
| process_inode_entry(struct nffs_inode_entry *inode_entry, int indent) |
| { |
| struct nffs_inode_entry *child; |
| |
| print_inode_entry(inode_entry, indent); |
| |
| if (nffs_hash_id_is_dir(inode_entry->nie_hash_entry.nhe_id)) { |
| SLIST_FOREACH(child, &inode_entry->nie_child_list, nie_sibling_next) { |
| process_inode_entry(child, indent + 2); |
| } |
| } |
| } |
| |
| int |
| print_nffs_flash_inode(struct nffs_area *area, uint32_t off) |
| { |
| struct nffs_disk_inode ndi; |
| char filename[128]; |
| int len; |
| int rc; |
| |
| rc = hal_flash_read(area->na_flash_id, area->na_offset + off, |
| &ndi, sizeof(ndi)); |
| assert(rc == 0); |
| |
| memset(filename, 0, sizeof(filename)); |
| len = min(sizeof(filename) - 1, ndi.ndi_filename_len); |
| rc = hal_flash_read(area->na_flash_id, area->na_offset + off + sizeof(ndi), |
| filename, len); |
| |
| printf(" off %jx %s id %jx flen %ju seq %ju last %jx prnt %jx " |
| "flgs %jx %s\n", |
| (uintmax_t) off, |
| (nffs_hash_id_is_file(ndi.ndi_id) ? "File" : |
| (nffs_hash_id_is_dir(ndi.ndi_id) ? "Dir" : "???")), |
| (uintmax_t) ndi.ndi_id, |
| (uintmax_t) ndi.ndi_filename_len, |
| (uintmax_t) ndi.ndi_seq, |
| (uintmax_t) ndi.ndi_lastblock_id, |
| (uintmax_t) ndi.ndi_parent_id, |
| (uintmax_t) ndi.ndi_flags, |
| filename); |
| return sizeof(ndi) + ndi.ndi_filename_len; |
| } |
| |
| int |
| print_nffs_flash_block(struct nffs_area *area, uint32_t off) |
| { |
| struct nffs_disk_block ndb; |
| int rc; |
| |
| rc = hal_flash_read(area->na_flash_id, area->na_offset + off, |
| &ndb, sizeof(ndb)); |
| assert(rc == 0); |
| |
| printf(" off %jx Block id %jx len %ju seq %ju prev %jx own ino %jx\n", |
| (uintmax_t) off, |
| (uintmax_t) ndb.ndb_id, |
| (uintmax_t) ndb.ndb_data_len, |
| (uintmax_t) ndb.ndb_seq, |
| (uintmax_t) ndb.ndb_prev_id, |
| (uintmax_t) ndb.ndb_inode_id); |
| return sizeof(ndb) + ndb.ndb_data_len; |
| } |
| |
| int |
| print_nffs_flash_object(struct nffs_area *area, uint32_t off) |
| { |
| struct nffs_disk_object ndo; |
| |
| hal_flash_read(area->na_flash_id, area->na_offset + off, |
| &ndo.ndo_un_obj, sizeof(ndo.ndo_un_obj)); |
| |
| if (nffs_hash_id_is_inode(ndo.ndo_disk_inode.ndi_id)) { |
| return print_nffs_flash_inode(area, off); |
| |
| } else if (nffs_hash_id_is_block(ndo.ndo_disk_block.ndb_id)) { |
| return print_nffs_flash_block(area, off); |
| |
| } else if (ndo.ndo_disk_block.ndb_id == 0xffffffff) { |
| return area->na_length; |
| |
| } else { |
| return 1; |
| } |
| } |
| |
| void |
| print_nffs_flash_areas(int verbose) |
| { |
| struct nffs_area area; |
| struct nffs_disk_area darea; |
| int off; |
| int i; |
| |
| for (i = 0; nffs_current_area_descs[i].nad_length != 0; i++) { |
| if (i > NFFS_MAX_AREAS) { |
| return; |
| } |
| area.na_offset = nffs_current_area_descs[i].nad_offset; |
| area.na_length = nffs_current_area_descs[i].nad_length; |
| area.na_flash_id = nffs_current_area_descs[i].nad_flash_id; |
| hal_flash_read(area.na_flash_id, area.na_offset, &darea, sizeof(darea)); |
| area.na_id = darea.nda_id; |
| area.na_cur = nffs_areas[i].na_cur; |
| if (!nffs_area_magic_is_set(&darea)) { |
| printf("Area header corrupt!\n"); |
| } |
| printf("area %d: id %ju %jx-%jx cur %jx len %ju flashid %jx " |
| "gc-seq %jd %s%s\n", |
| i, |
| (uintmax_t)area.na_id, |
| (uintmax_t)area.na_offset, |
| (uintmax_t)area.na_offset + area.na_length, |
| (uintmax_t)area.na_cur, |
| (uintmax_t)area.na_length, |
| (uintmax_t)area.na_flash_id, |
| (uintmax_t)darea.nda_gc_seq, |
| nffs_scratch_area_idx == i ? "(scratch)" : "", |
| !nffs_area_magic_is_set(&darea) ? "corrupt" : ""); |
| if (verbose < 2) { |
| off = sizeof (struct nffs_disk_area); |
| while (off < area.na_length) { |
| off += print_nffs_flash_object(&area, off); |
| } |
| } |
| } |
| } |
| |
| static int |
| nffs_hash_fn(uint32_t id) |
| { |
| return id % NFFS_HASH_SIZE; |
| } |
| |
| void |
| print_hashlist(struct nffs_hash_entry *he) |
| { |
| struct nffs_hash_list *list; |
| int idx = nffs_hash_fn(he->nhe_id); |
| list = nffs_hash + idx; |
| |
| SLIST_FOREACH(he, list, nhe_next) { |
| printf("hash_entry %s %p: id 0x%jx flash_loc 0x%jx next %p\n", |
| nffs_hash_id_is_inode(he->nhe_id) ? "inode" : "block", |
| he, |
| (uintmax_t)he->nhe_id, |
| (uintmax_t)he->nhe_flash_loc, |
| he->nhe_next.sle_next); |
| } |
| } |
| |
| void |
| print_hash(void) |
| { |
| int i; |
| struct nffs_hash_entry *he; |
| struct nffs_hash_entry *next; |
| struct nffs_inode ni; |
| struct nffs_disk_inode di; |
| struct nffs_block nb; |
| struct nffs_disk_block db; |
| uint32_t area_offset; |
| uint8_t area_idx; |
| int rc; |
| |
| NFFS_HASH_FOREACH(he, i, next) { |
| if (nffs_hash_id_is_inode(he->nhe_id)) { |
| printf("hash_entry inode %d %p: id 0x%jx flash_loc 0x%jx " |
| "next %p\n", |
| i, |
| he, |
| (uintmax_t)he->nhe_id, |
| (uintmax_t)he->nhe_flash_loc, |
| he->nhe_next.sle_next); |
| if (he->nhe_id == NFFS_ID_ROOT_DIR) { |
| continue; |
| } |
| nffs_flash_loc_expand(he->nhe_flash_loc, |
| &area_idx, &area_offset); |
| rc = nffs_inode_read_disk(area_idx, area_offset, &di); |
| if (rc) { |
| printf("%d: fail inode read id 0x%jx rc %d\n", |
| i, (uintmax_t)he->nhe_id, rc); |
| } |
| printf(" Disk inode: id %jx seq %ju parent %jx last %jx " |
| "flgs %jx\n", |
| (uintmax_t)di.ndi_id, |
| (uintmax_t)di.ndi_seq, |
| (uintmax_t)di.ndi_parent_id, |
| (uintmax_t)di.ndi_lastblock_id, |
| (uintmax_t)di.ndi_flags); |
| ni.ni_inode_entry = (struct nffs_inode_entry *)he; |
| ni.ni_seq = di.ndi_seq; |
| ni.ni_parent = nffs_hash_find_inode(di.ndi_parent_id); |
| printf(" RAM inode: entry %p seq %ju parent %p " |
| "filename %s\n", |
| ni.ni_inode_entry, |
| (uintmax_t)ni.ni_seq, |
| ni.ni_parent, |
| ni.ni_filename); |
| |
| } else if (nffs_hash_id_is_block(he->nhe_id)) { |
| printf("hash_entry block %d %p: id 0x%jx flash_loc 0x%jx " |
| "next %p\n", |
| i, |
| he, |
| (uintmax_t)he->nhe_id, |
| (uintmax_t)he->nhe_flash_loc, |
| he->nhe_next.sle_next); |
| rc = nffs_block_from_hash_entry(&nb, he); |
| if (rc) { |
| printf("%d: fail block read id 0x%jx rc %d\n", |
| i, (uintmax_t)he->nhe_id, rc); |
| } |
| printf(" block: id %jx seq %ju inode %jx prev %jx\n", |
| (uintmax_t)nb.nb_hash_entry->nhe_id, |
| (uintmax_t)nb.nb_seq, |
| (uintmax_t)nb.nb_inode_entry->nie_hash_entry.nhe_id, |
| (uintmax_t)nb.nb_prev->nhe_id); |
| nffs_flash_loc_expand(nb.nb_hash_entry->nhe_flash_loc, |
| &area_idx, &area_offset); |
| rc = nffs_block_read_disk(area_idx, area_offset, &db); |
| if (rc) { |
| printf("%d: fail disk block read id 0x%jx rc %d\n", |
| i, (uintmax_t)nb.nb_hash_entry->nhe_id, rc); |
| } |
| printf(" disk block: id %jx seq %ju inode %jx prev %jx " |
| "len %ju\n", |
| (uintmax_t)db.ndb_id, |
| (uintmax_t)db.ndb_seq, |
| (uintmax_t)db.ndb_inode_id, |
| (uintmax_t)db.ndb_prev_id, |
| (uintmax_t)db.ndb_data_len); |
| } else { |
| printf("hash_entry UNKNONN %d %p: id 0x%jx flash_loc 0x%jx " |
| "next %p\n", |
| i, |
| he, |
| (uintmax_t)he->nhe_id, |
| (uintmax_t)he->nhe_flash_loc, |
| he->nhe_next.sle_next); |
| } |
| } |
| |
| } |
| |
| void |
| nffs_print_object(struct nffs_disk_object *dobj) |
| { |
| struct nffs_disk_inode *di = &dobj->ndo_disk_inode; |
| struct nffs_disk_block *db = &dobj->ndo_disk_block; |
| |
| if (dobj->ndo_type == NFFS_OBJECT_TYPE_INODE) { |
| printf(" %s id %jx seq %ju prnt %jx last %jx\n", |
| nffs_hash_id_is_file(di->ndi_id) ? "File" : |
| nffs_hash_id_is_dir(di->ndi_id) ? "Dir" : "???", |
| (uintmax_t)di->ndi_id, |
| (uintmax_t)di->ndi_seq, |
| (uintmax_t)di->ndi_parent_id, |
| (uintmax_t)di->ndi_lastblock_id); |
| } else if (dobj->ndo_type != NFFS_OBJECT_TYPE_BLOCK) { |
| printf(" %s: id %jx seq %ju ino %jx prev %jx len %ju\n", |
| nffs_hash_id_is_block(db->ndb_id) ? "Block" : "Block?", |
| (uintmax_t)db->ndb_id, |
| (uintmax_t)db->ndb_seq, |
| (uintmax_t)db->ndb_inode_id, |
| (uintmax_t)db->ndb_prev_id, |
| (uintmax_t)db->ndb_data_len); |
| } |
| } |
| |
| void |
| print_nffs_hash_block(struct nffs_hash_entry *he, int verbose) |
| { |
| struct nffs_block nb = { 0 }; |
| struct nffs_disk_block db = { 0 }; |
| uint32_t area_offset = 0; |
| uint8_t area_idx = 0; |
| int rc; |
| |
| if (he == NULL) { |
| return; |
| } |
| if (!nffs_hash_entry_is_dummy(he)) { |
| nffs_flash_loc_expand(he->nhe_flash_loc, |
| &area_idx, &area_offset); |
| rc = nffs_block_read_disk(area_idx, area_offset, &db); |
| if (rc) { |
| printf("%p: fail block read id 0x%jx rc %d\n", |
| he, (uintmax_t)he->nhe_id, rc); |
| |
| } |
| nb.nb_hash_entry = he; |
| nb.nb_seq = db.ndb_seq; |
| if (db.ndb_inode_id != NFFS_ID_NONE) { |
| nb.nb_inode_entry = nffs_hash_find_inode(db.ndb_inode_id); |
| } else { |
| nb.nb_inode_entry = (void*)db.ndb_inode_id; |
| } |
| if (db.ndb_prev_id != NFFS_ID_NONE) { |
| nb.nb_prev = nffs_hash_find_block(db.ndb_prev_id); |
| } else { |
| nb.nb_prev = (void*)db.ndb_prev_id; |
| } |
| nb.nb_data_len = db.ndb_data_len; |
| } |
| if (!verbose) { |
| printf("%s%s id %jx idx/off %ju/%jx seq %ju ino %jx prev %jx " |
| "len %ju\n", |
| nffs_hash_entry_is_dummy(he) ? "Dummy " : "", |
| nffs_hash_id_is_block(he->nhe_id) ? "Block" : "Unknown", |
| (uintmax_t)he->nhe_id, |
| (uintmax_t)area_idx, |
| (uintmax_t)area_offset, |
| (uintmax_t)nb.nb_seq, |
| (uintmax_t)(nb.nb_inode_entry ? nb.nb_inode_entry->nie_hash_entry.nhe_id : 0), |
| (uintmax_t)db.ndb_prev_id, |
| (uintmax_t)db.ndb_data_len); |
| return; |
| } |
| printf("%s%s id %jx loc %jx/%jx %jx ent %p\n", |
| nffs_hash_entry_is_dummy(he) ? "Dummy " : "", |
| nffs_hash_id_is_block(he->nhe_id) ? "Block:" : "Unknown:", |
| (uintmax_t)he->nhe_id, |
| (uintmax_t)area_idx, |
| (uintmax_t)area_offset, |
| (uintmax_t)he->nhe_flash_loc, |
| he); |
| if (nb.nb_inode_entry) { |
| printf(" Ram: ent %p seq %ju ino %p prev %p len %ju\n", |
| nb.nb_hash_entry, |
| (uintmax_t)nb.nb_seq, |
| nb.nb_inode_entry, |
| nb.nb_prev, |
| (uintmax_t)nb.nb_data_len); |
| } |
| if (db.ndb_id) { |
| printf(" Disk %s id %jx seq %ju ino %jx prev %jx len %ju\n", |
| nffs_hash_id_is_block(db.ndb_id) ? "Block:" : "???:", |
| (uintmax_t)db.ndb_id, |
| (uintmax_t)db.ndb_seq, |
| (uintmax_t)db.ndb_inode_id, |
| (uintmax_t)db.ndb_prev_id, |
| (uintmax_t)db.ndb_data_len); |
| } |
| } |
| |
| void |
| print_nffs_hash_inode(struct nffs_hash_entry *he, int verbose) |
| { |
| struct nffs_inode ni = { 0 }; |
| struct nffs_disk_inode di = { 0 }; |
| struct nffs_inode_entry *nie = (struct nffs_inode_entry*)he; |
| int cached_name_len; |
| uint32_t area_offset = 0; |
| uint8_t area_idx = 0; |
| int rc = 0; |
| |
| if (he == NULL) { |
| return; |
| } |
| if (!nffs_hash_entry_is_dummy(he)) { |
| nffs_flash_loc_expand(he->nhe_flash_loc, |
| &area_idx, &area_offset); |
| rc = nffs_inode_read_disk(area_idx, area_offset, &di); |
| if (rc) { |
| printf("Entry %p: fail inode read id 0x%jx rc %d\n", |
| he, (uintmax_t)he->nhe_id, rc); |
| } |
| ni.ni_inode_entry = (struct nffs_inode_entry *)he; |
| ni.ni_seq = di.ndi_seq; |
| if (di.ndi_parent_id != NFFS_ID_NONE) { |
| ni.ni_parent = nffs_hash_find_inode(di.ndi_parent_id); |
| } else { |
| ni.ni_parent = NULL; |
| } |
| if (ni.ni_filename_len > NFFS_SHORT_FILENAME_LEN) { |
| cached_name_len = NFFS_SHORT_FILENAME_LEN; |
| } else { |
| cached_name_len = ni.ni_filename_len; |
| } |
| if (cached_name_len != 0) { |
| rc = nffs_flash_read(area_idx, area_offset + sizeof di, |
| ni.ni_filename, cached_name_len); |
| if (rc != 0) { |
| printf("entry %p: fail filename read id 0x%jx rc %d\n", |
| he, (uintmax_t)he->nhe_id, rc); |
| return; |
| } |
| } |
| } |
| if (!verbose) { |
| printf("%s%s id %jx idx/off %jx/%jx seq %ju prnt %jx last %jx " |
| "flags %jx", |
| nffs_hash_entry_is_dummy(he) ? "Dummy " : "", |
| nffs_hash_id_is_file(he->nhe_id) ? "File" : |
| he->nhe_id == NFFS_ID_ROOT_DIR ? "**ROOT Dir" : |
| nffs_hash_id_is_dir(he->nhe_id) ? "Dir" : "Inode", |
| |
| (uintmax_t)he->nhe_id, |
| (uintmax_t)area_idx, |
| (uintmax_t)area_offset, |
| (uintmax_t)ni.ni_seq, |
| (uintmax_t)di.ndi_parent_id, |
| (uintmax_t)di.ndi_lastblock_id, |
| (uintmax_t)nie->nie_flags); |
| if (ni.ni_inode_entry) { |
| printf(" ref %ju\n", (uintmax_t)ni.ni_inode_entry->nie_refcnt); |
| } else { |
| printf("\n"); |
| } |
| return; |
| } |
| printf("%s%s id %jx loc %jx/%jx %jx entry %p\n", |
| nffs_hash_entry_is_dummy(he) ? "Dummy " : "", |
| nffs_hash_id_is_file(he->nhe_id) ? "File:" : |
| he->nhe_id == NFFS_ID_ROOT_DIR ? "**ROOT Dir:" : |
| nffs_hash_id_is_dir(he->nhe_id) ? "Dir:" : "Inode:", |
| (uintmax_t)he->nhe_id, |
| (uintmax_t)area_idx, |
| (uintmax_t)area_offset, |
| (uintmax_t)he->nhe_flash_loc, |
| he); |
| if (ni.ni_inode_entry) { |
| printf(" ram: ent %p seq %ju prnt %p lst %p ref %ju flgs %jx nm %s\n", |
| ni.ni_inode_entry, |
| (uintmax_t)ni.ni_seq, |
| ni.ni_parent, |
| ni.ni_inode_entry->nie_last_block_entry, |
| (uintmax_t)ni.ni_inode_entry->nie_refcnt, |
| (uintmax_t)ni.ni_inode_entry->nie_flags, |
| ni.ni_filename); |
| } |
| if (rc == 0) { |
| printf(" Disk %s: id %jx seq %ju prnt %jx lst %jx flgs %jx\n", |
| nffs_hash_id_is_file(di.ndi_id) ? "File" : |
| nffs_hash_id_is_dir(di.ndi_id) ? "Dir" : "???", |
| (uintmax_t)di.ndi_id, |
| (uintmax_t)di.ndi_seq, |
| (uintmax_t)di.ndi_parent_id, |
| (uintmax_t)di.ndi_lastblock_id, |
| (uintmax_t)di.ndi_flags); |
| } |
| } |
| |
| void |
| print_hash_entries(int verbose) |
| { |
| int i; |
| struct nffs_hash_entry *he; |
| struct nffs_hash_entry *next; |
| |
| printf("\nnffs_hash_entries:\n"); |
| for (i = 0; i < NFFS_HASH_SIZE; i++) { |
| he = SLIST_FIRST(nffs_hash + i); |
| while (he != NULL) { |
| next = SLIST_NEXT(he, nhe_next); |
| if (nffs_hash_id_is_inode(he->nhe_id)) { |
| print_nffs_hash_inode(he, verbose); |
| } else if (nffs_hash_id_is_block(he->nhe_id)) { |
| print_nffs_hash_block(he, verbose); |
| } else { |
| printf("UNKNOWN type hash entry %d: id 0x%jx loc 0x%jx\n", |
| i, |
| (uintmax_t)he->nhe_id, |
| (uintmax_t)he->nhe_flash_loc); |
| } |
| he = next; |
| } |
| } |
| } |
| |
| void |
| print_nffs_hashlist(int verbose) |
| { |
| struct nffs_hash_entry *he; |
| struct nffs_hash_entry *next; |
| int i; |
| |
| NFFS_HASH_FOREACH(he, i, next) { |
| if (nffs_hash_id_is_inode(he->nhe_id)) { |
| print_nffs_hash_inode(he, verbose); |
| } else if (nffs_hash_id_is_block(he->nhe_id)) { |
| print_nffs_hash_block(he, verbose); |
| } else { |
| printf("UNKNOWN type hash entry %d: id 0x%jx loc 0x%jx\n", |
| i, |
| (uintmax_t)he->nhe_id, |
| (uintmax_t)he->nhe_flash_loc); |
| } |
| } |
| } |
| |
| void |
| printfs() |
| { |
| if (nffs_misc_ready()) { |
| printf("NFFS directory:\n"); |
| process_inode_entry(nffs_root_dir, print_verbose); |
| |
| printf("\nNFFS hash list:\n"); |
| print_nffs_hashlist(print_verbose); |
| } |
| printf("\nNFFS flash areas:\n"); |
| print_nffs_flash_areas(print_verbose); |
| } |
